Edit the selected hunk from the focused main view

The staging view can hand the hunk you are on to an editor and apply what comes back, which is how you stage something the diff cannot express: half of a changed line, or a change written differently from either side. The focused main view has to be able to do the same before that view can go. The hunk is git's own, context and all, rather than lazygit's block of adjacent changes: an editable patch is one that still applies, and the context lines are what let git place it. What the editor leaves behind is applied whole rather than matched against the file's diff again, the point being that it says something the diff didn't. Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
Don't refresh while the editor still has the hunk
2026-10-03 20:46:47 -04:00 · 2026-10-01 17:07:53 +02:00 · 2026-10-01 17:07:53 +02:00 · 2026-10-01 17:07:53 +02:00 · 2026-10-01 17:07:53 +02:00 · 2026-10-01 17:07:53 +02:00
135 changed files with 6417 additions and 413 deletions
@@ -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
@@ -226,11 +226,19 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 | `` a `` | Toggle hunk selection | Toggle line-by-line vs. hunk selection mode. |
 | `` v `` | Toggle range select |  |
 | `` e `` | Edit file | Open file in external editor. |
+| `` <space> `` | Stage | Toggle selection staged / unstaged. |
+| `` d `` | Discard | When unstaged change is selected, discard the change using `git reset`. When staged change is selected, unstage the change. |
+| `` E `` | Edit hunk | Edit selected hunk in external editor. |
+| `` <ctrl+o> `` | Copy selected text to clipboard |  |
 | `` <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 |  |
+| `` c `` | Commit | Commit staged changes. |
+| `` w `` | Commit changes without pre-commit hook |  |
+| `` C `` | Commit changes using git editor |  |
+| `` <ctrl+f> `` | Find base commit for fixup | Find the commit that your current changes are building upon, for the sake of amending/fixing up the commit. This spares you from having to look through your branch's commits one-by-one to see which commit should be amended/fixed up. See docs: <https://github.com/jesseduffield/lazygit/tree/master/docs/Fixup_Commits.md> |
 | `` / `` | Search the current view by text |  |

 ## Main panel (patch building)
@@ -338,11 +346,19 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 | `` a `` | Toggle hunk selection | Toggle line-by-line vs. hunk selection mode. |
 | `` v `` | Toggle range select |  |
 | `` e `` | Edit file | Open file in external editor. |
+| `` <space> `` | Stage | Toggle selection staged / unstaged. |
+| `` d `` | Discard | When unstaged change is selected, discard the change using `git reset`. When staged change is selected, unstage the change. |
+| `` E `` | Edit hunk | Edit selected hunk in external editor. |
+| `` <ctrl+o> `` | Copy selected text to clipboard |  |
 | `` <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 |  |
+| `` c `` | Commit | Commit staged changes. |
+| `` w `` | Commit changes without pre-commit hook |  |
+| `` C `` | Commit changes using git editor |  |
+| `` <ctrl+f> `` | Find base commit for fixup | Find the commit that your current changes are building upon, for the sake of amending/fixing up the commit. This spares you from having to look through your branch's commits one-by-one to see which commit should be amended/fixed up. See docs: <https://github.com/jesseduffield/lazygit/tree/master/docs/Fixup_Commits.md> |
 | `` / `` | Search the current view by text |  |

 ## Stash
@@ -195,11 +195,19 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 | `` a `` | ハンクの選択を切り替える | Toggle line-by-line vs. hunk selection mode. |
 | `` v `` | 範囲選択を切り替え |  |
 | `` e `` | ファイルを編集 | 外部エディタでファイルを開きます。 |
+| `` <space> `` | ステージ | 選択された部分のステージ / アンステージを切り替えます。 |
+| `` d `` | 破棄 | ステージされていない変更が選択されている場合、`git reset`を使用して変更を破棄します。ステージされた変更が選択されている場合、変更をアンステージします。 |
+| `` E `` | ハンクを編集 | 選択したハンクを外部エディタで編集します。 |
+| `` <ctrl+o> `` | 選択したテキストをクリップボードにコピー |  |
 | `` <left>, h `` | 前のハンクに移動 |  |
 | `` <right>, l `` | 次のハンクに移動 |  |
 | `` N `` | Go to previous file |  |
 | `` n `` | Go to next file |  |
 | `` <esc> `` | サイドパネルに戻る |  |
+| `` c `` | コミット | ステージされた変更をコミットします。 |
+| `` w `` | pre-commitフックなしで変更をコミット |  |
+| `` C `` | Gitエディタを使用して変更をコミット |  |
+| `` <ctrl+f> `` | フィックスアップのベースコミットを検索 | 現在の変更が基づいているコミットを見つけて、コミットの修正/フィックスアップを行います。これにより、ブランチのコミットを一つずつ確認して、どのコミットを修正/フィックスアップすべきかを調べる手間が省けます。詳細はドキュメントを参照: <https://github.com/jesseduffield/lazygit/tree/master/docs/Fixup_Commits.md> |
 | `` / `` | 現在のビューをテキストで検索 |  |

 ## タグ
@@ -315,11 +323,19 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 | `` a `` | ハンクの選択を切り替える | Toggle line-by-line vs. hunk selection mode. |
 | `` v `` | 範囲選択を切り替え |  |
 | `` e `` | ファイルを編集 | 外部エディタでファイルを開きます。 |
+| `` <space> `` | ステージ | 選択された部分のステージ / アンステージを切り替えます。 |
+| `` d `` | 破棄 | ステージされていない変更が選択されている場合、`git reset`を使用して変更を破棄します。ステージされた変更が選択されている場合、変更をアンステージします。 |
+| `` E `` | ハンクを編集 | 選択したハンクを外部エディタで編集します。 |
+| `` <ctrl+o> `` | 選択したテキストをクリップボードにコピー |  |
 | `` <left>, h `` | 前のハンクに移動 |  |
 | `` <right>, l `` | 次のハンクに移動 |  |
 | `` N `` | Go to previous file |  |
 | `` n `` | Go to next file |  |
 | `` <esc> `` | サイドパネルに戻る |  |
+| `` c `` | コミット | ステージされた変更をコミットします。 |
+| `` w `` | pre-commitフックなしで変更をコミット |  |
+| `` C `` | Gitエディタを使用して変更をコミット |  |
+| `` <ctrl+f> `` | フィックスアップのベースコミットを検索 | 現在の変更が基づいているコミットを見つけて、コミットの修正/フィックスアップを行います。これにより、ブランチのコミットを一つずつ確認して、どのコミットを修正/フィックスアップすべきかを調べる手間が省けます。詳細はドキュメントを参照: <https://github.com/jesseduffield/lazygit/tree/master/docs/Fixup_Commits.md> |
 | `` / `` | 現在のビューをテキストで検索 |  |

 ## メニュー
@@ -87,11 +87,19 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 | `` a `` | Toggle hunk selection | Toggle line-by-line vs. hunk selection mode. |
 | `` v `` | 드래그 선택 전환 |  |
 | `` e `` | 파일 편집 | Open file in external editor. |
+| `` <space> `` | Staged 전환 | 선택한 행을 staged / unstaged |
+| `` d `` | 변경을 삭제 (git reset) | When unstaged change is selected, discard the change using `git reset`. When staged change is selected, unstage the change. |
+| `` E `` | Edit hunk | Edit selected hunk in external editor. |
+| `` <ctrl+o> `` | 선택한 텍스트를 클립보드에 복사 |  |
 | `` <left>, h `` | 이전 hunk를 선택 |  |
 | `` <right>, l `` | 다음 hunk를 선택 |  |
 | `` N `` | Go to previous file |  |
 | `` n `` | Go to next file |  |
 | `` <esc> `` | Exit back to side panel |  |
+| `` c `` | 커밋 변경내용 | 스테이징된 변경 사항 커밋. |
+| `` w `` | Commit changes without pre-commit hook |  |
+| `` C `` | Git 편집기를 사용하여 변경 내용을 커밋합니다. |  |
+| `` <ctrl+f> `` | Find base commit for fixup | Find the commit that your current changes are building upon, for the sake of amending/fixing up the commit. This spares you from having to look through your branch's commits one-by-one to see which commit should be amended/fixed up. See docs: <https://github.com/jesseduffield/lazygit/tree/master/docs/Fixup_Commits.md> |
 | `` / `` | 검색 시작 |  |

 ## Stash
@@ -172,11 +180,19 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 | `` a `` | Toggle hunk selection | Toggle line-by-line vs. hunk selection mode. |
 | `` v `` | 드래그 선택 전환 |  |
 | `` e `` | 파일 편집 | Open file in external editor. |
+| `` <space> `` | Staged 전환 | 선택한 행을 staged / unstaged |
+| `` d `` | 변경을 삭제 (git reset) | When unstaged change is selected, discard the change using `git reset`. When staged change is selected, unstage the change. |
+| `` E `` | Edit hunk | Edit selected hunk in external editor. |
+| `` <ctrl+o> `` | 선택한 텍스트를 클립보드에 복사 |  |
 | `` <left>, h `` | 이전 hunk를 선택 |  |
 | `` <right>, l `` | 다음 hunk를 선택 |  |
 | `` N `` | Go to previous file |  |
 | `` n `` | Go to next file |  |
 | `` <esc> `` | Exit back to side panel |  |
+| `` c `` | 커밋 변경내용 | 스테이징된 변경 사항 커밋. |
+| `` w `` | Commit changes without pre-commit hook |  |
+| `` C `` | Git 편집기를 사용하여 변경 내용을 커밋합니다. |  |
+| `` <ctrl+f> `` | Find base commit for fixup | Find the commit that your current changes are building upon, for the sake of amending/fixing up the commit. This spares you from having to look through your branch's commits one-by-one to see which commit should be amended/fixed up. See docs: <https://github.com/jesseduffield/lazygit/tree/master/docs/Fixup_Commits.md> |
 | `` / `` | 검색 시작 |  |

 ## 메인 패널 (Patch Building)
@@ -234,11 +234,19 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 | `` 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. |
+| `` <space> `` | Toggle staged | Toggle lijnen staged / unstaged |
+| `` d `` | Verwijdert change (git reset) | When unstaged change is selected, discard the change using `git reset`. When staged change is selected, unstage the change. |
+| `` E `` | Edit hunk | Edit selected hunk in external editor. |
+| `` <ctrl+o> `` | Copy selected text to clipboard |  |
 | `` <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 |  |
+| `` c `` | Commit veranderingen | Commit gestagede wijzigingen. |
+| `` w `` | Commit veranderingen zonder pre-commit hook |  |
+| `` C `` | Commit veranderingen met de git editor |  |
+| `` <ctrl+f> `` | Find base commit for fixup | Vind de commit waar je huidige wijzigingen bovenop zijn gebouwd met als doel die commit te amenden/fixen. Hierdoor hoef je dit niet met de hand te doen. Zie: <https://github.com/jesseduffield/lazygit/tree/master/docs/Fixup_Commits.md> |
 | `` / `` | Start met zoeken |  |

 ## Patch bouwen
@@ -316,11 +324,19 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 | `` 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. |
+| `` <space> `` | Toggle staged | Toggle lijnen staged / unstaged |
+| `` d `` | Verwijdert change (git reset) | When unstaged change is selected, discard the change using `git reset`. When staged change is selected, unstage the change. |
+| `` E `` | Edit hunk | Edit selected hunk in external editor. |
+| `` <ctrl+o> `` | Copy selected text to clipboard |  |
 | `` <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 |  |
+| `` c `` | Commit veranderingen | Commit gestagede wijzigingen. |
+| `` w `` | Commit veranderingen zonder pre-commit hook |  |
+| `` C `` | Commit veranderingen met de git editor |  |
+| `` <ctrl+f> `` | Find base commit for fixup | Vind de commit waar je huidige wijzigingen bovenop zijn gebouwd met als doel die commit te amenden/fixen. Hierdoor hoef je dit niet met de hand te doen. Zie: <https://github.com/jesseduffield/lazygit/tree/master/docs/Fixup_Commits.md> |
 | `` / `` | Start met zoeken |  |

 ## Staging
@@ -102,11 +102,19 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 | `` 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. |
+| `` <space> `` | Zatwierdź | Przełącz zaznaczenie zatwierdzone/niezatwierdzone. |
+| `` d `` | Odrzuć | Gdy zaznaczona jest niezatwierdzona zmiana, odrzuć ją używając `git reset`. Gdy zaznaczona jest zatwierdzona zmiana, cofnij zatwierdzenie. |
+| `` E `` | Edytuj fragment | Edytuj wybrany fragment w zewnętrznym edytorze. |
+| `` <ctrl+o> `` | Kopiuj zaznaczony tekst do schowka |  |
 | `` <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 |  |
+| `` c `` | Commit | Zatwierdź zmiany zatwierdzone. |
+| `` w `` | Zatwierdź zmiany bez hooka pre-commit |  |
+| `` C `` | Zatwierdź zmiany używając edytora git |  |
+| `` <ctrl+f> `` | Znajdź bazowy commit do poprawki | Znajdź commit, na którym opierają się Twoje obecne zmiany, w celu poprawienia/zmiany commita. To pozwala Ci uniknąć przeglądania commitów w Twojej gałęzi jeden po drugim, aby zobaczyć, który commit powinien być poprawiony/zmieniony. Zobacz dokumentację: <https://github.com/jesseduffield/lazygit/tree/master/docs/Fixup_Commits.md> |
 | `` / `` | Szukaj w bieżącym widoku po tekście |  |

 ## Drzewa pracy
@@ -211,11 +219,19 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 | `` 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. |
+| `` <space> `` | Zatwierdź | Przełącz zaznaczenie zatwierdzone/niezatwierdzone. |
+| `` d `` | Odrzuć | Gdy zaznaczona jest niezatwierdzona zmiana, odrzuć ją używając `git reset`. Gdy zaznaczona jest zatwierdzona zmiana, cofnij zatwierdzenie. |
+| `` E `` | Edytuj fragment | Edytuj wybrany fragment w zewnętrznym edytorze. |
+| `` <ctrl+o> `` | Kopiuj zaznaczony tekst do schowka |  |
 | `` <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 |  |
+| `` c `` | Commit | Zatwierdź zmiany zatwierdzone. |
+| `` w `` | Zatwierdź zmiany bez hooka pre-commit |  |
+| `` C `` | Zatwierdź zmiany używając edytora git |  |
+| `` <ctrl+f> `` | Znajdź bazowy commit do poprawki | Znajdź commit, na którym opierają się Twoje obecne zmiany, w celu poprawienia/zmiany commita. To pozwala Ci uniknąć przeglądania commitów w Twojej gałęzi jeden po drugim, aby zobaczyć, który commit powinien być poprawiony/zmieniony. Zobacz dokumentację: <https://github.com/jesseduffield/lazygit/tree/master/docs/Fixup_Commits.md> |
 | `` / `` | Szukaj w bieżącym widoku po tekście |  |

 ## Panel główny (scalanie)
@@ -238,11 +238,19 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 | `` 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. |
+| `` <space> `` | Etapa | Ativar/desativar seleção em staged/unstaged |
+| `` d `` | Descartar | Quando a mudança não desejada for selecionada, descarte a mudança usando `git reset`. Quando a mudança em fase é selecionada, despare a mudança. |
+| `` E `` | Editar hunk | Editar o local selecionado no editor externo. |
+| `` <ctrl+o> `` | Copiar texto selecionado para área de transferência |  |
 | `` <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 |  |
+| `` c `` | Commit | Submeter mudanças em staging |
+| `` w `` | Fazer commit de alterações sem pré-commit |  |
+| `` C `` | Enviar alteração usando um editor Git |  |
+| `` <ctrl+f> `` | Encontrar commit da base para corrigir | Encontre o commit em que as suas mudanças atuais estão se baseando, para alterar/consertar o commit. Isso poupa-te você de ter que olhar pelos commits da sua branch um por um para ver qual commit deve ser alterado/consertado<br>Veja a documentação:<br><https://github.com/jesseduffield/lazygit/tree/master/docs/Fixup_Commits.md> |
 | `` / `` | Pesquisar na visualização atual por texto |  |

 ## Painel Principal (preparação)
@@ -347,11 +355,19 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 | `` 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. |
+| `` <space> `` | Etapa | Ativar/desativar seleção em staged/unstaged |
+| `` d `` | Descartar | Quando a mudança não desejada for selecionada, descarte a mudança usando `git reset`. Quando a mudança em fase é selecionada, despare a mudança. |
+| `` E `` | Editar hunk | Editar o local selecionado no editor externo. |
+| `` <ctrl+o> `` | Copiar texto selecionado para área de transferência |  |
 | `` <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 |  |
+| `` c `` | Commit | Submeter mudanças em staging |
+| `` w `` | Fazer commit de alterações sem pré-commit |  |
+| `` C `` | Enviar alteração usando um editor Git |  |
+| `` <ctrl+f> `` | Encontrar commit da base para corrigir | Encontre o commit em que as suas mudanças atuais estão se baseando, para alterar/consertar o commit. Isso poupa-te você de ter que olhar pelos commits da sua branch um por um para ver qual commit deve ser alterado/consertado<br>Veja a documentação:<br><https://github.com/jesseduffield/lazygit/tree/master/docs/Fixup_Commits.md> |
 | `` / `` | Pesquisar na visualização atual por texto |  |

 ## Stash
@@ -77,11 +77,19 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 | `` a `` | Toggle hunk selection | Toggle line-by-line vs. hunk selection mode. |
 | `` v `` | Переключить выборку перетаскивания |  |
 | `` e `` | Редактировать файл | Open file in external editor. |
+| `` <space> `` | Переключить индекс | Переключить строку в проиндексированные / непроиндексированные |
+| `` d `` | Отменить изменение (git reset) | When unstaged change is selected, discard the change using `git reset`. When staged change is selected, unstage the change. |
+| `` E `` | Изменить эту часть | Edit selected hunk in external editor. |
+| `` <ctrl+o> `` | Скопировать выделенный текст в буфер обмена |  |
 | `` <left>, h `` | Выбрать предыдущую часть |  |
 | `` <right>, l `` | Выбрать следующую часть |  |
 | `` N `` | Go to previous file |  |
 | `` n `` | Go to next file |  |
 | `` <esc> `` | Exit back to side panel |  |
+| `` c `` | Сохранить изменения | Commit staged changes. |
+| `` w `` | Закоммитить изменения без предварительного хука коммита |  |
+| `` C `` | Сохранить изменения с помощью редактора git |  |
+| `` <ctrl+f> `` | Find base commit for fixup | Find the commit that your current changes are building upon, for the sake of amending/fixing up the commit. This spares you from having to look through your branch's commits one-by-one to see which commit should be amended/fixed up. See docs: <https://github.com/jesseduffield/lazygit/tree/master/docs/Fixup_Commits.md> |
 | `` / `` | Найти |  |

 ## Главная панель (Индексирование)
@@ -116,11 +124,19 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 | `` a `` | Toggle hunk selection | Toggle line-by-line vs. hunk selection mode. |
 | `` v `` | Переключить выборку перетаскивания |  |
 | `` e `` | Редактировать файл | Open file in external editor. |
+| `` <space> `` | Переключить индекс | Переключить строку в проиндексированные / непроиндексированные |
+| `` d `` | Отменить изменение (git reset) | When unstaged change is selected, discard the change using `git reset`. When staged change is selected, unstage the change. |
+| `` E `` | Изменить эту часть | Edit selected hunk in external editor. |
+| `` <ctrl+o> `` | Скопировать выделенный текст в буфер обмена |  |
 | `` <left>, h `` | Выбрать предыдущую часть |  |
 | `` <right>, l `` | Выбрать следующую часть |  |
 | `` N `` | Go to previous file |  |
 | `` n `` | Go to next file |  |
 | `` <esc> `` | Exit back to side panel |  |
+| `` c `` | Сохранить изменения | Commit staged changes. |
+| `` w `` | Закоммитить изменения без предварительного хука коммита |  |
+| `` C `` | Сохранить изменения с помощью редактора git |  |
+| `` <ctrl+f> `` | Find base commit for fixup | Find the commit that your current changes are building upon, for the sake of amending/fixing up the commit. This spares you from having to look through your branch's commits one-by-one to see which commit should be amended/fixed up. See docs: <https://github.com/jesseduffield/lazygit/tree/master/docs/Fixup_Commits.md> |
 | `` / `` | Найти |  |

 ## Главная панель (Слияние)
@@ -289,11 +289,19 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 | `` a `` | 切换代码块选择 | 切换逐行选择与代码块选择模式。 |
 | `` v `` | 切换拖动选择 |  |
 | `` e `` | 编辑文件 | 使用外部编辑器打开文件 |
+| `` <space> `` | 切换暂存状态 | 切换行暂存状态 |
+| `` d `` | 取消变更(git reset) | 当选择未暂存的变更时，使用git reset丢弃该变更。当选择已暂存的变更时，取消暂存该变更 |
+| `` E `` | 编辑代码块 | 在外部编辑器中编辑选中的代码块 |
+| `` <ctrl+o> `` | 复制选中文本到剪贴板 |  |
 | `` <left>, h `` | 选择上一个区块 |  |
 | `` <right>, l `` | 选择下一个区块 |  |
 | `` N `` | Go to previous file |  |
 | `` n `` | Go to next file |  |
 | `` <esc> `` | 退出回到侧边面板 |  |
+| `` c `` | 提交变更 | 提交暂存文件 |
+| `` w `` | 提交变更而无需预先提交钩子 |  |
+| `` C `` | 使用 Git 编辑器提交变更 |  |
+| `` <ctrl+f> `` | 找到用于修复的基准提交 | 找到您当前变更所基于的提交，以便于修正/改进该提交。这样做可以省去您逐一查看分支提交来确定应该修正/改进哪个提交的麻烦。请参阅文档: <https://github.com/jesseduffield/lazygit/tree/master/docs/Fixup_Commits.md> |
 | `` / `` | 开始搜索 |  |

 ## 正在合并
@@ -344,11 +352,19 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 | `` a `` | 切换代码块选择 | 切换逐行选择与代码块选择模式。 |
 | `` v `` | 切换拖动选择 |  |
 | `` e `` | 编辑文件 | 使用外部编辑器打开文件 |
+| `` <space> `` | 切换暂存状态 | 切换行暂存状态 |
+| `` d `` | 取消变更(git reset) | 当选择未暂存的变更时，使用git reset丢弃该变更。当选择已暂存的变更时，取消暂存该变更 |
+| `` E `` | 编辑代码块 | 在外部编辑器中编辑选中的代码块 |
+| `` <ctrl+o> `` | 复制选中文本到剪贴板 |  |
 | `` <left>, h `` | 选择上一个区块 |  |
 | `` <right>, l `` | 选择下一个区块 |  |
 | `` N `` | Go to previous file |  |
 | `` n `` | Go to next file |  |
 | `` <esc> `` | 退出回到侧边面板 |  |
+| `` c `` | 提交变更 | 提交暂存文件 |
+| `` w `` | 提交变更而无需预先提交钩子 |  |
+| `` C `` | 使用 Git 编辑器提交变更 |  |
+| `` <ctrl+f> `` | 找到用于修复的基准提交 | 找到您当前变更所基于的提交，以便于修正/改进该提交。这样做可以省去您逐一查看分支提交来确定应该修正/改进哪个提交的麻烦。请参阅文档: <https://github.com/jesseduffield/lazygit/tree/master/docs/Fixup_Commits.md> |
 | `` / `` | 开始搜索 |  |

 ## 状态
@@ -78,11 +78,19 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 | `` a `` | 切換程式碼塊選擇 | 切換逐行選擇與程式碼塊選擇模式。 |
 | `` v `` | 切換拖曳選擇 |  |
 | `` e `` | 編輯檔案 | 使用外部編輯器開啟 |
+| `` <space> `` | 切換預存 | 切換現有行的狀態 (已預存/未預存) |
+| `` d `` | 刪除變更 (git reset) | 選取未暫存的變更時，使用 `git reset` 捨棄變更。選取已暫存的變更時，取消暫存變更。 |
+| `` E `` | 編輯程式碼塊 | 在外部編輯器中編輯選中的程式碼塊。 |
+| `` <ctrl+o> `` | 複製所選文本至剪貼簿 |  |
 | `` <left>, h `` | 選擇上一段 |  |
 | `` <right>, l `` | 選擇下一段 |  |
 | `` N `` | Go to previous file |  |
 | `` n `` | Go to next file |  |
 | `` <esc> `` | 退出回到側邊面板 |  |
+| `` c `` | 提交變更 | 提交暫存區變更 |
+| `` w `` | 沒有預提交 hook 就提交更改 |  |
+| `` C `` | 使用 git 編輯器提交變更 |  |
+| `` <ctrl+f> `` | 尋找 fixup 的基礎提交 | 找出目前變更所依據的提交，以便 amend/fixup。這樣不必逐一檢視分支中的提交來找出要 amend/fixup 的提交。請見文件：<https://github.com/jesseduffield/lazygit/tree/master/docs/Fixup_Commits.md> |
 | `` / `` | 搜尋 |  |

 ## 主面板（合併）
@@ -366,11 +374,19 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 | `` a `` | 切換程式碼塊選擇 | 切換逐行選擇與程式碼塊選擇模式。 |
 | `` v `` | 切換拖曳選擇 |  |
 | `` e `` | 編輯檔案 | 使用外部編輯器開啟 |
+| `` <space> `` | 切換預存 | 切換現有行的狀態 (已預存/未預存) |
+| `` d `` | 刪除變更 (git reset) | 選取未暫存的變更時，使用 `git reset` 捨棄變更。選取已暫存的變更時，取消暫存變更。 |
+| `` E `` | 編輯程式碼塊 | 在外部編輯器中編輯選中的程式碼塊。 |
+| `` <ctrl+o> `` | 複製所選文本至剪貼簿 |  |
 | `` <left>, h `` | 選擇上一段 |  |
 | `` <right>, l `` | 選擇下一段 |  |
 | `` N `` | Go to previous file |  |
 | `` n `` | Go to next file |  |
 | `` <esc> `` | 退出回到側邊面板 |  |
+| `` c `` | 提交變更 | 提交暫存區變更 |
+| `` w `` | 沒有預提交 hook 就提交更改 |  |
+| `` C `` | 使用 git 編輯器提交變更 |  |
+| `` <ctrl+f> `` | 尋找 fixup 的基礎提交 | 找出目前變更所依據的提交，以便 amend/fixup。這樣不必逐一檢視分支中的提交來找出要 amend/fixup 的提交。請見文件：<https://github.com/jesseduffield/lazygit/tree/master/docs/Fixup_Commits.md> |
 | `` / `` | 搜尋 |  |

 ## 狀態
@@ -135,8 +135,10 @@ func NewGitCommandAux(
 	rebaseCommands := git_commands.NewRebaseCommands(gitCommon, commitCommands, workingTreeCommands)
 	stashCommands := git_commands.NewStashCommands(gitCommon, fileLoader, workingTreeCommands)
 	patchBuilder := patch.NewPatchBuilder(cmn.Log,
-		func(from string, to string, reverse bool, filename string, previousPath string, plain bool) (string, error) {
-			return workingTreeCommands.ShowFileDiff(from, to, reverse, filename, previousPath, plain)
+		func(from string, to string, reverse bool, filename string, previousPath string) (string, error) {
+			// A patch is built from git's own diff: what a diff renderer would make of it
+			// is a picture of it, not something that can be applied.
+			return workingTreeCommands.ShowFileDiff(from, to, reverse, filename, previousPath, git_commands.DiffModePlain)
 		})
 	patchCommands := git_commands.NewPatchCommands(gitCommon, rebaseCommands, commitCommands, statusCommands, stashCommands, patchBuilder)
 	bisectCommands := git_commands.NewBisectCommands(gitCommon)
@@ -240,12 +240,12 @@ func (self *CommitCommands) AmendHeadCmdObj() *oscommands.CmdObj {
 	return self.cmd.New(cmdArgs)
 }

-func (self *CommitCommands) ShowCmdObj(hash string, filterPaths []string) *oscommands.CmdObj {
+func (self *CommitCommands) ShowCmdObj(hash string, filterPaths []string, mode DiffMode) *oscommands.CmdObj {
 	cmdArgs := NewGitCmd("show").
 		Config("diff.noprefix=false").
-		AddCommonDiffArgs(self.diffRendererConfigManager, self.UserConfig(), true).
+		AddCommonDiffArgs(self.diffRendererConfigManager, self.UserConfig(), mode).
 		Arg("--submodule").
-		Arg("--color=" + self.diffRendererConfigManager.GetColorArg()).
+		Arg("--color=" + mode.colorArg(self.diffRendererConfigManager)).
 		Arg("--stat").
 		Arg("--decorate").
 		Arg("-p").
@@ -341,7 +341,7 @@ func TestCommitShowCmdObj(t *testing.T) {
 			}
 			instance := buildCommitCommands(commonDeps{userConfig: userConfig, appState: &config.AppState{}, runner: runner, repoPaths: &repoPaths})

-			assert.NoError(t, instance.ShowCmdObj("1234567890", s.filterPaths).Run())
+			assert.NoError(t, instance.ShowCmdObj("1234567890", s.filterPaths, DiffModeRendered).Run())
 			runner.CheckForMissingCalls()
 		})
 	}
@@ -2,10 +2,135 @@ package git_commands

 import (
 	"fmt"
+	"os"
+	"strings"

 	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
+	"github.com/jesseduffield/lazygit/pkg/config"
+	"github.com/mgutz/str"
 )

+// metadataHandshake is the record a diff renderer that speaks the OSC 1717 protocol
+// emits before anything else, to announce that it does: a version-only record, with
+// none of the fields a line's record has. See ProbeDiffRendererEmitsMetadata, and
+// gocui's escape interpreter for how it is kept off the screen on a real render.
+const metadataHandshake = "\x1b]1717"
+
+// probeWidth is the width a probe asks the renderer to lay out to. A probe has
+// nothing to render, so any width does, as long as it is one a renderer will
+// accept: a renderer that lays its rendering out in columns may well refuse a
+// width of zero, and would then never get as far as announcing itself.
+const probeWidth = 80
+
+// ProbeDiffRendererEmitsMetadata reports whether the configured diff renderer states
+// which line of which file it is rendering, by running it on empty input and looking
+// for the handshake. The answer decides whether a diff the renderer produced can be
+// acted on at all, or has to be replaced by git's own when the user wants to act on it
+// (see DiffLineHelper.MainViewDiffMode).
+//
+// Asking rather than watching a real render: the handshake is the renderer's first
+// output whatever the diff, so the answer is a property of the renderer, known before
+// we render anything — where watching would have to see a diff go by first, and would
+// be fooled by a diff with no lines to describe.
+//
+// No terminal is needed. git only invokes a stdin filter when it thinks it is talking
+// to one, but the renderer itself doesn't care: it announces itself whenever OSC1717 is
+// set, so it can be run directly with empty input.
+func (self *DiffCommands) ProbeDiffRendererEmitsMetadata() bool {
+	manager := self.diffRendererConfigManager
+	values := config.DiffRendererValues{Width: probeWidth, DiffContext: 3}
+
+	switch manager.GetDiffRendererType() {
+	case config.DiffRendererType_StdinFilter:
+		if command, err := manager.GetStdinFilterCommand(values); err == nil && command != "" {
+			return self.probeEmitsMetadata(self.cmd.NewShell(command, ""))
+		}
+	case config.DiffRendererType_ExtDiff:
+		// An empty command means git's own diff.external config, which picks a driver
+		// per file through .gitattributes: there is no one renderer to ask, and a single
+		// diff can be produced by several, so we take it that it says nothing.
+		if command, err := manager.GetExternalDiffCommand(values); err == nil && command != "" {
+			return self.externalDiffEmitsMetadata(command)
+		}
+	case config.DiffRendererType_RawGit:
+		// git describes only the formats whose output can't be read back as a diff, and
+		// asked with the renderer's own arguments it answers for exactly the format
+		// those select: a handshake for a word diff, silence for a unified one. With no
+		// arguments there is nothing to fall back to anyway, since this already is git's
+		// own diff.
+		if args := manager.GetRawGitArgs(); len(args) > 0 {
+			return self.rawGitEmitsMetadata(args)
+		}
+	}
+
+	return false
+}
+
+// rawGitEmitsMetadata asks git itself, run with the diff renderer's own arguments.
+func (self *DiffCommands) rawGitEmitsMetadata(rawGitArgs []string) bool {
+	oldPath, newPath, cleanup, ok := self.probeFiles()
+	if !ok {
+		return false
+	}
+	defer cleanup()
+
+	return self.probeEmitsMetadata(self.cmd.New(
+		NewGitCmd("diff").
+			Arg("--no-index").
+			Arg(rawGitArgs...).
+			Arg(oldPath, newPath).
+			ToArgv(),
+	))
+}
+
+// externalDiffEmitsMetadata asks an external diff command, invoking it the way git
+// invokes one — with the seven positional arguments of git's diff.external convention —
+// over two empty files, so that it announces itself without having a diff to render.
+func (self *DiffCommands) externalDiffEmitsMetadata(externalDiffCommand string) bool {
+	oldPath, newPath, cleanup, ok := self.probeFiles()
+	if !ok {
+		return false
+	}
+	defer cleanup()
+
+	args := append(str.ToArgv(externalDiffCommand),
+		"probe", oldPath, "0000000", "100644", newPath, "0000000", "100644")
+	return self.probeEmitsMetadata(self.cmd.New(args))
+}
+
+// probeFiles makes the two empty files a probe stands a diff up from, and the cleanup
+// that removes them. Empty, because what the probe wants is for the renderer to announce
+// itself, not for it to have anything to say.
+func (self *DiffCommands) probeFiles() (string, string, func(), bool) {
+	tempDir := self.os.GetTempDir()
+
+	oldFile, err := os.CreateTemp(tempDir, "lazygit-probe-old-*")
+	if err != nil {
+		return "", "", nil, false
+	}
+	oldFile.Close()
+
+	newFile, err := os.CreateTemp(tempDir, "lazygit-probe-new-*")
+	if err != nil {
+		os.Remove(oldFile.Name())
+		return "", "", nil, false
+	}
+	newFile.Close()
+
+	return oldFile.Name(), newFile.Name(), func() {
+		os.Remove(oldFile.Name())
+		os.Remove(newFile.Name())
+	}, true
+}
+
+func (self *DiffCommands) probeEmitsMetadata(cmdObj *oscommands.CmdObj) bool {
+	cmdObj.AddEnvVars("OSC1717=V1")
+	// A renderer may well object to being handed nothing to render. We want to know
+	// whatever it said before objecting, and that is captured either way.
+	output, _ := cmdObj.RunWithOutput()
+	return strings.Contains(output, metadataHandshake)
+}
+
 type DiffCommands struct {
 	*GitCommon
 }
@@ -18,13 +143,13 @@ func NewDiffCommands(gitCommon *GitCommon) *DiffCommands {

 // This is for generating diffs to be shown in the UI (e.g. rendering a range
 // diff to the main view). It uses a custom diff renderer if one is configured.
-func (self *DiffCommands) DiffCmdObj(diffArgs []string) *oscommands.CmdObj {
+func (self *DiffCommands) DiffCmdObj(diffArgs []string, mode DiffMode) *oscommands.CmdObj {
 	return self.cmd.New(
 		NewGitCmd("diff").
 			Config("diff.noprefix=false").
-			AddCommonDiffArgs(self.diffRendererConfigManager, self.UserConfig(), true).
+			AddCommonDiffArgs(self.diffRendererConfigManager, self.UserConfig(), mode).
 			Arg("--submodule").
-			Arg(fmt.Sprintf("--color=%s", self.diffRendererConfigManager.GetColorArg())).
+			Arg(fmt.Sprintf("--color=%s", mode.colorArg(self.diffRendererConfigManager))).
 			Arg(diffArgs...).
 			Dir(self.repoPaths.worktreePath).
 			ToArgv(),
@@ -0,0 +1,35 @@
+package git_commands
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/config"
+)
+
+// DiffMode says what a diff command's output is for. This decides whether the
+// configured diff renderer produces it, and whether it is coloured.
+type DiffMode int
+
+const (
+	// DiffModeRendered is the diff as the user has arranged for it to look: through the
+	// diff renderer, with the renderer's own arguments and its preference about colour.
+	DiffModeRendered DiffMode = iota
+	// DiffModeRaw is git's own coloured diff, for showing a diff whose rendered form
+	// couldn't be acted on.
+	DiffModeRaw
+	// DiffModePlain is git's own uncoloured diff, for building patches from and copying
+	// text out of rather than for looking at.
+	DiffModePlain
+)
+
+// colorArg returns the value to pass to git's --color for this mode. Rendered output is
+// coloured however the renderer wants its input; a raw diff gets git's own colour, which
+// is the point of it; a plain one is for reading as text, not for looking at.
+func (self DiffMode) colorArg(diffRendererConfigManager *config.DiffRendererConfigManager) string {
+	switch self {
+	case DiffModeRendered:
+		return diffRendererConfigManager.GetColorArg()
+	case DiffModeRaw:
+		return "always"
+	default:
+		return "never"
+	}
+}
@@ -123,16 +123,21 @@ func (self *GitCommandBuilder) GitDirIf(condition bool, path string) *GitCommand
 	return self
 }

-func (self *GitCommandBuilder) AddCommonDiffArgs(diffRendererConfigManager *config.DiffRendererConfigManager, userConfig *config.UserConfig, forUI bool) *GitCommandBuilder {
+func (self *GitCommandBuilder) AddCommonDiffArgs(diffRendererConfigManager *config.DiffRendererConfigManager, userConfig *config.UserConfig, mode DiffMode) *GitCommandBuilder {
 	contextSize := userConfig.Git.DiffContextSize
-	useExtDiff := forUI && diffRendererConfigManager.GetDiffRendererType() == config.DiffRendererType_ExtDiff
+	useExtDiff := mode == DiffModeRendered && diffRendererConfigManager.GetDiffRendererType() == config.DiffRendererType_ExtDiff

 	return self.
 		ArgIfElse(useExtDiff, "--ext-diff", "--no-ext-diff").
 		Arg(fmt.Sprintf("--unified=%d", contextSize)).
-		ArgIf(forUI && userConfig.Git.IgnoreWhitespaceInDiffView, "--ignore-all-space").
+		// Ignoring whitespace is about what the user wants to see, so it holds for a raw
+		// diff as much as for a rendered one. Patches are built from a plain diff,
+		// where a diff that leaves changes out would apply to nothing.
+		ArgIf(mode != DiffModePlain && userConfig.Git.IgnoreWhitespaceInDiffView, "--ignore-all-space").
 		Arg(fmt.Sprintf("--find-renames=%d%%", userConfig.Git.RenameSimilarityThreshold)).
-		ArgIf(forUI, diffRendererConfigManager.GetRawGitArgs()...)
+		// The renderer's own arguments to git — a word diff, say — are part of the
+		// rendering, so they go with it.
+		ArgIf(mode == DiffModeRendered, diffRendererConfigManager.GetRawGitArgs()...)
 }

 func (self *GitCommandBuilder) ToArgv() []string {
@@ -80,14 +80,14 @@ func (self *StashCommands) Hash(index int) (string, error) {
 	return strings.Trim(hash, "\r\n"), err
 }

-func (self *StashCommands) ShowStashEntryCmdObj(index int) *oscommands.CmdObj {
+func (self *StashCommands) ShowStashEntryCmdObj(index int, mode DiffMode) *oscommands.CmdObj {
 	// "-u" is the same as "--include-untracked", but the latter fails in older git versions for some reason
 	cmdArgs := NewGitCmd("stash").Arg("show").
-		AddCommonDiffArgs(self.diffRendererConfigManager, self.UserConfig(), true).
+		AddCommonDiffArgs(self.diffRendererConfigManager, self.UserConfig(), mode).
 		Arg("-p").
 		Arg("--stat").
 		Arg("-u").
-		Arg(fmt.Sprintf("--color=%s", self.diffRendererConfigManager.GetColorArg())).
+		Arg(fmt.Sprintf("--color=%s", mode.colorArg(self.diffRendererConfigManager))).
 		Arg(fmt.Sprintf("refs/stash@{%d}", index)).
 		Dir(self.repoPaths.worktreePath).
 		ToArgv()
@@ -174,7 +174,7 @@ func TestStashStashEntryCmdObj(t *testing.T) {
 			}
 			instance := buildStashCommands(commonDeps{userConfig: userConfig, appState: &config.AppState{}, repoPaths: &repoPaths})

-			cmdStr := instance.ShowStashEntryCmdObj(s.index).Args()
+			cmdStr := instance.ShowStashEntryCmdObj(s.index, DiffModeRendered).Args()
 			assert.Equal(t, s.expected, cmdStr)
 		})
 	}
@@ -383,9 +383,9 @@ func (self *WorkingTreeCommands) Exclude(filename string) error {
 }

 // WorktreeFileDiff returns the diff of a file
-func (self *WorkingTreeCommands) WorktreeFileDiff(file *models.File, plain bool, cached bool) string {
+func (self *WorkingTreeCommands) WorktreeFileDiff(file *models.File, mode DiffMode, cached bool) string {
 	// for now we assume an error means the file was deleted
-	s, _ := self.WorktreeFileDiffCmdObj(file, plain, cached, file.Names()).RunWithOutput()
+	s, _ := self.WorktreeFileDiffCmdObj(file, mode, cached, file.Names()).RunWithOutput()
 	return s
 }

@@ -393,18 +393,13 @@ func (self *WorkingTreeCommands) WorktreeFileDiff(file *models.File, plain bool,
 // in the working tree. node is the item they belong to; all it decides is
 // whether git has to compare against /dev/null, which is the case for a file
 // that isn't in the index yet.
-func (self *WorkingTreeCommands) WorktreeFileDiffCmdObj(node models.IFile, plain bool, cached bool, paths []string) *oscommands.CmdObj {
-	colorArg := self.diffRendererConfigManager.GetColorArg()
-	if plain {
-		colorArg = "never"
-	}
-
+func (self *WorkingTreeCommands) WorktreeFileDiffCmdObj(node models.IFile, mode DiffMode, cached bool, paths []string) *oscommands.CmdObj {
 	noIndex := !node.GetIsTracked() && !node.GetHasStagedChanges() && !cached && node.GetIsFile()

 	cmdArgs := NewGitCmd("diff").
-		AddCommonDiffArgs(self.diffRendererConfigManager, self.UserConfig(), !plain).
+		AddCommonDiffArgs(self.diffRendererConfigManager, self.UserConfig(), mode).
 		Arg("--submodule").
-		Arg(fmt.Sprintf("--color=%s", colorArg)).
+		Arg(fmt.Sprintf("--color=%s", mode.colorArg(self.diffRendererConfigManager))).
 		ArgIf(cached, "--cached").
 		ArgIf(noIndex, "--no-index").
 		Arg("--").
@@ -420,25 +415,20 @@ func (self *WorkingTreeCommands) WorktreeFileDiffCmdObj(node models.IFile, plain
 // but when we're in diff mode it could be any 'from' to any 'to'. The reverse flag is also here thanks to diff mode.
 // For a renamed file, previousPath is the path it was renamed from (empty otherwise);
 // both paths must be passed to git for the rename to be detected.
-func (self *WorkingTreeCommands) ShowFileDiff(from string, to string, reverse bool, fileName string, previousPath string, plain bool) (string, error) {
+func (self *WorkingTreeCommands) ShowFileDiff(from string, to string, reverse bool, fileName string, previousPath string, mode DiffMode) (string, error) {
 	fileNames := []string{fileName}
 	if previousPath != "" {
 		fileNames = append(fileNames, previousPath)
 	}
-	return self.ShowFileDiffCmdObj(from, to, reverse, fileNames, plain).RunWithOutput()
+	return self.ShowFileDiffCmdObj(from, to, reverse, fileNames, mode).RunWithOutput()
 }

-func (self *WorkingTreeCommands) ShowFileDiffCmdObj(from string, to string, reverse bool, fileNames []string, plain bool) *oscommands.CmdObj {
-	colorArg := self.diffRendererConfigManager.GetColorArg()
-	if plain {
-		colorArg = "never"
-	}
-
+func (self *WorkingTreeCommands) ShowFileDiffCmdObj(from string, to string, reverse bool, fileNames []string, mode DiffMode) *oscommands.CmdObj {
 	cmdArgs := NewGitCmd("diff").
 		Config("diff.noprefix=false").
-		AddCommonDiffArgs(self.diffRendererConfigManager, self.UserConfig(), !plain).
+		AddCommonDiffArgs(self.diffRendererConfigManager, self.UserConfig(), mode).
 		Arg("--submodule").
-		Arg(fmt.Sprintf("--color=%s", colorArg)).
+		Arg(fmt.Sprintf("--color=%s", mode.colorArg(self.diffRendererConfigManager))).
 		Arg(from).
 		Arg(to).
 		ArgIf(reverse, "-R").
@@ -197,7 +197,7 @@ func TestWorkingTreeDiff(t *testing.T) {
 	type scenario struct {
 		testName            string
 		file                *models.File
-		plain               bool
+		mode                DiffMode
 		cached              bool
 		ignoreWhitespace    bool
 		contextSize         uint64
@@ -215,7 +215,7 @@ func TestWorkingTreeDiff(t *testing.T) {
 				HasStagedChanges: false,
 				Tracked:          true,
 			},
-			plain:               false,
+			mode:                DiffModeRendered,
 			cached:              false,
 			ignoreWhitespace:    false,
 			contextSize:         3,
@@ -230,7 +230,7 @@ func TestWorkingTreeDiff(t *testing.T) {
 				HasStagedChanges: false,
 				Tracked:          true,
 			},
-			plain:               false,
+			mode:                DiffModeRendered,
 			cached:              true,
 			ignoreWhitespace:    false,
 			contextSize:         3,
@@ -245,7 +245,7 @@ func TestWorkingTreeDiff(t *testing.T) {
 				HasStagedChanges: false,
 				Tracked:          true,
 			},
-			plain:               true,
+			mode:                DiffModePlain,
 			cached:              false,
 			ignoreWhitespace:    false,
 			contextSize:         3,
@@ -260,7 +260,7 @@ func TestWorkingTreeDiff(t *testing.T) {
 				HasStagedChanges: false,
 				Tracked:          false,
 			},
-			plain:               false,
+			mode:                DiffModeRendered,
 			cached:              false,
 			ignoreWhitespace:    false,
 			contextSize:         3,
@@ -275,7 +275,7 @@ func TestWorkingTreeDiff(t *testing.T) {
 				HasStagedChanges: false,
 				Tracked:          true,
 			},
-			plain:               false,
+			mode:                DiffModeRendered,
 			cached:              false,
 			ignoreWhitespace:    true,
 			contextSize:         3,
@@ -290,7 +290,7 @@ func TestWorkingTreeDiff(t *testing.T) {
 				HasStagedChanges: false,
 				Tracked:          true,
 			},
-			plain:               false,
+			mode:                DiffModeRendered,
 			cached:              false,
 			ignoreWhitespace:    false,
 			contextSize:         17,
@@ -305,7 +305,7 @@ func TestWorkingTreeDiff(t *testing.T) {
 				HasStagedChanges: false,
 				Tracked:          true,
 			},
-			plain:               false,
+			mode:                DiffModeRendered,
 			cached:              false,
 			ignoreWhitespace:    false,
 			contextSize:         3,
@@ -326,7 +326,7 @@ func TestWorkingTreeDiff(t *testing.T) {
 			}

 			instance := buildWorkingTreeCommands(commonDeps{runner: s.runner, userConfig: userConfig, appState: &config.AppState{}, repoPaths: &repoPaths})
-			result := instance.WorktreeFileDiff(s.file, s.plain, s.cached)
+			result := instance.WorktreeFileDiff(s.file, s.mode, s.cached)
 			assert.Equal(t, expectedResult, result)
 			s.runner.CheckForMissingCalls()
 		})
@@ -341,7 +341,7 @@ func TestWorkingTreeShowFileDiff(t *testing.T) {
 		reverse          bool
 		fileName         string
 		previousPath     string
-		plain            bool
+		mode             DiffMode
 		ignoreWhitespace bool
 		contextSize      uint64
 		runner           *oscommands.FakeCmdObjRunner
@@ -356,7 +356,7 @@ func TestWorkingTreeShowFileDiff(t *testing.T) {
 			to:               "0987654321",
 			reverse:          false,
 			fileName:         "test.txt",
-			plain:            false,
+			mode:             DiffModeRendered,
 			ignoreWhitespace: false,
 			contextSize:      3,
 			runner: oscommands.NewFakeRunner(t).
@@ -368,7 +368,7 @@ func TestWorkingTreeShowFileDiff(t *testing.T) {
 			to:               "0987654321",
 			reverse:          false,
 			fileName:         "test.txt",
-			plain:            false,
+			mode:             DiffModeRendered,
 			ignoreWhitespace: false,
 			contextSize:      123,
 			runner: oscommands.NewFakeRunner(t).
@@ -380,7 +380,7 @@ func TestWorkingTreeShowFileDiff(t *testing.T) {
 			to:               "0987654321",
 			reverse:          false,
 			fileName:         "test.txt",
-			plain:            false,
+			mode:             DiffModeRendered,
 			ignoreWhitespace: true,
 			contextSize:      3,
 			runner: oscommands.NewFakeRunner(t).
@@ -393,7 +393,7 @@ func TestWorkingTreeShowFileDiff(t *testing.T) {
 			reverse:          false,
 			fileName:         "new.txt",
 			previousPath:     "old.txt",
-			plain:            false,
+			mode:             DiffModeRendered,
 			ignoreWhitespace: false,
 			contextSize:      3,
 			runner: oscommands.NewFakeRunner(t).
@@ -412,7 +412,7 @@ func TestWorkingTreeShowFileDiff(t *testing.T) {

 			instance := buildWorkingTreeCommands(commonDeps{runner: s.runner, userConfig: userConfig, appState: &config.AppState{}, repoPaths: &repoPaths})

-			result, err := instance.ShowFileDiff(s.from, s.to, s.reverse, s.fileName, s.previousPath, s.plain)
+			result, err := instance.ShowFileDiff(s.from, s.to, s.reverse, s.fileName, s.previousPath, s.mode)
 			assert.NoError(t, err)
 			assert.Equal(t, expectedResult, result)
 			s.runner.CheckForMissingCalls()
@@ -33,7 +33,7 @@ type fileInfo struct {
 }

 type (
-	loadFileDiffFunc func(from string, to string, reverse bool, filename string, previousPath string, plain bool) (string, error)
+	loadFileDiffFunc func(from string, to string, reverse bool, filename string, previousPath string) (string, error)
 )

 // PatchBuilder manages the building of a patch for a commit to be applied to another commit (or the working tree, or removed from the current commit). We also support building patches from things like stashes, for which there is less flexibility
@@ -162,7 +162,7 @@ func (p *PatchBuilder) getFileInfo(filename string, previousPath string) (*fileI
 		return info, nil
 	}

-	diff, err := p.loadFileDiff(from, to, reverse, filename, previousPath, true)
+	diff, err := p.loadFileDiff(from, to, reverse, filename, previousPath)
 	if err != nil {
 		return nil, err
 	}
@@ -50,6 +50,22 @@ func setupKeyRecorder(t *testing.T, g *Gui) (GocuiEvent, *[]int) {
 	return GocuiEvent{Type: eventKey, Key: key}, &fired
 }

+// runQueuedWork runs what the gui has queued for the following passes of the
+// event loop, which is where EndBlockingEvents leaves the replay of the keys it
+// buffered.
+func runQueuedWork(t *testing.T, g *Gui) {
+	t.Helper()
+
+	for {
+		ev, ok := g.userEvents.dequeue()
+		if !ok {
+			return
+		}
+		assert.NoError(t, ev.f(g))
+		ev.task.Done()
+	}
+}
+
 func TestBlockingEvents_KeysBufferedAndReplayed(t *testing.T) {
 	g := newTestGui(t)
 	keyEvent, fired := setupKeyRecorder(t, g)
@@ -64,12 +80,37 @@ func TestBlockingEvents_KeysBufferedAndReplayed(t *testing.T) {
 	assert.NoError(t, g.handleEvent(&keyEvent))
 	assert.Len(t, *fired, 1, "buffered keys must not dispatch while blocking")

-	// Unblocking replays the buffered keys.
-	assert.NoError(t, g.EndBlockingEvents())
+	// Unblocking queues the replay rather than dispatching from here.
+	g.EndBlockingEvents()
+	assert.Len(t, *fired, 1, "the replay must wait for the event loop")
+
+	runQueuedWork(t, g)
 	assert.Len(t, *fired, 3, "both buffered keys should replay on unblock")
 	assert.Empty(t, g.bufferedKeyEvents)
 }

+func TestBlockingEvents_KeysArrivingBeforeTheReplayGoBehindIt(t *testing.T) {
+	g := newTestGui(t)
+	keyEvent, fired := setupKeyRecorder(t, g)
+	other := GocuiEvent{Type: eventKey, Key: NewKeyRune('y')}
+	g.SetKeybinding("main", other.Key, func(*Gui, *View) error {
+		*fired = append(*fired, 0)
+		return nil
+	})
+
+	g.BeginBlockingEvents()
+	assert.NoError(t, g.handleEvent(&keyEvent))
+	g.EndBlockingEvents()
+
+	// A key pressed while the replay is still queued joins the end of the buffer:
+	// dispatching it now would put it ahead of the keys buffered before it.
+	assert.NoError(t, g.handleEvent(&other))
+	assert.Empty(t, *fired)
+
+	runQueuedWork(t, g)
+	assert.Equal(t, []int{1, 0}, *fired, "the keys should arrive in the order they were pressed")
+}
+
 func TestBlockingEvents_NestsWithCounter(t *testing.T) {
 	g := newTestGui(t)
 	keyEvent, fired := setupKeyRecorder(t, g)
@@ -79,11 +120,13 @@ func TestBlockingEvents_NestsWithCounter(t *testing.T) {
 	assert.NoError(t, g.handleEvent(&keyEvent))

 	// The inner block ending still leaves us blocked: no replay yet.
-	assert.NoError(t, g.EndBlockingEvents())
+	g.EndBlockingEvents()
+	runQueuedWork(t, g)
 	assert.Empty(t, *fired)

 	// Only the outermost block ending replays.
-	assert.NoError(t, g.EndBlockingEvents())
+	g.EndBlockingEvents()
+	runQueuedWork(t, g)
 	assert.Len(t, *fired, 1)
 }

@@ -94,5 +137,6 @@ func TestBlockingEvents_MouseClicksDroppedNotBuffered(t *testing.T) {
 	click := GocuiEvent{Type: eventMouse, Key: NewKeyName(MouseLeft)}
 	assert.NoError(t, g.handleEvent(&click))
 	assert.Empty(t, g.bufferedKeyEvents, "mouse clicks must be dropped, not buffered")
-	assert.NoError(t, g.EndBlockingEvents())
+	g.EndBlockingEvents()
+	runQueuedWork(t, g)
 }
@@ -236,10 +236,13 @@ type Gui struct {
 	// blockInputCount, when greater than zero, withholds keyboard input from
 	// the handlers: key events are buffered into bufferedKeyEvents and replayed
 	// once the count drops back to zero, while mouse clicks and hover are
-	// dropped outright. It's a counter so blocking can nest. Both fields are
-	// only touched on the UI thread. See BeginBlockingEvents.
+	// dropped outright. It's a counter so blocking can nest. replayPending says
+	// that the replay is queued but hasn't run yet, and input is withheld until
+	// it has. All three fields are only touched on the UI thread. See
+	// BeginBlockingEvents.
 	blockInputCount   int
 	bufferedKeyEvents []GocuiEvent
+	replayPending     bool
 }

 type NewGuiOpts struct {
@@ -930,12 +933,33 @@ func (g *Gui) BeginBlockingEvents() {
 // normal dispatch path, so they act on the now-current context (a key whose
 // binding no longer exists is simply ignored, just as if it had been pressed
 // now). Must be called on the UI thread.
-func (g *Gui) EndBlockingEvents() error {
+//
+// The replay is queued rather than run here, so that the buffered keys arrive on
+// a later pass of the event loop, as they would have if the user had pressed them
+// then. Running them here dispatches them from the middle of whatever the caller
+// was doing. If a caller ends the block partway through updating the screen, a
+// handler then acts on state the caller has yet to finish writing.
+func (g *Gui) EndBlockingEvents() {
 	g.blockInputCount--
 	if g.blockInputCount > 0 {
-		return nil
+		return
 	}

+	// Input stays withheld until the replay has run. Gui events are dispatched in
+	// preference to queued work (see processRemainingEvents), so a key pressed
+	// before the replay gets its turn would otherwise be handled ahead of the keys
+	// buffered before it.
+	g.replayPending = true
+	g.Update(func(*Gui) error { return g.replayBufferedKeys() })
+}
+
+// replayBufferedKeys dispatches the keys withheld while input was blocked, and
+// lets input through again. One of their handlers may block input afresh, and
+// then the keys after it are withheld in their turn, to be replayed when that
+// block ends.
+func (g *Gui) replayBufferedKeys() error {
+	g.replayPending = false
+
 	buffered := g.bufferedKeyEvents
 	g.bufferedKeyEvents = nil
 	for i := range buffered {
@@ -1206,7 +1230,7 @@ func (g *Gui) processRemainingEvents() (bool, error) {
 // handleEvent handles an event, based on its type (key-press, error,
 // etc.)
 func (g *Gui) handleEvent(ev *GocuiEvent) error {
-	if g.blockInputCount > 0 && eventWithheldWhileBlocking(ev) {
+	if g.withholdingInput() && eventWithheldWhileBlocking(ev) {
 		if ev.Type == eventKey {
 			// Buffer keys so they replay against fresh state on unblock.
 			g.bufferedKeyEvents = append(g.bufferedKeyEvents, *ev)
@@ -1235,6 +1259,13 @@ func (g *Gui) handleEvent(ev *GocuiEvent) error {
 	}
 }

+// withholdingInput reports whether events are being kept from the handlers. They
+// are while a block is in force, and on until the keys it buffered have been
+// replayed.
+func (g *Gui) withholdingInput() bool {
+	return g.blockInputCount > 0 || g.replayPending
+}
+
 // eventWithheldWhileBlocking reports whether an event must not reach the
 // handlers while input is blocked (see BeginBlockingEvents). Key events are
 // withheld (buffered for replay); mouse clicks and hover are withheld (dropped).
@@ -637,6 +637,13 @@ 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
@@ -1477,9 +1484,9 @@ func (v *View) CopyContent(from *View) {

 	// A background task may be streaming output into the source view's buffer
 	// via Write, so read it under its own lock. The source is always a
-	// different view than the destination (see the sole caller,
-	// moveMainContextToTop), and no other code holds two view write locks at
-	// once, so this can't deadlock.
+	// different view than the destination — its callers hand content from one
+	// view to another — and no other code holds two view write locks at once, so
+	// this can't deadlock.
 	from.writeMutex.Lock()
 	defer from.writeMutex.Unlock()

@@ -1996,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) {
@@ -2288,6 +2346,11 @@ 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.
@@ -2380,6 +2443,23 @@ func (v *View) SelectedLineRange() (int, int) {
 	return start, end
 }

+// SelectedBufferLineRange is SelectedLineRange in buffer lines (see
+// BufferLineForViewLine): the first and last line of the view's content that the
+// selection covers, however the view wraps them. ok is false when the selection
+// isn't on the content, which happens when there is none.
+func (v *View) SelectedBufferLineRange() (int, int, bool) {
+	first, last := v.SelectedLineRange()
+	firstBufferLine, ok := v.BufferLineForViewLine(first)
+	if !ok {
+		return 0, 0, false
+	}
+	lastBufferLine, ok := v.BufferLineForViewLine(last)
+	if !ok {
+		return 0, 0, false
+	}
+	return firstBufferLine, lastBufferLine, true
+}
+
 func (v *View) RenderTextArea() {
 	v.Clear()
 	fmt.Fprint(v, v.TextArea.GetContent())
@@ -453,6 +453,26 @@ func TestLastViewLineForBufferLine(t *testing.T) {
 	assert.False(t, ok)
 }

+func TestSelectedBufferLineRange(t *testing.T) {
+	v := NewView("name", 0, 0, 10, 10, OutputNormal) // InnerWidth is 9
+	v.Wrap = true
+
+	_, _, ok := v.SelectedBufferLineRange()
+	assert.False(t, ok)
+
+	// Buffer line 1 wraps into view lines 1, 2 and 3.
+	v.writeString("short\n" + strings.Repeat("b", 27) + "\nlast")
+
+	// A range from the middle of the wrapped line to the line below it covers both
+	// lines.
+	v.FocusPoint(0, 2, false)
+	v.SetRangeSelectStart(4)
+	first, last, ok := v.SelectedBufferLineRange()
+	assert.True(t, ok)
+	assert.Equal(t, 1, first)
+	assert.Equal(t, 2, last)
+}
+
 // While an async re-render loads, it swaps in only a partially-filled buffer at
 // its first paint and keeps appending lines afterwards. The scrollbar must keep
 // using the pre-load height until the load ends, so the thumb doesn't shrink and
@@ -13,14 +13,15 @@ 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
-	onRenderToMainFn    func()
-	onFocusFns          []onFocusFn
-	onFocusLostFns      []onFocusLostFn
-	onQuitFns           []func()
+	keybindingsFns            []types.KeybindingsFn
+	mouseKeybindingsFns       []types.MouseKeybindingsFn
+	onDoubleClickFn           func() error
+	onClickFn                 func(opts gocui.ViewMouseBindingOpts) error
+	focusedMainViewDiffSource types.FocusedMainViewDiffSource
+	onRenderToMainFn          func()
+	onFocusFns                []onFocusFn
+	onFocusLostFns            []onFocusLostFn
+	onQuitFns                 []func()

 	focusable                   bool
 	transient                   bool
@@ -159,6 +160,7 @@ func (self *BaseContext) ClearAllAttachedControllerFunctions() {
 	self.onQuitFns = nil
 	self.onDoubleClickFn = nil
 	self.onClickFn = nil
+	self.focusedMainViewDiffSource = nil
 	self.onRenderToMainFn = nil
 }

@@ -180,6 +182,15 @@ func (self *BaseContext) AddOnClickFn(fn func(opts gocui.ViewMouseBindingOpts) e
 	}
 }

+func (self *BaseContext) AddFocusedMainViewDiffSource(source types.FocusedMainViewDiffSource) {
+	if source != nil {
+		if self.focusedMainViewDiffSource != nil {
+			panic("only one controller is allowed to set the focused main view diff source")
+		}
+		self.focusedMainViewDiffSource = source
+	}
+}
+
 func (self *BaseContext) GetOnDoubleClick() func() error {
 	return self.onDoubleClickFn
 }
@@ -188,6 +199,10 @@ func (self *BaseContext) GetOnClick() func(opts gocui.ViewMouseBindingOpts) erro
 	return self.onClickFn
 }

+func (self *BaseContext) GetFocusedMainViewDiffSource() types.FocusedMainViewDiffSource {
+	return self.focusedMainViewDiffSource
+}
+
 func (self *BaseContext) AddOnRenderToMainFn(fn func()) {
 	if fn != nil {
 		if self.onRenderToMainFn != nil {
@@ -85,10 +85,16 @@ func (self *CommitFilesContext) RefForAdjustingLineNumberInDiff() string {
 }

 func (self *CommitFilesContext) GetFromAndToForDiff() (string, string) {
-	if refs := self.GetRefRange(); refs != nil {
-		return refs.From.ParentRefName(), refs.To.RefName()
+	return FromAndToForDiff(self.GetRef(), self.GetRefRange())
+}
+
+// FromAndToForDiff gives the two ends to diff for a ref, or for a range of them: a
+// range runs from the parent of its first ref to its last, a single ref from its own
+// parent to itself.
+func FromAndToForDiff(ref models.Ref, refRange *types.RefRange) (string, string) {
+	if refRange != nil {
+		return refRange.From.ParentRefName(), refRange.To.RefName()
 	}
-	ref := self.GetRef()
 	return ref.ParentRefName(), ref.RefName()
 }

@@ -19,6 +19,11 @@ type MainContext struct {
 	// 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
+	// contentIsDiff says the render this pane was last given is the diff the panel
+	// beneath offers here, rather than a message or an explanation (see
+	// types.ContentIsDiff). It is known as the render is asked for, well before there
+	// is any content to look at.
+	contentIsDiff bool
 }

 var (
@@ -65,6 +70,17 @@ func (self *MainContext) SetSelectableContentRenderKey(key string) {
 	self.selectableContentRenderKey = key
 }

+// ContentIsDiff reports whether this pane is showing the panel's diff (see
+// contentIsDiff).
+func (self *MainContext) ContentIsDiff() bool {
+	return self.contentIsDiff
+}
+
+// SetContentIsDiff records what kind of render the pane is being given.
+func (self *MainContext) SetContentIsDiff(value bool) {
+	self.contentIsDiff = value
+}
+
 func NewMainContext(
 	view *gocui.View,
 	windowName string,
@@ -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,
@@ -8,6 +8,7 @@ func AttachControllers(context types.Context, controllers ...types.IController)
 		context.AddMouseKeybindingsFn(controller.GetMouseKeybindings)
 		context.AddOnDoubleClickFn(controller.GetOnDoubleClick())
 		context.AddOnClickFn(controller.GetOnClick())
+		context.AddFocusedMainViewDiffSource(controller.GetFocusedMainViewDiffSource())
 		context.AddOnRenderToMainFn(controller.GetOnRenderToMain())
 		context.AddOnFocusFn(controller.GetOnFocus())
 		context.AddOnFocusLostFn(controller.GetOnFocusLost())
@@ -23,6 +23,10 @@ func (self *baseController) GetOnClick() func(opts gocui.ViewMouseBindingOpts) e
 	return nil
 }

+func (self *baseController) GetFocusedMainViewDiffSource() types.FocusedMainViewDiffSource {
+	return nil
+}
+
 func (self *baseController) GetOnRenderToMain() func() {
 	return nil
 }
@@ -175,9 +175,10 @@ func (self *CommitFilesController) GetOnRenderToMain() func() {
 		from, to := self.context().GetFromAndToForDiff()
 		from, reverse := self.c.Modes().Diffing.GetFromAndReverseArgsForDiff(from)

+		mode := self.c.Helpers().DiffLine.MainViewDiffMode()
 		paths := self.pathsForDiff(node)
-		cmdObj := self.c.Git().WorkingTree.ShowFileDiffCmdObj(from, to, reverse, paths, false)
-		task := types.NewRunDiffRendererTask(cmdObj.GetCmd())
+		cmdObj := self.c.Git().WorkingTree.ShowFileDiffCmdObj(from, to, reverse, paths, mode)
+		task := types.NewMainViewDiffTask(cmdObj.GetCmd(), mode)

 		self.c.RenderToMainViews(types.RefreshMainOpts{
 			Pair: self.c.MainViewPairs().Normal,
@@ -191,11 +192,23 @@ func (self *CommitFilesController) GetOnRenderToMain() func() {
 	}
 }

+func (self *CommitFilesController) GetFocusedMainViewDiffSource() types.FocusedMainViewDiffSource {
+	return self
+}
+
+// PlainDiff hands out the commit's diff for the given files. Both panes show the same
+// diff here — the secondary one shows the custom patch built from it, which is not a
+// diff of the commit — so which pane asks makes no difference.
+func (self *CommitFilesController) PlainDiff(_ types.DiffPaneContext, paths []string) string {
+	from, to := self.context().GetFromAndToForDiff()
+	return self.c.Helpers().Diff.PlainDiffBetweenRefs(from, to, paths)
+}
+
 func (self *CommitFilesController) copyDiffToClipboard(paths []string, toastMessage string) error {
 	from, to := self.context().GetFromAndToForDiff()
 	from, reverse := self.c.Modes().Diffing.GetFromAndReverseArgsForDiff(from)

-	cmdObj := self.c.Git().WorkingTree.ShowFileDiffCmdObj(from, to, reverse, paths, true)
+	cmdObj := self.c.Git().WorkingTree.ShowFileDiffCmdObj(from, to, reverse, paths, git_commands.DiffModePlain)
 	diff, err := cmdObj.RunWithOutput()
 	if err != nil {
 		return err
@@ -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
@@ -21,6 +21,9 @@ type FilesController struct {
 	baseController
 	*ListControllerTrait[*filetree.FileNode]
 	c *ControllerCommon
+
+	// what this panel offers on the diff it shows in the focused main view
+	diffActions *WorkingTreeDiffActions
 }

 var _ types.IController = &FilesController{}
@@ -36,6 +39,7 @@ func NewFilesController(
 			c.Contexts().Files.GetSelected,
 			c.Contexts().Files.GetSelectedItems,
 		),
+		diffActions: NewWorkingTreeDiffActions(c),
 	}
 }

@@ -348,7 +352,7 @@ func (self *FilesController) renderNonTextualConflict(node *filetree.FileNode) {
 	message := self.conflictResolutionHint(node.File.GetMergeStateDescription(self.c.Tr))

 	if node.File.ShortStatus == "DU" || node.File.ShortStatus == "UD" {
-		cmdObj := self.c.Git().Diff.DiffCmdObj([]string{"--base", "--", node.GetPath()})
+		cmdObj := self.c.Git().Diff.DiffCmdObj([]string{"--base", "--", node.GetPath()}, git_commands.DiffModeRendered)
 		prefix := message + "\n\n"
 		if node.File.ShortStatus == "DU" {
 			prefix += self.c.Tr.MergeConflictIncomingDiff
@@ -366,42 +370,50 @@ func (self *FilesController) renderNonTextualConflict(node *filetree.FileNode) {
 func (self *FilesController) renderWorkingTreeDiff(node *filetree.FileNode) {
 	self.c.Helpers().MergeConflicts.ResetMergeState()

-	split := self.c.UserConfig().Gui.SplitDiff == "always" || (node.GetHasUnstagedChanges() && node.GetHasStagedChanges())
-	mainShowsStaged := !split && node.GetHasStagedChanges()
+	// The unstaged side of a file's diff is shown in the main pane and the staged side
+	// in the secondary one, each only where there is a side to show — so a side is
+	// always in the same place, whatever the file happens to have. A file with nothing
+	// unstaged therefore shows its staged changes in the secondary pane, which then has
+	// the whole section to itself. Configured to always split, both panes are shown
+	// whether or not there is anything on either side.
+	alwaysSplit := self.c.UserConfig().Gui.SplitDiff == "always"
+	showStaged := node.GetHasStagedChanges() || alwaysSplit
+	showUnstaged := node.GetHasUnstagedChanges() || alwaysSplit || !showStaged
+
+	// While the main view is focused to act on this diff, it may have to be git's own
+	// rather than the diff renderer's; both panes have to agree about that.
+	mode := self.c.Helpers().DiffLine.MainViewDiffMode()

 	paths := self.pathsForDiff(node)
-	cmdObj := self.c.Git().WorkingTree.WorktreeFileDiffCmdObj(node, false, mainShowsStaged, paths)
-	title := self.c.Tr.UnstagedChanges
-	if mainShowsStaged {
-		title = self.c.Tr.StagedChanges
-	}
-	refreshOpts := types.RefreshMainOpts{
-		Pair: self.c.MainViewPairs().Normal,
-		Main: &types.ViewUpdateOpts{
-			Task:     types.NewRunDiffRendererTask(cmdObj.GetCmd()),
-			SubTitle: self.c.Helpers().Diff.IgnoringWhitespaceSubTitle(),
-			Title:    title,
-		},
-	}
+	refreshOpts := types.RefreshMainOpts{Pair: self.c.MainViewPairs().Normal}

-	if split {
-		cmdObj := self.c.Git().WorkingTree.WorktreeFileDiffCmdObj(node, false, true, paths)
-
-		title := self.c.Tr.StagedChanges
-		if mainShowsStaged {
-			title = self.c.Tr.UnstagedChanges
+	if showUnstaged {
+		cmdObj := self.c.Git().WorkingTree.WorktreeFileDiffCmdObj(node, mode, false, paths)
+		refreshOpts.Main = &types.ViewUpdateOpts{
+			Task:           types.NewMainViewDiffTask(cmdObj.GetCmd(), mode),
+			SubTitle:       self.c.Helpers().Diff.IgnoringWhitespaceSubTitle(),
+			Title:          self.c.Tr.UnstagedChanges,
+			NothingToActOn: !node.GetHasUnstagedChanges(),
 		}
+	}

+	if showStaged {
+		cmdObj := self.c.Git().WorkingTree.WorktreeFileDiffCmdObj(node, mode, true, paths)
 		refreshOpts.Secondary = &types.ViewUpdateOpts{
-			Title:    title,
-			SubTitle: self.c.Helpers().Diff.IgnoringWhitespaceSubTitle(),
-			Task:     types.NewRunDiffRendererTask(cmdObj.GetCmd()),
+			Task:           types.NewMainViewDiffTask(cmdObj.GetCmd(), mode),
+			SubTitle:       self.c.Helpers().Diff.IgnoringWhitespaceSubTitle(),
+			Title:          self.c.Tr.StagedChanges,
+			NothingToActOn: !node.GetHasStagedChanges(),
 		}
 	}

 	self.c.RenderToMainViews(refreshOpts)
 }

+func (self *FilesController) GetFocusedMainViewDiffSource() types.FocusedMainViewDiffSource {
+	return self.diffActions
+}
+
 func (self *FilesController) GetOnDoubleClick() func() error {
 	return self.withItemGraceful(func(node *filetree.FileNode) error {
 		return self.press([]*filetree.FileNode{node})
@@ -99,21 +99,27 @@ func (self *AppStatusHelper) WithWaitingStatusBlockingInput(opts types.WaitingSt
 		self.modeHelper.SetSuppressWorkingTreeStateMode(true)
 	}
 	self.c.OnWorker(func(task gocui.Task) error {
-		// End the block and restore the mode indicator once the operation and its
-		// refresh have applied their UI updates: OnUIThread queues this after the
-		// refresh's model bounces and Then (which RefreshFromWorker has already
-		// enqueued by the time f returns), so the replayed keys act on the
-		// refreshed state and any resulting working tree state shows correctly.
-		defer self.c.OnUIThread(func() error {
-			if opts.HideWorkingTreeState {
-				self.modeHelper.SetSuppressWorkingTreeStateMode(false)
-			}
-			return self.c.GocuiGui().EndBlockingEvents()
-		})
+		defer self.endBlockingInput(opts.HideWorkingTreeState)
 		return self.WithWaitingStatusImpl(opts.Message, f, task)
 	})
 }

+// endBlockingInput lets input through again once the operation and its refresh
+// have applied their UI updates, and restores the mode indicator with it.
+// OnUIThread queues this after the refresh's model bounces and Then (which
+// RefreshFromWorker has already enqueued by the time the operation returns), so
+// the replayed keys act on the refreshed state and any resulting working tree
+// state shows correctly.
+func (self *AppStatusHelper) endBlockingInput(hideWorkingTreeState bool) {
+	self.c.OnUIThread(func() error {
+		if hideWorkingTreeState {
+			self.modeHelper.SetSuppressWorkingTreeStateMode(false)
+		}
+		self.c.GocuiGui().EndBlockingEvents()
+		return nil
+	})
+}
+
 func (self *AppStatusHelper) HasStatus() bool {
 	return self.statusMgr().HasStatus()
 }
@@ -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,
 	}
 }

@@ -53,6 +55,8 @@ func (self *DiffHelper) DiffArgs() []string {
 // either there's no range, or it can't be diffed for some reason), then we want
 // to fall back to rendering the diff for the single commit.
 func (self *DiffHelper) GetUpdateTaskForRenderingCommitsDiff(commit *models.Commit, refRange *types.RefRange) types.UpdateTask {
+	mode := self.diffLineHelper.MainViewDiffMode()
+
 	if refRange != nil {
 		from, to := refRange.From, refRange.To
 		args := []string{from.ParentRefName(), to.RefName(), "--stat", "-p"}
@@ -72,13 +76,26 @@ func (self *DiffHelper) GetUpdateTaskForRenderingCommitsDiff(commit *models.Comm
 				args = append(args, filterPath)
 			}
 		}
-		cmdObj := self.c.Git().Diff.DiffCmdObj(args)
+		cmdObj := self.c.Git().Diff.DiffCmdObj(args, mode)
 		prefix := style.FgYellow.Sprintf("%s %s-%s\n\n", self.c.Tr.ShowingDiffForRange, from.ShortRefName(), to.ShortRefName())
-		return types.NewRunDiffRendererTaskWithPrefix(cmdObj.GetCmd(), prefix)
+		return types.NewMainViewDiffTaskWithPrefix(cmdObj.GetCmd(), prefix, mode)
 	}

-	cmdObj := self.c.Git().Commit.ShowCmdObj(commit.Hash(), self.FilterPathsForCommit(commit))
-	return types.NewRunDiffRendererTask(cmdObj.GetCmd())
+	cmdObj := self.c.Git().Commit.ShowCmdObj(commit.Hash(), self.FilterPathsForCommit(commit), mode)
+	return types.NewMainViewDiffTask(cmdObj.GetCmd(), mode)
+}
+
+// PlainDiffBetweenRefs returns the diff of the given files between two refs as git
+// writes it, without colour or a diff renderer's involvement — what a panel showing
+// a commit's diff hands out as the diff behind its rendering (see
+// types.FocusedMainViewDiffSource). It honours diffing mode, so that the diff is of
+// the same two ends the main view is showing.
+func (self *DiffHelper) PlainDiffBetweenRefs(from string, to string, paths []string) string {
+	from, reverse := self.c.Modes().Diffing.GetFromAndReverseArgsForDiff(from)
+	// An error means there is no diff to be had, which for our purposes is the same
+	// as an empty one.
+	diff, _ := self.c.Git().WorkingTree.ShowFileDiffCmdObj(from, to, reverse, paths, git_commands.DiffModePlain).RunWithOutput()
+	return diff
 }

 func (self *DiffHelper) FilterPathsForCommit(commit *models.Commit) []string {
@@ -107,19 +124,24 @@ 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()
 	}
 }

 func (self *DiffHelper) RenderDiff() {
 	args := self.DiffArgs()
-	cmdObj := self.c.Git().Diff.DiffCmdObj(args)
+	cmdObj := self.c.Git().Diff.DiffCmdObj(args, git_commands.DiffModeRendered)
 	prefix := style.FgMagenta.Sprintf(
 		"%s %s\n\n",
 		self.c.Tr.ShowingGitDiff,
 		"git diff "+strings.Join(args, " "),
 	)
-	task := types.NewRunDiffRendererTaskWithPrefix(cmdObj.GetCmd(), prefix)
+	task := types.NewMainViewDiffTaskWithPrefix(cmdObj.GetCmd(), prefix, git_commands.DiffModeRendered)

 	self.c.RenderToMainViews(types.RefreshMainOpts{
 		Pair: self.c.MainViewPairs().Normal,
@@ -9,6 +9,11 @@ import (

 type DiffLineHelper struct {
 	c *HelperCommon
+
+	// What the probe said about the diff renderer that rendererSignature names, or nil
+	// before it has been asked about any (see diffRendererEmitsMetadata).
+	rendererEmitsMetadata *bool
+	rendererSignature     string
 }

 func NewDiffLineHelper(c *HelperCommon) *DiffLineHelper {
@@ -32,48 +37,70 @@ 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) {
-		if info, ok := self.diffLineInfoFromRecords(contents[bufferLineIdx].Metadata); ok {
-			return info, 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
 }

-// diffLineInfoFromRecords recovers a row's identity from the records the diff
-// renderer stated for it. ok is false when the row carries no record we understand.
-//
-// 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); the leftmost
-// is the one a reader would call the row's own, so it is the row's identity.
+// 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))
+}
+
+// diffLineInfoFromRecords recovers a row's own identity from the records the diff
+// renderer stated for it. That is the line the row leads with, of the ones
+// diffLineIdentitiesFromRecords finds on it. ok is false when the row carries no
+// record we understand.
 func (self *DiffLineHelper) diffLineInfoFromRecords(metadata []string) (types.DiffLineInfo, bool) {
-	if len(metadata) == 0 {
+	identities := self.diffLineIdentitiesFromRecords(metadata)
+	if len(identities) == 0 {
 		return types.DiffLineInfo{}, false
 	}
-	parsed, ok := parseDiffLineMetadata(metadata[0])
-	if !ok {
-		return types.DiffLineInfo{}, false
-	}
-	return self.diffLineInfo(parsed), true
+	return identities[0], true
 }

 // resolvedDiffLine is one rendered row's recovered identity, plus whether it could
@@ -86,36 +113,59 @@ type resolvedDiffLine struct {
 // 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), and reads the rendering the same way: by the renderer's records, or by
-// parsing it as a unified diff (see renderingStatesDiffLines). Resolving row by row
-// would re-run the buffer parser's whole-section parse once per row — O(n²) on a
-// large single-file diff — so the buffer parser runs once for the whole buffer.
+// 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))
-	if renderingStatesDiffLines(contents) {
-		for i, content := range contents {
-			if info, ok := self.diffLineInfoFromRecords(content.Metadata); ok {
-				resolved[i] = resolvedDiffLine{info, true}
-			}
-		}
-		return resolved
-	}
-
-	for i, parsed := range parseAllDiffLinesFromBuffer(diffLineTexts(contents)) {
-		if parsed.ok {
-			resolved[i] = resolvedDiffLine{self.diffLineInfo(parsed.parsed), true}
+	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{
@@ -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
@@ -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)
+		}
+	})
+}
@@ -0,0 +1,164 @@
+package helpers
+
+import (
+	"path/filepath"
+	"slices"
+	"strings"
+
+	"github.com/jesseduffield/lazygit/pkg/gocui"
+	"github.com/jesseduffield/lazygit/pkg/gui/types"
+)
+
+// Reading a rendering back to the diff it came from. What a diff view shows is a diff
+// renderer's picture of a diff, and a picture is not what you want on your clipboard,
+// or in a patch — so the lines of interest are located by identity in the diff itself,
+// which the panel that rendered it hands out (types.FocusedMainViewDiffSource).
+
+// PlainDiffOfSelection returns the text of the rows a selection covers in view, the
+// inclusive buffer-line range [first, last] (see DiffLinesInBufferRange), in two parts.
+//
+// aboveDiff is what the selection covers above the diff, as it reads on screen; see
+// textAboveDiff. fromDiff is the diff behind the rest: per file the selection touches,
+// the run of diff lines from the first of its selected lines to the last, with the
+// files in the order the selection meets them.
+//
+// A run, rather than the matched lines alone, so that what comes out reads as a diff:
+// the lines between two selected ones come along even when the rendering didn't show
+// them (difftastic leaves out whitespace-only changes) or showed them in another order
+// (a side-by-side rendering groups the deletions of a hunk before its additions).
+//
+// Headers are selected lines like any other. A hunk header names the first line of its
+// hunk, in the rendering as in the diff, so it is looked for the way a line of the file
+// is; a file header names no line at all and a rendering may spread it over as many
+// rows as it likes, so a selection touching one of them takes the whole header.
+//
+// plainDiff fetches the diff of the given repo-relative files, and is asked only for
+// the files the selection touches, so that copying three lines of a commit's diff
+// doesn't fetch the whole of it. fromDiff is "" when no selected row could be found in
+// the diff, e.g. because the selection covers nothing but a renderer's decoration.
+func (self *DiffLineHelper) PlainDiffOfSelection(
+	view *gocui.View, first int, last int, plainDiff func(paths []string) string,
+) (aboveDiff string, fromDiff string) {
+	worktreePath := self.c.Git().RepoPaths.WorktreePath()
+	aboveDiff = self.textAboveDiff(view, first, last)
+
+	// The files in the order they are shown, and per file what the selection covers of
+	// its diff.
+	paths := []string{}
+	selection := map[string]*selectedDiffLines{}
+	for _, info := range self.DiffLinesInBufferRange(view, first, last) {
+		// A row that is neither a line of the file nor a header — the "\ No newline at
+		// end of file" marker — names nothing to look for. It comes along anyway when it
+		// falls within a run.
+		if info.Type == types.DiffLineOther {
+			continue
+		}
+		selected, ok := selection[info.Path]
+		if !ok {
+			paths = append(paths, info.Path)
+			selected = &selectedDiffLines{lines: map[patchLine]bool{}}
+			selection[info.Path] = selected
+		}
+		if info.Type == types.DiffLineFileHeader {
+			selected.header = true
+		} else {
+			selected.lines[patchLineOf(info)] = true
+		}
+	}
+
+	relPaths := repoRelativePaths(worktreePath, paths)
+	if len(relPaths) == 0 {
+		return aboveDiff, ""
+	}
+
+	diffLines := strings.Split(strings.TrimSuffix(plainDiff(relPaths), "\n"), "\n")
+	runs := map[string][2]int{}
+	for i, parsed := range parseAllDiffLinesFromBuffer(diffLines) {
+		if !parsed.ok {
+			continue
+		}
+		info := diffLineInfoIn(worktreePath, parsed.parsed)
+		selected := selection[info.Path]
+		if selected == nil || !selected.covers(info) {
+			continue
+		}
+		if run, ok := runs[info.Path]; ok {
+			runs[info.Path] = [2]int{run[0], i}
+		} else {
+			runs[info.Path] = [2]int{i, i}
+		}
+	}
+
+	text := strings.Builder{}
+	for _, path := range paths {
+		run, ok := runs[path]
+		if !ok {
+			continue
+		}
+		for _, line := range diffLines[run[0] : run[1]+1] {
+			text.WriteString(line)
+			text.WriteString("\n")
+		}
+	}
+	return aboveDiff, text.String()
+}
+
+// textAboveDiff returns the text of the selected rows that sit above the diff, as they
+// read on screen. What a diff view shows before its first file — a commit's message and
+// git's summary of it — is part of no file's diff, so there is nothing to look those
+// rows up in and the rendering is all we have of them.
+//
+// It is "" for a view that shows no file at all: with no diff on screen there is
+// nothing for the text to be above, and a rendering we couldn't read as a diff is
+// exactly what we don't want on the clipboard.
+func (self *DiffLineHelper) textAboveDiff(view *gocui.View, first int, last int) string {
+	startOfDiff := slices.IndexFunc(self.filePaths(view), func(path string) bool { return path != "" })
+	if startOfDiff == -1 {
+		return ""
+	}
+
+	last = min(last, startOfDiff-1)
+	if last < first {
+		return ""
+	}
+	return strings.Join(view.BufferLines()[first:last+1], "\n") + "\n"
+}
+
+// selectedDiffLines is what a selection covers of one file's diff.
+type selectedDiffLines struct {
+	// The lines of the file to look for, hunk headers among them, by the identity that
+	// names them in any rendering of the diff.
+	lines map[patchLine]bool
+	// Whether the file's header is covered, in whole or in part.
+	header bool
+}
+
+// covers reports whether the given line of a file's diff is one the selection holds.
+//
+// A file header is answered for by kind rather than looked for: the two ways a row's
+// identity is recovered disagree about what to call it — a parse of the diff says the
+// file's first line, a renderer's record says the file has no line — and a rendering
+// may show the header as one row or as ten. So a selection that touches it holds every
+// line of it.
+func (self *selectedDiffLines) covers(info types.DiffLineInfo) bool {
+	if info.Type == types.DiffLineFileHeader {
+		return self.header
+	}
+	return self.lines[patchLineOf(info)]
+}
+
+// repoRelativePaths turns the absolute paths a diff line's identity carries into the
+// repo-relative ones git speaks, dropping any that lies outside the worktree — a diff
+// renderer states the path however it likes, and one we can't place is one we can't
+// ask git about.
+func repoRelativePaths(worktreePath string, paths []string) []string {
+	relPaths := make([]string, 0, len(paths))
+	for _, path := range paths {
+		relPath, err := filepath.Rel(worktreePath, path)
+		if err != nil || strings.HasPrefix(relPath, "..") {
+			continue
+		}
+		relPaths = append(relPaths, filepath.ToSlash(relPath))
+	}
+	return relPaths
+}
@@ -8,9 +8,41 @@ import (

 // 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
+// cursor and a click speak, except for what a selection covers (see
+// DiffLinesInBufferRange). They are all built on the identities recovered in
 // diff_line_helper.go, which is where the answering stops and the recovering starts.

+// DiffLinesInBufferRange returns the identity of every diff line shown by the rows in
+// the inclusive buffer-line range [first, last] of view's rendered diff, in display
+// order. Rows whose identity can't be recovered are left out.
+//
+// The range is what a selection covers (see View.SelectedBufferLineRange). It is given
+// in buffer lines because a buffer line stays on its line of the content however the
+// view wraps it, so the selection can be read when a key is pressed and acted on after
+// the view has changed.
+//
+// A row can show more than one diff line — a side-by-side rendering puts a deletion
+// beside the addition replacing it — and all of them are reported: what the user
+// pointed at is the row, so everything on it is selected.
+func (self *DiffLineHelper) DiffLinesInBufferRange(view *gocui.View, first int, last int) []types.DiffLineInfo {
+	identities := self.resolveDiffLineIdentities(view.DiffLineContents())
+
+	infos := []types.DiffLineInfo{}
+	for bufferLine := first; bufferLine <= min(last, len(identities)-1); bufferLine++ {
+		infos = append(infos, identities[bufferLine]...)
+	}
+	return infos
+}
+
+// ChangeLinesInBufferRange returns the change lines — the additions and deletions —
+// among the diff lines shown by the rows in the inclusive buffer-line range. Those are
+// the lines a patch is built from: a patch carries whatever context it needs around
+// them by itself, so a selection contributes only its changes.
+func (self *DiffLineHelper) ChangeLinesInBufferRange(view *gocui.View, first int, last int) []types.DiffLineInfo {
+	return lo.Filter(self.DiffLinesInBufferRange(view, first, last),
+		func(info types.DiffLineInfo, _ int) bool { return info.IsChange() })
+}
+
 // 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
@@ -191,17 +223,6 @@ func (self *DiffLineHelper) ChangeBlockBounds(view *gocui.View, anchorViewLine i
 	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
@@ -0,0 +1,112 @@
+package helpers
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/jesseduffield/lazygit/pkg/commands/git_commands"
+	"github.com/jesseduffield/lazygit/pkg/config"
+	"github.com/jesseduffield/lazygit/pkg/gocui"
+	"github.com/jesseduffield/lazygit/pkg/gui/types"
+	"github.com/jesseduffield/lazygit/pkg/tasks"
+)
+
+// Falling back to git's own diff when the configured one can't be acted on.
+//
+// A diff renderer is free to lay a diff out however it likes, and once it has, we can
+// only tell which line of which file a row shows if the renderer says so. A renderer
+// that doesn't produces a diff that can be read but not staged, edited or copied from,
+// so when the user focuses the main view to act on it, we show git's own diff instead.
+// Browsing keeps the renderer's version; only acting on it needs one we can follow.
+
+// MainViewDiffMode says how a side panel should produce the diff it renders into the
+// main view: as the user configured it, or as git's own — while the main view holds
+// focus and what the renderer would produce couldn't be acted on.
+//
+// Every panel that renders a diff into the main view asks, so that a re-render while
+// focused — after staging a hunk, say — stays with git's own diff rather than flipping
+// back to the renderer's.
+func (self *DiffLineHelper) MainViewDiffMode() git_commands.DiffMode {
+	if self.mainViewIsFocused() && self.diffNeedsMetadata() && !self.diffRendererEmitsMetadata() {
+		return git_commands.DiffModeRaw
+	}
+	return git_commands.DiffModeRendered
+}
+
+// RenderFocusedMainViewAgain has the panel beneath the focused main view render its
+// diff again — which, the main view now holding focus, is git's own diff rather than
+// the renderer's — and calls place once that is on screen.
+//
+// The whole diff is read before it is shown, rather than the first screenful: place
+// looks at what is there to decide where to put the selection, and a change line
+// further down would otherwise be missed.
+//
+// It is the same diff of the same files, so the view keeps the scroll position it has
+// rather than starting from the top: git lays the changes out its own way and the line
+// the user was on is somewhere else now, but the offset still puts them among the same
+// part of the file — and the selection is then established from what that leaves on
+// screen.
+func (self *DiffLineHelper) RenderFocusedMainViewAgain(view *gocui.View, sidePanel types.Context, place func()) {
+	manager := self.c.GetOrCreateViewBufferManagerForView(view)
+	if manager == nil {
+		return
+	}
+
+	manager.SetKeepScrollPositionForNextTask()
+	manager.SetRestoreForNextTask(&tasks.RenderRestore{
+		FirstPaintReady: func() bool { return false },
+		Apply: func(swapIn func()) {
+			swapIn()
+			place()
+		},
+	})
+
+	sidePanel.HandleRenderToMain()
+}
+
+func (self *DiffLineHelper) mainViewIsFocused() bool {
+	current := self.c.Context().CurrentStatic().GetKey()
+	return current == self.c.Contexts().Normal.GetKey() ||
+		current == self.c.Contexts().NormalSecondary.GetKey()
+}
+
+// diffNeedsMetadata reports whether the diff we would show is one whose rows can only
+// be placed in the file by the records the renderer states. Any custom renderer may
+// restructure the diff; so may git itself, once the renderer's arguments ask for a word
+// diff, whose markup is inline. Plain git output describes itself, and needs no records.
+func (self *DiffLineHelper) diffNeedsMetadata() bool {
+	manager := self.c.State().GetDiffRendererConfigManager()
+	if manager.GetDiffRendererType() != config.DiffRendererType_RawGit {
+		return true
+	}
+	return len(manager.GetRawGitArgs()) > 0
+}
+
+// diffRendererEmitsMetadata is the probed verdict about the current diff renderer, asked
+// once and remembered until the renderer changes — the user cycling to another one, or a
+// changed config being reloaded.
+func (self *DiffLineHelper) diffRendererEmitsMetadata() bool {
+	signature := self.diffRendererSignature()
+	if self.rendererEmitsMetadata == nil || signature != self.rendererSignature {
+		verdict := self.c.Git().Diff.ProbeDiffRendererEmitsMetadata()
+		self.rendererEmitsMetadata = &verdict
+		self.rendererSignature = signature
+	}
+	return *self.rendererEmitsMetadata
+}
+
+// diffRendererSignature identifies the current diff renderer, so that the remembered
+// verdict is dropped when it stops describing the renderer we have. The values a command
+// is resolved with are no part of its identity, so fixed ones are used.
+func (self *DiffLineHelper) diffRendererSignature() string {
+	manager := self.c.State().GetDiffRendererConfigManager()
+	index, _ := manager.CurrentDiffRendererIndex()
+	values := config.DiffRendererValues{}
+	externalDiff, _ := manager.GetExternalDiffCommand(values)
+	stdinFilter, _ := manager.GetStdinFilterCommand(values)
+	return fmt.Sprintf("%d\x00%s\x00%s\x00%s",
+		index,
+		externalDiff,
+		stdinFilter,
+		strings.Join(manager.GetRawGitArgs(), "\x00"))
+}
@@ -0,0 +1,545 @@
+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),
+) {
+	if len(candidates) == 0 {
+		return
+	}
+
+	// The search of the loading content runs on the task's own goroutine, where the
+	// repo we are in may not be read — a repo switch replaces it — so take it here, on
+	// the UI thread, for the search to work from.
+	worktreePath := self.c.Git().RepoPaths.WorktreePath()
+
+	// Which candidate the search settled on, for place to put back where it was.
+	found := diffLineAnchor{}
+
+	self.installDiffLineRestore(view,
+		func(rows []gocui.DiffLineContent, offset int) (int, bool) {
+			for i, row := range rows {
+				if rowShowsDiffLine(row, worktreePath, candidates[0].identity) {
+					found = candidates[0]
+					return offset + i, true
+				}
+			}
+			return 0, false
+		},
+		func(contents []gocui.DiffLineContent) (int, bool) {
+			anchor, bufferLine := self.nearestSurvivingCandidate(contents, candidates)
+			if bufferLine == -1 {
+				return 0, false
+			}
+			found = anchor
+			return bufferLine, true
+		},
+		func(viewLine int) { place(found, viewLine) },
+		nil,
+	)
+}
+
+// ChangeLineOrdinal returns how many change lines of view's rendered diff come before
+// the given buffer line — that line's place in the sequence of changes.
+//
+// It is how a place in a diff is remembered across acting on it: an action consumes
+// the lines it acted on, so the identity of the line the user was on is gone, but the
+// place it left behind is the same one that identity used to have.
+func (self *DiffLineHelper) ChangeLineOrdinal(view *gocui.View, bufferLine int) int {
+	ordinal := 0
+	for i, row := range self.resolveDiffLines(view.DiffLineContents()) {
+		if i >= bufferLine {
+			break
+		}
+		if row.ok && row.info.IsChange() {
+			ordinal++
+		}
+	}
+	return ordinal
+}
+
+// RevealChangeLineAtOrdinal arranges for view's next re-render to be shown with the
+// change line at the given ordinal placed by place — the diff having changed under the
+// user, this is where what they were doing carries on. When the new diff has fewer
+// changes than that, because the ones acted on were its last, it lands on the last
+// change left.
+//
+// done is called once the selection is where it belongs, or once it turns out that no
+// render is coming to put it there, for a caller that must not let the user act again
+// in between.
+func (self *DiffLineHelper) RevealChangeLineAtOrdinal(
+	view *gocui.View, ordinal int, place func(viewLine int), done func(),
+) {
+	// How many change lines the incremental search has passed, so that it can carry on
+	// counting where it left off.
+	seen := 0
+
+	self.installDiffLineRestore(view,
+		func(rows []gocui.DiffLineContent, offset int) (int, bool) {
+			for i, row := range rows {
+				if info, ok := self.diffLineInfoFromRecords(row.Metadata); ok && info.IsChange() {
+					if seen == ordinal {
+						return offset + i, true
+					}
+					seen++
+				}
+			}
+			return 0, false
+		},
+		func(contents []gocui.DiffLineContent) (int, bool) {
+			last, count := -1, 0
+			for i, row := range self.resolveDiffLines(contents) {
+				if !row.ok || !row.info.IsChange() {
+					continue
+				}
+				if count == ordinal {
+					return i, true
+				}
+				count++
+				last = i
+			}
+			return last, last != -1
+		},
+		place,
+		done,
+	)
+}
+
+// installDiffLineRestore is what the restores are built on: it arranges for view's
+// next re-render to be revealed with the row a search finds in it placed by place,
+// instead of from the top.
+//
+// The search comes in two halves, because the content arrives a line at a time.
+// findEarly is given the rows that have loaded since it last looked, so that the
+// re-render can be revealed as soon as the row is there rather than waiting for the
+// rest of a long diff; it can only go by what the renderer states about a row, a
+// partly-loaded diff being unparseable. findComplete is given the whole rendering at
+// the swap, for a target the incremental search couldn't settle on. Either returns the
+// buffer line it found, and place is not called at all when neither does.
+func (self *DiffLineHelper) installDiffLineRestore(
+	view *gocui.View,
+	findEarly func(rows []gocui.DiffLineContent, offset int) (int, bool),
+	findComplete func(contents []gocui.DiffLineContent) (int, bool),
+	place func(viewLine int),
+	done func(),
+) {
+	// Get-or-create, because the pane may not have rendered anything yet: a file whose
+	// diff has only just become split has a second pane whose first render is the one
+	// this restore is for.
+	manager := self.c.GetOrCreateViewBufferManagerForView(view)
+	if manager == nil {
+		if done != nil {
+			done()
+		}
+		return
+	}
+
+	// The readiness check below runs on the task's own goroutine, which may not read
+	// the view's dimensions, so take them here, on the UI thread.
+	viewHeight := view.InnerHeight()
+
+	// What the search of the loading content has found, and how far it has looked, so
+	// that each line is looked at once.
+	foundLine := -1
+	scanned := 0
+
+	manager.SetRestoreForNextTask(&tasks.RenderRestore{
+		FirstPaintReady: func() bool {
+			if foundLine == -1 {
+				rows := view.OffscreenDiffLineContentsFrom(scanned)
+				if bufferLine, ok := findEarly(rows, scanned); ok {
+					foundLine = bufferLine
+				}
+				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()) {
+			bufferLine := foundLine
+			if bufferLine == -1 {
+				if line, ok := findComplete(view.OffscreenDiffLineContents()); ok {
+					bufferLine = line
+				}
+			}
+
+			swapIn()
+
+			if bufferLine == -1 {
+				return
+			}
+			if viewLine, ok := view.ViewLineForBufferLine(bufferLine); ok {
+				place(viewLine)
+			}
+		},
+		Done: done,
+	})
+}
+
+// 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}
+	}
+}
@@ -0,0 +1,133 @@
+package helpers
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/gocui"
+	"github.com/jesseduffield/lazygit/pkg/gui/context"
+	"github.com/jesseduffield/lazygit/pkg/gui/types"
+	"github.com/samber/lo"
+)
+
+// Putting a selection in the focused main view: where it starts out, and how it is
+// widened to a whole change block. Both are answered from what the view is showing,
+// as recovered by the queries next door.
+
+// EstablishSelection 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 (self *DiffLineHelper) EstablishSelection(mainContext *context.MainContext, clickedViewLine int) {
+	mainContext.ResetDiffSelectMode()
+	view := mainContext.GetView()
+
+	// The pane may hold nothing to act on: a diff of a binary file or an empty commit,
+	// or content that is no diff of the panel's at all. Rendering it worked that out,
+	// so the pane is already showing no selection and there is nowhere to put one.
+	if !mainContext.HasSelectableContent() {
+		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 self.hunkModeApplies(view, clickedViewLine) && self.IsChangeLine(view, clickedViewLine) {
+			mainContext.DiffSelectState().Mode = types.DiffSelectModeHunk
+			self.SelectChangeBlock(mainContext, clickedViewLine, false)
+			return
+		}
+		self.ShowSelectionAtLine(view, clickedViewLine, false)
+		return
+	}
+
+	target, ok := self.changeToSelectOnScreen(view)
+	if !ok {
+		self.ShowSelectionAtLine(view, view.MiddleVisibleLineIdx(), false)
+		return
+	}
+	if self.hunkModeApplies(view, target) {
+		mainContext.DiffSelectState().Mode = types.DiffSelectModeHunk
+		self.SelectChangeBlock(mainContext, target, false)
+		return
+	}
+	self.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 (self *DiffLineHelper) changeToSelectOnScreen(view *gocui.View) (int, bool) {
+	if self.c.UserConfig().Gui.UseHunkModeInStagingView {
+		return self.FirstChangeBlockInView(view)
+	}
+	return self.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 IsSingleHunkForWholeFile.
+func (self *DiffLineHelper) hunkModeApplies(view *gocui.View, changeViewLine int) bool {
+	return self.c.UserConfig().Gui.UseHunkModeInStagingView &&
+		!self.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 (self *DiffLineHelper) 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()
+}
+
+// SelectChangeBlock 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 (self *DiffLineHelper) SelectChangeBlock(
+	pane types.DiffPaneContext, changeViewLine int, scrollIntoView bool,
+) {
+	view := pane.GetView()
+	start, end, ok := self.ChangeBlockBounds(view, changeViewLine)
+	if !ok {
+		pane.DiffSelectState().Mode = types.DiffSelectModeLine
+		view.CancelRangeSelect()
+		self.ShowSelectionAtLine(view, changeViewLine, scrollIntoView)
+		return
+	}
+	view.SetRangeSelectStart(end)
+	self.ShowSelectionAtLine(view, start, scrollIntoView)
+}
+
+// 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)
+}
@@ -46,8 +46,16 @@ func (self *FilesHelper) EditFileAtLineAndWait(filename string, lineNumber int)

 	// Always suspend, regardless of the value of the suspend config,
 	// since we want to prevent interacting with the UI until the editor
-	// returns, even if the editor doesn't use the terminal
-	return self.callEditor(cmdStr, true)
+	// returns, even if the editor doesn't use the terminal.
+	//
+	// And nothing is refreshed here; that is why this doesn't go through
+	// callEditor. The editor was handed a patch we wrote for it, so the repo
+	// hasn't changed when it returns; it changes when the caller applies what
+	// came back. A refresh in between reads the state from before that, and
+	// then races the caller's own refresh to publish it.
+	_, err = self.c.RunSubprocess(
+		self.c.OS().Cmd.NewShell(cmdStr, self.c.UserConfig().OS.ShellFunctionsFile))
+	return err
 }

 func (self *FilesHelper) OpenDirInEditor(path string) error {
@@ -3,6 +3,8 @@ package helpers
 import (
 	"fmt"

+	"github.com/jesseduffield/lazygit/pkg/commands/git_commands"
+
 	"github.com/jesseduffield/lazygit/pkg/commands/patch"
 	"github.com/jesseduffield/lazygit/pkg/gui/patch_exploring"
 	"github.com/jesseduffield/lazygit/pkg/gui/types"
@@ -73,7 +75,7 @@ func (self *PatchBuildingHelper) RefreshPatchBuildingPanel(opts types.OnFocusOpt

 	from, to := self.c.Contexts().CommitFiles.GetFromAndToForDiff()
 	from, reverse := self.c.Modes().Diffing.GetFromAndReverseArgsForDiff(from)
-	diff, err := self.c.Git().WorkingTree.ShowFileDiff(from, to, reverse, file.Path, file.PreviousPath, true)
+	diff, err := self.c.Git().WorkingTree.ShowFileDiff(from, to, reverse, file.Path, file.PreviousPath, git_commands.DiffModePlain)
 	if err != nil {
 		return
 	}
@@ -589,7 +589,8 @@ func (self *RefreshHelper) performRefresh(options types.RefreshOptions, calledFr
 			// this runs — and the keys buffered during the refresh replay —
 			// the refreshed state is in place.
 			self.c.OnUIThread(func() error {
-				return self.c.GocuiGui().EndBlockingEvents()
+				self.c.GocuiGui().EndBlockingEvents()
+				return nil
 			})
 		}

@@ -1,6 +1,7 @@
 package helpers

 import (
+	"github.com/jesseduffield/lazygit/pkg/commands/git_commands"
 	"github.com/jesseduffield/lazygit/pkg/commands/models"
 	"github.com/jesseduffield/lazygit/pkg/gui/patch_exploring"
 	"github.com/jesseduffield/lazygit/pkg/gui/types"
@@ -53,8 +54,8 @@ func (self *StagingHelper) RefreshStagingPanel(focusOpts types.OnFocusOpts) {
 		return
 	}

-	mainDiff := self.c.Git().WorkingTree.WorktreeFileDiff(file, true, false)
-	secondaryDiff := self.c.Git().WorkingTree.WorktreeFileDiff(file, true, true)
+	mainDiff := self.c.Git().WorkingTree.WorktreeFileDiff(file, git_commands.DiffModePlain, false)
+	secondaryDiff := self.c.Git().WorkingTree.WorktreeFileDiff(file, git_commands.DiffModePlain, true)

 	// grabbing locks here and releasing before we finish the function
 	// because pushing say the secondary context could mean entering this function
@@ -60,7 +60,7 @@ type WindowArrangementArgs struct {
 	ContentHeightForWindow func(window string) int
 	// Whether the main panel is split (as is the case e.g. when a file has both
 	// staged and unstaged changes)
-	SplitMainPanel bool
+	MainPanes types.MainPanes
 	// The current screen mode (normal, half, full)
 	ScreenMode types.ScreenMode
 	// The content shown on the bottom left of the screen when showing a loader
@@ -103,7 +103,7 @@ func (self *WindowArrangementHelper) GetWindowDimensions(informationStr string,
 		ContentHeightForWindow: func(window string) int {
 			return self.windowHelper.GetContextForWindow(window).TotalContentHeight()
 		},
-		SplitMainPanel:   repoState.GetSplitMainPanel(),
+		MainPanes:        repoState.GetMainPanes(),
 		ScreenMode:       repoState.GetScreenMode(),
 		AppStatus:        appStatus,
 		InformationStr:   informationStr,
@@ -215,36 +215,27 @@ func MergeMaps[K comparable, V any](maps ...map[K]V) map[K]V {
 }

 func mainSectionChildren(args WindowArrangementArgs) []*boxlayout.Box {
-	// if we're not in split mode we can just show the one main panel. Likewise if
-	// the main panel is focused and we're in full-screen mode
-	if !args.SplitMainPanel || (args.ScreenMode == types.SCREEN_FULL && args.CurrentWindow == "main") {
-		return []*boxlayout.Box{
-			{
-				Window: "main",
-				Weight: 1,
-			},
+	mainPane := &boxlayout.Box{Window: "main", Weight: 1}
+	secondaryPane := &boxlayout.Box{Window: "secondary", Weight: 1}
+
+	switch args.MainPanes {
+	case types.MainPaneOnly:
+		return []*boxlayout.Box{mainPane}
+	case types.SecondaryPaneOnly:
+		return []*boxlayout.Box{secondaryPane}
+	case types.BothMainPanes:
+		// In full-screen mode the focused one takes the whole section anyway.
+		if args.ScreenMode == types.SCREEN_FULL {
+			if args.CurrentWindow == "main" {
+				return []*boxlayout.Box{mainPane}
+			}
+			if args.CurrentWindow == "secondary" {
+				return []*boxlayout.Box{secondaryPane}
+			}
 		}
 	}

-	if args.CurrentWindow == "secondary" && args.ScreenMode == types.SCREEN_FULL {
-		return []*boxlayout.Box{
-			{
-				Window: "secondary",
-				Weight: 1,
-			},
-		}
-	}
-
-	return []*boxlayout.Box{
-		{
-			Window: "main",
-			Weight: 1,
-		},
-		{
-			Window: "secondary",
-			Weight: 1,
-		},
-	}
+	return []*boxlayout.Box{mainPane, secondaryPane}
 }

 func getMidSectionWeights(args WindowArrangementArgs) (int, int) {
@@ -382,7 +373,7 @@ func infoSectionChildren(args WindowArrangementArgs) []*boxlayout.Box {
 }

 func splitMainPanelSideBySide(args WindowArrangementArgs) bool {
-	if !args.SplitMainPanel {
+	if args.MainPanes != types.BothMainPanes {
 		return false
 	}

@@ -35,7 +35,7 @@ func TestGetWindowDimensions(t *testing.T) {
 			// Each panel shows its first tab by default; for the special-cased
 			// panels (status, stash) the view name matches the window name.
 			ActiveViewForWindow: func(window string) string { return window },
-			SplitMainPanel:      false,
+			MainPanes:           types.MainPaneOnly,
 			ScreenMode:          types.SCREEN_NORMAL,
 			AppStatus:           "",
 			InformationStr:      "information",
@@ -727,7 +727,7 @@ func secondaryPatchPanelUpdateOpts(c *ControllerCommon) *types.ViewUpdateOpts {
 		patch := c.Git().Patch.PatchBuilder.RenderAggregatedPatch(false)

 		return &types.ViewUpdateOpts{
-			Task:  types.NewRenderStringWithoutScrollTask(patch),
+			Task:  types.NewMainViewDiffStringTask(patch),
 			Title: c.Tr.CustomPatch,
 		}
 	}
@@ -79,6 +79,39 @@ func (self *MainViewController) GetKeybindings(opts types.KeybindingsOpts) []*ty
 			GetDisabledReason: self.diffSelectionDisabledReason,
 			Tooltip:           self.c.Tr.EditFileTooltip,
 		},
+		{
+			Keys:              opts.GetKeys(opts.Config.Universal.Select),
+			Handler:           self.primaryAction,
+			Description:       self.c.Tr.Stage,
+			DescriptionFunc:   self.workingTreeActionDescription(self.c.Tr.Stage),
+			GetDisabledReason: self.diffSelectionDisabledReason,
+			Tooltip:           self.c.Tr.StageSelectionTooltip,
+			DisplayOnScreen:   true,
+		},
+		{
+			Keys:              opts.GetKeys(opts.Config.Universal.Remove),
+			Handler:           self.discardSelection,
+			Description:       self.c.Tr.DiscardSelection,
+			DescriptionFunc:   self.workingTreeActionDescription(self.c.Tr.DiscardSelection),
+			GetDisabledReason: self.diffSelectionDisabledReason,
+			Tooltip:           self.c.Tr.DiscardSelectionTooltip,
+			DisplayOnScreen:   true,
+		},
+		{
+			Keys:              opts.GetKeys(opts.Config.Main.EditSelectHunk),
+			Handler:           self.editHunk,
+			Description:       self.c.Tr.EditHunk,
+			DescriptionFunc:   self.workingTreeActionDescription(self.c.Tr.EditHunk),
+			GetDisabledReason: self.diffSelectionDisabledReason,
+			Tooltip:           self.c.Tr.EditHunkTooltip,
+		},
+		{
+			Keys:              opts.GetKeys(opts.Config.Universal.CopyToClipboard),
+			Handler:           self.copySelection,
+			Description:       self.c.Tr.CopySelectedTextToClipboard,
+			DescriptionFunc:   self.diffSelectionDescriptionText(self.c.Tr.CopySelectedTextToClipboard),
+			GetDisabledReason: self.diffSelectionDisabledReason,
+		},
 		{
 			Keys:              opts.GetKeys(opts.Config.Main.PrevHunk),
 			Handler:           self.prevChangeBlock,
@@ -139,6 +172,32 @@ func (self *MainViewController) GetKeybindings(opts types.KeybindingsOpts) []*ty
 			DescriptionFunc:   self.diffSelectionDescriptionText(self.c.Tr.RangeSelectDown),
 			GetDisabledReason: self.diffSelectionDisabledReason,
 		},
+		{
+			Keys:            opts.GetKeys(opts.Config.Files.CommitChanges),
+			Handler:         self.workingTreeAction(self.c.Helpers().WorkingTree.HandleCommitPress),
+			Description:     self.c.Tr.Commit,
+			DescriptionFunc: self.workingTreeActionDescription(self.c.Tr.Commit),
+			Tooltip:         self.c.Tr.CommitTooltip,
+		},
+		{
+			Keys:            opts.GetKeys(opts.Config.Files.CommitChangesWithoutHook),
+			Handler:         self.workingTreeAction(self.c.Helpers().WorkingTree.HandleWIPCommitPress),
+			Description:     self.c.Tr.CommitChangesWithoutHook,
+			DescriptionFunc: self.workingTreeActionDescription(self.c.Tr.CommitChangesWithoutHook),
+		},
+		{
+			Keys:            opts.GetKeys(opts.Config.Files.CommitChangesWithEditor),
+			Handler:         self.workingTreeAction(self.c.Helpers().WorkingTree.HandleCommitEditorPress),
+			Description:     self.c.Tr.CommitChangesWithEditor,
+			DescriptionFunc: self.workingTreeActionDescription(self.c.Tr.CommitChangesWithEditor),
+		},
+		{
+			Keys:            opts.GetKeys(opts.Config.Files.FindBaseCommitForFixup),
+			Handler:         self.workingTreeAction(self.c.Helpers().FixupHelper.HandleFindBaseCommitForFixupPress),
+			Description:     self.c.Tr.FindBaseCommitForFixup,
+			DescriptionFunc: self.workingTreeActionDescription(self.c.Tr.FindBaseCommitForFixup),
+			Tooltip:         self.c.Tr.FindBaseCommitForFixupTooltip,
+		},
 		{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},
@@ -191,7 +250,7 @@ func (self *MainViewController) togglePanel() error {
 	isDiff := self.isDiffView()
 	self.c.Context().Push(self.otherContext, types.OnFocusOpts{})
 	if isDiff {
-		establishDiffSelection(self.c, self.otherContext, -1)
+		self.c.Helpers().DiffLine.EstablishSelection(self.otherContext, -1)
 	}
 	return nil
 }
@@ -248,6 +307,189 @@ func (self *MainViewController) diffMainViewType() types.DiffMainViewType {
 	return types.DiffMainViewTypeNone
 }

+// diffSource returns the panel beneath the focused main view, as the thing that can
+// hand out the diff it rendered there. nil when this pane isn't on the stack, or the
+// panel beneath shows no diff.
+func (self *MainViewController) diffSource() types.FocusedMainViewDiffSource {
+	if !self.c.Context().IsInStack(self.context) {
+		return nil
+	}
+	sidePanel := self.c.Context().NextInStack(self.context)
+	if sidePanel == nil {
+		return nil
+	}
+	return sidePanel.GetFocusedMainViewDiffSource()
+}
+
+// focusedMainViewActions returns what the panel beneath the focused main view does to
+// a selection in its diff, or nil where it does nothing to it — a panel whose diff can
+// be read and copied but not acted on.
+func (self *MainViewController) focusedMainViewActions() types.FocusedMainViewActions {
+	actions, _ := self.diffSource().(types.FocusedMainViewActions)
+	return actions
+}
+
+// primaryAction acts on the selected diff lines, leaving what that means to the panel
+// beneath — which also re-renders the diff, since it is the one that changed it.
+func (self *MainViewController) primaryAction() error {
+	actions := self.focusedMainViewActions()
+	if actions == nil {
+		return nil
+	}
+	first, last, ok := self.context.GetView().SelectedBufferLineRange()
+	if !ok {
+		return nil
+	}
+	return actions.PrimaryAction(self.context, first, last)
+}
+
+// revealSelectionAfterAction moves the selection to the change that takes the place of
+// the one just acted on, once the changed diff has re-rendered. Call it from the panel's
+// action handler with the pane it acted in, the pane the work carries on in, and the
+// buffer line the selection starts on, before triggering the re-render.
+//
+// The line acted on is gone from the diff, so what is remembered is its place among the
+// diff's changes: the next change moves up into it, which is where you want to be to
+// carry on. A range collapses to a single line at its start, and hunk mode selects the
+// whole block it lands in, so that pressing the key again acts on the next hunk. The
+// target pane inherits that select mode, this being the same piece of work continuing
+// in another pane — and shows no selection until the restore places one, so that what
+// it was left showing the last time it was used doesn't appear for a frame.
+//
+// done is called once the selection is where it belongs, or once it turns out that no
+// render is coming to put it there, for a caller that must not let the user act again
+// in between.
+func revealSelectionAfterAction(
+	c *ControllerCommon, source types.DiffPaneContext, target types.DiffPaneContext,
+	firstBufferLine int, done func(),
+) {
+	ordinal := c.Helpers().DiffLine.ChangeLineOrdinal(source.GetView(), firstBufferLine)
+
+	sel := source.DiffSelectState()
+	if sel.Mode == types.DiffSelectModeRange {
+		sel.Mode = types.DiffSelectModeLine
+		sel.RangeIsSticky = false
+	}
+	*target.DiffSelectState() = *sel
+	selectHunk := sel.Mode == types.DiffSelectModeHunk
+
+	targetView := target.GetView()
+	if target != source {
+		target.SetHasSelectableContent(false)
+		c.Context().UpdateSelectionHighlights()
+	}
+
+	c.Helpers().DiffLine.RevealChangeLineAtOrdinal(targetView, ordinal, func(viewLine int) {
+		if selectHunk {
+			c.Helpers().DiffLine.SelectChangeBlock(target, viewLine, true)
+			return
+		}
+		targetView.CancelRangeSelect()
+		c.Helpers().DiffLine.ShowSelectionAtLine(targetView, viewLine, true)
+	}, done)
+}
+
+// discardSelection takes the selected diff lines back out of what they are part of,
+// which — like the primary action — is the panel's business, and so is the re-render
+// that follows.
+func (self *MainViewController) discardSelection() error {
+	actions := self.focusedMainViewActions()
+	if actions == nil {
+		return nil
+	}
+	first, last, ok := self.context.GetView().SelectedBufferLineRange()
+	if !ok {
+		return nil
+	}
+	return actions.DiscardSelection(self.context, first, last)
+}
+
+// editHunk hands the hunk around the selection to an editor, and is only offered over
+// the working tree's diff: what comes back is applied to the index, which is not
+// something a commit's diff has any use for.
+func (self *MainViewController) editHunk() error {
+	actions, ok := self.diffSource().(*WorkingTreeDiffActions)
+	if !ok {
+		return nil
+	}
+	first, last, ok := self.context.GetView().SelectedBufferLineRange()
+	if !ok {
+		return nil
+	}
+	return actions.EditHunk(self.context, first, last)
+}
+
+// workingTreeAction wraps a command that acts on the working tree — committing, finding
+// the commit to fix up — so that it only runs while the focused main view is showing the
+// working tree's diff. Over a commit's diff the key does nothing, so that browsing
+// through history can't commit by accident. The check is per press, since what the main
+// view shows changes as the user moves around while the keybindings are registered once.
+func (self *MainViewController) workingTreeAction(action func() error) func() error {
+	return func() error {
+		if self.diffMainViewType() != types.DiffMainViewTypeStaging {
+			return nil
+		}
+		return action()
+	}
+}
+
+// workingTreeActionDescription gives a command's description only where the command
+// applies — over the working tree's diff — so that it is listed there and nowhere else.
+func (self *MainViewController) workingTreeActionDescription(description string) func() string {
+	return func() string {
+		if self.diffMainViewType() != types.DiffMainViewTypeStaging {
+			return ""
+		}
+		return description
+	}
+}
+
+// copySelection copies the selected diff lines to the clipboard — not as the diff
+// renderer drew them, but as they read in the diff itself, which is both what you meant
+// to copy and the only form a renderer can't have mangled. A selection that is all
+// additions or all deletions loses its +/- column, so that it can be pasted straight
+// into code.
+//
+// The rows above the diff (a commit's message, git's summary of it) belong to no file,
+// so they are copied as they stand on screen.
+func (self *MainViewController) copySelection() error {
+	text := self.textOfSelection()
+	if text == "" {
+		self.c.ErrorToast(self.c.Tr.SelectionNotFoundInDiffToast)
+		return nil
+	}
+
+	self.c.LogAction(self.c.Tr.Actions.CopySelectedTextToClipboard)
+	if err := self.c.OS().CopyToClipboard(text); err != nil {
+		return err
+	}
+	self.c.Toast(self.c.Tr.SelectedDiffLinesCopiedToast)
+	return nil
+}
+
+// textOfSelection is what copying the selection puts on the clipboard. It is "" when
+// none of the selected rows could be placed in the diff, which is what a rendering's
+// own decoration comes to.
+func (self *MainViewController) textOfSelection() string {
+	source := self.diffSource()
+	if source == nil {
+		return ""
+	}
+	view := self.context.GetView()
+	first, last, ok := view.SelectedBufferLineRange()
+	if !ok {
+		return ""
+	}
+	aboveDiff, fromDiff := self.c.Helpers().DiffLine.PlainDiffOfSelection(view, first, last,
+		func(paths []string) string { return source.PlainDiff(self.context, paths) })
+	if aboveDiff == "" {
+		// Only text that is all diff has a +/- column to lose: a line of a commit message
+		// may begin with a '-' without being a deletion of anything.
+		fromDiff = dropDiffPrefix(fromDiff)
+	}
+	return aboveDiff + fromDiff
+}
+
 // diffSelectState returns this pane's diff selection mode state.
 func (self *MainViewController) diffSelectState() *types.DiffSelectState {
 	return self.context.DiffSelectState()
@@ -400,7 +642,7 @@ func (self *MainViewController) selectClickedDiffLine(viewLine int) {
 		if start, end, ok := self.c.Helpers().DiffLine.SelectedHunkBounds(view); ok &&
 			viewLine >= start && viewLine <= end {
 			self.context.ResetDiffSelectMode()
-			showSelectionAtLine(view, viewLine, false)
+			self.c.Helpers().DiffLine.ShowSelectionAtLine(view, viewLine, false)
 			return
 		}
 		if self.c.Helpers().DiffLine.IsChangeLine(view, viewLine) {
@@ -409,122 +651,11 @@ func (self *MainViewController) selectClickedDiffLine(viewLine int) {
 		}
 	}
 	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()
+	self.c.Helpers().DiffLine.ShowSelectionAtLine(view, viewLine, false)
 }

 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)
+	self.c.Helpers().DiffLine.SelectChangeBlock(self.context, changeViewLine, scrollIntoView)
 }

 // navigate moves the focused main view to the row find locates from the current
@@ -623,7 +754,7 @@ func (self *MainViewController) placeNavigationTarget(target int, alignTop bool)
 	}
 	// Line mode leaves a single-line selection at the target; an active range extends
 	// to it, the anchor being untouched.
-	showSelectionAtLine(v, target, true)
+	self.c.Helpers().DiffLine.ShowSelectionAtLine(v, target, true)
 }

 // scrollTargetToTop scrolls the given row of the diff to the top of the view, leaving
@@ -655,7 +786,7 @@ func (self *MainViewController) moveCursor(delta int) {
 	} else if delta == 1 {
 		checkScrollDown(self.context.GetViewTrait(), self.c.UserConfig(), before, after)
 	}
-	showSelectionAtLine(v, after, true)
+	self.c.Helpers().DiffLine.ShowSelectionAtLine(v, after, true)
 }

 // collapseForLineMove drops hunk mode, and a non-sticky range, back to a single-line
@@ -702,7 +833,7 @@ func (self *MainViewController) adjustSelection(delta int) {
 // 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)
+	self.c.Helpers().DiffLine.ShowSelectionAtLine(self.context.GetView(), target, true)
 }

 // selectingRange reports whether a range selection is currently active: we're in
@@ -37,6 +37,20 @@ func (self *ReflogCommitsController) context() *context.ReflogCommitsContext {
 	return self.c.Contexts().ReflogCommits
 }

+func (self *ReflogCommitsController) GetFocusedMainViewDiffSource() types.FocusedMainViewDiffSource {
+	return self
+}
+
+// PlainDiff hands out the reflog entry's diff for the given files — the same diff its
+// main view shows, only without the entry's message and stat above it.
+func (self *ReflogCommitsController) PlainDiff(_ types.DiffPaneContext, paths []string) string {
+	commit := self.context().GetSelected()
+	if commit == nil {
+		return ""
+	}
+	return self.c.Helpers().Diff.PlainDiffBetweenRefs(commit.ParentRefName(), commit.RefName(), paths)
+}
+
 func (self *ReflogCommitsController) GetOnRenderToMain() func() {
 	return func() {
 		self.c.Helpers().Diff.WithDiffModeCheck(func() {
@@ -45,9 +59,10 @@ func (self *ReflogCommitsController) GetOnRenderToMain() func() {
 			if commit == nil {
 				task = types.NewRenderStringTask("No reflog history")
 			} else {
-				cmdObj := self.c.Git().Commit.ShowCmdObj(commit.Hash(), self.c.Helpers().Diff.FilterPathsForCommit(commit))
+				mode := self.c.Helpers().DiffLine.MainViewDiffMode()
+				cmdObj := self.c.Git().Commit.ShowCmdObj(commit.Hash(), self.c.Helpers().Diff.FilterPathsForCommit(commit), mode)

-				task = types.NewRunDiffRendererTask(cmdObj.GetCmd())
+				task = types.NewMainViewDiffTask(cmdObj.GetCmd(), mode)
 			}

 			self.c.RenderToMainViews(types.RefreshMainOpts{
@@ -92,10 +92,12 @@ func (self *StashController) GetOnRenderToMain() func() {
 			if stashEntry == nil {
 				task = types.NewRenderStringTask(self.c.Tr.NoStashEntries)
 			} else {
+				mode := self.c.Helpers().DiffLine.MainViewDiffMode()
 				prefix := style.FgYellow.Sprintf("%s\n\n", stashEntry.Description())
-				task = types.NewRunDiffRendererTaskWithPrefix(
-					self.c.Git().Stash.ShowStashEntryCmdObj(stashEntry.Index).GetCmd(),
+				task = types.NewMainViewDiffTaskWithPrefix(
+					self.c.Git().Stash.ShowStashEntryCmdObj(stashEntry.Index, mode).GetCmd(),
 					prefix,
+					mode,
 				)
 			}

@@ -5,6 +5,8 @@ import (
 	"path/filepath"
 	"strings"

+	"github.com/jesseduffield/lazygit/pkg/commands/git_commands"
+
 	"github.com/jesseduffield/lazygit/pkg/commands/models"
 	"github.com/jesseduffield/lazygit/pkg/gocui"
 	"github.com/jesseduffield/lazygit/pkg/gui/context"
@@ -123,7 +125,7 @@ func (self *SubmodulesController) GetOnRenderToMain() func() {
 				if file == nil {
 					task = types.NewRenderStringTask(prefix)
 				} else {
-					cmdObj := self.c.Git().WorkingTree.WorktreeFileDiffCmdObj(file, false, !file.HasUnstagedChanges && file.HasStagedChanges, file.Names())
+					cmdObj := self.c.Git().WorkingTree.WorktreeFileDiffCmdObj(file, git_commands.DiffModeRendered, !file.HasUnstagedChanges && file.HasStagedChanges, file.Names())
 					task = types.NewRunCommandTaskWithPrefix(cmdObj.GetCmd(), prefix)
 				}
 			}
@@ -4,6 +4,7 @@ import (
 	"path/filepath"

 	"github.com/jesseduffield/lazygit/pkg/commands/models"
+	"github.com/jesseduffield/lazygit/pkg/gui/context"
 	"github.com/jesseduffield/lazygit/pkg/gui/types"
 )

@@ -64,6 +65,22 @@ func (self *SwitchToDiffFilesController) GetOnDoubleClick() func() error {
 	}
 }

+func (self *SwitchToDiffFilesController) GetFocusedMainViewDiffSource() types.FocusedMainViewDiffSource {
+	return self
+}
+
+// PlainDiff hands out the diff of the panel's selected commit (or range of them) for
+// the given files — the same diff its main view shows, only without the commit's
+// message and stat above it.
+func (self *SwitchToDiffFilesController) PlainDiff(_ types.DiffPaneContext, paths []string) string {
+	ref := self.context.GetSelectedRef()
+	if ref == nil {
+		return ""
+	}
+	from, to := context.FromAndToForDiff(ref, self.context.GetSelectedRefRangeForDiffFiles())
+	return self.c.Helpers().Diff.PlainDiffBetweenRefs(from, to, paths)
+}
+
 func (self *SwitchToDiffFilesController) enter() error {
 	ref := self.context.GetSelectedRef()
 	refsRange := self.context.GetSelectedRefRangeForDiffFiles()
@@ -1,6 +1,7 @@
 package controllers

 import (
+	"github.com/jesseduffield/lazygit/pkg/commands/git_commands"
 	"github.com/jesseduffield/lazygit/pkg/gocui"
 	"github.com/jesseduffield/lazygit/pkg/gui/context"
 	"github.com/jesseduffield/lazygit/pkg/gui/types"
@@ -70,16 +71,35 @@ func (self *SwitchToFocusedMainViewController) onClickSecondary(opts gocui.ViewM
 }

 func (self *SwitchToFocusedMainViewController) handleFocusMainView() error {
-	return self.focusMainView(self.c.Contexts().Normal, -1)
+	// Usually the main pane, but the content can be in the secondary one alone: a file
+	// with nothing but staged changes shows them there.
+	mainViewContext := self.c.Contexts().Normal
+	if self.c.State().GetRepoState().GetMainPanes() == types.SecondaryPaneOnly {
+		mainViewContext = self.c.Contexts().NormalSecondary
+	}
+	return self.focusMainView(mainViewContext, -1)
 }

 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)
+	if _, ok := self.context.(types.DiffMainViewContext); !ok {
+		return nil
 	}

+	// The diff on screen was produced for reading, and the renderer that produced it may
+	// have laid it out in a way that says nothing about which line of which file each row
+	// is. Now that the user wants to act on it, it is re-rendered as git's own diff — the
+	// panel below decides that for itself, from the same question — and the selection
+	// goes on that instead of on rows we can't place.
+	if self.c.Helpers().DiffLine.MainViewDiffMode() == git_commands.DiffModeRaw {
+		self.c.Helpers().DiffLine.RenderFocusedMainViewAgain(mainViewContext.GetView(), self.context, func() {
+			self.c.Helpers().DiffLine.EstablishSelection(mainViewContext, clickedLineIdx)
+		})
+		return nil
+	}
+
+	self.c.Helpers().DiffLine.EstablishSelection(mainViewContext, clickedLineIdx)
 	return nil
 }
@@ -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
 }
@@ -0,0 +1,414 @@
+package controllers
+
+import (
+	"fmt"
+	"path/filepath"
+	"strings"
+
+	"github.com/jesseduffield/generics/set"
+	"github.com/jesseduffield/lazygit/pkg/commands/git_commands"
+	"github.com/jesseduffield/lazygit/pkg/commands/models"
+	"github.com/jesseduffield/lazygit/pkg/commands/patch"
+	"github.com/jesseduffield/lazygit/pkg/gui/context"
+	"github.com/jesseduffield/lazygit/pkg/gui/types"
+	"github.com/samber/lo"
+)
+
+// WorkingTreeDiffActions implements what the files panel offers on the diff it renders
+// into the focused main view: the diff itself, for the commands that need to read lines
+// out of it rather than off the screen.
+type WorkingTreeDiffActions struct {
+	c *ControllerCommon
+}
+
+var _ types.FocusedMainViewActions = &WorkingTreeDiffActions{}
+
+func NewWorkingTreeDiffActions(c *ControllerCommon) *WorkingTreeDiffActions {
+	return &WorkingTreeDiffActions{c: c}
+}
+
+func (self *WorkingTreeDiffActions) context() *context.WorkingTreeContext {
+	return self.c.Contexts().Files
+}
+
+// PlainDiff hands out the working tree's diff for the given files, taken from the
+// side of the index that the asking pane shows.
+func (self *WorkingTreeDiffActions) PlainDiff(pane types.DiffPaneContext, paths []string) string {
+	node := self.context().GetSelected()
+	if node == nil {
+		return ""
+	}
+	// An error means there is no diff to be had, which for our purposes is the same as
+	// an empty one.
+	diff, _ := self.c.Git().WorkingTree.
+		WorktreeFileDiffCmdObj(node, git_commands.DiffModePlain, self.showsStagedSide(pane), paths).
+		RunWithOutput()
+	return diff
+}
+
+// showsStagedSide reports whether the given main pane is the one showing the staged
+// side of a file's diff, which is always the lower one.
+func (self *WorkingTreeDiffActions) showsStagedSide(pane types.DiffPaneContext) bool {
+	return pane.GetKey() == self.c.Contexts().NormalSecondary.GetKey()
+}
+
+// PrimaryAction stages the selected diff lines, or takes them back out of the index
+// when what is selected is the staged side of the diff.
+func (self *WorkingTreeDiffActions) PrimaryAction(pane types.DiffPaneContext, firstBufferLine int, lastBufferLine int) error {
+	if self.c.UserConfig().Git.DiffContextSize == 0 {
+		return fmt.Errorf(self.c.Tr.Actions.NotEnoughContextToStage,
+			self.c.UserConfig().Keybinding.Universal.IncreaseContextInDiffView)
+	}
+
+	infos, onStagedSide, ok := self.diffLineSelection(pane, firstBufferLine, lastBufferLine)
+	if !ok {
+		return nil
+	}
+
+	// Either way the patch goes to the index: forwards from the unstaged side to stage
+	// it, backwards from the staged side to take it back out.
+	return self.applyDiffLineSelection(pane, firstBufferLine, infos, onStagedSide,
+		git_commands.ApplyPatchOpts{Reverse: onStagedSide, Cached: true})
+}
+
+// DiscardSelection takes the selected diff lines out of the working tree — or, on the
+// staged side, out of the index, which is where "discard this" means "I don't want it
+// staged".
+func (self *WorkingTreeDiffActions) DiscardSelection(pane types.DiffPaneContext, firstBufferLine int, lastBufferLine int) error {
+	if self.c.UserConfig().Git.DiffContextSize == 0 {
+		return fmt.Errorf(self.c.Tr.Actions.NotEnoughContextToDiscard,
+			self.c.UserConfig().Keybinding.Universal.IncreaseContextInDiffView)
+	}
+
+	infos, onStagedSide, ok := self.diffLineSelection(pane, firstBufferLine, lastBufferLine)
+	if !ok {
+		return nil
+	}
+
+	// Either way the change is applied backwards; which side it is applied to decides
+	// how destructive that is. On the staged side it goes to the index; this is the
+	// same as unstaging, so nothing is lost. On the unstaged side it goes to the
+	// working tree, where the change is gone for good, so we ask first.
+	return self.c.ConfirmIf(!onStagedSide && !self.c.UserConfig().Gui.SkipDiscardChangeWarning,
+		types.ConfirmOpts{
+			Title:  self.c.Tr.DiscardChangeTitle,
+			Prompt: self.c.Tr.DiscardChangePrompt,
+			HandleConfirm: func() error {
+				return self.applyDiffLineSelection(pane, firstBufferLine, infos, onStagedSide,
+					git_commands.ApplyPatchOpts{Reverse: true, Cached: onStagedSide})
+			},
+		})
+}
+
+// EditHunk opens the git hunk holding the selection in an editor, as a patch against
+// the index, and applies whatever comes back. It is how you stage something the diff
+// can't express — half of a changed line, or a change written differently from either
+// side — since what the editor hands back is applied rather than matched against the
+// file's own diff.
+//
+// The hunk is the git one, context and all, rather than lazygit's block of adjacent
+// changes: an editable patch is one that still applies, and the context lines are what
+// let git place it.
+func (self *WorkingTreeDiffActions) EditHunk(
+	pane types.DiffPaneContext, firstBufferLine int, lastBufferLine int,
+) error {
+	infos, onStagedSide, ok := self.diffLineSelection(pane, firstBufferLine, lastBufferLine)
+	if !ok {
+		return nil
+	}
+	file := self.fileForDiffLinePath(infos[0].Path)
+	if file == nil {
+		return nil
+	}
+
+	parsedPatch := patch.Parse(self.c.Git().WorkingTree.WorktreeFileDiff(file, git_commands.DiffModePlain, onStagedSide))
+	lineIndices := changeLineIndices(parsedPatch, infos[:1])
+	if len(lineIndices) == 0 {
+		return nil
+	}
+
+	hunkIdx := parsedPatch.HunkContainingLine(lineIndices[0])
+	hunkStartIdx := parsedPatch.HunkStartIdx(hunkIdx)
+	patchText := parsedPatch.
+		Transform(patch.TransformOpts{
+			Reverse:             onStagedSide,
+			IncludedLineIndices: patch.ExpandRange(hunkStartIdx, parsedPatch.HunkEndIdx(hunkIdx)),
+			FileNameOverride:    file.GetPath(),
+		}).
+		FormatPlain()
+
+	patchFilepath, err := self.c.Git().Patch.SaveTemporaryPatch(patchText)
+	if err != nil {
+		return err
+	}
+
+	// The patch is written with a two-line header before its hunk, so the line the
+	// user was on sits that much further down the file they are about to edit.
+	const headerLineCount = 2
+	if err := self.c.Helpers().Files.EditFileAtLineAndWait(patchFilepath,
+		lineIndices[0]-hunkStartIdx+headerLineCount+1); err != nil {
+		return err
+	}
+
+	editedPatchText, err := self.c.Git().File.Cat(patchFilepath)
+	if err != nil {
+		return err
+	}
+
+	self.c.LogAction(self.c.Tr.Actions.ApplyPatch)
+
+	// Everything the editor left behind is taken, this being a patch the user wrote
+	// rather than a selection out of one of ours.
+	lineCount := strings.Count(editedPatchText, "\n") + 1
+	newPatchText := patch.
+		Parse(editedPatchText).
+		Transform(patch.TransformOpts{
+			IncludedLineIndices: patch.ExpandRange(0, lineCount),
+			FileNameOverride:    file.GetPath(),
+		}).
+		FormatPlain()
+
+	if err := self.c.Git().Patch.ApplyPatch(newPatchText, git_commands.ApplyPatchOpts{
+		Reverse: onStagedSide,
+		Cached:  true,
+	}); err != nil {
+		return err
+	}
+
+	// Block input until the refresh has landed, as the staging commands do: the diff is
+	// about to be rebuilt from a file that no longer looks the way it did.
+	self.c.RefreshBlockingInput(types.RefreshOptions{Scope: []types.RefreshableView{types.FILES}})
+	return nil
+}
+
+// diffLineSelection resolves what the user has selected in a pane of the focused main
+// view to the change lines to act on, and reports whether they are the staged side of
+// the diff — which is a question about the pane, so it is the same for every file of a
+// directory's diff. ok is false when the selection holds no change line, in which case
+// there is nothing to act on.
+func (self *WorkingTreeDiffActions) diffLineSelection(
+	pane types.DiffPaneContext, firstBufferLine int, lastBufferLine int,
+) (infos []types.DiffLineInfo, onStagedSide bool, ok bool) {
+	infos = self.c.Helpers().DiffLine.ChangeLinesInBufferRange(pane.GetView(), firstBufferLine, lastBufferLine)
+	if len(infos) == 0 {
+		return nil, false, false
+	}
+	return infos, self.showsStagedSide(pane), true
+}
+
+// applyDiffLineSelection applies the selected change lines, a patch per file, and
+// re-renders what that changed. onStagedSide says which of the file's two diffs the
+// lines were selected in and so are to be found in; opts says how to apply them.
+// firstBufferLine is where the selection started, which is where the work carries on
+// from once the diff has changed under it.
+func (self *WorkingTreeDiffActions) applyDiffLineSelection(
+	pane types.DiffPaneContext, firstBufferLine int,
+	infos []types.DiffLineInfo, onStagedSide bool, opts git_commands.ApplyPatchOpts,
+) error {
+	self.c.LogAction(self.c.Tr.Actions.ApplyPatch)
+
+	// A directory's diff spans several files, and a patch is of one file, so the
+	// selected lines are grouped by the file they belong to and applied file by file.
+	infosByFile := lo.GroupBy(infos, func(info types.DiffLineInfo) string { return info.Path })
+	acted := set.New[string]()
+	actedSideRemains := false
+	for path, fileInfos := range infosByFile {
+		file := self.fileForDiffLinePath(path)
+		if file == nil {
+			continue
+		}
+		changesLeft, err := self.applyDiffLines(file, fileInfos, onStagedSide, opts)
+		if err != nil {
+			return err
+		}
+		acted.Add(file.GetPath())
+		actedSideRemains = actedSideRemains || changesLeft
+	}
+	if !actedSideRemains {
+		actedSideRemains = self.anyFileHasChangesOnSide(acted, onStagedSide)
+	}
+
+	// Whether the other side has anything decides which pane the work carries on in.
+	// If the lines were staged, they are in the index now, so that side has them. If
+	// they were discarded, the other side was not touched, so the model still
+	// describes it correctly.
+	otherSideHasChanges := opts.Cached || self.anyFileHasChangesOnSide(set.New[string](), !onStagedSide)
+
+	// The refresh below queues the re-render of the diff we just changed; this rides it,
+	// so that the selection ends up on the change that took the place of the one acted
+	// on rather than at a position that means nothing any more — and in the pane the
+	// work carries on in, which is not always the one it was in.
+	self.revealSelectionInPaneItLandsIn(pane, firstBufferLine, actedSideRemains, otherSideHasChanges)
+
+	// Block input until the refresh has landed, so that a quick second keypress acts on
+	// the diff as it now is rather than on the one we just changed.
+	self.c.RefreshBlockingInput(types.RefreshOptions{Scope: []types.RefreshableView{types.FILES}})
+	return nil
+}
+
+// fileForDiffLinePath maps the absolute path a diff line carries to the working tree
+// file it belongs to, or nil for a path that is no file of this repo's working tree.
+func (self *WorkingTreeDiffActions) fileForDiffLinePath(path string) *models.File {
+	relativePath, err := filepath.Rel(self.c.Git().RepoPaths.WorktreePath(), path)
+	if err != nil {
+		return nil
+	}
+	return self.context().FileTreeViewModel.GetFile(filepath.ToSlash(relativePath))
+}
+
+// applyDiffLines applies the given change lines of one file — a line, a hunk, a range —
+// as a patch built from that file's own diff:
+//
+//   - stage:   read the unstaged diff, apply it to the index
+//   - unstage: read the staged diff, apply it to the index backwards
+//
+// sourceCached names the diff the lines were selected in, which is where they are found
+// again; opts says how to apply what is built from them. The two are independent — a
+// discard reads one side and reverses it — so they are passed separately.
+//
+// Each selected line is looked for by where it sits in the file. This tells the two
+// halves of a modified line apart: the deletion and the addition replacing it share a
+// position in the new file and differ only in being a deletion. Context lines are not
+// selected: a patch of the lines you picked keeps whatever context it needs around
+// them by itself.
+//
+// It reports whether the diff it read holds changes the selection didn't cover. The
+// caller uses this to tell whether the side acted on still has anything of this file
+// in it once we are done.
+func (self *WorkingTreeDiffActions) applyDiffLines(
+	file *models.File, infos []types.DiffLineInfo, sourceCached bool, opts git_commands.ApplyPatchOpts,
+) (bool, error) {
+	parsedPatch := patch.Parse(self.c.Git().WorkingTree.WorktreeFileDiff(file, git_commands.DiffModePlain, sourceCached))
+
+	patchLineIndices := changeLineIndices(parsedPatch, infos)
+
+	changesLeft := len(patchLineIndices) < changeLineCount(parsedPatch)
+
+	// Acting on every change of a file is acting on the file itself, and saying so is
+	// not the same as applying its diff. The diff of a deleted file is its content
+	// going away, and putting that into the index line by line leaves an empty file
+	// there rather than the deletion; the diff of an added one is its whole content,
+	// and taking that back out leaves an empty file in the index rather than an
+	// untracked one.
+	if !changesLeft && opts.Cached {
+		if opts.Reverse {
+			return false, self.c.Git().WorkingTree.UnStageFile(file.Names(), file.Tracked)
+		}
+		return false, self.c.Git().WorkingTree.StageFile(file.GetPath())
+	}
+
+	patchToApply := parsedPatch.
+		Transform(patch.TransformOpts{
+			Reverse:             opts.Reverse,
+			IncludedLineIndices: patchLineIndices,
+			FileNameOverride:    file.GetPath(),
+		}).
+		FormatPlain()
+	if patchToApply == "" {
+		return changesLeft, nil
+	}
+
+	return changesLeft, self.c.Git().Patch.ApplyPatch(patchToApply, opts)
+}
+
+// changeLineIndices says which lines of a parsed patch the given diff rows are, as the
+// indices a patch is built in terms of. Each row is looked for by where it sits in the
+// file: an addition by its place in the new version, a deletion by its place in the
+// old one, which is what tells the two halves of a changed line apart.
+func changeLineIndices(parsedPatch *patch.Patch, infos []types.DiffLineInfo) []int {
+	type changeLine struct {
+		lineNumber int
+		isDeletion bool
+	}
+	selected := set.New[changeLine]()
+	for _, info := range infos {
+		if info.Type == types.DiffLineDeleted {
+			selected.Add(changeLine{info.OldLine, true})
+		} else {
+			selected.Add(changeLine{info.NewLine, false})
+		}
+	}
+
+	var indices []int
+	for idx, line := range parsedPatch.Lines() {
+		var key changeLine
+		switch {
+		case line.IsAddition():
+			key = changeLine{parsedPatch.LineNumberOfLine(idx), false}
+		case line.IsDeletion():
+			key = changeLine{parsedPatch.OldLineNumberOfLine(idx), true}
+		default:
+			continue
+		}
+		if selected.Includes(key) {
+			indices = append(indices, idx)
+		}
+	}
+	return indices
+}
+
+// changeLineCount returns how many of a patch's lines are changes rather than context
+// or header. A selection of the whole diff covers exactly that many.
+func changeLineCount(p *patch.Patch) int {
+	return lo.CountBy(p.Lines(), func(line *patch.PatchLine) bool {
+		return line.IsAddition() || line.IsDeletion()
+	})
+}
+
+// revealSelectionInPaneItLandsIn arranges for the selection to carry on where the work
+// does, which is not always the pane it was in.
+//
+// Each side of the diff has a pane of its own, so acting on one usually leaves
+// everything where it is. But a pane is only shown while its side has something in it:
+// staging the last unstaged change takes the upper pane away, and unstaging the last
+// staged one takes the lower one away. The refresh moves the focus into whichever pane
+// is left, and this puts the selection there to meet it — on the lines just acted on,
+// which are in that pane now, unless they were discarded rather than moved, in which
+// case on what is left of the file.
+func (self *WorkingTreeDiffActions) revealSelectionInPaneItLandsIn(
+	pane types.DiffPaneContext, firstBufferLine int, actedSideRemains bool, otherSideHasChanges bool,
+) {
+	target := pane
+	if !actedSideRemains && otherSideHasChanges {
+		target = self.otherPane(pane)
+	}
+
+	// Hold input back until the selection is on the change the work carries on from. The
+	// refresh holds it until the model is up to date, but the diff is re-rendered after
+	// that, and until it has been the selection is still on lines that aren't there any
+	// more — so a key pressed meanwhile would act on nothing.
+	self.c.GocuiGui().BeginBlockingEvents()
+	revealSelectionAfterAction(self.c, pane, target, firstBufferLine,
+		self.c.GocuiGui().EndBlockingEvents)
+}
+
+// otherPane returns the main pane that isn't the given one.
+func (self *WorkingTreeDiffActions) otherPane(pane types.DiffPaneContext) types.DiffPaneContext {
+	if pane.GetKey() == self.c.Contexts().Normal.GetKey() {
+		return self.c.Contexts().NormalSecondary
+	}
+	return self.c.Contexts().Normal
+}
+
+// anyFileHasChangesOnSide reports whether any file under the selected node, other than
+// the ones named by except, has changes on the given side of the index, as the model
+// has them. The model is right about any file the action didn't touch; the ones it did
+// touch report for themselves, their entry not being right until the refresh lands.
+func (self *WorkingTreeDiffActions) anyFileHasChangesOnSide(except *set.Set[string], staged bool) bool {
+	node := self.context().GetSelected()
+	if node == nil {
+		return false
+	}
+
+	found := false
+	_ = node.ForEachFile(func(file *models.File) error {
+		if except.Includes(file.GetPath()) {
+			return nil
+		}
+		if (staged && file.HasStagedChanges) || (!staged && file.HasUnstagedChanges) {
+			found = true
+		}
+		return nil
+	})
+	return found
+}
@@ -22,12 +22,7 @@ func (gui *Gui) scrollDownView(view *gocui.View) {
 }

 func (gui *Gui) scrollUpMain() error {
-	var view *gocui.View
-	if gui.c.Context().Current().GetWindowName() == "secondary" {
-		view = gui.secondaryView()
-	} else {
-		view = gui.mainView()
-	}
+	view := gui.mainSectionView()

 	if view.Name() == "mergeConflicts" {
 		// although we have this same logic in the controller, this method can be invoked
@@ -43,12 +38,7 @@ func (gui *Gui) scrollUpMain() error {
 }

 func (gui *Gui) scrollDownMain() error {
-	var view *gocui.View
-	if gui.c.Context().Current().GetWindowName() == "secondary" {
-		view = gui.secondaryView()
-	} else {
-		view = gui.mainView()
-	}
+	view := gui.mainSectionView()

 	if view.Name() == "mergeConflicts" {
 		gui.State.Contexts.MergeConflicts.SetUserScrolling(true)
@@ -59,6 +49,17 @@ func (gui *Gui) scrollDownMain() error {
 	return nil
 }

+// mainSectionView returns the view that the keys for scrolling the main section act
+// on: the pane the focus is in when it is in one of them, and otherwise the pane the
+// section is showing — which is the lower one whenever it has the section to itself.
+func (gui *Gui) mainSectionView() *gocui.View {
+	if gui.c.Context().Current().GetWindowName() == "secondary" ||
+		gui.State.MainPanes == types.SecondaryPaneOnly {
+		return gui.secondaryView()
+	}
+	return gui.mainView()
+}
+
 func (gui *Gui) mainView() *gocui.View {
 	viewName := gui.helpers.Window.GetViewNameForWindow("main")
 	view, _ := gui.g.View(viewName)
@@ -101,6 +101,10 @@ type Gui struct {
 	// this tells us whether our views have been initially set up
 	ViewsSetup bool

+	// the label for the key that focuses the main view, worn by whichever of the two
+	// main panes that key focuses (see showFocusMainViewJumpLabelOn)
+	focusMainViewJumpLabel string
+
 	Views types.Views

 	// Log of the commands/actions logged in the Command Log panel.
@@ -231,7 +235,7 @@ type GuiRepoState struct {
 	Model *types.Model
 	Modes *types.Modes

-	SplitMainPanel bool
+	MainPanes types.MainPanes

 	SearchState *types.SearchState
 	// Lets us not load everything at once. Written and read from refresh
@@ -321,12 +325,12 @@ func (self *GuiRepoState) GetSearchState() *types.SearchState {
 	return self.SearchState
 }

-func (self *GuiRepoState) SetSplitMainPanel(value bool) {
-	self.SplitMainPanel = value
+func (self *GuiRepoState) SetMainPanes(value types.MainPanes) {
+	self.MainPanes = value
 }

-func (self *GuiRepoState) GetSplitMainPanel() bool {
-	return self.SplitMainPanel
+func (self *GuiRepoState) GetMainPanes() types.MainPanes {
+	return self.MainPanes
 }

 func (gui *Gui) onSwitchToNewRepo(startArgs appTypes.StartArgs, contextKey types.ContextKey) error {
@@ -185,6 +185,10 @@ func (self *guiCommon) GetViewBufferManagerForView(view *gocui.View) *tasks.View
 	return self.gui.getViewBufferManagerForView(view)
 }

+func (self *guiCommon) GetOrCreateViewBufferManagerForView(view *gocui.View) *tasks.ViewBufferManager {
+	return self.gui.getManager(view)
+}
+
 func (self *guiCommon) ReadLinesToFillView(view *gocui.View) {
 	self.gui.readLinesToFillView(view)
 }
@@ -4,6 +4,7 @@ import (
 	"github.com/jesseduffield/lazygit/pkg/gocui"
 	"github.com/jesseduffield/lazygit/pkg/gui/context"
 	"github.com/jesseduffield/lazygit/pkg/gui/types"
+	"github.com/jesseduffield/lazygit/pkg/tasks"
 )

 func (gui *Gui) runTaskForView(view *gocui.View, task types.UpdateTask) error {
@@ -65,6 +66,10 @@ func (gui *Gui) RefreshMainView(opts *types.ViewUpdateOpts, context types.Contex

 	view.Subtitle = opts.SubTitle

+	if mainContext := gui.mainContextForView(view); mainContext != nil {
+		mainContext.SetContentIsDiff(types.ContentIsDiff(opts.Task))
+	}
+
 	if err := gui.runTaskForView(view, opts.Task); err != nil {
 		gui.c.Log.Error(err)
 	}
@@ -108,10 +113,20 @@ func (gui *Gui) allMainContextPairs() []types.MainContextPair {
 }

 func (gui *Gui) refreshMainViews(opts types.RefreshMainOpts) {
+	panes := mainPanesFor(opts)
+
+	// Before the render is triggered, so that the pane the focus moves into can be
+	// told where to put its selection as it renders.
+	gui.followFocusIntoWorkablePane(opts)
+
 	gui.moveMainContextPairToTop(opts.Pair)

+	gui.handOverMainSection(opts.Pair, panes)
+
 	if opts.Main != nil {
 		gui.RefreshMainView(opts.Main, opts.Pair.Main)
+	} else {
+		gui.clearMainView(opts.Pair.Main)
 	}

 	if opts.Secondary != nil {
@@ -134,7 +149,115 @@ func (gui *Gui) refreshMainViews(opts types.RefreshMainOpts) {
 		}
 	}

-	gui.splitMainPanel(opts.Secondary != nil)
+	gui.setMainPanes(panes)
+}
+
+// handOverMainSection carries the content of the main section from the pane that has
+// been showing it on its own to the pane about to, when a render moves the section's
+// content from one to the other — a file's changes going from unstaged to staged, say.
+//
+// The section is one region of the screen to the user, so a change of which pane holds
+// it has to look like that region re-rendering rather than blanking and filling in
+// again: the incoming pane shows what the outgoing one was showing, where it was
+// showing it, until its own render has read enough to be swapped in. It renders from
+// the top when it does, the content it took over not being its own (see
+// clearMainView).
+func (gui *Gui) handOverMainSection(pair types.MainContextPair, panes types.MainPanes) {
+	// The lower pane is always the same view, being the only one a render can leave
+	// holding the section on its own; the upper one is whichever view of the main
+	// window this render is for, which moveMainContextPairToTop has just given a copy
+	// of what that window was showing.
+	upper, lower := pair.Main.GetView(), gui.Views.Secondary
+
+	var from, to *gocui.View
+	switch {
+	case gui.State.MainPanes == types.MainPaneOnly && panes == types.SecondaryPaneOnly:
+		from, to = upper, lower
+	case gui.State.MainPanes == types.SecondaryPaneOnly && panes == types.MainPaneOnly:
+		from, to = lower, upper
+	default:
+		return
+	}
+
+	gui.g.CopyContent(from, to)
+}
+
+// mainPanesFor says which panes the given render occupies: the one it has content for,
+// or both when it has content for both.
+func mainPanesFor(opts types.RefreshMainOpts) types.MainPanes {
+	switch {
+	case opts.Secondary == nil:
+		return types.MainPaneOnly
+	case opts.Main == nil:
+		return types.SecondaryPaneOnly
+	default:
+		return types.BothMainPanes
+	}
+}
+
+// followFocusIntoWorkablePane moves the focus out of a main pane that the render about
+// to happen leaves nothing to work on, and into the one it does.
+//
+// Each side of a file's diff has a pane of its own, and a pane holds something only
+// while its side of the file does. So anything that empties the side the focus is on
+// leaves that pane with nothing: staging the last unstaged change, committing what was
+// staged, or either of those happening outside lazygit and arriving with a refresh.
+// Usually the pane goes away with its content; configured to always split the diff it
+// stays, empty. Either way the focus has nothing left to act on where it is.
+//
+// The pane moved into gets its selection once the render has finished and there is
+// something to put one on, and shows none until then, so that the selection it was
+// left with the last time it was used doesn't appear for a frame. A pane that has
+// already been told where to put its selection — by the action that caused all this —
+// keeps what it was told.
+func (gui *Gui) followFocusIntoWorkablePane(opts types.RefreshMainOpts) {
+	// The focused main view's two panes only: the staging and patch-building views
+	// arrange theirs for themselves, and the merge-conflicts view has just the one.
+	if opts.Pair.Main.GetKey() != context.NORMAL_MAIN_CONTEXT_KEY {
+		return
+	}
+
+	current := gui.State.ContextMgr.CurrentStatic().GetKey()
+	if current != opts.Pair.Main.GetKey() && current != opts.Pair.Secondary.GetKey() {
+		return
+	}
+	pane := onlyWorkablePane(opts)
+	if pane == nil || pane.GetKey() == current {
+		return
+	}
+
+	target := gui.mainContextForView(pane.GetView())
+	target.SetHasSelectableContent(false)
+	gui.State.ContextMgr.UpdateSelectionHighlights()
+	if manager := gui.getManager(target.GetView()); !manager.HasRestoreForNextTask() {
+		manager.SetRestoreForNextTask(&tasks.RenderRestore{
+			// The whole render is read before it is shown: where the selection goes
+			// is decided from what is there, and a change line further down would
+			// otherwise be missed.
+			FirstPaintReady: func() bool { return false },
+			Apply: func(swapIn func()) {
+				swapIn()
+				gui.helpers.DiffLine.EstablishSelection(target, -1)
+			},
+		})
+	}
+	gui.State.ContextMgr.Push(target, types.OnFocusOpts{})
+}
+
+// onlyWorkablePane returns the main pane a render leaves as the only one worth having
+// the focus in, or nil when that is true of both of them or of neither. Being shown is
+// not the same as being worth working in: a pane the layout keeps around for the sake
+// of always splitting the diff shows an empty side of the file.
+func onlyWorkablePane(opts types.RefreshMainOpts) types.Context {
+	main := opts.Main != nil && !opts.Main.NothingToActOn
+	secondary := opts.Secondary != nil && !opts.Secondary.NothingToActOn
+	if main == secondary {
+		return nil
+	}
+	if main {
+		return opts.Pair.Main
+	}
+	return opts.Pair.Secondary
 }

 // clampDiffSelectionToContent brings the focused main view's selection back onto the
@@ -162,18 +285,35 @@ func (gui *Gui) clampDiffSelectionToContent(view *gocui.View) {
 }

 // clearMainView empties a pane that is being given nothing to show, selection and all.
+//
+// An emptied pane is showing nothing, so it also goes back to the top and stops
+// claiming the render it was showing: whatever it is given next is content the user
+// hasn't seen there, and is shown from the top like any other.
+//
+// A position waiting to be put back goes too: this pane is getting no render for it
+// to ride, and whoever is waiting for the view to be back where it belongs has to
+// hear that it never will be.
 func (gui *Gui) clearMainView(mainContext types.Context) {
-	mainContext.GetView().Clear()
+	view := mainContext.GetView()
+	view.Clear()
+	view.SetOrigin(0, 0)
 	mainContext.SetHasSelectableContent(false)
+	if pane := gui.mainContextForView(view); pane != nil {
+		pane.SetContentIsDiff(false)
+	}
 	gui.State.ContextMgr.UpdateSelectionHighlights()
+	if manager := gui.getViewBufferManagerForView(view); manager != nil {
+		manager.ForgetRenderedContent()
+		manager.DropRestoreForNextTask()
+	}
 }

 // 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.
+// view is a diff, only while the pane is showing that diff rather than a message like
+// "No changed files", and only while the diff holds something to select — never over
+// one 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
@@ -251,6 +391,14 @@ func (gui *Gui) readOnUntilTheDiffPaneCanTell(view *gocui.View) {
 func (gui *Gui) diffPaneHasSomethingToSelect(
 	mainContext *context.MainContext, view *gocui.View, contentIsComplete bool,
 ) (bool, bool) {
+	if !mainContext.ContentIsDiff() {
+		// The pane is holding something other than the panel's diff: a message, or the
+		// hint shown for a merge conflict that has to be resolved by picking a side,
+		// which explains itself with a diff of what the sides did. Whatever is in there
+		// is not ours to act on, so this needs no content to answer either.
+		return false, true
+	}
+
 	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,
@@ -289,8 +437,24 @@ func (gui *Gui) mainContextForView(view *gocui.View) *context.MainContext {
 	return nil
 }

-func (gui *Gui) splitMainPanel(splitMainPanel bool) {
-	gui.State.SplitMainPanel = splitMainPanel
+func (gui *Gui) setMainPanes(panes types.MainPanes) {
+	gui.State.MainPanes = panes
+
+	// The label for the key that focuses the main view belongs on the pane that key
+	// focuses, which is the secondary one while it is the only one shown.
+	if panes == types.SecondaryPaneOnly {
+		gui.showFocusMainViewJumpLabelOn(gui.Views.Secondary)
+	} else {
+		gui.showFocusMainViewJumpLabelOn(gui.Views.Main)
+	}
+}
+
+// showFocusMainViewJumpLabelOn puts the main view's jump label on the given pane and
+// takes it off the other one, so that only the pane the key focuses wears it.
+func (gui *Gui) showFocusMainViewJumpLabelOn(view *gocui.View) {
+	gui.Views.Main.TitlePrefix = ""
+	gui.Views.Secondary.TitlePrefix = ""
+	view.TitlePrefix = gui.focusMainViewJumpLabel
 }

 // reApplySearch runs a search the view holds again over the content a render has just
@@ -50,7 +50,11 @@ func (self *OptionsMapMgr) renderContextOptionsMap() {
 	})...)

 	bindingsToDisplay := lo.Filter(allBindings, func(binding *types.Binding, _ int) bool {
-		return len(binding.Keys) > 0 && binding.DisplayOnScreen && !binding.IsDisabled()
+		// A binding that describes itself as nothing has nothing to do where we are —
+		// that is how a command which only applies to some of a view's contents says so
+		// — and an empty entry in the options bar would say nothing about it.
+		return len(binding.Keys) > 0 && binding.DisplayOnScreen && !binding.IsDisabled() &&
+			binding.GetShortDescription() != ""
 	})

 	optionsMap := lo.Map(bindingsToDisplay, func(binding *types.Binding, _ int) bindingInfo {
@@ -227,7 +227,7 @@ M file1
 			}
 			patchBuilder := patch.NewPatchBuilder(
 				utils.NewDummyLog(),
-				func(from string, to string, reverse bool, filename string, previousPath string, plain bool) (string, error) {
+				func(from string, to string, reverse bool, filename string, previousPath string) (string, error) {
 					return "", nil
 				},
 			)
@@ -93,6 +93,9 @@ func (gui *Gui) newStringTask(view *gocui.View, str string) error {

 func (gui *Gui) newStringTaskWithoutScroll(view *gocui.View, str string) error {
 	manager := gui.getManager(view)
+	// Whatever the view was going to be put back to belonged to a re-render of its
+	// content; this is a message instead, so there is nothing to put back.
+	manager.DropRestoreForNextTask()

 	f := func(tasks.TaskOpts) error {
 		return gui.g.OnUIThreadAndWaitBackground(func() {
@@ -111,6 +114,9 @@ func (gui *Gui) newStringTaskWithoutScroll(view *gocui.View, str string) error {

 func (gui *Gui) newStringTaskWithScroll(view *gocui.View, str string, originX int, originY int) error {
 	manager := gui.getManager(view)
+	// Whatever the view was going to be put back to belonged to a re-render of its
+	// content; this is a message instead, so there is nothing to put back.
+	manager.DropRestoreForNextTask()

 	f := func(tasks.TaskOpts) error {
 		return gui.g.OnUIThreadAndWaitBackground(func() {
@@ -130,6 +136,9 @@ func (gui *Gui) newStringTaskWithScroll(view *gocui.View, str string, originX in

 func (gui *Gui) newStringTaskWithKey(view *gocui.View, str string, key string) error {
 	manager := gui.getManager(view)
+	// Whatever the view was going to be put back to belonged to a re-render of its
+	// content; this is a message instead, so there is nothing to put back.
+	manager.DropRestoreForNextTask()

 	f := func(tasks.TaskOpts) error {
 		return gui.g.OnUIThreadAndWaitBackground(func() {
@@ -72,6 +72,10 @@ type IGuiCommon interface {
 	// return the view buffer manager for the given view, or nil if it doesn't have one
 	GetViewBufferManagerForView(view *gocui.View) *tasks.ViewBufferManager

+	// return the view buffer manager for the given view, making one if the view has
+	// never rendered anything, for saying something about a render still to come
+	GetOrCreateViewBufferManagerForView(view *gocui.View) *tasks.ViewBufferManager
+
 	// read enough lines into the given view's buffer to fill it at its current
 	// scroll position, plus some read-ahead for smooth scrolling
 	ReadLinesToFillView(view *gocui.View)
@@ -461,8 +465,8 @@ type IRepoStateAccessor interface {
 	SetScreenMode(ScreenMode)
 	InSearchPrompt() bool
 	GetSearchState() *SearchState
-	SetSplitMainPanel(bool)
-	GetSplitMainPanel() bool
+	SetMainPanes(MainPanes)
+	GetMainPanes() MainPanes
 	GetMergeOrRebaseStartedInLazygit() bool
 	SetMergeOrRebaseStartedInLazygit(bool)
 }
@@ -106,6 +106,10 @@ type IBaseContext interface {
 	// 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)
+	// Likewise for the focused main view, which acts on the diff of whichever panel
+	// is beneath it and so has to reach that panel's controller. nil for a panel
+	// that shows no diff.
+	AddFocusedMainViewDiffSource(FocusedMainViewDiffSource)

 	AddOnRenderToMainFn(func())
 	AddOnFocusFn(func(OnFocusOpts))
@@ -220,6 +224,43 @@ type DiffPaneContext interface {
 	DiffSelectState() *DiffSelectState
 }

+// FocusedMainViewDiffSource is how a side panel hands out the diff behind what it
+// renders into the focused main view: the diff of the given files as git writes it,
+// with no colour and no diff renderer in the way. What the main view shows is that
+// same diff after a renderer has had it, which may have restructured, reordered or
+// dropped parts of it — so anything that needs the diff itself, rather than a picture
+// of it, asks the panel that produced it.
+//
+// paths are repo-relative, and are asked for rather than assumed so that a few lines
+// of a commit's diff can be had without fetching the whole thing. pane says which of
+// the two main panes is asking, since a panel can show a different diff in each — the
+// files panel shows the unstaged changes in one and the staged ones in the other.
+type FocusedMainViewDiffSource interface {
+	PlainDiff(pane DiffPaneContext, paths []string) string
+}
+
+// FocusedMainViewActions describes what a side panel does when the user acts on a
+// selection of diff lines in the focused main view. The main view owns the selection
+// and the keys; what acting on it means is the panel's business, e.g. the working
+// tree panel stages and unstages.
+//
+// It extends the diff source rather than standing beside it, because acting on a
+// selection needs the diff behind the rendering just as reading it does; a panel that
+// implements only the source offers a diff to read and copy but nothing to do to it.
+type FocusedMainViewActions interface {
+	FocusedMainViewDiffSource
+
+	// PrimaryAction acts on the diff lines in the inclusive buffer-line range that the
+	// current selection in the given pane covers (see View.SelectedBufferLineRange): a
+	// single line, a range, or a hunk. The panel re-renders the diff itself, being the
+	// one that knows what it did to it.
+	PrimaryAction(pane DiffPaneContext, firstBufferLine int, lastBufferLine int) error
+
+	// DiscardSelection takes the selected diff lines back out of whatever they are part
+	// of: the working tree for the files panel.
+	DiscardSelection(pane DiffPaneContext, firstBufferLine int, lastBufferLine int) error
+}
+
 type IListContext interface {
 	Context

@@ -315,6 +356,11 @@ 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 hand out the diff behind what your
+	// panel renders into the focused main view, for the commands that act on a
+	// selection in it. nil for a controller whose panel shows no diff.
+	GetFocusedMainViewDiffSource() FocusedMainViewDiffSource
 }

 type IController interface {
@@ -40,3 +40,11 @@ type DiffLineInfo struct {
 func (self DiffLineInfo) IsChange() bool {
 	return self.Type == DiffLineAdded || self.Type == DiffLineDeleted
 }
+
+// IsContent reports whether the row is a line of the file itself — a change or a
+// context line — as opposed to a header or a marker. Those are the rows that have a
+// position in the file, and so can be looked for in another rendering of the same
+// diff, or in the diff itself.
+func (self DiffLineInfo) IsContent() bool {
+	return self.IsChange() || self.Type == DiffLineContext
+}
@@ -2,6 +2,8 @@ package types

 import (
 	"os/exec"
+
+	"github.com/jesseduffield/lazygit/pkg/commands/git_commands"
 )

 type MainContextPair struct {
@@ -13,6 +15,19 @@ func NewMainContextPair(main Context, secondary Context) MainContextPair {
 	return MainContextPair{Main: main, Secondary: secondary}
 }

+// MainPanes says which of the two panes of the main section are shown. Most content
+// takes the main pane alone; content with two sides to it — the working tree's
+// unstaged and staged changes, a commit's diff and the patch built from it — takes
+// both; and content whose only side is the second one takes the secondary pane alone,
+// so that it has the whole section rather than sitting under an empty pane.
+type MainPanes int
+
+const (
+	MainPaneOnly MainPanes = iota
+	BothMainPanes
+	SecondaryPaneOnly
+)
+
 type MainViewPairs struct {
 	Normal         MainContextPair
 	MergeConflicts MainContextPair
@@ -25,6 +40,11 @@ type ViewUpdateOpts struct {
 	SubTitle string

 	Task UpdateTask
+
+	// NothingToActOn marks a pane that is being shown only because the layout is
+	// configured to always split the diff: its side of the file holds nothing, so it
+	// is not a pane to leave the focus in.
+	NothingToActOn bool
 }

 type RefreshMainOpts struct {
@@ -49,6 +69,9 @@ func NewRenderStringTask(str string) *RenderStringTask {

 type RenderStringWithoutScrollTask struct {
 	Str string
+
+	// contentIsDiff marks a string that is a panel's own diff; see ContentIsDiff.
+	contentIsDiff bool
 }

 func (t *RenderStringWithoutScrollTask) IsUpdateTask() {}
@@ -57,6 +80,16 @@ func NewRenderStringWithoutScrollTask(str string) *RenderStringWithoutScrollTask
 	return &RenderStringWithoutScrollTask{Str: str}
 }

+// NewMainViewDiffStringTask returns the task for rendering a diff we hold as text
+// rather than as a command to run — the custom patch being built, which we assemble
+// ourselves. The view stays where it is, the patch being rendered again on every
+// change to it.
+func NewMainViewDiffStringTask(str string) UpdateTask {
+	task := NewRenderStringWithoutScrollTask(str)
+	task.contentIsDiff = true
+	return task
+}
+
 type RenderStringWithScrollTask struct {
 	Str     string
 	OriginX int
@@ -72,6 +105,9 @@ func NewRenderStringWithScrollTask(str string, originX int, originY int) *Render
 type RunCommandTask struct {
 	Cmd    *exec.Cmd
 	Prefix string
+
+	// contentIsDiff marks output that is a panel's own diff; see ContentIsDiff.
+	contentIsDiff bool
 }

 func (t *RunCommandTask) IsUpdateTask() {}
@@ -87,6 +123,9 @@ func NewRunCommandTaskWithPrefix(cmd *exec.Cmd, prefix string) *RunCommandTask {
 type RunDiffRendererTask struct {
 	Cmd    *exec.Cmd
 	Prefix string
+
+	// contentIsDiff marks output that is a panel's own diff; see ContentIsDiff.
+	contentIsDiff bool
 }

 func (t *RunDiffRendererTask) IsUpdateTask() {}
@@ -98,3 +137,41 @@ func NewRunDiffRendererTask(cmd *exec.Cmd) *RunDiffRendererTask {
 func NewRunDiffRendererTaskWithPrefix(cmd *exec.Cmd, prefix string) *RunDiffRendererTask {
 	return &RunDiffRendererTask{Cmd: cmd, Prefix: prefix}
 }
+
+// NewMainViewDiffTask returns the task for rendering a diff into a main view. A diff
+// normally goes through the diff renderer, however the render arranges to feed it. A
+// diff we are producing with git itself, because the renderer's version of it couldn't
+// be acted on, has to keep the renderer out, so it runs as a plain command instead.
+//
+// The task it returns is the one that says its output is a diff, so a pane rendering
+// it can be pointed at (see ContentIsDiff).
+func NewMainViewDiffTask(cmd *exec.Cmd, mode git_commands.DiffMode) UpdateTask {
+	return NewMainViewDiffTaskWithPrefix(cmd, "", mode)
+}
+
+func NewMainViewDiffTaskWithPrefix(cmd *exec.Cmd, prefix string, mode git_commands.DiffMode) UpdateTask {
+	if mode == git_commands.DiffModeRaw {
+		task := NewRunCommandTaskWithPrefix(cmd, prefix)
+		task.contentIsDiff = true
+		return task
+	}
+	task := NewRunDiffRendererTaskWithPrefix(cmd, prefix)
+	task.contentIsDiff = true
+	return task
+}
+
+// ContentIsDiff reports whether the given render fills a main pane with the diff a
+// panel offers there, as opposed to a message, a commit log, or a diff that is part of
+// an explanation. A selection means the lines of the panel's diff, so it is only over
+// such a render that there is anything to point at.
+func ContentIsDiff(task UpdateTask) bool {
+	switch task := task.(type) {
+	case *RenderStringWithoutScrollTask:
+		return task.contentIsDiff
+	case *RunCommandTask:
+		return task.contentIsDiff
+	case *RunDiffRendererTask:
+		return task.contentIsDiff
+	}
+	return false
+}
@@ -283,11 +283,11 @@ func (gui *Gui) configureViewProperties() {
 		}
 	}

+	gui.focusMainViewJumpLabel = ""
 	if gui.c.UserConfig().Gui.ShowPanelJumps {
-		gui.Views.Main.TitlePrefix = keyToTitlePrefix(gui.c.UserConfig().Keybinding.Universal.FocusMainView)
-	} else {
-		gui.Views.Main.TitlePrefix = ""
+		gui.focusMainViewJumpLabel = keyToTitlePrefix(gui.c.UserConfig().Keybinding.Universal.FocusMainView)
 	}
+	gui.showFocusMainViewJumpLabelOn(gui.Views.Main)

 	// Index the tab strips by view so we can both set them on views that are
 	// part of a multi-tab panel and clear them on views that no longer are
@@ -736,6 +736,8 @@ type TranslationSet struct {
 	CopyPathToClipboard                   string
 	CommitPrefixPatternError              string
 	CopySelectedTextToClipboard           string
+	SelectedDiffLinesCopiedToast          string
+	SelectionNotFoundInDiffToast          string
 	NoFilesStagedTitle                    string
 	NoFilesStagedPrompt                   string
 	BranchNotFoundTitle                   string
@@ -1925,6 +1927,8 @@ func EnglishTranslationSet() *TranslationSet {
 		CopyTagToClipboard:                       "Copy tag to clipboard",
 		CopyPathToClipboard:                      "Copy path to clipboard",
 		CopySelectedTextToClipboard:              "Copy selected text to clipboard",
+		SelectedDiffLinesCopiedToast:             "Selected diff lines copied to clipboard",
+		SelectionNotFoundInDiffToast:             "Nothing in the selection could be found in the diff",
 		CommitPrefixPatternError:                 "Error in commitPrefix pattern",
 		NoFilesStagedTitle:                       "No files staged",
 		NoFilesStagedPrompt:                      "You have not staged any files. Commit all files?",
@@ -88,6 +88,17 @@ func (self *ViewDriver) IsImmediatelyBelow(upper *ViewDriver) *ViewDriver {
 	return self
 }

+// TitlePrefix asserts on the label a view wears in front of its title, which is the
+// key that jumps to it.
+func (self *ViewDriver) TitlePrefix(expected *TextMatcher) *ViewDriver {
+	self.t.assertWithRetries(func() (bool, string) {
+		actual := self.getView().TitlePrefix
+		return expected.context(fmt.Sprintf("%s title prefix", self.context)).test(actual)
+	})
+
+	return self
+}
+
 func (self *ViewDriver) Clear() *ViewDriver {
 	// clearing multiple times in case there's multiple lines
 	//  (the clear button only clears a single line at a time)
@@ -300,6 +311,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()")
@@ -54,6 +54,6 @@ var ResolveWithoutTrailingLf = NewIntegrationTest(NewIntegrationTestArgs{
 				Contains("M  file").IsSelected(),
 			)

-		t.Views().Main().Content(Contains("-a1\n+a2\n").DoesNotContain("-no eol"))
+		t.Views().Secondary().Content(Contains("-a1\n+a2\n").DoesNotContain("-no eol"))
 	},
 })
@@ -73,6 +73,7 @@ var DiffAndApplyPatch = NewIntegrationTest(NewIntegrationTestArgs{
 			Focus().
 			SelectedLine(Contains("file1"))

-		t.Views().Main().Content(Contains("+second line"))
+		// The patch was applied to the index, so the file's changes are all staged.
+		t.Views().Secondary().Content(Contains("+second line"))
 	},
 })
@@ -32,7 +32,7 @@ var DirectoryDiffWithRenamedFiles = NewIntegrationTest(NewIntegrationTestArgs{
 				Equals("  R  dir/nested/file3 → file3"),
 			)

-		t.Views().Main().ContainsLines(
+		t.Views().Secondary().ContainsLines(
 			Equals("diff --git a/file1 b/dir/file1"),
 			Equals("similarity index 100%"),
 			Equals("rename from file1"),
@@ -51,7 +51,7 @@ var DirectoryDiffWithRenamedFiles = NewIntegrationTest(NewIntegrationTestArgs{
 			SelectNextItem().
 			SelectedLine(Equals("  ▼ dir"))

-		t.Views().Main().
+		t.Views().Secondary().
 			ContainsLines(
 				Equals("diff --git a/file1 b/dir/file1"),
 				Equals("similarity index 100%"),
@@ -75,7 +75,7 @@ var DirectoryDiffWithRenamedFiles = NewIntegrationTest(NewIntegrationTestArgs{
 				Equals("  R  file1 → file1"),
 			)

-		t.Views().Main().
+		t.Views().Secondary().
 			ContainsLines(
 				Equals("diff --git a/file1 b/dir/file1"),
 				Equals("similarity index 100%"),
@@ -0,0 +1,61 @@
+package file
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var PaneShownAgainStartsAtTheTop = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "A pane that was emptied while it wasn't shown starts at the top when it comes back, rather than where it was left",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	Width:        120,
+	Height:       30,
+	SetupConfig:  func(cfg *config.AppConfig) {},
+	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\n")
+		shell.Commit("one")
+
+		// More staged changes in file1 than fit in the pane they are shown in, so that
+		// there is a position in it to lose, plus an unstaged change to give the file a
+		// second pane.
+		for i := range lines {
+			lines[i] = strings.ToUpper(lines[i])
+		}
+		shell.UpdateFileAndAdd("file1", strings.Join(lines, "\n")+"\n")
+		shell.UpdateFile("file1", strings.Join(lines, "\n")+"unstaged\n")
+
+		shell.UpdateFile("file2", "two\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			NavigateToLine(Contains("file1"))
+
+		t.Views().Secondary().
+			IsVisible().
+			Title(Equals("Staged changes")).
+			ScrollWheelDown().
+			ScrollWheelDown().
+			OriginYAtLeast(1)
+
+		// A file with nothing staged leaves that pane with nothing to show, so it goes
+		// away and is emptied.
+		t.Views().Files().NavigateToLine(Contains("file2"))
+		t.Views().Secondary().IsInvisible()
+
+		t.Views().Files().NavigateToLine(Contains("file1"))
+		t.Views().Secondary().
+			IsVisible().
+			Content(Contains("+LINE40")).
+			OriginY(0)
+	},
+})
@@ -0,0 +1,85 @@
+package file
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+// changedLines is a file's worth of numbered lines, prefixed so that each file's diff
+// can be told from the other's on screen.
+func changedLines(prefix string) string {
+	lines := make([]string, 40)
+	for i := range lines {
+		lines[i] = fmt.Sprintf("%s%02d", prefix, i+1)
+	}
+	return strings.Join(lines, "\n") + "\n"
+}
+
+var PaneTakingOverStartsAtTheTop = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "A pane taking the main section over shows its diff from the top, rather than at the offset it was left at",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	Width:        120,
+	Height:       30,
+	SetupConfig:  func(cfg *config.AppConfig) {},
+	SetupRepo: func(shell *Shell) {
+		shell.CreateFileAndAdd("file1", changedLines("one"))
+		shell.CreateFileAndAdd("file2", changedLines("two"))
+		shell.Commit("one")
+
+		// One file's changes are unstaged and the other's are staged, so each is shown
+		// in a pane of its own — and selecting one after the other hands the section
+		// from one pane to the other. Both diffs are longer than the section, so either
+		// pane can be scrolled.
+		shell.UpdateFile("file1", changedLines("ONE"))
+		shell.UpdateFileAndAdd("file2", changedLines("TWO"))
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			NavigateToLine(Contains("file1"))
+
+		t.Views().Secondary().IsInvisible()
+		t.Views().Main().
+			IsVisible().
+			Title(Equals("Unstaged changes")).
+			ScrollWheelDown().
+			ScrollWheelDown().
+			OriginYAtLeast(1)
+
+		t.Views().Files().NavigateToLine(Contains("file2"))
+
+		t.Views().Main().IsInvisible()
+		t.Views().Secondary().
+			IsVisible().
+			Title(Equals("Staged changes")).
+			Content(Contains("+TWO40")).
+			OriginY(0).
+			ScrollWheelDown().
+			ScrollWheelDown().
+			OriginYAtLeast(1)
+
+		// Back to the pane that was left scrolled: what it is given is a diff the user
+		// hasn't seen there, so it starts at the top like any other.
+		t.Views().Files().NavigateToLine(Contains("file1"))
+
+		t.Views().Secondary().IsInvisible()
+		t.Views().Main().
+			IsVisible().
+			Title(Equals("Unstaged changes")).
+			Content(Contains("+ONE40")).
+			OriginY(0)
+
+		t.Views().Files().NavigateToLine(Contains("file2"))
+
+		t.Views().Main().IsInvisible()
+		t.Views().Secondary().
+			IsVisible().
+			Title(Equals("Staged changes")).
+			Content(Contains("+TWO40")).
+			OriginY(0)
+	},
+})
@@ -34,7 +34,7 @@ var RenameSimilarityThresholdChange = NewIntegrationTest(NewIntegrationTestArgs{
 			).
 			Press(keys.Universal.FocusMainView).
 			Tap(func() {
-				t.Views().Main().
+				t.Views().Secondary().
 					Press(keys.Universal.IncreaseRenameSimilarityThreshold)
 				t.ExpectToast(Equals("Changed rename similarity threshold to 50%"))
 			}).
@@ -0,0 +1,81 @@
+package file
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var StagedChangesInLowerPane = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "A file's staged changes are shown in the lower pane whether or not it also has unstaged ones",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	SetupConfig:  func(cfg *config.AppConfig) {},
+	SetupRepo: func(shell *Shell) {
+		shell.CreateFileAndAdd("both", "one\n")
+		shell.CreateFileAndAdd("indexOnly", "one\n")
+		shell.CreateFileAndAdd("worktreeOnly", "one\n")
+		shell.Commit("one")
+
+		shell.UpdateFileAndAdd("both", "one\nstaged\n")
+		shell.UpdateFile("both", "one\nstaged\nunstaged\n")
+		// More staged lines than fit in the pane, so that it can be scrolled.
+		staged := make([]string, 40)
+		for i := range staged {
+			staged[i] = fmt.Sprintf("staged%02d", i+1)
+		}
+		shell.UpdateFileAndAdd("indexOnly", "one\n"+strings.Join(staged, "\n")+"\n")
+		shell.UpdateFile("worktreeOnly", "one\nunstaged\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			NavigateToLine(Contains("both"))
+
+		// With changes on both sides, each side has its own pane.
+		t.Views().Main().
+			Title(Equals("Unstaged changes")).
+			Content(Contains("+unstaged"))
+		t.Views().Secondary().
+			Title(Equals("Staged changes")).
+			Content(Contains("+staged"))
+
+		// With nothing unstaged, the staged side keeps its pane, which then has the
+		// whole space to itself.
+		t.Views().Files().NavigateToLine(Contains("indexOnly"))
+
+		t.Views().Main().IsInvisible()
+		t.Views().Secondary().
+			IsVisible().
+			Title(Equals("Staged changes")).
+			Content(Contains("+staged01")).
+			// The key that focuses the diff wears its label, wherever the diff is.
+			TitlePrefix(Equals("[0]")).
+			OriginY(0)
+
+		// And the keys for scrolling the diff scroll the pane it is in.
+		t.GlobalPress(keys.Universal.ScrollDownMain)
+		t.Views().Secondary().OriginYAtLeast(1)
+		t.GlobalPress(keys.Universal.ScrollUpMain)
+		t.Views().Secondary().OriginY(0)
+
+		// And focusing the diff focuses the pane it is in.
+		t.Views().Files().Press(keys.Universal.FocusMainView)
+		t.Views().Secondary().IsFocused()
+		t.Views().Secondary().PressEscape()
+
+		// With nothing staged, only the upper pane is shown.
+		t.Views().Files().
+			IsFocused().
+			NavigateToLine(Contains("worktreeOnly"))
+
+		t.Views().Secondary().IsInvisible()
+		t.Views().Main().
+			IsVisible().
+			Title(Equals("Unstaged changes")).
+			Content(Contains("+unstaged")).
+			TitlePrefix(Equals("[0]"))
+	},
+})
@@ -0,0 +1,45 @@
+package main_view
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var AdvanceAfterStagingShiftsLineNumbers = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Staging a hunk that adds a line still leaves the selection on the next hunk, whose line numbers it moved",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	SetupConfig: func(cfg *config.AppConfig) {
+		cfg.GetUserConfig().Gui.UseHunkModeInStagingView = true
+	},
+	SetupRepo: func(shell *Shell) {
+		shell.CreateFileAndAdd("file1", "1\n2\n3\n4\n5\n6\n7\n8\n")
+		shell.Commit("one")
+
+		// Three change blocks: a modification, an added line, and another modification
+		// below it. Staging the middle one changes how many lines the file has, and so
+		// where the last one sits.
+		shell.UpdateFile("file1", "1\nX\n3\n4\nNEW\n5\n6\nY\n8\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			Press(keys.Universal.FocusMainView)
+
+		t.Views().Main().
+			IsFocused().
+			SelectedLines(
+				Contains("-2"),
+				Contains("+X"),
+			).
+			Press(keys.Main.NextHunk).
+			SelectedLines(
+				Contains("+NEW"),
+			).
+			PressPrimaryAction().
+			SelectedLines(
+				Contains("-7"),
+				Contains("+Y"),
+			)
+	},
+})
@@ -0,0 +1,67 @@
+package main_view
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var CommitFromMainView = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Commit what you staged without leaving the focused main view, but not while looking at a commit's diff",
+	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.UpdateFile("file1", "one\nADDED\ntwo\nthree\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		// Committing acts on the working tree, so it is offered over the working tree's
+		// diff and does nothing over a commit's.
+		t.Views().Commits().
+			Focus().
+			Press(keys.Universal.FocusMainView)
+
+		t.Views().Main().
+			IsFocused().
+			Press(keys.Files.CommitChanges).
+			// Nothing happened: the commit message panel would have taken the focus.
+			IsFocused()
+
+		t.Views().Files().
+			Focus().
+			Press(keys.Universal.FocusMainView)
+
+		t.Views().Main().
+			IsFocused().
+			SelectedLines(
+				Contains("+ADDED"),
+			).
+			PressPrimaryAction()
+
+		// Staging it left nothing unstaged, so the diff — and the focus with it — is in
+		// the pane the staged side has.
+		t.Views().Secondary().
+			IsFocused().
+			Press(keys.Files.CommitChanges)
+
+		t.ExpectPopup().CommitMessagePanel().
+			Type("staged from the diff").
+			Confirm()
+
+		// The commit left the staged side with nothing in it, so the pane it was made
+		// from is gone and the focus is in the one that is still there.
+		t.Views().Secondary().IsInvisible()
+		t.Views().Main().
+			IsFocused().
+			Content(Contains("No changed files"))
+
+		t.Views().Commits().Lines(
+			Contains("staged from the diff"),
+			Contains("one"),
+		)
+	},
+})
@@ -0,0 +1,56 @@
+package main_view
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var CopyRowsThatAreNoDiffLine = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Copying rows that stand for no line of the diff says so rather than copying nothing",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	SetupConfig: func(cfg *config.AppConfig) {
+		cfg.GetUserConfig().Gui.UseHunkModeInStagingView = false
+		cfg.GetUserConfig().OS.CopyToClipboardCmd = "printf '%s' {{text}} > clipboard"
+		// A renderer that states which line of the file each row of its diff shows, and
+		// ends with a row of its own that shows none. It ignores its input and prints
+		// this one.
+		cfg.GetUserConfig().Git.DiffRenderers = []config.DiffRendererConfig{
+			{Command: `printf '\033]1717;1\007'; ` +
+				`printf '\033]1717;1;f;;;file1\007file1\n'; ` +
+				`printf '\033]1717;1;c;1;;file1\007 one\n'; ` +
+				`printf '\033]1717;1;d;2;2;file1\007-two\n'; ` +
+				`printf '\033]1717;1;a;2;;file1\007+TWO\n'; ` +
+				`printf '\033]1717;1;c;3;;file1\007 three\n'; ` +
+				`printf -- '--- that was the diff ---\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"),
+			).
+			SelectNextItem().
+			SelectNextItem().
+			SelectNextItem().
+			SelectedLines(
+				Contains("that was the diff"),
+			).
+			Press(keys.Universal.CopyToClipboard)
+
+		t.ExpectToast(Equals("Nothing in the selection could be found in the diff"))
+		t.FileSystem().PathNotPresent("clipboard")
+	},
+})
@@ -0,0 +1,143 @@
+package main_view
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+// The clipboard is emulated by a file, so that this works on CI too. A copy says so
+// with a toast, which the harness wants acknowledged before the next keypress.
+func expectClipboard(t *TestDriver, matcher *TextMatcher) {
+	defer t.Shell().DeleteFile("clipboard")
+
+	t.ExpectToast(Equals("Selected diff lines copied to clipboard"))
+	t.FileSystem().FileContent("clipboard", matcher)
+}
+
+var CopySelectedDiffLines = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Copy the selected diff lines from the focused main view, as the diff reads rather than as the renderer drew it",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	SetupConfig: func(cfg *config.AppConfig) {
+		cfg.GetUserConfig().Gui.UseHunkModeInStagingView = true
+		// Emulate the clipboard by writing to a file.
+		cfg.GetUserConfig().OS.CopyToClipboardCmd = "printf '%s' {{text}} > clipboard"
+		// A renderer that decorates every line of a diff's body, so that what is on
+		// screen is not what the diff says. It announces the metadata protocol, so that
+		// its output is taken at its word rather than replaced by git's own; and it
+		// reads the +/- column, so it wants its input uncoloured.
+		cfg.GetUserConfig().Git.DiffRenderers = []config.DiffRendererConfig{
+			{
+				Command: `printf '\033]1717;1\007'; ` +
+					`awk '/^@@/ { body = 1 } body && /^[-+ ]/ { print $0 " <<<"; next } { print }'`,
+				ColorArg: "never",
+			},
+		}
+	},
+	SetupRepo: func(shell *Shell) {
+		shell.CreateFileAndAdd("file1", "one\ntwo\nthree\n")
+		shell.Commit("one")
+		shell.UpdateFileAndAdd("file1", "one\nTWO\nthree\n")
+		shell.Commit("two")
+
+		shell.UpdateFile("file1", "one\nTWO\nADD1\nADD2\nthree\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			Press(keys.Universal.FocusMainView)
+
+		t.Views().Main().
+			IsFocused().
+			SelectedLines(
+				Contains("+ADD1 <<<"),
+				Contains("+ADD2 <<<"),
+			).
+			Press(keys.Universal.CopyToClipboard)
+
+		// The renderer's decoration is nowhere in what was copied, and a selection that
+		// is all additions loses its '+' column, ready to be pasted into code.
+		expectClipboard(t, Equals("ADD1\nADD2\n"))
+
+		// A selection reaching up into the hunk header takes the header with it, and what
+		// comes out is a patch fragment rather than lines of code, so the columns stay.
+		t.Views().Main().
+			IsFocused().
+			Press(keys.Main.ToggleSelectHunk).
+			SelectedLines(
+				Contains("+ADD1 <<<"),
+			).
+			Press(keys.Universal.ToggleRangeSelect).
+			Press(keys.Universal.PrevItem).
+			Press(keys.Universal.PrevItem).
+			Press(keys.Universal.PrevItem).
+			SelectedLines(
+				Contains("@@ -1,3 +1,5 @@"),
+				Contains(" one <<<"),
+				Contains(" TWO <<<"),
+				Contains("+ADD1 <<<"),
+			).
+			Press(keys.Universal.CopyToClipboard)
+
+		expectClipboard(t, Equals("@@ -1,3 +1,5 @@\n one\n TWO\n+ADD1\n"))
+
+		// A file header is taken whole, however much of it is selected: the rendering may
+		// show it as any number of rows, none of which is a line of the file.
+		t.Views().Main().
+			IsFocused().
+			Press(keys.Universal.PrevItem).
+			SelectedLines(
+				Contains("+++ b/file1"),
+				Contains("@@ -1,3 +1,5 @@"),
+				Contains(" one <<<"),
+				Contains(" TWO <<<"),
+				Contains("+ADD1 <<<"),
+			).
+			Press(keys.Universal.CopyToClipboard)
+
+		expectClipboard(t, MatchesRegexp(
+			`\Adiff --git a/file1 b/file1\nindex [0-9a-f]+\.\.[0-9a-f]+ 100644\n`+
+				`--- a/file1\n\+\+\+ b/file1\n@@ -1,3 \+1,5 @@\n one\n TWO\n\+ADD1\n\z`))
+
+		// A commit's diff is copied the same way, through the panel that produced it.
+		t.Views().Commits().
+			Focus().
+			NavigateToLine(Contains("two")).
+			Press(keys.Universal.FocusMainView)
+
+		t.Views().Main().
+			IsFocused().
+			SelectedLines(
+				Contains("-two <<<"),
+				Contains("+TWO <<<"),
+			).
+			Press(keys.Universal.CopyToClipboard)
+
+		// Both kinds of line are in the selection, so the columns stay: what comes out
+		// is the diff itself.
+		expectClipboard(t, Equals("-two\n+TWO\n"))
+
+		// What a diff view shows above the diff is part of no file's diff, a commit's
+		// message among it, so a selection of those rows is copied as it stands on screen.
+		t.Views().Main().
+			IsFocused().
+			Press(keys.Main.ToggleSelectHunk).
+			NavigateToLine(Contains("    two")).
+			Press(keys.Universal.CopyToClipboard)
+
+		expectClipboard(t, Equals("    two\n"))
+
+		// A selection reaching from there into the diff takes the screen's rows down to
+		// the first file and the diff's own from there on.
+		t.Views().Main().
+			IsFocused().
+			Press(keys.Universal.ToggleRangeSelect).
+			NavigateToLine(Contains("-two <<<")).
+			Press(keys.Universal.CopyToClipboard)
+
+		expectClipboard(t, MatchesRegexp(
+			`\A {4}two\n---\n file1 \|[^\n]*\n 1 file changed[^\n]*\n\n`+
+				`diff --git a/file1 b/file1\nindex [0-9a-f]+\.\.[0-9a-f]+ 100644\n`+
+				`--- a/file1\n\+\+\+ b/file1\n@@ -1,3 \+1,3 @@\n one\n-two\n\z`))
+	},
+})
@@ -0,0 +1,70 @@
+package main_view
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var DiscardDiffLines = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Discard a hunk of the working tree's diff from the focused main view, and unstage one from the staged half",
+	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.UpdateFileAndAdd("file1", "one\nSTAGED\ntwo\nthree\nfour\nfive\nsix\nseven\neight\nnine\nten\n")
+		shell.UpdateFile("file1", "one\nSTAGED\ntwo\nthree\nfour\nfive\nsix\nseven\nUNSTAGED\neight\nnine\nten\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			Lines(
+				Contains("MM file1").IsSelected(),
+			).
+			Press(keys.Universal.FocusMainView)
+
+		// Discarding from the unstaged side throws the change away, so it asks first.
+		t.Views().Main().
+			IsFocused().
+			SelectedLines(
+				Contains("+UNSTAGED"),
+			).
+			Press(keys.Universal.Remove).
+			Tap(func() {
+				t.ExpectPopup().Confirmation().
+					Title(Equals("Discard change")).
+					Content(Contains("Are you sure you want to discard this change")).
+					Confirm()
+			})
+
+		// Nothing is unstaged any more, so that pane is gone and the focus has followed
+		// the file's remaining changes into the staged one.
+		t.Views().Files().Lines(
+			Contains("M  file1"),
+		)
+		t.Views().Main().IsInvisible()
+
+		// There the same key means "I don't want this staged", which is unstaging, so it
+		// doesn't ask.
+		t.Views().Secondary().
+			IsFocused().
+			Title(Equals("Staged changes")).
+			SelectedLines(
+				Contains("+STAGED"),
+			).
+			Press(keys.Universal.Remove)
+
+		t.Views().Files().Lines(
+			Contains(" M file1"),
+		)
+		t.Views().Secondary().IsInvisible()
+		t.Views().Main().
+			IsFocused().
+			Title(Equals("Unstaged changes")).
+			Content(Contains("+STAGED"))
+	},
+})
@@ -0,0 +1,59 @@
+package main_view
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var EditHunkInFocusedDiff = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Edit the hunk around the selection in an editor, and stage what comes back",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	SetupConfig: func(cfg *config.AppConfig) {
+		cfg.GetUserConfig().Gui.UseHunkModeInStagingView = false
+		// Stand in for the editor: record the line it was pointed at, outside the
+		// repo so that the files panel keeps saying what the test is about, then
+		// write a patch that stages something neither side of the diff says. That
+		// is the point of editing a hunk.
+		cfg.GetUserConfig().OS.EditAtLineAndWait = "echo {{line}} > ../edit-line && " +
+			"printf '%s\\n' '--- a/file1' '+++ b/file1' '@@ -1,3 +1,3 @@' " +
+			"' one' '-two' '+TWO_EDITED' ' three' > {{filename}}"
+	},
+	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().
+			Lines(
+				Contains("file1").IsSelected(),
+			).
+			Press(keys.Universal.FocusMainView)
+
+		t.Views().Main().
+			IsFocused().
+			SelectedLines(Contains("-two")).
+			Press(keys.Main.EditSelectHunk)
+
+		// The patch is written with a two-line header, so the deletion the cursor was
+		// on is its fifth line.
+		t.FileSystem().FileContent("../edit-line", Equals("5\n"))
+
+		// What the editor wrote went into the index, leaving the working tree as it
+		// was: the file is changed on both sides now, differently.
+		t.Views().Files().Lines(
+			Contains("MM").Contains("file1"),
+		)
+		t.Views().Secondary().ContainsLines(
+			Contains("-two"),
+			Contains("+TWO_EDITED"),
+		)
+		t.Views().Main().ContainsLines(
+			Contains("-TWO_EDITED"),
+			Contains("+TWO"),
+		)
+	},
+})
@@ -0,0 +1,52 @@
+package main_view
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var FocusFollowsAPaneEmptiedFromOutside = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Committing the staged changes outside lazygit takes the staged pane away, so the focus follows into the one that is left",
+	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\n")
+		shell.Commit("one")
+
+		// One change on each side, so the diff is split.
+		shell.UpdateFileAndAdd("file1", "one\nSTAGED\ntwo\nthree\nfour\nfive\n")
+		shell.UpdateFile("file1", "one\nSTAGED\ntwo\nthree\nUNSTAGED\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.TogglePanel)
+
+		t.Views().Secondary().
+			IsFocused().
+			Title(Equals("Staged changes")).
+			SelectedLines(
+				Contains("+STAGED"),
+			)
+
+		// Nothing lazygit did empties the staged side here; the refresh simply finds
+		// it empty, and the pane the focus was in is gone by the time it lands.
+		t.Shell().Commit("two")
+		t.GlobalPress(keys.Universal.Refresh)
+
+		t.Views().Secondary().IsInvisible()
+		t.Views().Main().
+			IsFocused().
+			Title(Equals("Unstaged changes")).
+			SelectedLines(
+				Contains("+UNSTAGED"),
+			)
+	},
+})
@@ -0,0 +1,74 @@
+package main_view
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var FocusFollowsIntoAPaneTakingOver = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "The pane the focus follows into as it takes the section over gets its selection from the top of the diff it is given",
+	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")
+
+		// Everything staged and nothing unstaged, so the staged side has the section to
+		// itself, with more changes in it than fit.
+		for i := range lines {
+			lines[i] = strings.ToUpper(lines[i])
+		}
+		shell.UpdateFileAndAdd("file1", strings.Join(lines, "\n")+"\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			Lines(
+				Contains("M  file1").IsSelected(),
+			)
+
+		// Read a way into the diff before focusing it, so that the selection starts out
+		// somewhere other than the first change.
+		t.Views().Secondary().
+			IsVisible().
+			ScrollWheelDown().
+			ScrollWheelDown().
+			ScrollWheelDown().
+			ScrollWheelDown().
+			OriginY(8)
+
+		t.Views().Files().Press(keys.Universal.FocusMainView)
+		t.Views().Secondary().
+			IsFocused().
+			SelectedLines(
+				Contains("-line04"),
+			)
+
+		// The index is reset outside lazygit, so the staged side empties and the
+		// unstaged side has everything: the pane the focus is in goes away and the other
+		// one takes the section over with a diff that is new to it.
+		t.Shell().RunCommand([]string{"git", "reset"})
+		t.GlobalPress(keys.Universal.Refresh)
+
+		t.Views().Secondary().IsInvisible()
+		t.Views().Main().
+			IsFocused().
+			Title(Equals("Unstaged changes")).
+			OriginY(0).
+			SelectedLines(
+				Contains("-line01"),
+			)
+	},
+})
@@ -0,0 +1,54 @@
+package main_view
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var FocusFollowsStagedSide = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Unstaging from a fully staged file leaves the focus on the staged side, which keeps its pane",
+	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")
+
+		// Two staged additions and nothing unstaged, so only the pane the staged side
+		// lives in is shown.
+		shell.UpdateFileAndAdd("file1", "one\nSTAGED1\ntwo\nthree\nfour\nfive\nsix\nseven\nSTAGED2\neight\nnine\nten\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			Lines(
+				Contains("M  file1").IsSelected(),
+			).
+			Press(keys.Universal.FocusMainView)
+
+		t.Views().Main().IsInvisible()
+		t.Views().Secondary().
+			IsFocused().
+			Title(Equals("Staged changes")).
+			SelectedLines(
+				Contains("+STAGED1"),
+			).
+			PressPrimaryAction()
+
+		// The line taken out of the index turns up in the pane that has just appeared
+		// above, and the work carries on where it was, on the next staged change.
+		t.Views().Files().Lines(
+			Contains("MM file1"),
+		)
+		t.Views().Main().
+			IsVisible().
+			Content(Contains("+STAGED1"))
+		t.Views().Secondary().
+			IsFocused().
+			SelectedLines(
+				Contains("+STAGED2"),
+			)
+	},
+})
@@ -0,0 +1,47 @@
+package main_view
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var FocusFollowsWhenPaneGoes = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Staging the last unstaged change takes the upper pane away, so the focus follows the lines into the lower one",
+	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.UpdateFile("file1", "one\nADDED\ntwo\nthree\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			Press(keys.Universal.FocusMainView)
+
+		t.Views().Main().
+			IsFocused().
+			Title(Equals("Unstaged changes")).
+			SelectedLines(
+				Contains("+ADDED"),
+			).
+			PressPrimaryAction()
+
+		// Nothing is unstaged any more, so that pane is gone and the line is in the one
+		// below, where the focus and the selection now are.
+		t.Views().Files().Lines(
+			Contains("M  file1"),
+		)
+		t.Views().Main().IsInvisible()
+		t.Views().Secondary().
+			IsFocused().
+			Title(Equals("Staged changes")).
+			SelectedLines(
+				Contains("+ADDED"),
+			)
+	},
+})
@@ -0,0 +1,53 @@
+package main_view
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var FocusLeavesAnAlwaysSplitEmptyPane = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Configured to always split the diff, the emptied pane stays but the focus still leaves it",
+	ExtraCmdArgs: []string{},
+	Skip:         false,
+	SetupConfig: func(cfg *config.AppConfig) {
+		cfg.GetUserConfig().Gui.UseHunkModeInStagingView = false
+		cfg.GetUserConfig().Gui.SplitDiff = "always"
+	},
+	SetupRepo: func(shell *Shell) {
+		shell.CreateFileAndAdd("file1", "one\ntwo\nthree\nfour\nfive\n")
+		shell.Commit("one")
+
+		shell.UpdateFileAndAdd("file1", "one\nSTAGED\ntwo\nthree\nfour\nfive\n")
+		shell.UpdateFile("file1", "one\nSTAGED\ntwo\nthree\nUNSTAGED\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.TogglePanel)
+
+		t.Views().Secondary().
+			IsFocused().
+			SelectedLines(
+				Contains("+STAGED"),
+			)
+
+		t.Shell().Commit("two")
+		t.GlobalPress(keys.Universal.Refresh)
+
+		// The staged side is empty now, but its pane is still shown because the split
+		// is configured as permanent. There is nothing left to act on in it, so the
+		// focus goes where there is.
+		t.Views().Secondary().
+			IsVisible().
+			Content(DoesNotContain("STAGED"))
+		t.Views().Main().
+			IsFocused().
+			SelectedLines(
+				Contains("+UNSTAGED"),
+			)
+	},
+})
@@ -0,0 +1,56 @@
+package main_view
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/config"
+	. "github.com/jesseduffield/lazygit/pkg/integration/components"
+)
+
+var FocusReturnsWhenSplitCollapses = NewIntegrationTest(NewIntegrationTestArgs{
+	Description:  "Unstaging the last staged change from the secondary pane brings the focus back to the main one",
+	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")
+
+		// One change on each side, so the diff is split.
+		shell.UpdateFileAndAdd("file1", "one\nSTAGED\ntwo\nthree\nfour\nfive\nsix\nseven\neight\nnine\nten\n")
+		shell.UpdateFile("file1", "one\nSTAGED\ntwo\nthree\nfour\nfive\nsix\nseven\nUNSTAGED\neight\nnine\nten\n")
+	},
+	Run: func(t *TestDriver, keys config.KeybindingConfig) {
+		t.Views().Files().
+			IsFocused().
+			Lines(
+				Contains("MM file1").IsSelected(),
+			).
+			Press(keys.Universal.FocusMainView)
+
+		t.Views().Main().
+			IsFocused().
+			Press(keys.Universal.TogglePanel)
+
+		t.Views().Secondary().
+			IsFocused().
+			SelectedLines(
+				Contains("+STAGED"),
+			).
+			PressPrimaryAction()
+
+		// With nothing staged left the diff isn't split any more, so the pane that was
+		// showing the staged side is gone — and the focus is back on the main one, where
+		// the change just taken out of the index now is.
+		t.Views().Files().Lines(
+			Contains(" M file1"),
+		)
+		t.Views().Main().
+			IsFocused().
+			Content(Contains("+STAGED")).
+			Content(Contains("+UNSTAGED")).
+			SelectedLines(
+				Contains("+STAGED"),
+			)
+	},
+})
@@ -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)
+	},
+})
@@ -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"),
+			)
+	},
+})
@@ -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"),
+			)
+	},
+})
@@ -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)
+	},
+})
@@ -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)
+	},
+})
@@ -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)
+	},
+})
@@ -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)
+	},
+})
@@ -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)
+	},
+})
--- a/Show More
+++ b/Show More