refactor(input): make pane key forwarding protocol-complete

docs/next/CHANGELOG.md

@@ -15,7 +15,7 @@
 - Experimental pane graphics now support bounded named layers, acknowledged full-RGBA primary-layer direct file frames on audited local terminals, owned BGRA fallback, exact pixel mouse input, and placement-only resize replay.
 
 ### Fixed
-- Fish `Ctrl+Alt` keybindings now work in panes after legacy Alt-prefixed control bytes are decoded with both modifiers. (#2514)
+- Pane key forwarding now uses one state-aware encoder, fixing Fish `Ctrl+Alt` bindings and preserving Kitty alternate and associated text, extended modifiers, repeats and releases, F13–F25, and `modifyOtherKeys` state through handoff. (#2514)
 - `herdr config check` now reports unknown built-in theme names instead of silently accepting them. (#2452)
 - macOS `herdr --remote` clients now keep the accepted bridge socket blocking, preventing an immediate disconnect after the protocol handshake. (#2478, thanks @mathijshenquet)
 - Prefix keybindings now preserve Shift in WezTerm Kitty keyboard mode, so commands such as config reload no longer trigger their unshifted action. (#2435)

src/app/api/panes.rs

@@ -2746,7 +2746,7 @@ mod tests {
 
         assert_eq!(
             rx.try_recv().expect("forwarded press"),
-            bytes::Bytes::from_static(b"\x1b[106;1:1u")
+            bytes::Bytes::from_static(b"\x1b[106u")
         );
         assert_eq!(
             rx.try_recv().expect("forwarded release after pane move"),

src/app/input/mouse.rs

@@ -3577,6 +3577,7 @@ mod tests {
             mouse_protocol_encoding: crate::input::MouseProtocolEncoding::Sgr,
             mouse_alternate_scroll: true,
             modify_other_keys: false,
+            modify_other_keys_mode: None,
             color_scheme_reporting: false,
         };
 
@@ -4254,6 +4255,7 @@ mod tests {
             mouse_protocol_encoding: crate::input::MouseProtocolEncoding::Default,
             mouse_alternate_scroll: true,
             modify_other_keys: false,
+            modify_other_keys_mode: None,
             color_scheme_reporting: false,
         };
 
@@ -4271,6 +4273,7 @@ mod tests {
             mouse_protocol_encoding: crate::input::MouseProtocolEncoding::Default,
             mouse_alternate_scroll: true,
             modify_other_keys: false,
+            modify_other_keys_mode: None,
             color_scheme_reporting: false,
         };
 

src/app/mod.rs

@@ -3622,7 +3622,7 @@ mod tests {
 
         assert_eq!(
             rx.recv().await.unwrap(),
-            bytes::Bytes::from_static(b"\x1b[106;1:1u")
+            bytes::Bytes::from_static(b"\x1b[106u")
         );
         assert_eq!(
             rx.recv().await.unwrap(),
@@ -5305,7 +5305,10 @@ last_pane = "prefix+tab"
 
         app.route_client_input(b"\x1b[106;1:1u\x1b[106;1:2u\x1b[106;1:3u".to_vec());
         assert_eq!(rx.recv().await.unwrap(), bytes::Bytes::from_static(b"j"));
-        assert_eq!(rx.recv().await.unwrap(), bytes::Bytes::from_static(b"j"));
+        assert_eq!(
+            rx.recv().await.unwrap(),
+            bytes::Bytes::from_static(b"\x1b[106;1:2u")
+        );
         assert_eq!(
             rx.recv().await.unwrap(),
             bytes::Bytes::from_static(b"\x1b[106;1:3u")
@@ -5392,7 +5395,7 @@ last_pane = "prefix+tab"
 
         assert_eq!(
             rx.recv().await.unwrap(),
-            bytes::Bytes::from_static(b"\x1b[106;1:1u")
+            bytes::Bytes::from_static(b"\x1b[106u")
         );
         assert_eq!(
             rx.recv().await.unwrap(),
@@ -5490,7 +5493,7 @@ last_pane = "prefix+tab"
 
         assert_eq!(
             rx.try_recv().expect("physical press"),
-            bytes::Bytes::from_static(b"\x1b[106;1:1u")
+            bytes::Bytes::from_static(b"\x1b[106u")
         );
         assert_eq!(
             rx.try_recv().expect("committed text"),
@@ -5530,7 +5533,7 @@ last_pane = "prefix+tab"
 
         assert_eq!(
             rx.try_recv().expect("forwarded press"),
-            bytes::Bytes::from_static(b"\x1b[106;1:1u")
+            bytes::Bytes::from_static(b"\x1b[106u")
         );
         assert_eq!(
             rx.try_recv().expect("synthetic release on focus loss"),
@@ -5565,7 +5568,7 @@ last_pane = "prefix+tab"
 
         assert_eq!(
             rx.try_recv().expect("forwarded press"),
-            bytes::Bytes::from_static(b"\x1b[106;1:1u")
+            bytes::Bytes::from_static(b"\x1b[106u")
         );
         assert_eq!(
             rx.try_recv().expect("synthetic release on disconnect"),
@@ -5647,7 +5650,7 @@ last_pane = "prefix+tab"
         );
 
         for expected in [
-            b"\x1b[97;1:1u".as_slice(),
+            b"\x1b[97u".as_slice(),
             b"\x1b[97;1:2u".as_slice(),
             b"\x1b[97;1:2u".as_slice(),
             b"\x1b[97;1:3u".as_slice(),
@@ -5710,7 +5713,7 @@ last_pane = "prefix+tab"
 
         assert_eq!(
             rx.try_recv().expect("grouped press"),
-            bytes::Bytes::from_static(b"\x1b[97;1:1u\x1b[97;1:2u\x1b[97;1:2u")
+            bytes::Bytes::from_static(b"\x1b[97u\x1b[97;1:2u\x1b[97;1:2u")
         );
         assert_eq!(
             rx.try_recv()
@@ -5748,7 +5751,7 @@ last_pane = "prefix+tab"
 
         assert_eq!(
             pressed_rx.recv().await.unwrap(),
-            bytes::Bytes::from_static(b"\x1b[106;1:1u")
+            bytes::Bytes::from_static(b"\x1b[106u")
         );
         assert_eq!(
             pressed_rx.recv().await.unwrap(),
@@ -5823,7 +5826,7 @@ last_pane = "prefix+tab"
         for rx in [&mut first_rx, &mut second_rx] {
             assert_eq!(
                 rx.recv().await.unwrap(),
-                bytes::Bytes::from_static(b"\x1b[106;1:1u")
+                bytes::Bytes::from_static(b"\x1b[106u")
             );
             assert_eq!(
                 rx.recv().await.unwrap(),
@@ -5850,7 +5853,7 @@ last_pane = "prefix+tab"
 
         assert_eq!(
             rx.recv().await.unwrap(),
-            bytes::Bytes::from_static(b"\x1b[106:74;2:1u")
+            bytes::Bytes::from_static(b"\x1b[106:74;2u")
         );
         assert_eq!(
             rx.recv().await.unwrap(),

src/client/input.rs

@@ -365,7 +365,7 @@ fn windows_crossterm_reader_loop(
             Err(_) => break,
         };
 
-        let raw_sequence_pending = framer.has_pending_input();
+        let raw_sequence_pending = framer.requires_raw_continuation();
         if let Some(bytes) = windows_key_raw_bytes(&event, raw_sequence_pending) {
             tracing::debug!(
                 bytes = ?bytes,
@@ -521,6 +521,9 @@ fn windows_client_input_event_from_raw(
             let source = if let Some(bytes) = key.vt_bytes() {
                 crate::protocol::ClientKeySource::Vt {
                     bytes: bytes.to_vec(),
+                    shifted_codepoint: key.shifted_codepoint,
+                    base_layout_codepoint: key.base_layout_codepoint,
+                    text_commit: key.is_text_commit(),
                 }
             } else if let Some(record) = key.windows_record() {
                 crate::protocol::ClientKeySource::WindowsConsole { record }
@@ -748,6 +751,25 @@ mod windows_tests {
     use super::*;
     use crossterm::event::{Event, KeyCode, KeyEvent, KeyModifiers};
 
+    #[test]
+    fn windows_oversized_csi_final_is_routed_through_discard_state() {
+        let mut framer = crate::raw_input::RawInputFramer::default();
+        let mut oversized = b"\x1b[".to_vec();
+        oversized.extend(std::iter::repeat_n(b'1', 4096));
+
+        assert!(framer.push(&oversized).is_empty());
+        assert!(framer.requires_raw_continuation());
+
+        let final_key = Event::Key(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::empty()));
+        let final_bytes = windows_key_raw_bytes(&final_key, framer.requires_raw_continuation())
+            .expect("discard continuation routes through raw framer");
+        assert!(framer.push(&final_bytes).is_empty());
+        assert!(!framer.requires_raw_continuation());
+
+        let following_key = Event::Key(KeyEvent::new(KeyCode::Char('x'), KeyModifiers::empty()));
+        assert_eq!(windows_key_raw_bytes(&following_key, false), None);
+    }
+
     #[test]
     fn windows_control_chars_are_reframed_as_raw_bytes() {
         let escape = Event::Key(KeyEvent::new(KeyCode::Esc, KeyModifiers::empty()));
@@ -776,18 +798,23 @@ mod windows_tests {
     #[test]
     fn windows_crossterm_printable_press_keeps_key_semantics_and_text() {
         let event = Event::Key(KeyEvent::new(KeyCode::Char('你'), KeyModifiers::empty()));
+        let event = windows_crossterm_input_event(event).expect("printable key converts");
 
         assert_eq!(
-            windows_crossterm_input_event(event),
-            Some(crate::protocol::ClientInputEvent::Key {
+            event,
+            crate::protocol::ClientInputEvent::Key {
                 code: crate::protocol::ClientKeyCode::Char('你'),
                 modifiers: 0,
                 kind: crate::protocol::ClientKeyKind::Press,
                 repeat_count: 1,
                 generated_text: Some("你".to_string()),
                 source: crate::protocol::ClientKeySource::Synthesized,
-            })
+            }
         );
+        let crate::raw_input::RawInputEvent::Key(key) = event.to_raw_input_event() else {
+            panic!("expected key event");
+        };
+        assert!(key.is_text_commit());
     }
 
     #[test]
@@ -825,9 +852,8 @@ mod windows_tests {
         assert_eq!(windows_key_raw_bytes(&ctrl_shift_bracket, false), None);
     }
 
-    #[cfg(windows)]
-    #[test]
-    fn windows_ctrl_d_semantic_event_encodes_to_eot() {
+    #[tokio::test]
+    async fn windows_ctrl_d_reaches_the_pane_as_eot() {
         let event = Event::Key(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::CONTROL));
         assert_eq!(windows_key_raw_bytes(&event, false), None);
 
@@ -839,10 +865,12 @@ mod windows_tests {
         };
         assert_eq!(key.code, KeyCode::Char('d'));
         assert_eq!(key.modifiers, KeyModifiers::CONTROL);
-        assert_eq!(
-            crate::input::encode_terminal_key(key, crate::input::KeyboardProtocol::Legacy),
-            b"\x04"
-        );
+
+        let (runtime, _rx) =
+            crate::terminal::TerminalRuntime::test_with_channel_and_scrollback_bytes(
+                80, 24, 0, b"", 1,
+            );
+        assert_eq!(runtime.encode_terminal_key(key), b"\x04");
     }
 
     #[test]
@@ -883,7 +911,12 @@ mod windows_tests {
                 kind: crate::protocol::ClientKeyKind::Press,
                 repeat_count: 1,
                 generated_text: None,
-                source: crate::protocol::ClientKeySource::Vt { bytes: vec![4] },
+                source: crate::protocol::ClientKeySource::Vt {
+                    bytes: vec![4],
+                    shifted_codepoint: None,
+                    base_layout_codepoint: None,
+                    text_commit: false,
+                },
             }
         );
     }
@@ -907,12 +940,41 @@ mod windows_tests {
                 repeat_count: 1,
                 generated_text: None,
                 source: crate::protocol::ClientKeySource::Vt {
-                    bytes: b"\x1b[A".to_vec()
+                    bytes: b"\x1b[A".to_vec(),
+                    shifted_codepoint: None,
+                    base_layout_codepoint: None,
+                    text_commit: false,
                 },
             }
         );
     }
 
+    #[test]
+    fn windows_raw_kitty_input_preserves_alternate_codepoints() {
+        let mut framer = crate::raw_input::RawInputFramer::default();
+        let mut events = framer.push(b"\x1b[97:65:113;;65:769u");
+        assert_eq!(events.len(), 1);
+
+        let event =
+            windows_client_input_event_from_raw(events.remove(0)).expect("raw key converts");
+        let crate::protocol::ClientInputEvent::Key {
+            generated_text,
+            source:
+                crate::protocol::ClientKeySource::Vt {
+                    shifted_codepoint,
+                    base_layout_codepoint,
+                    ..
+                },
+            ..
+        } = event
+        else {
+            panic!("expected VT key event");
+        };
+        assert_eq!(generated_text.as_deref(), Some("A\u{301}"));
+        assert_eq!(shifted_codepoint, Some('A' as u32));
+        assert_eq!(base_layout_codepoint, Some('q' as u32));
+    }
+
     #[test]
     fn windows_bare_escape_flushes_to_semantic_escape() {
         let mut framer = crate::raw_input::RawInputFramer::default();
@@ -930,7 +992,12 @@ mod windows_tests {
                 kind: crate::protocol::ClientKeyKind::Press,
                 repeat_count: 1,
                 generated_text: None,
-                source: crate::protocol::ClientKeySource::Vt { bytes: vec![0x1b] },
+                source: crate::protocol::ClientKeySource::Vt {
+                    bytes: vec![0x1b],
+                    shifted_codepoint: None,
+                    base_layout_codepoint: None,
+                    text_commit: false,
+                },
             }
         );
     }

src/client/input/windows_vti.rs

@@ -1467,7 +1467,12 @@ mod tests {
 
                 repeat_count: 1,
                 generated_text: None,
-                source: crate::protocol::ClientKeySource::Vt { bytes: vec![0x1b] },
+                source: crate::protocol::ClientKeySource::Vt {
+                    bytes: vec![0x1b],
+                    shifted_codepoint: None,
+                    base_layout_codepoint: None,
+                    text_commit: false,
+                },
             }]
         );
     }
@@ -1487,7 +1492,12 @@ mod tests {
 
                 repeat_count: 1,
                 generated_text: None,
-                source: crate::protocol::ClientKeySource::Vt { bytes: vec![0x1b] },
+                source: crate::protocol::ClientKeySource::Vt {
+                    bytes: vec![0x1b],
+                    shifted_codepoint: None,
+                    base_layout_codepoint: None,
+                    text_commit: false,
+                },
             }]
         );
     }
@@ -2201,7 +2211,12 @@ mod tests {
 
                 repeat_count: 1,
                 generated_text: None,
-                source: crate::protocol::ClientKeySource::Vt { bytes: vec![0x1b] },
+                source: crate::protocol::ClientKeySource::Vt {
+                    bytes: vec![0x1b],
+                    shifted_codepoint: None,
+                    base_layout_codepoint: None,
+                    text_commit: false,
+                },
             }]
         );
     }
@@ -2220,7 +2235,12 @@ mod tests {
 
                     repeat_count: 1,
                     generated_text: None,
-                    source: crate::protocol::ClientKeySource::Vt { bytes: vec![0x1b] },
+                    source: crate::protocol::ClientKeySource::Vt {
+                        bytes: vec![0x1b],
+                        shifted_codepoint: None,
+                        base_layout_codepoint: None,
+                        text_commit: false,
+                    },
                 },
                 crate::protocol::ClientInputEvent::Key {
                     code: crate::protocol::ClientKeyCode::Enter,

src/ghostty/bindings.rs

@@ -67,6 +67,8 @@ pub const GHOSTTY_MODS_ALT: u32 = 4;
 pub const GHOSTTY_MODS_SUPER: u32 = 8;
 pub const GHOSTTY_MODS_CAPS_LOCK: u32 = 16;
 pub const GHOSTTY_MODS_NUM_LOCK: u32 = 32;
+pub const GHOSTTY_MODS_HYPER: u32 = 1024;
+pub const GHOSTTY_MODS_META: u32 = 2048;
 pub const GHOSTTY_MODS_SHIFT_SIDE: u32 = 64;
 pub const GHOSTTY_MODS_CTRL_SIDE: u32 = 128;
 pub const GHOSTTY_MODS_ALT_SIDE: u32 = 256;
@@ -3891,6 +3893,18 @@ unsafe extern "C" {
     #[doc = " Set the unshifted Unicode codepoint.\n\n @param event The key event handle, must not be NULL\n @param codepoint The unshifted Unicode codepoint to set\n\n @ingroup key"]
     pub fn ghostty_key_event_set_unshifted_codepoint(event: GhosttyKeyEvent, codepoint: u32);
 }
+unsafe extern "C" {
+    pub fn ghostty_key_event_set_shifted_codepoint(event: GhosttyKeyEvent, codepoint: u32);
+}
+unsafe extern "C" {
+    pub fn ghostty_key_event_get_shifted_codepoint(event: GhosttyKeyEvent) -> u32;
+}
+unsafe extern "C" {
+    pub fn ghostty_key_event_set_base_layout_codepoint(event: GhosttyKeyEvent, codepoint: u32);
+}
+unsafe extern "C" {
+    pub fn ghostty_key_event_get_base_layout_codepoint(event: GhosttyKeyEvent) -> u32;
+}
 unsafe extern "C" {
     #[doc = " Get the unshifted Unicode codepoint.\n\n @param event The key event handle, must not be NULL\n @return The unshifted Unicode codepoint\n\n @ingroup key"]
     pub fn ghostty_key_event_get_unshifted_codepoint(event: GhosttyKeyEvent) -> u32;