Retain request dependencies only when discovery supplies the answer

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

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

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

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

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

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

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

Cargo.toml

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

TODO

@@ -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

@@ -15,7 +15,7 @@
 //! reuse, size, placement, and text events for one suspicious widget. The
 //! selection is a set and survives [`take`] until cleared.
 
-use crate::{Axis, LayoutLen, PxVec2, Size, UiRegion, WidgetId};
+use crate::{Axis, LayoutHolds, LayoutLen, PxVec2, Size, UiRegion, UiVec2, WidgetId};
 use std::{
     cell::RefCell,
     collections::{HashMap, HashSet},
@@ -23,100 +23,71 @@ use std::{
     time::Instant,
 };
 
+/// 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,)*];
+        }
+    };
+}
+
+labelled! {
     pub(crate) enum Counter {
-    Updates,
+        Updates = "updates",
-    DrawRequests,
+        DrawRequests = "draw requests",
-    WidgetDraws,
+        WidgetDraws = "widget draws",
-    RegionNodeDraws,
+        RegionNodeDraws = "region-node draws",
-    SizeReads,
+        SizeReads = "draw-result size reads",
-    HintHits,
+        HintHits = "hint hits",
-    HintMisses,
+        HintMisses = "hint misses",
-    ReuseAttempts,
+        ReuseAttempts = "reuse attempts",
-    ReuseExact,
+        ReuseExact = "reuse exact",
-    ReuseMoved,
+        ReuseMoved = "reuse moved",
-    ReuseDirty,
+        ReuseDirty = "reuse: dirty",
-    ReuseWrongParent,
+        ReuseUndrawn = "reuse: nothing drawn to keep",
-    ReuseRemapped,
+        ReuseWrongParent = "reuse: wrong parent",
-    ReuseOutside,
+        ReuseRemapped = "reuse remapped",
-    ReuseWrongLayer,
+        ReuseOutside = "reuse: outside what it holds for",
-    ReuseWrongNode,
+        ReuseWrongLayer = "reuse: another layer",
-    QueuePops,
+        ReuseWrongNode = "reuse: region-node choice changed",
-    DepthReads,
+        ReuseWrongMask = "reuse: a different inherited mask",
-    LocalRedraws,
+        QueuePops = "redraw queue pops",
-    SizeChanges,
+        DepthReads = "depth reads",
-    ReaderEdges,
+        LocalRedraws = "local redraws",
-    PrimitiveWrites,
+        SizeChanges = "size changes",
-    TextRenders,
+        ReaderEdges = "reader edges",
-    TextShapeHits,
+        PrimitiveWrites = "primitive writes",
-    TextShapes,
+        TextRenders = "text renders",
-    TextBreaks,
+        TextShapeHits = "text shape hits",
-    GlyphPlacements,
+        TextShapes = "text shapes",
-    OutsidePinnedLen,
+        TextBreaks = "text line breaks",
-    OutsideRelBase,
+        GlyphPlacements = "glyph placements",
-    OutsideRegion,
+        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",
+    }
 }
 
-impl Counter {
+labelled! {
-    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",
-    ];
-}
-
-#[derive(Clone, Copy)]
     pub(crate) enum TimerKind {
-    Update,
+        Update = "update total",
-    FullLayout,
+        FullLayout = "full layout",
-    IncrementalLayout,
+        IncrementalLayout = "incremental layout",
-    TextRender,
+        TextRender = "text render",
-    TextShape,
+        TextShape = "text shape",
-    TextBreak,
+        TextBreak = "text line break",
-    GlyphPlacement,
+        GlyphPlacement = "glyph placement",
     }
-
-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",
-    ];
 }
 
 #[derive(Clone)]
@@ -251,6 +222,8 @@ pub enum ReuseOutcome {
     Dirty,
     WrongParent,
     WrongLayer,
+    WrongMask,
+    WrongNode,
     Remapped,
     Outside,
     Undrawn,
@@ -264,7 +237,7 @@ pub enum TraceEvent {
         id: WidgetId,
         parent: Option<WidgetId>,
         region: UiRegion,
-        pixel_size: PxVec2,
+        region_px: PxVec2,
         region_node: bool,
     },
     Reuse {
@@ -360,7 +333,7 @@ pub(crate) fn draw_request(
     id: WidgetId,
     parent: Option<WidgetId>,
     region: UiRegion,
-    pixel_size: PxVec2,
+    region_px: PxVec2,
     region_node: bool,
 ) {
     trace(
@@ -369,7 +342,7 @@ pub(crate) fn draw_request(
             id,
             parent,
             region,
-            pixel_size,
+            region_px,
             region_node,
         },
     );
@@ -379,6 +352,41 @@ pub(crate) fn reuse(id: WidgetId, outcome: ReuseOutcome) {
     trace(id, TraceEvent::Reuse { id, outcome });
 }
 
+/// A drawing that cannot be reused because the box on offer is outside what
+/// it holds for, and which of the four contracts said so. They overlap: a
+/// drawing can be outside two of them at once, and counting each is what
+/// says where a rel base redrawing more than it should is coming from.
+pub(crate) fn outside(
+    id: WidgetId,
+    holds: LayoutHolds,
+    region: UiRegion,
+    rel_base: UiVec2,
+    window: PxVec2,
+) {
+    for axis in Axis::BOTH {
+        let holds = holds[axis];
+        let len = region[axis].len();
+        let window = window[axis];
+        if holds.region_len.is_some_and(|pinned| pinned != len) {
+            bump(Counter::OutsidePinnedLen);
+        }
+        if !holds.window.contains(window) {
+            bump(Counter::OutsideWindow);
+        }
+        if holds
+            .rel_base
+            .is_some_and(|pinned| pinned != rel_base[axis])
+        {
+            bump(Counter::OutsideRelBase);
+        }
+        if !holds.region.contains(len.to_px(window)) {
+            bump(Counter::OutsideRegion);
+        }
+    }
+    bump(Counter::ReuseOutside);
+    reuse(id, ReuseOutcome::Outside);
+}
+
 pub(crate) fn size_reported(id: WidgetId, size: Size) {
     trace(id, TraceEvent::SizeReported { id, size });
 }

core/src/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))),
+            start: at - self.scale(rel),
-            end: Len::from_parts(at.rel.add(self.rel.mul(rest)), at.px.add(self.px.mul(rest))),
+            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

@@ -9,14 +9,8 @@ pub enum Axis {
 }
 
 impl Axis {
-    /// A per-axis pair with `aligned` on this axis and `ortho` on the other,
+    /// Both of them, for the layout code that asks the same question of each.
-    /// which is what `from_axis` does for a vector.
+    pub const BOTH: [Self; 2] = [Self::X, Self::Y];
-    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 {
@@ -77,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

@@ -23,6 +23,14 @@ pub struct LayoutLen {
     pub leftover: Weight,
 }
 
+/// A bare number is pixels, which is the one length that needs no box to be
+/// read in.
+impl<N: UiNum> From<N> for Len {
+    fn from(value: N) -> Self {
+        Len::px(value.to_f32())
+    }
+}
+
 impl<N: UiNum> From<N> for LayoutLen {
     fn from(value: N) -> Self {
         LayoutLen::px(value.to_f32())
@@ -148,20 +156,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 +177,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

@@ -163,14 +163,6 @@ impl Len {
         Self::from_parts(Rel::ZERO, Px::from_f32(px))
     }
 
-    pub const fn rel_min() -> Self {
-        Self::ZERO
-    }
-
-    pub const fn rel_max() -> Self {
-        Self::FULL
-    }
-
     pub const fn max(&self, other: Self) -> Self {
         Self {
             rel: self.rel.max(other.rel),
@@ -213,10 +205,6 @@ impl Len {
         })
     }
 
-    pub fn select_len(&self, len: Len) -> Self {
-        len.within_len(*self)
-    }
-
     pub const fn flip(&mut self) {
         self.rel = Rel::ONE.sub(self.rel);
         self.px = self.px.neg();
@@ -293,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)]
@@ -312,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
+    // Every number both sides count in, written once here rather than a
-    // a second copy of them written into the shader: a grid the two disagree
+    // second time in the shader: a grid the two disagree about puts every
-    // about puts every coordinate somewhere else.
+    // 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:
+// `PX_STEP`, `REL_STEP`, `MASK_NONE`, `MOVE_NONE` and `CHAIN_LIMIT` are
-// what it stores is a whole count of each, both powers of two, so decoding
+// prepended from `iris_core`'s own constants, so none of them is written
-// is exact and the number here is the number the CPU decided.
+// 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

@@ -1,6 +1,6 @@
 use crate::{
-    Declared, LayerId, LayoutHolds, MaskIdx, MoveIdx, PlaceDesc, RegionAlign, RetainedPrimitive,
+    Bounds, Declared, LayerId, LayoutHolds, MaskIdx, MoveIdx, PlaceDesc, RegionAlign,
-    Size, TextureHandle, UiRegion, UiVec2, WidgetId,
+    RetainedPrimitive, Size, TextureHandle, UiRegion, UiVec2, WidgetId,
 };
 
 /// What is kept of a widget its parent has asked about. `drawn` says whether
@@ -27,7 +27,7 @@ pub struct ActiveData {
     pub region: UiRegion,
     /// The measured answer and its dependencies. A hint-only dependency or
     /// a widget first encountered during placement has no measurement yet.
-    pub answer: Option<(Size, LayoutHolds)>,
+    pub answer: Option<Answer>,
     /// Asked more than once in its parent's last draw -- measured in one box
     /// and then asked in the one the parent decided. The parent's layout
     /// rests on the first answer and its drawing on the last, so only the
@@ -51,8 +51,8 @@ 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 request_deps: Vec<WidgetId>,
-    pub size_deps: Vec<WidgetId>,
+    pub(crate) scratch: DrawScratch,
     /// The movable region its primitives are positioned through: its own when
     /// opted in, otherwise the nearest ancestor's.
     pub move_idx: MoveIdx,
@@ -60,6 +60,10 @@ pub struct ActiveData {
     /// A change to one moves a box this widget cannot fix by drawing again,
     /// and comparing them is what says so.
     pub declared: Declared,
+    /// Its bounds, resolved the same way. The answer is held to these where
+    /// the box was not, so a change to one changes what it answers even
+    /// where its declared lengths stand.
+    pub bounds: Bounds,
     /// Its alignment when it was last drawn, which a change to the property
     /// is found against.
     pub own_align: RegionAlign,
@@ -82,6 +86,29 @@ impl ActiveData {
     /// all. Not `size`, which is what its last drawing reported: a drawing
     /// re-expressed in the box that answer chose is not a second answer.
     pub fn measured(&self) -> Option<Size> {
-        self.answer.map(|(size, _)| size)
+        self.answer.map(|answer| answer.size)
+    }
+
+    /// Whether it owns a region node rather than sharing the one it was drawn
+    /// under, which is what its two move indices being different says.
+    pub fn is_region_node(&self) -> bool {
+        self.move_idx != self.parent_move
     }
 }
+
+/// What a widget answered when it was asked: the size it reported, and the
+/// boxes and windows that answer holds for.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct Answer {
+    pub size: Size,
+    pub holds: LayoutHolds,
+}
+
+#[derive(Debug, Default)]
+pub(crate) struct DrawScratch {
+    pub children: Vec<WidgetId>,
+    pub size_deps: Vec<WidgetId>,
+    pub under: Vec<(WidgetId, LayoutHolds)>,
+    pub requests: Vec<crate::RequestedLen>,
+    pub lengths: Vec<crate::Px>,
+}

core/src/ui/holds.rs

@@ -1,4 +1,4 @@
-use crate::{Len, Px, REL_SHIFT, fixed::div_toward, fixed::narrow};
+use crate::{Bound, Len, Outside, Px, REL_SHIFT, fixed::div_toward, fixed::narrow};
 use std::ops::RangeInclusive;
 
 /// The lengths of a box, in pixels, that one drawing of a widget holds for:
@@ -19,6 +19,64 @@ 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 Bound {
+    /// Which end of this bound `len` falls outside, and the windows that
+    /// answer holds for. Nothing where it is inside, which is the answer
+    /// wherever there is no bound at all.
+    ///
+    /// `len` and this bound are lengths of the same thing, whichever that
+    /// is: a box in window lengths wants the bound resolved, and a length a
+    /// widget declares of its rel base wants it as the rule wrote it. Both
+    /// comparisons are in pixels, so each is a question about this window,
+    /// and the box is decided again on the other side of a crossing.
+    pub fn outside(&self, len: Len, window: Px) -> (Option<Outside>, Holds) {
+        let mut outside = None;
+        let mut holds = Holds::ANY;
+        let mut held = len;
+        if let Some(min) = self.min {
+            let (shorter, kept) = min.longer_than(held, window);
+            holds = holds.and(kept);
+            if shorter {
+                outside = Some(Outside::Shorter);
+                held = min;
+            }
+        }
+        if let Some(max) = self.max {
+            let (longer, kept) = held.longer_than(max, window);
+            holds = holds.and(kept);
+            if longer {
+                debug_assert!(
+                    outside.is_none(),
+                    "a floor of {:?} over a cap of {max:?} bounds nothing",
+                    self.min,
+                );
+                outside = Some(Outside::Longer);
+            }
+        }
+        (outside, holds)
+    }
+}
+
 impl Holds {
     pub const ANY: Self = Self {
         lo: Px::MIN,
@@ -35,11 +93,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 +115,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

@@ -1,8 +1,6 @@
 use crate::util::impl_axis_index;
 use crate::{Axis, Holds, Len, Px, PxVec2, UiRegion, UiVec2};
 
-const AXES: [Axis; 2] = [Axis::X, Axis::Y];
-
 /// What one evaluation of a widget depends on along one axis: the window
 /// lengths its reads hold for, the pixel lengths of its own box, and the
 /// symbolic lengths of that box and of its rel base where either one is what
@@ -36,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!(
@@ -55,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
@@ -66,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))
@@ -89,19 +87,20 @@ 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 {
-        AXES.into_iter()
+        Axis::BOTH
+            .into_iter()
             .all(|axis| self[axis].contains(window[axis], rel_base[axis], region[axis].len()))
     }
 }

core/src/ui/mod.rs

@@ -20,7 +20,7 @@ pub use active::*;
 pub use holds::*;
 pub use layout_holds::*;
 pub use painter::{Painter, PrimitiveLike};
-pub use place::*;
+pub use place::{PlaceDesc, PlaceDescAxis, PlaceFit, RetainedPrimitive};
 pub use render_state::*;
 
 #[derive(Default)]

core/src/ui/painter.rs

@@ -1,16 +1,19 @@
 #[cfg(feature = "layout-diagnostics")]
 use crate::layout_diagnostics::{self as diag, Counter};
 use crate::{
-    Axis, Declared, Holds, LayoutHolds, LayoutLen, Len, PlaceDesc, Px, PxVec2, RegionAlign, Rel,
+    Axis, Bounds, Declared, Holds, LayoutHolds, LayoutLen, Len, PlaceDesc, Px, PxVec2, RegionAlign,
-    RenderedText, RetainedPrimitive, Size, StrongWidget, TextAttrs, TextBuffer, TextData,
+    Rel, RenderedText, RequestArena, RequestedLen, RetainedPrimitive, Size, SizeRequests,
-    TextureHandle, UiRegion, UiRenderState, UiRsc, UiVec2, Weight, WidgetId, Widgets,
+    StrongWidget, TextAttrs, TextBuffer, TextureHandle, UiRegion, UiRenderState, UiRsc, UiVec2,
+    Weight, WidgetId, Widgets,
     render::{
         GlyphPrimitive, Mask, MaskIdx, MoveIdx, Primitive, PrimitiveInst, PrimitiveKind,
         TexturePrimitive,
     },
-    ui::render_state::{DrawInfo, Placing},
+    ui::{
+        place::{PlaceSpan, RelBase},
+        render_state::{DrawInfo, Placing},
+    },
 };
-const AXES: [Axis; 2] = [Axis::X, Axis::Y];
 
 /// makes your surfaces look pretty
 pub struct Painter<'a> {
@@ -39,6 +42,8 @@ pub struct Painter<'a> {
     pub(super) children: Vec<WidgetId>,
     /// The children whose size this widget read while drawing.
     pub(super) size_deps: Vec<WidgetId>,
+    pub(super) request_deps: Vec<WidgetId>,
+    pub(super) scratch: crate::DrawScratch,
     /// What this draw itself reads, as against what its children's drawings
     /// hold for: every window and every length of its own region until it
     /// reads one, then that one unless it says otherwise, and the rel base or
@@ -60,6 +65,126 @@ pub struct Painter<'a> {
 }
 
 impl<'a> Painter<'a> {
+    /// Reuses this widget's allocation buffers across draws. Nested painters
+    /// have independent buffers, so discovering a child cannot overwrite them.
+    pub fn with_requests<T>(
+        &mut self,
+        f: impl FnOnce(&mut Self, &mut Vec<RequestedLen>, &mut Vec<Px>) -> T,
+    ) -> T {
+        let mut requests = std::mem::take(&mut self.scratch.requests);
+        let mut lengths = std::mem::take(&mut self.scratch.lengths);
+        requests.clear();
+        lengths.clear();
+        let result = f(self, &mut requests, &mut lengths);
+        self.scratch.requests = requests;
+        self.scratch.lengths = lengths;
+        result
+    }
+
+    /// Discovers a composable request without painting a provisional box.
+    pub fn size_request<W: ?Sized>(
+        &mut self,
+        child: &StrongWidget<W>,
+        axis: Axis,
+    ) -> Option<RequestedLen> {
+        if self.rsc.widgets().size_rules(child.id())[axis].bound() == crate::Bound::ANY
+            && let Some(len) = self.size_hint(child, axis)
+        {
+            self.request_deps.push(child.id());
+            return Some(len.into());
+        }
+        let start = self.request_deps.len();
+        let mut requests = SizeRequests {
+            arena: &mut self.state.requests,
+            measured: None,
+            widgets: self.rsc.widgets(),
+            dependencies: &mut self.request_deps,
+            rel_base: self.rel_base[axis],
+        };
+        // Intrinsic fixed content must keep its offered box for wrapping;
+        // only a declaration or a share chooses the box it is drawn in.
+        let request = requests.widget(child, axis).filter(|request| {
+            request.has_leftover()
+                || matches!(
+                    self.rsc.widgets().size_rules(child.id())[axis],
+                    crate::SizeRule::Request(_)
+                )
+        });
+        if request.is_some() {
+            self.rel_base(axis);
+        } else {
+            // A discarded request contributes no dependency: the measured
+            // draw below records the size and box it actually used instead.
+            self.request_deps.truncate(start);
+        }
+        request
+    }
+
+    /// Completes discovery after a child was measured. Only this call may use
+    /// drawn answers: before the ask they could belong to an obsolete box.
+    pub fn measured_request<W: ?Sized>(
+        &mut self,
+        child: &StrongWidget<W>,
+        axis: Axis,
+        len: LayoutLen,
+    ) -> RequestedLen {
+        let start = self.request_deps.len();
+        let bound = self.rsc.widgets().size_rules(child.id())[axis].bound();
+        let mut requests = SizeRequests {
+            arena: &mut self.state.requests,
+            measured: Some(&self.state.active),
+            widgets: self.rsc.widgets(),
+            dependencies: &mut self.request_deps,
+            rel_base: self.rel_base[axis],
+        };
+        if let Some(request) = requests.widget(child, axis)
+            && request.linear().is_none()
+            && request.has_leftover()
+        {
+            self.rel_base(axis);
+            return request;
+        }
+        let request = if len.leftover > Weight::ZERO {
+            requests.bounded(len.into(), bound)
+        } else {
+            len.into()
+        };
+        self.request_deps.truncate(start);
+        if len.leftover > Weight::ZERO && bound != crate::Bound::ANY {
+            self.rel_base(axis);
+        }
+        request
+    }
+
+    /// A deferred comparison reads this window when the allocation is solved.
+    pub fn allocate(
+        &mut self,
+        requests: &[RequestedLen],
+        room: Len,
+        axis: Axis,
+        output: &mut Vec<Px>,
+    ) {
+        let window = self.window[axis];
+        self.own[axis].window = self.own[axis].window.and(Holds::at(window));
+        output.clear();
+        output.extend(
+            self.state
+                .requests
+                .allocate(requests, room.to_px(window), window),
+        )
+    }
+
+    pub fn minimum_request(&mut self, request: &RequestedLen, axis: Axis) -> Len {
+        match request.linear() {
+            Some(len) => len.without_leftover(),
+            None => {
+                let window = self.window[axis];
+                self.own[axis].window = self.own[axis].window.and(Holds::at(window));
+                Len::from_parts(Rel::ZERO, self.state.requests.minimum(*request, window))
+            }
+        }
+    }
+
     fn primitive_at<P: Primitive>(&mut self, primitive: P, region: UiRegion) {
         let kind = self.rsc.ui_mut().primitives.kind::<P>();
         self.write(kind, primitive, region);
@@ -155,13 +280,17 @@ impl<'a> Painter<'a> {
     /// where that is this widget's own narrowed the way the region is. An
     /// axis the region leaves whole is not read at all, so a wrapper that
     /// only moves its child does not pin its drawing to a rel base.
-    fn state_rel_base(&mut self, mut place: PlaceDesc) -> PlaceDesc {
+    fn resolve_rel_base(&mut self, mut place: PlaceDesc) -> PlaceDesc {
-        for axis in AXES {
+        for axis in Axis::BOTH {
-            if let Some(span) = place[axis].narrows_rel_base() {
+            let at = &mut place[axis];
+            let (RelBase::WithRegion, PlaceSpan::Within(span)) = (at.rel_base, at.span) else {
+                continue;
+            };
             let len = span.len();
-                let stated = (len != Len::FULL).then(|| len.within_len(self.rel_base(axis)));
+            at.rel_base = match len == Len::FULL {
-                place[axis] = place[axis].with_rel_base(stated);
+                true => RelBase::Inherit,
-            }
+                false => RelBase::Len(len.within_len(self.rel_base(axis))),
+            };
         }
         place
     }
@@ -181,12 +310,24 @@ impl<'a> Painter<'a> {
         id: &'s StrongWidget<W>,
         place: impl Into<PlaceDesc>,
     ) -> DrawResult<'s, 'a, W> {
-        let place = self.state_rel_base(place.into());
+        let offer = self.resolve_rel_base(place.into());
+        let Ask {
+            rel_base,
+            region,
+            place,
+            declared,
+            bounds,
+            holds: ask_holds,
+            inputs,
+        } = self.placing().ask(
+            self.rsc.widgets(),
+            &mut self.state.requests,
+            self.window,
+            id.id(),
+            offer,
+        );
+        self.own = self.own.and(inputs);
         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);
@@ -197,8 +338,7 @@ impl<'a> Painter<'a> {
         if !re_asked {
             self.children.push(id.id());
         }
-        let px = rel_base.to_px(self.window);
+        let drawn = self.state.draw_inner(
-        let (size, answer_holds, holds) = self.state.draw_inner(
             id.id(),
             DrawInfo {
                 layer: self.layer,
@@ -210,15 +350,17 @@ impl<'a> Painter<'a> {
                 rel_base,
                 region,
                 placed: place,
-                asked: place,
+                asked: offer,
+                declared,
+                bounds,
+                ask_holds,
                 re_asked,
-                px,
             },
             None,
             self.rsc,
         );
-        let holds = self.in_parent(holds, region, place, declared);
+        let holds = self.in_parent(drawn.drawing_holds, region, place, declared);
-        let answer_holds = self.in_parent(answer_holds, region, place, declared);
+        let answer_holds = self.in_parent(drawn.answer.holds, region, place, declared);
         match self.under.iter_mut().find(|(child, _)| *child == id.id()) {
             Some((_, kept)) => *kept = holds,
             None => self.under.push((id.id(), holds)),
@@ -226,7 +368,7 @@ impl<'a> Painter<'a> {
         DrawResult {
             child: id,
             painter: self,
-            size,
+            size: drawn.answer.size,
             answer_holds,
         }
     }
@@ -255,10 +397,10 @@ impl<'a> Painter<'a> {
         id: &'s StrongWidget<W>,
         place: impl Into<PlaceDesc>,
     ) -> DrawResult<'s, 'a, W> {
-        let place = self.state_rel_base(place.into());
+        let place = self.resolve_rel_base(place.into());
-        let states_rel_base = AXES
+        let states_rel_base = Axis::BOTH
             .iter()
-            .any(|&axis| place[axis].stated_rel_base().is_some());
+            .any(|&axis| matches!(place[axis].rel_base, RelBase::Len(_)));
         if states_rel_base || !self.children.contains(&id.id()) {
             return self.widget_at(id, place);
         }
@@ -278,37 +420,21 @@ 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,
-            window: self.window,
             depth: self.depth,
             move_idx: self.move_idx,
             mask: self.mask,
         }
     }
 
-    /// 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();
+        let hint = self.rsc.widgets().exact_len(id.id(), axis);
-        // 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 rel_base = self.rel_base[axis];
         let resolved = hint.map(|hint| hint.within_len(rel_base));
         #[cfg(feature = "layout-diagnostics")]
@@ -425,9 +551,10 @@ impl<'a> Painter<'a> {
     /// worth anything, since reading one is also what makes its own size
     /// depend on it.
     pub fn has_exact_size(&self, axis: Axis) -> bool {
-        self.rsc.widgets().size_rules(self.id)[axis]
+        matches!(
-            .exact()
+            self.rsc.widgets().size_rules(self.id)[axis],
-            .is_some()
+            crate::SizeRule::Exact(_) | crate::SizeRule::Request(_)
+        )
     }
 
     /// This widget's own box in pixels. Reading it makes the drawing one
@@ -479,6 +606,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
@@ -494,10 +641,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);
     }
@@ -579,10 +722,10 @@ impl PrimitiveLike for &TextureHandle {
     }
 }
 
-/// Moves what a child depends on into this widget's own terms: this
-/// method's `impl` block is where a `Painter`'s own boxes are, so it takes
-/// only what the child was asked with.
 impl Painter<'_> {
+    /// Moves what a child depends on into this widget's own terms, taking
+    /// only what the child was asked with.
+    ///
     /// Window ranges are already about the one unit and combine directly.
     /// A rel base pin becomes this widget's own rel base wherever a length of it
     /// is what reached the child; where only pixels did, no length of this
@@ -602,19 +745,23 @@ impl Painter<'_> {
         declared: Declared,
     ) -> LayoutHolds {
         let mut result = LayoutHolds::ANY;
-        for axis in AXES {
+        for axis in Axis::BOTH {
             let declared = declared[axis];
             let holds = holds[axis];
+            let at = place[axis];
             let result = &mut result[axis];
             // Every read became pixels against the window, so a range on
             // it is already in this widget's terms.
             result.window = holds.window;
-            let at = place[axis];
+            // A length this widget named -- a resolved share, a box a sibling
-            let reaches = at.stated_rel_base().is_none()
+            // decided, a box it sized outright, which is its own base -- is
-                && !at.is_sized()
+            // not a length of this widget's rel base, so a pin on it stops
+            // here. So does a declaration in pixels: no length of either base
+            // is in it to see.
+            let reaches = !matches!(at.rel_base, RelBase::Len(_))
                 && declared.is_none_or(|len| len.rel != Rel::ZERO);
             result.rel_base = holds.rel_base.and(reaches.then(|| self.rel_base[axis]));
-            match (at.within_span(), declared.is_some()) {
+            match (at.span, declared) {
                 // Its box is a part of this widget's own box, in that box's
                 // own lengths, so what it holds for maps back through that
                 // part into a range on this widget's box. A length it pinned
@@ -622,7 +769,7 @@ impl Painter<'_> {
                 // part is the whole of the box less pixels, which is the one
                 // shape that inverts exactly; any other part pins this
                 // widget's own length.
-                (Some(span), false) => {
+                (PlaceSpan::Within(span), None) => {
                     let part_len = span.len();
                     result.region = holds.region.through(part_len);
                     result.region_len = holds.region_len.map(|pinned| match part_len.rel {
@@ -644,24 +791,187 @@ impl Painter<'_> {
 }
 
 impl Widgets {
-    /// What a widget's box is where a rule or its own hint says so outright.
+    /// What says a widget's length on one axis without drawing it, if anything
-    pub(crate) fn declared_lens(&self, id: WidgetId) -> Declared {
+    /// does. A rule is the answer where there is one: it wins over whatever the
-        let rules = self.size_rules(id);
+    /// widget would draw, so it has to win over what the widget says too -- a
-        let widget = self.get_dyn(id);
+    /// share included, since a share is a length only to whoever divides one,
-        Declared::from_axes(|axis| {
+    /// and that is the parent rather than this widget.
-            rules[axis].declared().or_else(|| {
+    fn exact_len(&self, id: WidgetId, axis: Axis) -> Option<LayoutLen> {
-                // A hint still narrows the box where no rule does, which is
+        if matches!(self.size_rules(id)[axis], crate::SizeRule::Request(_)) {
-                // how a widget with a natural pixel size -- an image, a gap
+            return None;
-                // -- gets that size rather than the whole offer. That is the
+        }
-                // offer's business rather than a declaration's, and this
+        self.size_rules(id)[axis].exact().or_else(|| {
-                // falls away once a widget occupies its reported size inside
+            // A hint still narrows the box where no rule does, which is how a
-                // the box it was offered.
+            // widget with a natural pixel size -- an image, a gap -- gets that
-                widget
+            // size rather than the whole offer. That is the offer's business
-                    .and_then(|widget| widget.size_hint(axis))
+            // rather than a declaration's, and this falls away once a widget
-                    .and_then(LayoutLen::declared)
+            // 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,
+    /// What the widget's box is on each axis where something says so
+    /// outright: its rule or its hint, or a bound of its own that the box it
+    /// was offered falls outside -- a bound that binds is a declaration, and
+    /// the same one the widget answers with.
+    pub declared: Declared,
+    /// Its bounds, resolved against the rel base its rules were resolved
+    /// against, for the answer to be held to where the box was not.
+    pub bounds: Bounds,
+    /// 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,
+    /// Inputs read against the parent before declarations choose a new base.
+    /// These belong to the asker; the widget's own holds describe its output box.
+    pub inputs: 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,
+        requests: &mut RequestArena,
+        window: PxVec2,
+        id: WidgetId,
+        mut place: PlaceDesc,
+    ) -> Ask {
+        let align = widgets.alignment(id);
+        let rules = widgets.size_rules(id);
+        let mut holds = LayoutHolds::ANY;
+        let mut inputs = LayoutHolds::ANY;
+        let mut declared = widgets.declared_lens(id);
+        let mut bounds = Bounds::ANY;
+        for axis in Axis::BOTH {
+            let base = place.base(axis, self.rel_base);
+            if let crate::SizeRule::Request(request) = &rules[axis] {
+                inputs[axis].rel_base = Some(self.rel_base[axis]);
+                inputs[axis].region_len = Some(self.region[axis].len());
+                inputs[axis].window = Holds::at(window[axis]);
+                let offer = place.of(self.region, align)[axis].len();
+                let len = if place[axis].fit == crate::PlaceFit::Allocated {
+                    offer
+                } else {
+                    let request = requests.import(request, base);
+                    let len = requests
+                        .allocate(&[request], offer.to_px(window[axis]), window[axis])
+                        .next()
+                        .unwrap();
+                    holds[axis].window = Holds::at(window[axis]);
+                    Len::from_parts(Rel::ZERO, len)
+                };
+                let len = Len::from_parts(Rel::ZERO, len.to_px(window[axis]));
+                place[axis].rel_base = RelBase::Len(len);
+                declared[axis] = Some(len);
+                holds[axis].rel_base = Some(len);
+                continue;
+            }
+            // 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 widget's own: a share that fits is the box it was given,
+            // which is what this place already says.
+            let (share, 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) = share {
+                place[axis] = len.as_desc().fills();
+            }
+            // A bound holds what the widget answers, not the box it is asked
+            // in: the box it is given is whoever asked's to decide, and a
+            // rule that read it would be decided again by every path that
+            // hands the widget a box -- including the ones that never ask it
+            // anything. Resolved here because only the ask knows the rel base
+            // a fraction in it is of. `MaxSize` is the box version, and it is
+            // a widget because a widget is drawn again when its box changes.
+            let bound = rules[axis].bound();
+            if [bound.min, bound.max]
+                .into_iter()
+                .flatten()
+                .any(|len| len.rel != Rel::ZERO)
+            {
+                inputs[axis].rel_base = Some(self.rel_base[axis]);
+            }
+            bounds[axis] = bound.within_len(base);
+        }
+        let (rel_base, region) =
+            place.rel_base_and_region(self.region, self.rel_base, declared, align);
+        Ask {
+            rel_base,
+            region,
+            place,
+            declared,
+            bounds,
+            holds,
+            inputs,
+        }
+    }
+
+    /// 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].fit.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 {
@@ -672,22 +982,22 @@ 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(crate) 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
     }
 }
 
+impl PlaceDesc {
     /// Where a widget's drawing goes inside the part its parent gave it: what
     /// it reported, on the side of the part its alignment says, and the whole
     /// part wherever the answer fills it.
     ///
-/// The length it reported is a length of its rel base, and the part is one too,
+    /// The length it reported is a length of its rel base, and the part is one
-/// so this takes one from the other rather than composing it into the part.
+    /// too, so this takes one from the other rather than composing it into the
-/// That is what makes a fraction the same fraction wherever the part it is
+    /// part. That is what makes a fraction the same fraction wherever the part
-/// placed in sits and however long it is -- the fraction is resolved once,
+    /// it is placed in sits and however long it is -- the fraction is resolved
-/// here, against the rel base it was reported of.
+    /// once, here, against the rel base it was reported of.
-impl PlaceDesc {
+    pub(super) fn placement(
-    pub(crate) fn placement(
         self,
         region: UiRegion,
         size: Size,
@@ -695,9 +1005,9 @@ impl PlaceDesc {
         align: RegionAlign,
     ) -> UiRegion {
         let mut placed = region;
-        for axis in AXES {
+        for axis in Axis::BOTH {
             let reported = size[axis];
-            if reported.fills(declared[axis], self[axis].does_fill()) {
+            if reported.fills(declared[axis], self[axis].fit.fills()) {
                 continue;
             }
             placed[axis] = placed[axis].place(reported.without_leftover(), align[axis]);
@@ -715,7 +1025,7 @@ impl PlaceDesc {
     /// name. The child's declaration is a fraction of whichever reached it, and
     /// is the only one that also places the box: a box the caller decided is
     /// what `place` names.
-    pub(crate) fn rel_base_and_region(
+    pub(super) fn rel_base_and_region(
         self,
         own: UiRegion,
         parent_rel_base: UiVec2,
@@ -725,10 +1035,8 @@ impl PlaceDesc {
         let given = self.of(own, align);
         let mut rel_base = parent_rel_base;
         let mut region = given;
-        for axis in AXES {
+        for axis in Axis::BOTH {
-            let base = self[axis]
+            let base = self.base(axis, parent_rel_base);
-                .stated_rel_base()
-                .unwrap_or_else(|| parent_rel_base[axis]);
             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.
@@ -11,21 +11,37 @@ use crate::{Axis, AxisAlign, Len, PrimitiveHandle, RegionAlign, UiRegion, UiSpan
 /// it differently, so it is said here.
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub struct PlaceDescAxis {
-    span: PlaceSpan,
+    pub span: PlaceSpan,
-    fills: bool,
+    pub fit: PlaceFit,
-    rel_base: RelBase,
+    pub rel_base: RelBase,
 }
 
 #[derive(Clone, Copy, Debug, PartialEq)]
-enum PlaceSpan {
+pub enum PlaceFit {
+    Align,
+    Fill,
+    /// The parent has already evaluated the child's size request.
+    Allocated,
+}
+
+impl PlaceFit {
+    pub fn fills(self) -> bool {
+        self != Self::Align
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum PlaceSpan {
     Within(UiSpan),
     Shifted(UiSpan),
     Sized(Len),
 }
 
-/// What a child's fractions are of, where the caller has not named a length.
+/// What a child's fractions are of. [`PlaceSpan::Sized`] is a length the
+/// caller named, which is always its own base, so nothing here constructs one
+/// beside anything but [`Self::Len`].
 #[derive(Clone, Copy, Debug, PartialEq)]
-enum RelBase {
+pub enum RelBase {
     /// The caller's own, unchanged.
     Inherit,
     /// The caller's own, narrowed the way the region is.
@@ -42,7 +58,13 @@ impl PlaceDescAxis {
     /// it again. A container uses it where it hands back exactly what the
     /// child asked for -- a row placing a child at the length it reported.
     pub const fn fills(mut self) -> Self {
-        self.fills = true;
+        self.fit = PlaceFit::Fill;
+        self
+    }
+
+    /// A final allocation, including any comparisons in the child's request.
+    pub const fn allocated(mut self) -> Self {
+        self.fit = PlaceFit::Allocated;
         self
     }
 
@@ -61,14 +83,8 @@ impl PlaceDescAxis {
         self
     }
 
-    /// Whether the region is the placement outright, rather than a box the
-    /// answer is placed inside.
-    pub(crate) const fn does_fill(self) -> bool {
-        self.fills
-    }
-
     /// Where it lands in the coordinates `own` is in.
-    pub(crate) fn of(self, own: UiSpan, align: AxisAlign) -> UiSpan {
+    pub fn of(self, own: UiSpan, align: AxisAlign) -> UiSpan {
         match self.span {
             PlaceSpan::Within(span) => span.within(&own),
             PlaceSpan::Shifted(mut span) => {
@@ -78,50 +94,6 @@ impl PlaceDescAxis {
             PlaceSpan::Sized(len) => own.place(len, align),
         }
     }
-
-    /// The child's rel base, where this says one outright. `None` forwards
-    /// the caller's own, and [`RelBase::WithRegion`] is resolved by whoever
-    /// can read that rel base, so it does not reach here.
-    pub(crate) const fn stated_rel_base(self) -> Option<Len> {
-        match self.rel_base {
-            RelBase::Len(len) => Some(len),
-            _ => None,
-        }
-    }
-
-    /// The length this narrows the caller's rel base by, where it does.
-    /// `None` leaves that rel base alone, and reading it is then a
-    /// dependency the caller does not take.
-    pub(crate) const fn narrows_rel_base(self) -> Option<UiSpan> {
-        match (self.rel_base, self.span) {
-            (RelBase::WithRegion, PlaceSpan::Within(span)) => Some(span),
-            _ => None,
-        }
-    }
-
-    /// The span it composes into the caller's box, where that is what it
-    /// does: the one case whose validity maps back through the part.
-    pub(crate) const fn within_span(self) -> Option<UiSpan> {
-        match self.span {
-            PlaceSpan::Within(span) => Some(span),
-            _ => None,
-        }
-    }
-
-    /// Whether the caller decided this length rather than a place along its
-    /// own box, which is what stops its length reaching the child at all.
-    pub(crate) const fn is_sized(self) -> bool {
-        matches!(self.span, PlaceSpan::Sized(_))
-    }
-
-    /// The same, with its rel base stated outright.
-    pub(crate) const fn with_rel_base(mut self, len: Option<Len>) -> Self {
-        self.rel_base = match len {
-            Some(len) => RelBase::Len(len),
-            None => RelBase::Inherit,
-        };
-        self
-    }
 }
 
 /// Where a child is asked, on both axes. A [`UiRegion`] converts into the
@@ -171,8 +143,18 @@ 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(crate) fn of(self, own: UiRegion, align: RegionAlign) -> UiRegion {
+    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))
     }
 }
@@ -191,7 +173,7 @@ impl UiSpan {
     pub const fn within_desc(self) -> PlaceDescAxis {
         PlaceDescAxis {
             span: PlaceSpan::Within(self),
-            fills: false,
+            fit: PlaceFit::Align,
             rel_base: RelBase::WithRegion,
         }
     }
@@ -209,7 +191,7 @@ impl UiSpan {
     pub const fn shifted_desc(self) -> PlaceDescAxis {
         PlaceDescAxis {
             span: PlaceSpan::Shifted(self),
-            fills: false,
+            fit: PlaceFit::Align,
             rel_base: RelBase::Inherit,
         }
     }
@@ -223,7 +205,7 @@ impl Len {
     pub const fn as_desc(self) -> PlaceDescAxis {
         PlaceDescAxis {
             span: PlaceSpan::Sized(self),
-            fills: false,
+            fit: PlaceFit::Align,
             rel_base: RelBase::Len(self),
         }
     }

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

@@ -4,6 +4,7 @@ use std::any::Any;
 mod data;
 mod handle;
 mod like;
+mod request;
 mod size_rule;
 mod tag;
 mod view;
@@ -12,6 +13,7 @@ mod widgets;
 pub use data::*;
 pub use handle::*;
 pub use like::*;
+pub use request::*;
 pub use size_rule::*;
 pub use tag::*;
 pub use view::*;
@@ -21,6 +23,12 @@ pub trait Widget: Any {
     /// Draws the widget, and returns what it used of the box it was given.
     fn draw(&mut self, painter: &mut Painter) -> Size;
 
+    /// Describes an axis before painting. Return `None` when discovering it
+    /// needs a concrete box or work performed by `draw`.
+    fn size_request(&self, requests: &mut SizeRequests, axis: Axis) -> Option<RequestedLen> {
+        self.size_hint(axis).map(|len| requests.length(len))
+    }
+
     /// An exact length the widget can give without a painter or its children.
     /// Optional, and saves a draw rather than changing one: a hint that
     /// disagrees with the eventual draw fails a debug assertion.

core/src/widget/request.rs

@@ -0,0 +1,438 @@
+use crate::{Axis, LayoutLen, Len, Px, StrongWidget, Weight, WidgetId, Widgets};
+
+impl<N: crate::UiNum> From<N> for SizeRequest {
+    fn from(value: N) -> Self {
+        LayoutLen::px(value).into()
+    }
+}
+
+impl LayoutLen {
+    pub fn min(self, other: impl Into<SizeRequest>) -> SizeRequest {
+        SizeRequest::from(self).min(other)
+    }
+
+    pub fn max(self, other: impl Into<SizeRequest>) -> SizeRequest {
+        SizeRequest::from(self).max(other)
+    }
+
+    pub fn clamp(self, min: impl Into<SizeRequest>, max: impl Into<SizeRequest>) -> SizeRequest {
+        SizeRequest::from(self).clamp(min, max)
+    }
+}
+
+/// A size request before a container has divided its leftover space.
+/// Comparisons keep both operands until the share is known.
+#[derive(Clone, Debug, PartialEq)]
+pub enum SizeRequest {
+    Linear(LayoutLen),
+    Sum(std::sync::Arc<(Self, Self)>),
+    Min(std::sync::Arc<(Self, Self)>),
+    Max(std::sync::Arc<(Self, Self)>),
+}
+
+impl From<LayoutLen> for SizeRequest {
+    fn from(len: LayoutLen) -> Self {
+        Self::Linear(len)
+    }
+}
+
+impl From<Len> for SizeRequest {
+    fn from(len: Len) -> Self {
+        LayoutLen::from(len).into()
+    }
+}
+
+impl SizeRequest {
+    pub fn min(self, other: impl Into<Self>) -> Self {
+        let other = other.into();
+        if let (Self::Linear(a), Self::Linear(b)) = (&self, &other)
+            && let Some(order) = independent_order(*a, *b)
+        {
+            return if !order.is_gt() { self } else { other };
+        }
+        if self == other {
+            self
+        } else {
+            Self::Min(std::sync::Arc::new((self, other)))
+        }
+    }
+
+    pub fn max(self, other: impl Into<Self>) -> Self {
+        let other = other.into();
+        if let (Self::Linear(a), Self::Linear(b)) = (&self, &other)
+            && let Some(order) = independent_order(*a, *b)
+        {
+            return if !order.is_lt() { self } else { other };
+        }
+        if self == other {
+            self
+        } else {
+            Self::Max(std::sync::Arc::new((self, other)))
+        }
+    }
+
+    pub fn clamp(self, min: impl Into<Self>, max: impl Into<Self>) -> Self {
+        self.max(min).min(max)
+    }
+}
+
+impl std::ops::Add for SizeRequest {
+    type Output = Self;
+
+    fn add(self, other: Self) -> Self {
+        match (self, other) {
+            (Self::Linear(a), Self::Linear(b)) => Self::Linear(a + b),
+            (a, b) => Self::Sum(std::sync::Arc::new((a, b))),
+        }
+    }
+}
+
+/// A discovered length. Deferred values belong to the current layout pass;
+/// widgets must not retain them. Ordinary requests remain inline lengths.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct RequestedLen(RequestValue);
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+enum RequestValue {
+    Linear(LayoutLen),
+    Deferred {
+        index: usize,
+        epoch: u64,
+        leftover: bool,
+    },
+}
+
+impl From<LayoutLen> for RequestedLen {
+    fn from(len: LayoutLen) -> Self {
+        Self(RequestValue::Linear(len))
+    }
+}
+impl From<Len> for RequestedLen {
+    fn from(len: Len) -> Self {
+        LayoutLen::from(len).into()
+    }
+}
+impl RequestedLen {
+    pub fn linear(self) -> Option<LayoutLen> {
+        match self.0 {
+            RequestValue::Linear(len) => Some(len),
+            _ => None,
+        }
+    }
+    pub fn has_leftover(self) -> bool {
+        match self.0 {
+            RequestValue::Linear(len) => len.leftover > Weight::ZERO,
+            RequestValue::Deferred { leftover, .. } => leftover,
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+enum Op {
+    Sum,
+    Min,
+    Max,
+}
+struct Node {
+    op: Op,
+    a: RequestedLen,
+    b: RequestedLen,
+}
+
+#[derive(Default)]
+pub(crate) struct RequestArena {
+    nodes: Vec<Node>,
+    epoch: u64,
+}
+
+impl RequestArena {
+    pub(crate) fn reset(&mut self) {
+        self.nodes.clear();
+        self.epoch = self
+            .epoch
+            .checked_add(1)
+            .expect("layout generation exhausted");
+    }
+    pub(crate) fn import(&mut self, request: &SizeRequest, base: Len) -> RequestedLen {
+        let (op, pair) = match request {
+            SizeRequest::Linear(len) => return len.within_len(base).into(),
+            SizeRequest::Sum(pair) => (Op::Sum, pair),
+            SizeRequest::Min(pair) => (Op::Min, pair),
+            SizeRequest::Max(pair) => (Op::Max, pair),
+        };
+        let a = self.import(&pair.0, base);
+        let b = self.import(&pair.1, base);
+        self.combine(op, a, b)
+    }
+    fn combine(&mut self, op: Op, a: RequestedLen, b: RequestedLen) -> RequestedLen {
+        if let (Some(x), Some(y)) = (a.linear(), b.linear()) {
+            if matches!(op, Op::Sum) {
+                return (x + y).into();
+            }
+            let order = independent_order(x, y);
+            if let Some(order) = order {
+                let take_a = match op {
+                    Op::Min => !order.is_gt(),
+                    _ => !order.is_lt(),
+                };
+                return if take_a { a } else { b };
+            }
+        }
+        if a == b && !matches!(op, Op::Sum) {
+            return a;
+        }
+        let index = self.nodes.len();
+        self.nodes.push(Node { op, a, b });
+        RequestedLen(RequestValue::Deferred {
+            index,
+            epoch: self.epoch,
+            leftover: a.has_leftover() || b.has_leftover(),
+        })
+    }
+    pub(crate) fn minimum(&self, request: RequestedLen, window: Px) -> Px {
+        Px::from_raw(self.segment(request, Ratio::ZERO, window).fixed as i32)
+    }
+    fn segment(&self, request: RequestedLen, at: Ratio, window: Px) -> Segment {
+        match request.0 {
+            RequestValue::Linear(len) => {
+                assert!(
+                    len.leftover >= Weight::ZERO,
+                    "a leftover weight cannot be negative"
+                );
+                Segment {
+                    fixed: i64::from(len.without_leftover().to_px(window).raw()),
+                    weight: i64::from(len.leftover.raw()),
+                    end: None,
+                }
+            }
+            RequestValue::Deferred { index, epoch, .. } => {
+                assert_eq!(epoch, self.epoch, "request retained beyond its layout pass");
+                let Node { op, a, b } = self.nodes[index];
+                let a = self.segment(a, at, window);
+                let b = self.segment(b, at, window);
+                if matches!(op, Op::Sum) {
+                    return a + b;
+                }
+                // At a crossing choose the branch to its right, so the next
+                // iteration advances rather than selecting that crossing again.
+                let order = a.value(at).cmp(&b.value(at)).then(a.weight.cmp(&b.weight));
+                let take_a = match op {
+                    Op::Min => !order.is_gt(),
+                    _ => !order.is_lt(),
+                };
+                let mut selected = if take_a { a } else { b };
+                selected.end = first(a.end, b.end);
+                if a.weight != b.weight {
+                    let crossing = Ratio::new(b.fixed - a.fixed, a.weight - b.weight);
+                    if crossing > at {
+                        selected.end = first(selected.end, Some(crossing));
+                    }
+                }
+                selected
+            }
+        }
+    }
+    /// Allocates one scope of nonnegative shares. Floors can overflow; caps
+    /// can leave unused room. Prefix rounding keeps adjacent slot edges equal.
+    pub(crate) fn allocate<'a>(
+        &'a self,
+        requests: &'a [RequestedLen],
+        room: Px,
+        window: Px,
+    ) -> impl Iterator<Item = Px> + 'a {
+        let mut at = Ratio::ZERO;
+        loop {
+            let total = requests.iter().fold(Segment::ZERO, |total, request| {
+                total + self.segment(*request, at, window)
+            });
+            if total.value(at) >= i128::from(room.raw()) * i128::from(at.den) {
+                break;
+            }
+            if total.weight != 0 {
+                let solution = Ratio::new(i64::from(room.raw()) - total.fixed, total.weight);
+                if total.end.is_none_or(|end| solution <= end) {
+                    at = solution;
+                    break;
+                }
+            }
+            match total.end {
+                Some(end) => at = end,
+                None => break,
+            }
+        }
+        let mut prefix = 0_i128;
+        let mut previous = 0_i128;
+        requests.iter().map(move |request| {
+            prefix += self.segment(*request, at, window).value(at);
+            let den = i128::from(at.den);
+            let edge = prefix.signum() * ((prefix.abs() + den / 2) / den);
+            let len = Px::from_raw((edge - previous) as i32);
+            previous = edge;
+            len
+        })
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq)]
+struct Ratio {
+    num: i64,
+    den: i64,
+}
+
+impl PartialEq for Ratio {
+    fn eq(&self, other: &Self) -> bool {
+        self.cmp(other).is_eq()
+    }
+}
+
+impl Ratio {
+    const ZERO: Self = Self { num: 0, den: 1 };
+
+    fn new(num: i64, den: i64) -> Self {
+        assert_ne!(den, 0);
+        if den < 0 {
+            Self {
+                num: -num,
+                den: -den,
+            }
+        } else {
+            Self { num, den }
+        }
+    }
+}
+
+impl Ord for Ratio {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        (i128::from(self.num) * i128::from(other.den))
+            .cmp(&(i128::from(other.num) * i128::from(self.den)))
+    }
+}
+
+impl PartialOrd for Ratio {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+#[derive(Clone, Copy)]
+struct Segment {
+    fixed: i64,
+    weight: i64,
+    end: Option<Ratio>,
+}
+
+impl Segment {
+    const ZERO: Self = Self {
+        fixed: 0,
+        weight: 0,
+        end: None,
+    };
+
+    fn value(self, at: Ratio) -> i128 {
+        i128::from(self.fixed) * i128::from(at.den) + i128::from(self.weight) * i128::from(at.num)
+    }
+}
+
+impl std::ops::Add for Segment {
+    type Output = Self;
+    fn add(self, other: Self) -> Self {
+        Self {
+            fixed: self.fixed + other.fixed,
+            weight: self.weight + other.weight,
+            end: first(self.end, other.end),
+        }
+    }
+}
+
+fn first(a: Option<Ratio>, b: Option<Ratio>) -> Option<Ratio> {
+    match (a, b) {
+        (Some(a), Some(b)) => Some(a.min(b)),
+        (a, b) => a.or(b),
+    }
+}
+
+/// Read-only discovery of requests through a widget's children. A request is
+/// expressed in window lengths; `rel_base` supplies the base for declarations.
+pub struct SizeRequests<'a> {
+    pub(crate) arena: &'a mut RequestArena,
+    pub(crate) measured: Option<&'a crate::util::HashMap<WidgetId, crate::ActiveData>>,
+    pub(crate) widgets: &'a Widgets,
+    pub(crate) dependencies: &'a mut Vec<WidgetId>,
+    pub(crate) rel_base: Len,
+}
+
+impl SizeRequests<'_> {
+    pub fn sum(&mut self, a: RequestedLen, b: RequestedLen) -> RequestedLen {
+        self.arena.combine(Op::Sum, a, b)
+    }
+    pub fn min(&mut self, a: RequestedLen, b: RequestedLen) -> RequestedLen {
+        self.arena.combine(Op::Min, a, b)
+    }
+    pub fn max(&mut self, a: RequestedLen, b: RequestedLen) -> RequestedLen {
+        self.arena.combine(Op::Max, a, b)
+    }
+
+    pub fn widget<W: ?Sized>(
+        &mut self,
+        child: &StrongWidget<W>,
+        axis: Axis,
+    ) -> Option<RequestedLen> {
+        self.dependencies.push(child.id());
+        let rules = self.widgets.size_rules(child.id());
+        let rule = &rules[axis];
+        if let crate::SizeRule::Request(request) = rule {
+            return Some(self.arena.import(request, self.rel_base));
+        }
+        if let Some(exact) = rule.exact() {
+            return Some(exact.within_len(self.rel_base).into());
+        }
+        let widget = self.widgets.get_dyn(child.id())?;
+        let request = widget.size_request(self, axis).or_else(|| {
+            self.measured?
+                .get(&child.id())?
+                .measured()
+                .map(|size| size[axis].into())
+        })?;
+        Some(self.bounded(request, rule.bound()))
+    }
+
+    pub(crate) fn bounded(&mut self, request: RequestedLen, bound: crate::Bound) -> RequestedLen {
+        let bound = bound.within_len(self.rel_base);
+        let request = match bound.min {
+            Some(min) => self.max(request, min.into()),
+            None => request,
+        };
+        match bound.max {
+            Some(max) => self.min(request, max.into()),
+            None => request,
+        }
+    }
+
+    pub fn length(&self, len: LayoutLen) -> RequestedLen {
+        len.within_len(self.rel_base).into()
+    }
+
+    pub fn inset<W: ?Sized>(
+        &mut self,
+        child: &StrongWidget<W>,
+        axis: Axis,
+        padding: Px,
+    ) -> Option<RequestedLen> {
+        let base = self.rel_base;
+        self.rel_base.px -= padding;
+        let request = self.widget(child, axis);
+        self.rel_base = base;
+        request.map(|request| self.sum(request, Len::from_parts(crate::Rel::ZERO, padding).into()))
+    }
+}
+
+// Equal fractions keep this valid even when padding makes a rel base negative.
+fn independent_order(a: LayoutLen, b: LayoutLen) -> Option<std::cmp::Ordering> {
+    if a.rel == b.rel && a.leftover == b.leftover {
+        Some(a.px.cmp(&b.px))
+    } else if a.px == b.px && a.rel == b.rel {
+        Some(a.leftover.cmp(&b.leftover))
+    } else {
+        None
+    }
+}

core/src/widget/size_rule.rs

@@ -1,5 +1,5 @@
 use crate::util::impl_axis_index;
-use crate::{Axis, LayoutLen, Len};
+use crate::{Axis, LayoutLen, Len, Rel, SizeRequest};
 
 /// What a widget's length on one axis is, as a rule its parent applies where
 /// it draws it rather than an answer the widget gives about itself.
@@ -9,20 +9,84 @@ use crate::{Axis, LayoutLen, Len};
 /// with no rule. That is what lets a span divide its space around a length
 /// nobody has drawn yet, and it is why a rule lives beside the widget rather
 /// than inside it -- the widget under the rule never has to know about it.
-#[derive(Debug, Clone, Copy, PartialEq, Default)]
+///
+/// Exact expressions can bound a share before allocation. Bounds on an
+/// intrinsic answer are applied after that answer becomes known.
+#[derive(Debug, Clone, PartialEq, Default)]
 pub enum SizeRule {
     /// Whatever the widget reports from drawing.
     #[default]
     Free,
     /// This length, whatever the widget reports.
     Exact(LayoutLen),
+    /// An exact request whose comparisons await the parent's allocation.
+    Request(std::sync::Arc<SizeRequest>),
+    /// At least this long, and otherwise whatever the box gives it.
+    Min(Len),
+    /// At most this long.
+    Max(Len),
+    /// Between the two.
+    Clamp { min: Len, max: Len },
 }
 
 impl SizeRule {
+    /// What this rule allows the length to be where it does not give one
+    /// outright.
+    pub fn bound(&self) -> Bound {
+        match *self {
+            Self::Free | Self::Exact(_) | Self::Request(_) => Bound::ANY,
+            Self::Min(min) => Bound {
+                min: Some(min),
+                max: None,
+            },
+            Self::Max(max) => Bound {
+                min: None,
+                max: Some(max),
+            },
+            Self::Clamp { min, max } => Bound {
+                min: Some(min),
+                max: Some(max),
+            },
+        }
+    }
+
+    /// Whether what this rule says is a fraction of the rel base, so that
+    /// the same rule against a different one is a different length.
+    pub fn has_fraction(&self) -> bool {
+        let bound = self.bound();
+        self.exact().is_some_and(|len| len.rel != Rel::ZERO)
+            || [bound.min, bound.max]
+                .iter()
+                .flatten()
+                .any(|len| len.rel != Rel::ZERO)
+    }
+
+    /// This rule with a floor under it, which is the whole of it where there
+    /// was no rule.
+    pub fn at_least(&self, min: Len) -> Self {
+        match *self {
+            Self::Free | Self::Min(_) => Self::Min(min),
+            Self::Max(max) | Self::Clamp { max, .. } => Self::Clamp { min, max },
+            Self::Request(ref request) => request.as_ref().clone().max(min).into(),
+            Self::Exact(len) => len.max(min).into(),
+        }
+    }
+
+    /// This rule with a cap over it, which is the whole of it where there was
+    /// no rule.
+    pub fn at_most(&self, max: Len) -> Self {
+        match *self {
+            Self::Free | Self::Max(_) => Self::Max(max),
+            Self::Min(min) | Self::Clamp { min, .. } => Self::Clamp { min, max },
+            Self::Request(ref request) => request.as_ref().clone().min(max).into(),
+            Self::Exact(len) => len.min(max).into(),
+        }
+    }
+
     /// 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 --
@@ -32,26 +96,97 @@ impl SizeRule {
     /// that give a box directly.
     pub fn exact(&self) -> Option<LayoutLen> {
         match self {
-            Self::Free => None,
             Self::Exact(len) => Some(*len),
+            Self::Free | Self::Request(_) | Self::Min(_) | Self::Max(_) | Self::Clamp { .. } => {
+                None
+            }
+        }
     }
 }
 
-    /// The length a widget reporting `reported` ends up with.
+/// What a rule allows a length to be where it does not give one outright: a
-    pub fn apply(&self, reported: LayoutLen) -> LayoutLen {
+/// floor, a cap, or both. Each is a length of the rel base the widget is
-        match self {
+/// asked with, which is the base a declared length is a fraction of too.
-            Self::Free => reported,
+///
-            Self::Exact(len) => *len,
+/// A bound is a [`Len`]. Comparisons involving shares are [`SizeRequest`]s.
+#[derive(Debug, Clone, Copy, PartialEq, Default)]
+pub struct Bound {
+    pub min: Option<Len>,
+    pub max: Option<Len>,
+}
+
+/// Which end of a bound a length fell outside.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Outside {
+    Shorter,
+    Longer,
+}
+
+impl Bound {
+    /// Every length.
+    pub const ANY: Self = Self {
+        min: None,
+        max: None,
+    };
+
+    /// The end [`Outside`] names, which is the length a widget outside it
+    /// gets instead of its own.
+    pub fn at(&self, outside: Outside) -> Len {
+        let end = match outside {
+            Outside::Shorter => self.min,
+            Outside::Longer => self.max,
+        };
+        end.expect("an end nothing is outside of")
+    }
+
+    /// This bound as lengths of the window, from lengths of a rel base that
+    /// long.
+    pub fn within_len(&self, len: Len) -> Self {
+        Self {
+            min: self.min.map(|min| min.within_len(len)),
+            max: self.max.map(|max| max.within_len(len)),
         }
     }
 }
 
+/// One bound per axis, as [`SizeRules`] is one rule per axis.
+#[derive(Debug, Clone, Copy, PartialEq, Default)]
+pub struct Bounds {
+    pub x: Bound,
+    pub y: Bound,
+}
+
+impl Bounds {
+    pub const ANY: Self = Self {
+        x: Bound::ANY,
+        y: Bound::ANY,
+    };
+
+    pub fn from_axes(f: impl Fn(Axis) -> Bound) -> Self {
+        Self {
+            x: f(Axis::X),
+            y: f(Axis::Y),
+        }
+    }
+}
+
+impl_axis_index!(Bounds => Bound);
+
 impl From<LayoutLen> for SizeRule {
     fn from(len: LayoutLen) -> Self {
         Self::Exact(len)
     }
 }
 
+impl From<SizeRequest> for SizeRule {
+    fn from(request: SizeRequest) -> Self {
+        match request {
+            SizeRequest::Linear(len) => Self::Exact(len),
+            request => Self::Request(std::sync::Arc::new(request)),
+        }
+    }
+}
+
 impl From<Option<LayoutLen>> for SizeRule {
     fn from(len: Option<LayoutLen>) -> Self {
         len.map_or(Self::Free, Self::Exact)
@@ -60,7 +195,7 @@ impl From<Option<LayoutLen>> for SizeRule {
 
 /// One rule per axis, which is how a widget carries a length on one axis and
 /// leaves the other to whatever it draws.
-#[derive(Debug, Clone, Copy, PartialEq, Default)]
+#[derive(Debug, Clone, PartialEq, Default)]
 pub struct SizeRules {
     pub x: SizeRule,
     pub y: SizeRule,

core/src/widget/widgets.rs

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

macro/src/lib.rs

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

scripts/run-headless.sh

@@ -106,11 +106,16 @@ export WAYLAND_DISPLAY
 
 echo "run-headless: $WAYLAND_DISPLAY (sway $(swaymsg -t get_version --raw | sed -n 's/.*"human_readable":"\([^"]*\)".*/\1/p'))" >&2
 
-swaymsg output HEADLESS-1 mode "$mode" >/dev/null
+# The extent `replay-touch` positions against, so a script's coordinates are
-# The extent `replay-touch` positions against, so a script's coordinates
+# the output's own pixels. Set beside every mode change, since a gesture
-# are the output's own pixels.
+# scaled against a mode the output no longer has lands somewhere else and
-out_w=${mode%x*}
+# still looks like a run that worked.
-out_h=${mode#*x}; out_h=${out_h%@*}
+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
+            // The two regions are on the grid and the pointer is not, so the
-            // it is compared against is on the grid.
+            // step between them is taken there and the pointer keeps the
-            let pos = (PxVec2::from_f32(ctx.data.pos) + container_pos - id_pos).to_f32();
+            // 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() {
+        let (output, suboptimal) = match self.surface.get_current_texture() {
-            CurrentSurfaceTexture::Success(texture) => texture,
+            CurrentSurfaceTexture::Success(texture) => (texture, false),
-            CurrentSurfaceTexture::Suboptimal(texture) => {
+            // Used for this frame, and the swapchain rebuilt after it has
-                self.surface.configure(&self.device, &self.config);
+            // been presented: configuring the surface while a texture it
-                texture
+            // 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>,
+    pub size: Option<SizeRules>,
-    /// The alignment it carries, under the same one-offer rule.
+    /// The alignment it carries, under the same one-offer rule. An axis left
-    pub align: Option<Aligns>,
+    /// 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 {
@@ -294,7 +292,7 @@ impl Plan {
                 align: None,
                 ..self.clone()
             }),
-            self.size.map(|_| Plan {
+            self.size.as_ref().map(|_| Plan {
                 size: None,
                 ..self.clone()
             }),
@@ -375,7 +373,7 @@ impl Plan {
             }
             if plan.size.is_some() {
                 if let Some(lens) = edits.sizes.get(&sized) {
-                    plan.size = Some(*lens);
+                    plan.size = Some(lens.clone());
                 }
                 sized += 1;
             }
@@ -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;
@@ -643,15 +644,49 @@ impl Sow<'_> {
         })
     }
 
-    fn len(&mut self) -> Option<LayoutLen> {
+    fn len(&mut self) -> LayoutLen {
-        match self.rng.below(4) {
+        LayoutLen::px(20.0 + self.rng.below(180) as f32)
-            0 => Some(LayoutLen::px(20.0 + self.rng.below(180) as f32)),
+    }
-            1 => Some(LayoutLen::LEFTOVER),
+
-            _ => None,
+    /// A length of a box rather than a length of the window, which is what a
+    /// bound is.
+    ///
+    /// Pixels only, for now. A fraction in a bound is resolved against the rel
+    /// base the widget was asked with, and `place_at` hands a parent a
+    /// retained answer without checking that the answer still holds for the
+    /// rel base this place gives -- so a fraction resolved against one rel
+    /// base survives into another. Seeds 4 (shuffle-all-but-first) and 196
+    /// (resize-size) at depth 5 are where that showed; both pass with pixels.
+    /// The hole is older than bounds -- an `Exact` rule that is a fraction
+    /// can reach it too -- and closing it is a check at the re-place site.
+    fn bound(&mut self) -> Len {
+        Len::px(20.0 + self.rng.below(180) as f32)
+    }
+
+    fn rule(&mut self) -> SizeRule {
+        match self.rng.below(8) {
+            0 | 1 => self.len().into(),
+            2 => LayoutLen::LEFTOVER.into(),
+            3 => SizeRule::Min(self.bound()),
+            4 => SizeRule::Max(self.bound()),
+            // Both in pixels, so one can be put under the other: a floor and
+            // a cap that change sides with the window bound nothing, which
+            // is a caller's bug rather than a tree to grow.
+            5 => {
+                let (a, b) = (
+                    Px::from_f32(20.0 + self.rng.below(180) as f32),
+                    Px::from_f32(20.0 + self.rng.below(180) as f32),
+                );
+                SizeRule::Clamp {
+                    min: Len::px(a.min(b).to_f32()),
+                    max: Len::px(a.max(b).to_f32()),
+                }
+            }
+            _ => SizeRule::Free,
         }
     }
 
-    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,21 +696,27 @@ 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],
+            true => Align {
-            false => [x, y],
+                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.rule(),
+            y: self.rule(),
+        };
         if !take || inner.size.is_some() {
             return;
         }
         let idx = self.sized;
         self.sized += 1;
-        inner.size = Some(self.edits.sizes.get(&idx).copied().unwrap_or(lens));
+        inner.size = Some(self.edits.sizes.get(&idx).cloned().unwrap_or(lens));
     }
 
     /// An alignment over some of the tree, kept where a test can change it.
@@ -773,10 +814,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 +833,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,23 +842,25 @@ 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> {
     fn node(&mut self, plan: &Plan) -> StrongWidget {
         let built = self.kind(&plan.kind);
         let id = built.id();
-        if let Some(lens) = plan.size {
+        if let Some(lens) = plan.size.clone() {
-            self.rsc
+            self.rsc.ui_mut().widgets.set_size_rules(id, lens.x, lens.y);
-                .ui_mut()
-                .widgets
-                .set_size_rules(id, lens[0], lens[1]);
             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) {
+            for axis in Axis::BOTH {
-                widgets.set_alignment(id, axis, align.unwrap_or_default());
+                widgets.set_alignment(id, axis, resolved[axis]);
             }
             self.tree.aligned.push(id);
         }
@@ -831,6 +871,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 +893,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 +970,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/layer.rs

@@ -6,6 +6,10 @@ pub struct LayerOffset {
 }
 
 impl Widget for LayerOffset {
+    fn size_request(&self, requests: &mut SizeRequests, axis: Axis) -> Option<RequestedLen> {
+        requests.widget(&self.inner, axis)
+    }
+
     fn draw(&mut self, painter: &mut Painter) -> Size {
         for _ in 0..self.offset {
             painter.next_layer();

src/widget/position/max_size.rs

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

src/widget/position/mod.rs

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

src/widget/position/offset.rs

@@ -6,6 +6,10 @@ pub struct Offset {
 }
 
 impl Widget for Offset {
+    fn size_request(&self, requests: &mut SizeRequests, axis: Axis) -> Option<RequestedLen> {
+        requests.widget(&self.inner, axis)
+    }
+
     fn draw(&mut self, painter: &mut Painter) -> Size {
         painter
             .widget_at(&self.inner, UiRegion::FULL.offset(self.amt))

src/widget/position/pad.rs

@@ -6,6 +6,14 @@ pub struct Pad {
 }
 
 impl Widget for Pad {
+    fn size_request(&self, requests: &mut SizeRequests, axis: Axis) -> Option<RequestedLen> {
+        let padding = match axis {
+            Axis::X => self.padding.left + self.padding.right,
+            Axis::Y => self.padding.top + self.padding.bottom,
+        };
+        requests.inset(&self.inner, axis, padding)
+    }
+
     fn draw(&mut self, painter: &mut Painter) -> Size {
         // The inner's own alignment, not the near edge. This reports the
         // inner's size plus the padding, so where the box is that answer the

src/widget/position/scroll.rs

@@ -16,44 +16,45 @@ impl Widget for Scroll {
         let answer_len = painter
             .widget_at(&self.inner, PlaceDesc::WHOLE.fills())
             .len(self.axis);
-        let fixed = painter.to_px(answer_len.without_leftover(), self.axis);
+        let answer_px = painter.to_px(answer_len.without_leftover(), self.axis);
         self.container_len = container_len;
-        self.content_len = fixed.max(container_len);
+        self.content_len = answer_px.max(container_len);
 
         if self.snap_end {
             self.amt = self.content_len - self.container_len;
         }
         self.update_amt();
-        let align = painter.alignment()[self.axis];
+        // Reading the box in pixels above holds this drawing to that one
-        // Content of a fixed length that fits sits at the start of any box it
+        // length, so these two say where it holds more widely.
-        // 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
+        // Content of a fixed length that fits is handed the whole box below,
-        // the drawing holds for that length alone. One scrolled part way sits
+        // and nothing here reads the box again, so every longer box gives the
-        // where it is until the box shrinks past what is left of it. Kept to
+        // same drawing: it holds from the length the content needs upwards,
-        // the end, it moves with every length.
+        // and shrinking past that is what changes it. Where it sits in a box
-        let fixed_len = answer_len.is_px();
+        // longer than itself is not this widget's to say -- placing its
-        if fixed_len && self.content_len <= self.container_len && align == AxisAlign::NEG {
+        // answer in the whole box is its own alignment, and that placement is
-            painter.holds(self.axis, fixed..=Px::MAX);
+        // a fraction of the box, so it holds at every length too.
-        } else if fixed_len && !self.snap_end {
+        //
+        // One scrolled part way sits where it is until the box shrinks past
+        // what is left of it. Kept to the end, it moves with every length.
+        let answer_is_px = answer_len.is_px();
+        if answer_is_px && self.content_len <= self.container_len {
+            painter.holds(self.axis, answer_px..=Px::MAX);
+        } else if answer_is_px && !self.snap_end {
             let left = self.content_len - self.amt;
             painter.holds(self.axis, Px::MIN..=left);
         }
 
-        // Content shorter than the viewport has room to sit in, and where it
+        // Content that fills the viewport is the viewport, and is handed back
-        // sits is this widget's own alignment -- the same property that would
+        // as it came -- it has nothing to scroll through, so the clamp above
-        // have placed the whole scroll in a box longer than it.
+        // has already put `amt` at zero. Writing the same box as its own
-        let slack = (self.container_len - self.content_len).max(Px::ZERO);
+        // length in pixels is the same box in another form, and the two do
-        let anchor = slack.mul(align.rel());
+        // not round alike: a part centred in `rel 1` lands a step from one
-        // Content that fills the viewport and has not been scrolled is the
+        // centred in `px 900`, since halving a difference is not halving each
-        // viewport, and is handed back as it came. Writing the same box as
+        // part of it.
-        // its own length in pixels is the same box in another form, and the
+        let content = match self.content_len > self.container_len {
-        // 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 {
             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

@@ -8,72 +8,81 @@ pub struct Span {
 }
 
 impl Widget for Span {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
+    fn size_request(&self, requests: &mut SizeRequests, axis: Axis) -> Option<RequestedLen> {
-        let axis = self.dir.axis;
+        if axis != self.dir.axis {
-        // The row: this span's own box, as a length of the rel base its children
+            // A share can be hidden when the other axis has no room. Its
-        // are laid out against. Its start is nothing's business -- a slot is
+            // cross-axis length then contributes nothing to the drawn answer.
-        // a length from it -- so what this reads is the length alone.
+            return None;
-        let far = painter.region_len(axis);
-        let along = |from: Len, to: Len| match self.dir.sign {
-            Sign::Pos => UiSpan::new(from, to),
-            Sign::Neg => UiSpan::new(far - to, far - from),
-        };
-        // A length for every child before their final slots are chosen: from
-        // a hint where one says, and from drawing otherwise. The rel base passes
-        // through unchanged, so `rel(0.5)` is half the area this span was
-        // given whatever else is in it and wherever this child sits among
-        // them; what a drawn child is asked in is the room left from the
-        // cursor, because a text has to wrap at the width actually there.
-        let mut cursor = Len::rel_min();
-        let mut lens = Vec::with_capacity(self.children.len());
-        for child in &self.children {
-            let len = match painter.size_hint(child, axis) {
-                Some(len) => len,
-                None => {
-                    // Across itself the child sits where its own alignment
-                    // says, in the whole of the row: a span is what contains
-                    // its children there, and nothing divides that axis.
-                    let room = along(cursor, far).shifted_desc().on_axis(axis);
-                    painter.widget_at(child, room).len(axis)
         }
-            };
+        let mut total = RequestedLen::from(Len::from_parts(
-            cursor.px += len.px + self.gap;
+            Rel::ZERO,
-            cursor.rel += len.rel;
+            self.gap
-            lens.push(len);
+                .mul_int(self.children.len().saturating_sub(1) as i32),
+        ));
+        for child in &self.children {
+            let child = requests.widget(child, axis)?;
+            total = requests.sum(total, child);
+        }
+        Some(total)
     }
 
+    fn draw(&mut self, painter: &mut Painter) -> Size {
+        painter.with_requests(|painter, lens, values| self.layout(painter, lens, values))
+    }
+}
+
+impl Span {
+    fn layout(
+        &self,
+        painter: &mut Painter,
+        lens: &mut Vec<RequestedLen>,
+        values: &mut Vec<Px>,
+    ) -> Size {
+        let axis = self.dir.axis;
+        // The row this span lays its children out along, as a length of the
+        // rel base they are laid out against. Where it starts is nothing's
+        // business -- a slot is a length from there -- so what this reads is
+        // the length alone.
+        let row = painter.region_len(axis);
+        self.collect(painter, row, lens, true);
         let gaps = self
             .gap
             .mul_int(self.children.len().saturating_sub(1) as i32);
-        let total = lens.iter().fold(
+        let fixed = lens
+            .iter()
+            .try_fold(Len::from_parts(Rel::ZERO, gaps), |sum, len| {
+                Some(sum + len.linear()?.without_leftover())
+            });
+        if let Some(fixed) = fixed
+            && lens.iter().any(|len| len.has_leftover())
+            && !painter.longer_than(row, fixed, axis)
+        {
+            // With no share to assign, intrinsic drawings keep the remaining
+            // offer, including overflow. Their answer is only moved into a slot.
+            self.collect(painter, row, lens, false);
+        }
+        let nonlinear = lens.iter().any(|len| len.linear().is_none());
+        if nonlinear {
+            painter.allocate(lens, row - Len::from_parts(Rel::ZERO, gaps), axis, values);
+        }
+        let allocated = nonlinear.then_some(&values);
+        let total = match &allocated {
+            Some(allocated) => LayoutLen {
+                px: allocated.iter().fold(gaps, |sum, len| sum + *len),
+                ..LayoutLen::ZERO
+            },
+            None => lens.iter().fold(
                 LayoutLen {
                     px: gaps,
                     ..LayoutLen::ZERO
                 },
-            |sum, len| sum + *len,
+                |sum, len| sum + len.linear().unwrap(),
-        );
+            ),
-
-        // 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 = far - 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
-        // growing slower than the box, faster, or exactly with it -- are the
-        // sign of `room.rel`, which `through` already reads. What the
-        // generated oracle checks is the consequence, since which children
-        // exist at all turns on this.
-        let mut shares = false;
-        if total.leftover > Weight::ZERO {
-            shares = painter.to_px(room, axis) > Px::ZERO;
-            let holds = match shares {
-                true => Holds::from(Px::STEP..=Px::MAX),
-                false => Holds::from(Px::MIN..=Px::ZERO),
         };
-            painter.window_holds(axis, holds.through(room));
+        let all_fixed = total.without_leftover();
-        }
+        let room = row - all_fixed;
+        let any_leftover = total.leftover > Weight::ZERO;
+        let has_room = any_leftover && painter.longer_than(row, all_fixed, axis);
 
         // Across itself a span is as long as its longest child -- unless a
         // rule beside it gives that length outright, and then reading them
@@ -83,34 +92,47 @@ impl Widget for Span {
         let shrinks = !painter.has_exact_size(!axis);
         // What the fixed parts and the gaps before here take, which is a sum
         // of lengths and exact, and how much of the leftover weight is
-        // spoken for. A position is one from the other rather than a step
+        // spoken for. Both ends of a slot are read from those two rather
-        // from the last child: the share of the room is rounded, and taking
+        // than stepped from the last child: the share of the room is
-        // each from the one before it would carry every rounding along the
+        // rounded, and taking each end from the one before it would carry
-        // row.
+        // every rounding along the row.
-        let mut fixed = Len::rel_min();
+        let mut fixed = Len::ZERO;
         let mut taken = Weight::ZERO;
-        let mut start = Len::rel_min();
         let mut ortho = LayoutLen::ZERO;
-        let shared = |fixed: Len, taken: Weight| match taken == Weight::ZERO {
+        // Nothing divides the room where no child asked for any of it, and a
-            true => fixed,
+        // ratio of a whole of nothing has no answer.
-            false => fixed + room.scale(Rel::ratio(taken, total.leftover)),
+        let reached = |fixed: Len, taken: Weight| match any_leftover {
+            false => fixed,
+            true => fixed + room.scale(Rel::ratio(taken, total.leftover)),
+        };
+        for (index, (child, request)) in self.children.iter().zip(lens.iter()).enumerate() {
+            let len = match &allocated {
+                Some(allocated) => LayoutLen {
+                    px: allocated[index],
+                    ..LayoutLen::ZERO
+                },
+                None => request.linear().unwrap(),
+            };
+            let shares = match &allocated {
+                Some(_) => request.has_leftover(),
+                None => len.leftover > Weight::ZERO && has_room,
             };
-        for (child, &len) in self.children.iter().zip(&lens) {
             // A child asking for nothing but a part of what is left over,
             // when nothing is, is not drawn at all. One that also asked for
             // pixels or a fraction keeps those and overflows.
-            if len.is_only_leftover() && !shares {
+            if (len.is_only_leftover() && !has_room)
+                || (allocated.is_some() && shares && len.px == Px::ZERO)
+            {
                 painter.undraw(child);
                 fixed.px += self.gap;
-                start = shared(fixed, taken);
                 continue;
             }
-            let from = start;
+            let from = reached(fixed, taken);
-            if len.leftover > Weight::ZERO && shares {
+            if shares {
                 taken += len.leftover;
             }
             fixed += len.without_leftover();
-            start = shared(fixed, taken);
+            let to = reached(fixed, taken);
             // Along the row the span says where the child goes, and that slot
             // is the child's box outright rather than something to place an
             // answer inside again. A share is decided here and nowhere
@@ -118,16 +140,16 @@ impl Widget for Span {
             // it, since a text wraps at the width it is actually given. A
             // fixed child's slot is its own answer, so a drawing made in the
             // room is put there as it is, and one not made yet is made here.
-            let slot = along(from, start);
+            let slot = self.slot(row, from, to);
-            let mut place = slot.shifted_desc().fills().on_axis(axis);
+            let mut place = slot.shifted_desc().allocated().on_axis(axis);
-            if len.leftover > Weight::ZERO && shares {
+            if shares {
                 place = place.rel_base(axis, slot.len());
             }
             let used = painter.place_at(child, place).len(!axis);
             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;
@@ -136,26 +158,60 @@ impl Widget for Span {
                 }
             }
             fixed.px += self.gap;
-            start = shared(fixed, taken);
         }
 
-        // Carried whole rather than collapsed to one share: a span that sizes
+        // Discovery carries nested requests to the allocating ancestor. The
-        // from its children does not resolve `leftover`, it passes the weight up,
+        // draw still returns an ordinary Size for callers measuring content.
-        // so nesting spans divides the same space rather than re-dividing a
-        // share of it. Four `leftover(1)` children under two spans under one span
-        // get a quarter each, which collapsing to `leftover(1)` per level does
-        // not give. Resolution happens at the nearest ancestor with a length,
-        // and the root always has one.
-        let along = total;
         let ortho = match shrinks {
             true => ortho,
             false => LayoutLen::rel(1.0),
         };
-        Size::from_axis(axis, along, ortho)
+        Size::from_axis(axis, total, ortho)
     }
 }
 
 impl Span {
+    fn collect(
+        &self,
+        painter: &mut Painter,
+        row: Len,
+        lens: &mut Vec<RequestedLen>,
+        discover: bool,
+    ) {
+        let axis = self.dir.axis;
+        let mut cursor = Len::ZERO;
+        lens.clear();
+        for child in &self.children {
+            let request = if discover {
+                painter.size_request(child, axis)
+            } else {
+                painter.size_hint(child, axis).map(Into::into)
+            };
+            let len = match request {
+                Some(len) => len,
+                None => {
+                    let room = self.slot(row, cursor, row).shifted_desc().on_axis(axis);
+                    let len = painter.widget_at(child, room).len(axis);
+                    painter.measured_request(child, axis, len)
+                }
+            };
+            cursor += painter.minimum_request(&len, axis);
+            cursor.px += self.gap;
+            lens.push(len);
+        }
+    }
+
+    /// The stretch of the row between two distances from where this span
+    /// starts laying children out, as a span of its own box. A negative
+    /// direction lays out from the far end, so the same two distances mirror
+    /// in a row `row` long.
+    fn slot(&self, row: Len, from: Len, to: Len) -> UiSpan {
+        match self.dir.sign {
+            Sign::Pos => from.to(to),
+            Sign::Neg => (row - to).to(row - from),
+        }
+    }
+
     pub fn empty(dir: Dir) -> Self {
         Self {
             children: Vec::new(),

src/widget/position/stack.rs

@@ -8,6 +8,16 @@ pub struct Stack {
 }
 
 impl Widget for Stack {
+    fn size_request(&self, requests: &mut SizeRequests, axis: Axis) -> Option<RequestedLen> {
+        match self.size {
+            StackSize::Default => Some(LayoutLen::LEFTOVER.into()),
+            StackSize::Child(i) => match self.children.get(i) {
+                Some(child) => requests.widget(child, axis),
+                None => Some(LayoutLen::LEFTOVER.into()),
+            },
+        }
+    }
+
     fn draw(&mut self, painter: &mut Painter) -> Size {
         let sizing = match self.size {
             StackSize::Default => None,

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 undo && let Some((old, selection)) = self.text.history.pop() {
-            if 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)] {
+            for axis in Axis::BOTH {
-                if let Some(align) = align {
+                if let Some(align) = align[axis] {
                     widgets.set_alignment(id, axis, align);
                 }
             }
@@ -59,26 +59,70 @@ widget_trait! {
         }
     }
 
-    fn width(self, len: impl Into<LayoutLen>) -> impl WidgetIdFn<Rsc, WL::Widget> {
+    fn width(self, len: impl Into<SizeRequest>) -> impl WidgetIdFn<Rsc, WL::Widget> {
         let len = len.into();
         move |state| {
             let id = self.add(state);
             state
                 .ui_mut()
                 .widgets
-                .set_size_rule(id, Axis::X, SizeRule::Exact(len));
+                .set_size_rule(id, Axis::X, SizeRule::from(len));
             id
         }
     }
 
-    fn height(self, len: impl Into<LayoutLen>) -> impl WidgetIdFn<Rsc, WL::Widget> {
+    /// Answers at least this wide, whatever it drew: a rule beside the
+    /// widget, so what a row gives it is at least this even where the widget
+    /// itself wanted less. The box it draws in is untouched -- for that, see
+    /// [`MaxSize`].
+    fn min_width(self, len: impl Into<Len>) -> impl WidgetIdFn<Rsc, WL::Widget> {
+        let len = len.into();
+        move |state| {
+            let id = self.add(state);
+            state.ui_mut().widgets.set_min_len(id, Axis::X, len);
+            id
+        }
+    }
+
+    fn min_height(self, len: impl Into<Len>) -> impl WidgetIdFn<Rsc, WL::Widget> {
+        let len = len.into();
+        move |state| {
+            let id = self.add(state);
+            state.ui_mut().widgets.set_min_len(id, Axis::Y, len);
+            id
+        }
+    }
+
+    /// Puts this in a [`MaxSize`]: it is asked in the shorter of the cap and
+    /// the box that widget was given, and is as long as it used, held to the
+    /// cap. A widget rather than a rule because the box is whoever asked's to
+    /// decide -- see [`MaxSize`].
+    fn max_width(self, len: impl Into<Len>) -> impl WidgetFn<Rsc, MaxSize> {
+        let len = len.into();
+        move |state| MaxSize {
+            inner: self.add_strong(state),
+            x: Some(len),
+            y: None,
+        }
+    }
+
+    fn max_height(self, len: impl Into<Len>) -> impl WidgetFn<Rsc, MaxSize> {
+        let len = len.into();
+        move |state| MaxSize {
+            inner: self.add_strong(state),
+            x: None,
+            y: Some(len),
+        }
+    }
+
+    fn height(self, len: impl Into<SizeRequest>) -> impl WidgetIdFn<Rsc, WL::Widget> {
         let len = len.into();
         move |state| {
             let id = self.add(state);
             state
                 .ui_mut()
                 .widgets
-                .set_size_rule(id, Axis::Y, SizeRule::Exact(len));
+                .set_size_rule(id, Axis::Y, SizeRule::from(len));
             id
         }
     }

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

@@ -0,0 +1,80 @@
+use iris::{harness::Harness, prelude::*};
+use std::{
+    alloc::{GlobalAlloc, Layout, System},
+    cell::Cell,
+};
+
+struct Counting;
+thread_local! {
+    static COUNT: Cell<Option<usize>> = const { Cell::new(None) };
+}
+fn count() {
+    COUNT.with(|count| {
+        if let Some(n) = count.get() {
+            count.set(Some(n + 1));
+        }
+    });
+}
+// The wrapper preserves System's allocation and deallocation contracts;
+// observing calls here also counts allocations hidden inside layout helpers.
+unsafe impl GlobalAlloc for Counting {
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        count();
+        unsafe { System.alloc(layout) }
+    }
+    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
+        unsafe { System.dealloc(ptr, layout) }
+    }
+    unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, size: usize) -> *mut u8 {
+        count();
+        unsafe { System.realloc(ptr, layout, size) }
+    }
+}
+#[global_allocator]
+static ALLOCATOR: Counting = Counting;
+
+#[test]
+fn unchanged_tree_reuses_layout_storage() {
+    for deferred in [false, true] {
+        let mut h = Harness::new((600, 200));
+        let mut children: Vec<StrongWidget> = Vec::new();
+        for _ in 0..8 {
+            let a = rect(Color::RED).add(&mut h.rsc);
+            if deferred {
+                h.rsc
+                    .widgets_mut()
+                    .set_size_rule(a, Axis::X, leftover(1).clamp(20, 80).into());
+            }
+            let row = (a, rect(Color::BLUE))
+                .span(Dir::RIGHT)
+                .add_strong(&mut h.rsc);
+            children.push(row);
+        }
+        let root = h.rsc.widgets_mut().add_strong(Span {
+            children,
+            dir: Dir::DOWN,
+            gap: Px::ZERO,
+        });
+        h.state.root = Some(root);
+        h.frame();
+        let ids: Vec<_> = h.render.active.keys().copied().collect();
+        for frame in 0..8 {
+            for &id in &ids {
+                h.rsc.widgets_mut().mark_for_redraw(id);
+            }
+            h.resize((600 + frame % 2, 200));
+            h.frame();
+        }
+        COUNT.set(Some(0));
+        for frame in 0..100 {
+            for &id in &ids {
+                h.rsc.widgets_mut().mark_for_redraw(id);
+            }
+            h.resize((600 + frame % 2, 200));
+            h.frame();
+        }
+        let allocations = COUNT.replace(None).unwrap();
+        println!("deferred={deferred}: {allocations} allocations over 100 resize frames");
+        assert_eq!(allocations, 0);
+    }
+}

tests/cases/deferred.rs

@@ -0,0 +1,391 @@
+use std::{cell::Cell, rc::Rc};
+
+use iris::harness::{Harness, assert_corners};
+use iris::prelude::*;
+
+struct Counted {
+    draws: Rc<Cell<usize>>,
+}
+
+impl Widget for Counted {
+    fn draw(&mut self, painter: &mut Painter) -> Size {
+        self.draws.set(self.draws.get() + 1);
+        painter.px_size();
+        painter.primitive(RectPrimitive::color(Color::RED));
+        Size::LEFTOVER
+    }
+
+    fn size_hint(&self, _: Axis) -> Option<LayoutLen> {
+        Some(LayoutLen::LEFTOVER)
+    }
+}
+
+#[test]
+fn a_capped_share_returns_room_to_its_sibling() {
+    let mut h = Harness::new((300, 100));
+    let first = rect(Color::RED).max_width(80).add(&mut h.rsc);
+    let second = rect(Color::BLUE).add(&mut h.rsc);
+    h.set_root((first, second).span(Dir::RIGHT));
+    assert_corners!(h, first, (0, 0), (80, 100));
+    assert_corners!(h, second, (80, 0), (300, 100));
+    h.resize((100, 100));
+    h.frame();
+    assert_corners!(h, first, (0, 0), (50, 100));
+    assert_corners!(h, second, (50, 0), (100, 100));
+    h.resize((300, 100));
+    h.frame();
+    assert_corners!(h, first, (0, 0), (80, 100));
+    assert_corners!(h, second, (80, 0), (300, 100));
+}
+
+#[test]
+fn nested_shares_are_discovered_without_provisional_paint() {
+    let mut h = Harness::new((400, 100));
+    let draws = Rc::new(Cell::new(0));
+    let leaf = h.rsc.ui_mut().widgets.add_strong(Counted {
+        draws: draws.clone(),
+    });
+    let leaf_id = leaf.id();
+    let mut inner: StrongWidget = leaf;
+    for _ in 0..8 {
+        let sibling = rect(Color::BLUE).add_strong(&mut h.rsc);
+        inner = h.rsc.ui_mut().widgets.add_strong(Span {
+            children: vec![inner, sibling],
+            dir: Dir::RIGHT,
+            gap: Px::ZERO,
+        });
+    }
+    h.state.root = Some(inner);
+    h.frame();
+    assert_eq!(draws.get(), 1);
+    assert!(h.region(&leaf_id).is_some());
+    h.resize((800, 100));
+    h.frame();
+    assert_eq!(draws.get(), 2);
+}
+
+#[test]
+fn nested_bounds_are_resolved_in_the_outer_allocation() {
+    let mut h = Harness::new((300, 100));
+    let a = rect(Color::RED).max_width(40).add(&mut h.rsc);
+    let b = rect(Color::GREEN).max_width(60).add(&mut h.rsc);
+    let inner = (a, b).span(Dir::RIGHT).add(&mut h.rsc);
+    let tail = rect(Color::BLUE).add(&mut h.rsc);
+    h.set_root((inner, tail).span(Dir::RIGHT));
+    assert_corners!(h, a, (0, 0), (40, 100));
+    assert_corners!(h, b, (40, 0), (100, 100));
+    assert_corners!(h, tail, (100, 0), (300, 100));
+}
+
+#[test]
+fn request_edits_in_a_nested_child_reach_the_allocator() {
+    let mut h = Harness::new((300, 100));
+    let a = rect(Color::RED).max_width(80).add(&mut h.rsc);
+    let inner = (a,).span(Dir::RIGHT).add(&mut h.rsc);
+    let tail = rect(Color::BLUE).add(&mut h.rsc);
+    h.set_root((inner, tail).span(Dir::RIGHT));
+    h.rsc.ui_mut().widgets.get_mut(&a).unwrap().x = Some(Len::px(40.0));
+    h.frame();
+    assert_corners!(h, a, (0, 0), (40, 100));
+    assert_corners!(h, tail, (40, 0), (300, 100));
+}
+
+#[test]
+fn adding_a_bound_to_a_previously_unbounded_share_reallocates_the_row() {
+    for hinted in [true, false] {
+        let mut h = Harness::new((300, 100));
+        let a = if hinted {
+            rect(Color::RED).add_strong(&mut h.rsc).any()
+        } else {
+            h.rsc.widgets_mut().add_strong(Unhinted).any()
+        };
+        let id = a.id();
+        let b = rect(Color::BLUE).add(&mut h.rsc);
+        let mut row = Span::empty(Dir::RIGHT);
+        row.push(a);
+        row.push(b.add_strong(&mut h.rsc));
+        h.set_root(row);
+        h.resize((400, 100));
+        h.frame();
+        h.rsc
+            .widgets_mut()
+            .set_size_rule(id, Axis::X, SizeRule::Max(Len::px(80.0)));
+        h.frame();
+        assert_corners!(h, id, (0, 0), (80, 100));
+        assert_corners!(h, b, (80, 0), (400, 100));
+    }
+}
+
+#[test]
+fn a_deferred_comparison_can_compare_two_different_weights() {
+    let a = SizeRequest::from(leftover(1.0) + px(30.0)).min(leftover(2.0));
+    let b = SizeRequest::from(leftover(1.0)).clamp(px(20.0), px(100.0));
+    let mut h = Harness::new((60, 100));
+    let a = rect(Color::RED).width(a).add(&mut h.rsc);
+    let b = rect(Color::BLUE).width(b).add(&mut h.rsc);
+    h.set_root((a, b).span(Dir::RIGHT));
+    assert_corners!(h, a, (0, 0), (40, 100));
+    assert_corners!(h, b, (40, 0), (60, 100));
+    h.resize((300, 100));
+    h.frame();
+    assert_corners!(h, a, (0, 0), (200, 100));
+    assert_corners!(h, b, (200, 0), (300, 100));
+}
+
+#[test]
+fn a_length_expression_is_resolved_before_wrapping_text() {
+    let mut h = Harness::new((300, 500));
+    let text = wtext("one two three four five six seven eight nine ten")
+        .size(16)
+        .wrap(true)
+        .width(leftover(1).clamp(40, 80))
+        .add(&mut h.rsc);
+    let other = rect(Color::BLUE).add(&mut h.rsc);
+    h.set_root((text, other).span(Dir::RIGHT));
+    let box_ = h.region(&text).unwrap();
+    assert_eq!(box_.top_left.x, Px::ZERO);
+    assert_eq!(box_.bot_right.x, Px::from_int(80));
+    assert!(box_.bot_right.y - box_.top_left.y > Px::from_int(30));
+    assert_corners!(h, other, (80, 0), (300, 500));
+}
+
+#[test]
+fn relative_bounds_keep_the_allocators_base() {
+    let mut h = Harness::new((300, 100));
+    let head = rect(Color::BLUE).width(30).add(&mut h.rsc);
+    let bounded = rect(Color::RED)
+        .width(leftover(1).min(rel(0.25)))
+        .add(&mut h.rsc);
+    let tail = rect(Color::GREEN).add(&mut h.rsc);
+    h.set_root((head, bounded, tail).span(Dir::RIGHT));
+    assert_corners!(h, bounded, (30, 0), (105, 100));
+    assert_corners!(h, tail, (105, 0), (300, 100));
+    h.resize((400, 100));
+    h.frame();
+    assert_corners!(h, bounded, (30, 0), (130, 100));
+    assert_corners!(h, tail, (130, 0), (400, 100));
+}
+
+#[test]
+fn the_root_resolves_a_deferred_request_again_after_resize() {
+    let mut h = Harness::new((300, 100));
+    let bounded = rect(Color::RED)
+        .width(leftover(1).min(rel(0.25)))
+        .add(&mut h.rsc);
+    h.set_root(bounded);
+    assert_corners!(h, bounded, (112.5, 0), (187.5, 100));
+    h.resize((400, 100));
+    h.frame();
+    assert_corners!(h, bounded, (150, 0), (250, 100));
+}
+
+#[test]
+fn filling_a_stack_does_not_mean_its_sizing_child_was_already_allocated() {
+    let mut h = Harness::new((300, 100));
+    let child = rect(Color::RED).width(leftover(1).min(80)).add(&mut h.rsc);
+    let overlay = rect(Color::BLUE).add(&mut h.rsc);
+    let children: Vec<StrongWidget> =
+        vec![child.add_strong(&mut h.rsc), overlay.add_strong(&mut h.rsc)];
+    h.set_root(Stack {
+        children,
+        size: StackSize::Child(0),
+    });
+    assert_corners!(h, child, (110, 0), (190, 100));
+    assert_corners!(h, overlay, (110, 0), (190, 100));
+}
+
+struct Unhinted;
+impl Widget for Unhinted {
+    fn draw(&mut self, painter: &mut Painter) -> Size {
+        painter.px_size();
+        painter.primitive(RectPrimitive::color(Color::RED));
+        Size::LEFTOVER
+    }
+}
+
+#[test]
+fn bounds_also_apply_to_shares_discovered_by_drawing() {
+    let mut h = Harness::new((300, 100));
+    let a = h.rsc.widgets_mut().add_strong(Unhinted);
+    h.rsc
+        .widgets_mut()
+        .set_size_rule(a.id(), Axis::X, SizeRule::Max(Len::px(80.0)));
+    let id = a.id();
+    let b = rect(Color::BLUE).add_strong(&mut h.rsc);
+    let b_id = b.id();
+    h.state.root = Some(h.rsc.widgets_mut().add_strong(Span {
+        children: vec![a, b],
+        dir: Dir::RIGHT,
+        gap: Px::ZERO,
+    }));
+    h.frame();
+    assert_corners!(h, id, (0, 0), (80, 100));
+    assert_corners!(h, b_id, (80, 0), (300, 100));
+    h.resize((100, 100));
+    h.frame();
+    assert_corners!(h, id, (0, 0), (50, 100));
+    assert_corners!(h, b_id, (50, 0), (100, 100));
+}
+
+#[test]
+fn comparisons_with_a_known_order_remain_plain_lengths() {
+    assert_eq!(leftover(2).max(leftover(5)), SizeRequest::from(leftover(5)));
+    assert_eq!(leftover(2).min(leftover(5)), SizeRequest::from(leftover(2)));
+    assert_eq!(
+        (px(10) + rel(0.5)).max(px(30) + rel(0.5)),
+        SizeRequest::from(px(30) + rel(0.5))
+    );
+    assert_eq!(LayoutLen::px(10).clamp(20, 80), SizeRequest::from(20));
+}
+
+#[test]
+fn a_measured_nested_share_keeps_its_comparison_for_the_outer_span() {
+    let mut h = Harness::new((300, 100));
+    let a = h.rsc.widgets_mut().add_strong(Unhinted);
+    let a_id = a.id();
+    h.rsc
+        .widgets_mut()
+        .set_size_rule(a_id, Axis::X, SizeRule::Max(Len::px(80.0)));
+    let b = rect(Color::BLUE).add_strong(&mut h.rsc);
+    let b_id = b.id();
+    let inner = h.rsc.widgets_mut().add_strong(Span {
+        children: vec![a, b],
+        dir: Dir::RIGHT,
+        gap: Px::ZERO,
+    });
+    let c = rect(Color::GREEN).add_strong(&mut h.rsc);
+    let c_id = c.id();
+    h.state.root = Some(h.rsc.widgets_mut().add_strong(Span {
+        children: vec![inner, c],
+        dir: Dir::RIGHT,
+        gap: Px::ZERO,
+    }));
+    h.frame();
+    assert_corners!(h, a_id, (0, 0), (80, 100));
+    assert_corners!(h, b_id, (80, 0), (190, 100));
+    assert_corners!(h, c_id, (190, 0), (300, 100));
+    h.rsc
+        .widgets_mut()
+        .mark_for_redraw(h.state.root.as_ref().unwrap().id());
+    h.frame();
+    assert_corners!(h, c_id, (190, 0), (300, 100));
+}
+
+struct Natural;
+impl Widget for Natural {
+    fn draw(&mut self, painter: &mut Painter) -> Size {
+        painter.primitive(RectPrimitive::color(Color::RED));
+        Size::from_axis(Axis::X, LayoutLen::px(64), LayoutLen::px(64))
+    }
+    fn size_hint(&self, _: Axis) -> Option<LayoutLen> {
+        Some(LayoutLen::px(64))
+    }
+}
+
+#[test]
+fn relative_bounds_on_a_hinted_child_track_the_offer_before_its_declared_size() {
+    fn tree(h: &mut Harness) -> WidgetId {
+        let natural = h.rsc.widgets_mut().add_strong(Natural);
+        let id = natural.id();
+        h.rsc
+            .widgets_mut()
+            .set_size_rule(id, Axis::X, SizeRule::Max(Len::rel(0.75)));
+        h.rsc.widgets_mut().set_size_rule(
+            id,
+            Axis::Y,
+            SizeRule::Clamp {
+                min: Len::rel(0.25),
+                max: Len::rel(0.75),
+            },
+        );
+        let inner = h.rsc.widgets_mut().add_strong(Stack {
+            children: vec![natural],
+            size: StackSize::Child(0),
+        });
+        let inner_id = inner.id();
+        let fill = rect(Color::BLUE).add_strong(&mut h.rsc);
+        let overlay = h.rsc.widgets_mut().add_strong(Stack {
+            children: vec![fill, inner],
+            size: StackSize::Child(0),
+        });
+        let share = rect(Color::GREEN).add_strong(&mut h.rsc);
+        let bounded = rect(Color::GREEN).add_strong(&mut h.rsc);
+        h.rsc.widgets_mut().set_size_rule(
+            bounded.id(),
+            Axis::X,
+            SizeRule::Clamp {
+                min: Len::rel(0.25),
+                max: Len::rel(0.75),
+            },
+        );
+        let fixed = wtext("one line, overflowing whatever it is given")
+            .size(16)
+            .wrap(false)
+            .add_strong(&mut h.rsc);
+        h.state.root = Some(h.rsc.widgets_mut().add_strong(Span {
+            children: vec![share, bounded, fixed, overlay],
+            dir: Dir::LEFT,
+            gap: Px::from_int(8),
+        }));
+        h.rsc.widgets_mut().set_size_rule(
+            h.state.root.as_ref().unwrap().id(),
+            Axis::Y,
+            LayoutLen::rel(1).into(),
+        );
+        h.frame();
+        inner_id
+    }
+    let mut warm = Harness::new((1920, 1200));
+    let a = tree(&mut warm);
+    warm.resize((640, 900));
+    warm.frame();
+    let mut cold = Harness::new((640, 900));
+    let b = tree(&mut cold);
+    assert_eq!(warm.region(&a), cold.region(&b));
+}
+
+#[test]
+fn a_bound_can_extend_an_explicit_share_request() {
+    let mut h = Harness::new((300, 100));
+    let a = rect(Color::RED)
+        .width(leftover(1))
+        .min_width(100)
+        .add(&mut h.rsc);
+    let b = rect(Color::BLUE).add(&mut h.rsc);
+    h.set_root((a, b).span(Dir::RIGHT));
+    assert_corners!(h, a, (0, 0), (150, 100));
+    h.resize((120, 100));
+    h.frame();
+    assert_corners!(h, a, (0, 0), (100, 100));
+    assert_corners!(h, b, (100, 0), (120, 100));
+}
+
+#[test]
+fn moving_scroll_content_preserves_its_resolved_expression_size() {
+    let mut h = Harness::new((300, 300));
+    let leaf = rect(Color::BLUE).add_strong(&mut h.rsc);
+    let leaf_id = leaf.id();
+    let content = h.rsc.widgets_mut().add_strong(Stack {
+        children: vec![leaf],
+        size: StackSize::Child(0),
+    });
+    let content_id = content.id();
+    h.rsc
+        .widgets_mut()
+        .set_size_rule(content_id, Axis::Y, leftover(1).min(120).into());
+    let scroll = h
+        .rsc
+        .widgets_mut()
+        .add_strong(Scroll::new(content, Axis::Y));
+    let scroll_id = scroll.id();
+    h.state.root = Some(scroll);
+    for _ in 0..3 {
+        h.rsc.widgets_mut().mark_for_redraw(scroll_id);
+        h.frame();
+        assert_corners!(h, content_id, (0, 90), (300, 210));
+        assert_corners!(h, leaf_id, (0, 90), (300, 210));
+    }
+    h.resize((300, 600));
+    h.frame();
+    assert_corners!(h, leaf_id, (0, 240), (300, 360));
+}

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().mark_for_redraw(wide);
-            h.rsc.widgets_mut().get_dyn_mut(narrow);
+            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.0) + LayoutLen::LEFTOVER, 400),
+        (LayoutLen::px(500.0) + LayoutLen::LEFTOVER, 500),
+        (LayoutLen::rel(0.5) + LayoutLen::LEFTOVER, 400),
+        (LayoutLen::rel(2.0) + LayoutLen::LEFTOVER, 800),
+        (LayoutLen::px(500.0), 500),
+    ] {
+        let want = Px::from_int(want);
+        for asked in Asked::ALL {
+            assert_eq!(asked.width(rule), want, "{rule:?} asked {asked:?}");
+        }
+    }
+}
+
+/// Which of the two is longer is a question in pixels, so the box is decided
+/// again wherever the answer can change: a window that crosses the length the
+/// pixels ask for, and the rule itself crossing it while the window holds
+/// still. The first is a range the drawing holds for; the second cannot be
+/// seen in what the widget declares, since a share declares nothing either
+/// way, so it reaches the parent as a length only the parent can resolve.
+#[test]
+fn a_share_past_the_box_is_decided_again_on_either_side_of_the_crossing() {
+    // At the root as well as under a parent: the comparison is the same one,
+    // and nothing above the root will make it again on its behalf, so the
+    // range it holds for is the root's own.
+    for wrapped in [false, true] {
+        let mut h = Harness::new((400, 200));
+        let probe = rect(Color::RED).add(&mut h.rsc);
+        h.set_len(probe, Axis::X, LayoutLen::px(500.0) + LayoutLen::LEFTOVER);
+        match wrapped {
+            true => h.set_root(probe.wrapper()),
+            false => h.set_root(probe),
+        }
+        let width = |h: &Harness| h.region(&probe).unwrap().size().x;
+        assert_eq!(width(&h), Px::from_int(500), "wrapped: {wrapped}");
+
+        h.resize((900, 200));
+        h.frame();
+        assert_eq!(width(&h), Px::from_int(900), "wrapped: {wrapped}");
+
+        h.resize((400, 200));
+        h.frame();
+        assert_eq!(width(&h), Px::from_int(500), "wrapped: {wrapped}");
+
+        h.set_len(probe, Axis::X, LayoutLen::px(50.0) + LayoutLen::LEFTOVER);
+        h.frame();
+        assert_eq!(width(&h), Px::from_int(400), "wrapped: {wrapped}");
+
+        h.set_len(probe, Axis::X, LayoutLen::px(500.0) + LayoutLen::LEFTOVER);
+        h.frame();
+        assert_eq!(width(&h), Px::from_int(500), "wrapped: {wrapped}");
+    }
+}
+
 #[test]
 fn a_child_drawn_twice_moves_once() {
     let mut h = Harness::new((400, 200));
@@ -626,7 +756,7 @@ fn only_a_pure_leftover_child_disappears_when_nothing_is_left() {
     let mut h = Harness::new((100, 20));
     let fixed = rect(Color::RED).width(100).add(&mut h.rsc);
     let mixed = rect(Color::BLUE)
-        .width(LayoutLen::px(20) + LayoutLen::LEFTOVER)
+        .width(LayoutLen::px(20.0) + LayoutLen::LEFTOVER)
         .add(&mut h.rsc);
     h.set_root((fixed, mixed).span(Dir::RIGHT));
 
@@ -858,3 +988,131 @@ 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));
+}
+
+/// A bound is a rule about what a widget answers: it holds the length that
+/// reaches whoever asked and leaves the box alone. Here the content is 400
+/// wide in a 250 window, so a cap cuts what the row reports and a floor
+/// raises it, while the rects inside stay where the 250 box put them.
+#[test]
+fn a_bound_holds_what_a_widget_answers() {
+    let row = |rule: SizeRule| {
+        let mut h = Harness::new((250, 200));
+        let left = rect(Color::RED).width(200).add(&mut h.rsc);
+        let right = rect(Color::BLUE).width(200).add(&mut h.rsc);
+        let row = (left, right).span(Dir::RIGHT).add(&mut h.rsc);
+        h.rsc.widgets_mut().set_size_rule(row, Axis::X, rule);
+        h.set_root(row);
+        (
+            h.region(&row).unwrap().size().x,
+            h.region(&left).unwrap().size().x,
+        )
+    };
+    let (capped, left) = row(SizeRule::Max(Len::px(300.0)));
+    assert_eq!(capped, Px::from_int(300), "the cap, not the 400 drawn");
+    assert_eq!(left, Px::from_int(200), "the box the children were given");
+
+    let (floored, _) = row(SizeRule::Min(Len::px(600.0)));
+    assert_eq!(floored, Px::from_int(600), "the floor, not the 400 drawn");
+
+    let (free, _) = row(SizeRule::Free);
+    assert_eq!(free, Px::from_int(400), "what it drew");
+}
+
+/// A cap on the box is `MaxSize`, which asks its child in the shorter of the
+/// cap and its own box. That is the box a text wraps at and a scroll takes
+/// its viewport from, so it cannot be had by holding the answer.
+#[test]
+fn a_cap_widget_asks_its_child_in_the_shorter_box() {
+    let mut h = Harness::new((400, 200));
+    // A fraction of its box, so it says what box it was asked in.
+    let fills = rect(Color::RED).width(rel(1.0)).add(&mut h.rsc);
+    let capped = fills.max_width(300).add(&mut h.rsc);
+    h.set_root(capped);
+
+    assert_eq!(h.region(&fills).unwrap().size().x, Px::from_int(300));
+    assert_eq!(
+        h.region(&capped).unwrap().size().x,
+        Px::from_int(300),
+        "as long as its child used"
+    );
+
+    // A child that asked for a share takes the box the cap allows, and the
+    // share itself passes up: whoever divides one is this widget's parent.
+    let mut h = Harness::new((400, 200));
+    let share = rect(Color::RED).add(&mut h.rsc);
+    let capped = share.max_width(300).add(&mut h.rsc);
+    h.set_root(capped);
+
+    assert_eq!(h.region(&share).unwrap().size().x, Px::from_int(300));
+    assert_eq!(h.region(&capped).unwrap().size().x, Px::from_int(400));
+}
+
+/// Which of the cap and the box is shorter is a question in pixels, so it is
+/// asked again wherever the answer can change -- and the widget asking it is
+/// drawn again whenever its own box is, which is what keeps the two in step.
+#[test]
+fn a_cap_widget_is_decided_again_on_either_side_of_the_crossing() {
+    let mut h = Harness::new((400, 200));
+    let probe = rect(Color::RED).add(&mut h.rsc);
+    h.set_root(probe.max_width(300));
+    let width = |h: &Harness| h.region(&probe).unwrap().size().x;
+    assert_eq!(width(&h), Px::from_int(300));
+
+    h.resize((250, 200));
+    h.frame();
+    assert_eq!(
+        width(&h),
+        Px::from_int(250),
+        "its box, which is under the cap"
+    );
+
+    h.resize((400, 200));
+    h.frame();
+    assert_eq!(width(&h), Px::from_int(300));
+}
+
+/// A fraction in a cap is a fraction of the box the widget capping it was
+/// given, which is the box a declared length of its own would be a fraction
+/// of -- not of the window, and not of what the cap itself decided.
+#[test]
+fn a_cap_is_a_fraction_of_the_box_it_was_given() {
+    let mut h = Harness::new((400, 200));
+    let probe = rect(Color::RED).add(&mut h.rsc);
+    h.set_root(probe.max_width(Len::rel(0.5)).pad(Padding::uniform(50)));
+
+    // Half of the 300 left by the padding, not half of the window.
+    assert_eq!(h.region(&probe).unwrap().size().x, Px::from_int(150));
+}
+
+/// A cap is a promise about the length as well as the box: a widget whose
+/// content is longer than the box it was given reports what it drew, and the
+/// cap holds that down even though it never decided the box.
+#[test]
+fn a_cap_holds_an_answer_that_overflowed_its_box() {
+    let mut h = Harness::new((250, 200));
+    let left = rect(Color::RED).width(200).add(&mut h.rsc);
+    let right = rect(Color::BLUE).width(200).add(&mut h.rsc);
+    let row = (left, right).span(Dir::RIGHT).add(&mut h.rsc);
+    h.rsc.widgets_mut().set_max_len(row, Axis::X, 300.into());
+    h.set_root(row);
+
+    // The box is the 250 window, which the cap of 300 leaves alone, and the
+    // row draws 400 of it. Its answer is the cap, and the window centres it.
+    assert_corners!(h, row, (-25, 0), (275, 200));
+}

tests/cases/plan.rs

@@ -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
+/// No simplification is larger, which is the half of "the shrinker stops" a
-/// fixed point instead of circling. A shrinker that can return to a tree it
+/// widget count can see. Most are not smaller either -- a dropped alignment
-/// has already tried does not stop.
+/// 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 {
+    let root = Layered { children }.add(&mut h.rsc);
-        children,
-        _revision: 0,
-    }
-    .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());
@@ -125,7 +120,7 @@ fn moving_an_ordinary_subtree_remaps_its_mask() {
     let active = &h.render.active[&masked.id()];
     assert_eq!(
         h.rsc.ui().masks[active.mask.idx()].region,
-        UiRegion::new(UiSpan::new(Len::px(150.0), Len::rel_max()), UiSpan::FULL,)
+        UiRegion::new(UiSpan::new(Len::px(150.0), Len::FULL), UiSpan::FULL,)
     );
     assert_corners!(h, inner, (150, 0), (400, 200));
 }
@@ -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
+    // Marked with nothing about it changed, and it reports the same size
-    // widget returns the same size, so the parent has nothing to lay out.
+    // either way, so the parent has nothing to lay out.
-    let _ = h.rsc.widgets_mut().get_dyn_mut(first.id());
+    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| {
+        assert_eq!(
-            let active = &h.render.active[&id];
+            mask_bounds(&warm, warm.render.active[&leaf.id()].mask),
-            let mask = &h.rsc.ui().masks[active.mask.idx()];
+            mask_bounds(&cold, cold.render.active[&other.id()].mask)
-            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()));
     }
 }
 
@@ -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| {
+            assert_eq!(
-                let active = &h.render.active[&id];
+                mask_bounds(&warm, warm.render.active[&leaf.id()].mask),
-                let mask = &h.rsc.ui().masks[active.mask.idx()];
+                mask_bounds(&cold, cold.render.active[&other.id()].mask)
-                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()));
         }
     }
 }
@@ -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()];
+        assert_eq!(mask_bounds(&h, mask), h.region(&masked).unwrap());
-        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_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
@@ -161,3 +161,26 @@ fn content_that_fits_is_placed_in_the_viewport_and_not_in_the_window() {
     assert_corners!(h, scroll, (0, 100), (400, 400));
     assert_corners!(h, inner, (0, 225), (400, 275));
 }
+
+/// A cap narrows the box the widget is asked in, which is what a scroll
+/// measures its viewport from: the content scrolls within the cap rather than
+/// within the room the cap was cut from.
+#[test]
+fn a_capped_scroll_takes_its_viewport_from_the_cap() {
+    let mut h = Harness::new((400, 200));
+    let top = rect(Color::RED).height(200).add(&mut h.rsc);
+    let bottom = rect(Color::BLUE).height(200).add(&mut h.rsc);
+    let scroll = (top, bottom).span(Dir::DOWN).scrollable().add(&mut h.rsc);
+    let capped = scroll.max_height(100).add(&mut h.rsc);
+    h.set_root(capped);
+    h.move_to((200, 50));
+
+    // 400 of content in a viewport of 100, so 300 to scroll and the end
+    // showing: the top is 300 above the box, which the window centres.
+    assert_eq!(h.region(&scroll).unwrap().size().y, Px::from_int(100));
+    assert_corners!(h, top, (0, -250), (400, -50));
+
+    h.scroll((0, 1));
+    h.frame();
+    assert_corners!(h, top, (0, -200), (400, 0));
+}

tests/cases/unsettled.rs

@@ -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 wrapped = wtext("Wrapping shapes")
-    let sized = wrapped.width(76).add(&mut h.rsc);
+        .size(16)
-    let aligned = sized;
+        .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![
+    vec![plain.id(), wrapped.id(), stack.id(), root.id()]
-        plain.id(),
-        wrapped.id(),
-        sized.id(),
-        aligned.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();
+    assert_same_regions(&warm, &ids, &cold, &cold_ids);
-    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"));
 }
 
-/// 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 inner = (text,).span(Dir::RIGHT).sized((189, 176)).add(&mut h.rsc);
-    let sized = inner.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![
+    vec![text.id(), inner.id(), filler.id(), root.id()]
-        text.id(),
-        aligned.id(),
-        inner.id(),
-        sized.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();
+    assert_same_regions(&warm, &ids, &cold, &cold_ids);
-    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"));
 }
 
-/// 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));
+    h.state.root = Some(span.add_strong(&mut h.rsc));
-    (
+    (vec![wrapped.id(), plain.id(), span.id()], span)
-        vec![wrapped.id(), plain.id(), span.id(), aligned.id()],
-        span_handle,
-    )
 }
 
 #[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();
+    assert_same_regions(&warm, &ids, &cold, &cold_ids);
-    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"));
 }
 
-/// 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 = rect(Color::RED).width(87).add(&mut h.rsc);
-    let fixed = block.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();
+    assert_same_regions(&warm, &ids, &cold, &cold_ids);
-    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"));
 }
 
 /// 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();
+    assert_same_regions(&warm, &ids, &cold, &cold_ids);
-    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"));
 }
 
 /// 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();
+    assert_same_regions(&warm, &ids, &cold, &cold_ids);
-    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"));
 }
 
 /// 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();
+    assert_same_regions(&warm, &ids, &cold, &cold_ids);
-    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"));
 }
 
 const PARAGRAPH: &str = "Wrapping shapes one source into as many lines as the \
@@ -1067,3 +1024,32 @@ fn resizing_under_a_short_scroll_snaps_its_window_tall_content_again() {
 
     assert_same_regions(&warm, &ids, &cold, &cold_ids);
 }
+
+/// A scroll clamps its position against the box it is drawn in, so drawing it
+/// once at one viewport and again at another writes state the second draw then
+/// reads. That the answer is still the one a cold layout gives is a property
+/// of the clamp, not something the layout enforces.
+#[test]
+fn a_scrolled_view_resized_lands_where_a_cold_layout_puts_it() {
+    for amt in [10.0, 40.0, 90.0, 140.0] {
+        let mut warm = Harness::new((100, 100));
+        let (_, warm_scroll) = plant_wider(&mut warm, 100.0);
+        warm.move_to((50.0, 50.0));
+        warm.scroll((-amt, 0.0));
+        warm.frame();
+        warm.resize((160, 100));
+        warm.frame();
+
+        let mut cold = Harness::new((160, 100));
+        let (_, cold_scroll) = plant_wider(&mut cold, 100.0);
+        cold.move_to((50.0, 50.0));
+        cold.scroll((-amt, 0.0));
+        cold.frame();
+
+        assert_eq!(
+            warm.region(&warm_scroll),
+            cold.region(&cold_scroll),
+            "scrolled by {amt} then widened"
+        );
+    }
+}

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 adapter = gpu::adapter()?;
-    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()?;
     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/deferred_generated.rs

@@ -0,0 +1,67 @@
+#[path = "scenario/mod.rs"]
+mod scenario;
+
+use iris::prelude::*;
+use iris::random::{Edits, Plan, plan};
+
+fn check_requests(edit: impl Fn(&mut Plan) + Sync) {
+    let count = scenario::env("IRIS_DEFERRED_SEEDS", 20_u64);
+    let depth = scenario::env("IRIS_DEFERRED_DEPTH", 4_usize);
+    let seeds = std::env::var("IRIS_DEFERRED_SEED")
+        .ok()
+        .and_then(|seed| seed.parse().ok())
+        .map_or_else(|| (1..=count).collect(), |seed| vec![seed]);
+    scenario::over_seeds(seeds, |seed| {
+        let mut grown = plan(seed, depth, &Edits::default());
+        edit(&mut grown);
+        for case in scenario::ALL {
+            if let Some(how) = scenario::diverges(&grown, case, seed) {
+                panic!(
+                    "request seed {seed} depth {depth} after {}: {how}",
+                    case.name()
+                );
+            }
+        }
+    });
+}
+
+#[test]
+fn deferred_requests_agree_warm_and_cold() {
+    check_requests(|grown| {
+        let mut index = 0;
+        grown.walk_mut(&mut |node| {
+            if let Some(rules) = &mut node.size {
+                for axis in Axis::BOTH {
+                    index += 1;
+                    rules[axis] = match index % 7 {
+                        0 => leftover(1).clamp(20, 120).into(),
+                        1 => leftover(1).min(rel(0.5)).into(),
+                        2 => (leftover(1) + px(30)).min(leftover(2)).into(),
+                        _ => rules[axis].clone(),
+                    };
+                }
+            }
+        });
+    });
+}
+
+#[test]
+fn relative_intrinsic_bounds_agree_warm_and_cold() {
+    check_requests(|grown| {
+        grown.walk_mut(&mut |node| {
+            if let Some(rules) = &mut node.size {
+                for axis in Axis::BOTH {
+                    rules[axis] = match rules[axis] {
+                        SizeRule::Min(_) => SizeRule::Min(Len::rel(0.25)),
+                        SizeRule::Max(_) => SizeRule::Max(Len::rel(0.75)),
+                        SizeRule::Clamp { .. } => SizeRule::Clamp {
+                            min: Len::rel(0.25),
+                            max: Len::rel(0.75),
+                        },
+                        ref rule => rule.clone(),
+                    };
+                }
+            }
+        });
+    });
+}

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
+    let adapter = gpu::adapter()?;
-    // 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()?;
     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,
+/// The seeds the ordinary tests take: a corpus rather than a set of
-/// which a `Scroll` fixed point once settled differently on; and 20, which
+/// regression cases, since a seed names a tree only for as long as the
-/// caught a locally redrawn widget being placed twice in the box its parent
+/// generator draws the same things in the same order. Adding images to the
-/// had already placed it in.
+/// 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 {
+/// A test per case, and the list of which cases have one, from the same
-    ($name:ident, $case:expr) => {
+/// 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!(
+cases! {
-    many_widgets_redrawing_at_once_leaves_every_box_where_it_was,
+    many_widgets_redrawing_at_once_leaves_every_box_where_it_was = Case::RepaintSome,
-    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,
-case!(
+    a_resize_and_a_repaint_land_where_starting_that_way_would = Case::ResizeRepaint,
-    everything_redrawing_at_once_leaves_every_box_where_it_was,
+    a_size_change_after_a_resize_lands_the_same_way = Case::ResizeSize,
-    Case::Repaint
+    a_resize_after_a_size_change_lands_the_same_way = Case::SizeResize,
-);
+    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,
-    a_resize_lands_where_starting_at_that_size_would,
+    an_alignment_change_lands_where_growing_it_that_way_would = Case::Align,
-    Case::Resize
+    giving_and_taking_a_movable_region_rebuilds_what_resolves_it = Case::RegionNode,
-);
+    reordering_a_span_lands_where_growing_it_that_way_would = Case::Reorder,
-case!(
+}
-    a_resize_and_a_repaint_land_where_starting_that_way_would,
+
-    Case::ResizeRepaint
+/// The shuffles are one test between them, so they are the only cases `ALL`
-);
+/// may hold without a test of their own.
-case!(
+#[test]
-    a_size_change_after_a_resize_lands_the_same_way,
+fn every_case_runs_without_the_long_scan() {
-    Case::ResizeSize
+    for case in ALL {
-);
+        assert!(
-case!(
+            NAMED.contains(&case) || matches!(case, Case::Shuffle(_)),
-    a_size_change_lands_where_growing_it_that_way_would,
+            "{} runs only in the long seed scan; give it a case here",
-    Case::Size
+            case.name()
-);
-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
         );
+    }
+}
 
 #[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

@@ -13,15 +13,40 @@
 //!
 //! `IRIS_PHASE` is `cold`, `repaint`, `many`, `size`, `scroll`, `resize`, or
 //! `all`. `IRIS_SEED`, `IRIS_DEPTH`, and `IRIS_FRAMES` select the load, and
-//! `IRIS_DIRTY` how many widgets `many` marks at once.
+//! `IRIS_DIRTY` how many widgets `many` marks at once. `IRIS_UNBOUNDED=1`
+//! removes intrinsic bounds while preserving the rest of the generated tree.
 
 use iris::harness::Harness;
 use iris::prelude::*;
-use iris::random::{Edits, Tree, grow};
+use iris::random::{Edits, Tree, build, plan};
 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 +62,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());
+    harness.rsc.widgets_mut().mark_for_redraw(root.id());
-    let _ = harness.rsc.widgets_mut().get_dyn_mut(leaf.id());
+    harness.rsc.widgets_mut().mark_for_redraw(leaf.id());
     harness.frame();
 
     let report = diagnostics::take();
@@ -101,9 +126,25 @@ fn rig_edits() -> Edits {
     }
 }
 
+fn fixture(harness: &mut Harness, seed: u64, depth: usize) -> (StrongWidget, Tree) {
+    let mut plan = plan(seed, depth, &rig_edits());
+    if env("IRIS_UNBOUNDED", 0_u8) != 0 {
+        plan.walk_mut(&mut |node| {
+            if let Some(rules) = &mut node.size {
+                for axis in Axis::BOTH {
+                    if rules[axis].bound() != Bound::ANY {
+                        rules[axis] = SizeRule::Free;
+                    }
+                }
+            }
+        });
+    }
+    build(&mut harness.rsc, &plan)
+}
+
 fn warm(seed: u64, depth: usize) -> (Harness, Tree) {
     let mut harness = Harness::new(OUTPUT);
-    let (root, tree) = grow(&mut harness.rsc, seed, depth, &rig_edits());
+    let (root, tree) = fixture(&mut harness, seed, depth);
     harness.state.root = Some(root);
     harness.frame();
     println!(
@@ -185,7 +226,7 @@ fn layout_cost() {
 
     if selected("cold") {
         let mut harness = Harness::new(OUTPUT);
-        let (root, tree) = grow(&mut harness.rsc, seed, depth, &rig_edits());
+        let (root, tree) = fixture(&mut harness, seed, depth);
         harness.state.root = Some(root);
         println!(
             "fixture: seed {seed}, depth {depth}, {} widgets",
@@ -195,7 +236,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 +243,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 +258,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 +291,21 @@ 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);
     }
 }
+
+#[cfg(feature = "layout-diagnostics")]
+#[test]
+fn repainting_measured_text_does_not_invalidate_its_span() {
+    use iris::core::layout_diagnostics as diag;
+
+    let mut h = Harness::new((400, 200));
+    let text = wtext("a paragraph that fits").wrap(true).add(&mut h.rsc);
+    h.set_root((text, wtext("another paragraph")).span(Dir::DOWN));
+    let _ = diag::take();
+    h.rsc.widgets_mut().mark_for_redraw(text);
+    h.frame();
+    let report = diag::take();
+    assert_eq!(report.distinct_widgets(), 1);
+    assert_eq!(report.hot_widgets()[0].id, text.id());
+}

tests/layout_dump.rs

@@ -11,7 +11,8 @@
 //! it is not drawn.
 
 use iris::harness::Harness;
-use iris::random::{Edits, grow};
+use iris::prelude::{Axis, Bound, SizeRule};
+use iris::random::{Edits, build, plan};
 
 fn env<T: std::str::FromStr>(name: &str, fallback: T) -> T {
     std::env::var(name)
@@ -28,7 +29,19 @@ fn every_cold_layout_is_printed() {
     let mut out = String::new();
     for seed in 1..=seeds {
         let mut harness = Harness::new((1920.0, 1200.0));
-        let (root, tree) = grow(&mut harness.rsc, seed, depth, &Edits::default());
+        let mut plan = plan(seed, depth, &Edits::default());
+        if std::env::var_os("IRIS_DUMP_UNBOUNDED").is_some() {
+            plan.walk_mut(&mut |node| {
+                if let Some(rules) = &mut node.size {
+                    for axis in Axis::BOTH {
+                        if rules[axis].bound() != Bound::ANY {
+                            rules[axis] = SizeRule::Free;
+                        }
+                    }
+                }
+            });
+        }
+        let (root, tree) = build(&mut harness.rsc, &plan);
         harness.state.root = Some(root);
         harness.frame();
         for (index, id) in tree.ids.iter().enumerate() {

tests/revision_cost.rs

@@ -1,19 +1,22 @@
-//! What a resize frame costs and what it holds, on a tree the revision before
+//! Text-layout workloads with stable paragraphs for comparisons across revisions.
-//! #16 also builds.
+//! PR #19's base uses the older spelling of the fixed 40-pixel width and has
-//!
+//! no diagnostics. The random generator changed with layout, so it cannot
-//! Deliberately written in the API subset `43ce8c7` and this branch share, so
+//! provide the same workload across the full PR.
-//! the same source can be dropped into an old worktree and measured there:
-//! that is the only like-for-like comparison with the code the retained
-//! layout replaced. The random tree cannot carry one, because the generator
-//! itself changed with the work.
 //!
 //!     ROWS=40 FRAMES=500 cargo test --release --test revision_cost \
 //!       -- --ignored --nocapture resize_cost
+//!     PHASE=edit ROWS=40 FRAMES=2000 cargo test --release --test revision_cost \
+//!       -- --ignored --nocapture text_updates_cost
 //!     ROWS=2000 cargo test --release --test revision_cost \
 //!       -- --ignored --nocapture text_memory
 //!
-//! Wall time on this machine varies with CPU frequency; take the number from
+//! `text_updates_cost` selects idle, repaint, edit, or scroll with `PHASE`.
-//! `perf stat -e instructions:u` on the test binary directly.
+//! It alternates a short suffix for edits so later frames do not get a longer
+//! paragraph than earlier ones. These are CPU fixtures, with no GPU submission.
+//!
+//! Use repeated `perf stat -e instructions:u` runs on the executable directly;
+//! process totals include font loading and the cold frame, so compare identical
+//! row and frame counts. Wall time on this machine is not a stable comparison.
 
 use iris::harness::Harness;
 use iris::prelude::*;
@@ -137,9 +140,10 @@ fn resize_cost() {
         println!("paragraph {at}: {:?}", h.region(id));
     }
 
-    // Two widths in turn is the friendly case for anything that remembers an
+    // The sweep cycles 256 widths, avoiding the two-width cache-friendly case.
-    // answer, so `SWEEP=1` never repeats one -- a drag rather than a toggle.
     let sweep = env("SWEEP", 0_usize) != 0;
+    #[cfg(feature = "layout-diagnostics")]
+    let _ = iris::core::layout_diagnostics::take();
     let mut elapsed = Vec::with_capacity(frames);
     for frame in 0..frames {
         let narrower = match sweep {
@@ -151,6 +155,11 @@ fn resize_cost() {
         h.frame();
         elapsed.push(start.elapsed().as_secs_f64() * 1000.0);
     }
+    #[cfg(feature = "layout-diagnostics")]
+    print!(
+        "{}",
+        iris::core::layout_diagnostics::take().per_frame(frames)
+    );
     elapsed.sort_by(|a, b| a.partial_cmp(b).unwrap());
     println!(
         "resize: {frames} frames, min {:.3} ms, median {:.3} ms, p99 {:.3} ms, \
@@ -194,10 +203,73 @@ 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();
     }
     report("after settling");
 }
+
+#[test]
+#[ignore = "measurement, not a check"]
+fn text_updates_cost() {
+    let rows = env("ROWS", 40_usize);
+    let frames = env("FRAMES", 1000_usize);
+    let phase = env("PHASE", String::from("edit"));
+    assert!(rows > 0 && frames > 0);
+    assert!(["idle", "repaint", "edit", "scroll"].contains(&phase.as_str()));
+    let mut h = Harness::new(OUTPUT);
+    let mut rng = Rng(1);
+    let mut col = Span::empty(Dir::DOWN);
+    let first = wtext(words(&mut rng, 12, 52))
+        .size(16)
+        .wrap(true)
+        .add(&mut h.rsc);
+    col.push(first.add_strong(&mut h.rsc));
+    for _ in 1..rows {
+        col.push(
+            wtext(words(&mut rng, 12, 52))
+                .size(16)
+                .wrap(true)
+                .add_strong(&mut h.rsc),
+        );
+    }
+    let root = col.scrollable().add(&mut h.rsc);
+    h.set_root(root);
+    #[cfg(feature = "layout-diagnostics")]
+    let _ = iris::core::layout_diagnostics::take();
+    let original = h.rsc[first].content.to_string();
+    let alternate = format!("{original} another word");
+    let start = Instant::now();
+    for frame in 0..frames {
+        match phase.as_str() {
+            "idle" => {}
+            "repaint" => {
+                let _ = h.rsc.widgets_mut().get_dyn_mut(first.id());
+            }
+            "edit" => {
+                h.rsc[first].content.clear();
+                h.rsc[first].content.push_str(if frame % 2 == 0 {
+                    &alternate
+                } else {
+                    &original
+                });
+            }
+            "scroll" => h.rsc[root].scroll(if frame % 2 == 0 { -12.0 } else { 12.0 }),
+            _ => unreachable!(),
+        }
+        h.frame();
+    }
+    println!(
+        "{phase}: {rows} rows, {frames} frames, {:.1} ms",
+        start.elapsed().as_secs_f64() * 1000.0
+    );
+    #[cfg(feature = "layout-diagnostics")]
+    print!(
+        "{}",
+        iris::core::layout_diagnostics::take().per_frame(frames)
+    );
+}

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,35 +190,48 @@ 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);
     }
 }
 
-fn a_len(rng: &mut Rng) -> Option<LayoutLen> {
+/// A length in pixels, or a cap over one: a rule that reads the box it is
-    Some(LayoutLen::px(20.0 + rng.below(180) as f32))
+/// given is the one a resize can change the effect of without changing the
+/// rule, so a tree that never grows one leaves that unexercised.
+fn a_rule(rng: &mut Rng) -> SizeRule {
+    let len = Len::px(20.0 + rng.below(180) as f32);
+    match rng.below(4) {
+        0 => SizeRule::Max(len),
+        1 => SizeRule::Min(len),
+        _ => LayoutLen::from(len).into(),
+    }
 }
 
-fn resize_one(warm: &mut Harness, tree: &Tree, idx: usize, rng: &mut Rng) -> Lens {
+fn resize_one(warm: &mut Harness, tree: &Tree, idx: usize, rng: &mut Rng) -> SizeRules {
-    let lens = [a_len(rng), a_len(rng)];
+    let lens = SizeRules {
+        x: a_rule(rng),
+        y: a_rule(rng),
+    };
     warm.rsc
         .widgets_mut()
-        .set_size_rules(tree.sized[idx], lens[0], lens[1]);
+        .set_size_rules(tree.sized[idx], lens.x.clone(), lens.y.clone());
     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) {
+    let taken = RegionAlign::from(align);
-        warm.rsc
+    for axis in Axis::BOTH {
-            .widgets_mut()
+        warm.rsc.widgets_mut().set_alignment(id, axis, taken[axis]);
-            .set_alignment(id, axis, align.unwrap_or_default());
     }
     align
 }
@@ -343,10 +356,18 @@ fn change(case: Case, warm: &mut Harness, tree: &mut Tree, plan: &Plan, rng: &mu
 /// out by hand. A failure is a lead; the fast test that replaces it has to be
 /// buildable from what the failure printed.
 fn describe(id: WidgetId, h: &Harness) -> String {
-    let rules = h.rsc.widgets().size_rules(id);
+    let rules = h.rsc.widgets().size_rules(id).clone();
-    let rule = |r: SizeRule| match r.exact() {
+    // A bound prints as itself: a failure is reproduced from what it printed,
-        Some(len) => format!("{len}"),
+    // and a rule shown as "no rule" cannot be written out again.
-        None => "-".into(),
+    let rule = |r: SizeRule| match r {
+        SizeRule::Free => "-".into(),
+        SizeRule::Exact(len) => format!("{len}"),
+        SizeRule::Request(request) => format!("{request:?}"),
+        SizeRule::Min(min) => format!(">{}", LayoutLen::from(min)),
+        SizeRule::Max(max) => format!("<{}", LayoutLen::from(max)),
+        SizeRule::Clamp { min, max } => {
+            format!(">{}<{}", LayoutLen::from(min), LayoutLen::from(max))
+        }
     };
     let align = h.rsc.widgets().alignment(id);
     let side = |a: AxisAlign| {
@@ -363,7 +384,7 @@ fn describe(id: WidgetId, h: &Harness) -> String {
     // A rule and an alignment are properties of whatever carries them, so
     // they print with that widget rather than as widgets of their own.
     let mut out = describe_widget(id, h);
-    if (rules.x, rules.y) != (SizeRule::Free, SizeRule::Free) {
+    if rules != SizeRules::default() {
         out += &format!("[x:{},y:{}]", rule(rules.x), rule(rules.y));
     }
     if align != RegionAlign::default() {

tests/suite.rs

@@ -32,3 +32,6 @@ mod tasks;
 mod text_edit;
 #[path = "cases/unsettled.rs"]
 mod unsettled;
+
+#[path = "cases/deferred.rs"]
+mod deferred;

tests/trace_unsettled.rs

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