Drop the refcount a widget handle can never raise

StrongWidget has no Clone on purpose, so the RefCounter in it never counted
anything: the count stayed at zero, RefCounter::drop always answered true,
and StrongWidget::refs had no caller -- while every widget made paid a heap
allocation for an Arc<AtomicU32> and every one created or dropped paid two
atomic read-modify-writes. The handle is the id, the sender and the type now,
and Drop sends. It is 32 bytes rather than 40, and 40 rather than 48 for a
dyn one.

RefCounter stays for TextureHandle, which does clone -- several widgets
showing one picture share its slot -- and is trimmed to what that needs:
quiet_clone and refs had no callers at all, and new was Default spelt out.

Bryan asked for this in #19 rather than in the review of the code written
before the gate, where the fourteenth sweep had left it.

Cargo.toml

@@ -25,6 +25,18 @@ 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
+
+[profile.test]
+debug = "line-tables-only"
+
 [workspace.package]
 version = "0.1.0"
 edition = "2024"

TODO

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

core/src/fixed.rs

@@ -0,0 +1,518 @@
+use crate::{UiNum, util::Vec2};
+use std::{
+    fmt::{Debug, Display, Formatter},
+    ops::{Add, AddAssign, Mul, Neg, Sub, SubAssign},
+};
+
+/// A number held as a whole count of `1 / 2^SHIFT`.
+///
+/// Layout reaches one place by more than one route -- a box composed down the
+/// chain, and the same box summed from what its children asked for -- and has
+/// to decide whether the two are the same place. In floats they land a few
+/// bits apart, which is a defect wherever the answer changes what is drawn
+/// rather than where. Here adding and subtracting are exact, a multiply
+/// drops to the step below, and a conversion between grids takes the nearest
+/// one, so two routes to one place land on one number and everything
+/// downstream compares for equality instead of for nearness.
+///
+/// `SHIFT` is the number of fractional bits, which is what makes the steps
+/// divide a whole number: a power of two also converts to `f32` without
+/// rounding while the value fits in its mantissa.
+///
+/// Arithmetic wraps at the ends of the range, the way the `i32` underneath
+/// does. Saturating instead was measured at a twelfth of layout's
+/// instructions -- five per add against one -- to keep the ordering of
+/// coordinates two million pixels out, where nothing draws anyway. A value
+/// off the end is a defect either way; wrapping makes it an obvious one.
+/// Only [`Self::from_f32`] clamps, since a float has further to come from.
+#[repr(transparent)]
+#[derive(
+    Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default, bytemuck::Pod, bytemuck::Zeroable,
+)]
+pub struct Fixed<const SHIFT: u32>(i32);
+
+/// A length or a coordinate in pixels, in steps of `1/1024`. Finer than
+/// anything a display can show, and exact in `f32` up to 16,384 px, which is
+/// what lets the same number reach the GPU.
+pub type Px = Fixed<PX_SHIFT>;
+
+/// How many bits of a pixel a [`Px`] keeps. One place, because [`PxVec2`]
+/// and the shader's own decoding are the same grid or nothing lines up.
+pub const PX_SHIFT: u32 = 10;
+
+/// A share of what a box has left over, which is a weight beside its
+/// siblings rather than a fraction of anything: a list divides its room by
+/// the total of these, so the range has to hold a whole list's worth and the
+/// precision only has to tell two weights apart.
+pub type Weight = Fixed<16>;
+
+/// A fraction of a box. Twenty-four bits of it, which matches `f32` around a
+/// half and beats it above one -- where anchors actually sit -- and leaves
+/// +/-128 of range, enough to sum a hundred children each asking for a whole
+/// box. A `leftover` weight is not one of these: it is a share of what is
+/// left rather than a fraction of anything, and it sums over a whole list.
+pub type Rel = Fixed<REL_SHIFT>;
+
+/// How many bits of a box a [`Rel`] keeps, beside [`PX_SHIFT`] and for the
+/// same reason.
+pub const REL_SHIFT: u32 = 24;
+
+impl<const SHIFT: u32> Fixed<SHIFT> {
+    pub const ZERO: Self = Self(0);
+    pub const ONE: Self = Self::one();
+    /// The gap between neighbouring values, which is also how far apart two
+    /// numbers can be and still mean the same place.
+    pub const STEP: Self = Self(1);
+    /// Also what stands in for an unbounded end: compared against, never
+    /// added to, since arithmetic wraps past it.
+    pub const MIN: Self = Self(i32::MIN);
+    pub const MAX: Self = Self(i32::MAX);
+
+    const fn one() -> Self {
+        assert!(SHIFT < 31, "a Fixed needs a bit for the whole part");
+        Self(1 << SHIFT)
+    }
+
+    pub const fn from_raw(raw: i32) -> Self {
+        Self(raw)
+    }
+
+    /// The count of steps, for a caller that needs the representation rather
+    /// than the number.
+    pub const fn raw(self) -> i32 {
+        self.0
+    }
+
+    pub const fn from_int(v: i32) -> Self {
+        Self(v.wrapping_mul(Self::one().0))
+    }
+
+    /// Rounds to the nearest step, and clamps to the ends of the grid rather
+    /// than wrapping: this is where a number from outside arrives, and a float
+    /// has the range to be anywhere. A NaN has no nearest step and becomes
+    /// zero, which is a caller's mistake rather than a value worth carrying.
+    ///
+    /// Half-away is written out rather than called through `f32::round`,
+    /// which is not `const`: a layout constant has to stay a constant.
+    pub const fn from_f32(v: f32) -> Self {
+        debug_assert!(!v.is_nan(), "a NaN has no place on the grid");
+        let scaled = v * Self::one().0 as f32;
+        // Above 2^23 an `f32` has no fractional part left to round, and
+        // adding a half there rounds the number itself up instead. The cast
+        // saturates at both ends and sends NaN to zero, which is the
+        // behaviour wanted at both.
+        const WHOLE: f32 = (1 << 23) as f32;
+        Self(match (scaled >= WHOLE, scaled <= -WHOLE, scaled < 0.0) {
+            (true, _, _) | (_, true, _) => scaled as i32,
+            (_, _, true) => (scaled - 0.5) as i32,
+            _ => (scaled + 0.5) as i32,
+        })
+    }
+
+    /// The first step at or above `v`, where [`Self::from_f32`] takes the
+    /// nearest one and is below it half the time. For a bound that has to
+    /// admit the value it came from: a measurement rounded down is a bound
+    /// that leaves out the thing it was measured from.
+    pub const fn ceil_from_f32(v: f32) -> Self {
+        let nearest = Self::from_f32(v);
+        // The top of the grid has no step above it, and stepping past it
+        // wraps to the bottom. A value out there is a caller's mistake, and
+        // the clamp `from_f32` already made is the answer to it.
+        match nearest.to_f32() < v && nearest.0 != Self::MAX.0 {
+            true => nearest.next_up(),
+            false => nearest,
+        }
+    }
+
+    /// From a number as it is written in source -- `16`, `1.5` -- which is
+    /// the other place a value enters the grid.
+    pub fn from_num(v: impl UiNum) -> Self {
+        Self::from_f32(v.to_f32())
+    }
+
+    pub const fn to_f32(self) -> f32 {
+        self.0 as f32 / Self::one().0 as f32
+    }
+
+    pub const fn add(self, rhs: Self) -> Self {
+        Self(self.0.wrapping_add(rhs.0))
+    }
+
+    pub const fn sub(self, rhs: Self) -> Self {
+        Self(self.0.wrapping_sub(rhs.0))
+    }
+
+    pub const fn neg(self) -> Self {
+        Self(self.0.wrapping_neg())
+    }
+
+    /// Scaled by a number on any grid, which is how a length takes a fraction
+    /// of itself and keeps being a length: the product is measured in the
+    /// receiver's steps.
+    ///
+    /// Dropped to the step below rather than taken to the nearest one
+    /// (Bryan, 2026-09-16), which costs a share a thousandth of a pixel of
+    /// its row -- less than an even number of pixels draws. Toward negative
+    /// infinity on both sides of zero, since that is a shift and nothing
+    /// else: a value and its negation therefore land different distances
+    /// from where they came, so a flipped span can sit a step from its
+    /// mirror image.
+    pub const fn mul<const BY: u32>(self, by: Fixed<BY>) -> Self {
+        Self(((self.0 as i64 * by.0 as i64) >> BY) as i32)
+    }
+
+    /// Repeated a whole number of times, which no grid rounds.
+    pub const fn mul_int(self, by: i32) -> Self {
+        Self(self.0.wrapping_mul(by))
+    }
+
+    /// Divided into a whole number of parts, rounded to the nearest step.
+    pub const fn div_int(self, by: i32) -> Self {
+        debug_assert!(by != 0, "no part of nothing");
+        if by == 0 {
+            return Self::ZERO;
+        }
+        Self(div_round(self.0 as i64, by as i64) as i32)
+    }
+
+    /// `num / den` on *this* grid rather than on theirs, for weights coarser
+    /// than the share they divide.
+    pub const fn ratio<const OF: u32>(num: Fixed<OF>, den: Fixed<OF>) -> Self {
+        debug_assert!(den.0 != 0, "no part of a whole of nothing");
+        if den.0 == 0 {
+            return Self::ZERO;
+        }
+        Self(div_round((num.0 as i64) << SHIFT, den.0 as i64) as i32)
+    }
+
+    /// `from` and `to` a fraction of the way apart, the fraction being the
+    /// receiver -- the argument order [`crate::util::LerpUtil`] already uses.
+    pub const fn lerp<const OF: u32>(self, from: Fixed<OF>, to: Fixed<OF>) -> Fixed<OF> {
+        from.add(to.sub(from).mul(self))
+    }
+
+    pub const fn min(self, other: Self) -> Self {
+        match self.0 < other.0 {
+            true => self,
+            false => other,
+        }
+    }
+
+    pub const fn max(self, other: Self) -> Self {
+        match self.0 > other.0 {
+            true => self,
+            false => other,
+        }
+    }
+
+    pub const fn abs(self) -> Self {
+        Self(self.0.wrapping_abs())
+    }
+
+    pub const fn clamp(self, lo: Self, hi: Self) -> Self {
+        debug_assert!(lo.0 <= hi.0, "an empty clamp has no answer");
+        self.max(lo).min(hi)
+    }
+
+    /// The next value along, for an interval that must not admit its own
+    /// boundary. The step is the whole gap, so there is nothing to exclude
+    /// between this and the boundary itself.
+    pub const fn next_up(self) -> Self {
+        Self(self.0.wrapping_add(1))
+    }
+
+    pub const fn next_down(self) -> Self {
+        Self(self.0.wrapping_sub(1))
+    }
+}
+
+const fn div_round(num: i64, den: i64) -> i64 {
+    let (q, rem) = (num / den, num % den);
+    match rem.unsigned_abs() * 2 >= den.unsigned_abs() {
+        true => match (num < 0) == (den < 0) {
+            true => q + 1,
+            false => q - 1,
+        },
+        false => q,
+    }
+}
+
+/// Toward positive infinity when `up`, toward negative infinity otherwise.
+pub(crate) const fn div_toward(num: i64, den: i64, up: bool) -> i64 {
+    let (q, rem) = (num / den, num % den);
+    if rem == 0 {
+        return q;
+    }
+    match (rem < 0) == (den < 0) {
+        true => q + up as i64,
+        false => q - !up as i64,
+    }
+}
+
+/// Clamped to the ends, unlike a [`Fixed`]'s own arithmetic: a range of box
+/// lengths that runs past `i32` really is unbounded.
+pub(crate) const fn narrow(v: i64) -> i32 {
+    if v > i32::MAX as i64 {
+        return i32::MAX;
+    }
+    if v < i32::MIN as i64 {
+        return i32::MIN;
+    }
+    v as i32
+}
+
+const impl<const SHIFT: u32> Add for Fixed<SHIFT> {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self {
+        Fixed::add(self, rhs)
+    }
+}
+
+const impl<const SHIFT: u32> Sub for Fixed<SHIFT> {
+    type Output = Self;
+
+    fn sub(self, rhs: Self) -> Self {
+        Fixed::sub(self, rhs)
+    }
+}
+
+const impl<const SHIFT: u32> Neg for Fixed<SHIFT> {
+    type Output = Self;
+
+    fn neg(self) -> Self {
+        Fixed::neg(self)
+    }
+}
+
+const impl<const SHIFT: u32> AddAssign for Fixed<SHIFT> {
+    fn add_assign(&mut self, rhs: Self) {
+        *self = Fixed::add(*self, rhs);
+    }
+}
+
+const impl<const SHIFT: u32> SubAssign for Fixed<SHIFT> {
+    fn sub_assign(&mut self, rhs: Self) {
+        *self = Fixed::sub(*self, rhs);
+    }
+}
+
+const impl<const SHIFT: u32, const BY: u32> Mul<Fixed<BY>> for Fixed<SHIFT> {
+    type Output = Self;
+
+    fn mul(self, rhs: Fixed<BY>) -> Self {
+        Fixed::mul(self, rhs)
+    }
+}
+
+impl<const SHIFT: u32> Display for Fixed<SHIFT> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        Display::fmt(&self.to_f32(), f)
+    }
+}
+
+/// Prints the number rather than the count of steps: a failing layout test
+/// reports boxes, and `1126` is not a height anybody can read.
+impl<const SHIFT: u32> Debug for Fixed<SHIFT> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        Display::fmt(&self.to_f32(), f)
+    }
+}
+
+/// Two of them, for the places a size or a position needs both axes: a
+/// window, a box in pixels, a pointer. Held apart from [`crate::util::Vec2`]
+/// because that one is what the GPU and the platform speak.
+#[repr(C)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Default)]
+pub struct FixedVec2<const SHIFT: u32> {
+    pub x: Fixed<SHIFT>,
+    pub y: Fixed<SHIFT>,
+}
+
+pub type PxVec2 = FixedVec2<PX_SHIFT>;
+
+impl<const SHIFT: u32> FixedVec2<SHIFT> {
+    pub const ZERO: Self = Self::splat(Fixed::ZERO);
+
+    pub const fn new(x: Fixed<SHIFT>, y: Fixed<SHIFT>) -> Self {
+        Self { x, y }
+    }
+
+    pub const fn splat(v: Fixed<SHIFT>) -> Self {
+        Self { x: v, y: v }
+    }
+
+    pub fn from_f32(v: Vec2) -> Self {
+        Self::new(Fixed::from_f32(v.x), Fixed::from_f32(v.y))
+    }
+
+    /// The first step at or above each part, for a measurement reported as a
+    /// box: what it occupies is not less than what was measured.
+    pub fn ceil_from_f32(v: Vec2) -> Self {
+        Self::new(Fixed::ceil_from_f32(v.x), Fixed::ceil_from_f32(v.y))
+    }
+
+    pub fn to_f32(self) -> Vec2 {
+        Vec2::new(self.x.to_f32(), self.y.to_f32())
+    }
+
+    pub const fn div_int(self, by: i32) -> Self {
+        Self::new(self.x.div_int(by), self.y.div_int(by))
+    }
+
+    pub const fn min(self, other: Self) -> Self {
+        Self::new(self.x.min(other.x), self.y.min(other.y))
+    }
+
+    pub const fn max(self, other: Self) -> Self {
+        Self::new(self.x.max(other.x), self.y.max(other.y))
+    }
+}
+
+// `impl_op!` names one concrete type, and this one is generic.
+const impl<const SHIFT: u32> Add for FixedVec2<SHIFT> {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self {
+        Self::new(self.x.add(rhs.x), self.y.add(rhs.y))
+    }
+}
+
+const impl<const SHIFT: u32> Sub for FixedVec2<SHIFT> {
+    type Output = Self;
+
+    fn sub(self, rhs: Self) -> Self {
+        Self::new(self.x.sub(rhs.x), self.y.sub(rhs.y))
+    }
+}
+
+const impl<const SHIFT: u32> AddAssign for FixedVec2<SHIFT> {
+    fn add_assign(&mut self, rhs: Self) {
+        *self = Add::add(*self, rhs);
+    }
+}
+
+const impl<const SHIFT: u32> SubAssign for FixedVec2<SHIFT> {
+    fn sub_assign(&mut self, rhs: Self) {
+        *self = Sub::sub(*self, rhs);
+    }
+}
+
+impl<const SHIFT: u32> Debug for FixedVec2<SHIFT> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "({}, {})", self.x, self.y)
+    }
+}
+
+impl<const SHIFT: u32> Display for FixedVec2<SHIFT> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "({}, {})", self.x, self.y)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn a_sum_of_steps_does_not_drift() {
+        let mut at = Px::ZERO;
+        for _ in 0..20_000 {
+            at += Px::from_raw(3);
+        }
+        assert_eq!(at, Px::from_raw(60_000));
+        for _ in 0..20_000 {
+            at -= Px::from_raw(3);
+        }
+        assert_eq!(at, Px::ZERO);
+    }
+
+    #[test]
+    fn a_pixel_survives_the_trip_through_f32() {
+        for raw in [0, 1, -1, 64, -1000, 16_777_215, -16_777_215] {
+            let px = Px::from_raw(raw);
+            assert_eq!(Px::from_f32(px.to_f32()), px);
+        }
+    }
+
+    #[test]
+    fn a_fraction_of_a_length_is_a_length() {
+        let half = Px::from_int(100) * Rel::from_f32(0.5);
+        assert_eq!(half, Px::from_int(50));
+        assert_eq!(Px::from_int(100) * Rel::ONE, Px::from_int(100));
+        assert_eq!(Px::from_int(100) * Rel::ZERO, Px::ZERO);
+    }
+
+    /// Toward negative infinity on both sides of zero, which is what makes
+    /// it a shift rather than a shift and a sign branch -- and what makes a
+    /// value and its negation land different distances from where they came,
+    /// so a flipped span can sit a step from its mirror image.
+    #[test]
+    fn a_multiply_drops_to_the_step_below_on_both_sides_of_zero() {
+        // A step and a half of one, which has no step of its own.
+        let step_and_a_half = Rel::from_f32(1.5).div_int(Px::ONE.raw());
+        assert_eq!(Px::ONE * step_and_a_half, Px::from_raw(1));
+        assert_eq!(Px::ONE.neg() * step_and_a_half, Px::from_raw(-2));
+    }
+
+    /// The bound a greedy line break needs: the width it was measured at is
+    /// not on the grid, and the narrowest box the break still holds for is
+    /// the step at or above it, never the one below.
+    #[test]
+    fn a_ceiling_never_lands_below_the_number_it_came_from() {
+        let step = 1.0 / (1 << PX_SHIFT) as f32;
+        for n in 0..64 {
+            let v = 189.0 + n as f32 * step / 3.0;
+            let up = Px::ceil_from_f32(v);
+            assert!(up.to_f32() >= v, "{up:?} is below {v}");
+            assert!(
+                up.to_f32() - v < step,
+                "{up:?} is more than a step above {v}"
+            );
+        }
+        // An exact step is its own ceiling.
+        assert_eq!(Px::ceil_from_f32(189.5), Px::from_f32(189.5));
+    }
+
+    #[test]
+    fn a_number_from_outside_is_clamped_to_the_grid() {
+        assert_eq!(Px::from_f32(1e12), Px::MAX);
+        assert_eq!(Px::from_f32(-1e12), Px::MIN);
+        // The ceiling is the other way in from a float, and there is no step
+        // above the top of the grid for it to take.
+        assert_eq!(Px::ceil_from_f32(1e12), Px::MAX);
+        assert_eq!(Px::ceil_from_f32(-1e12), Px::MIN);
+    }
+
+    #[test]
+    fn lerp_takes_the_fraction_as_the_receiver() {
+        let (from, to) = (Px::from_int(10), Px::from_int(20));
+        assert_eq!(Rel::ZERO.lerp(from, to), from);
+        assert_eq!(Rel::ONE.lerp(from, to), to);
+        assert_eq!(Rel::from_f32(0.5).lerp(from, to), Px::from_int(15));
+        assert_eq!(Rel::from_f32(0.5).lerp(to, from), Px::from_int(15));
+    }
+
+    #[test]
+    fn a_ratio_is_finer_than_the_weights_it_divides() {
+        let (one, three) = (Weight::ONE, Weight::from_int(3));
+        // A third, which the weights' own grid could only hold to 1/65536.
+        assert_eq!(Rel::ratio(one, three), Rel::from_raw(5592405));
+        assert_eq!(Rel::ratio(three, three), Rel::ONE);
+        assert_eq!(Rel::ratio(Weight::ZERO, three), Rel::ZERO);
+    }
+
+    #[test]
+    fn nothing_sits_between_a_value_and_the_next_one() {
+        let at = Px::from_int(3);
+        assert_eq!(at.next_up().next_down(), at);
+        assert_eq!(at.next_up().raw() - at.raw(), 1);
+        assert!(at.next_down() < at && at < at.next_up());
+    }
+
+    #[test]
+    fn it_prints_the_number_rather_than_the_steps() {
+        assert_eq!(format!("{:?}", Px::from_f32(17.59375)), "17.59375");
+        assert_eq!(format!("{}", Px::from_int(-2)), "-2");
+    }
+}

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, Len, Size, UiRegion, WidgetId, util::Vec2};
+use crate::{Axis, LayoutHolds, LayoutLen, PxVec2, Size, UiRegion, UiVec2, WidgetId};
 use std::{
     cell::RefCell,
     collections::{HashMap, HashSet},
@@ -23,104 +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,
-    ResizeDependents,
-    DrawRequests,
-    WidgetDraws,
-    PlaceCalls,
-    SizeReads,
-    HintHits,
-    HintMisses,
-    RetainedSizeHits,
-    ReuseAttempts,
-    ReuseExact,
-    ReuseMoved,
-    ReuseDirty,
-    ReuseWrongParent,
-    ReuseUnslotted,
-    ReuseOwnResize,
-    ReuseDescendantResize,
-    ResizeChecks,
-    ResizeCheckChildren,
-    QueuePops,
-    DepthReads,
-    EagerReaderRedraws,
-    LocalRedraws,
-    SizeChanges,
-    ReaderEdges,
-    PrimitiveWrites,
-    TextRenders,
-    TextShapeHits,
-    TextShapes,
-    TextBreaks,
-    GlyphPlacements,
+        Updates = "updates",
+        DrawRequests = "draw requests",
+        WidgetDraws = "widget draws",
+        RegionNodeDraws = "region-node draws",
+        SizeReads = "draw-result size reads",
+        HintHits = "hint hits",
+        HintMisses = "hint misses",
+        ReuseAttempts = "reuse attempts",
+        ReuseExact = "reuse exact",
+        ReuseMoved = "reuse moved",
+        ReuseDirty = "reuse: dirty",
+        ReuseUndrawn = "reuse: nothing drawn to keep",
+        ReuseWrongParent = "reuse: wrong parent",
+        ReuseRemapped = "reuse remapped",
+        ReuseOutside = "reuse: outside what it holds for",
+        ReuseWrongLayer = "reuse: another layer",
+        ReuseWrongNode = "reuse: region-node choice changed",
+        ReuseWrongMask = "reuse: a different inherited mask",
+        QueuePops = "redraw queue pops",
+        DepthReads = "depth reads",
+        LocalRedraws = "local redraws",
+        SizeChanges = "size changes",
+        ReaderEdges = "reader edges",
+        PrimitiveWrites = "primitive writes",
+        TextRenders = "text renders",
+        TextShapeHits = "text shape hits",
+        TextShapes = "text shapes",
+        TextBreaks = "text line breaks",
+        GlyphPlacements = "glyph placements",
+        OutsidePinnedLen = "reuse outside: the length it was pinned to",
+        OutsideWindow = "reuse outside: this window",
+        OutsideRelBase = "reuse outside: a rel base",
+        OutsideRegion = "reuse outside: a region length",
+    }
 }
 
-impl Counter {
-    const COUNT: usize = Self::GlyphPlacements as usize + 1;
-
-    const NAMES: [&'static str; Self::COUNT] = [
-        "updates",
-        "resize dependents",
-        "draw requests",
-        "widget draws",
-        "place calls",
-        "draw-result size reads",
-        "hint hits",
-        "hint misses",
-        "retained size hits",
-        "reuse attempts",
-        "reuse exact",
-        "reuse moved",
-        "reuse: dirty",
-        "reuse: wrong parent",
-        "reuse: unslotted",
-        "reuse: own resize",
-        "reuse: descendant resize",
-        "resize checks",
-        "resize children checked",
-        "redraw queue pops",
-        "depth reads",
-        "eager reader redraws",
-        "local redraws",
-        "size changes",
-        "reader edges",
-        "primitive writes",
-        "text renders",
-        "text shape hits",
-        "text shapes",
-        "text line breaks",
-        "glyph placements",
-    ];
-}
-
-#[derive(Clone, Copy)]
+labelled! {
     pub(crate) enum TimerKind {
-    Update,
-    FullLayout,
-    ResizeMarking,
-    IncrementalLayout,
-    TextRender,
-    TextShape,
-    TextBreak,
-    GlyphPlacement,
+        Update = "update total",
+        FullLayout = "full layout",
+        IncrementalLayout = "incremental layout",
+        TextRender = "text render",
+        TextShape = "text shape",
+        TextBreak = "text line break",
+        GlyphPlacement = "glyph placement",
     }
-
-impl TimerKind {
-    const COUNT: usize = Self::GlyphPlacement as usize + 1;
-
-    const NAMES: [&'static str; Self::COUNT] = [
-        "update total",
-        "full layout",
-        "resize marking",
-        "incremental layout",
-        "text render",
-        "text shape",
-        "text line break",
-        "glyph placement",
-    ];
 }
 
 #[derive(Clone)]
@@ -254,9 +221,12 @@ pub enum ReuseOutcome {
     Moved,
     Dirty,
     WrongParent,
-    Unslotted,
-    OwnResize,
-    DescendantResize,
+    WrongLayer,
+    WrongMask,
+    WrongNode,
+    Remapped,
+    Outside,
+    Undrawn,
 }
 
 /// One targeted layout event. Events are retained in execution order, making
@@ -267,8 +237,8 @@ pub enum TraceEvent {
         id: WidgetId,
         parent: Option<WidgetId>,
         region: UiRegion,
-        pixel_size: Vec2,
-        slotted: bool,
+        region_px: PxVec2,
+        region_node: bool,
     },
     Reuse {
         id: WidgetId,
@@ -278,7 +248,7 @@ pub enum TraceEvent {
         id: WidgetId,
         size: Size,
     },
-    Placed {
+    RegionNode {
         id: WidgetId,
         parent: WidgetId,
         region: UiRegion,
@@ -292,7 +262,7 @@ pub enum TraceEvent {
         id: WidgetId,
         reader: WidgetId,
         axis: Axis,
-        hint: Option<Len>,
+        hint: Option<LayoutLen>,
     },
     TextRendered {
         id: WidgetId,
@@ -363,8 +333,8 @@ pub(crate) fn draw_request(
     id: WidgetId,
     parent: Option<WidgetId>,
     region: UiRegion,
-    pixel_size: Vec2,
-    slotted: bool,
+    region_px: PxVec2,
+    region_node: bool,
 ) {
     trace(
         id,
@@ -372,8 +342,8 @@ pub(crate) fn draw_request(
             id,
             parent,
             region,
-            pixel_size,
-            slotted,
+            region_px,
+            region_node,
         },
     );
 }
@@ -382,19 +352,63 @@ 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,
+) {
+    let mut reasons = 0;
+    let mut why = |counter| {
+        bump(counter);
+        reasons += 1;
+    };
+    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) {
+            why(Counter::OutsidePinnedLen);
+        }
+        if !holds.window.contains(window) {
+            why(Counter::OutsideWindow);
+        }
+        if holds
+            .rel_base
+            .is_some_and(|pinned| pinned != rel_base[axis])
+        {
+            why(Counter::OutsideRelBase);
+        }
+        if !holds.region.contains(len.to_px(window)) {
+            why(Counter::OutsideRegion);
+        }
+    }
+    // These four are `AxisHolds::contains`'s four clauses written out again,
+    // because the report wants which one refused rather than that one did. A
+    // clause added there and not here would leave a refusal unexplained.
+    debug_assert!(reasons > 0, "a reuse was refused for no reason counted");
+    bump(Counter::ReuseOutside);
+    reuse(id, ReuseOutcome::Outside);
+}
+
 pub(crate) fn size_reported(id: WidgetId, size: Size) {
     trace(id, TraceEvent::SizeReported { id, size });
 }
 
-pub(crate) fn placed(id: WidgetId, parent: WidgetId, region: UiRegion) {
-    trace(id, TraceEvent::Placed { id, parent, region });
+pub(crate) fn region_node(id: WidgetId, parent: WidgetId, region: UiRegion) {
+    trace(id, TraceEvent::RegionNode { id, parent, region });
 }
 
 pub(crate) fn size_read(id: WidgetId, reader: WidgetId, size: Size) {
     trace(id, TraceEvent::SizeRead { id, reader, size });
 }
 
-pub(crate) fn hint_read(id: WidgetId, reader: WidgetId, axis: Axis, hint: Option<Len>) {
+pub(crate) fn hint_read(id: WidgetId, reader: WidgetId, axis: Axis, hint: Option<LayoutLen>) {
     trace(
         id,
         TraceEvent::HintRead {

core/src/lib.rs

@@ -9,12 +9,14 @@
 #![feature(unsize)]
 #![feature(coerce_unsized)]
 #![feature(option_into_flat_iter)]
+#![feature(const_index)]
 
 #[cfg(feature = "layout-diagnostics")]
 pub mod layout_diagnostics;
 
 mod attr;
 mod event;
+mod fixed;
 mod num;
 mod orientation;
 mod primitive;
@@ -26,6 +28,7 @@ pub mod util;
 
 pub use attr::*;
 pub use event::*;
+pub use fixed::*;
 pub use num::*;
 pub use orientation::*;
 pub use primitive::*;

core/src/orientation/align.rs

@@ -1,8 +1,9 @@
-use crate::vec2;
+use crate::util::impl_axis_index;
+use crate::{Px, Rel};
 
 use super::*;
 
-#[derive(Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub struct Align {
     pub x: Option<AxisAlign>,
     pub y: Option<AxisAlign>,
@@ -30,20 +31,32 @@ impl Align {
     }
 }
 
-#[derive(Clone, Copy, PartialEq, Eq)]
-pub enum AxisAlign {
-    Neg,
-    Center,
-    Pos,
-}
+/// Where a widget sits in a box longer than it is. The default is the middle,
+/// because the two edges are the ones that assume a direction: which of them
+/// is the near one depends on the writing system and on which way a container
+/// runs, and the middle is the same either way.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct AxisAlign(Rel);
 
 impl AxisAlign {
-    pub const fn rel(&self) -> f32 {
-        match self {
-            Self::Neg => 0.0,
-            Self::Center => 0.5,
-            Self::Pos => 1.0,
+    pub const NEG: Self = Self::new(0.0);
+    pub const CENTER: Self = Self::new(0.5);
+    pub const POS: Self = Self::new(1.0);
+
+    pub const fn new(rel: f32) -> Self {
+        Self(Rel::from_f32(rel))
     }
+
+    /// A fraction of the room left over, which is what the layout reads: the
+    /// three constants are the familiar places along it, not the only ones.
+    pub const fn rel(&self) -> Rel {
+        self.0
+    }
+}
+
+impl Default for AxisAlign {
+    fn default() -> Self {
+        Self::CENTER
     }
 }
 
@@ -53,41 +66,38 @@ pub struct CardinalAlign {
 }
 
 impl CardinalAlign {
-    pub const LEFT: Self = Self::new(Axis::X, AxisAlign::Neg);
-    pub const H_CENTER: Self = Self::new(Axis::X, AxisAlign::Center);
-    pub const RIGHT: Self = Self::new(Axis::X, AxisAlign::Pos);
-    pub const TOP: Self = Self::new(Axis::Y, AxisAlign::Neg);
-    pub const V_CENTER: Self = Self::new(Axis::Y, AxisAlign::Center);
-    pub const BOT: Self = Self::new(Axis::Y, AxisAlign::Pos);
+    pub const LEFT: Self = Self::new(Axis::X, AxisAlign::NEG);
+    pub const H_CENTER: Self = Self::new(Axis::X, AxisAlign::CENTER);
+    pub const RIGHT: Self = Self::new(Axis::X, AxisAlign::POS);
+    pub const TOP: Self = Self::new(Axis::Y, AxisAlign::NEG);
+    pub const V_CENTER: Self = Self::new(Axis::Y, AxisAlign::CENTER);
+    pub const BOT: Self = Self::new(Axis::Y, AxisAlign::POS);
 
     pub const fn new(axis: Axis, align: AxisAlign) -> Self {
         Self { axis, align }
     }
 }
 
-#[derive(Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, PartialEq, Default)]
 pub struct RegionAlign {
     pub x: AxisAlign,
     pub y: AxisAlign,
 }
 
 impl RegionAlign {
-    pub const TOP_LEFT: Self = Self::new(AxisAlign::Neg, AxisAlign::Neg);
-    pub const TOP_CENTER: Self = Self::new(AxisAlign::Center, AxisAlign::Neg);
-    pub const TOP_RIGHT: Self = Self::new(AxisAlign::Pos, AxisAlign::Neg);
-    pub const CENTER_LEFT: Self = Self::new(AxisAlign::Neg, AxisAlign::Center);
-    pub const CENTER: Self = Self::new(AxisAlign::Center, AxisAlign::Center);
-    pub const CENTER_RIGHT: Self = Self::new(AxisAlign::Pos, AxisAlign::Center);
-    pub const BOT_LEFT: Self = Self::new(AxisAlign::Neg, AxisAlign::Pos);
-    pub const BOT_CENTER: Self = Self::new(AxisAlign::Center, AxisAlign::Pos);
-    pub const BOT_RIGHT: Self = Self::new(AxisAlign::Pos, AxisAlign::Pos);
+    pub const TOP_LEFT: Self = Self::new(AxisAlign::NEG, AxisAlign::NEG);
+    pub const TOP_CENTER: Self = Self::new(AxisAlign::CENTER, AxisAlign::NEG);
+    pub const TOP_RIGHT: Self = Self::new(AxisAlign::POS, AxisAlign::NEG);
+    pub const CENTER_LEFT: Self = Self::new(AxisAlign::NEG, AxisAlign::CENTER);
+    pub const CENTER: Self = Self::new(AxisAlign::CENTER, AxisAlign::CENTER);
+    pub const CENTER_RIGHT: Self = Self::new(AxisAlign::POS, AxisAlign::CENTER);
+    pub const BOT_LEFT: Self = Self::new(AxisAlign::NEG, AxisAlign::POS);
+    pub const BOT_CENTER: Self = Self::new(AxisAlign::CENTER, AxisAlign::POS);
+    pub const BOT_RIGHT: Self = Self::new(AxisAlign::POS, AxisAlign::POS);
 
     pub const fn new(x: AxisAlign, y: AxisAlign) -> Self {
         Self { x, y }
     }
-    pub const fn rel(&self) -> Vec2 {
-        vec2(self.x.rel(), self.y.rel())
-    }
 }
 
 impl UiVec2 {
@@ -140,16 +150,17 @@ impl Vec2 {
     }
 }
 
-impl UiScalar {
+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 mut start = UiScalar::rel(rel);
-        start.abs -= self.abs * rel;
-        start.rel -= self.rel * rel;
-        let mut end = UiScalar::rel(rel);
-        end.abs += self.abs * (1.0 - rel);
-        end.rel += self.rel * (1.0 - rel);
-        UiSpan { start, end }
+        let at = Len::from_parts(rel, Px::ZERO);
+        UiSpan {
+            start: at - self.scale(rel),
+            end: at + self.scale(Rel::ONE.sub(rel)),
+        }
     }
 }
 
@@ -165,8 +176,8 @@ impl From<RegionAlign> for Align {
 impl From<Align> for RegionAlign {
     fn from(align: Align) -> Self {
         Self {
-            x: align.x.unwrap_or(AxisAlign::Center),
-            y: align.y.unwrap_or(AxisAlign::Center),
+            x: align.x.unwrap_or(AxisAlign::CENTER),
+            y: align.y.unwrap_or(AxisAlign::CENTER),
         }
     }
 }
@@ -189,7 +200,10 @@ impl From<CardinalAlign> for Align {
 
 const impl From<RegionAlign> for UiVec2 {
     fn from(align: RegionAlign) -> Self {
-        Self::rel(align.rel())
+        Self::new(
+            Len::from_parts(align.x.rel(), Px::ZERO),
+            Len::from_parts(align.y.rel(), Px::ZERO),
+        )
     }
 }
 
@@ -198,3 +212,6 @@ impl RegionAlign {
         UiVec2::from(self)
     }
 }
+
+impl_axis_index!(RegionAlign => AxisAlign);
+impl_axis_index!(Align => Option<AxisAlign>);

core/src/orientation/axis.rs

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

core/src/orientation/len.rs

@@ -1,22 +1,39 @@
 use super::*;
-use crate::{UiNum, util::impl_op};
+use crate::util::impl_axis_index;
+use crate::{Px, PxVec2, Rel, UiNum, Weight, util::impl_op};
 
 #[derive(Debug, Default, Clone, Copy, PartialEq)]
 pub struct Size {
-    pub x: Len,
-    pub y: Len,
+    pub x: LayoutLen,
+    pub y: LayoutLen,
 }
 
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub struct Len {
-    pub abs: f32,
-    pub rel: f32,
-    pub rest: f32,
+/// What a widget asks for along one axis: a [`Len`] -- pixels and a fraction
+/// of the box it is given -- plus a share of whatever is left over once
+/// everything fixed has been taken. The parts add up rather than choosing
+/// between one another.
+///
+/// Only a container dividing its room can answer a share, so a length nobody
+/// divides is a `Len`: a position, a padding, a cap, anything already
+/// resolved.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct LayoutLen {
+    pub px: Px,
+    pub rel: Rel,
+    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::abs(value.to_f32())
+        Len::px(value.to_f32())
+    }
+}
+
+impl<N: UiNum> From<N> for LayoutLen {
+    fn from(value: N) -> Self {
+        LayoutLen::px(value.to_f32())
     }
 }
 
@@ -29,52 +46,76 @@ impl<Nx: UiNum, Ny: UiNum> From<(Nx, Ny)> for Size {
     }
 }
 
-impl From<Len> for Size {
-    fn from(value: Len) -> Self {
+/// A length with no share in it is a length a container does not have to
+/// divide, which is one it can always give.
+impl From<Len> for LayoutLen {
+    fn from(len: Len) -> Self {
+        Self {
+            px: len.px,
+            rel: len.rel,
+            leftover: Weight::ZERO,
+        }
+    }
+}
+
+impl From<LayoutLen> for Size {
+    fn from(value: LayoutLen) -> Self {
         Self { x: value, y: value }
     }
 }
 
 impl Size {
     pub const ZERO: Self = Self {
-        x: Len::ZERO,
-        y: Len::ZERO,
+        x: LayoutLen::ZERO,
+        y: LayoutLen::ZERO,
     };
 
-    pub const REST: Self = Self {
-        x: Len::REST,
-        y: Len::REST,
+    pub const LEFTOVER: Self = Self {
+        x: LayoutLen::LEFTOVER,
+        y: LayoutLen::LEFTOVER,
     };
 
-    pub fn abs(v: Vec2) -> Self {
+    /// From something measured outside layout -- a texture, a shaped line --
+    /// which is where a size in floats comes from.
+    pub fn px(v: Vec2) -> Self {
+        Self::from_px(PxVec2::from_f32(v))
+    }
+
+    pub const fn from_px(v: PxVec2) -> Self {
         Self {
-            x: Len::abs(v.x),
-            y: Len::abs(v.y),
+            x: LayoutLen {
+                px: v.x,
+                ..LayoutLen::ZERO
+            },
+            y: LayoutLen {
+                px: v.y,
+                ..LayoutLen::ZERO
+            },
         }
     }
 
     pub fn rel(v: Vec2) -> Self {
         Self {
-            x: Len::rel(v.x),
-            y: Len::rel(v.y),
+            x: LayoutLen::rel(v.x),
+            y: LayoutLen::rel(v.y),
         }
     }
 
-    pub fn rest(v: Vec2) -> Self {
+    pub fn leftover(v: Vec2) -> Self {
         Self {
-            x: Len::rest(v.x),
-            y: Len::rest(v.y),
+            x: LayoutLen::leftover(v.x),
+            y: LayoutLen::leftover(v.y),
         }
     }
 
     pub fn to_uivec2(self) -> UiVec2 {
         UiVec2 {
-            x: self.x.apply_rest(),
-            y: self.y.apply_rest(),
+            x: self.x.apply_leftover(),
+            y: self.y.apply_leftover(),
         }
     }
 
-    pub fn from_axis(axis: Axis, aligned: Len, ortho: Len) -> Self {
+    pub fn from_axis(axis: Axis, aligned: LayoutLen, ortho: LayoutLen) -> Self {
         match axis {
             Axis::X => Self {
                 x: aligned,
@@ -86,54 +127,88 @@ impl Size {
             },
         }
     }
-
-    pub fn axis(&self, axis: Axis) -> Len {
-        match axis {
-            Axis::X => self.x,
-            Axis::Y => self.y,
-        }
-    }
 }
 
-impl Len {
+impl LayoutLen {
     pub const ZERO: Self = Self {
-        abs: 0.0,
-        rel: 0.0,
-        rest: 0.0,
+        px: Px::ZERO,
+        rel: Rel::ZERO,
+        leftover: Weight::ZERO,
     };
 
-    pub const REST: Self = Self {
-        abs: 0.0,
-        rel: 0.0,
-        rest: 1.0,
+    pub const LEFTOVER: Self = Self {
+        px: Px::ZERO,
+        rel: Rel::ZERO,
+        leftover: Weight::ONE,
     };
 
-    pub fn apply_rest(&self) -> UiScalar {
-        UiScalar {
-            rel: self.rel + if self.rest > 0.0 { 1.0 } else { 0.0 },
-            abs: self.abs,
-        }
+    /// The whole of what is left over counts as the whole box, which is what
+    /// a length means to something that is not dividing a box between
+    /// siblings -- a scroll asking how long its content is.
+    pub fn apply_leftover(&self) -> Len {
+        let share = match self.leftover > Weight::ZERO {
+            true => Rel::ONE,
+            false => Rel::ZERO,
+        };
+        Len::from_parts(self.rel.add(share), self.px)
     }
 
-    pub fn abs(abs: impl UiNum) -> Self {
+    /// Only pixels: the same number of them whatever box it lands in, and
+    /// whatever anyone else in the row asks for. A length that is any part
+    /// of a box or of what is left over is not one.
+    pub fn is_px(&self) -> bool {
+        self.rel == Rel::ZERO && self.leftover == Weight::ZERO
+    }
+
+    /// Nothing but a claim on what is left over, so there is no length here
+    /// at all where nothing is.
+    pub fn is_only_leftover(&self) -> bool {
+        self.leftover > Weight::ZERO && self.without_leftover() == Len::ZERO
+    }
+
+    /// This as a length of a box, where it is one. `leftover` is not: a
+    /// share of what is left over is a length only to whoever divides one,
+    /// so it passes up in the reported size instead and is resolved there.
+    pub fn declared(&self) -> Option<Len> {
+        (self.leftover == Weight::ZERO).then(|| self.without_leftover())
+    }
+
+    /// What this takes whatever is left over: the reading of a length for
+    /// anyone not dividing a box between siblings, where a share is a claim
+    /// on someone else's room rather than a length of its own.
+    /// [`Self::apply_leftover`] is the opposite reading of the same value.
+    pub const fn without_leftover(&self) -> Len {
+        Len::from_parts(self.rel, self.px)
+    }
+
+    /// This length, given as a part of a box `len` long, as a part of the
+    /// box `len` is itself a part of. The share is untouched: it is a claim
+    /// on whoever divides the room, not a fraction of anything.
+    pub const fn within_len(self, len: Len) -> Self {
+        let part = self.without_leftover().within_len(len);
         Self {
-            abs: abs.to_f32(),
-            rel: 0.0,
-            rest: 0.0,
+            px: part.px,
+            rel: part.rel,
+            leftover: self.leftover,
+        }
+    }
+
+    pub fn px(px: impl UiNum) -> Self {
+        Self {
+            px: Px::from_num(px),
+            ..Self::ZERO
         }
     }
     pub fn rel(rel: impl UiNum) -> Self {
         Self {
-            abs: 0.0,
-            rel: rel.to_f32(),
-            rest: 0.0,
+            rel: Rel::from_num(rel),
+            ..Self::ZERO
         }
     }
-    pub fn rest(ratio: impl UiNum) -> Self {
+    pub fn leftover(ratio: impl UiNum) -> Self {
         Self {
-            abs: 0.0,
-            rel: 0.0,
-            rest: ratio.to_f32(),
+            leftover: Weight::from_num(ratio),
+            ..Self::ZERO
         }
     }
 }
@@ -141,38 +216,26 @@ impl Len {
 pub mod len_fns {
     use super::*;
 
-    pub fn abs(abs: impl UiNum) -> Len {
-        Len {
-            abs: abs.to_f32(),
-            rel: 0.0,
-            rest: 0.0,
+    pub fn px(px: impl UiNum) -> LayoutLen {
+        LayoutLen::px(px)
     }
+    pub fn rel(rel: impl UiNum) -> LayoutLen {
+        LayoutLen::rel(rel)
     }
-    pub fn rel(rel: impl UiNum) -> Len {
-        Len {
-            abs: 0.0,
-            rel: rel.to_f32(),
-            rest: 0.0,
-        }
-    }
-    pub fn rest(ratio: impl UiNum) -> Len {
-        Len {
-            abs: 0.0,
-            rel: 0.0,
-            rest: ratio.to_f32(),
-        }
+    pub fn leftover(ratio: impl UiNum) -> LayoutLen {
+        LayoutLen::leftover(ratio)
     }
 }
 
-impl_op!(Len Add add; abs rel rest);
-impl_op!(Len Sub sub; abs rel rest);
+impl_op!(same LayoutLen Add add; px rel leftover);
+impl_op!(same LayoutLen Sub sub; px rel leftover);
 
-impl_op!(Size Add add; x y);
-impl_op!(Size Sub sub; x y);
+impl_op!(same Size Add add; x y);
+impl_op!(same Size Sub sub; x y);
 
-impl Default for Len {
+impl Default for LayoutLen {
     fn default() -> Self {
-        Self::rest(1.0)
+        Self::leftover(1.0)
     }
 }
 
@@ -182,17 +245,46 @@ impl std::fmt::Display for Size {
     }
 }
 
-impl std::fmt::Display for Len {
+impl std::fmt::Display for LayoutLen {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        if self.abs != 0.0 {
-            write!(f, "{} abs;", self.abs)?;
+        // A part that is zero is left out, so a length that is zero all
+        // through would print as nothing -- which reads as no length at all
+        // wherever one is printed beside something that has none.
+        if *self == Self::ZERO {
+            return write!(f, "0 px;");
         }
-        if self.rel != 0.0 {
+        if self.px != Px::ZERO {
+            write!(f, "{} px;", self.px)?;
+        }
+        if self.rel != Rel::ZERO {
             write!(f, "{} rel;", self.rel)?;
         }
-        if self.rest != 0.0 {
-            write!(f, "{} rest;", self.rest)?;
+        if self.leftover != Weight::ZERO {
+            write!(f, "{} leftover;", self.leftover)?;
         }
         Ok(())
     }
 }
+
+impl_axis_index!(Size => LayoutLen);
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// What a request prints as is how a failing case is read and written out
+    /// again, and a length that printed as nothing could not be told from a
+    /// widget that has no rule at all.
+    #[test]
+    fn every_length_prints_as_something() {
+        for len in [
+            LayoutLen::ZERO,
+            LayoutLen::px(8),
+            LayoutLen::rel(0.5),
+            LayoutLen::LEFTOVER,
+        ] {
+            assert!(!len.to_string().is_empty(), "{len:?} printed as nothing");
+        }
+        assert_eq!(LayoutLen::ZERO.to_string(), "0 px;");
+    }
+}

core/src/orientation/pos.rs

@@ -1,41 +1,47 @@
-use std::{fmt::Display, hash::Hash, marker::Destruct};
+use crate::util::impl_axis_index;
+use std::{fmt::Display, marker::Destruct};
 
 use super::*;
-use crate::{
-    UiNum,
-    util::{LerpUtil, impl_op},
-};
+use crate::{Px, PxVec2, Rel, UiNum, util::impl_op};
 
 #[repr(C)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, bytemuck::Pod, bytemuck::Zeroable, Default)]
 pub struct UiVec2 {
-    pub x: UiScalar,
-    pub y: UiScalar,
+    pub x: Len,
+    pub y: Len,
 }
 
 impl UiVec2 {
     pub const ZERO: Self = Self {
-        x: UiScalar::ZERO,
-        y: UiScalar::ZERO,
+        x: Len::ZERO,
+        y: Len::ZERO,
     };
 
-    pub const fn new(x: UiScalar, y: UiScalar) -> Self {
+    pub const fn new(x: Len, y: Len) -> Self {
         Self { x, y }
     }
 
-    pub const fn abs(abs: impl const Into<Vec2>) -> Self {
-        let abs = abs.into();
+    pub const fn px(px: impl const Into<Vec2>) -> Self {
+        let px = px.into();
         Self {
-            x: UiScalar::abs(abs.x),
-            y: UiScalar::abs(abs.y),
+            x: Len::px(px.x),
+            y: Len::px(px.y),
+        }
+    }
+
+    /// From lengths already on the grid, with no fraction of a box.
+    pub const fn from_px(px: PxVec2) -> Self {
+        Self {
+            x: Len::from_parts(Rel::ZERO, px.x),
+            y: Len::from_parts(Rel::ZERO, px.y),
         }
     }
 
     pub const fn rel(rel: impl const Into<Vec2>) -> Self {
         let rel = rel.into();
         Self {
-            x: UiScalar::rel(rel.x),
-            y: UiScalar::rel(rel.y),
+            x: Len::rel(rel.x),
+            y: Len::rel(rel.y),
         }
     }
 
@@ -56,30 +62,15 @@ impl UiVec2 {
         }
     }
 
-    pub fn axis_mut(&mut self, axis: Axis) -> &mut UiScalar {
-        match axis {
-            Axis::X => &mut self.x,
-            Axis::Y => &mut self.y,
-        }
-    }
-
-    pub fn axis(&self, axis: Axis) -> UiScalar {
-        match axis {
-            Axis::X => self.x,
-            Axis::Y => self.y,
-        }
-    }
-
-    pub fn to_abs(&self, rel: Vec2) -> Vec2 {
-        Vec2 {
-            x: self.x.to_abs(rel.x),
-            y: self.y.to_abs(rel.y),
-        }
+    /// Resolved against a box of `size`, which is where a fraction stops
+    /// being one and becomes a place.
+    pub fn to_px(&self, size: PxVec2) -> PxVec2 {
+        PxVec2::new(self.x.to_px(size.x), self.y.to_px(size.y))
     }
 
     pub const FULL_SIZE: Self = Self::rel(Vec2::ONE);
 
-    pub const fn from_axis(axis: Axis, aligned: UiScalar, ortho: UiScalar) -> Self {
+    pub const fn from_axis(axis: Axis, aligned: Len, ortho: Len) -> Self {
         match axis {
             Axis::X => Self {
                 x: aligned,
@@ -92,34 +83,27 @@ impl UiVec2 {
         }
     }
 
-    pub fn get_abs(&self) -> Vec2 {
-        (self.x.abs, self.y.abs).into()
+    pub fn get_px(&self) -> Vec2 {
+        (self.x.px.to_f32(), self.y.px.to_f32()).into()
     }
 
     pub fn get_rel(&self) -> Vec2 {
-        (self.x.rel, self.y.rel).into()
-    }
-
-    pub fn abs_mut(&mut self) -> Vec2View<'_> {
-        Vec2View {
-            x: &mut self.x.abs,
-            y: &mut self.y.abs,
-        }
+        (self.x.rel.to_f32(), self.y.rel.to_f32()).into()
     }
 }
 
 impl Display for UiVec2 {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "rel{};abs{}", self.get_rel(), self.get_abs())
+        write!(f, "rel{};px{}", self.get_rel(), self.get_px())
     }
 }
 
-impl_op!(UiVec2 Add add; x y);
-impl_op!(UiVec2 Sub sub; x y);
+impl_op!(same UiVec2 Add add; x y);
+impl_op!(same UiVec2 Sub sub; x y);
 
 const impl From<Vec2> for UiVec2 {
-    fn from(abs: Vec2) -> Self {
-        Self::abs(abs)
+    fn from(px: Vec2) -> Self {
+        Self::px(px)
     }
 }
 
@@ -127,127 +111,137 @@ const impl<T: const UiNum, U: const UiNum> From<(T, U)> for UiVec2
 where
     (T, U): const Destruct,
 {
-    fn from(abs: (T, U)) -> Self {
-        Self::abs(abs)
+    fn from(px: (T, U)) -> Self {
+        Self::px(px)
     }
 }
 
+/// A length along one axis: a fraction of the box it is measured in plus an
+/// offset, `rel * box + px`. A position is the same number -- the length from
+/// the start of the box to the point -- which is why a [`UiSpan`] is two of
+/// these. Both parts are fixed point, so composing one through a chain of
+/// boxes rounds only where it multiplies, and lands on the same number as any
+/// other route to the same place.
+///
+/// It carries no claim on what a container has left over. That is
+/// [`crate::LayoutLen`], which is this plus a weight, and which means nothing
+/// to anyone but whoever divides the room.
 #[repr(C)]
-#[derive(Debug, Copy, Clone, PartialEq, bytemuck::Pod, Default, bytemuck::Zeroable)]
-pub struct UiScalar {
-    pub rel: f32,
-    pub abs: f32,
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, bytemuck::Pod, Default, bytemuck::Zeroable)]
+pub struct Len {
+    pub rel: Rel,
+    pub px: Px,
 }
 
-impl Eq for UiScalar {}
-impl Hash for UiScalar {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        state.write_u32(self.rel.to_bits());
-        state.write_u32(self.abs.to_bits());
-    }
+impl_op!(same Len Add add; rel px);
+impl_op!(same Len Sub sub; rel px);
+
+impl Len {
+    pub const ZERO: Self = Self {
+        rel: Rel::ZERO,
+        px: Px::ZERO,
+    };
+    pub const FULL: Self = Self {
+        rel: Rel::ONE,
+        px: Px::ZERO,
+    };
+
+    pub const fn new(rel: f32, px: f32) -> Self {
+        Self::from_parts(Rel::from_f32(rel), Px::from_f32(px))
     }
 
-impl_op!(UiScalar Add add; rel abs);
-impl_op!(UiScalar Sub sub; rel abs);
-
-impl UiScalar {
-    pub const ZERO: Self = Self { rel: 0.0, abs: 0.0 };
-    pub const FULL: Self = Self { rel: 1.0, abs: 0.0 };
-
-    pub const fn new(rel: f32, abs: f32) -> Self {
-        Self { rel, abs }
+    /// From parts already on the grid, rather than numbers to be put on it.
+    pub const fn from_parts(rel: Rel, px: Px) -> Self {
+        Self { rel, px }
     }
 
     pub const fn rel(rel: f32) -> Self {
-        Self { rel, abs: 0.0 }
+        Self::from_parts(Rel::from_f32(rel), Px::ZERO)
     }
 
-    pub const fn abs(abs: f32) -> Self {
-        Self { rel: 0.0, abs }
-    }
-
-    pub const fn rel_min() -> Self {
-        Self::new(0.0, 0.0)
-    }
-
-    pub const fn rel_max() -> Self {
-        Self::new(1.0, 0.0)
+    pub const fn px(px: f32) -> Self {
+        Self::from_parts(Rel::ZERO, Px::from_f32(px))
     }
 
     pub const fn max(&self, other: Self) -> Self {
         Self {
             rel: self.rel.max(other.rel),
-            abs: self.abs.max(other.abs),
+            px: self.px.max(other.px),
         }
     }
 
     pub const fn min(&self, other: Self) -> Self {
         Self {
             rel: self.rel.min(other.rel),
-            abs: self.abs.min(other.abs),
+            px: self.px.min(other.px),
         }
     }
 
-    pub const fn offset(mut self, amt: f32) -> Self {
-        self.abs += amt;
+    /// Both parts by the same fraction, which is what a part of a length
+    /// means when the length is part pixels and part a fraction of a box.
+    pub const fn scale(&self, by: Rel) -> Self {
+        Self {
+            rel: self.rel.mul(by),
+            px: self.px.mul(by),
+        }
+    }
+
+    pub const fn offset(mut self, amt: Px) -> Self {
+        self.px = self.px.add(amt);
         self
     }
 
     pub const fn within(&self, span: &UiSpan) -> Self {
-        let anchor = self.rel.lerp(span.start.rel, span.end.rel);
-        let offset = self.abs + self.rel.lerp(span.start.abs, span.end.abs);
         Self {
-            rel: anchor,
-            abs: offset,
+            rel: self.rel.lerp(span.start.rel, span.end.rel),
+            px: self.px.add(self.rel.lerp(span.start.px, span.end.px)),
         }
     }
 
-    pub fn within_len(&self, len: UiScalar) -> Self {
+    pub const fn within_len(&self, len: Len) -> Self {
         self.within(&UiSpan {
-            start: UiScalar::ZERO,
+            start: Len::ZERO,
             end: len,
         })
     }
 
-    pub fn select_len(&self, len: UiScalar) -> Self {
-        len.within_len(*self)
-    }
-
     pub const fn flip(&mut self) {
-        self.rel = 1.0 - self.rel;
-        self.abs = -self.abs;
+        self.rel = Rel::ONE.sub(self.rel);
+        self.px = self.px.neg();
     }
 
     pub const fn to(&self, end: Self) -> UiSpan {
         UiSpan { start: *self, end }
     }
 
-    pub const fn to_abs(&self, rel: f32) -> f32 {
-        self.rel * rel + self.abs
+    /// Resolved against a box of `len`, which is the only place a fraction
+    /// becomes a number of pixels.
+    pub const fn to_px(&self, len: Px) -> Px {
+        self.px.add(len.mul(self.rel))
     }
 }
 
 #[repr(C)]
 #[derive(Debug, Copy, Clone, PartialEq, bytemuck::Pod, bytemuck::Zeroable)]
 pub struct UiSpan {
-    pub start: UiScalar,
-    pub end: UiScalar,
+    pub start: Len,
+    pub end: Len,
 }
 
 impl UiSpan {
     pub const FULL: Self = Self {
-        start: UiScalar::ZERO,
-        end: UiScalar::FULL,
+        start: Len::ZERO,
+        end: Len::FULL,
     };
 
     pub const fn rel(rel: f32) -> Self {
         Self {
-            start: UiScalar::rel(rel),
-            end: UiScalar::rel(rel),
+            start: Len::rel(rel),
+            end: Len::rel(rel),
         }
     }
 
-    pub const fn new(start: UiScalar, end: UiScalar) -> Self {
+    pub const fn new(start: Len, end: Len) -> Self {
         Self { start, end }
     }
 
@@ -255,14 +249,19 @@ impl UiSpan {
         self.start.flip();
         self.end.flip();
         std::mem::swap(&mut self.start.rel, &mut self.end.rel);
-        std::mem::swap(&mut self.start.abs, &mut self.end.abs);
+        std::mem::swap(&mut self.start.px, &mut self.end.px);
     }
 
-    pub const fn shift(&mut self, offset: UiScalar) {
+    pub const fn shift(&mut self, offset: Len) {
         self.start += offset;
         self.end += offset;
     }
 
+    /// Composing a box through the one it sits in, and the hottest line in
+    /// layout. It used to skip the multiplies where a span was the whole of
+    /// its parent or the parent the whole of its own; both come out of the
+    /// multiply unchanged anyway, and the body those comparisons cost was
+    /// what kept the inliner from taking this at all.
     pub const fn within(&self, parent: &Self) -> Self {
         Self {
             start: self.start.within(parent),
@@ -270,7 +269,16 @@ impl UiSpan {
         }
     }
 
-    pub const fn len(&self) -> UiScalar {
+    /// A box `len` long inside this one, on the side `align` says. Both must
+    /// be lengths of the same rel base: it subtracts one from the other
+    /// rather than composing it in, which is what keeps a fraction the same
+    /// fraction however long this box turns out to be.
+    pub const fn place(self, len: Len, align: AxisAlign) -> Self {
+        let start = self.start + (self.len() - len).scale(align.rel());
+        Self::new(start, start + len)
+    }
+
+    pub const fn len(&self) -> Len {
         self.end - self.start
     }
 }
@@ -304,20 +312,6 @@ impl UiRegion {
             y: self.y.within(&parent.y),
         }
     }
-    pub const fn axis(&self, axis: Axis) -> &UiSpan {
-        match axis {
-            Axis::X => &self.x,
-            Axis::Y => &self.y,
-        }
-    }
-
-    pub const fn axis_mut(&mut self, axis: Axis) -> &mut UiSpan {
-        match axis {
-            Axis::X => &mut self.x,
-            Axis::Y => &mut self.y,
-        }
-    }
-
     pub const fn flip(&mut self, axis: Axis) {
         match axis {
             Axis::X => self.x.flip(),
@@ -336,10 +330,10 @@ impl UiRegion {
         self
     }
 
-    pub fn to_px(&self, size: Vec2) -> PixelRegion {
+    pub fn to_px(&self, size: PxVec2) -> PixelRegion {
         PixelRegion {
-            top_left: self.top_left().get_rel() * size + self.top_left().get_abs(),
-            bot_right: self.bot_right().get_rel() * size + self.bot_right().get_abs(),
+            top_left: self.top_left().to_px(size),
+            bot_right: self.bot_right().to_px(size),
         }
     }
 
@@ -394,21 +388,21 @@ impl Display for UiRegion {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct PixelRegion {
-    pub top_left: Vec2,
-    pub bot_right: Vec2,
+    pub top_left: PxVec2,
+    pub bot_right: PxVec2,
 }
 
 impl PixelRegion {
-    pub fn contains(&self, pos: Vec2) -> bool {
+    pub fn contains(&self, pos: PxVec2) -> bool {
         pos.x >= self.top_left.x
             && pos.x <= self.bot_right.x
             && pos.y >= self.top_left.y
             && pos.y <= self.bot_right.y
     }
 
-    pub fn size(&self) -> Vec2 {
+    pub fn size(&self) -> PxVec2 {
         self.bot_right - self.top_left
     }
 }
@@ -419,19 +413,5 @@ impl Display for PixelRegion {
     }
 }
 
-pub struct Vec2View<'a> {
-    pub x: &'a mut f32,
-    pub y: &'a mut f32,
-}
-
-impl Vec2View<'_> {
-    pub fn set(&mut self, other: Vec2) {
-        *self.x = other.x;
-        *self.y = other.y;
-    }
-
-    pub fn add(&mut self, other: Vec2) {
-        *self.x += other.x;
-        *self.y += other.y;
-    }
-}
+impl_axis_index!(UiVec2 => Len);
+impl_axis_index!(UiRegion => UiSpan);

core/src/primitive/layer.rs

@@ -120,6 +120,10 @@ impl<T: Default> Layers<T> {
 }
 
 impl DrawLayers {
+    /// Inlined on purpose: it is one call per glyph, the innermost thing a
+    /// frame does, and whether the inliner takes it turns out to depend on
+    /// unrelated code elsewhere in the crate -- 12% of a resize frame.
+    #[inline]
     pub fn write<P: Primitive>(
         &mut self,
         layer: LayerId,

core/src/primitive/text.rs

@@ -1,7 +1,8 @@
 #[cfg(feature = "layout-diagnostics")]
 use crate::layout_diagnostics::{self as diag, Counter, TimerKind};
 use crate::{
-    Align, GlyphAtlas, GlyphEntry, GlyphKey, PlacedGlyph, RegionAlign, UiColor, util::Vec2,
+    Align, GlyphAtlas, GlyphEntry, GlyphKey, PlacedGlyph, Px, PxVec2, RegionAlign, UiColor,
+    util::Vec2,
 };
 use parley::{
     Alignment, AlignmentOptions, FontContext, FontFamily, FontFamilyName, GenericFamily, Layout,
@@ -132,10 +133,6 @@ impl TextBuffer {
         }
     }
 
-    pub fn new_empty() -> Self {
-        Self::new("")
-    }
-
     pub fn text(&self) -> &str {
         &self.text
     }
@@ -175,25 +172,47 @@ impl TextBuffer {
         self.layout_key.as_ref()?.max_width
     }
 
+    /// Widths covered by the current line breaks, including a wider shaping
+    /// retained when a later draw requested a narrower box.
+    pub fn width_holds(&self) -> crate::Holds {
+        let Some(width) = self.wrap_width() else {
+            return crate::Holds::ANY;
+        };
+        let width = Px::from_f32(width);
+        let soft_wrapped = self.layout.lines().any(|line| {
+            matches!(
+                line.break_reason(),
+                parley::layout::BreakReason::Regular | parley::layout::BreakReason::Emergency
+            )
+        });
+        let upper = if soft_wrapped { width } else { Px::MAX };
+        crate::Holds::from(Px::ceil_from_f32(self.layout.width()).min(width)..=upper)
+    }
+
     pub fn size(&self) -> Vec2 {
         Vec2::new(self.layout.width(), self.layout.height())
     }
 
     pub fn shape(&mut self, data: &mut TextData, attrs: &TextAttrs, width: Option<f32>) {
-        let layout_key = LayoutKey {
-            attrs: attrs.clone(),
-            max_width: width,
-        };
-        if self.layout_key.as_ref() == Some(&layout_key) {
-            #[cfg(feature = "layout-diagnostics")]
-            diag::bump(Counter::TextShapeHits);
-            return;
-        }
+        // Asked of the attrs it was given rather than of a copy: copying one
+        // allocates wherever its family is named, and the hit below is what
+        // this cache is for.
         let same_shaping = self
             .layout_key
             .as_ref()
             .is_some_and(|key| key.attrs == *attrs);
-        let old_key = self.layout_key.replace(layout_key);
+        if same_shaping
+            && let Some(key) = &self.layout_key
+            && self.breaks_the_same(key.max_width, width)
+        {
+            #[cfg(feature = "layout-diagnostics")]
+            diag::bump(Counter::TextShapeHits);
+            return;
+        }
+        let old_key = self.layout_key.replace(LayoutKey {
+            attrs: attrs.clone(),
+            max_width: width,
+        });
         // The glyphs it holds are of the width it held, which the layout may
         // well come back to.
         if let Some(key) = old_key
@@ -233,6 +252,28 @@ impl TextBuffer {
         self.break_lines(width);
     }
 
+    /// Whether the break in hand is the break `want` would make. The attrs
+    /// are the caller's to compare; this is about the width alone.
+    ///
+    /// A greedy break at one width is the same break at every width down to
+    /// the longest line it produced: each line still fits, and none can take a
+    /// word that would not fit in the wider box. So the layout in hand already
+    /// answers, and re-breaking would only be work.
+    ///
+    /// At the longest line exactly, with no margin below it. A narrower width
+    /// really does break differently, so answering one from the break in hand
+    /// is how a warm tree keeps lines a cold tree would never produce. The
+    /// margin was here because a text reports the width it used and a parent
+    /// hands that back; the report is the step at or above its longest line
+    /// now, so what comes back fits.
+    fn breaks_the_same(&self, broke_at: Option<f32>, want: Option<f32>) -> bool {
+        match (broke_at, want) {
+            (broke_at, want) if broke_at == want => true,
+            (Some(broke_at), Some(want)) => want <= broke_at && want >= self.layout.width(),
+            _ => false,
+        }
+    }
+
     fn break_lines(&mut self, width: Option<f32>) {
         self.layout.break_all_lines(width);
         self.layout
@@ -279,9 +320,9 @@ impl TextData {
                     };
                     placed.push(PlacedGlyph {
                         entry,
-                        offset: Vec2::new(
-                            glyph.x.floor() + entry.left as f32,
-                            glyph.y.floor() - entry.top as f32,
+                        offset: PxVec2::new(
+                            Px::from_int(glyph.x.floor() as i32 + entry.left),
+                            Px::from_int(glyph.y.floor() as i32 - entry.top),
                         ),
                     });
                 }

core/src/primitive/texture.rs

@@ -66,7 +66,7 @@ impl Textures {
         TextureHandle {
             slot: self.push(image),
             size,
-            counter: RefCounter::new(),
+            counter: RefCounter::default(),
             send: self.send.clone(),
         }
     }

core/src/render/atlas.rs

@@ -1,5 +1,5 @@
 use crate::{
-    PatchRect,
+    PatchRect, PxVec2,
     util::{HashMap, Vec2},
 };
 use image::RgbaImage;
@@ -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 {
@@ -241,5 +237,7 @@ fn write_glyph(page: &mut RgbaImage, image: &Image, x: u32, y: u32) {
 #[derive(Clone, Copy)]
 pub struct PlacedGlyph {
     pub entry: GlyphEntry,
-    pub offset: Vec2,
+    /// Whole pixels from the origin of the text to this glyph's top-left,
+    /// on the grid once here rather than on every frame that draws it.
+    pub offset: PxVec2,
 }

core/src/render/data.rs

@@ -16,11 +16,13 @@ pub struct PrimitiveInstance {
 }
 
 impl PrimitiveInstance {
+    // The region's four scalars, each a `Rel` beside a `Px`: whole counts
+    // that the shader decodes, rather than the numbers themselves.
     const ATTRIBS: [VertexAttribute; 6] = vertex_attr_array![
-        0 => Float32x2,
-        1 => Float32x2,
-        2 => Float32x2,
-        3 => Float32x2,
+        0 => Sint32x2,
+        1 => Sint32x2,
+        2 => Sint32x2,
+        3 => Sint32x2,
         4 => Uint32,
         5 => Uint32,
     ];

core/src/render/mod.rs

@@ -22,6 +22,26 @@ pub use primitive::*;
 
 const PRELUDE: &str = include_str!("./shader/prelude.wgsl");
 
+fn module_source(wgsl: &str) -> String {
+    // Every number both sides count in, written once here rather than a
+    // second time in the shader: a grid the two disagree about puts every
+    // coordinate somewhere else, and a sentinel they disagree about makes one
+    // of them walk a chain from a slot the other says is not there.
+    format!(
+        "const PX_STEP: f32 = 1.0 / {}.0;\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,
+    )
+}
+
 pub struct UiRenderNode {
     shared_layout: BindGroupLayout,
     shared_group: BindGroup,
@@ -95,7 +115,8 @@ impl UiRenderNode {
             self.active.push(i);
             for change in draws.apply_free() {
                 if let Some(inst) = ui_render.active.get_mut(&change.id) {
-                    for h in &mut inst.primitives {
+                    for primitive in &mut inst.primitives {
+                        let h = &mut primitive.handle;
                         if h.layer == i && h.kind == change.kind && h.inst_idx == change.old {
                             h.inst_idx = change.new;
                             break;
@@ -222,7 +243,7 @@ impl UiRenderNode {
     ) -> RenderPipeline {
         let module = device.create_shader_module(ShaderModuleDescriptor {
             label: Some(label),
-            source: ShaderSource::Wgsl(format!("{PRELUDE}\n{wgsl}").into()),
+            source: ShaderSource::Wgsl(module_source(wgsl).into()),
         });
         device.create_render_pipeline(&RenderPipelineDescriptor {
             label: Some(label),
@@ -264,7 +285,9 @@ impl UiRenderNode {
     }
 
     /// What every draw in the ui is given: the window, the masks and the
-    /// move chain every position is resolved through.
+    /// move chain every position is resolved through. The last two are the
+    /// vertex stage's alone -- a mask's rectangle is the same for every
+    /// fragment of one instance, so it is resolved once and handed on.
     fn shared_layout(device: &Device) -> BindGroupLayout {
         device.create_bind_group_layout(&BindGroupLayoutDescriptor {
             entries: &[
@@ -280,7 +303,7 @@ impl UiRenderNode {
                 },
                 BindGroupLayoutEntry {
                     binding: 1,
-                    visibility: ShaderStages::FRAGMENT,
+                    visibility: ShaderStages::VERTEX,
                     ty: BindingType::Buffer {
                         ty: BufferBindingType::Storage { read_only: true },
                         has_dynamic_offset: false,
@@ -290,7 +313,7 @@ impl UiRenderNode {
                 },
                 BindGroupLayoutEntry {
                     binding: 2,
-                    visibility: ShaderStages::VERTEX | ShaderStages::FRAGMENT,
+                    visibility: ShaderStages::VERTEX,
                     ty: BindingType::Buffer {
                         ty: BufferBindingType::Storage { read_only: true },
                         has_dynamic_offset: false,
@@ -401,3 +424,35 @@ impl ListBuffers {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::module_source;
+    use wgpu::naga::{
+        front::wgsl,
+        valid::{Capabilities, ValidationFlags, Validator},
+    };
+
+    /// Every shader file, composed as the renderer composes it, parses and
+    /// validates with no device -- so an edit that breaks one fails here and
+    /// not in the first window opened.
+    #[test]
+    fn every_shader_validates() {
+        let dir = concat!(env!("CARGO_MANIFEST_DIR"), "/src/render/shader");
+        let mut checked = 0;
+        for entry in std::fs::read_dir(dir).unwrap() {
+            let path = entry.unwrap().path();
+            if path.extension().is_none_or(|e| e != "wgsl") || path.ends_with("prelude.wgsl") {
+                continue;
+            }
+            let source = module_source(&std::fs::read_to_string(&path).unwrap());
+            let module = wgsl::parse_str(&source)
+                .unwrap_or_else(|e| panic!("{}: {}", path.display(), e.emit_to_string(&source)));
+            Validator::new(ValidationFlags::all(), Capabilities::all())
+                .validate(&module)
+                .unwrap_or_else(|e| panic!("{}: {e:?}", path.display()));
+            checked += 1;
+        }
+        assert!(checked > 0, "no shaders found in {dir}");
+    }
+}

core/src/render/shader/prelude.wgsl

@@ -15,32 +15,71 @@ struct WindowUniform {
 };
 
 struct Mask {
-    x: UiSpan,
-    y: UiSpan,
+    x: RawSpan,
+    y: RawSpan,
     move_idx: u32,
 }
 
 struct MoveOffset {
-    x: UiSpan,
-    y: UiSpan,
+    x: RawSpan,
+    y: RawSpan,
     parent: u32,
 }
 
+// `PX_STEP`, `REL_STEP`, `MASK_NONE`, `MOVE_NONE` and `CHAIN_LIMIT` are
+// prepended from `iris_core`'s own constants, so none of them is written
+// twice. What the CPU stores is a whole count of each step, and both steps
+// are powers of two, so decoding is exact and the number here is the number
+// the CPU decided.
+
+// Every coordinate the CPU decided is a whole count of `PX_STEP`, so one that
+// composes to within half a step of a pixel boundary is on that boundary and
+// belongs to the pixel above it. Flooring the product instead drops a pixel
+// wherever a fraction divides a window exactly: a fifth of 1920 comes out of
+// `REL_STEP` as 383.99998, and five tabs each lose their last column.
+//
+// Taken over the whole coordinate, fraction and pixels summed, since a floor
+// does not distribute over a sum: floored apart, a half of one and a half of
+// the other lose the pixel the two together make.
+fn snap_floor(v: vec2<f32>) -> vec2<f32> {
+    return floor(v + PX_STEP * 0.5);
+}
+
+struct RawScalar {
+    rel: i32,
+    px: i32,
+}
+
+struct RawSpan {
+    start: RawScalar,
+    end: RawScalar,
+}
+
+fn scalar_of(raw: RawScalar) -> Len {
+    return Len(f32(raw.rel) * REL_STEP, f32(raw.px) * PX_STEP);
+}
+
+fn span_of(raw: RawSpan) -> UiSpan {
+    return UiSpan(scalar_of(raw.start), scalar_of(raw.end));
+}
+
+fn scalar_of_pair(raw: vec2<i32>) -> Len {
+    return Len(f32(raw.x) * REL_STEP, f32(raw.y) * PX_STEP);
+}
+
 struct Region {
     x: UiSpan,
     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;
-
-fn scalar_within(s: UiScalar, p: UiSpan) -> UiScalar {
-    return UiScalar(
-        mix(p.start.rel, p.end.rel, s.rel),
-        s.abs + mix(p.start.abs, p.end.abs, s.rel),
+// 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
+// itself frame to frame, not that it matches the CPU to the last bit.
+fn scalar_within(s: Len, p: UiSpan) -> Len {
+    return Len(
+        p.start.rel + (p.end.rel - p.start.rel) * s.rel,
+        s.px + (p.start.px + (p.end.px - p.start.px) * s.rel),
     );
 }
 
@@ -56,27 +95,27 @@ fn resolve_move(idx: u32, local: Region) -> Region {
             break;
         }
         let entry = move_offsets[at];
-        r = Region(span_within(r.x, entry.x), span_within(r.y, entry.y));
+        r = Region(span_within(r.x, span_of(entry.x)), span_within(r.y, span_of(entry.y)));
         at = entry.parent;
     }
     return r;
 }
 
 struct UiSpan {
-    start: UiScalar,
-    end: UiScalar,
+    start: Len,
+    end: Len,
 }
 
-struct UiScalar {
+struct Len {
     rel: f32,
-    abs: f32,
+    px: f32,
 }
 
 struct InstanceInput {
-    @location(0) x_start: vec2<f32>,
-    @location(1) x_end: vec2<f32>,
-    @location(2) y_start: vec2<f32>,
-    @location(3) y_end: vec2<f32>,
+    @location(0) x_start: vec2<i32>,
+    @location(1) x_end: vec2<i32>,
+    @location(2) y_start: vec2<i32>,
+    @location(3) y_end: vec2<i32>,
     @location(4) mask_idx: u32,
     @location(5) move_idx: u32,
 }
@@ -87,9 +126,25 @@ struct VertexOutput {
     @location(2) uv: vec2<f32>,
     @location(3) @interpolate(flat) mask_idx: u32,
     @location(4) @interpolate(flat) idx: u32,
+    // The mask's rectangle in output pixels, resolved here because it is the
+    // same rectangle for every fragment of one instance and resolving it is a
+    // walk up a chain. Its own chain, not the drawn primitive's, so a
+    // stationary viewport clips content that moves inside it.
+    @location(5) @interpolate(flat) mask_top_left: vec2<f32>,
+    @location(6) @interpolate(flat) mask_bot_right: vec2<f32>,
     @builtin(position) clip_position: vec4<f32>,
 };
 
+// The pixel corners of a region, which is where every coordinate the CPU
+// decided becomes one.
+fn corners(r: Region) -> mat2x2<f32> {
+    let top_left = snap_floor(vec2(r.x.start.rel, r.y.start.rel) * window.dim
+        + vec2(r.x.start.px, r.y.start.px));
+    let bot_right = snap_floor(vec2(r.x.end.rel, r.y.end.rel) * window.dim
+        + vec2(r.x.end.px, r.y.end.px));
+    return mat2x2<f32>(top_left, bot_right);
+}
+
 @vertex
 fn vs_main(
     @builtin(vertex_index) vi: u32,
@@ -99,19 +154,20 @@ fn vs_main(
     var out: VertexOutput;
 
     let local = Region(
-        UiSpan(UiScalar(in.x_start.x, in.x_start.y), UiScalar(in.x_end.x, in.x_end.y)),
-        UiSpan(UiScalar(in.y_start.x, in.y_start.y), UiScalar(in.y_end.x, in.y_end.y)),
+        UiSpan(scalar_of_pair(in.x_start), scalar_of_pair(in.x_end)),
+        UiSpan(scalar_of_pair(in.y_start), scalar_of_pair(in.y_end)),
     );
-    let r = resolve_move(in.move_idx, local);
-    let top_left_rel = vec2(r.x.start.rel, r.y.start.rel);
-    let top_left_abs = vec2(r.x.start.abs, r.y.start.abs);
-    let bot_right_rel = vec2(r.x.end.rel, r.y.end.rel);
-    let bot_right_abs = vec2(r.x.end.abs, r.y.end.abs);
-
-    let top_left = floor(top_left_rel * window.dim) + floor(top_left_abs);
-    let bot_right = floor(bot_right_rel * window.dim) + floor(bot_right_abs);
+    let own = corners(resolve_move(in.move_idx, local));
+    let top_left = own[0];
+    let bot_right = own[1];
     let size = bot_right - top_left;
 
+    var mask = mat2x2<f32>(vec2<f32>(0.0), vec2<f32>(0.0));
+    if in.mask_idx != MASK_NONE {
+        let m = masks[in.mask_idx];
+        mask = corners(resolve_move(m.move_idx, Region(span_of(m.x), span_of(m.y))));
+    }
+
     let uv = vec2<f32>(
         f32(vi % 2u),
         f32(vi / 2u)
@@ -122,26 +178,19 @@ fn vs_main(
     out.top_left = top_left;
     out.bot_right = bot_right;
     out.mask_idx = in.mask_idx;
+    out.mask_top_left = mask[0];
+    out.mask_bot_right = mask[1];
     out.idx = ii;
 
     return out;
 }
 
 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];
-    // Its own chain, not the drawn primitive's, so a stationary viewport
-    // clips content that moves inside it.
-    let m = resolve_move(mask.move_idx, Region(mask.x, mask.y));
-    let tl = vec2(m.x.start.rel, m.y.start.rel);
-    let tl_abs = vec2(m.x.start.abs, m.y.start.abs);
-    let br = vec2(m.x.end.rel, m.y.end.rel);
-    let br_abs = vec2(m.x.end.abs, m.y.end.abs);
-
-    let top_left = floor(tl * window.dim) + floor(tl_abs);
-    let bot_right = floor(br * window.dim) + floor(br_abs);
+    let top_left = in.mask_top_left;
+    let bot_right = in.mask_bot_right;
     let pos = in.clip_position.xy;
     if pos.x < top_left.x || pos.x > bot_right.x || pos.y < top_left.y || pos.y > bot_right.y {
         return color * 0.0;

core/src/ui/active.rs

@@ -1,43 +1,137 @@
 use crate::{
-    LayerId, MaskIdx, MoveIdx, PrimitiveHandle, Size, TextureHandle, UiRegion, WidgetId, util::Vec2,
+    Bounds, Declared, LayerId, LayoutHolds, MaskIdx, MoveIdx, PlaceDesc, RegionAlign,
+    RetainedPrimitive, Size, TextureHandle, UiRegion, UiVec2, WidgetId,
 };
 
-/// important non rendering data for retained drawing
+/// One draw of one widget, so that a widget it asked about can carry which
+/// draw that was. Its own type beside the indices here because it names an
+/// occasion rather than a slot: nothing is stored per draw.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct DrawId(u64);
+
+impl DrawId {
+    /// No draw at all, which is what a widget nothing has asked about carries.
+    pub const NONE: Self = Self(0);
+
+    /// The next one after this. Handed out in order and never reused, so a
+    /// note left by an earlier draw can never be read as this one's.
+    pub(crate) fn next(self) -> Self {
+        Self(self.0 + 1)
+    }
+}
+
+/// What is kept of a widget its parent has asked about. `drawn` says whether
+/// it currently draws; one that does not is kept so that a change to it, or
+/// under it, still reaches whoever asked.
 #[derive(Debug)]
 pub struct ActiveData {
     pub id: WidgetId,
+    /// Where its drawing goes, in its region node's coordinates.
+    pub placement: UiRegion,
+    /// What a fraction declared or reported under this widget is a fraction
+    /// of, as a length of the window.
+    pub rel_base: UiVec2,
+    /// Where its drawing was put, and where it was asked. The two differ
+    /// where a container asks in one place and puts the answer in another --
+    /// a row measures from its cursor and puts the child in its slot. Each
+    /// carries the rel base that ask stated, so asking again from either is
+    /// the same question it was.
+    pub placed: PlaceDesc,
+    pub asked: PlaceDesc,
+    /// The box it was asked in, in the parent's region-node coordinates: the
+    /// box its drawing was made in and the one its contract is about. Its
+    /// drawing is placed elsewhere by re-expression, never by asking again.
     pub region: UiRegion,
-    /// What the widget said it used of `region`, the last time it drew.
+    /// The measured answer and its dependencies. A hint-only dependency or
+    /// a widget first encountered during placement has no measurement yet.
+    pub answer: Option<Answer>,
+    /// The draw that last asked about this widget, which is what says whether
+    /// the draw now running has already asked -- a question the child list can
+    /// only answer by a search, and so in the children a container has rather
+    /// than in one read. Written by whoever asked, so a draw of this widget
+    /// itself carries it across rather than setting it.
+    pub(crate) asked_by: DrawId,
+    /// Asked more than once in its parent's last draw -- measured in one box
+    /// and then asked in the one the parent decided. The parent's layout
+    /// rests on the first answer and its drawing on the last, so only the
+    /// parent can ask either again.
+    pub re_asked: bool,
+    /// What the widget reported, in window-unit lengths.
     pub size: Size,
-    /// The pixel size of the box it drew against. `region` alone cannot say:
-    /// it is a fraction of a slot's box, and the same fraction of a box that
-    /// has since changed is a different number of pixels.
-    pub px: Vec2,
+    /// The window and region reads that this drawing holds for, and the
+    /// rel base and region it pinned.
+    pub holds: LayoutHolds,
+    pub drawn: bool,
     pub parent: Option<WidgetId>,
     /// How far down the tree it was drawn, the root being 1. Carried down a
     /// draw rather than worked out by walking up, so it is right for every
     /// widget a frame visits and cannot drift while one is being drawn.
     pub depth: usize,
     pub textures: Vec<TextureHandle>,
-    pub primitives: Vec<PrimitiveHandle>,
+    /// Its primitives, each keeping the box it was written in -- in this
+    /// widget's placement coordinates, which is what a move recomposes from.
+    pub primitives: Vec<RetainedPrimitive>,
+    /// An owned mask holds one reference independently of its primitives.
+    pub mask_region: Option<UiRegion>,
     pub children: Vec<WidgetId>,
-    /// The children whose size this widget read while drawing.
-    pub size_deps: Vec<WidgetId>,
-    /// Offered pixel axes which flowed into this widget's reported size,
-    /// directly or through a child size it read.
-    pub size_box_inputs: [bool; 2],
-    /// Output axes read while producing `size`, distinct from the widget's
-    /// own box when that box has a fixed pixel length.
-    pub size_output_inputs: [bool; 2],
-    /// The output dimensions against which those dependencies were observed.
-    pub output_px: Vec2,
-    /// Output axes it read directly or while resolving its offered box.
-    pub reads_output: [bool; 2],
-    /// The slot its primitives are positioned through: its own if its parent
-    /// placed it, otherwise the nearest ancestor that has one.
+    pub request_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,
-    /// The slot `region` is given in, which is whatever its parent drew in.
+    /// The declared lengths whoever drew this widget resolved into its rel base.
+    /// A change to one moves a box this widget cannot fix by drawing again,
+    /// and comparing them is what says so.
+    pub declared: Declared,
+    /// Its bounds, resolved the same way. The answer is held to these where
+    /// the box was not, so a change to one changes what it answers even
+    /// where its declared lengths stand.
+    pub bounds: Bounds,
+    /// Its alignment when it was last drawn, which a change to the property
+    /// is found against.
+    pub own_align: RegionAlign,
+    /// The movable region whose coordinates its placement is in when this
+    /// widget does not own a region node.
     pub parent_move: MoveIdx,
+    /// The mask its drawing is clipped to: one it set itself, or the one it
+    /// inherited from whoever drew it.
     pub mask: MaskIdx,
+    /// That inherited one. The two differ exactly where the widget set a
+    /// mask of its own, which is the one it owns and the one a move rewrites
+    /// -- and the one a redraw of it must not be handed back, since setting
+    /// a mask asserts there is none.
+    pub parent_mask: MaskIdx,
     pub layer: LayerId,
 }
+
+impl ActiveData {
+    /// What it answered when its parent asked, where it has been asked at
+    /// all. Not `size`, which is what its last drawing reported: a drawing
+    /// re-expressed in the box that answer chose is not a second answer.
+    pub fn measured(&self) -> Option<Size> {
+        self.answer.map(|answer| answer.size)
+    }
+
+    /// Whether it owns a region node rather than sharing the one it was drawn
+    /// under, which is what its two move indices being different says.
+    pub fn is_region_node(&self) -> bool {
+        self.move_idx != self.parent_move
+    }
+}
+
+/// What a widget answered when it was asked: the size it reported, and the
+/// boxes and windows that answer holds for.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct Answer {
+    pub size: Size,
+    pub holds: LayoutHolds,
+}
+
+#[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

@@ -0,0 +1,241 @@
+use crate::{Bound, Len, 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:
+/// give the widget any box in this range and it draws the same thing and
+/// reports the same size. A widget that never reads its box in pixels holds
+/// for every length; one that does holds for the one it read unless it says
+/// otherwise, and a parent holds for whatever keeps every child it asked
+/// about or drew inside its own range.
+///
+/// The ends are lengths on the grid rather than floats with a tolerance
+/// around them: a box offered back at the length a widget reported comes back
+/// as the same number, so a range means what it says. The one place a range
+/// is wider than the length it came from is [`Self::through`], and what it is
+/// wider by is the floor that inverting a fraction undoes.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Holds {
+    pub lo: Px,
+    pub hi: Px,
+}
+
+impl Len {
+    /// Whether this is longer than `than` in a window this wide, and the
+    /// windows that answer holds for.
+    ///
+    /// Which is longer is a question in pixels -- `rel(0.5)` is longer than
+    /// 300 px at a box of 600 and shorter at 400 -- and it is asked of the
+    /// difference and answered back through that same difference, so the
+    /// boundary is the comparison's own rather than a second way of finding
+    /// it.
+    pub fn longer_than(&self, than: Len, window: Px) -> (bool, Holds) {
+        let over = *self - than;
+        let longer = over.to_px(window) > Px::ZERO;
+        let side = match longer {
+            true => Px::STEP..=Px::MAX,
+            false => Px::MIN..=Px::ZERO,
+        };
+        (longer, Holds::from(side).through(over))
+    }
+}
+
+impl Bound {
+    /// The end of this bound `len` falls outside, which is the length it
+    /// gets instead of its own, 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<Len>, Holds) {
+        let mut held = None;
+        let mut holds = Holds::ANY;
+        if let Some(min) = self.min {
+            let (shorter, kept) = min.longer_than(len, window);
+            holds = holds.and(kept);
+            if shorter {
+                held = Some(min);
+            }
+        }
+        if let Some(max) = self.max {
+            let (longer, kept) = held.unwrap_or(len).longer_than(max, window);
+            holds = holds.and(kept);
+            if longer {
+                debug_assert!(
+                    held.is_none(),
+                    "a floor of {:?} over a cap of {max:?} bounds nothing",
+                    self.min,
+                );
+                held = Some(max);
+            }
+        }
+        (held, holds)
+    }
+}
+
+impl Holds {
+    pub const ANY: Self = Self {
+        lo: Px::MIN,
+        hi: Px::MAX,
+    };
+
+    pub const fn at(len: Px) -> Self {
+        Self { lo: len, hi: len }
+    }
+
+    pub const fn contains(&self, len: Px) -> bool {
+        len.raw() >= self.lo.raw() && len.raw() <= self.hi.raw()
+    }
+
+    /// Every length `other` holds for is one this holds for, so a drawing
+    /// made under this range is still good wherever `other` is.
+    pub const fn covers(&self, other: Self) -> bool {
+        self.lo.raw() <= other.lo.raw() && self.hi.raw() >= other.hi.raw()
+    }
+
+    pub const fn and(&self, other: Self) -> Self {
+        Self {
+            lo: self.lo.max(other.lo),
+            hi: self.hi.min(other.hi),
+        }
+    }
+
+    /// What a box has to be for a part of it, `len` of the box long, to stay
+    /// in this range: the exact preimage of `px + floor(rel * box)`, which is
+    /// the one way a box in pixels is reached. A part with no relative extent
+    /// is a fixed length -- it was drawn at that length and any box keeps it
+    /// there.
+    ///
+    /// The answer is an interval even where this range is a single length,
+    /// because the multiply on the way in drops to the step below and many
+    /// boxes therefore give one length. That is a floor rather than an
+    /// allowance: inverting it is two divisions and nothing else, and the
+    /// whole of a box maps back to itself.
+    pub const fn through(&self, len: Len) -> Self {
+        if self.lo.raw() == Px::MIN.raw() && self.hi.raw() == Px::MAX.raw() {
+            return Self::ANY;
+        }
+        let rel = len.rel.raw() as i64;
+        if rel == 0 {
+            return Self::ANY;
+        }
+        let px = len.px.raw() as i64;
+        // `floor(rel * box) >= lo - px` is `rel * box >= (lo - px) << REL`, and
+        // `floor(rel * box) <= hi - px` is `rel * box < (hi - px + 1) << REL`.
+        let lo = (self.lo.raw() as i64 - px) << REL_SHIFT;
+        let hi = (((self.hi.raw() as i64 - px) + 1) << REL_SHIFT) - 1;
+        // Dividing by a negative fraction turns the ends around, so which
+        // bound each comes from is decided before dividing rather than by
+        // taking the min and max of four divisions.
+        match rel > 0 {
+            true => Self::raws(div_toward(lo, rel, true), div_toward(hi, rel, false)),
+            false => Self::raws(div_toward(hi, rel, true), div_toward(lo, rel, false)),
+        }
+    }
+
+    const fn raws(lo: i64, hi: i64) -> Self {
+        Self {
+            lo: Px::from_raw(narrow(lo)),
+            hi: Px::from_raw(narrow(hi)),
+        }
+    }
+}
+
+impl From<RangeInclusive<Px>> for Holds {
+    fn from(range: RangeInclusive<Px>) -> Self {
+        Self {
+            lo: *range.start(),
+            hi: *range.end(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::Rel;
+
+    #[test]
+    fn an_unrestricted_range_stays_unrestricted_through_any_length() {
+        for rel in [-2.0, -0.5, 0.0, 0.5, 1.0, 2.0] {
+            for px in [-8, 0, 8] {
+                let len = Len::from_parts(Rel::from_f32(rel), Px::from_int(px));
+                assert_eq!(Holds::ANY.through(len), Holds::ANY);
+            }
+        }
+    }
+
+    #[test]
+    fn through_reverses_a_range_for_a_negative_fraction() {
+        // `10 - box / 2` is between 20 and 40 for boxes from -60 to -20.
+        let part = Len::from_parts(Rel::from_f32(-0.5), Px::from_int(10));
+        let holds = Holds::from(Px::from_int(20)..=Px::from_int(40)).through(part);
+        assert!(holds.contains(Px::from_int(-60)) && holds.contains(Px::from_int(-20)));
+        assert!(!holds.contains(Px::from_int(-61)) && !holds.contains(Px::from_int(-19)));
+    }
+
+    /// The case the widening is for: a part that holds only for the length it
+    /// was drawn at has to hold for the box it was drawn in, and a third of a
+    /// box is not a whole number of steps.
+    #[test]
+    fn a_part_maps_back_onto_the_box_it_was_measured_in() {
+        let part = Len::from_parts(Rel::from_f32(1.0 / 3.0), Px::from_int(-146));
+        for box_len in (440..460).map(Px::from_int) {
+            let holds = Holds::at(part.to_px(box_len)).through(part);
+            assert!(holds.contains(box_len), "{box_len:?} left out by {holds:?}");
+        }
+    }
+
+    /// A widget handed the whole of its parent's box, with or without pixels
+    /// taken off it, has no fraction to invert: multiplying by one is exact
+    /// and taking the pixels off again is too, so the box maps back to
+    /// itself. Allowing for anything here compounded a step a level down a
+    /// chain of widgets each taking the whole of its parent.
+    #[test]
+    fn the_whole_of_a_box_maps_back_to_itself() {
+        let at = Px::from_int(956);
+        assert_eq!(Holds::at(at).through(Len::FULL), Holds::at(at));
+        let less_eight = Len::from_parts(Rel::ONE, Px::from_int(-8));
+        assert_eq!(
+            Holds::at(at).through(less_eight),
+            Holds::at(at + Px::from_int(8))
+        );
+    }
+
+    /// The range is the exact preimage at both ends, so a box one step
+    /// outside it really does give a length outside this range. What a wider
+    /// range costs is a drawing reused where it does not hold.
+    #[test]
+    fn a_box_one_step_outside_the_range_is_outside_it() {
+        let part = Len::from_parts(Rel::from_f32(1.0 / 3.0), Px::from_int(-146));
+        let at = Px::from_int(300);
+        let holds = Holds::at(at).through(part);
+        for inside in [holds.lo, holds.hi] {
+            assert_eq!(part.to_px(inside), at, "{inside:?} left out of {holds:?}");
+        }
+        for outside in [holds.lo.next_down(), holds.hi.next_up()] {
+            assert_ne!(part.to_px(outside), at, "{outside:?} admitted by {holds:?}");
+        }
+    }
+
+    /// A truncating multiply only ever drops, so the step it needs allowing
+    /// for on the way in belongs at the top of the range and not the bottom.
+    #[test]
+    fn a_fraction_widens_further_up_than_down() {
+        let half = Len::from_parts(Rel::from_f32(0.5), Px::ZERO);
+        let holds = Holds::at(Px::from_int(100)).through(half);
+        let box_len = Px::from_int(200);
+        assert!(holds.hi - box_len > box_len - holds.lo, "{holds:?}");
+    }
+
+    #[test]
+    fn a_boundary_the_next_step_along_does_not_admit_it() {
+        let boundary = Px::from_int(10);
+        let above = Holds::from(boundary.next_up()..=Px::MAX);
+        assert!(!above.contains(boundary));
+        assert!(above.contains(boundary.next_up()));
+    }
+}

core/src/ui/layout_holds.rs

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

core/src/ui/mod.rs

@@ -10,11 +10,17 @@ use crate::{
 pub const CHAIN_LIMIT: u32 = 64;
 
 mod active;
+mod holds;
+mod layout_holds;
 mod painter;
+mod place;
 mod render_state;
 
 pub use active::*;
+pub use holds::*;
+pub use layout_holds::*;
 pub use painter::{Painter, PrimitiveLike};
+pub use place::{PlaceDesc, PlaceDescAxis, PlaceFit, RetainedPrimitive};
 pub use render_state::*;
 
 #[derive(Default)]
@@ -51,8 +57,11 @@ impl Moves {
         }
     }
 
+    /// Frees a slot. Not a change to the entries: the slot keeps the bytes it
+    /// had, nothing names it until it is handed out again, and whoever is
+    /// handed it writes it then -- so re-uploading the array here would send
+    /// the GPU what it already has.
     pub fn remove(&mut self, idx: MoveIdx) {
-        self.changed = true;
         self.arena.remove(Id::preset(idx.idx() as u32));
     }
 
@@ -66,17 +75,24 @@ impl Moves {
         }
     }
 
-    /// Composes a region held in `idx`'s coordinates down the chain, which is
-    /// the same walk the vertex shader does.
+    /// The same walk the vertex shader does, in the same `Len` the shader is
+    /// handed, for asking where a drawing will actually land -- hit testing,
+    /// and nothing layout decides on. Layout threads its lengths down the
+    /// draw instead, so no box it compares is composed back up this chain.
     pub fn resolve(&self, idx: MoveIdx, local: UiRegion) -> UiRegion {
         let mut region = local;
+        self.walk(idx, |entry| region = region.within(entry));
+        region
+    }
+
+    fn walk(&self, idx: MoveIdx, mut step: impl FnMut(&UiRegion)) {
         let mut at = idx;
         for _ in 0..CHAIN_LIMIT {
             if at == MoveIdx::NONE {
-                return region;
+                return;
             }
-            let entry = self.arena[at.idx()];
-            region = region.within(&entry.region);
+            let entry = &self.arena[at.idx()];
+            step(&entry.region);
             at = entry.parent;
         }
         debug_assert!(
@@ -84,18 +100,13 @@ impl Moves {
             "a move chain longer than {CHAIN_LIMIT} resolves to the wrong place, \
              and the shader stops at the same depth"
         );
-        region
     }
 
     /// How many slots a region in `idx` is composed through, which is what
     /// the shader's walk costs per primitive.
     pub fn depth(&self, idx: MoveIdx) -> usize {
         let mut depth = 0;
-        let mut at = idx;
-        while at != MoveIdx::NONE && depth < CHAIN_LIMIT as usize {
-            at = self.arena[at.idx()].parent;
-            depth += 1;
-        }
+        self.walk(idx, |_| depth += 1);
         depth
     }
 

core/src/ui/place.rs

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

core/src/util/arena.rs

@@ -75,6 +75,11 @@ impl<T, I: IdNum> TrackedArena<T, I> {
         self.refs[i.idx()] += 1;
     }
 
+    pub fn get_mut(&mut self, id: Id<I>) -> &mut T {
+        self.changed = true;
+        self.inner.get_mut(id)
+    }
+
     pub fn remove(&mut self, id: Id<I>) -> T
     where
         T: Copy,

core/src/util/math.rs

@@ -56,6 +56,34 @@ macro_rules! impl_op {
             }
         }
     };
+    // Without the `f32` operations, for a type whose fields are not all the
+    // same kind of number: there is nothing a bare float means to a fraction
+    // and an offset at once.
+    (same $T:ident $op:ident $fn:ident $opa:ident $fna:ident; $($field:ident)*) => {
+        #[allow(non_snake_case)]
+        mod ${concat($T, _op_, $fn, _same_impl)} {
+            use super::*;
+            #[allow(unused_imports)]
+            use std::ops::*;
+            const impl $op for $T {
+                type Output = Self;
+
+                fn $fn(self, rhs: Self) -> Self::Output {
+                    Self {
+                        $($field: self.$field.$fn(rhs.$field),)*
+                    }
+                }
+            }
+            const impl $opa for $T {
+                fn $fna(&mut self, rhs: Self) {
+                    *self = self.$fn(rhs);
+                }
+            }
+        }
+    };
+    (same $T:ident $op:ident $fn:ident; $($field:ident)*) => {
+        impl_op!(same $T $op $fn ${concat($op,Assign)} ${concat($fn,_assign)}; $($field)*);
+    };
     ($T:ident $op:ident $fn:ident; $($field:ident)*) => {
         impl_op!($T $op $fn ${concat($op,Assign)} ${concat($fn,_assign)}; $($field)*);
     };
@@ -65,3 +93,31 @@ macro_rules! impl_op {
 }
 
 pub(crate) use impl_op;
+
+/// `Index<Axis>` for a pair, which is how every pair here is read by axis.
+/// The generics clause is given in braces where the type has one.
+macro_rules! impl_axis_index {
+    ($({$($gen:tt)*})? $T:ty => $Out:ty) => {
+        const impl $(<$($gen)*>)? std::ops::Index<crate::Axis> for $T {
+            type Output = $Out;
+
+            fn index(&self, axis: crate::Axis) -> &$Out {
+                match axis {
+                    crate::Axis::X => &self.x,
+                    crate::Axis::Y => &self.y,
+                }
+            }
+        }
+
+        const impl $(<$($gen)*>)? std::ops::IndexMut<crate::Axis> for $T {
+            fn index_mut(&mut self, axis: crate::Axis) -> &mut $Out {
+                match axis {
+                    crate::Axis::X => &mut self.x,
+                    crate::Axis::Y => &mut self.y,
+                }
+            }
+        }
+    };
+}
+
+pub(crate) use impl_axis_index;

core/src/util/refcount.rs

@@ -3,29 +3,18 @@ use std::sync::{
     atomic::{AtomicU32, Ordering},
 };
 
-#[derive(Debug)]
+/// How many handles to one thing there are, less one: a fresh counter is a
+/// single handle, which is what the derived default gives. Only
+/// [`crate::TextureHandle`] has any, a texture slot being shared by every
+/// widget drawing that picture.
+#[derive(Debug, Default)]
 pub struct RefCounter(Arc<AtomicU32>);
 
 impl RefCounter {
-    pub fn new() -> Self {
-        Self(Arc::new(0.into()))
-    }
-    pub fn refs(&self) -> u32 {
-        self.0.load(Ordering::Acquire)
-    }
     pub fn drop(&mut self) -> bool {
         let refs = self.0.fetch_sub(1, Ordering::Release);
         refs == 0
     }
-    pub fn quiet_clone(&self) -> Self {
-        Self(self.0.clone())
-    }
-}
-
-impl Default for RefCounter {
-    fn default() -> Self {
-        Self::new()
-    }
 }
 
 impl Clone for RefCounter {

core/src/util/slot.rs

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

core/src/widget/data.rs

@@ -1,8 +1,11 @@
-use crate::Widget;
+use crate::{RegionAlign, SizeRules, Widget};
 
 pub struct WidgetData {
     pub widget: Box<dyn Widget>,
     pub label: String,
+    pub(super) region_node: bool,
+    pub(super) size: SizeRules,
+    pub(super) align: RegionAlign,
     /// dynamic borrow checking
     pub borrowed: bool,
 }
@@ -16,6 +19,9 @@ impl WidgetData {
         Self {
             widget: Box::new(widget),
             label,
+            region_node: false,
+            size: SizeRules::default(),
+            align: RegionAlign::default(),
             borrowed: false,
         }
     }

core/src/widget/handle.rs

@@ -1,9 +1,6 @@
 use std::{marker::Unsize, ops::CoerceUnsized, sync::mpsc::Sender};
 
-use crate::{
-    UiRsc, Widget,
-    util::{RefCounter, SlotId},
-};
+use crate::{UiRsc, Widget, util::SlotId};
 
 pub type WidgetId = SlotId;
 
@@ -11,10 +8,12 @@ pub type WidgetId = SlotId;
 /// This is a strong handle that does not impl Clone, and when it is dropped,
 /// a signal is sent to the owning UI to clean up the resources.
 ///
+/// There is nothing to count: not being `Clone` is what makes one handle the
+/// only one, so the drop is the last one and the widget is one container's.
+///
 /// TODO: ergonomic clones when they get put in rust-analyzer & don't cause ICEs?
 pub struct StrongWidget<W: ?Sized = dyn Widget> {
     pub(super) id: WidgetId,
-    counter: RefCounter,
     send: Sender<WidgetId>,
     ty: *const W,
 }
@@ -37,7 +36,6 @@ impl<W: ?Sized> StrongWidget<W> {
     pub(crate) fn new(id: WidgetId, send: Sender<WidgetId>) -> Self {
         Self {
             id,
-            counter: RefCounter::new(),
             send,
             ty: null_ptr(),
         }
@@ -47,10 +45,6 @@ impl<W: ?Sized> StrongWidget<W> {
         self.id
     }
 
-    pub fn refs(&self) -> u32 {
-        self.counter.refs()
-    }
-
     pub fn weak(&self) -> WeakWidget<W> {
         let Self { ty, id, .. } = *self;
         WeakWidget { ty, id }
@@ -74,11 +68,9 @@ impl<W: ?Sized> WeakWidget<W> {
 
 impl<W: ?Sized> Drop for StrongWidget<W> {
     fn drop(&mut self) {
-        if self.counter.drop() {
         let _ = self.send.send(self.id);
     }
 }
-}
 
 pub trait WidgetIdFn<Rsc, W: ?Sized = dyn Widget>: FnOnce(&mut Rsc) -> WeakWidget<W> {}
 impl<Rsc, W: ?Sized, F: FnOnce(&mut Rsc) -> WeakWidget<W>> WidgetIdFn<Rsc, W> for F {}

core/src/widget/mod.rs

@@ -1,9 +1,11 @@
-use crate::{Axis, Len, Painter, Size};
+use crate::{Axis, LayoutLen, Painter, Size};
 use std::any::Any;
 
 mod data;
 mod handle;
 mod like;
+mod request;
+mod size_rule;
 mod tag;
 mod view;
 mod widgets;
@@ -11,38 +13,28 @@ mod widgets;
 pub use data::*;
 pub use handle::*;
 pub use like::*;
+pub use request::*;
+pub use size_rule::*;
 pub use tag::*;
 pub use view::*;
 pub use widgets::*;
 
-/// What may be done to a widget's drawing when the box it was given changes
-/// on this axis, instead of drawing it again. Asked per axis, because wrapped
-/// text reads the width it is offered and not the height.
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
-pub enum OnResize {
-    Scale,
-    /// Reserved: nothing reads this yet, so a widget saying it is redrawn.
-    /// Keeping an unchanged drawing in a bigger box needs the widget to say
-    /// *where* in that box it should sit, which is the alignment work.
-    Translate,
-    #[default]
-    Redraw,
-}
-
 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.
-    fn size_hint(&self, _axis: Axis) -> Option<Len> {
+    fn size_hint(&self, _axis: Axis) -> Option<LayoutLen> {
         None
     }
-
-    fn on_resize(&self, _axis: Axis) -> OnResize {
-        OnResize::default()
-    }
 }
 
 impl Widget for () {
@@ -51,12 +43,8 @@ impl Widget for () {
         Size::default()
     }
 
-    fn size_hint(&self, _axis: Axis) -> Option<Len> {
-        Some(Len::default())
-    }
-
-    fn on_resize(&self, _axis: Axis) -> OnResize {
-        OnResize::Scale
+    fn size_hint(&self, _axis: Axis) -> Option<LayoutLen> {
+        Some(LayoutLen::default())
     }
 }
 

core/src/widget/request.rs

@@ -0,0 +1,609 @@
+use crate::{
+    ActiveData, Axis, Bound, LayoutLen, Len, Px, Rel, StrongWidget, UiNum, Weight, WidgetId,
+    Widgets, util::HashMap,
+};
+use std::cmp::Ordering;
+
+impl<N: 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)
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+enum Op {
+    Sum,
+    Min,
+    Max,
+}
+
+/// One operand of a [`Node`]: a length, or another node. Node numbers are an
+/// arena's own, so an operand says nothing about which arena it came from --
+/// [`RequestedLen`] is the form that does, and the only one that leaves one.
+#[derive(Clone, Copy, Debug, PartialEq)]
+enum Operand {
+    Linear(LayoutLen),
+    Node(u32),
+}
+
+impl Operand {
+    /// The length itself, where no comparison is waiting on an allocation.
+    fn linear(&self) -> Option<LayoutLen> {
+        match *self {
+            Self::Linear(len) => Some(len),
+            Self::Node(_) => None,
+        }
+    }
+}
+
+/// One sum or comparison, with its two operands. Whether anything under it
+/// divides leftover space is carried on the node rather than walked for,
+/// because every caller of one asks.
+#[derive(Clone, Copy, Debug, PartialEq)]
+struct Node {
+    op: Op,
+    a: Operand,
+    b: Operand,
+    leftover: bool,
+}
+
+/// The nodes of one expression, numbered from zero, and the folding that
+/// happens as each is added. There are two kinds of owner and one kind of
+/// arena: a rule's [`SizeRequest`] holds a small one for as long as the rule
+/// lasts, and [`RequestArena`] holds the layout pass's.
+#[derive(Clone, Debug, Default, PartialEq)]
+struct Nodes(Vec<Node>);
+
+impl Nodes {
+    fn node(&self, index: u32) -> Node {
+        self.0[index as usize]
+    }
+
+    fn leftover(&self, at: Operand) -> bool {
+        match at {
+            Operand::Linear(len) => len.leftover > Weight::ZERO,
+            Operand::Node(index) => self.node(index).leftover,
+        }
+    }
+
+    /// `a op b`, which is a node only where the answer needs one. Two
+    /// lengths that keep their order whatever the room comes to are already
+    /// decided, and so are two operands that are the same thing.
+    fn combine(&mut self, op: Op, a: Operand, b: Operand) -> Operand {
+        if let (Some(x), Some(y)) = (a.linear(), b.linear()) {
+            if matches!(op, Op::Sum) {
+                return Operand::Linear(x + y);
+            }
+            if let Some(order) = independent_order(x, y) {
+                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 = u32::try_from(self.0.len()).expect("more nodes than one arena can number");
+        let leftover = self.leftover(a) || self.leftover(b);
+        self.0.push(Node { op, a, b, leftover });
+        Operand::Node(index)
+    }
+
+    /// Copies `at` and everything under it out of `from`, with every length
+    /// it holds passed through `resolve`. Folded again on the way in, since
+    /// resolving a fraction can settle a comparison that was open before it.
+    fn graft(
+        &mut self,
+        from: &Self,
+        at: Operand,
+        resolve: impl Copy + Fn(LayoutLen) -> LayoutLen,
+    ) -> Operand {
+        let index = match at {
+            Operand::Linear(len) => return Operand::Linear(resolve(len)),
+            Operand::Node(index) => index,
+        };
+        let Node { op, a, b, .. } = from.node(index);
+        let a = self.graft(from, a, resolve);
+        let b = self.graft(from, b, resolve);
+        self.combine(op, a, b)
+    }
+
+    fn write(&self, f: &mut std::fmt::Formatter<'_>, at: Operand) -> std::fmt::Result {
+        let index = match at {
+            Operand::Linear(len) => return write!(f, "{len}"),
+            Operand::Node(index) => index,
+        };
+        let Node { op, a, b, .. } = self.node(index);
+        write!(
+            f,
+            "{}(",
+            match op {
+                Op::Sum => "sum",
+                Op::Min => "min",
+                Op::Max => "max",
+            }
+        )?;
+        self.write(f, a)?;
+        write!(f, ", ")?;
+        self.write(f, b)?;
+        write!(f, ")")
+    }
+}
+
+/// A size request before a container has divided its leftover space.
+/// Comparisons keep both operands until the share is known.
+///
+/// An expression is the same nodes the layout pass allocates, in an arena of
+/// its own: importing one copies those nodes into the pass's arena, so there
+/// is no second shape to keep in step and one place where folding is decided.
+#[derive(Clone, PartialEq)]
+pub enum SizeRequest {
+    Linear(LayoutLen),
+    /// Behind a pointer, because a plain length is what nearly every rule
+    /// holds and an expression should cost those rules nothing.
+    Expr(Box<Expr>),
+}
+
+/// An expression's own arena, and which of its nodes is the whole of it.
+/// `root` is a node number rather than an operand, so an expression that
+/// folded all the way down to a length cannot be written as one: that is a
+/// [`SizeRequest::Linear`].
+#[derive(Clone, Debug, PartialEq)]
+pub struct Expr {
+    nodes: Nodes,
+    root: u32,
+}
+
+impl SizeRequest {
+    pub fn min(self, other: impl Into<Self>) -> Self {
+        self.join(Op::Min, other.into())
+    }
+
+    pub fn max(self, other: impl Into<Self>) -> Self {
+        self.join(Op::Max, other.into())
+    }
+
+    pub fn clamp(self, min: impl Into<Self>, max: impl Into<Self>) -> Self {
+        self.max(min).min(max)
+    }
+
+    /// `self op other`, keeping `self`'s arena and copying `other`'s into
+    /// it, so the two sets of node numbers become one. Two requests that are
+    /// the same request compare to the same thing whatever the room is, which
+    /// is a comparison worth not building -- but adding something to itself
+    /// is twice it.
+    fn join(self, op: Op, other: Self) -> Self {
+        if self == other && !matches!(op, Op::Sum) {
+            return self;
+        }
+        let (mut nodes, a) = match self {
+            Self::Linear(len) => (Nodes::default(), Operand::Linear(len)),
+            Self::Expr(expr) => {
+                let Expr { nodes, root } = *expr;
+                (nodes, Operand::Node(root))
+            }
+        };
+        let b = match other {
+            Self::Linear(len) => Operand::Linear(len),
+            Self::Expr(expr) => nodes.graft(&expr.nodes, Operand::Node(expr.root), |len| len),
+        };
+        match nodes.combine(op, a, b) {
+            Operand::Linear(len) => Self::Linear(len),
+            Operand::Node(root) => Self::Expr(Box::new(Expr { nodes, root })),
+        }
+    }
+}
+
+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 std::ops::Add for SizeRequest {
+    type Output = Self;
+
+    fn add(self, other: Self) -> Self {
+        self.join(Op::Sum, other)
+    }
+}
+
+impl std::fmt::Display for SizeRequest {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Linear(len) => write!(f, "{len}"),
+            Self::Expr(expr) => expr.nodes.write(f, Operand::Node(expr.root)),
+        }
+    }
+}
+
+/// The same, since an arena printed as a struct is not a tree anyone can
+/// write out again, which is what a request is printed for.
+impl std::fmt::Debug for SizeRequest {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self, f)
+    }
+}
+
+/// 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: u32,
+        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 {
+    /// The length itself, where no comparison is waiting on an allocation.
+    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(Default)]
+pub(crate) struct RequestArena {
+    nodes: Nodes,
+    epoch: u64,
+}
+
+impl RequestArena {
+    pub(crate) fn reset(&mut self) {
+        self.nodes.0.clear();
+        self.epoch = self
+            .epoch
+            .checked_add(1)
+            .expect("layout generation exhausted");
+    }
+
+    /// An operand of this pass's arena as the handle that leaves it. The
+    /// epoch says which pass numbered the node, so a handle a widget kept
+    /// past its pass is caught rather than answering about whatever node
+    /// took its place.
+    fn handle(&self, at: Operand) -> RequestedLen {
+        RequestedLen(match at {
+            Operand::Linear(len) => RequestValue::Linear(len),
+            Operand::Node(index) => RequestValue::Deferred {
+                index,
+                epoch: self.epoch,
+                leftover: self.nodes.leftover(at),
+            },
+        })
+    }
+
+    /// The other direction, checked once where a handle comes back in rather
+    /// than again at every level of the walk it starts.
+    fn operand(&self, request: RequestedLen) -> Operand {
+        match request.0 {
+            RequestValue::Linear(len) => Operand::Linear(len),
+            RequestValue::Deferred { index, epoch, .. } => {
+                assert_eq!(epoch, self.epoch, "request retained beyond its layout pass");
+                Operand::Node(index)
+            }
+        }
+    }
+
+    /// A rule's expression in this pass's arena, with its fractions resolved
+    /// against the rel base the widget is being asked with.
+    pub(crate) fn import(&mut self, request: &SizeRequest, base: Len) -> RequestedLen {
+        let at = match request {
+            SizeRequest::Linear(len) => Operand::Linear(len.within_len(base)),
+            SizeRequest::Expr(expr) => {
+                self.nodes
+                    .graft(&expr.nodes, Operand::Node(expr.root), |len| {
+                        len.within_len(base)
+                    })
+            }
+        };
+        self.handle(at)
+    }
+
+    pub(crate) fn bounded(&mut self, request: RequestedLen, bound: Bound) -> RequestedLen {
+        let request = match bound.min {
+            Some(min) => self.combine(Op::Max, request, min.into()),
+            None => request,
+        };
+        match bound.max {
+            Some(max) => self.combine(Op::Min, request, max.into()),
+            None => request,
+        }
+    }
+
+    fn combine(&mut self, op: Op, a: RequestedLen, b: RequestedLen) -> RequestedLen {
+        let (a, b) = (self.operand(a), self.operand(b));
+        let at = self.nodes.combine(op, a, b);
+        self.handle(at)
+    }
+
+    pub(crate) fn minimum(&self, request: RequestedLen, window: Px) -> Px {
+        let at = self.operand(request);
+        Px::from_raw(self.segment(at, Ratio::ZERO, window).fixed as i32)
+    }
+
+    fn segment(&self, of: Operand, at: Ratio, window: Px) -> Segment {
+        let index = match of {
+            Operand::Linear(len) => {
+                debug_assert!(
+                    len.leftover >= Weight::ZERO,
+                    "a leftover weight cannot be negative"
+                );
+                return Segment {
+                    fixed: i64::from(len.without_leftover().to_px(window).raw()),
+                    weight: i64::from(len.leftover.raw()),
+                    end: None,
+                };
+            }
+            Operand::Node(index) => index,
+        };
+        let Node { op, a, b, .. } = self.nodes.node(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
+    }
+
+    /// Divides `room` between requests whose weights are nonnegative, one
+    /// length per request. A floor can overflow the room and a cap can leave
+    /// part of it unused, so the lengths need not come to `room`. Each edge
+    /// is rounded from the running total rather than from the length before
+    /// it, so two neighbouring slots meet exactly.
+    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(self.operand(*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(self.operand(*request), at, window).value(at);
+            let den = i128::from(at.den);
+            // Half away from zero, which is what `Fixed` rounds a division
+            // to: the two decide the same edge, and a change to one of them
+            // is a change to the other.
+            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 {
+        debug_assert_ne!(den, 0, "a ratio of nothing");
+        if den < 0 {
+            Self {
+                num: -num,
+                den: -den,
+            }
+        } else {
+            Self { num, den }
+        }
+    }
+}
+
+impl Ord for Ratio {
+    fn cmp(&self, other: &Self) -> 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<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 HashMap<WidgetId, 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];
+        let request = match &rule.request {
+            Some(request) => self.arena.import(request, self.rel_base),
+            None => {
+                let widget = self.widgets.get_dyn(child.id())?;
+                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: Bound) -> RequestedLen {
+        self.arena.bounded(request, bound.within_len(self.rel_base))
+    }
+
+    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(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<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

@@ -0,0 +1,173 @@
+use crate::util::impl_axis_index;
+use crate::{LayoutLen, Len, Rel, SizeRequest, Weight};
+
+/// A preferred length and independent bounds on one axis. Without a
+/// request, the widget's drawing supplies the preferred length.
+#[derive(Debug, Clone, PartialEq, Default)]
+pub struct SizeRule {
+    pub request: Option<SizeRequest>,
+    pub bound: Bound,
+}
+
+impl SizeRule {
+    pub const FREE: Self = Self {
+        request: None,
+        bound: Bound::ANY,
+    };
+
+    pub fn min(min: Len) -> Self {
+        Self::bounded(Bound {
+            min: Some(min),
+            max: None,
+        })
+    }
+
+    pub fn max(max: Len) -> Self {
+        Self::bounded(Bound {
+            min: None,
+            max: Some(max),
+        })
+    }
+
+    pub fn clamp(min: Len, max: Len) -> Self {
+        Self::bounded(Bound {
+            min: Some(min),
+            max: Some(max),
+        })
+    }
+
+    /// A bound and no preferred length, so whatever the widget draws is held
+    /// to it.
+    fn bounded(bound: Bound) -> Self {
+        Self {
+            request: None,
+            bound,
+        }
+    }
+
+    pub fn has_fraction(&self) -> bool {
+        self.exact().is_some_and(|len| len.rel != Rel::ZERO) || self.bound.has_fraction()
+    }
+
+    /// A linear preferred length, before applying the independent bounds.
+    pub fn exact(&self) -> Option<LayoutLen> {
+        match self.request {
+            Some(SizeRequest::Linear(len)) => Some(len),
+            _ => None,
+        }
+    }
+
+    /// Requests whose final length needs allocation, including a linear
+    /// share constrained by an independent bound.
+    pub(crate) fn deferred(&self) -> Option<&SizeRequest> {
+        let request = self.request.as_ref()?;
+        match request {
+            SizeRequest::Linear(len)
+                if len.leftover == Weight::ZERO || self.bound == Bound::ANY =>
+            {
+                None
+            }
+            _ => Some(request),
+        }
+    }
+}
+
+/// A floor, a cap, or both, independent of the preferred length.
+/// Fractions use the incoming rel base. An allocated slot keeps the
+/// allocator's base for bounds, even when the slot narrows the widget's own.
+///
+/// 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>,
+}
+
+impl Bound {
+    /// Every length.
+    pub const ANY: Self = Self {
+        min: None,
+        max: None,
+    };
+
+    /// Whether either end is a fraction of the rel base, so that the same
+    /// bound against a different one binds at a different length.
+    pub fn has_fraction(&self) -> bool {
+        [self.min, self.max]
+            .into_iter()
+            .flatten()
+            .any(|len| len.rel != Rel::ZERO)
+    }
+
+    /// 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,
+    };
+}
+
+impl_axis_index!(Bounds => Bound);
+
+impl From<LayoutLen> for SizeRule {
+    fn from(len: LayoutLen) -> Self {
+        SizeRequest::from(len).into()
+    }
+}
+
+impl From<SizeRequest> for SizeRule {
+    fn from(request: SizeRequest) -> Self {
+        Self {
+            request: Some(request),
+            bound: Bound::ANY,
+        }
+    }
+}
+
+impl From<Option<LayoutLen>> for SizeRule {
+    fn from(len: Option<LayoutLen>) -> Self {
+        len.map_or(Self::FREE, Self::from)
+    }
+}
+
+/// 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, PartialEq, Default)]
+pub struct SizeRules {
+    pub x: SizeRule,
+    pub y: SizeRule,
+}
+
+impl_axis_index!(SizeRules => SizeRule);
+
+/// Box lengths chosen by the ask: a declaration, a natural-size hint, or
+/// a binding bound. These are window lengths, already resolved against the
+/// incoming rel base. Moving a drawing preserves them instead of resolving
+/// a fraction against its destination a second time.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct Declared {
+    pub x: Option<Len>,
+    pub y: Option<Len>,
+}
+
+impl Declared {
+    pub const NONE: Self = Self { x: None, y: None };
+}
+
+impl_axis_index!(Declared => Option<Len>);

core/src/widget/widgets.rs

@@ -1,7 +1,8 @@
 use std::sync::mpsc::{Receiver, Sender, channel};
 
 use crate::{
-    IdLike, StrongWidget, WeakWidget, Widget, WidgetData, WidgetId,
+    Axis, AxisAlign, Bound, IdLike, Len, RegionAlign, SizeRequest, SizeRule, SizeRules,
+    StrongWidget, WeakWidget, Widget, WidgetData, WidgetId,
     util::{DynBorrower, HashSet, SlotVec, forget_mut, to_mut},
 };
 
@@ -29,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())
     }
@@ -40,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>
@@ -100,6 +109,107 @@ impl Widgets {
         self.data_mut(id.id()).unwrap().label = label;
     }
 
+    /// Whether this widget owns a movable retained region.
+    pub fn is_region_node(&self, id: impl IdLike) -> bool {
+        self.data(id).unwrap().region_node
+    }
+
+    /// Chooses whether this widget's retained drawing has one movable region
+    /// of its own. Changing the boundary redraws the subtree once so every
+    /// primitive names the right coordinate space.
+    pub fn set_region_node(&mut self, id: impl IdLike, region_node: bool) {
+        let id = id.id();
+        let data = self.data_mut(id).unwrap();
+        if data.region_node == region_node {
+            return;
+        }
+        data.region_node = region_node;
+        self.needs_redraw.insert(id);
+    }
+
+    /// The length rules whoever draws this widget applies to its box.
+    pub fn size_rules(&self, id: impl IdLike) -> &SizeRules {
+        &self.data(id).unwrap().size
+    }
+
+    /// Sets one axis's rule. The widget is marked rather than its parent
+    /// because the parent is not known here; `redraw` escalates a changed
+    /// declared length to whoever resolves it.
+    pub fn set_size_rule(&mut self, id: impl IdLike, axis: Axis, rule: SizeRule) {
+        let id = id.id();
+        let data = self.data_mut(id).unwrap();
+        if data.size[axis] == rule {
+            return;
+        }
+        data.size[axis] = rule;
+        self.needs_redraw.insert(id);
+    }
+
+    /// Changes the preferred length, leaving the bounds beside it alone.
+    pub fn set_len(&mut self, id: impl IdLike, axis: Axis, len: impl Into<SizeRequest>) {
+        let id = id.id();
+        let request = Some(len.into());
+        let rule = &mut self.data_mut(id).unwrap().size[axis];
+        if rule.request == request {
+            return;
+        }
+        rule.request = request;
+        self.needs_redraw.insert(id);
+    }
+
+    /// Puts a floor under this widget's length on one axis, keeping a cap it
+    /// already had and the preferred length beside it.
+    pub fn set_min_len(&mut self, id: impl IdLike, axis: Axis, min: Len) {
+        self.edit_bound(id.id(), axis, |bound| bound.min = Some(min));
+    }
+
+    /// Puts a cap over it, keeping a floor it already had.
+    pub fn set_max_len(&mut self, id: impl IdLike, axis: Axis, max: Len) {
+        self.edit_bound(id.id(), axis, |bound| bound.max = Some(max));
+    }
+
+    /// Edits one axis's bound where it sits, rather than reading the whole
+    /// rule out and writing it back: an expression beside the bound is not
+    /// this edit's business, and copying it to move one end would be the
+    /// only thing here that ever copies one.
+    fn edit_bound(&mut self, id: WidgetId, axis: Axis, edit: impl FnOnce(&mut Bound)) {
+        let bound = &mut self.data_mut(id).unwrap().size[axis].bound;
+        let before = *bound;
+        edit(bound);
+        if *bound != before {
+            self.needs_redraw.insert(id);
+        }
+    }
+
+    /// 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
+    }
+
+    /// Sets one axis's alignment. Which box a widget ends up in is its
+    /// parent's to decide, so this is escalated the way a length rule is.
+    pub fn set_alignment(&mut self, id: impl IdLike, axis: Axis, align: AxisAlign) {
+        let id = id.id();
+        let data = self.data_mut(id).unwrap();
+        if data.align[axis] == align {
+            return;
+        }
+        data.align[axis] = align;
+        self.needs_redraw.insert(id);
+    }
+
+    /// Both axes at once.
+    pub fn set_size_rules(
+        &mut self,
+        id: impl IdLike,
+        x: impl Into<SizeRule>,
+        y: impl Into<SizeRule>,
+    ) {
+        let id = id.id();
+        self.set_size_rule(id, Axis::X, x.into());
+        self.set_size_rule(id, Axis::Y, y.into());
+    }
+
     pub fn data_mut(&mut self, id: impl IdLike) -> Option<&mut WidgetData> {
         self.vec.get_mut(id.id())
     }
@@ -122,8 +232,6 @@ impl Default for Widgets {
     }
 }
 
-pub type WidgetWrapper<'a> = DynBorrower<'a, dyn Widget>;
-
 impl<I: IdLike> std::ops::Index<I> for Widgets
 where
     I::Widget: Sized + Widget,

examples/tabs/main.rs

@@ -20,22 +20,26 @@ impl DefaultAppState for Client {
         let pad_test = (
             rrect.color(Color::BLUE),
             (
+                // The square is one widget and the two shares of the row it
+                // sits centred in are another: a length is a property of a
+                // widget, so `.width` here would overwrite the `.sized`.
                 rrect
                     .color(Color::RED)
                     .sized((100, 100))
                     .center()
-                    .width(rest(2)),
+                    .wrapper()
+                    .width(leftover(2)),
                 (
                     rrect.color(Color::ORANGE),
                     rrect.color(Color::LIME).pad(10.0),
                 )
                     .span(Dir::RIGHT)
-                    .width(rest(2)),
+                    .width(leftover(2)),
                 rrect.color(Color::YELLOW),
             )
                 .span(Dir::RIGHT)
                 .pad(10)
-                .width(rest(3)),
+                .width(leftover(3)),
         )
             .span(Dir::RIGHT)
             .add(rsc);
@@ -121,11 +125,11 @@ impl DefaultAppState for Client {
             .add(rsc);
 
         let text_edit_scroll = (
-            msg_area.height(rest(1)),
+            msg_area.height(leftover(1)),
             (
                 Rect::new(Color::WHITE.darker(0.9)),
                 (
-                    add_text.width(rest(1)),
+                    add_text.width(leftover(1)),
                     Rect::new(Color::GREEN)
                         .on(CursorSense::click(), move |ctx, rsc: &mut ClientRsc| {
                             rsc.run_event::<Submit>(add_text, (), ctx.state);
@@ -143,7 +147,7 @@ impl DefaultAppState for Client {
             .span(Dir::DOWN)
             .add(rsc);
 
-        let main = WidgetPtr::new().add(rsc);
+        let main = Wrapper::new().add(rsc);
 
         let vals = Rc::new(RefCell::new((0, Vec::new())));
         let mut switch_button = |color, to: WeakWidget, label| {

examples/text.rs

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

macro/src/lib.rs

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

scripts/run-headless.sh

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

src/default/attr.rs

@@ -15,8 +15,11 @@ 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;
-            let pos = ctx.data.pos + container_pos - id_pos;
-            let size = region.size();
+            // The two regions are on the grid and the pointer is not, so the
+            // step between them is taken there and the pointer keeps the
+            // precision the platform gave it.
+            let pos = ctx.data.pos + (container_pos - id_pos).to_f32();
+            let size = region.size().to_f32();
             select(
                 rsc,
                 ctx.data.render,
@@ -70,8 +73,8 @@ fn select(
     if let Some(region) = render.window_region(&id) {
         state.window.set_ime_allowed(true);
         state.window.set_ime_cursor_area(
-            LogicalPosition::<f32>::from(region.top_left.tuple()),
-            LogicalSize::<f32>::from(region.size().tuple()),
+            LogicalPosition::<f32>::from(region.top_left.to_f32().tuple()),
+            LogicalSize::<f32>::from(region.size().to_f32().tuple()),
         );
     }
     state.focus = Some(id);

src/default/mod.rs

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

src/default/render.rs

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

src/default/sense.rs

@@ -198,7 +198,7 @@ impl SensorUi for UiRenderState {
                 let Some(region) = region_of(id) else {
                     continue;
                 };
-                if !cursor.exists || !region.contains(cursor.pos) {
+                if !cursor.exists || !region.contains(PxVec2::from_f32(cursor.pos)) {
                     continue;
                 }
                 hovered.now.push(id);
@@ -249,8 +249,8 @@ fn deliver<Rsc: HasEvents>(
     region: PixelRegion,
 ) -> bool {
     let data = CursorData {
-        pos: cursor.pos - region.top_left,
-        size: region.bot_right - region.top_left,
+        pos: cursor.pos - region.top_left.to_f32(),
+        size: region.size().to_f32(),
         scroll_delta: cursor.scroll_delta,
         hover,
         cursor: cursor.clone(),

src/harness.rs

@@ -29,8 +29,14 @@ macro_rules! assert_corners {
         assert_eq!(
             $harness.region(&$id).expect("widget drew nothing"),
             $crate::core::PixelRegion {
-                top_left: $crate::core::util::Vec2::new($x0 as f32, $y0 as f32),
-                bot_right: $crate::core::util::Vec2::new($x1 as f32, $y1 as f32),
+                top_left: $crate::core::PxVec2::new(
+                    $crate::core::Px::from_f32($x0 as f32),
+                    $crate::core::Px::from_f32($y0 as f32),
+                ),
+                bot_right: $crate::core::PxVec2::new(
+                    $crate::core::Px::from_f32($x1 as f32),
+                    $crate::core::Px::from_f32($y1 as f32),
+                ),
             }
         );
     };
@@ -138,9 +144,9 @@ impl Harness {
         // bound that comes with `SyncSender` is far past anything a test
         // leaves unread.
         let (send, updates) = sync_channel(1024);
-        let rsc = DefaultRsc::init(Arc::new(Queue(send)));
+        let mut rsc = DefaultRsc::init(Arc::new(Queue(send)));
         let mut render = UiRenderState::new();
-        render.resize(size);
+        render.resize(size, rsc.widgets_mut());
         Self {
             rsc,
             render,
@@ -151,11 +157,18 @@ impl Harness {
     }
 
     pub fn size(&self) -> Vec2 {
-        self.render.output_size()
+        self.render.output_size().to_f32()
     }
 
     pub fn resize(&mut self, size: impl Into<Vec2>) {
-        self.render.resize(size);
+        self.render.resize(size, self.rsc.widgets_mut());
+    }
+
+    /// Changes a length rule after the fact, the way `.width()` sets one --
+    /// which leaves a bound beside it alone, where writing the whole rule
+    /// would drop it and pass the case for the wrong reason.
+    pub fn set_len(&mut self, id: impl IdLike, axis: Axis, len: impl Into<LayoutLen>) {
+        self.rsc.widgets_mut().set_len(id, axis, len.into());
     }
 
     /// Sets the root and lays it out, so a pointer event has something to hit.

src/widget/image.rs

@@ -8,15 +8,20 @@ pub struct Image {
 impl Widget for Image {
     fn draw(&mut self, painter: &mut Painter) -> Size {
         painter.primitive(&self.handle);
-        Size::abs(self.handle.size())
+        Size::px(self.handle.size())
     }
 
-    fn size_hint(&self, axis: Axis) -> Option<Len> {
-        Some(Len::abs(self.handle.size().axis(axis)))
+    fn size_hint(&self, axis: Axis) -> Option<LayoutLen> {
+        Some(LayoutLen::px(self.handle.size()[axis]))
+    }
 }
 
-    fn on_resize(&self, _: Axis) -> OnResize {
-        OnResize::Scale
+impl Image {
+    /// One texture already uploaded, for a caller holding its handle: [`image()`]
+    /// uploads what it is given, and several widgets showing one picture want
+    /// one upload and one slot between them.
+    pub fn new(handle: TextureHandle) -> Self {
+        Self { handle }
     }
 }
 

src/widget/mask.rs

@@ -6,12 +6,20 @@ pub struct Masked {
 
 impl Widget for Masked {
     fn draw(&mut self, painter: &mut Painter) -> Size {
-        painter.set_mask(painter.region());
-        painter.widget(&self.inner).size()
+        painter.set_mask(UiRegion::FULL);
+        painter.widget(&self.inner);
+        // What it occupies is its box, on both axes, because it clips what is
+        // inside to that box: it can neither take less of one nor honestly ask
+        // for more. Passing the inner size up instead asks to be placed at a
+        // length it does not draw, and the framework would place the drawing it
+        // clipped away. `Scroll` reports its box too, for a reason of its own:
+        // it is a viewport whose content is positioned by a move rather than
+        // clipped, since masking is a capability a caller opts into by putting
+        // one of these around it.
+        Size::LEFTOVER
     }
 
-    /// It clips to the box it was given, not to the part its child used.
-    fn on_resize(&self, _: Axis) -> OnResize {
-        OnResize::Redraw
+    fn size_hint(&self, _: Axis) -> Option<LayoutLen> {
+        Some(LayoutLen::LEFTOVER)
     }
 }

src/widget/mod.rs

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

src/widget/position/align.rs

@@ -1,42 +0,0 @@
-use crate::prelude::*;
-
-pub struct Aligned {
-    pub inner: StrongWidget,
-    pub align: Align,
-}
-
-impl Widget for Aligned {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
-        let known = match self.align.tuple() {
-            (Some(_), Some(_)) => painter
-                .known_len(&self.inner, Axis::X, UiRegion::FULL)
-                .zip(painter.known_len(&self.inner, Axis::Y, UiRegion::FULL))
-                .map(|(x, y)| Size { x, y }),
-            (Some(_), None) => painter
-                .known_len(&self.inner, Axis::X, UiRegion::FULL)
-                .map(|x| Size { x, y: Len::REST }),
-            (None, Some(_)) => painter
-                .known_len(&self.inner, Axis::Y, UiRegion::FULL)
-                .map(|y| Size { x: Len::REST, y }),
-            (None, None) => Some(Size::REST),
-        };
-        // Drawn where it may be too big only when the aligned axes are not
-        // already known, then given its aligned box once its size is known.
-        let had_size = known.is_some();
-        let size = known.unwrap_or_else(|| painter.place(&self.inner, UiRegion::FULL).size());
-        let region = match self.align.tuple() {
-            (Some(x), Some(y)) => size.to_uivec2().align(RegionAlign { x, y }),
-            (Some(x), None) => UiRegion::new(size.x.apply_rest().align(x), UiSpan::FULL),
-            (None, Some(y)) => UiRegion::new(UiSpan::FULL, size.y.apply_rest().align(y)),
-            (None, None) => UiRegion::FULL,
-        };
-        let placed = painter.place(&self.inner, region).size();
-        if had_size { placed } else { size }
-    }
-
-    /// The aligned box is a fraction of its own, so the child keeps its
-    /// length and stays against the edge it was aligned to.
-    fn on_resize(&self, _: Axis) -> OnResize {
-        OnResize::Scale
-    }
-}

src/widget/position/layer.rs

@@ -6,14 +6,14 @@ 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();
         }
         painter.widget(&self.inner).size()
     }
-
-    fn on_resize(&self, _: Axis) -> OnResize {
-        OnResize::Scale
-    }
 }

src/widget/position/max_size.rs

@@ -1,25 +0,0 @@
-use crate::prelude::*;
-
-pub struct MaxSize {
-    pub inner: StrongWidget,
-    pub x: Option<Len>,
-    pub y: Option<Len>,
-}
-
-impl Widget for MaxSize {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
-        let child = painter.widget(&self.inner).size();
-        let output = painter.output_size();
-        Size {
-            x: capped(child.x, self.x, output.x),
-            y: capped(child.y, self.y, output.y),
-        }
-    }
-}
-
-fn capped(len: Len, max: Option<Len>, output: f32) -> Len {
-    match max {
-        Some(max) if len.apply_rest().to_abs(output) > max.apply_rest().to_abs(output) => max,
-        _ => len,
-    }
-}

src/widget/position/mod.rs

@@ -1,19 +1,13 @@
-mod align;
 mod layer;
-mod max_size;
 mod offset;
 mod pad;
 mod scroll;
-mod set_size;
 mod span;
 mod stack;
 
-pub use align::*;
 pub use layer::*;
-pub use max_size::*;
 pub use offset::*;
 pub use pad::*;
 pub use scroll::*;
-pub use set_size::*;
 pub use span::*;
 pub use stack::*;

src/widget/position/offset.rs

@@ -6,12 +6,13 @@ pub struct Offset {
 }
 
 impl Widget for Offset {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
-        let region = UiRegion::FULL.offset(self.amt);
-        painter.widget_within(&self.inner, region).size()
+    fn size_request(&self, requests: &mut SizeRequests, axis: Axis) -> Option<RequestedLen> {
+        requests.widget(&self.inner, axis)
     }
 
-    fn on_resize(&self, _: Axis) -> OnResize {
-        OnResize::Scale
+    fn draw(&mut self, painter: &mut Painter) -> Size {
+        painter
+            .widget_at(&self.inner, UiRegion::FULL.offset(self.amt))
+            .size()
     }
 }

src/widget/position/pad.rs

@@ -6,46 +6,54 @@ pub struct Pad {
 }
 
 impl Widget for Pad {
+    fn size_request(&self, requests: &mut SizeRequests, axis: Axis) -> Option<RequestedLen> {
+        requests.inset(&self.inner, axis, self.padding.along(axis))
+    }
+
     fn draw(&mut self, painter: &mut Painter) -> Size {
-        let inner = painter
-            .widget_within(&self.inner, self.padding.region())
-            .size();
+        // The inner's own alignment, not the near edge. This reports the
+        // inner's size plus the padding, so where the box is that answer the
+        // inset box is exactly the inner and alignment has no room to move
+        // it; where the box is bigger -- a share of a row, a rule over this
+        // widget -- the slack is the inner's to sit in, and forcing the near
+        // edge pinned it to a corner it had not asked for.
+        //
+        // Padding is an inset of both: it comes off the rel base, so `rel(1)`
+        // under it fills this widget rather than overflowing it by the
+        // padding, and it comes off the box, so what is drawn sits inside.
+        // The two stay distinct -- the box can be narrower still, where a row
+        // asked this widget in the room left, and a text wraps at that.
+        let inner = painter.widget_at(&self.inner, self.padding.region()).size();
         Size {
-            x: Len {
-                abs: inner.x.abs + self.padding.left + self.padding.right,
+            x: LayoutLen {
+                px: inner.x.px + self.padding.along(Axis::X),
                 ..inner.x
             },
-            y: Len {
-                abs: inner.y.abs + self.padding.top + self.padding.bottom,
+            y: LayoutLen {
+                px: inner.y.px + self.padding.along(Axis::Y),
                 ..inner.y
             },
         }
     }
-
-    /// The padding is an offset from each edge, so a longer box pads the same
-    /// amount and the child takes the rest.
-    fn on_resize(&self, _: Axis) -> OnResize {
-        OnResize::Scale
-    }
 }
 
 pub struct Padding {
-    pub left: f32,
-    pub right: f32,
-    pub top: f32,
-    pub bottom: f32,
+    pub left: Px,
+    pub right: Px,
+    pub top: Px,
+    pub bottom: Px,
 }
 
 impl Padding {
     pub const ZERO: Self = Self {
-        left: 0.0,
-        right: 0.0,
-        top: 0.0,
-        bottom: 0.0,
+        left: Px::ZERO,
+        right: Px::ZERO,
+        top: Px::ZERO,
+        bottom: Px::ZERO,
     };
 
     pub fn uniform(amt: impl UiNum) -> Self {
-        let amt = amt.to_f32();
+        let amt = Px::from_num(amt);
         Self {
             left: amt,
             right: amt,
@@ -53,80 +61,92 @@ impl Padding {
             bottom: amt,
         }
     }
-    pub fn region(&self) -> UiRegion {
-        let mut region = UiRegion::FULL;
-        region.x.start.abs += self.left;
-        region.y.start.abs += self.top;
-        region.x.end.abs -= self.right;
-        region.y.end.abs -= self.bottom;
+
+    /// Both sides of one axis together, which is what this padding takes
+    /// of a length along it.
+    pub fn along(&self, axis: Axis) -> Px {
+        match axis {
+            Axis::X => self.left + self.right,
+            Axis::Y => self.top + self.bottom,
+        }
+    }
+
+    /// `region` less this padding on each side.
+    pub fn region_of(&self, mut region: UiRegion) -> UiRegion {
+        region.x.start.px += self.left;
+        region.y.start.px += self.top;
+        region.x.end.px -= self.right;
+        region.y.end.px -= self.bottom;
         region
     }
+
+    pub fn region(&self) -> UiRegion {
+        self.region_of(UiRegion::FULL)
+    }
     pub fn x(amt: impl UiNum) -> Self {
-        let amt = amt.to_f32();
+        let amt = Px::from_num(amt);
         Self {
             left: amt,
             right: amt,
-            top: 0.0,
-            bottom: 0.0,
+            ..Self::ZERO
         }
     }
     pub fn y(amt: impl UiNum) -> Self {
-        let amt = amt.to_f32();
+        let amt = Px::from_num(amt);
         Self {
-            left: 0.0,
-            right: 0.0,
             top: amt,
             bottom: amt,
+            ..Self::ZERO
         }
     }
 
     pub fn top(amt: impl UiNum) -> Self {
         let mut s = Self::ZERO;
-        s.top = amt.to_f32();
+        s.top = Px::from_num(amt);
         s
     }
 
     pub fn bottom(amt: impl UiNum) -> Self {
         let mut s = Self::ZERO;
-        s.bottom = amt.to_f32();
+        s.bottom = Px::from_num(amt);
         s
     }
 
     pub fn left(amt: impl UiNum) -> Self {
         let mut s = Self::ZERO;
-        s.left = amt.to_f32();
+        s.left = Px::from_num(amt);
         s
     }
 
     pub fn right(amt: impl UiNum) -> Self {
         let mut s = Self::ZERO;
-        s.right = amt.to_f32();
+        s.right = Px::from_num(amt);
         s
     }
 
     pub fn with_top(mut self, amt: impl UiNum) -> Self {
-        self.top = amt.to_f32();
+        self.top = Px::from_num(amt);
         self
     }
 
     pub fn with_bottom(mut self, amt: impl UiNum) -> Self {
-        self.bottom = amt.to_f32();
+        self.bottom = Px::from_num(amt);
         self
     }
 
     pub fn with_left(mut self, amt: impl UiNum) -> Self {
-        self.left = amt.to_f32();
+        self.left = Px::from_num(amt);
         self
     }
 
     pub fn with_right(mut self, amt: impl UiNum) -> Self {
-        self.right = amt.to_f32();
+        self.right = Px::from_num(amt);
         self
     }
 }
 
 impl<T: UiNum> From<T> for Padding {
     fn from(amt: T) -> Self {
-        Self::uniform(amt.to_f32())
+        Self::uniform(amt)
     }
 }

src/widget/position/scroll.rs

@@ -3,38 +3,76 @@ use crate::prelude::*;
 pub struct Scroll {
     inner: StrongWidget,
     axis: Axis,
-    amt: f32,
+    amt: Px,
     snap_end: bool,
-    container_len: f32,
-    content_len: f32,
+    container_len: Px,
+    content_len: Px,
 }
 
 impl Widget for Scroll {
     fn draw(&mut self, painter: &mut Painter) -> Size {
-        let output_len = painter.output_len(self.axis);
-        let container_len = UiScalar::abs(painter.px_len(self.axis));
-        // Draw in the whole container only when its scrolling-axis length is
-        // not already known, then place it at the scrolled offset.
-        let known_len = painter.known_len(&self.inner, self.axis, UiRegion::FULL);
-        let measured = known_len.is_none();
-        let child = measured.then(|| painter.place(&self.inner, UiRegion::FULL).size());
-        let content_len = known_len
-            .unwrap_or_else(|| child.unwrap().axis(self.axis))
-            .apply_rest()
-            .within_len(container_len)
-            .to_abs(output_len);
-        self.container_len = container_len.to_abs(output_len);
-        self.content_len = content_len;
+        let container_len = painter.px_len(self.axis);
+        // Asked in the whole viewport, then put at the scrolled offset.
+        let answer_len = painter
+            .widget_at(&self.inner, PlaceDesc::WHOLE.fills())
+            .len(self.axis);
+        let answer_px = painter.to_px(answer_len.without_leftover(), self.axis);
+        self.container_len = container_len;
+        self.content_len = answer_px.max(container_len);
 
         if self.snap_end {
             self.amt = self.content_len - self.container_len;
         }
         self.update_amt();
+        // Reading the box in pixels above holds this drawing to that one
+        // length, so these two say where it holds more widely.
+        //
+        // Content of a fixed length that fits is handed the whole box below,
+        // and nothing here reads the box again, so every longer box gives the
+        // same drawing: it holds from the length the content needs upwards,
+        // and shrinking past that is what changes it. Where it sits in a box
+        // longer than itself is not this widget's to say -- placing its
+        // answer in the whole box is its own alignment, and that placement is
+        // a fraction of the box, so it holds at every length too.
+        //
+        // One scrolled part way sits where it is until the box shrinks past
+        // what is left of it. Kept to the end, it moves with every length.
+        let answer_is_px = answer_len.is_px();
+        if answer_is_px && self.content_len <= self.container_len {
+            painter.holds(self.axis, answer_px..=Px::MAX);
+        } else if answer_is_px && !self.snap_end {
+            let left = self.content_len - self.amt;
+            painter.holds(self.axis, Px::MIN..=left);
+        }
 
-        let mut region = UiRegion::FULL.offset(Vec2::from_axis(self.axis, -self.amt, 0.0));
-        region.axis_mut(self.axis).end = region.axis(self.axis).start.offset(self.content_len);
-        let placed = painter.place(&self.inner, region).size();
-        child.unwrap_or(placed)
+        // Content that fills the viewport is the viewport, and is handed back
+        // as it came -- it has nothing to scroll through, so the clamp above
+        // has already put `amt` at zero. Writing the same box as its own
+        // length in pixels is the same box in another form, and the two do
+        // not round alike: a part centred in `rel 1` lands a step from one
+        // centred in `px 900`, since halving a difference is not halving each
+        // part of it.
+        let content = match self.content_len > self.container_len {
+            true => {
+                let start = Len::from_parts(Rel::ZERO, -self.amt);
+                UiSpan::new(start, start.offset(self.content_len)).shifted_desc()
+            }
+            false => PlaceDescAxis::WHOLE,
+        };
+        // The viewport is the inner's rel base, so a fraction it declares or
+        // reports is a fraction of what is on screen rather than of the
+        // content box its own answer decided. Where it goes is the content
+        // box, scrolled: its drawing moved there, not made again there.
+        painter.place_at(&self.inner, content.on_axis(self.axis).fills());
+        // What it occupies is its box, on both axes: it clips its content to
+        // that box, so it can neither take less of one nor honestly ask for
+        // more. The content's length is what it scrolls through, not what it
+        // is.
+        Size::LEFTOVER
+    }
+
+    fn size_hint(&self, _: Axis) -> Option<LayoutLen> {
+        Some(LayoutLen::LEFTOVER)
     }
 }
 
@@ -43,22 +81,24 @@ impl Scroll {
         Self {
             inner,
             axis,
-            amt: 0.0,
+            amt: Px::ZERO,
             snap_end: true,
-            container_len: 0.0,
-            content_len: 0.0,
+            container_len: Px::ZERO,
+            content_len: Px::ZERO,
         }
     }
 
     pub fn update_amt(&mut self) {
-        self.amt = self.amt.max(0.0);
-        let len = (self.content_len - self.container_len).max(0.0);
+        self.amt = self.amt.max(Px::ZERO);
+        let len = (self.content_len - self.container_len).max(Px::ZERO);
         self.amt = self.amt.min(len);
         self.snap_end = self.amt == len;
     }
 
+    /// Scrolled by a distance the platform measures, which is the last place
+    /// a wheel notch or a finger is a float.
     pub fn scroll(&mut self, amt: f32) {
-        self.amt -= amt;
+        self.amt -= Px::from_f32(amt);
         self.update_amt();
     }
 }

src/widget/position/set_size.rs

@@ -1,30 +0,0 @@
-use crate::prelude::*;
-
-pub struct SetSize {
-    pub inner: StrongWidget,
-    pub x: Option<Len>,
-    pub y: Option<Len>,
-}
-
-impl Widget for SetSize {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
-        let child = painter.widget(&self.inner).size();
-        Size {
-            x: self.x.unwrap_or(child.x),
-            y: self.y.unwrap_or(child.y),
-        }
-    }
-
-    /// A declared axis is known without looking at the child, which is what
-    /// lets a span lay out around `.height(rest(1))` without drawing it.
-    fn size_hint(&self, axis: Axis) -> Option<Len> {
-        match axis {
-            Axis::X => self.x,
-            Axis::Y => self.y,
-        }
-    }
-
-    fn on_resize(&self, _: Axis) -> OnResize {
-        OnResize::Scale
-    }
-}

src/widget/position/span.rs

@@ -4,87 +4,236 @@ use std::marker::PhantomData;
 pub struct Span {
     pub children: Vec<StrongWidget>,
     pub dir: Dir,
-    pub gap: f32,
+    pub gap: Px,
 }
 
 impl Widget for Span {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
-        let axis = self.dir.axis;
-        // A length for every child before any is placed: from its own hint
-        // where it has one, and from drawing it where it does not.
-        let mut cursor = UiScalar::rel_min();
-        let mut lens = Vec::with_capacity(self.children.len());
+    fn size_request(&self, requests: &mut SizeRequests, axis: Axis) -> Option<RequestedLen> {
+        if axis != self.dir.axis {
+            // A share can be hidden when the other axis has no room. Its
+            // cross-axis length then contributes nothing to the drawn answer.
+            return None;
+        }
+        let mut total = RequestedLen::from(Len::from_parts(Rel::ZERO, self.gaps()));
         for child in &self.children {
-            let mut span = UiSpan::new(cursor, UiScalar::rel_max());
-            if self.dir.sign == Sign::Neg {
-                span.flip();
+            let child = requests.widget(child, axis)?;
+            total = requests.sum(total, child);
         }
-            let region = UiRegion::from_axis(axis, span, UiSpan::FULL);
-            let len = match painter.known_len(child, axis, region) {
-                Some(len) => len,
-                None => painter.place(child, region).len(axis),
-            };
-            cursor.abs += len.abs + self.gap;
-            cursor.rel += len.rel;
-            lens.push(len);
+        Some(total)
     }
 
-        let gap = self.gap * self.children.len().saturating_sub(1) as f32;
-        let total = lens.iter().fold(Len::abs(gap), |sum, len| sum + *len);
-
-        let mut start = UiScalar::rel_min();
-        let mut ortho = Len::ZERO;
-        for (child, len) in self.children.iter().zip(&lens) {
-            let mut span = UiSpan::FULL;
-            span.start = start;
-            if len.rest > 0.0 {
-                let offset = UiScalar::new(total.rel, total.abs);
-                let rel_end = UiScalar::rel(len.rest / total.rest);
-                let end = (UiScalar::rel_max() + start) - offset;
-                start = rel_end.within(&start.to(end));
-            }
-            start.abs += len.abs;
-            start.rel += len.rel;
-            span.end = start;
-            let mut region = UiRegion::from_axis(axis, span, UiSpan::FULL);
-            if self.dir.sign == Sign::Neg {
-                region.flip(axis);
-            }
-            let used = painter.place(child, region).size().axis(!axis);
-            // TODO: rel shouldn't do this, but no easy way before actually calculating pixels
-            if used.rel > 0.0 || used.rest > 0.0 {
-                ortho = Len::REST;
-            } else if ortho.rest == 0.0 {
-                ortho.abs = ortho.abs.max(used.abs);
-            }
-            start.abs += self.gap;
-        }
-
-        let along = match total.rest == 0.0 && total.rel == 0.0 {
-            true => total,
-            false => Len::default(),
-        };
-        Size::from_axis(axis, along, ortho)
-    }
-
-    /// Every child is placed in fractions and offsets of the span's own box,
-    /// so a longer box holds the same layout and the children follow it.
-    fn on_resize(&self, _: Axis) -> OnResize {
-        OnResize::Scale
+    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.gaps();
+        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(|| &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.linear().unwrap(),
+            ),
+        };
+        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
+        // answers nothing and makes its size depend on theirs for it. A rule
+        // that only bounds the length does not count: the answer is still
+        // this span's to give.
+        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. Both ends of a slot are read from those two rather
+        // than stepped from the last child: the share of the room is
+        // rounded, and taking each end from the one before it would carry
+        // every rounding along the row.
+        let mut fixed = Len::ZERO;
+        let mut taken = Weight::ZERO;
+        let mut ortho = LayoutLen::ZERO;
+        // Nothing divides the room where no child asked for any of it, and a
+        // ratio of a whole of nothing has no answer.
+        let reached = |fixed: Len, taken: Weight| match any_leftover {
+            false => fixed,
+            true => fixed + room.scale(Rel::ratio(taken, total.leftover)),
+        };
+        for (index, (child, request)) in self.children.iter().zip(lens.iter()).enumerate() {
+            // An allocated row already has a length for every child; without
+            // one the request is the length and the room is divided here.
+            // Either way 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.
+            let (len, shares, nothing_left) = match allocated {
+                Some(allocated) => {
+                    let len = LayoutLen {
+                        px: allocated[index],
+                        ..LayoutLen::ZERO
+                    };
+                    let shares = request.has_leftover();
+                    (len, shares, shares && len.px == Px::ZERO)
+                }
+                None => {
+                    let len = request.linear().unwrap();
+                    let shares = len.leftover > Weight::ZERO && has_room;
+                    (len, shares, len.is_only_leftover() && !has_room)
+                }
+            };
+            if nothing_left {
+                painter.undraw(child);
+                fixed.px += self.gap;
+                continue;
+            }
+            let from = reached(fixed, taken);
+            if shares {
+                taken += len.leftover;
+            }
+            fixed += len.without_leftover();
+            let to = reached(fixed, taken);
+            // Along the row the span says where the child goes, and that slot
+            // is the child's box outright rather than something to place an
+            // answer inside again. A share is decided here and nowhere
+            // else: its slot narrows its rel base, and the child is asked in
+            // it, since a text wraps at the width it is actually given. A
+            // fixed child's slot is its own answer, so a drawing made in the
+            // room is put there as it is, and one not made yet is made here.
+            let slot = self.slot(row, from, to);
+            let mut place = slot.shifted_desc().allocated().on_axis(axis);
+            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 the span scalable too;
+                // only fixed children are compared with one another.
+                if !used.is_px() {
+                    ortho = LayoutLen::LEFTOVER;
+                } else if ortho.leftover == Weight::ZERO {
+                    ortho.px = ortho.px.max(used.px);
+                }
+            }
+            fixed.px += self.gap;
+        }
+
+        // Where nothing was allocated the weight is carried whole rather
+        // than collapsed to one share, 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
+        // one share per level does not give. Resolution happens at the
+        // nearest ancestor with a length, and the root always has one --
+        // or, where a comparison deferred the row, at the ancestor whose
+        // allocation discovery carried these requests to, and `total` is
+        // pixels by the time it gets here.
+        let ortho = match shrinks {
+            true => ortho,
+            false => LayoutLen::rel(1.0),
+        };
+        Size::from_axis(axis, total, ortho)
+    }
+}
+
+impl Span {
+    /// What the gaps between this span's children take, which is a length of
+    /// the row before anything is divided.
+    fn gaps(&self) -> Px {
+        self.gap
+            .mul_int(self.children.len().saturating_sub(1) as i32)
+    }
+
+    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(),
             dir,
-            gap: 0.0,
+            gap: Px::ZERO,
         }
     }
 
     pub fn gap(mut self, gap: impl UiNum) -> Self {
-        self.gap = gap.to_f32();
+        self.gap = Px::from_num(gap);
         self
     }
 
@@ -100,7 +249,7 @@ impl Span {
 pub struct SpanBuilder<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag> {
     pub children: Wa,
     pub dir: Dir,
-    pub gap: f32,
+    pub gap: Px,
     _pd: PhantomData<(State, Tag)>,
 }
 
@@ -126,13 +275,13 @@ impl<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag>
         Self {
             children,
             dir,
-            gap: 0.0,
+            gap: Px::ZERO,
             _pd: PhantomData,
         }
     }
 
     pub fn gap(mut self, gap: impl UiNum) -> Self {
-        self.gap = gap.to_f32();
+        self.gap = Px::from_num(gap);
         self
     }
 }

src/widget/position/stack.rs

@@ -8,29 +8,66 @@ pub struct Stack {
 }
 
 impl Widget for Stack {
+    fn size_request(&self, requests: &mut SizeRequests, axis: Axis) -> Option<RequestedLen> {
+        let sizing = match self.size {
+            StackSize::Default => None,
+            StackSize::Child(i) => self.children.get(i),
+        };
+        // With nothing sizing it a stack is a share of the box it is given,
+        // which is what its draw answers too.
+        match sizing {
+            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,
             StackSize::Child(i) => Some(i),
         };
-        let mut size = Size::default();
+        // Whichever child sizes the stack is given the stack's whole box --
+        // the stack is the length that child asked for, so placing that
+        // answer inside the box it decided would apply it twice.
+        let size = match sizing.and_then(|i| self.children.get(i).map(|c| (i, c))) {
+            // On the layer that child ends up on, so the ask below is a reuse
+            // rather than a second drawing of it somewhere else: a retained
+            // drawing belongs to the layer it was made on.
+            Some((i, child)) => {
+                painter.child_layer_at(i);
+                painter.widget_at(child, PlaceDesc::WHOLE.fills()).size()
+            }
+            None => Size::LEFTOVER,
+        };
+        // Every other child gets the box the sizing child decided: the
+        // stack is that length, so that is the box they are asked in, and a
+        // fraction under them is a fraction of it. A share leaves the axis
+        // to whoever gave the stack its box. Where a child sits in a box
+        // bigger than itself is its own business.
+        let place = PlaceDesc::from_axes(|axis| {
+            let len = size[axis];
+            match len.leftover == Weight::ZERO {
+                true => len.without_leftover().as_desc().fills(),
+                false => PlaceDescAxis::WHOLE,
+            }
+        });
         for (i, child) in self.children.iter().enumerate() {
-            match i {
-                0 => painter.child_layer(),
-                _ => painter.next_layer(),
-            }
-            let drawn = painter.widget(child);
-            // Only the child that sizes the stack is read, so the others
-            // changing size does not redraw it.
             if sizing == Some(i) {
-                size = drawn.size();
+                continue;
             }
+            painter.child_layer_at(i);
+            painter.widget_at(child, place);
         }
         size
     }
 
-    fn on_resize(&self, _: Axis) -> OnResize {
-        OnResize::Scale
+    /// Without a sizing child a stack is whatever box it is given, which it
+    /// can say without drawing anything.
+    fn size_hint(&self, _: Axis) -> Option<LayoutLen> {
+        match self.size {
+            StackSize::Default => Some(LayoutLen::LEFTOVER),
+            StackSize::Child(_) => None,
+        }
     }
 }
 

src/widget/rect.rs

@@ -35,16 +35,11 @@ impl Widget for Rect {
             thickness: self.thickness,
             inner_radius: self.inner_radius,
         });
-        Size::REST
+        Size::LEFTOVER
     }
 
-    fn size_hint(&self, _: Axis) -> Option<Len> {
-        Some(Len::REST)
-    }
-
-    /// Its box is its primitive's own region, so a new one is written there.
-    fn on_resize(&self, _: Axis) -> OnResize {
-        OnResize::Scale
+    fn size_hint(&self, _: Axis) -> Option<LayoutLen> {
+        Some(LayoutLen::LEFTOVER)
     }
 }
 

src/widget/text/edit.rs

@@ -93,10 +93,6 @@ impl Widget for TextEdit {
         );
         size
     }
-
-    fn on_resize(&self, axis: Axis) -> OnResize {
-        self.view.on_resize(axis)
-    }
 }
 
 const CARET_WIDTH: f32 = 1.0;
@@ -280,7 +276,13 @@ impl<'a> TextEditCtx<'a> {
     }
 
     pub fn select(&mut self, pos: Vec2, size: Vec2, drag: bool, recent: bool) {
-        let pos = pos - self.text.region().top_left().to_abs(size);
+        let pos = pos
+            - self
+                .text
+                .region()
+                .top_left()
+                .to_px(PxVec2::from_f32(size))
+                .to_f32();
         let prev_sel = self.text.selection;
         let prev_hit = self.text.double_hit;
 
@@ -319,12 +321,10 @@ impl<'a> TextEditCtx<'a> {
         let old = (self.text.view.buf.text().to_string(), self.text.selection);
         let mut undo = false;
         let res = self.apply_event_inner(event, modifiers, &mut undo);
-        if undo {
-            if let Some((old, selection)) = self.text.history.pop() {
+        if undo && let Some((old, selection)) = self.text.history.pop() {
             self.set(&old);
             self.text.selection = selection;
             self.clamp_selection_to_layout();
-            }
         } else if self.text.view.buf.text() != old.0 {
             self.text.history.push(old);
         }

src/widget/text/mod.rs

@@ -47,12 +47,14 @@ impl TextView {
     /// answers under the attrs too, so changing those asks a new question
     /// rather than invalidating anything.
     fn render(&mut self, painter: &mut Painter) -> &RenderedText {
-        let width = if self.attrs.wrap {
-            Some(painter.px_len(Axis::X))
-        } else {
-            None
-        };
-        painter.render_text(&mut self.buf, &self.attrs, width)
+        let width = self.attrs.wrap.then(|| painter.px_len(Axis::X));
+        // The shaper measures in floats, which is where a glyph advance comes
+        // from; what it answers goes back on the grid.
+        painter.render_text(&mut self.buf, &self.attrs, width.map(Px::to_f32));
+        if width.is_some() {
+            painter.holds(Axis::X, self.buf.width_holds());
+        }
+        self.buf.rendered().expect("render_text placed the glyphs")
     }
 
     pub fn tex(&self) -> Option<&RenderedText> {
@@ -72,28 +74,16 @@ impl TextView {
 
         let tex = self.render(painter);
         let region = tex.size.align(align);
-        let size = Size::abs(tex.size);
-        let within = region.within(&painter.region());
-        painter.glyphs(tex, within);
+        // The step at or above what the shaper measured, so a parent that
+        // hands back the length this reports hands back a box the longest
+        // line fits in. Rounded to the nearest step it is half the time a
+        // hair under that line, and the break made in it is not the break a
+        // cold layout makes there.
+        let size = Size::from_px(PxVec2::ceil_from_f32(tex.size));
+        painter.glyphs(tex, region);
         (region, size)
     }
 
-    /// Wrapping reads the width it is offered, so a wider box reshapes it and
-    /// a taller one does not. Alignment matters too, and separately: glyphs
-    /// anchored to the start of an axis stay put when that extent changes,
-    /// but centred or end-aligned ones move even though the shaping stands.
-    pub fn on_resize(&self, axis: Axis) -> OnResize {
-        let reshapes = axis == Axis::X && self.attrs.wrap;
-        let anchored = match axis {
-            Axis::X => self.align.x,
-            Axis::Y => self.align.y,
-        } == AxisAlign::Neg;
-        match reshapes || !anchored {
-            true => OnResize::Redraw,
-            false => OnResize::Translate,
-        }
-    }
-
     pub fn content(&self) -> String {
         self.buf.text().to_string()
     }
@@ -120,10 +110,6 @@ impl Widget for Text {
         self.update_buf();
         self.view.draw(painter).1
     }
-
-    fn on_resize(&self, axis: Axis) -> OnResize {
-        self.view.on_resize(axis)
-    }
 }
 
 impl Deref for Text {

src/widget/trait_fns.rs

@@ -12,14 +12,23 @@ widget_trait! {
         }
     }
 
-    fn align(self, align: impl Into<Align>) -> impl WidgetFn<Rsc, Aligned> {
-        move |state| Aligned {
-            inner: self.add_strong(state),
-            align: align.into(),
+    fn align(self, align: impl Into<Align>) -> impl WidgetIdFn<Rsc, WL::Widget> {
+        // An axis left out keeps whatever it had, which is centered unless
+        // something else set it.
+        let align = align.into();
+        move |state| {
+            let id = self.add(state);
+            let widgets = &mut state.ui_mut().widgets;
+            for axis in Axis::BOTH {
+                if let Some(align) = align[axis] {
+                    widgets.set_alignment(id, axis, align);
+                }
+            }
+            id
         }
     }
 
-    fn center(self) -> impl WidgetFn<Rsc, Aligned> {
+    fn center(self) -> impl WidgetIdFn<Rsc, WL::Widget> {
         self.align(Align::CENTER)
     }
 
@@ -31,48 +40,78 @@ widget_trait! {
         }
     }
 
-    fn sized(self, size: impl Into<Size>) -> impl WidgetFn<Rsc, SetSize> {
+    fn region_node(self) -> impl WidgetIdFn<Rsc, WL::Widget> {
+        |state| {
+            let id = self.add(state);
+            state.ui_mut().widgets.set_region_node(id, true);
+            id
+        }
+    }
+
+    fn sized(self, size: impl Into<Size>) -> impl WidgetIdFn<Rsc, WL::Widget> {
         let size = size.into();
-        move |state| SetSize {
-            inner: self.add_strong(state),
-            x: Some(size.x),
-            y: Some(size.y),
+        move |state| {
+            let id = self.add(state);
+            let widgets = &mut state.ui_mut().widgets;
+            widgets.set_len(id, Axis::X, size.x);
+            widgets.set_len(id, Axis::Y, size.y);
+            id
         }
     }
 
-    fn max_width(self, len: impl Into<Len>) -> impl WidgetFn<Rsc, MaxSize> {
+    fn width(self, len: impl Into<SizeRequest>) -> impl WidgetIdFn<Rsc, WL::Widget> {
         let len = len.into();
-        move |state| MaxSize {
-            inner: self.add_strong(state),
-            x: Some(len),
-            y: None,
+        move |state| {
+            let id = self.add(state);
+            state.ui_mut().widgets.set_len(id, Axis::X, len);
+            id
         }
     }
 
-    fn max_height(self, len: impl Into<Len>) -> impl WidgetFn<Rsc, MaxSize> {
+    /// Sets a floor on this widget's offered width and reported width.
+    fn min_width(self, len: impl Into<Len>) -> impl WidgetIdFn<Rsc, WL::Widget> {
         let len = len.into();
-        move |state| MaxSize {
-            inner: self.add_strong(state),
-            x: None,
-            y: Some(len),
+        move |state| {
+            let id = self.add(state);
+            state.ui_mut().widgets.set_min_len(id, Axis::X, len);
+            id
         }
     }
 
-    fn width(self, len: impl Into<Len>) -> impl WidgetFn<Rsc, SetSize> {
+    fn min_height(self, len: impl Into<Len>) -> impl WidgetIdFn<Rsc, WL::Widget> {
         let len = len.into();
-        move |state| SetSize {
-            inner: self.add_strong(state),
-            x: Some(len),
-            y: None,
+        move |state| {
+            let id = self.add(state);
+            state.ui_mut().widgets.set_min_len(id, Axis::Y, len);
+            id
         }
     }
 
-    fn height(self, len: impl Into<Len>) -> impl WidgetFn<Rsc, SetSize> {
+    /// Caps this widget's offered width and reported width.
+    fn max_width(self, len: impl Into<Len>) -> impl WidgetIdFn<Rsc, WL::Widget> {
         let len = len.into();
-        move |state| SetSize {
-            inner: self.add_strong(state),
-            x: None,
-            y: Some(len),
+        move |state| {
+            let id = self.add(state);
+            state.ui_mut().widgets.set_max_len(id, Axis::X, len);
+            id
+        }
+    }
+
+    fn max_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_max_len(id, Axis::Y, len);
+            id
+        }
+    }
+
+    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_len(id, Axis::Y, len);
+            id
         }
     }
 
@@ -85,7 +124,9 @@ widget_trait! {
 
     fn scrollable(self) -> impl WidgetIdFn<Rsc, Scroll> where Rsc: HasEvents {
         move |state| {
-            Scroll::new(self.add_strong(state), Axis::Y)
+            let inner = self.add(state);
+            state.ui_mut().widgets.set_region_node(inner, true);
+            Scroll::new(inner.upgrade(state), Axis::Y)
                 .on(CursorSense::Scroll, |ctx, rsc| {
                     let delta = ctx.data.scroll_delta.y * 50.0;
                     ctx.widget(rsc).scroll(delta);
@@ -125,9 +166,13 @@ widget_trait! {
         |state| self.add(state)
     }
 
-    fn set_ptr(self, ptr: WeakWidget<WidgetPtr>, state: &mut Rsc) {
-        let id = self.add_strong(state);
-        state.ui_mut().widgets[ptr].inner = Some(id);
+    /// This widget in a [`Wrapper`], which is how it gets a second length or
+    /// alignment beside the one it already carries. Named for the type it
+    /// makes rather than as `wrapped`, which would read as the text setting.
+    fn wrapper(self) -> impl WidgetFn<Rsc, Wrapper> {
+        |state| Wrapper {
+            inner: Some(self.add_strong(state)),
+        }
     }
 }
 

src/widget/wrapper.rs

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

tests/allocation_cost.rs

@@ -0,0 +1,124 @@
+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 rule in [
+        SizeRule::FREE,
+        leftover(1).clamp(20, 80).into(),
+        SizeRule::clamp(20.into(), 80.into()),
+    ] {
+        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);
+            h.rsc.widgets_mut().set_size_rule(a, Axis::X, rule.clone());
+            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!("rule={rule:?}: {allocations} allocations over 100 resize frames");
+        assert_eq!(allocations, 0);
+    }
+}
+
+/// A text drawn again at the width it already has places no glyphs and shapes
+/// nothing, so the frame costs nothing at all -- which is what the shaping
+/// cache is for, and a copy of the attrs made to ask it undid for any text
+/// naming its font family.
+///
+/// Only that case: a text drawn at a width it has not seen places its glyphs,
+/// and placing them allocates a list to hold them.
+#[test]
+fn redrawing_a_text_at_one_width_allocates_nothing() {
+    let mut h = Harness::new((600, 200));
+    let mut col = Span::empty(Dir::DOWN);
+    let mut texts = Vec::new();
+    for _ in 0..8 {
+        let text =
+            wtext("wrapping shapes one source into as many lines as the box leaves room for")
+                .size(16)
+                // Named rather than generic, because a named one is the family
+                // that costs an allocation to copy.
+                .family(Family::Named("sans-serif".into()))
+                .wrap(true)
+                .add_strong(&mut h.rsc);
+        texts.push(text.id());
+        col.push(text);
+    }
+    let root = col.add(&mut h.rsc);
+    h.set_root(root);
+    let redraw = |h: &mut Harness| {
+        for &id in &texts {
+            h.rsc.widgets_mut().mark_for_redraw(id);
+        }
+        h.frame();
+    };
+    for _ in 0..8 {
+        redraw(&mut h);
+    }
+    COUNT.set(Some(0));
+    for _ in 0..100 {
+        redraw(&mut h);
+    }
+    let allocations = COUNT.replace(None).unwrap();
+    println!("text: {allocations} allocations over 100 redraws of 8 texts");
+    assert_eq!(allocations, 0);
+}

tests/bounds_cost.rs

@@ -0,0 +1,88 @@
+//! CPU comparison of a bounds attribute against the `MaxSize` wrapper it
+//! replaced, using the same builder calls and the same geometry. The wrapper
+//! is gone from this tree, so its side of the comparison is run by checking
+//! out a commit that still has it: the fixture is written to build the same
+//! way at both.
+//!
+//!     MODE=cap FRAMES=2000 cargo test --release --test bounds_cost \
+//!       -- --ignored --nocapture
+//!
+//! `MODE` is `plain`, `exact` or `cap`; `REDRAW=1` marks every widget for
+//! redraw each frame; `FRAMES` is how many resize frames to measure. Use
+//! repeated `perf stat -e instructions:u` runs on the executable directly.
+//! Process totals include the cold frame, so compare identical modes and
+//! frame counts. Wall time on this machine is not a stable comparison.
+
+mod rig;
+
+use iris::{harness::Harness, prelude::*};
+use rig::env;
+
+/// The two widths the loop alternates. The cap of 80 binds at 300 and does
+/// not at 100, so the measured frames cross it in both directions.
+const WIDTHS: [i32; 2] = [100, 300];
+
+#[test]
+#[ignore = "instruction-count measurement"]
+fn bounds_cost() {
+    let mode = env("MODE", "cap".to_string());
+    let redraw = env("REDRAW", 0_u8) != 0;
+    let frames = env("FRAMES", 2000_usize);
+    let mut h = Harness::new((300, 512));
+    let mut column = Span::empty(Dir::DOWN);
+    let mut leaves = Vec::new();
+    for _ in 0..128 {
+        let first = match mode.as_str() {
+            "plain" => rect(Color::RED).add_strong(&mut h.rsc).any(),
+            "exact" => rect(Color::RED).width(40).add_strong(&mut h.rsc).any(),
+            "cap" => rect(Color::RED).max_width(80).add_strong(&mut h.rsc).any(),
+            _ => panic!("unknown MODE {mode}"),
+        };
+        leaves.push(first.id());
+        let second = rect(Color::BLUE).add_strong(&mut h.rsc);
+        let row = Span {
+            children: vec![first, second],
+            dir: Dir::RIGHT,
+            gap: Px::ZERO,
+        };
+        column.push(row.height(4).add_strong(&mut h.rsc));
+    }
+    h.set_root(column);
+    let ids: Vec<_> = h.render.active.keys().copied().collect();
+    println!(
+        "mode={mode}, widgets={}, rule_bytes={}",
+        ids.len(),
+        std::mem::size_of::<SizeRule>()
+    );
+    // That the fixture measures what it says is checked on both sides of the
+    // crossing here rather than inside the measured loop, which is what the
+    // other rigs do. Per frame it measured only 0.65% of the total (5.780B
+    // against 5.743B instructions at MODE=cap, FRAMES=2000), but none of it
+    // is the layout the number is about.
+    for width in WIDTHS {
+        h.resize((width, 512));
+        h.frame();
+        let expected = match mode.as_str() {
+            "plain" => width / 2,
+            "exact" => 40,
+            "cap" => (width / 2).min(80),
+            _ => unreachable!("the mode was checked while building"),
+        };
+        for id in &leaves {
+            assert_eq!(h.region(id).unwrap().size().x, Px::from_int(expected));
+        }
+        println!(
+            "width {width}: first leaf {}",
+            h.region(&leaves[0]).unwrap()
+        );
+    }
+    for frame in 0..frames {
+        if redraw {
+            for &id in &ids {
+                h.rsc.widgets_mut().mark_for_redraw(id);
+            }
+        }
+        h.resize((WIDTHS[frame % WIDTHS.len()], 512));
+        h.frame();
+    }
+}

tests/cases/deferred.rs

@@ -0,0 +1,421 @@
+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.widgets_mut().set_max_len(a, Axis::X, 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_comparison_between_two_comparisons_keeps_both_of_them() {
+    // Joining two expressions is the one path that copies a request's nodes
+    // into another's arena; the floor puts a node under the copied one, so
+    // its operands have to be renumbered as they land.
+    let capped = leftover(1).min(px(40));
+    let floored = leftover(2).min(px(70)).max(px(10));
+    let mut h = Harness::new((90, 100));
+    let both = rect(Color::RED).width(capped.max(floored)).add(&mut h.rsc);
+    let rest = rect(Color::BLUE).add(&mut h.rsc);
+    h.set_root((both, rest).span(Dir::RIGHT));
+    // Under either cap, so the doubled share is the longer of the two.
+    assert_corners!(h, both, (0, 0), (60, 100));
+    assert_corners!(h, rest, (60, 0), (90, 100));
+    h.resize((300, 100));
+    h.frame();
+    // Over both caps, so the comparison is between 40 and 70.
+    assert_corners!(h, both, (0, 0), (70, 100));
+    assert_corners!(h, rest, (70, 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(Len::rel(0.25), 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(Len::rel(0.25), 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));
+}
+
+#[test]
+fn an_intrinsic_share_cap_uses_the_allocators_fractional_base() {
+    let mut h = Harness::new((300, 100));
+    let head = rect(Color::BLUE).width(30).add(&mut h.rsc);
+    let bounded = rect(Color::RED).max_width(Len::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));
+}

tests/cases/determinism.rs

@@ -0,0 +1,103 @@
+//! A measurement that decides control flow.
+//!
+//! Comparing boxes catches a widget that moved. It does not catch a widget
+//! that measured a child, believed a different answer from the one a cold
+//! start would give, and took the other branch -- which is the same defect
+//! arriving somewhere it cannot be ignored. A widget here branches on what it
+//! measured, so a disagreement shows up as a different tree.
+
+use iris::harness::Harness;
+use iris::prelude::*;
+
+/// Measures `probe` across `axis` and draws one of two children on the
+/// answer. Its own configuration never changes, so which child is drawn is a
+/// property of the layout alone.
+struct BranchesOnMeasurement {
+    probe: StrongWidget,
+    wide: StrongWidget,
+    narrow: StrongWidget,
+    threshold: f32,
+}
+
+impl Widget for BranchesOnMeasurement {
+    fn draw(&mut self, painter: &mut Painter) -> Size {
+        let cut = Len::from_parts(Rel::ZERO, Px::from_int(40));
+        let top = UiSpan::new(Len::ZERO, cut).shifted_desc();
+        let measured = painter
+            .widget_at(&self.probe, top.on_axis(Axis::Y))
+            .len(Axis::X);
+        let px = painter.to_px(measured.apply_leftover(), Axis::X);
+
+        let below = UiSpan::new(cut, painter.region_len(Axis::Y)).shifted_desc();
+        let place = below.on_axis(Axis::Y);
+        match px > Px::from_f32(self.threshold) {
+            true => painter.widget_at(&self.wide, place),
+            false => painter.widget_at(&self.narrow, place),
+        };
+        Size::LEFTOVER
+    }
+}
+
+fn plant(h: &mut Harness, threshold: f32) -> (WidgetId, WidgetId) {
+    let words = "the quick brown fox jumps over the lazy dog and keeps running";
+    let probe = wtext(words).size(16).wrap(true).add(&mut h.rsc);
+    let wide = rect(Color::RED).add(&mut h.rsc);
+    let narrow = rect(Color::BLUE).add(&mut h.rsc);
+    let branch = BranchesOnMeasurement {
+        probe: probe.add_strong(&mut h.rsc),
+        wide: wide.add_strong(&mut h.rsc),
+        narrow: narrow.add_strong(&mut h.rsc),
+        threshold,
+    }
+    .add(&mut h.rsc);
+    let side = rect(Color::GREEN).width(120).add(&mut h.rsc);
+    h.set_root((side, branch).span(Dir::RIGHT));
+    (wide.id(), narrow.id())
+}
+
+/// Which of the two branches drew, as a pair a test can compare.
+fn taken(h: &Harness, wide: WidgetId, narrow: WidgetId) -> (bool, bool) {
+    (h.region(&wide).is_some(), h.region(&narrow).is_some())
+}
+
+#[test]
+fn a_branch_taken_on_a_measurement_holds_across_repaints() {
+    for threshold in [0.0, 200.0, 400.0, 600.0, 779.0, 780.0, 781.0, 2000.0] {
+        let mut h = Harness::new((900, 600));
+        let (wide, narrow) = plant(&mut h, threshold);
+        let first = taken(&h, wide, narrow);
+        assert_ne!(first, (false, false), "threshold {threshold}: neither drew");
+
+        for frame in 0..4 {
+            h.rsc.widgets_mut().mark_for_redraw(wide);
+            h.rsc.widgets_mut().mark_for_redraw(narrow);
+            h.frame();
+            assert_eq!(
+                taken(&h, wide, narrow),
+                first,
+                "threshold {threshold}, repaint {frame}: the branch moved when nothing did"
+            );
+        }
+    }
+}
+
+#[test]
+fn a_branch_taken_on_a_measurement_is_the_one_a_cold_start_takes() {
+    for threshold in [0.0, 200.0, 400.0, 600.0, 779.0, 780.0, 781.0, 2000.0] {
+        let mut warm = Harness::new((900, 600));
+        let (wide, narrow) = plant(&mut warm, threshold);
+        warm.resize((640, 480));
+        warm.frame();
+        warm.rsc.widgets_mut().mark_for_redraw(wide);
+        warm.frame();
+
+        let mut cold = Harness::new((640, 480));
+        let (cwide, cnarrow) = plant(&mut cold, threshold);
+
+        assert_eq!(
+            taken(&warm, wide, narrow),
+            taken(&cold, cwide, cnarrow),
+            "threshold {threshold}: warm and cold took different branches"
+        );
+    }
+}

tests/cases/drift.rs

@@ -0,0 +1,45 @@
+//! What a retained drawing costs in accuracy when it is moved instead of made
+//! again. A subtree's stored regions are the only record of where it is, so a
+//! move that works from the last answer rather than from the box it is now in
+//! integrates its own rounding, and nothing later recomputes it. Re-expressing
+//! each part as the same fraction of the new box is what keeps a long-lived
+//! layout on the one a cold start produces.
+
+use iris::harness::Harness;
+use iris::prelude::*;
+
+/// A row of a fixed height under a bar, so changing the bar's height moves the
+/// row without changing the box it is given: the move path, repeatedly.
+fn plant(h: &mut Harness, bar_height: f32) -> (WeakWidget<Rect>, WeakWidget<Rect>) {
+    let bar = rect(Color::RED).height(bar_height).add(&mut h.rsc);
+    let inner = rect(Color::BLUE).add(&mut h.rsc);
+    let row = (inner, rect(Color::GREEN)).span(Dir::RIGHT).height(100);
+    h.set_root((bar, row).span(Dir::DOWN));
+    (bar, inner)
+}
+
+/// Enough moves to pass the 0.05 physical pixels layout treats as the same
+/// place, for a move that adds an offset to the last answer. Measured on this
+/// fixture on 2026-09-15: adding the offset to both ends of a span shortened
+/// the row by 0.071 over this many moves and by 0.712 over ten times as many,
+/// growing with the count rather than settling. Placing the far end from the
+/// near one instead left 0.069, because the length is re-derived either way.
+const MOVES: usize = 20_000;
+
+#[test]
+fn a_subtree_moved_many_times_stays_where_a_cold_layout_puts_it() {
+    let mut warm = Harness::new((640, 900));
+    let (bar, inner) = plant(&mut warm, 40.0);
+    let mut height = 40.0;
+    for step in 0..MOVES {
+        height = 40.0 + (step % 300) as f32 * 0.37;
+        warm.set_len(bar, Axis::Y, height);
+        warm.frame();
+    }
+
+    let mut cold = Harness::new((640, 900));
+    let (_, cold_inner) = plant(&mut cold, height);
+    cold.frame();
+
+    assert_eq!(warm.region(&inner), cold.region(&cold_inner));
+}

tests/cases/idempotence.rs

@@ -0,0 +1,29 @@
+//! Whether measuring a widget and then giving it the length it reported is a
+//! fixed point, which is what a span that sizes to its children needs.
+
+use iris::harness::Harness;
+use iris::prelude::*;
+
+#[test]
+fn a_wrapping_text_in_a_span_settles_on_one_width() {
+    let mut h = Harness::new((900, 600));
+    let words = "the quick brown fox jumps over the lazy dog and keeps on running \
+                 until it reaches the end of a rather long line of text";
+    let t = wtext(words).size(16).wrap(true).add(&mut h.rsc);
+    let filler = rect(Color::BLUE).add(&mut h.rsc);
+    h.set_root((t, filler).span(Dir::RIGHT));
+
+    let mut widths = Vec::new();
+    for _ in 0..6 {
+        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().mark_for_redraw(t.id());
+        h.frame();
+    }
+    println!("widths over six frames: {widths:?}");
+    assert!(
+        widths.windows(2).all(|w| w[0] == w[1]),
+        "a repaint that changed nothing moved it: {widths:?}"
+    );
+}

tests/cases/plan.rs

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

tests/cases/scroll.rs

@@ -0,0 +1,191 @@
+//! Scrolling moves content and stops at its ends.
+
+use iris::harness::{Harness, assert_corners};
+use iris::prelude::*;
+
+#[test]
+fn scrollable_enables_a_region_node_but_raw_scroll_does_not() {
+    let mut h = Harness::new((100, 100));
+    let default_child = ().add(&mut h.rsc);
+    let _default = default_child.scrollable().add(&mut h.rsc);
+    assert!(h.rsc.widgets().is_region_node(default_child));
+    h.rsc.widgets_mut().set_region_node(default_child, false);
+    assert!(!h.rsc.widgets().is_region_node(default_child));
+
+    let raw_child = ().add(&mut h.rsc);
+    let _raw = Scroll::new(raw_child.add_strong(&mut h.rsc), Axis::Y).add(&mut h.rsc);
+    assert!(!h.rsc.widgets().is_region_node(raw_child));
+
+    let explicit = ().region_node().add(&mut h.rsc);
+    assert!(h.rsc.widgets().is_region_node(explicit));
+}
+
+#[test]
+fn a_scrollable_child_can_drop_its_region_node() {
+    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 content = (top, bottom).span(Dir::DOWN).add(&mut h.rsc);
+    h.set_root(content.scrollable());
+    h.rsc.widgets_mut().set_region_node(content, false);
+    h.frame();
+
+    h.move_to((200, 100));
+    h.scroll((0, 1));
+    h.frame();
+
+    assert!(!h.rsc.widgets().is_region_node(content));
+    assert_corners!(h, top, (0, -150), (400, 50));
+}
+
+#[test]
+fn a_wheel_scrolls_the_content_and_stops_at_its_end() {
+    let mut h = Harness::new((400, 200));
+    // Twice the window's height, so there is 200 to scroll.
+    let top = rect(Color::RED).height(200).add(&mut h.rsc);
+    let bottom = rect(Color::BLUE).height(200).add(&mut h.rsc);
+    h.set_root((top, bottom).span(Dir::DOWN).scrollable());
+    h.move_to((200, 100));
+
+    // `Scroll` starts snapped to the end.
+    assert_corners!(h, top, (0, -200), (400, 0));
+
+    // The handler scales a wheel line by 50.
+    h.scroll((0, 1));
+    h.frame();
+    assert_corners!(h, top, (0, -150), (400, 50));
+
+    h.scroll((0, 10));
+    h.frame();
+    assert_corners!(h, top, (0, 0), (400, 200));
+}
+
+#[test]
+fn fixed_content_and_a_share_fill_one_viewport() {
+    let mut h = Harness::new((900, 100));
+    let content = rect(Color::RED)
+        .width(LayoutLen {
+            px: Px::from_int(600),
+            rel: Rel::ZERO,
+            leftover: Weight::ONE,
+        })
+        .add(&mut h.rsc);
+    let scroll = Scroll::new(content.add_strong(&mut h.rsc), Axis::X);
+    h.set_root(scroll);
+
+    assert_corners!(h, content, (0, 0), (900, 100));
+}
+
+#[test]
+fn fixed_content_wider_than_the_viewport_still_scrolls() {
+    let mut h = Harness::new((900, 100));
+    let content = rect(Color::RED).width(1200).add(&mut h.rsc);
+    let scroll = Scroll::new(content.add_strong(&mut h.rsc), Axis::X);
+    h.set_root(scroll);
+
+    assert_corners!(h, content, (-300, 0), (900, 100));
+}
+
+#[test]
+fn a_lone_share_fills_without_scrolling() {
+    let mut h = Harness::new((900, 100));
+    let content = rect(Color::RED).width(LayoutLen::LEFTOVER).add(&mut h.rsc);
+    let scroll = Scroll::new(content.add_strong(&mut h.rsc), Axis::X);
+    h.set_root(scroll);
+
+    assert_corners!(h, content, (0, 0), (900, 100));
+}
+
+#[test]
+fn wrapping_content_beside_a_fixed_length_is_stable_warm_and_cold() {
+    fn plant(h: &mut Harness) -> (WidgetId, WidgetId) {
+        let fixed = rect(Color::RED).width(600).add(&mut h.rsc);
+        let text = wtext("Wrapping shapes one source into as many lines as the box leaves room for, so a paragraph's height is an answer and not a setting.")
+            .size(16)
+            .wrap(true)
+            .width(LayoutLen::LEFTOVER)
+            .add(&mut h.rsc);
+        let content = (fixed, text).span(Dir::RIGHT).add(&mut h.rsc);
+        let scroll = Scroll::new(content.add_strong(&mut h.rsc), Axis::X);
+        h.set_root(scroll);
+        (text.id(), content.id())
+    }
+
+    let mut warm = Harness::new((900, 300));
+    let (text, content) = plant(&mut warm);
+    warm.rsc.widgets_mut().mark_for_redraw(text);
+    warm.frame();
+
+    let mut cold = Harness::new((900, 300));
+    let (cold_text, cold_content) = plant(&mut cold);
+
+    assert_eq!(warm.region(&text), cold.region(&cold_text));
+    assert_eq!(warm.region(&content), cold.region(&cold_content));
+}
+
+/// A widget that clips to its box may not report more than the box: its
+/// parent would place the part it cut off, and the framework would put a
+/// drawing longer than its box somewhere. `Masked` is the second of these
+/// after `Scroll`, and the assertion in `draw_at` is what says so.
+// What it checks is a debug assertion, which a release build does not compile
+// -- and a `should_panic` test of one fails there rather than passing
+// vacuously, so it is not built either. Every measurement rig here is run in
+// release, so `cargo test --release` has to pass.
+#[cfg(debug_assertions)]
+#[test]
+#[should_panic = "clips to"]
+fn a_clipping_widget_reporting_more_than_its_box_is_caught() {
+    struct Clipper(StrongWidget);
+
+    impl Widget for Clipper {
+        fn draw(&mut self, painter: &mut Painter) -> Size {
+            painter.set_mask(UiRegion::FULL);
+            painter.widget(&self.0).size()
+        }
+    }
+
+    let mut h = Harness::new((100, 100));
+    let tall = rect(Color::RED).height(400).add_strong(&mut h.rsc);
+    let clipper = Clipper(tall).add(&mut h.rsc);
+    // `set_root` lays the tree out, so this is where it is caught.
+    h.set_root(clipper);
+}
+
+/// Content that fits sits in the viewport, not in a box of the window's
+/// length anchored at the viewport's start. `Part::From` takes window
+/// lengths, so a `rel(1.0)` span in one is the window, and only a scroll
+/// filling the window would land right.
+#[test]
+fn content_that_fits_is_placed_in_the_viewport_and_not_in_the_window() {
+    let mut h = Harness::new((400, 400));
+    let head = rect(Color::RED).height(100).add(&mut h.rsc);
+    let inner = rect(Color::BLUE).height(50).add(&mut h.rsc);
+    let scroll = Scroll::new(inner.add_strong(&mut h.rsc), Axis::Y).add(&mut h.rsc);
+    h.set_root((head, scroll).span(Dir::DOWN));
+
+    assert_corners!(h, scroll, (0, 100), (400, 400));
+    assert_corners!(h, inner, (0, 225), (400, 275));
+}
+
+/// A cap narrows the box the widget is asked in, which is what a scroll
+/// measures its viewport from: the content scrolls within the cap rather than
+/// within the room the cap was cut from.
+#[test]
+fn a_capped_scroll_takes_its_viewport_from_the_cap() {
+    let mut h = Harness::new((400, 200));
+    let top = rect(Color::RED).height(200).add(&mut h.rsc);
+    let bottom = rect(Color::BLUE).height(200).add(&mut h.rsc);
+    let scroll = (top, bottom).span(Dir::DOWN).scrollable().add(&mut h.rsc);
+    let capped = scroll.max_height(100).add(&mut h.rsc);
+    h.set_root(capped);
+    h.move_to((200, 50));
+
+    // 400 of content in a viewport of 100, so 300 to scroll and the end
+    // showing: the top is 300 above the box, which the window centres.
+    assert_eq!(h.region(&scroll).unwrap().size().y, Px::from_int(100));
+    assert_corners!(h, top, (0, -250), (400, -50));
+
+    h.scroll((0, 1));
+    h.frame();
+    assert_corners!(h, top, (0, -200), (400, 0));
+}

tests/chain_cost.rs

@@ -1,6 +1,5 @@
-//! What the vertex shader's move-chain walk costs, against how deep the chain
-//! is. Every active widget owns a slot, so the depth a primitive resolves
-//! through is its depth in the widget tree.
+//! What the vertex shader's move-chain walk costs, against how many nested
+//! region nodes a primitive resolves through.
 //!
 //!     cargo test --release --test chain_cost -- --ignored --nocapture
 //!
@@ -9,19 +8,22 @@
 //! submitted and waited on, so this is the GPU's cost and not the recording
 //! loop's -- which is what `draw_cost.rs` measures instead.
 //!
-//! 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.
+//! Two fixtures, because the walk happens in both stages. `chain_cost_by_depth`
+//! draws instances two pixels wide so that vertex work dominates; a walk that
+//! does not show up against small quads will not show up against anything.
+//! `mask_cost_by_depth` draws one screenful through a mask instead, which is
+//! where a walk in the fragment stage would show and nowhere else.
 
 use iris::prelude::*;
 use iris_core::{
-    MaskIdx, MoveIdx, PrimitiveInst, RectPrimitive, UiData, UiRegion, UiRenderNode, UiRenderState,
-    UiScalar, UiSpan,
+    Len, Mask, MaskIdx, MoveIdx, PrimitiveInst, RectPrimitive, UiData, UiRegion, UiRenderNode,
+    UiRenderState, UiSpan,
 };
 use wgpu::{Color as GpuColor, *};
 
+#[path = "gpu/mod.rs"]
+mod gpu;
+
 const SIZE: u32 = 1024;
 const INSTANCES: usize = 200_000;
 const FRAMES: u32 = 20;
@@ -30,18 +32,7 @@ const FRAMES: u32 = 20;
 const BATCHES: u32 = 8;
 
 fn gpu() -> Option<(Device, Queue, f32)> {
-    let all = Instance::new(InstanceDescriptor::new_without_display_handle());
-    let instance = match pollster::block_on(all.request_adapter(&RequestAdapterOptions::default()))
-    {
-        Ok(_) => all,
-        Err(_) => Instance::new(InstanceDescriptor {
-            backends: Backends::GL,
-            ..InstanceDescriptor::new_without_display_handle()
-        }),
-    };
-    let instance: &'static Instance = Box::leak(Box::new(instance));
-    let adapter =
-        pollster::block_on(instance.request_adapter(&RequestAdapterOptions::default())).ok()?;
+    let adapter = gpu::adapter()?;
     if !adapter.features().contains(Features::TIMESTAMP_QUERY) {
         println!("no timestamp queries on {:?}", adapter.get_info().name);
         return None;
@@ -56,22 +47,17 @@ 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![],
-    }
+/// Which stage the fill puts the work in: many small quads, where a walk per
+/// vertex is what shows, or one screenful of masked rows, where a walk per
+/// fragment would.
+#[derive(Clone, Copy)]
+enum Fixture {
+    Quads,
+    Masked,
 }
 
 /// A chain `depth` slots long, and instances that all resolve through its end.
-fn fill(ui: &mut UiData, render: &mut UiRenderState, depth: usize) {
+fn fill(ui: &mut UiData, render: &mut UiRenderState, depth: usize, fixture: Fixture) {
     let kind = ui.primitives.kind::<RectPrimitive>();
     let id = ui.widgets.add_strong(Rect::new(UiColor::WHITE)).id();
 
@@ -80,21 +66,52 @@ fn fill(ui: &mut UiData, render: &mut UiRenderState, depth: usize) {
         slot = render.moves.push(slot, UiRegion::FULL);
     }
 
-    let px = |v: f32| UiScalar { rel: 0.0, abs: v };
-    for i in 0..INSTANCES {
-        let x = (i % (SIZE as usize / 2)) as f32 * 2.0;
-        let y = (i / (SIZE as usize / 2)) as f32;
+    let px = |v: f32| Len::px(v);
+    let rows = SIZE as usize;
+    let mask_idx = match fixture {
+        Fixture::Quads => MaskIdx::NONE,
+        // Its own chain as long as the instances', since a viewport sits as
+        // deep in the tree as the content it clips.
+        Fixture::Masked => {
+            let idx = ui.masks.push(Mask {
+                region: UiRegion::FULL,
+                move_idx: slot,
+            });
+            // Nothing frees it here, but the owner's reference is what a real
+            // one is kept alive by.
+            ui.masks.push_ref(idx);
+            idx
+        }
+    };
+    let instances = match fixture {
+        Fixture::Quads => INSTANCES,
+        Fixture::Masked => rows,
+    };
+    for i in 0..instances {
+        let region = match fixture {
+            Fixture::Quads => {
+                let x = (i % (rows / 2)) as f32 * 2.0;
+                let y = (i / (rows / 2)) as f32;
+                UiRegion::new(
+                    UiSpan::new(px(x), px(x + 2.0)),
+                    UiSpan::new(px(y), px(y + 1.0)),
+                )
+            }
+            // A full row each, so one screenful of fragments goes through the
+            // mask and the vertex stage is four corners per row.
+            Fixture::Masked => UiRegion::new(
+                UiSpan::new(px(0.0), px(SIZE as f32)),
+                UiSpan::new(px(i as f32), px(i as f32 + 1.0)),
+            ),
+        };
         render.layers.write(
             0,
             PrimitiveInst {
                 kind,
                 id,
                 primitive: RectPrimitive::color(UiColor::WHITE),
-                region: UiRegion::new(
-                    UiSpan::new(px(x), px(x + 2.0)),
-                    UiSpan::new(px(y), px(y + 1.0)),
-                ),
-                mask_idx: MaskIdx::NONE,
+                region,
+                mask_idx,
                 move_idx: slot,
             },
         );
@@ -102,28 +119,15 @@ 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 {
+fn pass_cost(device: &Device, queue: &Queue, period: f32, depth: usize, fixture: Fixture) -> 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);
+    fill(&mut ui, &mut render, depth, fixture);
     node.update(device, queue, &mut ui, &mut render);
 
-    let target = device.create_texture(&TextureDescriptor {
-        label: Some("chain cost"),
-        size: Extent3d {
-            width: SIZE,
-            height: SIZE,
-            depth_or_array_layers: 1,
-        },
-        mip_level_count: 1,
-        sample_count: 1,
-        dimension: TextureDimension::D2,
-        format,
-        usage: TextureUsages::RENDER_ATTACHMENT,
-        view_formats: &[],
-    });
+    let target = gpu::target(device, format, SIZE, false);
     let view = target.create_view(&TextureViewDescriptor::default());
 
     let queries = device.create_query_set(&QuerySetDescriptor {
@@ -203,17 +207,15 @@ fn pass_cost(device: &Device, queue: &Queue, period: f32, depth: usize) -> f64 {
     best
 }
 
-#[test]
-#[ignore = "measurement, not a check"]
-fn chain_cost_by_depth() {
+fn by_depth(fixture: Fixture, instances: usize) {
     let Some((device, queue, period)) = gpu() else {
         println!("no gpu with timestamps; nothing measured");
         return;
     };
-    println!("{INSTANCES} instances, {SIZE}x{SIZE}, best of {BATCHES} batches");
+    println!("{instances} instances, {SIZE}x{SIZE}, best of {BATCHES} batches");
     let mut base = None;
     for depth in [1, 2, 4, 8, 16, 32, 64] {
-        let ns = pass_cost(&device, &queue, period, depth);
+        let ns = pass_cost(&device, &queue, period, depth, fixture);
         let base = *base.get_or_insert(ns);
         println!(
             "depth {depth:>3}: {:>9.1} us   {:+6.1}% against depth 1",
@@ -222,3 +224,19 @@ fn chain_cost_by_depth() {
         );
     }
 }
+
+#[test]
+#[ignore = "measurement, not a check"]
+fn chain_cost_by_depth() {
+    by_depth(Fixture::Quads, INSTANCES);
+}
+
+/// One screenful of rows, every one clipped by a mask whose own chain is that
+/// deep. What this says that the quads cannot is whether a mask costs the walk
+/// once per instance or once per fragment: at a screenful of fragments per
+/// chain, the second is the difference between these two tables.
+#[test]
+#[ignore = "measurement, not a check"]
+fn mask_cost_by_depth() {
+    by_depth(Fixture::Masked, SIZE as usize);
+}

tests/children_cost.rs

@@ -0,0 +1,59 @@
+//! What one container's draw costs against the number of children it has.
+//!
+//!     cargo test --release --test children_cost -- --ignored --nocapture
+//!
+//! Every other rig here varies depth, the window, or what changed between
+//! frames; this one varies width, which is the dimension a container's own
+//! per-child bookkeeping is counted in. A list of rows is the shape that gets
+//! wide -- a transcript, a file tree -- and a cost per child that is not flat
+//! down this table is a cost paid twice for every child added.
+//!
+//! Wall time rather than instructions, because what is being told apart here
+//! is a factor rather than a few percent, and the table says which it is: a
+//! flat right-hand column is linear and a rising one is not.
+
+mod rig;
+
+use iris::harness::Harness;
+use iris::prelude::*;
+use rig::env;
+use std::time::Instant;
+
+/// A column of leaves each with a length of its own, so the span asks every
+/// one of them and reads what each answered.
+fn build(h: &mut Harness, children: usize) -> WidgetId {
+    let mut col = Span::empty(Dir::DOWN);
+    for _ in 0..children {
+        col.push(
+            rect(Color::RED)
+                .height(LayoutLen::px(4.0))
+                .add_strong(&mut h.rsc),
+        );
+    }
+    let root = col.add(&mut h.rsc);
+    h.set_root(root);
+    root.id()
+}
+
+#[test]
+#[ignore = "measurement, not a check"]
+fn draw_cost_by_children() {
+    let frames = env("FRAMES", 40_usize);
+    println!("{frames} full redraws of one span, per child in the last column");
+    for children in [100_usize, 200, 400, 800, 1600] {
+        // Tall enough that no child is collapsed for want of room.
+        let mut h = Harness::new((600.0, children as f32 * 8.0));
+        let root = build(&mut h, children);
+        h.frame();
+        let start = Instant::now();
+        for _ in 0..frames {
+            h.rsc.widgets_mut().mark_for_redraw(root);
+            h.frame();
+        }
+        let ms = start.elapsed().as_secs_f64() * 1000.0 / frames as f64;
+        println!(
+            "children {children:>5}: {ms:>8.3} ms per redraw, {:>7.4} ms each",
+            ms / children as f64
+        );
+    }
+}

tests/deferred_generated.rs

@@ -0,0 +1,85 @@
+mod rig;
+#[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 depth = rig::env("IRIS_DEFERRED_DEPTH", 4_usize);
+    let seeds = rig::seeds("IRIS_DEFERRED_SEED", "IRIS_DEFERRED_SEEDS", 20);
+    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(),
+                        // Both sides an expression, the one shape that
+                        // copies a request's nodes into another's.
+                        3 => leftover(1).min(px(40)).max(leftover(2).min(px(70))).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 {
+                    let bound = &mut rules[axis].bound;
+                    if bound.min.is_some() {
+                        bound.min = Some(Len::rel(0.25));
+                    }
+                    if bound.max.is_some() {
+                        bound.max = Some(Len::rel(0.75));
+                    }
+                }
+            }
+        });
+    });
+}
+
+#[test]
+fn preferred_requests_with_independent_bounds_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].request = Some(match index % 4 {
+                        0 => leftover(1).into(),
+                        1 => rel(0.5).into(),
+                        2 => px(80).into(),
+                        _ => (leftover(1) + px(30)).min(leftover(2)),
+                    });
+                }
+            }
+        });
+    });
+}

tests/draw_cost.rs

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

tests/generated.rs

@@ -1,408 +1,123 @@
-//! Random trees, checked against building the same tree cold.
+//! Laying a tree out again has to land where growing it that way would.
 //!
-//! A frame reaches its layout by keeping most of the last one: slots
-//! rewritten, some widgets drawn again, the rest untouched. The property here
-//! is that what comes out is the tree a cold start would have produced, so
-//! anything the retained path carried over that it should not have shows up
-//! as a difference in somebody's box.
+//! Every case is one of `scenario`'s, over the trees `iris::random` grows
+//! from a seed. The fast test takes a handful of seeds and the ignored one
+//! takes as many as it is asked for; both run the same cases the shrinker
+//! does over the same trees, so a seed that fails here is reduced by
 //!
-//! `iris::random` grows the tree and `examples/random.rs` draws one. A seed is
-//! the whole reproduction; `a_long_run_of_seeds_agrees` is the ignored sweep
-//! for when it is worth spending the time.
+//!     SHRINK_SEED=<seed> SHRINK_DEPTH=<depth> SHRINK_CASE=<case> \
+//!       cargo test --release --test shrink -- --ignored --nocapture
+//!
+//! `IRIS_GENERATED_SEED`, `IRIS_GENERATED_SEEDS` and `IRIS_GENERATED_DEPTH`
+//! select what the long run covers.
 
-use std::collections::HashMap;
+mod rig;
+#[path = "scenario/mod.rs"]
+mod scenario;
 
-use iris::harness::Harness;
-use iris::prelude::*;
-use iris::random::{Edits, Lens, Rng, SpanEdit, Tree, grow};
+use iris::random::{Edits, Plan, plan};
+use rig::env;
+use scenario::{ALL, Case, diverges, over_seeds};
 
-const DEPTH: usize = 4;
-const SEEDS: [u64; 7] = [1, 2, 3, 5, 8, 13, 98];
-const REGION_EPSILON_PX: f32 = 0.05;
-
-fn same_coordinate(got: f32, want: f32) -> bool {
-    (got - want).abs() <= REGION_EPSILON_PX
+/// How deep the generator branches. The generator widens two to four ways per
+/// level, so depth is exponential in width and a deep narrow tree is not
+/// reachable by raising this -- it buys more overlap between dependency
+/// paths, not more ancestry.
+fn depth() -> usize {
+    env("IRIS_GENERATED_DEPTH", 4)
 }
 
-fn same_region(got: Option<PixelRegion>, want: Option<PixelRegion>) -> bool {
-    match (got, want) {
-        (Some(got), Some(want)) => {
-            same_coordinate(got.top_left.x, want.top_left.x)
-                && same_coordinate(got.top_left.y, want.top_left.y)
-                && same_coordinate(got.bot_right.x, want.bot_right.x)
-                && same_coordinate(got.bot_right.y, want.bot_right.y)
+/// The seeds the ordinary tests take: a corpus rather than a set of
+/// regression cases, since a seed names a tree only for as long as the
+/// generator draws the same things in the same order. Adding images to the
+/// leaves moved every one of them, so 20 and 86 -- which once caught a widget
+/// placed twice in a box its parent had already placed it in, and a `Scroll`
+/// fixed point settling differently -- no longer grow those trees. Both
+/// defects are pinned by the shrunk fixtures in `cases/unsettled.rs`, which
+/// are trees rather than numbers.
+const SEEDS: [u64; 10] = [1, 2, 3, 5, 8, 10, 13, 20, 86, 98];
+
+fn check(seed: u64, depth: usize, case: Case) {
+    check_plan(&plan(seed, depth, &Edits::default()), seed, depth, case);
 }
-        (None, None) => true,
-        _ => false,
+
+fn check_plan(grown: &Plan, seed: u64, depth: usize, case: Case) {
+    if let Some(how) = diverges(grown, case, seed) {
+        panic!(
+            "seed {seed} at depth {depth} differs after {}: {how}\n\
+             reduce it with SHRINK_SEED={seed} SHRINK_DEPTH={depth} \
+             SHRINK_CASE={} cargo test --release --test shrink -- --ignored --nocapture",
+            case.name(),
+            case.name(),
+        );
     }
 }
 
-fn plant(h: &mut Harness, seed: u64, edits: &Edits) -> Tree {
-    let (root, tree) = grow(&mut h.rsc, seed, DEPTH, edits);
-    h.state.root = Some(root);
-    h.frame();
-    tree
+/// A test per case, and the list of which cases have one, from the same
+/// place. A case the ordinary suite leaves out runs only in the long scan,
+/// which nobody runs by hand.
+macro_rules! cases {
+    ($($name:ident = $case:expr,)*) => {
+        $(
+            #[test]
+            fn $name() {
+                for seed in SEEDS {
+                    check(seed, depth(), $case);
                 }
+            }
+        )*
 
-fn resize_one(h: &mut Harness, tree: &Tree, idx: usize, rng: &mut Rng) -> Lens {
-    let lens = [
-        Some(Len::abs(20.0 + rng.below(180) as f32)),
-        Some(Len::abs(20.0 + rng.below(180) as f32)),
-    ];
-    let sized = &mut h.rsc[tree.sized[idx]];
-    sized.x = lens[0];
-    sized.y = lens[1];
-    lens
-}
-
-/// Changes a few of the declared sizes, and says which, so the cold tree can
-/// be grown with the same ones.
-fn edit(h: &mut Harness, tree: &Tree, rng: &mut Rng) -> HashMap<usize, Lens> {
-    let mut edits = HashMap::new();
-    for _ in 0..4 {
-        let idx = rng.below(tree.sized.len());
-        edits.insert(idx, resize_one(h, tree, idx, rng));
-    }
-    edits
-}
-
-/// Every declared size at once, so every reader of a size in the tree has a
-/// changed descendant in the same frame and the whole dirty set has to settle
-/// together.
-fn edit_every(h: &mut Harness, tree: &Tree, rng: &mut Rng) -> HashMap<usize, Lens> {
-    (0..tree.sized.len())
-        .map(|idx| (idx, resize_one(h, tree, idx, rng)))
-        .collect()
-}
-
-/// A way of changing what a span holds. Each is a shape worth its own case:
-/// taking a child out of the middle is not the same as emptying a span, and
-/// adding one is not the same as adding three.
-#[derive(Clone, Copy, Debug)]
-enum Shuffle {
-    /// Every other child, so what is left is interleaved with what went.
-    EveryOther,
-    /// Everything but the first, which is the last step before empty.
-    AllButFirst,
-    /// Three more on the end at once.
-    AddThree,
-    /// The first out and three more on, so the count moves both ways.
-    SwapForThree,
-    /// One out of the middle and one on the end.
-    TradeOne,
-}
-
-const SHUFFLES: [Shuffle; 5] = [
-    Shuffle::EveryOther,
-    Shuffle::AllButFirst,
-    Shuffle::AddThree,
-    Shuffle::SwapForThree,
-    Shuffle::TradeOne,
-];
-
-impl Shuffle {
-    fn of(self, grown: usize) -> SpanEdit {
-        let all = |step: usize, from: usize| (from..grown).step_by(step).collect();
-        match self {
-            Self::EveryOther => SpanEdit {
-                detach: all(2, 0),
-                attach: 0,
-            },
-            Self::AllButFirst => SpanEdit {
-                detach: all(1, 1),
-                attach: 0,
-            },
-            Self::AddThree => SpanEdit {
-                detach: Vec::new(),
-                attach: 3,
-            },
-            Self::SwapForThree => SpanEdit {
-                detach: vec![0],
-                attach: 3,
-            },
-            Self::TradeOne => SpanEdit {
-                detach: vec![grown / 2],
-                attach: 1,
-            },
-        }
-    }
-}
-
-/// Applies `shuffle` to every third span, and says what it did so the cold
-/// tree can be grown that way. The widgets it takes out are given back: the
-/// last share of one must outlive the comparison, or its id is handed to
-/// something else and the two trees stop lining up.
-fn reshuffle(
-    h: &mut Harness,
-    tree: &mut Tree,
-    shuffle: Shuffle,
-) -> (HashMap<usize, SpanEdit>, Vec<StrongWidget>) {
-    let mut edits = HashMap::new();
-    let mut detached = Vec::new();
-    for (idx, span) in tree.spans.iter_mut().enumerate().step_by(3) {
-        let span_edit = shuffle.of(span.grown);
-        let mut take = span_edit.detach.clone();
-        take.sort_unstable();
-        let children = &mut h.rsc[span.id].children;
-        // Highest first, so an index means the same child however many of
-        // its neighbours are going too.
-        for j in take.into_iter().rev() {
-            if j < children.len() {
-                detached.push(children.remove(j));
-            }
-        }
-        let attach = span_edit.attach.min(span.spares.len());
-        children.extend(span.spares.drain(..attach));
-        edits.insert(idx, span_edit);
-    }
-    (edits, detached)
-}
-
-/// Every widget in one tree against the matching widget in the other. A
-/// mismatch prints the widget's ancestry, marking the ones that own a slot,
-/// since where two trees disagree is rarely where the cause is.
-fn assert_same(seed: u64, what: &str, warm: (&Harness, &Tree), cold: (&Harness, &Tree)) {
-    let ((wh, wt), (ch, ct)) = (warm, cold);
-    assert_eq!(wt.ids.len(), ct.ids.len(), "seed {seed}: different trees");
-    let mut drawn = 0;
-    let mut wrong = 0;
-    for (i, (&w, &c)) in wt.ids.iter().zip(&ct.ids).enumerate() {
-        let (got, want) = (wh.region(&w), ch.region(&c));
-        drawn += usize::from(got.is_some());
-        // This oracle cares where rasterization lands, not whether equivalent
-        // arithmetic produced the same f32. Keep the tolerance to one
-        // twentieth of a physical pixel, while whether a widget drew remains
-        // exact.
-        if same_region(got, want) {
-            continue;
-        }
-        wrong += 1;
-        if wrong <= 3 {
-            let mut chain = Vec::new();
-            let mut at = Some(w);
-            while let Some(id) = at {
-                let active = &wh.render.active[&id];
-                let slot = match active.move_idx == active.parent_move {
-                    true => "",
-                    false => "*",
+        const NAMED: [Case; [$($case,)*].len()] = [$($case,)*];
     };
-                chain.push(format!("{}{slot}", wh.rsc.widgets().label(id)));
-                at = active.parent;
-            }
-            println!(
-                "seed {seed} after {what}: widget {i}\n  warm {got:?}\n  cold {want:?}\n  {}",
-                chain.join(" < ")
-            );
-        }
-    }
-    assert!(drawn > 0, "seed {seed}: nothing was drawn");
-    assert_eq!(wrong, 0, "seed {seed}: {wrong} widgets differ after {what}");
 }
 
-fn changed_size(seed: u64) {
-    let mut warm = Harness::new((900, 1200));
-    let grown = plant(&mut warm, seed, &Edits::default());
-
-    let mut rng = Rng::new(seed ^ 0x5eed);
-    let sizes = edit(&mut warm, &grown, &mut rng);
-    warm.frame();
-
-    let mut cold = Harness::new((900, 1200));
-    let same = plant(
-        &mut cold,
-        seed,
-        &Edits {
-            sizes,
-            ..Default::default()
-        },
-    );
-
-    assert_same(seed, "a size change", (&warm, &grown), (&cold, &same));
+cases! {
+    many_widgets_redrawing_at_once_leaves_every_box_where_it_was = Case::RepaintSome,
+    everything_redrawing_at_once_leaves_every_box_where_it_was = Case::Repaint,
+    a_resize_lands_where_starting_at_that_size_would = Case::Resize,
+    a_resize_and_a_repaint_land_where_starting_that_way_would = Case::ResizeRepaint,
+    a_size_change_after_a_resize_lands_the_same_way = Case::ResizeSize,
+    a_resize_after_a_size_change_lands_the_same_way = Case::SizeResize,
+    a_size_change_lands_where_growing_it_that_way_would = Case::Size,
+    every_size_changing_at_once_lands_where_growing_it_that_way_would = Case::EverySize,
+    an_alignment_change_lands_where_growing_it_that_way_would = Case::Align,
+    giving_and_taking_a_movable_region_rebuilds_what_resolves_it = Case::RegionNode,
+    reordering_a_span_lands_where_growing_it_that_way_would = Case::Reorder,
 }
 
-fn reshuffled(seed: u64, shuffle: Shuffle) {
-    let mut warm = Harness::new((900, 1200));
-    let mut grown = plant(&mut warm, seed, &Edits::default());
-    // Some seeds grow nothing but wrappers, and a shuffle with no span to
-    // shuffle is not the same thing as one that had no effect.
-    if grown.spans.is_empty() {
-        return;
-    }
-    let before: Vec<_> = grown.ids.iter().map(|id| warm.region(id)).collect();
-
-    let (spans, _held) = reshuffle(&mut warm, &mut grown, shuffle);
-    warm.frame();
-
-    // Or the two trees would agree for want of anything having happened.
-    let after = grown.ids.iter().map(|id| warm.region(id));
-    let moved = before.iter().zip(after).filter(|(a, b)| *a != b).count();
-    assert!(moved > 0, "seed {seed}: {shuffle:?} changed nothing");
-
-    let mut cold = Harness::new((900, 1200));
-    let same = plant(
-        &mut cold,
-        seed,
-        &Edits {
-            spans,
-            ..Default::default()
-        },
-    );
-
-    let what = format!("{shuffle:?}");
-    assert_same(seed, &what, (&warm, &grown), (&cold, &same));
-}
-
-fn changed_every_size(seed: u64) {
-    let mut warm = Harness::new((900, 1200));
-    let grown = plant(&mut warm, seed, &Edits::default());
-    if grown.sized.is_empty() {
-        return;
-    }
-
-    let mut rng = Rng::new(seed ^ 0xa11);
-    let sizes = edit_every(&mut warm, &grown, &mut rng);
-    warm.frame();
-
-    let mut cold = Harness::new((900, 1200));
-    let same = plant(
-        &mut cold,
-        seed,
-        &Edits {
-            sizes,
-            ..Default::default()
-        },
-    );
-
-    assert_same(seed, "every size at once", (&warm, &grown), (&cold, &same));
-}
-
-/// Marks a spread of widgets for redraw at once. Nothing changes, so no box
-/// may either; what this exercises is the order a frame settles a dirty set
-/// in, which the other cases reach one dependency path at a time.
-fn repainted_together(seed: u64) {
-    let mut warm = Harness::new((900, 1200));
-    let grown = plant(&mut warm, seed, &Edits::default());
-    for &id in grown.ids.iter().step_by(5) {
-        warm.rsc.widgets_mut().get_dyn_mut(id);
-    }
+/// The shuffles are one test between them, so they are the only cases `ALL`
+/// may hold without a test of their own.
+#[test]
+fn every_case_runs_without_the_long_scan() {
+    for case in ALL {
         assert!(
-        !warm.rsc.widgets().needs_redraw.is_empty(),
-        "seed {seed}: nothing was marked"
+            NAMED.contains(&case) || matches!(case, Case::Shuffle(_)),
+            "{} runs only in the long seed scan; give it a case here",
+            case.name()
         );
-    warm.frame();
-
-    let mut cold = Harness::new((900, 1200));
-    let same = plant(&mut cold, seed, &Edits::default());
-
-    let what = "many repaints at once";
-    assert_same(seed, what, (&warm, &grown), (&cold, &same));
     }
-
-fn resized(seed: u64) {
-    let mut warm = Harness::new((1920, 1200));
-    let grown = plant(&mut warm, seed, &Edits::default());
-    warm.resize((640, 900));
-    warm.frame();
-
-    let mut cold = Harness::new((640, 900));
-    let same = plant(&mut cold, seed, &Edits::default());
-
-    assert_same(seed, "a resize", (&warm, &grown), (&cold, &same));
-}
-
-fn resized_then_changed(seed: u64) {
-    let mut warm = Harness::new((1920, 1200));
-    let grown = plant(&mut warm, seed, &Edits::default());
-    warm.resize((640, 900));
-    warm.frame();
-
-    let mut rng = Rng::new(seed ^ 0xb0a7);
-    let sizes = edit(&mut warm, &grown, &mut rng);
-    warm.frame();
-
-    let mut cold = Harness::new((640, 900));
-    let same = plant(
-        &mut cold,
-        seed,
-        &Edits {
-            sizes,
-            ..Default::default()
-        },
-    );
-
-    let what = "a resize then a size change";
-    assert_same(seed, what, (&warm, &grown), (&cold, &same));
-}
-
-#[test]
-fn a_changed_size_lands_where_growing_it_that_way_would() {
-    SEEDS.into_iter().for_each(changed_size);
-}
-
-#[test]
-fn every_size_changing_at_once_lands_where_growing_it_that_way_would() {
-    SEEDS.into_iter().for_each(changed_every_size);
-}
-
-#[test]
-fn many_widgets_redrawing_at_once_leaves_every_box_where_it_was() {
-    SEEDS.into_iter().for_each(repainted_together);
-}
-
-#[test]
-fn a_resize_lands_where_starting_at_that_size_would() {
-    SEEDS.into_iter().for_each(resized);
-}
-
-#[test]
-fn a_size_change_after_a_resize_lands_the_same_way() {
-    SEEDS.into_iter().for_each(resized_then_changed);
 }
 
 #[test]
 fn adding_and_removing_span_children_lands_where_growing_it_that_way_would() {
-    for shuffle in SHUFFLES {
+    for case in ALL {
+        if matches!(case, Case::Shuffle(_)) {
             for seed in SEEDS {
-            reshuffled(seed, shuffle);
+                check(seed, depth(), case);
+            }
         }
     }
 }
 
-/// Reproduces a divergence that predates the position chain: laying a tree out
-/// again does not always land where growing it cold does.
-///
-/// Every one seen so far is a wrapping text on a span's *own* axis, where the
-/// two draws do not agree. The span measures the child in the whole box, the
-/// child shapes to that width and reports the width it used, the span then
-/// places it in exactly that width -- which is a length change, so the child
-/// shapes again, and its longest line is shorter than the box it was just
-/// given. Each pass narrows it, so where the tree ends up depends on how many
-/// passes it has had, and a warm tree has had a different number from a cold
-/// one. Layout is supposed to be a function of the state alone.
-///
-/// A span whose axis is not the wrap axis is stable, which is every real
-/// column of text, and why nothing else has run into this.
-///
-/// 7 of these 90 diverge on `db1751f`, before the chain; 30 do with it, since
-/// a placed child reaches the second shaping more often. Both numbers are the
-/// same defect, and it wants fixing where the two draws meet -- LAYOUT.md §4 --
-/// rather than anywhere in the chain.
 #[test]
-#[ignore = "a hundred seeds, rather than the seven the others check"]
+#[ignore = "as many seeds as it is asked for, rather than the ten the others check"]
 fn a_long_run_of_seeds_agrees() {
-    let seeds = std::env::var("IRIS_GENERATED_SEED")
-        .ok()
-        .and_then(|seed| seed.parse().ok())
-        .map(|seed| seed..=seed)
-        .unwrap_or(1..=100);
-    for seed in seeds {
-        changed_size(seed);
-        changed_every_size(seed);
-        repainted_together(seed);
-        resized(seed);
-        resized_then_changed(seed);
-        for shuffle in SHUFFLES {
-            reshuffled(seed, shuffle);
-        }
+    let depth = depth();
+    let seeds = rig::seeds("IRIS_GENERATED_SEED", "IRIS_GENERATED_SEEDS", 100);
+    over_seeds(seeds, |seed| {
+        let grown = plan(seed, depth, &Edits::default());
+        for case in ALL {
+            check_plan(&grown, seed, depth, case);
         }
+    });
 }

tests/gpu/mod.rs

@@ -0,0 +1,66 @@
+//! The adapter, the surface configuration and the target the GPU rigs share,
+//! so no two of them can probe for a device or make a target in 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![],
+    }
+}
+
+/// A square colour target to draw a pass into. `copy` adds the usage a rig
+/// that reads the pixels back needs; one that only times the pass does not.
+// This module is compiled into each rig target separately, so a helper the
+// ones that make no target of their own do not call is dead code there.
+#[allow(dead_code)]
+pub fn target(device: &Device, format: TextureFormat, size: u32, copy: bool) -> Texture {
+    device.create_texture(&TextureDescriptor {
+        label: Some("gpu rig target"),
+        size: Extent3d {
+            width: size,
+            height: size,
+            depth_or_array_layers: 1,
+        },
+        mip_level_count: 1,
+        sample_count: 1,
+        dimension: TextureDimension::D2,
+        format,
+        usage: match copy {
+            true => TextureUsages::RENDER_ATTACHMENT | TextureUsages::COPY_SRC,
+            false => TextureUsages::RENDER_ATTACHMENT,
+        },
+        view_formats: &[],
+    })
+}

tests/layout.rs

@@ -1,184 +0,0 @@
-//! Where a frame puts things, with no window to put them in.
-
-use iris::harness::{Harness, assert_corners};
-use iris::prelude::*;
-
-/// A fixed 100 wide, and the rest of the 400 to its neighbour.
-fn two_rects(h: &mut Harness) -> (WidgetId, WidgetId) {
-    let left = rect(Color::RED).width(100).add(&mut h.rsc);
-    let right = rect(Color::BLUE).add(&mut h.rsc);
-    h.set_root((left, right).span(Dir::RIGHT));
-    (left.id(), right.id())
-}
-
-#[test]
-fn a_span_gives_each_child_the_width_it_asked_for() {
-    let mut h = Harness::new((400, 200));
-    let (left, right) = two_rects(&mut h);
-
-    assert_corners!(h, left, (0, 0), (100, 200));
-    assert_corners!(h, right, (100, 0), (400, 200));
-}
-
-#[test]
-fn resizing_relays_out_against_the_new_output() {
-    let mut h = Harness::new((400, 200));
-    let (left, right) = two_rects(&mut h);
-
-    h.resize((800, 100));
-    assert!(h.needs_redraw());
-    h.frame();
-
-    assert_corners!(h, left, (0, 0), (100, 100));
-    assert_corners!(h, right, (100, 0), (800, 100));
-}
-
-#[test]
-fn an_empty_widget_takes_a_share_of_a_span() {
-    let mut h = Harness::new((400, 200));
-    let gap = ().add(&mut h.rsc);
-    let right = rect(Color::BLUE).width(100).add(&mut h.rsc);
-    h.set_root((gap, right).span(Dir::RIGHT));
-
-    assert_corners!(h, gap, (0, 0), (300, 200));
-    assert_corners!(h, right, (300, 0), (400, 200));
-}
-
-#[test]
-fn a_child_drawn_twice_moves_once() {
-    let mut h = Harness::new((400, 200));
-    // `Aligned` draws its child twice; listing it twice would move it twice.
-    let inner = rect(Color::BLUE).add(&mut h.rsc);
-    let centered = inner.center().width(200).add(&mut h.rsc);
-    let left = rect(Color::RED).width(100).add(&mut h.rsc);
-    h.set_root((left, centered).span(Dir::RIGHT));
-    assert_corners!(h, inner, (100, 0), (300, 200));
-
-    h.rsc[left].x = Some(Len::abs(150));
-    h.frame();
-
-    assert_corners!(h, inner, (150, 0), (350, 200));
-}
-
-#[test]
-fn a_resize_lands_where_a_cold_start_would() {
-    let build = |h: &mut Harness| {
-        let para = wtext(
-            "Wrapping shapes one source into as many lines as its container leaves room \
-             for, so the height of a paragraph is an answer rather than a setting.",
-        )
-        .size(20)
-        .wrap(true)
-        .pad(16)
-        .add(&mut h.rsc);
-        let below = rect(Color::RED).add(&mut h.rsc);
-        let root = (para, below).span(Dir::DOWN).pad(12);
-        h.set_root(root);
-        (para, below)
-    };
-
-    let mut cold = Harness::new((900, 1200));
-    let (cold_para, cold_below) = build(&mut cold);
-
-    let mut resized = Harness::new((1920, 1200));
-    let (para, below) = build(&mut resized);
-    resized.resize((900, 1200));
-    resized.frame();
-
-    assert_eq!(resized.region(&para), cold.region(&cold_para), "paragraph");
-    assert_eq!(resized.region(&below), cold.region(&cold_below), "below");
-}
-
-#[test]
-fn a_fixed_box_is_drawn_again_rather_than_stretched() {
-    let mut h = Harness::new((400, 400));
-    // The panel fills a stack sized by its sibling, so it is drawn in the
-    // whole box and then placed in the shorter one. Reusing it in that fixed
-    // box afterwards would leave it whatever height it happened to have.
-    let panel = rect(Color::BLUE).add(&mut h.rsc);
-    let leaf = rect(Color::RED).height(100).add(&mut h.rsc);
-    let stack = (panel, leaf)
-        .stack()
-        .size(StackSize::Child(1))
-        .add(&mut h.rsc);
-    h.set_root(stack.align(Align::TOP));
-    assert_corners!(h, panel, (0, 0), (400, 100));
-
-    h.rsc[leaf].y = Some(Len::abs(250));
-    h.frame();
-
-    assert_corners!(h, panel, (0, 0), (400, 250));
-}
-
-#[test]
-fn a_moved_subtree_takes_its_children_with_it() {
-    let mut h = Harness::new((400, 400));
-    let first = rect(Color::RED).height(40).add(&mut h.rsc);
-    let inner = rect(Color::BLUE).add(&mut h.rsc);
-    let row = inner.pad(10).height(40).add(&mut h.rsc);
-    h.set_root((first, row).span(Dir::DOWN));
-    assert_corners!(h, inner, (10, 50), (390, 70));
-
-    h.rsc[first].y = Some(Len::abs(80));
-    h.frame();
-
-    // The row is the same shape somewhere else, so one slot moved it and
-    // `inner`'s own region was never rewritten.
-    assert_corners!(h, inner, (10, 90), (390, 110));
-}
-
-#[test]
-fn a_fixed_length_child_keeps_it_when_the_box_around_it_grows() {
-    let mut h = Harness::new((400, 200));
-    let fixed = rect(Color::BLUE).width(50).add(&mut h.rsc);
-    let rest = rect(Color::GREEN).add(&mut h.rsc);
-    let panel = (fixed, rest).span(Dir::RIGHT).add(&mut h.rsc);
-    // Changing the bar's width is the only thing that changes the box the
-    // panel and everything under it was drawn for.
-    let bar = rect(Color::RED).width(100).add(&mut h.rsc);
-    h.set_root((bar, panel).span(Dir::RIGHT));
-    assert_corners!(h, fixed, (100, 0), (150, 200));
-    assert_corners!(h, rest, (150, 0), (400, 200));
-
-    h.rsc[bar].x = Some(Len::abs(200));
-    h.frame();
-
-    // The panel's box is 100 shorter, so the fixed child is the same 50 wide
-    // against its new start and the one taking the rest absorbs the change.
-    assert_corners!(h, fixed, (200, 0), (250, 200));
-    assert_corners!(h, rest, (250, 0), (400, 200));
-}
-
-#[test]
-fn a_box_with_a_fixed_length_can_be_stretched_on_its_other_axis() {
-    let mut h = Harness::new((400, 200));
-    // The row is 40 tall whatever happens, which used to make its drawing
-    // impossible to take out of: recovering a fraction of a box needs a
-    // relative extent, and it has none on that axis.
-    let inner = rect(Color::BLUE).add(&mut h.rsc);
-    let row = inner.pad(10).height(40).add(&mut h.rsc);
-    let filler = rect(Color::GREEN).add(&mut h.rsc);
-    let column = (row, filler).span(Dir::DOWN).add(&mut h.rsc);
-    let bar = rect(Color::RED).width(100).add(&mut h.rsc);
-    h.set_root((bar, column).span(Dir::RIGHT));
-    assert_corners!(h, inner, (110, 10), (390, 30));
-
-    h.rsc[bar].x = Some(Len::abs(200));
-    h.frame();
-
-    assert_corners!(h, inner, (210, 10), (390, 30));
-}
-
-#[test]
-fn only_a_container_that_places_its_children_lengthens_the_chain() {
-    let mut h = Harness::new((400, 200));
-    let leaf = rect(Color::BLUE).add(&mut h.rsc);
-    // Four widgets between the span and the leaf, none of which places what
-    // it draws, so all of them share the span's slot.
-    let buried = leaf.pad(4).pad(4).pad(4).pad(4).add(&mut h.rsc);
-    let bar = rect(Color::RED).width(100).add(&mut h.rsc);
-    h.set_root((bar, buried).span(Dir::RIGHT));
-
-    let slot = h.render.active[&leaf.id()].parent_move;
-    assert_eq!(h.render.moves.depth(slot), 1, "one span above the leaf");
-}

tests/layout_diagnostics.rs

@@ -5,23 +5,51 @@
 //!     cargo test --release --features layout-diagnostics \
 //!       --test layout_diagnostics -- --ignored --nocapture
 //!
-//! Uninstrumented hardware totals for one phase:
+//! Build the uninstrumented test with `cargo test --release --test
+//! layout_diagnostics --no-run`, then run the emitted executable directly:
 //!
-//!     IRIS_PHASE=resize IRIS_FRAMES=1000 perf stat \
-//!       -e cycles:u,instructions:u cargo test --release \
-//!       --test layout_diagnostics -- --ignored --nocapture
+//!     IRIS_PHASE=resize IRIS_FRAMES=10000 perf stat -r 7 \
+//!       -e cycles:u,instructions:u /path/to/layout_diagnostics --ignored --nocapture
 //!
 //! `IRIS_PHASE` is `cold`, `repaint`, `many`, `size`, `scroll`, `resize`, or
 //! `all`. `IRIS_SEED`, `IRIS_DEPTH`, and `IRIS_FRAMES` select the load, and
-//! `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.
+
+mod rig;
 
 use iris::harness::Harness;
 use iris::prelude::*;
-use iris::random::{Edits, Tree, grow};
+use iris::random::{Edits, Tree, build, plan};
+use rig::env;
 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() {
@@ -30,15 +58,15 @@ fn a_selected_widget_retains_its_layout_events() {
     diagnostics::clear_traced_widgets();
     let _ = diagnostics::take();
     let mut harness = Harness::new((400, 200));
-    let leaf = rect(Color::RED).add(&mut harness.rsc);
+    let leaf = rect(Color::RED).region_node().add(&mut harness.rsc);
     let other = rect(Color::BLUE).add(&mut harness.rsc);
     let root = (leaf, other).span(Dir::RIGHT).add(&mut harness.rsc);
     harness.set_root(root);
     diagnostics::trace_widget(leaf.id());
     let _ = diagnostics::take();
 
-    let _ = harness.rsc.widgets_mut().get_dyn_mut(root.id());
-    let _ = harness.rsc.widgets_mut().get_dyn_mut(leaf.id());
+    harness.rsc.widgets_mut().mark_for_redraw(root.id());
+    harness.rsc.widgets_mut().mark_for_redraw(leaf.id());
     harness.frame();
 
     let report = diagnostics::take();
@@ -46,7 +74,7 @@ fn a_selected_widget_retains_its_layout_events() {
         report
             .traces()
             .iter()
-            .any(|event| matches!(event, TraceEvent::Placed { id, .. } if *id == leaf.id()))
+            .any(|event| matches!(event, TraceEvent::RegionNode { id, .. } if *id == leaf.id()))
     );
     assert!(
         report
@@ -69,13 +97,6 @@ fn a_selected_widget_retains_its_layout_events() {
     diagnostics::clear_traced_widgets();
 }
 
-fn env<T: std::str::FromStr>(name: &str, fallback: T) -> T {
-    std::env::var(name)
-        .ok()
-        .and_then(|value| value.parse().ok())
-        .unwrap_or(fallback)
-}
-
 #[cfg(feature = "layout-diagnostics")]
 fn trace_selected(tree: &Tree) {
     let Ok(value) = std::env::var("IRIS_TRACE_INDEX") else {
@@ -92,9 +113,26 @@ fn trace_selected(tree: &Tree) {
 #[cfg(not(feature = "layout-diagnostics"))]
 fn trace_selected(_: &Tree) {}
 
+/// The shape a cost is measured on must not depend on what layout measured,
+/// or two commits are compared on two different trees. See `Edits`.
+fn rig_edits() -> Edits {
+    Edits {
+        fixed_branches: true,
+        ..Default::default()
+    }
+}
+
+fn 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.drop_bounds();
+    }
+    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, &Edits::default());
+    let (root, tree) = fixture(&mut harness, seed, depth);
     harness.state.root = Some(root);
     harness.frame();
     println!(
@@ -125,6 +163,9 @@ fn report(label: &str, mut elapsed: Vec<f64>, _harness: &Harness) {
     {
         let diagnostics = iris::core::layout_diagnostics::take();
         print!("{}", diagnostics.per_frame(frames));
+        for event in diagnostics.traces() {
+            println!("    {event:?}");
+        }
         for callsite in diagnostics.hot_text().iter().take(3) {
             let mut ancestry = Vec::new();
             let mut id = Some(callsite.id);
@@ -173,7 +214,7 @@ fn layout_cost() {
 
     if selected("cold") {
         let mut harness = Harness::new(OUTPUT);
-        let (root, tree) = grow(&mut harness.rsc, seed, depth, &Edits::default());
+        let (root, tree) = fixture(&mut harness, seed, depth);
         harness.state.root = Some(root);
         println!(
             "fixture: seed {seed}, depth {depth}, {} widgets",
@@ -183,7 +224,6 @@ fn layout_cost() {
         #[cfg(feature = "layout-diagnostics")]
         let _ = iris::core::layout_diagnostics::take();
         run("cold", 1, &mut harness, |_, _| {});
-        drop(tree);
     }
 
     if selected("repaint") {
@@ -191,7 +231,7 @@ fn layout_cost() {
         trace_selected(&tree);
         let leaf = tree.ids[0];
         run("repaint", frames, &mut harness, move |harness, _| {
-            let _ = harness.rsc.widgets_mut().get_dyn_mut(leaf);
+            harness.rsc.widgets_mut().mark_for_redraw(leaf);
         });
     }
 
@@ -206,7 +246,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);
             }
         });
     }
@@ -216,7 +256,11 @@ fn layout_cost() {
         trace_selected(&tree);
         let sized = tree.sized[0];
         run("size", frames, &mut harness, move |harness, frame| {
-            harness.rsc[sized].x = Some(Len::abs(100.0 + (frame % 2) as f32 * 40.0));
+            let len = LayoutLen::px(100.0 + (frame % 2) as f32 * 40.0);
+            harness
+                .rsc
+                .widgets_mut()
+                .set_size_rule(sized, Axis::X, SizeRule::from(len));
         });
     }
 
@@ -235,6 +279,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

@@ -0,0 +1,43 @@
+//! Prints where a cold layout puts every widget of many grown trees, so two
+//! commits can be compared on cold layout alone. The warm/cold oracle cannot
+//! see a change that moves cold layout, since both of its sides move; this
+//! can, by diffing its output across the change:
+//!
+//!     IRIS_DUMP_SEEDS=400 IRIS_DUMP_DEPTH=5 cargo test --release \
+//!       --test layout_dump -- --ignored --nocapture > /tmp/before.txt
+//!
+//! then the same after, and `diff` the two. A line is one widget: the seed,
+//! its index in creation order, and its box in window pixels, or `-` where
+//! it is not drawn. `IRIS_UNBOUNDED=1` drops the trees' intrinsic bounds, as
+//! in the diagnostics rig, which compares the two paths over the same shapes.
+
+mod rig;
+
+use iris::harness::Harness;
+use iris::random::{Edits, build, plan};
+use rig::env;
+
+#[test]
+#[ignore = "a dump to diff across commits, not a check"]
+fn every_cold_layout_is_printed() {
+    let seeds = env("IRIS_DUMP_SEEDS", 400_u64);
+    let depth = env("IRIS_DUMP_DEPTH", 5_usize);
+    let mut out = String::new();
+    for seed in 1..=seeds {
+        let mut harness = Harness::new((1920.0, 1200.0));
+        let mut plan = plan(seed, depth, &Edits::default());
+        if env("IRIS_UNBOUNDED", 0_u8) != 0 {
+            plan.drop_bounds();
+        }
+        let (root, tree) = build(&mut harness.rsc, &plan);
+        harness.state.root = Some(root);
+        harness.frame();
+        for (index, id) in tree.ids.iter().enumerate() {
+            match harness.region(id) {
+                Some(region) => out.push_str(&format!("{seed} {index} {region:?}\n")),
+                None => out.push_str(&format!("{seed} {index} -\n")),
+            }
+        }
+    }
+    print!("{out}");
+}

tests/mask_clip.rs

@@ -0,0 +1,162 @@
+//! Which pixels a mask lets through, read back off the GPU.
+//!
+//!     cargo test --release --test mask_clip -- --ignored --nocapture
+//!
+//! Ignored because it needs a device, which not every machine running the
+//! suite has -- and a deliberate run on one without fails rather than passing
+//! with nothing checked. Nothing else here sees a mask at all: `iris::harness`
+//! draws no pixels, and a mask's rectangle is resolved through its own move
+//! chain in the shader, so the CPU's idea of it is not what clips anything.
+
+use iris::prelude::*;
+use iris_core::{
+    Len, Mask, MoveIdx, PrimitiveInst, RectPrimitive, UiData, UiRegion, UiRenderNode,
+    UiRenderState, UiSpan,
+};
+use wgpu::{Color as GpuColor, *};
+
+#[path = "gpu/mod.rs"]
+mod gpu;
+
+const SIZE: u32 = 256;
+
+/// The mask is a box inside a move chain two links long and the drawing
+/// overflows it on both axes, so what comes back is the mask's own rectangle
+/// composed through that chain -- and a clip resolved through the wrong one,
+/// or not composed at all, lands somewhere else.
+#[test]
+#[ignore = "needs a gpu"]
+fn a_mask_clips_its_own_box_composed_through_its_chain() {
+    let adapter = gpu::adapter().expect("no adapter to draw with");
+    println!("adapter: {:?}", adapter.get_info().name);
+    let (device, queue) = pollster::block_on(adapter.request_device(&DeviceDescriptor::default()))
+        .expect("no device on that adapter");
+    let format = TextureFormat::Bgra8Unorm;
+    let mut node = UiRenderNode::new(&device, &gpu::config(format, SIZE));
+    let mut ui = UiData::default();
+    let mut render = UiRenderState::new();
+    let kind = ui.primitives.kind::<RectPrimitive>();
+    let id = ui.widgets.add_strong(Rect::new(UiColor::WHITE)).id();
+    let px = Len::px;
+
+    let outer = render.moves.push(MoveIdx::NONE, UiRegion::FULL);
+    let shift = (16.0, 24.0);
+    let inner = render.moves.push(
+        outer,
+        UiRegion::new(
+            UiSpan::new(px(shift.0), px(shift.0) + Len::FULL),
+            UiSpan::new(px(shift.1), px(shift.1) + Len::FULL),
+        ),
+    );
+    let clip = (20.0, 30.0, 120.0, 90.0);
+    let mask = ui.masks.push(Mask {
+        region: UiRegion::new(
+            UiSpan::new(px(clip.0), px(clip.2)),
+            UiSpan::new(px(clip.1), px(clip.3)),
+        ),
+        move_idx: inner,
+    });
+    // The owner's reference, which is what keeps a real one alive.
+    ui.masks.push_ref(mask);
+    render.layers.write(
+        0,
+        PrimitiveInst {
+            kind,
+            id,
+            primitive: RectPrimitive::color(UiColor::WHITE),
+            region: UiRegion::new(
+                UiSpan::new(px(0.0), px(200.0)),
+                UiSpan::new(px(0.0), px(200.0)),
+            ),
+            mask_idx: mask,
+            move_idx: inner,
+        },
+    );
+    node.update(&device, &queue, &mut ui, &mut render);
+
+    let target = gpu::target(&device, format, SIZE, true);
+    let view = target.create_view(&TextureViewDescriptor::default());
+    let row = SIZE * 4;
+    let readback = device.create_buffer(&BufferDescriptor {
+        label: Some("mask clip"),
+        size: (row * SIZE) as u64,
+        usage: BufferUsages::MAP_READ | BufferUsages::COPY_DST,
+        mapped_at_creation: false,
+    });
+    let mut encoder = device.create_command_encoder(&CommandEncoderDescriptor::default());
+    {
+        let pass = &mut encoder.begin_render_pass(&RenderPassDescriptor {
+            label: None,
+            color_attachments: &[Some(RenderPassColorAttachment {
+                view: &view,
+                resolve_target: None,
+                ops: Operations {
+                    load: LoadOp::Clear(GpuColor::BLACK),
+                    store: StoreOp::Store,
+                },
+                depth_slice: None,
+            })],
+            depth_stencil_attachment: None,
+            timestamp_writes: None,
+            occlusion_query_set: None,
+            multiview_mask: None,
+        });
+        node.draw(pass);
+    }
+    let whole = Extent3d {
+        width: SIZE,
+        height: SIZE,
+        depth_or_array_layers: 1,
+    };
+    encoder.copy_texture_to_buffer(
+        TexelCopyTextureInfo {
+            texture: &target,
+            mip_level: 0,
+            origin: Origin3d::ZERO,
+            aspect: TextureAspect::All,
+        },
+        TexelCopyBufferInfo {
+            buffer: &readback,
+            layout: TexelCopyBufferLayout {
+                offset: 0,
+                bytes_per_row: Some(row),
+                rows_per_image: Some(SIZE),
+            },
+        },
+        whole,
+    );
+    queue.submit(Some(encoder.finish()));
+    let slice = readback.slice(..);
+    slice.map_async(MapMode::Read, |_| {});
+    device
+        .poll(PollType::Wait {
+            submission_index: None,
+            timeout: None,
+        })
+        .expect("the pass did not finish");
+    let pixels = slice.get_mapped_range().expect("the target did not map");
+
+    let mut lit = 0;
+    let mut bounds: Option<(u32, u32, u32, u32)> = None;
+    for y in 0..SIZE {
+        for x in 0..SIZE {
+            if pixels[(y * row + x * 4) as usize] == 0 {
+                continue;
+            }
+            lit += 1;
+            let (x0, y0, x1, y1) = bounds.unwrap_or((x, y, x, y));
+            bounds = Some((x0.min(x), y0.min(y), x1.max(x), y1.max(y)));
+        }
+    }
+    // The clip shifted by the chain. Its far edge is exclusive: a fragment
+    // exactly on it is the first one outside.
+    let want = (
+        (clip.0 + shift.0) as u32,
+        (clip.1 + shift.1) as u32,
+        (clip.2 + shift.0) as u32 - 1,
+        (clip.3 + shift.1) as u32 - 1,
+    );
+    assert_eq!(bounds, Some(want), "{lit} pixels through the mask");
+    let (x0, y0, x1, y1) = want;
+    assert_eq!(lit, (x1 - x0 + 1) * (y1 - y0 + 1), "the clip has a hole");
+}

tests/replace_cost.rs

@@ -1,4 +1,4 @@
-//! What re-placing a subtree costs per frame, as a load for a counter rather
+//! What remapping a subtree costs per frame, as a load for a counter rather
 //! than a check. A span of 200 fixed-height rows, five primitives each, with
 //! the row above them changing height every frame, so every row below is
 //! offered a box the same shape somewhere else.
@@ -6,9 +6,7 @@
 //!     cargo test --release --test replace_cost -- --ignored
 //!     perf stat -e instructions:u target/release/.../replace_cost-* --ignored
 //!
-//! Wall time is the wrong number here; see `draw_cost.rs`. Measured on
-//! 2026-09-14 at 1.98M instructions per frame, against 2.38M for rewriting
-//! each row's regions instead and 7.13M for redrawing them.
+//! Wall time is the wrong number here; see `draw_cost.rs`.
 
 use iris::harness::Harness;
 use iris::prelude::*;
@@ -18,7 +16,7 @@ const FRAMES: usize = 200;
 
 #[test]
 #[ignore = "measurement, not a check"]
-fn replacing_rows_every_frame() {
+fn remapping_rows_every_frame() {
     let mut h = Harness::new((1920, 1200));
     let first = rect(Color::RED).height(40).add(&mut h.rsc);
     let mut span = Span::empty(Dir::DOWN);
@@ -37,7 +35,7 @@ fn replacing_rows_every_frame() {
     }
     h.set_root(span);
     for i in 0..FRAMES {
-        h.rsc[first].y = Some(Len::abs(40.0 + (i % 2) as f32));
+        h.set_len(first, Axis::Y, 40.0 + (i % 2) as f32);
         h.frame();
     }
 }

tests/retained.rs

@@ -1,445 +0,0 @@
-//! What a second frame draws again, and what it keeps.
-
-use std::{cell::Cell, rc::Rc};
-
-use iris::harness::{Harness, assert_corners};
-use iris::prelude::*;
-
-/// A leaf that counts its draws and reports whatever size it is given, so a
-/// test can see what the retained path skipped.
-struct Counted {
-    draws: Rc<Cell<usize>>,
-    size: Size,
-    dependence: OnResize,
-}
-
-impl Widget for Counted {
-    fn draw(&mut self, _: &mut Painter) -> Size {
-        self.draws.set(self.draws.get() + 1);
-        self.size
-    }
-
-    fn on_resize(&self, _: Axis) -> OnResize {
-        self.dependence
-    }
-}
-
-struct Counts(Rc<Cell<usize>>);
-
-impl Counts {
-    fn get(&self) -> usize {
-        self.0.get()
-    }
-}
-
-fn counted(h: &mut Harness, size: Size, dependence: OnResize) -> (WeakWidget<Counted>, Counts) {
-    let draws = Rc::new(Cell::new(0));
-    let id = Counted {
-        draws: draws.clone(),
-        size,
-        dependence,
-    }
-    .add(&mut h.rsc);
-    (id, Counts(draws))
-}
-
-/// A fixed-width leaf beside one that takes the rest, so changing the first
-/// hands the second a different box without the output changing.
-fn pair(h: &mut Harness, rest: OnResize) -> (WeakWidget<Counted>, Counts, WidgetId) {
-    let (first, _) = counted(h, Size::from((100, 200)), OnResize::Translate);
-    let (second, draws) = counted(h, Size::REST, rest);
-    h.set_root((first, second).span(Dir::RIGHT));
-    (first, draws, second.id())
-}
-
-#[test]
-fn a_leaf_that_ignores_its_box_is_not_drawn_again_when_the_box_changes() {
-    let mut h = Harness::new((400, 200));
-    let (first, draws, second) = pair(&mut h, OnResize::Scale);
-    let settled = draws.get();
-    assert_corners!(h, second, (100, 0), (400, 200));
-
-    h.rsc[first].size = Size::from((150, 200));
-    h.frame();
-
-    assert_eq!(
-        draws.get(),
-        settled,
-        "its box is a field to write, not a reason to draw"
-    );
-    assert_corners!(h, second, (150, 0), (400, 200));
-}
-
-#[test]
-fn a_leaf_that_depends_on_its_box_is_drawn_again_when_the_box_changes() {
-    let mut h = Harness::new((400, 200));
-    let (first, draws, second) = pair(&mut h, OnResize::Redraw);
-    let settled = draws.get();
-
-    h.rsc[first].size = Size::from((150, 200));
-    h.frame();
-
-    // The preceding fixed child makes the remaining box this child's real
-    // box, so measuring it also draws it in its final place.
-    assert_eq!(draws.get(), settled + 1);
-    assert_corners!(h, second, (150, 0), (400, 200));
-}
-
-#[test]
-fn a_span_child_that_declares_its_length_is_drawn_once() {
-    let mut h = Harness::new((400, 200));
-    let (told, told_draws) = counted(&mut h, Size::from((100, 200)), OnResize::Translate);
-    let (asked, asked_draws) = counted(&mut h, Size::from((100, 200)), OnResize::Translate);
-    // The span takes one child's length from its hint and has to draw the
-    // other to find out, so only the second is drawn before it is placed.
-    let hinted = told.width(100).add(&mut h.rsc);
-    h.set_root((hinted, asked).span(Dir::RIGHT));
-
-    assert_eq!(told_draws.get(), 1);
-    assert_eq!(
-        asked_draws.get(),
-        2,
-        "drawn to be measured, then again to be placed"
-    );
-}
-
-#[test]
-fn a_span_relays_out_when_a_child_it_measured_changes() {
-    let mut h = Harness::new((400, 200));
-    let (first, _, second) = pair(&mut h, OnResize::Translate);
-
-    h.rsc[first].size = Size::from((250, 200));
-    h.frame();
-
-    assert_corners!(h, first, (0, 0), (250, 200));
-    assert_corners!(h, second, (250, 0), (400, 200));
-}
-
-#[test]
-fn a_repaint_that_keeps_its_size_does_not_relay_out() {
-    let mut h = Harness::new((400, 200));
-    let (first, draws) = counted(&mut h, Size::from((100, 200)), OnResize::Translate);
-    let (second, _) = counted(&mut h, Size::REST, OnResize::Translate);
-    h.set_root((first, second).span(Dir::RIGHT));
-    let settled = draws.get();
-
-    // Taking mutable access is the ordinary content-change signal. This
-    // widget returns the same size, so the parent has nothing to lay out.
-    let _ = h.rsc.widgets_mut().get_dyn_mut(first.id());
-    h.frame();
-
-    assert_eq!(draws.get(), settled + 1);
-}
-
-#[test]
-fn a_placed_child_survives_the_next_frame() {
-    let mut h = Harness::new((400, 200));
-    // Both children declare a length, so the span places them from their hints
-    // rather than drawing them to find out.
-    let top = rect(Color::RED).height(80).add(&mut h.rsc);
-    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.frame();
-
-    assert_corners!(h, top, (0, 0), (400, 80));
-    assert_corners!(h, bottom, (0, 80), (400, 200));
-}
-
-/// Lays its child out from the hint alone, never reading what it drew.
-struct FromHint {
-    inner: StrongWidget,
-}
-
-impl Widget for FromHint {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
-        let len = painter.size_hint(&self.inner, Axis::Y).unwrap();
-        let mut region = UiRegion::FULL;
-        region.y.end = region.y.start.offset(len.abs);
-        painter.widget_within(&self.inner, region);
-        Size::REST
-    }
-}
-
-#[test]
-fn a_parent_that_only_read_a_hint_relays_out_when_the_hint_changes() {
-    let mut h = Harness::new((400, 200));
-    let inner = rect(Color::RED).height(80).add(&mut h.rsc);
-    let parent = FromHint {
-        inner: inner.add_strong(&mut h.rsc),
-    }
-    .add(&mut h.rsc);
-    h.set_root(parent);
-    assert_corners!(h, inner, (0, 0), (400, 80));
-
-    h.rsc[inner].y = Some(Len::abs(120));
-    h.frame();
-
-    assert_corners!(h, inner, (0, 0), (400, 120));
-}
-
-/// Reads the output's size, which nothing but its own draw can put right.
-struct ReadsOutput {
-    draws: Rc<Cell<usize>>,
-}
-
-impl Widget for ReadsOutput {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
-        self.draws.set(self.draws.get() + 1);
-        Size::abs(painter.output_size() / 4.0)
-    }
-}
-
-struct ReadsWidth {
-    draws: Rc<Cell<usize>>,
-}
-
-impl Widget for ReadsWidth {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
-        self.draws.set(self.draws.get() + 1);
-        Size::abs((painter.output_len(Axis::X) / 4.0, 20.0).into())
-    }
-}
-
-#[test]
-fn a_resize_does_not_redraw_what_the_shader_can_move() {
-    let mut h = Harness::new((400, 200));
-    let (leaf, draws) = counted(&mut h, Size::REST, OnResize::Redraw);
-    h.set_root(leaf);
-    let settled = draws.get();
-
-    h.resize((800, 100));
-    assert!(h.needs_redraw());
-    h.frame();
-
-    assert_eq!(
-        draws.get(),
-        settled,
-        "its box is the same fraction of a different output"
-    );
-    assert_corners!(h, leaf, (0, 0), (800, 100));
-}
-
-#[test]
-fn a_resize_redraws_what_read_the_output() {
-    let mut h = Harness::new((400, 200));
-    let draws = Rc::new(Cell::new(0));
-    let leaf = ReadsOutput {
-        draws: draws.clone(),
-    }
-    .add(&mut h.rsc);
-    h.set_root(leaf);
-    let settled = draws.get();
-
-    h.resize((800, 100));
-    h.frame();
-
-    assert_eq!(draws.get(), settled + 1);
-}
-
-#[test]
-fn a_resize_only_redraws_read_output_axes() {
-    let mut h = Harness::new((400, 200));
-    let draws = Rc::new(Cell::new(0));
-    let leaf = ReadsWidth {
-        draws: draws.clone(),
-    }
-    .add(&mut h.rsc);
-    h.set_root(leaf);
-    let settled = draws.get();
-
-    h.resize((400, 300));
-    h.frame();
-    assert_eq!(draws.get(), settled, "height was never read");
-
-    h.resize((800, 300));
-    h.frame();
-    assert_eq!(draws.get(), settled + 1, "width changes its answer");
-}
-
-#[test]
-fn subpixel_resize_changes_accumulate_from_the_last_layout() {
-    let mut h = Harness::new((400, 200));
-    let draws = Rc::new(Cell::new(0));
-    let leaf = ReadsWidth {
-        draws: draws.clone(),
-    }
-    .add(&mut h.rsc);
-    h.set_root(leaf);
-    let settled = draws.get();
-
-    for width in [400.02, 400.04, 400.05] {
-        h.resize((width, 200.0));
-        h.frame();
-        assert_eq!(draws.get(), settled);
-    }
-
-    h.resize((400.06, 200.0));
-    h.frame();
-    assert_eq!(draws.get(), settled + 1);
-}
-
-#[test]
-fn subpixel_box_changes_accumulate_from_the_last_draw() {
-    let mut h = Harness::new((400, 200));
-    let (first, draws, _) = pair(&mut h, OnResize::Redraw);
-    let settled = draws.get();
-
-    for width in [100.02, 100.04, 100.05] {
-        h.rsc[first].size.x = Len::abs(width);
-        h.frame();
-        assert_eq!(draws.get(), settled);
-    }
-
-    h.rsc[first].size.x = Len::abs(100.06);
-    h.frame();
-    assert_eq!(draws.get(), settled + 1);
-}
-
-#[test]
-fn reporting_the_same_output_size_does_not_start_a_resize() {
-    let mut h = Harness::new((400, 200));
-    let draws = Rc::new(Cell::new(0));
-    let leaf = ReadsOutput {
-        draws: draws.clone(),
-    }
-    .add(&mut h.rsc);
-    h.set_root(leaf);
-    let settled = draws.get();
-
-    h.resize((400, 200));
-
-    assert!(!h.needs_redraw());
-    h.frame();
-    assert_eq!(draws.get(), settled);
-}
-
-#[test]
-fn narrowing_the_output_reflows_text_and_relays_out_around_it() {
-    let mut h = Harness::new((600, 400));
-    let para = wtext(
-        "Wrapping shapes one source into as many lines as its container leaves \
-        room for, so the height of a paragraph is an answer rather than a setting.",
-    )
-    .size(20)
-    .wrap(true)
-    .add(&mut h.rsc);
-    let below = rect(Color::RED).add(&mut h.rsc);
-    h.set_root((para, below).span(Dir::DOWN));
-    let top = h.region(&below).expect("drew nothing").top_left.y;
-
-    h.resize((300, 400));
-    h.frame();
-
-    let lower = h.region(&below).expect("drew nothing").top_left.y;
-    assert!(lower > top, "same words, half the width: {top} -> {lower}");
-}
-
-#[test]
-fn a_change_two_levels_under_its_reader_still_reaches_it() {
-    let mut h = Harness::new((400, 400));
-    // Every wrapper up to the outer pad read the size below it, so the outer
-    // pad is what draws again -- and the span it hands the box to is the same
-    // size as before, which is what lets a draw reuse its way past the leaf.
-    let (leaf, _) = counted(&mut h, Size::abs((100, 100).into()), OnResize::Redraw);
-    let padded = leaf.pad(10).add(&mut h.rsc);
-    let below = rect(Color::RED).add(&mut h.rsc);
-    h.set_root((padded, below).span(Dir::DOWN).pad(12));
-    assert_corners!(h, below, (12, 132), (388, 388));
-
-    h.rsc[leaf].size = Size::abs((100, 200).into());
-    h.frame();
-
-    assert_corners!(h, below, (12, 232), (388, 388));
-}
-
-/// Claims its drawing survives its box changing length, and has a child so
-/// that the walk looking for what does not has one to reach.
-struct Stretchy {
-    inner: StrongWidget,
-    draws: Rc<Cell<usize>>,
-}
-
-impl Widget for Stretchy {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
-        self.draws.set(self.draws.get() + 1);
-        painter.widget(&self.inner).size()
-    }
-
-    fn on_resize(&self, _: Axis) -> OnResize {
-        OnResize::Scale
-    }
-}
-
-#[test]
-fn stretching_a_subtree_carries_the_children_in_it() {
-    let mut h = Harness::new((400, 400));
-    let first = rect(Color::RED).height(40).add(&mut h.rsc);
-    let inner = rect(Color::BLUE).add(&mut h.rsc);
-    let draws = Rc::new(Cell::new(0));
-    let outer = Stretchy {
-        inner: inner.add_strong(&mut h.rsc),
-        draws: draws.clone(),
-    }
-    .add(&mut h.rsc);
-    h.set_root((first, outer).span(Dir::DOWN));
-    let settled = draws.get();
-    assert_corners!(h, inner, (0, 40), (400, 400));
-
-    h.rsc[first].y = Some(Len::abs(80));
-    h.frame();
-
-    assert_eq!(
-        draws.get(),
-        settled,
-        "its drawing follows its box, rather than being made again"
-    );
-    assert_corners!(h, outer, (0, 80), (400, 400));
-    assert_corners!(h, inner, (0, 80), (400, 400));
-}
-
-#[test]
-fn a_widened_row_redraws_what_reads_its_length_and_nothing_else() {
-    let mut h = Harness::new((400, 200));
-    // What a transcript row is: something whose shaping depends on the width
-    // it is given, beside something that only has to be the right shape.
-    let (wraps, wrap_draws) = counted(&mut h, Size::REST, OnResize::Redraw);
-    let (backing, back_draws) = counted(&mut h, Size::REST, OnResize::Scale);
-    let row = (backing, wraps).span(Dir::RIGHT).add(&mut h.rsc);
-    let bar = rect(Color::RED).width(100).add(&mut h.rsc);
-    h.set_root((bar, row).span(Dir::RIGHT));
-    let (settled_wrap, settled_back) = (wrap_draws.get(), back_draws.get());
-
-    h.rsc[bar].x = Some(Len::abs(200));
-    h.frame();
-
-    // The span reads every child's size, so redrawing one takes the span
-    // with it -- and the span then measures and places the redrawn child.
-    assert!(wrap_draws.get() > settled_wrap, "reads the width it got");
-    assert_eq!(back_draws.get(), settled_back, "only has to be the shape");
-    assert_corners!(h, backing, (200, 0), (300, 200));
-    assert_corners!(h, wraps, (300, 0), (400, 200));
-}
-
-#[test]
-fn a_declared_length_child_is_not_redrawn_when_the_box_around_it_grows() {
-    let mut h = Harness::new((400, 200));
-    // Its box is a fixed 80 wherever the row's edges end up, so drawing it
-    // again would be for a width it does not have. The declared width is what
-    // lets the span say that without drawing it: a width the span learnt by
-    // drawing the child in its own box is only an answer for that box.
-    let (counter, draws) = counted(&mut h, Size::from((80, 200)), OnResize::Redraw);
-    let fixed = counter.width(80).add(&mut h.rsc);
-    let (rest, _) = counted(&mut h, Size::REST, OnResize::Scale);
-    let row = (fixed, rest).span(Dir::RIGHT).add(&mut h.rsc);
-    let bar = rect(Color::RED).width(100).add(&mut h.rsc);
-    h.set_root((bar, row).span(Dir::RIGHT));
-    let settled = draws.get();
-
-    h.rsc[bar].x = Some(Len::abs(200));
-    h.frame();
-
-    assert_eq!(draws.get(), settled, "its own length did not change");
-    assert_corners!(h, fixed, (200, 0), (280, 200));
-}

tests/revision_cost.rs

@@ -1,22 +1,28 @@
-//! What a resize frame costs and what it holds, on a tree the revision before
-//! #16 also builds.
-//!
-//! Deliberately written in the API subset `43ce8c7` and this branch share, so
-//! 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.
+//! Text-layout workloads with stable paragraphs for comparisons across revisions.
+//! 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
+//! provide the same workload across the full PR.
 //!
 //!     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
-//! `perf stat -e instructions:u` on the test binary directly.
+//! `text_updates_cost` selects idle, repaint, edit, or scroll with `PHASE`.
+//! 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.
+
+mod rig;
 
 use iris::harness::Harness;
 use iris::prelude::*;
+use rig::env;
 use std::time::Instant;
 
 /// xorshift64, so one seed is one set of paragraphs on any machine.
@@ -78,13 +84,6 @@ fn words(rng: &mut Rng, least: usize, most: usize) -> String {
 
 const OUTPUT: (f32, f32) = (900.0, 1200.0);
 
-fn env<T: std::str::FromStr>(name: &str, fallback: T) -> T {
-    std::env::var(name)
-        .ok()
-        .and_then(|value| value.parse().ok())
-        .unwrap_or(fallback)
-}
-
 /// A row of a fixed-width rect beside a column of one wrapping and one
 /// overflowing text: the shape that makes a container measure a child in a
 /// box it will not keep.
@@ -96,7 +95,7 @@ fn build(h: &mut Harness, rows: usize) -> Vec<WidgetId> {
         let mut row = Span::empty(Dir::RIGHT);
         row.push(
             rect(Color::RED)
-                .width(Len::abs(40.0))
+                .width(LayoutLen::px(40.0))
                 .add_strong(&mut h.rsc),
         );
         let mut body = Span::empty(Dir::DOWN);
@@ -137,9 +136,10 @@ fn resize_cost() {
         println!("paragraph {at}: {:?}", h.region(id));
     }
 
-    // Two widths in turn is the friendly case for anything that remembers an
-    // answer, so `SWEEP=1` never repeats one -- a drag rather than a toggle.
+    // The sweep cycles 256 widths, avoiding the two-width cache-friendly case.
     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 +151,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 +199,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/rig/mod.rs

@@ -0,0 +1,25 @@
+//! What the rigs need and none of them should spell its own way. Every
+//! fuzzer and measurement here is run by hand with its parameters in the
+//! environment, so one reader is shared rather than copied into each target.
+
+/// A rig's parameter from the environment, or its default. A switch is
+/// `env("NAME", 0_u8) != 0`, so `NAME=1` turns it on.
+pub fn env<T: std::str::FromStr>(name: &str, fallback: T) -> T {
+    std::env::var(name)
+        .ok()
+        .and_then(|value| value.parse().ok())
+        .unwrap_or(fallback)
+}
+
+/// The seeds a scan runs: the one `one` names on its own, or `1..=` the
+/// count `many` gives. One seed replaces the range rather than narrowing
+/// it, which is how a tree a scan failed on is run again by itself.
+// This module is compiled into each rig target separately, so a helper the
+// measurement rigs have no seeds to choose is dead code in those builds.
+#[allow(dead_code)]
+pub fn seeds(one: &str, many: &str, count: u64) -> Vec<u64> {
+    match std::env::var(one).ok().and_then(|seed| seed.parse().ok()) {
+        Some(seed) => vec![seed],
+        None => (1..=env(many, count)).collect(),
+    }
+}

tests/scenario/mod.rs

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

tests/scroll.rs

@@ -1,26 +0,0 @@
-//! Scrolling moves content and stops at its ends.
-
-use iris::harness::{Harness, assert_corners};
-use iris::prelude::*;
-
-#[test]
-fn a_wheel_scrolls_the_content_and_stops_at_its_end() {
-    let mut h = Harness::new((400, 200));
-    // Twice the window's height, so there is 200 to scroll.
-    let top = rect(Color::RED).height(200).add(&mut h.rsc);
-    let bottom = rect(Color::BLUE).height(200).add(&mut h.rsc);
-    h.set_root((top, bottom).span(Dir::DOWN).scrollable());
-    h.move_to((200, 100));
-
-    // `Scroll` starts snapped to the end.
-    assert_corners!(h, top, (0, -200), (400, 0));
-
-    // The handler scales a wheel line by 50.
-    h.scroll((0, 1));
-    h.frame();
-    assert_corners!(h, top, (0, -150), (400, 50));
-
-    h.scroll((0, 10));
-    h.frame();
-    assert_corners!(h, top, (0, 0), (400, 200));
-}

tests/shrink.rs

@@ -0,0 +1,99 @@
+//! A fuzzer that reduces its own counterexample.
+//!
+//! A seed is not a lead anybody can read: the tree is hundreds of widgets,
+//! and reconstructing the part that matters by hand has failed every time it
+//! has been tried. This grows the trees `iris::random` describes, takes them
+//! apart, and prints the smallest one that still fails as something to write
+//! a fast test from.
+//!
+//!     cargo test --release --test shrink -- --ignored --nocapture
+//!
+//! `SHRINK_SEEDS` how many trees to try, `SHRINK_DEPTH` how deep to grow
+//! them, `SHRINK_CASE` which scenario or `all` for every one. `SHRINK_SEED`
+//! takes a single seed, which is how a failure `generated` printed is handed
+//! straight here: the two run the same cases over the same trees, so a seed
+//! that fails there fails here and is reduced.
+//!
+//! It is a fuzzer: run it once the ordinary tests pass, and turn what it
+//! finds into a test of its own rather than leaving a seed as the record.
+
+mod rig;
+#[path = "scenario/mod.rs"]
+mod scenario;
+
+use iris::random::{Edits, Plan, plan};
+use rig::env;
+use scenario::{ALL, Case, diverges, over_seeds};
+
+/// Takes the first simplification that still fails, until none does. The
+/// simplifications come biggest first, so this walks down rather than
+/// nibbling: a six-hundred-widget tree reaches single figures in a few
+/// hundred builds.
+fn shrink(mut node: Plan, case: Case, seed: u64) -> Plan {
+    loop {
+        let Some(next) = node
+            .smaller()
+            .into_iter()
+            .find(|small| diverges(small, case, seed).is_some())
+        else {
+            return node;
+        };
+        node = next;
+    }
+}
+
+fn cases() -> Vec<Case> {
+    match env("SHRINK_CASE", String::from("all")).as_str() {
+        "all" => ALL.to_vec(),
+        name => match Case::named(name) {
+            Some(case) => vec![case],
+            None => panic!(
+                "unknown SHRINK_CASE {name:?}; one of all, {}",
+                ALL.map(Case::name).join(", ")
+            ),
+        },
+    }
+}
+
+#[test]
+#[ignore = "a fuzzer; run it once the ordinary tests pass"]
+fn no_grown_tree_lays_out_differently_warm_than_cold() {
+    let depth: usize = env("SHRINK_DEPTH", 5);
+    let cases = cases();
+    let seeds = rig::seeds("SHRINK_SEED", "SHRINK_SEEDS", 400);
+    let count = seeds.len();
+
+    over_seeds(seeds, |seed| {
+        let grown = plan(seed, depth, &Edits::default());
+        for &case in &cases {
+            if diverges(&grown, case, seed).is_none() {
+                continue;
+            }
+            let small = shrink(grown.clone(), case, seed);
+            // Described from the shrunk tree: the grown tree's chain names
+            // widgets that are no longer there, and the ancestry of the
+            // failure is what a test is written from.
+            let how = diverges(&small, case, seed).unwrap_or_default();
+            println!(
+                "seed {seed} case {}: {how}\ngrown {} widgets, shrank to {}\n{small:#?}",
+                case.name(),
+                grown.size(),
+                small.size()
+            );
+            panic!(
+                "seed {seed} lays out differently warm than cold after {}",
+                case.name()
+            );
+        }
+    });
+
+    let sizes: Vec<usize> = (1..=count as u64)
+        .map(|seed| plan(seed, depth, &Edits::default()).size())
+        .collect();
+    println!(
+        "{count} trees at depth {depth} agree over {} case(s): {} widgets total, largest {}",
+        cases.len(),
+        sizes.iter().sum::<usize>(),
+        sizes.iter().max().copied().unwrap_or(0)
+    );
+}

tests/suite.rs

@@ -0,0 +1,36 @@
+//! Every ordinary correctness test, as modules of one target.
+//!
+//! One binary rather than a dozen: each `tests/*.rs` links the whole
+//! dependency graph again, which is most of what `cargo test` spends its time
+//! on here. Libtest still runs the cases in parallel, and a filter still
+//! selects them -- `cargo test --test suite layout::` for one module.
+//!
+//! The rigs stay their own targets: `shrink` and `generated` are fuzzers run
+//! on their own, and the `*_cost` and `*_diagnostics` ones are measurements.
+
+#[path = "cases/deferred.rs"]
+mod deferred;
+#[path = "cases/determinism.rs"]
+mod determinism;
+#[path = "cases/drift.rs"]
+mod drift;
+#[path = "cases/idempotence.rs"]
+mod idempotence;
+#[path = "cases/layout.rs"]
+mod layout;
+#[path = "cases/plan.rs"]
+mod plan;
+#[path = "cases/pointer.rs"]
+mod pointer;
+#[path = "cases/pointer_routing.rs"]
+mod pointer_routing;
+#[path = "cases/retained.rs"]
+mod retained;
+#[path = "cases/scroll.rs"]
+mod scroll;
+#[path = "cases/tasks.rs"]
+mod tasks;
+#[path = "cases/text_edit.rs"]
+mod text_edit;
+#[path = "cases/unsettled.rs"]
+mod unsettled;

tests/trace_unsettled.rs

@@ -0,0 +1,126 @@
+//! Traces the four-widget trees in `unsettled.rs`, to see what box their text
+//! is actually drawn in on a first frame against a settled one.
+
+#![cfg(feature = "layout-diagnostics")]
+
+use iris::core::layout_diagnostics::{self as diag, TraceEvent};
+use iris::harness::Harness;
+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)
+        .width(76)
+        .add(&mut h.rsc);
+    h.rsc
+        .widgets_mut()
+        .set_alignment(wrapped, Axis::X, AxisAlign::POS);
+    h.rsc
+        .widgets_mut()
+        .set_alignment(wrapped, Axis::Y, AxisAlign::POS);
+    let stack = Stack {
+        children: vec![plain.add_strong(&mut h.rsc), wrapped.add_strong(&mut h.rsc)],
+        size: StackSize::Child(0),
+    }
+    .add(&mut h.rsc);
+    let root = (stack,).span(Dir::RIGHT).add(&mut h.rsc);
+    h.state.root = Some(root.add_strong(&mut h.rsc));
+    vec![plain.id(), wrapped.id(), stack.id(), root.id()]
+}
+
+fn dump(label: &str, report: &diag::Report, text: WidgetId) {
+    println!("--- {label} ---");
+    for event in report.traces() {
+        match event {
+            TraceEvent::DrawRequest {
+                id,
+                region,
+                region_px,
+                ..
+            } if *id == text => {
+                println!(
+                    "  draw in {:.2}x{:.2}  region {region:?}",
+                    region_px.x, region_px.y
+                )
+            }
+            TraceEvent::SizeReported { id, size } if *id == text => {
+                println!("  reported {size}")
+            }
+            TraceEvent::SizeRead { id, reader, size } if *id == text => {
+                println!("  size read by {reader:?}: {size}")
+            }
+            TraceEvent::RegionNode { id, parent, region } if *id == text => {
+                println!("  region node under {parent:?} at {region:?}")
+            }
+            TraceEvent::Reuse { id, outcome } if *id == text => println!("  reuse: {outcome:?}"),
+            _ => {}
+        }
+    }
+}
+
+#[test]
+#[ignore = "a diagnostic, not a check"]
+fn what_box_the_text_is_drawn_in() {
+    diag::clear_traced_widgets();
+    let _ = diag::take();
+    let mut h = Harness::new((640, 900));
+    let ids = plant(&mut h);
+    let text = ids[1];
+    diag::trace_widget(text);
+    let _ = diag::take();
+
+    h.frame();
+    dump("first frame", &diag::take(), text);
+
+    for _ in 0..2 {
+        for &id in &ids {
+            h.rsc.widgets_mut().mark_for_redraw(id);
+        }
+        let _ = diag::take();
+        h.frame();
+        dump("repaint", &diag::take(), text);
+    }
+    diag::clear_traced_widgets();
+}
+
+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);
+    h.rsc
+        .widgets_mut()
+        .set_alignment(text, Axis::X, AxisAlign::NEG);
+    let inner = (text,).span(Dir::RIGHT).sized((189, 176)).add(&mut h.rsc);
+    let filler = rect(Color::RED).add(&mut h.rsc);
+    let root = (filler, inner).span(Dir::RIGHT).add(&mut h.rsc);
+    h.state.root = Some(root.add_strong(&mut h.rsc));
+    vec![text.id(), inner.id(), filler.id(), root.id()]
+}
+
+#[test]
+#[ignore = "a diagnostic, not a check"]
+fn what_box_the_fixed_text_is_drawn_in() {
+    diag::clear_traced_widgets();
+    let _ = diag::take();
+    let mut h = Harness::new((1920, 1200));
+    let ids = plant_fixed(&mut h);
+    let text = ids[0];
+    diag::trace_widget(text);
+    let _ = diag::take();
+
+    h.frame();
+    dump("first frame at 1920", &diag::take(), text);
+    h.resize((640, 900));
+    h.frame();
+    dump("after resize to 640", &diag::take(), text);
+
+    let mut cold = Harness::new((640, 900));
+    let cids = plant_fixed(&mut cold);
+    diag::clear_traced_widgets();
+    diag::trace_widget(cids[0]);
+    let _ = diag::take();
+    cold.frame();
+    dump("cold at 640", &diag::take(), cids[0]);
+    diag::clear_traced_widgets();
+}