Reduce TUI zero-state animation CPU usage (#14604)

## Description

Reduces the CPU cost of the TUI zero-state animation while preserving
its original 66 ms (~15 FPS) visual cadence.

- Suspends animation repaint scheduling while the terminal is unfocused
and resumes immediately on focus gain.
- Caches logo geometry, reuses projection buffers, and paints the
starfield directly.
- Replaces generic stack composition in the zero state with a
specialized direct compositor while preserving opaque-overlay semantics.
- Adds production-shaped Criterion benchmarks and rendering/focus
regression coverage.

At 120×40, the retained-frame benchmarks improved by approximately 68%
for the built-in logo and 73% for the ASCII logo. Larger terminal sizes
showed greater savings.

Implementation plan:
https://staging.warp.dev/drive/notebook/NHie0i2bcU6ge5gHne0EEC

## Linked Issue

None.

## Testing

- [x] Manually tested the TUI locally with `./script/run-tui`
- [x] `cargo nextest run -p warpui_core --features tui --no-fail-fast`
(559 passed, 7 skipped)
- [x] `cargo nextest run -p warp_tui --features test-util
--no-fail-fast` (947 passed)
- [x] `cargo clippy --workspace --exclude warp_completer --all-targets
--tests -- -D warnings`
- [x] `cargo clippy -p warp --all-targets --tests -- -D warnings`
- [x] `cargo clippy -p warp_completer --all-targets --tests -- -D
warnings`
- [x] `./script/format --check`
- [x] `git diff --check`

## Agent Mode

- [x] Warp Agent Mode - This PR was created via Warp's AI Agent Mode

CHANGELOG-TUI: Reduced CPU usage while the zero-state animation is
active.

Author: kevinyang372

crates/warp_tui/Cargo.toml

@@ -123,6 +123,11 @@ name = "transcript_bench"
 harness = false
 required-features = ["test-util"]
 
+[[bench]]
+name = "zero_state_bench"
+harness = false
+required-features = ["test-util"]
+
 [features]
 # Exposes deterministic, production-shaped transcript fixtures to benchmarks.
 test-util = ["warp/test-util", "warp_core/test-util"]

crates/warp_tui/benches/zero_state_bench.rs

@@ -0,0 +1,53 @@
+use std::hint::black_box;
+use std::time::Duration;
+
+use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
+use warp_tui::benchmark_support::{
+    ZeroStateBenchmark, ZeroStateBenchmarkShape, ZeroStateProjectionBenchmark,
+};
+
+fn benchmark_zero_state_frame(criterion: &mut Criterion) {
+    let mut group = criterion.benchmark_group("tui_zero_state/retained_frame");
+    for (width, height) in [(80, 24), (120, 40), (240, 80)] {
+        for shape in [
+            ZeroStateBenchmarkShape::BuiltIn,
+            ZeroStateBenchmarkShape::Ascii,
+        ] {
+            let mut benchmark = ZeroStateBenchmark::new(shape, width, height);
+            group.bench_with_input(
+                BenchmarkId::new(format!("{shape:?}"), format!("{width}x{height}")),
+                &(width, height),
+                |b, _| b.iter(|| black_box(benchmark.present())),
+            );
+        }
+    }
+    group.finish();
+}
+
+fn benchmark_logo_projection(criterion: &mut Criterion) {
+    let mut group = criterion.benchmark_group("tui_zero_state/logo_projection");
+    for (width, height) in [(32, 24), (32, 40), (32, 80)] {
+        for shape in [
+            ZeroStateBenchmarkShape::BuiltIn,
+            ZeroStateBenchmarkShape::Ascii,
+        ] {
+            let mut benchmark = ZeroStateProjectionBenchmark::new(shape, width, height);
+            group.bench_with_input(
+                BenchmarkId::new(format!("{shape:?}"), format!("{width}x{height}")),
+                &(width, height),
+                |b, _| b.iter(|| black_box(benchmark.project())),
+            );
+        }
+    }
+    group.finish();
+}
+
+criterion_group! {
+    name = benches;
+    config = Criterion::default()
+        .sample_size(10)
+        .warm_up_time(Duration::from_millis(500))
+        .measurement_time(Duration::from_secs(1));
+    targets = benchmark_zero_state_frame, benchmark_logo_projection
+}
+criterion_main!(benches);

crates/warp_tui/src/benchmark_support.rs

@@ -4,6 +4,7 @@ use std::cell::RefCell;
 use std::collections::HashMap;
 use std::rc::Rc;
 use std::sync::Arc;
+use std::time::Duration;
 
 use parking_lot::FairMutex;
 use warp::tui_export::{
@@ -17,9 +18,10 @@ use warpui::{
     AddWindowOptions, App, AppContext, Entity, EntityId, EntityIdSet, TuiView, TypedActionView,
     ViewContext, ViewHandle, WindowInvalidation,
 };
+use warpui_core::elements::animation::AnimationClock;
 use warpui_core::elements::tui::{
-    TuiClipped, TuiElement, TuiRect, TuiViewportPosition, TuiViewportVerticalAlignment,
-    TuiViewportedList, TuiViewportedListState,
+    TuiClipped, TuiElement, TuiRect, TuiSize, TuiStyle, TuiText, TuiViewportPosition,
+    TuiViewportVerticalAlignment, TuiViewportedList, TuiViewportedListState,
 };
 use warpui_core::presenter::tui::TuiPresenter;
 
@@ -31,6 +33,158 @@ use crate::tui_block_list_viewport_source::{
     TuiBlockListViewportSource,
 };
 use crate::tui_builder::TuiUiBuilder;
+use crate::zero_state::build_zero_state_layout;
+use crate::zero_state_animation::{
+    LogoProjector, WarpLogoStyles, ZeroStateAnimationConfig, ZeroStateAnimationElement,
+    ZeroStateInteractionHandle, ZeroStateStarfieldElement, benchmark_logo_projection,
+};
+
+const ZERO_STATE_COPY_COLS: u16 = 48;
+const ZERO_STATE_ANIMATION_COLS: u16 = 32;
+
+#[derive(Clone, Copy, Debug)]
+pub enum ZeroStateBenchmarkShape {
+    BuiltIn,
+    Ascii,
+}
+
+impl ZeroStateBenchmarkShape {
+    fn config(self) -> ZeroStateAnimationConfig {
+        match self {
+            Self::BuiltIn => ZeroStateAnimationConfig::default(),
+            Self::Ascii => ZeroStateAnimationConfig::benchmark_ascii(),
+        }
+    }
+}
+
+pub struct ZeroStateBenchmark {
+    app: App,
+    root: ViewHandle<BenchmarkZeroStateView>,
+    presenter: TuiPresenter,
+    area: TuiRect,
+}
+
+impl ZeroStateBenchmark {
+    pub fn new(shape: ZeroStateBenchmarkShape, width: u16, height: u16) -> Self {
+        let config = Arc::new(shape.config());
+        App::test((), move |mut app| async move {
+            let (_, root) = app.update(|ctx| {
+                ctx.add_tui_window(
+                    AddWindowOptions {
+                        window_style: WindowStyle::NotStealFocus,
+                        ..Default::default()
+                    },
+                    move |_| BenchmarkZeroStateView {
+                        clock: AnimationClock::starting_at(Duration::ZERO),
+                        config,
+                        interaction: ZeroStateInteractionHandle::default(),
+                    },
+                )
+            });
+            let mut benchmark = Self {
+                app,
+                root,
+                presenter: TuiPresenter::new(),
+                area: TuiRect::new(0, 0, width, height),
+            };
+            benchmark.invalidate();
+            benchmark.present();
+            benchmark
+        })
+    }
+
+    pub fn present(&mut self) -> u64 {
+        let frame = self
+            .app
+            .update(|ctx| self.presenter.present(ctx, &self.root, self.area));
+        frame.buffer.content.iter().fold(0u64, |checksum, cell| {
+            checksum.wrapping_add(cell.symbol().len() as u64)
+        })
+    }
+
+    fn invalidate(&mut self) {
+        let invalidation = WindowInvalidation {
+            updated: EntityIdSet::from_iter([self.root.id()]),
+            ..Default::default()
+        };
+        self.app.read(|ctx| {
+            self.presenter
+                .invalidate(&invalidation, ctx, self.root.window_id(ctx));
+        });
+    }
+}
+
+struct BenchmarkZeroStateView {
+    clock: AnimationClock,
+    config: Arc<ZeroStateAnimationConfig>,
+    interaction: ZeroStateInteractionHandle,
+}
+
+impl Entity for BenchmarkZeroStateView {
+    type Event = ();
+}
+
+impl TypedActionView for BenchmarkZeroStateView {
+    type Action = ();
+}
+
+impl TuiView for BenchmarkZeroStateView {
+    fn ui_name() -> &'static str {
+        "BenchmarkZeroStateView"
+    }
+
+    fn render(&self, _app: &AppContext) -> Box<dyn TuiElement> {
+        let style = TuiStyle::default();
+        let starfield = ZeroStateStarfieldElement::new(
+            self.clock,
+            style,
+            ZERO_STATE_COPY_COLS,
+            ZERO_STATE_ANIMATION_COLS,
+        )
+        .finish();
+        let animation = ZeroStateAnimationElement::new(
+            self.clock,
+            self.config.clone(),
+            self.interaction.clone(),
+            WarpLogoStyles {
+                front: style,
+                back: style,
+                side: style,
+                background: style,
+            },
+        )
+        .without_background_stars()
+        .finish();
+        let overlay = TuiText::new(
+            "Warp Agent\nv0.0.0\n\nWhat's new\n• benchmark\n\nProject\nbenchmark fixture",
+        )
+        .finish();
+        build_zero_state_layout(starfield, animation, overlay)
+    }
+}
+
+pub struct ZeroStateProjectionBenchmark {
+    elapsed: Duration,
+    size: TuiSize,
+    config: ZeroStateAnimationConfig,
+    projector: LogoProjector,
+}
+
+impl ZeroStateProjectionBenchmark {
+    pub fn new(shape: ZeroStateBenchmarkShape, width: u16, height: u16) -> Self {
+        Self {
+            elapsed: Duration::ZERO,
+            size: TuiSize::new(width, height),
+            config: shape.config(),
+            projector: LogoProjector::default(),
+        }
+    }
+
+    pub fn project(&mut self) -> u64 {
+        self.elapsed += Duration::from_millis(66);
+        benchmark_logo_projection(self.elapsed, self.size, &self.config, &mut self.projector)
+    }
+}
 
 /// Shape of the retained transcript fixture.
 #[derive(Clone, Copy, Debug)]

crates/warp_tui/src/editor_element.rs

@@ -890,7 +890,9 @@ impl TuiElement for TuiEditorElement {
                     handler(TuiEditorAction::PasteText(text.clone()), event_ctx);
                     return true;
                 }
-                TuiEvent::ModifierKeyChanged { .. }
+                TuiEvent::FocusGained
+                | TuiEvent::FocusLost
+                | TuiEvent::ModifierKeyChanged { .. }
                 | TuiEvent::ScrollWheel { .. }
                 | TuiEvent::LeftMouseDown { .. }
                 | TuiEvent::LeftMouseUp { .. }

crates/warp_tui/src/option_selector.rs

@@ -1711,7 +1711,9 @@ impl TuiElement for SelectorInputElement {
                 true
             }
             TuiEvent::Paste { .. } => false,
-            TuiEvent::ModifierKeyChanged { .. }
+            TuiEvent::FocusGained
+            | TuiEvent::FocusLost
+            | TuiEvent::ModifierKeyChanged { .. }
             | TuiEvent::LeftMouseDown { .. }
             | TuiEvent::LeftMouseUp { .. }
             | TuiEvent::LeftMouseDragged { .. }

crates/warp_tui/src/terminal_content_element.rs

@@ -176,6 +176,7 @@ impl TuiElement for TuiTerminalContentElement {
                         return true;
                     }
                 }
+                TuiEvent::FocusGained | TuiEvent::FocusLost => {}
                 TuiEvent::ScrollWheel { .. }
                 | TuiEvent::LeftMouseDown { .. }
                 | TuiEvent::LeftMouseUp { .. }
@@ -257,7 +258,9 @@ fn forwarded_pty_input_for_event<'a>(
                 possible_typeahead: Some(Cow::Owned(normalized)),
             })
         }
-        TuiEvent::KeyDown {
+        TuiEvent::FocusGained
+        | TuiEvent::FocusLost
+        | TuiEvent::KeyDown {
             is_composing: true, ..
         }
         | TuiEvent::ModifierKeyChanged { .. }