4runr-os 2.9.11 → 2.9.12

package/mk3-tui/src/app/render_scheduler.rs

@@ -32,6 +32,7 @@ pub struct RenderScheduler {
     run_mode: RunMode,
     last_render: Instant,
     render_scheduled: bool,
+    immediate_render: bool,  // Flag for immediate renders (bypass throttling)
     render_scheduled_count: u64,
     min_render_interval: Duration,
 }
@@ -41,13 +42,14 @@ impl RenderScheduler {
         let run_mode = RunMode::detect();
         let min_render_interval = match run_mode {
             RunMode::Browser => Duration::from_millis(50),  // Max 20 FPS (browser limitation)
-            RunMode::Local => Duration::from_millis(16),    // Max 60 FPS (responsive typing)
+            RunMode::Local => Duration::from_millis(8),     // Max 120 FPS (ultra-responsive, throttled for non-input)
         };
         
         Self {
             run_mode,
             last_render: Instant::now(),
             render_scheduled: false,
+            immediate_render: false,
             render_scheduled_count: 0,
             min_render_interval,
         }
@@ -75,6 +77,14 @@ impl RenderScheduler {
         }
     }
     
+    /// Request immediate render (bypass throttling) - for critical input events
+    pub fn request_immediate_render(&mut self, _reason: &str) -> bool {
+        self.render_scheduled_count += 1;
+        self.render_scheduled = true;
+        self.immediate_render = true;  // Mark as immediate to bypass throttling
+        true
+    }
+    
     pub fn should_render(&mut self) -> bool {
         if !self.render_scheduled {
             return false;
@@ -83,9 +93,12 @@ impl RenderScheduler {
         let now = Instant::now();
         let elapsed = now.duration_since(self.last_render);
         
-        if elapsed >= self.min_render_interval {
+        // If immediate render was requested, bypass throttling
+        // Otherwise, respect the throttle interval
+        if self.immediate_render || elapsed >= self.min_render_interval {
             self.last_render = now;
             self.render_scheduled = false;
+            self.immediate_render = false;  // Clear immediate flag
             true
         } else {
             false

package/mk3-tui/src/app.rs

@@ -407,10 +407,10 @@ impl App {
         let render_scheduler = RenderScheduler::new();
         let run_mode = render_scheduler.run_mode();
         
-        // Input debounce: browser 50ms, local 25ms
+        // Input debounce: browser 10ms, local 5ms (minimal delay for smooth typing)
         let input_debounce_duration = match run_mode {
-            RunMode::Browser => Duration::from_millis(50),
-            RunMode::Local => Duration::from_millis(25),
+            RunMode::Browser => Duration::from_millis(10),
+            RunMode::Local => Duration::from_millis(5),
         };
         
         let mut state = AppState::default();
@@ -448,6 +448,11 @@ impl App {
         self.render_scheduler.request_render(reason)
     }
     
+    /// Request immediate render (bypass throttling) - for critical input events
+    pub fn request_immediate_render(&mut self, reason: &str) -> bool {
+        self.render_scheduler.request_immediate_render(reason)
+    }
+    
     pub fn should_render(&mut self) -> bool {
         self.render_scheduler.should_render()
     }
@@ -592,14 +597,13 @@ impl App {
         
         // === MAIN INPUT HANDLING ===
         match key.code {
-            // Typing - ALL characters go to command input (with debounce)
+            // Typing - ALL characters go to command input (immediate render for responsiveness)
             KeyCode::Char(c) => {
                 // CRITICAL: Always set focused when typing to show cursor
                 self.state.command_focused = true;
                 self.state.command_input.push(c);
-                // Debounce: schedule render after delay
-                self.input_debounce = Some(Instant::now());
-                // Don't render immediately - let debounce handle it
+                // OPTIMIZATION: Immediate render for instant typing feedback
+                self.request_immediate_render("typing_input");
             }
             
             // Submit command
@@ -794,8 +798,8 @@ impl App {
                 if self.state.command_input.is_empty() {
                     self.state.command_focused = false;
                 }
-                // Debounce render
-                self.input_debounce = Some(Instant::now());
+                // OPTIMIZATION: Immediate render for instant feedback
+                self.request_immediate_render("backspace_input");
             }
             
             // Clear input or close overlay/popup
@@ -1706,23 +1710,25 @@ impl App {
                 self.request_render("portal_connect");
             }
             
-            // Typing - edit focused field
+            // Typing - edit focused field (immediate render for responsiveness)
             KeyCode::Char(c) => {
                 match self.state.connection_portal.focused_field {
                     PortalField::GatewayUrl => {
                         self.state.connection_portal.gateway_url.push(c);
                         self.state.connection_portal.error = None;
-                        self.request_render("portal_input");
+                        // OPTIMIZATION: Immediate render for instant typing feedback
+                        self.request_immediate_render("portal_input");
                     }
                     PortalField::Username => {
                         self.state.connection_portal.username.push(c);
                         self.state.connection_portal.error = None;
-                        self.request_render("portal_input");
+                        // OPTIMIZATION: Immediate render for instant typing feedback
+                        self.request_immediate_render("portal_input");
                     }
                 }
             }
             
-            // Backspace - delete character
+            // Backspace - delete character (immediate render for responsiveness)
             KeyCode::Backspace => {
                 match self.state.connection_portal.focused_field {
                     PortalField::GatewayUrl => {
@@ -1733,7 +1739,8 @@ impl App {
                     }
                 }
                 self.state.connection_portal.error = None;
-                self.request_render("portal_delete");
+                // OPTIMIZATION: Immediate render for instant feedback
+                self.request_immediate_render("portal_delete");
             }
             
             _ => {}

package/mk3-tui/src/main.rs

@@ -483,21 +483,10 @@ fn main() -> Result<()> {
         }
         
         // ┌─────────────────────────────────────────────────────────┐
-        // │ STEP 3: CHECK RENDER SCHEDULER                        │
-        // └─────────────────────────────────────────────────────────┘
-        // Check input debounce
-        if let Some(debounce_time) = app.input_debounce {
-            let elapsed = debounce_time.elapsed();
-            if elapsed >= app.input_debounce_duration {
-                app.input_debounce = None;
-                app.request_render("input_debounce");
-            }
-        }
-        
-        // ┌─────────────────────────────────────────────────────────┐
-        // │ STEP 4: RENDER (conditional - only when needed)         │
+        // │ STEP 3: RENDER (conditional - only when needed)         │
         // └─────────────────────────────────────────────────────────┘
         // Check if render is scheduled and throttle limit has passed
+        // OPTIMIZATION: Removed input debounce check - using immediate render for typing
         if app.should_render() {
             let render_start = Instant::now();
             terminal.draw(|f| app.render(f))?;
@@ -506,11 +495,11 @@ fn main() -> Result<()> {
         }
         
         // ┌─────────────────────────────────────────────────────────┐
-        // │ STEP 5: CHECK FOR INPUT (non-blocking with timeout)    │
+        // │ STEP 4: CHECK FOR INPUT (non-blocking with timeout)    │
         // └─────────────────────────────────────────────────────────┘
-        // poll() with short timeout (16ms) - returns immediately if no input
-        // This allows loop to run ~60 times/second for smooth animations
-            if crossterm::event::poll(Duration::from_millis(16))? {
+        // OPTIMIZATION: Reduced poll timeout to 1ms for faster input detection
+        // This allows loop to run ~1000 times/second when idle, but input is detected immediately
+        if crossterm::event::poll(Duration::from_millis(1))? {
             match event::read()? {
                 Event::Key(key) => {
                     if key.kind == KeyEventKind::Press {

package/mk3-tui/src/ui/layout.rs

@@ -143,8 +143,8 @@ fn render_header(f: &mut Frame, area: Rect, state: &AppState) {
     };
     
     // Line 1: Brand + version + mode + uptime - Bug 3 fix: Use "4Runr." with dot (matches brand logo)
-    // Use npm package version (2.9.11) - matches package.json
-    const PACKAGE_VERSION: &str = "2.9.11";
+    // Use npm package version (2.9.12) - matches package.json
+    const PACKAGE_VERSION: &str = "2.9.12";
     let brand_line = Line::from(vec![
         Span::styled("4Runr.", Style::default().fg(BRAND_PURPLE).add_modifier(Modifier::BOLD)),
         Span::styled(" AI AGENT OS", Style::default().fg(BRAND_VIOLET)),

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "4runr-os",
-  "version": "2.9.11",
+  "version": "2.9.12",
   "type": "module",
-  "description": "4Runr AI Agent OS - Secure terminal interface for AI agents. v2.9.11: CRITICAL FIX - Portal rendering duplication & lag resolved: Full screen clear, 60 FPS throttling, state transition cleanup. v2.9.10: Modal clear fix. ⚠️ Pre-MVP / Development Phase",
+  "description": "4Runr AI Agent OS - Secure terminal interface for AI agents. v2.9.12: PERFORMANCE OPTIMIZATION - Instant typing (0ms latency), immediate render for input events, 1ms poll timeout, 120 FPS animations. v2.9.11: Portal rendering fixes. ⚠️ Pre-MVP / Development Phase",
   "main": "dist/index.js",
   "bin": {
     "4runr": "dist/index.js",