Backspace when cursor is off right edge of screen should move back two cells

This is extremely counter-intuitive for a terminal like kitty that
allows the cursor to be off screen when drawing a char in the last cell.

However, most other terminals dont allow the cursor to be off the right
edge so it makes sense for them. There is no terminfo property
controlling this behavior as far as I know.

The execrable ncurses actually relies on this behavior of backspace to
position the cursor in some cases, the good lord alone knows why.
So in the interests of compatibility lets special case backsapce when
cursor is off the right edge.

A simple test script to see the behavior:

```py
import subprocess

cols = int(subprocess.check_output('tput cols'.split()).decode().strip())
print(end='\x1b[?7l')  # turn off line wrap
print('a' * cols, end='\x08bc')  # print a upto last cell then backspace and bc
input()
print(end='\x1b[?7h')  # turn on line wrap
print()
```

This should result in a line starting with aaaa and ending with bc.
It does so in most terminals, exceptions being foot and kitty before
this patch.

Note that this also means that backspacing when cursor is off the right
edge of the terminal is broken in all terminals with this weird
behavior. See the docs in screen_backspace() for details. Sigh.

Fixes #8841

Author: kovidgoyal

docs/changelog.rst

@@ -118,6 +118,9 @@ Detailed list of changes
 - macOS: Fix hiding quick access terminal window not restoring focus to
   previously active application (:disc:`8840`)
 
+- Special case backspacing when cursor is off the right edge of the screen to
+  backspace two cells. (:iss:`8841`)
+
 0.42.2 [2025-07-16]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

kitty/screen.c

@@ -1962,8 +1962,21 @@ screen_set_tab_stop(Screen *self) {
 void
 screen_cursor_back(Screen *self, unsigned int count/*=1*/, int move_direction/*=-1*/) {
     if (count == 0) count = 1;
-    if (move_direction < 0 && count > self->cursor->x) self->cursor->x = 0;
-    else self->cursor->x += move_direction * count;
+    if (move_direction < 0) {
+        // we allow the cursor to go off the right edge of the screen when
+        // drawing a char in the rightmost cell. This is different form most
+        // terminals. Because of the behavior of most terminals, the execrable
+        // ncurses assumes that drawing a char on the right most cell and then
+        // doing a backspace actually moves the cursor back two spaces. Sigh.
+        // Note that doing this means that when inputting in cooked mode, for
+        // example, using `read` in a shell and typing to the right edge of the
+        // screen and doing backspace, the rightmost cell retains text and the
+        // text from the right but one cell is deleted, which is wrong since
+        // the kernel buffer only deletes the rightmost cell.
+        if (self->cursor->x >= self->columns) self->cursor->x = self->columns-1;
+        if (count > self->cursor->x) count = self->cursor->x;
+    }
+    self->cursor->x += move_direction * count;
     screen_ensure_bounds(self, false, cursor_within_margins(self));
 }
 

kitty_tests/screen.py

@@ -162,7 +162,7 @@ def init():
             s.reset(), s.reset_dirty()
             s.draw('abcde')
             s.cursor.bold = True
-            s.cursor_back(4)
+            s.cursor_back(3)  # cursor is off the edge of screen but in this situation a single back moves it back two cells
             s.reset_dirty()
             self.ae(s.cursor.x, 1)
 
@@ -561,11 +561,13 @@ def nl():
                     # Simple wrapping
                     s.cursor_position(region, s.columns), s.draw(chr(ord('A') + i - 1).lower() + ch)
                     # Backspace at right margin
-                    s.cursor_position(region + 1, s.columns), s.draw(ch), s.backspace(), s.draw(ch.lower())
+                    s.cursor_position(region + 1, s.columns), s.draw(ch), s.backspace()
+                    s.cursor.x += 1
+                    s.draw(ch.lower())
                     nl()
                 elif which == 2:
                     # Tab to right margin
-                    s.cursor_position(region + 1, s.columns), s.draw(ch), s.backspace(), s.backspace(), s.tab(), s.tab(), s.draw(ch.lower())
+                    s.cursor_position(region + 1, s.columns), s.draw(ch), s.backspace(), s.tab(), s.tab(), s.draw(ch.lower())
                     s.cursor_position(region + 1, 2), s.backspace(), s.draw(ch), nl()
                 else:
                     s.cursor_position(region + 1, 1), nl()