keybinding fixes

1 files changed, 100 insertions, 11 deletions

diff --git a/src/tui_input.zig b/src/tui_input.zig
index 276b7e1..b05131c 100644
--- a/src/tui_input.zig
+++ b/src/tui_input.zig
@@ -19,7 +19,8 @@
 //! Shift+Enter: in the bare legacy protocol Enter and Shift+Enter send the same
 //! byte (`\r`), so they're indistinguishable. To recover the distinction we
 //! negotiate at startup (see `negotiate_query`): we push the Kitty keyboard
-//! protocol (flags 1|2|4) and query the terminal; if it confirms Kitty we use
+//! protocol (flags 1|4 — disambiguate + report-alternates; NOT report-events,
+//! see `enable_kitty_keyboard`) and query the terminal; if it confirms Kitty we use
 //! that, otherwise we fall back to xterm modifyOtherKeys mode 2. Either way:
 //!   - Kitty-protocol terminals (ghostty/kitty/foot/…) send `\x1b[13;2u`.
 //!   - xterm and tmux (which does NOT honor the Kitty push but DOES forward
@@ -76,16 +77,25 @@ pub const paste_end = "\x1b[201~";
 
 /// Kitty keyboard protocol: push a flags entry that asks for:
 ///   flag 1 (0b001) disambiguate escape codes,
-///   flag 2 (0b010) report event types (press/repeat/release),
 ///   flag 4 (0b100) report alternate keys (shifted/base-layout key).
-/// 1|2|4 = 7. This matches what pi requests. Flag 1 makes the terminal report
-/// modified special keys — including Shift+Enter — as distinct CSI-u sequences
-/// (`\x1b[13;2u`), which is exactly what we need; we deliberately do NOT set
-/// flag 8 (report-all-keys), since that suppresses normal text input and forces
-/// every printable key through the escape-sequence path. We push (not set) so
-/// teardown can pop cleanly. Best-effort; unsupported terminals ignore it and
-/// we fall back to modifyOtherKeys / legacy decoding.
-pub const enable_kitty_keyboard = "\x1b[>7u";
+/// 1|4 = 5. Flag 1 makes the terminal report modified special keys — including
+/// Shift+Enter — as distinct CSI-u sequences (`\x1b[13;2u`), which is exactly
+/// what we need.
+///
+/// We deliberately do NOT set flag 2 (report event types / press-repeat-
+/// release). Nothing in the TUI consumes key-release events (no component sets
+/// `Component.wantsKeyRelease`), and requesting them makes the terminal emit a
+/// release sequence for every key. Under flag 2 a single arrow press produces
+/// BOTH a press and a release event; since the editor treated each decoded
+/// arrow as a motion, the cursor moved twice per physical press (once on key-
+/// down, once on key-up). Dropping flag 2 removes the release events at the
+/// source. `applyKey` still drops any `.release` it sees as defense-in-depth.
+///
+/// We also do NOT set flag 8 (report-all-keys), since that suppresses normal
+/// text input and forces every printable key through the escape-sequence path.
+/// We push (not set) so teardown can pop cleanly. Best-effort; unsupported
+/// terminals ignore it and we fall back to modifyOtherKeys / legacy decoding.
+pub const enable_kitty_keyboard = "\x1b[>5u";
 /// Query the terminal's currently-active Kitty flags: it replies `\x1b[?<n>u`.
 pub const query_kitty_flags = "\x1b[?u";
 /// Primary Device Attributes query. Every terminal answers this (`\x1b[?...c`),
@@ -109,7 +119,8 @@ pub const disable_modify_other_keys = "\x1b[>4;0m";
 
 /// Startup negotiation to write once raw mode is engaged. We:
 ///   1. enable bracketed paste,
-///   2. push the Kitty flags we want (1|2|4),
+///   2. push the Kitty flags we want (1|4 = disambiguate + report-alternates;
+///      deliberately NOT flag 2 report-events, see `enable_kitty_keyboard`),
 ///   3. query the now-active Kitty flags, then
 ///   4. send a Primary Device Attributes query as a sentinel.
 /// The app then reads the responses (`Decoded.negotiation`): a non-zero Kitty
@@ -618,6 +629,67 @@ test "csi home/end and modified arrow" {
     try std.testing.expect(s.mods.ctrl);
 }
 
+test "modified arrows: alt and ctrl, legacy CSI 1;<mods> form" {
+    // Alt+Left = CSI 1;3D  (mods field 3 = 1 + alt)
+    const al = decodeOne("\x1b[1;3D").?.decoded.key;
+    try std.testing.expectEqual(KeyCode.left, al.code);
+    try std.testing.expect(al.mods.alt);
+    try std.testing.expect(!al.mods.ctrl);
+    // Alt+Right = CSI 1;3C
+    const ar = decodeOne("\x1b[1;3C").?.decoded.key;
+    try std.testing.expectEqual(KeyCode.right, ar.code);
+    try std.testing.expect(ar.mods.alt);
+    // Ctrl+Left = CSI 1;5D (tmux/modifyOtherKeys word-motion path)
+    const cl = decodeOne("\x1b[1;5D").?.decoded.key;
+    try std.testing.expectEqual(KeyCode.left, cl.code);
+    try std.testing.expect(cl.mods.ctrl);
+    try std.testing.expect(!cl.mods.alt);
+}
+
+test "modified arrows: kitty functional CSU-u form (alt/ctrl)" {
+    // Some terminals (Kitty/Ghostty under disambiguate) report arrows as the
+    // functional-key codepoints 57350..57353 with a `;<mods>` field.
+    // Alt+Left = CSI 57350 ; 3 u
+    const al = decodeOne("\x1b[57350;3u").?.decoded.key;
+    try std.testing.expectEqual(KeyCode.left, al.code);
+    try std.testing.expect(al.mods.alt);
+    // Ctrl+Right = CSI 57351 ; 5 u
+    const cr = decodeOne("\x1b[57351;5u").?.decoded.key;
+    try std.testing.expectEqual(KeyCode.right, cr.code);
+    try std.testing.expect(cr.mods.ctrl);
+    // Plain functional Left = CSI 57350 u (no mods).
+    const pl = decodeOne("\x1b[57350u").?.decoded.key;
+    try std.testing.expectEqual(KeyCode.left, pl.code);
+    try std.testing.expect(!pl.mods.any());
+    try std.testing.expectEqual(key.KeyEvent.press, pl.event);
+}
+
+test "modified arrows: ESC-prefixed alt forms" {
+    // A terminal can emit alt+arrow as ESC + the arrow sequence. The recursive
+    // alt-prefix path in decodeEscape must OR in alt.
+    // ESC ESC [ D  (alt + legacy left)
+    const a1 = decodeOne("\x1b\x1b[D").?.decoded.key;
+    try std.testing.expectEqual(KeyCode.left, a1.code);
+    try std.testing.expect(a1.mods.alt);
+    // ESC ESC O C  (alt + SS3 right)
+    const a2 = decodeOne("\x1b\x1bOC").?.decoded.key;
+    try std.testing.expectEqual(KeyCode.right, a2.code);
+    try std.testing.expect(a2.mods.alt);
+}
+
+test "arrow release events are tagged .release (so the editor can drop them)" {
+    // Even though we no longer REQUEST release events (flag 2 dropped), the
+    // decoder must still classify a release form correctly if one arrives, so
+    // applyKey's release guard is effective. Functional Left release:
+    //   CSI 57350 ; 1 : 3 u   (mods field 1 = none, event 3 = release)
+    const rel = decodeOne("\x1b[57350;1:3u").?.decoded.key;
+    try std.testing.expectEqual(KeyCode.left, rel.code);
+    try std.testing.expectEqual(key.KeyEvent.release, rel.event);
+    // A press (event 1) is a press.
+    const pre = decodeOne("\x1b[57350;1:1u").?.decoded.key;
+    try std.testing.expectEqual(key.KeyEvent.press, pre.event);
+}
+
 test "csi tilde delete / pageup / pagedown" {
     try std.testing.expectEqual(KeyCode.delete, decodeOne("\x1b[3~").?.decoded.key.code);
     try std.testing.expectEqual(KeyCode.page_up, decodeOne("\x1b[5~").?.decoded.key.code);
@@ -657,6 +729,22 @@ test "kitty release event" {
     try std.testing.expectEqual(key.KeyEvent.release, s.event);
 }
 
+test "negotiate_query pushes Kitty flags >5u (1|4, NOT report-events flag 2)" {
+    // Root-cause regression guard for the arrow double-move bug: we must NOT
+    // request flag 2 (report event types), or the terminal emits a key-RELEASE
+    // for every press and arrows move twice. The pushed flag set is
+    // disambiguate (1) | report-alternates (4) = 5, encoded as `\x1b[>5u`.
+    try std.testing.expectEqualStrings("\x1b[>5u", enable_kitty_keyboard);
+    // It must appear verbatim inside the startup negotiation string.
+    try std.testing.expect(std.mem.indexOf(u8, negotiate_query, "\x1b[>5u") != null);
+    // And the report-events form (>7u, i.e. 1|2|4) must NOT be pushed.
+    try std.testing.expect(std.mem.indexOf(u8, negotiate_query, "\x1b[>7u") == null);
+    // Sanity: the numeric flag set is exactly 1|4 with bit 2 (0b010) clear.
+    const flags: u8 = 1 | 4;
+    try std.testing.expectEqual(@as(u8, 5), flags);
+    try std.testing.expectEqual(@as(u8, 0), flags & 2);
+}
+
 test "negotiation: kitty flags reply" {
     const s = decodeOne("\x1b[?7u").?;
     try std.testing.expectEqual(@as(usize, 5), s.consumed);
@@ -800,3 +888,4 @@ test "splitter: batched read yields individual keys" {
     off += s3.consumed;
     try std.testing.expectEqual(input.len, off);
 }
+