feat(ie-shell): add help overlay, status bar, and raise tokenizer step limit

Tokenizer (ie-html):
- Raise step limit from 200 to 10,000 — the reconsume-on-EOF fix
  from #56 resolved the actual infinite loops, 200 was triggering
  on legitimate complex pages

Help overlay (Ctrl+H / F1):
- Centered panel listing all keyboard shortcuts
- Shows key combo + description for all 14 actions

Status bar overlay (F12):
- Bottom bar showing: current URL, tab state, load time in ms
- Log entries: navigation events and errors (most recent first)
- last_load_time_ms tracked per navigation via UserEvent

Keybinding additions:
- Ctrl+H / F1 → ShowHelp
- F12 → ShowStatusBar
- OverlayState::Help and OverlayState::StatusBar variants

Status tracking:
- status_log: Vec<String> on Browser — captures navigation events
- last_load_time_ms: timed in async navigation task
- UserEvent::NavigationComplete now carries elapsed_ms

Author: thomasnemer

crates/ie-html/src/tokenizer.rs

@@ -1949,7 +1949,7 @@ impl<'a> Iterator for Tokenizer<'a> {
             }
             self.step();
             steps += 1;
-            if steps > 200 {
+            if steps > 10_000 {
                 tracing::error!("tokenizer infinite loop detected, emitting EOF");
                 self.finished = true;
                 return Some(Token::Eof);

crates/ie-render/src/chrome.rs

@@ -5,6 +5,8 @@ pub struct ChromeOverlay {
     pub address_bar: Option<AddressBarOverlay>,
     pub tab_list: Option<TabListOverlay>,
     pub bookmarks: Option<BookmarkListOverlay>,
+    pub help: bool,
+    pub status_bar: Option<StatusBarOverlay>,
 }
 
 pub struct AddressBarOverlay {
@@ -32,25 +34,39 @@ pub struct BookmarkEntry {
     pub url: String,
 }
 
+pub struct StatusBarOverlay {
+    pub url: String,
+    pub status: String,
+    pub load_time_ms: Option<u64>,
+    pub log_entries: Vec<String>,
+}
+
 impl ChromeOverlay {
     pub fn none() -> Self {
         Self {
             address_bar: None,
             tab_list: None,
             bookmarks: None,
+            help: false,
+            status_bar: None,
         }
     }
 
+    #[allow(dead_code)]
     pub fn is_active(&self) -> bool {
-        self.address_bar.is_some() || self.tab_list.is_some() || self.bookmarks.is_some()
+        self.address_bar.is_some()
+            || self.tab_list.is_some()
+            || self.bookmarks.is_some()
+            || self.help
+            || self.status_bar.is_some()
     }
 }
 
 /// Build paint commands for chrome overlays (rendered on top of page content).
 pub fn build_chrome_display_list(
     chrome: &ChromeOverlay,
     viewport_width: f32,
-    _viewport_height: f32,
+    viewport_height: f32,
 ) -> Vec<PaintCommand> {
     let mut commands = Vec::new();
 
@@ -66,6 +82,14 @@ pub fn build_chrome_display_list(
         render_bookmark_list(&mut commands, bookmarks, viewport_width);
     }
 
+    if chrome.help {
+        render_help(&mut commands, viewport_width, viewport_height);
+    }
+
+    if let Some(status) = &chrome.status_bar {
+        render_status_bar(&mut commands, status, viewport_width, viewport_height);
+    }
+
     commands
 }
 
@@ -260,3 +284,123 @@ fn render_bookmark_list(
         });
     }
 }
+
+const HELP_SHORTCUTS: &[(&str, &str)] = &[
+    ("Ctrl+L", "Address bar"),
+    ("Ctrl+T", "New tab"),
+    ("Ctrl+W", "Close tab"),
+    ("Ctrl+Tab", "Next tab"),
+    ("Ctrl+Shift+Tab", "Previous tab"),
+    ("Ctrl+Shift+T", "Tab list"),
+    ("Ctrl+D", "Bookmark page"),
+    ("Ctrl+Shift+B", "Bookmarks"),
+    ("Alt+Left", "Go back"),
+    ("Alt+Right", "Go forward"),
+    ("Ctrl+H / F1", "This help"),
+    ("F12", "Status bar"),
+    ("Ctrl+Q", "Quit"),
+    ("Escape", "Dismiss overlay"),
+];
+
+fn render_help(commands: &mut Vec<PaintCommand>, viewport_width: f32, viewport_height: f32) {
+    let panel_width = 360.0f32.min(viewport_width * 0.5);
+    let line_height = 28.0;
+    let panel_height = (HELP_SHORTCUTS.len() as f32 * line_height + 50.0).min(viewport_height);
+    let panel_x = (viewport_width - panel_width) / 2.0;
+    let panel_y = (viewport_height - panel_height) / 2.0;
+
+    // Background
+    commands.push(PaintCommand::FillRect {
+        x: panel_x,
+        y: panel_y,
+        width: panel_width,
+        height: panel_height,
+        color: PANEL_BG,
+    });
+
+    // Title
+    commands.push(PaintCommand::Text {
+        text: "Keyboard Shortcuts".to_string(),
+        x: panel_x + 16.0,
+        y: panel_y + 12.0,
+        font_size: 16.0,
+        color: BAR_TEXT,
+    });
+
+    // Shortcuts
+    for (i, (key, desc)) in HELP_SHORTCUTS.iter().enumerate() {
+        let y = panel_y + 44.0 + i as f32 * line_height;
+
+        // Key
+        commands.push(PaintCommand::Text {
+            text: key.to_string(),
+            x: panel_x + 16.0,
+            y,
+            font_size: 13.0,
+            color: BAR_CURSOR,
+        });
+
+        // Description
+        commands.push(PaintCommand::Text {
+            text: desc.to_string(),
+            x: panel_x + 180.0,
+            y,
+            font_size: 13.0,
+            color: ITEM_TEXT,
+        });
+    }
+}
+
+fn render_status_bar(
+    commands: &mut Vec<PaintCommand>,
+    status: &StatusBarOverlay,
+    viewport_width: f32,
+    viewport_height: f32,
+) {
+    let bar_height = 24.0 + status.log_entries.len().min(8) as f32 * 16.0;
+    let bar_y = viewport_height - bar_height;
+
+    // Background
+    commands.push(PaintCommand::FillRect {
+        x: 0.0,
+        y: bar_y,
+        width: viewport_width,
+        height: bar_height,
+        color: BAR_BG,
+    });
+
+    // Status line: URL | status | load time
+    let mut status_text = String::new();
+    if !status.url.is_empty() {
+        status_text.push_str(&status.url);
+        status_text.push_str("  |  ");
+    }
+    status_text.push_str(&status.status);
+    if let Some(ms) = status.load_time_ms {
+        status_text.push_str(&format!("  |  {}ms", ms));
+    }
+
+    commands.push(PaintCommand::Text {
+        text: status_text,
+        x: 8.0,
+        y: bar_y + 4.0,
+        font_size: 12.0,
+        color: ITEM_TEXT,
+    });
+
+    // Log entries
+    for (i, entry) in status.log_entries.iter().rev().take(8).enumerate() {
+        let truncated = if entry.len() > 100 {
+            format!("{}...", &entry[..100])
+        } else {
+            entry.clone()
+        };
+        commands.push(PaintCommand::Text {
+            text: truncated,
+            x: 8.0,
+            y: bar_y + 22.0 + i as f32 * 16.0,
+            font_size: 11.0,
+            color: URL_TEXT,
+        });
+    }
+}

crates/ie-render/src/lib.rs

@@ -10,8 +10,8 @@ pub mod software;
 pub mod text;
 
 pub use chrome::{
-    AddressBarOverlay, BookmarkEntry, BookmarkListOverlay, ChromeOverlay, TabEntry, TabListOverlay,
-    build_chrome_display_list,
+    AddressBarOverlay, BookmarkEntry, BookmarkListOverlay, ChromeOverlay, StatusBarOverlay,
+    TabEntry, TabListOverlay, build_chrome_display_list,
 };
 pub use gpu::GpuRenderer;
 pub use paint::{Color, PaintCommand, build_display_list};

crates/ie-shell/src/app.rs

@@ -15,7 +15,7 @@ use crate::overlay::{AddressBarState, OverlayState};
 use crate::tab::{TabId, TabManager, TabState};
 
 pub enum UserEvent {
-    NavigationComplete(TabId, Result<NavigationResult, NavigationError>),
+    NavigationComplete(TabId, Result<NavigationResult, NavigationError>, u64),
 }
 
 pub struct Browser {
@@ -31,6 +31,8 @@ pub struct Browser {
     _network_child: Option<ie_sandbox::ChildHandle>,
     modifiers: ModifiersState,
     event_loop_proxy: EventLoopProxy<UserEvent>,
+    status_log: Vec<String>,
+    last_load_time_ms: Option<u64>,
 }
 
 impl Browser {
@@ -81,6 +83,8 @@ impl Browser {
             _network_child: network_child,
             modifiers: ModifiersState::empty(),
             event_loop_proxy: proxy,
+            status_log: Vec::new(),
+            last_load_time_ms: None,
         };
 
         if let Some(url) = url {
@@ -149,6 +153,14 @@ impl Browser {
                 self.overlay = OverlayState::Bookmarks;
                 tracing::info!("overlay: Bookmarks");
             }
+            Action::ShowHelp => {
+                self.overlay = OverlayState::Help;
+                tracing::info!("overlay: Help");
+            }
+            Action::ShowStatusBar => {
+                self.overlay = OverlayState::StatusBar;
+                tracing::info!("overlay: StatusBar");
+            }
             Action::GoBack => {
                 if self.tab_manager.go_back()
                     && let Some(tab) = self.tab_manager.active_tab()
@@ -239,11 +251,16 @@ impl Browser {
 
         tracing::info!("navigate: tab={}, url={}", tab_id.0, url);
 
+        self.status_log
+            .push(format!("navigating: tab={}, url={}", tab_id.0, url));
+
         let proxy = self.event_loop_proxy.clone();
         let navigator = Arc::clone(&self.navigator);
         self.tokio_runtime.spawn(async move {
+            let start = std::time::Instant::now();
             let result = navigator.navigate(&url).await;
-            let _ = proxy.send_event(UserEvent::NavigationComplete(tab_id, result));
+            let elapsed = start.elapsed().as_millis() as u64;
+            let _ = proxy.send_event(UserEvent::NavigationComplete(tab_id, result, elapsed));
         });
     }
 
@@ -254,11 +271,12 @@ impl Browser {
     ) {
         match result {
             Ok(nav_result) => {
-                tracing::info!(
+                let msg = format!(
                     "navigation complete: tab={}, status={}",
-                    tab_id.0,
-                    nav_result.status
+                    tab_id.0, nav_result.status
                 );
+                tracing::info!("{msg}");
+                self.status_log.push(msg);
                 let source = String::from_utf8(nav_result.body).ok();
                 // Find the tab (it might have been closed while loading)
                 if let Some(tab) = self
@@ -278,7 +296,9 @@ impl Browser {
                 }
             }
             Err(e) => {
-                tracing::error!("navigation error: tab={}, error={}", tab_id.0, e);
+                let msg = format!("navigation error: tab={}, error={}", tab_id.0, e);
+                tracing::error!("{msg}");
+                self.status_log.push(msg);
                 if let Some(tab) = self
                     .tab_manager
                     .tabs_mut()
@@ -325,6 +345,8 @@ impl Browser {
                 }),
                 tab_list: None,
                 bookmarks: None,
+                help: false,
+                status_bar: None,
             },
             OverlayState::TabList => {
                 let tabs = self
@@ -350,6 +372,8 @@ impl Browser {
                     address_bar: None,
                     tab_list: Some(ie_render::TabListOverlay { tabs, active_index }),
                     bookmarks: None,
+                    help: false,
+                    status_bar: None,
                 }
             }
             OverlayState::Bookmarks => {
@@ -366,6 +390,40 @@ impl Browser {
                     address_bar: None,
                     tab_list: None,
                     bookmarks: Some(ie_render::BookmarkListOverlay { bookmarks }),
+                    help: false,
+                    status_bar: None,
+                }
+            }
+            OverlayState::Help => ie_render::ChromeOverlay {
+                address_bar: None,
+                tab_list: None,
+                bookmarks: None,
+                help: true,
+                status_bar: None,
+            },
+            OverlayState::StatusBar => {
+                let url = self
+                    .tab_manager
+                    .active_tab()
+                    .and_then(|t| t.url.as_ref())
+                    .map(|u| u.as_str().to_string())
+                    .unwrap_or_default();
+                let status = self
+                    .tab_manager
+                    .active_tab()
+                    .map(|t| format!("{:?}", t.state))
+                    .unwrap_or_else(|| "No tab".to_string());
+                ie_render::ChromeOverlay {
+                    address_bar: None,
+                    tab_list: None,
+                    bookmarks: None,
+                    help: false,
+                    status_bar: Some(ie_render::StatusBarOverlay {
+                        url,
+                        status,
+                        load_time_ms: self.last_load_time_ms,
+                        log_entries: self.status_log.clone(),
+                    }),
                 }
             }
         }
@@ -468,7 +526,8 @@ impl ApplicationHandler<UserEvent> for Browser {
 
     fn user_event(&mut self, _event_loop: &ActiveEventLoop, event: UserEvent) {
         match event {
-            UserEvent::NavigationComplete(tab_id, result) => {
+            UserEvent::NavigationComplete(tab_id, result, elapsed_ms) => {
+                self.last_load_time_ms = Some(elapsed_ms);
                 self.handle_navigation_complete(tab_id, result);
             }
         }

crates/ie-shell/src/keybindings.rs

@@ -11,6 +11,8 @@ pub enum Action {
     ShowTabList,
     BookmarkCurrentPage,
     ShowBookmarks,
+    ShowHelp,
+    ShowStatusBar,
     GoBack,
     GoForward,
     DismissOverlay,
@@ -31,11 +33,14 @@ fn resolve_key(key: &Key, modifiers: &ModifiersState) -> Option<Action> {
 
     match key {
         Key::Named(NamedKey::Escape) => Some(Action::DismissOverlay),
+        Key::Named(NamedKey::F1) => Some(Action::ShowHelp),
+        Key::Named(NamedKey::F12) => Some(Action::ShowStatusBar),
         Key::Named(NamedKey::Tab) if ctrl && shift => Some(Action::PrevTab),
         Key::Named(NamedKey::Tab) if ctrl => Some(Action::NextTab),
         Key::Named(NamedKey::ArrowLeft) if alt => Some(Action::GoBack),
         Key::Named(NamedKey::ArrowRight) if alt => Some(Action::GoForward),
         Key::Character(c) if ctrl => match c.as_str() {
+            "h" | "H" => Some(Action::ShowHelp),
             "l" | "L" => Some(Action::ShowAddressBar),
             "T" => Some(Action::ShowTabList),
             "t" if shift => Some(Action::ShowTabList),

crates/ie-shell/src/overlay.rs

@@ -4,6 +4,8 @@ pub enum OverlayState {
     AddressBar(AddressBarState),
     TabList,
     Bookmarks,
+    Help,
+    StatusBar,
 }
 
 impl OverlayState {