Re-ask a dirty widget at its offer locally instead of deferring to its parent

A local redraw refused any widget whose given box was not as long as its
offer and marked its parent instead. Under the frame/extent protocol that
is nearly every widget beneath a self-sized container: a span hands its
children its own placement across itself, which is `FULL` while the span
is measured and its answer once it is placed, so the children's offer and
given frames differ on every such axis. A `many` frame at seed 13, depth
8 escalated 43 marks along chains up to seven levels and redrew 508 of
583 active widgets where e44dea3 redraws 159.

Retain the offer's frame beside the given one and ask the offer question
locally: the offer frame composed where the given one is, at the offer's
lengths and placement, then place at the given box where the two differ.
Seed 13 `many` goes from 4.73 ms to 1.28 ms against e44dea3's 0.90, and
294 distinct widgets a frame; size, scroll and repaint are unchanged.

Not sound yet: the suite, the debug oracle and the shrinker at 400 trees
of depth 5 pass, but the oracle at 1000 seeds of depth 6 diverges on seed
532 under reorder and seed 398 under every-size. Both reduce to a
self-sized container whose answer changes under a local redraw; the
reduced plans are in docs/HANDOFF.md of ai-app-2.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

core/src/ui/active.rs

@@ -1,6 +1,6 @@
 use crate::{
-    LayerId, LayoutHolds, LayoutLen, MaskIdx, MoveIdx, Place, RegionAlign, RetainedPrimitive, Size,
+    DrawRegion, LayerId, LayoutHolds, LayoutLen, MaskIdx, MoveIdx, RegionAlign, RetainedPrimitive,
-    TextureHandle, UiRegion, WidgetId,
+    Size, TextureHandle, UiRegion, UiVec2, WidgetId,
 };
 
 /// What is kept of a widget its parent has asked about. `drawn` says whether
@@ -9,35 +9,31 @@ use crate::{
 #[derive(Debug)]
 pub struct ActiveData {
     pub id: WidgetId,
-    /// Its frame in `parent_move`'s coordinates: what a fraction it declares
+    /// The box its parent gave it, in `parent_move`'s coordinates: what it
-    /// or reports is a fraction of, composed. Everything it draws sits inside
+    /// was asked about, and what a fraction under it is a fraction of. A
-    /// this by way of `extent`.
+    /// local redraw asks here.
-    pub frame_abs: UiRegion,
+    pub region: UiRegion,
-    /// Where its drawing goes, in the frame's own coordinates.
+    /// Where its drawing sits inside that box, in the box's own coordinates.
-    pub extent: UiRegion,
+    pub placement: UiRegion,
-    /// That frame in its parent's frame coordinates, before composition:
+    /// The original frame in its parent widget's coordinates. Recomposition
-    /// forwarded whole by a transparent container, narrowed by a declared
+    /// and pixel-length evaluation both follow this chain.
-    /// length or an inset. Its length is the same on every ask, which is what
+    pub given_region: UiRegion,
-    /// a local redraw relies on to ask its parent's own question again.
+    /// The frame it was first asked in, in the same coordinates: the offer's
-    pub frame: UiRegion,
+    /// frame, which its parent's placing draw may since have narrowed.
-    /// What of its parent's extent the drawing was given, and what it was
+    pub offer_region: UiRegion,
-    /// given at the parent's first ask of it -- the question a cold layout
+    /// The lengths of the box its parent first asked about it in, as
-    /// asks. A part is a length from the extent's start, so an extent that
+    /// lengths of the box the parent was itself offered. Any later box it
-    /// moved re-places every child by re-adding that start.
+    /// was given was decided knowing its answer, so this is the question
-    pub place: [Place; 2],
+    /// asked again -- and a chain of fractions has no frame in it, which is
-    pub offer_place: [Place; 2],
+    /// why a region node between two widgets cannot break it.
-    /// The box that ask gave it, in its frame's coordinates. Kept rather
+    pub offer_len: UiVec2,
-    /// than worked out again from where its parent's own box is now: a
+    pub offer_placement: [Option<crate::UiSpan>; 2],
-    /// parent drawn again in the box its own answer chose gives its children
-    /// boxes it never measured anything in, and the measurement this widget
-    /// answered is the one its parent's layout was built on.
-    pub offer_part: UiRegion,
     /// The measured answer and its dependencies. A hint-only dependency or
     /// a widget first encountered during placement has no measurement yet.
     pub answer: Option<(Size, LayoutHolds)>,
-    /// What the widget said it used of its frame, the last time it drew.
+    /// What the widget said it used of its box, the last time it drew.
     pub size: Size,
-    /// The frame and extent reads that this drawing holds for.
+    /// The frame, extent and explicit placement reads that this drawing holds for.
     pub holds: LayoutHolds,
     pub drawn: bool,
     pub parent: Option<WidgetId>,
@@ -46,24 +42,30 @@ pub struct ActiveData {
     /// widget a frame visits and cannot drift while one is being drawn.
     pub depth: usize,
     pub textures: Vec<TextureHandle>,
-    /// Its primitives, each keeping the box it was written in -- in this
-    /// widget's extent coordinates, which is what a move recomposes from.
     pub primitives: Vec<RetainedPrimitive>,
-    pub mask_region: Option<UiRegion>,
+    pub mask_region: Option<DrawRegion>,
+    /// The children whose box is a part of this widget's extent rather than
+    /// of its frame, and which part each was given. Moving the extent
+    /// re-places them through that part, so the drawing need not depend on
+    /// where it sits.
+    pub(crate) extent_children: Vec<(WidgetId, ExtentPlacement)>,
     pub children: Vec<WidgetId>,
     /// The children whose size this widget read while drawing.
     pub size_deps: Vec<WidgetId>,
     /// The movable region its primitives are positioned through: its own when
     /// opted in, otherwise the nearest ancestor's.
     pub move_idx: MoveIdx,
-    /// The declared lengths whoever drew this widget resolved into its frame.
+    /// The declared lengths whoever drew this widget resolved into its box.
     /// A change to one moves a box this widget cannot fix by drawing again,
     /// and comparing them is what says so.
     pub declared: [Option<LayoutLen>; 2],
+    /// The axes along which its parent chose its box from its own answer,
+    /// so a local redraw asks the question its parent asked.
+    pub decided: [bool; 2],
     /// 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 `frame_abs` uses.
+    /// The movable region whose coordinates `region` uses.
     pub parent_move: MoveIdx,
     /// The mask its drawing is clipped to: one it set itself, or the one it
     /// inherited from whoever drew it.
@@ -77,12 +79,37 @@ pub struct ActiveData {
 }
 
 impl ActiveData {
-    /// Whether what it answered still stands for a frame of these pixel
+    /// Whether what it answered still stands for a box of these pixel
-    /// lengths. The answer was given in the box its parent first asked
+    /// lengths -- the box it was asked in, where `holds` is about the box its
-    /// about, which is what it is checked against -- `holds` on the record
+    /// answer then chose.
-    /// is about the box the answer then chose.
+    pub fn answers_at(&self, px: crate::PxVec2) -> bool {
-    pub fn answers_at(&self, px: crate::PxVec2, part: UiRegion) -> bool {
+        self.answer.is_some_and(|(_, holds)| {
-        self.answer
+            holds.contains(
-            .is_some_and(|(_, holds)| holds.contains(px, part))
+                px,
+                UiRegion {
+                    x: self.offer_placement[0].unwrap_or(crate::UiSpan::FULL),
+                    y: self.offer_placement[1].unwrap_or(crate::UiSpan::FULL),
+                },
+            )
+        })
+    }
+}
+
+/// What of a container's extent a child was given: the whole of it, for a
+/// wrapper whose box is its child's, or a part of it.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(crate) enum ExtentPlacement {
+    Inherit,
+    Within(UiRegion),
+}
+
+impl ExtentPlacement {
+    /// The child's frame in the container's frame coordinates, and the slot
+    /// the container chose within it.
+    pub fn resolve(self, extent: UiRegion) -> (UiRegion, [Option<crate::UiSpan>; 2]) {
+        match self {
+            Self::Inherit => (UiRegion::FULL, [Some(extent.x), Some(extent.y)]),
+            Self::Within(part) => (part.within(&extent), [None; 2]),
+        }
     }
 }

core/src/ui/draw_region.rs

@@ -0,0 +1,36 @@
+use crate::{PrimitiveHandle, UiRegion};
+
+/// Retains which box geometry follows when only the extent changes.
+#[derive(Clone, Copy, Debug)]
+pub enum DrawRegion {
+    Frame(UiRegion),
+    Extent(UiRegion),
+}
+
+impl DrawRegion {
+    pub(crate) fn resolve(self, frame: UiRegion, extent: UiRegion) -> UiRegion {
+        match self {
+            Self::Frame(local) => local.within(&frame),
+            Self::Extent(local) => local.within(&extent).within(&frame),
+        }
+    }
+
+    pub(crate) fn map(self, f: impl FnOnce(UiRegion) -> UiRegion) -> Self {
+        match self {
+            Self::Frame(local) => Self::Frame(f(local)),
+            Self::Extent(local) => Self::Extent(f(local)),
+        }
+    }
+}
+
+impl From<UiRegion> for DrawRegion {
+    fn from(region: UiRegion) -> Self {
+        Self::Frame(region)
+    }
+}
+
+#[derive(Debug)]
+pub struct RetainedPrimitive {
+    pub handle: PrimitiveHandle,
+    pub region: DrawRegion,
+}

core/src/ui/layout_holds.rs

@@ -1,62 +1,63 @@
-use crate::{Axis, Holds, Len, PxVec2, UiRegion};
+use crate::{Axis, Holds, PxVec2, UiRegion};
 
-const AXES: [Axis; 2] = [Axis::X, Axis::Y];
+/// Dependencies of one evaluation, before the frame and extent are composed.
-
-/// What one evaluation of a widget depends on: the pixel lengths of its
-/// frame and of its own box that its drawing and its answer hold for, and
-/// the symbolic length of its own box where it read one.
-///
-/// The symbolic length is a pin rather than a range: a container places its
-/// children as lengths of its frame measured from where its own box starts,
-/// so what it draws turns on that box's length and on nothing about where it
-/// is. It does not compose into the parent -- a widget pinned this way is
-/// checked when it is re-placed.
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub struct LayoutHolds {
     pub frame: [Holds; 2],
     pub extent: [Holds; 2],
-    pub extent_len: [Option<Len>; 2],
+    pub placement: Option<UiRegion>,
 }
 
 impl LayoutHolds {
     pub const ANY: Self = Self {
         frame: [Holds::ANY; 2],
         extent: [Holds::ANY; 2],
-        extent_len: [None; 2],
+        placement: None,
     };
 
     pub fn and(self, other: Self) -> Self {
-        let mut result = Self::ANY;
+        debug_assert!(
-        for n in 0..2 {
+            self.placement.is_none()
-            result.frame[n] = self.frame[n].and(other.frame[n]);
+                || other.placement.is_none()
-            result.extent[n] = self.extent[n].and(other.extent[n]);
+                || self.placement == other.placement
-            debug_assert!(
+        );
-                self.extent_len[n].is_none()
+        Self {
-                    || other.extent_len[n].is_none()
+            frame: [
-                    || self.extent_len[n] == other.extent_len[n]
+                self.frame[0].and(other.frame[0]),
-            );
+                self.frame[1].and(other.frame[1]),
-            result.extent_len[n] = self.extent_len[n].or(other.extent_len[n]);
+            ],
+            extent: [
+                self.extent[0].and(other.extent[0]),
+                self.extent[1].and(other.extent[1]),
+            ],
+            placement: self.placement.or(other.placement),
         }
-        result
     }
 
     pub fn covers(self, other: Self) -> bool {
-        (0..2).all(|n| {
+        self.placement
-            self.frame[n].lo <= other.frame[n].lo
+            .is_none_or(|placement| other.placement == Some(placement))
-                && self.frame[n].hi >= other.frame[n].hi
+            && [0, 1].into_iter().all(|n| {
-                && self.extent[n].lo <= other.extent[n].lo
+                self.frame[n].lo <= other.frame[n].lo
-                && self.extent[n].hi >= other.extent[n].hi
+                    && self.frame[n].hi >= other.frame[n].hi
-                && self.extent_len[n].is_none_or(|len| other.extent_len[n] == Some(len))
+                    && self.extent[n].lo <= other.extent[n].lo
-        })
+                    && self.extent[n].hi >= other.extent[n].hi
+            })
     }
 
-    pub fn contains(self, px: PxVec2, extent: UiRegion) -> bool {
+    pub fn contains(self, px: PxVec2, placement: UiRegion) -> bool {
-        AXES.into_iter().all(|axis| {
+        self.placement.is_none_or(|old| old == placement)
-            let n = axis as usize;
+            && [Axis::X, Axis::Y].into_iter().all(|axis| {
-            let len = extent.axis(axis).len();
+                self.frame[axis as usize].contains(px.axis(axis))
-            self.frame[n].contains(px.axis(axis))
+                    && self.extent[axis as usize]
-                && self.extent[n].contains(len.to_px(px.axis(axis)))
+                        .contains(placement.axis(axis).len().to_px(px.axis(axis)))
-                && self.extent_len[n].is_none_or(|pinned| pinned == len)
+            })
+    }
+
+    pub fn in_frame(self, placement: UiRegion) -> [Holds; 2] {
+        [Axis::X, Axis::Y].map(|axis| {
+            self.frame[axis as usize]
+                .and(self.extent[axis as usize].through(placement.axis(axis).len()))
         })
     }
 }

core/src/ui/mod.rs

@@ -10,17 +10,17 @@ use crate::{
 pub const CHAIN_LIMIT: u32 = 64;
 
 mod active;
+mod draw_region;
 mod holds;
 mod layout_holds;
 mod painter;
-mod place;
 mod render_state;
 
 pub use active::*;
+pub use draw_region::*;
 pub use holds::*;
 pub use layout_holds::*;
 pub use painter::{Painter, PrimitiveLike};
-pub use place::*;
 pub use render_state::*;
 
 #[derive(Default)]

core/src/ui/painter.rs

@@ -1,9 +1,9 @@
 #[cfg(feature = "layout-diagnostics")]
 use crate::layout_diagnostics::{self as diag, Counter};
 use crate::{
-    Axis, Holds, LayoutHolds, LayoutLen, Len, Part, Place, Px, PxVec2, RegionAlign, RenderedText,
+    Axis, DrawRegion, ExtentPlacement, Holds, LayoutHolds, LayoutLen, Len, Px, PxVec2, RegionAlign,
-    RetainedPrimitive, Size, StrongWidget, TextAttrs, TextBuffer, TextData, TextureHandle,
+    RenderedText, RetainedPrimitive, Size, StrongWidget, TextAttrs, TextBuffer, TextData,
-    UiRegion, UiRenderState, UiRsc, UiSpan, UiVec2, Weight, WidgetId, Widgets,
+    TextureHandle, UiRegion, UiRenderState, UiRsc, UiSpan, UiVec2, Weight, WidgetId, Widgets,
     render::{
         GlyphPrimitive, Mask, MaskIdx, MoveIdx, Primitive, PrimitiveInst, PrimitiveKind,
         TexturePrimitive,
@@ -17,47 +17,49 @@ pub struct Painter<'a> {
     pub(super) state: &'a mut UiRenderState,
     pub(super) rsc: &'a mut dyn UiRsc,
 
-    /// What a fraction this widget declares or reports is a fraction of, in
+    /// The box its parent gave it, in the coordinates of `move_idx`: what a
-    /// the coordinates of `move_idx`: forwarded from its parent unchanged
+    /// fraction of this widget's area is a fraction of, and what every region
-    /// through a span, a stack or a scroll, and narrowed only by what was
+    /// it writes composes within. The same box on the ask that measures and
-    /// decided above it -- a declared length, an inset, the root. Its length
+    /// the ask that places, which is what keeps a fraction under it from
-    /// is the same on every ask of the widget, which is what keeps a fraction
+    /// being resolved twice.
-    /// under it from being resolved twice.
+    pub(super) region: UiRegion,
-    pub(super) frame: UiRegion,
+    /// Where this widget's drawing sits inside that box, in the box's own
-    /// Where this widget's drawing goes, in the frame's own coordinates.
+    /// coordinates: `FULL` while its answer is not yet known, and the box
-    /// Everything it writes is in these coordinates, and its children are
+    /// its answer or its parent chose once one of them has.
-    /// placed as parts of it.
+    pub(super) placement: UiRegion,
-    pub(super) extent: UiRegion,
+    /// Whether this draw read its placement, which makes the drawing one
-    /// The extent's symbolic length where this draw read it, which makes the
+    /// that holds for that placement alone -- the way reading a length in
-    /// drawing one that holds for that length alone -- the way reading a
+    /// pixels makes it hold for that length.
-    /// length in pixels makes it hold for that number of pixels.
+    pub(super) reads_placement: bool,
-    pub(super) extent_len: [Option<Len>; 2],
+    /// That box in pixels, which its children's are a length of: threaded
-    /// The frame in pixels, which its children's frames are a length of:
+    /// down from the box this widget was given rather than composed back up
-    /// threaded down rather than composed back up the chain, so every length
+    /// the chain, so every length in layout is one multiply from its
-    /// in layout is one multiply from its parent's and [`Holds::through`]
+    /// parent's and [`Holds::through`] inverts exactly that.
-    /// inverts exactly that.
     pub(super) px: PxVec2,
     pub(super) mask: MaskIdx,
     pub(super) textures: Vec<TextureHandle>,
     pub(super) primitives: Vec<RetainedPrimitive>,
-    pub(super) mask_region: Option<UiRegion>,
+    pub(super) mask_region: Option<DrawRegion>,
+    pub(super) extent_children: Vec<(WidgetId, ExtentPlacement)>,
+    pub(super) extent_own: [Holds; 2],
     /// Only children whose answers were read constrain this widget's answer.
     pub(super) answer_under: LayoutHolds,
     pub(super) children: Vec<WidgetId>,
-    /// The children asked about so far, so the first place each was asked in
+    /// The children asked about so far, so the first box each was asked in
     /// is the one recorded as its offer.
     pub(super) offered: Vec<WidgetId>,
-    /// Whether this draw is at the place its parent first asked about, which
+    /// The lengths of the box this widget was first asked about in, in
-    /// makes the questions it asks the ones a cold layout asks and their
+    /// pixels. Its children's offers are a fraction of it.
-    /// answers the ones to keep.
+    pub(super) offered_px: PxVec2,
+    /// Whether this draw is in a box of those lengths, which makes the
+    /// questions it asks the ones a cold layout asks and their answers the
+    /// ones to keep.
     pub(super) at_offer: bool,
     /// The children whose size this widget read while drawing.
     pub(super) size_deps: Vec<WidgetId>,
-    /// What this draw itself read of its frame in pixels, per axis: every
+    /// What this draw itself read of its box in pixels, per axis: every
     /// length until it reads one, then that one, unless it says otherwise.
     pub(super) own: [Holds; 2],
-    /// The same for its extent.
-    pub(super) extent_own: [Holds; 2],
     /// Dependencies of every child drawing, including unmeasured overlays.
     pub(super) under: LayoutHolds,
     /// The movable region this widget's primitives are positioned through:
@@ -72,29 +74,26 @@ pub struct Painter<'a> {
 }
 
 impl<'a> Painter<'a> {
-    fn primitive_at<P: Primitive>(&mut self, primitive: P, region: UiRegion) {
+    fn primitive_at<P: Primitive>(&mut self, primitive: P, region: DrawRegion) {
         let kind = self.rsc.ui_mut().primitives.kind::<P>();
         self.write(kind, primitive, region);
     }
 
     /// Takes the kind, for a caller writing many of one primitive.
-    fn write<P: Primitive>(&mut self, kind: PrimitiveKind<P>, primitive: P, region: UiRegion) {
+    fn write<P: Primitive>(&mut self, kind: PrimitiveKind<P>, primitive: P, region: DrawRegion) {
-        self.write_resolved(kind, primitive, region, self.resolve(region));
+        self.write_resolved(
-    }
+            kind,
-
+            primitive,
-    /// A box in this widget's extent coordinates, composed into the
+            region,
-    /// coordinates its move slot is in: through the extent, then through the
+            region.resolve(self.region, self.placement),
-    /// frame the extent is a part of. The same two steps a recomposition
+        );
-    /// replays, so a moved drawing lands where a cold one does.
-    fn resolve(&self, region: UiRegion) -> UiRegion {
-        region.within(&self.extent).within(&self.frame)
     }
 
     fn write_resolved<P: Primitive>(
         &mut self,
         kind: PrimitiveKind<P>,
         primitive: P,
-        region: UiRegion,
+        region: DrawRegion,
         resolved: UiRegion,
     ) {
         #[cfg(feature = "layout-diagnostics")]
@@ -123,70 +122,135 @@ impl<'a> Painter<'a> {
 
     /// Writes a primitive over the whole of this widget's own box.
     pub fn primitive(&mut self, primitive: impl PrimitiveLike) {
+        let at = DrawRegion::Extent(UiRegion::FULL);
         let primitive = primitive.into_primitive(self);
-        self.primitive_at(primitive, UiRegion::FULL)
+        self.primitive_at(primitive, at)
     }
 
-    /// Writes a primitive in a part of this widget's own box, in that box's
+    /// Writes in the frame by default. `DrawRegion::Extent` keeps the local
-    /// coordinates.
+    /// geometry attached to this widget's box without reading its placement.
-    pub fn primitive_within(&mut self, primitive: impl PrimitiveLike, region: UiRegion) {
+    pub fn primitive_within(
+        &mut self,
+        primitive: impl PrimitiveLike,
+        region: impl Into<DrawRegion>,
+    ) {
         let primitive = primitive.into_primitive(self);
-        self.primitive_at(primitive, region);
+        self.primitive_at(primitive, region.into());
     }
 
-    /// Sets a mask, in this widget's own box's coordinates.
+    /// Sets a mask in the selected frame or extent coordinates.
-    pub fn set_mask(&mut self, region: UiRegion) {
+    pub fn set_mask(&mut self, region: impl Into<DrawRegion>) {
+        let region = region.into();
         self.mask_region = Some(region);
         assert!(self.mask == MaskIdx::NONE);
-        let resolved = self.resolve(region);
-        let move_idx = self.move_idx;
         self.mask = self.rsc.ui_mut().masks.push(Mask {
-            region: resolved,
+            region: region.resolve(self.region, self.placement),
-            move_idx,
+            move_idx: self.move_idx,
         });
     }
 
-    /// Draws a widget in the whole of this widget's own box, with the frame
+    /// Draws a widget in the whole of this widget's own box: it gets the
-    /// forwarded unchanged: what a container that is only a wrapper around
+    /// same region -- the same area for its fractions to be of -- and is put
-    /// one child wants, and what every transparent container passes for the
+    /// where this widget was put. What a container that is only a wrapper
-    /// frame.
+    /// around one child wants, since its box is the child's.
     pub fn widget<'s, W: ?Sized>(&'s mut self, id: &'s StrongWidget<W>) -> DrawResult<'s, 'a, W> {
-        self.widget_at(id, UiRegion::FULL, [Place::Within(Part::All); 2])
+        let own = self.placement;
+        self.widget_at_inner(
+            id,
+            UiRegion::FULL,
+            [Some(own.x), Some(own.y)],
+            Some(ExtentPlacement::Inherit),
+            false,
+        )
     }
 
-    /// Draws a child, saying what its fractions are of and where its drawing
+    /// What a widget's rules declare its lengths to be, which whoever draws
-    /// goes.
+    /// it resolves into its box. Reading them depends on nothing -- the box
+    /// that comes of them is kept on the child, and `redraw` compares it
+    /// there.
+    fn declared_lens<W: ?Sized>(&self, id: &StrongWidget<W>) -> [Option<LayoutLen>; 2] {
+        declared_lens(self.rsc.widgets(), id.id())
+    }
+
+    /// Takes back a child that was drawn only to find out how long it is.
+    /// Its drawing is dropped and it is not one of this widget's children
+    /// this frame; what it answered is still something this widget asked.
+    pub fn undraw<W: ?Sized>(&mut self, id: &StrongWidget<W>) {
+        self.children.retain(|child| *child != id.id());
+        self.extent_children.retain(|(child, _)| *child != id.id());
+        self.state.undraw_rec(id.id(), self.rsc);
+    }
+
+    /// Draws a child in `region`, relative to this widget's frame. The child
+    /// resolves declared lengths and reports against that frame, then places
+    /// its drawing by its own alignment.
     ///
-    /// `frame` is that reference, in this widget's own frame coordinates:
+    /// `DrawRegion::Extent` gives a part of where this widget's drawing sits
-    /// [`UiRegion::FULL`] forwards this widget's frame, which is what a
+    /// instead, for a container whose children belong inside that rather than
-    /// container that only divides room passes, so a fraction under it means
+    /// inside the box it was offered. The part is what is kept, so moving the
-    /// the same wherever it sits and however deeply it is nested. Narrowing
+    /// extent re-places the child rather than drawing this widget again.
-    /// it is for what is decided from above -- an inset's margins -- and a
+    pub fn widget_within<'s, W: ?Sized>(
-    /// declared length narrows it here.
+        &'s mut self,
+        id: &'s StrongWidget<W>,
+        region: impl Into<DrawRegion>,
+    ) -> DrawResult<'s, 'a, W> {
+        match region.into() {
+            DrawRegion::Frame(region) => self.widget_at(id, region, [None; 2]),
+            DrawRegion::Extent(part) => {
+                let within = part.within(&self.placement);
+                self.widget_at_inner(
+                    id,
+                    within,
+                    [None; 2],
+                    Some(ExtentPlacement::Within(part)),
+                    false,
+                )
+            }
+        }
+    }
+
+    /// Draws a widget in `region`, saying where in it the drawing goes.
     ///
-    /// `place` is where the drawing goes, per axis, as a part of this
+    /// `region` is the child's own area: what a fraction it declares or
-    /// widget's extent: see [`Place`]. A narrowed frame is its own extent,
+    /// reports is a fraction of, and the coordinates the regions it writes
-    /// since the narrowing is what said where the drawing goes.
+    /// compose within. It is the same box on the ask that measures and the
+    /// ask that places, which is what stops a fraction under it being
+    /// resolved twice.
+    ///
+    /// `placement` is what of that region the child's drawing takes, per
+    /// axis, wherever this widget is choosing. `None` leaves the axis to the
+    /// child's own answer and alignment, which is what
+    /// [`Self::widget_within`] passes. A span passes the whole row as the
+    /// region, so `rel(0.5)` is half the row wherever the child sits in it,
+    /// and places the child by passing the slot along its axis.
     pub fn widget_at<'s, W: ?Sized>(
         &'s mut self,
         id: &'s StrongWidget<W>,
-        frame: UiRegion,
+        region: UiRegion,
-        place: [Place; 2],
+        placement: [Option<UiSpan>; 2],
     ) -> DrawResult<'s, 'a, W> {
+        self.widget_at_inner(id, region, placement, None, false)
+    }
+
+    fn widget_at_inner<'s, W: ?Sized>(
+        &'s mut self,
+        id: &'s StrongWidget<W>,
+        region: UiRegion,
+        placement: [Option<UiSpan>; 2],
+        extent: Option<ExtentPlacement>,
+        measuring: bool,
+    ) -> DrawResult<'s, 'a, W> {
+        self.extent_children.retain(|(child, _)| *child != id.id());
+        if let Some(extent) = extent {
+            self.extent_children.push((id.id(), extent));
+        }
         let region_node = self.rsc.widgets().is_region_node(id.id());
         let declared = self.declared_lens(id);
         let align = self.rsc.widgets().alignment(id.id());
-        let narrow = AXES.map(|axis| {
+        let (local, placement) = ask_box(region, declared, align, placement);
-            let n = axis as usize;
-            // A rule's fraction is a fraction of the frame the child was
-            // given, which is the one length the rule can mean.
-            declared[n]
-                .map(|len| Len::from_parts(len.rel, len.px).within_len(frame.axis(axis).len()))
-        });
-        let (local, extent) = frame_and_extent(frame, part_of(self.extent, place), narrow, align);
         let within = match local == UiRegion::FULL {
-            true => self.frame,
+            true => self.region,
-            false => local.within(&self.frame),
+            false => local.within(&self.region),
         };
         #[cfg(feature = "layout-diagnostics")]
         if region_node {
@@ -198,20 +262,39 @@ impl<'a> Painter<'a> {
             self.children.push(id.id());
         }
         let first_ask = self.offer(id.id());
-        let offer_place = if first_ask {
+        let given_len = local.size();
-            place
+        let offer_len = match first_ask {
+            true => given_len,
+            false => self
+                .state
+                .active
+                .get(&id.id())
+                .map_or(given_len, |a| a.offer_len),
+        };
+        let offer_region = match first_ask {
+            true => local,
+            false => self
+                .state
+                .active
+                .get(&id.id())
+                .map_or(local, |a| a.offer_region),
+        };
+        let offer_placement = if first_ask {
+            placement
         } else {
             self.state
                 .active
                 .get(&id.id())
-                .map_or(place, |a| a.offer_place)
+                .map_or(placement, |a| a.offer_placement)
         };
-        let px = local.size().to_px(self.px);
+        let px = given_len.to_px(self.px);
-        // The answer and what it holds for, both about the place asked in.
+        let offered_px = offer_len.to_px(self.offered_px);
-        // The child's record may say something else once its drawing has been
+        // The answer and what it holds for, both about the box asked in. The
+        // child's record may say something else once its drawing has been
         // placed: a drawing made again in its placed box holds for that box.
         let (size, answer_holds, holds) = self.state.draw_inner(
             id.id(),
+            within,
             DrawInfo {
                 layer: self.layer,
                 parent: Some(self.id),
@@ -219,46 +302,77 @@ impl<'a> Painter<'a> {
                 parent_move: self.move_idx,
                 region_node,
                 mask: self.mask,
-                frame: local,
+                given_region: local,
-                frame_abs: within,
+                offer_region,
-                part: extent,
+                offer_len,
-                place,
+                offer_placement,
-                offer_place,
-                // The question its parent measured it by, asked again: the
-                // same widget in the same place, however this draw came
-                // about.
-                offer: place == offer_place,
                 px,
+                offered_px,
+                placement,
             },
             None,
+            measuring,
             self.rsc,
         );
-        let compose = |holds| in_parent(holds, local, extent, place, declared);
+        let in_parent = |holds: LayoutHolds| {
-        self.under = self.under.and(compose(holds));
+            let mut result = LayoutHolds::ANY;
+            for axis in AXES {
+                let n = axis as usize;
+                let chosen = placement[n].unwrap_or(UiSpan::FULL).len();
+                match extent {
+                    // Its box is this widget's own, so what its drawing holds
+                    // for is what this widget's extent holds for.
+                    Some(ExtentPlacement::Inherit) if declared[n].is_none() => {
+                        result.frame[n] = holds.frame[n].through(local.axis(axis).len());
+                        result.extent[n] = holds.extent[n];
+                        if holds.placement.is_some() {
+                            result.placement = Some(self.placement);
+                        }
+                    }
+                    // Its box is a part of this widget's extent, so what it
+                    // holds for is a range on that extent and none of it a
+                    // range on the frame. Only the part's length reaches it,
+                    // which is what lets the extent move without a redraw.
+                    Some(ExtentPlacement::Within(part)) if declared[n].is_none() => {
+                        result.extent[n] = holds.frame[n]
+                            .and(holds.extent[n].through(chosen))
+                            .through(part.axis(axis).len());
+                    }
+                    // Its box is a length of this widget's frame: an
+                    // ordinary ask, or a declared length, which is that
+                    // length wherever the box it sits in came from.
+                    _ => {
+                        result.frame[n] = holds.frame[n].through(local.axis(axis).len()).and(
+                            holds.extent[n]
+                                .through(chosen)
+                                .through(local.axis(axis).len()),
+                        );
+                    }
+                }
+            }
+            result
+        };
+        self.under = self.under.and(in_parent(holds));
+        let mut answer_holds = in_parent(answer_holds);
+        // What it reports is a fraction of the box it was given, which is a
+        // part of this widget's extent -- so the same fraction is a different
+        // length once that extent is, and pixels are not. The answer only:
+        // the drawing this holds is re-placed rather than made again.
+        if matches!(extent, Some(ExtentPlacement::Within(_)))
+            && AXES.into_iter().any(|axis| {
+                declared[axis as usize].is_none() && size.axis(axis).rel != crate::Rel::ZERO
+            })
+        {
+            answer_holds.placement = Some(self.placement);
+        }
         DrawResult {
             child: id,
             painter: self,
             size: in_parent_frame(size, local.size(), declared),
-            answer_holds: compose(answer_holds),
+            answer_holds,
         }
     }
 
-    /// Takes back a child that was drawn only to find out how long it is.
-    /// Its drawing is dropped and it is not one of this widget's children
-    /// this frame; what it answered is still something this widget asked.
-    pub fn undraw<W: ?Sized>(&mut self, id: &StrongWidget<W>) {
-        self.children.retain(|child| *child != id.id());
-        self.state.undraw_rec(id.id(), self.rsc);
-    }
-
-    /// What a widget's rules declare its lengths to be, which whoever draws
-    /// it resolves into its frame. Reading them depends on nothing -- the box
-    /// that comes of them is kept on the child, and `redraw` compares it
-    /// there.
-    fn declared_lens<W: ?Sized>(&self, id: &StrongWidget<W>) -> [Option<LayoutLen>; 2] {
-        declared_lens(self.rsc.widgets(), id.id())
-    }
-
     /// What a child says its length is without being drawn, if it can say.
     /// Asking counts as reading its size.
     pub fn size_hint<W: ?Sized>(&mut self, id: &StrongWidget<W>, axis: Axis) -> Option<LayoutLen> {
@@ -287,11 +401,58 @@ impl<'a> Painter<'a> {
         }
     }
 
+    /// Measures a child's length from its hint, a retained answer, or `draw`.
+    /// A fresh draw evaluates the offer without placing its answer. The caller
+    /// must later place or undraw the child.
+    pub fn measure_len<W: ?Sized>(
+        &mut self,
+        child: &StrongWidget<W>,
+        axis: Axis,
+        region: UiRegion,
+        placement: [Option<UiSpan>; 2],
+    ) -> LayoutLen {
+        let offered = placement;
+        let declared = self.declared_lens(child);
+        let align = self.rsc.widgets().alignment(child.id());
+        let (local, placement) = ask_box(region, declared, align, placement);
+        let first_ask = self.at_offer && !self.offered.contains(&child.id());
+
+        if let Some(hint) = self.size_hint(child, axis) {
+            return hint;
+        }
+        let px = local.size().to_px(self.px);
+        let retained =
+            self.state
+                .retained_size(child.id(), px, placement, self.move_idx, self.rsc.widgets());
+        let Some((size, holds)) = retained else {
+            return self
+                .widget_at_inner(child, region, offered, None, true)
+                .len(axis);
+        };
+        #[cfg(feature = "layout-diagnostics")]
+        diag::bump(Counter::RetainedSizeHits);
+        self.depend_on(child);
+        if first_ask {
+            self.offered.push(child.id());
+            let active = self.state.active.get_mut(&child.id()).unwrap();
+            active.offer_len = local.size();
+            active.offer_region = local;
+            active.offer_placement = placement;
+        }
+        let placement = UiRegion {
+            x: placement[0].unwrap_or(UiSpan::FULL),
+            y: placement[1].unwrap_or(UiSpan::FULL),
+        };
+        let holds = holds.in_frame(placement);
+        for (axis, under) in AXES.into_iter().zip(self.answer_under.frame.iter_mut()) {
+            *under = under.and(holds[axis as usize].through(local.axis(axis).len()));
+        }
+        in_parent_frame(size, local.size(), declared).axis(axis)
+    }
+
     /// Whether this is the first box a child is asked about in during a draw
-    /// that is itself the one its parent measured -- the question a cold
+    /// that is itself in the box it was asked in -- the question a cold
-    /// layout asks, whose answer is the one to keep. A drawing made again in
+    /// layout asks, whose answer is the one to keep.
-    /// a box chosen from an answer asks about that box instead, and what it
-    /// hears back is not a measurement of anything.
     fn offer(&mut self, child: WidgetId) -> bool {
         if !self.at_offer || self.offered.contains(&child) {
             return false;
@@ -320,10 +481,11 @@ impl<'a> Painter<'a> {
 
     /// Writes glyphs in the selected frame or extent coordinates.
     // TODO: merge the text methods into the primitive ones.
-    pub fn glyphs(&mut self, text: &RenderedText, origin: UiRegion) {
+    pub fn glyphs(&mut self, text: &RenderedText, origin: impl Into<DrawRegion>) {
+        let origin = origin.into();
         // Glyph offsets and sizes are pixels, which compose additively.
-        // Only the shared origin needs composing through the extent.
+        // Only the shared origin needs the frame/extent composition.
-        let resolved = self.resolve(origin);
+        let resolved = origin.resolve(self.region, self.placement);
         let kind = self.rsc.ui_mut().primitives.kind::<GlyphPrimitive>();
         for glyph in text.glyphs.iter() {
             let place = |mut region: UiRegion| {
@@ -347,22 +509,30 @@ impl<'a> Painter<'a> {
                     color: text.color,
                     flags: glyph.entry.flags(),
                 },
-                place(origin),
+                origin.map(place),
                 place(resolved),
             );
         }
     }
 
-    /// The symbolic length of this widget's own box along one axis, in the
+    /// The box this widget's parent gave it, in the coordinates its own
-    /// lengths of its frame that it places its children in. Reading it pins
+    /// primitives are written in -- so a region composed `within` it may be
-    /// the drawing to that length -- and to nothing about where the box
+    /// drawn directly. Its own box is [`Self::placement`] of this one.
-    /// starts, which is what lets a container move without being drawn
+    pub fn region(&self) -> UiRegion {
-    /// again. One axis at a time, because a container that divides one axis
+        self.region
-    /// holds for any length of the other.
+    }
-    pub fn extent_len(&mut self, axis: Axis) -> Len {
+
-        let len = self.extent.axis(axis).len();
+    /// Where this widget's drawing goes inside the box it was given, in that
-        self.extent_len[axis as usize] = Some(len);
+    /// box's coordinates: what its own answer took of it, or what its parent
-        len
+    /// chose for it. `FULL` on the ask that measures, since nothing has been
+    /// placed yet.
+    ///
+    /// Reading it is what says the drawing depends on it, so a widget that
+    /// positions its own content reads it and is drawn again once its box is
+    /// known, and one that fills whatever it is given never is.
+    pub fn placement(&mut self) -> UiRegion {
+        self.reads_placement = true;
+        self.placement
     }
 
     /// Where this widget sits in a box longer than the length it takes. A
@@ -390,6 +560,14 @@ impl<'a> Painter<'a> {
             .is_some()
     }
 
+    /// The part of this widget's box that something of `size` takes, at the
+    /// near edge. A container that reports one child's size gives every child
+    /// this, so what it draws is inside what it says it occupies.
+    pub fn box_of(&self, size: Size) -> UiRegion {
+        let lens = placed_lens(size, [None; 2], [false; 2]);
+        placed_box(UiRegion::FULL, lens, RegionAlign::NEAR)
+    }
+
     /// This widget's own box in pixels. Reading it makes the drawing one
     /// that holds for this box only, until `holds` says how far it goes.
     pub fn px_size(&mut self) -> PxVec2 {
@@ -399,7 +577,7 @@ impl<'a> Painter<'a> {
     /// One axis of this widget's own box in pixels. Prefer this to
     /// [`Self::px_size`] when the other axis cannot affect the drawing.
     pub fn px_len(&mut self, axis: Axis) -> Px {
-        let part = self.extent.axis(axis).len();
+        let part = self.placement.axis(axis).len();
         let len = part.to_px(self.px.axis(axis));
         let own = &mut self.extent_own[axis as usize];
         if *own == Holds::ANY {
@@ -413,7 +591,7 @@ impl<'a> Painter<'a> {
     /// of the box, and the same reported size. A widget that read its length
     /// in pixels holds for that one alone until it says otherwise.
     pub fn holds(&mut self, axis: Axis, holds: impl Into<Holds>) {
-        let part = self.extent.axis(axis).len();
+        let part = self.placement.axis(axis).len();
         let holds = holds.into();
         debug_assert!(
             holds.contains(part.to_px(self.px.axis(axis))),
@@ -424,10 +602,10 @@ impl<'a> Painter<'a> {
         self.extent_own[axis as usize] = holds;
     }
 
-    /// One axis of this widget's frame in pixels -- what a fraction of its
+    /// One axis of the box this widget's parent gave it, in pixels -- what a
-    /// area resolves against, and so what a container divides among its
+    /// fraction of its area resolves against, and so what a container divides
-    /// children. Its own box is a part of this one.
+    /// among its children. Its own box is a part of this one.
-    pub fn frame_px_len(&mut self, axis: Axis) -> Px {
+    pub fn region_px_len(&mut self, axis: Axis) -> Px {
         let len = self.px.axis(axis);
         let own = &mut self.own[axis as usize];
         if *own == Holds::ANY {
@@ -436,14 +614,14 @@ impl<'a> Painter<'a> {
         len
     }
 
-    /// [`Self::holds`] stated about the frame rather than about this
+    /// [`Self::holds`] stated about the region rather than about this
-    /// widget's own box, for a container whose drawing turns on what its
+    /// widget's own box, for a container whose drawing turns on the box it
-    /// fractions are of rather than on the part of it it took.
+    /// was given rather than on the part of it it took.
-    pub fn frame_holds(&mut self, axis: Axis, holds: impl Into<Holds>) {
+    pub fn region_holds(&mut self, axis: Axis, holds: impl Into<Holds>) {
         let holds = holds.into();
         debug_assert!(
             holds.contains(self.px.axis(axis)),
-            "'{}' ({:?}) says its drawing holds for lengths that leave out its frame",
+            "'{}' ({:?}) says its drawing holds for lengths that leave out its region",
             self.label(),
             self.id
         );
@@ -535,57 +713,6 @@ impl PrimitiveLike for &TextureHandle {
     }
 }
 
-/// What a child depends on, said about the boxes the widget that drew it
-/// has rather than the ones the child was given.
-///
-/// `frame` is the child's frame in this widget's frame coordinates and
-/// `extent` the box it was given, in the child's own frame coordinates. Both
-/// reach it as one length, so what it holds for maps back through that
-/// length exactly -- and where the box it was given is this widget's own,
-/// what it says about that box is what this widget can say about its own.
-pub(crate) fn in_parent(
-    holds: LayoutHolds,
-    frame: UiRegion,
-    extent: UiRegion,
-    place: [Place; 2],
-    declared: [Option<LayoutLen>; 2],
-) -> LayoutHolds {
-    let mut result = LayoutHolds::ANY;
-    for axis in AXES {
-        let n = axis as usize;
-        let frame_len = frame.axis(axis).len();
-        result.frame[n] = holds.frame[n].through(frame_len);
-        match (place[n].part(), declared[n]) {
-            // Its box is this widget's own, or a part of it in that box's
-            // own lengths: so what it holds for is a range on this widget's
-            // own box, which is what lets that box move without a redraw. A
-            // length it pinned is this widget's length wherever the part is
-            // the whole of it, and pins the same way.
-            (Part::All, None) => {
-                result.extent[n] = holds.extent[n];
-                result.extent_len[n] = holds.extent_len[n];
-            }
-            // Its box is a part of this widget's own box, in that box's own
-            // lengths, so what it holds for maps back through that part into
-            // a range on this widget's box.
-            (Part::Of(span), None) => {
-                result.extent[n] = holds.extent[n].through(span.len());
-            }
-            // Its box is a part of this widget's frame: a length of the
-            // frame is all that reaches it, so what it holds for is a range
-            // on the frame and none of it on this widget's own box.
-            _ => {
-                result.frame[n] = result.frame[n].and(
-                    holds.extent[n]
-                        .through(extent.axis(axis).len())
-                        .through(frame_len),
-                );
-            }
-        }
-    }
-    result
-}
-
 /// A child's answer as lengths of the parent's own region. A widget reports
 /// a fraction of its own region, and `of` is that region as a length of this
 /// one. Pixels come through untouched, being that many pixels wherever they
@@ -632,82 +759,68 @@ pub(crate) fn fills(reported: LayoutLen, declared: Option<LayoutLen>, decided: b
     reported.leftover != Weight::ZERO || declared.is_some() || decided
 }
 
-/// Where a widget's drawing goes inside the part its parent gave it: what
+/// What of the box it was given a widget's drawing occupies, as lengths of
-/// it reported, on the side of the part its alignment says, and the whole
+/// that box: the size it reported wherever that is a part to be placed, and
-/// part wherever the answer fills it.
+/// the whole of the box wherever the answer fills it.
 ///
-/// The length it reported is a length of its frame, and the part is one too,
+/// A reported fraction is a fraction of the box the widget drew in, where a
-/// so this takes one from the other rather than composing it into the part.
+/// declared one is a fraction of the box its parent handed down -- a span
-/// That is what makes a fraction the same fraction wherever the part it is
+/// reporting `rel(1.0)` means all of what it was given, whatever that was a
-/// placed in sits and however long it is -- the fraction is resolved once,
+/// fraction of. So this is a length of the box rather than a length composed
-/// here, against the frame it was reported of.
+/// into it, and a box in pixels is this step from the given box's pixels.
-pub(crate) fn placed_extent(
+pub(crate) fn placed_lens(
-    part: UiRegion,
     size: Size,
     declared: [Option<LayoutLen>; 2],
-    fill: [bool; 2],
+    decided: [bool; 2],
-    align: RegionAlign,
+) -> UiVec2 {
-) -> UiRegion {
+    let mut lens = UiVec2::FULL_SIZE;
-    let mut placed = part;
+    for (axis, (declared, decided)) in AXES.into_iter().zip(declared.into_iter().zip(decided)) {
-    for axis in AXES {
-        let n = axis as usize;
         let reported = size.axis(axis);
-        if fills(reported, declared[n], fill[n]) {
+        if !fills(reported, declared, decided) {
+            *lens.axis_mut(axis) = Len::from_parts(reported.rel, reported.px);
+        }
+    }
+    lens
+}
+
+/// Where that drawing sits: those lengths taken of the box the widget was
+/// asked in, on the side of it that the widget's alignment says.
+pub(crate) fn placed_box(region: UiRegion, lens: UiVec2, align: RegionAlign) -> UiRegion {
+    let mut placed = region;
+    for axis in AXES {
+        // The whole of the box is already where it sits, and the arithmetic
+        // below is the identity for it.
+        if lens.axis(axis) == Len::FULL {
             continue;
         }
-        let len = Len::from_parts(reported.rel, reported.px);
         let span = placed.axis_mut(axis);
+        let len = lens.axis(axis).within_len(span.len());
         span.start += (span.len() - len).scale(align.axis(axis).rel());
         span.end = span.start + len;
     }
     placed
 }
 
-/// The part of a widget's extent a `place` names, in the coordinates its
+/// A declared axis gets a frame of that length, aligned within the parent's
-/// extent is in: a span is measured in frame lengths from where the extent
+/// slot (or the offer). Undeclared axes keep the offered frame and chosen
-/// starts, so nothing under it depends on where that is, and an extent that
+/// placement, so their reported fractions retain that reference.
-/// moved re-places every child by re-adding its start.
+pub(crate) fn ask_box(
-pub(crate) fn part_of(extent: UiRegion, place: [Place; 2]) -> UiRegion {
+    mut region: UiRegion,
-    let mut part = extent;
+    declared: [Option<LayoutLen>; 2],
-    for axis in AXES {
-        *part.axis_mut(axis) = place[axis as usize].part().of(*extent.axis(axis));
-    }
-    part
-}
-
-/// The frame a child is asked in and the box its drawing goes in, both in
-/// the coordinates of the widget asking.
-///
-/// `frame` is what the caller said the child's fractions are of, and `part`
-/// what of the caller's own box the drawing takes. `narrow` is the length a
-/// declared rule gives the frame, which makes the frame the box the drawing
-/// goes in -- a rule is what decided where it goes, and there is nothing
-/// left to place inside it. A caller that narrowed the frame itself said the
-/// same thing.
-///
-/// The length is the caller's to supply so that a widget asked again gets
-/// the frame it already has rather than a second resolution of its rule.
-pub(crate) fn frame_and_extent(
-    mut frame: UiRegion,
-    part: UiRegion,
-    narrow: [Option<Len>; 2],
     align: RegionAlign,
-) -> (UiRegion, UiRegion) {
+    placement: [Option<UiSpan>; 2],
-    let mut extent = part;
+) -> (UiRegion, [Option<UiSpan>; 2]) {
-    for (axis, narrow) in AXES.into_iter().zip(narrow) {
+    let mut placed = [None; 2];
-        let span = frame.axis_mut(axis);
+    for (axis, (len, chosen)) in AXES.into_iter().zip(declared.into_iter().zip(placement)) {
-        let narrowed = match narrow {
+        let Some(len) = len else {
-            Some(len) => {
+            placed[axis as usize] = chosen;
-                let slot = part.axis(axis);
+            continue;
-                let start = slot.start + (slot.len() - len).scale(align.axis(axis).rel());
-                *span = UiSpan::new(start, start + len);
-                true
-            }
-            None => *span != UiSpan::FULL,
         };
-        if narrowed {
+        let span = region.axis_mut(axis);
-            *extent.axis_mut(axis) = UiSpan::FULL;
+        let len = Len::from_parts(len.rel, len.px);
-        }
+        let slot = chosen.unwrap_or(*span);
+        span.start = slot.start + (slot.len() - len).scale(align.axis(axis).rel());
+        span.end = span.start + len;
     }
-    (frame, extent)
+    (region, placed)
 }

core/src/ui/place.rs

@@ -1,61 +0,0 @@
-use crate::{PrimitiveHandle, UiRegion, UiSpan};
-
-/// What of a widget's own box a child is given, along one axis.
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub enum Part {
-    /// The whole of it.
-    All,
-    /// Frame lengths from where the box starts, which is what a container
-    /// dividing room among its children speaks: a child's report is a length
-    /// of the frame, so the cursor that sums those reports is one too. A
-    /// moved box re-places every child by re-adding its start, exactly.
-    From(UiSpan),
-    /// A part of the box in its own coordinates, which is what a container
-    /// that insets one speaks: taking eleven pixels off the end needs no
-    /// length, where saying the same thing in frame lengths would make the
-    /// container read its own box -- and a box chosen from its own answer
-    /// then feeds back into the answer.
-    Of(UiSpan),
-}
-
-impl Part {
-    /// Where it lands in the coordinates `extent` is in.
-    pub(crate) fn of(self, extent: UiSpan) -> UiSpan {
-        match self {
-            Self::All => extent,
-            Self::From(span) => UiSpan::new(extent.start + span.start, extent.start + span.end),
-            Self::Of(span) => span.within(&extent),
-        }
-    }
-}
-
-/// Where a child goes along one axis, as a part of this widget's box.
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub enum Place {
-    /// The child's answer, aligned inside the part by the child's alignment.
-    Within(Part),
-    /// Exactly the part; the answer is not placed inside it again.
-    Fill(Part),
-}
-
-impl Place {
-    pub(crate) fn part(self) -> Part {
-        match self {
-            Self::Within(part) | Self::Fill(part) => part,
-        }
-    }
-
-    /// Whether the part is the drawing's box outright, rather than the box
-    /// the answer is placed inside.
-    pub(crate) fn fills(self) -> bool {
-        matches!(self, Self::Fill(_))
-    }
-}
-
-/// 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,
-}

src/random.rs

@@ -117,18 +117,16 @@ pub struct Branch {
 
 impl Widget for Branch {
     fn draw(&mut self, painter: &mut Painter) -> Size {
-        let cut = Len::from_parts(Rel::ZERO, Px::from_int(40));
+        let mut top = UiRegion::FULL;
-        let top = Place::Within(Part::From(UiSpan::new(Len::ZERO, cut)));
+        top.y.end = top.y.start.offset(Px::from_int(40));
-        let measured = painter
+        let measured = painter.widget_within(&self.probe, top).len(Axis::X);
-            .widget_at(&self.probe, UiRegion::FULL, [Place::Within(Part::All), top])
-            .len(Axis::X);
         let px = measured.apply_leftover().to_px(painter.px_len(Axis::X));
 
-        let below = Place::Within(Part::From(UiSpan::new(cut, painter.extent_len(Axis::Y))));
+        let mut below = UiRegion::FULL;
-        let place = [Place::Within(Part::All), below];
+        below.y.start = below.y.start.offset(Px::from_int(40));
         match px > Px::from_f32(self.threshold) {
-            true => painter.widget_at(&self.wide, UiRegion::FULL, place),
+            true => painter.widget_within(&self.wide, below),
-            false => painter.widget_at(&self.narrow, UiRegion::FULL, place),
+            false => painter.widget_within(&self.narrow, below),
         };
         Size::LEFTOVER
     }

src/widget/mask.rs

@@ -6,7 +6,7 @@ pub struct Masked {
 
 impl Widget for Masked {
     fn draw(&mut self, painter: &mut Painter) -> Size {
-        painter.set_mask(UiRegion::FULL);
+        painter.set_mask(DrawRegion::Extent(UiRegion::FULL));
         painter.widget(&self.inner);
         // What it occupies is its box, on both axes, for the reason `Scroll`
         // reports the same: it clips what is inside to that box, so it can

src/widget/position/offset.rs

@@ -7,14 +7,7 @@ pub struct Offset {
 
 impl Widget for Offset {
     fn draw(&mut self, painter: &mut Painter) -> Size {
-        // The whole of this widget's box, moved: the frame passes through, so
+        let region = UiRegion::FULL.offset(self.amt);
-        // what the child declares or reports means the same as it would
+        painter.widget_within(&self.inner, region).size()
-        // without the offset.
-        let moved = |len: Len, amt: Len| Place::Within(Part::From(UiSpan::new(amt, len + amt)));
-        let place = [
-            moved(painter.extent_len(Axis::X), self.amt.x),
-            moved(painter.extent_len(Axis::Y), self.amt.y),
-        ];
-        painter.widget_at(&self.inner, UiRegion::FULL, place).size()
     }
 }

src/widget/position/pad.rs

@@ -13,26 +13,8 @@ impl Widget for Pad {
         // 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.
-        //
+        let inside = DrawRegion::Extent(self.padding.region());
-        // The padding goes around what it pads: the frame passes through, so
+        let inner = painter.widget_within(&self.inner, inside).size();
-        // the inner's fractions mean what they would without it, and only
-        // the box it draws in is moved in by the pixels.
-        // A part of this widget's own box, in that box's own lengths: the
-        // padding is pixels, which are the same pixels wherever the box
-        // lands, so nothing here reads how long the box is -- and a box
-        // chosen from this widget's own answer therefore does not feed back
-        // into that answer.
-        let inset = |lead: Px, trail: Px| {
-            Place::Within(Part::Of(UiSpan::new(
-                Len::from_parts(Rel::ZERO, lead),
-                Len::from_parts(Rel::ONE, -trail),
-            )))
-        };
-        let place = [
-            inset(self.padding.left, self.padding.right),
-            inset(self.padding.top, self.padding.bottom),
-        ];
-        let inner = painter.widget_at(&self.inner, UiRegion::FULL, place).size();
         Size {
             x: LayoutLen {
                 px: inner.x.px + self.padding.left + self.padding.right,

src/widget/position/scroll.rs

@@ -12,11 +12,12 @@ pub struct Scroll {
 impl Widget for Scroll {
     fn draw(&mut self, painter: &mut Painter) -> Size {
         let container_len = painter.px_len(self.axis);
-        // Measured in the whole viewport, then drawn at the scrolled offset.
+        // Draw in the whole container only when its scrolling-axis length is
+        // not already known, then draw it at the scrolled offset.
         let whole = UiRegion::FULL;
-        let answer_len = painter
+        let own = painter.placement();
-            .widget_at(&self.inner, whole, [Place::Fill(Part::All); 2])
+        let answer_len =
-            .len(self.axis);
+            painter.measure_len(&self.inner, self.axis, whole, [Some(own.x), Some(own.y)]);
         let content = answer_len.apply_leftover();
         self.container_len = container_len;
         self.content_len = content.to_px(container_len);
@@ -45,7 +46,7 @@ impl Widget for Scroll {
         // have placed the whole scroll in a box longer than it.
         let slack = (self.container_len - self.content_len).max(Px::ZERO);
         let anchor = slack.mul(align.rel());
-        let mut content = UiSpan::FULL;
+        let mut region = UiRegion::FULL;
         // Content that fills the viewport and has not been scrolled is the
         // viewport, and is handed back as it came. Writing the same box as
         // its own length in pixels is the same box in another form, and the
@@ -54,19 +55,19 @@ impl Widget for Scroll {
         // each part of it.
         let moved = anchor != Px::ZERO || self.amt != Px::ZERO;
         if moved || self.content_len != self.container_len {
-            let start = Len::from_parts(Rel::ZERO, anchor - self.amt);
+            let offset = UiVec2::from_axis(
-            content = UiSpan::new(start, start.offset(self.content_len));
+                self.axis,
+                Len::from_parts(Rel::ZERO, anchor - self.amt),
+                Len::ZERO,
+            );
+            region = region.offset(offset);
+            region.axis_mut(self.axis).end = region.axis(self.axis).start.offset(self.content_len);
         }
-        // The viewport is the inner's frame, so a fraction it declares or
+        // The viewport is the inner's region, 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 is drawn is the
+        // content box its own answer decided. Where it is put is the content
-        // content box, scrolled.
+        // box, scrolled.
-        painter.widget_at(
+        painter.widget_at(&self.inner, whole, [Some(region.x), Some(region.y)]);
-            &self.inner,
-            whole,
-            self.axis
-                .pair(Place::Fill(Part::From(content)), Place::Fill(Part::All)),
-        );
         // What it occupies is its box, on both axes: it clips its content to
         // that box, so it can neither take less of one nor honestly ask for
         // more. The content's length is what it scrolls through, not what it

src/widget/position/span.rs

@@ -10,30 +10,34 @@ pub struct Span {
 impl Widget for Span {
     fn draw(&mut self, painter: &mut Painter) -> Size {
         let axis = self.dir.axis;
-        // The row: this span's own box, as a length of the frame its children
+        // The row: this span's own box, as a span of the region it was given.
-        // are laid out against. Its start is nothing's business -- a slot is
+        // Its children are laid out along it, and what they declare or report
-        // a length from it -- so what this reads is the length alone.
+        // is a fraction of the region -- the area this span was told it has,
-        let far = painter.extent_len(axis);
+        // which it passes on unchanged.
+        let own = painter.placement();
+        let row = *own.axis(axis);
+        // Across itself the span's own box is the child's region: a span is
+        // what contains its children there, and nothing divides that axis.
+        // Along it the whole region is, so a fraction means the same thing
+        // for every child however much of the row is left when it is asked.
+        let region = UiRegion::from_axis(axis, UiSpan::FULL, *own.axis(!axis));
         let along = |from: Len, to: Len| match self.dir.sign {
-            Sign::Pos => UiSpan::new(from, to),
+            Sign::Pos => UiSpan::new(row.start + from, row.start + to),
-            Sign::Neg => UiSpan::new(far - to, far - from),
+            Sign::Neg => UiSpan::new(row.end - to, row.end - from),
         };
-        // Across itself the child sits where its own alignment says, in the
+        let far = row.len();
-        // whole of the row: a span is what contains its children there, and
+        // A length for every child before their final boxes are chosen: from
-        // nothing divides that axis.
+        // a hint where one exists, and from drawing otherwise.
-        let across = Place::Within(Part::All);
-        // A length for every child before their final slots are chosen. The
-        // frame passes through unchanged, so `rel(0.5)` is half the area this
-        // span was given whatever else is in it and wherever this child sits
-        // among them; what it is drawn in is the room left from the cursor,
-        // because a text has to wrap at the width actually there.
         let mut cursor = Len::rel_min();
         let mut lens = Vec::with_capacity(self.children.len());
         for child in &self.children {
-            let room = Place::Within(Part::From(along(cursor, far)));
+            // The whole region is the child's, so `rel(0.5)` is half the area
-            let len = painter
+            // this span was given whatever else is in it and wherever this
-                .widget_at(child, UiRegion::FULL, axis.pair(room, across))
+            // child sits among them. What it is placed in is the room left
-                .len(axis);
+            // from the cursor, because a text has to wrap at the width
+            // actually there.
+            let room = axis.pair(Some(along(cursor, far)), None);
+            let len = painter.measure_len(child, axis, region, room);
             cursor.px += len.px + self.gap;
             cursor.rel += len.rel;
             lens.push(len);
@@ -51,7 +55,7 @@ impl Widget for Span {
         );
 
         // What is left for the shares to divide: the row less everything
-        // fixed, as a length of the frame rather than a number of pixels.
+        // fixed, as a length of the region rather than a number of pixels.
         let room = far - Len::from_parts(total.rel, total.px);
         // Whether anything is left over is a question in pixels: `rel(0.5)`
         // beside 300 px is full at 600 and overfull at 400. Asked of `room`
@@ -64,12 +68,12 @@ impl Widget for Span {
         // exist at all turns on this.
         let mut shares = false;
         if total.leftover > Weight::ZERO {
-            shares = room.to_px(painter.frame_px_len(axis)) > Px::ZERO;
+            shares = room.to_px(painter.region_px_len(axis)) > Px::ZERO;
             let holds = match shares {
                 true => Holds::from(Px::STEP..=Px::MAX),
                 false => Holds::from(Px::MIN..=Px::ZERO),
             };
-            painter.frame_holds(axis, holds.through(room));
+            painter.region_holds(axis, holds.through(room));
         }
 
         // Across itself a span is as long as its longest child -- unless a
@@ -105,11 +109,12 @@ impl Widget for Span {
             fixed.px += len.px;
             fixed.rel += len.rel;
             start = shared(fixed, taken, total.leftover, room);
-            // Along the row the span says where the child goes, and that slot
+            // Along the row the span says where the child goes; across it the
-            // is the drawing's box outright rather than something to place an
+            // child sits where its own alignment says. Its region is the
-            // answer inside again.
+            // whole of what this span was given either way, which is what its
-            let slot = Place::Fill(Part::From(along(from, start)));
+            // fractions are of.
-            let placed = painter.widget_at(child, UiRegion::FULL, axis.pair(slot, across));
+            let placed =
+                painter.widget_at(child, region, axis.pair(Some(along(from, start)), None));
             if shrinks {
                 let used = placed.len(!axis);
                 // Choosing between a fixed and a relative length from the

src/widget/position/stack.rs

@@ -13,18 +13,17 @@ impl Widget for Stack {
             StackSize::Default => None,
             StackSize::Child(i) => Some(i),
         };
-        // Whichever child sizes the stack is given the stack's whole box --
+        // Whichever child sizes the stack keeps the stack's whole region as
-        // the stack is the length that child asked for, so placing that
+        // its own -- the stack is the length that child asked for, so taking
-        // answer inside the box it decided would apply it twice.
+        // the fraction of the stack's box again would take it twice -- and is
+        // put where the stack itself is put.
         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
+                painter.widget(child).size()
-                    .widget_at(child, UiRegion::FULL, [Place::Fill(Part::All); 2])
-                    .size()
             }
             None => Size::LEFTOVER,
         };
@@ -33,9 +32,10 @@ impl Widget for Stack {
                 continue;
             }
             painter.child_layer_at(i);
-            // Every other child is drawn in the stack's own box, and where it
+            // Every other child has the stack's own box for its region, since
-            // sits in one bigger than itself is its own business.
+            // the stack is what contains it, and where it sits in one bigger
-            painter.widget(child);
+            // than itself is its own business.
+            painter.widget_within(child, DrawRegion::Extent(UiRegion::FULL));
         }
         size
     }

src/widget/text/mod.rs

@@ -80,7 +80,7 @@ impl TextView {
         // 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);
+        painter.glyphs(tex, DrawRegion::Extent(region));
         (region, size)
     }
 

tests/cases/determinism.rs

@@ -21,18 +21,16 @@ struct BranchesOnMeasurement {
 
 impl Widget for BranchesOnMeasurement {
     fn draw(&mut self, painter: &mut Painter) -> Size {
-        let cut = Len::from_parts(Rel::ZERO, Px::from_int(40));
+        let mut top = UiRegion::FULL;
-        let top = Place::Within(Part::From(UiSpan::new(Len::ZERO, cut)));
+        top.y.end = top.y.start.offset(Px::from_int(40));
-        let measured = painter
+        let measured = painter.widget_within(&self.probe, top).len(Axis::X);
-            .widget_at(&self.probe, UiRegion::FULL, [Place::Within(Part::All), top])
-            .len(Axis::X);
         let px = measured.apply_leftover().to_px(painter.px_len(Axis::X));
 
-        let below = Place::Within(Part::From(UiSpan::new(cut, painter.extent_len(Axis::Y))));
+        let mut below = UiRegion::FULL;
-        let place = [Place::Within(Part::All), below];
+        below.y.start = below.y.start.offset(Px::from_int(40));
         match px > Px::from_f32(self.threshold) {
-            true => painter.widget_at(&self.wide, UiRegion::FULL, place),
+            true => painter.widget_within(&self.wide, below),
-            false => painter.widget_at(&self.narrow, UiRegion::FULL, place),
+            false => painter.widget_within(&self.narrow, below),
         };
         Size::LEFTOVER
     }

tests/cases/layout.rs

@@ -83,12 +83,11 @@ fn a_text_in_a_span_wraps_at_the_room_left_rather_than_the_whole_row() {
     assert!(crowded > whole_row, "{crowded} against {whole_row}");
 }
 
-/// The same reading through a pad: padding goes around what it pads and
+/// The same reading through a pad: its inset is the whole box less the
-/// does not narrow what a fraction under it is a fraction of, so half of the
+/// padding, so half of the inset plus the padding is half the box plus one
-/// window plus the padding is what the pad takes and where the next child
+/// padding, not two.
-/// starts.
 #[test]
-fn a_pad_puts_its_padding_around_a_fraction_of_the_whole_box() {
+fn a_pad_reports_a_fraction_of_its_inset_as_a_fraction_of_its_box() {
     let mut h = Harness::new((400, 100));
     let inner = rect(Color::GREEN).width(rel(0.5)).add(&mut h.rsc);
     let padded = (inner,).span(Dir::RIGHT).pad(10).add(&mut h.rsc);
@@ -97,9 +96,8 @@ fn a_pad_puts_its_padding_around_a_fraction_of_the_whole_box() {
     // placed inside it by its own alignment, which is not what is under test.
     h.set_root((padded, tail).span(Dir::RIGHT).width(rel(1.0)));
 
-    assert_corners!(h, inner, (10, 10), (210, 90));
+    assert_corners!(h, padded, (0, 0), (210, 100));
-    assert_corners!(h, padded, (0, 0), (220, 100));
+    assert_corners!(h, tail, (210, 0), (310, 100));
-    assert_corners!(h, tail, (220, 0), (320, 100));
 }
 
 #[test]
@@ -428,8 +426,7 @@ fn a_row_of_equal_shares_fills_it_exactly() {
 /// a step of. Kept in step with `snap_floor` in `prelude.wgsl`.
 fn drawn_edges(h: &Harness, id: WidgetId, axis: Axis) -> (f32, f32) {
     let active = &h.render.active[&id];
-    let drawn = active.extent.within(&active.frame_abs);
+    let region = h.render.moves.resolve(active.parent_move, active.region);
-    let region = h.render.moves.resolve(active.parent_move, drawn);
     let dim = h.size().axis(axis);
     let snap = |v: f32| (v + Px::STEP.to_f32() * 0.5).floor();
     let edge = |s: Len| snap(s.rel.to_f32() * dim + s.px.to_f32());

tests/cases/retained.rs

@@ -213,12 +213,9 @@ struct FromHint {
 impl Widget for FromHint {
     fn draw(&mut self, painter: &mut Painter) -> Size {
         let len = painter.size_hint(&self.inner, Axis::Y).unwrap();
-        let top = UiSpan::new(Len::ZERO, Len::from_parts(Rel::ZERO, len.px));
+        let mut region = UiRegion::FULL;
-        painter.widget_at(
+        region.y.end = region.y.start.offset(len.px);
-            &self.inner,
+        painter.widget_within(&self.inner, region);
-            UiRegion::FULL,
-            [Place::Within(Part::All), Place::Within(Part::From(top))],
-        );
         Size::LEFTOVER
     }
 }
@@ -308,51 +305,6 @@ fn a_span_ruled_across_itself_moves_its_child_without_redrawing_it() {
     assert_eq!(h.render.active[&span.id()].size.y, LayoutLen::rel(1.0));
 }
 
-/// A row places its children as lengths from where its own box starts, so a
-/// child that grew moves the ones after it and nothing else: each of them is
-/// the same box in a new place, which the retained drawing follows without
-/// being made again. Both kinds of length: one the row resolves from a rule,
-/// and one it takes from what the child reported.
-#[test]
-fn a_row_moves_what_follows_a_child_that_grew_rather_than_drawing_it() {
-    for declared in [false, true] {
-        let mut h = Harness::new((400, 200));
-        let first = rect(Color::RED).width(50).add(&mut h.rsc);
-        let ruled = Rc::new(Cell::new(0));
-        let second = Counted {
-            draws: ruled.clone(),
-            size: Size::LEFTOVER,
-            reads_box: false,
-        };
-        let second = match declared {
-            true => second.width(rel(0.25)).add(&mut h.rsc),
-            false => second.width(60).add(&mut h.rsc),
-        };
-        let (third, reported) = counted(&mut h, Size::from((70, 20)), false);
-        h.set_root((first, second, third).span(Dir::RIGHT).width(rel(1.0)));
-        let (was_ruled, was_reported) = (ruled.get(), reported.get());
-        // A quarter of the row is a quarter of the row, wherever it sits in
-        // it and whatever the first child takes.
-        let width = match declared {
-            true => 100,
-            false => 60,
-        };
-        assert_corners!(h, second, (50, 0), (50 + width, 200));
-
-        h.set_len(first, Axis::X, 80);
-        h.frame();
-
-        assert_eq!(ruled.get(), was_ruled, "the ruled child was drawn again");
-        assert_eq!(
-            reported.get(),
-            was_reported,
-            "the reported child was drawn again"
-        );
-        assert_corners!(h, second, (80, 0), (80 + width, 200));
-        assert_corners!(h, third, (80 + width, 90), (150 + width, 110));
-    }
-}
-
 /// The output is the root of the box chain, so a resize is a box that changed
 /// length like any other -- there is not a second rule for the window. A
 /// drawing that holds for one length is drawn again whichever box moved.
@@ -797,6 +749,36 @@ fn primitive_bounds(h: &Harness, id: WidgetId) -> Vec<PixelRegion> {
         .collect()
 }
 
+#[test]
+fn frame_geometry_and_extent_geometry_keep_their_references() {
+    struct Both(Rc<Cell<usize>>);
+    impl Widget for Both {
+        fn draw(&mut self, painter: &mut Painter) -> Size {
+            self.0.set(self.0.get() + 1);
+            painter.primitive_within(RectPrimitive::color(Color::RED), UiRegion::FULL);
+            painter.primitive(RectPrimitive::color(Color::BLUE));
+            Size::LEFTOVER
+        }
+    }
+    for node in [false, true] {
+        let mut h = Harness::new((400, 200));
+        let first = rect(Color::GREEN).width(100).add(&mut h.rsc);
+        let draws = Rc::new(Cell::new(0));
+        let both = Both(draws.clone()).add(&mut h.rsc);
+        h.rsc.widgets_mut().set_region_node(both, node);
+        h.set_root((first, both).span(Dir::RIGHT));
+        let count = draws.get();
+        h.set_len(first, Axis::X, 200);
+        h.frame();
+        assert_eq!(draws.get(), count);
+        let bounds = primitive_bounds(&h, both.id());
+        assert_eq!(bounds[0].top_left.x, Px::ZERO);
+        assert_eq!(bounds[0].bot_right.x, Px::from_int(400));
+        assert_eq!(bounds[1].top_left.x, Px::from_int(200));
+        assert_eq!(bounds[1].bot_right.x, Px::from_int(400));
+    }
+}
+
 #[test]
 fn changing_an_inherited_extent_keeps_the_original_measurement_offer() {
     fn build(h: &mut Harness, width: i32, text: &str) -> (WeakWidget<Text>, WeakWidget<Rect>) {
@@ -876,14 +858,7 @@ fn resizing_a_fixed_frame_recomposes_its_contents_without_drawing_them() {
     }
     impl Widget for Frame {
         fn draw(&mut self, painter: &mut Painter) -> Size {
-            painter.widget_at(
+            painter.widget_within(&self.child, self.region);
-                &self.child,
-                UiRegion::FULL,
-                [
-                    Place::Within(Part::From(self.region.x)),
-                    Place::Within(Part::From(self.region.y)),
-                ],
-            );
             Size::LEFTOVER
         }
     }
@@ -891,7 +866,7 @@ fn resizing_a_fixed_frame_recomposes_its_contents_without_drawing_them() {
     impl Widget for Painted {
         fn draw(&mut self, painter: &mut Painter) -> Size {
             self.0.set(self.0.get() + 1);
-            painter.set_mask(UiRegion::FULL);
+            painter.set_mask(DrawRegion::Extent(UiRegion::FULL));
             painter.primitive(RectPrimitive::color(Color::BLUE));
             Size::LEFTOVER
         }
@@ -940,6 +915,43 @@ fn resizing_a_fixed_frame_recomposes_its_contents_without_drawing_them() {
     }
 }
 
+#[test]
+fn a_span_does_not_place_its_measurement_before_assigning_the_childs_slot() {
+    struct MeasuredBox(Rc<Cell<usize>>);
+
+    impl Widget for MeasuredBox {
+        fn draw(&mut self, painter: &mut Painter) -> Size {
+            self.0.set(self.0.get() + 1);
+            painter.px_size();
+            painter.primitive(RectPrimitive::color(Color::BLUE));
+            Size::from((100, 50))
+        }
+    }
+
+    let mut h = Harness::new((400, 200));
+    let draws = Rc::new(Cell::new(0));
+    let leaf = MeasuredBox(draws.clone()).add(&mut h.rsc);
+    h.set_root((leaf,).span(Dir::RIGHT).width(rel(1.0)).height(rel(1.0)));
+
+    assert_eq!(draws.get(), 3);
+    assert_corners!(h, leaf, (0, 75), (100, 125));
+    assert_eq!(
+        primitive_bounds(&h, leaf.id()),
+        vec![h.region(&leaf.id()).unwrap()]
+    );
+    h.frame();
+    assert_eq!(draws.get(), 3);
+
+    h.resize((600, 300));
+    h.frame();
+    assert_eq!(draws.get(), 6);
+    assert_corners!(h, leaf, (0, 125), (100, 175));
+    assert_eq!(
+        primitive_bounds(&h, leaf.id()),
+        vec![h.region(&leaf.id()).unwrap()]
+    );
+}
+
 #[test]
 fn glyph_origins_compose_identically_when_drawn_and_when_retained() {
     struct Glyphs {
@@ -954,7 +966,8 @@ fn glyph_origins_compose_identically_when_drawn_and_when_retained() {
                 UiSpan::new(Len::rel(0.23) + Len::px(-7.125), Len::FULL),
                 UiSpan::new(Len::rel(0.37) + Len::px(3.25), Len::FULL),
             );
-            painter.glyphs(text, origin);
+            painter.glyphs(text, DrawRegion::Frame(origin));
+            painter.glyphs(text, DrawRegion::Extent(origin));
             Size::LEFTOVER
         }
     }
@@ -968,10 +981,7 @@ fn glyph_origins_compose_identically_when_drawn_and_when_retained() {
             painter.widget_at(
                 &self.child,
                 self.region,
-                [
+                [Some(self.extent.x), Some(self.extent.y)],
-                    Place::Fill(Part::From(self.extent.x)),
-                    Place::Fill(Part::From(self.extent.y)),
-                ],
             );
             Size::LEFTOVER
         }
@@ -1118,7 +1128,7 @@ fn widening_and_restoring_a_contract_does_not_invalidate_its_reader() {
     assert_eq!(leaf_draws.get(), settled + 1);
 }
 #[test]
-fn padding_and_stack_boxes_follow_the_extent_without_drawing_again() {
+fn padding_and_stack_frames_follow_the_extent_without_drawing_again() {
     struct Observed<W> {
         widget: W,
         draws: Rc<Cell<usize>>,
@@ -1138,10 +1148,7 @@ fn padding_and_stack_boxes_follow_the_extent_without_drawing_again() {
             painter.widget_at(
                 &self.child,
                 UiRegion::FULL,
-                [
+                [Some(self.extent.x), Some(self.extent.y)],
-                    Place::Fill(Part::From(self.extent.x)),
-                    Place::Fill(Part::From(self.extent.y)),
-                ],
             );
             Size::LEFTOVER
         }
@@ -1172,18 +1179,13 @@ fn padding_and_stack_boxes_follow_the_extent_without_drawing_again() {
             h.set_root(root);
             (root, leaf, fixed, draws)
         };
-        // The same box in three places. A pad places its child as lengths of
-        // its own box measured from where that box starts, so moving it is
-        // nothing to the pad -- where changing its length is a different
-        // question, and does draw it again.
-        let at = |start: f32| {
-            let span = |start: Len| UiSpan::new(start, start + Len::rel(0.4));
-            UiRegion::new(span(Len::rel(start) + Len::px(3.125)), span(Len::px(11.25)))
-        };
         let mut warm = Harness::new((403, 211));
-        let (root, leaf, fixed, draws) = plant(&mut warm, at(0.13));
+        let (root, leaf, fixed, draws) = plant(&mut warm, UiRegion::FULL);
-        for start in [0.13, -0.17, 0.31] {
+        for (start, end) in [(0.13, 0.83), (-0.17, 1.23), (0.31, 0.67)] {
-            let extent = at(start);
+            let extent = UiRegion::new(
+                UiSpan::new(Len::rel(start) + Len::px(3.125), Len::rel(end)),
+                UiSpan::new(Len::px(11.25), Len::rel(end)),
+            );
             let before = draws.get();
             warm.rsc[root].extent = extent;
             warm.frame();
@@ -1227,11 +1229,11 @@ fn moving_an_extent_child_preserves_the_slot_chosen_from_its_measurement() {
                 &self.child,
                 UiRegion::FULL,
                 [
-                    Place::Fill(Part::From(UiSpan::new(
+                    Some(UiSpan::new(
                         Len::px(self.start),
                         Len::px(self.start + 200.0),
-                    ))),
+                    )),
-                    Place::Fill(Part::From(UiSpan::FULL)),
+                    Some(UiSpan::FULL),
                 ],
             );
             Size::LEFTOVER
@@ -1265,14 +1267,7 @@ fn extent_frames_keep_fractional_reports_and_numeric_dependencies_valid() {
     impl Widget for Container {
         fn draw(&mut self, painter: &mut Painter) -> Size {
             painter
-                .widget_at(
+                .widget_within(&self.child, DrawRegion::Extent(self.region))
-                    &self.child,
-                    UiRegion::FULL,
-                    [
-                        Place::Within(Part::From(self.region.x)),
-                        Place::Within(Part::From(self.region.y)),
-                    ],
-                )
                 .size()
         }
     }
@@ -1288,10 +1283,7 @@ fn extent_frames_keep_fractional_reports_and_numeric_dependencies_valid() {
                     .widget_at(
                         &self.child,
                         UiRegion::FULL,
-                        [
+                        [Some(self.extent.x), Some(self.extent.y)],
-                            Place::Fill(Part::From(self.extent.x)),
-                            Place::Fill(Part::From(self.extent.y)),
-                        ],
                     )
                     .size(),
             );

tests/cases/scroll.rs

@@ -71,7 +71,7 @@ fn a_clipping_widget_reporting_more_than_its_box_is_caught() {
 
     impl Widget for Clipper {
         fn draw(&mut self, painter: &mut Painter) -> Size {
-            painter.set_mask(UiRegion::FULL);
+            painter.set_mask(painter.region());
             painter.widget(&self.0).size()
         }
     }