From a53715eff1e16c21e7493289031991ae0f17a1f3 Mon Sep 17 00:00:00 2001
From: Andreas Gerler <baron@bundesbrandschatzamt.de>
Date: Tue, 25 Nov 2025 19:35:56 +0100
Subject: [PATCH] update magit

---
 .../.dir-locals.el                            |    0
 .../AUTHORS.md                                |    1 +
 .../LICENSE                                   |    0
 .../dir                                       |    0
 .../git-commit.el                             |   68 +-
 .../git-rebase.el                             |  239 ++-
 .../magit-apply.el                            |   97 +-
 .../magit-autoloads.el                        |   78 +-
 .../magit-autorevert.el                       |   28 +-
 .../magit-base.el                             |  150 +-
 .../magit-bisect.el                           |   15 +-
 .../magit-blame.el                            |  107 +-
 .../magit-bookmark.el                         |   16 +
 .../magit-branch.el                           |  177 ++-
 .../magit-bundle.el                           |   13 +-
 .../magit-clone.el                            |   29 +-
 .../magit-commit.el                           |   21 +-
 .../magit-core.el                             |   11 +
 .../magit-diff.el                             | 1403 +++++++++--------
 .../magit-dired.el                            |   17 +-
 .../magit-ediff.el                            |   46 +-
 .../magit-extras.el                           |  217 +--
 .../magit-fetch.el                            |   14 +-
 .../magit-files.el                            |  204 ++-
 .../magit-git.el                              |  735 +++++----
 .../magit-gitignore.el                        |   19 +-
 .../magit-log.el                              |  526 +++---
 .../magit-margin.el                           |  172 +-
 .../magit-merge.el                            |   46 +-
 .../magit-mode.el                             |  445 +++---
 .../magit-notes.el                            |   33 +-
 .../magit-patch.el                            |   27 +-
 .../magit-pkg.el                              |   19 +-
 .../magit-process.el                          |  188 ++-
 .../magit-pull.el                             |   30 +-
 .../magit-push.el                             |   45 +-
 .../magit-reflog.el                           |   17 +-
 .../magit-refs.el                             |  164 +-
 .../magit-remote.el                           |   15 +-
 .../magit-repos.el                            |   66 +-
 .../magit-reset.el                            |   17 +-
 .../magit-sequence.el                         |  120 +-
 .../magit-sparse-checkout.el                  |   21 +-
 .../magit-stash.el                            |   24 +-
 .../magit-status.el                           |  211 +--
 .../magit-submodule.el                        |   42 +-
 .../magit-subtree.el                          |   11 +
 .../magit-tag.el                              |   38 +-
 .../magit-transient.el                        |   93 +-
 .../magit-wip.el                              |  118 +-
 .../magit-worktree.el                         |  169 +-
 .../magit.el                                  |  121 +-
 .../magit.info                                | 1061 +++++++------
 .../dir                                       |    0
 .../magit-section-autoloads.el                |    0
 .../magit-section-pkg.el                      |   15 +-
 .../magit-section.el                          |  587 +++----
 .../magit-section.info                        |    2 +-
 58 files changed, 4604 insertions(+), 3544 deletions(-)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/.dir-locals.el (100%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/AUTHORS.md (99%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/LICENSE (100%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/dir (100%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/git-commit.el (96%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/git-rebase.el (80%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-apply.el (93%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-autoloads.el (97%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-autorevert.el (92%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-base.el (93%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-bisect.el (95%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-blame.el (93%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-bookmark.el (88%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-branch.el (90%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-bundle.el (92%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-clone.el (94%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-commit.el (97%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-core.el (91%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-diff.el (78%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-dired.el (85%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-ediff.el (95%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-extras.el (86%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-fetch.el (93%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-files.el (78%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-git.el (84%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-gitignore.el (91%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-log.el (83%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-margin.el (60%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-merge.el (91%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-mode.el (81%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-notes.el (86%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-patch.el (93%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-pkg.el (59%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-process.el (91%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-pull.el (89%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-push.el (92%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-reflog.el (92%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-refs.el (88%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-remote.el (96%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-repos.el (91%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-reset.el (91%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-sequence.el (93%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-sparse-checkout.el (92%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-stash.el (97%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-status.el (85%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-submodule.el (96%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-subtree.el (94%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-tag.el (89%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-transient.el (78%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-wip.el (85%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit-worktree.el (51%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit.el (89%)
 rename elpa/{magit-20250519.1537 => magit-20251103.1130}/magit.info (96%)
 rename elpa/{magit-section-20250518.653 => magit-section-20251027.1634}/dir (100%)
 rename elpa/{magit-section-20250518.653 => magit-section-20251027.1634}/magit-section-autoloads.el (100%)
 rename elpa/{magit-section-20250518.653 => magit-section-20251027.1634}/magit-section-pkg.el (55%)
 rename elpa/{magit-section-20250518.653 => magit-section-20251027.1634}/magit-section.el (87%)
 rename elpa/{magit-section-20250518.653 => magit-section-20251027.1634}/magit-section.info (99%)

diff --git a/elpa/magit-20250519.1537/.dir-locals.el b/elpa/magit-20251103.1130/.dir-locals.el
similarity index 100%
rename from elpa/magit-20250519.1537/.dir-locals.el
rename to elpa/magit-20251103.1130/.dir-locals.el
diff --git a/elpa/magit-20250519.1537/AUTHORS.md b/elpa/magit-20251103.1130/AUTHORS.md
similarity index 99%
rename from elpa/magit-20250519.1537/AUTHORS.md
rename to elpa/magit-20251103.1130/AUTHORS.md
index e0b88d92..ba62bdf3 100644
--- a/elpa/magit-20250519.1537/AUTHORS.md
+++ b/elpa/magit-20251103.1130/AUTHORS.md
@@ -411,6 +411,7 @@ All Contributors
 - Wouter Bolsterlee
 - X4lldux
 - Xavier Noria
+- Xavier Young
 - Xu Chunyang
 - Yann Herklotz
 - Yann Hodique
diff --git a/elpa/magit-20250519.1537/LICENSE b/elpa/magit-20251103.1130/LICENSE
similarity index 100%
rename from elpa/magit-20250519.1537/LICENSE
rename to elpa/magit-20251103.1130/LICENSE
diff --git a/elpa/magit-20250519.1537/dir b/elpa/magit-20251103.1130/dir
similarity index 100%
rename from elpa/magit-20250519.1537/dir
rename to elpa/magit-20251103.1130/dir
diff --git a/elpa/magit-20250519.1537/git-commit.el b/elpa/magit-20251103.1130/git-commit.el
similarity index 96%
rename from elpa/magit-20250519.1537/git-commit.el
rename to elpa/magit-20251103.1130/git-commit.el
index 206cef88..0bcad3d3 100644
--- a/elpa/magit-20250519.1537/git-commit.el
+++ b/elpa/magit-20251103.1130/git-commit.el
@@ -235,7 +235,7 @@ Also see `magit-post-commit-hook'."
   :type 'hook
   :get #'magit-hook-custom-get)
 
-(defcustom git-commit-post-finish-hook-timeout 1
+(defcustom git-commit-post-finish-hook-timeout 2
   "Time in seconds to wait for git to create a commit.
 
 The hook `git-commit-post-finish-hook' (which see) is run only
@@ -502,7 +502,7 @@ the redundant bindings, then set this to nil, before loading
                   (not (file-accessible-directory-p
                         (file-name-directory buffer-file-name)))
                   (magit-expand-git-file-name (substring buffer-file-name 2))))
-       ((file-accessible-directory-p (file-name-directory file)))
+       (_(file-accessible-directory-p (file-name-directory file)))
        (inhibit-read-only t))
     (insert-file-contents file t)
     t))
@@ -619,17 +619,14 @@ Used as the local value of `header-line-format', in buffer using
 
 (defun git-commit-run-post-finish-hook (previous)
   (when git-commit-post-finish-hook
-    (cl-block nil
-      (let ((break (time-add (current-time)
-                             (seconds-to-time
-                              git-commit-post-finish-hook-timeout))))
-        (while (equal (magit-rev-parse "HEAD") previous)
-          (if (time-less-p (current-time) break)
-              (sit-for 0.01)
-            (message "No commit created after 1 second.  Not running %s."
-                     'git-commit-post-finish-hook)
-            (cl-return))))
-      (run-hooks 'git-commit-post-finish-hook))))
+    (if (with-timeout (git-commit-post-finish-hook-timeout)
+          (while (equal (magit-rev-parse "HEAD") previous)
+            (sit-for 0.01))
+          t)
+        (run-hooks 'git-commit-post-finish-hook)
+      (message "No commit created after %s second.  Not running %s."
+               git-commit-post-finish-hook-timeout
+               'git-commit-post-finish-hook))))
 
 (define-minor-mode git-commit-mode
   "Auxiliary minor mode used when editing Git commit messages.
@@ -721,15 +718,15 @@ conventions are checked."
       (save-excursion
         (goto-char (point-min))
         (re-search-forward (git-commit-summary-regexp) nil t)
-        (if (equal (match-string 1) "")
+        (if (equal (match-str 1) "")
             t ; Just try; we don't know whether --allow-empty-message was used.
           (and (or (not (memq 'overlong-summary-line
                               git-commit-style-convention-checks))
-                   (equal (match-string 2) "")
+                   (equal (match-str 2) "")
                    (y-or-n-p "Summary line is too long.  Commit anyway? "))
                (or (not (memq 'non-empty-second-line
                               git-commit-style-convention-checks))
-                   (not (match-string 3))
+                   (not (match-str 3))
                    (y-or-n-p "Second line is not empty.  Commit anyway? ")))))))
 
 (defun git-commit-cancel-message ()
@@ -751,7 +748,7 @@ With a numeric prefix ARG, go back ARG messages."
       ;; non-empty and newly written comment, because otherwise
       ;; it would be irreversibly lost.
       (when-let* ((message (git-commit-buffer-message))
-                  ((not (ring-member log-edit-comment-ring message))))
+                  (_(not (ring-member log-edit-comment-ring message))))
         (ring-insert log-edit-comment-ring message)
         (cl-incf arg)
         (setq len (ring-length log-edit-comment-ring)))
@@ -799,16 +796,16 @@ Save current message first."
 (defun git-commit-save-message ()
   "Save current message to `log-edit-comment-ring'."
   (interactive)
-  (if-let ((message (git-commit-buffer-message)))
-      (progn
-        (when-let ((index (ring-member log-edit-comment-ring message)))
-          (ring-remove log-edit-comment-ring index))
-        (ring-insert log-edit-comment-ring message)
-        (when git-commit-use-local-message-ring
-          (magit-repository-local-set 'log-edit-comment-ring
-                                      log-edit-comment-ring))
-        (message "Message saved"))
-    (message "Only whitespace and/or comments; message not saved")))
+  (cond-let
+    ([message (git-commit-buffer-message)]
+     (when-let ((index (ring-member log-edit-comment-ring message)))
+       (ring-remove log-edit-comment-ring index))
+     (ring-insert log-edit-comment-ring message)
+     (when git-commit-use-local-message-ring
+       (magit-repository-local-set 'log-edit-comment-ring
+                                   log-edit-comment-ring))
+     (message "Message saved"))
+    ((message "Only whitespace and/or comments; message not saved"))))
 
 (defun git-commit-prepare-message-ring ()
   (make-local-variable 'log-edit-comment-ring-index)
@@ -950,11 +947,11 @@ completion candidates.  The input must have the form \"NAME <EMAIL>\"."
               (sort (delete-dups
                      (magit-git-lines "log" "-n9999" "--format=%aN <%ae>"))
                     #'string<)
-              nil nil nil 'git-commit-read-ident-history)))
+              nil 'any nil 'git-commit-read-ident-history)))
     (save-match-data
       (if (string-match "\\`\\([^<]+\\) *<\\([^>]+\\)>\\'" str)
-          (list (save-match-data (string-trim (match-string 1 str)))
-                (string-trim (match-string 2 str)))
+          (list (save-match-data (string-trim (match-str 1 str)))
+                (string-trim (match-str 2 str)))
         (user-error "Invalid input")))))
 
 (defun git-commit--insert-ident-trailer (trailer name email)
@@ -1221,4 +1218,15 @@ Elisp doc-strings, including this one.  Unlike in doc-strings,
  "git-commit 4.0.0")
 
 (provide 'git-commit)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; git-commit.el ends here
diff --git a/elpa/magit-20250519.1537/git-rebase.el b/elpa/magit-20251103.1130/git-rebase.el
similarity index 80%
rename from elpa/magit-20250519.1537/git-rebase.el
rename to elpa/magit-20251103.1130/git-rebase.el
index 65441f89..614887f0 100644
--- a/elpa/magit-20250519.1537/git-rebase.el
+++ b/elpa/magit-20251103.1130/git-rebase.el
@@ -44,8 +44,8 @@
 ;;   M-p      Move the commit at point up.
 ;;   M-n      Move the commit at point down.
 ;;
-;;   k        Drop the commit at point.
-;;   c        Don't drop the commit at point.
+;;   d        Drop the commit at point.
+;;   c        Keep the commit at point.
 ;;   r        Change the message of the commit at point.
 ;;   e        Edit the commit at point.
 ;;   s        Squash the commit at point, into the one above.
@@ -53,6 +53,7 @@
 ;;   b        Break for editing at this point in the sequence.
 ;;   x        Add a script to be run with the commit at point
 ;;            being checked out.
+;;   k        Un-/comment current line.
 ;;   z        Add noop action at point.
 ;;
 ;;   SPC      Show the commit at point in another buffer.
@@ -152,6 +153,7 @@
   "M-p" #'git-rebase-move-line-up
   "M-n" #'git-rebase-move-line-down
   "c"   #'git-rebase-pick
+  "d"   #'git-rebase-drop
   "k"   #'git-rebase-kill-line
   "C-k" #'git-rebase-kill-line
   "b"   #'git-rebase-break
@@ -160,11 +162,14 @@
   "M M" #'git-rebase-merge
   "M t" #'git-rebase-merge-toggle-editmsg
   "m"   #'git-rebase-edit
+  "s"   #'git-rebase-squash
+  "S"   #'git-rebase-squish
   "f"   #'git-rebase-fixup
+  "F"   #'git-rebase-alter
+  "A"   #'git-rebase-alter
   "q"   #'undefined
   "r"   #'git-rebase-reword
   "w"   #'git-rebase-reword
-  "s"   #'git-rebase-squash
   "t"   #'git-rebase-reset
   "u"   #'git-rebase-update-ref
   "x"   #'git-rebase-exec
@@ -176,6 +181,7 @@
   "M-<up>"         #'git-rebase-move-line-up
   "M-<down>"       #'git-rebase-move-line-down
   "<remap> <undo>" #'git-rebase-undo)
+(put 'git-rebase-alter        :advertised-binding (kbd "F"))
 (put 'git-rebase-reword       :advertised-binding (kbd "r"))
 (put 'git-rebase-move-line-up :advertised-binding (kbd "M-p"))
 (put 'git-rebase-kill-line    :advertised-binding (kbd "k"))
@@ -184,6 +190,7 @@
   "Git-Rebase mode menu."
   '("Rebase"
     ["Pick" git-rebase-pick t]
+    ["Drop" git-rebase-drop t]
     ["Reword" git-rebase-reword t]
     ["Edit" git-rebase-edit t]
     ["Squash" git-rebase-squash t]
@@ -208,10 +215,22 @@
     (git-rebase-show-commit
      . "show the commit at point in another buffer and select its window")
     (undo                         . "undo last change")
-    (git-rebase-kill-line         . "drop the commit at point")
+    (git-rebase-drop              . "drop the commit at point")
+    (git-rebase-kill-line         . "un-/comment current line")
     (git-rebase-insert            . "insert a line for an arbitrary commit")
     (git-rebase-noop              . "add noop action at point")))
 
+(defvar git-rebase-fixup-descriptions
+  '((git-rebase-squish
+     . "fixup -c <commit> = use commit, but meld into previous commit,\n#\
+          dropping previous commit's message, and open the editor")
+    (git-rebase-fixup
+     . "fixup <commit> = use commit, but meld into previous commit,\n#\
+          dropping <commit>'s message")
+    (git-rebase-alter
+     . "fixup -C <commit> = use commit, but meld into previous commit,\n#\
+          dropping previous commit's message")))
+
 ;;; Commands
 
 (defun git-rebase-pick ()
@@ -220,6 +239,12 @@ If the region is active, act on all lines touched by the region."
   (interactive)
   (git-rebase-set-action "pick"))
 
+(defun git-rebase-drop ()
+  "Drop commit on current line.
+If the region is active, act on all lines touched by the region."
+  (interactive)
+  (git-rebase-set-action "drop"))
+
 (defun git-rebase-reword ()
   "Edit message of commit on current line.
 If the region is active, act on all lines touched by the region."
@@ -233,21 +258,38 @@ If the region is active, act on all lines touched by the region."
   (git-rebase-set-action "edit"))
 
 (defun git-rebase-squash ()
-  "Meld commit on current line into previous commit, edit message.
+  "Fold commit on current line into previous commit, edit combined message.
 If the region is active, act on all lines touched by the region."
   (interactive)
   (git-rebase-set-action "squash"))
 
+(defun git-rebase-squish ()
+  "Fold current into previous commit, discard previous message and edit current.
+This is like `git-rebase-squash', except that the other message is kept.
+The action indicatore shown in the list commits is \"fixup -c\".  If the
+region is active, act on all lines touched by the region."
+  (interactive)
+  (git-rebase-set-action "fixup -c"))
+
 (defun git-rebase-fixup ()
-  "Meld commit on current line into previous commit, discard its message.
+  "Fold commit on current line into previous commit, discard current message.
 If the region is active, act on all lines touched by the region."
   (interactive)
   (git-rebase-set-action "fixup"))
 
+(defun git-rebase-alter ()
+  "Meld current into previous commit, discard previous message and use current.
+This is like `git-rebase-fixup', except that the other message is kept.
+The action indicatore shown in the list commits is \"fixup -C\".  If the
+region is active, act on all lines touched by the region."
+  (interactive)
+  (git-rebase-set-action "fixup -C"))
+
 (defvar-local git-rebase-comment-re nil)
 
 (defvar git-rebase-short-options
   '((?b . "break")
+    (?d . "drop")
     (?e . "edit")
     (?f . "fixup")
     (?l . "label")
@@ -279,14 +321,22 @@ If the region is active, act on all lines touched by the region."
    (abbrev)))
 
 (defvar git-rebase-line-regexps
+  ;; 1: action, 2: option, 3: target, 4: "#", 5: description.
+  ;;
+  ;; <action> <commit> [[# ] <oneline>]
+  ;; fixup [-C|-c] <commit> [[# ] <oneline>]
   `((commit . ,(concat
-                (regexp-opt '("e" "edit"
-                              "f" "fixup"
-                              "p" "pick"
-                              "r" "reword"
-                              "s" "squash")
+                (regexp-opt '("d"    "drop"
+                              "e"    "edit"
+                              "f"    "fixup"
+                              "f -C" "fixup -C"
+                              "f -c" "fixup -c"
+                              "p"    "pick"
+                              "r"    "reword"
+                              "s"    "squash")
                             "\\(?1:")
-                " \\(?3:[^ \n]+\\) ?\\(?4:.*\\)"))
+                " \\(?3:[^ \n]+\\)"
+                "\\(?: \\(?4:# \\)?\\(?5:.*\\)\\)?"))
     (exec . "\\(?1:x\\|exec\\) \\(?3:.*\\)")
     (bare . ,(concat (regexp-opt '("b" "break" "noop") "\\(?1:")
                      " *$"))
@@ -294,37 +344,44 @@ If the region is active, act on all lines touched by the region."
                                     "t" "reset"
                                     "u" "update-ref")
                                   "\\(?1:")
-                      " \\(?3:[^ \n]+\\) ?\\(?4:.*\\)"))
+                      " \\(?3:[^ \n]+\\)"
+                      "\\(?: \\(?4:# \\)?\\(?5:.*\\)\\)?"))
+    ;; merge [-C <commit> | -c <commit>] <label> [# <oneline>]
+    ;; <commit> is matched by group 22 (part of group 2), not group 3
     (merge . ,(concat "\\(?1:m\\|merge\\) "
-                      "\\(?:\\(?2:-[cC] [^ \n]+\\) \\)?"
+                      "\\(?:\\(?2:\\(?21:-[cC]\\) \\(?22:[^ \n]+\\)\\) \\)?"
                       "\\(?3:[^ \n]+\\)"
-                      " ?\\(?4:.*\\)"))))
+                      "\\(?: \\(?4:# \\)?\\(?5:.*\\)\\)?"))))
 
 ;;;###autoload
-(defun git-rebase-current-line ()
+(defun git-rebase-current-line (&optional batch)
   "Parse current line into a `git-rebase-action' instance.
 If the current line isn't recognized as a rebase line, an
-instance with all nil values is returned."
+instance with all nil values is returned, unless optional
+BATCH is non-nil, in which case nil is returned.  Non-nil
+BATCH also ignores commented lines."
   (save-excursion
     (goto-char (line-beginning-position))
-    (if-let ((re-start (concat "^\\(?5:" (regexp-quote comment-start)
-                               "\\)? *"))
-             (type (seq-some (lambda (arg)
-                               (let ((case-fold-search nil))
-                                 (and (looking-at (concat re-start (cdr arg)))
-                                      (car arg))))
-                             git-rebase-line-regexps)))
-        (git-rebase-action
+    (cond-let*
+      ([re-start (if batch
+                     "^"
+                   (format "^\\(?99:%s\\)? *" (regexp-quote comment-start)))]
+       [type (seq-some (pcase-lambda (`(,type . ,re))
+                         (let ((case-fold-search nil))
+                           (and (looking-at (concat re-start re)) type)))
+                       git-rebase-line-regexps)]
+       (git-rebase-action
          :action-type    type
-         :action         (and-let* ((action (match-string-no-properties 1)))
+         :action         (and-let ((action (match-str 1)))
                            (or (cdr (assoc action git-rebase-short-options))
                                action))
-         :action-options (match-string-no-properties 2)
-         :target         (match-string-no-properties 3)
-         :trailer        (match-string-no-properties 4)
-         :comment-p      (and (match-string 5) t))
-      ;; Use default empty class rather than nil to ease handling.
-      (git-rebase-action))))
+         :action-options (match-str 2)
+         :target         (match-str 3)
+         :trailer        (match-str 5)
+         :comment-p      (and (match-str 99) t)))
+      ((not batch)
+       ;; Use empty object rather than nil to ease handling.
+       (git-rebase-action)))))
 
 (defun git-rebase-set-action (action)
   "Set action of commit line to ACTION.
@@ -345,22 +402,23 @@ of its action type."
             ((and action (eq action-type 'commit))
              (let ((inhibit-read-only t))
                (magit-delete-line)
-               (insert (concat action " " target " " trailer "\n"))))
+               (insert (concat action " " target " "))
+               (when (magit-git-version>= "2.50.0")
+                 (insert "# "))
+               (insert (concat trailer "\n"))))
             ((and (not action) action-type)
              (let ((inhibit-read-only t))
                (if comment-p
                    (delete-region beg (+ beg 2))
                  (insert comment-start " ")))
              (forward-line))
-            (t
-             ;; In the case of --rebase-merges, commit lines may have
-             ;; other lines with other action types, empty lines, and
-             ;; "Branch" comments interspersed.  Move along.
-             (forward-line)))))
-       (goto-char
-        (if git-rebase-auto-advance
-            end-marker
-          (if pt-below-p (1- end-marker) beg)))
+            ;; In the case of --rebase-merges, commit lines may have
+            ;; other lines with other action types, empty lines, and
+            ;; "Branch" comments interspersed.  Move along.
+            ((forward-line)))))
+       (goto-char (cond (git-rebase-auto-advance end-marker)
+                        (pt-below-p (1- end-marker))
+                        (beg)))
        (goto-char (line-beginning-position))))
     (_ (ding))))
 
@@ -531,7 +589,7 @@ remove the label on the current line, if any."
     (save-excursion
       (goto-char (point-min))
       (while (re-search-forward "^\\(?:l\\|label\\) \\([^ \n]+\\)" nil t)
-        (push (match-string-no-properties 1) labels)))
+        (push (match-str 1) labels)))
     (nreverse labels)))
 
 (defun git-rebase-reset (arg)
@@ -755,7 +813,8 @@ running \"man git-rebase\" at the command line) for details."
   `((,(concat "^" (cdr (assq 'commit git-rebase-line-regexps)))
      (1 'git-rebase-action)
      (3 'git-rebase-hash)
-     (4 'git-rebase-description))
+     (4 'font-lock-comment-face nil t)
+     (5 'git-rebase-description nil t))
     (,(concat "^" (cdr (assq 'exec git-rebase-line-regexps)))
      (1 'git-rebase-action)
      (3 'git-rebase-description))
@@ -764,30 +823,33 @@ running \"man git-rebase\" at the command line) for details."
     (,(concat "^" (cdr (assq 'label git-rebase-line-regexps)))
      (1 'git-rebase-action)
      (3 'git-rebase-label)
-     (4 'font-lock-comment-face))
-    ("^\\(m\\(?:erge\\)?\\) -[Cc] \\([^ \n]+\\) \\([^ \n]+\\)\\( #.*\\)?"
-     (1 'git-rebase-action)
-     (2 'git-rebase-hash)
-     (3 'git-rebase-label)
-     (4 'font-lock-comment-face))
-    ("^\\(m\\(?:erge\\)?\\) \\([^ \n]+\\)"
-     (1 'git-rebase-action)
-     (2 'git-rebase-label))
+     (4 'font-lock-comment-face nil t)
+     (5 'git-rebase-description nil t))
+    (,(concat "^" (cdr (assq 'merge git-rebase-line-regexps)))
+     (1  'git-rebase-action)
+     (21 'git-rebase-action nil t)
+     (22 'git-rebase-hash t t)
+     (3  'magit-branch-local)
+     (4  'font-lock-comment-face nil t)
+     (5  'git-rebase-description nil t))
+    (,(format "^%s Branch \\(.*\\)" comment-start)
+     (1 'magit-branch-local t))
+    ("^drop \\(.+\\)"
+     (1 'git-rebase-killed-action t))
     (,(concat git-rebase-comment-re " *"
               (cdr (assq 'commit git-rebase-line-regexps)))
-     0 'git-rebase-killed-action t)
-    (git-rebase-match-comment-line 0 'font-lock-comment-face)
+     (0 'git-rebase-killed-action t))
+    (git-rebase-match-comment-line
+     (0 'font-lock-comment-face))
     ("\\[[^[]*\\]"
-     0 'magit-keyword t)
+     (0 'magit-keyword t))
     ("\\(?:fixup!\\|squash!\\|amend!\\)"
-     0 'magit-keyword-squash t)
+     (0 'magit-keyword-squash t))
     (,(format "^%s Rebase \\([^ ]*\\) onto \\([^ ]*\\)" comment-start)
      (1 'git-rebase-comment-hash t)
      (2 'git-rebase-comment-hash t))
     (,(format "^%s \\(Commands:\\)" comment-start)
-     (1 'git-rebase-comment-heading t))
-    (,(format "^%s Branch \\(.*\\)" comment-start)
-     (1 'git-rebase-label t))))
+     (1 'git-rebase-comment-heading t))))
 
 (defun git-rebase-mode-show-keybindings ()
   "Modify the \"Commands:\" section of the comment Git generates.
@@ -802,24 +864,23 @@ except for the \"pick\" command."
                   (concat git-rebase-comment-re "\\s-+p, pick")
                   nil t))
         (goto-char (line-beginning-position))
-        (pcase-dolist (`(,cmd . ,desc) git-rebase-command-descriptions)
-          (insert (format (propertize "%s %s %s\n"
-                                      'font-lock-face 'font-lock-comment-face)
-                          comment-start
-                          (string-pad
-                           (substitute-command-keys (format "\\[%s]" cmd)) 8)
-                          desc)))
-        (while (re-search-forward
-                (concat git-rebase-comment-re "\\(?:"
-                        "\\( \\.?     *\\)\\|"
-                        "\\( +\\)\\([^\n,],\\) \\([^\n ]+\\) \\)")
-                nil t)
-          (if (match-string 1)
-              (replace-match (make-string 10 ?\s) t t nil 1)
-            (let ((cmd (intern (concat "git-rebase-" (match-string 4)))))
-              (if (not (fboundp cmd))
-                  (delete-region (line-beginning-position)
-                                 (1+ (line-end-position)))
+        (git-rebase--insert-descriptions git-rebase-command-descriptions)
+        (let ((cmd nil)
+              (line (concat git-rebase-comment-re "\\(?:\\( \\.?     *\\)\\|"
+                            "\\( +\\)\\([^\n,],\\) \\([^\n ]+\\) \\)")))
+          (while (re-search-forward line nil t)
+            (if (match-str 1)
+                (if (assq cmd git-rebase-fixup-descriptions)
+                    (delete-line)
+                  (replace-match (make-string 10 ?\s) t t nil 1))
+              (setq cmd (intern (concat "git-rebase-" (match-str 4))))
+              (cond
+               ((not (fboundp cmd))
+                (delete-line))
+               ((eq cmd 'git-rebase-fixup)
+                (delete-line)
+                (git-rebase--insert-descriptions git-rebase-fixup-descriptions))
+               (t
                 (add-text-properties (line-beginning-position)
                                      (1+ (line-end-position))
                                      '(font-lock-face font-lock-comment-face))
@@ -829,7 +890,16 @@ except for the \"pick\" command."
                   (save-match-data
                     (substitute-command-keys (format "\\[%s]" cmd)))
                   8)
-                 t t nil 3)))))))))
+                 t t nil 3))))))))))
+
+(defun git-rebase--insert-descriptions (alist)
+  (pcase-dolist (`(,cmd . ,desc) alist)
+    (insert (format (propertize "%s %s %s\n"
+                                'font-lock-face 'font-lock-comment-face)
+                    comment-start
+                    (string-pad
+                     (substitute-command-keys (format "\\[%s]" cmd)) 8)
+                    (replace-regexp-in-string "#" comment-start desc)))))
 
 (add-hook 'git-rebase-mode-hook #'git-rebase-mode-show-keybindings t)
 
@@ -872,4 +942,15 @@ is used as a value for `imenu-extract-index-name-function'."
 
 ;;; _
 (provide 'git-rebase)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; git-rebase.el ends here
diff --git a/elpa/magit-20250519.1537/magit-apply.el b/elpa/magit-20251103.1130/magit-apply.el
similarity index 93%
rename from elpa/magit-20250519.1537/magit-apply.el
rename to elpa/magit-20251103.1130/magit-apply.el
index 3f6f5bd0..e5b69d59 100644
--- a/elpa/magit-20250519.1537/magit-apply.el
+++ b/elpa/magit-20251103.1130/magit-apply.el
@@ -33,6 +33,7 @@
 (require 'magit-diff)
 (require 'magit-wip)
 
+(require 'dired)
 (require 'transient) ; See #3732.
 
 ;; For `magit-apply'
@@ -161,15 +162,15 @@ and only the second and third are to be applied, they would be
 adjusted as \"@@ -10,6 +10,7 @@\" and \"@@ -18,6 +19,7 @@\"."
   (let* ((first-hunk (car hunks))
          (offset (if (string-match diff-hunk-header-re-unified first-hunk)
-                     (- (string-to-number (match-string 3 first-hunk))
-                        (string-to-number (match-string 1 first-hunk)))
+                     (- (string-to-number (match-str 3 first-hunk))
+                        (string-to-number (match-str 1 first-hunk)))
                    (error "Header hunks have to be applied individually"))))
     (if (= offset 0)
         hunks
       (mapcar (lambda (hunk)
                 (if (string-match diff-hunk-header-re-unified hunk)
                     (replace-match (number-to-string
-                                    (- (string-to-number (match-string 3 hunk))
+                                    (- (string-to-number (match-str 3 hunk))
                                        offset))
                                    t t hunk 3)
                   (error "Hunk does not have expected header")))
@@ -218,8 +219,9 @@ adjusted as \"@@ -10,6 +10,7 @@\" and \"@@ -18,6 +19,7 @@\"."
                   (mapcar (##oref % value) section:s)))
          (command (symbol-name this-command))
          (command (if (and command (string-match "^magit-\\([^-]+\\)" command))
-                      (match-string 1 command)
+                      (match-str 1 command)
                     "apply"))
+         (context (magit-diff-get-context))
          (ignore-context (magit-diff-ignore-any-space-p)))
     (unless (magit-diff-context-p)
       (user-error "Not enough context to apply patch.  Increase the context"))
@@ -230,7 +232,7 @@ adjusted as \"@@ -10,6 +10,7 @@\" and \"@@ -18,6 +19,7 @@\"."
       (let ((magit-inhibit-refresh t))
         (magit-run-git-with-input
          "apply" args "-p0"
-         (and ignore-context "-C0")
+         (if ignore-context "-C0" (format "-C%s" context))
          "--ignore-space-change" "-")))
     (unless magit-inhibit-refresh
       (when magit-wip-after-apply-mode
@@ -448,8 +450,8 @@ ignored) files."
   (magit-wip-commit-after-apply files " after unstage"))
 
 (defun magit-unstage-intent (files)
-  (if-let ((staged (magit-staged-files))
-           (intent (seq-filter (##member % staged) files)))
+  (if-let* ((staged (magit-staged-files))
+            (intent (seq-filter (##member % staged) files)))
       (magit-unstage-1 intent)
     (user-error "Already unstaged")))
 
@@ -489,10 +491,7 @@ of a side, then keep that side without prompting."
     (pcase (list (magit-diff-type) (magit-diff-scope))
       (`(committed   ,_) (user-error "Cannot discard committed changes"))
       (`(undefined   ,_) (user-error "Cannot discard this change"))
-      (`(untracked list) (magit-discard-files--delete
-                          (magit-with-toplevel
-                            (magit-untracked-files nil nil "--directory"))
-                          nil))
+      (`(untracked list) (magit-discard-untracked))
       (`(,_      region) (magit-discard-region s))
       (`(,_        hunk) (magit-discard-hunk   s))
       (`(,_       hunks) (magit-discard-hunks  s))
@@ -500,6 +499,12 @@ of a side, then keep that side without prompting."
       (`(,_       files) (magit-discard-files  s))
       (`(,_        list) (magit-discard-files  s)))))
 
+(defun magit-discard-untracked ()
+  (magit-discard-files--delete
+   (magit-with-toplevel (magit-list-untracked-files))
+   nil)
+  (magit-refresh))
+
 (defun magit-discard-region (section)
   (magit-confirm 'discard "Discard region")
   (magit-discard-apply section 'magit-apply-region))
@@ -511,39 +516,26 @@ of a side, then keep that side without prompting."
       ('(?U ?U) (magit-smerge-keep-current))
       (_ (magit-discard-apply section #'magit-apply-hunk)))))
 
-(defun magit-discard-apply (section apply)
-  (if (eq (magit-diff-type section) 'unstaged)
-      (funcall apply section "--reverse")
-    (if (magit-anything-unstaged-p
-         nil (if (magit-file-section-p section)
-                 (oref section value)
-               (magit-section-parent-value section)))
-        (progn (let ((magit-inhibit-refresh t))
-                 (funcall apply section "--reverse" "--cached")
-                 (funcall apply section "--reverse" "--reject"))
-               (magit-refresh))
-      (funcall apply section "--reverse" "--index"))))
-
 (defun magit-discard-hunks (sections)
   (magit-confirm 'discard
     (list "Discard %d hunks from %s"
           (length sections)
           (magit-section-parent-value (car sections))))
-  (magit-discard-apply-n sections #'magit-apply-hunks))
-
-(defun magit-discard-apply-n (sections apply)
-  (let ((section (car sections)))
-    (if (eq (magit-diff-type section) 'unstaged)
-        (funcall apply sections "--reverse")
-      (if (magit-anything-unstaged-p
-           nil (if (magit-file-section-p section)
-                   (oref section value)
-                 (magit-section-parent-value section)))
-          (progn (let ((magit-inhibit-refresh t))
-                   (funcall apply sections "--reverse" "--cached")
-                   (funcall apply sections "--reverse" "--reject"))
-                 (magit-refresh))
-        (funcall apply sections "--reverse" "--index")))))
+  (magit-discard-apply sections #'magit-apply-hunks))
+
+(defun magit-discard-apply (section:s apply)
+  (let ((primus (if (atom section:s) section:s (car section:s))))
+    (cond ((eq (magit-diff-type primus) 'unstaged)
+           (funcall apply section:s "--reverse"))
+          ((magit-anything-unstaged-p
+            nil (if (magit-file-section-p primus)
+                    (oref primus value)
+                  (magit-section-parent-value primus)))
+           (let ((magit-inhibit-refresh t))
+             (funcall apply section:s "--reverse" "--cached")
+             (funcall apply section:s "--reverse" "--reject"))
+           (magit-refresh))
+          ((funcall apply section:s "--reverse" "--index")))))
 
 (defun magit-discard-file (section)
   (magit-discard-files (list section)))
@@ -633,7 +625,7 @@ of a side, then keep that side without prompting."
         (?M  (let ((temp (magit-git-string "checkout-index" "--temp" file)))
                (string-match
                 (format "\\(.+?\\)\t%s" (regexp-quote file)) temp)
-               (rename-file (match-string 1 temp)
+               (rename-file (match-str 1 temp)
                             (setq temp (concat file ".~{index}~")))
                (delete-file temp t))
              (magit-call-git "rm" "--cached" "--force" "--" file))
@@ -671,10 +663,8 @@ of a side, then keep that side without prompting."
           (setq sections
                 (seq-remove (##member (oref % value) binaries)
                             sections)))
-        (cond ((length= sections 1)
-               (magit-discard-apply (car sections) 'magit-apply-diff))
-              (sections
-               (magit-discard-apply-n sections #'magit-apply-diffs)))
+        (when sections
+          (magit-discard-apply sections #'magit-apply-diffs))
         (when binaries
           (let ((modified (magit-unstaged-files t)))
             (setq binaries (magit--separate (##member % modified) binaries)))
@@ -729,8 +719,7 @@ so causes the change to be applied to the index as well."
                                  magit-buffer-range)
                                 ((derived-mode-p 'magit-diff-mode)
                                  magit-buffer-range)
-                                (t
-                                 "--cached")))))
+                                ("--cached")))))
                  (magit--separate (##member (oref % value) bs)
                                   sections))))
     (magit-confirm-files 'reverse (mapcar (##oref % value) sections))
@@ -796,9 +785,8 @@ a separate commit.  A typical workflow would be:
 (defun magit-call-smerge (fn)
   (pcase-let* ((file (magit-file-at-point t t))
                (keep (get-file-buffer file))
-               (`(,buf ,pos)
-                (let ((magit-diff-visit-jump-to-change nil))
-                  (magit-diff-visit-file--noselect file))))
+               (`(,buf ,pos) (magit-diff-visit-file--noselect))
+               (keep (eq keep buf)))
     (with-current-buffer buf
       (save-excursion
         (save-restriction
@@ -827,4 +815,15 @@ a separate commit.  A typical workflow would be:
 
 ;;; _
 (provide 'magit-apply)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-apply.el ends here
diff --git a/elpa/magit-20250519.1537/magit-autoloads.el b/elpa/magit-20251103.1130/magit-autoloads.el
similarity index 97%
rename from elpa/magit-20250519.1537/magit-autoloads.el
rename to elpa/magit-20251103.1130/magit-autoloads.el
index b070d97e..9d414e5f 100644
--- a/elpa/magit-20250519.1537/magit-autoloads.el
+++ b/elpa/magit-20251103.1130/magit-autoloads.el
@@ -27,7 +27,11 @@
 (autoload 'git-rebase-current-line "git-rebase" "\
 Parse current line into a `git-rebase-action' instance.
 If the current line isn't recognized as a rebase line, an
-instance with all nil values is returned.")
+instance with all nil values is returned, unless optional
+BATCH is non-nil, in which case nil is returned.  Non-nil
+BATCH also ignores commented lines.
+
+(fn &optional BATCH)")
 (autoload 'git-rebase-mode "git-rebase" "\
 Major mode for editing of a Git rebase file.
 
@@ -181,7 +185,10 @@ either customize it (see the info node `Easy Customization')
 or call the function `magit-auto-revert-mode'.")
 (custom-autoload 'magit-auto-revert-mode "magit-autorevert" nil)
 (autoload 'magit-auto-revert-mode "magit-autorevert" "\
-Toggle Auto-Revert mode in all buffers.
+Toggle Auto-Revert mode in many buffers.
+Specifically, Auto-Revert mode is enabled in all buffers where
+`magit-turn-on-auto-revert-mode-if-desired' would do it.
+
 With prefix ARG, enable Magit-Auto-Revert mode if ARG is positive;
 otherwise, disable it.
 
@@ -189,9 +196,6 @@ If called from Lisp, toggle the mode if ARG is `toggle'.
 Enable the mode if ARG is nil, omitted, or is a positive number.
 Disable the mode if ARG is a negative number.
 
-Auto-Revert mode is enabled in all buffers where
-`magit-turn-on-auto-revert-mode-if-desired' would do it.
-
 See `auto-revert-mode' for more information on Auto-Revert mode.
 
 (fn &optional ARG)" t)
@@ -206,7 +210,7 @@ See info node `(magit)Debugging Tools' for more information." t)
 (define-advice Info-follow-nearest-node (:around (fn &optional fork) gitman) (let ((node (Info-get-token (point) "\\*note[ 
 	]+" "\\*note[ 
 	]+\\([^:]*\\):\\(:\\|[ 
-	]*(\\)?"))) (if (and node (string-match "^(gitman)\\(.+\\)" node)) (pcase magit-view-git-manual-method ('info (funcall fn fork)) ('man (require 'man) (man (match-string 1 node))) ('woman (require 'woman) (woman (match-string 1 node))) (_ (user-error "Invalid value for `magit-view-git-manual-method'"))) (funcall fn fork))))
+	]*(\\)?"))) (if (and node (string-match "^(gitman)\\(.+\\)" node)) (pcase magit-view-git-manual-method ('info (funcall fn fork)) ('man (require 'man) (man (match-string-no-properties 1 node))) ('woman (require 'woman) (woman (match-string-no-properties 1 node))) (_ (user-error "Invalid value for `magit-view-git-manual-method'"))) (funcall fn fork))))
 (define-advice org-man-export (:around (fn link description format) gitman) (if (and (eq format 'texinfo) (string-prefix-p "git" link)) (string-replace "%s" link "
 @ifinfo
 @ref{%s,,,gitman,}.
@@ -282,15 +286,15 @@ bisect run'.
 
  (autoload 'magit-branch "magit" nil t)
 (autoload 'magit-checkout "magit-branch" "\
-Checkout REVISION, updating the index and the working tree.
-If REVISION is a local branch, then that becomes the current
+Checkout COMMIT, updating the index and the working tree.
+If COMMIT is a local branch, then that becomes the current
 branch.  If it is something else, then `HEAD' becomes detached.
 Checkout fails if the working tree or the staging area contain
 changes.
 
-(git checkout REVISION).
+(git checkout COMMIT).
 
-(fn REVISION &optional ARGS)" t)
+(fn COMMIT &optional ARGS)" t)
 (function-put 'magit-checkout 'interactive-only 'magit--checkout)
 (autoload 'magit-branch-create "magit-branch" "\
 Create BRANCH at branch or revision START-POINT.
@@ -969,11 +973,9 @@ to be visited.
 
 Neither the blob nor the file buffer are killed when finishing
 the rebase.  If that is undesirable, then it might be better to
-use `magit-rebase-edit-commit' instead of this command.
-
-(fn FILE)" t)
+use `magit-rebase-edit-commit' instead of this command." t)
 (autoload 'magit-reshelve-since "magit-extras" "\
-Change the author and committer dates of the commits since REV.
+Change the author and committer dates of the commits since COMMIT.
 
 Ask the user for the first reachable commit whose dates should
 be changed.  Then read the new date for that commit.  The initial
@@ -988,7 +990,7 @@ If KEYID is non-nil, then use that to sign all reshelved commits.
 Interactively use the value of the \"--gpg-sign\" option in the
 list returned by `magit-rebase-arguments'.
 
-(fn REV KEYID)" t)
+(fn COMMIT KEYID)" t)
 (autoload 'magit-pop-revision-stack "magit-extras" "\
 Insert a representation of a revision into the current buffer.
 
@@ -1289,7 +1291,7 @@ restrict the log to the lines that the region touches.
 (autoload 'magit-log-trace-definition "magit-log" "\
 Show log for the definition at point.
 
-(fn FILE FN REV)" t)
+(fn FILE FN COMMIT)" t)
 (autoload 'magit-log-merged "magit-log" "\
 Show log for the merge of COMMIT into BRANCH.
 
@@ -1302,6 +1304,11 @@ This command requires git-when-merged, which is available from
 https://github.com/mhagger/git-when-merged.
 
 (fn COMMIT BRANCH &optional ARGS FILES)" t)
+(autoload 'magit-delete-shelved-branch "magit-log" "\
+Delete the shelved BRANCH.
+Delete a ref created by `magit-branch-shelve'.
+
+(fn BRANCH)" t)
 (autoload 'magit-log-move-to-parent "magit-log" "\
 Move to the Nth parent of the current commit.
 
@@ -1310,7 +1317,7 @@ Move to the Nth parent of the current commit.
 (autoload 'magit-shortlog-since "magit-log" "\
 Show a history summary for commits since REV.
 
-(fn REV ARGS)" t)
+(fn COMMIT ARGS)" t)
 (autoload 'magit-shortlog-range "magit-log" "\
 Show a history summary for commit or range REV-OR-RANGE.
 
@@ -1632,19 +1639,19 @@ Reset the `HEAD' and index to COMMIT, but not the working tree.
 (autoload 'magit-reset-soft "magit-reset" "\
 Reset the `HEAD' to COMMIT, but not the index and working tree.
 
-(git reset --soft REVISION)
+(git reset --soft COMMIT)
 
 (fn COMMIT)" t)
 (autoload 'magit-reset-hard "magit-reset" "\
 Reset the `HEAD', index, and working tree to COMMIT.
 
-(git reset --hard REVISION)
+(git reset --hard COMMIT)
 
 (fn COMMIT)" t)
 (autoload 'magit-reset-keep "magit-reset" "\
 Reset the `HEAD' and index to COMMIT, while keeping uncommitted changes.
 
-(git reset --keep REVISION)
+(git reset --keep COMMIT)
 
 (fn COMMIT)" t)
 (autoload 'magit-reset-index "magit-reset" "\
@@ -2021,7 +2028,9 @@ Instead of invoking this alias for `magit-status' using
 and read the info node `(magit)Getting Started', which
 also contains other useful hints.")
 (autoload 'magit-status-here "magit-status" "\
-Like `magit-status' but with non-nil `magit-status-goto-file-position'." t)
+Like `magit-status' but with non-nil `magit-status-goto-file-position'.
+Before doing so, save all file-visiting buffers belonging to the current
+repository without prompting." t)
 (autoload 'magit-status-quick "magit-status" "\
 Show the status of the current Git repository, maybe without refreshing.
 
@@ -2134,12 +2143,12 @@ Extract the history of the subtree PREFIX.
 
  (autoload 'magit-tag "magit" nil t)
 (autoload 'magit-tag-create "magit-tag" "\
-Create a new tag with the given NAME at REV.
+Create a new tag with the given NAME at COMMIT.
 With a prefix argument annotate the tag.
 
 (git tag [--annotate] NAME REV)
 
-(fn NAME REV &optional ARGS)" t)
+(fn NAME COMMIT &optional ARGS)" t)
 (autoload 'magit-tag-delete "magit-tag" "\
 Delete one or more tags.
 If the region marks multiple tags (and nothing else), then offer
@@ -2225,7 +2234,10 @@ either customize it (see the info node `Easy Customization')
 or call the function `magit-wip-after-save-mode'.")
 (custom-autoload 'magit-wip-after-save-mode "magit-wip" nil)
 (autoload 'magit-wip-after-save-mode "magit-wip" "\
-Toggle Magit-Wip-After-Save-Local mode in all buffers.
+Toggle Magit-Wip-After-Save-Local mode in many buffers.
+Specifically, Magit-Wip-After-Save-Local mode is enabled in all
+buffers where `magit-wip-after-save-local-mode-turn-on' would do it.
+
 With prefix ARG, enable Magit-Wip-After-Save mode if ARG is positive;
 otherwise, disable it.
 
@@ -2233,9 +2245,6 @@ If called from Lisp, toggle the mode if ARG is `toggle'.
 Enable the mode if ARG is nil, omitted, or is a positive number.
 Disable the mode if ARG is a negative number.
 
-Magit-Wip-After-Save-Local mode is enabled in all buffers where
-`magit-wip-after-save-local-mode-turn-on' would do it.
-
 See `magit-wip-after-save-local-mode' for more information on
 Magit-Wip-After-Save-Local mode.
 
@@ -2326,17 +2335,20 @@ a Git repository.")
 
  (autoload 'magit-worktree "magit-worktree" nil t)
 (autoload 'magit-worktree-checkout "magit-worktree" "\
-Checkout BRANCH in a new worktree at PATH.
+Checkout COMMIT in a new worktree in DIRECTORY.
+COMMIT may, but does not have to be, a local branch.
+Interactively, use `magit-read-worktree-directory-function'.
 
-(fn PATH BRANCH)" t)
+(fn DIRECTORY COMMIT)" t)
 (autoload 'magit-worktree-branch "magit-worktree" "\
-Create a new BRANCH and check it out in a new worktree at PATH.
+Create a new BRANCH and check it out in a new worktree at DIRECTORY.
+Interactively, use `magit-read-worktree-directory-function'.
 
-(fn PATH BRANCH START-POINT)" t)
+(fn DIRECTORY BRANCH START-POINT)" t)
 (autoload 'magit-worktree-move "magit-worktree" "\
-Move WORKTREE to PATH.
+Move existing WORKTREE directory to DIRECTORY.
 
-(fn WORKTREE PATH)" t)
+(fn WORKTREE DIRECTORY)" t)
 (register-definition-prefixes "magit-worktree" '("magit-"))
 
 ;;; End of scraped data
diff --git a/elpa/magit-20250519.1537/magit-autorevert.el b/elpa/magit-20251103.1130/magit-autorevert.el
similarity index 92%
rename from elpa/magit-20250519.1537/magit-autorevert.el
rename to elpa/magit-20251103.1130/magit-autorevert.el
index 3579bf2e..564b9c0d 100644
--- a/elpa/magit-20250519.1537/magit-autorevert.el
+++ b/elpa/magit-20251103.1130/magit-autorevert.el
@@ -166,13 +166,16 @@ and code surrounding the definition of this function."
              (format " (%.3fs, %s buffers checked)" elapsed
                      (length (buffer-list)))
            ""))))))
-(if after-init-time
-    ;; Since `after-init-hook' has already been
-    ;; run, turn the mode on or off right now.
-    (magit-auto-revert-mode--init-kludge)
-  ;; By the time the init file has been fully loaded the
-  ;; values of the relevant variables might have changed.
-  (add-hook 'after-init-hook #'magit-auto-revert-mode--init-kludge t))
+;; FIXME Suppressing this for recent 31.0.50 builds is not the
+;; final solution.
+(unless (fboundp 'custom-initialize-after-file-load)
+  (if after-init-time
+      ;; Since `after-init-hook' has already been
+      ;; run, turn the mode on or off right now.
+      (magit-auto-revert-mode--init-kludge)
+    ;; By the time the init file has been fully loaded the
+    ;; values of the relevant variables might have changed.
+    (add-hook 'after-init-hook #'magit-auto-revert-mode--init-kludge t)))
 
 (put 'magit-auto-revert-mode 'function-documentation
      "Toggle Magit Auto Revert mode.
@@ -268,4 +271,15 @@ defaults to nil) for any BUFFER."
 
 ;;; _
 (provide 'magit-autorevert)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-autorevert.el ends here
diff --git a/elpa/magit-20250519.1537/magit-base.el b/elpa/magit-20251103.1130/magit-base.el
similarity index 93%
rename from elpa/magit-20250519.1537/magit-base.el
rename to elpa/magit-20251103.1130/magit-base.el
index 40245465..99566a83 100644
--- a/elpa/magit-20250519.1537/magit-base.el
+++ b/elpa/magit-20251103.1130/magit-base.el
@@ -33,13 +33,14 @@
 ;;; Code:
 
 ;; Also update EMACS_VERSION in "default.mk".
-(defconst magit--minimal-emacs "27.1")
+(defconst magit--minimal-emacs "28.1")
 (defconst magit--minimal-git "2.25.0")
 
 (require 'cl-lib)
 (require 'compat)
+(require 'cond-let)
 (require 'eieio)
-(require 'llama)
+(require 'llama) ; For (##these ...) see M-x describe-function RET # # RET.
 (require 'subr-x)
 
 ;; For older Emacs releases we depend on an updated `seq' release from
@@ -493,6 +494,7 @@ and delay of your graphical environment or operating system."
 (defclass magit-hunk-section (magit-diff-section)
   ((keymap      :initform 'magit-hunk-section-map)
    (painted     :initform nil)
+   (fontified   :initform nil) ;TODO
    (refined     :initform nil)
    (combined    :initform nil :initarg :combined)
    (from-range  :initform nil :initarg :from-range)
@@ -576,6 +578,10 @@ acts similarly to `completing-read', except for the following:
 - If REQUIRE-MATCH is nil and the user exits without a choice,
   then nil is returned instead of an empty string.
 
+- If REQUIRE-MATCH is `any', then do not require a match but
+  do require non-empty input (or non-nil DEFAULT, since that
+  is substituted for empty input).
+
 - If REQUIRE-MATCH is non-nil and the user exits without a
   choice, `user-error' is raised.
 
@@ -591,12 +597,13 @@ acts similarly to `completing-read', except for the following:
   `minibuffer-default-prompt-format' and depending on
   `magit-completing-read-default-prompt-predicate'."
   (setq magit-completing-read--silent-default nil)
-  (if-let ((dwim (and def
-                      (nth 2 (seq-find (pcase-lambda (`(,cmd ,re ,_))
-                                         (and (eq this-command cmd)
-                                              (or (not re)
-                                                  (string-match-p re prompt))))
-                                       magit-dwim-selection)))))
+  (if-let ((_ def)
+           (dwim (seq-some (pcase-lambda (`(,cmd ,re ,dwim))
+                             (and (eq cmd this-command)
+                                  (or (not re)
+                                      (string-match-p re prompt))
+                                  dwim))
+                           magit-dwim-selection)))
       (if (eq dwim 'ask)
           (if (y-or-n-p (format "%s %s? " prompt def))
               def
@@ -613,7 +620,8 @@ acts similarly to `completing-read', except for the following:
           (reply (funcall magit-completing-read-function
                           (magit--format-prompt prompt def)
                           collection predicate
-                          require-match initial-input hist def)))
+                          (if (eq require-match 'any) nil require-match)
+                          initial-input hist def)))
       (setq this-command command)
       ;; Note: Avoid `string=' to support `helm-comp-read-use-marked'.
       (if (equal reply "")
@@ -681,6 +689,14 @@ third-party completion frameworks."
                      (equal omit-nulls t))
             (setq input string))
           (funcall split-string string separators omit-nulls trim)))
+       ;; Add the default to the table if absent, which is necessary
+       ;; because we don't add it to the prompt for some frameworks.
+       (table (if (and def
+                       (listp table)
+                       (not (listp (car table)))
+                       (not (member def table)))
+                  (cons def table)
+                table))
        ;; Prevent `BUILT-IN' completion from messing up our existing
        ;; order of the completion candidates. aa5f098ab
        (table (magit--completion-table table))
@@ -696,8 +712,12 @@ third-party completion frameworks."
        ;; And now, the moment we have all been waiting for...
        (values (completing-read-multiple
                 (magit--format-prompt prompt def)
-                table predicate require-match initial-input
-                hist def inherit-input-method)))
+                table predicate
+                (if (eq require-match 'any) nil require-match)
+                initial-input hist def inherit-input-method)))
+    (when (and (eq require-match 'any)
+               (not values))
+      (user-error "Nothing selected"))
     (if no-split input values)))
 
 (defvar-keymap magit-minibuffer-local-ns-map
@@ -748,7 +768,7 @@ This is similar to `read-string', but
            (user-error "Need non-empty input"))
           ((and no-whitespace (string-match-p "[\s\t\n]" val))
            (user-error "Input contains whitespace"))
-          (t val))))
+          (val))))
 
 (defun magit-read-string-ns ( prompt &optional initial-input history
                               default-value inherit-input-method)
@@ -867,6 +887,7 @@ See info node `(magit)Debugging Tools' for more information."
                          (error "Cannot find mandatory dependency %s" lib)))
                      '(;; Like `LOAD_PATH' in `default.mk'.
                        "compat"
+                       "cond-let"
                        "llama"
                        "seq"
                        "transient"
@@ -887,21 +908,20 @@ See info node `(magit)Debugging Tools' for more information."
 
 (defmacro magit-bind-match-strings (varlist string &rest body)
   "Bind variables to submatches according to VARLIST then evaluate BODY.
-Bind the symbols in VARLIST to submatches of the current match
-data, starting with 1 and incrementing by 1 for each symbol.  If
-the last match was against a string, then that has to be provided
-as STRING."
+Bind the symbols in VARLIST to submatches of the current match data,
+starting with 1 and incrementing by 1 for each symbol.  If the last
+match was against a string, then that has to be provided as STRING."
   (declare (indent 2) (debug (listp form body)))
   (let ((s (gensym "string"))
         (i 0))
-    `(let ((,s ,string))
-       (let ,(save-match-data
-               (mapcan (lambda (sym)
-                         (cl-incf i)
-                         (and (not (eq (aref (symbol-name sym) 0) ?_))
-                              (list (list sym (list 'match-string i s)))))
-                       varlist))
-         ,@body))))
+    `(let* ((,s ,string)
+            ,@(save-match-data
+                (seq-keep (lambda (sym)
+                            (cl-incf i)
+                            (and (not (eq (aref (symbol-name sym) 0) ?_))
+                                 `(,sym (match-str ,i ,s))))
+                          varlist)))
+       ,@body)))
 
 (defun magit-delete-line ()
   "Delete the rest of the current line."
@@ -948,8 +968,8 @@ Pad the left side of STRING so that it aligns with the text area."
         (delete-char 1))
        ;; Valid format spec.
        ((looking-at "\\([-0-9.]*\\)\\([a-zA-Z]\\)")
-        (let* ((num (match-string 1))
-               (spec (string-to-char (match-string 2)))
+        (let* ((num (match-str 1))
+               (spec (string-to-char (match-str 2)))
                (val (assq spec specification)))
           (unless val
             (error "Invalid format character: `%%%c'" spec))
@@ -968,42 +988,11 @@ Pad the left side of STRING so that it aligns with the text area."
             ;; Delete the percent sign.
             (delete-region (1- (match-beginning 0)) (match-beginning 0)))))
        ;; Signal an error on bogus format strings.
-       (t
-        (error "Invalid format string"))))
+       ((error "Invalid format string"))))
     (buffer-string)))
 
 ;;; Missing from Emacs
 
-(defun magit-kill-this-buffer ()
-  "Kill the current buffer."
-  (interactive)
-  (kill-buffer (current-buffer)))
-
-(defun magit--buffer-string (&optional min max trim)
-  "Like `buffer-substring-no-properties' but the arguments are optional.
-
-This combines the benefits of `buffer-string', `buffer-substring'
-and `buffer-substring-no-properties' into one function that is
-not as painful to use as the latter.  I.e., you can write
-  (magit--buffer-string)
-instead of
-  (buffer-substring-no-properties (point-min)
-                                  (point-max))
-
-Optional MIN defaults to the value of `point-min'.
-Optional MAX defaults to the value of `point-max'.
-
-If optional TRIM is non-nil, then all leading and trailing
-whitespace is remove.  If it is the newline character, then
-one trailing newline is added."
-  ;; Lets write that one last time and be done with it:
-  (let ((str (buffer-substring-no-properties (or min (point-min))
-                                             (or max (point-max)))))
-    (if trim
-        (concat (string-trim str)
-                (and (eq trim ?\n) "\n"))
-      str)))
-
 (defun magit--separate (pred list)
   "Separate elements of LIST that do and don't satisfy PRED.
 Return a list of two lists; the first containing the elements that
@@ -1085,6 +1074,8 @@ the value in the symbol's `saved-value' property if any, or
 
 ;;;###autoload
 (define-advice Info-follow-nearest-node (:around (fn &optional fork) gitman)
+  ;; Do not use `if-let*' (aka `cond-let--if-let*') because this is
+  ;; copied to the autoload file, which does not require `cond-let'.
   (let ((node (Info-get-token
                (point) "\\*note[ \n\t]+"
                "\\*note[ \n\t]+\\([^:]*\\):\\(:\\|[ \n\t]*(\\)?")))
@@ -1092,9 +1083,9 @@ the value in the symbol's `saved-value' property if any, or
         (pcase magit-view-git-manual-method
           ('info  (funcall fn fork))
           ('man   (require 'man)
-                  (man (match-string 1 node)))
+                  (man (match-str 1 node)))
           ('woman (require 'woman)
-                  (woman (match-string 1 node)))
+                  (woman (match-str 1 node)))
           (_ (user-error "Invalid value for `magit-view-git-manual-method'")))
       (funcall fn fork))))
 
@@ -1134,7 +1125,7 @@ See <https://github.com/raxod502/straight.el/issues/520>."
        (build (pcase manager
                 ('straight (bound-and-true-p straight-build-dir))
                 ('elpaca (bound-and-true-p elpaca-builds-directory))))
-       ((string-prefix-p build filename))
+       (_(string-prefix-p build filename))
        (repo (pcase manager
                ('straight
                 (and (bound-and-true-p straight-base-dir)
@@ -1172,19 +1163,19 @@ Like `message', except that `message-log-max' is bound to nil."
 
 (defun magit--ellipsis (&optional where)
   "Build an ellipsis always as string, depending on WHERE."
-  (if (stringp magit-ellipsis)
-      magit-ellipsis
-    (if-let ((pair (car (or
-                         (alist-get (or where t) magit-ellipsis)
-                         (alist-get t magit-ellipsis)))))
-        (pcase-let ((`(,fancy . ,universal) pair))
-          (let ((ellipsis (if (and fancy (char-displayable-p fancy))
-                              fancy
-                            universal)))
-            (if (characterp ellipsis)
-                (char-to-string ellipsis)
-              ellipsis)))
-      (user-error "Variable magit-ellipsis is invalid"))))
+  (cond-let
+    ((stringp magit-ellipsis)
+     magit-ellipsis)
+    ([pair (car (or (alist-get (or where t) magit-ellipsis)
+                    (alist-get t magit-ellipsis)))]
+     (pcase-let* ((`(,fancy . ,universal) pair)
+                  (ellipsis (if (and fancy (char-displayable-p fancy))
+                                fancy
+                              universal)))
+       (if (characterp ellipsis)
+           (char-to-string ellipsis)
+         ellipsis)))
+    ((user-error "Variable magit-ellipsis is invalid"))))
 
 (defun magit--ext-regexp-quote (string)
   "Like `reqexp-quote', but for Extended Regular Expressions."
@@ -1198,4 +1189,15 @@ Like `message', except that `message-log-max' is bound to nil."
 
 ;;; _
 (provide 'magit-base)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-base.el ends here
diff --git a/elpa/magit-20250519.1537/magit-bisect.el b/elpa/magit-20251103.1130/magit-bisect.el
similarity index 95%
rename from elpa/magit-20250519.1537/magit-bisect.el
rename to elpa/magit-20251103.1130/magit-bisect.el
index 8c737c13..6496510f 100644
--- a/elpa/magit-20250519.1537/magit-bisect.el
+++ b/elpa/magit-20251103.1130/magit-bisect.el
@@ -258,7 +258,7 @@ bisect run'."
                               (pop lines))
                          (seq-find (##string-match done-re %) lines))))
       (magit-insert-section ((eval (if bad-line 'commit 'bisect-output))
-                             (and bad-line (match-string 1 bad-line)))
+                             (and bad-line (match-str 1 bad-line)))
         (magit-insert-heading
           (propertize (or bad-line (pop lines))
                       'font-lock-face 'magit-section-heading))
@@ -291,7 +291,7 @@ bisect run'."
     (while (progn (setq beg (point-marker))
                   (re-search-forward
                    "^\\(\\(?:git bisect\\|# status:\\) [^\n]+\n\\)" nil t))
-      (if (string-prefix-p "# status:" (match-string 1))
+      (if (string-prefix-p "# status:" (match-str 1))
           (magit-delete-match)
         (magit-bind-match-strings (heading) nil
           (magit-delete-match)
@@ -315,4 +315,15 @@ bisect run'."
 
 ;;; _
 (provide 'magit-bisect)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-bisect.el ends here
diff --git a/elpa/magit-20250519.1537/magit-blame.el b/elpa/magit-20251103.1130/magit-blame.el
similarity index 93%
rename from elpa/magit-20250519.1537/magit-blame.el
rename to elpa/magit-20251103.1130/magit-blame.el
index e87bd4fc..bd0b444f 100644
--- a/elpa/magit-20250519.1537/magit-blame.el
+++ b/elpa/magit-20251103.1130/magit-blame.el
@@ -128,7 +128,8 @@ part of the default value:
    (margin-body-face . (magit-blame-dimmed)))"
   :package-version '(magit . "2.13.0")
   :group 'magit-blame
-  :type 'string)
+  :type '(alist :key-type symbol
+                :value-type (alist :key-type symbol :value-type sexp)))
 
 (defcustom magit-blame-echo-style 'lines
   "The blame visualization style used by `magit-blame-echo'.
@@ -265,21 +266,22 @@ Also see option `magit-blame-styles'."
                             (magit-file-relative-name
                              nil (not magit-buffer-file-name))))
                  (line (format "%d,+1" (line-number-at-pos))))
-             (cond (file (with-temp-buffer
-                           (magit-with-toplevel
-                             (magit-git-insert
-                              "blame" "--porcelain"
-                              (if (memq magit-blame-type '(final removal))
-                                  (cons "--reverse" (magit-blame-arguments))
-                                (magit-blame-arguments))
-                              "-L" line rev "--" file)
-                             (goto-char (point-min))
-                             (if (eobp)
-                                 (unless noerror
-                                   (error "Cannot get blame chunk at eob"))
-                               (car (magit-blame--parse-chunk type))))))
-                   (noerror nil)
-                   ((error "Buffer does not visit a tracked file")))))))
+             (cond (file
+                    (with-temp-buffer
+                      (magit-with-toplevel
+                        (magit-git-insert
+                         "blame" "--porcelain"
+                         (if (memq magit-blame-type '(final removal))
+                             (cons "--reverse" (magit-blame-arguments))
+                           (magit-blame-arguments))
+                         "-L" line rev "--" file)
+                        (goto-char (point-min))
+                        (cond ((not (eobp))
+                               (car (magit-blame--parse-chunk type)))
+                              ((not noerror)
+                               (error "Cannot get blame chunk at eob"))))))
+                   ((not noerror)
+                    (error "Buffer does not visit a tracked file")))))))
 
 (defun magit-blame-chunk-at (pos)
   (seq-some (##overlay-get % 'magit-blame-chunk)
@@ -326,12 +328,6 @@ in `magit-blame-read-only-mode-map' instead."
   :lighter magit-blame-mode-lighter
   :interactive nil
   (cond (magit-blame-mode
-         (unless arg
-           ;; Emacs < 28.1 doesn't support `:interactive'.
-           (setq magit-blame-mode nil)
-           (user-error
-            (concat "Don't call `magit-blame-mode' directly; "
-                    "instead use `magit-blame'")))
          (add-hook 'after-save-hook     #'magit-blame--refresh t t)
          (add-hook 'post-command-hook   #'magit-blame-goto-chunk-hook t t)
          (add-hook 'before-revert-hook  #'magit-blame--remove-overlays t t)
@@ -422,7 +418,8 @@ modes is toggled, then this mode also gets toggled automatically.
       (magit-blame-mode 1))
     (message "Blaming...")
     (magit-blame-run-process
-     (or magit-buffer-refname magit-buffer-revision)
+     (and$ (or magit-buffer-refname magit-buffer-revision)
+           (and (not (equal $ "{index}")) $))
      (magit-file-relative-name nil (not magit-buffer-file-name))
      (if (memq magit-blame-type '(final removal))
          (cons "--reverse" args)
@@ -432,14 +429,14 @@ modes is toggled, then this mode also gets toggled automatically.
     (set-process-sentinel magit-this-process
                           #'magit-blame-process-quickstart-sentinel)))
 
-(defun magit-blame-run-process (revision file args &optional lines)
+(defun magit-blame-run-process (rev file args &optional lines)
   (let ((process (magit-parse-git-async
                   "blame" "--incremental" args
                   (and lines (list "-L" (apply #'format "%s,%s" lines)))
-                  revision "--" file)))
+                  rev "--" file)))
     (set-process-filter   process #'magit-blame-process-filter)
     (set-process-sentinel process #'magit-blame-process-sentinel)
-    (process-put process 'arguments (list revision file args))
+    (process-put process 'arguments (list rev file args))
     (setq magit-blame-cache (make-hash-table :test #'equal))
     (setq magit-blame-process process)))
 
@@ -464,10 +461,10 @@ modes is toggled, then this mode also gets toggled automatically.
             (message "Blaming...done"))
         (magit-blame-assert-buffer process)
         (with-current-buffer (process-get process 'command-buf)
-          (if magit-blame-mode
-              (progn (magit-blame-mode -1)
-                     (message "Blaming...failed"))
-            (message "Blaming...aborted"))))
+          (cond (magit-blame-mode
+                 (magit-blame-mode -1)
+                 (message "Blaming...failed"))
+                ((message "Blaming...aborted")))))
       (kill-local-variable 'magit-blame-process))))
 
 (defun magit-blame-process-filter (process string)
@@ -501,22 +498,22 @@ modes is toggled, then this mode also gets toggled automatically.
              (buffer-substring-no-properties (point) (line-end-position))))
     (with-slots (orig-rev orig-file prev-rev prev-file)
         (setq chunk (magit-blame-chunk
-                     :orig-rev                     (match-string 1)
-                     :orig-line  (string-to-number (match-string 2))
-                     :final-line (string-to-number (match-string 3))
-                     :num-lines  (string-to-number (match-string 4))))
+                     :orig-rev                     (match-str 1)
+                     :orig-line  (string-to-number (match-str 2))
+                     :final-line (string-to-number (match-str 3))
+                     :num-lines  (string-to-number (match-str 4))))
       (forward-line)
       (let (done)
         (while (not done)
           (cond ((looking-at "^filename \\(.+\\)")
                  (setq done t)
-                 (setf orig-file (magit-decode-git-path (match-string 1))))
+                 (setf orig-file (magit-decode-git-path (match-str 1))))
                 ((looking-at "^previous \\(.\\{40,\\}\\) \\(.+\\)")
-                 (setf prev-rev  (match-string 1))
-                 (setf prev-file (magit-decode-git-path (match-string 2))))
+                 (setf prev-rev  (match-str 1))
+                 (setf prev-file (magit-decode-git-path (match-str 2))))
                 ((looking-at "^\\([^ ]+\\) \\(.+\\)")
-                 (push (cons (match-string 1)
-                             (match-string 2))
+                 (push (cons (match-str 1)
+                             (match-str 2))
                        revinfo)))
           (forward-line)))
       (when (and (eq type 'removal) prev-rev)
@@ -753,14 +750,14 @@ modes is toggled, then this mode also gets toggled automatically.
         (delete-overlay ov)))))
 
 (defun magit-blame-maybe-show-message ()
-  (when (magit-blame--style-get 'show-message)
-    (if-let ((msg (cdr (assoc "summary"
-                              (gethash (oref (magit-current-blame-chunk)
-                                             orig-rev)
-                                       magit-blame-cache)))))
-        (progn (set-text-properties 0 (length msg) nil msg)
-               (magit-msg "%S" msg))
-      (magit-msg "Commit data not available yet.  Still blaming."))))
+  (cond-let
+    ((not (magit-blame--style-get 'show-message)))
+    ([msg (cdr (assoc "summary"
+                      (gethash (oref (magit-current-blame-chunk) orig-rev)
+                               magit-blame-cache)))]
+     (set-text-properties 0 (length msg) nil msg)
+     (magit-msg "%S" msg))
+    ((magit-msg "Commit data not available yet.  Still blaming."))))
 
 ;;; Commands
 
@@ -907,8 +904,9 @@ then also kill the buffer."
                                      #'previous-single-char-property-change
                                    #'next-single-char-property-change)
                                  pos 'magit-blame-chunk)))
-            (when-let ((o (magit-blame--overlay-at pos))
-                       ((equal (oref (magit-blame-chunk-at pos) orig-rev) rev)))
+            (when-let
+                ((o (magit-blame--overlay-at pos))
+                 (_(equal (oref (magit-blame-chunk-at pos) orig-rev) rev)))
               (setq ov o))))
         (if ov
             (goto-char (overlay-start ov))
@@ -1002,4 +1000,15 @@ instead of the hash, like `kill-ring-save' would."
 
 ;;; _
 (provide 'magit-blame)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-blame.el ends here
diff --git a/elpa/magit-20250519.1537/magit-bookmark.el b/elpa/magit-20251103.1130/magit-bookmark.el
similarity index 88%
rename from elpa/magit-20250519.1537/magit-bookmark.el
rename to elpa/magit-20251103.1130/magit-bookmark.el
index 963b7e1c..8ded15f7 100644
--- a/elpa/magit-20250519.1537/magit-bookmark.el
+++ b/elpa/magit-20251103.1130/magit-bookmark.el
@@ -37,6 +37,11 @@
 (cl-defmethod magit-bookmark-get-filename (&context (major-mode magit-mode))
   (magit-toplevel))
 
+(cl-defmethod magit-bookmark-get-value
+  (bookmark &context (major-mode magit-mode))
+  (dolist (var (get major-mode 'magit-bookmark-variables))
+    (bookmark-prop-set bookmark var (symbol-value var))))
+
 (cl-defmethod magit-bookmark-get-buffer-create
   (bookmark (mode (derived-mode magit-mode)))
   (let ((default-directory (bookmark-get-filename bookmark))
@@ -151,4 +156,15 @@
 
 ;;; _
 (provide 'magit-bookmark)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-bookmark.el ends here
diff --git a/elpa/magit-20250519.1537/magit-branch.el b/elpa/magit-20251103.1130/magit-branch.el
similarity index 90%
rename from elpa/magit-20250519.1537/magit-branch.el
rename to elpa/magit-20251103.1130/magit-branch.el
index 56a754e5..7e252d35 100644
--- a/elpa/magit-20250519.1537/magit-branch.el
+++ b/elpa/magit-20251103.1130/magit-branch.el
@@ -252,24 +252,24 @@ has to be used to view and change branch related variables."
   (transient-args 'magit-branch))
 
 ;;;###autoload
-(defun magit-checkout (revision &optional args)
-  "Checkout REVISION, updating the index and the working tree.
-If REVISION is a local branch, then that becomes the current
+(defun magit-checkout (commit &optional args)
+  "Checkout COMMIT, updating the index and the working tree.
+If COMMIT is a local branch, then that becomes the current
 branch.  If it is something else, then `HEAD' becomes detached.
 Checkout fails if the working tree or the staging area contain
 changes.
-\n(git checkout REVISION)."
+\n(git checkout COMMIT)."
   (declare (interactive-only magit--checkout))
   (interactive (list (magit-read-other-branch-or-commit "Checkout")
                      (magit-branch-arguments)))
-  (when (string-match "\\`heads/\\(.+\\)" revision)
-    (setq revision (match-string 1 revision)))
-  (magit-run-git-async "checkout" args revision))
+  (when (string-match "\\`heads/\\(.+\\)" commit)
+    (setq commit (match-str 1 commit)))
+  (magit-run-git-async "checkout" args commit))
 
-(defun magit--checkout (revision &optional args)
-  (when (string-match "\\`heads/\\(.+\\)" revision)
-    (setq revision (match-string 1 revision)))
-  (magit-call-git "checkout" args revision))
+(defun magit--checkout (rev &optional args)
+  (when (string-match "\\`heads/\\(.+\\)" rev)
+    (setq rev (match-str 1 rev)))
+  (magit-call-git "checkout" args rev))
 
 ;;;###autoload
 (defun magit-branch-create (branch start-point)
@@ -319,7 +319,7 @@ does."
            (and (not (magit-commit-p arg))
                 (magit-read-starting-point "Create and checkout branch" arg)))))
   (when (string-match "\\`heads/\\(.+\\)" arg)
-    (setq arg (match-string 1 arg)))
+    (setq arg (match-str 1 arg)))
   (if start-point
       (with-suppressed-warnings ((interactive-only magit-branch-and-checkout))
         (magit-branch-and-checkout arg start-point))
@@ -374,8 +374,7 @@ when using `magit-branch-and-checkout'."
                   choice))
            ((member choice local)
             (list choice))
-           (t
-            (list choice (magit-read-starting-point "Create" choice))))))
+           ((list choice (magit-read-starting-point "Create" choice))))))
   (cond
    ((not start-point)
     (magit--checkout branch (magit-branch-arguments))
@@ -496,37 +495,38 @@ from the source branch's upstream, then an error is raised."
              (magit-anything-modified-p))
     (message "Staying on HEAD due to uncommitted changes")
     (setq checkout t))
-  (if-let ((current (magit-get-current-branch)))
-      (let ((tracked (magit-get-upstream-branch current))
-            base)
-        (when from
-          (unless (magit-rev-ancestor-p from current)
-            (user-error "Cannot spin off %s.  %s is not reachable from %s"
-                        branch from current))
-          (when (and tracked
-                     (magit-rev-ancestor-p from tracked))
-            (user-error "Cannot spin off %s.  %s is ancestor of upstream %s"
-                        branch from tracked)))
-        (let ((magit-process-raise-error t))
-          (if checkout
-              (magit-call-git "checkout" "-b" branch current)
-            (magit-call-git "branch" branch current)))
-        (when-let ((upstream (magit-get-indirect-upstream-branch current)))
-          (magit-call-git "branch" "--set-upstream-to" upstream branch))
-        (when (and tracked
-                   (setq base
-                         (if from
-                             (concat from "^")
-                           (magit-git-string "merge-base" current tracked)))
-                   (not (magit-rev-eq base current)))
-          (if checkout
-              (magit-call-git "update-ref" "-m"
-                              (format "reset: moving to %s" base)
-                              (concat "refs/heads/" current) base)
-            (magit-call-git "reset" "--hard" base))))
-    (if checkout
-        (magit-call-git "checkout" "-b" branch)
-      (magit-call-git "branch" branch)))
+  (cond-let
+    ([current (magit-get-current-branch)]
+     (let ((tracked (magit-get-upstream-branch current))
+           base)
+       (when from
+         (unless (magit-rev-ancestor-p from current)
+           (user-error "Cannot spin off %s.  %s is not reachable from %s"
+                       branch from current))
+         (when (and tracked
+                    (magit-rev-ancestor-p from tracked))
+           (user-error "Cannot spin off %s.  %s is ancestor of upstream %s"
+                       branch from tracked)))
+       (let ((magit-process-raise-error t))
+         (if checkout
+             (magit-call-git "checkout" "-b" branch current)
+           (magit-call-git "branch" branch current)))
+       (when-let ((upstream (magit-get-indirect-upstream-branch current)))
+         (magit-call-git "branch" "--set-upstream-to" upstream branch))
+       (when (and tracked
+                  (setq base
+                        (if from
+                            (concat from "^")
+                          (magit-git-string "merge-base" current tracked)))
+                  (not (magit-rev-eq base current)))
+         (if checkout
+             (magit-call-git "update-ref" "-m"
+                             (format "reset: moving to %s" base)
+                             (concat "refs/heads/" current) base)
+           (magit-call-git "reset" "--hard" base)))))
+    (checkout
+     (magit-call-git "checkout" "-b" branch))
+    ((magit-call-git "branch" branch)))
   (magit-refresh))
 
 ;;;###autoload
@@ -595,16 +595,16 @@ prompt is confusing."
        (setq branches
              (list (magit-read-branch-prefer-other
                     (if force "Force delete branch" "Delete branch")))))
-     (when-let (((not force))
-                (unmerged (seq-remove #'magit-branch-merged-p branches)))
-       (if (magit-confirm 'delete-unmerged-branch
-             "Delete unmerged branch %s"
-             "Delete %d unmerged branches"
-             'noabort unmerged)
-           (setq force branches)
-         (or (setq branches
-                   (cl-set-difference branches unmerged :test #'equal))
-             (user-error "Abort"))))
+     (cond-let
+       (force)
+       [[unmerged (seq-remove #'magit-branch-merged-p branches)]]
+       ((magit-confirm 'delete-unmerged-branch
+          "Delete unmerged branch %s"
+          "Delete %d unmerged branches"
+          'noabort unmerged)
+        (setq force branches))
+       ((setq branches (cl-set-difference branches unmerged :test #'equal)))
+       ((user-error "Abort")))
      (list branches force)))
   (let ((refs (mapcar #'magit-ref-fullname branches)))
     ;; If a member of refs is nil, that means that
@@ -618,11 +618,10 @@ prompt is confusing."
            (format "%s is" (seq-find #'magit-ref-ambiguous-p branches)))
           ((= len (length refs))
            (format "These %s names are" len))
-          (t
-           (format "%s of these names are" len))))))
+          ((format "%s of these names are" len))))))
     (cond
      ((string-match "^refs/remotes/\\([^/]+\\)" (car refs))
-      (let* ((remote (match-string 1 (car refs)))
+      (let* ((remote (match-str 1 (car refs)))
              (offset (1+ (length remote))))
         (cond
          ((magit-confirm 'delete-branch-on-remote
@@ -728,25 +727,24 @@ prompt is confusing."
   (magit-set nil "branch" branch "pushRemote"))
 
 (defun magit-delete-remote-branch-sentinel (remote refs process event)
-  (when (memq (process-status process) '(exit signal))
-    (if (= (process-exit-status process) 1)
-        (if-let ((on-remote (mapcar (##concat "refs/remotes/" remote "/" %)
-                                    (magit-remote-list-branches remote)))
-                 (rest (seq-filter (##and (not (member % on-remote))
-                                          (magit-ref-exists-p %))
-                                   refs)))
-            (progn
-              (process-put process 'inhibit-refresh t)
-              (magit-process-sentinel process event)
-              (setq magit-this-error nil)
-              (message "Some remote branches no longer exist.  %s"
-                       "Deleting just the local tracking refs instead...")
-              (dolist (ref rest)
-                (magit-call-git "update-ref" "-d" ref))
-              (magit-refresh)
-              (message "Deleting local remote-tracking refs...done"))
-          (magit-process-sentinel process event))
-      (magit-process-sentinel process event))))
+  (cond-let*
+    ((not (memq (process-status process) '(exit signal))))
+    ([_(= (process-exit-status process) 1)]
+     [on-remote (mapcar (##concat "refs/remotes/" remote "/" %)
+                        (magit-remote-list-branches remote))]
+     [rest (seq-filter (##and (not (member % on-remote))
+                              (magit-ref-exists-p %))
+                       refs)]
+     (process-put process 'inhibit-refresh t)
+     (magit-process-sentinel process event)
+     (setq magit-this-error nil)
+     (message "Some remote branches no longer exist.  %s"
+              "Deleting just the local tracking refs instead...")
+     (dolist (ref rest)
+       (magit-call-git "update-ref" "-d" ref))
+     (magit-refresh)
+     (message "Deleting local remote-tracking refs...done"))
+    ((magit-process-sentinel process event))))
 
 ;;;###autoload
 (defun magit-branch-rename (old new &optional force)
@@ -766,7 +764,7 @@ the remote."
                                  nil 'magit-revision-history)
            current-prefix-arg)))
   (when (string-match "\\`heads/\\(.+\\)" old)
-    (setq old (match-string 1 old)))
+    (setq old (match-str 1 old)))
   (when (equal old new)
     (user-error "Old and new branch names are the same"))
   (magit-call-git "branch" (if force "-M" "-m") old new)
@@ -787,9 +785,8 @@ the remote."
                  (or (not (eq magit-branch-rename-push-target 'forge-only))
                      (and (require (quote forge) nil t)
                           (fboundp 'forge--split-forge-url)
-                          (and-let* ((url (magit-git-string
-                                           "remote" "get-url" remote)))
-                            (forge--split-forge-url url)))))
+                          (and$ (magit-git-string "remote" "get-url" remote)
+                                (forge--split-forge-url $)))))
         (let ((old-target (magit-get-push-branch old t))
               (new-target (magit-get-push-branch new t))
               (remote (magit-get-push-remote new)))
@@ -830,12 +827,7 @@ and also rename the respective reflog file."
 Rename \"refs/shelved/BRANCH\" to \"refs/heads/BRANCH\".  If BRANCH
 is prefixed with \"YYYY-MM-DD\", then drop that part of the name.
 Also rename the respective reflog file."
-  (interactive
-   (list (magit-completing-read
-          "Unshelve branch"
-          (mapcar (##substring % 8)
-                  (nreverse (magit-list-refnames "refs/shelved")))
-          nil t)))
+  (interactive (list (magit-read-shelved-branch "Unshelve branch")))
   (let ((old (concat "refs/shelved/" branch))
         (new (concat "refs/heads/"
                      (if (string-match-p
@@ -979,4 +971,15 @@ Also rename the respective reflog file."
 
 ;;; _
 (provide 'magit-branch)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-branch.el ends here
diff --git a/elpa/magit-20250519.1537/magit-bundle.el b/elpa/magit-20251103.1130/magit-bundle.el
similarity index 92%
rename from elpa/magit-20250519.1537/magit-bundle.el
rename to elpa/magit-20251103.1130/magit-bundle.el
index 1cd98d55..5c739575 100644
--- a/elpa/magit-20250519.1537/magit-bundle.el
+++ b/elpa/magit-20251103.1130/magit-bundle.el
@@ -99,7 +99,7 @@
 ;;;###autoload
 (defun magit-bundle-update-tracked (tag)
   "Update a bundle that is being tracked using TAG."
-  (interactive (list (magit-read-tag "Update bundle tracked by tag" t)))
+  (interactive (list (magit-read-tag "Update bundle tracked by tag")))
   (let (msg)
     (let-alist (magit--with-temp-process-buffer
                  (save-excursion
@@ -136,4 +136,15 @@
 
 ;;; _
 (provide 'magit-bundle)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-bundle.el ends here
diff --git a/elpa/magit-20250519.1537/magit-clone.el b/elpa/magit-20251103.1130/magit-clone.el
similarity index 94%
rename from elpa/magit-20250519.1537/magit-clone.el
rename to elpa/magit-20251103.1130/magit-clone.el
index 42187eb3..dc7c827c 100644
--- a/elpa/magit-20250519.1537/magit-clone.el
+++ b/elpa/magit-20251103.1130/magit-clone.el
@@ -314,13 +314,13 @@ Then show the status buffer for the new repository."
 
 (defun magit-clone--url-to-name (url)
   (and (string-match "\\([^/:]+?\\)\\(/?\\.git\\)?$" url)
-       (match-string 1 url)))
+       (match-str 1 url)))
 
 (defun magit-clone--name-to-url (name)
   (or (seq-some
        (pcase-lambda (`(,re ,host ,user))
          (and (string-match re name)
-              (let ((repo (match-string 1 name)))
+              (let ((repo (match-str 1 name)))
                 (magit-clone--format-url host user repo))))
        magit-clone-name-alist)
       (user-error "Not an url and no matching entry in `%s'"
@@ -336,16 +336,27 @@ Then show the status buffer for the new repository."
       (format-spec
        url-format
        `((?h . ,host)
-         (?n . ,(if (string-search "/" repo)
-                    repo
-                  (if (string-search "." user)
-                      (if-let ((user (magit-get user)))
-                          (concat user "/" repo)
-                        (user-error "Set %S or specify owner explicitly" user))
-                    (concat user "/" repo))))))
+         (?n . ,(cond
+                 ((string-search "/" repo) repo)
+                 ((string-search "." user)
+                  (if-let ((user (magit-get user)))
+                      (concat user "/" repo)
+                    (user-error "Set %S or specify owner explicitly" user)))
+                 ((concat user "/" repo))))))
     (user-error
      "Bogus `magit-clone-url-format' (bad type or missing default)")))
 
 ;;; _
 (provide 'magit-clone)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-clone.el ends here
diff --git a/elpa/magit-20250519.1537/magit-commit.el b/elpa/magit-20251103.1130/magit-commit.el
similarity index 97%
rename from elpa/magit-20250519.1537/magit-commit.el
rename to elpa/magit-20251103.1130/magit-commit.el
index e8b84383..c5a40146 100644
--- a/elpa/magit-20250519.1537/magit-commit.el
+++ b/elpa/magit-20251103.1130/magit-commit.el
@@ -572,7 +572,7 @@ See `magit-commit-autofixup' for an alternative implementation."
     (when commit
       (setq commit (magit-rebase-interactive-assert commit t)))
     (if (and commit (eq phase 'run))
-        (progn (magit-run-git-async "absorb" args "-b" commit) t)
+        (prog1 t (magit-run-git-async "absorb" args "-b" commit))
       (magit-log-select
         (lambda (commit)
           (with-no-warnings ; about non-interactive use
@@ -614,7 +614,7 @@ an alternative implementation."
     (when commit
       (setq commit (magit-rebase-interactive-assert commit t)))
     (if (and commit (eq phase 'run))
-        (progn (magit-run-git-async "autofixup" args commit) t)
+        (prog1 t (magit-run-git-async "autofixup" args commit))
       (magit-log-select
         (lambda (commit)
           (with-no-warnings ; about non-interactive use
@@ -707,8 +707,8 @@ an alternative implementation."
     (cond
      ((not
        (and (eq this-command 'magit-diff-while-committing)
-            (and-let* ((buf (magit-get-mode-buffer
-                             'magit-diff-mode nil 'selected)))
+            (and-let ((buf (magit-get-mode-buffer
+                            'magit-diff-mode nil 'selected)))
               (and (equal rev (buffer-local-value 'magit-buffer-range buf))
                    (equal arg (buffer-local-value 'magit-buffer-typearg buf)))))))
      ((eq command 'magit-commit-amend)
@@ -784,7 +784,7 @@ actually insert the entry."
       (narrow-to-region (point-min) (point))
       (cond ((re-search-backward (format "* %s\\(?: (\\([^)]+\\))\\)?: " file)
                                  nil t)
-             (when (equal (match-string 1) defun)
+             (when (equal (match-str 1) defun)
                (setq defun nil))
              (re-search-forward ": "))
             (t
@@ -813,4 +813,15 @@ actually insert the entry."
 
 ;;; _
 (provide 'magit-commit)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-commit.el ends here
diff --git a/elpa/magit-20250519.1537/magit-core.el b/elpa/magit-20251103.1130/magit-core.el
similarity index 91%
rename from elpa/magit-20250519.1537/magit-core.el
rename to elpa/magit-20251103.1130/magit-core.el
index a7ff47e7..0ea2385c 100644
--- a/elpa/magit-20250519.1537/magit-core.el
+++ b/elpa/magit-20251103.1130/magit-core.el
@@ -120,4 +120,15 @@ Each of these options falls into one or more of these categories:
 
 ;;; _
 (provide 'magit-core)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-core.el ends here
diff --git a/elpa/magit-20250519.1537/magit-diff.el b/elpa/magit-20251103.1130/magit-diff.el
similarity index 78%
rename from elpa/magit-20250519.1537/magit-diff.el
rename to elpa/magit-20251103.1130/magit-diff.el
index 02cbbc71..1b3d568c 100644
--- a/elpa/magit-20250519.1537/magit-diff.el
+++ b/elpa/magit-20251103.1130/magit-diff.el
@@ -35,11 +35,15 @@
 (require 'image)
 (require 'smerge-mode)
 
+;; For `magit-diff--get-value'
+(defvar magit-status-use-buffer-arguments)
 ;; For `magit-diff-popup'
 (declare-function magit-stash-show "magit-stash" (stash &optional args files))
 ;; For `magit-diff-visit-file'
-(declare-function magit-find-file-noselect "magit-files" (rev file))
+(declare-function magit-find-file-noselect "magit-files" (rev file &optional revert))
 (declare-function magit-status-setup-buffer "magit-status" (&optional directory))
+;; For `magit-diff-wash-diff'
+(defvar magit-log-heading-re)
 ;; For `magit-diff-while-committing'
 (declare-function magit-commit-diff-1 "magit-commit" ())
 (declare-function magit-commit-message-buffer "magit-commit" ())
@@ -50,7 +54,7 @@
 (declare-function magit-blame-mode "magit-blame" (&optional arg))
 (defvar magit-blame-mode)
 ;; For `magit-diff-show-or-scroll'
-(declare-function git-rebase-current-line "git-rebase" ())
+(declare-function git-rebase-current-line "git-rebase" (&optional batch))
 ;; For `magit-diff-unmerged'
 (declare-function magit-merge-in-progress-p "magit-merge" ())
 (declare-function magit--merge-range "magit-merge" (&optional head))
@@ -78,14 +82,14 @@
                   (&optional whoami file-name other-window))
 (declare-function magit-add-change-log-entry-other-window "magit-extras"
                   (&optional whoami file-name))
-(declare-function magit-diff-edit-hunk-commit "magit-extras" (file))
+(declare-function magit-diff-edit-hunk-commit "magit-extras" ())
 (declare-function magit-smerge-keep-current "magit-apply" ())
 (declare-function magit-smerge-keep-all "magit-apply" ())
 (declare-function magit-smerge-keep-upper "magit-apply" ())
 (declare-function magit-smerge-keep-base "magit-apply" ())
 (declare-function magit-smerge-keep-lower "magit-apply" ())
 
-(eval-when-compile
+(eval-and-compile
   (cl-pushnew 'orig-rev eieio--known-slot-names)
   (cl-pushnew 'action-type eieio--known-slot-names)
   (cl-pushnew 'target eieio--known-slot-names))
@@ -192,13 +196,18 @@ keep their distinct foreground colors."
   "Whether to show word-granularity differences within diff hunks.
 
 `nil'  Never show fine differences.
-`t'    Show fine differences for the current diff hunk only.
-`all'  Show fine differences for all displayed diff hunks."
+`all'  Show fine differences for all displayed diff hunks.
+`t'    Refine each hunk once it becomes the current section.
+       Keep the refinement when another section is selected.
+       Refreshing the buffer removes all refinement.  This
+       variant is only provided for performance reasons."
   :group 'magit-diff
   :safe (##memq % '(nil t all))
-  :type '(choice (const :tag "Never" nil)
-                 (const :tag "Current" t)
-                 (const :tag "All" all)))
+  :type '(choice (const :tag "No refinement" nil)
+                 (const :tag "Immediately refine all hunks" all)
+                 (const :tag "Refine each hunk when moving to it" t)))
+
+(put 'magit-diff-refine-hunk 'permanent-local t)
 
 (defcustom magit-diff-refine-ignore-whitespace smerge-refine-ignore-whitespace
   "Whether to ignore whitespace changes in word-granularity differences."
@@ -208,8 +217,6 @@ keep their distinct foreground colors."
   :safe 'booleanp
   :type 'boolean)
 
-(put 'magit-diff-refine-hunk 'permanent-local t)
-
 (defcustom magit-diff-adjust-tab-width nil
   "Whether to adjust the width of tabs in diffs.
 
@@ -539,37 +546,40 @@ log's file filter is always honored."
 
 ;;;; Visit Commands
 
-(defcustom magit-diff-visit-previous-blob t
-  "Whether `magit-diff-visit-file' may visit the previous blob.
+(defcustom magit-diff-visit-prefer-worktree nil
+  "Whether `magit-diff-visit-file' prefers visiting the worktree file.
 
-When this is t and point is on a removed line in a diff for a
-committed change, then `magit-diff-visit-file' visits the blob
-from the last revision which still had that line.
+By default `magit-diff-visit-file' does not do that.  Instead it
+behaves for staged and unstaged changes as it does for committed
+changes, by visiting a blob from the old/left or new/right side,
+depending on whether point is on a removed line or not.
 
-Currently this is only supported for committed changes, for
-staged and unstaged changes `magit-diff-visit-file' always
-visits the file in the working tree."
-  :package-version '(magit . "2.9.0")
+Setting this to nil, causes `magit-diff-visit-file' to always go to
+the file in the worktree when invoked from anywhere within a staged
+or unstaged change.
+
+It is strongly recommended that instead of changing the value of
+this option, you use the command `magit-diff-visit-worktree-file',
+which was created for that very purpose.  See the description of
+this option in the manual for an explanation."
+  :package-version '(magit . "4.4.0")
   :group 'magit-diff
   :type 'boolean)
 
-(defcustom magit-diff-visit-avoid-head-blob nil
-  "Whether `magit-diff-visit-file' avoids visiting a blob from `HEAD'.
-
-By default `magit-diff-visit-file' always visits the blob that
-added the current line, while `magit-diff-visit-worktree-file'
-visits the respective file in the working tree.  For the `HEAD'
-commit, the former command used to visit the worktree file too,
-but that made it impossible to visit a blob from `HEAD'.
+(defcustom magit-diff-visit-previous-blob t
+  "Whether `magit-diff-visit-file' may visit the previous blob.
 
-When point is on a removed line and that change has not been
-committed yet, then `magit-diff-visit-file' now visits the last
-blob that still had that line, which is a blob from `HEAD'.
-Previously this function used to visit the worktree file not
-only for added lines but also for such removed lines.
+When this is t (the default) and point is on a removed line, then
+`magit-diff-visit-file' visits the blob from the old/left commit,
+which still has that line, instead of going to the new/right blob,
+which removes that line.
 
-If you prefer the old behaviors, then set this to t."
-  :package-version '(magit . "3.0.0")
+Setting this to nil, causes `magit-diff-visit-file' to always go to
+the new/right blob, even when point is on a removed line.  This is
+very strongly discouraged.  Instead place the cursor anywhere else
+within the hunk but on a removed line, if you want to visit the new
+side.  That way you don't lose the ability to visit the old side."
+  :package-version '(magit . "2.9.0")
   :group 'magit-diff
   :type 'boolean)
 
@@ -646,6 +656,11 @@ loss of information.  Good properties to set here are `:weight'
 and `:slant'."
   :group 'magit-faces)
 
+(defface magit-diff-conflict-heading-highlight
+  '((t :inherit magit-diff-hunk-heading-highlight))
+  "Face for conflict markers."
+  :group 'magit-faces)
+
 (defface magit-diff-revision-summary
   '((t :inherit magit-diff-hunk-heading))
   "Face for commit message summaries."
@@ -801,13 +816,13 @@ and `:slant'."
 (defface magit-diffstat-added
   '((((class color) (background light)) :foreground "#22aa22")
     (((class color) (background  dark)) :foreground "#448844"))
-  "Face for plus sign in diffstat."
+  "Face for addition indicator in diffstat."
   :group 'magit-faces)
 
 (defface magit-diffstat-removed
   '((((class color) (background light)) :foreground "#aa2222")
     (((class color) (background  dark)) :foreground "#aa4444"))
-  "Face for minus sign in diffstat."
+  "Face for removal indicator in diffstat."
   :group 'magit-faces)
 
 ;;; Arguments
@@ -823,11 +838,15 @@ and `:slant'."
 
 ;;;; Prefix Methods
 
+(cl-defmethod transient-prefix-value ((obj magit-diff-prefix))
+  (let ((args (cl-call-next-method obj)))
+    (list (seq-filter #'atom args)
+          (cdr (assoc "--" args)))))
+
 (cl-defmethod transient-init-value ((obj magit-diff-prefix))
   (pcase-let ((`(,args ,files)
-               (magit-diff--get-value 'magit-diff-mode
-                                      magit-prefix-use-buffer-arguments)))
-    (when-let (((not (eq transient-current-command 'magit-dispatch)))
+               (magit-diff--get-value 'magit-diff-mode 'prefix)))
+    (when-let ((_(not (eq transient-current-command 'magit-dispatch)))
                (file (magit-file-relative-name)))
       (setq files (list file)))
     (oset obj value (if files `(("--" ,@files) ,@args) args))))
@@ -849,40 +868,38 @@ and `:slant'."
 (defun magit-diff-arguments (&optional mode)
   "Return the current diff arguments."
   (if (memq transient-current-command '(magit-diff magit-diff-refresh))
-      (magit--transient-args-and-files)
-    (magit-diff--get-value (or mode 'magit-diff-mode))))
+      (transient-args transient-current-command)
+    (magit-diff--get-value (or mode 'magit-diff-mode) 'direct)))
 
 (defun magit-diff--get-value (mode &optional use-buffer-args)
-  (unless use-buffer-args
-    (setq use-buffer-args magit-direct-use-buffer-arguments))
-  (let (args files)
-    (cond
-     ((and (memq use-buffer-args '(always selected current))
-           (eq major-mode mode))
-      (setq args  magit-buffer-diff-args)
-      (setq files magit-buffer-diff-files))
-     ((when-let (((memq use-buffer-args '(always selected)))
-                 (buffer (magit-get-mode-buffer
-                          mode nil
-                          (eq use-buffer-args 'selected))))
-        (setq args  (buffer-local-value 'magit-buffer-diff-args buffer))
-        (setq files (buffer-local-value 'magit-buffer-diff-files buffer))
-        t))
-     ((plist-member (symbol-plist mode) 'magit-diff-current-arguments)
-      (setq args (get mode 'magit-diff-current-arguments)))
-     ((when-let ((elt (assq (intern (format "magit-diff:%s" mode))
-                            transient-values)))
-        (setq args (cdr elt))
-        t))
-     (t
-      (setq args (get mode 'magit-diff-default-arguments))))
-    (list args files)))
+  (setq use-buffer-args
+        (pcase-exhaustive use-buffer-args
+          ('prefix magit-prefix-use-buffer-arguments)
+          ('status magit-status-use-buffer-arguments)
+          ('direct magit-direct-use-buffer-arguments)
+          ('nil    magit-direct-use-buffer-arguments)
+          ((or 'always 'selected 'current 'never)
+           use-buffer-args)))
+  (cond-let
+    ((and (memq use-buffer-args '(always selected current))
+          (eq major-mode mode))
+     (list magit-buffer-diff-args
+           magit-buffer-diff-files))
+    ([_(memq use-buffer-args '(always selected))]
+     [buffer (magit-get-mode-buffer mode nil (eq use-buffer-args 'selected))]
+     (list (buffer-local-value 'magit-buffer-diff-args buffer)
+           (buffer-local-value 'magit-buffer-diff-files buffer)))
+    ((plist-member (symbol-plist mode) 'magit-diff-current-arguments)
+     (list (get mode 'magit-diff-current-arguments) nil))
+    ([elt (assq (intern (format "magit-diff:%s" mode)) transient-values)]
+     (list (cdr elt) nil))
+    ((list (get mode 'magit-diff-default-arguments) nil))))
 
 (defun magit-diff--set-value (obj &optional save)
   (pcase-let* ((obj  (oref obj prototype))
                (mode (or (oref obj major-mode) major-mode))
                (key  (intern (format "magit-diff:%s" mode)))
-               (`(,args ,files) (magit--transient-args-and-files)))
+               (`(,args ,files) (transient-args (oref obj command))))
     (put mode 'magit-diff-current-arguments args)
     (when save
       (setf (alist-get key transient-values) args)
@@ -1168,8 +1185,8 @@ use the commands that allow you to explicitly specify what you need."
 The information can be in three forms:
 1. TYPE
    A symbol describing a type of diff where no additional information
-   is needed to generate the diff.  Currently, this includes `staged',
-   `unstaged' and `unmerged'.
+   is needed to generate the diff.  One of `staged', `unstaged',
+   `unmerged', and `undefined'.
 2. (TYPE . VALUE)
    Like #1 but the diff requires additional information, which is
    given by VALUE.  Currently, this includes `commit' and `stash',
@@ -1178,57 +1195,56 @@ The information can be in three forms:
    A string indicating a diff range.
 
 If no DWIM context is found, nil is returned."
-  (cond
-   ((and-let* ((commits (magit-region-values '(commit branch) t)))
-      (progn
-        (deactivate-mark)
-        (concat (car (last commits)) ".." (car commits)))))
-   (magit-buffer-refname
-    (cons 'commit magit-buffer-refname))
-   ((derived-mode-p 'magit-stash-mode)
-    (cons 'commit
-          (magit-section-case
-            (commit (oref it value))
-            (file (thread-first it
-                    (oref parent)
-                    (oref value)))
-            (hunk (thread-first it
-                    (oref parent)
-                    (oref parent)
-                    (oref value))))))
-   ((derived-mode-p 'magit-revision-mode)
-    (cons 'commit magit-buffer-revision))
-   ((derived-mode-p 'magit-diff-mode)
-    magit-buffer-range)
-   (t
-    (magit-section-case
-      ([* unstaged] 'unstaged)
-      ([* staged] 'staged)
-      (unmerged 'unmerged)
-      (unpushed (magit-diff--range-to-endpoints (oref it value)))
-      (unpulled (magit-diff--range-to-endpoints (oref it value)))
-      (branch (let ((current (magit-get-current-branch))
-                    (atpoint (oref it value)))
-                (if (equal atpoint current)
-                    (if-let ((upstream (magit-get-upstream-branch)))
-                        (format "%s...%s" upstream current)
-                      (if (magit-anything-modified-p)
-                          current
-                        (cons 'commit current)))
-                  (format "%s...%s"
-                          (or current "HEAD")
-                          atpoint))))
-      (commit (cons 'commit (oref it value)))
-      ([file commit] (cons 'commit (oref (oref it parent) value)))
-      ([hunk file commit]
-       (cons 'commit (oref (oref (oref it parent) parent) value)))
-      (stash (cons 'stash (oref it value)))
-      (pullreq (forge--pullreq-range (oref it value) t))))))
+  (cond-let
+    ([commits (magit-region-values '(commit branch) t)]
+     (deactivate-mark)
+     (concat (car (last commits)) ".." (car commits)))
+    (magit-buffer-refname
+     (cons 'commit magit-buffer-refname))
+    ((derived-mode-p 'magit-stash-mode)
+     (cons 'commit
+           (magit-section-case
+             (commit (oref it value))
+             (file (thread-first it
+                     (oref parent)
+                     (oref value)))
+             (hunk (thread-first it
+                     (oref parent)
+                     (oref parent)
+                     (oref value))))))
+    ((derived-mode-p 'magit-revision-mode)
+     (cons 'commit magit-buffer-revision))
+    ((derived-mode-p 'magit-diff-mode)
+     (pcase-exhaustive magit-buffer-diff-type
+       ('committed magit-buffer-range)
+       ((or 'unstaged 'staged 'undefined) magit-buffer-diff-type)))
+    ((magit-section-case
+       ([* unstaged] 'unstaged)
+       ([* staged] 'staged)
+       (unmerged 'unmerged)
+       (unpushed (magit-diff--range-to-endpoints (oref it value)))
+       (unpulled (magit-diff--range-to-endpoints (oref it value)))
+       (branch (cond-let
+                 [[current (magit-get-current-branch)]
+                  [atpoint (oref it value)]]
+                 ((not (equal atpoint current))
+                  (format "%s...%s" (or current "HEAD") atpoint))
+                 ([upstream (magit-get-upstream-branch)]
+                  (format "%s...%s" upstream current))
+                 ((magit-anything-modified-p)
+                  current)
+                 ((cons 'commit current))))
+       (commit (cons 'commit (oref it value)))
+       ([file commit] (cons 'commit (oref (oref it parent) value)))
+       ([hunk file commit]
+        (cons 'commit (oref (oref (oref it parent) parent) value)))
+       (stash (cons 'stash (oref it value)))
+       (pullreq (forge--pullreq-range (oref it value) t))))))
 
 (defun magit-diff--range-to-endpoints (range)
   (cond ((string-match "\\.\\.\\." range) (replace-match ".."  nil nil range))
         ((string-match "\\.\\."    range) (replace-match "..." nil nil range))
-        (t range)))
+        (range)))
 
 (defun magit-diff--region-range (&optional interactive mbase)
   (and-let* ((commits (magit-region-values '(commit branch) t))
@@ -1250,7 +1266,7 @@ If no DWIM context is found, nil is returned."
                                                  nil t nil nil revB)))
                 (format "%s...%s"
                         (if (string= main revB) revA revB) main)))
-             (t "%s...%s" revA revB)))
+             ((format "%s...%s" revA revB))))
         (format "%s..%s" revA revB)))))
 
 (defun magit-diff-read-range-or-commit (prompt &optional secondary-default mbase)
@@ -1359,7 +1375,7 @@ the file or blob."
                                        (list file)
                                        'unstaged
                                        magit-diff-buffer-file-locked)
-            (magit-diff--goto-position file line col))))
+            (magit-diff--goto-file-position file line col))))
     (user-error "Buffer isn't visiting a file")))
 
 ;;;###autoload
@@ -1402,7 +1418,7 @@ for a revision."
                 (magit-section-parent-value (magit-current-section))))))
   (require 'magit)
   (let* ((file (magit-file-relative-name))
-         (ln (and file (line-number-at-pos))))
+         (line (and file (line-number-at-pos))))
     (magit-with-toplevel
       (when module
         (setq default-directory
@@ -1413,47 +1429,54 @@ for a revision."
         (save-buffer))
       (let ((buf (magit-revision-setup-buffer rev args files)))
         (when file
-          (let ((line (magit-diff-visit--offset file (list "-R" rev) ln))
+          (let ((line (magit-diff-visit--offset file (list "-R" rev) line))
                 (col (current-column)))
             (with-current-buffer buf
-              (magit-diff--goto-position file line col))))))))
-
-(defun magit-diff--locate-hunk (file line &optional parent)
-  (and-let* ((diff (cl-find-if (##and (cl-typep % 'magit-file-section)
-                                      (equal (oref % value) file))
-                               (oref (or parent magit-root-section) children))))
-    (let ((hunks (oref diff children)))
-      (cl-block nil
-        (while-let ((hunk (pop hunks)))
-          (when-let ((range (oref hunk to-range)))
-            (pcase-let* ((`(,beg ,len) range)
-                         (end (+ beg len)))
-              (cond ((>  beg line)     (cl-return (list diff nil)))
-                    ((<= beg line end) (cl-return (list hunk t)))
-                    ((null hunks)      (cl-return (list hunk nil)))))))))))
-
-(defun magit-diff--goto-position (file line column &optional parent)
-  (when-let ((pos (magit-diff--locate-hunk file line parent)))
-    (pcase-let ((`(,section ,exact) pos))
-      (cond ((cl-typep section 'magit-file-section)
-             (goto-char (oref section start)))
-            (exact
-             (goto-char (oref section content))
-             (let ((pos (car (oref section to-range))))
-               (while (or (< pos line)
-                          (= (char-after) ?-))
-                 (unless (= (char-after) ?-)
-                   (cl-incf pos))
-                 (forward-line)))
-             (forward-char (1+ column)))
-            (t
-             (goto-char (oref section start))
-             (setq section (oref section parent))))
-      (while section
-        (when (oref section hidden)
-          (magit-section-show section))
-        (setq section (oref section parent))))
-    t))
+              (magit-diff--goto-file-position file line col))))))))
+
+(defun magit-diff--locate-file-position (file line column &optional parent)
+  (and-let*
+      ((parent (pcase parent
+                 ('unstaged (magit-get-section '((unstaged) (status))))
+                 ('staged   (magit-get-section '((staged)   (status))))
+                 ('nil (and (cl-typep (car (oref magit-root-section children))
+                                      'magit-file-section)
+                            magit-root-section))
+                 (_ parent)))
+       (diff (cl-find-if (##equal (oref % value) file)
+                         (oref parent children)))
+       (hunks (oref diff children)))
+    (let (hunk pos found)
+      (while (and (setq hunk (pop hunks))
+                  (not pos))
+        (when-let* ((range (oref hunk to-range))
+                    (beg (car range))
+                    (len (cadr range))
+                    (end (+ beg len)))
+          (cond
+           ((> beg line)
+            (setq pos (oref diff start)))
+           ((<= beg line end)
+            (save-excursion
+              (goto-char (oref hunk content))
+              (let ((l beg))
+                (while (or (< l line)
+                           (= (char-after) ?-))
+                  (unless (= (char-after) ?-)
+                    (cl-incf l))
+                  (forward-line)))
+              (setq found (if (= (char-after) ?+) 'line 'hunk))
+              (forward-char (1+ column))
+              (setq pos (point))))
+           ((null hunks)
+            (setq pos (oref hunk start))))))
+      (and pos
+           (list pos (or found file))))))
+
+(defun magit-diff--goto-file-position (file line column &optional parent)
+  (when-let ((pos (magit-diff--locate-file-position file line column parent)))
+    (goto-char (car pos))
+    (magit-section-reveal (magit-current-section))))
 
 ;;;; Setting Commands
 
@@ -1461,31 +1484,29 @@ for a revision."
   "Convert diff range type.
 Change \"revA..revB\" to \"revA...revB\", or vice versa."
   (interactive)
-  (if (and magit-buffer-range
-           (derived-mode-p 'magit-diff-mode)
-           (string-match magit-range-re magit-buffer-range))
-      (setq magit-buffer-range
-            (replace-match (if (string= (match-string 2 magit-buffer-range) "..")
-                               "..."
-                             "..")
-                           t t magit-buffer-range 2))
-    (user-error "No range to change"))
-  (magit-refresh))
+  (cond ((and magit-buffer-range
+              (derived-mode-p 'magit-diff-mode)
+              (string-match magit-range-re magit-buffer-range))
+         (setq magit-buffer-range
+               (replace-match
+                (if (string= (match-str 2 magit-buffer-range) "..") "..." "..")
+                t t magit-buffer-range 2))
+         (magit-refresh))
+        ((user-error "No range to change"))))
 
 (defun magit-diff-flip-revs ()
   "Swap revisions in diff range.
 Change \"revA..revB\" to \"revB..revA\"."
   (interactive)
-  (if (and magit-buffer-range
-           (derived-mode-p 'magit-diff-mode)
-           (string-match magit-range-re magit-buffer-range))
-      (progn
-        (setq magit-buffer-range
-              (concat (match-string 3 magit-buffer-range)
-                      (match-string 2 magit-buffer-range)
-                      (match-string 1 magit-buffer-range)))
-        (magit-refresh))
-    (user-error "No range to swap")))
+  (cond ((and magit-buffer-range
+              (derived-mode-p 'magit-diff-mode)
+              (string-match magit-range-re magit-buffer-range))
+         (setq magit-buffer-range
+               (concat (match-str 3 magit-buffer-range)
+                       (match-str 2 magit-buffer-range)
+                       (match-str 1 magit-buffer-range)))
+         (magit-refresh))
+        ((user-error "No range to swap"))))
 
 (defun magit-diff-toggle-file-filter ()
   "Toggle the file restriction of the current buffer's diffs.
@@ -1510,8 +1531,7 @@ instead."
         (message "No revision buffer")))
      ((local-variable-p 'magit-buffer-diff-files)
       (toggle))
-     (t
-      (user-error "Cannot toggle file filter in this buffer")))))
+     ((user-error "Cannot toggle file filter in this buffer")))))
 
 (defun magit-diff-less-context (&optional count)
   "Decrease the context for diff hunks by COUNT lines."
@@ -1536,7 +1556,7 @@ instead."
                 3))
          (val magit-buffer-diff-args)
          (arg (seq-find (##string-match "^-U\\([0-9]+\\)?$" %) val))
-         (num (if-let ((str (and arg (match-string 1 arg))))
+         (num (if-let ((str (and arg (match-str 1 arg))))
                   (string-to-number str)
                 def))
          (val (delete arg val))
@@ -1546,6 +1566,14 @@ instead."
     (setq magit-buffer-diff-args val))
   (magit-refresh))
 
+(defun magit-diff-get-context ()
+  (string-to-number
+   (or (seq-some (##and (string-match "\\`-U\\([0-9]+\\)?\\'" %)
+                        (match-str 1 %))
+                 magit-buffer-diff-args)
+       (magit-get "diff.context")
+       "3")))
+
 (defun magit-diff-context-p ()
   (if-let ((arg (seq-find (##string-match "^-U\\([0-9]+\\)$" %)
                           magit-buffer-diff-args)))
@@ -1584,110 +1612,119 @@ Customize variable `magit-diff-refine-hunk' to change the default mode."
 ;;;; Visit Commands
 ;;;;; Dwim Variants
 
-(defun magit-diff-visit-file (file &optional other-window)
-  "From a diff visit the appropriate version of FILE.
-
-Display the buffer in the selected window.  With a prefix
-argument OTHER-WINDOW display the buffer in another window
-instead.
-
-The location of point inside the diff determines which file is
-being visited.  The visited version depends on what changes the
-diff is about.
-
-1. If the diff shows uncommitted changes (i.e., stage or unstaged
-   changes), then visit the file in the working tree (i.e., the
-   same \"real\" file that `find-file' would visit).  In all
-   other cases visit a \"blob\" (i.e., the version of a file as
-   stored in some commit).
-
-2. If point is on a removed line, then visit the blob for the
-   first parent of the commit that removed that line, i.e., the
-   last commit where that line still exists.
-
-3. If point is on an added or context line, then visit the blob
-   that adds that line, or if the diff shows from more than a
-   single commit, then visit the blob from the last of these
-   commits.
-
-In the file-visiting buffer also go to the line that corresponds
-to the line that point is on in the diff.
-
-Note that this command only works if point is inside a diff.
-In other cases `magit-find-file' (which see) has to be used."
-  (interactive (list (magit-diff--file-at-point t t) current-prefix-arg))
-  (magit-diff-visit-file--internal file nil
-                                   (if other-window
-                                       #'switch-to-buffer-other-window
-                                     #'pop-to-buffer-same-window)))
-
-(defun magit-diff-visit-file-other-window (file)
-  "From a diff visit the appropriate version of FILE in another window.
-Like `magit-diff-visit-file' but use
-`switch-to-buffer-other-window'."
-  (interactive (list (magit-diff--file-at-point t t)))
-  (magit-diff-visit-file--internal file nil #'switch-to-buffer-other-window))
-
-(defun magit-diff-visit-file-other-frame (file)
-  "From a diff visit the appropriate version of FILE in another frame.
-Like `magit-diff-visit-file' but use
-`switch-to-buffer-other-frame'."
-  (interactive (list (magit-diff--file-at-point t t)))
-  (magit-diff-visit-file--internal file nil #'switch-to-buffer-other-frame))
+(defun magit-diff-visit-file (&optional other-window)
+  "From a diff, visit the appropriate version of the file at point.
+
+Display the buffer in the selected window.  With a prefix argument,
+OTHER-WINDOW, instead display the buffer in another window.
+
+In the visited file or blob, go to the location corresponding to the
+location in the diff.
+
+If point is on an added or context line, visit the blob corresponding
+to our side (i.e., the new/right side).  If point is on a removed line,
+visit the blob corresponding to their side (i.e., the old/left side).
+
+This applies to diffs of staged and unstaged changes as well.  For
+staged changes the two sides are blobs from the index and the `HEAD'
+commit.  For unstaged changes the two sides are the actual file in
+the worktree and the blob from the index.
+
+To visit the file in the worktree, regardless of what the current diff
+is about, use \
+\\<magit-diff-section-map>\
+\\[magit-diff-visit-worktree-file] \
+(`magit-diff-visit-worktree-file').
+
+In the past \\`<return>' (this command) used to go to the file in the
+worktree, if point is on an added or context line of a diff showing
+staged changes.  Set `magit-diff-visit-prefer-worktree' to t to restore
+that behavior, but note that doing so makes the behavior inconsistent
+and you would give up on the ability to visit the index blob.  If you
+already use \\[magit-diff-visit-worktree-file] to jump to the live \
+file from committed changes,
+it might be better to retrain muscle memory to do the same from staged
+changes.
+
+This command only works when point is inside a diff; elsewhere use
+`magit-find-file'."
+  (interactive "P")
+  (magit-diff-visit-file--internal
+   (and magit-diff-visit-prefer-worktree
+        (memq (magit-diff--dwim) '(staged unstaged)))
+   (and other-window t)))
+
+(defun magit-diff-visit-file-other-window ()
+  "From a diff visit a version of the file at point in another window.
+Like `magit-diff-visit-file' but always display in another window."
+  (interactive)
+  (magit-diff-visit-file--internal
+   (and magit-diff-visit-prefer-worktree
+        (memq (magit-diff--dwim) '(staged unstaged)))
+   #'switch-to-buffer-other-window))
+
+(defun magit-diff-visit-file-other-frame ()
+  "From a diff visit a version of the file at point in another frame.
+Like `magit-diff-visit-file' but always display in another frame."
+  (interactive)
+  (magit-diff-visit-file--internal
+   (and magit-diff-visit-prefer-worktree
+        (memq (magit-diff--dwim) '(staged unstaged)))
+   #'switch-to-buffer-other-frame))
 
 ;;;;; Worktree Variants
 
-(defun magit-diff-visit-worktree-file (file &optional other-window)
-  "From a diff visit the worktree version of FILE.
+(defun magit-diff-visit-worktree-file (&optional other-window)
+  "From a diff visit the worktree version of the file at point.
 
-Display the buffer in the selected window.  With a prefix
-argument OTHER-WINDOW display the buffer in another window
-instead.
+Display the buffer in the selected window.  With a prefix argument,
+OTHER-WINDOW, display the buffer in another window instead.
 
 Visit the worktree version of the appropriate file.  The location
 of point inside the diff determines which file is being visited.
 
 Unlike `magit-diff-visit-file' always visits the \"real\" file in
-the working tree, i.e the \"current version\" of the file.
+the working tree, i.e., the \"current version\" of the file.
 
 In the file-visiting buffer also go to the line that corresponds
 to the line that point is on in the diff.  Lines that were added
 or removed in the working tree, the index and other commits in
 between are automatically accounted for."
-  (interactive (list (magit-file-at-point t t) current-prefix-arg))
-  (magit-diff-visit-file--internal file t
-                                   (if other-window
-                                       #'switch-to-buffer-other-window
-                                     #'pop-to-buffer-same-window)))
-
-(defun magit-diff-visit-worktree-file-other-window (file)
-  "From a diff visit the worktree version of FILE in another window.
-Like `magit-diff-visit-worktree-file' but use
-`switch-to-buffer-other-window'."
-  (interactive (list (magit-file-at-point t t)))
-  (magit-diff-visit-file--internal file t #'switch-to-buffer-other-window))
-
-(defun magit-diff-visit-worktree-file-other-frame (file)
-  "From a diff visit the worktree version of FILE in another frame.
-Like `magit-diff-visit-worktree-file' but use
-`switch-to-buffer-other-frame'."
-  (interactive (list (magit-file-at-point t t)))
-  (magit-diff-visit-file--internal file t #'switch-to-buffer-other-frame))
+  (interactive "P")
+  (magit-diff-visit-file--internal t (and other-window t)))
+
+(defun magit-diff-visit-worktree-file-other-window ()
+  "From a diff visit the file at point in another window.
+Like `magit-diff-visit-worktree-file' but display in another window."
+  (interactive)
+  (magit-diff-visit-file--internal t #'switch-to-buffer-other-window))
+
+(defun magit-diff-visit-worktree-file-other-frame ()
+  "From a diff visit the file at point in another frame.
+Like `magit-diff-visit-worktree-file' but display in another frame."
+  (interactive)
+  (magit-diff-visit-file--internal t #'switch-to-buffer-other-frame))
 
 ;;;;; Internal
 
-(defun magit-diff-visit-file--internal (file force-worktree fn)
+(defun magit-diff-visit-file--internal (force-worktree display)
   "From a diff visit the appropriate version of FILE.
-If FORCE-WORKTREE is non-nil, then visit the worktree version of
-the file, even if the diff is about a committed change.  Use FN
-to display the buffer in some window."
-  (if (file-accessible-directory-p file)
-      (magit-diff-visit-directory file force-worktree)
-    (pcase-let ((`(,buf ,pos)
-                 (magit-diff-visit-file--noselect file force-worktree)))
-      (funcall fn buf)
-      (magit-diff-visit-file--setup buf pos)
-      buf)))
+If FORCE-WORKTREE is non-nil, then visit the worktree version of the
+file, even if the diff is about a committed change.  DISPLAY controls
+how the buffer is displayed.  If nil display in the same window, if
+t display in another window, or if a function, use that to display."
+  (let ((file (or (magit-diff--file)
+                  (user-error "Cannot determine file to visit"))))
+    (if (file-accessible-directory-p file)
+        (magit-diff-visit-directory file display)
+      (pcase-let ((`(,buf ,pos)
+                   (magit-diff-visit-file--noselect force-worktree)))
+        (pcase display
+          ('nil (pop-to-buffer-same-window buf))
+          ('t   (switch-to-buffer-other-window buf))
+          (_    (funcall display buf)))
+        (magit-diff-visit-file--setup buf pos)
+        buf))))
 
 (defun magit-diff-visit-directory (directory &optional other-window)
   "Visit DIRECTORY in some window.
@@ -1706,107 +1743,77 @@ the Magit-Status buffer for DIRECTORY."
       (magit-status-setup-buffer directory))))
 
 (defun magit-diff-visit-file--setup (buf pos)
-  (if-let ((win (get-buffer-window buf 'visible)))
-      (with-selected-window win
-        (when pos
-          (unless (<= (point-min) pos (point-max))
-            (widen))
-          (goto-char pos))
-        (when (and buffer-file-name
-                   (magit-anything-unmerged-p buffer-file-name))
-          (smerge-start-session))
-        (run-hooks 'magit-diff-visit-file-hook))
-    (error "File buffer is not visible")))
-
-(defun magit-diff-visit-file--noselect (&optional file goto-worktree)
-  (unless file
-    (setq file (magit-diff--file-at-point t t)))
-  (let* ((hunk (magit-diff-visit--hunk))
-         (goto-from (and hunk
-                         (magit-diff-visit--goto-from-p hunk goto-worktree)))
-         (line (and hunk (magit-diff-hunk-line   hunk goto-from)))
-         (col  (and hunk (magit-diff-hunk-column hunk goto-from)))
-         (spec (magit-diff--dwim))
-         (rev  (if goto-from
-                   (magit-diff-visit--range-from spec)
-                 (magit-diff-visit--range-to spec)))
-         (buf  (if (or goto-worktree
-                       (equal magit-buffer-typearg "--no-index")
-                       (and (not (stringp rev))
-                            (or magit-diff-visit-avoid-head-blob
-                                (not goto-from))))
-                   (or (get-file-buffer file)
-                       (find-file-noselect file))
-                 (magit-find-file-noselect (if (stringp rev) rev "HEAD")
-                                           file))))
-    (if line
-        (with-current-buffer buf
-          (cond ((eq rev 'staged)
-                 (setq line (magit-diff-visit--offset file nil line)))
-                ((and goto-worktree
-                      (stringp rev))
-                 (setq line (magit-diff-visit--offset file rev line))))
-          (list buf (save-restriction
-                      (widen)
-                      (goto-char (point-min))
-                      (forward-line (1- line))
-                      (move-to-column col)
-                      (point))))
-      (list buf nil))))
-
-(defun magit-diff--file-at-point (&optional expand assert)
-  ;; This is a variation of magit-file-at-point.
-  (if-let* ((file-section (magit-section-case
-                            (file it)
-                            (hunk (oref it parent))))
-            (file (or (and (magit-section-match 'hunk)
-                           (magit-diff-visit--goto-from-p
-                            (magit-current-section) nil)
-                           (oref file-section source))
-                      (oref file-section value))))
-      (cond ((equal magit-buffer-typearg "--no-index")
-             (concat "/" file))
-            (expand (expand-file-name file (magit-toplevel)))
-            (file))
-    (when assert
-      (user-error "No file at point"))))
-
-(defun magit-diff-visit--hunk ()
-  (and-let* ((scope (magit-diff-scope))
-             (section (magit-current-section)))
-    (progn
-      (cl-case scope
-        ((file files)
-         (setq section (car (oref section children))))
-        (list
-         (setq section (car (oref section children)))
-         (when section
-           (setq section (car (oref section children))))))
-      (and
-       ;; Unmerged files appear in the list of staged changes
-       ;; but unlike in the list of unstaged changes no diffs
-       ;; are shown here.  In that case `section' is nil.
-       section
-       ;; Currently the `hunk' type is also abused for file
-       ;; mode changes, which we are not interested in here.
-       (not (equal (oref section value) '(chmod)))
-       section))))
-
-(defun magit-diff-visit--goto-from-p (section in-worktree)
-  (and magit-diff-visit-previous-blob
-       (not in-worktree)
-       (not (oref section combined))
-       (not (< (magit-point) (oref section content)))
-       (= (char-after (line-beginning-position)) ?-)))
-
-(defvar magit-diff-visit-jump-to-change t)
+  (with-selected-window (or (get-buffer-window buf) (selected-window))
+    (with-current-buffer buf
+      (when pos
+        (unless (<= (point-min) pos (point-max))
+          (widen))
+        (goto-char pos))
+      (when (and buffer-file-name
+                 (magit-anything-unmerged-p buffer-file-name))
+        (smerge-start-session))
+      (run-hooks 'magit-diff-visit-file-hook))))
+
+(defun magit-diff-visit-file--noselect (&optional goto-file)
+  (pcase-let*
+      ((`(,old ,new)  (magit-diff-visit--sides))
+       (goto-from     (and (not goto-file) (magit-diff-on-removed-line-p)))
+       (goto-file     (or goto-file (equal magit-buffer-typearg "--no-index")))
+       (`(,rev ,file) (if goto-from old new))
+       (buffer        (magit-find-file-noselect (if goto-file "{worktree}" rev)
+                                                file)))
+    (list buffer
+          (magit-diff-visit--position buffer rev file goto-from goto-file))))
+
+(defun magit-diff-visit--sides ()
+  (pcase-let* (((eieio source value)
+                (magit-diff--file-section))
+               (old-file (or source value))
+               (new-file value)
+               (spec (magit-diff--dwim))
+               (`(,old-rev . ,new-rev)
+                (pcase spec
+                  ((pred stringp)
+                   (magit-split-range spec t))
+                  (`(,(or 'commit 'stash) . ,rev)
+                   (cons (magit-rev-abbrev (concat rev "^"))
+                         (magit--abbrev-if-hash rev)))
+                  ('staged    (cons (magit-rev-abbrev "HEAD") "{index}"))
+                  ('unstaged  (cons (if (magit-anything-staged-p nil old-file)
+                                        "{index}"
+                                      (magit-rev-abbrev "HEAD"))
+                                    "{worktree}"))
+                  ('nil       (cons "{worktree}" "{worktree}"))
+                  ('unmerged  (cons "{worktree}" "{worktree}"))
+                  ('undefined (cons "{worktree}" "{worktree}")) ;--no-index
+                  (_          (error "BUG: Unexpected diff type %s" spec)))))
+    (when (equal magit-buffer-typearg "--no-index")
+      (setq old-file (concat "/" old-file))
+      (setq new-file (concat "/" new-file)))
+    (list (list old-rev old-file)
+          (list new-rev new-file))))
+
+(defun magit-diff-visit--position (buffer rev file goto-from goto-file)
+  (and-let ((hunk (magit-diff--hunk-section)))
+    (let ((line   (magit-diff-hunk-line   hunk goto-from))
+          (column (magit-diff-hunk-column hunk goto-from)))
+      (with-current-buffer buffer
+        (when (and goto-file (not (equal rev "{worktree}")))
+          (setq line (magit-diff-visit--offset
+                      file (if (equal rev "{index}") nil rev) line)))
+        (save-restriction
+          (widen)
+          (goto-char (point-min))
+          (forward-line (1- line))
+          (move-to-column column)
+          (point))))))
 
 (defun magit-diff-hunk-line (section goto-from)
   (save-excursion
     (goto-char (line-beginning-position))
     (with-slots (content combined from-ranges from-range to-range) section
       (when (or from-range to-range)
-        (when (and magit-diff-visit-jump-to-change (< (point) content))
+        (when (< (point) content)
           (goto-char content)
           (re-search-forward "^[-+]"))
         (+ (car (if goto-from from-range to-range))
@@ -1831,25 +1838,6 @@ the Magit-Status buffer for DIRECTORY."
     (max 0 (- (+ (current-column) 2)
               (length (oref section value))))))
 
-(defun magit-diff-visit--range-from (spec)
-  (cond ((consp spec)
-         (concat (cdr spec) "^"))
-        ((stringp spec)
-         (car (magit-split-range spec)))
-        (t
-         spec)))
-
-(defun magit-diff-visit--range-to (spec)
-  (if (symbolp spec)
-      spec
-    (let ((rev (if (consp spec)
-                   (cdr spec)
-                 (cdr (magit-split-range spec)))))
-      (if (and magit-diff-visit-avoid-head-blob
-               (magit-rev-head-p rev))
-          'unstaged
-        rev))))
-
 (defun magit-diff-visit--offset (file rev line)
   (let ((offset 0))
     (with-temp-buffer
@@ -1860,9 +1848,9 @@ the Magit-Status buffer for DIRECTORY."
         (while (re-search-forward
                 "^@@ -\\([0-9]+\\),\\([0-9]+\\) \\+\\([0-9]+\\),\\([0-9]+\\) @@.*\n"
                 nil t)
-          (let ((from-beg (string-to-number (match-string 1)))
-                (from-len (string-to-number (match-string 2)))
-                (  to-len (string-to-number (match-string 4))))
+          (let ((from-beg (string-to-number (match-str 1)))
+                (from-len (string-to-number (match-str 2)))
+                (  to-len (string-to-number (match-str 4))))
             (if (<= from-beg line)
                 (if (< (+ from-beg from-len) line)
                     (cl-incf offset (- to-len from-len))
@@ -1876,23 +1864,6 @@ the Magit-Status buffer for DIRECTORY."
               (throw 'found nil))))))
     (+ line offset)))
 
-;;;;; Movement
-
-(defun magit-jump-to-diffstat-or-diff ()
-  "Jump to the diffstat or diff.
-When point is on a file inside the diffstat section, then jump
-to the respective diff section, otherwise jump to the diffstat
-section or a child thereof."
-  (interactive)
-  (if-let ((section (magit-get-section
-                     (append (magit-section-case
-                               ([file diffstat] `((file . ,(oref it value))))
-                               (file `((file . ,(oref it value)) (diffstat)))
-                               (t '((diffstat))))
-                             (magit-section-ident magit-root-section)))))
-      (magit-section-goto section)
-    (user-error "No diffstat in this buffer")))
-
 ;;;; Scroll Commands
 
 (defun magit-diff-show-or-scroll-up ()
@@ -1933,8 +1904,7 @@ commit or stash at point, then prompt for a commit."
           (setq rev target)
           (setq cmd #'magit-show-commit)
           (setq buf (magit-get-mode-buffer 'magit-revision-mode)))))
-     (t
-      (magit-section-case
+     ((magit-section-case
         (branch
          (setq rev (magit-ref-maybe-qualify (oref it value)))
          (setq cmd #'magit-show-commit)
@@ -1999,8 +1969,91 @@ commit or stash at point, then prompt for a commit."
                (mapc #'magit-section-show-headings sections))
               ((seq-some #'magit-section-hidden-body children)
                (mapc #'magit-section-show-children sections))
-              (t
-               (mapc #'magit-section-hide sections)))))))
+              ((mapc #'magit-section-hide sections)))))))
+
+;;;; Jump Commands
+
+(transient-define-prefix magit-revision-jump (&optional menu)
+  "In a Magit-Revision buffer, jump to a section.
+Show a menu to choose a section, unless point is on a file
+heading, or with a prefix argument, in which case behave
+like 'magit-jump-to-diffstat-or-diff'."
+  [["Jump to"
+    ("h" magit-jump-to-revision-headers)
+    ("m" magit-jump-to-revision-message)
+    ("n" magit-jump-to-revision-notes)
+    ("s" magit-jump-to-revision-diffstat)
+    ("d" magit-jump-to-revision-diff)]
+   ["Jump using"
+    ("j" "Imenu" imenu)]]
+  (interactive (list (or (not (magit-section-match 'file))
+                         current-prefix-arg)))
+  (if menu
+      (transient-setup 'magit-revision-jump)
+    (magit-jump-to-diffstat-or-diff)))
+
+(magit-define-section-jumper magit-jump-to-revision-headers
+  "Headings" headers nil magit-insert-revision-headers)
+
+(magit-define-section-jumper magit-jump-to-revision-message
+  "Message" commit-message nil magit-insert-revision-message)
+
+(magit-define-section-jumper magit-jump-to-revision-notes
+  "Notes" notes nil magit-insert-revision-notes)
+
+(transient-define-suffix magit-jump-to-revision-diffstat (&optional expand)
+  :description "Diffstat"
+  :inapt-if-not (##cl-find-if (##eq (oref % type) 'diffstat)
+                              (oref magit-root-section children))
+  (interactive "P")
+  (cond-let
+    ([section (magit-get-section
+               (append (magit-section-case
+                         (file `((file . ,(oref it value)) (diffstat)))
+                         (hunk `((file . ,(magit-section-parent-value it))
+                                 (diffstat)))
+                         (t '((diffstat))))
+                       (magit-section-ident magit-root-section)))]
+     (goto-char (oref section start))
+     (when expand
+       (with-local-quit (magit-section-show section))
+       (recenter 0)))
+    ((message (format "No diff sections found")))))
+
+(transient-define-suffix magit-jump-to-revision-diff (&optional expand)
+  :description "Diff"
+  :inapt-if-not (##cl-find-if (##eq (oref % type) 'file)
+                              (oref magit-root-section children))
+  (interactive "P")
+  (cond-let
+    ([section (cl-find-if (##eq (oref % type) 'file)
+                          (oref magit-root-section children))]
+     (goto-char (oref section start))
+     (when expand
+       (with-local-quit (magit-section-show section))
+       (recenter 0)))
+    ((message (format "No diff sections found")))))
+
+(defun magit-jump-to-diffstat-or-diff (&optional expand)
+  "Jump to the diffstat or diff.
+When point is on a file inside the diffstat section, then jump
+to the respective diff section, otherwise jump to the diffstat
+section or a child thereof."
+  (interactive)
+  (cond-let
+    ([section (magit-get-section
+               (append (magit-section-case
+                         ([file diffstat] `((file . ,(oref it value))))
+                         (file `((file . ,(oref it value)) (diffstat)))
+                         (hunk `((file . ,(magit-section-parent-value it))
+                                 (diffstat)))
+                         (t '((diffstat))))
+                       (magit-section-ident magit-root-section)))]
+     (goto-char (oref section start))
+     (when expand
+       (with-local-quit (magit-section-show section))
+       (recenter 0)))
+    ((user-error "No diffstat in this buffer"))))
 
 ;;; Diff Mode
 
@@ -2011,6 +2064,7 @@ commit or stash at point, then prompt for a commit."
   "C-c C-b" #'magit-go-backward
   "C-c C-f" #'magit-go-forward
   "SPC"     #'scroll-up
+  "S-SPC"   #'scroll-down
   "DEL"     #'scroll-down
   "j"       #'magit-jump-to-diffstat-or-diff
   "<remap> <write-file>" #'magit-patch-save)
@@ -2060,23 +2114,23 @@ Staging and applying changes is documented in info node
   (magit-set-header-line-format
    (if (equal magit-buffer-typearg "--no-index")
        (apply #'format "Differences between %s and %s" magit-buffer-diff-files)
-     (concat (if magit-buffer-range
-                 (if (string-match-p "\\(\\.\\.\\|\\^-\\)"
-                                     magit-buffer-range)
-                     (format "Changes in %s" magit-buffer-range)
-                   (let ((msg "Changes from %s to %s")
-                         (end (if (equal magit-buffer-typearg "--cached")
-                                  "index"
-                                "working tree")))
-                     (if (member "-R" magit-buffer-diff-args)
-                         (format msg end magit-buffer-range)
-                       (format msg magit-buffer-range end))))
-               (cond ((equal magit-buffer-typearg "--cached")
-                      "Staged changes")
-                     ((and (magit-repository-local-get 'this-commit-command)
-                           (not (magit-anything-staged-p)))
-                      "Uncommitting changes")
-                     (t "Unstaged changes")))
+     (concat (cond (magit-buffer-range
+                    (if (string-match-p "\\(\\.\\.\\|\\^-\\)"
+                                        magit-buffer-range)
+                        (format "Changes in %s" magit-buffer-range)
+                      (let ((msg "Changes from %s to %s")
+                            (end (if (equal magit-buffer-typearg "--cached")
+                                     "index"
+                                   "working tree")))
+                        (if (member "-R" magit-buffer-diff-args)
+                            (format msg end magit-buffer-range)
+                          (format msg magit-buffer-range end)))))
+                   ((equal magit-buffer-typearg "--cached")
+                    "Staged changes")
+                   ((and (magit-repository-local-get 'this-commit-command)
+                         (not (magit-anything-staged-p)))
+                    "Uncommitting changes")
+                   ("Unstaged changes"))
              (pcase (length magit-buffer-diff-files)
                (0)
                (1 (concat " in file " (car magit-buffer-diff-files)))
@@ -2092,8 +2146,7 @@ Staging and applying changes is documented in info node
                 (delq nil (list magit-buffer-range magit-buffer-typearg)))
                ((equal magit-buffer-typearg "--cached")
                 (list 'staged))
-               (t
-                (list 'unstaged magit-buffer-typearg)))
+               ((list 'unstaged magit-buffer-typearg)))
          (and magit-buffer-diff-files (cons "--" magit-buffer-diff-files))))
 
 (cl-defmethod magit-menu-common-value ((_section magit-diff-section))
@@ -2164,31 +2217,7 @@ keymap is the parent of their keymaps."
     map)
   "Keymap for `hunk' sections.")
 
-(defconst magit-diff-conflict-headline-re
-  (concat "^" (regexp-opt
-               ;; Defined in merge-tree.c in this order.
-               '("merged"
-                 "added in remote"
-                 "added in both"
-                 "added in local"
-                 "removed in both"
-                 "changed in both"
-                 "removed in local"
-                 "removed in remote"))))
-
-(defconst magit-diff-headline-re
-  (concat "^\\(@@@?\\|diff\\|Submodule\\|"
-          "\\* Unmerged path\\|"
-          (substring magit-diff-conflict-headline-re 1)
-          "\\)"))
-
-(defconst magit-diff-statline-re
-  (concat "^ ?"
-          "\\(.*\\)"     ; file
-          "\\( +| +\\)"  ; separator
-          "\\([0-9]+\\|Bin\\(?: +[0-9]+ -> [0-9]+ bytes\\)?$\\) ?"
-          "\\(\\+*\\)"   ; add
-          "\\(-*\\)$"))  ; del
+;;; Diff Insert
 
 (defvar magit-diff--reset-non-color-moved
   (list
@@ -2245,10 +2274,38 @@ keymap is the parent of their keymaps."
               args)
     args))
 
+;;; Diff Wash
+
+(defconst magit-diff-conflict-headline-re
+  (concat "^" (regexp-opt
+               ;; Defined in merge-tree.c in this order.
+               '("merged"
+                 "added in remote"
+                 "added in both"
+                 "added in local"
+                 "removed in both"
+                 "changed in both"
+                 "removed in local"
+                 "removed in remote"))))
+
+(defconst magit-diff-headline-re
+  (concat "^\\(@@@?\\|diff\\|Submodule\\|"
+          "\\* Unmerged path\\|"
+          (substring magit-diff-conflict-headline-re 1)
+          "\\)"))
+
+(defconst magit-diff-statline-re
+  (concat "^ ?"
+          "\\(.*\\)"     ; file
+          "\\( +| +\\)"  ; separator
+          "\\([0-9]+\\|Bin\\(?: +[0-9]+ -> [0-9]+ bytes\\)?$\\) ?"
+          "\\(\\+*\\)"   ; add
+          "\\(-*\\)$"))  ; del
+
 (defun magit-diff-use-window-width-as-stat-width ()
   "Use the `window-width' as the value of `--stat-width'."
-  (and-let* ((window (get-buffer-window (current-buffer) 'visible)))
-    (list (format "--stat-width=%d" (window-width window)))))
+  (and$ (get-buffer-window (current-buffer) 'visible)
+        (list (format "--stat-width=%d" (window-width $)))))
 
 (defun magit-diff-wash-diffs (args &optional limit)
   (run-hooks 'magit-diff-wash-diffs-hook)
@@ -2271,13 +2328,13 @@ keymap is the parent of their keymaps."
         (while (looking-at "^gpg: ")
           (cond
            ((looking-at "^gpg: Good signature from")
-            (setq title (propertize
+            (setq title (magit--propertize-face
                          (buffer-substring (point) (line-end-position))
-                         'face 'magit-signature-good)))
+                         'magit-signature-good)))
            ((looking-at "^gpg: Can't check signature")
-            (setq title (propertize
+            (setq title (magit--propertize-face
                          (buffer-substring (point) (line-end-position))
-                         'face '(italic bold)))))
+                         '(italic bold)))))
           (forward-line))
         (setq end (point-marker)))
       (magit-insert-section (signature object title)
@@ -2290,7 +2347,7 @@ keymap is the parent of their keymaps."
 (defun magit-diff-wash-diffstat ()
   (let (heading (beg (point)))
     (when (re-search-forward "^ ?\\([0-9]+ +files? change[^\n]*\n\\)" nil t)
-      (setq heading (match-string 1))
+      (setq heading (match-str 1))
       (magit-delete-match)
       (goto-char beg)
       (magit-insert-section (diffstat)
@@ -2299,13 +2356,13 @@ keymap is the parent of their keymaps."
         (let (files)
           (while (looking-at "^[-0-9]+\t[-0-9]+\t\\(.+\\)$")
             (push (magit-decode-git-path
-                   (let ((f (match-string 1)))
-                     (cond
-                      ((string-match "{.* => \\(.*\\)}" f)
-                       (replace-match (match-string 1 f) nil t f))
-                      ((string-match " => " f)
-                       (substring f (match-end 0)))
-                      (t f))))
+                   (cond-let
+                     [[file (match-str 1)]]
+                     ((string-match "{.* => \\(.*\\)}" file)
+                      (replace-match (match-str 1 file) nil t file))
+                     ((string-match " => " file)
+                      (substring file (match-end 0)))
+                     (file)))
                   files)
             (magit-delete-line))
           (setq files (nreverse files))
@@ -2313,7 +2370,7 @@ keymap is the parent of their keymaps."
             (magit-bind-match-strings (file sep cnt add del) nil
               (magit-delete-line)
               (when (string-match " +$" file)
-                (setq sep (concat (match-string 0 file) sep))
+                (setq sep (concat (match-str 0 file) sep))
                 (setq file (substring file 0 (match-beginning 0))))
               (let ((le (length file)) ld)
                 (setq file (magit-decode-git-path file))
@@ -2340,7 +2397,7 @@ keymap is the parent of their keymaps."
    ((looking-at "^Submodule")
     (magit-diff-wash-submodule))
    ((looking-at "^\\* Unmerged path \\(.*\\)")
-    (let ((file (magit-decode-git-path (match-string 1))))
+    (let ((file (magit-decode-git-path (match-str 1))))
       (magit-delete-line)
       (unless (and (derived-mode-p 'magit-status-mode)
                    (not (member "--cached" args)))
@@ -2359,7 +2416,7 @@ keymap is the parent of their keymaps."
           (insert ?\n))))
     t)
    ((looking-at magit-diff-conflict-headline-re)
-    (let ((long-status (match-string 0))
+    (let ((long-status (match-str 0))
           (status "BUG")
           file orig base)
       (if (equal long-status "merged")
@@ -2392,43 +2449,45 @@ keymap is the parent of their keymaps."
    ((looking-at "^diff --\
 \\(?:\\(?1:git\\) \\(?:\\(?2:.+?\\) \\2\\)?\
 \\|\\(?:cc\\|combined\\) \\(?3:.+\\)\\)")
-    (let ((status (cond ((equal (match-string 1) "git")        "modified")
+    (let ((status (cond ((equal (match-str 1) "git")           "modified")
                         ((derived-mode-p 'magit-revision-mode) "resolved")
                         (t                                     "unmerged")))
           (orig nil)
-          (file (or (match-string 2) (match-string 3)))
+          (file (or (match-str 2) (match-str 3)))
           (header (list (buffer-substring-no-properties
                          (line-beginning-position) (1+ (line-end-position)))))
           (modes nil)
           (rename nil)
           (binary nil))
       (magit-delete-line)
-      (while (not (or (eobp) (looking-at magit-diff-headline-re)))
+      (while (not (or (eobp)
+                      (looking-at magit-diff-headline-re)
+                      (looking-at magit-log-heading-re)))
         (cond
          ((looking-at "old mode \\(?:[^\n]+\\)\nnew mode \\(?:[^\n]+\\)\n")
-          (setq modes (match-string 0)))
+          (setq modes (match-str 0)))
          ((looking-at "deleted file .+\n")
           (setq status "deleted"))
          ((looking-at "new file .+\n")
           (setq status "new file"))
          ((looking-at "rename from \\(.+\\)\nrename to \\(.+\\)\n")
-          (setq rename (match-string 0))
-          (setq orig (match-string 1))
-          (setq file (match-string 2))
+          (setq rename (match-str 0))
+          (setq orig (match-str 1))
+          (setq file (match-str 2))
           (setq status "renamed"))
          ((looking-at "copy from \\(.+\\)\ncopy to \\(.+\\)\n")
-          (setq orig (match-string 1))
-          (setq file (match-string 2))
+          (setq orig (match-str 1))
+          (setq file (match-str 2))
           (setq status "new file"))
          ((looking-at "similarity index .+\n"))
          ((looking-at "dissimilarity index .+\n"))
          ((looking-at "index .+\n"))
          ((looking-at "--- \\(.+?\\)\t?\n")
-          (unless (equal (match-string 1) "/dev/null")
-            (setq orig (match-string 1))))
+          (unless (equal (match-str 1) "/dev/null")
+            (setq orig (match-str 1))))
          ((looking-at "\\+\\+\\+ \\(.+?\\)\t?\n")
-          (unless (equal (match-string 1) "/dev/null")
-            (setq file (match-string 1))))
+          (unless (equal (match-str 1) "/dev/null")
+            (setq file (match-str 1))))
          ((looking-at "Binary files .+ and .+ differ\n")
           (setq binary t))
          ((looking-at "Binary files differ\n")
@@ -2438,9 +2497,9 @@ keymap is the parent of their keymaps."
          ((error "BUG: Unknown extended header: %S"
                  (buffer-substring (point) (line-end-position)))))
         ;; These headers are treated as some sort of special hunk.
-        (unless (or (string-prefix-p "old mode" (match-string 0))
-                    (string-prefix-p "rename"   (match-string 0)))
-          (push (match-string 0) header))
+        (unless (or (string-prefix-p "old mode" (match-str 0))
+                    (string-prefix-p "rename"   (match-str 0)))
+          (push (match-str 0) header))
         (magit-delete-match))
       (when orig
         (setq orig (magit-decode-git-path orig)))
@@ -2456,7 +2515,7 @@ keymap is the parent of their keymaps."
         (setq header (list (save-excursion
                              (string-match "diff [^ ]+" (car header))
                              (format "%s %s %s\n"
-                                     (match-string 0 (car header))
+                                     (match-str 0 (car header))
                                      (or orig file)
                                      (or file orig)))
                            (format "--- %s\n" (or orig "/dev/null"))
@@ -2482,10 +2541,10 @@ keymap is the parent of their keymaps."
              (format " (%s)" (if binary "binary" long-status)))))
     (when modes
       (magit-insert-section (hunk '(chmod))
-        (magit-insert-heading (propertize modes 'face 'default))))
+        (magit-insert-heading (magit--propertize-face modes 'default))))
     (when rename
       (magit-insert-section (hunk '(rename))
-        (magit-insert-heading (propertize rename 'face 'default))))
+        (magit-insert-heading (magit--propertize-face rename 'default))))
     (magit-wash-sequence #'magit-diff-wash-hunk)))
 
 (defun magit-format-file (kind file face &optional status orig)
@@ -2501,44 +2560,43 @@ keymap is the parent of their keymaps."
   "Show the status, filename and icon (using the `all-the-icons' package).
 You have to explicitly install the `all-the-icons' package, else this
 function errors."
-  (cl-flet ((icon (if (or (eq kind 'module) (string-suffix-p "/" file))
-                      'all-the-icons-icon-for-dir
-                    'all-the-icons-icon-for-file)))
-    (cl-letf (((symbol-function 'all-the-icons-dir-is-submodule)
-               (if (eq kind 'module)
-                   (lambda (_) t)
-                 (symbol-function 'all-the-icons-dir-is-submodule))))
-      (propertize (concat (and status (format "%-11s" status))
-                          (if orig
-                              (format "%s %s -> %s %s"
-                                      (icon orig) orig
-                                      (icon file) file)
-                            (format "%s %s" (icon file) file)))
-                  'font-lock-face face))))
+  (magit--get-file-icon kind file face status orig
+                        'all-the-icons-icon-for-file
+                        'all-the-icons-icon-for-dir
+                        'all-the-icons-dir-is-submodule))
 
 (defun magit-format-file-nerd-icons (kind file face &optional status orig)
   "Show the status, filename and icon (using the `nerd-icons' package).
 You have to explicitly install the `nerd-icons' package, else this
 function errors."
+  (magit--get-file-icon kind file face status orig
+                        'nerd-icons-icon-for-file
+                        'nerd-icons-icon-for-dir
+                        'nerd-icons-dir-is-submodule))
+
+(defun magit--get-file-icon ( kind file face status orig
+                              icon-for-file icon-for-dir dir-is-submodule)
   (cl-flet ((icon (if (or (eq kind 'module) (string-suffix-p "/" file))
-                      'nerd-icons-icon-for-dir
-                    'nerd-icons-icon-for-file)))
-    (cl-letf (((symbol-function 'nerd-icons-dir-is-submodule)
+                      icon-for-dir
+                    icon-for-file)))
+    (cl-letf (((symbol-function dir-is-submodule)
                (if (eq kind 'module)
                    (lambda (_) t)
-                 (symbol-function 'nerd-icons-dir-is-submodule))))
-      (propertize (concat (and status (format "%-11s" status))
-                          (if orig
-                              (format "%s %s -> %s %s"
-                                      (icon orig) orig
-                                      (icon file) file)
-                            (format "%s %s" (icon file) file)))
-                  'font-lock-face face))))
+                 (symbol-function dir-is-submodule))))
+      (if orig
+          (format (magit--propertize-face "%s%s %s -> %s %s" face)
+                  (if status (format "%-11s" status) "")
+                  (icon orig) orig
+                  (icon file) file)
+        (format (magit--propertize-face "%s%s %s" face)
+                (if status (format "%-11s" status) "")
+                (icon file)
+                file)))))
 
 (defun magit-diff-wash-submodule ()
   ;; See `show_submodule_summary' in submodule.c and "this" commit.
   (when (looking-at "^Submodule \\([^ ]+\\)")
-    (let ((module (match-string 1))
+    (let ((module (match-str 1))
           untracked modified)
       (when (looking-at "^Submodule [^ ]+ contains untracked content$")
         (magit-delete-line)
@@ -2548,7 +2606,7 @@ function errors."
         (setq modified t))
       (cond
        ((and (looking-at "^Submodule \\([^ ]+\\) \\([^ :]+\\)\\( (rewind)\\)?:$")
-             (equal (match-string 1) module))
+             (equal (match-str 1) module))
         (magit-bind-match-strings (_module range rewind) nil
           (magit-delete-line)
           (while (looking-at "^  \\([<>]\\) \\(.*\\)$")
@@ -2563,7 +2621,7 @@ function errors."
               " ("
               (cond (rewind "rewind")
                     ((string-search "..." range) "non-ff")
-                    (t "new commits"))
+                    ("new commits"))
               (and (or modified untracked)
                    (concat ", "
                            (and modified "modified")
@@ -2579,7 +2637,7 @@ function errors."
                   "log" "--oneline" "--left-right" range)
                 (delete-char -1))))))
        ((and (looking-at "^Submodule \\([^ ]+\\) \\([^ ]+\\) (\\([^)]+\\))$")
-             (equal (match-string 1) module))
+             (equal (match-str 1) module))
         (magit-bind-match-strings (_module _range msg) nil
           (magit-delete-line)
           (magit-insert-section (module module)
@@ -2600,7 +2658,7 @@ function errors."
 
 (defun magit-diff-wash-hunk ()
   (when (looking-at "^@\\{2,\\} \\(.+?\\) @\\{2,\\}\\(?: \\(.*\\)\\)?")
-    (let* ((heading  (match-string 0))
+    (let* ((heading  (match-str 0))
            (ranges   (mapcar
                       (lambda (str)
                         (let ((range
@@ -2610,8 +2668,8 @@ function errors."
                           (if (length= range 1)
                               (nconc range (list 1))
                             range)))
-                      (split-string (match-string 1))))
-           (about    (match-string 2))
+                      (split-string (match-str 1))))
+           (about    (match-str 2))
            (combined (length= ranges 3))
            (value    (cons about ranges)))
       (magit-delete-line)
@@ -2639,6 +2697,11 @@ function errors."
 
 ;;; Revision Mode
 
+(defvar-keymap magit-revision-mode-map
+  :doc "Keymap for `magit-revision-mode'."
+  :parent magit-diff-mode-map
+  "j" #'magit-revision-jump)
+
 (define-derived-mode magit-revision-mode magit-diff-mode "Magit Rev"
   "Mode for looking at a Git commit.
 
@@ -2692,6 +2755,8 @@ Staging and applying changes is documented in info node
 (cl-defmethod magit-buffer-value (&context (major-mode magit-revision-mode))
   (cons magit-buffer-revision magit-buffer-diff-files))
 
+;;; Revision Sections
+
 (defun magit-insert-revision-diff ()
   "Insert the diff into this `magit-revision-mode' buffer."
   (magit--insert-diff t
@@ -2722,8 +2787,8 @@ or a ref which is not a branch, then it inserts nothing."
         (delete-region beg (point)))
       (looking-at "^tagger \\([^<]+\\) <\\([^>]+\\)")
       (let ((heading (format "Tagger: %s <%s>"
-                             (match-string 1)
-                             (match-string 2))))
+                             (match-str 1)
+                             (match-str 2))))
         (magit-delete-line)
         (magit-insert-heading
           (propertize heading 'font-lock-face
@@ -2763,21 +2828,21 @@ or a ref which is not a branch, then it inserts nothing."
   (magit-insert-section
       ( commit-message nil nil
         :heading-highlight-face 'magit-diff-revision-summary-highlight)
-    (if-let* ((rev magit-buffer-revision)
-              (msg (with-temp-buffer
-                     (save-excursion (magit-rev-insert-format "%B" rev))
-                     (magit-revision--wash-message))))
-        (progn
-          (save-excursion (insert msg))
-          (magit-revision--wash-message-hashes)
-          (save-excursion
-            (magit--add-face-text-property (point)
-                                           (progn (forward-line) (point))
-                                           'magit-diff-revision-summary
-                                           t nil t)
-            (magit-insert-heading))
-          (goto-char (point-max)))
-      (insert "(no message)\n"))))
+    (cond-let*
+      ([rev magit-buffer-revision]
+       [msg (with-temp-buffer
+              (save-excursion (magit-rev-insert-format "%B" rev))
+              (magit-revision--wash-message))]
+       (save-excursion (insert msg))
+       (magit-revision--wash-message-hashes)
+       (save-excursion
+         (magit--add-face-text-property (point)
+                                        (progn (forward-line) (point))
+                                        'magit-diff-revision-summary
+                                        t nil t)
+         (magit-insert-heading))
+       (goto-char (point-max)))
+      ((insert "(no message)\n")))))
 
 (defun magit-insert-revision-notes ()
   "Insert commit notes into a revision buffer."
@@ -2878,9 +2943,8 @@ or a ref which is not a branch, then it inserts nothing."
   "Insert headers about the commit into a revision buffer."
   (magit-insert-section (headers)
     (magit-insert-heading nil
-      (and-let* ((string (magit-rev-format "%D" magit-buffer-revision
-                                           "--decorate=full")))
-        (concat (magit-format-ref-labels string) " "))
+      (and$ (magit-rev-format "%D" magit-buffer-revision "--decorate=full")
+            (concat (magit-format-ref-labels $) " "))
       (propertize
        (magit-rev-parse (magit--rev-dereference magit-buffer-revision))
        'font-lock-face 'magit-hash))
@@ -2906,7 +2970,7 @@ or a ref which is not a branch, then it inserts nothing."
         (magit--insert-related-refs
          magit-buffer-revision "--contains" "Contained"
          (memq magit-revision-insert-related-refs '(all mixed))))
-      (when-let (((magit-revision-insert-related-refs-display-p 'follows))
+      (when-let ((_(magit-revision-insert-related-refs-display-p 'follows))
                  (follows (magit-get-current-tag magit-buffer-revision t)))
         (let ((tag (car  follows))
               (cnt (cadr follows)))
@@ -2916,7 +2980,7 @@ or a ref which is not a branch, then it inserts nothing."
                      (propertize tag 'font-lock-face 'magit-tag)
                      (propertize (number-to-string cnt)
                                  'font-lock-face 'magit-branch-local))))))
-      (when-let (((magit-revision-insert-related-refs-display-p 'precedes))
+      (when-let ((_(magit-revision-insert-related-refs-display-p 'precedes))
                  (precedes (magit-get-next-tag magit-buffer-revision t)))
         (let ((tag (car  precedes))
               (cnt (cadr precedes)))
@@ -2967,9 +3031,9 @@ Refer to user option `magit-revision-insert-related-refs-display-alist'."
 (defun magit-insert-revision-gravatar (beg rev email regexp)
   (save-excursion
     (goto-char beg)
-    (when-let (((re-search-forward regexp nil t))
+    (when-let ((_(re-search-forward regexp nil t))
                (window (get-buffer-window)))
-      (let* ((column   (length (match-string 0)))
+      (let* ((column   (length (match-str 0)))
              (font-obj (query-font (font-at (point) window)))
              (size     (* 2 (+ (aref font-obj 4)
                                (aref font-obj 5))))
@@ -2984,33 +3048,34 @@ Refer to user option `magit-revision-insert-related-refs-display-alist'."
                                    align-to column)))))))
 
 (defun magit-insert-revision-gravatar-cb (image size rev marker align-to column)
-  (unless (eq image 'error)
-    (when-let ((buffer (marker-buffer marker)))
-      (with-current-buffer buffer
-        (save-excursion
-          (goto-char marker)
-          ;; The buffer might display another revision by now or
-          ;; it might have been refreshed, in which case another
-          ;; process might already have inserted the image.
-          (when (and (equal rev magit-buffer-revision)
-                     (not (eq (car-safe
-                               (car-safe
-                                (get-text-property (point) 'display)))
-                              'image)))
-            (setf (image-property image :ascent) 'center)
-            (setf (image-property image :relief) 1)
-            (setf (image-property image :scale)  1)
-            (setf (image-property image :height) size)
-            (let ((top (list image '(slice 0.0 0.0 1.0 0.5)))
-                  (bot (list image '(slice 0.0 0.5 1.0 1.0)))
-                  (align `((space :align-to ,align-to))))
-              (let ((inhibit-read-only t))
-                (insert (propertize " " 'display top))
-                (insert (propertize " " 'display align))
-                (forward-line)
-                (forward-char column)
-                (insert (propertize " " 'display bot))
-                (insert (propertize " " 'display align))))))))))
+  (cond-let
+    ((eq image 'error))
+    ([buffer (marker-buffer marker)]
+     (with-current-buffer buffer
+       (save-excursion
+         (goto-char marker)
+         ;; The buffer might display another revision by now or
+         ;; it might have been refreshed, in which case another
+         ;; process might already have inserted the image.
+         (when (and (equal rev magit-buffer-revision)
+                    (not (eq (car-safe
+                              (car-safe
+                               (get-text-property (point) 'display)))
+                             'image)))
+           (setf (image-property image :ascent) 'center)
+           (setf (image-property image :relief) 1)
+           (setf (image-property image :scale)  1)
+           (setf (image-property image :height) size)
+           (let ((top (list image '(slice 0.0 0.0 1.0 0.5)))
+                 (bot (list image '(slice 0.0 0.5 1.0 1.0)))
+                 (align `((space :align-to ,align-to))))
+             (let ((inhibit-read-only t))
+               (insert (propertize " " 'display top))
+               (insert (propertize " " 'display align))
+               (forward-line)
+               (forward-char column)
+               (insert (propertize " " 'display bot))
+               (insert (propertize " " 'display align))))))))))
 
 ;;; Merge-Preview Mode
 
@@ -3068,14 +3133,14 @@ It the SECTION has a different type, then do nothing."
                           (forward-line -1)
                           (regexp-quote (buffer-substring-no-properties
                                          beg (line-end-position))))
-                         (t t))))))))
+                         (t))))))))
 
 (cl-defmethod magit-section-goto-successor ((section magit-hunk-section)
                                             line char &optional arg)
   (or (magit-section-goto-successor--same section line char)
-      (and-let* ((parent (magit-get-section
-                          (magit-section-ident
-                           (oref section parent)))))
+      (and-let ((parent (magit-get-section
+                         (magit-section-ident
+                          (oref section parent)))))
         (let* ((children (oref parent children))
                (siblings (magit-section-siblings section 'prev))
                (previous (nth (length siblings) children)))
@@ -3141,9 +3206,7 @@ It the SECTION has a different type, then do nothing."
         "diff" "--cached" magit-buffer-diff-args "--no-prefix"
         "--" magit-buffer-diff-files))))
 
-;;; Diff Type
-
-(defvar magit--diff-use-recorded-type-p t)
+;;; Diff Information
 
 (defun magit-diff-type (&optional section)
   "Return the diff type of SECTION.
@@ -3173,8 +3236,7 @@ Do not confuse this with `magit-diff-scope' (which see)."
           ((derived-mode-p 'magit-diff-mode)
            (let ((range magit-buffer-range)
                  (const magit-buffer-typearg))
-             (cond ((and magit--diff-use-recorded-type-p
-                         magit-buffer-diff-type))
+             (cond (magit-buffer-diff-type)
                    ((equal const "--no-index") 'undefined)
                    ((or (not range)
                         (equal range "HEAD")
@@ -3186,29 +3248,28 @@ Do not confuse this with `magit-diff-scope' (which see)."
                     (if (magit-rev-head-p range)
                         'staged
                       'undefined)) ; i.e., committed and staged
-                   (t 'committed))))
+                   ('committed))))
           ((derived-mode-p 'magit-status-mode)
-           (let ((stype (oref section type)))
-             (if (memq stype '(staged unstaged tracked untracked))
-                 stype
-               (pcase stype
-                 ((or 'file 'module)
-                  (let* ((parent (oref section parent))
-                         (type   (oref parent type)))
-                    (if (memq type '(file module))
-                        (magit-diff-type parent)
-                      type)))
-                 ('hunk (thread-first section
-                          (oref parent)
-                          (oref parent)
-                          (oref type)))))))
+           (pcase (oref section type)
+             ((and type (or 'staged 'unstaged 'tracked 'untracked))
+              type)
+             ((or 'file 'module)
+              (let* ((parent (oref section parent))
+                     (type   (oref parent type)))
+                (if (memq type '(file module))
+                    (magit-diff-type parent)
+                  type)))
+             ('hunk (thread-first section
+                      (oref parent)
+                      (oref parent)
+                      (oref type)))))
           ((derived-mode-p 'magit-log-mode)
            (if (or (and (magit-section-match 'commit section)
                         (oref section children))
                    (magit-section-match [* file commit] section))
                'committed
              'undefined))
-          (t 'undefined))))
+          ('undefined))))
 
 (cl-defun magit-diff-scope (&optional (section nil ssection) strict)
   "Return the diff scope of SECTION or the selected section(s).
@@ -3236,8 +3297,8 @@ actually a `diff' but a `diffstat' section."
     (when (and section
                (or (not strict)
                    (and (not (eq (magit-diff-type section) 'untracked))
-                        (not (eq (and-let* ((parent (oref section parent)))
-                                   (oref parent type))
+                        (not (eq (and$ (oref section parent)
+                                       (oref $ type))
                                  'diffstat)))))
       (pcase (list (oref section type)
                    (and siblings t)
@@ -3265,7 +3326,42 @@ actually a `diff' but a `diffstat' section."
                      (byte-code-function-p last-command))
                  (eq (region-end) (region-beginning))))))
 
+(defun magit-diff--hunk-section ()
+  (and-let* ((section (magit-current-section))
+             (scope (magit-diff-scope section)))
+    ;; Currently the `hunk' type is also abused for file
+    ;; mode changes, which we are not interested in here.
+    (cl-flet ((first-hunk (file-section)
+                (seq-find (##not (equal (oref % value) '(chmod)))
+                          (oref file-section children))))
+      (pcase scope
+        ('hunk section)
+        ('file (first-hunk section))
+        ('list (and$ (car (oref section children))
+                     (first-hunk $)))
+        ('module nil)))))
+
+(defun magit-diff--file-section ()
+  (and-let* ((section (magit-current-section))
+             (scope (magit-diff-scope section)))
+    (pcase scope
+      ('hunk (oref section parent))
+      ('file section)
+      ('list (car (oref section children)))
+      ('module section))))
+
+(defun magit-diff--file ()
+  (and-let* ((file-section (magit-diff--file-section))
+             (file (or (and (magit-section-match 'hunk)
+                            (magit-diff-on-removed-line-p)
+                            (oref file-section source))
+                       (oref file-section value))))
+    (if (equal magit-buffer-typearg "--no-index")
+        (concat "/" file)
+      (expand-file-name file (magit-toplevel)))))
+
 ;;; Hunk Paint
+;;;; Paint
 
 (cl-defmethod magit-section-paint ((section magit-hunk-section) highlight)
   (unless magit-diff-highlight-hunk-body
@@ -3286,7 +3382,7 @@ actually a `diff' but a `diffstat' section."
        (point) (1+ (line-end-position)) 'font-lock-face
        (cond
         ((looking-at "^\\+\\+?\\([<=|>]\\)\\{7\\}")
-         (setq stage (pcase (list (match-string 1) highlight)
+         (setq stage (pcase (list (match-str 1) highlight)
                        ('("<" nil) 'magit-diff-our)
                        ('("<"   t) 'magit-diff-our-highlight)
                        ('("|" nil) 'magit-diff-base)
@@ -3294,7 +3390,9 @@ actually a `diff' but a `diffstat' section."
                        ('("=" nil) 'magit-diff-their)
                        ('("="   t) 'magit-diff-their-highlight)
                        ('(">" nil) nil)))
-         'magit-diff-conflict-heading)
+         (if highlight
+             'magit-diff-conflict-heading-highlight
+           'magit-diff-conflict-heading))
         ((looking-at (if merging "^\\(\\+\\| \\+\\)" "^\\+"))
          (magit-diff-paint-tab merging tab-width)
          (magit-diff-paint-whitespace merging 'added diff-type)
@@ -3309,37 +3407,35 @@ actually a `diff' but a `diffstat' section."
          (magit-diff-paint-whitespace merging 'context diff-type)
          (if highlight 'magit-diff-context-highlight 'magit-diff-context))))
       (forward-line)))
-  (magit-diff-update-hunk-refinement section)
+  (when (eq magit-diff-refine-hunk 'all)
+    (magit-diff-update-hunk-refinement section))
   (oset section painted (if highlight 'highlight 'plain)))
 
+;;;; Whitespace
+
 (defvar magit-diff--tab-width-cache nil)
 
 (defun magit-diff-tab-width (file)
-  (setq file (expand-file-name file))
-  (cl-flet ((cache (value)
-              (let ((elt (assoc file magit-diff--tab-width-cache)))
-                (if elt
-                    (setcdr elt value)
-                  (setq magit-diff--tab-width-cache
-                        (cons (cons file value)
-                              magit-diff--tab-width-cache))))
-              value))
-    (cond
-     ((not magit-diff-adjust-tab-width)
-      tab-width)
-     ((and-let* ((buffer (find-buffer-visiting file)))
-        (cache (buffer-local-value 'tab-width buffer))))
-     ((and-let* ((elt (assoc file magit-diff--tab-width-cache)))
-        (or (cdr elt)
-            tab-width)))
-     ((or (eq magit-diff-adjust-tab-width 'always)
-          (and (numberp magit-diff-adjust-tab-width)
-               (>= magit-diff-adjust-tab-width
-                   (nth 7 (file-attributes file)))))
-      (cache (buffer-local-value 'tab-width (find-file-noselect file))))
-     (t
-      (cache nil)
-      tab-width))))
+  (cond-let
+    ((not magit-diff-adjust-tab-width)
+     tab-width)
+    [[file (expand-file-name file)]]
+    ((and$ (find-buffer-visiting file)
+           (setf (alist-get file magit-diff--tab-width-cache nil nil #'equal)
+                 (buffer-local-value 'tab-width $))))
+    ((and$ (assoc file magit-diff--tab-width-cache)
+           (or (cdr $) tab-width)))
+    ((or (eq magit-diff-adjust-tab-width 'always)
+         (and (numberp magit-diff-adjust-tab-width)
+              (>= magit-diff-adjust-tab-width
+                  (nth 7 (file-attributes file)))))
+     (let* ((buf (find-file-noselect file))
+            (val (buffer-local-value 'tab-width buf)))
+       (kill-buffer buf)
+       (setf (alist-get file magit-diff--tab-width-cache nil nil #'equal) val)))
+    ((prog1 tab-width
+       (setf (alist-get file magit-diff--tab-width-cache nil nil #'equal)
+             nil))))) ; The buffer is too large.  Don't check size again.
 
 (defun magit-diff-paint-tab (merging width)
   (save-excursion
@@ -3383,7 +3479,13 @@ actually a `diff' but a `diffstat' section."
           (overlay-put ov 'priority 2)
           (overlay-put ov 'evaporate t))))))
 
-(defun magit-diff-update-hunk-refinement (&optional section)
+;;;; Refinement
+
+(cl-defmethod magit-section--refine ((section magit-hunk-section))
+  (when (eq magit-diff-refine-hunk t)
+    (magit-diff-update-hunk-refinement section)))
+
+(defun magit-diff-update-hunk-refinement (&optional section allow-remove)
   (if section
       (unless (oref section hidden)
         (pcase (list magit-diff-refine-hunk
@@ -3397,20 +3499,20 @@ actually a `diff' but a `diffstat' section."
              (unless (looking-at "@@@")
                (let ((smerge-refine-ignore-whitespace
                       magit-diff-refine-ignore-whitespace)
-                     ;; Avoid fsyncing many small temp files
+                     ;; Avoid fsyncing many small temp files.
                      (write-region-inhibit-fsync t))
                  (diff-refine-hunk)))))
-          ((or `(nil t ,_) '(t t nil))
+          ((and (guard allow-remove)
+                (or `(nil t ,_) '(t t nil)))
            (oset section refined nil)
            (remove-overlays (oref section start)
                             (oref section end)
                             'diff-mode 'fine))))
-    (cl-labels ((recurse (section)
-                  (if (magit-section-match 'hunk section)
-                      (magit-diff-update-hunk-refinement section)
-                    (dolist (child (oref section children))
-                      (recurse child)))))
-      (recurse magit-root-section))))
+    (named-let update ((section magit-root-section))
+      (if (magit-section-match 'hunk section)
+          (magit-diff-update-hunk-refinement section t)
+        (dolist (child (oref section children))
+          (update child))))))
 
 ;;; Hunk Region
 
@@ -3520,10 +3622,20 @@ last (visual) lines of the region."
 ;;; Utilities
 
 (defun magit-diff-inside-hunk-body-p ()
-  "Return non-nil if point is inside the body of a hunk."
-  (and (magit-section-match 'hunk)
-       (and-let* ((content (oref (magit-current-section) content)))
-         (> (magit-point) content))))
+  "Return t if point is inside the body of a hunk."
+  (and-let* ((section (magit-current-section))
+             (_(cl-typep section 'magit-hunk-section))
+             (content (oref section content)))
+    (> (magit-point) content)))
+
+(defun magit-diff-on-removed-line-p ()
+  "Return t if point is on a removed line inside the body of a hunk.
+If `magit-diff-visit-previous-blob' is nil, then always return nil."
+  (let ((section (magit-current-section)))
+    (and magit-diff-visit-previous-blob
+         (cl-typep section 'magit-hunk-section)
+         (not (oref section combined))
+         (= (char-after (pos-bol)) ?-))))
 
 (defun magit-diff--combined-p (section)
   (cl-assert (cl-typep section 'magit-file-section))
@@ -3557,12 +3669,12 @@ last (visual) lines of the region."
       (goto-char sbeg)
       (while (< (point) send)
         (looking-at "\\(.\\)\\([^\n]*\n\\)")
-        (cond ((or (string-match-p "[@ ]" (match-string-no-properties 1))
+        (cond ((or (string-match-p "[@ ]" (match-str 1))
                    (and (>= (point) rbeg)
                         (<= (point) rend)))
-               (push (match-string-no-properties 0) patch))
-              ((equal op (match-string-no-properties 1))
-               (push (concat " " (match-string-no-properties 2)) patch)))
+               (push (match-str 0) patch))
+              ((equal op (match-str 1))
+               (push (concat " " (match-str 2)) patch)))
         (forward-line)))
     (let ((buffer-list-update-hook nil)) ; #3759
       (with-temp-buffer
@@ -3573,4 +3685,15 @@ last (visual) lines of the region."
 
 ;;; _
 (provide 'magit-diff)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-diff.el ends here
diff --git a/elpa/magit-20250519.1537/magit-dired.el b/elpa/magit-20251103.1130/magit-dired.el
similarity index 85%
rename from elpa/magit-20250519.1537/magit-dired.el
rename to elpa/magit-20251103.1130/magit-dired.el
index 5e361ac9..b7384e27 100644
--- a/elpa/magit-20250519.1537/magit-dired.el
+++ b/elpa/magit-20251103.1130/magit-dired.el
@@ -28,6 +28,8 @@
 
 (require 'magit)
 
+(require 'dired)
+
 ;; For `magit-do-async-shell-command'.
 (declare-function dired-read-shell-command "dired-aux" (prompt arg files))
 
@@ -40,7 +42,9 @@ With a prefix argument, visit in another window.  If there
 is no file at point, then instead visit `default-directory'."
   (interactive "P")
   (dired-jump other-window
-              (and-let* ((file (magit-file-at-point)))
+              (and-let ((file (if (derived-mode-p 'magit-repolist-mode)
+                                  (tabulated-list-get-id)
+                                (magit-file-at-point))))
                 (expand-file-name (if (file-directory-p file)
                                       (file-name-as-directory file)
                                     file)))))
@@ -106,4 +110,15 @@ Interactively, open the file at point."
 
 ;;; _
 (provide 'magit-dired)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-dired.el ends here
diff --git a/elpa/magit-20250519.1537/magit-ediff.el b/elpa/magit-20251103.1130/magit-ediff.el
similarity index 95%
rename from elpa/magit-20250519.1537/magit-ediff.el
rename to elpa/magit-20251103.1130/magit-ediff.el
index 16e38b78..0390d452 100644
--- a/elpa/magit-20250519.1537/magit-ediff.el
+++ b/elpa/magit-20251103.1130/magit-ediff.el
@@ -266,21 +266,21 @@ and alternative commands."
                            (goto-char (point-min))
                            (unless (re-search-forward "^<<<<<<< " nil t)
                              (magit-stage-files (list file)))))))))
-        (if fileC
-            (magit-ediff-buffers
-             ((magit-get-revision-buffer revA fileA)
-              (magit-find-file-noselect  revA fileA))
-             ((magit-get-revision-buffer revB fileB)
-              (magit-find-file-noselect  revB fileB))
-             ((magit-get-revision-buffer revC fileC)
-              (magit-find-file-noselect  revC fileC))
-             setup quit file)
-          (magit-ediff-buffers
-           ((magit-get-revision-buffer revA fileA)
-            (magit-find-file-noselect  revA fileA))
-           ((magit-get-revision-buffer revB fileB)
-            (magit-find-file-noselect  revB fileB))
-           nil setup quit file))))))
+        (cond (fileC
+               (magit-ediff-buffers
+                ((magit-get-revision-buffer revA fileA)
+                 (magit-find-file-noselect  revA fileA))
+                ((magit-get-revision-buffer revB fileB)
+                 (magit-find-file-noselect  revB fileB))
+                ((magit-get-revision-buffer revC fileC)
+                 (magit-find-file-noselect  revC fileC))
+                setup quit file))
+              ((magit-ediff-buffers
+                ((magit-get-revision-buffer revA fileA)
+                 (magit-find-file-noselect  revA fileA))
+                ((magit-get-revision-buffer revB fileB)
+                 (magit-find-file-noselect  revB fileB))
+                nil setup quit file)))))))
 
 ;;;###autoload
 (defun magit-ediff-resolve-rest (file)
@@ -332,7 +332,7 @@ FILE has to be relative to the top directory of the repository."
            (bufC* (or bufC (find-file-noselect file)))
            (coding-system-for-read
             (buffer-local-value 'buffer-file-coding-system bufC*))
-           (bufA* (magit-find-file-noselect-1 "HEAD" file t))
+           (bufA* (magit-find-file-noselect "HEAD" file t))
            (bufB* (magit-find-file-index-noselect file t)))
       (with-current-buffer bufB* (setq buffer-read-only nil))
       (magit-ediff-buffers
@@ -488,8 +488,7 @@ mind at all, then it asks the user for a command to run."
               (magit-ediff-show-stash revB))
              (file
               (funcall command file))
-             (t
-              (call-interactively command)))))))
+             ((call-interactively command)))))))
 
 ;;;###autoload
 (defun magit-ediff-show-staged (file)
@@ -602,4 +601,15 @@ stash that were staged."
 
 ;;; _
 (provide 'magit-ediff)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-ediff.el ends here
diff --git a/elpa/magit-20250519.1537/magit-extras.el b/elpa/magit-20251103.1130/magit-extras.el
similarity index 86%
rename from elpa/magit-20250519.1537/magit-extras.el
rename to elpa/magit-20251103.1130/magit-extras.el
index 7e346a68..9e17129e 100644
--- a/elpa/magit-20250519.1537/magit-extras.el
+++ b/elpa/magit-20251103.1130/magit-extras.el
@@ -205,9 +205,6 @@ to nil before loading Magit to prevent \"m\" from being bound.")
 
 (with-eval-after-load 'project
   (when (and magit-bind-magit-project-status
-             ;; Added in Emacs 28.1.
-             (boundp 'project-prefix-map)
-             (boundp 'project-switch-commands)
              ;; Only modify if it hasn't already been modified.
              (equal project-switch-commands
                     (eval (car (get 'project-switch-commands 'standard-value))
@@ -335,10 +332,7 @@ a position in a file-visiting buffer."
                      (prompt-for-change-log-name)))
   (pcase-let ((`(,buf ,pos) (magit-diff-visit-file--noselect)))
     (magit--with-temp-position buf pos
-      (let ((add-log-buffer-file-name-function
-             (lambda ()
-               (or magit-buffer-file-name
-                   (buffer-file-name)))))
+      (let ((add-log-buffer-file-name-function #'magit-buffer-file-name))
         (add-change-log-entry whoami file-name other-window)))))
 
 ;;;###autoload
@@ -396,7 +390,7 @@ points at it) otherwise."
 (put 'magit-edit-line-commit 'disabled t)
 
 ;;;###autoload
-(defun magit-diff-edit-hunk-commit (file)
+(defun magit-diff-edit-hunk-commit ()
   "From a hunk, edit the respective commit and visit the file.
 
 First visit the file being modified by the hunk at the correct
@@ -413,10 +407,10 @@ to be visited.
 Neither the blob nor the file buffer are killed when finishing
 the rebase.  If that is undesirable, then it might be better to
 use `magit-rebase-edit-commit' instead of this command."
-  (interactive (list (magit-file-at-point t t)))
+  (interactive)
   (let ((magit-diff-visit-previous-blob nil))
     (with-current-buffer
-        (magit-diff-visit-file--internal file nil #'pop-to-buffer-same-window)
+        (magit-diff-visit-file--internal nil #'pop-to-buffer-same-window)
       (magit-edit-line-commit))))
 
 (put 'magit-diff-edit-hunk-commit 'disabled t)
@@ -431,8 +425,8 @@ Otherwise the author dates are also changed."
   :type 'boolean)
 
 ;;;###autoload
-(defun magit-reshelve-since (rev keyid)
-  "Change the author and committer dates of the commits since REV.
+(defun magit-reshelve-since (commit keyid)
+  "Change the author and committer dates of the commits since COMMIT.
 
 Ask the user for the first reachable commit whose dates should
 be changed.  Then read the new date for that commit.  The initial
@@ -453,7 +447,7 @@ list returned by `magit-rebase-arguments'."
                       (user-error "Refusing to reshelve detached head")))
          (backup (concat "refs/original/refs/heads/" current)))
     (cond
-     ((not rev)
+     ((not commit)
       (when (and (magit-ref-p backup)
                  (not (magit-y-or-n-p
                        (format "Backup ref %s already exists.  Override? "
@@ -470,7 +464,7 @@ list returned by `magit-rebase-arguments'."
                    (+ (floor time)
                       (* offset 60)
                       (- (car (decode-time time)))))))
-        (let* ((start (concat rev "^"))
+        (let* ((start (concat commit "^"))
                (range (concat start ".." current))
                (time-rev (adjust (float-time (string-to-number
                                               (magit-rev-format "%at" start)))
@@ -609,47 +603,45 @@ the minibuffer too."
                default-directory))
      (push (caar magit-revision-stack) magit-revision-history)
      (pop magit-revision-stack)))
-  (if rev
-      (pcase-let ((`(,pnt-format ,eob-format ,idx-format)
-                   magit-pop-revision-stack-format))
-        (let ((default-directory toplevel)
-              (idx (and idx-format
-                        (save-excursion
-                          (if (re-search-backward idx-format nil t)
-                              (number-to-string
-                               (1+ (string-to-number (match-string 1))))
-                            "1"))))
-              pnt-args eob-args)
-          (when (listp pnt-format)
-            (setq pnt-args (cdr pnt-format))
-            (setq pnt-format (car pnt-format)))
-          (when (listp eob-format)
-            (setq eob-args (cdr eob-format))
-            (setq eob-format (car eob-format)))
-          (when pnt-format
-            (when idx-format
-              (setq pnt-format
-                    (string-replace "%N" idx pnt-format)))
-            (magit-rev-insert-format pnt-format rev pnt-args)
-            (delete-char -1))
-          (when eob-format
-            (when idx-format
-              (setq eob-format
-                    (string-replace "%N" idx eob-format)))
-            (save-excursion
-              (goto-char (point-max))
-              (skip-syntax-backward ">-")
-              (beginning-of-line)
-              (if (and comment-start (looking-at comment-start))
-                  (while (looking-at comment-start)
-                    (forward-line -1))
-                (forward-line)
-                (unless (= (current-column) 0)
-                  (insert ?\n)))
-              (insert ?\n)
-              (magit-rev-insert-format eob-format rev eob-args)
-              (delete-char -1)))))
-    (user-error "Revision stack is empty")))
+  (unless rev
+    (user-error "Revision stack is empty"))
+  (pcase-let ((`(,pnt-format ,eob-format ,idx-format)
+               magit-pop-revision-stack-format))
+    (let ((default-directory toplevel)
+          (idx (and idx-format
+                    (if (save-excursion
+                          (re-search-backward idx-format nil t))
+                        (number-to-string (1+ (string-to-number (match-str 1))))
+                      "1")))
+          (pnt-args nil)
+          (eob-args nil))
+      (when (listp pnt-format)
+        (setq pnt-args (cdr pnt-format))
+        (setq pnt-format (car pnt-format)))
+      (when (listp eob-format)
+        (setq eob-args (cdr eob-format))
+        (setq eob-format (car eob-format)))
+      (when pnt-format
+        (when idx-format
+          (setq pnt-format (string-replace "%N" idx pnt-format)))
+        (magit-rev-insert-format pnt-format rev pnt-args)
+        (delete-char -1))
+      (when eob-format
+        (when idx-format
+          (setq eob-format (string-replace "%N" idx eob-format)))
+        (save-excursion
+          (goto-char (point-max))
+          (skip-syntax-backward ">-")
+          (beginning-of-line)
+          (if (and comment-start (looking-at comment-start))
+              (while (looking-at comment-start)
+                (forward-line -1))
+            (forward-line)
+            (unless (= (current-column) 0)
+              (insert ?\n)))
+          (insert ?\n)
+          (magit-rev-insert-format eob-format rev eob-args)
+          (delete-char -1))))))
 
 ;;;###autoload
 (defun magit-copy-section-value (arg)
@@ -675,42 +667,41 @@ a hunk, then strip the diff marker column and keep only either
 the added or removed lines, depending on the sign of the prefix
 argument."
   (interactive "P")
-  (cond
-   ((and arg
-         (magit-section-internal-region-p)
-         (magit-section-match 'hunk))
-    (kill-new
-     (thread-last (buffer-substring-no-properties
-                   (region-beginning)
-                   (region-end))
-       (replace-regexp-in-string
-        (format "^\\%c.*\n?" (if (< (prefix-numeric-value arg) 0) ?+ ?-))
-        "")
-       (replace-regexp-in-string "^[ +-]" "")))
-    (deactivate-mark))
-   ((use-region-p)
-    (call-interactively #'copy-region-as-kill))
-   (t
-    (when-let* ((section (magit-current-section))
-                (value (oref section value)))
-      (magit-section-case
-        ((branch commit module-commit tag)
-         (let ((default-directory default-directory) ref)
-           (magit-section-case
-             ((branch tag)
-              (setq ref value))
-             (module-commit
-              (setq default-directory
-                    (file-name-as-directory
-                     (expand-file-name (magit-section-parent-value section)
-                                       (magit-toplevel))))))
-           (setq value (magit-rev-parse
-                        (and magit-copy-revision-abbreviated "--short")
-                        value))
-           (push (list value default-directory) magit-revision-stack)
-           (kill-new (message "%s" (or (and current-prefix-arg ref)
-                                       value)))))
-        (t (kill-new (message "%s" value))))))))
+  (cond-let*
+    ((and arg
+          (magit-section-internal-region-p)
+          (magit-section-match 'hunk))
+     (kill-new
+      (thread-last (buffer-substring-no-properties
+                    (region-beginning)
+                    (region-end))
+        (replace-regexp-in-string
+         (format "^\\%c.*\n?" (if (< (prefix-numeric-value arg) 0) ?+ ?-))
+         "")
+        (replace-regexp-in-string "^[ +-]" "")))
+     (deactivate-mark))
+    ((use-region-p)
+     (call-interactively #'copy-region-as-kill))
+    ([section (magit-current-section)]
+     [value (oref section value)]
+     (magit-section-case
+       ((branch commit module-commit tag)
+        (let ((default-directory default-directory) ref)
+          (magit-section-case
+            ((branch tag)
+             (setq ref value))
+            (module-commit
+             (setq default-directory
+                   (file-name-as-directory
+                    (expand-file-name (magit-section-parent-value section)
+                                      (magit-toplevel))))))
+          (setq value (magit-rev-parse
+                       (and magit-copy-revision-abbreviated "--short")
+                       value))
+          (push (list value default-directory) magit-revision-stack)
+          (kill-new (message "%s" (or (and current-prefix-arg ref)
+                                      value)))))
+       (t (kill-new (message "%s" value)))))))
 
 ;;;###autoload
 (defun magit-copy-buffer-revision ()
@@ -739,22 +730,23 @@ When `magit-copy-revision-abbreviated' is non-nil, save the
 abbreviated revision to the `kill-ring' and the
 `magit-revision-stack'."
   (interactive)
-  (if (use-region-p)
-      (call-interactively #'copy-region-as-kill)
-    (when-let ((rev (or magit-buffer-revision
-                        (cl-case major-mode
-                          (magit-diff-mode
-                           (if (string-match "\\.\\.\\.?\\(.+\\)"
-                                             magit-buffer-range)
-                               (match-string 1 magit-buffer-range)
-                             magit-buffer-range))
-                          (magit-status-mode "HEAD")))))
-      (when (magit-commit-p rev)
-        (setq rev (magit-rev-parse
-                   (and magit-copy-revision-abbreviated "--short")
-                   rev))
-        (push (list rev default-directory) magit-revision-stack)
-        (kill-new (message "%s" rev))))))
+  (cond-let*
+    ((use-region-p)
+     (call-interactively #'copy-region-as-kill))
+    ([rev (or magit-buffer-revision
+              (cl-case major-mode
+                (magit-diff-mode
+                 (if (string-match "\\.\\.\\.?\\(.+\\)"
+                                   magit-buffer-range)
+                     (match-str 1 magit-buffer-range)
+                   magit-buffer-range))
+                (magit-status-mode "HEAD")))]
+     [_(magit-commit-p rev)]
+     (setq rev (magit-rev-parse
+                (and magit-copy-revision-abbreviated "--short")
+                rev))
+     (push (list rev default-directory) magit-revision-stack)
+     (kill-new (message "%s" rev)))))
 
 ;;; Buffer Switching
 
@@ -835,4 +827,15 @@ In Magit diffs, also skip over - and + at the beginning of the line."
 
 ;;; _
 (provide 'magit-extras)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-extras.el ends here
diff --git a/elpa/magit-20250519.1537/magit-fetch.el b/elpa/magit-20251103.1130/magit-fetch.el
similarity index 93%
rename from elpa/magit-20250519.1537/magit-fetch.el
rename to elpa/magit-20251103.1130/magit-fetch.el
index 7ef4504b..4a38da72 100644
--- a/elpa/magit-20250519.1537/magit-fetch.el
+++ b/elpa/magit-20251103.1130/magit-fetch.el
@@ -84,8 +84,7 @@ push-remote."
      ((member remote (magit-list-remotes)) remote)
      (remote
       (format "%s, replacing invalid" v))
-     (t
-      (format "%s, setting that" v)))))
+     ((format "%s, setting that" v)))))
 
 ;;;###autoload (autoload 'magit-fetch-from-upstream "magit-fetch" nil t)
 (transient-define-suffix magit-fetch-from-upstream (remote args)
@@ -183,4 +182,15 @@ with a prefix argument."
 
 ;;; _
 (provide 'magit-fetch)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-fetch.el ends here
diff --git a/elpa/magit-20250519.1537/magit-files.el b/elpa/magit-20251103.1130/magit-files.el
similarity index 78%
rename from elpa/magit-20250519.1537/magit-files.el
rename to elpa/magit-20251103.1130/magit-files.el
index ed65c0ea..38f4beba 100644
--- a/elpa/magit-20250519.1537/magit-files.el
+++ b/elpa/magit-20251103.1130/magit-files.el
@@ -68,17 +68,15 @@ the line and column corresponding to that location."
 
 (defun magit-find-file-read-args (prompt)
   (let ((pseudo-revs '("{worktree}" "{index}")))
-    (if-let ((rev (magit-completing-read "Find file from revision"
-                                         (append pseudo-revs
-                                                 (magit-list-refnames nil t))
-                                         nil nil nil 'magit-revision-history
-                                         (or (magit-branch-or-commit-at-point)
-                                             (magit-get-current-branch)))))
-        (list rev (magit-read-file-from-rev (if (member rev pseudo-revs)
-                                                "HEAD"
-                                              rev)
-                                            prompt))
-      (user-error "Nothing selected"))))
+    (let ((rev (magit-completing-read "Find file from revision"
+                                      (append pseudo-revs
+                                              (magit-list-refnames nil t))
+                                      nil 'any nil 'magit-revision-history
+                                      (or (magit-branch-or-commit-at-point)
+                                          (magit-get-current-branch)))))
+      (list rev
+            (magit-read-file-from-rev (if (member rev pseudo-revs) "HEAD" rev)
+                                      prompt)))))
 
 (defun magit-find-file--internal (rev file fn)
   (let ((buf (magit-find-file-noselect rev file))
@@ -96,8 +94,7 @@ the line and column corresponding to that location."
        (magit-buffer-revision
         (setq line (magit-diff-visit--offset
                     file (concat magit-buffer-revision ".." rev) line)))
-       (t
-        (setq line (magit-diff-visit--offset file (list "-R" rev) line)))))
+       ((setq line (magit-diff-visit--offset file (list "-R" rev) line)))))
     (funcall fn buf)
     (when line
       (with-current-buffer buf
@@ -107,39 +104,35 @@ the line and column corresponding to that location."
         (move-to-column col)))
     buf))
 
-(defun magit-find-file-noselect (rev file)
+(defun magit-find-file-noselect (rev file &optional revert)
   "Read FILE from REV into a buffer and return the buffer.
-REV is a revision or one of \"{worktree}\" or \"{index}\".
-FILE must be relative to the top directory of the repository."
-  (magit-find-file-noselect-1 rev file))
-
-(defun magit-find-file-noselect-1 (rev file &optional revert)
-  "Read FILE from REV into a buffer and return the buffer.
-REV is a revision or one of \"{worktree}\" or \"{index}\".
-FILE must be relative to the top directory of the repository.
-Non-nil REVERT means to revert the buffer.  If `ask-revert',
-then only after asking.  A non-nil value for REVERT is ignored if REV is
-\"{worktree}\"."
-  (if (equal rev "{worktree}")
-      (find-file-noselect (expand-file-name file (magit-toplevel)))
-    (let ((topdir (magit-toplevel)))
-      (when (file-name-absolute-p file)
-        (setq file (file-relative-name file topdir)))
-      (with-current-buffer (magit-get-revision-buffer-create rev file)
+REV is a revision or one of \"{worktree}\" or \"{index}\".  FILE must
+be relative to the top directory of the repository.  Non-nil REVERT
+means to revert the buffer.  If `ask-revert', then only after asking.
+A non-nil value for REVERT is ignored if REV is \"{worktree}\"."
+  (let* ((topdir   (magit-toplevel))
+         (absolute (file-name-absolute-p file))
+         (file-abs (if absolute file (expand-file-name file topdir)))
+         (file-rel (if absolute (file-relative-name file topdir) file))
+         (defdir   (file-name-directory file-abs))
+         (rev      (magit--abbrev-if-hash rev)))
+    (if (equal rev "{worktree}")
+        (let ((revert-without-query
+               (if (and$ (find-buffer-visiting file-abs)
+                         (buffer-local-value 'auto-revert-mode $))
+                   (cons "." revert-without-query)
+                 revert-without-query)))
+            (find-file-noselect file-abs))
+      (with-current-buffer (magit-get-revision-buffer-create rev file-rel)
         (when (or (not magit-buffer-file-name)
                   (if (eq revert 'ask-revert)
                       (y-or-n-p (format "%s already exists; revert it? "
                                         (buffer-name))))
                   revert)
-          (setq magit-buffer-revision
-                (if (equal rev "{index}")
-                    "{index}"
-                  (magit-rev-format "%H" rev)))
+          (setq magit-buffer-revision rev)
           (setq magit-buffer-refname rev)
-          (setq magit-buffer-file-name (expand-file-name file topdir))
-          (setq default-directory
-                (let ((dir (file-name-directory magit-buffer-file-name)))
-                  (if (file-exists-p dir) dir topdir)))
+          (setq magit-buffer-file-name file-abs)
+          (setq default-directory (if (file-exists-p defdir) defdir topdir))
           (setq-local revert-buffer-function #'magit-revert-rev-file-buffer)
           (revert-buffer t t)
           (run-hooks (if (equal rev "{index}")
@@ -182,7 +175,10 @@ then only after asking.  A non-nil value for REVERT is ignored if REV is
                              global-diff-hl-mode-enable-in-buffers ; Emacs < 30
                              eglot--maybe-activate-editing-mode)
                            #'eq)))
-      (normal-mode t))
+      ;; We want `normal-mode' to respect nil `enable-local-variables'.
+      ;; The FIND-FILE argument wasn't designed for our use case, so we
+      ;; have to use this strange invocation to achieve that.
+      (normal-mode (not enable-local-variables)))
     (setq buffer-read-only t)
     (set-buffer-modified-p nil)
     (goto-char (point-min))))
@@ -196,11 +192,12 @@ See also https://github.com/doomemacs/doomemacs/pull/6309."
 ;;; Find Index
 
 (defvar magit-find-index-hook nil)
+(add-hook 'magit-find-index-hook #'magit-blob-mode)
 
 (defun magit-find-file-index-noselect (file &optional revert)
   "Read FILE from the index into a buffer and return the buffer.
 FILE must to be relative to the top directory of the repository."
-  (magit-find-file-noselect-1 "{index}" file (or revert 'ask-revert)))
+  (magit-find-file-noselect "{index}" file (or revert 'ask-revert)))
 
 (defun magit-update-index ()
   "Update the index with the contents of the current buffer.
@@ -355,7 +352,7 @@ to `magit-dispatch'."
   "b" #'magit-blame-addition
   "r" #'magit-blame-removal
   "f" #'magit-blame-reverse
-  "q" #'magit-kill-this-buffer)
+  "q" #'magit-bury-or-kill-buffer)
 
 (define-minor-mode magit-blob-mode
   "Enable some Magit features in blob-visiting buffers.
@@ -364,26 +361,51 @@ Currently this only adds the following key bindings.
 \n\\{magit-blob-mode-map}"
   :package-version '(magit . "2.3.0"))
 
-(defun magit-blob-next ()
-  "Visit the next blob which modified the current file."
+(defun magit-bury-buffer (&optional kill-buffer)
+  "Bury the current buffer, or with a prefix argument kill it."
+  (interactive "P")
+  (if kill-buffer (kill-buffer) (bury-buffer)))
+
+(defun magit-bury-or-kill-buffer (&optional bury-buffer)
+  "Bury the current buffer if displayed in multiple windows, else kill it.
+With a prefix argument only bury the buffer even if it is only displayed
+in a single window."
+  (interactive "P")
+  (if (or bury-buffer (cdr (get-buffer-window-list nil nil t)))
+      (bury-buffer)
+    (kill-buffer)))
+
+(defun magit-kill-this-buffer ()
+  "Kill the current buffer."
   (interactive)
-  (if magit-buffer-file-name
-      (magit-blob-visit (or (magit-blob-successor magit-buffer-revision
-                                                  magit-buffer-file-name)
-                            magit-buffer-file-name))
-    (if (buffer-file-name (buffer-base-buffer))
-        (user-error "You have reached the end of time")
-      (user-error "Buffer isn't visiting a file or blob"))))
-
-(defun magit-blob-previous ()
+  (kill-buffer))
+
+(transient-define-suffix magit-blob-previous ()
   "Visit the previous blob which modified the current file."
+  :inapt-if-not (##and$ (magit-buffer-file-name)
+                        (magit-blob-ancestor (magit-buffer-revision) $))
+  (interactive)
+  (cond-let
+    [[rev  (or magit-buffer-revision "{worktree}")]
+     [file (magit-buffer-file-name)]]
+    ((not file)
+     (user-error "Buffer isn't visiting a file or blob"))
+    ([prev (magit-blob-ancestor rev file)]
+     (apply #'magit-blob-visit prev))
+    ((user-error "You have reached the beginning of time"))))
+
+(transient-define-suffix magit-blob-next ()
+  "Visit the next blob which modified the current file."
+  :inapt-if-nil 'magit-buffer-file-name
   (interactive)
-  (if-let ((file (or magit-buffer-file-name
-                     (buffer-file-name (buffer-base-buffer)))))
-      (if-let ((ancestor (magit-blob-ancestor magit-buffer-revision file)))
-          (magit-blob-visit ancestor)
-        (user-error "You have reached the beginning of time"))
-    (user-error "Buffer isn't visiting a file or blob")))
+  (cond-let
+    [[rev  (or magit-buffer-revision "{worktree}")]
+     [file (magit-buffer-file-name)]]
+    ((not file)
+     (user-error "Buffer isn't visiting a file or blob"))
+    ([next (magit-blob-successor rev file)]
+     (apply #'magit-blob-visit next))
+    ((user-error "You have reached the end of time"))))
 
 ;;;###autoload
 (defun magit-blob-visit-file ()
@@ -395,30 +417,40 @@ the same location in the respective file in the working tree."
       (magit-find-file--internal "{worktree}" file #'pop-to-buffer-same-window)
     (user-error "Not visiting a blob")))
 
-(defun magit-blob-visit (blob-or-file)
-  (if (stringp blob-or-file)
-      (find-file blob-or-file)
-    (pcase-let ((`(,rev ,file) blob-or-file))
-      (magit-find-file rev file)
-      (apply #'message "%s (%s %s ago)"
-             (magit-rev-format "%s" rev)
-             (magit--age (magit-rev-format "%ct" rev))))))
+(defun magit-blob-visit (rev file)
+  (magit-find-file rev file)
+  (unless (member rev '("{worktree}" "{index}"))
+    (apply #'message "%s (%s %s ago)"
+           (magit-rev-format "%s" rev)
+           (magit--age (magit-rev-format "%ct" rev)))))
 
 (defun magit-blob-ancestor (rev file)
-  (let ((lines (magit-with-toplevel
-                 (magit-git-lines "log" "-2" "--format=%H" "--name-only"
-                                  "--follow" (or rev "HEAD") "--" file))))
-    (if rev (cddr lines) (butlast lines 2))))
+  (pcase rev
+    ((and "{worktree}" (guard (magit-anything-staged-p nil file)))
+     (list "{index}" file))
+    ((or "{worktree}" "{index}")
+     (list (magit-rev-abbrev "HEAD") file))
+    (_ (nth (if rev 1 0)
+            (magit-with-toplevel
+              (seq-partition
+               (magit-git-lines "log" "-2" "--format=%h" "--name-only"
+                                "--follow" (or rev "HEAD") "--" file)
+               2))))))
 
 (defun magit-blob-successor (rev file)
-  (let ((lines (magit-with-toplevel
-                 (magit-git-lines "log" "--format=%H" "--name-only" "--follow"
-                                  "HEAD" "--" file))))
-    (catch 'found
-      (while lines
-        (if (equal (nth 2 lines) rev)
-            (throw 'found (list (nth 0 lines) (nth 1 lines)))
-          (setq lines (nthcdr 2 lines)))))))
+  (pcase rev
+    ("{worktree}" nil)
+    ("{index}" (list "{worktree}" file))
+    (_ (let ((lines (magit-with-toplevel
+                      (magit-git-lines "log" "--format=%h" "--name-only"
+                                       "--follow" "HEAD" "--" file))))
+         (catch 'found
+           (while lines
+             (if (equal (nth 2 lines) rev)
+                 (throw 'found (list (nth 0 lines) (nth 1 lines)))
+               (setq lines (nthcdr 2 lines))))
+           (list (if (magit-anything-staged-p nil file) "{index}" "{worktree}")
+                 file))))))
 
 ;;; File Commands
 
@@ -591,5 +623,19 @@ If DEFAULT is non-nil, use this as the default value instead of
 (define-obsolete-function-alias 'magit-unstage-buffer-file
   'magit-file-unstage "Magit 4.3.2")
 
+(define-obsolete-function-alias 'magit-find-file-noselect-1
+  'magit-find-file-noselect "Magit 4.4.0")
+
 (provide 'magit-files)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-files.el ends here
diff --git a/elpa/magit-20250519.1537/magit-git.el b/elpa/magit-20251103.1130/magit-git.el
similarity index 84%
rename from elpa/magit-20250519.1537/magit-git.el
rename to elpa/magit-20251103.1130/magit-git.el
index 2e6a14c5..73f64ee2 100644
--- a/elpa/magit-20250519.1537/magit-git.el
+++ b/elpa/magit-20251103.1130/magit-git.el
@@ -38,6 +38,7 @@
 (declare-function magit-maybe-make-margin-overlay "magit-margin" ())
 
 ;; From `magit-mode'.
+(declare-function magit-buffer-file-name "magit-mode" ())
 (declare-function magit-get-mode-buffer "magit-mode"
                   (mode &optional value frame))
 (declare-function magit-refresh "magit-mode" ())
@@ -63,7 +64,10 @@
 (defvar magit-this-error)
 (defvar magit-process-error-message-regexps)
 
-(eval-when-compile
+;; From `magit-status'.
+(defvar magit-status-show-untracked-files)
+
+(eval-and-compile
   (cl-pushnew 'orig-rev eieio--known-slot-names)
   (cl-pushnew 'number eieio--known-slot-names))
 
@@ -100,7 +104,7 @@ successfully.")
   (or (and (eq system-type 'windows-nt)
            ;; Avoid the wrappers "cmd/git.exe" and "cmd/git.cmd",
            ;; which are much slower than using "bin/git.exe" directly.
-           (and-let* ((exec (executable-find "git")))
+           (and-let ((exec (executable-find "git")))
              (ignore-errors
                ;; Git for Windows 2.x provides cygpath so we can
                ;; ask it for native paths.
@@ -188,14 +192,14 @@ that change the upstream and many that create new branches."
 (defcustom magit-list-refs-namespaces
   '("refs/heads"
     "refs/remotes"
-    "refs/tags"
-    "refs/pullreqs")
+    "refs/tags")
   "List of ref namespaces considered when reading a ref.
 
-This controls the order of refs returned by `magit-list-refs',
-which is called by functions like `magit-list-branch-names' to
-generate the collection of refs."
-  :package-version '(magit . "3.1.0")
+This controls which refs are returned by `magit-list-refs', which
+is called by functions like `magit-list-branch-names' to generate
+the collection of refs.  Additionally namespaces appear in the same
+order as specified here."
+  :package-version '(magit . "4.4.0")
   :group 'magit-commands
   :type '(repeat string))
 
@@ -214,6 +218,9 @@ recent committer or tagger dates earlier in the list.  A list of
 strings can also be given in order to pass multiple sort keys to
 \"git for-each-ref\".
 
+Regardless of what is specified here, refs are first sorted by
+namespace, according to the order of `magit-list-refs-namespaces'.
+
 Note that, depending on the completion framework you use, this
 may not be sufficient to change the order in which the refs are
 displayed.  It only controls the order of the collection passed
@@ -510,7 +517,7 @@ insert the run command and stderr into the process buffer."
   (goto-char (point-max))
   (and (run-hook-wrapped 'magit-process-error-message-regexps
                          (##re-search-backward % nil t))
-       (match-string-no-properties 1)))
+       (match-str 1)))
 
 (defun magit-git-string (&rest args)
   "Execute Git with ARGS, returning the first line of its output.
@@ -570,7 +577,7 @@ standard output even in case of an error."
         (exit (magit--git-insert (and keep-error 'full) args)))
     (when (stringp exit)
       (goto-char beg)
-      (insert (propertize exit 'face 'error))
+      (insert (magit--propertize-face exit 'error))
       (insert (if (bolp) "\n" "\n\n")))
     (if (= (point) beg)
         (magit-cancel-section)
@@ -646,7 +653,7 @@ using `magit-debug-git-executable'.")
                          output)))
                ((save-match-data
                   (and (string-match magit--git-version-regexp output)
-                       (let ((version (match-string 1 output)))
+                       (let ((version (match-str 1 output)))
                          (push (cons host version)
                                magit--host-git-version-cache)
                          version))))
@@ -690,8 +697,8 @@ values of `magit-remote-git-executable' and `exec-path'.\n"))
       (cond ((not (zerop status)) output)
             ((save-match-data
                (and (string-match magit--git-version-regexp output)
-                    (match-string 1 output))))
-            (t output)))))
+                    (match-str 1 output))))
+            (output)))))
 
 (defun magit-debug-git-executable ()
   "Display a buffer with information about `magit-git-executable'.
@@ -815,10 +822,8 @@ Also see `magit-git-config-p'."
 (defun magit-git-dir (&optional path)
   "Like (expand-file-name PATH (magit-gitdir)) or just (magit-gitdir)."
   (declare (obsolete magit-gitdir "Magit 4.0.0"))
-  (and-let* ((dir (magit-gitdir)))
-    (if path
-        (expand-file-name (convert-standard-filename path) dir)
-      dir)))
+  (and$ (magit-gitdir)
+        (if path (expand-file-name (convert-standard-filename path) $) $)))
 
 (defun magit-gitdir (&optional directory)
   "Return the absolute and resolved path of the .git directory.
@@ -874,70 +879,63 @@ tree is involved, or when called from within a sub-directory of
 the gitdir or from the toplevel of a gitdir, which itself is not
 located within the working tree, then it is not possible to avoid
 returning the truename."
-  (or
-   (magit--with-refresh-cache
-       (cons (or directory default-directory) 'magit-toplevel)
-     (magit--with-safe-default-directory directory
-       (if-let ((topdir (magit-rev-parse-safe "--show-toplevel")))
-           (let (updir)
-             (setq topdir (magit-expand-git-file-name topdir))
-             (cond
-              ((and
-                ;; Always honor these settings.
-                (not find-file-visit-truename)
-                (not (getenv "GIT_WORK_TREE"))
-                ;; `--show-cdup' is the relative path to the toplevel
-                ;; from `(file-truename default-directory)'.  Here we
-                ;; pretend it is relative to `default-directory', and
-                ;; go to that directory.  Then we check whether
-                ;; `--show-toplevel' still returns the same value and
-                ;; whether `--show-cdup' now is the empty string.  If
-                ;; both is the case, then we are at the toplevel of
-                ;; the same working tree, but also avoided needlessly
-                ;; following any symlinks.
-                (progn
-                  (setq updir (file-name-as-directory
-                               (magit-rev-parse-safe "--show-cdup")))
-                  (setq updir (if (file-name-absolute-p updir)
-                                  (concat (file-remote-p default-directory)
-                                          updir)
-                                (expand-file-name updir)))
-                  (and-let*
-                      ((default-directory updir)
-                       (top (and (string-equal
-                                  (magit-rev-parse-safe "--show-cdup") "")
-                                 (magit-rev-parse-safe "--show-toplevel"))))
-                    (string-equal (magit-expand-git-file-name top) topdir))))
-               updir)
-              ((concat (file-remote-p default-directory)
-                       (file-name-as-directory topdir)))))
-         (and-let* ((gitdir (magit-rev-parse-safe "--git-dir"))
-                    (gitdir (file-name-as-directory
-                             (if (file-name-absolute-p gitdir)
-                                 ;; We might have followed a symlink.
-                                 (concat (file-remote-p default-directory)
-                                         (magit-expand-git-file-name gitdir))
-                               (expand-file-name gitdir)))))
-           (if (magit-bare-repo-p)
-               gitdir
-             (let* ((link (expand-file-name "gitdir" gitdir))
-                    (wtree (and (file-exists-p link)
-                                (magit-file-line link))))
-               (cond
-                ((and wtree
-                      ;; Ignore .git/gitdir files that result from a
-                      ;; Git bug.  See #2364.
-                      (not (equal wtree ".git")))
-                 ;; Return the linked working tree.
-                 (concat (file-remote-p default-directory)
-                         (file-name-directory wtree)))
-                ;; The working directory may not be the parent
-                ;; directory of .git if it was set up with
-                ;; "git init --separate-git-dir".  See #2955.
-                ((car (rassoc gitdir magit--separated-gitdirs)))
-                (;; Step outside the control directory to enter the
-                 ;; working tree.
-                 (file-name-directory (directory-file-name gitdir))))))))))))
+  (magit--with-refresh-cache
+      (cons (or directory default-directory) 'magit-toplevel)
+    (magit--with-safe-default-directory directory
+      (cond-let*
+        ([topdir (magit-rev-parse-safe "--show-toplevel")]
+         [topdir (magit-expand-git-file-name topdir)]
+         (cond-let*
+           (;; Always honor these settings.
+            [_(not find-file-visit-truename)]
+            [_(not (getenv "GIT_WORK_TREE"))]
+            ;; `--show-cdup' is the relative path to the toplevel
+            ;; from `(file-truename default-directory)'.  Here we
+            ;; pretend it is relative to `default-directory', and
+            ;; go to that directory.  Then we check whether
+            ;; `--show-toplevel' still returns the same value and
+            ;; whether `--show-cdup' now is the empty string.  If
+            ;; both is the case, then we are at the toplevel of
+            ;; the same working tree, but also avoided needlessly
+            ;; following any symlinks.
+            [updir (file-name-as-directory
+                    (magit-rev-parse-safe "--show-cdup"))]
+            [updir (if (file-name-absolute-p updir)
+                       (concat (file-remote-p default-directory) updir)
+                     (expand-file-name updir))]
+            [updir->topdir
+             (let ((default-directory updir))
+               (and (string-equal (magit-rev-parse-safe "--show-cdup") "")
+                    (magit-rev-parse-safe "--show-toplevel")))]
+            [_(string-equal (magit-expand-git-file-name updir->topdir) topdir)]
+            updir)
+           ((concat (file-remote-p default-directory)
+                    (file-name-as-directory topdir)))))
+        ([gitdir (magit-rev-parse-safe "--git-dir")]
+         [gitdir (file-name-as-directory
+                  (if (file-name-absolute-p gitdir)
+                      ;; We might have followed a symlink.
+                      (concat (file-remote-p default-directory)
+                              (magit-expand-git-file-name gitdir))
+                    (expand-file-name gitdir)))]
+         (cond-let*
+           ((magit-bare-repo-p) gitdir)
+           ;; Return the linked working tree, if any.
+           ([link (expand-file-name "gitdir" gitdir)]
+            [wtree (and (file-exists-p link)
+                        (magit-file-line link))]
+            ;; Ignore ".git/gitdir" files that result from a Git bug.
+            ;; This has long been fixed, but old repository may still
+            ;; exist that contain such a file.  See #2364.
+            [_(not (equal wtree ".git"))]
+            (concat (file-remote-p default-directory)
+                    (file-name-directory wtree)))
+           ;; The working directory may not be the parent
+           ;; directory of .git if it was set up with
+           ;; "git init --separate-git-dir".  See #2955.
+           ((car (rassoc gitdir magit--separated-gitdirs)))
+           ;; Step outside the control directory to enter the working tree.
+           ((file-name-directory (directory-file-name gitdir)))))))))
 
 (defun magit--toplevel-safe ()
   (or (magit-toplevel)
@@ -961,11 +959,9 @@ returning the truename."
            (lambda (err)
              (signal 'magit-corrupt-git-config
                      (format "%s: %s" default-directory err)))))
-      ;; This should always succeed unless there's a corrupt config
-      ;; (or at least a similarly severe failing state).  Note that
-      ;; git-config's --default is avoided because it's not available
-      ;; until Git 2.18.
-      (magit-git-string "config" "--get-color" "" "reset"))
+      ;; This should always succeed unless there is a corrupt
+      ;; config (or possibly a similarly severe failing state).
+      (magit-git-string "config" "--default=_" "core.bare"))
     nil))
 
 (defun magit--not-inside-repository-error ()
@@ -987,7 +983,7 @@ is non-nil, in which case return nil."
                ((signal 'magit-outside-git-repo default-directory))))))
 
 (defun magit-inside-worktree-p (&optional noerror)
-  "Return t if `default-directory' is below the working directory.
+  "Return t if `default-directory' is below a working directory.
 If it is below the repository directory, then return nil.
 If it isn't below either, then signal an error unless NOERROR
 is non-nil, in which case return nil."
@@ -1042,17 +1038,16 @@ If the file is not inside a Git repository, then return nil.
 
 If TRACKED is non-nil, return the path only if it matches a
 tracked file."
-  (and-let* ((file (or file
-                       magit-buffer-file-name
-                       buffer-file-name
-                       (and (derived-mode-p 'dired-mode)
-                            default-directory)))
-             ((or (not tracked)
-                  (magit-file-tracked-p (file-relative-name file))))
-             (dir (magit-toplevel
-                   (magit--safe-default-directory
-                    (directory-file-name (file-name-directory file))))))
-    (file-relative-name file dir)))
+  (with-current-buffer (or (buffer-base-buffer) (current-buffer))
+    (and-let* ((file (or file
+                         (magit-buffer-file-name)
+                         (and (derived-mode-p 'dired-mode)
+                              default-directory)))
+               (dir (magit-toplevel (magit--safe-default-directory
+                                     (file-name-parent-directory file))))
+               (_(or (not tracked)
+                     (magit-file-tracked-p file))))
+      (file-relative-name file dir))))
 
 (defun magit-file-ignored-p (file)
   (magit-git-string-p "ls-files" "--others" "--ignored" "--exclude-standard"
@@ -1069,10 +1064,42 @@ tracked file."
   (magit-list-files "--cached" args))
 
 (defun magit-untracked-files (&optional all files &rest args)
+  "Return a list of untracked files.
+
+Note that when using \"--directory\", the rules from \".gitignore\"
+files from sub-directories are ignore, which is probably a Git bug.
+See also `magit-list-untracked-files', which does not have this
+issue."
   (magit-list-files "--other" args
                     (and (not all) "--exclude-standard")
                     "--" files))
 
+(defun magit-list-untracked-files (&optional files)
+  "Return a list of untracked files.
+
+List files if `magit-status-show-untracked-files' is non-nil, but also
+take the local value of Git variable `status.showUntrackedFiles' into
+account.  The local value of the Lisp variable takes precedence over the
+local value of the Git variable.  The global value of the Git variable
+is always ignored.
+
+See also `magit-untracked-files'."
+  (and-let*
+      ((value (or (and (local-variable-p 'magit-status-show-untracked-files)
+                       magit-status-show-untracked-files)
+                  (pcase (magit-get "--local" "status.showUntrackedFiles")
+                    ((or "no" "off" "false" "0") 'no)
+                    ((or "yes" "on" "true" "1") t)
+                    ("all" 'all))
+                  magit-status-show-untracked-files))
+       (_(not (eq value 'no))))
+    (mapcan (##and (eq (aref % 0) ??)
+                   (list (substring % 3)))
+            (apply #'magit-git-items "status" "-z" "--porcelain"
+                   (format "--untracked-files=%s"
+                           (if (eq value 'all) "all" "normal"))
+                   "--" files))))
+
 (defun magit-ignored-files (&rest args)
   (magit-list-files "--others" "--ignored" "--exclude-standard" args))
 
@@ -1096,7 +1123,7 @@ tracked file."
 
 (defun magit-binary-files (&rest args)
   (mapcan (##and (string-match "^-\t-\t\\(.+\\)" %)
-                 (list (match-string 1 %)))
+                 (list (match-str 1 %)))
           (apply #'magit-git-items
                  "diff" "-z" "--numstat" "--ignore-submodules"
                  args)))
@@ -1148,8 +1175,8 @@ range.  Otherwise, it can be any revision or range accepted by
 Return nil, if FILE appears neither in REV nor OTHER-REV,
 or if no rename is detected."
   (or (car (member file (magit-revision-files rev)))
-      (and-let* ((renamed (magit-renamed-files rev other-rev)))
-        (car (rassoc file renamed)))))
+      (and$ (magit-renamed-files rev other-rev)
+            (car (rassoc file $)))))
 
 (defun magit-file-status (&rest args)
   (magit--with-temp-process-buffer
@@ -1175,8 +1202,8 @@ or if no rename is detected."
        (cl-sort (mapcar
                  (lambda (mount)
                    (if (string-match "^\\(.*\\) on \\(.*\\) type" mount)
-                       (cons (file-name-as-directory (match-string 2 mount))
-                             (file-name-as-directory (match-string 1 mount)))
+                       (cons (file-name-as-directory (match-str 2 mount))
+                             (file-name-as-directory (match-str 1 mount)))
                      (lwarn '(magit) :error
                             "Failed to parse Cygwin mount: %S" mount)))
                  ;; If --exec-path is not a native Windows path,
@@ -1213,15 +1240,16 @@ Sorted from longest to shortest CYGWIN name."
    Git does not understand.
 2. If it is a remote filename, then remove the remote part.
 3. Deal with an `windows-nt' Emacs vs. Cygwin Git incompatibility."
-  (if (file-name-absolute-p filename)
-      (if-let ((cyg:win (cl-rassoc filename magit-cygwin-mount-points
-                                   :test (##string-prefix-p %2 %1))))
-          (concat (car cyg:win)
-                  (substring filename (length (cdr cyg:win))))
-        (let ((expanded (expand-file-name filename)))
-          (or (file-remote-p expanded 'localname)
-              expanded)))
-    filename))
+  (cond-let
+    ((not (file-name-absolute-p filename))
+     filename)
+    ([cyg:win (cl-rassoc filename magit-cygwin-mount-points
+                         :test (##string-prefix-p %2 %1))]
+     (concat (car cyg:win)
+             (substring filename (length (cdr cyg:win)))))
+    ([expanded (expand-file-name filename)]
+     (or (file-remote-p expanded 'localname)
+         expanded))))
 
 (defun magit-decode-git-path (path)
   (if (eq (aref path 0) ?\")
@@ -1232,14 +1260,15 @@ Sorted from longest to shortest CYGWIN name."
     path))
 
 (defun magit-file-at-point (&optional expand assert)
-  (if-let ((file (magit-section-case
-                   (file (oref it value))
-                   (hunk (magit-section-parent-value it)))))
-      (if expand
-          (expand-file-name file (magit-toplevel))
-        file)
-    (when assert
-      (user-error "No file at point"))))
+  (cond-let
+    ([file (magit-section-case
+             (file (oref it value))
+             (hunk (magit-section-parent-value it)))]
+     (if expand
+         (expand-file-name file (magit-toplevel))
+       file))
+    (assert
+     (user-error "No file at point"))))
 
 (defun magit-current-file ()
   (or (magit-file-relative-name)
@@ -1307,10 +1336,10 @@ are considered."
 (defun magit-ignore-submodules-p (&optional return-argument)
   (or (cl-find-if (##string-prefix-p "--ignore-submodules" %)
                   magit-buffer-diff-args)
-      (and-let* ((value (magit-get "diff.ignoreSubmodules")))
-        (if return-argument
-            (concat "--ignore-submodules=" value)
-          (concat "diff.ignoreSubmodules=" value)))))
+      (and$ (magit-get "diff.ignoreSubmodules")
+            (if return-argument
+                (concat "--ignore-submodules=" $)
+              (concat "diff.ignoreSubmodules=" $)))))
 
 ;;; Revisions and References
 
@@ -1393,19 +1422,10 @@ of REV."
 (defun magit-rev-name (rev &optional pattern not-anchored)
   "Return a symbolic name for REV using `git-name-rev'.
 
-PATTERN can be used to limit the result to a matching ref.
-Unless NOT-ANCHORED is non-nil, the beginning of the ref must
-match PATTERN.
-
-An anchored lookup is done using the arguments
-\"--exclude=*/<PATTERN> --exclude=*/HEAD\" in addition to
-\"--refs=<PATTERN>\", provided at least version v2.13 of Git is
-used.  Older versions did not support the \"--exclude\" argument.
-When \"--exclude\" cannot be used and `git-name-rev' returns a
-ref that should have been excluded, then that is discarded and
-this function returns nil instead.  This is unfortunate because
-there might be other refs that do match.  To fix that, update
-Git."
+PATTERN can be used to limit the result to a matching ref.  Unless
+NOT-ANCHORED is non-nil, the beginning of the ref must match PATTERN.
+An anchored lookup is done using the arguments \"--exclude=*/<PATTERN>\"
+and \"--exclude=*/HEAD\", in addition to \"--refs=<PATTERN>\"."
   (magit-git-string "name-rev" "--name-only" "--no-undefined"
                     (and pattern (concat "--refs=" pattern))
                     (and pattern
@@ -1415,8 +1435,8 @@ Git."
                     rev))
 
 (defun magit-rev-branch (rev)
-  (and-let* ((name (magit-rev-name rev "refs/heads/*")))
-    (and (not (string-match-p "[~^]" name)) name)))
+  (and$ (magit-rev-name rev "refs/heads/*")
+        (and (not (string-match-p "[~^]" $)) $)))
 
 (defun magit-rev-fixup-target (rev)
   (let ((msg (magit-rev-format "%s" rev)))
@@ -1424,7 +1444,7 @@ Git."
       (and (string-match "\\`\\(squash!\\|fixup!\\|amend!\\) \\(.+\\)" msg)
            (magit-rev-format
             "%h" (format "%s^{/^%s}" rev
-                         (magit--ext-regexp-quote (match-string 2 msg))))))))
+                         (magit--ext-regexp-quote (match-str 2 msg))))))))
 
 (defun magit-get-shortname (rev)
   (let* ((fn (apply-partially #'magit-rev-name rev))
@@ -1434,9 +1454,9 @@ Git."
     (cond ((not name)
            (magit-rev-parse "--short" rev))
           ((string-match "^\\(?:tags\\|remotes\\)/\\(.+\\)" name)
-           (if (magit-ref-ambiguous-p (match-string 1 name))
+           (if (magit-ref-ambiguous-p (match-str 1 name))
                name
-             (match-string 1 name)))
+             (match-str 1 name)))
           ((magit-ref-maybe-qualify name)))))
 
 (defun magit-name-branch (rev &optional lax)
@@ -1446,16 +1466,16 @@ Git."
                    (magit-name-remote-branch rev t)))))
 
 (defun magit-name-local-branch (rev &optional lax)
-  (and-let* ((name (magit-rev-name rev "refs/heads/*")))
-    (and (or lax (not (string-match-p "[~^]" name))) name)))
+  (and$ (magit-rev-name rev "refs/heads/*")
+        (and (or lax (not (string-match-p "[~^]" $))) $)))
 
 (defun magit-name-remote-branch (rev &optional lax)
-  (and-let* ((name (magit-rev-name rev "refs/remotes/*")))
-    (and (or lax (not (string-match-p "[~^]" name)))
-         (substring name 8))))
+  (and$ (magit-rev-name rev "refs/remotes/*")
+        (and (or lax (not (string-match-p "[~^]" $)))
+             (substring $ 8))))
 
 (defun magit-name-tag (rev &optional lax)
-  (and-let* ((name (magit-rev-name rev "refs/tags/*")))
+  (and-let ((name (magit-rev-name rev "refs/tags/*")))
     (progn
       (when (string-suffix-p "^0" name)
         (setq name (substring name 0 -2)))
@@ -1474,7 +1494,7 @@ If REFNAME is ambiguous, return nil."
 (defun magit-ref-ambiguous-p (refname)
   (save-match-data
     (if (string-match "\\`\\([^^~]+\\)\\(.*\\)" refname)
-        (not (magit-ref-fullname (match-string 1 refname)))
+        (not (magit-ref-fullname (match-str 1 refname)))
       (error "%S has an unrecognized format" refname))))
 
 (defun magit-ref-maybe-qualify (refname &optional prefix)
@@ -1537,8 +1557,8 @@ to, or to some other symbolic-ref that points to the same ref."
            (memq (get-text-property (magit-point) 'font-lock-face)
                  (list 'magit-branch-local
                        'magit-branch-current))
-           (and-let* ((branch (magit-thing-at-point 'git-revision t)))
-             (cdr (magit-split-branch-name branch))))
+           (and$ (magit-thing-at-point 'git-revision t)
+                 (cdr (magit-split-branch-name $))))
       (and (not (eq type 'local))
            (memq (get-text-property (magit-point) 'font-lock-face)
                  (list 'magit-branch-remote
@@ -1564,9 +1584,9 @@ to, or to some other symbolic-ref that points to the same ref."
 (defun magit-commit-at-point ()
   (or (magit-section-value-if 'commit)
       (magit-thing-at-point 'git-revision t)
-      (and-let* ((chunk (and (bound-and-true-p magit-blame-mode)
-                             (fboundp 'magit-current-blame-chunk)
-                             (magit-current-blame-chunk))))
+      (and-let ((chunk (and (bound-and-true-p magit-blame-mode)
+                            (fboundp 'magit-current-blame-chunk)
+                            (magit-current-blame-chunk))))
         (oref chunk orig-rev))
       (and (derived-mode-p 'magit-stash-mode
                            'magit-merge-preview-mode
@@ -1589,9 +1609,9 @@ to, or to some other symbolic-ref that points to the same ref."
          (magit-ref-abbrev
           (replace-regexp-in-string "\\.\\.\\.?" "" (oref it value)))))
       (magit-thing-at-point 'git-revision t)
-      (and-let* ((chunk (and (bound-and-true-p magit-blame-mode)
-                             (fboundp 'magit-current-blame-chunk)
-                             (magit-current-blame-chunk))))
+      (and-let ((chunk (and (bound-and-true-p magit-blame-mode)
+                            (fboundp 'magit-current-blame-chunk)
+                            (magit-current-blame-chunk))))
         (oref chunk orig-rev))
       (and magit-buffer-file-name
            magit-buffer-refname)
@@ -1638,9 +1658,9 @@ The amount of time spent searching is limited by
   (let ((t0 (float-time))
         (current (magit-get-current-branch))
         (i 1) prev)
-    (while (if (> (- (float-time) t0) magit-get-previous-branch-timeout)
-               (setq prev nil) ;; Timed out.
-             (and (setq prev (magit-rev-verify (format "@{-%d}" i)))
+    (while (cond ((> (- (float-time) t0) magit-get-previous-branch-timeout)
+                  (setq prev nil))
+                 ((setq prev (magit-rev-verify (format "@{-%d}" i)))
                   (or (not (setq prev (magit-rev-branch prev)))
                       (equal prev current))))
       (cl-incf i))
@@ -1654,7 +1674,7 @@ The amount of time spent searching is limited by
                            "for-each-ref" "refs/heads"
                            "--format=%(refname:short)\t%(upstream:short)"))))
     (when-let ((old (assoc oldname branches))
-               ((not (assoc newname branches))))
+               (_(not (assoc newname branches))))
       (magit-call-git "branch" "-m" oldname newname)
       (setcar old newname))
     (let ((new (if (magit-branch-p newname)
@@ -1697,8 +1717,8 @@ if any, nil otherwise.  If the upstream is not configured, the
 configured remote is an url, or the named branch does not exist,
 then return nil.  I.e.,  return an existing local or
 remote-tracking branch ref."
-  (and-let* ((branch (or branch (magit-get-current-branch))))
-    (magit-ref-fullname (concat branch "@{upstream}"))))
+  (and$ (or branch (magit-get-current-branch))
+        (magit-ref-fullname (concat $ "@{upstream}"))))
 
 (defun magit-get-upstream-branch (&optional branch)
   "Return the name of the upstream branch of BRANCH.
@@ -1777,10 +1797,10 @@ according to the branch type."
         (magit--propertize-face remote 'magit-branch-remote))))
 
 (defun magit-get-push-remote (&optional branch)
-  (and-let* ((remote
-              (or (and (or branch (setq branch (magit-get-current-branch)))
-                       (magit-get "branch" branch "pushRemote"))
-                  (magit-get "remote.pushDefault"))))
+  (and-let ((remote
+             (or (and (or branch (setq branch (magit-get-current-branch)))
+                      (magit-get "branch" branch "pushRemote"))
+                 (magit-get "remote.pushDefault"))))
     (magit--propertize-face remote 'magit-branch-remote)))
 
 (defun magit-get-push-branch (&optional branch verify)
@@ -1808,8 +1828,8 @@ according to the branch type."
 
 (defun magit-get-some-remote (&optional branch)
   (or (magit-get-remote branch)
-      (and-let* ((main (magit-main-branch)))
-        (magit-get-remote main))
+      (and$ (magit-main-branch)
+            (magit-get-remote $))
       (magit-primary-remote)
       (car (magit-list-remotes))))
 
@@ -1853,30 +1873,31 @@ as into its upstream."
                                (magit-get-upstream-branch branch))))
            (magit-rev-ancestor-p branch upstream)
          t)
-       (if (eq target t)
-           (delete (magit-name-local-branch branch)
-                   (magit-list-containing-branches branch))
-         (and-let* ((target (or target (magit-get-current-branch))))
-           (magit-rev-ancestor-p branch target)))))
+       (cond-let
+         ((eq target t)
+          (delete (magit-name-local-branch branch)
+                  (magit-list-containing-branches branch)))
+         ([target (or target (magit-get-current-branch))]
+          (magit-rev-ancestor-p branch target)))))
 
 (defun magit-get-tracked (refname)
   "Return the remote branch tracked by the remote-tracking branch REFNAME.
 The returned value has the form (REMOTE . REF), where REMOTE is
 the name of a remote and REF is the ref local to the remote."
-  (and-let* ((ref (magit-ref-fullname refname)))
+  (and-let ((ref (magit-ref-fullname refname)))
     (save-match-data
       (seq-some (lambda (line)
                   (and (string-match "\
 \\`remote\\.\\([^.]+\\)\\.fetch=\\+?\\([^:]+\\):\\(.+\\)" line)
-                       (let ((rmt (match-string 1 line))
-                             (src (match-string 2 line))
-                             (dst (match-string 3 line)))
+                       (let ((rmt (match-str 1 line))
+                             (src (match-str 2 line))
+                             (dst (match-str 3 line)))
                          (and (string-match (format "\\`%s\\'"
                                                     (string-replace
                                                      "*" "\\(.+\\)" dst))
                                             ref)
                               (cons rmt (string-replace
-                                         "*" (match-string 1 ref) src))))))
+                                         "*" (match-str 1 ref) src))))))
                 (magit-git-lines "config" "--local" "--list")))))
 
 (defun magit-split-branch-name (branch)
@@ -1887,8 +1908,8 @@ the name of a remote and REF is the ref local to the remote."
                          (and (string-match
                                (format "\\`\\(%s\\)/\\(.+\\)\\'" remote)
                                branch)
-                              (cons (match-string 1 branch)
-                                    (match-string 2 branch))))
+                              (cons (match-str 1 branch)
+                                    (match-str 2 branch))))
                        (magit-list-remotes))
              (error "Invalid branch name %s" branch)))))
 
@@ -1900,17 +1921,17 @@ If optional WITH-DISTANCE is non-nil then return (TAG COMMITS),
 if it is `dirty' return (TAG COMMIT DIRTY).  COMMITS is the number
 of commits in `HEAD' but not in TAG and DIRTY is t if there are
 uncommitted changes, nil otherwise."
-  (and-let* ((str (magit-git-str "describe" "--long" "--tags"
-                                 (and (eq with-distance 'dirty) "--dirty")
-                                 rev)))
+  (and-let ((str (magit-git-str "describe" "--long" "--tags"
+                                (and (eq with-distance 'dirty) "--dirty")
+                                rev)))
     (save-match-data
       (string-match
        "\\(.+\\)-\\(?:0[0-9]*\\|\\([0-9]+\\)\\)-g[0-9a-z]+\\(-dirty\\)?$" str)
       (if with-distance
-          `(,(match-string 1 str)
-            ,(string-to-number (or (match-string 2 str) "0"))
-            ,@(and (match-string 3 str) (list t)))
-        (match-string 1 str)))))
+          `(,(match-str 1 str)
+            ,(string-to-number (or (match-str 2 str) "0"))
+            ,@(and (match-str 3 str) (list t)))
+        (match-str 1 str)))))
 
 (defun magit-get-next-tag (&optional rev with-distance)
   "Return the closest tag from which REV is reachable.
@@ -1920,10 +1941,10 @@ If no such tag can be found or if the distance is 0 (in which
 case it is the current tag, not the next), return nil instead.
 If optional WITH-DISTANCE is non-nil, then return (TAG COMMITS)
 where COMMITS is the number of commits in TAG but not in REV."
-  (and-let* ((str (magit-git-str "describe" "--contains" (or rev "HEAD"))))
+  (and-let ((str (magit-git-str "describe" "--contains" (or rev "HEAD"))))
     (save-match-data
       (when (string-match "^[^^~]+" str)
-        (setq str (match-string 0 str))
+        (setq str (match-str 0 str))
         (unless (equal str (magit-get-current-tag rev))
           (if with-distance
               (list str (car (magit-rev-diff-count str rev)))
@@ -1938,22 +1959,26 @@ rather than those from `magit-list-refs-namespaces'.
 FORMAT is passed to the `--format' flag of `git for-each-ref'
 and defaults to \"%(refname)\".
 
-SORTBY is a key or list of keys to pass to the `--sort' flag of
-`git for-each-ref'.  When nil, use `magit-list-refs-sortby'"
-  (unless format
-    (setq format "%(refname)"))
-  (seq-keep (lambda (line)
-              (pcase-let* ((`(,symrefp ,value)
-                            (split-string line ""))
-                           (symrefp (not (equal symrefp ""))))
-                (and (not symrefp) value)))
-            (magit-git-lines "for-each-ref"
-                             (concat "--format=%(symref)" format)
-                             (mapcar (##concat "--sort=" %)
-                                     (pcase (or sortby magit-list-refs-sortby)
-                                       ((and val (pred stringp)) (list val))
-                                       ((and val (pred listp)) val)))
-                             (or namespaces magit-list-refs-namespaces))))
+SORTBY is a key or list of keys to pass to the `--sort' flag
+of `git for-each-ref' to sort the refs within each namespace.
+When nil, use `magit-list-refs-sortby'.  If both are nil, use
+\"version:refname\", but only for \"refs/tags\"."
+  (let ((format (concat "--format=%(symref)" (or format "%(refname)")))
+        (sortby (mapcar (##concat "--sort=" %)
+                        (ensure-list (or sortby magit-list-refs-sortby)))))
+    (seq-keep (lambda (line)
+                (pcase-let* ((`(,symrefp ,value)
+                              (split-string line ""))
+                             (symrefp (not (equal symrefp ""))))
+                  (and (not symrefp) value)))
+              (mapcan (lambda (ns)
+                        (if (and (not sortby)
+                                 (equal ns "refs/tags"))
+                            (magit-git-lines "for-each-ref" format
+                                             "--sort=-version:refname" ns)
+                          (magit-git-lines "for-each-ref" format sortby ns)))
+                      (ensure-list
+                       (or namespaces magit-list-refs-namespaces))))))
 
 (defun magit-list-branches ()
   (magit-list-refs (list "refs/heads" "refs/remotes")))
@@ -1964,34 +1989,34 @@ SORTBY is a key or list of keys to pass to the `--sort' flag of
 (defun magit-list-remote-branches (&optional remote)
   (magit-list-refs (concat "refs/remotes/" remote)))
 
-(defun magit-list-related-branches (relation &optional commit &rest args)
+(defun magit-list-related-branches (relation &optional rev &rest args)
   (seq-remove (##string-match-p "\\(\\`(HEAD\\|HEAD -> \\)" %)
               (mapcar (##substring % 2)
-                      (magit-git-lines "branch" args relation commit))))
+                      (magit-git-lines "branch" args relation rev))))
 
-(defun magit-list-containing-branches (&optional commit &rest args)
-  (magit-list-related-branches "--contains" commit args))
+(defun magit-list-containing-branches (&optional rev &rest args)
+  (magit-list-related-branches "--contains" rev args))
 
-(defun magit-list-publishing-branches (&optional commit)
-  (seq-filter (##magit-rev-ancestor-p (or commit "HEAD") %)
+(defun magit-list-publishing-branches (&optional rev)
+  (seq-filter (##magit-rev-ancestor-p (or rev "HEAD") %)
               magit-published-branches))
 
-(defun magit-list-merged-branches (&optional commit &rest args)
-  (magit-list-related-branches "--merged" commit args))
+(defun magit-list-merged-branches (&optional rev &rest args)
+  (magit-list-related-branches "--merged" rev args))
 
-(defun magit-list-unmerged-branches (&optional commit &rest args)
-  (magit-list-related-branches "--no-merged" commit args))
+(defun magit-list-unmerged-branches (&optional rev &rest args)
+  (magit-list-related-branches "--no-merged" rev args))
 
 (defun magit-list-unmerged-to-upstream-branches ()
-  (seq-filter (##and-let* ((upstream (magit-get-upstream-branch %)))
+  (seq-filter (##and-let ((upstream (magit-get-upstream-branch %)))
                 (member % (magit-list-unmerged-branches upstream)))
               (magit-list-local-branch-names)))
 
-(defun magit-list-branches-pointing-at (commit)
+(defun magit-list-branches-pointing-at (rev)
   (let ((re (format "\\`%s refs/\\(heads\\|remotes\\)/\\(.*\\)\\'"
-                    (magit-rev-verify commit))))
+                    (magit-rev-verify rev))))
     (seq-keep (##and (string-match re %)
-                     (let ((name (match-string 2 %)))
+                     (let ((name (match-str 2 %)))
                        (and (not (string-suffix-p "HEAD" name))
                             name)))
               (magit-git-lines "show-ref"))))
@@ -2019,7 +2044,7 @@ SORTBY is a key or list of keys to pass to the `--sort' flag of
   (if (and remote relative)
       (let ((regexp (format "^refs/remotes/%s/\\(.+\\)" remote)))
         (mapcan (##when (string-match regexp %)
-                  (list (match-string 1 %)))
+                  (list (match-str 1 %)))
                 (magit-list-remote-branches remote)))
     (magit-list-refnames (concat "refs/remotes/" remote))))
 
@@ -2065,21 +2090,20 @@ SORTBY is a key or list of keys to pass to the `--sort' flag of
             (magit-git-lines "ls-remote" remote)))
 
 (defun magit-remote-head (remote)
-  (and-let* ((line (cl-find-if
-                    (##string-match
+  (and$ (cl-find-if (##string-match
                      "\\`ref: refs/heads/\\([^\s\t]+\\)[\s\t]HEAD\\'" %)
-                    (magit-git-lines "ls-remote" "--symref" remote "HEAD"))))
-    (match-string 1 line)))
+                    (magit-git-lines "ls-remote" "--symref" remote "HEAD"))
+        (match-str 1 $)))
 
 (defun magit-list-modified-modules ()
   (seq-keep (##and (string-match "\\`\\+\\([^ ]+\\) \\(.+\\) (.+)\\'" %)
-                   (match-string 2 %))
+                   (match-str 2 %))
             (magit-git-lines "submodule" "status")))
 
 (defun magit-list-module-paths ()
   (magit-with-toplevel
     (mapcan (##and (string-match "^160000 [0-9a-z]\\{40,\\} 0\t\\(.+\\)$" %)
-                   (list (match-string 1 %)))
+                   (list (match-str 1 %)))
             (magit-git-items "ls-files" "-z" "--stage"))))
 
 (defun magit-list-module-names ()
@@ -2223,26 +2247,26 @@ If `first-parent' is set, traverse only first parents."
                         "\t")))
 
 (defun magit-abbrev-length ()
-  (let ((abbrev (magit-get "core.abbrev")))
-    (if (and abbrev (not (equal abbrev "auto")))
-        (string-to-number abbrev)
-      ;; Guess the length git will be using based on an example
-      ;; abbreviation.  Actually HEAD's abbreviation might be an
-      ;; outlier, so use the shorter of the abbreviations for two
-      ;; commits.  See #3034.
-      (if-let ((head (magit-rev-parse "--short" "HEAD"))
-               (head-len (length head)))
-          (min head-len
-               (if-let ((rev (magit-rev-parse "--short" "HEAD~")))
-                   (length rev)
-                 head-len))
-        ;; We're on an unborn branch, but perhaps the repository has
-        ;; other commits.  See #4123.
-        (if-let ((commits (magit-git-lines "rev-list" "-n2" "--all"
-                                           "--abbrev-commit")))
-            (apply #'min (mapcar #'length commits))
-          ;; A commit does not exist.  Fall back to the default of 7.
-          7)))))
+  (cond-let*
+    ([abbrev (magit-get "core.abbrev")]
+     [_(not (equal abbrev "auto"))]
+     (string-to-number abbrev))
+    ;; Guess the length git will be using based on an example
+    ;; abbreviation.  Actually HEAD's abbreviation might be an
+    ;; outlier, so use the shorter of the abbreviations for two
+    ;; commits.  See #3034.
+    ([head (magit-rev-parse "--short" "HEAD")]
+     [head-len (length head)]
+     (min head-len
+          (if-let ((rev (magit-rev-parse "--short" "HEAD~")))
+              (length rev)
+            head-len)))
+    ;; We're on an unborn branch, but perhaps the repository has
+    ;; other commits.  See #4123.
+    ([commits (magit-git-lines "rev-list" "-n2" "--all" "--abbrev-commit")]
+     (apply #'min (mapcar #'length commits)))
+    ;; A commit does not exist.  Fall back to the default of 7.
+    (7)))
 
 (defun magit-abbrev-arg (&optional arg)
   (format "--%s=%d" (or arg "abbrev") (magit-abbrev-length)))
@@ -2250,17 +2274,22 @@ If `first-parent' is set, traverse only first parents."
 (defun magit-rev-abbrev (rev)
   (magit-rev-parse (magit-abbrev-arg "short") rev))
 
-(defun magit-commit-children (commit &optional args)
+(defun magit--abbrev-if-hash (rev)
+  (cond ((or (magit-ref-p rev) (member rev '("{index}" "{worktree}"))) rev)
+        ((magit-rev-parse (magit-abbrev-arg "short") rev))
+        (rev)))
+
+(defun magit-commit-children (rev &optional args)
   (seq-keep (lambda (line)
               (pcase-let ((`(,child . ,parents) (split-string line " ")))
-                (and (member commit parents) child)))
+                (and (member rev parents) child)))
             (magit-git-lines "log" "--format=%H %P"
                              (or args (list "--branches" "--tags" "--remotes"))
-                             "--not" commit)))
+                             "--not" rev)))
 
-(defun magit-commit-parents (commit)
-  (and-let* ((str (magit-git-string "rev-list" "-1" "--parents" commit)))
-    (cdr (split-string str))))
+(defun magit-commit-parents (rev)
+  (and$ (magit-git-string "rev-list" "-1" "--parents" rev)
+        (cdr (split-string $))))
 
 (defun magit-patch-id (rev)
   (with-connection-local-variables
@@ -2290,7 +2319,7 @@ If `first-parent' is set, traverse only first parents."
                     "--"))
 
 (defun magit-format-rev-summary (rev)
-  (and-let* ((str (magit-rev-format "%h %s" rev)))
+  (and-let ((str (magit-rev-format "%h %s" rev)))
     (progn
       (magit--put-face 0 (string-match " " str) 'magit-hash str)
       str)))
@@ -2331,7 +2360,7 @@ and this option only controls what face is used.")
       (dolist (ref refs)
         (let* ((face (cdr (seq-find (##string-match (car %) ref)
                                     magit-ref-namespaces)))
-               (name (match-string 1 ref))
+               (name (match-str 1 ref))
                (name (if (and name
                               (not (string-prefix-p "refs/tags/" ref))
                               (magit-rev-verify (concat "refs/tags/" name)))
@@ -2351,8 +2380,8 @@ and this option only controls what face is used.")
             (seq-keep
              (lambda (name)
                (if (string-match "\\`\\([^/]*\\)/\\(.*\\)\\'" name)
-                   (let ((r (match-string 1 name))
-                         (b (match-string 2 name)))
+                   (let ((r (match-str 1 name))
+                         (b (match-str 2 name)))
                      (and (not (equal b "HEAD"))
                           (if (equal (concat "refs/remotes/" name)
                                      (magit-git-string
@@ -2383,20 +2412,19 @@ and this option only controls what face is used.")
                             (magit--propertize-face
                              name '(magit-branch-upstream
                                     magit-branch-local)))))
-             (t
-              (push (concat push name) combined)))))
-        (when (and target (not upstream))
-          (if (member target remotes)
-              (progn
-                (magit--add-face-text-property
-                 0 (length target) 'magit-branch-upstream nil target)
-                (setq upstream target)
-                (setq remotes  (delete target remotes)))
-            (when-let ((target (car (member target combined))))
-              (magit--add-face-text-property
-               0 (length target) 'magit-branch-upstream nil target)
-              (setq upstream target)
-              (setq combined (delete target combined))))))
+             ((push (concat push name) combined)))))
+        (cond-let
+          ((or upstream (not target)))
+          ((member target remotes)
+           (magit--add-face-text-property
+            0 (length target) 'magit-branch-upstream nil target)
+           (setq upstream target)
+           (setq remotes (delete target remotes)))
+          ([target (car (member target combined))]
+           (magit--add-face-text-property
+            0 (length target) 'magit-branch-upstream nil target)
+           (setq upstream target)
+           (setq combined (delete target combined)))))
       (string-join (flatten-tree `(,state
                                    ,head
                                    ,upstream
@@ -2409,14 +2437,14 @@ and this option only controls what face is used.")
 (defun magit-object-type (object)
   (magit-git-string "cat-file" "-t" object))
 
-(defmacro magit-with-blob (commit file &rest body)
+(defmacro magit-with-blob (rev file &rest body)
   (declare (indent 2)
            (debug (form form body)))
   `(magit--with-temp-process-buffer
      (let ((buffer-file-name ,file))
        (save-excursion
          (magit-git-insert "cat-file" "-p"
-                           (concat ,commit ":" buffer-file-name)))
+                           (concat ,rev ":" buffer-file-name)))
        (decode-coding-inserted-region
         (point-min) (point-max) buffer-file-name t nil nil t)
        ,@body)))
@@ -2431,9 +2459,9 @@ and this option only controls what face is used.")
        (unwind-protect
            (magit-with-toplevel
              (when-let* ((tree ,tree)
-                         ((not (magit-git-success
-                                "read-tree" ,arg tree
-                                (concat "--index-output=" ,file)))))
+                         (_(not (magit-git-success
+                                 "read-tree" ,arg tree
+                                 (concat "--index-output=" ,file)))))
                (error "Cannot read tree %s" tree))
              (with-environment-variables (("GIT_INDEX_FILE" ,file))
                ,@body))
@@ -2467,33 +2495,34 @@ and this option only controls what face is used.")
           "\\(\\.\\.\\.?\\)"            ; range marker
           "\\([^.][^ \t]*\\)?\\'"))     ; revB
 
-(defun magit-split-range (range)
-  (pcase-let ((`(,beg ,end ,sep) (magit--split-range-raw range)))
-    (and sep
-         (let ((beg (or beg "HEAD"))
+(defun magit-split-range (range &optional abbrev)
+  (pcase-let* ((`(,beg ,end ,sep) (magit--split-range-raw range))
+               (beg (or beg "HEAD"))
                (end (or end "HEAD")))
-           (if (string-equal (match-string 2 range) "...")
-               (and-let* ((base (magit-git-string "merge-base" beg end)))
-                 (cons base end))
-             (cons beg end))))))
+    (when abbrev
+      (setq beg (magit--abbrev-if-hash beg))
+      (setq end (magit--abbrev-if-hash end)))
+    (pcase sep
+      (".."  (cons beg end))
+      ("..." (and$ (magit-git-string "merge-base" beg end)
+                   (cons (if abbrev (magit-rev-abbrev $) $)
+                         end))))))
 
 (defun magit--split-range-raw (range)
   (and (string-match magit-range-re range)
-       (let ((beg (match-string 1 range))
-             (end (match-string 3 range)))
+       (magit-bind-match-strings (beg sep end) range
          (and (or beg end)
-              (list beg end (match-string 2 range))))))
+              (list beg end sep)))))
 
 (defun magit-hash-range (range)
   (if (string-match magit-range-re range)
-      (let ((beg (match-string 1 range))
-            (end (match-string 3 range)))
+      (magit-bind-match-strings (beg sep end) range
         (and (or beg end)
-             (let ((beg-hash (and beg (magit-rev-hash (match-string 1 range))))
-                   (end-hash (and end (magit-rev-hash (match-string 3 range)))))
+             (let ((beg-hash (and beg (magit-rev-hash beg)))
+                   (end-hash (and end (magit-rev-hash end))))
                (and (or (not beg) beg-hash)
                     (or (not end) end-hash)
-                    (concat beg-hash (match-string 2 range) end-hash)))))
+                    (concat beg-hash sep end-hash)))))
     (magit-rev-hash range)))
 
 (defvar magit-revision-faces
@@ -2600,29 +2629,29 @@ and this option only controls what face is used.")
                              (magit-get-current-branch))))
 
 (defun magit-read-branch-or-commit (prompt &optional secondary-default exclude)
-  (let ((current (magit-get-current-branch))
-        (branch-at-point (magit-branch-at-point))
-        (commit-at-point (magit-commit-at-point))
-        (choices (delete exclude (magit-list-refnames nil t))))
-    (when (equal current exclude)
+  (let* ((current (magit-get-current-branch))
+         (branch-at-point (magit-branch-at-point))
+         (commit-at-point (magit-commit-at-point))
+         (exclude (ensure-list exclude))
+         (choices (cl-set-difference (magit-list-refnames nil t)
+                                     exclude :test #'equal)))
+    (when (member current exclude)
       (setq current nil))
-    (when (equal branch-at-point exclude)
+    (when (member branch-at-point exclude)
       (setq branch-at-point nil))
     (when (and commit-at-point (not branch-at-point))
       (setq choices (cons commit-at-point choices)))
     (minibuffer-with-setup-hook #'magit--minibuf-default-add-commit
-      (or (magit-completing-read
-           prompt choices nil nil nil 'magit-revision-history
-           (or branch-at-point commit-at-point secondary-default current))
-          (user-error "Nothing selected")))))
+      (magit-completing-read
+       prompt choices nil 'any nil 'magit-revision-history
+       (or branch-at-point commit-at-point secondary-default current)))))
 
 (defun magit-read-range-or-commit (prompt &optional secondary-default)
   (magit-read-range
    prompt
-   (or (and-let* ((revs (magit-region-values '(commit branch) t)))
-         (progn
-           (deactivate-mark)
-           (concat (car (last revs)) ".." (car revs))))
+   (or (and-let ((revs (magit-region-values '(commit branch) t)))
+         (prog1 (concat (car (last revs)) ".." (car revs))
+           (deactivate-mark)))
        (magit-branch-or-commit-at-point)
        secondary-default
        (magit-get-current-branch))))
@@ -2635,7 +2664,7 @@ and this option only controls what face is used.")
     (magit-completing-read-multiple
      (concat prompt ": ")
      (magit-list-refnames)
-     nil nil nil 'magit-revision-history default nil t)))
+     nil 'any nil 'magit-revision-history default nil t)))
 
 (defun magit-read-remote-branch
     (prompt &optional remote default local-branch require-match)
@@ -2648,7 +2677,8 @@ and this option only controls what face is used.")
                                           (magit-list-remotes))))
                            (magit-list-remote-branch-names remote t)
                            :test #'equal)
-                 nil require-match nil 'magit-revision-history default)))
+                 nil (or require-match 'any)
+                 nil 'magit-revision-history default)))
     (if (or remote (string-match "\\`\\([^/]+\\)/\\(.+\\)" choice))
         choice
       (user-error "`%s' doesn't have the form REMOTE/BRANCH" choice))))
@@ -2657,7 +2687,8 @@ and this option only controls what face is used.")
   (magit-completing-read prompt
                          (prog2 (message "Determining available refs...")
                              (magit-remote-list-refs remote)
-                           (message "Determining available refs...done"))))
+                           (message "Determining available refs...done"))
+                         nil 'any))
 
 (defun magit-read-local-branch (prompt &optional secondary-default)
   (magit-completing-read prompt (magit-list-local-branch-names)
@@ -2673,10 +2704,9 @@ and this option only controls what face is used.")
     (when commit
       (push commit choices))
     (minibuffer-with-setup-hook #'magit--minibuf-default-add-commit
-      (or (magit-completing-read prompt choices
-                                 nil nil nil 'magit-revision-history
-                                 (or (magit-local-branch-at-point) commit))
-          (user-error "Nothing selected")))))
+      (magit-completing-read prompt choices
+                             nil 'any nil 'magit-revision-history
+                             (or (magit-local-branch-at-point) commit)))))
 
 (defun magit-read-local-branch-or-ref (prompt &optional secondary-default)
   (magit-completing-read prompt (nconc (magit-list-local-branch-names)
@@ -2687,7 +2717,7 @@ and this option only controls what face is used.")
                              (magit-get-current-branch))))
 
 (defun magit-read-other-branch
-    (prompt &optional exclude secondary-default no-require-match)
+    (prompt &optional exclude secondary-default)
   (let* ((current (magit-get-current-branch))
          (atpoint (magit-branch-at-point))
          (exclude (or exclude current))
@@ -2696,8 +2726,7 @@ and this option only controls what face is used.")
                       secondary-default
                       (magit-get-previous-branch))))
     (magit-completing-read prompt (delete exclude (magit-list-branch-names))
-                           nil (not no-require-match)
-                           nil 'magit-revision-history default)))
+                           nil t nil 'magit-revision-history default)))
 
 (defun magit-read-other-branch-or-commit
     (prompt &optional exclude secondary-default)
@@ -2712,12 +2741,11 @@ and this option only controls what face is used.")
                       secondary-default
                       (magit-get-previous-branch))))
     (minibuffer-with-setup-hook #'magit--minibuf-default-add-commit
-      (or (magit-completing-read prompt (delete exclude (magit-list-refnames))
-                                 nil nil nil 'magit-revision-history default)
-          (user-error "Nothing selected")))))
+      (magit-completing-read prompt (delete exclude (magit-list-refnames))
+                             nil 'any nil 'magit-revision-history default))))
 
 (defun magit-read-other-local-branch
-    (prompt &optional exclude secondary-default no-require-match)
+    (prompt &optional exclude secondary-default)
   (let* ((current (magit-get-current-branch))
          (atpoint (magit-local-branch-at-point))
          (exclude (or exclude current))
@@ -2727,8 +2755,7 @@ and this option only controls what face is used.")
                       (magit-get-previous-branch))))
     (magit-completing-read prompt
                            (delete exclude (magit-list-local-branch-names))
-                           nil (not no-require-match)
-                           nil 'magit-revision-history default)))
+                           nil t nil 'magit-revision-history default)))
 
 (defun magit-read-branch-prefer-other (prompt)
   (let* ((current (magit-get-current-branch))
@@ -2759,7 +2786,7 @@ out.  Only existing branches can be selected."
      (or (let ((r (car (member (magit-remote-branch-at-point) branches)))
                (l (car (member (magit-local-branch-at-point) branches))))
            (if magit-prefer-remote-upstream (or r l) (or l r)))
-         (and-let* ((main (magit-main-branch)))
+         (and-let ((main (magit-main-branch)))
            (let ((r (car (member (concat "origin/" main) branches)))
                  (l (car (member main branches))))
              (if magit-prefer-remote-upstream (or r l) (or l r))))
@@ -2778,7 +2805,7 @@ out.  Only existing branches can be selected."
        (nconc (list "HEAD")
               (magit-list-refnames)
               (directory-files (magit-gitdir) nil "_HEAD\\'"))
-       nil nil nil 'magit-revision-history
+       nil 'any nil 'magit-revision-history
        (or default (magit--default-starting-point)))
       (user-error "Nothing selected")))
 
@@ -2790,9 +2817,9 @@ out.  Only existing branches can be selected."
       (magit-stash-at-point)
       (magit-get-current-branch)))
 
-(defun magit-read-tag (prompt &optional require-match)
-  (magit-completing-read prompt (magit-list-tags) nil
-                         require-match nil 'magit-revision-history
+(defun magit-read-tag (prompt)
+  (magit-completing-read prompt (magit-list-tags) nil t nil
+                         'magit-revision-history
                          (magit-tag-at-point)))
 
 (defun magit-read-stash (prompt)
@@ -2810,7 +2837,16 @@ out.  Only existing branches can be selected."
                                          (car choices))))
     (and choice
          (string-match "^\\([^ ]+\\) \\(.+\\)" choice)
-         (substring-no-properties (match-string 1 choice)))))
+         (substring-no-properties (match-str 1 choice)))))
+
+(defun magit-read-shelved-branch (prompt)
+  (magit-completing-read
+   prompt
+   (mapcar (##substring % 8)
+           (nreverse (magit-list-refnames "refs/shelved")))
+   nil t nil nil
+   (and$ (magit-section-value-if 'shelved-branch)
+         (substring $ 13))))
 
 (defun magit-read-remote (prompt &optional default use-only)
   (let ((remotes (magit-list-remotes)))
@@ -2826,7 +2862,7 @@ out.  Only existing branches can be selected."
   (magit-completing-read prompt
                          (nconc (magit-list-remotes)
                                 (list "https://" "git://" "git@"))
-                         nil nil nil nil
+                         nil 'any nil nil
                          (or default
                              (magit-remote-at-point)
                              (magit-get-remote))))
@@ -2841,25 +2877,36 @@ out.  Only existing branches can be selected."
   ;; and some repositories have thousands of submodules.
   (let ((magit--refresh-cache (list (cons 0 0)))
         (modules nil))
-    (if current-prefix-arg
-        (progn
-          (setq modules (magit-list-module-paths))
-          (when predicate
-            (setq modules (seq-filter predicate modules)))
-          (unless modules
-            (if predicate
-                (user-error "No modules satisfying %s available" predicate)
-              (user-error "No modules available"))))
-      (setq modules (magit-region-values 'module))
-      (when modules
-        (when predicate
-          (setq modules (seq-filter predicate modules)))
-        (unless modules
-          (user-error "No modules satisfying %s selected" predicate))))
+    (cond (current-prefix-arg
+           (setq modules (magit-list-module-paths))
+           (when predicate
+             (setq modules (seq-filter predicate modules)))
+           (unless modules
+             (if predicate
+                 (user-error "No modules satisfying %s available" predicate)
+               (user-error "No modules available"))))
+          (t
+           (setq modules (magit-region-values 'module))
+           (when modules
+             (when predicate
+               (setq modules (seq-filter predicate modules)))
+             (unless modules
+               (user-error "No modules satisfying %s selected" predicate)))))
     (if (or (length> modules 1) current-prefix-arg)
         (magit-confirm t nil (format "%s %%d modules" verb) nil modules)
       (list (magit-read-module-path (format "%s module" verb) predicate)))))
 
 ;;; _
 (provide 'magit-git)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-git.el ends here
diff --git a/elpa/magit-20250519.1537/magit-gitignore.el b/elpa/magit-20251103.1130/magit-gitignore.el
similarity index 91%
rename from elpa/magit-20250519.1537/magit-gitignore.el
rename to elpa/magit-20251103.1130/magit-gitignore.el
index 0ee63df0..ef2bc7a3 100644
--- a/elpa/magit-20250519.1537/magit-gitignore.el
+++ b/elpa/magit-20251103.1130/magit-gitignore.el
@@ -118,9 +118,9 @@ Rules that are defined in that file affect all local repositories."
            (mapcan
             (lambda (file)
               (cons (concat "/" file)
-                    (and-let* ((ext (file-name-extension file)))
-                      (list (concat "/" (file-name-directory file) "*." ext)
-                            (concat "*." ext)))))
+                    (and$ (file-name-extension file)
+                          (list (concat "/" (file-name-directory file) "*." $)
+                                (concat "*." $)))))
             (sort (nconc
                    (magit-untracked-files nil base)
                    ;; The untracked section of the status buffer lists
@@ -138,7 +138,7 @@ Rules that are defined in that file affect all local repositories."
         (unless (member default choices)
           (setq default nil))))
     (magit-completing-read "File or pattern to ignore"
-                           choices nil nil nil nil default)))
+                           choices nil 'any nil nil default)))
 
 ;;; Skip Worktree Commands
 
@@ -192,4 +192,15 @@ Rules that are defined in that file affect all local repositories."
 
 ;;; _
 (provide 'magit-gitignore)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-gitignore.el ends here
diff --git a/elpa/magit-20250519.1537/magit-log.el b/elpa/magit-20251103.1130/magit-log.el
similarity index 83%
rename from elpa/magit-20250519.1537/magit-log.el
rename to elpa/magit-20251103.1130/magit-log.el
index 3c4ac21d..3e5b4fc9 100644
--- a/elpa/magit-20250519.1537/magit-log.el
+++ b/elpa/magit-20251103.1130/magit-log.el
@@ -32,7 +32,7 @@
 (require 'magit-diff)
 
 (declare-function magit--any-wip-mode-enabled-p "magit-wip" ())
-(declare-function magit-blob-visit "magit-files" (blob-or-file))
+(declare-function magit-blob-visit "magit-files" (rev file))
 (declare-function magit-cherry-apply "magit-sequence" (commit &optional args))
 (declare-function magit-insert-head-branch-header "magit-status"
                   (&optional branch))
@@ -48,9 +48,10 @@
 (defvar magit-refs-focus-column-width)
 (defvar magit-refs-margin)
 (defvar magit-refs-show-commit-count)
-(defvar magit-buffer-margin)
+(defvar magit--right-margin-config)
 (defvar magit-status-margin)
 (defvar magit-status-sections-hook)
+(defvar magit-status-use-buffer-arguments)
 
 (require 'ansi-color)
 (require 'crm)
@@ -78,7 +79,7 @@
   :group 'magit-log
   :type 'hook)
 
-(defcustom magit-log-remove-graph-args '("--follow" "--grep" "-G" "-S" "-L")
+(defcustom magit-log-remove-graph-args '("--follow" "-G" "-S" "-L")
   "The log arguments that cause the `--graph' argument to be dropped.
 
 The default value lists the arguments that are incompatible with
@@ -87,10 +88,10 @@ can add additional arguments that are available in `magit-log',
 but I recommend that you don't do that.  Nowadays I would define
 this as a constant, but I am preserving it as an option, in case
 someone actually customized it."
-  :package-version '(magit . "2.3.0")
+  :package-version '(magit . "4.3.7")
   :group 'magit-log
   :type '(repeat (string :tag "Argument"))
-  :options '("--follow" "--grep" "-G" "-S" "-L"))
+  :options '("--follow" "-G" "-S" "-L"))
 
 (defcustom magit-log-revision-headers-format "\
 %+b%+N
@@ -170,6 +171,23 @@ want to use the same functions for both hooks."
   :options (list #'magit-highlight-squash-markers
                  #'magit-highlight-bracket-keywords))
 
+(defcustom magit-log-trailer-labels nil
+  "Whether and how to insert labels, derived from commit message trailers.
+
+If non-nil, the value has the form (FUNCTION . OPTIONS).  FUNCTION is
+called with one argument, the trailers as an alist, and should return a
+string, which is then inserted in between the refnames and the message,
+or nil.  OPTIONS specifies additional options for \"%(trailers)\".  You
+should probably use something like \"key=KEY1,key=KEY2,only=true\".
+\"unfold=true,separator=^^,key_value_separator=^_\" is always appended
+to the options specified here.  See the git-log(1) manpage."
+  :package-version '(magit . "4.4.1")
+  :group 'magit-log
+  :type '(choice (const :tag "Ignore trailers" nil)
+                 (cons  :tag "Process trailers"
+                        (function :tag "Formatting function")
+                        (string   :tag "Options for %%(trailers)"))))
+
 (defcustom magit-log-header-line-function #'magit-log-header-line-sentence
   "Function used to generate text shown in header line of log buffers."
   :package-version '(magit . "2.12.0")
@@ -370,11 +388,15 @@ commits before and half after."
 
 ;;;; Prefix Methods
 
+(cl-defmethod transient-prefix-value ((obj magit-log-prefix))
+  (let ((args (cl-call-next-method obj)))
+    (list (seq-filter #'atom args)
+          (cdr (assoc "--" args)))))
+
 (cl-defmethod transient-init-value ((obj magit-log-prefix))
   (pcase-let ((`(,args ,files)
-               (magit-log--get-value 'magit-log-mode
-                                     magit-prefix-use-buffer-arguments)))
-    (when-let (((not (eq transient-current-command 'magit-dispatch)))
+               (magit-log--get-value 'magit-log-mode 'prefix)))
+    (when-let ((_(not (eq transient-current-command 'magit-dispatch)))
                (file (magit-file-relative-name)))
       (setq files (list file)))
     (oset obj value (if files `(("--" ,@files) ,@args) args))))
@@ -396,40 +418,38 @@ commits before and half after."
 (defun magit-log-arguments (&optional mode)
   "Return the current log arguments."
   (if (memq transient-current-command '(magit-log magit-log-refresh))
-      (magit--transient-args-and-files)
-    (magit-log--get-value (or mode 'magit-log-mode))))
+      (transient-args transient-current-command)
+    (magit-log--get-value (or mode 'magit-log-mode) 'direct)))
 
 (defun magit-log--get-value (mode &optional use-buffer-args)
-  (unless use-buffer-args
-    (setq use-buffer-args magit-direct-use-buffer-arguments))
-  (let (args files)
-    (cond
-     ((and (memq use-buffer-args '(always selected current))
-           (eq major-mode mode))
-      (setq args  magit-buffer-log-args)
-      (setq files magit-buffer-log-files))
-     ((when-let (((memq use-buffer-args '(always selected)))
-                 (buffer (magit-get-mode-buffer
-                          mode nil
-                          (eq use-buffer-args 'selected))))
-        (setq args  (buffer-local-value 'magit-buffer-log-args buffer))
-        (setq files (buffer-local-value 'magit-buffer-log-files buffer))
-        t))
-     ((plist-member (symbol-plist mode) 'magit-log-current-arguments)
-      (setq args (get mode 'magit-log-current-arguments)))
-     ((when-let ((elt (assq (intern (format "magit-log:%s" mode))
-                            transient-values)))
-        (setq args (cdr elt))
-        t))
-     (t
-      (setq args (get mode 'magit-log-default-arguments))))
-    (list args files)))
+  (setq use-buffer-args
+        (pcase-exhaustive use-buffer-args
+          ('prefix magit-prefix-use-buffer-arguments)
+          ('status magit-status-use-buffer-arguments)
+          ('direct magit-direct-use-buffer-arguments)
+          ('nil    magit-direct-use-buffer-arguments)
+          ((or 'always 'selected 'current 'never)
+           use-buffer-args)))
+  (cond-let
+    ((and (memq use-buffer-args '(always selected current))
+          (eq major-mode mode))
+     (list magit-buffer-log-args
+           magit-buffer-log-files))
+    ([_(memq use-buffer-args '(always selected))]
+     [buffer (magit-get-mode-buffer mode nil (eq use-buffer-args 'selected))]
+     (list (buffer-local-value 'magit-buffer-log-args buffer)
+           (buffer-local-value 'magit-buffer-log-files buffer)))
+    ((plist-member (symbol-plist mode) 'magit-log-current-arguments)
+     (list (get mode 'magit-log-current-arguments) nil))
+    ([elt (assq (intern (format "magit-log:%s" mode)) transient-values)]
+     (list (cdr elt) nil))
+    ((list (get mode 'magit-log-default-arguments) nil))))
 
 (defun magit-log--set-value (obj &optional save)
   (pcase-let* ((obj  (oref obj prototype))
                (mode (or (oref obj major-mode) major-mode))
                (key  (intern (format "magit-log:%s" mode)))
-               (`(,args ,files) (magit--transient-args-and-files)))
+               (`(,args ,files) (transient-args (oref obj command))))
     (put mode 'magit-log-current-arguments args)
     (when save
       (setf (alist-get key transient-values) args)
@@ -639,13 +659,13 @@ commits before and half after."
   "SPC" #'self-insert-command)
 
 (defun magit-log-read-revs (&optional use-current)
-  (or (and use-current (and-let* ((buf (magit-get-current-branch))) (list buf)))
+  (or (and use-current (and$ (magit-get-current-branch) (list $)))
       (let ((crm-separator "\\(\\.\\.\\.?\\|[, ]\\)")
             (crm-local-completion-map magit-log-read-revs-map))
         (split-string (magit-completing-read-multiple
                        "Log rev,s: "
                        (magit-list-refnames nil t)
-                       nil nil nil 'magit-revision-history
+                       nil 'any nil 'magit-revision-history
                        (or (magit-branch-or-commit-at-point)
                            (and (not use-current)
                                 (magit-get-previous-branch)))
@@ -722,18 +742,18 @@ completion candidates."
 ;;;###autoload
 (defun magit-log-matching-branches (pattern &optional args files)
   "Show log for all branches matching PATTERN and `HEAD'."
-  (interactive (cons (magit-log-read-pattern "--branches") (magit-log-arguments)))
-  (magit-log-setup-buffer
-   (list "HEAD" (format "--branches=%s" pattern))
-   args files))
+  (interactive (cons (magit-log-read-pattern "--branches")
+                     (magit-log-arguments)))
+  (magit-log-setup-buffer (list "HEAD" (format "--branches=%s" pattern))
+                          args files))
 
 ;;;###autoload
 (defun magit-log-matching-tags (pattern &optional args files)
   "Show log for all tags matching PATTERN and `HEAD'."
-  (interactive (cons (magit-log-read-pattern "--tags") (magit-log-arguments)))
-  (magit-log-setup-buffer
-   (list "HEAD" (format "--tags=%s" pattern))
-   args files))
+  (interactive (cons (magit-log-read-pattern "--tags")
+                     (magit-log-arguments)))
+  (magit-log-setup-buffer (list "HEAD" (format "--tags=%s" pattern))
+                          args files))
 
 ;;;###autoload
 (defun magit-log-all-branches (&optional args files)
@@ -748,10 +768,7 @@ completion candidates."
 (defun magit-log-all (&optional args files)
   "Show log for all references and `HEAD'."
   (interactive (magit-log-arguments))
-  (magit-log-setup-buffer (if (magit-get-current-branch)
-                              (list "--all")
-                            (list "HEAD" "--all"))
-                          args files))
+  (magit-log-setup-buffer (list "--all") args files))
 
 ;;;###autoload
 (defun magit-log-buffer-file (&optional follow beg end)
@@ -780,7 +797,7 @@ restrict the log to the lines that the region touches."
     (user-error "Buffer isn't visiting a file")))
 
 ;;;###autoload
-(defun magit-log-trace-definition (file fn rev)
+(defun magit-log-trace-definition (file fn commit)
   "Show log for the definition at point."
   (interactive (list (or (magit-file-relative-name)
                          (user-error "Buffer isn't visiting a file"))
@@ -791,7 +808,7 @@ restrict the log to the lines that the region touches."
                          "HEAD")))
   (require 'magit)
   (magit-log-setup-buffer
-   (list rev)
+   (list commit)
    (cons (format "-L:%s%s:%s"
                  (string-replace ":" "\\:" (regexp-quote fn))
                  (if (derived-mode-p 'lisp-mode 'emacs-lisp-mode)
@@ -865,6 +882,13 @@ https://github.com/mhagger/git-when-merged."
         (user-error "Could not find when %s was merged into %s: %s"
                     commit branch m)))))
 
+;;;###autoload
+(defun magit-delete-shelved-branch (branch)
+  "Delete the shelved BRANCH.
+Delete a ref created by `magit-branch-shelve'."
+  (interactive (list (magit-read-shelved-branch "Log shelved branch")))
+  (magit-run-git "update-ref" "-d" (concat "refs/shelved/" branch)))
+
 ;;;; Limit Commands
 
 (defun magit-log-toggle-commit-limit ()
@@ -887,7 +911,7 @@ limit.  Otherwise set it to 256."
 (defun magit-log-set-commit-limit (fn)
   (let* ((val magit-buffer-log-args)
          (arg (seq-find (##string-match "^-n\\([0-9]+\\)?$" %) val))
-         (num (and arg (string-to-number (match-string 1 arg))))
+         (num (and arg (string-to-number (match-str 1 arg))))
          (num (if num (funcall fn num 2) 256)))
     (setq val (remove arg val))
     (setq magit-buffer-log-args
@@ -897,9 +921,9 @@ limit.  Otherwise set it to 256."
   (magit-refresh))
 
 (defun magit-log-get-commit-limit (&optional args)
-  (and-let* ((str (seq-find (##string-match "^-n\\([0-9]+\\)?$" %)
-                            (or args magit-buffer-log-args))))
-    (string-to-number (match-string 1 str))))
+  (and$ (seq-find (##string-match "^-n\\([0-9]+\\)?$" %)
+                  (or args magit-buffer-log-args))
+        (string-to-number (match-str 1 $))))
 
 ;;;; Mode Commands
 
@@ -909,15 +933,15 @@ Like `magit-mode-bury-buffer' (which see) but with a negative
 prefix argument instead bury the revision buffer, provided it
 is displayed in the current frame."
   (interactive "p")
-  (if (< arg 0)
-      (let* ((buf (magit-get-mode-buffer 'magit-revision-mode))
-             (win (and buf (get-buffer-window buf (selected-frame)))))
-        (if win
-            (with-selected-window win
-              (with-current-buffer buf
-                (magit-mode-bury-buffer (> (abs arg) 1))))
-          (user-error "No revision buffer in this frame")))
-    (magit-mode-bury-buffer (> arg 1))))
+  (cond-let*
+    ((>= arg 0)
+     (magit-mode-bury-buffer (> arg 1)))
+    ([buf (magit-get-mode-buffer 'magit-revision-mode)]
+     [win (get-buffer-window buf (selected-frame))]
+     (with-selected-window win
+       (with-current-buffer buf
+         (magit-mode-bury-buffer (> (abs arg) 1)))))
+    ((user-error "No revision buffer in this frame"))))
 
 ;;;###autoload
 (defun magit-log-move-to-parent (&optional n)
@@ -937,33 +961,31 @@ is displayed in the current frame."
                       "\\[magit-log-double-commit-limit] first"))))
         (user-error "Parent %s does not exist" parent-rev)))))
 
-(defun magit-log-move-to-revision (rev)
-  "Read a revision and move to it in current log buffer.
+(defun magit-log-move-to-revision (commit)
+  "Read a commit and move to it in current log buffer.
 
-If the chosen reference or revision isn't being displayed in
+If the chosen reference or commit isn't being displayed in
 the current log buffer, then inform the user about that and do
 nothing else.
 
 If invoked outside any log buffer, then display the log buffer
 of the current repository first; creating it if necessary."
   (interactive
-   (list (or (magit-completing-read
-              "In log, jump to"
-              (magit-list-refnames nil t)
-              nil nil nil 'magit-revision-history
-              (or (and-let* ((rev (magit-commit-at-point)))
-                    (magit-rev-fixup-target rev))
-                  (magit-get-current-branch)))
-             (user-error "Nothing selected"))))
+   (list (magit-completing-read
+          "In log, jump to"
+          (magit-list-refnames nil t)
+          nil 'any nil 'magit-revision-history
+          (or (and$ (magit-commit-at-point)
+                    (magit-rev-fixup-target $))
+              (magit-get-current-branch)))))
   (with-current-buffer
       (cond ((derived-mode-p 'magit-log-mode)
              (current-buffer))
-            ((and-let* ((buf (magit-get-mode-buffer 'magit-log-mode)))
-               (pop-to-buffer-same-window buf)))
-            (t
-             (apply #'magit-log-all-branches (magit-log-arguments))))
-    (unless (magit-log-goto-commit-section (magit-rev-abbrev rev))
-      (user-error "%s isn't visible in the current log buffer" rev))))
+            ((and$ (magit-get-mode-buffer 'magit-log-mode)
+                   (pop-to-buffer-same-window $)))
+            ((apply #'magit-log-all-branches (magit-log-arguments))))
+    (unless (magit-log-goto-commit-section (magit-rev-abbrev commit))
+      (user-error "%s isn't visible in the current log buffer" commit))))
 
 ;;;; Shortlog Commands
 
@@ -996,12 +1018,12 @@ of the current repository first; creating it if necessary."
         (switch-to-buffer-other-window (current-buffer))))))
 
 ;;;###autoload
-(defun magit-shortlog-since (rev args)
+(defun magit-shortlog-since (commit args)
   "Show a history summary for commits since REV."
   (interactive
    (list (magit-read-branch-or-commit "Shortlog since" (magit-get-current-tag))
          (transient-args 'magit-shortlog)))
-  (magit-git-shortlog (concat rev "..") args))
+  (magit-git-shortlog (concat commit "..") args))
 
 ;;;###autoload
 (defun magit-shortlog-range (rev-or-range args)
@@ -1203,6 +1225,19 @@ Type \\[magit-reset] to reset `HEAD' to the commit at point.
   (declare (obsolete magit--insert-log "Magit 4.0.0"))
   (magit--insert-log nil revs args files))
 
+(defconst magit-log-heading-format
+  ;; See `magit-log-heading-re'.
+  (concat "--format="
+          "%s"         ;  4     graph    --graph
+          "%%h%%x0c"   ;  1 %h  hash
+          "%s%%x0c"    ;  3 %D  refs     --decorate
+          "%s%%x0c"    ;  7 %G? gpg      --show-signature
+          "%%aN%%x0c"  ;  5 %aN author
+          "%s%%x0c"    ;  6 %at date     magit-log-margin-show-committer-date
+          "%s%%x0c"    ; 12 %() trailers magit-log-trailer-labels
+          "%%s"        ;  2 %s  msg
+          "%s"))       ; \n ..  headers  magit-log-revision-headers-format
+
 (defun magit--insert-log (keep-error revs &optional args files)
   "Insert a log section.
 Do not add this to a hook variable."
@@ -1212,7 +1247,7 @@ Do not add this to a hook variable."
          (remove "--literal-pathspecs" magit-git-global-arguments)))
     (magit--git-wash (apply-partially #'magit-log-wash-log 'log) keep-error
       "log"
-      (format "--format=%s%%h%%x0c%s%%x0c%s%%x0c%%aN%%x0c%s%%x0c%%s%s"
+      (format magit-log-heading-format
               (if (and (member "--left-right" args)
                        (not (member "--graph" args)))
                   "%m "
@@ -1235,6 +1270,13 @@ Do not add this to a hook variable."
                     "")
                    ("%G?"))))
               (if magit-log-margin-show-committer-date "%ct" "%at")
+              (if magit-log-trailer-labels
+                  (format "%%(trailers:%s%s)"
+                          (if (not (equal (cdr magit-log-trailer-labels) ""))
+                              (concat (cdr magit-log-trailer-labels) ",")
+                            "")
+                          "unfold=true,separator=,key_value_separator=")
+                "")
               (if (member "++header" args)
                   (if (member "--graph" (setq args (remove "++header" args)))
                       (concat "\n" magit-log-revision-headers-format "\n")
@@ -1243,7 +1285,7 @@ Do not add this to a hook variable."
       (progn
         (when-let ((order (seq-find (##string-match "^\\+\\+order=\\(.+\\)$" %)
                                     args)))
-          (setq args (cons (format "--%s-order" (match-string 1 order))
+          (setq args (cons (format "--%s-order" (match-str 1 order))
                            (remove order args))))
         (when (member "--decorate" args)
           (setq args (cons "--decorate=full" (remove "--decorate" args))))
@@ -1271,18 +1313,20 @@ Do not add this to a hook variable."
   :parent magit-commit-section-map)
 
 (defconst magit-log-heading-re
-  ;; Note: A form feed instead of a null byte is used as the delimiter
-  ;; because using the latter interferes with the graph prefix when
-  ;; ++header is used.
+  ;; Use a form feed instead of a null byte as the delimiter because using
+  ;; the latter interferes with the graph prefix when ++header is used.
   (concat "^"
           "\\(?4:[-_/|\\*o<>. ]*\\)"               ; graph
           "\\(?1:[0-9a-fA-F]+\\)?"               ; hash
           "\\(?3:[^\n]+\\)?"                   ; refs
           "\\(?7:[BGUXYREN]\\)?"                 ; gpg
           "\\(?5:[^\n]*\\)"                    ; author
-          ;; Note: Date is optional because, prior to Git v2.19.0,
-          ;; `git rebase -i --root` corrupts the root's author date.
+          ;; Prior to Git v2.19.0, "git rebase -i --root" corrupted the
+          ;; root's author date.  Keep date optional because even though
+          ;; we no longer support such old releases, the roots they create
+          ;; may live on.
           "\\(?6:[^\n]*\\)"                    ; date
+          "\\(?12:[^\n]+\\)?"                  ; trailers
           "\\(?2:.*\\)$"))                         ; msg
 
 (defconst magit-log-cherry-re
@@ -1376,129 +1420,145 @@ Do not add this to a hook variable."
                 ('stash      magit-log-stash-re)
                 ('bisect-vis magit-log-bisect-vis-re)
                 ('bisect-log magit-log-bisect-log-re)))
-  (magit-bind-match-strings
-      (hash msg refs graph author date gpg cherry _ refsub side) nil
-    (setq msg (substring-no-properties msg))
-    (when refs
-      (setq refs (substring-no-properties refs)))
-    (let ((align (or (eq style 'cherry)
-                     (not (member "--stat" magit-buffer-log-args))))
-          (non-graph-re (if (eq style 'bisect-vis)
-                            magit-log-bisect-vis-re
-                          magit-log-heading-re)))
-      (magit-delete-line)
-      ;; If the reflog entries have been pruned, the output of `git
-      ;; reflog show' includes a partial line that refers to the hash
-      ;; of the youngest expired reflog entry.
-      (when (and (eq style 'reflog) (not date))
-        (cl-return-from magit-log-wash-rev t))
-      (magit-insert-section
-          ((eval (pcase style
-                   ('stash  'stash)
-                   ('module 'module-commit)
-                   (_       'commit)))
-           hash)
-        (setq hash (propertize (if (eq style 'bisect-log)
-                                   (magit-rev-parse "--short" hash)
-                                 hash)
-                               'font-lock-face
-                               (pcase (and gpg (aref gpg 0))
-                                 (?G 'magit-signature-good)
-                                 (?B 'magit-signature-bad)
-                                 (?U 'magit-signature-untrusted)
-                                 (?X 'magit-signature-expired)
-                                 (?Y 'magit-signature-expired-key)
-                                 (?R 'magit-signature-revoked)
-                                 (?E 'magit-signature-error)
-                                 (?N 'magit-hash)
-                                 (_  'magit-hash))))
-        (when cherry
-          (when (and (derived-mode-p 'magit-refs-mode)
-                     magit-refs-show-commit-count)
-            (insert (make-string (1- magit-refs-focus-column-width) ?\s)))
-          (insert (propertize cherry 'font-lock-face
-                              (if (string= cherry "-")
-                                  'magit-cherry-equivalent
-                                'magit-cherry-unmatched)))
-          (insert ?\s))
-        (when side
-          (insert (propertize side 'font-lock-face
-                              (if (string= side "<")
-                                  'magit-cherry-equivalent
-                                'magit-cherry-unmatched)))
-          (insert ?\s))
-        (when align
-          (insert hash ?\s))
-        (when graph
-          (insert graph))
-        (unless align
-          (insert hash ?\s))
-        (when (and refs (not magit-log-show-refname-after-summary))
-          (insert (magit-format-ref-labels refs) ?\s))
-        (when (eq style 'reflog)
-          (insert (format "%-2s " (1- magit-log-count)))
-          (when refsub
-            (insert (magit-reflog-format-subject
-                     (substring refsub 0
-                                (if (string-search ":" refsub) -2 -1))))))
-        (insert (magit-log--wash-summary msg))
-        (when (and refs magit-log-show-refname-after-summary)
-          (insert ?\s)
-          (insert (magit-format-ref-labels refs)))
-        (insert ?\n)
-        (when (memq style '(log reflog stash))
-          (goto-char (line-beginning-position))
-          (when (and refsub
-                     (string-match "\\`\\([^ ]\\) \\+\\(..\\)\\(..\\)" date))
-            (setq date (+ (string-to-number (match-string 1 date))
-                          (* (string-to-number (match-string 2 date)) 60 60)
-                          (* (string-to-number (match-string 3 date)) 60))))
-          (magit-log-format-margin hash author date))
-        (when (and (eq style 'cherry)
-                   (magit-buffer-margin-p))
-          (apply #'magit-log-format-margin hash
-                 (split-string (magit-rev-format "%aN%x00%ct" hash) "\0")))
-        (when (and graph
-                   (not (eobp))
-                   (not (looking-at non-graph-re)))
-          (when (looking-at "")
+  (let* ((hash     (match-str 1))
+         (msg      (match-str 2))
+         (refs     (match-str 3))
+         (refs     (and refs (magit-format-ref-labels refs)))
+         (graph    (match-string 4))
+         (author   (match-str 5))
+         (date     (match-str 6))
+         (gpg      (match-str 7))
+         (cherry   (match-str 8))
+         (refsub   (match-str 10))
+         (side     (match-str 11))
+         (trailers (match-str 12))
+         (trailers (and trailers
+                        (funcall (car magit-log-trailer-labels)
+                                 (mapcar (##split-string % "")
+                                         (split-string trailers "")))))
+         (align    (or (eq style 'cherry)
+                       (not (member "--stat" magit-buffer-log-args))))
+         (non-graph-re (if (eq style 'bisect-vis)
+                           magit-log-bisect-vis-re
+                         magit-log-heading-re)))
+    (magit-delete-line)
+    ;; If the reflog entries have been pruned, the output of `git
+    ;; reflog show' includes a partial line that refers to the hash
+    ;; of the youngest expired reflog entry.
+    (when (and (eq style 'reflog) (not date))
+      (cl-return-from magit-log-wash-rev t))
+    (magit-insert-section
+        ((eval (pcase style
+                 ('stash  'stash)
+                 ('module 'module-commit)
+                 (_       'commit)))
+         hash)
+      (setq hash (propertize (if (eq style 'bisect-log)
+                                 (magit-rev-parse "--short" hash)
+                               hash)
+                             'font-lock-face
+                             (pcase (and gpg (aref gpg 0))
+                               (?G 'magit-signature-good)
+                               (?B 'magit-signature-bad)
+                               (?U 'magit-signature-untrusted)
+                               (?X 'magit-signature-expired)
+                               (?Y 'magit-signature-expired-key)
+                               (?R 'magit-signature-revoked)
+                               (?E 'magit-signature-error)
+                               (?N 'magit-hash)
+                               (_  'magit-hash))))
+      (when cherry
+        (when (and (derived-mode-p 'magit-refs-mode)
+                   magit-refs-show-commit-count)
+          (insert (make-string (1- magit-refs-focus-column-width) ?\s)))
+        (insert (propertize cherry 'font-lock-face
+                            (if (string= cherry "-")
+                                'magit-cherry-equivalent
+                              'magit-cherry-unmatched)))
+        (insert ?\s))
+      (when side
+        (insert (propertize side 'font-lock-face
+                            (if (string= side "<")
+                                'magit-cherry-equivalent
+                              'magit-cherry-unmatched)))
+        (insert ?\s))
+      (when align
+        (insert hash ?\s))
+      (when graph
+        (insert graph))
+      (unless align
+        (insert hash ?\s))
+      (unless magit-log-show-refname-after-summary
+        (when refs
+          (insert refs ?\s))
+        (when trailers
+          (insert trailers ?\s)))
+      (when (eq style 'reflog)
+        (insert (format "%-2s " (1- magit-log-count)))
+        (when refsub
+          (insert (magit-reflog-format-subject
+                   (substring refsub 0
+                              (if (string-search ":" refsub) -2 -1))))))
+      (insert (magit-log--wash-summary msg))
+      (when magit-log-show-refname-after-summary
+        (when refs
+          (insert ?\s refs))
+        (when trailers
+          (insert ?\s trailers)))
+      (insert ?\n)
+      (when (memq style '(log reflog stash))
+        (goto-char (line-beginning-position))
+        (when (and refsub
+                   (string-match "\\`\\([^ ]\\) \\+\\(..\\)\\(..\\)" date))
+          (setq date (+ (string-to-number (match-str 1 date))
+                        (* (string-to-number (match-str 2 date)) 60 60)
+                        (* (string-to-number (match-str 3 date)) 60))))
+        (magit-log-format-margin hash author date))
+      (when (and (eq style 'cherry)
+                 (magit--right-margin-active))
+        (apply #'magit-log-format-margin hash
+               (split-string (magit-rev-format "%aN%x00%ct" hash) "\0")))
+      (when (and graph
+                 (not (eobp))
+                 (not (looking-at non-graph-re)))
+        (when (looking-at "")
+          (magit-insert-heading)
+          (delete-char 1)
+          (magit-insert-section (commit-header)
+            (forward-line)
             (magit-insert-heading)
-            (delete-char 1)
-            (magit-insert-section (commit-header)
-              (forward-line)
-              (magit-insert-heading)
-              (re-search-forward "")
-              (delete-char -1)
-              (forward-char)
-              (insert ?\n))
-            (delete-char 1))
-          (if (looking-at "^\\(---\\|\n\s\\|\ndiff\\)")
-              (let ((limit (save-excursion
-                             (and (re-search-forward non-graph-re nil t)
-                                  (match-beginning 0)))))
-                (unless (oref magit-insert-section--current content)
-                  (magit-insert-heading))
-                (delete-char (if (looking-at "\n") 1 4))
-                (magit-diff-wash-diffs (list "--stat") limit))
+            (re-search-forward "")
+            (delete-char -1)
+            (forward-char)
+            (insert ?\n))
+          (delete-char 1))
+        (if (looking-at "^\\(---\\|\n\s\\|\ndiff\\)")
+            (let ((limit (save-excursion
+                           (and (re-search-forward non-graph-re nil t)
+                                (match-beginning 0)))))
+              (unless (oref magit-insert-section--current content)
+                (magit-insert-heading))
+              (delete-char (if (looking-at "\n") 1 4))
+              (magit-diff-wash-diffs (list "--stat") limit))
+          (when align
+            (setq align (make-string (1+ abbrev) ? )))
+          (when (and (not (eobp)) (not (looking-at non-graph-re)))
             (when align
               (setq align (make-string (1+ abbrev) ? )))
-            (when (and (not (eobp)) (not (looking-at non-graph-re)))
+            (while (and (not (eobp)) (not (looking-at non-graph-re)))
               (when align
-                (setq align (make-string (1+ abbrev) ? )))
-              (while (and (not (eobp)) (not (looking-at non-graph-re)))
-                (when align
-                  (save-excursion (insert align)))
-                (forward-line)
-                (magit-make-margin-overlay))
-              ;; When `--format' is used and its value isn't one of the
-              ;; predefined formats, then `git-log' does not insert a
-              ;; separator line.
-              (save-excursion
-                (forward-line -1)
-                (looking-at "[-_/|\\*o<>. ]*"))
-              (setq graph (match-string 0))
-              (unless (string-match-p "[/\\.]" graph)
-                (insert graph ?\n))))))))
+                (save-excursion (insert align)))
+              (forward-line)
+              (magit-make-margin-overlay))
+            ;; When `--format' is used and its value isn't one of the
+            ;; predefined formats, then `git-log' does not insert a
+            ;; separator line.
+            (save-excursion
+              (forward-line -1)
+              (looking-at "[-_/|\\*o<>. ]*"))
+            (setq graph (match-string 0))
+            (unless (string-match-p "[/\\.]" graph)
+              (insert graph ?\n)))))))
   t)
 
 (defun magit-log--wash-summary (summary)
@@ -1530,7 +1590,8 @@ exists mostly for backward compatibility reasons."
 
 (defun magit-log-maybe-update-revision-buffer (&optional _)
   "When moving in a log or cherry buffer, update the revision buffer.
-If there is no revision buffer in the same frame, then do nothing."
+If there is no revision buffer in the same frame, then do nothing.
+See also info node `(magit)Section Movement'."
   (when (derived-mode-p 'magit-log-mode 'magit-cherry-mode 'magit-reflog-mode)
     (magit--maybe-update-revision-buffer)))
 
@@ -1558,7 +1619,8 @@ If there is no revision buffer in the same frame, then do nothing."
 
 (defun magit-log-maybe-update-blob-buffer (&optional _)
   "When moving in a log or cherry buffer, update the blob buffer.
-If there is no blob buffer in the same frame, then do nothing."
+If there is no blob buffer in the same frame, then do nothing.
+See also info node `(magit)Section Movement'."
   (when (derived-mode-p 'magit-log-mode 'magit-cherry-mode 'magit-reflog-mode)
     (magit--maybe-update-blob-buffer)))
 
@@ -1580,9 +1642,9 @@ If there is no blob buffer in the same frame, then do nothing."
              (with-selected-window (get-buffer-window buf)
                (with-current-buffer buf
                  (save-excursion
-                   (magit-blob-visit (list (magit-rev-parse rev)
-                                           (magit-file-relative-name
-                                            magit-buffer-file-name)))))))))))))
+                   (magit-blob-visit (magit-rev-parse rev)
+                                     (magit-file-relative-name
+                                      magit-buffer-file-name))))))))))))
 
 (defun magit-log-goto-commit-section (rev)
   (let ((abbrev (magit-rev-format "%h" rev)))
@@ -1609,18 +1671,18 @@ The shortstat style is experimental and rather slow."
   (interactive)
   (setq magit-log-margin-show-shortstat
         (not magit-log-margin-show-shortstat))
-  (magit-set-buffer-margin nil t))
+  (magit-set-buffer-margins nil t))
 
 (defun magit-log-format-margin (rev author date)
-  (when (magit-margin-option)
+  (when (magit--right-margin-option)
     (if magit-log-margin-show-shortstat
         (magit-log-format-shortstat-margin rev)
       (magit-log-format-author-margin author date))))
 
 (defun magit-log-format-author-margin (author date)
   (pcase-let ((`(,_ ,style ,width ,details ,details-width)
-               (or magit-buffer-margin
-                   (symbol-value (magit-margin-option))
+               (or magit--right-margin-config
+                   (symbol-value (magit--right-margin-option))
                    (error "No margin format specified for %s" major-mode))))
     (magit-make-margin-overlay
      (concat (and details
@@ -1743,15 +1805,14 @@ Type \\[magit-log-select-quit] to abort without selecting a commit."
   (magit-log-select-setup-buffer
    (or branch (magit-get-current-branch) "HEAD")
    (append args
-           (car (magit-log--get-value 'magit-log-select-mode
-                                      magit-direct-use-buffer-arguments))))
+           (car (magit-log--get-value 'magit-log-select-mode 'direct))))
   (if initial
       (magit-log-goto-commit-section initial)
-    (while-let ((rev (magit-section-value-if 'commit))
-                ((string-match-p "\\`\\(squash!\\|fixup!\\|amend!\\)"
-                                 (magit-rev-format "%s" rev)))
-                (section (magit-current-section))
-                (next (car (magit-section-siblings section 'next))))
+    (while-let* ((rev (magit-section-value-if 'commit))
+                 (_(string-match-p "\\`\\(squash!\\|fixup!\\|amend!\\)"
+                                   (magit-rev-format "%s" rev)))
+                 (section (magit-current-section))
+                 (next (car (magit-section-siblings section 'next))))
       (magit-section-goto next)))
   (setq magit-log-select-pick-function pick)
   (setq magit-log-select-quit-function quit)
@@ -1909,7 +1970,7 @@ need an unique value, so we use that string in the pushremote case."
   "Insert commits that haven't been pulled from the push-remote yet."
   (when-let* ((target (magit-get-push-branch))
               (range  (concat ".." target))
-              ((magit--insert-pushremote-log-p)))
+              (_(magit--insert-pushremote-log-p)))
     (magit-insert-section (unpulled range t)
       (magit-insert-heading
         (format (propertize "Unpulled from %s."
@@ -1989,7 +2050,7 @@ Show the last `magit-log-section-commit-count' commits."
   "Insert commits that haven't been pushed to the push-remote yet."
   (when-let* ((target (magit-get-push-branch))
               (range  (concat target ".."))
-              ((magit--insert-pushremote-log-p)))
+              (_(magit--insert-pushremote-log-p)))
     (magit-insert-section (unpushed range t)
       (magit-insert-heading
         (format (propertize "Unpushed to %s."
@@ -2048,4 +2109,15 @@ all others with \"-\"."
 
 ;;; _
 (provide 'magit-log)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-log.el ends here
diff --git a/elpa/magit-20250519.1537/magit-margin.el b/elpa/magit-20251103.1130/magit-margin.el
similarity index 60%
rename from elpa/magit-20250519.1537/magit-margin.el
rename to elpa/magit-20251103.1130/magit-margin.el
index b710fbdd..841da400 100644
--- a/elpa/magit-20250519.1537/magit-margin.el
+++ b/elpa/magit-20251103.1130/magit-margin.el
@@ -49,17 +49,32 @@ does not carry to other options."
   :link '(info-link "(magit)Log Margin")
   :group 'magit-log)
 
-(defvar-local magit-buffer-margin nil)
-(put 'magit-buffer-margin 'permanent-local t)
+;;; Settings
 
-(defvar-local magit-set-buffer-margin-refresh nil)
+(defvar-local magit--right-margin-delayed nil)
 
-(defvar magit--age-spec)
+(defvar-local magit--right-margin-config nil)
+(put 'magit--right-margin-config 'permanent-local t)
+
+(defun magit--right-margin-active ()
+  (car magit--right-margin-config))
+
+(defun magit--right-margin-option ()
+  (pcase major-mode
+    ('magit-cherry-mode        'magit-cherry-margin)
+    ('magit-log-mode           'magit-log-margin)
+    ('magit-log-select-mode    'magit-log-select-margin)
+    ('magit-reflog-mode        'magit-reflog-margin)
+    ('magit-refs-mode          'magit-refs-margin)
+    ('magit-stashes-mode       'magit-stashes-margin)
+    ('magit-status-mode        'magit-status-margin)
+    ('forge-notifications-mode 'magit-status-margin)
+    ('forge-topics-mode        'magit-status-margin)))
 
 ;;; Commands
 
 (transient-define-prefix magit-margin-settings ()
-  "Change what information is displayed in the margin."
+  "Change what information is displayed in the right margin."
   :info-manual "(magit) Log Margin"
   ["Margin"
    (magit-toggle-margin)
@@ -68,96 +83,89 @@ does not carry to other options."
    (magit-refs-set-show-commit-count)])
 
 (transient-define-suffix magit-toggle-margin ()
-  "Show or hide the Magit margin."
+  "Show or hide the right margin."
   :description "Toggle visibility"
   :key "L"
   :transient t
   (interactive)
-  (unless (magit-margin-option)
+  (unless (magit--right-margin-option)
     (user-error "Magit margin isn't supported in this buffer"))
-  (setcar magit-buffer-margin (not (magit-buffer-margin-p)))
-  (magit-set-buffer-margin))
+  (setcar magit--right-margin-config (not (magit--right-margin-active)))
+  (magit-set-buffer-margins))
 
 (defvar magit-margin-default-time-format nil
   "See https://github.com/magit/magit/pull/4605.")
 
 (transient-define-suffix magit-cycle-margin-style ()
-  "Cycle style used for the Magit margin."
+  "Cycle style used for the right margin."
   :description "Cycle style"
   :key "l"
   :transient t
   (interactive)
-  (unless (magit-margin-option)
+  (unless (magit--right-margin-option)
     (user-error "Magit margin isn't supported in this buffer"))
   ;; This is only suitable for commit margins (there are not others).
-  (setf (cadr magit-buffer-margin)
-        (pcase (cadr magit-buffer-margin)
+  (setf (cadr magit--right-margin-config)
+        (pcase (cadr magit--right-margin-config)
           ('age 'age-abbreviated)
           ('age-abbreviated
            (let ((default (or magit-margin-default-time-format
-                              (cadr (symbol-value (magit-margin-option))))))
+                              (cadr (symbol-value (magit--right-margin-option))))))
              (if (stringp default) default "%Y-%m-%d %H:%M ")))
           (_ 'age)))
-  (magit-set-buffer-margin nil t))
+  (magit-set-buffer-margins nil t))
 
 (transient-define-suffix magit-toggle-margin-details ()
-  "Show or hide details in the Magit margin."
+  "Show or hide details in the right margin."
   :description "Toggle details"
   :key "d"
   :transient t
   (interactive)
-  (unless (magit-margin-option)
+  (unless (magit--right-margin-option)
     (user-error "Magit margin isn't supported in this buffer"))
-  (setf (nth 3 magit-buffer-margin)
-        (not (nth 3 magit-buffer-margin)))
-  (magit-set-buffer-margin nil t))
+  (setf (nth 3 magit--right-margin-config)
+        (not (nth 3 magit--right-margin-config)))
+  (magit-set-buffer-margins nil t))
 
 ;;; Core
 
-(defun magit-buffer-margin-p ()
-  (car magit-buffer-margin))
-
-(defun magit-margin-option ()
-  (pcase major-mode
-    ('magit-cherry-mode     'magit-cherry-margin)
-    ('magit-log-mode        'magit-log-margin)
-    ('magit-log-select-mode 'magit-log-select-margin)
-    ('magit-reflog-mode     'magit-reflog-margin)
-    ('magit-refs-mode       'magit-refs-margin)
-    ('magit-stashes-mode    'magit-stashes-margin)
-    ('magit-status-mode     'magit-status-margin)
-    ('forge-notifications-mode 'magit-status-margin)
-    ('forge-topics-mode     'magit-status-margin)))
-
-(defun magit-set-buffer-margin (&optional reset refresh)
-  (when-let ((option (magit-margin-option)))
-    (let* ((default (symbol-value option))
-           (default-width (nth 2 default)))
-      (when (or reset (not magit-buffer-margin))
-        (setq magit-buffer-margin (copy-sequence default)))
-      (pcase-let ((`(,enable ,style ,_width ,details ,details-width)
-                   magit-buffer-margin))
-        (when (functionp default-width)
-          (setf (nth 2 magit-buffer-margin)
-                (funcall default-width style details details-width)))
-        (dolist (window (get-buffer-window-list nil nil 0))
-          (with-selected-window window
-            (magit-set-window-margin window)
-            (if enable
-                (add-hook  'window-configuration-change-hook
-                           #'magit-set-window-margin nil t)
-              (remove-hook 'window-configuration-change-hook
-                           #'magit-set-window-margin t))))
-        (when (and enable (or refresh magit-set-buffer-margin-refresh))
-          (magit-refresh-buffer))))))
-
-(defun magit-set-window-margin (&optional window)
+(defun magit-set-buffer-margins (&optional reset-right refresh-right)
+  (let ((lmargin nil)
+        (rmargin nil)
+        (roption (magit--right-margin-option)))
+    (when (or lmargin roption)
+      (when roption
+        (let* ((default (symbol-value roption))
+               (default-width (nth 2 default)))
+          (when (or reset-right (not magit--right-margin-config))
+            (setq magit--right-margin-config (copy-sequence default)))
+          (pcase-let ((`(,enable ,style ,_width ,details ,details-width)
+                       magit--right-margin-config))
+            (setq rmargin enable)
+            (when (functionp default-width)
+              (setf (nth 2 magit--right-margin-config)
+                    (funcall default-width style details details-width))))))
+      (dolist (window (get-buffer-window-list nil nil 0))
+        (with-selected-window window
+          (magit-set-window-margins window)
+          (if (or lmargin rmargin)
+              (add-hook  'window-configuration-change-hook
+                         #'magit-set-window-margins nil t)
+            (remove-hook 'window-configuration-change-hook
+                         #'magit-set-window-margins t))))
+      (when (and rmargin (or refresh-right magit--right-margin-delayed))
+        (magit-refresh-buffer)))))
+
+(defun magit-set-window-margins (&optional window)
   (when (or window (setq window (get-buffer-window)))
     (with-selected-window window
       (set-window-margins
-       nil (car (window-margins))
-       (and (magit-buffer-margin-p)
-            (nth 2 magit-buffer-margin))))))
+       nil
+       (if (characterp (car magit-section-visibility-indicator))
+           1
+         (car (window-margins)))
+       (and (magit--right-margin-active)
+            (nth 2 magit--right-margin-config))))))
 
 (cl-defun magit-make-margin-overlay (&optional string (previous-line nil sline))
   "Display STRING in the margin of the previous (or current) line.
@@ -180,7 +188,7 @@ line is affected."
      [remote branchbuf]
      [shelved branchbuf]
      [tags branchbuf]
-     topics issues pullreqs))
+     topics discussions issues pullreqs))
 
 (defun magit-maybe-make-margin-overlay ()
   (when (magit-section-match magit-margin-overlay-conditions
@@ -195,7 +203,7 @@ line is affected."
   (dolist (buffer (buffer-list))
     (with-current-buffer buffer
       (when (eq major-mode mode)
-        (magit-set-buffer-margin t)
+        (magit-set-buffer-margins t)
         (magit-refresh))))
   (message "Updating margins in %s buffers...done" mode))
 
@@ -233,21 +241,31 @@ as an option, because most other parts of Magit are always in
 English.")
 
 (defun magit--age (date &optional abbreviate)
-  (cl-labels ((fn (age spec)
-                (pcase-let ((`(,char ,unit ,units ,weight) (car spec)))
-                  (let ((cnt (round (/ age weight 1.0))))
-                    (if (or (not (cdr spec))
-                            (>= (/ age weight) 1))
-                        (list cnt (cond (abbreviate char)
-                                        ((= cnt 1) unit)
-                                        (t units)))
-                      (fn age (cdr spec)))))))
-    (fn (abs (- (float-time)
-                (if (stringp date)
-                    (string-to-number date)
-                  date)))
-        magit--age-spec)))
+  (named-let calc ((age (abs (- (float-time)
+                                (if (stringp date)
+                                    (string-to-number date)
+                                  date))))
+                   (spec magit--age-spec))
+    (pcase-let* ((`((,char ,unit ,units ,weight) . ,spec) spec)
+                 (cnt (round (/ age weight 1.0))))
+      (if (or (not spec)
+              (>= (/ age weight) 1))
+          (list cnt (cond (abbreviate char)
+                          ((= cnt 1) unit)
+                          (units)))
+        (calc age spec)))))
 
 ;;; _
 (provide 'magit-margin)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-margin.el ends here
diff --git a/elpa/magit-20250519.1537/magit-merge.el b/elpa/magit-20251103.1130/magit-merge.el
similarity index 91%
rename from elpa/magit-20250519.1537/magit-merge.el
rename to elpa/magit-20251103.1130/magit-merge.el
index 4dc003ff..ae5a8203 100644
--- a/elpa/magit-20250519.1537/magit-merge.el
+++ b/elpa/magit-20251103.1130/magit-merge.el
@@ -172,21 +172,21 @@ then also remove the respective remote branch."
              (format "Do you really want to merge `%s' into another branch? "
                      branch))
       (user-error "Abort")))
-  (if-let ((target (magit-get-push-branch branch t)))
-      (progn
-        (magit-git-push branch target (list "--force-with-lease"))
-        (set-process-sentinel
-         magit-this-process
-         (lambda (process event)
-           (when (memq (process-status process) '(exit signal))
-             (if (not (zerop (process-exit-status process)))
-                 (magit-process-sentinel process event)
-               (process-put process 'inhibit-refresh t)
-               (magit-process-sentinel process event)
-               (magit--merge-absorb-1 branch args))
-             (when message
-               (message message))))))
-    (magit--merge-absorb-1 branch args)))
+  (cond-let
+    ([target (magit-get-push-branch branch t)]
+     (magit-git-push branch target (list "--force-with-lease"))
+     (set-process-sentinel
+      magit-this-process
+      (lambda (process event)
+        (when (memq (process-status process) '(exit signal))
+          (if (not (zerop (process-exit-status process)))
+              (magit-process-sentinel process event)
+            (process-put process 'inhibit-refresh t)
+            (magit-process-sentinel process event)
+            (magit--merge-absorb-1 branch args))
+          (when message
+            (message message))))))
+    ((magit--merge-absorb-1 branch args))))
 
 (defun magit--merge-absorb-1 (branch args)
   (if-let ((pr (magit-get "branch" branch "pullRequest")))
@@ -241,15 +241,14 @@ then also remove the respective remote branch."
   "During a conflict checkout and stage side, or restore conflict."
   (interactive
    (let ((file (magit-completing-read "Checkout file"
-                                      (magit-tracked-files) nil nil nil
+                                      (magit-tracked-files) nil 'any nil
                                       'magit-read-file-hist
                                       (magit-current-file))))
      (cond ((member file (magit-unmerged-files))
             (list file (magit-checkout-read-stage file)))
            ((yes-or-no-p (format "Restore conflicts in %s? " file))
             (list file "--merge"))
-           (t
-            (user-error "Quit")))))
+           ((user-error "Quit")))))
   (pcase (cons arg (cddr (car (magit-file-status file))))
     ((or `("--ours"   ?D ,_)
          '("--ours"   ?U ?A)
@@ -312,4 +311,15 @@ If no merge is in progress, do nothing."
 
 ;;; _
 (provide 'magit-merge)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-merge.el ends here
diff --git a/elpa/magit-20250519.1537/magit-mode.el b/elpa/magit-20251103.1130/magit-mode.el
similarity index 81%
rename from elpa/magit-20250519.1537/magit-mode.el
rename to elpa/magit-20251103.1130/magit-mode.el
index 34af2422..f70d1db7 100644
--- a/elpa/magit-20250519.1537/magit-mode.el
+++ b/elpa/magit-20251103.1130/magit-mode.el
@@ -53,18 +53,16 @@
 
 ;;; Options
 
-(defcustom magit-mode-hook
-  (list #'magit-load-config-extensions)
+(defcustom magit-mode-hook nil
   "Hook run when entering a mode derived from Magit mode."
-  :package-version '(magit . "3.0.0")
+  :package-version '(magit . "4.4.2")
   :group 'magit-modes
   :type 'hook
-  :options (list #'magit-load-config-extensions
-                 #'bug-reference-mode))
+  :options (list #'bug-reference-mode))
 
 (defcustom magit-setup-buffer-hook
   (list #'magit-maybe-save-repository-buffers
-        'magit-set-buffer-margin) ; from magit-margin.el
+        'magit-set-buffer-margins) ; from magit-margin.el
   "Hook run by `magit-setup-buffer'.
 
 This is run right after displaying the buffer and right before
@@ -76,7 +74,7 @@ should be used instead of this one."
   :group 'magit-modes
   :type 'hook
   :options (list #'magit-maybe-save-repository-buffers
-                 'magit-set-buffer-margin))
+                 'magit-set-buffer-margins))
 
 (defcustom magit-pre-refresh-hook
   (list #'magit-maybe-save-repository-buffers)
@@ -425,6 +423,7 @@ recommended value."
   "C-c C-w" 'magit-copy-thing
   "C-w"     'magit-copy-section-value
   "M-w"     'magit-copy-buffer-revision
+  "<remap> <mouse-set-point>"     'magit-mouse-set-point
   "<remap> <back-to-indentation>" 'magit-back-to-indentation
   "<remap> <previous-line>"       'magit-previous-line
   "<remap> <next-line>"           'magit-next-line
@@ -435,52 +434,52 @@ recommended value."
   "This is a placeholder command, which signals an error if called.
 Where applicable, other keymaps remap this command to another,
 which actually deletes the thing at point."
+  (declare (completion ignore))
   (interactive)
   (user-error "There is no thing at point that could be deleted"))
-;; Starting with Emacs 28.1 we could use (declare (completion ignore)).
-(put 'magit-delete-thing 'completion-predicate #'ignore)
 
 (defun magit-visit-thing ()
   "This is a placeholder command, which may signal an error if called.
 Where applicable, other keymaps remap this command to another,
 which actually visits the thing at point."
+  (declare (completion ignore))
   (interactive)
-  (if (eq transient-current-command 'magit-dispatch)
-      (call-interactively (key-binding (this-command-keys)))
-    (if-let ((url (thing-at-point 'url t)))
-        (browse-url url)
-      (user-error "There is no thing at point that could be visited"))))
-(put 'magit-visit-thing 'completion-predicate #'ignore)
+  (cond-let
+    ((eq transient-current-command 'magit-dispatch)
+     (call-interactively (key-binding (this-command-keys))))
+    ([url (thing-at-point 'url t)]
+     (browse-url url))
+    ((user-error "There is no thing at point that could be visited"))))
 
 (defun magit-edit-thing ()
   "This is a placeholder command, which may signal an error if called.
 Where applicable, other keymaps remap this command to another,
 which actually lets you edit the thing at point, likely in another
 buffer."
+  (declare (completion ignore))
   (interactive)
   (if (eq transient-current-command 'magit-dispatch)
       (call-interactively (key-binding (this-command-keys)))
     (user-error "There is no thing at point that could be edited")))
-(put 'magit-edit-thing 'completion-predicate #'ignore)
 
 (defun magit-browse-thing ()
   "This is a placeholder command, which may signal an error if called.
 Where applicable, other keymaps remap this command to another,
 which actually visits thing at point using `browse-url'."
+  (declare (completion ignore))
   (interactive)
   (if-let ((url (thing-at-point 'url t)))
       (browse-url url)
     (user-error "There is no thing at point that could be browsed")))
-(put 'magit-browse-thing 'completion-predicate #'ignore)
 
 (defun magit-copy-thing ()
   "This is a placeholder command, which signals an error if called.
 Where applicable, other keymaps remap this command to another,
 which actually copies some representation of the thing at point
 to the kill ring."
+  (declare (completion ignore))
   (interactive)
   (user-error "There is no thing at point that we know how to copy"))
-(put 'magit-copy-thing 'completion-predicate #'ignore)
 
 ;;;###autoload
 (defun magit-info ()
@@ -554,13 +553,6 @@ to the kill ring."
 
 ;;; Mode
 
-(defun magit-load-config-extensions ()
-  "Load Magit extensions that are defined at the Git config layer."
-  (dolist (ext (magit-get-all "magit.extension"))
-    (let ((sym (intern (format "magit-%s-mode" ext))))
-      (when (fboundp sym)
-        (funcall sym 1)))))
-
 (define-derived-mode magit-mode magit-section-mode "Magit"
   "Parent major mode from which Magit major modes inherit.
 
@@ -615,6 +607,21 @@ Magit is documented in info node `(magit)'."
 ;; function does not reinstate this.
 (put 'magit-buffer-diff-files-suspended 'permanent-local t)
 
+(defun magit-buffer-file-name ()
+  "Return `magit-buffer-file-name' or if that is nil `buffer-file-name'.
+In an indirect buffer get the value for its base buffer."
+  (or magit-buffer-file-name
+      (buffer-file-name (buffer-base-buffer))))
+
+(defun magit-buffer-revision ()
+  "Return `magit-buffer-revision' or if that is nil \"{worktree}\".
+If not visiting a blob or file, or the file isn't being tracked,
+return nil."
+  (or magit-buffer-revision
+      (and buffer-file-name
+           (magit-file-tracked-p buffer-file-name)
+           "{worktree}")))
+
 (cl-defgeneric magit-buffer-value ()
   "Return the value of the current buffer.
 The \"value\" identifies what is being displayed in the buffer.
@@ -626,24 +633,35 @@ The buffer's major-mode should derive from `magit-section-mode'."
 
 ;;; Setup Buffer
 
-(defmacro magit-setup-buffer (mode &optional locked &rest bindings)
-  (declare (indent 2))
-  `(magit-setup-buffer-internal
-    ,mode ,locked
-    ,(cons 'list (mapcar (pcase-lambda (`(,var ,form))
-                           `(list ',var ,form))
-                         bindings))))
-
-(defun magit-setup-buffer-internal ( mode locked bindings
-                                     &optional buffer-or-name directory)
+(defmacro magit-setup-buffer (mode &optional locked &rest args)
+  "\n\n(fn MODE &optional LOCKED &key BUFFER DIRECTORY \
+INITIAL-SECTION SELECT-SECTION &rest BINDINGS)"
+  (declare (indent 2)
+           (debug (form [&optional locked]
+                        [&rest keywordp form]
+                        [&rest (symbolp form)])))
+  (let (kwargs)
+    (while (keywordp (car args))
+      (push (pop args) kwargs)
+      (push (pop args) kwargs))
+    `(magit-setup-buffer-internal
+      ,mode ,locked
+      ,(cons 'list (mapcar (pcase-lambda (`(,var ,form))
+                             `(list ',var ,form))
+                           args))
+      ,@(nreverse kwargs))))
+
+(cl-defun magit-setup-buffer-internal
+    ( mode locked bindings
+      &key buffer directory initial-section select-section)
   (let* ((value   (and locked
                        (with-temp-buffer
                          (pcase-dolist (`(,var ,val) bindings)
                            (set (make-local-variable var) val))
                          (let ((major-mode mode))
                            (magit-buffer-value)))))
-         (buffer  (if buffer-or-name
-                      (get-buffer-create buffer-or-name)
+         (buffer  (if buffer
+                      (get-buffer-create buffer)
                     (magit-get-mode-buffer mode value)))
          (section (and buffer (magit-current-section)))
          (created (not buffer)))
@@ -662,7 +680,9 @@ The buffer's major-mode should derive from `magit-section-mode'."
     (magit-display-buffer buffer)
     (with-current-buffer buffer
       (run-hooks 'magit-setup-buffer-hook)
-      (magit-refresh-buffer created)
+      (magit-refresh-buffer created
+                            :initial-section initial-section
+                            :select-section select-section)
       (when created
         (run-hooks 'magit-post-create-buffer-hook)))
     buffer))
@@ -689,8 +709,8 @@ and `magit-post-display-buffer-hook'."
   (let ((window (funcall (or display-function magit-display-buffer-function)
                          buffer)))
     (unless magit-display-buffer-noselect
-      (let* ((old-frame (selected-frame))
-             (new-frame (window-frame window)))
+      (let ((old-frame (selected-frame))
+            (new-frame (window-frame window)))
         (select-window window)
         (unless (eq old-frame new-frame)
           (select-frame-set-input-focus new-frame)))))
@@ -777,8 +797,7 @@ split is made vertically or horizontally is determined by
          ((with-current-buffer buffer
             (derived-mode-p 'magit-diff-mode 'magit-process-mode))
           '(magit--display-buffer-topleft))
-         (t
-          '(display-buffer-same-window)))))
+         ('(display-buffer-same-window)))))
 
 (defun magit--display-buffer-fullcolumn (buffer alist)
   (when-let ((window (or (display-buffer-reuse-window buffer alist)
@@ -809,8 +828,7 @@ the mode of the current buffer derives from `magit-log-mode' or
          ((with-current-buffer buffer
             (derived-mode-p 'magit-process-mode))
           nil)
-         (t
-          '(magit--display-buffer-fullcolumn)))))
+         ('(magit--display-buffer-fullcolumn)))))
 
 (defun magit-maybe-set-dedicated ()
   "Mark the selected window as dedicated if appropriate.
@@ -944,32 +962,33 @@ and another unlocked buffer already exists for that mode and
 repository, then the former buffer is instead deleted and the
 latter is displayed in its place."
   (interactive)
-  (if magit-buffer-locked-p
-      (if-let ((unlocked (magit-get-mode-buffer major-mode)))
-          (let ((locked (current-buffer)))
-            (switch-to-buffer unlocked nil t)
-            (kill-buffer locked))
-        (setq magit-buffer-locked-p nil)
-        (let ((name (funcall magit-generate-buffer-name-function major-mode))
-              (buffer (current-buffer))
-              (mode major-mode))
-          (rename-buffer (generate-new-buffer-name name))
-          (with-temp-buffer
-            (magit--maybe-uniquify-buffer-names buffer name mode))))
-    (if-let ((value (magit-buffer-value)))
-        (if-let ((locked (magit-get-mode-buffer major-mode value)))
-            (let ((unlocked (current-buffer)))
-              (switch-to-buffer locked nil t)
-              (kill-buffer unlocked))
-          (setq magit-buffer-locked-p t)
-          (let ((name (funcall magit-generate-buffer-name-function
-                               major-mode value))
-                (buffer (current-buffer))
-                (mode major-mode))
-            (rename-buffer (generate-new-buffer-name name))
-            (with-temp-buffer
-              (magit--maybe-uniquify-buffer-names buffer name mode))))
-      (user-error "Buffer has no value it could be locked to"))))
+  (cond-let
+    (magit-buffer-locked-p
+     (if-let ((unlocked (magit-get-mode-buffer major-mode)))
+         (let ((locked (current-buffer)))
+           (switch-to-buffer unlocked nil t)
+           (kill-buffer locked))
+       (setq magit-buffer-locked-p nil)
+       (let ((name (funcall magit-generate-buffer-name-function major-mode))
+             (buffer (current-buffer))
+             (mode major-mode))
+         (rename-buffer (generate-new-buffer-name name))
+         (with-temp-buffer
+           (magit--maybe-uniquify-buffer-names buffer name mode)))))
+    ([value (magit-buffer-value)]
+     (if-let ((locked (magit-get-mode-buffer major-mode value)))
+         (let ((unlocked (current-buffer)))
+           (switch-to-buffer locked nil t)
+           (kill-buffer unlocked))
+       (setq magit-buffer-locked-p t)
+       (let ((name (funcall magit-generate-buffer-name-function
+                            major-mode value))
+             (buffer (current-buffer))
+             (mode major-mode))
+         (rename-buffer (generate-new-buffer-name name))
+         (with-temp-buffer
+           (magit--maybe-uniquify-buffer-names buffer name mode)))))
+    ((user-error "Buffer has no value it could be locked to"))))
 
 ;;; Bury Buffer
 
@@ -1065,64 +1084,102 @@ Run hooks `magit-pre-refresh-hook' and `magit-post-refresh-hook'."
 
 (defvar-local magit--refresh-start-time nil)
 
-(defvar magit--initial-section-hook nil)
-
-(defun magit-refresh-buffer (&optional created)
-  "Refresh the current Magit buffer."
+(cl-defun magit-refresh-buffer ( &optional created
+                                 &key initial-section select-section)
+  "Refresh the current Magit buffer.
+The arguments are for internal use."
   (interactive)
-  (let ((magit--refreshing-buffer-p t)
-        (magit--refresh-start-time (current-time))
-        (magit--refresh-cache (or magit--refresh-cache (list (cons 0 0))))
-        (refresh (intern (format "%s-refresh-buffer"
-                                 (substring (symbol-name major-mode) 0 -5)))))
-    (when (functionp refresh)
+  (when-let ((refresh (magit--refresh-buffer-function)))
+    (let ((magit--refreshing-buffer-p t)
+          (magit--refresh-start-time (current-time))
+          (magit--refresh-cache (or magit--refresh-cache (list (cons 0 0))))
+          (action (if created "Creating" "Refreshing")))
       (when magit-refresh-verbose
-        (message "Refreshing buffer `%s'..." (buffer-name)))
-      (let* ((buffer (current-buffer))
-             (windows (mapcan
-                       (lambda (window)
-                         (with-selected-window window
-                           (with-current-buffer buffer
-                             (and-let* ((section (magit-section-at)))
-                               `(( ,window
-                                   ,section
-                                   ,@(magit-section-get-relative-position
-                                      section)))))))
-                       ;; If it qualifies, then the selected window
-                       ;; comes first, but we want to handle it last
-                       ;; so that its `magit-section-movement-hook'
-                       ;; run can override the effects of other runs.
-                       (or (nreverse (get-buffer-window-list buffer nil t))
-                           (list (selected-window))))))
+        (message "%s buffer `%s'..." action (buffer-name)))
+      (cond
+       (created
+        (funcall refresh)
+        (cond (initial-section (funcall initial-section))
+              (select-section (funcall select-section))))
+       (t
         (deactivate-mark)
         (setq magit-section-pre-command-section nil)
         (setq magit-section-highlight-overlays nil)
         (setq magit-section-selection-overlays nil)
         (setq magit-section-highlighted-sections nil)
-        (let ((inhibit-read-only t))
-          (erase-buffer)
-          (save-excursion
-            (funcall refresh)))
-        (pcase-dolist (`(,window . ,args) windows)
-          (if (eq buffer (window-buffer window))
-              (with-selected-window window
-                (apply #'magit-section-goto-successor args))
-            (with-current-buffer buffer
-              (let ((magit-section-movement-hook nil))
-                (apply #'magit-section-goto-successor args)))))
-        (when created
-          (run-hooks 'magit--initial-section-hook)
-          (setq-local magit--initial-section-hook nil))
-        (let ((magit-section-cache-visibility nil))
-          (magit-section-show magit-root-section))
-        (run-hooks 'magit-refresh-buffer-hook)
-        (magit-section-update-highlight)
-        (set-buffer-modified-p nil)
-        (push buffer magit-section--refreshed-buffers))
+        (setq magit-section-focused-sections nil)
+        (let ((positions (magit--refresh-buffer-get-positions)))
+          (funcall refresh)
+          (cond (select-section (funcall select-section))
+                ((magit--refresh-buffer-set-positions positions))))))
+      (let ((magit-section-cache-visibility nil))
+        (magit-section-show magit-root-section))
+      (run-hooks 'magit-refresh-buffer-hook)
+      (magit-section-update-highlight)
+      (set-buffer-modified-p nil)
+      (push (current-buffer) magit-section--refreshed-buffers)
       (when magit-refresh-verbose
-        (message "Refreshing buffer `%s'...done (%.3fs)" (buffer-name)
+        (message "%s buffer `%s'...done (%.3fs)" action (buffer-name)
                  (float-time (time-since magit--refresh-start-time)))))))
 
+(defun magit--refresh-buffer-function ()
+  (let ((fn (intern (format "%s-refresh-buffer"
+                            (substring (symbol-name major-mode) 0 -5)))))
+    (and (functionp fn)
+         (lambda ()
+           (let ((inhibit-read-only t))
+             (erase-buffer)
+             (save-excursion (funcall fn)))))))
+
+(defun magit--refresh-buffer-get-positions ()
+  (or (let ((buffer (current-buffer)))
+        (mapcan
+         (lambda (window)
+           (with-selected-window window
+             (with-current-buffer buffer
+               (and-let ((section (magit-section-at)))
+                 `((,window
+                    ,section
+                    ,@(magit-section-get-relative-position section)
+                    ,@(and-let ((ws (magit-section-at (window-start))))
+                        (list ws
+                              (car (magit-section-get-relative-position ws))
+                              (window-start)))))))))
+         ;; For hunks we run `magit-section-movement-hook' (once for
+         ;; each window displaying the buffer).  The selected window
+         ;; comes first in this list, but we want to process it last.
+         (nreverse (get-buffer-window-list buffer nil t))))
+      (and$ (magit-section-at)
+            `((nil ,$ ,@(magit-section-get-relative-position $))))))
+
+(defun magit--refresh-buffer-set-positions (positions)
+  (pcase-dolist
+      (`(,window ,section ,line ,char ,ws-section ,ws-line ,window-start)
+       positions)
+    (if window
+        (with-selected-window window
+          (magit-section-goto-successor section line char)
+          (cond-let
+            ((derived-mode-p 'magit-log-mode))
+            ((or (not window-start)
+                 (> window-start (point))))
+            ((magit-section-equal ws-section (magit-section-at window-start))
+             (set-window-start window window-start t))
+            ([pos (save-excursion
+                    (and (magit-section-goto-successor--same
+                          ws-section ws-line 0)
+                         (point)))]
+             (set-window-start window pos t))))
+      ;; We must make sure this does not call `set-window-start',
+      ;; which the HUNK METHOD does by calling `magit-section-goto'
+      ;; because that runs the `magit-section-goto-successor-hook'
+      ;; and thus `magit-hunk-set-window-start'.  The window does
+      ;; not display this buffer, so the window start would be set
+      ;; for the wrong buffer.  Originally reported in #4196 and
+      ;; fixed with 482c25a3204468a4f6c2fe12ff061666b61f5f4d.
+      (let ((magit-section-movement-hook nil))
+        (magit-section-goto-successor section line char)))))
+
 (defun magit-revert-buffer (_ignore-auto _noconfirm)
   "Wrapper around `magit-refresh-buffer' suitable as `revert-buffer-function'."
   (magit-refresh-buffer))
@@ -1188,8 +1245,8 @@ Note that refreshing a Magit buffer is done by re-creating its
 contents from scratch, which can be slow in large repositories.
 If you are not satisfied with Magit's performance, then you
 should obviously not add this function to that hook."
-  (when-let (((and (not magit--disable-save-buffers)
-                   (magit-inside-worktree-p t)))
+  (when-let ((_(not magit-inhibit-refresh))
+             (_(magit-inside-worktree-p t))
              (buf (ignore-errors (magit-get-mode-buffer 'magit-status-mode))))
     (cl-pushnew buf magit-after-save-refresh-buffers)
     (add-hook 'post-command-hook #'magit-after-save-refresh-buffers)))
@@ -1212,71 +1269,80 @@ if you so desire."
 
 (defvar-local magit-inhibit-refresh-save nil)
 
+(defvar magit-save-repository-buffers-predicate
+  (lambda (topdir)
+    (let ((remote (file-remote-p default-directory))
+          (topdirs nil)
+          ;; If the current file is modified and resides inside
+          ;; a repository, and a let-binding is in effect, which
+          ;; places us in another repository, then this binding
+          ;; is needed to prevent that file from being saved.
+          (default-directory default-directory))
+      (and buffer-file-name
+           (setq default-directory (file-name-directory buffer-file-name))
+           ;; Check whether the repository still exists.
+           (file-exists-p default-directory)
+           ;; Check whether refreshing is disabled.
+           (not magit-inhibit-refresh-save)
+           ;; Check whether the visited file is either on the
+           ;; same remote as the repository, or both are on
+           ;; the local system.
+           (equal (file-remote-p buffer-file-name) remote)
+           ;; Delayed checks that are more expensive for remote
+           ;; repositories, due to the required network access.
+           ;;
+           ;; Check whether the file is inside the repository.
+           (equal (or (cdr (assoc default-directory topdirs))
+                      (let ((top (magit-rev-parse-safe "--show-toplevel")))
+                        (push (cons default-directory top) topdirs)
+                        top))
+                  topdir)
+           ;; Check whether the file is actually writable.
+           (file-writable-p buffer-file-name))))
+  "Predicate for `magit-save-repository-buffers'.
+
+This function is called for each buffer that might need saving with
+one argument, the working tree of the respective repository.  If it
+returns non-nil, the current buffer is saved.")
+
 (defun magit-save-repository-buffers (&optional arg)
   "Save file-visiting buffers belonging to the current repository.
 After any buffer where `buffer-save-without-query' is non-nil
 is saved without asking, the user is asked about each modified
-buffer which visits a file in the current repository.  Optional
+buffer, which visits a file in the current repository.  Optional
 argument (the prefix) non-nil means save all with no questions."
   (interactive "P")
   (when-let ((topdir (magit-rev-parse-safe "--show-toplevel")))
-    (let ((remote (file-remote-p default-directory))
-          (save-some-buffers-action-alist
-           `((?Y (##with-current-buffer %
-                   (setq buffer-save-without-query t)
-                   (save-buffer))
+    (let ((save-some-buffers-action-alist
+           `((?Y ,(##with-current-buffer %
+                    (setq buffer-save-without-query t)
+                    (save-buffer))
                  "to save the current buffer and remember choice")
-             (?N (##with-current-buffer %
-                   (setq magit-inhibit-refresh-save t))
+             (?N ,(##with-current-buffer %
+                    (setq magit-inhibit-refresh-save t))
                  "to skip the current buffer and remember choice")
              ,@save-some-buffers-action-alist))
-          (topdirs nil)
-          (unwiped nil)
-          (magit--wip-inhibit-autosave t))
+          ;; Create a single wip commit for all saved files, for
+          ;; which `magit-wip-after-save-local-mode' is enabled.
+          (magit--wip-inhibit-autosave t)
+          (saved nil))
       (unwind-protect
           (save-some-buffers
            arg
            (lambda ()
-             ;; If the current file is modified and resides inside
-             ;; a repository, and a let-binding is in effect, which
-             ;; places us in another repository, then this binding
-             ;; is needed to prevent that file from being saved.
-             (and-let* ((default-directory
-                         (and buffer-file-name
-                              (file-name-directory buffer-file-name))))
-               (and
-                ;; Check whether the repository still exists.
-                (file-exists-p default-directory)
-                ;; Check whether refreshing is disabled.
-                (not magit-inhibit-refresh-save)
-                ;; Check whether the visited file is either on the
-                ;; same remote as the repository, or both are on
-                ;; the local system.
-                (equal (file-remote-p buffer-file-name) remote)
-                ;; Delayed checks that are more expensive for remote
-                ;; repositories, due to the required network access.
-                ;;
-                ;; Check whether the file is inside the repository.
-                (equal (or (cdr (assoc default-directory topdirs))
-                           (let ((top (magit-rev-parse-safe "--show-toplevel")))
-                             (push (cons default-directory top) topdirs)
-                             top))
-                       topdir)
-                ;; Check whether the file is actually writable.
-                (file-writable-p buffer-file-name)
-                (prog1 t
-                  ;; Schedule for wip commit, if appropriate.
-                  (when magit-wip-after-save-local-mode
-                    (push (expand-file-name buffer-file-name) unwiped)))))))
-        (when unwiped
+             (and (funcall magit-save-repository-buffers-predicate topdir)
+                  (prog1 t
+                    (when magit-wip-after-save-local-mode
+                      (push (expand-file-name buffer-file-name) saved))))))
+        (when saved
           (let ((default-directory topdir))
             (magit-wip-commit-worktree
              (magit-wip-get-ref)
-             unwiped
-             (if (cdr unwiped)
-                 (format "autosave %s files after save" (length unwiped))
+             saved
+             (if (cdr saved)
+                 (format "autosave %s files after save" (length saved))
                (format "autosave %s after save"
-                       (file-relative-name (car unwiped)))))))))))
+                       (file-relative-name (car saved)))))))))))
 
 ;;; Restore Window Configuration
 
@@ -1290,12 +1356,12 @@ argument (the prefix) non-nil means save all with no questions."
 
 Later, when the buffer is buried, it may be restored by
 `magit-restore-window-configuration'."
-  (if magit-inhibit-save-previous-winconf
-      (when (eq magit-inhibit-save-previous-winconf 'unset)
-        (setq magit-previous-window-configuration nil))
-    (unless (get-buffer-window (current-buffer) (selected-frame))
-      (setq magit-previous-window-configuration
-            (current-window-configuration)))))
+  (cond (magit-inhibit-save-previous-winconf
+         (when (eq magit-inhibit-save-previous-winconf 'unset)
+           (setq magit-previous-window-configuration nil)))
+        ((not (get-buffer-window (current-buffer) (selected-frame)))
+         (setq magit-previous-window-configuration
+               (current-window-configuration)))))
 
 (defun magit-restore-window-configuration (&optional kill-buffer)
   "Bury or kill the current buffer and restore previous window configuration."
@@ -1417,9 +1483,9 @@ Return a (KEY . VALUE) cons cell.
 The KEY is matched using `equal'.
 
 Unless specified, REPOSITORY is the current buffer's repository."
-  (and-let* ((cache (assoc (or repository
-                               (magit-repository-local-repository))
-                           magit-repository-local-cache)))
+  (and-let ((cache (assoc (or repository
+                              (magit-repository-local-repository))
+                          magit-repository-local-cache)))
     (assoc key (cdr cache))))
 
 (defun magit-repository-local-get (key &optional default repository)
@@ -1440,13 +1506,13 @@ Unless specified, REPOSITORY is the current buffer's repository."
 Unless specified, REPOSITORY is the current buffer's repository.
 If REPOSITORY is `all', then delete the value for KEY for all
 repositories."
-  (if (eq repository 'all)
-      (dolist (cache magit-repository-local-cache)
-        (setf cache (compat-call assoc-delete-all key cache)))
-    (when-let ((cache (assoc (or repository
-                                 (magit-repository-local-repository))
-                             magit-repository-local-cache)))
-      (setf cache (compat-call assoc-delete-all key cache)))))
+  (cond-let
+    ((eq repository 'all)
+     (dolist (cache magit-repository-local-cache)
+       (setf cache (compat-call assoc-delete-all key cache))))
+    ([cache (assoc (or repository (magit-repository-local-repository))
+                   magit-repository-local-cache)]
+     (setf cache (compat-call assoc-delete-all key cache)))))
 
 (defmacro magit--with-repository-local-cache (key &rest body)
   (declare (indent 1) (debug (form body)))
@@ -1530,7 +1596,7 @@ The additional output can be found in the *Messages* buffer."
 The returned value has the form (BEGINNING-LINE END-LINE).  If
 the region end at the beginning of a line, do not include that
 line.  Avoid including the line after the end of the file."
-  (and (or magit-buffer-file-name buffer-file-name)
+  (and (magit-buffer-file-name)
        (region-active-p)
        (not (= (region-beginning) (region-end) (1+ (buffer-size))))
        (let ((beg (region-beginning))
@@ -1543,4 +1609,15 @@ line.  Avoid including the line after the end of the file."
 
 ;;; _
 (provide 'magit-mode)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-mode.el ends here
diff --git a/elpa/magit-20250519.1537/magit-notes.el b/elpa/magit-20251103.1130/magit-notes.el
similarity index 86%
rename from elpa/magit-20250519.1537/magit-notes.el
rename to elpa/magit-20251103.1130/magit-notes.el
index 0b262158..d43be85f 100644
--- a/elpa/magit-20250519.1537/magit-notes.el
+++ b/elpa/magit-20251103.1130/magit-notes.el
@@ -163,14 +163,14 @@ Also see `magit-notes-merge'."
 
 ;;; Readers
 
-(defun magit-notes-read-ref (prompt _initial-input history)
-  (and-let* ((ref (magit-completing-read
-                   prompt (magit-list-notes-refnames) nil nil
-                   (and-let* ((def (magit-get "core.notesRef")))
-                     (if (string-prefix-p "refs/notes/" def)
-                         (substring def 11)
-                       def))
-                   history)))
+(defun magit-notes-read-ref (prompt &optional _initial-input history)
+  (and-let ((ref (magit-completing-read
+                  prompt (magit-list-notes-refnames) nil t
+                  (and-let ((def (magit-get "core.notesRef")))
+                    (if (string-prefix-p "refs/notes/" def)
+                        (substring def 11)
+                      def))
+                  history)))
     (if (string-prefix-p "refs/" ref)
         ref
       (concat "refs/notes/" ref))))
@@ -192,10 +192,21 @@ Also see `magit-notes-merge'."
 
 (defun magit-notes-read-args (prompt)
   (list (magit-read-branch-or-commit prompt (magit-stash-at-point))
-        (and-let* ((str (seq-find (##string-match "^--ref=\\(.+\\)" %)
-                                  (transient-args 'magit-notes))))
-          (match-string 1 str))))
+        (and-let ((str (seq-find (##string-match "^--ref=\\(.+\\)" %)
+                                 (transient-args 'magit-notes))))
+          (match-str 1 str))))
 
 ;;; _
 (provide 'magit-notes)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-notes.el ends here
diff --git a/elpa/magit-20250519.1537/magit-patch.el b/elpa/magit-20251103.1130/magit-patch.el
similarity index 93%
rename from elpa/magit-20250519.1537/magit-patch.el
rename to elpa/magit-20251103.1130/magit-patch.el
index 88641d51..0d903635 100644
--- a/elpa/magit-20250519.1537/magit-patch.el
+++ b/elpa/magit-20251103.1130/magit-patch.el
@@ -28,6 +28,8 @@
 
 (require 'magit)
 
+(declare-function message-goto-body "message" (&optional interactive))
+
 ;;; Options
 
 (defcustom magit-patch-save-arguments '(exclude "--stat")
@@ -116,8 +118,8 @@ which creates patches for all commits that are reachable from
       (save-match-data
         (find-file
          (expand-file-name
-          (concat (and-let* ((v (transient-arg-value "--reroll-count=" args)))
-                    (format "v%s-" v))
+          (concat (and$ (transient-arg-value "--reroll-count=" args)
+                        (format "v%s-" $))
                   "0000-cover-letter.patch")
           (let ((topdir (magit-toplevel)))
             (if-let ((dir (transient-arg-value "--output-directory=" args)))
@@ -150,9 +152,8 @@ which creates patches for all commits that are reachable from
   :reader #'magit-format-patch-select-base)
 
 (defun magit-format-patch-select-base (prompt initial-input history)
-  (or (magit-completing-read prompt (cons "auto" (magit-list-refnames))
-                             nil nil initial-input history "auto")
-      (user-error "Nothing selected")))
+  (magit-completing-read prompt (cons "auto" (magit-list-refnames))
+                         nil 'any initial-input history "auto"))
 
 (transient-define-argument magit-format-patch:--reroll-count ()
   :description "Reroll count"
@@ -251,8 +252,8 @@ which creates patches for all commits that are reachable from
      (list (expand-file-name
             (read-file-name "Apply patch: "
                             default-directory nil nil
-                            (and-let* ((file (magit-file-at-point)))
-                              (file-relative-name file))))
+                            (and$ (magit-file-at-point)
+                                  (file-relative-name $))))
            (transient-args 'magit-patch-apply))))
   (if (not file)
       (transient-setup 'magit-patch-apply)
@@ -315,6 +316,7 @@ is asked to pull.  START has to be reachable from that commit."
    (list (magit-get "remote" (magit-read-remote "Remote") "url")
          (magit-read-branch-or-commit "Start" (magit-get-upstream-branch))
          (magit-read-branch-or-commit "End")))
+  (require 'message)
   (let ((dir default-directory))
     ;; mu4e changes default-directory
     (compose-mail)
@@ -325,4 +327,15 @@ is asked to pull.  START has to be reachable from that commit."
 
 ;;; _
 (provide 'magit-patch)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-patch.el ends here
diff --git a/elpa/magit-20250519.1537/magit-pkg.el b/elpa/magit-20251103.1130/magit-pkg.el
similarity index 59%
rename from elpa/magit-20250519.1537/magit-pkg.el
rename to elpa/magit-20251103.1130/magit-pkg.el
index 3a09fdd3..4799f659 100644
--- a/elpa/magit-20250519.1537/magit-pkg.el
+++ b/elpa/magit-20251103.1130/magit-pkg.el
@@ -1,16 +1,17 @@
 ;; -*- no-byte-compile: t; lexical-binding: nil -*-
-(define-package "magit" "20250519.1537"
+(define-package "magit" "20251103.1130"
   "A Git porcelain inside Emacs."
-  '((emacs         "27.1")
-    (compat        "30.1.0.0")
-    (llama         "0.6.2")
-    (magit-section "4.3.5")
+  '((emacs         "28.1")
+    (compat        "30.1")
+    (cond-let      "0.1")
+    (llama         "1.0")
+    (magit-section "4.4")
     (seq           "2.24")
-    (transient     "0.8.8")
-    (with-editor   "3.4.3"))
+    (transient     "0.10")
+    (with-editor   "3.4"))
   :url "https://github.com/magit/magit"
-  :commit "9b81df36b4eb6d2443632cb44c67acd8ea1f366f"
-  :revdesc "9b81df36b4eb"
+  :commit "84c5c8c8c6108f6a5dbae1f145518cbaa9ca7480"
+  :revdesc "84c5c8c8c610"
   :keywords '("git" "tools" "vc")
   :authors '(("Marius Vollmer" . "marius.vollmer@gmail.com")
              ("Jonas Bernoulli" . "emacs.magit@jonas.bernoulli.dev"))
diff --git a/elpa/magit-20250519.1537/magit-process.el b/elpa/magit-20251103.1130/magit-process.el
similarity index 91%
rename from elpa/magit-20250519.1537/magit-process.el
rename to elpa/magit-20251103.1130/magit-process.el
index 2a4083ed..7d4cc829 100644
--- a/elpa/magit-20250519.1537/magit-process.el
+++ b/elpa/magit-20251103.1130/magit-process.el
@@ -249,11 +249,36 @@ implement such functions."
   :type 'boolean)
 
 (defcustom magit-process-display-mode-line-error t
-  "Whether Magit should retain and highlight process errors in the mode line."
+  "Whether Magit should retain and highlight process errors in the mode line.
+
+See `magit-show-process-buffer-hint' for another way to display the
+complete output on demand."
   :package-version '(magit . "2.12.0")
   :group 'magit-process
   :type 'boolean)
 
+(defcustom magit-show-process-buffer-hint t
+  "Whether to append hint about process buffer to Git error messages.
+
+When Magit runs Git for side-effects, the output is always logged to
+a per-repository process buffer.  If Git exits with a non-zero status,
+then a single line of its error output is shown in the repositories
+status buffer and in the echo area.
+
+When a user want to learn more about the error, they can switch to that
+process buffer, to see the complete output, but initially users are not
+aware of this, so Magit appends a usage hint to the error message in
+both of these places.
+
+Once you are aware of this, you probably won't need the reminder and can
+set this option to nil.
+
+See `magit-process-display-mode-line-error' for another way to display
+the complete output on demand."
+  :package-version '(magit . "4.3.7")
+  :group 'magit-process
+  :type 'boolean)
+
 (defcustom magit-process-apply-ansi-colors nil
   "Whether and when to apply color escapes in the process buffer.
 
@@ -439,7 +464,7 @@ After Git returns, the current buffer (if it is a Magit buffer)
 as well as the current repository's status buffer are refreshed.
 
 Process output goes into a new section in the buffer returned by
-`magit-process-buffer'."
+`magit-process-buffer'.  Return the exit code."
   (let ((magit--refresh-cache (list (cons 0 0))))
     (prog1 (magit-call-git args)
       (when (member (car args) '("init" "clone"))
@@ -458,7 +483,7 @@ The arguments ARGS specify arguments to Git, they are flattened
 before use.
 
 Process output goes into a new section in the buffer returned by
-`magit-process-buffer'."
+`magit-process-buffer'.  Return the exit code."
   (run-hooks 'magit-pre-call-git-hook)
   (let ((default-process-coding-system (magit--process-coding-system)))
     (apply #'magit-call-process
@@ -468,7 +493,7 @@ Process output goes into a new section in the buffer returned by
 (defun magit-call-process (program &rest args)
   "Call PROGRAM synchronously in a separate process.
 Process output goes into a new section in the buffer returned by
-`magit-process-buffer'."
+`magit-process-buffer'.  Return the exit code."
   (pcase-let ((`(,process-buf . ,section)
                (magit-process-setup program args)))
     (magit-process-finish
@@ -489,8 +514,9 @@ ensure unix eol conversion."
 
 (defun magit-process-file (process &optional infile buffer display &rest args)
   "Process files synchronously in a separate process.
-Similar to `process-file' but temporarily enable Cygwin's
-\"noglob\" option during the call and ensure unix eol conversion."
+Return the exit code.  Similar to `process-file' but temporarily
+enable Cygwin's \"noglob\" option during the call and ensure unix
+eol conversion."
   (when magit-process-record-invocations
     (let ((messages-buffer-name magit-process-record-buffer-name)
           (inhibit-message t))
@@ -527,7 +553,7 @@ ARGS is flattened and then used as arguments to Git.
 
 The current buffer's content is used as the process's standard
 input.  The buffer is assumed to be temporary and thus OK to
-modify.
+modify.  Return the exit code.
 
 Function `magit-git-executable' specifies the Git executable and
 option `magit-git-global-arguments' specifies constant arguments.
@@ -758,7 +784,8 @@ Magit status buffer."
                                                       default-directory))))
                        (concat (file-relative-name pwd default-directory) " "))
                   (magit-process--format-arguments program args))))
-        (magit-insert-heading (if face (propertize cmd 'face face) cmd)))
+        (magit-insert-heading
+          (if face (magit--propertize-face cmd face) cmd)))
       (when errlog
         (if (bufferp errlog)
             (insert (with-current-buffer errlog
@@ -784,8 +811,7 @@ Magit status buffer."
    ((and args (equal program shell-file-name))
     (propertize (cadr args)
                 'font-lock-face 'magit-section-heading))
-   (t
-    (concat (propertize (file-name-nondirectory program)
+   ((concat (propertize (file-name-nondirectory program)
                         'font-lock-face 'magit-section-heading)
             " "
             (propertize (mapconcat #'shell-quote-argument args " ")
@@ -806,8 +832,7 @@ Magit status buffer."
                  (delete-region (oref section start)
                                 (1+ (oref section end)))
                  (cl-decf count))
-                (t
-                 (push section head))))
+                ((push section head))))
         (pop tail))
       (oset magit-root-section children
             (nconc (reverse head) tail)))))
@@ -835,7 +860,7 @@ Magit status buffer."
   (when (memq (process-status process) '(exit signal))
     (magit-process-sentinel process event)
     (when-let* ((process-buf (process-buffer process))
-                ((buffer-live-p process-buf))
+                (_(buffer-live-p process-buf))
                 (status-buf (with-current-buffer process-buf
                               (magit-get-mode-buffer 'magit-status-mode))))
       (with-current-buffer status-buf
@@ -921,8 +946,8 @@ PARENT is used as the parent of the returned keymap."
                  (y-or-n-p-map
                   (magit-process-make-keymap process y-or-n-p-map)))
              (yes-or-no-p (substring string 0 beg))))
-         (concat (downcase (match-string 1 string)) "\n")
-       (concat (downcase (match-string 2 string)) "\n")))))
+         (concat (downcase (match-str 1 string)) "\n")
+       (concat (downcase (match-str 2 string)) "\n")))))
 
 (defun magit-process-password-auth-source (key)
   "Use `auth-source-search' to get a password.
@@ -964,8 +989,8 @@ be translated on the fly by doing this once
   (require 'auth-source)
   (and (fboundp 'auth-source-search)
        (string-match "\\`\\(.+\\)@\\([^@]+\\)\\'" key)
-       (let* ((user (match-string 1 key))
-              (host (match-string 2 key))
+       (let* ((user (match-str 1 key))
+              (host (match-str 2 key))
               (secret
                (plist-get
                 (car (or (auth-source-search :max 1 :host host :user user)
@@ -1000,9 +1025,9 @@ from the user."
                       magit-process-password-prompt-regexps string)))
     (process-send-string
      process
-     (concat (or (and-let* ((key (match-string 99 string)))
-                   (run-hook-with-args-until-success
-                    'magit-process-find-password-functions key))
+     (concat (or (and$ (match-str 99 string)
+                       (run-hook-with-args-until-success
+                        'magit-process-find-password-functions $))
                  (let ((read-passwd-map
                         (magit-process-make-keymap process read-passwd-map)))
                    (read-passwd prompt)))
@@ -1022,7 +1047,7 @@ from the user."
   "Match STRING against PROMPTS and set match data.
 Return the matched string, appending \": \" if needed."
   (when (seq-some (##string-match % string) prompts)
-    (let ((prompt (match-string 0 string)))
+    (let ((prompt (match-str 0 string)))
       (cond ((string-suffix-p ": " prompt) prompt)
             ((string-suffix-p ":"  prompt) (concat prompt " "))
             (t                             (concat prompt ": "))))))
@@ -1173,21 +1198,17 @@ If STR is supplied, it replaces the `mode-line-process' text."
 
 (defun magit-process-error-summary (process-buf section)
   "A one-line error summary from the given SECTION."
-  (or (and (buffer-live-p process-buf)
-           (with-current-buffer process-buf
-             (and (oref section content)
-                  (save-excursion
-                    (goto-char (oref section end))
-                    (run-hook-wrapped
-                     'magit-process-error-message-regexps
-                     (lambda (re)
-                       (save-excursion
-                         (and (re-search-backward
-                               re (oref section start) t)
-                              (or (match-string-no-properties 1)
-                                  (and (not magit-process-raise-error)
-                                       'suppressed))))))))))
-      "Git failed"))
+  (and (buffer-live-p process-buf)
+       (with-current-buffer process-buf
+         (and (oref section content)
+              (save-excursion
+                (goto-char (oref section end))
+                (run-hook-wrapped
+                 'magit-process-error-message-regexps
+                 (lambda (re)
+                   (save-excursion
+                     (and (re-search-backward re (oref section start) t)
+                          (match-str 1))))))))))
 
 (defun magit-process-error-tooltip (process-buf section)
   "Returns the text from SECTION of the PROCESS-BUF buffer.
@@ -1216,11 +1237,10 @@ Limited by `magit-process-error-tooltip-max-lines'."
 
 (defvar-local magit-this-error nil)
 
-(defun magit-process-finish (arg &optional process-buf command-buf
+(defun magit-process-finish (arg &optional process-buf _command-buf
                                  default-dir section)
   (unless (integerp arg)
     (setq process-buf (process-buffer arg))
-    (setq command-buf (process-get arg 'command-buf))
     (setq default-dir (process-get arg 'default-dir))
     (setq section     (process-get arg 'section))
     (setq arg         (process-exit-status arg)))
@@ -1230,35 +1250,28 @@ Limited by `magit-process-error-tooltip-max-lines'."
     (with-current-buffer process-buf
       (magit-process-finish-section section arg)))
   (if (= arg 0)
-      ;; Unset the `mode-line-process' value upon success.
       (magit-process-unset-mode-line default-dir)
-    ;; Otherwise process the error.
     (let ((msg (magit-process-error-summary process-buf section)))
-      ;; Change `mode-line-process' to an error face upon failure.
       (if magit-process-display-mode-line-error
           (magit-process-set-mode-line-error-status
-           (or (magit-process-error-tooltip process-buf section)
-               msg))
+           (or (magit-process-error-tooltip process-buf section) msg))
         (magit-process-unset-mode-line default-dir))
-      ;; Either signal the error, or else display the error summary in
-      ;; the status buffer and with a message in the echo area.
-      (cond
-       (magit-process-raise-error
-        (signal 'magit-git-error (list (format "%s (in %s)" msg default-dir))))
-       ((not (eq msg 'suppressed))
-        (when (buffer-live-p process-buf)
-          (with-current-buffer process-buf
-            (when-let ((status-buf (magit-get-mode-buffer 'magit-status-mode)))
-              (with-current-buffer status-buf
-                (setq magit-this-error msg)))))
-        (message "%s ... [%s buffer %s for details]" msg
-                 (if-let ((key (and (buffer-live-p command-buf)
-                                    (with-current-buffer command-buf
-                                      (car (where-is-internal
-                                            'magit-process-buffer))))))
-                     (format "Hit %s to see" (key-description key))
-                   "See")
-                 (buffer-name process-buf))))))
+      (when (buffer-live-p process-buf)
+        (with-current-buffer process-buf
+          (when-let ((status-buf (magit-get-mode-buffer 'magit-status-mode)))
+            (with-current-buffer status-buf
+              (setq magit-this-error msg)))))
+      (let ((usage
+             (and magit-show-process-buffer-hint
+                  (if-let ((keys (where-is-internal 'magit-process-buffer)))
+                      (format "Type %s to see %S for details"
+                              (key-description (car keys)) process-buf)
+                    (format "See %S for details" process-buf)))))
+        (if magit-process-raise-error
+            (signal 'magit-git-error
+                    (list msg (or usage (list 'in default-dir))))
+          (message "Git error: %s"
+                   (concat msg (and usage (format " [%s]" usage))))))))
   arg)
 
 (defun magit-process-finish-section (section exit-code)
@@ -1278,16 +1291,16 @@ Limited by `magit-process-error-tooltip-max-lines'."
     (when (eq magit-process-apply-ansi-colors t)
       (ansi-color-apply-on-region (oref section content)
                                   (oref section end)))
-    (if (= (oref section end)
-           (+ (line-end-position) 2))
-        (save-excursion
-          (goto-char (1+ (line-end-position)))
-          (delete-char -1)
-          (oset section content nil))
-      (when (and (= exit-code 0)
-                 (not (seq-some (##eq (window-buffer %) buffer)
-                                (window-list))))
-        (magit-section-hide section)))))
+    (cond ((= (oref section end)
+              (+ (line-end-position) 2))
+           (save-excursion
+             (goto-char (1+ (line-end-position)))
+             (delete-char -1)
+             (oset section content nil)))
+          ((and (= exit-code 0)
+                (not (seq-some (##eq (window-buffer %) buffer)
+                               (window-list))))
+           (magit-section-hide section)))))
 
 (defun magit-process-display-buffer (process)
   (when (process-live-p process)
@@ -1300,20 +1313,20 @@ Limited by `magit-process-error-tooltip-max-lines'."
             ((> magit-process-popup-time 0)
              (run-with-timer magit-process-popup-time nil
                              (lambda (p)
-                               (when (eq (process-status p) 'run)
-                                 (let ((buf (process-buffer p)))
-                                   (when (buffer-live-p buf)
-                                     (if (minibufferp)
-                                         (switch-to-buffer-other-window buf)
-                                       (pop-to-buffer buf))))))
+                               (when-let* ((_(eq (process-status p) 'run))
+                                           (buf (process-buffer p))
+                                           (_(buffer-live-p buf)))
+                                 (if (minibufferp)
+                                     (switch-to-buffer-other-window buf)
+                                   (pop-to-buffer buf))))
                              process))))))
 
 (defun magit--log-action (summary line list)
   (let (heading lines)
-    (if (cdr list)
-        (progn (setq heading (funcall summary list))
-               (setq lines (mapcar line list)))
-      (setq heading (funcall line (car list))))
+    (cond ((cdr list)
+           (setq lines (mapcar line list))
+           (setq heading (funcall summary list)))
+          ((setq heading (funcall line (car list)))))
     (with-current-buffer (magit-process-buffer t)
       (goto-char (1- (point-max)))
       (let ((inhibit-read-only t))
@@ -1330,4 +1343,15 @@ Limited by `magit-process-error-tooltip-max-lines'."
 
 ;;; _
 (provide 'magit-process)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-process.el ends here
diff --git a/elpa/magit-20250519.1537/magit-pull.el b/elpa/magit-20251103.1130/magit-pull.el
similarity index 89%
rename from elpa/magit-20250519.1537/magit-pull.el
rename to elpa/magit-20251103.1130/magit-pull.el
index 7116c29d..17401cd7 100644
--- a/elpa/magit-20250519.1537/magit-pull.el
+++ b/elpa/magit-20251103.1130/magit-pull.el
@@ -99,14 +99,12 @@ push-remote."
          (target (magit-get-push-branch branch t))
          (remote (magit-get-push-remote branch))
          (v (magit--push-remote-variable branch t)))
-    (cond
-     (target)
-     ((member remote (magit-list-remotes))
-      (format "%s, replacing non-existent" v))
-     (remote
-      (format "%s, replacing invalid" v))
-     (t
-      (format "%s, setting that" v)))))
+    (cond (target)
+          ((member remote (magit-list-remotes))
+           (format "%s, replacing non-existent" v))
+          (remote
+           (format "%s, replacing invalid" v))
+          ((format "%s, setting that" v)))))
 
 ;;;###autoload (autoload 'magit-pull-from-upstream "magit-pull" nil t)
 (transient-define-suffix magit-pull-from-upstream (args)
@@ -134,7 +132,7 @@ the upstream."
     (magit-run-git-with-editor "pull" args remote merge)))
 
 (defun magit-pull--upstream-description ()
-  (and-let* ((branch (magit-get-current-branch)))
+  (and-let ((branch (magit-get-current-branch)))
     (or (magit-get-upstream-branch branch)
         (let ((remote (magit-get "branch" branch "remote"))
               (merge  (magit-get "branch" branch "merge"))
@@ -148,8 +146,7 @@ the upstream."
             (concat u ", replacing non-existent"))
            ((or remote merge)
             (concat u ", replacing invalid"))
-           (t
-            (concat u ", setting that")))))))
+           ((concat u ", setting that")))))))
 
 ;;;###autoload
 (defun magit-pull-branch (source args)
@@ -163,4 +160,15 @@ the upstream."
 
 ;;; _
 (provide 'magit-pull)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-pull.el ends here
diff --git a/elpa/magit-20250519.1537/magit-push.el b/elpa/magit-20251103.1130/magit-push.el
similarity index 92%
rename from elpa/magit-20250519.1537/magit-push.el
rename to elpa/magit-20251103.1130/magit-push.el
index 1b8acb42..3c8c806a 100644
--- a/elpa/magit-20250519.1537/magit-push.el
+++ b/elpa/magit-20251103.1130/magit-push.el
@@ -107,8 +107,7 @@ argument the push-remote can be changed before pushed to it."
                                       'magit-branch-remote)))
      (remote
       (format "%s, replacing invalid" v))
-     (t
-      (format "%s, setting that" v)))))
+     ((format "%s, setting that" v)))))
 
 ;;;###autoload (autoload 'magit-push-current-to-upstream "magit-push" nil t)
 (transient-define-suffix magit-push-current-to-upstream (args)
@@ -134,7 +133,7 @@ the upstream."
                                  :test #'equal))
              (upstream (magit-completing-read
                         (format "Set upstream of %s and push there" branch)
-                        branches nil nil nil 'magit-revision-history
+                        branches nil 'any nil 'magit-revision-history
                         (or (car (member (magit-remote-branch-at-point) branches))
                             (car (member "origin/master" branches)))))
              (upstream* (or (magit-get-tracked upstream)
@@ -155,7 +154,7 @@ the upstream."
     (magit-run-git-async "push" "-v" args remote (concat branch ":" merge))))
 
 (defun magit-push--upstream-description ()
-  (and-let* ((branch (magit-get-current-branch)))
+  (and-let ((branch (magit-get-current-branch)))
     (or (magit-get-upstream-branch branch)
         (let ((remote (magit-get "branch" branch "remote"))
               (merge  (magit-get "branch" branch "merge"))
@@ -171,8 +170,7 @@ the upstream."
                     (magit--propertize-face merge 'magit-branch-remote)))
            ((or remote merge)
             (concat u ", creating it and replacing invalid"))
-           (t
-            (concat u ", creating it")))))))
+           ((concat u ", creating it")))))))
 
 ;;;###autoload
 (defun magit-push-current (target args)
@@ -194,10 +192,10 @@ Both the source and the target are read in the minibuffer."
      (list source
            (magit-read-remote-branch
             (format "Push %s to" source) nil
-            (if (magit-local-branch-p source)
-                (or (magit-get-push-branch source)
-                    (magit-get-upstream-branch source))
-              (and (magit-rev-ancestor-p source "HEAD")
+            (cond ((magit-local-branch-p source)
+                   (or (magit-get-push-branch source)
+                       (magit-get-upstream-branch source)))
+                  ((magit-rev-ancestor-p source "HEAD")
                    (or (magit-get-push-branch)
                        (magit-get-upstream-branch))))
             source 'confirm)
@@ -218,7 +216,7 @@ is used."
          (magit-completing-read-multiple
           "Push refspec,s: "
           (cons "HEAD" (magit-list-local-branch-names))
-          nil nil nil 'magit-push-refspecs-history)
+          nil 'any nil 'magit-push-refspecs-history)
          (magit-push-arguments)))
   (run-hooks 'magit-credential-hook)
   (magit-run-git-async "push" "-v" args remote refspecs))
@@ -258,7 +256,7 @@ branch as default."
 (defun magit-push-notes-ref (ref remote &optional args)
   "Push a notes ref to another repository."
   (interactive
-   (let ((note (magit-notes-read-ref "Push notes" nil nil)))
+   (let ((note (magit-notes-read-ref "Push notes")))
      (list note
            (magit-read-remote (format "Push %s to remote" note) nil t)
            (magit-push-arguments))))
@@ -302,12 +300,12 @@ what this command will do.  To add it use something like:
                      ;; Note: Avoid `magit-get-remote' because it
                      ;; filters out the local repo case (".").
                      (magit-get "branch" branch "remote")
-                     (let ((remotes (magit-list-remotes)))
-                       (cond
-                        ((and (magit-git-version>= "2.27")
-                              (length= remotes 1))
-                         (car remotes))
-                        ((member "origin" remotes) "origin"))))))
+                       (cond-let
+                         [[remotes (magit-list-remotes)]]
+                         ((and (magit-git-version>= "2.27")
+                               (length= remotes 1))
+                          (car remotes))
+                         ((car (member "origin" remotes)))))))
     (if (null remote)
         "nothing (no remote)"
       (let ((refspec (magit-get "remote" remote "push")))
@@ -370,4 +368,15 @@ You can add this command as a suffix using something like:
 
 ;;; _
 (provide 'magit-push)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-push.el ends here
diff --git a/elpa/magit-20250519.1537/magit-reflog.el b/elpa/magit-20251103.1130/magit-reflog.el
similarity index 92%
rename from elpa/magit-20250519.1537/magit-reflog.el
rename to elpa/magit-20251103.1130/magit-reflog.el
index 7ffce3e0..4399ea21 100644
--- a/elpa/magit-20250519.1537/magit-reflog.el
+++ b/elpa/magit-20251103.1130/magit-reflog.el
@@ -189,9 +189,9 @@ Type \\[magit-reset] to reset `HEAD' to the commit at point.
 
 (defun magit-reflog-format-subject (subject)
   (let* ((match (string-match magit-reflog-subject-re subject))
-         (command (and match (match-string 1 subject)))
-         (option  (and match (match-string 2 subject)))
-         (type    (and match (match-string 3 subject)))
+         (command (and match (match-str 1 subject)))
+         (option  (and match (match-str 2 subject)))
+         (type    (and match (match-str 3 subject)))
          (label (if (string= command "commit")
                     (or type command)
                   command))
@@ -205,4 +205,15 @@ Type \\[magit-reset] to reset `HEAD' to the commit at point.
 
 ;;; _
 (provide 'magit-reflog)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-reflog.el ends here
diff --git a/elpa/magit-20250519.1537/magit-refs.el b/elpa/magit-20251103.1130/magit-refs.el
similarity index 88%
rename from elpa/magit-20250519.1537/magit-refs.el
rename to elpa/magit-20251103.1130/magit-refs.el
index 2bcee3e7..8a53dba0 100644
--- a/elpa/magit-20250519.1537/magit-refs.el
+++ b/elpa/magit-20251103.1130/magit-refs.el
@@ -314,7 +314,7 @@ Type \\[magit-reset] to reset `HEAD' to the commit at point.
     (magit-buffer-arguments args)))
 
 (defun magit-refs-refresh-buffer ()
-  (setq magit-set-buffer-margin-refresh (not (magit-buffer-margin-p)))
+  (setq magit--right-margin-delayed (not (magit--right-margin-active)))
   (unless (magit-rev-verify magit-buffer-upstream)
     (setq magit-refs-show-commit-count nil))
   (magit-set-header-line-format
@@ -356,22 +356,16 @@ Type \\[magit-reset] to reset `HEAD' to the commit at point.
 (defun magit-show-refs-arguments (&optional use-buffer-args)
   (unless use-buffer-args
     (setq use-buffer-args magit-direct-use-buffer-arguments))
-  (let (args)
-    (cond
-     ((eq transient-current-command 'magit-show-refs)
-      (setq args (transient-args 'magit-show-refs)))
-     ((eq major-mode 'magit-refs-mode)
-      (setq args magit-buffer-arguments))
-     ((and (memq use-buffer-args '(always selected))
-           (and-let* ((buffer (magit-get-mode-buffer
-                               'magit-refs-mode nil
-                               (eq use-buffer-args 'selected))))
-             (progn
-               (setq args (buffer-local-value 'magit-buffer-arguments buffer))
-               t))))
-     (t
-      (setq args (alist-get 'magit-show-refs transient-values))))
-    args))
+  (cond-let*
+    ((eq transient-current-command 'magit-show-refs)
+     (transient-args 'magit-show-refs))
+    ((eq major-mode 'magit-refs-mode)
+     magit-buffer-arguments)
+    ([_(memq use-buffer-args '(always selected))]
+     [buffer (magit-get-mode-buffer 'magit-refs-mode nil
+                                    (eq use-buffer-args 'selected))]
+     (buffer-local-value 'magit-buffer-arguments buffer))
+    ((alist-get 'magit-show-refs transient-values))))
 
 (transient-define-argument magit-for-each-ref:--contains ()
   :description "Contains"
@@ -441,47 +435,48 @@ different, but only if you have customized the option
 `magit-visit-ref-behavior' (which see).  When invoked from a
 menu this command always behaves like `magit-show-commit'."
   (interactive)
-  (if (and (derived-mode-p 'magit-refs-mode)
-           (magit-section-match '(branch tag))
-           (not (magit-menu-position)))
-      (let ((ref (oref (magit-current-section) value)))
-        (cond (current-prefix-arg
-               (cond ((memq 'focus-on-ref magit-visit-ref-behavior)
-                      (magit-refs-setup-buffer ref (magit-show-refs-arguments)))
-                     (magit-visit-ref-behavior
-                      ;; Don't prompt for commit to visit.
-                      (let ((current-prefix-arg nil))
-                        (call-interactively #'magit-show-commit)))))
-              ((and (memq 'create-branch magit-visit-ref-behavior)
-                    (magit-section-match [branch remote]))
-               (let ((branch (cdr (magit-split-branch-name ref))))
-                 (if (magit-branch-p branch)
-                     (if (magit-rev-eq branch ref)
-                         (magit-call-git "checkout" branch)
-                       (setq branch (propertize branch 'face 'magit-branch-local))
-                       (setq ref (propertize ref 'face 'magit-branch-remote))
-                       (pcase (prog1 (read-char-choice (format (propertize "\
+  (cond-let
+    ((not (and (derived-mode-p 'magit-refs-mode)
+               (magit-section-match '(branch tag))
+               (not (magit-menu-position))))
+     (call-interactively #'magit-show-commit))
+    [[ref (oref (magit-current-section) value)]]
+    ((and current-prefix-arg
+          (memq 'focus-on-ref magit-visit-ref-behavior))
+     (magit-refs-setup-buffer ref (magit-show-refs-arguments)))
+    ((and current-prefix-arg
+          magit-visit-ref-behavior
+          ;; Don't prompt for commit to visit.
+          (let ((current-prefix-arg nil))
+            (call-interactively #'magit-show-commit))))
+    ((and (memq 'create-branch magit-visit-ref-behavior)
+          (magit-section-match [branch remote]))
+     (let ((branch (cdr (magit-split-branch-name ref))))
+       (if (magit-branch-p branch)
+           (if (magit-rev-eq branch ref)
+               (magit-call-git "checkout" branch)
+             (setq branch (propertize branch 'face 'magit-branch-local))
+             (setq ref (propertize ref 'face 'magit-branch-remote))
+             (pcase (prog1 (read-char-choice (format (propertize "\
 Branch %s already exists.
   [c]heckout %s as-is
   [r]reset %s to %s and checkout %s
   [a]bort " 'face 'minibuffer-prompt) branch branch branch ref branch)
-                                                       '(?c ?r ?a))
-                                (message "")) ; otherwise prompt sticks
-                         (?c (magit-call-git "checkout" branch))
-                         (?r (magit-call-git "checkout" "-B" branch ref))
-                         (?a (user-error "Abort"))))
-                   (magit-call-git "checkout" "-b" branch ref))
-                 (setq magit-buffer-upstream branch)
-                 (magit-refresh)))
-              ((or (memq 'checkout-any magit-visit-ref-behavior)
-                   (and (memq 'checkout-branch magit-visit-ref-behavior)
-                        (magit-section-match [branch local])))
-               (magit-call-git "checkout" ref)
-               (setq magit-buffer-upstream ref)
-               (magit-refresh))
-              (t
-               (call-interactively #'magit-show-commit))))
-    (call-interactively #'magit-show-commit)))
+                                             '(?c ?r ?a))
+                      (message "")) ; otherwise prompt sticks
+               (?c (magit-call-git "checkout" branch))
+               (?r (magit-call-git "checkout" "-B" branch ref))
+               (?a (user-error "Abort"))))
+         (magit-call-git "checkout" "-b" branch ref))
+       (setq magit-buffer-upstream branch)
+       (magit-refresh)))
+    ((or (memq 'checkout-any magit-visit-ref-behavior)
+         (and (memq 'checkout-branch magit-visit-ref-behavior)
+              (magit-section-match [branch local])))
+     (magit-call-git "checkout" ref)
+     (setq magit-buffer-upstream ref)
+     (magit-refresh))
+    ((call-interactively #'magit-show-commit))))
 
 ;;; Sections
 
@@ -501,6 +496,10 @@ Branch %s already exists.
   "<2>" (magit-menu-item "Delete %m"    #'magit-branch-delete)
   "<1>" (magit-menu-item "Visit commit" #'magit-visit-ref))
 
+(defvar-keymap magit-shelved-branch-section-map
+  :doc "Keymap for `shelved-branch' sections."
+  "<remap> <magit-delete-thing>" #'magit-delete-shelved-branch)
+
 (defvar-keymap magit-tag-section-map
   :doc "Keymap for `tag' sections."
   "<remap> <magit-delete-thing>" #'magit-tag-delete
@@ -509,8 +508,8 @@ Branch %s already exists.
   "<1>" (magit-menu-item "Visit %s"  #'magit-visit-ref))
 
 (defun magit--painted-branch-as-menu-section (section)
-  (and-let* ((branch (and (magit-section-match 'commit)
-                          (magit--painted-branch-at-point))))
+  (and-let ((_(magit-section-match 'commit))
+            (branch (magit--painted-branch-at-point)))
     (let ((dummy (magit-section :type 'branch :value branch)))
       (oset dummy keymap magit-branch-section-map)
       (dolist (slot '(start content hidden parent children))
@@ -547,8 +546,8 @@ line is inserted at all."
         (magit-insert-heading (length tags) "Tags")
         (dolist (tag tags)
           (string-match "^\\([^ \t]+\\)[ \t]+\\([^ \t\n].*\\)?" tag)
-          (let ((tag (match-string 1 tag))
-                (msg (match-string 2 tag)))
+          (let ((tag (match-str 1 tag))
+                (msg (match-str 2 tag)))
             (when (magit-refs--insert-refname-p tag)
               (magit-insert-section (tag tag t)
                 (magit-insert-heading
@@ -561,8 +560,8 @@ line is inserted at all."
                              (length tag)))
                    ?\s)
                   (and msg (magit-log--wash-summary msg)))
-                (when (and magit-refs-margin-for-tags (magit-buffer-margin-p))
-                  (magit-refs--format-margin tag))
+                (when magit-refs-margin-for-tags
+                  (magit-refs--maybe-format-margin tag))
                 (magit-refs--insert-cherry-commits tag)))))
         (insert ?\n)
         (magit-make-margin-overlay)))))
@@ -616,8 +615,7 @@ line is inserted at all."
                                  (length abbrev)))
                        ?\s)
                       (and msg (magit-log--wash-summary msg))))
-                  (when (magit-buffer-margin-p)
-                    (magit-refs--format-margin branch))
+                  (magit-refs--maybe-format-margin branch)
                   (magit-refs--insert-cherry-commits branch))))))))
       (insert ?\n)
       (magit-make-margin-overlay))))
@@ -633,8 +631,7 @@ line is inserted at all."
              (or branch (magit-rev-parse "HEAD"))
              t)
           (apply #'magit-insert-heading strings)
-          (when (magit-buffer-margin-p)
-            (magit-refs--format-margin branch))
+          (magit-refs--maybe-format-margin branch)
           (magit-refs--insert-cherry-commits branch))))
     (insert ?\n)
     (magit-make-margin-overlay)))
@@ -642,14 +639,13 @@ line is inserted at all."
 (defun magit-insert-shelved-branches ()
   "Insert sections showing all shelved branches."
   (when-let ((refs (magit-list-refs "refs/shelved/")))
-    (magit-insert-section (shelved nil)
+    (magit-insert-section (shelved nil t)
       (magit-insert-heading t "Shelved branches")
       (dolist (ref (nreverse refs))
         (magit-insert-section (shelved-branch ref t)
           (magit-insert-heading
             "  " (magit--propertize-face (substring ref 13) 'magit-refname))
-          (when (magit-buffer-margin-p)
-            (magit-refs--format-margin ref))
+          (magit-refs--maybe-format-margin ref)
           (magit-refs--insert-cherry-commits ref)))
       (insert ?\n)
       (magit-make-margin-overlay))))
@@ -709,20 +705,20 @@ line is inserted at all."
                             (string-match "ahead \\([0-9]+\\)" u:track)
                             (magit--propertize-face
                              (concat (and magit-refs-pad-commit-counts " ")
-                                     (match-string 1 u:track)
+                                     (match-str 1 u:track)
                                      ">")
                              'magit-dimmed)))
              (u:behind (and u:track
                             (string-match "behind \\([0-9]+\\)" u:track)
                             (magit--propertize-face
                              (concat "<"
-                                     (match-string 1 u:track)
+                                     (match-str 1 u:track)
                                      (and magit-refs-pad-commit-counts " "))
                              'magit-dimmed)))
              (p:ahead  (and pushp p:track
                             (string-match "ahead \\([0-9]+\\)" p:track)
                             (magit--propertize-face
-                             (concat (match-string 1 p:track)
+                             (concat (match-str 1 p:track)
                                      ">"
                                      (and magit-refs-pad-commit-counts " "))
                              'magit-branch-remote)))
@@ -730,7 +726,7 @@ line is inserted at all."
                             (string-match "behind \\([0-9]+\\)" p:track)
                             (magit--propertize-face
                              (concat "<"
-                                     (match-string 1 p:track)
+                                     (match-str 1 p:track)
                                      (and magit-refs-pad-commit-counts " "))
                              'magit-dimmed))))
         (list (1+ (length (concat branch-pretty u:ahead p:ahead u:behind)))
@@ -748,7 +744,7 @@ line is inserted at all."
                            (magit--propertize-face
                             push 'magit-branch-remote)
                            " "))
-              (if-let ((magit-refs-show-branch-descriptions)
+              (if-let ((_ magit-refs-show-branch-descriptions)
                        (desc (magit-get "branch" branch "description")))
                   (magit--propertize-face desc 'bold)
                 (and msg (magit-log--wash-summary msg))))))))
@@ -774,9 +770,9 @@ line is inserted at all."
               (magit--propertize-face
                (cond ((> ahead  0) (concat "<" (number-to-string ahead)))
                      ((> behind 0) (concat (number-to-string behind) ">"))
-                     (t "="))
+                     ("="))
                'magit-dimmed)))
-           (t "")))))
+           ("")))))
 
 (defun magit-refs--propertize-branch (branch ref &optional head-face)
   (let ((face (cdr (cl-find-if (pcase-lambda (`(,re . ,_))
@@ -804,11 +800,23 @@ line is inserted at all."
           (message "No cherries for %s" ref)
         (magit-make-margin-overlay)))))
 
-(defun magit-refs--format-margin (commit)
-  (if-let ((line (magit-rev-format "%cN%x00%ct" commit)))
-      (apply #'magit-log-format-margin commit (split-string line "\0"))
-    (magit-make-margin-overlay)))
+(defun magit-refs--maybe-format-margin (rev)
+  (when (magit--right-margin-active)
+    (if-let ((line (magit-rev-format "%cN%x00%ct" rev)))
+        (apply #'magit-log-format-margin rev (split-string line "\0"))
+      (magit-make-margin-overlay))))
 
 ;;; _
 (provide 'magit-refs)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-refs.el ends here
diff --git a/elpa/magit-20250519.1537/magit-remote.el b/elpa/magit-20251103.1130/magit-remote.el
similarity index 96%
rename from elpa/magit-20250519.1537/magit-remote.el
rename to elpa/magit-20251103.1130/magit-remote.el
index e4cdab79..afcaeea4 100644
--- a/elpa/magit-20250519.1537/magit-remote.el
+++ b/elpa/magit-20251103.1130/magit-remote.el
@@ -175,8 +175,8 @@ the now stale refspecs.  Other stale branches are not removed."
          stale)
     (dolist (refspec refspecs)
       (when (string-match magit--refspec-re refspec)
-        (let ((theirs (match-string 2 refspec))
-              (ours   (match-string 3 refspec)))
+        (let ((theirs (match-str 2 refspec))
+              (ours   (match-str 3 refspec)))
           (unless (if (string-match "\\*" theirs)
                       (let ((re (replace-match ".*" t t theirs)))
                         (seq-some (##string-match-p re %) remote-refs))
@@ -393,4 +393,15 @@ refspec."
 
 ;;; _
 (provide 'magit-remote)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-remote.el ends here
diff --git a/elpa/magit-20250519.1537/magit-repos.el b/elpa/magit-20251103.1130/magit-repos.el
similarity index 91%
rename from elpa/magit-20250519.1537/magit-repos.el
rename to elpa/magit-20251103.1130/magit-repos.el
index b815757c..44b05e59 100644
--- a/elpa/magit-20250519.1537/magit-repos.el
+++ b/elpa/magit-20251103.1130/magit-repos.el
@@ -31,6 +31,7 @@
 (require 'magit-core)
 
 (declare-function magit-status-setup-buffer "magit-status" (&optional directory))
+(declare-function magit-dired-jump "magit-dired" (&optional other-window))
 
 (defvar x-stretch-cursor)
 
@@ -262,7 +263,8 @@ If it contains \"%s\" then the directory is substituted for that."
   "m"   #'magit-repolist-mark
   "u"   #'magit-repolist-unmark
   "f"   #'magit-repolist-fetch
-  "5"   #'magit-repolist-find-file-other-frame)
+  "5"   #'magit-repolist-find-file-other-frame
+  "<remap> <dired-jump>" #'magit-dired-jump)
 
 (define-derived-mode magit-repolist-mode tabulated-list-mode "Repos"
   "Major mode for browsing a list of Git repositories."
@@ -308,7 +310,7 @@ If it contains \"%s\" then the directory is substituted for that."
                                            sort-fn #'identity idx))
                                          (sort-fn sort-fn)
                                          (sort-set nil)
-                                         (t t)))
+                                         (t)))
                              (flatten-tree props))))
                   magit-repolist-columns))))
 
@@ -372,10 +374,10 @@ Usually this is just its basename."
 
 (defun magit-repolist-column-version (_)
   "Insert a description of the repository's `HEAD' revision."
-  (and-let* ((v (or (magit-git-string "describe" "--tags" "--dirty")
-                    ;; If there are no tags, use the date in MELPA format.
-                    (magit-rev-format "%cd-g%h" nil
-                                      "--date=format:%Y%m%d.%H%M"))))
+  (and-let ((v (or (magit-git-string "describe" "--tags" "--dirty")
+                   ;; If there are no tags, use the date in MELPA format.
+                   (magit-rev-format "%cd-g%h" nil
+                                     "--date=format:%Y%m%d.%H%M"))))
     (save-match-data
       (when (string-match magit-repolist-column-version-regexp v)
         (magit--put-face (match-beginning 0) (match-end 0) 'shadow v)
@@ -384,24 +386,25 @@ Usually this is just its basename."
         (when (match-end 4)
           (magit--put-face (or (match-beginning 3) (match-beginning 4))
                            (match-end 4) 'error v))
-        (when (and (equal (match-string 2 v) "1")
+        (when (and (equal (match-str 2 v) "1")
                    (string-match-p magit-repolist-column-version-resume-regexp
                                    (magit-rev-format "%s")))
           (setq v (replace-match (propertize "+" 'face 'shadow) t t v 1))))
-      (if (and v (string-match "\\`[0-9]" v))
-          (concat " " v)
-        (when (and v (string-match "\\`[^0-9]+" v))
-          (magit--put-face 0 (match-end 0) 'shadow v))
-        v))))
+      (cond ((not v) nil)
+            ((string-match "\\`[0-9]" v)
+             (concat " " v))
+            ((string-match "\\`[^0-9]+" v)
+             (magit--put-face 0 (match-end 0) 'shadow v)
+             v)))))
 
 (defun magit-repolist-version< (a b)
   (save-match-data
     (let ((re "[0-9]+\\(\\.[0-9]*\\)*"))
-      (setq a (and (string-match re a) (match-string 0 a)))
-      (setq b (and (string-match re b) (match-string 0 b)))
+      (setq a (and (string-match re a) (match-str 0 a)))
+      (setq b (and (string-match re b) (match-str 0 b)))
       (cond ((and a b) (version< a b))
             (b nil)
-            (t t)))))
+            (t)))))
 
 (defun magit-repolist-column-branch (_)
   "Insert the current branch."
@@ -437,23 +440,27 @@ which only lists the first one found."
 
 (defun magit-repolist-column-unpulled-from-upstream (spec)
   "Insert number of upstream commits not in the current branch."
-  (and-let* ((br (magit-get-upstream-branch)))
-    (magit-repolist-insert-count (cadr (magit-rev-diff-count "HEAD" br)) spec)))
+  (and$ (magit-get-upstream-branch)
+        (magit-repolist-insert-count (cadr (magit-rev-diff-count "HEAD" $))
+                                     spec)))
 
 (defun magit-repolist-column-unpulled-from-pushremote (spec)
   "Insert number of commits in the push branch but not the current branch."
-  (and-let* ((br (magit-get-push-branch nil t)))
-    (magit-repolist-insert-count (cadr (magit-rev-diff-count "HEAD" br)) spec)))
+  (and$ (magit-get-push-branch nil t)
+        (magit-repolist-insert-count (cadr (magit-rev-diff-count "HEAD" $))
+                                     spec)))
 
 (defun magit-repolist-column-unpushed-to-upstream (spec)
   "Insert number of commits in the current branch but not its upstream."
-  (and-let* ((br (magit-get-upstream-branch)))
-    (magit-repolist-insert-count (car (magit-rev-diff-count "HEAD" br)) spec)))
+  (and$ (magit-get-upstream-branch)
+        (magit-repolist-insert-count (car (magit-rev-diff-count "HEAD" $))
+                                     spec)))
 
 (defun magit-repolist-column-unpushed-to-pushremote (spec)
   "Insert number of commits in the current branch but not its push branch."
-  (and-let* ((br (magit-get-push-branch nil t)))
-    (magit-repolist-insert-count (car (magit-rev-diff-count "HEAD" br)) spec)))
+  (and$ (magit-get-push-branch nil t)
+        (magit-repolist-insert-count (car (magit-rev-diff-count "HEAD" $))
+                                     spec)))
 
 (defun magit-repolist-column-branches (spec)
   "Insert number of branches."
@@ -490,7 +497,7 @@ instead."
   (if-let ((repos (and (not read-directory-name)
                        magit-repository-directories
                        (magit-repos-alist))))
-      (let ((reply (magit-completing-read "Git repository" repos)))
+      (let ((reply (magit-completing-read "Git repository" repos nil 'any)))
         (file-name-as-directory
          (or (cdr (assoc reply repos))
              (if (file-directory-p reply)
@@ -544,4 +551,15 @@ instead."
 
 ;;; _
 (provide 'magit-repos)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-repos.el ends here
diff --git a/elpa/magit-20250519.1537/magit-reset.el b/elpa/magit-20251103.1130/magit-reset.el
similarity index 91%
rename from elpa/magit-20250519.1537/magit-reset.el
rename to elpa/magit-20251103.1130/magit-reset.el
index 4baa64b2..4e8af09c 100644
--- a/elpa/magit-20250519.1537/magit-reset.el
+++ b/elpa/magit-20251103.1130/magit-reset.el
@@ -55,14 +55,14 @@
 ;;;###autoload
 (defun magit-reset-soft (commit)
   "Reset the `HEAD' to COMMIT, but not the index and working tree.
-\n(git reset --soft REVISION)"
+\n(git reset --soft COMMIT)"
   (interactive (list (magit-reset-read-branch-or-commit "Soft reset %s to")))
   (magit-reset-internal "--soft" commit))
 
 ;;;###autoload
 (defun magit-reset-hard (commit)
   "Reset the `HEAD', index, and working tree to COMMIT.
-\n(git reset --hard REVISION)"
+\n(git reset --hard COMMIT)"
   (interactive (list (magit-reset-read-branch-or-commit
                       (concat (magit--propertize-face "Hard" 'bold)
                               " reset %s to"))))
@@ -71,7 +71,7 @@
 ;;;###autoload
 (defun magit-reset-keep (commit)
   "Reset the `HEAD' and index to COMMIT, while keeping uncommitted changes.
-\n(git reset --keep REVISION)"
+\n(git reset --keep COMMIT)"
   (interactive (list (magit-reset-read-branch-or-commit "Reset %s to")))
   (magit-reset-internal "--keep" commit))
 
@@ -134,4 +134,15 @@ or \"detached head\" will be substituted for %s."
 
 ;;; _
 (provide 'magit-reset)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-reset.el ends here
diff --git a/elpa/magit-20250519.1537/magit-sequence.el b/elpa/magit-20251103.1130/magit-sequence.el
similarity index 93%
rename from elpa/magit-20250519.1537/magit-sequence.el
rename to elpa/magit-20251103.1130/magit-sequence.el
index 90e352a7..97f15634 100644
--- a/elpa/magit-20250519.1537/magit-sequence.el
+++ b/elpa/magit-20251103.1130/magit-sequence.el
@@ -31,8 +31,8 @@
 (require 'magit)
 
 ;; For `magit-rebase--todo'.
-(declare-function git-rebase-current-line "git-rebase" ())
-(eval-when-compile
+(declare-function git-rebase-current-line "git-rebase" (&optional batch))
+(eval-and-compile
   (cl-pushnew 'action-type eieio--known-slot-names)
   (cl-pushnew 'action eieio--known-slot-names)
   (cl-pushnew 'action-options eieio--known-slot-names)
@@ -349,8 +349,7 @@ the process manually."
                      command))
         ((seq-find (##string-prefix-p "--mainline=" %) args)
          args)
-        (t
-         (cons (format "--mainline=%s"
+        ((cons (format "--mainline=%s"
                        (read-number "Replay merges relative to parent: "))
                args))))
      commits)))
@@ -361,9 +360,8 @@ the process manually."
     (or (file-exists-p (expand-file-name "CHERRY_PICK_HEAD" dir))
         ;; And CHERRY_PICK_HEAD does not exist when a conflict happens
         ;; while picking a series of commits with --no-commit.
-        (and-let* ((line (magit-file-line
-                          (expand-file-name "sequencer/todo" dir))))
-          (string-prefix-p "pick" line)))))
+        (and$ (magit-file-line (expand-file-name "sequencer/todo" dir))
+              (string-prefix-p "pick" $)))))
 
 ;;; Revert
 
@@ -419,9 +417,8 @@ without prompting."
     (or (file-exists-p (expand-file-name "REVERT_HEAD" dir))
         ;; And REVERT_HEAD does not exist when a conflict happens
         ;; while reverting a series of commits with --no-commit.
-        (and-let* ((line (magit-file-line
-                          (expand-file-name "sequencer/todo" dir))))
-          (string-prefix-p "revert" line)))))
+        (and$ (magit-file-line (expand-file-name "sequencer/todo" dir))
+              (string-prefix-p "revert" $)))))
 
 ;;; Patch
 
@@ -622,7 +619,7 @@ the upstream."
     (magit-git-rebase upstream args)))
 
 (defun magit-rebase--upstream-description ()
-  (and-let* ((branch (magit-get-current-branch)))
+  (and-let ((branch (magit-get-current-branch)))
     (or (magit-get-upstream-branch branch)
         (let ((remote (magit-get "branch" branch "remote"))
               (merge  (magit-get "branch" branch "merge"))
@@ -634,8 +631,7 @@ the upstream."
             (concat u ", replacing non-existent"))
            ((or remote merge)
             (concat u ", replacing invalid"))
-           (t
-            (concat u ", setting that")))))))
+           ((concat u ", setting that")))))))
 
 ;;;###autoload
 (defun magit-rebase-branch (target args)
@@ -658,15 +654,15 @@ START has to be selected from a list of recent commits."
                       (magit-get-upstream-branch))
                      nil
                      (magit-rebase-arguments)))
-  (if start
-      (progn (message "Rebasing...")
-             (magit-run-git-sequencer "rebase" "--onto" newbase start args)
-             (message "Rebasing...done"))
-    (magit-log-select
-      `(lambda (commit)
-         (magit-rebase-subset ,newbase (concat commit "^") (list ,@args)))
-      (concat "Type %p on a commit to rebase it "
-              "and commits above it onto " newbase ","))))
+  (cond (start
+         (message "Rebasing...")
+         (magit-run-git-sequencer "rebase" "--onto" newbase start args)
+         (message "Rebasing...done"))
+        ((magit-log-select
+           `(lambda (commit)
+              (magit-rebase-subset ,newbase (concat commit "^") (list ,@args)))
+           (concat "Type %p on a commit to rebase it "
+                   "and commits above it onto " newbase ",")))))
 
 (defvar magit-rebase-interactive-include-selected t)
 
@@ -764,8 +760,8 @@ argument, prompt for the first commit to potentially squash into."
   (interactive (list current-prefix-arg
                      (magit-rebase-arguments)))
   (magit-rebase-interactive-1
-      (and-let* (((not select))
-                 (upstream (magit-get-upstream-branch)))
+      (and-let ((_(not select))
+                (upstream (magit-get-upstream-branch)))
         (magit-git-string "merge-base" upstream "HEAD"))
       (nconc (list "--autosquash" "--keep-empty") args)
     "Type %p on a commit to squash into it and then rebase as necessary,"
@@ -822,25 +818,26 @@ argument, prompt for the first commit to potentially squash into."
 In some cases this pops up a commit message buffer for you do
 edit.  With a prefix argument the old message is reused as-is."
   (interactive "P")
-  (if (magit-rebase-in-progress-p)
-      (if (magit-anything-unstaged-p t)
-          (user-error "Cannot continue rebase with unstaged changes")
-        (let ((dir (magit-gitdir)))
-          (when (and (magit-anything-staged-p)
-                     (file-exists-p (expand-file-name "rebase-merge" dir))
-                     (not (member (magit-toplevel)
-                                  magit--rebase-public-edit-confirmed)))
-            (magit-commit-amend-assert
-             (magit-file-line
-              (expand-file-name "rebase-merge/orig-head" dir)))))
-        (if noedit
-            (with-environment-variables (("GIT_EDITOR" "true"))
-              (magit-run-git-async (magit--rebase-resume-command) "--continue")
-              (set-process-sentinel magit-this-process
-                                    #'magit-sequencer-process-sentinel)
-              magit-this-process)
-          (magit-run-git-sequencer (magit--rebase-resume-command) "--continue")))
-    (user-error "No rebase in progress")))
+  (cond
+   ((not (magit-rebase-in-progress-p))
+    (user-error "No rebase in progress"))
+   ((magit-anything-unstaged-p t)
+    (user-error "Cannot continue rebase with unstaged changes"))
+   (t
+    (let ((dir (magit-gitdir)))
+      (when (and (magit-anything-staged-p)
+                 (file-exists-p (expand-file-name "rebase-merge" dir))
+                 (not (member (magit-toplevel)
+                              magit--rebase-public-edit-confirmed)))
+        (magit-commit-amend-assert
+         (magit-file-line (expand-file-name "rebase-merge/orig-head" dir)))))
+    (if noedit
+        (with-environment-variables (("GIT_EDITOR" "true"))
+          (magit-run-git-async (magit--rebase-resume-command) "--continue")
+          (set-process-sentinel magit-this-process
+                                #'magit-sequencer-process-sentinel)
+          magit-this-process)
+      (magit-run-git-sequencer (magit--rebase-resume-command) "--continue")))))
 
 ;;;###autoload
 (defun magit-rebase-skip ()
@@ -942,8 +939,7 @@ If no such sequence is in progress, do nothing."
                 (commit
                  (magit-sequence-insert-commit
                   "pick" commit 'magit-sequence-pick))
-                (t
-                 (magit-sequence-insert-am-patch
+                ((magit-sequence-insert-am-patch
                   "pick" patch 'magit-sequence-pick)))
           (cl-decf i)))
       (magit-sequence-insert-sequence nil "ORIG_HEAD")
@@ -997,7 +993,7 @@ status buffer (i.e., the reverse of how they will be applied)."
       (insert-file-contents
        (expand-file-name "rebase-merge/git-rebase-todo" (magit-gitdir)))
       (while (not (eobp))
-        (when-let ((obj (git-rebase-current-line)))
+        (when-let ((obj (git-rebase-current-line t)))
           (push obj actions)
           (when (memq (oref obj action-type) '(commit merge))
             (push obj commits)))
@@ -1010,7 +1006,7 @@ status buffer (i.e., the reverse of how they will be applied)."
                            (if (eq (oref obj action-type) 'merge)
                                (let ((options (oref obj action-options)))
                                  (and (string-match "-[cC] \\([^ ]+\\)" options)
-                                      (match-string 1 options)))
+                                      (match-str 1 options)))
                              (oref obj target)))
                          commits)))))
       (cl-assert (equal (length commits) (length abbrevs)))
@@ -1031,9 +1027,8 @@ status buffer (i.e., the reverse of how they will be applied)."
     (magit-sequence-insert-sequence
      (magit-file-line (expand-file-name "rebase-merge/stopped-sha" dir))
      onto
-     (and-let* ((lines (magit-file-lines
-                        (expand-file-name "rebase-merge/done" dir))))
-       (cadr (split-string (car (last lines))))))))
+     (and$ (magit-file-lines (expand-file-name "rebase-merge/done" dir))
+           (cadr (split-string (car (last $))))))))
 
 (defun magit-rebase-insert-apply-sequence (onto)
   (let* ((dir (magit-gitdir))
@@ -1090,15 +1085,14 @@ status buffer (i.e., the reverse of how they will be applied)."
                      (equal (magit-patch-id unstaged) id))
                  "same")
                 ;; ...and some changes are gone and/or others were added.
-                (t "work")))
+                ("work")))
              stop 'magit-sequence-part))
            ;; The commit is definitely gone...
            ((assoc (##magit-rev-equal % stop) done)
             ;; ...but all of its changes are still in effect.
             (magit-sequence-insert-commit "poof" stop 'magit-sequence-drop))
-           (t
-            ;; ...and some changes are gone and/or other changes were added.
-            (magit-sequence-insert-commit "gone" stop 'magit-sequence-drop)))
+           ;; ...and some changes are gone and/or other changes were added.
+           ((magit-sequence-insert-commit "gone" stop 'magit-sequence-drop)))
           (setq stop nil))))
     (pcase-dolist (`(,rev ,abbrev ,msg) done)
       (apply #'magit-sequence-insert-commit
@@ -1116,8 +1110,7 @@ status buffer (i.e., the reverse of how they will be applied)."
                           abbrev msg))
                    ((equal rev head)
                     (list "done" rev 'magit-sequence-head abbrev msg))
-                   (t
-                    (list "done" rev 'magit-sequence-done abbrev msg)))))
+                   ((list "done" rev 'magit-sequence-done abbrev msg)))))
     (magit-sequence-insert-commit "onto" onto
                                   (if (equal onto head)
                                       'magit-sequence-head
@@ -1126,9 +1119,9 @@ status buffer (i.e., the reverse of how they will be applied)."
 (defun magit-sequence-insert-commit (type hash face &optional abbrev msg)
   (magit-insert-section (commit hash)
     (magit-insert-heading
-      (propertize type 'font-lock-face face) " "
+      (magit--propertize-face type face) " "
       (if abbrev
-          (concat (propertize abbrev 'face 'magit-hash) " " msg "\n")
+          (concat (magit--propertize-face abbrev 'magit-hash) " " msg "\n")
         (concat (magit-format-rev-summary hash) "\n")))))
 
 (defun magit-sequence-insert-step (type target)
@@ -1141,4 +1134,15 @@ status buffer (i.e., the reverse of how they will be applied)."
 
 ;;; _
 (provide 'magit-sequence)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-sequence.el ends here
diff --git a/elpa/magit-20250519.1537/magit-sparse-checkout.el b/elpa/magit-20251103.1130/magit-sparse-checkout.el
similarity index 92%
rename from elpa/magit-20250519.1537/magit-sparse-checkout.el
rename to elpa/magit-20251103.1130/magit-sparse-checkout.el
index 1df657a7..8fb9e59a 100644
--- a/elpa/magit-20250519.1537/magit-sparse-checkout.el
+++ b/elpa/magit-20251103.1130/magit-sparse-checkout.el
@@ -23,15 +23,7 @@
 ;;; Commentary:
 
 ;; This library provides an interface to the `git sparse-checkout'
-;; command.  It's been possible to define sparse checkouts since Git
-;; v1.7.0 by adding patterns to $GIT_DIR/info/sparse-checkout and
-;; calling `git read-tree -mu HEAD' to update the index and working
-;; tree.  However, Git v2.25 introduced the `git sparse-checkout'
-;; command along with "cone mode", which restricts the possible
-;; patterns to directories to provide better performance.
-;;
-;; The goal of this library is to support the `git sparse-checkout'
-;; command operating in cone mode.
+;; command (operating in cone mode).
 
 ;;; Code:
 
@@ -155,4 +147,15 @@ This header is not inserted by default.  To enable it, add it to
 
 ;;; _
 (provide 'magit-sparse-checkout)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-sparse-checkout.el ends here
diff --git a/elpa/magit-20250519.1537/magit-stash.el b/elpa/magit-20251103.1130/magit-stash.el
similarity index 97%
rename from elpa/magit-20250519.1537/magit-stash.el
rename to elpa/magit-20251103.1130/magit-stash.el
index 4ceea526..456cb624 100644
--- a/elpa/magit-20250519.1537/magit-stash.el
+++ b/elpa/magit-20251103.1130/magit-stash.el
@@ -448,10 +448,10 @@ Then apply STASH, dropping it if it applies cleanly."
     (unless noerror
       (user-error "No %s changes to save" (cond ((not index)  "unstaged")
                                                 ((not worktree) "staged")
-                                                (t "local"))))))
+                                                ("local"))))))
 
-(defun magit-stash-store (message ref commit)
-  (magit-update-ref ref message commit))
+(defun magit-stash-store (message ref rev)
+  (magit-update-ref ref message rev))
 
 (defun magit-stash-create (message index worktree untracked)
   (unless (magit-rev-parse "--verify" "HEAD")
@@ -569,7 +569,8 @@ instead of \"Stashes:\"."
 
 (defun magit-stashes-maybe-update-stash-buffer (&optional _)
   "When moving in the stashes buffer, update the stash buffer.
-If there is no stash buffer in the same frame, then do nothing."
+If there is no stash buffer in the same frame, then do nothing.
+See also info node `(magit)Section Movement'."
   (when (derived-mode-p 'magit-stashes-mode)
     (magit--maybe-update-stash-buffer)))
 
@@ -636,8 +637,8 @@ If there is no stash buffer in the same frame, then do nothing."
 (cl-defmethod magit-buffer-value (&context (major-mode magit-stash-mode))
   magit-buffer-revision)
 
-(defun magit-stash-insert-section (commit range message &optional files)
-  (magit-insert-section (commit commit)
+(defun magit-stash-insert-section (rev range message &optional files)
+  (magit-insert-section (commit rev)
     (magit-insert-heading message)
     (magit--insert-diff nil
       "diff" range "-p" "--no-prefix" magit-buffer-diff-args
@@ -680,4 +681,15 @@ that make up the stash."
 
 ;;; _
 (provide 'magit-stash)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-stash.el ends here
diff --git a/elpa/magit-20250519.1537/magit-status.el b/elpa/magit-20251103.1130/magit-status.el
similarity index 85%
rename from elpa/magit-20250519.1537/magit-status.el
rename to elpa/magit-20251103.1130/magit-status.el
index 970d7274..0ac1169a 100644
--- a/elpa/magit-20250519.1537/magit-status.el
+++ b/elpa/magit-20251103.1130/magit-status.el
@@ -147,7 +147,7 @@ The functions which respect this option are
 
 - If nil, do not list any untracked files.
 - If t, list untracked files, but if a directory does not contain any
-  untracked files, then only list that directory, not the contained
+  tracked files, then only list that directory, not the contained
   untracked files.
 - If all, then list each individual untracked files.  This is can be
   very slow and is discouraged.
@@ -346,8 +346,12 @@ also contains other useful hints.")
 
 ;;;###autoload
 (defun magit-status-here ()
-  "Like `magit-status' but with non-nil `magit-status-goto-file-position'."
+  "Like `magit-status' but with non-nil `magit-status-goto-file-position'.
+Before doing so, save all file-visiting buffers belonging to the current
+repository without prompting."
   (interactive)
+  (let ((magit-inhibit-refresh t))
+    (magit-save-repository-buffers t))
   (let ((magit-status-goto-file-position t))
     (call-interactively #'magit-status)))
 
@@ -433,9 +437,6 @@ Type \\[magit-commit] to create a commit.
   :interactive nil
   :group 'magit-status
   (magit-hack-dir-local-variables)
-  (when magit-status-initial-section
-    (add-hook 'magit--initial-section-hook
-              #'magit-status-goto-initial-section nil t))
   (setq magit--imenu-group-types '(not branch commit)))
 
 (put 'magit-status-mode 'magit-diff-default-arguments
@@ -445,42 +446,47 @@ Type \\[magit-commit] to create a commit.
 
 ;;;###autoload
 (defun magit-status-setup-buffer (&optional directory)
-  (unless directory
-    (setq directory default-directory))
-  (when (file-remote-p directory)
-    (magit-git-version-assert))
-  (let* ((default-directory directory)
-         (d (magit-diff--get-value 'magit-status-mode
-                                   magit-status-use-buffer-arguments))
-         (l (magit-log--get-value 'magit-status-mode
-                                  magit-status-use-buffer-arguments))
-         (file (and magit-status-goto-file-position
-                    (magit-file-relative-name)))
-         (line (and file (save-restriction (widen) (line-number-at-pos))))
-         (col  (and file (save-restriction (widen) (current-column))))
-         (buf  (magit-setup-buffer #'magit-status-mode nil
-                 (magit-buffer-diff-args  (nth 0 d))
-                 (magit-buffer-diff-files (nth 1 d))
-                 (magit-buffer-log-args   (nth 0 l))
-                 (magit-buffer-log-files  (nth 1 l)))))
-    (when file
-      (with-current-buffer buf
-        (let ((staged (magit-get-section '((staged) (status)))))
-          (if (and staged
-                   (cadr (magit-diff--locate-hunk file line staged)))
-              (magit-diff--goto-position file line col staged)
-            (let ((unstaged (magit-get-section '((unstaged) (status)))))
-              (unless (and unstaged
-                           (magit-diff--goto-position file line col unstaged))
-                (when staged
-                  (magit-diff--goto-position file line col staged))))))))
-    buf))
+  (let ((default-directory (or directory default-directory)))
+    (when (file-remote-p default-directory)
+      (magit-git-version-assert))
+    (pcase-let
+        ((`(,dargs ,dfiles) (magit-diff--get-value 'magit-status-mode 'status))
+         (`(,largs ,lfiles) (magit-log--get-value  'magit-status-mode 'status)))
+      (magit-setup-buffer #'magit-status-mode nil
+        :initial-section #'magit-status-goto-initial-section
+        :select-section (and$ (magit-status--get-file-position)
+                              (lambda () (apply #'magit-status--goto-file-position $)))
+        (magit-buffer-diff-args  dargs)
+        (magit-buffer-diff-files dfiles)
+        (magit-buffer-log-args   largs)
+        (magit-buffer-log-files  lfiles)))))
 
 (defun magit-status-refresh-buffer ()
   (magit-git-exit-code "update-index" "--refresh")
   (magit-insert-section (status)
     (magit-run-section-hook 'magit-status-sections-hook)))
 
+(defun magit-status--get-file-position ()
+  (and-let* ((_ magit-status-goto-file-position)
+             (file (magit-file-relative-name)))
+    (save-excursion
+      (widen)
+      (list file (line-number-at-pos) (current-column)))))
+
+(defun magit-status--goto-file-position (file line column)
+  (pcase-let ((`(,upos ,uloc)
+               (magit-diff--locate-file-position file line column 'unstaged))
+              (`(,spos ,sloc)
+               (magit-diff--locate-file-position file line column 'staged)))
+    (cond ((eq uloc 'line) (goto-char upos))
+          ((eq sloc 'line) (goto-char spos))
+          ((eq uloc 'hunk) (goto-char upos))
+          ((eq sloc 'hunk) (goto-char spos))
+          (upos            (goto-char upos))
+          (spos            (goto-char spos)))
+    (when (or upos spos)
+      (magit-section-reveal (magit-current-section)))))
+
 (defun magit-status-goto-initial-section ()
   "Jump to the section specified by `magit-status-initial-section'."
   (when-let ((section
@@ -500,19 +506,22 @@ Type \\[magit-commit] to create a commit.
 
 (defun magit-status-maybe-update-revision-buffer (&optional _)
   "When moving in the status buffer, update the revision buffer.
-If there is no revision buffer in the same frame, then do nothing."
+If there is no revision buffer in the same frame, then do nothing.
+See also info node `(magit)Section Movement'."
   (when (derived-mode-p 'magit-status-mode)
     (magit--maybe-update-revision-buffer)))
 
 (defun magit-status-maybe-update-stash-buffer (&optional _)
   "When moving in the status buffer, update the stash buffer.
-If there is no stash buffer in the same frame, then do nothing."
+If there is no stash buffer in the same frame, then do nothing.
+See also info node `(magit)Section Movement'."
   (when (derived-mode-p 'magit-status-mode)
     (magit--maybe-update-stash-buffer)))
 
 (defun magit-status-maybe-update-blob-buffer (&optional _)
   "When moving in the status buffer, update the blob buffer.
-If there is no blob buffer in the same frame, then do nothing."
+If there is no blob buffer in the same frame, then do nothing.
+See also info node `(magit)Section Movement'."
   (when (derived-mode-p 'magit-status-mode)
     (magit--maybe-update-blob-buffer)))
 
@@ -544,7 +553,8 @@ the status buffer causes this section to disappear again."
       (insert (propertize (format "%-10s" "GitError! ")
                           'font-lock-face 'magit-section-heading))
       (insert (propertize magit-this-error 'font-lock-face 'error))
-      (when-let ((key (car (where-is-internal 'magit-process-buffer))))
+      (when-let ((_ magit-show-process-buffer-hint)
+                 (key (car (where-is-internal 'magit-process-buffer))))
         (insert (format "  [Type `%s' for details]" (key-description key))))
       (insert ?\n))
     (setq magit-this-error nil)))
@@ -609,35 +619,34 @@ arguments are for internal use only."
             (_       (setq rebase (magit-get-boolean "pull.rebase"))))
           (insert (format "%-10s" (or keyword (if rebase "Rebase: " "Merge: "))))
           (insert
-           (if upstream
-               (concat (and magit-status-show-hashes-in-headers
-                            (concat (propertize (magit-rev-format "%h" upstream)
-                                                'font-lock-face 'magit-hash)
-                                    " "))
-                       upstream " "
-                       (magit-log--wash-summary
-                        (or (magit-rev-format "%s" upstream)
-                            "(no commit message)")))
-             (cond
-              ((magit--unnamed-upstream-p remote merge)
-               (concat (propertize merge  'font-lock-face 'magit-branch-remote)
-                       " from "
-                       (propertize remote 'font-lock-face 'bold)))
-              ((magit--valid-upstream-p remote merge)
-               (if (equal remote ".")
-                   (concat
-                    (propertize merge 'font-lock-face 'magit-branch-local) " "
-                    (propertize "does not exist"
-                                'font-lock-face 'magit-branch-warning))
-                 (format
-                  "%s %s %s"
-                  (propertize merge 'font-lock-face 'magit-branch-remote)
-                  (propertize "does not exist on"
-                              'font-lock-face 'magit-branch-warning)
-                  (propertize remote 'font-lock-face 'magit-branch-remote))))
-              (t
-               (propertize "invalid upstream configuration"
-                           'font-lock-face 'magit-branch-warning)))))
+           (cond
+            (upstream
+             (concat (and magit-status-show-hashes-in-headers
+                          (concat (propertize (magit-rev-format "%h" upstream)
+                                              'font-lock-face 'magit-hash)
+                                  " "))
+                     upstream " "
+                     (magit-log--wash-summary
+                      (or (magit-rev-format "%s" upstream)
+                          "(no commit message)"))))
+            ((magit--unnamed-upstream-p remote merge)
+             (concat (propertize merge  'font-lock-face 'magit-branch-remote)
+                     " from "
+                     (propertize remote 'font-lock-face 'bold)))
+            ((magit--valid-upstream-p remote merge)
+             (if (equal remote ".")
+                 (concat
+                  (propertize merge 'font-lock-face 'magit-branch-local) " "
+                  (propertize "does not exist"
+                              'font-lock-face 'magit-branch-warning))
+               (format
+                "%s %s %s"
+                (propertize merge 'font-lock-face 'magit-branch-remote)
+                (propertize "does not exist on"
+                            'font-lock-face 'magit-branch-warning)
+                (propertize remote 'font-lock-face 'magit-branch-remote))))
+            ((propertize "invalid upstream configuration"
+                         'font-lock-face 'magit-branch-warning))))
           (insert ?\n))))))
 
 (defun magit-insert-push-branch-header ()
@@ -647,22 +656,24 @@ arguments are for internal use only."
     (magit-insert-section (branch target)
       (insert (format "%-10s" "Push: "))
       (insert
-       (if (magit-rev-verify target)
-           (concat (and magit-status-show-hashes-in-headers
-                        (concat (propertize (magit-rev-format "%h" target)
-                                            'font-lock-face 'magit-hash)
-                                " "))
-                   target " "
-                   (magit-log--wash-summary (or (magit-rev-format "%s" target)
-                                                "(no commit message)")))
-         (let ((remote (magit-get-push-remote branch)))
-           (if (magit-remote-p remote)
-               (concat target " "
-                       (propertize "does not exist"
-                                   'font-lock-face 'magit-branch-warning))
-             (concat remote " "
-                     (propertize "remote does not exist"
-                                 'font-lock-face 'magit-branch-warning))))))
+       (cond-let
+         ((magit-rev-verify target)
+          (concat (and magit-status-show-hashes-in-headers
+                       (concat (propertize (magit-rev-format "%h" target)
+                                           'font-lock-face 'magit-hash)
+                               " "))
+                  target " "
+                  (magit-log--wash-summary
+                   (or (magit-rev-format "%s" target)
+                       "(no commit message)"))))
+         [[remote (magit-get-push-remote branch)]]
+         ((magit-remote-p remote)
+          (concat target " "
+                  (propertize "does not exist"
+                              'font-lock-face 'magit-branch-warning)))
+         ((concat remote " "
+                  (propertize "remote does not exist"
+                              'font-lock-face 'magit-branch-warning)))))
       (insert ?\n))))
 
 (defun magit-insert-tags-header ()
@@ -748,31 +759,14 @@ remote in alphabetic order."
   magit-insert-assume-unchanged-files)
 
 (defun magit-insert-untracked-files ()
-  "Maybe insert list of untracked files.
+  "Maybe insert a list of untracked files.
 
 List files if `magit-status-show-untracked-files' is non-nil, but also
 take the local value of Git variable `status.showUntrackedFiles' into
 account.  The local value of the Lisp variable takes precedence over the
 local value of the Git variable.  The global value of the Git variable
 is always ignored."
-  (when-let*
-      ((value (or (and (local-variable-p 'magit-status-show-untracked-files)
-                       magit-status-show-untracked-files)
-                  (pcase (magit-get "--local" "status.showUntrackedFiles")
-                    ((or "no" "off" "false" "0") 'no)
-                    ((or "yes" "on" "true" "1") t)
-                    ("all" 'all))
-                  magit-status-show-untracked-files))
-       ((not (eq value 'no))))
-    (magit-insert-files
-     'untracked
-     (lambda (files)
-       (mapcan (##and (eq (aref % 0) ??)
-                      (list (substring % 3)))
-               (apply #'magit-git-items "status" "-z" "--porcelain"
-                      (format "--untracked-files=%s"
-                              (if (eq value 'all) "all" "normal"))
-                      "--" files))))))
+  (magit-insert-files 'untracked #'magit-list-untracked-files))
 
 (defun magit-insert-tracked-files ()
   "Insert a list of tracked files.
@@ -824,4 +818,15 @@ Honor the buffer's file filter, which can be set using \"D - -\"."
 
 ;;; _
 (provide 'magit-status)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-status.el ends here
diff --git a/elpa/magit-20250519.1537/magit-submodule.el b/elpa/magit-20251103.1130/magit-submodule.el
similarity index 96%
rename from elpa/magit-20250519.1537/magit-submodule.el
rename to elpa/magit-20251103.1130/magit-submodule.el
index 9d2b3368..0c0a4d6a 100644
--- a/elpa/magit-20250519.1537/magit-submodule.el
+++ b/elpa/magit-20251103.1130/magit-submodule.el
@@ -230,7 +230,7 @@ it is nil, then PATH also becomes the name."
    (file-relative-name
     (read-directory-name prompt nil nil nil
                          (and (string-match "\\([^./]+\\)\\(\\.git\\)?$" url)
-                              (match-string 1 url))))))
+                              (match-str 1 url))))))
 
 (defun magit-submodule-add-1 (url &optional path name args)
   (magit-with-toplevel
@@ -498,13 +498,14 @@ or, failing that, the abbreviated HEAD commit hash."
                 (if-let ((branch (magit-get-current-branch)))
                     (propertize branch 'font-lock-face 'magit-branch-local)
                   (propertize "(detached)" 'font-lock-face 'warning))))
-              (if-let ((desc (magit-git-string "describe" "--tags")))
-                  (progn (when (and magit-modules-overview-align-numbers
-                                    (string-match-p "\\`[0-9]" desc))
-                           (insert ?\s))
-                         (insert (propertize desc 'font-lock-face 'magit-tag)))
-                (when-let ((abbrev (magit-rev-format "%h")))
-                  (insert (propertize abbrev 'font-lock-face 'magit-hash)))))
+              (cond-let
+                ([desc (magit-git-string "describe" "--tags")]
+                 (when (and magit-modules-overview-align-numbers
+                            (string-match-p "\\`[0-9]" desc))
+                   (insert ?\s))
+                 (insert (propertize desc 'font-lock-face 'magit-tag)))
+                ([abbrev (magit-rev-format "%h")]
+                 (insert (propertize abbrev 'font-lock-face 'magit-hash)))))
             (insert ?\n))))))
   (insert ?\n))
 
@@ -587,24 +588,24 @@ These sections can be expanded to show the respective commits."
 
 (defun magit--insert-modules-logs (heading type range)
   "For internal use, don't add to a hook."
-  (when-let (((not (magit-ignore-submodules-p)))
+  (when-let ((_(not (magit-ignore-submodules-p)))
              (modules (magit-list-module-paths)))
     (magit-insert-section ((eval type) nil t)
       (string-match "\\`\\(.+\\) \\([^ ]+\\)\\'" heading)
       (magit-insert-heading
-        (propertize (match-string 1 heading)
+        (propertize (match-str 1 heading)
                     'font-lock-face 'magit-section-heading)
         " "
-        (propertize (match-string 2 heading)
+        (propertize (match-str 2 heading)
                     'font-lock-face 'magit-branch-remote)
         ":")
       (dolist (module modules)
         (when-let* ((default-directory (expand-file-name module))
-                    ((file-exists-p (expand-file-name ".git")))
+                    (_(file-exists-p (expand-file-name ".git")))
                     (lines (magit-git-lines "-c" "push.default=current"
                                             "log" "--oneline" range))
                     (count (length lines))
-                    ((> count 0)))
+                    (_(> count 0)))
           (magit-insert-section
               ( module module t
                 :range range)
@@ -612,8 +613,8 @@ These sections can be expanded to show the respective commits."
               (propertize module 'font-lock-face 'magit-diff-file-heading))
             (dolist (line lines)
               (string-match magit-log-module-re line)
-              (let ((rev (match-string 1 line))
-                    (msg (match-string 2 line)))
+              (let ((rev (match-str 1 line))
+                    (msg (match-str 2 line)))
                 (magit-insert-section (module-commit rev t)
                   (insert (propertize rev 'font-lock-face 'magit-hash) " "
                           (magit-log--wash-summary msg) "\n")))))))
@@ -713,4 +714,15 @@ These sections can be expanded to show the respective commits."
 
 ;;; _
 (provide 'magit-submodule)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-submodule.el ends here
diff --git a/elpa/magit-20250519.1537/magit-subtree.el b/elpa/magit-20251103.1130/magit-subtree.el
similarity index 94%
rename from elpa/magit-20250519.1537/magit-subtree.el
rename to elpa/magit-20251103.1130/magit-subtree.el
index b771a23e..5f2bf3c5 100644
--- a/elpa/magit-20250519.1537/magit-subtree.el
+++ b/elpa/magit-20251103.1130/magit-subtree.el
@@ -184,4 +184,15 @@
 
 ;;; _
 (provide 'magit-subtree)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-subtree.el ends here
diff --git a/elpa/magit-20250519.1537/magit-tag.el b/elpa/magit-20251103.1130/magit-tag.el
similarity index 89%
rename from elpa/magit-20250519.1537/magit-tag.el
rename to elpa/magit-20251103.1130/magit-tag.el
index 78c87b27..b73b29b7 100644
--- a/elpa/magit-20250519.1537/magit-tag.el
+++ b/elpa/magit-20251103.1130/magit-tag.el
@@ -62,17 +62,17 @@
   :history-key 'magit:--gpg-sign)
 
 ;;;###autoload
-(defun magit-tag-create (name rev &optional args)
-  "Create a new tag with the given NAME at REV.
+(defun magit-tag-create (name commit &optional args)
+  "Create a new tag with the given NAME at COMMIT.
 With a prefix argument annotate the tag.
 \n(git tag [--annotate] NAME REV)"
-  (interactive (list (magit-read-tag "Tag name")
+  (interactive (list (magit-completing-read "Create tag" (magit-list-tags))
                      (magit-read-branch-or-commit "Place tag on")
                      (let ((args (magit-tag-arguments)))
                        (when current-prefix-arg
                          (cl-pushnew "--annotate" args :test #'equal))
                        args)))
-  (magit-run-git-with-editor "tag" args name rev))
+  (magit-run-git-with-editor "tag" args name commit))
 
 ;;;###autoload
 (defun magit-tag-delete (tags)
@@ -84,7 +84,7 @@ defaulting to the tag at point.
   (interactive (list (if-let ((tags (magit-region-values 'tag)))
                          (magit-confirm t nil "Delete %d tags" nil tags)
                        (let ((helm-comp-read-use-marked t))
-                         (magit-read-tag "Delete tag" t)))))
+                         (magit-read-tag "Delete tag")))))
   (magit-run-git "tag" "-d" tags))
 
 ;;;###autoload
@@ -128,7 +128,7 @@ defaulting to the tag at point.
 See also `magit-release-tag-regexp'.")
 
 (defvar magit-release-tag-regexp "\\`\
-\\(?1:\\(?:v\\(?:ersion\\)?\\|r\\(?:elease\\)?\\)[-_]?\\)?\
+\\(?1:\\(?:v\\(?:ersion\\)?\\|r\\(?:elease\\)?\\)[-_/]?\\)?\
 \\(?2:[0-9]+\\(?:\\.[0-9]+\\)*\
 \\(?:-[a-zA-Z0-9-]+\\(?:\\.[a-zA-Z0-9-]+\\)*\\)?\\)\\'"
   "Regexp used by `magit-tag-release' to parse release tags.
@@ -167,7 +167,7 @@ that is not the case, propose a message using a reasonable format."
           (`(,pver ,ptag ,pmsg) (car (magit--list-releases)))
           (msg (magit-rev-format "%s"))
           (ver (and (string-match magit-release-commit-regexp msg)
-                    (match-string 1 msg)))
+                    (match-str 1 msg)))
           (_   (and (not ver)
                     (require (quote sisyphus) nil t)
                     (string-match magit-release-commit-regexp
@@ -185,14 +185,13 @@ that is not the case, propose a message using a reasonable format."
                                 ver)))
                 (ver
                  (concat (and (string-match magit-release-tag-regexp ptag)
-                              (match-string 1 ptag))
+                              (match-str 1 ptag))
                          ver))
-                (t
-                 (read-string
-                  (format "Create release tag (previous was %s): " ptag)
-                  ptag))))
+                ((read-string (format "Create release tag (previous was %s): "
+                                      ptag)
+                              ptag))))
           (ver (and (string-match magit-release-tag-regexp tag)
-                    (match-string 2 tag))))
+                    (match-str 2 tag))))
        (list tag
              (and (seq-some (apply-partially
                              #'string-match-p
@@ -232,7 +231,7 @@ a tag qualifies as a release tag."
                        (let ((tag (substring line 0 (match-beginning 0)))
                              (msg (substring line (match-end 0))))
                          (and (string-match magit-release-tag-regexp tag)
-                              (let ((ver (match-string 2 tag))
+                              (let ((ver (match-str 2 tag))
                                     (version-regexp-alist
                                      magit-tag-version-regexp-alist))
                                 (list (list (version-to-list ver)
@@ -245,4 +244,15 @@ a tag qualifies as a release tag."
 
 ;;; _
 (provide 'magit-tag)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-tag.el ends here
diff --git a/elpa/magit-20250519.1537/magit-transient.el b/elpa/magit-20251103.1130/magit-transient.el
similarity index 78%
rename from elpa/magit-20250519.1537/magit-transient.el
rename to elpa/magit-20251103.1130/magit-transient.el
index 7ebd10cd..7cafc54b 100644
--- a/elpa/magit-20250519.1537/magit-transient.el
+++ b/elpa/magit-20251103.1130/magit-transient.el
@@ -68,8 +68,7 @@
     (oset obj value
           (cond ((oref obj multi-value)
                  (magit-get-all arg variable))
-                (t
-                 (magit-get arg variable))))))
+                ((magit-get arg variable))))))
 
 (cl-defmethod transient-init-value ((obj magit--git-variable:boolean))
   (let ((variable (format (oref obj variable)
@@ -93,18 +92,19 @@
   (let ((choices (oref obj choices)))
     (when (functionp choices)
       (setq choices (funcall choices)))
-    (if current-prefix-arg
-        (pcase-let*
-            ((`(,fallback . ,choices)
-              (magit--git-variable-list-choices obj))
-             (choice (magit-completing-read
-                      (format "Set `%s' to" (oref obj variable))
-                      (if fallback (nconc choices (list fallback)) choices)
-                      nil t)))
-          (if (equal choice fallback) nil choice))
-      (if-let ((value (oref obj value)))
-          (cadr (member value choices))
-        (car choices)))))
+    (cond-let
+      (current-prefix-arg
+       (pcase-let*
+           ((`(,fallback . ,choices)
+             (magit--git-variable-list-choices obj))
+            (choice (magit-completing-read
+                     (format "Set `%s' to" (oref obj variable))
+                     (if fallback (nconc choices (list fallback)) choices)
+                     nil t)))
+         (if (equal choice fallback) nil choice)))
+      ([value (oref obj value)]
+       (cadr (member value choices)))
+      ((car choices)))))
 
 ;;;; Readers
 
@@ -118,11 +118,10 @@
    nil nil initial-input history))
 
 (defun magit-transient-read-revision (prompt initial-input history)
-  (or (magit-completing-read prompt (cons "HEAD" (magit-list-refnames))
-                             nil nil initial-input history
-                             (or (magit-branch-or-commit-at-point)
-                                 (magit-get-current-branch)))
-      (user-error "Nothing selected")))
+  (magit-completing-read prompt (cons "HEAD" (magit-list-refnames))
+                         nil 'any initial-input history
+                         (or (magit-branch-or-commit-at-point)
+                             (magit-get-current-branch))))
 
 ;;;; Set
 
@@ -156,20 +155,21 @@
       (oref obj variable)))
 
 (cl-defmethod transient-format-value ((obj magit--git-variable))
-  (if-let ((value (oref obj value)))
-      (if (oref obj multi-value)
-          (if (cdr value)
-              (mapconcat (##concat "\n     "
-                                   (propertize % 'face 'transient-value))
-                         value "")
-            (propertize (car value) 'face 'transient-value))
-        (propertize (car (split-string value "\n"))
-                    'face 'transient-value))
-    (if-let* ((default (oref obj default))
-              (default (if (functionp default) (funcall default) default)))
-        (concat (propertize "default:" 'face 'transient-inactive-value)
-                (propertize default 'face 'transient-value))
-      (propertize "unset" 'face 'transient-inactive-value))))
+  (cond-let*
+    ([value (oref obj value)]
+     (if (oref obj multi-value)
+         (if (cdr value)
+             (mapconcat (##concat "\n     "
+                                  (propertize % 'face 'transient-value))
+                        value "")
+           (propertize (car value) 'face 'transient-value))
+       (propertize (car (split-string value "\n"))
+                   'face 'transient-value)))
+    ([default (oref obj default)]
+     [default (if (functionp default) (funcall default) default)]
+     (concat (propertize "default:" 'face 'transient-inactive-value)
+             (propertize default 'face 'transient-value)))
+    ((propertize "unset" 'face 'transient-inactive-value))))
 
 (cl-defmethod transient-format-value ((obj magit--git-variable:choices))
   (pcase-let ((`(,fallback . ,choices) (magit--git-variable-list-choices obj)))
@@ -191,8 +191,8 @@
          (default  (if (functionp defaultp) (funcall defaultp obj) defaultp))
          (fallback (oref obj fallback))
          (fallback (and fallback
-                        (and-let* ((val (magit-get fallback)))
-                          (concat fallback ":" val)))))
+                        (and$ (magit-get fallback)
+                              (concat fallback ":" $)))))
     (if (not globalp)
         (setq value (magit-git-string "config" "--local"  variable))
       (setq value global)
@@ -205,8 +205,7 @@
                                           'transient-inactive-value)
                                          ((member global choices)
                                           'transient-value)
-                                         (t
-                                          'font-lock-warning-face))))
+                                         ('font-lock-warning-face))))
                 (fallback
                  (propertize fallback
                              'face (if value
@@ -229,15 +228,17 @@
                       (cons value choices)
                     choices)))))
 
-;;; Utilities
-
-(defun magit--transient-args-and-files ()
-  "Return (args files) for use by log and diff functions.
-The value derives from that returned by `transient-get-value'."
-  (let ((args (transient-get-value)))
-    (list (seq-filter #'atom args)
-          (cdr (assoc "--" args)))))
-
 ;;; _
 (provide 'magit-transient)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-transient.el ends here
diff --git a/elpa/magit-20250519.1537/magit-wip.el b/elpa/magit-20251103.1130/magit-wip.el
similarity index 85%
rename from elpa/magit-20250519.1537/magit-wip.el
rename to elpa/magit-20251103.1130/magit-wip.el
index 712b7845..b42fdd36 100644
--- a/elpa/magit-20250519.1537/magit-wip.el
+++ b/elpa/magit-20251103.1130/magit-wip.el
@@ -22,7 +22,7 @@
 
 ;;; Commentary:
 
-;; This library defines tree global modes which automatically commit
+;; This library defines global modes which automatically commit
 ;; snapshots to branch-specific work-in-progress refs before and after
 ;; making changes, and two commands which can be used to do so on
 ;; demand.
@@ -117,30 +117,33 @@ variant `magit-wip-after-save-mode'."
     (remove-hook 'after-save-hook #'magit-wip-commit-buffer-file t)))
 
 (defun magit-wip-after-save-local-mode-turn-on ()
-  (when (and buffer-file-name
-             (if magit--wip-activation-cache
-                 (if-let ((elt (assoc default-directory
-                                      magit--wip-activation-cache)))
-                     (and-let* ((top (cadr elt)))
-                       (member (file-relative-name buffer-file-name top)
-                               (cddr elt)))
-                   (if-let ((top (magit-toplevel)))
-                       (let (files)
-                         (if-let ((elt (assoc top magit--wip-activation-cache)))
-                             (setq files (cddr elt))
-                           (setq files (let ((default-directory top))
-                                         (magit-tracked-files)))
-                           (push `(,top ,top ,@files)
-                                 magit--wip-activation-cache)
-                           (unless (eq default-directory top)
-                             (push `(,default-directory ,top ,@files)
-                                   magit--wip-activation-cache)))
-                         (member (file-relative-name buffer-file-name) files))
-                     (push (list default-directory nil)
-                           magit--wip-activation-cache)
-                     nil))
-               (and (magit-inside-worktree-p t)
-                    (magit-file-tracked-p buffer-file-name))))
+  (when (cond-let
+          ((not buffer-file-name)
+           nil)
+          ((not magit--wip-activation-cache)
+           (and (magit-inside-worktree-p t)
+                (magit-file-tracked-p buffer-file-name)))
+          ([elt (assoc default-directory
+                       magit--wip-activation-cache)]
+           (and-let ((top (cadr elt)))
+             (member (file-relative-name buffer-file-name top)
+                     (cddr elt))))
+          ([top (magit-toplevel)]
+           (let (files)
+             (if-let ((elt (assoc top magit--wip-activation-cache)))
+                 (setq files (cddr elt))
+               (setq files (let ((default-directory top))
+                             (magit-tracked-files)))
+               (push `(,top ,top ,@files)
+                     magit--wip-activation-cache)
+               (unless (eq default-directory top)
+                 (push `(,default-directory ,top ,@files)
+                       magit--wip-activation-cache)))
+             (member (file-relative-name buffer-file-name) files)))
+          (t
+           (push (list default-directory nil)
+                 magit--wip-activation-cache)
+           nil))
     (magit-wip-after-save-local-mode)))
 
 ;;;###autoload
@@ -155,7 +158,7 @@ variant `magit-wip-after-save-mode'."
 Also see `magit-wip-after-save-mode' which calls this function
 automatically whenever a buffer visiting a tracked file is saved."
   (interactive (list "wip-save %s after save"))
-  (when-let (((not magit--wip-inhibit-autosave))
+  (when-let ((_(not magit--wip-inhibit-autosave))
              (ref (magit-wip-get-ref)))
     (magit-with-toplevel
       (let ((file (file-relative-name buffer-file-name)))
@@ -352,24 +355,16 @@ commit message."
 (defun magit--wip-ref (namespace &optional ref)
   (concat magit-wip-namespace namespace
           (or (and ref (string-prefix-p "refs/" ref) ref)
-              (and-let* ((branch (and (not (equal ref "HEAD"))
-                                      (or ref (magit-get-current-branch)))))
+              (and-let ((_(not (equal ref "HEAD")))
+                        (branch (or ref (magit-get-current-branch))))
                 (concat "refs/heads/" branch))
               "HEAD")))
 
 (defun magit-wip-maybe-add-commit-hook ()
   (when (and magit-wip-merge-branch
-             (magit-wip-any-enabled-p))
+             (magit--any-wip-mode-enabled-p))
     (add-hook 'git-commit-post-finish-hook #'magit-wip-commit nil t)))
 
-(defun magit-wip-any-enabled-p ()
-  (or magit-wip-mode
-      magit-wip-after-save-local-mode
-      magit-wip-after-save-mode
-      magit-wip-after-apply-mode
-      magit-wip-before-change-mode
-      magit-wip-initial-backup-mode))
-
 ;;; Log
 
 (defun magit-wip-log-index (args files)
@@ -420,7 +415,7 @@ many \"branches\" of each wip ref are shown."
                           args files))
 
 (defun magit-wip-log-get-tips (wipref count)
-  (and-let* ((reflog (magit-git-lines "reflog" wipref)))
+  (and-let ((reflog (magit-git-lines "reflog" wipref)))
     (let (tips)
       (while (and reflog (> count 1))
         ;; "start autosaving ..." is the current message, but it used
@@ -430,7 +425,7 @@ many \"branches\" of each wip ref are shown."
                                 reflog :test #'string-match-p))
         (when (and (cadr reflog)
                    (string-match "^[^ ]+ \\([^:]+\\)" (cadr reflog)))
-          (push (match-string 1 (cadr reflog)) tips))
+          (push (match-str 1 (cadr reflog)) tips))
         (setq reflog (cddr reflog))
         (cl-decf count))
       (cons wipref (nreverse tips)))))
@@ -438,24 +433,35 @@ many \"branches\" of each wip ref are shown."
 (defun magit-wip-purge ()
   "Ask to delete all wip-refs that no longer have a corresponding ref."
   (interactive)
-  (if-let ((wiprefs (thread-last
-                      (cl-set-difference (magit-list-refs "refs/wip/")
-                                         (magit-list-refs)
-                                         :test (##equal (substring %1 15) %2))
-                      (delete "refs/wip/index/HEAD")
-                      (delete "refs/wip/wtree/HEAD"))))
-      (progn
-        (magit-confirm 'purge-dangling-wiprefs
-          "Delete wip-ref %s without corresponding ref"
-          "Delete %d wip-refs without corresponding ref"
-          nil wiprefs)
-        (message "Deleting wip-refs...")
-        (dolist (wipref wiprefs)
-          (magit-call-git "update-ref" "-d" wipref))
-        (message "Deleting wip-refs...done")
-        (magit-refresh))
-    (message "All wip-refs have a corresponding ref")))
+  (cond-let
+    ([wiprefs (thread-last
+                (cl-set-difference (magit-list-refs "refs/wip/")
+                                   (magit-list-refs)
+                                   :test (##equal (substring %1 15) %2))
+                (delete "refs/wip/index/HEAD")
+                (delete "refs/wip/wtree/HEAD"))]
+     (magit-confirm 'purge-dangling-wiprefs
+       "Delete wip-ref %s without corresponding ref"
+       "Delete %d wip-refs without corresponding ref"
+       nil wiprefs)
+     (message "Deleting wip-refs...")
+     (dolist (wipref wiprefs)
+       (magit-call-git "update-ref" "-d" wipref))
+     (message "Deleting wip-refs...done")
+     (magit-refresh))
+    ((message "All wip-refs have a corresponding ref"))))
 
 ;;; _
 (provide 'magit-wip)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-wip.el ends here
diff --git a/elpa/magit-20250519.1537/magit-worktree.el b/elpa/magit-20251103.1130/magit-worktree.el
similarity index 51%
rename from elpa/magit-20250519.1537/magit-worktree.el
rename to elpa/magit-20251103.1130/magit-worktree.el
index f38cad52..085f99b7 100644
--- a/elpa/magit-20250519.1537/magit-worktree.el
+++ b/elpa/magit-20251103.1130/magit-worktree.el
@@ -30,14 +30,98 @@
 
 ;;; Options
 
-(defcustom magit-worktree-read-directory-name-function #'read-directory-name
-  "Function used to read a directory for worktree commands.
-This is called with one argument, the prompt, and can be used
-to, e.g., use a base directory other than `default-directory'.
-Used by `magit-worktree-checkout' and `magit-worktree-branch'."
-  :package-version '(magit . "3.0.0")
+(defcustom magit-read-worktree-directory-function
+  #'magit-read-worktree-directory-sibling
+  "Function used to read the directory to be used as a new worktree.
+This is called with two arguments, the prompt and the branch to be
+checked out.  When not checking out a branch then use nil for the
+second argument."
+  :package-version '(magit . "4.4.0")
   :group 'magit-commands
-  :type 'function)
+  :type `(radio (function-item ,#'magit-read-worktree-directory)
+                (function-item ,#'magit-read-worktree-directory-nested)
+                (function-item ,#'magit-read-worktree-directory-sibling)
+                (function-item ,#'magit-read-worktree-directory-offsite)
+                function))
+
+(defcustom magit-read-worktree-offsite-directory
+  (expand-file-name "wtrees/" (or (getenv "XDG_DATA_HOME") "~/.local/share"))
+  "Base directory used by `magit-read-worktree-directory-offsite'.
+That function is suitable as `magit-read-worktree-directory-function',
+but is not used by default."
+  :package-version '(magit . "4.4.0")
+  :group 'magit-commands
+  :type 'directory)
+
+(defvar magit-worktree-read-directory-name-function nil
+  "Like `magit-read-worktree-directory-function' but takes only one argument.")
+(make-obsolete-variable 'magit-worktree-read-directory-name-function
+                        'magit-read-worktree-directory-function
+                        "Magit 4.4.0")
+
+;;; Functions
+
+(defun magit-read-worktree-directory (prompt _branch)
+  "Call `read-directory-name' with PROMPT, but ignoring _BRANCH."
+  (read-directory-name prompt))
+
+(defun magit-read-worktree-directory-nested (prompt branch)
+  "Call `read-directory-name' in current worktree.
+For `read-directory-name's INITIAL argument use a string based on
+BRANCH, replacing slashes with dashes.  If BRANCH is nil, use nil
+as INITIAL.  Always forward PROMPT as-is."
+  (read-directory-name prompt nil nil nil
+                       (and branch (string-replace "/" "-" branch))))
+
+(defun magit-read-worktree-directory-sibling (prompt branch)
+  "Call `read-directory-name' in parent directory of current worktree.
+For `read-directory-name's INITIAL argument use a string based on the
+name of the current worktree and BRANCH.  Use \"PREFIX_BRANCH\" where
+PREFIX is the name of the current worktree, up to the first underscore,
+and slashes in BRANCH are replaced with dashes.  If BRANCH is nil use
+just \"PREFIX_\".  Always forward PROMPT as-is."
+  (let* ((path (directory-file-name default-directory))
+         (name (file-name-nondirectory path)))
+    (read-directory-name
+     prompt (file-name-directory path) nil nil
+     (concat (if (string-match "_" name)
+                 (substring name 0 (match-beginning 0))
+               name)
+             "_"
+             (and branch (string-replace "/" "-" branch))))))
+
+(defun magit-read-worktree-directory-offsite (prompt branch)
+  "Call `read-directory-name' in a directory shared by all repositories.
+
+Option `magit-read-worktree-offsite-directory' specifies that shared
+base directory.
+
+For `read-directory-name's INITIAL argument use a string based on the
+name of the current worktree and BRANCH.  Use \"PREFIX_BRANCH\" where
+PREFIX is the name of the current worktree, up to the first underscore,
+and slashes in BRANCH are replaced with dashes.  If BRANCH is nil use
+just \"PREFIX_\".  Always forward PROMPT as-is."
+  (mkdir magit-read-worktree-offsite-directory t)
+  (read-directory-name
+   prompt magit-read-worktree-offsite-directory nil nil
+   (let* ((name (file-name-nondirectory (directory-file-name default-directory)))
+          (name (if (string-match "_" name)
+                    (substring name 0 (match-beginning 0))
+                  name))
+          (name (concat name "_")))
+     (if branch
+         (concat name (string-replace "/" "-" branch))
+       (file-name-nondirectory
+        (make-temp-name
+         (expand-file-name name magit-read-worktree-offsite-directory)))))))
+
+(defun magit--read-worktree-directory (rev branchp)
+  (let ((default-directory (magit-toplevel))
+        (prompt (format "Checkout %s in new worktree: " rev)))
+    (if magit-worktree-read-directory-name-function
+        (funcall magit-worktree-read-directory-name-function prompt)
+      (funcall magit-read-worktree-directory-function
+               prompt (and branchp rev)))))
 
 ;;; Commands
 
@@ -54,51 +138,56 @@ Used by `magit-worktree-checkout' and `magit-worktree-branch'."
     ("g" "Visit worktree"        magit-worktree-status)]])
 
 ;;;###autoload
-(defun magit-worktree-checkout (path branch)
-  "Checkout BRANCH in a new worktree at PATH."
+(defun magit-worktree-checkout (directory commit)
+  "Checkout COMMIT in a new worktree in DIRECTORY.
+COMMIT may, but does not have to be, a local branch.
+Interactively, use `magit-read-worktree-directory-function'."
   (interactive
-   (let ((branch (magit-read-branch-or-commit "Checkout")))
-     (list (funcall magit-worktree-read-directory-name-function
-                    (format "Checkout %s in new worktree: " branch))
-           branch)))
+   (let ((commit (magit-read-branch-or-commit
+                  "In new worktree; checkout" nil
+                  (mapcar #'caddr (magit-list-worktrees)))))
+     (list (magit--read-worktree-directory commit (magit-local-branch-p commit))
+           commit)))
   (when (zerop (magit-run-git "worktree" "add"
-                              (magit--expand-worktree path) branch))
-    (magit-diff-visit-directory path)))
+                              (magit--expand-worktree directory) commit))
+    (magit-diff-visit-directory directory)))
 
 ;;;###autoload
-(defun magit-worktree-branch (path branch start-point)
-  "Create a new BRANCH and check it out in a new worktree at PATH."
+(defun magit-worktree-branch (directory branch start-point)
+  "Create a new BRANCH and check it out in a new worktree at DIRECTORY.
+Interactively, use `magit-read-worktree-directory-function'."
   (interactive
-   `(,(funcall magit-worktree-read-directory-name-function
-               "Create worktree: ")
-     ,@(magit-branch-read-args "Create and checkout branch")))
+   (pcase-let
+       ((`(,branch ,start-point)
+         (magit-branch-read-args "In new worktree; checkout new branch")))
+     (list (magit--read-worktree-directory branch t)
+           branch start-point)))
   (when (zerop (magit-run-git "worktree" "add" "-b" branch
-                              (magit--expand-worktree path) start-point))
-    (magit-diff-visit-directory path)))
+                              (magit--expand-worktree directory) start-point))
+    (magit-diff-visit-directory directory)))
 
 ;;;###autoload
-(defun magit-worktree-move (worktree path)
-  "Move WORKTREE to PATH."
+(defun magit-worktree-move (worktree directory)
+  "Move existing WORKTREE directory to DIRECTORY."
   (interactive
    (list (magit-completing-read "Move worktree"
                                 (cdr (magit-list-worktrees))
                                 nil t nil nil
                                 (magit-section-value-if 'worktree))
-         (funcall magit-worktree-read-directory-name-function
-                  "Move worktree to: ")))
+         (read-directory-name "Move worktree to: ")))
   (if (file-directory-p (expand-file-name ".git" worktree))
       (user-error "You may not move the main working tree")
-    (let ((preexisting-directory (file-directory-p path)))
+    (let ((preexisting-directory (file-directory-p directory)))
       (when (and (zerop (magit-call-git "worktree" "move" worktree
-                                        (magit--expand-worktree path)))
+                                        (magit--expand-worktree directory)))
                  (not (file-exists-p default-directory))
                  (derived-mode-p 'magit-status-mode))
         (kill-buffer)
         (magit-diff-visit-directory
          (if preexisting-directory
-             (concat (file-name-as-directory path)
+             (concat (file-name-as-directory directory)
                      (file-name-nondirectory worktree))
-           path)))
+           directory)))
       (magit-refresh))))
 
 (defun magit-worktree-delete (worktree)
@@ -106,7 +195,7 @@ Used by `magit-worktree-checkout' and `magit-worktree-branch'."
 The primary worktree cannot be deleted."
   (interactive
    (list (magit-completing-read "Delete worktree"
-                                (cdr (magit-list-worktrees))
+                                (mapcar #'car (cdr (magit-list-worktrees)))
                                 nil t nil nil
                                 (magit-section-value-if 'worktree))))
   (if (file-directory-p (expand-file-name ".git" worktree))
@@ -137,11 +226,12 @@ then show it in Dired instead."
               "Show status for worktree"
               (cl-delete (directory-file-name (magit-toplevel))
                          (magit-list-worktrees)
-                         :test #'equal :key #'car)))))
+                         :test #'equal :key #'car)
+              nil t))))
   (magit-diff-visit-directory worktree))
 
-(defun magit--expand-worktree (path)
-  (magit-convert-filename-for-git (expand-file-name path)))
+(defun magit--expand-worktree (directory)
+  (magit-convert-filename-for-git (expand-file-name directory)))
 
 ;;; Sections
 
@@ -204,4 +294,15 @@ with padding for alignment."
 
 ;;; _
 (provide 'magit-worktree)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-worktree.el ends here
diff --git a/elpa/magit-20250519.1537/magit.el b/elpa/magit-20251103.1130/magit.el
similarity index 89%
rename from elpa/magit-20250519.1537/magit.el
rename to elpa/magit-20251103.1130/magit.el
index 3eb52650..189672b3 100644
--- a/elpa/magit-20250519.1537/magit.el
+++ b/elpa/magit-20251103.1130/magit.el
@@ -17,16 +17,17 @@
 ;; Homepage: https://github.com/magit/magit
 ;; Keywords: git tools vc
 
-;; Package-Version: 20250519.1537
-;; Package-Revision: 9b81df36b4eb
+;; Package-Version: 20251103.1130
+;; Package-Revision: 84c5c8c8c610
 ;; Package-Requires: (
-;;     (emacs "27.1")
-;;     (compat "30.1.0.0")
-;;     (llama "0.6.2")
-;;     (magit-section "4.3.5")
-;;     (seq "2.24")
-;;     (transient "0.8.8")
-;;     (with-editor "3.4.3"))
+;;     (emacs        "28.1")
+;;     (compat       "30.1")
+;;     (cond-let      "0.1")
+;;     (llama         "1.0")
+;;     (magit-section "4.4")
+;;     (seq           "2.24")
+;;     (transient     "0.10")
+;;     (with-editor   "3.4"))
 
 ;; SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -69,15 +70,10 @@
 (require 'magit-repos)
 (require 'git-commit)
 
+(require 'epa) ;used in magit-read-gpg-{secret,signing}-key
 (require 'format-spec)
-(require 'package nil t) ; used in `magit-version'
 (require 'with-editor)
 
-;; For `magit:--gpg-sign'
-(declare-function epg-list-keys "epg" (context &optional name mode))
-(declare-function epg-decode-dn "epg" (alist))
-(defvar epa-protocol)
-
 ;;; Options
 
 (defcustom magit-openpgp-default-signing-key nil
@@ -532,8 +528,8 @@ is run in the top-level directory of the current working tree."
                               (fpr (epg-sub-key-fingerprint key))
                               (id  (epg-sub-key-id key))
                               (author
-                               (and-let* ((id-obj
-                                           (car (epg-key-user-id-list cert))))
+                               (and-let ((id-obj
+                                          (car (epg-key-user-id-list cert))))
                                  (let ((id-str (epg-user-id-string id-obj)))
                                    (if (stringp id-str)
                                        id-str
@@ -638,7 +634,9 @@ the output in the kill ring.
                 (push t debug)
                 (load-file static)
                 magit-version))
-            (when (featurep 'package)
+            (when (and (featurep 'package)
+                       (boundp 'package-alist)
+                       (fboundp 'package-version-join))
               (push 'elpa debug)
               (ignore-errors
                 (when-let ((version (cadr (assq 'magit package-alist))))
@@ -652,7 +650,7 @@ the output in the kill ring.
               (let ((dirname (file-name-nondirectory
                               (directory-file-name topdir))))
                 (when (string-match "\\`magit-\\([0-9].*\\)" dirname)
-                  (setq magit-version (match-string 1 dirname)))))
+                  (setq magit-version (match-str 1 dirname)))))
             ;; If all else fails, just report the commit hash. It's
             ;; better than nothing and we cannot do better in the case
             ;; of e.g., a shallow clone.
@@ -667,44 +665,44 @@ the output in the kill ring.
                         (magit-git-string "rev-parse" "HEAD"))))))))
     (if (stringp magit-version)
         (when print-dest
-          (let ((str (format
-                      "Magit %s%s, Transient %s,%s Git %s, Emacs %s, %s"
-                      (or magit-version "(unknown)")
-                      (or (and (ignore-errors
+          (let* ((alt (or (and (ignore-errors
                                  (magit--version>= magit-version "2008"))
                                (ignore-errors
                                  (require 'lisp-mnt)
                                  (and (fboundp 'lm-header)
-                                      (format
-                                       " [>= %s]"
-                                       (with-temp-buffer
-                                         (insert-file-contents
-                                          (locate-library "magit.el" t))
-                                         (lm-header "Package-Version"))))))
-                          "")
-                      (or (ignore-errors
-                            (require 'lisp-mnt)
-                            (and (fboundp 'lm-header)
-                                 (with-temp-buffer
-                                   (insert-file-contents
-                                    (locate-library "transient.el" t))
-                                   (lm-header "Package-Version"))))
-                          "(unknown)")
-                      (let ((lib (locate-library "forge.el" t)))
-                        (or (and lib
-                                 (format
-                                  " Forge %s,"
-                                  (or (ignore-errors
-                                        (require 'lisp-mnt)
-                                        (with-temp-buffer
-                                          (insert-file-contents lib)
-                                          (and (fboundp 'lm-header)
-                                               (lm-header "Package-Version"))))
-                                      "(unknown)")))
-                            ""))
-                      (magit--safe-git-version)
-                      emacs-version
-                      system-type)))
+                                      (with-temp-buffer
+                                        (insert-file-contents
+                                         (locate-library "magit.el" t))
+                                        (lm-header "Package-Version")))))))
+                 (str (format
+                       "Magit %s%s, Transient %s,%s Git %s, Emacs %s, %s"
+                       (or magit-version "(unknown)")
+                       (if (and alt (not (equal alt magit-version)))
+                           (format " [>= %s]" alt)
+                         "")
+                       (or (ignore-errors
+                             (require 'lisp-mnt)
+                             (and (fboundp 'lm-header)
+                                  (with-temp-buffer
+                                    (insert-file-contents
+                                     (locate-library "transient.el" t))
+                                    (lm-header "Package-Version"))))
+                           "(unknown)")
+                       (let ((lib (locate-library "forge.el" t)))
+                         (or (and lib
+                                  (format
+                                   " Forge %s,"
+                                   (or (ignore-errors
+                                         (require 'lisp-mnt)
+                                         (with-temp-buffer
+                                           (insert-file-contents lib)
+                                           (and (fboundp 'lm-header)
+                                                (lm-header "Package-Version"))))
+                                       "(unknown)")))
+                             ""))
+                       (magit--safe-git-version)
+                       emacs-version
+                       system-type)))
             (when interactive
               (kill-new str))
             (princ str print-dest)))
@@ -776,7 +774,11 @@ For X11 something like ~/.xinitrc should work.\n"
   (require 'magit-stash)
   (require 'magit-blame)
   (require 'magit-submodule)
-  (unless (load "magit-autoloads" t t)
+  ;; The `provide' form may be missing so we have to
+  ;; try harder to ensure this is loaded exactly once.
+  (unless (or (featurep 'magit-autoloads)
+              (autoloadp (symbol-function 'magit-patch))
+              (load "magit-autoloads" t))
     (require 'magit-patch)
     (require 'magit-subtree)
     (require 'magit-ediff)
@@ -797,4 +799,15 @@ For X11 something like ~/.xinitrc should work.\n"
     (add-hook 'after-init-hook #'magit-startup-asserts t)
     (add-hook 'after-init-hook #'magit-version t)))
 
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit.el ends here
diff --git a/elpa/magit-20250519.1537/magit.info b/elpa/magit-20251103.1130/magit.info
similarity index 96%
rename from elpa/magit-20250519.1537/magit.info
rename to elpa/magit-20251103.1130/magit.info
index efd5f29c..b10a4a58 100644
--- a/elpa/magit-20250519.1537/magit.info
+++ b/elpa/magit-20251103.1130/magit.info
@@ -32,7 +32,7 @@ to perform almost all of their daily version control tasks directly from
 within Emacs.  While many fine Git clients exist, only Magit and Git
 itself deserve to be called porcelains.
 
-This manual is for Magit version 4.3.5.
+This manual is for Magit version 4.4.2.
 
      Copyright (C) 2015-2025 Jonas Bernoulli
      <emacs.magit@jonas.bernoulli.dev>
@@ -292,11 +292,11 @@ File: magit.info,  Node: Installing from the Git Repository,  Next: Post-Install
 2.2 Installing from the Git Repository
 ======================================
 
-Magit depends on the ‘compat’, ‘llama’, ‘seq’ (the built-in version is
-enough when using Emacs >= 29.1), ‘transient’ and ‘with-editor’
-libraries which are available from Melpa and Melpa-Stable.  Install them
-using ‘M-x package-install RET <package> RET’.  Of course you may also
-install them manually from their repository.
+Magit depends on the ‘compat’, ‘cond-let’, ‘llama’, ‘seq’ (the built-in
+version is enough when using Emacs >= 29.1), ‘transient’ and
+‘with-editor’ libraries which are available from Melpa and Melpa-Stable.
+Install them using ‘M-x package-install RET <package> RET’.  Of course
+you may also install them manually from their repository.
 
    Then clone the Magit repository:
 
@@ -307,14 +307,15 @@ install them manually from their repository.
 
      $ make
 
-   If you haven’t installed ‘compat’, ‘llama’, ‘seq’ (for Emacs < 29.1),
-‘transient’ and ‘with-editor’ from Melpa, or at
+   If you haven’t installed ‘compat’, ‘cond-let’, ‘llama’, ‘seq’ (only
+for Emacs 28), ‘transient’ and ‘with-editor’ from Melpa, or at
 ‘/path/to/magit/../<package>’, then you have to tell ‘make’ where to
 find them.  To do so create the file ‘/path/to/magit/config.mk’ with the
 following content before running ‘make’:
 
      LOAD_PATH  = -L ~/.emacs.d/site-lisp/magit/lisp
      LOAD_PATH += -L ~/.emacs.d/site-lisp/compat
+     LOAD_PATH += -L ~/.emacs.d/site-lisp/cond-let
      LOAD_PATH += -L ~/.emacs.d/site-lisp/llama
      LOAD_PATH += -L ~/.emacs.d/site-lisp/seq
      LOAD_PATH += -L ~/.emacs.d/site-lisp/transient/lisp
@@ -333,6 +334,7 @@ following content before running ‘make’:
 you have to tell Emacs about them too, by prefixing the above with:
 
      (add-to-list 'load-path "~/.emacs.d/site-lisp/compat")
+     (add-to-list 'load-path "~/.emacs.d/site-lisp/cond-let")
      (add-to-list 'load-path "~/.emacs.d/site-lisp/llama")
      (add-to-list 'load-path "~/.emacs.d/site-lisp/seq")
      (add-to-list 'load-path "~/.emacs.d/site-lisp/transient/lisp")
@@ -1015,6 +1017,12 @@ To move within a section use the usual keys (‘C-p’, ‘C-n’, ‘C-b’, 
 etc), whose global bindings are not shadowed.  To move to another
 section use the following commands.
 
+   The section movement commands described here run the hook
+‘magit-section-movement-hook’.  Note that they explicitly run that hook
+and that arbitrary other movement, defined in Emacs and other packages,
+do not run that hook.  That hook, and hook functions that can be added
+to it, or are part of its default value, are described below.
+
 ‘p’ (‘magit-section-backward’)
      When not at the beginning of a section, then move to the beginning
      of the current section.  At the beginning of a section, instead
@@ -1047,8 +1055,10 @@ remove function that haven’t even been added yet, for example:
                     'magit-hunk-set-window-start))
 
  -- Variable: magit-section-movement-hook
-     This hook is run by all of the above movement commands, after
-     arriving at the destination.
+     This hook is run by all of the above section movement commands,
+     after arriving at the destination.  It is *not* run by arbitrary
+     other movement commands (such as ‘next-line’), which are provided
+     by Emacs or third-party packages.
 
  -- Function: magit-hunk-set-window-start
      This hook function ensures that the beginning of the current
@@ -1105,9 +1115,11 @@ remove function that haven’t even been added yet, for example:
  -- User Option: magit-update-other-window-delay
      Delay before automatically updating the other window.
 
-     When moving around in certain buffers, then certain other buffers,
-     which are being displayed in another window, may optionally be
-     updated to display information about the section at point.
+     When moving around in certain buffers using Magit’s own section
+     movement commands (but not other movement commands), then certain
+     other buffers, which are being displayed in another window, may
+     optionally be updated to display information about the section at
+     point.
 
      When holding down a key to move by more than just one section, then
      that would update that buffer for each section on the way.  To
@@ -1852,10 +1864,6 @@ use an alternative completion framework.  For example, if you enable
 ‘ivy-mode’, then Magit will respect that, and if you enable ‘helm-mode’,
 then you are done too.
 
-   However if you want to use Ido, then ‘ido-mode’ won’t do the trick.
-You will also have to install the ‘ido-completing-read+’ package and use
-‘magit-ido-completing-read’ as ‘magit-completing-read-function’.
-
  -- User Option: magit-completing-read-function
      The value of this variable is the low-level function used to
      perform completion by code that uses ‘magit-completing-read’ (as
@@ -1875,17 +1883,6 @@ You will also have to install the ‘ido-completing-read+’ package and use
      This function performs completion using the built-in
      ‘completing-read’ and does some additional magit-specific work.
 
- -- Function: magit-ido-completing-read prompt choices &optional
-          predicate require-match initial-input hist def
-     This function performs completion using ‘ido-completing-read+’ from
-     the package by the same name (which you have to explicitly install)
-     and does some additional magit-specific work.
-
-     We have to use ‘ido-completing-read+’ instead of the
-     ‘ido-completing-read’ that comes with Ido itself, because the
-     latter, while intended as a drop-in replacement, cannot serve that
-     purpose because it violates too many of the implicit conventions.
-
  -- Function: magit-completing-read prompt choices &optional predicate
           require-match initial-input hist def fallback
      This is the function that Magit commands use when they need the
@@ -1909,7 +1906,11 @@ You will also have to install the ‘ido-completing-read+’ package and use
         • If REQUIRE-MATCH is ‘nil’ and the user exits without a choice,
           then ‘nil’ is returned instead of an empty string.
 
-        • If REQUIRE-MATCH is non-nil and the users exits without a
+        • If REQUIRE-MATCH is ‘any’, then do not require a match but do
+          require non-empty input (or non-nil DEFAULT, since that is
+          substituted for empty input).
+
+        • If REQUIRE-MATCH is non-‘nil’ and the users exits without a
           choice, an user-error is raised.
 
         • FALLBACK specifies a secondary default that is only used if
@@ -1963,12 +1964,12 @@ some value (e.g., the name of the current branch).
 
    When Git is run for side-effects, the process output is logged in a
 per-repository log buffer, which can be consulted using the
-‘magit-process’ command when things don’t go as expected.
+‘magit-process-buffer’ command, when things don’t go as expected.
 
    The output/errors for up to ‘magit-process-log-max’ Git commands are
 retained.
 
-‘$’ (‘magit-process’)
+‘$’ (‘magit-process-buffer’)
      This commands displays the process buffer for the current
      repository.
 
@@ -2016,10 +2017,13 @@ for mouse users.  This error indicator persists in the mode line until
 the next magit buffer refresh.
 
    If you do not wish process errors to be indicated in the mode line,
-customize the ‘magit-process-display-mode-line-error’ user option.
+set ‘magit-process-display-mode-line-error’ to ‘nil’.
 
-   Process errors are additionally indicated at the top of the status
-buffer.
+   Process errors are displayed at the top of the status buffer and in
+the echo area.  In both places a hint is appended, which informs users
+that they can see the full output in the process buffer and how to
+display that buffer.  However, once you are aware of that, you might
+want to set ‘magit-show-process-buffer-hint’ to ‘nil’.
 
 4.7.3 Running Git Manually
 --------------------------
@@ -2290,25 +2294,6 @@ that it should be bound globally.  We recommend using ‘C-x g’:
      existing Magit buffer that belongs to the current repository; not
      just the status buffer.
 
- -- Command: ido-enter-magit-status
-     From an Ido prompt used to open a file, instead drop into
-     ‘magit-status’.  This is similar to ‘ido-magic-delete-char’, which,
-     despite its name, usually causes a Dired buffer to be created.
-
-     To make this command available, use something like:
-
-          (add-hook 'ido-setup-hook
-                    (lambda ()
-                      (define-key ido-completion-map
-                        (kbd \"C-x g\") 'ido-enter-magit-status)))
-
-     Starting with Emacs 25.1 the Ido keymaps are defined just once
-     instead of every time Ido is invoked, so now you can modify it like
-     pretty much every other keymap:
-
-          (define-key ido-common-completion-map
-            (kbd \"C-x g\") 'ido-enter-magit-status)
-
 5.1.1 Status Sections
 ---------------------
 
@@ -2328,6 +2313,11 @@ such hooks and how to customize them.
      by default added to another hooks, are listed in *note References
      Buffer::.
 
+ -- Function: magit-insert-status-headers
+     Insert header sections appropriate for ‘magit-status-mode’ buffers.
+     The sections are inserted by running the functions on the hook
+     ‘magit-status-headers-hook’.  See *note Status Header Sections::.
+
  -- Function: magit-insert-merge-log
      Insert section for the on-going merge.  Display the heads that are
      being merged.  If no merge is in progress, do nothing.
@@ -2373,6 +2363,14 @@ such hooks and how to customize them.
      Insert section showing commits that haven’t been pulled from the
      push-remote branch yet.
 
+ -- Function: magit-insert-unpushed-to-upstream-or-recent
+     Insert section showing unpushed or other recent commits.  If an
+     upstream is configured for the current branch and it is behind of
+     the current branch, then show the commits that have not yet been
+     pushed into the upstream branch.  If no upstream is configured or
+     if the upstream is not behind of the current branch, then show the
+     last ‘magit-log-section-commit-count’ commits.
+
  -- Function: magit-insert-unpushed-to-upstream
      Insert section showing commits that haven’t been pushed to the
      upstream yet.
@@ -2397,8 +2395,8 @@ These functions honor the buffer’s file filter, which can be set using
 
         • If ‘nil’, do not list any untracked files.
         • If ‘t’, list untracked files, but if a directory does not
-          contain any untracked files, then only list that directory,
-          not the contained untracked files.
+          contain any tracked files, then only list that directory, not
+          the contained untracked files.
         • If ‘all’, then list each individual untracked files.  This is
           can be very slow and is discouraged.
 
@@ -2443,7 +2441,7 @@ that you don’t do that.
  -- Function: magit-insert-skip-worktree-files
      Insert a list of skip-worktree files.
 
- -- Function: magit-insert-assumed-unchanged-files
+ -- Function: magit-insert-assume-unchanged-files
      Insert a list of files that are assumed to be unchanged.
 
 5.1.3 Status Log Sections
@@ -3396,8 +3394,11 @@ they are available here too.
      Whether to show word-granularity differences within diff hunks.
 
         • ‘nil’ Never show fine differences.
-        • ‘t’ Show fine differences for the current diff hunk only.
         • ‘all’ Show fine differences for all displayed diff hunks.
+        • ‘t’ Refine each hunk once it becomes the current section.
+          Keep the refinement when another section is selected.
+          Refreshing the buffer removes all refinement.  This variant is
+          only provided for performance reasons.
 
  -- User Option: magit-diff-refine-ignore-whitespace
      Whether to ignore whitespace changes in word-granularity
@@ -4070,51 +4071,37 @@ are bound to these commands by default, but that is likely to change.
 5.8.2 Visiting Files and Blobs from a Diff
 ------------------------------------------
 
-These commands can only be used when point is inside a diff.
+These commands can only be used when point is inside a diff.  Elsewhere
+use ‘magit-find-file’.
 
 ‘<RET>’ (‘magit-diff-visit-file’)
-     This command visits the appropriate version of the file that the
-     diff at point is about.  The location of point inside the diff
-     determines which file is being visited.  The visited version
-     depends on what changes the diff is about.
-
-       1. If the diff shows uncommitted changes (i.e., staged or
-          unstaged changes), then visit the file in the working tree
-          (i.e., the same "real" file that ‘find-file’ would visit.  In
-          all other cases visit a "blob" (i.e., the version of a file as
-          stored in some commit).
-
-       2. If point is on a removed line, then visit the blob for the
-          first parent of the commit that removed that line, i.e., the
-          last commit where that line still exists.
-
-       3. If point is on an added or context line, then visit the blob
-          that adds that line, or if the diff shows from more than a
-          single commit, then visit the blob from the last of these
-          commits.
+     This command visits the appropriate version of the file at point.
 
-     In the file-visiting buffer this command goes to the line that
-     corresponds to the line that point is on in the diff.
+     Display the buffer in the selected window.  With a prefix argument,
+     OTHER-WINDOW, instead display the buffer in another window.
 
-     The buffer is displayed in the selected window.  With a prefix
-     argument the buffer is displayed in another window instead.
+     In the visited file or blob, go to the location corresponding to
+     the location in the diff.
 
- -- User Option: magit-diff-visit-previous-blob
-     This option controls whether ‘magit-diff-visit-file’ may visit the
-     previous blob.  When this is ‘t’ (the default) and point is on a
-     removed line in a diff for a committed change, then
-     ‘magit-diff-visit-file’ visits the blob from the last revision
-     which still had that line.
+     If point is on an added or context line, visit the blob
+     corresponding to our side (i.e., the new/right side).  If point is
+     on a removed line, visit the blob corresponding to their side
+     (i.e., the old/left side).
+
+     This applies to diffs of staged and unstaged changes as well.  For
+     staged changes the two sides are blobs from the index and the
+     ‘HEAD’ commit.  For unstaged changes the two sides are the actual
+     file in the worktree and the blob from the index.
 
-     Currently this is only supported for committed changes, for staged
-     and unstaged changes ‘magit-diff-visit-file’ always visits the file
-     in the working tree.
+     To visit the file in the worktree, regardless of what the current
+     diff is about, use ‘magit-diff-visit-worktree-file’, described
+     next.
 
-‘C-<return>’ (‘magit-diff-visit-file-worktree’)
+‘C-<return>’ (‘magit-diff-visit-worktree-file’)
      This command visits the worktree version of the appropriate file.
      The location of point inside the diff determines which file is
      being visited.  Unlike ‘magit-diff-visit-file’ it always visits the
-     "real" file in the working tree, i.e the "current version" of the
+     "real" file in the working tree, i.e., the "current version" of the
      file.
 
      In the file-visiting buffer this command goes to the line that
@@ -4135,6 +4122,59 @@ argument.
  -- Command: magit-diff-visit-file-other-frame
  -- Command: magit-diff-visit-worktree-file-other-window
  -- Command: magit-diff-visit-worktree-file-other-frame
+     These commands behave like the respective commands described above,
+     except that they display the blob or file in another window or
+     frame.
+
+ -- User Option: magit-diff-visit-prefer-worktree
+     This option controls whether ‘magit-diff-visit-file’ always visits
+     the respective file in the worktree, when invoked anywhere from
+     within a hunk of staged or unstaged changes.
+
+     By default ‘magit-diff-visit-file’ does not do that.  Instead it
+     behaves for staged and unstaged changes as it does for committed
+     changes, by visiting a blob from the old/left or new/right side,
+     depending on whether point is on a removed line or not.
+
+     For staged changes the old side is the blob from HEAD and the right
+     side is the blog from the index.  For unstaged changes the left
+     side is the blob from the index (if there are any changes in the
+     index for that file, else the blob from HEAD), and the right side
+     is the file in the worktree.
+
+     Being able to jump to HEAD or the index from a removed line is very
+     useful, because it allows you to, e.g., use blame to investigate
+     why some line, which you have already removed, was added in the
+     first place.
+
+     But if you want to make further changes to already staged changes,
+     you of course instead need to go to the respective file in the
+     worktree.  The command ‘magit-diff-visit-worktree-file’ was created
+     for that purpose, and it is strongly recommend that you make use of
+     that command, even if you initially find it inconvenient having to
+     remember to use ‘C-<return>’ instead of ‘RET’ in this case.
+
+     While discouraged, you can alternatively set this option to ‘t’,
+     which causes ‘magit-diff-visit-file’ itself to go to the file in
+     the worktree, even when invoked from within a hunk of staged
+     changes.  If you do that, you lose the ability to instantly go to
+     lines you have already removed.
+
+ -- User Option: magit-diff-visit-previous-blob
+     This option controls whether ‘magit-diff-visit-file’ visits the
+     previous blob when invoked with point on a removed line.
+
+     When this is ‘t’ (the default) and point is on a removed line, then
+     ‘magit-diff-visit-file’ visits the blob from the old/left commit,
+     which still has that line, instead of going to the new/right blob,
+     which removes that line.
+
+     Setting this to ‘nil’, causes ‘magit-diff-visit-file’ to always go
+     to the new/right blob, even when point is on a removed line.  This
+     is very strongly discouraged.  Instead place the cursor anywhere
+     else within the hunk but on a removed line, if you want to visit
+     the new side.  That way you don’t lose the ability to visit the old
+     side.
 
 
 File: magit.info,  Node: Blaming,  Prev: Visiting Files and Blobs,  Up: Inspecting
@@ -5245,7 +5285,7 @@ The transient prefix command ‘magit-branch’ is used to create and
 checkout branches, and to make changes to existing branches.  It is not
 used to fetch, pull, merge, rebase, or push branches, i.e., this command
 deals with branches themselves, not with the commits reachable from
-them.  Those features are available from separate transient command.
+them.  Those features are available from separate transient commands.
 
 ‘b’ (‘magit-branch’)
      This transient prefix command binds the following suffix commands
@@ -6024,11 +6064,35 @@ following suffix commands.
      Stop at the commit on the current line.
 
 ‘s’ (‘git-rebase-squash’)
-     Meld commit on current line into previous commit, and edit message.
+     This command folds the commit on the current line into the previous
+     commit, giving the user a change to manually merge the two
+     messages.
+
+‘S’ (‘git-rebase-squish’)
+     This command folds the commit on the current line into the previous
+     commit, discarding the message of the previous commit but giving
+     the user a change to edit the final message, based on the message
+     of the current commit.
+
+     This action’s indicator, shown in the list of commits, is ‘fixup
+     -c’ (with a lower-case c).
 
 ‘f’ (‘git-rebase-fixup’)
-     Meld commit on current line into previous commit, discarding the
-     current commit’s message.
+     This command folds the commit on the current line into the previous
+     commit, using only the message of the previous commit as-is and
+     discarding the message of the current commit.
+
+‘F’ (‘git-rebase-alter’)
+     This command folds the commit on the current into the previous
+     commit, discarding the message of the previous commit and instead
+     using the message of the current commit as-is.
+
+     This is like ‘git-rebase-alter’, except that it uses the other
+     message.  This is also like ‘git-rebase-squish’, except that it
+     lets the user edit the message.
+
+     This action’s indicator, shown in the list of commits, is ‘fixup
+     -C’ (with a upper-case C).
 
 ‘k’ (‘git-rebase-kill-line’)
      Comment the current action line, or if it is already commented,
@@ -7844,6 +7908,9 @@ all, add this to your init file and restart Emacs.
      the position in that buffer, which corresponds to the position in
      the current file-visiting buffer (if any).
 
+     Before doing so, save all file-visiting buffers belonging to the
+     current repository without prompting.
+
 ‘C-c M-g G’ (‘magit-display-repository-buffer’)
      This command reads and displays a Magit buffer belonging to the
      current repository, without refreshing it.
@@ -7876,13 +7943,19 @@ minor mode.  Currently this mode only establishes a few key bindings,
 but this might be extended.
 
 ‘p’ (‘magit-blob-previous’)
-     Visit the previous blob which modified the current file.
+     This command visits the previous blob that modified the current
+     file.
 
 ‘n’ (‘magit-blob-next’)
-     Visit the next blob which modified the current file.
+     This command visit the next blob that modified the current file.
+
+‘q’ (‘magit-bury-or-kill-buffer’)
+     This command buries the current buffer, if that is being displayed
+     in multiple windows and/or when a prefix argument is used.  If
+     neither is the case, it instead kills the current buffer.
 
-‘q’ (‘magit-kill-this-buffer’)
-     Kill the current buffer.
+   You might want to bind ‘u’ to another command.  Suitable commands
+include ‘bury-buffer’, ‘magit-bury-buffer’ and ‘magit-kill-this-buffer’.
 
 
 File: magit.info,  Node: Customizing,  Next: Plumbing,  Prev: Miscellaneous,  Up: Top
@@ -8434,6 +8507,9 @@ for git to complete before letting the user do something else.  For
 example after staging a change it is useful to wait until after the
 refresh because that also automatically moves to the next change.
 
+   The synchronous functions return the exit code, while the
+asynchronous functions return the process object.
+
  -- Function: magit-call-git &rest args
      Calls git synchronously with ARGS.
 
@@ -9407,28 +9483,28 @@ Appendix C Keystroke Index
 [index]
 * Menu:
 
-* !:                                     Running Git.         (line  82)
-* ! !:                                   Running Git.         (line  86)
-* ! a:                                   Running Git.         (line 122)
-* ! b:                                   Running Git.         (line 125)
-* ! g:                                   Running Git.         (line 128)
-* ! k:                                   Running Git.         (line 119)
-* ! m:                                   Running Git.         (line 131)
-* ! p:                                   Running Git.         (line  94)
-* ! s:                                   Running Git.         (line 103)
-* ! S:                                   Running Git.         (line 107)
+* !:                                     Running Git.         (line  85)
+* ! !:                                   Running Git.         (line  89)
+* ! a:                                   Running Git.         (line 125)
+* ! b:                                   Running Git.         (line 128)
+* ! g:                                   Running Git.         (line 131)
+* ! k:                                   Running Git.         (line 122)
+* ! m:                                   Running Git.         (line 134)
+* ! p:                                   Running Git.         (line  97)
+* ! s:                                   Running Git.         (line 106)
+* ! S:                                   Running Git.         (line 110)
 * $:                                     Running Git.         (line  20)
 * +:                                     Logging.             (line 160)
 * + <1>:                                 Diffing.             (line 154)
 * -:                                     Logging.             (line 163)
 * - <1>:                                 Diffing.             (line 151)
 * 0:                                     Diffing.             (line 157)
-* 1:                                     Sections.            (line 163)
-* 2:                                     Sections.            (line 163)
-* 3:                                     Sections.            (line 163)
-* 4:                                     Sections.            (line 163)
+* 1:                                     Sections.            (line 173)
+* 2:                                     Sections.            (line 173)
+* 3:                                     Sections.            (line 173)
+* 4:                                     Sections.            (line 173)
 * 5:                                     Repository List.     (line 115)
-* ::                                     Running Git.         (line  94)
+* ::                                     Running Git.         (line  97)
 * =:                                     Logging.             (line 155)
 * >:                                     Sparse checkouts.    (line  17)
 * > a:                                   Sparse checkouts.    (line  39)
@@ -9436,7 +9512,7 @@ Appendix C Keystroke Index
 * > e:                                   Sparse checkouts.    (line  21)
 * > r:                                   Sparse checkouts.    (line  44)
 * > s:                                   Sparse checkouts.    (line  33)
-* ^:                                     Sections.            (line  44)
+* ^:                                     Sections.            (line  50)
 * a:                                     Applying.            (line  34)
 * A:                                     Cherry Picking.      (line   9)
 * A A:                                   Cherry Picking.      (line  17)
@@ -9451,7 +9527,7 @@ Appendix C Keystroke Index
 * B:                                     Bisecting.           (line   9)
 * b:                                     Blaming.             (line 115)
 * b <1>:                                 Branching.           (line  63)
-* b <2>:                                 Rebasing.            (line 187)
+* b <2>:                                 Rebasing.            (line 211)
 * B B:                                   Bisecting.           (line  16)
 * B b:                                   Bisecting.           (line  32)
 * b b:                                   Branching.           (line  97)
@@ -9472,7 +9548,7 @@ Appendix C Keystroke Index
 * c:                                     Blaming.             (line 141)
 * C:                                     Cloning Repository.  (line  20)
 * c <1>:                                 Committing.          (line  21)
-* c <2>:                                 Rebasing.            (line 176)
+* c <2>:                                 Rebasing.            (line 200)
 * C >:                                   Cloning Repository.  (line  38)
 * c a:                                   Committing.          (line  59)
 * c A:                                   Committing.          (line 141)
@@ -9492,8 +9568,8 @@ Appendix C Keystroke Index
 * c w:                                   Committing.          (line  65)
 * c W:                                   Committing.          (line 167)
 * C-<return>:                            Visiting Files and Blobs.
-                                                              (line  78)
-* C-<tab>:                               Sections.            (line 138)
+                                                              (line  64)
+* C-<tab>:                               Sections.            (line 148)
 * C-c C-a:                               Committing.          (line 415)
 * C-c C-b:                               Logging.             (line 116)
 * C-c C-b <1>:                           Diffing.             (line 173)
@@ -9607,19 +9683,19 @@ Appendix C Keystroke Index
 * C-c M-g B q:                           Blaming.             (line  87)
 * C-c M-g B r:                           Blaming.             (line  60)
 * C-c M-g c:                             Commands for Buffers Visiting Files.
-                                                              (line 176)
+                                                              (line 179)
 * C-c M-g D:                             Commands for Buffers Visiting Files.
                                                               (line  91)
 * C-c M-g d:                             Commands for Buffers Visiting Files.
                                                               (line 101)
 * C-c M-g e:                             Blaming.             (line  76)
 * C-c M-g e <1>:                         Commands for Buffers Visiting Files.
-                                                              (line 182)
+                                                              (line 185)
 * C-c M-g f:                             Blaming.             (line  68)
 * C-c M-g g:                             Commands for Buffers Visiting Files.
                                                               (line 166)
 * C-c M-g G:                             Commands for Buffers Visiting Files.
-                                                              (line 172)
+                                                              (line 175)
 * C-c M-g L:                             Commands for Buffers Visiting Files.
                                                               (line 109)
 * C-c M-g l:                             Commands for Buffers Visiting Files.
@@ -9648,11 +9724,11 @@ Appendix C Keystroke Index
                                                               (line 160)
 * C-c M-i:                               Committing.          (line 434)
 * C-c M-s:                               Committing.          (line 318)
-* C-c TAB:                               Sections.            (line 138)
+* C-c TAB:                               Sections.            (line 148)
 * C-w:                                   Common Commands.     (line  22)
 * C-x g:                                 Status Buffer.       (line  23)
 * C-x M-g:                               Transient Commands.  (line  20)
-* C-x u:                                 Rebasing.            (line 194)
+* C-x u:                                 Rebasing.            (line 218)
 * d:                                     Diffing.             (line  22)
 * D:                                     Diffing.             (line 105)
 * d c:                                   Diffing.             (line  82)
@@ -9688,9 +9764,10 @@ Appendix C Keystroke Index
 * E w:                                   Ediffing.            (line  97)
 * E z:                                   Ediffing.            (line 103)
 * f:                                     Repository List.     (line 111)
-* f <1>:                                 Rebasing.            (line 168)
+* f <1>:                                 Rebasing.            (line 179)
+* F:                                     Rebasing.            (line 184)
 * f <2>:                                 Fetching.            (line  10)
-* F:                                     Pulling.             (line  10)
+* F <1>:                                 Pulling.             (line  10)
 * f a:                                   Fetching.            (line  45)
 * f C:                                   Branching.           (line  81)
 * F C:                                   Branching.           (line  81)
@@ -9705,19 +9782,19 @@ Appendix C Keystroke Index
 * F u:                                   Pulling.             (line  21)
 * g:                                     Modes and Buffers.   (line 265)
 * G:                                     Modes and Buffers.   (line 273)
-* H:                                     Sections.            (line 331)
+* H:                                     Sections.            (line 341)
 * I:                                     Creating Repository. (line   7)
 * j:                                     Logging.             (line 127)
 * j <1>:                                 Diffing.             (line 218)
 * k:                                     Running Git.         (line  27)
 * k <1>:                                 Applying.            (line  40)
-* k <2>:                                 Rebasing.            (line 172)
+* k <2>:                                 Rebasing.            (line 196)
 * k <3>:                                 Stashing.            (line 114)
 * l:                                     Logging.             (line  28)
 * L:                                     Logging.             (line  75)
 * L <1>:                                 Logging.             (line 103)
 * L <2>:                                 Logging.             (line 263)
-* l <1>:                                 Rebasing.            (line 211)
+* l <1>:                                 Rebasing.            (line 235)
 * l a:                                   Logging.             (line  59)
 * l b:                                   Logging.             (line  56)
 * L d:                                   Logging.             (line 277)
@@ -9754,27 +9831,27 @@ Appendix C Keystroke Index
 * M r:                                   Remotes.             (line  55)
 * m s:                                   Merging.             (line  67)
 * M u:                                   Remotes.             (line  59)
-* M-1:                                   Sections.            (line 169)
-* M-2:                                   Sections.            (line 169)
-* M-3:                                   Sections.            (line 169)
-* M-4:                                   Sections.            (line 169)
-* M-<tab>:                               Sections.            (line 153)
-* M-n:                                   Sections.            (line  40)
+* M-1:                                   Sections.            (line 179)
+* M-2:                                   Sections.            (line 179)
+* M-3:                                   Sections.            (line 179)
+* M-4:                                   Sections.            (line 179)
+* M-<tab>:                               Sections.            (line 163)
+* M-n:                                   Sections.            (line  46)
 * M-n <1>:                               Committing.          (line 326)
 * M-n <2>:                               Rebasing.            (line 156)
-* M-p:                                   Sections.            (line  35)
+* M-p:                                   Sections.            (line  41)
 * M-p <1>:                               Committing.          (line 321)
 * M-p <2>:                               Rebasing.            (line 153)
 * M-w:                                   Blaming.             (line 134)
 * M-w <1>:                               Common Commands.     (line  39)
-* MM:                                    Rebasing.            (line 219)
-* Mt:                                    Rebasing.            (line 225)
-* n:                                     Sections.            (line  32)
+* MM:                                    Rebasing.            (line 243)
+* Mt:                                    Rebasing.            (line 249)
+* n:                                     Sections.            (line  38)
 * n <1>:                                 Blaming.             (line 118)
 * N:                                     Blaming.             (line 121)
 * n <2>:                                 Rebasing.            (line 150)
 * n <3>:                                 Minor Mode for Buffers Visiting Blobs.
-                                                              (line  16)
+                                                              (line  17)
 * o:                                     Submodules.          (line  55)
 * O:                                     Subtree.             (line   9)
 * o a:                                   Submodules.          (line  68)
@@ -9793,7 +9870,7 @@ Appendix C Keystroke Index
 * o r:                                   Submodules.          (line  74)
 * o s:                                   Submodules.          (line  88)
 * o u:                                   Submodules.          (line  84)
-* p:                                     Sections.            (line  27)
+* p:                                     Sections.            (line  33)
 * p <1>:                                 Blaming.             (line 124)
 * P:                                     Blaming.             (line 127)
 * p <2>:                                 Rebasing.            (line 147)
@@ -9813,7 +9890,7 @@ Appendix C Keystroke Index
 * q <1>:                                 Logging.             (line 110)
 * q <2>:                                 Blaming.             (line 130)
 * q <3>:                                 Minor Mode for Buffers Visiting Blobs.
-                                                              (line  19)
+                                                              (line  20)
 * r:                                     Rebasing.            (line  10)
 * r <1>:                                 Rebasing.            (line 159)
 * r a:                                   Rebasing.            (line 116)
@@ -9832,7 +9909,7 @@ Appendix C Keystroke Index
 * RET:                                   Repository List.     (line 102)
 * RET <1>:                               References Buffer.   (line 159)
 * RET <2>:                               Visiting Files and Blobs.
-                                                              (line  40)
+                                                              (line  41)
 * RET <3>:                               Blaming.             (line  91)
 * RET <4>:                               Rebasing.            (line 131)
 * s:                                     Staging and Unstaging.
@@ -9840,12 +9917,13 @@ Appendix C Keystroke Index
 * S:                                     Staging and Unstaging.
                                                               (line  36)
 * s <1>:                                 Rebasing.            (line 165)
-* S-<tab>:                               Sections.            (line 157)
+* S <1>:                                 Rebasing.            (line 170)
+* S-<tab>:                               Sections.            (line 167)
 * SPC:                                   Logging.             (line 137)
 * SPC <1>:                               Diffing.             (line 228)
 * SPC <2>:                               Blaming.             (line  94)
 * SPC <3>:                               Rebasing.            (line 135)
-* t:                                     Rebasing.            (line 214)
+* t:                                     Rebasing.            (line 238)
 * t <1>:                                 Tagging.             (line   9)
 * T:                                     Notes.               (line   9)
 * T a:                                   Notes.               (line  47)
@@ -9858,7 +9936,7 @@ Appendix C Keystroke Index
 * T r:                                   Notes.               (line  21)
 * t t:                                   Tagging.             (line  14)
 * T T:                                   Notes.               (line  14)
-* TAB:                                   Sections.            (line 134)
+* TAB:                                   Sections.            (line 144)
 * u:                                     Repository List.     (line 108)
 * u <1>:                                 Staging and Unstaging.
                                                               (line  42)
@@ -9882,7 +9960,7 @@ Appendix C Keystroke Index
 * w s:                                   Maildir Patches.     (line  34)
 * w w:                                   Maildir Patches.     (line  14)
 * w w <1>:                               Maildir Patches.     (line  31)
-* x:                                     Rebasing.            (line 179)
+* x:                                     Rebasing.            (line 203)
 * x <1>:                                 Resetting.           (line   9)
 * X f:                                   Resetting.           (line  44)
 * X h:                                   Resetting.           (line  24)
@@ -9894,7 +9972,7 @@ Appendix C Keystroke Index
 * X w <1>:                               Wip Modes.           (line  64)
 * Y:                                     Logging.             (line 382)
 * y:                                     References Buffer.   (line   7)
-* y <1>:                                 Rebasing.            (line 191)
+* y <1>:                                 Rebasing.            (line 215)
 * y c:                                   References Buffer.   (line  25)
 * y o:                                   References Buffer.   (line  30)
 * y r:                                   References Buffer.   (line  34)
@@ -9950,28 +10028,29 @@ Appendix D Function and Command Index
 * git-commit-test:                       Committing.          (line 424)
 * git-commit-turn-on-auto-fill:          Committing.          (line 466)
 * git-commit-turn-on-flyspell:           Committing.          (line 469)
+* git-rebase-alter:                      Rebasing.            (line 184)
 * git-rebase-backward-line:              Rebasing.            (line 147)
-* git-rebase-break:                      Rebasing.            (line 187)
+* git-rebase-break:                      Rebasing.            (line 211)
 * git-rebase-edit:                       Rebasing.            (line 162)
-* git-rebase-exec:                       Rebasing.            (line 179)
-* git-rebase-fixup:                      Rebasing.            (line 168)
-* git-rebase-insert:                     Rebasing.            (line 191)
-* git-rebase-kill-line:                  Rebasing.            (line 172)
-* git-rebase-label:                      Rebasing.            (line 211)
-* git-rebase-merge:                      Rebasing.            (line 219)
-* git-rebase-merge-toggle-editmsg:       Rebasing.            (line 225)
+* git-rebase-exec:                       Rebasing.            (line 203)
+* git-rebase-fixup:                      Rebasing.            (line 179)
+* git-rebase-insert:                     Rebasing.            (line 215)
+* git-rebase-kill-line:                  Rebasing.            (line 196)
+* git-rebase-label:                      Rebasing.            (line 235)
+* git-rebase-merge:                      Rebasing.            (line 243)
+* git-rebase-merge-toggle-editmsg:       Rebasing.            (line 249)
 * git-rebase-move-line-down:             Rebasing.            (line 156)
 * git-rebase-move-line-up:               Rebasing.            (line 153)
-* git-rebase-pick:                       Rebasing.            (line 176)
-* git-rebase-reset:                      Rebasing.            (line 214)
+* git-rebase-pick:                       Rebasing.            (line 200)
+* git-rebase-reset:                      Rebasing.            (line 238)
 * git-rebase-reword:                     Rebasing.            (line 159)
 * git-rebase-show-commit:                Rebasing.            (line 131)
 * git-rebase-show-or-scroll-down:        Rebasing.            (line 141)
 * git-rebase-show-or-scroll-up:          Rebasing.            (line 135)
 * git-rebase-squash:                     Rebasing.            (line 165)
-* git-rebase-undo:                       Rebasing.            (line 194)
-* ido-enter-magit-status:                Status Buffer.       (line  96)
-* magit-add-section-hook:                Sections.            (line 291)
+* git-rebase-squish:                     Rebasing.            (line 170)
+* git-rebase-undo:                       Rebasing.            (line 218)
+* magit-add-section-hook:                Sections.            (line 301)
 * magit-after-save-refresh-status:       Modes and Buffers.   (line 294)
 * magit-am:                              Maildir Patches.     (line   9)
 * magit-am-abort:                        Maildir Patches.     (line  38)
@@ -10027,7 +10106,7 @@ Appendix D Function and Command Index
 * magit-blob-next <1>:                   Commands for Buffers Visiting Files.
                                                               (line 153)
 * magit-blob-next <2>:                   Minor Mode for Buffers Visiting Blobs.
-                                                              (line  16)
+                                                              (line  17)
 * magit-blob-previous:                   Commands for Buffers Visiting Files.
                                                               (line  52)
 * magit-blob-previous <1>:               Commands for Buffers Visiting Files.
@@ -10053,10 +10132,12 @@ Appendix D Function and Command Index
 * magit-branch-spinout:                  Branching.           (line 168)
 * magit-branch-unshelve:                 Branching.           (line 457)
 * magit-builtin-completing-read:         Completion Confirmation and the Selection.
-                                                              (line 358)
+                                                              (line 354)
 * magit-bundle:                          Bundle.              (line   8)
-* magit-call-git:                        Calling Git.         (line 135)
-* magit-call-process:                    Calling Git.         (line 138)
+* magit-bury-or-kill-buffer:             Minor Mode for Buffers Visiting Blobs.
+                                                              (line  20)
+* magit-call-git:                        Calling Git.         (line 138)
+* magit-call-process:                    Calling Git.         (line 141)
 * magit-cancel-section:                  Section Plumbing.    (line  72)
 * magit-checkout:                        Branching.           (line  97)
 * magit-cherry:                          Logging.             (line 382)
@@ -10079,7 +10160,7 @@ Appendix D Function and Command Index
 * magit-commit <1>:                      Commands for Buffers Visiting Files.
                                                               (line  52)
 * magit-commit <2>:                      Commands for Buffers Visiting Files.
-                                                              (line 176)
+                                                              (line 179)
 * magit-commit-alter:                    Committing.          (line 141)
 * magit-commit-amend:                    Committing.          (line  59)
 * magit-commit-augment:                  Committing.          (line 153)
@@ -10092,16 +10173,16 @@ Appendix D Function and Command Index
 * magit-commit-reword:                   Committing.          (line  65)
 * magit-commit-squash:                   Committing.          (line 130)
 * magit-completing-read:                 Completion Confirmation and the Selection.
-                                                              (line 374)
+                                                              (line 359)
 * magit-copy-buffer-revision:            Common Commands.     (line  39)
 * magit-copy-section-value:              Common Commands.     (line  22)
 * magit-current-section:                 Section Plumbing.    (line  84)
 * magit-cycle-margin-style:              Logging.             (line 274)
-* magit-debug-git-executable:            Running Git.         (line 188)
+* magit-debug-git-executable:            Running Git.         (line 191)
 * magit-debug-git-executable <1>:        Debugging Tools.     (line  69)
 * magit-define-section-jumper:           Section Plumbing.    (line  77)
-* magit-describe-section:                Sections.            (line 331)
-* magit-describe-section-briefly:        Sections.            (line 334)
+* magit-describe-section:                Sections.            (line 341)
+* magit-describe-section-briefly:        Sections.            (line 344)
 * magit-describe-section-briefly <1>:    Section Plumbing.    (line 123)
 * magit-diff:                            Diffing.             (line  22)
 * magit-diff <1>:                        Commands for Buffers Visiting Files.
@@ -10137,17 +10218,17 @@ Appendix D Function and Command Index
 * magit-diff-type:                       Section Plumbing.    (line 204)
 * magit-diff-unstaged:                   Diffing.             (line  72)
 * magit-diff-visit-file:                 Visiting Files and Blobs.
-                                                              (line  40)
+                                                              (line  41)
 * magit-diff-visit-file-other-frame:     Visiting Files and Blobs.
-                                                              (line  99)
+                                                              (line  85)
 * magit-diff-visit-file-other-window:    Visiting Files and Blobs.
-                                                              (line  98)
-* magit-diff-visit-file-worktree:        Visiting Files and Blobs.
-                                                              (line  78)
+                                                              (line  84)
+* magit-diff-visit-worktree-file:        Visiting Files and Blobs.
+                                                              (line  64)
 * magit-diff-visit-worktree-file-other-frame: Visiting Files and Blobs.
-                                                              (line 101)
+                                                              (line  87)
 * magit-diff-visit-worktree-file-other-window: Visiting Files and Blobs.
-                                                              (line 100)
+                                                              (line  86)
 * magit-diff-while-committing:           Diffing.             (line 164)
 * magit-diff-while-committing <1>:       Committing.          (line 339)
 * magit-diff-working-tree:               Diffing.             (line  62)
@@ -10168,7 +10249,7 @@ Appendix D Function and Command Index
 * magit-display-repository-buffer <1>:   Commands for Buffers Visiting Files.
                                                               (line  52)
 * magit-display-repository-buffer <2>:   Commands for Buffers Visiting Files.
-                                                              (line 172)
+                                                              (line 175)
 * magit-ediff:                           Ediffing.            (line  21)
 * magit-ediff-compare:                   Ediffing.            (line  25)
 * magit-ediff-dwim:                      Ediffing.            (line  10)
@@ -10183,7 +10264,7 @@ Appendix D Function and Command Index
 * magit-edit-line-commit:                Commands for Buffers Visiting Files.
                                                               (line  52)
 * magit-edit-line-commit <1>:            Commands for Buffers Visiting Files.
-                                                              (line 182)
+                                                              (line 185)
 * magit-emacs-Q-command:                 Debugging Tools.     (line  16)
 * magit-fetch:                           Fetching.            (line  10)
 * magit-fetch-all:                       Fetching.            (line  45)
@@ -10228,78 +10309,76 @@ Appendix D Function and Command Index
 * magit-generate-buffer-name-default-function: Modes and Buffers.
                                                               (line 141)
 * magit-get-section:                     Section Plumbing.    (line 130)
-* magit-git:                             Calling Git.         (line 153)
-* magit-git-command:                     Running Git.         (line  94)
-* magit-git-command-topdir:              Running Git.         (line  86)
+* magit-git:                             Calling Git.         (line 156)
+* magit-git-command:                     Running Git.         (line  97)
+* magit-git-command-topdir:              Running Git.         (line  89)
 * magit-git-exit-code:                   Calling Git.         (line  37)
 * magit-git-failure:                     Calling Git.         (line  44)
 * magit-git-false:                       Calling Git.         (line  52)
 * magit-git-insert:                      Calling Git.         (line  56)
 * magit-git-items:                       Calling Git.         (line  68)
 * magit-git-lines:                       Calling Git.         (line  64)
-* magit-git-mergetool:                   Running Git.         (line 131)
+* magit-git-mergetool:                   Running Git.         (line 134)
 * magit-git-mergetool <1>:               Ediffing.            (line  79)
 * magit-git-str:                         Calling Git.         (line 102)
 * magit-git-string:                      Calling Git.         (line  59)
 * magit-git-success:                     Calling Git.         (line  40)
 * magit-git-true:                        Calling Git.         (line  48)
-* magit-git-wash:                        Calling Git.         (line 157)
+* magit-git-wash:                        Calling Git.         (line 160)
 * magit-go-backward:                     Logging.             (line 116)
 * magit-go-backward <1>:                 Diffing.             (line 173)
 * magit-go-forward:                      Logging.             (line 119)
 * magit-go-forward <1>:                  Diffing.             (line 176)
-* magit-hunk-set-window-start:           Sections.            (line  61)
-* magit-ido-completing-read:             Completion Confirmation and the Selection.
-                                                              (line 363)
+* magit-hunk-set-window-start:           Sections.            (line  69)
 * magit-init:                            Creating Repository. (line   7)
-* magit-insert-am-sequence:              Status Buffer.       (line 142)
-* magit-insert-assumed-unchanged-files:  Status Buffer.       (line 249)
-* magit-insert-bisect-log:               Status Buffer.       (line 156)
-* magit-insert-bisect-output:            Status Buffer.       (line 150)
-* magit-insert-bisect-rest:              Status Buffer.       (line 153)
-* magit-insert-diff-filter-header:       Status Buffer.       (line 315)
-* magit-insert-error-header:             Status Buffer.       (line 306)
-* magit-insert-head-branch-header:       Status Buffer.       (line 318)
+* magit-insert-am-sequence:              Status Buffer.       (line 128)
+* magit-insert-assume-unchanged-files:   Status Buffer.       (line 243)
+* magit-insert-bisect-log:               Status Buffer.       (line 142)
+* magit-insert-bisect-output:            Status Buffer.       (line 136)
+* magit-insert-bisect-rest:              Status Buffer.       (line 139)
+* magit-insert-diff-filter-header:       Status Buffer.       (line 309)
+* magit-insert-error-header:             Status Buffer.       (line 300)
+* magit-insert-head-branch-header:       Status Buffer.       (line 312)
 * magit-insert-heading:                  Section Plumbing.    (line  44)
-* magit-insert-ignored-files:            Status Buffer.       (line 243)
+* magit-insert-ignored-files:            Status Buffer.       (line 237)
 * magit-insert-local-branches:           References Buffer.   (line 244)
-* magit-insert-merge-log:                Status Buffer.       (line 134)
-* magit-insert-modules:                  Status Buffer.       (line 357)
-* magit-insert-modules-overview:         Status Buffer.       (line 375)
+* magit-insert-merge-log:                Status Buffer.       (line 120)
+* magit-insert-modules:                  Status Buffer.       (line 351)
+* magit-insert-modules-overview:         Status Buffer.       (line 369)
 * magit-insert-modules-unpulled-from-pushremote: Status Buffer.
-                                                              (line 390)
-* magit-insert-modules-unpulled-from-upstream: Status Buffer. (line 385)
-* magit-insert-modules-unpushed-to-pushremote: Status Buffer. (line 400)
-* magit-insert-modules-unpushed-to-upstream: Status Buffer.   (line 395)
-* magit-insert-push-branch-header:       Status Buffer.       (line 325)
-* magit-insert-rebase-sequence:          Status Buffer.       (line 138)
-* magit-insert-recent-commits:           Status Buffer.       (line 261)
+                                                              (line 384)
+* magit-insert-modules-unpulled-from-upstream: Status Buffer. (line 379)
+* magit-insert-modules-unpushed-to-pushremote: Status Buffer. (line 394)
+* magit-insert-modules-unpushed-to-upstream: Status Buffer.   (line 389)
+* magit-insert-push-branch-header:       Status Buffer.       (line 319)
+* magit-insert-rebase-sequence:          Status Buffer.       (line 124)
+* magit-insert-recent-commits:           Status Buffer.       (line 255)
 * magit-insert-remote-branches:          References Buffer.   (line 247)
-* magit-insert-remote-header:            Status Buffer.       (line 338)
-* magit-insert-repo-header:              Status Buffer.       (line 335)
+* magit-insert-remote-header:            Status Buffer.       (line 332)
+* magit-insert-repo-header:              Status Buffer.       (line 329)
 * magit-insert-section:                  Section Plumbing.    (line   9)
-* magit-insert-sequencer-sequence:       Status Buffer.       (line 146)
-* magit-insert-skip-worktree-files:      Status Buffer.       (line 246)
-* magit-insert-staged-changes:           Status Buffer.       (line 162)
-* magit-insert-stashes:                  Status Buffer.       (line 165)
-* magit-insert-status-headers:           Status Buffer.       (line 292)
+* magit-insert-sequencer-sequence:       Status Buffer.       (line 132)
+* magit-insert-skip-worktree-files:      Status Buffer.       (line 240)
+* magit-insert-staged-changes:           Status Buffer.       (line 148)
+* magit-insert-stashes:                  Status Buffer.       (line 151)
+* magit-insert-status-headers:           Status Buffer.       (line 115)
+* magit-insert-status-headers <1>:       Status Buffer.       (line 286)
 * magit-insert-tags:                     References Buffer.   (line 250)
-* magit-insert-tags-header:              Status Buffer.       (line 329)
-* magit-insert-tracked-files:            Status Buffer.       (line 240)
-* magit-insert-unpulled-cherries:        Status Buffer.       (line 270)
-* magit-insert-unpulled-from-pushremote: Status Buffer.       (line 175)
-* magit-insert-unpulled-from-upstream:   Status Buffer.       (line 171)
-* magit-insert-unpulled-or-recent-commits: Status Buffer.     (line 255)
-* magit-insert-unpushed-cherries:        Status Buffer.       (line 276)
-* magit-insert-unpushed-to-pushremote:   Status Buffer.       (line 183)
-* magit-insert-unpushed-to-upstream:     Status Buffer.       (line 179)
-* magit-insert-unstaged-changes:         Status Buffer.       (line 159)
-* magit-insert-untracked-files:          Status Buffer.       (line 193)
-* magit-insert-upstream-branch-header:   Status Buffer.       (line 321)
-* magit-insert-user-header:              Status Buffer.       (line 345)
+* magit-insert-tags-header:              Status Buffer.       (line 323)
+* magit-insert-tracked-files:            Status Buffer.       (line 234)
+* magit-insert-unpulled-cherries:        Status Buffer.       (line 264)
+* magit-insert-unpulled-from-pushremote: Status Buffer.       (line 161)
+* magit-insert-unpulled-from-upstream:   Status Buffer.       (line 157)
+* magit-insert-unpulled-or-recent-commits: Status Buffer.     (line 249)
+* magit-insert-unpushed-cherries:        Status Buffer.       (line 270)
+* magit-insert-unpushed-to-pushremote:   Status Buffer.       (line 177)
+* magit-insert-unpushed-to-upstream:     Status Buffer.       (line 173)
+* magit-insert-unpushed-to-upstream-or-recent: Status Buffer. (line 165)
+* magit-insert-unstaged-changes:         Status Buffer.       (line 145)
+* magit-insert-untracked-files:          Status Buffer.       (line 187)
+* magit-insert-upstream-branch-header:   Status Buffer.       (line 315)
+* magit-insert-user-header:              Status Buffer.       (line 339)
 * magit-jump-to-diffstat-or-diff:        Diffing.             (line 218)
-* magit-kill-this-buffer:                Minor Mode for Buffers Visiting Blobs.
-                                                              (line  19)
 * magit-list-repositories:               Repository List.     (line   6)
 * magit-list-submodules:                 Submodules.          (line  18)
 * magit-list-submodules <1>:             Submodules.          (line  96)
@@ -10320,9 +10399,9 @@ Appendix D Function and Command Index
 * magit-log-double-commit-limit:         Logging.             (line 160)
 * magit-log-half-commit-limit:           Logging.             (line 163)
 * magit-log-head:                        Logging.             (line  38)
-* magit-log-maybe-show-more-commits:     Sections.            (line  74)
-* magit-log-maybe-update-blob-buffer:    Sections.            (line  88)
-* magit-log-maybe-update-revision-buffer: Sections.           (line  81)
+* magit-log-maybe-show-more-commits:     Sections.            (line  82)
+* magit-log-maybe-update-blob-buffer:    Sections.            (line  96)
+* magit-log-maybe-update-revision-buffer: Sections.           (line  89)
 * magit-log-merged:                      Commands for Buffers Visiting Files.
                                                               (line  52)
 * magit-log-merged <1>:                  Commands for Buffers Visiting Files.
@@ -10372,7 +10451,7 @@ Appendix D Function and Command Index
 * magit-patch-create:                    Plain Patches.       (line  12)
 * magit-patch-save:                      Plain Patches.       (line  26)
 * magit-pop-revision-stack:              Committing.          (line 347)
-* magit-process:                         Running Git.         (line  20)
+* magit-process-buffer:                  Running Git.         (line  20)
 * magit-process-file:                    Calling Git.         (line  84)
 * magit-process-git:                     Calling Git.         (line  77)
 * magit-process-kill:                    Running Git.         (line  27)
@@ -10461,43 +10540,43 @@ Appendix D Function and Command Index
 * magit-revert:                          Cherry Picking.      (line  98)
 * magit-revert-and-commit:               Cherry Picking.      (line 106)
 * magit-revert-no-commit:                Cherry Picking.      (line 111)
-* magit-run:                             Running Git.         (line  82)
-* magit-run-git:                         Calling Git.         (line 141)
-* magit-run-git-async:                   Calling Git.         (line 166)
-* magit-run-git-gui:                     Running Git.         (line 128)
-* magit-run-git-with-editor:             Calling Git.         (line 178)
-* magit-run-git-with-input:              Calling Git.         (line 144)
-* magit-run-gitk:                        Running Git.         (line 119)
-* magit-run-gitk-all:                    Running Git.         (line 122)
-* magit-run-gitk-branches:               Running Git.         (line 125)
+* magit-run:                             Running Git.         (line  85)
+* magit-run-git:                         Calling Git.         (line 144)
+* magit-run-git-async:                   Calling Git.         (line 169)
+* magit-run-git-gui:                     Running Git.         (line 131)
+* magit-run-git-with-editor:             Calling Git.         (line 181)
+* magit-run-git-with-input:              Calling Git.         (line 147)
+* magit-run-gitk:                        Running Git.         (line 122)
+* magit-run-gitk-all:                    Running Git.         (line 125)
+* magit-run-gitk-branches:               Running Git.         (line 128)
 * magit-save-window-configuration:       Modes and Buffers.   (line 112)
-* magit-section-backward:                Sections.            (line  27)
-* magit-section-backward-siblings:       Sections.            (line  35)
+* magit-section-backward:                Sections.            (line  33)
+* magit-section-backward-siblings:       Sections.            (line  41)
 * magit-section-case:                    Section Plumbing.    (line 182)
-* magit-section-cycle:                   Sections.            (line 138)
-* magit-section-cycle-diffs:             Sections.            (line 153)
-* magit-section-cycle-global:            Sections.            (line 157)
-* magit-section-forward:                 Sections.            (line  32)
-* magit-section-forward-siblings:        Sections.            (line  40)
-* magit-section-hide:                    Sections.            (line 179)
-* magit-section-hide-children:           Sections.            (line 191)
+* magit-section-cycle:                   Sections.            (line 148)
+* magit-section-cycle-diffs:             Sections.            (line 163)
+* magit-section-cycle-global:            Sections.            (line 167)
+* magit-section-forward:                 Sections.            (line  38)
+* magit-section-forward-siblings:        Sections.            (line  46)
+* magit-section-hide:                    Sections.            (line 189)
+* magit-section-hide-children:           Sections.            (line 201)
 * magit-section-ident:                   Section Plumbing.    (line 126)
 * magit-section-match:                   Section Plumbing.    (line 134)
-* magit-section-set-window-start:        Sections.            (line  68)
-* magit-section-show:                    Sections.            (line 176)
-* magit-section-show-children:           Sections.            (line 186)
-* magit-section-show-headings:           Sections.            (line 182)
-* magit-section-show-level-1:            Sections.            (line 163)
-* magit-section-show-level-1-all:        Sections.            (line 169)
-* magit-section-show-level-2:            Sections.            (line 163)
-* magit-section-show-level-2-all:        Sections.            (line 169)
-* magit-section-show-level-3:            Sections.            (line 163)
-* magit-section-show-level-3-all:        Sections.            (line 169)
-* magit-section-show-level-4:            Sections.            (line 163)
-* magit-section-show-level-4-all:        Sections.            (line 169)
-* magit-section-toggle:                  Sections.            (line 134)
-* magit-section-toggle-children:         Sections.            (line 194)
-* magit-section-up:                      Sections.            (line  44)
+* magit-section-set-window-start:        Sections.            (line  76)
+* magit-section-show:                    Sections.            (line 186)
+* magit-section-show-children:           Sections.            (line 196)
+* magit-section-show-headings:           Sections.            (line 192)
+* magit-section-show-level-1:            Sections.            (line 173)
+* magit-section-show-level-1-all:        Sections.            (line 179)
+* magit-section-show-level-2:            Sections.            (line 173)
+* magit-section-show-level-2-all:        Sections.            (line 179)
+* magit-section-show-level-3:            Sections.            (line 173)
+* magit-section-show-level-3-all:        Sections.            (line 179)
+* magit-section-show-level-4:            Sections.            (line 173)
+* magit-section-show-level-4-all:        Sections.            (line 179)
+* magit-section-toggle:                  Sections.            (line 144)
+* magit-section-toggle-children:         Sections.            (line 204)
+* magit-section-up:                      Sections.            (line  50)
 * magit-section-value-if:                Section Plumbing.    (line 173)
 * magit-sequence-abort:                  Cherry Picking.      (line  91)
 * magit-sequence-abort <1>:              Cherry Picking.      (line 126)
@@ -10505,8 +10584,8 @@ Appendix D Function and Command Index
 * magit-sequence-continue <1>:           Cherry Picking.      (line 120)
 * magit-sequence-skip:                   Cherry Picking.      (line  88)
 * magit-sequence-skip <1>:               Cherry Picking.      (line 123)
-* magit-shell-command:                   Running Git.         (line 107)
-* magit-shell-command-topdir:            Running Git.         (line 103)
+* magit-shell-command:                   Running Git.         (line 110)
+* magit-shell-command-topdir:            Running Git.         (line 106)
 * magit-show-commit:                     Diffing.             (line  82)
 * magit-show-commit <1>:                 Blaming.             (line  91)
 * magit-show-refs:                       References Buffer.   (line   7)
@@ -10536,8 +10615,8 @@ Appendix D Function and Command Index
                                                               (line  63)
 * magit-stage-modified:                  Staging and Unstaging.
                                                               (line  36)
-* magit-start-git:                       Calling Git.         (line 189)
-* magit-start-process:                   Calling Git.         (line 207)
+* magit-start-git:                       Calling Git.         (line 192)
+* magit-start-process:                   Calling Git.         (line 210)
 * magit-stash:                           Stashing.            (line   9)
 * magit-stash-apply:                     Stashing.            (line  52)
 * magit-stash-both:                      Stashing.            (line  14)
@@ -10553,15 +10632,15 @@ Appendix D Function and Command Index
 * magit-stash-show:                      Diffing.             (line  86)
 * magit-stash-show <1>:                  Stashing.            (line  98)
 * magit-stash-worktree:                  Stashing.            (line  24)
-* magit-stashes-maybe-update-stash-buffer: Sections.          (line 108)
+* magit-stashes-maybe-update-stash-buffer: Sections.          (line 116)
 * magit-status:                          Status Buffer.       (line  23)
 * magit-status-here:                     Commands for Buffers Visiting Files.
                                                               (line  52)
 * magit-status-here <1>:                 Commands for Buffers Visiting Files.
                                                               (line 166)
-* magit-status-maybe-update-blob-buffer: Sections.            (line 103)
-* magit-status-maybe-update-revision-buffer: Sections.        (line  93)
-* magit-status-maybe-update-stash-buffer: Sections.           (line  98)
+* magit-status-maybe-update-blob-buffer: Sections.            (line 111)
+* magit-status-maybe-update-revision-buffer: Sections.        (line 101)
+* magit-status-maybe-update-stash-buffer: Sections.           (line 106)
 * magit-status-quick:                    Status Buffer.       (line  70)
 * magit-submodule:                       Submodules.          (line  55)
 * magit-submodule-add:                   Submodules.          (line  68)
@@ -10612,7 +10691,7 @@ Appendix D Function and Command Index
                                                               (line  52)
 * magit-unstage-file <2>:                Commands for Buffers Visiting Files.
                                                               (line  69)
-* magit-version:                         Running Git.         (line 192)
+* magit-version:                         Running Git.         (line 195)
 * magit-version <1>:                     Debugging Tools.     (line  11)
 * magit-visit-ref:                       References Buffer.   (line 159)
 * magit-wip-commit:                      Wip Modes.           (line  85)
@@ -10663,9 +10742,9 @@ Appendix E Variable Index
 * git-commit-setup-hook:                 Committing.          (line 454)
 * git-commit-style-convention-checks:    Committing.          (line 538)
 * git-commit-summary-max-length:         Committing.          (line 513)
-* git-rebase-auto-advance:               Rebasing.            (line 197)
-* git-rebase-confirm-cancel:             Rebasing.            (line 203)
-* git-rebase-show-instructions:          Rebasing.            (line 200)
+* git-rebase-auto-advance:               Rebasing.            (line 221)
+* git-rebase-confirm-cancel:             Rebasing.            (line 227)
+* git-rebase-show-instructions:          Rebasing.            (line 224)
 * global-auto-revert-mode:               Modes and Buffers.   (line 343)
 * magit-auto-revert-immediately:         Modes and Buffers.   (line 352)
 * magit-auto-revert-mode:                Modes and Buffers.   (line 339)
@@ -10697,23 +10776,25 @@ Appendix E Variable Index
 * magit-commit-show-diff:                Committing.          (line 221)
 * magit-commit-squash-confirm:           Committing.          (line 269)
 * magit-completing-read-function:        Completion Confirmation and the Selection.
-                                                              (line 344)
+                                                              (line 340)
 * magit-define-global-key-bindings:      Essential Settings.  (line 239)
-* magit-diff-adjust-tab-width:           Diffing.             (line 247)
+* magit-diff-adjust-tab-width:           Diffing.             (line 250)
 * magit-diff-buffer-file-locked:         Commands for Buffers Visiting Files.
                                                               (line 104)
-* magit-diff-extra-stat-arguments:       Diffing.             (line 342)
-* magit-diff-hide-trailing-cr-characters: Diffing.            (line 307)
-* magit-diff-highlight-hunk-region-functions: Diffing.        (line 310)
-* magit-diff-highlight-indentation:      Diffing.             (line 293)
-* magit-diff-highlight-trailing:         Diffing.             (line 289)
-* magit-diff-paint-whitespace:           Diffing.             (line 268)
-* magit-diff-paint-whitespace-lines:     Diffing.             (line 282)
+* magit-diff-extra-stat-arguments:       Diffing.             (line 345)
+* magit-diff-hide-trailing-cr-characters: Diffing.            (line 310)
+* magit-diff-highlight-hunk-region-functions: Diffing.        (line 313)
+* magit-diff-highlight-indentation:      Diffing.             (line 296)
+* magit-diff-highlight-trailing:         Diffing.             (line 292)
+* magit-diff-paint-whitespace:           Diffing.             (line 271)
+* magit-diff-paint-whitespace-lines:     Diffing.             (line 285)
 * magit-diff-refine-hunk:                Diffing.             (line 236)
-* magit-diff-refine-ignore-whitespace:   Diffing.             (line 243)
-* magit-diff-unmarked-lines-keep-foreground: Diffing.         (line 335)
+* magit-diff-refine-ignore-whitespace:   Diffing.             (line 246)
+* magit-diff-unmarked-lines-keep-foreground: Diffing.         (line 338)
+* magit-diff-visit-prefer-worktree:      Visiting Files and Blobs.
+                                                              (line  92)
 * magit-diff-visit-previous-blob:        Visiting Files and Blobs.
-                                                              (line  66)
+                                                              (line 126)
 * magit-direct-use-buffer-arguments:     Transient Arguments and Buffer Variables.
                                                               (line  73)
 * magit-display-buffer-function:         Modes and Buffers.   (line  57)
@@ -10724,28 +10805,28 @@ Appendix E Variable Index
 * magit-ediff-dwim-show-on-hunks:        Ediffing.            (line 111)
 * magit-ediff-quit-hook:                 Ediffing.            (line 124)
 * magit-ediff-show-stash-with-index:     Ediffing.            (line 118)
-* magit-format-file-function:            Diffing.             (line 352)
+* magit-format-file-function:            Diffing.             (line 355)
 * magit-generate-buffer-name-function:   Modes and Buffers.   (line 131)
 * magit-git-debug:                       Calling Git.         (line  95)
-* magit-git-executable:                  Running Git.         (line 159)
-* magit-git-global-arguments:            Running Git.         (line 199)
+* magit-git-executable:                  Running Git.         (line 162)
+* magit-git-global-arguments:            Running Git.         (line 202)
 * magit-keep-region-overlay:             Completion Confirmation and the Selection.
                                                               (line 294)
 * magit-list-refs-sortby:                Completion Confirmation and the Selection.
-                                                              (line 415)
+                                                              (line 404)
 * magit-log-auto-more:                   Logging.             (line 165)
 * magit-log-buffer-file-locked:          Commands for Buffers Visiting Files.
                                                               (line 124)
 * magit-log-margin:                      Logging.             (line 223)
 * magit-log-margin-show-committer-date:  Logging.             (line 255)
-* magit-log-section-commit-count:        Status Buffer.       (line 265)
+* magit-log-section-commit-count:        Status Buffer.       (line 259)
 * magit-log-select-margin:               Logging.             (line 304)
 * magit-log-show-color-graph-limit:      Logging.             (line 174)
 * magit-log-show-refname-after-summary:  Logging.             (line 170)
 * magit-log-show-signatures-limit:       Logging.             (line 180)
 * magit-log-trace-definition-function:   Diffing.             (line 192)
-* magit-module-sections-hook:            Status Buffer.       (line 364)
-* magit-module-sections-nested:          Status Buffer.       (line 367)
+* magit-module-sections-hook:            Status Buffer.       (line 358)
+* magit-module-sections-nested:          Status Buffer.       (line 361)
 * magit-no-confirm:                      Completion Confirmation and the Selection.
                                                               (line  21)
 * magit-pop-revision-stack-format:       Committing.          (line 374)
@@ -10756,7 +10837,7 @@ Appendix E Variable Index
 * magit-prefer-remote-upstream:          Branching.           (line 431)
 * magit-prefix-use-buffer-arguments:     Transient Arguments and Buffer Variables.
                                                               (line  65)
-* magit-process-raise-error:             Calling Git.         (line 232)
+* magit-process-raise-error:             Calling Git.         (line 235)
 * magit-pull-or-fetch:                   Fetching.            (line  52)
 * magit-reflog-margin:                   Logging.             (line 344)
 * magit-refresh-args:                    Refreshing Buffers.  (line  52)
@@ -10774,34 +10855,34 @@ Appendix E Variable Index
 * magit-refs-show-remote-prefix:         References Buffer.   (line  57)
 * magit-remote-add-set-remote.pushDefault: Remotes.           (line  86)
 * magit-remote-direct-configure:         Remotes.             (line  23)
-* magit-remote-git-executable:           Running Git.         (line 165)
+* magit-remote-git-executable:           Running Git.         (line 168)
 * magit-repolist-columns:                Repository List.     (line  12)
 * magit-repository-directories:          Status Buffer.       (line  57)
-* magit-revision-filter-files-on-follow: Diffing.             (line 412)
-* magit-revision-insert-related-refs:    Diffing.             (line 363)
-* magit-revision-show-gravatars:         Diffing.             (line 372)
-* magit-revision-use-hash-sections:      Diffing.             (line 388)
+* magit-revision-filter-files-on-follow: Diffing.             (line 415)
+* magit-revision-insert-related-refs:    Diffing.             (line 366)
+* magit-revision-show-gravatars:         Diffing.             (line 375)
+* magit-revision-use-hash-sections:      Diffing.             (line 391)
 * magit-root-section:                    Section Plumbing.    (line 197)
 * magit-save-repository-buffers:         Modes and Buffers.   (line 314)
-* magit-section-cache-visibility:        Sections.            (line 219)
-* magit-section-initial-visibility-alist: Sections.           (line 203)
-* magit-section-movement-hook:           Sections.            (line  57)
-* magit-section-set-visibility-hook:     Sections.            (line 229)
-* magit-section-show-child-count:        Sections.            (line 356)
-* magit-section-visibility-indicator:    Sections.            (line 246)
-* magit-shell-command-verbose-prompt:    Running Git.         (line 112)
+* magit-section-cache-visibility:        Sections.            (line 229)
+* magit-section-initial-visibility-alist: Sections.           (line 213)
+* magit-section-movement-hook:           Sections.            (line  63)
+* magit-section-set-visibility-hook:     Sections.            (line 239)
+* magit-section-show-child-count:        Sections.            (line 366)
+* magit-section-visibility-indicator:    Sections.            (line 256)
+* magit-shell-command-verbose-prompt:    Running Git.         (line 115)
 * magit-stashes-margin:                  Stashing.            (line 119)
-* magit-status-file-list-limit:          Status Buffer.       (line 230)
-* magit-status-headers-hook:             Status Buffer.       (line 297)
-* magit-status-margin:                   Status Buffer.       (line 408)
-* magit-status-sections-hook:            Status Buffer.       (line 122)
-* magit-status-show-untracked-files:     Status Buffer.       (line 197)
+* magit-status-file-list-limit:          Status Buffer.       (line 224)
+* magit-status-headers-hook:             Status Buffer.       (line 291)
+* magit-status-margin:                   Status Buffer.       (line 402)
+* magit-status-sections-hook:            Status Buffer.       (line 103)
+* magit-status-show-untracked-files:     Status Buffer.       (line 191)
 * magit-submodule-list-columns:          Submodules.          (line  25)
-* magit-this-process:                    Calling Git.         (line 228)
+* magit-this-process:                    Calling Git.         (line 231)
 * magit-uniquify-buffer-names:           Modes and Buffers.   (line 190)
 * magit-unstage-committed:               Staging and Unstaging.
                                                               (line  52)
-* magit-update-other-window-delay:       Sections.            (line 113)
+* magit-update-other-window-delay:       Sections.            (line 121)
 * magit-visit-ref-behavior:              References Buffer.   (line 168)
 * magit-wip-after-apply-mode:            Wip Modes.           (line 172)
 * magit-wip-after-apply-mode-lighter:    Wip Modes.           (line 208)
@@ -10832,179 +10913,179 @@ Node: Introduction3572
 Node: Installation8288
 Node: Installing from Melpa8618
 Node: Installing from the Git Repository9693
-Node: Post-Installation Tasks12745
-Node: Getting Started14028
-Node: Interface Concepts19839
-Node: Modes and Buffers20218
-Ref: Switching Buffers21720
-Ref: Naming Buffers26366
-Ref: Quitting Windows29323
-Ref: Automatic Refreshing of Magit Buffers31120
-Ref: Automatic Saving of File-Visiting Buffers33836
-Ref: Automatic Reverting of File-Visiting Buffers34827
-Ref: Risk of Reverting Automatically39619
-Node: Sections41890
-Ref: Section Movement42695
-Ref: Section Visibility47482
-Ref: Section Hooks54060
-Ref: Section Types and Values56349
-Ref: Section Options57650
-Node: Transient Commands58029
-Node: Transient Arguments and Buffer Variables59505
-Node: Completion Confirmation and the Selection66522
-Ref: Action Confirmation66783
-Ref: Completion and Confirmation75156
-Ref: The Selection78187
-Ref: The hunk-internal region80926
-Ref: Support for Completion Frameworks81850
-Ref: Additional Completion Options86554
-Node: Mouse Support87004
-Node: Running Git87580
-Ref: Viewing Git Output87700
-Ref: Git Process Status89591
-Ref: Running Git Manually90435
-Ref: Git Executable93008
-Ref: Global Git Arguments95897
-Node: Inspecting96612
-Node: Status Buffer97769
-Ref: Status Sections102677
-Ref: Status File List Sections105404
-Ref: Status Log Sections107981
-Ref: Status Header Sections109331
-Ref: Status Module Sections111824
-Ref: Status Options114196
-Node: Repository List115465
-Node: Logging120243
-Ref: Refreshing Logs122978
-Ref: Log Buffer124322
-Ref: Log Margin129049
-Ref: Select from Log132106
-Ref: Reflog134224
-Ref: Cherries135771
-Node: Diffing137543
-Ref: Refreshing Diffs141494
-Ref: Commands Available in Diffs145088
-Ref: Diff Options147485
-Ref: Revision Buffer153283
-Node: Ediffing156524
-Node: References Buffer162574
-Ref: References Sections173134
-Node: Bisecting173919
-Node: Visiting Files and Blobs176230
-Ref: General-Purpose Visit Commands176672
-Ref: Visiting Files and Blobs from a Diff177490
-Node: Blaming180722
-Node: Manipulating187710
-Node: Creating Repository188052
-Node: Cloning Repository188589
-Node: Staging and Unstaging195030
-Ref: Staging from File-Visiting Buffers198954
-Node: Applying199969
-Node: Committing202042
-Ref: Initiating a Commit202669
-Ref: Creating a new commit202981
-Ref: Editing the last commit203091
-Ref: Editing any reachable commit205070
-Ref: Editing any reachable commit and rebasing immediately209483
-Ref: Options used by commit commands211131
-Ref: Used by all or most commit commands211203
-Ref: Used by all squash and fixup commands213434
-Ref: Used by specific commit commands213982
-Ref: Editing Commit Messages214306
-Ref: Using the Revision Stack216860
-Ref: Commit Pseudo Headers219792
-Ref: Commit Mode and Hooks220944
-Ref: Commit Message Conventions223657
-Node: Branching225529
-Ref: The Two Remotes225650
-Ref: Branch Commands228219
-Ref: Branch Git Variables240956
-Ref: Auxiliary Branch Commands246203
-Node: Merging247220
-Node: Resolving Conflicts251380
-Node: Rebasing256754
-Ref: Editing Rebase Sequences261714
-Ref: Information About In-Progress Rebase265875
-Ref: Rebasing-Footnote-1274875
-Node: Cherry Picking275471
-Ref: Reverting279781
-Node: Resetting281141
-Node: Stashing282967
-Node: Transferring289208
-Node: Remotes289430
-Ref: Remote Commands289527
-Ref: Remote Git Variables293479
-Node: Fetching294663
-Node: Pulling297146
-Node: Pushing298172
-Node: Plain Patches302463
-Node: Maildir Patches303934
-Node: Miscellaneous305413
-Node: Tagging305759
-Node: Notes307652
-Node: Submodules309987
-Ref: Listing Submodules310148
-Ref: Submodule Transient312204
-Node: Subtree314557
-Node: Worktree316488
-Node: Sparse checkouts317564
-Node: Bundle320340
-Node: Common Commands320715
-Node: Wip Modes323343
-Ref: Wip Graph328189
-Ref: Legacy Wip Modes330423
-Node: Commands for Buffers Visiting Files333231
-Node: Minor Mode for Buffers Visiting Blobs341458
-Node: Customizing342256
-Node: Per-Repository Configuration343852
-Node: Essential Settings346106
-Ref: Safety346395
-Ref: Performance348076
-Ref: Log Performance350869
-Ref: Diff Performance352174
-Ref: Refs Buffer Performance353515
-Ref: Committing Performance354090
-Ref: Microsoft Windows Performance355072
-Ref: MacOS Performance356161
-Ref: Global Bindings357046
-Ref: Essential Settings-Footnote-1359221
-Node: Plumbing359303
-Node: Calling Git360132
-Ref: Getting a Value from Git361591
-Ref: Calling Git for Effect365217
-Node: Section Plumbing371009
-Ref: Creating Sections371161
-Ref: Section Selection374962
-Ref: Matching Sections376637
-Node: Refreshing Buffers382463
-Node: Conventions385607
-Ref: Theming Faces385771
-Node: FAQ393816
-Node: FAQ - How to ...?394254
-Ref: How to pronounce Magit?394387
-Ref: How to show git's output?395081
-Ref: How to install the gitman info manual?395706
-Ref: How to show diffs for gpg-encrypted files?396517
-Ref: How does branching and pushing work?396926
-Ref: Should I disable VC?397090
-Node: FAQ - Issues and Errors397575
-Ref: Magit is slow397720
-Ref: I changed several thousand files at once and now Magit is unusable397866
-Ref: I am having problems committing398405
-Ref: I am using MS Windows and cannot push with Magit398670
-Ref: I am using macOS and SOMETHING works in shell but not in Magit399070
-Ref: Expanding a file to show the diff causes it to disappear399661
-Ref: Point is wrong in the COMMIT_EDITMSG buffer400011
-Ref: The mode-line information isn't always up-to-date400835
-Ref: A branch and tag sharing the same name breaks SOMETHING401674
-Ref: My Git hooks work on the command-line but not inside Magit402322
-Ref: git-commit-mode isn't used when committing from the command-line402914
-Ref: Point ends up inside invisible text when jumping to a file-visiting buffer404912
-Ref: I am no longer able to save popup defaults405504
-Node: Debugging Tools406301
-Node: Keystroke Index410240
-Node: Function and Command Index448190
-Node: Variable Index499700
+Node: Post-Installation Tasks12890
+Node: Getting Started14173
+Node: Interface Concepts19984
+Node: Modes and Buffers20363
+Ref: Switching Buffers21865
+Ref: Naming Buffers26511
+Ref: Quitting Windows29468
+Ref: Automatic Refreshing of Magit Buffers31265
+Ref: Automatic Saving of File-Visiting Buffers33981
+Ref: Automatic Reverting of File-Visiting Buffers34972
+Ref: Risk of Reverting Automatically39764
+Node: Sections42035
+Ref: Section Movement42840
+Ref: Section Visibility48212
+Ref: Section Hooks54790
+Ref: Section Types and Values57079
+Ref: Section Options58380
+Node: Transient Commands58759
+Node: Transient Arguments and Buffer Variables60235
+Node: Completion Confirmation and the Selection67252
+Ref: Action Confirmation67513
+Ref: Completion and Confirmation75886
+Ref: The Selection78917
+Ref: The hunk-internal region81656
+Ref: Support for Completion Frameworks82580
+Ref: Additional Completion Options86649
+Node: Mouse Support87099
+Node: Running Git87675
+Ref: Viewing Git Output87795
+Ref: Git Process Status89701
+Ref: Running Git Manually90799
+Ref: Git Executable93372
+Ref: Global Git Arguments96261
+Node: Inspecting96976
+Node: Status Buffer98133
+Ref: Status Sections102265
+Ref: Status File List Sections105723
+Ref: Status Log Sections108297
+Ref: Status Header Sections109647
+Ref: Status Module Sections112140
+Ref: Status Options114512
+Node: Repository List115781
+Node: Logging120559
+Ref: Refreshing Logs123294
+Ref: Log Buffer124638
+Ref: Log Margin129365
+Ref: Select from Log132422
+Ref: Reflog134540
+Ref: Cherries136087
+Node: Diffing137859
+Ref: Refreshing Diffs141810
+Ref: Commands Available in Diffs145404
+Ref: Diff Options147801
+Ref: Revision Buffer153785
+Node: Ediffing157026
+Node: References Buffer163076
+Ref: References Sections173636
+Node: Bisecting174421
+Node: Visiting Files and Blobs176732
+Ref: General-Purpose Visit Commands177174
+Ref: Visiting Files and Blobs from a Diff177992
+Node: Blaming183246
+Node: Manipulating190234
+Node: Creating Repository190576
+Node: Cloning Repository191113
+Node: Staging and Unstaging197554
+Ref: Staging from File-Visiting Buffers201478
+Node: Applying202493
+Node: Committing204566
+Ref: Initiating a Commit205193
+Ref: Creating a new commit205505
+Ref: Editing the last commit205615
+Ref: Editing any reachable commit207594
+Ref: Editing any reachable commit and rebasing immediately212007
+Ref: Options used by commit commands213655
+Ref: Used by all or most commit commands213727
+Ref: Used by all squash and fixup commands215958
+Ref: Used by specific commit commands216506
+Ref: Editing Commit Messages216830
+Ref: Using the Revision Stack219384
+Ref: Commit Pseudo Headers222316
+Ref: Commit Mode and Hooks223468
+Ref: Commit Message Conventions226181
+Node: Branching228053
+Ref: The Two Remotes228174
+Ref: Branch Commands230743
+Ref: Branch Git Variables243481
+Ref: Auxiliary Branch Commands248728
+Node: Merging249745
+Node: Resolving Conflicts253905
+Node: Rebasing259279
+Ref: Editing Rebase Sequences264239
+Ref: Information About In-Progress Rebase269472
+Ref: Rebasing-Footnote-1278472
+Node: Cherry Picking279068
+Ref: Reverting283378
+Node: Resetting284738
+Node: Stashing286564
+Node: Transferring292805
+Node: Remotes293027
+Ref: Remote Commands293124
+Ref: Remote Git Variables297076
+Node: Fetching298260
+Node: Pulling300743
+Node: Pushing301769
+Node: Plain Patches306060
+Node: Maildir Patches307531
+Node: Miscellaneous309010
+Node: Tagging309356
+Node: Notes311249
+Node: Submodules313584
+Ref: Listing Submodules313745
+Ref: Submodule Transient315801
+Node: Subtree318154
+Node: Worktree320085
+Node: Sparse checkouts321161
+Node: Bundle323937
+Node: Common Commands324312
+Node: Wip Modes326940
+Ref: Wip Graph331786
+Ref: Legacy Wip Modes334020
+Node: Commands for Buffers Visiting Files336828
+Node: Minor Mode for Buffers Visiting Blobs345169
+Node: Customizing346332
+Node: Per-Repository Configuration347928
+Node: Essential Settings350182
+Ref: Safety350471
+Ref: Performance352152
+Ref: Log Performance354945
+Ref: Diff Performance356250
+Ref: Refs Buffer Performance357591
+Ref: Committing Performance358166
+Ref: Microsoft Windows Performance359148
+Ref: MacOS Performance360237
+Ref: Global Bindings361122
+Ref: Essential Settings-Footnote-1363297
+Node: Plumbing363379
+Node: Calling Git364208
+Ref: Getting a Value from Git365667
+Ref: Calling Git for Effect369293
+Node: Section Plumbing375197
+Ref: Creating Sections375349
+Ref: Section Selection379150
+Ref: Matching Sections380825
+Node: Refreshing Buffers386651
+Node: Conventions389795
+Ref: Theming Faces389959
+Node: FAQ398004
+Node: FAQ - How to ...?398442
+Ref: How to pronounce Magit?398575
+Ref: How to show git's output?399269
+Ref: How to install the gitman info manual?399894
+Ref: How to show diffs for gpg-encrypted files?400705
+Ref: How does branching and pushing work?401114
+Ref: Should I disable VC?401278
+Node: FAQ - Issues and Errors401763
+Ref: Magit is slow401908
+Ref: I changed several thousand files at once and now Magit is unusable402054
+Ref: I am having problems committing402593
+Ref: I am using MS Windows and cannot push with Magit402858
+Ref: I am using macOS and SOMETHING works in shell but not in Magit403258
+Ref: Expanding a file to show the diff causes it to disappear403849
+Ref: Point is wrong in the COMMIT_EDITMSG buffer404199
+Ref: The mode-line information isn't always up-to-date405023
+Ref: A branch and tag sharing the same name breaks SOMETHING405862
+Ref: My Git hooks work on the command-line but not inside Magit406510
+Ref: git-commit-mode isn't used when committing from the command-line407102
+Ref: Point ends up inside invisible text when jumping to a file-visiting buffer409100
+Ref: I am no longer able to save popup defaults409692
+Node: Debugging Tools410489
+Node: Keystroke Index414428
+Node: Function and Command Index452524
+Node: Variable Index504096
 
 End Tag Table
 
diff --git a/elpa/magit-section-20250518.653/dir b/elpa/magit-section-20251027.1634/dir
similarity index 100%
rename from elpa/magit-section-20250518.653/dir
rename to elpa/magit-section-20251027.1634/dir
diff --git a/elpa/magit-section-20250518.653/magit-section-autoloads.el b/elpa/magit-section-20251027.1634/magit-section-autoloads.el
similarity index 100%
rename from elpa/magit-section-20250518.653/magit-section-autoloads.el
rename to elpa/magit-section-20251027.1634/magit-section-autoloads.el
diff --git a/elpa/magit-section-20250518.653/magit-section-pkg.el b/elpa/magit-section-20251027.1634/magit-section-pkg.el
similarity index 55%
rename from elpa/magit-section-20250518.653/magit-section-pkg.el
rename to elpa/magit-section-20251027.1634/magit-section-pkg.el
index 4378ce88..ff472196 100644
--- a/elpa/magit-section-20250518.653/magit-section-pkg.el
+++ b/elpa/magit-section-20251027.1634/magit-section-pkg.el
@@ -1,13 +1,14 @@
 ;; -*- no-byte-compile: t; lexical-binding: nil -*-
-(define-package "magit-section" "20250518.653"
+(define-package "magit-section" "20251027.1634"
   "Sections for read-only buffers."
-  '((emacs  "27.1")
-    (compat "30.0.2.0")
-    (llama  "0.6.1")
-    (seq    "2.24"))
+  '((emacs    "28.1")
+    (compat   "30.1")
+    (cond-let "0.1")
+    (llama    "1.0")
+    (seq      "2.24"))
   :url "https://github.com/magit/magit"
-  :commit "c556fee1bd3ccc44da9f2322ec17dc5c3f0ef5be"
-  :revdesc "c556fee1bd3c"
+  :commit "c58fc97c0ae53647148a3b490765d0a02fcb00ce"
+  :revdesc "c58fc97c0ae5"
   :keywords '("tools")
   :authors '(("Jonas Bernoulli" . "emacs.magit@jonas.bernoulli.dev"))
   :maintainers '(("Jonas Bernoulli" . "emacs.magit@jonas.bernoulli.dev")))
diff --git a/elpa/magit-section-20250518.653/magit-section.el b/elpa/magit-section-20251027.1634/magit-section.el
similarity index 87%
rename from elpa/magit-section-20250518.653/magit-section.el
rename to elpa/magit-section-20251027.1634/magit-section.el
index 9cec925e..90b1f366 100644
--- a/elpa/magit-section-20250518.653/magit-section.el
+++ b/elpa/magit-section-20251027.1634/magit-section.el
@@ -8,13 +8,14 @@
 ;; Homepage: https://github.com/magit/magit
 ;; Keywords: tools
 
-;; Package-Version: 20250518.653
-;; Package-Revision: c556fee1bd3c
+;; Package-Version: 20251027.1634
+;; Package-Revision: c58fc97c0ae5
 ;; Package-Requires: (
-;;     (emacs "27.1")
-;;     (compat "30.0.2.0")
-;;     (llama "0.6.1")
-;;     (seq "2.24"))
+;;     (emacs   "28.1")
+;;     (compat  "30.1")
+;;     (cond-let "0.1")
+;;     (llama    "1.0")
+;;     (seq      "2.24"))
 
 ;; SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -45,8 +46,9 @@
 
 (require 'cl-lib)
 (require 'compat)
+(require 'cond-let)
 (require 'eieio)
-(require 'llama)
+(require 'llama) ; For (##these ...) see M-x describe-function RET # # RET.
 (require 'subr-x)
 
 ;; For older Emacs releases we depend on an updated `seq' release from GNU
@@ -107,7 +109,8 @@ similar defect.")
 
 (defvar magit-section-movement-hook nil
   "Hook run by `magit-section-goto'.
-That function in turn is used by all section movement commands.")
+That function in turn is used by all section movement commands.
+See also info node `(magit)Section Movement'.")
 
 (defvar magit-section-set-visibility-hook
   (list #'magit-section-cached-visibility)
@@ -199,7 +202,7 @@ entries of this alist."
   "Whether and how to indicate that a section can be expanded/collapsed.
 
 If nil, then don't show any indicators.
-Otherwise the value has to have one of these two forms:
+Otherwise the value has to have one of these three forms:
 
 \(EXPANDABLE-BITMAP . COLLAPSIBLE-BITMAP)
 
@@ -210,6 +213,11 @@ Otherwise the value has to have one of these two forms:
   To provide extra padding around the indicator, set
   `left-fringe-width' in `magit-mode-hook'.
 
+\(EXPANDABLE-CHAR . COLLAPSIBLE-CHAR)
+
+  In this case every section that can be expanded or collapsed
+  gets an indicator in the left margin.
+
 \(STRING . BOOLEAN)
 
   In this case STRING (usually an ellipsis) is shown at the end
@@ -222,17 +230,23 @@ Otherwise the value has to have one of these two forms:
   :group 'magit-section
   :type '(choice (const :tag "No indicators" nil)
                  (cons  :tag "Use +- fringe indicators"
-                        (const magit-fringe-bitmap+)
-                        (const magit-fringe-bitmap-))
+                        :format "%{%t%}%v\n"
+                        (const :format " " magit-fringe-bitmap+)
+                        (const :format " " magit-fringe-bitmap-))
                  (cons  :tag "Use >v fringe indicators"
-                        (const magit-fringe-bitmap>)
-                        (const magit-fringe-bitmapv))
-                 (cons  :tag "Use bold >v fringe indicators)"
-                        (const magit-fringe-bitmap-bold>)
-                        (const magit-fringe-bitmap-boldv))
+                        :format "%{%t%}%v\n"
+                        (const :format " " magit-fringe-bitmap>)
+                        (const :format " " magit-fringe-bitmapv))
+                 (cons  :tag "Use bold >v fringe indicators"
+                        :format "%{%t%}%v\n"
+                        (const :format " " magit-fringe-bitmap-bold>)
+                        (const :format " " magit-fringe-bitmap-boldv))
                  (cons  :tag "Use custom fringe indicators"
                         (variable :tag "Expandable bitmap variable")
                         (variable :tag "Collapsible bitmap variable"))
+                 (cons  :tag "Use margin indicators"
+                        (character :tag "Expandable char" ?+)
+                        (character :tag "Collapsible char" ?-))
                  (cons  :tag "Use ellipses at end of headings"
                         (string :tag "Ellipsis" "…")
                         (choice :tag "Use face kludge"
@@ -290,22 +304,13 @@ but that ship has sailed, thus this option."
   :group 'magit-section
   :type 'boolean)
 
-(defcustom magit-section-show-context-menu-for-emacs<28 nil
-  "Whether `mouse-3' shows a context menu for Emacs < 28.
-
-This has to be set before loading `magit-section' or it has
-no effect.  This also has no effect for Emacs >= 28, where
-`context-menu-mode' should be enabled instead."
-  :package-version '(magit-section . "4.0.0")
-  :group 'magit-section
-  :type 'boolean)
-
 ;;; Variables
 
 (defvar-local magit-section-preserve-visibility t)
 
 (defvar-local magit-section-pre-command-region-p nil)
 (defvar-local magit-section-pre-command-section nil)
+
 (defvar-local magit-section-highlight-force-update nil)
 (defvar-local magit-section-highlight-overlays nil)
 (defvar-local magit-section-selection-overlays nil)
@@ -367,6 +372,24 @@ no effect.  This also has no effect for Emacs >= 28, where
   "Face used for child counts at the end of some section headings."
   :group 'magit-section-faces)
 
+(defface magit-left-margin '((t :inherit default))
+  "Face used for the left margin.
+
+Currently this is only used for section visibility indicators, and only
+when `magit-section-visibility-indicator' is configured to show them in
+the margin.
+
+Due to limitations of how the margin works in Emacs, this is only used
+for those parts of the margin that actually display an indicator.  For
+that reason you should probably avoid setting the background color.
+
+Reasonable values include ((t)), which causes the indicator to inherit
+the look of the heading (including section highlighting, if any), and
+\((t :inherit default), which prevents that and causes the margin to
+look like regular un-styled text in the buffer.  Building on that, you
+can make it look different, e.g., ((t :inherit default :weight bold)."
+  :group 'magit-section-faces)
+
 ;;; Classes
 
 (defvar magit--current-section-hook nil
@@ -398,49 +421,36 @@ no effect.  This also has no effect for Emacs >= 28, where
 (defvar-keymap magit-section-heading-map
   :doc "Keymap used in the heading line of all expandable sections.
 This keymap is used in addition to the section-specific keymap, if any."
-  "<double-down-mouse-1>" #'ignore
-  "<double-mouse-1>" #'magit-mouse-toggle-section
-  "<double-mouse-2>" #'magit-mouse-toggle-section)
-
-(defvar magit-section-mode-map
-  (let ((map (make-keymap)))
-    (suppress-keymap map t)
-    (when (and magit-section-show-context-menu-for-emacs<28
-               (< emacs-major-version 28))
-      (keymap-set map "<mouse-3>" nil)
-      (keymap-set
-       map "<down-mouse-3>"
-       `( menu-item "" ,(make-sparse-keymap)
-          :filter ,(lambda (_)
-                     (let ((menu (make-sparse-keymap)))
-                       (if (fboundp 'context-menu-local)
-                           (context-menu-local menu last-input-event)
-                         (magit--context-menu-local menu last-input-event))
-                       (magit-section-context-menu menu last-input-event)
-                       menu)))))
-    (keymap-set map "<left-fringe> <mouse-1>" #'magit-mouse-toggle-section)
-    (keymap-set map "<left-fringe> <mouse-2>" #'magit-mouse-toggle-section)
-    (keymap-set map "TAB"       #'magit-section-toggle)
-    (keymap-set map "C-c TAB"   #'magit-section-cycle)
-    (keymap-set map "C-<tab>"   #'magit-section-cycle)
-    (keymap-set map "M-<tab>"   #'magit-section-cycle)
-    ;; <backtab> is the most portable binding for Shift+Tab.
-    (keymap-set map "<backtab>" #'magit-section-cycle-global)
-    (keymap-set map   "^" #'magit-section-up)
-    (keymap-set map   "p" #'magit-section-backward)
-    (keymap-set map   "n" #'magit-section-forward)
-    (keymap-set map "M-p" #'magit-section-backward-sibling)
-    (keymap-set map "M-n" #'magit-section-forward-sibling)
-    (keymap-set map   "1" #'magit-section-show-level-1)
-    (keymap-set map   "2" #'magit-section-show-level-2)
-    (keymap-set map   "3" #'magit-section-show-level-3)
-    (keymap-set map   "4" #'magit-section-show-level-4)
-    (keymap-set map "M-1" #'magit-section-show-level-1-all)
-    (keymap-set map "M-2" #'magit-section-show-level-2-all)
-    (keymap-set map "M-3" #'magit-section-show-level-3-all)
-    (keymap-set map "M-4" #'magit-section-show-level-4-all)
-    map)
-  "Parent keymap for all keymaps of modes derived from `magit-section-mode'.")
+  "<double-down-mouse-1>"   #'ignore
+  "<double-mouse-1>"        #'magit-mouse-toggle-section
+  "<double-mouse-2>"        #'magit-mouse-toggle-section
+  "<left-margin> <mouse-1>" #'magit-mouse-toggle-section)
+
+(defvar-keymap magit-section-mode-map
+  :doc "Parent keymap for keymaps of modes derived from `magit-section-mode'."
+  :full t
+  :suppress t
+  "<left-fringe> <mouse-1>" #'magit-mouse-toggle-section
+  "<left-fringe> <mouse-2>" #'magit-mouse-toggle-section
+  "TAB"       #'magit-section-toggle
+  "C-c TAB"   #'magit-section-cycle
+  "C-<tab>"   #'magit-section-cycle
+  "M-<tab>"   #'magit-section-cycle
+  ;; <backtab> is the most portable binding for Shift+Tab.
+  "<backtab>" #'magit-section-cycle-global
+  "^"   #'magit-section-up
+  "p"   #'magit-section-backward
+  "n"   #'magit-section-forward
+  "M-p" #'magit-section-backward-sibling
+  "M-n" #'magit-section-forward-sibling
+  "1"   #'magit-section-show-level-1
+  "2"   #'magit-section-show-level-2
+  "3"   #'magit-section-show-level-3
+  "4"   #'magit-section-show-level-4
+  "M-1" #'magit-section-show-level-1-all
+  "M-2" #'magit-section-show-level-2-all
+  "M-3" #'magit-section-show-level-3-all
+  "M-4" #'magit-section-show-level-4-all)
 
 (define-derived-mode magit-section-mode special-mode "Magit-Sections"
   "Parent major mode from which major modes with Magit-like sections inherit.
@@ -451,11 +461,9 @@ Magit-Section is documented in info node `(magit-section)'."
   (buffer-disable-undo)
   (setq truncate-lines t)
   (setq buffer-read-only t)
-  (setq-local line-move-visual t) ; see #1771
-  ;; Turn off syntactic font locking, but not by setting
-  ;; `font-lock-defaults' because that would enable font locking, and
-  ;; not all magit plugins may be ready for that (see #3950).
-  (setq-local font-lock-syntactic-face-function #'ignore)
+  (setq-local line-move-visual t) ; See #1771.
+  ;; Turn off syntactic font locking.  See #5420.
+  (setq-local font-lock-defaults '(nil t))
   (setq show-trailing-whitespace nil)
   (setq-local symbol-overlay-inhibit-map t)
   (setq list-buffers-directory (abbreviate-file-name default-directory))
@@ -543,8 +551,13 @@ the click occurred.  Otherwise return the section at point."
 The return value has the form ((TYPE . VALUE)...)."
   (cons (cons (oref section type)
               (magit-section-ident-value section))
-        (and-let* ((parent (oref section parent)))
-          (magit-section-ident parent))))
+        (and$ (oref section parent)
+              (magit-section-ident $))))
+
+(defun magit-section-equal (a b)
+  "Return t if A an B are the same section."
+  (and a b (equal (magit-section-ident a)
+                  (magit-section-ident b))))
 
 (cl-defgeneric magit-section-ident-value (object)
   "Return OBJECT's value, making it constant and unique if necessary.
@@ -599,8 +612,8 @@ instead of in the one whose root `magit-root-section' is."
 If optional RAW is non-nil, return a list of section objects, beginning
 with SECTION, otherwise return a list of section types."
   (cons (if raw section (oref section type))
-        (and-let* ((parent (oref section parent)))
-          (magit-section-lineage parent raw))))
+        (and$ (oref section parent)
+              (magit-section-lineage $ raw))))
 
 (defvar-local magit-insert-section--current nil "For internal use only.")
 (defvar-local magit-insert-section--parent  nil "For internal use only.")
@@ -631,17 +644,17 @@ with SECTION, otherwise return a list of section types."
         `(menu-item
           ,(if (oref section hidden) "Expand section" "Collapse section")
           magit-section-toggle))
-      (when-let (((not (oref section hidden)))
-                 (children (oref section children)))
-        (when (seq-some #'magit-section-content-p children)
-          (when (seq-some (##oref % hidden) children)
-            (keymap-set-after menu "<magit-section-show-children>"
-              `(menu-item "Expand children"
-                          magit-section-show-children)))
-          (when (seq-some (##not (oref % hidden)) children)
-            (keymap-set-after menu "<magit-section-hide-children>"
-              `(menu-item "Collapse children"
-                          magit-section-hide-children)))))
+      (when-let* ((_(not (oref section hidden)))
+                  (children (oref section children))
+                  (_(seq-some #'magit-section-content-p children)))
+        (when (seq-some (##oref % hidden) children)
+          (keymap-set-after menu "<magit-section-show-children>"
+            `(menu-item "Expand children"
+                        magit-section-show-children)))
+        (when (seq-some (##not (oref % hidden)) children)
+          (keymap-set-after menu "<magit-section-hide-children>"
+            `(menu-item "Collapse children"
+                        magit-section-hide-children))))
       (keymap-set-after menu "<separator-magit-1>" menu-bar-separator))
     (keymap-set-after menu "<magit-describe-section>"
       `(menu-item "Describe section" magit-describe-section))
@@ -655,9 +668,7 @@ with SECTION, otherwise return a list of section types."
                     (when (consp binding)
                       (define-key-after menu (vector key)
                         (copy-sequence binding))))
-                  (if (fboundp 'menu-bar-keymap)
-                      (menu-bar-keymap map)
-                    (magit--menu-bar-keymap map)))))
+                  (menu-bar-keymap map))))
   menu)
 
 (defun magit-menu-item (desc def &optional props)
@@ -680,11 +691,11 @@ See `magit-menu-format-desc'."
   (or (ignore-errors
         (save-excursion
           (goto-char (magit-menu-position))
-          (and-let* ((key (cl-find-if-not
-                           (lambda (key)
-                             (string-match-p "\\`<[0-9]+>\\'"
-                                             (key-description key)))
-                           (where-is-internal def))))
+          (and-let ((key (cl-find-if-not
+                          (lambda (key)
+                            (string-match-p "\\`<[0-9]+>\\'"
+                                            (key-description key)))
+                          (where-is-internal def))))
             (key-description key))))
       ""))
 
@@ -698,14 +709,15 @@ then return nil."
 
 (defun magit-menu-highlight-point-section ()
   (setq magit-section-highlight-force-update t)
-  (if (eq (current-buffer) magit--context-menu-buffer)
-      (setq magit--context-menu-section nil)
-    (if-let ((window (get-buffer-window magit--context-menu-buffer)))
-        (with-selected-window window
-          (setq magit--context-menu-section nil)
-          (magit-section-update-highlight))
-      (with-current-buffer magit--context-menu-buffer
-        (setq magit--context-menu-section nil))))
+  (cond-let
+    ((eq (current-buffer) magit--context-menu-buffer)
+     (setq magit--context-menu-section nil))
+    ([window (get-buffer-window magit--context-menu-buffer)]
+     (with-selected-window window
+       (setq magit--context-menu-section nil)
+       (magit-section-update-highlight)))
+    ((with-current-buffer magit--context-menu-buffer
+       (setq magit--context-menu-section nil))))
   (setq magit--context-menu-buffer nil))
 
 (defvar magit--plural-append-es '(branch))
@@ -751,28 +763,6 @@ The following %-specs are allowed:
                    (?M . ,(or multiple value))
                    (?x . ,(format "%s" magit-menu-common-value))))))
 
-(defun magit--menu-bar-keymap (keymap)
-  "Backport of `menu-bar-keymap' for Emacs < 28.
-Slight trimmed down."
-  (let ((menu-bar nil))
-    (map-keymap (lambda (key binding)
-                  (push (cons key binding) menu-bar))
-                keymap)
-    (cons 'keymap (nreverse menu-bar))))
-
-(defun magit--context-menu-local (menu _click)
-  "Backport of `context-menu-local' for Emacs < 28."
-  (run-hooks 'activate-menubar-hook 'menu-bar-update-hook)
-  (keymap-set-after menu "<separator-local>" menu-bar-separator)
-  (let ((keymap (local-key-binding [menu-bar])))
-    (when keymap
-      (map-keymap (lambda (key binding)
-                    (when (consp binding)
-                      (define-key-after menu (vector key)
-                        (copy-sequence binding))))
-                  (magit--menu-bar-keymap keymap))))
-  menu)
-
 (define-advice context-menu-region (:around (fn menu click) magit-section-mode)
   "Disable in `magit-section-mode' buffers."
   (if (derived-mode-p 'magit-section-mode)
@@ -850,23 +840,25 @@ the beginning of the current section."
   "Move to the beginning of the next sibling section.
 If there is no next sibling section, then move to the parent."
   (interactive)
-  (let ((current (magit-current-section)))
-    (if (oref current parent)
-        (if-let ((next (car (magit-section-siblings current 'next))))
-            (magit-section-goto next)
-          (magit-section-forward))
-      (magit-section-goto 1))))
+  (cond-let
+    [[current (magit-current-section)]]
+    ((not (oref current parent))
+     (magit-section-goto 1))
+    ([next (car (magit-section-siblings current 'next))]
+     (magit-section-goto next))
+    ((magit-section-forward))))
 
 (defun magit-section-backward-sibling ()
   "Move to the beginning of the previous sibling section.
 If there is no previous sibling section, then move to the parent."
   (interactive)
-  (let ((current (magit-current-section)))
-    (if (oref current parent)
-        (if-let ((previous (car (magit-section-siblings current 'prev))))
-            (magit-section-goto previous)
-          (magit-section-backward))
-      (magit-section-goto -1))))
+  (cond-let
+    [[current (magit-current-section)]]
+    ((not (oref current parent))
+     (magit-section-goto -1))
+    ([previous (car (magit-section-siblings current 'prev))]
+     (magit-section-goto previous))
+    ((magit-section-backward))))
 
 (defun magit-mouse-set-point (event &optional promote-to-region)
   "Like `mouse-set-point' but also call `magit-section-movement-hook'."
@@ -875,6 +867,8 @@ If there is no previous sibling section, then move to the parent."
   (run-hook-with-args 'magit-section-movement-hook (magit-current-section)))
 
 (defun magit-section-goto (arg)
+  "Run `magit-section-movement-hook'.
+See info node `(magit)Section Movement'."
   (if (integerp arg)
       (progn (forward-line arg)
              (setq arg (magit-current-section)))
@@ -888,7 +882,7 @@ If there is no previous sibling section, then move to the parent."
 
 (defmacro magit-define-section-jumper
     (name heading type &optional value inserter &rest properties)
-  "Define an interactive function to go some section.
+  "Define an interactive function to go to some section.
 Together TYPE and VALUE identify the section.
 HEADING is the displayed heading of the section."
   (declare (indent defun))
@@ -900,19 +894,23 @@ With a prefix argument also expand it." heading)
             (list :description heading))
      ,@(and inserter
             `(:if (##memq ',inserter
-                          (bound-and-true-p magit-status-sections-hook))))
+                          (symbol-value
+                           (intern (format "%s-sections-hook"
+                                           (substring (symbol-name major-mode)
+                                                      0 -5)))))))
      :inapt-if-not (##magit-get-section
                     (cons (cons ',type ,value)
                           (magit-section-ident magit-root-section)))
      (interactive "P")
-     (if-let ((section (magit-get-section
-                        (cons (cons ',type ,value)
-                              (magit-section-ident magit-root-section)))))
-         (progn (goto-char (oref section start))
-                (when expand
-                  (with-local-quit (magit-section-show section))
-                  (recenter 0)))
-       (message ,(format "Section \"%s\" wasn't found" heading)))))
+     (cond-let
+       ([section (magit-get-section
+                  (cons (cons ',type ,value)
+                        (magit-section-ident magit-root-section)))]
+        (goto-char (oref section start))
+        (when expand
+          (with-local-quit (magit-section-show section))
+          (recenter 0)))
+       ((message ,(format "Section \"%s\" wasn't found" heading))))))
 
 ;;;; Visibility
 
@@ -1017,62 +1015,61 @@ from using this key and instead bind another key to `tab-next'.  Because
 `tab-bar-mode' does not use a mode map but instead manipulates the
 global map, this involves advising `tab-bar--define-keys'."
   (interactive (list (magit-current-section)))
-  (cond
-   ((and (equal (this-command-keys) [C-tab])
-         (eq (global-key-binding [C-tab]) 'tab-next)
-         (fboundp 'tab-bar-switch-to-next-tab))
-    (tab-bar-switch-to-next-tab current-prefix-arg))
-   ((eq section magit-root-section)
-    (magit-section-cycle-global))
-   ((oref section hidden)
-    (magit-section-show section)
-    (magit-section-hide-children section))
-   ((let ((children (oref section children)))
-      (cond ((and (seq-some (##oref % hidden)   children)
-                  (seq-some (##oref % children) children))
-             (magit-section-show-headings section))
-            ((seq-some #'magit-section-hidden-body children)
-             (magit-section-show-children section))
-            ((magit-section-hide section)))))))
+  (cond-let
+    ((and (equal (this-command-keys) [C-tab])
+          (eq (global-key-binding [C-tab]) 'tab-next)
+          (fboundp 'tab-bar-switch-to-next-tab))
+     (tab-bar-switch-to-next-tab current-prefix-arg))
+    ((eq section magit-root-section)
+     (magit-section-cycle-global))
+    ((oref section hidden)
+     (magit-section-show section)
+     (magit-section-hide-children section))
+    [[children (oref section children)]]
+    ((and (seq-some (##oref % hidden)   children)
+          (seq-some (##oref % children) children))
+     (magit-section-show-headings section))
+    ((seq-some #'magit-section-hidden-body children)
+     (magit-section-show-children section))
+    ((magit-section-hide section))))
 
 (defun magit-section-cycle-global ()
   "Cycle visibility of all sections in the current buffer."
   (interactive)
-  (let ((children (oref magit-root-section children)))
-    (cond ((and (seq-some (##oref % hidden)   children)
-                (seq-some (##oref % children) children))
-           (magit-section-show-headings magit-root-section))
-          ((seq-some #'magit-section-hidden-body children)
-           (magit-section-show-children magit-root-section))
-          (t
-           (mapc #'magit-section-hide children)))))
+  (cond-let
+    [[children (oref magit-root-section children)]]
+    ((and (seq-some (##oref % hidden)   children)
+          (seq-some (##oref % children) children))
+     (magit-section-show-headings magit-root-section))
+    ((seq-some #'magit-section-hidden-body children)
+     (magit-section-show-children magit-root-section))
+    ((mapc #'magit-section-hide children))))
 
 (defun magit-section-hidden (section)
-  "Return t if SECTION and/or an ancestor is hidden."
+  "Return t if the content of SECTION or of any ancestor is hidden.
+Ignore whether the body of any of SECTION's descendants is hidden.
+When the status of descendants is irrelevant but that of ancestors
+matters, instead use `magit-section-hidden-body'."
   (or (oref section hidden)
-      (and-let* ((parent (oref section parent)))
-        (magit-section-hidden parent))))
+      (and$ (oref section parent)
+            (magit-section-hidden $))))
 
 (defun magit-section-hidden-body (section &optional pred)
-  "Return t if the content of SECTION or of any children is hidden."
+  "Return t if the content of SECTION or of any descendant is hidden.
+Ignore whether the body of any of SECTION's ancestors is hidden;
+if you need that use `magit-section-hidden'."
   (if-let ((children (oref section children)))
       (funcall (or pred #'seq-some) #'magit-section-hidden-body children)
     (and (oref section content)
          (oref section hidden))))
 
+(defalias 'magit-section-invisible-p #'magit-section-hidden)
+
 (defun magit-section-content-p (section)
   "Return non-nil if SECTION has content or an unused washer function."
   (with-slots (content end washer) section
     (and content (or (not (= content end)) washer))))
 
-(defun magit-section-invisible-p (section)
-  "Return t if the SECTION's body is invisible.
-When the body of an ancestor of SECTION is collapsed then
-SECTION's body (and heading) obviously cannot be visible."
-  (or (oref section hidden)
-      (and-let* ((parent (oref section parent)))
-        (magit-section-invisible-p parent))))
-
 (defun magit-section-show-level (level)
   "Show surrounding sections up to LEVEL.
 Likewise hide sections at higher levels.  If the region selects multiple
@@ -1154,12 +1151,15 @@ silently ignored."
 
 ;;;; Auxiliary
 
-(defun magit-describe-section-briefly (section &optional ident interactive)
-  "Show information about the section at point.
+(defun magit-describe-section-briefly (&optional section ident interactive)
+  "Show information about SECTION or the section at point.
 With a prefix argument show the section identity instead of the
 section lineage.  This command is intended for debugging purposes.
-\n(fn SECTION &optional IDENT)"
+Non-interactively, just return the information.  Interactively,
+or when INTERACTIVE is non-nil, show the section in the echo area."
   (interactive (list (magit-current-section) current-prefix-arg t))
+  (unless section
+    (setq section (magit-current-section)))
   (let ((str (format "#<%s %S %S %s-%s%s>"
                      (eieio-object-class section)
                      (let ((val (oref section value)))
@@ -1168,19 +1168,18 @@ section lineage.  This command is intended for debugging purposes.
                              ((and (eieio-object-p val)
                                    (fboundp 'cl-prin1-to-string))
                               (cl-prin1-to-string val))
-                             (t
-                              val)))
+                             (val)))
                      (if ident
                          (magit-section-ident section)
                        (apply #'vector (magit-section-lineage section)))
-                     (and-let* ((m (oref section start)))
-                       (if (markerp m) (marker-position m) m))
+                     (and$ (oref section start)
+                           (if (markerp $) (marker-position $) $))
                      (if-let ((m (oref section content)))
                          (format "[%s-]"
                                  (if (markerp m) (marker-position m) m))
                        "")
-                     (and-let* ((m (oref section end)))
-                       (if (markerp m) (marker-position m) m)))))
+                     (and$ (oref section end)
+                           (if (markerp $) (marker-position $) $)))))
     (when interactive
       (message "%s" str))
     str))
@@ -1278,17 +1277,18 @@ of course you want to be that precise."
 (defun magit-section-match-2 (condition section)
   (if (eq (car condition) '*)
       (or (magit-section-match-2 (cdr condition) section)
-          (and-let* ((parent (oref section parent)))
-            (magit-section-match-2 condition parent)))
-    (and (let ((c (car condition)))
-           (if (class-p c)
-               (cl-typep section c)
-             (if-let ((class (cdr (assq c magit--section-type-alist))))
-                 (cl-typep section class)
-               (eq (oref section type) c))))
+          (and$ (oref section parent)
+                (magit-section-match-2 condition $)))
+    (and (cond-let
+           [[c (car condition)]]
+           ((class-p c)
+            (cl-typep section c))
+           ([class (cdr (assq c magit--section-type-alist))]
+            (cl-typep section class))
+           ((eq (oref section type) c)))
          (or (not (setq condition (cdr condition)))
-             (and-let* ((parent (oref section parent)))
-               (magit-section-match-2 condition parent))))))
+             (and$ (oref section parent)
+                   (magit-section-match-2 condition $))))))
 
 (defun magit-section-value-if (condition &optional section)
   "If the section at point matches CONDITION, then return its value.
@@ -1299,9 +1299,9 @@ then return nil.  If the section does not match, then return
 nil.
 
 See `magit-section-match' for the forms CONDITION can take."
-  (and-let* ((section (or section (magit-current-section))))
-    (and (magit-section-match condition section)
-         (oref section value))))
+  (and$ (or section (magit-current-section))
+        (and (magit-section-match condition $)
+             (oref $ value))))
 
 (defmacro magit-section-case (&rest clauses)
   "Choose among clauses on the type of the section at point.
@@ -1319,7 +1319,7 @@ matches if no other CONDITION match, even if there is no section
 at point."
   (declare (indent 0)
            (debug (&rest (sexp body))))
-  `(let* ((it (magit-current-section)))
+  `(let ((it (magit-current-section)))
      (cond ,@(mapcar (lambda (clause)
                        `(,(or (eq (car clause) t)
                               `(and it
@@ -1605,8 +1605,8 @@ is explicitly expanded."
 (defun magit-section--set-section-properties (section)
   (pcase-let* (((eieio start end children keymap) section)
                (props `( magit-section ,section
-                         ,@(and-let* ((map (symbol-value keymap)))
-                             (list 'keymap map)))))
+                         ,@(and$ (symbol-value keymap)
+                                 (list 'keymap $)))))
     (if children
         (save-excursion
           (goto-char start)
@@ -1771,7 +1771,9 @@ evaluated its BODY.  Admittedly that's a bit of a hack."
                  (magit-section-highlight-range content child-start)))
              (mapc #'magit-section-highlight children))
             ((and content (not (slot-boundp section 'painted)))
-             (magit-section-highlight-range content end))))
+             (magit-section-highlight-range content end))
+            ;; Unfortunate kludge for delayed hunk refinement.
+            ((magit-section--refine section))))
      (headlight
       (magit-section-highlight-range start (or content end) headlight)
       (when content
@@ -1787,6 +1789,7 @@ evaluated its BODY.  Admittedly that's a bit of a hack."
                        (or heading-selection-face
                            'magit-section-heading-selection))
           (overlay-put ov 'evaporate t)
+          (overlay-put ov 'priority '(nil . 9))
           (push ov magit-section-selection-overlays)
           ov)))))
 
@@ -1802,8 +1805,8 @@ evaluated its BODY.  Admittedly that's a bit of a hack."
       (and as-child
            (oref section heading-highlight-face))
       (slot-boundp section 'painted)
-      (and-let* ((children (oref section children)))
-        (magit-section-selective-highlight-p (car children) t))))
+      (and$ (oref section children)
+            (magit-section-selective-highlight-p (car $) t))))
 
 ;;; Paint
 
@@ -1827,6 +1830,8 @@ evaluated its BODY.  Admittedly that's a bit of a hack."
         (`(focus ,(or 'nil 'plain))
          (paint t)
          (cl-pushnew section magit-section-highlighted-sections))
+        (`(focus highlight)
+         (cl-pushnew section magit-section-highlighted-sections))
         (`(unfocus ,(or 'nil 'highlight))
          (paint nil)
          (unregister))
@@ -1846,6 +1851,8 @@ evaluated its BODY.  Admittedly that's a bit of a hack."
           (cl-pushnew section magit-section-highlighted-sections))
       (magit-section-update-paint section (magit-focused-sections)))))
 
+(cl-defmethod magit-section--refine ((_section magit-section)))
+
 ;;; Long Lines
 
 (defvar magit-show-long-lines-warning t)
@@ -1894,7 +1901,7 @@ to nil." (bound-and-true-p long-line-threshold)) :warning)))))
 
 (defun magit-section-goto-successor--same (section line char)
   (let ((ident (magit-section-ident section)))
-    (and-let* ((found (magit-get-section ident)))
+    (and-let ((found (magit-get-section ident)))
       (let ((start (oref found start)))
         (goto-char start)
         (unless (eq found magit-root-section)
@@ -1906,25 +1913,25 @@ to nil." (bound-and-true-p long-line-threshold)) :warning)))))
         t))))
 
 (defun magit-section-goto-successor--related (section)
-  (and-let* ((found (magit-section-goto-successor--related-1 section)))
+  (and-let ((found (magit-section-goto-successor--related-1 section)))
     (goto-char (if (eq (oref found type) 'button)
                    (point-min)
                  (oref found start)))))
 
 (defun magit-section-goto-successor--related-1 (section)
-  (or (and-let* ((alt (pcase (oref section type)
-                        ('staged 'unstaged)
-                        ('unstaged 'staged)
-                        ('unpushed 'unpulled)
-                        ('unpulled 'unpushed))))
-        (magit-get-section `((,alt) (status))))
-      (and-let* ((next (car (magit-section-siblings section 'next))))
-        (magit-get-section (magit-section-ident next)))
-      (and-let* ((prev (car (magit-section-siblings section 'prev))))
-        (magit-get-section (magit-section-ident prev)))
-      (and-let* ((parent (oref section parent)))
-        (or (magit-get-section (magit-section-ident parent))
-            (magit-section-goto-successor--related-1 parent)))))
+  (or (and$ (pcase (oref section type)
+              ('staged 'unstaged)
+              ('unstaged 'staged)
+              ('unpushed 'unpulled)
+              ('unpulled 'unpushed))
+           (magit-get-section `((,$) (status))))
+      (and$ (magit-section-siblings section 'next)
+            (magit-get-section (magit-section-ident (car $))))
+      (and$ (magit-section-siblings section 'prev)
+            (magit-get-section (magit-section-ident (car $))))
+      (and$ (oref section parent)
+            (or (magit-get-section (magit-section-ident $))
+                (magit-section-goto-successor--related-1 $)))))
 
 ;;; Region
 
@@ -1985,33 +1992,42 @@ When `magit-section-preserve-visibility' is nil, return nil."
   (when (and magit-section-visibility-indicator
              (magit-section-content-p section))
     (let* ((beg (oref section start))
-           (eoh (magit--eol-position beg)))
-      (cond
-       ((symbolp (car-safe magit-section-visibility-indicator))
-        (let ((ov (magit--overlay-at beg 'magit-vis-indicator 'fringe)))
-          (unless ov
-            (setq ov (make-overlay beg eoh nil t))
-            (overlay-put ov 'evaporate t)
-            (overlay-put ov 'magit-vis-indicator 'fringe))
-          (overlay-put
-           ov 'before-string
-           (propertize "fringe" 'display
-                       (list 'left-fringe
-                             (if (oref section hidden)
-                                 (car magit-section-visibility-indicator)
-                               (cdr magit-section-visibility-indicator))
-                             'fringe)))))
-       ((stringp (car-safe magit-section-visibility-indicator))
-        (let ((ov (magit--overlay-at (1- eoh) 'magit-vis-indicator 'eoh)))
-          (cond ((oref section hidden)
-                 (unless ov
-                   (setq ov (make-overlay (1- eoh) eoh))
-                   (overlay-put ov 'evaporate t)
-                   (overlay-put ov 'magit-vis-indicator 'eoh))
-                 (overlay-put ov 'after-string
-                              (car magit-section-visibility-indicator)))
-                (ov
-                 (delete-overlay ov)))))))))
+           (eoh (magit--eol-position beg))
+           (indicator (if (oref section hidden)
+                          (car magit-section-visibility-indicator)
+                        (cdr magit-section-visibility-indicator)))
+           (kind (cl-typecase (car magit-section-visibility-indicator)
+                   (symbol    'fringe)
+                   (character 'margin)
+                   (string    'ellipsis))))
+      (pcase kind
+        ((or 'fringe 'margin)
+         (let ((ov (magit--overlay-at beg 'magit-vis-indicator kind)))
+           (unless ov
+             (setq ov (make-overlay beg eoh nil t))
+             (overlay-put ov 'evaporate t)
+             (overlay-put ov 'magit-vis-indicator kind))
+           (overlay-put
+            ov 'before-string
+            (pcase kind
+              ('fringe
+               (propertize "fringe" 'display
+                           `(left-fringe ,indicator fringe)))
+              ('margin
+               (propertize "margin" 'display
+                           `((margin left-margin)
+                             ,(propertize (string indicator)
+                                          'face 'magit-left-margin))))))))
+        ('ellipsis
+         (let ((ov (magit--overlay-at (1- eoh) 'magit-vis-indicator 'eoh)))
+           (cond ((oref section hidden)
+                  (unless ov
+                    (setq ov (make-overlay (1- eoh) eoh))
+                    (overlay-put ov 'evaporate t)
+                    (overlay-put ov 'magit-vis-indicator 'eoh))
+                  (overlay-put ov 'after-string indicator))
+                 (ov
+                  (delete-overlay ov)))))))))
 
 (defvar-local magit--ellipses-sections nil)
 
@@ -2065,16 +2081,15 @@ When `magit-section-preserve-visibility' is nil, return nil."
     (let ((section (magit-current-section)))
       (while section
         (let ((content (oref section content)))
-          (if (and (magit-section-invisible-p section)
-                   (<= (or content (oref section start))
-                       beg
-                       (oref section end)))
-              (progn
-                (when content
-                  (magit-section-show section)
-                  (push section magit-section--opened-sections))
-                (setq section (oref section parent)))
-            (setq section nil))))))
+          (cond ((and (magit-section-hidden section)
+                      (<= (or content (oref section start))
+                          beg
+                          (oref section end)))
+                 (when content
+                   (magit-section-show section)
+                   (push section magit-section--opened-sections))
+                 (setq section (oref section parent)))
+                ((setq section nil)))))))
   (or (eq search-invisible t)
       (not (isearch-range-invisible beg end))))
 
@@ -2087,6 +2102,12 @@ When `magit-section-preserve-visibility' is nil, return nil."
         (setq magit-section--opened-sections nil))
     (funcall fn)))
 
+(defun magit-section-reveal (section)
+  (while section
+    (when (oref section hidden)
+      (magit-section-show section))
+    (setq section (oref section parent))))
+
 ;;; Utilities
 
 (cl-defun magit-section-selected-p (section &optional (selection nil sselection))
@@ -2095,12 +2116,12 @@ When `magit-section-preserve-visibility' is nil, return nil."
             (memq section (if sselection
                               selection
                             (setq selection (magit-region-sections))))
-            (and-let* ((parent (oref section parent)))
-              (magit-section-selected-p parent selection)))))
+            (and$ (oref section parent)
+                  (magit-section-selected-p $ selection)))))
 
 (defun magit-section-parent-value (section)
-  (and-let* ((parent (oref section parent)))
-    (oref parent value)))
+  (and$ (oref section parent)
+        (oref $ value)))
 
 (defun magit-section-siblings (section &optional direction)
   "Return a list of the sibling sections of SECTION.
@@ -2332,7 +2353,7 @@ Configuration'."
                 (message "  %-50s %f %s" entry time
                          (cond ((> time 0.03) "!!")
                                ((> time 0.01) "!")
-                               (t ""))))
+                               (""))))
             (apply entry args)))))))
 
 (cl-defun magit--overlay-at (pos prop &optional (val nil sval) testfn)
@@ -2360,8 +2381,8 @@ Configuration'."
 (defun magit--add-face-text-property ( beg end face
                                        &optional append object adopt-face)
   "Like `add-face-text-property' but for `font-lock-face'.
-If optional ADOPT-FACE, the replace `face' with `font-lock-face'
-first.  This is a hack, which is likely to be remove again."
+If optional ADOPT-FACE, then replace `face' with `font-lock-face'
+first.  The latter is a hack, which is likely to be removed again."
   (when (stringp object)
     (unless beg (setq beg 0))
     (unless end (setq end (length object))))
@@ -2437,7 +2458,7 @@ This is like moving to POS and then calling `pos-eol'."
                                   (cdr magit--imenu-group-types)
                                   section))
                           (magit-section-match magit--imenu-group-types section))
-                        (and-let* ((children (oref section children)))
+                        (and-let ((children (oref section children)))
                           `((,(magit--imenu-index-name section)
                              ,@(mapcar (##cons (magit--imenu-index-name %)
                                                (oref % start))
@@ -2469,7 +2490,7 @@ This is like moving to POS and then calling `pos-eol'."
                 (oref section value)))
        ((string-match " ([0-9]+)\\'" heading)
         (substring heading 0 (match-beginning 0)))
-       (t heading)))))
+       (heading)))))
 
 (defun magit--imenu-goto-function (_name position &rest _rest)
   "Go to the section at POSITION.
@@ -2493,6 +2514,8 @@ necessary.  For use as `imenu-default-goto-function' in
 (cl-defgeneric magit-bookmark-get-filename ()
   (or (buffer-file-name) (buffer-name)))
 
+(cl-defgeneric magit-bookmark-get-value (bookmark mode))
+
 (cl-defgeneric magit-bookmark--get-child-value (section)
   (oref section value))
 
@@ -2514,8 +2537,7 @@ and the buffer-local values of the variables referenced in its
         (bookmark-prop-set bookmark 'mode     major-mode)
         (bookmark-prop-set bookmark 'filename (magit-bookmark-get-filename))
         (bookmark-prop-set bookmark 'defaults (list (magit-bookmark-name)))
-        (dolist (var (get major-mode 'magit-bookmark-variables))
-          (bookmark-prop-set bookmark var (symbol-value var)))
+        (magit-bookmark-get-value bookmark)
         (bookmark-prop-set
          bookmark 'magit-hidden-sections
          (seq-keep (##and (oref % hidden)
@@ -2627,4 +2649,15 @@ with the variables' values as arguments, which were recorded by
 
 ;;; _
 (provide 'magit-section)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;;   ("and$"         . "cond-let--and$")
+;;   ("and>"         . "cond-let--and>")
+;;   ("and-let"      . "cond-let--and-let")
+;;   ("if-let"       . "cond-let--if-let")
+;;   ("when-let"     . "cond-let--when-let")
+;;   ("while-let"    . "cond-let--while-let")
+;;   ("match-string" . "match-string")
+;;   ("match-str"    . "match-string-no-properties"))
+;; End:
 ;;; magit-section.el ends here
diff --git a/elpa/magit-section-20250518.653/magit-section.info b/elpa/magit-section-20251027.1634/magit-section.info
similarity index 99%
rename from elpa/magit-section-20250518.653/magit-section.info
rename to elpa/magit-section-20251027.1634/magit-section.info
index f6f1e4f3..139d3227 100644
--- a/elpa/magit-section-20250518.653/magit-section.info
+++ b/elpa/magit-section-20251027.1634/magit-section.info
@@ -34,7 +34,7 @@ packages that have nothing to do with Magit or Git.
 and user options see *note (magit)Sections::.  This manual documents how
 you can use sections in your own packages.
 
-This manual is for Magit-Section version 4.3.5.
+This manual is for Magit-Section version 4.4.2.
 
      Copyright (C) 2015-2025 Jonas Bernoulli
      <emacs.magit@jonas.bernoulli.dev>
-- 
2.47.3