From 5d627f76696e4424f0375328af2868affcc013a5 Mon Sep 17 00:00:00 2001
From: same mf who else <AAAAA@AAAAA.AAAAA>
Date: Sat, 21 Mar 2026 15:30:25 +0200
Subject: [PATCH] all possible insanities simultaneously.

but at least deleting more than i'm writing (hopefully!)
---
 src/.scratch.rs |  21 --
 src/color.rs    |  10 +-
 src/draw.rs     | 971 ++++++++++++++++++++++++------------------------
 src/term.rs     | 618 +++++++++++++++---------------
 src/text.rs     |  63 +++-
 5 files changed, 868 insertions(+), 815 deletions(-)

diff --git a/src/.scratch.rs b/src/.scratch.rs
index 1b68884..c07d40b 100644
--- a/src/.scratch.rs
+++ b/src/.scratch.rs
@@ -1439,25 +1439,4 @@ impl<E: Engine, S, C: Command<S>> MenuItem<E, S, C> {
 
 ///// TUI helper defs.
 //impl Tui {
-    ////pub const fn null     () -> Color { Color::Reset }
-    ////pub const fn red      () -> Color { Color::Rgb(255,0,  0) }
-    ////pub const fn orange   () -> Color { Color::Rgb(255,128,0) }
-    ////pub const fn yellow   () -> Color { Color::Rgb(255,255,0) }
-    ////pub const fn brown    () -> Color { Color::Rgb(128,255,0) }
-    ////pub const fn green    () -> Color { Color::Rgb(0,255,0) }
-    ////pub const fn electric () -> Color { Color::Rgb(0,255,128) }
-    ////pub const fn g   (g: u8) -> Color { Color::Rgb(g, g, g) }
-    ////fn bg0  () -> Color { Color::Rgb(20, 20, 20) }
-    ////fn bg   () -> Color { Color::Rgb(28, 35, 25) }
-    ////fn border_bg () -> Color { Color::Rgb(40, 50, 30) }
-    ////fn border_fg (f: bool) -> Color { if f { Self::bo1() } else { Self::bo2() } }
-    ////fn title_fg (f: bool) -> Color { if f { Self::ti1() } else { Self::ti2() } }
-    ////fn separator_fg (_: bool) -> Color { Color::Rgb(0, 0, 0) }
-    ////fn mode_bg () -> Color { Color::Rgb(150, 160, 90) }
-    ////fn mode_fg () -> Color { Color::Rgb(255, 255, 255) }
-    ////fn status_bar_bg () -> Color { Color::Rgb(28, 35, 25) }
-    ////fn bo1 () -> Color { Color::Rgb(100, 110, 40) }
-    ////fn bo2 () -> Color { Color::Rgb(70, 80, 50) }
-    ////fn ti1 () -> Color { Color::Rgb(150, 160, 90) }
-    ////fn ti2 () -> Color { Color::Rgb(120, 130, 100) }
 //}
diff --git a/src/color.rs b/src/color.rs
index cab02c2..d1e7889 100644
--- a/src/color.rs
+++ b/src/color.rs
@@ -55,7 +55,15 @@ impl ItemColor {
     }
 }
 
-pub struct ItemTheme {}
+pub struct ItemTheme {
+    pub base: ItemColor,
+    pub light: ItemColor,
+    pub lighter: ItemColor,
+    pub lightest: ItemColor,
+    pub dark: ItemColor,
+    pub darker: ItemColor,
+    pub darkest: ItemColor,
+}
 impl_from!(ItemTheme: |base: ItemColor|   Self::from_item_color(base));
 impl_from!(ItemTheme: |base: Color|       Self::from_tui_color(base));
 impl ItemTheme {
diff --git a/src/draw.rs b/src/draw.rs
index 323093e..8033666 100644
--- a/src/draw.rs
+++ b/src/draw.rs
@@ -5,9 +5,10 @@ use crate::{*, lang::*, color::*};
 /// ```
 /// use tengri::draw::*;
 /// struct TestScreen(bool);
+/// impl Screen for TestScreen { type Unit = u16; }
 /// struct TestWidget(bool);
 /// impl Draw<TestScreen> for TestWidget {
-///     fn draw (&self, screen: &mut T) {
+///     fn draw (&self, screen: &mut T) -> Usually<WH<u16>> {
 ///         screen.0 |= self.0;
 ///     }
 /// }
@@ -16,26 +17,47 @@ use crate::{*, lang::*, color::*};
 /// TestWidget(true).draw(&mut screen);
 /// TestWidget(false).draw(&mut screen);
 /// ```
-pub trait Draw<T> {
-    fn draw (&self, to: &mut T);
+pub trait Draw<T: Screen> {
+    fn draw (&self, to: &mut T) -> Usually<WH<T::Unit>>;
 }
-impl<T> Draw<T> for () {
-    fn draw (&self, __: &mut T) {}
+impl<T: Screen> Draw<T> for () {
+    fn draw (&self, __: &mut T) -> Usually<WH<T::Unit>> {
+        Ok(Default::default())
+    }
 }
-impl<T, F: Fn(&mut T)> Draw<T> for F {
-    fn draw (&self, to: &mut T) { self(to) }
+impl<T: Screen, D: Draw<T>> Draw<T> for &D {
+    fn draw (&self, to: &mut T) -> Usually<WH<T::Unit>> {
+        (*self).draw(to)
+    }
 }
-//impl<T, D: Draw<T>> Draw<T> for &D {
-    //fn draw (&self, to: &mut T) { (*self).draw(to) }
-//}
-impl<T, D: Draw<T>> Draw<T> for Arc<D> {
-    fn draw (&self, to: &mut T) { (**self).draw(to) }
+impl<T: Screen, D: Draw<T>> Draw<T> for Arc<D> {
+    fn draw (&self, to: &mut T) -> Usually<WH<T::Unit>> {
+        (**self).draw(to)
+    }
 }
-impl<T, D: Draw<T>> Draw<T> for RwLock<D> {
-    fn draw (&self, to: &mut T) { self.read().unwrap().draw(to) }
+impl<T: Screen, D: Draw<T>> Draw<T> for RwLock<D> {
+    fn draw (&self, to: &mut T) -> Usually<WH<T::Unit>> {
+        self.read().unwrap().draw(to)
+    }
 }
-impl<T, D: Draw<T>> Draw<T> for Option<D> {
-    fn draw (&self, to: &mut T) { if let Some(draw) = self { draw.draw(to) } }
+impl<T: Screen, D: Draw<T>> Draw<T> for Option<D> {
+    fn draw (&self, to: &mut T) -> Usually<WH<T::Unit>> {
+        self.map(|draw|draw.draw(to)).transpose()?.flatten()
+    }
+}
+
+/// Because we can't implement [Draw] for `F: FnOnce...` without conflicts.
+pub struct Thunk<T: Screen, F: FnOnce(&mut T)->Usually<WH<T::Unit>>>(
+    pub F,
+    std::marker::PhantomData<T>
+);
+pub const fn thunk <T: Screen, F: FnOnce(&mut T)->Usually<WH<T::Unit>>> (draw: F) -> Thunk<T, F> {
+    Thunk(draw, std::marker::PhantomData)
+}
+impl<T: Screen, F: FnOnce(&mut T)->Usually<WH<T::Unit>>> Draw<T> for Thunk<T, F> {
+    fn draw (&self, to: &mut T) -> Usually<WH<T::Unit>> {
+        (self.0)(to)
+    }
 }
 
 /// Only render when condition is true.
@@ -45,8 +67,8 @@ impl<T, D: Draw<T>> Draw<T> for Option<D> {
 ///     tengri::when(true, "Yes")
 /// # }
 /// ```
-pub fn when <T> (condition: bool, draw: impl Draw<T>) -> impl Draw<T> {
-    move|to: &mut T|if condition { draw.draw(to); }
+pub const fn when <T: Screen> (condition: bool, draw: impl Draw<T>) -> impl Draw<T> {
+    thunk(move|to: &mut T|if condition { draw.draw(to) } else { Ok(Default::default()) })
 }
 
 /// Render one thing if a condition is true and another false.
@@ -56,8 +78,449 @@ pub fn when <T> (condition: bool, draw: impl Draw<T>) -> impl Draw<T> {
 ///     tengri::either(true, "Yes", "No")
 /// # }
 /// ```
-pub fn either <T> (condition: bool, a: impl Draw<T>, b: impl Draw<T>) -> impl Draw<T> {
-    move|to: &mut T|if condition { a.draw(to) } else { b.draw(to) }
+pub const fn either <T: Screen> (condition: bool, a: impl Draw<T>, b: impl Draw<T>) -> impl Draw<T> {
+    thunk(move|to: &mut T|if condition { a.draw(to) } else { b.draw(to) })
+}
+
+/// Something that has `[0, 0]` at a particular point.
+pub trait HasOrigin {
+    fn origin (&self) -> Origin;
+}
+impl<T: AsRef<Origin>> HasOrigin for T {
+    fn origin (&self) -> Origin { self.as_ref() }
+}
+
+/// Where is [0, 0] located?
+///
+/// ```
+/// use tengri::draw::Origin;
+/// let _ = Origin::NW.align(())
+/// ```
+#[cfg_attr(test, derive(Arbitrary))]
+#[derive(Debug, Copy, Clone, Default)] pub enum Origin {
+    #[default] C, X, Y, NW, N, NE, E, SE, S, SW, W
+}
+impl Origin {
+    pub fn align <T: Screen> (&self, a: impl Draw<T>) -> impl Draw<T> {
+        align(*self, a)
+    }
+}
+
+/// ```
+/// use tengri::draw::{align, Origin::*};
+/// let _ = align(NW, "test");
+/// let _ = align(SE, "test");
+/// ```
+pub fn align <T: Screen> (origin: Origin, a: impl Draw<T>) -> impl Draw<T> {
+    thunk(move|to: &mut T| { todo!() })
+}
+
+/// A numeric type that can be used as coordinate.
+///
+/// FIXME: Replace with `num` crate?
+/// FIXME: Use AsRef/AsMut?
+///
+/// ```
+/// use tengri::draw::Coord;
+/// let a: u16 = Coord::zero();
+/// let b: u16 = a.plus(1);
+/// let c: u16 = a.minus(2);
+/// let d = a.atomic();
+/// ```
+pub trait Coord: Send + Sync + Copy
+    + Add<Self, Output=Self>
+    + Sub<Self, Output=Self>
+    + Mul<Self, Output=Self>
+    + Div<Self, Output=Self>
+    + Ord + PartialEq + Eq
+    + Debug + Display + Default
+    + From<u16> + Into<u16>
+    + Into<usize>
+    + Into<f64>
+    + std::iter::Step
+{
+    /// Zero in own type.
+    fn zero () -> Self { 0.into() }
+    /// Addition.
+    fn plus (self, other: Self) -> Self;
+    /// Saturating subtraction.
+    fn minus  (self, other: Self) -> Self { if self >= other { self - other } else { 0.into() } }
+    /// Convert to [AtomicUsize].
+    fn atomic (self) -> AtomicUsize { AtomicUsize::new(self.into()) }
+}
+
+/// A cardinal direction.
+#[cfg_attr(test, derive(Arbitrary))]
+#[derive(Copy, Clone, PartialEq, Debug, Default)] pub enum Split {
+    North, South, East, West, Above, #[default] Below
+}
+
+pub const fn east <T: Screen> (a: impl Draw<T>, b: impl Draw<T>) -> impl Draw<T> {
+    Split::East.half(a, b)
+}
+pub const fn north <T: Screen> (a: impl Draw<T>, b: impl Draw<T>) -> impl Draw<T> {
+    Split::North.half(a, b)
+}
+pub const fn west <T: Screen> (a: impl Draw<T>, b: impl Draw<T>) -> impl Draw<T> {
+    Split::West.half(a, b)
+}
+pub const fn south <T: Screen> (a: impl Draw<T>, b: impl Draw<T>) -> impl Draw<T> {
+    Split::South.half(a, b)
+}
+pub const fn above <T: Screen> (a: impl Draw<T>, b: impl Draw<T>) -> impl Draw<T> {
+    Split::Above.half(a, b)
+}
+pub const fn below <T: Screen> (a: impl Draw<T>, b: impl Draw<T>) -> impl Draw<T> {
+    Split::Below.half(a, b)
+}
+impl Split {
+    /// ```
+    /// use tengri::draw::Split::*;
+    /// let _ = Above.bsp((), ());
+    /// let _ = Below.bsp((), ());
+    /// let _ = North.bsp((), ());
+    /// let _ = South.bsp((), ());
+    /// let _ = East.bsp((), ());
+    /// let _ = West.bsp((), ());
+    /// ```
+    pub const fn half <T: Screen> (&self, a: impl Draw<T>, b: impl Draw<T>) -> impl Draw<T> {
+        thunk(move|to: &mut T|{
+            let (area_a, area_b) = to.xywh().split_half(self);
+            let (origin_a, origin_b) = self.origins();
+            match self {
+                Self::Below => {
+                    to.place(area_b, &origin_b.align(b));
+                    to.place(area_a, &origin_a.align(a));
+                },
+                _ => {
+                    to.place(area_a, &origin_a.align(a));
+                    to.place(area_b, &origin_b.align(b));
+                }
+            }
+            Ok(to.wh()) // FIXME: compute and return actually used area
+        })
+    }
+    /// Newly split areas begin at the center of the split
+    /// to maintain centeredness in the user's field of view.
+    ///
+    /// Use [align] to override that and always start
+    /// at the top, bottom, etc.
+    ///
+    /// ```
+    /// /*
+    ///
+    ///  Split east:   Split south:
+    ///  |    |    |   |    A    |
+    ///  | <-A|B-> |   |---------|
+    ///  |    |    |   |    B    |
+    ///
+    /// */
+    /// ```
+    const fn origins (&self) -> (Origin, Origin) {
+        use Origin::*;
+        match self {
+            Self::South => (S, N),
+            Self::East  => (E, W),
+            Self::North => (N, S),
+            Self::West  => (W, E),
+            Self::Above    => (C, C),
+            Self::Below  => (C, C),
+        }
+    }
+    /// Iterate over a collection of renderables:
+    ///
+    /// ```
+    /// use tengri::draw::{Origin::*, Split::*};
+    /// let _ = Below.iter([
+    ///   NW.align(W(15).max(W(10).min("Leftbar"))),
+    ///   NE.align(W(12).max(W(10).min("Rightbar"))),
+    ///   Center.align(W(40).max(H(20.max("Center"))))
+    /// ].iter(), |x|x);
+    /// ```
+    pub fn iter <T: Screen, U: Draw<T>, F: Fn(U)->dyn Draw<T>> (
+        _items: impl Iterator<Item = U>, _cb: F
+    ) -> impl Draw<T> {
+        thunk(move|_to: &mut T|{ todo!() })
+    }
+}
+
+/// Coordinate along horizontal axis.
+#[derive(Copy, Clone, Debug, Default)] pub struct X<N: Coord>(pub N);
+impl<N: Coord> X<N> {
+    pub const fn push <T: Screen<Unit = N>> (x: N, a: impl Draw<T>) -> impl Draw<T> {
+        a
+    }
+    pub const fn pull <T: Screen<Unit = N>> (x: N, a: impl Draw<T>) -> impl Draw<T> {
+        a
+    }
+}
+#[derive(Copy, Clone, Debug, Default)] pub struct W<N: Coord>(pub N);
+impl<N: Coord> W<N> {
+    pub const fn max <T: Screen<Unit = N>> (w: Option<N>, a: impl Draw<T>) -> impl Draw<T> {
+        WH::max(w, None, a)
+    }
+    pub const fn min <T: Screen<Unit = N>> (w: Option<N>, a: impl Draw<T>) -> impl Draw<T> {
+        WH::min(w, None, a)
+    }
+    pub const fn exact <T: Screen<Unit = N>> (w: T::Unit, c: impl Draw<T>) -> impl Draw<T> {
+        WH::exact(Some(w), None, c)
+    }
+    /// Shrink drawing area symmetrically.
+    ///
+    /// ```
+    /// let padded = tengri::W(3).pad("Hello");
+    /// ```
+    pub const fn pad <T: Screen<Unit = N>> (x: N, draw: impl Draw<T>)
+        -> impl Draw<T>
+    {
+        thunk(move|to: &mut T|draw.draw(todo!()))
+    }
+}
+#[derive(Copy, Clone, Debug, Default)] pub struct Y<N: Coord>(pub N);
+impl<N: Coord> Y<N> {
+    pub const fn push <T: Screen<Unit = N>> (x: N, a: impl Draw<T>) -> impl Draw<T> {
+        a
+    }
+    pub const fn pull <T: Screen<Unit = N>> (x: N, a: impl Draw<T>) -> impl Draw<T> {
+        a
+    }
+}
+#[derive(Copy, Clone, Debug, Default)] pub struct H<N: Coord>(pub N);
+impl<N: Coord> H<N> {
+    pub const fn max <T: Screen<Unit = N>> (h: Option<N>, a: impl Draw<T>) -> impl Draw<T> {
+        WH::max(None, h, a)
+    }
+    pub const fn min <T: Screen<Unit = N>> (h: Option<N>, a: impl Draw<T>) -> impl Draw<T> {
+        WH::min(None, h, a)
+    }
+    pub const fn exact <T: Screen<Unit = N>> (h: T::Unit, c: impl Draw<T>) -> impl Draw<T> {
+        WH::exact(None, Some(h), c)
+    }
+    /// Shrink drawing area symmetrically.
+    ///
+    /// ```
+    /// let padded = tengri::W::pad(3, "Hello");
+    /// ```
+    pub const fn pad <T: Screen<Unit = N>> (x: N, draw: impl Draw<T>) -> impl Draw<T> {
+        thunk(move|to: &mut T|draw.draw(todo!()))
+    }
+}
+/// An origin point (X, Y).
+///
+/// ```
+/// let xy = tengri::XY(0u16, 0);
+/// ```
+#[cfg_attr(test, derive(Arbitrary))] #[derive(Copy, Clone, Debug, Default, PartialEq)]
+pub struct XY<C: Coord>(pub C, pub C);
+impl<N: Coord> HasX<N> for XY<N> { fn x (&self) -> X<N> { X(self.0) } }
+impl<N: Coord> HasY<N> for XY<N> { fn y (&self) -> Y<N> { Y(self.1) } }
+impl<N: Coord> XY<N> {
+    pub const fn push <T: Screen<Unit = N>> (&self, a: impl Draw<T>) -> impl Draw<T> {
+        a
+    }
+    pub const fn pull <T: Screen<Unit = N>> (&self, a: impl Draw<T>) -> impl Draw<T> {
+        a
+    }
+}
+/// A size (Width, Height).
+///
+/// ```
+/// let wh = tengri::WH(0u16, 0);
+/// ```
+#[cfg_attr(test, derive(Arbitrary))] #[derive(Copy, Clone, Debug, Default, PartialEq)]
+pub struct WH<C: Coord>(pub C, pub C);
+impl<N: Coord> HasW<N> for WH<N> { fn w (&self) -> W<N> { W(self.0) } }
+impl<N: Coord> HasH<N> for WH<N> { fn h (&self) -> H<N> { H(self.1) } }
+impl<N: Coord> WH<N> {
+    /// Shrink drawing area symmetrically.
+    ///
+    /// ```
+    /// let padded = tengri::WH(3, 5).pad("Hello");
+    /// ```
+    pub const fn pad <T: Screen<Unit = N>> (&self, draw: impl Draw<T>)
+        -> impl Draw<T>
+    {
+        thunk(move|to: &mut T|draw.draw(todo!()))
+    }
+
+    /// Only draw content if area is above a certain size.
+    ///
+    /// ```
+    /// let min = tengri::WH::min(3, 5, "Hello"); // 5x5
+    /// ```
+    pub const fn min <T: Screen<Unit = N>> (w: Option<N>, h: Option<N>, draw: impl Draw<T>)
+        -> impl Draw<T>
+    {
+        thunk(move|to: &mut T|draw.draw(todo!()))
+    }
+
+    /// Set the maximum width and/or height of the content.
+    ///
+    /// ```
+    /// let max = tengri::WH::max(Some(3), Some(5), "Hello");
+    /// ```
+    pub const fn max <T: Screen<Unit = N>> (w: Option<N>, h: Option<N>, draw: impl Draw<T>)
+        -> impl Draw<T>
+    {
+        thunk(move|to: &mut T|draw.draw(todo!()))
+    }
+
+    /// Set the maximum width and/or height of the content.
+    ///
+    /// ```
+    /// let exact = tengri::WH::exact(Some(3), Some(5), "Hello");
+    /// ```
+    pub const fn exact <T: Screen<Unit = N>> (w: Option<N>, h: Option<N>, draw: impl Draw<T>)
+        -> impl Draw<T>
+    {
+        thunk(move|to: &mut T|draw.draw(todo!()))
+    }
+
+    /// Limit size of drawing area
+    /// ```
+    /// let clipped = tengri::WH::clip(Some(3), Some(5), "Hello");
+    /// ```
+    pub const fn clip <T: Screen<Unit = N>> (w: Option<N>, h: Option<N>, draw: impl Draw<T>) -> impl Draw<T> {
+        thunk(move|to: &mut T|draw.draw(todo!()))
+    }
+}
+/// Point with size.
+///
+/// ```
+/// let xywh = tengri::XYWH(0u16, 0, 0, 0);
+/// assert_eq!(tengri::XYWH(10u16, 10, 20, 20).center(), tengri::XY(20, 20));
+/// ```
+///
+/// * [ ] TODO: origin field (determines at which corner/side is X0 Y0)
+///
+#[cfg_attr(test, derive(Arbitrary))] #[derive(Copy, Clone, Debug, Default, PartialEq)]
+pub struct XYWH<C: Coord>(pub C, pub C, pub C, pub C);
+impl<N: Coord> HasX<N> for XYWH<N> { fn x (&self) -> X<N> { X(self.0) } }
+impl<N: Coord> HasY<N> for XYWH<N> { fn y (&self) -> Y<N> { Y(self.1) } }
+impl<N: Coord> HasW<N> for XYWH<N> { fn w (&self) -> W<N> { W(self.2) } }
+impl<N: Coord> HasH<N> for XYWH<N> { fn h (&self) -> H<N> { H(self.3) } }
+impl<N: Coord> XYWH<N> {
+    pub fn zero () -> Self {
+        Self(0.into(), 0.into(), 0.into(), 0.into())
+    }
+    pub fn center (&self) -> XY<N> {
+        let Self(x, y, w, h) = *self;
+        XY(x.plus(w/2.into()), y.plus(h/2.into()))
+    }
+    pub fn centered (&self) -> XY<N> {
+        let Self(x, y, w, h) = *self;
+        XY(x.minus(w/2.into()), y.minus(h/2.into()))
+    }
+    pub fn centered_x (&self, n: N) -> Self {
+        let Self(x, y, w, h) = *self;
+        let x_center = (x.plus(w / 2.into())).minus(n / 2.into());
+        let y_center = y.plus(h / 2.into());
+        XYWH(x_center, y_center, n, 1.into())
+    }
+    pub fn centered_y (&self, n: N) -> Self {
+        let Self(x, y, w, h) = *self;
+        let x_center = x.plus(w / 2.into());
+        let y_corner = (y.plus(h / 2.into())).minus(n / 2.into());
+        XYWH(x_center, y_corner, 1.into(), n)
+    }
+    pub fn centered_xy (&self, [n, m]: [N;2]) -> Self {
+        let Self(x, y, w, h) = *self;
+        let x_center = (x.plus(w / 2.into())).minus(n / 2.into());
+        let y_corner = (y.plus(h / 2.into())).minus(m / 2.into());
+        XYWH(x_center, y_corner, n, m)
+    }
+    pub fn split_half (&self, direction: &Split) -> (Self, Self) {
+        use Split::*;
+        let XYWH(x, y, w, h) = self.xywh();
+        match self {
+            South => (XYWH(x, y, w, h - h / 2), XYWH(x, y + h / 2, w, h / 2)),
+            East  => (XYWH(x, y, w - w / 2, h), XYWH(x + w / 2, y, w / 2, h)),
+            North => (XYWH(x, y + h / 2, w, h - h / 2), XYWH(x, y, w, h / 2)),
+            West  => (XYWH(x + w / 2, y, w - w / 2, h), XYWH(x, y, w / 2, h)),
+            Above | Below => (XYWH(x, y, w, h), XYWH(x, y, w, h))
+        }
+    }
+}
+
+pub trait HasXYWH<N: Coord>: HasXY<N> + HasWH<N> {
+    fn xywh (&self) -> XYWH<N>;
+}
+pub trait HasXY<N: Coord>: HasX<N> + HasY<N> {
+    fn xy (&self) -> XY<N>;
+}
+pub trait HasWH<N: Coord>: HasX<N> + HasY<N> {
+    fn wh (&self) -> WH<N>;
+}
+pub trait HasX<N: Coord> {
+    fn x (&self) -> X<N>;
+    fn iter_x (&self) -> impl Iterator<Item = N> where Self: HasW<N> + HasOrigin {
+        self.x_west()..self.x_east()
+    }
+    fn x_west (&self) -> N where Self: HasW<N> + HasOrigin {
+        use Origin::*;
+        let w = self.w();
+        let a = self.origin();
+        let d = match a { NW|W|SW => 0.into(), N|X|C|Y|S => w/2.into(), NE|E|SE => w };
+        self.x().minus(d)
+    }
+    fn x_east (&self) -> N where Self: HasW<N> + HasOrigin {
+        use Origin::*;
+        let w = self.w();
+        let a = self.origin();
+        let d = match a { NW|W|SW => w, N|X|C|Y|S => w/2.into(), NE|E|SE => 0.into() };
+        self.x().plus(d)
+    }
+    fn x_center (&self) -> N where Self: HasW<N> + HasOrigin {
+        todo!()
+    }
+}
+pub trait HasY<N: Coord> {
+    fn y (&self) -> Y<N>;
+    fn iter_y (&self) -> impl Iterator<Item = N> where Self: HasH<N> + HasOrigin {
+        self.y_north()..self.y_south()
+    }
+    fn y_north (&self) -> N where Self: HasH<N> + HasOrigin {
+        let a = self.origin();
+        let h = self.h();
+        use Origin::*;
+        let d = match a { NW|N|NE => 0.into(), W|X|C|Y|E => h/2.into(), SW|S|SE => h };
+        self.y().minus(d)
+    }
+    fn y_south (&self) -> N where Self: HasH<N> + HasOrigin  {
+        let a = self.origin();
+        let h = self.h();
+        use Origin::*;
+        let d = match a { NW|N|NE => h, W|X|C|Y|E => h/2.into(), SW|S|SE => 0.into() };
+        self.y().plus(d)
+    }
+    fn y_center (&self) -> N where Self: HasH<N> + HasOrigin {
+        todo!()
+    }
+}
+pub trait HasW<N: Coord> {
+    fn w (&self) -> W<N>;
+    fn w_min (&self) -> W<N> { self.w() }
+    fn w_max (&self) -> W<N> { self.w() }
+}
+pub trait HasH<N: Coord> {
+    fn h (&self) -> H<N>;
+    fn h_min (&self) -> H<N> { self.h() }
+    fn h_max (&self) -> H<N> { self.h() }
+}
+impl<N: Coord, T: AsRef<X<N>>> HasX<N> for T {
+    fn x (&self) -> X<N> { *self.as_ref() }
+}
+impl<N: Coord, T: AsRef<X<N>>> HasY<N> for T {
+    fn y (&self) -> Y<N> { *self.as_ref() }
+}
+impl<N: Coord, T: HasX<N> + HasY<N>> HasXY<N> for T {
+    fn xy (&self) -> XY<N> { XY(self.x(), self.y()) }
+}
+impl<N: Coord, T: HasX<N> + HasY<N>> HasWH<N> for T {
+    fn wh (&self) -> WH<N> { WH(self.x(), self.h()) }
+}
+impl<N: Coord, T: HasXY<N> + HasWH<N>> HasXYWH<N> for T {
+    fn xywh (&self) -> XYWH<N> { XYWH(self.x(), self.y(), self.w(), self.h()) }
 }
 
 /// Output target.
@@ -69,198 +532,38 @@ pub fn either <T> (condition: bool, a: impl Draw<T>, b: impl Draw<T>) -> impl Dr
 ///
 /// impl Screen for TestOut {
 ///     type Unit = u16;
-///     fn area (&self) -> impl TwoD<u16> { self.0 }
-///     fn area_mut (&mut self) -> &mut impl TwoD<u16> { &mut self.0 }
-///     fn show <T: Draw<Self> + ?Sized> (&mut self, area: impl TwoD<u16>, _: &T) {
-///         println!("show: {area:?}");
+///     fn place <T: Draw<Self> + ?Sized> (&mut self, area: impl TwoD<u16>, _: &T) {
+///         println!("place: {area:?}");
 ///         ()
 ///     }
 /// }
 ///
 /// impl Draw<Screen> for String {
-///     fn draw (&self, to: &mut TestOut) {
+///     fn draw (&self, to: &mut TestOut) -> Usually<WH<u16>> {
 ///         to.area_mut().set_w(self.len() as u16);
 ///     }
 /// }
 /// ```
-pub trait Screen: Area<Self::Unit> + Aligned +  Send + Sync + Sized {
+pub trait Screen: HasXYWH<Self::Unit> + HasOrigin +  Send + Sync + Sized {
     type Unit: Coord;
     /// Render drawable in area specified by `area`
-    fn show <'t, T: Draw<Self> + ?Sized> (&mut self, area: impl Area<Self::Unit>, content: &'t T);
-
-    fn clipped_mut (&mut self, w: Option<Self::Unit>, h: Option<Self::Unit>)
-        -> &mut Self;
-    fn padded_mut (&mut self, w: Self::Unit, h: Self::Unit)
-        -> &mut Self;
-}
-impl<O: Screen> X<O::Unit> for O { fn x (&self) -> O::Unit { self.x() } }
-impl<O: Screen> Y<O::Unit> for O { fn y (&self) -> O::Unit { self.y() } }
-impl<O: Screen> W<O::Unit> for O { fn w (&self) -> O::Unit { self.w() } }
-impl<O: Screen> H<O::Unit> for O { fn h (&self) -> O::Unit { self.h() } }
-
-/// Something that has area in 2D space.
-pub trait Area<N: Coord>: W<N> + H<N> {
-    fn wh (&self) -> WH<N> {
-        WH(self.w(), self.h())
+    fn place <'t, T: Draw<Self> + ?Sized> (&mut self, area: impl HasWH<Self::Unit>, content: &'t T) {
+        unimplemented!()
     }
-    fn clip_w (&self, w: N) -> [N;2] {
-        [self.w().min(w), self.h()]
-    }
-    fn clip_h (&self, h: N) -> [N;2] {
-        [self.w(), self.h().min(h)]
-    }
-    fn at_least (&self, w: N, h: N) -> Usually<&Self> {
-        if self.w() < w || self.h() < h { return Err(format!("min {w}x{h}").into()) }
-        Ok(self)
-    }
-    fn clip_wh (&self, w: Option<N>, h: Option<N>) -> [N;2] {
-        let w = w.map(|w|self.w().min(w)).unwrap_or(self.w());
-        let h = h.map(|h|self.h().min(h)).unwrap_or(self.h());
-        [w, h]
-    }
-}
-
-/// Something that has length along horizontal axis.
-pub trait W<N: Coord> {
-    fn w (&self) -> N { N::zero() }
-    fn w_min (&self) -> N { self.w() }
-    fn w_max (&self) -> N { self.w() }
-}
-fn w_exact <N: Coord, T: Screen<Unit = N>> (_w: N, _c: impl Draw<T>) -> impl Draw<T> {
-    move|_to: &mut T|{ todo!() }
-}
-fn w_fill <N: Coord, T: Screen<Unit = N>> (_c: impl Draw<T>) -> impl Draw<T> {
-    move|_to: &mut T|{ todo!() }
-}
-fn w_min <N: Coord, T: Screen<Unit = N>> (w: N, x: impl Draw<T>) -> impl Draw<T> {
-    min(Some(w), None, x)
-}
-fn w_max <N: Coord, T> (w: N, x: impl Draw<T>) -> impl Draw<T> {
-    max(Some(w), None, x)
-}
-
-/// Something that has length along vertical axis.
-pub trait H<N: Coord> {
-    fn h (&self) -> N { N::zero() }
-    fn h_min (&self) -> N { self.h() }
-    fn h_max (&self) -> N { self.h() }
-}
-fn h_exact <N: Coord, T: Screen<Unit = N>> (_h: N, _c: impl Draw<T>) -> impl Draw<T> {
-    move|_to: &mut T|{ todo!() }
-}
-fn h_fill <N: Coord, T: Screen<Unit = N>> (_c: impl Draw<T>) -> impl Draw<T> {
-    move|_to: &mut T|{ todo!() }
-}
-fn h_min <N: Coord, T: Screen<Unit = N>> (h: N, x: impl Draw<T>) -> impl Draw<T> {
-    min(None, Some(h), x)
-}
-fn h_max <N: Coord, T> (h: N, x: impl Draw<T>) -> impl Draw<T> {
-    max(None, Some(h), x)
 }
 
 /// Something that has a [Measure] of its rendered size.
 pub trait Measured <N: Coord> {}
 
-/// Point along (X, Y).
-pub trait Point<N: Coord>: X<N> + Y<N> {
-    fn xy (&self) -> XY<N> { XY(self.x(), self.y()) }
-}
-
-/// Something that has `[0, 0]` at a particular point.
-pub trait Anchored { fn anchor (&self) -> Align; }
-
 /// Something that has a bounding box
 ///
 /// ```
 /// use tengri::{Bounded, XYWH};
 /// let bounded: Bounded<tengri::Tui, _> = Bounded(0, 0 ,0 ,0 ,"");
 /// ```
-pub trait Bounding <N: Coord>: Point<N> + Area<N> + Anchored {
-    /// Iterate over every covered X coordinate.
-    fn iter_x (&self) -> impl Iterator<Item = N> where N: std::iter::Step {
-        self.x_left()..self.x_right()
-    }
-    /// Iterate over every covered Y coordinate.
-    fn iter_y (&self) -> impl Iterator<Item = N> where N: std::iter::Step {
-        self.y_top()..self.y_bottom()
-    }
-    fn x_left (&self) -> N {
-        use Align::*;
-        let w = self.w();
-        let a = self.anchor();
-        let d = match a { NW|W|SW => 0.into(), N|X|C|Y|S => w/2.into(), NE|E|SE => w };
-        self.x().minus(d)
-    }
-    fn x_right  (&self) -> N {
-        use Align::*;
-        let w = self.w();
-        let a = self.anchor();
-        let d = match a { NW|W|SW => w, N|X|C|Y|S => w/2.into(), NE|E|SE => 0.into() };
-        self.x().plus(d)
-    }
-    fn y_top    (&self) -> N {
-        use Align::*;
-        let a = self.anchor();
-        let h = self.h();
-        let d = match a { NW|N|NE => 0.into(), W|X|C|Y|E => h/2.into(), SW|S|SE => h };
-        self.y().minus(d)
-    }
-    fn y_bottom (&self) -> N {
-        use Align::*;
-        let a = self.anchor();
-        let h = self.h();
-        let d = match a { NW|N|NE => h, W|X|C|Y|E => h/2.into(), SW|S|SE => 0.into() };
-        self.y().plus(d)
-    }
+pub trait Bounding <N: Coord>: HasXY<N> + HasWH<N> + HasOrigin {
 }
 
-/// A cardinal direction.
-///
-/// ```
-/// let direction = tengri::Direction::Above;
-/// ```
-#[cfg_attr(test, derive(Arbitrary))]
-#[derive(Copy, Clone, PartialEq, Debug)] pub enum Direction {
-    North, South, East, West, Above, Below
-}
-
-/// A numeric type that can be used as coordinate.
-///
-/// FIXME: Replace with `num` crate?
-/// FIXME: Use AsRef/AsMut?
-pub trait Coord: Send + Sync + Copy
-    + Add<Self, Output=Self>
-    + Sub<Self, Output=Self>
-    + Mul<Self, Output=Self>
-    + Div<Self, Output=Self>
-    + Ord + PartialEq + Eq
-    + Debug + Display + Default
-    + From<u16> + Into<u16>
-    + Into<usize>
-    + Into<f64>
-{
-    fn zero   () -> Self { 0.into() }
-    fn plus   (self, other: Self) -> Self;
-    /// Saturating subtraction
-    fn minus  (self, other: Self) -> Self { if self >= other { self - other } else { 0.into() } }
-    fn atomic (self) -> AtomicUsize { AtomicUsize::new(self.into()) }
-}
-
-/// Point along horizontal axis.
-pub trait X<N: Coord> {
-    fn x (&self) -> N { N::zero() }
-    fn push <T> (a: impl Draw<T>) -> impl Draw<T> { a }
-    fn pull <T> (a: impl Draw<T>) -> impl Draw<T> { a }
-}
-
-/// Point along vertical axis.
-pub trait Y<N: Coord> {
-    fn y (&self) -> N { N::zero() }
-    fn push <T> (a: impl Draw<T>) -> impl Draw<T> { a }
-    fn pull <T> (a: impl Draw<T>) -> impl Draw<T> { a }
-}
-
-
 //impl<O: Screen, T: Draw<O>> Draw<O> for Bounded<O, T> {
     //fn draw (&self, to: &mut O) {
         //let area = to.area();
@@ -270,296 +573,4 @@ pub trait Y<N: Coord> {
     //}
 //}
 
-/// A point (X, Y).
-///
-/// ```
-/// let xy = tengri::XY(0u16, 0);
-/// ```
-#[cfg_attr(test, derive(Arbitrary))]
-#[derive(Copy, Clone, Debug, Default, PartialEq)]
-pub struct XY<C: Coord>(pub C, pub C);
-impl<N: Coord> X<N> for XY<N> { fn x (&self) -> N { self.0 } }
-impl<N: Coord> Y<N> for XY<N> { fn y (&self) -> N { self.1 } }
-
-/// A size (Width, Height).
-///
-/// ```
-/// let wh = tengri::WH(0u16, 0);
-/// ```
-#[cfg_attr(test, derive(Arbitrary))]
-#[derive(Copy, Clone, Debug, Default, PartialEq)]
-pub struct WH<C: Coord>(pub C, pub C);
-impl<N: Coord> W<N> for WH<N> { fn w (&self) -> N { self.0 } }
-impl<N: Coord> H<N> for WH<N> { fn h (&self) -> N { self.1 } }
-impl<N: Coord> WH<N> {
-    fn min <T: Screen<Unit = N>> (&self, x: impl Draw<T>) -> impl Draw<T> {
-        min(Some(self.w()), Some(self.h()), x)
-    }
-    fn exact <T: Screen<Unit = N>> (&self, c: impl Draw<T>) -> impl Draw<T> {
-        move|_to: &mut T|{ todo!() }
-    }
-    fn fill <T: Screen<Unit = N>> (c: impl Draw<T>) -> impl Draw<T> {
-        move|_to: &mut T|{ todo!() }
-    }
-}
-
-/// Point with size.
-///
-/// ```
-/// let xywh = tengri::XYWH(0u16, 0, 0, 0);
-/// assert_eq!(tengri::XYWH(10u16, 10, 20, 20).center(), tengri::XY(20, 20));
-/// ```
-///
-/// * [ ] TODO: anchor field (determines at which corner/side is X0 Y0)
-///
-#[cfg_attr(test, derive(Arbitrary))]
-#[derive(Copy, Clone, Debug, Default, PartialEq)] pub struct XYWH<C: Coord>(
-    pub C, pub C, pub C, pub C
-);
-impl<N: Coord> X<N> for XYWH<N> { fn x (&self) -> N { self.0 } }
-impl<N: Coord> Y<N> for XYWH<N> { fn y (&self) -> N { self.1 } }
-impl<N: Coord> W<N> for XYWH<N> { fn w (&self) -> N { self.0 } }
-impl<N: Coord> H<N> for XYWH<N> { fn h (&self) -> N { self.1 } }
-
-impl<N: Coord> XYWH<N> {
-    pub fn zero () -> Self {
-        Self(0.into(), 0.into(), 0.into(), 0.into())
-    }
-    pub fn clipped_w (&self, w: N) -> XYWH<N> {
-        Self(self.x(), self.y(), self.w().min(w), self.h())
-    }
-    pub fn clipped_h (&self, h: N) -> XYWH<N> {
-        Self(self.x(), self.y(), self.w(), self.h().min(h))
-    }
-    pub fn clipped (&self, wh: WH<N>) -> XYWH<N> {
-        Self(self.x(), self.y(), wh.w(), wh.h())
-    }
-    pub fn center (&self) -> XY<N> {
-        XY(self.x().plus(self.w()/2.into()), self.y().plus(self.h()/2.into()))
-    }
-    pub fn centered (&self) -> XY<N> {
-        let Self(x, y, w, h) = *self;
-        XY(x.minus(w/2.into()), y.minus(h/2.into()))
-    }
-    pub fn centered_x (&self, n: N) -> XYWH<N> {
-        let Self(x, y, w, h) = *self;
-        XYWH((x.plus(w / 2.into())).minus(n / 2.into()), y.plus(h / 2.into()), n, 1.into())
-    }
-    pub fn centered_y (&self, n: N) -> XYWH<N> {
-        let Self(x, y, w, h) = *self;
-        XYWH(x.plus(w / 2.into()), (y.plus(h / 2.into())).minus(n / 2.into()), 1.into(), n)
-    }
-    pub fn centered_xy (&self, [n, m]: [N;2]) -> XYWH<N> {
-        let Self(x, y, w, h) = *self;
-        XYWH((x.plus(w / 2.into())).minus(n / 2.into()), (y.plus(h / 2.into())).minus(m / 2.into()), n, m)
-    }
-}
-
-
-/// Set maximum width and/or height of drawing area.
-pub fn clip <T: Screen<Unit = N>, N: Coord> (w: Option<N>, h: Option<N>, draw: impl Draw<T>) -> impl Draw<T> {
-    move|to: &mut T|draw.draw(to.clipped_mut(w, h))
-}
-
-/// Shrink drawing area symmetrically.
-pub fn pad <T: Screen<Unit = N>, N: Coord> (w: N, h: N, draw: impl Draw<T>) -> impl Draw<T> {
-    move|to: &mut T|draw.draw(to.padded_mut(w, h))
-}
-pub fn pad_x <T: Screen<Unit = N>, N: Coord> (w: N, draw: impl Draw<T>) -> impl Draw<T> {
-    pad(w, N::zero(), draw)
-}
-pub fn pad_y <T: Screen<Unit = N>, N: Coord> (h: N, draw: impl Draw<T>) -> impl Draw<T> {
-    pad(N::zero(), h, draw)
-}
-pub fn pad_xy <T: Screen<Unit = N>, N: Coord> (p: N, draw: impl Draw<T>) -> impl Draw<T> {
-    pad(p, p, draw)
-}
-
-/// 9th of area to place.
-///
-/// ```
-/// let alignment = tengri::Align::C;
-/// use ::tengri::*;
-/// let area = XYWH(10u16, 10, 20, 20);
-/// fn test (area: XYWH<u16>, item: &impl Draw<Tui>, expected: [u16;4]) {
-///     //assert_eq!(Lay::layout(item, area), expected);
-///     //assert_eq!(Draw::layout(item, area),  expected);
-/// };
-/// 
-/// let four = exact_xy(4, 4, "foo");
-/// test(area, &Align::nw(four()), [10, 10, 4, 4]);
-/// test(area, &Align::n(four()),  [18, 10, 4, 4]);
-/// test(area, &Align::ne(four()), [26, 10, 4, 4]);
-/// test(area, &Align::e(four()),  [26, 18, 4, 4]);
-/// test(area, &Align::se(four()), [26, 26, 4, 4]);
-/// test(area, &Align::s(four()),  [18, 26, 4, 4]);
-/// test(area, &Align::sw(four()), [10, 26, 4, 4]);
-/// test(area, &Align::w(four()),  [10, 18, 4, 4]);
-/// 
-/// let two_by_four = exact_xy(4, 2, "foo");
-/// test(area, &Align::nw(two_by_four()), [10, 10, 4, 2]);
-/// test(area, &Align::n(two_by_four()),  [18, 10, 4, 2]);
-/// test(area, &Align::ne(two_by_four()), [26, 10, 4, 2]);
-/// test(area, &Align::e(two_by_four()),  [26, 19, 4, 2]);
-/// test(area, &Align::se(two_by_four()), [26, 28, 4, 2]);
-/// test(area, &Align::s(two_by_four()),  [18, 28, 4, 2]);
-/// test(area, &Align::sw(two_by_four()), [10, 28, 4, 2]);
-/// test(area, &Align::w(two_by_four()),  [10, 19, 4, 2]);
-/// pub struct Align<T>(pub Align, pub T);
-/// ```
-#[cfg_attr(test, derive(Arbitrary))]
-#[derive(Debug, Copy, Clone, Default)] pub enum Align {
-    #[default] C, X, Y, NW, N, NE, E, SE, S, SW, W
-}
-pub trait Aligned {
-    fn aligned (&mut self, align: Align) -> &mut Self;
-}
-/// Set 0, 0 of drawing subarea.
-pub fn align <T: Aligned> (alignment: Align, draw: impl Draw<T>) -> impl Draw<T> {
-    move|to: &mut T|draw.draw(to.aligned(alignment))
-}
-impl Align {
-    pub fn n  <T: Aligned> (x: impl Draw<T>) -> impl Draw<T> { align(Align::N,  x) }
-    pub fn s  <T: Aligned> (x: impl Draw<T>) -> impl Draw<T> { align(Align::S,  x) }
-    pub fn e  <T: Aligned> (x: impl Draw<T>) -> impl Draw<T> { align(Align::E,  x) }
-    pub fn w  <T: Aligned> (x: impl Draw<T>) -> impl Draw<T> { align(Align::W,  x) }
-    pub fn nw <T: Aligned> (x: impl Draw<T>) -> impl Draw<T> { align(Align::NW, x) }
-    pub fn ne <T: Aligned> (x: impl Draw<T>) -> impl Draw<T> { align(Align::NE, x) }
-    pub fn sw <T: Aligned> (x: impl Draw<T>) -> impl Draw<T> { align(Align::SW, x) }
-    pub fn se <T: Aligned> (x: impl Draw<T>) -> impl Draw<T> { align(Align::SE, x) }
-    pub fn c  <T: Aligned> (x: impl Draw<T>) -> impl Draw<T> { align(Align::C,  x) }
-}
-
-/// Only draw content if area is above a certain size.
-///
-/// ```
-/// let minimum = tengri::min_wh(3, 5, "Hello"); // 5x5
-/// ```
-pub fn min <T, N: Coord> (w: Option<N>, h: Option<N>, draw: impl Draw<T>) -> impl Draw<T> {
-    move|to: &mut T| { todo!() }//draw.draw(to.min(w, h))
-}
-
-/// Set the maximum width and/or height of the content.
-///
-/// ```
-/// let maximum = tengri::max_wh(3, 5, "Hello"); // 3x1
-/// ```
-pub fn max <T, N: Coord> (w: Option<N>, h: Option<N>, draw: impl Draw<T>) -> impl Draw<T> {
-    move|to: &mut T| { todo!() }// { todo!() }//draw.draw(to.max(w, h))
-}
-
-// pub fn displace ... 
-
-pub fn iter <T, U: Draw<T>, F: Fn(U)->dyn Draw<T>> (
-    _items: impl Iterator<Item = U>, _cb: F
-) -> impl Draw<T> {
-    move|_to: &mut T|{ todo!() }
-}
-
-/// Split screen between two items, or layer them atop each other.
-///
-/// ```
-/// use tengri::Direction::*;
-/// let _ = tengri::draw::bsp(Above, (), ());
-/// let _ = tengri::draw::bsp(Below, (), ());
-/// let _ = tengri::draw::bsp(North, (), ());
-/// let _ = tengri::draw::bsp(South, (), ());
-/// let _ = tengri::draw::bsp(East,  (), ());
-/// let _ = tengri::draw::bsp(West,  (), ());
-/// ```
-pub fn bsp <T> (_dir: Direction, a: impl Draw<T>, b: impl Draw<T>) -> impl Draw<T> {
-    move|_to: &mut T|{ todo!() }
-}
-pub fn bsp_n <T> (a: impl Draw<T>, b: impl Draw<T>) -> impl Draw<T> {
-    bsp(Direction::North, a, b)
-}
-pub fn bsp_s <T> (a: impl Draw<T>, b: impl Draw<T>) -> impl Draw<T> {
-    bsp(Direction::South, a, b)
-}
-pub fn bsp_e <T> (a: impl Draw<T>, b: impl Draw<T>) -> impl Draw<T> {
-    bsp(Direction::East, a, b)
-}
-pub fn bsp_w <T> (a: impl Draw<T>, b: impl Draw<T>) -> impl Draw<T> {
-    bsp(Direction::West, a, b)
-}
-pub fn bsp_a <T> (a: impl Draw<T>, b: impl Draw<T>) -> impl Draw<T> {
-    bsp(Direction::Above, a, b)
-}
-pub fn bsp_b <T> (a: impl Draw<T>, b: impl Draw<T>) -> impl Draw<T> {
-    bsp(Direction::Below, a, b)
-}
-
-/// Clear a pre-allocated buffer, then write into it.
-#[macro_export] macro_rules! rewrite {
-    ($buf:ident, $($rest:tt)*) => { |$buf,_,_|{ $buf.clear(); write!($buf, $($rest)*) } }
-}
-
-/// FIXME: This macro should be some variant of `eval`, too.
-/// But taking into account the different signatures (resolving them into 1?)
-#[cfg(feature = "lang")] #[macro_export] macro_rules! draw {
-    ($State:ident: $Output:ident: $layers:expr) => {
-        impl Draw<$Output> for $State {
-            fn draw (&self, to: &mut $Output) {
-                for layer in $layers { layer(self, to) }
-            }
-        }
-    }
-}
-
-/// FIXME: This is generic: should be called `eval` and be part of [dizzle].
-#[cfg(feature = "lang")] #[macro_export] macro_rules! view {
-    ($State:ident: $Output:ident: $namespaces:expr) => {
-        impl Understand<$Output, ()> for $State {
-            fn understand_expr <'a> (&'a self, to: &mut $Output, expr: &'a impl Expression) -> Usually<()> {
-                for namespace in $namespaces { if namespace(self, to, expr)? { return Ok(()) } }
-                Err(format!("{}::<{}, ()>::understand_expr: unexpected: {expr:?}",
-                    stringify! { $State  },
-                    stringify! { $Output }).into())
-            }
-        }
-    }
-}
-
-/// Stack things on top of each other,
-#[macro_export] macro_rules! lay (($($expr:expr),* $(,)?) => {{
-    let bsp = (); $(let bsp = bsp_b(bsp, $expr);)* bsp
-}});
-
-/// Stack southward.
-#[macro_export] macro_rules! col (($($expr:expr),* $(,)?) => {{
-    let bsp = (); $(let bsp = bsp_s(bsp, $expr);)* bsp
-}});
-
-/// Stack northward.
-#[macro_export] macro_rules! col_up (($($expr:expr),* $(,)?) => {{
-    let bsp = (); $(let bsp = bsp_n(bsp, $expr);)* bsp
-}});
-
-/// Stack eastward.
-#[macro_export] macro_rules! row (($($expr:expr),* $(,)?) => {{
-    let bsp = (); $(let bsp = bsp_e(bsp, $expr);)* bsp
-}});
-
-/// Memoize a rendering.
-///
-/// ```
-/// let _ = tengri::Memo::new((), ());
-/// ```
-#[derive(Debug, Default)] pub struct Memo<T, U> {
-    pub value: T,
-    pub view: Arc<RwLock<U>>
-}
-
-impl<T: PartialEq, U> Memo<T, U> {
-    pub fn new (value: T, view: U) -> Self {
-        Self { value, view: Arc::new(view.into()) }
-    }
-    pub fn update <R> (&mut self, newval: T, draw: impl Fn(&mut U, &T, &T)->R) -> Option<R> {
-        if newval != self.value {
-            let result = draw(&mut*self.view.write().unwrap(), &newval, &self.value);
-            self.value = newval;
-            return Some(result);
-        }
-        None
-    }
-}
+// pub fn displace ...
diff --git a/src/term.rs b/src/term.rs
index d88cc8c..809ec2c 100644
--- a/src/term.rs
+++ b/src/term.rs
@@ -1,4 +1,4 @@
-use crate::{*, lang::*, play::*, draw::*, color::*, text::*};
+use crate::{*, lang::*, play::*, draw::{*, Split::*}, color::*, text::*};
 use unicode_width::{UnicodeWidthStr, UnicodeWidthChar};
 use rand::distributions::uniform::UniformSampler;
 use ::{
@@ -8,149 +8,140 @@ use ::{
     },
     better_panic::{Settings, Verbosity},
     ratatui::{
-        prelude::{Color, Style, Buffer, Position, Backend},
+        prelude::{Style, Buffer as ScreenBuffer, Position, Backend, Color},
         style::{Modifier, Color::*},
         backend::{CrosstermBackend, ClearType},
         layout::{Size, Rect},
-        buffer::Cell
+        buffer::{Buffer, Cell},
     },
     crossterm::{
+        ExecutableCommand,
         terminal::{EnterAlternateScreen, LeaveAlternateScreen, enable_raw_mode, disable_raw_mode},
         event::{poll, read, Event, KeyEvent, KeyCode, KeyModifiers, KeyEventKind, KeyEventState},
     }
 };
 
-/// Marker trait for structs that may be root of TUI app.
-pub trait Tui: Draw<Buffer> + Do<TuiEvent, Perhaps<TuiEvent>> {}
-
-/// `Tui` is automatically implemented.
-impl<T: Draw<Buffer> + Do<TuiEvent, Perhaps<TuiEvent>>> Tui for T {}
-
-/// Spawn the TUI input thread which reads keys from the terminal.
-pub fn tui_input <T: Act<TuiEvent, T> + Send + Sync + 'static> (
-    exited: &Arc<AtomicBool>, state: &Arc<RwLock<T>>, poll: Duration
-) -> Result<Thread, std::io::Error> {
-    let exited = exited.clone();
-    let state = state.clone();
-    Thread::new_poll(exited.clone(), poll, move |_| {
-        let event = read().unwrap();
-        match event {
-
-            // Hardcoded exit.
-            Event::Key(KeyEvent {
-                modifiers: KeyModifiers::CONTROL,
-                code:      KeyCode::Char('c'),
-                kind:      KeyEventKind::Press,
-                state:     KeyEventState::NONE
-            }) => { exited.store(true, Relaxed); },
-
-            // Handle all other events by the state:
-            _ => {
-                let event = TuiEvent::from_crossterm(event);
-                if let Err(e) = state.write().unwrap().handle(&event) {
-                    panic!("{e}")
-                }
-            }
+pub struct Tui(pub Buffer, pub XYWH<u16>);
+impl Screen for Tui { type Unit = u16; }
+impl HasX<u16> for Tui { fn x (&self) -> X<u16> { self.1.x() } }
+impl HasY<u16> for Tui { fn y (&self) -> Y<u16> { self.1.y() } }
+impl HasW<u16> for Tui { fn w (&self) -> W<u16> { self.1.w() } }
+impl HasH<u16> for Tui { fn h (&self) -> H<u16> { self.1.h() } }
+impl HasOrigin for Tui { fn origin (&self) -> Origin { Origin::NW } }
+impl AsRef<Buffer> for Tui { fn as_ref (&self) -> &Buffer { &self.0 } }
+impl AsMut<Buffer> for Tui { fn as_mut (&mut self) -> &mut Buffer { &mut self.0 } }
+impl AsRef<XYWH<u16>> for Tui { fn as_ref (&self) -> &XYWH<u16> { &self.0 } }
+impl AsMut<XYWH<u16>> for Tui { fn as_mut (&mut self) -> &mut XYWH<u16> { &mut self.0 } }
+impl Tui {
+    fn update (&mut self, callback: &impl Fn(&mut Cell, u16, u16)) -> WH<u16> {
+        tui_update(self.0, self.1, callback);
+        self.1.wh()
+    }
+    fn tint_all (&mut self, fg: Color, bg: Color, modifier: Modifier) {
+        for cell in self.buffer().content.iter_mut() {
+            cell.fg = fg;
+            cell.bg = bg;
+            cell.modifier = modifier;
+        }
+    }
+    fn blit (&mut self, text: &impl AsRef<str>, x: u16, y: u16, style: Option<Style>) {
+        let text = text.as_ref();
+        let style = style.unwrap_or(Style::default());
+        let buf = self.buffer();
+        if x < buf.area.width && y < buf.area.height {
+            buf.set_string(x, y, text, style);
+        }
+    }
+}
+/// Apply foreground color.
+pub const fn fg (fg: Color, draw: impl Draw<Tui>) -> impl Draw<Tui> {
+    thunk(move|to: &mut Tui|{
+        to.update(&|cell,_,_|{ cell.set_fg(fg); });
+        draw.draw(to)
+    })
+}
+/// Apply background color.
+pub const fn bg (bg: Color, draw: impl Draw<Tui>) -> impl Draw<Tui> {
+    thunk(move|to: &mut Tui|{
+        to.update(&|cell,_,_|{ cell.set_bg(bg); });
+        draw.draw(to)
+    })
+}
+pub const fn fg_bg (fg: Color, bg: Color, draw: impl Draw<Tui>) -> impl Draw<Tui> {
+    thunk(move|to: &mut Tui|{
+        to.update(&|cell,_,_|{ cell.set_fg(fg); cell.set_bg(bg); });
+        draw.draw(to)
+    })
+}
+pub const fn fill_char (c: char) {
+    thunk(move|to: &mut Tui|Ok(to.update(&|cell,_,_|{
+        cell.set_char(c);
+    })))
+}
+/// Draw contents with modifier applied.
+pub const fn modify (on: bool, modifier: Modifier, draw: impl Draw<Tui>) -> impl Draw<Tui> {
+    thunk(move|to: &mut Tui|{
+        fill_mod(on, modifier).draw(to)?;
+        draw.draw(to)
+    })
+}
+pub const fn fill_mod (on: bool, modifier: Modifier) {
+    thunk(move|to: &mut Tui|{
+        if on {
+            to.update(&|cell,_,_|cell.modifier.insert(modifier))
+        } else {
+            to.update(&|cell,_,_|cell.modifier.remove(modifier))
+        }
+    })
+}
+/// Draw contents with bold modifier applied.
+pub const fn bold (on: bool, draw: impl Draw<Tui>) -> impl Draw<Tui> {
+    modify(on, Modifier::BOLD, draw)
+}
+pub const fn fill_ul (on: bool, color: Option<Color>) {
+    thunk(move|to: &mut Tui|{
+        if on {
+            to.update(&|cell,_,_|{
+                cell.modifier.insert(Modifier::UNDERLINED);
+                cell.underline_color = color;
+            })
+        } else {
+            to.update(&|cell,_,_|&|cell,_,_|{
+                cell.modifier.remove(Modifier::UNDERLINED);
+                cell.underline_color = Reset;
+            })
         }
     })
 }
 
-/// TUI input loop event.
-#[derive(Debug, Clone, Eq, PartialEq, PartialOrd)]
-pub struct TuiEvent(pub Event);
-impl_from!(TuiEvent: |e: Event| TuiEvent(e));
-impl_from!(TuiEvent: |c: char|  TuiEvent(Event::Key(KeyEvent::new(KeyCode::Char(c), KeyModifiers::NONE))));
-impl TuiEvent {
-    #[cfg(feature = "dsl")] pub fn from_dsl (dsl: impl Language) -> Perhaps<Self> {
-        Ok(TuiKey::from_dsl(dsl)?.to_crossterm().map(Self))
-    }
-}
-impl Ord for TuiEvent {
-    fn cmp (&self, other: &Self) -> std::cmp::Ordering {
-        self.partial_cmp(other)
-            .unwrap_or_else(||format!("{:?}", self).cmp(&format!("{other:?}"))) // FIXME perf
-    }
-}
-
-/// TUI key spec.
-#[derive(Debug, Clone, Eq, PartialEq, PartialOrd)]
-pub struct TuiKey(pub Option<KeyCode>, pub KeyModifiers);
-
-impl TuiKey {
-    const SPLIT: char = '/';
-    pub fn to_crossterm (&self) -> Option<Event> {
-        self.0.map(|code|Event::Key(KeyEvent {
-            code,
-            modifiers: self.1,
-            kind:  KeyEventKind::Press,
-            state: KeyEventState::NONE,
-        }))
-    }
-    pub fn named (token: &str) -> Option<KeyCode> {
-        use KeyCode::*;
-        Some(match token {
-            "up"                => Up,
-            "down"              => Down,
-            "left"              => Left,
-            "right"             => Right,
-            "esc"    | "escape" => Esc,
-            "enter"  | "return" => Enter,
-            "delete" | "del"    => Delete,
-            "backspace"         => Backspace,
-            "tab"               => Tab,
-            "space"             => Char(' '),
-            "comma"             => Char(','),
-            "period"            => Char('.'),
-            "plus"              => Char('+'),
-            "minus" | "dash"    => Char('-'),
-            "equal" | "equals"  => Char('='),
-            "underscore"        => Char('_'),
-            "backtick"          => Char('`'),
-            "lt"                => Char('<'),
-            "gt"                => Char('>'),
-            "cbopen"  | "openbrace"  => Char('{'),
-            "cbclose" | "closebrace" => Char('}'),
-            "bropen"  | "openbracket"  => Char('['),
-            "brclose" | "closebracket" => Char(']'),
-            "pgup" | "pageup"   => PageUp,
-            "pgdn" | "pagedown" => PageDown,
-            "f1"                => F(1),
-            "f2"                => F(2),
-            "f3"                => F(3),
-            "f4"                => F(4),
-            "f5"                => F(5),
-            "f6"                => F(6),
-            "f7"                => F(7),
-            "f8"                => F(8),
-            "f9"                => F(9),
-            "f10"               => F(10),
-            "f11"               => F(11),
-            "f12"               => F(12),
-            _ => return None,
-        })
-    }
-}
-
 /// TUI works in u16 coordinates.
-impl Coord for u16 { fn plus (self, other: Self) -> Self { self.saturating_add(other) } }
+impl Coord for u16 {
+    fn plus (self, other: Self) -> Self {
+        self.saturating_add(other)
+    }
+}
 
-impl Draw<Buffer> for u64 {
-    fn draw (&self, _to: &mut Buffer) { todo!() }
+impl Draw<Tui> for u64 {
+    fn draw (&self, _to: &mut Tui) -> Usually<WH<u16>> { todo!() }
 }
-impl Draw<Buffer> for f64 {
-    fn draw (&self, _to: &mut Buffer) { todo!() }
+impl Draw<Tui> for f64 {
+    fn draw (&self, _to: &mut Tui) -> Usually<WH<u16>> { todo!() }
 }
-impl Draw<Buffer> for &str {
-    fn draw (&self, to: &mut Buffer) {
+impl Draw<Tui> for &str {
+    fn draw (&self, to: &mut Tui) -> Usually<WH<u16>> {
         let XYWH(x, y, w, ..) = to.centered_xy([width_chars_max(to.w(), self), 1]);
         to.text(&self, x, y, w)
     }
 }
-impl Draw<Buffer> for String {
-    fn draw (&self, to: &mut Buffer) { self.as_str().draw(to) }
+impl Draw<Tui> for String {
+    fn draw (&self, to: &mut Tui) -> Usually<WH<u16>> {
+        self.as_str().draw(to)
+    }
 }
-impl Draw<Buffer> for Arc<str> {
-    fn draw (&self, to: &mut Buffer) { self.as_ref().draw(to) }
+impl Draw<Tui> for Arc<str> {
+    fn draw (&self, to: &mut Tui) -> Usually<WH<u16>> {
+        self.as_ref().draw(to)
+    }
 }
 
 mod phat {
@@ -158,12 +149,12 @@ mod phat {
     pub const LO: &'static str = "▄";
     pub const HI: &'static str = "▀";
     /// A phat line
-    pub fn lo (fg: Color, bg: Color) -> impl Draw<Buffer> {
-        H::fixed(1, Tui::fg_bg(fg, bg, X::repeat(self::phat::LO)))
+    pub fn lo (fg: Color, bg: Color) -> impl Draw<Tui> {
+        H::exact(1, fg_bg(fg, bg, x_repeat(self::phat::LO)))
     }
     /// A phat line
-    pub fn hi (fg: Color, bg: Color) -> impl Draw<Buffer> {
-        H::fixed(1, Tui::fg_bg(fg, bg, X::repeat(self::phat::HI)))
+    pub fn hi (fg: Color, bg: Color) -> impl Draw<Tui> {
+        H::exact(1, fg_bg(fg, bg, x_repeat(self::phat::HI)))
     }
 }
 
@@ -174,66 +165,71 @@ mod scroll {
     pub const ICON_INC_H: &[char] = &[' ', '🞂', ' '];
 }
 
-fn x_repeat (c: char) {
-    move|to: &mut Buffer|{
-        let XYWH(x, y, w, h) = to.area();
+pub const fn x_repeat (c: &str) -> impl Draw<Tui> {
+    thunk(move|to: &mut Tui|{
+        let XYWH(x, y, w, h) = to.xywh();
         for x in x..x+w {
-            if let Some(cell) = to.cell_mut(Position::from((x, y))) {
+            if let Some(cell) = to.0.cell_mut(Position::from((x, y))) {
                 cell.set_symbol(&c);
             }
         }
-    }
+        Ok(WH(w, 1))
+    })
 }
 
-fn y_repeat (c: char) {
-    move|to: &mut Buffer|{
-        let XYWH(x, y, w, h) = to.area();
+pub const fn y_repeat (c: &str) -> impl Draw<Tui> {
+    thunk(move|to: &mut Tui|{
+        let XYWH(x, y, w, h) = to.xywh();
         for y in y..y+h {
-            if let Some(cell) = to.cell_mut(Position::from((x, y))) {
+            if let Some(cell) = to.0.cell_mut(Position::from((x, y))) {
                 cell.set_symbol(&c);
             }
         }
-    }
+        Ok(WH(1, h))
+    })
 }
 
-fn xy_repeat (c: char) {
-    move|to: &mut Buffer|{
-        let XYWH(x, y, w, h) = to.area();
+pub const fn xy_repeat (c: &str) -> impl Draw<Tui> {
+    thunk(move|to: &mut Tui|{
+        let XYWH(x, y, w, h) = to.xywh();
         let a = c.len();
         for (_v, y) in (y..y+h).enumerate() {
             for (u, x) in (x..x+w).enumerate() {
-                if let Some(cell) = to.cell_mut(Position::from((x, y))) {
+                if let Some(cell) = to.0.cell_mut(Position::from((x, y))) {
                     let u = u % a;
                     cell.set_symbol(&c[u..u+1]);
                 }
             }
         }
-    }
+        Ok(WH(w, h))
+    })
 }
 
 /// ```
 /// let _ = tengri::button_2("", "", true);
 /// let _ = tengri::button_2("", "", false);
 /// ```
-pub fn button_2 <'a> (key: impl Draw<Buffer>, label: impl Draw<Buffer>, editing: bool) -> impl Draw<Buffer> {
-    Tui::bold(true, bsp_e(
-        Tui::fg_bg(Tui::orange(), Tui::g(0), bsp_e(Tui::fg(Tui::g(0), &"▐"), bsp_e(key, Tui::fg(Tui::g(96), &"▐")))),
-        when(!editing, Tui::fg_bg(Tui::g(255), Tui::g(96), label))))
+pub const fn button_2 <'a> (key: impl Draw<Tui>, label: impl Draw<Tui>, hide: bool) -> impl Draw<Tui> {
+    let c1 = tui_orange();
+    let c2 = tui_g(0);
+    let c3 = tui_g(96);
+    let c4 = tui_g(255);
+    bold(true, fg_bg(c1, c2, east(fg(c2, east(key, fg(c3, &"▐"))), when(!hide, fg_bg(c4, c3, label)))))
 }
 
 /// ```
 /// let _ = tengri::button_3("", "", "", true);
 /// let _ = tengri::button_3("", "", "", false);
 /// ```
-pub fn button_3 <'a> (
-    key: impl Draw<Buffer>, label: impl Draw<Buffer>, value: impl Draw<Buffer>, editing: bool,
-) -> impl Draw<Buffer> {
-    Tui::bold(true, bsp_e(
-        Tui::fg_bg(Tui::orange(), Tui::g(0),
-            bsp_e(Tui::fg(Tui::g(0), &"▐"), bsp_e(key, Tui::fg(if editing { Tui::g(128) } else { Tui::g(96) }, "▐")))),
-        bsp_e(
-            when(!editing, bsp_e(Tui::fg_bg(Tui::g(255), Tui::g(96), label), Tui::fg_bg(Tui::g(128), Tui::g(96), &"▐"),)),
-            bsp_e(Tui::fg_bg(Tui::g(224), Tui::g(128), value), Tui::fg_bg(Tui::g(128), Reset, &"▌"), ))))
+pub const fn button_3 <'a> (
+    key: impl Draw<Tui>, label: impl Draw<Tui>, value: impl Draw<Tui>, editing: bool,
+) -> impl Draw<Tui> {
+    bold(true, east(
+        fg_bg(tui_orange(), tui_g(0),
+            east(fg(tui_g(0), &"▐"), east(key, fg(if editing { tui_g(128) } else { tui_g(96) }, "▐")))),
+        east(
+            when(!editing, east(fg_bg(tui_g(255), tui_g(96), label), fg_bg(tui_g(128), tui_g(96), &"▐"),)),
+            east(fg_bg(tui_g(224), tui_g(128), value), fg_bg(tui_g(128), Reset, &"▌"), ))))
 }
 
 macro_rules! border {
@@ -255,9 +251,9 @@ macro_rules! border {
         }
         #[derive(Copy, Clone)] pub struct $T(pub bool, pub Style);
         //impl Layout<Tui> for $T {}
-        impl Draw<Buffer> for $T {
-            fn draw (&self, to: &mut Buffer) {
-                if self.enabled() { let _ = BorderStyle::draw(self, to); }
+        impl Draw<Tui> for $T {
+            fn draw (&self, to: &mut Tui) -> Usually<WH<u16>> {
+                when(self.enabled(), |to: &mut Tui|BorderStyle::draw(self, to)).draw(to)
             }
         }
     )+}
@@ -369,87 +365,7 @@ border! {
     }
 }
 
-pub trait TuiOut: Screen {
-    fn tui_out (&mut self) -> &mut Buffer;
-    fn update (&mut self, area: impl Area<u16>, callback: &impl Fn(&mut Cell, u16, u16)) {
-        tui_update(self.buffer(), area, callback);
-    }
-    fn fill_char (&mut self, area: impl Area<u16>, c: char) {
-        self.update(area, &|cell,_,_|{cell.set_char(c);})
-    }
-    fn fill_bg (&mut self, area: impl Area<u16>, color: Color) {
-        self.update(area, &|cell,_,_|{cell.set_bg(color);})
-    }
-    fn fill_fg (&mut self, area: impl Area<u16>, color: Color) {
-        self.update(area, &|cell,_,_|{cell.set_fg(color);})
-    }
-    fn fill_mod (&mut self, area: impl Area<u16>, on: bool, modifier: Modifier) {
-        if on {
-            self.update(area, &|cell,_,_|cell.modifier.insert(modifier))
-        } else {
-            self.update(area, &|cell,_,_|cell.modifier.remove(modifier))
-        }
-    }
-    fn fill_bold (&mut self, area: impl Area<u16>, on: bool) {
-        self.fill_mod(area, on, Modifier::BOLD)
-    }
-    fn fill_reversed (&mut self, area: impl Area<u16>, on: bool) {
-        self.fill_mod(area, on, Modifier::REVERSED)
-    }
-    fn fill_crossed_out (&mut self, area: impl Area<u16>, on: bool) {
-        self.fill_mod(area, on, Modifier::CROSSED_OUT)
-    }
-    fn fill_ul (&mut self, area: impl Area<u16>, color: Option<Color>) {
-        if let Some(color) = color {
-            self.update(area, &|cell,_,_|{
-                cell.modifier.insert(ratatui::prelude::Modifier::UNDERLINED);
-                cell.underline_color = color;
-            })
-        } else {
-            self.update(area, &|cell,_,_|{
-                cell.modifier.remove(ratatui::prelude::Modifier::UNDERLINED);
-            })
-        }
-    }
-    fn tint_all (&mut self, fg: Color, bg: Color, modifier: Modifier) {
-        for cell in self.buffer().content.iter_mut() {
-            cell.fg = fg;
-            cell.bg = bg;
-            cell.modifier = modifier;
-        }
-    }
-    fn blit (&mut self, text: &impl AsRef<str>, x: u16, y: u16, style: Option<Style>) {
-        let text = text.as_ref();
-        let style = style.unwrap_or(Style::default());
-        let buf = self.buffer();
-        if x < buf.area.width && y < buf.area.height {
-            buf.set_string(x, y, text, style);
-        }
-    }
-    /// Write a line of text
-    ///
-    /// TODO: do a paragraph (handle newlines)
-    fn text (&mut self, text: &impl AsRef<str>, x0: u16, y: u16, max_width: u16) {
-        let text = text.as_ref();
-        let buf = self.buffer();
-        let mut string_width: u16 = 0;
-        for character in text.chars() {
-            let x = x0 + string_width;
-            let character_width = character.width().unwrap_or(0) as u16;
-            string_width += character_width;
-            if string_width > max_width {
-                break
-            }
-            if let Some(cell) = buf.write().unwrap().cell_mut(ratatui::prelude::Position { x, y }) {
-                cell.set_char(character);
-            } else {
-                break
-            }
-        }
-    }
-}
-
-pub trait BorderStyle: Draw<Buffer> + Copy {
+pub trait BorderStyle: Draw<Tui> + Copy {
     fn enabled   (&self) -> bool;
     fn border_n  (&self) -> &str { Self::N  }
     fn border_s  (&self) -> &str { Self::S  }
@@ -460,17 +376,17 @@ pub trait BorderStyle: Draw<Buffer> + Copy {
     fn border_sw (&self) -> &str { Self::SW }
     fn border_se (&self) -> &str { Self::SE }
 
-    fn enclose (self, w: impl Draw<Buffer>) -> impl Draw<Buffer> {
-        bsp_b(XY::fill(border(self.enabled(), self)), w)
+    fn enclose (self, w: impl Draw<Tui>) -> impl Draw<Tui> {
+        below(WH::fill(border(self.enabled(), self)), w)
     }
-    fn enclose2 (self, w: impl Draw<Buffer>) -> impl Draw<Buffer> {
-        bsp_b(XY::pad(1, 1, XY::fill(border(self.enabled(), self))), w)
+    fn enclose2 (self, w: impl Draw<Tui>) -> impl Draw<Tui> {
+        below(WH::pad(1, 1, WH::fill(border(self.enabled(), self))), w)
     }
-    fn enclose_bg (self, w: impl Draw<Buffer>) -> impl Draw<Buffer> {
-        TuiOut::bg(self.style().unwrap().bg.unwrap_or(Color::Reset),
-            bsp_b(XY::fill(border(self.enabled(), self)), w))
+    fn enclose_bg (self, w: impl Draw<Tui>) -> impl Draw<Tui> {
+        Tui::bg(self.style().unwrap().bg.unwrap_or(Color::Reset),
+            below(WH::fill(border(self.enabled(), self)), w))
     }
-    #[inline] fn draw <'a> (&self, to: &mut impl TuiOut) -> Usually<()> {
+    #[inline] fn draw <'a> (&self, to: &mut impl Draw<Tui>) -> Usually<()> {
         if self.enabled() {
             self.draw_h(to, None)?;
             self.draw_v(to, None)?;
@@ -478,7 +394,7 @@ pub trait BorderStyle: Draw<Buffer> + Copy {
         }
         Ok(())
     }
-    #[inline] fn draw_h (&self, to: &mut impl TuiOut, style: Option<Style>) -> Usually<impl Area<u16>> {
+    #[inline] fn draw_h (&self, to: &mut impl Draw<Tui>, style: Option<Style>) -> Usually<XYWH<u16>> {
         let area = to.area();
         let style = style.or_else(||self.style_horizontal());
         let [x, x2, y, y2] = area.lrtb();
@@ -488,7 +404,7 @@ pub trait BorderStyle: Draw<Buffer> + Copy {
         }
         Ok(area)
     }
-    #[inline] fn draw_v (&self, to: &mut impl TuiOut, style: Option<Style>) -> Usually<impl Area<u16>> {
+    #[inline] fn draw_v (&self, to: &mut impl Draw<Tui>, style: Option<Style>) -> Usually<XYWH<u16>> {
         let area = to.area();
         let style = style.or_else(||self.style_vertical());
         let [x, x2, y, y2] = area.lrtb();
@@ -504,7 +420,7 @@ pub trait BorderStyle: Draw<Buffer> + Copy {
         }
         Ok(area)
     }
-    #[inline] fn draw_c (&self, to: &mut impl TuiOut, style: Option<Style>) -> Usually<impl Area<u16>> {
+    #[inline] fn draw_c (&self, to: &mut impl Draw<Tui>, style: Option<Style>) -> Usually<XYWH<u16>> {
         let area = to.area();
         let style = style.or_else(||self.style_corners());
         let XYWH(x, y, w, h) = area;
@@ -541,15 +457,15 @@ pub trait BorderStyle: Draw<Buffer> + Copy {
 /// ```
 /// /// TODO
 /// ```
-pub fn phat <T, N: Coord> (w: N, h: N, [fg, bg, hi, lo]: [Color;4], draw: impl Tui) -> impl Tui {
+pub fn phat <T, N: Coord> (w: N, h: N, [fg, bg, hi, lo]: [Color;4], draw: impl Draw<Tui>) -> impl Draw<Tui> {
     let top = W::exact(1, self::phat::lo(bg, hi));
     let low = W::exact(1, self::phat::hi(bg, lo));
-    let draw = Tui::fg_bg(fg, bg, draw);
-    WH::min(w, h, bsp_s(top, bsp_n(low, WH::fill(draw))))
+    let draw = fg_bg(fg, bg, draw);
+    WH::min(w, h, south(top, north(low, WH::fill(draw))))
 }
 
 fn x_scroll () {
-    |to: &mut Buffer|{
+    |to: &mut Tui|{
         let XYWH(x1, y1, w, h) = to.area();
         let mut buf = to.buffer.write().unwrap();
         let x2 = x1 + w;
@@ -578,7 +494,7 @@ fn x_scroll () {
 }
 
 fn y_scroll () {
-    |to: &mut Buffer|{
+    |to: &mut Tui|{
         let XYWH(x1, y1, w, h) = to.area();
         let mut buf = to.buffer.write().unwrap();
         let y2 = y1 + h;
@@ -607,7 +523,7 @@ fn y_scroll () {
 }
 
 /// Spawn the TUI output thread which writes colored characters to the terminal.
-pub fn tui_output <W: Write, T: Draw<Buffer> + Send + Sync + 'static> (
+pub fn tui_output <W: Write, T: Draw<Tui> + Send + Sync + 'static> (
     output: W,
     exited: &Arc<AtomicBool>,
     state:  &Arc<RwLock<T>>,
@@ -645,7 +561,7 @@ pub fn tui_setup (output: &mut impl Write) -> Usually<()> {
 
 pub fn tui_resize <W: Write> (
     backend: &mut CrosstermBackend<W>,
-    buffer:  &mut Buffer,
+    buffer:  &mut Tui,
     size:    WH<u16>
 ) {
     if buffer.area != size {
@@ -675,14 +591,14 @@ pub fn tui_teardown <W: Write> (backend: &mut CrosstermBackend<W>) -> Usually<()
 }
 
 pub fn tui_update (
-    buf: &mut Buffer, area: XYWH<u16>, callback: &impl Fn(&mut Cell, u16, u16)
+    buf: &mut Tui, area: XYWH<u16>, callback: &impl Fn(&mut Cell, u16, u16)
 ) {
-    for row in 0..area.h() {
-        let y = area.y() + row;
-        for col in 0..area.w() {
+    for row in 0..area.h().0 {
+        let y = area.y().0 + row;
+        for col in 0..area.w().0 {
             let x = area.x() + col;
             if x < buf.area.width && y < buf.area.height {
-                if let Some(cell) = buf.cell_mut(ratatui::prelude::Position { x, y }) {
+                if let Some(cell) = buf.cell_mut(Position { x, y }) {
                     callback(cell, col, row);
                 }
             }
@@ -695,37 +611,14 @@ pub(crate) fn tui_wh <W: Write> (backend: &mut CrosstermBackend<W>) -> WH<u16> {
     WH(width, height)
 }
 
-/// Draw contents with foreground color applied.
-pub const fn fg (enabled: bool, color: Color, item: impl Tui) -> impl Tui {
-    |to: &mut Buffer|item.draw(to.with_fg(enabled, color))
-}
-
-/// Draw contents with background color applied.
-pub const fn bg (enabled: bool, color: Color, item: impl Tui) -> impl Tui {
-    |to: &mut Buffer|item.draw(to.with_bg(enabled, color))
-}
-
-/// Draw contents with modifier applied.
-pub const fn modify (enabled: bool, modifier: Modifier, item: impl Tui) -> impl Tui {
-    |to: &mut Buffer|item.draw(to.with_modifier(enabled, modifier, item))
-}
-
-pub const fn bold (enabled: bool, item: impl Tui) -> impl Tui {
-    modify(enabled, Modifier::BOLD, item)
-}
-
-/// Draw contents with style applied.
-pub const fn styled (enabled: bool, style: Style, item: impl Tui) -> impl Tui {
-    |to: &mut Buffer|item.draw(to.with_style(enabled, style, item))
-}
-
 /// Draw border around shrinked item.
 ///
 /// ```
 /// /// TODO
 /// ```
-pub const fn border <T, S: BorderStyle> (on: bool, style: S, draw: impl Tui) -> impl Tui {
-    WH::fill(bsp_a(when(on, |to: &mut Area|{
+pub const fn border <T, S: BorderStyle> (on: bool, style: S, draw: impl Draw<Tui>) -> impl Draw<Tui> {
+    let content = pad(Some(1), Some(1), draw);
+    let outline = when(on, |to: &mut Tui|{
         let area = to.area();
         if area.w() > 0 && area.y() > 0 {
             to.blit(&style.border_nw(), area.x(), area.y(), style.style());
@@ -741,7 +634,8 @@ pub const fn border <T, S: BorderStyle> (on: bool, style: S, draw: impl Tui) ->
                 to.blit(&style.border_e(), area.x() + area.w() - 1, y, style.style());
             }
         }
-    }), pad(Some(1), Some(1), draw)))
+    });
+    Above.split(outline, content)
 }
 
 /// Draw TUI content or its error message.
@@ -751,18 +645,18 @@ pub const fn border <T, S: BorderStyle> (on: bool, style: S, draw: impl Tui) ->
 /// let _ = tengri::tui::catcher(Ok(None));
 /// let _ = tengri::tui::catcher(Err("draw fail".into()));
 /// ```
-pub fn catcher <T, E> (error: Perhaps<E>, draw: impl Tui) -> impl Tui {
-    move|to: &mut Buffer|match error.as_ref() {
+pub fn catcher <T, E> (error: Usually<E>, draw: impl Draw<Tui>) -> impl Draw<Tui> {
+    thunk(move|to: &mut Tui|match error.as_ref() {
         Ok(Some(content)) => draw(to),
         Ok(None) => to.blit(&"<empty>", 0, 0, Some(Style::default().yellow())),
         Err(e) => {
             let err_fg = rgb(255,224,244);
             let err_bg = rgb(96, 24, 24);
-            let title  = bsp_e(bold(true, "upsi daisy. "), "rendering failed.");
-            let error  = bsp_e("\"why?\" ", bold(true, format!("{e}")));
-            &fg(err_fg, bg(err_bg, bsp_s(title, error)))(to)
+            let title  = east(bold(true, "upsi daisy. "), "rendering failed.");
+            let error  = east("\"why?\" ", bold(true, format!("{e}")));
+            &fg(err_fg, bg(err_bg, south(title, error)))(to)
         }
-    }
+    })
 }
 
 /// TUI buffer sized by `usize` instead of `u16`.
@@ -790,3 +684,141 @@ impl BigBuffer {
         y * self.width + x
     }
 }
+
+use self::colors::*; mod colors {
+    use ratatui::prelude::Color;
+    pub const fn tui_color_bg () -> Color { Color::Rgb(28, 35, 25) }
+    pub const fn tui_bg0 () -> Color { Color::Rgb(20, 20, 20) }
+    pub const fn tui_bo1 () -> Color { Color::Rgb(100, 110, 40) }
+    pub const fn tui_bo2 () -> Color { Color::Rgb(70, 80, 50) }
+    pub const fn tui_border_bg () -> Color { Color::Rgb(40, 50, 30) }
+    pub const fn tui_border_fg (f: bool) -> Color { if f { tui_bo1() } else { tui_bo2() } }
+    pub const fn tui_brown () -> Color { Color::Rgb(128,255,0) }
+    pub const fn tui_electric () -> Color { Color::Rgb(0,255,128) }
+    pub const fn tui_g (g: u8) -> Color { Color::Rgb(g, g, g) }
+    pub const fn tui_green () -> Color { Color::Rgb(0,255,0) }
+    pub const fn tui_mode_bg () -> Color { Color::Rgb(150, 160, 90) }
+    pub const fn tui_mode_fg () -> Color { Color::Rgb(255, 255, 255) }
+    pub const fn tui_null () -> Color { Color::Reset }
+    pub const fn tui_orange () -> Color { Color::Rgb(255,128,0) }
+    pub const fn tui_red () -> Color { Color::Rgb(255,0,  0) }
+    pub const fn tui_separator_fg (_: bool) -> Color { Color::Rgb(0, 0, 0) }
+    pub const fn tui_status_bar_bg () -> Color { Color::Rgb(28, 35, 25) }
+    pub const fn tui_ti1 () -> Color { Color::Rgb(150, 160, 90) }
+    pub const fn tui_ti2 () -> Color { Color::Rgb(120, 130, 100) }
+    pub const fn tui_title_fg (f: bool) -> Color { if f { tui_ti1() } else { tui_ti2() } }
+    pub const fn tui_yellow () -> Color { Color::Rgb(255,255,0) }
+}
+
+/// Spawn the TUI input thread which reads keys from the terminal.
+pub fn tui_input <T: Do<TuiEvent, T> + Send + Sync + 'static> (
+    exited: &Arc<AtomicBool>, state: &Arc<RwLock<T>>, poll: Duration
+) -> Result<Thread, std::io::Error> {
+    let exited = exited.clone();
+    let state = state.clone();
+    Thread::new_poll(exited.clone(), poll, move |_| {
+        let event = read().unwrap();
+        match event {
+
+            // Hardcoded exit.
+            Event::Key(KeyEvent {
+                modifiers: KeyModifiers::CONTROL,
+                code:      KeyCode::Char('c'),
+                kind:      KeyEventKind::Press,
+                state:     KeyEventState::NONE
+            }) => { exited.store(true, Relaxed); },
+
+            // Handle all other events by the state:
+            _ => {
+                let event = TuiEvent::from_crossterm(event);
+                if let Err(e) = state.write().unwrap().handle(&event) {
+                    panic!("{e}")
+                }
+            }
+        }
+    })
+}
+
+/// TUI input loop event.
+#[derive(Debug, Clone, Eq, PartialEq, PartialOrd)]
+pub struct TuiEvent(pub Event);
+
+impl_from!(TuiEvent: |e: Event| TuiEvent(e));
+impl_from!(TuiEvent: |c: char|  TuiEvent(Event::Key(KeyEvent::new(KeyCode::Char(c), KeyModifiers::NONE))));
+
+impl TuiEvent {
+    #[cfg(feature = "lang")]
+    pub fn from_dsl (dsl: impl Language) -> Usually<Self> {
+        Ok(TuiKey::from_dsl(dsl)?.to_crossterm().map(Self))
+    }
+}
+
+impl Ord for TuiEvent {
+    fn cmp (&self, other: &Self) -> std::cmp::Ordering {
+        self.partial_cmp(other)
+            .unwrap_or_else(||format!("{:?}", self).cmp(&format!("{other:?}"))) // FIXME perf
+    }
+}
+
+/// TUI key spec.
+#[derive(Debug, Clone, Eq, PartialEq, PartialOrd)]
+pub struct TuiKey(pub Option<KeyCode>, pub KeyModifiers);
+
+impl TuiKey {
+
+    const SPLIT: char = '/';
+
+    pub fn to_crossterm (&self) -> Option<Event> {
+        self.0.map(|code|Event::Key(KeyEvent {
+            code,
+            modifiers: self.1,
+            kind:  KeyEventKind::Press,
+            state: KeyEventState::NONE,
+        }))
+    }
+
+    pub fn named (token: &str) -> Option<KeyCode> {
+        use KeyCode::*;
+        Some(match token {
+            "up"                => Up,
+            "down"              => Down,
+            "left"              => Left,
+            "right"             => Right,
+            "esc"    | "escape" => Esc,
+            "enter"  | "return" => Enter,
+            "delete" | "del"    => Delete,
+            "backspace"         => Backspace,
+            "tab"               => Tab,
+            "space"             => Char(' '),
+            "comma"             => Char(','),
+            "period"            => Char('.'),
+            "plus"              => Char('+'),
+            "minus" | "dash"    => Char('-'),
+            "equal" | "equals"  => Char('='),
+            "underscore"        => Char('_'),
+            "backtick"          => Char('`'),
+            "lt"                => Char('<'),
+            "gt"                => Char('>'),
+            "cbopen"  | "openbrace"  => Char('{'),
+            "cbclose" | "closebrace" => Char('}'),
+            "bropen"  | "openbracket"  => Char('['),
+            "brclose" | "closebracket" => Char(']'),
+            "pgup" | "pageup"   => PageUp,
+            "pgdn" | "pagedown" => PageDown,
+            "f1"                => F(1),
+            "f2"                => F(2),
+            "f3"                => F(3),
+            "f4"                => F(4),
+            "f5"                => F(5),
+            "f6"                => F(6),
+            "f7"                => F(7),
+            "f8"                => F(8),
+            "f9"                => F(9),
+            "f10"               => F(10),
+            "f11"               => F(11),
+            "f12"               => F(12),
+            _ => return None,
+        })
+    }
+
+}
diff --git a/src/text.rs b/src/text.rs
index 4f4d6bf..d0a72a9 100644
--- a/src/text.rs
+++ b/src/text.rs
@@ -1,4 +1,4 @@
-use crate::draw::Draw;
+use crate::{Usually, draw::{Draw, WH}};
 pub(crate) use ::unicode_width::*;
 
 /// Displays an owned [str]-like with fixed maximum width.
@@ -46,37 +46,60 @@ pub(crate) fn width_chars_max (max: u16, text: impl AsRef<str>) -> u16 {
 #[cfg(feature = "term")] mod impl_term {
     use super::*;
     use crate::draw::XYWH;
-    use ratatui::prelude::{Buffer, Position};
-    impl<'a, T> Draw<Buffer> for TrimStringRef<'a, T> {
-        fn draw (&self, to: &mut Buffer) {
-            let XYWH(x, y, w, ..) = XYWH(to.x(), to.y(), to.w().min(self.0).min(self.1.as_ref().width() as u16), to.h());
-            to.text(&self, x, y, w)
-        }
+    use crate::term::Tui;
+    use ratatui::prelude::Position;
+
+    impl Draw<Tui> for str {
+        fn draw (&self, to: &mut Tui) -> Usually<WH<u16>> { todo!() }
     }
-    impl<T> Draw<Buffer> for TrimString<T> {
-        fn draw (&self, to: &mut Buffer) { self.as_ref().draw(to) }
+
+    impl<T: AsRef<str>> Draw<Tui> for TrimString<T> {
+        fn draw (&self, to: &mut Tui) -> Usually<WH<u16>> { self.as_ref().draw(to) }
     }
-    impl<'a, T: AsRef<str>> Draw<Buffer> for TrimString<T> {
-        fn draw (&self, to: &mut Buffer) { Draw::draw(&self.as_ref(), to) }
-    }
-    impl<T: AsRef<str>> Draw<Buffer> for TrimStringRef<'_, T> {
-        fn draw (&self, target: &mut Buffer) {
-            let area = target.area();
-            let mut buf = target.buffer.write().unwrap();
+
+    impl<T: AsRef<str>> Draw<Tui> for TrimStringRef<'_, T> {
+        fn draw (&self, to: &mut Tui) -> Usually<WH<u16>> {
+            let area = to.area();
             let mut width: u16 = 1;
             let mut chars = self.1.as_ref().chars();
             while let Some(c) = chars.next() {
                 if width > self.0 || width > area.w() {
                     break
                 }
-                if let Some(cell) = buf.cell_mut(Position {
-                    x: area.x() + width - 1,
-                    y: area.y()
-                }) {
+                let x = area.x() + width - 1;
+                let y = area.y();
+                let pos = Position { x, y };
+                if let Some(cell) = to.cell_mut(pos) {
                     cell.set_char(c);
                 }
                 width += c.width().unwrap_or(0) as u16;
             }
+            let XYWH(x, y, w, ..) = XYWH(to.x(), to.y(), to.w().min(self.0).min(self.1.as_ref().width() as u16), to.h());
+            to.text(&self, x, y, w)
+        }
+    }
+
+    impl Tui {
+        /// Write a line of text
+        ///
+        /// TODO: do a paragraph (handle newlines)
+        fn text (&mut self, text: &impl AsRef<str>, x0: u16, y: u16, max_width: u16) {
+            let text = text.as_ref();
+            let buf = self.buffer();
+            let mut string_width: u16 = 0;
+            for character in text.chars() {
+                let x = x0 + string_width;
+                let character_width = character.width().unwrap_or(0) as u16;
+                string_width += character_width;
+                if string_width > max_width {
+                    break
+                }
+                if let Some(cell) = buf.write().unwrap().cell_mut(ratatui::prelude::Position { x, y }) {
+                    cell.set_char(character);
+                } else {
+                    break
+                }
+            }
         }
     }
 }