feat(tui): implement TUI input view milestone 1 (warpdotdev#13064)

## Description

Implements the TUI input view (Milestone 1) as specified in
`specs/tui-input-view/TECH.md`. This is the first functional
editor-backed text input for the TUI rendering path.

**What's in this PR:**

### Prerequisite refactor in `crates/editor/` (~580 LOC + ~200 LOC
tests, no GUI-path regressions)

- **`ColumnUnit` enum** on `SoftWrapPoint`: replaces the bare `Pixels`
column with an explicit `ColumnUnit::Pixels(Pixels)` /
`ColumnUnit::Chars(u16)` discriminant so the GUI and TUI coordinate
spaces are enforced at the type level (cross-variant ops
`debug_assert!`). The ~15 construction sites and
`SelectionModel::goal_xs` (now `Option<Vec1<ColumnUnit>>`) /
`NavigationResult::goal_x` are updated; `navigate_line` sticky-column
logic is unchanged in shape.

- **`LayoutMode` on `RenderState`**: adds
`LayoutMode::CharCell(CharCellState)` alongside the existing
`LayoutMode::Pixels` path (`CharCellState` holds `terminal_width`,
`line_starts`, `total_chars`). In CharCell mode `handle_layout_action`
skips font shaping entirely, and `offset_to_softwrap_point` /
`softwrap_point_to_offset` / `max_line` use pure char-cell integer
arithmetic. New APIs: `RenderState::new_tui(terminal_width, styles,
ctx)`, `is_char_cell_mode()`, `update_char_cell_text(text)`,
`set_char_cell_terminal_width(width)`. The styles field is retained for
API compatibility but unused in CharCell mode.

- **`usize → u32` overflow guard**: `char_cell_softwrap_point_to_offset`
treats the final (unbounded) logical line as spanning all remaining
rows, so a target row past the end resolves there instead of
overflowing. Covered by the round-trip unit tests.

### Editor-backed TUI input (no separate model)

There is **no** `TuiInputModel` — the input reuses the existing
`CodeEditorModel` in char-cell mode:

- `app/src/code/editor/model.rs`: adds
`CodeEditorModel::new_tui(terminal_width, ctx)` (shares sub-model wiring
with the GUI `new()` via a `from_content(..)` helper) and
`set_tui_terminal_width(..)`. Its
`CoreEditorModel::on_buffer_version_updated` override drives
`update_char_cell_text` synchronously on every edit when in char-cell
mode (the async font-shaping pipeline is bypassed there). Re-exported
for the TUI front-end via `app/src/editor/mod.rs`.

- `crates/warp_tui/src/input/` (~1.2k LOC incl. tests):
- `kill_buffer.rs`: single-entry kill buffer (Ctrl+K / Ctrl+U / Ctrl+W →
Ctrl+Y yank)
- `view.rs`: `TuiInputView` implementing `TuiView` + `TypedActionView`.
Holds `ModelHandle<CodeEditorModel>` plus TUI session state (kill
buffer, scroll offset, terminal width, `max_visible_rows = 6`). Full
Emacs/readline keybinding dispatch via a `TuiInputAction` enum
(Ctrl+A/E/B/F/P/N/K/U/W/Y/H/D/Z, word movement, Shift+arrows,
Shift+Enter). Renders via pure char-cell helpers; `TuiInputElement`
paints rows, applies `Modifier::REVERSED` to selection spans, and
reports the block cursor via `cursor_position()`. Emits
`TuiInputViewEvent::Submitted(String)` on Enter.
  - `view_tests.rs`: drives a real `CodeEditorModel` + `TuiInputView`.

### Spec + examples

- `specs/tui-input-view/TECH.md`: as-built architecture spec (design
rationale, keybinding table, follow-up scope for runtime wiring, input
mode, slash commands, history).
- `crates/warp_tui/examples/tui_input_demo.rs`: interactive
editor-backed input demo (`cargo run -p warp_tui --example
tui_input_demo`).
- `crates/warpui_core/examples/tui_file_viewer.rs`: validates the TUI
rendering/runtime pipeline independently of the editor (scrollable file
viewer).

## Linked Issue

N/A — spec-driven feature, see `specs/tui-input-view/TECH.md`

## Testing

- `crates/editor/src/render/model/mod_tests.rs::char_cell`: 12 unit
tests (max_line, `offset → point → offset` round-trips at multiple
widths, `ColumnUnit::Chars` correctness, multi-line/wrapping
boundaries).
- `crates/warp_tui/src/input/view_tests.rs`: 12 tests driving a real
`CodeEditorModel` + `TuiInputView` (cursor placement, blank-line
navigation, selection text, kill/yank).
- Existing `warp_editor` test suite continues to pass (no GUI-path
behaviour changes).
- `./script/format` and `cargo clippy --workspace --all-targets --tests
-- -D warnings` pass.

Run the examples from a real terminal:
```sh
cargo run -p warp_tui --example tui_input_demo
cargo run -p warpui_core --example tui_file_viewer --features tui -- specs/tui-input-view/TECH.md
```

Wiring `TuiInputView` into the `warp-tui` binary's runtime (today only
auth runs there) is the next step.

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

Conversation:
https://staging.warp.dev/conversation/c5b70ee0-60c6-49f9-908c-2e3275949d37

CHANGELOG-NEW-FEATURE: TUI input view (Milestone 1): multi-line,
Emacs/readline keybindings, editor-backed via CodeEditorModel +
SelectionModel + CharCell RenderState

Author: kevinyang372

Cargo.lock

@@ -463,7 +463,7 @@ embed-resource = "3.0"
 
 # Note that we support channel-specific enables for these features
 [features]
-tui = []
+tui = ["warpui_core/tui"]
 ai_resume_button = []
 autoupdate = []
 figma_detection = []

app/Cargo.toml

@@ -47,8 +47,9 @@ use warp_editor::editor::TextDecoration;
 use warp_editor::model::{CoreEditorModel, PlainTextEditorModel};
 use warp_editor::multiline::{AnyMultilineString, MultilineString, LF};
 use warp_editor::render::model::{
-    AutoScrollMode, BlockItem, Decoration, LineCount, LineDecoration, RenderEvent,
-    RenderLineLocation, RenderState, RichTextStyles, StyleUpdateAction,
+    AutoScrollMode, BlockItem, BlockSpacings, BrokenLinkStyle, CheckBoxStyle, ColumnUnit,
+    Decoration, HorizontalRuleStyle, InlineCodeStyle, LineCount, LineDecoration, ParagraphStyles,
+    RenderEvent, RenderLineLocation, RenderState, RichTextStyles, StyleUpdateAction, TableStyle,
     UpdateDecorationAfterLayout, WidthSetting,
 };
 use warp_editor::selection::{SelectionMode, SelectionModel, TextDirection, TextUnit};
@@ -332,6 +333,72 @@ impl CodeEditorModel {
         content.update(ctx, |buffer, _| {
             buffer.set_session_platform(session_platform);
         });
+
+        Self::from_content(
+            content,
+            true,        // show_current_line_highlights
+            lazy_layout, // lazy_layout_enabled
+            false,       // lazy_layout_initialized
+            ctx,
+            |hidden_lines, ctx| {
+                ctx.add_model(|ctx| {
+                    RenderState::new(text_styles, lazy_layout, Some(hidden_lines.clone()), ctx)
+                        .with_width_setting(WidthSetting::InfiniteWidth)
+                })
+            },
+        )
+    }
+
+    /// Constructs a `CodeEditorModel` in TUI char-cell mode.
+    ///
+    /// Identical to `new` but creates the `RenderState` with
+    /// [`LayoutMode::CharCell`] so all soft-wrap positions use monospace
+    /// character-count arithmetic rather than font-aware pixel layout.
+    /// `TuiEditorModel` (in `warp_tui`) is a type alias for this type;
+    /// constructing via this method is what gives the TUI editor all of
+    /// `CodeEditorModel`'s features (vim, syntax, diff, hidden lines) for free
+    /// while sharing no GUI-rendering infrastructure.
+    ///
+    /// Like `new`, this reads syntax-highlight colors from the `Appearance`
+    /// singleton, so callers must register `Appearance` (a real one for the
+    /// runtime, `Appearance::mock()` for tests) before constructing the model.
+    pub fn new_tui(terminal_width: u16, ctx: &mut ModelContext<Self>) -> Self {
+        let content = ctx.add_model(|_| Buffer::new(Box::new(|_, _| IndentBehavior::Ignore)));
+
+        Self::from_content(
+            content,
+            false, // show_current_line_highlights: no GPU rendering in TUI
+            false, // lazy_layout_enabled: no lazy layout in TUI
+            true,  // lazy_layout_initialized: no lazy layout in TUI
+            ctx,
+            |_hidden_lines, ctx| {
+                // CharCell layout never consults `RichTextStyles`, so pass a stub.
+                ctx.add_model(|ctx| {
+                    RenderState::new_tui(terminal_width, Self::tui_stub_text_styles(), ctx)
+                })
+            },
+        )
+    }
+
+    /// Shared construction for [`Self::new`] and [`Self::new_tui`]. The two modes
+    /// differ only in how the backing `content` buffer and the `RenderState` are
+    /// built (GUI pixel layout vs. TUI char-cell layout) plus a few flags; all
+    /// other sub-models (selection, syntax tree, diff, hidden lines, comments)
+    /// and event subscriptions are identical and wired up here.
+    ///
+    /// `build_render_state` receives the freshly-created `hidden_lines` handle so
+    /// the GUI path can attach it; the TUI path ignores it.
+    fn from_content(
+        content: ModelHandle<Buffer>,
+        show_current_line_highlights: bool,
+        lazy_layout_enabled: bool,
+        lazy_layout_initialized: bool,
+        ctx: &mut ModelContext<Self>,
+        build_render_state: impl FnOnce(
+            &ModelHandle<HiddenLinesModel>,
+            &mut ModelContext<Self>,
+        ) -> ModelHandle<RenderState>,
+    ) -> Self {
         ctx.subscribe_to_model(&content, |me, _, event, ctx| {
             me.handle_content_model_event(event, ctx);
         });
@@ -355,10 +422,7 @@ impl CodeEditorModel {
         let hidden_lines =
             ctx.add_model(|_| HiddenLinesModel::new(content.clone(), selection_model.clone()));
 
-        let render_state = ctx.add_model(|ctx| {
-            RenderState::new(text_styles, lazy_layout, Some(hidden_lines.clone()), ctx)
-                .with_width_setting(WidthSetting::InfiniteWidth)
-        });
+        let render_state = build_render_state(&hidden_lines, ctx);
         ctx.subscribe_to_model(&render_state, |me, _, event, ctx| {
             me.handle_render_state_model_event(event, ctx);
         });
@@ -388,17 +452,96 @@ impl CodeEditorModel {
             hidden_lines,
             diff_navigation_state: DiffNavigationState::Collapsed,
             interaction_state: InteractionState::Editable,
-            show_current_line_highlights: true,
+            show_current_line_highlights,
             delay_rendering: None,
             vim_visual_tails: vec![],
             hovered_symbol_range: None,
             hide_lines_outside_of_active_diff: None,
-            lazy_layout_enabled: lazy_layout,
-            lazy_layout_initialized: false,
+            lazy_layout_enabled,
+            lazy_layout_initialized,
             pending_syntax_tree_bootstrap: false,
         }
     }
 
+    /// A minimal [`RichTextStyles`] for the TUI char-cell editor.
+    ///
+    /// `RenderState::new_tui` stores styles only for API compatibility and never
+    /// uses them for char-cell layout, so these values are placeholders. This
+    /// lives here (the caller of `RenderState::new_tui`) rather than in the core
+    /// editor crate so the editor API doesn't carry a TUI-specific stub.
+    fn tui_stub_text_styles() -> RichTextStyles {
+        use warpui::elements::{Border, Fill};
+        use warpui::fonts::{FamilyId, Weight};
+
+        const TRANSPARENT: warpui::color::ColorU = warpui::color::ColorU {
+            r: 0,
+            g: 0,
+            b: 0,
+            a: 0,
+        };
+        let paragraph = |fixed_width_tab_size| ParagraphStyles {
+            font_family: FamilyId(0),
+            font_size: 10.,
+            font_weight: Weight::Normal,
+            line_height_ratio: 1.,
+            text_color: TRANSPARENT,
+            baseline_ratio: 0.7,
+            fixed_width_tab_size,
+        };
+        RichTextStyles {
+            base_text: paragraph(None),
+            code_text: paragraph(Some(4)),
+            code_background: Fill::None,
+            embedding_background: Fill::None,
+            embedding_text: paragraph(None),
+            code_border: Border::new(0.),
+            placeholder_color: TRANSPARENT,
+            selection_fill: Fill::None,
+            cursor_fill: Fill::None,
+            inline_code_style: InlineCodeStyle {
+                font_family: FamilyId(0),
+                background: TRANSPARENT,
+                font_color: TRANSPARENT,
+            },
+            check_box_style: CheckBoxStyle {
+                border_width: 0.,
+                border_color: TRANSPARENT,
+                icon_path: "",
+                background: TRANSPARENT,
+                hover_background: TRANSPARENT,
+            },
+            horizontal_rule_style: HorizontalRuleStyle {
+                rule_height: 0.,
+                color: TRANSPARENT,
+            },
+            broken_link_style: BrokenLinkStyle {
+                icon_path: "",
+                icon_color: TRANSPARENT,
+            },
+            block_spacings: BlockSpacings::default(),
+            minimum_paragraph_height: None,
+            show_placeholder_text_on_empty_block: false,
+            cursor_width: 0.,
+            highlight_urls: false,
+            table_style: TableStyle {
+                border_color: TRANSPARENT,
+                header_background: TRANSPARENT,
+                cell_background: TRANSPARENT,
+                alternate_row_background: None,
+                text_color: TRANSPARENT,
+                header_text_color: TRANSPARENT,
+                scrollbar_nonactive_thumb_color: TRANSPARENT,
+                scrollbar_active_thumb_color: TRANSPARENT,
+                font_family: FamilyId(0),
+                font_size: 10.,
+                cell_padding: 0.,
+                outer_border: false,
+                column_dividers: false,
+                row_dividers: false,
+            },
+        }
+    }
+
     fn should_defer_syntax_tree_parsing(&self) -> bool {
         self.lazy_layout_enabled && !self.lazy_layout_initialized
     }
@@ -1588,8 +1731,6 @@ impl CodeEditorModel {
     fn update_cursor_line_highlights(&self, ctx: &mut ModelContext<CodeEditorModel>) {
         let selection_model = self.selection_model.as_ref(ctx);
 
-        let overlay = Appearance::as_ref(ctx).theme().surface_2();
-
         let highlight_line = if self.diff_nav_is_active() {
             // We don't show current line highlights during diff navigation so we don't need
             // to update the `RenderState`. This lets us keep the line decorations we set
@@ -1598,6 +1739,7 @@ impl CodeEditorModel {
         } else if selection_model.all_single_cursors() && self.show_current_line_highlights {
             // When diff is not expanded, the only source of line decoration is highlights
             // from the active cursor, e.g. the current line highlight.
+            let overlay = Appearance::as_ref(ctx).theme().surface_2();
             Some(
                 selection_model
                     .selected_lines(ctx)
@@ -2435,7 +2577,7 @@ impl CodeEditorModel {
             if let Some(existing) = self.selection().as_ref(ctx).goal_xs.as_ref() {
                 existing
                     .iter()
-                    .map(|px| px.as_f32().round() as u32)
+                    .map(|col| col.as_pixels().as_f32().round() as u32)
                     .collect()
             } else {
                 current_selections
@@ -2476,10 +2618,11 @@ impl CodeEditorModel {
         if let Ok(new_selections) = Vec1::try_from_vec(new_selections_vec) {
             self.vim_set_selections(new_selections, AutoScrollBehavior::Selection, ctx);
 
-            // Update goal_xs to the desired columns (stored as pixels for consistency with SelectionModel)
+            // Update goal_xs to the desired columns (stored as ColumnUnit::Pixels for
+            // consistency with the GUI SelectionModel pixel path)
             let goal_pixels: Vec<_> = goal_cols
                 .into_iter()
-                .map(|c| (c as usize).into_pixels())
+                .map(|c| ColumnUnit::Pixels((c as usize).into_pixels()))
                 .collect();
             self.selection().update(ctx, |selection, _| {
                 selection.goal_xs = Vec1::try_from_vec(goal_pixels).ok();
@@ -3649,11 +3792,19 @@ impl CoreEditorModel for CodeEditorModel {
         buffer_version: BufferVersion,
         ctx: &mut ModelContext<Self::T>,
     ) {
-        // Synchronously convert hidden range anchors into offsets for the given version. This allows the render model
-        // to accurately hide line ranges based on the corresponding incoming buffer state.
+        // Synchronously convert hidden range anchors into offsets for the given version. This allows
+        // the render model to accurately hide line ranges based on the corresponding incoming buffer state.
         self.hidden_lines.update(ctx, |hidden_lines_model, ctx| {
             hidden_lines_model.materialize_hidden_range_offsets(buffer_version, ctx);
         });
+        // In TUI char-cell mode the async font-shaping pipeline is bypassed entirely (the
+        // LayoutAction::BufferEdit arm is a no-op for CharCell). We must therefore refresh the
+        // char-cell line index synchronously here so that offset_to_softwrap_point, max_line,
+        // and all cursor-positioning queries see up-to-date data in the same frame.
+        if let Some(char_cell) = self.render_state.as_ref(ctx).char_cell() {
+            let text = self.content.as_ref(ctx).text().into_string();
+            char_cell.update_text(&text);
+        }
     }
 
     fn content(&self) -> &ModelHandle<Buffer> {

app/src/code/editor/model.rs

@@ -13,6 +13,10 @@ pub use view::*;
 pub use warpui::text::point::Point;
 use warpui::AppContext;
 
+// Re-exported for use by the `warp_tui` TUI front-end, which needs to
+// construct and subscribe to `CodeEditorModel` in char-cell mode.
+pub use crate::code::editor::model::{CodeEditorModel, CodeEditorModelEvent};
+
 pub fn init(app: &mut AppContext) {
     view::init(app);
 }

app/src/editor/mod.rs

@@ -46,6 +46,7 @@ string-offset.workspace = true
 sum_tree.workspace = true
 thiserror.workspace = true
 pathfinder_color = "0.5.0"
+unicode-width.workspace = true
 vec1.workspace = true
 warpui_core.workspace = true
 warp_core.workspace = true