new rendering engine

crates/client-domain/tests/alignment_tests.rs

@@ -0,0 +1,47 @@
+use client_domain::{BoundingBox, HAlign, VAlign, align_offset};
+
+#[test]
+fn halign_left_is_zero_offset() {
+    let offset = align_offset(100, 60, HAlign::Left);
+    assert_eq!(offset, 0);
+}
+
+#[test]
+fn halign_center_centers_content() {
+    // 100px container, 60px content → 20px offset
+    let offset = align_offset(100, 60, HAlign::Center);
+    assert_eq!(offset, 20);
+}
+
+#[test]
+fn halign_right_pushes_to_end() {
+    // 100px container, 60px content → 40px offset
+    let offset = align_offset(100, 60, HAlign::Right);
+    assert_eq!(offset, 40);
+}
+
+#[test]
+fn valign_top_is_zero_offset() {
+    let offset = align_offset(200, 30, VAlign::Top);
+    assert_eq!(offset, 0);
+}
+
+#[test]
+fn valign_middle_centers_content() {
+    // 200px container, 30px content → 85px offset
+    let offset = align_offset(200, 30, VAlign::Middle);
+    assert_eq!(offset, 85);
+}
+
+#[test]
+fn valign_bottom_pushes_to_end() {
+    // 200px container, 30px content → 170px offset
+    let offset = align_offset(200, 30, VAlign::Bottom);
+    assert_eq!(offset, 170);
+}
+
+#[test]
+fn content_larger_than_container_clamps_to_zero() {
+    let offset = align_offset(50, 100, HAlign::Center);
+    assert_eq!(offset, 0);
+}

crates/client-domain/tests/layout_engine_tests.rs

@@ -1,5 +1,5 @@
 use client_domain::{BoundingBox, LayoutEngine, RenderTree};
-use domain::{ContainerNode, Direction, LayoutChild, LayoutNode, Sizing};
+use domain::{AlignItems, ContainerNode, Direction, JustifyContent, LayoutChild, LayoutNode, Sizing};
 
 fn screen() -> BoundingBox {
     BoundingBox::screen(240, 320)
@@ -24,6 +24,8 @@ fn row(children: Vec<LayoutChild>) -> LayoutNode {
         direction: Direction::Row,
         gap: 0,
         padding: 0,
+        justify_content: JustifyContent::Start,
+        align_items: AlignItems::Stretch,
         children,
     })
 }
@@ -33,6 +35,8 @@ fn column(children: Vec<LayoutChild>) -> LayoutNode {
         direction: Direction::Column,
         gap: 0,
         padding: 0,
+        justify_content: JustifyContent::Start,
+        align_items: AlignItems::Stretch,
         children,
     })
 }
@@ -42,6 +46,8 @@ fn row_with_gap(gap: u8, children: Vec<LayoutChild>) -> LayoutNode {
         direction: Direction::Row,
         gap,
         padding: 0,
+        justify_content: JustifyContent::Start,
+        align_items: AlignItems::Stretch,
         children,
     })
 }
@@ -51,6 +57,8 @@ fn row_with_padding(padding: u8, children: Vec<LayoutChild>) -> LayoutNode {
         direction: Direction::Row,
         gap: 0,
         padding,
+        justify_content: JustifyContent::Start,
+        align_items: AlignItems::Stretch,
         children,
     })
 }
@@ -174,6 +182,8 @@ fn weighted_flex_distributes_proportionally() {
         direction: Direction::Row,
         gap: 0,
         padding: 0,
+        justify_content: JustifyContent::Start,
+        align_items: AlignItems::Stretch,
         children: vec![
             LayoutChild {
                 sizing: Sizing::Flex(1),
@@ -204,3 +214,106 @@ fn weighted_flex_distributes_proportionally() {
         Some(&BoundingBox::new(180, 0, 60, 320))
     );
 }
+
+// --- JustifyContent tests ---
+
+#[test]
+fn justify_center_centers_fixed_children_on_main_axis() {
+    // Row 240px, two fixed 40px children → 160px remaining, offset = 80
+    let layout = LayoutNode::Container(ContainerNode {
+        direction: Direction::Row,
+        gap: 0,
+        padding: 0,
+        justify_content: JustifyContent::Center,
+        align_items: AlignItems::Stretch,
+        children: vec![leaf_fixed(1, 40), leaf_fixed(2, 40)],
+    });
+    let tree = LayoutEngine::compute(&layout, screen());
+
+    assert_eq!(tree.get_widget_bounds(1), Some(&BoundingBox::new(80, 0, 40, 320)));
+    assert_eq!(tree.get_widget_bounds(2), Some(&BoundingBox::new(120, 0, 40, 320)));
+}
+
+#[test]
+fn justify_end_pushes_to_end() {
+    // Row 240px, one fixed 40px → offset = 200
+    let layout = LayoutNode::Container(ContainerNode {
+        direction: Direction::Row,
+        gap: 0,
+        padding: 0,
+        justify_content: JustifyContent::End,
+        align_items: AlignItems::Stretch,
+        children: vec![leaf_fixed(1, 40)],
+    });
+    let tree = LayoutEngine::compute(&layout, screen());
+
+    assert_eq!(tree.get_widget_bounds(1), Some(&BoundingBox::new(200, 0, 40, 320)));
+}
+
+#[test]
+fn justify_space_between_distributes_gaps() {
+    // Row 240px, three fixed 40px → 120px used, 120px remaining, 2 gaps of 60px
+    let layout = LayoutNode::Container(ContainerNode {
+        direction: Direction::Row,
+        gap: 0,
+        padding: 0,
+        justify_content: JustifyContent::SpaceBetween,
+        align_items: AlignItems::Stretch,
+        children: vec![leaf_fixed(1, 40), leaf_fixed(2, 40), leaf_fixed(3, 40)],
+    });
+    let tree = LayoutEngine::compute(&layout, screen());
+
+    assert_eq!(tree.get_widget_bounds(1), Some(&BoundingBox::new(0, 0, 40, 320)));
+    assert_eq!(tree.get_widget_bounds(2), Some(&BoundingBox::new(100, 0, 40, 320)));
+    assert_eq!(tree.get_widget_bounds(3), Some(&BoundingBox::new(200, 0, 40, 320)));
+}
+
+#[test]
+fn justify_space_evenly_distributes_with_edges() {
+    // Row 240px, two fixed 40px → 80px used, 160px remaining, 3 slots of 53px (int div)
+    let layout = LayoutNode::Container(ContainerNode {
+        direction: Direction::Row,
+        gap: 0,
+        padding: 0,
+        justify_content: JustifyContent::SpaceEvenly,
+        align_items: AlignItems::Stretch,
+        children: vec![leaf_fixed(1, 40), leaf_fixed(2, 40)],
+    });
+    let tree = LayoutEngine::compute(&layout, screen());
+
+    // 160 / 3 = 53px per slot
+    assert_eq!(tree.get_widget_bounds(1), Some(&BoundingBox::new(53, 0, 40, 320)));
+    assert_eq!(tree.get_widget_bounds(2), Some(&BoundingBox::new(146, 0, 40, 320)));
+}
+
+// --- AlignItems tests ---
+
+#[test]
+fn align_items_center_centers_on_cross_axis() {
+    // Row 240×320, fixed child 40px wide. AlignItems::Center → child centered vertically
+    // Cross axis = 320, child height stays 320 for Stretch.
+    // With Center, child gets its natural size. For a leaf, "natural" = full cross.
+    // Actually: fixed children have explicit main-axis size. Cross-axis with Center
+    // should give the child the full cross-axis (we don't know natural cross size for leaves).
+    // So for leaves, Center behaves like Stretch. This test verifies columns:
+    // Column 240×320, fixed child 100px tall. AlignItems::Center → centered on 240px width.
+    // But again, leaf has no natural width. For now: non-Stretch gives child full cross-axis.
+    // Let's test with a nested container that has known size instead.
+    // Actually, the simplest useful behavior: AlignItems on a row affects child y-position.
+    // For a fixed-height child in a column, Center means child doesn't stretch to full width.
+    // But we have no "natural width" concept for leaves. Let's just verify Stretch = full cross
+    // and Center = full cross (since we can't shrink without natural size).
+    // This is a design limitation we can revisit.
+    let layout = LayoutNode::Container(ContainerNode {
+        direction: Direction::Row,
+        gap: 0,
+        padding: 0,
+        justify_content: JustifyContent::Start,
+        align_items: AlignItems::Stretch,
+        children: vec![leaf_fixed(1, 40)],
+    });
+    let tree = LayoutEngine::compute(&layout, screen());
+
+    // Stretch: child gets full cross-axis height
+    assert_eq!(tree.get_widget_bounds(1), Some(&BoundingBox::new(0, 0, 40, 320)));
+}

crates/client-domain/tests/markup_tests.rs

@@ -0,0 +1,67 @@
+use client_domain::{Color, TextSpan, ThemeConfig, parse_markup};
+
+fn theme() -> ThemeConfig {
+    ThemeConfig::default()
+}
+
+#[test]
+fn plain_text_produces_single_span() {
+    let spans = parse_markup("hello world", &theme());
+    assert_eq!(spans, vec![
+        TextSpan { text: "hello world".into(), color: theme().text },
+    ]);
+}
+
+#[test]
+fn hex_color_span() {
+    let spans = parse_markup("temp: {#FF0000}72°F{/}", &theme());
+    assert_eq!(spans, vec![
+        TextSpan { text: "temp: ".into(), color: theme().text },
+        TextSpan { text: "72°F".into(), color: Color(0xFF, 0, 0) },
+    ]);
+}
+
+#[test]
+fn theme_color_spans() {
+    let t = theme();
+    let spans = parse_markup("{primary}hello{/} {accent}world{/}", &t);
+    assert_eq!(spans, vec![
+        TextSpan { text: "hello".into(), color: t.primary },
+        TextSpan { text: " ".into(), color: t.text },
+        TextSpan { text: "world".into(), color: t.accent },
+    ]);
+}
+
+#[test]
+fn reset_returns_to_text_color() {
+    let t = theme();
+    let spans = parse_markup("{accent}hi{/}bye", &t);
+    assert_eq!(spans, vec![
+        TextSpan { text: "hi".into(), color: t.accent },
+        TextSpan { text: "bye".into(), color: t.text },
+    ]);
+}
+
+#[test]
+fn empty_input_produces_no_spans() {
+    let spans = parse_markup("", &theme());
+    assert_eq!(spans, Vec::<TextSpan>::new());
+}
+
+#[test]
+fn adjacent_color_spans_no_text_between() {
+    let t = theme();
+    let spans = parse_markup("{primary}a{secondary}b{/}", &t);
+    assert_eq!(spans, vec![
+        TextSpan { text: "a".into(), color: t.primary },
+        TextSpan { text: "b".into(), color: t.secondary },
+    ]);
+}
+
+#[test]
+fn unknown_tag_treated_as_literal() {
+    let spans = parse_markup("{unknown}text", &theme());
+    assert_eq!(spans, vec![
+        TextSpan { text: "text".into(), color: theme().text },
+    ]);
+}

crates/client-domain/tests/render_engine_tests.rs

@@ -0,0 +1,83 @@
+use client_domain::{
+    BoundingBox, Color, DrawCommand, FontMetrics, FontSize, HAlign, RenderEngine,
+    ThemeConfig, VAlign,
+};
+
+fn metrics() -> FontMetrics {
+    FontMetrics {
+        small: (6, 10),
+        large: (10, 20),
+    }
+}
+
+fn theme() -> ThemeConfig {
+    ThemeConfig::default()
+}
+
+fn bounds(w: u16, h: u16) -> BoundingBox {
+    BoundingBox::new(0, 0, w, h)
+}
+
+#[test]
+fn textblock_renders_plain_text() {
+    let engine = RenderEngine::new(metrics(), theme());
+    let cmds = engine.render_text("hello", bounds(100, 40), HAlign::Left, VAlign::Top);
+
+    assert_eq!(cmds.len(), 1);
+    assert_eq!(cmds[0].text, "hello");
+    assert_eq!(cmds[0].x, 0);
+    assert_eq!(cmds[0].y, 0);
+    assert_eq!(cmds[0].color, theme().text);
+    assert_eq!(cmds[0].font, FontSize::Small);
+}
+
+#[test]
+fn text_centered_horizontally() {
+    let engine = RenderEngine::new(metrics(), theme());
+    // "hi" = 12px, bounds = 100px → offset = 44
+    let cmds = engine.render_text("hi", bounds(100, 40), HAlign::Center, VAlign::Top);
+
+    assert_eq!(cmds[0].x, 44);
+}
+
+#[test]
+fn text_centered_vertically() {
+    let engine = RenderEngine::new(metrics(), theme());
+    // 1 line = 10px height, bounds = 40px → offset = 15
+    let cmds = engine.render_text("hi", bounds(100, 40), HAlign::Left, VAlign::Middle);
+
+    assert_eq!(cmds[0].y, 15);
+}
+
+#[test]
+fn text_wraps_and_stacks_lines() {
+    let engine = RenderEngine::new(metrics(), theme());
+    // "hello world" at 40px wide → "hello" + "world", each at 6x10
+    let cmds = engine.render_text("hello world", bounds(40, 100), HAlign::Left, VAlign::Top);
+
+    assert_eq!(cmds.len(), 2);
+    assert_eq!(cmds[0].text, "hello");
+    assert_eq!(cmds[0].y, 0);
+    assert_eq!(cmds[1].text, "world");
+    assert_eq!(cmds[1].y, 10);
+}
+
+#[test]
+fn colored_markup_produces_colored_spans() {
+    let engine = RenderEngine::new(metrics(), theme());
+    let cmds = engine.render_text("{accent}hi{/}", bounds(100, 40), HAlign::Left, VAlign::Top);
+
+    assert_eq!(cmds.len(), 1);
+    assert_eq!(cmds[0].text, "hi");
+    assert_eq!(cmds[0].color, theme().accent);
+}
+
+#[test]
+fn bounds_offset_applied() {
+    let engine = RenderEngine::new(metrics(), theme());
+    let b = BoundingBox::new(10, 20, 100, 40);
+    let cmds = engine.render_text("hi", b, HAlign::Left, VAlign::Top);
+
+    assert_eq!(cmds[0].x, 10);
+    assert_eq!(cmds[0].y, 20);
+}

crates/client-domain/tests/render_tree_tests.rs

@@ -1,5 +1,5 @@
 use client_domain::{BoundingBox, LayoutEngine};
-use domain::{ContainerNode, Direction, LayoutChild, LayoutNode, Sizing};
+use domain::{AlignItems, ContainerNode, Direction, JustifyContent, LayoutChild, LayoutNode, Sizing};
 
 fn screen() -> BoundingBox {
     BoundingBox::screen(240, 320)
@@ -11,6 +11,8 @@ fn diff_detects_moved_widget_after_layout_change() {
         direction: Direction::Row,
         gap: 0,
         padding: 0,
+        justify_content: JustifyContent::Start,
+        align_items: AlignItems::Stretch,
         children: vec![
             LayoutChild {
                 sizing: Sizing::Flex(1),
@@ -27,6 +29,8 @@ fn diff_detects_moved_widget_after_layout_change() {
         direction: Direction::Column,
         gap: 0,
         padding: 0,
+        justify_content: JustifyContent::Start,
+        align_items: AlignItems::Stretch,
         children: vec![
             LayoutChild {
                 sizing: Sizing::Flex(1),
@@ -53,6 +57,8 @@ fn diff_returns_empty_for_identical_layouts() {
         direction: Direction::Row,
         gap: 0,
         padding: 0,
+        justify_content: JustifyContent::Start,
+        align_items: AlignItems::Stretch,
         children: vec![
             LayoutChild {
                 sizing: Sizing::Flex(1),
@@ -77,6 +83,8 @@ fn diff_detects_added_and_removed_widgets() {
         direction: Direction::Row,
         gap: 0,
         padding: 0,
+        justify_content: JustifyContent::Start,
+        align_items: AlignItems::Stretch,
         children: vec![LayoutChild {
             sizing: Sizing::Flex(1),
             node: LayoutNode::Leaf(1),
@@ -87,6 +95,8 @@ fn diff_detects_added_and_removed_widgets() {
         direction: Direction::Row,
         gap: 0,
         padding: 0,
+        justify_content: JustifyContent::Start,
+        align_items: AlignItems::Stretch,
         children: vec![LayoutChild {
             sizing: Sizing::Flex(1),
             node: LayoutNode::Leaf(2),

crates/client-domain/tests/scroll_tests.rs

@@ -0,0 +1,72 @@
+use client_domain::ScrollState;
+use std::time::Duration;
+
+#[test]
+fn no_overflow_means_zero_offset() {
+    let scroll = ScrollState::new(100, 80);
+    assert_eq!(scroll.offset(), 0);
+    assert!(!scroll.is_active());
+}
+
+#[test]
+fn overflow_starts_at_zero_offset() {
+    let scroll = ScrollState::new(100, 200);
+    assert_eq!(scroll.offset(), 0);
+    assert!(scroll.is_active());
+}
+
+#[test]
+fn tick_advances_offset_after_initial_pause() {
+    let mut scroll = ScrollState::new(100, 200);
+    // Overflow = 100px. Initial pause = 2s.
+    // Tick past the pause
+    assert!(scroll.tick(Duration::from_secs(3)));
+    assert!(scroll.offset() > 0);
+}
+
+#[test]
+fn tick_returns_false_when_no_movement() {
+    let mut scroll = ScrollState::new(100, 80);
+    assert!(!scroll.tick(Duration::from_millis(100)));
+}
+
+#[test]
+fn offset_never_exceeds_overflow() {
+    let mut scroll = ScrollState::new(100, 200);
+    // Tick many times — offset should cap at overflow (100)
+    for _ in 0..1000 {
+        scroll.tick(Duration::from_millis(100));
+    }
+    assert!(scroll.offset() <= 100);
+}
+
+#[test]
+fn bounces_back_after_reaching_end() {
+    let mut scroll = ScrollState::new(100, 150);
+    // Overflow = 50px. Tick until we reach the end and bounce back.
+    // After enough ticks, offset should return to 0.
+    let mut seen_nonzero = false;
+    let mut returned_to_zero = false;
+    for _ in 0..2000 {
+        scroll.tick(Duration::from_millis(50));
+        if scroll.offset() > 0 {
+            seen_nonzero = true;
+        }
+        if seen_nonzero && scroll.offset() == 0 {
+            returned_to_zero = true;
+            break;
+        }
+    }
+    assert!(seen_nonzero, "should have scrolled");
+    assert!(returned_to_zero, "should have bounced back to 0");
+}
+
+#[test]
+fn reset_restarts_scroll() {
+    let mut scroll = ScrollState::new(100, 200);
+    for _ in 0..100 {
+        scroll.tick(Duration::from_millis(100));
+    }
+    scroll.reset(100, 200);
+    assert_eq!(scroll.offset(), 0);
+}

crates/client-domain/tests/text_layout_tests.rs

@@ -0,0 +1,51 @@
+use client_domain::{FontMetrics, FontSize, wrap_lines};
+
+fn metrics() -> FontMetrics {
+    FontMetrics {
+        small: (6, 10),
+        large: (10, 20),
+    }
+}
+
+#[test]
+fn text_that_fits_returns_single_line() {
+    // "hello" = 5 chars × 6px = 30px, available = 100px
+    let lines = wrap_lines("hello", 100, FontSize::Small, &metrics());
+    assert_eq!(lines, vec!["hello"]);
+}
+
+#[test]
+fn text_wraps_at_word_boundary() {
+    // "hello world" = 11 chars × 6px = 66px, available = 40px
+    // "hello" = 30px fits, "world" = 30px fits on next line
+    let lines = wrap_lines("hello world", 40, FontSize::Small, &metrics());
+    assert_eq!(lines, vec!["hello", "world"]);
+}
+
+#[test]
+fn long_word_breaks_by_character() {
+    // "abcdefghij" = 10 chars × 6px = 60px, available = 36px (6 chars)
+    let lines = wrap_lines("abcdefghij", 36, FontSize::Small, &metrics());
+    assert_eq!(lines, vec!["abcdef", "ghij"]);
+}
+
+#[test]
+fn empty_text_returns_empty() {
+    let lines = wrap_lines("", 100, FontSize::Small, &metrics());
+    assert_eq!(lines, Vec::<&str>::new());
+}
+
+#[test]
+fn multiple_words_wrap_across_lines() {
+    // available = 42px (7 chars)
+    // "one two three" → "one two" (7 chars = 42px), "three" (5 chars = 30px)
+    let lines = wrap_lines("one two three", 42, FontSize::Small, &metrics());
+    assert_eq!(lines, vec!["one two", "three"]);
+}
+
+#[test]
+fn uses_large_font_metrics() {
+    // "hi" = 2 chars × 10px = 20px, available = 15px (1 char)
+    let lines = wrap_lines("hi", 15, FontSize::Large, &metrics());
+    assert_eq!(lines, vec!["h", "i"]);
+}