Keep both ends of a selected range across a re-render

A range or hunk selection covers a stretch of the diff, and restoring only
the cursor left the other end pointing at whatever line the new rendering
happened to put there — with more context lines above, a selected hunk
would grow a tail of context it never covered.

So the other end is remembered by identity too, and put back before the
cursor. If it is a line the re-render dropped, the selection is left as the
single line we landed on: there is no telling which line inherits a
selection's edge, and a wrong guess acts on lines the user never chose.

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>

AGENTS.md

@@ -63,7 +63,9 @@ Prefer a fine-grained commit history. Commits should be as small as possible
 while still being meaningful and self-contained.
 
 - **Every commit must compile and pass all tests.** No "WIP" commits, no
-  commits that leave the tree broken and rely on a follow-up to fix it.
+  commits that leave the tree broken and rely on a follow-up to fix it. A
+  `fixup!` is not such a follow-up; see "Iterate with `fixup!` commits" for
+  what one may leave broken until it is folded in.
 - **Every commit must be `gofumpt`-formatted.** Run `just format` before
   committing.
 - **Every commit must be lint-clean.** Run `just lint` before committing —
@@ -134,6 +136,32 @@ target, make the change, `git commit --fixup=<target>`, then
 branch. The fixup stays a separate, reviewable commit; only its position
 changes.
 
+**A fixup may leave commits before it broken until it is folded in.** If a
+`fixup!` on an early commit deletes something that a later commit still uses,
+the later commit doesn't build until its own `fixup!`, right behind it, catches
+up; the same goes for lint. That is expected. The rules above about every
+commit compiling, testing and linting clean describe the history _after_
+autosquash, and I fold fixups in soon after reviewing them. Never amend a
+commit directly, or edit the commits between two fixups, to keep every commit
+of the un-squashed history green. The reviewable fixup is worth more than a
+green intermediate state. Verify at each fixup instead, since the tree there
+is what the folded-in history will have at that point, and say in the handoff
+which commits stay broken until which fixup.
+
+**After a mid-stack fixup, check every branch tip above it, not just the stack
+tip.** A fixup that deletes or renames something rewrites every commit replayed
+above it, and a commit further up can hide the damage at the tip. A helper
+whose last caller the fixup deleted is flagged as unused by `just lint` at the
+tip of its own PR, but a later PR that calls it again makes the stack tip lint
+clean. Each PR is reviewed and merged on its own, so each PR branch tip has to
+be green on its own. After the replay, run `just build`, `just unit-test` and
+`just lint` at each branch tip from the insertion point up. If the fixup deleted
+or renamed a symbol, also build every replayed commit, for example with
+`git -c rebase.autosquash=false rebase -x 'go build ./...' <insertion point>`;
+unchanged commits are fast-forwarded, so their hashes stay, and the commits a
+fixup is expected to leave broken stop it, so `git rebase --continue` past
+those.
+
 If the changes don't map cleanly onto existing commits — say they cut
 across several of them, or restructure something at a different layer
 than any existing commit naturally owns — stop and ask the user how to
@@ -180,7 +208,7 @@ looks messy. The whole point of a fixup is that the iteration stays
 **visible and reviewable**; squashing it away yourself destroys exactly the
 artifact it exists to create. Collapsing fixups into their targets is the
 user's action, taken once they've reviewed the iterations. Every mention of
-`--autosquash` in this section describes what the *user* will eventually
+`--autosquash` in this section describes what the _user_ will eventually
 run, never a step for you to perform. If you think the history is ready to
 collapse, say so and leave it to them.
 
@@ -320,7 +348,7 @@ refactor to an earlier commit (but don't do it without asking first).
 ## Don't read model state right after a `Refresh`
 
 A `Refresh` (or `RefreshFromWorker`) does its git work on a worker and then
-*enqueues* the model update onto the UI thread. So when `Refresh` returns, the
+_enqueues_ the model update onto the UI thread. So when `Refresh` returns, the
 model is **not** updated yet — the write is still queued. Reading a field
 synchronously right after refreshing its scope reads the stale, pre-refresh
 value (and this is true even for SYNC refreshes):
@@ -406,7 +434,7 @@ column. Applies only to `pkg/i18n/english.go`.
 
 ## Code comments are for future readers, not development history
 
-Comments in source code explain *why this code is shaped the way it is*. They
+Comments in source code explain _why this code is shaped the way it is_. They
 are not the place to narrate the path we took during development — what was
 tried first, what didn't work, what's "more reliable" or "cleaner" than some
 alternative. That framing is interesting in the moment, but it's noise to
@@ -422,7 +450,7 @@ Avoid phrasings like:
 - "X rather than Y", where Y is what the code did before the change
 
 The iteration story is sometimes worth preserving — but it belongs in the
-commit message, which is the durable record of *why this change was made*. The
+commit message, which is the durable record of _why this change was made_. The
 code comment should make sense to someone who has never seen any prior version
 and is just trying to understand the file as it currently exists.
 
@@ -475,7 +503,7 @@ So:
   struct, run `just generate` and include the regenerated
   `docs-master/Config.md` (and `schema-master/config.json`) in your commit.
 - Don't hard-wrap the doc comments on `userConfig` fields. This applies
-  *only* to `userConfig`, because those comments are fed through the doc
+  _only_ to `userConfig`, because those comments are fed through the doc
   generator; comments on every other struct follow the normal Go wrapping
   conventions. For `userConfig` fields, write each sentence (or paragraph)
   as a single unwrapped line, however long — the generator re-wraps them for

docs-master/Config.md

@@ -845,6 +845,8 @@ keybinding:
   main:
     prevHunk: [<left>, h]
     nextHunk: [<right>, l]
+    prevFile: "N"
+    nextFile: "n"
     toggleSelectHunk: a
     pickBothHunks: b
     editSelectHunk: E

docs-master/keybindings/Keybindings_en.md

@@ -223,6 +223,13 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 | `` <mouse wheel down> (fn+up) `` | Scroll down |  |
 | `` <mouse wheel up> (fn+down) `` | Scroll up |  |
 | `` <tab> `` | Switch view | Switch to other view (staged/unstaged changes). |
+| `` a `` | Toggle hunk selection | Toggle line-by-line vs. hunk selection mode. |
+| `` v `` | Toggle range select |  |
+| `` e `` | Edit file | Open file in external editor. |
+| `` <left>, h `` | Go to previous hunk |  |
+| `` <right>, l `` | Go to next hunk |  |
+| `` N `` | Go to previous file |  |
+| `` n `` | Go to next file |  |
 | `` <esc> `` | Exit back to side panel |  |
 | `` / `` | Search the current view by text |  |
 
@@ -328,6 +335,13 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 | Key | Action | Info |
 |-----|--------|-------------|
 | `` <tab> `` | Switch view | Switch to other view (staged/unstaged changes). |
+| `` a `` | Toggle hunk selection | Toggle line-by-line vs. hunk selection mode. |
+| `` v `` | Toggle range select |  |
+| `` e `` | Edit file | Open file in external editor. |
+| `` <left>, h `` | Go to previous hunk |  |
+| `` <right>, l `` | Go to next hunk |  |
+| `` N `` | Go to previous file |  |
+| `` n `` | Go to next file |  |
 | `` <esc> `` | Exit back to side panel |  |
 | `` / `` | Search the current view by text |  |
 

docs-master/keybindings/Keybindings_ja.md

@@ -192,6 +192,13 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 | Key | Action | Info |
 |-----|--------|-------------|
 | `` <tab> `` | ビューを切り替え | 他のビュー（ステージされた変更/ステージされていない変更）に切り替えます。 |
+| `` a `` | ハンクの選択を切り替える | Toggle line-by-line vs. hunk selection mode. |
+| `` v `` | 範囲選択を切り替え |  |
+| `` e `` | ファイルを編集 | 外部エディタでファイルを開きます。 |
+| `` <left>, h `` | 前のハンクに移動 |  |
+| `` <right>, l `` | 次のハンクに移動 |  |
+| `` N `` | Go to previous file |  |
+| `` n `` | Go to next file |  |
 | `` <esc> `` | サイドパネルに戻る |  |
 | `` / `` | 現在のビューをテキストで検索 |  |
 
@@ -305,6 +312,13 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 | `` <mouse wheel down> (fn+up) `` | 下にスクロール |  |
 | `` <mouse wheel up> (fn+down) `` | 上にスクロール |  |
 | `` <tab> `` | ビューを切り替え | 他のビュー（ステージされた変更/ステージされていない変更）に切り替えます。 |
+| `` a `` | ハンクの選択を切り替える | Toggle line-by-line vs. hunk selection mode. |
+| `` v `` | 範囲選択を切り替え |  |
+| `` e `` | ファイルを編集 | 外部エディタでファイルを開きます。 |
+| `` <left>, h `` | 前のハンクに移動 |  |
+| `` <right>, l `` | 次のハンクに移動 |  |
+| `` N `` | Go to previous file |  |
+| `` n `` | Go to next file |  |
 | `` <esc> `` | サイドパネルに戻る |  |
 | `` / `` | 現在のビューをテキストで検索 |  |
 

docs-master/keybindings/Keybindings_ko.md

@@ -84,6 +84,13 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 | Key | Action | Info |
 |-----|--------|-------------|
 | `` <tab> `` | 패널 전환 | Switch to other view (staged/unstaged changes). |
+| `` a `` | Toggle hunk selection | Toggle line-by-line vs. hunk selection mode. |
+| `` v `` | 드래그 선택 전환 |  |
+| `` e `` | 파일 편집 | Open file in external editor. |
+| `` <left>, h `` | 이전 hunk를 선택 |  |
+| `` <right>, l `` | 다음 hunk를 선택 |  |
+| `` N `` | Go to previous file |  |
+| `` n `` | Go to next file |  |
 | `` <esc> `` | Exit back to side panel |  |
 | `` / `` | 검색 시작 |  |
 
@@ -162,6 +169,13 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 | `` <mouse wheel down> (fn+up) `` | 아래로 스크롤 |  |
 | `` <mouse wheel up> (fn+down) `` | 위로 스크롤 |  |
 | `` <tab> `` | 패널 전환 | Switch to other view (staged/unstaged changes). |
+| `` a `` | Toggle hunk selection | Toggle line-by-line vs. hunk selection mode. |
+| `` v `` | 드래그 선택 전환 |  |
+| `` e `` | 파일 편집 | Open file in external editor. |
+| `` <left>, h `` | 이전 hunk를 선택 |  |
+| `` <right>, l `` | 다음 hunk를 선택 |  |
+| `` N `` | Go to previous file |  |
+| `` n `` | Go to next file |  |
 | `` <esc> `` | Exit back to side panel |  |
 | `` / `` | 검색 시작 |  |
 

docs-master/keybindings/Keybindings_nl.md

@@ -231,6 +231,13 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 | `` <mouse wheel down> (fn+up) `` | Scroll omlaag |  |
 | `` <mouse wheel up> (fn+down) `` | Scroll omhoog |  |
 | `` <tab> `` | Ga naar een ander paneel | Switch to other view (staged/unstaged changes). |
+| `` a `` | Wissel tussen hunk selectie aan of uit | Wissel tussen regel-voor-regel of hunk selectie modus. |
+| `` v `` | Toggle drag selecteer |  |
+| `` e `` | Verander bestand | Open bestand in externe editor. |
+| `` <left>, h `` | Selecteer de vorige hunk |  |
+| `` <right>, l `` | Selecteer de volgende hunk |  |
+| `` N `` | Go to previous file |  |
+| `` n `` | Go to next file |  |
 | `` <esc> `` | Exit back to side panel |  |
 | `` / `` | Start met zoeken |  |
 
@@ -306,6 +313,13 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 | Key | Action | Info |
 |-----|--------|-------------|
 | `` <tab> `` | Ga naar een ander paneel | Switch to other view (staged/unstaged changes). |
+| `` a `` | Wissel tussen hunk selectie aan of uit | Wissel tussen regel-voor-regel of hunk selectie modus. |
+| `` v `` | Toggle drag selecteer |  |
+| `` e `` | Verander bestand | Open bestand in externe editor. |
+| `` <left>, h `` | Selecteer de vorige hunk |  |
+| `` <right>, l `` | Selecteer de volgende hunk |  |
+| `` N `` | Go to previous file |  |
+| `` n `` | Go to next file |  |
 | `` <esc> `` | Exit back to side panel |  |
 | `` / `` | Start met zoeken |  |
 

docs-master/keybindings/Keybindings_pl.md

@@ -99,6 +99,13 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 | Key | Action | Info |
 |-----|--------|-------------|
 | `` <tab> `` | Przełącz widok | Przełącz na inny widok (zatwierdzone/niezatwierdzone zmiany). |
+| `` a `` | Toggle hunk selection | Toggle line-by-line vs. hunk selection mode. |
+| `` v `` | Przełącz zaznaczenie zakresu |  |
+| `` e `` | Edytuj plik | Otwórz plik w zewnętrznym edytorze. |
+| `` <left>, h `` | Idź do poprzedniego fragmentu |  |
+| `` <right>, l `` | Idź do następnego fragmentu |  |
+| `` N `` | Go to previous file |  |
+| `` n `` | Go to next file |  |
 | `` <esc> `` | Exit back to side panel |  |
 | `` / `` | Szukaj w bieżącym widoku po tekście |  |
 
@@ -201,6 +208,13 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 | `` <mouse wheel down> (fn+up) `` | Przewiń w dół |  |
 | `` <mouse wheel up> (fn+down) `` | Przewiń w górę |  |
 | `` <tab> `` | Przełącz widok | Przełącz na inny widok (zatwierdzone/niezatwierdzone zmiany). |
+| `` a `` | Toggle hunk selection | Toggle line-by-line vs. hunk selection mode. |
+| `` v `` | Przełącz zaznaczenie zakresu |  |
+| `` e `` | Edytuj plik | Otwórz plik w zewnętrznym edytorze. |
+| `` <left>, h `` | Idź do poprzedniego fragmentu |  |
+| `` <right>, l `` | Idź do następnego fragmentu |  |
+| `` N `` | Go to previous file |  |
+| `` n `` | Go to next file |  |
 | `` <esc> `` | Exit back to side panel |  |
 | `` / `` | Szukaj w bieżącym widoku po tekście |  |
 

docs-master/keybindings/Keybindings_pt.md

@@ -235,6 +235,13 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 | `` <mouse wheel down> (fn+up) `` | Rolar para baixo |  |
 | `` <mouse wheel up> (fn+down) `` | Rolar para cima |  |
 | `` <tab> `` | Mudar de visão | Alternar para outra visão (staged/não processadas alterações). |
+| `` a `` | Toggle hunk selection | Ativa/desativa modo linha por linha vs. modo de seleção por partes. |
+| `` v `` | Toggle range select |  |
+| `` e `` | Editar arquivo | Abrir arquivo no editor externo. |
+| `` <left>, h `` | Ir para o local anterior |  |
+| `` <right>, l `` | Ir para o próximo trecho |  |
+| `` N `` | Go to previous file |  |
+| `` n `` | Go to next file |  |
 | `` <esc> `` | Exit back to side panel |  |
 | `` / `` | Pesquisar na visualização atual por texto |  |
 
@@ -337,6 +344,13 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 | Key | Action | Info |
 |-----|--------|-------------|
 | `` <tab> `` | Mudar de visão | Alternar para outra visão (staged/não processadas alterações). |
+| `` a `` | Toggle hunk selection | Ativa/desativa modo linha por linha vs. modo de seleção por partes. |
+| `` v `` | Toggle range select |  |
+| `` e `` | Editar arquivo | Abrir arquivo no editor externo. |
+| `` <left>, h `` | Ir para o local anterior |  |
+| `` <right>, l `` | Ir para o próximo trecho |  |
+| `` N `` | Go to previous file |  |
+| `` n `` | Go to next file |  |
 | `` <esc> `` | Exit back to side panel |  |
 | `` / `` | Pesquisar na visualização atual por texto |  |
 

docs-master/keybindings/Keybindings_ru.md

@@ -74,6 +74,13 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 | Key | Action | Info |
 |-----|--------|-------------|
 | `` <tab> `` | Переключиться на другую панель (проиндексированные/непроиндексированные изменения) | Switch to other view (staged/unstaged changes). |
+| `` a `` | Toggle hunk selection | Toggle line-by-line vs. hunk selection mode. |
+| `` v `` | Переключить выборку перетаскивания |  |
+| `` e `` | Редактировать файл | Open file in external editor. |
+| `` <left>, h `` | Выбрать предыдущую часть |  |
+| `` <right>, l `` | Выбрать следующую часть |  |
+| `` N `` | Go to previous file |  |
+| `` n `` | Go to next file |  |
 | `` <esc> `` | Exit back to side panel |  |
 | `` / `` | Найти |  |
 
@@ -106,6 +113,13 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 | `` <mouse wheel down> (fn+up) `` | Прокрутить вниз |  |
 | `` <mouse wheel up> (fn+down) `` | Прокрутить вверх |  |
 | `` <tab> `` | Переключиться на другую панель (проиндексированные/непроиндексированные изменения) | Switch to other view (staged/unstaged changes). |
+| `` a `` | Toggle hunk selection | Toggle line-by-line vs. hunk selection mode. |
+| `` v `` | Переключить выборку перетаскивания |  |
+| `` e `` | Редактировать файл | Open file in external editor. |
+| `` <left>, h `` | Выбрать предыдущую часть |  |
+| `` <right>, l `` | Выбрать следующую часть |  |
+| `` N `` | Go to previous file |  |
+| `` n `` | Go to next file |  |
 | `` <esc> `` | Exit back to side panel |  |
 | `` / `` | Найти |  |
 

docs-master/keybindings/Keybindings_zh-CN.md

@@ -286,6 +286,13 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 | Key | Action | Info |
 |-----|--------|-------------|
 | `` <tab> `` | 切换到其他面板 | 切换到其他视图（已暂存/未暂存的变更） |
+| `` a `` | 切换代码块选择 | 切换逐行选择与代码块选择模式。 |
+| `` v `` | 切换拖动选择 |  |
+| `` e `` | 编辑文件 | 使用外部编辑器打开文件 |
+| `` <left>, h `` | 选择上一个区块 |  |
+| `` <right>, l `` | 选择下一个区块 |  |
+| `` N `` | Go to previous file |  |
+| `` n `` | Go to next file |  |
 | `` <esc> `` | 退出回到侧边面板 |  |
 | `` / `` | 开始搜索 |  |
 
@@ -334,6 +341,13 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 | `` <mouse wheel down> (fn+up) `` | 向下滚动 |  |
 | `` <mouse wheel up> (fn+down) `` | 向上滚动 |  |
 | `` <tab> `` | 切换到其他面板 | 切换到其他视图（已暂存/未暂存的变更） |
+| `` a `` | 切换代码块选择 | 切换逐行选择与代码块选择模式。 |
+| `` v `` | 切换拖动选择 |  |
+| `` e `` | 编辑文件 | 使用外部编辑器打开文件 |
+| `` <left>, h `` | 选择上一个区块 |  |
+| `` <right>, l `` | 选择下一个区块 |  |
+| `` N `` | Go to previous file |  |
+| `` n `` | Go to next file |  |
 | `` <esc> `` | 退出回到侧边面板 |  |
 | `` / `` | 开始搜索 |  |
 

docs-master/keybindings/Keybindings_zh-TW.md

@@ -75,6 +75,13 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 | `` <mouse wheel down> (fn+up) `` | 向下捲動 |  |
 | `` <mouse wheel up> (fn+down) `` | 向上捲動 |  |
 | `` <tab> `` | 切換至另一個面板 (已預存/未預存更改) | 切換到其他檢視（已暫存/未暫存的變更）。 |
+| `` a `` | 切換程式碼塊選擇 | 切換逐行選擇與程式碼塊選擇模式。 |
+| `` v `` | 切換拖曳選擇 |  |
+| `` e `` | 編輯檔案 | 使用外部編輯器開啟 |
+| `` <left>, h `` | 選擇上一段 |  |
+| `` <right>, l `` | 選擇下一段 |  |
+| `` N `` | Go to previous file |  |
+| `` n `` | Go to next file |  |
 | `` <esc> `` | 退出回到側邊面板 |  |
 | `` / `` | 搜尋 |  |
 
@@ -356,6 +363,13 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 | Key | Action | Info |
 |-----|--------|-------------|
 | `` <tab> `` | 切換至另一個面板 (已預存/未預存更改) | 切換到其他檢視（已暫存/未暫存的變更）。 |
+| `` a `` | 切換程式碼塊選擇 | 切換逐行選擇與程式碼塊選擇模式。 |
+| `` v `` | 切換拖曳選擇 |  |
+| `` e `` | 編輯檔案 | 使用外部編輯器開啟 |
+| `` <left>, h `` | 選擇上一段 |  |
+| `` <right>, l `` | 選擇下一段 |  |
+| `` N `` | Go to previous file |  |
+| `` n `` | Go to next file |  |
 | `` <esc> `` | 退出回到側邊面板 |  |
 | `` / `` | 搜尋 |  |
 

pkg/config/user_config.go

@@ -672,6 +672,8 @@ type KeybindingCommitFilesConfig struct {
 type KeybindingMainConfig struct {
 	PrevHunk         Keybinding `yaml:"prevHunk"`
 	NextHunk         Keybinding `yaml:"nextHunk"`
+	PrevFile         Keybinding `yaml:"prevFile"`
+	NextFile         Keybinding `yaml:"nextFile"`
 	ToggleSelectHunk Keybinding `yaml:"toggleSelectHunk"`
 	PickBothHunks    Keybinding `yaml:"pickBothHunks"`
 	EditSelectHunk   Keybinding `yaml:"editSelectHunk"`
@@ -1182,6 +1184,8 @@ func GetDefaultConfigForPlatform(platform string) *UserConfig {
 			Main: KeybindingMainConfig{
 				PrevHunk:         Keybinding{"<left>", "h"},
 				NextHunk:         Keybinding{"<right>", "l"},
+				PrevFile:         Keybinding{"N"},
+				NextFile:         Keybinding{"n"},
 				ToggleSelectHunk: Keybinding{"a"},
 				PickBothHunks:    Keybinding{"b"},
 				EditSelectHunk:   Keybinding{"E"},

pkg/gocui/view.go

@@ -164,6 +164,12 @@ type View struct {
 	// instead of Sel{Bg,Fg}Colors for highlighting selected lines.
 	HighlightInactive bool
 
+	// If SelectedLineColorWidth is greater than zero, a highlighted line is painted
+	// in the selection colors on that many columns at its left edge only, rather
+	// than across its whole width, leaving the line's own colors to show through.
+	// For content that conveys meaning by color of its own.
+	SelectedLineColorWidth int
+
 	// If Frame is true, a border will be drawn around the view.
 	Frame bool
 
@@ -621,10 +627,23 @@ func (v *View) SetRangeSelectStart(rangeSelectStartY int) {
 	v.rangeSelectStartY = rangeSelectStartY
 }
 
+// RangeSelectStartY returns the view line the range selection is anchored on,
+// or -1 when there is no range.
+func (v *View) RangeSelectStartY() int {
+	return v.rangeSelectStartY
+}
+
 func (v *View) CancelRangeSelect() {
 	v.rangeSelectStartY = -1
 }
 
+// HasRangeSelect reports whether a range selection is anchored, as opposed to the
+// view showing a plain cursor. A range whose ends are on the same view line is still
+// one, which SelectedLineRange alone can't tell you.
+func (v *View) HasRangeSelect() bool {
+	return v.rangeSelectStartY != -1
+}
+
 func calculateNewOrigin(selectedLine int, oldOrigin int, lineCount int, viewHeight int) int {
 	if viewHeight >= lineCount {
 		return 0
@@ -863,7 +882,8 @@ func (v *View) setCharacter(x, y int, ch string, fgColor, bgColor Attribute, isW
 			rangeSelectEnd = max(relativeRangeSelectStart, v.cy)
 		}
 
-		if y >= rangeSelectStart && y <= rangeSelectEnd {
+		colorWidth := v.SelectedLineColorWidth
+		if y >= rangeSelectStart && y <= rangeSelectEnd && (colorWidth == 0 || x < colorWidth) {
 			fgColor = applySelTextColor(fgColor, v.SelTextColor)
 			if v.HighlightInactive || !isWindowFocused {
 				bgColor = (bgColor & AttrStyleBits) | v.InactiveViewSelBgColor
@@ -1983,9 +2003,60 @@ func (v *View) DiffLineContents() []DiffLineContent {
 	v.writeMutex.Lock()
 	defer v.writeMutex.Unlock()
 
-	contents := make([]DiffLineContent, len(v.buf.lines))
-	for i := range v.buf.lines {
-		line := &v.buf.lines[i]
+	return diffLineContentsFrom(v.buf, 0)
+}
+
+// OffscreenDiffLineContents is DiffLineContents for the content of a re-render in
+// progress (see BeginOffscreenRender). A reader deciding where the new content
+// should be shown has to work from this: it has to answer before the swap, since
+// after the swap the content is already on screen. Returns nil when no re-render
+// is underway.
+func (v *View) OffscreenDiffLineContents() []DiffLineContent {
+	v.writeMutex.Lock()
+	defer v.writeMutex.Unlock()
+
+	if v.offscreen == nil {
+		return nil
+	}
+	return diffLineContentsFrom(v.offscreen, 0)
+}
+
+// OffscreenDiffLineContentsFrom is OffscreenDiffLineContents restricted to the lines
+// from index `from` on (so result[0] is buffer line `from`). It lets a reader that
+// follows a re-render as it loads look at each line once, rather than snapshotting
+// the whole buffer again on every line — the difference between an O(n) and an O(n²)
+// scan of a large diff. Returns nil when no re-render is underway, or when `from` is
+// past the lines read so far.
+func (v *View) OffscreenDiffLineContentsFrom(from int) []DiffLineContent {
+	v.writeMutex.Lock()
+	defer v.writeMutex.Unlock()
+
+	if v.offscreen == nil || from < 0 || from >= len(v.offscreen.lines) {
+		return nil
+	}
+	return diffLineContentsFrom(v.offscreen, from)
+}
+
+// OffscreenLineCount returns the number of unwrapped lines a re-render in progress
+// has read so far, or 0 when none is underway. It tells a reader waiting for a
+// particular line, cheaply, when a screenful below it has arrived too — so that the
+// swap shows that line with content under it rather than at the bottom edge of a
+// half-filled view.
+func (v *View) OffscreenLineCount() int {
+	v.writeMutex.Lock()
+	defer v.writeMutex.Unlock()
+
+	if v.offscreen == nil {
+		return 0
+	}
+	return len(v.offscreen.lines)
+}
+
+func diffLineContentsFrom(buf *viewBuffer, from int) []DiffLineContent {
+	lines := buf.lines[from:]
+	contents := make([]DiffLineContent, len(lines))
+	for i := range lines {
+		line := &lines[i]
 		var metadata []string
 		for _, c := range line.cells {
 			if c.metadata != "" && !slices.Contains(metadata, c.metadata) {
@@ -2063,6 +2134,9 @@ func (v *View) ViewBufferLines() []string {
 
 // LinesHeight is the count of view lines (i.e. lines excluding wrapping)
 func (v *View) LinesHeight() int {
+	v.writeMutex.Lock()
+	defer v.writeMutex.Unlock()
+
 	return len(v.buf.lines)
 }
 
@@ -2272,6 +2346,20 @@ func (v *View) SelectedLineIdx() int {
 	return seletedLineIdx
 }
 
+// IsLineVisible reports whether the given view line is one of those on screen.
+func (v *View) IsLineVisible(viewLine int) bool {
+	return viewLine >= v.OriginY() && viewLine < v.OriginY()+v.InnerHeight()
+}
+
+// MiddleVisibleLineIdx returns the view line halfway down the visible content. It
+// stands in for a cursor in a view that has none: of the lines on screen, the one in
+// the middle is the likeliest to be the one being read.
+func (v *View) MiddleVisibleLineIdx() int {
+	top := v.OriginY()
+	bottom := min(top+v.InnerHeight(), v.ViewLinesHeight())
+	return (top + bottom) / 2
+}
+
 // expected to only be used in tests
 func (v *View) SelectedLine() string {
 	v.writeMutex.Lock()

pkg/gui/context.go

@@ -196,12 +196,12 @@ func (self *ContextMgr) Activate(c types.Context, opts types.OnFocusOpts) {
 
 	self.gui.c.GocuiGui().Cursor = v.Editable && v.Mask == ""
 
-	self.updateSelectionHighlights()
+	self.UpdateSelectionHighlights()
 
 	c.HandleFocus(opts)
 }
 
-// updateSelectionHighlights re-derives which views draw a selection, and which of
+// UpdateSelectionHighlights re-derives which views draw a selection, and which of
 // them draw theirs as the active one: a view shows a selection while its context is
 // on the stack and has something to select, and the context the user is in shows the
 // active selection while the ones behind it show inactive ones.
@@ -210,7 +210,7 @@ func (self *ContextMgr) Activate(c types.Context, opts types.OnFocusOpts) {
 // every change to the stack goes through; after a refresh, since that is when the
 // contents of a list change; and from whoever tells a context that its content has
 // gained or lost something to select.
-func (self *ContextMgr) updateSelectionHighlights() {
+func (self *ContextMgr) UpdateSelectionHighlights() {
 	self.RLock()
 	defer self.RUnlock()
 
@@ -399,3 +399,14 @@ func (self *ContextMgr) NextInStack(c types.Context) types.Context {
 
 	panic("context not in stack")
 }
+
+// IsInStack reports whether the given context is on the stack at all, for callers
+// that can't otherwise know and would make NextInStack panic.
+func (self *ContextMgr) IsInStack(c types.Context) bool {
+	self.RLock()
+	defer self.RUnlock()
+
+	return lo.ContainsBy(self.ContextStack, func(other types.Context) bool {
+		return other.GetKey() == c.GetKey()
+	})
+}

pkg/gui/context/base_context.go

@@ -13,15 +13,14 @@ type BaseContext struct {
 	windowName      string
 	onGetOptionsMap func() map[string]string
 
-	keybindingsFns           []types.KeybindingsFn
-	mouseKeybindingsFns      []types.MouseKeybindingsFn
-	onDoubleClickFn          func() error
-	onClickFn                func(opts gocui.ViewMouseBindingOpts) error
-	onClickFocusedMainViewFn onClickFocusedMainViewFn
-	onRenderToMainFn         func()
-	onFocusFns               []onFocusFn
-	onFocusLostFns           []onFocusLostFn
-	onQuitFns                []func()
+	keybindingsFns      []types.KeybindingsFn
+	mouseKeybindingsFns []types.MouseKeybindingsFn
+	onDoubleClickFn     func() error
+	onClickFn           func(opts gocui.ViewMouseBindingOpts) error
+	onRenderToMainFn    func()
+	onFocusFns          []onFocusFn
+	onFocusLostFns      []onFocusLostFn
+	onQuitFns           []func()
 
 	focusable                   bool
 	transient                   bool
@@ -34,9 +33,8 @@ type BaseContext struct {
 }
 
 type (
-	onFocusFn                = func(types.OnFocusOpts)
-	onFocusLostFn            = func(types.OnFocusLostOpts)
-	onClickFocusedMainViewFn = func(mainViewName string, clickedLineIdx int) error
+	onFocusFn     = func(types.OnFocusOpts)
+	onFocusLostFn = func(types.OnFocusLostOpts)
 )
 
 var _ types.IBaseContext = &BaseContext{}
@@ -122,6 +120,14 @@ func (self *BaseContext) HasSelectableContent() bool {
 	return self.hasSelectableContent
 }
 
+// SetHasSelectableContent is for the contexts whose answer isn't fixed and isn't a
+// list length either: the main panes, which can only tell by reading the diff they
+// have rendered. Whoever sets it re-derives the highlights that follow from it (see
+// ContextMgr.UpdateSelectionHighlights).
+func (self *BaseContext) SetHasSelectableContent(value bool) {
+	self.hasSelectableContent = value
+}
+
 func (self *BaseContext) GetKey() types.ContextKey {
 	return self.key
 }
@@ -153,7 +159,6 @@ func (self *BaseContext) ClearAllAttachedControllerFunctions() {
 	self.onQuitFns = nil
 	self.onDoubleClickFn = nil
 	self.onClickFn = nil
-	self.onClickFocusedMainViewFn = nil
 	self.onRenderToMainFn = nil
 }
 
@@ -175,15 +180,6 @@ func (self *BaseContext) AddOnClickFn(fn func(opts gocui.ViewMouseBindingOpts) e
 	}
 }
 
-func (self *BaseContext) AddOnClickFocusedMainViewFn(fn onClickFocusedMainViewFn) {
-	if fn != nil {
-		if self.onClickFocusedMainViewFn != nil {
-			panic("only one controller is allowed to set an onClickFocusedMainViewFn")
-		}
-		self.onClickFocusedMainViewFn = fn
-	}
-}
-
 func (self *BaseContext) GetOnDoubleClick() func() error {
 	return self.onDoubleClickFn
 }
@@ -192,10 +188,6 @@ func (self *BaseContext) GetOnClick() func(opts gocui.ViewMouseBindingOpts) erro
 	return self.onClickFn
 }
 
-func (self *BaseContext) GetOnClickFocusedMainView() onClickFocusedMainViewFn {
-	return self.onClickFocusedMainViewFn
-}
-
 func (self *BaseContext) AddOnRenderToMainFn(fn func()) {
 	if fn != nil {
 		if self.onRenderToMainFn != nil {

pkg/gui/context/commit_files_context.go

@@ -19,11 +19,16 @@ type CommitFilesContext struct {
 }
 
 var (
-	_ types.IListContext       = (*CommitFilesContext)(nil)
-	_ types.DiffableContext    = (*CommitFilesContext)(nil)
-	_ types.IFilterableContext = (*CommitFilesContext)(nil)
+	_ types.IListContext        = (*CommitFilesContext)(nil)
+	_ types.DiffableContext     = (*CommitFilesContext)(nil)
+	_ types.IFilterableContext  = (*CommitFilesContext)(nil)
+	_ types.DiffMainViewContext = (*CommitFilesContext)(nil)
 )
 
+func (self *CommitFilesContext) GetDiffMainViewType() types.DiffMainViewType {
+	return types.DiffMainViewTypePatchBuilding
+}
+
 func NewCommitFilesContext(c *ContextCommon) *CommitFilesContext {
 	viewModel := filetree.NewCommitFileTreeViewModel(
 		func() []*models.CommitFile { return c.Model().CommitFiles },

pkg/gui/context/local_commits_context.go

@@ -31,11 +31,16 @@ type commitDropIndicator struct {
 }
 
 var (
-	_ types.IListContext       = (*LocalCommitsContext)(nil)
-	_ types.DiffableContext    = (*LocalCommitsContext)(nil)
-	_ types.ISearchableContext = (*LocalCommitsContext)(nil)
+	_ types.IListContext        = (*LocalCommitsContext)(nil)
+	_ types.DiffableContext     = (*LocalCommitsContext)(nil)
+	_ types.ISearchableContext  = (*LocalCommitsContext)(nil)
+	_ types.DiffMainViewContext = (*LocalCommitsContext)(nil)
 )
 
+func (self *LocalCommitsContext) GetDiffMainViewType() types.DiffMainViewType {
+	return types.DiffMainViewTypePatchBuilding
+}
+
 func NewLocalCommitsContext(c *ContextCommon) *LocalCommitsContext {
 	dropIndicator := &commitDropIndicator{insertionIndex: -1}
 	viewModel := NewLocalCommitsViewModel(

pkg/gui/context/main_context.go

@@ -8,9 +8,62 @@ import (
 type MainContext struct {
 	*SimpleContext
 	*SearchTrait
+
+	diffSelect types.DiffSelectState
+	// dragAnchorViewLine is the view line a mouse-down landed on, remembered so that a
+	// drag that follows can anchor its range there. The click may have selected a whole
+	// hunk, whose range anchor is the block's far end, so the clicked line can't be
+	// read back from the view.
+	dragAnchorViewLine int
+	// selectableContentRenderKey names the render whose content HasSelectableContent
+	// was worked out from. What there is to select is a property of the content, so an
+	// answer about the content of another render says nothing about this one.
+	selectableContentRenderKey string
 }
 
-var _ types.ISearchableContext = (*MainContext)(nil)
+var (
+	_ types.ISearchableContext = (*MainContext)(nil)
+	_ types.DiffPaneContext    = (*MainContext)(nil)
+)
+
+// DiffSelectState returns the focused main view's selection mode state, for the
+// controllers to read and mutate directly.
+func (self *MainContext) DiffSelectState() *types.DiffSelectState {
+	return &self.diffSelect
+}
+
+// ResetDiffSelectMode returns the pane's selection to the default mode — a single
+// line, no range — for whenever it is established from scratch rather than moved. The
+// view's range anchor is cleared too, so the next render highlights the cursor line
+// only.
+func (self *MainContext) ResetDiffSelectMode() {
+	self.diffSelect.Mode = types.DiffSelectModeLine
+	self.diffSelect.RangeIsSticky = false
+	self.diffSelect.UserEnabledHunkMode = false
+	self.GetView().CancelRangeSelect()
+}
+
+// SetDragAnchorViewLine records the view line a mouse-down landed on, so that a drag
+// that follows can anchor its range there (see dragAnchorViewLine).
+func (self *MainContext) SetDragAnchorViewLine(viewLine int) {
+	self.dragAnchorViewLine = viewLine
+}
+
+// DragAnchorViewLine returns the view line the last mouse-down landed on.
+func (self *MainContext) DragAnchorViewLine() int {
+	return self.dragAnchorViewLine
+}
+
+// SelectableContentRenderKey returns the render HasSelectableContent describes (see
+// selectableContentRenderKey).
+func (self *MainContext) SelectableContentRenderKey() string {
+	return self.selectableContentRenderKey
+}
+
+// SetSelectableContentRenderKey records which render HasSelectableContent describes.
+func (self *MainContext) SetSelectableContentRenderKey(key string) {
+	self.selectableContentRenderKey = key
+}
 
 func NewMainContext(
 	view *gocui.View,
@@ -21,12 +74,11 @@ func NewMainContext(
 	ctx := &MainContext{
 		SimpleContext: NewSimpleContext(
 			NewBaseContext(NewBaseContextOpts{
-				Kind:                 types.MAIN_CONTEXT,
-				View:                 view,
-				WindowName:           windowName,
-				Key:                  key,
-				Focusable:            true,
-				HasSelectableContent: false,
+				Kind:       types.MAIN_CONTEXT,
+				View:       view,
+				WindowName: windowName,
+				Key:        key,
+				Focusable:  true,
 			})),
 		SearchTrait: NewSearchTrait(c),
 	}
@@ -38,5 +90,8 @@ func (self *MainContext) ModelSearchResults(searchStr string, caseSensitive bool
 	return nil
 }
 
+// When selecting a search result, collapse a range selection (whether sticky or not)
+// or a hunk selection to just the matching line.
 func (self *MainContext) OnSearchSelect(int) {
+	self.ResetDiffSelectMode()
 }

pkg/gui/context/reflog_commits_context.go

@@ -14,10 +14,15 @@ type ReflogCommitsContext struct {
 }
 
 var (
-	_ types.IListContext    = (*ReflogCommitsContext)(nil)
-	_ types.DiffableContext = (*ReflogCommitsContext)(nil)
+	_ types.IListContext        = (*ReflogCommitsContext)(nil)
+	_ types.DiffableContext     = (*ReflogCommitsContext)(nil)
+	_ types.DiffMainViewContext = (*ReflogCommitsContext)(nil)
 )
 
+func (self *ReflogCommitsContext) GetDiffMainViewType() types.DiffMainViewType {
+	return types.DiffMainViewTypePatchBuilding
+}
+
 func NewReflogCommitsContext(c *ContextCommon) *ReflogCommitsContext {
 	viewModel := NewFilteredListViewModel(
 		func() []*models.Commit { return c.Model().FilteredReflogCommits },

pkg/gui/context/stash_context.go

@@ -12,10 +12,15 @@ type StashContext struct {
 }
 
 var (
-	_ types.IListContext    = (*StashContext)(nil)
-	_ types.DiffableContext = (*StashContext)(nil)
+	_ types.IListContext        = (*StashContext)(nil)
+	_ types.DiffableContext     = (*StashContext)(nil)
+	_ types.DiffMainViewContext = (*StashContext)(nil)
 )
 
+func (self *StashContext) GetDiffMainViewType() types.DiffMainViewType {
+	return types.DiffMainViewTypePatchBuilding
+}
+
 func NewStashContext(
 	c *ContextCommon,
 ) *StashContext {

pkg/gui/context/sub_commits_context.go

@@ -21,11 +21,16 @@ type SubCommitsContext struct {
 }
 
 var (
-	_ types.IListContext       = (*SubCommitsContext)(nil)
-	_ types.DiffableContext    = (*SubCommitsContext)(nil)
-	_ types.ISearchableContext = (*SubCommitsContext)(nil)
+	_ types.IListContext        = (*SubCommitsContext)(nil)
+	_ types.DiffableContext     = (*SubCommitsContext)(nil)
+	_ types.ISearchableContext  = (*SubCommitsContext)(nil)
+	_ types.DiffMainViewContext = (*SubCommitsContext)(nil)
 )
 
+func (self *SubCommitsContext) GetDiffMainViewType() types.DiffMainViewType {
+	return types.DiffMainViewTypePatchBuilding
+}
+
 func NewSubCommitsContext(
 	c *ContextCommon,
 ) *SubCommitsContext {

pkg/gui/context/working_tree_context.go

@@ -15,10 +15,15 @@ type WorkingTreeContext struct {
 }
 
 var (
-	_ types.IListContext       = (*WorkingTreeContext)(nil)
-	_ types.IFilterableContext = (*WorkingTreeContext)(nil)
+	_ types.IListContext        = (*WorkingTreeContext)(nil)
+	_ types.IFilterableContext  = (*WorkingTreeContext)(nil)
+	_ types.DiffMainViewContext = (*WorkingTreeContext)(nil)
 )
 
+func (self *WorkingTreeContext) GetDiffMainViewType() types.DiffMainViewType {
+	return types.DiffMainViewTypeStaging
+}
+
 func NewWorkingTreeContext(c *ContextCommon) *WorkingTreeContext {
 	viewModel := filetree.NewFileTreeViewModel(
 		func() []*models.File { return c.Model().Files },

pkg/gui/controllers.go

@@ -67,8 +67,8 @@ func (gui *Gui) resetHelpersAndControllers() {
 		worktreeHelper,
 		searchHelper,
 	)
-	diffHelper := helpers.NewDiffHelper(helperCommon)
 	diffLineHelper := helpers.NewDiffLineHelper(helperCommon)
+	diffHelper := helpers.NewDiffHelper(helperCommon, diffLineHelper)
 	cherryPickHelper := helpers.NewCherryPickHelper(
 		helperCommon,
 		rebaseHelper,
@@ -178,7 +178,6 @@ func (gui *Gui) resetHelpersAndControllers() {
 	contextLinesController := controllers.NewContextLinesController(common)
 	renameSimilarityThresholdController := controllers.NewRenameSimilarityThresholdController(common)
 	verticalScrollControllerFactory := controllers.NewVerticalScrollControllerFactory(common)
-	viewSelectionControllerFactory := controllers.NewViewSelectionControllerFactory(common)
 
 	branchesController := controllers.NewBranchesController(common)
 	gitFlowController := controllers.NewGitFlowController(common)
@@ -315,13 +314,11 @@ func (gui *Gui) resetHelpersAndControllers() {
 	controllers.AttachControllers(gui.State.Contexts.Normal,
 		mainViewController,
 		verticalScrollControllerFactory.Create(gui.State.Contexts.Normal),
-		viewSelectionControllerFactory.Create(gui.State.Contexts.Normal),
 	)
 
 	controllers.AttachControllers(gui.State.Contexts.NormalSecondary,
 		secondaryViewController,
 		verticalScrollControllerFactory.Create(gui.State.Contexts.NormalSecondary),
-		viewSelectionControllerFactory.Create(gui.State.Contexts.NormalSecondary),
 	)
 
 	controllers.AttachControllers(gui.State.Contexts.Files,

pkg/gui/controllers/attach.go

@@ -8,7 +8,6 @@ func AttachControllers(context types.Context, controllers ...types.IController)
 		context.AddMouseKeybindingsFn(controller.GetMouseKeybindings)
 		context.AddOnDoubleClickFn(controller.GetOnDoubleClick())
 		context.AddOnClickFn(controller.GetOnClick())
-		context.AddOnClickFocusedMainViewFn(controller.GetOnClickFocusedMainView())
 		context.AddOnRenderToMainFn(controller.GetOnRenderToMain())
 		context.AddOnFocusFn(controller.GetOnFocus())
 		context.AddOnFocusLostFn(controller.GetOnFocusLost())

pkg/gui/controllers/base_controller.go

@@ -19,10 +19,6 @@ func (self *baseController) GetOnDoubleClick() func() error {
 	return nil
 }
 
-func (self *baseController) GetOnClickFocusedMainView() func(mainViewName string, clickedLineIdx int) error {
-	return nil
-}
-
 func (self *baseController) GetOnClick() func(opts gocui.ViewMouseBindingOpts) error {
 	return nil
 }

pkg/gui/controllers/commits_files_controller.go

@@ -606,16 +606,6 @@ func (self *CommitFilesController) expandAll() error {
 	return nil
 }
 
-func (self *CommitFilesController) GetOnClickFocusedMainView() func(mainViewName string, clickedLineIdx int) error {
-	return func(mainViewName string, clickedLineIdx int) error {
-		node := self.getSelectedItem()
-		if node != nil && node.File != nil {
-			return self.enterCommitFile(node, types.OnFocusOpts{ClickedWindowName: mainViewName, ClickedViewLineIdx: clickedLineIdx})
-		}
-		return nil
-	}
-}
-
 func (self *CommitFilesController) pathsForDiff(node *filetree.CommitFileNode) []string {
 	return diffPathsForNode(
 		node.Raw(), self.context().GetRoot().Raw(), self.c.Model().CommitFiles, self.context().IsFiltering())

pkg/gui/controllers/context_lines_controller.go

@@ -83,6 +83,11 @@ func (self *ContextLinesController) applyChange() error {
 	case context.STAGING_MAIN_CONTEXT_KEY, context.STAGING_SECONDARY_CONTEXT_KEY:
 		self.c.Refresh(types.RefreshOptions{Scope: []types.RefreshableView{types.STAGING}})
 	default:
+		// The diff is about to be rendered again with more or less context around
+		// each change, which reads as the lines you were looking at moving up or down
+		// the view; keep them where they are instead.
+		self.c.Helpers().DiffLine.PreserveDiffPositionOnRerender(self.c.Contexts().Normal.GetView())
+		self.c.Helpers().DiffLine.PreserveDiffPositionOnRerender(self.c.Contexts().NormalSecondary.GetView())
 		currentContext.HandleRenderToMain()
 	}
 	return nil

pkg/gui/controllers/files_controller.go

@@ -408,16 +408,6 @@ func (self *FilesController) GetOnDoubleClick() func() error {
 	})
 }
 
-func (self *FilesController) GetOnClickFocusedMainView() func(mainViewName string, clickedLineIdx int) error {
-	return func(mainViewName string, clickedLineIdx int) error {
-		node := self.getSelectedItem()
-		if node != nil && node.File != nil {
-			return self.EnterFile(types.OnFocusOpts{ClickedWindowName: mainViewName, ClickedViewLineIdx: clickedLineIdx})
-		}
-		return nil
-	}
-}
-
 // if we are dealing with a status for which there is no key in this map,
 // then we won't optimistically render: we'll just let `git status` tell
 // us what the new status is.

pkg/gui/controllers/helpers/diff_helper.go

@@ -14,12 +14,14 @@ import (
 )
 
 type DiffHelper struct {
-	c *HelperCommon
+	c              *HelperCommon
+	diffLineHelper *DiffLineHelper
 }
 
-func NewDiffHelper(c *HelperCommon) *DiffHelper {
+func NewDiffHelper(c *HelperCommon, diffLineHelper *DiffLineHelper) *DiffHelper {
 	return &DiffHelper{
-		c: c,
+		c:              c,
+		diffLineHelper: diffLineHelper,
 	}
 }
 
@@ -107,6 +109,11 @@ func (self *DiffHelper) RenderToMainAgain() {
 	if currentSide.GetKey() == currentKey ||
 		currentKey == context.NORMAL_MAIN_CONTEXT_KEY ||
 		currentKey == context.NORMAL_SECONDARY_CONTEXT_KEY {
+		// Whatever changed can make the diff come out differently, such as a new
+		// renderer laying it out its own way, so the line you were looking at could
+		// end up anywhere in the view; keep it in front of you.
+		self.diffLineHelper.PreserveDiffPositionOnRerender(self.c.Contexts().Normal.GetView())
+		self.diffLineHelper.PreserveDiffPositionOnRerender(self.c.Contexts().NormalSecondary.GetView())
 		currentSide.HandleRenderToMain()
 	}
 }

pkg/gui/controllers/helpers/diff_line_helper.go

@@ -32,45 +32,123 @@ func NewDiffLineHelper(c *HelperCommon) *DiffLineHelper {
 // ok is false when the row's identity can't be recovered, in which case the
 // caller must not act on the line at all.
 func (self *DiffLineHelper) GetDiffLineInfo(view *gocui.View, viewLineIdx int) (types.DiffLineInfo, bool) {
+	identities, ok := self.diffLineIdentitiesAt(view, viewLineIdx)
+	if !ok {
+		return types.DiffLineInfo{}, false
+	}
+	return identities[0], true
+}
+
+// diffLineIdentitiesAt recovers every diff line the row at the given (wrapped) view
+// line shows, left to right. It is GetDiffLineInfo's form for a reader that can't
+// settle for the line the row leads with: an end of a selection covers its whole
+// row, so where a rendering puts a modification's two halves side by side it covers
+// both of them. ok is false when the row's identity can't be recovered at all.
+func (self *DiffLineHelper) diffLineIdentitiesAt(
+	view *gocui.View, viewLineIdx int,
+) ([]types.DiffLineInfo, bool) {
 	// The cursor and clicks land on a view line, which counts wrapped segments;
 	// the contents are indexed by unwrapped buffer line.
 	bufferLineIdx, ok := view.BufferLineForViewLine(viewLineIdx)
 	if !ok {
-		return types.DiffLineInfo{}, false
+		return nil, false
 	}
 
 	contents := view.DiffLineContents()
 	if bufferLineIdx >= len(contents) {
-		return types.DiffLineInfo{}, false
+		return nil, false
 	}
 
 	if renderingStatesDiffLines(contents) {
-		// A row can carry more than one record, when the rendering puts two diff
-		// lines on it; the first one is the row's identity, and the leftmost record
-		// is the one a reader would call the row's own.
-		if metadata := contents[bufferLineIdx].Metadata; len(metadata) > 0 {
-			if parsed, ok := parseDiffLineMetadata(metadata[0]); ok {
-				return self.diffLineInfo(parsed), true
-			}
+		if identities := self.diffLineIdentitiesFromRecords(contents[bufferLineIdx].Metadata); len(identities) > 0 {
+			return identities, true
 		}
-		return types.DiffLineInfo{}, false
+		return nil, false
 	}
 
 	parsed, ok := parseDiffLineFromBuffer(diffLineTexts(contents), bufferLineIdx)
 	if !ok {
-		return types.DiffLineInfo{}, false
+		return nil, false
 	}
 
-	return self.diffLineInfo(parsed), true
+	return []types.DiffLineInfo{self.diffLineInfo(parsed)}, true
+}
+
+// diffLineIdentitiesFromRecords recovers the identity of every diff line the row's
+// records state, left to right. A row can carry more than one record, when the
+// rendering puts two diff lines on it (a side-by-side row shows a deletion and the
+// addition replacing it). Which of them a reader is after depends on the reader: the
+// one the row leads with is the row's own identity (see GetDiffLineInfo and
+// resolveDiffLines), while a reader looking for a particular line has to consider
+// them all, since which of a modification's two halves leads a row is up to the
+// rendering.
+func (self *DiffLineHelper) diffLineIdentitiesFromRecords(metadata []string) []types.DiffLineInfo {
+	return self.diffLineInfos(parseDiffLineRecords(metadata))
+}
+
+// resolvedDiffLine is one rendered row's recovered identity, plus whether it could
+// be recovered at all — the element of the table resolveDiffLines produces.
+type resolvedDiffLine struct {
+	info types.DiffLineInfo
+	ok   bool
+}
+
+// resolveDiffLines recovers the identity of every row of a rendered diff in one
+// pass, indexed 1:1 with contents. It is the batch form of GetDiffLineInfo, for the
+// whole-buffer scans (which change lines are where, which file each row belongs
+// to). A row's identity is the line it leads with, of those resolveDiffLineIdentities
+// finds on it.
+func (self *DiffLineHelper) resolveDiffLines(contents []gocui.DiffLineContent) []resolvedDiffLine {
+	resolved := make([]resolvedDiffLine, len(contents))
+	for i, identities := range self.resolveDiffLineIdentities(contents) {
+		if len(identities) > 0 {
+			resolved[i] = resolvedDiffLine{identities[0], true}
+		}
+	}
+	return resolved
+}
+
+// resolveDiffLineIdentities recovers every diff line each row of a rendered diff
+// shows, in one pass, indexed 1:1 with contents. It reads the rendering the way
+// GetDiffLineInfo does, by the renderer's records or by parsing it as a unified diff
+// (see parseDiffLineIdentities), and is the form of the batch resolver for the
+// readers that can't settle for the line a row leads with: looking for a remembered
+// line in a new rendering has to consider both halves of a modification, since a
+// side-by-side row leads with the deletion whose addition was what got remembered
+// under a unified one.
+func (self *DiffLineHelper) resolveDiffLineIdentities(contents []gocui.DiffLineContent) [][]types.DiffLineInfo {
+	identities := make([][]types.DiffLineInfo, len(contents))
+	for i, parsed := range parseDiffLineIdentities(contents) {
+		if len(parsed) > 0 {
+			identities[i] = self.diffLineInfos(parsed)
+		}
+	}
+	return identities
 }
 
 // diffLineInfo turns a parser's result into the absolute-path identity consumers
 // work with. The path arrives repo-relative from the diff header, but a renderer
 // states it however it likes, absolute paths included.
 func (self *DiffLineHelper) diffLineInfo(parsed parsedDiffLine) types.DiffLineInfo {
+	return diffLineInfoIn(self.c.Git().RepoPaths.WorktreePath(), parsed)
+}
+
+// diffLineInfos is diffLineInfo over every line of a row.
+func (self *DiffLineHelper) diffLineInfos(parsed []parsedDiffLine) []types.DiffLineInfo {
+	infos := make([]types.DiffLineInfo, len(parsed))
+	for i, line := range parsed {
+		infos[i] = self.diffLineInfo(line)
+	}
+	return infos
+}
+
+// diffLineInfoIn is diffLineInfo against a given worktree, for the callers that can't
+// ask which repo we are in where they run: a repo switch replaces it, so only the UI
+// thread may read it.
+func diffLineInfoIn(worktreePath string, parsed parsedDiffLine) types.DiffLineInfo {
 	path := parsed.Path
 	if !filepath.IsAbs(path) {
-		path = filepath.Join(self.c.Git().RepoPaths.WorktreePath(), path)
+		path = filepath.Join(worktreePath, path)
 	}
 
 	return types.DiffLineInfo{

pkg/gui/controllers/helpers/diff_line_parser.go

@@ -125,6 +125,46 @@ func renderingStatesDiffLines(contents []gocui.DiffLineContent) bool {
 	})
 }
 
+// parseDiffLineRecords parses the records a row carries, left to right, leaving out
+// the ones we don't understand. A row carries more than one when the rendering puts
+// two diff lines on it, as a side-by-side row does with a deletion and the addition
+// replacing it.
+func parseDiffLineRecords(metadata []string) []parsedDiffLine {
+	parsed := make([]parsedDiffLine, 0, len(metadata))
+	for _, record := range metadata {
+		if line, ok := parseDiffLineMetadata(record); ok {
+			parsed = append(parsed, line)
+		}
+	}
+	return parsed
+}
+
+// parseDiffLineIdentities recovers, for every row of a rendering, the diff lines it
+// shows, indexed 1:1 with contents; a row that shows none we can place gets an empty
+// entry. The rendering is read the way renderingStatesDiffLines settles: by the
+// renderer's records, every one a row carries, or else by parsing the rendering as a
+// unified diff, where each row shows one line. Each file's section is parsed once;
+// resolving row by row would re-run that parse once per row, O(n²) on a large
+// single-file diff.
+func parseDiffLineIdentities(contents []gocui.DiffLineContent) [][]parsedDiffLine {
+	identities := make([][]parsedDiffLine, len(contents))
+	if renderingStatesDiffLines(contents) {
+		for i, content := range contents {
+			if parsed := parseDiffLineRecords(content.Metadata); len(parsed) > 0 {
+				identities[i] = parsed
+			}
+		}
+		return identities
+	}
+
+	for i, parsed := range parseAllDiffLinesFromBuffer(diffLineTexts(contents)) {
+		if parsed.ok {
+			identities[i] = []parsedDiffLine{parsed.parsed}
+		}
+	}
+	return identities
+}
+
 // fileSectionBounds returns the half-open range [start, end) of the file section
 // containing targetIdx: the nearest line starting a section at or above it, up to
 // where that section ends. start is -1 when targetIdx is above the first file

pkg/gui/controllers/helpers/diff_line_parser_test.go

@@ -420,3 +420,61 @@ func TestRenderingStatesDiffLines(t *testing.T) {
 		})
 	}
 }
+
+func TestParseDiffLineIdentities(t *testing.T) {
+	row := func(text string, records ...string) gocui.DiffLineContent {
+		return gocui.DiffLineContent{Text: text, Metadata: records}
+	}
+
+	t.Run("a rendering with records is read by them alone", func(t *testing.T) {
+		// A renderer's picture of a commit that adds a test whose input is a diff. The
+		// test's "diff --git" line is an added line of the test's file and is shown on
+		// a row of its own, and the rows the renderer puts between hunks carry no
+		// record. Parsed as a diff, that row would open a section of a file the diff
+		// doesn't have and claim every untagged row below it.
+		contents := []gocui.DiffLineContent{
+			row("src/parser.rs", "1;f;;;src/parser.rs"),
+			row(`let input = "\`, "1;c;10;;src/parser.rs"),
+			row("diff --git a/img.png b/img.png", "1;a;11;;src/parser.rs"),
+			row("Binary files a/img.png and b/img.png differ", "1;a;12;;src/parser.rs"),
+			row(""),
+			row("fn later() {}", "1;c;40;;src/parser.rs"),
+		}
+
+		assert.Equal(t, [][]parsedDiffLine{
+			{{Path: "src/parser.rs", Type: types.DiffLineFileHeader}},
+			{{Path: "src/parser.rs", Type: types.DiffLineContext, NewLine: 10}},
+			{{Path: "src/parser.rs", Type: types.DiffLineAdded, NewLine: 11}},
+			{{Path: "src/parser.rs", Type: types.DiffLineAdded, NewLine: 12}},
+			nil,
+			{{Path: "src/parser.rs", Type: types.DiffLineContext, NewLine: 40}},
+		}, parseDiffLineIdentities(contents))
+	})
+
+	t.Run("a row with two records shows both of their lines", func(t *testing.T) {
+		contents := []gocui.DiffLineContent{
+			row("two │ TWO", "1;d;2;2;file1", "1;a;2;;file1"),
+		}
+
+		assert.Equal(t, [][]parsedDiffLine{
+			{
+				{Path: "file1", Type: types.DiffLineDeleted, NewLine: 2, OldLine: 2},
+				{Path: "file1", Type: types.DiffLineAdded, NewLine: 2},
+			},
+		}, parseDiffLineIdentities(contents))
+	})
+
+	t.Run("a rendering without records is parsed as a diff", func(t *testing.T) {
+		bufferLines := strings.Split(twoFileDiff, "\n")
+		contents := make([]gocui.DiffLineContent, len(bufferLines))
+		for i, line := range bufferLines {
+			contents[i] = row(line)
+		}
+
+		identities := parseDiffLineIdentities(contents)
+		for i, parsed := range parseAllDiffLinesFromBuffer(bufferLines) {
+			assert.True(t, parsed.ok, "line %d", i)
+			assert.Equal(t, []parsedDiffLine{parsed.parsed}, identities[i], "line %d", i)
+		}
+	})
+}

pkg/gui/controllers/helpers/diff_line_queries.go

@@ -0,0 +1,359 @@
+package helpers
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/gocui"
+	"github.com/jesseduffield/lazygit/pkg/gui/types"
+	"github.com/samber/lo"
+)
+
+// The questions a diff view can be asked about what it is showing — where the change
+// lines are, which block or file a row belongs to — answered in the view-line terms a
+// cursor and a click speak. They are all built on the identities recovered in
+// diff_line_helper.go, which is where the answering stops and the recovering starts.
+
+// changeLines resolves view's rendered diff to one flag per buffer line: whether
+// that row is a change line (an addition or a deletion), as opposed to context, a
+// header, or a row whose identity couldn't be recovered. Those are the rows a
+// selection is anchored on and navigation moves between.
+func (self *DiffLineHelper) changeLines(view *gocui.View) []bool {
+	resolved := self.resolveDiffLines(view.DiffLineContents())
+	isChange := make([]bool, len(resolved))
+	for i, r := range resolved {
+		isChange[i] = r.ok && r.info.IsChange()
+	}
+	return isChange
+}
+
+// FirstChangeLineInView returns the view line of the first change line on screen. It
+// is where the selection goes when the main view is focused by keyboard: focusing a
+// diff you are reading points at something in it without moving it, so the search
+// stops at the bottom of the viewport rather than going after a change further down.
+// ok is false when the viewport holds no change line — scrolled into a long stretch
+// of context, or past the last change.
+func (self *DiffLineHelper) FirstChangeLineInView(view *gocui.View) (int, bool) {
+	top, bottom, ok := visibleBufferLines(view)
+	if !ok {
+		return 0, false
+	}
+
+	isChange := self.changeLines(view)
+	for i := top; i <= min(bottom, len(isChange)-1); i++ {
+		if isChange[i] {
+			return view.ViewLineForBufferLine(i)
+		}
+	}
+	return 0, false
+}
+
+// FirstChangeBlockInView returns the view line of the first change block on screen:
+// the first one that *begins* in the viewport, and failing that the one that reaches
+// into the viewport from above, whose start is off screen. Hunk mode wants that order
+// for the block it offers up on focus: preferably a block whose beginning the user can
+// see, rather than the tail of one they have scrolled past the start of. The block
+// bleeding in from above is kept as the answer for a change too long to fit on screen,
+// where there is no other. ok is false when the viewport shows no change line.
+func (self *DiffLineHelper) FirstChangeBlockInView(view *gocui.View) (int, bool) {
+	top, bottom, ok := visibleBufferLines(view)
+	if !ok {
+		return 0, false
+	}
+
+	isChange := self.changeLines(view)
+	for i := top; i <= min(bottom, len(isChange)-1); i++ {
+		if isChange[i] && (i == 0 || !isChange[i-1]) {
+			return view.ViewLineForBufferLine(i)
+		}
+	}
+	// A block covering the top line is one that began above it: nothing else can put a
+	// change there once no block starts on screen.
+	if top < len(isChange) && isChange[top] {
+		return view.ViewLineForBufferLine(top)
+	}
+	return 0, false
+}
+
+// visibleBufferLines returns the first and last line of view's content that the
+// viewport shows any part of, for the queries that only care about what the user can
+// see. The last line is the one at the bottom edge, or the content's last when the
+// content ends above it. ok is false for a view showing no content at all.
+func visibleBufferLines(view *gocui.View) (int, int, bool) {
+	top, ok := view.BufferLineForViewLine(view.OriginY())
+	if !ok {
+		return 0, 0, false
+	}
+
+	lastVisible := min(view.OriginY()+view.InnerHeight(), view.ViewLinesHeight()) - 1
+	bottom, ok := view.BufferLineForViewLine(lastVisible)
+	if !ok {
+		return top, top, true
+	}
+	return top, bottom, true
+}
+
+// ViewHasChangeLines reports whether view's rendered diff holds any change line at
+// all, i.e. whether there is anything to select. It is false over a non-diff
+// placeholder, and over a diff with nothing in it — an empty commit, a binary file —
+// which are the cases where the focused main view shows no selection.
+func (self *DiffLineHelper) ViewHasChangeLines(view *gocui.View) bool {
+	return lo.Contains(self.changeLines(view), true)
+}
+
+// IsChangeLine reports whether the given view line of view's rendered diff is a
+// change line rather than context, a header, or an unresolvable row — i.e. whether
+// pointing at it points at something a patch could be built from.
+func (self *DiffLineHelper) IsChangeLine(view *gocui.View, viewLineIdx int) bool {
+	info, ok := self.GetDiffLineInfo(view, viewLineIdx)
+	return ok && info.IsChange()
+}
+
+// IsSingleHunkForWholeFile reports whether the file the given change line belongs to
+// is shown as one solid block of changes — every row of its diff a change of the same
+// kind, no context — which is what a newly added or deleted file looks like. That is
+// the case where widening the selection to the change block would select the file
+// entire, so hunk mode drops to a single line there instead. It asks of a rendered
+// diff the question patch.Patch.IsSingleHunkForWholeFile asks of a patch.
+//
+// It says false while the diff is still being read in, since the rows that would
+// answer otherwise — a context line, a change of the other kind — may not have
+// arrived yet. That errs towards hunk mode, which is what the user asked for.
+func (self *DiffLineHelper) IsSingleHunkForWholeFile(view *gocui.View, changeViewLine int) bool {
+	if manager := self.c.GetViewBufferManagerForView(view); manager != nil && manager.IsLoading() {
+		return false
+	}
+
+	anchor, ok := view.BufferLineForViewLine(changeViewLine)
+	if !ok {
+		return false
+	}
+	resolved := self.resolveDiffLines(view.DiffLineContents())
+	if anchor >= len(resolved) || !resolved[anchor].ok {
+		return false
+	}
+
+	// The question is per file: a commit's diff may hold a newly added file next to an
+	// edited one.
+	path := resolved[anchor].info.Path
+	kind := resolved[anchor].info.Type
+	for _, row := range resolved {
+		if !row.ok || row.info.Path != path {
+			continue
+		}
+		if row.info.Type == types.DiffLineContext {
+			return false
+		}
+		if row.info.IsChange() && row.info.Type != kind {
+			return false
+		}
+	}
+	return true
+}
+
+// ChangeBlockBounds returns the inclusive view-line range of the change block to
+// select in hunk mode around anchorViewLine. A change block is lazygit's notion of a
+// hunk — a run of consecutive added or deleted lines bounded by context, of which a
+// single git @@ hunk may hold several. When the anchor is context, the block used is
+// the first at or below it, or — with nothing below, the cursor sitting past the last
+// change — the nearest above, so that hunk mode always has a block to select. ok is
+// false only when the diff holds no change line at all.
+func (self *DiffLineHelper) ChangeBlockBounds(view *gocui.View, anchorViewLine int) (int, int, bool) {
+	anchor, ok := view.BufferLineForViewLine(anchorViewLine)
+	if !ok {
+		return 0, 0, false
+	}
+
+	isChange := self.changeLines(view)
+	start := anchor
+	for start < len(isChange) && !isChange[start] {
+		start++
+	}
+	if start >= len(isChange) {
+		for start = min(anchor, len(isChange)-1); start >= 0 && !isChange[start]; start-- {
+		}
+		if start < 0 {
+			return 0, 0, false
+		}
+	}
+	end := start
+	for start > 0 && isChange[start-1] {
+		start--
+	}
+	for end < len(isChange)-1 && isChange[end+1] {
+		end++
+	}
+
+	startView, startOk := view.ViewLineForBufferLine(start)
+	// The block's last line goes to its last view line, so that a line the view
+	// wrapped is highlighted to its end rather than only where it begins.
+	endView, endOk := view.LastViewLineForBufferLine(end)
+	if !startOk || !endOk {
+		return 0, 0, false
+	}
+	return startView, endView, true
+}
+
+// SelectedHunkBounds returns the change block selected in hunk mode. The range
+// anchor stays on the block's far end when a click moves the cursor before its
+// handler runs, so it still identifies the selected block.
+func (self *DiffLineHelper) SelectedHunkBounds(view *gocui.View) (int, int, bool) {
+	anchor := view.RangeSelectStartY()
+	if anchor < 0 {
+		return 0, 0, false
+	}
+	return self.ChangeBlockBounds(view, anchor)
+}
+
+// AdjacentChangeBlock returns the view line to move to for next/previous change-block
+// navigation in view's rendered diff, starting from anchorViewLine. A change block is
+// lazygit's notion of a hunk (see ChangeBlockBounds). forward=true targets the start
+// of the next block, forward=false the start of the previous one — from mid-block that
+// means the previous block, rather than the one we are in. ok is false when there's no
+// further block, so the caller leaves the view where it is.
+func (self *DiffLineHelper) AdjacentChangeBlock(view *gocui.View, anchorViewLine int, forward bool) (int, bool) {
+	anchor, ok := view.BufferLineForViewLine(anchorViewLine)
+	if !ok {
+		return 0, false
+	}
+
+	target, ok := changeBlockStart(self.changeLines(view), anchor, forward)
+	if !ok {
+		return 0, false
+	}
+	return view.ViewLineForBufferLine(target)
+}
+
+// AdjacentFile returns the view line to move to for next/previous file navigation in
+// view's (possibly multi-file) rendered diff, starting from anchorViewLine: the first
+// located row of the neighbouring file, found where the rows' file changes. ok is
+// false at the first or last file.
+func (self *DiffLineHelper) AdjacentFile(view *gocui.View, anchorViewLine int, forward bool) (int, bool) {
+	anchor, ok := view.BufferLineForViewLine(anchorViewLine)
+	if !ok {
+		return 0, false
+	}
+
+	target, ok := fileStart(self.filePaths(view), anchor, forward)
+	if !ok {
+		return 0, false
+	}
+	return view.ViewLineForBufferLine(target)
+}
+
+// filePaths resolves view's rendered diff to the path each buffer line belongs to,
+// empty for a row whose identity couldn't be recovered.
+func (self *DiffLineHelper) filePaths(view *gocui.View) []string {
+	resolved := self.resolveDiffLines(view.DiffLineContents())
+	paths := make([]string, len(resolved))
+	for i, row := range resolved {
+		if row.ok {
+			paths[i] = row.info.Path
+		}
+	}
+	return paths
+}
+
+// fileStart finds, in a diff whose lines carry the file path they belong to (empty for
+// a row no backend could place), the first located row of the file adjacent to `from`
+// in the given direction — the row file navigation lands on. It is the pure index
+// arithmetic behind AdjacentFile.
+//
+// A file is identified by its path, so we look for where the path changes, skipping
+// rows that carry none: those are the blank separator rows between files, or the
+// header rows of a diff renderer that doesn't state which file its headers belong to.
+// So the landing row is the file's header wherever the source says so — a parseable
+// buffer, or a renderer that tags its headers — and the file's first content line
+// otherwise, which is an accepted degradation.
+func fileStart(paths []string, from int, forward bool) (int, bool) {
+	anchorPath, ok := anchorFilePath(paths, from)
+	if !ok {
+		return 0, false
+	}
+
+	if forward {
+		for i := from; i < len(paths); i++ {
+			if paths[i] != "" && paths[i] != anchorPath {
+				return i, true
+			}
+		}
+		return 0, false
+	}
+
+	// Walk back past the current file (its rows and any unlocated ones) to the previous
+	// file's last located row, then back over that whole file, landing on its first.
+	i := from
+	for i >= 0 && (paths[i] == "" || paths[i] == anchorPath) {
+		i--
+	}
+	if i < 0 {
+		return 0, false
+	}
+	prevPath := paths[i]
+	for i > 0 && (paths[i-1] == "" || paths[i-1] == prevPath) {
+		i--
+	}
+	for paths[i] != prevPath {
+		i++
+	}
+	return i, true
+}
+
+// anchorFilePath returns the path of the file the anchor sits in: the first row at or
+// below it that carries a path — the file whose content is at or below the top of the
+// view — falling back to the nearest above when there is nothing below. Scanning down
+// first matters because the anchor is often a file-header row that carries no path of
+// its own, whose nearest tagged row above is the *previous* file's content; taking
+// that would make next-file navigation jump back into the file just left, so a second
+// press wouldn't advance. ok is false when no row carries a path.
+func anchorFilePath(paths []string, from int) (string, bool) {
+	if from < 0 {
+		return "", false
+	}
+	for i := from; i < len(paths); i++ {
+		if paths[i] != "" {
+			return paths[i], true
+		}
+	}
+	for i := min(from, len(paths)) - 1; i >= 0; i-- {
+		if paths[i] != "" {
+			return paths[i], true
+		}
+	}
+	return "", false
+}
+
+// changeBlockStart finds, in a diff whose lines are flagged by isChange, the first
+// line of the change block adjacent to `from` in the given direction. It is the pure
+// index arithmetic behind AdjacentChangeBlock.
+func changeBlockStart(isChange []bool, from int, forward bool) (int, bool) {
+	if from < 0 || from >= len(isChange) {
+		return 0, false
+	}
+
+	if forward {
+		i := from
+		for i < len(isChange) && isChange[i] { // leave the current block
+			i++
+		}
+		for i < len(isChange) && !isChange[i] { // skip the separating context
+			i++
+		}
+		if i == len(isChange) {
+			return 0, false
+		}
+		return i, true
+	}
+
+	i := from
+	for i >= 0 && isChange[i] { // leave the current block
+		i--
+	}
+	for i >= 0 && !isChange[i] { // skip context, landing on the previous block's last line
+		i--
+	}
+	if i < 0 {
+		return 0, false
+	}
+	for i > 0 && isChange[i-1] { // walk back to that block's first line
+		i--
+	}
+	return i, true
+}

pkg/gui/controllers/helpers/diff_line_queries_test.go

@@ -0,0 +1,104 @@
+package helpers
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestChangeBlockStart(t *testing.T) {
+	// A diff with three change blocks separated by context:
+	//   0 file header   1 hunk header   2 context
+	//   3 +   4 +                         (block A)
+	//   5 context
+	//   6 -                               (block B)
+	//   7 context
+	//   8 +                               (block C)
+	isChange := []bool{false, false, false, true, true, false, true, false, true}
+
+	scenarios := []struct {
+		name     string
+		from     int
+		forward  bool
+		expected int
+		found    bool
+	}{
+		{"forward from a header lands on the first block", 0, true, 3, true},
+		{"forward from separating context lands on the next block", 5, true, 6, true},
+		{"forward from the start of a block skips to the next", 3, true, 6, true},
+		{"forward from inside a block skips the rest of it", 4, true, 6, true},
+		{"forward from the last block finds nothing", 8, true, 0, false},
+		{"backward from a later block lands on the previous one's start", 8, false, 6, true},
+		{"backward from a block start lands on the previous block's start", 6, false, 3, true},
+		{"backward from inside the first block finds nothing", 4, false, 0, false},
+		{"backward from the first block's start finds nothing", 3, false, 0, false},
+		{"backward from context lands on the preceding block's start", 7, false, 6, true},
+		{"an anchor past the end finds nothing", 9, true, 0, false},
+		{"a negative anchor finds nothing", -1, true, 0, false},
+	}
+
+	for _, s := range scenarios {
+		t.Run(s.name, func(t *testing.T) {
+			got, found := changeBlockStart(isChange, s.from, s.forward)
+			assert.Equal(t, s.found, found)
+			if s.found {
+				assert.Equal(t, s.expected, got)
+			}
+		})
+	}
+}
+
+func TestFileStart(t *testing.T) {
+	// A parseable two-file diff: every row carries its file's path, headers included,
+	// as the buffer parser reports it.
+	parseable := []string{"a", "a", "a", "a", "b", "b", "b", "b"}
+
+	// The same diff as a renderer that doesn't say which file its headers belong to
+	// emits it: only content lines carry the path, so navigation can land no higher
+	// than each file's first content line.
+	contentOnly := []string{"", "", "a", "a", "", "", "b", "b"}
+
+	// Three such files, to exercise navigating from one file's untagged header to the
+	// next: the row just above b's header is a's content, so the anchor's file has to
+	// be found by scanning down (b) rather than up (a) — otherwise next-file would
+	// jump back into b and a second press couldn't advance.
+	contentOnlyThree := []string{"", "", "a", "a", "", "", "b", "b", "", "", "c", "c"}
+
+	// A renderer that does tag its header rows: the file header and the hunk-header box
+	// carry the file's path, but the blank separator rows around them carry nothing.
+	// Navigation must land on the header's first row, not the blank line above it.
+	//    0 blank   1-2 file hdr   3 blank   4-6 hunk hdr box   7 content
+	//    8 blank   9-10 file hdr  11 blank  12-13 hunk hdr box  14 content
+	headerTagged := []string{"", "a", "a", "", "a", "a", "a", "a", "", "b", "b", "", "b", "b", "b"}
+
+	scenarios := []struct {
+		name     string
+		paths    []string
+		from     int
+		forward  bool
+		expected int
+		found    bool
+	}{
+		{"forward lands on the next file's header", parseable, 1, true, 4, true},
+		{"forward from the last file finds nothing", parseable, 5, true, 0, false},
+		{"backward lands on the previous file's header", parseable, 5, false, 0, true},
+		{"backward from the first file finds nothing", parseable, 1, false, 0, false},
+		{"forward lands on the next file's first content line", contentOnly, 2, true, 6, true},
+		{"backward lands on the previous file's first content line", contentOnly, 7, false, 2, true},
+		{"forward from an untagged header advances past it", contentOnly, 0, true, 6, true},
+		{"a second forward press advances again", contentOnlyThree, 4, true, 10, true},
+		{"forward lands on a tagged file header", headerTagged, 7, true, 9, true},
+		{"backward lands on a tagged file header", headerTagged, 14, false, 1, true},
+		{"a diff with no located rows finds nothing", []string{"", ""}, 0, true, 0, false},
+	}
+
+	for _, s := range scenarios {
+		t.Run(s.name, func(t *testing.T) {
+			got, found := fileStart(s.paths, s.from, s.forward)
+			assert.Equal(t, s.found, found)
+			if s.found {
+				assert.Equal(t, s.expected, got)
+			}
+		})
+	}
+}

pkg/gui/controllers/helpers/diff_line_restore.go

@@ -0,0 +1,426 @@
+package helpers
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/gocui"
+	"github.com/jesseduffield/lazygit/pkg/gui/types"
+	"github.com/jesseduffield/lazygit/pkg/tasks"
+	"github.com/samber/lo"
+)
+
+// Keeping a diff view where it is when the same diff is rendered again differently.
+// The line the user is on is remembered by identity (diff_line_helper.go), because a
+// new rendering puts it on a different line of the view — and may not have it at all,
+// which is what the fallbacks below are for.
+
+// diffLineAnchor is a line for a restore to land on: the identity to find it by in
+// the new rendering, and the screen row it was on, so that it can be put back there.
+type diffLineAnchor struct {
+	identity types.DiffLineInfo
+	row      int
+}
+
+// PreserveDiffPositionOnRerender remembers where a diff view is and puts it back
+// there as it next re-renders, instead of leaving the user at the top of a new
+// rendering of the diff they were already reading. Call it on the view about to be
+// re-rendered, right before triggering the re-render — on both panes of the main
+// window where both are being rendered again, since either of them may hold the diff
+// being read; a pane that isn't showing is left alone.
+//
+// The line to keep is the end of the selection that is on screen, and the middle
+// visible line when there is no selection or the whole of it has been scrolled out of
+// sight — what the user is looking at, rather than the view's top edge or a selection
+// they have long since left behind. It may not survive the re-render: a context line
+// goes when the context size shrinks, and a whole hunk or file goes when whitespace
+// stops counting. So the lines around it come along as fallbacks and the view lands on
+// the nearest one that is still there, put back on the screen row it was on. With none
+// of them left — and with a renderer that says nothing about its rows there is nothing
+// to look for in the first place — the view keeps the scroll offset it had, which is
+// still nearer to what was being read than the top of the diff.
+//
+// An off-screen selection is still put back on the diff line it was on, wherever the
+// new rendering has that; it is only the view that stays where it is.
+//
+// A range or hunk selection has a second end, which is remembered the same way, so
+// that it still covers the same lines of the diff afterwards.
+func (self *DiffLineHelper) PreserveDiffPositionOnRerender(view *gocui.View) {
+	// A view that isn't the one its window is currently showing — the merge-conflicts
+	// view takes the main window over — isn't the one about to be re-rendered, so a
+	// restore installed on it would sit there and claim a later render instead.
+	if !view.Visible {
+		return
+	}
+
+	// The re-render is produced by a different command from the one behind what is on
+	// screen — another context size, another renderer — so without being told otherwise
+	// it would be taken for content the user has never seen and shown from the top.
+	// Whether or not a line of the old rendering can be found in the new one, the offset
+	// into it is nearer to where they were reading than the top is.
+	if manager := self.c.GetViewBufferManagerForView(view); manager != nil {
+		manager.SetKeepScrollPositionForNextTask()
+	}
+
+	showSelection := view.Highlight
+	anchorViewLine := view.MiddleVisibleLineIdx()
+	farEnd, hasFarEnd := types.DiffLineInfo{}, false
+	// A cursor that has been scrolled away from is put back by its own lines rather
+	// than by the anchor's, so that it comes out on the same line of the diff without
+	// the view having to go there.
+	var cursorCandidates []diffLineAnchor
+	if showSelection {
+		farEnd, hasFarEnd = self.selectionFarEndIdentity(view)
+		if end, ok := visibleSelectionEnd(view); ok {
+			anchorViewLine = end
+		}
+		if anchorViewLine != view.SelectedLineIdx() {
+			cursorCandidates = self.nearbyDiffLines(view, view.SelectedLineIdx())
+		}
+	}
+
+	self.restoreDiffLinePositionOnRerender(view, self.nearbyDiffLines(view, anchorViewLine),
+		func(anchor diffLineAnchor, viewLine int) {
+			// Put the line back on the screen row it was on, clamped into the view for
+			// the fallback lines, which can come from off screen.
+			row := lo.Clamp(anchor.row, 0, max(0, view.InnerHeight()-1))
+			view.SetOrigin(0, max(0, viewLine-row))
+			if showSelection {
+				// Put the far end back before the cursor, so that the selection covers
+				// the same lines again; a selection whose far end didn't survive the
+				// re-render is left as the single line we landed on. The origin is
+				// already where it should be, so moving the cursor mustn't scroll.
+				view.CancelRangeSelect()
+				cursorViewLine := self.selectionLine(view, cursorCandidates, viewLine)
+				if hasFarEnd {
+					if farEndViewLine, ok := self.findDiffLine(view, farEnd); ok {
+						cursorViewLine, farEndViewLine = coverWholeLines(view, cursorViewLine, farEndViewLine)
+						view.SetRangeSelectStart(farEndViewLine)
+					}
+				}
+				view.FocusPoint(0, cursorViewLine, false)
+			}
+		})
+}
+
+// coverWholeLines moves the two ends of a restored selection out to the edges of the
+// diff lines they are on, so that the selection covers those lines whole. Both ends
+// arrive on the first view line of their diff line, which is where looking one up by
+// identity lands, and the view draws a line it wraps as several — of which a
+// selection of that line means all.
+func coverWholeLines(view *gocui.View, cursorViewLine int, farEndViewLine int) (int, int) {
+	if cursorViewLine <= farEndViewLine {
+		return cursorViewLine, lastViewLineOfSameDiffLine(view, farEndViewLine)
+	}
+	return lastViewLineOfSameDiffLine(view, cursorViewLine), farEndViewLine
+}
+
+// lastViewLineOfSameDiffLine returns the last view line showing the same line of the
+// diff as the given one, which is that line itself unless the view wrapped it.
+func lastViewLineOfSameDiffLine(view *gocui.View, viewLine int) int {
+	bufferLine, ok := view.BufferLineForViewLine(viewLine)
+	if !ok {
+		return viewLine
+	}
+	if last, ok := view.LastViewLineForBufferLine(bufferLine); ok {
+		return last
+	}
+	return viewLine
+}
+
+// visibleSelectionEnd returns the end of the selection to keep in place across a
+// re-render: the selected line when it is on screen, and the range's other end when
+// that is and the selected line isn't — a range can be long enough for the user to be
+// looking at one end of it with the other far away. ok is false when the whole
+// selection is off screen, and there is nothing of it to keep in place.
+func visibleSelectionEnd(view *gocui.View) (int, bool) {
+	if view.IsLineVisible(view.SelectedLineIdx()) {
+		return view.SelectedLineIdx(), true
+	}
+	if farEnd, _, ok := selectionFarEndViewLine(view); ok && view.IsLineVisible(farEnd) {
+		return farEnd, true
+	}
+	return 0, false
+}
+
+// selectionLine returns the line to put the cursor on once a re-render is on screen:
+// the line the position anchor landed on, which is the selected one whenever it was
+// on screen, and otherwise the nearest surviving line to where the selection was —
+// found among its own candidates, since the anchor's are a search of the diff from
+// somewhere else entirely.
+func (self *DiffLineHelper) selectionLine(
+	view *gocui.View, candidates []diffLineAnchor, anchorViewLine int,
+) int {
+	if len(candidates) == 0 {
+		return anchorViewLine
+	}
+	_, bufferLine := self.nearestSurvivingCandidate(view.DiffLineContents(), candidates)
+	if bufferLine == -1 {
+		return anchorViewLine
+	}
+	if viewLine, ok := view.ViewLineForBufferLine(bufferLine); ok {
+		return viewLine
+	}
+	return anchorViewLine
+}
+
+// selectionFarEndIdentity returns the identity of the end of a range or hunk
+// selection the cursor isn't on, so that a re-render can put it back. ok is false for
+// a selection that is only a cursor, where restoring that is the whole job, and for
+// an end that resolves to no diff line.
+//
+// An end covers the whole of its row, so where the row shows more than one diff line
+// — a rendering that puts a modification's two halves side by side, or a word diff
+// that puts both on the one line it changed — the end takes the outermost of them:
+// the last for the range's lower end and the first for its upper one. Otherwise a
+// rendering that splits them apart again would get back only the half the row led
+// with, and half a change selected where a whole one was.
+func (self *DiffLineHelper) selectionFarEndIdentity(view *gocui.View) (types.DiffLineInfo, bool) {
+	farEnd, isLowerEnd, ok := selectionFarEndViewLine(view)
+	if !ok {
+		return types.DiffLineInfo{}, false
+	}
+	identities, ok := self.diffLineIdentitiesAt(view, farEnd)
+	if !ok {
+		return types.DiffLineInfo{}, false
+	}
+	if isLowerEnd {
+		return identities[len(identities)-1], true
+	}
+	return identities[0], true
+}
+
+// selectionFarEndViewLine returns the view line of the end of a range or hunk
+// selection the cursor isn't on, and whether that is the lower of the two ends. ok
+// is false when there is no range at all, only a cursor.
+//
+// A range whose two ends are on the same view line still has one, and is not the
+// same thing as a cursor sitting there: it covers everything that row shows, which
+// may be two lines of the diff at once.
+func selectionFarEndViewLine(view *gocui.View) (int, bool, bool) {
+	if !view.HasRangeSelect() {
+		return 0, false, false
+	}
+	first, last := view.SelectedLineRange()
+	if view.SelectedLineIdx() == first {
+		return last, true, true
+	}
+	return first, false, true
+}
+
+// findDiffLine returns the view line showing the given diff line in what view is
+// displaying now, for placing a remembered line once the re-render is on screen.
+func (self *DiffLineHelper) findDiffLine(view *gocui.View, identity types.DiffLineInfo) (int, bool) {
+	bufferLine, ok := self.patchLineRows(view.DiffLineContents())[patchLineOf(identity)]
+	if !ok {
+		return 0, false
+	}
+	return view.ViewLineForBufferLine(bufferLine)
+}
+
+// restoreDiffLinePositionOnRerender arranges for view's next re-render to land on the
+// first of the given candidate lines the new rendering still has, calling place with
+// that candidate and the view line it ended up on. The candidates are in priority
+// order (see nearbyDiffLines); if the rendering has none of them, place isn't called
+// and the view re-renders as it otherwise would.
+//
+// The nearest candidate is looked for as the content loads, so that the re-render can
+// be revealed at the right position as soon as that line and a screenful below it
+// have arrived. Only the nearest one, because the candidates aren't in load order: a
+// farther one can load first, and landing on it while a nearer one is still on its
+// way would be settling for worse. The rest are considered together once the whole
+// rendering is there.
+func (self *DiffLineHelper) restoreDiffLinePositionOnRerender(
+	view *gocui.View, candidates []diffLineAnchor, place func(anchor diffLineAnchor, viewLine int),
+) {
+	manager := self.c.GetViewBufferManagerForView(view)
+	if manager == nil || len(candidates) == 0 {
+		return
+	}
+
+	// The readiness check below runs on the task's own goroutine, where neither the
+	// view's dimensions nor the repo we are in may be read — a repo switch replaces
+	// the latter — so take both here, on the UI thread, for it to work from.
+	viewHeight := view.InnerHeight()
+	worktreePath := self.c.Git().RepoPaths.WorktreePath()
+
+	// What the search of the loading content has found, and how far it has looked, so
+	// that each line is looked at once.
+	found := diffLineAnchor{}
+	foundLine := -1
+	scanned := 0
+
+	manager.SetRestoreForNextTask(&tasks.RenderRestore{
+		FirstPaintReady: func() bool {
+			if foundLine == -1 {
+				rows := view.OffscreenDiffLineContentsFrom(scanned)
+				for i, row := range rows {
+					if rowShowsDiffLine(row, worktreePath, candidates[0].identity) {
+						found, foundLine = candidates[0], scanned+i
+						break
+					}
+				}
+				scanned += len(rows)
+				if foundLine == -1 {
+					return false
+				}
+			}
+			// Wait for a screenful below the line as well, so that the re-render isn't
+			// revealed with it stranded at the bottom of a half-filled view.
+			return view.OffscreenLineCount() >= foundLine+viewHeight
+		},
+		Apply: func(swapIn func()) bool {
+			anchor, bufferLine := found, foundLine
+			if bufferLine == -1 {
+				anchor, bufferLine = self.nearestSurvivingCandidate(view.OffscreenDiffLineContents(), candidates)
+			}
+
+			swapIn()
+
+			if bufferLine == -1 {
+				return false
+			}
+			viewLine, ok := view.ViewLineForBufferLine(bufferLine)
+			if !ok {
+				return false
+			}
+			place(anchor, viewLine)
+			return true
+		},
+	})
+}
+
+// nearbyDiffLines collects the lines of view's rendered diff as candidates for a
+// restore to land on, ordered by proximity to the anchor line — the anchor itself
+// first, then outward, preferring at-or-below on ties — each tagged with the screen
+// row it is on. A restore lands on the first of them its re-render still has, so this
+// order makes it land as near as possible to where the user was.
+//
+// The walk covers the whole diff rather than stopping at the change lines on either
+// side of the anchor, which a context-size change always keeps: ignoring whitespace
+// keeps nothing in particular, and can take a hunk or a whole file out of the diff,
+// leaving the nearest surviving line in a neighbouring file.
+func (self *DiffLineHelper) nearbyDiffLines(view *gocui.View, anchorViewLine int) []diffLineAnchor {
+	anchor, ok := view.BufferLineForViewLine(anchorViewLine)
+	if !ok {
+		return nil
+	}
+	resolved := self.resolveDiffLines(view.DiffLineContents())
+	if anchor >= len(resolved) {
+		return nil
+	}
+	rows := screenRows(view, len(resolved))
+
+	candidates := make([]diffLineAnchor, 0, len(resolved))
+	collect := func(bufferLine int) {
+		if line := resolved[bufferLine]; line.ok {
+			candidates = append(candidates, diffLineAnchor{identity: line.info, row: rows[bufferLine]})
+		}
+	}
+	collect(anchor)
+	for below, above := anchor+1, anchor-1; below < len(resolved) || above >= 0; below, above = below+1, above-1 {
+		if below < len(resolved) {
+			collect(below)
+		}
+		if above >= 0 {
+			collect(above)
+		}
+	}
+	return candidates
+}
+
+// screenRows maps each line of view's content to the screen row it is drawn on. The
+// lines above the visible ones get -1 and those below them the view's height, so that
+// putting one of them back where it was lands it at the top or bottom edge.
+func screenRows(view *gocui.View, bufferLineCount int) []int {
+	height := view.InnerHeight()
+	originY := view.OriginY()
+
+	rows := make([]int, bufferLineCount)
+	for i := range rows {
+		rows[i] = -1
+	}
+	lastVisible := -1
+	for y := originY; y < min(originY+height, view.ViewLinesHeight()); y++ {
+		bufferLine, ok := view.BufferLineForViewLine(y)
+		if !ok || bufferLine >= bufferLineCount {
+			continue
+		}
+		if rows[bufferLine] == -1 {
+			rows[bufferLine] = y - originY
+		}
+		lastVisible = bufferLine
+	}
+	for i := lastVisible + 1; i < bufferLineCount; i++ {
+		rows[i] = height
+	}
+	return rows
+}
+
+// nearestSurvivingCandidate returns the first of the candidates that the given
+// rendering still shows, and the line of it that does. The rendering is indexed
+// first, rather than searched once per candidate: the candidate list is as long as
+// the diff, and so is the rendering.
+func (self *DiffLineHelper) nearestSurvivingCandidate(
+	contents []gocui.DiffLineContent, candidates []diffLineAnchor,
+) (diffLineAnchor, int) {
+	rows := self.patchLineRows(contents)
+	for _, candidate := range candidates {
+		if line, ok := rows[patchLineOf(candidate.identity)]; ok {
+			return candidate, line
+		}
+	}
+	return diffLineAnchor{}, -1
+}
+
+// patchLineRows indexes a rendering by the diff lines it shows: for each of them, the
+// first of its rows that does. A row can show more than one, and each is then a way
+// of finding that row again.
+func (self *DiffLineHelper) patchLineRows(contents []gocui.DiffLineContent) map[patchLine]int {
+	rows := map[patchLine]int{}
+	for i, identities := range self.resolveDiffLineIdentities(contents) {
+		for _, identity := range identities {
+			if _, seen := rows[patchLineOf(identity)]; !seen {
+				rows[patchLineOf(identity)] = i
+			}
+		}
+	}
+	return rows
+}
+
+// rowShowsDiffLine reports whether the given row of a rendering shows the given diff
+// line — among any others it shows, since a side-by-side rendering puts a deletion
+// beside the addition replacing it. It only knows what the renderer states about the
+// row, since the alternative, parsing the rendering as a diff, needs whole hunks and
+// this is asked of content that is still loading. It takes the repo's worktree path
+// rather than reading it, being asked off the UI thread.
+func rowShowsDiffLine(row gocui.DiffLineContent, worktreePath string, target types.DiffLineInfo) bool {
+	return lo.SomeBy(row.Metadata, func(record string) bool {
+		parsed, ok := parseDiffLineMetadata(record)
+		return ok && patchLineOf(diffLineInfoIn(worktreePath, parsed)) == patchLineOf(target)
+	})
+}
+
+// patchLine records what stays the same about a diff line when the same diff is
+// rendered again differently: which file it belongs to, the line number that
+// identifies it on the side it belongs to, and what kind of line it is.
+type patchLine struct {
+	path string
+	// Every kind of content line collapses into DiffLineContext, since an addition
+	// and the context line it turns into when whitespace stops counting are the same
+	// line of the same file. The header rows keep their kind: a file's header and the
+	// first line of the file it heads are not the same place.
+	kind types.DiffLineType
+	// The old file's line number for a deletion, since two consecutive deletions
+	// share a new-file position and differ only here; the new file's otherwise.
+	line       int
+	isDeletion bool
+}
+
+func patchLineOf(info types.DiffLineInfo) patchLine {
+	switch info.Type {
+	case types.DiffLineFileHeader, types.DiffLineHunkHeader:
+		return patchLine{path: info.Path, kind: info.Type, line: info.NewLine}
+	case types.DiffLineDeleted:
+		return patchLine{path: info.Path, kind: types.DiffLineContext, line: info.OldLine, isDeletion: true}
+	default:
+		return patchLine{path: info.Path, kind: types.DiffLineContext, line: info.NewLine}
+	}
+}

pkg/gui/controllers/main_view_controller.go

@@ -3,7 +3,9 @@ package controllers
 import (
 	"github.com/jesseduffield/lazygit/pkg/gocui"
 	"github.com/jesseduffield/lazygit/pkg/gui/context"
+	"github.com/jesseduffield/lazygit/pkg/gui/controllers/helpers"
 	"github.com/jesseduffield/lazygit/pkg/gui/types"
+	"github.com/samber/lo"
 )
 
 type MainViewController struct {
@@ -12,6 +14,9 @@ type MainViewController struct {
 
 	context      *context.MainContext
 	otherContext *context.MainContext
+
+	dragAutoscroller  *helpers.DragAutoscroller
+	draggingWithMouse bool
 }
 
 var _ types.IController = &MainViewController{}
@@ -21,12 +26,19 @@ func NewMainViewController(
 	context *context.MainContext,
 	otherContext *context.MainContext,
 ) *MainViewController {
-	return &MainViewController{
+	controller := &MainViewController{
 		baseController: baseController{},
 		c:              c,
 		context:        context,
 		otherContext:   otherContext,
 	}
+	controller.dragAutoscroller = helpers.NewDragAutoscroller(
+		c.HelperCommon,
+		context,
+		controller.canDragAutoscroll,
+		controller.handleDragAutoscroll,
+	)
+	return controller
 }
 
 func (self *MainViewController) GetKeybindings(opts types.KeybindingsOpts) []*types.Binding {
@@ -38,10 +50,68 @@ func (self *MainViewController) GetKeybindings(opts types.KeybindingsOpts) []*ty
 			Tooltip:         self.c.Tr.ToggleStagingViewTooltip,
 			DisplayOnScreen: true,
 		},
+		{
+			Keys:    opts.GetKeys(opts.Config.Main.ToggleSelectHunk),
+			Handler: self.toggleSelectHunk,
+			DescriptionFunc: self.diffSelectionDescription(func() string {
+				if self.diffSelectState().Mode == types.DiffSelectModeHunk {
+					return self.c.Tr.SelectLineByLine
+				}
+				return self.c.Tr.SelectHunk
+			}),
+			Description:       self.c.Tr.ToggleSelectHunk,
+			GetDisabledReason: self.diffSelectionDisabledReason,
+			Tooltip:           self.c.Tr.ToggleSelectHunkTooltip,
+			DisplayOnScreen:   true,
+		},
+		{
+			Keys:              opts.GetKeys(opts.Config.Universal.ToggleRangeSelect),
+			Handler:           self.toggleRangeSelect,
+			Description:       self.c.Tr.ToggleRangeSelect,
+			DescriptionFunc:   self.diffSelectionDescriptionText(self.c.Tr.ToggleRangeSelect),
+			GetDisabledReason: self.diffSelectionDisabledReason,
+		},
+		{
+			Keys:              opts.GetKeys(opts.Config.Universal.Edit),
+			Handler:           self.editLine,
+			Description:       self.c.Tr.EditFile,
+			DescriptionFunc:   self.diffSelectionDescriptionText(self.c.Tr.EditFile),
+			GetDisabledReason: self.diffSelectionDisabledReason,
+			Tooltip:           self.c.Tr.EditFileTooltip,
+		},
+		{
+			Keys:              opts.GetKeys(opts.Config.Main.PrevHunk),
+			Handler:           self.prevChangeBlock,
+			Description:       self.c.Tr.PrevHunk,
+			DescriptionFunc:   self.diffSelectionDescriptionText(self.c.Tr.PrevHunk),
+			GetDisabledReason: self.diffSelectionDisabledReason,
+		},
+		{
+			Keys:              opts.GetKeys(opts.Config.Main.NextHunk),
+			Handler:           self.nextChangeBlock,
+			Description:       self.c.Tr.NextHunk,
+			DescriptionFunc:   self.diffSelectionDescriptionText(self.c.Tr.NextHunk),
+			GetDisabledReason: self.diffSelectionDisabledReason,
+		},
+		{
+			Keys:              opts.GetKeys(opts.Config.Main.PrevFile),
+			Handler:           self.prevFile,
+			Description:       self.c.Tr.PrevFileInDiff,
+			DescriptionFunc:   self.diffSelectionDescriptionText(self.c.Tr.PrevFileInDiff),
+			GetDisabledReason: self.diffSelectionDisabledReason,
+		},
+		{
+			Keys:              opts.GetKeys(opts.Config.Main.NextFile),
+			Handler:           self.nextFile,
+			Description:       self.c.Tr.NextFileInDiff,
+			DescriptionFunc:   self.diffSelectionDescriptionText(self.c.Tr.NextFileInDiff),
+			GetDisabledReason: self.diffSelectionDisabledReason,
+		},
 		{
 			Keys:            opts.GetKeys(opts.Config.Universal.Return),
 			Handler:         self.escape,
 			Description:     self.c.Tr.ExitFocusedMainView,
+			DescriptionFunc: self.escapeDescription,
 			DisplayOnScreen: true,
 		},
 		{
@@ -51,6 +121,28 @@ func (self *MainViewController) GetKeybindings(opts types.KeybindingsOpts) []*ty
 			Description: self.c.Tr.StartSearch,
 			Tag:         "navigation",
 		},
+		{Tag: "navigation", Keys: opts.GetKeys(opts.Config.Universal.PrevItem), Handler: self.handlePrevLine},
+		{Tag: "navigation", Keys: opts.GetKeys(opts.Config.Universal.NextItem), Handler: self.handleNextLine},
+		{
+			Tag:               "navigation",
+			Keys:              opts.GetKeys(opts.Config.Universal.RangeSelectUp),
+			Handler:           self.extendRangeUp,
+			Description:       self.c.Tr.RangeSelectUp,
+			DescriptionFunc:   self.diffSelectionDescriptionText(self.c.Tr.RangeSelectUp),
+			GetDisabledReason: self.diffSelectionDisabledReason,
+		},
+		{
+			Tag:               "navigation",
+			Keys:              opts.GetKeys(opts.Config.Universal.RangeSelectDown),
+			Handler:           self.extendRangeDown,
+			Description:       self.c.Tr.RangeSelectDown,
+			DescriptionFunc:   self.diffSelectionDescriptionText(self.c.Tr.RangeSelectDown),
+			GetDisabledReason: self.diffSelectionDisabledReason,
+		},
+		{Tag: "navigation", Keys: opts.GetKeys(opts.Config.Universal.PrevPage), Handler: self.handlePrevPage, Description: self.c.Tr.PrevPage},
+		{Tag: "navigation", Keys: opts.GetKeys(opts.Config.Universal.NextPage), Handler: self.handleNextPage, Description: self.c.Tr.NextPage},
+		{Tag: "navigation", Keys: opts.GetKeys(opts.Config.Universal.GotoTop), Handler: self.handleGotoTop, Description: self.c.Tr.GotoTop},
+		{Tag: "navigation", Keys: opts.GetKeys(opts.Config.Universal.GotoBottom), Handler: self.handleGotoBottom, Description: self.c.Tr.GotoBottom},
 	}
 }
 
@@ -68,6 +160,19 @@ func (self *MainViewController) GetMouseKeybindings(opts types.KeybindingsOpts)
 			Handler:     self.onClickInOtherViewOfMainViewPair,
 			FocusedView: self.otherContext.GetViewName(),
 		},
+		{
+			// Dragging after a click extends a range selection from the clicked line.
+			ViewName:    self.context.GetViewName(),
+			Key:         gocui.MouseLeft,
+			Modifier:    gocui.ModMotion,
+			Handler:     self.onDragInFocusedView,
+			FocusedView: self.context.GetViewName(),
+		},
+		{
+			ViewName: self.context.GetViewName(),
+			Key:      gocui.MouseRelease,
+			Handler:  self.onDragRelease,
+		},
 	}
 }
 
@@ -76,35 +181,691 @@ func (self *MainViewController) Context() types.Context {
 }
 
 func (self *MainViewController) togglePanel() error {
-	if self.otherContext.GetView().Visible {
-		self.c.Context().Push(self.otherContext, types.OnFocusOpts{})
+	if !self.otherContext.GetView().Visible {
+		return nil
 	}
 
+	// Whether the pair holds a diff is decided by the side panel beneath, which
+	// NextInStack only finds while our context is still the focused main view, so
+	// read it before pushing the other pane.
+	isDiff := self.isDiffView()
+	self.c.Context().Push(self.otherContext, types.OnFocusOpts{})
+	if isDiff {
+		establishDiffSelection(self.c, self.otherContext, -1)
+	}
 	return nil
 }
 
+// escape dismisses the selection a step at a time before leaving the view: a range
+// collapses to its cursor line, and hunk mode the user turned on goes back to
+// line-by-line. Hunk mode that is merely the configured default is not something to
+// escape from, so there escape leaves.
 func (self *MainViewController) escape() error {
+	if self.selectingRange() || self.selectingHunkEnabledByUser() {
+		self.context.ResetDiffSelectMode()
+		return nil
+	}
+
 	self.c.Context().Pop()
 	return nil
 }
 
-func (self *MainViewController) onClickInAlreadyFocusedView(opts gocui.ViewMouseBindingOpts) error {
-	sidePanelContext := self.c.Context().NextInStack(self.context)
-	if sidePanelContext != nil && sidePanelContext.GetOnClickFocusedMainView() != nil {
-		return sidePanelContext.GetOnClickFocusedMainView()(self.context.GetViewName(), opts.Y)
+func (self *MainViewController) escapeDescription() string {
+	if self.selectingRange() {
+		return self.c.Tr.DismissRangeSelect
+	}
+	if self.selectingHunkEnabledByUser() {
+		return self.c.Tr.SelectLineByLine
+	}
+	return self.c.Tr.ExitFocusedMainView
+}
+
+// selectingHunkEnabledByUser reports whether we are in hunk mode because the user
+// asked for it, as opposed to it being the configured default.
+func (self *MainViewController) selectingHunkEnabledByUser() bool {
+	return self.diffSelectState().Mode == types.DiffSelectModeHunk && self.diffSelectState().UserEnabledHunkMode
+}
+
+// isDiffView reports whether the focused main view currently shows a diff, and so
+// shows a selection. See types.DiffMainViewContext.
+func (self *MainViewController) isDiffView() bool {
+	return self.diffMainViewType() != types.DiffMainViewTypeNone
+}
+
+// diffMainViewType reports what the diff in the focused main view belongs to, taken
+// from the side panel beneath it, or DiffMainViewTypeNone when this pane isn't on the
+// stack or has no diff panel beneath it. The IsInStack guard is essential:
+// NextInStack panics for a context that isn't in the stack, and GetKeybindings (which
+// leads here) also runs for off-stack panes — at startup and while generating the
+// cheatsheets, where the stack is empty.
+func (self *MainViewController) diffMainViewType() types.DiffMainViewType {
+	if !self.c.Context().IsInStack(self.context) {
+		return types.DiffMainViewTypeNone
+	}
+	if diffContext, ok := self.c.Context().NextInStack(self.context).(types.DiffMainViewContext); ok {
+		return diffContext.GetDiffMainViewType()
+	}
+	return types.DiffMainViewTypeNone
+}
+
+// diffSelectState returns this pane's diff selection mode state.
+func (self *MainViewController) diffSelectState() *types.DiffSelectState {
+	return self.context.DiffSelectState()
+}
+
+// diffSelectionDescription qualifies the description of a command that acts on the
+// selection, so that it is listed only where it applies: the main view also shows
+// content with nothing to select in it — a branch's commit log, the status dashboard —
+// and a command with no description is left out of the keybindings menu.
+//
+// The static Description stays as it is: the cheatsheets are generated from that, and
+// they document what a key does rather than when it applies.
+func (self *MainViewController) diffSelectionDescription(describe func() string) func() string {
+	return func() string {
+		if !self.isDiffView() {
+			return ""
+		}
+		return describe()
+	}
+}
+
+func (self *MainViewController) diffSelectionDescriptionText(description string) func() string {
+	return self.diffSelectionDescription(func() string { return description })
+}
+
+// diffSelectionDisabledReason disables the commands that act on the selection while
+// there is none to act on: a diff view whose diff holds nothing selectable (a binary
+// file, an empty commit) or which is showing a placeholder message.
+func (self *MainViewController) diffSelectionDisabledReason() *types.DisabledReason {
+	if !self.context.GetView().Highlight {
+		return &types.DisabledReason{Text: self.c.Tr.NothingToSelectInDiff}
 	}
 	return nil
 }
 
+func (self *MainViewController) onClickInAlreadyFocusedView(opts gocui.ViewMouseBindingOpts) error {
+	self.selectClickedDiffLine(opts.Y)
+	return nil
+}
+
 func (self *MainViewController) onClickInOtherViewOfMainViewPair(opts gocui.ViewMouseBindingOpts) error {
-	self.c.Context().Push(self.context, types.OnFocusOpts{
-		ClickedWindowName:  self.context.GetWindowName(),
-		ClickedViewLineIdx: opts.Y,
+	// Carry the select mode over from the pane we're leaving, so that clicking into
+	// the other pane keeps hunk mode even the first time we enter it — its own mode
+	// would otherwise still be the default single line until it had been focused at
+	// least once. selectClickedDiffLine then keeps or collapses that mode depending on
+	// where the click landed.
+	*self.context.DiffSelectState() = *self.otherContext.DiffSelectState()
+	self.c.Context().Push(self.context, types.OnFocusOpts{})
+	self.selectClickedDiffLine(opts.Y)
+	return nil
+}
+
+// onDragInFocusedView extends a range selection as the mouse is dragged after a
+// click, anchored at the line the click landed on rather than wherever the click left
+// the selection — a click can select a whole hunk, whose far end would otherwise
+// become the anchor. Dragging turns hunk mode off: you get a plain range from the
+// clicked line to the line under the cursor, which gocui has already moved here.
+func (self *MainViewController) onDragInFocusedView(opts gocui.ViewMouseBindingOpts) error {
+	view := self.context.GetView()
+	if !self.isDiffView() || !view.Highlight {
+		return nil
+	}
+	sel := self.diffSelectState()
+	sel.Mode = types.DiffSelectModeRange
+	sel.RangeIsSticky = false
+	sel.UserEnabledHunkMode = false
+	view.SetRangeSelectStart(self.context.DragAnchorViewLine())
+
+	// A drag that reaches the edge of the view keeps going: mouse capture means the
+	// pointer can be dragged past the edge, and there is more diff down there than
+	// fits on screen. opts.Y is where the pointer is in the content, which the
+	// autoscroller wants relative to the viewport.
+	self.draggingWithMouse = true
+	originY, _ := self.context.GetViewTrait().ViewPortYBounds()
+	self.dragAutoscroller.Update(opts.Y - originY)
+	return nil
+}
+
+func (self *MainViewController) onDragRelease(gocui.ViewMouseBindingOpts) error {
+	self.draggingWithMouse = false
+	self.dragAutoscroller.Cancel()
+
+	// The drag moved the selection without going through showSelectionAtLine: gocui
+	// moves the cursor for it. Let the search catch up with where it ended.
+	self.context.GetView().SetNearestSearchPosition()
+	return nil
+}
+
+// GetOnFocusLost stops an autoscroll that is still running when the view loses focus
+// mid-drag, e.g. because a popup appeared, and gives up the mouse capture with it —
+// otherwise the pointer would keep driving a view that no longer has focus.
+func (self *MainViewController) GetOnFocusLost() func(types.OnFocusLostOpts) {
+	return func(types.OnFocusLostOpts) {
+		self.dragAutoscroller.Cancel()
+		if self.draggingWithMouse {
+			self.draggingWithMouse = false
+			self.c.GocuiGui().CancelMouseCapture()
+		}
+	}
+}
+
+// canDragAutoscroll reports whether the autoscroller should run: only while a drag is
+// actually extending a range in a diff. Scrolling down also has to keep the lazily
+// loaded content ahead of the scroll, or it would stop at the loaded edge.
+func (self *MainViewController) canDragAutoscroll(direction int) bool {
+	if !self.draggingWithMouse || !self.isDiffView() {
+		return false
+	}
+	view := self.context.GetView()
+	if !view.Highlight || self.diffSelectState().Mode != types.DiffSelectModeRange {
+		return false
+	}
+	if direction > 0 {
+		self.c.ReadLinesToFillView(view)
+	}
+	return true
+}
+
+// handleDragAutoscroll extends the selection to the line the pointer ends up over
+// after the autoscroller has scrolled, leaving the range anchored where the drag
+// started. It reports whether the autoscroll should carry on.
+//
+// The pointer is usually outside the view by now — that is what mouse capture is for —
+// so the line it is over is clamped to the visible ones, leaving the selection's far
+// end at the edge the scroll is moving towards.
+func (self *MainViewController) handleDragAutoscroll(viewLine int) bool {
+	if !self.canDragAutoscroll(0) {
+		return false
+	}
+	view := self.context.GetView()
+	originY, viewportHeight := self.context.GetViewTrait().ViewPortYBounds()
+	target := lo.Clamp(viewLine, 0, max(0, view.ViewLinesHeight()-1))
+	view.SetCursorY(lo.Clamp(target-originY, 0, max(0, viewportHeight-1)))
+	return true
+}
+
+// selectClickedDiffLine sets the focused main view's selection from a click at the
+// given view line. In hunk mode, clicking inside the selected block collapses it to
+// that line; clicking a change line outside it keeps hunk mode and selects that block.
+// A click on context, or any click outside hunk mode, selects just that line too.
+func (self *MainViewController) selectClickedDiffLine(viewLine int) {
+	if !self.isDiffView() {
+		return
+	}
+	view := self.context.GetView()
+	// Remember where the click landed so that a drag that follows anchors its range
+	// there, even when this click selects a whole hunk.
+	self.context.SetDragAnchorViewLine(viewLine)
+	if self.diffSelectState().Mode == types.DiffSelectModeHunk {
+		if start, end, ok := self.c.Helpers().DiffLine.SelectedHunkBounds(view); ok &&
+			viewLine >= start && viewLine <= end {
+			self.context.ResetDiffSelectMode()
+			showSelectionAtLine(view, viewLine, false)
+			return
+		}
+		if self.c.Helpers().DiffLine.IsChangeLine(view, viewLine) {
+			self.selectHunkAround(viewLine, false)
+			return
+		}
+	}
+	self.context.ResetDiffSelectMode()
+	showSelectionAtLine(view, viewLine, false)
+}
+
+// establishDiffSelection turns on the focused main view's selection once the view has
+// been focused. clickedViewLine is the view line a click pointed at, or -1 for
+// keyboard focus, which points at no particular line and so starts at the first
+// change line on screen.
+//
+// Focusing never moves the view: you focus the diff you are reading in order to point
+// at something in it, so the selection goes where you are looking rather than the
+// view going where the selection would like to be. With no change line on screen at
+// all — a long stretch of context — it lands on the middle visible line, the likeliest
+// one to be the one being read.
+//
+// With hunk mode configured as the default the selection widens to the whole change
+// block: keyboard focus lands on the first block on screen, and a click on a change
+// line selects that line's block, ready to act on. A click on context still selects
+// just that line — the click points at it precisely, so it stays editable.
+func establishDiffSelection(c *ControllerCommon, mainContext *context.MainContext, clickedViewLine int) {
+	mainContext.ResetDiffSelectMode()
+	view := mainContext.GetView()
+
+	// The panel beneath renders a diff, but that diff may hold nothing to act on: a
+	// binary file, or an empty commit. Rendering it worked that out, so the pane is
+	// already showing no selection and there is nowhere to put one.
+	if !c.Helpers().DiffLine.ViewHasChangeLines(view) {
+		return
+	}
+
+	if clickedViewLine >= 0 {
+		// Remember where the click landed so that a drag that follows anchors its range
+		// there, even when this click selects a whole hunk.
+		mainContext.SetDragAnchorViewLine(clickedViewLine)
+		if hunkModeApplies(c, view, clickedViewLine) &&
+			c.Helpers().DiffLine.IsChangeLine(view, clickedViewLine) {
+			mainContext.DiffSelectState().Mode = types.DiffSelectModeHunk
+			selectDiffHunk(c, mainContext, clickedViewLine, false)
+			return
+		}
+		showSelectionAtLine(view, clickedViewLine, false)
+		return
+	}
+
+	target, ok := changeToSelectOnScreen(c, view)
+	if !ok {
+		showSelectionAtLine(view, view.MiddleVisibleLineIdx(), false)
+		return
+	}
+	if hunkModeApplies(c, view, target) {
+		mainContext.DiffSelectState().Mode = types.DiffSelectModeHunk
+		selectDiffHunk(c, mainContext, target, false)
+		return
+	}
+	showSelectionAtLine(view, target, false)
+}
+
+// changeToSelectOnScreen returns the change line keyboard focus establishes the
+// selection on. In hunk mode that is the first block that begins on screen, so that
+// the block being offered up is one the user can see the extent of, falling back to a
+// block that reaches into the view from above — a change longer than the screen, where
+// there is nothing else to offer. Line by line it is simply the first change line on
+// screen. ok is false when the viewport shows no change at all.
+func changeToSelectOnScreen(c *ControllerCommon, view *gocui.View) (int, bool) {
+	if c.UserConfig().Gui.UseHunkModeInStagingView {
+		return c.Helpers().DiffLine.FirstChangeBlockInView(view)
+	}
+	return c.Helpers().DiffLine.FirstChangeLineInView(view)
+}
+
+// hunkModeApplies reports whether an established selection should start out as the
+// whole change block around the given change line. That's what the config asks for,
+// except over a file shown as one solid block of changes, where it would select the
+// whole file — see DiffLineHelper.IsSingleHunkForWholeFile.
+func hunkModeApplies(c *ControllerCommon, view *gocui.View, changeViewLine int) bool {
+	return c.UserConfig().Gui.UseHunkModeInStagingView &&
+		!c.Helpers().DiffLine.IsSingleHunkForWholeFile(view, changeViewLine)
+}
+
+// showSelectionAtLine moves the focused main view's selection to the given view line,
+// clamped to the content. scrollIntoView scrolls the line into view when it's
+// off-screen, for navigating to it; a click leaves it false, the clicked line being on
+// screen already.
+func showSelectionAtLine(view *gocui.View, lineIdx int, scrollIntoView bool) {
+	view.FocusPoint(0, lo.Clamp(lineIdx, 0, max(0, view.ViewLinesHeight()-1)), scrollIntoView)
+
+	// A search carries on from where the selection now is, so that stepping to the
+	// next match goes to the one after it rather than the one after the match the
+	// user last stepped to.
+	view.SetNearestSearchPosition()
+}
+
+func (self *MainViewController) selectHunkAround(changeViewLine int, scrollIntoView bool) {
+	selectDiffHunk(self.c, self.context, changeViewLine, scrollIntoView)
+}
+
+// selectDiffHunk selects the whole change block around the given change line, for
+// hunk mode: the cursor goes to the block's first line and the range anchor to its
+// last, so the native range highlight spans the block. With no block to be found —
+// a diff with no changes in it — it falls back to a single-line selection.
+//
+// scrollIntoView brings the block's first line on screen, for the commands that mean
+// to go there; a click leaves it false, so that the view doesn't move under the mouse
+// when the block the click landed in starts above the viewport.
+func selectDiffHunk(
+	c *ControllerCommon, mainContext *context.MainContext, changeViewLine int, scrollIntoView bool,
+) {
+	view := mainContext.GetView()
+	start, end, ok := c.Helpers().DiffLine.ChangeBlockBounds(view, changeViewLine)
+	if !ok {
+		mainContext.DiffSelectState().Mode = types.DiffSelectModeLine
+		view.CancelRangeSelect()
+		showSelectionAtLine(view, changeViewLine, scrollIntoView)
+		return
+	}
+	view.SetRangeSelectStart(end)
+	showSelectionAtLine(view, start, scrollIntoView)
+}
+
+// navigate moves the focused main view to the row find locates from the current
+// anchor — the selected line when a selection is showing, otherwise the top visible
+// line. With a selection we move it there and scroll it into view, re-selecting the
+// whole block in hunk mode; with none we stay in scroll mode, bringing the target
+// to the top without selecting anything.
+// alignTop says what a jump does with a target it has to scroll to: bring it to the
+// top of the view, or leave the scrolling to place it as it sees fit.
+func (self *MainViewController) navigate(find findDiffRowFn, forward bool, alignTop bool) {
+	v := self.context.GetView()
+	anchor := v.OriginY()
+	if v.Highlight {
+		anchor = v.SelectedLineIdx()
+	}
+
+	if target, ok := find(v, anchor, forward); ok {
+		self.placeNavigationTarget(target, alignTop)
+		return
+	}
+	if !forward {
+		// Everything above the anchor has loaded, so a backward target that wasn't
+		// found doesn't exist.
+		return
+	}
+
+	// The diff loads lazily, so a target below the loaded portion isn't there to be
+	// found yet. Read the rest of it in and look again before concluding there is none.
+	manager := self.c.GetViewBufferManagerForView(v)
+	if manager == nil {
+		return
+	}
+	manager.ReadToEnd(func() {
+		self.c.OnUIThread(func() error {
+			if target, ok := find(v, anchor, forward); ok {
+				self.placeNavigationTarget(target, alignTop)
+			}
+			return nil
+		})
 	})
+}
+
+// findDiffRowFn locates a row of the rendered diff to navigate to, given the view,
+// the anchor view line to start from, and the direction.
+type findDiffRowFn func(view *gocui.View, anchorViewLine int, forward bool) (int, bool)
+
+func (self *MainViewController) nextChangeBlock() error {
+	self.navigate(self.c.Helpers().DiffLine.AdjacentChangeBlock, true, false)
+	return nil
+}
+
+func (self *MainViewController) prevChangeBlock() error {
+	self.navigate(self.c.Helpers().DiffLine.AdjacentChangeBlock, false, false)
+	return nil
+}
+
+// nextFile and prevFile bring the file they go to to the top of the view, since what
+// you are going there for is the file, and the more of it is on screen the better.
+func (self *MainViewController) nextFile() error {
+	self.navigate(self.c.Helpers().DiffLine.AdjacentFile, true, true)
+	return nil
+}
+
+func (self *MainViewController) prevFile() error {
+	self.navigate(self.c.Helpers().DiffLine.AdjacentFile, false, true)
+	return nil
+}
+
+// placeNavigationTarget moves the selection to the row a jump found, bringing it on
+// screen if it isn't already.
+//
+// alignTop asks for the target to become the view's top line, so that everything that
+// begins there is on screen. It only applies to a target the view has to scroll to: a
+// jump to something already on screen leaves the view alone, there being nothing to
+// gain from moving what the user is looking at. In hunk mode what ends up selected is
+// the first change block at or below the target, which a large context size can put
+// further down than a screenful; the selection is then scrolled into view as any other
+// jump's is, and the alignment gives way to that.
+func (self *MainViewController) placeNavigationTarget(target int, alignTop bool) {
+	v := self.context.GetView()
+	if !v.Highlight {
+		v.SetOrigin(0, target)
+		return
+	}
+	if alignTop {
+		self.scrollTargetToTop(target)
+	}
+	// Jumping to another block or file moves the cursor without shift held, so a
+	// range that grows only while shift is held collapses rather than stretching all
+	// the way to the target. A sticky range stretches instead; this is the point of
+	// being sticky.
+	self.collapseNonStickyRange()
+	if self.diffSelectState().Mode == types.DiffSelectModeHunk {
+		self.selectHunkAround(target, true)
+		return
+	}
+	// Line mode leaves a single-line selection at the target; an active range extends
+	// to it, the anchor being untouched.
+	showSelectionAtLine(v, target, true)
+}
+
+// scrollTargetToTop scrolls the given row of the diff to the top of the view, leaving
+// the view where it is when that row is on screen already. The last screenful of the
+// diff is as far as it goes, so that the view doesn't scroll past the end of what it is
+// showing.
+func (self *MainViewController) scrollTargetToTop(target int) {
+	view := self.context.GetView()
+	originY, height := self.context.GetViewTrait().ViewPortYBounds()
+	if target >= originY && target < originY+height {
+		return
+	}
+	view.SetOriginY(min(target, max(0, view.ViewLinesHeight()-height)))
+}
+
+// moveCursor moves the selection cursor by delta view lines (negative = up), with the
+// configured scroll-off margin, reading more content in first when moving down. The
+// range anchor is left untouched, so this extends or contracts a range and just moves
+// the selected line otherwise.
+func (self *MainViewController) moveCursor(delta int) {
+	v := self.context.GetView()
+	if delta > 0 {
+		self.c.ReadLinesToFillView(v)
+	}
+	before := v.SelectedLineIdx()
+	after := lo.Clamp(before+delta, 0, v.ViewLinesHeight()-1)
+	if delta == -1 {
+		checkScrollUp(self.context.GetViewTrait(), self.c.UserConfig(), before, after)
+	} else if delta == 1 {
+		checkScrollDown(self.context.GetViewTrait(), self.c.UserConfig(), before, after)
+	}
+	showSelectionAtLine(v, after, true)
+}
+
+// collapseForLineMove drops hunk mode, and a non-sticky range, back to a single-line
+// selection — what a plain (non-shift, non-hunk-step) move does before moving. A
+// sticky range is kept, so the move extends it.
+func (self *MainViewController) collapseForLineMove() {
+	sel := self.diffSelectState()
+	if sel.Mode == types.DiffSelectModeHunk {
+		sel.Mode = types.DiffSelectModeLine
+		self.context.GetView().CancelRangeSelect()
+		return
+	}
+	self.collapseNonStickyRange()
+}
+
+// collapseNonStickyRange drops a range that only grows while shift is held back to a
+// single line at the cursor.
+func (self *MainViewController) collapseNonStickyRange() {
+	sel := self.diffSelectState()
+	if sel.Mode == types.DiffSelectModeRange && !sel.RangeIsSticky {
+		sel.Mode = types.DiffSelectModeLine
+		self.context.GetView().CancelRangeSelect()
+	}
+}
+
+// adjustSelection moves the selection by delta view lines, for the plain up/down and
+// page keys. In hunk mode a single-line step jumps to the adjacent block, while a
+// larger page step drops out of hunk mode first. A non-sticky range collapses back to
+// a single line on a plain move. With no selection — non-diff content — it scrolls.
+func (self *MainViewController) adjustSelection(delta int) {
+	if !self.context.GetView().Highlight {
+		self.handleLineChange(delta)
+		return
+	}
+	if self.diffSelectState().Mode == types.DiffSelectModeHunk && (delta == 1 || delta == -1) {
+		self.navigate(self.c.Helpers().DiffLine.AdjacentChangeBlock, delta > 0, false)
+		return
+	}
+	self.collapseForLineMove()
+	self.moveCursor(delta)
+}
+
+// selectAbsoluteLine moves the selection to a specific view line — the top or bottom
+// of the diff — dropping hunk mode and a non-sticky range like a plain move does.
+func (self *MainViewController) selectAbsoluteLine(target int) {
+	self.collapseForLineMove()
+	showSelectionAtLine(self.context.GetView(), target, true)
+}
+
+// selectingRange reports whether a range selection is currently active: we're in
+// range mode and either it's sticky or the anchor and cursor differ, i.e. a
+// non-sticky range that has actually been extended.
+func (self *MainViewController) selectingRange() bool {
+	if self.diffSelectState().Mode != types.DiffSelectModeRange {
+		return false
+	}
+	start, end := self.context.GetView().SelectedLineRange()
+	return self.diffSelectState().RangeIsSticky || start != end
+}
+
+// toggleSelectHunk switches between selecting the change block around the cursor and
+// a single line.
+func (self *MainViewController) toggleSelectHunk() error {
+	v := self.context.GetView()
+	if !v.Highlight {
+		return nil
+	}
+	sel := self.diffSelectState()
+	if sel.Mode == types.DiffSelectModeHunk {
+		sel.Mode = types.DiffSelectModeLine
+		v.CancelRangeSelect()
+	} else {
+		sel.Mode = types.DiffSelectModeHunk
+		sel.UserEnabledHunkMode = true
+		self.selectHunkAround(v.SelectedLineIdx(), true)
+	}
+	return nil
+}
+
+// toggleRangeSelect starts or cancels a sticky range selection, which the plain
+// up/down keys extend.
+func (self *MainViewController) toggleRangeSelect() error {
+	v := self.context.GetView()
+	if !v.Highlight {
+		return nil
+	}
+	sel := self.diffSelectState()
+	if self.selectingRange() {
+		sel.Mode = types.DiffSelectModeLine
+		sel.RangeIsSticky = false
+		v.CancelRangeSelect()
+	} else {
+		sel.Mode = types.DiffSelectModeRange
+		sel.RangeIsSticky = true
+		v.SetRangeSelectStart(v.SelectedLineIdx())
+	}
+	return nil
+}
+
+// extendRange grows a non-sticky range selection by one line in response to
+// shift+up/down, starting one at the cursor if there isn't one yet.
+func (self *MainViewController) extendRange(forward bool) error {
+	v := self.context.GetView()
+	if !v.Highlight {
+		return nil
+	}
+	sel := self.diffSelectState()
+	if !self.selectingRange() {
+		sel.Mode = types.DiffSelectModeRange
+		v.SetRangeSelectStart(v.SelectedLineIdx())
+	}
+	sel.RangeIsSticky = false
+	if forward {
+		self.moveCursor(1)
+	} else {
+		self.moveCursor(-1)
+	}
+	return nil
+}
+
+func (self *MainViewController) extendRangeUp() error {
+	return self.extendRange(false)
+}
+
+func (self *MainViewController) extendRangeDown() error {
+	return self.extendRange(true)
+}
+
+func (self *MainViewController) handleLineChange(delta int) {
+	v := self.context.GetView()
+	if delta < 0 {
+		v.ScrollUp(-delta)
+	} else {
+		v.ScrollDown(delta)
+		self.c.ReadLinesToFillView(v)
+	}
+}
+
+func (self *MainViewController) handlePrevLine() error {
+	self.adjustSelection(-1)
+	return nil
+}
+
+func (self *MainViewController) handleNextLine() error {
+	self.adjustSelection(1)
+	return nil
+}
+
+func (self *MainViewController) handlePrevPage() error {
+	self.adjustSelection(-self.context.GetViewTrait().PageDelta())
+	return nil
+}
+
+func (self *MainViewController) handleNextPage() error {
+	self.adjustSelection(self.context.GetViewTrait().PageDelta())
+	return nil
+}
+
+func (self *MainViewController) handleGotoTop() error {
+	v := self.context.GetView()
+	if !v.Highlight {
+		self.handleLineChange(-v.ViewLinesHeight())
+		return nil
+	}
+	self.selectAbsoluteLine(0)
+	return nil
+}
+
+func (self *MainViewController) handleGotoBottom() error {
+	if manager := self.c.GetViewBufferManagerForView(self.context.GetView()); manager != nil {
+		manager.ReadToEnd(func() {
+			self.c.OnUIThread(func() error {
+				v := self.context.GetView()
+				if !v.Highlight {
+					self.handleLineChange(v.ViewLinesHeight())
+					return nil
+				}
+				self.selectAbsoluteLine(v.ViewLinesHeight() - 1)
+				return nil
+			})
+		})
+	}
 
 	return nil
 }
 
+func (self *MainViewController) editLine() error {
+	view := self.context.GetView()
+	if !view.Highlight {
+		return nil
+	}
+
+	info, ok := self.c.Helpers().DiffLine.GetDiffLineInfo(view, view.SelectedLineIdx())
+	if !ok {
+		return nil
+	}
+
+	// A file-header row points at the file as a whole rather than at a line in it, so
+	// it opens the file without jumping anywhere — as pressing edit on a file in a side
+	// panel does.
+	if info.Type == types.DiffLineFileHeader {
+		return self.c.Helpers().Files.EditFiles([]string{info.Path})
+	}
+
+	// The diff may be of an older commit, whose line numbers aren't the file's current
+	// ones, so they have to be carried forward before we can point an editor at them.
+	lineNumber := self.c.Helpers().Diff.AdjustLineNumber(info.Path, info.NewLine, self.context.GetViewName())
+	return self.c.Helpers().Files.EditFileAtLine(info.Path, lineNumber)
+}
+
 func (self *MainViewController) openSearch() error {
 	if manager := self.c.GetViewBufferManagerForView(self.context.GetView()); manager != nil {
 		manager.ReadToEnd(func() {

pkg/gui/controllers/switch_to_focused_main_view_controller.go

@@ -2,6 +2,7 @@ package controllers
 
 import (
 	"github.com/jesseduffield/lazygit/pkg/gocui"
+	"github.com/jesseduffield/lazygit/pkg/gui/context"
 	"github.com/jesseduffield/lazygit/pkg/gui/types"
 )
 
@@ -61,21 +62,24 @@ func (self *SwitchToFocusedMainViewController) Context() types.Context {
 }
 
 func (self *SwitchToFocusedMainViewController) onClickMain(opts gocui.ViewMouseBindingOpts) error {
-	return self.focusMainView(self.c.Contexts().Normal)
+	return self.focusMainView(self.c.Contexts().Normal, opts.Y)
 }
 
 func (self *SwitchToFocusedMainViewController) onClickSecondary(opts gocui.ViewMouseBindingOpts) error {
-	return self.focusMainView(self.c.Contexts().NormalSecondary)
+	return self.focusMainView(self.c.Contexts().NormalSecondary, opts.Y)
 }
 
 func (self *SwitchToFocusedMainViewController) handleFocusMainView() error {
-	return self.focusMainView(self.c.Contexts().Normal)
+	return self.focusMainView(self.c.Contexts().Normal, -1)
 }
 
-func (self *SwitchToFocusedMainViewController) focusMainView(mainViewContext types.Context) error {
-	if context, ok := mainViewContext.(types.ISearchableContext); ok {
-		context.ClearSearchString()
-	}
+func (self *SwitchToFocusedMainViewController) focusMainView(mainViewContext *context.MainContext, clickedLineIdx int) error {
+	mainViewContext.ClearSearchString()
 	self.c.Context().Push(mainViewContext, types.OnFocusOpts{})
+
+	if _, ok := self.context.(types.DiffMainViewContext); ok {
+		establishDiffSelection(self.c, mainViewContext, clickedLineIdx)
+	}
+
 	return nil
 }

pkg/gui/controllers/toggle_whitespace_action.go

@@ -27,6 +27,12 @@ func (self *ToggleWhitespaceAction) Call() error {
 
 	self.c.UserConfig().Git.IgnoreWhitespaceInDiffView = !self.c.UserConfig().Git.IgnoreWhitespaceInDiffView
 
+	// You toggle this to see whether what you are looking at is more than
+	// reindentation, so that is the thing to keep in front of you — even though
+	// ignoring whitespace, unlike the other ways of re-rendering a diff, can take
+	// the line away entirely along with the hunk or file it was in.
+	self.c.Helpers().DiffLine.PreserveDiffPositionOnRerender(self.c.Contexts().Normal.GetView())
+	self.c.Helpers().DiffLine.PreserveDiffPositionOnRerender(self.c.Contexts().NormalSecondary.GetView())
 	self.c.Context().CurrentSide().HandleRenderToMain()
 	return nil
 }

pkg/gui/controllers/view_selection_controller.go

@@ -1,100 +0,0 @@
-package controllers
-
-import (
-	"github.com/jesseduffield/lazygit/pkg/gocui"
-	"github.com/jesseduffield/lazygit/pkg/gui/types"
-)
-
-type ViewSelectionControllerFactory struct {
-	c *ControllerCommon
-}
-
-func NewViewSelectionControllerFactory(c *ControllerCommon) *ViewSelectionControllerFactory {
-	return &ViewSelectionControllerFactory{
-		c: c,
-	}
-}
-
-func (self *ViewSelectionControllerFactory) Create(context types.Context) types.IController {
-	return &ViewSelectionController{
-		baseController: baseController{},
-		c:              self.c,
-		context:        context,
-	}
-}
-
-type ViewSelectionController struct {
-	baseController
-	c *ControllerCommon
-
-	context types.Context
-}
-
-func (self *ViewSelectionController) Context() types.Context {
-	return self.context
-}
-
-func (self *ViewSelectionController) GetKeybindings(opts types.KeybindingsOpts) []*types.Binding {
-	return []*types.Binding{
-		{Tag: "navigation", Keys: opts.GetKeys(opts.Config.Universal.PrevItem), Handler: self.handlePrevLine},
-		{Tag: "navigation", Keys: opts.GetKeys(opts.Config.Universal.NextItem), Handler: self.handleNextLine},
-		{Tag: "navigation", Keys: opts.GetKeys(opts.Config.Universal.PrevPage), Handler: self.handlePrevPage, Description: self.c.Tr.PrevPage},
-		{Tag: "navigation", Keys: opts.GetKeys(opts.Config.Universal.NextPage), Handler: self.handleNextPage, Description: self.c.Tr.NextPage},
-		{Tag: "navigation", Keys: opts.GetKeys(opts.Config.Universal.GotoTop), Handler: self.handleGotoTop, Description: self.c.Tr.GotoTop},
-		{Tag: "navigation", Keys: opts.GetKeys(opts.Config.Universal.GotoBottom), Handler: self.handleGotoBottom, Description: self.c.Tr.GotoBottom},
-	}
-}
-
-func (self *ViewSelectionController) GetMouseKeybindings(opts types.KeybindingsOpts) []*gocui.ViewMouseBinding {
-	return []*gocui.ViewMouseBinding{}
-}
-
-func (self *ViewSelectionController) handleLineChange(delta int) {
-	v := self.Context().GetView()
-	if delta < 0 {
-		v.ScrollUp(-delta)
-	} else {
-		v.ScrollDown(delta)
-		self.c.ReadLinesToFillView(v)
-	}
-}
-
-func (self *ViewSelectionController) handlePrevLine() error {
-	self.handleLineChange(-1)
-	return nil
-}
-
-func (self *ViewSelectionController) handleNextLine() error {
-	self.handleLineChange(1)
-	return nil
-}
-
-func (self *ViewSelectionController) handlePrevPage() error {
-	self.handleLineChange(-self.context.GetViewTrait().PageDelta())
-	return nil
-}
-
-func (self *ViewSelectionController) handleNextPage() error {
-	self.handleLineChange(self.context.GetViewTrait().PageDelta())
-	return nil
-}
-
-func (self *ViewSelectionController) handleGotoTop() error {
-	v := self.Context().GetView()
-	self.handleLineChange(-v.ViewLinesHeight())
-	return nil
-}
-
-func (self *ViewSelectionController) handleGotoBottom() error {
-	if manager := self.c.GetViewBufferManagerForView(self.context.GetView()); manager != nil {
-		manager.ReadToEnd(func() {
-			self.c.OnUIThread(func() error {
-				v := self.Context().GetView()
-				self.handleLineChange(v.ViewLinesHeight())
-				return nil
-			})
-		})
-	}
-
-	return nil
-}

pkg/gui/main_panels.go

@@ -117,7 +117,7 @@ func (gui *Gui) refreshMainViews(opts types.RefreshMainOpts) {
 	if opts.Secondary != nil {
 		gui.RefreshMainView(opts.Secondary, opts.Pair.Secondary)
 	} else if opts.Pair.Secondary != nil {
-		opts.Pair.Secondary.GetView().Clear()
+		gui.clearMainView(opts.Pair.Secondary)
 	}
 
 	// Reset the scroll positions of all the other main views. We do this after
@@ -137,6 +137,158 @@ func (gui *Gui) refreshMainViews(opts types.RefreshMainOpts) {
 	gui.splitMainPanel(opts.Secondary != nil)
 }
 
+// clampDiffSelectionToContent brings the focused main view's selection back onto the
+// content when the render that just finished left the diff with fewer lines than the
+// selection was on — a diff renderer that renders the same diff more compactly, a
+// smaller context size. That selection lives in the view rather than in a model, so
+// nothing else re-derives it, and past the end of the content it isn't drawn at all,
+// which reads as having no selection until an arrow key brings it back.
+//
+// Called at end of input, when the content is final: doing it while the render is
+// still loading would drag the selection to a line that only looks like the last one.
+// Only these two views need it; every other view's selection is derived from a model
+// as it renders, and so is clamped along with it.
+func (gui *Gui) clampDiffSelectionToContent(view *gocui.View) {
+	if gui.mainContextForView(view) == nil {
+		return
+	}
+	if !view.Highlight {
+		return
+	}
+
+	if lastLine := view.ViewLinesHeight() - 1; view.SelectedLineIdx() > lastLine {
+		view.FocusPoint(0, max(0, lastLine), true)
+	}
+}
+
+// clearMainView empties a pane that is being given nothing to show, selection and all.
+func (gui *Gui) clearMainView(mainContext types.Context) {
+	mainContext.GetView().Clear()
+	mainContext.SetHasSelectableContent(false)
+	gui.State.ContextMgr.UpdateSelectionHighlights()
+}
+
+// updateDiffSelectionVisibility works out whether a main pane holds anything for a
+// selection to sit on, from what it is now showing: only beneath a panel whose main
+// view is a diff, and only while that diff holds something to select — never over a
+// message like "No changed files", and never over a diff with nothing in it, such as a
+// binary file's or an empty commit's. Whether the selection is then drawn, and drawn as
+// the active one, follows from the context stack.
+//
+// It is asked wherever the pane's content changes: as a string is rendered, at the
+// paint that reveals a command's output, with every further batch of that output, and
+// once it has been read to the end. contentIsComplete tells those apart, since a render
+// still being read can leave the question open (see diffPaneHasSomethingToSelect). The
+// pane never answers from the render before it, and a render that leaves the question
+// open is read on until it doesn't, so the answer is always about what is there.
+func (gui *Gui) updateDiffSelectionVisibility(view *gocui.View, contentIsComplete bool) {
+	mainContext := gui.mainContextForView(view)
+	if mainContext == nil {
+		return
+	}
+
+	gui.dropAnAnswerAboutAnotherRender(mainContext, view)
+
+	if hasSomethingToSelect, known := gui.diffPaneHasSomethingToSelect(
+		mainContext, view, contentIsComplete,
+	); known {
+		mainContext.SetHasSelectableContent(hasSomethingToSelect)
+		gui.State.ContextMgr.UpdateSelectionHighlights()
+	} else {
+		gui.readOnUntilTheDiffPaneCanTell(view)
+	}
+}
+
+// dropAnAnswerAboutAnotherRender takes away what the pane worked out about the content
+// of an earlier render, so that this one starts from no answer rather than inheriting
+// one. An answer about other content says nothing about this content: carried over, it
+// shows a selection over a diff that may have nothing to select, or hides one over a
+// diff that has.
+//
+// A re-render of the same content keeps its answer, and with it the selection drawn
+// over it, since that answer is still about what the pane is showing.
+func (gui *Gui) dropAnAnswerAboutAnotherRender(mainContext *context.MainContext, view *gocui.View) {
+	manager := gui.getViewBufferManagerForView(view)
+	if manager == nil {
+		return
+	}
+
+	if key := manager.GetTaskKey(); key != mainContext.SelectableContentRenderKey() {
+		mainContext.SetSelectableContentRenderKey(key)
+		mainContext.SetHasSelectableContent(false)
+		gui.State.ContextMgr.UpdateSelectionHighlights()
+	}
+}
+
+// readOnUntilTheDiffPaneCanTell keeps a render going past the lines that were asked of
+// it, while the pane still can't say whether there is anything in it to select.
+//
+// A render is asked for as many lines as the scrollbar needs (see
+// linesToReadFromCmdTask), and what a commit's diff opens with can run past that: the
+// diffstat of a commit touching thousands of files, or a commit message thousands of
+// lines long. Without this the pane would be left with no answer until the user
+// scrolled far enough to ask for the rest themselves, which is no way to find out
+// whether a diff can be acted on. Another render's worth is asked for each time, so the
+// reading stops soon after the first change line, and only runs to the end of a diff
+// that has none.
+func (gui *Gui) readOnUntilTheDiffPaneCanTell(view *gocui.View) {
+	manager := gui.getViewBufferManagerForView(view)
+	if manager == nil {
+		return
+	}
+
+	step := gui.linesToReadFromCmdTask(view).Total
+	if step < 0 {
+		// A view that is being searched is already being read to the end.
+		return
+	}
+	manager.ReadLinesAndWait(view.LinesHeight() + step)
+}
+
+// diffPaneHasSomethingToSelect answers whether the given main pane holds anything for a
+// selection to sit on, from what it is showing so far. known is false while a render
+// still being read leaves the question open.
+func (gui *Gui) diffPaneHasSomethingToSelect(
+	mainContext *context.MainContext, view *gocui.View, contentIsComplete bool,
+) (bool, bool) {
+	if _, showsDiff := gui.State.ContextMgr.CurrentSide().(types.DiffMainViewContext); !showsDiff {
+		// Under a panel that shows no diff there is nothing to select whatever the pane
+		// ends up holding, so this needs no content to answer. Answering it now matters,
+		// because a render may never reach an end. The rest of a long commit log is read
+		// only as far as the user scrolls, and until then the pane would go on showing
+		// the selection it was left with under the panel before.
+		return false, true
+	}
+
+	if !contentIsComplete && mainContext.HasSelectableContent() {
+		// This render has already found something to select, and its content only grows
+		// from here, so there is nothing to ask again — nor to read the diff for. An
+		// answer the render before it gave has been dropped by now (see
+		// dropAnAnswerAboutAnotherRender), so this really is about the content in hand.
+		return true, true
+	}
+
+	hasChangeLines := gui.helpers.DiffLine.ViewHasChangeLines(view)
+
+	// One change line among those read settles it. Finding none in a render that is
+	// still going may only mean the changes are in the part still to come. A commit's
+	// diff opens with a diffstat, and for a commit touching hundreds of files that runs
+	// well past the screenful the first paint reveals, so that answer waits.
+	return hasChangeLines, contentIsComplete || hasChangeLines
+}
+
+// mainContextForView returns the context of the main pane the given view is, or nil for
+// any other view.
+func (gui *Gui) mainContextForView(view *gocui.View) *context.MainContext {
+	switch view {
+	case gui.Views.Main:
+		return gui.State.Contexts.Normal
+	case gui.Views.Secondary:
+		return gui.State.Contexts.NormalSecondary
+	}
+	return nil
+}
+
 func (gui *Gui) splitMainPanel(splitMainPanel bool) {
 	gui.State.SplitMainPanel = splitMainPanel
 }

pkg/gui/tasks_adapter.go

@@ -91,6 +91,7 @@ func (gui *Gui) newStringTaskWithoutScroll(view *gocui.View, str string) error {
 	f := func(tasks.TaskOpts) error {
 		return gui.g.OnUIThreadAndWaitBackground(func() {
 			gui.c.SetViewContent(view, str)
+			gui.updateDiffSelectionVisibility(view, true)
 			gui.reApplySearch(view)
 		})
 	}
@@ -109,6 +110,7 @@ func (gui *Gui) newStringTaskWithScroll(view *gocui.View, str string, originX in
 		return gui.g.OnUIThreadAndWaitBackground(func() {
 			gui.c.SetViewContent(view, str)
 			view.SetOrigin(originX, originY)
+			gui.updateDiffSelectionVisibility(view, true)
 			gui.reApplySearch(view)
 		})
 	}
@@ -127,6 +129,7 @@ func (gui *Gui) newStringTaskWithKey(view *gocui.View, str string, key string) e
 		return gui.g.OnUIThreadAndWaitBackground(func() {
 			gui.c.ResetViewOrigin(view)
 			gui.c.SetViewContent(view, str)
+			gui.updateDiffSelectionVisibility(view, true)
 			gui.reApplySearch(view)
 		})
 	}
@@ -154,10 +157,20 @@ func (gui *Gui) getManager(view *gocui.View) *tasks.ViewBufferManager {
 			func() {
 				// As the task reads more lines, the only thing that changes is the
 				// view's content (and its scrollbar); the window layout doesn't. So a
-				// content-only render is enough, and it's much cheaper than a full
-				// layout-and-redraw on every read - which matters a lot when reading
-				// a long diff, where reads happen repeatedly as the user scrolls.
-				gui.renderContentOnly()
+				// content-only render is enough — it skips the layout pass and redraws
+				// only the cells that differ — and it's much cheaper than a full
+				// layout-and-redraw on every read, which matters a lot when reading a
+				// long diff, where reads happen repeatedly as the user scrolls.
+				//
+				// What this draws is more of the content than the pane held a moment
+				// ago, so it is also where what is drawn over that content is worked
+				// out again. The screenful the first paint reveals may not be enough
+				// to say whether there is anything to select, and for a diff that
+				// opens with a long diffstat it isn't.
+				gui.c.OnUIThreadContentOnly(func() error {
+					gui.updateDiffSelectionVisibility(view, false)
+					return nil
+				})
 			},
 			func() {
 				// The content is fully loaded now, so let the scrollbar track it
@@ -174,13 +187,22 @@ func (gui *Gui) getManager(view *gocui.View) *tasks.ViewBufferManager {
 					view.SetOrigin(0, newOriginY)
 				}
 
+				gui.updateDiffSelectionVisibility(view, true)
+				gui.clampDiffSelectionToContent(view)
 				gui.reApplySearch(view)
 			},
 			func() {
 				view.SetOrigin(0, 0)
 			},
 			view.BeginOffscreenRender,
-			view.SwapInOffscreenRender,
+			func() {
+				view.SwapInOffscreenRender()
+
+				// The content the pane is being given is on display from here on, so
+				// what is drawn over it is settled against that content rather than
+				// against the render before it.
+				gui.updateDiffSelectionVisibility(view, false)
+			},
 			func() gocui.Task {
 				// A background task: rendering content into a view is display
 				// work, not lazygit driving a git operation, so it must not

pkg/gui/types/context.go

@@ -78,6 +78,7 @@ type IBaseContext interface {
 	// true if the context holds something for a selection to sit on. Contexts that
 	// don't show a selection at all say false, and so do lists with nothing in them.
 	HasSelectableContent() bool
+	SetHasSelectableContent(bool)
 
 	// the total height of the content that the view is currently showing
 	TotalContentHeight() int
@@ -102,9 +103,6 @@ type IBaseContext interface {
 	// that the generic ListController can be specialized by view-specific controllers.
 	// We'll need to think of a better way to do this.
 	AddOnDoubleClickFn(func() error)
-	// Likewise for the focused main view: we need this to communicate between a
-	// side panel controller and the focused main view controller.
-	AddOnClickFocusedMainViewFn(func(mainViewName string, clickedLineIdx int) error)
 	// Adding on to the above, this is so that a list-specific handler can register
 	// a hook for doing additional click handling
 	AddOnClickFn(func(opts gocui.ViewMouseBindingOpts) error)
@@ -180,6 +178,48 @@ type DiffableContext interface {
 	RefForAdjustingLineNumberInDiff() string
 }
 
+// DiffMainViewContext is implemented by the side panel contexts whose focused
+// main view shows a unified diff — files, local commits, sub-commits, reflog,
+// stash, and commit files — as opposed to a commit log or other non-diff content
+// (branches, tags, status, …). It is distinct from DiffableContext, which is
+// about producing a diff between two refs for the diff menu. The focused main
+// view shows a selection only for a context that implements this: a selection is
+// only meaningful where there are diff lines to act on (edit one, copy some, jump
+// by hunk or file). The returned type additionally classifies what acting on that
+// selection means.
+type DiffMainViewContext interface {
+	Context
+
+	GetDiffMainViewType() DiffMainViewType
+}
+
+// DiffMainViewType classifies what the focused main view's diff belongs to, which
+// decides what acting on a selection in it means.
+type DiffMainViewType int
+
+const (
+	// DiffMainViewTypeNone: the main view holds no diff, so there is nothing to
+	// select. A side panel that doesn't implement DiffMainViewContext counts as
+	// this; no panel returns it itself.
+	DiffMainViewTypeNone DiffMainViewType = iota
+	// DiffMainViewTypeStaging: the diff is the working tree's, so the selection can
+	// be staged or unstaged (the files panel).
+	DiffMainViewTypeStaging
+	// DiffMainViewTypePatchBuilding: the diff belongs to a commit, so the selection
+	// can be taken into a custom patch (the commit files / commits / sub-commits /
+	// reflog / stash panels).
+	DiffMainViewTypePatchBuilding
+)
+
+// DiffPaneContext is one of the two panes the main section can show, as the thing
+// that holds a diff with a selection in it. The panels that act on such a selection
+// are handed the pane it was made in, and speak to it through this.
+type DiffPaneContext interface {
+	Context
+
+	DiffSelectState() *DiffSelectState
+}
+
 type IListContext interface {
 	Context
 
@@ -275,10 +315,6 @@ type HasKeybindings interface {
 	// HandleFocus has already been called (so the main view is up to date). Should return nil if it
 	// decides not to do anything with the click.
 	GetOnClick() func(opts gocui.ViewMouseBindingOpts) error
-
-	// Implement this in a side-panel controller to get called when there's a click in the main view
-	// that belongs to your panel while the main view is already focused.
-	GetOnClickFocusedMainView() func(mainViewName string, clickedLineIdx int) error
 }
 
 type IController interface {
@@ -339,6 +375,8 @@ type IContextMgr interface {
 	CurrentSide() Context
 	CurrentPopup() []Context
 	NextInStack(context Context) Context
+	IsInStack(context Context) bool
+	UpdateSelectionHighlights()
 	IsCurrent(c Context) bool
 	IsCurrentOrParent(c Context) bool
 	ForEach(func(Context))

pkg/gui/types/diff_select.go

@@ -0,0 +1,28 @@
+package types
+
+// DiffSelectMode is how the focused main view's diff selection extends from the
+// cursor: a single line, a range from a fixed anchor, or the change block (hunk)
+// around the cursor.
+type DiffSelectMode int
+
+const (
+	DiffSelectModeLine DiffSelectMode = iota
+	DiffSelectModeRange
+	DiffSelectModeHunk
+)
+
+// DiffSelectState holds the *mode* of the focused main view's diff selection. The
+// selected line and the range anchor themselves live in the gocui view (its cursor
+// and range-select start), so only the mode lives here. It's on the context rather
+// than on the controller because the controller that drives the selection, the
+// controller that establishes it on focus, and the pane-toggle that seeds it on the
+// other pane all reach the pane through its context.
+type DiffSelectState struct {
+	Mode DiffSelectMode
+	// When a range is sticky, moving the cursor without holding shift extends the
+	// range; otherwise it collapses the range back to a single line.
+	RangeIsSticky bool
+	// Whether hunk mode was turned on by the user rather than being the configured
+	// default. This decides whether escape leaves hunk mode or leaves the view.
+	UserEnabledHunkMode bool
+}

pkg/gui/view_helpers.go

@@ -133,14 +133,6 @@ func (gui *Gui) render() {
 	gui.c.OnUIThread(func() error { return nil })
 }
 
-// renderContentOnly triggers a re-render that skips the layout pass and only
-// redraws the views whose content changed (relying on tcell's cell-level dirty
-// tracking to emit just the cells that actually differ). Use it when only a
-// view's content changed, not the window layout.
-func (gui *Gui) renderContentOnly() {
-	gui.c.OnUIThreadContentOnly(func() error { return nil })
-}
-
 // postRefreshUpdate is to be called on a context after the state that it depends on has been refreshed
 // if the context's view is set to another context we do nothing.
 // if the context's view is the current view we trigger a focus; re-selecting the current item.
@@ -154,7 +146,7 @@ func (gui *Gui) postRefreshUpdate(c types.Context, opts types.OnFocusOpts) {
 
 	// The render may have given the context its first item, or taken its last one
 	// away, which decides whether its view draws a selection at all.
-	gui.State.ContextMgr.updateSelectionHighlights()
+	gui.State.ContextMgr.UpdateSelectionHighlights()
 
 	if gui.currentViewName() == c.GetInputViewName() {
 		c.HandleFocus(opts)

pkg/gui/views.go

@@ -168,6 +168,15 @@ func (gui *Gui) createAllViews() error {
 
 	gui.Views.Snake.FgColor = gocui.ColorGreen
 
+	// The main views show diffs, whose own colors say what each line is: which side of
+	// the diff it's on, and often its syntax highlighting too. A selection painted
+	// across the whole line takes those colors over, which for a whole selected hunk
+	// leaves one unreadable block; so mark the selection with a narrow bar at the left
+	// edge instead, and leave the rest of the line to the diff. Two columns, enough to
+	// read as a marker rather than as an artefact.
+	gui.Views.Main.SelectedLineColorWidth = 2
+	gui.Views.Secondary.SelectedLineColorWidth = 2
+
 	return nil
 }
 

pkg/i18n/english.go

@@ -310,6 +310,7 @@ type TranslationSet struct {
 	DiscardSelectionTooltip               string
 	ToggleSelectHunk                      string
 	SelectHunk                            string
+	NothingToSelectInDiff                 string
 	SelectLineByLine                      string
 	ToggleSelectHunkTooltip               string
 	HunkStagingHint                       string
@@ -410,6 +411,8 @@ type TranslationSet struct {
 	AskQuestion                           string
 	PrevHunk                              string
 	NextHunk                              string
+	PrevFileInDiff                        string
+	NextFileInDiff                        string
 	PrevConflict                          string
 	NextConflict                          string
 	SelectPrevHunk                        string
@@ -1493,6 +1496,7 @@ func EnglishTranslationSet() *TranslationSet {
 		ToggleRangeSelect:                    "Toggle range select",
 		DismissRangeSelect:                   "Dismiss range select",
 		ToggleSelectHunk:                     "Toggle hunk selection",
+		NothingToSelectInDiff:                "There is nothing to select here",
 		SelectHunk:                           "Select hunks",
 		SelectLineByLine:                     "Select line-by-line",
 		ToggleSelectHunkTooltip:              "Toggle line-by-line vs. hunk selection mode.",
@@ -1598,6 +1602,8 @@ func EnglishTranslationSet() *TranslationSet {
 		AskQuestion:                          "Ask Question",
 		PrevHunk:                             "Go to previous hunk",
 		NextHunk:                             "Go to next hunk",
+		PrevFileInDiff:                       "Go to previous file",
+		NextFileInDiff:                       "Go to next file",
 		PrevConflict:                         "Previous conflict",
 		NextConflict:                         "Next conflict",
 		SelectPrevHunk:                       "Previous hunk",

pkg/integration/components/view_driver.go

@@ -141,6 +141,24 @@ func (self *ViewDriver) VisibleLines(matchers ...*TextMatcher) *ViewDriver {
 	return self.assertLines(originY, matchers...)
 }
 
+// Asserts on the line the view shows at the top of its viewport, i.e. on where the
+// view is scrolled to. It is a view line, so a wrapped line above it doesn't throw the
+// count off.
+func (self *ViewDriver) TopVisibleLine(matcher *TextMatcher) *ViewDriver {
+	self.t.assertWithRetries(func() (bool, string) {
+		view := self.getView()
+		lines := view.ViewBufferLines()
+		originY := view.OriginY()
+		if originY >= len(lines) {
+			return false, fmt.Sprintf("%s: the view is scrolled to line %d, but it has only %d lines",
+				self.context, originY, len(lines))
+		}
+		return matcher.context(fmt.Sprintf("%s top visible line", self.context)).test(lines[originY])
+	})
+
+	return self
+}
+
 // asserts that somewhere in the view there are consecutive lines matching the given matchers.
 func (self *ViewDriver) ContainsLines(matchers ...*TextMatcher) *ViewDriver {
 	self.validateMatchersPassed(matchers)
@@ -249,6 +267,21 @@ func (self *ViewDriver) SelectedLines(matchers ...*TextMatcher) *ViewDriver {
 	return self
 }
 
+// SelectedViewLineRange asserts which view lines the selection covers. View lines
+// count the wrapped segments a line is drawn as, so this can say whether a selection
+// covers a wrapped line to its end; SelectedLines, which reports the lines of the
+// content, cannot.
+func (self *ViewDriver) SelectedViewLineRange(first int, last int) *ViewDriver {
+	self.t.assertWithRetries(func() (bool, string) {
+		actualFirst, actualLast := self.getSelectedRange()
+		return actualFirst == first && actualLast == last,
+			fmt.Sprintf("%s: Expected view lines %d-%d to be selected, but %d-%d were.",
+				self.context, first, last, actualFirst, actualLast)
+	})
+
+	return self
+}
+
 func (self *ViewDriver) validateMatchersPassed(matchers []*TextMatcher) {
 	if len(matchers) < 1 {
 		self.t.fail("'Lines' methods require at least one matcher to be passed as an argument. If you are trying to assert that there are no lines, use .IsEmpty()")

pkg/integration/tests/main_view/click_selects_diff_line.go

@@ -0,0 +1,40 @@
+package main_view
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var ClickSelectsDiffLine = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Clicking a line of the main view's diff focuses the view and selects that line",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	SetupConfig: func(config *config.AppConfig) {
+		config.GetUserConfig().Gui.UseHunkModeInStagingView = false
+	},
+	SetupRepo: func(shell *Shell) {
+		shell.CreateFileAndAdd("file1", "one\ntwo\nthree\nfour\nfive\n")
+		shell.Commit("one")
+
+		shell.UpdateFile("file1", "one\ntwo\nTHREE\nfour\nfive\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused()
+
+		// The click both focuses the view and points at a line, so that line is selected
+		// rather than the first change.
+		t.Views().Main().
+			Click(0, 4).
+			IsFocused().
+			SelectionIsActive().
+			SelectedLines(
+				Contains("@@ -1,5 +1,5 @@"),
+			).
+			// A click in the already-focused view moves the selection to the clicked line.
+			Click(0, 7).
+			SelectedLines(
+				Contains("-three"),
+			)
+	},
+})

pkg/integration/tests/main_view/drag_range_with_autoscroll.go

@@ -0,0 +1,43 @@
+package main_view
+
+import (
+	"fmt"
+
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var DragRangeWithAutoscroll = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Keep scrolling while dragging a range selection at the edge of the focused main view",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	Width:        120,
+	Height:       30,
+	SetupConfig: func(config *config.AppConfig) {
+		config.GetUserConfig().Gui.UseHunkModeInStagingView = false
+	},
+	SetupRepo: func(shell *Shell) {
+		fileContent := "base\n"
+		shell.CreateFileAndAdd("file1", fileContent)
+		shell.Commit("one")
+		for i := 1; i <= 40; i++ {
+			fileContent += fmt.Sprintf("line %d\n", i)
+		}
+		shell.UpdateFile("file1", fileContent)
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			Press(keys.Universal.FocusMainView)
+
+		// The diff is longer than the view, so holding the pointer at the bottom edge has
+		// to keep scrolling and extending the selection rather than stopping there.
+		t.Views().Main().
+			IsFocused().
+			ClickAndHold(1, 6).
+			MouseMoveToBottom(1).
+			OriginYAtLeast(3).
+			SelectedLineIdxAtLeast(9).
+			MouseRelease()
+	},
+})

pkg/integration/tests/main_view/drag_selects_diff_line_range.go

@@ -0,0 +1,55 @@
+package main_view
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var DragSelectsDiffLineRange = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Dragging in the main view's diff selects the range from the line the drag started on",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	SetupConfig: func(config *config.AppConfig) {
+		config.GetUserConfig().Gui.UseHunkModeInStagingView = true
+	},
+	SetupRepo: func(shell *Shell) {
+		shell.CreateFileAndAdd("file1", "one\ntwo\nthree\nfour\nfive\n")
+		shell.Commit("one")
+
+		shell.UpdateFile("file1", "one\ntwo\nTHREE\nFOUR\nfive\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			Press(keys.Universal.FocusMainView)
+
+		// Hunk mode is on, so the mouse-down alone selects the whole block; the drag
+		// anchors the range where the mouse went down instead, one line at a time.
+		t.Views().Main().
+			IsFocused().
+			SelectedLines(
+				Contains("-three"),
+				Contains("-four"),
+				Contains("+THREE"),
+				Contains("+FOUR"),
+			).
+			ClickAndHold(0, 8).
+			MouseMove(0, 9).
+			SelectedLines(
+				Contains("-four"),
+				Contains("+THREE"),
+			).
+			MouseMove(0, 10).
+			SelectedLines(
+				Contains("-four"),
+				Contains("+THREE"),
+				Contains("+FOUR"),
+			).
+			MouseRelease().
+			SelectedLines(
+				Contains("-four"),
+				Contains("+THREE"),
+				Contains("+FOUR"),
+			)
+	},
+})

pkg/integration/tests/main_view/edit_selected_diff_line.go

@@ -0,0 +1,45 @@
+package main_view
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var EditSelectedDiffLine = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Open the selected line of the main view's diff in the editor, at that line of the file",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	SetupConfig: func(config *config.AppConfig) {
+		config.GetUserConfig().Gui.UseHunkModeInStagingView = false
+		config.GetUserConfig().OS.EditAtLine = "echo {{filename}}:{{line}} > edit-command"
+		config.GetUserConfig().OS.Edit = "echo {{filename}} > edit-command"
+	},
+	SetupRepo: func(shell *Shell) {
+		shell.CreateFileAndAdd("file1", "one\ntwo\nthree\nfour\nfive\n")
+		shell.Commit("one")
+
+		shell.UpdateFile("file1", "one\ntwo\nTHREE\nfour\nfive\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			Press(keys.Universal.FocusMainView)
+
+		// The addition is the third line of the file as it now stands.
+		t.Views().Main().
+			IsFocused().
+			NavigateToLine(Contains("+THREE")).
+			Press(keys.Universal.Edit)
+
+		// The editor is pointed at the file by absolute path.
+		t.FileSystem().FileContent("edit-command", Contains("/repo/file1:3\n"))
+
+		// A file header points at the file rather than at a line in it, so it opens the
+		// file with no line to jump to.
+		t.Views().Main().
+			NavigateToLine(Contains("diff --git a/file1 b/file1")).
+			Press(keys.Universal.Edit)
+
+		t.FileSystem().FileContent("edit-command", Contains("/repo/file1\n"))
+	},
+})

pkg/integration/tests/main_view/escape_dismisses_selection.go

@@ -0,0 +1,59 @@
+package main_view
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var EscapeDismissesSelection = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Escape gives up a range selection, then hunk mode, before leaving the focused main view",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	SetupConfig: func(config *config.AppConfig) {
+		config.GetUserConfig().Gui.UseHunkModeInStagingView = false
+	},
+	SetupRepo: func(shell *Shell) {
+		shell.CreateFileAndAdd("file1", "one\ntwo\nthree\nfour\nfive\n")
+		shell.Commit("one")
+
+		shell.UpdateFile("file1", "one\nTWO\nTHREE\nfour\nfive\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			Press(keys.Universal.FocusMainView)
+
+		// A sticky range: escape collapses it to the cursor line rather than leaving.
+		t.Views().Main().
+			IsFocused().
+			Press(keys.Universal.ToggleRangeSelect).
+			Press(keys.Universal.NextItem).
+			SelectedLines(
+				Contains("-two"),
+				Contains("-three"),
+			).
+			Press(keys.Universal.Return).
+			IsFocused().
+			SelectedLines(
+				Contains("-three"),
+			).
+			// Hunk mode the user asked for: escape goes back to line-by-line.
+			Press(keys.Main.ToggleSelectHunk).
+			SelectedLines(
+				Contains("-two"),
+				Contains("-three"),
+				Contains("+TWO"),
+				Contains("+THREE"),
+			).
+			Press(keys.Universal.Return).
+			IsFocused().
+			SelectedLines(
+				Contains("-two"),
+			).
+			// With nothing left to give up, escape leaves.
+			Press(keys.Universal.Return)
+
+		t.Views().Files().
+			IsFocused()
+	},
+})

pkg/integration/tests/main_view/file_navigation_scrolls_to_the_top.go

@@ -0,0 +1,88 @@
+package main_view
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var FileNavigationScrollsToTheTop = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Going to a file of a diff brings it to the top of the view, unless it is on screen already",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	Width:        100,
+	Height:       20,
+	SetupConfig: func(config *config.AppConfig) {
+		config.GetUserConfig().Gui.UseHunkModeInStagingView = false
+		// More context than fits on screen, so that a long file's change is further
+		// down than a screenful from the header naming the file.
+		config.GetUserConfig().Git.DiffContextSize = 30
+	},
+	SetupRepo: func(shell *Shell) {
+		lines := make([]string, 100)
+		for i := range lines {
+			lines[i] = fmt.Sprintf("line%03d", i+1)
+		}
+		long := strings.Join(lines, "\n") + "\n"
+		longChanged := strings.Replace(long, "line100", "LINE100", 1)
+
+		// Two long files with two short ones between them: the short ones are on screen
+		// together, and there is enough diff below them to scroll to.
+		shell.CreateFileAndAdd("aaa.txt", long)
+		shell.CreateFileAndAdd("bbb.txt", "one\ntwo\nthree\n")
+		shell.CreateFileAndAdd("ccc.txt", "one\ntwo\nthree\n")
+		shell.CreateFileAndAdd("ddd.txt", long)
+		shell.Commit("first commit")
+
+		shell.UpdateFileAndAdd("aaa.txt", longChanged)
+		shell.UpdateFileAndAdd("bbb.txt", "one\nTWO\nthree\n")
+		shell.UpdateFileAndAdd("ccc.txt", "one\nTWO\nthree\n")
+		shell.UpdateFileAndAdd("ddd.txt", longChanged)
+		shell.Commit("second commit")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Commits().
+			Focus().
+			Press(keys.Universal.FocusMainView)
+
+		// A file below the viewport becomes the top of it, so that as much of the file
+		// as possible is on screen.
+		t.Views().Main().
+			IsFocused().
+			SelectionIsActive().
+			Press(keys.Main.NextFile).
+			TopVisibleLine(Contains("diff --git a/bbb.txt b/bbb.txt")).
+			SelectedLines(
+				Contains("diff --git a/bbb.txt b/bbb.txt"),
+			).
+			// The next file is on screen already, so the view stays where it is and
+			// only the selection moves.
+			Press(keys.Main.NextFile).
+			TopVisibleLine(Contains("diff --git a/bbb.txt b/bbb.txt")).
+			SelectedLines(
+				Contains("diff --git a/ccc.txt b/ccc.txt"),
+			).
+			// Going back to a file above the viewport brings that one to the top.
+			Press(keys.Main.PrevFile).
+			Press(keys.Main.PrevFile).
+			TopVisibleLine(Contains("diff --git a/aaa.txt b/aaa.txt")).
+			SelectedLines(
+				Contains("diff --git a/aaa.txt b/aaa.txt"),
+			).
+			// In hunk mode the selection is the file's first change rather than the row
+			// the file begins at, and with this much context that change is further down
+			// than a screenful. The selection has to be on screen, so the alignment gives
+			// way and the selection is scrolled into view as any other jump's is.
+			Press(keys.Main.ToggleSelectHunk).
+			Press(keys.Main.NextFile).
+			Press(keys.Main.NextFile).
+			Press(keys.Main.NextFile).
+			SelectedLines(
+				Contains("-line100"),
+				Contains("+LINE100"),
+			).
+			SelectedLineIsVisible()
+	},
+})

pkg/integration/tests/main_view/hide_selection_when_changes_vanish.go

@@ -0,0 +1,47 @@
+package main_view
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var HideSelectionWhenChangesVanish = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "The main view's selection disappears along with the changes it was on",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	SetupConfig:  func(config *config.AppConfig) {},
+	SetupRepo: func(shell *Shell) {
+		shell.CreateFileAndAdd("file1", "one\ntwo\nthree\n")
+		shell.Commit("one")
+
+		shell.UpdateFile("file1", "one\ntwo\nTHREE\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			Press(keys.Universal.FocusMainView)
+
+		t.Views().Main().
+			IsFocused().
+			SelectionIsActive().
+			Press(keys.Universal.Return)
+
+		// Discarding the change leaves the main view with a placeholder to show, so the
+		// selection that was on the change goes with it rather than lingering over the
+		// message.
+		t.Views().Files().
+			IsFocused().
+			Press(keys.Universal.Remove).
+			Tap(func() {
+				t.ExpectPopup().Menu().
+					Title(Equals("Discard changes")).
+					Select(Contains("Discard all changes")).
+					Confirm()
+			}).
+			IsEmpty()
+
+		t.Views().Main().
+			Content(Contains("No changed files")).
+			SelectionIsHidden()
+	},
+})

pkg/integration/tests/main_view/keep_a_wrapped_line_covered_across_a_rerender.go

@@ -0,0 +1,60 @@
+package main_view
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var KeepAWrappedLineCoveredAcrossARerender = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "A selection over a line too long for the view still covers all of it after a re-render",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	Width:        80,
+	Height:       20,
+	SetupConfig: func(cfg *config.AppConfig) {
+		cfg.GetUserConfig().Gui.UseHunkModeInStagingView = true
+	},
+	SetupRepo: func(shell *Shell) {
+		long := strings.Repeat("word ", 40)
+		lines := make([]string, 20)
+		for i := range lines {
+			lines[i] = fmt.Sprintf("line%02d", i+1)
+		}
+		before := strings.Join(lines[:10], "\n") + "\n"
+		after := strings.Join(lines[10:], "\n") + "\n"
+
+		shell.CreateFileAndAdd("file1", before+long+"\n"+after)
+		shell.Commit("one")
+
+		shell.UpdateFile("file1", before+"CHANGED "+long+"\n"+after)
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			Press(keys.Universal.FocusMainView)
+
+		// The changed line is far too long for the view, so each half of the change
+		// is drawn as several view lines, and hunk mode selects all of them.
+		t.Views().Main().
+			IsFocused().
+			SelectedLines(
+				Contains("-word word"),
+				Contains("+CHANGED word"),
+			).
+			SelectedViewLineRange(8, 16).
+			// The same two lines of the diff, wrapped the same way, are still covered
+			// to their ends once the diff has been rendered again.
+			Press(keys.Universal.IncreaseContextInDiffView).
+			Tap(func() {
+				t.ExpectToast(Equals("Changed diff context size to 4"))
+			}).
+			SelectedLines(
+				Contains("-word word"),
+				Contains("+CHANGED word"),
+			).
+			SelectedViewLineRange(9, 17)
+	},
+})

pkg/integration/tests/main_view/keep_both_halves_of_a_change_selected.go

@@ -0,0 +1,68 @@
+package main_view
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var KeepBothHalvesOfAChangeSelected = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "A change selected on the one row a renderer draws it as is selected on both rows of a renderer that splits it",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	SetupConfig: func(cfg *config.AppConfig) {
+		cfg.GetUserConfig().Gui.UseHunkModeInStagingView = true
+		cfg.GetUserConfig().Git.DiffRenderers = []config.DiffRendererConfig{
+			// Git's own diff, which has a row for each half of a change. It announces
+			// the metadata protocol, so lazygit acts on its output rather than
+			// replacing it; it states no records of its own, so the rows are located
+			// by parsing the text, which still looks like a diff.
+			{Name: "unified", Command: `printf '\033]1717;1\007'; cat`},
+			// A renderer that puts the two halves of a change beside each other on one
+			// row. Only the records it states can say where those halves are; parsing
+			// the text could not. It ignores its input and prints this one.
+			{Name: "columns", Command: `printf '\033]1717;1\007'; ` +
+				`printf '\033]1717;1;f;;;file1\007file1\n'; ` +
+				`printf '\033]1717;1;h;1;;file1\007@@\n'; ` +
+				`printf '\033]1717;1;c;1;;file1\007one    one\n'; ` +
+				`printf '\033]1717;1;d;2;2;file1\007two    \033]1717;1;a;2;;file1\007TWO\n'; ` +
+				`printf '\033]1717;1;c;3;;file1\007three  three\n'; ` +
+				`cat >/dev/null`},
+		}
+	},
+	SetupRepo: func(shell *Shell) {
+		shell.CreateFileAndAdd("file1", "one\ntwo\nthree\n")
+		shell.Commit("one")
+
+		shell.UpdateFile("file1", "one\nTWO\nthree\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			Press(keys.Universal.FocusMainView)
+
+		t.Views().Main().
+			IsFocused().
+			SelectedLines(
+				Contains("-two"),
+				Contains("+TWO"),
+			).
+			// The change is one row here, and selecting it selects that row: both
+			// halves are on it.
+			Press(keys.Universal.CycleDiffRenderers).
+			Tap(func() {
+				t.ExpectToast(Equals("Diff renderer: columns (2 of 2)"))
+			}).
+			SelectedLines(
+				Contains("two    TWO"),
+			).
+			// Split apart again, the same change is the same two lines it was.
+			Press(keys.Universal.CycleDiffRenderers).
+			Tap(func() {
+				t.ExpectToast(Equals("Diff renderer: unified (1 of 2)"))
+			}).
+			SelectedLines(
+				Contains("-two"),
+				Contains("+TWO"),
+			)
+	},
+})

pkg/integration/tests/main_view/keep_position_by_the_visible_end_of_a_selection.go

@@ -0,0 +1,102 @@
+package main_view
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var KeepPositionByTheVisibleEndOfASelection = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "A re-render keeps the place by the end of a selected hunk that is on screen when its other end isn't",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	Width:        120,
+	Height:       30,
+	SetupConfig: func(cfg *config.AppConfig) {
+		cfg.GetUserConfig().Gui.UseHunkModeInStagingView = true
+		// One line per scroll, so that the test can put the top of the view exactly
+		// where it wants it.
+		cfg.GetUserConfig().Gui.ScrollHeight = 1
+	},
+	SetupRepo: func(shell *Shell) {
+		lines := make([]string, 60)
+		for i := range lines {
+			lines[i] = fmt.Sprintf("line%02d", i+1)
+		}
+		shell.CreateFileAndAdd("file1", strings.Join(lines, "\n")+"\n")
+		shell.Commit("one")
+
+		// A first change tall enough to be scrolled halfway out of the view, and more
+		// of them below it, so that a context-size change moves the lines further down
+		// the diff by more than it moves the first change.
+		for _, i := range []int{10, 11, 12, 13, 14, 15, 30, 45} {
+			lines[i-1] = strings.ToUpper(lines[i-1])
+		}
+		shell.UpdateFile("file1", strings.Join(lines, "\n")+"\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			Press(keys.Universal.FocusMainView)
+
+		t.Views().Main().
+			IsFocused().
+			SelectedLines(
+				Contains("-line10"),
+				Contains("-line11"),
+				Contains("-line12"),
+				Contains("-line13"),
+				Contains("-line14"),
+				Contains("-line15"),
+				Contains("+LINE10"),
+				Contains("+LINE11"),
+				Contains("+LINE12"),
+				Contains("+LINE13"),
+				Contains("+LINE14"),
+				Contains("+LINE15"),
+			).
+			SelectedLineIdx(8).
+			// Scroll past the start of the selected block, leaving its last lines on
+			// screen and the cursor above the top of the view.
+			Press(keys.Universal.ScrollDownMain).
+			Press(keys.Universal.ScrollDownMain).
+			Press(keys.Universal.ScrollDownMain).
+			Press(keys.Universal.ScrollDownMain).
+			Press(keys.Universal.ScrollDownMain).
+			Press(keys.Universal.ScrollDownMain).
+			Press(keys.Universal.ScrollDownMain).
+			Press(keys.Universal.ScrollDownMain).
+			Press(keys.Universal.ScrollDownMain).
+			Press(keys.Universal.ScrollDownMain).
+			Press(keys.Universal.ScrollDownMain).
+			Press(keys.Universal.ScrollDownMain).
+			Press(keys.Universal.ScrollDownMain).
+			Press(keys.Universal.ScrollDownMain).
+			OriginY(14).
+			Press(keys.Universal.IncreaseContextInDiffView).
+			Tap(func() {
+				t.ExpectToast(Equals("Changed diff context size to 4"))
+			}).
+			// The block's last line was the fifth row of the screen, and one context
+			// line more above the block puts it a line further down the diff: the view
+			// follows it, rather than the middle visible line, which the hunks below
+			// have pushed further still.
+			OriginY(15).
+			SelectedLines(
+				Contains("-line10"),
+				Contains("-line11"),
+				Contains("-line12"),
+				Contains("-line13"),
+				Contains("-line14"),
+				Contains("-line15"),
+				Contains("+LINE10"),
+				Contains("+LINE11"),
+				Contains("+LINE12"),
+				Contains("+LINE13"),
+				Contains("+LINE14"),
+				Contains("+LINE15"),
+			)
+	},
+})

pkg/integration/tests/main_view/keep_position_in_both_panes_when_changing_context_size.go

@@ -0,0 +1,71 @@
+package main_view
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var KeepPositionInBothPanesWhenChangingContextSize = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Changing the diff's context size keeps the place in the lower pane too, not only in the upper one",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	Width:        120,
+	Height:       30,
+	SetupConfig: func(cfg *config.AppConfig) {
+		cfg.GetUserConfig().Gui.UseHunkModeInStagingView = false
+	},
+	SetupRepo: func(shell *Shell) {
+		lines := make([]string, 40)
+		for i := range lines {
+			lines[i] = fmt.Sprintf("line%02d", i+1)
+		}
+		shell.CreateFileAndAdd("file1", strings.Join(lines, "\n")+"\n")
+		shell.Commit("one")
+
+		// Four staged changes, far enough apart that they stay four hunks as the
+		// context size grows, and one unstaged one to split the file's diff across
+		// both panes.
+		for _, i := range []int{5, 15, 25, 35} {
+			lines[i-1] = strings.ToUpper(lines[i-1])
+		}
+		shell.UpdateFile("file1", strings.Join(lines, "\n")+"\n")
+		shell.GitAddAll()
+
+		lines[39] = strings.ToUpper(lines[39])
+		shell.UpdateFile("file1", strings.Join(lines, "\n")+"\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			Press(keys.Universal.FocusMainView)
+
+		// The lower pane holds the staged changes; getting to the last of them scrolls
+		// it, so there is a position to lose.
+		t.Views().Main().
+			IsFocused().
+			PressTab()
+
+		t.Views().Secondary().
+			IsFocused().
+			Press(keys.Main.NextHunk).
+			Press(keys.Main.NextHunk).
+			Press(keys.Main.NextHunk).
+			SelectedLines(
+				Contains("-line35"),
+			).
+			SelectedLineIdx(35).
+			OriginY(14).
+			Press(keys.Universal.IncreaseContextInDiffView).
+			Tap(func() {
+				t.ExpectToast(Equals("Changed diff context size to 4"))
+			}).
+			SelectedLines(
+				Contains("-line35"),
+			).
+			SelectedLineIdx(42).
+			OriginY(21)
+	},
+})

pkg/integration/tests/main_view/keep_position_in_both_panes_when_ignoring_whitespace.go

@@ -0,0 +1,70 @@
+package main_view
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var KeepPositionInBothPanesWhenIgnoringWhitespace = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Ignoring whitespace keeps the place in the lower pane too, not only in the upper one",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	Width:        120,
+	Height:       30,
+	SetupConfig: func(cfg *config.AppConfig) {
+		cfg.GetUserConfig().Gui.UseHunkModeInStagingView = false
+	},
+	SetupRepo: func(shell *Shell) {
+		lines := make([]string, 60)
+		for i := range lines {
+			lines[i] = fmt.Sprintf("line%02d", i+1)
+		}
+		shell.CreateFileAndAdd("file1", strings.Join(lines, "\n")+"\n")
+		shell.Commit("one")
+
+		// Staged: real changes at lines 5, 25 and 45, and a whitespace-only one at 15,
+		// whose hunk goes when whitespace stops counting.
+		lines[4] = strings.ToUpper(lines[4])
+		lines[14] = " " + lines[14]
+		lines[24] = strings.ToUpper(lines[24])
+		lines[44] = strings.ToUpper(lines[44])
+		shell.UpdateFile("file1", strings.Join(lines, "\n")+"\n")
+		shell.GitAddAll()
+
+		// And one unstaged change, to split the file's diff across both panes.
+		lines[59] = strings.ToUpper(lines[59])
+		shell.UpdateFile("file1", strings.Join(lines, "\n")+"\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			Press(keys.Universal.FocusMainView)
+
+		t.Views().Main().
+			IsFocused().
+			PressTab()
+
+		t.Views().Secondary().
+			IsFocused().
+			Press(keys.Main.NextHunk).
+			Press(keys.Main.NextHunk).
+			Press(keys.Main.NextHunk).
+			SelectedLines(
+				Contains("-line45"),
+			).
+			SelectedLineIdx(35).
+			OriginY(14).
+			Press(keys.Universal.ToggleWhitespaceInDiffView).
+			// The hunk above this one held nothing but a whitespace change, so it is
+			// gone and has taken nine lines of the lower pane's diff with it — leaving
+			// the line we were on where it was on the screen.
+			SelectedLines(
+				Contains("-line45"),
+			).
+			SelectedLineIdx(26).
+			OriginY(5)
+	},
+})

pkg/integration/tests/main_view/keep_position_in_both_panes_when_switching_diff_renderers.go

@@ -0,0 +1,78 @@
+package main_view
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var KeepPositionInBothPanesWhenSwitchingDiffRenderers = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Switching to another diff renderer keeps the place in the lower pane too, not only in the upper one",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	Width:        120,
+	Height:       30,
+	SetupConfig: func(cfg *config.AppConfig) {
+		cfg.GetUserConfig().Gui.UseHunkModeInStagingView = false
+		// Renderers that speak the metadata protocol, so that focusing the main view
+		// keeps their rendering rather than falling back to git's own diff.
+		cfg.GetUserConfig().Git.DiffRenderers = []config.DiffRendererConfig{
+			{Name: "plain", Command: `printf '\033]1717;1\007'; cat`},
+			// The same diff, three lines further down the view. (Lines before the
+			// diff's own header aren't part of it, so it still reads the same.)
+			{Name: "banner", Command: `printf '\033]1717;1\007'; printf 'rendered for you\n\n\n'; cat`},
+		}
+	},
+	SetupRepo: func(shell *Shell) {
+		lines := make([]string, 40)
+		for i := range lines {
+			lines[i] = fmt.Sprintf("line%02d", i+1)
+		}
+		shell.CreateFileAndAdd("file1", strings.Join(lines, "\n")+"\n")
+		shell.Commit("one")
+
+		// Four staged changes to have a diff worth scrolling in the lower pane, and one
+		// unstaged one to split the file's diff across both panes.
+		for _, i := range []int{5, 15, 25, 35} {
+			lines[i-1] = strings.ToUpper(lines[i-1])
+		}
+		shell.UpdateFile("file1", strings.Join(lines, "\n")+"\n")
+		shell.GitAddAll()
+
+		lines[39] = strings.ToUpper(lines[39])
+		shell.UpdateFile("file1", strings.Join(lines, "\n")+"\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			Press(keys.Universal.FocusMainView)
+
+		t.Views().Main().
+			IsFocused().
+			PressTab()
+
+		t.Views().Secondary().
+			IsFocused().
+			Press(keys.Main.NextHunk).
+			Press(keys.Main.NextHunk).
+			Press(keys.Main.NextHunk).
+			SelectedLines(
+				Contains("-line35"),
+			).
+			SelectedLineIdx(35).
+			OriginY(14).
+			Press(keys.Universal.CycleDiffRenderers).
+			Tap(func() {
+				t.ExpectToast(Equals("Diff renderer: banner (2 of 2)"))
+			}).
+			// The banner pushed the whole diff three lines down, and the lower pane came
+			// along with it, just as the upper one would have.
+			SelectedLines(
+				Contains("-line35"),
+			).
+			SelectedLineIdx(38).
+			OriginY(17)
+	},
+})

pkg/integration/tests/main_view/keep_position_when_changing_context_size.go

@@ -0,0 +1,97 @@
+package main_view
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var KeepPositionWhenChangingContextSize = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Changing the diff's context size keeps the line you were looking at where it was",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	Width:        120,
+	Height:       30,
+	SetupConfig: func(cfg *config.AppConfig) {
+		cfg.GetUserConfig().Gui.UseHunkModeInStagingView = false
+	},
+	SetupRepo: func(shell *Shell) {
+		lines := make([]string, 40)
+		for i := range lines {
+			lines[i] = fmt.Sprintf("line%02d", i+1)
+		}
+		shell.CreateFileAndAdd("file1", strings.Join(lines, "\n")+"\n")
+		shell.Commit("one")
+
+		// Four changes, far enough apart that they stay four hunks as the context
+		// size grows.
+		for _, i := range []int{5, 15, 25, 35} {
+			lines[i-1] = strings.ToUpper(lines[i-1])
+		}
+		shell.UpdateFile("file1", strings.Join(lines, "\n")+"\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			Press(keys.Universal.FocusMainView)
+
+		t.Views().Main().
+			IsFocused().
+			Press(keys.Main.NextHunk).
+			Press(keys.Main.NextHunk).
+			Press(keys.Main.NextHunk).
+			SelectedLines(
+				Contains("-line35"),
+			).
+			// The diff is longer than the view, so getting to the last hunk scrolled
+			// it: the selected line sits 21 rows down the screen.
+			SelectedLineIdx(35).
+			OriginY(14).
+			Press(keys.Universal.IncreaseContextInDiffView).
+			Tap(func() {
+				t.ExpectToast(Equals("Changed diff context size to 4"))
+			}).
+			// A context line more on either side of each of the four hunks pushes the
+			// selected line seven lines further into the diff. The view follows it, so
+			// it is still the same line on the same screen row (42 - 21 = 21).
+			SelectedLines(
+				Contains("-line35"),
+			).
+			SelectedLineIdx(42).
+			OriginY(21).
+			Press(keys.Universal.DecreaseContextInDiffView).
+			Tap(func() {
+				t.ExpectToast(Equals("Changed diff context size to 3"))
+			}).
+			Press(keys.Universal.DecreaseContextInDiffView).
+			Tap(func() {
+				t.ExpectToast(Equals("Changed diff context size to 2"))
+			}).
+			// And the same the other way (28 - 21 = 7).
+			SelectedLines(
+				Contains("-line35"),
+			).
+			SelectedLineIdx(28).
+			OriginY(7).
+			// Leaving the view gives up the selection but not the scroll position, and
+			// with no selection to keep, it is the middle visible line that stays put.
+			PressEscape()
+
+		t.Views().Files().
+			IsFocused().
+			Press(keys.Universal.IncreaseContextInDiffView).
+			Tap(func() {
+				t.ExpectToast(Equals("Changed diff context size to 3"))
+			})
+
+		// The middle visible line here is a hunk's header, and a context-size change
+		// rewrites those — they name the lines the hunk covers. So the restore falls
+		// back to the nearest line that does survive, the context line just below it,
+		// and puts that back on the row it was on.
+		t.Views().Main().
+			SelectionIsHidden().
+			OriginY(12)
+	},
+})

pkg/integration/tests/main_view/keep_position_when_ignoring_whitespace.go

@@ -0,0 +1,85 @@
+package main_view
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var KeepPositionWhenIgnoringWhitespace = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Ignoring whitespace keeps the line you were looking at where it was, even when it turns into a context line",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	Width:        120,
+	Height:       30,
+	SetupConfig: func(cfg *config.AppConfig) {
+		cfg.GetUserConfig().Gui.UseHunkModeInStagingView = false
+	},
+	SetupRepo: func(shell *Shell) {
+		lines := make([]string, 40)
+		for i := range lines {
+			lines[i] = fmt.Sprintf("line%02d", i+1)
+		}
+		shell.CreateFileAndAdd("file1", strings.Join(lines, "\n")+"\n")
+		shell.Commit("one")
+
+		// Real changes at lines 5 and 25, whitespace-only ones at 15, 27 and 35. The
+		// one at 27 shares a hunk with the change at 25, so ignoring whitespace turns
+		// it into a context line rather than taking its hunk away.
+		lines[4] = strings.ToUpper(lines[4])
+		lines[14] = " " + lines[14]
+		lines[24] = strings.ToUpper(lines[24])
+		lines[26] = lines[26] + " "
+		lines[34] = " " + lines[34]
+		shell.UpdateFile("file1", strings.Join(lines, "\n")+"\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			Press(keys.Universal.FocusMainView)
+
+		t.Views().Main().
+			IsFocused().
+			Press(keys.Main.NextHunk).
+			Press(keys.Main.NextHunk).
+			SelectedLines(
+				Contains("-line25"),
+			).
+			SelectedLineIdx(26).
+			OriginY(14).
+			Press(keys.Universal.ToggleWhitespaceInDiffView).
+			// The hunk above this one held nothing but a whitespace change, so it is
+			// gone and has taken nine lines of diff with it. This is still the line we
+			// were on, on the row we were on (26 - 14 = 17 - 5).
+			SelectedLines(
+				Contains("-line25"),
+			).
+			SelectedLineIdx(17).
+			OriginY(5).
+			// And back again, whitespace and all.
+			Press(keys.Universal.ToggleWhitespaceInDiffView).
+			SelectedLines(
+				Contains("-line25"),
+			).
+			SelectedLineIdx(26).
+			OriginY(14).
+			// The whitespace-only change further down this hunk is a line of the file
+			// like any other: ignoring whitespace shows it as context instead of as a
+			// change, and that is still where we are.
+			Press(keys.Main.NextHunk).
+			Press(keys.Universal.NextItem).
+			SelectedLines(
+				Contains("+line27"),
+			).
+			SelectedLineIdx(30).
+			OriginY(14).
+			Press(keys.Universal.ToggleWhitespaceInDiffView).
+			SelectedLines(
+				Contains(" line27"),
+			).
+			SelectedLineIdx(20).
+			OriginY(4)
+	},
+})

pkg/integration/tests/main_view/keep_position_when_ignoring_whitespace_removes_it.go

@@ -0,0 +1,81 @@
+package main_view
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var KeepPositionWhenIgnoringWhitespaceRemovesIt = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Ignoring whitespace where that takes the line you were on out of the diff lands on the nearest line it kept",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	Width:        120,
+	Height:       30,
+	SetupConfig: func(cfg *config.AppConfig) {
+		cfg.GetUserConfig().Gui.UseHunkModeInStagingView = false
+	},
+	SetupRepo: func(shell *Shell) {
+		lines := make([]string, 40)
+		for i := range lines {
+			lines[i] = fmt.Sprintf("line%02d", i+1)
+		}
+		shell.CreateFileAndAdd("file1", strings.Join(lines, "\n")+"\n")
+		shell.CreateFileAndAdd("file2", "one\ntwo\nthree\n")
+		shell.Commit("one")
+
+		// Real changes at lines 5, 15 and 25, and a whitespace-only one at 35, far
+		// enough apart to be hunks of their own.
+		for _, i := range []int{5, 15, 25} {
+			lines[i-1] = strings.ToUpper(lines[i-1])
+		}
+		lines[34] = " " + lines[34]
+		shell.UpdateFile("file1", strings.Join(lines, "\n")+"\n")
+
+		// Nothing but reindentation, so ignoring whitespace leaves no diff at all.
+		shell.UpdateFile("file2", "  one\n  two\n  three\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			SelectNextItem().
+			SelectedLine(Contains("file1")).
+			Press(keys.Universal.FocusMainView)
+
+		t.Views().Main().
+			IsFocused().
+			Press(keys.Main.NextHunk).
+			Press(keys.Main.NextHunk).
+			Press(keys.Main.NextHunk).
+			SelectedLines(
+				Contains("-line35"),
+			).
+			SelectedLineIdx(35).
+			OriginY(14).
+			Press(keys.Universal.ToggleWhitespaceInDiffView).
+			// That hunk was a whitespace change and nothing else, so ignoring
+			// whitespace takes it — and the context around it — out of the diff
+			// entirely. The nearest line the diff kept is the last line of the hunk
+			// above, so that is where the selection lands; it goes back on the row it
+			// was on itself, which leaves everything above it exactly where it was.
+			SelectedLines(
+				Contains(" line28"),
+			).
+			SelectedLineIdx(30).
+			OriginY(14).
+			// The whole diff can go this way, and then there is nothing to land on.
+			Press(keys.Universal.ToggleWhitespaceInDiffView).
+			PressEscape()
+
+		t.Views().Files().
+			IsFocused().
+			SelectNextItem().
+			SelectedLine(Contains("file2")).
+			Press(keys.Universal.ToggleWhitespaceInDiffView)
+
+		t.Views().Main().
+			Content(Equals(""))
+	},
+})

pkg/integration/tests/main_view/keep_position_when_switching_diff_renderers.go

@@ -0,0 +1,75 @@
+package main_view
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var KeepPositionWhenSwitchingDiffRenderers = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Switching to another diff renderer keeps the line you were looking at where it was",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	Width:        120,
+	Height:       30,
+	SetupConfig: func(cfg *config.AppConfig) {
+		cfg.GetUserConfig().Gui.UseHunkModeInStagingView = false
+		cfg.GetUserConfig().Git.DiffRenderers = []config.DiffRendererConfig{
+			{Name: "plain", Command: "cat"},
+			// The same diff, three lines further down the view. (Lines before the
+			// diff's own header aren't part of it, so it still reads the same.)
+			{Name: "banner", Command: `printf 'rendered for you\n\n\n'; cat`},
+		}
+	},
+	SetupRepo: func(shell *Shell) {
+		lines := make([]string, 40)
+		for i := range lines {
+			lines[i] = fmt.Sprintf("line%02d", i+1)
+		}
+		shell.CreateFileAndAdd("file1", strings.Join(lines, "\n")+"\n")
+		shell.Commit("one")
+
+		for _, i := range []int{5, 15, 25, 35} {
+			lines[i-1] = strings.ToUpper(lines[i-1])
+		}
+		shell.UpdateFile("file1", strings.Join(lines, "\n")+"\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			Press(keys.Universal.FocusMainView)
+
+		t.Views().Main().
+			IsFocused().
+			Press(keys.Main.NextHunk).
+			Press(keys.Main.NextHunk).
+			Press(keys.Main.NextHunk).
+			SelectedLines(
+				Contains("-line35"),
+			).
+			SelectedLineIdx(35).
+			OriginY(14).
+			Press(keys.Universal.CycleDiffRenderers).
+			Tap(func() {
+				t.ExpectToast(Equals("Diff renderer: banner (2 of 2)"))
+			}).
+			// The banner pushed the whole diff three lines down, and the view came
+			// along with it: the same line on the same screen row (38 - 17 = 21).
+			SelectedLines(
+				Contains("-line35"),
+			).
+			SelectedLineIdx(38).
+			OriginY(17).
+			Press(keys.Universal.CycleDiffRenderers).
+			Tap(func() {
+				t.ExpectToast(Equals("Diff renderer: plain (1 of 2)"))
+			}).
+			SelectedLines(
+				Contains("-line35"),
+			).
+			SelectedLineIdx(35).
+			OriginY(14)
+	},
+})

pkg/integration/tests/main_view/keep_position_when_the_selection_is_off_screen.go

@@ -0,0 +1,65 @@
+package main_view
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var KeepPositionWhenTheSelectionIsOffScreen = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "A re-render keeps the lines that are on screen where they are, not a selection scrolled away from",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	Width:        120,
+	Height:       30,
+	SetupConfig: func(cfg *config.AppConfig) {
+		cfg.GetUserConfig().Gui.UseHunkModeInStagingView = false
+		// Half a diff per scroll, to leave the selection well behind in two presses.
+		cfg.GetUserConfig().Gui.ScrollHeight = 15
+	},
+	SetupRepo: func(shell *Shell) {
+		lines := make([]string, 60)
+		for i := range lines {
+			lines[i] = fmt.Sprintf("line%02d", i+1)
+		}
+		shell.CreateFileAndAdd("file1", strings.Join(lines, "\n")+"\n")
+		shell.Commit("one")
+
+		for _, i := range []int{5, 15, 25, 35, 45, 55} {
+			lines[i-1] = strings.ToUpper(lines[i-1])
+		}
+		shell.UpdateFile("file1", strings.Join(lines, "\n")+"\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			Press(keys.Universal.FocusMainView)
+
+		t.Views().Main().
+			IsFocused().
+			SelectedLines(
+				Contains("-line05"),
+			).
+			// Reading on past the selection leaves it far behind, off the top of the
+			// view.
+			Press(keys.Universal.ScrollDownMain).
+			Press(keys.Universal.ScrollDownMain).
+			OriginY(30).
+			Press(keys.Universal.DecreaseContextInDiffView).
+			Tap(func() {
+				t.ExpectToast(Equals("Changed diff context size to 2"))
+			}).
+			// A context line less on either side of the four hunks above what is on
+			// screen pulls it nine lines up the diff, and the view follows it there: the
+			// lines the user was reading are still on the rows they were on.
+			OriginY(21).
+			// The selection is where it always was, on its own line of the diff, rather
+			// than having been dragged back into view.
+			SelectedLines(
+				Contains("-line05"),
+			).
+			SelectedLineIdx(7)
+	},
+})

pkg/integration/tests/main_view/keep_scroll_when_the_diff_cant_be_read.go

@@ -0,0 +1,58 @@
+package main_view
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var KeepScrollWhenTheDiffCantBeRead = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Changing the context size under a diff renderer whose rows can't be placed keeps the scroll position rather than jumping to the top",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	Width:        120,
+	Height:       30,
+	SetupConfig: func(cfg *config.AppConfig) {
+		cfg.GetUserConfig().Gui.UseHunkModeInStagingView = false
+		// A renderer that says nothing about which line of which file each row shows,
+		// and mangles the diff enough that it can't be read back as one either: no line
+		// of it can be looked for in the re-render.
+		cfg.GetUserConfig().Git.DiffRenderers = []config.DiffRendererConfig{
+			{Name: "opaque", Command: `sed -e 's/^/| /'`},
+		}
+	},
+	SetupRepo: func(shell *Shell) {
+		lines := make([]string, 40)
+		for i := range lines {
+			lines[i] = fmt.Sprintf("line%02d", i+1)
+		}
+		shell.CreateFileAndAdd("file1", strings.Join(lines, "\n")+"\n")
+		shell.Commit("one")
+
+		for _, i := range []int{5, 15, 25, 35} {
+			lines[i-1] = strings.ToUpper(lines[i-1])
+		}
+		shell.UpdateFile("file1", strings.Join(lines, "\n")+"\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			Press(keys.Universal.ScrollDownMain).
+			Press(keys.Universal.ScrollDownMain).
+			Press(keys.Universal.ScrollDownMain)
+
+		t.Views().Main().
+			Content(Contains("| +LINE05")).
+			OriginY(6).
+			Tap(func() {
+				t.Views().Files().Press(keys.Universal.IncreaseContextInDiffView)
+				t.ExpectToast(Equals("Changed diff context size to 4"))
+			}).
+			// The re-render is a different command, and nothing in its output can be
+			// matched up with what was on screen, so the offset is all there is to keep —
+			// and it is a good deal closer than the top.
+			OriginY(6)
+	},
+})

pkg/integration/tests/main_view/keep_selected_range_when_changing_context_size.go

@@ -0,0 +1,123 @@
+package main_view
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var KeepSelectedRangeWhenChangingContextSize = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "A range selection still covers the same lines of the diff after the context size changes",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	Width:        120,
+	Height:       30,
+	SetupConfig: func(cfg *config.AppConfig) {
+		cfg.GetUserConfig().Gui.UseHunkModeInStagingView = false
+	},
+	SetupRepo: func(shell *Shell) {
+		lines := make([]string, 40)
+		for i := range lines {
+			lines[i] = fmt.Sprintf("line%02d", i+1)
+		}
+		shell.CreateFileAndAdd("file1", strings.Join(lines, "\n")+"\n")
+		shell.Commit("one")
+
+		for _, i := range []int{5, 15, 25, 35} {
+			lines[i-1] = strings.ToUpper(lines[i-1])
+		}
+		shell.UpdateFile("file1", strings.Join(lines, "\n")+"\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			Press(keys.Universal.FocusMainView)
+
+		// A range from a change down into the context below it, so that the cursor is
+		// on the last line of the selection and the other end is three lines above.
+		t.Views().Main().
+			IsFocused().
+			Press(keys.Main.NextHunk).
+			Press(keys.Main.NextHunk).
+			Press(keys.Universal.ToggleRangeSelect).
+			Press(keys.Universal.NextItem).
+			Press(keys.Universal.NextItem).
+			Press(keys.Universal.NextItem).
+			SelectedLines(
+				Contains("-line25"),
+				Contains("+LINE25"),
+				Contains(" line26"),
+				Contains(" line27"),
+			).
+			// Both ends are still lines of the diff with more context around the
+			// change, so the selection still covers the same four.
+			Press(keys.Universal.IncreaseContextInDiffView).
+			Tap(func() {
+				t.ExpectToast(Equals("Changed diff context size to 4"))
+			}).
+			SelectedLines(
+				Contains("-line25"),
+				Contains("+LINE25"),
+				Contains(" line26"),
+				Contains(" line27"),
+			).
+			// With a single line of context, the line the cursor was on is no longer in
+			// the diff. The end that survived stays put and the cursor lands on the
+			// nearest line that is left, so the selection shrinks with the diff.
+			Press(keys.Universal.DecreaseContextInDiffView).
+			Tap(func() {
+				t.ExpectToast(Equals("Changed diff context size to 3"))
+			}).
+			Press(keys.Universal.DecreaseContextInDiffView).
+			Tap(func() {
+				t.ExpectToast(Equals("Changed diff context size to 2"))
+			}).
+			Press(keys.Universal.DecreaseContextInDiffView).
+			Tap(func() {
+				t.ExpectToast(Equals("Changed diff context size to 1"))
+			}).
+			SelectedLines(
+				Contains("-line25"),
+				Contains("+LINE25"),
+				Contains(" line26"),
+			).
+			// The other way round: a range extended upwards, so that it is the far end
+			// that the shrinking context takes away. There is no guessing which line
+			// inherits it, so what is left is the line the cursor is on.
+			PressEscape().
+			Press(keys.Universal.IncreaseContextInDiffView).
+			Tap(func() {
+				t.ExpectToast(Equals("Changed diff context size to 2"))
+			}).
+			Press(keys.Universal.IncreaseContextInDiffView).
+			Tap(func() {
+				t.ExpectToast(Equals("Changed diff context size to 3"))
+			}).
+			SelectedLines(
+				Contains(" line26"),
+			).
+			Press(keys.Universal.NextItem).
+			Press(keys.Universal.RangeSelectUp).
+			Press(keys.Universal.RangeSelectUp).
+			Press(keys.Universal.RangeSelectUp).
+			SelectedLines(
+				Contains("-line25"),
+				Contains("+LINE25"),
+				Contains(" line26"),
+				Contains(" line27"),
+			).
+			Press(keys.Universal.DecreaseContextInDiffView).
+			Tap(func() {
+				t.ExpectToast(Equals("Changed diff context size to 2"))
+			}).
+			Press(keys.Universal.DecreaseContextInDiffView).
+			Tap(func() {
+				t.ExpectToast(Equals("Changed diff context size to 1"))
+			}).
+			SelectedLines(
+				Contains("-line25"),
+			)
+	},
+})

pkg/integration/tests/main_view/keep_selection_visible_when_diff_shrinks.go

@@ -0,0 +1,58 @@
+package main_view
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var KeepSelectionVisibleWhenDiffShrinks = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "The selection stays on the content when a re-render leaves the diff with fewer lines than the selection was on",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	SetupConfig: func(cfg *config.AppConfig) {
+		cfg.GetUserConfig().Gui.UseHunkModeInStagingView = false
+		cfg.GetUserConfig().Git.DiffRenderers = []config.DiffRendererConfig{
+			{Command: "cat"},
+			// The same diff in fewer lines, as a renderer that collapses or elides
+			// parts of it would give us: the addition at the end goes, and the hunk
+			// header says so, since a diff that contradicts its own header can't be
+			// read as one. (It has to read all of its input: one that exits early
+			// leaves the render looking like it is still loading, which holds off the
+			// clamping this test is about.)
+			{Name: "shrinking", Command: `sed -e 's/@@ -1,5 +1,5 @@/@@ -1,5 +1,4 @@/' -e '$d'`},
+		}
+	},
+	SetupRepo: func(shell *Shell) {
+		shell.CreateFileAndAdd("file1", "one\ntwo\nthree\nfour\nfive\n")
+		shell.Commit("one")
+
+		shell.UpdateFile("file1", "one\ntwo\nTHREE\nfour\nFIVE\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			Press(keys.Universal.FocusMainView)
+
+		t.Views().Main().
+			IsFocused().
+			Press(keys.Universal.GotoBottom).
+			SelectedLines(
+				Contains("+FIVE"),
+			).
+			Press(keys.Universal.CycleDiffRenderers).
+			Tap(func() {
+				t.ExpectToast(Equals("Diff renderer: shrinking (2 of 2)"))
+			})
+
+		// The selection has nowhere to be but the last line there is. Asserting on the
+		// index first waits for that to happen: the re-render and the clamp that
+		// follows it are a frame apart, and reading the selected line's text in
+		// between would be reading past the content.
+		t.Views().Main().
+			SelectionIsActive().
+			SelectedLineIdx(10).
+			SelectedLines(
+				Contains("-five"),
+			)
+	},
+})

pkg/integration/tests/main_view/navigate_by_hunk_and_file.go

@@ -0,0 +1,88 @@
+package main_view
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var NavigateByHunkAndFile = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Jump from hunk to hunk and from file to file in the focused main view of a commit's diff",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	SetupConfig: func(config *config.AppConfig) {
+		config.GetUserConfig().Gui.UseHunkModeInStagingView = false
+	},
+	SetupRepo: func(shell *Shell) {
+		shell.CreateFileAndAdd("file1", "one\ntwo\nthree\nfour\nfive\nsix\nseven\neight\nnine\nten\n")
+		shell.CreateFileAndAdd("file2", "one\ntwo\nthree\n")
+		shell.Commit("one")
+
+		shell.UpdateFileAndAdd("file1", "one\ntwo\nTHREE\nfour\nfive\nsix\nseven\neight\nNINE\nten\n")
+		shell.UpdateFileAndAdd("file2", "one\ntwo\nTHREE\n")
+		shell.Commit("two")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Commits().
+			Focus().
+			Lines(
+				Contains("two").IsSelected(),
+				Contains("one"),
+			).
+			Press(keys.Universal.FocusMainView)
+
+		t.Views().Main().
+			IsFocused().
+			SelectedLines(
+				Contains("-three"),
+			).
+			// Hunk navigation moves between change blocks. A hunk, in lazygit's sense,
+			// is a run of changes bounded by context; one @@ hunk may hold several.
+			Press(keys.Main.NextHunk).
+			SelectedLines(
+				Contains("-nine"),
+			).
+			Press(keys.Main.PrevHunk).
+			SelectedLines(
+				Contains("-three"),
+			).
+			// File navigation lands on the top of the next file's diff, which for a
+			// parseable diff is its header.
+			Press(keys.Main.NextFile).
+			SelectedLines(
+				Contains("diff --git a/file2 b/file2"),
+			).
+			Press(keys.Main.NextFile).
+			SelectedLines(
+				Contains("diff --git a/file2 b/file2"),
+			).
+			Press(keys.Main.PrevFile).
+			SelectedLines(
+				Contains("diff --git a/file1 b/file1"),
+			).
+			// A range that only grows while shift is held is a plain selection again once
+			// we jump elsewhere, rather than stretching to wherever we land.
+			Press(keys.Main.NextHunk).
+			Press(keys.Universal.RangeSelectDown).
+			SelectedLines(
+				Contains("-three"),
+				Contains("+THREE"),
+			).
+			Press(keys.Main.NextHunk).
+			SelectedLines(
+				Contains("-nine"),
+			).
+			// A sticky range does stretch to it.
+			Press(keys.Universal.ToggleRangeSelect).
+			Press(keys.Main.PrevHunk).
+			SelectedLines(
+				Contains("-three"),
+				Contains("+THREE"),
+				Contains(" four"),
+				Contains(" five"),
+				Contains(" six"),
+				Contains(" seven"),
+				Contains(" eight"),
+				Contains("-nine"),
+			)
+	},
+})

pkg/integration/tests/main_view/no_selection_over_a_binary_diff.go

@@ -0,0 +1,36 @@
+package main_view
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var NoSelectionOverABinaryDiff = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "A diff with nothing selectable in it shows no selection, and a refresh doesn't bring one",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	SetupConfig: func(cfg *config.AppConfig) {
+		cfg.GetUserConfig().Gui.UseHunkModeInStagingView = false
+	},
+	SetupRepo: func(shell *Shell) {
+		shell.CreateFileAndAdd("binary", "\x00one\x00two\x00")
+		shell.Commit("one")
+
+		shell.UpdateFile("binary", "\x00one\x00TWO\x00")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		// git says only that the file differs, so there is nothing to select — and a
+		// refresh, which renders the same diff again, doesn't make one appear.
+		t.Views().Files().
+			IsFocused().
+			Press(keys.Universal.FocusMainView)
+
+		t.Views().Main().
+			IsFocused().
+			SelectionIsHidden().
+			Tap(func() {
+				t.GlobalPress(keys.Universal.Refresh)
+			}).
+			SelectionIsHidden()
+	},
+})

pkg/integration/tests/main_view/no_selection_over_a_commit_log.go

@@ -0,0 +1,48 @@
+package main_view
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var NoSelectionOverACommitLog = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Focusing the main view over a branch's commit log shows no selection, even for a log too long to be read in one go",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	// A short terminal, so that the log below is longer than the initial read of it.
+	Width:       100,
+	Height:      20,
+	SetupConfig: func(config *config.AppConfig) {},
+	SetupRepo: func(shell *Shell) {
+		shell.CreateNCommits(60)
+		shell.CreateFileAndAdd("file1", "one\ntwo\nthree\n")
+		shell.Commit("add file1")
+		shell.UpdateFile("file1", "one\ntwo modified\nthree\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		// Leave a selection behind in the main view, on the file's diff.
+		t.Views().Files().
+			IsFocused().
+			Press(keys.Universal.FocusMainView)
+
+		t.Views().Main().
+			IsFocused().
+			SelectionIsActive().
+			PressEscape()
+
+		t.Views().Branches().
+			Focus()
+
+		t.Views().Main().
+			Content(Contains("commit-60"))
+
+		// A commit log holds nothing to point at, so focusing it shows no selection —
+		// not even the one the pane was left with under the files panel.
+		t.Views().Branches().
+			Press(keys.Universal.FocusMainView)
+
+		t.Views().Main().
+			IsFocused().
+			SelectionIsHidden()
+	},
+})

pkg/integration/tests/main_view/no_selection_when_no_changes.go

@@ -0,0 +1,31 @@
+package main_view
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var NoSelectionWhenNoChanges = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Focusing the main view when there are no changes shows no selection, and navigating doesn't conjure one",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	SetupConfig:  func(config *config.AppConfig) {},
+	SetupRepo: func(shell *Shell) {
+		shell.EmptyCommit("one")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			IsEmpty().
+			Press(keys.Universal.FocusMainView)
+
+		// There's nothing to act on, so the placeholder is shown with no selection — and
+		// a navigation key just scrolls rather than conjuring one.
+		t.Views().Main().
+			IsFocused().
+			Content(Contains("No changed files")).
+			SelectionIsHidden().
+			Press(keys.Universal.GotoTop).
+			SelectionIsHidden()
+	},
+})

pkg/integration/tests/main_view/range_select_diff_lines.go

@@ -0,0 +1,59 @@
+package main_view
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var RangeSelectDiffLines = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Select a range of diff lines in the focused main view, both sticky and with shift",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	SetupConfig: func(config *config.AppConfig) {
+		config.GetUserConfig().Gui.UseHunkModeInStagingView = false
+	},
+	SetupRepo: func(shell *Shell) {
+		shell.CreateFileAndAdd("file1", "one\ntwo\nthree\nfour\nfive\n")
+		shell.Commit("one")
+
+		shell.UpdateFile("file1", "one\ntwo\nTHREE\nFOUR\nfive\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			Press(keys.Universal.FocusMainView)
+
+		// A sticky range is extended by the plain arrow keys, and pressing the key again
+		// collapses it back to the cursor line.
+		t.Views().Main().
+			IsFocused().
+			SelectedLines(
+				Contains("-three"),
+			).
+			Press(keys.Universal.ToggleRangeSelect).
+			Press(keys.Universal.NextItem).
+			SelectedLines(
+				Contains("-three"),
+				Contains("-four"),
+			).
+			Press(keys.Universal.ToggleRangeSelect).
+			SelectedLines(
+				Contains("-four"),
+			).
+			// A non-sticky range only grows while shift is held, and a plain move
+			// collapses it again.
+			Press(keys.Universal.RangeSelectDown).
+			SelectedLines(
+				Contains("-four"),
+				Contains("+THREE"),
+			).
+			Press(keys.Universal.RangeSelectUp).
+			SelectedLines(
+				Contains("-four"),
+			).
+			Press(keys.Universal.NextItem).
+			SelectedLines(
+				Contains("+THREE"),
+			)
+	},
+})

pkg/integration/tests/main_view/search_collapses_the_selection.go

@@ -0,0 +1,51 @@
+package main_view
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var SearchCollapsesTheSelection = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Searching the focused main view leaves a single line selected at the match, whatever was selected before",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	SetupConfig: func(cfg *config.AppConfig) {
+		cfg.GetUserConfig().Gui.UseHunkModeInStagingView = false
+	},
+	SetupRepo: func(shell *Shell) {
+		shell.CreateFileAndAdd("file1", "one\ntwo\nthree\nfour\nfive\nsix\nseven\neight\nnine\nten\n")
+		shell.Commit("one")
+
+		shell.UpdateFile("file1", "one\ntwo\nTHREE\nfour\nfive\nsix\nseven\neight\nNINE\nten\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			Press(keys.Universal.FocusMainView)
+
+		t.Views().Main().
+			IsFocused().
+			Press(keys.Main.ToggleSelectHunk).
+			SelectedLines(
+				Contains("-three"),
+				Contains("+THREE"),
+			).
+			// The match is in another block entirely, so the hunk selection the cursor
+			// has just left goes with it.
+			FilterOrSearch("NINE").
+			SelectedLines(
+				Contains("+NINE"),
+			).
+			// And the same for a hunk selected while a search is on: the next match is
+			// not part of it either.
+			Press(keys.Main.ToggleSelectHunk).
+			SelectedLines(
+				Contains("-nine"),
+				Contains("+NINE"),
+			).
+			Press(keys.Universal.NextMatch).
+			SelectedLines(
+				Contains("+NINE"),
+			)
+	},
+})

pkg/integration/tests/main_view/search_follows_the_selection.go

@@ -0,0 +1,44 @@
+package main_view
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var SearchFollowsTheSelection = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Stepping to the next match in the focused main view carries on from the selection",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	SetupConfig:  func(config *config.AppConfig) {},
+	SetupRepo: func(shell *Shell) {
+		shell.CreateFileAndAdd("file1", "")
+		shell.Commit("one")
+
+		shell.UpdateFile("file1", "NEEDLE a\ntwo\nNEEDLE b\nfour\nNEEDLE c\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			Press(keys.Universal.FocusMainView)
+
+		t.Views().Main().
+			IsFocused().
+			FilterOrSearch("NEEDLE").
+			SelectedLines(Contains("+NEEDLE a")).
+			Tap(func() {
+				t.Views().Search().Content(Contains("matches for 'NEEDLE' (1 of 3)"))
+			}).
+			// Move the selection past the second match by hand.
+			SelectNextItem().
+			SelectNextItem().
+			SelectNextItem().
+			SelectedLines(Contains("+four")).
+			Tap(func() {
+				t.Views().Search().Content(Contains("matches for 'NEEDLE' (2 of 3)"))
+			}).
+			// So the next match is the one after where the selection is, not the one
+			// after the match it was last on.
+			Press(keys.Universal.NextMatch).
+			SelectedLines(Contains("+NEEDLE c"))
+	},
+})

pkg/integration/tests/main_view/select_below_a_long_commit_message.go

@@ -0,0 +1,64 @@
+package main_view
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var SelectBelowALongCommitMessage = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Focusing the main view over a commit whose diff begins below a very long commit message still shows a selection",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	// A short terminal, so that the message below is longer than a render is asked to
+	// read, and the diff under it is only reached by reading on.
+	Width:       100,
+	Height:      20,
+	SetupConfig: func(config *config.AppConfig) {},
+	SetupRepo: func(shell *Shell) {
+		shell.CreateFileAndAdd("file1", "one\ntwo\nthree\n")
+		shell.Commit("first commit")
+
+		body := make([]string, 1000)
+		for i := range body {
+			body[i] = fmt.Sprintf("message line %d", i+1)
+		}
+		shell.UpdateFileAndAdd("file1", "one\nTWO\nthree\n")
+		shell.Commit("a commit with a great deal to say\n\n" + strings.Join(body, "\n"))
+
+		shell.EmptyCommit("nothing to see here")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		// A commit with nothing to select leaves the pane showing no selection.
+		t.Views().Commits().
+			Focus().
+			Lines(
+				Contains("nothing to see here").IsSelected(),
+				Contains("a commit with a great deal to say"),
+				Contains("first commit"),
+			).
+			Press(keys.Universal.FocusMainView)
+
+		t.Views().Main().
+			IsFocused().
+			SelectionIsHidden().
+			PressEscape()
+
+		// The commit below it has a change, a thousand lines further down than a render
+		// reads by itself. The pane reads on until it knows, rather than taking the
+		// answer from the commit before it or waiting for the user to scroll.
+		t.Views().Commits().
+			IsFocused().
+			SelectNextItem().
+			Press(keys.Universal.FocusMainView)
+
+		t.Views().Main().
+			IsFocused().
+			// The change is in the pane, a thousand lines below where the render stopped
+			// reading of its own accord.
+			Content(Contains("-two")).
+			SelectionIsActive()
+	},
+})

pkg/integration/tests/main_view/select_below_a_long_diffstat.go

@@ -0,0 +1,61 @@
+package main_view
+
+import (
+	"fmt"
+
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var SelectBelowALongDiffstat = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Focusing the main view over a commit whose diff begins below a long diffstat still shows a selection",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	// A short terminal, so that the diffstat below fills more than the screenful the
+	// first paint reveals, and the diff itself is longer than the initial read of it.
+	Width:       100,
+	Height:      20,
+	SetupConfig: func(config *config.AppConfig) {},
+	SetupRepo: func(shell *Shell) {
+		for i := range 40 {
+			shell.CreateFileAndAdd(fmt.Sprintf("file%02d", i+1), "one\ntwo\nthree\n")
+		}
+		shell.Commit("first commit")
+		for i := range 40 {
+			shell.UpdateFileAndAdd(fmt.Sprintf("file%02d", i+1), "one\nTWO\nthree\n")
+		}
+		shell.Commit("touch every file")
+		shell.EmptyCommit("nothing to see here")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		// A commit with nothing to select leaves the pane showing no selection.
+		t.Views().Commits().
+			Focus().
+			Lines(
+				Contains("nothing to see here").IsSelected(),
+				Contains("touch every file"),
+				Contains("first commit"),
+			).
+			Press(keys.Universal.FocusMainView)
+
+		t.Views().Main().
+			IsFocused().
+			SelectionIsHidden().
+			PressEscape()
+
+		// The commit below it has plenty to select, even though none of it is among
+		// the diffstat the first paint shows.
+		t.Views().Commits().
+			IsFocused().
+			SelectNextItem()
+
+		t.Views().Main().Content(Contains("40 files changed"))
+
+		t.Views().Commits().
+			Press(keys.Universal.FocusMainView)
+
+		t.Views().Main().
+			IsFocused().
+			SelectionIsActive()
+	},
+})

pkg/integration/tests/main_view/select_diff_lines.go

@@ -0,0 +1,54 @@
+package main_view
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var SelectDiffLines = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Focusing the main view selects the first visible change line, and the arrow keys move the selection",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	SetupConfig: func(config *config.AppConfig) {
+		config.GetUserConfig().Gui.UseHunkModeInStagingView = false
+	},
+	SetupRepo: func(shell *Shell) {
+		shell.CreateFileAndAdd("file1", "one\ntwo\nthree\nfour\nfive\n")
+		shell.Commit("one")
+
+		shell.UpdateFile("file1", "one\ntwo\nTHREE\nfour\nfive\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			Lines(
+				Contains("file1").IsSelected(),
+			).
+			Press(keys.Universal.FocusMainView)
+
+		// The selection starts on the first change line rather than at the top of the
+		// diff, so that it lands on something to act on without the view jumping.
+		t.Views().Main().
+			IsFocused().
+			SelectionIsActive().
+			SelectedLines(
+				Contains("-three"),
+			).
+			Press(keys.Universal.NextItem).
+			SelectedLines(
+				Contains("+THREE"),
+			).
+			Press(keys.Universal.PrevItem).
+			SelectedLines(
+				Contains("-three"),
+			).
+			Press(keys.Universal.GotoTop).
+			SelectedLines(
+				Contains("diff --git a/file1 b/file1"),
+			).
+			Press(keys.Universal.Return)
+
+		t.Views().Files().
+			IsFocused()
+	},
+})

pkg/integration/tests/main_view/select_hunk_below_last_change.go

@@ -0,0 +1,37 @@
+package main_view
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var SelectHunkBelowLastChange = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Toggling hunk selection while below the last change selects the last change block",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	SetupConfig: func(config *config.AppConfig) {
+		config.GetUserConfig().Gui.UseHunkModeInStagingView = false
+	},
+	SetupRepo: func(shell *Shell) {
+		shell.CreateFileAndAdd("file1", "one\ntwo\nthree\nfour\nfive\n")
+		shell.Commit("one")
+
+		shell.UpdateFile("file1", "one\nTWO\nthree\nfour\nfive\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			Press(keys.Universal.FocusMainView)
+
+		// Below the last change there is no block ahead to select, so hunk mode takes
+		// the one behind rather than doing nothing.
+		t.Views().Main().
+			IsFocused().
+			NavigateToLine(Contains(" five")).
+			Press(keys.Main.ToggleSelectHunk).
+			SelectedLines(
+				Contains("-two"),
+				Contains("+TWO"),
+			)
+	},
+})

pkg/integration/tests/main_view/select_hunk_in_diff.go

@@ -0,0 +1,59 @@
+package main_view
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var SelectHunkInDiff = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Toggle hunk selection in the focused main view, and step from hunk to hunk",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	SetupConfig: func(config *config.AppConfig) {
+		config.GetUserConfig().Gui.UseHunkModeInStagingView = false
+	},
+	SetupRepo: func(shell *Shell) {
+		shell.CreateFileAndAdd("file1", "one\ntwo\nthree\nfour\nfive\nsix\nseven\neight\nnine\nten\n")
+		shell.Commit("one")
+
+		shell.UpdateFile("file1", "one\ntwo\nTHREE\nFOUR\nfive\nsix\nseven\neight\nNINE\nten\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			Press(keys.Universal.FocusMainView)
+
+		// Hunk mode widens the selection to the whole change block around the cursor —
+		// which is lazygit's notion of a hunk, so the two changed lines and their
+		// replacements are one block, and the isolated change further down is another.
+		t.Views().Main().
+			IsFocused().
+			SelectedLines(
+				Contains("-three"),
+			).
+			Press(keys.Main.ToggleSelectHunk).
+			SelectedLines(
+				Contains("-three"),
+				Contains("-four"),
+				Contains("+THREE"),
+				Contains("+FOUR"),
+			).
+			// In hunk mode the arrow keys step from block to block rather than by line.
+			Press(keys.Universal.NextItem).
+			SelectedLines(
+				Contains("-nine"),
+				Contains("+NINE"),
+			).
+			Press(keys.Universal.PrevItem).
+			SelectedLines(
+				Contains("-three"),
+				Contains("-four"),
+				Contains("+THREE"),
+				Contains("+FOUR"),
+			).
+			Press(keys.Main.ToggleSelectHunk).
+			SelectedLines(
+				Contains("-three"),
+			)
+	},
+})

pkg/integration/tests/main_view/select_hunk_on_focusing_main_view.go

@@ -0,0 +1,67 @@
+package main_view
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var SelectHunkOnFocusingMainView = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "When hunk mode is the default, focusing the main view selects the first whole change block",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	SetupConfig: func(config *config.AppConfig) {
+		config.GetUserConfig().Gui.UseHunkModeInStagingView = true
+	},
+	SetupRepo: func(shell *Shell) {
+		shell.CreateFileAndAdd("file1", "one\ntwo\nthree\nfour\nfive\nsix\nseven\neight\nnine\nten\n")
+		shell.Commit("one")
+
+		shell.UpdateFile("file1", "one\ntwo\nTHREE\nfour\nfive\nsix\nseven\neight\nNINE\nten\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			Press(keys.Universal.FocusMainView)
+
+		// No key press needed: the whole block is selected just by focusing.
+		t.Views().Main().
+			IsFocused().
+			SelectedLines(
+				Contains("-three"),
+				Contains("+THREE"),
+			).
+			// Hunk mode being the configured default, it isn't something escape gives up:
+			// escape leaves the view.
+			Press(keys.Universal.Return)
+
+		t.Views().Files().
+			IsFocused().
+			Press(keys.Universal.FocusMainView)
+
+		t.Views().Main().
+			IsFocused().
+			// A click on a change line keeps hunk mode and selects that line's block.
+			Click(0, 14).
+			SelectedLines(
+				Contains("-nine"),
+				Contains("+NINE"),
+			).
+			// A click inside the selected block collapses hunk mode to that line.
+			Click(0, 15).
+			SelectedLines(
+				Contains("+NINE"),
+			).
+			// Switch back to hunk mode so the context click below proves that it gives
+			// hunk mode up, rather than merely keeping line mode.
+			Press(keys.Main.ToggleSelectHunk).
+			SelectedLines(
+				Contains("-nine"),
+				Contains("+NINE"),
+			).
+			// A click on a context line points at it precisely, so it selects that line.
+			Click(0, 12).
+			SelectedLines(
+				Contains(" seven"),
+			)
+	},
+})

pkg/integration/tests/main_view/select_in_a_diff_read_in_part.go

@@ -0,0 +1,36 @@
+package main_view
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var SelectInADiffReadInPart = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Focusing the main view over a diff longer than the part of it that has been read still shows a selection",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	// A short terminal, so that the file below is longer than the initial read of its diff.
+	Width:       100,
+	Height:      20,
+	SetupConfig: func(config *config.AppConfig) {},
+	SetupRepo: func(shell *Shell) {
+		lines := make([]string, 600)
+		for i := range lines {
+			lines[i] = fmt.Sprintf("line%03d", i+1)
+		}
+		shell.CreateFileAndAdd("file1", strings.Join(lines, "\n")+"\n")
+		shell.Commit("one big commit")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Commits().
+			Focus().
+			Press(keys.Universal.FocusMainView)
+
+		t.Views().Main().
+			IsFocused().
+			SelectionIsActive()
+	},
+})

pkg/integration/tests/main_view/select_line_when_whole_file_is_one_hunk.go

@@ -0,0 +1,43 @@
+package main_view
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var SelectLineWhenWholeFileIsOneHunk = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Hunk mode falls back to a single line for a file that is one solid block of changes, rather than selecting all of it",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	SetupConfig: func(config *config.AppConfig) {
+		config.GetUserConfig().Gui.UseHunkModeInStagingView = true
+	},
+	SetupRepo: func(shell *Shell) {
+		shell.EmptyCommit("one")
+		shell.CreateFileAndAdd("added", "one\ntwo\nthree\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			Lines(
+				Contains("added").IsSelected(),
+			).
+			Press(keys.Universal.FocusMainView)
+
+		// Every line of the file is an addition, so widening to the change block would
+		// select the file entire; hunk mode gives way to a single line.
+		t.Views().Main().
+			IsFocused().
+			SelectedLines(
+				Contains("+one"),
+			).
+			// Toggling hunk mode on explicitly still selects the whole block: the fallback
+			// is about what the default does, not about forbidding the selection.
+			Press(keys.Main.ToggleSelectHunk).
+			SelectedLines(
+				Contains("+one"),
+				Contains("+two"),
+				Contains("+three"),
+			)
+	},
+})

pkg/integration/tests/main_view/select_visible_change_on_focusing_main_view.go

@@ -0,0 +1,77 @@
+package main_view
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var SelectVisibleChangeOnFocusingMainView = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Focusing the main view selects a change that is already on screen, leaving the diff where it is",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	Width:        120,
+	Height:       30,
+	SetupConfig: func(cfg *config.AppConfig) {
+		cfg.GetUserConfig().Gui.UseHunkModeInStagingView = false
+		// Enough context around each change to scroll into a stretch of the diff that
+		// holds none.
+		cfg.GetUserConfig().Git.DiffContextSize = 20
+	},
+	SetupRepo: func(shell *Shell) {
+		lines := make([]string, 60)
+		for i := range lines {
+			lines[i] = fmt.Sprintf("line%02d", i+1)
+		}
+		shell.CreateFileAndAdd("file1", strings.Join(lines, "\n")+"\n")
+		shell.Commit("one")
+
+		lines[4] = strings.ToUpper(lines[4])
+		lines[54] = strings.ToUpper(lines[54])
+		shell.UpdateFile("file1", strings.Join(lines, "\n")+"\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			Press(keys.Universal.ScrollDownMain).
+			Press(keys.Universal.ScrollDownMain)
+
+		t.Views().Main().
+			OriginY(4).
+			Tap(func() {
+				t.Views().Files().Press(keys.Universal.FocusMainView)
+			}).
+			IsFocused().
+			// The first change is on screen, so it is the one to point at — and the view
+			// hasn't moved to point at it.
+			SelectedLines(
+				Contains("-line05"),
+			).
+			OriginY(4).
+			PressEscape()
+
+		t.Views().Files().
+			IsFocused().
+			Press(keys.Universal.ScrollDownMain).
+			Press(keys.Universal.ScrollDownMain).
+			Press(keys.Universal.ScrollDownMain).
+			Press(keys.Universal.ScrollDownMain)
+
+		t.Views().Main().
+			OriginY(12).
+			Tap(func() {
+				t.Views().Files().Press(keys.Universal.FocusMainView)
+			}).
+			IsFocused().
+			// Now the whole screen is context: the changes are above and below it. The
+			// selection goes to the middle of what is on screen rather than to a change
+			// the user would have to be scrolled to.
+			SelectedLines(
+				Contains(" line19"),
+			).
+			SelectedLineIdx(24).
+			OriginY(12)
+	},
+})

pkg/integration/tests/main_view/select_visible_hunk_on_focusing_main_view.go

@@ -0,0 +1,93 @@
+package main_view
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var SelectVisibleHunkOnFocusingMainView = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Focusing the main view in hunk mode picks a block that begins on screen, leaving the diff where it is",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	Width:        120,
+	Height:       30,
+	SetupConfig: func(cfg *config.AppConfig) {
+		cfg.GetUserConfig().Gui.UseHunkModeInStagingView = true
+		// One line per scroll, so that the test can put the top of the view exactly
+		// where it wants it, and enough context to scroll about within one hunk.
+		cfg.GetUserConfig().Gui.ScrollHeight = 1
+		cfg.GetUserConfig().Git.DiffContextSize = 20
+	},
+	SetupRepo: func(shell *Shell) {
+		lines := make([]string, 80)
+		for i := range lines {
+			lines[i] = fmt.Sprintf("line%02d", i+1)
+		}
+		shell.CreateFileAndAdd("file1", strings.Join(lines, "\n")+"\n")
+		shell.Commit("one")
+
+		for _, i := range []int{10, 20, 70} {
+			lines[i-1] = strings.ToUpper(lines[i-1])
+		}
+		shell.UpdateFile("file1", strings.Join(lines, "\n")+"\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		scrollDown := func(lines int) {
+			for range lines {
+				t.Views().Files().Press(keys.Universal.ScrollDownMain)
+			}
+		}
+
+		t.Views().Files().IsFocused()
+
+		// The top of the view is the second line of the first change block, so that
+		// block is only half on screen; the second one begins below it, in full.
+		scrollDown(15)
+
+		t.Views().Main().
+			OriginY(15).
+			Tap(func() {
+				t.Views().Files().Press(keys.Universal.FocusMainView)
+			}).
+			IsFocused().
+			SelectedLines(
+				Contains("-line20"),
+				Contains("+LINE20"),
+			).
+			OriginY(15).
+			PressEscape()
+
+		// Now nothing begins on screen: the second block starts just above the top and
+		// the third change is far below. Only the half-visible block is on screen, so
+		// it is selected, with its first line off screen, since the view stays put.
+		scrollDown(11)
+
+		t.Views().Main().
+			OriginY(26).
+			Tap(func() {
+				t.Views().Files().Press(keys.Universal.FocusMainView)
+			}).
+			IsFocused().
+			SelectedLines(
+				Contains("-line20"),
+				Contains("+LINE20"),
+			).
+			SelectedLineIdx(25).
+			OriginY(26).
+			PressEscape()
+
+		// And a click inside a block that begins above the viewport selects the whole
+		// block without pulling the view up to its start either.
+		t.Views().Main().
+			Click(0, 0).
+			IsFocused().
+			SelectedLines(
+				Contains("-line20"),
+				Contains("+LINE20"),
+			).
+			OriginY(26)
+	},
+})

pkg/integration/tests/main_view/selection_commands_only_where_they_apply.go

@@ -0,0 +1,58 @@
+package main_view
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var SelectionCommandsOnlyWhereTheyApply = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "The keybindings menu offers the commands that act on a diff selection only in a main view that has one",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	SetupConfig:  func(config *config.AppConfig) {},
+	SetupRepo: func(shell *Shell) {
+		shell.CreateFileAndAdd("file1", "one\ntwo\nthree\n")
+		shell.Commit("one")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		// A branch's commit log has nothing to select, so the commands that act on a
+		// selection have no business being listed there.
+		t.Views().Branches().
+			Focus().
+			Press(keys.Universal.FocusMainView)
+
+		t.Views().Main().
+			IsFocused().
+			Press(keys.Universal.OptionMenu)
+
+		t.ExpectPopup().Menu().
+			Title(Equals("Keybindings")).
+			Tap(func() {
+				t.Views().Menu().
+					Content(DoesNotContain("Select hunks")).
+					Content(DoesNotContain("Toggle range select")).
+					Content(DoesNotContain("Go to next hunk")).
+					Content(DoesNotContain("Go to next file"))
+			}).
+			Cancel()
+
+		// A diff view does list them, and with nothing changed to select they're
+		// offered but disabled.
+		t.Views().Files().
+			Focus().
+			IsEmpty().
+			Press(keys.Universal.FocusMainView)
+
+		t.Views().Main().
+			IsFocused().
+			SelectionIsHidden().
+			Press(keys.Universal.OptionMenu)
+
+		t.ExpectPopup().Menu().
+			Title(Equals("Keybindings")).
+			Select(Contains("Select hunks")).
+			Confirm()
+
+		t.ExpectToast(Contains("There is nothing to select here"))
+	},
+})

pkg/integration/tests/main_view/selection_over_the_custom_patch.go

@@ -0,0 +1,47 @@
+package main_view
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var SelectionOverTheCustomPatch = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "The pane showing a custom patch keeps its selection across a refresh, its content being a diff like any other",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	SetupConfig: func(cfg *config.AppConfig) {
+		cfg.GetUserConfig().Gui.UseHunkModeInStagingView = false
+	},
+	SetupRepo: func(shell *Shell) {
+		shell.CreateFileAndAdd("file1", "one\ntwo\nthree\n")
+		shell.Commit("one")
+		shell.UpdateFileAndAdd("file1", "one\nTWO\nthree\n")
+		shell.Commit("two")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Commits().
+			Focus().
+			NavigateToLine(Contains("two")).
+			PressEnter()
+
+		t.Views().CommitFiles().
+			IsFocused().
+			PressPrimaryAction().
+			Press(keys.Universal.FocusMainView)
+
+		// The patch built from the commit is shown in the other pane, and it is a diff,
+		// so it has a selection of its own — one that a refresh doesn't take away.
+		t.Views().Main().
+			IsFocused().
+			Press(keys.Universal.TogglePanel)
+
+		t.Views().Secondary().
+			IsFocused().
+			Title(Equals("Custom patch")).
+			SelectionIsActive().
+			Tap(func() {
+				t.GlobalPress(keys.Universal.Refresh)
+			}).
+			SelectionIsActive()
+	},
+})

pkg/integration/tests/test_list.go

@@ -18,6 +18,7 @@ import (
 	"github.com/jesseduffield/lazygit/pkg/integration/tests/filter_by_author"
 	"github.com/jesseduffield/lazygit/pkg/integration/tests/filter_by_path"
 	"github.com/jesseduffield/lazygit/pkg/integration/tests/interactive_rebase"
+	"github.com/jesseduffield/lazygit/pkg/integration/tests/main_view"
 	"github.com/jesseduffield/lazygit/pkg/integration/tests/misc"
 	"github.com/jesseduffield/lazygit/pkg/integration/tests/patch_building"
 	"github.com/jesseduffield/lazygit/pkg/integration/tests/reflog"
@@ -362,6 +363,46 @@ var tests = []*components.IntegrationTest{
 	interactive_rebase.SwapInRebaseWithConflictAndEdit,
 	interactive_rebase.SwapWithConflict,
 	interactive_rebase.ViewFilesOfTodoEntries,
+	main_view.ClickSelectsDiffLine,
+	main_view.DragRangeWithAutoscroll,
+	main_view.DragSelectsDiffLineRange,
+	main_view.EditSelectedDiffLine,
+	main_view.EscapeDismissesSelection,
+	main_view.FileNavigationScrollsToTheTop,
+	main_view.HideSelectionWhenChangesVanish,
+	main_view.KeepAWrappedLineCoveredAcrossARerender,
+	main_view.KeepBothHalvesOfAChangeSelected,
+	main_view.KeepPositionByTheVisibleEndOfASelection,
+	main_view.KeepPositionInBothPanesWhenChangingContextSize,
+	main_view.KeepPositionInBothPanesWhenIgnoringWhitespace,
+	main_view.KeepPositionInBothPanesWhenSwitchingDiffRenderers,
+	main_view.KeepPositionWhenChangingContextSize,
+	main_view.KeepPositionWhenIgnoringWhitespace,
+	main_view.KeepPositionWhenIgnoringWhitespaceRemovesIt,
+	main_view.KeepPositionWhenSwitchingDiffRenderers,
+	main_view.KeepPositionWhenTheSelectionIsOffScreen,
+	main_view.KeepScrollWhenTheDiffCantBeRead,
+	main_view.KeepSelectedRangeWhenChangingContextSize,
+	main_view.KeepSelectionVisibleWhenDiffShrinks,
+	main_view.NavigateByHunkAndFile,
+	main_view.NoSelectionOverABinaryDiff,
+	main_view.NoSelectionOverACommitLog,
+	main_view.NoSelectionWhenNoChanges,
+	main_view.RangeSelectDiffLines,
+	main_view.SearchCollapsesTheSelection,
+	main_view.SearchFollowsTheSelection,
+	main_view.SelectBelowALongCommitMessage,
+	main_view.SelectBelowALongDiffstat,
+	main_view.SelectDiffLines,
+	main_view.SelectHunkBelowLastChange,
+	main_view.SelectHunkInDiff,
+	main_view.SelectHunkOnFocusingMainView,
+	main_view.SelectInADiffReadInPart,
+	main_view.SelectLineWhenWholeFileIsOneHunk,
+	main_view.SelectVisibleChangeOnFocusingMainView,
+	main_view.SelectVisibleHunkOnFocusingMainView,
+	main_view.SelectionCommandsOnlyWhereTheyApply,
+	main_view.SelectionOverTheCustomPatch,
 	misc.ConfirmOnQuit,
 	misc.CopyConfirmationMessageToClipboard,
 	misc.CopyToClipboard,

pkg/tasks/tasks.go

@@ -98,6 +98,24 @@ type ViewBufferManager struct {
 	// what that task was owed.
 	newContentPending atomic.Bool
 
+	// When set, the next command task puts the view back where it was once it has
+	// re-rendered the content, instead of showing the new render from the top (see
+	// RenderRestore). It is installed just before the re-render is triggered.
+	//
+	// Like newContentPending it outlives the task it was installed for, and for the
+	// same reason: that task can be stopped and replaced before it ever paints, and
+	// the replacement, rendering the same content, is then the one that owes the
+	// user their position. It is cleared by whichever task applies it. Guarded by
+	// taskIDMutex, like the task key.
+	restoreForNextTask *RenderRestore
+
+	// When set, the next command task leaves the view's scroll position alone even
+	// though it renders a different command's output, that output being the same
+	// content laid out differently (see SetKeepScrollPositionForNextTask). The task
+	// that starts consumes it, in place of noting that new content is on its way.
+	// Guarded by taskIDMutex, like the task key.
+	keepScrollForNextTask bool
+
 	// Whether a command task is currently reading content into the view. While
 	// this is true the content is still growing, so callers (e.g. the layout)
 	// must not clamp the view's scroll position to the amount loaded so far.
@@ -152,6 +170,80 @@ type LinesToRead struct {
 	Then func()
 }
 
+// RenderRestore puts a view back where it was when it re-renders content the user
+// is already looking at, laid out differently — a different context size, whitespace
+// ignored, another diff renderer — instead of showing the new render from the top.
+//
+// The task reads the new content into an off-screen buffer; the restore says when
+// enough of it has arrived to show the remembered position (FirstPaintReady), and
+// then finds that position and reveals it (Apply). It is a pair of callbacks rather
+// than a scroll position because a different layout of the same content puts the
+// remembered line somewhere else, and only the new content itself says where.
+type RenderRestore struct {
+	// FirstPaintReady reports whether enough of the new content has been read for
+	// the restore to show what it is looking for. It is consulted after each line
+	// is read, on the task's own goroutine.
+	FirstPaintReady func() bool
+
+	// Apply runs once, on the UI thread, at the first paint. It finds its target in
+	// the off-screen content, calls swapIn to promote that content to the display,
+	// and places the view on the target — in that order, so that the search runs
+	// while the previous content is still displayed, and the new content is never
+	// drawn at the previous render's scroll position.
+	//
+	// It must call swapIn either way, and reports whether it placed the view: when
+	// it didn't, because what it was looking for is not in the new content, the
+	// task does what it would have done without a restore.
+	Apply func(swapIn func()) bool
+}
+
+// SetRestoreForNextTask arranges for the next command task to put the view back
+// where it is now once it has re-rendered. Call it right before triggering a
+// re-render of the content the view is showing; see RenderRestore.
+func (self *ViewBufferManager) SetRestoreForNextTask(restore *RenderRestore) {
+	self.taskIDMutex.Lock()
+	defer self.taskIDMutex.Unlock()
+
+	self.restoreForNextTask = restore
+}
+
+func (self *ViewBufferManager) getRestoreForNextTask() *RenderRestore {
+	self.taskIDMutex.Lock()
+	defer self.taskIDMutex.Unlock()
+
+	return self.restoreForNextTask
+}
+
+// SetKeepScrollPositionForNextTask arranges for the next command task to leave the
+// view's scroll position alone, rather than showing its content from the top the way a
+// render of different content does. Call it right before triggering a re-render of the
+// content the view is showing, when the command producing it is not the one that
+// produced what is on screen — a different context size, another diff renderer.
+//
+// It is the coarser sibling of SetRestoreForNextTask, for the same moment. The restore
+// puts the view back on the line it remembers, which it can only do when the lines of
+// the new rendering can be told apart. This one says merely "the content is a
+// rearrangement of what is there, so the offset into it is nearer to where the user was
+// than the top is". Both can be set at once, and then the restore has the first say.
+func (self *ViewBufferManager) SetKeepScrollPositionForNextTask() {
+	self.taskIDMutex.Lock()
+	defer self.taskIDMutex.Unlock()
+
+	self.keepScrollForNextTask = true
+}
+
+// clearRestore drops a restore once a task has applied it, so that it rides exactly
+// one re-render. One installed since — the user pressing the key again while this
+// task was still reading — is left alone: it belongs to the render on its way.
+func (self *ViewBufferManager) clearRestore(restore *RenderRestore) {
+	self.taskIDMutex.Lock()
+	defer self.taskIDMutex.Unlock()
+
+	if self.restoreForNextTask == restore {
+		self.restoreForNextTask = nil
+	}
+}
+
 func (self *ViewBufferManager) GetTaskKey() string {
 	self.taskIDMutex.Lock()
 	defer self.taskIDMutex.Unlock()
@@ -212,8 +304,20 @@ func (self *ViewBufferManager) StartLoading() {
 }
 
 func (self *ViewBufferManager) ReadToEnd(then func()) {
-	// The reading happens on the task's own goroutine, and the caller hears about
-	// it through then, so lazygit must not count as idle in between.
+	self.readHoldingATask(-1, then)
+}
+
+// ReadLinesAndWait is ReadLines for lines lazygit is itself waiting on, rather than
+// reading ahead of the user. It holds a gocui task until they have been read, so
+// lazygit doesn't count as idle in the meantime (docs/dev/Busy.md).
+func (self *ViewBufferManager) ReadLinesAndWait(totalLines int) {
+	self.readHoldingATask(totalLines, nil)
+}
+
+// readHoldingATask asks the task to have read totalLines lines in total (-1 for all of
+// them) and calls then once it has. The reading happens on the task's own goroutine and
+// the caller is waiting on the result, so lazygit must not count as idle in between.
+func (self *ViewBufferManager) readHoldingATask(totalLines int, then func()) {
 	task := self.newGocuiTask()
 	answered := func() {
 		task.Done()
@@ -222,7 +326,7 @@ func (self *ViewBufferManager) ReadToEnd(then func()) {
 		}
 	}
 
-	request := LinesToRead{Total: -1, InitialRefreshAfter: -1, Then: answered}
+	request := LinesToRead{Total: totalLines, InitialRefreshAfter: -1, Then: answered}
 	if !self.readRequests.enqueue(request) {
 		// With no task reading, everything there is to read has been read.
 		answered()
@@ -258,6 +362,10 @@ func (self *ViewBufferManager) NewCmdTask(start func() (Cmd, io.Reader), prefix
 			onFirstPageShown()
 		}
 
+		// Whatever position is owed to the user belongs to this render: it was
+		// remembered just before the re-render that led here was triggered.
+		restore := self.getRestoreForNextTask()
+
 		if self.throttle.Load() {
 			self.Log.Info("throttling task")
 			time.Sleep(THROTTLE_TIME)
@@ -356,7 +464,12 @@ func (self *ViewBufferManager) NewCmdTask(start func() (Cmd, io.Reader), prefix
 				// content is common (a background refresh over a repo with submodules
 				// that have uncommitted changes, say). The pending flag isn't consumed
 				// here; the first paint still owes the scroll reset.
-				if !loaded && self.newContentPending.Load() {
+				//
+				// A restore keeps the view too: it is there to make a re-render of what
+				// the user is looking at seamless, and blanking the view for a message
+				// before putting them back where they were is the flicker it exists to
+				// avoid.
+				if !loaded && restore == nil && self.newContentPending.Load() {
 					self.beforeStart()
 					// beforeStart cleared the previous content to show "loading...", so
 					// put the view back at the top for it (beforeStart doesn't touch the
@@ -417,6 +530,18 @@ func (self *ViewBufferManager) NewCmdTask(start func() (Cmd, io.Reader), prefix
 					return
 				}
 				painted = true
+				if restore != nil {
+					// The restore does the swap itself, so that it can find where the
+					// user was in the new content before it is revealed.
+					placed := restore.Apply(self.swapInRender)
+					self.clearRestore(restore)
+					if placed {
+						// The view is where the user left it, which is exactly what the
+						// scroll reset would undo.
+						self.newContentPending.Store(false)
+						return
+					}
+				}
 				self.swapInRender()
 				if self.newContentPending.Swap(false) {
 					self.resetOrigin()
@@ -455,7 +580,13 @@ func (self *ViewBufferManager) NewCmdTask(start func() (Cmd, io.Reader), prefix
 							linesToRead.Then()
 						}
 					}
-					for linesToRead.Total == -1 || linesRead < linesToRead.Total {
+					// A restore that hasn't painted yet keeps us reading past the lines
+					// asked for, all the way to the end of the input if need be. What it
+					// is looking for may be anywhere in the new content, and a rendering
+					// that has to be parsed as a diff to be searched at all can only be
+					// parsed whole — so stopping early would leave it nothing to find,
+					// and the view somewhere the user didn't put it.
+					for linesToRead.Total == -1 || linesRead < linesToRead.Total || (restore != nil && !painted) {
 						if stopped() {
 							callThen()
 							break outer
@@ -526,12 +657,22 @@ func (self *ViewBufferManager) NewCmdTask(start func() (Cmd, io.Reader), prefix
 							time.Sleep(slowRenderPerLine)
 						}
 
-						if linesRead == linesToRead.InitialRefreshAfter {
-							// We have read enough lines to fill the view, so do the first paint
-							// and refresh to show it. Continue reading and refresh again at the
+						if !painted {
+							// Do the first paint once we have read enough lines to fill the
+							// view — or, when a position is waiting to be restored, once the
+							// restore says it can show it, since where the view should be is
+							// its call. Continue reading afterwards and refresh again at the
 							// end to make sure the scrollbar has the right size.
-							_ = self.onUIThread(firstPaint)
-							refreshViewIfStale()
+							var ready bool
+							if restore != nil {
+								ready = restore.FirstPaintReady()
+							} else {
+								ready = linesRead == linesToRead.InitialRefreshAfter
+							}
+							if ready {
+								_ = self.onUIThread(firstPaint)
+								refreshViewIfStale()
+							}
 						}
 					}
 					refreshViewIfStale()
@@ -658,10 +799,19 @@ func (self *ViewBufferManager) NewTask(f func(TaskOpts) error, key string) error
 		// newContentPending), so the previous content — left displayed until the
 		// swap — doesn't visibly jump to the top before the new content appears.
 		// Read taskKey directly: we already hold the mutex that guards it, and
-		// GetTaskKey would take it again.
-		if self.taskKey != key && self.resetOrigin != nil {
+		// GetTaskKey would take it again. A pending restore isn't dropped here
+		// either, even for a different command: the re-renders it rides are all
+		// different commands (a different context size, another diff renderer), and
+		// it validates itself against the content it lands in anyway.
+		// A task told to keep the scroll position renders the content the view is
+		// already showing, laid out differently, so the reset it would otherwise owe
+		// would take the user away from what they are reading — and the loading
+		// message, which the same flag governs, would blank content that is about to
+		// come back looking much the same.
+		if self.taskKey != key && self.resetOrigin != nil && !self.keepScrollForNextTask {
 			self.newContentPending.Store(true)
 		}
+		self.keepScrollForNextTask = false
 		self.taskKey = key
 
 		self.taskIDMutex.Unlock()

pkg/tasks/tasks_test.go

@@ -385,6 +385,231 @@ func TestLoadingIndicatorOnlyTakesOverForNewContent(t *testing.T) {
 		2*time.Second, 10*time.Millisecond)
 }
 
+// A pending restore takes the first paint over: it says when enough of the new
+// content has arrived to show the position it remembers, and does the swap itself so
+// that it can look for that position while the previous content is still displayed.
+// Having put the view where the user left it, it also keeps the scroll reset that new
+// content would otherwise get.
+func TestNewCmdTaskRestore(t *testing.T) {
+	writer := bytes.NewBuffer(nil)
+	linesWritten := func() int { return strings.Count(writer.String(), "\n") }
+	resetOrigin, getResetOriginCallCount := getCounter()
+
+	swapped := false
+	applyCount := 0
+	applyAtLines := -1
+	swappedBeforeApply := false
+	swappedByApply := false
+
+	manager := NewViewBufferManager(
+		utils.NewDummyLog(),
+		writer,
+		func() {}, // beforeStart
+		func() {}, // refreshView
+		func() {}, // onEndOfInput
+		resetOrigin,
+		func() {},                 // beginRender
+		func() { swapped = true }, // swapInRender
+		func() gocui.Task { return gocui.NewFakeTask() },
+		// no UI thread in the test; run the view mutations inline
+		func(f func()) error { f(); return nil },
+	)
+
+	manager.SetRestoreForNextTask(&RenderRestore{
+		// Ready once five lines have loaded — well before the view is filled (30).
+		FirstPaintReady: func() bool { return linesWritten() >= 5 },
+		Apply: func(swapIn func()) bool {
+			applyCount++
+			applyAtLines = linesWritten()
+			swappedBeforeApply = swappedBeforeApply || swapped
+			swapIn()
+			swappedByApply = swapped
+			return true
+		},
+	})
+
+	done := make(chan struct{})
+	start := func() (Cmd, io.Reader) {
+		// not actually starting this because it's not necessary
+		return ExecCmd{Cmd: exec.Command("blah")}, &BlankLineReader{totalLinesToYield: 50}
+	}
+	_ = manager.NewTask(manager.NewCmdTask(start, "", LinesToRead{100, 30, nil}, func() { close(done) }), "cmd")
+	<-done
+
+	assert.Equal(t, 1, applyCount, "Apply should run exactly once")
+	assert.False(t, swappedBeforeApply, "the off-screen render should not be swapped in before Apply runs")
+	assert.True(t, swappedByApply, "Apply should swap the off-screen render in via swapIn")
+	// The first paint was driven by the restore, not by having read enough lines to
+	// fill the view.
+	assert.GreaterOrEqual(t, applyAtLines, 5)
+	assert.Less(t, applyAtLines, 30)
+	assert.Equal(t, 0, getResetOriginCallCount(), "a restore that placed the view leaves the scroll alone")
+}
+
+// A restore that never finds what it is looking for keeps the task reading to the
+// end of its input, since the line might have been anywhere in it. Once there is no
+// more content to hope for, the render is revealed with the scroll reset that new
+// content is owed.
+func TestNewCmdTaskRestoreThatFindsNothing(t *testing.T) {
+	writer := bytes.NewBuffer(nil)
+	linesWritten := func() int { return strings.Count(writer.String(), "\n") }
+	resetOrigin, getResetOriginCallCount := getCounter()
+
+	applyCount := 0
+	swappedAtLines := -1
+
+	manager := NewViewBufferManager(
+		utils.NewDummyLog(),
+		writer,
+		func() {}, // beforeStart
+		func() {}, // refreshView
+		func() {}, // onEndOfInput
+		resetOrigin,
+		func() {}, // beginRender
+		func() { swappedAtLines = linesWritten() },
+		func() gocui.Task { return gocui.NewFakeTask() },
+		// no UI thread in the test; run the view mutations inline
+		func(f func()) error { f(); return nil },
+	)
+
+	manager.SetRestoreForNextTask(&RenderRestore{
+		FirstPaintReady: func() bool { return false },
+		Apply: func(swapIn func()) bool {
+			applyCount++
+			swapIn()
+			return false
+		},
+	})
+
+	done := make(chan struct{})
+	start := func() (Cmd, io.Reader) {
+		// not actually starting this because it's not necessary
+		return ExecCmd{Cmd: exec.Command("blah")}, &BlankLineReader{totalLinesToYield: 50}
+	}
+	_ = manager.NewTask(manager.NewCmdTask(start, "", LinesToRead{100, 30, nil}, func() { close(done) }), "cmd")
+	<-done
+
+	assert.Equal(t, 1, applyCount, "Apply should still run, to swap the render in")
+	assert.Equal(t, 50, swappedAtLines, "the whole input should be read before giving up on the restore")
+	assert.Equal(t, 1, getResetOriginCallCount(), "new content the restore couldn't place starts at the top")
+}
+
+// The task a restore was installed for can be stopped and replaced before it ever
+// paints — a background refresh landing right after the key was pressed. The
+// replacement renders the same content, so it is the one that owes the user their
+// position.
+func TestRestoreSurvivesTaskReplacement(t *testing.T) {
+	var applyCount atomic.Int32
+
+	manager := NewViewBufferManager(
+		utils.NewDummyLog(),
+		io.Discard,
+		func() {},
+		func() {},
+		func() {},
+		func() {},
+		func() {},
+		func() {},
+		func() gocui.Task { return gocui.NewFakeTask() },
+		// no UI thread in the test; run the view mutations inline
+		func(f func()) error { f(); return nil },
+	)
+
+	manager.SetRestoreForNextTask(&RenderRestore{
+		FirstPaintReady: func() bool { return false },
+		Apply: func(swapIn func()) bool {
+			applyCount.Add(1)
+			swapIn()
+			return true
+		},
+	})
+
+	startTask := func(reader io.Reader, onDone func()) {
+		start := func() (Cmd, io.Reader) {
+			// not actually starting this because it's not necessary
+			return ExecCmd{Cmd: exec.Command("blah")}, reader
+		}
+		_ = manager.NewTask(manager.NewCmdTask(start, "", LinesToRead{100, 50, nil}, onDone), "cmd")
+	}
+
+	// The task the restore was installed for stalls before it can paint.
+	stalled := BlockingLineReader{
+		linesToYield: 3,
+		blocked:      make(chan struct{}),
+		unblock:      make(chan struct{}),
+	}
+	defer close(stalled.unblock)
+	startTask(&stalled, nil)
+	<-stalled.blocked
+
+	done := make(chan struct{})
+	startTask(&BlankLineReader{totalLinesToYield: 3}, func() { close(done) })
+	<-done
+
+	assert.EqualValues(t, 1, applyCount.Load(), "the replacement should apply the restore the stopped task couldn't")
+}
+
+// A task told to keep the scroll position renders the content the view is showing
+// under another command — the same diff with more context around it, say — so it
+// neither resets the scroll nor blanks the view to say "loading...", both of which are
+// for content the user hasn't seen.
+func TestKeepScrollPositionForNextTask(t *testing.T) {
+	var beforeStartCount atomic.Int32
+	resetOrigin, getResetOriginCallCount := getCounter()
+
+	manager := NewViewBufferManager(
+		utils.NewDummyLog(),
+		io.Discard,
+		func() { beforeStartCount.Add(1) },
+		func() {}, // refreshView
+		func() {}, // onEndOfInput
+		resetOrigin,
+		func() {}, // beginRender
+		func() {}, // swapInRender
+		func() gocui.Task { return gocui.NewFakeTask() },
+		// no UI thread in the test; run the view mutations inline
+		func(f func()) error { f(); return nil },
+	)
+
+	startTask := func(key string, reader io.Reader, onDone func()) {
+		start := func() (Cmd, io.Reader) {
+			// not actually starting this because it's not necessary
+			return ExecCmd{Cmd: exec.Command("blah")}, reader
+		}
+		_ = manager.NewTask(manager.NewCmdTask(start, "", LinesToRead{100, 50, nil}, onDone), key)
+	}
+	runTaskToCompletion := func(key string) {
+		done := make(chan struct{})
+		startTask(key, &BlankLineReader{totalLinesToYield: 3}, func() { close(done) })
+		<-done
+	}
+
+	// Content the view wasn't showing, to have something to keep the position in.
+	runTaskToCompletion("cmd1")
+	assert.Equal(t, 1, getResetOriginCallCount())
+
+	manager.SetKeepScrollPositionForNextTask()
+	runTaskToCompletion("cmd2")
+	assert.Equal(t, 1, getResetOriginCallCount(), "the same content under another command keeps its position")
+
+	// And the request rides one task only: the next different command is a different
+	// diff as far as anyone knows.
+	runTaskToCompletion("cmd3")
+	assert.Equal(t, 2, getResetOriginCallCount())
+
+	// The loading indicator goes by the same question, so it stays out of the way too.
+	manager.SetKeepScrollPositionForNextTask()
+	stalled := BlockingLineReader{
+		blocked: make(chan struct{}),
+		unblock: make(chan struct{}),
+	}
+	defer close(stalled.unblock)
+	startTask("cmd4", &stalled, nil)
+	<-stalled.blocked
+	time.Sleep(500 * time.Millisecond)
+	assert.EqualValues(t, 0, beforeStartCount.Load())
+}
+
 func TestNewCmdTaskRefresh(t *testing.T) {
 	type scenario struct {
 		name                        string

schema-master/config.json

@@ -2461,6 +2461,34 @@
             "l"
           ]
         },
+        "prevFile": {
+          "oneOf": [
+            {
+              "type": "string"
+            },
+            {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            }
+          ],
+          "default": "N"
+        },
+        "nextFile": {
+          "oneOf": [
+            {
+              "type": "string"
+            },
+            {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            }
+          ],
+          "default": "n"
+        },
         "toggleSelectHunk": {
           "oneOf": [
             {