Repaint reserved toolbar after minimum-height reacquisition

tleonhardt · Sep 12, 2026 · Sep 12, 2026 · Sep 12, 2026 · Sep 12, 2026 · Sep 12, 2026
commit 37645b59755a8795f7d4412fe85f40515ff6a263
@@ -355,7 +355,7 @@ def __init__(
         self._autowrap_after_paint = autowrap_after_paint
         self._last_frame: ToolbarFrame | None = None
         self._last_attrs: Mapping[str, Attrs] | None = None
-        self._last_band: tuple[int, int, int, object] | None = None
+        self._last_band: tuple[int, int, int, object, int] | None = None
         self._pending_error: BaseException | None = None
 
     @property
@@ -438,7 +438,16 @@ def paint(self, prepared: PreparedFrame) -> bool:
                 return False
 
             frame = prepared.frame
-            band = (geometry.physical_rows, geometry.columns, geometry.reserved_rows, geometry.buffer_id)
+            # Identical coordinates do not imply retained cells. A shrink below the
+            # reservation floor can erase the band, then growth can reacquire exactly
+            # the same dimensions and viewport. The new generation needs a full paint.
+            band = (
+                geometry.physical_rows,
+                geometry.columns,
+                geometry.reserved_rows,
+                geometry.buffer_id,
+                geometry.generation,
+            )
             previous = self._last_frame if band == self._last_band else None
             previous_attrs = self._last_attrs if previous is not None else None
             runs = _changed_runs(previous, previous_attrs, frame, prepared.attrs)

@@ -300,6 +300,76 @@ class TestResize:
     attached, so the poll on ``output.get_size()`` is the only way a resize arrives there.
     """
 
+    @pytest.mark.parametrize("terminal_harness", [2, 3], indirect=True)
+    @pytest.mark.parametrize("text", ["", "typed"])
+    def test_minimum_height_reacquisition_through_idle_polling(self, terminal_harness, monkeypatch, text) -> None:
+        """Fallback can erase a cached band before growth returns to exactly the same size."""
+        harness, terminal = terminal_harness
+        ui = harness.app.main_session.app
+        ui.terminal_size_polling_interval = 0.01
+        task = None
+        polls = 0
+        errors = []
+
+        async def until(predicate):
+            async with asyncio.timeout(5):
+                while not predicate():  # noqa: ASYNC110 - observe upstream state without driving a redraw
+                    await asyncio.sleep(0.01)
+
+        async def transitions():
+            try:
+                if text:
+                    harness.pipe.send_text(text)
+                    await until(lambda: ui.current_buffer.text == text)
+                for rows, columns in ((3, 80), (2, 80), (3, 80), (4, 40), (24, 100), (3, 80), (2, 80), (3, 80)):
+                    baseline = polls
+                    # Let upstream establish/settle its size baseline before changing it.
+                    await until(lambda baseline=baseline: polls >= baseline + 2)
+                    if harness.size != Size(rows=rows, columns=columns):
+                        resize(harness, terminal, rows, columns)
+                    toolbar = harness.app.reserved_toolbar
+                    await until(lambda toolbar=toolbar, rows=rows: toolbar.is_active == (rows >= 3))
+                    if rows >= 3:
+                        await until(lambda toolbar=toolbar, rows=rows: toolbar.display.geometry.physical_rows == rows)
+                        await until(lambda: terminal.screen.display[-1].startswith("STATUS"))
+                    await until(lambda: any(row.startswith("TEST> " + text) for row in terminal.screen.display))
+                    assert ui.current_buffer.text == text
+                    assert ui.current_buffer.cursor_position == len(text)
+            except Exception as error:  # noqa: BLE001 - report outside prompt-toolkit's event loop
+                errors.append(error)
+            finally:
+                harness.pipe.send_text("\n")
+
+        def ready(app):
+            nonlocal task
+            if task is None:
+                task = ui.create_background_task(transitions())
+
+        ui.after_render += ready
+        try:
+            with harness.app._reserved_toolbar_context():
+                get_size = ui.output.get_size
+
+                def observe_size():
+                    nonlocal polls
+                    try:
+                        current = asyncio.current_task()
+                    except RuntimeError:
+                        current = None
+                    if current is not None and current.get_coro().__name__ == "_poll_output_size":
+                        polls += 1
+                    return get_size()
+
+                monkeypatch.setattr(ui.output, "get_size", observe_size)
+                assert harness.app._read_raw_input("TEST> ", harness.app.main_session) == text
+                assert task is not None
+                task.result()
+                if errors:
+                    raise errors[0]
+        finally:
+            ui.after_render -= ready
+        assert terminal.screen.margins is None
+
     @pytest.mark.parametrize("terminal_harness", [2], indirect=True)
     def test_initially_short_prompt_grows_and_accepts_visible_input(self, terminal_harness) -> None:
         harness, terminal = terminal_harness
@@ -330,6 +400,45 @@ def ready(app):
             watchdog.join()
             ui.after_render -= ready
 
+    @pytest.mark.parametrize("terminal_harness", [3], indirect=True)
+    @pytest.mark.parametrize("partial", ["", "PARTIAL"])
+    def test_quiet_command_reacquires_the_same_band(self, terminal_harness, monkeypatch, partial) -> None:
+        """The command poll restores the whole band without disturbing unfinished output."""
+        harness, terminal = terminal_harness
+        harness.app.main_session.app.terminal_size_polling_interval = 0.01
+        with harness.app._reserved_toolbar_context(), harness.app._command_toolbar_context():
+            toolbar = harness.app.reserved_toolbar
+            output = harness.app._command_toolbar.app.output
+            get_size = output.get_size
+            polls = 0
+
+            def observe_size():
+                nonlocal polls
+                try:
+                    current = asyncio.current_task()
+                except RuntimeError:
+                    current = None
+                if current is not None and current.get_coro().__name__ == "_poll_output_size":
+                    polls += 1
+                return get_size()
+
+            monkeypatch.setattr(output, "get_size", observe_size)
+            harness.app.stdout.write(partial)
+            harness.app.stdout.flush()
+            for rows in (2, 3, 4, 3, 2, 3):
+                baseline = polls
+                assert wait_for(lambda baseline=baseline: polls >= baseline + 2)
+                resize(harness, terminal, rows, 80)
+                assert wait_for(lambda rows=rows: toolbar.is_active == (rows >= 3))
+                if rows >= 3:
+                    assert wait_for(lambda rows=rows: toolbar.display.geometry.physical_rows == rows)
+                    assert wait_for(lambda: terminal.screen.display[-1].startswith("STATUS"))
+                if partial:
+                    assert any(row.startswith(partial) for row in terminal.screen.display)
+            harness.app.poutput(" COMPLETE")
+            assert any(row.startswith(partial + " COMPLETE") for row in terminal.screen.display)
+        assert terminal.screen.margins is None
+
     @pytest.mark.parametrize("terminal_harness", [2], indirect=True)
     def test_initially_short_terminal_acquires_during_a_quiet_command(self, terminal_harness, monkeypatch) -> None:
         harness, terminal = terminal_harness

@@ -470,6 +470,23 @@ def test_a_geometry_change_forces_a_full_repaint(self) -> None:
         assert harness.paint("hi") is True
         assert "\x1b[12;1Hhi   " in harness.visible()
 
+    @pytest.mark.parametrize("prepare_while_inactive", [False, True])
+    def test_reacquiring_the_same_band_repaints_all_cells(self, prepare_while_inactive: bool) -> None:
+        """Returning from fallback must not reuse cells painted before the reservation ended."""
+        harness = Harness(rows=3)
+        assert harness.paint("hi") is True
+        harness.display.resize(2)
+        assert not harness.display.is_reserved
+        if prepare_while_inactive:
+            assert harness.painter.prepare(lambda: "hi") is None
+        harness.display.resize(3)
+        harness.clear()
+        assert harness.paint("hi") is True
+        assert "\x1b[3;1Hhi   " in harness.visible()
+        harness.clear()
+        assert harness.paint("hi") is False
+        assert harness.written() == ""
+
     def test_empty_content_is_painted_rather_than_skipped(self) -> None:
         """An empty toolbar is an intentional visibility change and must reach the band."""
         harness = Harness()