fix(theme): stack Claude weekly and Fable meters when no 5h limit is reported

src/theme_engine/tests.rs

@@ -944,12 +944,16 @@ fn built_in_themes_hide_absent_claude_sessions_and_keep_weekly_and_fable_limits(
 }
 
 #[test]
-fn built_in_classic_adds_a_fable_column_when_the_limit_is_available() {
+fn classic_stacks_weekly_and_fable_without_a_claude_session() {
     use crate::models::{UsageData, UsageLimit, UsageSection};
 
-    let usage = AppUsageData::from_iter([(
+    let mut usage = AppUsageData::from_iter([(
         ProviderId::Claude,
         UsageData {
+            weekly: UsageSection {
+                available: true,
+                ..Default::default()
+            },
             limits: vec![UsageLimit {
                 key: "weekly_scoped_fable".into(),
                 kind: "weekly_scoped".into(),
@@ -968,20 +972,85 @@ fn built_in_classic_adds_a_fable_column_when_the_limit_is_available() {
         },
     )]);
     let theme = ThemeDocument::starter();
+    let surface = &theme.surfaces[0];
 
-    assert_eq!(
-        resolve_surface_size(
-            &theme,
-            0,
-            Some(&usage),
-            ThemeRuntime::new(true, false, false)
-        ),
-        (310, 46)
-    );
-    assert!(theme.surfaces[0]
-        .children
-        .iter()
-        .any(|object| object.id == "fable-provider"));
+    for session_available in [false, true] {
+        let mut claude = usage.get(ProviderId::Claude).unwrap().clone();
+        claude.session.available = session_available;
+        usage.insert(ProviderId::Claude, claude);
+        for (runtime, provider_count) in [
+            (ThemeRuntime::new(true, false, false), 1),
+            (ThemeRuntime::new(true, true, false), 2),
+            (
+                ThemeRuntime::from_providers(ProviderSet::from_enabled(ProviderId::ALL)),
+                ProviderId::ALL.len(),
+            ),
+        ] {
+            let (width, height) = resolve_surface_size(&theme, 0, Some(&usage), runtime);
+            let canvas = Canvas {
+                width,
+                height,
+                ..Default::default()
+            };
+            let (objects, warnings) =
+                resolve_objects_for(surface, &canvas, &surface.children, Some(&usage), runtime);
+            assert!(warnings.is_empty(), "{warnings:?}");
+            let find = |prefix: &str| objects.iter().find(|o| o.source.id.starts_with(prefix));
+            let stacked = !session_available;
+            let weekly_y = if stacked { 5.0 } else { 28.0 };
+
+            assert_eq!(
+                find("session-label-").is_some(),
+                session_available || provider_count > 1
+            );
+            assert_eq!(
+                find("claude-session-segments-").is_some(),
+                session_available
+            );
+            assert_eq!(find("claude-window-label-").is_some(), stacked);
+            assert_eq!(find("fable-window-label-").is_some(), stacked);
+
+            let weekly_bar = find("claude-weekly-segments-").unwrap();
+            let weekly_value = find("claude-weekly-value-").unwrap();
+            let fable_bar = find("fable-weekly-segments-").unwrap();
+            let fable_value = find("fable-weekly-value-").unwrap();
+            assert_eq!(weekly_bar.y, weekly_y);
+            assert_eq!(weekly_value.y, weekly_y);
+            assert_eq!(fable_bar.y, if stacked { 28.0 } else { 5.0 });
+            assert_eq!(fable_value.y, 28.0);
+            if stacked {
+                let claude_label = find("claude-window-label-").unwrap();
+                let fable_label = find("fable-window-label-").unwrap();
+                assert_eq!(claude_label.x, fable_label.x);
+                assert_eq!(claude_label.y, weekly_bar.y);
+                assert_eq!(fable_label.y, fable_bar.y);
+                assert_eq!(weekly_bar.x, fable_bar.x);
+                assert_eq!(weekly_bar.width, fable_bar.width);
+                assert_eq!(weekly_value.x, fable_value.x);
+                assert!(fable_value.x + fable_value.width <= f64::from(width));
+
+                for provider in objects
+                    .iter()
+                    .filter(|object| object.source.parent.as_deref() == Some("provider-row"))
+                {
+                    assert!(provider.x + provider.width <= claude_label.x);
+                }
+                if provider_count == 1 {
+                    assert_eq!(width, 245);
+                    assert!(find("weekly-label-").is_none());
+                } else if provider_count == 2 {
+                    let codex_session = find("codex-session-segments-").unwrap();
+                    let codex_weekly = find("codex-weekly-segments-").unwrap();
+                    assert_eq!(codex_session.x, 41.0);
+                    assert_eq!(codex_session.x, codex_weekly.x);
+                    assert_eq!(find("session-label-").unwrap().y, codex_session.y);
+                    assert_eq!(find("weekly-label-").unwrap().y, codex_weekly.y);
+                }
+            } else {
+                assert!(fable_bar.x >= weekly_value.x + weekly_value.width);
+            }
+        }
+    }
 }
 
 #[test]