From e0747124595d045d12136b264c8d30876c0ed8c5 Mon Sep 17 00:00:00 2001
From: i do not exist <donotem@ilme.no>
Date: Fri, 24 Apr 2026 01:34:43 +0300
Subject: [PATCH 01/25] fixes and refactors

- use macros for the evals
- move some space stuff into submodules
- partial update to doctests
---
 examples/tui_00.rs  |   2 +-
 src/draw.rs         |  30 +++---
 src/eval.rs         | 211 ++++++++++++++++++-------------------
 src/lib.rs          |  41 +++++---
 src/sing.rs         |   6 +-
 src/space.rs        | 247 ++------------------------------------------
 src/space/origin.rs | 100 ++++++++++++++++++
 src/space/split.rs  | 127 +++++++++++++++++++++++
 src/space/xywh.rs   |  80 ++++++++++++++
 9 files changed, 464 insertions(+), 380 deletions(-)
 create mode 100644 src/space/origin.rs
 create mode 100644 src/space/split.rs
 create mode 100644 src/space/xywh.rs

diff --git a/examples/tui_00.rs b/examples/tui_00.rs
index 730efa4..dc166b8 100644
--- a/examples/tui_00.rs
+++ b/examples/tui_00.rs
@@ -1,6 +1,6 @@
 use ::{
     std::{io::stdout, sync::{Arc, RwLock}},
-    tengri::{*, term::*, lang::*, keys::*, draw::*, space::*, dizzle::*},
+    tengri::{*, term::*, lang::*, keys::*, draw::*, space::*, lang::*},
     ratatui::style::Color,
 };
 
diff --git a/src/draw.rs b/src/draw.rs
index ad47922..98ad3ef 100644
--- a/src/draw.rs
+++ b/src/draw.rs
@@ -1,4 +1,4 @@
-use crate::{*, lang::*, color::*, space::*};
+use crate::{*, space::*};
 
 /// Drawable that supports dynamic dispatch.
 ///
@@ -13,12 +13,12 @@ use crate::{*, lang::*, color::*, space::*};
 /// a [Draw]able.
 /// 
 /// ```
-/// use tengri::draw::*;
+/// use tengri::{*, draw::*, space::*};
 /// struct TestScreen(bool);
 /// impl Screen for TestScreen { type Unit = u16; }
 /// struct TestWidget(bool);
 /// impl Draw<TestScreen> for TestWidget {
-///     fn draw (&self, screen: &mut T) -> Usually<XYWH<u16>> {
+///     fn draw (&self, screen: &mut TestScreen) -> Usually<XYWH<u16>> {
 ///         screen.0 |= self.0;
 ///     }
 /// }
@@ -31,12 +31,12 @@ pub trait Draw<T: Screen> {
     fn draw (self, to: &mut T) -> Usually<XYWH<T::Unit>>;
 }
 impl<T: Screen, D: Draw<T>> Draw<T> for &D {
-    fn draw (self, to: &mut T) -> Usually<XYWH<T::Unit>> {
+    fn draw (self, __: &mut T) -> Usually<XYWH<T::Unit>> {
         todo!()
     }
 }
 impl<T: Screen, D: Draw<T>> Draw<T> for Option<D> {
-    fn draw (self, to: &mut T) -> Usually<XYWH<T::Unit>> {
+    fn draw (self, __: &mut T) -> Usually<XYWH<T::Unit>> {
         todo!()
     }
 }
@@ -66,8 +66,9 @@ impl<T: Screen, F: FnOnce(&mut T)->Usually<XYWH<T::Unit>>> Draw<T> for Thunk<T,
 /// Only render when condition is true.
 ///
 /// ```
-/// # fn test () -> impl tengri::Draw<tengri::Tui> {
-///     tengri::when(true, "Yes")
+/// # use tengri::draw::*;
+/// # fn test () -> impl tengri::draw::Draw<tengri::term::Tui> {
+///     when(true, "Yes")
 /// # }
 /// ```
 pub const fn when <T: Screen> (condition: bool, draw: impl Draw<T>) -> impl Draw<T> {
@@ -77,8 +78,9 @@ pub const fn when <T: Screen> (condition: bool, draw: impl Draw<T>) -> impl Draw
 /// Render one thing if a condition is true and another false.
 ///
 /// ```
-/// # fn test () -> impl tengri::Draw<tengri::Tui> {
-///     tengri::either(true, "Yes", "No")
+/// # use tengri::draw::*;
+/// # fn test () -> impl tengri::draw::Draw<tengri::term::Tui> {
+///     either(true, "Yes", "No")
 /// # }
 /// ```
 pub const fn either <T: Screen> (condition: bool, a: impl Draw<T>, b: impl Draw<T>) -> impl Draw<T> {
@@ -88,13 +90,13 @@ pub const fn either <T: Screen> (condition: bool, a: impl Draw<T>, b: impl Draw<
 /// Output target.
 ///
 /// ```
-/// use tengri::*;
+/// use tengri::draw::*;
 ///
-/// struct TestOut(impl TwoD<u16>);
+/// struct TestOut<T: Screen<Unit = u16>>(T);
 ///
-/// impl Screen for TestOut {
+/// impl<T: Screen<Unit = u16>> Screen<T> for TestOut {
 ///     type Unit = u16;
-///     fn place_at <T: Draw<Self> + ?Sized> (&mut self, area: impl TwoD<u16>, _: &T) {
+///     fn place_at <D: Draw<Self> + ?Sized> (&mut self, area: T, _: D) {
 ///         println!("placed: {area:?}");
 ///         ()
 ///     }
@@ -114,7 +116,7 @@ pub trait Screen: Space<Self::Unit> + Send + Sync + Sized {
     }
     /// Render drawable in subarea specified by `area`
     fn place_at <'t, T: Draw<Self> + ?Sized> (
-        &mut self, area: XYWH<Self::Unit>, content: &'t T
+        &mut self, _area: XYWH<Self::Unit>, _content: &'t T
     ) {
         unimplemented!()
     }
diff --git a/src/eval.rs b/src/eval.rs
index 9cb0048..9e48051 100644
--- a/src/eval.rs
+++ b/src/eval.rs
@@ -1,10 +1,65 @@
-use crate::{*, term::*, draw::*, ratatui::prelude::*};
-use dizzle::*;
+use crate::{*, term::*, draw::*, space::*, lang::*, ratatui::prelude::*};
+
+/// Some layout operations exist in XY, X, and Y variants that take 3 or 2 arguments.
+/// Their handling in [eval_view] is uniform and goes like this:
+macro_rules! eval_xy ((
+    $name:expr, $expr:expr, $head:expr, $output:ident, $state:ident,
+    $variant:expr, $arg0: ident, $arg1: ident, $arg2: ident,
+    $xy:ident, $x:ident, $y:ident
+) => {{
+    let variant = $variant;
+    let cb = thunk(move|output: &mut O|$state.interpret(output, &match variant {
+        Some("x")  | Some("y") => $arg1,
+        Some("xy") | None => $arg2,
+        _ => panic!("{}: unsupported axis {variant:?}; try /x, /y, /xy", $name)
+    }));
+    match variant {
+        // XY variant (can be omitted)
+        Some("xy") | None => xy_push(
+            $state.namespace($arg0?)?.unwrap(),
+            $state.namespace($arg1?)?.unwrap(),
+            cb
+        ).draw($output),
+        // X variant
+        Some("x") => x_push(
+            $state.namespace($arg0?)?.unwrap(),
+            cb
+        ).draw($output),
+        // Y variant
+        Some("y") => y_push(
+            $state.namespace($arg0?)?.unwrap(),
+            cb
+        ).draw($output),
+        // Other namespace members are invalid
+        frag => {
+            let name = $name;
+            let expr = $expr;
+            let head = $head;
+            unimplemented!(
+                "{name}/{frag:?} ({expr:?}) ({head:?}) ({:?})",
+                head.src()?.unwrap_or_default().split("/").next()
+            )
+        }
+    }
+}});
+
+/// Some layout operations exist in multiple variants that take a single argument.
+/// Their handling in [eval_view] is uniform and goes like this:
+macro_rules! eval_enum ((
+    $name:literal, $output:ident, $state:ident, $value:expr, $arg0: ident, $Enum:ident {
+        $($v:literal => $V:ident),* $(,)?
+    }
+) => {{
+    match $value {
+        $(Some($v) => $Enum::$V,)*
+        frag => unimplemented!("{}/{frag:?}", $name)
+    }
+}});
 
 /// Interpret layout operation.
 ///
 /// ```
-/// # use tengri::*;
+/// # use tengri::{*, space::*};
 /// struct Target { xywh: XYWH<u16> /*platform-specific*/}
 /// impl tengri::Out for Target {
 ///     type Unit = u16;
@@ -27,137 +82,87 @@ use dizzle::*;
 /// // TODO test all
 /// # Ok(()) }
 /// ```
-#[cfg(feature = "dsl")] pub fn eval_view <'a, O: Screen + 'a, S> (
+pub fn eval_view <'a, O: Screen + 'a, S> (
     state: &S, output: &mut O, expr: &'a impl Expression
 ) -> Usually<bool> where
-    S: Interpret<O, ()>
-        + for<'b>Namespace<'b, bool>
-        + for<'b>Namespace<'b, O::Unit>
+    S: Interpret<O, XYWH<O::Unit>>
+        + for<'b> Namespace<'b, bool>
+        + for<'b> Namespace<'b, O::Unit>
+        + for<'b> Namespace<'b, Option<O::Unit>>
 {
-    // First element of expression is used for dispatch.
-    // Dispatch is proto-namespaced using separator character
+    // First element of expression is name of the operation.
+    // These are quasi-namespaced using the separator character, `/`.
     let head = expr.head()?;
     let mut frags = head.src()?.unwrap_or_default().split("/");
+
     // The rest of the tokens in the expr are arguments.
     // Their meanings depend on the dispatched operation
+    // Here we just reference them, so that they are in scope.
+    // Dereferencing them happens in the dispatch branch.
     let args  = expr.tail();
     let arg0  = args.head();
     let tail0 = args.tail();
     let arg1  = tail0.head();
     let tail1 = tail0.tail();
     let arg2  = tail1.head();
-    // And we also have to do the above binding dance
-    // so that the Perhaps<token>s remain in scope.
+
+    // First `frags.next()` calls returns the namespace.
     match frags.next() {
 
-        Some("when") => output.place(&when(
+        Some("when") => when(
             state.namespace(arg0?)?.unwrap(),
-            move|output: &mut O|state.interpret(output, &arg1)
-        )),
+            thunk(move|output: &mut O|state.interpret(output, &arg1))
+        ).draw(output),
 
-        Some("either") => output.place(&either(
+        Some("either") => either(
             state.namespace(arg0?)?.unwrap(),
-            move|output: &mut O|state.interpret(output, &arg1),
-            move|output: &mut O|state.interpret(output, &arg2),
-        )),
+            thunk(move|output: &mut O|state.interpret(output, &arg1)),
+            thunk(move|output: &mut O|state.interpret(output, &arg2)),
+        ).draw(output),
 
-        Some("bsp") => output.place(&{
-            let a = move|output: &mut O|state.interpret(output, &arg0);
-            let b = move|output: &mut O|state.interpret(output, &arg1);
-            bsp(match frags.next() {
-                Some("n") => Alignment::N,
-                Some("s") => Alignment::S,
-                Some("e") => Alignment::E,
-                Some("w") => Alignment::W,
-                Some("a") => Alignment::A,
-                Some("b") => Alignment::B,
-                frag => unimplemented!("bsp/{frag:?}")
-            }, a, b)
-        }),
-
-        Some("align") => output.place(&{
-            let a = move|output: &mut O|state.interpret(output, &arg0).unwrap();
-            align(match frags.next() {
-                Some("c") => Alignment::Center,
-                Some("n") => Alignment::N,
-                Some("s") => Alignment::S,
-                Some("e") => Alignment::E,
-                Some("w") => Alignment::W,
-                Some("x") => Alignment::X,
-                Some("y") => Alignment::Y,
-                frag => unimplemented!("align/{frag:?}")
-            }, a)
-        }),
-
-        Some("fill") => output.place(&{
-            let a = move|output: &mut O|state.interpret(output, &arg0).unwrap();
-            match frags.next() {
-                Some("xy") | None => fill_wh(a),
-                Some("x") => fill_w(a),
-                Some("y") => fill_h(a),
-                frag => unimplemented!("fill/{frag:?}")
+        // Second `frags.next()` calls returns the namespace member.
+        Some("bsp") => eval_enum!(
+            "bsp", output, state, frags.next(), arg0, Split {
+                "n" => North, "s" => South, "e" => East, "w" => West, "a" => Above, "b" => Below
             }
-        }),
+        ).half(
+            thunk(move|output: &mut O|state.interpret(output, &arg0)),
+            thunk(move|output: &mut O|state.interpret(output, &arg1)),
+        ).draw(output),
 
-        Some("exact") => output.place(&{
-            let axis = frags.next();
-            let arg  = match axis { Some("x") | Some("y") => arg1, Some("xy") | None => arg2, _ => panic!("exact: unsupported axis {axis:?}") };
-            let cb   = move|output: &mut O|state.interpret(output, &arg).unwrap();
-            match axis {
-                Some("xy") | None => exact_wh(state.namespace(arg0?)?.unwrap(), state.namespace(arg1?)?.unwrap(), cb),
-                Some("x") => exact_w(state.namespace(arg0?)?.unwrap(), cb),
-                Some("y") => exact_h(state.namespace(arg0?)?.unwrap(), cb),
-                frag => unimplemented!("exact/{frag:?} ({expr:?}) ({head:?}) ({:?})",
-                    head.src()?.unwrap_or_default().split("/").next())
+        Some("align") => eval_enum!(
+            "align", output, state, frags.next(), arg0, Origin {
+                "c" => C, "n" => N, "s" => S, "e" => E, "w" => W, "x" => X, "y" => Y
             }
-        }),
+        ).align(
+            thunk(move|output: &mut O|state.interpret(output, &arg0))
+        ).draw(output),
 
-        Some("min") => output.place(&{
-            let axis = frags.next();
-            let arg  = match axis { Some("x") | Some("y") => arg1, Some("xy") | None => arg2, _ => panic!("min: unsupported axis {axis:?}") };
-            let cb   = move|output: &mut O|state.interpret(output, &arg).unwrap();
-            match axis {
-                Some("xy") | None => min_wh(state.namespace(arg0?)?.unwrap(), state.namespace(arg1?)?.unwrap(), cb),
-                Some("x") => min_w(state.namespace(arg0?)?.unwrap(), cb),
-                Some("y") => min_h(state.namespace(arg0?)?.unwrap(), cb),
-                frag => unimplemented!("min/{frag:?}")
-            }
-        }),
-
-        Some("max") => output.place(&{
-            let axis = frags.next();
-            let arg  = match axis { Some("x") | Some("y") => arg1, Some("xy") | None => arg2, _ => panic!("max: unsupported axis {axis:?}") };
-            let cb   = move|output: &mut O|state.interpret(output, &arg).unwrap();
-            match axis {
-                Some("xy") | None => max_wh(state.namespace(arg0?)?.unwrap(), state.namespace(arg1?)?.unwrap(), cb),
-                Some("x") => max_w(state.namespace(arg0?)?.unwrap(), cb),
-                Some("y") => max_h(state.namespace(arg0?)?.unwrap(), cb),
-                frag => unimplemented!("max/{frag:?}")
-            }
-        }),
-
-        Some("push") => output.place(&{
-            let axis = frags.next();
-            let arg  = match axis { Some("x") | Some("y") => arg1, Some("xy") | None => arg2, _ => panic!("push: unsupported axis {axis:?}") };
-            let cb   = move|output: &mut O|state.interpret(output, &arg);
-            match axis {
-                Some("xy") | None => push_xy(state.namespace(arg0?)?.unwrap(), state.namespace(arg1?)?.unwrap(), cb),
-                Some("x") => push_x(state.namespace(arg0?)?.unwrap(), cb),
-                Some("y") => push_y(state.namespace(arg0?)?.unwrap(), cb),
-                frag => unimplemented!("push/{frag:?}")
-            }
-        }),
+        Some("exact") => eval_xy!(
+            "exact", expr, head, output, state, frags.next(), arg0, arg1, arg2, wh_exact, w_exact, h_exact
+        ),
+        Some("min")   => eval_xy!(
+            "min",   expr, head, output, state, frags.next(), arg0, arg1, arg2, wh_min,   w_min,   h_min
+        ),
+        Some("max")   => eval_xy!(
+            "max",   expr, head, output, state, frags.next(), arg0, arg1, arg2, wh_max,   w_max,   h_max
+        ),
+        Some("push")  => eval_xy!(
+            "push",  expr, head, output, state, frags.next(), arg0, arg1, arg2, xy_push,  x_push,  y_push
+        ),
 
         _ => return Ok(false)
 
-    };
+    }?;
+
     Ok(true)
 }
 
+
 /// Interpret TUI-specific layout operation.
 ///
 /// ```
-/// use tengri::{Namespace, Interpret, Tui, ratatui::prelude::Color};
+/// use tengri::{lang::{Namespace, Interpret}, term::Tui, ratatui::prelude::Color};
 ///
 /// struct State;
 /// impl<'b> Namespace<'b, bool>    for State {}
@@ -189,8 +194,6 @@ pub fn eval_view_tui <'a, S> (
     let arg0  = args.head();
     let tail0 = args.tail();
     let arg1  = tail0.head();
-    let tail1 = tail0.tail();
-    let arg2  = tail1.head();
     match frags.next() {
 
         Some("text") => {
diff --git a/src/lib.rs b/src/lib.rs
index e7d22ac..c7fe21d 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,18 +1,22 @@
 #![feature(anonymous_lifetime_in_impl_trait)]
-#![feature(associated_type_defaults)]
-#![feature(const_default)]
-#![feature(const_option_ops)]
+//#![feature(associated_type_defaults)]
+//#![feature(const_default)]
+//#![feature(const_option_ops)]
 #![feature(const_precise_live_drops)]
 #![feature(const_trait_impl)]
-#![feature(impl_trait_in_assoc_type)]
+//#![feature(impl_trait_in_assoc_type)]
 #![feature(step_trait)]
-#![feature(trait_alias)]
-#![feature(type_alias_impl_trait)]
-#![feature(type_changing_struct_update)]
+//#![feature(trait_alias)]
+//#![feature(type_alias_impl_trait)]
+//#![feature(type_changing_struct_update)]
 pub extern crate atomic_float;
 pub extern crate palette;
 pub extern crate better_panic;
 pub extern crate unicode_width;
+#[cfg(feature = "sing")] pub extern crate jack;
+#[cfg(feature = "term")] pub extern crate ratatui;
+#[cfg(feature = "term")] pub extern crate crossterm;
+#[cfg(feature = "lang")] pub extern crate dizzle as lang;
 #[cfg(test)] #[macro_use] pub extern crate proptest;
 
 pub(crate) use ::{
@@ -23,27 +27,30 @@ pub(crate) use ::{
     std::sync::atomic::{AtomicBool, AtomicUsize, Ordering::*},
 };
 
-#[cfg(feature = "lang")] pub extern crate dizzle as lang;
-#[cfg(feature = "lang")] pub use ::dizzle::{self, Usually, Perhaps, impl_default};
+#[cfg(feature = "lang")]
+pub use ::dizzle::{Usually, Perhaps, impl_default};
+/// DSL builtins.
 #[cfg(feature = "lang")] pub mod eval;
-
+/// Temporal dimension.
 #[cfg(feature = "time")] pub mod time;
-
+/// Circuit breaker for main loop.
 #[cfg(feature = "play")] pub mod exit;
+/// Thread management.
 #[cfg(feature = "play")] pub mod task;
-
-#[cfg(feature = "sing")] pub extern crate jack;
+/// Integration with JACK audio backend.
 #[cfg(feature = "sing")] pub mod sing;
-
+/// Generic drawing utilities.
 #[cfg(feature = "draw")] pub mod draw;
+/// Spatial dimension.
 #[cfg(feature = "draw")] pub mod space;
+/// Color handling.
 #[cfg(feature = "draw")] pub mod color;
-
+/// Text handling.
 #[cfg(feature = "text")] pub mod text;
+/// Terminal output.
 #[cfg(feature = "term")] pub mod term;
+/// Terminal keyboard input.
 #[cfg(feature = "term")] pub mod keys;
-#[cfg(feature = "term")] pub extern crate ratatui;
-#[cfg(feature = "term")] pub extern crate crossterm;
 
 /// Define a trait an implement it for various mutation-enabled wrapper types. */
 #[macro_export] macro_rules! flex_trait_mut (
diff --git a/src/sing.rs b/src/sing.rs
index a7903b8..7716129 100644
--- a/src/sing.rs
+++ b/src/sing.rs
@@ -25,7 +25,7 @@ pub trait Audio {
 /// Wraps [JackState], and through it [jack::Client] when connected.
 ///
 /// ```
-/// let jack = tengri::Jack::default();
+/// let jack = tengri::sing::Jack::default();
 /// ```
 #[derive(Clone, Debug, Default)] pub struct Jack<'j> (
     pub(crate) Arc<RwLock<JackState<'j>>>
@@ -36,7 +36,7 @@ pub trait Audio {
 /// [jack::Client], which you can use to talk to the JACK API.
 ///
 /// ```
-/// let state = tengri::JackState::default();
+/// let state = tengri::sing::JackState::default();
 /// ```
 #[derive(Debug, Default)] pub enum JackState<'j> {
     /// Unused
@@ -223,7 +223,7 @@ impl JackPerfModel for PerfModel {
 /// Things that can provide a [jack::Client] reference.
 ///
 /// ```
-/// use tengri::{Jack, HasJack};
+/// use tengri::sing::{Jack, HasJack};
 ///
 /// let jack: &Jack = Jacked::default().jack();
 ///
diff --git a/src/space.rs b/src/space.rs
index 2d2033f..a2f7010 100644
--- a/src/space.rs
+++ b/src/space.rs
@@ -1,144 +1,14 @@
 use crate::{*, draw::*};
 #[cfg(test)] use proptest_derive::Arbitrary;
 
-/// 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<N: Coord>(pub N, pub N, pub N, pub N);
-impl From<&ratatui::prelude::Rect> for XYWH<u16> {
-    fn from (rect: &ratatui::prelude::Rect) -> Self {
-        Self(rect.x, rect.y, rect.width, rect.height)
-    }
-}
-impl<N: Coord> X<N> for XYWH<N> { fn x (&self) -> N { self.0 } fn w (&self) -> N { self.2 } }
-impl<N: Coord> Y<N> for XYWH<N> { fn y (&self) -> N { self.0 } fn h (&self) -> N { self.2 } }
-impl<N: Coord> XYWH<N> {
-    pub fn zero () -> Self {
-        Self(0.into(), 0.into(), 0.into(), 0.into())
-    }
-    pub fn center (&self) -> (N, N) {
-        let Self(x, y, w, h) = *self;
-        (x.plus(w/2.into()), y.plus(h/2.into()))
-    }
-    pub fn centered (&self) -> (N, N) {
-        let Self(x, y, w, h) = *self;
-        (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 direction {
-            South => (XYWH(x, y, w, h - h / 2.into()), XYWH(x, y + h / 2.into(), w, h / 2.into())),
-            East  => (XYWH(x, y, w - w / 2.into(), h), XYWH(x + w / 2.into(), y, w / 2.into(), h)),
-            North => (XYWH(x, y + h / 2.into(), w, h - h / 2.into()), XYWH(x, y, w, h / 2.into())),
-            West  => (XYWH(x + w / 2.into(), y, w - w / 2.into(), h), XYWH(x, y, w / 2.into(), h)),
-            Above | Below => (XYWH(x, y, w, h), XYWH(x, y, w, h))
-        }
-    }
-}
+mod xywh;
+pub use self::xywh::*;
 
-/// 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() } }
-pub struct Anchor<T>(Origin, T);
-impl<T> AsRef<Origin> for Anchor<T> {
-    fn as_ref (&self) -> &Origin {
-        &self.0
-    }
-}
-impl<T: Screen, U: Draw<T>> Draw<T> for Anchor<U> {
-    fn draw (self, to: &mut T) -> Usually<XYWH<T::Unit>> {
-        todo!()
-    }
-}
+mod origin;
+pub use self::origin::*;
 
-pub const fn origin_c <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
-    Anchor(Origin::C, a)
-}
-pub const fn origin_x <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
-    Anchor(Origin::X, a)
-}
-pub const fn origin_y <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
-    Anchor(Origin::Y, a)
-}
-pub const fn origin_nw <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
-    Anchor(Origin::NW, a)
-}
-pub const fn origin_n <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
-    Anchor(Origin::N, a)
-}
-pub const fn origin_ne <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
-    Anchor(Origin::NE, a)
-}
-pub const fn origin_w <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
-    Anchor(Origin::W, a)
-}
-pub const fn origin_e <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
-    Anchor(Origin::E, a)
-}
-pub const fn origin_sw <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
-    Anchor(Origin::SW, a)
-}
-pub const fn origin_s <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
-    Anchor(Origin::S, a)
-}
-pub const fn origin_se <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
-    Anchor(Origin::SE, a)
-}
-
-/// 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!() })
-}
-pub fn align_n <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
-    align(Origin::N, a)
-}
+mod split;
+pub use self::split::*;
 
 /// A numeric type that can be used as coordinate.
 ///
@@ -174,88 +44,6 @@ pub trait Coord: Send + Sync + Copy
     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();
-            let a = origin_a.align(a);
-            let b = origin_b.align(b);
-            match self {
-                Self::Below => {
-                    to.place_at(area_b, &b);
-                    to.place_at(area_b, &a);
-                },
-                _ => {
-                    to.place_at(area_a, &a);
-                    to.place_at(area_a, &b);
-                }
-            }
-            Ok(to.xywh()) // 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),
-        }
-    }
-}
-
 /// Horizontal axis.
 pub trait X<N: Coord> {
     fn x (&self) -> N;
@@ -426,29 +214,6 @@ pub const fn wh_full <T: Screen> (a: impl Draw<T>) -> impl Draw<T> { a }
 pub const fn w_full <T: Screen> (a: impl Draw<T>) -> impl Draw<T> { a }
 pub const fn h_full <T: Screen> (a: impl Draw<T>) -> impl Draw<T> { a }
 
-#[macro_export] macro_rules! north {
-    ($head:expr $(,)?) => { $head };
-    ($head:expr, $($tail:expr),* $(,)?) => { north($head, north!($($tail,)*)) };
-}
-#[macro_export] macro_rules! south {
-    ($head:expr $(,)?) => { $head };
-    ($head:expr, $($tail:expr),* $(,)?) => { south($head, south!($($tail,)*)) };
-}
-#[macro_export] macro_rules! east {
-    ($head:expr $(,)?) => { $head };
-    ($head:expr, $($tail:expr),* $(,)?) => { east($head, east!($($tail,)*)) };
-}
-#[macro_export] macro_rules! west {
-    ($head:expr $(, $tail:expr)* $(,)?) => { west($head, west!($($tail,)*)) };
-}
-#[macro_export] macro_rules! above {
-    ($head:expr $(, $tail:expr)* $(,)?) => { above($head, above!($($tail,)*)) };
-}
-#[macro_export] macro_rules! below {
-    ($head:expr $(,)?) => { $head };
-    ($head:expr, $($tail:expr),* $(,)?) => { below($head, below!($($tail,)*)) };
-}
-
 /// Iterate over a collection of renderables:
 ///
 /// ```
diff --git a/src/space/origin.rs b/src/space/origin.rs
new file mode 100644
index 0000000..256a7f6
--- /dev/null
+++ b/src/space/origin.rs
@@ -0,0 +1,100 @@
+use super::*;
+
+pub const fn origin_c <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
+    Anchor(Origin::C, a)
+}
+
+pub const fn origin_x <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
+    Anchor(Origin::X, a)
+}
+
+pub const fn origin_y <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
+    Anchor(Origin::Y, a)
+}
+
+pub const fn origin_nw <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
+    Anchor(Origin::NW, a)
+}
+
+pub const fn origin_n <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
+    Anchor(Origin::N, a)
+}
+
+pub const fn origin_ne <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
+    Anchor(Origin::NE, a)
+}
+
+pub const fn origin_w <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
+    Anchor(Origin::W, a)
+}
+
+pub const fn origin_e <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
+    Anchor(Origin::E, a)
+}
+
+pub const fn origin_sw <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
+    Anchor(Origin::SW, a)
+}
+
+pub const fn origin_s <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
+    Anchor(Origin::S, a)
+}
+
+pub const fn origin_se <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
+    Anchor(Origin::SE, a)
+}
+
+/// 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()
+    }
+}
+
+pub struct Anchor<T>(Origin, T);
+
+impl<T> AsRef<Origin> for Anchor<T> {
+    fn as_ref (&self) -> &Origin {
+        &self.0
+    }
+}
+
+impl<T: Screen, U: Draw<T>> Draw<T> for Anchor<U> {
+    fn draw (self, to: &mut T) -> Usually<XYWH<T::Unit>> {
+        todo!()
+    }
+}
+
+/// 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!() })
+}
+
+pub fn align_n <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
+    align(Origin::N, a)
+}
diff --git a/src/space/split.rs b/src/space/split.rs
new file mode 100644
index 0000000..fabcb6b
--- /dev/null
+++ b/src/space/split.rs
@@ -0,0 +1,127 @@
+use super::*;
+
+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)
+}
+
+/// Split along an axis. Direction determines order.
+#[cfg_attr(test, derive(Arbitrary))]
+#[derive(Copy, Clone, PartialEq, Debug, Default)] pub enum Split {
+    North,
+    South,
+    East,
+    West,
+    Above,
+    #[default] Below
+}
+
+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();
+            let a = origin_a.align(a);
+            let b = origin_b.align(b);
+            match self {
+                Self::Below => {
+                    to.place_at(area_b, &b);
+                    to.place_at(area_b, &a);
+                },
+                _ => {
+                    to.place_at(area_a, &a);
+                    to.place_at(area_a, &b);
+                }
+            }
+            Ok(to.xywh()) // 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),
+        }
+    }
+
+}
+
+#[macro_export] macro_rules! north {
+    ($head:expr $(,)?) => { $head };
+    ($head:expr, $($tail:expr),* $(,)?) => { north($head, north!($($tail,)*)) };
+}
+
+#[macro_export] macro_rules! south {
+    ($head:expr $(,)?) => { $head };
+    ($head:expr, $($tail:expr),* $(,)?) => { south($head, south!($($tail,)*)) };
+}
+
+#[macro_export] macro_rules! east {
+    ($head:expr $(,)?) => { $head };
+    ($head:expr, $($tail:expr),* $(,)?) => { east($head, east!($($tail,)*)) };
+}
+
+#[macro_export] macro_rules! west {
+    ($head:expr $(,)?) => { $head };
+    ($head:expr $(, $tail:expr)* $(,)?) => { west($head, west!($($tail,)*)) };
+}
+
+#[macro_export] macro_rules! above {
+    ($head:expr $(,)?) => { $head };
+    ($head:expr $(, $tail:expr)* $(,)?) => { above($head, above!($($tail,)*)) };
+}
+
+#[macro_export] macro_rules! below {
+    ($head:expr $(,)?) => { $head };
+    ($head:expr, $($tail:expr),* $(,)?) => { below($head, below!($($tail,)*)) };
+}
diff --git a/src/space/xywh.rs b/src/space/xywh.rs
new file mode 100644
index 0000000..a4047db
--- /dev/null
+++ b/src/space/xywh.rs
@@ -0,0 +1,80 @@
+use super::*;
+
+/// 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<N: Coord>(pub N, pub N, pub N, pub N);
+
+impl From<&ratatui::prelude::Rect> for XYWH<u16> {
+    fn from (rect: &ratatui::prelude::Rect) -> Self {
+        Self(rect.x, rect.y, rect.width, rect.height)
+    }
+}
+
+impl<N: Coord> X<N> for XYWH<N> {
+    fn x (&self) -> N { self.0 }
+    fn w (&self) -> N { self.2 }
+}
+
+impl<N: Coord> Y<N> for XYWH<N> {
+    fn y (&self) -> N { self.0 }
+    fn h (&self) -> N { self.2 }
+}
+
+impl<N: Coord> XYWH<N> {
+
+    pub fn zero () -> Self {
+        Self(0.into(), 0.into(), 0.into(), 0.into())
+    }
+
+    pub fn center (&self) -> (N, N) {
+        let Self(x, y, w, h) = *self;
+        (x.plus(w/2.into()), y.plus(h/2.into()))
+    }
+
+    pub fn centered (&self) -> (N, N) {
+        let Self(x, y, w, h) = *self;
+        (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 direction {
+            South => (XYWH(x, y, w, h - h / 2.into()), XYWH(x, y + h / 2.into(), w, h / 2.into())),
+            East  => (XYWH(x, y, w - w / 2.into(), h), XYWH(x + w / 2.into(), y, w / 2.into(), h)),
+            North => (XYWH(x, y + h / 2.into(), w, h - h / 2.into()), XYWH(x, y, w, h / 2.into())),
+            West  => (XYWH(x + w / 2.into(), y, w - w / 2.into(), h), XYWH(x, y, w / 2.into(), h)),
+            Above | Below => (XYWH(x, y, w, h), XYWH(x, y, w, h))
+        }
+    }
+
+}

From 42a1807c2b25c8c103d33f680e579362ce8e9dc7 Mon Sep 17 00:00:00 2001
From: i do not exist <donotem@ilme.no>
Date: Fri, 24 Apr 2026 01:44:03 +0300
Subject: [PATCH 02/25] fix some more doctest errors

---
 src/draw.rs | 36 ++++++++++++++++++++++++++----------
 src/eval.rs |  4 ++--
 2 files changed, 28 insertions(+), 12 deletions(-)

diff --git a/src/draw.rs b/src/draw.rs
index 98ad3ef..67ee223 100644
--- a/src/draw.rs
+++ b/src/draw.rs
@@ -1,4 +1,20 @@
-use crate::{*, space::*};
+use crate::*;
+pub use crate::space::*;
+
+/// Implement the [Draw] trait for a particular drawable and [Screen].
+///
+/// ```
+/// use tengri::{*, draw::*, term::*};
+/// struct MyDrawable;
+/// impl_draw!(|self: MyDrawable, to: Tui|{
+///   todo!()
+/// });
+/// ```
+#[macro_export] macro_rules! impl_draw ((|
+    $self:ident:$Self:ty, $to:ident:$To:ty
+|$draw:block)=>{ impl Draw<$To> for $Self {
+    fn draw ($self, $to: &mut $To) -> Usually<XYWH<u16>> $draw
+} });
 
 /// Drawable that supports dynamic dispatch.
 ///
@@ -13,12 +29,14 @@ use crate::{*, space::*};
 /// a [Draw]able.
 /// 
 /// ```
-/// use tengri::{*, draw::*, space::*};
+/// use tengri::{*, draw::*};
 /// struct TestScreen(bool);
 /// impl Screen for TestScreen { type Unit = u16; }
+/// impl X<u16> for TestScreen { fn x (&self) -> u16 { 0 } }
+/// impl Y<u16> for TestScreen { fn y (&self) -> u16 { 0 } }
 /// struct TestWidget(bool);
 /// impl Draw<TestScreen> for TestWidget {
-///     fn draw (&self, screen: &mut TestScreen) -> Usually<XYWH<u16>> {
+///     fn draw (self, screen: &mut TestScreen) -> Usually<XYWH<u16>> {
 ///         screen.0 |= self.0;
 ///     }
 /// }
@@ -90,11 +108,11 @@ pub const fn either <T: Screen> (condition: bool, a: impl Draw<T>, b: impl Draw<
 /// Output target.
 ///
 /// ```
-/// use tengri::draw::*;
+/// use tengri::{*, draw::*};
 ///
 /// struct TestOut<T: Screen<Unit = u16>>(T);
 ///
-/// impl<T: Screen<Unit = u16>> Screen<T> for TestOut {
+/// impl<T: Screen<Unit = u16>> Screen for TestOut {
 ///     type Unit = u16;
 ///     fn place_at <D: Draw<Self> + ?Sized> (&mut self, area: T, _: D) {
 ///         println!("placed: {area:?}");
@@ -102,11 +120,9 @@ pub const fn either <T: Screen> (condition: bool, a: impl Draw<T>, b: impl Draw<
 ///     }
 /// }
 ///
-/// impl Draw<Screen> for String {
-///     fn draw (&self, to: &mut TestOut) -> Usually<XYWH<u16>> {
-///         to.area_mut().set_w(self.len() as u16);
-///     }
-/// }
+/// impl_draw!(|self: String, to: TestOut<u16>|{
+///    to.area_mut().set_w(self.len() as u16);
+/// });
 /// ```
 pub trait Screen: Space<Self::Unit> + Send + Sync + Sized {
     type Unit: Coord;
diff --git a/src/eval.rs b/src/eval.rs
index 9e48051..c87eb56 100644
--- a/src/eval.rs
+++ b/src/eval.rs
@@ -59,7 +59,7 @@ macro_rules! eval_enum ((
 /// Interpret layout operation.
 ///
 /// ```
-/// # use tengri::{*, space::*};
+/// # use tengri::{lang::*, draw::*, eval::*};
 /// struct Target { xywh: XYWH<u16> /*platform-specific*/}
 /// impl tengri::Out for Target {
 ///     type Unit = u16;
@@ -162,7 +162,7 @@ pub fn eval_view <'a, O: Screen + 'a, S> (
 /// Interpret TUI-specific layout operation.
 ///
 /// ```
-/// use tengri::{lang::{Namespace, Interpret}, term::Tui, ratatui::prelude::Color};
+/// use tengri::{lang::*, term::*, eval::*, ratatui::prelude::Color};
 ///
 /// struct State;
 /// impl<'b> Namespace<'b, bool>    for State {}

From 145047b7ff09eab9d796d52b78fd896aaf75d0c2 Mon Sep 17 00:00:00 2001
From: facile pop culture reference <donotem@ilme.no>
Date: Fri, 24 Apr 2026 02:06:04 +0300
Subject: [PATCH 03/25] more space/ and draw/ modules

- 26 errors and 16 doctest fails
- getting there, perpetually
---
 src/draw.rs         | 117 +++----------------------------------------
 src/draw/draw.rs    |  60 ++++++++++++++++++++++
 src/draw/screen.rs  |  34 +++++++++++++
 src/draw/thunk.rs   |  16 ++++++
 src/draw/view.rs    |   8 +++
 src/eval.rs         |  10 ++--
 src/sing.rs         |   4 +-
 src/space.rs        | 118 ++++++--------------------------------------
 src/space/coord.rs  |  35 +++++++++++++
 src/space/iter.rs   |  46 +++++++++++++++++
 src/space/origin.rs |   2 +-
 src/space/size.rs   |  28 +++++++++++
 src/space/split.rs  |  12 ++---
 src/space/xywh.rs   |   5 +-
 src/term.rs         |   6 +--
 15 files changed, 269 insertions(+), 232 deletions(-)
 create mode 100644 src/draw/draw.rs
 create mode 100644 src/draw/screen.rs
 create mode 100644 src/draw/thunk.rs
 create mode 100644 src/draw/view.rs
 create mode 100644 src/space/coord.rs
 create mode 100644 src/space/iter.rs
 create mode 100644 src/space/size.rs

diff --git a/src/draw.rs b/src/draw.rs
index 67ee223..29dbac7 100644
--- a/src/draw.rs
+++ b/src/draw.rs
@@ -1,85 +1,17 @@
 use crate::*;
 pub use crate::space::*;
 
-/// Implement the [Draw] trait for a particular drawable and [Screen].
-///
-/// ```
-/// use tengri::{*, draw::*, term::*};
-/// struct MyDrawable;
-/// impl_draw!(|self: MyDrawable, to: Tui|{
-///   todo!()
-/// });
-/// ```
-#[macro_export] macro_rules! impl_draw ((|
-    $self:ident:$Self:ty, $to:ident:$To:ty
-|$draw:block)=>{ impl Draw<$To> for $Self {
-    fn draw ($self, $to: &mut $To) -> Usually<XYWH<u16>> $draw
-} });
+mod draw;
+pub use self::draw::*;
 
-/// Drawable that supports dynamic dispatch.
-///
-/// Drawables are composable, e.g. the [when] and [either] conditionals
-/// or the layout constraints.
-///
-/// Drawables are consumable, i.e. the [Draw::draw] method receives an
-/// owned `self` and does not return it, consuming the drawable.
-///
-/// To draw a thing multiple times, instead of explicitly constructing it
-/// every time, implement the [View] trait instead, which will construct
-/// a [Draw]able.
-/// 
-/// ```
-/// use tengri::{*, draw::*};
-/// struct TestScreen(bool);
-/// impl Screen for TestScreen { type Unit = u16; }
-/// impl X<u16> for TestScreen { fn x (&self) -> u16 { 0 } }
-/// impl Y<u16> for TestScreen { fn y (&self) -> u16 { 0 } }
-/// struct TestWidget(bool);
-/// impl Draw<TestScreen> for TestWidget {
-///     fn draw (self, screen: &mut TestScreen) -> Usually<XYWH<u16>> {
-///         screen.0 |= self.0;
-///     }
-/// }
-/// let mut screen = TestScreen(false);
-/// TestWidget(false).draw(&mut screen);
-/// TestWidget(true).draw(&mut screen);
-/// TestWidget(false).draw(&mut screen);
-/// ```
-pub trait Draw<T: Screen> {
-    fn draw (self, to: &mut T) -> Usually<XYWH<T::Unit>>;
-}
-impl<T: Screen, D: Draw<T>> Draw<T> for &D {
-    fn draw (self, __: &mut T) -> Usually<XYWH<T::Unit>> {
-        todo!()
-    }
-}
-impl<T: Screen, D: Draw<T>> Draw<T> for Option<D> {
-    fn draw (self, __: &mut T) -> Usually<XYWH<T::Unit>> {
-        todo!()
-    }
-}
+mod view;
+pub use self::view::*;
 
-/// Emit a [Draw]able.
-///
-/// Speculative. How to avoid conflicts with [Draw] proper?
-pub trait View<T: Screen> {
-    fn view (&self) -> impl Draw<T>;
-}
+mod thunk;
+pub use self::thunk::*;
 
-pub const fn thunk <T: Screen, F: FnOnce(&mut T)->Usually<XYWH<T::Unit>>> (draw: F) -> Thunk<T, F> {
-    Thunk(draw, std::marker::PhantomData)
-}
-
-/// Because we can't implement [Draw] for `F: FnOnce...` without conflicts.
-pub struct Thunk<T: Screen, F: FnOnce(&mut T)->Usually<XYWH<T::Unit>>>(
-    pub F,
-    std::marker::PhantomData<T>
-);
-impl<T: Screen, F: FnOnce(&mut T)->Usually<XYWH<T::Unit>>> Draw<T> for Thunk<T, F> {
-    fn draw (self, to: &mut T) -> Usually<XYWH<T::Unit>> {
-        (self.0)(to)
-    }
-}
+mod screen;
+pub use self::screen::*;
 
 /// Only render when condition is true.
 ///
@@ -104,36 +36,3 @@ pub const fn when <T: Screen> (condition: bool, draw: impl Draw<T>) -> impl Draw
 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) })
 }
-
-/// Output target.
-///
-/// ```
-/// use tengri::{*, draw::*};
-///
-/// struct TestOut<T: Screen<Unit = u16>>(T);
-///
-/// impl<T: Screen<Unit = u16>> Screen for TestOut {
-///     type Unit = u16;
-///     fn place_at <D: Draw<Self> + ?Sized> (&mut self, area: T, _: D) {
-///         println!("placed: {area:?}");
-///         ()
-///     }
-/// }
-///
-/// impl_draw!(|self: String, to: TestOut<u16>|{
-///    to.area_mut().set_w(self.len() as u16);
-/// });
-/// ```
-pub trait Screen: Space<Self::Unit> + Send + Sync + Sized {
-    type Unit: Coord;
-    /// Render drawable in area.
-    fn place <'t, T: Draw<Self> + ?Sized> (&mut self, content: &'t T) {
-        self.place_at(self.xywh(), content)
-    }
-    /// Render drawable in subarea specified by `area`
-    fn place_at <'t, T: Draw<Self> + ?Sized> (
-        &mut self, _area: XYWH<Self::Unit>, _content: &'t T
-    ) {
-        unimplemented!()
-    }
-}
diff --git a/src/draw/draw.rs b/src/draw/draw.rs
new file mode 100644
index 0000000..8701084
--- /dev/null
+++ b/src/draw/draw.rs
@@ -0,0 +1,60 @@
+use super::*;
+
+/// Implement the [Draw] trait for a particular drawable and [Screen].
+///
+/// ```
+/// use tengri::{*, draw::*, term::*};
+/// struct MyDrawable;
+/// impl_draw!(|self: MyDrawable, to: Tui|{
+///   todo!()
+/// });
+/// ```
+#[macro_export] macro_rules! impl_draw ((|
+    $self:ident:$Self:ty, $to:ident:$To:ty
+|$draw:block)=>{ impl Draw<$To> for $Self {
+    fn draw ($self, $to: &mut $To) -> Usually<XYWH<u16>> $draw
+} });
+
+/// Drawable that supports dynamic dispatch.
+///
+/// Drawables are composable, e.g. the [when] and [either] conditionals
+/// or the layout constraints.
+///
+/// Drawables are consumable, i.e. the [Draw::draw] method receives an
+/// owned `self` and does not return it, consuming the drawable.
+///
+/// To draw a thing multiple times, instead of explicitly constructing it
+/// every time, implement the [View] trait instead, which will construct
+/// a [Draw]able.
+/// 
+/// ```
+/// use tengri::{*, draw::*};
+/// struct MyScreen(bool);
+/// impl Screen for MyScreen { type Unit = u16; }
+/// impl X<u16> for MyScreen { fn x (&self) -> u16 { 0 } }
+/// impl Y<u16> for MyScreen { fn y (&self) -> u16 { 0 } }
+/// struct MyWidget(bool);
+/// impl Draw<MyScreen> for MyWidget {
+///     fn draw (self, screen: &mut MyScreen) -> Usually<XYWH<u16>> {
+///         screen.0 |= self.0;
+///     }
+/// }
+/// let mut screen = MyScreen(false);
+/// MyWidget(false).draw(&mut screen);
+/// MyWidget(true).draw(&mut screen);
+/// MyWidget(false).draw(&mut screen);
+/// ```
+pub trait Draw<T: Screen> {
+    fn draw (self, to: &mut T) -> Usually<XYWH<T::Unit>>;
+}
+impl<T: Screen, D: Draw<T>> Draw<T> for &D {
+    fn draw (self, __: &mut T) -> Usually<XYWH<T::Unit>> {
+        todo!()
+    }
+}
+impl<T: Screen, D: Draw<T>> Draw<T> for Option<D> {
+    fn draw (self, __: &mut T) -> Usually<XYWH<T::Unit>> {
+        todo!()
+    }
+}
+
diff --git a/src/draw/screen.rs b/src/draw/screen.rs
new file mode 100644
index 0000000..dc51744
--- /dev/null
+++ b/src/draw/screen.rs
@@ -0,0 +1,34 @@
+use super::*;
+
+/// Output target.
+///
+/// ```
+/// use tengri::{*, draw::*};
+///
+/// struct TestOut<T: Screen<Unit = u16>>(T);
+///
+/// impl<T: Screen<Unit = u16>> Screen for TestOut {
+///     type Unit = u16;
+///     fn place_at <D: Draw<Self> + ?Sized> (&mut self, area: T, _: D) {
+///         println!("placed: {area:?}");
+///         ()
+///     }
+/// }
+///
+/// impl_draw!(|self: String, to: TestOut<u16>|{
+///    to.area_mut().set_w(self.len() as u16);
+/// });
+/// ```
+pub trait Screen: Space<Self::Unit> + Send + Sync + Sized {
+    type Unit: Coord;
+    /// Render drawable in area.
+    fn place <'t, T: Draw<Self> + ?Sized> (&mut self, content: &'t T) {
+        self.place_at(self.xywh(), content)
+    }
+    /// Render drawable in subarea specified by `area`
+    fn place_at <'t, T: Draw<Self> + ?Sized> (
+        &mut self, _area: XYWH<Self::Unit>, _content: &'t T
+    ) {
+        unimplemented!()
+    }
+}
diff --git a/src/draw/thunk.rs b/src/draw/thunk.rs
new file mode 100644
index 0000000..9b1d4b5
--- /dev/null
+++ b/src/draw/thunk.rs
@@ -0,0 +1,16 @@
+use super::*;
+
+pub const fn thunk <T: Screen, F: FnOnce(&mut T)->Usually<XYWH<T::Unit>>> (draw: F) -> Thunk<T, F> {
+    Thunk(draw, std::marker::PhantomData)
+}
+
+/// Because we can't implement [Draw] for `F: FnOnce...` without conflicts.
+pub struct Thunk<T: Screen, F: FnOnce(&mut T)->Usually<XYWH<T::Unit>>>(
+    pub F,
+    std::marker::PhantomData<T>
+);
+impl<T: Screen, F: FnOnce(&mut T)->Usually<XYWH<T::Unit>>> Draw<T> for Thunk<T, F> {
+    fn draw (self, to: &mut T) -> Usually<XYWH<T::Unit>> {
+        (self.0)(to)
+    }
+}
diff --git a/src/draw/view.rs b/src/draw/view.rs
new file mode 100644
index 0000000..82fe908
--- /dev/null
+++ b/src/draw/view.rs
@@ -0,0 +1,8 @@
+use super::*;
+
+/// Emit a [Draw]able.
+///
+/// Speculative. How to avoid conflicts with [Draw] proper?
+pub trait View<T: Screen> {
+    fn view (&self) -> impl Draw<T>;
+}
diff --git a/src/eval.rs b/src/eval.rs
index c87eb56..4fc5934 100644
--- a/src/eval.rs
+++ b/src/eval.rs
@@ -172,11 +172,11 @@ pub fn eval_view <'a, O: Screen + 'a, S> (
 /// # fn main () -> tengri::Usually<()> {
 /// let state = State;
 /// let mut out = Tui::default();
-/// tengri::eval_view_tui(&state, &mut out, "")?;
-/// tengri::eval_view_tui(&state, &mut out, "text Hello world!")?;
-/// tengri::eval_view_tui(&state, &mut out, "fg (g 0) (text Hello world!)")?;
-/// tengri::eval_view_tui(&state, &mut out, "bg (g 2) (text Hello world!)")?;
-/// tengri::eval_view_tui(&state, &mut out, "(bg (g 3) (fg (g 4) (text Hello world!)))")?;
+/// tengri::eval::eval_view_tui(&state, &mut out, "")?;
+/// tengri::eval::eval_view_tui(&state, &mut out, "text Hello world!")?;
+/// tengri::eval::eval_view_tui(&state, &mut out, "fg (g 0) (text Hello world!)")?;
+/// tengri::eval::eval_view_tui(&state, &mut out, "bg (g 2) (text Hello world!)")?;
+/// tengri::eval::eval_view_tui(&state, &mut out, "(bg (g 3) (fg (g 4) (text Hello world!)))")?;
 /// # Ok(()) }
 /// ```
 pub fn eval_view_tui <'a, S> (
diff --git a/src/sing.rs b/src/sing.rs
index 7716129..cd76eb2 100644
--- a/src/sing.rs
+++ b/src/sing.rs
@@ -52,7 +52,7 @@ pub trait Audio {
 /// Event enum for JACK events.
 ///
 /// ```
-/// let event = tengri::JackEvent::XRun;
+/// let event = tengri::sing::JackEvent::XRun; // kerpop
 /// ```
 #[derive(Debug, Clone, PartialEq)] pub enum JackEvent {
     ThreadInit,
@@ -70,7 +70,7 @@ pub trait Audio {
 /// Generic notification handler that emits [JackEvent]
 ///
 /// ```
-/// let notify = tengri::JackNotify(|_|{});
+/// let notify = tengri::sing::JackNotify(|_|{});
 /// ```
 pub struct JackNotify<T: Fn(JackEvent) + Send>(pub T);
 
diff --git a/src/space.rs b/src/space.rs
index a2f7010..9a8650c 100644
--- a/src/space.rs
+++ b/src/space.rs
@@ -1,6 +1,9 @@
 use crate::{*, draw::*};
 #[cfg(test)] use proptest_derive::Arbitrary;
 
+mod coord;
+pub use self::coord::*;
+
 mod xywh;
 pub use self::xywh::*;
 
@@ -10,39 +13,11 @@ pub use self::origin::*;
 mod split;
 pub use self::split::*;
 
-/// 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()) }
-}
+mod iter;
+pub use self::iter::*;
+
+mod size;
+pub use self::size::*;
 
 /// Horizontal axis.
 pub trait X<N: Coord> {
@@ -89,7 +64,7 @@ pub const fn w_exact <T: Screen> (w: T::Unit, c: impl Draw<T>) -> impl Draw<T> {
 /// Shrink drawing area symmetrically.
 ///
 /// ```
-/// let padded = tengri::W(3).pad("Hello");
+/// let padded = tengri::space::w_pad(3, "Hello");
 /// ```
 pub const fn w_pad <T: Screen> (x: T::Unit, draw: impl Draw<T>) -> impl Draw<T> {
     thunk(move|to: &mut T|draw.draw(todo!()))
@@ -139,7 +114,7 @@ pub const fn h_exact <T: Screen> (h: T::Unit, c: impl Draw<T>) -> impl Draw<T> {
 /// Shrink drawing area symmetrically.
 ///
 /// ```
-/// let padded = tengri::W::pad(3, "Hello");
+/// let padded = tengri::space::w_pad(3, "Hello");
 /// ```
 pub const fn h_pad <T: Screen> (x: T::Unit, draw: impl Draw<T>) -> impl Draw<T> {
     thunk(move|to: &mut T|draw.draw(todo!()))
@@ -170,7 +145,7 @@ pub const fn wh_pad <T: Screen> (w: T::Unit, h: T::Unit, draw: impl Draw<T>)
 /// Only draw content if area is above a certain size.
 ///
 /// ```
-/// let min = tengri::wh_min(3, 5, "Hello"); // 5x5
+/// let min = tengri::space::wh_min(3, 5, "Hello"); // 5x5
 /// ```
 pub const fn wh_min <T: Screen> (w: Option<T::Unit>, h: Option<T::Unit>, draw: impl Draw<T>)
     -> impl Draw<T>
@@ -181,7 +156,7 @@ pub const fn wh_min <T: Screen> (w: Option<T::Unit>, h: Option<T::Unit>, draw: i
 /// Set the maximum width and/or height of the content.
 ///
 /// ```
-/// let max = tengri::wh_max(Some(3), Some(5), "Hello");
+/// let max = tengri::space::wh_max(Some(3), Some(5), "Hello");
 /// ```
 pub const fn wh_max <T: Screen> (w: Option<T::Unit>, h: Option<T::Unit>, draw: impl Draw<T>)
     -> impl Draw<T>
@@ -192,7 +167,7 @@ pub const fn wh_max <T: Screen> (w: Option<T::Unit>, h: Option<T::Unit>, draw: i
 /// Set the maximum width and/or height of the content.
 ///
 /// ```
-/// let exact = tengri::wh_exact(Some(3), Some(5), "Hello");
+/// let exact = tengri::space::wh_exact(Some(3), Some(5), "Hello");
 /// ```
 pub const fn wh_exact <T: Screen> (w: Option<T::Unit>, h: Option<T::Unit>, draw: impl Draw<T>)
     -> impl Draw<T>
@@ -202,7 +177,7 @@ pub const fn wh_exact <T: Screen> (w: Option<T::Unit>, h: Option<T::Unit>, draw:
 
 /// Limit size of drawing area
 /// ```
-/// let clipped = tengri::wh_clip(Some(3), Some(5), "Hello");
+/// let clipped = tengri::space::wh_clip(Some(3), Some(5), "Hello");
 /// ```
 pub const fn wh_clip <T: Screen> (
     w: Option<T::Unit>, h: Option<T::Unit>, draw: impl Draw<T>
@@ -213,68 +188,3 @@ pub const fn wh_clip <T: Screen> (
 pub const fn wh_full <T: Screen> (a: impl Draw<T>) -> impl Draw<T> { a }
 pub const fn w_full <T: Screen> (a: impl Draw<T>) -> impl Draw<T> { a }
 pub const fn h_full <T: Screen> (a: impl Draw<T>) -> impl Draw<T> { a }
-
-/// 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 <
-    S: Screen,
-    D: Draw<S>,
-    V: Fn()->I,
-    I: Iterator<Item = D>,
-    F: Fn(&D)->dyn Draw<S>,
-> (_items: V, _cb: F) -> impl Draw<S> {
-    thunk(move|_to: &mut S|{ todo!() })
-}
-
-pub fn iter_north <'a, S: Screen, D: 'a, I: Iterator<Item = D>, U: Draw<S>> (
-    _iter: impl Fn()->I, _draw: impl Fn(D)->U,
-) -> impl Draw<S> {
-    thunk(move|_to: &mut S|{ todo!() })
-}
-
-pub fn iter_east <'a, S: Screen, D: 'a, I: Iterator<Item = D>, U: Draw<S>> (
-    _iter: impl Fn()->I, _draw: impl Fn(D)->U,
-) -> impl Draw<S> {
-    thunk(move|_to: &mut S|{ todo!() })
-}
-
-pub fn iter_south <'a, S: Screen, D: 'a, I: Iterator<Item = D>, U: Draw<S>> (
-    _iter: impl Fn()->I, _draw: impl Fn(D)->U,
-) -> impl Draw<S> {
-    thunk(move|_to: &mut S|{ todo!() })
-}
-
-pub fn iter_west <'a, S: Screen, D: 'a, I: Iterator<Item = D>, U: Draw<S>> (
-    _iter: impl Fn()->I, _draw: impl Fn(D)->U,
-) -> impl Draw<S> {
-    thunk(move|_to: &mut S|{ todo!() })
-}
-
-#[derive(Default, Debug)]
-pub struct Size(AtomicUsize, AtomicUsize);
-impl X<u16> for Size {
-    fn x (&self) -> u16 { 0 }
-    fn w (&self) -> u16 { self.0.load(Relaxed) as u16 }
-}
-impl Y<u16> for Size {
-    fn y (&self) -> u16 { 0 }
-    fn h (&self) -> u16 { self.1.load(Relaxed) as u16 }
-}
-impl Size {
-    pub const fn of <T: Screen> (&self, of: impl Draw<T>) -> impl Draw<T> {
-        thunk(move|to: &mut T|{
-            let area = of.draw(to)?;
-            self.0.store(area.w().into(), Relaxed);
-            self.1.store(area.h().into(), Relaxed);
-            Ok(area)
-        })
-    }
-}
diff --git a/src/space/coord.rs b/src/space/coord.rs
new file mode 100644
index 0000000..f5e6974
--- /dev/null
+++ b/src/space/coord.rs
@@ -0,0 +1,35 @@
+use super::*;
+
+/// 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()) }
+}
diff --git a/src/space/iter.rs b/src/space/iter.rs
new file mode 100644
index 0000000..4bcfde8
--- /dev/null
+++ b/src/space/iter.rs
@@ -0,0 +1,46 @@
+use super::*;
+
+/// 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 <
+    S: Screen,
+    D: Draw<S>,
+    V: Fn()->I,
+    I: Iterator<Item = D>,
+    F: Fn(&D)->dyn Draw<S>,
+> (_items: V, _cb: F) -> impl Draw<S> {
+    thunk(move|_to: &mut S|{ todo!() })
+}
+
+pub fn iter_north <'a, S: Screen, D: 'a, I: Iterator<Item = D>, U: Draw<S>> (
+    _iter: impl Fn()->I, _draw: impl Fn(D)->U,
+) -> impl Draw<S> {
+    thunk(move|_to: &mut S|{ todo!() })
+}
+
+pub fn iter_east <'a, S: Screen, D: 'a, I: Iterator<Item = D>, U: Draw<S>> (
+    _iter: impl Fn()->I, _draw: impl Fn(D)->U,
+) -> impl Draw<S> {
+    thunk(move|_to: &mut S|{ todo!() })
+}
+
+pub fn iter_south <'a, S: Screen, D: 'a, I: Iterator<Item = D>, U: Draw<S>> (
+    _iter: impl Fn()->I, _draw: impl Fn(D)->U,
+) -> impl Draw<S> {
+    thunk(move|_to: &mut S|{ todo!() })
+}
+
+pub fn iter_west <'a, S: Screen, D: 'a, I: Iterator<Item = D>, U: Draw<S>> (
+    _iter: impl Fn()->I, _draw: impl Fn(D)->U,
+) -> impl Draw<S> {
+    thunk(move|_to: &mut S|{ todo!() })
+}
+
diff --git a/src/space/origin.rs b/src/space/origin.rs
index 256a7f6..f3f7acc 100644
--- a/src/space/origin.rs
+++ b/src/space/origin.rs
@@ -73,7 +73,7 @@ impl<T: Screen, U: Draw<T>> Draw<T> for Anchor<U> {
 ///
 /// ```
 /// use tengri::draw::Origin;
-/// let _ = Origin::NW.align(())
+/// let _ = Origin::NW.align(());
 /// ```
 #[cfg_attr(test, derive(Arbitrary))]
 #[derive(Debug, Copy, Clone, Default)] pub enum Origin {
diff --git a/src/space/size.rs b/src/space/size.rs
new file mode 100644
index 0000000..add71ae
--- /dev/null
+++ b/src/space/size.rs
@@ -0,0 +1,28 @@
+use super::*;
+
+/// Uses [AtomicUsize] to measure size during\
+/// rendering (which is normally read-only).
+#[derive(Default, Debug)]
+pub struct Size(AtomicUsize, AtomicUsize);
+
+impl X<u16> for Size {
+    fn x (&self) -> u16 { 0 }
+    fn w (&self) -> u16 { self.0.load(Relaxed) as u16 }
+}
+
+impl Y<u16> for Size {
+    fn y (&self) -> u16 { 0 }
+    fn h (&self) -> u16 { self.1.load(Relaxed) as u16 }
+}
+
+impl Size {
+    pub const fn of <T: Screen> (&self, of: impl Draw<T>) -> impl Draw<T> {
+        thunk(move|to: &mut T|{
+            let area = of.draw(to)?;
+            self.0.store(area.w().into(), Relaxed);
+            self.1.store(area.h().into(), Relaxed);
+            Ok(area)
+        })
+    }
+}
+
diff --git a/src/space/split.rs b/src/space/split.rs
index fabcb6b..f6f53b2 100644
--- a/src/space/split.rs
+++ b/src/space/split.rs
@@ -39,12 +39,12 @@ impl Split {
 
     /// ```
     /// use tengri::draw::Split::*;
-    /// let _ = Above.bsp((), ());
-    /// let _ = Below.bsp((), ());
-    /// let _ = North.bsp((), ());
-    /// let _ = South.bsp((), ());
-    /// let _ = East.bsp((), ());
-    /// let _ = West.bsp((), ());
+    /// let _ = Above.half("", "");
+    /// let _ = Below.half("", "");
+    /// let _ = North.half("", "");
+    /// let _ = South.half("", "");
+    /// let _ = East.half("", "");
+    /// let _ = West.half("", "");
     /// ```
     pub const fn half <T: Screen> (&self, a: impl Draw<T>, b: impl Draw<T>) -> impl Draw<T> {
         thunk(move|to: &mut T|{
diff --git a/src/space/xywh.rs b/src/space/xywh.rs
index a4047db..c403f5a 100644
--- a/src/space/xywh.rs
+++ b/src/space/xywh.rs
@@ -3,8 +3,9 @@ use super::*;
 /// Point with size.
 ///
 /// ```
-/// let xywh = tengri::XYWH(0u16, 0, 0, 0);
-/// assert_eq!(tengri::XYWH(10u16, 10, 20, 20).center(), tengri::XY(20, 20));
+/// use tengri::space::{XY, XYWH};
+/// let xywh = XYWH(0u16, 0, 0, 0);
+/// assert_eq!(XYWH(10u16, 10, 20, 20).center(), XY(20, 20));
 /// ```
 ///
 /// * [ ] TODO: origin field (determines at which corner/side is X0 Y0)
diff --git a/src/term.rs b/src/term.rs
index 2251432..4be440c 100644
--- a/src/term.rs
+++ b/src/term.rs
@@ -645,9 +645,9 @@ pub const fn border <T, S: BorderStyle> (on: bool, style: S, draw: impl Draw<Tui
 /// Draw TUI content or its error message.
 ///
 /// ```
-/// let _ = tengri::tui::catcher(Ok(Some("hello")));
-/// let _ = tengri::tui::catcher(Ok(None));
-/// let _ = tengri::tui::catcher(Err("draw fail".into()));
+/// let _ = tengri::term::catcher(Ok(Some("hello")));
+/// let _ = tengri::term::catcher(Ok(None));
+/// let _ = tengri::term::catcher(Err("draw fail".into()));
 /// ```
 pub fn catcher <T: Draw<Tui>> (result: Usually<T>) -> impl Draw<Tui> {
     thunk(move|to: &mut Tui|match result {

From be14173126664657e283c892fb8211e2de2d4c05 Mon Sep 17 00:00:00 2001
From: facile pop culture reference <donotem@ilme.no>
Date: Sat, 25 Apr 2026 00:02:58 +0300
Subject: [PATCH 04/25] well, one tui example works again

---
 examples/tui_00.rs |   2 +-
 src/color.rs       |   4 +-
 src/draw.rs        |   6 +-
 src/draw/screen.rs |   2 +-
 src/exit.rs        |   1 -
 src/keys.rs        |  85 +++++----
 src/term.rs        | 463 ++++++++++++++-------------------------------
 src/term/border.rs | 239 +++++++++++++++++++++++
 8 files changed, 440 insertions(+), 362 deletions(-)
 create mode 100644 src/term/border.rs

diff --git a/examples/tui_00.rs b/examples/tui_00.rs
index dc166b8..1ac73c5 100644
--- a/examples/tui_00.rs
+++ b/examples/tui_00.rs
@@ -10,7 +10,7 @@ tui_main!(State {
 });
 
 tui_keys!(|self: State, input| {
-    todo!()
+    Ok(())
 });
 
 tui_view!(|self: State| {
diff --git a/src/color.rs b/src/color.rs
index f16358a..82bdc70 100644
--- a/src/color.rs
+++ b/src/color.rs
@@ -1,10 +1,10 @@
-use ::ratatui::style::Color;
 use crate::lang::impl_from;
+use ::ratatui::style::Color;
+use ::rand::distributions::uniform::UniformSampler;
 pub(crate) use ::palette::{
     Okhsl, Srgb, OklabHue, Mix, okhsl::UniformOkhsl,
     convert::{FromColor, FromColorUnclamped}
 };
-use rand::distributions::uniform::UniformSampler;
 
 pub fn rgb (r: u8, g: u8, b: u8) -> ItemColor {
     let term = Color::Rgb(r, g, b);
diff --git a/src/draw.rs b/src/draw.rs
index 29dbac7..d6462fc 100644
--- a/src/draw.rs
+++ b/src/draw.rs
@@ -1,6 +1,3 @@
-use crate::*;
-pub use crate::space::*;
-
 mod draw;
 pub use self::draw::*;
 
@@ -13,6 +10,9 @@ pub use self::thunk::*;
 mod screen;
 pub use self::screen::*;
 
+use crate::*;
+pub use crate::space::*;
+
 /// Only render when condition is true.
 ///
 /// ```
diff --git a/src/draw/screen.rs b/src/draw/screen.rs
index dc51744..ea6b858 100644
--- a/src/draw/screen.rs
+++ b/src/draw/screen.rs
@@ -29,6 +29,6 @@ pub trait Screen: Space<Self::Unit> + Send + Sync + Sized {
     fn place_at <'t, T: Draw<Self> + ?Sized> (
         &mut self, _area: XYWH<Self::Unit>, _content: &'t T
     ) {
-        unimplemented!()
+        unimplemented!("place_at")
     }
 }
diff --git a/src/exit.rs b/src/exit.rs
index 0b79708..afdc2ad 100644
--- a/src/exit.rs
+++ b/src/exit.rs
@@ -14,4 +14,3 @@ impl AsRef<Arc<AtomicBool>> for Exit {
         &self.0
     }
 }
-
diff --git a/src/keys.rs b/src/keys.rs
index 9cc54e1..ba56615 100644
--- a/src/keys.rs
+++ b/src/keys.rs
@@ -7,8 +7,17 @@ use ::crossterm::event::{
     read, Event, KeyEvent, KeyCode, KeyModifiers, KeyEventKind, KeyEventState
 };
 
+/// Enable TUI keyboard input for main state struct.
+#[macro_export] macro_rules! tui_keys {
+    (|$self:ident:$State:ty,$input:ident|$body:block) => {
+        impl Apply<TuiEvent, Usually<()>> for $State {
+            fn apply (&mut $self, $input: &TuiEvent) -> Usually<()> $body
+        }
+    };
+}
+
 /// Spawn the TUI input thread which reads keys from the terminal.
-pub fn tui_input <T: Apply<TuiEvent, Usually<T>> + Send + Sync + 'static> (
+pub fn tui_input <T: Apply<TuiEvent, Usually<()>> + Send + Sync + 'static> (
     exited: &Arc<AtomicBool>, state: &Arc<RwLock<T>>, poll: Duration
 ) -> Result<Task, std::io::Error> {
     let exited = exited.clone();
@@ -39,8 +48,11 @@ pub fn tui_input <T: Apply<TuiEvent, Usually<T>> + Send + Sync + 'static> (
 /// 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 Ord for TuiEvent {
     fn cmp (&self, other: &Self) -> std::cmp::Ordering {
         self.partial_cmp(other)
@@ -51,6 +63,7 @@ impl Ord for TuiEvent {
 /// TUI key spec.
 #[derive(Debug, Clone, Eq, PartialEq, PartialOrd)]
 pub struct TuiKey(pub Option<KeyCode>, pub KeyModifiers);
+
 impl TuiKey {
     const SPLIT: char = '/';
     pub fn from_crossterm (event: KeyEvent) -> Self {
@@ -67,43 +80,43 @@ impl TuiKey {
     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('}'),
+            "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),
+            "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/term.rs b/src/term.rs
index 4be440c..ef9ddd1 100644
--- a/src/term.rs
+++ b/src/term.rs
@@ -1,4 +1,7 @@
-use crate::{*, lang::*, draw::*, space::{*, Split::*}, color::*, text::*, task::*};
+mod border;
+pub use self::border::*;
+
+use crate::{*, lang::*, draw::*, task::*};
 //use unicode_width::{UnicodeWidthStr, UnicodeWidthChar};
 //use rand::distributions::uniform::UniformSampler;
 use ::{
@@ -7,51 +10,84 @@ use ::{
         time::Duration,
         ops::{Deref, DerefMut},
     },
-    better_panic::{Settings, Verbosity},
     ratatui::{
-        prelude::{Style, Buffer as ScreenBuffer, Position, Backend, Color},
+        prelude::{Style, Position, Backend, Color},
         style::{Modifier, Color::*},
         backend::{CrosstermBackend, ClearType},
         layout::{Size, Rect},
         buffer::{Buffer, Cell},
+        crossterm::{
+            ExecutableCommand,
+            terminal::{EnterAlternateScreen, LeaveAlternateScreen, enable_raw_mode, disable_raw_mode},
+            //event::{poll, read, Event, KeyEvent, KeyCode, KeyModifiers, KeyEventKind, KeyEventState},
+        }
     },
-    crossterm::{
-        ExecutableCommand,
-        terminal::{EnterAlternateScreen, LeaveAlternateScreen, enable_raw_mode, disable_raw_mode},
-        //event::{poll, read, Event, KeyEvent, KeyCode, KeyModifiers, KeyEventKind, KeyEventState},
-    }
 };
 
 #[macro_export] macro_rules! tui_main {
     ($state:expr) => {
         pub fn main () -> Usually<()> {
-            tengri::exit::Exit::run(|exit|{
-                let state = Arc::new(RwLock::new($state));
-                let input = ::tengri::keys::tui_input(
-                    exit.as_ref(),
-                    &state,
-                    ::std::time::Duration::from_millis(100)
-                )?;
-                let output = ::tengri::term::tui_output(
-                    stdout(),
-                    exit.as_ref(),
-                    &state,
-                    ::std::time::Duration::from_millis(10)
-                )?;
+            use ::{
+                std::sync::{
+                    Arc,
+                    RwLock
+                },
+                std::panic::{
+                    set_hook,
+                    PanicHookInfo,
+                },
+                std::time::{
+                    Duration
+                },
+                better_panic::{
+                    Settings,
+                    Verbosity
+                },
+                ratatui::{
+                    backend::{
+                        Backend,
+                        CrosstermBackend
+                    },
+                    crossterm::{
+                        ExecutableCommand,
+                        terminal::{
+                            disable_raw_mode,
+                            LeaveAlternateScreen
+                        }
+                    }
+                },
+                tengri::{
+                    exit::Exit,
+                    keys::tui_input,
+                    term::tui_output,
+                }
+            };
+            let panic = Settings::auto()
+                .verbosity(Verbosity::Full)
+                .create_panic_handler();
+            set_hook(Box::new(move |info: &PanicHookInfo|{
+                stdout().execute(LeaveAlternateScreen).unwrap();
+                CrosstermBackend::new(stdout()).show_cursor().unwrap();
+                disable_raw_mode().unwrap();
+                panic(info);
+            }));
+            Exit::run(|exit|{
+                let state  = Arc::new(RwLock::new($state));
+                let scan   = Duration::from_millis(100);
+                let input  = tui_input(exit.as_ref(), &state, scan)?;
+                let frame  = Duration::from_millis(10);
+                let output = tui_output(stdout(), exit.as_ref(), &state, frame)?;
+                output.join();
+                stdout().execute(LeaveAlternateScreen)?;
+                CrosstermBackend::new(stdout()).show_cursor()?;
+                disable_raw_mode()?;
                 Ok(())
             })
         }
     }
 }
 
-#[macro_export] macro_rules! tui_keys {
-    (|$self:ident:$State:ty,$input:ident|$body:block) => {
-        impl Apply<TuiEvent, Usually<Self>> for $State {
-            fn apply (&mut $self, $input: &TuiEvent) -> Usually<Self> $body
-        }
-    };
-}
-
+/// Enable TUI output for state struct.
 #[macro_export] macro_rules! tui_view {
     (|$self:ident: $State:ty|$body:block) => {
         impl View<Tui> for $State {
@@ -61,42 +97,94 @@ use ::{
 }
 
 /// Spawn the TUI output thread which writes colored characters to the terminal.
-pub fn tui_output <W: Write + Send + Sync + 'static, T: View<Tui> + Send + Sync + 'static> (
+pub fn tui_output <
+    W: Write + Send + Sync + 'static, T: View<Tui> + Send + Sync + 'static
+> (
     output: W,
     exited: &Arc<AtomicBool>,
     state:  &Arc<RwLock<T>>,
     sleep:  Duration
 ) -> Usually<Task> {
     let state = state.clone();
-    tui_setup()?;
+    stdout().execute(EnterAlternateScreen)?;
+    CrosstermBackend::new(stdout()).hide_cursor()?;
+    enable_raw_mode()?;
     let mut backend = CrosstermBackend::new(output);
     let Size { width, height } = backend.size().expect("get size failed");
-    let mut buffer_a = Buffer::empty(Rect { x: 0, y: 0, width, height });
-    let mut buffer_b = Buffer::empty(Rect { x: 0, y: 0, width, height });
+    let mut prev = Tui::new(width, height);
+    let mut next = Tui::new(width, height);
     Ok(Task::new_sleep(exited.clone(), sleep, move |perf| {
         let Size { width, height } = backend.size().expect("get size failed");
         if let Ok(state) = state.try_read() {
-            tui_resize(&mut backend, &mut buffer_a, Rect { x: 0, y: 0, width, height });
-            tui_redraw(&mut backend, &mut buffer_a, &mut buffer_b);
+            prev.resize(&mut backend, width, height);
+            state.view().draw(&mut next).expect("draw failed"); // TODO draw error
+            prev.redraw(&mut backend, &mut next);
+            //tui_redraw(&mut backend, &mut prev, &mut next);
         }
         let timer = format!("{:>3.3}ms", perf.used.load(Relaxed));
-        buffer_a.set_string(0, 0, &timer, Style::default());
+        prev.set_string(0, 0, &timer, Style::default());
     })?)
 }
 
-pub struct Tui(pub Buffer, pub XYWH<u16>);
-impl Screen    for Tui { type Unit = u16; }
-impl Deref     for Tui { type Target = Buffer; fn deref (&self) -> &Buffer { &self.0 } }
-impl DerefMut  for Tui { fn deref_mut (&mut self) -> &mut Buffer { &mut self.0 } }
+pub fn tui_redraw <'b, W: Write> (
+    back: &mut CrosstermBackend<W>,
+    mut prev: &'b mut Buffer,
+    mut next: &'b mut Buffer
+) {
+    let updates = prev.diff(&next);
+    back.draw(updates.into_iter()).expect("failed to render");
+    Backend::flush(back).expect("failed to flush output new");
+    std::mem::swap(&mut prev, &mut next);
+    next.reset();
+}
+
+/// Terminal output.
+pub struct Tui(
+    /// Ratatui buffer; area is screen size
+    pub Buffer,
+    /// Current draw area
+    pub XYWH<u16>
+);
+
+impl Tui {
+    fn new (width: u16, height: u16) -> Self {
+        Self(Buffer::empty(Rect { x: 0, y: 0, width, height }), XYWH(0, 0, width, height))
+    }
+    fn resize <W: Write> (&mut self, back: &mut CrosstermBackend<W>, width: u16, height: u16) {
+        let size = Rect { x: 0, y: 0, width, height };
+        if self.0.area != size {
+            back.clear_region(ClearType::All).unwrap();
+            self.0.resize(size);
+            self.0.reset();
+        }
+    }
+    fn redraw <'b, W: Write> (&'b mut self, back: &mut CrosstermBackend<W>, mut next: &'b mut Self) {
+        let updates = self.0.diff(&next.0);
+        back.draw(updates.into_iter()).expect("failed to render");
+        Backend::flush(back).expect("failed to flush output new");
+        std::mem::swap(self, &mut next);
+        next.0.reset();
+    }
+}
+
+impl Screen for Tui { type Unit = u16; }
+
+impl Deref for Tui { type Target = Buffer; fn deref (&self) -> &Buffer { &self.0 } }
+
+impl DerefMut for Tui { fn deref_mut (&mut self) -> &mut Buffer { &mut self.0 } }
+
 impl HasOrigin for Tui { fn origin (&self) -> Origin { Origin::NW } }
+
 impl X<u16> for Tui {
     fn x (&self) -> u16 { self.1.0 }
     fn w (&self) -> u16 { self.1.2 }
 }
+
 impl Y<u16> for Tui {
     fn y (&self) -> u16 { self.1.1 }
     fn h (&self) -> u16 { self.1.3 }
 }
+
 impl Tui {
     pub fn update (&mut self, callback: &impl Fn(&mut Cell, u16, u16)) -> XYWH<u16> {
         for row in 0..self.h() {
@@ -127,6 +215,7 @@ impl Tui {
         }
     }
 }
+
 /// Apply foreground color.
 pub const fn fg (fg: Color, draw: impl Draw<Tui>) -> impl Draw<Tui> {
     thunk(move|to: &mut Tui|{
@@ -134,6 +223,7 @@ pub const fn fg (fg: Color, draw: impl Draw<Tui>) -> impl Draw<Tui> {
         draw.draw(to)
     })
 }
+
 /// Apply background color.
 pub const fn bg (bg: Color, draw: impl Draw<Tui>) -> impl Draw<Tui> {
     thunk(move|to: &mut Tui|{
@@ -141,17 +231,20 @@ pub const fn bg (bg: Color, draw: impl Draw<Tui>) -> impl Draw<Tui> {
         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) -> impl Draw<Tui> {
     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|{
@@ -159,6 +252,7 @@ pub const fn modify (on: bool, modifier: Modifier, draw: impl Draw<Tui>) -> impl
         draw.draw(to)
     })
 }
+
 pub const fn fill_mod (on: bool, modifier: Modifier) -> impl Draw<Tui> {
     thunk(move|to: &mut Tui|Ok({
         if on {
@@ -168,10 +262,12 @@ pub const fn fill_mod (on: bool, modifier: Modifier) -> impl Draw<Tui> {
         }
     }))
 }
+
 /// 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 (color: Option<Color>) -> impl Draw<Tui> {
     thunk(move|to: &mut Tui|Ok(if let Some(color) = color {
         to.update(&|cell,_,_|{
@@ -196,6 +292,7 @@ impl Coord for u16 {
 impl Draw<Tui> for u64 {
     fn draw (self, _to: &mut Tui) -> Usually<XYWH<u16>> { todo!() }
 }
+
 impl Draw<Tui> for f64 {
     fn draw (self, _to: &mut Tui) -> Usually<XYWH<u16>> { todo!() }
 }
@@ -288,216 +385,6 @@ pub const fn button_3 <'a> (
             east(fg_bg(tui_g(224), tui_g(128), value), fg_bg(tui_g(128), Reset, "▌"), ))))
 }
 
-macro_rules! border {
-    ($($T:ident {
-        $nw:literal $n:literal $ne:literal $w:literal $e:literal $sw:literal $s:literal $se:literal
-        $($x:tt)*
-    }),+) => {$(
-        impl BorderStyle for $T {
-            const NW: &'static str = $nw;
-            const N:  &'static str = $n;
-            const NE: &'static str = $ne;
-            const W:  &'static str = $w;
-            const E:  &'static str = $e;
-            const SW: &'static str = $sw;
-            const S:  &'static str = $s;
-            const SE: &'static str = $se;
-            $($x)*
-            fn enabled (&self) -> bool { self.0 }
-        }
-        #[derive(Copy, Clone)] pub struct $T(pub bool, pub Style);
-        //impl Layout<Tui> for $T {}
-        impl Draw<Tui> for $T {
-            fn draw (self, to: &mut Tui) -> Usually<XYWH<u16>> {
-                when(self.enabled(), thunk(|to: &mut Tui|BorderStyle::draw(self, to))).draw(to)
-            }
-        }
-    )+}
-}
-
-border! {
-    Square {
-        "┌" "─" "┐"
-        "│"     "│"
-        "└" "─" "┘" fn style (&self) -> Option<Style> { Some(self.1) }
-    },
-    SquareBold {
-        "┏" "━" "┓"
-        "┃"     "┃"
-        "┗" "━" "┛" fn style (&self) -> Option<Style> { Some(self.1) }
-    },
-    TabLike {
-        "╭" "─" "╮"
-        "│"     "│"
-        "│" " " "│" fn style (&self) -> Option<Style> { Some(self.1) }
-    },
-    Lozenge {
-        "╭" "─" "╮"
-        "│"     "│"
-        "╰" "─" "╯" fn style (&self) -> Option<Style> { Some(self.1) }
-    },
-    Brace {
-        "╭" "" "╮"
-        "│"    "│"
-        "╰" "" "╯" fn style (&self) -> Option<Style> { Some(self.1) }
-    },
-    LozengeDotted {
-        "╭" "┅" "╮"
-        "┇"     "┇"
-        "╰" "┅" "╯" fn style (&self) -> Option<Style> { Some(self.1) }
-    },
-    Quarter {
-        "▎" "▔" "🮇"
-        "▎"     "🮇"
-        "▎" "▁" "🮇" fn style (&self) -> Option<Style> { Some(self.1) }
-    },
-    QuarterV {
-        "▎" "" "🮇"
-        "▎"    "🮇"
-        "▎" "" "🮇" fn style (&self) -> Option<Style> { Some(self.1) }
-    },
-    Chamfer {
-        "🭂" "▔" "🭍"
-        "▎"     "🮇"
-        "🭓" "▁" "🭞" fn style (&self) -> Option<Style> { Some(self.1) }
-    },
-    Corners {
-        "🬆" "" "🬊" // 🬴 🬸
-        ""     ""
-        "🬱" "" "🬵" fn style (&self) -> Option<Style> { Some(self.1) }
-    },
-    CornersTall {
-        "🭽" "" "🭾"
-        ""     ""
-        "🭼" "" "🭿" fn style (&self) -> Option<Style> { Some(self.1) }
-    },
-    Outer {
-        "🭽" "▔" "🭾"
-        "▏"     "▕"
-        "🭼" "▁" "🭿"
-        const W0: &'static str = "[";
-        const E0: &'static str = "]";
-        const N0: &'static str = "⎴";
-        const S0: &'static str = "⎵";
-        fn style (&self) -> Option<Style> { Some(self.1) }
-    },
-    Thick {
-        "▄" "▄" "▄"
-        "█"     "█"
-        "▀" "▀" "▀"
-        fn style (&self) -> Option<Style> { Some(self.1) }
-    },
-    Rugged {
-        "▄" "▂" "▄"
-        "▐"     "▌"
-        "▀" "🮂" "▀"
-        fn style (&self) -> Option<Style> { Some(self.1) }
-    },
-    Skinny {
-        "▗" "▄" "▖"
-        "▐"     "▌"
-        "▝" "▀" "▘"
-        fn style (&self) -> Option<Style> { Some(self.1) }
-    },
-    Brackets {
-        "⎡" "" "⎤"
-        ""     ""
-        "⎣" "" "⎦"
-        const W0: &'static str = "[";
-        const E0: &'static str = "]";
-        const N0: &'static str = "⎴";
-        const S0: &'static str = "⎵";
-        fn style (&self) -> Option<Style> { Some(self.1) }
-    },
-    Reticle {
-        "⎡" "" "⎤"
-        ""     ""
-        "⎣" "" "⎦"
-        const W0: &'static str = "╟";
-        const E0: &'static str = "╢";
-        const N0: &'static str = "┯";
-        const S0: &'static str = "┷";
-        fn style (&self) -> Option<Style> { Some(self.1) }
-    }
-}
-
-pub trait BorderStyle: Draw<Tui> + Copy {
-    fn enabled   (&self) -> bool;
-    fn border_n  (&self) -> &str { Self::N  }
-    fn border_s  (&self) -> &str { Self::S  }
-    fn border_e  (&self) -> &str { Self::E  }
-    fn border_w  (&self) -> &str { Self::W  }
-    fn border_nw (&self) -> &str { Self::NW }
-    fn border_ne (&self) -> &str { Self::NE }
-    fn border_sw (&self) -> &str { Self::SW }
-    fn border_se (&self) -> &str { Self::SE }
-
-    #[inline] fn draw <'a> (self, to: &mut Tui) -> Usually<XYWH<u16>> {
-        if self.enabled() {
-            self.draw_h(to, None)?;
-            self.draw_v(to, None)?;
-            self.draw_c(to, None)?;
-        }
-        Ok(to.1)
-    }
-    #[inline] fn draw_h (self, to: &mut Tui, style: Option<Style>) -> Usually<XYWH<u16>> {
-        let style = style.or_else(||self.style_horizontal());
-        let y1 = to.y_north();
-        let y2 = to.y_south().saturating_sub(1);
-        for x in to.x_west()..to.x_east().saturating_sub(1) {
-            to.blit(&Self::N, x, y1, style);
-            to.blit(&Self::S, x, y2, style)
-        }
-        Ok(to.xywh())
-    }
-    #[inline] fn draw_v (self, to: &mut Tui, style: Option<Style>) -> Usually<XYWH<u16>> {
-        let area = to.1;
-        let style = style.or_else(||self.style_vertical());
-        let [x, x2, y, y2] = area.lrtb();
-        let h = y2 - y;
-        if h > 1 {
-            for y in y..y2.saturating_sub(1) {
-                to.blit(&Self::W, x, y, style);
-                to.blit(&Self::E, x2.saturating_sub(1), y, style);
-            }
-        } else if h > 0 {
-            to.blit(&Self::W0, x, y, style);
-            to.blit(&Self::E0, x2.saturating_sub(1), y, style);
-        }
-        Ok(area)
-    }
-    #[inline] fn draw_c (self, to: &mut Tui, style: Option<Style>) -> Usually<XYWH<u16>> {
-        let area = to.1;
-        let style = style.or_else(||self.style_corners());
-        let XYWH(x, y, w, h) = area;
-        if w > 1 && h > 1 {
-            to.blit(&Self::NW, x, y, style);
-            to.blit(&Self::NE, x + w - 1, y, style);
-            to.blit(&Self::SW, x, y + h- 1, style);
-            to.blit(&Self::SE, x + w - 1, y + h - 1, style);
-        }
-        Ok(area)
-    }
-    #[inline] fn style            (&self) -> Option<Style> { None }
-    #[inline] fn style_horizontal (&self) -> Option<Style> { self.style() }
-    #[inline] fn style_vertical   (&self) -> Option<Style> { self.style() }
-    #[inline] fn style_corners    (&self) -> Option<Style> { self.style() }
-
-    const NW: &'static str = "";
-    const N:  &'static str = "";
-    const NE: &'static str = "";
-    const E:  &'static str = "";
-    const SE: &'static str = "";
-    const S:  &'static str = "";
-    const SW: &'static str = "";
-    const W:  &'static str = "";
-
-    const N0: &'static str = "";
-    const S0: &'static str = "";
-    const W0: &'static str = "";
-    const E0: &'static str = "";
-}
-
 /// Stackably padded.
 ///
 /// ```
@@ -566,82 +453,20 @@ fn y_scroll () -> impl Draw<Tui> {
     })
 }
 
-pub fn tui_redraw <'b, W: Write> (
-    backend: &mut CrosstermBackend<W>,
-    mut prev_buffer: &'b mut Buffer,
-    mut next_buffer: &'b mut Buffer
-) {
-    let updates = prev_buffer.diff(&next_buffer);
-    backend.draw(updates.into_iter()).expect("failed to render");
-    Backend::flush(backend).expect("failed to flush output new_buffer");
-    std::mem::swap(&mut prev_buffer, &mut next_buffer);
-    next_buffer.reset();
-}
-
-pub fn tui_setup () -> Usually<()> {
-    let better_panic_handler = Settings::auto().verbosity(Verbosity::Full).create_panic_handler();
-    std::panic::set_hook(Box::new(move |info: &std::panic::PanicHookInfo|{
-        stdout().execute(LeaveAlternateScreen).unwrap();
-        CrosstermBackend::new(stdout()).show_cursor().unwrap();
-        disable_raw_mode().unwrap();
-        better_panic_handler(info);
-    }));
-    stdout().execute(EnterAlternateScreen)?;
-    CrosstermBackend::new(stdout()).hide_cursor()?;
-    enable_raw_mode().map_err(Into::into)
-}
-
-pub fn tui_resize <W: Write> (
-    backend: &mut CrosstermBackend<W>,
-    buffer:  &mut Buffer,
-    size:    Rect
-) {
-    if buffer.area != size {
-        backend.clear_region(ClearType::All).unwrap();
-        buffer.resize(size);
-        buffer.reset();
-    }
-}
-
 pub fn tui_teardown <W: Write> (backend: &mut CrosstermBackend<W>) -> Usually<()> {
+    use ::ratatui::backend::Backend;
     stdout().execute(LeaveAlternateScreen)?;
     backend.show_cursor()?;
     disable_raw_mode().map_err(Into::into)
 }
 
 pub fn tui_update (
-    Tui(buf, ..): &mut Tui, area: XYWH<u16>, callback: &impl Fn(&mut Cell, u16, u16)
+    Tui(buf, ..): &mut Tui,
+    area: XYWH<u16>,
+    callback: &impl Fn(&mut Cell, u16, u16)
 ) {
 }
 
-/// Draw border around shrinked item.
-///
-/// ```
-/// /// TODO
-/// ```
-pub const fn border <T, S: BorderStyle> (on: bool, style: S, draw: impl Draw<Tui>) -> impl Draw<Tui> {
-    let content = wh_pad(1, 1, draw);
-    let outline = when(on, thunk(move|to: &mut Tui|{
-        let XYWH(x, y, w, h) = to.1;
-        if w > 0 && h > 0 {
-            to.blit(&style.border_nw(), x, y, style.style());
-            to.blit(&style.border_ne(), x + w - 1, y, style.style());
-            to.blit(&style.border_sw(), x, y + h - 1, style.style());
-            to.blit(&style.border_se(), x + w - 1, y + h - 1, style.style());
-            for x in x+1..x+w-1 {
-                to.blit(&style.border_n(), x, y, style.style());
-                to.blit(&style.border_s(), x, y + h - 1, style.style());
-            }
-            for y in y+1..y+h-1 {
-                to.blit(&style.border_w(), x, y, style.style());
-                to.blit(&style.border_e(), x + w - 1, y, style.style());
-            }
-        }
-        Ok(XYWH(x, y, w, h))
-    }));
-    above(outline, content)
-}
-
 /// Draw TUI content or its error message.
 ///
 /// ```
@@ -663,14 +488,16 @@ pub fn catcher <T: Draw<Tui>> (result: Usually<T>) -> impl Draw<Tui> {
 }
 
 /// TUI buffer sized by `usize` instead of `u16`.
-#[derive(Default)]
-pub struct BigBuffer {
+#[derive(Default)] pub struct BigBuffer {
     pub width:   usize,
     pub height:  usize,
     pub content: Vec<Cell>
 }
+
 impl_from!(BigBuffer: |size:(usize, usize)| Self::new(size.0, size.1));
+
 impl_debug!(BigBuffer |self, f| { write!(f, "[BB {}x{} ({})]", self.width, self.height, self.content.len()) });
+
 impl BigBuffer {
     pub fn new (width: usize, height: usize) -> Self {
         Self { width, height, content: vec![Cell::default(); width*height] }
diff --git a/src/term/border.rs b/src/term/border.rs
new file mode 100644
index 0000000..1fbd210
--- /dev/null
+++ b/src/term/border.rs
@@ -0,0 +1,239 @@
+use super::*;
+
+/// Draw border around item shrunk by 1 on each side.
+///
+/// ```
+/// /// TODO
+/// ```
+pub const fn border <T, S: BorderStyle> (on: bool, style: S, draw: impl Draw<Tui>) -> impl Draw<Tui> {
+    let content = wh_pad(1, 1, draw);
+    let outline = when(on, thunk(move|to: &mut Tui|{
+        let XYWH(x, y, w, h) = to.1;
+        if w > 0 && h > 0 {
+            to.blit(&style.border_nw(), x, y, style.style());
+            to.blit(&style.border_ne(), x + w - 1, y, style.style());
+            to.blit(&style.border_sw(), x, y + h - 1, style.style());
+            to.blit(&style.border_se(), x + w - 1, y + h - 1, style.style());
+            for x in x+1..x+w-1 {
+                to.blit(&style.border_n(), x, y, style.style());
+                to.blit(&style.border_s(), x, y + h - 1, style.style());
+            }
+            for y in y+1..y+h-1 {
+                to.blit(&style.border_w(), x, y, style.style());
+                to.blit(&style.border_e(), x + w - 1, y, style.style());
+            }
+        }
+        Ok(XYWH(x, y, w, h))
+    }));
+    above(outline, content)
+}
+
+macro_rules! border {
+    ($($T:ident {
+        $nw:literal $n:literal $ne:literal $w:literal $e:literal $sw:literal $s:literal $se:literal
+        $($x:tt)*
+    }),+) => {$(
+        impl BorderStyle for $T {
+            const NW: &'static str = $nw;
+            const N:  &'static str = $n;
+            const NE: &'static str = $ne;
+            const W:  &'static str = $w;
+            const E:  &'static str = $e;
+            const SW: &'static str = $sw;
+            const S:  &'static str = $s;
+            const SE: &'static str = $se;
+            $($x)*
+            fn enabled (&self) -> bool { self.0 }
+        }
+        #[derive(Copy, Clone)] pub struct $T(pub bool, pub Style);
+        //impl Layout<Tui> for $T {}
+        impl Draw<Tui> for $T {
+            fn draw (self, to: &mut Tui) -> Usually<XYWH<u16>> {
+                when(self.enabled(), thunk(|to: &mut Tui|BorderStyle::draw(self, to))).draw(to)
+            }
+        }
+    )+}
+}
+
+border! {
+    Square {
+        "┌" "─" "┐"
+        "│"     "│"
+        "└" "─" "┘" fn style (&self) -> Option<Style> { Some(self.1) }
+    },
+    SquareBold {
+        "┏" "━" "┓"
+        "┃"     "┃"
+        "┗" "━" "┛" fn style (&self) -> Option<Style> { Some(self.1) }
+    },
+    TabLike {
+        "╭" "─" "╮"
+        "│"     "│"
+        "│" " " "│" fn style (&self) -> Option<Style> { Some(self.1) }
+    },
+    Lozenge {
+        "╭" "─" "╮"
+        "│"     "│"
+        "╰" "─" "╯" fn style (&self) -> Option<Style> { Some(self.1) }
+    },
+    Brace {
+        "╭" "" "╮"
+        "│"    "│"
+        "╰" "" "╯" fn style (&self) -> Option<Style> { Some(self.1) }
+    },
+    LozengeDotted {
+        "╭" "┅" "╮"
+        "┇"     "┇"
+        "╰" "┅" "╯" fn style (&self) -> Option<Style> { Some(self.1) }
+    },
+    Quarter {
+        "▎" "▔" "🮇"
+        "▎"     "🮇"
+        "▎" "▁" "🮇" fn style (&self) -> Option<Style> { Some(self.1) }
+    },
+    QuarterV {
+        "▎" "" "🮇"
+        "▎"    "🮇"
+        "▎" "" "🮇" fn style (&self) -> Option<Style> { Some(self.1) }
+    },
+    Chamfer {
+        "🭂" "▔" "🭍"
+        "▎"     "🮇"
+        "🭓" "▁" "🭞" fn style (&self) -> Option<Style> { Some(self.1) }
+    },
+    Corners {
+        "🬆" "" "🬊" // 🬴 🬸
+        ""     ""
+        "🬱" "" "🬵" fn style (&self) -> Option<Style> { Some(self.1) }
+    },
+    CornersTall {
+        "🭽" "" "🭾"
+        ""     ""
+        "🭼" "" "🭿" fn style (&self) -> Option<Style> { Some(self.1) }
+    },
+    Outer {
+        "🭽" "▔" "🭾"
+        "▏"     "▕"
+        "🭼" "▁" "🭿"
+        const W0: &'static str = "[";
+        const E0: &'static str = "]";
+        const N0: &'static str = "⎴";
+        const S0: &'static str = "⎵";
+        fn style (&self) -> Option<Style> { Some(self.1) }
+    },
+    Thick {
+        "▄" "▄" "▄"
+        "█"     "█"
+        "▀" "▀" "▀"
+        fn style (&self) -> Option<Style> { Some(self.1) }
+    },
+    Rugged {
+        "▄" "▂" "▄"
+        "▐"     "▌"
+        "▀" "🮂" "▀"
+        fn style (&self) -> Option<Style> { Some(self.1) }
+    },
+    Skinny {
+        "▗" "▄" "▖"
+        "▐"     "▌"
+        "▝" "▀" "▘"
+        fn style (&self) -> Option<Style> { Some(self.1) }
+    },
+    Brackets {
+        "⎡" "" "⎤"
+        ""     ""
+        "⎣" "" "⎦"
+        const W0: &'static str = "[";
+        const E0: &'static str = "]";
+        const N0: &'static str = "⎴";
+        const S0: &'static str = "⎵";
+        fn style (&self) -> Option<Style> { Some(self.1) }
+    },
+    Reticle {
+        "⎡" "" "⎤"
+        ""     ""
+        "⎣" "" "⎦"
+        const W0: &'static str = "╟";
+        const E0: &'static str = "╢";
+        const N0: &'static str = "┯";
+        const S0: &'static str = "┷";
+        fn style (&self) -> Option<Style> { Some(self.1) }
+    }
+}
+
+pub trait BorderStyle: Draw<Tui> + Copy {
+    fn enabled   (&self) -> bool;
+    fn border_n  (&self) -> &str { Self::N  }
+    fn border_s  (&self) -> &str { Self::S  }
+    fn border_e  (&self) -> &str { Self::E  }
+    fn border_w  (&self) -> &str { Self::W  }
+    fn border_nw (&self) -> &str { Self::NW }
+    fn border_ne (&self) -> &str { Self::NE }
+    fn border_sw (&self) -> &str { Self::SW }
+    fn border_se (&self) -> &str { Self::SE }
+
+    #[inline] fn draw <'a> (self, to: &mut Tui) -> Usually<XYWH<u16>> {
+        if self.enabled() {
+            self.draw_h(to, None)?;
+            self.draw_v(to, None)?;
+            self.draw_c(to, None)?;
+        }
+        Ok(to.1)
+    }
+    #[inline] fn draw_h (self, to: &mut Tui, style: Option<Style>) -> Usually<XYWH<u16>> {
+        let style = style.or_else(||self.style_horizontal());
+        let y1 = to.y_north();
+        let y2 = to.y_south().saturating_sub(1);
+        for x in to.x_west()..to.x_east().saturating_sub(1) {
+            to.blit(&Self::N, x, y1, style);
+            to.blit(&Self::S, x, y2, style)
+        }
+        Ok(to.xywh())
+    }
+    #[inline] fn draw_v (self, to: &mut Tui, style: Option<Style>) -> Usually<XYWH<u16>> {
+        let area = to.1;
+        let style = style.or_else(||self.style_vertical());
+        let [x, x2, y, y2] = area.lrtb();
+        let h = y2 - y;
+        if h > 1 {
+            for y in y..y2.saturating_sub(1) {
+                to.blit(&Self::W, x, y, style);
+                to.blit(&Self::E, x2.saturating_sub(1), y, style);
+            }
+        } else if h > 0 {
+            to.blit(&Self::W0, x, y, style);
+            to.blit(&Self::E0, x2.saturating_sub(1), y, style);
+        }
+        Ok(area)
+    }
+    #[inline] fn draw_c (self, to: &mut Tui, style: Option<Style>) -> Usually<XYWH<u16>> {
+        let area = to.1;
+        let style = style.or_else(||self.style_corners());
+        let XYWH(x, y, w, h) = area;
+        if w > 1 && h > 1 {
+            to.blit(&Self::NW, x, y, style);
+            to.blit(&Self::NE, x + w - 1, y, style);
+            to.blit(&Self::SW, x, y + h- 1, style);
+            to.blit(&Self::SE, x + w - 1, y + h - 1, style);
+        }
+        Ok(area)
+    }
+    #[inline] fn style            (&self) -> Option<Style> { None }
+    #[inline] fn style_horizontal (&self) -> Option<Style> { self.style() }
+    #[inline] fn style_vertical   (&self) -> Option<Style> { self.style() }
+    #[inline] fn style_corners    (&self) -> Option<Style> { self.style() }
+
+    const NW: &'static str = "";
+    const N:  &'static str = "";
+    const NE: &'static str = "";
+    const E:  &'static str = "";
+    const SE: &'static str = "";
+    const S:  &'static str = "";
+    const SW: &'static str = "";
+    const W:  &'static str = "";
+
+    const N0: &'static str = "";
+    const S0: &'static str = "";
+    const W0: &'static str = "";
+    const E0: &'static str = "";
+}

From 2dc501c184c0404a50b220a9fe9f756b87e4635b Mon Sep 17 00:00:00 2001
From: facile pop culture reference <donotem@ilme.no>
Date: Tue, 16 Jun 2026 14:23:03 +0300
Subject: [PATCH 05/25] fokken wip

---
 dizzle             |  2 +-
 src/draw.rs        | 68 ++++++++++++++++++++++++++++++++--------------
 src/draw/draw.rs   | 60 ----------------------------------------
 src/draw/screen.rs | 12 ++------
 src/draw/thunk.rs  | 43 ++++++++++++++++++++++++++---
 src/eval.rs        | 25 +++++++----------
 src/lib.rs         |  2 +-
 src/space.rs       | 11 ++++++--
 src/space/iter.rs  |  2 +-
 src/space/split.rs |  8 +++---
 src/term.rs        | 32 ++++++++++------------
 11 files changed, 129 insertions(+), 136 deletions(-)
 delete mode 100644 src/draw/draw.rs

diff --git a/dizzle b/dizzle
index e984fbb..2dbf9d8 160000
--- a/dizzle
+++ b/dizzle
@@ -1 +1 @@
-Subproject commit e984fbb9fe8e588399744d50841d006454c16657
+Subproject commit 2dbf9d8797a3642f69813be4ef3613836e061b94
diff --git a/src/draw.rs b/src/draw.rs
index d6462fc..76dc916 100644
--- a/src/draw.rs
+++ b/src/draw.rs
@@ -1,5 +1,5 @@
-mod draw;
-pub use self::draw::*;
+use crate::*;
+pub use crate::space::*;
 
 mod view;
 pub use self::view::*;
@@ -10,29 +10,57 @@ pub use self::thunk::*;
 mod screen;
 pub use self::screen::*;
 
-use crate::*;
-pub use crate::space::*;
-
-/// Only render when condition is true.
+/// Implement the [Draw] trait for a particular drawable and [Screen].
 ///
 /// ```
-/// # use tengri::draw::*;
-/// # fn test () -> impl tengri::draw::Draw<tengri::term::Tui> {
-///     when(true, "Yes")
-/// # }
+/// use tengri::{*, draw::*, term::*};
+/// struct MyDrawable;
+/// impl_draw!(|self: MyDrawable, to: Tui|{
+///     todo!("your draw logic")
+/// });
 /// ```
-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()) })
-}
+#[macro_export] macro_rules! impl_draw ((|
+    $self:ident:$Self:ty, $to:ident:$To:ty
+|$draw:block)=>{ impl Draw<$To> for $Self {
+    fn draw ($self, $to: &mut $To) -> Usually<XYWH<u16>> $draw
+} });
 
-/// Render one thing if a condition is true and another false.
+/// Drawable that supports dynamic dispatch.
+///
+/// Drawables are composable, e.g. the [when] and [either] conditionals
+/// or the layout constraints.
+///
+/// Drawables are consumable, i.e. the [Draw::draw] method receives an
+/// owned `self` and does not return it, consuming the drawable.
+///
+/// To draw a thing multiple times, instead of explicitly constructing it
+/// every time, implement the [View] trait instead, which will construct
+/// a [Draw]able.
 ///
 /// ```
-/// # use tengri::draw::*;
-/// # fn test () -> impl tengri::draw::Draw<tengri::term::Tui> {
-///     either(true, "Yes", "No")
-/// # }
+/// use tengri::{*, draw::*, term::*};
+/// struct MyWidget(bool);
+/// impl Draw<Tui> for MyWidget {
+///     fn draw (self, to: &mut Tui) -> Usually<XYWH<u16>> {
+///         todo!("your draw logic")
+///     }
+/// }
 /// ```
-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) })
+pub trait Draw<T: Screen> {
+    fn draw (self, to: &mut T) -> Usually<XYWH<T::Unit>>;
 }
+impl<T: Screen, D: Draw<T>> Draw<T> for &D {
+    fn draw (self, __: &mut T) -> Usually<XYWH<T::Unit>> {
+        todo!()
+    }
+}
+impl<T: Screen, D: Draw<T>> Draw<T> for Option<D> {
+    fn draw (self, __: &mut T) -> Usually<XYWH<T::Unit>> {
+        todo!()
+    }
+}
+//impl<T: Screen, D: Draw<T>> Draw<T> for Arc<D> {
+    //fn draw (self, __: &mut T) -> Usually<XYWH<T::Unit>> {
+        //todo!()
+    //}
+//}
diff --git a/src/draw/draw.rs b/src/draw/draw.rs
deleted file mode 100644
index 8701084..0000000
--- a/src/draw/draw.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-use super::*;
-
-/// Implement the [Draw] trait for a particular drawable and [Screen].
-///
-/// ```
-/// use tengri::{*, draw::*, term::*};
-/// struct MyDrawable;
-/// impl_draw!(|self: MyDrawable, to: Tui|{
-///   todo!()
-/// });
-/// ```
-#[macro_export] macro_rules! impl_draw ((|
-    $self:ident:$Self:ty, $to:ident:$To:ty
-|$draw:block)=>{ impl Draw<$To> for $Self {
-    fn draw ($self, $to: &mut $To) -> Usually<XYWH<u16>> $draw
-} });
-
-/// Drawable that supports dynamic dispatch.
-///
-/// Drawables are composable, e.g. the [when] and [either] conditionals
-/// or the layout constraints.
-///
-/// Drawables are consumable, i.e. the [Draw::draw] method receives an
-/// owned `self` and does not return it, consuming the drawable.
-///
-/// To draw a thing multiple times, instead of explicitly constructing it
-/// every time, implement the [View] trait instead, which will construct
-/// a [Draw]able.
-/// 
-/// ```
-/// use tengri::{*, draw::*};
-/// struct MyScreen(bool);
-/// impl Screen for MyScreen { type Unit = u16; }
-/// impl X<u16> for MyScreen { fn x (&self) -> u16 { 0 } }
-/// impl Y<u16> for MyScreen { fn y (&self) -> u16 { 0 } }
-/// struct MyWidget(bool);
-/// impl Draw<MyScreen> for MyWidget {
-///     fn draw (self, screen: &mut MyScreen) -> Usually<XYWH<u16>> {
-///         screen.0 |= self.0;
-///     }
-/// }
-/// let mut screen = MyScreen(false);
-/// MyWidget(false).draw(&mut screen);
-/// MyWidget(true).draw(&mut screen);
-/// MyWidget(false).draw(&mut screen);
-/// ```
-pub trait Draw<T: Screen> {
-    fn draw (self, to: &mut T) -> Usually<XYWH<T::Unit>>;
-}
-impl<T: Screen, D: Draw<T>> Draw<T> for &D {
-    fn draw (self, __: &mut T) -> Usually<XYWH<T::Unit>> {
-        todo!()
-    }
-}
-impl<T: Screen, D: Draw<T>> Draw<T> for Option<D> {
-    fn draw (self, __: &mut T) -> Usually<XYWH<T::Unit>> {
-        todo!()
-    }
-}
-
diff --git a/src/draw/screen.rs b/src/draw/screen.rs
index ea6b858..eab296b 100644
--- a/src/draw/screen.rs
+++ b/src/draw/screen.rs
@@ -9,7 +9,7 @@ use super::*;
 ///
 /// impl<T: Screen<Unit = u16>> Screen for TestOut {
 ///     type Unit = u16;
-///     fn place_at <D: Draw<Self> + ?Sized> (&mut self, area: T, _: D) {
+///     fn show <D: Draw<Self> + ?Sized> (&mut self, area: T, _: D) {
 ///         println!("placed: {area:?}");
 ///         ()
 ///     }
@@ -21,14 +21,6 @@ use super::*;
 /// ```
 pub trait Screen: Space<Self::Unit> + Send + Sync + Sized {
     type Unit: Coord;
-    /// Render drawable in area.
-    fn place <'t, T: Draw<Self> + ?Sized> (&mut self, content: &'t T) {
-        self.place_at(self.xywh(), content)
-    }
     /// Render drawable in subarea specified by `area`
-    fn place_at <'t, T: Draw<Self> + ?Sized> (
-        &mut self, _area: XYWH<Self::Unit>, _content: &'t T
-    ) {
-        unimplemented!("place_at")
-    }
+    fn show <'t, T: Draw<Self>> (&mut self, area: XYWH<Self::Unit>, content: T);
 }
diff --git a/src/draw/thunk.rs b/src/draw/thunk.rs
index 9b1d4b5..a56b5f3 100644
--- a/src/draw/thunk.rs
+++ b/src/draw/thunk.rs
@@ -1,16 +1,51 @@
 use super::*;
 
-pub const fn thunk <T: Screen, F: FnOnce(&mut T)->Usually<XYWH<T::Unit>>> (draw: F) -> Thunk<T, F> {
-    Thunk(draw, std::marker::PhantomData)
-}
-
 /// Because we can't implement [Draw] for `F: FnOnce...` without conflicts.
 pub struct Thunk<T: Screen, F: FnOnce(&mut T)->Usually<XYWH<T::Unit>>>(
     pub F,
     std::marker::PhantomData<T>
 );
+
 impl<T: Screen, F: FnOnce(&mut T)->Usually<XYWH<T::Unit>>> Draw<T> for Thunk<T, F> {
     fn draw (self, to: &mut T) -> Usually<XYWH<T::Unit>> {
         (self.0)(to)
     }
 }
+
+/// Basic [Draw]able closure.
+///
+/// ```
+/// # use tengri::{draw::*, term::*};
+/// # fn test () -> impl tengri::draw::Draw<tengri::term::Tui> {
+///     thunk(|to: &mut Tui|Ok(to.1))
+/// # }
+/// ```
+pub const fn thunk <T: Screen, F: FnOnce(&mut T)->Usually<XYWH<T::Unit>>> (
+    draw: F
+) -> Thunk<T, F> {
+    Thunk(draw, std::marker::PhantomData)
+}
+
+/// Only render when condition is true.
+///
+/// ```
+/// # use tengri::{draw::*, term::*};
+/// # fn test () -> impl tengri::draw::Draw<tengri::term::Tui> {
+///     when(true, "Yes")
+/// # }
+/// ```
+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.
+///
+/// ```
+/// # use tengri::{draw::*, term::*};
+/// # fn test () -> impl tengri::draw::Draw<tengri::term::Tui> {
+///     either(true, "Yes", "No")
+/// # }
+/// ```
+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) })
+}
diff --git a/src/eval.rs b/src/eval.rs
index 4fc5934..8709747 100644
--- a/src/eval.rs
+++ b/src/eval.rs
@@ -59,23 +59,16 @@ macro_rules! eval_enum ((
 /// Interpret layout operation.
 ///
 /// ```
-/// # use tengri::{lang::*, draw::*, eval::*};
-/// struct Target { xywh: XYWH<u16> /*platform-specific*/}
-/// impl tengri::Out for Target {
-///     type Unit = u16;
-///     fn area (&self) -> XYWH<u16> { self.xywh }
-///     fn area_mut (&mut self) -> &mut XYWH<u16> { &mut self.xywh }
-///     fn show <'t, T: Draw<Self> + ?Sized> (&mut self, area: XYWH<u16>, content: &'t T) {}
-/// }
+/// # use tengri::{lang::*, draw::*, eval::*, term::*};
 ///
 /// struct State {/*app-specific*/}
 /// impl<'b> Namespace<'b, bool> for State {}
 /// impl<'b> Namespace<'b, u16> for State {}
-/// impl Interpret<Target, ()> for State {}
+/// impl Interpret<Tui, XYWH<u16>> for State {}
 ///
 /// # fn main () -> tengri::Usually<()> {
 /// let state = State {};
-/// let mut target = Target { xywh: Default::default() };
+/// let mut target = Tui::new(80, 25);
 /// eval_view(&state, &mut target, &"")?;
 /// eval_view(&state, &mut target, &"(when true (text hello))")?;
 /// eval_view(&state, &mut target, &"(either true (text hello) (text world))")?;
@@ -197,13 +190,15 @@ pub fn eval_view_tui <'a, S> (
     match frags.next() {
 
         Some("text") => {
-            if let Some(src) = args?.src()? { output.place(&src) }
+            if let Some(src) = args?.src()? {
+                output.show(output.xywh(), &src)
+            }
         },
 
         Some("fg") => {
-            let arg0  = arg0?.expect("fg: expected arg 0 (color)");
+            let arg0 = arg0?.expect("fg: expected arg 0 (color)");
             let color = Namespace::namespace(state, arg0)?.unwrap_or_else(||panic!("fg: {arg0:?}: not a color"));
-            output.place(&fg(color, thunk(move|output: &mut Tui|{
+            output.show(output.xywh(), &fg(color, thunk(move|output: &mut Tui|{
                 state.interpret(output, &arg1)?;
                 // FIXME?: don't max out the used area?
                 Ok(output.area().into())
@@ -211,9 +206,9 @@ pub fn eval_view_tui <'a, S> (
         },
 
         Some("bg") => {
-            let arg0  = arg0?.expect("bg: expected arg 0 (color)");
+            let arg0 = arg0?.expect("bg: expected arg 0 (color)");
             let color = Namespace::namespace(state, arg0)?.unwrap_or_else(||panic!("bg: {arg0:?}: not a color"));
-            output.place(&bg(color, thunk(move|output: &mut Tui|{
+            output.show(output.xywh(), &bg(color, thunk(move|output: &mut Tui|{
                 state.interpret(output, &arg1)?;
                 // FIXME?: don't max out the used area?
                 Ok(output.area().into())
diff --git a/src/lib.rs b/src/lib.rs
index c7fe21d..394f592 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -93,7 +93,7 @@ pub use ::dizzle::{Usually, Perhaps, impl_default};
             // FIXME: support attrs (docstrings)
             $($Variant $({ $($arg: $Arg),* })?),*
         }
-        impl ::tengri::dizzle::Act<$State> for $Command {
+        impl ::tengri::lang::Act<$State> for $Command {
             fn act (&self, $state: &mut $State) -> Perhaps<Self> {
                 match self {
                     $(Self::$Variant $({ $($arg),* })? => $body,)*
diff --git a/src/space.rs b/src/space.rs
index 9a8650c..fd9ac7d 100644
--- a/src/space.rs
+++ b/src/space.rs
@@ -125,13 +125,17 @@ pub trait Space<N: Coord>: X<N> + Y<N> {
     // FIXME: factor origin
     fn lrtb (&self) -> [N;4] { [self.x(), self.y(), self.x()+self.w(), self.y()+self.h()] }
 }
+
 impl<N: Coord, T: X<N> + Y<N>> Space<N> for T {}
+
 pub const fn xy_push <T: Screen> (x: T::Unit, y: T::Unit, a: impl Draw<T>) -> impl Draw<T> {
     a
 }
+
 pub const fn xy_pull <T: Screen> (x: T::Unit, y: T::Unit, a: impl Draw<T>) -> impl Draw<T> {
     a
 }
+
 /// Shrink drawing area symmetrically.
 ///
 /// ```
@@ -142,6 +146,7 @@ pub const fn wh_pad <T: Screen> (w: T::Unit, h: T::Unit, draw: impl Draw<T>)
 {
     thunk(move|to: &mut T|draw.draw(todo!()))
 }
+
 /// Only draw content if area is above a certain size.
 ///
 /// ```
@@ -161,7 +166,7 @@ pub const fn wh_min <T: Screen> (w: Option<T::Unit>, h: Option<T::Unit>, draw: i
 pub const fn wh_max <T: Screen> (w: Option<T::Unit>, h: Option<T::Unit>, draw: impl Draw<T>)
     -> impl Draw<T>
 {
-    thunk(move|to: &mut T|draw.draw(todo!()))
+    thunk(move|_to: &mut T|draw.draw(todo!()))
 }
 
 /// Set the maximum width and/or height of the content.
@@ -172,7 +177,7 @@ pub const fn wh_max <T: Screen> (w: Option<T::Unit>, h: Option<T::Unit>, draw: i
 pub const fn wh_exact <T: Screen> (w: Option<T::Unit>, h: Option<T::Unit>, draw: impl Draw<T>)
     -> impl Draw<T>
 {
-    thunk(move|to: &mut T|draw.draw(todo!()))
+    thunk(move|_to: &mut T|draw.draw(todo!()))
 }
 
 /// Limit size of drawing area
@@ -182,7 +187,7 @@ pub const fn wh_exact <T: Screen> (w: Option<T::Unit>, h: Option<T::Unit>, draw:
 pub const fn wh_clip <T: Screen> (
     w: Option<T::Unit>, h: Option<T::Unit>, draw: impl Draw<T>
 ) -> impl Draw<T> {
-    thunk(move|to: &mut T|draw.draw(todo!()))
+    thunk(move|_to: &mut T|draw.draw(todo!()))
 }
 
 pub const fn wh_full <T: Screen> (a: impl Draw<T>) -> impl Draw<T> { a }
diff --git a/src/space/iter.rs b/src/space/iter.rs
index 4bcfde8..a431f3d 100644
--- a/src/space/iter.rs
+++ b/src/space/iter.rs
@@ -33,7 +33,7 @@ pub fn iter_east <'a, S: Screen, D: 'a, I: Iterator<Item = D>, U: Draw<S>> (
 }
 
 pub fn iter_south <'a, S: Screen, D: 'a, I: Iterator<Item = D>, U: Draw<S>> (
-    _iter: impl Fn()->I, _draw: impl Fn(D)->U,
+    _iter: impl Fn()->I, _draw: impl Fn(D, usize)->U,
 ) -> impl Draw<S> {
     thunk(move|_to: &mut S|{ todo!() })
 }
diff --git a/src/space/split.rs b/src/space/split.rs
index f6f53b2..4fb42cc 100644
--- a/src/space/split.rs
+++ b/src/space/split.rs
@@ -54,12 +54,12 @@ impl Split {
             let b = origin_b.align(b);
             match self {
                 Self::Below => {
-                    to.place_at(area_b, &b);
-                    to.place_at(area_b, &a);
+                    to.show(area_b, &b);
+                    to.show(area_b, &a);
                 },
                 _ => {
-                    to.place_at(area_a, &a);
-                    to.place_at(area_a, &b);
+                    to.show(area_a, &a);
+                    to.show(area_a, &b);
                 }
             }
             Ok(to.xywh()) // FIXME: compute and return actually used area
diff --git a/src/term.rs b/src/term.rs
index ef9ddd1..622f636 100644
--- a/src/term.rs
+++ b/src/term.rs
@@ -119,25 +119,12 @@ pub fn tui_output <
             prev.resize(&mut backend, width, height);
             state.view().draw(&mut next).expect("draw failed"); // TODO draw error
             prev.redraw(&mut backend, &mut next);
-            //tui_redraw(&mut backend, &mut prev, &mut next);
         }
         let timer = format!("{:>3.3}ms", perf.used.load(Relaxed));
         prev.set_string(0, 0, &timer, Style::default());
     })?)
 }
 
-pub fn tui_redraw <'b, W: Write> (
-    back: &mut CrosstermBackend<W>,
-    mut prev: &'b mut Buffer,
-    mut next: &'b mut Buffer
-) {
-    let updates = prev.diff(&next);
-    back.draw(updates.into_iter()).expect("failed to render");
-    Backend::flush(back).expect("failed to flush output new");
-    std::mem::swap(&mut prev, &mut next);
-    next.reset();
-}
-
 /// Terminal output.
 pub struct Tui(
     /// Ratatui buffer; area is screen size
@@ -147,10 +134,10 @@ pub struct Tui(
 );
 
 impl Tui {
-    fn new (width: u16, height: u16) -> Self {
+    pub fn new (width: u16, height: u16) -> Self {
         Self(Buffer::empty(Rect { x: 0, y: 0, width, height }), XYWH(0, 0, width, height))
     }
-    fn resize <W: Write> (&mut self, back: &mut CrosstermBackend<W>, width: u16, height: u16) {
+    pub fn resize <W: Write> (&mut self, back: &mut CrosstermBackend<W>, width: u16, height: u16) {
         let size = Rect { x: 0, y: 0, width, height };
         if self.0.area != size {
             back.clear_region(ClearType::All).unwrap();
@@ -158,7 +145,7 @@ impl Tui {
             self.0.reset();
         }
     }
-    fn redraw <'b, W: Write> (&'b mut self, back: &mut CrosstermBackend<W>, mut next: &'b mut Self) {
+    pub fn redraw <'b, W: Write> (&'b mut self, back: &mut CrosstermBackend<W>, mut next: &'b mut Self) {
         let updates = self.0.diff(&next.0);
         back.draw(updates.into_iter()).expect("failed to render");
         Backend::flush(back).expect("failed to flush output new");
@@ -167,7 +154,18 @@ impl Tui {
     }
 }
 
-impl Screen for Tui { type Unit = u16; }
+impl Screen for Tui {
+    type Unit = u16;
+    /// Render drawable in subarea specified by `area`
+    fn show <'t, T: Draw<Self>> (
+        &mut self, area: XYWH<u16>, content: T
+    ) {
+        let previous_area = self.1;
+        self.1 = area;
+        let _result_area = content.draw(self);
+        self.1 = previous_area;
+    }
+}
 
 impl Deref for Tui { type Target = Buffer; fn deref (&self) -> &Buffer { &self.0 } }
 

From 29035d0b36221f43902ead396a5e94c423f0581d Mon Sep 17 00:00:00 2001
From: facile pop culture reference <donotem@ilme.no>
Date: Tue, 16 Jun 2026 14:58:48 +0300
Subject: [PATCH 06/25] add index to all iter helpers

---
 src/draw.rs        |  5 +++++
 src/space/iter.rs  | 17 ++++++++---------
 src/term/border.rs |  2 +-
 3 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/src/draw.rs b/src/draw.rs
index 76dc916..a76126b 100644
--- a/src/draw.rs
+++ b/src/draw.rs
@@ -49,6 +49,11 @@ pub use self::screen::*;
 pub trait Draw<T: Screen> {
     fn draw (self, to: &mut T) -> Usually<XYWH<T::Unit>>;
 }
+impl<T: Screen> Draw<T> for () {
+    fn draw (self, __: &mut T) -> Usually<XYWH<T::Unit>> {
+        Ok(Default::default())
+    }
+}
 impl<T: Screen, D: Draw<T>> Draw<T> for &D {
     fn draw (self, __: &mut T) -> Usually<XYWH<T::Unit>> {
         todo!()
diff --git a/src/space/iter.rs b/src/space/iter.rs
index a431f3d..4277d05 100644
--- a/src/space/iter.rs
+++ b/src/space/iter.rs
@@ -11,23 +11,23 @@ use super::*;
 /// ].iter(), |x|x);
 /// ```
 pub fn iter <
-    S: Screen,
-    D: Draw<S>,
-    V: Fn()->I,
-    I: Iterator<Item = D>,
-    F: Fn(&D)->dyn Draw<S>,
+    S: Screen,              // Target screen
+    D,                      // Input doesn't need to be [Draw]able, output does
+    V: Fn()->I,             // Function that returns the iterator
+    I: Iterator<Item = D>,  // Type of the iterator
+    F: Fn(&D, usize)->dyn Draw<S>, // Function that returns [Draw]able from iterator item
 > (_items: V, _cb: F) -> impl Draw<S> {
     thunk(move|_to: &mut S|{ todo!() })
 }
 
 pub fn iter_north <'a, S: Screen, D: 'a, I: Iterator<Item = D>, U: Draw<S>> (
-    _iter: impl Fn()->I, _draw: impl Fn(D)->U,
+    _iter: impl Fn()->I, _draw: impl Fn(D, usize)->U,
 ) -> impl Draw<S> {
     thunk(move|_to: &mut S|{ todo!() })
 }
 
 pub fn iter_east <'a, S: Screen, D: 'a, I: Iterator<Item = D>, U: Draw<S>> (
-    _iter: impl Fn()->I, _draw: impl Fn(D)->U,
+    _iter: impl Fn()->I, _draw: impl Fn(D, usize)->U,
 ) -> impl Draw<S> {
     thunk(move|_to: &mut S|{ todo!() })
 }
@@ -39,8 +39,7 @@ pub fn iter_south <'a, S: Screen, D: 'a, I: Iterator<Item = D>, U: Draw<S>> (
 }
 
 pub fn iter_west <'a, S: Screen, D: 'a, I: Iterator<Item = D>, U: Draw<S>> (
-    _iter: impl Fn()->I, _draw: impl Fn(D)->U,
+    _iter: impl Fn()->I, _draw: impl Fn(D, usize)->U,
 ) -> impl Draw<S> {
     thunk(move|_to: &mut S|{ todo!() })
 }
-
diff --git a/src/term/border.rs b/src/term/border.rs
index 1fbd210..9a30995 100644
--- a/src/term/border.rs
+++ b/src/term/border.rs
@@ -5,7 +5,7 @@ use super::*;
 /// ```
 /// /// TODO
 /// ```
-pub const fn border <T, S: BorderStyle> (on: bool, style: S, draw: impl Draw<Tui>) -> impl Draw<Tui> {
+pub const fn border (on: bool, style: impl BorderStyle, draw: impl Draw<Tui>) -> impl Draw<Tui> {
     let content = wh_pad(1, 1, draw);
     let outline = when(on, thunk(move|to: &mut Tui|{
         let XYWH(x, y, w, h) = to.1;

From 9c5bfafb7a4163022c5a96c3a25d0aca258a28d2 Mon Sep 17 00:00:00 2001
From: facile pop culture reference <donotem@ilme.no>
Date: Fri, 19 Jun 2026 10:17:04 +0300
Subject: [PATCH 07/25] wip: text drawing impls

---
 src/draw.rs | 21 +++++++++++++--------
 src/text.rs |  2 ++
 2 files changed, 15 insertions(+), 8 deletions(-)

diff --git a/src/draw.rs b/src/draw.rs
index a76126b..df505d3 100644
--- a/src/draw.rs
+++ b/src/draw.rs
@@ -46,21 +46,26 @@ pub use self::screen::*;
 ///     }
 /// }
 /// ```
-pub trait Draw<T: Screen> {
-    fn draw (self, to: &mut T) -> Usually<XYWH<T::Unit>>;
+pub trait Draw<S: Screen> {
+    fn draw (self, to: &mut S) -> Usually<XYWH<S::Unit>>;
 }
-impl<T: Screen> Draw<T> for () {
-    fn draw (self, __: &mut T) -> Usually<XYWH<T::Unit>> {
+impl<S: Screen> Draw<S> for () {
+    fn draw (self, __: &mut S) -> Usually<XYWH<S::Unit>> {
         Ok(Default::default())
     }
 }
-impl<T: Screen, D: Draw<T>> Draw<T> for &D {
-    fn draw (self, __: &mut T) -> Usually<XYWH<T::Unit>> {
+impl<S: Screen, D: Draw<S>> Draw<S> for &D {
+    fn draw (self, __: &mut S) -> Usually<XYWH<S::Unit>> {
         todo!()
     }
 }
-impl<T: Screen, D: Draw<T>> Draw<T> for Option<D> {
-    fn draw (self, __: &mut T) -> Usually<XYWH<T::Unit>> {
+impl<S: Screen, D: Draw<S>> Draw<S> for Option<D> {
+    fn draw (self, __: &mut S) -> Usually<XYWH<S::Unit>> {
+        todo!()
+    }
+}
+impl<S: Screen, D: Draw<S>> Draw<S> for RwLock<D> {
+    fn draw (self, __: &mut S) -> Usually<XYWH<S::Unit>> {
         todo!()
     }
 }
diff --git a/src/text.rs b/src/text.rs
index c9752a4..9943d4b 100644
--- a/src/text.rs
+++ b/src/text.rs
@@ -12,11 +12,13 @@ pub(crate) use ::unicode_width::*;
             to.text(&self, x, y, w)
         }
     }
+
     impl Draw<Tui> for String {
         fn draw (self, to: &mut Tui) -> Usually<XYWH<u16>> {
             self.as_str().draw(to)
         }
     }
+
     impl Draw<Tui> for &std::sync::Arc<str> {
         fn draw (self, to: &mut Tui) -> Usually<XYWH<u16>> {
             self.as_ref().draw(to)

From e0781571c42cb72e7445a2adbdb7a99e37600562 Mon Sep 17 00:00:00 2001
From: facile pop culture reference <donotem@ilme.no>
Date: Fri, 19 Jun 2026 20:23:42 +0300
Subject: [PATCH 08/25] add iter_dyn and iter_<dir>_fixed stubs

---
 src/space/iter.rs | 20 +++++++++++++++++++-
 src/term.rs       |  6 ++++++
 2 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/src/space/iter.rs b/src/space/iter.rs
index 4277d05..c27b73c 100644
--- a/src/space/iter.rs
+++ b/src/space/iter.rs
@@ -10,7 +10,7 @@ use super::*;
 ///   Center.align(W(40).max(H(20.max("Center"))))
 /// ].iter(), |x|x);
 /// ```
-pub fn iter <
+pub fn iter_dyn <
     S: Screen,              // Target screen
     D,                      // Input doesn't need to be [Draw]able, output does
     V: Fn()->I,             // Function that returns the iterator
@@ -20,6 +20,12 @@ pub fn iter <
     thunk(move|_to: &mut S|{ todo!() })
 }
 
+pub fn iter <'a, S: Screen, D: 'a, I: Iterator<Item = D>, U: Draw<S>> (
+    _iter: impl Fn()->I, _draw: impl Fn(D, usize)->U,
+) -> impl Draw<S> {
+    thunk(move|_to: &mut S|{ todo!() })
+}
+
 pub fn iter_north <'a, S: Screen, D: 'a, I: Iterator<Item = D>, U: Draw<S>> (
     _iter: impl Fn()->I, _draw: impl Fn(D, usize)->U,
 ) -> impl Draw<S> {
@@ -32,12 +38,24 @@ pub fn iter_east <'a, S: Screen, D: 'a, I: Iterator<Item = D>, U: Draw<S>> (
     thunk(move|_to: &mut S|{ todo!() })
 }
 
+pub fn iter_east_fixed <'a, S: Screen, D: 'a, I: Iterator<Item = D>, U: Draw<S>> (
+    _height: S::Unit, _iter: impl Fn()->I, _draw: impl Fn(D, usize)->U,
+) -> impl Draw<S> {
+    thunk(move|_to: &mut S|{ todo!() })
+}
+
 pub fn iter_south <'a, S: Screen, D: 'a, I: Iterator<Item = D>, U: Draw<S>> (
     _iter: impl Fn()->I, _draw: impl Fn(D, usize)->U,
 ) -> impl Draw<S> {
     thunk(move|_to: &mut S|{ todo!() })
 }
 
+pub fn iter_south_fixed <'a, S: Screen, D: 'a, I: Iterator<Item = D>, U: Draw<S>> (
+    _height: S::Unit, _iter: impl Fn()->I, _draw: impl Fn(D, usize)->U,
+) -> impl Draw<S> {
+    thunk(move|_to: &mut S|{ todo!() })
+}
+
 pub fn iter_west <'a, S: Screen, D: 'a, I: Iterator<Item = D>, U: Draw<S>> (
     _iter: impl Fn()->I, _draw: impl Fn(D, usize)->U,
 ) -> impl Draw<S> {
diff --git a/src/term.rs b/src/term.rs
index 622f636..63c9b95 100644
--- a/src/term.rs
+++ b/src/term.rs
@@ -171,6 +171,12 @@ impl Deref for Tui { type Target = Buffer; fn deref (&self) -> &Buffer { &self.0
 
 impl DerefMut for Tui { fn deref_mut (&mut self) -> &mut Buffer { &mut self.0 } }
 
+impl AsMut<Buffer> for Tui {
+    fn as_mut (&mut self) -> &mut Buffer {
+        &mut self.0
+    }
+}
+
 impl HasOrigin for Tui { fn origin (&self) -> Origin { Origin::NW } }
 
 impl X<u16> for Tui {

From 0273d2ac75b8a144ea03b4bdd94d08003f3589df Mon Sep 17 00:00:00 2001
From: facile pop culture reference <donotem@ilme.no>
Date: Wed, 24 Jun 2026 06:37:07 +0300
Subject: [PATCH 09/25] drawing and singing fixes

---
 src/sing.rs            | 189 +----------------------------------------
 src/sing/jack.rs       |  98 +++++++++++++++++++++
 src/sing/jack_event.rs |  72 ++++++++++++++++
 src/sing/jack_perf.rs  |  22 +++++
 src/space/iter.rs      |  46 ++++++++--
 src/space/size.rs      |  10 ++-
 src/text.rs            |   2 +-
 7 files changed, 244 insertions(+), 195 deletions(-)
 create mode 100644 src/sing/jack.rs
 create mode 100644 src/sing/jack_event.rs
 create mode 100644 src/sing/jack_perf.rs

diff --git a/src/sing.rs b/src/sing.rs
index cd76eb2..9899fbe 100644
--- a/src/sing.rs
+++ b/src/sing.rs
@@ -1,6 +1,9 @@
 pub use ::jack::{*, contrib::{*, ClosureProcessHandler}};
 use crate::{*, time::PerfModel};
-use JackState::*;
+
+mod jack; pub use self::jack::*;
+mod jack_event; pub use self::jack_event::*;
+mod jack_perf; pub use self::jack_perf::*;
 
 /// Trait for thing that has a JACK process callback.
 pub trait Audio {
@@ -22,58 +25,6 @@ pub trait Audio {
     }
 }
 
-/// Wraps [JackState], and through it [jack::Client] when connected.
-///
-/// ```
-/// let jack = tengri::sing::Jack::default();
-/// ```
-#[derive(Clone, Debug, Default)] pub struct Jack<'j> (
-    pub(crate) Arc<RwLock<JackState<'j>>>
-);
-
-/// This is a connection which may be [Inactive], [Activating], or [Active].
-/// In the [Active] and [Inactive] states, [JackState::client] returns a
-/// [jack::Client], which you can use to talk to the JACK API.
-///
-/// ```
-/// let state = tengri::sing::JackState::default();
-/// ```
-#[derive(Debug, Default)] pub enum JackState<'j> {
-    /// Unused
-    #[default] Inert,
-    /// Before activation.
-    Inactive(Client),
-    /// During activation.
-    Activating,
-    /// After activation. Must not be dropped for JACK thread to persist.
-    Active(DynamicAsyncClient<'j>),
-}
-
-/// Event enum for JACK events.
-///
-/// ```
-/// let event = tengri::sing::JackEvent::XRun; // kerpop
-/// ```
-#[derive(Debug, Clone, PartialEq)] pub enum JackEvent {
-    ThreadInit,
-    Shutdown(ClientStatus, Arc<str>),
-    Freewheel(bool),
-    SampleRate(Frames),
-    ClientRegistration(Arc<str>, bool),
-    PortRegistration(PortId, bool),
-    PortRename(PortId, Arc<str>, Arc<str>),
-    PortsConnected(PortId, PortId, bool),
-    GraphReorder,
-    XRun,
-}
-
-/// Generic notification handler that emits [JackEvent]
-///
-/// ```
-/// let notify = tengri::sing::JackNotify(|_|{});
-/// ```
-pub struct JackNotify<T: Fn(JackEvent) + Send>(pub T);
-
 /// Running JACK [AsyncClient] with maximum type erasure.
 ///
 /// One [Box] contains function that handles [JackEvent]s.
@@ -92,134 +43,6 @@ pub type DynamicAudioHandler<'j> =
 pub type BoxedAudioHandler<'j> =
     Box<dyn FnMut(&Client, &ProcessScope) -> Control + Send + Sync + 'j>;
 
-/// Notification handler wrapper for [BoxedJackEventHandler].
-pub type DynamicNotifications<'j> =
-    JackNotify<BoxedJackEventHandler<'j>>;
-
-/// Boxed [JackEvent] callback.
-pub type BoxedJackEventHandler<'j> =
-    Box<dyn Fn(JackEvent) + Send + Sync + 'j>;
-
-impl<'j> HasJack<'j> for Jack<'j> { fn jack (&self) -> &Jack<'j> { self } }
-
-impl<'j> HasJack<'j> for &Jack<'j> { fn jack (&self) -> &Jack<'j> { self } }
-
-/// Implement [Jack] constructor and methods
-impl<'j> Jack<'j> {
-    /// Register new [Client] and wrap it for shared use.
-    pub fn new_run <T: HasJack<'j> + Audio + Send + Sync + 'static> (
-        name: &impl AsRef<str>,
-        init: impl FnOnce(Jack<'j>)->Usually<T>
-    ) -> Usually<Arc<RwLock<T>>> {
-        Jack::new(name)?.run(init)
-    }
-
-    pub fn new (name: &impl AsRef<str>) -> Usually<Self> {
-        let client = Client::new(name.as_ref(), ClientOptions::NO_START_SERVER)?.0;
-        Ok(Jack(Arc::new(RwLock::new(JackState::Inactive(client)))))
-    }
-
-    pub fn run <T: HasJack<'j> + Audio + Send + Sync + 'static>
-        (self, init: impl FnOnce(Self)->Usually<T>) -> Usually<Arc<RwLock<T>>>
-    {
-        let client_state = self.0.clone();
-        let app: Arc<RwLock<T>> = Arc::new(RwLock::new(init(self)?));
-        let mut state = Activating;
-        std::mem::swap(&mut*client_state.write().unwrap(), &mut state);
-        if let Inactive(client) = state {
-            // This is the misc notifications handler. It's a struct that wraps a [Box]
-            // which performs type erasure on a callback that takes [JackEvent], which is
-            // one of the available misc notifications.
-            let notify = JackNotify(Box::new({
-                let app = app.clone();
-                move|event|(&mut*app.write().unwrap()).handle(event)
-            }) as BoxedJackEventHandler);
-            // This is the main processing handler. It's a struct that wraps a [Box]
-            // which performs type erasure on a callback that takes [Client] and [ProcessScope]
-            // and passes them down to the `app`'s `process` callback, which in turn
-            // implements audio and MIDI input and output on a realtime basis.
-            let process = ::jack::contrib::ClosureProcessHandler::new(Box::new({
-                let app = app.clone();
-                move|c: &_, s: &_|if let Ok(mut app) = app.write() {
-                    app.process(c, s)
-                } else {
-                    Control::Quit
-                }
-            }) as BoxedAudioHandler);
-            // Launch a client with the two handlers.
-            *client_state.write().unwrap() = Active(
-                client.activate_async(notify, process)?
-            );
-        } else {
-            unreachable!();
-        }
-        Ok(app)
-    }
-
-    /// Run something with the client.
-    pub fn with_client <T> (&self, op: impl FnOnce(&Client)->T) -> T {
-        match &*self.0.read().unwrap() {
-            Inert            => panic!("jack client not activated"),
-            Inactive(client) => op(client),
-            Activating       => panic!("jack client has not finished activation"),
-            Active(client)   => op(client.as_client()),
-        }
-    }
-}
-
-impl<T: Fn(JackEvent) + Send> NotificationHandler for JackNotify<T> {
-    fn thread_init(&self, _: &Client) {
-        self.0(JackEvent::ThreadInit);
-    }
-    unsafe fn shutdown(&mut self, status: ClientStatus, reason: &str) {
-        self.0(JackEvent::Shutdown(status, reason.into()));
-    }
-    fn freewheel(&mut self, _: &Client, enabled: bool) {
-        self.0(JackEvent::Freewheel(enabled));
-    }
-    fn sample_rate(&mut self, _: &Client, frames: Frames) -> Control {
-        self.0(JackEvent::SampleRate(frames));
-        Control::Quit
-    }
-    fn client_registration(&mut self, _: &Client, name: &str, reg: bool) {
-        self.0(JackEvent::ClientRegistration(name.into(), reg));
-    }
-    fn port_registration(&mut self, _: &Client, id: PortId, reg: bool) {
-        self.0(JackEvent::PortRegistration(id, reg));
-    }
-    fn port_rename(&mut self, _: &Client, id: PortId, old: &str, new: &str) -> Control {
-        self.0(JackEvent::PortRename(id, old.into(), new.into()));
-        Control::Continue
-    }
-    fn ports_connected(&mut self, _: &Client, a: PortId, b: PortId, are: bool) {
-        self.0(JackEvent::PortsConnected(a, b, are));
-    }
-    fn graph_reorder(&mut self, _: &Client) -> Control {
-        self.0(JackEvent::GraphReorder);
-        Control::Continue
-    }
-    fn xrun(&mut self, _: &Client) -> Control {
-        self.0(JackEvent::XRun);
-        Control::Continue
-    }
-}
-
-impl JackPerfModel for PerfModel {
-    fn update_from_jack_scope (&self, t0: Option<u64>, scope: &ProcessScope) {
-        if let Some(t0) = t0 {
-            let t1 = self.clock.raw();
-            self.used.store(
-                self.clock.delta_as_nanos(t0, t1) as f64,
-                Relaxed,
-            );
-            self.window.store(
-                scope.cycle_times().unwrap().period_usecs as f64,
-                Relaxed,
-            );
-        }
-    }
-}
-
 /// Things that can provide a [jack::Client] reference.
 ///
 /// ```
@@ -266,10 +89,6 @@ pub trait HasJack<'j>: Send + Sync {
     }
 }
 
-pub trait JackPerfModel {
-    fn update_from_jack_scope (&self, t0: Option<u64>, scope: &ProcessScope);
-}
-
 /// Implement [Audio]: provide JACK callbacks.
 #[macro_export] macro_rules! impl_audio {
 
diff --git a/src/sing/jack.rs b/src/sing/jack.rs
new file mode 100644
index 0000000..a833244
--- /dev/null
+++ b/src/sing/jack.rs
@@ -0,0 +1,98 @@
+use crate::{*, sing::*, time::PerfModel};
+pub use ::jack::{*, contrib::{*, ClosureProcessHandler}};
+
+use JackState::*;
+
+/// Wraps [JackState], and through it [jack::Client] when connected.
+///
+/// ```
+/// let jack = tengri::sing::Jack::default();
+/// ```
+#[derive(Clone, Debug, Default)] pub struct Jack<'j> (
+    pub(crate) Arc<RwLock<JackState<'j>>>
+);
+
+/// This is a connection which may be [Inactive], [Activating], or [Active].
+/// In the [Active] and [Inactive] states, [JackState::client] returns a
+/// [jack::Client], which you can use to talk to the JACK API.
+///
+/// ```
+/// let state = tengri::sing::JackState::default();
+/// ```
+#[derive(Debug, Default)] pub enum JackState<'j> {
+    /// Unused
+    #[default] Inert,
+    /// Before activation.
+    Inactive(Client),
+    /// During activation.
+    Activating,
+    /// After activation. Must not be dropped for JACK thread to persist.
+    Active(DynamicAsyncClient<'j>),
+}
+
+/// Implement [Jack] constructor and methods
+impl<'j> Jack<'j> {
+    /// Register new [Client] and wrap it for shared use.
+    pub fn new_run <T: HasJack<'j> + Audio + Send + Sync + 'static> (
+        name: impl AsRef<str>,
+        init: impl FnOnce(Jack<'j>)->Usually<T>
+    ) -> Usually<Arc<RwLock<T>>> {
+        Jack::new(name)?.run(init)
+    }
+
+    pub fn new (name: impl AsRef<str>) -> Usually<Self> {
+        let client = Client::new(name.as_ref(), ClientOptions::NO_START_SERVER)?.0;
+        Ok(Jack(Arc::new(RwLock::new(JackState::Inactive(client)))))
+    }
+
+    pub fn run <T: HasJack<'j> + Audio + Send + Sync + 'static>
+        (self, init: impl FnOnce(Self)->Usually<T>) -> Usually<Arc<RwLock<T>>>
+    {
+        let client_state = self.0.clone();
+        let app: Arc<RwLock<T>> = Arc::new(RwLock::new(init(self)?));
+        let mut state = Activating;
+        std::mem::swap(&mut*client_state.write().unwrap(), &mut state);
+        if let Inactive(client) = state {
+            // This is the misc notifications handler. It's a struct that wraps a [Box]
+            // which performs type erasure on a callback that takes [JackEvent], which is
+            // one of the available misc notifications.
+            let notify = JackNotify(Box::new({
+                let app = app.clone();
+                move|event|(&mut*app.write().unwrap()).handle(event)
+            }) as BoxedJackEventHandler);
+            // This is the main processing handler. It's a struct that wraps a [Box]
+            // which performs type erasure on a callback that takes [Client] and [ProcessScope]
+            // and passes them down to the `app`'s `process` callback, which in turn
+            // implements audio and MIDI input and output on a realtime basis.
+            let process = ::jack::contrib::ClosureProcessHandler::new(Box::new({
+                let app = app.clone();
+                move|c: &_, s: &_|if let Ok(mut app) = app.write() {
+                    app.process(c, s)
+                } else {
+                    Control::Quit
+                }
+            }) as BoxedAudioHandler);
+            // Launch a client with the two handlers.
+            *client_state.write().unwrap() = Active(
+                client.activate_async(notify, process)?
+            );
+        } else {
+            unreachable!();
+        }
+        Ok(app)
+    }
+
+    /// Run something with the client.
+    pub fn with_client <T> (&self, op: impl FnOnce(&Client)->T) -> T {
+        match &*self.0.read().unwrap() {
+            Inert            => panic!("jack client not activated"),
+            Inactive(client) => op(client),
+            Activating       => panic!("jack client has not finished activation"),
+            Active(client)   => op(client.as_client()),
+        }
+    }
+}
+
+impl<'j> HasJack<'j> for Jack<'j> { fn jack (&self) -> &Jack<'j> { self } }
+
+impl<'j> HasJack<'j> for &Jack<'j> { fn jack (&self) -> &Jack<'j> { self } }
diff --git a/src/sing/jack_event.rs b/src/sing/jack_event.rs
new file mode 100644
index 0000000..7802842
--- /dev/null
+++ b/src/sing/jack_event.rs
@@ -0,0 +1,72 @@
+use crate::{*, time::PerfModel};
+pub use ::jack::{*, contrib::{*, ClosureProcessHandler}};
+
+/// Event enum for JACK events.
+///
+/// ```
+/// let event = tengri::sing::JackEvent::XRun; // kerpop
+/// ```
+#[derive(Debug, Clone, PartialEq)] pub enum JackEvent {
+    ThreadInit,
+    Shutdown(ClientStatus, Arc<str>),
+    Freewheel(bool),
+    SampleRate(Frames),
+    ClientRegistration(Arc<str>, bool),
+    PortRegistration(PortId, bool),
+    PortRename(PortId, Arc<str>, Arc<str>),
+    PortsConnected(PortId, PortId, bool),
+    GraphReorder,
+    XRun,
+}
+
+/// Generic notification handler that emits [JackEvent]
+///
+/// ```
+/// let notify = tengri::sing::JackNotify(|_|{});
+/// ```
+pub struct JackNotify<T: Fn(JackEvent) + Send>(pub T);
+
+/// Notification handler wrapper for [BoxedJackEventHandler].
+pub type DynamicNotifications<'j> =
+    JackNotify<BoxedJackEventHandler<'j>>;
+
+/// Boxed [JackEvent] callback.
+pub type BoxedJackEventHandler<'j> =
+    Box<dyn Fn(JackEvent) + Send + Sync + 'j>;
+
+impl<T: Fn(JackEvent) + Send> NotificationHandler for JackNotify<T> {
+    fn thread_init(&self, _: &Client) {
+        self.0(JackEvent::ThreadInit);
+    }
+    unsafe fn shutdown(&mut self, status: ClientStatus, reason: &str) {
+        self.0(JackEvent::Shutdown(status, reason.into()));
+    }
+    fn freewheel(&mut self, _: &Client, enabled: bool) {
+        self.0(JackEvent::Freewheel(enabled));
+    }
+    fn sample_rate(&mut self, _: &Client, frames: Frames) -> Control {
+        self.0(JackEvent::SampleRate(frames));
+        Control::Quit
+    }
+    fn client_registration(&mut self, _: &Client, name: &str, reg: bool) {
+        self.0(JackEvent::ClientRegistration(name.into(), reg));
+    }
+    fn port_registration(&mut self, _: &Client, id: PortId, reg: bool) {
+        self.0(JackEvent::PortRegistration(id, reg));
+    }
+    fn port_rename(&mut self, _: &Client, id: PortId, old: &str, new: &str) -> Control {
+        self.0(JackEvent::PortRename(id, old.into(), new.into()));
+        Control::Continue
+    }
+    fn ports_connected(&mut self, _: &Client, a: PortId, b: PortId, are: bool) {
+        self.0(JackEvent::PortsConnected(a, b, are));
+    }
+    fn graph_reorder(&mut self, _: &Client) -> Control {
+        self.0(JackEvent::GraphReorder);
+        Control::Continue
+    }
+    fn xrun(&mut self, _: &Client) -> Control {
+        self.0(JackEvent::XRun);
+        Control::Continue
+    }
+}
diff --git a/src/sing/jack_perf.rs b/src/sing/jack_perf.rs
new file mode 100644
index 0000000..ee0d7d6
--- /dev/null
+++ b/src/sing/jack_perf.rs
@@ -0,0 +1,22 @@
+use crate::{*, time::PerfModel};
+pub use ::jack::{*, contrib::{*, ClosureProcessHandler}};
+
+pub trait JackPerfModel {
+    fn update_from_jack_scope (&self, t0: Option<u64>, scope: &ProcessScope);
+}
+
+impl JackPerfModel for PerfModel {
+    fn update_from_jack_scope (&self, t0: Option<u64>, scope: &ProcessScope) {
+        if let Some(t0) = t0 {
+            let t1 = self.clock.raw();
+            self.used.store(
+                self.clock.delta_as_nanos(t0, t1) as f64,
+                Relaxed,
+            );
+            self.window.store(
+                scope.cycle_times().unwrap().period_usecs as f64,
+                Relaxed,
+            );
+        }
+    }
+}
diff --git a/src/space/iter.rs b/src/space/iter.rs
index c27b73c..fa5d3de 100644
--- a/src/space/iter.rs
+++ b/src/space/iter.rs
@@ -1,6 +1,20 @@
 use super::*;
 
-/// Iterate over a collection of renderables:
+/// Iterate over a collection of the same kind of [Draw]able:
+pub fn iter <'a, S: Screen, D: 'a, I: Iterator<Item = D>, U: Draw<S>> (
+    _iter: impl Fn()->I, _draw: impl Fn(D, usize)->U,
+) -> impl Draw<S> {
+    thunk(move|_to: &mut S|{ todo!() })
+}
+
+/// Iterate over a collection of the same kind of [Draw]able:
+pub fn iter_once <'a, S: Screen, D: 'a, U: Draw<S>> (
+    _iter: impl Iterator<Item = D>, _draw: impl Fn(D, usize)->U,
+) -> impl Draw<S> {
+    thunk(move|_to: &mut S|{ todo!() })
+}
+
+/// Iterate over a collection of various [Draw]ables:
 ///
 /// ```
 /// use tengri::draw::{Origin::*, Split::*};
@@ -20,12 +34,6 @@ pub fn iter_dyn <
     thunk(move|_to: &mut S|{ todo!() })
 }
 
-pub fn iter <'a, S: Screen, D: 'a, I: Iterator<Item = D>, U: Draw<S>> (
-    _iter: impl Fn()->I, _draw: impl Fn(D, usize)->U,
-) -> impl Draw<S> {
-    thunk(move|_to: &mut S|{ todo!() })
-}
-
 pub fn iter_north <'a, S: Screen, D: 'a, I: Iterator<Item = D>, U: Draw<S>> (
     _iter: impl Fn()->I, _draw: impl Fn(D, usize)->U,
 ) -> impl Draw<S> {
@@ -61,3 +69,27 @@ pub fn iter_west <'a, S: Screen, D: 'a, I: Iterator<Item = D>, U: Draw<S>> (
 ) -> impl Draw<S> {
     thunk(move|_to: &mut S|{ todo!() })
 }
+
+pub fn row_south <S: Screen> (south: S::Unit, height: S::Unit, content: impl Draw<S>)
+    -> impl Draw<S>
+{
+    y_push(south, h_exact(height, content))
+}
+
+pub fn row_north <S: Screen> (north: S::Unit, height: S::Unit, content: impl Draw<S>)
+    -> impl Draw<S>
+{
+    y_pull(north, h_exact(height, content))
+}
+
+pub fn col_east <S: Screen> (east: S::Unit, width: S::Unit, content: impl Draw<S>)
+    -> impl Draw<S>
+{
+    x_push(east, h_exact(width, content))
+}
+
+pub fn col_west <S: Screen> (west: S::Unit, width: S::Unit, content: impl Draw<S>)
+    -> impl Draw<S>
+{
+    x_pull(west, h_exact(width, content))
+}
diff --git a/src/space/size.rs b/src/space/size.rs
index add71ae..7a275ac 100644
--- a/src/space/size.rs
+++ b/src/space/size.rs
@@ -2,8 +2,14 @@ use super::*;
 
 /// Uses [AtomicUsize] to measure size during\
 /// rendering (which is normally read-only).
-#[derive(Default, Debug)]
-pub struct Size(AtomicUsize, AtomicUsize);
+#[derive(Default, Debug, Clone)]
+pub struct Size(Arc<AtomicUsize>, Arc<AtomicUsize>);
+
+impl PartialEq for Size {
+    fn eq (&self, _: &Self) -> bool {
+        todo!()
+    }
+}
 
 impl X<u16> for Size {
     fn x (&self) -> u16 { 0 }
diff --git a/src/text.rs b/src/text.rs
index 9943d4b..7eb181e 100644
--- a/src/text.rs
+++ b/src/text.rs
@@ -19,7 +19,7 @@ pub(crate) use ::unicode_width::*;
         }
     }
 
-    impl Draw<Tui> for &std::sync::Arc<str> {
+    impl Draw<Tui> for std::sync::Arc<str> {
         fn draw (self, to: &mut Tui) -> Usually<XYWH<u16>> {
             self.as_ref().draw(to)
         }

From cb382cf12e9169310ddab4eca2ca01e87fde9869 Mon Sep 17 00:00:00 2001
From: facile pop culture reference <donotem@ilme.no>
Date: Thu, 25 Jun 2026 10:56:13 +0300
Subject: [PATCH 10/25] fix Exit; document Size

---
 dizzle            | 2 +-
 src/exit.rs       | 2 +-
 src/space/size.rs | 8 ++++++--
 3 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/dizzle b/dizzle
index 2dbf9d8..4da276a 160000
--- a/dizzle
+++ b/dizzle
@@ -1 +1 @@
-Subproject commit 2dbf9d8797a3642f69813be4ef3613836e061b94
+Subproject commit 4da276af7be5690f0a7a763de3710433a9700c3c
diff --git a/src/exit.rs b/src/exit.rs
index afdc2ad..787e3e5 100644
--- a/src/exit.rs
+++ b/src/exit.rs
@@ -4,7 +4,7 @@ use crate::Usually;
 #[derive(Clone)] pub struct Exit(Arc<AtomicBool>);
 
 impl Exit {
-    pub fn run <T> (run: impl Fn(Self)->Usually<T>) -> Usually<T> {
+    pub fn run <T> (run: impl FnOnce(Self)->Usually<T>) -> Usually<T> {
         run(Self(Arc::new(AtomicBool::new(false))))
     }
 }
diff --git a/src/space/size.rs b/src/space/size.rs
index 7a275ac..4614ff1 100644
--- a/src/space/size.rs
+++ b/src/space/size.rs
@@ -3,7 +3,12 @@ use super::*;
 /// Uses [AtomicUsize] to measure size during\
 /// rendering (which is normally read-only).
 #[derive(Default, Debug, Clone)]
-pub struct Size(Arc<AtomicUsize>, Arc<AtomicUsize>);
+pub struct Size(
+    /// Width
+    pub Arc<AtomicUsize>,
+    /// Height
+    pub Arc<AtomicUsize>,
+);
 
 impl PartialEq for Size {
     fn eq (&self, _: &Self) -> bool {
@@ -31,4 +36,3 @@ impl Size {
         })
     }
 }
-

From 80b086603ea5c4535fb3c82c19d37ad3c14b3815 Mon Sep 17 00:00:00 2001
From: facile pop culture reference <donotem@ilme.no>
Date: Sat, 27 Jun 2026 22:09:09 +0300
Subject: [PATCH 11/25] jack: support in Arc<T>

---
 src/sing/jack.rs | 18 ++++++++++++++++--
 1 file changed, 16 insertions(+), 2 deletions(-)

diff --git a/src/sing/jack.rs b/src/sing/jack.rs
index a833244..20f5c23 100644
--- a/src/sing/jack.rs
+++ b/src/sing/jack.rs
@@ -93,6 +93,20 @@ impl<'j> Jack<'j> {
     }
 }
 
-impl<'j> HasJack<'j> for Jack<'j> { fn jack (&self) -> &Jack<'j> { self } }
+impl<'j> HasJack<'j> for Jack<'j> {
+    fn jack (&self) -> &Jack<'j> {
+        self
+    }
+}
 
-impl<'j> HasJack<'j> for &Jack<'j> { fn jack (&self) -> &Jack<'j> { self } }
+impl<'j> HasJack<'j> for &Jack<'j> {
+    fn jack (&self) -> &Jack<'j> {
+        self
+    }
+}
+
+impl<'j, T: HasJack<'j>> HasJack<'j> for Arc<T> {
+    fn jack (&self) -> &Jack<'j> {
+        (&**self).jack()
+    }
+}

From f7b05e95fa7cfc152e9395da3f2592bf9cc6f538 Mon Sep 17 00:00:00 2001
From: facile pop culture reference <donotem@ilme.no>
Date: Sat, 27 Jun 2026 22:09:29 +0300
Subject: [PATCH 12/25] term: collect keys

---
 src/lib.rs             | 2 --
 src/term.rs            | 4 ++++
 src/{ => term}/keys.rs | 0
 3 files changed, 4 insertions(+), 2 deletions(-)
 rename src/{ => term}/keys.rs (100%)

diff --git a/src/lib.rs b/src/lib.rs
index 394f592..4a5a44e 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -49,8 +49,6 @@ pub use ::dizzle::{Usually, Perhaps, impl_default};
 #[cfg(feature = "text")] pub mod text;
 /// Terminal output.
 #[cfg(feature = "term")] pub mod term;
-/// Terminal keyboard input.
-#[cfg(feature = "term")] pub mod keys;
 
 /// Define a trait an implement it for various mutation-enabled wrapper types. */
 #[macro_export] macro_rules! flex_trait_mut (
diff --git a/src/term.rs b/src/term.rs
index 63c9b95..c3ad757 100644
--- a/src/term.rs
+++ b/src/term.rs
@@ -543,3 +543,7 @@ use self::colors::*; mod colors {
     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) }
 }
+
+/// Terminal keyboard input.
+#[cfg(feature = "term")] pub mod keys;
+#[cfg(feature = "term")] pub use self::keys::*;
diff --git a/src/keys.rs b/src/term/keys.rs
similarity index 100%
rename from src/keys.rs
rename to src/term/keys.rs

From 7613c655000949180e6e838ce96c0f168b8d4cc7 Mon Sep 17 00:00:00 2001
From: facile pop culture reference <donotem@ilme.no>
Date: Sat, 27 Jun 2026 22:09:50 +0300
Subject: [PATCH 13/25] chore: bump

---
 dizzle | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dizzle b/dizzle
index 4da276a..7382600 160000
--- a/dizzle
+++ b/dizzle
@@ -1 +1 @@
-Subproject commit 4da276af7be5690f0a7a763de3710433a9700c3c
+Subproject commit 73826009cd94b9c667f4ecff88b7a1aa96a825b5

From dd7091bda11504a16ba8de0c0b719359df37b5ef Mon Sep 17 00:00:00 2001
From: facile pop culture reference <donotem@ilme.no>
Date: Sun, 28 Jun 2026 04:56:47 +0300
Subject: [PATCH 14/25] term: move output to end; move from_dsl

---
 src/lang.rs      | 40 ----------------------------------------
 src/term.rs      |  9 +++++++--
 src/term/keys.rs | 40 +++++++++++++++++++++++++++++++++++++++-
 3 files changed, 46 insertions(+), 43 deletions(-)
 delete mode 100644 src/lang.rs

diff --git a/src/lang.rs b/src/lang.rs
deleted file mode 100644
index 8266bae..0000000
--- a/src/lang.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-#[cfg(feature = "term")]
-impl crate::term::TuiKey {
-    #[cfg(feature = "lang")]
-    pub fn from_dsl (dsl: impl Language) -> Usually<Self> {
-        if let Some(word) = dsl.word()? {
-            let word = word.trim();
-            Ok(if word == ":char" {
-                Self(None, KeyModifiers::NONE)
-            } else if word.chars().nth(0) == Some('@') {
-                let mut key       = None;
-                let mut modifiers = KeyModifiers::NONE;
-                let mut tokens    = word[1..].split(Self::SPLIT).peekable();
-                while let Some(token) = tokens.next() {
-                    if tokens.peek().is_some() {
-                        match token {
-                            "ctrl"  | "Ctrl"  | "c" | "C" => modifiers |= KeyModifiers::CONTROL,
-                            "alt"   | "Alt"   | "m" | "M" => modifiers |= KeyModifiers::ALT,
-                            "shift" | "Shift" | "s" | "S" => {
-                                modifiers |= KeyModifiers::SHIFT;
-                                // + TODO normalize character case, BackTab, etc.
-                            },
-                            _ => panic!("unknown modifier {token}"),
-                        }
-                    } else {
-                        key = if token.len() == 1 {
-                            Some(KeyCode::Char(token.chars().next().unwrap()))
-                        } else {
-                            Some(named_key(token).unwrap_or_else(||panic!("unknown character {token}")))
-                        }
-                    }
-                }
-                Self(key, modifiers)
-            } else {
-                return Err(format!("TuiKey: unexpected: {word}").into())
-            })
-        } else {
-            return Err(format!("TuiKey: unspecified").into())
-        }
-    }
-}
diff --git a/src/term.rs b/src/term.rs
index c3ad757..02f858b 100644
--- a/src/term.rs
+++ b/src/term.rs
@@ -97,13 +97,18 @@ use ::{
 }
 
 /// Spawn the TUI output thread which writes colored characters to the terminal.
+///
+/// ```
+/// let state = Arc::new(RwLock::new(()));
+/// Exit::run(|exit|tui_output(exit, state, sleep, stdout()))
+/// ```
 pub fn tui_output <
     W: Write + Send + Sync + 'static, T: View<Tui> + Send + Sync + 'static
 > (
-    output: W,
     exited: &Arc<AtomicBool>,
     state:  &Arc<RwLock<T>>,
-    sleep:  Duration
+    sleep:  Duration,
+    output: W,
 ) -> Usually<Task> {
     let state = state.clone();
     stdout().execute(EnterAlternateScreen)?;
diff --git a/src/term/keys.rs b/src/term/keys.rs
index ba56615..248e97d 100644
--- a/src/term/keys.rs
+++ b/src/term/keys.rs
@@ -2,7 +2,7 @@ use crate::task::Task;
 
 use ::std::sync::{Arc, RwLock, atomic::{AtomicBool, Ordering::*}};
 use ::std::time::Duration;
-use ::dizzle::{Usually, Apply, impl_from};
+use ::dizzle::{Language, Symbol, Usually, Apply, impl_from};
 use ::crossterm::event::{
     read, Event, KeyEvent, KeyCode, KeyModifiers, KeyEventKind, KeyEventState
 };
@@ -120,4 +120,42 @@ impl TuiKey {
             _ => return None,
         })
     }
+
+    #[cfg(feature = "lang")]
+    pub fn from_dsl (dsl: impl Language) -> Usually<Self> {
+        if let Some(word) = dsl.word()? {
+            let word = word.trim();
+            Ok(if word == ":char" {
+                Self(None, KeyModifiers::NONE)
+            } else if word.chars().nth(0) == Some('@') {
+                let mut key       = None;
+                let mut modifiers = KeyModifiers::NONE;
+                let mut tokens    = word[1..].split(Self::SPLIT).peekable();
+                while let Some(token) = tokens.next() {
+                    if tokens.peek().is_some() {
+                        match token {
+                            "ctrl"  | "Ctrl"  | "c" | "C" => modifiers |= KeyModifiers::CONTROL,
+                            "alt"   | "Alt"   | "m" | "M" => modifiers |= KeyModifiers::ALT,
+                            "shift" | "Shift" | "s" | "S" => {
+                                modifiers |= KeyModifiers::SHIFT;
+                                // + TODO normalize character case, BackTab, etc.
+                            },
+                            _ => panic!("unknown modifier {token}"),
+                        }
+                    } else {
+                        key = Some(if token.len() == 1 {
+                            KeyCode::Char(token.chars().next().unwrap())
+                        } else {
+                            Self::named(token).unwrap_or_else(||panic!("unknown character {token}"))
+                        })
+                    }
+                }
+                Self(key, modifiers)
+            } else {
+                return Err(format!("TuiKey: unexpected: {word}").into())
+            })
+        } else {
+            return Err(format!("TuiKey: unspecified").into())
+        }
+    }
 }

From 53c9438f7d9990d60adc1a25cccfdd2971a07500 Mon Sep 17 00:00:00 2001
From: facile pop culture reference <donotem@ilme.no>
Date: Mon, 29 Jun 2026 19:56:32 +0300
Subject: [PATCH 15/25] try to sort TuiKey/TuiEvent mess

---
 src/term.rs       | 139 ++++++++++++++++++++++++++--------------------
 src/term/event.rs |  25 +++++++++
 src/term/keys.rs  |  57 ++-----------------
 3 files changed, 108 insertions(+), 113 deletions(-)
 create mode 100644 src/term/event.rs

diff --git a/src/term.rs b/src/term.rs
index 02f858b..c2e836d 100644
--- a/src/term.rs
+++ b/src/term.rs
@@ -1,7 +1,7 @@
 mod border;
 pub use self::border::*;
 
-use crate::{*, lang::*, draw::*, task::*};
+use crate::{*, lang::*, draw::*, task::*, exit::*};
 //use unicode_width::{UnicodeWidthStr, UnicodeWidthChar};
 //use rand::distributions::uniform::UniformSampler;
 use ::{
@@ -22,69 +22,84 @@ use ::{
             //event::{poll, read, Event, KeyEvent, KeyCode, KeyModifiers, KeyEventKind, KeyEventState},
         }
     },
+    crossterm::event::{
+        read, Event, KeyEvent, KeyModifiers, KeyCode, KeyEventKind, KeyEventState
+    },
 };
 
+/// Implement standard [main] entrypoint for TUI apps.
 #[macro_export] macro_rules! tui_main {
-    ($state:expr) => {
-        pub fn main () -> Usually<()> {
-            use ::{
-                std::sync::{
-                    Arc,
-                    RwLock
-                },
-                std::panic::{
-                    set_hook,
-                    PanicHookInfo,
-                },
-                std::time::{
-                    Duration
-                },
-                better_panic::{
-                    Settings,
-                    Verbosity
-                },
-                ratatui::{
-                    backend::{
-                        Backend,
-                        CrosstermBackend
-                    },
-                    crossterm::{
-                        ExecutableCommand,
-                        terminal::{
-                            disable_raw_mode,
-                            LeaveAlternateScreen
-                        }
-                    }
-                },
-                tengri::{
-                    exit::Exit,
-                    keys::tui_input,
-                    term::tui_output,
-                }
-            };
-            let panic = Settings::auto()
-                .verbosity(Verbosity::Full)
-                .create_panic_handler();
-            set_hook(Box::new(move |info: &PanicHookInfo|{
-                stdout().execute(LeaveAlternateScreen).unwrap();
-                CrosstermBackend::new(stdout()).show_cursor().unwrap();
-                disable_raw_mode().unwrap();
-                panic(info);
-            }));
-            Exit::run(|exit|{
-                let state  = Arc::new(RwLock::new($state));
-                let scan   = Duration::from_millis(100);
-                let input  = tui_input(exit.as_ref(), &state, scan)?;
-                let frame  = Duration::from_millis(10);
-                let output = tui_output(stdout(), exit.as_ref(), &state, frame)?;
-                output.join();
-                stdout().execute(LeaveAlternateScreen)?;
-                CrosstermBackend::new(stdout()).show_cursor()?;
-                disable_raw_mode()?;
-                Ok(())
-            })
+    ($state:expr) => { pub fn main () -> Usually<()> { tui_run_main($state) } }
+}
+
+pub fn tui_run_main <T> (state: T) -> Usually<()> where
+    T: View<Tui> + Apply<TuiEvent, Usually<()>> + Send + Sync + 'static
+{
+    tui_setup_panic();
+    Exit::run(|exit|{
+        let state  = Arc::new(RwLock::new(state));
+        let scan   = Duration::from_millis(100);
+        let input  = tui_input(exit.as_ref(), &state, scan)?;
+        let frame  = Duration::from_millis(10);
+        let output = tui_output(exit.as_ref(), &state, frame, std::io::stdout())?;
+        output.join();
+        stdout().execute(LeaveAlternateScreen)?;
+        CrosstermBackend::new(stdout()).show_cursor()?;
+        disable_raw_mode()?;
+        Ok(())
+    })
+}
+
+pub fn tui_setup_panic () {
+    use ::std::panic::{set_hook, PanicHookInfo};
+    use ::better_panic::{Settings, Verbosity};
+    let panic = Settings::auto()
+        .verbosity(Verbosity::Full)
+        .create_panic_handler();
+    set_hook(Box::new(move |info: &PanicHookInfo|{
+        stdout().execute(LeaveAlternateScreen).unwrap();
+        CrosstermBackend::new(stdout()).show_cursor().unwrap();
+        disable_raw_mode().unwrap();
+        panic(info);
+    }));
+}
+
+/// Enable TUI keyboard input for main state struct.
+#[macro_export] macro_rules! tui_keys {
+    (|$self:ident:$State:ty,$input:ident|$body:block) => {
+        impl Apply<TuiEvent, Usually<()>> for $State {
+            fn apply (&mut $self, $input: &TuiEvent) -> Usually<()> $body
         }
-    }
+    };
+}
+
+/// Spawn the TUI input thread which reads keys from the terminal.
+pub fn tui_input <T: Apply<TuiEvent, Usually<()>> + Send + Sync + 'static> (
+    exited: &Arc<AtomicBool>, state: &Arc<RwLock<T>>, poll: Duration
+) -> Result<Task, std::io::Error> {
+    let exited = exited.clone();
+    let state = state.clone();
+    Task::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:
+            event => {
+                if let Err(e) = state.write().unwrap().apply(&TuiEvent(event)) {
+                    panic!("{e}")
+                }
+            },
+
+        }
+    })
 }
 
 /// Enable TUI output for state struct.
@@ -549,6 +564,8 @@ use self::colors::*; mod colors {
     pub const fn tui_yellow () -> Color { Color::Rgb(255,255,0) }
 }
 
-/// Terminal keyboard input.
+#[cfg(feature = "term")] pub mod event;
+#[cfg(feature = "term")] pub use self::event::*;
+
 #[cfg(feature = "term")] pub mod keys;
 #[cfg(feature = "term")] pub use self::keys::*;
diff --git a/src/term/event.rs b/src/term/event.rs
new file mode 100644
index 0000000..76af779
--- /dev/null
+++ b/src/term/event.rs
@@ -0,0 +1,25 @@
+use ::dizzle::impl_from;
+use ::crossterm::event::{Event, KeyEvent, KeyCode, KeyModifiers};
+
+/// TUI input loop event.
+#[derive(Debug, Clone, Eq, PartialEq, PartialOrd)]
+pub struct TuiEvent(
+    /// Wrapped [crossterm::event::Event].
+    pub Event
+);
+
+impl_from!(TuiEvent: |e: Event| TuiEvent(
+    e));
+impl_from!(TuiEvent: |e: KeyEvent| TuiEvent(
+    Event::Key(e)));
+impl_from!(TuiEvent: |c: KeyCode| TuiEvent(
+    Event::Key(KeyEvent::new(c, KeyModifiers::NONE))));
+impl_from!(TuiEvent: |c: char| TuiEvent(
+    Event::Key(KeyEvent::new(KeyCode::Char(c), KeyModifiers::NONE))));
+
+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
+    }
+}
diff --git a/src/term/keys.rs b/src/term/keys.rs
index 248e97d..a0ccca8 100644
--- a/src/term/keys.rs
+++ b/src/term/keys.rs
@@ -1,69 +1,22 @@
-use crate::task::Task;
-
+use crate::{task::Task, term::TuiEvent};
 use ::std::sync::{Arc, RwLock, atomic::{AtomicBool, Ordering::*}};
 use ::std::time::Duration;
-use ::dizzle::{Language, Symbol, Usually, Apply, impl_from};
+use ::dizzle::{Language, Symbol, Usually, Apply};
 use ::crossterm::event::{
     read, Event, KeyEvent, KeyCode, KeyModifiers, KeyEventKind, KeyEventState
 };
 
-/// Enable TUI keyboard input for main state struct.
-#[macro_export] macro_rules! tui_keys {
-    (|$self:ident:$State:ty,$input:ident|$body:block) => {
-        impl Apply<TuiEvent, Usually<()>> for $State {
-            fn apply (&mut $self, $input: &TuiEvent) -> Usually<()> $body
-        }
-    };
-}
-
-/// Spawn the TUI input thread which reads keys from the terminal.
-pub fn tui_input <T: Apply<TuiEvent, Usually<()>> + Send + Sync + 'static> (
-    exited: &Arc<AtomicBool>, state: &Arc<RwLock<T>>, poll: Duration
-) -> Result<Task, std::io::Error> {
-    let exited = exited.clone();
-    let state = state.clone();
-    Task::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:
-            event => {
-                if let Err(e) = state.write().unwrap().apply(&TuiEvent(event)) {
-                    panic!("{e}")
-                }
-            },
-
-        }
-    })
-}
-
-/// TUI input loop event.
+/// TUI key spec.
 #[derive(Debug, Clone, Eq, PartialEq, PartialOrd)]
-pub struct TuiEvent(pub Event);
+pub struct TuiKey(pub Option<KeyCode>, pub KeyModifiers);
 
-impl_from!(TuiEvent: |e: Event| TuiEvent(e));
-
-impl_from!(TuiEvent: |c: char|  TuiEvent(Event::Key(KeyEvent::new(KeyCode::Char(c), KeyModifiers::NONE))));
-
-impl Ord for TuiEvent {
+impl Ord for TuiKey {
     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 from_crossterm (event: KeyEvent) -> Self {

From 4e6c62a7f1edd9e173065afbb8e9cf897baa2ead Mon Sep 17 00:00:00 2001
From: facile pop culture reference <donotem@ilme.no>
Date: Mon, 29 Jun 2026 20:38:08 +0300
Subject: [PATCH 16/25] term: add combined tui_io

---
 src/term.rs | 19 +++++++++++++++++--
 1 file changed, 17 insertions(+), 2 deletions(-)

diff --git a/src/term.rs b/src/term.rs
index c2e836d..b5fa807 100644
--- a/src/term.rs
+++ b/src/term.rs
@@ -39,9 +39,8 @@ pub fn tui_run_main <T> (state: T) -> Usually<()> where
     Exit::run(|exit|{
         let state  = Arc::new(RwLock::new(state));
         let scan   = Duration::from_millis(100);
-        let input  = tui_input(exit.as_ref(), &state, scan)?;
         let frame  = Duration::from_millis(10);
-        let output = tui_output(exit.as_ref(), &state, frame, std::io::stdout())?;
+        let (input, output) = tui_io(exit.as_ref(), &state, scan, frame, std::io::stdout())?;
         output.join();
         stdout().execute(LeaveAlternateScreen)?;
         CrosstermBackend::new(stdout()).show_cursor()?;
@@ -73,6 +72,22 @@ pub fn tui_setup_panic () {
     };
 }
 
+/// Spawn the TUI input and output threadsl.
+pub fn tui_io <
+    T: View<Tui> + Apply<TuiEvent, Usually<()>> + Send + Sync + 'static,
+    W: Write + Send + Sync + 'static,
+> (
+    exited: &Arc<AtomicBool>,
+    state:  &Arc<RwLock<T>>,
+    poll:   Duration,
+    sleep:  Duration,
+    output: W,
+) -> Result<(Task, Task), Box<dyn Error>> {
+    let keyboard = tui_input(exited, state, poll)?;
+    let terminal = tui_output(exited, state, sleep, output)?;
+    Ok((keyboard, terminal))
+}
+
 /// Spawn the TUI input thread which reads keys from the terminal.
 pub fn tui_input <T: Apply<TuiEvent, Usually<()>> + Send + Sync + 'static> (
     exited: &Arc<AtomicBool>, state: &Arc<RwLock<T>>, poll: Duration

From 347151f7fcc2f0500de2c293d5d83b79f1e833d9 Mon Sep 17 00:00:00 2001
From: facile pop culture reference <donotem@ilme.no>
Date: Tue, 30 Jun 2026 15:38:47 +0300
Subject: [PATCH 17/25] screen: return damaged area

---
 src/draw/screen.rs |  3 ++-
 src/eval.rs        | 55 +++++++++++++++++++++++++---------------------
 src/term.rs        |  5 +++--
 3 files changed, 35 insertions(+), 28 deletions(-)

diff --git a/src/draw/screen.rs b/src/draw/screen.rs
index eab296b..857031d 100644
--- a/src/draw/screen.rs
+++ b/src/draw/screen.rs
@@ -22,5 +22,6 @@ use super::*;
 pub trait Screen: Space<Self::Unit> + Send + Sync + Sized {
     type Unit: Coord;
     /// Render drawable in subarea specified by `area`
-    fn show <'t, T: Draw<Self>> (&mut self, area: XYWH<Self::Unit>, content: T);
+    fn show <'t, T: Draw<Self>> (&mut self, area: XYWH<Self::Unit>, content: T) ->
+        Usually<XYWH<Self::Unit>>;
 }
diff --git a/src/eval.rs b/src/eval.rs
index 8709747..b64b83e 100644
--- a/src/eval.rs
+++ b/src/eval.rs
@@ -77,7 +77,7 @@ macro_rules! eval_enum ((
 /// ```
 pub fn eval_view <'a, O: Screen + 'a, S> (
     state: &S, output: &mut O, expr: &'a impl Expression
-) -> Usually<bool> where
+) -> Perhaps<XYWH<O::Unit>> where
     S: Interpret<O, XYWH<O::Unit>>
         + for<'b> Namespace<'b, bool>
         + for<'b> Namespace<'b, O::Unit>
@@ -100,7 +100,7 @@ pub fn eval_view <'a, O: Screen + 'a, S> (
     let arg2  = tail1.head();
 
     // First `frags.next()` calls returns the namespace.
-    match frags.next() {
+    Some(match frags.next() {
 
         Some("when") => when(
             state.namespace(arg0?)?.unwrap(),
@@ -132,26 +132,30 @@ pub fn eval_view <'a, O: Screen + 'a, S> (
         ).draw(output),
 
         Some("exact") => eval_xy!(
-            "exact", expr, head, output, state, frags.next(), arg0, arg1, arg2, wh_exact, w_exact, h_exact
-        ),
-        Some("min")   => eval_xy!(
-            "min",   expr, head, output, state, frags.next(), arg0, arg1, arg2, wh_min,   w_min,   h_min
-        ),
-        Some("max")   => eval_xy!(
-            "max",   expr, head, output, state, frags.next(), arg0, arg1, arg2, wh_max,   w_max,   h_max
-        ),
-        Some("push")  => eval_xy!(
-            "push",  expr, head, output, state, frags.next(), arg0, arg1, arg2, xy_push,  x_push,  y_push
+            "exact", expr, head, output, state, frags.next(),
+            arg0, arg1, arg2, wh_exact, w_exact, h_exact
         ),
 
-        _ => return Ok(false)
+        Some("min") => eval_xy!(
+            "min", expr, head, output, state, frags.next(),
+            arg0, arg1, arg2, wh_min,   w_min,   h_min
+        ),
 
-    }?;
+        Some("max") => eval_xy!(
+            "max", expr, head, output, state, frags.next(),
+            arg0, arg1, arg2, wh_max,   w_max,   h_max
+        ),
 
-    Ok(true)
+        Some("push") => eval_xy!(
+            "push", expr, head, output, state, frags.next(),
+            arg0, arg1, arg2, xy_push,  x_push,  y_push
+        ),
+
+        _ => return Ok(None)
+
+    }).transpose()
 }
 
-
 /// Interpret TUI-specific layout operation.
 ///
 /// ```
@@ -174,8 +178,8 @@ pub fn eval_view <'a, O: Screen + 'a, S> (
 /// ```
 pub fn eval_view_tui <'a, S> (
     state: &S, output: &mut Tui, expr: impl Expression + 'a
-) -> Usually<bool> where
-    S: Interpret<Tui, ()>
+) -> Perhaps<XYWH<u16>> where
+    S: Interpret<Tui, XYWH<u16>>
         + for<'b>Namespace<'b, bool>
         + for<'b>Namespace<'b, u16>
         + for<'b>Namespace<'b, Color>
@@ -187,11 +191,13 @@ pub fn eval_view_tui <'a, S> (
     let arg0  = args.head();
     let tail0 = args.tail();
     let arg1  = tail0.head();
-    match frags.next() {
+    Ok(Some(match frags.next() {
 
         Some("text") => {
             if let Some(src) = args?.src()? {
-                output.show(output.xywh(), &src)
+                output.show(output.xywh(), &src)?
+            } else {
+                return Ok(None)
             }
         },
 
@@ -202,7 +208,7 @@ pub fn eval_view_tui <'a, S> (
                 state.interpret(output, &arg1)?;
                 // FIXME?: don't max out the used area?
                 Ok(output.area().into())
-            })))
+            })))?
         },
 
         Some("bg") => {
@@ -212,11 +218,10 @@ pub fn eval_view_tui <'a, S> (
                 state.interpret(output, &arg1)?;
                 // FIXME?: don't max out the used area?
                 Ok(output.area().into())
-            })))
+            })))?
         },
 
-        _ => return Ok(false)
+        _ => return Ok(None)
 
-    };
-    Ok(true)
+    }))
 }
diff --git a/src/term.rs b/src/term.rs
index b5fa807..57caf15 100644
--- a/src/term.rs
+++ b/src/term.rs
@@ -194,11 +194,12 @@ impl Screen for Tui {
     /// Render drawable in subarea specified by `area`
     fn show <'t, T: Draw<Self>> (
         &mut self, area: XYWH<u16>, content: T
-    ) {
+    ) -> Usually<XYWH<u16>> {
         let previous_area = self.1;
         self.1 = area;
-        let _result_area = content.draw(self);
+        let result_area = content.draw(self);
         self.1 = previous_area;
+        result_area
     }
 }
 

From 2ab871d10b26b40d129d62f68ecbd9e960aa4c86 Mon Sep 17 00:00:00 2001
From: facile pop culture reference <donotem@ilme.no>
Date: Wed, 1 Jul 2026 19:21:13 +0300
Subject: [PATCH 18/25] fix: bump dizzle

---
 dizzle | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dizzle b/dizzle
index 7382600..0292cea 160000
--- a/dizzle
+++ b/dizzle
@@ -1 +1 @@
-Subproject commit 73826009cd94b9c667f4ecff88b7a1aa96a825b5
+Subproject commit 0292cea24f5bfe71e0f8c6f4afe3cad105aa8ab8

From 90ebae0f26fc4524659704df274d0aec815dba2e Mon Sep 17 00:00:00 2001
From: facile pop culture reference <donotem@ilme.no>
Date: Thu, 2 Jul 2026 07:29:22 +0300
Subject: [PATCH 19/25] refactor: reuse tui_teardown

---
 src/term.rs | 27 ++++++++++-----------------
 1 file changed, 10 insertions(+), 17 deletions(-)

diff --git a/src/term.rs b/src/term.rs
index 57caf15..cd31156 100644
--- a/src/term.rs
+++ b/src/term.rs
@@ -32,23 +32,25 @@ use ::{
     ($state:expr) => { pub fn main () -> Usually<()> { tui_run_main($state) } }
 }
 
-pub fn tui_run_main <T> (state: T) -> Usually<()> where
+pub fn tui_run_main <T> (state: Arc<RwLock<T>>) -> Usually<()> where
     T: View<Tui> + Apply<TuiEvent, Usually<()>> + Send + Sync + 'static
 {
-    tui_setup_panic();
     Exit::run(|exit|{
-        let state  = Arc::new(RwLock::new(state));
         let scan   = Duration::from_millis(100);
         let frame  = Duration::from_millis(10);
         let (input, output) = tui_io(exit.as_ref(), &state, scan, frame, std::io::stdout())?;
         output.join();
-        stdout().execute(LeaveAlternateScreen)?;
-        CrosstermBackend::new(stdout()).show_cursor()?;
-        disable_raw_mode()?;
-        Ok(())
+        tui_teardown(&mut stdout())
     })
 }
 
+pub fn tui_teardown <W: Write> (backend: &mut W) -> Usually<()> {
+    use ::ratatui::backend::Backend;
+    stdout().execute(LeaveAlternateScreen)?;
+    CrosstermBackend::new(backend).show_cursor()?;
+    disable_raw_mode().map_err(Into::into)
+}
+
 pub fn tui_setup_panic () {
     use ::std::panic::{set_hook, PanicHookInfo};
     use ::better_panic::{Settings, Verbosity};
@@ -56,9 +58,7 @@ pub fn tui_setup_panic () {
         .verbosity(Verbosity::Full)
         .create_panic_handler();
     set_hook(Box::new(move |info: &PanicHookInfo|{
-        stdout().execute(LeaveAlternateScreen).unwrap();
-        CrosstermBackend::new(stdout()).show_cursor().unwrap();
-        disable_raw_mode().unwrap();
+        let _ = tui_teardown(&mut stdout());
         panic(info);
     }));
 }
@@ -493,13 +493,6 @@ fn y_scroll () -> impl Draw<Tui> {
     })
 }
 
-pub fn tui_teardown <W: Write> (backend: &mut CrosstermBackend<W>) -> Usually<()> {
-    use ::ratatui::backend::Backend;
-    stdout().execute(LeaveAlternateScreen)?;
-    backend.show_cursor()?;
-    disable_raw_mode().map_err(Into::into)
-}
-
 pub fn tui_update (
     Tui(buf, ..): &mut Tui,
     area: XYWH<u16>,

From 0b9e9c06962e5cd55b639d9c0a7cef6f11405d81 Mon Sep 17 00:00:00 2001
From: facile pop culture reference <donotem@ilme.no>
Date: Sun, 5 Jul 2026 18:46:22 +0300
Subject: [PATCH 20/25] wip: final simplify

---
 PAPER.qmd                       |   0
 dizzle                          |   2 +-
 shell.nix                       |  29 +++-
 src/draw.rs                     | 123 ++++++++++++++---
 src/draw/screen.rs              |  27 ----
 src/draw/thunk.rs               |  51 -------
 src/draw/view.rs                |   8 --
 src/eval.rs                     |   6 +-
 src/layout.rs                   |  87 ++++++++++++
 src/layout/align.rs             |  13 ++
 src/layout/area.rs              |  15 +++
 src/layout/origin.rs            |  23 ++++
 src/{space => layout}/split.rs  |  12 +-
 src/lib.rs                      |  46 ++++---
 src/space.rs                    | 198 +--------------------------
 src/space/origin.rs             | 100 --------------
 src/space/{size.rs => sizer.rs} |  25 ++--
 src/space/xywh.rs               | 231 ++++++++++++++++++++++++++++++--
 src/term.rs                     | 118 ++++++----------
 src/term/buffer.rs              |  31 +++++
 src/text.rs                     |   6 +
 21 files changed, 607 insertions(+), 544 deletions(-)
 create mode 100644 PAPER.qmd
 delete mode 100644 src/draw/screen.rs
 delete mode 100644 src/draw/thunk.rs
 delete mode 100644 src/draw/view.rs
 create mode 100644 src/layout.rs
 create mode 100644 src/layout/align.rs
 create mode 100644 src/layout/area.rs
 create mode 100644 src/layout/origin.rs
 rename src/{space => layout}/split.rs (92%)
 delete mode 100644 src/space/origin.rs
 rename src/space/{size.rs => sizer.rs} (53%)
 create mode 100644 src/term/buffer.rs

diff --git a/PAPER.qmd b/PAPER.qmd
new file mode 100644
index 0000000..e69de29
diff --git a/dizzle b/dizzle
index 0292cea..f8e310b 160000
--- a/dizzle
+++ b/dizzle
@@ -1 +1 @@
-Subproject commit 0292cea24f5bfe71e0f8c6f4afe3cad105aa8ab8
+Subproject commit f8e310b477afc1aab4701fdc52da474143d78a28
diff --git a/shell.nix b/shell.nix
index dba3faf..6f44581 100644
--- a/shell.nix
+++ b/shell.nix
@@ -1,13 +1,28 @@
 #!/usr/bin/env nix-shell
 {pkgs?import<nixpkgs>{}}:let
-  stdenv            = pkgs.clang19Stdenv;
-  name              = "tengri";
-  nativeBuildInputs = [ pkgs.pkg-config pkgs.clang pkgs.libclang pkgs.mold pkgs.bacon ];
-  buildInputs       = [ pkgs.libclang pkgs.jack2 ];
-  LIBCLANG_PATH     = "${pkgs.libclang.lib.outPath}/lib";
-  LD_LIBRARY_PATH   = pkgs.lib.makeLibraryPath [];
+  name            = "tengri";
+  stdenv          = pkgs.clang19Stdenv;
+  LIBCLANG_PATH   = "${pkgs.libclang.lib.outPath}/lib";
+  LD_LIBRARY_PATH = pkgs.lib.makeLibraryPath [];
 in pkgs.mkShell.override {
   inherit stdenv;
 } {
-  inherit name nativeBuildInputs buildInputs LIBCLANG_PATH LD_LIBRARY_PATH;
+  inherit name LIBCLANG_PATH LD_LIBRARY_PATH;
+  buildInputs = [
+    pkgs.libclang
+    pkgs.jack2
+  ];
+  nativeBuildInputs = [
+    pkgs.pkg-config
+    pkgs.clang
+    pkgs.libclang
+    pkgs.mold
+    pkgs.bacon
+    (pkgs.quarto.overrideAttrs (oldAttrs: { # https://github.com/NixOS/nixpkgs/issues/519484
+      postPatch = (oldAttrs.postPatch or "") + ''
+        substituteInPlace bin/quarto.js \
+          --replace-fail "syntax-highlighting" "highlight-style"
+      '';
+    }))
+  ];
 }
diff --git a/src/draw.rs b/src/draw.rs
index df505d3..23c55b5 100644
--- a/src/draw.rs
+++ b/src/draw.rs
@@ -1,14 +1,30 @@
 use crate::*;
 pub use crate::space::*;
 
-mod view;
-pub use self::view::*;
-
-mod thunk;
-pub use self::thunk::*;
-
-mod screen;
-pub use self::screen::*;
+/// Output target.
+///
+/// ```
+/// use tengri::{*, draw::*};
+///
+/// struct TestOut<T: Screen<Unit = u16>>(T);
+///
+/// impl<T: Screen<Unit = u16>> Screen for TestOut {
+///     type Unit = u16;
+///     fn show <D: Draw<Self> + ?Sized> (&mut self, _: D) {
+///         println!("placed");
+///         ()
+///     }
+/// }
+///
+/// impl_draw!(|self: String, to: TestOut<u16>|{
+///    to.area_mut().set_w(self.len() as u16);
+/// });
+/// ```
+pub trait Screen: Xy<Self::Unit> + Wh<Self::Unit> + Send + Sync + Sized {
+    type Unit: Coord;
+    /// Render drawable in subarea specified by `area`
+    fn show <'t, T: Draw<Self>> (&mut self, content: T) -> Perhaps<XYWH<Self::Unit>>;
+}
 
 /// Implement the [Draw] trait for a particular drawable and [Screen].
 ///
@@ -22,7 +38,7 @@ pub use self::screen::*;
 #[macro_export] macro_rules! impl_draw ((|
     $self:ident:$Self:ty, $to:ident:$To:ty
 |$draw:block)=>{ impl Draw<$To> for $Self {
-    fn draw ($self, $to: &mut $To) -> Usually<XYWH<u16>> $draw
+    fn draw ($self, $to: &mut $To) -> Usually<XYWH<<$To as Screen>::Unit>> $draw
 } });
 
 /// Drawable that supports dynamic dispatch.
@@ -48,29 +64,94 @@ pub use self::screen::*;
 /// ```
 pub trait Draw<S: Screen> {
     fn draw (self, to: &mut S) -> Usually<XYWH<S::Unit>>;
+    fn layout (&self, area: XYWH<S::Unit>) -> Perhaps<XYWH<S::Unit>> {
+        Ok(Some(area))
+    }
 }
+
 impl<S: Screen> Draw<S> for () {
     fn draw (self, __: &mut S) -> Usually<XYWH<S::Unit>> {
         Ok(Default::default())
     }
 }
-impl<S: Screen, D: Draw<S>> Draw<S> for &D {
-    fn draw (self, __: &mut S) -> Usually<XYWH<S::Unit>> {
-        todo!()
-    }
-}
+
 impl<S: Screen, D: Draw<S>> Draw<S> for Option<D> {
-    fn draw (self, __: &mut S) -> Usually<XYWH<S::Unit>> {
-        todo!()
-    }
-}
-impl<S: Screen, D: Draw<S>> Draw<S> for RwLock<D> {
-    fn draw (self, __: &mut S) -> Usually<XYWH<S::Unit>> {
-        todo!()
+    fn draw (self, to: &mut S) -> Usually<XYWH<S::Unit>> {
+        self.map(|it|it.draw(to)).transpose().map(Option::unwrap_or_default)
     }
 }
+
+//impl<S: Screen, D: Draw<S>> Draw<S> for RwLock<D> {
+    //fn draw (self, __: &mut S) -> Usually<XYWH<S::Unit>> {
+        //todo!()
+    //}
+//}
+
 //impl<T: Screen, D: Draw<T>> Draw<T> for Arc<D> {
     //fn draw (self, __: &mut T) -> Usually<XYWH<T::Unit>> {
         //todo!()
     //}
 //}
+
+/// Emit a [Draw]able.
+///
+/// Speculative. How to avoid conflicts with [Draw] proper?
+pub trait View<T: Screen> {
+    fn view (&self) -> impl Draw<T>;
+}
+
+impl<T: Screen, V: View<T>> Draw<T> for &V {
+    fn draw (self, to: &mut T) -> Usually<XYWH<T::Unit>> {
+        self.view().draw(to)
+    }
+}
+
+/// Because we can't implement [Draw] for `F: FnOnce...` without conflicts.
+pub struct Thunk<T: Screen, F: FnOnce(&mut T)->Usually<XYWH<T::Unit>>>(
+    pub F,
+    std::marker::PhantomData<T>
+);
+
+impl<T: Screen, F: FnOnce(&mut T)->Usually<XYWH<T::Unit>>> Draw<T> for Thunk<T, F> {
+    fn draw (self, to: &mut T) -> Usually<XYWH<T::Unit>> {
+        (self.0)(to)
+    }
+}
+
+/// Basic [Draw]able closure.
+///
+/// ```
+/// # use tengri::{draw::*, term::*};
+/// # fn test () -> impl tengri::draw::Draw<tengri::term::Tui> {
+///     thunk(|to: &mut Tui|Ok(to.1))
+/// # }
+/// ```
+pub const fn thunk <T: Screen, F: FnOnce(&mut T)->Usually<XYWH<T::Unit>>> (
+    draw: F
+) -> Thunk<T, F> {
+    Thunk(draw, std::marker::PhantomData)
+}
+
+/// Only render when condition is true.
+///
+/// ```
+/// # use tengri::{draw::*, term::*};
+/// # fn test () -> impl tengri::draw::Draw<tengri::term::Tui> {
+///     when(true, "Yes")
+/// # }
+/// ```
+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.
+///
+/// ```
+/// # use tengri::{draw::*, term::*};
+/// # fn test () -> impl tengri::draw::Draw<tengri::term::Tui> {
+///     either(true, "Yes", "No")
+/// # }
+/// ```
+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) })
+}
diff --git a/src/draw/screen.rs b/src/draw/screen.rs
deleted file mode 100644
index 857031d..0000000
--- a/src/draw/screen.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-use super::*;
-
-/// Output target.
-///
-/// ```
-/// use tengri::{*, draw::*};
-///
-/// struct TestOut<T: Screen<Unit = u16>>(T);
-///
-/// impl<T: Screen<Unit = u16>> Screen for TestOut {
-///     type Unit = u16;
-///     fn show <D: Draw<Self> + ?Sized> (&mut self, area: T, _: D) {
-///         println!("placed: {area:?}");
-///         ()
-///     }
-/// }
-///
-/// impl_draw!(|self: String, to: TestOut<u16>|{
-///    to.area_mut().set_w(self.len() as u16);
-/// });
-/// ```
-pub trait Screen: Space<Self::Unit> + Send + Sync + Sized {
-    type Unit: Coord;
-    /// Render drawable in subarea specified by `area`
-    fn show <'t, T: Draw<Self>> (&mut self, area: XYWH<Self::Unit>, content: T) ->
-        Usually<XYWH<Self::Unit>>;
-}
diff --git a/src/draw/thunk.rs b/src/draw/thunk.rs
deleted file mode 100644
index a56b5f3..0000000
--- a/src/draw/thunk.rs
+++ /dev/null
@@ -1,51 +0,0 @@
-use super::*;
-
-/// Because we can't implement [Draw] for `F: FnOnce...` without conflicts.
-pub struct Thunk<T: Screen, F: FnOnce(&mut T)->Usually<XYWH<T::Unit>>>(
-    pub F,
-    std::marker::PhantomData<T>
-);
-
-impl<T: Screen, F: FnOnce(&mut T)->Usually<XYWH<T::Unit>>> Draw<T> for Thunk<T, F> {
-    fn draw (self, to: &mut T) -> Usually<XYWH<T::Unit>> {
-        (self.0)(to)
-    }
-}
-
-/// Basic [Draw]able closure.
-///
-/// ```
-/// # use tengri::{draw::*, term::*};
-/// # fn test () -> impl tengri::draw::Draw<tengri::term::Tui> {
-///     thunk(|to: &mut Tui|Ok(to.1))
-/// # }
-/// ```
-pub const fn thunk <T: Screen, F: FnOnce(&mut T)->Usually<XYWH<T::Unit>>> (
-    draw: F
-) -> Thunk<T, F> {
-    Thunk(draw, std::marker::PhantomData)
-}
-
-/// Only render when condition is true.
-///
-/// ```
-/// # use tengri::{draw::*, term::*};
-/// # fn test () -> impl tengri::draw::Draw<tengri::term::Tui> {
-///     when(true, "Yes")
-/// # }
-/// ```
-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.
-///
-/// ```
-/// # use tengri::{draw::*, term::*};
-/// # fn test () -> impl tengri::draw::Draw<tengri::term::Tui> {
-///     either(true, "Yes", "No")
-/// # }
-/// ```
-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) })
-}
diff --git a/src/draw/view.rs b/src/draw/view.rs
deleted file mode 100644
index 82fe908..0000000
--- a/src/draw/view.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-use super::*;
-
-/// Emit a [Draw]able.
-///
-/// Speculative. How to avoid conflicts with [Draw] proper?
-pub trait View<T: Screen> {
-    fn view (&self) -> impl Draw<T>;
-}
diff --git a/src/eval.rs b/src/eval.rs
index b64b83e..2da55fd 100644
--- a/src/eval.rs
+++ b/src/eval.rs
@@ -195,7 +195,7 @@ pub fn eval_view_tui <'a, S> (
 
         Some("text") => {
             if let Some(src) = args?.src()? {
-                output.show(output.xywh(), &src)?
+                output.show(src)?
             } else {
                 return Ok(None)
             }
@@ -204,7 +204,7 @@ pub fn eval_view_tui <'a, S> (
         Some("fg") => {
             let arg0 = arg0?.expect("fg: expected arg 0 (color)");
             let color = Namespace::namespace(state, arg0)?.unwrap_or_else(||panic!("fg: {arg0:?}: not a color"));
-            output.show(output.xywh(), &fg(color, thunk(move|output: &mut Tui|{
+            output.show(fg(color, thunk(move|output: &mut Tui|{
                 state.interpret(output, &arg1)?;
                 // FIXME?: don't max out the used area?
                 Ok(output.area().into())
@@ -214,7 +214,7 @@ pub fn eval_view_tui <'a, S> (
         Some("bg") => {
             let arg0 = arg0?.expect("bg: expected arg 0 (color)");
             let color = Namespace::namespace(state, arg0)?.unwrap_or_else(||panic!("bg: {arg0:?}: not a color"));
-            output.show(output.xywh(), &bg(color, thunk(move|output: &mut Tui|{
+            output.show(bg(color, thunk(move|output: &mut Tui|{
                 state.interpret(output, &arg1)?;
                 // FIXME?: don't max out the used area?
                 Ok(output.area().into())
diff --git a/src/layout.rs b/src/layout.rs
new file mode 100644
index 0000000..5fa4660
--- /dev/null
+++ b/src/layout.rs
@@ -0,0 +1,87 @@
+use crate::*;
+
+mod align; pub use self::align::*;
+mod area; pub use self::area::*;
+mod origin; pub use self::origin::*;
+mod split; pub use self::split::*;
+
+pub enum Layout<T: Screen, X: Into<Option<T::Unit>>, I: Draw<T>> {
+    __(PhantomData<T>),
+    MinW(X, I),
+    MinH(X, I),
+    MinWH(X, X, I),
+    MaxW(X, I),
+    MaxH(X, I),
+    MaxWH(X, X, I),
+    ExactW(X, I),
+    ExactH(X, I),
+    ExactWH(X, X, I),
+    ClipW(X, I),
+    ClipH(X, I),
+    ClipWH(X, X, I),
+}
+
+impl<
+    T: Screen,
+    X: Into<Option<T::Unit>>,
+    I: Draw<T>
+> Draw<T> for Layout<T, X, I> {
+    fn draw (self, to: &mut T) -> Usually<XYWH<T::Unit>> {
+        use Layout::*;
+        match self {
+            __(_) => unreachable!(),
+            MinW(x, it) => {
+                let x = x.into();
+                it.draw(to)
+            },
+            MinH(y, it) => {
+                let y = y.into();
+                it.draw(to)
+            },
+            MinWH(x, y, it) => {
+                let x = x.into();
+                let y = y.into();
+                it.draw(to)
+            },
+            MaxW(x, it) => {
+                let x = x.into();
+                it.draw(to)
+            },
+            MaxH(y, it) => {
+                let y = y.into();
+                it.draw(to)
+            },
+            MaxWH(x, y, it) => {
+                let x = x.into();
+                let y = y.into();
+                it.draw(to)
+            },
+            ExactW(x, it) => {
+                let x = x.into();
+                it.draw(to)
+            },
+            ExactH(y, it) => {
+                let y = y.into();
+                it.draw(to)
+            },
+            ExactWH(x, y, it) => {
+                let x = x.into();
+                let y = y.into();
+                it.draw(to)
+            },
+            ClipW(x, it) => {
+                let x = x.into();
+                it.draw(to)
+            },
+            ClipH(y, it) => {
+                let y = y.into();
+                it.draw(to)
+            },
+            ClipWH(x, y, it) => {
+                let x = x.into();
+                let y = y.into();
+                it.draw(to)
+            },
+        }
+    }
+}
diff --git a/src/layout/align.rs b/src/layout/align.rs
new file mode 100644
index 0000000..eac9e76
--- /dev/null
+++ b/src/layout/align.rs
@@ -0,0 +1,13 @@
+use crate::*;
+
+pub struct Align<T>(Option<Origin>, T);
+
+/// ```
+/// use tengri::*;
+/// let _ = align(None, "unaligned");
+/// let _ = align(Origin::SE, "southeast");
+/// let _ = align(Some(Origin::SE), "southeast");
+/// ```
+pub fn align <S: Screen, T: Draw<S>, U: Into<Option<Origin>>> (origin: U, it: T) -> Align<T> {
+    Align(origin.into(), it)
+}
diff --git a/src/layout/area.rs b/src/layout/area.rs
new file mode 100644
index 0000000..eb71215
--- /dev/null
+++ b/src/layout/area.rs
@@ -0,0 +1,15 @@
+use crate::*;
+
+pub struct Area<S: Screen, T: Draw<S>>(Option<XYWH<S::Unit>>, T);
+
+/// ```
+/// use tengri::*;
+/// let _ = area(None, "unareaed");
+/// let _ = area([1, 2, 3, 4], "southeast");
+/// let _ = area(Some([1, 2, 3, 4]), "southeast");
+/// ```
+pub fn area <S: Screen, T: Draw<S>, U: Into<Option<XYWH<S::Unit>>>> (
+    origin: U, it: T
+) -> Area<S, T> {
+    Area(origin.into(), it)
+}
diff --git a/src/layout/origin.rs b/src/layout/origin.rs
new file mode 100644
index 0000000..8b8b85e
--- /dev/null
+++ b/src/layout/origin.rs
@@ -0,0 +1,23 @@
+use super::*;
+
+/// 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
+}
+
+/// 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()
+    }
+}
diff --git a/src/space/split.rs b/src/layout/split.rs
similarity index 92%
rename from src/space/split.rs
rename to src/layout/split.rs
index 4fb42cc..2c9bd62 100644
--- a/src/space/split.rs
+++ b/src/layout/split.rs
@@ -50,16 +50,16 @@ impl Split {
         thunk(move|to: &mut T|{
             let (area_a, area_b) = to.xywh().split_half(self);
             let (origin_a, origin_b) = self.origins();
-            let a = origin_a.align(a);
-            let b = origin_b.align(b);
+            let a = align(origin_a, a);
+            let b = align(origin_b, b);
             match self {
                 Self::Below => {
-                    to.show(area_b, &b);
-                    to.show(area_b, &a);
+                    to.show(area(area_b, b))?;
+                    to.show(area(area_b, a))?;
                 },
                 _ => {
-                    to.show(area_a, &a);
-                    to.show(area_a, &b);
+                    to.show(area(area_a, a))?;
+                    to.show(area(area_b, b))?;
                 }
             }
             Ok(to.xywh()) // FIXME: compute and return actually used area
diff --git a/src/lib.rs b/src/lib.rs
index 4a5a44e..d0ddf0e 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -25,30 +25,32 @@ pub(crate) use ::{
     std::ops::{Add, Sub, Mul, Div},
     std::sync::{Arc, RwLock},
     std::sync::atomic::{AtomicBool, AtomicUsize, Ordering::*},
+    std::error::Error,
+    std::marker::PhantomData
 };
 
-#[cfg(feature = "lang")]
-pub use ::dizzle::{Usually, Perhaps, impl_default};
-/// DSL builtins.
-#[cfg(feature = "lang")] pub mod eval;
-/// Temporal dimension.
-#[cfg(feature = "time")] pub mod time;
-/// Circuit breaker for main loop.
-#[cfg(feature = "play")] pub mod exit;
-/// Thread management.
-#[cfg(feature = "play")] pub mod task;
-/// Integration with JACK audio backend.
-#[cfg(feature = "sing")] pub mod sing;
-/// Generic drawing utilities.
-#[cfg(feature = "draw")] pub mod draw;
-/// Spatial dimension.
-#[cfg(feature = "draw")] pub mod space;
-/// Color handling.
-#[cfg(feature = "draw")] pub mod color;
-/// Text handling.
-#[cfg(feature = "text")] pub mod text;
-/// Terminal output.
-#[cfg(feature = "term")] pub mod term;
+macro_rules! features {
+    ($($feature:literal: [ $($module:ident),* ]),*) => {
+        $(
+            $(
+                #[cfg(feature = $feature)] mod $module;
+                #[cfg(feature = $feature)] pub use $module::*;
+            )*
+        )*
+    }
+}
+
+#[cfg(feature = "lang")] pub use ::dizzle::{Usually, Perhaps, impl_default};
+
+features! {
+    "lang": [ eval ],
+    "time": [ time ],
+    "play": [ exit, task ],
+    "sing": [ sing ],
+    "draw": [ draw, space, layout, color ],
+    "text": [ text ],
+    "term": [ term ]
+}
 
 /// Define a trait an implement it for various mutation-enabled wrapper types. */
 #[macro_export] macro_rules! flex_trait_mut (
diff --git a/src/space.rs b/src/space.rs
index fd9ac7d..8be15b4 100644
--- a/src/space.rs
+++ b/src/space.rs
@@ -1,195 +1,7 @@
-use crate::{*, draw::*};
+use crate::*;
 #[cfg(test)] use proptest_derive::Arbitrary;
 
-mod coord;
-pub use self::coord::*;
-
-mod xywh;
-pub use self::xywh::*;
-
-mod origin;
-pub use self::origin::*;
-
-mod split;
-pub use self::split::*;
-
-mod iter;
-pub use self::iter::*;
-
-mod size;
-pub use self::size::*;
-
-/// Horizontal axis.
-pub trait X<N: Coord> {
-    fn x (&self) -> N;
-    fn w (&self) -> N { N::zero() }
-    fn w_min (&self) -> N { self.w() }
-    fn w_max (&self) -> N { self.w() }
-    fn iter_x (&self) -> impl Iterator<Item = N> where Self: HasOrigin {
-        self.x_west()..self.x_east()
-    }
-    fn x_west (&self) -> N where Self: 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: 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: HasOrigin {
-        todo!()
-    }
-}
-pub const fn x_push <T: Screen> (x: T::Unit, a: impl Draw<T>) -> impl Draw<T> {
-    a
-}
-pub const fn x_pull <T: Screen> (x: T::Unit, a: impl Draw<T>) -> impl Draw<T> {
-    a
-}
-pub const fn w_max <T: Screen> (w: Option<T::Unit>, a: impl Draw<T>) -> impl Draw<T> {
-    wh_max(w, None, a)
-}
-pub const fn w_min <T: Screen> (w: Option<T::Unit>, a: impl Draw<T>) -> impl Draw<T> {
-    wh_min(w, None, a)
-}
-pub const fn w_exact <T: Screen> (w: T::Unit, c: impl Draw<T>) -> impl Draw<T> {
-    wh_exact(Some(w), None, c)
-}
-/// Shrink drawing area symmetrically.
-///
-/// ```
-/// let padded = tengri::space::w_pad(3, "Hello");
-/// ```
-pub const fn w_pad <T: Screen> (x: T::Unit, draw: impl Draw<T>) -> impl Draw<T> {
-    thunk(move|to: &mut T|draw.draw(todo!()))
-}
-
-pub trait Y<N: Coord> {
-    fn y (&self) -> N;
-    fn h (&self) -> N { N::zero() }
-    fn h_min (&self) -> N { self.h() }
-    fn h_max (&self) -> N { self.h() }
-    fn iter_y (&self) -> impl Iterator<Item = N> where Self: HasOrigin {
-        self.y_north()..self.y_south()
-    }
-    fn y_north (&self) -> N where Self: 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: 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: HasOrigin {
-        todo!()
-    }
-}
-pub const fn y_push <T: Screen> (x: T::Unit, a: impl Draw<T>) -> impl Draw<T> {
-    a
-}
-pub const fn y_pull <T: Screen> (x: T::Unit, a: impl Draw<T>) -> impl Draw<T> {
-    a
-}
-pub const fn h_max <T: Screen> (h: Option<T::Unit>, a: impl Draw<T>) -> impl Draw<T> {
-    wh_max(None, h, a)
-}
-pub const fn h_min <T: Screen> (h: Option<T::Unit>, a: impl Draw<T>) -> impl Draw<T> {
-    wh_min(None, h, a)
-}
-pub const fn h_exact <T: Screen> (h: T::Unit, c: impl Draw<T>) -> impl Draw<T> {
-    wh_exact(None, Some(h), c)
-}
-/// Shrink drawing area symmetrically.
-///
-/// ```
-/// let padded = tengri::space::w_pad(3, "Hello");
-/// ```
-pub const fn h_pad <T: Screen> (x: T::Unit, draw: impl Draw<T>) -> impl Draw<T> {
-    thunk(move|to: &mut T|draw.draw(todo!()))
-}
-
-pub trait Space<N: Coord>: X<N> + Y<N> {
-    fn xywh (&self) -> XYWH<N> { XYWH(self.x(), self.y(), self.w(), self.h()) }
-    // FIXME: factor origin
-    fn lrtb (&self) -> [N;4] { [self.x(), self.y(), self.x()+self.w(), self.y()+self.h()] }
-}
-
-impl<N: Coord, T: X<N> + Y<N>> Space<N> for T {}
-
-pub const fn xy_push <T: Screen> (x: T::Unit, y: T::Unit, a: impl Draw<T>) -> impl Draw<T> {
-    a
-}
-
-pub const fn xy_pull <T: Screen> (x: T::Unit, y: T::Unit, a: impl Draw<T>) -> impl Draw<T> {
-    a
-}
-
-/// Shrink drawing area symmetrically.
-///
-/// ```
-/// let padded = tengri::WH(3, 5).pad("Hello");
-/// ```
-pub const fn wh_pad <T: Screen> (w: T::Unit, h: T::Unit, 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::space::wh_min(3, 5, "Hello"); // 5x5
-/// ```
-pub const fn wh_min <T: Screen> (w: Option<T::Unit>, h: Option<T::Unit>, 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::space::wh_max(Some(3), Some(5), "Hello");
-/// ```
-pub const fn wh_max <T: Screen> (w: Option<T::Unit>, h: Option<T::Unit>, 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::space::wh_exact(Some(3), Some(5), "Hello");
-/// ```
-pub const fn wh_exact <T: Screen> (w: Option<T::Unit>, h: Option<T::Unit>, draw: impl Draw<T>)
-    -> impl Draw<T>
-{
-    thunk(move|_to: &mut T|draw.draw(todo!()))
-}
-
-/// Limit size of drawing area
-/// ```
-/// let clipped = tengri::space::wh_clip(Some(3), Some(5), "Hello");
-/// ```
-pub const fn wh_clip <T: Screen> (
-    w: Option<T::Unit>, h: Option<T::Unit>, draw: impl Draw<T>
-) -> impl Draw<T> {
-    thunk(move|_to: &mut T|draw.draw(todo!()))
-}
-
-pub const fn wh_full <T: Screen> (a: impl Draw<T>) -> impl Draw<T> { a }
-pub const fn w_full <T: Screen> (a: impl Draw<T>) -> impl Draw<T> { a }
-pub const fn h_full <T: Screen> (a: impl Draw<T>) -> impl Draw<T> { a }
+mod coord;  pub use self::coord::*;
+mod iter;   pub use self::iter::*;
+mod sizer;  pub use self::sizer::*;
+mod xywh;   pub use self::xywh::*;
diff --git a/src/space/origin.rs b/src/space/origin.rs
deleted file mode 100644
index f3f7acc..0000000
--- a/src/space/origin.rs
+++ /dev/null
@@ -1,100 +0,0 @@
-use super::*;
-
-pub const fn origin_c <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
-    Anchor(Origin::C, a)
-}
-
-pub const fn origin_x <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
-    Anchor(Origin::X, a)
-}
-
-pub const fn origin_y <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
-    Anchor(Origin::Y, a)
-}
-
-pub const fn origin_nw <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
-    Anchor(Origin::NW, a)
-}
-
-pub const fn origin_n <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
-    Anchor(Origin::N, a)
-}
-
-pub const fn origin_ne <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
-    Anchor(Origin::NE, a)
-}
-
-pub const fn origin_w <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
-    Anchor(Origin::W, a)
-}
-
-pub const fn origin_e <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
-    Anchor(Origin::E, a)
-}
-
-pub const fn origin_sw <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
-    Anchor(Origin::SW, a)
-}
-
-pub const fn origin_s <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
-    Anchor(Origin::S, a)
-}
-
-pub const fn origin_se <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
-    Anchor(Origin::SE, a)
-}
-
-/// 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()
-    }
-}
-
-pub struct Anchor<T>(Origin, T);
-
-impl<T> AsRef<Origin> for Anchor<T> {
-    fn as_ref (&self) -> &Origin {
-        &self.0
-    }
-}
-
-impl<T: Screen, U: Draw<T>> Draw<T> for Anchor<U> {
-    fn draw (self, to: &mut T) -> Usually<XYWH<T::Unit>> {
-        todo!()
-    }
-}
-
-/// 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!() })
-}
-
-pub fn align_n <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
-    align(Origin::N, a)
-}
diff --git a/src/space/size.rs b/src/space/sizer.rs
similarity index 53%
rename from src/space/size.rs
rename to src/space/sizer.rs
index 4614ff1..90d09bf 100644
--- a/src/space/size.rs
+++ b/src/space/sizer.rs
@@ -1,32 +1,25 @@
 use super::*;
+use std::sync::atomic::Ordering;
 
 /// Uses [AtomicUsize] to measure size during\
 /// rendering (which is normally read-only).
 #[derive(Default, Debug, Clone)]
-pub struct Size(
+pub struct Sizer(
     /// Width
     pub Arc<AtomicUsize>,
     /// Height
     pub Arc<AtomicUsize>,
 );
 
-impl PartialEq for Size {
-    fn eq (&self, _: &Self) -> bool {
-        todo!()
-    }
+impl Xy<u16> for Sizer {
+    fn x (&self) -> u16 { self.0.load(Ordering::Relaxed) as u16 }
+    fn y (&self) -> u16 { self.1.load(Ordering::Relaxed) as u16 }
 }
+impl Wide<u16> for Sizer { fn w (&self) -> u16 { self.0.load(Relaxed) as u16 } }
+impl Tall<u16> for Sizer { fn h (&self) -> u16 { self.1.load(Relaxed) as u16 } }
+impl PartialEq for Sizer { fn eq (&self, _: &Self) -> bool { todo!() } }
 
-impl X<u16> for Size {
-    fn x (&self) -> u16 { 0 }
-    fn w (&self) -> u16 { self.0.load(Relaxed) as u16 }
-}
-
-impl Y<u16> for Size {
-    fn y (&self) -> u16 { 0 }
-    fn h (&self) -> u16 { self.1.load(Relaxed) as u16 }
-}
-
-impl Size {
+impl Sizer {
     pub const fn of <T: Screen> (&self, of: impl Draw<T>) -> impl Draw<T> {
         thunk(move|to: &mut T|{
             let area = of.draw(to)?;
diff --git a/src/space/xywh.rs b/src/space/xywh.rs
index c403f5a..518b314 100644
--- a/src/space/xywh.rs
+++ b/src/space/xywh.rs
@@ -1,4 +1,76 @@
 use super::*;
+use Origin::*;
+use Split::*;
+
+pub trait Xy<N: Coord> {
+    fn x (&self) -> N;
+    fn y (&self) -> N;
+}
+
+pub trait Wh<N: Coord>: Wide<N> + Tall<N> {
+    fn wh (&self) -> [N;2];
+}
+
+pub trait Xywh<N: Coord>: Xy<N> + Wh<N> {
+    fn xywh (&self) -> XYWH<N> {
+        XYWH(self.x(), self.y(), self.w(), self.h())
+    }
+}
+
+pub trait Lrtb<N: Coord> {
+    // FIXME: factor origin
+    fn lrtb (&self) -> [N;4] {
+        [self.x(), self.y(), self.x()+self.w(), self.y()+self.h()]
+    }
+}
+
+pub trait Wide<N: Coord> {
+    fn w (&self) -> N { N::zero() }
+    fn w_min (&self) -> N { self.w() }
+    fn w_max (&self) -> N { self.w() }
+    fn iter_x (&self) -> impl Iterator<Item = N> where Self: HasOrigin {
+        self.x_west()..self.x_east()
+    }
+    fn x_west (&self) -> N where Self: HasOrigin {
+        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: HasOrigin {
+        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: HasOrigin {
+        todo!()
+    }
+}
+
+pub trait Tall<N: Coord> {
+    fn h (&self) -> N { N::zero() }
+    fn h_min (&self) -> N { self.h() }
+    fn h_max (&self) -> N { self.h() }
+    fn iter_y (&self) -> impl Iterator<Item = N> where Self: HasOrigin {
+        self.y_north()..self.y_south()
+    }
+    fn y_north (&self) -> N where Self: HasOrigin {
+        let a = self.origin();
+        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_south (&self) -> N where Self: HasOrigin  {
+        let a = self.origin();
+        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)
+    }
+    fn y_center (&self) -> N where Self: HasOrigin {
+        todo!()
+    }
+}
 
 /// Point with size.
 ///
@@ -13,21 +85,14 @@ use super::*;
 #[cfg_attr(test, derive(Arbitrary))] #[derive(Copy, Clone, Debug, Default, PartialEq)]
 pub struct XYWH<N: Coord>(pub N, pub N, pub N, pub N);
 
-impl From<&ratatui::prelude::Rect> for XYWH<u16> {
-    fn from (rect: &ratatui::prelude::Rect) -> Self {
-        Self(rect.x, rect.y, rect.width, rect.height)
-    }
-}
-
-impl<N: Coord> X<N> for XYWH<N> {
+impl<N: Coord> Xy<N> for XYWH<N> {
     fn x (&self) -> N { self.0 }
-    fn w (&self) -> N { self.2 }
+    fn y (&self) -> N { self.1 }
 }
 
-impl<N: Coord> Y<N> for XYWH<N> {
-    fn y (&self) -> N { self.0 }
-    fn h (&self) -> N { self.2 }
-}
+impl<N: Coord> Wide<N> for XYWH<N> { fn w (&self) -> N { self.2 } }
+
+impl<N: Coord> Tall<N> for XYWH<N> { fn h (&self) -> N { self.3 } }
 
 impl<N: Coord> XYWH<N> {
 
@@ -67,7 +132,6 @@ impl<N: Coord> XYWH<N> {
     }
 
     pub fn split_half (&self, direction: &Split) -> (Self, Self) {
-        use Split::*;
         let XYWH(x, y, w, h) = self.xywh();
         match direction {
             South => (XYWH(x, y, w, h - h / 2.into()), XYWH(x, y + h / 2.into(), w, h / 2.into())),
@@ -79,3 +143,144 @@ impl<N: Coord> XYWH<N> {
     }
 
 }
+
+impl From<&ratatui::prelude::Rect> for XYWH<u16> {
+    fn from (rect: &ratatui::prelude::Rect) -> Self {
+        Self(rect.x, rect.y, rect.width, rect.height)
+    }
+}
+
+impl<N: Coord, T: Wide<N> + Tall<N>> Wh<N> for T {
+    fn wh (&self) -> [N;2] {
+        [self.w(), self.h()]
+    }
+}
+
+impl<N: Coord, T: Xy<N> + Wh<N>> Xywh<N> for T {}
+
+/// Shrink drawing area symmetrically.
+///
+/// ```
+/// let padded = tengri::wh_pad("Hello");
+/// ```
+pub const fn wh_pad <T: Screen> (w: T::Unit, h: T::Unit, it: impl Draw<T>)
+    -> impl Draw<T>
+{
+    thunk(move|to: &mut T|it.draw(todo!()))
+}
+
+/// Only draw content if area is above a certain size.
+///
+/// ```
+/// let min = tengri::wh_min(3, 5, "Hello"); // 5x5
+/// ```
+pub const fn wh_min <T: Screen> (w: Option<T::Unit>, h: Option<T::Unit>, it: impl Draw<T>)
+    -> impl Draw<T>
+{
+    thunk(move|to: &mut T|it.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 wh_max <T: Screen> (w: Option<T::Unit>, h: Option<T::Unit>, it: impl Draw<T>)
+    -> impl Draw<T>
+{
+    thunk(move|_to: &mut T|it.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 wh_exact <T: Screen> (w: Option<T::Unit>, h: Option<T::Unit>, it: impl Draw<T>)
+    -> impl Draw<T>
+{
+    thunk(move|_to: &mut T|it.draw(todo!()))
+}
+
+/// Limit size of drawing area
+/// ```
+/// let clipped = tengri::wh_clip(Some(3), Some(5), "Hello");
+/// ```
+pub const fn wh_clip <T: Screen> (
+    w: Option<T::Unit>, h: Option<T::Unit>, it: impl Draw<T>
+) -> impl Draw<T> {
+    thunk(move|_to: &mut T|it.draw(todo!()))
+}
+
+pub const fn wh_full <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
+    todo!();
+    a
+}
+
+pub const fn w_full <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
+    todo!();
+    a
+}
+
+pub const fn h_full <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
+    todo!();
+    a
+}
+
+pub const fn h_max <T: Screen> (h: Option<T::Unit>, a: impl Draw<T>) -> impl Draw<T> {
+    wh_max(None, h, a)
+}
+pub const fn h_min <T: Screen> (h: Option<T::Unit>, a: impl Draw<T>) -> impl Draw<T> {
+    wh_min(None, h, a)
+}
+pub const fn h_exact <T: Screen> (h: T::Unit, c: impl Draw<T>) -> impl Draw<T> {
+    wh_exact(None, Some(h), c)
+}
+pub const fn w_max <T: Screen> (w: Option<T::Unit>, a: impl Draw<T>) -> impl Draw<T> {
+    wh_max(w, None, a)
+}
+pub const fn w_min <T: Screen> (w: Option<T::Unit>, a: impl Draw<T>) -> impl Draw<T> {
+    wh_min(w, None, a)
+}
+pub const fn w_exact <T: Screen> (w: T::Unit, c: impl Draw<T>) -> impl Draw<T> {
+    wh_exact(Some(w), None, c)
+}
+/// Shrink drawing area symmetrically.
+///
+/// ```
+/// let padded = tengri::space::w_pad(3, "Hello");
+/// ```
+pub const fn w_pad <T: Screen> (x: T::Unit, draw: impl Draw<T>) -> impl Draw<T> {
+    thunk(move|to: &mut T|draw.draw(todo!()))
+}
+/// Shrink drawing area symmetrically.
+///
+/// ```
+/// let padded = tengri::space::w_pad(3, "Hello");
+/// ```
+pub const fn h_pad <T: Screen> (x: T::Unit, draw: impl Draw<T>) -> impl Draw<T> {
+    thunk(move|to: &mut T|draw.draw(todo!()))
+}
+
+pub const fn xy_push <T: Screen> (x: T::Unit, y: T::Unit, a: impl Draw<T>) -> impl Draw<T> {
+    a
+}
+
+pub const fn xy_pull <T: Screen> (x: T::Unit, y: T::Unit, a: impl Draw<T>) -> impl Draw<T> {
+    a
+}
+
+pub const fn x_push <T: Screen> (x: T::Unit, a: impl Draw<T>) -> impl Draw<T> {
+    a
+}
+pub const fn x_pull <T: Screen> (x: T::Unit, a: impl Draw<T>) -> impl Draw<T> {
+    a
+}
+
+pub const fn y_push <T: Screen> (x: T::Unit, a: impl Draw<T>) -> impl Draw<T> {
+    a
+}
+pub const fn y_pull <T: Screen> (x: T::Unit, a: impl Draw<T>) -> impl Draw<T> {
+    a
+}
+
diff --git a/src/term.rs b/src/term.rs
index cd31156..bf4df07 100644
--- a/src/term.rs
+++ b/src/term.rs
@@ -29,7 +29,27 @@ use ::{
 
 /// Implement standard [main] entrypoint for TUI apps.
 #[macro_export] macro_rules! tui_main {
-    ($state:expr) => { pub fn main () -> Usually<()> { tui_run_main($state) } }
+    ($state:expr) => {
+        pub fn main () -> Usually<()> { tui_run_main($state) }
+    }
+}
+
+/// Enable TUI keyboard input for main state struct.
+#[macro_export] macro_rules! tui_keys {
+    (|$self:ident:$State:ty,$input:ident|$body:block) => {
+        impl Apply<TuiEvent, Usually<()>> for $State {
+            fn apply (&mut $self, $input: &TuiEvent) -> Usually<()> $body
+        }
+    };
+}
+
+/// Enable TUI output for state struct.
+#[macro_export] macro_rules! tui_view {
+    (|$self:ident: $State:ty|$body:block) => {
+        impl View<Tui> for $State {
+            fn view (&$self) -> impl Draw<Tui> $body
+        }
+    }
 }
 
 pub fn tui_run_main <T> (state: Arc<RwLock<T>>) -> Usually<()> where
@@ -63,15 +83,6 @@ pub fn tui_setup_panic () {
     }));
 }
 
-/// Enable TUI keyboard input for main state struct.
-#[macro_export] macro_rules! tui_keys {
-    (|$self:ident:$State:ty,$input:ident|$body:block) => {
-        impl Apply<TuiEvent, Usually<()>> for $State {
-            fn apply (&mut $self, $input: &TuiEvent) -> Usually<()> $body
-        }
-    };
-}
-
 /// Spawn the TUI input and output threadsl.
 pub fn tui_io <
     T: View<Tui> + Apply<TuiEvent, Usually<()>> + Send + Sync + 'static,
@@ -117,15 +128,6 @@ pub fn tui_input <T: Apply<TuiEvent, Usually<()>> + Send + Sync + 'static> (
     })
 }
 
-/// Enable TUI output for state struct.
-#[macro_export] macro_rules! tui_view {
-    (|$self:ident: $State:ty|$body:block) => {
-        impl View<Tui> for $State {
-            fn view (&$self) -> impl Draw<Tui> $body
-        }
-    }
-}
-
 /// Spawn the TUI output thread which writes colored characters to the terminal.
 ///
 /// ```
@@ -192,37 +194,31 @@ impl Tui {
 impl Screen for Tui {
     type Unit = u16;
     /// Render drawable in subarea specified by `area`
-    fn show <'t, T: Draw<Self>> (
-        &mut self, area: XYWH<u16>, content: T
-    ) -> Usually<XYWH<u16>> {
+    fn show <'t, T: Draw<Self>> (&mut self, content: T) -> Perhaps<XYWH<u16>> {
         let previous_area = self.1;
-        self.1 = area;
-        let result_area = content.draw(self);
-        self.1 = previous_area;
-        result_area
-    }
-}
-
-impl Deref for Tui { type Target = Buffer; fn deref (&self) -> &Buffer { &self.0 } }
-
-impl DerefMut for Tui { fn deref_mut (&mut self) -> &mut Buffer { &mut self.0 } }
-
-impl AsMut<Buffer> for Tui {
-    fn as_mut (&mut self) -> &mut Buffer {
-        &mut self.0
+        if let Some(area) = content.layout(self.1)? {
+            self.1 = area;
+            if let Some(result_area) = content.draw(self)? {
+                self.1 = previous_area;
+                result_area
+            } else {
+                Ok(None)
+            }
+        } else {
+            Ok(None)
+        }
     }
 }
 
+impl Deref         for Tui { type Target = Buffer; fn deref (&self) -> &Buffer { &self.0 } }
+impl DerefMut      for Tui { fn deref_mut (&mut self) -> &mut Buffer { &mut self.0 } }
+impl AsMut<Buffer> for Tui { fn as_mut (&mut self) -> &mut Buffer { &mut self.0 } }
+impl Wide<u16> for Tui { fn w (&self) -> u16 { self.1.2 } }
+impl Tall<u16> for Tui { fn h (&self) -> u16 { self.1.3 } }
 impl HasOrigin for Tui { fn origin (&self) -> Origin { Origin::NW } }
-
-impl X<u16> for Tui {
+impl Xy<u16> for Tui {
     fn x (&self) -> u16 { self.1.0 }
-    fn w (&self) -> u16 { self.1.2 }
-}
-
-impl Y<u16> for Tui {
     fn y (&self) -> u16 { self.1.1 }
-    fn h (&self) -> u16 { self.1.3 }
 }
 
 impl Tui {
@@ -520,33 +516,9 @@ pub fn catcher <T: Draw<Tui>> (result: Usually<T>) -> impl Draw<Tui> {
     })
 }
 
-/// TUI buffer sized by `usize` instead of `u16`.
-#[derive(Default)] pub struct BigBuffer {
-    pub width:   usize,
-    pub height:  usize,
-    pub content: Vec<Cell>
-}
-
-impl_from!(BigBuffer: |size:(usize, usize)| Self::new(size.0, size.1));
-
-impl_debug!(BigBuffer |self, f| { write!(f, "[BB {}x{} ({})]", self.width, self.height, self.content.len()) });
-
-impl BigBuffer {
-    pub fn new (width: usize, height: usize) -> Self {
-        Self { width, height, content: vec![Cell::default(); width*height] }
-    }
-    pub fn get (&self, x: usize, y: usize) -> Option<&Cell> {
-        let i = self.index_of(x, y);
-        self.content.get(i)
-    }
-    pub fn get_mut (&mut self, x: usize, y: usize) -> Option<&mut Cell> {
-        let i = self.index_of(x, y);
-        self.content.get_mut(i)
-    }
-    pub fn index_of (&self, x: usize, y: usize) -> usize {
-        y * self.width + x
-    }
-}
+mod event;  pub use self::event::*;
+mod keys;   pub use self::keys::*;
+mod buffer; pub use self::buffer::*;
 
 use self::colors::*; mod colors {
     use ratatui::prelude::Color;
@@ -572,9 +544,3 @@ use self::colors::*; mod colors {
     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) }
 }
-
-#[cfg(feature = "term")] pub mod event;
-#[cfg(feature = "term")] pub use self::event::*;
-
-#[cfg(feature = "term")] pub mod keys;
-#[cfg(feature = "term")] pub use self::keys::*;
diff --git a/src/term/buffer.rs b/src/term/buffer.rs
new file mode 100644
index 0000000..fcd83f1
--- /dev/null
+++ b/src/term/buffer.rs
@@ -0,0 +1,31 @@
+use crate::*;
+use crate::{*, lang::*, draw::*, task::*, exit::*};
+use ::ratatui::buffer::Cell;
+
+/// TUI buffer sized by `usize` instead of `u16`.
+#[derive(Default)] pub struct BigBuffer {
+    pub width:   usize,
+    pub height:  usize,
+    pub content: Vec<Cell>
+}
+
+impl_from!(BigBuffer: |size:(usize, usize)| Self::new(size.0, size.1));
+
+impl_debug!(BigBuffer |self, f| { write!(f, "[BB {}x{} ({})]", self.width, self.height, self.content.len()) });
+
+impl BigBuffer {
+    pub fn new (width: usize, height: usize) -> Self {
+        Self { width, height, content: vec![Cell::default(); width*height] }
+    }
+    pub fn get (&self, x: usize, y: usize) -> Option<&Cell> {
+        let i = self.index_of(x, y);
+        self.content.get(i)
+    }
+    pub fn get_mut (&mut self, x: usize, y: usize) -> Option<&mut Cell> {
+        let i = self.index_of(x, y);
+        self.content.get_mut(i)
+    }
+    pub fn index_of (&self, x: usize, y: usize) -> usize {
+        y * self.width + x
+    }
+}
diff --git a/src/text.rs b/src/text.rs
index 7eb181e..c9c899b 100644
--- a/src/text.rs
+++ b/src/text.rs
@@ -25,6 +25,12 @@ pub(crate) use ::unicode_width::*;
         }
     }
 
+    impl Draw<Tui> for &std::sync::Arc<str> {
+        fn draw (self, to: &mut Tui) -> Usually<XYWH<u16>> {
+            self.as_ref().draw(to)
+        }
+    }
+
     impl<T: AsRef<str>> Draw<Tui> for TrimString<T> {
         fn draw (self, to: &mut Tui) -> Usually<XYWH<u16>> { self.as_ref().draw(to) }
     }

From bf16288884081bc1cf21776fa124b93252dd668b Mon Sep 17 00:00:00 2001
From: facile pop culture reference <donotem@ilme.no>
Date: Mon, 6 Jul 2026 05:35:48 +0300
Subject: [PATCH 21/25] wip: impl_draw, optional drawing

---
 src/draw.rs          |  47 +++++++++--------
 src/eval.rs          |  37 ++++++-------
 src/layout.rs        | 121 +++++++++++++++++++++----------------------
 src/layout/align.rs  |   6 ++-
 src/layout/area.rs   |   6 ++-
 src/layout/origin.rs |  23 --------
 src/space.rs         |   1 +
 src/space/lrtb.rs    |  47 +++++++++++++++++
 src/space/xywh.rs    |  67 ++++++++----------------
 src/term.rs          |   9 +---
 src/term/border.rs   |   4 +-
 src/text.rs          |  74 ++++++++++----------------
 12 files changed, 213 insertions(+), 229 deletions(-)
 delete mode 100644 src/layout/origin.rs
 create mode 100644 src/space/lrtb.rs

diff --git a/src/draw.rs b/src/draw.rs
index 23c55b5..6675132 100644
--- a/src/draw.rs
+++ b/src/draw.rs
@@ -35,11 +35,18 @@ pub trait Screen: Xy<Self::Unit> + Wh<Self::Unit> + Send + Sync + Sized {
 ///     todo!("your draw logic")
 /// });
 /// ```
-#[macro_export] macro_rules! impl_draw ((|
-    $self:ident:$Self:ty, $to:ident:$To:ty
-|$draw:block)=>{ impl Draw<$To> for $Self {
-    fn draw ($self, $to: &mut $To) -> Usually<XYWH<<$To as Screen>::Unit>> $draw
-} });
+#[macro_export] macro_rules! impl_draw (
+    ($(<$($T:ident: $Trait:path,)+>)?|
+        $self:ident:$Self:path, $to:ident:$To:ty
+    |$draw:block)=>{ impl$(<$($T:$Trait),+>)? Draw<$To> for $Self {
+        fn draw ($self, $to: &mut $To) -> Perhaps<XYWH<<$To as Screen>::Unit>> $draw
+    } };
+    ($(<$($T:ident: $Trait:path,)+>)?|
+        $self:ident:$Self:ty, $to:ident:$To:ty
+    |$draw:block)=>{ impl$(<$($T:$Trait),+>)? Draw<$To> for $Self {
+        fn draw ($self, $to: &mut $To) -> Perhaps<XYWH<<$To as Screen>::Unit>> $draw
+    } }
+);
 
 /// Drawable that supports dynamic dispatch.
 ///
@@ -57,38 +64,36 @@ pub trait Screen: Xy<Self::Unit> + Wh<Self::Unit> + Send + Sync + Sized {
 /// use tengri::{*, draw::*, term::*};
 /// struct MyWidget(bool);
 /// impl Draw<Tui> for MyWidget {
-///     fn draw (self, to: &mut Tui) -> Usually<XYWH<u16>> {
+///     fn draw (self, to: &mut Tui) -> Perhaps<XYWH<u16>> {
 ///         todo!("your draw logic")
 ///     }
 /// }
 /// ```
 pub trait Draw<S: Screen> {
-    fn draw (self, to: &mut S) -> Usually<XYWH<S::Unit>>;
+    fn draw (self, to: &mut S) -> Perhaps<XYWH<S::Unit>>;
     fn layout (&self, area: XYWH<S::Unit>) -> Perhaps<XYWH<S::Unit>> {
         Ok(Some(area))
     }
 }
 
 impl<S: Screen> Draw<S> for () {
-    fn draw (self, __: &mut S) -> Usually<XYWH<S::Unit>> {
-        Ok(Default::default())
+    fn draw (self, _: &mut S) -> Perhaps<XYWH<S::Unit>> {
+        Ok(None)
     }
 }
 
-impl<S: Screen, D: Draw<S>> Draw<S> for Option<D> {
-    fn draw (self, to: &mut S) -> Usually<XYWH<S::Unit>> {
-        self.map(|it|it.draw(to)).transpose().map(Option::unwrap_or_default)
-    }
-}
+impl_draw!(<S: Screen, D: Draw<S>,>|self: Option<D>, to: S|{
+    self.map(|it|it.draw(to)).transpose().map(Option::unwrap_or_default)
+});
 
 //impl<S: Screen, D: Draw<S>> Draw<S> for RwLock<D> {
-    //fn draw (self, __: &mut S) -> Usually<XYWH<S::Unit>> {
+    //fn draw (self, __: &mut S) -> Perhaps<XYWH<S::Unit>> {
         //todo!()
     //}
 //}
 
 //impl<T: Screen, D: Draw<T>> Draw<T> for Arc<D> {
-    //fn draw (self, __: &mut T) -> Usually<XYWH<T::Unit>> {
+    //fn draw (self, __: &mut T) -> Perhaps<XYWH<T::Unit>> {
         //todo!()
     //}
 //}
@@ -101,19 +106,19 @@ pub trait View<T: Screen> {
 }
 
 impl<T: Screen, V: View<T>> Draw<T> for &V {
-    fn draw (self, to: &mut T) -> Usually<XYWH<T::Unit>> {
+    fn draw (self, to: &mut T) -> Perhaps<XYWH<T::Unit>> {
         self.view().draw(to)
     }
 }
 
 /// Because we can't implement [Draw] for `F: FnOnce...` without conflicts.
-pub struct Thunk<T: Screen, F: FnOnce(&mut T)->Usually<XYWH<T::Unit>>>(
+pub struct Thunk<T: Screen, F: FnOnce(&mut T)->Perhaps<XYWH<T::Unit>>>(
     pub F,
     std::marker::PhantomData<T>
 );
 
-impl<T: Screen, F: FnOnce(&mut T)->Usually<XYWH<T::Unit>>> Draw<T> for Thunk<T, F> {
-    fn draw (self, to: &mut T) -> Usually<XYWH<T::Unit>> {
+impl<T: Screen, F: FnOnce(&mut T)->Perhaps<XYWH<T::Unit>>> Draw<T> for Thunk<T, F> {
+    fn draw (self, to: &mut T) -> Perhaps<XYWH<T::Unit>> {
         (self.0)(to)
     }
 }
@@ -126,7 +131,7 @@ impl<T: Screen, F: FnOnce(&mut T)->Usually<XYWH<T::Unit>>> Draw<T> for Thunk<T,
 ///     thunk(|to: &mut Tui|Ok(to.1))
 /// # }
 /// ```
-pub const fn thunk <T: Screen, F: FnOnce(&mut T)->Usually<XYWH<T::Unit>>> (
+pub const fn thunk <T: Screen, F: FnOnce(&mut T)->Perhaps<XYWH<T::Unit>>> (
     draw: F
 ) -> Thunk<T, F> {
     Thunk(draw, std::marker::PhantomData)
diff --git a/src/eval.rs b/src/eval.rs
index 2da55fd..63c579c 100644
--- a/src/eval.rs
+++ b/src/eval.rs
@@ -114,22 +114,23 @@ pub fn eval_view <'a, O: Screen + 'a, S> (
         ).draw(output),
 
         // Second `frags.next()` calls returns the namespace member.
-        Some("bsp") => eval_enum!(
-            "bsp", output, state, frags.next(), arg0, Split {
+        Some("bsp") => {
+            let direction = eval_enum!("bsp", output, state, frags.next(), arg0, Split {
                 "n" => North, "s" => South, "e" => East, "w" => West, "a" => Above, "b" => Below
-            }
-        ).half(
-            thunk(move|output: &mut O|state.interpret(output, &arg0)),
-            thunk(move|output: &mut O|state.interpret(output, &arg1)),
-        ).draw(output),
+            });
+            direction.half(
+                thunk(move|output: &mut O|state.interpret(output, &arg0)),
+                thunk(move|output: &mut O|state.interpret(output, &arg1)),
+            ).draw(output)
+        },
 
-        Some("align") => eval_enum!(
-            "align", output, state, frags.next(), arg0, Origin {
+        Some("align") => {
+            let alignment = eval_enum!("align", output, state, frags.next(), arg0, Origin {
                 "c" => C, "n" => N, "s" => S, "e" => E, "w" => W, "x" => X, "y" => Y
-            }
-        ).align(
-            thunk(move|output: &mut O|state.interpret(output, &arg0))
-        ).draw(output),
+            });
+            let content = thunk(move|output: &mut O|state.interpret(output, &arg0));
+            align(alignment, content).draw(output)
+        },
 
         Some("exact") => eval_xy!(
             "exact", expr, head, output, state, frags.next(),
@@ -191,11 +192,11 @@ pub fn eval_view_tui <'a, S> (
     let arg0  = args.head();
     let tail0 = args.tail();
     let arg1  = tail0.head();
-    Ok(Some(match frags.next() {
+    match frags.next() {
 
         Some("text") => {
             if let Some(src) = args?.src()? {
-                output.show(src)?
+                output.show(src)
             } else {
                 return Ok(None)
             }
@@ -208,7 +209,7 @@ pub fn eval_view_tui <'a, S> (
                 state.interpret(output, &arg1)?;
                 // FIXME?: don't max out the used area?
                 Ok(output.area().into())
-            })))?
+            })))
         },
 
         Some("bg") => {
@@ -218,10 +219,10 @@ pub fn eval_view_tui <'a, S> (
                 state.interpret(output, &arg1)?;
                 // FIXME?: don't max out the used area?
                 Ok(output.area().into())
-            })))?
+            })))
         },
 
         _ => return Ok(None)
 
-    }))
+    }
 }
diff --git a/src/layout.rs b/src/layout.rs
index 5fa4660..3f0173f 100644
--- a/src/layout.rs
+++ b/src/layout.rs
@@ -2,7 +2,6 @@ use crate::*;
 
 mod align; pub use self::align::*;
 mod area; pub use self::area::*;
-mod origin; pub use self::origin::*;
 mod split; pub use self::split::*;
 
 pub enum Layout<T: Screen, X: Into<Option<T::Unit>>, I: Draw<T>> {
@@ -21,67 +20,65 @@ pub enum Layout<T: Screen, X: Into<Option<T::Unit>>, I: Draw<T>> {
     ClipWH(X, X, I),
 }
 
-impl<
+impl_draw!(<
     T: Screen,
     X: Into<Option<T::Unit>>,
-    I: Draw<T>
-> Draw<T> for Layout<T, X, I> {
-    fn draw (self, to: &mut T) -> Usually<XYWH<T::Unit>> {
-        use Layout::*;
-        match self {
-            __(_) => unreachable!(),
-            MinW(x, it) => {
-                let x = x.into();
-                it.draw(to)
-            },
-            MinH(y, it) => {
-                let y = y.into();
-                it.draw(to)
-            },
-            MinWH(x, y, it) => {
-                let x = x.into();
-                let y = y.into();
-                it.draw(to)
-            },
-            MaxW(x, it) => {
-                let x = x.into();
-                it.draw(to)
-            },
-            MaxH(y, it) => {
-                let y = y.into();
-                it.draw(to)
-            },
-            MaxWH(x, y, it) => {
-                let x = x.into();
-                let y = y.into();
-                it.draw(to)
-            },
-            ExactW(x, it) => {
-                let x = x.into();
-                it.draw(to)
-            },
-            ExactH(y, it) => {
-                let y = y.into();
-                it.draw(to)
-            },
-            ExactWH(x, y, it) => {
-                let x = x.into();
-                let y = y.into();
-                it.draw(to)
-            },
-            ClipW(x, it) => {
-                let x = x.into();
-                it.draw(to)
-            },
-            ClipH(y, it) => {
-                let y = y.into();
-                it.draw(to)
-            },
-            ClipWH(x, y, it) => {
-                let x = x.into();
-                let y = y.into();
-                it.draw(to)
-            },
-        }
+    I: Draw<T>,
+>|self: Layout<T, X, I>, to: T|{
+    use Layout::*;
+    match self {
+        __(_) => unreachable!(),
+        MinW(x, it) => {
+            let x = x.into();
+            it.draw(to)
+        },
+        MinH(y, it) => {
+            let y = y.into();
+            it.draw(to)
+        },
+        MinWH(x, y, it) => {
+            let x = x.into();
+            let y = y.into();
+            it.draw(to)
+        },
+        MaxW(x, it) => {
+            let x = x.into();
+            it.draw(to)
+        },
+        MaxH(y, it) => {
+            let y = y.into();
+            it.draw(to)
+        },
+        MaxWH(x, y, it) => {
+            let x = x.into();
+            let y = y.into();
+            it.draw(to)
+        },
+        ExactW(x, it) => {
+            let x = x.into();
+            it.draw(to)
+        },
+        ExactH(y, it) => {
+            let y = y.into();
+            it.draw(to)
+        },
+        ExactWH(x, y, it) => {
+            let x = x.into();
+            let y = y.into();
+            it.draw(to)
+        },
+        ClipW(x, it) => {
+            let x = x.into();
+            it.draw(to)
+        },
+        ClipH(y, it) => {
+            let y = y.into();
+            it.draw(to)
+        },
+        ClipWH(x, y, it) => {
+            let x = x.into();
+            let y = y.into();
+            it.draw(to)
+        },
     }
-}
+});
diff --git a/src/layout/align.rs b/src/layout/align.rs
index eac9e76..74af5c6 100644
--- a/src/layout/align.rs
+++ b/src/layout/align.rs
@@ -1,7 +1,5 @@
 use crate::*;
 
-pub struct Align<T>(Option<Origin>, T);
-
 /// ```
 /// use tengri::*;
 /// let _ = align(None, "unaligned");
@@ -11,3 +9,7 @@ pub struct Align<T>(Option<Origin>, T);
 pub fn align <S: Screen, T: Draw<S>, U: Into<Option<Origin>>> (origin: U, it: T) -> Align<T> {
     Align(origin.into(), it)
 }
+
+pub struct Align<T>(Option<Origin>, T);
+
+impl_draw!(<S: Screen, T: Draw<S>,>|self: Align<T>, to: S|{ todo!() });
diff --git a/src/layout/area.rs b/src/layout/area.rs
index eb71215..58e8b6c 100644
--- a/src/layout/area.rs
+++ b/src/layout/area.rs
@@ -1,7 +1,5 @@
 use crate::*;
 
-pub struct Area<S: Screen, T: Draw<S>>(Option<XYWH<S::Unit>>, T);
-
 /// ```
 /// use tengri::*;
 /// let _ = area(None, "unareaed");
@@ -13,3 +11,7 @@ pub fn area <S: Screen, T: Draw<S>, U: Into<Option<XYWH<S::Unit>>>> (
 ) -> Area<S, T> {
     Area(origin.into(), it)
 }
+
+pub struct Area<S: Screen, T: Draw<S>>(Option<XYWH<S::Unit>>, T);
+
+impl_draw!(<S: Screen, T: Draw<S>,>|self: Area<S, T>, to: S|{ todo!() });
diff --git a/src/layout/origin.rs b/src/layout/origin.rs
deleted file mode 100644
index 8b8b85e..0000000
--- a/src/layout/origin.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-use super::*;
-
-/// 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
-}
-
-/// 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()
-    }
-}
diff --git a/src/space.rs b/src/space.rs
index 8be15b4..985dd15 100644
--- a/src/space.rs
+++ b/src/space.rs
@@ -5,3 +5,4 @@ mod coord;  pub use self::coord::*;
 mod iter;   pub use self::iter::*;
 mod sizer;  pub use self::sizer::*;
 mod xywh;   pub use self::xywh::*;
+mod lrtb;   pub use self::lrtb::*;
diff --git a/src/space/lrtb.rs b/src/space/lrtb.rs
new file mode 100644
index 0000000..a905e89
--- /dev/null
+++ b/src/space/lrtb.rs
@@ -0,0 +1,47 @@
+use crate::*;
+use Origin::*;
+
+impl<N: Coord, T: Xywh<N>> Lrtb<N> for T {}
+
+pub trait Lrtb<N: Coord>: Xywh<N> {
+    fn lrtb (&self) -> [N;4] {
+        // FIXME: factor origin
+        [self.x(), self.y(), self.x()+self.w(), self.y()+self.h()]
+    }
+    fn iter_x (&self) -> impl Iterator<Item = N> where Self: HasOrigin {
+        self.x_west()..self.x_east()
+    }
+    fn x_west (&self) -> N where Self: HasOrigin {
+        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: HasOrigin {
+        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: HasOrigin {
+        todo!()
+    }
+    fn iter_y (&self) -> impl Iterator<Item = N> where Self: HasOrigin {
+        self.y_north()..self.y_south()
+    }
+    fn y_north (&self) -> N where Self: HasOrigin {
+        let a = self.origin();
+        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_south (&self) -> N where Self: HasOrigin  {
+        let a = self.origin();
+        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)
+    }
+    fn y_center (&self) -> N where Self: HasOrigin {
+        todo!()
+    }
+}
diff --git a/src/space/xywh.rs b/src/space/xywh.rs
index 518b314..fa2cc8c 100644
--- a/src/space/xywh.rs
+++ b/src/space/xywh.rs
@@ -2,6 +2,28 @@ use super::*;
 use Origin::*;
 use Split::*;
 
+/// 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
+}
+
+/// 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()
+    }
+}
+
 pub trait Xy<N: Coord> {
     fn x (&self) -> N;
     fn y (&self) -> N;
@@ -17,59 +39,16 @@ pub trait Xywh<N: Coord>: Xy<N> + Wh<N> {
     }
 }
 
-pub trait Lrtb<N: Coord> {
-    // FIXME: factor origin
-    fn lrtb (&self) -> [N;4] {
-        [self.x(), self.y(), self.x()+self.w(), self.y()+self.h()]
-    }
-}
-
-pub trait Wide<N: Coord> {
+pub trait Wide<N: Coord>: Xy<N> {
     fn w (&self) -> N { N::zero() }
     fn w_min (&self) -> N { self.w() }
     fn w_max (&self) -> N { self.w() }
-    fn iter_x (&self) -> impl Iterator<Item = N> where Self: HasOrigin {
-        self.x_west()..self.x_east()
-    }
-    fn x_west (&self) -> N where Self: HasOrigin {
-        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: HasOrigin {
-        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: HasOrigin {
-        todo!()
-    }
 }
 
 pub trait Tall<N: Coord> {
     fn h (&self) -> N { N::zero() }
     fn h_min (&self) -> N { self.h() }
     fn h_max (&self) -> N { self.h() }
-    fn iter_y (&self) -> impl Iterator<Item = N> where Self: HasOrigin {
-        self.y_north()..self.y_south()
-    }
-    fn y_north (&self) -> N where Self: HasOrigin {
-        let a = self.origin();
-        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_south (&self) -> N where Self: HasOrigin  {
-        let a = self.origin();
-        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)
-    }
-    fn y_center (&self) -> N where Self: HasOrigin {
-        todo!()
-    }
 }
 
 /// Point with size.
diff --git a/src/term.rs b/src/term.rs
index bf4df07..7571155 100644
--- a/src/term.rs
+++ b/src/term.rs
@@ -325,13 +325,8 @@ impl Coord for u16 {
     }
 }
 
-impl Draw<Tui> for u64 {
-    fn draw (self, _to: &mut Tui) -> Usually<XYWH<u16>> { todo!() }
-}
-
-impl Draw<Tui> for f64 {
-    fn draw (self, _to: &mut Tui) -> Usually<XYWH<u16>> { todo!() }
-}
+impl_draw!(|self: u64, _to: Tui|{ todo!() });
+impl_draw!(|self: f64, _to: Tui|{ todo!() });
 
 mod phat {
     use super::*;
diff --git a/src/term/border.rs b/src/term/border.rs
index 9a30995..837445a 100644
--- a/src/term/border.rs
+++ b/src/term/border.rs
@@ -23,7 +23,7 @@ pub const fn border (on: bool, style: impl BorderStyle, draw: impl Draw<Tui>) ->
                 to.blit(&style.border_e(), x + w - 1, y, style.style());
             }
         }
-        Ok(XYWH(x, y, w, h))
+        Ok(Some(XYWH(x, y, w, h)))
     }));
     above(outline, content)
 }
@@ -48,7 +48,7 @@ macro_rules! border {
         #[derive(Copy, Clone)] pub struct $T(pub bool, pub Style);
         //impl Layout<Tui> for $T {}
         impl Draw<Tui> for $T {
-            fn draw (self, to: &mut Tui) -> Usually<XYWH<u16>> {
+            fn draw (self, to: &mut Tui) -> Perhaps<XYWH<u16>> {
                 when(self.enabled(), thunk(|to: &mut Tui|BorderStyle::draw(self, to))).draw(to)
             }
         }
diff --git a/src/text.rs b/src/text.rs
index c9c899b..e79ae55 100644
--- a/src/text.rs
+++ b/src/text.rs
@@ -3,63 +3,41 @@ pub(crate) use ::unicode_width::*;
 
 #[cfg(feature = "term")] mod impl_term {
     use super::*;
-    use crate::term::Tui;
+    use crate::*;
     use ratatui::prelude::Position;
 
-    impl Draw<Tui> for &str {
-        fn draw (self, to: &mut Tui) -> Usually<XYWH<u16>> {
-            let XYWH(x, y, w, ..) = to.1.centered_xy([width_chars_max(to.w(), self), 1]);
-            to.text(&self, x, y, w)
-        }
-    }
+    impl_draw!(|self: String, to: Tui|{self.as_str().draw(to)});
+    impl_draw!(|self: std::sync::Arc<str>, to: Tui|{self.as_ref().draw(to)});
+    impl_draw!(|self: &std::sync::Arc<str>, to: Tui|{self.as_ref().draw(to)});
+    impl_draw!(|self: &str, to: Tui|{
+        let XYWH(x, y, w, ..) = to.1.centered_xy([width_chars_max(to.w(), self), 1]);
+        to.text(&self, x, y, w)
+    });
 
-    impl Draw<Tui> for String {
-        fn draw (self, to: &mut Tui) -> Usually<XYWH<u16>> {
-            self.as_str().draw(to)
-        }
-    }
-
-    impl Draw<Tui> for std::sync::Arc<str> {
-        fn draw (self, to: &mut Tui) -> Usually<XYWH<u16>> {
-            self.as_ref().draw(to)
-        }
-    }
-
-    impl Draw<Tui> for &std::sync::Arc<str> {
-        fn draw (self, to: &mut Tui) -> Usually<XYWH<u16>> {
-            self.as_ref().draw(to)
-        }
-    }
-
-    impl<T: AsRef<str>> Draw<Tui> for TrimString<T> {
-        fn draw (self, to: &mut Tui) -> Usually<XYWH<u16>> { self.as_ref().draw(to) }
-    }
-
-    impl<T: AsRef<str>> Draw<Tui> for TrimStringRef<'_, T> {
-        fn draw (self, to: &mut Tui) -> Usually<XYWH<u16>> {
-            let XYWH(x, y, w, ..) = to.1;
-            let mut width: u16 = 1;
-            let mut chars = self.1.as_ref().chars();
-            while let Some(c) = chars.next() {
-                if width > self.0 || width > w {
-                    break
-                }
-                let pos = Position { x: x + width - 1, y };
-                if let Some(cell) = to.0.cell_mut(pos) {
-                    cell.set_char(c);
-                }
-                width += c.width().unwrap_or(0) as u16;
+    impl_draw!(<T: AsRef<str>,>|self: TrimString<T>, to: Tui|{self.as_ref().draw(to)});
+    impl_draw!(<T: AsRef<str>,>|self: TrimStringRef<'_, T>, to: Tui|{
+        let XYWH(x, y, w, ..) = to.1;
+        let mut width: u16 = 1;
+        let mut chars = self.1.as_ref().chars();
+        while let Some(c) = chars.next() {
+            if width > self.0 || width > w {
+                break
             }
-            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.as_ref(), x, y, w)
+            let pos = Position { x: x + width - 1, y };
+            if let Some(cell) = to.0.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.as_ref(), x, y, w)
+    });
 
     impl Tui {
         /// Write a line of text
         ///
         /// TODO: do a paragraph (handle newlines)
-        pub fn text (&mut self, text: &impl AsRef<str>, x0: u16, y: u16, max_width: u16) -> Usually<XYWH<u16>> {
+        pub fn text (&mut self, text: &impl AsRef<str>, x0: u16, y: u16, max_width: u16) -> Perhaps<XYWH<u16>> {
             let text = text.as_ref();
             let mut string_width: u16 = 0;
             for character in text.chars() {
@@ -75,7 +53,7 @@ pub(crate) use ::unicode_width::*;
                     break
                 }
             }
-            Ok(XYWH(x0, y, string_width, 1))
+            Ok(Some(XYWH(x0, y, string_width, 1)))
         }
     }
 }

From 1f60b43f616ff49ddd8187bcca8d31e9b6597cec Mon Sep 17 00:00:00 2001
From: facile pop culture reference <donotem@ilme.no>
Date: Mon, 6 Jul 2026 20:40:52 +0300
Subject: [PATCH 22/25] reorganize, add Azimuth

---
 dizzle                        |   2 +-
 src/draw.rs                   |  76 ++---
 src/draw/align.rs             |  31 ++
 src/{layout => draw}/area.rs  |   0
 src/draw/azimuth.rs           |  12 +
 src/{ => draw}/color.rs       |   7 +
 src/{space => draw}/coord.rs  |   0
 src/{space => draw}/iter.rs   |   0
 src/{ => draw}/layout.rs      |   4 -
 src/{space => draw}/lrtb.rs   |   2 +-
 src/draw/origin.rs            |  42 +++
 src/{space => draw}/sizer.rs  |   4 +-
 src/draw/space.rs             |   2 +
 src/{layout => draw}/split.rs |   7 +-
 src/draw/thunk.rs             |  48 +++
 src/{space => draw}/xywh.rs   |  24 --
 src/eval.rs                   |  56 +++-
 src/layout/align.rs           |  15 -
 src/lib.rs                    |   5 +-
 src/origin.rs                 |   0
 src/space.rs                  |   8 -
 src/term.rs                   | 540 +++++-----------------------------
 src/term/border.rs            |   2 +-
 src/term/input.rs             |  39 +++
 src/term/output.rs            | 343 +++++++++++++++++++++
 src/text.rs                   |   2 +-
 26 files changed, 677 insertions(+), 594 deletions(-)
 create mode 100644 src/draw/align.rs
 rename src/{layout => draw}/area.rs (100%)
 create mode 100644 src/draw/azimuth.rs
 rename src/{ => draw}/color.rs (99%)
 rename src/{space => draw}/coord.rs (100%)
 rename src/{space => draw}/iter.rs (100%)
 rename src/{ => draw}/layout.rs (94%)
 rename src/{space => draw}/lrtb.rs (98%)
 create mode 100644 src/draw/origin.rs
 rename src/{space => draw}/sizer.rs (82%)
 create mode 100644 src/draw/space.rs
 rename src/{layout => draw}/split.rs (95%)
 create mode 100644 src/draw/thunk.rs
 rename src/{space => draw}/xywh.rs (93%)
 delete mode 100644 src/layout/align.rs
 create mode 100644 src/origin.rs
 delete mode 100644 src/space.rs
 create mode 100644 src/term/input.rs
 create mode 100644 src/term/output.rs

diff --git a/dizzle b/dizzle
index f8e310b..af2a107 160000
--- a/dizzle
+++ b/dizzle
@@ -1 +1 @@
-Subproject commit f8e310b477afc1aab4701fdc52da474143d78a28
+Subproject commit af2a10751f87caef8e5526d1f692c941b8de8357
diff --git a/src/draw.rs b/src/draw.rs
index 6675132..c5e895a 100644
--- a/src/draw.rs
+++ b/src/draw.rs
@@ -1,5 +1,4 @@
 use crate::*;
-pub use crate::space::*;
 
 /// Output target.
 ///
@@ -70,14 +69,16 @@ pub trait Screen: Xy<Self::Unit> + Wh<Self::Unit> + Send + Sync + Sized {
 /// }
 /// ```
 pub trait Draw<S: Screen> {
-    fn draw (self, to: &mut S) -> Perhaps<XYWH<S::Unit>>;
-    fn layout (&self, area: XYWH<S::Unit>) -> Perhaps<XYWH<S::Unit>> {
+    fn draw (self, to: &mut S) -> Drawn<S::Unit>;
+    fn layout (&self, area: XYWH<S::Unit>) -> Drawn<S::Unit> {
         Ok(Some(area))
     }
 }
 
+pub type Drawn<U> = Perhaps<XYWH<U>>;
+
 impl<S: Screen> Draw<S> for () {
-    fn draw (self, _: &mut S) -> Perhaps<XYWH<S::Unit>> {
+    fn draw (self, _: &mut S) -> Drawn<S::Unit> {
         Ok(None)
     }
 }
@@ -87,7 +88,7 @@ impl_draw!(<S: Screen, D: Draw<S>,>|self: Option<D>, to: S|{
 });
 
 //impl<S: Screen, D: Draw<S>> Draw<S> for RwLock<D> {
-    //fn draw (self, __: &mut S) -> Perhaps<XYWH<S::Unit>> {
+    //fn draw (self, __: &mut S) -> Drawn<S::Unit> {
         //todo!()
     //}
 //}
@@ -111,52 +112,21 @@ impl<T: Screen, V: View<T>> Draw<T> for &V {
     }
 }
 
-/// Because we can't implement [Draw] for `F: FnOnce...` without conflicts.
-pub struct Thunk<T: Screen, F: FnOnce(&mut T)->Perhaps<XYWH<T::Unit>>>(
-    pub F,
-    std::marker::PhantomData<T>
-);
-
-impl<T: Screen, F: FnOnce(&mut T)->Perhaps<XYWH<T::Unit>>> Draw<T> for Thunk<T, F> {
-    fn draw (self, to: &mut T) -> Perhaps<XYWH<T::Unit>> {
-        (self.0)(to)
-    }
-}
-
-/// Basic [Draw]able closure.
-///
-/// ```
-/// # use tengri::{draw::*, term::*};
-/// # fn test () -> impl tengri::draw::Draw<tengri::term::Tui> {
-///     thunk(|to: &mut Tui|Ok(to.1))
-/// # }
-/// ```
-pub const fn thunk <T: Screen, F: FnOnce(&mut T)->Perhaps<XYWH<T::Unit>>> (
-    draw: F
-) -> Thunk<T, F> {
-    Thunk(draw, std::marker::PhantomData)
-}
-
-/// Only render when condition is true.
-///
-/// ```
-/// # use tengri::{draw::*, term::*};
-/// # fn test () -> impl tengri::draw::Draw<tengri::term::Tui> {
-///     when(true, "Yes")
-/// # }
-/// ```
-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.
-///
-/// ```
-/// # use tengri::{draw::*, term::*};
-/// # fn test () -> impl tengri::draw::Draw<tengri::term::Tui> {
-///     either(true, "Yes", "No")
-/// # }
-/// ```
-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) })
+features! {
+    "draw": [
+        align,
+        area,
+        azimuth,
+        color,
+        coord,
+        iter,
+        layout,
+        lrtb,
+        origin,
+        sizer,
+        space,
+        split,
+        thunk,
+        xywh
+    ]
 }
diff --git a/src/draw/align.rs b/src/draw/align.rs
new file mode 100644
index 0000000..8e4ebb1
--- /dev/null
+++ b/src/draw/align.rs
@@ -0,0 +1,31 @@
+use crate::*;
+
+pub struct Align<T>(Option<Azimuth>, T);
+
+impl_draw!(<S: Screen, T: Draw<S>,>|self: Align<T>, to: S|{
+    todo!()
+});
+
+/// ```
+/// use tengri::*;
+/// let _ = align(None, "unaligned");
+/// let _ = align(Azimuth::SE, "southeast");
+/// let _ = align(Some(Azimuth::SE), "southeast");
+/// ```
+pub fn align <S: Screen, T: Draw<S>, U: Into<Option<Azimuth>>> (origin: U, it: T) -> Align<T> {
+    Align(origin.into(), it)
+}
+
+pub fn align_c <S: Screen, T: Draw<S>> (it: T) -> Align<T> { Align(Some(Azimuth::C), it) }
+pub fn align_x <S: Screen, T: Draw<S>> (it: T) -> Align<T> { Align(Some(Azimuth::X), it) }
+pub fn align_y <S: Screen, T: Draw<S>> (it: T) -> Align<T> { Align(Some(Azimuth::Y), it) }
+
+pub fn align_n <S: Screen, T: Draw<S>> (it: T) -> Align<T> { Align(Some(Azimuth::N), it) }
+pub fn align_s <S: Screen, T: Draw<S>> (it: T) -> Align<T> { Align(Some(Azimuth::S), it) }
+pub fn align_e <S: Screen, T: Draw<S>> (it: T) -> Align<T> { Align(Some(Azimuth::E), it) }
+pub fn align_w <S: Screen, T: Draw<S>> (it: T) -> Align<T> { Align(Some(Azimuth::W), it) }
+
+pub fn align_ne <S: Screen, T: Draw<S>> (it: T) -> Align<T> { Align(Some(Azimuth::NE), it) }
+pub fn align_se <S: Screen, T: Draw<S>> (it: T) -> Align<T> { Align(Some(Azimuth::SE), it) }
+pub fn align_nw <S: Screen, T: Draw<S>> (it: T) -> Align<T> { Align(Some(Azimuth::NW), it) }
+pub fn align_sw <S: Screen, T: Draw<S>> (it: T) -> Align<T> { Align(Some(Azimuth::SW), it) }
diff --git a/src/layout/area.rs b/src/draw/area.rs
similarity index 100%
rename from src/layout/area.rs
rename to src/draw/area.rs
diff --git a/src/draw/azimuth.rs b/src/draw/azimuth.rs
new file mode 100644
index 0000000..de72abc
--- /dev/null
+++ b/src/draw/azimuth.rs
@@ -0,0 +1,12 @@
+use crate::*;
+
+/// Where is [0, 0] located?
+///
+/// ```
+/// use tengri::draw::Azimuth;
+/// let _ = Azimuth::NW.align(());
+/// ```
+#[cfg_attr(test, derive(Arbitrary))]
+#[derive(Debug, Copy, Clone, Default)] pub enum Azimuth {
+    #[default] C, X, Y, NW, N, NE, E, SE, S, SW, W
+}
diff --git a/src/color.rs b/src/draw/color.rs
similarity index 99%
rename from src/color.rs
rename to src/draw/color.rs
index 82bdc70..ccea5e6 100644
--- a/src/color.rs
+++ b/src/draw/color.rs
@@ -29,6 +29,7 @@ pub fn rgb_to_okhsl (color: Color) -> Okhsl<f32> {
 }
 
 pub trait HasColor { fn color (&self) -> ItemColor; }
+
 #[macro_export] macro_rules! has_color {
     (|$self:ident:$Struct:ident$(<$($L:lifetime),*$($T:ident$(:$U:path)?),*>)?|$cb:expr) => {
         impl $(<$($L),*$($T $(: $U)?),*>)? HasColor for $Struct $(<$($L),*$($T),*>)? {
@@ -42,8 +43,11 @@ pub struct ItemColor {
     pub term: Color,
     pub okhsl: Okhsl<f32>
 }
+
 impl_from!(ItemColor: |term: Color|       Self { term, okhsl: rgb_to_okhsl(term)  });
+
 impl_from!(ItemColor: |okhsl: Okhsl<f32>| Self { okhsl, term: okhsl_to_rgb(okhsl) });
+
 // A single color within item theme parameters, in OKHSL and RGB representations.
 impl ItemColor {
     #[cfg(feature = "term")] pub const fn from_tui (term: Color) -> Self {
@@ -80,8 +84,11 @@ pub struct ItemTheme {
     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 {
     #[cfg(feature = "term")] pub const G: [Self;256] = {
         let mut builder = dizzle::konst::array::ArrayBuilder::new();
diff --git a/src/space/coord.rs b/src/draw/coord.rs
similarity index 100%
rename from src/space/coord.rs
rename to src/draw/coord.rs
diff --git a/src/space/iter.rs b/src/draw/iter.rs
similarity index 100%
rename from src/space/iter.rs
rename to src/draw/iter.rs
diff --git a/src/layout.rs b/src/draw/layout.rs
similarity index 94%
rename from src/layout.rs
rename to src/draw/layout.rs
index 3f0173f..5db0b5b 100644
--- a/src/layout.rs
+++ b/src/draw/layout.rs
@@ -1,9 +1,5 @@
 use crate::*;
 
-mod align; pub use self::align::*;
-mod area; pub use self::area::*;
-mod split; pub use self::split::*;
-
 pub enum Layout<T: Screen, X: Into<Option<T::Unit>>, I: Draw<T>> {
     __(PhantomData<T>),
     MinW(X, I),
diff --git a/src/space/lrtb.rs b/src/draw/lrtb.rs
similarity index 98%
rename from src/space/lrtb.rs
rename to src/draw/lrtb.rs
index a905e89..7f8b182 100644
--- a/src/space/lrtb.rs
+++ b/src/draw/lrtb.rs
@@ -1,5 +1,5 @@
 use crate::*;
-use Origin::*;
+use Azimuth::*;
 
 impl<N: Coord, T: Xywh<N>> Lrtb<N> for T {}
 
diff --git a/src/draw/origin.rs b/src/draw/origin.rs
new file mode 100644
index 0000000..da47996
--- /dev/null
+++ b/src/draw/origin.rs
@@ -0,0 +1,42 @@
+use crate::*;
+
+pub struct Origin<T>(Option<Azimuth>, T);
+
+impl_draw!(<S: Screen, T: Draw<S>,>|self: Origin<T>, to: S|{
+    todo!()
+});
+
+/// ```
+/// use tengri::*;
+/// let _ = origin(None, "origin unspecified");
+/// let _ = origin(Azimuth::SE, "southeast");
+/// let _ = origin(Some(Azimuth::SE), "southeast");
+/// ```
+pub fn origin <S: Screen, T: Draw<S>, U: Into<Option<Azimuth>>> (origin: U, it: T) -> Origin<T> {
+    Origin(origin.into(), it)
+}
+
+pub fn origin_c <S: Screen, T: Draw<S>> (it: T) -> Origin<T> { Origin(Some(Azimuth::C), it) }
+pub fn origin_x <S: Screen, T: Draw<S>> (it: T) -> Origin<T> { Origin(Some(Azimuth::X), it) }
+pub fn origin_y <S: Screen, T: Draw<S>> (it: T) -> Origin<T> { Origin(Some(Azimuth::Y), it) }
+
+pub fn origin_n <S: Screen, T: Draw<S>> (it: T) -> Origin<T> { Origin(Some(Azimuth::N), it) }
+pub fn origin_s <S: Screen, T: Draw<S>> (it: T) -> Origin<T> { Origin(Some(Azimuth::S), it) }
+pub fn origin_e <S: Screen, T: Draw<S>> (it: T) -> Origin<T> { Origin(Some(Azimuth::E), it) }
+pub fn origin_w <S: Screen, T: Draw<S>> (it: T) -> Origin<T> { Origin(Some(Azimuth::W), it) }
+
+pub fn origin_ne <S: Screen, T: Draw<S>> (it: T) -> Origin<T> { Origin(Some(Azimuth::NE), it) }
+pub fn origin_se <S: Screen, T: Draw<S>> (it: T) -> Origin<T> { Origin(Some(Azimuth::SE), it) }
+pub fn origin_nw <S: Screen, T: Draw<S>> (it: T) -> Origin<T> { Origin(Some(Azimuth::NW), it) }
+pub fn origin_sw <S: Screen, T: Draw<S>> (it: T) -> Origin<T> { Origin(Some(Azimuth::SW), it) }
+
+/// Something that has `[0, 0]` at a particular point.
+pub trait HasOrigin {
+    fn origin (&self) -> Azimuth;
+}
+
+impl<T: AsRef<Azimuth>> HasOrigin for T {
+    fn origin (&self) -> Azimuth {
+        *self.as_ref()
+    }
+}
diff --git a/src/space/sizer.rs b/src/draw/sizer.rs
similarity index 82%
rename from src/space/sizer.rs
rename to src/draw/sizer.rs
index 90d09bf..7ff5ed5 100644
--- a/src/space/sizer.rs
+++ b/src/draw/sizer.rs
@@ -23,8 +23,8 @@ impl Sizer {
     pub const fn of <T: Screen> (&self, of: impl Draw<T>) -> impl Draw<T> {
         thunk(move|to: &mut T|{
             let area = of.draw(to)?;
-            self.0.store(area.w().into(), Relaxed);
-            self.1.store(area.h().into(), Relaxed);
+            self.0.store(area.map(|a|a.w()).unwrap_or(T::Unit::zero()).into(), Relaxed);
+            self.1.store(area.map(|a|a.h()).unwrap_or(T::Unit::zero()).into(), Relaxed);
             Ok(area)
         })
     }
diff --git a/src/draw/space.rs b/src/draw/space.rs
new file mode 100644
index 0000000..6576b44
--- /dev/null
+++ b/src/draw/space.rs
@@ -0,0 +1,2 @@
+use crate::*;
+
diff --git a/src/layout/split.rs b/src/draw/split.rs
similarity index 95%
rename from src/layout/split.rs
rename to src/draw/split.rs
index 2c9bd62..3d64a75 100644
--- a/src/layout/split.rs
+++ b/src/draw/split.rs
@@ -1,4 +1,5 @@
 use super::*;
+use Azimuth::*;
 
 pub const fn east <T: Screen> (a: impl Draw<T>, b: impl Draw<T>) -> impl Draw<T> {
     Split::East.half(a, b)
@@ -62,7 +63,7 @@ impl Split {
                     to.show(area(area_b, b))?;
                 }
             }
-            Ok(to.xywh()) // FIXME: compute and return actually used area
+            Ok(Some(to.xywh())) // FIXME: compute and return actually used area
         })
     }
 
@@ -82,8 +83,8 @@ impl Split {
     ///
     /// */
     /// ```
-    const fn origins (&self) -> (Origin, Origin) {
-        use Origin::*;
+    const fn origins (&self) -> (Azimuth, Azimuth) {
+        use Azimuth::*;
         match self {
             Self::South => (S, N),
             Self::East  => (E, W),
diff --git a/src/draw/thunk.rs b/src/draw/thunk.rs
new file mode 100644
index 0000000..7e98b20
--- /dev/null
+++ b/src/draw/thunk.rs
@@ -0,0 +1,48 @@
+use crate::*;
+
+/// Because we can't implement [Draw] for `F: FnOnce...` without conflicts.
+pub struct Thunk<T: Screen, F>(pub F, std::marker::PhantomData<T>);
+
+impl<T: Screen, F: FnOnce(&mut T)->Perhaps<XYWH<T::Unit>>> Draw<T> for Thunk<T, F> {
+    fn draw (self, to: &mut T) -> Perhaps<XYWH<T::Unit>> {
+        (self.0)(to)
+    }
+}
+
+/// Basic [Draw]able closure.
+///
+/// ```
+/// # use tengri::{draw::*, term::*};
+/// # fn test () -> impl tengri::draw::Draw<tengri::term::Tui> {
+///     thunk(|to: &mut Tui|Ok(to.1))
+/// # }
+/// ```
+pub const fn thunk <T: Screen, F: FnOnce(&mut T)->Perhaps<XYWH<T::Unit>>> (
+    draw: F
+) -> Thunk<T, F> {
+    Thunk(draw, std::marker::PhantomData)
+}
+
+/// Only render when condition is true.
+///
+/// ```
+/// # use tengri::{draw::*, term::*};
+/// # fn test () -> impl tengri::draw::Draw<tengri::term::Tui> {
+///     when(true, "Yes")
+/// # }
+/// ```
+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.
+///
+/// ```
+/// # use tengri::{draw::*, term::*};
+/// # fn test () -> impl tengri::draw::Draw<tengri::term::Tui> {
+///     either(true, "Yes", "No")
+/// # }
+/// ```
+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) })
+}
diff --git a/src/space/xywh.rs b/src/draw/xywh.rs
similarity index 93%
rename from src/space/xywh.rs
rename to src/draw/xywh.rs
index fa2cc8c..c831d14 100644
--- a/src/space/xywh.rs
+++ b/src/draw/xywh.rs
@@ -1,29 +1,6 @@
 use super::*;
-use Origin::*;
 use Split::*;
 
-/// 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
-}
-
-/// 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()
-    }
-}
-
 pub trait Xy<N: Coord> {
     fn x (&self) -> N;
     fn y (&self) -> N;
@@ -262,4 +239,3 @@ pub const fn y_push <T: Screen> (x: T::Unit, a: impl Draw<T>) -> impl Draw<T> {
 pub const fn y_pull <T: Screen> (x: T::Unit, a: impl Draw<T>) -> impl Draw<T> {
     a
 }
-
diff --git a/src/eval.rs b/src/eval.rs
index 63c579c..b3d0a4f 100644
--- a/src/eval.rs
+++ b/src/eval.rs
@@ -1,4 +1,5 @@
-use crate::{*, term::*, draw::*, space::*, lang::*, ratatui::prelude::*};
+use crate::{*, lang::*};
+use ratatui::style::Color;
 
 /// Some layout operations exist in XY, X, and Y variants that take 3 or 2 arguments.
 /// Their handling in [eval_view] is uniform and goes like this:
@@ -78,7 +79,7 @@ macro_rules! eval_enum ((
 pub fn eval_view <'a, O: Screen + 'a, S> (
     state: &S, output: &mut O, expr: &'a impl Expression
 ) -> Perhaps<XYWH<O::Unit>> where
-    S: Interpret<O, XYWH<O::Unit>>
+    S: Interpret<O, Option<XYWH<O::Unit>>>
         + for<'b> Namespace<'b, bool>
         + for<'b> Namespace<'b, O::Unit>
         + for<'b> Namespace<'b, Option<O::Unit>>
@@ -100,35 +101,58 @@ pub fn eval_view <'a, O: Screen + 'a, S> (
     let arg2  = tail1.head();
 
     // First `frags.next()` calls returns the namespace.
-    Some(match frags.next() {
+    match frags.next() {
 
         Some("when") => when(
             state.namespace(arg0?)?.unwrap(),
-            thunk(move|output: &mut O|state.interpret(output, &arg1))
+            thunk(move|output: &mut O|{
+                state.interpret(output, &arg1)
+            })
         ).draw(output),
 
         Some("either") => either(
             state.namespace(arg0?)?.unwrap(),
-            thunk(move|output: &mut O|state.interpret(output, &arg1)),
-            thunk(move|output: &mut O|state.interpret(output, &arg2)),
+            thunk(move|output: &mut O|{
+                state.interpret(output, &arg1)
+            }),
+            thunk(move|output: &mut O|{
+                state.interpret(output, &arg2)
+            }),
         ).draw(output),
 
         // Second `frags.next()` calls returns the namespace member.
         Some("bsp") => {
             let direction = eval_enum!("bsp", output, state, frags.next(), arg0, Split {
-                "n" => North, "s" => South, "e" => East, "w" => West, "a" => Above, "b" => Below
+                "n" => North,
+                "s" => South,
+                "e" => East,
+                "w" => West,
+                "a" => Above,
+                "b" => Below
             });
             direction.half(
-                thunk(move|output: &mut O|state.interpret(output, &arg0)),
-                thunk(move|output: &mut O|state.interpret(output, &arg1)),
+                thunk(move|output: &mut O|{
+                    state.interpret(output, &arg0)
+                }),
+                thunk(move|output: &mut O|{
+                    state.interpret(output, &arg1)
+                }),
             ).draw(output)
         },
 
         Some("align") => {
-            let alignment = eval_enum!("align", output, state, frags.next(), arg0, Origin {
-                "c" => C, "n" => N, "s" => S, "e" => E, "w" => W, "x" => X, "y" => Y
+            let alignment = eval_enum!("align", output, state, frags.next(), arg0, Azimuth {
+                "c" => C,
+                "n" => N,
+                "s" => S,
+                "e" => E,
+                "w" => W,
+                "x" => X,
+                "y" => Y
+            });
+            let content = thunk(move|output: &mut O|{
+                state.interpret(output, &arg0)
             });
-            let content = thunk(move|output: &mut O|state.interpret(output, &arg0));
             align(alignment, content).draw(output)
         },
 
@@ -154,7 +178,7 @@ pub fn eval_view <'a, O: Screen + 'a, S> (
 
         _ => return Ok(None)
 
-    }).transpose()
+    }
 }
 
 /// Interpret TUI-specific layout operation.
@@ -180,7 +204,7 @@ pub fn eval_view <'a, O: Screen + 'a, S> (
 pub fn eval_view_tui <'a, S> (
     state: &S, output: &mut Tui, expr: impl Expression + 'a
 ) -> Perhaps<XYWH<u16>> where
-    S: Interpret<Tui, XYWH<u16>>
+    S: Interpret<Tui, Option<XYWH<u16>>>
         + for<'b>Namespace<'b, bool>
         + for<'b>Namespace<'b, u16>
         + for<'b>Namespace<'b, Color>
@@ -208,7 +232,7 @@ pub fn eval_view_tui <'a, S> (
             output.show(fg(color, thunk(move|output: &mut Tui|{
                 state.interpret(output, &arg1)?;
                 // FIXME?: don't max out the used area?
-                Ok(output.area().into())
+                Ok(Some(output.area().into()))
             })))
         },
 
@@ -218,7 +242,7 @@ pub fn eval_view_tui <'a, S> (
             output.show(bg(color, thunk(move|output: &mut Tui|{
                 state.interpret(output, &arg1)?;
                 // FIXME?: don't max out the used area?
-                Ok(output.area().into())
+                Ok(Some(output.area().into()))
             })))
         },
 
diff --git a/src/layout/align.rs b/src/layout/align.rs
deleted file mode 100644
index 74af5c6..0000000
--- a/src/layout/align.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-use crate::*;
-
-/// ```
-/// use tengri::*;
-/// let _ = align(None, "unaligned");
-/// let _ = align(Origin::SE, "southeast");
-/// let _ = align(Some(Origin::SE), "southeast");
-/// ```
-pub fn align <S: Screen, T: Draw<S>, U: Into<Option<Origin>>> (origin: U, it: T) -> Align<T> {
-    Align(origin.into(), it)
-}
-
-pub struct Align<T>(Option<Origin>, T);
-
-impl_draw!(<S: Screen, T: Draw<S>,>|self: Align<T>, to: S|{ todo!() });
diff --git a/src/lib.rs b/src/lib.rs
index d0ddf0e..f42030b 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -18,6 +18,7 @@ pub extern crate unicode_width;
 #[cfg(feature = "term")] pub extern crate crossterm;
 #[cfg(feature = "lang")] pub extern crate dizzle as lang;
 #[cfg(test)] #[macro_use] pub extern crate proptest;
+#[cfg(test)] pub(crate) use proptest_derive::Arbitrary;
 
 pub(crate) use ::{
     atomic_float::AtomicF64,
@@ -47,9 +48,9 @@ features! {
     "time": [ time ],
     "play": [ exit, task ],
     "sing": [ sing ],
-    "draw": [ draw, space, layout, color ],
     "text": [ text ],
-    "term": [ term ]
+    "term": [ term ],
+    "draw": [ draw ]
 }
 
 /// Define a trait an implement it for various mutation-enabled wrapper types. */
diff --git a/src/origin.rs b/src/origin.rs
new file mode 100644
index 0000000..e69de29
diff --git a/src/space.rs b/src/space.rs
deleted file mode 100644
index 985dd15..0000000
--- a/src/space.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-use crate::*;
-#[cfg(test)] use proptest_derive::Arbitrary;
-
-mod coord;  pub use self::coord::*;
-mod iter;   pub use self::iter::*;
-mod sizer;  pub use self::sizer::*;
-mod xywh;   pub use self::xywh::*;
-mod lrtb;   pub use self::lrtb::*;
diff --git a/src/term.rs b/src/term.rs
index 7571155..fb2b207 100644
--- a/src/term.rs
+++ b/src/term.rs
@@ -1,10 +1,15 @@
-mod border;
-pub use self::border::*;
+use crate::{*, lang::*};
+
+mod border; pub use self::border::*;
+mod event;  pub use self::event::*;
+mod keys;   pub use self::keys::*;
+mod buffer; pub use self::buffer::*;
+mod input;  pub use self::input::*;
+mod output; pub use self::output::*;
 
-use crate::{*, lang::*, draw::*, task::*, exit::*};
 //use unicode_width::{UnicodeWidthStr, UnicodeWidthChar};
 //use rand::distributions::uniform::UniformSampler;
-use ::{
+pub(crate) use ::{
     std::{
         io::{stdout, Write},
         time::Duration,
@@ -27,6 +32,74 @@ use ::{
     },
 };
 
+/// Terminal output.
+pub struct Tui(
+    /// Ratatui buffer; area is screen size
+    pub Buffer,
+    /// Current draw area
+    pub XYWH<u16>
+);
+
+impl Deref         for Tui { type Target = Buffer; fn deref (&self) -> &Buffer { &self.0 } }
+impl DerefMut      for Tui { fn deref_mut (&mut self) -> &mut Buffer { &mut self.0 } }
+impl AsMut<Buffer> for Tui { fn as_mut (&mut self) -> &mut Buffer { &mut self.0 } }
+impl Wide<u16>     for Tui { fn w (&self) -> u16 { self.1.2 } }
+impl Tall<u16>     for Tui { fn h (&self) -> u16 { self.1.3 } }
+impl HasOrigin     for Tui { fn origin (&self) -> Azimuth { Azimuth::NW } }
+impl Xy<u16>       for Tui { fn x (&self) -> u16 { self.1.0 } fn y (&self) -> u16 { self.1.1 } }
+
+impl Tui {
+    pub fn new (width: u16, height: u16) -> Self {
+        Self(Buffer::empty(Rect { x: 0, y: 0, width, height }), XYWH(0, 0, width, height))
+    }
+    pub fn resize <W: Write> (&mut self, back: &mut CrosstermBackend<W>, width: u16, height: u16) {
+        let size = Rect { x: 0, y: 0, width, height };
+        if self.0.area != size {
+            back.clear_region(ClearType::All).unwrap();
+            self.0.resize(size);
+            self.0.reset();
+        }
+    }
+    pub fn redraw <'b, W: Write> (&'b mut self, back: &mut CrosstermBackend<W>, mut next: &'b mut Self) {
+        let updates = self.0.diff(&next.0);
+        back.draw(updates.into_iter()).expect("failed to render");
+        Backend::flush(back).expect("failed to flush output new");
+        std::mem::swap(self, &mut next);
+        next.0.reset();
+    }
+}
+
+impl Tui {
+    pub fn update (&mut self, callback: &impl Fn(&mut Cell, u16, u16)) -> XYWH<u16> {
+        for row in 0..self.h() {
+            let y = self.y() + row;
+            for col in 0..self.w() {
+                let x = self.x() + col;
+                if x < self.0.area.width && y < self.0.area.height {
+                    if let Some(cell) = self.0.cell_mut(Position { x, y }) {
+                        callback(cell, col, row);
+                    }
+                }
+            }
+        }
+        self.xywh()
+    }
+    pub fn tint_all (&mut self, fg: Color, bg: Color, modifier: Modifier) {
+        for cell in self.0.content.iter_mut() {
+            cell.fg = fg;
+            cell.bg = bg;
+            cell.modifier = modifier;
+        }
+    }
+    pub 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());
+        if x < self.0.area.width && y < self.0.area.height {
+            self.0.set_string(x, y, text, style);
+        }
+    }
+}
+
 /// Implement standard [main] entrypoint for TUI apps.
 #[macro_export] macro_rules! tui_main {
     ($state:expr) => {
@@ -34,24 +107,6 @@ use ::{
     }
 }
 
-/// Enable TUI keyboard input for main state struct.
-#[macro_export] macro_rules! tui_keys {
-    (|$self:ident:$State:ty,$input:ident|$body:block) => {
-        impl Apply<TuiEvent, Usually<()>> for $State {
-            fn apply (&mut $self, $input: &TuiEvent) -> Usually<()> $body
-        }
-    };
-}
-
-/// Enable TUI output for state struct.
-#[macro_export] macro_rules! tui_view {
-    (|$self:ident: $State:ty|$body:block) => {
-        impl View<Tui> for $State {
-            fn view (&$self) -> impl Draw<Tui> $body
-        }
-    }
-}
-
 pub fn tui_run_main <T> (state: Arc<RwLock<T>>) -> Usually<()> where
     T: View<Tui> + Apply<TuiEvent, Usually<()>> + Send + Sync + 'static
 {
@@ -98,444 +153,3 @@ pub fn tui_io <
     let terminal = tui_output(exited, state, sleep, output)?;
     Ok((keyboard, terminal))
 }
-
-/// Spawn the TUI input thread which reads keys from the terminal.
-pub fn tui_input <T: Apply<TuiEvent, Usually<()>> + Send + Sync + 'static> (
-    exited: &Arc<AtomicBool>, state: &Arc<RwLock<T>>, poll: Duration
-) -> Result<Task, std::io::Error> {
-    let exited = exited.clone();
-    let state = state.clone();
-    Task::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:
-            event => {
-                if let Err(e) = state.write().unwrap().apply(&TuiEvent(event)) {
-                    panic!("{e}")
-                }
-            },
-
-        }
-    })
-}
-
-/// Spawn the TUI output thread which writes colored characters to the terminal.
-///
-/// ```
-/// let state = Arc::new(RwLock::new(()));
-/// Exit::run(|exit|tui_output(exit, state, sleep, stdout()))
-/// ```
-pub fn tui_output <
-    W: Write + Send + Sync + 'static, T: View<Tui> + Send + Sync + 'static
-> (
-    exited: &Arc<AtomicBool>,
-    state:  &Arc<RwLock<T>>,
-    sleep:  Duration,
-    output: W,
-) -> Usually<Task> {
-    let state = state.clone();
-    stdout().execute(EnterAlternateScreen)?;
-    CrosstermBackend::new(stdout()).hide_cursor()?;
-    enable_raw_mode()?;
-    let mut backend = CrosstermBackend::new(output);
-    let Size { width, height } = backend.size().expect("get size failed");
-    let mut prev = Tui::new(width, height);
-    let mut next = Tui::new(width, height);
-    Ok(Task::new_sleep(exited.clone(), sleep, move |perf| {
-        let Size { width, height } = backend.size().expect("get size failed");
-        if let Ok(state) = state.try_read() {
-            prev.resize(&mut backend, width, height);
-            state.view().draw(&mut next).expect("draw failed"); // TODO draw error
-            prev.redraw(&mut backend, &mut next);
-        }
-        let timer = format!("{:>3.3}ms", perf.used.load(Relaxed));
-        prev.set_string(0, 0, &timer, Style::default());
-    })?)
-}
-
-/// Terminal output.
-pub struct Tui(
-    /// Ratatui buffer; area is screen size
-    pub Buffer,
-    /// Current draw area
-    pub XYWH<u16>
-);
-
-impl Tui {
-    pub fn new (width: u16, height: u16) -> Self {
-        Self(Buffer::empty(Rect { x: 0, y: 0, width, height }), XYWH(0, 0, width, height))
-    }
-    pub fn resize <W: Write> (&mut self, back: &mut CrosstermBackend<W>, width: u16, height: u16) {
-        let size = Rect { x: 0, y: 0, width, height };
-        if self.0.area != size {
-            back.clear_region(ClearType::All).unwrap();
-            self.0.resize(size);
-            self.0.reset();
-        }
-    }
-    pub fn redraw <'b, W: Write> (&'b mut self, back: &mut CrosstermBackend<W>, mut next: &'b mut Self) {
-        let updates = self.0.diff(&next.0);
-        back.draw(updates.into_iter()).expect("failed to render");
-        Backend::flush(back).expect("failed to flush output new");
-        std::mem::swap(self, &mut next);
-        next.0.reset();
-    }
-}
-
-impl Screen for Tui {
-    type Unit = u16;
-    /// Render drawable in subarea specified by `area`
-    fn show <'t, T: Draw<Self>> (&mut self, content: T) -> Perhaps<XYWH<u16>> {
-        let previous_area = self.1;
-        if let Some(area) = content.layout(self.1)? {
-            self.1 = area;
-            if let Some(result_area) = content.draw(self)? {
-                self.1 = previous_area;
-                result_area
-            } else {
-                Ok(None)
-            }
-        } else {
-            Ok(None)
-        }
-    }
-}
-
-impl Deref         for Tui { type Target = Buffer; fn deref (&self) -> &Buffer { &self.0 } }
-impl DerefMut      for Tui { fn deref_mut (&mut self) -> &mut Buffer { &mut self.0 } }
-impl AsMut<Buffer> for Tui { fn as_mut (&mut self) -> &mut Buffer { &mut self.0 } }
-impl Wide<u16> for Tui { fn w (&self) -> u16 { self.1.2 } }
-impl Tall<u16> for Tui { fn h (&self) -> u16 { self.1.3 } }
-impl HasOrigin for Tui { fn origin (&self) -> Origin { Origin::NW } }
-impl Xy<u16> for Tui {
-    fn x (&self) -> u16 { self.1.0 }
-    fn y (&self) -> u16 { self.1.1 }
-}
-
-impl Tui {
-    pub fn update (&mut self, callback: &impl Fn(&mut Cell, u16, u16)) -> XYWH<u16> {
-        for row in 0..self.h() {
-            let y = self.y() + row;
-            for col in 0..self.w() {
-                let x = self.x() + col;
-                if x < self.0.area.width && y < self.0.area.height {
-                    if let Some(cell) = self.0.cell_mut(Position { x, y }) {
-                        callback(cell, col, row);
-                    }
-                }
-            }
-        }
-        self.xywh()
-    }
-    pub fn tint_all (&mut self, fg: Color, bg: Color, modifier: Modifier) {
-        for cell in self.0.content.iter_mut() {
-            cell.fg = fg;
-            cell.bg = bg;
-            cell.modifier = modifier;
-        }
-    }
-    pub 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());
-        if x < self.0.area.width && y < self.0.area.height {
-            self.0.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) -> impl Draw<Tui> {
-    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) -> impl Draw<Tui> {
-    thunk(move|to: &mut Tui|Ok({
-        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 (color: Option<Color>) -> impl Draw<Tui> {
-    thunk(move|to: &mut Tui|Ok(if let Some(color) = color {
-        to.update(&|cell,_,_|{
-            cell.modifier.insert(Modifier::UNDERLINED);
-            cell.underline_color = color;
-        })
-    } else {
-        to.update(&|cell,_,_|{
-            cell.modifier.remove(Modifier::UNDERLINED);
-            cell.underline_color = Reset;
-        })
-    }))
-}
-
-/// TUI works in u16 coordinates.
-impl Coord for u16 {
-    fn plus (self, other: Self) -> Self {
-        self.saturating_add(other)
-    }
-}
-
-impl_draw!(|self: u64, _to: Tui|{ todo!() });
-impl_draw!(|self: f64, _to: Tui|{ todo!() });
-
-mod phat {
-    use super::*;
-    pub const LO: &'static str = "▄";
-    pub const HI: &'static str = "▀";
-    /// A phat line
-    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<Tui> {
-        h_exact(1, fg_bg(fg, bg, x_repeat(self::phat::HI)))
-    }
-}
-
-mod scroll {
-    pub const ICON_DEC_V: &[char] = &['▲'];
-    pub const ICON_INC_V: &[char] = &['▼'];
-    pub const ICON_DEC_H: &[char] = &[' ', '🞀', ' '];
-    pub const ICON_INC_H: &[char] = &[' ', '🞂', ' '];
-}
-
-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.0.cell_mut(Position::from((x, y))) {
-                cell.set_symbol(&c);
-            }
-        }
-        Ok(XYWH(x, y, w, 1))
-    })
-}
-
-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.0.cell_mut(Position::from((x, y))) {
-                cell.set_symbol(&c);
-            }
-        }
-        Ok(XYWH(x, y, 1, h))
-    })
-}
-
-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.0.cell_mut(Position::from((x, y))) {
-                    let u = u % a;
-                    cell.set_symbol(&c[u..u+1]);
-                }
-            }
-        }
-        Ok(XYWH(x, y, w, h))
-    })
-}
-
-/// ```
-/// let _ = tengri::button_2("", "", true);
-/// let _ = tengri::button_2("", "", false);
-/// ```
-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 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, "▌"), ))))
-}
-
-/// Stackably padded.
-///
-/// ```
-/// /// TODO
-/// ```
-pub fn phat (w: u16, h: u16, [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 = fg_bg(fg, bg, draw);
-    wh_min(Some(w), Some(h), south(top, north(low, draw)))
-}
-
-fn x_scroll () -> impl Draw<Tui> {
-    thunk(|Tui(buf, XYWH(x1, y1, w, h)): &mut Tui|{
-        let x2 = *x1 + *w;
-        for (i, x) in (*x1..=x2).enumerate() {
-            if let Some(cell) = buf.cell_mut(Position::from((x, *y1))) {
-                if i < (self::scroll::ICON_DEC_H.len()) {
-                    cell.set_fg(Rgb(255, 255, 255));
-                    cell.set_bg(Rgb(0, 0, 0));
-                    cell.set_char(self::scroll::ICON_DEC_H[i as usize]);
-                } else if i > (*w as usize - self::scroll::ICON_INC_H.len()) {
-                    cell.set_fg(Rgb(255, 255, 255));
-                    cell.set_bg(Rgb(0, 0, 0));
-                    cell.set_char(self::scroll::ICON_INC_H[*w as usize - i]);
-                } else if false {
-                    cell.set_fg(Rgb(255, 255, 255));
-                    cell.set_bg(Reset);
-                    cell.set_char('━');
-                } else {
-                    cell.set_fg(Rgb(0, 0, 0));
-                    cell.set_bg(Reset);
-                    cell.set_char('╌');
-                }
-            }
-        }
-        Ok(XYWH(*x1, *y1, *w, 1))
-    })
-}
-
-fn y_scroll () -> impl Draw<Tui> {
-    thunk(|Tui(buf, XYWH(x1, y1, w, h)): &mut Tui|{
-        let y2 = *y1 + *h;
-        for (i, y) in (*y1..=y2).enumerate() {
-            if let Some(cell) = buf.cell_mut(Position::from((*x1, y))) {
-                if (i as usize) < (self::scroll::ICON_DEC_V.len()) {
-                    cell.set_fg(Rgb(255, 255, 255));
-                    cell.set_bg(Rgb(0, 0, 0));
-                    cell.set_char(self::scroll::ICON_DEC_V[i as usize]);
-                } else if (i as usize) > (*h as usize - self::scroll::ICON_INC_V.len()) {
-                    cell.set_fg(Rgb(255, 255, 255));
-                    cell.set_bg(Rgb(0, 0, 0));
-                    cell.set_char(self::scroll::ICON_INC_V[*h as usize - i]);
-                } else if false {
-                    cell.set_fg(Rgb(255, 255, 255));
-                    cell.set_bg(Reset);
-                    cell.set_char('‖'); // ━
-                } else {
-                    cell.set_fg(Rgb(0, 0, 0));
-                    cell.set_bg(Reset);
-                    cell.set_char('╎'); // ━
-                }
-            }
-        }
-        Ok(XYWH(*x1, *y1, 1, *h))
-    })
-}
-
-pub fn tui_update (
-    Tui(buf, ..): &mut Tui,
-    area: XYWH<u16>,
-    callback: &impl Fn(&mut Cell, u16, u16)
-) {
-}
-
-/// Draw TUI content or its error message.
-///
-/// ```
-/// let _ = tengri::term::catcher(Ok(Some("hello")));
-/// let _ = tengri::term::catcher(Ok(None));
-/// let _ = tengri::term::catcher(Err("draw fail".into()));
-/// ```
-pub fn catcher <T: Draw<Tui>> (result: Usually<T>) -> impl Draw<Tui> {
-    thunk(move|to: &mut Tui|match result {
-        Ok(content) => content.draw(to),
-        Err(e) => {
-            let err_fg = Color::Rgb(255,224,244);
-            let err_bg = Color::Rgb(96, 24, 24);
-            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))).draw(to)
-        }
-    })
-}
-
-mod event;  pub use self::event::*;
-mod keys;   pub use self::keys::*;
-mod buffer; pub use self::buffer::*;
-
-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) }
-}
diff --git a/src/term/border.rs b/src/term/border.rs
index 837445a..e8c984a 100644
--- a/src/term/border.rs
+++ b/src/term/border.rs
@@ -49,7 +49,7 @@ macro_rules! border {
         //impl Layout<Tui> for $T {}
         impl Draw<Tui> for $T {
             fn draw (self, to: &mut Tui) -> Perhaps<XYWH<u16>> {
-                when(self.enabled(), thunk(|to: &mut Tui|BorderStyle::draw(self, to))).draw(to)
+                when(self.enabled(), thunk(|to: &mut Tui|BorderStyle::draw(self, to).map(Some))).draw(to)
             }
         }
     )+}
diff --git a/src/term/input.rs b/src/term/input.rs
new file mode 100644
index 0000000..62ecafe
--- /dev/null
+++ b/src/term/input.rs
@@ -0,0 +1,39 @@
+use crate::{*, lang::*};
+
+/// Enable TUI keyboard input for main state struct.
+#[macro_export] macro_rules! tui_keys {
+    (|$self:ident:$State:ty,$input:ident|$body:block) => {
+        impl Apply<TuiEvent, Usually<()>> for $State {
+            fn apply (&mut $self, $input: &TuiEvent) -> Usually<()> $body
+        }
+    };
+}
+
+/// Spawn the TUI input thread which reads keys from the terminal.
+pub fn tui_input <T: Apply<TuiEvent, Usually<()>> + Send + Sync + 'static> (
+    exited: &Arc<AtomicBool>, state: &Arc<RwLock<T>>, poll: Duration
+) -> Result<Task, std::io::Error> {
+    let exited = exited.clone();
+    let state = state.clone();
+    Task::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:
+            event => {
+                if let Err(e) = state.write().unwrap().apply(&TuiEvent(event)) {
+                    panic!("{e}")
+                }
+            },
+
+        }
+    })
+}
diff --git a/src/term/output.rs b/src/term/output.rs
new file mode 100644
index 0000000..eefb9e8
--- /dev/null
+++ b/src/term/output.rs
@@ -0,0 +1,343 @@
+use crate::{*, lang::*};
+use ratatui::{prelude::{Style, Position, Backend, Color}};
+
+/// TUI works in u16 coordinates.
+impl Coord for u16 { fn plus (self, other: Self) -> Self { self.saturating_add(other) } }
+impl_draw!(|self: u64, _to: Tui|{ todo!() });
+impl_draw!(|self: f64, _to: Tui|{ todo!() });
+
+impl Screen for Tui {
+    type Unit = u16;
+    /// Render drawable in subarea specified by `area`
+    fn show <'t, T: Draw<Self>> (&mut self, content: T) -> Perhaps<XYWH<u16>> {
+        let previous_area = self.1;
+        Ok(if let Some(area) = content.layout(self.1)? {
+            self.1 = area;
+            if let Some(result_area) = content.draw(self)? {
+                self.1 = previous_area;
+                Some(result_area)
+            } else {
+                None
+            }
+        } else {
+            None
+        })
+    }
+}
+
+/// Enable TUI output for state struct.
+#[macro_export] macro_rules! tui_view {
+    (|$self:ident: $State:ty|$body:block) => {
+        impl View<Tui> for $State {
+            fn view (&$self) -> impl Draw<Tui> $body
+        }
+    }
+}
+
+/// Spawn the TUI output thread which writes colored characters to the terminal.
+///
+/// ```
+/// let state = Arc::new(RwLock::new(()));
+/// Exit::run(|exit|tui_output(exit, state, sleep, stdout()))
+/// ```
+pub fn tui_output <
+    W: Write + Send + Sync + 'static, T: View<Tui> + Send + Sync + 'static
+> (
+    exited: &Arc<AtomicBool>,
+    state:  &Arc<RwLock<T>>,
+    sleep:  Duration,
+    output: W,
+) -> Usually<Task> {
+    let state = state.clone();
+    stdout().execute(EnterAlternateScreen)?;
+    CrosstermBackend::new(stdout()).hide_cursor()?;
+    enable_raw_mode()?;
+    let mut backend = CrosstermBackend::new(output);
+    let Size { width, height } = backend.size().expect("get size failed");
+    let mut prev = Tui::new(width, height);
+    let mut next = Tui::new(width, height);
+    Ok(Task::new_sleep(exited.clone(), sleep, move |perf| {
+        let Size { width, height } = backend.size().expect("get size failed");
+        if let Ok(state) = state.try_read() {
+            prev.resize(&mut backend, width, height);
+            state.view().draw(&mut next).expect("draw failed"); // TODO draw error
+            prev.redraw(&mut backend, &mut next);
+        }
+        let timer = format!("{:>3.3}ms", perf.used.load(Relaxed));
+        prev.set_string(0, 0, &timer, Style::default());
+    })?)
+}
+
+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) }
+}
+
+/// 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) -> impl Draw<Tui> {
+    thunk(move|to: &mut Tui|Ok(Some(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) -> impl Draw<Tui> {
+    thunk(move|to: &mut Tui|Ok(Some({
+        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 (color: Option<Color>) -> impl Draw<Tui> {
+    thunk(move|to: &mut Tui|Ok(Some(if let Some(color) = color {
+        to.update(&|cell,_,_|{
+            cell.modifier.insert(Modifier::UNDERLINED);
+            cell.underline_color = color;
+        })
+    } else {
+        to.update(&|cell,_,_|{
+            cell.modifier.remove(Modifier::UNDERLINED);
+            cell.underline_color = Reset;
+        })
+    })))
+}
+
+mod phat {
+    use super::*;
+    pub const LO: &'static str = "▄";
+    pub const HI: &'static str = "▀";
+    /// A phat line
+    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<Tui> {
+        h_exact(1, fg_bg(fg, bg, x_repeat(self::phat::HI)))
+    }
+}
+
+mod scroll {
+    pub const ICON_DEC_V: &[char] = &['▲'];
+    pub const ICON_INC_V: &[char] = &['▼'];
+    pub const ICON_DEC_H: &[char] = &[' ', '🞀', ' '];
+    pub const ICON_INC_H: &[char] = &[' ', '🞂', ' '];
+}
+
+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.0.cell_mut(Position::from((x, y))) {
+                cell.set_symbol(&c);
+            }
+        }
+        Ok(Some(XYWH(x, y, w, 1)))
+    })
+}
+
+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.0.cell_mut(Position::from((x, y))) {
+                cell.set_symbol(&c);
+            }
+        }
+        Ok(Some(XYWH(x, y, 1, h)))
+    })
+}
+
+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.0.cell_mut(Position::from((x, y))) {
+                    let u = u % a;
+                    cell.set_symbol(&c[u..u+1]);
+                }
+            }
+        }
+        Ok(Some(XYWH(x, y, w, h)))
+    })
+}
+
+/// ```
+/// let _ = tengri::button_2("", "", true);
+/// let _ = tengri::button_2("", "", false);
+/// ```
+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 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, "▌"), ))))
+}
+
+/// Stackably padded.
+///
+/// ```
+/// /// TODO
+/// ```
+pub fn phat (w: u16, h: u16, [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 = fg_bg(fg, bg, draw);
+    wh_min(Some(w), Some(h), south(top, north(low, draw)))
+}
+
+fn x_scroll () -> impl Draw<Tui> {
+    thunk(|Tui(buf, XYWH(x1, y1, w, h)): &mut Tui|{
+        let x2 = *x1 + *w;
+        for (i, x) in (*x1..=x2).enumerate() {
+            if let Some(cell) = buf.cell_mut(Position::from((x, *y1))) {
+                if i < (self::scroll::ICON_DEC_H.len()) {
+                    cell.set_fg(Rgb(255, 255, 255));
+                    cell.set_bg(Rgb(0, 0, 0));
+                    cell.set_char(self::scroll::ICON_DEC_H[i as usize]);
+                } else if i > (*w as usize - self::scroll::ICON_INC_H.len()) {
+                    cell.set_fg(Rgb(255, 255, 255));
+                    cell.set_bg(Rgb(0, 0, 0));
+                    cell.set_char(self::scroll::ICON_INC_H[*w as usize - i]);
+                } else if false {
+                    cell.set_fg(Rgb(255, 255, 255));
+                    cell.set_bg(Reset);
+                    cell.set_char('━');
+                } else {
+                    cell.set_fg(Rgb(0, 0, 0));
+                    cell.set_bg(Reset);
+                    cell.set_char('╌');
+                }
+            }
+        }
+        Ok(Some(XYWH(*x1, *y1, *w, 1)))
+    })
+}
+
+fn y_scroll () -> impl Draw<Tui> {
+    thunk(|Tui(buf, XYWH(x1, y1, w, h)): &mut Tui|{
+        let y2 = *y1 + *h;
+        for (i, y) in (*y1..=y2).enumerate() {
+            if let Some(cell) = buf.cell_mut(Position::from((*x1, y))) {
+                if (i as usize) < (self::scroll::ICON_DEC_V.len()) {
+                    cell.set_fg(Rgb(255, 255, 255));
+                    cell.set_bg(Rgb(0, 0, 0));
+                    cell.set_char(self::scroll::ICON_DEC_V[i as usize]);
+                } else if (i as usize) > (*h as usize - self::scroll::ICON_INC_V.len()) {
+                    cell.set_fg(Rgb(255, 255, 255));
+                    cell.set_bg(Rgb(0, 0, 0));
+                    cell.set_char(self::scroll::ICON_INC_V[*h as usize - i]);
+                } else if false {
+                    cell.set_fg(Rgb(255, 255, 255));
+                    cell.set_bg(Reset);
+                    cell.set_char('‖'); // ━
+                } else {
+                    cell.set_fg(Rgb(0, 0, 0));
+                    cell.set_bg(Reset);
+                    cell.set_char('╎'); // ━
+                }
+            }
+        }
+        Ok(Some(XYWH(*x1, *y1, 1, *h)))
+    })
+}
+
+pub fn tui_update (
+    Tui(buf, ..): &mut Tui,
+    area: XYWH<u16>,
+    callback: &impl Fn(&mut Cell, u16, u16)
+) {
+}
+
+/// Draw TUI content or its error message.
+///
+/// ```
+/// let _ = tengri::term::catcher(Ok(Some("hello")));
+/// let _ = tengri::term::catcher(Ok(None));
+/// let _ = tengri::term::catcher(Err("draw fail".into()));
+/// ```
+pub fn catcher <T: Draw<Tui>> (result: Usually<T>) -> impl Draw<Tui> {
+    thunk(move|to: &mut Tui|match result {
+        Ok(content) => content.draw(to),
+        Err(e) => {
+            let err_fg = Color::Rgb(255,224,244);
+            let err_bg = Color::Rgb(96, 24, 24);
+            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))).draw(to)
+        }
+    })
+}
diff --git a/src/text.rs b/src/text.rs
index e79ae55..3fd8806 100644
--- a/src/text.rs
+++ b/src/text.rs
@@ -1,4 +1,4 @@
-use crate::{Usually, draw::Draw, space::*};
+use crate::*;
 pub(crate) use ::unicode_width::*;
 
 #[cfg(feature = "term")] mod impl_term {

From 09463649c673b0d883ca18746a36aa86c6bd114f Mon Sep 17 00:00:00 2001
From: facile pop culture reference <donotem@ilme.no>
Date: Tue, 7 Jul 2026 16:35:29 +0300
Subject: [PATCH 23/25] add Layout trait

---
 src/draw/iter.rs   |   8 +-
 src/draw/layout.rs | 259 ++++++++++++++++++++++++++++++++-------------
 src/draw/xywh.rs   | 126 ----------------------
 src/eval.rs        |  23 ++--
 src/term/border.rs |   4 +-
 src/term/output.rs |  10 +-
 6 files changed, 208 insertions(+), 222 deletions(-)

diff --git a/src/draw/iter.rs b/src/draw/iter.rs
index fa5d3de..1e5fa38 100644
--- a/src/draw/iter.rs
+++ b/src/draw/iter.rs
@@ -73,23 +73,23 @@ pub fn iter_west <'a, S: Screen, D: 'a, I: Iterator<Item = D>, U: Draw<S>> (
 pub fn row_south <S: Screen> (south: S::Unit, height: S::Unit, content: impl Draw<S>)
     -> impl Draw<S>
 {
-    y_push(south, h_exact(height, content))
+    content.exact_h(height).push_y(south)
 }
 
 pub fn row_north <S: Screen> (north: S::Unit, height: S::Unit, content: impl Draw<S>)
     -> impl Draw<S>
 {
-    y_pull(north, h_exact(height, content))
+    content.exact_h(height).pull_y(north)
 }
 
 pub fn col_east <S: Screen> (east: S::Unit, width: S::Unit, content: impl Draw<S>)
     -> impl Draw<S>
 {
-    x_push(east, h_exact(width, content))
+    content.exact_w(width).push_x(east)
 }
 
 pub fn col_west <S: Screen> (west: S::Unit, width: S::Unit, content: impl Draw<S>)
     -> impl Draw<S>
 {
-    x_pull(west, h_exact(width, content))
+    content.exact_w(width).pull_x(west)
 }
diff --git a/src/draw/layout.rs b/src/draw/layout.rs
index 5db0b5b..d1728bb 100644
--- a/src/draw/layout.rs
+++ b/src/draw/layout.rs
@@ -1,80 +1,189 @@
 use crate::*;
 
-pub enum Layout<T: Screen, X: Into<Option<T::Unit>>, I: Draw<T>> {
-    __(PhantomData<T>),
-    MinW(X, I),
-    MinH(X, I),
-    MinWH(X, X, I),
-    MaxW(X, I),
-    MaxH(X, I),
-    MaxWH(X, X, I),
-    ExactW(X, I),
-    ExactH(X, I),
-    ExactWH(X, X, I),
-    ClipW(X, I),
-    ClipH(X, I),
-    ClipWH(X, X, I),
+pub trait Layout<S: Screen>: Draw<S> + Sized {
+    fn full_w (self) -> impl Draw<S> {
+        Full::W(self)
+    }
+    fn full_h (self) -> impl Draw<S> {
+        Full::H(self)
+    }
+    fn full_wh (self) -> impl Draw<S> {
+        Full::WH(self)
+    }
+
+    fn exact_w <N: Into<Option<S::Unit>>> (self, x: N) -> impl Draw<S> {
+        Exact::W(self, x.into())
+    }
+    fn exact_h <N: Into<Option<S::Unit>>> (self, y: N) -> impl Draw<S> {
+        Exact::H(self, y.into())
+    }
+    fn exact_wh <N: Into<Option<S::Unit>>> (self, x: N, y: N) -> impl Draw<S> {
+        Exact::WH(self, x.into(), y.into())
+    }
+
+    fn min_w <N: Into<Option<S::Unit>>> (self, x: N) -> impl Draw<S> {
+        Min::W(self, x.into())
+    }
+    fn min_h <N: Into<Option<S::Unit>>> (self, y: N) -> impl Draw<S> {
+        Min::H(self, y.into())
+    }
+    fn min_wh <N: Into<Option<S::Unit>>> (self, x: N, y: N) -> impl Draw<S> {
+        Min::WH(self, x.into(), y.into())
+    }
+
+    fn max_w <N: Into<Option<S::Unit>>> (self, x: N) -> impl Draw<S> {
+        Max::W(self, x.into())
+    }
+    fn max_h <N: Into<Option<S::Unit>>> (self, y: N) -> impl Draw<S> {
+        Max::H(self, y.into())
+    }
+    fn max_wh <N: Into<Option<S::Unit>>> (self, x: N, y: N) -> impl Draw<S> {
+        Max::WH(self, x.into(), y.into())
+    }
+
+    fn pad_w <N: Into<Option<S::Unit>>> (self, x: N) -> impl Draw<S> {
+        Pad::W(self, x.into())
+    }
+    fn pad_h <N: Into<Option<S::Unit>>> (self, y: N) -> impl Draw<S> {
+        Pad::H(self, y.into())
+    }
+    fn pad_wh <N: Into<Option<S::Unit>>> (self, x: N, y: N) -> impl Draw<S> {
+        Pad::WH(self, x.into(), y.into())
+    }
+
+    fn pull_x <N: Into<Option<S::Unit>>> (self, x: N) -> impl Draw<S> {
+        Pull::X(self, x.into())
+    }
+    fn pull_y <N: Into<Option<S::Unit>>> (self, y: N) -> impl Draw<S> {
+        Pull::X(self, y.into())
+    }
+    fn pull_xy <N: Into<Option<S::Unit>>> (self, x: N, y: N) -> impl Draw<S> {
+        Pull::XY(self, x.into(), y.into())
+    }
+
+    fn push_x <N: Into<Option<S::Unit>>> (self, x: N) -> impl Draw<S> {
+        Push::X(self, x.into())
+    }
+    fn push_y <N: Into<Option<S::Unit>>> (self, y: N) -> impl Draw<S> {
+        Push::X(self, y.into())
+    }
+    fn push_xy <N: Into<Option<S::Unit>>> (self, x: N, y: N) -> impl Draw<S> {
+        Push::XY(self, x.into(), y.into())
+    }
 }
 
-impl_draw!(<
-    T: Screen,
-    X: Into<Option<T::Unit>>,
-    I: Draw<T>,
->|self: Layout<T, X, I>, to: T|{
-    use Layout::*;
-    match self {
-        __(_) => unreachable!(),
-        MinW(x, it) => {
-            let x = x.into();
-            it.draw(to)
-        },
-        MinH(y, it) => {
-            let y = y.into();
-            it.draw(to)
-        },
-        MinWH(x, y, it) => {
-            let x = x.into();
-            let y = y.into();
-            it.draw(to)
-        },
-        MaxW(x, it) => {
-            let x = x.into();
-            it.draw(to)
-        },
-        MaxH(y, it) => {
-            let y = y.into();
-            it.draw(to)
-        },
-        MaxWH(x, y, it) => {
-            let x = x.into();
-            let y = y.into();
-            it.draw(to)
-        },
-        ExactW(x, it) => {
-            let x = x.into();
-            it.draw(to)
-        },
-        ExactH(y, it) => {
-            let y = y.into();
-            it.draw(to)
-        },
-        ExactWH(x, y, it) => {
-            let x = x.into();
-            let y = y.into();
-            it.draw(to)
-        },
-        ClipW(x, it) => {
-            let x = x.into();
-            it.draw(to)
-        },
-        ClipH(y, it) => {
-            let y = y.into();
-            it.draw(to)
-        },
-        ClipWH(x, y, it) => {
-            let x = x.into();
-            let y = y.into();
-            it.draw(to)
-        },
-    }
+impl<S: Screen, T: Draw<S>> Layout<S> for T {}
+
+/// Use whole drawing area along one or both axes.
+pub enum Full<T: Screen, I: Draw<T>> {
+    __(PhantomData<T>),
+    W(I),
+    H(I),
+    WH(I),
+}
+
+impl_draw!(<T: Screen, I: Draw<T>,>|self: Full<T, I>, to: T|{
+    todo!()
+});
+
+/// Only draw content if area is above a certain size.
+///
+/// ```
+/// let min = tengri::wh_min(3, 5, "Hello"); // 5x5
+/// ```
+pub enum Push<T: Screen, I: Draw<T>, X: Into<Option<T::Unit>>> {
+    __(PhantomData<T>),
+    X(I, X),
+    Y(I, X),
+    XY(I, X, X),
+}
+
+impl_draw!(<T: Screen, I: Draw<T>, X: Into<Option<T::Unit>>,>|self: Push<T, I, X>, to: T|{
+    todo!()
+});
+
+/// Only draw content if area is above a certain size.
+///
+/// ```
+/// let min = tengri::wh_min(3, 5, "Hello"); // 5x5
+/// ```
+pub enum Pull<T: Screen, I: Draw<T>, X: Into<Option<T::Unit>>> {
+    __(PhantomData<T>),
+    X(I, X),
+    Y(I, X),
+    XY(I, X, X),
+}
+
+impl_draw!(<T: Screen, I: Draw<T>, X: Into<Option<T::Unit>>,>|self: Pull<T, I, X>, to: T|{
+    todo!()
+});
+
+/// Only draw content if area is above a certain size.
+///
+/// ```
+/// let min = tengri::wh_min(3, 5, "Hello"); // 5x5
+/// ```
+pub enum Min<T: Screen, I: Draw<T>, X: Into<Option<T::Unit>>> {
+    __(PhantomData<T>),
+    W(I, X),
+    H(I, X),
+    WH(I, X, X),
+}
+
+impl_draw!(<T: Screen, I: Draw<T>, X: Into<Option<T::Unit>>,>|self: Min<T, I, X>, to: T|{
+    todo!()
+});
+
+/// Set maximum size of of drawing area.
+///
+/// ```
+/// let max = tengri::w_max(3, "Hello");
+/// let max = tengri::w_max(None, "Hello");
+/// let max = tengri::w_max(Some(3), "Hello");
+/// ```
+pub enum Max<T: Screen, I: Draw<T>, X: Into<Option<T::Unit>>> {
+    __(PhantomData<T>),
+    W(I, X),
+    H(I, X),
+    WH(I, X, X),
+}
+
+impl_draw!(<T: Screen, I: Draw<T>, X: Into<Option<T::Unit>>,>|self: Max<T, I, X>, to: T|{
+    todo!()
+});
+
+/// Set size of of drawing area.
+///
+/// ```
+/// let max = tengri::w_max(3, "Hello");
+/// let max = tengri::w_max(None, "Hello");
+/// let max = tengri::w_max(Some(3), "Hello");
+/// ```
+pub enum Exact<T: Screen, I: Draw<T>, X: Into<Option<T::Unit>>> {
+    __(PhantomData<T>),
+    W(I, X),
+    H(I, X),
+    WH(I, X, X),
+}
+
+impl_draw!(<T: Screen, I: Draw<T>, X: Into<Option<T::Unit>>,>|self: Exact<T, I, X>, to: T|{
+    todo!()
+});
+
+/// Define inner drawing area.
+///
+/// ```
+/// let max = tengri::w_max(3, "Hello");
+/// let max = tengri::w_max(None, "Hello");
+/// let max = tengri::w_max(Some(3), "Hello");
+/// ```
+pub enum Pad<T: Screen, I: Draw<T>, X: Into<Option<T::Unit>>> {
+    __(PhantomData<T>),
+    W(I, X),
+    H(I, X),
+    WH(I, X, X),
+}
+
+impl_draw!(<T: Screen, I: Draw<T>, X: Into<Option<T::Unit>>,>|self: Pad<T, I, X>, to: T|{
+    todo!()
 });
diff --git a/src/draw/xywh.rs b/src/draw/xywh.rs
index c831d14..ebe866f 100644
--- a/src/draw/xywh.rs
+++ b/src/draw/xywh.rs
@@ -113,129 +113,3 @@ impl<N: Coord, T: Wide<N> + Tall<N>> Wh<N> for T {
 }
 
 impl<N: Coord, T: Xy<N> + Wh<N>> Xywh<N> for T {}
-
-/// Shrink drawing area symmetrically.
-///
-/// ```
-/// let padded = tengri::wh_pad("Hello");
-/// ```
-pub const fn wh_pad <T: Screen> (w: T::Unit, h: T::Unit, it: impl Draw<T>)
-    -> impl Draw<T>
-{
-    thunk(move|to: &mut T|it.draw(todo!()))
-}
-
-/// Only draw content if area is above a certain size.
-///
-/// ```
-/// let min = tengri::wh_min(3, 5, "Hello"); // 5x5
-/// ```
-pub const fn wh_min <T: Screen> (w: Option<T::Unit>, h: Option<T::Unit>, it: impl Draw<T>)
-    -> impl Draw<T>
-{
-    thunk(move|to: &mut T|it.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 wh_max <T: Screen> (w: Option<T::Unit>, h: Option<T::Unit>, it: impl Draw<T>)
-    -> impl Draw<T>
-{
-    thunk(move|_to: &mut T|it.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 wh_exact <T: Screen> (w: Option<T::Unit>, h: Option<T::Unit>, it: impl Draw<T>)
-    -> impl Draw<T>
-{
-    thunk(move|_to: &mut T|it.draw(todo!()))
-}
-
-/// Limit size of drawing area
-/// ```
-/// let clipped = tengri::wh_clip(Some(3), Some(5), "Hello");
-/// ```
-pub const fn wh_clip <T: Screen> (
-    w: Option<T::Unit>, h: Option<T::Unit>, it: impl Draw<T>
-) -> impl Draw<T> {
-    thunk(move|_to: &mut T|it.draw(todo!()))
-}
-
-pub const fn wh_full <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
-    todo!();
-    a
-}
-
-pub const fn w_full <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
-    todo!();
-    a
-}
-
-pub const fn h_full <T: Screen> (a: impl Draw<T>) -> impl Draw<T> {
-    todo!();
-    a
-}
-
-pub const fn h_max <T: Screen> (h: Option<T::Unit>, a: impl Draw<T>) -> impl Draw<T> {
-    wh_max(None, h, a)
-}
-pub const fn h_min <T: Screen> (h: Option<T::Unit>, a: impl Draw<T>) -> impl Draw<T> {
-    wh_min(None, h, a)
-}
-pub const fn h_exact <T: Screen> (h: T::Unit, c: impl Draw<T>) -> impl Draw<T> {
-    wh_exact(None, Some(h), c)
-}
-pub const fn w_max <T: Screen> (w: Option<T::Unit>, a: impl Draw<T>) -> impl Draw<T> {
-    wh_max(w, None, a)
-}
-pub const fn w_min <T: Screen> (w: Option<T::Unit>, a: impl Draw<T>) -> impl Draw<T> {
-    wh_min(w, None, a)
-}
-pub const fn w_exact <T: Screen> (w: T::Unit, c: impl Draw<T>) -> impl Draw<T> {
-    wh_exact(Some(w), None, c)
-}
-/// Shrink drawing area symmetrically.
-///
-/// ```
-/// let padded = tengri::space::w_pad(3, "Hello");
-/// ```
-pub const fn w_pad <T: Screen> (x: T::Unit, draw: impl Draw<T>) -> impl Draw<T> {
-    thunk(move|to: &mut T|draw.draw(todo!()))
-}
-/// Shrink drawing area symmetrically.
-///
-/// ```
-/// let padded = tengri::space::w_pad(3, "Hello");
-/// ```
-pub const fn h_pad <T: Screen> (x: T::Unit, draw: impl Draw<T>) -> impl Draw<T> {
-    thunk(move|to: &mut T|draw.draw(todo!()))
-}
-
-pub const fn xy_push <T: Screen> (x: T::Unit, y: T::Unit, a: impl Draw<T>) -> impl Draw<T> {
-    a
-}
-
-pub const fn xy_pull <T: Screen> (x: T::Unit, y: T::Unit, a: impl Draw<T>) -> impl Draw<T> {
-    a
-}
-
-pub const fn x_push <T: Screen> (x: T::Unit, a: impl Draw<T>) -> impl Draw<T> {
-    a
-}
-pub const fn x_pull <T: Screen> (x: T::Unit, a: impl Draw<T>) -> impl Draw<T> {
-    a
-}
-
-pub const fn y_push <T: Screen> (x: T::Unit, a: impl Draw<T>) -> impl Draw<T> {
-    a
-}
-pub const fn y_pull <T: Screen> (x: T::Unit, a: impl Draw<T>) -> impl Draw<T> {
-    a
-}
diff --git a/src/eval.rs b/src/eval.rs
index b3d0a4f..6e6b8c4 100644
--- a/src/eval.rs
+++ b/src/eval.rs
@@ -14,23 +14,25 @@ macro_rules! eval_xy ((
         Some("xy") | None => $arg2,
         _ => panic!("{}: unsupported axis {variant:?}; try /x, /y, /xy", $name)
     }));
+
     match variant {
+
         // XY variant (can be omitted)
-        Some("xy") | None => xy_push(
-            $state.namespace($arg0?)?.unwrap(),
-            $state.namespace($arg1?)?.unwrap(),
-            cb
+        Some("xy") | None => cb.push_xy(
+            $state.namespace($arg0?)?,
+            $state.namespace($arg1?)?,
         ).draw($output),
+
         // X variant
-        Some("x") => x_push(
-            $state.namespace($arg0?)?.unwrap(),
-            cb
+        Some("x") => cb.push_x(
+            $state.namespace($arg0?)?,
         ).draw($output),
+
         // Y variant
-        Some("y") => y_push(
-            $state.namespace($arg0?)?.unwrap(),
-            cb
+        Some("y") => cb.push_y(
+            $state.namespace($arg0?)?,
         ).draw($output),
+
         // Other namespace members are invalid
         frag => {
             let name = $name;
@@ -41,6 +43,7 @@ macro_rules! eval_xy ((
                 head.src()?.unwrap_or_default().split("/").next()
             )
         }
+
     }
 }});
 
diff --git a/src/term/border.rs b/src/term/border.rs
index e8c984a..81aa69d 100644
--- a/src/term/border.rs
+++ b/src/term/border.rs
@@ -5,8 +5,8 @@ use super::*;
 /// ```
 /// /// TODO
 /// ```
-pub const fn border (on: bool, style: impl BorderStyle, draw: impl Draw<Tui>) -> impl Draw<Tui> {
-    let content = wh_pad(1, 1, draw);
+pub fn border (on: bool, style: impl BorderStyle, draw: impl Draw<Tui>) -> impl Draw<Tui> {
+    let content = draw.pad_wh(1, 1);
     let outline = when(on, thunk(move|to: &mut Tui|{
         let XYWH(x, y, w, h) = to.1;
         if w > 0 && h > 0 {
diff --git a/src/term/output.rs b/src/term/output.rs
index eefb9e8..e0ff044 100644
--- a/src/term/output.rs
+++ b/src/term/output.rs
@@ -165,11 +165,11 @@ mod phat {
     pub const HI: &'static str = "▀";
     /// A phat line
     pub fn lo (fg: Color, bg: Color) -> impl Draw<Tui> {
-        h_exact(1, fg_bg(fg, bg, x_repeat(self::phat::LO)))
+        fg_bg(fg, bg, x_repeat(self::phat::LO)).exact_h(1)
     }
     /// A phat line
     pub fn hi (fg: Color, bg: Color) -> impl Draw<Tui> {
-        h_exact(1, fg_bg(fg, bg, x_repeat(self::phat::HI)))
+        fg_bg(fg, bg, x_repeat(self::phat::HI)).exact_h(1)
     }
 }
 
@@ -253,10 +253,10 @@ pub const fn button_3 <'a> (
 /// /// TODO
 /// ```
 pub fn phat (w: u16, h: u16, [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 top = self::phat::lo(bg, hi).exact_h(1);
+    let low = self::phat::hi(bg, lo).exact_h(1);
     let draw = fg_bg(fg, bg, draw);
-    wh_min(Some(w), Some(h), south(top, north(low, draw)))
+    south(top, north(low, draw)).min_wh(w, h)
 }
 
 fn x_scroll () -> impl Draw<Tui> {

From 13c886d9e05a8df712461d44025196ae9be51b78 Mon Sep 17 00:00:00 2001
From: facile pop culture reference <donotem@ilme.no>
Date: Fri, 10 Jul 2026 18:24:44 +0300
Subject: [PATCH 24/25] add origin and align methods to Layout trait

---
 examples/tui_00.rs     |  10 +--
 src/draw.rs            |  36 ++++----
 src/draw/align.rs      |  31 -------
 src/draw/area.rs       |  17 ----
 src/draw/azimuth.rs    |  12 ---
 src/draw/coord.rs      |   2 +-
 src/draw/iter.rs       |   9 --
 src/draw/layout.rs     | 192 ++++++++++++++++++++++++++++++++++++-----
 src/draw/origin.rs     |  42 ---------
 src/draw/split.rs      |  33 +++++--
 src/draw/thunk.rs      |  14 +--
 src/draw/xywh.rs       |   4 +-
 src/eval.rs            | 124 +++++++++++++++-----------
 src/sing.rs            |   2 +-
 src/sing/jack.rs       |   6 +-
 src/sing/jack_event.rs |   4 +-
 src/term.rs            |   2 +-
 src/term/output.rs     |  41 +++++----
 18 files changed, 333 insertions(+), 248 deletions(-)
 delete mode 100644 src/draw/align.rs
 delete mode 100644 src/draw/area.rs
 delete mode 100644 src/draw/azimuth.rs
 delete mode 100644 src/draw/origin.rs

diff --git a/examples/tui_00.rs b/examples/tui_00.rs
index 1ac73c5..8aedd9f 100644
--- a/examples/tui_00.rs
+++ b/examples/tui_00.rs
@@ -1,7 +1,7 @@
 use ::{
     std::{io::stdout, sync::{Arc, RwLock}},
-    tengri::{*, term::*, lang::*, keys::*, draw::*, space::*, lang::*},
     ratatui::style::Color,
+    tengri::{*, lang::*},
 };
 
 tui_main!(State {
@@ -18,10 +18,10 @@ tui_view!(|self: State| {
     let wh      = (self.size.w(), self.size.h());
     let src     = VIEWS.get(self.cursor).unwrap_or(&"");
     let heading = format!("State {}/{} in {:?}", index, VIEWS.len(), &wh);
-    let title   = bg(Color::Rgb(60, 10, 10), y_push(1, align_n(heading)));
-    let code    = bg(Color::Rgb(10, 60, 10), y_push(2, align_n(format!("{}", src))));
+    let title   = bg(Color::Rgb(60, 10, 10), heading.align_n().push_y(1));
+    let code    = bg(Color::Rgb(10, 60, 10), format!("{}", src).align_n().push_y(2));
     //let content = ;//();//bg(Color::Rgb(10, 10, 60), View(self, CstIter::new(src)));
-    let widget  = thunk(move|to: &mut Tui|self.interpret(to, &src));
+    let widget  = thunk(move|to: &mut Tui|self.interpret(to, &src).map(Some));
     self.size.of(south(title, north(code, widget)))
 });
 
@@ -32,7 +32,7 @@ struct State {
     /** User-controllable value. */
     cursor: usize,
     /** Rendered window size. */
-    size: crate::space::Size,
+    size: Sizer,
 }
 
 impl Interpret<Tui, XYWH<u16>> for State {
diff --git a/src/draw.rs b/src/draw.rs
index c5e895a..64738bd 100644
--- a/src/draw.rs
+++ b/src/draw.rs
@@ -3,32 +3,34 @@ use crate::*;
 /// Output target.
 ///
 /// ```
-/// use tengri::{*, draw::*};
-///
-/// struct TestOut<T: Screen<Unit = u16>>(T);
-///
-/// impl<T: Screen<Unit = u16>> Screen for TestOut {
+/// use tengri::*;
+/// struct TestOut { w: u16, h: u16 };
+/// impl Wide<u16> for TestOut {}
+/// impl Tall<u16> for TestOut {}
+/// impl Xy<u16> for TestOut { fn x (&self) -> u16 { 0 } fn y (&self) -> u16 { 0 } }
+/// impl Screen for TestOut {
 ///     type Unit = u16;
-///     fn show <D: Draw<Self> + ?Sized> (&mut self, _: D) {
+///     fn show <D: Draw<Self>> (&mut self, _: D) -> Drawn<u16> {
 ///         println!("placed");
-///         ()
+///         Ok(None)
 ///     }
 /// }
 ///
-/// impl_draw!(|self: String, to: TestOut<u16>|{
-///    to.area_mut().set_w(self.len() as u16);
+/// impl_draw!(|self: String, to: TestOut|{
+///     to.w = self.len() as u16;
+///     Ok(None)
 /// });
 /// ```
 pub trait Screen: Xy<Self::Unit> + Wh<Self::Unit> + Send + Sync + Sized {
     type Unit: Coord;
     /// Render drawable in subarea specified by `area`
-    fn show <'t, T: Draw<Self>> (&mut self, content: T) -> Perhaps<XYWH<Self::Unit>>;
+    fn show <T: Draw<Self>> (&mut self, content: T) -> Perhaps<XYWH<Self::Unit>>;
 }
 
 /// Implement the [Draw] trait for a particular drawable and [Screen].
 ///
 /// ```
-/// use tengri::{*, draw::*, term::*};
+/// use tengri::*;
 /// struct MyDrawable;
 /// impl_draw!(|self: MyDrawable, to: Tui|{
 ///     todo!("your draw logic")
@@ -60,7 +62,7 @@ pub trait Screen: Xy<Self::Unit> + Wh<Self::Unit> + Send + Sync + Sized {
 /// a [Draw]able.
 ///
 /// ```
-/// use tengri::{*, draw::*, term::*};
+/// use tengri::*;
 /// struct MyWidget(bool);
 /// impl Draw<Tui> for MyWidget {
 ///     fn draw (self, to: &mut Tui) -> Perhaps<XYWH<u16>> {
@@ -106,6 +108,12 @@ pub trait View<T: Screen> {
     fn view (&self) -> impl Draw<T>;
 }
 
+impl<T: Screen> View<T> for () {
+    fn view (&self) -> impl Draw<T> {
+        ()
+    }
+}
+
 impl<T: Screen, V: View<T>> Draw<T> for &V {
     fn draw (self, to: &mut T) -> Perhaps<XYWH<T::Unit>> {
         self.view().draw(to)
@@ -114,15 +122,11 @@ impl<T: Screen, V: View<T>> Draw<T> for &V {
 
 features! {
     "draw": [
-        align,
-        area,
-        azimuth,
         color,
         coord,
         iter,
         layout,
         lrtb,
-        origin,
         sizer,
         space,
         split,
diff --git a/src/draw/align.rs b/src/draw/align.rs
deleted file mode 100644
index 8e4ebb1..0000000
--- a/src/draw/align.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-use crate::*;
-
-pub struct Align<T>(Option<Azimuth>, T);
-
-impl_draw!(<S: Screen, T: Draw<S>,>|self: Align<T>, to: S|{
-    todo!()
-});
-
-/// ```
-/// use tengri::*;
-/// let _ = align(None, "unaligned");
-/// let _ = align(Azimuth::SE, "southeast");
-/// let _ = align(Some(Azimuth::SE), "southeast");
-/// ```
-pub fn align <S: Screen, T: Draw<S>, U: Into<Option<Azimuth>>> (origin: U, it: T) -> Align<T> {
-    Align(origin.into(), it)
-}
-
-pub fn align_c <S: Screen, T: Draw<S>> (it: T) -> Align<T> { Align(Some(Azimuth::C), it) }
-pub fn align_x <S: Screen, T: Draw<S>> (it: T) -> Align<T> { Align(Some(Azimuth::X), it) }
-pub fn align_y <S: Screen, T: Draw<S>> (it: T) -> Align<T> { Align(Some(Azimuth::Y), it) }
-
-pub fn align_n <S: Screen, T: Draw<S>> (it: T) -> Align<T> { Align(Some(Azimuth::N), it) }
-pub fn align_s <S: Screen, T: Draw<S>> (it: T) -> Align<T> { Align(Some(Azimuth::S), it) }
-pub fn align_e <S: Screen, T: Draw<S>> (it: T) -> Align<T> { Align(Some(Azimuth::E), it) }
-pub fn align_w <S: Screen, T: Draw<S>> (it: T) -> Align<T> { Align(Some(Azimuth::W), it) }
-
-pub fn align_ne <S: Screen, T: Draw<S>> (it: T) -> Align<T> { Align(Some(Azimuth::NE), it) }
-pub fn align_se <S: Screen, T: Draw<S>> (it: T) -> Align<T> { Align(Some(Azimuth::SE), it) }
-pub fn align_nw <S: Screen, T: Draw<S>> (it: T) -> Align<T> { Align(Some(Azimuth::NW), it) }
-pub fn align_sw <S: Screen, T: Draw<S>> (it: T) -> Align<T> { Align(Some(Azimuth::SW), it) }
diff --git a/src/draw/area.rs b/src/draw/area.rs
deleted file mode 100644
index 58e8b6c..0000000
--- a/src/draw/area.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-use crate::*;
-
-/// ```
-/// use tengri::*;
-/// let _ = area(None, "unareaed");
-/// let _ = area([1, 2, 3, 4], "southeast");
-/// let _ = area(Some([1, 2, 3, 4]), "southeast");
-/// ```
-pub fn area <S: Screen, T: Draw<S>, U: Into<Option<XYWH<S::Unit>>>> (
-    origin: U, it: T
-) -> Area<S, T> {
-    Area(origin.into(), it)
-}
-
-pub struct Area<S: Screen, T: Draw<S>>(Option<XYWH<S::Unit>>, T);
-
-impl_draw!(<S: Screen, T: Draw<S>,>|self: Area<S, T>, to: S|{ todo!() });
diff --git a/src/draw/azimuth.rs b/src/draw/azimuth.rs
deleted file mode 100644
index de72abc..0000000
--- a/src/draw/azimuth.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-use crate::*;
-
-/// Where is [0, 0] located?
-///
-/// ```
-/// use tengri::draw::Azimuth;
-/// let _ = Azimuth::NW.align(());
-/// ```
-#[cfg_attr(test, derive(Arbitrary))]
-#[derive(Debug, Copy, Clone, Default)] pub enum Azimuth {
-    #[default] C, X, Y, NW, N, NE, E, SE, S, SW, W
-}
diff --git a/src/draw/coord.rs b/src/draw/coord.rs
index f5e6974..40d784d 100644
--- a/src/draw/coord.rs
+++ b/src/draw/coord.rs
@@ -6,7 +6,7 @@ use super::*;
 /// FIXME: Use AsRef/AsMut?
 ///
 /// ```
-/// use tengri::draw::Coord;
+/// use tengri::*;
 /// let a: u16 = Coord::zero();
 /// let b: u16 = a.plus(1);
 /// let c: u16 = a.minus(2);
diff --git a/src/draw/iter.rs b/src/draw/iter.rs
index 1e5fa38..1bbdcfa 100644
--- a/src/draw/iter.rs
+++ b/src/draw/iter.rs
@@ -15,15 +15,6 @@ pub fn iter_once <'a, S: Screen, D: 'a, U: Draw<S>> (
 }
 
 /// Iterate over a collection of various [Draw]ables:
-///
-/// ```
-/// 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_dyn <
     S: Screen,              // Target screen
     D,                      // Input doesn't need to be [Draw]able, output does
diff --git a/src/draw/layout.rs b/src/draw/layout.rs
index d1728bb..71dca39 100644
--- a/src/draw/layout.rs
+++ b/src/draw/layout.rs
@@ -70,11 +70,96 @@ pub trait Layout<S: Screen>: Draw<S> + Sized {
     fn push_xy <N: Into<Option<S::Unit>>> (self, x: N, y: N) -> impl Draw<S> {
         Push::XY(self, x.into(), y.into())
     }
+
+    fn align (self, azimuth: impl Into<Option<Azimuth>>) -> impl Draw<S> {
+        Align(azimuth.into(), self)
+    }
+    fn align_c (self) -> impl Draw<S> {
+        Align(Some(Azimuth::C), self)
+    }
+    fn align_x (self) -> impl Draw<S> {
+        Align(Some(Azimuth::X), self)
+    }
+    fn align_y (self) -> impl Draw<S> {
+        Align(Some(Azimuth::Y), self)
+    }
+
+    fn align_n (self) -> impl Draw<S> {
+        Align(Some(Azimuth::N), self)
+    }
+    fn align_s (self) -> impl Draw<S> {
+        Align(Some(Azimuth::S), self)
+    }
+    fn align_e (self) -> impl Draw<S> {
+        Align(Some(Azimuth::E), self)
+    }
+    fn align_w (self) -> impl Draw<S> {
+        Align(Some(Azimuth::W), self)
+    }
+
+    fn align_ne (self) -> impl Draw<S> {
+        Align(Some(Azimuth::NE), self)
+    }
+    fn align_se (self) -> impl Draw<S> {
+        Align(Some(Azimuth::SE), self)
+    }
+    fn align_nw (self) -> impl Draw<S> {
+        Align(Some(Azimuth::NW), self)
+    }
+    fn align_sw (self) -> impl Draw<S> {
+        Align(Some(Azimuth::SW), self)
+    }
+
+    fn origin (self, azimuth: impl Into<Option<Azimuth>>) -> impl Draw<S> {
+        Origin(azimuth.into(), self)
+    }
+    fn origin_c (self) -> impl Draw<S> {
+        Origin(Some(Azimuth::C), self)
+    }
+    fn origin_x (self) -> impl Draw<S> {
+        Origin(Some(Azimuth::X), self)
+    }
+    fn origin_y (self) -> impl Draw<S> {
+        Origin(Some(Azimuth::Y), self)
+    }
+
+    fn origin_n (self) -> impl Draw<S> {
+        Origin(Some(Azimuth::N), self)
+    }
+    fn origin_s (self) -> impl Draw<S> {
+        Origin(Some(Azimuth::S), self)
+    }
+    fn origin_e (self) -> impl Draw<S> {
+        Origin(Some(Azimuth::E), self)
+    }
+    fn origin_w (self) -> impl Draw<S> {
+        Origin(Some(Azimuth::W), self)
+    }
+
+    fn origin_ne (self) -> impl Draw<S> {
+        Origin(Some(Azimuth::NE), self)
+    }
+    fn origin_se (self) -> impl Draw<S> {
+        Origin(Some(Azimuth::SE), self)
+    }
+    fn origin_nw (self) -> impl Draw<S> {
+        Origin(Some(Azimuth::NW), self)
+    }
+    fn origin_sw (self) -> impl Draw<S> {
+        Origin(Some(Azimuth::SW), self)
+    }
 }
 
 impl<S: Screen, T: Draw<S>> Layout<S> for T {}
 
 /// Use whole drawing area along one or both axes.
+///
+/// ```
+/// use tengri::Layout;
+/// let _ = "".full_w();
+/// let _ = "".full_h();
+/// let _ = "".full_wh();
+/// ```
 pub enum Full<T: Screen, I: Draw<T>> {
     __(PhantomData<T>),
     W(I),
@@ -82,14 +167,17 @@ pub enum Full<T: Screen, I: Draw<T>> {
     WH(I),
 }
 
-impl_draw!(<T: Screen, I: Draw<T>,>|self: Full<T, I>, to: T|{
+impl_draw!(<T: Screen, I: Draw<T>,>|self: Full<T, I>, _to: T|{
     todo!()
 });
 
-/// Only draw content if area is above a certain size.
+/// Move content in the positive direction of one or both axes.
 ///
 /// ```
-/// let min = tengri::wh_min(3, 5, "Hello"); // 5x5
+/// use tengri::Layout;
+/// let _ = "".push_x(1);
+/// let _ = "".push_y(1);
+/// let _ = "".push_xy(1, 1);
 /// ```
 pub enum Push<T: Screen, I: Draw<T>, X: Into<Option<T::Unit>>> {
     __(PhantomData<T>),
@@ -98,14 +186,17 @@ pub enum Push<T: Screen, I: Draw<T>, X: Into<Option<T::Unit>>> {
     XY(I, X, X),
 }
 
-impl_draw!(<T: Screen, I: Draw<T>, X: Into<Option<T::Unit>>,>|self: Push<T, I, X>, to: T|{
+impl_draw!(<T: Screen, I: Draw<T>, X: Into<Option<T::Unit>>,>|self: Push<T, I, X>, _to: T|{
     todo!()
 });
 
-/// Only draw content if area is above a certain size.
+/// Move content in the negative direction of one or both axes.
 ///
 /// ```
-/// let min = tengri::wh_min(3, 5, "Hello"); // 5x5
+/// use tengri::Layout;
+/// let _ = "".pull_x(1);
+/// let _ = "".pull_y(1);
+/// let _ = "".pull_xy(1, 1);
 /// ```
 pub enum Pull<T: Screen, I: Draw<T>, X: Into<Option<T::Unit>>> {
     __(PhantomData<T>),
@@ -114,14 +205,17 @@ pub enum Pull<T: Screen, I: Draw<T>, X: Into<Option<T::Unit>>> {
     XY(I, X, X),
 }
 
-impl_draw!(<T: Screen, I: Draw<T>, X: Into<Option<T::Unit>>,>|self: Pull<T, I, X>, to: T|{
+impl_draw!(<T: Screen, I: Draw<T>, X: Into<Option<T::Unit>>,>|self: Pull<T, I, X>, _to: T|{
     todo!()
 });
 
 /// Only draw content if area is above a certain size.
 ///
 /// ```
-/// let min = tengri::wh_min(3, 5, "Hello"); // 5x5
+/// use tengri::Layout;
+/// let _ = "".min_w(1);
+/// let _ = "".min_h(1);
+/// let _ = "".min_wh(1, 1);
 /// ```
 pub enum Min<T: Screen, I: Draw<T>, X: Into<Option<T::Unit>>> {
     __(PhantomData<T>),
@@ -130,16 +224,17 @@ pub enum Min<T: Screen, I: Draw<T>, X: Into<Option<T::Unit>>> {
     WH(I, X, X),
 }
 
-impl_draw!(<T: Screen, I: Draw<T>, X: Into<Option<T::Unit>>,>|self: Min<T, I, X>, to: T|{
+impl_draw!(<T: Screen, I: Draw<T>, X: Into<Option<T::Unit>>,>|self: Min<T, I, X>, _to: T|{
     todo!()
 });
 
 /// Set maximum size of of drawing area.
 ///
 /// ```
-/// let max = tengri::w_max(3, "Hello");
-/// let max = tengri::w_max(None, "Hello");
-/// let max = tengri::w_max(Some(3), "Hello");
+/// use tengri::Layout;
+/// let _ = "".max_w(1);
+/// let _ = "".max_h(1);
+/// let _ = "".max_wh(1, 1);
 /// ```
 pub enum Max<T: Screen, I: Draw<T>, X: Into<Option<T::Unit>>> {
     __(PhantomData<T>),
@@ -148,16 +243,17 @@ pub enum Max<T: Screen, I: Draw<T>, X: Into<Option<T::Unit>>> {
     WH(I, X, X),
 }
 
-impl_draw!(<T: Screen, I: Draw<T>, X: Into<Option<T::Unit>>,>|self: Max<T, I, X>, to: T|{
+impl_draw!(<T: Screen, I: Draw<T>, X: Into<Option<T::Unit>>,>|self: Max<T, I, X>, _to: T|{
     todo!()
 });
 
 /// Set size of of drawing area.
 ///
 /// ```
-/// let max = tengri::w_max(3, "Hello");
-/// let max = tengri::w_max(None, "Hello");
-/// let max = tengri::w_max(Some(3), "Hello");
+/// use tengri::Layout;
+/// let _ = "".exact_w(1);
+/// let _ = "".exact_h(1);
+/// let _ = "".exact_wh(1, 1);
 /// ```
 pub enum Exact<T: Screen, I: Draw<T>, X: Into<Option<T::Unit>>> {
     __(PhantomData<T>),
@@ -166,16 +262,17 @@ pub enum Exact<T: Screen, I: Draw<T>, X: Into<Option<T::Unit>>> {
     WH(I, X, X),
 }
 
-impl_draw!(<T: Screen, I: Draw<T>, X: Into<Option<T::Unit>>,>|self: Exact<T, I, X>, to: T|{
+impl_draw!(<T: Screen, I: Draw<T>, X: Into<Option<T::Unit>>,>|self: Exact<T, I, X>, _to: T|{
     todo!()
 });
 
 /// Define inner drawing area.
 ///
 /// ```
-/// let max = tengri::w_max(3, "Hello");
-/// let max = tengri::w_max(None, "Hello");
-/// let max = tengri::w_max(Some(3), "Hello");
+/// use tengri::Layout;
+/// let _ = "".pad_w(1);
+/// let _ = "".pad_h(1);
+/// let _ = "".pad_wh(1, 1);
 /// ```
 pub enum Pad<T: Screen, I: Draw<T>, X: Into<Option<T::Unit>>> {
     __(PhantomData<T>),
@@ -184,6 +281,59 @@ pub enum Pad<T: Screen, I: Draw<T>, X: Into<Option<T::Unit>>> {
     WH(I, X, X),
 }
 
-impl_draw!(<T: Screen, I: Draw<T>, X: Into<Option<T::Unit>>,>|self: Pad<T, I, X>, to: T|{
+impl_draw!(<T: Screen, I: Draw<T>, X: Into<Option<T::Unit>>,>|self: Pad<T, I, X>, _to: T|{
     todo!()
 });
+
+pub struct Align<T>(Option<Azimuth>, T);
+
+impl_draw!(<S: Screen, T: Draw<S>,>|self: Align<T>, _to: S|{
+    todo!()
+});
+
+/// Where is [0, 0] located?
+///
+/// ```
+/// use tengri::*;
+/// use Azimuth::*;
+/// let _ = "".align(NW);
+/// ```
+#[cfg_attr(test, derive(Arbitrary))]
+#[derive(Debug, Copy, Clone, Default)] pub enum Azimuth {
+    #[default] C, X, Y, NW, N, NE, E, SE, S, SW, W
+}
+
+/// ```
+/// use tengri::*;
+/// let _ = area(None, "unareaed");
+/// let _ = area(XYWH(1, 2, 3, 4), "southeast");
+/// let _ = area(Some(XYWH(1, 2, 3, 4)), "southeast");
+/// ```
+pub fn area <S: Screen, T: Draw<S>, U: Into<Option<XYWH<S::Unit>>>> (
+    origin: U, it: T
+) -> Area<S, T> {
+    Area(origin.into(), it)
+}
+
+pub struct Area<S: Screen, T: Draw<S>>(Option<XYWH<S::Unit>>, T);
+
+impl_draw!(<S: Screen, T: Draw<S>,>|self: Area<S, T>, _to: S|{
+    todo!()
+});
+
+pub struct Origin<T>(Option<Azimuth>, T);
+
+impl_draw!(<S: Screen, T: Draw<S>,>|self: Origin<T>, _to: S|{
+    todo!()
+});
+
+/// Something that has `[0, 0]` at a particular point.
+pub trait HasOrigin {
+    fn origin (&self) -> Azimuth;
+}
+
+impl<T: AsRef<Azimuth>> HasOrigin for T {
+    fn origin (&self) -> Azimuth {
+        *self.as_ref()
+    }
+}
diff --git a/src/draw/origin.rs b/src/draw/origin.rs
deleted file mode 100644
index da47996..0000000
--- a/src/draw/origin.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-use crate::*;
-
-pub struct Origin<T>(Option<Azimuth>, T);
-
-impl_draw!(<S: Screen, T: Draw<S>,>|self: Origin<T>, to: S|{
-    todo!()
-});
-
-/// ```
-/// use tengri::*;
-/// let _ = origin(None, "origin unspecified");
-/// let _ = origin(Azimuth::SE, "southeast");
-/// let _ = origin(Some(Azimuth::SE), "southeast");
-/// ```
-pub fn origin <S: Screen, T: Draw<S>, U: Into<Option<Azimuth>>> (origin: U, it: T) -> Origin<T> {
-    Origin(origin.into(), it)
-}
-
-pub fn origin_c <S: Screen, T: Draw<S>> (it: T) -> Origin<T> { Origin(Some(Azimuth::C), it) }
-pub fn origin_x <S: Screen, T: Draw<S>> (it: T) -> Origin<T> { Origin(Some(Azimuth::X), it) }
-pub fn origin_y <S: Screen, T: Draw<S>> (it: T) -> Origin<T> { Origin(Some(Azimuth::Y), it) }
-
-pub fn origin_n <S: Screen, T: Draw<S>> (it: T) -> Origin<T> { Origin(Some(Azimuth::N), it) }
-pub fn origin_s <S: Screen, T: Draw<S>> (it: T) -> Origin<T> { Origin(Some(Azimuth::S), it) }
-pub fn origin_e <S: Screen, T: Draw<S>> (it: T) -> Origin<T> { Origin(Some(Azimuth::E), it) }
-pub fn origin_w <S: Screen, T: Draw<S>> (it: T) -> Origin<T> { Origin(Some(Azimuth::W), it) }
-
-pub fn origin_ne <S: Screen, T: Draw<S>> (it: T) -> Origin<T> { Origin(Some(Azimuth::NE), it) }
-pub fn origin_se <S: Screen, T: Draw<S>> (it: T) -> Origin<T> { Origin(Some(Azimuth::SE), it) }
-pub fn origin_nw <S: Screen, T: Draw<S>> (it: T) -> Origin<T> { Origin(Some(Azimuth::NW), it) }
-pub fn origin_sw <S: Screen, T: Draw<S>> (it: T) -> Origin<T> { Origin(Some(Azimuth::SW), it) }
-
-/// Something that has `[0, 0]` at a particular point.
-pub trait HasOrigin {
-    fn origin (&self) -> Azimuth;
-}
-
-impl<T: AsRef<Azimuth>> HasOrigin for T {
-    fn origin (&self) -> Azimuth {
-        *self.as_ref()
-    }
-}
diff --git a/src/draw/split.rs b/src/draw/split.rs
index 3d64a75..37ef914 100644
--- a/src/draw/split.rs
+++ b/src/draw/split.rs
@@ -39,20 +39,20 @@ pub const fn below <T: Screen> (a: impl Draw<T>, b: impl Draw<T>) -> impl Draw<T
 impl Split {
 
     /// ```
-    /// use tengri::draw::Split::*;
-    /// let _ = Above.half("", "");
-    /// let _ = Below.half("", "");
-    /// let _ = North.half("", "");
-    /// let _ = South.half("", "");
-    /// let _ = East.half("", "");
-    /// let _ = West.half("", "");
+    /// use tengri::*;
+    /// let _ = Split::Above.half("", "");
+    /// let _ = Split::Below.half("", "");
+    /// let _ = Split::North.half("", "");
+    /// let _ = Split::South.half("", "");
+    /// let _ = Split::East.half("", "");
+    /// let _ = Split::West.half("", "");
     /// ```
     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();
-            let a = align(origin_a, a);
-            let b = align(origin_b, b);
+            let a = a.align(origin_a);
+            let b = b.align(origin_b);
             match self {
                 Self::Below => {
                     to.show(area(area_b, b))?;
@@ -95,6 +95,21 @@ impl Split {
         }
     }
 
+    ///// ```
+    ///// use tengri::*;
+    ///// let _ = Split::Below.iter([
+    /////     "Leftbar"
+    /////         .min_w(10).max_w(15).align(Azimuth::NW),
+    /////     "Rightbar"
+    /////         .min_w(10).max_w(12).align(Azimuth::NE),
+    /////     "Center"
+    /////         .min_w(20).max_w(40).align(Azimuth::C),
+    ///// ].iter());
+    ///// ```
+    //pub fn iter <S: Screen, T: Draw<S>> (&self, _: impl Iterator<Item = T>) {
+        //todo!()
+    //}
+
 }
 
 #[macro_export] macro_rules! north {
diff --git a/src/draw/thunk.rs b/src/draw/thunk.rs
index 7e98b20..af27f5b 100644
--- a/src/draw/thunk.rs
+++ b/src/draw/thunk.rs
@@ -12,9 +12,9 @@ impl<T: Screen, F: FnOnce(&mut T)->Perhaps<XYWH<T::Unit>>> Draw<T> for Thunk<T,
 /// Basic [Draw]able closure.
 ///
 /// ```
-/// # use tengri::{draw::*, term::*};
-/// # fn test () -> impl tengri::draw::Draw<tengri::term::Tui> {
-///     thunk(|to: &mut Tui|Ok(to.1))
+/// # use tengri::*;
+/// # fn test () -> impl Draw<Tui> {
+///     thunk(|to: &mut Tui|Ok(Some(to.1)))
 /// # }
 /// ```
 pub const fn thunk <T: Screen, F: FnOnce(&mut T)->Perhaps<XYWH<T::Unit>>> (
@@ -26,8 +26,8 @@ pub const fn thunk <T: Screen, F: FnOnce(&mut T)->Perhaps<XYWH<T::Unit>>> (
 /// Only render when condition is true.
 ///
 /// ```
-/// # use tengri::{draw::*, term::*};
-/// # fn test () -> impl tengri::draw::Draw<tengri::term::Tui> {
+/// # use tengri::*;
+/// # fn test () -> impl Draw<Tui> {
 ///     when(true, "Yes")
 /// # }
 /// ```
@@ -38,8 +38,8 @@ pub const fn when <T: Screen> (condition: bool, draw: impl Draw<T>) -> impl Draw
 /// Render one thing if a condition is true and another false.
 ///
 /// ```
-/// # use tengri::{draw::*, term::*};
-/// # fn test () -> impl tengri::draw::Draw<tengri::term::Tui> {
+/// # use tengri::*;
+/// # fn test () -> impl Draw<Tui> {
 ///     either(true, "Yes", "No")
 /// # }
 /// ```
diff --git a/src/draw/xywh.rs b/src/draw/xywh.rs
index ebe866f..5b308d1 100644
--- a/src/draw/xywh.rs
+++ b/src/draw/xywh.rs
@@ -31,9 +31,9 @@ pub trait Tall<N: Coord> {
 /// Point with size.
 ///
 /// ```
-/// use tengri::space::{XY, XYWH};
+/// # use tengri::*;
 /// let xywh = XYWH(0u16, 0, 0, 0);
-/// assert_eq!(XYWH(10u16, 10, 20, 20).center(), XY(20, 20));
+/// assert_eq!(XYWH(10u16, 10, 20, 20).center(), (20, 20));
 /// ```
 ///
 /// * [ ] TODO: origin field (determines at which corner/side is X0 Y0)
diff --git a/src/eval.rs b/src/eval.rs
index 6e6b8c4..423cb64 100644
--- a/src/eval.rs
+++ b/src/eval.rs
@@ -63,18 +63,19 @@ macro_rules! eval_enum ((
 /// Interpret layout operation.
 ///
 /// ```
-/// # use tengri::{lang::*, draw::*, eval::*, term::*};
+/// # use tengri::{*, lang::*};
 ///
 /// struct State {/*app-specific*/}
-/// impl<'b> Namespace<'b, bool> for State {}
 /// impl<'b> Namespace<'b, u16> for State {}
-/// impl Interpret<Tui, XYWH<u16>> for State {}
+/// impl<'b> Namespace<'b, bool> for State {}
+/// impl<'b> Namespace<'b, Option<u16>> for State {}
+/// impl Interpret<Tui, Option<XYWH<u16>>> for State {}
 ///
 /// # fn main () -> tengri::Usually<()> {
 /// let state = State {};
 /// let mut target = Tui::new(80, 25);
 /// eval_view(&state, &mut target, &"")?;
-/// eval_view(&state, &mut target, &"(when true (text hello))")?;
+/// eval_view(&state, &mut target, &"(whe true (text hello))")?;
 /// eval_view(&state, &mut target, &"(either true (text hello) (text world))")?;
 /// // TODO test all
 /// # Ok(()) }
@@ -108,43 +109,33 @@ pub fn eval_view <'a, O: Screen + 'a, S> (
 
         Some("when") => when(
             state.namespace(arg0?)?.unwrap(),
-            thunk(move|output: &mut O|{
-                state.interpret(output, &arg1)
-            })
+            thunk(move|output: &mut O|{state.interpret(output, &arg1)})
         ).draw(output),
 
         Some("either") => either(
             state.namespace(arg0?)?.unwrap(),
-            thunk(move|output: &mut O|{
-                state.interpret(output, &arg1)
-            }),
-            thunk(move|output: &mut O|{
-                state.interpret(output, &arg2)
-            }),
+            thunk(move|output: &mut O|{state.interpret(output, &arg1)}),
+            thunk(move|output: &mut O|{state.interpret(output, &arg2)}),
         ).draw(output),
 
         // Second `frags.next()` calls returns the namespace member.
         Some("bsp") => {
-            let direction = eval_enum!("bsp", output, state, frags.next(), arg0, Split {
+            eval_enum!("bsp", output, state, frags.next(), arg0, Split {
                 "n" => North,
                 "s" => South,
                 "e" => East,
                 "w" => West,
                 "a" => Above,
                 "b" => Below
-            });
-            direction.half(
-                thunk(move|output: &mut O|{
-                    state.interpret(output, &arg0)
-                }),
-                thunk(move|output: &mut O|{
-                    state.interpret(output, &arg1)
-                }),
+            }).half(
+                thunk(move|output: &mut O|{state.interpret(output, &arg0)}),
+                thunk(move|output: &mut O|{state.interpret(output, &arg1)}),
             ).draw(output)
         },
 
         Some("align") => {
-            let alignment = eval_enum!("align", output, state, frags.next(), arg0, Azimuth {
+            let content = thunk(move|output: &mut O|{state.interpret(output, &arg0)});
+            content.align(eval_enum!("align", output, state, frags.next(), arg0, Azimuth {
                 "c" => C,
                 "n" => N,
                 "s" => S,
@@ -152,11 +143,7 @@ pub fn eval_view <'a, O: Screen + 'a, S> (
                 "w" => W,
                 "x" => X,
                 "y" => Y
-            });
-            let content = thunk(move|output: &mut O|{
-                state.interpret(output, &arg0)
-            });
-            align(alignment, content).draw(output)
+            })).draw(output)
         },
 
         Some("exact") => eval_xy!(
@@ -187,21 +174,50 @@ pub fn eval_view <'a, O: Screen + 'a, S> (
 /// Interpret TUI-specific layout operation.
 ///
 /// ```
-/// use tengri::{lang::*, term::*, eval::*, ratatui::prelude::Color};
+/// use tengri::{*, lang::*, ratatui::prelude::Color};
 ///
+/// #[namespace(bool {})]
+/// #[namespace(u8:    try_to_u8)]
+/// #[namespace(u16:   try_to_u16)]
+/// #[namespace(Color: try_to_color)]
+/// #[interpret(Tui -> Option<XYWH<u16>>: try_eval_tui)]
 /// struct State;
-/// impl<'b> Namespace<'b, bool>    for State {}
-/// impl<'b> Namespace<'b, u16>     for State {}
-/// impl<'b> Namespace<'b, Color>   for State {}
-/// impl     Interpret<Tui, ()> for State {}
+/// tengri::lang::primitive!(u8: try_to_u8);
+/// tengri::lang::primitive!(u16: try_to_u16);
+/// tengri::lang::namespace!(State: bool {
+/// });
+/// tengri::lang::namespace!(State: u8 {
+///     literal = |x|try_to_u8(x);
+/// });
+/// tengri::lang::namespace!(State: u16 {
+///     literal = |x|try_to_u16(x);
+/// });
+/// tengri::lang::namespace!(State: Color {
+///     expression = |_state| {
+///         "g" (x: u8) => { ItemTheme::G[x as usize].base.term }
+///     };
+/// });
+/// tengri::lang::interpret!(|self: State, context: Tui, lang|->Option<XYWH<u16>>{
+///     expression = {
+///         "text" (...rest) => { todo!() }
+///     }
+/// });
+/// impl Interpret<Tui, Option<XYWH<u16>>> for State {
+///     fn interpret_expr <'a> (&'a self, _: &mut Tui, lang: &'a impl Expression)
+///         -> Usually<Option<XYWH<u16>>>
+///     {
+///         Ok(None)
+///     }
+/// }
+///
 /// # fn main () -> tengri::Usually<()> {
 /// let state = State;
-/// let mut out = Tui::default();
-/// tengri::eval::eval_view_tui(&state, &mut out, "")?;
-/// tengri::eval::eval_view_tui(&state, &mut out, "text Hello world!")?;
-/// tengri::eval::eval_view_tui(&state, &mut out, "fg (g 0) (text Hello world!)")?;
-/// tengri::eval::eval_view_tui(&state, &mut out, "bg (g 2) (text Hello world!)")?;
-/// tengri::eval::eval_view_tui(&state, &mut out, "(bg (g 3) (fg (g 4) (text Hello world!)))")?;
+/// let mut out = Tui::new(80, 25);
+/// eval_view_tui(&state, &mut out, "")?;
+/// eval_view_tui(&state, &mut out, "text Hello world!")?;
+/// eval_view_tui(&state, &mut out, "fg (g 0) (text Hello world!)")?;
+/// eval_view_tui(&state, &mut out, "bg (g 2) (text Hello world!)")?;
+/// eval_view_tui(&state, &mut out, "(bg (g 3) (fg (g 4) (text Hello world!)))")?;
 /// # Ok(()) }
 /// ```
 pub fn eval_view_tui <'a, S> (
@@ -231,22 +247,28 @@ pub fn eval_view_tui <'a, S> (
 
         Some("fg") => {
             let arg0 = arg0?.expect("fg: expected arg 0 (color)");
-            let color = Namespace::namespace(state, arg0)?.unwrap_or_else(||panic!("fg: {arg0:?}: not a color"));
-            output.show(fg(color, thunk(move|output: &mut Tui|{
-                state.interpret(output, &arg1)?;
-                // FIXME?: don't max out the used area?
-                Ok(Some(output.area().into()))
-            })))
+            if let Some(color) = Namespace::namespace(state, arg0)? {
+                output.show(fg(color, thunk(move|output: &mut Tui|{
+                    state.interpret(output, &arg1)?;
+                    // FIXME?: don't max out the used area?
+                    Ok(Some(output.area().into()))
+                })))
+            } else {
+                return Err(format!("fg: {arg0:?}: not a color").into())
+            }
         },
 
         Some("bg") => {
             let arg0 = arg0?.expect("bg: expected arg 0 (color)");
-            let color = Namespace::namespace(state, arg0)?.unwrap_or_else(||panic!("bg: {arg0:?}: not a color"));
-            output.show(bg(color, thunk(move|output: &mut Tui|{
-                state.interpret(output, &arg1)?;
-                // FIXME?: don't max out the used area?
-                Ok(Some(output.area().into()))
-            })))
+            if let Some(color) = Namespace::namespace(state, arg0)? {
+                output.show(bg(color, thunk(move|output: &mut Tui|{
+                    state.interpret(output, &arg1)?;
+                    // FIXME?: don't max out the used area?
+                    Ok(Some(output.area().into()))
+                })))
+            } else {
+                return Err(format!("bg: {arg0:?}: not a color").into())
+            }
         },
 
         _ => return Ok(None)
diff --git a/src/sing.rs b/src/sing.rs
index 9899fbe..ce776a6 100644
--- a/src/sing.rs
+++ b/src/sing.rs
@@ -46,7 +46,7 @@ pub type BoxedAudioHandler<'j> =
 /// Things that can provide a [jack::Client] reference.
 ///
 /// ```
-/// use tengri::sing::{Jack, HasJack};
+/// use tengri::*;
 ///
 /// let jack: &Jack = Jacked::default().jack();
 ///
diff --git a/src/sing/jack.rs b/src/sing/jack.rs
index 20f5c23..0100fed 100644
--- a/src/sing/jack.rs
+++ b/src/sing/jack.rs
@@ -1,4 +1,4 @@
-use crate::{*, sing::*, time::PerfModel};
+use crate::{*, PerfModel};
 pub use ::jack::{*, contrib::{*, ClosureProcessHandler}};
 
 use JackState::*;
@@ -6,7 +6,7 @@ use JackState::*;
 /// Wraps [JackState], and through it [jack::Client] when connected.
 ///
 /// ```
-/// let jack = tengri::sing::Jack::default();
+/// let jack = tengri::Jack::default();
 /// ```
 #[derive(Clone, Debug, Default)] pub struct Jack<'j> (
     pub(crate) Arc<RwLock<JackState<'j>>>
@@ -17,7 +17,7 @@ use JackState::*;
 /// [jack::Client], which you can use to talk to the JACK API.
 ///
 /// ```
-/// let state = tengri::sing::JackState::default();
+/// let state = tengri::JackState::default();
 /// ```
 #[derive(Debug, Default)] pub enum JackState<'j> {
     /// Unused
diff --git a/src/sing/jack_event.rs b/src/sing/jack_event.rs
index 7802842..cfeae6c 100644
--- a/src/sing/jack_event.rs
+++ b/src/sing/jack_event.rs
@@ -4,7 +4,7 @@ pub use ::jack::{*, contrib::{*, ClosureProcessHandler}};
 /// Event enum for JACK events.
 ///
 /// ```
-/// let event = tengri::sing::JackEvent::XRun; // kerpop
+/// let event = tengri::JackEvent::XRun; // kerpop
 /// ```
 #[derive(Debug, Clone, PartialEq)] pub enum JackEvent {
     ThreadInit,
@@ -22,7 +22,7 @@ pub use ::jack::{*, contrib::{*, ClosureProcessHandler}};
 /// Generic notification handler that emits [JackEvent]
 ///
 /// ```
-/// let notify = tengri::sing::JackNotify(|_|{});
+/// let notify = tengri::JackNotify(|_|{});
 /// ```
 pub struct JackNotify<T: Fn(JackEvent) + Send>(pub T);
 
diff --git a/src/term.rs b/src/term.rs
index fb2b207..a289e66 100644
--- a/src/term.rs
+++ b/src/term.rs
@@ -103,7 +103,7 @@ impl Tui {
 /// Implement standard [main] entrypoint for TUI apps.
 #[macro_export] macro_rules! tui_main {
     ($state:expr) => {
-        pub fn main () -> Usually<()> { tui_run_main($state) }
+        pub fn main () -> Usually<()> { tui_run_main(Arc::new(RwLock::new($state))) }
     }
 }
 
diff --git a/src/term/output.rs b/src/term/output.rs
index e0ff044..b91f919 100644
--- a/src/term/output.rs
+++ b/src/term/output.rs
@@ -1,10 +1,8 @@
-use crate::{*, lang::*};
+use crate::*;
 use ratatui::{prelude::{Style, Position, Backend, Color}};
 
 /// TUI works in u16 coordinates.
 impl Coord for u16 { fn plus (self, other: Self) -> Self { self.saturating_add(other) } }
-impl_draw!(|self: u64, _to: Tui|{ todo!() });
-impl_draw!(|self: f64, _to: Tui|{ todo!() });
 
 impl Screen for Tui {
     type Unit = u16;
@@ -37,8 +35,15 @@ impl Screen for Tui {
 /// Spawn the TUI output thread which writes colored characters to the terminal.
 ///
 /// ```
-/// let state = Arc::new(RwLock::new(()));
-/// Exit::run(|exit|tui_output(exit, state, sleep, stdout()))
+/// let state = std::sync::Arc::new(std::sync::RwLock::new(()));
+/// let _ = tengri::Exit::run(|exit|{
+///     tengri::tui_output(
+///         exit.as_ref(),
+///         &state,
+///         std::time::Duration::from_millis(10),
+///         std::io::stdout()
+///     )
+/// });
 /// ```
 pub fn tui_output <
     W: Write + Send + Sync + 'static, T: View<Tui> + Send + Sync + 'static
@@ -68,7 +73,7 @@ pub fn tui_output <
     })?)
 }
 
-use self::colors::*; mod colors {
+pub 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) }
@@ -259,7 +264,7 @@ pub fn phat (w: u16, h: u16, [fg, bg, hi, lo]: [Color;4], draw: impl Draw<Tui>)
     south(top, north(low, draw)).min_wh(w, h)
 }
 
-fn x_scroll () -> impl Draw<Tui> {
+pub fn x_scroll () -> impl Draw<Tui> {
     thunk(|Tui(buf, XYWH(x1, y1, w, h)): &mut Tui|{
         let x2 = *x1 + *w;
         for (i, x) in (*x1..=x2).enumerate() {
@@ -287,7 +292,7 @@ fn x_scroll () -> impl Draw<Tui> {
     })
 }
 
-fn y_scroll () -> impl Draw<Tui> {
+pub fn y_scroll () -> impl Draw<Tui> {
     thunk(|Tui(buf, XYWH(x1, y1, w, h)): &mut Tui|{
         let y2 = *y1 + *h;
         for (i, y) in (*y1..=y2).enumerate() {
@@ -315,19 +320,16 @@ fn y_scroll () -> impl Draw<Tui> {
     })
 }
 
-pub fn tui_update (
-    Tui(buf, ..): &mut Tui,
-    area: XYWH<u16>,
-    callback: &impl Fn(&mut Cell, u16, u16)
-) {
-}
-
 /// Draw TUI content or its error message.
 ///
 /// ```
-/// let _ = tengri::term::catcher(Ok(Some("hello")));
-/// let _ = tengri::term::catcher(Ok(None));
-/// let _ = tengri::term::catcher(Err("draw fail".into()));
+/// for variant in [
+///     Ok(Some("hello")),
+///     Ok(None),
+///     Err("fail".into()),
+/// ] {
+///     let _ = tengri::catcher(variant);
+/// }
 /// ```
 pub fn catcher <T: Draw<Tui>> (result: Usually<T>) -> impl Draw<Tui> {
     thunk(move|to: &mut Tui|match result {
@@ -341,3 +343,6 @@ pub fn catcher <T: Draw<Tui>> (result: Usually<T>) -> impl Draw<Tui> {
         }
     })
 }
+
+impl_draw!(|self: u64, _to: Tui|{ todo!() });
+impl_draw!(|self: f64, _to: Tui|{ todo!() });

From ddc53b23c2c435f3544b4c2203d576ec80ddc847 Mon Sep 17 00:00:00 2001
From: facile pop culture reference <donotem@ilme.no>
Date: Fri, 10 Jul 2026 19:31:37 +0300
Subject: [PATCH 25/25] gitmodules: use ssh clone

---
 .gitmodules | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.gitmodules b/.gitmodules
index c4e9da5..34ea4da 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -3,4 +3,4 @@
 	url = ssh://git@codeberg.org/unspeaker/dizzle.git
 [submodule "rust-jack"]
 	path = rust-jack
-	url = https://codeberg.org/unspeaker/rust-jack
+	url = ssh://git@codeberg.org/unspeaker/rust-jack