Improve map UX: direction carets, stations, search tooltips

- Shrink sidebar from 30% to 18% for better map aspect ratio
- Replace cluttered train number labels with directional carets
(▲▶▼◀ etc.) — only show label on selected train as tooltip
- Speed-based animation: trains pulse at rates proportional to
velocity (stopped=dim, slow=8-tick, medium=4-tick, fast=2-tick)
- Add 561 Amtrak stations to the map with zoom-level filtering
- Station mode (s key): departure-board view showing trains
arriving/departing the selected station
- Fetch and decrypt station data from Amtrak's station API

53 tests passing, zero clippy warnings.

Co-Authored-By: Claude Opus 4.6 (1M context) <[e-mail]>

.gitignore

···
 decrypt.js
 utility.js
 xdr.js
+stations_sample.json
+__pycache__/

src/api.rs

···
 use serde::Deserialize;
 
 use crate::crypto::{self, DecryptionKeys};
-use crate::model::{self, Train};
+use crate::model::{self, Station, Train};
 
 const TRAINS_URL: &str = "https://maps.amtrak.com/services/MapDataService/trains/getTrainsData";
+const STATIONS_URL: &str = "https://maps.amtrak.com/services/MapDataService/stations/trainStations";
 const ROUTES_URL: &str = "https://maps.amtrak.com/rttl/js/RoutesList.json";
 const ROUTES_V_URL: &str = "https://maps.amtrak.com/rttl/js/RoutesList.v.json";
 
···
         salt,
         iv,
     })
+}
+
+pub async fn fetch_stations(
+    client: &reqwest::Client,
+    keys: &DecryptionKeys,
+) -> Result<Vec<Station>> {
+    let encrypted = client
+        .get(STATIONS_URL)
+        .send()
+        .await
+        .context("failed to fetch station data")?
+        .text()
+        .await
+        .context("failed to read station data response")?;
+
+    let json = crypto::decrypt_train_data(encrypted.trim(), keys)
+        .context("failed to decrypt station data")?;
+
+    model::parse_station_response(&json)
 }
 
 pub async fn fetch_trains(client: &reqwest::Client, keys: &DecryptionKeys) -> Result<Vec<Train>> {

src/app.rs

···
 // Application state - viewport, selected train, etc.
 
 use crate::geo::GeoLayers;
-use crate::model::{DelayStatus, Train, TrainState};
+use crate::model::{DelayStatus, Station, Train, TrainState};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum InputMode {
···
 pub struct App {
     pub viewport: Viewport,
     pub trains: Vec<Train>,
+    pub stations: Vec<Station>,
     pub geo: Option<GeoLayers>,
     pub selected_index: Option<usize>,
+    pub selected_station: Option<usize>,
+    pub station_mode: bool,
     pub should_quit: bool,
     pub last_update: Option<std::time::Instant>,
     pub status_message: String,
     pub input_mode: InputMode,
     pub search_query: String,
+    pub animation_tick: u64,
 }
 
 impl Default for App {
···
         Self {
             viewport: Viewport::conus(),
             trains: Vec::new(),
+            stations: Vec::new(),
             geo,
             selected_index: None,
+            selected_station: None,
+            station_mode: false,
             should_quit: false,
             last_update: None,
             status_message: "Loading...".into(),
             input_mode: InputMode::Normal,
             search_query: String::new(),
+            animation_tick: 0,
         }
     }
 
···
         self.selected_index = None;
     }
 
+    pub fn tick(&mut self) {
+        self.animation_tick = self.animation_tick.wrapping_add(1);
+    }
+
+    pub fn is_train_bright(&self, velocity: f64) -> bool {
+        if velocity == 0.0 {
+            return false;
+        }
+        let period = if velocity < 20.0 {
+            8
+        } else if velocity < 60.0 {
+            4
+        } else {
+            2
+        };
+        self.animation_tick.is_multiple_of(period)
+    }
+
+    pub fn zoom_detail_level(&self) -> u32 {
+        let w = self.viewport.width();
+        if w > 40.0 {
+            4
+        } else if w > 20.0 {
+            5
+        } else if w > 10.0 {
+            6
+        } else {
+            7
+        }
+    }
+
+    pub fn visible_stations(&self) -> Vec<&Station> {
+        let level = self.zoom_detail_level();
+        self.stations
+            .iter()
+            .filter(|s| s.zoom_level <= level)
+            .filter(|s| self.viewport.contains(s.lon, s.lat))
+            .collect()
+    }
+
+    pub fn trains_at_station(&self, station_code: &str) -> Vec<&Train> {
+        self.trains
+            .iter()
+            .filter(|t| t.state == TrainState::Active)
+            .filter(|t| {
+                t.origin == station_code
+                    || t.destination == station_code
+                    || t.stations.iter().any(|s| s.code == station_code)
+            })
+            .collect()
+    }
+
+    pub fn toggle_station_mode(&mut self) {
+        self.station_mode = !self.station_mode;
+        if self.station_mode {
+            let visible = self.visible_stations();
+            if !visible.is_empty() {
+                self.selected_station = Some(0);
+            }
+        } else {
+            self.selected_station = None;
+        }
+    }
+
+    pub fn select_next_station(&mut self) {
+        let count = self.visible_stations().len();
+        if count == 0 {
+            self.selected_station = None;
+            return;
+        }
+        self.selected_station = Some(match self.selected_station {
+            None => 0,
+            Some(i) => (i + 1) % count,
+        });
+    }
+
+    pub fn select_prev_station(&mut self) {
+        let count = self.visible_stations().len();
+        if count == 0 {
+            self.selected_station = None;
+            return;
+        }
+        self.selected_station = Some(match self.selected_station {
+            None => count - 1,
+            Some(0) => count - 1,
+            Some(i) => i - 1,
+        });
+    }
+
     pub fn reset_view(&mut self) {
         self.viewport = Viewport::conus();
         self.selected_index = None;
+        self.selected_station = None;
+        self.station_mode = false;
         self.search_query.clear();
         self.input_mode = InputMode::Normal;
     }
···
             app.selected_index, None,
             "selection should reset on search change"
         );
+    }
+
+    // --- Animation tick and brightness ---
+
+    #[test]
+    fn test_tick_increments() {
+        let mut app = App::new();
+        assert_eq!(app.animation_tick, 0);
+        app.tick();
+        assert_eq!(app.animation_tick, 1);
+        app.tick();
+        assert_eq!(app.animation_tick, 2);
+    }
+
+    #[test]
+    fn test_is_train_bright_stopped() {
+        let app = App::new();
+        // velocity == 0 is always dim
+        assert!(!app.is_train_bright(0.0));
+    }
+
+    #[test]
+    fn test_is_train_bright_slow() {
+        let mut app = App::new();
+        // velocity < 20: bright every 8 ticks
+        assert!(app.is_train_bright(10.0)); // tick 0
+        app.tick(); // tick 1
+        assert!(!app.is_train_bright(10.0));
+        for _ in 0..7 {
+            app.tick();
+        }
+        // tick 8
+        assert!(app.is_train_bright(10.0));
+    }
+
+    #[test]
+    fn test_is_train_bright_medium() {
+        let mut app = App::new();
+        // velocity < 60: bright every 4 ticks
+        assert!(app.is_train_bright(40.0)); // tick 0
+        app.tick();
+        assert!(!app.is_train_bright(40.0)); // tick 1
+        app.tick();
+        app.tick();
+        app.tick();
+        // tick 4
+        assert!(app.is_train_bright(40.0));
+    }
+
+    #[test]
+    fn test_is_train_bright_fast() {
+        let mut app = App::new();
+        // velocity >= 60: bright every 2 ticks
+        assert!(app.is_train_bright(80.0)); // tick 0
+        app.tick();
+        assert!(!app.is_train_bright(80.0)); // tick 1
+        app.tick();
+        assert!(app.is_train_bright(80.0)); // tick 2
+    }
+
+    // --- Station methods ---
+
+    #[test]
+    fn test_visible_stations_filters_by_viewport_and_zoom() {
+        let mut app = App::new();
+        // Default CONUS viewport width is 70, so zoom_detail_level = 4
+        app.stations = vec![
+            Station {
+                code: "CHI".into(),
+                name: "Chicago".into(),
+                city: "Chicago".into(),
+                state: "IL".into(),
+                lon: -87.6,
+                lat: 41.8,
+                station_type: "Station".into(),
+                zoom_level: 4,
+            },
+            Station {
+                code: "ABE".into(),
+                name: "Aberdeen".into(),
+                city: "Aberdeen".into(),
+                state: "MD".into(),
+                lon: -76.2,
+                lat: 39.5,
+                station_type: "Station".into(),
+                zoom_level: 5, // too detailed for level 4
+            },
+            Station {
+                code: "LDN".into(),
+                name: "London".into(),
+                city: "London".into(),
+                state: "UK".into(),
+                lon: 0.0,
+                lat: 51.5,
+                station_type: "Station".into(),
+                zoom_level: 4, // out of viewport
+            },
+        ];
+
+        let visible = app.visible_stations();
+        assert_eq!(visible.len(), 1);
+        assert_eq!(visible[0].code, "CHI");
+    }
+
+    #[test]
+    fn test_trains_at_station() {
+        let mut app = App::new();
+        app.trains = vec![
+            Train {
+                number: "1".into(),
+                route_name: "Test".into(),
+                origin: "CHI".into(),
+                destination: "NYP".into(),
+                lon: -87.6,
+                lat: 41.8,
+                velocity: 50.0,
+                heading: "E".into(),
+                state: TrainState::Active,
+                status_msg: String::new(),
+                stations: vec![
+                    crate::model::StationStop {
+                        code: "CHI".into(),
+                        comment: None,
+                    },
+                    crate::model::StationStop {
+                        code: "TOL".into(),
+                        comment: None,
+                    },
+                ],
+            },
+            Train {
+                number: "2".into(),
+                route_name: "Test2".into(),
+                origin: "NYP".into(),
+                destination: "BOS".into(),
+                lon: -73.9,
+                lat: 40.7,
+                velocity: 60.0,
+                heading: "NE".into(),
+                state: TrainState::Active,
+                status_msg: String::new(),
+                stations: vec![],
+            },
+        ];
+
+        let at_chi = app.trains_at_station("CHI");
+        assert_eq!(at_chi.len(), 1);
+        assert_eq!(at_chi[0].number, "1");
+
+        let at_nyp = app.trains_at_station("NYP");
+        assert_eq!(at_nyp.len(), 2); // train 1 destination + train 2 origin
+
+        let at_tol = app.trains_at_station("TOL");
+        assert_eq!(at_tol.len(), 1); // train 1 has TOL in stations list
+    }
+
+    #[test]
+    fn test_toggle_station_mode() {
+        let mut app = App::new();
+        app.stations = vec![Station {
+            code: "CHI".into(),
+            name: "Chicago".into(),
+            city: "Chicago".into(),
+            state: "IL".into(),
+            lon: -87.6,
+            lat: 41.8,
+            station_type: "Station".into(),
+            zoom_level: 4,
+        }];
+
+        assert!(!app.station_mode);
+        app.toggle_station_mode();
+        assert!(app.station_mode);
+        assert_eq!(app.selected_station, Some(0));
+        app.toggle_station_mode();
+        assert!(!app.station_mode);
+        assert_eq!(app.selected_station, None);
+    }
+
+    #[test]
+    fn test_zoom_detail_level() {
+        let mut app = App::new();
+        // Default CONUS = 70 degrees wide
+        assert_eq!(app.zoom_detail_level(), 4);
+
+        app.viewport.x_min = -100.0;
+        app.viewport.x_max = -70.0; // width = 30
+        assert_eq!(app.zoom_detail_level(), 5);
+
+        app.viewport.x_min = -90.0;
+        app.viewport.x_max = -75.0; // width = 15
+        assert_eq!(app.zoom_detail_level(), 6);
+
+        app.viewport.x_min = -90.0;
+        app.viewport.x_max = -82.0; // width = 8
+        assert_eq!(app.zoom_detail_level(), 7);
     }
 
     #[test]

src/main.rs

···
         }
     }
 
+    // Fetch stations
+    app.status_message = format!("{} | Fetching stations...", app.status_message);
+    terminal.draw(|f| ui::draw(f, &app))?;
+    match api::fetch_stations(&client, &keys).await {
+        Ok(stations) => {
+            let count = stations.len();
+            app.stations = stations;
+            app.status_message = format!("Loaded {} stations", count);
+        }
+        Err(e) => {
+            app.status_message = format!("Station error: {}", e);
+        }
+    }
+
     loop {
+        app.tick();
         terminal.draw(|f| ui::draw(f, &app))?;
 
         // Poll for events with a short timeout so we can check for refresh
···
                         (KeyCode::Down, _) => app.viewport.pan(0.0, -0.15),
 
                         // Selection
-                        (KeyCode::Tab, _) => app.select_next(),
-                        (KeyCode::BackTab, _) => app.select_prev(),
+                        (KeyCode::Tab, _) => {
+                            if app.station_mode {
+                                app.select_next_station();
+                            } else {
+                                app.select_next();
+                            }
+                        }
+                        (KeyCode::BackTab, _) => {
+                            if app.station_mode {
+                                app.select_prev_station();
+                            } else {
+                                app.select_prev();
+                            }
+                        }
 
                         // Jump to selected train
                         (KeyCode::Enter, _) => {
···
 
                         // Search
                         (KeyCode::Char('/'), _) => app.enter_search(),
+
+                        // Station selection mode
+                        (KeyCode::Char('s'), _) => {
+                            if app.station_mode {
+                                // In station mode, Tab/Shift-Tab cycle stations
+                                // Toggle off
+                                app.toggle_station_mode();
+                            } else {
+                                app.toggle_station_mode();
+                            }
+                        }
 
                         // Reset view
                         (KeyCode::Char('0'), _) => app.reset_view(),

src/model.rs

···
     }
 }
 
+pub fn heading_to_caret(heading: &str) -> &'static str {
+    match heading {
+        "N" => "▲",
+        "NE" => "◥",
+        "E" => "▶",
+        "SE" => "◢",
+        "S" => "▼",
+        "SW" => "◣",
+        "W" => "◀",
+        "NW" => "◤",
+        _ => "●",
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct Station {
+    pub code: String,
+    pub name: String,
+    pub city: String,
+    pub state: String,
+    pub lon: f64,
+    pub lat: f64,
+    pub station_type: String,
+    pub zoom_level: u32,
+}
+
+pub fn parse_station_response(json: &str) -> Result<Vec<Station>> {
+    let data: serde_json::Value =
+        serde_json::from_str(json).context("failed to parse station JSON")?;
+    let response = data
+        .get("StationsDataResponse")
+        .context("missing StationsDataResponse key")?;
+    let features = response
+        .get("features")
+        .and_then(|f| f.as_array())
+        .context("missing features array")?;
+
+    let mut stations = Vec::new();
+    for feat in features {
+        let geom = feat.get("geometry").and_then(|g| g.get("coordinates"));
+        let props = feat.get("properties");
+        if let (Some(coords), Some(props)) = (geom, props) {
+            let coords_arr = coords.as_array();
+            if let Some(coords_arr) = coords_arr {
+                let lon = coords_arr.first().and_then(|v| v.as_f64()).unwrap_or(0.0);
+                let lat = coords_arr.get(1).and_then(|v| v.as_f64()).unwrap_or(0.0);
+
+                let get_str = |key: &str| -> String {
+                    props
+                        .get(key)
+                        .and_then(|v| v.as_str())
+                        .unwrap_or("")
+                        .trim()
+                        .to_string()
+                };
+
+                let zoom_level: u32 = get_str("MapZmLvl").parse().unwrap_or(7);
+
+                stations.push(Station {
+                    code: get_str("Code"),
+                    name: get_str("StationName"),
+                    city: get_str("City"),
+                    state: get_str("State"),
+                    lon,
+                    lat,
+                    station_type: get_str("StaType"),
+                    zoom_level,
+                });
+            }
+        }
+    }
+    Ok(stations)
+}
+
 pub fn parse_train_response(json: &str) -> Result<Vec<Train>> {
     let collection: geojson::FeatureCollection =
         serde_json::from_str(json).context("failed to parse GeoJSON")?;
···
             comment: Some("15 MI LATE".into()),
         });
         assert_eq!(train.delay_status(), DelayStatus::Late);
+    }
+
+    #[test]
+    fn test_heading_to_caret() {
+        assert_eq!(heading_to_caret("N"), "▲");
+        assert_eq!(heading_to_caret("NE"), "◥");
+        assert_eq!(heading_to_caret("E"), "▶");
+        assert_eq!(heading_to_caret("SE"), "◢");
+        assert_eq!(heading_to_caret("S"), "▼");
+        assert_eq!(heading_to_caret("SW"), "◣");
+        assert_eq!(heading_to_caret("W"), "◀");
+        assert_eq!(heading_to_caret("NW"), "◤");
+        assert_eq!(heading_to_caret(""), "●");
+        assert_eq!(heading_to_caret("XYZ"), "●");
+    }
+
+    #[test]
+    fn test_parse_station_response() {
+        let json = r#"{
+            "StationsDataResponse": {
+                "type": "FeatureCollection",
+                "features": [
+                    {
+                        "type": "Feature",
+                        "id": 1,
+                        "geometry": { "type": "Point", "coordinates": [-76.163, 39.508] },
+                        "properties": {
+                            "Code": "ABE",
+                            "StationName": "Aberdeen, MD",
+                            "City": "Aberdeen",
+                            "State": "MD",
+                            "StaType": "Station Building (with waiting room)",
+                            "MapZmLvl": "5"
+                        }
+                    },
+                    {
+                        "type": "Feature",
+                        "id": 2,
+                        "geometry": { "type": "Point", "coordinates": [-74.501, 39.424] },
+                        "properties": {
+                            "Code": "ABN",
+                            "StationName": "Absecon, NJ",
+                            "City": "Absecon",
+                            "State": "NJ",
+                            "StaType": "Platform with Shelter",
+                            "MapZmLvl": "5"
+                        }
+                    }
+                ]
+            }
+        }"#;
+
+        let stations = parse_station_response(json).unwrap();
+        assert_eq!(stations.len(), 2);
+        assert_eq!(stations[0].code, "ABE");
+        assert_eq!(stations[0].city, "Aberdeen");
+        assert_eq!(stations[0].state, "MD");
+        assert_eq!(stations[0].zoom_level, 5);
+        assert!((stations[0].lon - (-76.163)).abs() < 0.001);
+        assert!((stations[0].lat - 39.508).abs() < 0.001);
+        assert_eq!(stations[1].code, "ABN");
+    }
+
+    #[test]
+    fn test_parse_station_response_missing_key() {
+        let json = r#"{"features": []}"#;
+        assert!(parse_station_response(json).is_err());
     }
 
     #[test]

src/ui.rs

···
 
 use crate::app::App;
 use crate::geo::LineSegment;
-use crate::model::{DelayStatus, TrainState};
+use crate::model::{heading_to_caret, DelayStatus, TrainState};
 
 fn delay_color(status: &DelayStatus) -> Color {
     match status {
···
     // Main layout: map on top/left, info panel on right
     let main_chunks = Layout::default()
         .direction(Direction::Horizontal)
-        .constraints([Constraint::Percentage(70), Constraint::Percentage(30)])
+        .constraints([Constraint::Percentage(82), Constraint::Percentage(18)])
         .split(frame.area());
 
     draw_map(frame, app, main_chunks[0]);
···
     lon: f64,
     lat: f64,
     number: String,
+    caret: &'static str,
     color: Color,
+    is_bright: bool,
+    is_selected: bool,
+}
+
+struct StationDot {
+    lon: f64,
+    lat: f64,
+    code: String,
+    is_selected: bool,
 }
 
 /// Convert LineSegments into owned (x1,y1,x2,y2,color) tuples for the paint closure.
···
     let vp = &app.viewport;
     let vp_width = vp.width();
 
+    let selected_number = app.selected_train().map(|t| t.number.clone());
+
     // Collect train dots into owned data for the 'static paint closure
     let dots: Vec<TrainDot> = app
         .trains
         .iter()
         .filter(|t| t.state == TrainState::Active)
-        .map(|t| TrainDot {
-            lon: t.lon,
-            lat: t.lat,
-            number: t.number.clone(),
-            color: delay_color(&t.delay_status()),
+        .map(|t| {
+            let is_selected = selected_number.as_deref() == Some(&t.number);
+            TrainDot {
+                lon: t.lon,
+                lat: t.lat,
+                number: t.number.clone(),
+                caret: heading_to_caret(&t.heading),
+                color: delay_color(&t.delay_status()),
+                is_bright: app.is_train_bright(t.velocity),
+                is_selected,
+            }
+        })
+        .collect();
+
+    // Collect station dots
+    let selected_station_code = if app.station_mode {
+        let visible_stations = app.visible_stations();
+        app.selected_station
+            .and_then(|i| visible_stations.get(i))
+            .map(|s| s.code.clone())
+    } else {
+        None
+    };
+    let station_dots: Vec<StationDot> = app
+        .visible_stations()
+        .iter()
+        .map(|s| StationDot {
+            lon: s.lon,
+            lat: s.lat,
+            code: s.code.clone(),
+            is_selected: selected_station_code.as_deref() == Some(&s.code),
         })
         .collect();
 
···
                 });
             }
 
-            // Layer 4: Train markers — use ◆ character for visibility
+            // Layer 4: Station markers
+            for station in &station_dots {
+                let color = if station.is_selected {
+                    Color::White
+                } else {
+                    Color::Rgb(100, 100, 120)
+                };
+                ctx.print(
+                    station.lon,
+                    station.lat,
+                    Span::styled("·", Style::default().fg(color)),
+                );
+                if station.is_selected {
+                    ctx.print(
+                        station.lon + vp_width * 0.012,
+                        station.lat,
+                        Span::styled(
+                            station.code.clone(),
+                            Style::default()
+                                .fg(Color::White)
+                                .add_modifier(Modifier::BOLD),
+                        ),
+                    );
+                }
+            }
+
+            // Layer 5: Train markers — directional carets with speed animation
             for dot in &dots {
+                let fg = if dot.is_bright {
+                    dot.color
+                } else {
+                    Color::DarkGray
+                };
                 ctx.print(
                     dot.lon,
                     dot.lat,
                     Span::styled(
-                        "◆",
-                        Style::default().fg(dot.color).add_modifier(Modifier::BOLD),
+                        dot.caret,
+                        Style::default().fg(fg).add_modifier(Modifier::BOLD),
                     ),
                 );
-                ctx.print(
-                    dot.lon + vp_width * 0.012,
-                    dot.lat,
-                    Span::styled(dot.number.clone(), Style::default().fg(dot.color)),
-                );
+                // Only show number label for the selected train (tooltip)
+                if dot.is_selected {
+                    ctx.print(
+                        dot.lon + vp_width * 0.012,
+                        dot.lat,
+                        Span::styled(dot.number.clone(), Style::default().fg(dot.color)),
+                    );
+                }
             }
         })
         .marker(ratatui::symbols::Marker::Braille);
···
 }
 
 fn draw_train_panel(frame: &mut Frame, app: &App, area: Rect) {
+    // Station departure board mode
+    if app.station_mode {
+        draw_station_panel(frame, app, area);
+        return;
+    }
+
     if let Some(train) = app.selected_train() {
         // Detail view for selected train
         let delay = train.delay_status();
···
             .iter()
             .enumerate()
             .map(|(i, train)| {
-                let color = delay_color(&train.delay_status());
+                let delay = train.delay_status();
+                let color = delay_color(&delay);
                 let selected = app.selected_index == Some(i);
                 let marker = if selected { "▸" } else { " " };
+                let delay_text = match &delay {
+                    DelayStatus::OnTime => " OT".to_string(),
+                    DelayStatus::Early => " E".to_string(),
+                    DelayStatus::Late => {
+                        // Try to extract delay minutes from station comments
+                        let msg = train
+                            .stations
+                            .iter()
+                            .filter_map(|s| s.comment.as_deref())
+                            .find(|c| c.to_uppercase().contains("LATE"))
+                            .unwrap_or("LATE");
+                        format!(" {}", msg)
+                    }
+                    DelayStatus::Unknown => String::new(),
+                };
                 ListItem::new(Line::from(vec![
                     Span::raw(marker),
                     Span::styled(
-                        format!("#{:<5}", train.number),
+                        format!("#{}", train.number),
                         Style::default().fg(color).add_modifier(Modifier::BOLD),
                     ),
-                    Span::styled(
-                        format!(" {}", train.route_name),
-                        Style::default().fg(Color::White),
-                    ),
+                    Span::styled(delay_text, Style::default().fg(color)),
                 ]))
             })
             .collect();
···
     }
 }
 
+fn draw_station_panel(frame: &mut Frame, app: &App, area: Rect) {
+    let visible_stations = app.visible_stations();
+    let selected_station = app
+        .selected_station
+        .and_then(|i| visible_stations.get(i).cloned());
+
+    if let Some(station) = selected_station {
+        let trains = app.trains_at_station(&station.code);
+
+        let mut lines = vec![
+            Line::from(vec![
+                Span::styled(
+                    &station.code,
+                    Style::default()
+                        .fg(Color::White)
+                        .add_modifier(Modifier::BOLD),
+                ),
+                Span::raw(" "),
+                Span::styled(&station.name, Style::default().fg(Color::Gray)),
+            ]),
+            Line::from(""),
+        ];
+
+        if trains.is_empty() {
+            lines.push(Line::from(Span::styled(
+                "No trains",
+                Style::default().fg(Color::DarkGray),
+            )));
+        } else {
+            for train in &trains {
+                let delay = train.delay_status();
+                let color = delay_color(&delay);
+                let caret = heading_to_caret(&train.heading);
+                let delay_label = match &delay {
+                    DelayStatus::OnTime => "OT",
+                    DelayStatus::Early => "E",
+                    DelayStatus::Late => "LATE",
+                    DelayStatus::Unknown => "?",
+                };
+                lines.push(Line::from(vec![
+                    Span::styled(caret, Style::default().fg(color)),
+                    Span::styled(
+                        format!(" #{}", train.number),
+                        Style::default().fg(color).add_modifier(Modifier::BOLD),
+                    ),
+                    Span::styled(format!(" {}", delay_label), Style::default().fg(color)),
+                ]));
+            }
+        }
+
+        let paragraph = Paragraph::new(lines).block(
+            Block::default()
+                .title(format!(" Station: {} ", station.code))
+                .borders(Borders::ALL)
+                .border_style(Style::default().fg(Color::Cyan)),
+        );
+        frame.render_widget(paragraph, area);
+    } else {
+        let paragraph = Paragraph::new("No station selected").block(
+            Block::default()
+                .title(" Stations ")
+                .borders(Borders::ALL)
+                .border_style(Style::default().fg(Color::DarkGray)),
+        );
+        frame.render_widget(paragraph, area);
+    }
+}
+
 fn draw_help(frame: &mut Frame, area: Rect) {
     let help_text = vec![
         Line::from("←↑↓→ pan | +/- zoom | ↹/⇧↹ select"),
-        Line::from("Enter: jump | /: search | 0: reset | q: quit"),
+        Line::from("Enter: jump | /: search | s: stations"),
+        Line::from("0: reset | q: quit"),
     ];
     let paragraph = Paragraph::new(help_text).block(
         Block::default()