From b37bfba223b7d54e58b95564292c915f0e0953bb Mon Sep 17 00:00:00 2001
From: Frank Benkstein <benkfr@amazon.com>
Date: Fri, 19 Apr 2024 16:24:26 +0200
Subject: [PATCH 001/305] mu-move: remove debug print

---
 mu/mu-cmd-move.cc | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/mu/mu-cmd-move.cc b/mu/mu-cmd-move.cc
index 46070af1c..7ad7a483c 100644
--- a/mu/mu-cmd-move.cc
+++ b/mu/mu-cmd-move.cc
@@ -50,9 +50,6 @@ Mu::mu_cmd_move(Mu::Store& store, const Options& opts)
 			   "Must have at least one of destination and flags");
 	else if (!dest.empty()) {
 		const auto mdirs{store.maildirs()};
-		mu_printerrln("XXXX");
-		for (auto&& m:mdirs)
-			mu_printerrln("m:'{}'", m);
 
 		if (!seq_some(mdirs, [&](auto &&d){ return d == dest;}))
 			return Err(Error{Error::Code::InvalidArgument,

From 4f72e2656dad879a031378d4e2757125f275d95e Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 16 Apr 2024 19:03:08 +0300
Subject: [PATCH 002/305] mu4e: use message-field-value

Simplify

...instead of
save-restriction/message-narrow-to-headers/message-fetch-field.
---
 mu4e/mu4e-compose.el | 136 +++++++++++++++++++------------------------
 mu4e/mu4e-message.el |   5 +-
 mu4e/mu4e-view.el    |   2 +-
 3 files changed, 65 insertions(+), 78 deletions(-)

diff --git a/mu4e/mu4e-compose.el b/mu4e/mu4e-compose.el
index 3b458c5f0..3c15903c7 100644
--- a/mu4e/mu4e-compose.el
+++ b/mu4e/mu4e-compose.el
@@ -441,14 +441,12 @@ If MSGPATH is nil, do nothing."
   ;;  - (temporarily) remove the mail-header separator
   (setq mu4e--compose-undo buffer-undo-list)
   (save-excursion
-    (save-restriction
-      (message-narrow-to-headers)
-      (unless (message-fetch-field "Message-ID")
-        (message-generate-headers '(Message-ID)))
-        ;; older Emacsen (<= 28 perhaps?) won't update the Date
-        ;; if there already is one; so make sure it's gone.
-      (message-remove-header "Date")
-      (message-generate-headers '(Date Subject From)))
+    (unless (message-field-value "Message-ID")
+      (message-generate-headers '(Message-ID)))
+    ;; older Emacsen (<= 28 perhaps?) won't update the Date
+    ;; if there already is one; so make sure it's gone.
+    (message-remove-header "Date")
+    (message-generate-headers '(Date Subject From))
     (mu4e--delimit-headers 'undelimit))) ;; remove separator
 
 (defvar mu4e--compose-buffer-max-name-length 48)
@@ -487,26 +485,24 @@ message buffer."
   (let ((buf (find-file-noselect path)))
     (when buf
       (with-current-buffer buf
-        (save-restriction
-          (message-narrow-to-headers)
-          (let ((in-reply-to (message-fetch-field "in-reply-to"))
-                (forwarded-from)
-                (references (message-fetch-field "references")))
-            (unless in-reply-to
-              (when references
-                (with-temp-buffer ;; inspired by `message-shorten-references'.
-                  (insert references)
-                  (goto-char (point-min))
-                  (let ((refs))
-                    (while (re-search-forward "<[^ <]+@[^ <]+>" nil t)
-                      (push (match-string 0) refs))
-                    ;; the last will be the first
-                    (setq forwarded-from (car refs))))))
-            ;; remove the <> and update the flags on the server-side.
-            (when (and in-reply-to (string-match "<\\(.*\\)>" in-reply-to))
-              (mu4e--server-move (match-string 1 in-reply-to) nil "+R-N"))
-            (when (and forwarded-from (string-match "<\\(.*\\)>" forwarded-from))
-              (mu4e--server-move (match-string 1 forwarded-from) nil "+P-N"))))))))
+        (let ((in-reply-to (message-field-value "in-reply-to"))
+              (forwarded-from)
+              (references (message-field-value "references")))
+          (unless in-reply-to
+            (when references
+              (with-temp-buffer ;; inspired by `message-shorten-references'.
+                (insert references)
+                (goto-char (point-min))
+                (let ((refs))
+                  (while (re-search-forward "<[^ <]+@[^ <]+>" nil t)
+                    (push (match-string 0) refs))
+                  ;; the last will be the first
+                  (setq forwarded-from (car refs))))))
+          ;; remove the <> and update the flags on the server-side.
+          (when (and in-reply-to (string-match "<\\(.*\\)>" in-reply-to))
+            (mu4e--server-move (match-string 1 in-reply-to) nil "+R-N"))
+          (when (and forwarded-from (string-match "<\\(.*\\)>" forwarded-from))
+            (mu4e--server-move (match-string 1 forwarded-from) nil "+P-N")))))))
 
 (defun mu4e--compose-after-save()
   "Function called immediately after the draft buffer is saved."
@@ -546,29 +542,25 @@ appropriate flag at the message forwarded or replied-to."
   ;; Remove References: if In-Reply-To: is missing.
   ;; This allows the user to effectively start a new message-thread by
   ;; removing the In-Reply-To header.
-  (save-restriction
-    (message-narrow-to-headers)
-    (when (eq mu4e-compose-type 'reply)
-      (unless (message-fetch-field "In-Reply-To")
-        (message-remove-header "References")))
-    (when use-hard-newlines
-      (mu4e--send-harden-newlines))
-    ;; now handle what happens _after_ sending; typically, draft is gone and
-    ;; the sent message appears in sent. Update flags for related messages,
-    ;; i.e. for Forwarded ('Passed') and Replied messages, try to set the
-    ;; appropriate flag at the message forwarded or replied-to.
-    (add-hook 'message-sent-hook
-              (lambda ()
-                (save-restriction
-                  (message-narrow-to-headers)
-                  (when-let ((fcc-path (message-fetch-field "Fcc")))
-                    (mu4e--set-parent-flags fcc-path)
-                    ;; we end up with a ((buried) buffer here, visiting
-                    ;; the fcc-path; not quite sure why. But let's
-                    ;; get rid of it (#2681)
-                    (when-let ((buf (find-buffer-visiting fcc-path)))
-                      (kill-buffer buf)))))
-              nil t)))
+  (when (eq mu4e-compose-type 'reply)
+    (unless (message-field-value "In-Reply-To")
+      (message-remove-header "References")))
+  (when use-hard-newlines
+    (mu4e--send-harden-newlines))
+  ;; now handle what happens _after_ sending; typically, draft is gone and
+  ;; the sent message appears in sent. Update flags for related messages,
+  ;; i.e. for Forwarded ('Passed') and Replied messages, try to set the
+  ;; appropriate flag at the message forwarded or replied-to.
+  (add-hook 'message-sent-hook
+            (lambda ()
+              (when-let ((fcc-path (message-field-value "Fcc")))
+                (mu4e--set-parent-flags fcc-path)
+                ;; we end up with a ((buried) buffer here, visiting
+                ;; the fcc-path; not quite sure why. But let's
+                ;; get rid of it (#2681)
+                (when-let ((buf (find-buffer-visiting fcc-path)))
+                  (kill-buffer buf))))
+            nil t))
 
 ;;; Crypto
 (defun mu4e--compose-setup-crypto (parent compose-type)
@@ -718,11 +710,9 @@ With HEADERS-ONLY non-nil, only include the headers part."
     ;; in rare (broken) case, if a message-id is missing use the generated one
     ;; from mu.
     (mu4e--delimit-headers)
-    (save-restriction
-      (message-narrow-to-headers)
-      (unless (message-fetch-field "Message-Id")
-        (goto-char (point-min))
-        (insert (format "Message-Id: <%s>\n" (plist-get msg :message-id)))))
+    (unless (message-field-value "Message-Id")
+      (goto-char (point-min))
+      (insert (format "Message-Id: <%s>\n" (plist-get msg :message-id))))
     (mu4e--delimit-headers 'undelimit)
     (ignore-errors (run-hooks 'gnus-article-decode-hook))
     (buffer-substring-no-properties (point-min) (point-max))))
@@ -822,14 +812,12 @@ This is mu4e's version of `message-hidden-headers'.")
 FUNC is the original function, and ARGS are its arguments.
 Is this address yours?"
   (if (mu4e-running-p)
-      (save-restriction
-        (message-narrow-to-headers)
-        (let ((sender (message-fetch-field "from"))
-              (from (message-fetch-field "sender")))
-          (or (and sender (mu4e-personal-or-alternative-address-p
-                           (car (mail-header-parse-address sender))))
-              (and from (mu4e-personal-or-alternative-address-p
-                         (car (mail-header-parse-address from)))))))
+      (let ((sender (message-field-value "from"))
+            (from (message-field-value "sender")))
+        (or (and sender (mu4e-personal-or-alternative-address-p
+                         (car (mail-header-parse-address sender))))
+            (and from (mu4e-personal-or-alternative-address-p
+                       (car (mail-header-parse-address from))))))
     (apply func args)))
 
 (defun mu4e--compose-setup-post (compose-type &optional parent)
@@ -986,17 +974,15 @@ must be from current user, as determined through
        (mu4e--delimit-headers)
        ;; message-forward expects message-reply-headers to be set up; here we
        ;; only need message-id & references, rest is for completeness.
-       (save-restriction
-         (message-narrow-to-headers)
-         (setq-local message-reply-headers
-                     (make-full-mail-header
-                      0
-                      (or (message-fetch-field "subject") "none")
-                      (or (message-fetch-field "from") "nobody")
-                      (message-fetch-field "date")
-                      (message-fetch-field "message-id" t)
-                      (message-fetch-field "references")
-                      0 0 "")))
+       (setq-local message-reply-headers
+                   (make-full-mail-header
+                    0
+                    (or (message-field-value "subject") "none")
+                    (or (message-field-value "from") "nobody")
+                    (message-field-value "date")
+                    (message-field-value "message-id" t)
+                    (message-field-value "references")
+                    0 0 ""))
        (mu4e--delimit-headers 'undelimit)
        (set-buffer-modified-p nil)
        (message-forward)))))
diff --git a/mu4e/mu4e-message.el b/mu4e/mu4e-message.el
index f7b805c58..95f8aff53 100644
--- a/mu4e/mu4e-message.el
+++ b/mu4e/mu4e-message.el
@@ -232,7 +232,8 @@ If MSG is nil, use `mu4e-message-at-point'."
 
 If the header appears multiple times, the field values are
 concatenated, unless FIRST is non-nil, in which case only the
-first value is returned. See `message-fetch-field' for details.
+first value is returned. See `message-field-value' and
+`nessage-fetch-field' for details.
 
 Note: this loads the full message file such that any available
 message header can be used. If the header is part of the MSG
@@ -240,7 +241,7 @@ plist, it is much more efficient to get the information from that
 plist."
   (with-temp-buffer
     (insert (mu4e--decoded-message msg 'headers-only))
-    (message-fetch-field hdr first)))
+    (message-field-value hdr first)))
 ;;;
 (provide 'mu4e-message)
 ;;; mu4e-message.el ends here
diff --git a/mu4e/mu4e-view.el b/mu4e/mu4e-view.el
index 10a2bcec0..033540aa3 100644
--- a/mu4e/mu4e-view.el
+++ b/mu4e/mu4e-view.el
@@ -685,7 +685,7 @@ determine which browser function to use."
     (ignore-errors (run-hooks 'gnus-article-decode-hook))
     (let ((header (unless skip-headers
                     (cl-loop for field in '("from" "to" "cc" "date" "subject")
-                             when (message-fetch-field field)
+                             when (message-field-value field)
                              concat (format "%s: %s\n" (capitalize field) it))))
           (parts (mm-dissect-buffer t t)))
       ;; If singlepart, enforce a list.

From 386153f1a7e73fca2b63c6f593b30717316e04fa Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 20 Apr 2024 11:43:15 +0300
Subject: [PATCH 003/305] github: update bug filing template

---
 .github/ISSUE_TEMPLATE/mu4e-bug-report.md | 26 +++++++++++++++++------
 1 file changed, 19 insertions(+), 7 deletions(-)

diff --git a/.github/ISSUE_TEMPLATE/mu4e-bug-report.md b/.github/ISSUE_TEMPLATE/mu4e-bug-report.md
index cb5c0b2ad..63d857f66 100644
--- a/.github/ISSUE_TEMPLATE/mu4e-bug-report.md
+++ b/.github/ISSUE_TEMPLATE/mu4e-bug-report.md
@@ -7,23 +7,35 @@ assignees: ''
 ---
 
 **Describe the bug**
+
+Give the bug a good title.
+
 Please provide a clear and concise description of what you expected to happen
-and what actually happened.
+and what actually happened, and follow the steps below.
 
 **How to Reproduce**
+
 Include the exact steps of what you were doing (commands executed etc.). Include
-any relevant logs and outputs. Best start with `emacs -Q` and a minimal `mu4e` setup.
+any relevant logs and outputs:
 
-If this is about a specific (kind of) message, attach an example message. (Open
-the message, press `.` (`mu4e-view-raw-message`), then `C-x C-w` and attach.
-Anonymize as needed, all that matters is that the issue still reproduces.
+- Best start from `emacs -Q`, and load a minimal `mu4e` setup; describe the steps
+  that lead up to the bug.
+- Does the problem happen each time? Sometimes?
+- If this is about a specific (kind of) message, attach an example message.
+  (Open the message, press `.` (`mu4e-view-raw-message`), then `C-x C-w` and
+  attach. Anonymize as needed, all that matters is that the issue still
+  reproduces.
 
 **Environment**
+
 Please describe the versions of OS, Emacs, mu/mu4e etc. you are using.
 
 **Checklist**
-- [ ] you are running either an 1.8.x/1.10.x release or `master` (otherwise please upgrade)
+
+- [ ] you are running either an 1.10.x/1.12.x release or `master` (otherwise please upgrade)
 - [ ] you can reproduce the problem without 3rd party extensions (including Doom/Evil, various extensions etc.)
 - [ ] you have read all of the above
 
-Please make sure you all items in the checklist are set/met before filing the ticket. Thank you!
\ No newline at end of file
+Please make sure you all items in the checklist are set/met before filing the ticket.
+
+Thank you!

From a0d60d23b0a34c34d1da639173c7fffd40880b60 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 21 Apr 2024 22:08:10 +0300
Subject: [PATCH 004/305] compat: include sys/wait.h where needed

netbsd needs this explicitly, other systems let us get away without it.
---
 lib/utils/mu-utils-file.cc | 3 ++-
 mu/mu-cmd-find.cc          | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/lib/utils/mu-utils-file.cc b/lib/utils/mu-utils-file.cc
index a8be52207..3daea34a3 100644
--- a/lib/utils/mu-utils-file.cc
+++ b/lib/utils/mu-utils-file.cc
@@ -1,5 +1,5 @@
 /*
-** Copyright (C) 2023 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2023-2024 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify it
 ** under the terms of the GNU General Public License as published by the
@@ -23,6 +23,7 @@
 #include "mu-utils-file.hh"
 
 #include <sys/stat.h>
+#include <sys/wait.h>
 
 #include <glib.h>
 #include <gio/gio.h>
diff --git a/mu/mu-cmd-find.cc b/mu/mu-cmd-find.cc
index f21ff6e51..3853856d7 100644
--- a/mu/mu-cmd-find.cc
+++ b/mu/mu-cmd-find.cc
@@ -1,5 +1,5 @@
  /*
-** Copyright (C) 2008-2023 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2008-2024 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify it
 ** under the terms of the GNU General Public License as published by the
@@ -27,6 +27,7 @@
 #include <errno.h>
 #include <stdlib.h>
 #include <signal.h>
+#include <sys/wait.h>
 
 #include "message/mu-message.hh"
 #include "mu-maildir.hh"

From 6349091061d3f077cc332f6c56ad2ab5b67bf2a4 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 23 Apr 2024 19:45:39 +0300
Subject: [PATCH 005/305] mu4e-compose: don't interfere with non-mu4e
 completion

When enabled, attempt mu4e's auto-completion the first in line (in
completion-at-point-functions); but don't remove any other completions
the user may have set up.

Fixes #2697.
---
 mu4e/mu4e-compose.el | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/mu4e/mu4e-compose.el b/mu4e/mu4e-compose.el
index 3c15903c7..701ed93d0 100644
--- a/mu4e/mu4e-compose.el
+++ b/mu4e/mu4e-compose.el
@@ -390,16 +390,18 @@ contact fields."
       (mu4e-complete-contact))))
 
 (defun mu4e--compose-setup-completion ()
-  "Set up auto-completion of addresses if enabled."
-  ;; turn off message-mode's completion, it's just interfering.
-  (remove-hook 'completion-at-point-functions
-               #'message-completion-function 'local)
+  "Maybe enable auto-completion of addresses.
+Do this when `mu4e-compose-complete-addresses' is non-nil.
+
+When enabled, this attempts to put mu4e's completions at the
+start of the buffer-local `completion-at-point-functions'. Other
+completion functions still apply."
   (when mu4e-compose-complete-addresses
     (set (make-local-variable 'completion-ignore-case) t)
     (set (make-local-variable 'completion-cycle-threshold) 7)
     (add-to-list (make-local-variable 'completion-styles) 'substring)
     (add-hook 'completion-at-point-functions
-              #'mu4e--compose-complete-contact-field nil t)))
+              #'mu4e--compose-complete-contact-field -10 t)))
 
 (defun mu4e--fcc-handler (msgpath)
   "Handle Fcc: for MSGPATH.

From 0f0d2189d4453c1e3d328d7927c4c1546f4c35bd Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 23 Apr 2024 22:08:23 +0300
Subject: [PATCH 006/305] mu4d-contacts: fix typo

---
 mu4e/mu4e-contacts.el | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mu4e/mu4e-contacts.el b/mu4e/mu4e-contacts.el
index f70106f7c..ab6079cf2 100644
--- a/mu4e/mu4e-contacts.el
+++ b/mu4e/mu4e-contacts.el
@@ -236,7 +236,7 @@ case a phrase contains a quote, it will be escaped."
      (mu4e-contact-email contact)))
 
 (defsubst mu4e-contact-make (name email)
-  "Creata contact plist from NAME and EMAIL."
+  "Create a contact plist from NAME and EMAIL."
     `(:name ,name :email ,email))
 
 (defun mu4e-contact-full (contact)

From 4d923b6bbc603c7f78050f357dc273681710105c Mon Sep 17 00:00:00 2001
From: Joseph Turner <joseph@breatheoutbreathe.in>
Date: Mon, 22 Apr 2024 00:23:19 -0700
Subject: [PATCH 007/305] mu4e-compose: fix when mu4e-sent-messages-behavior is
 functional

This commits fixes a regression introduced in
85bfe763362b95935a3967f6585e14b3f9890a70 , at which point sent mails ended up in
the "cur/" subdirectory of the root maildir when the mu4e-sent-messages-behavior
user option was set to a function.
---
 mu4e/mu4e-compose.el | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/mu4e/mu4e-compose.el b/mu4e/mu4e-compose.el
index 701ed93d0..0767ea697 100644
--- a/mu4e/mu4e-compose.el
+++ b/mu4e/mu4e-compose.el
@@ -330,12 +330,18 @@ Returns the path for the sent message, either in the sent or
 trash folder, or nil if the message should be removed after
 sending."
   (when-let ((sent-dir
-          (pcase mu4e-sent-messages-behavior
-            ('delete nil)
-            ('trash (mu4e-get-trash-folder parent))
-            ('sent (mu4e-get-sent-folder parent))
-            ((pred functionp) (funcall mu4e-sent-messages-behavior))
-            (_ (mu4e-error "Error in `mu4e-sent-messages-behavior'")))))
+              ;; We can't call `functionp' since at least 'delete is a function.
+              (pcase mu4e-sent-messages-behavior
+                ('delete nil)
+                ('trash (mu4e-get-trash-folder parent))
+                ('sent (mu4e-get-sent-folder parent))
+                ((pred functionp)
+                 (pcase (funcall mu4e-sent-messages-behavior)
+                   ('delete nil)
+                   ('trash (mu4e-get-trash-folder parent))
+                   ('sent (mu4e-get-sent-folder parent))
+                   (_ (mu4e-error "Error in `mu4e-sent-messages-behavior'"))))
+                (_ (mu4e-error "Error in `mu4e-sent-messages-behavior'")))))
     (mu4e-join-paths
      (mu4e-root-maildir) sent-dir "cur"
      (format "%s%s2,S" base-name mu4e-maildir-info-delimiter))))

From f00ca68c670baf30e139a4af381a95e590c82381 Mon Sep 17 00:00:00 2001
From: Joseph Turner <joseph@breatheoutbreathe.in>
Date: Wed, 24 Apr 2024 12:49:06 -0400
Subject: [PATCH 008/305] mu4e-compose: Don't nest pcase

---
 mu4e/mu4e-compose.el | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/mu4e/mu4e-compose.el b/mu4e/mu4e-compose.el
index 0767ea697..0ed93abc0 100644
--- a/mu4e/mu4e-compose.el
+++ b/mu4e/mu4e-compose.el
@@ -329,18 +329,18 @@ base filename without any Maildir decoration.
 Returns the path for the sent message, either in the sent or
 trash folder, or nil if the message should be removed after
 sending."
-  (when-let ((sent-dir
+  (when-let ((sent-behavior
               ;; We can't call `functionp' since at least 'delete is a function.
               (pcase mu4e-sent-messages-behavior
+                ((or 'delete 'trash 'sent) mu4e-sent-messages-behavior)
+                ((pred functionp mu4e-sent-messages-behavior)
+                 (funcall mu4e-sent-messages-behavior))
+                (_ mu4e-sent-messages-behavior)))
+             (sent-dir
+              (pcase sent-behavior
                 ('delete nil)
                 ('trash (mu4e-get-trash-folder parent))
                 ('sent (mu4e-get-sent-folder parent))
-                ((pred functionp)
-                 (pcase (funcall mu4e-sent-messages-behavior)
-                   ('delete nil)
-                   ('trash (mu4e-get-trash-folder parent))
-                   ('sent (mu4e-get-sent-folder parent))
-                   (_ (mu4e-error "Error in `mu4e-sent-messages-behavior'"))))
                 (_ (mu4e-error "Error in `mu4e-sent-messages-behavior'")))))
     (mu4e-join-paths
      (mu4e-root-maildir) sent-dir "cur"

From 178402fabbf6179508463c34f8d6f653cad397ac Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Fri, 26 Apr 2024 22:57:39 +0300
Subject: [PATCH 009/305] mu4e-compose: prepare for rebase

temporarily remove the mu4e-sent-messages-behavior change, it comes
back in a slightly different way in the next commits.
---
 mu4e/mu4e-compose.el | 20 +++++++-------------
 1 file changed, 7 insertions(+), 13 deletions(-)

diff --git a/mu4e/mu4e-compose.el b/mu4e/mu4e-compose.el
index 0ed93abc0..701ed93d0 100644
--- a/mu4e/mu4e-compose.el
+++ b/mu4e/mu4e-compose.el
@@ -329,19 +329,13 @@ base filename without any Maildir decoration.
 Returns the path for the sent message, either in the sent or
 trash folder, or nil if the message should be removed after
 sending."
-  (when-let ((sent-behavior
-              ;; We can't call `functionp' since at least 'delete is a function.
-              (pcase mu4e-sent-messages-behavior
-                ((or 'delete 'trash 'sent) mu4e-sent-messages-behavior)
-                ((pred functionp mu4e-sent-messages-behavior)
-                 (funcall mu4e-sent-messages-behavior))
-                (_ mu4e-sent-messages-behavior)))
-             (sent-dir
-              (pcase sent-behavior
-                ('delete nil)
-                ('trash (mu4e-get-trash-folder parent))
-                ('sent (mu4e-get-sent-folder parent))
-                (_ (mu4e-error "Error in `mu4e-sent-messages-behavior'")))))
+  (when-let ((sent-dir
+          (pcase mu4e-sent-messages-behavior
+            ('delete nil)
+            ('trash (mu4e-get-trash-folder parent))
+            ('sent (mu4e-get-sent-folder parent))
+            ((pred functionp) (funcall mu4e-sent-messages-behavior))
+            (_ (mu4e-error "Error in `mu4e-sent-messages-behavior'")))))
     (mu4e-join-paths
      (mu4e-root-maildir) sent-dir "cur"
      (format "%s%s2,S" base-name mu4e-maildir-info-delimiter))))

From 6a4d6a49c49594b6feb2496d4eab462128c96b5d Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 23 Apr 2024 19:19:26 +0300
Subject: [PATCH 010/305] mu4e-compose: split off parts in mu4e-draft; rework

Move draft-creation part of message-composition to a new file
mu4e-drafts

However, this is more than just some refactoring: rework the
message (draft) setup as such to ensure we always get a (non-active,
live) buffer back from the composition process.

This also fixes

(progn
  (compose-mail "test@example.org" "Test")
  (insert "TEST"))

as mentioned on the mailing list.

Fixes #2699
---
 mu4e/meson.build      |   1 +
 mu4e/mu4e-compose.el  | 745 +++++-------------------------------------
 mu4e/mu4e-draft.el    | 673 ++++++++++++++++++++++++++++++++++++++
 mu4e/mu4e-obsolete.el |   6 +-
 mu4e/mu4e.texi        |   4 +-
 5 files changed, 765 insertions(+), 664 deletions(-)
 create mode 100644 mu4e/mu4e-draft.el

diff --git a/mu4e/meson.build b/mu4e/meson.build
index 079e74869..a2a22bbd7 100644
--- a/mu4e/meson.build
+++ b/mu4e/meson.build
@@ -43,6 +43,7 @@ mu4e_srcs=[
   'mu4e-contacts.el',
   'mu4e-context.el',
   'mu4e-contrib.el',
+  'mu4e-draft.el',
   'mu4e-folders.el',
   'mu4e.el',
   'mu4e-headers.el',
diff --git a/mu4e/mu4e-compose.el b/mu4e/mu4e-compose.el
index 701ed93d0..f085619a3 100644
--- a/mu4e/mu4e-compose.el
+++ b/mu4e/mu4e-compose.el
@@ -22,10 +22,9 @@
 
 ;;; Commentary:
 
-;; Implements mu4e-compose-mode, which is a `message-mode' derivative. This is a
-;; *fairly* thin wrapper around the gnus functions for message composition,
-;; integrated with mu4e. Still, quite a bit of code to make it work nicely in
-;; the mu4e context.
+;; Implements mu4e-compose-mode, which is a `message-mode' derivative. There's
+;; quite a bit of trickery involved to make the message-mode functions work in
+;; this context; see mu4e-draft for details.
 
 
 ;;; Code:
@@ -40,124 +39,14 @@
 (require 'mu4e-context)
 (require 'mu4e-folders)
 
+(require 'mu4e-draft)
+
 
 ;;; User configuration for compose-mode
 (defgroup mu4e-compose nil
   "Customization for composing/sending messages."
   :group 'mu4e)
 
-(defcustom mu4e-sent-messages-behavior 'sent
-  "Determines what mu4e does with sent messages.
-
-This is one of the symbols:
-* `sent'    move the sent message to the Sent-folder (`mu4e-sent-folder')
-* `trash'   move the sent message to the Trash-folder (`mu4e-trash-folder')
-* `delete'  delete the sent message.
-
-Note, when using GMail/IMAP, you should set this to either
-`trash' or `delete', since GMail already takes care of keeping
-copies in the sent folder.
-
-Alternatively, `mu4e-sent-messages-behavior' can be a function
-which takes no arguments, and which should return one of the mentioned
-symbols, for example:
-
-  (setq mu4e-sent-messages-behavior (lambda ()
-  (if (string= (message-sendmail-envelope-from) \"foo@example.com\")
-       \\='delete \\='sent)))
-
-The various `message-' functions from `message-mode' are available
-for querying the message information."
-  :type '(choice (const :tag "move message to mu4e-sent-folder" sent)
-                 (const :tag "move message to mu4e-trash-folder" trash)
-                 (const :tag "delete message" delete))
-  :group 'mu4e-compose)
-
-(defcustom mu4e-compose-switch nil
-  "Where to display the new message?
-A symbol:
-- nil           : default (new buffer)
-- window        : compose in new window
-- frame or t    : compose in new frame
-- display-buffer: use `display-buffer' / `display-buffer-alist'
-  (for fine-tuning).
-
-For backward compatibility with `mu4e-compose-in-new-frame', t is
-treated as =\\'frame."
-  :type 'symbol
-  :group 'mu4e-compose)
-
-(defcustom mu4e-compose-context-policy 'ask
-  "Policy for determining the context when composing a new message.
-
-If the value is `always-ask', ask the user unconditionally.
-
-In all other cases, if any context matches (using its match
-function), this context is used. Otherwise, if none of the
-contexts match, we have the following choices:
-
-- `pick-first': pick the first of the contexts available (ie. the default)
-- `ask': ask the user
-- `ask-if-none': ask if there is no context yet, otherwise leave it as it is
--  nil: return nil; leaves the current context as is.
-
-Also see `mu4e-context-policy'."
-  :type '(choice
-          (const :tag "Always ask what context to use" always-ask)
-          (const :tag "Ask if none of the contexts match" ask)
-          (const :tag "Ask when there's no context yet" ask-if-none)
-          (const :tag "Pick the first context if none match" pick-first)
-          (const :tag "Don't change the context when none match" nil))
-  :safe 'symbolp
-  :group 'mu4e-compose)
-
-(defcustom mu4e-compose-crypto-policy
-  '(encrypt-encrypted-replies sign-encrypted-replies)
-  "Policy to control when messages will be signed/encrypted.
-
-The value is a list which influence the way draft messages are
-created. Specifically, it might contain:
-
-- `sign-all-messages': Always add a signature.
-- `sign-new-messages': Add a signature to new message, ie.
-  messages that aren't responses to another message.
-- `sign-forwarded-messages': Add a signature when forwarding
-  a message
-- `sign-edited-messages': Add a signature to drafts
-- `sign-all-replies': Add a signature when responding to
-  another message.
-- `sign-plain-replies': Add a signature when responding to
-  non-encrypted messages.
-- `sign-encrypted-replies': Add a signature when responding
-  to encrypted messages.
-
-It should be noted that certain symbols have priorities over one
-another. So `sign-all-messages' implies `sign-all-replies', which
-in turn implies `sign-plain-replies'. Adding both to the set, is
-not a contradiction, but a redundant configuration.
-
-All `sign-*' options have a `encrypt-*' analogue."
-  :type '(set :greedy t
-              (const :tag "Sign all messages" sign-all-messages)
-              (const :tag "Encrypt all messages" encrypt-all-messages)
-              (const :tag "Sign new messages" sign-new-messages)
-              (const :tag "Encrypt new messages" encrypt-new-messages)
-              (const :tag "Sign forwarded messages" sign-forwarded-messages)
-              (const :tag "Encrypt forwarded messages"
-                     encrypt-forwarded-messages)
-              (const :tag "Sign edited messages" sign-edited-messages)
-              (const :tag "Encrypt edited messages" edited-forwarded-messages)
-              (const :tag "Sign all replies" sign-all-replies)
-              (const :tag "Encrypt all replies" encrypt-all-replies)
-              (const :tag "Sign replies to plain messages" sign-plain-replies)
-              (const :tag "Encrypt replies to plain messages"
-                     encrypt-plain-replies)
-              (const :tag "Sign replies to encrypted messages"
-                     sign-encrypted-replies)
-              (const :tag "Encrypt replies to encrypted messages"
-                     encrypt-encrypted-replies))
-  :group 'mu4e-compose)
-
 (defcustom mu4e-compose-format-flowed nil
   "Whether to compose messages to be sent as format=flowed.
 \(Or with long lines if variable `use-hard-newlines' is set to
@@ -184,15 +73,6 @@ the place to do that."
   :group 'mu4e-compose)
 
 
-;;; Runtime variables; useful for user-hooks etc.
-(defvar-local mu4e-compose-parent-message nil
-  "The parent message plist.
-This is the message being replied to, forwarded or edited; used
-in `mu4e-compose-pre-hook'. For new (non-reply, forward etc.)
-messages, it is nil.")
-
-(defvar-local mu4e-compose-type nil
-  "The compose-type for the current message.")
 
 (defvar mu4e-captured-message)
 (defun mu4e-compose-attach-captured-message ()
@@ -285,61 +165,6 @@ the file under our feet, which is a bit fragile."
           (when message-signature
               (save-excursion (message-insert-signature))))))))
 
-
-;;; Filenames
-(defun mu4e--message-basename()
-  "Construct a randomized filename for a message with flags FLAGSTR.
-It looks something like
-    <time>-<random>.<hostname>
-
-This filename is used for the draft message and the sent message,
-depending on `mu4e-sent-messages-behavior'."
-  (let* ((sysname (if (fboundp 'system-name)
-                      (system-name) (with-no-warnings system-name)))
-         (sysname (if (string= sysname "") "localhost" sysname))
-         (hostname (downcase
-                    (save-match-data
-                      (substring sysname
-                                 (string-match "^[^.]+" sysname)
-                                 (match-end 0))))))
-    (format "%s.%04x%04x%04x%04x.%s"
-            (format-time-string "%s" (current-time))
-            (random 65535) (random 65535) (random 65535) (random 65535)
-            hostname)))
-
-(defun mu4e--draft-message-path (base-name &optional parent)
-  "Construct a draft message path, based on PARENT if provided.
-
-PARENT is either nil or the original message (being replied
- to/forwarded etc.), and is used to determine the draft folder.
-BASE-NAME is the base filename without any Maildir decoration."
-  (let ((draft-dir (mu4e-get-drafts-folder parent)))
-    (mu4e-join-paths
-     (mu4e-root-maildir) draft-dir "cur"
-     (format "%s%s2,DS" base-name mu4e-maildir-info-delimiter))))
-
-(defun mu4e--fcc-path (base-name &optional parent)
-  "Construct a Fcc: path, based on PARENT and `mu4e-sent-messages-behavior'.
-
-PARENT is either nil or the original message (being replied
-to/forwarded etc.), and is used to determine the sent folder,
-together with `mu4e-sent-messages-behavior'. BASE-NAME is the
-base filename without any Maildir decoration.
-
-Returns the path for the sent message, either in the sent or
-trash folder, or nil if the message should be removed after
-sending."
-  (when-let ((sent-dir
-          (pcase mu4e-sent-messages-behavior
-            ('delete nil)
-            ('trash (mu4e-get-trash-folder parent))
-            ('sent (mu4e-get-sent-folder parent))
-            ((pred functionp) (funcall mu4e-sent-messages-behavior))
-            (_ (mu4e-error "Error in `mu4e-sent-messages-behavior'")))))
-    (mu4e-join-paths
-     (mu4e-root-maildir) sent-dir "cur"
-     (format "%s%s2,S" base-name mu4e-maildir-info-delimiter))))
-
 
 ;;; address completion
 
@@ -360,10 +185,6 @@ sending."
       (display-sort-function . identity)
       (cycle-sort-function   . identity)))))
 
-(defconst mu4e--header-separator ;; XX properties down work... why not?
-  (propertize "--text follows this line--" 'read-only t 'intangible t)
-  "Line used to separate headers from text in messages being composed.")
-
 (defun mu4e-complete-contact ()
   "Attempt to complete the text at point with a contact.
 I.e., either \"name <email>\" or \"email\". Return nil if not found.
@@ -402,206 +223,6 @@ completion functions still apply."
     (add-to-list (make-local-variable 'completion-styles) 'substring)
     (add-hook 'completion-at-point-functions
               #'mu4e--compose-complete-contact-field -10 t)))
-
-(defun mu4e--fcc-handler (msgpath)
-  "Handle Fcc: for MSGPATH.
-
-This ensures that a copy of a sent messages ends up in the
-appropriate sent-messages folder.
-
-If MSGPATH is nil, do nothing."
-  (when msgpath
-    (let* ((target-dir (file-name-directory msgpath))
-           (target-mdir (file-name-directory target-dir)))
-      ;; create maildir if needed
-      (unless (file-exists-p target-mdir)
-        (make-directory
-         (mu4e-join-paths target-mdir "cur" 'parents))
-        (make-directory
-         (mu4e-join-paths target-mdir "new" 'parents)))
-      (write-file msgpath)
-      (mu4e--server-add msgpath))))
-
-;; save / send hooks
-
-(defvar-local mu4e--compose-undo nil
-  "Remember the undo-state.")
-
-(defun mu4e--delimit-headers (&optional undelimit)
-  "Delimit or undelimit (with UNDELIMIT) headers."
-  (let ((mail-header-separator mu4e--header-separator)
-        (inhibit-read-only t))
-    (save-excursion
-      (mail-sendmail-undelimit-header) ;; clear first
-      (unless undelimit (mail-sendmail-delimit-header)))))
-
-(defun mu4e--compose-before-save ()
-  "Function called just before the draft buffer is saved."
-  ;; This does 3 things:
-  ;;  - set the Message-Id if not already
-  ;;  - set the Date if not already
-  ;;  - (temporarily) remove the mail-header separator
-  (setq mu4e--compose-undo buffer-undo-list)
-  (save-excursion
-    (unless (message-field-value "Message-ID")
-      (message-generate-headers '(Message-ID)))
-    ;; older Emacsen (<= 28 perhaps?) won't update the Date
-    ;; if there already is one; so make sure it's gone.
-    (message-remove-header "Date")
-    (message-generate-headers '(Date Subject From))
-    (mu4e--delimit-headers 'undelimit))) ;; remove separator
-
-(defvar mu4e--compose-buffer-max-name-length 48)
-(defun mu4e--compose-set-friendly-buffer-name ()
-  "Use some friendly name for this composition buffer."
-  (let* ((subj (message-field-value "subject"))
-         (subj (if (or (not subj) (string-match "^[:blank:]*$" subj))
-                   "No subject"  subj)))
-    (rename-buffer (generate-new-buffer-name
-                    (format "\"%s\""
-                            (truncate-string-to-width subj
-                             mu4e--compose-buffer-max-name-length
-                             0 nil t)))
-                   (buffer-name))))
-
-(defun mu4e--set-parent-flags (path)
-  "Set flags for replied-to and forwarded for the message at PATH.
-That is, set the `replied' \"R\" flag on messages we replied to,
-and the `passed' \"F\" flag on message we have forwarded.
-
-If a message has an \"In-Reply-To\" header, it is considered a
-reply to the message with the corresponding message id.
-Otherwise, if it does not have an \"In-Reply-To\" header, but
-does have a \"References:\" header, it is considered to be a
-forward message for the message corresponding with the /last/
-message-id in the references header.
-
-If the message has been determined to be either a forwarded
-message or a reply, we instruct the server to update that message
-with resp. the \"P\" (passed) flag for a forwarded message, or
-the \"R\" flag for a replied message. The original messages are
-also marked as Seen.
-
-Function assumes that it is executed in the context of the
-message buffer."
-  (let ((buf (find-file-noselect path)))
-    (when buf
-      (with-current-buffer buf
-        (let ((in-reply-to (message-field-value "in-reply-to"))
-              (forwarded-from)
-              (references (message-field-value "references")))
-          (unless in-reply-to
-            (when references
-              (with-temp-buffer ;; inspired by `message-shorten-references'.
-                (insert references)
-                (goto-char (point-min))
-                (let ((refs))
-                  (while (re-search-forward "<[^ <]+@[^ <]+>" nil t)
-                    (push (match-string 0) refs))
-                  ;; the last will be the first
-                  (setq forwarded-from (car refs))))))
-          ;; remove the <> and update the flags on the server-side.
-          (when (and in-reply-to (string-match "<\\(.*\\)>" in-reply-to))
-            (mu4e--server-move (match-string 1 in-reply-to) nil "+R-N"))
-          (when (and forwarded-from (string-match "<\\(.*\\)>" forwarded-from))
-            (mu4e--server-move (match-string 1 forwarded-from) nil "+P-N")))))))
-
-(defun mu4e--compose-after-save()
-  "Function called immediately after the draft buffer is saved."
-  ;; This does 3 things:
-  ;; - restore the mail-header-separator (see mu4e--compose-before-save)
-  ;; - update the buffer name (based on the message subject
-  ;; - tell the mu server about the updated draft message
-  (mu4e--delimit-headers)
-  (mu4e--compose-set-friendly-buffer-name)
-  ;; tell the server
-  (mu4e--server-add (buffer-file-name))
-  ;; restore history.
-  (set-buffer-modified-p nil)
-  (setq buffer-undo-list mu4e--compose-undo))
-
-(defun mu4e-sent-handler (docid path)
-  "Handler called with DOCID and PATH for the just-sent message.
-For Forwarded ('Passed') and Replied messages, try to set the
-appropriate flag at the message forwarded or replied-to."
-  ;; XXX we don't need this function anymore here, but
-  ;; we have an external caller in mu4e-icalendar... we should
-  ;; update that.
-  (mu4e--set-parent-flags path)
-  ;; if the draft file exists, remove it now.
-  (when (file-exists-p path)
-    (mu4e--server-remove docid)))
-
-(defun mu4e--send-harden-newlines ()
-  "Set the hard property to all newlines."
-  (save-excursion
-    (goto-char (point-min))
-    (while (search-forward "\n" nil t)
-      (put-text-property (1- (point)) (point) 'hard t))))
-
-(defun mu4e--compose-before-send ()
-  "Function called just before sending a message."
-  ;; Remove References: if In-Reply-To: is missing.
-  ;; This allows the user to effectively start a new message-thread by
-  ;; removing the In-Reply-To header.
-  (when (eq mu4e-compose-type 'reply)
-    (unless (message-field-value "In-Reply-To")
-      (message-remove-header "References")))
-  (when use-hard-newlines
-    (mu4e--send-harden-newlines))
-  ;; now handle what happens _after_ sending; typically, draft is gone and
-  ;; the sent message appears in sent. Update flags for related messages,
-  ;; i.e. for Forwarded ('Passed') and Replied messages, try to set the
-  ;; appropriate flag at the message forwarded or replied-to.
-  (add-hook 'message-sent-hook
-            (lambda ()
-              (when-let ((fcc-path (message-field-value "Fcc")))
-                (mu4e--set-parent-flags fcc-path)
-                ;; we end up with a ((buried) buffer here, visiting
-                ;; the fcc-path; not quite sure why. But let's
-                ;; get rid of it (#2681)
-                (when-let ((buf (find-buffer-visiting fcc-path)))
-                  (kill-buffer buf))))
-            nil t))
-
-;;; Crypto
-(defun mu4e--compose-setup-crypto (parent compose-type)
-  "Possibly encrypt or sign a message based on PARENT and COMPOSE-TYPE.
-See `mu4e-compose-crypto-policy' for more details."
-  (let* ((encrypted-p
-          (and parent (memq 'encrypted (mu4e-message-field parent :flags))))
-         (encrypt
-          (or (memq 'encrypt-all-messages mu4e-compose-crypto-policy)
-              (and (memq 'encrypt-new-messages mu4e-compose-crypto-policy)
-                   (eq compose-type 'new))    ;; new messages
-              (and (eq compose-type 'forward) ;; forwarded
-                   (memq 'encrypt-forwarded-messages mu4e-compose-crypto-policy))
-              (and (eq compose-type 'edit) ;; edit
-                   (memq 'encrypt-edited-messages mu4e-compose-crypto-policy))
-              (and (eq compose-type 'reply) ;; all replies
-                   (memq 'encrypt-all-replies mu4e-compose-crypto-policy))
-              (and (eq compose-type 'reply) (not encrypted-p) ;; plain replies
-                   (memq 'encrypt-plain-replies mu4e-compose-crypto-policy))
-              (and (eq compose-type 'reply) encrypted-p
-                   (memq 'encrypt-encrypted-replies
-                         mu4e-compose-crypto-policy)))) ;; encrypted replies
-         (sign
-          (or (memq 'sign-all-messages mu4e-compose-crypto-policy)
-              (and (eq compose-type 'new) ;; new messages
-                   (memq 'sign-new-messages mu4e-compose-crypto-policy))
-              (and (eq compose-type 'forward) ;; forwarded messages
-                   (memq 'sign-forwarded-messages mu4e-compose-crypto-policy))
-              (and (eq compose-type 'edit) ;; edited messages
-                   (memq 'sign-edited-messages mu4e-compose-crypto-policy))
-              (and (eq compose-type 'reply) ;; all replies
-                   (memq 'sign-all-replies mu4e-compose-crypto-policy))
-              (and (eq compose-type 'reply) (not encrypted-p) ;; plain replies
-                   (memq 'sign-plain-replies mu4e-compose-crypto-policy))
-              (and (eq compose-type 'reply) encrypted-p ;; encrypted replies
-                   (memq 'sign-encrypted-replies mu4e-compose-crypto-policy)))))
-    (cond ((and sign encrypt) (mml-secure-message-sign-encrypt))
-          (sign (mml-secure-message-sign))
-          (encrypt (mml-secure-message-encrypt)))))
 
  ;;; mu4e-compose-mode
 (defun mu4e--compose-remap-faces ()
@@ -688,37 +309,6 @@ buffers; lets remap its faces so it uses the ones for mu4e."
     (message-cite-original-without-signature)
     (delete-region (point-min) (point-max))))
 
-(defun mu4e--decoded-message (msg &optional headers-only)
-  "Get the message MSG, decoded as a string.
-With HEADERS-ONLY non-nil, only include the headers part."
-  (with-temp-buffer
-    (setq-local gnus-article-decode-hook
-                '(article-decode-charset
-                  article-decode-encoded-words
-                  article-decode-idna-rhs
-                  article-treat-non-ascii
-                  article-remove-cr
-                  article-de-base64-unreadable
-                  article-de-quoted-unreadable)
-                gnus-inhibit-mime-unbuttonizing nil
-                gnus-unbuttonized-mime-types '(".*/.*")
-                gnus-original-article-buffer (current-buffer))
-    (insert-file-contents-literally
-     (mu4e-message-readable-path msg) nil nil nil t)
-    ;; remove the body / attachments and what not.
-    (when headers-only
-      (rfc822-goto-eoh)
-      (delete-region (point) (point-max)))
-    ;; in rare (broken) case, if a message-id is missing use the generated one
-    ;; from mu.
-    (mu4e--delimit-headers)
-    (unless (message-field-value "Message-Id")
-      (goto-char (point-min))
-      (insert (format "Message-Id: <%s>\n" (plist-get msg :message-id))))
-    (mu4e--delimit-headers 'undelimit)
-    (ignore-errors (run-hooks 'gnus-article-decode-hook))
-    (buffer-substring-no-properties (point-min) (point-max))))
-
 (defun mu4e--compose-cite (msg)
   "Return a cited version of the ORIG message MSG (a string).
 This function uses `message-cite-function', and its settings apply."
@@ -732,291 +322,124 @@ This function uses `message-cite-function', and its settings apply."
     (pop-mark)
     (goto-char (point-min))
     (buffer-string)))
-
-(defvar mu4e-user-agent-string
-  (format "mu4e %s; emacs %s" mu4e-mu-version emacs-version)
-  "The User-Agent string for mu4e, or nil.")
-
-(defun mu4e--compose-switch-function ()
-  "Function to switch & display composition buffer.
-Based on the value of `mu4e-compose-switch'."
-  (pcase mu4e-compose-switch
-    ('nil             #'switch-to-buffer)
-    ('window          #'switch-to-buffer-other-window)
-    ((or 'frame 't)   #'switch-to-buffer-other-frame)
-    ('display-buffer  #'display-buffer)
-    ;; t for backward compatibility with mu4e-compose-in-new-frame
-    (_             (mu4e-error "Invalid mu4e-compose-switch"))))
-
-(defun mu4e--fake-pop-to-buffer (name &optional _switch)
-  "A fake `message-pop-to-buffer' for creating buffer NAME.
-This is a little glue to use `message-reply', `message-forward'
-etc. We cannot use the normal `message-pop-to-buffer' since we're
-not ready yet to show the buffer in mu4e."
-  ;; note: we're in a _different_ buffer here, so we need to copy
-  ;; message-reply-header's buffer-local value.
-  (let ((reply-headers message-reply-headers))
-    (set-buffer (get-buffer-create name))
-    (setq-local message-reply-headers reply-headers)
-    (erase-buffer)
-    (current-buffer)))
-
-(defun mu4e--headers (compose-type)
-  "Determine headers needed for message based on COMPOSE-TYPE."
-  (seq-filter #'identity ;; ensure needed headers are generated.
-       `(From Subject Date Message-ID
-        ,(when (memq compose-type '(reply forward)) 'References)
-        ,(when (eq compose-type 'reply) 'In-Reply-To)
-        ,(when message-newsreader 'User-Agent)
-        ,(when message-user-organization 'Organization))))
-
-(defun mu4e--compose-setup-buffer (compose-type compose-func parent)
-  "Set up a buffer for message composition before `mu4e-compose-mode'.
-
-COMPOSE-TYPE is the type of message to creat.
-
-COMPOSE-FUNC is a function / lambda to create the specific type
-of message; it should return (but not show) the created buffer.
-
-PARENT is the \"parent\" message; nil
- for a \\='new message, set for all others (the message replied to /
- forwarded / ...)."
-  (with-temp-buffer
-    ;; call the call message function; turn off the gnus crypto stuff;
-    ;; we handle that ourselves below
-    (let* ((message-this-is-mail t)
-           (message-generate-headers-first nil)
-           (message-newsreader mu4e-user-agent-string)
-           (message-mail-user-agent nil))
-      ;; we handle it ourselves.
-      (setq-local gnus-message-replysign nil
-                  gnus-message-replyencrypt nil
-                  gnus-message-replysignencrypted nil)
-      (goto-char (point-min))
-      ;; annoyingly, various message- functions call `message-pop-to-buffer`
-      ;; (showing the message. But we're not ready for that yet. So
-      ;; temporarily override that.
-      (cl-letf (((symbol-function #'message-pop-to-buffer)
-                  #'mu4e--fake-pop-to-buffer))
-        (funcall compose-func parent))
-      ;; add some more headers, if needed.
-      (message-generate-headers (mu4e--headers compose-type))
-      (current-buffer)))) ;; returns new buffer (this is not the tmp buf)
-
 
-(defvar mu4e-compose-hidden-headers
-  (append message-hidden-headers '("^User-agent:" "^Fcc:"))
-  "Message headers to hide when composing.
-This is mu4e's version of `message-hidden-headers'.")
-
-(defun mu4e--message-is-yours-p (func &rest args)
-  "Mu4e advice for `message-is-yours'.
-FUNC is the original function, and ARGS are its arguments.
-Is this address yours?"
-  (if (mu4e-running-p)
-      (let ((sender (message-field-value "from"))
-            (from (message-field-value "sender")))
-        (or (and sender (mu4e-personal-or-alternative-address-p
-                         (car (mail-header-parse-address sender))))
-            (and from (mu4e-personal-or-alternative-address-p
-                       (car (mail-header-parse-address from))))))
-    (apply func args)))
-
-(defun mu4e--compose-setup-post (compose-type &optional parent)
-  "Prepare the new message buffer.
-
-COMPOSE-TYPE determines the type of message to create. PARENT
-refers to the optional message to start from, i.e., the message
-replied to or forwarded, etc."
-  (mu4e-compose-mode)
-  ;; remember some variables, e.g for user hooks.
-  (setq-local
-   mu4e-compose-parent-message parent
-   mu4e-compose-type compose-type)
-
-  (mu4e--compose-setup-crypto parent compose-type)
-  ;; set the attachment dir to something more reasonable than the draft
-  ;; directory.
-  (setq default-directory (mu4e-determine-attachment-dir))
-
-  (add-hook 'before-save-hook  #'mu4e--compose-before-save nil t)
-  (add-hook 'after-save-hook   #'mu4e--compose-after-save nil t)
-  (add-hook 'message-send-hook #'mu4e--compose-before-send nil t)
-
-  (when-let ((fcc-path (mu4e--fcc-path (mu4e--message-basename) parent)))
-    (message-add-header (concat "Fcc: " fcc-path "\n")))
-  (setq-local message-fcc-handler-function #'mu4e--fcc-handler)
-
-  (mu4e--compose-set-friendly-buffer-name)
-  (let ((message-hidden-headers mu4e-compose-hidden-headers))
-    (message-hide-headers))
-
-  ;; jump to some reasonable place.
-  (if (not (message-field-value "To"))
-      (message-goto-to)
-    (if (not (message-field-value "Subject"))
-        (message-goto-subject)
-      (pcase message-cite-reply-position
-        ((or 'above 'traditional) (message-goto-body))
-        (_ (when (message-goto-signature) (forward-line -2))))))
-  ;; buffer is not user-modified yet
-  (set-buffer-modified-p nil)
-  (undo-boundary))
-
-(defun mu4e--compose-setup (compose-type compose-func &optional switch)
-  "Set up a new buffer for mu4e message composition.
-
-COMPOSE-TYPE is a symbol for message-kind; one of \\='(new reply forward edit)
-PARENT is the \"parent\" message; nil for a \\='new message, set for
-all others (the message replied to / forwarded / ...).
-
-COMPOSE-FUNC is a function / lambda to create the specific type
-of message.
-
-Optionally, SWITCH determines how to find a buffer for the message
-\(see SWITCH-FUNCTION in `compose-mail').
-
-Returns the new buffer."
-  (cl-assert (member compose-type '(reply forward edit new)))
-  (unless (mu4e-running-p) (mu4e 'background)) ;; start if needed
-  (let* ((parent
-          (when (member compose-type '(reply forward edit))
-            (mu4e-message-at-point)))
-         (mu4e-compose-parent-message parent)
-         (mu4e-compose-type compose-type)
-         (oldframe (selected-frame)))
-    (advice-add 'message-is-yours-p :around #'mu4e--message-is-yours-p)
-    (run-hooks 'mu4e-compose-pre-hook) ;; run the pre-hook. Still useful?
-    (mu4e--context-autoswitch parent mu4e-compose-context-policy)
-    (with-current-buffer
-        (mu4e--compose-setup-buffer compose-type compose-func parent)
-      (unless (eq compose-type 'edit)
-        (set-visited-file-name ;; make it a draft file
-         (mu4e--draft-message-path (mu4e--message-basename) parent)))
-      (mu4e--compose-setup-post compose-type parent)
-      (funcall (or switch (mu4e--compose-switch-function)) (current-buffer))
-      (let* ((msgframe (selected-frame))
-             (actions (list
-                       (lambda () ;; kill frame when it was created for this
-                         (unless (eq oldframe msgframe)
-                           (delete-frame msgframe))))))
-        ;; handle closing of frames.
-        (setq-local ;;message-kill-actions actions
-         message-return-actions actions
-         message-send-actions actions
-         message-kill-actions actions))
-      (current-buffer))))
 
-
+;;;###autoload
+(defalias 'mu4e-compose-mail #'mu4e-compose-new)
+
 ;;;###autoload
 (defun mu4e-compose-new (&optional to subject other-headers continue
-                                   switch-function yank-action send-actions
+                                   _switch-function yank-action send-actions
                                    return-action &rest _)
   "Mu4e's implementation of `compose-mail'.
-TO, SUBJECT, OTHER-HEADERS, CONTINUE, SWITCH-FUNCTION,
-YANK-ACTION SEND-ACTIONS RETURN-ACTION are as described in
-`compose-mail', and to the extend that they do not conflict with
-mu4e inner workings."
+TO, SUBJECT, OTHER-HEADERS, CONTINUE, YANK-ACTION SEND-ACTIONS
+RETURN-ACTION are as described in `compose-mail', and to the
+extend that they do not conflict with mu4e's inner workings.
+SWITCH-FUNCTION is ignored."
   (interactive)
-  (mu4e--compose-setup
-   'new (lambda (_parent)
-          (message-mail to subject other-headers continue nil
-                        yank-action send-actions return-action))
-   switch-function))
+  (mu4e--draft
+   'new
+   (lambda () (mu4e--message-call
+               #'message-mail to subject other-headers continue
+               nil ;; switch-function -> we handle it ourselves.
+               yank-action send-actions return-action))))
 
 ;;;###autoload
-(defalias 'mu4e-compose-mail #'mu4e-compose-new)
+(defun mu4e-compose-reply-to (&optional to wide)
+  "Reply to the message at point.
+Optional TO can be the To: address for the message. If WIDE is
+non-nil, make it a \"wide\" reply (a.k.a. \"reply-to-all\")."
+  (interactive)
+  (let ((parent (mu4e-message-at-point)))
+    (mu4e--draft-with-parent
+     'reply parent
+     (lambda ()
+       (with-current-buffer (mu4e--message-call #'message-reply to wide)
+         (message-goto-body)
+         (insert (mu4e--compose-cite parent))
+         (current-buffer))))))
 
 ;;;###autoload
 (defun mu4e-compose-reply (&optional wide)
-  "Reply to the message at point.
-If WIDE is non-nil, make it a \"wide\" reply (a.k.a.
-\"reply-to-all\")."
+  "Reply to the message at point. If WIDE is
+non-nil, make it a \"wide\" reply (a.k.a. \"reply-to-all\")."
   (interactive)
-  (mu4e--compose-setup
-   'reply
-   (lambda (parent)
-     (insert (mu4e--decoded-message parent 'headers-only))
-     (message-reply nil wide)
-     (message-goto-body)
-     (insert (mu4e--compose-cite parent)))))
+  (mu4e-compose-reply-to nil wide))
 
 ;;;###autoload
 (defun mu4e-compose-wide-reply ()
-  "Wide-reply to the message at point.
-A.k.a., \"reply-to-all\"."
-  (interactive) (mu4e-compose-reply 'wide))
+  "Wide reply to the message at point.
+(a.k.a. \"reply-to-all\")."
+  (interactive)
+  (mu4e-compose-reply-to nil t))1
 
 ;;;###autoload
 (defun mu4e-compose-supersede ()
-  "Supersede message at point.
+  "Supersede the message at point.
 
 That is, send the message again, with all the same recipients;
 this can be useful to follow-up on a sent message. The message
-must be from current user, as determined through
+must originate from the current user, as determined through
 `mu4e-personal-or-alternative-address-p'."
   (interactive)
-  (mu4e--compose-setup
-   'reply ;; it's a special kind of reply.
-   (lambda (parent)
-     (insert (mu4e--decoded-message parent))
-     (set-buffer-modified-p nil)
-     (message-supersede))))
+  (let ((parent (mu4e-message-at-point)))
+    (mu4e--draft-with-parent
+     'reply ;; it's a special kind of reply.
+     parent
+     (lambda ()
+       (with-current-buffer (mu4e--message-call #'message-supersede))))))
 
-;;;###autoload
 (defun mu4e-compose-forward ()
-  "Forward the message at point."
+  "Forward the message at point.
+To influence the way a message is forwarded, you can use the
+variables ‘message-forward-as-mime’ and
+‘message-forward-show-mml’."
   (interactive)
-  (mu4e--compose-setup
-   'forward
-   (lambda (parent)
-     (let ((message-make-forward-subject-function
-            #'message-forward-subject-fwd))
-       (insert (mu4e--decoded-message parent))
-       (mu4e--delimit-headers)
-       ;; message-forward expects message-reply-headers to be set up; here we
-       ;; only need message-id & references, rest is for completeness.
-       (setq-local message-reply-headers
-                   (make-full-mail-header
-                    0
-                    (or (message-field-value "subject") "none")
-                    (or (message-field-value "from") "nobody")
-                    (message-field-value "date")
-                    (message-field-value "message-id" t)
-                    (message-field-value "references")
-                    0 0 ""))
-       (mu4e--delimit-headers 'undelimit)
-       (set-buffer-modified-p nil)
-       (message-forward)))))
+  (let ((parent (mu4e-message-at-point)))
+    (mu4e--draft-with-parent
+     'forward parent
+     (lambda ()
+       (setq
+        message-reply-headers (make-full-mail-header
+                               0
+                               (or (message-field-value "Subject") "none")
+                               (or (message-field-value "From") "nobody")
+                               (message-field-value "Date")
+                               (message-field-value "Message-Id" t)
+                               (message-field-value "References")
+                               0 0 ""))
+         (with-current-buffer (mu4e--message-call #'message-forward)
+           (current-buffer))))))
 
 ;;;###autoload
 (defun mu4e-compose-edit()
-  "Edit an existing draft message."
-  (interactive)
-  (let* ((msg (mu4e-message-at-point)))
-    (unless  (member 'draft (mu4e-message-field msg :flags))
-      (mu4e-warn "Cannot edit non-draft messages"))
-    (mu4e--compose-setup
-     'edit
-     (lambda (parent)
-       (let ((buf (find-file-noselect (plist-get parent :path))))
-         (with-current-buffer buf
-           (mu4e--delimit-headers))
-         (switch-to-buffer buf))))))
+         "Edit an existing draft message."
+         (interactive)
+         (let* ((msg (mu4e-message-at-point)))
+           (unless  (member 'draft (mu4e-message-field msg :flags))
+             (mu4e-warn "Cannot edit non-draft messages"))
+           (mu4e--draft
+            'edit
+            (lambda ()
+              (with-current-buffer
+                  (find-file-noselect (mu4e-message-readable-path msg))
+                (mu4e--delimit-headers)
+                (current-buffer))))))
 
 ;;;###autoload
 (defun mu4e-compose-resend (address)
   "Re-send the message at point to ADDRESS.
-The message is resent as-is, without any editing."
+The message is resent as-is, without any editing. See
+`message-resend' for details."
   (interactive
    (list (completing-read
           "Resend message to address: " mu4e--contacts-set)))
-  (unless (mu4e-running-p) (mu4e 'background))
-  (let ((path (plist-get (mu4e-message-at-point) :path)))
+  (let ((msg (mu4e-message-at-point)))
     (with-temp-buffer
-      (insert-file-contents path)
+      (mu4e--prepare-draft msg)
+      (insert-file-contents (mu4e-message-readable-path msg))
       (message-resend address))))
-
+
 ;;; Compose Mail
 
 (declare-function mu4e "mu4e")
diff --git a/mu4e/mu4e-draft.el b/mu4e/mu4e-draft.el
new file mode 100644
index 000000000..b4edf7118
--- /dev/null
+++ b/mu4e/mu4e-draft.el
@@ -0,0 +1,673 @@
+;;; mu4e-draft.el --- Helpers for m4e-compose -*- lexical-binding: t -*-
+
+;; Copyright (C) 2024 Dirk-Jan C. Binnema
+
+;; Author: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+;; Maintainer: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+
+;; This file is not part of GNU Emacs.
+
+;; mu4e is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; mu4e is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with mu4e.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; Implements various helper functions for mu4e-compose. This all
+;; look a little convoluted since we need to subvert the gnus/message
+;; functions a bit to work with mu4e.
+
+(require 'message)
+(require 'mu4e-config)
+(require 'mu4e-helpers)
+(require 'mu4e-contacts)
+(require 'mu4e-folders)
+(require 'mu4e-message)
+(require 'mu4e-context)
+(require 'mu4e-window)
+
+;;; Code:
+
+(declare-function mu4e-compose-mode "mu4e-compose")
+(declare-function mu4e "mu4e")
+
+(defcustom mu4e-compose-crypto-policy
+  '(encrypt-encrypted-replies sign-encrypted-replies)
+  "Policy to control when messages will be signed/encrypted.
+
+The value is a list which influence the way draft messages are
+created. Specifically, it might contain:
+
+- `sign-all-messages': Always add a signature.
+- `sign-new-messages': Add a signature to new message, ie.
+  messages that aren't responses to another message.
+- `sign-forwarded-messages': Add a signature when forwarding
+  a message
+- `sign-edited-messages': Add a signature to drafts
+- `sign-all-replies': Add a signature when responding to
+  another message.
+- `sign-plain-replies': Add a signature when responding to
+  non-encrypted messages.
+- `sign-encrypted-replies': Add a signature when responding
+  to encrypted messages.
+
+It should be noted that certain symbols have priorities over one
+another. So `sign-all-messages' implies `sign-all-replies', which
+in turn implies `sign-plain-replies'. Adding both to the set, is
+not a contradiction, but a redundant configuration.
+
+All `sign-*' options have a `encrypt-*' analogue."
+  :type '(set :greedy t
+              (const :tag "Sign all messages" sign-all-messages)
+              (const :tag "Encrypt all messages" encrypt-all-messages)
+              (const :tag "Sign new messages" sign-new-messages)
+              (const :tag "Encrypt new messages" encrypt-new-messages)
+              (const :tag "Sign forwarded messages" sign-forwarded-messages)
+              (const :tag "Encrypt forwarded messages"
+                     encrypt-forwarded-messages)
+              (const :tag "Sign edited messages" sign-edited-messages)
+              (const :tag "Encrypt edited messages" edited-forwarded-messages)
+              (const :tag "Sign all replies" sign-all-replies)
+              (const :tag "Encrypt all replies" encrypt-all-replies)
+              (const :tag "Sign replies to plain messages" sign-plain-replies)
+              (const :tag "Encrypt replies to plain messages"
+                     encrypt-plain-replies)
+              (const :tag "Sign replies to encrypted messages"
+                     sign-encrypted-replies)
+              (const :tag "Encrypt replies to encrypted messages"
+                     encrypt-encrypted-replies))
+  :group 'mu4e-compose)
+
+;;; Crypto
+(defun mu4e--prepare-crypto (parent compose-type)
+  "Possibly encrypt or sign a message based on PARENT and COMPOSE-TYPE.
+See `mu4e-compose-crypto-policy' for more details."
+  (let* ((encrypted-p
+          (and parent (memq 'encrypted (mu4e-message-field parent :flags))))
+         (encrypt
+          (or (memq 'encrypt-all-messages mu4e-compose-crypto-policy)
+              (and (memq 'encrypt-new-messages mu4e-compose-crypto-policy)
+                   (eq compose-type 'new))    ;; new messages
+              (and (eq compose-type 'forward) ;; forwarded
+                   (memq 'encrypt-forwarded-messages mu4e-compose-crypto-policy))
+              (and (eq compose-type 'edit) ;; edit
+                   (memq 'encrypt-edited-messages mu4e-compose-crypto-policy))
+              (and (eq compose-type 'reply) ;; all replies
+                   (memq 'encrypt-all-replies mu4e-compose-crypto-policy))
+              (and (eq compose-type 'reply) (not encrypted-p) ;; plain replies
+                   (memq 'encrypt-plain-replies mu4e-compose-crypto-policy))
+              (and (eq compose-type 'reply) encrypted-p
+                   (memq 'encrypt-encrypted-replies
+                         mu4e-compose-crypto-policy)))) ;; encrypted replies
+         (sign
+          (or (memq 'sign-all-messages mu4e-compose-crypto-policy)
+              (and (eq compose-type 'new) ;; new messages
+                   (memq 'sign-new-messages mu4e-compose-crypto-policy))
+              (and (eq compose-type 'forward) ;; forwarded messages
+                   (memq 'sign-forwarded-messages mu4e-compose-crypto-policy))
+              (and (eq compose-type 'edit) ;; edited messages
+                   (memq 'sign-edited-messages mu4e-compose-crypto-policy))
+              (and (eq compose-type 'reply) ;; all replies
+                   (memq 'sign-all-replies mu4e-compose-crypto-policy))
+              (and (eq compose-type 'reply) (not encrypted-p) ;; plain replies
+                   (memq 'sign-plain-replies mu4e-compose-crypto-policy))
+              (and (eq compose-type 'reply) encrypted-p ;; encrypted replies
+                   (memq 'sign-encrypted-replies mu4e-compose-crypto-policy)))))
+    (cond ((and sign encrypt) (mml-secure-message-sign-encrypt))
+          (sign (mml-secure-message-sign))
+          (encrypt (mml-secure-message-encrypt)))))
+
+(defcustom mu4e-sent-messages-behavior 'sent
+  "Determines what mu4e does with sent messages.
+
+This is one of the symbols:
+* `sent'    move the sent message to the Sent-folder (`mu4e-sent-folder')
+* `trash'   move the sent message to the Trash-folder (`mu4e-trash-folder')
+* `delete'  delete the sent message.
+
+Note, when using GMail/IMAP, you should set this to either
+`trash' or `delete', since GMail already takes care of keeping
+copies in the sent folder.
+
+Alternatively, `mu4e-sent-messages-behavior' can be a function
+which takes no arguments, and which should return one of the mentioned
+symbols, for example:
+
+  (setq mu4e-sent-messages-behavior (lambda ()
+  (if (string= (message-sendmail-envelope-from) \"foo@example.com\")
+       \\='delete \\='sent)))
+
+The various `message-' functions from `message-mode' are available
+for querying the message information."
+  :type '(choice (const :tag "move message to mu4e-sent-folder" sent)
+                 (const :tag "move message to mu4e-trash-folder" trash)
+                 (const :tag "delete message" delete))
+  :group 'mu4e-compose)
+
+(defcustom mu4e-compose-context-policy 'ask
+  "Policy for determining the context when composing a new message.
+
+If the value is `always-ask', ask the user unconditionally.
+
+In all other cases, if any context matches (using its match
+function), this context is used. Otherwise, if none of the
+contexts match, we have the following choices:
+
+- `pick-first': pick the first of the contexts available (ie. the default)
+- `ask': ask the user
+- `ask-if-none': ask if there is no context yet, otherwise leave it as it is
+-  nil: return nil; leaves the current context as is.
+
+Also see `mu4e-context-policy'."
+  :type '(choice
+          (const :tag "Always ask what context to use" always-ask)
+          (const :tag "Ask if none of the contexts match" ask)
+          (const :tag "Ask when there's no context yet" ask-if-none)
+          (const :tag "Pick the first context if none match" pick-first)
+          (const :tag "Don't change the context when none match" nil))
+  :safe 'symbolp
+  :group 'mu4e-compose)
+
+;;
+;; display the ready-to-go display buffer in the desired way.
+;;
+(defun mu4e--display-draft-buffer (cbuf)
+  "Display the message composition buffer CBUF.
+Display is influenced by `mu4e-compose-switch'."
+  (let ((func
+         (pcase mu4e-compose-switch
+           ('nil             #'switch-to-buffer)
+           ('window          #'switch-to-buffer-other-window)
+           ((or 'frame 't)   #'switch-to-buffer-other-frame)
+           ('display-buffer  #'display-buffer)
+           (_             (mu4e-error "Invalid mu4e-compose-switch")))))
+    (funcall func cbuf)))
+
+(defvar mu4e-user-agent-string
+  (format "mu4e %s; emacs %s" mu4e-mu-version emacs-version)
+  "The User-Agent string for mu4e, or nil.")
+
+;;; Runtime variables; useful for user-hooks etc.
+(defvar-local mu4e-compose-parent-message nil
+  "The parent message plist.
+This is the message being replied to, forwarded or edited; used
+in `mu4e-compose-pre-hook'. For new (non-reply, forward etc.)
+messages, it is nil.")
+
+(defvar-local mu4e-compose-type nil
+  "The compose-type for the current message.")
+
+;;; Filenames
+(defun mu4e--draft-basename()
+  "Construct a randomized filename for a message with flags FLAGSTR.
+It looks something like
+    <time>-<random>.<hostname>
+
+This filename is used for the draft message and the sent message,
+depending on `mu4e-sent-messages-behavior'."
+  (let* ((sysname (if (fboundp 'system-name)
+                      (system-name) (with-no-warnings system-name)))
+         (sysname (if (string= sysname "") "localhost" sysname))
+         (hostname (downcase
+                    (save-match-data
+                      (substring sysname
+                                 (string-match "^[^.]+" sysname)
+                                 (match-end 0))))))
+    (format "%s.%04x%04x%04x%04x.%s"
+            (format-time-string "%s" (current-time))
+            (random 65535) (random 65535) (random 65535) (random 65535)
+            hostname)))
+
+(defun mu4e--draft-message-path (base-name &optional parent)
+  "Construct a draft message path, based on PARENT if provided.
+
+PARENT is either nil or the original message (being replied
+ to/forwarded etc.), and is used to determine the draft folder.
+BASE-NAME is the base filename without any Maildir decoration."
+  (let ((draft-dir (mu4e-get-drafts-folder parent)))
+    (mu4e-join-paths
+     (mu4e-root-maildir) draft-dir "cur"
+     (format "%s%s2,DS" base-name mu4e-maildir-info-delimiter))))
+
+(defun mu4e--fcc-path (base-name &optional parent)
+  "Construct a Fcc: path, based on PARENT and `mu4e-sent-messages-behavior'.
+
+PARENT is either nil or the original message (being replied
+to/forwarded etc.), and is used to determine the sent folder,
+together with `mu4e-sent-messages-behavior'. BASE-NAME is the
+base filename without any Maildir decoration.
+
+Returns the path for the sent message, either in the sent or
+trash folder, or nil if the message should be removed after
+sending."
+  (when-let ((sent-dir
+          (pcase mu4e-sent-messages-behavior
+            ('delete nil)
+            ('trash (mu4e-get-trash-folder parent))
+            ('sent (mu4e-get-sent-folder parent))
+            ((pred functionp) (funcall mu4e-sent-messages-behavior))
+            (_ (mu4e-error "Error in `mu4e-sent-messages-behavior'")))))
+    (mu4e-join-paths
+     (mu4e-root-maildir) sent-dir "cur"
+     (format "%s%s2,S" base-name mu4e-maildir-info-delimiter))))
+
+
+
+(defconst mu4e--header-separator
+  ;; XX properties don't show... why not?
+  (propertize "--text follows this line--" 'read-only t 'intangible t)
+  "Line used to separate headers from text in messages being composed.")
+
+(defun mu4e--delimit-headers (&optional undelimit)
+  "Delimit or undelimit (with UNDELIMIT) headers."
+  (let ((mail-header-separator (substring-no-properties mu4e--header-separator))
+        (inhibit-read-only t))
+    (save-excursion (mail-sendmail-undelimit-header)) ;; clear first
+    (unless undelimit (save-excursion (mail-sendmail-delimit-header)))))
+
+(defun mu4e--decoded-message (msg &optional headers-only)
+  "Get the message MSG, decoded as a string.
+With HEADERS-ONLY non-nil, only include the headers part."
+  (with-temp-buffer
+    (setq-local gnus-article-decode-hook
+                '(article-decode-charset
+                  article-decode-encoded-words
+                  article-decode-idna-rhs
+                  article-treat-non-ascii
+                  article-remove-cr
+                  article-de-base64-unreadable
+                  article-de-quoted-unreadable)
+                gnus-inhibit-mime-unbuttonizing nil
+                gnus-unbuttonized-mime-types '(".*/.*")
+                gnus-original-article-buffer (current-buffer))
+    (insert-file-contents-literally
+     (mu4e-message-readable-path msg) nil nil nil t)
+    ;; remove the body / attachments and what not.
+    (when headers-only
+      (rfc822-goto-eoh)
+      (delete-region (point) (point-max)))
+    ;; in rare (broken) case, if a message-id is missing use the generated one
+    ;; from mu.
+    (mu4e--delimit-headers)
+    (unless (message-field-value "Message-Id")
+      (goto-char (point-min))
+      (insert (format "Message-Id: <%s>\n" (plist-get msg :message-id))))
+    (mu4e--delimit-headers 'undelimit)
+    (ignore-errors (run-hooks 'gnus-article-decode-hook))
+    (buffer-substring-no-properties (point-min) (point-max))))
+
+(defvar mu4e--draft-buffer-max-name-length 48)
+(defun mu4e--draft-set-friendly-buffer-name ()
+  "Use some friendly name for this draft buffer."
+  (let* ((subj (message-field-value "subject"))
+         (subj (if (or (not subj) (string-match "^[:blank:]*$" subj))
+                   "No subject"  subj)))
+    (rename-buffer (generate-new-buffer-name
+                    (format "\"%s\""
+                            (truncate-string-to-width subj
+                             mu4e--draft-buffer-max-name-length
+                             0 nil t)))
+                   (buffer-name))))
+
+;; hook impls
+
+(defun mu4e--fcc-handler (msgpath)
+  "Handle Fcc: for MSGPATH.
+This ensures that a copy of a sent messages ends up in the
+appropriate sent-messages folder. If MSGPATH is nil, do nothing."
+  (when msgpath
+    (let* ((target-dir (file-name-directory msgpath))
+           (target-mdir (file-name-directory target-dir)))
+      ;; create maildir if needed
+      (unless (file-exists-p target-mdir)
+        (make-directory
+         (mu4e-join-paths target-mdir "cur" 'parents))
+        (make-directory
+         (mu4e-join-paths target-mdir "new" 'parents)))
+      (write-file msgpath)
+      (mu4e--server-add msgpath))))
+
+;; save / send hooks
+
+(defvar-local mu4e--compose-undo nil
+  "Remember the undo-state.")
+
+(defun mu4e--compose-before-save ()
+  "Function called just before the draft buffer is saved."
+  ;; This does 3 things:
+  ;;  - set the Message-Id if not already
+  ;;  - set the Date if not already
+  ;;  - (temporarily) remove the mail-header separator
+  (setq mu4e--compose-undo buffer-undo-list)
+  (save-excursion
+    (unless (message-field-value "Message-ID")
+      (message-generate-headers '(Message-ID)))
+    ;; older Emacsen (<= 28 perhaps?) won't update the Date
+    ;; if there already is one; so make sure it's gone.
+    (message-remove-header "Date")
+    (message-generate-headers '(Date Subject From))
+    (mu4e--delimit-headers 'undelimit))) ;; remove separator
+
+(defun mu4e--set-parent-flags (path)
+  "Set flags for replied-to and forwarded for the message at PATH.
+That is, set the `replied' \"R\" flag on messages we replied to,
+and the `passed' \"F\" flag on message we have forwarded.
+
+If a message has an \"In-Reply-To\" header, it is considered a
+reply to the message with the corresponding message id.
+Otherwise, if it does not have an \"In-Reply-To\" header, but
+does have a \"References:\" header, it is considered to be a
+forward message for the message corresponding with the /last/
+message-id in the references header.
+
+If the message has been determined to be either a forwarded
+message or a reply, we instruct the server to update that message
+with resp. the \"P\" (passed) flag for a forwarded message, or
+the \"R\" flag for a replied message. The original messages are
+also marked as Seen.
+
+Function assumes that it is executed in the context of the
+message buffer."
+  (when-let ((buf (find-file-noselect path)))
+    (with-current-buffer buf
+      (let ((in-reply-to (message-field-value "in-reply-to"))
+            (forwarded-from)
+            (references (message-field-value "references")))
+        (unless in-reply-to
+          (when references
+            (with-temp-buffer ;; inspired by `message-shorten-references'.
+              (insert references)
+              (goto-char (point-min))
+              (let ((refs))
+                (while (re-search-forward "<[^ <]+@[^ <]+>" nil t)
+                  (push (match-string 0) refs))
+                ;; the last will be the first
+                (setq forwarded-from (car refs))))))
+        ;; remove the <> and update the flags on the server-side.
+        (when (and in-reply-to (string-match "<\\(.*\\)>" in-reply-to))
+          (mu4e--server-move (match-string 1 in-reply-to) nil "+R-N"))
+        (when (and forwarded-from (string-match "<\\(.*\\)>" forwarded-from))
+          (mu4e--server-move (match-string 1 forwarded-from) nil "+P-N"))))))
+
+(defun mu4e--compose-after-save()
+  "Function called immediately after the draft buffer is saved."
+  ;; This does 3 things:
+  ;; - restore the mail-header-separator (see mu4e--compose-before-save)
+  ;; - update the buffer name (based on the message subject
+  ;; - tell the mu server about the updated draft message
+  (mu4e--delimit-headers)
+  (mu4e--draft-set-friendly-buffer-name)
+  ;; tell the server
+  (mu4e--server-add (buffer-file-name))
+  ;; restore history.
+  (set-buffer-modified-p nil)
+  (setq buffer-undo-list mu4e--compose-undo))
+
+(defun mu4e-sent-handler (docid path)
+  "Handler called with DOCID and PATH for the just-sent message.
+For Forwarded ('Passed') and Replied messages, try to set the
+appropriate flag at the message forwarded or replied-to."
+  ;; XXX we don't need this function anymore here, but
+  ;; we have an external caller in mu4e-icalendar... we should
+  ;; update that.
+  (mu4e--set-parent-flags path)
+  ;; if the draft file exists, remove it now.
+  (when (file-exists-p path)
+    (mu4e--server-remove docid)))
+
+(defun mu4e--send-harden-newlines ()
+  "Set the hard property to all newlines."
+  (save-excursion
+    (goto-char (point-min))
+    (while (search-forward "\n" nil t)
+      (put-text-property (1- (point)) (point) 'hard t))))
+
+(defun mu4e--compose-before-send ()
+  "Function called just before sending a message."
+  ;; Remove References: if In-Reply-To: is missing.
+  ;; This allows the user to effectively start a new message-thread by
+  ;; removing the In-Reply-To header.
+  (when (eq mu4e-compose-type 'reply)
+    (unless (message-field-value "In-Reply-To")
+      (message-remove-header "References")))
+  (when use-hard-newlines
+    (mu4e--send-harden-newlines))
+  ;; now handle what happens _after_ sending; typically, draft is gone and
+  ;; the sent message appears in sent. Update flags for related messages,
+  ;; i.e. for Forwarded ('Passed') and Replied messages, try to set the
+  ;; appropriate flag at the message forwarded or replied-to.
+  (add-hook 'message-sent-hook
+            (lambda ()
+              (when-let ((fcc-path (message-field-value "Fcc")))
+                (mu4e--set-parent-flags fcc-path)
+                ;; we end up with a ((buried) buffer here, visiting the
+                ;; fcc-path; not quite sure why. But let's get rid of it (#2681)
+                (when-let ((buf (find-buffer-visiting fcc-path)))
+                  (kill-buffer buf))))
+            nil t))
+
+;; overrides for message-* functions
+;;
+;; mostly some magic because the message-reply/-forward/... functions want to
+;; create and switch to buffer by themselves; but mu4e wants to control
+;; when/where the buffers are shown so we subvert the message-functions and get
+;; the buffer without display it.
+
+(defvar mu4e--message-buf nil
+  "The message buffer created by (overridden) message-* functions.")
+
+(defun mu4e--message-pop-to-buffer (name &optional _switch)
+  "Mu4e override for `message-pop-to-buffer'.
+Creates a buffer NAME and returns it."
+  ;; note: we're in a _different_ buffer here, so we need to copy
+  ;; message-reply-header's buffer-local value.
+  (let ((reply-headers message-reply-headers))
+    (set-buffer (get-buffer-create name))
+    (setq-local message-reply-headers reply-headers)
+    (erase-buffer)
+    (setq mu4e--message-buf (current-buffer))))
+
+(defun mu4e--message-is-yours-p ()
+  "Mu4e's override for `message-is-yours-p'."
+  (seq-some (lambda (field)
+              (if-let ((recip (message-field-value field)))
+                  (mu4e-personal-or-alternative-address-p
+                   (car (mail-header-parse-address recip)))))
+            '("From" "Sender")))
+
+(defmacro mu4e--validate-hidden-buffer (&rest body)
+  "Macro to evaluate BODY and asserts that it yields a valid buffer.
+Where valid means that it is a live an non-active buffer.
+Returns said buffer."
+  `(let ((buf (progn ,@body)))
+     (cl-assert (buffer-live-p buf))
+     (cl-assert (not (eq buf (window-buffer (selected-window)))))
+     buf))
+
+(defun mu4e--message-call (func &rest params)
+  "Call message/gnus functions from a mu4e-context.
+E.g., functions such as `message-reply' or `message-forward', but
+manipulate such that they do *not* switch to the created buffer,
+but merely return it.
+
+FUNC is the function to call and PARAMS are its parameters.
+
+For replying/forwarding, this functions expects to be called
+while in a buffer with the to-be-forwarded/replied-to message."
+  (let* ((message-this-is-mail t)
+         (message-generate-headers-first nil)
+         (message-newsreader mu4e-user-agent-string)
+         (message-mail-user-agent nil))
+    (cl-letf
+        ;; `message-pop-to-buffer' attempts switching the visible buffer;
+        ;; instead, we manipulate it to _return_ the buffer.
+        (((symbol-function #'message-pop-to-buffer)
+          #'mu4e--message-pop-to-buffer)
+         ;; teach `message-is-yours-p' about how mu4e defines that
+         ((symbol-function #'message-is-yours-p)
+          #'mu4e--message-is-yours-p))
+      ;; also turn off all the gnus crypto handling, we do that ourselves..
+      (setq-local gnus-message-replysign nil
+                  gnus-message-replyencrypt nil
+                  gnus-message-replysignencrypted nil)
+      (setq mu4e--message-buf nil)
+      (apply func params))
+    (mu4e--validate-hidden-buffer mu4e--message-buf)))
+
+;;
+;; make the draft buffer ready for use.
+;;
+
+(defun mu4e--jump-to-a-reasonable-place ()
+  "Jump to a reasonable place for writing an email."
+  (if (not (message-field-value "To"))
+      (message-goto-to)
+    (if (not (message-field-value "Subject"))
+        (message-goto-subject)
+      (pcase message-cite-reply-position
+        ((or 'above 'traditional) (message-goto-body))
+        (_ (when (message-goto-signature) (forward-line -2)))))))
+
+(defvar mu4e-draft-hidden-headers
+  (append message-hidden-headers '("^User-agent:" "^Fcc:"))
+  "Message headers to hide when composing.
+This is mu4e's version of `message-hidden-headers'.")
+
+(defun mu4e--prepare-draft (&optional parent)
+  "Get ready for message composition.
+PARENT is the parent message, if any."
+  (unless (mu4e-running-p) (mu4e 'background)) ;; start if needed
+  (mu4e--context-autoswitch parent mu4e-compose-context-policy))
+
+(defun mu4e--prepare-draft-headers (compose-type)
+  "Add extra headers for message based on COMPOSE-TYPE."
+  (message-generate-headers
+   (seq-filter #'identity ;; ensure needed headers are generated.
+               `(From Subject Date Message-ID
+                      ,(when (memq compose-type '(reply forward)) 'References)
+                      ,(when (eq compose-type 'reply) 'In-Reply-To)
+                      ,(when message-newsreader 'User-Agent)
+                      ,(when message-user-organization 'Organization)))))
+
+(defun mu4e--prepare-draft-buffer (compose-type parent)
+  "Prepare the current buffer as a draft-buffer.
+COMPOSE-TYPE and PARENT are as in `mu4e--draft'."
+  (cl-assert (member compose-type '(reply forward edit new)))
+  (cl-assert (eq (if parent t nil)
+                 (if (member compose-type '(reply forward)) t nil)))
+  ;; remember some variables, e.g for user hooks. These are permanent-local
+  ;; hence survive the mode-switch below (we do this so these useful vars are
+  ;; available in mode-hooks.
+  (setq
+   mu4e-compose-parent-message parent
+   mu4e-compose-type compose-type)
+
+  ;; draft path
+  (unless (eq compose-type 'edit)
+    (set-visited-file-name ;; make it a draft file
+     (mu4e--draft-message-path (mu4e--draft-basename) parent)))
+  ;; fcc
+  (when-let ((fcc-path (mu4e--fcc-path (mu4e--draft-basename) parent)))
+    (message-add-header (concat "Fcc: " fcc-path "\n")))
+
+  (mu4e--prepare-draft-headers compose-type)
+  (mu4e--prepare-crypto parent compose-type)
+  ;; set the attachment dir to something more reasonable than the draft
+  ;; directory.
+  (setq default-directory (mu4e-determine-attachment-dir))
+  (mu4e--draft-set-friendly-buffer-name)
+
+  ;; now, switch to compose mode
+  (mu4e-compose-mode)
+
+  ;; hide some internal headers
+  (let ((message-hidden-headers mu4e-draft-hidden-headers))
+    (message-hide-headers))
+
+  ;; hooks
+  (add-hook 'before-save-hook  #'mu4e--compose-before-save nil t)
+  (add-hook 'after-save-hook   #'mu4e--compose-after-save nil t)
+  (add-hook 'message-send-hook #'mu4e--compose-before-send nil t)
+  (setq-local message-fcc-handler-function #'mu4e--fcc-handler)
+
+  (mu4e--jump-to-a-reasonable-place)
+
+  (set-buffer-modified-p nil)
+  (undo-boundary))
+
+(defun mu4e--prepare-message-actions (oldframe)
+  "Set up some message actions.
+In particular, handle closing frames when we created it. OLDFRAME
+is the frame from which the message-composition was triggered."
+  (let* ((msgframe (selected-frame))
+         (maybe-kill-frame ;; kill frame when it was created for this
+          (lambda ()
+            (when (and (frame-live-p msgframe) (not (eq oldframe msgframe)))
+              (delete-frame msgframe)))))
+    (make-local-variable 'message-send-actions)
+    (make-local-variable 'message-exit-actions)
+    (make-local-variable 'message-kill-actions)
+    (make-local-variable 'message-postpone-actions)
+
+    (add-to-list 'message-kill-actions maybe-kill-frame)
+    (add-to-list 'message-postpone-actions maybe-kill-frame)))
+
+(defun mu4e--draft (compose-type compose-func &optional parent)
+  "Create a new message draft.
+
+This is the central access point for creating new mail buffers;
+when there's a parent message, use `mu4e--compose-with-parent'.
+
+COMPOSE-TYPE is the type of message to create. COMPOSE-FUNC is a
+function that must return a buffer that satisfies
+`mu4e--validate-hidden-buffer'.
+
+Optionally, PARENT is the message parent or nil. For compose-type
+`reply' and `forward' we require a PARENT; for the other compose
+it must be nil.
+
+After this, user is presented with a message composition buffer."
+  (mu4e--prepare-draft parent)
+  ;; evaluate BODY; this must yield a hidden, live buffer. This is evaluated in
+  ;; a temp buffer with contains the parent-message, if any. if there's a
+  ;; PARENT, load the corresponding message into a temp-buffer before calling
+  ;; compose-func
+  (let ((draft-buffer) (oldframe (selected-frame)))
+    (with-temp-buffer
+      ;; provide a temp buffer so the compose-func can do its thing. without
+      ;; interference.
+      (setq draft-buffer (mu4e--validate-hidden-buffer (funcall compose-func)))
+      (with-current-buffer draft-buffer
+        ;; we have our basic buffer; turn it into a full mu4e composition buffer.
+        (mu4e--prepare-draft-buffer compose-type parent)))
+    ;; we're ready for composition; let's display it in the way user configured
+    ;; things.
+    (mu4e-display-buffer draft-buffer 'do-select)
+    ;; prepare possible message actions (such as cleaning-up)
+    (mu4e--prepare-message-actions oldframe)
+    draft-buffer))
+
+(defun mu4e--draft-with-parent (compose-type parent compose-func)
+  "Draft a message based on some parent message.
+COMPOSE-TYPE, COMPOSE-FUNC and PARENT are as in `mu4e--draft',
+but note the different order."
+  (mu4e--draft
+   compose-type
+   (lambda ()
+     (let ( ;; only needed for Fwd. Gnus has a bad default.
+           (message-make-forward-subject-function
+            (list #'message-forward-subject-fwd)))
+       (insert (mu4e--decoded-message parent))
+       (funcall compose-func)))
+   parent))
+
+(provide 'mu4e-draft)
diff --git a/mu4e/mu4e-obsolete.el b/mu4e/mu4e-obsolete.el
index 0ad5e9da8..c040e1abe 100644
--- a/mu4e/mu4e-obsolete.el
+++ b/mu4e/mu4e-obsolete.el
@@ -1,6 +1,6 @@
 ;;; mu4e-obsolete.el --- Obsolete things -*- lexical-binding: t -*-
 
-;; Copyright (C) 2022-2023 Dirk-Jan C. Binnema
+;; Copyright (C) 2022-2024 Dirk-Jan C. Binnema
 
 ;; Author: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ;; Maintainer: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
@@ -65,6 +65,10 @@
   'mu4e-compose-cite-function 'message-cite-function "1.11.22")
 (define-obsolete-variable-alias
   'mu4e-compose-in-new-frame 'mu4e-compose-switch "1.11.22")
+
+(define-obsolete-variable-alias 'mu4e-compose-hidden-headers
+  'mu4e-draft-hidden-headers "1.12.5")
+
 
 ;; mu4e-message
 
diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index e1ca68266..de057d40e 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -1648,8 +1648,8 @@ The major mode for the composer is @code{mu4e-compose-mode}.
 There are a view different ways to @emph{enter} the composer; i.e., from other
 @t{mu4e} views or even completely outside.
 
-If you want the composer to start in a new frame or window, see the variable
-@t{mu4e-compose-switch}.
+If you want the composer to start in a new frame or window, you can configure
+the variable @t{mu4e-compose-switch}; see its docstring for details.
 
 @subsection New message
 

From 813ce795ff7a835fc8554015dacd200180b533f7 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 23 Apr 2024 23:06:38 +0300
Subject: [PATCH 011/305] mu4e-icalendar: integrate with mu4e-compose

So we use context and display settings.
---
 mu4e/mu4e-icalendar.el | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/mu4e/mu4e-icalendar.el b/mu4e/mu4e-icalendar.el
index c5eabc2c9..30feb51c4 100644
--- a/mu4e/mu4e-icalendar.el
+++ b/mu4e/mu4e-icalendar.el
@@ -134,15 +134,14 @@
                     (or organizer
                         (plist-get (car (plist-get msg :reply-to)) :email)
                         (plist-get (car (plist-get msg :from)) :email)
-                        (mu4e-warn "Cannot find organizer"))))
-              (message-reply organizer)
-              (goto-char (point-max))
+                        (mu4e-warn "Cannot find organizer")))
+                   (message-cite-function #'mu4e-message-cite-nothing))
+              (mu4e-compose-reply-to organizer)
               (message-goto-body)
               (mml-insert-multipart "alternative")
               (mml-insert-empty-tag 'part 'type "text/plain")
               (mml-attach-buffer ical-name
                                  "text/calendar; method=REPLY; charset=UTF-8")
-              (mu4e-compose-mode)
               (when mu4e-icalendar-trash-after-reply
                 ;; Override `mu4e-sent-handler' set by `mu4e-compose-mode' to
                 ;; also trash the message (thus must be appended to hooks).

From a9b78718b25b1b34cf36c99b01e09d49a3255aff Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Wed, 24 Apr 2024 12:52:54 +0300
Subject: [PATCH 012/305] mu4e-draft/window: handle buffer display in
 mu4e-window

Handle buffer display where all mu4e's buffer display is done: in mu4e-window.el.

Avoid overly long lines in mu4e-window.el.
---
 mu4e/mu4e-draft.el  | 13 ++++---
 mu4e/mu4e-window.el | 82 ++++++++++++++++++++++++++++++++-------------
 2 files changed, 67 insertions(+), 28 deletions(-)

diff --git a/mu4e/mu4e-draft.el b/mu4e/mu4e-draft.el
index b4edf7118..2dcb1f0b9 100644
--- a/mu4e/mu4e-draft.el
+++ b/mu4e/mu4e-draft.el
@@ -635,7 +635,9 @@ Optionally, PARENT is the message parent or nil. For compose-type
 `reply' and `forward' we require a PARENT; for the other compose
 it must be nil.
 
-After this, user is presented with a message composition buffer."
+After this, user is presented with a message composition buffer.
+
+Returns the new buffer."
   (mu4e--prepare-draft parent)
   ;; evaluate BODY; this must yield a hidden, live buffer. This is evaluated in
   ;; a temp buffer with contains the parent-message, if any. if there's a
@@ -647,11 +649,14 @@ After this, user is presented with a message composition buffer."
       ;; interference.
       (setq draft-buffer (mu4e--validate-hidden-buffer (funcall compose-func)))
       (with-current-buffer draft-buffer
-        ;; we have our basic buffer; turn it into a full mu4e composition buffer.
+        ;; we have our basic buffer; turn it into a full mu4e composition
+        ;; buffer.
         (mu4e--prepare-draft-buffer compose-type parent)))
     ;; we're ready for composition; let's display it in the way user configured
-    ;; things.
-    (mu4e-display-buffer draft-buffer 'do-select)
+    ;; things: directly through display buffer (via pop-t or otherwise through mu4e-window.
+    (if (eq mu4e-compose-switch 'display-buffer)
+        (pop-to-buffer draft-buffer)
+      (mu4e-display-buffer draft-buffer 'do-select))
     ;; prepare possible message actions (such as cleaning-up)
     (mu4e--prepare-message-actions oldframe)
     draft-buffer))
diff --git a/mu4e/mu4e-window.el b/mu4e/mu4e-window.el
index 4714eedce..af2e9335d 100644
--- a/mu4e/mu4e-window.el
+++ b/mu4e/mu4e-window.el
@@ -1,6 +1,7 @@
 ;;; mu4e-window.el --- Window management -*- lexical-binding: t; -*-
 
 ;; Copyright (C) 2022  Mickey Petersen
+;; Copyright (C) 2023-2024 Dirk-Jan C. Binnema
 
 ;; Author: Mickey Petersen <mickey@masteringemacs.org>
 ;; Keywords: mail
@@ -33,7 +34,6 @@
 (defvar mu4e-embedded-buffer-name " *mu4e-embedded*"
   "Name for the embedded message view buffer.")
 
-
 ;; Buffer names for public use
 
 (defvar mu4e-headers-buffer-name "*mu4e-headers*"
@@ -89,6 +89,20 @@ vertical split-view."
   :type 'integer
   :group 'mu4e-headers)
 
+(defcustom mu4e-compose-switch nil
+  "Where to display the new message?
+A symbol:
+- nil           : default (new buffer)
+- window        : compose in new window
+- frame or t    : compose in new frame
+- display-buffer: use `display-buffer' / `display-buffer-alist'
+  (for fine-tuning).
+
+For backward compatibility with `mu4e-compose-in-new-frame', t is
+treated as =\\'frame."
+  :type 'symbol
+  :group 'mu4e-compose)
+
 (declare-function mu4e-view-mode "mu4e-view")
 (declare-function mu4e-error     "mu4e-helpers")
 (declare-function mu4e-warn      "mu4e-helpers")
@@ -196,20 +210,24 @@ being created if CREATE is non-nil."
     (let ((buffer)
           ;; If `mu4e-view-buffer-name-func' is non-nil, then use that
           ;; to source the name of the view buffer to create or re-use.
-          (buffer-name (or (and mu4e-view-buffer-name-func
-                                (funcall mu4e-view-buffer-name-func headers-buffer))
-                           ;; If the variable is nil, use the default
-                           ;; name
-                           mu4e-view-buffer-name))
+          (buffer-name
+           (or (and mu4e-view-buffer-name-func
+                    (funcall mu4e-view-buffer-name-func headers-buffer))
+               ;; If the variable is nil, use the default
+               ;; name
+               mu4e-view-buffer-name))
           ;; Search all view buffers and return those that are linked to
           ;; `headers-buffer'.
-          (linked-buffer (mu4e-get-view-buffers
-                          (lambda (buf)
-                            (and (mu4e--buffer-local-boundp 'mu4e-linked-headers-buffer buf)
-                                 (eq mu4e-linked-headers-buffer headers-buffer))))))
-      ;; If such a linked buffer exists and its buffer is live, we use that buffer.
+          (linked-buffer
+           (mu4e-get-view-buffers
+            (lambda (buf)
+              (and (mu4e--buffer-local-boundp 'mu4e-linked-headers-buffer buf)
+                   (eq mu4e-linked-headers-buffer headers-buffer))))))
+      ;; If such a linked buffer exists and its buffer is live, we use that
+      ;; buffer.
       (if (and linked-buffer (buffer-live-p (car linked-buffer)))
-          ;; NOTE: It's possible for there to be more than one linked view buffer.
+          ;; NOTE: It's possible for there to be more than one linked view
+          ;; buffer.
           ;;
           ;; What, if anything, should the heuristic be to pick the
           ;; one to use? Presently `car' is used, but there are better
@@ -274,8 +292,10 @@ for BUFFER-OR-NAME to be displayed in."
     (setq mu4e-split-view 'horizontal))
 
   (let* ((buffer-name (or (get-buffer buffer-or-name)
-                          (mu4e-error "Buffer `%s' does not exist" buffer-or-name)))
-         (buffer-type (with-current-buffer buffer-name (mu4e--get-current-buffer-type)))
+                          (mu4e-error "Buffer `%s' does not exist"
+                                      buffer-or-name)))
+         (buffer-type
+          (with-current-buffer buffer-name (mu4e--get-current-buffer-type)))
          (direction (cons 'direction
                           (pcase (cons buffer-type mu4e-split-view)
                             ;; views or headers can display
@@ -289,19 +309,34 @@ for BUFFER-OR-NAME to be displayed in."
             ;; views or headers can display
             ;; horz/vert depending on the value of
             ;; `mu4e-split-view'
-            ('(view . horizontal) '((window-height . shrink-window-if-larger-than-buffer)))
-            ('(view . vertical) '((window-min-width . fit-window-to-buffer)))
+            ('(view . horizontal)
+             '((window-height . shrink-window-if-larger-than-buffer)))
+            ('(view . vertical)
+             '((window-min-width . fit-window-to-buffer)))
             (`(,_ . t) nil)))
          (window-action (cond
-                         ((eq buffer-type 'main) '(display-buffer-reuse-window
-                                                   display-buffer-reuse-mode-window
-                                                   display-buffer-full-frame))
-                         ((memq buffer-type '(headers compose))
+                         ;; main-buffer
+                         ((eq buffer-type 'main)
+                          '(display-buffer-reuse-window
+                            display-buffer-reuse-mode-window
+                            display-buffer-full-frame))
+                         ;; compose-buffer
+                         ((eq buffer-type 'compose)
+                          (pcase mu4e-compose-switch
+                            ('window          #'display-buffer-pop-up-window)
+                            ((or 'frame 't)   #'display-buffer-pop-up-frame)
+                            (_                '(display-buffer-reuse-window
+                                                display-buffer-reuse-mode-window
+                                                display-buffer-same-window))))
+                         ;; headers buffer
+                         ((memq buffer-type '(headers))
                           '(display-buffer-reuse-window
                             display-buffer-reuse-mode-window
                             display-buffer-same-window))
+
                          ((memq mu4e-split-view '(horizontal vertical))
                           '(display-buffer-in-direction))
+
                          ((memq mu4e-split-view '(single-window))
                           '(display-buffer-reuse-window
                             display-buffer-reuse-mode-window
@@ -314,8 +349,7 @@ for BUFFER-OR-NAME to be displayed in."
                               display-buffer-same-window))))
          (arg `((,@window-action)
                 ,@window-size
-                ,direction
-                )))
+                ,direction)))
     (funcall (if select #'pop-to-buffer #'display-buffer)
              buffer-name
              arg)))
@@ -339,11 +373,11 @@ This function is best called from the hook
     ;; cause for error.
     (ignore-errors
       (cond ((eq mu4e-split-view 'vertical)
-             (window-resize win (- mu4e-headers-visible-columns (window-width win nil))
+             (window-resize win (- mu4e-headers-visible-columns
+                                   (window-width win nil))
                             t t nil))
             ((eq mu4e-split-view 'horizontal)
              (set-window-text-height win mu4e-headers-visible-lines))))))
 
-
 (provide 'mu4e-window)
 ;;; mu4e-window.el ends here

From a49cd03f6ba207e73146630da24036ad57bbb296 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Thu, 25 Apr 2024 22:31:43 +0300
Subject: [PATCH 013/305] mu4e-drafts: improve mu4e--fcc-path

Reworked from the pull #2698 for the new branch.
---
 mu4e/mu4e-draft.el | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/mu4e/mu4e-draft.el b/mu4e/mu4e-draft.el
index 2dcb1f0b9..c8200bd46 100644
--- a/mu4e/mu4e-draft.el
+++ b/mu4e/mu4e-draft.el
@@ -249,17 +249,19 @@ base filename without any Maildir decoration.
 Returns the path for the sent message, either in the sent or
 trash folder, or nil if the message should be removed after
 sending."
-  (when-let ((sent-dir
-          (pcase mu4e-sent-messages-behavior
+  (let* ((behavior
+          (if (functionp mu4e-sent-messages-behavior)
+              (funcall mu4e-sent-messages-behavior) mu4e-sent-messages-behavior))
+         (sent-dir
+          (pcase behavior
             ('delete nil)
             ('trash (mu4e-get-trash-folder parent))
             ('sent (mu4e-get-sent-folder parent))
-            ((pred functionp) (funcall mu4e-sent-messages-behavior))
             (_ (mu4e-error "Error in `mu4e-sent-messages-behavior'")))))
-    (mu4e-join-paths
-     (mu4e-root-maildir) sent-dir "cur"
-     (format "%s%s2,S" base-name mu4e-maildir-info-delimiter))))
-
+    (when sent-dir
+         (mu4e-join-paths
+          (mu4e-root-maildir) sent-dir "cur"
+          (format "%s%s2,S" base-name mu4e-maildir-info-delimiter)))))
 
 
 (defconst mu4e--header-separator

From 44405940661d34aeafc5d6c1ef6553c9636d6a27 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 27 Apr 2024 17:20:19 +0300
Subject: [PATCH 014/305] mu4e: implement mu4e-compose-post-hook

A hook for when we're done with message composition.

We populate it with a function to kill created frames and one to attempt
to restore window configuration.
---
 mu4e/mu4e-compose.el | 19 ++++++++++
 mu4e/mu4e-draft.el   | 89 ++++++++++++++++++++++++++++++++++++--------
 mu4e/mu4e.texi       | 10 +++--
 3 files changed, 100 insertions(+), 18 deletions(-)

diff --git a/mu4e/mu4e-compose.el b/mu4e/mu4e-compose.el
index f085619a3..142b74e5e 100644
--- a/mu4e/mu4e-compose.el
+++ b/mu4e/mu4e-compose.el
@@ -72,6 +72,25 @@ the place to do that."
   :type 'hook
   :group 'mu4e-compose)
 
+(defcustom mu4e-compose-post-hook
+  (list
+   ;; kill compose frames
+   #'mu4e-compose-post-kill-frame
+   ;; attempt to restore the old configuration.
+   #'mu4e-compose-post-restore-window-configuration)
+  "Hook run *after* message composition is over.
+
+This is hook is run when   composition buffer,
+either by sending, postponing, exiting or killing it.
+
+This multiplexes the `message-mode' hooks `message-send-actions',
+`message-postpone-actions', `message-exit-actions' and
+`message-kill-actions', and the hook is run with a variable
+`mu4e-compose-post-trigger' set correspondingly to a symbol,
+`send', `postpone', `exit' or `kill'."
+  :type 'hook
+  :group 'mu4e-compose)
+
 
 
 (defvar mu4e-captured-message)
diff --git a/mu4e/mu4e-draft.el b/mu4e/mu4e-draft.el
index c8200bd46..5e30710d8 100644
--- a/mu4e/mu4e-draft.el
+++ b/mu4e/mu4e-draft.el
@@ -606,22 +606,79 @@ COMPOSE-TYPE and PARENT are as in `mu4e--draft'."
   (set-buffer-modified-p nil)
   (undo-boundary))
 
-(defun mu4e--prepare-message-actions (oldframe)
-  "Set up some message actions.
-In particular, handle closing frames when we created it. OLDFRAME
-is the frame from which the message-composition was triggered."
-  (let* ((msgframe (selected-frame))
-         (maybe-kill-frame ;; kill frame when it was created for this
-          (lambda ()
-            (when (and (frame-live-p msgframe) (not (eq oldframe msgframe)))
-              (delete-frame msgframe)))))
+;;
+;; mu4e-compose-pos-hook helpers
+
+(defvar mu4e--before-draft-window-config nil
+  "The window configuration just before creating the draft.")
+
+(defun mu4e-compose-post-restore-window-configuration()
+  "Function that perhaps restores the window configuration.
+I.e. the configuration just before the draft buffer appeared.
+This is for use in `mu4e-compose-post-hook'.
+See `set-window-configuration' for further details."
+  (when mu4e--before-draft-window-config
+    ;;(message "RESTORE to %s" mu4e--before-draft-window-config)
+    (set-window-configuration mu4e--before-draft-window-config)
+    (setq mu4e--before-draft-window-config nil)))
+
+(defvar mu4e--draft-activation-frame nil
+  "Frame from which composition was activated.
+Used internally for mu4e-compose-post-kill-frame.")
+
+(defun mu4e-compose-post-kill-frame ()
+  "Function that perhaps kills the composition frame.
+This is for use in `mu4e-compose-post-hook'."
+  (let ((msgframe (selected-frame)))
+    ;;(message "kill frame? %s %s" mu4e--draft-activation-frame msgframe)
+    (when (and (frame-live-p msgframe)
+               (not (eq mu4e--draft-activation-frame msgframe)))
+      (delete-frame msgframe))))
+
+(defvar mu4e-message-post-action nil
+  "Runtime variable for use with `mu4e-compose-post-hook'.
+It contains a symbol denoting the action that triggered the hook,
+either `send', `exit', `kill' or `postpone'.")
+
+(defvar mu4e-compose-post-hook)
+(defun mu4e--message-post-actions (trigger)
+  "Invoked after we're done with a message.
+
+I.e. this multiplexes the `message-(send|exit|kill|postpone)-actions';
+with the mu4e-message-post-action set accordingly."
+  (setq mu4e-message-post-action trigger)
+  (run-hooks 'mu4e-compose-post-hook))
+
+(defun mu4e--prepare-post (&optional oldframe oldwindconf)
+    "Prepare the `mu4e-compose-post-hook` handling.
+
+Set up some message actions. In particular, handle closing frames
+when we created it. OLDFRAME is the frame from which the
+message-composition was triggered. OLDWINDCONF is the current
+window configuration."
+    ;; remember current frame & window conf
+    (setq mu4e--draft-activation-frame oldframe
+          mu4e--before-draft-window-config oldwindconf)
+
+    ;; make message's "post" hooks local, and multiplex them
     (make-local-variable 'message-send-actions)
+    (make-local-variable 'message-postpone-actions)
     (make-local-variable 'message-exit-actions)
     (make-local-variable 'message-kill-actions)
-    (make-local-variable 'message-postpone-actions)
 
-    (add-to-list 'message-kill-actions maybe-kill-frame)
-    (add-to-list 'message-postpone-actions maybe-kill-frame)))
+    (push (lambda () (mu4e--message-post-actions 'send))
+          message-send-actions)
+    (push (lambda () (mu4e--message-post-actions 'postpone))
+          message-postpone-actions)
+    (push (lambda () (mu4e--message-post-actions 'exit))
+          message-exit-actions)
+    (push (lambda () (mu4e--message-post-actions 'kill))
+          message-kill-actions))
+
+;;
+;; creating drafts
+;;
+
 
 (defun mu4e--draft (compose-type compose-func &optional parent)
   "Create a new message draft.
@@ -645,9 +702,11 @@ Returns the new buffer."
   ;; a temp buffer with contains the parent-message, if any. if there's a
   ;; PARENT, load the corresponding message into a temp-buffer before calling
   ;; compose-func
-  (let ((draft-buffer) (oldframe (selected-frame)))
+  (let ((draft-buffer)
+        (oldframe (selected-frame))
+        (oldwinconf (current-window-configuration)))
     (with-temp-buffer
-      ;; provide a temp buffer so the compose-func can do its thing. without
+      ;; provide a temp buffer so the compose-func can do its thing. withou
       ;; interference.
       (setq draft-buffer (mu4e--validate-hidden-buffer (funcall compose-func)))
       (with-current-buffer draft-buffer
@@ -660,7 +719,7 @@ Returns the new buffer."
         (pop-to-buffer draft-buffer)
       (mu4e-display-buffer draft-buffer 'do-select))
     ;; prepare possible message actions (such as cleaning-up)
-    (mu4e--prepare-message-actions oldframe)
+    (mu4e--prepare-post oldframe oldwinconf)
     draft-buffer))
 
 (defun mu4e--draft-with-parent (compose-type parent compose-func)
diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index de057d40e..e3e226c6b 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -1798,11 +1798,15 @@ value of various properties (and see @ref{Message functions}).
 starts, when the whole buffer has already been set up. This is a good place
 for editing-related settings. @code{mu4e-compose-parent-message} (see above)
 is also at your disposal.
+@item @code{mu4e-compose-post-hook}: this hook is run when we're done with
+message compositions. See the docstring for details.
 @end itemize
 
 @noindent
-Let's look at an examples. As mentioned, @code{mu4e-compose-mode-hook} is especially
-useful for editing-related settings. For example:
+As mentioned, @code{mu4e-compose-mode-hook} is especially useful for
+editing-related settings:
+
+Let's look at an example:
 @lisp
 (add-hook 'mu4e-compose-mode-hook
   (defun my-do-compose-stuff ()
@@ -1811,7 +1815,7 @@ useful for editing-related settings. For example:
     (flyspell-mode)))
 @end lisp
 
-This hook is also useful for adding headers or changing headers, since the
+The hook is also useful for adding headers or changing headers, since the
 message is fully formed when this hook runs. For example, to add a
 @t{Bcc:}-header, you could add something like the following, using
 @code{message-add-header} from @code{message-mode}.

From 6e8418bc646ed7117d8ca676096a1466454fd07c Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 28 Apr 2024 14:28:38 +0300
Subject: [PATCH 015/305] mu-server: better handle msgid-not-found in move

It's opportunistic: messages referred to be msgid may not exist, and
that's okay.
---
 lib/mu-server.cc | 70 +++++++++++++++++++++++++++++++++---------------
 1 file changed, 49 insertions(+), 21 deletions(-)

diff --git a/lib/mu-server.cc b/lib/mu-server.cc
index be1c6aa1e..87757e64c 100644
--- a/lib/mu-server.cc
+++ b/lib/mu-server.cc
@@ -449,7 +449,8 @@ Server::Private::invoke(const std::string& expr) noexcept
 			throw res.error();
 
 	} catch (const Mu::Error& me) {
-		output_sexp(make_error(me.code(), mu_format("{}", me.what())));
+		output_sexp(make_error(me.code(), mu_format("{}",
+							    me.what())));
 		keep_going_ = true;
 	} catch (const Xapian::Error& xerr) {
 		output_sexp(make_error(Error::Code::Internal,
@@ -458,7 +459,17 @@ Server::Private::invoke(const std::string& expr) noexcept
 		keep_going_ = false;
 	} catch (const std::runtime_error& re) {
 		output_sexp(make_error(Error::Code::Internal,
-				       mu_format("caught exception: {}", re.what())));
+				       mu_format("caught runtime exception: {}",
+						 re.what())));
+		keep_going_ = false;
+	} catch (const std::out_of_range& oore) {
+		output_sexp(make_error(Error::Code::Internal,
+				       mu_format("caught out-of-range exception: {}",
+						 oore.what())));
+		keep_going_ = false;
+	} catch (const std::exception& e) {
+		output_sexp(make_error(Error::Code::Internal,
+				       mu_format(" exception: {}", e.what())));
 		keep_going_ = false;
 	} catch (...) {
 		output_sexp(make_error(Error::Code::Internal,
@@ -872,10 +883,14 @@ Server::Private::move_docid(Store::Id		docid,
 }
 
 /*
- * 'move' moves a message to a different maildir and/or changes its
- * flags. parameters are *either* a 'docid:' or 'msgid:' pointing to
- * the message, a 'maildir:' for the target maildir, and a 'flags:'
- * parameter for the new flags.
+ * 'move' moves a message to a different maildir and/or changes its flags.
+ * parameters are *either* a 'docid:' or 'msgid:' pointing to the message, a
+ * 'maildir:' for the target maildir, and a 'flags:' parameter for the new
+ * flags.
+ *
+ * With :msgid, this is "opportunistic": it's not an error when the given
+ * message-id does not exist. This is e.g. for the case when tagging possible
+ * related messages.
  */
 void
 Server::Private::move_handler(const Command& cmd)
@@ -886,7 +901,19 @@ Server::Private::move_handler(const Command& cmd)
 	const auto no_view{cmd.boolean_arg(":noupdate")};
 	const auto docids{determine_docids(store_, cmd)};
 
-	if (docids.size() > 1) {
+	if (docids.empty()) {
+		if (!!cmd.string_arg(":msgid")) {
+			// msgid not found: no problem.
+			mu_debug("no move: '{}' not found",
+				 *cmd.string_arg(":msgid"));
+			return;
+		}
+		// however, if we wanted to be move by msgid, it's worth raising
+		// an error.
+			throw Mu::Error{Error::Code::Store,
+				"message not found in store (docid={})",
+				cmd.number_arg(":docid").value_or(0)};
+	} else if (docids.size() > 1) {
 		if (!maildir.empty()) // ie. duplicate message-ids.
 			throw Mu::Error{Error::Code::Store,
 				"cannot move multiple messages at the same time"};
@@ -894,21 +921,22 @@ Server::Private::move_handler(const Command& cmd)
 		for (auto&& docid : docids)
 			move_docid(docid, flagopt, rename, no_view);
 		return;
+	} else {
+		const auto docid{docids.at(0)};
+		auto    msg = store().find_message(docid)
+			.or_else([&]{throw Error{Error::Code::InvalidArgument,
+						"cannot find message {}", docid};}).value();
+
+		/* if maildir was not specified, take the current one */
+		if (maildir.empty())
+			maildir = msg.maildir();
+
+		/* determine the real target flags, which come from the flags-parameter
+		 * we received (ie., flagstr), if any, plus the existing message
+		 * flags. */
+		const auto flags = calculate_message_flags(msg, flagopt);
+		perform_move(docid, msg, maildir, flags, rename, no_view);
 	}
-	const auto docid{docids.at(0)};
-	auto    msg = store().find_message(docid)
-		.or_else([&]{throw Error{Error::Code::InvalidArgument,
-					"cannot find message {}", docid};}).value();
-
-	/* if maildir was not specified, take the current one */
-	if (maildir.empty())
-		maildir = msg.maildir();
-
-	/* determine the real target flags, which come from the flags-parameter
-	 * we received (ie., flagstr), if any, plus the existing message
-	 * flags. */
-	const auto flags = calculate_message_flags(msg, flagopt);
-	perform_move(docid, msg, maildir, flags, rename, no_view);
 }
 
 void

From c8bf57955da35884810a7520a811d45e069c9759 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 28 Apr 2024 22:05:53 +0300
Subject: [PATCH 016/305] mu4e-draft: better handle replies

(again) avoid mixing up message-reply-headers.
---
 mu4e/mu4e-draft.el | 21 +++++++++------------
 1 file changed, 9 insertions(+), 12 deletions(-)

diff --git a/mu4e/mu4e-draft.el b/mu4e/mu4e-draft.el
index 5e30710d8..90bf82158 100644
--- a/mu4e/mu4e-draft.el
+++ b/mu4e/mu4e-draft.el
@@ -470,13 +470,9 @@ appropriate flag at the message forwarded or replied-to."
 (defun mu4e--message-pop-to-buffer (name &optional _switch)
   "Mu4e override for `message-pop-to-buffer'.
 Creates a buffer NAME and returns it."
-  ;; note: we're in a _different_ buffer here, so we need to copy
-  ;; message-reply-header's buffer-local value.
-  (let ((reply-headers message-reply-headers))
-    (set-buffer (get-buffer-create name))
-    (setq-local message-reply-headers reply-headers)
-    (erase-buffer)
-    (setq mu4e--message-buf (current-buffer))))
+  (set-buffer (get-buffer-create name))
+  (erase-buffer)
+  (setq mu4e--message-buf (current-buffer)))
 
 (defun mu4e--message-is-yours-p ()
   "Mu4e's override for `message-is-yours-p'."
@@ -524,7 +520,6 @@ while in a buffer with the to-be-forwarded/replied-to message."
       (setq mu4e--message-buf nil)
       (apply func params))
     (mu4e--validate-hidden-buffer mu4e--message-buf)))
-
 ;;
 ;; make the draft buffer ready for use.
 ;;
@@ -679,7 +674,6 @@ window configuration."
 ;; creating drafts
 ;;
 
-
 (defun mu4e--draft (compose-type compose-func &optional parent)
   "Create a new message draft.
 
@@ -706,15 +700,15 @@ Returns the new buffer."
         (oldframe (selected-frame))
         (oldwinconf (current-window-configuration)))
     (with-temp-buffer
-      ;; provide a temp buffer so the compose-func can do its thing. withou
-      ;; interference.
+      ;; provide a temp buffer so the compose-func can do its thing
       (setq draft-buffer (mu4e--validate-hidden-buffer (funcall compose-func)))
       (with-current-buffer draft-buffer
         ;; we have our basic buffer; turn it into a full mu4e composition
         ;; buffer.
         (mu4e--prepare-draft-buffer compose-type parent)))
     ;; we're ready for composition; let's display it in the way user configured
-    ;; things: directly through display buffer (via pop-t or otherwise through mu4e-window.
+    ;; things: directly through display buffer (via pop-t or otherwise through
+    ;; mu4e-window.
     (if (eq mu4e-compose-switch 'display-buffer)
         (pop-to-buffer draft-buffer)
       (mu4e-display-buffer draft-buffer 'do-select))
@@ -733,6 +727,9 @@ but note the different order."
            (message-make-forward-subject-function
             (list #'message-forward-subject-fwd)))
        (insert (mu4e--decoded-message parent))
+       ;; let's make sure we don't use message-reply-headers from
+       ;; some unrelated message.
+       (setq message-reply-headers nil)
        (funcall compose-func)))
    parent))
 

From c56f8e2f064336c64d00fa03dbd1a2a81b774b70 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 30 Apr 2024 18:18:58 +0300
Subject: [PATCH 017/305] mu4e-draft: don't treat delete as a function

In mu4e-sent-messages-behavior.

Fixes #2701.
---
 mu4e/mu4e-draft.el | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/mu4e/mu4e-draft.el b/mu4e/mu4e-draft.el
index 90bf82158..4727b6f31 100644
--- a/mu4e/mu4e-draft.el
+++ b/mu4e/mu4e-draft.el
@@ -250,8 +250,11 @@ Returns the path for the sent message, either in the sent or
 trash folder, or nil if the message should be removed after
 sending."
   (let* ((behavior
-          (if (functionp mu4e-sent-messages-behavior)
-              (funcall mu4e-sent-messages-behavior) mu4e-sent-messages-behavior))
+          (if (and (functionp mu4e-sent-messages-behavior)
+                   ;; don't interpret 'delete as a function...
+                   (not (eq mu4e-sent-messages-behavior 'delete)))
+              (funcall mu4e-sent-messages-behavior)
+            mu4e-sent-messages-behavior))
          (sent-dir
           (pcase behavior
             ('delete nil)

From 32bb79b316b1e36e6dabbff569f3507f848ba2f9 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Mon, 29 Apr 2024 23:14:04 +0300
Subject: [PATCH 018/305] draft: explicitly remove drafts after sending

This seems necessary in some cases.
---
 lib/mu-server.cc    | 21 +++++++++++++++++----
 mu4e/mu4e-draft.el  | 10 ++++++----
 mu4e/mu4e-server.el |  8 +++++---
 3 files changed, 28 insertions(+), 11 deletions(-)

diff --git a/lib/mu-server.cc b/lib/mu-server.cc
index 87757e64c..62c9ca0c6 100644
--- a/lib/mu-server.cc
+++ b/lib/mu-server.cc
@@ -409,8 +409,11 @@ Server::Private::make_command_map()
 	    "remove",
 	    CommandInfo{
 		ArgMap{{":docid",
-			ArgInfo{Type::Number, true, "document-id for the message to remove"}}},
-		"remove a message from filesystem and database",
+			ArgInfo{Type::Number, false, "document-id for the message to remove"}},
+			{":path",
+			ArgInfo{Type::String, false, "document-id for the message to remove"}}
+		},
+		"remove a message from filesystem and database, using either :docid or :path",
 		[&](const auto& params) { remove_handler(params); }});
 
 	cmap.emplace(
@@ -989,8 +992,18 @@ Server::Private::quit_handler(const Command& cmd)
 void
 Server::Private::remove_handler(const Command& cmd)
 {
-	const auto docid{cmd.number_arg(":docid").value_or(0)};
-	const auto path{path_from_docid(store(), docid)};
+	auto docid_opt{cmd.number_arg(":docid")};
+	auto path_opt{cmd.string_arg(":path")};
+
+	if (!!docid_opt == !!path_opt)
+		throw Error(Error::Code::InvalidArgument,
+			    "must pass precisely one of :docid and :path");
+	std::string path;
+	Store::Id docid{};
+	if (docid = docid_opt.value_or(0); docid != 0)
+		path = path_from_docid(store(), docid);
+	else
+		path = path_opt.value();
 
 	if (::unlink(path.c_str()) != 0 && errno != ENOENT)
 		throw Error(Error::Code::File,
diff --git a/mu4e/mu4e-draft.el b/mu4e/mu4e-draft.el
index 4727b6f31..4568ffc7f 100644
--- a/mu4e/mu4e-draft.el
+++ b/mu4e/mu4e-draft.el
@@ -421,9 +421,8 @@ message buffer."
   "Handler called with DOCID and PATH for the just-sent message.
 For Forwarded ('Passed') and Replied messages, try to set the
 appropriate flag at the message forwarded or replied-to."
-  ;; XXX we don't need this function anymore here, but
-  ;; we have an external caller in mu4e-icalendar... we should
-  ;; update that.
+  ;; XXX we don't need this function anymore here, but we have an external
+  ;; caller in mu4e-icalendar... we should update that.
   (mu4e--set-parent-flags path)
   ;; if the draft file exists, remove it now.
   (when (file-exists-p path)
@@ -457,7 +456,10 @@ appropriate flag at the message forwarded or replied-to."
                 ;; we end up with a ((buried) buffer here, visiting the
                 ;; fcc-path; not quite sure why. But let's get rid of it (#2681)
                 (when-let ((buf (find-buffer-visiting fcc-path)))
-                  (kill-buffer buf))))
+                  (kill-buffer buf))
+                ;; remove draft
+                (when-let ((draft (buffer-file-name)))
+                  (mu4e--server-remove draft))))
             nil t))
 
 ;; overrides for message-* functions
diff --git a/mu4e/mu4e-server.el b/mu4e/mu4e-server.el
index 11a6c1777..a280f098e 100644
--- a/mu4e/mu4e-server.el
+++ b/mu4e/mu4e-server.el
@@ -684,11 +684,13 @@ QUERIES is a list of queries for the number of results with
 read/unread status are returned in the pong-response."
   (mu4e--server-call-mu `(queries :queries ,queries)))
 
-(defun mu4e--server-remove (docid)
-  "Remove message with DOCID.
+(defun mu4e--server-remove (docid-or-path)
+  "Remove message with either DOCID or PATH.
 The results are reported through either (:update ... )
 or (:error) sexps."
-  (mu4e--server-call-mu `(remove :docid ,docid)))
+  (if (stringp docid-or-path)
+      (mu4e--server-call-mu `(remove :path ,docid-or-path))
+      (mu4e--server-call-mu `(remove :docid ,docid-or-path))))
 
 (defun mu4e--server-view (docid-or-msgid &optional mark-as-read)
   "View a message referred to by DOCID-OR-MSGID.

From 5a4866403321a6a93e5e487ec4e0b9b5ee2abb36 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 30 Apr 2024 19:29:16 +0300
Subject: [PATCH 019/305] lib: centralize xapian include, enable move semantics

Only include xapian.h in one place, so we can have consistent options.
With that in place, we can enable C++ move semantics.

We don't do anything with that yet, but we check in the meson.build file
to see if we have the required xapian version.
---
 lib/message/mu-document.hh     |  1 -
 lib/message/mu-fields.hh       |  4 ++--
 lib/message/mu-message.hh      |  6 +++---
 lib/mu-config.hh               |  2 --
 lib/mu-query-match-deciders.hh |  4 ++--
 lib/mu-query-parser.hh         |  6 ++----
 lib/mu-query-results.hh        |  5 ++---
 lib/mu-query.cc                |  5 ++---
 lib/mu-store.hh                |  2 --
 lib/mu-xapian-db.hh            |  9 ++++++++-
 meson.build                    | 15 +++++++++------
 mu/mu-cmd-info.cc              |  1 -
 12 files changed, 30 insertions(+), 30 deletions(-)

diff --git a/lib/message/mu-document.hh b/lib/message/mu-document.hh
index ef0457725..5119044c7 100644
--- a/lib/message/mu-document.hh
+++ b/lib/message/mu-document.hh
@@ -19,7 +19,6 @@
 #ifndef MU_DOCUMENT_HH__
 #define MU_DOCUMENT_HH__
 
-#include <xapian.h>
 #include <utility>
 #include <string>
 #include <vector>
diff --git a/lib/message/mu-fields.hh b/lib/message/mu-fields.hh
index aa1ae0fb0..19a222b93 100644
--- a/lib/message/mu-fields.hh
+++ b/lib/message/mu-fields.hh
@@ -1,5 +1,5 @@
 /*
-** Copyright (C) 2022-2023 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2022-2024 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify it
 ** under the terms of the GNU General Public License as published by the
@@ -24,7 +24,7 @@
 #include <string_view>
 #include <algorithm>
 #include <array>
-#include <xapian.h>
+#include <mu-xapian-db.hh>
 #include <utils/mu-utils.hh>
 #include <utils/mu-option.hh>
 
diff --git a/lib/message/mu-message.hh b/lib/message/mu-message.hh
index 8fb9f4d25..0f029f404 100644
--- a/lib/message/mu-message.hh
+++ b/lib/message/mu-message.hh
@@ -1,5 +1,5 @@
 /*
-** Copyright (C) 2022-2023 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2022-2024 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify it
 ** under the terms of the GNU General Public License as published by the
@@ -25,6 +25,8 @@
 #include <vector>
 #include <iostream>
 
+#include "mu-xapian-db.hh"
+
 #include "mu-contact.hh"
 #include "mu-priority.hh"
 #include "mu-flags.hh"
@@ -33,8 +35,6 @@
 #include "mu-message-part.hh"
 #include "mu-message-file.hh"
 
-#include <xapian.h>
-
 #include "utils/mu-utils.hh"
 #include "utils/mu-option.hh"
 #include "utils/mu-result.hh"
diff --git a/lib/mu-config.hh b/lib/mu-config.hh
index afbfda859..17924c7de 100644
--- a/lib/mu-config.hh
+++ b/lib/mu-config.hh
@@ -29,8 +29,6 @@
 #include <variant>
 #include <unordered_map>
 
-#include <xapian.h>
-
 #include "mu-xapian-db.hh"
 
 #include <utils/mu-utils.hh>
diff --git a/lib/mu-query-match-deciders.hh b/lib/mu-query-match-deciders.hh
index 91488a5ef..bd1960596 100644
--- a/lib/mu-query-match-deciders.hh
+++ b/lib/mu-query-match-deciders.hh
@@ -1,5 +1,5 @@
 /*
-** Copyright (C) 2021 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2021-2024 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify it
 ** under the terms of the GNU General Public License as published by the
@@ -24,7 +24,7 @@
 #include <unordered_map>
 #include <memory>
 
-#include <xapian.h>
+#include "mu-xapian-db.hh"
 
 #include "mu-query-results.hh"
 
diff --git a/lib/mu-query-parser.hh b/lib/mu-query-parser.hh
index f78011bf3..72b23a7d0 100644
--- a/lib/mu-query-parser.hh
+++ b/lib/mu-query-parser.hh
@@ -1,5 +1,5 @@
 /*
-** Copyright (C) 2023 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2023-2024 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify it
 ** under the terms of the GNU General Public License as published by the
@@ -16,11 +16,9 @@
 ** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 **
 */
-#include <memory>
 #include <string>
-#include <array>
 
-#include <xapian.h>
+#include "mu-xapian-db.hh"
 
 #include "utils/mu-sexp.hh"
 #include "utils/mu-result.hh"
diff --git a/lib/mu-query-results.hh b/lib/mu-query-results.hh
index 479bd6c23..0123ab409 100644
--- a/lib/mu-query-results.hh
+++ b/lib/mu-query-results.hh
@@ -1,5 +1,5 @@
 /*
-** Copyright (C) 2022 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2022-2024 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify it
 ** under the terms of the GNU General Public License as published by the
@@ -33,12 +33,11 @@
 
 #include <unistd.h>
 #include <fcntl.h>
-#include <xapian.h>
 #include <glib.h>
 
+#include <mu-xapian-db.hh>
 #include <utils/mu-utils.hh>
 #include <utils/mu-option.hh>
-#include <mu-xapian-db.hh>
 
 #include <message/mu-message.hh>
 
diff --git a/lib/mu-query.cc b/lib/mu-query.cc
index 730a38c2c..5b76005b7 100644
--- a/lib/mu-query.cc
+++ b/lib/mu-query.cc
@@ -1,5 +1,5 @@
 /*
-** Copyright (C) 2008-2023 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2008-2024 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify
 ** it under the terms of the GNU General Public License as published by
@@ -26,13 +26,12 @@
 #include <cmath>
 
 #include <stdlib.h>
-#include <xapian.h>
 #include <glib/gstdio.h>
 
+#include "mu-xapian-db.hh"
 #include "mu-query-results.hh"
 #include "mu-query-match-deciders.hh"
 #include "mu-query-threads.hh"
-#include "mu-xapian-db.hh"
 
 #include "mu-query-parser.hh"
 
diff --git a/lib/mu-store.hh b/lib/mu-store.hh
index b6a092360..dd490451e 100644
--- a/lib/mu-store.hh
+++ b/lib/mu-store.hh
@@ -26,8 +26,6 @@
 #include <ctime>
 #include <memory>
 
-#include <xapian.h>
-
 #include "mu-contacts-cache.hh"
 #include "mu-xapian-db.hh"
 #include "mu-config.hh"
diff --git a/lib/mu-xapian-db.hh b/lib/mu-xapian-db.hh
index d4fca66df..f9753c60d 100644
--- a/lib/mu-xapian-db.hh
+++ b/lib/mu-xapian-db.hh
@@ -29,10 +29,17 @@
 
 #include <glib.h>
 
-#include <xapian.h>
 #include <utils/mu-result.hh>
 #include <utils/mu-utils.hh>
 
+/* starting with 1.4.6, Xapian supports C++ move semantics,
+ * but only with XAPIAN_MOVE_SEMANTICS defined
+ */
+#ifndef XAPIAN_MOVE_SEMANTICS
+#define XAPIAN_MOVE_SEMANTICS
+#endif /*XAPIAN_MOVE_SEMANTICS*/
+#include <xapian.h>
+
 namespace Mu {
 
 // LCOV_EXCL_START
diff --git a/meson.build b/meson.build
index 84ea0735a..5d91a8b65 100644
--- a/meson.build
+++ b/meson.build
@@ -191,13 +191,16 @@ gio_unix_dep   = dependency('gio-unix-2.0', version: '>= 2.60')
 gmime_dep      = dependency('gmime-3.0', version: '>= 3.2')
 thread_dep     = dependency('threads')
 
-# we need Xapian 1.4; if we have 1.4.23, we have some newer APIs.
-xapian_dep     = dependency('xapian-core', version:'>= 1.4.23', required:false)
-if xapian_dep.found()
+# we need Xapian 1.4
+xapian_dep = dependency('xapian-core', version:'>= 1.4', required:true)
+xapver = xapian_dep.version()
+if xapver.version_compare('>= 1.4.6')
+  message('xapian ' + xapver + ' supports c++ move-semantics')
+  config_h_data.set('HAVE_XAPIAN_MOVE_SEMANTICS', 1)
+endif
+if xapver.version_compare('>= 1.4.23')
+  message('xapian ' + xapver + ' supports ngrams')
   config_h_data.set('HAVE_XAPIAN_FLAG_NGRAMS', 1)
-else
-  xapian_dep = dependency('xapian-core', version:'>= 1.4')
-  message('Found xapian ' + xapian_dep.version())
 endif
 
 # optionally, use Compact Language Detector2 if we can find it.
diff --git a/mu/mu-cmd-info.cc b/mu/mu-cmd-info.cc
index fcc967067..2e155fc70 100644
--- a/mu/mu-cmd-info.cc
+++ b/mu/mu-cmd-info.cc
@@ -21,7 +21,6 @@
 
 #include "mu-cmd.hh"
 #include <message/mu-message.hh>
-#include <xapian.h>
 #include "utils/mu-utils.hh"
 
 #include <glib.h>

From e2bf38298d68dfb3975ffd64a5256e886dff9f52 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Wed, 1 May 2024 18:22:53 +0300
Subject: [PATCH 020/305] mu4e-draft: mark m-c-(type|parent-message) as
 permanent-local

The variables mu4e-compose-parent-message & mu4e-compose-type are
buffer-local as well as permanent-local. That way, they'll survive the
mode change to mu4e-compose-mode and we can use them in the
corresponding mode-hook.
---
 mu4e/mu4e-draft.el | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/mu4e/mu4e-draft.el b/mu4e/mu4e-draft.el
index 4568ffc7f..3b94cdd3a 100644
--- a/mu4e/mu4e-draft.el
+++ b/mu4e/mu4e-draft.el
@@ -197,14 +197,19 @@ Display is influenced by `mu4e-compose-switch'."
   "The User-Agent string for mu4e, or nil.")
 
 ;;; Runtime variables; useful for user-hooks etc.
+;; mu4e-compose-parent-message & mu4e-compose-type are buffer-local and
+;; permanent-local so they'll survive the mode change to mu4e-compose-mode and
+;; we can use them in the corresponding mode-hook.
 (defvar-local mu4e-compose-parent-message nil
   "The parent message plist.
 This is the message being replied to, forwarded or edited; used
 in `mu4e-compose-pre-hook'. For new (non-reply, forward etc.)
 messages, it is nil.")
+(put 'mu4e-compose-parent-message 'permanent-local t)
 
 (defvar-local mu4e-compose-type nil
   "The compose-type for the current message.")
+(put 'mu4e-compose-type 'permanent-local t)
 
 ;;; Filenames
 (defun mu4e--draft-basename()
@@ -569,7 +574,7 @@ COMPOSE-TYPE and PARENT are as in `mu4e--draft'."
   ;; remember some variables, e.g for user hooks. These are permanent-local
   ;; hence survive the mode-switch below (we do this so these useful vars are
   ;; available in mode-hooks.
-  (setq
+  (setq-local
    mu4e-compose-parent-message parent
    mu4e-compose-type compose-type)
 

From 808d725254082c3dc28d713896880bf32d676d8b Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Wed, 1 May 2024 18:37:48 +0300
Subject: [PATCH 021/305] mu4e-compose: use raw message to feed message-forward

Seemingly, message-forwarded needs the raw message, not the decode one
for proper forwarding when the parent message is encoded in some way.

Add a little hack / workaround for that.

See #2662.
---
 mu4e/mu4e-compose.el | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/mu4e/mu4e-compose.el b/mu4e/mu4e-compose.el
index 142b74e5e..5b5f9fdac 100644
--- a/mu4e/mu4e-compose.el
+++ b/mu4e/mu4e-compose.el
@@ -427,8 +427,13 @@ variables ‘message-forward-as-mime’ and
                                (message-field-value "Message-Id" t)
                                (message-field-value "References")
                                0 0 ""))
-         (with-current-buffer (mu4e--message-call #'message-forward)
-           (current-buffer))))))
+       ;; a bit of a hack; mu4e--draft-with-parent will insert the decoded
+       ;; version of the message, but that's not good enough for
+       ;; message-forward, which needs the raw message instead; see #2662.
+       (erase-buffer)
+       (insert-file-contents-literally (mu4e-message-readable-path parent))
+       (with-current-buffer (mu4e--message-call #'message-forward)
+         (current-buffer))))))
 
 ;;;###autoload
 (defun mu4e-compose-edit()

From c5a0dda9eac505cf7ce1f52cfe8d11616cd334b9 Mon Sep 17 00:00:00 2001
From: Dima Kogan <dima@secretsauce.net>
Date: Wed, 1 May 2024 09:50:33 -0700
Subject: [PATCH 022/305] mu4e-compose-reply with a prefix argument replies to
 ALL

---
 mu4e/mu4e-compose.el | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mu4e/mu4e-compose.el b/mu4e/mu4e-compose.el
index 142b74e5e..bf2dfdaf7 100644
--- a/mu4e/mu4e-compose.el
+++ b/mu4e/mu4e-compose.el
@@ -382,7 +382,7 @@ non-nil, make it a \"wide\" reply (a.k.a. \"reply-to-all\")."
 (defun mu4e-compose-reply (&optional wide)
   "Reply to the message at point. If WIDE is
 non-nil, make it a \"wide\" reply (a.k.a. \"reply-to-all\")."
-  (interactive)
+  (interactive "P")
   (mu4e-compose-reply-to nil wide))
 
 ;;;###autoload

From 5a1ca77b478ac208f15b6656f23f294f42311138 Mon Sep 17 00:00:00 2001
From: Jeremy Sowden <jeremy@azazel.net>
Date: Wed, 1 May 2024 20:36:28 +0100
Subject: [PATCH 023/305] scanner: don't skip directory entries with type
 `DT_UNKNOWN`

According to the readdir(2) man-page, not all file-systems support returning the
entry's file-type in `d_type`.  For example, the reprotest reproducibility tool,
uses the disorderfs FUSE file-system to shuffle the order in which directory
entries are returned, and this does not set `d_type`.  Therefore, in addition to
entries with type `DT_DIR` and `DT_LNK`, also process entries with type
`DT_UNKNOWN`.

Signed-off-by: Jeremy Sowden <azazel@debian.org>
---
 lib/mu-scanner.cc | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/lib/mu-scanner.cc b/lib/mu-scanner.cc
index ddda1598c..bbc8d7e6d 100644
--- a/lib/mu-scanner.cc
+++ b/lib/mu-scanner.cc
@@ -215,9 +215,13 @@ Scanner::Private::process_dir(const std::string& path, bool is_maildir)
 	while (running_) {
 		errno = 0;
 		if (const auto& dentry{::readdir(dir)}; dentry) {
-#if HAVE_DIRENT_D_TYPE /* opttimization: filter out non-dirs early */
+#if HAVE_DIRENT_D_TYPE /* optimization: filter out non-dirs early.  NB not all file-systems support
+			* returning the file-type in `d_type`, so don't skip `DT_UNKNOWN`.
+			*/
 			if (maildirs_only_mode() &&
-			    dentry->d_type != DT_DIR && dentry->d_type != DT_LNK)
+			    dentry->d_type != DT_DIR &&
+			    dentry->d_type != DT_LNK &&
+			    dentry->d_type != DT_UNKNOWN)
 				continue;
 #endif /*HAVE_DIRENT_D_TYPE*/
 			dir_entries.emplace_back(dentry);

From a2273b69e7365b755bcad5c2f005c3ff62b05bd7 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Thu, 2 May 2024 19:13:35 +0300
Subject: [PATCH 024/305] improve documentation

---
 NEWS.org             | 11 ++++++++---
 mu4e/mu4e-compose.el |  4 ++--
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/NEWS.org b/NEWS.org
index 10695feff..442eb4e33 100644
--- a/NEWS.org
+++ b/NEWS.org
@@ -13,7 +13,8 @@
   - Better and faster indexing of HTML messages
   - Experimental search by (human) language wit CLD2
 
-  For details & more, see below.
+  For details & more, see below. Note a few minor new features were added
+  _after_ the initial 1.12.0.
 
 *** mu
 
@@ -51,8 +52,8 @@
       messages; you can then search by their ISO-639-1 code, e.g.:
        ~$ mu find lang:en~
 
-      the matching is not perfect, and seems to favor non-english if there's a
-      mostly english message with some other language mixed in.
+      the matching is not perfect, and seems to favor non-English if there's a
+      mostly English message with some other language mixed in.
 
       this does require re-indexing the database.
 
@@ -121,6 +122,10 @@
       change when creating the message (=mu4e= asks you by default, see
       ~mu4e-compose-context-policy~).
 
+    - there's a new hook ~mu4e-compose-post-hook~ which fires when message
+      composition is complete - either a message has been sent, it is postponed,
+      canceled etc. (1.12.5).
+
     - iCalendar support is a work-in-progress with the new editor. One change is
       that support is now _automatically_ available.
 
diff --git a/mu4e/mu4e-compose.el b/mu4e/mu4e-compose.el
index c61f2024f..6135ef5c2 100644
--- a/mu4e/mu4e-compose.el
+++ b/mu4e/mu4e-compose.el
@@ -80,8 +80,8 @@ the place to do that."
    #'mu4e-compose-post-restore-window-configuration)
   "Hook run *after* message composition is over.
 
-This is hook is run when   composition buffer,
-either by sending, postponing, exiting or killing it.
+This is hook is run when closing the composition buffer, either
+by sending, postponing, exiting or killing it.
 
 This multiplexes the `message-mode' hooks `message-send-actions',
 `message-postpone-actions', `message-exit-actions' and

From b36e492d29eed332d074a221317849b5e78abbd7 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Fri, 3 May 2024 18:42:57 +0300
Subject: [PATCH 025/305] build: bump version to 1.12.5

New version 1.12.5

- Rework message composition; split off parts into mu4e-draft.el
  This tries harder to maintain the current buffer as expected
- This fixes e.g. emacs-report-bug handling
- New hook mu4e-compose-post-hook for tweaking what mu4e does when
  we're done with a message (after sending, cancelling, ...).
  By default, it tries to close the frame if needed, and restore
  the window configuration. See its docstring.
- Better handle forwarding of encoded messages
- Don't remove non-mu4e completion in composer
- Integrate iCalendar support with message-composition
- Handle mu4e-sent-messages-behavior correctly when it's a function
- Better support NetBSD
- Support some file systems that don't put the file type in d_type
- Improve documenation
---
 meson.build | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/meson.build b/meson.build
index 5d91a8b65..718d68fce 100644
--- a/meson.build
+++ b/meson.build
@@ -17,7 +17,7 @@
 ################################################################################
 # project setup
 project('mu', ['c', 'cpp'],
-        version: '1.12.4',
+        version: '1.12.5',
         meson_version: '>= 0.56.0',
         license: 'GPL-3.0-or-later',
         default_options : [

From 23941735df4d535e88a9a1d22bdf6c0c1fdf9cca Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 7 May 2024 19:26:10 +0300
Subject: [PATCH 026/305] logging: rework a bit, maybe support syslog

Seems journal logging fails on NetBSD (no surprise), but has some
unwanted/not-fully-understood side-effects.

In any case, outside Linux there's no use in even trying to use
journald; so we don't do that anymore.

Add conditional support for syslog (requires glib 2.80).
---
 lib/utils/mu-logger.cc      | 39 +++++++++++++++++++++++++++----------
 lib/utils/tests/meson.build |  2 +-
 meson.build                 | 19 +++++++++++++++++-
 3 files changed, 48 insertions(+), 12 deletions(-)

diff --git a/lib/utils/mu-logger.cc b/lib/utils/mu-logger.cc
index c9f516d14..c9a0d74d4 100644
--- a/lib/utils/mu-logger.cc
+++ b/lib/utils/mu-logger.cc
@@ -1,5 +1,5 @@
 /*
-** Copyright (C) 2020-2022 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2020-2024 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify it
 ** under the terms of the GNU General Public License as published by the
@@ -17,6 +17,9 @@
 **
 */
 
+#include "config.h"
+#include "mu-logger.hh"
+
 #define G_LOG_USE_STRUCTURED
 #include <glib.h>
 #include <glib/gstdio.h>
@@ -31,8 +34,6 @@
 #include <thread>
 #include <mutex>
 
-#include "mu-logger.hh"
-
 using namespace Mu;
 
 static bool			MuLogInitialized = false;
@@ -118,10 +119,29 @@ log_stdouterr(GLogLevelFlags level, const GLogField* fields, gsize n_fields, gpo
 	return g_log_writer_standard_streams(level, fields, n_fields, user_data);
 }
 
+
+
+// log to some logging system; the one that is available & works of journal,
+// syslog, file.
 static GLogWriterOutput
-log_journal(GLogLevelFlags level, const GLogField* fields, gsize n_fields, gpointer user_data)
+log_system(GLogLevelFlags level, const GLogField* fields, gsize n_fields, gpointer user_data)
 {
-	return g_log_writer_journald(level, fields, n_fields, user_data);
+	GLogWriterOutput res = G_LOG_WRITER_UNHANDLED;
+
+#ifdef MAYBE_USE_JOURNAL
+	res = g_log_writer_journald(level, fields, n_fields, user_data);
+	if (res == G_LOG_WRITER_HANDLED)
+		return res;
+#endif /*MAYBE_USE_JOURNAL*/
+
+#ifdef MAYBE_USE_SYSLOG
+	/* since glib 2.80 */
+	res = g_log_writer_syslog(level, fields, n_fields, user_data);
+	if (res == G_LOG_WRITER_HANDLED)
+		return res;
+#endif /*MAYBE_USE_SYSLOG*/
+
+	return res = log_file(level, fields, n_fields, user_data);
 }
 
 
@@ -156,11 +176,10 @@ Mu::Logger::Logger(const std::string& path, Mu::Logger::Options opts)
 		    }
 
 		    // log to the journal, or, if not available to a file.
-		    if (any_of(MuLogOptions & Options::File) ||
-			log_journal(level, fields, n_fields, user_data) != G_LOG_WRITER_HANDLED)
-			    return log_file(level, fields, n_fields, user_data);
-		    else
-			    return G_LOG_WRITER_HANDLED;
+		    if (any_of(MuLogOptions & Options::File))
+			return log_file(level, fields, n_fields, user_data);
+
+		    return log_system(level, fields, n_fields, user_data);
 	    },
 	    NULL,
 	    NULL);
diff --git a/lib/utils/tests/meson.build b/lib/utils/tests/meson.build
index 9c2883bb9..6fa3d1706 100644
--- a/lib/utils/tests/meson.build
+++ b/lib/utils/tests/meson.build
@@ -50,7 +50,7 @@ test('test-logger',
      executable('test-logger', '../mu-logger.cc',
                 install: false,
                 cpp_args: ['-DBUILD_TESTS'],
-                dependencies: [glib_dep, lib_mu_utils_dep, thread_dep ]))
+                dependencies: [glib_dep, lib_mu_utils_dep,config_h_dep,thread_dep ]))
 
 test('test-option',
      executable('test-option', '../mu-option.cc',
diff --git a/meson.build b/meson.build
index 718d68fce..265c4a8d1 100644
--- a/meson.build
+++ b/meson.build
@@ -203,6 +203,23 @@ if xapver.version_compare('>= 1.4.23')
   config_h_data.set('HAVE_XAPIAN_FLAG_NGRAMS', 1)
 endif
 
+host_system = host_machine.system()
+#
+# soft dependencies
+#
+
+
+# logging
+
+# if we're on a linux machine, perhaps there's systemd/journald.
+# otherwise, we don't bother.
+if host_machine.system() == 'linux'
+  config_h_data.set('MAYBE_USE_JOURNAL', 1)
+endif
+if cc.has_function('g_log_writer_syslog',dependencies: glib_dep)
+  config_h_data.set('MAYBE_USE_SYSLOG', 1)
+endif
+
 # optionally, use Compact Language Detector2 if we can find it.
 cld2_dep = meson.get_compiler('cpp').find_library('cld2', required: get_option('cld2'))
 if not get_option('cld2').disabled() and cld2_dep.found()
@@ -211,7 +228,7 @@ else
   message('CLD2 not found or disabled; no support for language detection')
 endif
 
-# soft dependencies
+# guile
 guile_dep = dependency('guile-3.0', required: get_option('guile'))
 # allow for a custom guile-extension-dir
 if guile_dep.found()

From c3283dc5ae6ca372d599709bd51fab4dc8e17119 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 7 May 2024 23:53:43 +0300
Subject: [PATCH 027/305] IDEAS.org: update

---
 IDEAS.org | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/IDEAS.org b/IDEAS.org
index e3e954e7f..0502c8515 100644
--- a/IDEAS.org
+++ b/IDEAS.org
@@ -5,9 +5,6 @@ Ideas for future enhancements. We collect those here so they don't clutter up
 the Github issue list, i.e. without any clear plan for adding in the near
 future.
 
-- Ability to _mute_ message threads. This is useful but also requires quite bit of extra infra; we could add some blacklist for "muted" messages, perhaps on the 'mu server' side, but then we'd need some way to manage that (ie., unmute).
-  https://github.com/djcb/mu/issues/636
-
 - Support automatic handling for List-Unsubscribe headers
   https://github.com/djcb/mu/issues/2623 This seems useful, but probably
   requires a lot of testing to get right.
@@ -41,6 +38,8 @@ future.
   in a set of messages. That'll require some advanced scripting, maybe using
   Guile.
   https://github.com/djcb/mu/issues/301
+  https://github.com/djcb/mu/issues/2704
+
 
 * Done
 

From ceed832cb9ce75ae3ffab2563036b3aa745c577c Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Wed, 8 May 2024 00:06:28 +0300
Subject: [PATCH 028/305] mu-query: minor cleanups

---
 lib/mu-query.cc | 16 ++--------------
 lib/mu-query.hh | 10 ++--------
 2 files changed, 4 insertions(+), 22 deletions(-)

diff --git a/lib/mu-query.cc b/lib/mu-query.cc
index 5b76005b7..bb4ec54ac 100644
--- a/lib/mu-query.cc
+++ b/lib/mu-query.cc
@@ -18,27 +18,15 @@
 */
 #include <mu-query.hh>
 
-#include <stdexcept>
-#include <string>
-#include <cctype>
-#include <cstring>
-#include <sstream>
-#include <cmath>
-
-#include <stdlib.h>
-#include <glib/gstdio.h>
-
 #include "mu-xapian-db.hh"
-#include "mu-query-results.hh"
 #include "mu-query-match-deciders.hh"
 #include "mu-query-threads.hh"
-
 #include "mu-query-parser.hh"
 
 using namespace Mu;
 
 struct Query::Private {
-	Private(const Store& store) :
+	explicit Private(const Store& store) :
 		store_{store},
 		parser_flags_{any_of(store_.message_options() & Message::Options::SupportNgrams) ?
 		ParserFlags::SupportNgrams : ParserFlags::None} {}
@@ -125,7 +113,7 @@ Query::Private::make_related_enquire(const StringSet& thread_ids,
 }
 
 struct ThreadKeyMaker : public Xapian::KeyMaker {
-	ThreadKeyMaker(const QueryMatches& matches) : match_info_(matches) {}
+	explicit ThreadKeyMaker(const QueryMatches& matches) : match_info_(matches) {}
 	std::string operator()(const Xapian::Document& doc) const override {
 		const auto it{match_info_.find(doc.get_docid())};
 		return (it == match_info_.end()) ? "" : it->second.thread_path;
diff --git a/lib/mu-query.hh b/lib/mu-query.hh
index 7ca1275e8..fb3628bc6 100644
--- a/lib/mu-query.hh
+++ b/lib/mu-query.hh
@@ -1,5 +1,5 @@
 /*
-** Copyright (C) 2008-2023 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2008-2024 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify
 ** it under the terms of the GNU General Public License as published by
@@ -20,9 +20,9 @@
 #ifndef __MU_QUERY_HH__
 #define __MU_QUERY_HH__
 
+#include <string>
 #include <memory>
 
-#include <glib.h>
 #include <mu-store.hh>
 #include <mu-query-results.hh>
 #include <utils/mu-utils.hh>
@@ -86,12 +86,6 @@ private:
 	 */
 	~Query();
 
-	/**
-	 * Move CTOR
-	 *
-	 * @param other
-	 */
-
 	struct Private;
 	std::unique_ptr<Private> priv_;
 };

From aeb6d441727f0cad3d9b08c15fc3cc41c155dd18 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Wed, 8 May 2024 19:11:40 +0300
Subject: [PATCH 029/305] mu-store/indexer: consume messages from workers

Add store::consume_message, which is like add message but std::move from
the caller such that the messages longer has copies (with
Xapian::Document) on the caller side; this is to avoid threading issues.
---
 lib/mu-indexer.cc |  8 +++-----
 lib/mu-store.cc   |  2 +-
 lib/mu-store.hh   | 18 ++++++++++++++++--
 3 files changed, 20 insertions(+), 8 deletions(-)

diff --git a/lib/mu-indexer.cc b/lib/mu-indexer.cc
index e7649337c..72756d1b9 100644
--- a/lib/mu-indexer.cc
+++ b/lib/mu-indexer.cc
@@ -241,19 +241,17 @@ Indexer::Private::add_message(const std::string& path)
 	 * The reason for having the lock is some helgrind warnings;
 	 * but it believed those are _false alarms_
 	 * https://gitlab.gnome.org/GNOME/glib/-/issues/2662
-	 *
-	 * For now, set the lock as we were seeing some db corruption.
 	 */
-	std::unique_lock lock{w_lock_};
+	//std::unique_lock lock{w_lock_};
 	auto msg{Message::make_from_path(path, store_.message_options())};
 	if (!msg) {
 		mu_warning("failed to create message from {}: {}", path, msg.error().what());
 		return false;
 	}
 	// if the store was empty, we know that the message is completely new
-	// and can use the fast path (Xapians 'add_document' rather tahn
+	// and can use the fast path (Xapians 'add_document' rather than
 	// 'replace_document)
-	auto res = store_.add_message(msg.value(), was_empty_);
+	auto res = store_.consume_message(std::move(msg.value()), was_empty_);
 	if (!res) {
 		mu_warning("failed to add message @ {}: {}", path, res.error().what());
 		return false;
diff --git a/lib/mu-store.cc b/lib/mu-store.cc
index eb08eac01..dd9f11460 100644
--- a/lib/mu-store.cc
+++ b/lib/mu-store.cc
@@ -1,5 +1,5 @@
 /*
-** Copyright (C) 2021-2023 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2021-2024 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify it
 ** under the terms of the GNU General Public License as published by the
diff --git a/lib/mu-store.hh b/lib/mu-store.hh
index dd490451e..07d8a03c1 100644
--- a/lib/mu-store.hh
+++ b/lib/mu-store.hh
@@ -204,8 +204,22 @@ public:
 	 *
 	 * @return the doc id of the added message or an error.
 	 */
-	Result<Id> add_message(Message& msg, bool is_new = false);
-	Result<Id> add_message(const std::string& path, bool is_new = false);
+	Result<Id> add_message(Message &msg, bool is_new = false);
+	Result<Id> add_message(const std::string &path, bool is_new = false);
+
+	/**
+	 * Like add_message(), however, this consumes the message and disposes
+	 * of it when the function ends. This can be useful when injecting
+	 * messages from a worker thread, to ensure no Xapian::Documents
+	 * live in different threads.
+	 *
+	 * @param msg a message
+	 * @param is_new whether this is a completely new message
+	 */
+	Result<Id> consume_message(Message&& msg, bool is_new = false) {
+		Message consumed{std::move(msg)};
+		return add_message(consumed, is_new);
+	}
 
 	/**
 	 * Remove a message from the store. It will _not_ remove the message

From a6208efd50786923aa2b0590b1749b3513b8c703 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 11 May 2024 08:01:31 +0300
Subject: [PATCH 030/305] mu4e: add mu4e-save-message

Convenience function for saving the message-at-point.
---
 mu4e/mu4e-message.el | 37 +++++++++++++++++++++++++++++++++----
 1 file changed, 33 insertions(+), 4 deletions(-)

diff --git a/mu4e/mu4e-message.el b/mu4e/mu4e-message.el
index 95f8aff53..fd6295c07 100644
--- a/mu4e/mu4e-message.el
+++ b/mu4e/mu4e-message.el
@@ -1,6 +1,6 @@
 ;;; mu4e-message.el --- Working with mu4e-message plists -*- lexical-binding: t -*-
 
-;; Copyright (C) 2012-2022 Dirk-Jan C. Binnema
+;; Copyright (C) 2012-2024 Dirk-Jan C. Binnema
 
 ;; Author: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ;; Maintainer: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
@@ -29,14 +29,14 @@
 (require 'mu4e-vars)
 (require 'mu4e-contacts)
 (require 'mu4e-window)
+(require 'mu4e-helpers)
 (require 'flow-fill)
 (require 'shr)
 (require 'pp)
 
-(declare-function mu4e-error "mu4e-helpers")
-(declare-function mu4e-warn  "mu4e-helpers")
+
+(declare-function mu4e-determine-attachment-dir  "mu4e-helpers")
 (declare-function mu4e-personal-address-p "mu4e-contacts")
-(declare-function mu4e-make-temp-file  "mu4e-helpers")
 
 ;;; Message fields
 
@@ -207,6 +207,34 @@ If MSG is nil, use `mu4e-message-at-point'."
     (kill-new path)
     (mu4e-message "Saved '%s' to kill-ring" path)))
 
+(defun mu4e-save-message (&optional auto-path auto-overwrite)
+  "Save a copy of the message-at-point.
+
+If AUTO-PATH is non-nil, save to the attachment directory for
+message/rfc822 files as per `mu4e-determine-attachment-dir'.
+Otherwise, ask user.
+
+If AUTO-OVERWRITE is non-nil, automatically overwrite if a file
+with the same name already exist in the target directory.
+Otherwise, ask for user confirmation.
+
+Returns the full path."
+  (interactive "P")
+  (let* ((srcpath (mu4e-message-readable-path))
+         (srcname (file-name-nondirectory srcpath))
+         (destdir (file-name-as-directory
+                   (mu4e-determine-attachment-dir
+                    srcpath "message/rfc822")))
+         (destpath (mu4e-join-paths destdir srcname))
+         (destpath
+          (if auto-path destpath
+              (read-file-name "Save message as: "
+                              destdir nil nil srcname))))
+    (when destpath
+      (copy-file srcpath destpath (if auto-overwrite t 0))
+      (mu4e-message "Saved %s" destpath)
+      destpath)))
+
 (defun mu4e-sexp-at-point ()
   "Show or hide the s-expression for the message-at-point, if any."
   (interactive)
@@ -242,6 +270,7 @@ plist."
   (with-temp-buffer
     (insert (mu4e--decoded-message msg 'headers-only))
     (message-field-value hdr first)))
+
 ;;;
 (provide 'mu4e-message)
 ;;; mu4e-message.el ends here

From b105fad181e75a6d5cb279b30a74c891c9ac1fd4 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 11 May 2024 08:13:26 +0300
Subject: [PATCH 031/305] NEWS.org: update

---
 NEWS.org | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/NEWS.org b/NEWS.org
index 442eb4e33..a782e64cc 100644
--- a/NEWS.org
+++ b/NEWS.org
@@ -13,7 +13,7 @@
   - Better and faster indexing of HTML messages
   - Experimental search by (human) language wit CLD2
 
-  For details & more, see below. Note a few minor new features were added
+  For details & more, see below. Note that a few minor new features were added
   _after_ the initial 1.12.0.
 
 *** mu
@@ -116,11 +116,8 @@
     - ~mu4e-compose-in-new-frame~ has been generalized (in a backward-compatible
       way) to ~mu4e-compose-switch~, which lets you decide whether a message
       should be composed in the current window (default), a new window or a new
-      frame.
-
-    - ~mu4e-compose-context-switch~ is gone; it was a little too fragile. Best
-      change when creating the message (=mu4e= asks you by default, see
-      ~mu4e-compose-context-policy~).
+      frame or fine-tune it completely through the ~display-buffer-alist~
+      mechanism.
 
     - there's a new hook ~mu4e-compose-post-hook~ which fires when message
       composition is complete - either a message has been sent, it is postponed,

From 66001c9148c95b343f1a228c8d1c54556230e7fd Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Wed, 15 May 2024 02:55:14 +0300
Subject: [PATCH 032/305] mu4e-headers: remove duplicate require

---
 mu4e/mu4e-headers.el | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/mu4e/mu4e-headers.el b/mu4e/mu4e-headers.el
index 11d1dea88..dd69cb90f 100644
--- a/mu4e/mu4e-headers.el
+++ b/mu4e/mu4e-headers.el
@@ -1,6 +1,6 @@
 ;;; mu4e-headers.el --- Message headers -*- lexical-binding: t; coding:utf-8 -*-
 
-;; Copyright (C) 2011-2023 Dirk-Jan C. Binnema
+;; Copyright (C) 2011-2024 Dirk-Jan C. Binnema
 
 ;; Author: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ;; Maintainer: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
@@ -35,8 +35,6 @@
 (require 'mule-util) ;; seems _some_ people need this for
                      ;; truncate-string-ellipsis
 
-(require 'mu4e-update)
-
     ;; utility functions
 (require 'mu4e-server)
 (require 'mu4e-vars)

From 142d91f21829a422befa1a9cda5ab0f3033bc587 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Fri, 17 May 2024 18:45:15 +0300
Subject: [PATCH 033/305] mu4e: some flycheck fixes

---
 mu4e/mu4e-compose.el  |  7 ++++---
 mu4e/mu4e-contacts.el | 14 +++++++-------
 mu4e/mu4e-draft.el    |  7 ++++---
 3 files changed, 15 insertions(+), 13 deletions(-)

diff --git a/mu4e/mu4e-compose.el b/mu4e/mu4e-compose.el
index 6135ef5c2..f2b6f890e 100644
--- a/mu4e/mu4e-compose.el
+++ b/mu4e/mu4e-compose.el
@@ -380,15 +380,16 @@ non-nil, make it a \"wide\" reply (a.k.a. \"reply-to-all\")."
 
 ;;;###autoload
 (defun mu4e-compose-reply (&optional wide)
-  "Reply to the message at point. If WIDE is
-non-nil, make it a \"wide\" reply (a.k.a. \"reply-to-all\")."
+  "Reply to the message at point.
+If WIDE is non-nil, make it a \"wide\" reply (a.k.a.
+\"reply-to-all\")."
   (interactive "P")
   (mu4e-compose-reply-to nil wide))
 
 ;;;###autoload
 (defun mu4e-compose-wide-reply ()
   "Wide reply to the message at point.
-(a.k.a. \"reply-to-all\")."
+I.e., \"reply-to-all\"."
   (interactive)
   (mu4e-compose-reply-to nil t))1
 
diff --git a/mu4e/mu4e-contacts.el b/mu4e/mu4e-contacts.el
index ab6079cf2..025cac44a 100644
--- a/mu4e/mu4e-contacts.el
+++ b/mu4e/mu4e-contacts.el
@@ -1,6 +1,6 @@
 ;;; mu4e-contacts.el --- Dealing with contacts -*- lexical-binding: t -*-
 
-;; Copyright (C) 2022-2023 Dirk-Jan C. Binnema
+;; Copyright (C) 2022-2024 Dirk-Jan C. Binnema
 
 ;; Author: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ;; Maintainer: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
@@ -69,7 +69,7 @@ Lowering this variable reduces start-up time and memory usage."
   :group 'mu4e-compose)
 
 ;; names and mail-addresses can be mapped onto their canonical
-;; counterpart.  use the customizeable function
+;; counterpart.  Use the customizable function
 ;; mu4e-canonical-contact-function to do that.  below the identity
 ;; function for mapping a contact onto the canonical one.
 (defun mu4e-contact-identity (contact)
@@ -84,9 +84,9 @@ their canonical counterpart; useful as an example."
   (lambda(addr)
     (cond
      ((string-match-p "reply" addr)
-      ;; no-reply adresses are not useful of course, but neither are are
-      ;; reply-xxxx addresses since they're autogenerated only useful for direct
-      ;; replies.
+      ;; no-reply addresses are not useful of course, but neither are are
+      ;; reply-xxxx addresses since they're auto-generated only useful for
+      ;; direct replies.
       nil)
      (t addr)))
   "Function for processing contact information for use in auto-completion.
@@ -157,7 +157,7 @@ That is, does it match either `mu4e-personal-address-p' or
 `message-alternative-emails'.
 
 Note that this expanded definition of user-addresses is only used
-in emacs, not in `mu' (e.g. when indexing).
+in Emacs, not in `mu' (e.g., when indexing).
 
 Also see `mu4e-personal-or-alternative-address-or-empty-p'."
   (let ((alts message-alternative-emails))
@@ -175,7 +175,7 @@ return t for _empty_ ADDR. This can be useful for use with
 `message-dont-reply-to-names' since it can receive empty strings;
 those can be filtered-out by returning t here.
 
-See #2680 for further details. "
+See #2680 for further details."
   (or (and addr (string= addr ""))
       (mu4e-personal-or-alternative-address-p addr)))
 
diff --git a/mu4e/mu4e-draft.el b/mu4e/mu4e-draft.el
index 3b94cdd3a..64b2f1a61 100644
--- a/mu4e/mu4e-draft.el
+++ b/mu4e/mu4e-draft.el
@@ -612,13 +612,13 @@ COMPOSE-TYPE and PARENT are as in `mu4e--draft'."
   (undo-boundary))
 
 ;;
-;; mu4e-compose-pos-hook helpers
+;; mu4e-compose-post-hook helpers
 
 (defvar mu4e--before-draft-window-config nil
   "The window configuration just before creating the draft.")
 
 (defun mu4e-compose-post-restore-window-configuration()
-  "Function that perhaps restores the window configuration.
+  "Function that might restore the window configuration.
 I.e. the configuration just before the draft buffer appeared.
 This is for use in `mu4e-compose-post-hook'.
 See `set-window-configuration' for further details."
@@ -632,7 +632,7 @@ See `set-window-configuration' for further details."
 Used internally for mu4e-compose-post-kill-frame.")
 
 (defun mu4e-compose-post-kill-frame ()
-  "Function that perhaps kills the composition frame.
+  "Function that might kill the composition frame.
 This is for use in `mu4e-compose-post-hook'."
   (let ((msgframe (selected-frame)))
     ;;(message "kill frame? %s %s" mu4e--draft-activation-frame msgframe)
@@ -744,3 +744,4 @@ but note the different order."
    parent))
 
 (provide 'mu4e-draft)
+;;; mu4e-draft.el ends here

From 3ff2f9f1ac87369f7f10ffbf769ea3404bae0dec Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Fri, 17 May 2024 20:02:39 +0300
Subject: [PATCH 034/305] mu4e-draft: invoke mu4e-compose-pre-hook

We should invoke it, as documented.
---
 mu4e/mu4e-draft.el | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/mu4e/mu4e-draft.el b/mu4e/mu4e-draft.el
index 64b2f1a61..1a5e015ef 100644
--- a/mu4e/mu4e-draft.el
+++ b/mu4e/mu4e-draft.el
@@ -553,7 +553,8 @@ This is mu4e's version of `message-hidden-headers'.")
   "Get ready for message composition.
 PARENT is the parent message, if any."
   (unless (mu4e-running-p) (mu4e 'background)) ;; start if needed
-  (mu4e--context-autoswitch parent mu4e-compose-context-policy))
+  (mu4e--context-autoswitch parent mu4e-compose-context-policy)
+  (run-hooks 'mu4e-compose-pre-hook))
 
 (defun mu4e--prepare-draft-headers (compose-type)
   "Add extra headers for message based on COMPOSE-TYPE."

From a9495f7be55621cfbc9b646564717cead77055a3 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 18 May 2024 00:14:22 +0300
Subject: [PATCH 035/305] mu4e-draft: use message-alternative-emails for
 replies

Set message-alternative-emails to the special
`mu4e-personal-or-alternative-address-p' such that it honors both
user-specified alternative address as well as the mu personal addresses.

Fixes #2708.
---
 mu4e/mu4e-draft.el | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/mu4e/mu4e-draft.el b/mu4e/mu4e-draft.el
index 1a5e015ef..12834580c 100644
--- a/mu4e/mu4e-draft.el
+++ b/mu4e/mu4e-draft.el
@@ -514,7 +514,14 @@ while in a buffer with the to-be-forwarded/replied-to message."
   (let* ((message-this-is-mail t)
          (message-generate-headers-first nil)
          (message-newsreader mu4e-user-agent-string)
-         (message-mail-user-agent nil))
+         (message-mail-user-agent nil)
+         (mam message-alternative-emails)
+         (message-alternative-emails
+          (lambda (addr)
+            (or (mu4e-personal-address-p addr)
+                (cond
+                 ((functionp mam) (funcall mam addr))
+                 ((stringp mam)   (string-match mam addr)))))))
     (cl-letf
         ;; `message-pop-to-buffer' attempts switching the visible buffer;
         ;; instead, we manipulate it to _return_ the buffer.

From 7c22e95b5eae3053cd9a3091960f9050817681b0 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Wed, 15 May 2024 02:53:22 +0300
Subject: [PATCH 036/305] mu4e: mark mu4e-sent-func as obsolete

mu4e-sent-func was used internally (triggered by mu-server), but is no
longer in use, so let's remove it and mark as obsolete.

Obsolete its callers as well.
---
 mu4e/mu4e-icalendar.el | 29 +++++++++++++++--------------
 mu4e/mu4e-obsolete.el  |  4 ++++
 mu4e/mu4e-server.el    | 13 +------------
 mu4e/mu4e.el           |  2 --
 4 files changed, 20 insertions(+), 28 deletions(-)

diff --git a/mu4e/mu4e-icalendar.el b/mu4e/mu4e-icalendar.el
index 30feb51c4..82a18f8e6 100644
--- a/mu4e/mu4e-icalendar.el
+++ b/mu4e/mu4e-icalendar.el
@@ -66,10 +66,10 @@
   "Icalendar related settings."
   :group 'mu4e)
 
-(defcustom mu4e-icalendar-trash-after-reply nil
-  "If non-nil, trash the icalendar invitation after replying."
-  :type 'boolean
-  :group 'mu4e-icalendar)
+;; (defcustom mu4e-icalendar-trash-after-reply nil
+;;   "If non-nil, trash the icalendar invitation after replying."
+;;   :type 'boolean
+;;   :group 'mu4e-icalendar)
 
 (defcustom mu4e-icalendar-diary-file nil
   "If non-nil, the file in which to add events upon reply."
@@ -142,11 +142,12 @@
               (mml-insert-empty-tag 'part 'type "text/plain")
               (mml-attach-buffer ical-name
                                  "text/calendar; method=REPLY; charset=UTF-8")
-              (when mu4e-icalendar-trash-after-reply
-                ;; Override `mu4e-sent-handler' set by `mu4e-compose-mode' to
-                ;; also trash the message (thus must be appended to hooks).
-                (add-hook 'message-sent-hook
-                          (mu4e--icalendar-trash-message-hook msg) 90 t))
+              ;; XXX: not currently supported
+              ;;(when mu4e-icalendar-trash-after-reply
+              ;;   ;; Override `mu4e-sent-handler' set by `mu4e-compose-mode' to
+              ;;   ;; also trash the message (thus must be appended to hooks).
+              ;;   (add-hook 'message-sent-hook
+              ;;             (mu4e--icalendar-trash-message-hook msg) 90 t))
 
               (when gnus-icalendar-org-enabled-p
                 (if (gnus-icalendar-find-org-event-file event)
@@ -175,11 +176,11 @@
         (or (mu4e-view-headers-next)
             (kill-buffer-and-window))))))
 
-(defun mu4e--icalendar-trash-message-hook (original-msg)
-  "Trash the iCalendar message ORIGINAL-MSG."
-  (lambda ()
-    (setq mu4e-sent-func
-          (mu4e--icalendar-trash-message original-msg))))
+;; (defun mu4e--icalendar-trash-message-hook (original-msg)
+;;   "Trash the iCalendar message ORIGINAL-MSG."
+;;   (lambda ()
+;;     (setq mu4e-sent-func
+;;           (mu4e--icalendar-trash-message original-msg))))
 
 (defun mu4e--icalendar-insert-diary (event reply-status filename)
   "Insert a diary entry for the EVENT in file named FILENAME.
diff --git a/mu4e/mu4e-obsolete.el b/mu4e/mu4e-obsolete.el
index c040e1abe..58362871a 100644
--- a/mu4e/mu4e-obsolete.el
+++ b/mu4e/mu4e-obsolete.el
@@ -229,6 +229,7 @@
 
 (make-obsolete-variable 'mu4e-header-func "mu4e-headers-append-func" "1.7.4")
 (make-obsolete-variable 'mu4e-temp-func "No longer used" "1.7.0")
+(make-obsolete-variable 'mu4e-sent-func  "No longer used" "1.12.5")
 
 
 ;; mu4e-update
@@ -276,6 +277,9 @@
 (define-obsolete-function-alias 'mu4e-icalendar-setup
   'gnus-icalendar-setup '"1.11.22")
 
+(make-obsolete-variable 'mu4e-icalendar-trash-after-reply
+                        "Not functional after composer changes"
+                        "1.12.5")
 ;; mu4e.
 (define-obsolete-function-alias 'mu4e-clear-caches #'ignore "1.11.15")
 
diff --git a/mu4e/mu4e-server.el b/mu4e/mu4e-server.el
index a280f098e..85f4050ec 100644
--- a/mu4e/mu4e-server.el
+++ b/mu4e/mu4e-server.el
@@ -1,6 +1,6 @@
 ;;; mu4e-server.el --- Control mu server from mu4e -*- lexical-binding: t -*-
 
-;; Copyright (C) 2011-2023 Dirk-Jan C. Binnema
+;; Copyright (C) 2011-2024 Dirk-Jan C. Binnema
 
 ;; Author: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ;; Maintainer: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
@@ -117,11 +117,6 @@ See `mu4e--server-filter' for the format.")
 This happens when some message has been deleted. The function is
 passed the docid of the removed message.")
 
-(defvar mu4e-sent-func  nil
-  "Function called for each :sent sexp received.
-This happens when some message has been sent. The function is
-passed the docid and the draft-path of the sent message.")
-
 (defvar mu4e-view-func  nil
   "Function called for each single-message sexp.
 The function is passed a message sexp as argument. See
@@ -358,12 +353,6 @@ The server output is as follows:
          ((plist-get sexp :erase)
           (funcall mu4e-erase-func))
 
-         ;; receive a :sent message
-         ((plist-get sexp :sent)
-          (funcall mu4e-sent-func
-                   (plist-get sexp :docid)
-                   (plist-get sexp :path)))
-
          ;; received a pong message
          ((plist-get sexp :pong)
           (setq mu4e--server-props (plist-get sexp :props))
diff --git a/mu4e/mu4e.el b/mu4e/mu4e.el
index d202a3ce0..8efc7b68d 100644
--- a/mu4e/mu4e.el
+++ b/mu4e/mu4e.el
@@ -253,8 +253,6 @@ chance."
   (mu4e-setq-if-nil mu4e-headers-append-func   #'mu4e~headers-append-handler)
   (mu4e-setq-if-nil mu4e-found-func            #'mu4e~headers-found-handler)
   (mu4e-setq-if-nil mu4e-erase-func            #'mu4e~headers-clear)
-
-  (mu4e-setq-if-nil mu4e-sent-func             #'mu4e--default-handler)
   (mu4e-setq-if-nil mu4e-contacts-func         #'mu4e--update-contacts)
   (mu4e-setq-if-nil mu4e-info-func             #'mu4e--info-handler)
   (mu4e-setq-if-nil mu4e-pong-func             #'mu4e--default-handler)

From 1e9f772e0aed180875ceed80e2004f88682d193a Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 26 May 2024 11:04:27 +0300
Subject: [PATCH 037/305] lib: fix batch-size after db creation

Ensure we use the user-specified batch-size immediately after db creation.
---
 lib/mu-store.cc     |  7 +++++--
 lib/mu-xapian-db.cc |  8 +++++++-
 lib/mu-xapian-db.hh | 10 +++++++++-
 3 files changed, 21 insertions(+), 4 deletions(-)

diff --git a/lib/mu-store.cc b/lib/mu-store.cc
index dd9f11460..927b38cb2 100644
--- a/lib/mu-store.cc
+++ b/lib/mu-store.cc
@@ -75,8 +75,11 @@ struct Store::Private {
 		config_{make_config(xapian_db_, root_maildir, conf)},
 		contacts_cache_{config_},
 		root_maildir_{remove_slash(config_.get<Config::Id::RootMaildir>())},
-		message_opts_{make_message_options(config_)}
-		{}
+		message_opts_{make_message_options(config_)} {
+		// so tell xapian-db to update its internal cacheed values from
+		// config. In practice: batch-size.
+		xapian_db_.reinit();
+	}
 
 	~Private() try {
 		mu_debug("closing store @ {}", xapian_db_.path());
diff --git a/lib/mu-xapian-db.cc b/lib/mu-xapian-db.cc
index a8c897a0e..bce9bf797 100644
--- a/lib/mu-xapian-db.cc
+++ b/lib/mu-xapian-db.cc
@@ -101,7 +101,7 @@ make_db(const std::string& db_path, Flavor flavor)
 XapianDb::XapianDb(const std::string& db_path, Flavor flavor):
 	path_(make_path(db_path, flavor)),
 	db_(make_db(path_, flavor)),
-	batch_size_{Config(*this).get<Config::Id::BatchSize>()}
+	batch_size_{Config(*this).get<Config::Id::BatchSize>()} // default
 {
 	if (flavor == Flavor::CreateOverwrite)
 		set_timestamp(MetadataIface::created_key);
@@ -109,6 +109,12 @@ XapianDb::XapianDb(const std::string& db_path, Flavor flavor):
 	mu_debug("created {} / {} (batch-size: {})", flavor, *this, batch_size_);
 }
 
+void
+XapianDb::reinit() {
+	batch_size_ = Config(*this).get<Config::Id::BatchSize>();
+	mu_debug("set batch-size to {}", batch_size_);
+}
+
 
 #ifdef BUILD_TESTS
 /*
diff --git a/lib/mu-xapian-db.hh b/lib/mu-xapian-db.hh
index f9753c60d..f0a977ff5 100644
--- a/lib/mu-xapian-db.hh
+++ b/lib/mu-xapian-db.hh
@@ -222,6 +222,14 @@ public:
 			mu_debug("closing db");
 	}
 
+	/**
+	 * Reinitialize from inner-config. Needed after CreateOverwrite.
+	 *
+	 * This is bit of a hack, needed since we cannot setup the config
+	 * before we have a database.
+	 */
+	void reinit();
+
 	/**
 	 * Is the database read-only?
 	 *
@@ -545,7 +553,7 @@ private:
 	std::string path_;
 	DbType	db_;
 	size_t	tx_level_{};
-	const size_t batch_size_;
+	size_t batch_size_;
 	size_t changes_{};
 };
 

From e3ab780413e589b19e2d7324832666dbb93ef966 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 26 May 2024 13:58:31 +0300
Subject: [PATCH 038/305] message: add default ctor

Useful for stuffing messages in async-queues
---
 lib/message/mu-message.cc | 4 ++++
 lib/message/mu-message.hh | 6 ++++++
 2 files changed, 10 insertions(+)

diff --git a/lib/message/mu-message.cc b/lib/message/mu-message.cc
index 6ddd1f394..ee692b4ee 100644
--- a/lib/message/mu-message.cc
+++ b/lib/message/mu-message.cc
@@ -104,6 +104,10 @@ get_statbuf(const std::string& path, Message::Options opts = Message::Options::N
 	return Ok(std::move(statbuf));
 }
 
+Message::Message() noexcept:
+	priv_{std::make_unique<Private>(Message::Options::None)}
+{}
+
 
 Message::Message(const std::string& path,  Message::Options opts):
 	priv_{std::make_unique<Private>(opts)}
diff --git a/lib/message/mu-message.hh b/lib/message/mu-message.hh
index 0f029f404..9be909608 100644
--- a/lib/message/mu-message.hh
+++ b/lib/message/mu-message.hh
@@ -55,6 +55,12 @@ public:
 						 * CJK and other languages. */
 	};
 
+	/**
+	 * Default CTOR; not useful by itself, but can be moved into.
+	 */
+	Message() noexcept;
+
+
 	/**
 	 * Move CTOR
 	 *

From 626b16a8f1adb71d5b5e3f9f0a3a4f369a6fbed4 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 26 May 2024 13:59:25 +0300
Subject: [PATCH 039/305] mu-config: cosmetic

---
 lib/mu-config.hh | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/mu-config.hh b/lib/mu-config.hh
index 17924c7de..eaa0cd94b 100644
--- a/lib/mu-config.hh
+++ b/lib/mu-config.hh
@@ -102,7 +102,7 @@ public:
 			Flags::Configurable,
 			"batch-size",
 			"50000",
-			"Number of changes in a database transaction"
+			"Maximum number of changes in a database transaction"
 		},
 		{
 			Id::Contacts,
@@ -216,7 +216,7 @@ public:
 	 */
 	static Option<const Property&> property(const std::string& name) {
 		const auto pname{std::string_view(name.data(), name.size())};
-		for(auto&& prop: properties)
+		for (auto&& prop: properties)
 			if (prop.name == pname)
 				return prop;
 		return Nothing;

From e978a58400f6c5ebc9de13f52dd5d13e1d7820e6 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 1 Jun 2024 10:04:18 +0300
Subject: [PATCH 040/305] mu4e-server: support non-numeric versions

For development / testing.
---
 mu4e/mu4e-server.el | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mu4e/mu4e-server.el b/mu4e/mu4e-server.el
index 85f4050ec..fae835148 100644
--- a/mu4e/mu4e-server.el
+++ b/mu4e/mu4e-server.el
@@ -431,7 +431,7 @@ As per issue #2198."
     ;; sanity-check 2
     (let ((version (let ((s (shell-command-to-string
                              (concat mu4e-mu-binary " --version"))))
-                     (and (string-match "version \\([.0-9]+\\)" s)
+                     (and (string-match "version \\(.+\\)" s)
                           (match-string 1 s)))))
       (if (not (string= version mu4e-mu-version))
           (mu4e-error

From c05b28e761ad0e0f3dc9cc14d84ac0543fd7ff53 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 26 May 2024 11:42:50 +0300
Subject: [PATCH 041/305] xapian-db: remove locks, transaction levels

Simplify xapian-db: locks should go elsewhere; transaction level add
too much complication.
---
 lib/mu-indexer.cc   |   2 -
 lib/mu-store.cc     |   4 +-
 lib/mu-xapian-db.cc |   3 +-
 lib/mu-xapian-db.hh | 170 +++++++++++++++-----------------------------
 4 files changed, 64 insertions(+), 115 deletions(-)

diff --git a/lib/mu-indexer.cc b/lib/mu-indexer.cc
index 72756d1b9..283a11b89 100644
--- a/lib/mu-indexer.cc
+++ b/lib/mu-indexer.cc
@@ -324,8 +324,6 @@ Indexer::Private::cleanup()
 void
 Indexer::Private::scan_worker()
 {
-	XapianDb::Transaction tx{store_.xapian_db()}; // RAII
-
 	progress_.reset();
 	if (conf_.scan) {
 		mu_debug("starting scanner");
diff --git a/lib/mu-store.cc b/lib/mu-store.cc
index 927b38cb2..0db198acb 100644
--- a/lib/mu-store.cc
+++ b/lib/mu-store.cc
@@ -382,10 +382,12 @@ Store::remove_messages(const std::vector<Store::Id>& ids)
 {
 	std::lock_guard guard{priv_->lock_};
 
-	XapianDb::Transaction tx (xapian_db()); // RAII
+	xapian_db().request_transaction();
 
 	for (auto&& id : ids)
 		xapian_db().delete_document(id);
+
+	xapian_db().request_commit(true/*force*/);
 }
 
 
diff --git a/lib/mu-xapian-db.cc b/lib/mu-xapian-db.cc
index bce9bf797..ddc2c115c 100644
--- a/lib/mu-xapian-db.cc
+++ b/lib/mu-xapian-db.cc
@@ -41,6 +41,7 @@ XapianDb::wdb()
 {
 	if (read_only())
 		throw std::runtime_error("database is read-only");
+
 	return std::get<Xapian::WritableDatabase>(db_);
 }
 
@@ -106,7 +107,7 @@ XapianDb::XapianDb(const std::string& db_path, Flavor flavor):
 	if (flavor == Flavor::CreateOverwrite)
 		set_timestamp(MetadataIface::created_key);
 
-	mu_debug("created {} / {} (batch-size: {})", flavor, *this, batch_size_);
+	mu_debug("created {}", *this);
 }
 
 void
diff --git a/lib/mu-xapian-db.hh b/lib/mu-xapian-db.hh
index f0a977ff5..66739e580 100644
--- a/lib/mu-xapian-db.hh
+++ b/lib/mu-xapian-db.hh
@@ -24,6 +24,7 @@
 #include <memory>
 #include <string>
 #include <mutex>
+#include <thread>
 #include <functional>
 #include <unordered_map>
 
@@ -186,10 +187,8 @@ private:
 
 /**
  * Fairly thin wrapper around Xapian::Database and Xapian::WritableDatabase
- * with just the things we need + locking + exception handling
  */
 class XapianDb: public MetadataIface {
-#define DB_LOCKED std::unique_lock lock__{lock_};
 public:
 	/**
 	 * Type of database to create.
@@ -202,7 +201,7 @@ public:
 	};
 
 	/**
-	 * XapianDb CTOR. This may throw some Xapian exception.
+	 * XapianDb CTOR. This may throw.
 	 *
 	 * @param db_path path to the database
 	 * @param flavor kind of database
@@ -213,13 +212,9 @@ public:
 	 * DTOR
 	 */
 	~XapianDb() {
-		if (tx_level_ > 0)
-			mu_warning("inconsistent transaction level ({})", tx_level_);
-		if (tx_level_ > 0) {
-			mu_debug("closing db after committing {} change(s)", changes_);
-			xapian_try([this]{ DB_LOCKED; wdb().commit_transaction(); });
-		} else
-			mu_debug("closing db");
+		if (!read_only())
+			request_commit(true/*force*/);
+		mu_debug("closing db");
 	}
 
 	/**
@@ -260,7 +255,7 @@ public:
 	 */
 	size_t size() const noexcept {
 		return xapian_try([this]{
-			DB_LOCKED; return db().get_doccount(); }, 0);
+			return db().get_doccount(); }, 0);
 	}
 
 	/**
@@ -276,7 +271,7 @@ public:
 	 * @return an enquire object
 	 */
 	Xapian::Enquire enquire() const {
-		DB_LOCKED; return Xapian::Enquire(db());
+		return Xapian::Enquire(db());
 	}
 
 	/**
@@ -288,7 +283,7 @@ public:
 	 */
 	Result<Xapian::Document> document(Xapian::docid id) const {
 		return xapian_try_result([&]{
-			DB_LOCKED; return Ok(db().get_document(id)); });
+			return Ok(db().get_document(id)); });
 	}
 
 	/**
@@ -300,7 +295,7 @@ public:
 	 */
 	std::string metadata(const std::string& key) const override {
 		return xapian_try([&]{
-			DB_LOCKED; return db().get_metadata(key);}, "");
+			return db().get_metadata(key);}, "");
 	}
 
 	/**
@@ -310,8 +305,8 @@ public:
 	 * @param val new value for key
 	 */
 	void set_metadata(const std::string& key, const std::string& val) override {
-		xapian_try([&] { DB_LOCKED; wdb().set_metadata(key, val);
-				maybe_commit(); });
+		xapian_try([&] { wdb().set_metadata(key, val);
+				maybe_commit();});
 	}
 
 	/**
@@ -323,7 +318,6 @@ public:
 	//using each_func = MetadataIface::each_func;
 	void for_each(MetadataIface::each_func&& func) const override {
 		xapian_try([&]{
-			DB_LOCKED;
 			for (auto&& it = db().metadata_keys_begin();
 			     it != db().metadata_keys_end(); ++it)
 				func(*it, db().get_metadata(*it));
@@ -339,7 +333,7 @@ public:
 	 */
 	bool term_exists(const std::string& term) const {
 		return xapian_try([&]{
-			DB_LOCKED; return db().term_exists(term);}, false);
+			return db().term_exists(term);}, false);
 	}
 
 	/**
@@ -351,7 +345,6 @@ public:
 	 */
 	Result<Xapian::docid> add_document(const Xapian::Document& doc) {
 		return xapian_try_result([&]{
-			DB_LOCKED;
 			auto&& id{wdb().add_document(doc)};
 			set_timestamp(MetadataIface::last_change_key);
 			maybe_commit();
@@ -369,9 +362,9 @@ public:
 	 * @return new docid or an error
 	 */
 	Result<Xapian::docid>
-	replace_document(const std::string& term, const Xapian::Document& doc) {
+	replace_document(const std::string& term,
+			 const Xapian::Document& doc) {
 		return xapian_try_result([&]{
-			DB_LOCKED;
 			auto&& id{wdb().replace_document(term, doc)};
 			set_timestamp(MetadataIface::last_change_key);
 			maybe_commit();
@@ -379,9 +372,9 @@ public:
 		});
 	}
 	Result<Xapian::docid>
-	replace_document(Xapian::docid id, const Xapian::Document& doc) {
+	replace_document(Xapian::docid id,
+			 const Xapian::Document& doc) {
 		return xapian_try_result([&]{
-			DB_LOCKED;
 			wdb().replace_document(id, doc);
 			set_timestamp(MetadataIface::last_change_key);
 			maybe_commit();
@@ -398,7 +391,6 @@ public:
 	 */
 	Result<void> delete_document(const std::string& term) {
 		return xapian_try_result([&]{
-			DB_LOCKED;
 			wdb().delete_document(term);
 			set_timestamp(MetadataIface::last_change_key);
 			maybe_commit();
@@ -407,7 +399,6 @@ public:
 	}
 	Result<void> delete_document(Xapian::docid id) {
 		return xapian_try_result([&]{
-			DB_LOCKED;
 			wdb().delete_document(id);
 			set_timestamp(MetadataIface::last_change_key);
 			maybe_commit();
@@ -417,7 +408,6 @@ public:
 
 	template<typename Func>
 	size_t all_terms(const std::string& prefix, Func&& func) const {
-		DB_LOCKED;
 		size_t n{};
 		for (auto it = db().allterms_begin(prefix); it != db().allterms_end(prefix); ++it) {
 			if (!func(*it))
@@ -427,110 +417,69 @@ public:
 		return n;
 	}
 
-	/*
-	 * If the "transaction ref count" > 0 (with inc_transactions());, we run
-	 * in "transaction mode". That means that the subsequent Xapian mutation
-	 * are part of a transactions, which is flushed when the number of
-	 * changes reaches the batch size, _or_ the transaction ref count is
-	 * decreased to 0 (dec_transactions()). *
-	 */
-
 	/**
-	 * Increase the transaction level; needs to be balance by dec_transactions()
+	 * Requests a transaction to be started; this is only
+	 * a request, which may not be granted.
+	 *
+	 * If you're already in a transaction but that transaction
+	 * was started in another thread, that transaction will be
+	 * committed before starting a new one.
+	 *
+	 * Otherwise, start a transaction if you're not already in one.
+	 *
+	 * @return A result; either true if a transaction was started; false
+	 * otherwise, or an error.
 	 */
-	void inc_transaction_level() {
-		xapian_try([this]{
-			DB_LOCKED;
-			if (tx_level_ == 0) {// need to start the Xapian transaction?
-				mu_debug("begin transaction");
-				wdb().begin_transaction();
-			}
-			++tx_level_;
-			mu_debug("ind'd tx level to {}", tx_level_);
+	Result<bool> request_transaction() {
+		return xapian_try_result([this]() {
+			auto& db = wdb();
+			if (in_transaction())
+				return Ok(false); // nothing to
+
+			db.begin_transaction();
+			mu_debug("begin transaction");
+			in_transaction_ = true;
+			return Ok(true);
 		});
 	}
 
+
 	/**
-	 * Decrease the transaction level (to balance inc_transactions())
+	 * Explicitly request the Xapian DB to be committed to disk. This won't
+	 * do anything when not in a transaction.
 	 *
-	 * If the level reach 0, perform a Xapian commit.
+	 * @param force whether to force-commit
 	 */
-	void dec_transaction_level() {
-		xapian_try([this]{
-			DB_LOCKED;
-			if (tx_level_ == 0) {
-				mu_critical("cannot dec transaction-level)");
-				throw std::runtime_error("cannot dec transactions");
-			}
-
-			--tx_level_;
-			if (tx_level_ == 0) {// need to commit the Xapian transaction?
-				mu_debug("committing {} changes", changes_);
-				changes_ = 0;
-				wdb().commit_transaction();
-			}
-
-			mu_debug("dec'd tx level to {}", tx_level_);
-		});
-	}
+	void request_commit(bool force = false) { request_commit(wdb(), force); }
+	void maybe_commit() { request_commit(false); }
 
 	/**
 	 * Are we inside a transaction?
 	 *
 	 * @return true or false
 	 */
-	bool in_transaction() const { DB_LOCKED; return tx_level_ > 0; }
-
-
-	/**
-	 * RAII Transaction object
-	 *
-	 */
-	struct Transaction {
-		Transaction(XapianDb& db): db_{db} {
-			db_.inc_transaction_level();
-		}
-		~Transaction() {
-			db_.dec_transaction_level();
-		}
-	private:
-		XapianDb& db_;
-	};
-
-
-	/**
-	 * Manually request the Xapian DB to be committed to disk. This won't
-	 * do anything while in a transaction.
-	 */
-	void commit() {
-		xapian_try([this]{
-			DB_LOCKED;
-			if (tx_level_ == 0) {
-				mu_info("committing xapian-db @ {}", path_);
-				wdb().commit();
-			} else
-				mu_debug("not committing while in transaction");
-		});
-	}
+	bool in_transaction() const { return in_transaction_; }
 
 	using DbType = std::variant<Xapian::Database, Xapian::WritableDatabase>;
-private:
 
+private:
 	/**
 	 * To be called after all changes, with DB_LOCKED held.
 	 */
-	void maybe_commit() {
+	void request_commit(Xapian::WritableDatabase& db, bool force) {
 		// in transaction-mode and enough changes, commit them
-		// and start a new transaction
-		if (tx_level_ > 0 && ++changes_ >= batch_size_) {
-			mu_debug("batch full ({}/{}); committing change", changes_, batch_size_);
-			wdb().commit_transaction();
-			wdb().commit();
-			--tx_level_;
+		if (!in_transaction())
+			return;
+		if ((++changes_ < batch_size_) && !force)
+			return;
+		xapian_try([&]{
+			mu_debug("committing transaction with {} changes; "
+				 "forced={}", changes_, force ? "yes" : "no");
+			db.commit_transaction();
+			db.commit();
 			changes_ = 0;
-			wdb().begin_transaction();
-			++tx_level_;
-		}
+			in_transaction_ = {};
+		});
 	}
 
 	void set_timestamp(const std::string_view key);
@@ -549,12 +498,11 @@ private:
 	 */
 	Xapian::WritableDatabase& wdb();
 
-	mutable std::mutex lock_;
 	std::string path_;
 	DbType	db_;
-	size_t	tx_level_{};
-	size_t batch_size_;
 	size_t changes_{};
+	bool in_transaction_{};
+	size_t batch_size_;
 };
 
 constexpr std::string_view

From cf9c09867fa553c7edb60651553cb9cf8b7e15ae Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 26 May 2024 14:20:47 +0300
Subject: [PATCH 042/305] store-worker: implement

store-worker is a thread + async queue to throttle requests to a single thread.
---
 lib/meson.build        |   1 +
 lib/mu-store-worker.cc |  68 +++++++++++++++++
 lib/mu-store-worker.hh | 169 +++++++++++++++++++++++++++++++++++++++++
 lib/mu-store.cc        |  11 +++
 lib/mu-store.hh        |  10 ++-
 5 files changed, 258 insertions(+), 1 deletion(-)
 create mode 100644 lib/mu-store-worker.cc
 create mode 100644 lib/mu-store-worker.hh

diff --git a/lib/meson.build b/lib/meson.build
index b3b519d54..91acaf287 100644
--- a/lib/meson.build
+++ b/lib/meson.build
@@ -42,6 +42,7 @@ lib_mu=static_library(
     # misc
     'mu-maildir.cc',
     'mu-script.cc',
+    'mu-store-worker.cc'
   ],
   dependencies: [
     glib_dep,
diff --git a/lib/mu-store-worker.cc b/lib/mu-store-worker.cc
new file mode 100644
index 000000000..d4bcbbfc9
--- /dev/null
+++ b/lib/mu-store-worker.cc
@@ -0,0 +1,68 @@
+/*
+** Copyright (C) 2024 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+**
+** This program is free software; you can redistribute it and/or modify it
+** under the terms of the GNU General Public License as published by the
+** Free Software Foundation; either version 3, or (at your option) any
+** later version.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with this program; if not, write to the Free Software Foundation,
+** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+**
+*/
+
+#include "mu-store-worker.hh"
+#include "mu-store.hh"
+#include "utils/mu-utils.hh"
+
+#include <type_traits>
+
+using namespace Mu;
+
+// helper constant for the visitor
+template<class> inline constexpr bool always_false_v = false;
+
+void
+StoreWorker::run() {
+
+	running_ = true;
+
+	while (running_) {
+		WorkItem workitem;
+
+		if (!q_.pop(workitem))
+			continue;
+
+		std::visit([&](auto&& item) {
+			using T = std::decay_t<decltype(item)>;
+
+			if constexpr (std::is_same_v<T, SexpCommand>) {
+				if (!sexp_handler_)
+					mu_critical("no handler for sexp '{}'", item);
+				else
+					sexp_handler_(item);
+			} else if constexpr (std::is_same_v<T, SetDirStamp>) {
+				store_.set_dirstamp(item.path, item.tstamp);
+			} else if constexpr (std::is_same_v<T, SetLastIndex>) {
+				store_.config().set<Mu::Config::Id::LastIndex>(item.tstamp);
+			} else if constexpr (std::is_same_v<T, StartTransaction>) {
+				store_.xapian_db().request_transaction();
+			} else if constexpr (std::is_same_v<T, EndTransaction>) {
+				store_.xapian_db().request_commit(true);
+			} else if constexpr (std::is_same_v<T, RemoveMessages>) {
+				store_.remove_messages(item);
+			} else if constexpr (std::is_same_v<T, AddMessage>) {
+				store_.consume_message(std::move(item.msg), true/*new*/);
+			} else if constexpr (std::is_same_v<T, UpdateMessage>) {
+				store_.consume_message(std::move(item.msg), false/*maybe not new*/);
+			} else
+				static_assert(always_false_v<T>, "non-exhaustive visitor");
+		}, workitem);
+	}
+}
diff --git a/lib/mu-store-worker.hh b/lib/mu-store-worker.hh
new file mode 100644
index 000000000..6c6ce83bc
--- /dev/null
+++ b/lib/mu-store-worker.hh
@@ -0,0 +1,169 @@
+/*
+** Copyright (C) 2024 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+**
+** This program is free software; you can redistribute it and/or modify it
+** under the terms of the GNU General Public License as published by the
+** Free Software Foundation; either version 3, or (at your option) any
+** later version.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with this program; if not, write to the Free Software Foundation,
+** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+**
+*/
+
+
+/**
+ * The store worker maintains a worker thread and an async queue to which
+ * commands can be added from any thread; the worker thread that is the sole
+ * thread to talk to the store / Xapian (at least for writing).
+ */
+
+#ifndef MU_STORE_WORKER_HH
+#define MU_STORE_WORKER_HH
+
+#include <variant>
+#include <string>
+#include <thread>
+#include <atomic>
+#include <vector>
+#include <functional>
+
+#include <message/mu-message.hh>
+#include <utils/mu-async-queue.hh>
+
+namespace Mu {
+
+/**< Sum type for all commands  */
+
+class Store; /// fwd declaration
+
+/**
+ * Worker for sending requests to the Store
+ *
+ * I.e. to execute database commands in a single thread.
+ */
+class StoreWorker {
+public:
+	/**
+	 * CTOR. This will create the store worker and start the worker thread.
+	 *
+	 * @param store a store
+	 */
+	StoreWorker(Store& store):
+		store_{store},
+		runner_ {std::thread([this]{run();})}
+		{}
+
+	/**
+	 * DTOR. Destroy the store worker after joining the worker thread
+	 */
+	~StoreWorker() {
+		running_ = false;
+		if (runner_.joinable())
+			runner_.join();
+	}
+
+	/*
+	 * The following types of work-item can be added to the queue:
+	 */
+	struct SetDirStamp {
+		std::string path; /**< full path to directory */
+		::time_t tstamp; /**< Timestamp for directory */
+	}; /**<  Write a directory timestamp to the store */
+
+	struct SetLastIndex {
+		::time_t tstamp; /**< Timestamp */
+	}; /**<  Write last indexing timestamp to the store */
+
+	struct StartTransaction{}; /**< Request transaction start
+				    * (opportunistically) */
+	struct EndTransaction{}; /**< Request transaction end/commit
+				  * (opportunistically) */
+	struct AddMessage  {
+		Message msg; /**< Add a new message */
+	}; /**< Add a new message; this is faster version of UpdateMessage
+	    * if we know the message does not exist yet. */
+	struct UpdateMessage  {
+		Message msg; /**< Add or update a message */
+	}; /**< Add message or update if it already exists */
+
+	using RemoveMessages = std::vector<unsigned>;
+	/**< Remove all message with the given ids */
+	using SexpCommand = std::string; /**< A sexp-command (i.e., from mu4e);
+					  * requires install_sexp_handler() */
+
+	using WorkItem = std::variant<SetDirStamp, SetLastIndex,
+				      AddMessage, UpdateMessage,
+				      StartTransaction, EndTransaction,
+				      RemoveMessages, SexpCommand>;
+	/// Sumtype with all types of work-item
+
+	using QueueType = AsyncQueue<WorkItem>;
+	const QueueType& queue() const { return q_; }
+	QueueType& queue() { return q_; }
+
+	/**
+	 * Push a work item to the que
+	 *
+	 * @param item
+	 */
+	void push(WorkItem&& item) {
+		q_.push(std::move(item));
+	}
+
+	/**
+	 * Get the current size of the work item queue
+	 *
+	 * @return the size
+	 */
+	size_t size() const {
+		return q_.size();
+	}
+
+	/**
+	 * Is the work item queue empty?
+	 *
+	 * @return true or false
+	 */
+	bool empty() const {
+		return q_.empty();
+	}
+
+	/**
+	 * Clear the queue of any items
+	 */
+	void clear() {
+		q_.clear();
+	}
+
+	using SexpCommandHandler = std::function<void(const std::string& sexp)>;
+	/**< Prototype for a SexpCommand handler function */
+
+	/**
+	 * Install a handler for Sexp commands
+	 *
+	 * @param handler
+	 */
+	void install_sexp_handler(SexpCommandHandler&& handler) {
+		sexp_handler_ = handler;
+	}
+
+private:
+	void run();
+	size_t cleanup_orphans();
+
+	QueueType q_;
+	Store& store_;;
+	std::thread runner_;
+	std::atomic<bool> running_{};
+	SexpCommandHandler sexp_handler_{};
+};
+
+} // namespace Mu
+#endif /*MU_STORE_WORKER_HH*/
diff --git a/lib/mu-store.cc b/lib/mu-store.cc
index 0db198acb..5aa367091 100644
--- a/lib/mu-store.cc
+++ b/lib/mu-store.cc
@@ -131,6 +131,7 @@ struct Store::Private {
 	XapianDb xapian_db_;
 	Config config_;
 	ContactsCache            contacts_cache_;
+	std::unique_ptr<StoreWorker> store_worker_;
 	std::unique_ptr<Indexer> indexer_;
 
 	const std::string	root_maildir_;
@@ -252,6 +253,7 @@ Store::Store(Store&& other)
 {
 	priv_ = std::move(other.priv_);
 	priv_->indexer_.reset();
+	priv_->store_worker_.reset();
 }
 
 Store::~Store() = default;
@@ -316,6 +318,15 @@ Store::indexer()
 	return *priv_->indexer_.get();
 }
 
+StoreWorker&
+Store::store_worker()
+{
+	if (!priv_->store_worker_)
+		priv_->store_worker_ = std::make_unique<StoreWorker>(*this);
+
+	return *priv_->store_worker_;
+}
+
 Result<Store::Id>
 Store::add_message(Message& msg, bool is_new)
 {
diff --git a/lib/mu-store.hh b/lib/mu-store.hh
index 07d8a03c1..643bb31cb 100644
--- a/lib/mu-store.hh
+++ b/lib/mu-store.hh
@@ -1,5 +1,5 @@
 /*
-** Copyright (C) 2023 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2024 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify it
 ** under the terms of the GNU General Public License as published by the
@@ -31,6 +31,7 @@
 #include "mu-config.hh"
 #include "mu-indexer.hh"
 #include "mu-query-results.hh"
+#include "mu-store-worker.hh"
 
 #include <utils/mu-utils.hh>
 #include <utils/mu-utils.hh>
@@ -147,6 +148,13 @@ public:
 	 */
 	Indexer& indexer();
 
+	/**
+	 * Get the store-worker instance
+	 *
+	 * @return the store-worker
+	 */
+	StoreWorker& store_worker();
+
 	/**
 	 * Run a query; see the `mu-query` man page for the syntax.
 	 *

From f2f01595a51380ae38aafb4cd11a0d3c17a33a10 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 26 May 2024 15:59:58 +0300
Subject: [PATCH 043/305] indexer: use store-worker

Use the store worker (-thread) to do all database modification.

Currently, the "removed" field of Progress is always 0.
---
 lib/mu-indexer.cc | 318 ++++++++++++++++++++--------------------------
 1 file changed, 137 insertions(+), 181 deletions(-)

diff --git a/lib/mu-indexer.cc b/lib/mu-indexer.cc
index 283a11b89..bfeac4870 100644
--- a/lib/mu-indexer.cc
+++ b/lib/mu-indexer.cc
@@ -1,5 +1,5 @@
 /*
-** Copyright (C) 2020-2023 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2020-2024 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify it
 ** under the terms of the GNU General Public License as published by the
@@ -29,6 +29,7 @@
 #include <condition_variable>
 #include <iostream>
 #include <atomic>
+#include <string_view>
 #include <chrono>
 using namespace std::chrono_literals;
 
@@ -42,49 +43,28 @@ using namespace std::chrono_literals;
 
 using namespace Mu;
 
-struct IndexState {
-	enum State { Idle,
-		     Scanning,
-		     Finishing,
-		     Cleaning
-	};
-	static const char* name(State s) {
-		switch (s) {
-		case Idle:
-			return "idle";
-		case Scanning:
-			return "scanning";
-		case Finishing:
-			return "finishing";
-		case Cleaning:
-			return "cleaning";
-		default:
-			return "<error>";
-		}
-	}
+// states
 
-	bool operator==(State rhs) const {
-		return state_.load() == rhs;
-	}
-	bool operator!=(State rhs) const {
-		return state_.load() != rhs;
-	}
-	void change_to(State new_state) {
-		mu_debug("changing indexer state {}->{}", name((State)state_),
-			name((State)new_state));
-		state_.store(new_state);
+enum struct State { Idle, Scanning, Draining };
+constexpr std::string_view
+format_as(State s)
+{
+	switch (s) {
+	case State::Idle:     return "idle";
+	case State::Scanning: return "scanning";
+	case State::Draining: return "draining";
+	default: return "<error>";
 	}
-
-private:
-	std::atomic<State> state_{Idle};
-};
+}
 
 struct Indexer::Private {
 	Private(Mu::Store& store)
-	    : store_{store}, scanner_{store_.root_maildir(),
+	    : store_{store},
+	      store_worker_{store.store_worker()},
+	      scanner_{store_.root_maildir(),
 		[this](auto&& path,
 		       auto&& statbuf, auto&& info) {
-			return handler(path, statbuf, info);
+			return scan_handler(path, statbuf, info);
 		}},
 	      max_message_size_{store_.config().get<Mu::Config::Id::MaxMessageSize>()},
 	      was_empty_{store.empty()} {
@@ -97,27 +77,55 @@ struct Indexer::Private {
 			   store.config().get<Mu::Config::Id::SupportNgrams>());
 	}
 
-	~Private() {
-		stop();
+	~Private() { force_cleanup(); }
+
+	void force_cleanup() {
+		switch_state(State::Idle);
+		scanner_.stop();
+		if (scanner_worker_.joinable())
+			scanner_worker_.join();
+		msg_paths_.clear();
+		for (auto&& w : workers_)
+			if (w.joinable())
+				w.join();
+		store_worker_.clear();
 	}
 
 	bool dir_predicate(const std::string& path, const struct dirent* dirent) const;
-	bool handler(const std::string& fullpath, struct stat* statbuf, Scanner::HandleType htype);
+	bool scan_handler(const std::string& fullpath, struct stat* statbuf,
+			  Scanner::HandleType htype);
 
 	void maybe_start_worker();
 	void item_worker();
 	void scan_worker();
 
-	bool add_message(const std::string& path);
-
-	bool cleanup();
 	bool start(const Indexer::Config& conf, bool block);
 	bool stop();
 
-	bool is_running() const { return state_ != IndexState::Idle; }
+	bool is_running() const { return state_ != State::Idle; }
+	void switch_state(State new_state) {
+		mu_debug("changing indexer state {}->{}", state_, new_state);
+		state_ = new_state;
+	}
+
+	// pace a bit so scan_items queue doesn't get too big.
+	void pace_scan_worker() {
+		while (msg_paths_.size() > 8 * max_workers_) {
+			std::this_thread::sleep_for(25ms);
+			continue;
+		}
+	}
+	// pace a bit so store-worker queue doesn't get too big.
+	void pace_store_worker() {
+		while (store_worker_.size() > 8) {
+			std::this_thread::sleep_for(25ms);
+			continue;
+		}
+	}
 
 	Indexer::Config conf_;
-	Store&          store_;
+	const Store&    store_;
+	StoreWorker&    store_worker_;
 	Scanner         scanner_;
 	const size_t    max_message_size_;
 
@@ -126,27 +134,18 @@ struct Indexer::Private {
 	std::vector<std::thread> workers_;
 	std::thread              scanner_worker_;
 
-	struct WorkItem {
-		std::string full_path;
-		enum Type {
-			Dir,
-			File
-		};
-		Type type;
-	};
-
-	AsyncQueue<WorkItem> todos_;
+	AsyncQueue<std::string> msg_paths_;
 
 	Progress   progress_{};
-	IndexState state_{};
+	std::atomic<State> state_{State::Idle};
 	std::mutex lock_, w_lock_;
 	std::atomic<time_t> completed_{};
 	bool was_empty_{};
 };
 
 bool
-Indexer::Private::handler(const std::string& fullpath, struct stat* statbuf,
-			  Scanner::HandleType htype)
+Indexer::Private::scan_handler(const std::string& fullpath, struct stat* statbuf,
+			       Scanner::HandleType htype)
 {
 	switch (htype) {
 	case Scanner::HandleType::EnterDir:
@@ -160,7 +159,7 @@ Indexer::Private::handler(const std::string& fullpath, struct stat* statbuf,
 			return false;
 		}
 
-		// in lazy-mode, we ignore this dir if its dirstamp suggest it
+		// in lazy-mode, we ignore this dir if its dirstamp suggests it
 		// is up-to-date (this is _not_ always true; hence we call it
 		// lazy-mode); only for actual message dirs, since the dir
 		// tstamps may not bubble up.U
@@ -193,14 +192,16 @@ Indexer::Private::handler(const std::string& fullpath, struct stat* statbuf,
 		return true;
 	}
 	case Scanner::HandleType::LeaveDir: {
-		todos_.push({fullpath, WorkItem::Type::Dir});
+		// directly push to store worker, bypass scan-items queue
+		pace_store_worker();
+		store_worker_.push(StoreWorker::SetDirStamp{fullpath, ::time({})});
 		return true;
 	}
 
 	case Scanner::HandleType::File: {
 		++progress_.checked;
 
-		if ((size_t)statbuf->st_size > max_message_size_) {
+		if (static_cast<size_t>(statbuf->st_size) > max_message_size_) {
 			mu_debug("skip {} (too big: {} bytes)", fullpath, statbuf->st_size);
 			return false;
 		}
@@ -210,9 +211,10 @@ Indexer::Private::handler(const std::string& fullpath, struct stat* statbuf,
 		if (statbuf->st_ctime <= dirstamp_ && store_.contains_message(fullpath))
 			return false;
 
-		// push the remaining messages to our "todo" queue for
+		// push the remaining messages to our "scan-items" queue for
 		// (re)parsing and adding/updating to the database.
-		todos_.push({fullpath, WorkItem::Type::File});
+		pace_scan_worker();
+		msg_paths_.push(std::string{fullpath}); // move?
 		return true;
 	}
 	default:
@@ -226,158 +228,94 @@ Indexer::Private::maybe_start_worker()
 {
 	std::lock_guard lock{w_lock_};
 
-	if (todos_.size() > workers_.size() && workers_.size() < max_workers_) {
+	if (msg_paths_.size() > workers_.size() && workers_.size() < max_workers_) {
 		workers_.emplace_back(std::thread([this] { item_worker(); }));
 		mu_debug("added worker {}", workers_.size());
 	}
 }
 
-bool
-Indexer::Private::add_message(const std::string& path)
-{
-	/*
-	 * Having the lock here makes things a _lot_ slower.
-	 *
-	 * The reason for having the lock is some helgrind warnings;
-	 * but it believed those are _false alarms_
-	 * https://gitlab.gnome.org/GNOME/glib/-/issues/2662
-	 */
-	//std::unique_lock lock{w_lock_};
-	auto msg{Message::make_from_path(path, store_.message_options())};
-	if (!msg) {
-		mu_warning("failed to create message from {}: {}", path, msg.error().what());
-		return false;
-	}
-	// if the store was empty, we know that the message is completely new
-	// and can use the fast path (Xapians 'add_document' rather than
-	// 'replace_document)
-	auto res = store_.consume_message(std::move(msg.value()), was_empty_);
-	if (!res) {
-		mu_warning("failed to add message @ {}: {}", path, res.error().what());
-		return false;
-	}
-
-	return true;
-}
-
 void
 Indexer::Private::item_worker()
 {
-	WorkItem item;
-
 	mu_debug("started worker");
 
-	while (state_ == IndexState::Scanning) {
-		if (!todos_.pop(item, 250ms))
-			continue;
-		try {
-			switch (item.type) {
-			case WorkItem::Type::File: {
-				if (G_LIKELY(add_message(item.full_path)))
-					++progress_.updated;
-			} break;
-			case WorkItem::Type::Dir:
-				store_.set_dirstamp(item.full_path, ::time(NULL));
-				break;
-			default:
-				g_warn_if_reached();
-				break;
-			}
-		} catch (const Mu::Error& er) {
-			mu_warning("error adding message @ {}: {}", item.full_path, er.what());
-		}
+	while (state_ == State::Scanning ||
+	       (state_ == State::Draining && !msg_paths_.empty())) {
 
-		maybe_start_worker();
-		std::this_thread::yield();
-	}
-}
+		std::string msgpath;
+		if (!msg_paths_.pop(msgpath, 250ms))
+			continue;
 
-bool
-Indexer::Private::cleanup()
-{
-	mu_debug("starting cleanup");
-
-	size_t                 n{};
-	std::vector<Store::Id> orphans; // store messages without files.
-	store_.for_each_message_path([&](Store::Id id, const std::string& path) {
-		++n;
-		if (::access(path.c_str(), R_OK) != 0) {
-			mu_debug("cannot read {} (id={}); queuing for removal from store",
-				 path, id);
-			orphans.emplace_back(id);
+		auto msg{Message::make_from_path(msgpath, store_.message_options())};
+		if (!msg) {
+			mu_warning("failed to create message from {}: {}",
+				   msgpath, msg.error().what());
+			continue;
 		}
 
-		return state_ == IndexState::Cleaning;
-	});
+		pace_store_worker(); /* slow down if store-worker q gets too big */
 
-	if (orphans.empty())
-		mu_debug("nothing to clean up");
-	else {
-		mu_debug("removing {} stale message(s) from store", orphans.size());
-		store_.remove_messages(orphans);
-		progress_.removed += orphans.size();
-	}
+		// if the store was empty, we know that the message is
+		// completely new and can use the fast path (Xapians
+		// 'add_document' rather than 'replace_document)
+		if (was_empty_)
+			store_worker_.push(StoreWorker::AddMessage{std::move(*msg)});
+		else
+			store_worker_.push(StoreWorker::UpdateMessage{std::move(*msg)});
+		++progress_.updated;
 
-	return true;
+		maybe_start_worker();
+	}
 }
 
 void
 Indexer::Private::scan_worker()
 {
-	progress_.reset();
 	if (conf_.scan) {
 		mu_debug("starting scanner");
 		if (!scanner_.start()) { // blocks.
 			mu_warning("failed to start scanner");
-			state_.change_to(IndexState::Idle);
+			switch_state(State::Idle);
 			return;
 		}
-		mu_debug("scanner finished with {} file(s) in queue", todos_.size());
+		mu_debug("scanner finished with {} file(s) in queue", msg_paths_.size());
 	}
 
-	// now there may still be messages in the work queue...
-	// finish those; this is a bit ugly; perhaps we should
-	// handle SIGTERM etc.
-
-	if (!todos_.empty()) {
-		const auto workers_size = std::invoke([this] {
-			std::lock_guard lock{w_lock_};
-			return workers_.size();
-		});
-		mu_debug("process {} remaining message(s) with {} worker(s)",
-			todos_.size(), workers_size);
-		while (!todos_.empty())
-			std::this_thread::sleep_for(100ms);
-	}
-	// and let the worker finish their work.
-	state_.change_to(IndexState::Finishing);
-	for (auto&& w : workers_)
-		if (w.joinable())
-			w.join();
-
 	if (conf_.cleanup) {
-		mu_debug("starting cleanup");
-		state_.change_to(IndexState::Cleaning);
-		cleanup();
-		mu_debug("cleanup finished");
+		mu_debug("starting cleanup with work-item(s) left: {}",
+			 store_worker_.size());
+
+		std::vector<Store::Id> orphans; // store messages without files.
+		store_.for_each_message_path([&](Store::Id id, const std::string& path) {
+			if (::access(path.c_str(), R_OK) != 0) {
+				mu_debug("orphan: cannot read {} (id={})", path, id);
+				orphans.emplace_back(id);
+			}
+			return true;
+		});
+		progress_.removed = orphans.size();
+		if (!orphans.empty()) {
+			mu_info("removing {} orphan message(s)", orphans.size());
+			store_worker_.push(StoreWorker::RemoveMessages{std::move(orphans)});
+		}
 	}
 
 	completed_ = ::time({});
-	store_.config().set<Mu::Config::Id::LastIndex>(completed_);
-	state_.change_to(IndexState::Idle);
+	store_worker_.push(StoreWorker::SetLastIndex{completed_});
+
+	stop();
 }
 
 bool
 Indexer::Private::start(const Indexer::Config& conf, bool block)
 {
-	stop();
+	force_cleanup();
 
 	conf_ = conf;
 	if (conf_.max_threads == 0) {
 		/* benchmarking suggests that ~4 threads is the fastest (the
 		 * real bottleneck is the database, so adding more threads just
-		 * slows things down)
-		 */
+		 * slows things down)  */
 		max_workers_ = std::min(4U, std::thread::hardware_concurrency());
 	} else
 		max_workers_ = conf.max_threads;
@@ -391,11 +329,14 @@ Indexer::Private::start(const Indexer::Config& conf, bool block)
 	mu_debug("indexing: {}; clean-up: {}", conf_.scan ? "yes" : "no",
 		 conf_.cleanup ? "yes" : "no");
 
-	state_.change_to(IndexState::Scanning);
+	progress_.reset();
+	switch_state(State::Scanning);
 	/* kick off the first worker, which will spawn more if needed. */
-	workers_.emplace_back(std::thread([this] { item_worker(); }));
-	/* kick the disk-scanner thread */
-	scanner_worker_ = std::thread([this] { scan_worker(); });
+	workers_.emplace_back(std::thread([this]{item_worker();}));
+	/* kick the file-system-scanner thread */
+	if (scanner_worker_.joinable())
+		scanner_worker_.join(); // kill old one
+	scanner_worker_ = std::thread([this]{scan_worker();});
 
 	mu_debug("started indexer in {}-mode", block ? "blocking" : "non-blocking");
 	if (block) {
@@ -411,18 +352,33 @@ Indexer::Private::start(const Indexer::Config& conf, bool block)
 bool
 Indexer::Private::stop()
 {
+	switch_state(State::Draining);
+
 	scanner_.stop();
+	// cannot join scanner_worker_ here since it may be our
+	// current thread.
 
-	todos_.clear();
-	if (scanner_worker_.joinable())
-		scanner_worker_.join();
+	// wait for completion.
+	while (!msg_paths_.empty()) {
+		mu_debug("scan-items left: {}", msg_paths_.size());
+		std::this_thread::sleep_for(250ms);
+	}
 
-	state_.change_to(IndexState::Idle);
 	for (auto&& w : workers_)
 		if (w.joinable())
 			w.join();
 	workers_.clear();
 
+	store_worker_.push(StoreWorker::EndTransaction());
+
+	// wait for completion.
+	while (!store_worker_.empty()) {
+		mu_debug("work-items left: {}", store_worker_.size());
+		std::this_thread::sleep_for(250ms);
+	}
+
+	switch_state(State::Idle);
+
 	return true;
 }
 
@@ -469,7 +425,7 @@ Indexer::is_running() const
 const Indexer::Progress&
 Indexer::progress() const
 {
-	priv_->progress_.running = priv_->state_ == IndexState::Idle ? false : true;
+	priv_->progress_.running = priv_->state_ == State::Idle ? false : true;
 
 	return priv_->progress_;
 }

From 697d6b6b4fe922af17a7535f25497798d925b68f Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Mon, 27 May 2024 23:02:42 +0300
Subject: [PATCH 044/305] server: pass sexp-commmands through store worker

To ensure all Xapian rw commands happen in the same thread.
---
 lib/mu-server.cc    | 70 ++++++++++++++++++++++++++++++++++++---------
 mu/mu-cmd-server.cc |  5 ++--
 2 files changed, 60 insertions(+), 15 deletions(-)

diff --git a/lib/mu-server.cc b/lib/mu-server.cc
index 62c9ca0c6..edc639821 100644
--- a/lib/mu-server.cc
+++ b/lib/mu-server.cc
@@ -1,5 +1,5 @@
 /*
-** Copyright (C) 2020-2023 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2020-2024 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify it
 ** under the terms of the GNU General Public License as published by the
@@ -29,9 +29,12 @@
 #include <atomic>
 #include <thread>
 #include <mutex>
+#include <condition_variable>
 #include <variant>
 #include <functional>
 
+
+
 #include <cstring>
 #include <glib.h>
 #include <glib/gprintf.h>
@@ -116,7 +119,7 @@ struct OutputStream {
 	}
 
 private:
-	std::string		fname_;
+	std::string fname_;
 	using OutType = std::variant<std::ofstream, std::ostringstream>;
 	OutType out_;
 };
@@ -126,11 +129,21 @@ struct OutputStream {
 /// @brief object to manage the server-context for all commands.
 struct Server::Private {
 	Private(Store& store, const Server::Options& opts, Output output)
-	    : store_{store}, options_{opts}, output_{output},
+	    : store_{store},
+	      store_worker_{store.store_worker()},
+	      options_{opts}, output_{output},
 	      command_handler_{make_command_map()},
 	      keep_going_{true},
-	      tmp_dir_{unwrap(make_temp_dir())}
-	{}
+	      tmp_dir_{unwrap(make_temp_dir())} {
+
+		// tell the store-worker that we (this class) can handle
+		// sexp strings.
+		store_worker_.install_sexp_handler(
+			[this](const std::string& sexp) {
+				this->invoke(sexp);
+			});
+
+	}
 
 	~Private() {
 		indexer().stop();
@@ -148,13 +161,10 @@ struct Server::Private {
 	// acccessors
 	Store&            store() { return store_; }
 	const Store&      store() const { return store_; }
+	StoreWorker&      store_worker() { return store_worker_; }
 	Indexer&          indexer() { return store().indexer(); }
 	//CommandMap&       command_map() const { return command_map_; }
 
-	//
-	// invoke
-	//
-	bool invoke(const std::string& expr) noexcept;
 
 	//
 	// output
@@ -186,7 +196,19 @@ struct Server::Private {
 	void remove_handler(const Command& cmd);
 	void view_handler(const Command& cmd);
 
+	bool keep_going() const { return keep_going_; }
+	void set_keep_going(bool going)  { keep_going_ = going; }
+
+	// make main thread wait until done with the command.
+	std::mutex done_lock_;
+	std::condition_variable done_cond_;
+
 private:
+	//
+	// invoke
+	//
+	bool invoke(const std::string& expr) noexcept;
+
 	void move_docid(Store::Id docid, Option<std::string> flagstr,
 			bool new_name, bool no_view);
 
@@ -209,6 +231,7 @@ struct Server::Private {
 	std::ofstream make_temp_file_stream(std::string& fname) const;
 
 	Store&			store_;
+	StoreWorker&            store_worker_;
 	Server::Options         options_;
 	Server::Output		output_;
 	const CommandHandler	command_handler_;
@@ -480,6 +503,10 @@ Server::Private::invoke(const std::string& expr) noexcept
 		keep_going_ = false;
 	}
 
+	// tell main thread we're done with the command.
+	std::lock_guard l{done_lock_};
+	done_cond_.notify_one();
+
 	return keep_going_;
 }
 
@@ -690,9 +717,6 @@ Server::Private::find_handler(const Command& cmd)
 	StopWatch sw{mu_format("{} (indexing: {})", __func__,
 			       indexer().is_running() ? "yes" :  "no")};
 
-	// we need to _lock_ the store while querying (which likely consists of
-	// multiple actual queries) + grabbing the results.
-	std::lock_guard l{store_.lock()};
 	auto qres{store_.run_query(q, sort_field_id, qflags, maxnum)};
 	if (!qres)
 		throw Error(Error::Code::Query, "failed to run query: {}", qres.error().what());
@@ -1081,7 +1105,27 @@ Server::~Server() = default;
 bool
 Server::invoke(const std::string& expr) noexcept
 {
-	return priv_->invoke(expr);
+	/* a _little_ hacky; handle _quit_ directly to properly
+	 * shut down the server */
+	if (expr == "(quit)")  {
+		mu_debug("quitting");
+		priv_->set_keep_going(false);
+		return false;
+	}
+
+	/*
+	 * feed the command to the queue; it'll get executed in the
+	 * store-worker thread; however, sync on its completion
+	 * so we get its keep_going() result
+	 *
+	 * as an added bonus, this ensures mu server shell doesn't require an
+	 * extra user RET to get back the prompt
+	 */
+	std::unique_lock done_lock{priv_->done_lock_};
+	priv_->store_worker().push(StoreWorker::SexpCommand{expr});
+	priv_->done_cond_.wait(done_lock);
+
+	return priv_->keep_going();
 }
 
 /* LCOV_EXCL_STOP */
diff --git a/mu/mu-cmd-server.cc b/mu/mu-cmd-server.cc
index 3a694566a..50c7c010f 100644
--- a/mu/mu-cmd-server.cc
+++ b/mu/mu-cmd-server.cc
@@ -79,11 +79,12 @@ cookie(size_t n)
 		::printf(COOKIE_PRE "%x" COOKIE_POST, num);
 }
 
-
-
 static void
 output_stdout(const std::string& str, Server::OutputFlags flags)
 {
+	// Note: with the StoreWorker, we _always_ need to flush
+	flags |= Server::OutputFlags::Flush;
+
 	cookie(str.size() + 1);
 	if (G_UNLIKELY(::puts(str.c_str()) < 0)) {
 		mu_critical("failed to write output '{}'", str);

From b4ff8d62af8c3a0224ab581ba139a9508ed7ee2b Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 2 Jun 2024 10:37:39 +0300
Subject: [PATCH 045/305] server: support doccount data request

So we can update doccount in mu4e after indexing
---
 lib/mu-server.cc | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/lib/mu-server.cc b/lib/mu-server.cc
index edc639821..e18ae3907 100644
--- a/lib/mu-server.cc
+++ b/lib/mu-server.cc
@@ -586,7 +586,9 @@ Server::Private::data_handler(const Command& cmd)
 {
 	const auto request_type{unwrap(cmd.symbol_arg(":kind"))};
 
-	if (request_type == "maildirs") {
+	if (request_type == "doccount") {
+		output(mu_format("(:doccount {})", store().size()));
+	} else if (request_type == "maildirs") {
 		auto&& out{make_output_stream()};
 		mu_print(out, "(");
 		for (auto&& mdir: store().maildirs())

From 525d110f7cdf2a24f558de17ca834067f9fb1633 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 2 Jun 2024 10:38:37 +0300
Subject: [PATCH 046/305] mu4e: improve update data

Update doccount after indexing.
---
 mu4e/mu4e-server.el | 18 ++++++++++---
 mu4e/mu4e-update.el |  6 ++---
 mu4e/mu4e.el        | 65 ++++++++++++++++++++++++---------------------
 3 files changed, 52 insertions(+), 37 deletions(-)

diff --git a/mu4e/mu4e-server.el b/mu4e/mu4e-server.el
index fae835148..0790501da 100644
--- a/mu4e/mu4e-server.el
+++ b/mu4e/mu4e-server.el
@@ -385,7 +385,10 @@ The server output is as follows:
          ((plist-get sexp :info)
           (funcall mu4e-info-func sexp))
 
-         ;; get some data
+         ;; get some data XXX generalize
+         ((plist-get sexp :doccount)
+          (plist-put mu4e--server-props :doccount
+                     (mu4e--server-plist-get sexp :doccount)))
          ((plist-get sexp :maildirs)
           (setq mu4e-maildir-list (mu4e--server-plist-get sexp :maildirs)))
 
@@ -556,9 +559,16 @@ get at most MAX contacts."
 
 (defun mu4e--server-data (kind)
   "Request data of some KIND.
-KIND is a symbol. Currently supported kinds: maildirs."
-  (mu4e--server-call-mu
-   `(data :kind ,kind)))
+KIND is a symbol or a list of symbols. Currently supported kinds:
+ `maildirs', `doccount'."
+  (pcase kind
+    ((pred (lambda (k) (memq k '(maildirs doccount))))
+     (mu4e--server-call-mu `(data :kind ,kind)))
+    ((pred listp)
+     (when kind
+       (mu4e--server-data (car kind))
+       (mu4e--server-data (cdr kind))))
+    (_ (mu4e-error "Unexpected kind %s" kind))))
 
 (defun mu4e--server-find (query threads sortfield sortdir maxnum skip-dups
                                 include-related)
diff --git a/mu4e/mu4e-update.el b/mu4e/mu4e-update.el
index 5bb9e1da1..11228fac2 100644
--- a/mu4e/mu4e-update.el
+++ b/mu4e/mu4e-update.el
@@ -130,9 +130,9 @@ changed")
 If non-nil, this is a plist of the form:
 \(
 :checked     <number of messages processed> (checked whether up-to-date)
-:updated     <number of messages updated/added
-:cleaned-up  <number of stale messages removed from store
-:stamp       <emacs (current-time) timestamp for the status)")
+:updated     <number of messages updated/added>
+:cleaned-up  <number of stale messages removed from store>
+:stamp       <emacs (current-time) timestamp for the status>")
 
 (defconst mu4e-last-update-buffer "*mu4e-last-update*"
   "Name of buffer with cloned from the last update buffer.
diff --git a/mu4e/mu4e.el b/mu4e/mu4e.el
index 8efc7b68d..31d4bf60d 100644
--- a/mu4e/mu4e.el
+++ b/mu4e/mu4e.el
@@ -1,6 +1,6 @@
 ;;; mu4e.el --- Mu4e, the mu mail user agent -*- lexical-binding: t -*-
 
-;; Copyright (C) 2011-2023 Dirk-Jan C. Binnema
+;; Copyright (C) 2011-2024 Dirk-Jan C. Binnema
 
 ;; Author: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ;; Maintainer: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
@@ -203,42 +203,47 @@ Otherwise, check requirements, then start mu4e. When successful, invoke
     (_ (mu4e-error "Error %d: %s" errcode errmsg))))
 
 (defun mu4e--update-status (info)
-  "Update the status message with INFO."
+  "Update `mu4e-index-update-status' with INFO.
+Return the former. As an additional side-effect, updates
+doccount in server-properties."
   (setq mu4e-index-update-status
-        `(:tstamp ,(current-time)
-          :checked ,(plist-get info :checked)
-          :updated  ,(plist-get info :updated)
-          :cleaned-up ,(plist-get info :cleaned-up))))
+        `(:tstamp     ,(current-time)
+          :checked    ,(or (plist-get info :checked) 0)
+          :updated    ,(or (plist-get info :updated) 0)
+          :cleaned-up ,(or (plist-get info :cleaned-up) 0)))
+  mu4e-index-update-status)
 
 (defun mu4e--info-handler (info)
   "Handler function for (:INFO ...) sexps received from server."
-  (let* ((type (plist-get info :info))
-         (checked (plist-get info :checked))
-         (updated (plist-get info :updated))
-         (cleaned-up (plist-get info :cleaned-up)))
+  (let* ((type (plist-get info :info)))
     (cond
      ((eq type 'add) t) ;; do nothing
      ((eq type 'index)
-      (if (eq (plist-get info :status) 'running)
-          (mu4e-index-message
-           "Indexing... checked %d, updated %d" checked updated)
-        (progn ;; i.e. 'complete
-          (mu4e--update-status info)
-          (mu4e-index-message
-           "%s completed; checked %d, updated %d, cleaned-up %d"
-           (if mu4e-index-lazy-check "Lazy indexing" "Indexing")
-           checked updated cleaned-up)
-          ;; index done; grab updated queries
-          (mu4e--query-items-refresh)
-          (run-hooks 'mu4e-index-updated-hook)
-          ;; backward compatibility...
-          (unless (zerop (+ updated cleaned-up))
-            mu4e-message-changed-hook)
-          (unless (and (not (string= mu4e--contacts-tstamp "0"))
-                       (zerop (plist-get info :updated)))
-            (mu4e--request-contacts-maybe)
-            (mu4e--server-data 'maildirs)) ;; update maildir list
-          (mu4e--main-redraw))))
+      (let* ((info (mu4e--update-status info))
+             (checked (plist-get info :checked))
+             (updated (plist-get info :updated))
+             (cleaned-up (plist-get  info :cleaned-up)))
+        (if (eq (plist-get info :status) 'running)
+            (mu4e-index-message
+             "Indexing... checked %d, updated %d"
+             checked updated)
+          (progn ;; i.e. 'complete
+            (mu4e-index-message
+             "%s completed; checked %d, updated %d, cleaned-up %d"
+             (if mu4e-index-lazy-check "Lazy indexing" "Indexing")
+             checked updated cleaned-up)
+            ;; index done; grab updated queries
+            (mu4e--query-items-refresh)
+            (run-hooks 'mu4e-index-updated-hook)
+            ;; backward compatibility...
+            (unless (zerop (+ updated cleaned-up))
+              mu4e-message-changed-hook)
+            (unless (and (not (string= mu4e--contacts-tstamp "0"))
+                         (zerop (plist-get info :updated)))
+              (mu4e--request-contacts-maybe)
+              (mu4e--server-data '(maildirs doccount)))
+            ;; update maildir list & doccount
+            (mu4e--main-redraw)))))
      ((plist-get info :message)
       (mu4e-index-message "%s" (plist-get info :message))))))
 

From 853fa32ace72878a672971811e1c52aaf937f7b1 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 4 Jun 2024 06:13:11 +0300
Subject: [PATCH 047/305] mu4e.texi: fix lisp bookmark examples

As per #2711.
---
 mu4e/mu4e.texi | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index e3e226c6b..7100c3ce7 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -2150,7 +2150,7 @@ inbox:
 (add-to-list 'mu4e-bookmarks
   '( :name  "Inbox messages in the last 7 days"
      :query (lambda () (concat "maildir:/inbox AND date:"
-            (format-time-string "%Y%m%d"
+            (format-time-string "%Y%m%d.."
                 (subtract-time (current-time) (days-to-time 7)))))
      :key   ?w) t)
 @end lisp
@@ -2163,7 +2163,7 @@ shown:
   (interactive (list (read-number "Show days old messages: " 7)))
   (let ((start-date (subtract-time (current-time) (days-to-time days-old))))
     (concat "maildir:/inbox AND date:"
-            (format-time-string "%Y%m%d" start-date))))
+            (format-time-string "%Y%m%d.." start-date))))
 
 (add-to-list 'mu4e-bookmarks
   `(:name  "Inbox messages in the last 7 days"

From 5bd439271d41fed86af83073461e6f0d83c226fc Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Wed, 5 Jun 2024 12:21:24 +0300
Subject: [PATCH 048/305] store-worker: temporarily revert

Of course, after merging some problems come up.
Let's fix those first.

This reverts commit f2f01595a51380ae38aafb4cd11a0d3c17a33a10.
---
 lib/mu-indexer.cc   | 318 +++++++++++++++++++++++++-------------------
 lib/mu-server.cc    |  74 ++---------
 mu/mu-cmd-server.cc |   5 +-
 mu4e/mu4e-server.el |  18 +--
 mu4e/mu4e-update.el |   6 +-
 mu4e/mu4e.el        |  65 +++++----
 6 files changed, 234 insertions(+), 252 deletions(-)

diff --git a/lib/mu-indexer.cc b/lib/mu-indexer.cc
index bfeac4870..283a11b89 100644
--- a/lib/mu-indexer.cc
+++ b/lib/mu-indexer.cc
@@ -1,5 +1,5 @@
 /*
-** Copyright (C) 2020-2024 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2020-2023 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify it
 ** under the terms of the GNU General Public License as published by the
@@ -29,7 +29,6 @@
 #include <condition_variable>
 #include <iostream>
 #include <atomic>
-#include <string_view>
 #include <chrono>
 using namespace std::chrono_literals;
 
@@ -43,28 +42,49 @@ using namespace std::chrono_literals;
 
 using namespace Mu;
 
-// states
+struct IndexState {
+	enum State { Idle,
+		     Scanning,
+		     Finishing,
+		     Cleaning
+	};
+	static const char* name(State s) {
+		switch (s) {
+		case Idle:
+			return "idle";
+		case Scanning:
+			return "scanning";
+		case Finishing:
+			return "finishing";
+		case Cleaning:
+			return "cleaning";
+		default:
+			return "<error>";
+		}
+	}
 
-enum struct State { Idle, Scanning, Draining };
-constexpr std::string_view
-format_as(State s)
-{
-	switch (s) {
-	case State::Idle:     return "idle";
-	case State::Scanning: return "scanning";
-	case State::Draining: return "draining";
-	default: return "<error>";
+	bool operator==(State rhs) const {
+		return state_.load() == rhs;
 	}
-}
+	bool operator!=(State rhs) const {
+		return state_.load() != rhs;
+	}
+	void change_to(State new_state) {
+		mu_debug("changing indexer state {}->{}", name((State)state_),
+			name((State)new_state));
+		state_.store(new_state);
+	}
+
+private:
+	std::atomic<State> state_{Idle};
+};
 
 struct Indexer::Private {
 	Private(Mu::Store& store)
-	    : store_{store},
-	      store_worker_{store.store_worker()},
-	      scanner_{store_.root_maildir(),
+	    : store_{store}, scanner_{store_.root_maildir(),
 		[this](auto&& path,
 		       auto&& statbuf, auto&& info) {
-			return scan_handler(path, statbuf, info);
+			return handler(path, statbuf, info);
 		}},
 	      max_message_size_{store_.config().get<Mu::Config::Id::MaxMessageSize>()},
 	      was_empty_{store.empty()} {
@@ -77,55 +97,27 @@ struct Indexer::Private {
 			   store.config().get<Mu::Config::Id::SupportNgrams>());
 	}
 
-	~Private() { force_cleanup(); }
-
-	void force_cleanup() {
-		switch_state(State::Idle);
-		scanner_.stop();
-		if (scanner_worker_.joinable())
-			scanner_worker_.join();
-		msg_paths_.clear();
-		for (auto&& w : workers_)
-			if (w.joinable())
-				w.join();
-		store_worker_.clear();
+	~Private() {
+		stop();
 	}
 
 	bool dir_predicate(const std::string& path, const struct dirent* dirent) const;
-	bool scan_handler(const std::string& fullpath, struct stat* statbuf,
-			  Scanner::HandleType htype);
+	bool handler(const std::string& fullpath, struct stat* statbuf, Scanner::HandleType htype);
 
 	void maybe_start_worker();
 	void item_worker();
 	void scan_worker();
 
+	bool add_message(const std::string& path);
+
+	bool cleanup();
 	bool start(const Indexer::Config& conf, bool block);
 	bool stop();
 
-	bool is_running() const { return state_ != State::Idle; }
-	void switch_state(State new_state) {
-		mu_debug("changing indexer state {}->{}", state_, new_state);
-		state_ = new_state;
-	}
-
-	// pace a bit so scan_items queue doesn't get too big.
-	void pace_scan_worker() {
-		while (msg_paths_.size() > 8 * max_workers_) {
-			std::this_thread::sleep_for(25ms);
-			continue;
-		}
-	}
-	// pace a bit so store-worker queue doesn't get too big.
-	void pace_store_worker() {
-		while (store_worker_.size() > 8) {
-			std::this_thread::sleep_for(25ms);
-			continue;
-		}
-	}
+	bool is_running() const { return state_ != IndexState::Idle; }
 
 	Indexer::Config conf_;
-	const Store&    store_;
-	StoreWorker&    store_worker_;
+	Store&          store_;
 	Scanner         scanner_;
 	const size_t    max_message_size_;
 
@@ -134,18 +126,27 @@ struct Indexer::Private {
 	std::vector<std::thread> workers_;
 	std::thread              scanner_worker_;
 
-	AsyncQueue<std::string> msg_paths_;
+	struct WorkItem {
+		std::string full_path;
+		enum Type {
+			Dir,
+			File
+		};
+		Type type;
+	};
+
+	AsyncQueue<WorkItem> todos_;
 
 	Progress   progress_{};
-	std::atomic<State> state_{State::Idle};
+	IndexState state_{};
 	std::mutex lock_, w_lock_;
 	std::atomic<time_t> completed_{};
 	bool was_empty_{};
 };
 
 bool
-Indexer::Private::scan_handler(const std::string& fullpath, struct stat* statbuf,
-			       Scanner::HandleType htype)
+Indexer::Private::handler(const std::string& fullpath, struct stat* statbuf,
+			  Scanner::HandleType htype)
 {
 	switch (htype) {
 	case Scanner::HandleType::EnterDir:
@@ -159,7 +160,7 @@ Indexer::Private::scan_handler(const std::string& fullpath, struct stat* statbuf
 			return false;
 		}
 
-		// in lazy-mode, we ignore this dir if its dirstamp suggests it
+		// in lazy-mode, we ignore this dir if its dirstamp suggest it
 		// is up-to-date (this is _not_ always true; hence we call it
 		// lazy-mode); only for actual message dirs, since the dir
 		// tstamps may not bubble up.U
@@ -192,16 +193,14 @@ Indexer::Private::scan_handler(const std::string& fullpath, struct stat* statbuf
 		return true;
 	}
 	case Scanner::HandleType::LeaveDir: {
-		// directly push to store worker, bypass scan-items queue
-		pace_store_worker();
-		store_worker_.push(StoreWorker::SetDirStamp{fullpath, ::time({})});
+		todos_.push({fullpath, WorkItem::Type::Dir});
 		return true;
 	}
 
 	case Scanner::HandleType::File: {
 		++progress_.checked;
 
-		if (static_cast<size_t>(statbuf->st_size) > max_message_size_) {
+		if ((size_t)statbuf->st_size > max_message_size_) {
 			mu_debug("skip {} (too big: {} bytes)", fullpath, statbuf->st_size);
 			return false;
 		}
@@ -211,10 +210,9 @@ Indexer::Private::scan_handler(const std::string& fullpath, struct stat* statbuf
 		if (statbuf->st_ctime <= dirstamp_ && store_.contains_message(fullpath))
 			return false;
 
-		// push the remaining messages to our "scan-items" queue for
+		// push the remaining messages to our "todo" queue for
 		// (re)parsing and adding/updating to the database.
-		pace_scan_worker();
-		msg_paths_.push(std::string{fullpath}); // move?
+		todos_.push({fullpath, WorkItem::Type::File});
 		return true;
 	}
 	default:
@@ -228,94 +226,158 @@ Indexer::Private::maybe_start_worker()
 {
 	std::lock_guard lock{w_lock_};
 
-	if (msg_paths_.size() > workers_.size() && workers_.size() < max_workers_) {
+	if (todos_.size() > workers_.size() && workers_.size() < max_workers_) {
 		workers_.emplace_back(std::thread([this] { item_worker(); }));
 		mu_debug("added worker {}", workers_.size());
 	}
 }
 
+bool
+Indexer::Private::add_message(const std::string& path)
+{
+	/*
+	 * Having the lock here makes things a _lot_ slower.
+	 *
+	 * The reason for having the lock is some helgrind warnings;
+	 * but it believed those are _false alarms_
+	 * https://gitlab.gnome.org/GNOME/glib/-/issues/2662
+	 */
+	//std::unique_lock lock{w_lock_};
+	auto msg{Message::make_from_path(path, store_.message_options())};
+	if (!msg) {
+		mu_warning("failed to create message from {}: {}", path, msg.error().what());
+		return false;
+	}
+	// if the store was empty, we know that the message is completely new
+	// and can use the fast path (Xapians 'add_document' rather than
+	// 'replace_document)
+	auto res = store_.consume_message(std::move(msg.value()), was_empty_);
+	if (!res) {
+		mu_warning("failed to add message @ {}: {}", path, res.error().what());
+		return false;
+	}
+
+	return true;
+}
+
 void
 Indexer::Private::item_worker()
 {
-	mu_debug("started worker");
-
-	while (state_ == State::Scanning ||
-	       (state_ == State::Draining && !msg_paths_.empty())) {
+	WorkItem item;
 
-		std::string msgpath;
-		if (!msg_paths_.pop(msgpath, 250ms))
-			continue;
+	mu_debug("started worker");
 
-		auto msg{Message::make_from_path(msgpath, store_.message_options())};
-		if (!msg) {
-			mu_warning("failed to create message from {}: {}",
-				   msgpath, msg.error().what());
+	while (state_ == IndexState::Scanning) {
+		if (!todos_.pop(item, 250ms))
 			continue;
+		try {
+			switch (item.type) {
+			case WorkItem::Type::File: {
+				if (G_LIKELY(add_message(item.full_path)))
+					++progress_.updated;
+			} break;
+			case WorkItem::Type::Dir:
+				store_.set_dirstamp(item.full_path, ::time(NULL));
+				break;
+			default:
+				g_warn_if_reached();
+				break;
+			}
+		} catch (const Mu::Error& er) {
+			mu_warning("error adding message @ {}: {}", item.full_path, er.what());
 		}
 
-		pace_store_worker(); /* slow down if store-worker q gets too big */
+		maybe_start_worker();
+		std::this_thread::yield();
+	}
+}
 
-		// if the store was empty, we know that the message is
-		// completely new and can use the fast path (Xapians
-		// 'add_document' rather than 'replace_document)
-		if (was_empty_)
-			store_worker_.push(StoreWorker::AddMessage{std::move(*msg)});
-		else
-			store_worker_.push(StoreWorker::UpdateMessage{std::move(*msg)});
-		++progress_.updated;
+bool
+Indexer::Private::cleanup()
+{
+	mu_debug("starting cleanup");
+
+	size_t                 n{};
+	std::vector<Store::Id> orphans; // store messages without files.
+	store_.for_each_message_path([&](Store::Id id, const std::string& path) {
+		++n;
+		if (::access(path.c_str(), R_OK) != 0) {
+			mu_debug("cannot read {} (id={}); queuing for removal from store",
+				 path, id);
+			orphans.emplace_back(id);
+		}
 
-		maybe_start_worker();
+		return state_ == IndexState::Cleaning;
+	});
+
+	if (orphans.empty())
+		mu_debug("nothing to clean up");
+	else {
+		mu_debug("removing {} stale message(s) from store", orphans.size());
+		store_.remove_messages(orphans);
+		progress_.removed += orphans.size();
 	}
+
+	return true;
 }
 
 void
 Indexer::Private::scan_worker()
 {
+	progress_.reset();
 	if (conf_.scan) {
 		mu_debug("starting scanner");
 		if (!scanner_.start()) { // blocks.
 			mu_warning("failed to start scanner");
-			switch_state(State::Idle);
+			state_.change_to(IndexState::Idle);
 			return;
 		}
-		mu_debug("scanner finished with {} file(s) in queue", msg_paths_.size());
+		mu_debug("scanner finished with {} file(s) in queue", todos_.size());
 	}
 
-	if (conf_.cleanup) {
-		mu_debug("starting cleanup with work-item(s) left: {}",
-			 store_worker_.size());
-
-		std::vector<Store::Id> orphans; // store messages without files.
-		store_.for_each_message_path([&](Store::Id id, const std::string& path) {
-			if (::access(path.c_str(), R_OK) != 0) {
-				mu_debug("orphan: cannot read {} (id={})", path, id);
-				orphans.emplace_back(id);
-			}
-			return true;
+	// now there may still be messages in the work queue...
+	// finish those; this is a bit ugly; perhaps we should
+	// handle SIGTERM etc.
+
+	if (!todos_.empty()) {
+		const auto workers_size = std::invoke([this] {
+			std::lock_guard lock{w_lock_};
+			return workers_.size();
 		});
-		progress_.removed = orphans.size();
-		if (!orphans.empty()) {
-			mu_info("removing {} orphan message(s)", orphans.size());
-			store_worker_.push(StoreWorker::RemoveMessages{std::move(orphans)});
-		}
+		mu_debug("process {} remaining message(s) with {} worker(s)",
+			todos_.size(), workers_size);
+		while (!todos_.empty())
+			std::this_thread::sleep_for(100ms);
 	}
+	// and let the worker finish their work.
+	state_.change_to(IndexState::Finishing);
+	for (auto&& w : workers_)
+		if (w.joinable())
+			w.join();
 
-	completed_ = ::time({});
-	store_worker_.push(StoreWorker::SetLastIndex{completed_});
+	if (conf_.cleanup) {
+		mu_debug("starting cleanup");
+		state_.change_to(IndexState::Cleaning);
+		cleanup();
+		mu_debug("cleanup finished");
+	}
 
-	stop();
+	completed_ = ::time({});
+	store_.config().set<Mu::Config::Id::LastIndex>(completed_);
+	state_.change_to(IndexState::Idle);
 }
 
 bool
 Indexer::Private::start(const Indexer::Config& conf, bool block)
 {
-	force_cleanup();
+	stop();
 
 	conf_ = conf;
 	if (conf_.max_threads == 0) {
 		/* benchmarking suggests that ~4 threads is the fastest (the
 		 * real bottleneck is the database, so adding more threads just
-		 * slows things down)  */
+		 * slows things down)
+		 */
 		max_workers_ = std::min(4U, std::thread::hardware_concurrency());
 	} else
 		max_workers_ = conf.max_threads;
@@ -329,14 +391,11 @@ Indexer::Private::start(const Indexer::Config& conf, bool block)
 	mu_debug("indexing: {}; clean-up: {}", conf_.scan ? "yes" : "no",
 		 conf_.cleanup ? "yes" : "no");
 
-	progress_.reset();
-	switch_state(State::Scanning);
+	state_.change_to(IndexState::Scanning);
 	/* kick off the first worker, which will spawn more if needed. */
-	workers_.emplace_back(std::thread([this]{item_worker();}));
-	/* kick the file-system-scanner thread */
-	if (scanner_worker_.joinable())
-		scanner_worker_.join(); // kill old one
-	scanner_worker_ = std::thread([this]{scan_worker();});
+	workers_.emplace_back(std::thread([this] { item_worker(); }));
+	/* kick the disk-scanner thread */
+	scanner_worker_ = std::thread([this] { scan_worker(); });
 
 	mu_debug("started indexer in {}-mode", block ? "blocking" : "non-blocking");
 	if (block) {
@@ -352,33 +411,18 @@ Indexer::Private::start(const Indexer::Config& conf, bool block)
 bool
 Indexer::Private::stop()
 {
-	switch_state(State::Draining);
-
 	scanner_.stop();
-	// cannot join scanner_worker_ here since it may be our
-	// current thread.
 
-	// wait for completion.
-	while (!msg_paths_.empty()) {
-		mu_debug("scan-items left: {}", msg_paths_.size());
-		std::this_thread::sleep_for(250ms);
-	}
+	todos_.clear();
+	if (scanner_worker_.joinable())
+		scanner_worker_.join();
 
+	state_.change_to(IndexState::Idle);
 	for (auto&& w : workers_)
 		if (w.joinable())
 			w.join();
 	workers_.clear();
 
-	store_worker_.push(StoreWorker::EndTransaction());
-
-	// wait for completion.
-	while (!store_worker_.empty()) {
-		mu_debug("work-items left: {}", store_worker_.size());
-		std::this_thread::sleep_for(250ms);
-	}
-
-	switch_state(State::Idle);
-
 	return true;
 }
 
@@ -425,7 +469,7 @@ Indexer::is_running() const
 const Indexer::Progress&
 Indexer::progress() const
 {
-	priv_->progress_.running = priv_->state_ == State::Idle ? false : true;
+	priv_->progress_.running = priv_->state_ == IndexState::Idle ? false : true;
 
 	return priv_->progress_;
 }
diff --git a/lib/mu-server.cc b/lib/mu-server.cc
index e18ae3907..62c9ca0c6 100644
--- a/lib/mu-server.cc
+++ b/lib/mu-server.cc
@@ -1,5 +1,5 @@
 /*
-** Copyright (C) 2020-2024 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2020-2023 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify it
 ** under the terms of the GNU General Public License as published by the
@@ -29,12 +29,9 @@
 #include <atomic>
 #include <thread>
 #include <mutex>
-#include <condition_variable>
 #include <variant>
 #include <functional>
 
-
-
 #include <cstring>
 #include <glib.h>
 #include <glib/gprintf.h>
@@ -119,7 +116,7 @@ struct OutputStream {
 	}
 
 private:
-	std::string fname_;
+	std::string		fname_;
 	using OutType = std::variant<std::ofstream, std::ostringstream>;
 	OutType out_;
 };
@@ -129,21 +126,11 @@ struct OutputStream {
 /// @brief object to manage the server-context for all commands.
 struct Server::Private {
 	Private(Store& store, const Server::Options& opts, Output output)
-	    : store_{store},
-	      store_worker_{store.store_worker()},
-	      options_{opts}, output_{output},
+	    : store_{store}, options_{opts}, output_{output},
 	      command_handler_{make_command_map()},
 	      keep_going_{true},
-	      tmp_dir_{unwrap(make_temp_dir())} {
-
-		// tell the store-worker that we (this class) can handle
-		// sexp strings.
-		store_worker_.install_sexp_handler(
-			[this](const std::string& sexp) {
-				this->invoke(sexp);
-			});
-
-	}
+	      tmp_dir_{unwrap(make_temp_dir())}
+	{}
 
 	~Private() {
 		indexer().stop();
@@ -161,10 +148,13 @@ struct Server::Private {
 	// acccessors
 	Store&            store() { return store_; }
 	const Store&      store() const { return store_; }
-	StoreWorker&      store_worker() { return store_worker_; }
 	Indexer&          indexer() { return store().indexer(); }
 	//CommandMap&       command_map() const { return command_map_; }
 
+	//
+	// invoke
+	//
+	bool invoke(const std::string& expr) noexcept;
 
 	//
 	// output
@@ -196,19 +186,7 @@ struct Server::Private {
 	void remove_handler(const Command& cmd);
 	void view_handler(const Command& cmd);
 
-	bool keep_going() const { return keep_going_; }
-	void set_keep_going(bool going)  { keep_going_ = going; }
-
-	// make main thread wait until done with the command.
-	std::mutex done_lock_;
-	std::condition_variable done_cond_;
-
 private:
-	//
-	// invoke
-	//
-	bool invoke(const std::string& expr) noexcept;
-
 	void move_docid(Store::Id docid, Option<std::string> flagstr,
 			bool new_name, bool no_view);
 
@@ -231,7 +209,6 @@ struct Server::Private {
 	std::ofstream make_temp_file_stream(std::string& fname) const;
 
 	Store&			store_;
-	StoreWorker&            store_worker_;
 	Server::Options         options_;
 	Server::Output		output_;
 	const CommandHandler	command_handler_;
@@ -503,10 +480,6 @@ Server::Private::invoke(const std::string& expr) noexcept
 		keep_going_ = false;
 	}
 
-	// tell main thread we're done with the command.
-	std::lock_guard l{done_lock_};
-	done_cond_.notify_one();
-
 	return keep_going_;
 }
 
@@ -586,9 +559,7 @@ Server::Private::data_handler(const Command& cmd)
 {
 	const auto request_type{unwrap(cmd.symbol_arg(":kind"))};
 
-	if (request_type == "doccount") {
-		output(mu_format("(:doccount {})", store().size()));
-	} else if (request_type == "maildirs") {
+	if (request_type == "maildirs") {
 		auto&& out{make_output_stream()};
 		mu_print(out, "(");
 		for (auto&& mdir: store().maildirs())
@@ -719,6 +690,9 @@ Server::Private::find_handler(const Command& cmd)
 	StopWatch sw{mu_format("{} (indexing: {})", __func__,
 			       indexer().is_running() ? "yes" :  "no")};
 
+	// we need to _lock_ the store while querying (which likely consists of
+	// multiple actual queries) + grabbing the results.
+	std::lock_guard l{store_.lock()};
 	auto qres{store_.run_query(q, sort_field_id, qflags, maxnum)};
 	if (!qres)
 		throw Error(Error::Code::Query, "failed to run query: {}", qres.error().what());
@@ -1107,27 +1081,7 @@ Server::~Server() = default;
 bool
 Server::invoke(const std::string& expr) noexcept
 {
-	/* a _little_ hacky; handle _quit_ directly to properly
-	 * shut down the server */
-	if (expr == "(quit)")  {
-		mu_debug("quitting");
-		priv_->set_keep_going(false);
-		return false;
-	}
-
-	/*
-	 * feed the command to the queue; it'll get executed in the
-	 * store-worker thread; however, sync on its completion
-	 * so we get its keep_going() result
-	 *
-	 * as an added bonus, this ensures mu server shell doesn't require an
-	 * extra user RET to get back the prompt
-	 */
-	std::unique_lock done_lock{priv_->done_lock_};
-	priv_->store_worker().push(StoreWorker::SexpCommand{expr});
-	priv_->done_cond_.wait(done_lock);
-
-	return priv_->keep_going();
+	return priv_->invoke(expr);
 }
 
 /* LCOV_EXCL_STOP */
diff --git a/mu/mu-cmd-server.cc b/mu/mu-cmd-server.cc
index 50c7c010f..3a694566a 100644
--- a/mu/mu-cmd-server.cc
+++ b/mu/mu-cmd-server.cc
@@ -79,12 +79,11 @@ cookie(size_t n)
 		::printf(COOKIE_PRE "%x" COOKIE_POST, num);
 }
 
+
+
 static void
 output_stdout(const std::string& str, Server::OutputFlags flags)
 {
-	// Note: with the StoreWorker, we _always_ need to flush
-	flags |= Server::OutputFlags::Flush;
-
 	cookie(str.size() + 1);
 	if (G_UNLIKELY(::puts(str.c_str()) < 0)) {
 		mu_critical("failed to write output '{}'", str);
diff --git a/mu4e/mu4e-server.el b/mu4e/mu4e-server.el
index 0790501da..fae835148 100644
--- a/mu4e/mu4e-server.el
+++ b/mu4e/mu4e-server.el
@@ -385,10 +385,7 @@ The server output is as follows:
          ((plist-get sexp :info)
           (funcall mu4e-info-func sexp))
 
-         ;; get some data XXX generalize
-         ((plist-get sexp :doccount)
-          (plist-put mu4e--server-props :doccount
-                     (mu4e--server-plist-get sexp :doccount)))
+         ;; get some data
          ((plist-get sexp :maildirs)
           (setq mu4e-maildir-list (mu4e--server-plist-get sexp :maildirs)))
 
@@ -559,16 +556,9 @@ get at most MAX contacts."
 
 (defun mu4e--server-data (kind)
   "Request data of some KIND.
-KIND is a symbol or a list of symbols. Currently supported kinds:
- `maildirs', `doccount'."
-  (pcase kind
-    ((pred (lambda (k) (memq k '(maildirs doccount))))
-     (mu4e--server-call-mu `(data :kind ,kind)))
-    ((pred listp)
-     (when kind
-       (mu4e--server-data (car kind))
-       (mu4e--server-data (cdr kind))))
-    (_ (mu4e-error "Unexpected kind %s" kind))))
+KIND is a symbol. Currently supported kinds: maildirs."
+  (mu4e--server-call-mu
+   `(data :kind ,kind)))
 
 (defun mu4e--server-find (query threads sortfield sortdir maxnum skip-dups
                                 include-related)
diff --git a/mu4e/mu4e-update.el b/mu4e/mu4e-update.el
index 11228fac2..5bb9e1da1 100644
--- a/mu4e/mu4e-update.el
+++ b/mu4e/mu4e-update.el
@@ -130,9 +130,9 @@ changed")
 If non-nil, this is a plist of the form:
 \(
 :checked     <number of messages processed> (checked whether up-to-date)
-:updated     <number of messages updated/added>
-:cleaned-up  <number of stale messages removed from store>
-:stamp       <emacs (current-time) timestamp for the status>")
+:updated     <number of messages updated/added
+:cleaned-up  <number of stale messages removed from store
+:stamp       <emacs (current-time) timestamp for the status)")
 
 (defconst mu4e-last-update-buffer "*mu4e-last-update*"
   "Name of buffer with cloned from the last update buffer.
diff --git a/mu4e/mu4e.el b/mu4e/mu4e.el
index 31d4bf60d..8efc7b68d 100644
--- a/mu4e/mu4e.el
+++ b/mu4e/mu4e.el
@@ -1,6 +1,6 @@
 ;;; mu4e.el --- Mu4e, the mu mail user agent -*- lexical-binding: t -*-
 
-;; Copyright (C) 2011-2024 Dirk-Jan C. Binnema
+;; Copyright (C) 2011-2023 Dirk-Jan C. Binnema
 
 ;; Author: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ;; Maintainer: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
@@ -203,47 +203,42 @@ Otherwise, check requirements, then start mu4e. When successful, invoke
     (_ (mu4e-error "Error %d: %s" errcode errmsg))))
 
 (defun mu4e--update-status (info)
-  "Update `mu4e-index-update-status' with INFO.
-Return the former. As an additional side-effect, updates
-doccount in server-properties."
+  "Update the status message with INFO."
   (setq mu4e-index-update-status
-        `(:tstamp     ,(current-time)
-          :checked    ,(or (plist-get info :checked) 0)
-          :updated    ,(or (plist-get info :updated) 0)
-          :cleaned-up ,(or (plist-get info :cleaned-up) 0)))
-  mu4e-index-update-status)
+        `(:tstamp ,(current-time)
+          :checked ,(plist-get info :checked)
+          :updated  ,(plist-get info :updated)
+          :cleaned-up ,(plist-get info :cleaned-up))))
 
 (defun mu4e--info-handler (info)
   "Handler function for (:INFO ...) sexps received from server."
-  (let* ((type (plist-get info :info)))
+  (let* ((type (plist-get info :info))
+         (checked (plist-get info :checked))
+         (updated (plist-get info :updated))
+         (cleaned-up (plist-get info :cleaned-up)))
     (cond
      ((eq type 'add) t) ;; do nothing
      ((eq type 'index)
-      (let* ((info (mu4e--update-status info))
-             (checked (plist-get info :checked))
-             (updated (plist-get info :updated))
-             (cleaned-up (plist-get  info :cleaned-up)))
-        (if (eq (plist-get info :status) 'running)
-            (mu4e-index-message
-             "Indexing... checked %d, updated %d"
-             checked updated)
-          (progn ;; i.e. 'complete
-            (mu4e-index-message
-             "%s completed; checked %d, updated %d, cleaned-up %d"
-             (if mu4e-index-lazy-check "Lazy indexing" "Indexing")
-             checked updated cleaned-up)
-            ;; index done; grab updated queries
-            (mu4e--query-items-refresh)
-            (run-hooks 'mu4e-index-updated-hook)
-            ;; backward compatibility...
-            (unless (zerop (+ updated cleaned-up))
-              mu4e-message-changed-hook)
-            (unless (and (not (string= mu4e--contacts-tstamp "0"))
-                         (zerop (plist-get info :updated)))
-              (mu4e--request-contacts-maybe)
-              (mu4e--server-data '(maildirs doccount)))
-            ;; update maildir list & doccount
-            (mu4e--main-redraw)))))
+      (if (eq (plist-get info :status) 'running)
+          (mu4e-index-message
+           "Indexing... checked %d, updated %d" checked updated)
+        (progn ;; i.e. 'complete
+          (mu4e--update-status info)
+          (mu4e-index-message
+           "%s completed; checked %d, updated %d, cleaned-up %d"
+           (if mu4e-index-lazy-check "Lazy indexing" "Indexing")
+           checked updated cleaned-up)
+          ;; index done; grab updated queries
+          (mu4e--query-items-refresh)
+          (run-hooks 'mu4e-index-updated-hook)
+          ;; backward compatibility...
+          (unless (zerop (+ updated cleaned-up))
+            mu4e-message-changed-hook)
+          (unless (and (not (string= mu4e--contacts-tstamp "0"))
+                       (zerop (plist-get info :updated)))
+            (mu4e--request-contacts-maybe)
+            (mu4e--server-data 'maildirs)) ;; update maildir list
+          (mu4e--main-redraw))))
      ((plist-get info :message)
       (mu4e-index-message "%s" (plist-get info :message))))))
 

From e6fd83d00d9b73a9cdcc48f40698d3b4003531ad Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Thu, 13 Jun 2024 20:24:03 +0300
Subject: [PATCH 049/305] logging: reduce debug logging a bit

---
 lib/message/mu-message.cc | 4 +---
 lib/mu-contacts-cache.cc  | 7 ++++---
 lib/mu-maildir.cc         | 3 ---
 3 files changed, 5 insertions(+), 9 deletions(-)

diff --git a/lib/message/mu-message.cc b/lib/message/mu-message.cc
index ee692b4ee..46063cfe5 100644
--- a/lib/message/mu-message.cc
+++ b/lib/message/mu-message.cc
@@ -563,9 +563,7 @@ process_message(const MimeMessage& mime_msg, const std::string& path,
 	if (info.body_txt) { /* attempt to get the body-language */
 		if (const auto lang{detect_language(info.body_txt.value())}; lang) {
 			info.language = lang->code;
-			mu_debug("detected language: {}", lang->code);
-		} else
-			mu_debug("could not detect language");
+		}
 	}
 #endif /*HAVE_CLD2*/
 }
diff --git a/lib/mu-contacts-cache.cc b/lib/mu-contacts-cache.cc
index b9b9b50f1..eaa5b1faf 100644
--- a/lib/mu-contacts-cache.cc
+++ b/lib/mu-contacts-cache.cc
@@ -194,10 +194,11 @@ ContactsCache::serialize() const
 void
 ContactsCache::add(Contact&& contact)
 {
-	/* we do _not_ cache invalid email addresses, so we won't offer them in completions etc. It
-	 * should be _rare_, but we've seen cases ( broken local messages) */
+	/* we do _not_ cache invalid email addresses, so we won't offer them in
+	 * completions etc. It should be _rare_, but we've seen cases ( broken
+	 * local messages, and various "fake" messages RSS2Imap etc. */
 	if (!is_valid(contact.email)) {
-		mu_warning("not caching invalid e-mail address '{}'", contact.email);
+		mu_debug("not caching invalid e-mail address '{}'", contact.email);
 		return;
 	}
 
diff --git a/lib/mu-maildir.cc b/lib/mu-maildir.cc
index 5166b17ed..5eef69e5e 100644
--- a/lib/mu-maildir.cc
+++ b/lib/mu-maildir.cc
@@ -264,8 +264,6 @@ msg_move_verify(const std::string& src, const std::string& dst)
 		mu_debug("source is still there ({}->{})", src, dst);
 	}
 
-	mu_debug("moved {} -> {}", src, dst);
-
 	return Ok();
 }
 /* LCOV_EXCL_STOP*/
@@ -430,7 +428,6 @@ Mu::maildir_determine_target(const std::string&	old_path,
 	if (const auto checked{check_determine_target_params(
 		old_path, root_maildir_path, target_maildir, newflags)}; !checked)
 		return Err(Error{std::move(checked.error())});
-
 	/*
 	 * this gets us the source maildir filesystem path, the directory
 	 * in which new/ & cur/ lives, and the source file

From 67ea98e36ec61cee05a3465b0af4cc992eaf851f Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Mon, 17 Jun 2024 22:00:03 +0300
Subject: [PATCH 050/305] mu4e-draft: fix mu4e-compose-pre-hook

Run the hook earlier, and ensure mu4e-compose-type &
mu4e-compose-parent-message are set.

As noted in #2715.
---
 mu4e/mu4e-draft.el | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/mu4e/mu4e-draft.el b/mu4e/mu4e-draft.el
index 12834580c..ed867a906 100644
--- a/mu4e/mu4e-draft.el
+++ b/mu4e/mu4e-draft.el
@@ -560,8 +560,7 @@ This is mu4e's version of `message-hidden-headers'.")
   "Get ready for message composition.
 PARENT is the parent message, if any."
   (unless (mu4e-running-p) (mu4e 'background)) ;; start if needed
-  (mu4e--context-autoswitch parent mu4e-compose-context-policy)
-  (run-hooks 'mu4e-compose-pre-hook))
+  (mu4e--context-autoswitch parent mu4e-compose-context-policy))
 
 (defun mu4e--prepare-draft-headers (compose-type)
   "Add extra headers for message based on COMPOSE-TYPE."
@@ -709,6 +708,11 @@ it must be nil.
 After this, user is presented with a message composition buffer.
 
 Returns the new buffer."
+  ;; run pre-hook early, so user can influence later steps.
+  (let ((mu4e-compose-parent-message parent)
+        (mu4e-compose-type compose-type))
+    (run-hooks 'mu4e-compose-pre-hook))
+
   (mu4e--prepare-draft parent)
   ;; evaluate BODY; this must yield a hidden, live buffer. This is evaluated in
   ;; a temp buffer with contains the parent-message, if any. if there's a

From a37f4a3f6c18a5e7ae75c0e3d957c3b4228e6519 Mon Sep 17 00:00:00 2001
From: Henrique Pereira <72633098+hgp22@users.noreply.github.com>
Date: Thu, 27 Jun 2024 16:38:47 +0100
Subject: [PATCH 051/305] fix: readme clone through ssh

---
 README.org | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.org b/README.org
index ec5c648ce..cdcf5edd8 100644
--- a/README.org
+++ b/README.org
@@ -76,7 +76,7 @@ Help is welcome!
 ** Building
 
 #+begin_example
-$ git clone git://github.com/djcb/mu.git
+$ git clone git@github.com:djcb/mu.git
 $ cd mu
 #+end_example
 

From a5a58975df39c2398c7ebfd5489a870db68113e9 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Thu, 27 Jun 2024 22:53:01 +0300
Subject: [PATCH 052/305] mu4e-view.el: set bookmark-make-record-function later

Otherwise, seems it's overridden. Fixes #2718.
---
 mu4e/mu4e-view.el | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/mu4e/mu4e-view.el b/mu4e/mu4e-view.el
index 033540aa3..c656ce0f2 100644
--- a/mu4e/mu4e-view.el
+++ b/mu4e/mu4e-view.el
@@ -658,6 +658,9 @@ As a side-effect, a message that is being viewed loses its
   (with-current-buffer gnus-article-buffer
     (let ((inhibit-read-only t))
       (run-hooks 'mu4e-view-rendered-hook))
+    ;; support bookmarks.
+    (setq-local bookmark-make-record-function
+                #'mu4e--make-bookmark-record)
     ;; only needed on some setups; #2683
     (goto-char (point-min))))
 
@@ -1074,10 +1077,6 @@ Based on Gnus' article-mode."
   (mu4e-compose-minor-mode)
   (setq buffer-undo-list t) ;; don't record undo info
 
-  ;; support bookmarks.
-  (set (make-local-variable 'bookmark-make-record-function)
-       'mu4e--make-bookmark-record)
-
   ;; autopair mode gives error when pressing RET
   ;; turn it off
   (when (boundp 'autopair-dont-activate)

From c5ff7abbb1eb159699de3cba8e5ae5ba1dd04ed8 Mon Sep 17 00:00:00 2001
From: Tristan Riehs <tristan.riehs@bordeaux-inp.fr>
Date: Fri, 28 Jun 2024 10:47:05 +0900
Subject: [PATCH 053/305] Add a missing verb

---
 mu4e/mu4e.texi | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index 7100c3ce7..72f303d6f 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -789,7 +789,7 @@ changes indeed. So it is mostly useful for tracking changes while you are
 @emph{not} using @t{mu4e}. For this reason, you can reset the baseline manually,
 e.g. by visiting the main view .
 
-By comparing current results with the baseline, you can quickly what new
+By comparing current results with the baseline, you can quickly see what new
 messages have arrived since the last time you looked.
 
 The baseline@footnote{For debugging, it can be useful to see the time for the

From f1132ec7d24f9070c8fac2f011b3289ed5461b81 Mon Sep 17 00:00:00 2001
From: Tristan Riehs <tristan.riehs@bordeaux-inp.fr>
Date: Fri, 28 Jun 2024 10:48:57 +0900
Subject: [PATCH 054/305] Correct period misplacement

---
 mu4e/mu4e.texi | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index 72f303d6f..911e6318b 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -793,7 +793,7 @@ By comparing current results with the baseline, you can quickly see what new
 messages have arrived since the last time you looked.
 
 The baseline@footnote{For debugging, it can be useful to see the time for the
-baseline - for that, there is the @code{mu4e-baseline-time} command} . is reset
+baseline - for that, there is the @code{mu4e-baseline-time} command.} is reset
 automatically when switching to the main view, or invoking @code{buffer-revert}
 (@kbd{g}) while in the main-view. Visiting the ``favorite'' bookmark does the
 same(explained below).

From 05eacd84d80166c462621d568bf9e2960580d481 Mon Sep 17 00:00:00 2001
From: Henrique Pereira <72633098+hgp22@users.noreply.github.com>
Date: Sun, 30 Jun 2024 20:00:30 +0100
Subject: [PATCH 055/305] Update README.org

---
 README.org | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.org b/README.org
index cdcf5edd8..3adafbf13 100644
--- a/README.org
+++ b/README.org
@@ -76,7 +76,7 @@ Help is welcome!
 ** Building
 
 #+begin_example
-$ git clone git@github.com:djcb/mu.git
+$ git clone https://github.com/djcb/mu.git
 $ cd mu
 #+end_example
 

From a23fc80e379eccfc3db198cf077689fbaa6c48f1 Mon Sep 17 00:00:00 2001
From: Tristan Riehs <tristan.riehs@bordeaux-inp.fr>
Date: Tue, 16 Jul 2024 11:01:54 +0900
Subject: [PATCH 056/305] mu-1: add missing word

---
 man/mu.1.org | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/man/mu.1.org b/man/mu.1.org
index 026fd3296..2aff85aef 100644
--- a/man/mu.1.org
+++ b/man/mu.1.org
@@ -14,7 +14,7 @@ For information about the common options, see *COMMON OPTIONS*.
 
 * DESCRIPTION
 
-~mu~ is the general command shows help about the specific commands:
+~mu~ is the general command that shows help about the specific commands:
 
 - ~add~:  add specific messages to the database.
 - ~cfind~: find contacts

From a9872fc536d20002333682110c6068b7a4ac44d0 Mon Sep 17 00:00:00 2001
From: Tristan Riehs <tristan.riehs@bordeaux-inp.fr>
Date: Tue, 16 Jul 2024 11:02:25 +0900
Subject: [PATCH 057/305] mu-1: remove extra '~'

---
 man/mu.1.org | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/man/mu.1.org b/man/mu.1.org
index 2aff85aef..a7c05f046 100644
--- a/man/mu.1.org
+++ b/man/mu.1.org
@@ -29,7 +29,7 @@ For information about the common options, see *COMMON OPTIONS*.
 - ~server~: start a server process (for ~mu4e~-internal use)
 - ~view~: view a specific message
 
-Each of the commands have their own manpage ~mu-<command~>~.
+Each of the commands have their own manpage ~mu-<command>~.
 
 ~mu~ is a set of tools for dealing with Maildirs and the e-mail messages
 in them.

From f66a4a37f555b0e0b8b99f4423fd3b3be26e9bf2 Mon Sep 17 00:00:00 2001
From: Tristan Riehs <tristan.riehs@bordeaux-inp.fr>
Date: Tue, 16 Jul 2024 11:44:17 +0900
Subject: [PATCH 058/305] mu-1: slightly improve syntax

---
 man/mu.1.org | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/man/mu.1.org b/man/mu.1.org
index a7c05f046..d3f0335be 100644
--- a/man/mu.1.org
+++ b/man/mu.1.org
@@ -74,7 +74,7 @@ the output is always UTF-8, regardless of the locale:
 
 * DATABASE AND FILE
 
-Commands ~mu index~ and ~find~ and ~cfind~ work with the database, while the other
+The ~index~, ~find~, and ~cfind~ commands work with the database, while the other
 ones work on individual mail files. Hence, running ~view~, ~mkdir~ and ~extract~ does
 not require the mu database.
 

From 2864039e60e45d640f7ec85f47273618ccddafc1 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 16 Jul 2024 06:39:57 +0300
Subject: [PATCH 059/305] mu4e-modeline: fix some typos

---
 mu4e/mu4e-modeline.el | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/mu4e/mu4e-modeline.el b/mu4e/mu4e-modeline.el
index f1e668d33..a28664386 100644
--- a/mu4e/mu4e-modeline.el
+++ b/mu4e/mu4e-modeline.el
@@ -1,6 +1,6 @@
 ;;; mu4e-modeline.el --- Modeline for mu4e  -*- lexical-binding: t -*-
 
-;; Copyright (C) 2023 Dirk-Jan C. Binnema
+;; Copyright (C) 2023-2024 Dirk-Jan C. Binnema
 
 ;; Author: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ;; Maintainer: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
@@ -34,9 +34,9 @@
   "Determines the maximum length of the local modeline string.
 If the string exceeds this limit, it will be truncated to fit.
 
-Note: this only affects the local modeline items (such as the context,
-the search properties and the last query), not the global items
-(such as the favorite bookmark results)."
+Note: this only affects the local modeline items (such as the
+context, the search properties and the last query), not the
+global items (such as the favorite bookmark results)."
   :type 'integer
   :group 'mu4e-modeline)
 
@@ -76,7 +76,7 @@ the buffer-local one."
 
 (defun mu4e--modeline-quote-and-truncate (str)
   "Quote STR to be used literally in the modeline.
-The string is truncaed to fit if its length exceeds
+The string is truncated to fit if its length exceeds
 `mu4e-modeline-max-width'."
   (replace-regexp-in-string
    "%" "%%"

From 0402a1c6926235e96b7f56ced032c56051201647 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 16 Jul 2024 06:40:10 +0300
Subject: [PATCH 060/305] README.org: fix meson command example

Fixes #2725
---
 README.org | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.org b/README.org
index ec5c648ce..5aec4c6ae 100644
--- a/README.org
+++ b/README.org
@@ -94,7 +94,7 @@ $ sudo make install
 Alternatively, you can run ~meson~ directly (see the ~meson~ documentation for
 more details):
 #+begin_example
-$ meson setup -C build
+$ meson setup build
 $ meson compile -C build
 $ meson install -C build
 #+end_example

From fab36e283a787963458a48f03262ee19c465c464 Mon Sep 17 00:00:00 2001
From: Tristan Riehs <tristan.riehs@bordeaux-inp.fr>
Date: Tue, 16 Jul 2024 14:11:50 +0900
Subject: [PATCH 061/305] common-options: capitalize first sentences

---
 man/common-options.inc | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/man/common-options.inc b/man/common-options.inc
index ec83e3fdb..556a9cc5c 100644
--- a/man/common-options.inc
+++ b/man/common-options.inc
@@ -1,30 +1,30 @@
 * COMMON OPTIONS
 
 ** -d, --debug
-makes mu generate extra debug information, useful for debugging the program
-itself. By default, debug information goes to the log file, ~/.cache/mu/mu.log.
-It can safely be deleted when mu is not running. When running with --debug
+Makes mu generate extra debug information, useful for debugging the program
+itself. By default, debug information goes to the log file, _~/.cache/mu/mu.log_.
+It can safely be deleted when mu is not running. When running with *--debug*
 option, the log file can grow rather quickly. See the note on logging below.
 
 ** -q, --quiet
-causes mu not to output informational messages and progress information to
+Causes mu not to output informational messages and progress information to
 standard output, but only to the log file. Error messages will still be sent to
-standard error. Note that mu index is much faster with --quiet, so it is
+standard error. Note that *mu index* is much faster with *--quiet*, so it is
 recommended you use this option when using mu from scripts etc.
 
 ** --log-stderr
-causes mu to not output log messages to standard error, in addition to sending
+Causes mu to not output log messages to standard error, in addition to sending
 them to the log file.
 
 ** --nocolor
-do not use ANSI colors. The environment variable ~NO_COLOR~ can be used as an
-alternative to ~--nocolor~.
+Do not use ANSI colors. The environment variable *NO_COLOR* can be used as an
+alternative to *--nocolor*.
 
 ** -V, --version
-prints mu version and copyright information.
+Prints *mu* version and copyright information.
 
 ** -h, --help
-lists the various command line options.
+Lists the various command line options.
 
 # Local Variables:
 # mode: org

From f1a2153578f17aa6e2bad9c07b745ba569a1da38 Mon Sep 17 00:00:00 2001
From: Tristan Riehs <tristan.riehs@bordeaux-inp.fr>
Date: Wed, 17 Jul 2024 23:51:39 +0900
Subject: [PATCH 062/305] mu-man: improve typesetting of synopses

---
 man/mu-add.1.org     | 2 +-
 man/mu-cfind.1.org   | 2 +-
 man/mu-extract.1.org | 4 ++--
 man/mu-find.1.org    | 2 +-
 man/mu-help.1.org    | 2 +-
 man/mu-index.1.org   | 2 +-
 man/mu-info.1.org    | 2 +-
 man/mu-init.1.org    | 2 +-
 man/mu-mkdir.1.org   | 2 +-
 man/mu-move.1.org    | 2 +-
 man/mu-remove.1.org  | 2 +-
 man/mu-server.1.org  | 2 +-
 man/mu-verify.1.org  | 2 +-
 man/mu-view.1.org    | 2 +-
 man/mu.1.org         | 2 +-
 15 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/man/mu-add.1.org b/man/mu-add.1.org
index f2b644cb2..1e099d370 100644
--- a/man/mu-add.1.org
+++ b/man/mu-add.1.org
@@ -7,7 +7,7 @@ mu-add - add one or more messages to the database
 
 * SYNOPSIS
 
-*mu [common-options] add [options] <file> [<files>]*
+*mu* [​_COMMON-OPTIONS_​] *add* [​_OPTIONS_​] _FILE_...
 
 * DESCRIPTION
 
diff --git a/man/mu-cfind.1.org b/man/mu-cfind.1.org
index 0c14dc6b6..1db984bdb 100644
--- a/man/mu-cfind.1.org
+++ b/man/mu-cfind.1.org
@@ -8,7 +8,7 @@ for use in other programs.
 
 * SYNOPSIS
 
-*mu [common-options] cfind [options] [<pattern>]*
+*mu* [​_COMMON-OPTIONS_​] *cfind* [​_OPTIONS_​] [​_PATTERN_​]
 
 * DESCRIPTION
 
diff --git a/man/mu-extract.1.org b/man/mu-extract.1.org
index 596a66378..c80ae5351 100644
--- a/man/mu-extract.1.org
+++ b/man/mu-extract.1.org
@@ -8,9 +8,9 @@ mu-extract - display and save message parts
 
 * SYNOPSIS
 
-*mu [common-options] extract [options] [<file>]*
+*mu* [​_COMMON-OPTIONS_​] *extract* [​_OPTIONS_​] [​_FILE_​]
 
-*mu [common-options] extract [options] <file> <pattern>*
+*mu* [​_COMMON-OPTIONS_​] *extract* [​_OPTIONS_​] _FILE_ _PATTERN_
 
 * DESCRIPTION
 
diff --git a/man/mu-find.1.org b/man/mu-find.1.org
index a8fc9fee8..ec171419c 100644
--- a/man/mu-find.1.org
+++ b/man/mu-find.1.org
@@ -7,7 +7,7 @@ mu-find - find e-mail messages in the *mu* database.
 
 * SYNOPSIS
 
-*mu [common-options] find [options] <search expression>*
+*mu* [​_COMMON-OPTIONS_​] *find* [​_OPTIONS_​] _SEARCH_EXPRESSION_
 
 * DESCRIPTION
 
diff --git a/man/mu-help.1.org b/man/mu-help.1.org
index 2a67dc2e6..0b5e71961 100644
--- a/man/mu-help.1.org
+++ b/man/mu-help.1.org
@@ -7,7 +7,7 @@ mu-help - show help information about mu commands.
 
 * SYNOPSIS
 
-*mu [common-options] help [<command>]*
+*mu* [​_COMMON-OPTIONS_​] *help* [​_COMMAND_​]
 
 * DESCRIPTION
 
diff --git a/man/mu-index.1.org b/man/mu-index.1.org
index 80452e072..026607b51 100644
--- a/man/mu-index.1.org
+++ b/man/mu-index.1.org
@@ -7,7 +7,7 @@ mu-index - index e-mail messages stored in Maildirs
 
 * SYNOPSIS
 
-*mu [common-options] index*
+*mu* [​_COMMON-OPTIONS_​] *index*
 
 * DESCRIPTION
 
diff --git a/man/mu-info.1.org b/man/mu-info.1.org
index 0d182d7c8..3879f2264 100644
--- a/man/mu-info.1.org
+++ b/man/mu-info.1.org
@@ -7,7 +7,7 @@ mu-info  - show information
 
 * SYNOPSIS
 
-*mu [common options] info [<topic>]*
+*mu* [​_COMMON OPTIONS_​] *info* [​_TOPIC_​]
 
 * DESCRIPTION
 
diff --git a/man/mu-init.1.org b/man/mu-init.1.org
index 6c3d4c946..2c8fefb83 100644
--- a/man/mu-init.1.org
+++ b/man/mu-init.1.org
@@ -7,7 +7,7 @@ mu-init - initialize the mu message database
 
 * SYNOPSIS
 
-*mu [common-options] init [options]*
+*mu* [​_COMMON-OPTIONS_​] *init* [​_OPTIONS_​]
 
 * DESCRIPTION
 
diff --git a/man/mu-mkdir.1.org b/man/mu-mkdir.1.org
index f10a71498..619759130 100644
--- a/man/mu-mkdir.1.org
+++ b/man/mu-mkdir.1.org
@@ -7,7 +7,7 @@ mu-mkdir - create a new Maildir
 
 * SYNOPSIS
 
-*mu [common-options] mkdir [options] <dir> [<dirs>]*
+*mu* [​_COMMON-OPTIONS_​] *mkdir* [​_OPTIONS_​] _DIR_...
 
 * DESCRIPTION
 
diff --git a/man/mu-move.1.org b/man/mu-move.1.org
index d43a3faa0..f8132e70d 100644
--- a/man/mu-move.1.org
+++ b/man/mu-move.1.org
@@ -7,7 +7,7 @@ mu-move - move a message file or change its flags
 
 * SYNOPSIS
 
-*mu [common-options] move [options] <src> [--flags=<flags>] [<target>]*
+*mu* [​_COMMON-OPTIONS_​] *move* [​_OPTIONS_​] _SRC_ [--flags=​_FLAGS_​] [​_TARGET_​]
 
 * DESCRIPTION
 
diff --git a/man/mu-remove.1.org b/man/mu-remove.1.org
index ff2c24c02..070e1cb02 100644
--- a/man/mu-remove.1.org
+++ b/man/mu-remove.1.org
@@ -7,7 +7,7 @@ mu-remove - remove messages from the database.
 
 * SYNOPSIS
 
-*mu [common-options] remove [options] <file> [<files>]*
+*mu* [​_COMMON-OPTIONS_​] *remove* [​_OPTIONS_​] _FILE_...
 
 * DESCRIPTION
 
diff --git a/man/mu-server.1.org b/man/mu-server.1.org
index 181486051..c0c8186f9 100644
--- a/man/mu-server.1.org
+++ b/man/mu-server.1.org
@@ -7,7 +7,7 @@ mu-server - the mu backend for the mu4e e-mail client
 
 * SYNOPSIS
 
-mu [common-options] server
+*mu* [​_COMMON-OPTIONS_​] *server*
 
 * DESCRIPTION
 
diff --git a/man/mu-verify.1.org b/man/mu-verify.1.org
index 9cc0933d2..c9bd0aaaf 100644
--- a/man/mu-verify.1.org
+++ b/man/mu-verify.1.org
@@ -7,7 +7,7 @@ mu-verify - verify message signatures and display information about them
 
 * SYNOPSIS
 
-*mu [common-options] verify [options] [<file> ... ]*
+*mu* [​_COMMON-OPTIONS_​] *verify* [​_OPTIONS_​] [​_FILE_...]
 
 * DESCRIPTION
 
diff --git a/man/mu-view.1.org b/man/mu-view.1.org
index 17351f74e..bec868b86 100644
--- a/man/mu-view.1.org
+++ b/man/mu-view.1.org
@@ -7,7 +7,7 @@ mu-view - display an e-mail message file
 
 * SYNOPSIS
 
-mu [common options] view [options] [<file> ...]
+*mu* [​_COMMON OPTIONS_​] *view* [​_OPTIONS_​] [​_FILE_...]
 
 * DESCRIPTION
 
diff --git a/man/mu.1.org b/man/mu.1.org
index d3f0335be..e1cb73d94 100644
--- a/man/mu.1.org
+++ b/man/mu.1.org
@@ -8,7 +8,7 @@ index and search e-mail messages.
 
 * SYNOPSIS
 
-~mu~ [COMMON-OPTIONS] [[COMMAND] [COMMAND-OPTIONS]]
+*mu* [​_COMMON-OPTIONS_​] [[​_COMMAND_​] [​_COMMAND-OPTIONS_​]]
 
 For information about the common options, see *COMMON OPTIONS*.
 

From 96f8729cb553273ef3d28f57b2af4b13cabc6e47 Mon Sep 17 00:00:00 2001
From: Tristan Riehs <tristan.riehs@bordeaux-inp.fr>
Date: Thu, 18 Jul 2024 10:01:45 +0900
Subject: [PATCH 063/305] mu-man: use more bold text

Make occurences of "mu", small commands such as "mu init", and
command-line arguments bold.
---
 man/common-options.inc | 10 +++----
 man/copyright.inc.in   |  2 +-
 man/exit-code.inc      |  4 +--
 man/mu-add.1.org       |  2 +-
 man/mu-bookmarks.5.org |  6 ++--
 man/mu-cfind.1.org     |  4 +--
 man/mu-easy.7.org      |  8 +++---
 man/mu-extract.1.org   |  8 +++---
 man/mu-find.1.org      | 18 ++++++------
 man/mu-help.1.org      |  2 +-
 man/mu-index.1.org     |  6 ++--
 man/mu-info.1.org      |  6 ++--
 man/mu-init.1.org      |  8 +++---
 man/mu-mkdir.1.org     |  2 +-
 man/mu-move.1.org      | 12 ++++----
 man/mu-query.7.org     | 14 ++++-----
 man/mu-server.1.org    |  8 +++---
 man/mu-view.1.org      |  6 ++--
 man/mu.1.org           | 64 +++++++++++++++++++++---------------------
 man/muhome.inc         |  6 ++--
 20 files changed, 98 insertions(+), 98 deletions(-)

diff --git a/man/common-options.inc b/man/common-options.inc
index 556a9cc5c..15b4c5125 100644
--- a/man/common-options.inc
+++ b/man/common-options.inc
@@ -1,19 +1,19 @@
 * COMMON OPTIONS
 
 ** -d, --debug
-Makes mu generate extra debug information, useful for debugging the program
+Makes *mu* generate extra debug information, useful for debugging the program
 itself. By default, debug information goes to the log file, _~/.cache/mu/mu.log_.
-It can safely be deleted when mu is not running. When running with *--debug*
+It can safely be deleted when *mu* is not running. When running with *--debug*
 option, the log file can grow rather quickly. See the note on logging below.
 
 ** -q, --quiet
-Causes mu not to output informational messages and progress information to
+Causes *mu* not to output informational messages and progress information to
 standard output, but only to the log file. Error messages will still be sent to
 standard error. Note that *mu index* is much faster with *--quiet*, so it is
-recommended you use this option when using mu from scripts etc.
+recommended you use this option when using *mu* from scripts etc.
 
 ** --log-stderr
-Causes mu to not output log messages to standard error, in addition to sending
+Causes *mu* to not output log messages to standard error, in addition to sending
 them to the log file.
 
 ** --nocolor
diff --git a/man/copyright.inc.in b/man/copyright.inc.in
index 2e0267073..d18ea89fd 100644
--- a/man/copyright.inc.in
+++ b/man/copyright.inc.in
@@ -1,6 +1,6 @@
 * COPYRIGHT
 
-This manpage is part of ~mu~ @VERSION@.
+This manpage is part of *mu* @VERSION@.
 
 Copyright © 2008-@YEAR@ Dirk-Jan C. Binnema. License GPLv3+: GNU GPL version 3
 or later <https://gnu.org/licenses/gpl.html>. This is free software: you are
diff --git a/man/exit-code.inc b/man/exit-code.inc
index 07c813839..948085cae 100644
--- a/man/exit-code.inc
+++ b/man/exit-code.inc
@@ -5,8 +5,8 @@ otherwise.
 
     0. success
     2. no matches found. Try a different query
-   11. database schema mismatch. You need to re-initialize ~mu~, see *mu-init(1)*
-   19. failed to acquire lock. Some other program has exclusive access to the mu database
+   11. database schema mismatch. You need to re-initialize *mu*, see *mu-init(1)*
+   19. failed to acquire lock. Some other program has exclusive access to the *mu* database
    99. caught an exception
 
 # Local Variables:
diff --git a/man/mu-add.1.org b/man/mu-add.1.org
index 1e099d370..8b0762bb8 100644
--- a/man/mu-add.1.org
+++ b/man/mu-add.1.org
@@ -11,7 +11,7 @@ mu-add - add one or more messages to the database
 
 * DESCRIPTION
 
-~mu add~ is the command to add specific message files to the database. Each file
+*mu add* is the command to add specific message files to the database. Each file
 must be specified with an absolute path.
 
 * ADD OPTIONS
diff --git a/man/mu-bookmarks.5.org b/man/mu-bookmarks.5.org
index b7d275e04..4ea372ae0 100644
--- a/man/mu-bookmarks.5.org
+++ b/man/mu-bookmarks.5.org
@@ -3,16 +3,16 @@
 
 * NAME
 
-mu-bookmarks - file with bookmarks (shortcuts) for mu search expressions
+mu-bookmarks - file with bookmarks (shortcuts) for *mu* search expressions
 
 * DESCRIPTION
 
 Bookmarks are named shortcuts for search queries. They allow using a convenient
 name for often-used queries. The bookmarks are also visible as shortcuts in the
-mu experimental user interfaces, =mug= and =mug2=.
+*mu* experimental user interfaces, =mug= and =mug2=.
 
 The bookmarks file is read from =<muhome>/bookmarks=. On Unix this would typically
-be w be =~/.config/mu/bookmarks=, but this can be influenced using the ~--muhome~
+be w be =~/.config/mu/bookmarks=, but this can be influenced using the *--muhome*
 parameter for *mu-find(1)*.
 
 The bookmarks file is a typical key=value *.ini*-file, which is best shown by
diff --git a/man/mu-cfind.1.org b/man/mu-cfind.1.org
index 1db984bdb..1ea6768e9 100644
--- a/man/mu-cfind.1.org
+++ b/man/mu-cfind.1.org
@@ -69,7 +69,7 @@ should only apply to name fields.
 
 ** --personal,-p only show addresses seen in messages where one of `my' e-mail
 addresses was seen in one of the address fields; this is to exclude addresses
-only seen in mailing-list messages. See the ~--my-address~ parameter to *mu init*.
+only seen in mailing-list messages. See the *--my-address* parameter to *mu init*.
 
 ** --after=<timestamp> only show addresses last seen after
 =<timestamp>=. =<timestamp>= is a UNIX *time_t* value, the number of
@@ -87,7 +87,7 @@ example, only consider addresses last seen after 2020-06-01, you could specify
 
 * JSON FORMAT
 
-With ~--format=json~, the matching contacts come out as a JSON array, e.g.,
+With *--format=json*, the matching contacts come out as a JSON array, e.g.,
 #+begin_example
 [
   {
diff --git a/man/mu-easy.7.org b/man/mu-easy.7.org
index 662a31494..8d7b66598 100644
--- a/man/mu-easy.7.org
+++ b/man/mu-easy.7.org
@@ -3,7 +3,7 @@
 
 * NAME
 
-mu-easy - a quick introduction to mu
+mu-easy - a quick introduction to *mu*
 
 * DESCRIPTION
 
@@ -27,7 +27,7 @@ non-empty.
 
 * SETTING THINGS UP
 
-The first time you run the mu commands, you need to initialize it. This is done
+The first time you run the *mu* commands, you need to initialize it. This is done
 with the *init* command.
 
 #+begin_example
@@ -145,7 +145,7 @@ messages in a maildir called ~'/archive'~.
 * MORE QUERIES
 
 Let's list a few more queries that may be interesting; please note that
-searches for message flags, priority and date ranges are only available in mu
+searches for message flags, priority and date ranges are only available in *mu*
 version 0.9 or later.
 
 Get all important messages which are signed:
@@ -180,7 +180,7 @@ which is equivalent to:
 #+begin_example
   *$ mu find subject:angstrom flag:unread*
 #+end_example
-because does mu is case-insensitive and accent-insensitive.
+because does *mu* is case-insensitive and accent-insensitive.
 
 Get all unread messages between March 2002 and August 2003 about some bird (or
 a Swedish rock band):
diff --git a/man/mu-extract.1.org b/man/mu-extract.1.org
index c80ae5351..571c49705 100644
--- a/man/mu-extract.1.org
+++ b/man/mu-extract.1.org
@@ -30,9 +30,9 @@ Without any options, *mu extract* simply outputs the list of leaf MIME-parts in
 the message. Only `leaf' MIME-parts (including RFC822 attachments) are
 considered, *multipart/** etc. are ignored.
 
-Without a filename parameter, ~mu extract~ reads a message from standard-input. In
+Without a filename parameter, *mu extract* reads a message from standard-input. In
 that case, you cannot use the second, ~<pattern>~ parameter as this would be
-ambiguous; instead, use the ~--matches~ option.
+ambiguous; instead, use the *--matches* option.
 
 * EXTRACT OPTIONS
 
@@ -56,7 +56,7 @@ overwrite existing files with the same name; by default overwriting is not
 allowed.
 
 ** -u,--uncooked
-by default, ~mu~ transforms the attachment filenames a bit (such as by replacing
+by default, *mu* transforms the attachment filenames a bit (such as by replacing
 spaces by dashes); with this option, leave that to the minimum for creating
 a legal filename in the target directory.
 
@@ -96,7 +96,7 @@ To extract an mp3-file, and play it in the default mp3-playing application:
 $ mu extract --play msgfile 'whoopsididitagain.mp3'
 #+end_example
 
-when reading from standard-input, you need ~--matches~, so:
+when reading from standard-input, you need *--matches*, so:
 #+begin_example
 $ cat msgfile | mu extract --play --matches 'whoopsididitagain.mp3'
 #+end_example
diff --git a/man/mu-find.1.org b/man/mu-find.1.org
index ec171419c..eae040473 100644
--- a/man/mu-find.1.org
+++ b/man/mu-find.1.org
@@ -45,11 +45,11 @@ For details on the possible queries, see *mu-query(7)*.
 * FIND OPTIONS
 
 Note, some of the important options are described in the *mu*(1) man-page
-and not here, as they apply to multiple mu-commands.
+and not here, as they apply to multiple *mu* commands.
 
 The *find*-command has various options that influence the way *mu* displays the
-results. If you don't specify anything, the defaults are ~fields="d f s"~,
-~--sortfield=date~ and ~--reverse~.
+results. If you don't specify anything, the defaults are *--fields="d f s"*,
+*--sortfield=date* and *--reverse*.
 
 ** -f, --fields=<fields>
 specifies a string that determines which fields are shown in the output. This
@@ -79,7 +79,7 @@ parameters, such as:
 	m       *m*aildir
 #+end_example
 
-For the complete list, try the command: ~mu info fields~.
+For the complete list, try the command: *mu info fields*.
 
 The message flags are described in *mu-query(7)*. As an example, a message which
 is `seen', has an attachment and is signed would have `asz' as its corresponding
@@ -100,7 +100,7 @@ specify the field to sort the search results by and the direction (i.e.,
 	to,t            To:-recipient(s)
 #+end_example
 
-For the complete list, try the command: ~mu info fields~.
+For the complete list, try the command: *mu info fields*.
 
 Thus, for example, to sort messages by date, you could specify:
 
@@ -132,11 +132,11 @@ output results in the specified format:
   environments
 
 ** --linksdir=<dir> and -c, --clearlinks
-when using ~-format=links~, output the results as a maildir with symbolic links to
+when using *-format=links*, output the results as a maildir with symbolic links to
 the found messages. This enables easy integration with mail-clients (see below
 for more information). *mu* will create the maildir if it does not exist yet.
 
-If you specify ~--clearlinks~, existing symlinks will be cleared from the target
+If you specify *--clearlinks*, existing symlinks will be cleared from the target
 directories; this allows for re-use of the same maildir. However, this option
 will delete any symlink it finds, so be careful.
 
@@ -163,7 +163,7 @@ could specify
 This is assuming the GNU *date* command.
 
 ** --exec=<command>
-the ~--exec~ coption causes the =command= to be executed on each matched message;
+the *--exec* coption causes the =command= to be executed on each matched message;
 for example, to see the raw text of all messages matching `milkshake', you could
 use:
 #+begin_example
@@ -216,7 +216,7 @@ description: http://www.jwz.org/doc/threading.html
 ** -a,--analyze
 instead of executing the query, analyze it by show the parse-tree s-expression
 and a stringified version of the Xapian query. This can help users to determine
-how ~mu~ interprets some query.
+how *mu* interprets some query.
 
 The output of this command are differ between versions, but should be helpful
 nevertheless.
diff --git a/man/mu-help.1.org b/man/mu-help.1.org
index 0b5e71961..9036b7f36 100644
--- a/man/mu-help.1.org
+++ b/man/mu-help.1.org
@@ -11,7 +11,7 @@ mu-help - show help information about mu commands.
 
 * DESCRIPTION
 
-*mu help* provides help information about mu commands.
+*mu help* provides help information about *mu* commands.
 
 #+include: "common-options.inc" :minlevel 1
 
diff --git a/man/mu-index.1.org b/man/mu-index.1.org
index 026607b51..23ae2a07f 100644
--- a/man/mu-index.1.org
+++ b/man/mu-index.1.org
@@ -42,7 +42,7 @@ speed up things you have some maildirs that never change.
 
 =.noupdate= does not affect already-indexed message: you can still search for
 them. =.noupdate= is ignored when you start indexing with an empty database (such
-as directly after =mu init=).
+as directly after *mu init*).
 
 There also the option *--lazy-check* which can greatly speed up indexing; see
 below for details.
@@ -54,7 +54,7 @@ the `PERFORMANCE (i,ii,iii)' below for more information.
 
 The optional `phase two' of the indexing-process is the removal of messages from
 the database for which there is no longer a corresponding file in the Maildir.
-If you do not want this, you can use ~-n~, ~--nocleanup~.
+If you do not want this, you can use *-n*, *--nocleanup*.
 
 When *mu index* catches one of the signals *SIGINT*, *SIGHUP* or *SIGTERM* (e.g., when
 you press Ctrl-C during the indexing process), it attempts to shutdown
@@ -71,7 +71,7 @@ in lazy-check mode, *mu* does not consider messages for which the time-stamp
 indexing run. This is much faster than the non-lazy check, but won't update
 messages that have change (rather than having been added or removed), since
 merely editing a message does not update the directory time-stamp. Of course,
-you can run *mu-index* occasionally without ~--lazy-check~, to pick up such
+you can run *mu-index* occasionally without *--lazy-check*, to pick up such
 messages.
 
 ** --nocleanup
diff --git a/man/mu-info.1.org b/man/mu-info.1.org
index 3879f2264..42114658a 100644
--- a/man/mu-info.1.org
+++ b/man/mu-info.1.org
@@ -11,14 +11,14 @@ mu-info  - show information
 
 * DESCRIPTION
 
-~mu info~ is the ~mu~ command for getting information about various topics:
+*mu info* is the *mu* command for getting information about various topics:
 
-- *mu*: general mu build information (default)
+- *mu*: general *mu* build information (default)
 - *store*: information about the message store
 - *fields*: table with all the query fields and flags
 - *maildirs*: list all maildirs under the store's root-maildir
 
-Note that while running (e.g. ~mu4e~), some of the ~store~ information can be
+Note that while running (e.g. ~mu4e~), some of the *store* information can be
 delayed due to database caching.
 
 #+include: "common-options.inc" :minlevel 1
diff --git a/man/mu-init.1.org b/man/mu-init.1.org
index 2c8fefb83..fbd69d29e 100644
--- a/man/mu-init.1.org
+++ b/man/mu-init.1.org
@@ -3,7 +3,7 @@
 
 * NAME
 
-mu-init - initialize the mu message database
+mu-init - initialize the *mu* message database
 
 * SYNOPSIS
 
@@ -11,7 +11,7 @@ mu-init - initialize the mu message database
 
 * DESCRIPTION
 
-*mu init* is the subcommand for setting up the mu message database. After *mu init*
+*mu init* is the subcommand for setting up the *mu* message database. After *mu init*
 has completed, you can run *mu index*
 
 * INIT OPTIONS
@@ -21,7 +21,7 @@ has completed, you can run *mu index*
 use =<maildir>= as the root-maildir.
 
 By default, *mu* uses the *MAILDIR* environment; if it is not set, it uses =~/Maildir=
-if it is an existing directory. If neither of those can be used, the ~--maildir~
+if it is an existing directory. If neither of those can be used, the *--maildir*
 option is required; it must be an absolute path (but ~~/~ expansion is
 performed).
 
@@ -69,7 +69,7 @@ Chinese/Japanese/Korean. See *NGRAM SUPPORT* below for details.
 ** --reinit
 
 reinitialize the database from an earlier version; that is, create a new empty
-database with the existing settings. This cannot be combined with the other ~init~
+database with the existing settings. This cannot be combined with the other *init*
 options.
 
 #+include: "muhome.inc" :minlevel 2
diff --git a/man/mu-mkdir.1.org b/man/mu-mkdir.1.org
index 619759130..b4dff2e3a 100644
--- a/man/mu-mkdir.1.org
+++ b/man/mu-mkdir.1.org
@@ -14,7 +14,7 @@ mu-mkdir - create a new Maildir
 *mu mkdir* is the command for creating Maildirs as per *maildir(5)*. A maildir is a
 a directory with subdirectories ~new~, ~cur~ and ~tmp~.
 
-The command does not use the mu database.
+The command does not use the *mu* database.
 
 If creation fails for any reason, *no* attempt is made to remove any parts that
 were created. This is for safety reasons.
diff --git a/man/mu-move.1.org b/man/mu-move.1.org
index f8132e70d..271203762 100644
--- a/man/mu-move.1.org
+++ b/man/mu-move.1.org
@@ -17,7 +17,7 @@ For any change, both the message file in the file system as well as its
 representation in the database are updated accordingly.
 
 The source message file and target-maildir must reside under the root-maildir
-for mu's database (see *mu info store*).
+for *mu*'s database (see *mu info store*).
 
 * MOVE OPTIONS
 
@@ -41,7 +41,7 @@ the source message.
 
 print the target filename(s), but don't change anything.
 
-Note that with the ~--change-name~, the target name is not constant, so you cannot
+Note that with the *--change-name*, the target name is not constant, so you cannot
 use a dry-run to predict the exact name when doing a `real' run.
 
 #+include: "common-options.inc" :minlevel 1
@@ -66,7 +66,7 @@ messages, i.e. messages that live in the ~cur/~ sub-directory of a Maildir.
 | T    | Trashed; to be deleted later       |
 
 New messages (in the ~new/~ sub-directory) do not have flags encoded in their
-file-name; but we *mu* uses `N' in the ~--flags~ to represent that:
+file-name; but we *mu* uses `N' in the *--flags* to represent that:
 
 #+ATTR_MAN: :disable-caption t
 | Flag | Meaning |
@@ -81,18 +81,18 @@ flags.
 
 * ABSOLUTE AND RELATIVE FLAGS
 
-You can specify the flags with the ~--flags~ parameter, and do either with either
+You can specify the flags with the *--flags* parameter, and do either with either
 *absolute* or *relative* flags.
 
 Absolute flags just specify the new flags by their letters; e.g. to specify a
-/Trashed/, /Seen/, /Replied/ message, you'd use ~--flags STR~.
+/Trashed/, /Seen/, /Replied/ message, you'd use *--flags STR*.
 #+end_example
 
 Relative flags are relative to the current flags for some message, and each of
 the flags is prefixed with either ~+~ ("add this flag") or ~-~ ("remove this flag").
 
 So to add the /Seen/ flag and remove the /Draft/ flag from whatever the message
-already has, ~--flags +S-D~.
+already has, *--flags +S-D*.
 
 You cannot combine relative and relative flags.
 
diff --git a/man/mu-query.7.org b/man/mu-query.7.org
index 49b8c46b2..ca3faff4c 100644
--- a/man/mu-query.7.org
+++ b/man/mu-query.7.org
@@ -7,7 +7,7 @@ mu-query - a language for finding messages in *mu* databases.
 
 * DESCRIPTION
 
-The mu query language is the language used by *mu find* and *mu4e* to find messages
+The *mu* query language is the language used by *mu find* and *mu4e* to find messages
 in *mu*'s Xapian database. The language is quite similar to Xapian's default
 query-parser, but is an independent implementation that is customized for the
 mu/mu4e use-case.
@@ -16,7 +16,7 @@ Here, we give a structured but informal overview of the query language and
 provide examples. As a companion to this, we recommend the *mu fields* and *mu
 flags* commands to get an up-to-date list of the available fields and flags.
 
-Furthermore, *mu find* provides the ~--analyze~ option, which shows how *mu*
+Furthermore, *mu find* provides the *--analyze* option, which shows how *mu*
 interprets your query; see the *ANALYZING QUERIES* section below.
 
 *NOTE:* if you use queries on the command-line (say, for *mu find*), you need to
@@ -116,7 +116,7 @@ Regular expressions can be useful, but are relatively slow.
 
 We already saw a number of search fields, such as *subject:* and *body:*. For the
 full table with all details, including single-char shortcuts, try the command:
-~mu info fields~.
+*mu info fields*.
 
 #+ATTR_MAN: :disable-caption t
 #+begin_example
@@ -153,7 +153,7 @@ full table with all details, including single-char shortcuts, try the command:
 +-----------+----------+----------+-----------------------------+
 #+end_example
 
-(*) The language code for the text-body if found. This works only if ~mu~ was
+(*) The language code for the text-body if found. This works only if *mu* was
 built with CLD2 support.
 
 There are also the special fields *contact:*, which matches all contact-fields
@@ -360,10 +360,10 @@ for "cld2-support*.
 * ANALZYING QUERIES
 
 Despite all the excellent documentation, in some cases it can be non-obvious how
-~mu~ interprets your query. For that, you can ask ~mu~ to analyze the query -- that
-is, show how ~mu~ interprets the query.
+*mu* interprets your query. For that, you can ask *mu* to analyze the query -- that
+is, show how *mu* interprets the query.
 
-This uses the the ~--analyze~ option to *mu find*.
+This uses the the *--analyze* option to *mu find*.
 #+begin_example
 $ mu find subject:wombat AND date:3m.. size:..2000  --analyze
 ,* query:
diff --git a/man/mu-server.1.org b/man/mu-server.1.org
index c0c8186f9..4476770a1 100644
--- a/man/mu-server.1.org
+++ b/man/mu-server.1.org
@@ -3,7 +3,7 @@
 
 * NAME
 
-mu-server - the mu backend for the mu4e e-mail client
+mu-server - the *mu* backend for the mu4e e-mail client
 
 * SYNOPSIS
 
@@ -11,7 +11,7 @@ mu-server - the mu backend for the mu4e e-mail client
 
 * DESCRIPTION
 
-*mu server* starts a simple shell in which one can query and manipulate the mu
+*mu server* starts a simple shell in which one can query and manipulate the *mu*
 database. The output uses s-expressions. *mu server* is not meant for use by
 humans, except for debugging purposes. Instead, it is designed specifically for
 the *mu4e* e-mail client.
@@ -50,7 +50,7 @@ UTF-8 (in which the s-expressions are encoded).
 
 ** --commands
 
-List available commands (and try with ~--verbose~)
+List available commands (and try with *--verbose*)
 
 ** --eval <expression>
 
@@ -71,7 +71,7 @@ does; we take overall time of 50 such requests:
 #+begin_src sh
 time build/mu/mu server --allow-temp-file --eval '(find :query "\"\"" :include-related t :threads t :maxnum 50000)' >/dev/null
 #+end_src
-(and ~--allow-temp-file~ for 1.11)
+(and *--allow-temp-file* for 1.11)
 
 #+ATTR_MAN: :disable-caption t
 |       release | time (sec) |
diff --git a/man/mu-view.1.org b/man/mu-view.1.org
index bec868b86..9ac5930e4 100644
--- a/man/mu-view.1.org
+++ b/man/mu-view.1.org
@@ -26,9 +26,9 @@ standard-input.
 ** --format,-o  = <format>
 use the given output format, one of:
 
-- ~plain~ - use the plain-text body; this is the default
-- ~html~ - use the HTML body
-- ~sexp~ - show the S-expression representation of the message
+- *plain* - use the plain-text body; this is the default
+- *html* - use the HTML body
+- *sexp* - show the S-expression representation of the message
 
 ** --summary-len=<number>
 instead of displaying the full message, output a summary based upon the first
diff --git a/man/mu.1.org b/man/mu.1.org
index e1cb73d94..4c03e2bad 100644
--- a/man/mu.1.org
+++ b/man/mu.1.org
@@ -14,69 +14,69 @@ For information about the common options, see *COMMON OPTIONS*.
 
 * DESCRIPTION
 
-~mu~ is the general command that shows help about the specific commands:
-
-- ~add~:  add specific messages to the database.
-- ~cfind~: find contacts
-- ~extract~: extract attachments and other MIME-parts
-- ~find~: find messages in the database
-- ~help~: get help for some command
-- ~index~: (re)index the messages in a Maildir
-- ~info~: show information about the mu database
-- ~init~: initialize the mu database
-- ~mkdir~: create a new Maildir
-- ~remove~: remove specific messages from the database
-- ~server~: start a server process (for ~mu4e~-internal use)
-- ~view~: view a specific message
-
-Each of the commands have their own manpage ~mu-<command>~.
-
-~mu~ is a set of tools for dealing with Maildirs and the e-mail messages
+*mu* is the general command that shows help about the specific commands:
+
+- *add*:  add specific messages to the database.
+- *cfind*: find contacts
+- *extract*: extract attachments and other MIME-parts
+- *find*: find messages in the database
+- *help*: get help for some command
+- *index*: (re)index the messages in a Maildir
+- *info*: show information about the *mu* database
+- *init*: initialize the *mu* database
+- *mkdir*: create a new Maildir
+- *remove*: remove specific messages from the database
+- *server*: start a server process (for ~mu4e~-internal use)
+- *view*: view a specific message
+
+Each of the commands have their own manpage *mu-<command>*.
+
+*mu* is a set of tools for dealing with Maildirs and the e-mail messages
 in them.
 
-~mu~'s main purpose is to enable searching of e-mail messages. It
+*mu*'s main purpose is to enable searching of e-mail messages. It
 does so by periodically scanning a Maildir directory tree and
 analyzing the e-mail messages found (this is called `indexing'). The
 results of this analysis are stored in a database, which can then be
 queried.
 
-In addition to indexing and searching, ~mu~ also offers
+In addition to indexing and searching, *mu* also offers
 functionality for viewing messages, extracting attachments and
 creating maildirs, and searching and exporting contact information.
 
-~mu~ can be used from the command line or can be integrated with various
+*mu* can be used from the command line or can be integrated with various
 e-mail clients.
 
 This manpage gives a general overview of the available commands
-(~index~, ~find~, etc.); each ~mu~ command has its own
+(*index*, *find*, etc.); each *mu* command has its own
 man-page as well.
 
 * COLORS
 
-Some ~mu~ commands support colorized output, and do so by default. If you don't
-want colors, you can use ~--nocolor~.
+Some *mu* commands support colorized output, and do so by default. If you don't
+want colors, you can use *--nocolor*.
 
 * ENCODING
 
-~mu~'s output is in the current locale, with the exceptions of the output
+*mu*'s output is in the current locale, with the exceptions of the output
 specifically meant for output to UTF8-encoded files. In practice, this means
-that the output of commands ~index~, ~view~, ~extract~ is always encoded according to
+that the output of commands *index*, *view*, *extract* is always encoded according to
 the current locale.
 
-The same is true for ~find~ and ~cfind~, with some exceptions, where
+The same is true for *find* and *cfind*, with some exceptions, where
 the output is always UTF-8, regardless of the locale:
 
-- For ~cfind~ the exception is ~--format=bbdb~. This is hard-coded to UTF-8, and as
+- For *cfind* the exception is *--format=bbdb*. This is hard-coded to UTF-8, and as
   such specified in the output-file, so emacs/bbdb can handle it correctly
   without guessing.
-- For ~find~ the output is encoded according the locale for ~--format=plain~ (the
+- For *find* the output is encoded according the locale for *--format=plain* (the
   default), and UTF-8 for all other formats.
 
 * DATABASE AND FILE
 
-The ~index~, ~find~, and ~cfind~ commands work with the database, while the other
-ones work on individual mail files. Hence, running ~view~, ~mkdir~ and ~extract~ does
-not require the mu database.
+The *index*, *find*, and *cfind* commands work with the database, while the other
+ones work on individual mail files. Hence, running *view*, *mkdir* and *extract* does
+not require the *mu* database.
 
 #+include: "common-options.inc" :minlevel 1
 
diff --git a/man/muhome.inc b/man/muhome.inc
index 8b312a2b9..145ed2cb2 100644
--- a/man/muhome.inc
+++ b/man/muhome.inc
@@ -1,10 +1,10 @@
 ** --muhome
 use a non-default directory to store and read the database, write the logs, etc.
-By default, ~mu~ uses the XDG Base Directory Specification (e.g. on GNU/Linux this
-defaults to =~/.cache/mu= and =~/.config/mu=). Earlier versions of ~mu~ defaulted to
+By default, *mu* uses the XDG Base Directory Specification (e.g. on GNU/Linux this
+defaults to =~/.cache/mu= and =~/.config/mu=). Earlier versions of *mu* defaulted to
 =~/.mu=, which now requires =--muhome=~/.mu=.
 
-The environment variable ~MUHOME~ can be used as an alternative to ~--muhome~. The
+The environment variable ~MUHOME~ can be used as an alternative to *--muhome*. The
 latter has precedence.
 
 # Local Variables:

From 263bbda74c48a0813667c0edff9e1c550ba4c835 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 20 Jul 2024 10:05:55 +0300
Subject: [PATCH 064/305] IDEAS.org: update mailing-list support idea

Fixes #2724.
---
 IDEAS.org | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/IDEAS.org b/IDEAS.org
index 0502c8515..ea5ed4e2e 100644
--- a/IDEAS.org
+++ b/IDEAS.org
@@ -5,9 +5,10 @@ Ideas for future enhancements. We collect those here so they don't clutter up
 the Github issue list, i.e. without any clear plan for adding in the near
 future.
 
-- Support automatic handling for List-Unsubscribe headers
-  https://github.com/djcb/mu/issues/2623 This seems useful, but probably
-  requires a lot of testing to get right.
+- Support automatic handling for List-Unsubscribe headers and more in general,
+  handle mailing-list commands https://github.com/djcb/mu/issues/2623 and
+  https://github.com/djcb/mu/issues/2724 This seems useful, but probably
+  requires a lot of testing to get right. Can we re-use the Gnus code for this?
 
 - Allow for *muting* messages https://github.com/djcb/mu/issues/636 Useful;
   probably need to do this by *remembering* the thread-id of muted messages; and

From d2ec1751ebf944f4a908cdfb8e2dcf791401c5b0 Mon Sep 17 00:00:00 2001
From: Tristan Riehs <tristan.riehs@bordeaux-inp.fr>
Date: Mon, 22 Jul 2024 12:46:46 +0900
Subject: [PATCH 065/305] mu-man: add macro for referencing manual pages

---
 man/macros.inc  | 5 +++++
 man/meson.build | 1 +
 2 files changed, 6 insertions(+)
 create mode 100644 man/macros.inc

diff --git a/man/macros.inc b/man/macros.inc
new file mode 100644
index 000000000..3c616c572
--- /dev/null
+++ b/man/macros.inc
@@ -0,0 +1,5 @@
+#+MACRO: man-link *$1*​($2)
+
+# Local Variables:
+# mode: org
+# End:
diff --git a/man/meson.build b/man/meson.build
index de4ba29d2..76018354f 100644
--- a/man/meson.build
+++ b/man/meson.build
@@ -26,6 +26,7 @@ incs=[
   'common-options.inc',
   'copyright.inc.in',
   'exit-code.inc',
+  'macros.inc',
   'muhome.inc',
   'prefooter.inc',
 ]

From dcc38071555ab7c0700e42c1689ec6f1aec01ff5 Mon Sep 17 00:00:00 2001
From: Tristan Riehs <tristan.riehs@bordeaux-inp.fr>
Date: Mon, 22 Jul 2024 15:18:46 +0900
Subject: [PATCH 066/305] mu-man: improve typesetting of references

Try to stick to the man-pages(7) standard.
---
 man/mu-add.1.org       |  5 ++++-
 man/mu-bookmarks.5.org |  8 +++++---
 man/mu-cfind.1.org     | 14 ++++++++++----
 man/mu-easy.7.org      | 37 +++++++++++++++++++++++--------------
 man/mu-extract.1.org   |  9 +++++----
 man/mu-find.1.org      | 28 ++++++++++++++++------------
 man/mu-index.1.org     | 17 +++++++++++------
 man/mu-info.1.org      |  3 ++-
 man/mu-init.1.org      | 19 ++++++++++++-------
 man/mu-mkdir.1.org     | 13 ++++++++-----
 man/mu-move.1.org      | 10 ++++++----
 man/mu-query.7.org     |  7 +++++--
 man/mu-remove.1.org    |  5 ++++-
 man/mu-server.1.org    |  4 +++-
 man/mu-verify.1.org    |  7 ++++---
 man/mu-view.1.org      |  3 ++-
 man/mu.1.org           | 19 ++++++++++++++++---
 man/muhome.inc         |  2 +-
 18 files changed, 137 insertions(+), 73 deletions(-)

diff --git a/man/mu-add.1.org b/man/mu-add.1.org
index 8b0762bb8..984de9fc0 100644
--- a/man/mu-add.1.org
+++ b/man/mu-add.1.org
@@ -1,5 +1,6 @@
 #+TITLE: MU ADD
 #+MAN_CLASS_OPTIONS: :section-id "@SECTION_ID@" :date "@MAN_DATE@"
+#+include: macros.inc
 
 * NAME
 
@@ -26,4 +27,6 @@ must be specified with an absolute path.
 
 * SEE ALSO
 
-*mu(1)*, *mu-index(1)*, *mu-remove(1)*
+{{{man-link(mu,1)}}},
+{{{man-link(mu-index,1)}}},
+{{{man-link(mu-remove,1)}}}
diff --git a/man/mu-bookmarks.5.org b/man/mu-bookmarks.5.org
index 4ea372ae0..4a85b1745 100644
--- a/man/mu-bookmarks.5.org
+++ b/man/mu-bookmarks.5.org
@@ -1,5 +1,6 @@
 #+TITLE: MU BOOKMARKS
 #+MAN_CLASS_OPTIONS: :section-id "@SECTION_ID@" :date "@MAN_DATE@"
+#+include: macros.inc
 
 * NAME
 
@@ -13,7 +14,7 @@ name for often-used queries. The bookmarks are also visible as shortcuts in the
 
 The bookmarks file is read from =<muhome>/bookmarks=. On Unix this would typically
 be w be =~/.config/mu/bookmarks=, but this can be influenced using the *--muhome*
-parameter for *mu-find(1)*.
+parameter for {{{man-link(mu-find,1)}}}.
 
 The bookmarks file is a typical key=value *.ini*-file, which is best shown by
 means of an example:
@@ -25,7 +26,7 @@ oldhat=maildir:/archive subject:hat   # archived with subject containing 'hat'
 #+end_example
 
 The *[mu]* group header is required. For practical uses of bookmarks, see
-*mu-find(1)*.
+{{{man-link(mu-find,1)}}}.
 
 #+include: "author.inc" :minlevel 1
 
@@ -33,4 +34,5 @@ The *[mu]* group header is required. For practical uses of bookmarks, see
 
 * SEE ALSO
 
-*mu(1)*, *mu-find(1)*
+{{{man-link(mu,1)}}},
+{{{man-link(mu-find,1)}}}
diff --git a/man/mu-cfind.1.org b/man/mu-cfind.1.org
index 1ea6768e9..b8a5b8c47 100644
--- a/man/mu-cfind.1.org
+++ b/man/mu-cfind.1.org
@@ -1,5 +1,6 @@
 #+TITLE: MU CFIND
 #+MAN_CLASS_OPTIONS: :section-id "@SECTION_ID@" :date "@MAN_DATE@"
+#+include: macros.inc
 
 * NAME
 
@@ -42,7 +43,7 @@ If you do not specify a search expression, *mu cfind* returns the full list of
 contacts. Note, *mu cfind* uses a cache with the e-mail information, which is
 populated during the indexing process.
 
-The regular expressions are basic case-insensitive PCRE, see *pcre(3)*.
+The regular expressions are basic case-insensitive PCRE, see {{{man-link(pcre,3)}}}.
 
 * CFIND OPTIONS
 
@@ -124,7 +125,7 @@ Each contact has the following fields:
 | ~personal~      | whether the email was seen in a message together with a personal address |
 | ~frequency~     | approximation of the number of times this contact was seen in messages   |
 
-The JSON format is useful for further processing, e.g. using the *jq(1)* tool:
+The JSON format is useful for further processing, e.g. using the {{{man-link(jq,1)}}} tool:
 
 List display names, sorted by their last-seen date:
 #+begin_example
@@ -146,7 +147,7 @@ which is (by default) accessible by pressing *Q*.
 * ENCODING
 
 *mu cfind* output is encoded according to the current locale except for
-=--format=bbdb=. This is hard-coded to UTF-8, and as such specified in the
+*--format=bbdb*. This is hard-coded to UTF-8, and as such specified in the
 output-file, so emacs/bbdb can handle things correctly, without guessing.
 
 #+include: "exit-code.inc" :minlevel 1
@@ -158,4 +159,9 @@ output-file, so emacs/bbdb can handle things correctly, without guessing.
 #+include: "copyright.inc" :minlevel 1
 
 * SEE ALSO
-*mu(1)*, *mu-index(1)*, *mu-find(1)*, *pcre(3)*, *jq(1)*
+
+{{{man-link(mu,1)}}},
+{{{man-link(mu-index,1)}}},
+{{{man-link(mu-find,1)}}},
+{{{man-link(pcre,3)}}},
+{{{man-link(jq,1)}}}
diff --git a/man/mu-easy.7.org b/man/mu-easy.7.org
index 8d7b66598..d2810ae06 100644
--- a/man/mu-easy.7.org
+++ b/man/mu-easy.7.org
@@ -1,5 +1,6 @@
 #+TITLE: MU EASY
 #+MAN_CLASS_OPTIONS: :section-id "@SECTION_ID@" :date "@MAN_DATE@"
+#+include: macros.inc
 
 * NAME
 
@@ -12,8 +13,8 @@ many options, which are all described in the man pages for the various
 sub-commands. This man pages jumps over all of the details and gives examples of
 some common use cases. If the use cases described here do not precisely do what
 you want, please check the more extensive information in the man page about the
-sub-command you are using -- for example, the *mu-index(1)* or *mu-find(1)* man
-pages.
+sub-command you are using -- for example, the {{{man-link(mu-index,1)}}} or
+{{{man-link(mu-find,1)}}} man pages.
 
 *NOTE*: the *index* command (and therefore, the ones that depend on that, such as
 *find*), require that you store your mail in the Maildir-format. If you don't do
@@ -34,7 +35,7 @@ with the *init* command.
 $ mu init
 #+end_example
 
-This uses the defaults (see *mu-init(1)* for details on how to change that).
+This uses the defaults (see {{{man-link(mu-init,1)}}} for details on how to change that).
 
 
 * INDEXING YOUR E-MAIL
@@ -50,23 +51,23 @@ the speed of your computer, hard drive etc. Usually, indexing should be able to
 reach a speed of a few hundred messages per second.
 
 *mu index* guesses the top-level Maildir to do its job; if it guesses wrong, you
-can use the =--maildir= option to specify the top-level directory that should be
-processed. See the *mu-index(1)* man page for more details.
+can use the *--maildir* option to specify the top-level directory that should be
+processed. See the {{{man-link(mu-index,1)}}} man page for more details.
 
 Normally, *mu index* visits all the directories under the top-level Maildir;
 however, you can exclude certain directories (say, the `trash' or `spam'
 folders) by creating a file called =.noindex= in the directory. When *mu* sees such
 a file, it will exclude this directory and its sub-directories from indexing.
-Also see *.noupdate* in the *mu-index(1)* manpage.
+Also see *.noupdate* in the {{{man-link(mu-index,1)}}} manpage.
 
 * SEARCHING YOUR E-MAIL
 
 After you have indexed your mail, you can start searching it. By default, the
 search results are printed on standard output. Alternatively, the output can
 take the form of Maildir with symbolic links to the found messages. This enables
-integration with e-mail clients; see the *mu-find(1)* man page for details, the
-syntax of the search parameters and so on. Here, we just give some examples for
-common cases.
+integration with e-mail clients; see the {{{man-link(mu-find,1)}}} man page for
+details, the syntax of the search parameters and so on. Here, we just give some
+examples for common cases.
 
 You can use the *mu fields* command to get information about all possible fields
 and flags.
@@ -89,7 +90,7 @@ on your the language/locale you are using.
 
 How do we know that the message was sent to Julius Caesar? Well, it's not
 visible from the results above, because the default fields that are shown are
-date/sender/subject. However, we can change this using the =--fields= parameter
+date/sender/subject. However, we can change this using the *--fields* parameter
 (try *mu fields* to see all the details):
 
 #+begin_example
@@ -122,7 +123,7 @@ from Socrates. This could return something like:
 #+end_example
 
 What if we want to see some of the body of the message? You can get a `summary'
-of the first lines of the message using the =--summary-len= option, which will
+of the first lines of the message using the *--summary-len* option, which will
 `summarize' the first =n= lines of the message:
 
 #+begin_example
@@ -283,9 +284,9 @@ $ mu cfind julius
 #+end_example
 
 will find all contacts with `julius' in either name or e-mail address. Note that
-*mu cfind* accepts a =regular expression= (as per *pcre(3)*)
+*mu cfind* accepts a =regular expression= (as per {{{man-link(pcre,3)}}}
 
-*mu cfind* also supports a =--format==-parameter, which sets the output to some
+*mu cfind* also supports a *--format=*-parameter, which sets the output to some
 specific format, so the results can be imported into another program. For
 example, to export your contact information to a *mutt* address book file, you can
 use something like:
@@ -300,4 +301,12 @@ to your =muttrc=.
 #+include: "prefooter.inc" :minlevel 1
 
 * SEE ALSO
-*mu(1)*, *mu-init(1)*, *mu-index(1)*, *mu-find(1)*, *mu-mfind(1)*, *mu-mkdir(1)*, *mu-view(1)*, *mu-extract(1)*
+
+{{{man-link(mu,1)}}},
+{{{man-link(mu-init,1)}}},
+{{{man-link(mu-index,1)}}},
+{{{man-link(mu-find,1)}}},
+{{{man-link(mu-mfind,1)}}},
+{{{man-link(mu-mkdir,1)}}},
+{{{man-link(mu-view,1)}}},
+{{{man-link(mu-extract,1)}}}
diff --git a/man/mu-extract.1.org b/man/mu-extract.1.org
index 571c49705..976137851 100644
--- a/man/mu-extract.1.org
+++ b/man/mu-extract.1.org
@@ -1,5 +1,6 @@
 #+TITLE: MU EXTRACT
 #+MAN_CLASS_OPTIONS: :section-id "@SECTION_ID@" :date "@MAN_DATE@"
+#+include: macros.inc
 
 * NAME
 
@@ -24,7 +25,7 @@ MIME-parts, a name is derived from the message-id of the message.
 
 If you specify a regular express pattern as the second argument, all attachments
 with filenames matching that pattern will be extracted. The regular expressions
-are basic PCRE, and are case-sensitive by default; see *pcre(3)* for more details.
+are basic PCRE, and are case-sensitive by default; see {{{man-link(pcre,3)}}} for more details.
 
 Without any options, *mu extract* simply outputs the list of leaf MIME-parts in
 the message. Only `leaf' MIME-parts (including RFC822 attachments) are
@@ -62,8 +63,8 @@ a legal filename in the target directory.
 
 ** --matches=<pattern>
 Attachments with filenames matching the pattern will be extracted. The regular
-expressions are basic PCRE, and are case-sensitive by default; see *pcre(3)* for
-more details.
+expressions are basic PCRE, and are case-sensitive by default; see
+{{{man-link(pcre,3)}}} for more details.
 
 ** --play
 Try to `play' (open) the attachment with the default application for the
@@ -105,4 +106,4 @@ $ cat msgfile | mu extract --play --matches 'whoopsididitagain.mp3'
 
 * SEE ALSO
 
-*mu(1)*
+{{{man-link(mu,1)}}}
diff --git a/man/mu-find.1.org b/man/mu-find.1.org
index eae040473..af889e4ef 100644
--- a/man/mu-find.1.org
+++ b/man/mu-find.1.org
@@ -1,5 +1,6 @@
 #+TITLE: MU FIND
 #+MAN_CLASS_OPTIONS: :section-id "@SECTION_ID@" :date "@MAN_DATE@"
+#+include: macros.inc
 
 * NAME
 
@@ -12,12 +13,12 @@ mu-find - find e-mail messages in the *mu* database.
 * DESCRIPTION
 
 *mu find* is the *mu* command for searching e-mail message that were stored earlier
-using *mu index(1)*.
+using {{{man-link(mu index,1)}}}.
 
 * SEARCHING MAIL
 
 *mu find* starts a search for messages in the database that match some search
-pattern. The search patterns are described in detail in *mu-query(7)*.
+pattern. The search patterns are described in detail in {{{man-link(mu-query,7)}}}.
 
 For example:
 
@@ -40,12 +41,12 @@ The search pattern is taken as a command-line parameter. If the search
 parameter consists of multiple parts (as in the example) they are
 treated as if there were a logical *and* between them.
 
-For details on the possible queries, see *mu-query(7)*.
+For details on the possible queries, see {{{man-link(mu-query,7)}}}.
 
 * FIND OPTIONS
 
-Note, some of the important options are described in the *mu*(1) man-page
-and not here, as they apply to multiple *mu* commands.
+Note, some of the important options are described in the {{{man-link(mu*,1)}}}
+manual page and not here, as they apply to multiple *mu* commands.
 
 The *find*-command has various options that influence the way *mu* displays the
 results. If you don't specify anything, the defaults are *--fields="d f s"*,
@@ -81,9 +82,9 @@ parameters, such as:
 
 For the complete list, try the command: *mu info fields*.
 
-The message flags are described in *mu-query(7)*. As an example, a message which
-is `seen', has an attachment and is signed would have `asz' as its corresponding
-output string, while an encrypted new message would have `nx'.
+The message flags are described in {{{man-link(mu-query,7)}}}. As an example, a
+message which is `seen', has an attachment and is signed would have `asz' as its
+corresponding output string, while an encrypted new message would have `nx'.
 
 ** -s, --sortfield=<field> and -z,--reverse
 specify the field to sort the search results by and the direction (i.e.,
@@ -176,8 +177,8 @@ $ mu find milkshake --fields="l" | xargs less
 
 ** -b, --bookmark=<bookmark>
 use a bookmarked search query. Using this option, a query from your bookmark
-file will be prepended to other search queries. See *mu-bookmarks(5)* for the
-details of the bookmarks file.
+file will be prepended to other search queries. See
+{{{man-link(mu-bookmarks,5)}}} for the details of the bookmarks file.
 
 
 ** -u, --skip-dups
@@ -276,7 +277,7 @@ After restarting Wanderlust, the virtual folders should appear.
 
 * ENCODING
 
-*mu find* output is encoded according to the locale for =--format=plain= (the
+*mu find* output is encoded according to the locale for *--format=plain* (the
 default format), and UTF-8 for all other formats (=sexp=, =xml=).
 
 
@@ -311,4 +312,7 @@ taking the total number for 10 test runs.
 
 * SEE ALSO
 
-*mu(1)*, *mu-index(1)*, *mu-query(7)*, *mu-info(1)*
+{{{man-link(mu,1)}}},
+{{{man-link(mu-index,1)}}},
+{{{man-link(mu-query,7)}}},
+{{{man-link(mu-info,1)}}}
diff --git a/man/mu-index.1.org b/man/mu-index.1.org
index 23ae2a07f..9300b0b6f 100644
--- a/man/mu-index.1.org
+++ b/man/mu-index.1.org
@@ -1,5 +1,6 @@
 #+TITLE: MU INDEX
 #+MAN_CLASS_OPTIONS: :section-id "@SECTION_ID@" :date "@MAN_DATE@"
+#+include: macros.inc
 
 * NAME
 
@@ -13,15 +14,15 @@ mu-index - index e-mail messages stored in Maildirs
 
 *mu index* is the *mu* command for scanning the contents of Maildir directories and
 storing the results in a Xapian database. The data can then be queried using
-*mu-find(1)*.
+{{{man-link(mu-find,1)}}}.
 
 Before the first time you run *mu index*, you must run *mu init* to initialize the
 database.
 
-*index* understands Maildirs as defined by Daniel Bernstein for *qmail(7)*. In
-addition, it understands recursive Maildirs (Maildirs within Maildirs),
-Maildir++. It also supports VFAT-based Maildirs which use =!= or =;= as the
-separators instead of =:=.
+*index* understands Maildirs as defined by Daniel Bernstein for
+{{{man-link(qmail,7)}}}. In addition, it understands recursive Maildirs
+(Maildirs within Maildirs), Maildir++. It also supports VFAT-based Maildirs
+which use =!= or =;= as the separators instead of =:=.
 
 E-mail messages which are not stored in something resembling a maildir
 leaf-directory (=cur= and =new=) are ignored, as are the cache directories for
@@ -215,4 +216,8 @@ least for now, the latest code is both the fastest and the most featureful!
 
 * SEE ALSO
 
-*maildir(5)*, *mu(1)*, *mu-init(1)*, *mu-find(1)*, *mu-cfind(1)*
+{{{man-link(maildir,5)}}},
+{{{man-link(mu,1)}}},
+{{{man-link(mu-init,1)}}},
+{{{man-link(mu-find,1)}}},
+{{{man-link(mu-cfind,1)}}}
diff --git a/man/mu-info.1.org b/man/mu-info.1.org
index 42114658a..cfc05663e 100644
--- a/man/mu-info.1.org
+++ b/man/mu-info.1.org
@@ -1,5 +1,6 @@
 #+TITLE: MU INFO
 #+MAN_CLASS_OPTIONS: :section-id "@SECTION_ID@" :date "@MAN_DATE@"
+#+include: macros.inc
 
 * NAME
 
@@ -29,4 +30,4 @@ delayed due to database caching.
 
 * SEE ALSO
 
-*mu(1)*
+{{{man-link(mu,1)}}}
diff --git a/man/mu-init.1.org b/man/mu-init.1.org
index fbd69d29e..2e9bf2964 100644
--- a/man/mu-init.1.org
+++ b/man/mu-init.1.org
@@ -1,5 +1,6 @@
 #+TITLE: MU INIT
 #+MAN_CLASS_OPTIONS: :section-id "@SECTION_ID@" :date "@MAN_DATE@"
+#+include: macros.inc
 
 * NAME
 
@@ -30,19 +31,20 @@ performed).
 specifies that some e-mail address is `my-address' (the option can be used
 multiple times). Any message in which at least one of the contact fields
 contains such an address is considered a `personal' messages; this can then be
-used for filtering in *mu-find(1)*, *mu-cfind(1)* and *mu4e*, e.g. to filter-out
-mailing list messages.
+used for filtering in {{{man-link(mu-find,1)}}}, {{{man-link(mu-cfind,1)}}} and
+*mu4e*, e.g. to filter-out mailing list messages.
 
 =<email-address-or-regex>= can be either a plain e-mail address (such as
-*foo@example.com*), or a basic PCRE regular-expression (see *pcre(3)* for details),
-wrapped in */* (such as =/foo-.*@example\\.com/=). Depending on your shell, the
-argument may need to be quoted.
+*foo@example.com*), or a basic PCRE regular-expression (see
+{{{man-link(pcre,3)}}} for details), wrapped in */* (such as
+=/foo-.*@example\\.com/=). Depending on your shell, the argument may need to be
+quoted.
 
 ** --ignored-address=<email-address-or-regex>
 
 specifies that some e-mail address is to be ignored from the contacts-cache (the
 option can be used multiple times). Such addresses then cannot be found with
-*mu-cfind(1)* or in the Mu4e contacts cache.
+{{{man-link(mu-cfind,1)}}} or in the Mu4e contacts cache.
 
 =<my-email-address>= can be either a plain e-mail address or a regexp, just like
 for the =--my-address= option.
@@ -97,4 +99,7 @@ $ mu init --maildir=~/Maildir --my-address=alice@example.com --my-address=bob@ex
 
 * SEE ALSO
 
-*mu-index(1)*, *mu-find(1)*, *mu-cfind(1)*, *pcre(3)*
+{{{man-link(mu-index,1)}}},
+{{{man-link(mu-find,1)}}},
+{{{man-link(mu-cfind,1)}}},
+{{{man-link(pcre,3)}}}
diff --git a/man/mu-mkdir.1.org b/man/mu-mkdir.1.org
index b4dff2e3a..7f67edd50 100644
--- a/man/mu-mkdir.1.org
+++ b/man/mu-mkdir.1.org
@@ -1,5 +1,6 @@
 #+TITLE: MU MKDIR
 #+MAN_CLASS_OPTIONS: :section-id "@SECTION_ID@" :date "@MAN_DATE@"
+#+include: macros.inc
 
 * NAME
 
@@ -11,8 +12,9 @@ mu-mkdir - create a new Maildir
 
 * DESCRIPTION
 
-*mu mkdir* is the command for creating Maildirs as per *maildir(5)*. A maildir is a
-a directory with subdirectories ~new~, ~cur~ and ~tmp~.
+*mu mkdir* is the command for creating Maildirs as per
+{{{man-link(maildir,5)}}}. A maildir is a a directory with subdirectories ~new~,
+~cur~ and ~tmp~.
 
 The command does not use the *mu* database.
 
@@ -22,8 +24,8 @@ were created. This is for safety reasons.
 * MKDIR OPTIONS
 
 ** --mode=<mode>
-set the file access mode for the new maildir(s) as in *chmod(1)*. The default
-is 0755.
+set the file access mode for the new maildir(s) as in
+{{{man-link(chmod,1)}}}. The default is 0755.
 
 #+include: "common-options.inc" :minlevel 1
 
@@ -39,4 +41,5 @@ creates three maildirs, =tom=, =dick= and =harry=.
 
 * SEE ALSO
 
-*maildir(5)*, *chmod(1)*
+{{{man-link(maildir,5)}}},
+{{{man-link(chmod,1)}}}
diff --git a/man/mu-move.1.org b/man/mu-move.1.org
index 271203762..53fd5a3ad 100644
--- a/man/mu-move.1.org
+++ b/man/mu-move.1.org
@@ -1,5 +1,6 @@
 #+TITLE: MU MOVE
 #+MAN_CLASS_OPTIONS: :section-id "@SECTION_ID@" :date "@MAN_DATE@"
+#+include: macros.inc
 
 * NAME
 
@@ -28,7 +29,8 @@ specify the new message flags. See *FLAGS* for details.
 ** --change-name
 
 change the basename of the message file when moving; this can be useful when
-using some external tools such as *mbsync(1)* which otherwise get confused
+using some external tools such as {{{man-link(mbsync,1)}}} which otherwise get
+confused
 
 ** --update-dups
 
@@ -48,8 +50,8 @@ use a dry-run to predict the exact name when doing a `real' run.
 
 * FLAGS
 
-(Note: if you are not familiar with Maildirs, please refer to the *maildir(5)*
-man-page, or see http://cr.yp.to/proto/maildir.html)
+(Note: if you are not familiar with Maildirs, please refer to the
+{{{man-link(maildir,5)}}} man-page, or see http://cr.yp.to/proto/maildir.html)
 
 The message flags specify the Maildir-metadata for a message and are represented
 by uppercase letters at the end of the message file name for all `non-new'
@@ -114,4 +116,4 @@ $ mu move /home/user/Maildir/project1/cur/1695559560.a73985881f4611ac2.hostname!
 
 * SEE ALSO
 
-*maildir(5)*
+{{{man-link(maildir,5)}}}
diff --git a/man/mu-query.7.org b/man/mu-query.7.org
index ca3faff4c..4169c5258 100644
--- a/man/mu-query.7.org
+++ b/man/mu-query.7.org
@@ -1,5 +1,6 @@
 #+TITLE: MU QUERY
 #+MAN_CLASS_OPTIONS: :section-id "@SECTION_ID@" :date "@MAN_DATE@"
+#+include: macros.inc
 
 * NAME
 
@@ -84,7 +85,7 @@ Note that a =pure not= - e.g. searching for *not apples* is quite a `heavy' quer
 
 * REGULAR EXPRESSIONS AND WILDCARDS
 
-The language supports matching basic PCRE regular expressions, see *pcre(3)*.
+The language supports matching basic PCRE regular expressions, see {{{man-link(pcre,3)}}}.
 
 Regular expressions are enclosed in *//*. Some examples:
 
@@ -381,4 +382,6 @@ interprets your query.
 
 * SEE ALSO
 
-*mu-find(1)*, *mu-info(1), *pcre(3)*
+{{{man-link(mu-find,1)}}},
+{{{man-link(mu-info,1)}}},
+{{{man-link(pcre,3)}}}
diff --git a/man/mu-remove.1.org b/man/mu-remove.1.org
index 070e1cb02..865a7c3af 100644
--- a/man/mu-remove.1.org
+++ b/man/mu-remove.1.org
@@ -1,5 +1,6 @@
 #+TITLE: MU REMOVE
 #+MAN_CLASS_OPTIONS: :section-id "@SECTION_ID@" :date "@MAN_DATE@"
+#+include: macros.inc
 
 * NAME
 
@@ -24,4 +25,6 @@ their filename. The files do not have to exist in the file system.
 
 * SEE ALSO
 
-*mu(1)*, *mu-index(1)*, *mu-add(1)*
+{{{man-link(mu,1)}}},
+{{{man-link(mu-index,1)}}},
+{{{man-link(mu-add,1)}}}
diff --git a/man/mu-server.1.org b/man/mu-server.1.org
index 4476770a1..d003ae6eb 100644
--- a/man/mu-server.1.org
+++ b/man/mu-server.1.org
@@ -1,5 +1,6 @@
 #+TITLE:  MU-SERVER
 #+MAN_CLASS_OPTIONS: :section-id "@SECTION_ID@" :date "@MAN_DATE@"
+#+include: macros.inc
 
 * NAME
 
@@ -88,4 +89,5 @@ time build/mu/mu server --allow-temp-file --eval '(find :query "\"\"" :include-r
 #+include: "prefooter.inc" :minlevel 1
 
 * SEE ALSO
-*mu(1)*
+
+{{{man-link(mu,1)}}}
diff --git a/man/mu-verify.1.org b/man/mu-verify.1.org
index c9bd0aaaf..939143533 100644
--- a/man/mu-verify.1.org
+++ b/man/mu-verify.1.org
@@ -1,5 +1,6 @@
 #+TITLE: MU VERIFY
 #+MAN_CLASS_OPTIONS: :section-id "@SECTION_ID@" :date "@MAN_DATE@"
+#+include: macros.inc
 
 * NAME
 
@@ -21,8 +22,8 @@ standard-input.
 * VERIFY OPTIONS
 
 ** -r, --auto-retrieve
-attempt to find keys online (see the *auto-key-retrieve* option in the *gnupg(1)*
-documentation).
+attempt to find keys online (see the *auto-key-retrieve* option in the
+{{{man-link(gnupg,1)}}} documentation).
 
 ** decrypt
 attempt to decrypt the message
@@ -52,4 +53,4 @@ which does not give any output unless there is an error.
 
 * SEE ALSO
 
-*mu(1)*
+{{{man-link(mu,1)}}}
diff --git a/man/mu-view.1.org b/man/mu-view.1.org
index 9ac5930e4..54be5a3aa 100644
--- a/man/mu-view.1.org
+++ b/man/mu-view.1.org
@@ -1,5 +1,6 @@
 #+TITLE: MU VIEW
 #+MAN_CLASS_OPTIONS: :section-id "@SECTION_ID@" :date "@MAN_DATE@"
+#+include: macros.inc
 
 * NAME
 
@@ -51,4 +52,4 @@ attempt to retrieve crypto-keys automatically from the network, when needed.
 
 * SEE ALSO
 
-*mu(1)*
+{{{man-link(mu,1)}}}
diff --git a/man/mu.1.org b/man/mu.1.org
index 4c03e2bad..7c7b715f0 100644
--- a/man/mu.1.org
+++ b/man/mu.1.org
@@ -1,5 +1,6 @@
 #+TITLE: MU
 #+MAN_CLASS_OPTIONS: :section-id "@SECTION_ID@" :date "@MAN_DATE@"
+#+include: macros.inc
 
 * NAME
 
@@ -85,6 +86,18 @@ not require the *mu* database.
 #+include: "prefooter.inc" :minlevel 1
 
 * SEE ALSO
-~mu-add(1)~, ~mu-cfind(1)~, ~mu-extract(1)~, ~mu-find(1)~, ~mu-help(1)~, ~mu-index(1)~,
-~mu-info(1)~, ~mu-init(1)~, ~mu-mkdir(1)~, ~mu-remove(1)~, ~mu-server(1)~, ~mu-view(1)~,
-~mu-query(7)~, ~mu-easy(1)~
+
+{{{man-link(mu-add,1)}}},
+{{{man-link(mu-cfind,1)}}},
+{{{man-link(mu-extract,1)}}},
+{{{man-link(mu-find,1)}}},
+{{{man-link(mu-help,1)}}},
+{{{man-link(mu-index,1)}}},
+{{{man-link(mu-info,1)}}},
+{{{man-link(mu-init,1)}}},
+{{{man-link(mu-mkdir,1)}}},
+{{{man-link(mu-remove,1)}}},
+{{{man-link(mu-server,1)}}},
+{{{man-link(mu-view,1)}}},
+{{{man-link(mu-query,7)}}},
+{{{man-link(mu-easy,1)}}}
diff --git a/man/muhome.inc b/man/muhome.inc
index 145ed2cb2..177b8deed 100644
--- a/man/muhome.inc
+++ b/man/muhome.inc
@@ -2,7 +2,7 @@
 use a non-default directory to store and read the database, write the logs, etc.
 By default, *mu* uses the XDG Base Directory Specification (e.g. on GNU/Linux this
 defaults to =~/.cache/mu= and =~/.config/mu=). Earlier versions of *mu* defaulted to
-=~/.mu=, which now requires =--muhome=~/.mu=.
+=~/.mu=, which now requires *--muhome=~/.mu*.
 
 The environment variable ~MUHOME~ can be used as an alternative to *--muhome*. The
 latter has precedence.

From b09ac79330dca98c0a8554ec4b3261fd18055df8 Mon Sep 17 00:00:00 2001
From: Tristan Riehs <tristan.riehs@bordeaux-inp.fr>
Date: Mon, 22 Jul 2024 15:21:09 +0900
Subject: [PATCH 067/305] mu-man: fix the BUGS section of mu-view

---
 man/mu-view.1.org | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/man/mu-view.1.org b/man/mu-view.1.org
index 54be5a3aa..9b6c4a38f 100644
--- a/man/mu-view.1.org
+++ b/man/mu-view.1.org
@@ -48,7 +48,7 @@ attempt to retrieve crypto-keys automatically from the network, when needed.
 
 #+include: "common-options.inc" :minlevel 1
 
-* BUGS
+#+include: "bugs.inc" :minlevel 1
 
 * SEE ALSO
 

From ec42817a5cf7a55ab6808359b7da3f92aa1833f1 Mon Sep 17 00:00:00 2001
From: Tristan Riehs <tristan.riehs@bordeaux-inp.fr>
Date: Mon, 22 Jul 2024 15:22:31 +0900
Subject: [PATCH 068/305] mu-man: typeset reference in included file

---
 man/exit-code.inc | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/man/exit-code.inc b/man/exit-code.inc
index 948085cae..9d822fb7a 100644
--- a/man/exit-code.inc
+++ b/man/exit-code.inc
@@ -1,3 +1,5 @@
+#+include: macros.inc
+
 * EXIT CODE
 
 This command returns 0 upon successful completion, or a non-zero exit code
@@ -5,7 +7,7 @@ otherwise.
 
     0. success
     2. no matches found. Try a different query
-   11. database schema mismatch. You need to re-initialize *mu*, see *mu-init(1)*
+   11. database schema mismatch. You need to re-initialize *mu*, see {{{man-link(mu-init,1)}}}
    19. failed to acquire lock. Some other program has exclusive access to the *mu* database
    99. caught an exception
 

From 5ed773aa4dd2e1bee72c30088145b1f7531b2f3d Mon Sep 17 00:00:00 2001
From: Tristan Riehs <tristan.riehs@bordeaux-inp.fr>
Date: Mon, 22 Jul 2024 15:26:31 +0900
Subject: [PATCH 069/305] mu-man: include whole prefooter in mu-view

---
 man/mu-view.1.org | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/man/mu-view.1.org b/man/mu-view.1.org
index 9b6c4a38f..6f741cfa6 100644
--- a/man/mu-view.1.org
+++ b/man/mu-view.1.org
@@ -48,7 +48,7 @@ attempt to retrieve crypto-keys automatically from the network, when needed.
 
 #+include: "common-options.inc" :minlevel 1
 
-#+include: "bugs.inc" :minlevel 1
+#+include: "prefooter.inc" :minlevel 1
 
 * SEE ALSO
 

From d46b428f7b60879ff86f6e4f6ced113ea6f2378d Mon Sep 17 00:00:00 2001
From: Tristan Riehs <tristan.riehs@bordeaux-inp.fr>
Date: Mon, 22 Jul 2024 15:28:47 +0900
Subject: [PATCH 070/305] mu-man: delete suspicious words

---
 man/mu-bookmarks.5.org | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/man/mu-bookmarks.5.org b/man/mu-bookmarks.5.org
index 4a85b1745..12c2af55a 100644
--- a/man/mu-bookmarks.5.org
+++ b/man/mu-bookmarks.5.org
@@ -13,7 +13,7 @@ name for often-used queries. The bookmarks are also visible as shortcuts in the
 *mu* experimental user interfaces, =mug= and =mug2=.
 
 The bookmarks file is read from =<muhome>/bookmarks=. On Unix this would typically
-be w be =~/.config/mu/bookmarks=, but this can be influenced using the *--muhome*
+be =~/.config/mu/bookmarks=, but this can be influenced using the *--muhome*
 parameter for {{{man-link(mu-find,1)}}}.
 
 The bookmarks file is a typical key=value *.ini*-file, which is best shown by

From cee4823f33684fb3f72961d4e9c2798854a65096 Mon Sep 17 00:00:00 2001
From: Tristan Riehs <tristan.riehs@bordeaux-inp.fr>
Date: Mon, 22 Jul 2024 15:40:57 +0900
Subject: [PATCH 071/305] mu-man: typeset file names using underlining

Make the emphasis more consistent, and do it using underscores in
Org documents, since verbatim is rendered as underlined anyway.
---
 man/mu-bookmarks.5.org |  4 ++--
 man/mu-cfind.1.org     |  2 +-
 man/mu-easy.7.org      | 10 +++++-----
 man/mu-find.1.org      |  8 ++++----
 man/mu-index.1.org     | 14 +++++++-------
 man/mu-init.1.org      |  6 +++---
 man/mu-mkdir.1.org     |  6 +++---
 man/mu-move.1.org      |  8 ++++----
 man/mu-query.7.org     |  2 +-
 man/mu-view.1.org      |  2 +-
 man/muhome.inc         |  6 +++---
 11 files changed, 34 insertions(+), 34 deletions(-)

diff --git a/man/mu-bookmarks.5.org b/man/mu-bookmarks.5.org
index 12c2af55a..5b13ffb52 100644
--- a/man/mu-bookmarks.5.org
+++ b/man/mu-bookmarks.5.org
@@ -12,8 +12,8 @@ Bookmarks are named shortcuts for search queries. They allow using a convenient
 name for often-used queries. The bookmarks are also visible as shortcuts in the
 *mu* experimental user interfaces, =mug= and =mug2=.
 
-The bookmarks file is read from =<muhome>/bookmarks=. On Unix this would typically
-be =~/.config/mu/bookmarks=, but this can be influenced using the *--muhome*
+The bookmarks file is read from _<muhome>/bookmarks_. On Unix this would typically
+be _~/.config/mu/bookmarks_, but this can be influenced using the *--muhome*
 parameter for {{{man-link(mu-find,1)}}}.
 
 The bookmarks file is a typical key=value *.ini*-file, which is best shown by
diff --git a/man/mu-cfind.1.org b/man/mu-cfind.1.org
index b8a5b8c47..32f4fb4a3 100644
--- a/man/mu-cfind.1.org
+++ b/man/mu-cfind.1.org
@@ -135,7 +135,7 @@ $ mu cfind --format=json --personal | jq -r '.[] | ."last-seen-iso" + " " + .dis
 * INTEGRATION WITH MUTT
 
 You can use *mu cfind* as an external address book server for *mutt*.
-For this to work, add the following to your =muttrc=:
+For this to work, add the following to your _muttrc_:
 
 #+begin_example
 set query_command = "mu cfind --format=mutt-ab '%s'"
diff --git a/man/mu-easy.7.org b/man/mu-easy.7.org
index d2810ae06..989132134 100644
--- a/man/mu-easy.7.org
+++ b/man/mu-easy.7.org
@@ -56,7 +56,7 @@ processed. See the {{{man-link(mu-index,1)}}} man page for more details.
 
 Normally, *mu index* visits all the directories under the top-level Maildir;
 however, you can exclude certain directories (say, the `trash' or `spam'
-folders) by creating a file called =.noindex= in the directory. When *mu* sees such
+folders) by creating a file called _.noindex_ in the directory. When *mu* sees such
 a file, it will exclude this directory and its sub-directories from indexing.
 Also see *.noupdate* in the {{{man-link(mu-index,1)}}} manpage.
 
@@ -106,8 +106,8 @@ Julius Caesar <jc@example.com> Fere libenter homines id quod volunt credunt
 This is the same message found before, only with some different fields
 displayed.
 
-By default, *mu* uses the logical ~AND~ for the search parameters -- that is, it
-displays messages that match all the parameters. However, we can use logical ~OR~
+By default, *mu* uses the logical _AND_ for the search parameters -- that is, it
+displays messages that match all the parameters. However, we can use logical _OR_
 as well:
 
 #+begin_example
@@ -141,7 +141,7 @@ The summary consists of the first /n/ lines of the message with all superfluous
 whitespace removed.
 
 Also note the *m:/archive* parameter in the query. This means that we only match
-messages in a maildir called ~'/archive'~.
+messages in a maildir called _'/archive'_.
 
 * MORE QUERIES
 
@@ -296,7 +296,7 @@ $ mu cfind --format=mutt-alias > ~/mutt-aliases
 #+end_example
 
 Then, you can use them in *mutt* if you add something like *source ~/mutt-aliases*
-to your =muttrc=.
+to your _muttrc_.
 
 #+include: "prefooter.inc" :minlevel 1
 
diff --git a/man/mu-find.1.org b/man/mu-find.1.org
index af889e4ef..576e640d3 100644
--- a/man/mu-find.1.org
+++ b/man/mu-find.1.org
@@ -145,9 +145,9 @@ will delete any symlink it finds, so be careful.
 $ mu find grolsch --format=links --linksdir=~/Maildir/search --clearlinks
 #+end_example
 
-stores links to found messages in =~/Maildir/search=. If the directory does not
+stores links to found messages in _~/Maildir/search_. If the directory does not
 exist yet, it will be created. Note: when *mu* creates a Maildir for these links,
-it automatically inserts a =.noindex= file, to exclude the directory from *mu
+it automatically inserts a _.noindex_ file, to exclude the directory from *mu
 index*.
 
 ** --after=<timestamp>
@@ -232,7 +232,7 @@ It is possible to integrate *mu find* with some mail clients
 
 ** *mutt*
 
-For *mutt* you can use the following in your =muttrc=; pressing the F8 key will
+For *mutt* you can use the following in your *muttrc*; pressing the F8 key will
 start a search, and F9 will take you to the results.
 
 #+begin_example
@@ -263,7 +263,7 @@ your Wanderlust configuration file:
 
 Now, you can search using the *g* key binding; you can also create permanent
 virtual folders when the messages matching some expression by adding something
-like the following to your =folders= file.
+like the following to your _folders_ file.
 
 #+begin_example
 VFolders {
diff --git a/man/mu-index.1.org b/man/mu-index.1.org
index 9300b0b6f..5794ffc62 100644
--- a/man/mu-index.1.org
+++ b/man/mu-index.1.org
@@ -22,27 +22,27 @@ database.
 *index* understands Maildirs as defined by Daniel Bernstein for
 {{{man-link(qmail,7)}}}. In addition, it understands recursive Maildirs
 (Maildirs within Maildirs), Maildir++. It also supports VFAT-based Maildirs
-which use =!= or =;= as the separators instead of =:=.
+which use *!* or *;* as the separators instead of *:*.
 
 E-mail messages which are not stored in something resembling a maildir
-leaf-directory (=cur= and =new=) are ignored, as are the cache directories for
-=notmuch= and =gnus=, and any dot-directory.
+leaf-directory (_cur_ and _new_) are ignored, as are the cache directories for
+_notmuch_ and _gnus_, and any dot-directory.
 
 Symlinks are followed, and the directories can be spread over multiple
 filesystems; however note that moving files around is much faster when multiple
 filesystems are not involved. Be careful to avoid self-referential symlinks!
 
-If there is a file called =.noindex= in a directory, the contents of that
+If there is a file called _.noindex_ in a directory, the contents of that
 directory and all of its subdirectories will be ignored. This can be useful to
 exclude certain directories from the indexing process, for example directories
 with spam-messages.
 
-If there is a file called =.noupdate= in a directory, the contents of that
+If there is a file called _.noupdate_ in a directory, the contents of that
 directory and all of its subdirectories will be ignored. This can be useful to
 speed up things you have some maildirs that never change.
 
-=.noupdate= does not affect already-indexed message: you can still search for
-them. =.noupdate= is ignored when you start indexing with an empty database (such
+_.noupdate_ does not affect already-indexed message: you can still search for
+them. _.noupdate_ is ignored when you start indexing with an empty database (such
 as directly after *mu init*).
 
 There also the option *--lazy-check* which can greatly speed up indexing; see
diff --git a/man/mu-init.1.org b/man/mu-init.1.org
index 2e9bf2964..0850a6ddc 100644
--- a/man/mu-init.1.org
+++ b/man/mu-init.1.org
@@ -21,7 +21,7 @@ has completed, you can run *mu index*
 
 use =<maildir>= as the root-maildir.
 
-By default, *mu* uses the *MAILDIR* environment; if it is not set, it uses =~/Maildir=
+By default, *mu* uses the *MAILDIR* environment; if it is not set, it uses _~/Maildir_
 if it is an existing directory. If neither of those can be used, the *--maildir*
 option is required; it must be an absolute path (but ~~/~ expansion is
 performed).
@@ -47,7 +47,7 @@ option can be used multiple times). Such addresses then cannot be found with
 {{{man-link(mu-cfind,1)}}} or in the Mu4e contacts cache.
 
 =<my-email-address>= can be either a plain e-mail address or a regexp, just like
-for the =--my-address= option.
+for the *--my-address* option.
 
 ** --max-message-size=<size>
 
@@ -85,7 +85,7 @@ query-parsing; it is not enabled by default, and is recommended only if you need
 to search for messages written in such languages.
 
 When enabled, *mu* automatically uses ngrams automatically. Xapian environment
-variables such as ~XAPIAN_CJK_NGRAM~ are ignored.
+variables such as *XAPIAN_CJK_NGRAM* are ignored.
 
 #+include: "exit-code.inc" :minlevel 1
 
diff --git a/man/mu-mkdir.1.org b/man/mu-mkdir.1.org
index 7f67edd50..c1587c3b7 100644
--- a/man/mu-mkdir.1.org
+++ b/man/mu-mkdir.1.org
@@ -13,8 +13,8 @@ mu-mkdir - create a new Maildir
 * DESCRIPTION
 
 *mu mkdir* is the command for creating Maildirs as per
-{{{man-link(maildir,5)}}}. A maildir is a a directory with subdirectories ~new~,
-~cur~ and ~tmp~.
+{{{man-link(maildir,5)}}}. A maildir is a a directory with subdirectories _new_,
+_cur_ and _tmp_.
 
 The command does not use the *mu* database.
 
@@ -35,7 +35,7 @@ set the file access mode for the new maildir(s) as in
 $ mu mkdir tom dick harry
 #+end_example
 
-creates three maildirs, =tom=, =dick= and =harry=.
+creates three maildirs, _tom_, _dick_ and _harry_.
 
 #+include: "prefooter.inc" :minlevel 1
 
diff --git a/man/mu-move.1.org b/man/mu-move.1.org
index 53fd5a3ad..c389c0d9b 100644
--- a/man/mu-move.1.org
+++ b/man/mu-move.1.org
@@ -55,7 +55,7 @@ use a dry-run to predict the exact name when doing a `real' run.
 
 The message flags specify the Maildir-metadata for a message and are represented
 by uppercase letters at the end of the message file name for all `non-new'
-messages, i.e. messages that live in the ~cur/~ sub-directory of a Maildir.
+messages, i.e. messages that live in the _cur/_ sub-directory of a Maildir.
 
 #+ATTR_MAN: :disable-caption t
 | Flag | Meaning                            |
@@ -67,7 +67,7 @@ messages, i.e. messages that live in the ~cur/~ sub-directory of a Maildir.
 | S    | Seen message                       |
 | T    | Trashed; to be deleted later       |
 
-New messages (in the ~new/~ sub-directory) do not have flags encoded in their
+New messages (in the _new/_ sub-directory) do not have flags encoded in their
 file-name; but we *mu* uses `N' in the *--flags* to represent that:
 
 #+ATTR_MAN: :disable-caption t
@@ -77,7 +77,7 @@ file-name; but we *mu* uses `N' in the *--flags* to represent that:
 
 Thus, changing flags means changing the letters at the end of the message
 file-name, except when setting or removing the `N' (new) flag. Setting or
-un-setting the New flag causes the message is to be moved from ~cur/~ to ~new/~ or
+un-setting the New flag causes the message is to be moved from _cur/_ to _new/_ or
 vice-versa, respectively. When marking a message as New, it looses the other
 flags.
 
@@ -91,7 +91,7 @@ Absolute flags just specify the new flags by their letters; e.g. to specify a
 #+end_example
 
 Relative flags are relative to the current flags for some message, and each of
-the flags is prefixed with either ~+~ ("add this flag") or ~-~ ("remove this flag").
+the flags is prefixed with either *+* ("add this flag") or *-* ("remove this flag").
 
 So to add the /Seen/ flag and remove the /Draft/ flag from whatever the message
 already has, *--flags +S-D*.
diff --git a/man/mu-query.7.org b/man/mu-query.7.org
index 4169c5258..bbc242e7b 100644
--- a/man/mu-query.7.org
+++ b/man/mu-query.7.org
@@ -281,7 +281,7 @@ prio:high
 
 The Maildir field describes the directory path starting *after* the Maildir root
 directory, and before the =/cur/= or =/new/= part. So, for example, if there's a
-message with the file name =~/Maildir/lists/running/cur/1234.213:2,=, you could
+message with the file name _~/Maildir/lists/running/cur/1234.213:2,_, you could
 find it (and all the other messages in that same maildir) with:
 #+begin_example
 maildir:/lists/running
diff --git a/man/mu-view.1.org b/man/mu-view.1.org
index 6f741cfa6..7dc208177 100644
--- a/man/mu-view.1.org
+++ b/man/mu-view.1.org
@@ -13,7 +13,7 @@ mu-view - display an e-mail message file
 * DESCRIPTION
 
 *mu view* is the *mu* command for displaying e-mail message files. It works on
-message files and does =not= require the message to be indexed in the database.
+message files and does _not_ require the message to be indexed in the database.
 
 The command shows some common headers (From:, To:, Cc:, Bcc:, Subject: and
 Date:), the list of attachments and either the plain-text or html body of the
diff --git a/man/muhome.inc b/man/muhome.inc
index 177b8deed..f3414c1be 100644
--- a/man/muhome.inc
+++ b/man/muhome.inc
@@ -1,10 +1,10 @@
 ** --muhome
 use a non-default directory to store and read the database, write the logs, etc.
 By default, *mu* uses the XDG Base Directory Specification (e.g. on GNU/Linux this
-defaults to =~/.cache/mu= and =~/.config/mu=). Earlier versions of *mu* defaulted to
-=~/.mu=, which now requires *--muhome=~/.mu*.
+defaults to _~/.cache/mu_ and _~/.config/mu_). Earlier versions of *mu* defaulted to
+_~/.mu_, which now requires *--muhome=~/.mu*.
 
-The environment variable ~MUHOME~ can be used as an alternative to *--muhome*. The
+The environment variable *MUHOME* can be used as an alternative to *--muhome*. The
 latter has precedence.
 
 # Local Variables:

From 547cc4ce7446624a72bfba358ffd40141d41e399 Mon Sep 17 00:00:00 2001
From: Tristan Riehs <tristan.riehs@bordeaux-inp.fr>
Date: Mon, 22 Jul 2024 16:09:17 +0900
Subject: [PATCH 072/305] mu-man: typeset option values differently

Use underlining only, do not use <>, as it is the most often done.
---
 man/mu-cfind.1.org   | 13 ++++++-----
 man/mu-extract.1.org | 23 +++++++++----------
 man/mu-find.1.org    | 53 ++++++++++++++++++++++----------------------
 man/mu-index.1.org   |  9 +++-----
 man/mu-init.1.org    | 35 ++++++++++++-----------------
 man/mu-mkdir.1.org   |  4 ++--
 man/mu-move.1.org    | 16 +++++--------
 man/mu-server.1.org  |  9 +++-----
 man/mu-verify.1.org  |  6 ++---
 man/mu-view.1.org    | 22 +++++++++---------
 man/muhome.inc       |  2 +-
 11 files changed, 87 insertions(+), 105 deletions(-)

diff --git a/man/mu-cfind.1.org b/man/mu-cfind.1.org
index 32f4fb4a3..c68058794 100644
--- a/man/mu-cfind.1.org
+++ b/man/mu-cfind.1.org
@@ -47,8 +47,8 @@ The regular expressions are basic case-insensitive PCRE, see {{{man-link(pcre,3)
 
 * CFIND OPTIONS
 
-** --format=plain|mutt-alias|mutt-ab|wl|org-contact|bbdb|csv
-sets the output format to the given value. The following are available:
+** --format plain|mutt-alias|mutt-ab|wl|org-contact|bbdb|csv
+Sets the output format to the given value. The following are available:
 
 #+ATTR_MAN: :disable-caption t
 | --format=   | description                       |
@@ -68,13 +68,14 @@ any double-quote is replaced by a double-double quote (thus, "hello" become
 ""hello"", and fields with commas are put in double-quotes. Normally, this
 should only apply to name fields.
 
-** --personal,-p only show addresses seen in messages where one of `my' e-mail
+** -p, --personal
+Only show addresses seen in messages where one of `my' e-mail
 addresses was seen in one of the address fields; this is to exclude addresses
 only seen in mailing-list messages. See the *--my-address* parameter to *mu init*.
 
-** --after=<timestamp> only show addresses last seen after
-=<timestamp>=. =<timestamp>= is a UNIX *time_t* value, the number of
-seconds since 1970-01-01 (in UTC).
+** --after _timestamp_
+Only show addresses last seen after _timestamp_. _timestamp_ is a UNIX
+*time_t* value, the number of seconds since 1970-01-01 (in UTC).
 
 From the command line, you can use the *date* command to get this value. For
 example, only consider addresses last seen after 2020-06-01, you could specify
diff --git a/man/mu-extract.1.org b/man/mu-extract.1.org
index 976137851..96a131e7d 100644
--- a/man/mu-extract.1.org
+++ b/man/mu-extract.1.org
@@ -32,37 +32,36 @@ the message. Only `leaf' MIME-parts (including RFC822 attachments) are
 considered, *multipart/** etc. are ignored.
 
 Without a filename parameter, *mu extract* reads a message from standard-input. In
-that case, you cannot use the second, ~<pattern>~ parameter as this would be
+that case, you cannot use the second, _PATTERN_ parameter as this would be
 ambiguous; instead, use the *--matches* option.
 
 * EXTRACT OPTIONS
 
 ** -a, --save-attachments
-save all MIME-parts that look like attachments.
+Save all MIME-parts that look like attachments.
 
 ** --save-all
-save all non-multipart MIME-parts.
+Save all non-multipart MIME-parts.
 
-** --parts=<parts>
-only consider the following numbered parts (comma-separated list). The numbers
+** --parts _parts_
+Only consider the following numbered _parts_ (comma-separated list). The numbers
 for the parts can be seen from running *mu extract* without any options but only
 the message file.
 
-** --target-dir=<dir>
-save the parts in the target directory rather than the current working
-directory.
+** --target-dir _dir_
+Save the parts in _dir_ rather than the current working directory.
 
 ** --overwrite
-overwrite existing files with the same name; by default overwriting is not
+Overwrite existing files with the same name; by default overwriting is not
 allowed.
 
 ** -u,--uncooked
-by default, *mu* transforms the attachment filenames a bit (such as by replacing
+By default, *mu* transforms the attachment filenames a bit (such as by replacing
 spaces by dashes); with this option, leave that to the minimum for creating
 a legal filename in the target directory.
 
-** --matches=<pattern>
-Attachments with filenames matching the pattern will be extracted. The regular
+** --matches _pattern_
+Attachments with filenames matching _pattern_ will be extracted. The regular
 expressions are basic PCRE, and are case-sensitive by default; see
 {{{man-link(pcre,3)}}} for more details.
 
diff --git a/man/mu-find.1.org b/man/mu-find.1.org
index 576e640d3..83e15e462 100644
--- a/man/mu-find.1.org
+++ b/man/mu-find.1.org
@@ -45,15 +45,15 @@ For details on the possible queries, see {{{man-link(mu-query,7)}}}.
 
 * FIND OPTIONS
 
-Note, some of the important options are described in the {{{man-link(mu*,1)}}}
+Note, some of the important options are described in the {{{man-link(mu,1)}}}
 manual page and not here, as they apply to multiple *mu* commands.
 
 The *find*-command has various options that influence the way *mu* displays the
 results. If you don't specify anything, the defaults are *--fields="d f s"*,
 *--sortfield=date* and *--reverse*.
 
-** -f, --fields=<fields>
-specifies a string that determines which fields are shown in the output. This
+** -f, --fields _fields_
+Specifies a string that determines which fields are shown in the output. This
 string consists of a number of characters (such as 's' for subject or 'f' for
 from), which will replace with the actual field in the output. Fields that are
 not known will be output as-is, allowing for some simple formatting.
@@ -86,8 +86,8 @@ The message flags are described in {{{man-link(mu-query,7)}}}. As an example, a
 message which is `seen', has an attachment and is signed would have `asz' as its
 corresponding output string, while an encrypted new message would have `nx'.
 
-** -s, --sortfield=<field> and -z,--reverse
-specify the field to sort the search results by and the direction (i.e.,
+** -s, --sortfield _field_ and -z,--reverse
+Specify the field to sort the search results by and the direction (i.e.,
 `reverse' means that the sort should be reverted - Z-A). Examples include:
 
 #+begin_example
@@ -113,16 +113,16 @@ Note, if you specify a sortfield, by default, messages are sorted in reverse
 (descending) order (e.g., from lowest to highest). This is usually a good
 choice, but for dates it may be more useful to sort in the opposite direction.
 
-** -n, --maxnum=<number>
-If > 0, display maximally that number of entries. If not specified, all matching
-entries are displayed.
+** -n, --maxnum _number_
+If _number_ > 0, display maximally that number of entries. If not specified, all
+matching entries are displayed.
 
-** --summary-len=<number>
-If > 0, use that number of lines of the message to provide a summary.
+** --summary-len _number_
+If _number_ > 0, use that number of lines of the message to provide a summary.
 
-** --format=<plain|links|xml|sexp>
+** --format plain|links|xml|sexp
 
-output results in the specified format:
+Output results in the specified format.
 
 - The default is *plain*, i.e normal output with one line per message.
 - *links* outputs the results as a maildir with symbolic links to the found
@@ -130,10 +130,10 @@ output results in the specified format:
   information).
 - *xml* formats the search results as XML.
 - *sexp* formats the search results as an s-expression as used in Lisp programming
-  environments
+  environments.
 
-** --linksdir=<dir> and -c, --clearlinks
-when using *-format=links*, output the results as a maildir with symbolic links to
+** --linksdir _dir_ and -c, --clearlinks
+When using *--format=links*, output the results as a maildir with symbolic links to
 the found messages. This enables easy integration with mail-clients (see below
 for more information). *mu* will create the maildir if it does not exist yet.
 
@@ -150,9 +150,9 @@ exist yet, it will be created. Note: when *mu* creates a Maildir for these links
 it automatically inserts a _.noindex_ file, to exclude the directory from *mu
 index*.
 
-** --after=<timestamp>
-only show messages whose message files were last modified (*mtime*) after
-=<timestamp>=. =<timestamp>= is a UNIX *time_t* value, the number of seconds since
+** --after _timestamp_
+Only show messages whose message files were last modified (*mtime*) after
+_timestamp_. _timestamp_ is a UNIX *time_t* value, the number of seconds since
 1970-01-01 (in UTC).
 
 From the command line, you can use the *date* command to get this value. For
@@ -163,8 +163,8 @@ could specify
 #+end_example
 This is assuming the GNU *date* command.
 
-** --exec=<command>
-the *--exec* coption causes the =command= to be executed on each matched message;
+** --exec _command_
+The *--exec* coption causes _command_ to be executed on each matched message;
 for example, to see the raw text of all messages matching `milkshake', you could
 use:
 #+begin_example
@@ -175,24 +175,23 @@ which is roughly equivalent to:
 $ mu find milkshake --fields="l" | xargs less
 #+end_example
 
-** -b, --bookmark=<bookmark>
-use a bookmarked search query. Using this option, a query from your bookmark
+** -b, --bookmark _bookmark_
+Use a bookmarked search query. Using this option, a query from your bookmark
 file will be prepended to other search queries. See
 {{{man-link(mu-bookmarks,5)}}} for the details of the bookmarks file.
 
-
 ** -u, --skip-dups
-whenever there are multiple messages with the same message-id field, only show
+Whenever there are multiple messages with the same message-id field, only show
 the first one. This is useful if you have copies of the same message, which is a
 common occurrence when using e.g. Gmail together with *offlineimap*.
 
 ** -r, --include-related
-include messages being referred to by the matched messages -- i.e.. include
+Include messages being referred to by the matched messages -- i.e.. include
 messages that are part of the same message thread as some matched messages. This
 is useful if you want Gmail-style `conversations'.
 
 ** -t, --threads
-show messages in a `threaded' format -- that is, with indentation and arrows
+Show messages in a `threaded' format -- that is, with indentation and arrows
 showing the conversation threads in the list of matching messages. When using
 this, sorting is chronological (by date), based on the newest message in a
 thread.
@@ -215,7 +214,7 @@ The algorithm used for determining the threads is based on Jamie Zawinksi's
 description: http://www.jwz.org/doc/threading.html
 
 ** -a,--analyze
-instead of executing the query, analyze it by show the parse-tree s-expression
+Instead of executing the query, analyze it by show the parse-tree s-expression
 and a stringified version of the Xapian query. This can help users to determine
 how *mu* interprets some query.
 
diff --git a/man/mu-index.1.org b/man/mu-index.1.org
index 5794ffc62..5ddb35b77 100644
--- a/man/mu-index.1.org
+++ b/man/mu-index.1.org
@@ -66,8 +66,7 @@ terminate immediately.
 * INDEX OPTIONS
 
 ** --lazy-check
-
-in lazy-check mode, *mu* does not consider messages for which the time-stamp
+In lazy-check mode, *mu* does not consider messages for which the time-stamp
 (ctime) of the directory they reside in has not changed since the previous
 indexing run. This is much faster than the non-lazy check, but won't update
 messages that have change (rather than having been added or removed), since
@@ -76,12 +75,10 @@ you can run *mu-index* occasionally without *--lazy-check*, to pick up such
 messages.
 
 ** --nocleanup
-
-disable the database cleanup that *mu* does by default after indexing.
+Disable the database cleanup that *mu* does by default after indexing.
 
 ** --reindex
-
-perform a complete reindexing of all the messages in the maildir.
+Perform a complete reindexing of all the messages in the maildir.
 
 #+include: "muhome.inc" :minlevel 2
 
diff --git a/man/mu-init.1.org b/man/mu-init.1.org
index 0850a6ddc..21e46e8a0 100644
--- a/man/mu-init.1.org
+++ b/man/mu-init.1.org
@@ -17,60 +17,53 @@ has completed, you can run *mu index*
 
 * INIT OPTIONS
 
-** -m, --maildir=<maildir>
-
-use =<maildir>= as the root-maildir.
+** -m, --maildir _maildir_
+Use _maildir_ as the root-maildir.
 
 By default, *mu* uses the *MAILDIR* environment; if it is not set, it uses _~/Maildir_
 if it is an existing directory. If neither of those can be used, the *--maildir*
 option is required; it must be an absolute path (but ~~/~ expansion is
 performed).
 
-** --my-address=<email-address-or-regex>
-
-specifies that some e-mail address is `my-address' (the option can be used
+** --my-address _email-address-or-regex_
+Specifies that some e-mail address is `my-address' (the option can be used
 multiple times). Any message in which at least one of the contact fields
 contains such an address is considered a `personal' messages; this can then be
 used for filtering in {{{man-link(mu-find,1)}}}, {{{man-link(mu-cfind,1)}}} and
 *mu4e*, e.g. to filter-out mailing list messages.
 
-=<email-address-or-regex>= can be either a plain e-mail address (such as
+_email-address-or-regex_ can be either a plain e-mail address (such as
 *foo@example.com*), or a basic PCRE regular-expression (see
 {{{man-link(pcre,3)}}} for details), wrapped in */* (such as
 =/foo-.*@example\\.com/=). Depending on your shell, the argument may need to be
 quoted.
 
-** --ignored-address=<email-address-or-regex>
-
-specifies that some e-mail address is to be ignored from the contacts-cache (the
+** --ignored-address _email-address-or-regex_
+Specifies that some e-mail address is to be ignored from the contacts-cache (the
 option can be used multiple times). Such addresses then cannot be found with
 {{{man-link(mu-cfind,1)}}} or in the Mu4e contacts cache.
 
-=<my-email-address>= can be either a plain e-mail address or a regexp, just like
+_my-email-address_ can be either a plain e-mail address or a regexp, just like
 for the *--my-address* option.
 
-** --max-message-size=<size>
-
-specifies the maximum size for an e-mail message. Usually, the default of
+** --max-message-size _size_
+Specifies the maximum size for an e-mail message. Usually, the default of
 100000000 bytes should be fine.
 
-** --batch-size=<size>
-
-the number of changes after which they are committed to the database; decreasing
+** --batch-size _size_
+The number of changes after which they are committed to the database; decreasing
 the value reduces the memory requirements, at the cost of make indexing
 substantially slower. Usually, the default of 250000 should be fine.
 
 Batch-size 0 is interpreted as `use the default'.
 
 ** --support-ngrams
-
-whether to enable support for using ngrams in indexing and query parsing; this
+Whether to enable support for using ngrams in indexing and query parsing; this
 can be useful for languages without explicit word breaks, such as
 Chinese/Japanese/Korean. See *NGRAM SUPPORT* below for details.
 
 ** --reinit
-
-reinitialize the database from an earlier version; that is, create a new empty
+Reinitialize the database from an earlier version; that is, create a new empty
 database with the existing settings. This cannot be combined with the other *init*
 options.
 
diff --git a/man/mu-mkdir.1.org b/man/mu-mkdir.1.org
index c1587c3b7..6d876098d 100644
--- a/man/mu-mkdir.1.org
+++ b/man/mu-mkdir.1.org
@@ -23,8 +23,8 @@ were created. This is for safety reasons.
 
 * MKDIR OPTIONS
 
-** --mode=<mode>
-set the file access mode for the new maildir(s) as in
+** --mode _mode_
+Set the file access mode for the new maildir(s) as in
 {{{man-link(chmod,1)}}}. The default is 0755.
 
 #+include: "common-options.inc" :minlevel 1
diff --git a/man/mu-move.1.org b/man/mu-move.1.org
index c389c0d9b..36b93d629 100644
--- a/man/mu-move.1.org
+++ b/man/mu-move.1.org
@@ -22,26 +22,22 @@ for *mu*'s database (see *mu info store*).
 
 * MOVE OPTIONS
 
-** --flags=<flags>
-
-specify the new message flags. See *FLAGS* for details.
+** --flags _flags_
+Specify the new message flags. See *FLAGS* for details.
 
 ** --change-name
-
-change the basename of the message file when moving; this can be useful when
+Change the basename of the message file when moving; this can be useful when
 using some external tools such as {{{man-link(mbsync,1)}}} which otherwise get
 confused
 
 ** --update-dups
-
-update the flags of duplicate messages too, where "duplicate messages" are
+Update the flags of duplicate messages too, where "duplicate messages" are
 defined as all message that share the same message-id. Note that the
 Draft/Flagged/Trashed flags are deliberately _not_ changed if you change those on
 the source message.
 
-** --dry-run,-n
-
-print the target filename(s), but don't change anything.
+** -n, --dry-run
+Print the target filename(s), but don't change anything.
 
 Note that with the *--change-name*, the target name is not constant, so you cannot
 use a dry-run to predict the exact name when doing a `real' run.
diff --git a/man/mu-server.1.org b/man/mu-server.1.org
index d003ae6eb..cd401e0fe 100644
--- a/man/mu-server.1.org
+++ b/man/mu-server.1.org
@@ -50,15 +50,12 @@ UTF-8 (in which the s-expressions are encoded).
 * SERVER OPTIONS
 
 ** --commands
+List available commands (and try with *--verbose*).
 
-List available commands (and try with *--verbose*)
-
-** --eval <expression>
-
-Evaluate a mu4e server s-expression
+** --eval _expression_
+Evaluate a mu4e server s-expression.
 
 ** --allow-temp-file
-
 If set, allow for the output of some commands to use temp-files rather than
 directly through the emacs process input/output. This is noticeably faster for
 commands with a lot of output, esp. when the the temp-file uses a in-memory
diff --git a/man/mu-verify.1.org b/man/mu-verify.1.org
index 939143533..e253ff070 100644
--- a/man/mu-verify.1.org
+++ b/man/mu-verify.1.org
@@ -22,11 +22,11 @@ standard-input.
 * VERIFY OPTIONS
 
 ** -r, --auto-retrieve
-attempt to find keys online (see the *auto-key-retrieve* option in the
+Attempt to find keys online (see the *auto-key-retrieve* option in the
 {{{man-link(gnupg,1)}}} documentation).
 
-** decrypt
-attempt to decrypt the message
+** --decrypt
+Attempt to decrypt the message.
 
 #+include: "common-options.inc" :minlevel 1
 
diff --git a/man/mu-view.1.org b/man/mu-view.1.org
index 7dc208177..6f6a8ec58 100644
--- a/man/mu-view.1.org
+++ b/man/mu-view.1.org
@@ -24,27 +24,27 @@ standard-input.
 
 * VIEW OPTIONS
 
-** --format,-o  = <format>
-use the given output format, one of:
+** -o, --format _format_
+Use the given output format, one of:
 
-- *plain* - use the plain-text body; this is the default
-- *html* - use the HTML body
-- *sexp* - show the S-expression representation of the message
+- *plain*: use the plain-text body; this is the default,
+- *html*: use the HTML body,
+- *sexp*: show the S-expression representation of the message.
 
-** --summary-len=<number>
-instead of displaying the full message, output a summary based upon the first
-=<number>= lines of the message.
+** --summary-len _number_
+Instead of displaying the full message, output a summary based upon the first
+_number_ lines of the message.
 
 ** --terminate
-terminate messages with \\​f (=form-feed=) characters when displaying them. This is
+Terminate messages with \\​f (=form-feed=) characters when displaying them. This is
 useful when you want to further process them.
 
 ** --decrypt
-attempt to decrypt encrypted message bodies. This is only possible if *mu*
+Attempt to decrypt encrypted message bodies. This is only possible if *mu*
 was built with crypto-support.
 
 ** --auto-retrieve
-attempt to retrieve crypto-keys automatically from the network, when needed.
+Attempt to retrieve crypto-keys automatically from the network, when needed.
 
 #+include: "common-options.inc" :minlevel 1
 
diff --git a/man/muhome.inc b/man/muhome.inc
index f3414c1be..237cef8ea 100644
--- a/man/muhome.inc
+++ b/man/muhome.inc
@@ -1,5 +1,5 @@
 ** --muhome
-use a non-default directory to store and read the database, write the logs, etc.
+Use a non-default directory to store and read the database, write the logs, etc.
 By default, *mu* uses the XDG Base Directory Specification (e.g. on GNU/Linux this
 defaults to _~/.cache/mu_ and _~/.config/mu_). Earlier versions of *mu* defaulted to
 _~/.mu_, which now requires *--muhome=~/.mu*.

From 737c891a213cab1e9a0ad9a20ad9be19db42a229 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Thu, 25 Jul 2024 19:55:54 +0300
Subject: [PATCH 073/305] mu4e.texi: update build / install instructions

The were outdated.

Fixes #2729.
---
 mu4e/mu4e.texi | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index 911e6318b..f77c94a7f 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -301,13 +301,19 @@ What all that in place, let's build and install @t{mu} and @t{mu4e}.
 Enter the directory where you unpacked or cloned @t{mu}. Then:
 
 @example
-$ ./configure && make
+$ ./autogen.sh && make
 $ sudo make install
 @end example
 
 Note: if you are familiar with @t{meson}, you can of course use its
 commands directly; the @t{make} commands are just a thin wrapper around
-that.
+that; so, this also works:
+
+@example
+$ meson setup build
+$ meson compile -C build
+$ meson install -C build
+@end example
 
 @subsection Installation
 

From 18c9b14c6d9b0bd44aa2f0c2a20685dffb0d0ae9 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Thu, 25 Jul 2024 20:19:11 +0300
Subject: [PATCH 074/305] mu4e.texi: complete half-sentence

Fixes #2723.
---
 mu4e/mu4e.texi | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index f77c94a7f..71d26e9e3 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -1572,9 +1572,12 @@ on the current message. You can specify these actions using the variable
 @code{mu4e-view-actions}; @t{mu4e} defines a number of example actions.
 
 @subsection MIME-part actions
-MIME-part actions allow you to act upon MIME-parts in a message - such
-as attachments.  For now, these actions are defined and documented in
-@code{mu4e-view-mime-part-actions} and see
+MIME-part actions allow you to act upon MIME-parts in a message - such as
+attachments. These actions are defined and documented in
+@code{mu4e-view-mime-part-actions}.
+
+There are a number of built-in actions which may be a good starting point for
+creating your own.
 
 @node MSGV Detaching and reattaching
 @section Detaching and reattaching messages

From c6e8f894c113be7621c06e903d70b39cdd8fef7f Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 27 Jul 2024 09:36:15 +0300
Subject: [PATCH 075/305] test_index_move: extend unit test

Double-check the changed values are seen in a newly opened store.
---
 lib/tests/test-mu-store.cc | 104 ++++++++++++++++++++++---------------
 1 file changed, 62 insertions(+), 42 deletions(-)

diff --git a/lib/tests/test-mu-store.cc b/lib/tests/test-mu-store.cc
index da7f1202d..9b0d59ae7 100644
--- a/lib/tests/test-mu-store.cc
+++ b/lib/tests/test-mu-store.cc
@@ -344,50 +344,70 @@ Yes, that would be excellent.
 
 	 // Index it into a store.
 	 TempDir tempdir;
-	 auto store{Store::make_new(tempdir.path(), tempdir2.path() + "/Maildir")};
-	 assert_valid_result(store);
+	 ::time_t msg3changed{};
+	 Store::Id msg3id;
+
+	 {
+		 auto store{Store::make_new(tempdir.path(), tempdir2.path() + "/Maildir")};
+		 assert_valid_result(store);
+
+		 store->indexer().start({});
+		 size_t n{};
+		 while (store->indexer().is_running()) {
+			 std::this_thread::sleep_for(100ms);
+			 g_assert_cmpuint(n++,<=,25);
+		 }
+		 g_assert_true(!store->indexer().is_running());
+		 const auto& prog{store->indexer().progress()};
+		 g_assert_cmpuint(prog.updated,==,1);
+		 g_assert_cmpuint(store->size(), ==, 1);
+		 g_assert_false(store->empty());
+
+		 // Find the message
+		 auto qr = store->run_query("path:" + tempdir2.path() + "/Maildir/a/new/msg");
+		 assert_valid_result(qr);
+		 g_assert_cmpuint(qr->size(),==,1);
+
+		 const auto msg = qr->begin().message();
+		 g_assert_true(!!msg);
+
+		 // Check the message
+		 const auto oldpath{msg->path()};
+		 assert_equal(msg->subject(), "Re: multi-eq hash tables");
+		 g_assert_true(msg->docid() != 0);
+		 g_debug("%s", msg->sexp().to_string().c_str());
+
+		 // Move the message from new->cur
+		 const auto oldchanged{msg->changed()};
+		 std::this_thread::sleep_for(1s); /* ctime should change */
+		 const auto msgs3 = store->move_message(msg->docid(), {}, Flags::Seen);
+		 assert_valid_result(msgs3);
+		 g_assert_true(msgs3->size() == 1);
+		 auto&& msg3_opt{store->find_message(msgs3->at(0).first/*id*/)};
+		 g_assert_true(!!msg3_opt);
+		 auto&& msg3{std::move(*msg3_opt)};
+		 msg3id = msg3.docid();
+		 assert_equal(msg3.maildir(), "/a");
+		 assert_equal(msg3.path(), tempdir2.path() + "/Maildir/a/cur/msg:2,S");
+		 g_assert_true(::access(msg3.path().c_str(), R_OK)==0);
+		 g_assert_false(::access(oldpath.c_str(), R_OK)==0);
+
+		 // ensure that the changed value was updated properly.
+		 msg3changed = msg->changed();
+		 const auto changeddiff(msg3changed - oldchanged);
+		 g_assert_true(changeddiff > 0 && changeddiff <= 2);
+		 g_assert_cmpuint(store->size(), ==, 1);
+	 }
 
-	 store->indexer().start({});
-	 size_t n{};
-	 while (store->indexer().is_running()) {
-		 std::this_thread::sleep_for(100ms);
-		 g_assert_cmpuint(n++,<=,25);
+	 // ensure the values are properly stored.
+	 {
+		const auto store2{Store::make(tempdir.path())};
+		assert_valid_result(store2);
+		const auto msg4 = store2->find_message(msg3id);
+		g_assert_true(!!msg4);
+		assert_equal(msg4->path(), tempdir2.path() + "/Maildir/a/cur/msg:2,S");
+		g_assert_cmpuint(msg4->changed(), ==, msg3changed);
 	 }
-	 g_assert_true(!store->indexer().is_running());
-	 const auto& prog{store->indexer().progress()};
-	 g_assert_cmpuint(prog.updated,==,1);
-	 g_assert_cmpuint(store->size(), ==, 1);
-	 g_assert_false(store->empty());
-
-	 // Find the message
-	 auto qr = store->run_query("path:" + tempdir2.path() + "/Maildir/a/new/msg");
-	 assert_valid_result(qr);
-	 g_assert_cmpuint(qr->size(),==,1);
-
-	 const auto msg = qr->begin().message();
-	 g_assert_true(!!msg);
-
-	 // Check the message
-	 const auto oldpath{msg->path()};
-	 assert_equal(msg->subject(), "Re: multi-eq hash tables");
-	 g_assert_true(msg->docid() != 0);
-	 g_debug("%s", msg->sexp().to_string().c_str());
-
-	 // Move the message from new->cur
-	 std::this_thread::sleep_for(1s); /* ctime should change */
-	 const auto msgs3 = store->move_message(msg->docid(), {}, Flags::Seen);
-	 assert_valid_result(msgs3);
-	 g_assert_true(msgs3->size() == 1);
-	 auto&& msg3_opt{store->find_message(msgs3->at(0).first/*id*/)};
-	 g_assert_true(!!msg3_opt);
-	 auto&& msg3{std::move(*msg3_opt)};
-
-	 assert_equal(msg3.maildir(), "/a");
-	 assert_equal(msg3.path(), tempdir2.path() + "/Maildir/a/cur/msg:2,S");
-	 g_assert_true(::access(msg3.path().c_str(), R_OK)==0);
-	 g_assert_false(::access(oldpath.c_str(), R_OK)==0);
-
-	 g_debug("%s", msg3.sexp().to_string().c_str());	 g_assert_cmpuint(store->size(), ==, 1);
 }
 
 

From e399fdc8b20924cda7603b131f27b59c9531f3ef Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 27 Jul 2024 12:27:58 +0300
Subject: [PATCH 076/305] IDEAS.org: add idea about encoding-guessing

Fixes #2700
---
 IDEAS.org | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/IDEAS.org b/IDEAS.org
index ea5ed4e2e..b80612495 100644
--- a/IDEAS.org
+++ b/IDEAS.org
@@ -41,6 +41,10 @@ future.
   https://github.com/djcb/mu/issues/301
   https://github.com/djcb/mu/issues/2704
 
+- Try to guess the encodings; sometimes people send messages that e.g., claim
+  they are ISO-8859-1 but actually use windows-1252, resulting in some
+  characters being shown incorrectly. Perhaps best solved by GMime, but maybe mu
+  can do something. https://github.com/djcb/mu/issues/2700
 
 * Done
 

From f1923fff7c97eaf2d6ac182b16cab9dbb8217219 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 27 Jul 2024 16:42:33 +0300
Subject: [PATCH 077/305] build: bump version to 1.12.6

---
 meson.build | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/meson.build b/meson.build
index 265c4a8d1..c7b07fe67 100644
--- a/meson.build
+++ b/meson.build
@@ -17,7 +17,7 @@
 ################################################################################
 # project setup
 project('mu', ['c', 'cpp'],
-        version: '1.12.5',
+        version: '1.12.6',
         meson_version: '>= 0.56.0',
         license: 'GPL-3.0-or-later',
         default_options : [
@@ -28,7 +28,7 @@ project('mu', ['c', 'cpp'],
 
 # hard-code the date here (for reproduciblity); we derive the dates used in e.g.
 # documentation from this.
-mu_date='2024-04-15'
+mu_date='2024-07-27'
 
 # installation paths
 prefixdir = get_option('prefix')
@@ -321,3 +321,7 @@ if gmime_dep.version() == '3.2.13'
   warning('gmime version 3.2.13 detected, which as a decoding bug')
   warning('See: https://github.com/jstedfast/gmime/issues/133')
 endif
+
+# Local Variables:
+# indent-tabs-mode: nil
+# End:

From 68435a1fdf6963d093ff9ac09dafb8a6ca135646 Mon Sep 17 00:00:00 2001
From: Christophe Troestler <Christophe.Troestler@umons.ac.be>
Date: Fri, 2 Aug 2024 22:13:10 +0200
Subject: [PATCH 078/305] Fix the "Next" header menu entry

---
 mu4e/mu4e-headers.el | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mu4e/mu4e-headers.el b/mu4e/mu4e-headers.el
index dd69cb90f..9e5165450 100644
--- a/mu4e/mu4e-headers.el
+++ b/mu4e/mu4e-headers.el
@@ -1007,7 +1007,7 @@ after the end of the search results."
      "--"
      ["Previous" mu4e-headers-prev
       :help "Move to previous header"]
-     ["Next" mu4e-headers-prev
+     ["Next" mu4e-headers-next
       :help "Move to next header"]
      "--"
      ["Mark for move" mu4e-headers-mark-for-move

From 9e3c8ba6c2fc46ff1a3d1eeb5cf0f8ac5bd291b2 Mon Sep 17 00:00:00 2001
From: Christophe Troestler <Christophe.Troestler@umons.ac.be>
Date: Fri, 2 Aug 2024 22:16:21 +0200
Subject: [PATCH 079/305] Doc: Use mu4e-search-toggle-property instead of its
 obsolete alias

---
 mu4e/mu4e.texi | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index 71d26e9e3..412821ae9 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -1093,10 +1093,10 @@ variable @code{mu4e-use-fancy-chars}}, indicating the sort order
 You can change the sort order by clicking the corresponding column with the
 mouse, or with @kbd{M-x mu4e-headers-change-sorting} (@key{O}); note that not
 all fields can be used for sorting. You can toggle threading on/off through
-@kbd{M-x mu4e-headers-toggle-property} or @key{Pt}. For both of these functions,
+@kbd{M-x mu4e-search-toggle-property} or @key{Pt}. For both of these functions,
 unless you provide a prefix argument (@key{C-u}), the current search is updated
 immediately using the new parameters. You can toggle full-search
-(@ref{Searching}) through @kbd{M-x mu4e-headers-toggle-property} as well; or
+(@ref{Searching}) through @kbd{M-x mu4e-search-toggle-property} as well; or
 @key{Pf}.
 
 Note that with threading enabled, the sorting is exclusively by date,
@@ -1941,7 +1941,7 @@ certain folder (maildir).
 Normally, queries return up to @code{mu4e-headers-results-limit} (default: 500)
 results. That is usually more than enough, and makes things significantly
 faster. Sometimes, however, you may want to show @emph{all} results; you can
-enable this with @kbd{M-x mu4e-headers-toggle-property}, or by customizing the
+enable this with @kbd{M-x mu4e-search-toggle-property}, or by customizing the
 variable @code{mu4e-headers-full-search}. This applies to all search commands.
 
 You can also influence the sort order and whether threads are shown or not;
@@ -4132,7 +4132,7 @@ docstring).
 @subsection How can I hide certain messages from the search results?
 See the variables @code{mu4e-headers-hide-predicate} and
 @code{mu4e-headers-hide-enabled}. The latter can be toggled through
-@code{mu4e-headers-toggle-property}.
+@code{mu4e-search-toggle-property}.
 
 For example, to filter out GMail's spam folder, set it to:
 @lisp

From bf49f729151459ded45f225389dff1eedd5377d1 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 3 Aug 2024 14:02:15 +0300
Subject: [PATCH 080/305] mu4e: use mu4e-search-full in doc

mu4e-headers-full-search is obsolete.
---
 mu4e/mu4e.texi | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index 412821ae9..632953d4e 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -1942,7 +1942,7 @@ Normally, queries return up to @code{mu4e-headers-results-limit} (default: 500)
 results. That is usually more than enough, and makes things significantly
 faster. Sometimes, however, you may want to show @emph{all} results; you can
 enable this with @kbd{M-x mu4e-search-toggle-property}, or by customizing the
-variable @code{mu4e-headers-full-search}. This applies to all search commands.
+variable @code{mu4e-search-full}. This applies to all search commands.
 
 You can also influence the sort order and whether threads are shown or not;
 see @ref{Sorting and threading}.

From 3ec3bedbce2ecd5c59da01a45a3315fd4e67a18f Mon Sep 17 00:00:00 2001
From: Christophe Troestler <Christophe.Troestler@umons.ac.be>
Date: Sat, 3 Aug 2024 13:24:05 +0200
Subject: [PATCH 081/305] Make toggling search properties easier to discover

---
 mu4e/mu4e-search.el | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/mu4e/mu4e-search.el b/mu4e/mu4e-search.el
index f42a981d7..daec362b3 100644
--- a/mu4e/mu4e-search.el
+++ b/mu4e/mu4e-search.el
@@ -628,7 +628,9 @@ query before submitting it."
     ["Next query" mu4e-search-next
      :help "Run next query"]
     ["Narrow search" mu4e-search-narrow
-     :help "Narrow the search query"])
+     :help "Narrow the search query"]
+    ["Search properties" mu4e-search-toggle-property
+     :help "Toggle some search properties"])
   "Easy menu items for search.")
 
 (provide 'mu4e-search)

From f01360ae9fefc488fe3e439884fc1499c7bdcdcb Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 4 Aug 2024 22:27:17 +0300
Subject: [PATCH 082/305] lib: commit to disk after indexing

---
 lib/mu-indexer.cc   |  2 ++
 lib/mu-xapian-db.hh | 21 +++++++++++----------
 2 files changed, 13 insertions(+), 10 deletions(-)

diff --git a/lib/mu-indexer.cc b/lib/mu-indexer.cc
index 283a11b89..ec4ef013f 100644
--- a/lib/mu-indexer.cc
+++ b/lib/mu-indexer.cc
@@ -363,6 +363,8 @@ Indexer::Private::scan_worker()
 	}
 
 	completed_ = ::time({});
+	// attempt to commit to disk.
+	store_.xapian_db().request_commit(true);
 	store_.config().set<Mu::Config::Id::LastIndex>(completed_);
 	state_.change_to(IndexState::Idle);
 }
diff --git a/lib/mu-xapian-db.hh b/lib/mu-xapian-db.hh
index 66739e580..27921b777 100644
--- a/lib/mu-xapian-db.hh
+++ b/lib/mu-xapian-db.hh
@@ -445,8 +445,7 @@ public:
 
 
 	/**
-	 * Explicitly request the Xapian DB to be committed to disk. This won't
-	 * do anything when not in a transaction.
+	 * Explicitly request the Xapian DB to be committed to disk
 	 *
 	 * @param force whether to force-commit
 	 */
@@ -464,21 +463,23 @@ public:
 
 private:
 	/**
-	 * To be called after all changes, with DB_LOCKED held.
+	 * To be called with DB_LOCKED held.
 	 */
 	void request_commit(Xapian::WritableDatabase& db, bool force) {
-		// in transaction-mode and enough changes, commit them
-		if (!in_transaction())
-			return;
 		if ((++changes_ < batch_size_) && !force)
 			return;
 		xapian_try([&]{
-			mu_debug("committing transaction with {} changes; "
-				 "forced={}", changes_, force ? "yes" : "no");
-			db.commit_transaction();
+			mu_debug("committing {} changes; transaction={}; "
+				 "forced={}", changes_,
+				 in_transaction() ? "yes" : "no",
+				 force ? "yes" : "no");
+			if (in_transaction()) {
+				db.commit_transaction();
+				in_transaction_ = {};
+			}
 			db.commit();
 			changes_ = 0;
-			in_transaction_ = {};
+
 		});
 	}
 

From 2d7288effa9b3a59da614f9e8f82f355b0e481ee Mon Sep 17 00:00:00 2001
From: Rasmus Buurman <dev@rbuurman.de>
Date: Tue, 6 Aug 2024 15:56:08 +0200
Subject: [PATCH 083/305] Canonicalize init --maildir argument after expanding

Ensure that `maildir` is an absolute and _canonical_ path when user passes
a custom maildir path using `mu init --maildir PATH`
---
 mu/mu-options.cc | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/mu/mu-options.cc b/mu/mu-options.cc
index 9533e9cc4..d01c824e2 100644
--- a/mu/mu-options.cc
+++ b/mu/mu-options.cc
@@ -459,7 +459,8 @@ sub_init(CLI::App& sub, Options& opts)
 	sub.add_option("--maildir,-m", opts.init.maildir, "Top of the maildir")
 		->type_name("<maildir>")
 		->default_val(default_mdir)
-		->transform(ExpandPath, "expand maildir path");
+		->transform(ExpandPath, "expand maildir path")
+		->transform(CanonicalizePath, "canonicalize maildir path");
 	sub.add_option("--my-address", opts.init.my_addresses,
 		       "Personal e-mail address or regexp")
 		->type_name("<address>");

From d7426238bdd92583181cfbd8d0db4a3a83b05af4 Mon Sep 17 00:00:00 2001
From: Eval Exec <execvy@gmail.com>
Date: Thu, 8 Aug 2024 15:47:38 +0800
Subject: [PATCH 084/305] Update mu-store-worker.hh, remove duplicate `;`
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fix gcc warning:
```
mu4e                           pre-build              [26/198] Compiling C++ object lib/libmu.a.p/mu-query-parser.cc.o               34.390111
mu4e                           pre-build              In file included from ../lib/mu-store.hh:34,                                   34.390132
mu4e                           pre-build                               from ../lib/mu-query-parser.hh:25,                            34.390140
mu4e                           pre-build                               from ../lib/mu-query-parser.cc:20:                            34.390146
mu4e                           pre-build              ../lib/mu-store-worker.hh:162:23: warning: extra ‘;’ [-Wpedantic]              34.390152
mu4e                           pre-build                162 |         Store& store_;;                                                34.390166
mu4e                           pre-build                    |                       ^                                                34.390172
mu4e                           pre-build                    |                       -                                                34.390177
mu4e                           pre-build              [27/198] Compiling C++ object lib/libmu.a.p/mu-contacts-cache.cc.o             34.538682
```
---
 lib/mu-store-worker.hh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/mu-store-worker.hh b/lib/mu-store-worker.hh
index 6c6ce83bc..45d0be533 100644
--- a/lib/mu-store-worker.hh
+++ b/lib/mu-store-worker.hh
@@ -159,7 +159,7 @@ private:
 	size_t cleanup_orphans();
 
 	QueueType q_;
-	Store& store_;;
+	Store& store_;
 	std::thread runner_;
 	std::atomic<bool> running_{};
 	SexpCommandHandler sexp_handler_{};

From af6ca080a4d956a0c706f5a01b767435d372ffd6 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Thu, 8 Aug 2024 12:54:42 +0300
Subject: [PATCH 085/305] mu4e: doc fixes

---
 mu4e/mu4e.texi | 37 ++++++++++++++++++++-----------------
 1 file changed, 20 insertions(+), 17 deletions(-)

diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index 632953d4e..d8e3166d4 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -1519,32 +1519,35 @@ MIME-parts that contain files@footnote{Attachments come in two flavors:
 operating on them; everything that specifies a filename is considered an
 attachment}.
 
-To save such attachments as files on your file systems, the @t{mu4e}
-message-view offers the command @code{mu4e-view-save-attachments}; default
-keybinding is @key{e} (think @emph{extract}). After invoking the command, you
-can enter the file names to save, comma-separated, and using the completion
-support. Press @key{RET} to save the chosen files to your file-system.
+To save such attachments as files on your file systems, @t{mu4e}'s message-view
+offers the command @code{mu4e-view-save-attachments}; its default keybinding is
+@key{e} (think @emph{extract}).
 
-With a prefix argument, you get to choose the target-directory, otherwise,
-@t{mu4e} determines it following the variable @t{mu4e-attachment-dir} (which can
-be file-system path or a function; see its docstring for details.
+After invoking the command, you can enter the file names to save,
+comma-separated, with completion support. Press @key{RET} to save the chosen
+files to your file-system.
 
-While completing, @code{mu4e-view-completion-minor-mode} is active, which offers
-@code{mu4e-view-complete-all} (bound to @key{C-c C-a} to complete @emph{all}
-files@footnote{Except when using 'Helm'; in that case, use the Helm-mechanism
-for selecting multiple}.
+@t{mu4e} determines the target directory using the variable
+@t{mu4e-attachment-dir} (which can be either file-system path or a function; see
+its docstring for details. However, you can manually set the target by calling
+@code{mu4e-view-save-attachments} with a prefix argument.
+
+When completing the file names, @code{mu4e-view-completion-minor-mode} is
+active, which offers @code{mu4e-view-complete-all} (bound to @key{C-c C-a} to
+complete @emph{all} files@footnote{Except when using 'Helm'; in that case, use
+the Helm-mechanism for selecting multiple}.
 
 @subsection MIME-parts
 
 Not all MIME-parts are message bodies or attachments, and it can be useful to
-operate on those other parts as well. For that, there is the function
+operate on those other parts as well. For that there is
 @code{mu4e-view-mime-part-action} (default key-binding @key{A}). You can pass
-the number of the MIME-pars (as seen in the message view) as a prefix argument,
+the number of the MIME-part (as seen in the message view) as a prefix argument;
 otherwise you get to get to choose from a completion menu.
 
-After choosing one or more MIME-parts, you are asked for an action to apply to
-them; see the variable @code{mu4e-view-mime-part-actions} for the possibilities;
-and you can add your own actions as well, see @ref{MIME-part actions} for some
+After choosing one or more MIME-parts, you can specify an action to apply to
+them; see the variable @code{mu4e-view-mime-part-actions} for the possibilities.
+You can add your own actions as well, see @ref{MIME-part actions} for an
 example.
 
 @node MSGV Custom headers

From 52e388923fcc20cd28e2fe048f15073307dd913e Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Fri, 16 Aug 2024 20:17:03 +0200
Subject: [PATCH 086/305] mu4e-view-save-attachments: document limitation

This function assumes that file names are unique; document this
limitation and point users to mu4e-view-mime-part-action.

Fixes #2742
---
 mu4e/mu4e-mime-parts.el | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/mu4e/mu4e-mime-parts.el b/mu4e/mu4e-mime-parts.el
index 73a174269..707ae477d 100644
--- a/mu4e/mu4e-mime-parts.el
+++ b/mu4e/mu4e-mime-parts.el
@@ -282,11 +282,18 @@ Optionally,
 
 (defun mu4e-view-save-attachments (&optional ask-dir)
   "Save files from the current view buffer.
-This applies to all MIME-parts that are \"attachment-like\" (have a filename),
-regardless of their disposition.
+
+This applies to all MIME-parts that are \"attachment-like\" (have
+a filename), regardless of their disposition.
 
 With ASK-DIR is non-nil, user can specify the target-directory; otherwise
-one is determined using `mu4e-attachment-dir'."
+one is determined using `mu4e-attachment-dir'.
+
+This command assumes unique filenames for the attachments, since
+that is how the underlying completion mechanism works. If there
+are duplicates, only one is recognized. For this corner-case, it
+is recommended to use `mu4e-view-mime-part-action' instead, which
+does not have this limitation."
   (interactive "P")
   (let* ((parts (mu4e-view-mime-parts))
          (candidates  (seq-map

From e04d1cf42c0759caf6cf8f0ef25b53f875502fd3 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Fri, 16 Aug 2024 20:28:29 +0200
Subject: [PATCH 087/305] mu4e: mention database-caching in FAQ

As a reason for discrepancies between mu and mu4e results; as per #2741.
---
 mu4e/mu4e.texi | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index d8e3166d4..9b791e1d1 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -4070,6 +4070,11 @@ answers.
 and @t{mu4e} should yield the same results. If they differ, this is
 usually because one of the following reasons:
 @itemize
+@item Database caching:
+changes in @t{mu4e} are not immediately visible in the command-line @t{mu},
+since it can take a while before changes are committed to disk (for performance
+reasons). Note that quitting @t{mu4e} or invoking @t{mu4e-update-mail-and-index}
+and @t{mu4e-update-index} trigger committing to disk as a side-effect.
 @item different options:
 @t{mu4e} defaults to having @t{mu4e-headers-include-related}, and
 @t{mu4e-headers-results-limit} set to 500. However, the command-line

From 806033f1640e1643e9d4eb532ca426f7068d7a81 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Fri, 16 Aug 2024 21:11:44 +0200
Subject: [PATCH 088/305] mu4e-query-items: improve documentation

Possibly useful for #2741.
---
 mu4e/mu4e-query-items.el | 38 ++++++++++++++++++++++++++------------
 1 file changed, 26 insertions(+), 12 deletions(-)

diff --git a/mu4e/mu4e-query-items.el b/mu4e/mu4e-query-items.el
index b2523e799..d7b6ef21e 100644
--- a/mu4e/mu4e-query-items.el
+++ b/mu4e/mu4e-query-items.el
@@ -1,6 +1,6 @@
 ;;; mu4e-query-items.el --- Manage query results -*- lexical-binding: t -*-
 
-;; Copyright (C) 2023 Dirk-Jan C. Binnema
+;; Copyright (C) 2023-2024 Dirk-Jan C. Binnema
 
 ;; Author: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ;; Maintainer: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
@@ -94,8 +94,8 @@ If ITEMS does not yet have a favorite item, pick the first."
 (defvar mu4e--bookmark-items-cached nil "Cached bookmarks query items.")
 (defvar mu4e--maildir-items-cached nil "Cached maildirs query items.")
 
-(declare-function  mu4e-bookmarks "mu4e-bookmarks")
-(declare-function  mu4e-maildir-shortcuts "mu4e-folders")
+(declare-function mu4e-bookmarks "mu4e-bookmarks")
+(declare-function mu4e-maildir-shortcuts "mu4e-folders")
 
 (defun mu4e--query-item-display-counts (item)
   "Get the count display string for some query-data ITEM."
@@ -222,18 +222,32 @@ bookmark or maildir."
    data))
 
 (defun mu4e-query-items (&optional type)
-  "Grab query items of TYPE.
+  "Grab cached information about query items of some TYPE.
 
-TYPE is symbol; either bookmarks or maildirs, or nil for both.
+TYPE is a symbol; either `bookmarks' or `maildirs', or nil for
+both, and returns a list of plists. The information is based on
+the last (cached) information known by mu4e.
 
 This combines:
-     - the latest queries data (i.e., `(mu4e-server-query-items)')
-     - baseline queries data (i.e. `mu4e-baseline')
-   with the combined queries for `(mu4e-bookmarks)' and
-    `(mu4e-maildir-shortcuts)' in bookmarks-compatible plists.
-
-This packages the aggregated information in a format that is convenient
-for use in various places."
+- the latest queries data (i.e., `(mu4e-server-query-items)')
+- baseline queries data (i.e. `mu4e-baseline') with the combined
+  queries for `mu4e-bookmarks' and `mu4e-maildir-shortcuts' in
+  bookmarks-compatible plists.
+
+Currently, the plist contains the following fields:
+- `:name'         - the name of the bookmark or query
+- `:query'        - the associated (unprocessed) query
+- `:count'        - number of matches for the query
+- `:unread'       - number of unread messages for the query
+- `:delta-count'  - change in count since baseline
+- `:delta-unread' - change in unread count since baseline
+- `:favorite'     - non-nil if this is the favorite query
+
+There are some other fields for internal mu4e use, better not use
+those externally.
+
+For the various nuances with the unread count and baseline,
+please refer to info node `(mu4e) Bookmarks and Maildirs'."
   (cond
    ((equal type 'bookmarks)
     (or mu4e--bookmark-items-cached

From 3de2bc04ab7879551baeed341b9abea4cb50af4b Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 17 Aug 2024 11:36:31 +0300
Subject: [PATCH 089/305] mu4e-draft: handle case where draft was not deleted

Ensure draft is removed also when there's no fcc-path. As suggested by
@malb in #2719.
---
 mu4e/mu4e-draft.el | 33 +++++++++++++++++----------------
 1 file changed, 17 insertions(+), 16 deletions(-)

diff --git a/mu4e/mu4e-draft.el b/mu4e/mu4e-draft.el
index ed867a906..bae0df8c1 100644
--- a/mu4e/mu4e-draft.el
+++ b/mu4e/mu4e-draft.el
@@ -440,6 +440,21 @@ appropriate flag at the message forwarded or replied-to."
     (while (search-forward "\n" nil t)
       (put-text-property (1- (point)) (point) 'hard t))))
 
+(defun mu4e--compose-message-sent ()
+  "Mu4e's `message-sent-hook' handling."
+  ;; typically, draft is gone and the sent message appears in sent. Update flags
+  ;; for related messages, i.e. for Forwarded ('Passed') and Replied messages,
+  ;; try to set the appropriate flag at the message forwarded or replied-to.
+  (when-let ((fcc-path (message-field-value "Fcc")))
+    (mu4e--set-parent-flags fcc-path)
+    ;; we end up with a ((buried) buffer here, visiting the
+    ;; fcc-path; not quite sure why. But let's get rid of it (#2681)
+    (when-let ((buf (find-buffer-visiting fcc-path)))
+      (kill-buffer buf)))
+  ;; remove draft
+  (when-let ((draft (buffer-file-name)))
+    (mu4e--server-remove draft)))
+
 (defun mu4e--compose-before-send ()
   "Function called just before sending a message."
   ;; Remove References: if In-Reply-To: is missing.
@@ -450,22 +465,8 @@ appropriate flag at the message forwarded or replied-to."
       (message-remove-header "References")))
   (when use-hard-newlines
     (mu4e--send-harden-newlines))
-  ;; now handle what happens _after_ sending; typically, draft is gone and
-  ;; the sent message appears in sent. Update flags for related messages,
-  ;; i.e. for Forwarded ('Passed') and Replied messages, try to set the
-  ;; appropriate flag at the message forwarded or replied-to.
-  (add-hook 'message-sent-hook
-            (lambda ()
-              (when-let ((fcc-path (message-field-value "Fcc")))
-                (mu4e--set-parent-flags fcc-path)
-                ;; we end up with a ((buried) buffer here, visiting the
-                ;; fcc-path; not quite sure why. But let's get rid of it (#2681)
-                (when-let ((buf (find-buffer-visiting fcc-path)))
-                  (kill-buffer buf))
-                ;; remove draft
-                (when-let ((draft (buffer-file-name)))
-                  (mu4e--server-remove draft))))
-            nil t))
+  ;; now handle what happens _after_ sending
+  (add-hook 'message-sent-hook #'mu4e--compose-message-sent nil t))
 
 ;; overrides for message-* functions
 ;;

From 2bf978ea1dd8cb980b79d4d8ddf0e30825c8e7b3 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 18 Aug 2024 11:36:39 +0300
Subject: [PATCH 090/305] github: update issue templates

---
 .github/ISSUE_TEMPLATE/feature-request.md | 14 +++++++-------
 .github/ISSUE_TEMPLATE/mu-bug-report.md   | 22 +++++++++++++++++-----
 .github/ISSUE_TEMPLATE/mu4e-bug-report.md |  5 ++++-
 3 files changed, 28 insertions(+), 13 deletions(-)

diff --git a/.github/ISSUE_TEMPLATE/feature-request.md b/.github/ISSUE_TEMPLATE/feature-request.md
index 77f019583..19d91d3e8 100644
--- a/.github/ISSUE_TEMPLATE/feature-request.md
+++ b/.github/ISSUE_TEMPLATE/feature-request.md
@@ -1,13 +1,13 @@
 ---
-name: Mu4e Feature request
-about: Suggest an idea for this project
-title: "[mu4e rfe]"
-labels: rfe, mu4e, new
+name: Feature request
+about: Suggest an idea for mu or mu4e
+title: "[RFE]"
+labels: rfe, new
 assignees: ''
-
 ---
-Note, please see the IDEAS.org file in repository root for existing ideas;
-maybe it's already there.
+
+Note, please see the IDEAS.org file in repository root for existing ideas; maybe
+it's already there.
 
 **Is your feature request related to a problem? Please describe.**
 A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
diff --git a/.github/ISSUE_TEMPLATE/mu-bug-report.md b/.github/ISSUE_TEMPLATE/mu-bug-report.md
index ef2b3f4b9..273a498f4 100644
--- a/.github/ISSUE_TEMPLATE/mu-bug-report.md
+++ b/.github/ISSUE_TEMPLATE/mu-bug-report.md
@@ -4,17 +4,29 @@ about: Create a report to help us improve
 title: "[mu bug]"
 labels: bug, mu, new
 assignees: ''
-
 ---
 
 **Describe the bug**
-A clear and concise description of what the bug is, what you expected to happen and what actually happened.
 
-**To Reproduce**
-Detailed steps to reproduce the behavior. If this is about a specific (kind of) message, **always** attach an (anonymized as need) example message.
+Give the bug a good title.
+
+Please provide a clear and concise description of what you expected to happen
+and what actually happened, and follow the steps below.
+
+**How to Reproduce**
+
+Include the exact steps of what you were doing (commands executed etc.). Include
+any relevant logs and outputs.
+
+Does the problem happen each time? Sometimes?
+
+If this is about a specific (kind of) message, please attach an example message
+(anonymized as needed)
 
 **Environment**
 Please describe the versions of OS, Emacs, mu etc. you are using.
 
 **Checklist**
-- [ ] you are running either the latest 1.8.x/1.10.x release or `master` (otherwise, please upgrade).
+- [ ] you are running either the latest 1.10.x/1.12.x release or `master` (otherwise, please upgrade).
+
+Thank you!
diff --git a/.github/ISSUE_TEMPLATE/mu4e-bug-report.md b/.github/ISSUE_TEMPLATE/mu4e-bug-report.md
index 63d857f66..5a3a96541 100644
--- a/.github/ISSUE_TEMPLATE/mu4e-bug-report.md
+++ b/.github/ISSUE_TEMPLATE/mu4e-bug-report.md
@@ -1,6 +1,6 @@
 ---
 name: Mu4e Bug Report
-about: Create a report to help us improve
+about: Create a report to help us improve mu4e
 title: "[mu4e bug]"
 labels: bug, mu4e, new
 assignees: ''
@@ -21,6 +21,9 @@ any relevant logs and outputs:
 - Best start from `emacs -Q`, and load a minimal `mu4e` setup; describe the steps
   that lead up to the bug.
 - Does the problem happen each time? Sometimes?
+
+- Try some small variations of what you were doing. Does it make a difference?
+
 - If this is about a specific (kind of) message, attach an example message.
   (Open the message, press `.` (`mu4e-view-raw-message`), then `C-x C-w` and
   attach. Anonymize as needed, all that matters is that the issue still

From 6092a26d0273d9852fd6e7188751689a78d532a2 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 18 Aug 2024 11:36:52 +0300
Subject: [PATCH 091/305] IDEAS.org: move guile revamp

---
 IDEAS.org | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/IDEAS.org b/IDEAS.org
index b80612495..29ee0ebe7 100644
--- a/IDEAS.org
+++ b/IDEAS.org
@@ -46,6 +46,11 @@ future.
   characters being shown incorrectly. Perhaps best solved by GMime, but maybe mu
   can do something. https://github.com/djcb/mu/issues/2700
 
+- Revamp the Guile support; mu has support Guile scripting for a long time, but
+  it's gone a bit stale, and the API is not very nice. It'd be nice to revamp
+  this support, so it becomes more widely useful.
+  https://github.com/djcb/mu/issues/1982
+
 * Done
 
 - Support mu4e-mark-handle-when also for when leaving emacs

From c58eacc0d514f12c79259811396ca3a32c4a73b4 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 18 Aug 2024 19:50:19 +0300
Subject: [PATCH 092/305] mu4e: whitespace / typo fixes

---
 mu4e/mu4e-compose.el      | 24 ++++++++++++------------
 mu4e/mu4e-draft.el        |  2 +-
 mu4e/mu4e-notification.el | 39 +++++++++++++++++++++++++++++++--------
 mu4e/mu4e.el              |  7 +++++--
 4 files changed, 49 insertions(+), 23 deletions(-)

diff --git a/mu4e/mu4e-compose.el b/mu4e/mu4e-compose.el
index f2b6f890e..760d2f4f6 100644
--- a/mu4e/mu4e-compose.el
+++ b/mu4e/mu4e-compose.el
@@ -438,18 +438,18 @@ variables ‘message-forward-as-mime’ and
 
 ;;;###autoload
 (defun mu4e-compose-edit()
-         "Edit an existing draft message."
-         (interactive)
-         (let* ((msg (mu4e-message-at-point)))
-           (unless  (member 'draft (mu4e-message-field msg :flags))
-             (mu4e-warn "Cannot edit non-draft messages"))
-           (mu4e--draft
-            'edit
-            (lambda ()
-              (with-current-buffer
-                  (find-file-noselect (mu4e-message-readable-path msg))
-                (mu4e--delimit-headers)
-                (current-buffer))))))
+  "Edit an existing draft message."
+  (interactive)
+  (let* ((msg (mu4e-message-at-point)))
+    (unless  (member 'draft (mu4e-message-field msg :flags))
+      (mu4e-warn "Cannot edit non-draft messages"))
+    (mu4e--draft
+     'edit
+     (lambda ()
+       (with-current-buffer
+           (find-file-noselect (mu4e-message-readable-path msg))
+         (mu4e--delimit-headers)
+         (current-buffer))))))
 
 ;;;###autoload
 (defun mu4e-compose-resend (address)
diff --git a/mu4e/mu4e-draft.el b/mu4e/mu4e-draft.el
index bae0df8c1..cef2033b7 100644
--- a/mu4e/mu4e-draft.el
+++ b/mu4e/mu4e-draft.el
@@ -244,7 +244,7 @@ BASE-NAME is the base filename without any Maildir decoration."
      (format "%s%s2,DS" base-name mu4e-maildir-info-delimiter))))
 
 (defun mu4e--fcc-path (base-name &optional parent)
-  "Construct a Fcc: path, based on PARENT and `mu4e-sent-messages-behavior'.
+  "Construct an Fcc: path, based on PARENT and `mu4e-sent-messages-behavior'.
 
 PARENT is either nil or the original message (being replied
 to/forwarded etc.), and is used to determine the sent folder,
diff --git a/mu4e/mu4e-notification.el b/mu4e/mu4e-notification.el
index 9ad96384e..1d47742f4 100644
--- a/mu4e/mu4e-notification.el
+++ b/mu4e/mu4e-notification.el
@@ -1,6 +1,24 @@
-;;; mu4e-notification.el --- Showing mail notifications -*- lexical-binding: t-*-
-;;
-;; Copyright (C) 1996-2023 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+;;; mu4e-notification.el --- Mail notifications -*- lexical-binding: t-*-
+
+;; Copyright (C) 2023-2024 Dirk-Jan C. Binnema
+
+;; Author: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+;; Maintainer: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+
+;; SPDX-License-Identifier: GPL-3.0-or-later
+
+;; mu4e is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; mu4e is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with mu4e.  If not, see <http://www.gnu.org/licenses/>.
 
 ;;; Commentary:
 ;;; Generic support for showing new-mail notifications.
@@ -10,11 +28,13 @@
 (require 'mu4e-query-items)
 (require 'mu4e-bookmarks)
 
-;; for emacs' built-in desktop notifications to work, we need
-;; dbus
+;; for Emacs' built-in desktop notifications to work, we need
+;; DBus
 (when (featurep 'dbus)
   (require 'notifications))
 
+;;; Options
+
 (defcustom mu4e-notification-filter #'mu4e--default-notification-filter
   "Function for determining if a notification is to be emitted.
 
@@ -38,6 +58,9 @@ now."
   :type 'function
   :group 'mu4e-notification)
 
+
+;;; Implementation
+
 (defvar mu4e--notification-id nil
   "The last notification id, so we can replace it.")
 
@@ -45,8 +68,8 @@ now."
   "Return t if a notification should be shown.
 
 This default implementation does so when the number of unread
-messages changed since the last notification and it is greater
-than zero."
+messages changed since the last notification and is greater than
+zero."
   (when-let* ((fav (mu4e-bookmark-favorite))
               (delta-unread (plist-get fav :delta-unread)))
     (when (and (> delta-unread 0)
@@ -57,7 +80,7 @@ than zero."
 
 (defun mu4e--default-notification-function (&optional _)
   "Default function for handling notifications.
-The default implementation uses emacs' built-in dbus-notification
+The default implementation uses Emacs' built-in DBus-notification
 support."
   (when-let* ((fav (mu4e-bookmark-favorite))
               (title "mu4e found new mail")
diff --git a/mu4e/mu4e.el b/mu4e/mu4e.el
index 8efc7b68d..621b21d12 100644
--- a/mu4e/mu4e.el
+++ b/mu4e/mu4e.el
@@ -1,12 +1,14 @@
 ;;; mu4e.el --- Mu4e, the mu mail user agent -*- lexical-binding: t -*-
 
-;; Copyright (C) 2011-2023 Dirk-Jan C. Binnema
+;; Copyright (C) 2011-2024 Dirk-Jan C. Binnema
 
 ;; Author: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ;; Maintainer: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+
+;; Homepage: https://www.djcbsoftware.nl/code/mu/
 ;; Keywords: email
 
-;; This file is not part of GNU Emacs.
+;; SPDX-License-Identifier: GPL-3.0-or-later
 
 ;; mu4e is free software: you can redistribute it and/or modify
 ;; it under the terms of the GNU General Public License as published by
@@ -24,6 +26,7 @@
 ;;; Commentary:
 
 ;;; Code:
+
 (require 'mu4e-obsolete)
 
 (require 'mu4e-vars)

From 407c6ed4d106e3e5d01184838c6a6ed899f686d2 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Wed, 21 Aug 2024 06:18:37 +0300
Subject: [PATCH 093/305] xapian-db: improve errors, fix warnings

---
 lib/mu-xapian-db.cc |  9 +--------
 lib/mu-xapian-db.hh | 25 ++++++++++++++++++-------
 2 files changed, 19 insertions(+), 15 deletions(-)

diff --git a/lib/mu-xapian-db.cc b/lib/mu-xapian-db.cc
index ddc2c115c..bd5f817c3 100644
--- a/lib/mu-xapian-db.cc
+++ b/lib/mu-xapian-db.cc
@@ -51,12 +51,6 @@ XapianDb::read_only() const
 	return !std::holds_alternative<Xapian::WritableDatabase>(db_);
 }
 
-const std::string&
-XapianDb::path() const
-{
-	return path_;
-}
-
 void
 XapianDb::set_timestamp(const std::string_view key)
 {
@@ -102,8 +96,7 @@ make_db(const std::string& db_path, Flavor flavor)
 XapianDb::XapianDb(const std::string& db_path, Flavor flavor):
 	path_(make_path(db_path, flavor)),
 	db_(make_db(path_, flavor)),
-	batch_size_{Config(*this).get<Config::Id::BatchSize>()} // default
-{
+	batch_size_{Config(*this).get<Config::Id::BatchSize>()/*default*/} {
 	if (flavor == Flavor::CreateOverwrite)
 		set_timestamp(MetadataIface::created_key);
 
diff --git a/lib/mu-xapian-db.hh b/lib/mu-xapian-db.hh
index 27921b777..24dbf5934 100644
--- a/lib/mu-xapian-db.hh
+++ b/lib/mu-xapian-db.hh
@@ -50,6 +50,8 @@ template <typename Func> void
 xapian_try(Func&& func) noexcept
 try {
 	func();
+} catch (const Mu::Error& me) {
+	mu_critical("{}: mu error '{}'", __func__, me.what());
 } catch (const Xapian::Error& xerr) {
 	mu_critical("{}: xapian error '{}'", __func__, xerr.get_msg());
 } catch (const std::runtime_error& re) {
@@ -64,6 +66,9 @@ template <typename Func, typename Default = std::invoke_result<Func>> auto
 xapian_try(Func&& func, Default&& def) noexcept -> std::decay_t<decltype(func())>
 try {
 	return func();
+} catch (const Mu::Error& me) {
+	mu_critical("{}: mu error '{}'", __func__, me.what());
+	return static_cast<Default>(def);
 } catch (const Xapian::DocNotFoundError& xerr) {
 	return static_cast<Default>(def);
 } catch (const Xapian::Error& xerr) {
@@ -84,6 +89,9 @@ template <typename Func> auto
 xapian_try_result(Func&& func) noexcept -> std::decay_t<decltype(func())>
 try {
 	return func();
+
+} catch (const Mu::Error& me) {
+	return Err(std::move(me));
 } catch (const Xapian::DatabaseNotFoundError& nferr) {
 	return Err(Error{Error::Code::Xapian, "failed to open database"}.
 		   add_hint("Try (re)creating using `mu init'"));
@@ -128,13 +136,13 @@ struct MetadataIface {
 
 
 /// In-memory db
-struct MemDb: public MetadataIface {
+struct MemDb final: public MetadataIface {
 	/**
 	 * Create a new memdb
 	 *
 	 * @param readonly read-only? (for testing)
 	 */
-	MemDb(bool readonly=false):read_only_{readonly} {}
+	explicit MemDb(bool readonly=false):read_only_{readonly} {}
 
 	/**
 	 * Set some metadata
@@ -188,7 +196,7 @@ private:
 /**
  * Fairly thin wrapper around Xapian::Database and Xapian::WritableDatabase
  */
-class XapianDb: public MetadataIface {
+class XapianDb final: public MetadataIface {
 public:
 	/**
 	 * Type of database to create.
@@ -211,8 +219,9 @@ public:
 	/**
 	 * DTOR
 	 */
-	~XapianDb() {
-		if (!read_only())
+	~XapianDb() override {
+		// shouldn't use read_only() here, since that's virtual.
+		if (std::holds_alternative<Xapian::WritableDatabase>(db_))
 			request_commit(true/*force*/);
 		mu_debug("closing db");
 	}
@@ -237,7 +246,9 @@ public:
 	 *
 	 * @return path to database
 	 */
-	const std::string& path() const;
+	const std::string& path() const {
+		return path_;
+	}
 
 	/**
 	 * Get a description of the Xapian database
@@ -500,7 +511,7 @@ private:
 	Xapian::WritableDatabase& wdb();
 
 	std::string path_;
-	DbType	db_;
+	DbType db_;
 	size_t changes_{};
 	bool in_transaction_{};
 	size_t batch_size_;

From 687db1aed6dd516cb2806bdc501d225e0a6d0459 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Wed, 21 Aug 2024 06:19:35 +0300
Subject: [PATCH 094/305] mu-server: cosmetic

---
 lib/mu-server.cc | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/lib/mu-server.cc b/lib/mu-server.cc
index 62c9ca0c6..9d21cab25 100644
--- a/lib/mu-server.cc
+++ b/lib/mu-server.cc
@@ -452,8 +452,7 @@ Server::Private::invoke(const std::string& expr) noexcept
 			throw res.error();
 
 	} catch (const Mu::Error& me) {
-		output_sexp(make_error(me.code(), mu_format("{}",
-							    me.what())));
+		output_sexp(make_error(me.code(), mu_format("{}", me.what())));
 		keep_going_ = true;
 	} catch (const Xapian::Error& xerr) {
 		output_sexp(make_error(Error::Code::Internal,

From 79dd15424b80aedba665a7f997776a65d971e3d7 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Wed, 21 Aug 2024 19:27:49 +0300
Subject: [PATCH 095/305] mu4e-compose: fix mu4e-compose-captured-message from
 sans-subject

In some but not all cases, a missing subject yielded a description=
without anything else.

Let's avoid that.

Fixes #2746.
---
 mu4e/mu4e-compose.el | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

diff --git a/mu4e/mu4e-compose.el b/mu4e/mu4e-compose.el
index 760d2f4f6..11ab2710d 100644
--- a/mu4e/mu4e-compose.el
+++ b/mu4e/mu4e-compose.el
@@ -96,16 +96,19 @@ This multiplexes the `message-mode' hooks `message-send-actions',
 (defvar mu4e-captured-message)
 (defun mu4e-compose-attach-captured-message ()
   "Insert the last captured message file as an attachment.
-Messages are captured with `mu4e-action-capture-message'."
+
+Messages are expect to have been captured earlier with
+`mu4e-action-capture-message'. Note: this is unrelated to
+`org-mode' capturing."
   (interactive)
   (if-let* ((msg mu4e-captured-message)
-            (path (plist-get msg :path))
-            (path (and (file-exists-p path) path)))
-      (mml-attach-file
-       path
-       "message/rfc822"
-       (or (plist-get msg :subject) "No subject")
-       "attachment")
+         (path (plist-get msg :path))
+         (path (and (file-exists-p path) path))
+         (descr (or (plist-get msg :subject) ""))
+         (descr
+          (if (and (stringp descr) (not (string-empty-p descr)))
+              descr "No subject")))
+    (mml-attach-file path "message/rfc822" descr "attachment")
     (mu4e-warn "No valid message has been captured")))
 
 ;; Go to bottom / top

From c28bfe04e177b1fce4aa9b1d6159c8412f1a8bdc Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Thu, 22 Aug 2024 22:34:34 +0300
Subject: [PATCH 096/305] message: detect top-level smime parts + test

Fixes #2745
---
 lib/message/mu-message.cc     | 45 +++++++++-------
 lib/message/mu-mime-object.hh | 25 +++++++--
 lib/tests/test-mu-msg.cc      | 96 +++++++++++++++++++++++++----------
 3 files changed, 119 insertions(+), 47 deletions(-)

diff --git a/lib/message/mu-message.cc b/lib/message/mu-message.cc
index 46063cfe5..111eef9fc 100644
--- a/lib/message/mu-message.cc
+++ b/lib/message/mu-message.cc
@@ -484,6 +484,28 @@ handle_encrypted(const MimeMultipartEncrypted& part, Message::Private& info)
 		handle_object(part, res->first, info);
 }
 
+static void
+maybe_handle_pkcs7(const MimeObject& obj, Message::Private& info)
+{
+	if (obj.is_mime_application_pkcs7_mime()) {
+		MimeApplicationPkcs7Mime smime(obj);
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wswitch-enum"
+		// CompressedData, CertsOnly, Unknown
+		switch (smime.smime_type()) {
+		case Mu::MimeApplicationPkcs7Mime::SecureMimeType::SignedData:
+			info.flags |= Flags::Signed;
+			break;
+		case Mu::MimeApplicationPkcs7Mime::SecureMimeType::EnvelopedData:
+			info.flags |= Flags::Encrypted;
+			break;
+		default:
+			break;
+		}
+#pragma GCC diagnostic pop
+	}
+}
+
 
 static void
 handle_object(const MimeObject& parent,
@@ -508,23 +530,8 @@ handle_object(const MimeObject& parent,
 		/* FIXME: An encrypted part might be signed at the same time.
 		 *        In that case the signed flag is lost. */
 		info.flags |= Flags::Encrypted;
-	} else if (obj.is_mime_application_pkcs7_mime()) {
-		MimeApplicationPkcs7Mime smime(obj);
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wswitch-enum"
-		// CompressedData, CertsOnly, Unknown
-		switch (smime.smime_type()) {
-		case Mu::MimeApplicationPkcs7Mime::SecureMimeType::SignedData:
-			info.flags |= Flags::Signed;
-			break;
-		case Mu::MimeApplicationPkcs7Mime::SecureMimeType::EnvelopedData:
-			info.flags |= Flags::Encrypted;
-			break;
-		default:
-			break;
-		}
-#pragma GCC diagnostic pop
-	}
+	} else
+		maybe_handle_pkcs7(obj, info);
 }
 
 /**
@@ -548,6 +555,10 @@ process_message(const MimeMessage& mime_msg, const std::string& path,
 			info.flags |= Flags::Unread;
 	}
 
+	// handle top-level
+	if (const auto mpart = mime_msg.mime_part(); mpart)
+		maybe_handle_pkcs7(*mpart, info);
+
 	// parts
 	mime_msg.for_each([&](auto&& parent, auto&& child_obj) {
 		handle_object(parent, child_obj, info);
diff --git a/lib/message/mu-mime-object.hh b/lib/message/mu-mime-object.hh
index bfb2867f5..20154069c 100644
--- a/lib/message/mu-mime-object.hh
+++ b/lib/message/mu-mime-object.hh
@@ -171,9 +171,6 @@ private:
 };
 
 
-
-
-
 
 /**
  * Thin wrapper around a GMimeContentType
@@ -200,6 +197,15 @@ struct MimeContentType: public Object {
 		return g_mime_content_type_is_type(self(), type.c_str(),
 						   subtype.c_str());
 	}
+
+	Option<std::string> parameter(const std::string& name) const noexcept {
+		const char *param{g_mime_content_type_get_parameter(self(), name.c_str())};
+		if (!param || !param[0])
+			return Nothing;
+		else
+			return Some(std::string{param});
+	}
+
 private:
 	GMimeContentType* self() const {
 		return reinterpret_cast<GMimeContentType*>(object());
@@ -929,6 +935,19 @@ public:
 			throw std::runtime_error("not a mime-message");
 	}
 
+	/**
+	 * Get the top-level MIME-part or Nothing if there is none
+	 *
+	 * @return MIME-part of nothing
+	 */
+	Option<MimeObject> mime_part() const noexcept {
+		auto obj = g_mime_message_get_mime_part(self());
+		if (!obj)
+			return Nothing;
+		else
+			return MimeObject{obj};
+	}
+
 	/**
 	 * Make a MimeMessage from a file
 	 *
diff --git a/lib/tests/test-mu-msg.cc b/lib/tests/test-mu-msg.cc
index 1e5d82dc2..abf16fff2 100644
--- a/lib/tests/test-mu-msg.cc
+++ b/lib/tests/test-mu-msg.cc
@@ -1,5 +1,5 @@
 /*
-** Copyright (C) 2008-2022 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2008-2024 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify it
 ** under the terms of the GNU General Public License as published by the
@@ -58,7 +58,7 @@ assert_contacts_equal(const Contacts& contacts,
 
 
 static void
-test_mu_msg_01(void)
+test_mu_msg_01()
 {
 	auto msg{Message::make_from_path(MU_TESTMAILDIR4 "/1220863042.12663_1.mindcrime!2,S")
 		.value()};
@@ -84,7 +84,7 @@ test_mu_msg_01(void)
 }
 
 static void
-test_mu_msg_02(void)
+test_mu_msg_02()
 {
 	auto msg{Message::make_from_path(MU_TESTMAILDIR4 "/1220863087.12663_19.mindcrime!2,S")
 		.value()};
@@ -110,7 +110,7 @@ test_mu_msg_02(void)
 }
 
 static void
-test_mu_msg_03(void)
+test_mu_msg_03()
 {
 	//const GSList* params;
 
@@ -135,7 +135,7 @@ test_mu_msg_03(void)
 }
 
 static void
-test_mu_msg_04(void)
+test_mu_msg_04()
 {
 	auto msg{Message::make_from_path(MU_TESTMAILDIR4 "/mail5").value()};
 
@@ -152,7 +152,7 @@ test_mu_msg_04(void)
 }
 
 static void
-test_mu_msg_multimime(void)
+test_mu_msg_multimime()
 {
 	auto msg{Message::make_from_path(MU_TESTMAILDIR4 "/multimime!2,FS").value()};
 
@@ -163,7 +163,7 @@ test_mu_msg_multimime(void)
 }
 
 static void
-test_mu_msg_flags(void)
+test_mu_msg_flags()
 {
 	std::array<std::pair<std::string, Flags>, 2> tests= {{
 			{MU_TESTMAILDIR4 "/multimime!2,FS",
@@ -181,7 +181,7 @@ test_mu_msg_flags(void)
 }
 
 static void
-test_mu_msg_umlaut(void)
+test_mu_msg_umlaut()
 {
 	auto msg{Message::make_from_path(MU_TESTMAILDIR4 "/1305664394.2171_402.cthulhu!2,")
 		.value()};
@@ -196,7 +196,7 @@ test_mu_msg_umlaut(void)
 }
 
 static void
-test_mu_msg_references(void)
+test_mu_msg_references()
 {
 	auto msg{Message::make_from_path(MU_TESTMAILDIR4 "/1305664394.2171_402.cthulhu!2,")
 		.value()};
@@ -213,7 +213,7 @@ test_mu_msg_references(void)
 }
 
 static void
-test_mu_msg_references_dups(void)
+test_mu_msg_references_dups()
 {
 	auto msg{Message::make_from_path(MU_TESTMAILDIR4 "/1252168370_3.14675.cthulhu!2,S")
 		.value()};
@@ -232,7 +232,7 @@ test_mu_msg_references_dups(void)
 }
 
 static void
-test_mu_msg_references_many(void)
+test_mu_msg_references_many()
 {
 	auto msg{Message::make_from_path(MU_TESTMAILDIR2 "/bar/cur/181736.eml")
 		.value()};
@@ -256,7 +256,7 @@ test_mu_msg_references_many(void)
 }
 
 static void
-test_mu_msg_tags(void)
+test_mu_msg_tags()
 {
 	auto msg{Message::make_from_path(MU_TESTMAILDIR4 "/mail1").value()};
 
@@ -278,7 +278,7 @@ test_mu_msg_tags(void)
 }
 
 static void
-test_mu_msg_comp_unix_programmer(void)
+test_mu_msg_comp_unix_programmer()
 {
 	auto msg{Message::make_from_path(MU_TESTMAILDIR4 "/181736.eml").value()};
 
@@ -309,13 +309,53 @@ test_mu_msg_comp_unix_programmer(void)
 }
 
 static void
-test_mu_str_prio_01(void)
+test_mu_str_prio_01()
 {
 	g_assert_true(priority_name(Priority::Low) == "low");
 	g_assert_true(priority_name(Priority::Normal) == "normal");
 	g_assert_true(priority_name(Priority::High) == "high");
 }
 
+
+static void
+test_mu_smime()
+{
+	const auto txt =
+R"(Return-Path: me@privacy.net
+From: Me <me@privacy.net>
+To: Me <me@privacy.net>
+Subject: smime
+Date: Mon, 19 Aug 2024 09:46:10 -0500
+Message-ID: <m2a5h8r2od.fsf@mitre.org>
+Content-Type: application/pkcs7-mime;
+ smime-type=enveloped-data;
+ name=smime.p7m
+Content-Transfer-Encoding: base64
+Content-Disposition: attachment; filename=smime.p7m
+MIME-Version: 1.0
+X-TUID: 9ipTl5lnIK+/
+
+MIAGCSqGSIb3DQEHA6CAMIACAQAxggGVMIIBkQIBADB5MHExCzAJBgNVBAYTAlVTMRAwDgYDVQQK
+EwdFbnRydXN0MSIwIAYDVQQLExlDZXJ0aWZpY2F0aW9uIEF1dGhvcml0aWVzMSwwKgYDVQQLEyNF
+bnRydXN0IE5GSSBNZWRpdW0gQXNzdXJhbmNlIFNTUCBDQQIEYdtv3DANBgkqhkiG9w0BAQEFAASC
+AQB8f86oe55rCRqzwbixv4QxWQdNsP8luhGVpDv7ojDd5qMhV30MDtM64gxqagPk44ZfaAA2NutT
+vPiWOxUp8FZYN4aNAQy18KMB5G+w2xFdbXrWMNvwXdoLOcMkxD2LF7jJyIT2hUQfBWffGXvlxiSE
+8HsAQKggmchkVJgNSMvIenXzFGhDXg9OVkRvxV/3zfbmF/0jF3e5DbjvW3Qyclidpg/H1zM2iuYE
+BMPdStvWRAkQL8sxOF0XVYjaCd0Y+crK7FwHS923vTNFxIyEaWdKD7HmuLTxVxaGAZpuRPwI/Vbj
+t0k68twxZ4sCUISxAkuvPYVntEwNjqxtOs6zdzq/MIAGCSqGSIb3DQEHATAdBglghkgBZQMEASoE
+EH4y0ZsEAM4pNRvjMhRTnIiggAQgnUUkL7jAwlLwDAsbqCdBTnqz2moSkhE9F/1Qqy/jXYwEEFYW
+k+ZGGoQ0v8b7RwmyskMAAAAAAAAAAAAA
+)";
+	const auto msg{Message::make_from_text(txt, "boo/cur/msg2:2,S")};
+	assert_valid_result(msg);
+
+	assert_equal(msg->subject(), "smime");
+
+	assert_equal("Sxa", to_string(msg->flags()));
+	g_assert_true(msg->flags() == (Flags::Seen|Flags::Encrypted|Flags::HasAttachment));
+}
+
+
 G_GNUC_UNUSED static gboolean
 ignore_error(const char* log_domain, GLogLevelFlags log_level, const gchar* msg, gpointer user_data)
 {
@@ -331,23 +371,25 @@ main(int argc, char* argv[])
 	g_test_init(&argc, &argv, NULL);
 
 	/* mu_msg_str_date */
-	g_test_add_func("/mu-msg/mu-msg-01", test_mu_msg_01);
-	g_test_add_func("/mu-msg/mu-msg-02", test_mu_msg_02);
-	g_test_add_func("/mu-msg/mu-msg-03", test_mu_msg_03);
-	g_test_add_func("/mu-msg/mu-msg-04", test_mu_msg_04);
-	g_test_add_func("/mu-msg/mu-msg-multimime", test_mu_msg_multimime);
+	g_test_add_func("/msg/mu-msg-01", test_mu_msg_01);
+	g_test_add_func("/msg/mu-msg-02", test_mu_msg_02);
+	g_test_add_func("/msg/mu-msg-03", test_mu_msg_03);
+	g_test_add_func("/msg/mu-msg-04", test_mu_msg_04);
+	g_test_add_func("/msg/mu-msg-multimime", test_mu_msg_multimime);
+
+	g_test_add_func("/msg/mu-msg-flags", test_mu_msg_flags);
 
-	g_test_add_func("/mu-msg/mu-msg-flags", test_mu_msg_flags);
+	g_test_add_func("/msg/mu-msg-tags", test_mu_msg_tags);
+	g_test_add_func("/msg/mu-msg-references", test_mu_msg_references);
+	g_test_add_func("/msg/mu-msg-references_dups", test_mu_msg_references_dups);
+	g_test_add_func("/msg/mu-msg-references_many", test_mu_msg_references_many);
 
-	g_test_add_func("/mu-msg/mu-msg-tags", test_mu_msg_tags);
-	g_test_add_func("/mu-msg/mu-msg-references", test_mu_msg_references);
-	g_test_add_func("/mu-msg/mu-msg-references_dups", test_mu_msg_references_dups);
-	g_test_add_func("/mu-msg/mu-msg-references_many", test_mu_msg_references_many);
+	g_test_add_func("/msg/mu-msg-umlaut", test_mu_msg_umlaut);
+	g_test_add_func("/msg/mu-msg-comp-unix-programmer", test_mu_msg_comp_unix_programmer);
 
-	g_test_add_func("/mu-msg/mu-msg-umlaut", test_mu_msg_umlaut);
-	g_test_add_func("/mu-msg/mu-msg-comp-unix-programmer", test_mu_msg_comp_unix_programmer);
+	g_test_add_func("/msg/mu-smime", test_mu_smime);
 
-	g_test_add_func("/mu-str/mu-str-prio-01", test_mu_str_prio_01);
+	g_test_add_func("/str/mu-str-prio-01", test_mu_str_prio_01);
 
 	rv = g_test_run();
 

From 1930d4b663fb01fe2338e87eee1c70700e2168c5 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Thu, 22 Aug 2024 22:59:46 +0300
Subject: [PATCH 097/305] mu4e-view: fallback to raw view for unreadable
 messages

So users can at least see _something_...
---
 mu4e/mu4e-view.el | 22 ++++++++++++----------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/mu4e/mu4e-view.el b/mu4e/mu4e-view.el
index c656ce0f2..60608dfe6 100644
--- a/mu4e/mu4e-view.el
+++ b/mu4e/mu4e-view.el
@@ -134,7 +134,7 @@ Then, display the results."
                      ((mu4e-current-buffer-type-p 'view)
                       (when (mu4e--view-detached-p (current-buffer))
                         (mu4e-error
-                         "Cannot navigate in a detached view buffer."))
+                         "Cannot navigate in a detached view buffer"))
                       (mu4e-get-headers-buffer))
                      ;; fallback; but what would trigger this?
                      (t (mu4e-get-headers-buffer))))
@@ -235,9 +235,10 @@ If this succeeds, return the new docid. Otherwise, return nil."
 ;;; Interactive functions
 (defun mu4e-view-action (&optional msg)
   "Ask user for some action to apply on MSG, then do it.
-If MSG is nil apply action to message returned
-bymessage-at-point.  The actions are specified in
-`mu4e-view-actions'."
+If MSG is nil apply action to message returned by
+`mu4e-message-at-point'.
+
+ The actions are specified in `mu4e-view-actions'."
   (interactive)
   (let* ((msg (or msg (mu4e-message-at-point)))
          (actionfunc (mu4e-read-option "Action: " mu4e-view-actions)))
@@ -327,7 +328,7 @@ Add this function to `mu4e-view-mode-hook' to enable this feature."
   "Detach the view buffer from its headers buffer."
   (interactive)
   (unless mu4e-linked-headers-buffer
-    (mu4e-error "This view buffer is already detached."))
+    (mu4e-error "This view buffer is already detached"))
   (mu4e-message "Detached view buffer from %s"
                 (progn mu4e-linked-headers-buffer
                   (with-current-buffer mu4e-linked-headers-buffer
@@ -339,7 +340,7 @@ Add this function to `mu4e-view-mode-hook' to enable this feature."
                   (rename-buffer (make-temp-name (buffer-name)) t))))
 
 (defun mu4e-view-attach (headers-buffer)
-  "Attaches a view buffer to a headers buffer."
+  "Attaches a view buffer to HEADERS-BUFFER."
   (interactive
    (list (get-buffer (read-buffer
                       "Select a headers buffer to attach to: " nil t
@@ -422,7 +423,6 @@ list."
   (mu4e--view-in-headers-context
    (mu4e-mark-execute-all)))
 
-
 ;;; URL handling
 
 (defvar mu4e--view-link-map nil
@@ -640,7 +640,8 @@ As a side-effect, a message that is being viewed loses its
         ;; problems later (#2260, #2508), so let's remove those
         (article-remove-cr)
         (setq-local mu4e--view-message msg)
-        (mu4e--view-render-buffer msg))
+        (ignore-errors
+          (mu4e--view-render-buffer msg)))
       (mu4e-loading-mode 0)))
   (unless (mu4e--view-detached-p gnus-article-buffer)
     (with-current-buffer mu4e-linked-headers-buffer
@@ -741,8 +742,9 @@ determine which browser function to use."
           (set-buffer-modified-p nil)
           (add-hook 'kill-buffer-hook #'mu4e--view-kill-mime-handles))
       (epg-error
-       (mu4e-warn "EPG error: %s; fall back to raw view"
-                  (error-message-string err))))))
+       (mu4e-message "EPG error: %s; fall back to raw view"
+                  (error-message-string err))
+       (error)))))
 
 (defun mu4e-view-refresh ()
   "Refresh the message view."

From aee76e47a86cb31edcf4ba70c0af9547db220e8c Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Fri, 23 Aug 2024 08:19:59 +0300
Subject: [PATCH 098/305] mu4e-view: fix epg error handling

---
 mu4e/mu4e-view.el | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/mu4e/mu4e-view.el b/mu4e/mu4e-view.el
index 60608dfe6..d479964f3 100644
--- a/mu4e/mu4e-view.el
+++ b/mu4e/mu4e-view.el
@@ -743,8 +743,7 @@ determine which browser function to use."
           (add-hook 'kill-buffer-hook #'mu4e--view-kill-mime-handles))
       (epg-error
        (mu4e-message "EPG error: %s; fall back to raw view"
-                  (error-message-string err))
-       (error)))))
+                     (error-message-string err))))))
 
 (defun mu4e-view-refresh ()
   "Refresh the message view."

From 075394b35f33bcf684eb0b0023a8640a3ce9c8f5 Mon Sep 17 00:00:00 2001
From: Matthew Smith <matthew@gentoo.org>
Date: Mon, 26 Aug 2024 14:46:54 +0000
Subject: [PATCH 099/305] lib: use time_t_max for empty datetime

In Mu::parse_date_time, when provided with an empty string, return
time_t_max instead of G_MAXINT64. For systems with a 64-bit time_t, there
is no difference. With a 32-bit time_t it caused a test to fail:

    not ok /utils/date-basic - ERROR:../mu-1.12.4/lib/utils/tests/test-utils.cc:92
    void test_date_basic(): assertion failed
    (parse_date_time(std::get<0>(test), std::get<1>(test)).value_or(-1)
      == std::get<2>(test)): (18446744073709551615 == 2147483647)

This edge case probably only affected the test, as when other parts of
the application call parse_date_time (e.g. mu-server.cc and
mu-query-processor.cc), they check if the input string is empty first.
---
 lib/utils/mu-utils.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/utils/mu-utils.cc b/lib/utils/mu-utils.cc
index 6d36dc1a3..deb966f3b 100644
--- a/lib/utils/mu-utils.cc
+++ b/lib/utils/mu-utils.cc
@@ -493,7 +493,7 @@ Mu::parse_date_time(const std::string& dstr, bool is_first, bool utc)
 
 	/* one-sided dates */
 	if (dstr.empty())
-		return is_first ? 0 : G_MAXINT64;
+		return is_first ? time_t_min : time_t_max;
 	else if (dstr == "today" || dstr == "now")
 		return special_date_time(dstr, is_first);
 	else if (dstr.find_first_of("ymdwhMs") != std::string::npos)

From f101e0d4ca86b46718e0e3d46dee04a6f8b77bc4 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Fri, 23 Aug 2024 23:17:34 +0300
Subject: [PATCH 100/305] mu4e: cosmetics

---
 mu4e/mu4e-compose.el | 23 ++++++++++++-----------
 mu4e/mu4e-draft.el   |  6 ++++--
 2 files changed, 16 insertions(+), 13 deletions(-)

diff --git a/mu4e/mu4e-compose.el b/mu4e/mu4e-compose.el
index 11ab2710d..570f1afce 100644
--- a/mu4e/mu4e-compose.el
+++ b/mu4e/mu4e-compose.el
@@ -26,7 +26,7 @@
 ;; quite a bit of trickery involved to make the message-mode functions work in
 ;; this context; see mu4e-draft for details.
 
-
+
 ;;; Code:
 (require 'message)
 (require 'sendmail)
@@ -41,7 +41,7 @@
 
 (require 'mu4e-draft)
 
-
+
 ;;; User configuration for compose-mode
 (defgroup mu4e-compose nil
   "Customization for composing/sending messages."
@@ -91,7 +91,7 @@ This multiplexes the `message-mode' hooks `message-send-actions',
   :type 'hook
   :group 'mu4e-compose)
 
-
+
 
 (defvar mu4e-captured-message)
 (defun mu4e-compose-attach-captured-message ()
@@ -187,8 +187,8 @@ the file under our feet, which is a bit fragile."
           (when message-signature
               (save-excursion (message-insert-signature))))))))
 
-
-;;; address completion
+
+;;; Address completion
 
 ;; inspired by org-contacts.el and
 ;; https://github.com/nordlow/elisp/blob/master/mine/completion-styles-cycle.el
@@ -246,7 +246,7 @@ completion functions still apply."
     (add-hook 'completion-at-point-functions
               #'mu4e--compose-complete-contact-field -10 t)))
 
- ;;; mu4e-compose-mode
+ ;;; mu4e-compose-mode
 (defun mu4e--compose-remap-faces ()
   "Remap `message-mode' faces to mu4e ones.
 
@@ -344,7 +344,8 @@ This function uses `message-cite-function', and its settings apply."
     (pop-mark)
     (goto-char (point-min))
     (buffer-string)))
-
+
+;;; Interactive functions
 
 ;;;###autoload
 (defalias 'mu4e-compose-mail #'mu4e-compose-new)
@@ -394,7 +395,7 @@ If WIDE is non-nil, make it a \"wide\" reply (a.k.a.
   "Wide reply to the message at point.
 I.e., \"reply-to-all\"."
   (interactive)
-  (mu4e-compose-reply-to nil t))1
+  (mu4e-compose-reply-to nil t))
 
 ;;;###autoload
 (defun mu4e-compose-supersede ()
@@ -468,7 +469,7 @@ The message is resent as-is, without any editing. See
       (insert-file-contents (mu4e-message-readable-path msg))
       (message-resend address))))
 
-;;; Compose Mail
+;;; Compose-mode
 
 (declare-function mu4e "mu4e")
 
@@ -487,7 +488,7 @@ The message is resent as-is, without any editing. See
 (defun mu4e-user-agent ()
   "Return the `mu4e-user-agent' symbol."
   'mu4e-user-agent)
-
+
 ;;; minor mode for use in other modes.
 (defvar mu4e-compose-minor-mode-map
   (let ((map (make-sparse-keymap)))
@@ -520,6 +521,6 @@ The message is resent as-is, without any editing. See
     ["Resend" mu4e-compose-resend
      :help "Re-send message"])
   "Easy menu items for message composition.")
- ;;;
+ ;;;
 (provide 'mu4e-compose)
 ;;; mu4e-compose.el ends here
diff --git a/mu4e/mu4e-draft.el b/mu4e/mu4e-draft.el
index cef2033b7..97a13ca2d 100644
--- a/mu4e/mu4e-draft.el
+++ b/mu4e/mu4e-draft.el
@@ -345,7 +345,7 @@ appropriate sent-messages folder. If MSGPATH is nil, do nothing."
          (mu4e-join-paths target-mdir "new" 'parents)))
       (write-file msgpath)
       (mu4e--server-add msgpath))))
-
+
 ;; save / send hooks
 
 (defvar-local mu4e--compose-undo nil
@@ -655,7 +655,9 @@ either `send', `exit', `kill' or `postpone'.")
 
 (defvar mu4e-compose-post-hook)
 (defun mu4e--message-post-actions (trigger)
-  "Invoked after we're done with a message.
+  "Invoked after we're done with a message with TRIGGER.
+
+See `mu4e-message-post-action' for the available triggers.
 
 I.e. this multiplexes the `message-(send|exit|kill|postpone)-actions';
 with the mu4e-message-post-action set accordingly."

From 411407f03e4bf55250d96015f427a86a373bfb12 Mon Sep 17 00:00:00 2001
From: Xiyue Deng <manphiz@gmail.com>
Date: Wed, 28 Aug 2024 12:40:53 -0700
Subject: [PATCH 101/305] Ensure `User-Agent' is set

* Set `message-newsreader' before calling `mu4e--prepare-draft-buffer' so that
`User-Agent' is properly set.

* Fixes #2750.
---
 mu4e/mu4e-draft.el | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/mu4e/mu4e-draft.el b/mu4e/mu4e-draft.el
index 97a13ca2d..b28ad4033 100644
--- a/mu4e/mu4e-draft.el
+++ b/mu4e/mu4e-draft.el
@@ -723,7 +723,8 @@ Returns the new buffer."
   ;; compose-func
   (let ((draft-buffer)
         (oldframe (selected-frame))
-        (oldwinconf (current-window-configuration)))
+        (oldwinconf (current-window-configuration))
+        (message-newsreader mu4e-user-agent-string))
     (with-temp-buffer
       ;; provide a temp buffer so the compose-func can do its thing
       (setq draft-buffer (mu4e--validate-hidden-buffer (funcall compose-func)))

From 797ca3e37fe74f081c16540b8c25a34a4e4276a4 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Wed, 28 Aug 2024 23:05:33 +0300
Subject: [PATCH 102/305] mu4e-draft: move the user-agent setting

This updates commit 411407f03e4bf55250d96015f427a86a373bfb12 and moves
the check to where we set the special headers.
---
 mu4e/mu4e-draft.el | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/mu4e/mu4e-draft.el b/mu4e/mu4e-draft.el
index b28ad4033..d7053540b 100644
--- a/mu4e/mu4e-draft.el
+++ b/mu4e/mu4e-draft.el
@@ -565,13 +565,14 @@ PARENT is the parent message, if any."
 
 (defun mu4e--prepare-draft-headers (compose-type)
   "Add extra headers for message based on COMPOSE-TYPE."
-  (message-generate-headers
-   (seq-filter #'identity ;; ensure needed headers are generated.
-               `(From Subject Date Message-ID
-                      ,(when (memq compose-type '(reply forward)) 'References)
-                      ,(when (eq compose-type 'reply) 'In-Reply-To)
-                      ,(when message-newsreader 'User-Agent)
-                      ,(when message-user-organization 'Organization)))))
+  (let ((message-newsreader mu4e-user-agent-string))
+    (message-generate-headers
+     (seq-filter #'identity ;; ensure needed headers are generated.
+                 `(From Subject Date Message-ID
+                        ,(when (memq compose-type '(reply forward)) 'References)
+                        ,(when (eq compose-type 'reply) 'In-Reply-To)
+                        ,(when message-newsreader 'User-Agent)
+                        ,(when message-user-organization 'Organization))))))
 
 (defun mu4e--prepare-draft-buffer (compose-type parent)
   "Prepare the current buffer as a draft-buffer.
@@ -723,8 +724,7 @@ Returns the new buffer."
   ;; compose-func
   (let ((draft-buffer)
         (oldframe (selected-frame))
-        (oldwinconf (current-window-configuration))
-        (message-newsreader mu4e-user-agent-string))
+        (oldwinconf (current-window-configuration)))
     (with-temp-buffer
       ;; provide a temp buffer so the compose-func can do its thing
       (setq draft-buffer (mu4e--validate-hidden-buffer (funcall compose-func)))

From 4397c030499381a964a47b660ceec806c3f3720d Mon Sep 17 00:00:00 2001
From: quaepoena <92120488+quaepoena@users.noreply.github.com>
Date: Mon, 2 Sep 2024 08:36:58 +0200
Subject: [PATCH 103/305] Fix typo in mu4e-context.el

---
 mu4e/mu4e-context.el | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mu4e/mu4e-context.el b/mu4e/mu4e-context.el
index 98cfedc4a..e35ef78ba 100644
--- a/mu4e/mu4e-context.el
+++ b/mu4e/mu4e-context.el
@@ -45,7 +45,7 @@ contexts match, we have the following choices:
 - `pick-first': pick the first of the contexts available (ie. the default)
 - `ask': ask the user `ask-if-none': ask if there is no context yet,
    otherwise leave it as it is
-- nil: return nil; eaves the current context as is.
+- nil: return nil; leaves the current context as is.
 
 Also see `mu4e-compose-context-policy'."
   :type '(choice

From e9ca3ad9f64bf395233136f393e18d0b39666328 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 1 Sep 2024 18:52:26 +0300
Subject: [PATCH 104/305] scanner: ignore emacs auto-saves

It's better to _not_ have auto-saves for your draft directory, but if
you do, ignore them at least in mu.

It may still trip up mbsync and friends, but not much we can do about
that.

Clean up the implementation a bit as well.
---
 lib/mu-scanner.cc | 29 ++++++++++++++++++-----------
 1 file changed, 18 insertions(+), 11 deletions(-)

diff --git a/lib/mu-scanner.cc b/lib/mu-scanner.cc
index bbc8d7e6d..7da9373fa 100644
--- a/lib/mu-scanner.cc
+++ b/lib/mu-scanner.cc
@@ -98,21 +98,28 @@ ignore_dentry(const dentry_t& dentry)
 {
 	const auto d_name{dentry.d_name.c_str()};
 
-	/* dotdir? */
-	if (d_name[0] == '\0' || (d_name[1] == '\0' && d_name[0] == '.') ||
+	/* ignore '.' and '..' and anything starting with '#' (emacs
+	 * auto-saves) */
+	if (d_name[0] == '\0' || d_name[0] == '#' ||
+	    (d_name[1] == '\0' && d_name[0] == '.') ||
 	    (d_name[2] == '\0' && d_name[0] == '.' && d_name[1] == '.'))
 		return true;
 
-	if (d_name[0] != 't' && d_name[0] != 'h' && d_name[0] != '.')
-		return false; /* don't ignore */
-
-	if (::strcmp(d_name, "tmp") == 0 || ::strcmp(d_name, "hcache.db") == 0)
-		return true; // ignore
-
-	if (d_name[0] == '.')
-		for (auto dname : { "nnmaildir", "notmuch", "noindex", "noupdate"})
+	switch (d_name[0]) {
+	case 't':
+		if (::strcmp(d_name, "tmp") == 0)
+			return true; // ignore the tmp dir
+		break;
+	case 'h':
+		if (::strcmp(d_name, "hcache.db") == 0)
+			return true; // ignore mutt cache
+		break;
+	case '.':
+		for (const auto& dname : {"nnmaildir", "notmuch", "noindex", "noupdate"})
 			if (::strcmp(d_name + 1, dname) == 0)
-				return true;
+				return true; // ignore some known other furniture
+		break;
+	}
 
 	return false; /* don't ignore */
 }

From b9cf667be970050bd19d41e43bfeb1df302de47a Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 3 Sep 2024 19:37:39 +0300
Subject: [PATCH 105/305] mu4e-helpers: cosmetics

Whitespace etc. fixes
---
 mu4e/mu4e-helpers.el | 24 +++++++-----------------
 1 file changed, 7 insertions(+), 17 deletions(-)

diff --git a/mu4e/mu4e-helpers.el b/mu4e/mu4e-helpers.el
index e2718bbb8..9b555e169 100644
--- a/mu4e/mu4e-helpers.el
+++ b/mu4e/mu4e-helpers.el
@@ -34,7 +34,7 @@
 
 (require 'mu4e-window)
 (require 'mu4e-config)
-
+
 ;;; Customization
 
 (defcustom mu4e-debug nil
@@ -46,7 +46,7 @@
   "Function to be used to receive user-input during completion.
 
 Suggested possible values are:
- * `completing-read':      emacs built-in completion method
+ * `completing-read':      Emacs' built-in completion method
  * `ido-completing-read':  dynamic completion within the minibuffer.
 
 The function is used in two contexts -
@@ -109,8 +109,6 @@ marked as read-only, or non-nil otherwise."
           function)
   :group 'mu4e-view)
 
-
-
 (defun mu4e-select-other-view ()
   "Switch between headers view and message view."
   (interactive)
@@ -121,14 +119,12 @@ marked as read-only, or non-nil otherwise."
            ((mu4e-current-buffer-type-p 'headers)
             (mu4e-get-view-buffer))
            (t (mu4e-error
-               "This window is neither the headers nor the view window."))))
+               "This window is neither the headers nor the view window"))))
          (other-win (and other-buf (get-buffer-window other-buf))))
     (if (window-live-p other-win)
         (select-window other-win)
       (mu4e-message "No window to switch to"))))
 
-
-
 ;;; Messages, warnings and errors
 (defun mu4e-format (frm &rest args)
   "Create [mu4e]-prefixed string based on format FRM and ARGS."
@@ -216,7 +212,7 @@ after trying an exact match.
 Return the matching choice value (cdr of the cell)."
   (let* ((metadata `(metadata
                      (display-sort-function . ,#'identity)
-                     (cycle-sort-function .   ,#'identity)))
+                     (cycle-sort-function   . ,#'identity)))
          (quick-result)
          (result
           (minibuffer-with-setup-hook
@@ -248,7 +244,7 @@ Return the matching choice value (cdr of the cell)."
   "Read and return one of CHOICES, prompting for PROMPT.
 
 PROMPT describes a multiple-choice question to the user. CHOICES
-is an alist of the fiorm
+is an alist of the form
   ( ( <display-string>  ( <shortcut> . <value> ))
      ... )
 Any input that is not one of CHOICES is ignored. This is mu4e's
@@ -324,7 +320,6 @@ Function returns the value (cdr) of the matching cell."
                 (characterp (plist-get item :key)))
               lst))
 
-
 ;;; Logging / debugging
 
 (defconst mu4e--log-max-size 1000000
@@ -400,8 +395,6 @@ log-buffer. See `mu4e-show-log'."
       (mu4e-warn "No debug log available"))
     (display-buffer buf)))
 
-
-
 ;;; Flags
 ;; Converting flags->string and vice-versa
 
@@ -450,7 +443,6 @@ http://cr.yp.to/proto/maildir.html."
           (_     nil))))
      str))))
 
-
 ;;; Misc
 (defun mu4e-copy-thing-at-point ()
   "Copy e-mail address or URL at point to the kill ring.
@@ -528,7 +520,7 @@ Or go to the top level if there is none."
           ('mu4e-view-mode    "(mu4e)Message view")
           (_                  "mu4e"))))
 
-
+
 ;;; bookmarks
 (defun mu4e--make-bookmark-record ()
   "Create a bookmark for the message at point."
@@ -553,14 +545,12 @@ Or go to the top level if there is none."
   (when-let ((msgid (bookmark-prop-get bookmark 'message-id)))
     (mu4e-view-message-with-message-id msgid)))
 
-;;; Macros
+;;; Macros
 
 (defmacro mu4e-setq-if-nil (var val)
   "Set VAR to VAL if VAR is nil."
   `(unless ,var (setq ,var ,val)))
 
-
-
 ;;; Misc
 (defun mu4e-join-paths (directory &rest components)
   "Append COMPONENTS to DIRECTORY and return the resulting string.

From 89f2162729a21ea1f3322db3e505e1fd69212093 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 3 Sep 2024 20:40:24 +0300
Subject: [PATCH 106/305] mu4e-draft/helpers: use newer message-hide-headers

It seems the older (<= emacs 28 at least) message-hide-headers caused
trouble when editing drafts with mu4e in some cases.

So use the _newer_ version of this function, imported as
mu4e--message-hide-headers.

Fixes #2661.
---
 mu4e/mu4e-draft.el   |  6 ++++--
 mu4e/mu4e-helpers.el | 26 ++++++++++++++++++++++++++
 2 files changed, 30 insertions(+), 2 deletions(-)

diff --git a/mu4e/mu4e-draft.el b/mu4e/mu4e-draft.el
index d7053540b..367f580ad 100644
--- a/mu4e/mu4e-draft.el
+++ b/mu4e/mu4e-draft.el
@@ -605,9 +605,11 @@ COMPOSE-TYPE and PARENT are as in `mu4e--draft'."
   ;; now, switch to compose mode
   (mu4e-compose-mode)
 
-  ;; hide some internal headers
+  ;; hide some internal headers; we use the special mu4e-- version of
+  ;; message-hide-headers, since older versions of the latter trigger some bug,
+  ;; #2661.
   (let ((message-hidden-headers mu4e-draft-hidden-headers))
-    (message-hide-headers))
+    (mu4e--message-hide-headers))
 
   ;; hooks
   (add-hook 'before-save-hook  #'mu4e--compose-before-save nil t)
diff --git a/mu4e/mu4e-helpers.el b/mu4e/mu4e-helpers.el
index 9b555e169..01deba0e2 100644
--- a/mu4e/mu4e-helpers.el
+++ b/mu4e/mu4e-helpers.el
@@ -31,6 +31,7 @@
 (require 'ido)
 (require 'cl-lib)
 (require 'bookmark)
+(require 'message)
 
 (require 'mu4e-window)
 (require 'mu4e-config)
@@ -576,6 +577,31 @@ This is mu4e's version of Emacs 29's `plistp'."
   (let ((len (proper-list-p object)))
     (and len (zerop (% len 2)))))
 
+(defun mu4e--message-hide-headers ()
+  "Hide headers based on the `message-hidden-headers' variable.
+This is mu4e's version of the post-emacs-28 `message-hide-headers',
+which we need to avoid #2661."
+  (let ((regexps (if (stringp message-hidden-headers)
+                     (list message-hidden-headers)
+                   message-hidden-headers))
+        end-of-headers)
+    (when regexps
+      (save-excursion
+        (save-restriction
+          (message-narrow-to-headers)
+          (setq end-of-headers (point-min-marker))
+          (goto-char (point-min))
+          (while (not (eobp))
+            (if (not (message-hide-header-p regexps))
+                (message-next-header)
+              (let ((begin (point)))
+                (message-next-header)
+                (let ((header (delete-and-extract-region begin (point))))
+                  (save-excursion
+                    (goto-char end-of-headers)
+                    (insert-before-markers header))))))))
+      (narrow-to-region end-of-headers (point-max)))))
+
 (defun mu4e-key-description (cmd)
   "Get the textual form of current binding to interactive function CMD.
 If it is unbound, return nil. If there are multiple bindings,

From 37bb5fe8c0ecc8b809f2c7ac00b38e9de83662e5 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 3 Sep 2024 22:54:50 +0300
Subject: [PATCH 107/305] mu4e-headers: fix elisp docstring warnings

---
 mu4e/mu4e-headers.el | 236 +++++++++++++++++++++++--------------------
 1 file changed, 124 insertions(+), 112 deletions(-)

diff --git a/mu4e/mu4e-headers.el b/mu4e/mu4e-headers.el
index 9e5165450..bbd0562bf 100644
--- a/mu4e/mu4e-headers.el
+++ b/mu4e/mu4e-headers.el
@@ -53,7 +53,7 @@
 (declare-function mu4e-view       "mu4e-view")
 (declare-function mu4e--main-view  "mu4e-main")
 
-
+
 ;;; Configuration
 
 (defgroup mu4e-headers nil
@@ -90,7 +90,7 @@ altogether."
   :group 'mu4e-headers)
 
 (defun mu4e--headers-header-p (symbol)
-  "Is symbol a valid mu4e header?
+  "Is SYMBOL a valid mu4e header?
 This means its either one of the build-in or user-specified headers."
   (assoc symbol (append mu4e-header-info mu4e-header-info-custom)))
 
@@ -122,13 +122,15 @@ for non-precise aligment (for 445 messages)."
   :group 'mu4e-headers)
 
 (defcustom mu4e-headers-auto-update t
-  "Whether to automatically update the current headers buffer if an
-indexing operation showed changes."
+  "Automatically update the current headers buffer?
+After an indexing operation with changes."
   :type 'boolean
   :group 'mu4e-headers)
 
 (defcustom mu4e-headers-advance-after-mark t
-  "With this option set to non-nil, automatically advance to the
+  "Advance to the next header after marking?
+
+With this option set to non-nil, automatically advance to the
 next mail after marking a message in header view."
   :type 'boolean
   :group 'mu4e-headers)
@@ -159,16 +161,19 @@ mostly covered by `new', and the display gets cluttered otherwise."
   :group 'mu4e-headers)
 
 (defcustom mu4e-headers-found-hook nil
-  "Hook run just *after* all of the headers for the last search
-query have been received and are displayed."
+  "Hook run just after all of the headers have been received.
+I.e., for the last search query have been received and are
+displayed."
   :type 'hook
   :group 'mu4e-headers)
 
 ;;; Public variables
 (defcustom mu4e-headers-from-or-to-prefix '("" . "To ")
-  "Prefix for the :from-or-to field when it is showing,
-  respectively, From: or To:.  It is a cons cell with the car
-  element being the From: prefix, the cdr element the To: prefix."
+  "Prefix for the :from-or-to field.
+
+When it is showing, respectively, From: or To:. It is a cons cell
+  with the car element being the From: prefix, the cdr element
+  the To: prefix."
   :type '(cons string string)
   :group 'mu4e-headers)
 
@@ -266,9 +271,10 @@ The first character of NAME is used as the shortcut."
     ("Bigger than"
      (lambda (msg bytes) (> (mu4e-msg-field msg :size) (* 1024 bytes)))
      (lambda () (read-number "Match messages bigger than (Kbytes): "))))
-  "List of custom markers -- functions to mark message that match
-some custom function. Each of the list members has the following
-format:
+  "List of custom markers-functions.
+
+The functions are to mark message that match some custom
+function. Each of the list members has the following format:
   (NAME PREDICATE-FUNC PARAM-FUNC)
 * NAME is the name of the predicate function, and the first
 character is the shortcut (so keep those unique).
@@ -282,13 +288,14 @@ getting user-input.")
 
 ;; docid cookies
 (defconst mu4e~headers-docid-pre "\376"
-  "Each header starts (invisibly) with the `mu4e~headers-docid-pre',
+  "Prefix for header (before).
+Each header starts (invisibly) with `mu4e~headers-docid-pre',
 followed by the docid, followed by `mu4e~headers-docid-post'.")
 (defconst mu4e~headers-docid-post "\377"
-  "Each header starts (invisibly) with the `mu4e~headers-docid-pre',
+  "Prefix for header (after).
+Each header starts (invisibly) with the `mu4e~headers-docid-pre',
 followed by the docid, followed by `mu4e~headers-docid-post'.")
 
-
 (defvar mu4e~headers-search-start nil)
 (defvar mu4e~headers-render-start nil)
 (defvar mu4e~headers-render-time  nil)
@@ -300,7 +307,7 @@ This is mostly useful for profiling.")
 (defvar mu4e~headers-hidden 0
   "Number of headers hidden due to `mu4e-headers-hide-predicate'.")
 
-
+
 ;;; Clear
 
 (defun mu4e~headers-clear (&optional text)
@@ -317,7 +324,7 @@ Optionally, show TEXT."
         (when text
           (goto-char (point-min))
           (insert (propertize text 'face 'mu4e-system-face 'intangible t)))))))
-
+
 ;;; Misc
 
 (defun mu4e~headers-contact-str (contacts)
@@ -356,23 +363,24 @@ into a string."
 ;; docid at point without string matching etc.
 
 (defun mu4e~headers-docid-pos (docid)
-  "Return the pos of the beginning of the line with the header with
-docid DOCID, or nil if it cannot be found."
+  "Return beginning-of-line for header with DOCID.
+Return nil if it cannot be found."
   (let ((pos))
     (save-excursion
       (setq pos (mu4e~headers-goto-docid docid)))
     pos))
 
 (defun mu4e~headers-docid-cookie (docid)
-  "Create an invisible string containing DOCID; this is to be used
-at the beginning of lines to identify headers."
+  "Create an invisible string containing DOCID.
+
+This is to be used at the beginning of lines to identify headers."
   (propertize (format "%s%d%s"
                       mu4e~headers-docid-pre docid mu4e~headers-docid-post)
               'docid docid 'invisible t));;
 
 (defun mu4e~headers-docid-at-point (&optional point)
-  "Get the docid for the header at POINT, or at current (point) if
-nil. Returns the docid, or nil if there is none."
+  "Get docid for header at POINT or (point).
+Returns the docid, or nil if there is none."
   (save-excursion
     (when point
       (goto-char point))
@@ -381,8 +389,8 @@ nil. Returns the docid, or nil if there is none."
 
 
 (defun mu4e~headers-goto-docid (docid &optional to-mark)
-  "Go to the beginning of the line with the header with docid
-DOCID, or nil if it cannot be found. If the optional TO-MARK is
+  "Go to beginning of the line with DOCID.
+Nil if it cannot be found. If the optional TO-MARK is
 non-nil, go to the point directly *after* the docid-cookie instead
 of the beginning of the line."
   (let ((oldpoint (point)) (newpoint))
@@ -398,8 +406,7 @@ of the beginning of the line."
     newpoint)) ;; return the point, or nil if not found
 
 (defun mu4e~headers-field-for-docid (docid field)
-  "Get FIELD (a symbol, see `mu4e-headers-names') for the message
-with DOCID which must be present in the headers buffer."
+  "Get FIELD for the message with DOCID, present in the headers buffer."
   (save-excursion
     (when (mu4e~headers-goto-docid docid)
       (mu4e-message-field (mu4e-message-at-point) field))))
@@ -535,14 +542,13 @@ e.g. \"mutt\"."
          (truncate-string-to-width subj 600) ""))))
 
 (defun mu4e~headers-mailing-list (list)
-  "Get some identifier for the mailing list."
+  "Get some identifier for mailing LIST."
   (if list
       (propertize (mu4e-get-mailing-list-shortname list) 'help-echo list)
     ""))
 
 (defsubst mu4e~headers-custom-field-value (msg field)
-  "Show some custom header field, or raise an error if it is not
-found."
+  "Show custom header FIELD for MSG, or raise error if not found."
   (let* ((item (or (assoc field mu4e-header-info-custom)
                    (mu4e-error "field %S not found" field)))
          (func (or (plist-get (cdr-safe item) :function)
@@ -551,6 +557,7 @@ found."
     (funcall func msg)))
 
 (defun mu4e~headers-field-value (msg field)
+  "Get the value for MSG FIELD."
   (let ((val (mu4e-message-field msg field)))
     (cl-case field
       (:subject
@@ -589,9 +596,11 @@ found."
     val))
 
 (defun mu4e~headers-truncate-field-precise (field val width)
-  "Return VAL truncated to one less than WIDTH, with a trailing
+  "Truncate FIELD value VAL to WIDTH precisely.
+
+Return VAL truncated to one less than WIDTH, with a trailing
 space propertized with a `display' text property which expands to
- the correct column for display."
+the correct column for display."
   (when width
     (let ((end-col (cl-loop for (f . w) in mu4e-headers-fields
                             sum w
@@ -611,7 +620,7 @@ space propertized with a `display' text property which expands to
   val)
 
 (defsubst mu4e~headers-truncate-field (field val width)
-  "Truncate VAL to WIDTH."
+  "Truncate FIELD value VAL to WIDTH."
   (if mu4e-headers-precise-alignment
       (mu4e~headers-truncate-field-precise field val width)
     (mu4e~headers-truncate-field-fast val width)))
@@ -645,8 +654,8 @@ space propertized with a `display' text property which expands to
     fieldval))
 
 (defsubst mu4e~message-header-line (msg)
-  "Return a propertized description of message MSG suitable for
-displaying in the header view."
+  "Return a propertized description of MSG.
+This is suitable for displaying in the header view."
   (if (and mu4e-search-hide-enabled mu4e-search-hide-predicate
            (funcall mu4e-search-hide-predicate msg))
       (progn
@@ -672,7 +681,7 @@ displaying in the header view."
 
 (defun mu4e~headers-remove-header (docid &optional ignore-missing)
   "Remove header with DOCID at point.
-When IGNORE-MISSING is non-nill, don't raise an error when the
+When IGNORE-MISSING is non-nil, don't raise an error when the
 docid is not found."
   (with-current-buffer (mu4e-get-headers-buffer)
     (if (mu4e~headers-goto-docid docid)
@@ -681,14 +690,14 @@ docid is not found."
       (unless ignore-missing
         (mu4e-error "Cannot find message with docid %S" docid)))))
 
-
+
 ;;; Handler functions
 
 ;; next are a bunch of handler functions; those will be called from mu4e~proc in
 ;; response to output from the server process
 
 (defun mu4e~headers-view-handler (msg)
-  "Handler function for displaying a message."
+  "Handler function for displaying a MSG."
   (mu4e-view msg))
 
 (defun mu4e~headers-view-this-message-p (docid)
@@ -698,7 +707,7 @@ docid is not found."
 
 ;; note: this function is very performance-sensitive
 (defun mu4e~headers-append-handler (msglst)
-  "Append one-line descriptions of messages in MSGLIST.
+  "Append one-line descriptions of messages in MSGLST.
 Do this at the end of the headers-buffer."
   (when (buffer-live-p (mu4e-get-headers-buffer))
     (with-current-buffer (mu4e-get-headers-buffer)
@@ -711,9 +720,10 @@ Do this at the end of the headers-buffer."
 
 
 (defun mu4e~headers-update-handler (msg is-move maybe-view)
-  "Update handler, will be called when a message has been updated
-in the database. This function will update the current list of
-headers."
+  "Update handler, called when MSG is updated.
+This function will update the current list of headers
+IS-MOVE specifies if this was a move and MAYBE-VIEW whether
+the updated message should be viewed."
   (when (buffer-live-p (mu4e-get-headers-buffer))
     (with-current-buffer (mu4e-get-headers-buffer)
       (let* ((docid (mu4e-message-field msg :docid))
@@ -767,8 +777,9 @@ headers."
           (run-hooks 'mu4e-message-changed-hook))))))
 
 (defun mu4e~headers-remove-handler (docid)
-  "Remove handler, will be called when a message with DOCID has
-been removed from the database. This function will hide the removed
+  "Remove handler, called when a message with DOCID is removed.
+
+This function will hide the removed
 message from the current list of headers. If the message is not
 present, don't do anything."
   (when (buffer-live-p (mu4e-get-headers-buffer))
@@ -782,7 +793,7 @@ present, don't do anything."
       (kill-buffer buf))))
 
 
-
+
 ;;; Performing queries (internal)
 (defconst mu4e~search-message "Searching...")
 (defconst mu4e~no-matches     "No matching messages found")
@@ -790,7 +801,7 @@ present, don't do anything."
 
 (defvar mu4e--search-background nil
   "Is this a background search?
- If so, do not attempt to switch buffers. This variable is to be let-bound
+If so, do not attempt to switch buffers. This variable is to be let-bound
 to t before \"automatic\" searches.")
 
 (defun mu4e--search-execute (expr ignore-history)
@@ -850,8 +861,7 @@ true, do *not* update the query history stack."
     ""))
 
 (defun mu4e~headers-found-handler (count)
-  "Create a one line description of the number of headers found
-after the end of the search results."
+  "Create one=line description of the COUNT of headers found."
   (when (buffer-live-p (mu4e-get-headers-buffer))
     (with-current-buffer (mu4e-get-headers-buffer)
       (save-excursion
@@ -867,33 +877,33 @@ after the end of the search results."
           (unless (zerop count)
             (mu4e-message "%s" msg))))
 
-          ;; if we need to jump to some specific message, do so now
-          (goto-char (point-min))
-          (when mu4e--search-msgid-target
-            (if (eq (current-buffer) (window-buffer))
-                (mu4e-headers-goto-message-id mu4e--search-msgid-target)
-              (let* ((pos (mu4e-headers-goto-message-id
-                           mu4e--search-msgid-target)))
-                (when pos
-                  (set-window-point (get-buffer-window nil t) pos)))))
-          (when (and mu4e--search-view-target (mu4e-message-at-point 'noerror))
-            ;; view the message at point when there is one.
-            (mu4e-headers-view-message))
-          (setq mu4e--search-view-target nil
-                mu4e--search-msgid-target nil)
-          (when (mu4e~headers-docid-at-point)
-            (mu4e~headers-highlight (mu4e~headers-docid-at-point)))
-          ;; maybe enable thread folding
-          (when mu4e-search-threads
-            (mu4e-thread-mode))))
+      ;; if we need to jump to some specific message, do so now
+      (goto-char (point-min))
+      (when mu4e--search-msgid-target
+        (if (eq (current-buffer) (window-buffer))
+            (mu4e-headers-goto-message-id mu4e--search-msgid-target)
+          (let* ((pos (mu4e-headers-goto-message-id
+                       mu4e--search-msgid-target)))
+            (when pos
+              (set-window-point (get-buffer-window nil t) pos)))))
+      (when (and mu4e--search-view-target (mu4e-message-at-point 'noerror))
+        ;; view the message at point when there is one.
+        (mu4e-headers-view-message))
+      (setq mu4e--search-view-target nil
+            mu4e--search-msgid-target nil)
+      (when (mu4e~headers-docid-at-point)
+        (mu4e~headers-highlight (mu4e~headers-docid-at-point)))
+      ;; maybe enable thread folding
+      (when mu4e-search-threads
+        (mu4e-thread-mode))))
   ;; run-hooks
   (run-hooks 'mu4e-headers-found-hook))
 
-
+
 ;;; Marking
 
 (defmacro mu4e~headers-defun-mark-for (mark)
-  "Define a function mu4e~headers-mark-MARK."
+  "Define a function mu4e~headers-mark-... for MARK."
   (let ((funcname (intern (format "mu4e-headers-mark-for-%s" mark)))
         (docstring (format "Mark header at point with %s." mark)))
     `(progn
@@ -1082,8 +1092,8 @@ after the end of the search results."
       mu4e-headers-fields))))
 
 (defun mu4e~headers-maybe-auto-update ()
-  "Update the current headers buffer after indexing has brought
-some changes, `mu4e-headers-auto-update' is non-nil and there is
+  "Update the current headers buffer after indexing changes.
+Furthermore, `mu4e-headers-auto-update' is non-nil and there is
 no user-interaction ongoing."
   (when (and mu4e-headers-auto-update ;; must be set
              mu4e-index-update-status
@@ -1115,6 +1125,7 @@ The following specs are supported:
   :group 'mu4e-headers)
 
 (defun mu4e-headers-eldoc-function (&rest _args)
+  "Determine function for eldoc."
   (let ((msg (get-text-property (point) 'msg)))
     (when msg
       (format-spec
@@ -1172,11 +1183,11 @@ The following specs are supported:
 ;;; Highlighting
 
 (defvar mu4e~highlighted-docid nil
-  "The highlighted docid")
+  "The highlighted docid.")
 
 (defun mu4e~headers-highlight (docid)
   "Highlight the header with DOCID, or do nothing if it's not found.
-Also, unhighlight any previously highlighted headers."
+Also, un-highlight any previously highlighted headers."
   (with-current-buffer (mu4e-get-headers-buffer)
     (save-excursion
       ;; first, unhighlight the previously highlighted docid, if any
@@ -1191,15 +1202,16 @@ Also, unhighlight any previously highlighted headers."
 ;;; Misc 2
 
 (defun mu4e~headers-select-window ()
-  "When there is a visible window for the headers buffer, make sure
-to select it. This is needed when adding new headers, otherwise
+  "Select a visible window for the headers buffer if it exists.
+
+This is needed when adding new headers, otherwise
 adding a lot of new headers looks really choppy."
   (let ((win (get-buffer-window (mu4e-get-headers-buffer))))
     (when win (select-window win))))
 
 (defun mu4e-headers-goto-message-id (msgid)
-  "Go to the next message with message-id MSGID. Return the
-message plist, or nil if not found."
+  "Go to the next message with MSGID.
+Return the message plist, or nil if not found."
   (mu4e-headers-find-if
    (lambda (msg)
      (let ((this-msgid (mu4e-message-field msg :message-id)))
@@ -1230,7 +1242,6 @@ message plist, or nil if not found."
                  'msg msg)))
       (goto-char oldpoint))))
 
-
 ;;; Queries & searching
 
 ;;; Search-based marking
@@ -1250,12 +1261,12 @@ corresponding header."
 
 
 (defun mu4e-headers-find-if (func &optional backward)
-  "Move to the header for which FUNC returns non-`nil'.
+  "Move to the header for which FUNC returns non-nil.
 if BACKWARD is non-nil, search backwards.
 
- FUNC receives one argument, the message s-expression for the
-corresponding header. If BACKWARD is non-`nil', search backwards.
-Returns the new position, or `nil' if nothing was found. If you
+FUNC receives one argument, the message s-expression for the
+corresponding header. If BACKWARD is non-nil, search backwards.
+Returns the new position, or nil if nothing was found. If you
 want to exclude matches for the current message, you can use
 `mu4e-headers-find-if-next'.
 
@@ -1276,8 +1287,9 @@ Return the found position or nil if not found."
 
 (defun mu4e-headers-find-if-next (func &optional backwards)
   "Like `mu4e-headers-find-if', but do not match the current header.
-Move to the next or (if BACKWARDS is non-`nil') header for which FUNC
-returns non-`nil', starting from the current position."
+
+Move to the next or (if BACKWARDS is non-nil) header for which
+FUNC returns non-nil, starting from the current position."
   (let ((pos))
     (save-excursion
       (if backwards (beginning-of-line) (end-of-line))
@@ -1288,8 +1300,8 @@ returns non-`nil', starting from the current position."
   "History list of regexps used.")
 
 (defun mu4e-headers-mark-for-each-if (markpair mark-pred &optional param)
-  "Mark all headers for which predicate function MARK-PRED returns
-non-nil with MARKPAIR. MARK-PRED is function that receives two
+  "Mark headers with predicate MARK-PRED with MARKPAIR.
+MARK-PRED is function that receives two
 arguments, MSG (the message at point) and PARAM (a user-specified
 parameter). MARKPAIR is a cell (MARK . TARGET); see
 `mu4e-mark-at-point' for details about marks."
@@ -1299,9 +1311,11 @@ parameter). MARKPAIR is a cell (MARK . TARGET); see
        (mu4e-mark-at-point (car markpair) (cdr markpair))))))
 
 (defun mu4e-headers-mark-pattern ()
-  "Ask user for a kind of mark (move, delete etc.), a field to
-match and a regular expression to match with. Then, mark all
-matching messages with that mark."
+  "Ask user for a kind of mark-pattern.
+
+That is, some markpair (move, delete etc.), a field to match and
+a regular expression to match with. Then, mark all matching
+messages with that mark."
   (interactive)
   (let ((markpair (mu4e--mark-get-markpair "Mark matched messages with: " t))
         (field (mu4e-read-option "Field to match: "
@@ -1352,9 +1366,9 @@ matching messages with that mark."
       (otherwise (mu4e-error "Not supported")))))
 
 (defun mu4e-headers-mark-thread-using-markpair (markpair &optional subthread)
-  "Mark the thread at point using the given markpair. If SUBTHREAD is
-non-nil, marking is limited to the message at point and its
-descendants."
+  "Mark the thread at point using the given MARKPAIR.
+If SUBTHREAD is non-nil, marking is limited to the message at
+point and its descendants."
   (let* ((mark (car markpair))
          (allowed-marks (mapcar 'car mu4e-marks)))
     (unless (memq mark allowed-marks)
@@ -1387,7 +1401,9 @@ descendants."
       (mu4e-headers-next))))
 
 (defun mu4e-headers-mark-thread (&optional subthread markpair)
-  "Like `mu4e-headers-mark-thread-using-markpair' but prompt for the markpair."
+  "Like `mu4e-headers-mark-thread-using-markpair' but prompt for MARKPAIR.
+
+If SUBTHREAD is non-nil, only apply to subthread."
   (interactive
    (let* ((subthread current-prefix-arg))
      (list current-prefix-arg
@@ -1399,14 +1415,12 @@ descendants."
   (mu4e-headers-mark-thread-using-markpair markpair subthread))
 
 (defun mu4e-headers-mark-subthread (&optional markpair)
-  "Like `mu4e-mark-thread', but only for a sub-thread."
+  "Like `mu4e-mark-thread' with MARKPAIR, but only for a sub-thread."
   (interactive)
   (if markpair (mu4e-headers-mark-thread t markpair)
     (let ((current-prefix-arg t))
       (call-interactively 'mu4e-headers-mark-thread))))
 
-
-
 (defun mu4e-headers-view-message ()
   "View message at point."
   (interactive)
@@ -1428,9 +1442,11 @@ descendants."
     (mu4e--server-view docid mark-as-read)))
 
 (defvar-local mu4e-headers-open-after-move t
-  "If set to non-nil, open message after `mu4e-headers-next' and
-`mu4e-headers-prev' if pointing at a message after the move
-and there is a live message view.
+  "Influence open behavior after moving.
+
+If set to non-nil, open message after `mu4e-headers-next' and
+`mu4e-headers-prev' if pointing at a message after the move and
+there is a live message view.
 
 This variable is for let-binding when scripting.")
 
@@ -1500,8 +1516,8 @@ view-window, open the message unless
   (mu4e~headers-move (- (or n 1))))
 
 (defun mu4e~headers-prev-or-next-unread (backwards)
-  "Move point to the next message that is unread (and
-untrashed). If BACKWARDS is non-`nil', move backwards."
+  "Move point to next message that is unread/untrashed.
+If BACKWARDS is non-nil, move backwards."
   (interactive "P")
   (or (mu4e-headers-find-if-next
        (lambda (msg)
@@ -1512,14 +1528,12 @@ untrashed). If BACKWARDS is non-`nil', move backwards."
                             (if backwards "previous" "next")))))
 
 (defun mu4e-headers-prev-unread ()
-  "Move point to the previous message that is unread (and
-untrashed)."
+  "Move point to previous unread/untrashed message."
   (interactive)
   (mu4e~headers-prev-or-next-unread t))
 
 (defun mu4e-headers-next-unread ()
-  "Move point to the next message that is unread (and
-untrashed)."
+  "Move point to next unread/untrashed message."
   (interactive)
   (mu4e~headers-prev-or-next-unread nil))
 
@@ -1535,7 +1549,7 @@ If MSG is nil, use message at point."
 
 (defun mu4e~headers-prev-or-next-thread (backwards)
   "Move point to the top of the next thread.
-If BACKWARDS is non-`nil', move backwards."
+If BACKWARDS is non-nil, move backwards."
   (when (mu4e-headers-find-if-next #'mu4e~headers-thread-root-p backwards)
       (point)))
 
@@ -1588,8 +1602,8 @@ argument."
     (funcall afunc msg)))
 
 (defun mu4e-headers-mark-and-next (mark)
-  "Set mark MARK on the message at point or on all messages in the
-region if there is a region, then move to the next message."
+  "Set MARK on the message at point or in region.
+Then, move to the next message."
   (interactive)
   (when (mu4e-thread-message-folded-p)
     (mu4e-warn "Cannot mark folded messages"))
@@ -1605,11 +1619,9 @@ region if there is a region, then move to the next message."
   (mu4e--query-items-refresh 'reset-baseline)
   (mu4e--main-view))
 
-
 ;;; Loading messages
 ;;
 
-
 (defvar-local mu4e--loading-overlay-bg nil
   "Internal variable that holds the loading overlay for the background.")
 
@@ -1617,7 +1629,7 @@ region if there is a region, then move to the next message."
   "Internal variable that holds the loading overlay for the text.")
 
 (define-minor-mode mu4e-loading-mode
-  "Minor mode for buffers awaiting data from mu"
+  "Minor mode for buffers awaiting data from mu."
   :init-value nil :lighter " Loading" :keymap nil
   (if mu4e-loading-mode
       (progn

From 0282c8551dc3c7b3038eef81e5fb63c0df59b054 Mon Sep 17 00:00:00 2001
From: QP <quaepoena@example.com>
Date: Wed, 4 Sep 2024 12:34:53 +0200
Subject: [PATCH 108/305] Replace zero-width spaces in man pages with an empty
 string.

The zero-width spaces are added by the `man-link` macro to ensure bold text
formatting when exporting from org, but they interfere with man page
functionality in Emacs.
---
 man/meson.build | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/man/meson.build b/man/meson.build
index 76018354f..5251964f5 100644
--- a/man/meson.build
+++ b/man/meson.build
@@ -80,10 +80,16 @@ foreach src : man_orgs
   configure_file(input: src, output:'@BASENAME@.org',
                  configuration: conf_data)
 
+  # (replace-regexp-in-string) removes zero-width spaces — added for
+  # text formatting purposes by the man-link macro — from the
+  # resulting man page.
   expr_tmpl = ''.join([
     '(progn',
     '  (require \'ox-man)',
     '  (setq org-export-with-sub-superscripts \'{})',
+    '  (add-to-list \'org-export-filter-plain-text-functions',
+    '    (lambda (text _backend _info)',
+    '      (replace-regexp-in-string "\u200b" "" text)))',
     '  (org-export-to-file \'man "@0@"))'])
   expr = expr_tmpl.format(org.substring(0,-4))
   sectiondir = join_paths(mandir, 'man' + section)

From 61ba9296b2f18851a37e8ed5a13c7be5e9a59ad6 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 15 Sep 2024 10:59:44 +0300
Subject: [PATCH 109/305] man: attempt to avoid \u escape in man building

This may help for #2756
---
 man/meson.build | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/man/meson.build b/man/meson.build
index 5251964f5..ac56f78f1 100644
--- a/man/meson.build
+++ b/man/meson.build
@@ -89,7 +89,8 @@ foreach src : man_orgs
     '  (setq org-export-with-sub-superscripts \'{})',
     '  (add-to-list \'org-export-filter-plain-text-functions',
     '    (lambda (text _backend _info)',
-    '      (replace-regexp-in-string "\u200b" "" text)))',
+    '      (let ((zwsp (format "%c" (char-from-name "ZERO WIDTH SPACE"))))',
+    '        (replace-regexp-in-string zwsp "" text))))',
     '  (org-export-to-file \'man "@0@"))'])
   expr = expr_tmpl.format(org.substring(0,-4))
   sectiondir = join_paths(mandir, 'man' + section)

From 6426363e012d899ad0f1c37d71e17f0eec59dbab Mon Sep 17 00:00:00 2001
From: Mark Knoop <mark@markknoop.com>
Date: Sun, 15 Sep 2024 09:46:34 +0100
Subject: [PATCH 110/305] Correct mu-query man page

Update mu-query man page to point to the mu info fields command.
---
 man/mu-query.7.org | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/man/mu-query.7.org b/man/mu-query.7.org
index bbc242e7b..cd164ae34 100644
--- a/man/mu-query.7.org
+++ b/man/mu-query.7.org
@@ -14,8 +14,8 @@ query-parser, but is an independent implementation that is customized for the
 mu/mu4e use-case.
 
 Here, we give a structured but informal overview of the query language and
-provide examples. As a companion to this, we recommend the *mu fields* and *mu
-flags* commands to get an up-to-date list of the available fields and flags.
+provide examples. As a companion to this, we recommend the *mu info fields*
+command to get an up-to-date list of the available fields and flags.
 
 Furthermore, *mu find* provides the *--analyze* option, which shows how *mu*
 interprets your query; see the *ANALYZING QUERIES* section below.

From 18a9bd4a19258c3a00f11b022c896196c0cb0a0a Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 17 Sep 2024 21:06:09 +0300
Subject: [PATCH 111/305] mu4e-org: ensure mu4e is started if not already

In order to show stored messages/queries, load mu4e if needed, since it
may not have been loaded already.
---
 mu4e/mu4e-org.el | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/mu4e/mu4e-org.el b/mu4e/mu4e-org.el
index 18d9b66a6..be24e3286 100644
--- a/mu4e/mu4e-org.el
+++ b/mu4e/mu4e-org.el
@@ -31,7 +31,6 @@
 (require 'mu4e-view)
 (require 'mu4e-contacts)
 
-
 (defgroup mu4e-org nil
   "Settings for the Org mode related functionality in mu4e."
   :group 'mu4e
@@ -61,7 +60,7 @@ Example usage:
 If non-nil, `org-store-link' in `mu4e-headers-mode' links to the
 the current query; otherwise, it links to the message at point.")
 
-;; backward compat until org >= 9.3 is univeral.
+;; backward compat until org >= 9.3 is universal.
 (defalias 'mu4e--org-link-store-props
   (if (fboundp 'org-link-store-props)
       #'org-link-store-props
@@ -118,11 +117,15 @@ valid even after moving the message around."
         (mu4e--org-store-link-query)
       (mu4e--org-store-link-message)))))
 
+(declare-function mu4e "mu4e")
+
+;;;###autoload
 (defun mu4e-org-open (link)
   "Open the org LINK.
 Open the mu4e message (for links starting with \"msgid:\") or run
 the query (for links starting with \"query:\")."
   (require 'mu4e)
+  (mu4e 'background)
   (cond
    ((string-match "^msgid:\\(.+\\)" link)
     (mu4e-view-message-with-message-id (match-string 1 link)))

From 29dc1cea0ce68542eddd6902e1ba0ac2f492dab5 Mon Sep 17 00:00:00 2001
From: James Cook <falsifian@falsifian.org>
Date: Sun, 22 Sep 2024 17:27:18 +0000
Subject: [PATCH 112/305] Fix typos.

---
 README.org            | 2 +-
 lib/mu-indexer.cc     | 2 +-
 lib/utils/mu-utils.hh | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/README.org b/README.org
index 2f07d09cb..a78b205c3 100644
--- a/README.org
+++ b/README.org
@@ -62,7 +62,7 @@ as a Linux distribution. Many have packages available.
 To be able to build ~mu~, ensure you have:
 
 - a C++17 compiler (~gcc~ or ~clang~ are known to work)
-- development packages for /Xapian/ and /GMime/ and /GLib/ (see ~meson.build~ for thex
+- development packages for /Xapian/ and /GMime/ and /GLib/ (see ~meson.build~ for the
   versions)
 - basic tools such as ~make~, ~sed~, ~grep~
 - ~meson~
diff --git a/lib/mu-indexer.cc b/lib/mu-indexer.cc
index ec4ef013f..65603c278 100644
--- a/lib/mu-indexer.cc
+++ b/lib/mu-indexer.cc
@@ -163,7 +163,7 @@ Indexer::Private::handler(const std::string& fullpath, struct stat* statbuf,
 		// in lazy-mode, we ignore this dir if its dirstamp suggest it
 		// is up-to-date (this is _not_ always true; hence we call it
 		// lazy-mode); only for actual message dirs, since the dir
-		// tstamps may not bubble up.U
+		// tstamps may not bubble up.
 		dirstamp_ = store_.dirstamp(fullpath);
 		if (conf_.lazy_check && dirstamp_ >= statbuf->st_ctime &&
 		    htype == Scanner::HandleType::EnterNewCur) {
diff --git a/lib/utils/mu-utils.hh b/lib/utils/mu-utils.hh
index 783351f86..f3817f39f 100644
--- a/lib/utils/mu-utils.hh
+++ b/lib/utils/mu-utils.hh
@@ -61,7 +61,7 @@ constexpr const auto SepaChar2 = '\xff';
 /*
  * Debug/error/warning logging
  *
- * The 'noexcept' means that they _wilL_ terminate the program
+ * The 'noexcept' means that they _will_ terminate the program
  * when the formatting fails (ie. a bug)
  */
 

From 23b39759e0a93f3fa4346cc43dce5118b91600ea Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 24 Sep 2024 23:23:37 +0300
Subject: [PATCH 113/305] man: update description of logging

Fixes #2762.
---
 man/common-options.inc |  7 +++----
 man/mu.1.org           | 11 +++++++++++
 2 files changed, 14 insertions(+), 4 deletions(-)

diff --git a/man/common-options.inc b/man/common-options.inc
index 15b4c5125..5cd178b57 100644
--- a/man/common-options.inc
+++ b/man/common-options.inc
@@ -2,9 +2,8 @@
 
 ** -d, --debug
 Makes *mu* generate extra debug information, useful for debugging the program
-itself. By default, debug information goes to the log file, _~/.cache/mu/mu.log_.
-It can safely be deleted when *mu* is not running. When running with *--debug*
-option, the log file can grow rather quickly. See the note on logging below.
+itself. Debug information goes to the standard logging location; see
+{{{man-link(mu,1)}}}.
 
 ** -q, --quiet
 Causes *mu* not to output informational messages and progress information to
@@ -14,7 +13,7 @@ recommended you use this option when using *mu* from scripts etc.
 
 ** --log-stderr
 Causes *mu* to not output log messages to standard error, in addition to sending
-them to the log file.
+them to the standard logging location.
 
 ** --nocolor
 Do not use ANSI colors. The environment variable *NO_COLOR* can be used as an
diff --git a/man/mu.1.org b/man/mu.1.org
index 7c7b715f0..d3b949841 100644
--- a/man/mu.1.org
+++ b/man/mu.1.org
@@ -79,6 +79,17 @@ The *index*, *find*, and *cfind* commands work with the database, while the othe
 ones work on individual mail files. Hence, running *view*, *mkdir* and *extract* does
 not require the *mu* database.
 
+* LOGGING
+
+*mu* logs to the standard logging location, which is either the systemd journal,
+*syslog* or a log file (by default, _~/.cache/mu/mu.log_), depending on your
+*system's setup; the first that appears to be working is used.
+
+When using a log file, it can safely be deleted when *mu* is not running. When
+running with *--debug* option, the log file can grow rather quickly. See the note
+on logging below.
+
+
 #+include: "common-options.inc" :minlevel 1
 
 #+include: "exit-code.inc" :minlevel 1

From 413c03ea1cc9e1f1139a826f357d26f7bb6b6d33 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Wed, 25 Sep 2024 00:04:21 +0300
Subject: [PATCH 114/305] mu4e-draft: always save before sending

This ensures fields (like Date:) are updated.
---
 mu4e/mu4e-draft.el | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/mu4e/mu4e-draft.el b/mu4e/mu4e-draft.el
index 367f580ad..a14e78301 100644
--- a/mu4e/mu4e-draft.el
+++ b/mu4e/mu4e-draft.el
@@ -465,6 +465,10 @@ appropriate flag at the message forwarded or replied-to."
       (message-remove-header "References")))
   (when use-hard-newlines
     (mu4e--send-harden-newlines))
+  ;; in any case, make sure to save the message; this will also trigger
+  ;; before/after save hooks, which fixes up various fields.
+  (set-buffer-modified-p t)
+  (save-buffer)
   ;; now handle what happens _after_ sending
   (add-hook 'message-sent-hook #'mu4e--compose-message-sent nil t))
 

From 262353996a884bfcdeef1bdd36f06231df3d4bb3 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Wed, 25 Sep 2024 19:11:56 +0300
Subject: [PATCH 115/305] mu-info: fix typo

---
 mu/mu-cmd-info.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mu/mu-cmd-info.cc b/mu/mu-cmd-info.cc
index 2e155fc70..7ff61f4ab 100644
--- a/mu/mu-cmd-info.cc
+++ b/mu/mu-cmd-info.cc
@@ -267,7 +267,7 @@ topic_mu(const Options& opts)
 #else
 			"no"
 #endif
-		, "Better 'm server' REPL for debugging?"});
+		, "Better 'mu server' REPL for debugging"});
 
 	if (!opts.nocolor)
 		colorify(info, opts);

From 9e0d0b8355be08f9dd4df82e3bbb57a1b1f29c59 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Wed, 25 Sep 2024 19:24:20 +0300
Subject: [PATCH 116/305] mu-init: fix typo in manpage, improve

---
 man/mu-init.1.org | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/man/mu-init.1.org b/man/mu-init.1.org
index 21e46e8a0..d790f2f5e 100644
--- a/man/mu-init.1.org
+++ b/man/mu-init.1.org
@@ -26,17 +26,18 @@ option is required; it must be an absolute path (but ~~/~ expansion is
 performed).
 
 ** --my-address _email-address-or-regex_
-Specifies that some e-mail address is `my-address' (the option can be used
-multiple times). Any message in which at least one of the contact fields
-contains such an address is considered a `personal' messages; this can then be
-used for filtering in {{{man-link(mu-find,1)}}}, {{{man-link(mu-cfind,1)}}} and
-*mu4e*, e.g. to filter-out mailing list messages.
+Specifies that some e-mail address is a personal address. The option can be used
+multiple times, to specify all your addresses.
+
+Any message in which at least one of the contact fields contains such an address
+is considered a `personal' message; this can then be used for filtering in
+{{{man-link(mu-find,1)}}}, {{{man-link(mu-cfind,1)}}} and *mu4e*, e.g. to
+filter-out mailing list messages.
 
 _email-address-or-regex_ can be either a plain e-mail address (such as
-*foo@example.com*), or a basic PCRE regular-expression (see
-{{{man-link(pcre,3)}}} for details), wrapped in */* (such as
-=/foo-.*@example\\.com/=). Depending on your shell, the argument may need to be
-quoted.
+*foo@example.com*), or a basic PCRE regular-expression (see {{{man-link(pcre,3)}}}
+for details), wrapped in */* (such as =/foo-.*@example\\.com/=). Depending on your
+shell, the argument may need to be quoted.
 
 ** --ignored-address _email-address-or-regex_
 Specifies that some e-mail address is to be ignored from the contacts-cache (the

From 8176663002fac592fed3c8406fa918b1ebca7028 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 28 Sep 2024 19:18:15 +0300
Subject: [PATCH 117/305] IDEAS.org: update

Fixes #2759
---
 IDEAS.org | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/IDEAS.org b/IDEAS.org
index 29ee0ebe7..2470026dd 100644
--- a/IDEAS.org
+++ b/IDEAS.org
@@ -51,6 +51,9 @@ future.
   this support, so it becomes more widely useful.
   https://github.com/djcb/mu/issues/1982
 
+- Display the messages from old-to-new (still get the newest though)
+  https://github.com/djcb/mu/issues/2759
+
 * Done
 
 - Support mu4e-mark-handle-when also for when leaving emacs

From d2343c6d62e7fe0638a6e60a55f0e72f01c0367d Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Mon, 16 Sep 2024 19:52:43 +0300
Subject: [PATCH 118/305] mu-server: try avoiding xapian multi-threaded access

Try to avoid multi-threaded operations with Xapian.

This remove the thread workers during indexing, and avoids the indexing
background thread. So, mu4e has to wait once again during indexing.

We can improve upon that, but first we need to know if it avoids the
problem of issue #2756.
---
 lib/mu-indexer.cc | 53 +++++++++++++++++++++++++++++++++--------------
 lib/mu-server.cc  | 37 +++++++++++++++++++++++++--------
 meson.build       | 10 ++++++++-
 meson_options.txt | 52 ++++++++++++++++++++++++++++++++--------------
 4 files changed, 110 insertions(+), 42 deletions(-)

diff --git a/lib/mu-indexer.cc b/lib/mu-indexer.cc
index 65603c278..12ff06a45 100644
--- a/lib/mu-indexer.cc
+++ b/lib/mu-indexer.cc
@@ -105,6 +105,7 @@ struct Indexer::Private {
 	bool handler(const std::string& fullpath, struct stat* statbuf, Scanner::HandleType htype);
 
 	void maybe_start_worker();
+
 	void item_worker();
 	void scan_worker();
 
@@ -135,6 +136,8 @@ struct Indexer::Private {
 		Type type;
 	};
 
+	void handle_item(WorkItem&& item);
+
 	AsyncQueue<WorkItem> todos_;
 
 	Progress   progress_{};
@@ -193,7 +196,11 @@ Indexer::Private::handler(const std::string& fullpath, struct stat* statbuf,
 		return true;
 	}
 	case Scanner::HandleType::LeaveDir: {
+#ifdef XAPIAN_SINGLE_THREADED
+		handle_item({fullpath, WorkItem::Type::Dir});
+#else
 		todos_.push({fullpath, WorkItem::Type::Dir});
+#endif /*XAPIAN_SINGLE_THREADED*/
 		return true;
 	}
 
@@ -210,9 +217,13 @@ Indexer::Private::handler(const std::string& fullpath, struct stat* statbuf,
 		if (statbuf->st_ctime <= dirstamp_ && store_.contains_message(fullpath))
 			return false;
 
+#ifdef XAPIAN_SINGLE_THREADED
+		handle_item({fullpath, WorkItem::Type::File});
+#else
 		// push the remaining messages to our "todo" queue for
 		// (re)parsing and adding/updating to the database.
 		todos_.push({fullpath, WorkItem::Type::File});
+#endif
 		return true;
 	}
 	default:
@@ -260,6 +271,30 @@ Indexer::Private::add_message(const std::string& path)
 	return true;
 }
 
+
+void
+Indexer::Private::handle_item(WorkItem&& item)
+{
+	try {
+		switch (item.type) {
+		case WorkItem::Type::File: {
+			if (G_LIKELY(add_message(item.full_path)))
+				++progress_.updated;
+		} break;
+		case WorkItem::Type::Dir:
+			store_.set_dirstamp(item.full_path, ::time(NULL));
+			break;
+		default:
+			g_warn_if_reached();
+			break;
+		}
+	} catch (const Mu::Error& er) {
+		mu_warning("error adding message @ {}: {}", item.full_path, er.what());
+	}
+}
+
+
+
 void
 Indexer::Private::item_worker()
 {
@@ -270,22 +305,8 @@ Indexer::Private::item_worker()
 	while (state_ == IndexState::Scanning) {
 		if (!todos_.pop(item, 250ms))
 			continue;
-		try {
-			switch (item.type) {
-			case WorkItem::Type::File: {
-				if (G_LIKELY(add_message(item.full_path)))
-					++progress_.updated;
-			} break;
-			case WorkItem::Type::Dir:
-				store_.set_dirstamp(item.full_path, ::time(NULL));
-				break;
-			default:
-				g_warn_if_reached();
-				break;
-			}
-		} catch (const Mu::Error& er) {
-			mu_warning("error adding message @ {}: {}", item.full_path, er.what());
-		}
+
+		handle_item(std::move(item));
 
 		maybe_start_worker();
 		std::this_thread::yield();
diff --git a/lib/mu-server.cc b/lib/mu-server.cc
index 9d21cab25..17c3acd83 100644
--- a/lib/mu-server.cc
+++ b/lib/mu-server.cc
@@ -149,6 +149,7 @@ struct Server::Private {
 	Store&            store() { return store_; }
 	const Store&      store() const { return store_; }
 	Indexer&          indexer() { return store().indexer(); }
+	void              do_index(const Indexer::Config& conf);
 	//CommandMap&       command_map() const { return command_map_; }
 
 	//
@@ -761,6 +762,20 @@ get_stats(const Indexer::Progress& stats, const std::string& state)
 	return sexp;
 }
 
+void
+Server::Private::do_index(const Indexer::Config& conf)
+{
+	StopWatch sw{"indexing"};
+	indexer().start(conf);
+	while (indexer().is_running()) {
+		std::this_thread::sleep_for(std::chrono::milliseconds(2000));
+		output_sexp(get_stats(indexer().progress(), "running"),
+			    Server::OutputFlags::Flush);
+	}
+	output_sexp(get_stats(indexer().progress(), "complete"),
+		    Server::OutputFlags::Flush);
+}
+
 void
 Server::Private::index_handler(const Command& cmd)
 {
@@ -770,22 +785,23 @@ Server::Private::index_handler(const Command& cmd)
 	// ignore .noupdate with an empty store.
 	conf.ignore_noupdate = store().empty();
 
+#ifdef XAPIAN_SINGLE_THREADED
+	// nothing to do
+	if (indexer().is_running()) {
+		throw Error{Error::Code::Xapian, "indexer is already running"};
+	}
+	do_index(conf);
+#else
 	indexer().stop();
 	if (index_thread_.joinable())
 		index_thread_.join();
 
 	// start a background track.
 	index_thread_ = std::thread([this, conf = std::move(conf)] {
-		StopWatch sw{"indexing"};
-		indexer().start(conf);
-		while (indexer().is_running()) {
-			std::this_thread::sleep_for(std::chrono::milliseconds(2000));
-			output_sexp(get_stats(indexer().progress(), "running"),
-				    Server::OutputFlags::Flush);
-		}
-		output_sexp(get_stats(indexer().progress(), "complete"),
-			    Server::OutputFlags::Flush);
+		do_index(conf);
 	});
+#endif /*XAPIAN_SINGLE_THREADED */
+
 }
 
 void
@@ -959,6 +975,9 @@ Server::Private::ping_handler(const Command& cmd)
 				       ":personal-addresses", std::move(addrs),
 				       ":database-path", store().path(),
 				       ":root-maildir", store().root_maildir(),
+#ifdef XAPIAN_SINGLE_THREADED
+				       ":xapian-single-threaded", Sexp::t_sym,
+#endif /*XAPIAN_SINGLE_THREADED*/
 				       ":doccount", storecount)));
 }
 
diff --git a/meson.build b/meson.build
index c7b07fe67..7aba9890e 100644
--- a/meson.build
+++ b/meson.build
@@ -133,7 +133,13 @@ add_project_arguments(['-DHAVE_CONFIG_H'], language: 'cpp')
 config_h_dep=declare_dependency(
   include_directories: include_directories(['.']))
 
-
+#
+# single-threaded Xapian access?
+#
+if get_option('xapian-single-threaded')
+  config_h_data.set('XAPIAN_SINGLE_THREADED', true)
+  message('use Xapian only in a single thread')
+endif
 #
 # d_type, d_ino are not available universally, so let's check
 # (we use them for optimizations in mu-scanner
@@ -322,6 +328,8 @@ if gmime_dep.version() == '3.2.13'
   warning('See: https://github.com/jstedfast/gmime/issues/133')
 endif
 
+
+
 # Local Variables:
 # indent-tabs-mode: nil
 # End:
diff --git a/meson_options.txt b/meson_options.txt
index 93bc7dbca..d79a3778d 100644
--- a/meson_options.txt
+++ b/meson_options.txt
@@ -14,36 +14,56 @@
 ## along with this program; if not, write to the Free Software Foundation,
 ## Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 
-option('tests',
+
+option('cld2',
        type : 'feature',
        value: 'auto',
-       description: 'build unit tests')
+       description: 'Add support for language-detection through cld2')
+
+#
+# emacs
+#
+
+option('emacs',
+       type: 'string',
+       value: 'emacs',
+       description: 'name/path of the emacs executable (for byte-compilation)')
+
+option('lispdir',
+       type: 'string',
+       description: 'path under which to install emacs-lisp files')
+
+
+#
+# guile
+#
 
 option('guile',
        type : 'feature',
        value: 'auto',
        description: 'build the guile scripting support (requires guile-3.x)')
 
-option('cld2',
-       type : 'feature',
-       value: 'auto',
-       description: 'Compact Language Detector2')
-
 # by default, this uses guile_dep.get_variable(pkgconfig: 'extensiondir')
 option('guile-extension-dir',
        type: 'string',
        description: 'custom install path for the guile extension module')
 
+
+#
+# misc
+#
+
+option('tests',
+       type : 'feature',
+       value: 'auto',
+       description: 'build unit tests')
+
+option('xapian-single-threaded',
+       type : 'boolean',
+       value: true,
+       description: 'only use Xapian from a single thread')
+
 option('readline',
        type: 'feature',
        value: 'auto',
        description: 'enable readline support for the mu4e repl')
-
-option('emacs',
-       type: 'string',
-       value: 'emacs',
-       description: 'name/path of the emacs executable')
-
-option('lispdir',
-       type: 'string',
-       description: 'path under which to install emacs-lisp files')

From e36d1554de4e395db7a91bb7dba06a10abe1c4a5 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Mon, 16 Sep 2024 22:47:39 +0300
Subject: [PATCH 119/305] mu4e: handle xapian single-threaded operation

Provide user feedback when we need to wait for the indexing to finish.

Suffix the version with "-st" when this is the case.
---
 mu4e/meson.build    | 10 ++++++++--
 mu4e/mu4e-main.el   |  6 ++++--
 mu4e/mu4e-server.el | 23 +++++++++++++++++++++--
 3 files changed, 33 insertions(+), 6 deletions(-)

diff --git a/mu4e/meson.build b/mu4e/meson.build
index a2a22bbd7..9fb00e669 100644
--- a/mu4e/meson.build
+++ b/mu4e/meson.build
@@ -16,14 +16,20 @@
 
 
 # generate some build data for use in mu4e
+version_extra=''
+if get_option('xapian-single-threaded')
+  version_extra='-st'
+endif
+
 mu4e_meta = configure_file(
   input: 'mu4e-config.el.in',
   output: 'mu4e-config.el',
   install: true,
   install_dir: mu4e_lispdir,
   configuration: {
-      'VERSION'         : meson.project_version(),
-      'MU_DOC_DIR'      : join_paths(datadir, 'doc', 'mu'),
+      'VERSION'           : meson.project_version(),
+      'MU_VERSION_EXTRA'  : version_extra,
+      'MU_DOC_DIR'        : join_paths(datadir, 'doc', 'mu'),
     })
 
 mu4e_pkg_desc = configure_file(
diff --git a/mu4e/mu4e-main.el b/mu4e/mu4e-main.el
index ffe22a583..3fab40231 100644
--- a/mu4e/mu4e-main.el
+++ b/mu4e/mu4e-main.el
@@ -1,6 +1,6 @@
 ;;; mu4e-main.el --- The Main interface for mu4e -*- lexical-binding: t -*-
 
-;; Copyright (C) 2011-2023 Dirk-Jan C. Binnema
+;; Copyright (C) 2011-2024 Dirk-Jan C. Binnema
 
 ;; Author: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ;; Maintainer: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
@@ -299,7 +299,9 @@ Otherwise, do nothing."
          "* "
          (propertize "mu4e" 'face 'mu4e-header-key-face)
          (propertize " - mu for emacs version " 'face 'mu4e-title-face)
-         (propertize  mu4e-mu-version 'face 'mu4e-header-key-face)
+         (propertize  (concat mu4e-mu-version
+                              (if (mu4e--server-xapian-single-threaded-p) "-st" ""))
+                      'face 'mu4e-header-key-face)
          "\n\n"
          (propertize "  Basics\n\n" 'face 'mu4e-title-face)
          (mu4e--main-action
diff --git a/mu4e/mu4e-server.el b/mu4e/mu4e-server.el
index fae835148..2122e8348 100644
--- a/mu4e/mu4e-server.el
+++ b/mu4e/mu4e-server.el
@@ -188,6 +188,11 @@ for bookmarks and maildirs.")
   "Get the latest server query items."
   mu4e--server-query-items)
 
+;; temporary
+(defun mu4e--server-xapian-single-threaded-p()
+  "Are we using Xapian in single-threaded mode?"
+  (plist-get mu4e--server-props :xapian-single-threaded))
+
 
 ;;; Handling raw server data
 
@@ -210,6 +215,9 @@ for bookmarks and maildirs.")
           mu4e--server-cookie-post)
   "Regular expression matching the length cookie.
 Match 1 will be the length (in hex).")
+
+(defvar mu4e--server-indexing nil "Currently indexing?")
+
 
 (defun mu4e-running-p ()
   "Whether mu4e is running.
@@ -383,6 +391,11 @@ The server output is as follows:
 
          ;; get some info
          ((plist-get sexp :info)
+          ;; when indexing is finished, remove the block
+          (when (and (eq (plist-get sexp :info) 'index)
+                     (eq (plist-get sexp :status) 'complete))
+            (setq mu4e--server-indexing nil))
+
           (funcall mu4e-info-func sexp))
 
          ;; get some data
@@ -486,6 +499,7 @@ You cannot run the repl when mu4e is running (or vice-versa)."
          (proc (and (buffer-live-p buf) (get-buffer-process buf))))
     (when proc
       (mu4e-message "shutting down")
+      (setq mu4e--server-indexing nil)
       (set-process-filter mu4e--server-process nil)
       (set-process-sentinel mu4e--server-process nil)
       (let ((delete-exited-processes t))
@@ -526,7 +540,11 @@ You cannot run the repl when mu4e is running (or vice-versa)."
 
 (defun mu4e--server-call-mu (form)
   "Call the mu server with some command FORM."
-  (unless (mu4e-running-p) (mu4e--server-start))
+  (unless (mu4e-running-p)
+    (mu4e--server-start))
+  ;; in single-threaded mode, mu can't accept our command right now.
+  (when (and (mu4e--server-xapian-single-threaded-p) mu4e--server-indexing)
+    (mu4e-warn "Cannot handle command while indexing, please retry later."))
   (let* ((print-length nil) (print-level nil)
          (cmd (format "%S" form)))
     (mu4e-log 'to-server "%s" cmd)
@@ -600,7 +618,8 @@ added or removed), since merely editing a message does not update
 the directory time stamp."
   (mu4e--server-call-mu
    `(index :cleanup ,(and cleanup t)
-           :lazy-check ,(and lazy-check t))))
+           :lazy-check ,(and lazy-check t)))
+  (setq mu4e--server-indexing t)) ;; remember we're indexing.
 
 (defun mu4e--server-mkdir (path &optional update)
   "Create a new maildir-directory at filesystem PATH.

From 0da33b3d7f7948a922670d86bcd70e80a84c10ca Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 6 Oct 2024 10:43:30 +0300
Subject: [PATCH 120/305] mu4e-server: fix some flycheck warnings

---
 mu4e/mu4e-server.el | 26 +++++++++++++++-----------
 1 file changed, 15 insertions(+), 11 deletions(-)

diff --git a/mu4e/mu4e-server.el b/mu4e/mu4e-server.el
index 2122e8348..204ef3e4e 100644
--- a/mu4e/mu4e-server.el
+++ b/mu4e/mu4e-server.el
@@ -29,7 +29,7 @@
 
 ;;; Configuration
 (defcustom mu4e-mu-home nil
-  "Location of an alternate mu home dir.
+  "Location of an alternate mu home directory.
 If not set, use the defaults, based on the XDG Base Directory
 Specification.
 
@@ -257,15 +257,18 @@ removed."
 (defun mu4e--server-plist-get (plist key)
   "Like `plist-get' but load data from file if it is a string.
 
-I.e. (mu4e--server-plist-get (:foo bar) :foo)
+PLIST is a property-list, and KEY is the the key to search for.
+
+
+E.g., (mu4e--server-plist-get (:foo bar) :foo)
   => bar
 but
      (mu4e--server-plist-get (:foo \"/tmp/data.eld\") :foo)
   => evaluates the contents of /tmp/data.eld
    (and deletes the file afterward).
 
-This for the few sexps we get from the mu server that support this
-(headers, contacts, maildirs)."
+This for the few sexps we get from the mu server that support
+ this -- headers, contacts, maildirs."
   ;; XXX: perhaps re-use the same buffer?
   (let ((val (plist-get plist key)))
     (if (stringp val)
@@ -436,6 +439,7 @@ As per issue #2198."
                 ,(when mu4e-mu-home (format "--muhome=%s" mu4e-mu-home)))))
 
 (defun mu4e--version-check ()
+  "Verify that the versions for mu4e and mu are the same."
   ;; sanity-check 1
   (let ((default-directory temporary-file-directory)) ;;ensure it's local.
     (unless (and mu4e-mu-binary (file-executable-p mu4e-mu-binary))
@@ -531,12 +535,12 @@ You cannot run the repl when mu4e is running (or vice-versa)."
        ((eq code 0)
         (message nil)) ;; don't do anything
        ((eq code 11)
-        (error "schema mismatch; please re-init mu from command-line"))
+        (error "Schema mismatch; please re-init mu from command-line"))
        ((eq code 19)
-        (error "mu database is locked by another process"))
-       (t (error "mu server process ended with exit code %d" code))))
+        (error "Mu database is locked by another process"))
+       (t (error "Mu server process ended with exit code %d" code))))
      (t
-      (error "something bad happened to the mu server process")))))
+      (error "Something bad happened to the mu server process")))))
 
 (defun mu4e--server-call-mu (form)
   "Call the mu server with some command FORM."
@@ -609,7 +613,7 @@ or an error."
 (defun mu4e--server-index (&optional cleanup lazy-check)
   "Index messages.
 If CLEANUP is non-nil, remove messages which are in the database
-but no longer in the filesystem. If LAZY-CHECK is non-nil, only
+but no longer in the file system. If LAZY-CHECK is non-nil, only
 consider messages for which the time stamp (ctime) of the
 directory they reside in has not changed since the previous
 indexing run. This is much faster than the non-lazy check, but
@@ -622,7 +626,7 @@ the directory time stamp."
   (setq mu4e--server-indexing t)) ;; remember we're indexing.
 
 (defun mu4e--server-mkdir (path &optional update)
-  "Create a new maildir-directory at filesystem PATH.
+  "Create a new maildir-directory at file system PATH.
 When UPDATE is non-nil, send a update when completed.
 PATH must be below the root-maildir."
   ;; handle maildir cache
@@ -693,7 +697,7 @@ read/unread status are returned in the pong-response."
   (mu4e--server-call-mu `(queries :queries ,queries)))
 
 (defun mu4e--server-remove (docid-or-path)
-  "Remove message with either DOCID or PATH.
+  "Remove message with either DOCID-OR-PATH.
 The results are reported through either (:update ... )
 or (:error) sexps."
   (if (stringp docid-or-path)

From aa4946cfe5d1072acec5080be72ce1ea4e3591e8 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 8 Oct 2024 23:32:25 +0300
Subject: [PATCH 121/305] mu4e-mime-parts: don't try to open non-files

When completion fails, don't try to open any files in
mu4e-view-save-attachments.
---
 mu4e/mu4e-mime-parts.el | 20 +++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/mu4e/mu4e-mime-parts.el b/mu4e/mu4e-mime-parts.el
index 707ae477d..3a5350bdc 100644
--- a/mu4e/mu4e-mime-parts.el
+++ b/mu4e/mu4e-mime-parts.el
@@ -297,13 +297,13 @@ does not have this limitation."
   (interactive "P")
   (let* ((parts (mu4e-view-mime-parts))
          (candidates  (seq-map
-                         (lambda (fpart)
-                           (cons ;; (filename . annotation)
-                            (plist-get fpart :filename)
-                            fpart))
-                         (seq-filter
-                          (lambda (part) (plist-get part :attachment-like))
-                          parts)))
+                       (lambda (fpart)
+                         (cons ;; (filename . annotation)
+                          (plist-get fpart :filename)
+                          fpart))
+                       (seq-filter
+                        (lambda (part) (plist-get part :attachment-like))
+                        parts)))
          (candidates (or candidates
                          (mu4e-warn "No attachments for this message")))
          (files (mu4e--completing-read "Save file(s): " candidates
@@ -316,8 +316,10 @@ does not have this limitation."
                      (path (mu4e--uniqify-file-name
                             (mu4e-join-paths
                              (or custom-dir (plist-get part :target-dir))
-                             (plist-get part :filename)))))
-                (mm-save-part-to-file (plist-get part :handle) path)))
+                             (plist-get part :filename))))
+                     (handle (plist-get part :handle)))
+                (when handle ;; completion may fail, and then there's no handle.
+                  (mm-save-part-to-file handle path))))
             files)))
 
 (defvar mu4e-view-mime-part-actions

From 96506300cf01abcbbee0a4bb2dada0f42fc1b6df Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Wed, 9 Oct 2024 17:58:55 +0300
Subject: [PATCH 122/305] mu4e-view-save-attachments: document limitation with
 crm-separator

As discussed in #2768.
---
 mu4e/mu4e-mime-parts.el | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/mu4e/mu4e-mime-parts.el b/mu4e/mu4e-mime-parts.el
index 3a5350bdc..86ca1b7d4 100644
--- a/mu4e/mu4e-mime-parts.el
+++ b/mu4e/mu4e-mime-parts.el
@@ -291,9 +291,15 @@ one is determined using `mu4e-attachment-dir'.
 
 This command assumes unique filenames for the attachments, since
 that is how the underlying completion mechanism works. If there
-are duplicates, only one is recognized. For this corner-case, it
-is recommended to use `mu4e-view-mime-part-action' instead, which
-does not have this limitation."
+are duplicates, only one is recognized.
+
+Furthermore, file-names that match `crm-separator' (by default,
+commas) are not supported (see `completing-read-multiple' for
+further details).
+
+For such corner-cases, it is recommended to use
+`mu4e-view-mime-part-action' instead, which does not have this
+limitation."
   (interactive "P")
   (let* ((parts (mu4e-view-mime-parts))
          (candidates  (seq-map

From 814ecc9882e7ff53c38d79aa731b9b0bd0c6d167 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Wed, 16 Oct 2024 22:45:22 +0300
Subject: [PATCH 123/305] mu4e.texi: document thread-mark behavior when there
 are no threads

Fixes #2771.
---
 mu4e/mu4e.texi | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index 9b791e1d1..11056a25a 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -2343,7 +2343,9 @@ view} matching a certain pattern with @kbd{M-x mu4e-headers-mark-pattern}
 (@key{%})
 @item @emph{thread/subthread}: You can put a mark on all the messages in the
 thread/subthread at point with @kbd{M-x mu4e-headers-mark-thread} and @kbd{M-x
-mu4e-headers-mark-subthread}, respectively
+mu4e-headers-mark-subthread}, respectively. When you haven't enabled separate
+threads in the headers view, the thread marking functions simply mark @emph{all}
+messages.
 @end itemize
 
 @node What to mark for
@@ -4103,6 +4105,9 @@ functions like @code{mu4e-headers-mark-thread} (@key{T}),
 time, and @code{mu4e-headers-mark-pattern} (@key{%}) to mark all messages
 matching a certain regular expression.
 
+Note that when you haven't enabled separate threads in the headers view, the
+thread marking functions simply mark @emph{all} messages.
+
 @subsection Can I automatically apply the marks on messages when leaving the headers buffer?
 Yes you can --- see the documentation for the variable
 @t{mu4e-headers-leave-behavior}.

From 7776e2b798aca3f47ba049c51da1a810a8a0401c Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Wed, 16 Oct 2024 23:51:16 +0300
Subject: [PATCH 124/305] mu4e-mark-at-point: update docstring for 'trash'

Fixes #2767.
---
 mu4e/mu4e-mark.el | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mu4e/mu4e-mark.el b/mu4e/mu4e-mark.el
index c3947a7cf..39103bad0 100644
--- a/mu4e/mu4e-mark.el
+++ b/mu4e/mu4e-mark.el
@@ -233,7 +233,7 @@ The following marks are available, and the corresponding props:
    `flag'      n        mark this message for flagging
    `move'      y        move the message to some folder
    `read'      n        mark the message as read
-   `trash'     y        trash the message to some folder
+   `trash'     n        trash the message to some folder
    `unflag'    n        mark this message for unflagging
    `untrash'   n        remove the `trashed' flag from a message
    `unmark'    n        unmark this message

From 954040fa5189d0e9507b102a5e6b4ffe8e926f85 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 20 Oct 2024 16:56:42 +0300
Subject: [PATCH 125/305] IDEAS.org: update for file-name with comma

Closes #2768
---
 IDEAS.org | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/IDEAS.org b/IDEAS.org
index 2470026dd..2a29f2015 100644
--- a/IDEAS.org
+++ b/IDEAS.org
@@ -19,11 +19,6 @@ future.
   https://github.com/djcb/mu/issues/2308
   Shouldn't be _too_ hard, for someone that uses the functionality.
 
-- Make sorting stable if there are multiple messages with the same date. We
-  _could_ do this by adding some random millisecs to each messasge's timestamp; _or_
-  complicating the search (i.e., the message hash?). Maybe leave as is?
-  https://github.com/djcb/mu/issues/2527
-
 - Include "message summary" in message information, for display in the headers
   buffer: https://github.com/djcb/mu/issues/1821 It's not so easy to get a
   useful one line description... perhaps the first line after the "Dear x,"?
@@ -54,6 +49,16 @@ future.
 - Display the messages from old-to-new (still get the newest though)
   https://github.com/djcb/mu/issues/2759
 
+- Make sorting stable if there are multiple messages with the same date. We
+  _could_ do this by adding some random millisecs to each messasge's timestamp; _or_
+  complicating the search (i.e., the message hash?). Maybe leave as is?
+  https://github.com/djcb/mu/issues/2527
+
+
+- Perhaps better support file names with commas.. perhaps temporarily add some
+  invisible unicode to fool crm-separator?
+  https://github.com/djcb/mu/issues/2768
+
 * Done
 
 - Support mu4e-mark-handle-when also for when leaving emacs

From 36cb0b9f5834f76a13e2332fb67a779bd00996a7 Mon Sep 17 00:00:00 2001
From: zuphinx <zuphinx@nowhere.net>
Date: Sat, 19 Oct 2024 12:30:06 -0700
Subject: [PATCH 126/305] doc(mu4e--server-move): typos

---
 mu4e/mu4e-server.el | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/mu4e/mu4e-server.el b/mu4e/mu4e-server.el
index 204ef3e4e..d37988f8f 100644
--- a/mu4e/mu4e-server.el
+++ b/mu4e/mu4e-server.el
@@ -664,12 +664,12 @@ The server reports the results for the operation through
 `mu4e-update-func'.
 
 If the variable `mu4e-change-filenames-when-moving' is
-non-nil, moving to a different maildir generates new names forq
+non-nil, moving to a different maildir generates new names for
 the target files; this helps certain tools (such as mbsync).
 
 If NO-VIEW is non-nil, do not update the view.
 
-Returns either (:update ... ) or (:error ) sexp, which are handled my
+Returns either (:update ... ) or (:error ) sexp, which are handled by
 `mu4e-update-func' and `mu4e-error-func', respectively."
   (unless (or maildir flags)
     (mu4e-error "At least one of maildir and flags must be specified"))

From 0f16b22bf7907769a47d1a525dbe2e22348fd5cf Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 27 Oct 2024 21:37:32 +0200
Subject: [PATCH 127/305] build: bump version to 1.12.7

---
 meson.build | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/meson.build b/meson.build
index 7aba9890e..7ea5f737f 100644
--- a/meson.build
+++ b/meson.build
@@ -17,7 +17,7 @@
 ################################################################################
 # project setup
 project('mu', ['c', 'cpp'],
-        version: '1.12.6',
+        version: '1.12.7',
         meson_version: '>= 0.56.0',
         license: 'GPL-3.0-or-later',
         default_options : [
@@ -26,9 +26,9 @@ project('mu', ['c', 'cpp'],
           'c_std=c11',
           'cpp_std=c++17'])
 
-# hard-code the date here (for reproduciblity); we derive the dates used in e.g.
+# hard-code the date here (for reproducibility); we derive the dates used in e.g.
 # documentation from this.
-mu_date='2024-07-27'
+mu_date='2024-10-27'
 
 # installation paths
 prefixdir = get_option('prefix')

From b4adf328f4e26f729dca10331c647d4e8b36a4d4 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Mon, 28 Oct 2024 21:50:49 +0200
Subject: [PATCH 128/305] mu4e: use if-let*, when-let*

Avoid the silly byte-compilation warning
---
 mu4e/mu4e-actions.el    |  2 +-
 mu4e/mu4e-bookmarks.el  |  4 ++--
 mu4e/mu4e-contacts.el   |  2 +-
 mu4e/mu4e-draft.el      | 12 ++++++------
 mu4e/mu4e-headers.el    |  4 ++--
 mu4e/mu4e-helpers.el    |  4 ++--
 mu4e/mu4e-lists.el      |  2 +-
 mu4e/mu4e-message.el    |  4 ++--
 mu4e/mu4e-mime-parts.el |  2 +-
 mu4e/mu4e-thread.el     |  2 +-
 mu4e/mu4e-view.el       |  8 ++++----
 mu4e/mu4e-window.el     | 10 +++++-----
 12 files changed, 28 insertions(+), 28 deletions(-)

diff --git a/mu4e/mu4e-actions.el b/mu4e/mu4e-actions.el
index 543ebac85..e7354e464 100644
--- a/mu4e/mu4e-actions.el
+++ b/mu4e/mu4e-actions.el
@@ -257,7 +257,7 @@ the message."
   "Browse the archive for a mailing list message MSG.
 See `mu4e-mailing-list-archive-url'."
   (interactive (list (mu4e-message-at-point)))
-  (if-let ((url (mu4e-mailing-list-archive-url msg)))
+  (if-let* ((url (mu4e-mailing-list-archive-url msg)))
     (browse-url url)
     (mu4e-warn "No archive available for this message")))
 
diff --git a/mu4e/mu4e-bookmarks.el b/mu4e/mu4e-bookmarks.el
index 452169bef..ee071df2f 100644
--- a/mu4e/mu4e-bookmarks.el
+++ b/mu4e/mu4e-bookmarks.el
@@ -152,7 +152,7 @@ I.e., very new messages.")
 (defun mu4e-jump-to-favorite ()
   "Jump to to the favorite bookmark, if any."
   (interactive)
-  (when-let ((fav (mu4e--bookmark-query (mu4e-bookmark-favorite))))
+  (when-let* ((fav (mu4e--bookmark-query (mu4e-bookmark-favorite))))
     (mu4e-search-bookmark fav)))
 
 (defun mu4e--bookmarks-modeline-item ()
@@ -160,7 +160,7 @@ I.e., very new messages.")
 
 This uses the one special ':favorite' bookmark, and if there is
 one, creates a propertized string for display in the modeline."
-  (when-let ((fav ;; any results for the favorite bookmark item?
+  (when-let* ((fav ;; any results for the favorite bookmark item?
               (seq-find (lambda (bm) (plist-get bm :favorite))
                         (mu4e-query-items 'bookmarks))))
     (cl-destructuring-bind (&key unread count delta-unread
diff --git a/mu4e/mu4e-contacts.el b/mu4e/mu4e-contacts.el
index 025cac44a..6a18ac1a4 100644
--- a/mu4e/mu4e-contacts.el
+++ b/mu4e/mu4e-contacts.el
@@ -131,7 +131,7 @@ The address are either plain e-mail addresses or regexps (strings
  address patterns (if any)."
   (seq-remove
    (lambda (addr) (and no-regexp (string-match-p "^/.*/" addr)))
-   (when-let ((props (mu4e-server-properties)))
+   (when-let* ((props (mu4e-server-properties)))
      (plist-get props :personal-addresses))))
 
 (defun mu4e-personal-address-p (addr)
diff --git a/mu4e/mu4e-draft.el b/mu4e/mu4e-draft.el
index a14e78301..c44ccae3a 100644
--- a/mu4e/mu4e-draft.el
+++ b/mu4e/mu4e-draft.el
@@ -387,7 +387,7 @@ also marked as Seen.
 
 Function assumes that it is executed in the context of the
 message buffer."
-  (when-let ((buf (find-file-noselect path)))
+  (when-let* ((buf (find-file-noselect path)))
     (with-current-buffer buf
       (let ((in-reply-to (message-field-value "in-reply-to"))
             (forwarded-from)
@@ -445,14 +445,14 @@ appropriate flag at the message forwarded or replied-to."
   ;; typically, draft is gone and the sent message appears in sent. Update flags
   ;; for related messages, i.e. for Forwarded ('Passed') and Replied messages,
   ;; try to set the appropriate flag at the message forwarded or replied-to.
-  (when-let ((fcc-path (message-field-value "Fcc")))
+  (when-let* ((fcc-path (message-field-value "Fcc")))
     (mu4e--set-parent-flags fcc-path)
     ;; we end up with a ((buried) buffer here, visiting the
     ;; fcc-path; not quite sure why. But let's get rid of it (#2681)
-    (when-let ((buf (find-buffer-visiting fcc-path)))
+    (when-let* ((buf (find-buffer-visiting fcc-path)))
       (kill-buffer buf)))
   ;; remove draft
-  (when-let ((draft (buffer-file-name)))
+  (when-let* ((draft (buffer-file-name)))
     (mu4e--server-remove draft)))
 
 (defun mu4e--compose-before-send ()
@@ -492,7 +492,7 @@ Creates a buffer NAME and returns it."
 (defun mu4e--message-is-yours-p ()
   "Mu4e's override for `message-is-yours-p'."
   (seq-some (lambda (field)
-              (if-let ((recip (message-field-value field)))
+              (if-let* ((recip (message-field-value field)))
                   (mu4e-personal-or-alternative-address-p
                    (car (mail-header-parse-address recip)))))
             '("From" "Sender")))
@@ -596,7 +596,7 @@ COMPOSE-TYPE and PARENT are as in `mu4e--draft'."
     (set-visited-file-name ;; make it a draft file
      (mu4e--draft-message-path (mu4e--draft-basename) parent)))
   ;; fcc
-  (when-let ((fcc-path (mu4e--fcc-path (mu4e--draft-basename) parent)))
+  (when-let* ((fcc-path (mu4e--fcc-path (mu4e--draft-basename) parent)))
     (message-add-header (concat "Fcc: " fcc-path "\n")))
 
   (mu4e--prepare-draft-headers compose-type)
diff --git a/mu4e/mu4e-headers.el b/mu4e/mu4e-headers.el
index bbd0562bf..691277f95 100644
--- a/mu4e/mu4e-headers.el
+++ b/mu4e/mu4e-headers.el
@@ -669,7 +669,7 @@ This is suitable for displaying in the header view."
 
 (defsubst mu4e~headers-insert-header (msg pos)
   "Insert a header for MSG at point POS."
-  (when-let ((line (mu4e~message-header-line msg))
+  (when-let* ((line (mu4e~message-header-line msg))
              (docid (plist-get msg :docid)))
     (goto-char pos)
     (insert
@@ -1436,7 +1436,7 @@ If SUBTHREAD is non-nil, only apply to subthread."
           (if (functionp mu4e-view-auto-mark-as-read)
               (funcall mu4e-view-auto-mark-as-read msg)
             mu4e-view-auto-mark-as-read)))
-    (when-let ((buf (mu4e-get-view-buffer (current-buffer) nil)))
+    (when-let* ((buf (mu4e-get-view-buffer (current-buffer) nil)))
       (with-current-buffer buf
         (mu4e-loading-mode 1)))
     (mu4e--server-view docid mark-as-read)))
diff --git a/mu4e/mu4e-helpers.el b/mu4e/mu4e-helpers.el
index 01deba0e2..c96509b58 100644
--- a/mu4e/mu4e-helpers.el
+++ b/mu4e/mu4e-helpers.el
@@ -259,7 +259,7 @@ Return the matching choice value (cdr of the cell)."
                         (mapconcat #'car choices ", "))))
     (while (not chosen)
       (message nil) ;; this seems needed...
-      (when-let ((kar (read-char-exclusive prompt)))
+      (when-let* ((kar (read-char-exclusive prompt)))
         (when (eq kar ?\e) (keyboard-quit)) ;; `read-char-exclusive' is a C
                                             ;; function and doesn't check for
                                             ;; `keyboard-quit', there we need to
@@ -543,7 +543,7 @@ Or go to the top level if there is none."
 
 (defun mu4e--jump-to-bookmark (bookmark)
   "View the message referred to by BOOKMARK."
-  (when-let ((msgid (bookmark-prop-get bookmark 'message-id)))
+  (when-let* ((msgid (bookmark-prop-get bookmark 'message-id)))
     (mu4e-view-message-with-message-id msgid)))
 
 ;;; Macros
diff --git a/mu4e/mu4e-lists.el b/mu4e/mu4e-lists.el
index f19239fee..43181cd54 100644
--- a/mu4e/mu4e-lists.el
+++ b/mu4e/mu4e-lists.el
@@ -40,7 +40,7 @@ e.g. public-inbox-based archives."
 (defmacro mu4e-x-seq-url (base-url)
   "Construct x-seq archive URL for MSG or nil if not found."
   `(lambda (msg)
-     (when-let ((xseq (mu4e-fetch-field msg "X-Seq")))
+     (when-let* ((xseq (mu4e-fetch-field msg "X-Seq")))
        (concat ,base-url "/" xseq))))
 
 ;;; Configuration
diff --git a/mu4e/mu4e-message.el b/mu4e/mu4e-message.el
index fd6295c07..e42ed4557 100644
--- a/mu4e/mu4e-message.el
+++ b/mu4e/mu4e-message.el
@@ -238,9 +238,9 @@ Returns the full path."
 (defun mu4e-sexp-at-point ()
   "Show or hide the s-expression for the message-at-point, if any."
   (interactive)
-  (if-let ((win (get-buffer-window mu4e--sexp-buffer-name)))
+  (if-let* ((win (get-buffer-window mu4e--sexp-buffer-name)))
       (delete-window win)
-    (when-let ((msg (mu4e-message-at-point 'noerror)))
+    (when-let* ((msg (mu4e-message-at-point 'noerror)))
       (when (buffer-live-p mu4e--sexp-buffer-name)
         (kill-buffer mu4e--sexp-buffer-name))
       (with-current-buffer-window
diff --git a/mu4e/mu4e-mime-parts.el b/mu4e/mu4e-mime-parts.el
index 86ca1b7d4..012d58696 100644
--- a/mu4e/mu4e-mime-parts.el
+++ b/mu4e/mu4e-mime-parts.el
@@ -97,7 +97,7 @@ There are some internal fields as well, e.g. ; subject to change:
          (save-excursion
            (goto-char (point-min))
            (while (not (eobp))
-             (when-let ((part (get-text-property (point) 'gnus-data))
+             (when-let* ((part (get-text-property (point) 'gnus-data))
                         (index (get-text-property (point) 'gnus-part)))
                (when (and part (numberp index) (not (member index indices)))
                  (let* ((disp (mm-handle-disposition part))
diff --git a/mu4e/mu4e-thread.el b/mu4e/mu4e-thread.el
index c97374561..2f093b8f6 100644
--- a/mu4e/mu4e-thread.el
+++ b/mu4e/mu4e-thread.el
@@ -206,7 +206,7 @@ Reset individual folding states."
   "Unfold thread at point and store state unless NO-SAVE is t."
   (interactive)
   (unless (eq (line-end-position) (point-max))
-    (when-let ((overlay (mu4e-thread-is-folded)))
+    (when-let* ((overlay (mu4e-thread-is-folded)))
       (unless no-save
         (mu4e-thread--save-state 'unfolded))
       (delete-overlay overlay))))
diff --git a/mu4e/mu4e-view.el b/mu4e/mu4e-view.el
index d479964f3..075c55878 100644
--- a/mu4e/mu4e-view.el
+++ b/mu4e/mu4e-view.el
@@ -615,7 +615,7 @@ As a side-effect, a message that is being viewed loses its
   ;; buffer-local state that *must* survive is correctly copied
   ;; across.
   (let ((linked-headers-buffer))
-    (when-let ((existing-buffer (mu4e-get-view-buffer nil nil)))
+    (when-let* ((existing-buffer (mu4e-get-view-buffer nil nil)))
       ;; required; this state must carry over from the killed buffer
       ;; to the new one.
       (setq linked-headers-buffer mu4e-linked-headers-buffer)
@@ -749,7 +749,7 @@ determine which browser function to use."
   "Refresh the message view."
   ;;; XXX: sometimes, side-effect: increase the header-buffers size
   (interactive)
-  (when-let ((msg (and (derived-mode-p 'mu4e-view-mode)
+  (when-let* ((msg (and (derived-mode-p 'mu4e-view-mode)
                        mu4e--view-message)))
     (mu4e-view-quit)
     (mu4e-view msg)))
@@ -789,7 +789,7 @@ Note that for some messages, this can trigger high CPU load."
               ((or ':path ':maildir ':list)
                (mu4e--view-gnus-insert-header field fieldval))
               (':message-id
-               (when-let ((msgid (plist-get msg :message-id)))
+               (when-let* ((msgid (plist-get msg :message-id)))
                  (mu4e--view-gnus-insert-header field (format "<%s>" msgid))))
               (':mailing-list
                (let ((list (plist-get msg :list)))
@@ -1109,7 +1109,7 @@ Article Treatment' for more options."
   ;; This function assumes `gnus-article-mime-handle-alist' is sorted by
   ;; pertinence, i.e. the first HTML part found in it is the most important one.
   (save-excursion
-    (if-let ((html-part
+    (if-let*((html-part
               (seq-find (lambda (handle)
                           (equal (mm-handle-media-type (cdr handle))
                                  "text/html"))
diff --git a/mu4e/mu4e-window.el b/mu4e/mu4e-window.el
index af2e9335d..8437b0980 100644
--- a/mu4e/mu4e-window.el
+++ b/mu4e/mu4e-window.el
@@ -263,7 +263,7 @@ This is an action function for buffer display, see Info
 node `(elisp) Buffer Display Action Functions'.  It should be
 called only by `display-buffer' or a function directly or
 indirectly called by the latter."
-    (when-let ((window (or (display-buffer-reuse-window buffer alist)
+    (when-let* ((window (or (display-buffer-reuse-window buffer alist)
                            (display-buffer-same-window buffer alist)
                            (display-buffer-pop-up-window buffer alist)
                            (display-buffer-use-some-window buffer alist))))
@@ -364,9 +364,9 @@ and `mu4e-headers-visible-lines' or
 This function is best called from the hook
 `mu4e-view-rendered-hook'."
   (unless (mu4e-current-buffer-type-p 'view)
-    (mu4e-error "Cannot resize as this is not a valid view buffer."))
-  (when-let (win (and mu4e-linked-headers-buffer
-                      (get-buffer-window mu4e-linked-headers-buffer)))
+    (mu4e-error "Cannot resize as this is not a valid view buffer"))
+  (when-let* ((win (and mu4e-linked-headers-buffer
+                          (get-buffer-window mu4e-linked-headers-buffer)))
     ;; This can fail for any number of reasons. If it does, we do
     ;; nothing. If the user has customized the window display we may
     ;; find it impossible to resize the window, and that should not be
@@ -377,7 +377,7 @@ This function is best called from the hook
                                    (window-width win nil))
                             t t nil))
             ((eq mu4e-split-view 'horizontal)
-             (set-window-text-height win mu4e-headers-visible-lines))))))
+             (set-window-text-height win mu4e-headers-visible-lines)))))))
 
 (provide 'mu4e-window)
 ;;; mu4e-window.el ends here

From 7e6ab29f12538cba0be2448324271849551b3bed Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Mon, 28 Oct 2024 21:56:56 +0200
Subject: [PATCH 129/305] mu4e-view-mime-part-action: unbreak prefix arg

As proposed by user @foudfou on Github.

Fixes #2776.
---
 mu4e/mu4e-mime-parts.el | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mu4e/mu4e-mime-parts.el b/mu4e/mu4e-mime-parts.el
index 012d58696..1e681e1fa 100644
--- a/mu4e/mu4e-mime-parts.el
+++ b/mu4e/mu4e-mime-parts.el
@@ -421,7 +421,7 @@ If N is not specified, ask for it. For instance, '3 A o' opens
 the third MIME-part."
   ;; (interactive
   ;;  (list (read-number "Number of MIME-part: ")))
-  (interactive)
+  (interactive "P")
   (let* ((parts (mu4e-view-mime-parts))
          (candidates (seq-map
                       (lambda (part)

From ae29b2dd0ff1a0f19043116642b4959e33ed5ec5 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 29 Oct 2024 19:08:34 +0200
Subject: [PATCH 130/305] mu4e: fix mu4e~headers-maybe-auto-update

The check for # of marked message was flawed since mu4e-mark-marks-num
should we called from the headers buffer (and wasn't, necessarily).

Fixes #2779.
---
 mu4e/mu4e-headers.el | 28 ++++++++++++++++------------
 1 file changed, 16 insertions(+), 12 deletions(-)

diff --git a/mu4e/mu4e-headers.el b/mu4e/mu4e-headers.el
index 691277f95..c214ce894 100644
--- a/mu4e/mu4e-headers.el
+++ b/mu4e/mu4e-headers.el
@@ -1093,19 +1093,23 @@ true, do *not* update the query history stack."
 
 (defun mu4e~headers-maybe-auto-update ()
   "Update the current headers buffer after indexing changes.
+
 Furthermore, `mu4e-headers-auto-update' is non-nil and there is
-no user-interaction ongoing."
-  (when (and mu4e-headers-auto-update ;; must be set
-             mu4e-index-update-status
-             (not (mu4e-get-view-buffer)) ;; not when viewing a message
-             (not (zerop (plist-get mu4e-index-update-status :updated)))
-             ;; NOTE: `mu4e-mark-marks-num' can return nil. Is that intended?
-             (zerop (or (mu4e-mark-marks-num) 0)) ;; non active marks
-             (not (active-minibuffer-window)))    ;; no user input only
-    ;; rerun search if there's a live window with search results;
-    ;; otherwise we'd trigger a headers view from out of nowhere.
-    (when (and (buffer-live-p (mu4e-get-headers-buffer))
-               (window-live-p (get-buffer-window (mu4e-get-headers-buffer) t)))
+no user-interaction ongoing.
+
+We only update headers when quite a few conditions are true --
+see the code."
+  (when-let* ((hdrsbuf (mu4e-get-headers-buffer)))
+    (when (and mu4e-headers-auto-update ;; must be set
+               mu4e-index-update-status
+               (not (mu4e-get-view-buffer)) ;; not when viewing a message
+               (not (zerop (plist-get mu4e-index-update-status :updated)))
+               (buffer-live-p hdrsbuf)
+               (window-live-p (get-buffer-window hdrsbuf t))
+               ;; don't disturb marks.
+               (zerop (or (with-current-buffer hdrsbuf (mu4e-mark-marks-num)) 0))
+               (not (active-minibuffer-window))) ;; no user input only
+      ;; when all that is true, rerun the current query.
       (let ((mu4e--search-background t))
         (mu4e-search-rerun)))))
 

From bbf348288131bb83efdf1e7991d26f13ff3d0730 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 29 Oct 2024 22:57:27 +0200
Subject: [PATCH 131/305] mu4e-search: try harder to update baseline

Try to update the query baseline if we're search for the favorite-query,
whether as a bookmark or an "organic" query, through a new function
mu4e--search-maybe-reset-baseline

Note that the query must string-match _exactly_, equivalence is not
enough.

Some cosmetic updates.

Fixes #2775.
---
 mu4e/mu4e-search.el | 41 ++++++++++++++++++++++-------------------
 1 file changed, 22 insertions(+), 19 deletions(-)

diff --git a/mu4e/mu4e-search.el b/mu4e/mu4e-search.el
index daec362b3..e17021ea8 100644
--- a/mu4e/mu4e-search.el
+++ b/mu4e/mu4e-search.el
@@ -1,6 +1,6 @@
 ;;; mu4e-search.el --- Search-related functions -*- lexical-binding: t -*-
 
-;; Copyright (C) 2021,2022 Dirk-Jan C. Binnema
+;; Copyright (C) 2021,2024 Dirk-Jan C. Binnema
 
 ;; Author: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ;; Maintainer: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
@@ -35,7 +35,7 @@
 (require 'mu4e-mark)
 (require 'mu4e-query-items)
 
-
+
 ;;; Configuration
 (defgroup mu4e-search nil
   "Search-related settings."
@@ -115,8 +115,9 @@ chronologically (`:date') by the newest message in the thread."
   :group 'mu4e-search)
 
 (defcustom mu4e-search-sort-direction 'descending
-  "Direction to sort by; a symbol either `descending' (sorting
-  Z->A) or `ascending' (sorting A->Z)."
+  "Direction to sort by.
+A symbol either `descending' (sorting Z->A) or
+`ascending' (sorting A->Z)."
   :type '(radio (const ascending)
                 (const descending))
   :group 'mu4e-search)
@@ -148,7 +149,7 @@ executed search, not just those that are invoked via bookmarks,
 but also manually invoked searches."
   :type 'hook
   :group 'mu4e-search)
-
+
 ;; Internals
 
 ;;; History
@@ -160,8 +161,6 @@ but also manually invoked searches."
 (defvar mu4e--search-last-query nil
   "The present (most recent) query.")
 
-
-
 ;;; Interactive functions
 (declare-function mu4e--search-execute "mu4e-headers")
 
@@ -170,6 +169,13 @@ but also manually invoked searches."
 (defvar mu4e--search-msgid-target nil
   "Message-id to jump to after the search has finished.")
 
+(defun mu4e--search-maybe-reset-baseline (query)
+  "Reset the baseline if QUERY matches the favorite.
+Note that the query must match the favorite _exactly_,
+equivalence is not enough."
+  (when-let* ((fav (mu4e--bookmark-query (mu4e-bookmark-favorite))))
+    (when (and fav (string= fav query))
+        (mu4e--query-items-refresh 'reset-baseline))))
 
 (defun mu4e-search (&optional expr prompt edit ignore-history msgid show)
   "Search for query EXPR.
@@ -183,7 +189,10 @@ the user edit the query before executing it.
 If IGNORE-HISTORY is true, do *not* update the query history
 stack. If MSGID is non-nil, attempt to move point to the first
 message with that message-id after searching. If SHOW is non-nil,
-show the message with MSGID."
+show the message with MSGID.
+
+Attempts to reset the query baseline if EXPR is an exact match
+with the favorite bookmark's query."
   (interactive)
   (let* ((prompt (mu4e-format (or prompt "Search for: ")))
          (expr
@@ -194,6 +203,7 @@ show the message with MSGID."
     (mu4e--search-execute expr ignore-history)
     (setq mu4e--search-msgid-target msgid
           mu4e--search-view-target show)
+    (mu4e--search-maybe-reset-baseline expr)
     (mu4e--modeline-update)))
 
 (defun mu4e-search-edit ()
@@ -210,12 +220,7 @@ the search."
          (or expr
              (mu4e-ask-bookmark
               (if edit "Select bookmark: " "Bookmark: "))))
-         (expr (if (functionp expr) (funcall expr) expr))
-         (fav (mu4e--bookmark-query (mu4e-bookmark-favorite))))
-    ;; reset baseline when searching for the favorite bookmark query
-    (when (and fav (string= fav expr))
-      (mu4e--query-items-refresh 'reset-baseline))
-
+         (expr (if (functionp expr) (funcall expr) expr)))
     (run-hook-with-args 'mu4e-search-bookmark-hook expr)
     (mu4e-search expr (when edit "Edit query: ") edit)))
 
@@ -224,7 +229,6 @@ the search."
   (interactive)
   (mu4e-search-bookmark nil t))
 
-
 (defun mu4e-search-maildir (maildir &optional edit)
   "Search the messages in MAILDIR.
 The user is prompted to ask what maildir. If prefix-argument EDIT
@@ -239,7 +243,7 @@ is given, offer to edit the search query before executing it."
       (mu4e-mark-handle-when-leaving)
       (mu4e-search query))))
 
-(defun mu4e-search-narrow(&optional filter)
+(defun mu4e-search-narrow (&optional filter)
   "Narrow the last search.
 Do so by appending search expression FILTER to the last search
 expression. Note that you can go back to the previous
@@ -328,7 +332,7 @@ either `future' or `past'."
 (defun mu4e-last-query ()
   "Get the most recent query or nil if there is none."
   mu4e--search-last-query)
-
+
 ;;; Completion for queries
 
 (defvar mu4e--search-hist nil "History list of searches.")
@@ -491,8 +495,7 @@ last search with the new setting."
 (defvar mu4e-search-skip-duplicates-label '("U" . "Ⓤ") ;; 'U' for 'unique'
   "Non-fancy and fancy labels for include-related search in the mode-line.")
 (defvar mu4e-search-hide-label            '("H" . "Ⓗ")
-  "Non-fancy and fancy labels to indicate header-hiding is active in
-the mode-line.")
+  "Non-fancy and fancy labels to indicate header-hiding.")
 
 (defun mu4e--search-modeline-item ()
   "Get mu4e-search modeline item."

From 33c09c57220be4c8bfd7cc77d6ebccebc4b3a528 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 3 Nov 2024 16:02:35 +0200
Subject: [PATCH 132/305] mu4e-server: demote 'Cannot handle command ...' to
 message

It was a warning, but seems some users got it a lot (which is a sign
they're spending too much time indexing!); so let's demote it to a mere
message.

Issue #2778.
---
 mu4e/mu4e-server.el | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mu4e/mu4e-server.el b/mu4e/mu4e-server.el
index d37988f8f..b62a4ab6e 100644
--- a/mu4e/mu4e-server.el
+++ b/mu4e/mu4e-server.el
@@ -548,7 +548,7 @@ You cannot run the repl when mu4e is running (or vice-versa)."
     (mu4e--server-start))
   ;; in single-threaded mode, mu can't accept our command right now.
   (when (and (mu4e--server-xapian-single-threaded-p) mu4e--server-indexing)
-    (mu4e-warn "Cannot handle command while indexing, please retry later."))
+    (mu4e-message "Cannot handle command while indexing, please retry later."))
   (let* ((print-length nil) (print-level nil)
          (cmd (format "%S" form)))
     (mu4e-log 'to-server "%s" cmd)

From 9d960d092f204decb78833ecea50fe19f47589ec Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 3 Nov 2024 16:03:59 +0200
Subject: [PATCH 133/305] NEWS.org: update

---
 NEWS.org | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/NEWS.org b/NEWS.org
index a782e64cc..669e429ec 100644
--- a/NEWS.org
+++ b/NEWS.org
@@ -1,6 +1,26 @@
 #+STARTUP:showall
 * NEWS (user visible changes & bigger non-visible ones)
 
+* 1.12 (post 1.12.0 updates)
+
+ The 1.12 series has been opened for a fairly long time, and gained some
+ changes, some beyond mere bug-fixing. We decided to put off a new development
+ series (1.13 -> 1.14) until incompatible changes are required; for now working
+ in the 1.12 series seems a good way to get improvements to users more quickly.
+
+  - man documentation improvements
+
+  - message composition has been reworked to avoid a number of problems user
+    reported
+
+  - many small mu4e bugs fixed, usually very old ones
+
+  - with 1.12.7, ~mu~ indexing is single-threaded again (by default), to avoid
+    cases of database-corruption that have appeared.
+
+  There's the ~-Dxapian-single-threaded=false~ flag to Meson to retain the old
+  behavior.
+
 * 1.12 (released on February 24, 2024)
 
 ** Some highlights

From fa59040ebc565a9c6a54da8a20f2e24eaac02bca Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 10 Nov 2024 11:07:15 +0200
Subject: [PATCH 134/305] message: treat pcks7::smt::Unknown as encrypted

GMime isn't more specific, so let's assume it's encrypted; better than
nothing.

Fixes #2784.
---
 lib/message/mu-message.cc | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/lib/message/mu-message.cc b/lib/message/mu-message.cc
index 111eef9fc..ee5929805 100644
--- a/lib/message/mu-message.cc
+++ b/lib/message/mu-message.cc
@@ -492,11 +492,15 @@ maybe_handle_pkcs7(const MimeObject& obj, Message::Private& info)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wswitch-enum"
 		// CompressedData, CertsOnly, Unknown
-		switch (smime.smime_type()) {
+		const auto smtype{smime.smime_type()};
+		switch (smtype) {
 		case Mu::MimeApplicationPkcs7Mime::SecureMimeType::SignedData:
 			info.flags |= Flags::Signed;
 			break;
 		case Mu::MimeApplicationPkcs7Mime::SecureMimeType::EnvelopedData:
+		case Mu::MimeApplicationPkcs7Mime::SecureMimeType::Unknown:
+			/* The "Unknown" case... GMIME doesn't give us anything
+			 * more specific, so assume it's encrypted for now  */
 			info.flags |= Flags::Encrypted;
 			break;
 		default:

From b0d8d42dd2c70abffca6122684dc6be0f7755935 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 10 Nov 2024 13:37:17 +0200
Subject: [PATCH 135/305] indexer: make lazy check even lazier

In lazy-mode, we were skipping directories that did not change; however,
this didn't help for the case were users received new messages in big
maildirs.

So, add another check where we compare the ctime of message files with
the time of the last indexing operation. If it's smaller, ignore the
message-file. This is faster than having to consult the Xapian database
for each message.

Note that this requires in mu4e:
      (setq mu4e-index-lazy-check t)
or
   --lazy-check
as a parameter for 'mu index'.
---
 lib/mu-indexer.cc  | 14 ++++++++++++--
 lib/mu-indexer.hh  |  4 ++--
 man/mu-index.1.org | 25 +++++++++++++++----------
 3 files changed, 29 insertions(+), 14 deletions(-)

diff --git a/lib/mu-indexer.cc b/lib/mu-indexer.cc
index 12ff06a45..a658ada3d 100644
--- a/lib/mu-indexer.cc
+++ b/lib/mu-indexer.cc
@@ -145,6 +145,8 @@ struct Indexer::Private {
 	std::mutex lock_, w_lock_;
 	std::atomic<time_t> completed_{};
 	bool was_empty_{};
+
+	uint64_t last_index_{};
 };
 
 bool
@@ -206,12 +208,16 @@ Indexer::Private::handler(const std::string& fullpath, struct stat* statbuf,
 
 	case Scanner::HandleType::File: {
 		++progress_.checked;
+		if (conf_.lazy_check && static_cast<uint64_t>(statbuf->st_ctime) < last_index_) {
+			// in lazy mode, ignore the file if it has not changed
+			// since the last indexing op.
+			return false;
+		}
 
-		if ((size_t)statbuf->st_size > max_message_size_) {
+		if (static_cast<size_t>(statbuf->st_size) > max_message_size_) {
 			mu_debug("skip {} (too big: {} bytes)", fullpath, statbuf->st_size);
 			return false;
 		}
-
 		// if the message is not in the db yet, or not up-to-date, queue
 		// it for updating/inserting.
 		if (statbuf->st_ctime <= dirstamp_ && store_.contains_message(fullpath))
@@ -414,6 +420,10 @@ Indexer::Private::start(const Indexer::Config& conf, bool block)
 	mu_debug("indexing: {}; clean-up: {}", conf_.scan ? "yes" : "no",
 		 conf_.cleanup ? "yes" : "no");
 
+	// remember the _previous_ indexing, so in lazy mode we can skip
+	// those files.
+	last_index_ = store_.config().get<Mu::Config::Id::LastIndex>();
+
 	state_.change_to(IndexState::Scanning);
 	/* kick off the first worker, which will spawn more if needed. */
 	workers_.emplace_back(std::thread([this] { item_worker(); }));
diff --git a/lib/mu-indexer.hh b/lib/mu-indexer.hh
index 3ea1fb632..7fa24169b 100644
--- a/lib/mu-indexer.hh
+++ b/lib/mu-indexer.hh
@@ -54,8 +54,8 @@ public:
 		bool ignore_noupdate{};
 		/**< ignore .noupdate files */
 		bool lazy_check{};
-		/**< whether to skip directories that don't have a changed
-		 * mtime */
+		/**< whether to skip directories or message files that haven't changed since the
+		 * previous indexing operation, based on their ctime */
 	};
 
 	/**
diff --git a/man/mu-index.1.org b/man/mu-index.1.org
index 5ddb35b77..af49eb023 100644
--- a/man/mu-index.1.org
+++ b/man/mu-index.1.org
@@ -41,7 +41,7 @@ If there is a file called _.noupdate_ in a directory, the contents of that
 directory and all of its subdirectories will be ignored. This can be useful to
 speed up things you have some maildirs that never change.
 
-_.noupdate_ does not affect already-indexed message: you can still search for
+_.noupdate_ does not affect already-indexed messages: you can still search for
 them. _.noupdate_ is ignored when you start indexing with an empty database (such
 as directly after *mu init*).
 
@@ -58,7 +58,7 @@ the database for which there is no longer a corresponding file in the Maildir.
 If you do not want this, you can use *-n*, *--nocleanup*.
 
 When *mu index* catches one of the signals *SIGINT*, *SIGHUP* or *SIGTERM* (e.g., when
-you press Ctrl-C during the indexing process), it attempts to shutdown
+you press *Ctrl-C* during the indexing process), it attempts to shutdown
 gracefully; it tries to save and commit data, and close the database etc. If it
 receives another signal (e.g., when pressing Ctrl-C once more), *mu index* will
 terminate immediately.
@@ -67,12 +67,17 @@ terminate immediately.
 
 ** --lazy-check
 In lazy-check mode, *mu* does not consider messages for which the time-stamp
-(ctime) of the directory they reside in has not changed since the previous
-indexing run. This is much faster than the non-lazy check, but won't update
-messages that have change (rather than having been added or removed), since
-merely editing a message does not update the directory time-stamp. Of course,
-you can run *mu-index* occasionally without *--lazy-check*, to pick up such
-messages.
+(*ctime*) of the directory in which they reside, has not changed since the
+previous time this directory was checked.
+
+This is much faster than the non-lazy check, but won't update messages that have
+changed (rather than having been added or removed), since merely editing a
+message does not update the directory time-stamp. Of course, you can run
+*mu-index* occasionally without *--lazy-check*, to pick up such messages.
+
+Furthermore, in lazy-check mode, files which have a *ctime* smaller than the time
+the previous indexing operation was completed, are ignored. This helps for the
+use-case where new messages can appear in big maildirs.
 
 ** --nocleanup
 Disable the database cleanup that *mu* does by default after indexing.
@@ -172,7 +177,7 @@ The instructions are a little different since we have a proper repeatable
 benchmark now. After building,
 
 #+begin_example
- $ sudo sh -c 'sync && echo 3 > /proc/sys/vm/drop_caches'
+$ sudo sh -c 'sync && echo 3 > /proc/sys/vm/drop_caches'
 % THREAD_NUM=4 build/lib/tests/bench-indexer -m perf
 # random seed: R02Sf5c50e4851ec51adaf301e0e054bd52b
 1..1
@@ -185,7 +190,7 @@ ok 1 /bench/indexer/4-cores
 #+end_example
 
 Things are again a little faster, even though the index does a lot more now
-(text-normalizatian, and pre-generating message-sexps). A faster machine helps,
+(text-normalization, and pre-generating message-sexps). A faster machine helps,
 too!
 
 ** recent releases

From 7e798f50c8b721d11c690c764b0428a8fe2a1c94 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 10 Nov 2024 14:15:52 +0200
Subject: [PATCH 136/305] mu4e-mark: handle case when mark line cannot fit

ht: @kpzart.

Fixes #2782.
---
 mu4e/mu4e-mark.el | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/mu4e/mu4e-mark.el b/mu4e/mu4e-mark.el
index 39103bad0..aa4271cf3 100644
--- a/mu4e/mu4e-mark.el
+++ b/mu4e/mu4e-mark.el
@@ -281,7 +281,8 @@ The following marks are available, and the corresponding props:
                    ;; the docid cookie and then we skip the mu4e--mark-fringe
                    (start (+ (length mu4e--mark-fringe)
                              (mu4e~headers-goto-docid docid t)))
-                   (overlay (make-overlay start (+ start (length targetstr)))))
+                   (overlay (make-overlay start (min (line-end-position)
+                                                     (+ start (length targetstr))))))
               (overlay-put overlay 'display targetstr)
               (overlay-put overlay 'mu4e-mark t)
               (overlay-put overlay 'evaporate t)

From f6f389a1eb2f0ce8bc7d4fa6ac5b08d9b9b1ecff Mon Sep 17 00:00:00 2001
From: dmct <dmct@q9x.io>
Date: Tue, 12 Nov 2024 23:32:40 -0600
Subject: [PATCH 137/305] mu4e-actions: ensure empty tag removal on message
 retagging.

---
 mu4e/mu4e-actions.el | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mu4e/mu4e-actions.el b/mu4e/mu4e-actions.el
index e7354e464..04757824d 100644
--- a/mu4e/mu4e-actions.el
+++ b/mu4e/mu4e-actions.el
@@ -215,7 +215,7 @@ would add \"tag\" and \"long tag\", and remove \"oldtag\"."
        (t
         (setq taglist (push tag taglist)))))
 
-    (setq taglist (sort (delete-dups taglist) 'string<))
+    (setq taglist (delete "" (sort (delete-dups taglist) 'string<)))
     (setq tagstr (mapconcat 'identity taglist sep))
 
     (setq tagstr (replace-regexp-in-string "[\\&]" "\\\\\\&" tagstr))

From f68d9a9b40f7dbd4a2a8587e3ae2aee39306d387 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Thu, 14 Nov 2024 20:26:07 +0200
Subject: [PATCH 138/305] mu4e.text: minor improvements for compose-related

---
 mu4e/mu4e.texi | 43 +++++++++++++++++++++++--------------------
 1 file changed, 23 insertions(+), 20 deletions(-)

diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index 11056a25a..4617542f1 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -1665,28 +1665,30 @@ the variable @t{mu4e-compose-switch}; see its docstring for details.
 
 @subsection New message
 
-You can start composing a completely new message with @t{mu4e-compose-new} (with
-@kbd{N} from within @t{mu4e}.
+You can start composing a completely new message with @code{mu4e-compose-new}
+(with @kbd{N} from within @t{mu4e}.
 
 @subsection Reply
 
-You can compose a reply to an existing message with @t{mu4e-compose-reply} (with
-@kbd{R} from within the headers view or when looking at some specific message.
+To compose a reply to an existing message, you can use @code{mu4e-compose-reply}
+(with @kbd{R}) from within the headers view or when looking at some specific
+message.
 
-When you want to reply to @emph{all} recipients of a message, you can use
-@t{mu4e-compose-wide-reply}, bound to @kbd{W}. This is often called
-``reply-to-all'', while Gnus uses the term ``wide reply''.
+If you want to reply to @emph{all} recipients of a message, there is
+@code{mu4e-compose-wide-reply}, by default bound to @kbd{W}. This is often
+called ``reply-to-all'', but @t{mu4e} follows the Gnus terminology ``wide
+reply''.
 
 By default, the reply will cite the message being replied to. If you do not want
 that, you can set (or @t{let}-bind) @t{message-cite-function} to
 @t{mu4e-message-cite-nothing}.
 
-See @ref{(message) Reply} and @ref{(message) Wide Reply} for further
-information.
+See @ref{(message) Reply} and @ref{(message) Wide Reply} for further details.
 
-Note: in older versions, @t{mu4e-compose-reply} would @emph{ask} whether you
-want to reply-to-all or not; if you are nostalgic for that old behavior, you
-could add something like the following to your configuration:
+Note: in older versions, @code{mu4e-compose-reply} would @emph{ask} whether you
+want to reply-to-all or not (there was no separate ``wide'' reply); if you are
+nostalgic for that old behavior, you could add something like the following to
+your configuration:
 @lisp
 (defun compose-reply-wide-or-not-please-ask ()
   "Ask whether to reply-to-all or not."
@@ -1699,21 +1701,22 @@ could add something like the following to your configuration:
 
 @subsection Forward
 
-You can forward some existing message with @t{mu4e-compose-forward} (with
-@kbd{F} from within the headers view or when looking at some specific message.
-
-For more information, see @ref{(message) Forwarding}.
+You can @emph{forward} some existing message with @code{mu4e-compose-forward}
+(bound to @kbd{F}) from within the headers view or when looking at some specific
+message. For further details, see @ref{(message) Forwarding}.
 
 To influence the way a message is forwarded, you can use the variables
 @code{message-forward-as-mime} and @code{message-forward-show-mml}.
 
 @subsection Supersede
 
-Occasionally, it can be useful to ``supersede'' a message you sent; this drops
-you into a new message that is just like the old message (and a @t{Supersedes:}
-message header). You can then edit this message and send it.
+Occasionally, it can be useful to ``supersede'' a message you sent; for this,
+there is @code{mu4e-compose-supersede}.
+
+This drops you into a new message that is just like the old message (and a
+@t{Supersedes:} message header). You can then edit this message and send it.
 
-This is only possible for messages @emph{you} sent, as determined by
+Superseding is only possible for messages @emph{you} sent, as determined by
 @code{mu4e-personal-or-alternative-address-p}.
 
 This wraps @code{message-supersede}.

From 5e340e3b5daf074790b3748125bb4260e5ed55c7 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Fri, 15 Nov 2024 18:50:35 +0200
Subject: [PATCH 139/305] mu4e-mime-parts: cosmetics

---
 mu4e/mu4e-mime-parts.el | 17 +++--------------
 1 file changed, 3 insertions(+), 14 deletions(-)

diff --git a/mu4e/mu4e-mime-parts.el b/mu4e/mu4e-mime-parts.el
index 1e681e1fa..875f5968a 100644
--- a/mu4e/mu4e-mime-parts.el
+++ b/mu4e/mu4e-mime-parts.el
@@ -1,6 +1,6 @@
 ;;; mu4e-mime-parts.el --- Dealing with MIME-parts & URLs -*- lexical-binding: t -*-
 
-;; Copyright (C) 2023 Dirk-Jan C. Binnema
+;; Copyright (C) 2023-2024 Dirk-Jan C. Binnema
 
 ;; Author: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ;; Maintainer: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
@@ -24,20 +24,15 @@
 
 ;; Implements functions and variables for dealing with MIME-parts and URLs.
 
-
 ;;; TODO:
 ;; [~] mime part candidate sorting -> is his even possible generally?
 ;; [ ] URL support
 
 ;;; Code:
-
-
 (require 'mu4e-vars)
 (require 'mu4e-folders)
 (require 'gnus-art)
 
-
-
 (defcustom mu4e-view-open-program
   (pcase system-type
     ('darwin "open")
@@ -54,7 +49,6 @@ specified a function as viewer."
   :type '(choice string function)
   :group 'mu4e-view)
 
-
 ;; remember the mime-handles, so we can clean them up when
 ;; we quit this buffer.
 (defvar-local mu4e~gnus-article-mime-handles nil)
@@ -66,11 +60,9 @@ specified a function as viewer."
     (mm-destroy-parts mu4e~gnus-article-mime-handles)
     (setq mu4e~gnus-article-mime-handles nil)))
 
-
 ;;; MIME-parts
 (defvar-local mu4e--view-mime-parts nil
   "Cached MIME parts for this message.")
-
 
 (defun mu4e-view-mime-parts()
   "Get the list of MIME parts for this message.
@@ -176,8 +168,8 @@ Otherwise, return a file with a unique number appended to the base-name."
   :keymap mu4e-view-completion-minor-mode-map)
 
 (defun mu4e--part-annotation (candidate part type longest-filename)
-  "Calculate the annotation candidates as per
-`:annotation-function' (see `completion-extra-properties')
+  "Calculate the annotation candidates as per annotation.
+I.e., `:annotation-function' (see `completion-extra-properties')
 
 CANDIDATE is the value to annotate.
 
@@ -227,7 +219,6 @@ information' is used for alignment."
         (format "%s" (concat "-> " target))))
       (_ (mu4e-error "Unsupported annotation type %s" type)))))
 
-
 (defvar helm-comp-read-use-marked)
 (defun mu4e--completing-read-real (prompt candidates multi)
   "Call the appropriate completion-read function.
@@ -381,7 +372,6 @@ Each of the actions is a plist with keys
                        ;;          or as a string parameter to a function
 ).")
 
-
 (defun mu4e--view-mime-part-to-temp-file (handle)
   "Write MIME-part HANDLE to a temporary file and return the file name.
 The filename is deduced from the MIME-part's filename, or
@@ -496,6 +486,5 @@ the third MIME-part."
     (display-buffer buf)))
 
 
-
 (provide 'mu4e-mime-parts)
 ;;; mu4e-mime-parts.el ends here

From d5d57b4327ab2c02ceca89794f88c6976c381c57 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 26 Nov 2024 19:17:14 +0200
Subject: [PATCH 140/305] remove non-single-threaded option

Single-threaded is the build-default, and seems to work well enough for
1.12.7, so remove the option to turn it off.

This is because build-options that influence such low-level/core
behavior are a pain to maintain.
---
 NEWS.org                   |  7 +---
 lib/mu-indexer.cc          | 83 +-------------------------------------
 lib/mu-indexer.hh          |  2 -
 lib/mu-server.cc           | 15 -------
 lib/tests/bench-indexer.cc |  1 -
 meson.build                |  7 ----
 meson_options.txt          |  6 ---
 mu4e/meson.build           |  5 +--
 mu4e/mu4e-main.el          |  4 +-
 9 files changed, 6 insertions(+), 124 deletions(-)

diff --git a/NEWS.org b/NEWS.org
index 669e429ec..f98bd89ea 100644
--- a/NEWS.org
+++ b/NEWS.org
@@ -15,11 +15,8 @@
 
   - many small mu4e bugs fixed, usually very old ones
 
-  - with 1.12.7, ~mu~ indexing is single-threaded again (by default), to avoid
-    cases of database-corruption that have appeared.
-
-  There's the ~-Dxapian-single-threaded=false~ flag to Meson to retain the old
-  behavior.
+  - with 1.12.7, ~mu~ indexing is single-threaded again, to avoid cases of
+    database-corruption that have appeared.
 
 * 1.12 (released on February 24, 2024)
 
diff --git a/lib/mu-indexer.cc b/lib/mu-indexer.cc
index a658ada3d..65fc0c6a2 100644
--- a/lib/mu-indexer.cc
+++ b/lib/mu-indexer.cc
@@ -106,7 +106,6 @@ struct Indexer::Private {
 
 	void maybe_start_worker();
 
-	void item_worker();
 	void scan_worker();
 
 	bool add_message(const std::string& path);
@@ -123,8 +122,6 @@ struct Indexer::Private {
 	const size_t    max_message_size_;
 
 	::time_t                 dirstamp_{};
-	std::size_t              max_workers_;
-	std::vector<std::thread> workers_;
 	std::thread              scanner_worker_;
 
 	struct WorkItem {
@@ -138,8 +135,6 @@ struct Indexer::Private {
 
 	void handle_item(WorkItem&& item);
 
-	AsyncQueue<WorkItem> todos_;
-
 	Progress   progress_{};
 	IndexState state_{};
 	std::mutex lock_, w_lock_;
@@ -198,11 +193,7 @@ Indexer::Private::handler(const std::string& fullpath, struct stat* statbuf,
 		return true;
 	}
 	case Scanner::HandleType::LeaveDir: {
-#ifdef XAPIAN_SINGLE_THREADED
 		handle_item({fullpath, WorkItem::Type::Dir});
-#else
-		todos_.push({fullpath, WorkItem::Type::Dir});
-#endif /*XAPIAN_SINGLE_THREADED*/
 		return true;
 	}
 
@@ -223,13 +214,7 @@ Indexer::Private::handler(const std::string& fullpath, struct stat* statbuf,
 		if (statbuf->st_ctime <= dirstamp_ && store_.contains_message(fullpath))
 			return false;
 
-#ifdef XAPIAN_SINGLE_THREADED
 		handle_item({fullpath, WorkItem::Type::File});
-#else
-		// push the remaining messages to our "todo" queue for
-		// (re)parsing and adding/updating to the database.
-		todos_.push({fullpath, WorkItem::Type::File});
-#endif
 		return true;
 	}
 	default:
@@ -238,17 +223,6 @@ Indexer::Private::handler(const std::string& fullpath, struct stat* statbuf,
 	}
 }
 
-void
-Indexer::Private::maybe_start_worker()
-{
-	std::lock_guard lock{w_lock_};
-
-	if (todos_.size() > workers_.size() && workers_.size() < max_workers_) {
-		workers_.emplace_back(std::thread([this] { item_worker(); }));
-		mu_debug("added worker {}", workers_.size());
-	}
-}
-
 bool
 Indexer::Private::add_message(const std::string& path)
 {
@@ -299,26 +273,6 @@ Indexer::Private::handle_item(WorkItem&& item)
 	}
 }
 
-
-
-void
-Indexer::Private::item_worker()
-{
-	WorkItem item;
-
-	mu_debug("started worker");
-
-	while (state_ == IndexState::Scanning) {
-		if (!todos_.pop(item, 250ms))
-			continue;
-
-		handle_item(std::move(item));
-
-		maybe_start_worker();
-		std::this_thread::yield();
-	}
-}
-
 bool
 Indexer::Private::cleanup()
 {
@@ -359,28 +313,11 @@ Indexer::Private::scan_worker()
 			state_.change_to(IndexState::Idle);
 			return;
 		}
-		mu_debug("scanner finished with {} file(s) in queue", todos_.size());
+		mu_debug("scanner finished");
 	}
 
-	// now there may still be messages in the work queue...
-	// finish those; this is a bit ugly; perhaps we should
-	// handle SIGTERM etc.
-
-	if (!todos_.empty()) {
-		const auto workers_size = std::invoke([this] {
-			std::lock_guard lock{w_lock_};
-			return workers_.size();
-		});
-		mu_debug("process {} remaining message(s) with {} worker(s)",
-			todos_.size(), workers_size);
-		while (!todos_.empty())
-			std::this_thread::sleep_for(100ms);
-	}
 	// and let the worker finish their work.
 	state_.change_to(IndexState::Finishing);
-	for (auto&& w : workers_)
-		if (w.joinable())
-			w.join();
 
 	if (conf_.cleanup) {
 		mu_debug("starting cleanup");
@@ -402,21 +339,13 @@ Indexer::Private::start(const Indexer::Config& conf, bool block)
 	stop();
 
 	conf_ = conf;
-	if (conf_.max_threads == 0) {
-		/* benchmarking suggests that ~4 threads is the fastest (the
-		 * real bottleneck is the database, so adding more threads just
-		 * slows things down)
-		 */
-		max_workers_ = std::min(4U, std::thread::hardware_concurrency());
-	} else
-		max_workers_ = conf.max_threads;
 
 	if (store_.empty() && conf_.lazy_check) {
 		mu_debug("turn off lazy check since we have an empty store");
 		conf_.lazy_check = false;
 	}
 
-	mu_debug("starting indexer with <= {} worker thread(s)", max_workers_);
+	mu_debug("starting indexer");
 	mu_debug("indexing: {}; clean-up: {}", conf_.scan ? "yes" : "no",
 		 conf_.cleanup ? "yes" : "no");
 
@@ -425,8 +354,6 @@ Indexer::Private::start(const Indexer::Config& conf, bool block)
 	last_index_ = store_.config().get<Mu::Config::Id::LastIndex>();
 
 	state_.change_to(IndexState::Scanning);
-	/* kick off the first worker, which will spawn more if needed. */
-	workers_.emplace_back(std::thread([this] { item_worker(); }));
 	/* kick the disk-scanner thread */
 	scanner_worker_ = std::thread([this] { scan_worker(); });
 
@@ -446,15 +373,10 @@ Indexer::Private::stop()
 {
 	scanner_.stop();
 
-	todos_.clear();
 	if (scanner_worker_.joinable())
 		scanner_worker_.join();
 
 	state_.change_to(IndexState::Idle);
-	for (auto&& w : workers_)
-		if (w.joinable())
-			w.join();
-	workers_.clear();
 
 	return true;
 }
@@ -562,7 +484,6 @@ test_index_basic()
 	}
 
 	conf.lazy_check	     = true;
-	conf.max_threads     = 1;
 	conf.ignore_noupdate = false;
 
 	{
diff --git a/lib/mu-indexer.hh b/lib/mu-indexer.hh
index 7fa24169b..255f6ec34 100644
--- a/lib/mu-indexer.hh
+++ b/lib/mu-indexer.hh
@@ -49,8 +49,6 @@ public:
 		/**< scan for new messages */
 		bool cleanup{true};
 		/**< clean messages no longer in the file system */
-		size_t max_threads{};
-		/**< maximum # of threads to use */
 		bool ignore_noupdate{};
 		/**< ignore .noupdate files */
 		bool lazy_check{};
diff --git a/lib/mu-server.cc b/lib/mu-server.cc
index 17c3acd83..6048b7072 100644
--- a/lib/mu-server.cc
+++ b/lib/mu-server.cc
@@ -785,23 +785,11 @@ Server::Private::index_handler(const Command& cmd)
 	// ignore .noupdate with an empty store.
 	conf.ignore_noupdate = store().empty();
 
-#ifdef XAPIAN_SINGLE_THREADED
 	// nothing to do
 	if (indexer().is_running()) {
 		throw Error{Error::Code::Xapian, "indexer is already running"};
 	}
 	do_index(conf);
-#else
-	indexer().stop();
-	if (index_thread_.joinable())
-		index_thread_.join();
-
-	// start a background track.
-	index_thread_ = std::thread([this, conf = std::move(conf)] {
-		do_index(conf);
-	});
-#endif /*XAPIAN_SINGLE_THREADED */
-
 }
 
 void
@@ -975,9 +963,6 @@ Server::Private::ping_handler(const Command& cmd)
 				       ":personal-addresses", std::move(addrs),
 				       ":database-path", store().path(),
 				       ":root-maildir", store().root_maildir(),
-#ifdef XAPIAN_SINGLE_THREADED
-				       ":xapian-single-threaded", Sexp::t_sym,
-#endif /*XAPIAN_SINGLE_THREADED*/
 				       ":doccount", storecount)));
 }
 
diff --git a/lib/tests/bench-indexer.cc b/lib/tests/bench-indexer.cc
index e76f9f867..e57bcbd6a 100644
--- a/lib/tests/bench-indexer.cc
+++ b/lib/tests/bench-indexer.cc
@@ -467,7 +467,6 @@ benchmark_indexer(gconstpointer testdata)
 		auto store{Store::make_new(BENCH_STORE, BENCH_MAILDIRS)};
 		g_assert_true(!!store);
 		Indexer::Config conf{};
-		conf.max_threads = tdata->num_threads;
 
 		auto res = store->indexer().start(conf);
 		g_assert_true(res);
diff --git a/meson.build b/meson.build
index 7ea5f737f..98b3f5304 100644
--- a/meson.build
+++ b/meson.build
@@ -133,13 +133,6 @@ add_project_arguments(['-DHAVE_CONFIG_H'], language: 'cpp')
 config_h_dep=declare_dependency(
   include_directories: include_directories(['.']))
 
-#
-# single-threaded Xapian access?
-#
-if get_option('xapian-single-threaded')
-  config_h_data.set('XAPIAN_SINGLE_THREADED', true)
-  message('use Xapian only in a single thread')
-endif
 #
 # d_type, d_ino are not available universally, so let's check
 # (we use them for optimizations in mu-scanner
diff --git a/meson_options.txt b/meson_options.txt
index d79a3778d..c0366bd88 100644
--- a/meson_options.txt
+++ b/meson_options.txt
@@ -48,7 +48,6 @@ option('guile-extension-dir',
        type: 'string',
        description: 'custom install path for the guile extension module')
 
-
 #
 # misc
 #
@@ -58,11 +57,6 @@ option('tests',
        value: 'auto',
        description: 'build unit tests')
 
-option('xapian-single-threaded',
-       type : 'boolean',
-       value: true,
-       description: 'only use Xapian from a single thread')
-
 option('readline',
        type: 'feature',
        value: 'auto',
diff --git a/mu4e/meson.build b/mu4e/meson.build
index 9fb00e669..664946af3 100644
--- a/mu4e/meson.build
+++ b/mu4e/meson.build
@@ -1,4 +1,4 @@
-## Copyright (C) 2022 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+## Copyright (C) 2022-2024 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ##
 ## This program is free software; you can redistribute it and/or modify
 ## it under the terms of the GNU General Public License as published by
@@ -17,9 +17,6 @@
 
 # generate some build data for use in mu4e
 version_extra=''
-if get_option('xapian-single-threaded')
-  version_extra='-st'
-endif
 
 mu4e_meta = configure_file(
   input: 'mu4e-config.el.in',
diff --git a/mu4e/mu4e-main.el b/mu4e/mu4e-main.el
index 3fab40231..160ff6d65 100644
--- a/mu4e/mu4e-main.el
+++ b/mu4e/mu4e-main.el
@@ -299,9 +299,7 @@ Otherwise, do nothing."
          "* "
          (propertize "mu4e" 'face 'mu4e-header-key-face)
          (propertize " - mu for emacs version " 'face 'mu4e-title-face)
-         (propertize  (concat mu4e-mu-version
-                              (if (mu4e--server-xapian-single-threaded-p) "-st" ""))
-                      'face 'mu4e-header-key-face)
+         (propertize  mu4e-mu-version 'face 'mu4e-header-key-face)
          "\n\n"
          (propertize "  Basics\n\n" 'face 'mu4e-title-face)
          (mu4e--main-action

From 831deb2364a2e7a7ecb998dd1b2c6728ccee95de Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 26 Nov 2024 21:17:36 +0200
Subject: [PATCH 141/305] lib/store-worker: remove

We're not using it.
---
 lib/meson.build        |   3 +-
 lib/mu-store-worker.cc |  68 -----------------
 lib/mu-store-worker.hh | 169 -----------------------------------------
 lib/mu-store.cc        |  11 ---
 lib/mu-store.hh        |   8 --
 5 files changed, 1 insertion(+), 258 deletions(-)
 delete mode 100644 lib/mu-store-worker.cc
 delete mode 100644 lib/mu-store-worker.hh

diff --git a/lib/meson.build b/lib/meson.build
index 91acaf287..c3a798dbb 100644
--- a/lib/meson.build
+++ b/lib/meson.build
@@ -41,8 +41,7 @@ lib_mu=static_library(
     'mu-server.cc',
     # misc
     'mu-maildir.cc',
-    'mu-script.cc',
-    'mu-store-worker.cc'
+    'mu-script.cc'
   ],
   dependencies: [
     glib_dep,
diff --git a/lib/mu-store-worker.cc b/lib/mu-store-worker.cc
deleted file mode 100644
index d4bcbbfc9..000000000
--- a/lib/mu-store-worker.cc
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
-** Copyright (C) 2024 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
-**
-** This program is free software; you can redistribute it and/or modify it
-** under the terms of the GNU General Public License as published by the
-** Free Software Foundation; either version 3, or (at your option) any
-** later version.
-**
-** This program is distributed in the hope that it will be useful,
-** but WITHOUT ANY WARRANTY; without even the implied warranty of
-** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-** GNU General Public License for more details.
-**
-** You should have received a copy of the GNU General Public License
-** along with this program; if not, write to the Free Software Foundation,
-** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-**
-*/
-
-#include "mu-store-worker.hh"
-#include "mu-store.hh"
-#include "utils/mu-utils.hh"
-
-#include <type_traits>
-
-using namespace Mu;
-
-// helper constant for the visitor
-template<class> inline constexpr bool always_false_v = false;
-
-void
-StoreWorker::run() {
-
-	running_ = true;
-
-	while (running_) {
-		WorkItem workitem;
-
-		if (!q_.pop(workitem))
-			continue;
-
-		std::visit([&](auto&& item) {
-			using T = std::decay_t<decltype(item)>;
-
-			if constexpr (std::is_same_v<T, SexpCommand>) {
-				if (!sexp_handler_)
-					mu_critical("no handler for sexp '{}'", item);
-				else
-					sexp_handler_(item);
-			} else if constexpr (std::is_same_v<T, SetDirStamp>) {
-				store_.set_dirstamp(item.path, item.tstamp);
-			} else if constexpr (std::is_same_v<T, SetLastIndex>) {
-				store_.config().set<Mu::Config::Id::LastIndex>(item.tstamp);
-			} else if constexpr (std::is_same_v<T, StartTransaction>) {
-				store_.xapian_db().request_transaction();
-			} else if constexpr (std::is_same_v<T, EndTransaction>) {
-				store_.xapian_db().request_commit(true);
-			} else if constexpr (std::is_same_v<T, RemoveMessages>) {
-				store_.remove_messages(item);
-			} else if constexpr (std::is_same_v<T, AddMessage>) {
-				store_.consume_message(std::move(item.msg), true/*new*/);
-			} else if constexpr (std::is_same_v<T, UpdateMessage>) {
-				store_.consume_message(std::move(item.msg), false/*maybe not new*/);
-			} else
-				static_assert(always_false_v<T>, "non-exhaustive visitor");
-		}, workitem);
-	}
-}
diff --git a/lib/mu-store-worker.hh b/lib/mu-store-worker.hh
deleted file mode 100644
index 45d0be533..000000000
--- a/lib/mu-store-worker.hh
+++ /dev/null
@@ -1,169 +0,0 @@
-/*
-** Copyright (C) 2024 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
-**
-** This program is free software; you can redistribute it and/or modify it
-** under the terms of the GNU General Public License as published by the
-** Free Software Foundation; either version 3, or (at your option) any
-** later version.
-**
-** This program is distributed in the hope that it will be useful,
-** but WITHOUT ANY WARRANTY; without even the implied warranty of
-** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-** GNU General Public License for more details.
-**
-** You should have received a copy of the GNU General Public License
-** along with this program; if not, write to the Free Software Foundation,
-** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-**
-*/
-
-
-/**
- * The store worker maintains a worker thread and an async queue to which
- * commands can be added from any thread; the worker thread that is the sole
- * thread to talk to the store / Xapian (at least for writing).
- */
-
-#ifndef MU_STORE_WORKER_HH
-#define MU_STORE_WORKER_HH
-
-#include <variant>
-#include <string>
-#include <thread>
-#include <atomic>
-#include <vector>
-#include <functional>
-
-#include <message/mu-message.hh>
-#include <utils/mu-async-queue.hh>
-
-namespace Mu {
-
-/**< Sum type for all commands  */
-
-class Store; /// fwd declaration
-
-/**
- * Worker for sending requests to the Store
- *
- * I.e. to execute database commands in a single thread.
- */
-class StoreWorker {
-public:
-	/**
-	 * CTOR. This will create the store worker and start the worker thread.
-	 *
-	 * @param store a store
-	 */
-	StoreWorker(Store& store):
-		store_{store},
-		runner_ {std::thread([this]{run();})}
-		{}
-
-	/**
-	 * DTOR. Destroy the store worker after joining the worker thread
-	 */
-	~StoreWorker() {
-		running_ = false;
-		if (runner_.joinable())
-			runner_.join();
-	}
-
-	/*
-	 * The following types of work-item can be added to the queue:
-	 */
-	struct SetDirStamp {
-		std::string path; /**< full path to directory */
-		::time_t tstamp; /**< Timestamp for directory */
-	}; /**<  Write a directory timestamp to the store */
-
-	struct SetLastIndex {
-		::time_t tstamp; /**< Timestamp */
-	}; /**<  Write last indexing timestamp to the store */
-
-	struct StartTransaction{}; /**< Request transaction start
-				    * (opportunistically) */
-	struct EndTransaction{}; /**< Request transaction end/commit
-				  * (opportunistically) */
-	struct AddMessage  {
-		Message msg; /**< Add a new message */
-	}; /**< Add a new message; this is faster version of UpdateMessage
-	    * if we know the message does not exist yet. */
-	struct UpdateMessage  {
-		Message msg; /**< Add or update a message */
-	}; /**< Add message or update if it already exists */
-
-	using RemoveMessages = std::vector<unsigned>;
-	/**< Remove all message with the given ids */
-	using SexpCommand = std::string; /**< A sexp-command (i.e., from mu4e);
-					  * requires install_sexp_handler() */
-
-	using WorkItem = std::variant<SetDirStamp, SetLastIndex,
-				      AddMessage, UpdateMessage,
-				      StartTransaction, EndTransaction,
-				      RemoveMessages, SexpCommand>;
-	/// Sumtype with all types of work-item
-
-	using QueueType = AsyncQueue<WorkItem>;
-	const QueueType& queue() const { return q_; }
-	QueueType& queue() { return q_; }
-
-	/**
-	 * Push a work item to the que
-	 *
-	 * @param item
-	 */
-	void push(WorkItem&& item) {
-		q_.push(std::move(item));
-	}
-
-	/**
-	 * Get the current size of the work item queue
-	 *
-	 * @return the size
-	 */
-	size_t size() const {
-		return q_.size();
-	}
-
-	/**
-	 * Is the work item queue empty?
-	 *
-	 * @return true or false
-	 */
-	bool empty() const {
-		return q_.empty();
-	}
-
-	/**
-	 * Clear the queue of any items
-	 */
-	void clear() {
-		q_.clear();
-	}
-
-	using SexpCommandHandler = std::function<void(const std::string& sexp)>;
-	/**< Prototype for a SexpCommand handler function */
-
-	/**
-	 * Install a handler for Sexp commands
-	 *
-	 * @param handler
-	 */
-	void install_sexp_handler(SexpCommandHandler&& handler) {
-		sexp_handler_ = handler;
-	}
-
-private:
-	void run();
-	size_t cleanup_orphans();
-
-	QueueType q_;
-	Store& store_;
-	std::thread runner_;
-	std::atomic<bool> running_{};
-	SexpCommandHandler sexp_handler_{};
-};
-
-} // namespace Mu
-#endif /*MU_STORE_WORKER_HH*/
diff --git a/lib/mu-store.cc b/lib/mu-store.cc
index 5aa367091..0db198acb 100644
--- a/lib/mu-store.cc
+++ b/lib/mu-store.cc
@@ -131,7 +131,6 @@ struct Store::Private {
 	XapianDb xapian_db_;
 	Config config_;
 	ContactsCache            contacts_cache_;
-	std::unique_ptr<StoreWorker> store_worker_;
 	std::unique_ptr<Indexer> indexer_;
 
 	const std::string	root_maildir_;
@@ -253,7 +252,6 @@ Store::Store(Store&& other)
 {
 	priv_ = std::move(other.priv_);
 	priv_->indexer_.reset();
-	priv_->store_worker_.reset();
 }
 
 Store::~Store() = default;
@@ -318,15 +316,6 @@ Store::indexer()
 	return *priv_->indexer_.get();
 }
 
-StoreWorker&
-Store::store_worker()
-{
-	if (!priv_->store_worker_)
-		priv_->store_worker_ = std::make_unique<StoreWorker>(*this);
-
-	return *priv_->store_worker_;
-}
-
 Result<Store::Id>
 Store::add_message(Message& msg, bool is_new)
 {
diff --git a/lib/mu-store.hh b/lib/mu-store.hh
index 643bb31cb..24130de03 100644
--- a/lib/mu-store.hh
+++ b/lib/mu-store.hh
@@ -31,7 +31,6 @@
 #include "mu-config.hh"
 #include "mu-indexer.hh"
 #include "mu-query-results.hh"
-#include "mu-store-worker.hh"
 
 #include <utils/mu-utils.hh>
 #include <utils/mu-utils.hh>
@@ -148,13 +147,6 @@ public:
 	 */
 	Indexer& indexer();
 
-	/**
-	 * Get the store-worker instance
-	 *
-	 * @return the store-worker
-	 */
-	StoreWorker& store_worker();
-
 	/**
 	 * Run a query; see the `mu-query` man page for the syntax.
 	 *

From c872efae34983feff2e2103746d8fcafbd02b034 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 26 Nov 2024 22:18:58 +0200
Subject: [PATCH 142/305] search: make references searchable

Allow searching for message that have the given message-id in
References: or Reply-To:
---
 lib/message/mu-fields.hh | 3 ++-
 mu/mu-cmd-info.cc        | 2 --
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/lib/message/mu-fields.hh b/lib/message/mu-fields.hh
index 19a222b93..63838aa1a 100644
--- a/lib/message/mu-fields.hh
+++ b/lib/message/mu-fields.hh
@@ -397,11 +397,12 @@ static constexpr std::array<Field, Field::id_size()>
 	    {
 		Field::Id::References,
 		Field::Type::StringList,
-		"references", {},
+		"references", "ref",
 		"References to related messages",
 		{},
 		'r',
 		Field::Flag::Value |
+				Field::Flag::BooleanTerm |
 		Field::Flag::IncludeInSexp
 	    },
 	    {
diff --git a/mu/mu-cmd-info.cc b/mu/mu-cmd-info.cc
index 7ff61f4ab..923a59e68 100644
--- a/mu/mu-cmd-info.cc
+++ b/mu/mu-cmd-info.cc
@@ -106,8 +106,6 @@ topic_fields(const Options& opts)
 			return "boolean";
 		if (field.is_phrasable_term())
 			return "phrase";
-		if (field.is_value())
-			return "yes";
 		if (field.is_contact())
 			return "contact";
 		if (field.is_range())

From d1b335f99e1228e4aa2a5564125de9951df434d2 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Thu, 28 Nov 2024 23:24:42 +0200
Subject: [PATCH 143/305] doc: update NEWS/mu4e manual

---
 NEWS.org       | 20 ++++++++++++--------
 mu4e/mu4e.texi | 16 ++++++++--------
 2 files changed, 20 insertions(+), 16 deletions(-)

diff --git a/NEWS.org b/NEWS.org
index f98bd89ea..4c5fc8d31 100644
--- a/NEWS.org
+++ b/NEWS.org
@@ -3,20 +3,24 @@
 
 * 1.12 (post 1.12.0 updates)
 
- The 1.12 series has been opened for a fairly long time, and gained some
- changes, some beyond mere bug-fixing. We decided to put off a new development
- series (1.13 -> 1.14) until incompatible changes are required; for now working
- in the 1.12 series seems a good way to get improvements to users more quickly.
+ The 1.12 series has been the stable one for a fairly long time, and gained some
+ changes in mean-time. Most of the changes are for big bugs, but some small new
+ features are available as well. We decided to put off a new development series
+ (1.13 -> 1.14) until incompatible changes are required; for now working in the
+ 1.12 series seems a good way to get improvements to users more quickly.
 
   - man documentation improvements
 
   - message composition has been reworked to avoid a number of problems user
-    reported
-
-  - many small mu4e bugs fixed, usually very old ones
+    reported. It is now directly uses the Gnus machinery, but integrate inside
+    mu4e.
 
   - with 1.12.7, ~mu~ indexing is single-threaded again, to avoid cases of
-    database-corruption that have appeared.
+    database-corruption. This of course means that in *mu4e* you need to _wait_
+    until indexing is ready before you can continue (*mu4e* will warn you). If you
+    see that warning often, perhaps your indexing is too slow, see the section
+    on "Speeding up indexing" in [[info:mu4e#Retrieval and indexing][Retrieval and indexing]] in the mu4e manual.
+
 
 * 1.12 (released on February 24, 2024)
 
diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index 4617542f1..d39eaddd0 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -545,16 +545,16 @@ because you are running your own mail-server, you can leave
 @t{mu4e} won't try to get new mail, but still re-index your messages.
 
 @subsection Speeding up indexing
+@anchor{Speeding up indexing}
 
-If you have a large number of e-mail messages in your store,
-(re)indexing might take a while. The defaults for indexing are to
-ensure that we always have correct, up-to-date information about your
-messages, even if other programs have modified the Maildir.
+If you have a large number of e-mail messages in your store, (re)indexing might
+take a while. The defaults for indexing are to ensure that we always have
+correct, up-to-date information about your messages, even if other programs have
+modified the Maildir.
 
-The downside of this thoroughness (which is the default) is that it is
-relatively slow, something that can be noticeable with large e-mail
-corpora on slow file-systems. For a faster approach, you can use the
-following:
+The downside of this thoroughness is that it is relatively slow, something that
+can be especially noticeable with large e-mail corpora on slow file-systems. For
+a faster approach, you can use the following:
 
 @lisp
 (setq

From af87ceaa28eee37df97f952259e78368f70c357a Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Thu, 28 Nov 2024 23:30:46 +0200
Subject: [PATCH 144/305] NEWS.org: add note on removal of -st suffix

---
 NEWS.org | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/NEWS.org b/NEWS.org
index 4c5fc8d31..940cd0732 100644
--- a/NEWS.org
+++ b/NEWS.org
@@ -16,11 +16,16 @@
     mu4e.
 
   - with 1.12.7, ~mu~ indexing is single-threaded again, to avoid cases of
-    database-corruption. This of course means that in *mu4e* you need to _wait_
-    until indexing is ready before you can continue (*mu4e* will warn you). If you
-    see that warning often, perhaps your indexing is too slow, see the section
-    on "Speeding up indexing" in [[info:mu4e#Retrieval and indexing][Retrieval and indexing]] in the mu4e manual.
+    database-corruption.
 
+    This, unfortunately, means that in *mu4e* you need to _wait_ until indexing is
+    ready before you can continue (*mu4e* will warn you). If you see that warning
+    often, perhaps your indexing is too slow, see the section on "Speeding up
+    indexing" in [[info:mu4e#Retrieval and indexing][Retrieval and indexing]] in the mu4e manual.
+
+    Note: for a while, the single-threadedness was signified by an "-st" suffix
+    in the mu4e version in its main-page; however, since this is optional no
+    longer, the suffix has been removed.
 
 * 1.12 (released on February 24, 2024)
 

From 0200cfd647e02334a03805a6432e81b98983d6b9 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 30 Nov 2024 11:15:20 +0200
Subject: [PATCH 145/305] NEWS.org: update

---
 NEWS.org | 27 ++++++++++++++++++---------
 1 file changed, 18 insertions(+), 9 deletions(-)

diff --git a/NEWS.org b/NEWS.org
index 940cd0732..b73a20d93 100644
--- a/NEWS.org
+++ b/NEWS.org
@@ -9,19 +9,28 @@
  (1.13 -> 1.14) until incompatible changes are required; for now working in the
  1.12 series seems a good way to get improvements to users more quickly.
 
-  - man documentation improvements
+  - many bug fixes
 
-  - message composition has been reworked to avoid a number of problems user
-    reported. It is now directly uses the Gnus machinery, but integrate inside
-    mu4e.
+  - many documentation improvements
+
+  - you can now search for messages that have a given message-id in their
+    ~References:~ or ~In-Reply-To:~ headers, e.g.
+    #+begin_example
+    mu find ref:0D9218A9-C7F5-4D50-B49C-FCE201114C9B@gmail.com
+    #+end_example
+    You do need to re-index the database for this to work though.
+
+  - message composition has been completely reworked to avoid a number of
+    problems user reported. It is now directly uses the Gnus machinery, but
+    integrate inside mu4e.
 
   - with 1.12.7, ~mu~ indexing is single-threaded again, to avoid cases of
-    database-corruption.
+    database-corruption. In *mu4e* that means you need to _wait_ until indexing is
+    ready before you can continue (*mu4e* will warn you).
 
-    This, unfortunately, means that in *mu4e* you need to _wait_ until indexing is
-    ready before you can continue (*mu4e* will warn you). If you see that warning
-    often, perhaps your indexing is too slow, see the section on "Speeding up
-    indexing" in [[info:mu4e#Retrieval and indexing][Retrieval and indexing]] in the mu4e manual.
+    If you see that warning often, perhaps your indexing is too slow; see the
+    section on "Speeding up indexing" in [[info:mu4e#Retrieval and indexing][Retrieval and indexing]] in the mu4e
+    manual.
 
     Note: for a while, the single-threadedness was signified by an "-st" suffix
     in the mu4e version in its main-page; however, since this is optional no

From 8c7db599727f42bf381fb4b636b462a82256dcf8 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 30 Nov 2024 22:58:15 +0200
Subject: [PATCH 146/305] fields: make combi-fields introspectable

And add the display of combination-fields to 'mu info fields'.
---
 lib/message/mu-fields.cc | 50 +++++++++++++++++++++++++++-
 lib/message/mu-fields.hh | 71 ++++++++++++++++------------------------
 mu/mu-cmd-info.cc        | 35 +++++++++++++++++++-
 3 files changed, 112 insertions(+), 44 deletions(-)

diff --git a/lib/message/mu-fields.cc b/lib/message/mu-fields.cc
index f64df5fa1..57399b59a 100644
--- a/lib/message/mu-fields.cc
+++ b/lib/message/mu-fields.cc
@@ -1,5 +1,5 @@
 /*
-** Copyright (C) 2022-2023 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2022-2024 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify it
 ** under the terms of the GNU General Public License as published by the
@@ -19,11 +19,59 @@
 
 #include "mu-fields.hh"
 #include "mu-flags.hh"
+#include "utils/mu-utils.hh"
 
 #include "utils/mu-test-utils.hh"
 
 using namespace Mu;
 
+const Mu::CombiFields&
+Mu::combi_fields()
+{
+	static CombiFields cfields = {
+		CombiField{ "recip",
+		  { field_from_id(Field::Id::To),
+		    field_from_id(Field::Id::Cc),
+		    field_from_id(Field::Id::Bcc)}},
+		CombiField { "contact",
+		  { field_from_id(Field::Id::To),
+		    field_from_id(Field::Id::Cc),
+		    field_from_id(Field::Id::Bcc),
+		    field_from_id(Field::Id::From)}},
+		CombiField { "",
+		  { field_from_id(Field::Id::To),
+		    field_from_id(Field::Id::Cc),
+		    field_from_id(Field::Id::Bcc),
+		    field_from_id(Field::Id::From),
+		    field_from_id(Field::Id::Subject),
+		    field_from_id(Field::Id::BodyText),
+		    field_from_id(Field::Id::EmbeddedText),
+		  }}
+	};
+
+	return cfields;
+}
+
+const Mu::FieldsVec&
+Mu::fields_from_name(const std::string& name) {
+
+	static const FieldsVec empty;
+	const auto& cfields{combi_fields()};
+	const auto it = seq_find_if(cfields, [&](auto cfield) {
+		return cfield.name == name;
+	});
+
+	return it == cfields.end() ? empty : it->fields;
+}
+
+bool
+Mu::field_is_combi(const std::string& name)
+{
+	return name != "" && seq_some(combi_fields(),[&](auto cfield) {
+		return cfield.name == name;
+	});
+}
+
 std::string
 Field::xapian_term(const std::string& s) const
 {
diff --git a/lib/message/mu-fields.hh b/lib/message/mu-fields.hh
index 63838aa1a..afa40362d 100644
--- a/lib/message/mu-fields.hh
+++ b/lib/message/mu-fields.hh
@@ -402,7 +402,7 @@ static constexpr std::array<Field, Field::id_size()>
 		{},
 		'r',
 		Field::Flag::Value |
-				Field::Flag::BooleanTerm |
+		Field::Flag::BooleanTerm |
 		Field::Flag::IncludeInSexp
 	    },
 	    {
@@ -534,6 +534,25 @@ Option<Field> field_from_name(const std::string& name) {
 	}
 }
 
+using FieldsVec = std::vector<Field>; /**< Vec of fields */
+
+/**
+ * Describe a combination-field, i.e., a pseudo-field that
+ * expands to some real fields, as a query shortcut.
+ */
+struct CombiField {
+	std::string_view name;	/**< name of the combi-field */
+	FieldsVec fields;	/**< fields this resolves to */
+};
+using CombiFields = std::vector<CombiField>; /**< vec of combi-fields */
+
+/**
+ * Get information about the combination fields
+ *
+ * @return vector with information.
+ */
+const CombiFields&  combi_fields();
+
 /**
  * Return combination-fields such
  * as "contact", "recip" and "" (empty)
@@ -542,48 +561,16 @@ Option<Field> field_from_name(const std::string& name) {
  *
  * @return list of matching fields
  */
-using FieldsVec = std::vector<Field>;
-static inline
-const FieldsVec& fields_from_name(const std::string& name) {
-
-	static const FieldsVec none{};
-	static const FieldsVec recip_fields ={
-		field_from_id(Field::Id::To),
-		field_from_id(Field::Id::Cc),
-		field_from_id(Field::Id::Bcc)};
-
-	static const FieldsVec contact_fields = {
-		field_from_id(Field::Id::To),
-		field_from_id(Field::Id::Cc),
-		field_from_id(Field::Id::Bcc),
-		field_from_id(Field::Id::From),
-	};
-	static const FieldsVec empty_fields= {
-		field_from_id(Field::Id::To),
-		field_from_id(Field::Id::Cc),
-		field_from_id(Field::Id::Bcc),
-		field_from_id(Field::Id::From),
-		field_from_id(Field::Id::Subject),
-		field_from_id(Field::Id::BodyText),
-		field_from_id(Field::Id::EmbeddedText),
-	};
-
-	if (name == "recip")
-		return recip_fields;
-	else if (name == "contact")
-		return contact_fields;
-	else if (name.empty())
-		return empty_fields;
-	else
-		return none;
-}
-
-static inline bool
-field_is_combi (const std::string& name)
-{
-	return name == "recip" || name == "contact";
-}
+const FieldsVec& fields_from_name(const std::string& name);
 
+/**
+ * Is the field a combination field?
+ *
+ * @param name name of the field
+ *
+ * @return true or false
+ */
+bool field_is_combi (const std::string& name);
 
 /**
  * Get the Field::Id for some number, or nullopt if it does not match
diff --git a/mu/mu-cmd-info.cc b/mu/mu-cmd-info.cc
index 923a59e68..257c90933 100644
--- a/mu/mu-cmd-info.cc
+++ b/mu/mu-cmd-info.cc
@@ -136,6 +136,37 @@ topic_fields(const Options& opts)
 	return Ok();
 }
 
+static Result<void>
+topic_combi_fields(const Options& opts)
+{
+	using namespace std::string_literals;
+
+	Table fields;
+	fields.add_row({"combi-field", "fields"});
+
+	seq_for_each(combi_fields(), [&](const auto& cfield) {
+
+		std::string fnames;
+		seq_for_each(cfield.fields, [&](auto&& field) {
+			if (!fnames.empty())
+				fnames += ", ";
+			fnames +=  mu_format("{}", field.name);
+		});
+
+		const std::string empty{"<empty>"};
+
+		fields.add_row({cfield.name.empty() ? empty : mu_format("{}", cfield.name),
+				fnames});
+	});
+
+	colorify(fields, opts);
+	std::cout << "# Combination fields\n" << fields << '\n';
+
+	return Ok();
+}
+
+
+
 static Result<void>
 topic_flags(const Options& opts)
 {
@@ -290,7 +321,9 @@ Mu::mu_cmd_info(const Mu::Store& store, const Options& opts)
 	else if (topic == "fields") {
 		topic_fields(opts);
 		std::cout << std::endl;
-		return topic_flags(opts);
+		topic_combi_fields(opts);
+		std::cout << std::endl;
+		topic_flags(opts);
 	} else if (topic == "mu") {
 		return topic_mu(opts);
 	} else {

From ed4d0f5e9da9a9c8d1627bc2706a759a800cd3e4 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 1 Dec 2024 23:27:32 +0200
Subject: [PATCH 147/305] tests: add tests for ref: searching

---
 lib/tests/test-mu-store-query.cc | 86 +++++++++++++++++++++++++++++++-
 1 file changed, 85 insertions(+), 1 deletion(-)

diff --git a/lib/tests/test-mu-store-query.cc b/lib/tests/test-mu-store-query.cc
index 5f282863b..92680b1dc 100644
--- a/lib/tests/test-mu-store-query.cc
+++ b/lib/tests/test-mu-store-query.cc
@@ -1,5 +1,5 @@
 /*
-** Copyright (C) 2022-2023 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2022-2024 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify it
 ** under the terms of the GNU General Public License as published by the
@@ -218,6 +218,88 @@ Boo!
 }
 
 
+
+
+
+static void
+test_related()
+{
+	const TestMap test_msgs = {{
+{
+"inbox/cur/msg1:2,S",
+R"(Message-Id: <aap@foo.bar>
+From: "Foo Example" <bar@example.com>
+Date: Sat, 06 Aug 2022 11:01:54 -0700
+To: example@example.com
+Subject: test1
+
+Parent
+)"},
+{
+"boo/cur/msg2:1,S",
+R"(Message-Id: <noot@foo.bar>
+In-Reply-To: <aap@foo.bar>
+From: "Foo Example" <bar@example.com>
+Date: Sat, 06 Aug 2022 13:01:54 -0700
+To: example@example.com
+Subject: Re: test1
+
+Child
+)"},
+{
+"inbox/cur/msg2:1,S",
+R"(Message-Id: <mies@foo.bar>
+In-Reply-To: <noot@foo.bar>
+References: <aap@foo.bar>
+From: "Foo Example" <bar@example.com>
+Date: Sat, 06 Aug 2022 14:01:54 -0700
+To: example@example.com
+Subject: Re: Re: test1
+
+Child
+)"},
+}};
+	TempDir tdir;
+	auto store{make_test_store(tdir.path(), test_msgs, {})};
+	{
+		// direct matches
+		auto qr = store.run_query("msgid:aap@foo.bar", Field::Id::Date,
+					  QueryFlags::None);
+		g_assert_true(!!qr);
+		g_assert_false(qr->empty());
+		g_assert_cmpuint(qr->size(), ==, 1);
+	}
+
+	{
+		// skip duplicate messages; which one is skipped is arbitrary.
+		auto qr = store.run_query("msgid:aap@foo.bar", Field::Id::Date,
+					  QueryFlags::IncludeRelated);
+		g_assert_true(!!qr);
+		g_assert_false(qr->empty());
+		g_assert_cmpuint(qr->size(), ==, 3);
+	}
+
+	{
+		// skip duplicate messages; which one is skipped is arbitrary.
+		auto qr = store.run_query("msgid:mies@foo.bar", Field::Id::Date,
+					  QueryFlags::IncludeRelated);
+		g_assert_true(!!qr);
+		g_assert_false(qr->empty());
+		g_assert_cmpuint(qr->size(), ==, 3);
+	}
+
+	{
+		// skip duplicate messages; which one is skipped is arbitrary.
+		auto qr = store.run_query("ref:aap@foo.bar", Field::Id::Date,
+					  QueryFlags::None);
+		g_assert_true(!!qr);
+		g_assert_false(qr->empty());
+		g_assert_cmpuint(qr->size(), ==, 2);
+	}
+
+}
+
+
 static void
 test_dups_related()
 {
@@ -888,6 +970,8 @@ main(int argc, char* argv[])
 			test_simple);
 	g_test_add_func("/store/query/spam-address-components",
 			test_spam_address_components);
+	g_test_add_func("/store/query/related",
+			test_related);
 	g_test_add_func("/store/query/dups-related",
 			test_dups_related);
 	g_test_add_func("/store/query/related-missing-root",

From 05be072676ad5c7571ed090f6d034cf0c8a72d5f Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 1 Dec 2024 23:45:28 +0200
Subject: [PATCH 148/305] man: improve mu-query manpage

---
 man/mu-query.7.org | 111 +++++++++++++++++++++++++++++----------------
 1 file changed, 72 insertions(+), 39 deletions(-)

diff --git a/man/mu-query.7.org b/man/mu-query.7.org
index cd164ae34..9736a4ffd 100644
--- a/man/mu-query.7.org
+++ b/man/mu-query.7.org
@@ -121,45 +121,71 @@ full table with all details, including single-char shortcuts, try the command:
 
 #+ATTR_MAN: :disable-caption t
 #+begin_example
-+-----------+----------+----------+-----------------------------+
-| flag      | shortcut | category | description                 |
-+-----------+----------+----------+-----------------------------+
-| draft     | D        | file     | Draft (in progress)         |
-+-----------+----------+----------+-----------------------------+
-| flagged   | F        | file     | User-flagged                |
-+-----------+----------+----------+-----------------------------+
-| passed    | P        | file     | Forwarded message           |
-+-----------+----------+----------+-----------------------------+
-| replied   | R        | file     | Replied-to                  |
-+-----------+----------+----------+-----------------------------+
-| seen      | S        | file     | Viewed at least once        |
-+-----------+----------+----------+-----------------------------+
-| trashed   | T        | file     | Marked for deletion         |
-+-----------+----------+----------+-----------------------------+
-| new       | N        | maildir  | New message                 |
-+-----------+----------+----------+-----------------------------+
-| signed    | z        | content  | Cryptographically signed    |
-+-----------+----------+----------+-----------------------------+
-| encrypted | x        | content  | Encrypted                   |
-+-----------+----------+----------+-----------------------------+
-| attach    | a        | content  | Has at least one attachment |
-+-----------+----------+----------+-----------------------------+
-| unread    | u        | pseudo   | New or not seen message     |
-+-----------+----------+----------+-----------------------------+
-| list      | l        | content  | Mailing list message        |
-+-----------+----------+----------+-----------------------------+
-| personal  | q        | content  | Personal message            |
-+-----------+----------+----------+-----------------------------+
-| calendar  | c        | content  | Calendar invitation         |
-+-----------+----------+----------+-----------------------------+
-#+end_example
-
-(*) The language code for the text-body if found. This works only if *mu* was
-built with CLD2 support.
++------------+-----------+-------+---------+-------+------+-------------------------------+----------------------------------+
+| field-name | alias     | short | search  | value | sexp | example query                 | description                      |
++------------+-----------+-------+---------+-------+------+-------------------------------+----------------------------------+
+| bcc        |           | h     | phrase  | yes   | yes  | bcc:foo@example.com           | Blind carbon-copy recipient      |
++------------+-----------+-------+---------+-------+------+-------------------------------+----------------------------------+
+| body       |           | b     | phrase  | no    | no   | body:capybara                 | Message plain-text body          |
++------------+-----------+-------+---------+-------+------+-------------------------------+----------------------------------+
+| cc         |           | c     | phrase  | yes   | yes  | cc:quinn@example.com          | Carbon-copy recipient            |
++------------+-----------+-------+---------+-------+------+-------------------------------+----------------------------------+
+| changed    |           | k     | range   | yes   | yes  | changed:30M..                 | Last change time                 |
++------------+-----------+-------+---------+-------+------+-------------------------------+----------------------------------+
+| date       |           | d     | range   | yes   | yes  | date:20220101..20220505       | Message date                     |
++------------+-----------+-------+---------+-------+------+-------------------------------+----------------------------------+
+| embed      |           | e     | phrase  | no    | no   | embed:war OR embed:peace      | Embedded text                    |
++------------+-----------+-------+---------+-------+------+-------------------------------+----------------------------------+
+| file       |           | j     | boolean | no    | no   | file:/image\.*.jpg/           | Attachment file name             |
++------------+-----------+-------+---------+-------+------+-------------------------------+----------------------------------+
+| flags      | flag      | g     | boolean | yes   | yes  | flag:unread AND flag:personal | Message properties               |
++------------+-----------+-------+---------+-------+------+-------------------------------+----------------------------------+
+| from       |           | f     | phrase  | yes   | yes  | from:jimbo                    | Message sender                   |
++------------+-----------+-------+---------+-------+------+-------------------------------+----------------------------------+
+| language   | lang      | a     | boolean | yes   | yes  | lang:nl                       | ISO 639-1 language code for body |
++------------+-----------+-------+---------+-------+------+-------------------------------+----------------------------------+
+| maildir    |           | m     | boolean | yes   | yes  | maildir:/private/archive      | Maildir path for message         |
++------------+-----------+-------+---------+-------+------+-------------------------------+----------------------------------+
+| list       |           | v     | boolean | yes   | yes  | list:mu-discuss.example.com   | Mailing list (List-Id:)          |
++------------+-----------+-------+---------+-------+------+-------------------------------+----------------------------------+
+| message-id | msgid     | i     | boolean | yes   | yes  | msgid:abc@123                 | Message-Id                       |
++------------+-----------+-------+---------+-------+------+-------------------------------+----------------------------------+
+| mime       | mime-type | y     | boolean | no    | no   | mime:image/jpeg               | Attachment MIME-type             |
++------------+-----------+-------+---------+-------+------+-------------------------------+----------------------------------+
+| path       |           | l     | boolean | yes   | yes  | path:/a/b/Maildir/cur/msg:2,S | File system path to message      |
++------------+-----------+-------+---------+-------+------+-------------------------------+----------------------------------+
+| priority   | prio      | p     | boolean | yes   | yes  | prio:high                     | Priority                         |
++------------+-----------+-------+---------+-------+------+-------------------------------+----------------------------------+
+| references | ref       | r     | boolean | yes   | yes  |                               | References to related messages   |
++------------+-----------+-------+---------+-------+------+-------------------------------+----------------------------------+
+| size       |           | z     | range   | yes   | yes  | size:1M..5M                   | Message size in bytes            |
++------------+-----------+-------+---------+-------+------+-------------------------------+----------------------------------+
+| subject    |           | s     | phrase  | yes   | yes  | subject:wombat                | Message subject                  |
++------------+-----------+-------+---------+-------+------+-------------------------------+----------------------------------+
+| tags       | tag       | x     | boolean | yes   | yes  | tag:projectx                  | Message tags                     |
++------------+-----------+-------+---------+-------+------+-------------------------------+----------------------------------+
+| thread     |           | w     | boolean | yes   | no   |                               | Thread a message belongs to      |
++------------+-----------+-------+---------+-------+------+-------------------------------+----------------------------------+
+| to         |           | t     | phrase  | yes   | yes  | to:flimflam@example.com       | Message recipient                |
++------------+-----------+-------+---------+-------+------+-------------------------------+----------------------------------+
+#+end_example
+
+There are also *combination fields* which allow you to search for multiple related
+fields at once:
 
-There are also the special fields *contact:*, which matches all contact-fields
-(=from=, =to=, =cc= and =bcc=), and *recip*, which matches all recipient-fields (=to=, =cc=
-and =bcc=).
+#+ATTR_MAN: :disable-caption t
+#+begin_example
+# Combination fields
++-------------+-----------------------------------------+
+| combi-field | fields                                  |
++-------------+-----------------------------------------+
+| recip       | to, cc, bcc                             |
++-------------+-----------------------------------------+
+| contact     | to, cc, bcc, from                       |
++-------------+-----------------------------------------+
+| <empty>     | to, cc, bcc, from, subject, body, embed |
++-------------+-----------------------------------------+
+#+end_example
 
 Hence, for instance,
 #+begin_example
@@ -294,7 +320,7 @@ maildir:/
 #+end_example
 
 If you have maildirs (or any fields) that include spaces, you need to quote
-them, ie.
+them, i.e.,
 #+begin_example
 maildir:"/Sent Items"
 #+end_example
@@ -349,6 +375,13 @@ Find all messages with attached images:
 #+begin_example
 mime:image/*
 #+end_example
+(and beware that on the command-line, you need to put this in quotes or it would
+expand the ~*~.
+
+Find a messages with the given message-id:
+#+begin_example
+msgid:CAE56pjGU2oNxN-wWku69@mail.gmail.com
+#+end_example
 
 Find all messages written in Dutch or German with the word `hallo':
 #+begin_example

From 8fefc52eeedc642a2811131b7789c1d3bc99b1e2 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Mon, 2 Dec 2024 21:41:59 +0200
Subject: [PATCH 149/305] query: add related: combi-field + test

Add a new combination (pseudo) field "related:", which combines
"message-id" and "references"
---
 lib/message/mu-fields.cc         |  4 ++++
 lib/tests/test-mu-store-query.cc | 16 ++++++-------
 man/mu-query.7.org               |  2 ++
 mu4e/mu4e-search.el              | 39 ++++++++++++++++++++++++++++----
 4 files changed, 47 insertions(+), 14 deletions(-)

diff --git a/lib/message/mu-fields.cc b/lib/message/mu-fields.cc
index 57399b59a..040e68c88 100644
--- a/lib/message/mu-fields.cc
+++ b/lib/message/mu-fields.cc
@@ -38,6 +38,10 @@ Mu::combi_fields()
 		    field_from_id(Field::Id::Cc),
 		    field_from_id(Field::Id::Bcc),
 		    field_from_id(Field::Id::From)}},
+		CombiField { "related",
+		  { field_from_id(Field::Id::MessageId),
+		    field_from_id(Field::Id::References)}
+		},
 		CombiField { "",
 		  { field_from_id(Field::Id::To),
 		    field_from_id(Field::Id::Cc),
diff --git a/lib/tests/test-mu-store-query.cc b/lib/tests/test-mu-store-query.cc
index 92680b1dc..ca4273b47 100644
--- a/lib/tests/test-mu-store-query.cc
+++ b/lib/tests/test-mu-store-query.cc
@@ -217,10 +217,6 @@ Boo!
 	}
 }
 
-
-
-
-
 static void
 test_related()
 {
@@ -262,7 +258,6 @@ Child
 	TempDir tdir;
 	auto store{make_test_store(tdir.path(), test_msgs, {})};
 	{
-		// direct matches
 		auto qr = store.run_query("msgid:aap@foo.bar", Field::Id::Date,
 					  QueryFlags::None);
 		g_assert_true(!!qr);
@@ -271,7 +266,6 @@ Child
 	}
 
 	{
-		// skip duplicate messages; which one is skipped is arbitrary.
 		auto qr = store.run_query("msgid:aap@foo.bar", Field::Id::Date,
 					  QueryFlags::IncludeRelated);
 		g_assert_true(!!qr);
@@ -280,7 +274,6 @@ Child
 	}
 
 	{
-		// skip duplicate messages; which one is skipped is arbitrary.
 		auto qr = store.run_query("msgid:mies@foo.bar", Field::Id::Date,
 					  QueryFlags::IncludeRelated);
 		g_assert_true(!!qr);
@@ -289,7 +282,6 @@ Child
 	}
 
 	{
-		// skip duplicate messages; which one is skipped is arbitrary.
 		auto qr = store.run_query("ref:aap@foo.bar", Field::Id::Date,
 					  QueryFlags::None);
 		g_assert_true(!!qr);
@@ -297,9 +289,15 @@ Child
 		g_assert_cmpuint(qr->size(), ==, 2);
 	}
 
+	{
+		auto qr = store.run_query("related:aap@foo.bar", Field::Id::Date,
+					  QueryFlags::None);
+		g_assert_true(!!qr);
+		g_assert_false(qr->empty());
+		g_assert_cmpuint(qr->size(), ==, 3);
+	}
 }
 
-
 static void
 test_dups_related()
 {
diff --git a/man/mu-query.7.org b/man/mu-query.7.org
index 9736a4ffd..0cb1cd3c5 100644
--- a/man/mu-query.7.org
+++ b/man/mu-query.7.org
@@ -183,6 +183,8 @@ fields at once:
 +-------------+-----------------------------------------+
 | contact     | to, cc, bcc, from                       |
 +-------------+-----------------------------------------+
+| related     | message-id, references                  |
++-------------+-----------------------------------------+
 | <empty>     | to, cc, bcc, from, subject, body, embed |
 +-------------+-----------------------------------------+
 #+end_example
diff --git a/mu4e/mu4e-search.el b/mu4e/mu4e-search.el
index e17021ea8..2fdb8ee47 100644
--- a/mu4e/mu4e-search.el
+++ b/mu4e/mu4e-search.el
@@ -352,10 +352,38 @@ either `future' or `past'."
     (read-string prompt initial-input 'mu4e--search-hist)))
 
 (defconst mu4e--search-query-keywords
-  '("and" "or" "not"
-    "from:" "to:" "cc:" "bcc:" "contact:" "recip:" "date:" "subject:" "body:"
-    "list:" "maildir:" "flag:" "mime:" "file:" "prio:" "tag:" "msgid:"
-    "size:" "embed:"))
+  '(;; logical
+    "and"
+    "or"
+    "not"
+    ;; fields
+    "bcc:"
+    "body:"
+    "cc:"
+    "changed:"
+    "date:"
+    "embed:"
+    "file:"
+    "flag:"
+    "from:"
+    "lang:"
+    "maildir:"
+    "list:"
+    "msgid"
+    "mime:"
+    "path:"
+    "prio:"
+    "ref"
+    "size:"
+    "subject:"
+    "tags:"
+    "thread:"
+    "to:"
+    ;; combin fields
+    "recip:"
+    "contact:"
+    "related:")
+  "Mu4e query-keywords for completion.")
 
 (defun mu4e--search-completion-contacts-action (match _status)
   "Delete contact alias from contact autocompletion, leaving just email address.
@@ -378,7 +406,8 @@ status, STATUS."
     (list (match-beginning 1)
           (match-end 1)
           '("attach" "draft" "flagged" "list" "new" "passed" "replied"
-            "seen" "trashed" "unread" "encrypted" "signed" "personal")))
+            "seen" "trashed" "unread" "encrypted" "signed" "personal"
+            "calendar")))
    ((looking-back "maildir:\\([a-zA-Z0-9/.]*\\)" nil)
     (list (match-beginning 1)
           (match-end 1)

From df30f7ed31163b5a00063d5cdfef0a1b482bca7e Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 3 Dec 2024 18:59:30 +0200
Subject: [PATCH 150/305] mu4e-mime-parts: warn when saving files matching
 crm-separator

When files contain crm-separator (by default, some comma with option
whitespace), we cannot use mu4e-view-save-attachments since the emacs'
completion mechanism gets confused.

Luckily, we can still use mu4e-view-mime-part-action instead (which uses
numbers for files).
---
 mu4e/mu4e-mime-parts.el | 23 +++++++++++++----------
 1 file changed, 13 insertions(+), 10 deletions(-)

diff --git a/mu4e/mu4e-mime-parts.el b/mu4e/mu4e-mime-parts.el
index 875f5968a..9ec18d8be 100644
--- a/mu4e/mu4e-mime-parts.el
+++ b/mu4e/mu4e-mime-parts.el
@@ -32,6 +32,7 @@
 (require 'mu4e-vars)
 (require 'mu4e-folders)
 (require 'gnus-art)
+(require 'crm)
 
 (defcustom mu4e-view-open-program
   (pcase system-type
@@ -284,20 +285,22 @@ This command assumes unique filenames for the attachments, since
 that is how the underlying completion mechanism works. If there
 are duplicates, only one is recognized.
 
-Furthermore, file-names that match `crm-separator' (by default,
-commas) are not supported (see `completing-read-multiple' for
-further details).
-
-For such corner-cases, it is recommended to use
-`mu4e-view-mime-part-action' instead, which does not have this
-limitation."
+Furthermore, file-names that match `crm-separator' (by default, a
+comma and some optional whitespace) are not supported (see
+`completing-read-multiple' for further details). Hence, when we
+detect that, the function bails out and advises to use
+`mu4e-view-mime-part-action' instead, which does support such
+files."
   (interactive "P")
   (let* ((parts (mu4e-view-mime-parts))
          (candidates  (seq-map
                        (lambda (fpart)
-                         (cons ;; (filename . annotation)
-                          (plist-get fpart :filename)
-                          fpart))
+                         (let ((fname (plist-get fpart :filename)))
+                           (when (and crm-separator (string-match-p crm-separator fname))
+                             (mu4e-warn (concat  "File(s) match `crm-separator'; "
+                                                 "use mu4e-view-mime-part-action instead")))
+                           ;; (filename . annotation)
+                           (cons fname fpart)))
                        (seq-filter
                         (lambda (part) (plist-get part :attachment-like))
                         parts)))

From 2341e3d8cb3ba56bf0c02788995fb8e0a0ae76d2 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 3 Dec 2024 19:04:35 +0200
Subject: [PATCH 151/305] NEWS.org: update

---
 NEWS.org | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/NEWS.org b/NEWS.org
index b73a20d93..7657716af 100644
--- a/NEWS.org
+++ b/NEWS.org
@@ -20,6 +20,9 @@
     #+end_example
     You do need to re-index the database for this to work though.
 
+    There's also a new combination-field ~related:~ which combines ~references:~ and
+    ~msgid:~.
+
   - message composition has been completely reworked to avoid a number of
     problems user reported. It is now directly uses the Gnus machinery, but
     integrate inside mu4e.

From a34a26a5a82b94b1a07b99129495ca36d7b010af Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 3 Dec 2024 22:38:13 +0200
Subject: [PATCH 152/305] IDEAS.org: include #2787.

Fixes #2787
---
 IDEAS.org | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/IDEAS.org b/IDEAS.org
index 2a29f2015..b34936410 100644
--- a/IDEAS.org
+++ b/IDEAS.org
@@ -54,11 +54,13 @@ future.
   complicating the search (i.e., the message hash?). Maybe leave as is?
   https://github.com/djcb/mu/issues/2527
 
-
 - Perhaps better support file names with commas.. perhaps temporarily add some
   invisible unicode to fool crm-separator?
   https://github.com/djcb/mu/issues/2768
 
+- Org-link type for any message matching some reference
+  See: https://github.com/djcb/mu/issues/2787
+
 * Done
 
 - Support mu4e-mark-handle-when also for when leaving emacs

From ffb3563f115493cf31acf06a607017412980ecd6 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Wed, 4 Dec 2024 22:29:12 +0200
Subject: [PATCH 153/305] mu4e: add mu4e-uniquify-save-file-name-function

Make the function to create a new file for saving customizable.
---
 mu4e/mu4e-mime-parts.el | 18 +++++++++++++++---
 1 file changed, 15 insertions(+), 3 deletions(-)

diff --git a/mu4e/mu4e-mime-parts.el b/mu4e/mu4e-mime-parts.el
index 9ec18d8be..dae3353ae 100644
--- a/mu4e/mu4e-mime-parts.el
+++ b/mu4e/mu4e-mime-parts.el
@@ -50,6 +50,17 @@ specified a function as viewer."
   :type '(choice string function)
   :group 'mu4e-view)
 
+(defcustom mu4e-uniquify-save-file-name-function 'mu4e--uniquify-file-name
+  "Function to create a unique, not-yet-existing file name.
+
+Takes one parameter, a file-name path, and returns a file-name
+path that does not yet exist. This can be the same, or some
+variation.
+
+See `mu4e--uniquify-file-name' for an example."
+  :type 'function
+  :group 'mu4e-view)
+
 ;; remember the mime-handles, so we can clean them up when
 ;; we quit this buffer.
 (defvar-local mu4e~gnus-article-mime-handles nil)
@@ -128,8 +139,9 @@ There are some internal fields as well, e.g. ; subject to change:
 
 ;; https://emacs.stackexchange.com/questions/74547/completing-read-search-also-in-annotationsxc
 
-(defun mu4e--uniqify-file-name (fname)
-  "Return a non-yet-existing filename based on FNAME.
+(defun mu4e--uniquify-file-name (fname)
+  "Return a not-yet-existing filename based on FNAME.
+
 If FNAME does not yet exist, return it unchanged.
 Otherwise, return a file with a unique number appended to the base-name."
   (let ((num 1) (orig-name fname))
@@ -313,7 +325,7 @@ files."
     ;; we have determined what files to save, and where.
     (seq-do (lambda (fname)
               (let* ((part (cdr (assoc fname candidates)))
-                     (path (mu4e--uniqify-file-name
+                     (path (funcall mu4e-uniquify-save-file-name-function
                             (mu4e-join-paths
                              (or custom-dir (plist-get part :target-dir))
                              (plist-get part :filename))))

From 1b2d9d3847ca879e92455d06b433a212506a16f8 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Wed, 4 Dec 2024 23:18:15 +0200
Subject: [PATCH 154/305] mu-find: insist on --linksdir for links

Fixes #2790.
---
 man/mu-find.1.org | 9 +++++----
 mu/mu-cmd-find.cc | 4 ++++
 2 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/man/mu-find.1.org b/man/mu-find.1.org
index 83e15e462..da3e4d710 100644
--- a/man/mu-find.1.org
+++ b/man/mu-find.1.org
@@ -127,15 +127,16 @@ Output results in the specified format.
 - The default is *plain*, i.e normal output with one line per message.
 - *links* outputs the results as a maildir with symbolic links to the found
   messages. This enables easy integration with mail-clients (see below for more
-  information).
+  information). This requires *--linksdir*.
 - *xml* formats the search results as XML.
 - *sexp* formats the search results as an s-expression as used in Lisp programming
   environments.
 
 ** --linksdir _dir_ and -c, --clearlinks
-When using *--format=links*, output the results as a maildir with symbolic links to
-the found messages. This enables easy integration with mail-clients (see below
-for more information). *mu* will create the maildir if it does not exist yet.
+When using *--format=links*, output the results as a maildir with symbolic links
+to the found messages. This enables easy integration with mail-clients (see
+below for more information). *mu* will create the maildir if it does not exist
+yet.
 
 If you specify *--clearlinks*, existing symlinks will be cleared from the target
 directories; this allows for re-use of the same maildir. However, this option
diff --git a/mu/mu-cmd-find.cc b/mu/mu-cmd-find.cc
index 3853856d7..cd48e8fc0 100644
--- a/mu/mu-cmd-find.cc
+++ b/mu/mu-cmd-find.cc
@@ -164,6 +164,10 @@ get_query(const Store& store, const Options& opts)
 static Result<void>
 prepare_links(const Options& opts)
 {
+	// XXX: can this be done as part of the option-parsing?
+	if (opts.find.linksdir.empty())
+		return Err(Error::Code::InvalidArgument, "--linksdir is required");
+
 	/* note, mu_maildir_mkdir simply ignores whatever part of the
 	 * mail dir already exists */
 	if (auto&& res = maildir_mkdir(opts.find.linksdir, 0700, true); !res)

From 454cfe3ea68d115f2e182d50a44388d281ecefac Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Fri, 6 Dec 2024 19:47:55 +0200
Subject: [PATCH 155/305] mu4e: add mu4e-view-mime-parts

Add a special mode for setting the gnus parameters to have images shown
/ buttonized so they can be saved etc.

Fixes #2516.
---
 mu4e/mu4e-view.el | 17 ++++++++++++-----
 mu4e/mu4e.texi    |  4 ++++
 2 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/mu4e/mu4e-view.el b/mu4e/mu4e-view.el
index 075c55878..4f719d3ad 100644
--- a/mu4e/mu4e-view.el
+++ b/mu4e/mu4e-view.el
@@ -754,12 +754,19 @@ determine which browser function to use."
     (mu4e-view-quit)
     (mu4e-view msg)))
 
-(defun mu4e-view-toggle-show-mime-parts()
-  "Toggle whether to show all MIME-parts."
+(defun mu4e-view-show-mime-parts()
+  "Show all MIME-parts.
+
+This can be useful for messages with embedded images etc. that
+you want to save, and that are not accessible otherwise. However,
+note that Emacs can get slow with big attached images.
+
+To go back to normal display, quit the message and re-open."
   (interactive)
-  (setq gnus-inhibit-mime-unbuttonizing
-        (not gnus-inhibit-mime-unbuttonizing))
-  (mu4e-view-refresh))
+  (let* ((toggle (not gnus-mime-display-multipart-as-mixed))
+         (gnus-inhibit-mime-unbuttonizing (not toggle))
+         (gnus-mime-display-multipart-as-mixed toggle))
+    (mu4e-view-refresh)))
 
 (defun mu4e-view-toggle-fill-flowed()
   "Toggle flowed-message text filling."
diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index d39eaddd0..2466a326b 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -1506,6 +1506,10 @@ if you have Gnus-specific settings for @t{gnus-blocked-images}, you
 should verify that they have the desired effect in @code{mu4e} as
 well.
 
+Finally, for some message with big images it can be useful to enable buttons and
+full display, e.g. for saving inline images. For this you can try @code{M-x
+mu4e-view-show-mime-parts}. This can be a little slow.
+
 @node MSGV Attachments and MIME-parts
 @section Attachments and MIME-parts
 @cindex attachments

From e14b5a3a48b81652cea8fe154fb1af766922b5f2 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Fri, 6 Dec 2024 19:49:38 +0200
Subject: [PATCH 156/305] mu4e: tweak manual for mode-line counts

Fixes #2791.
---
 mu4e/mu4e.texi | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index 2466a326b..9d92e83be 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -793,7 +793,10 @@ Note that the ``delta'' has its limitations: if you, for instance, deleted 5
 messages and received 5 new one, the ``delta'' would be 0, although there were
 changes indeed. So it is mostly useful for tracking changes while you are
 @emph{not} using @t{mu4e}. For this reason, you can reset the baseline manually,
-e.g. by visiting the main view .
+e.g. by visiting the main view.
+
+Furthermore, for speed reasons, the counts do @emph{not} exclude messages that
+no longer exist in the file-system, nor do they exclude duplicate messages.
 
 By comparing current results with the baseline, you can quickly see what new
 messages have arrived since the last time you looked.
@@ -4101,7 +4104,7 @@ necessary.
 
 @subsection The unread/all counts in the main-screen differ from the 'real' numbers - what's going on?
 For speed reasons, the counts do not exclude messages that no longer exist in
-the file-system, nor does it exclude duplicate messages; @xref{mu-mu4e-differ}.
+the file-system, nor do they exclude duplicate messages; @xref{mu-mu4e-differ}.
 
 @subsection How can I quickly delete/move/trash a lot of messages?
 You can select ('mark' in Emacs-speak) messages, just like you would select text

From 49606a76abc353a5baafac2d7559d8b9919ed4a9 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Fri, 6 Dec 2024 19:50:10 +0200
Subject: [PATCH 157/305] mu4e: cosmetics

---
 mu4e/mu4e-main.el        | 2 +-
 mu4e/mu4e-query-items.el | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/mu4e/mu4e-main.el b/mu4e/mu4e-main.el
index 160ff6d65..a4c879463 100644
--- a/mu4e/mu4e-main.el
+++ b/mu4e/mu4e-main.el
@@ -270,7 +270,7 @@ for aligning them."
    "\n"))
 
 (defun mu4e--main-baseline-time-string ()
-  "Calculate the baseline time string for use in the main-"
+  "Calculate the baseline time string for use in the main-view."
   (let* ((baseline-t mu4e--query-items-baseline-tstamp)
          (updated-t (plist-get mu4e-index-update-status :tstamp))
          (delta-t (and baseline-t updated-t
diff --git a/mu4e/mu4e-query-items.el b/mu4e/mu4e-query-items.el
index d7b6ef21e..b420155b2 100644
--- a/mu4e/mu4e-query-items.el
+++ b/mu4e/mu4e-query-items.el
@@ -56,8 +56,8 @@ anything about the query, it just does text replacement.
 
 A word of caution: the function should be deterministic and
 always return the same result for a given query (at least within
-some \"context\" (see `mu4e-context'). If not, you may get incorrect results
-for the various unread counts."
+some \"context\" (see `mu4e-context'). If not, you may get
+incorrect results for the various unread counts."
   :type 'function
   :group 'mu4e-search)
 

From 6166b435d2bfa4e8c12bcf78a44d7bdc7baa90cb Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Fri, 6 Dec 2024 20:01:39 +0200
Subject: [PATCH 158/305] thirdparty/cli11: bump to v2.4.2

---
 thirdparty/CLI11.hpp | 104 ++++++++++++++++++++++++++++---------------
 1 file changed, 68 insertions(+), 36 deletions(-)

diff --git a/thirdparty/CLI11.hpp b/thirdparty/CLI11.hpp
index 41027f0e9..8a5b4c544 100644
--- a/thirdparty/CLI11.hpp
+++ b/thirdparty/CLI11.hpp
@@ -1,11 +1,11 @@
-// CLI11: Version 2.4.1
+// CLI11: Version 2.4.2
 // Originally designed by Henry Schreiner
 // https://github.com/CLIUtils/CLI11
 //
 // This is a standalone header file generated by MakeSingleHeader.py in CLI11/scripts
-// from: v2.4.1
+// from: v2.4.2
 //
-// CLI11 2.4.1 Copyright (c) 2017-2024 University of Cincinnati, developed by Henry
+// CLI11 2.4.2 Copyright (c) 2017-2024 University of Cincinnati, developed by Henry
 // Schreiner under NSF AWARD 1414736. All rights reserved.
 //
 // Redistribution and use in source and binary forms of CLI11, with or without
@@ -66,8 +66,8 @@
 
 #define CLI11_VERSION_MAJOR 2
 #define CLI11_VERSION_MINOR 4
-#define CLI11_VERSION_PATCH 1
-#define CLI11_VERSION "2.4.1"
+#define CLI11_VERSION_PATCH 2
+#define CLI11_VERSION "2.4.2"
 
 
 
@@ -1451,22 +1451,22 @@ class RequiredError : public ParseError {
         if((min_option == 1) && (max_option == 1) && (used == 0))
             return RequiredError("Exactly 1 option from [" + option_list + "]");
         if((min_option == 1) && (max_option == 1) && (used > 1)) {
-            return {"Exactly 1 option from [" + option_list + "] is required and " + std::to_string(used) +
+            return {"Exactly 1 option from [" + option_list + "] is required but " + std::to_string(used) +
                         " were given",
                     ExitCodes::RequiredError};
         }
         if((min_option == 1) && (used == 0))
             return RequiredError("At least 1 option from [" + option_list + "]");
         if(used < min_option) {
-            return {"Requires at least " + std::to_string(min_option) + " options used and only " +
-                        std::to_string(used) + "were given from [" + option_list + "]",
+            return {"Requires at least " + std::to_string(min_option) + " options used but only " +
+                        std::to_string(used) + " were given from [" + option_list + "]",
                     ExitCodes::RequiredError};
         }
         if(max_option == 1)
             return {"Requires at most 1 options be given from [" + option_list + "]", ExitCodes::RequiredError};
 
-        return {"Requires at most " + std::to_string(max_option) + " options be used and " + std::to_string(used) +
-                    "were given from [" + option_list + "]",
+        return {"Requires at most " + std::to_string(max_option) + " options be used but " + std::to_string(used) +
+                    " were given from [" + option_list + "]",
                 ExitCodes::RequiredError};
     }
 };
@@ -1633,6 +1633,23 @@ template <> struct IsMemberType<const char *> {
     using type = std::string;
 };
 
+namespace adl_detail {
+/// Check for existence of user-supplied lexical_cast.
+///
+/// This struct has to be in a separate namespace so that it doesn't see our lexical_cast overloads in CLI::detail.
+/// Standard says it shouldn't see them if it's defined before the corresponding lexical_cast declarations, but this
+/// requires a working implementation of two-phase lookup, and not all compilers can boast that (msvc, ahem).
+template <typename T, typename S = std::string> class is_lexical_castable {
+    template <typename TT, typename SS>
+    static auto test(int) -> decltype(lexical_cast(std::declval<const SS &>(), std::declval<TT &>()), std::true_type());
+
+    template <typename, typename> static auto test(...) -> std::false_type;
+
+  public:
+    static constexpr bool value = decltype(test<T, S>(0))::value;
+};
+}  // namespace adl_detail
+
 namespace detail {
 
 // These are utilities for IsMember and other transforming objects
@@ -1714,7 +1731,7 @@ template <typename T, typename C> class is_direct_constructible {
 #pragma diag_suppress 2361
 #endif
 #endif
-        TT{std::declval<CC>()}
+                                              TT{std::declval<CC>()}
 #ifdef __CUDACC__
 #ifdef __NVCC_DIAG_PRAGMA_SUPPORT__
 #pragma nv_diag_default 2361
@@ -1722,8 +1739,8 @@ template <typename T, typename C> class is_direct_constructible {
 #pragma diag_default 2361
 #endif
 #endif
-        ,
-        std::is_move_assignable<TT>());
+                                              ,
+                                              std::is_move_assignable<TT>());
 
     template <typename TT, typename CC> static auto test(int, std::false_type) -> std::false_type;
 
@@ -2793,13 +2810,24 @@ bool lexical_cast(const std::string &input, T &output) {
 
 /// Non-string parsable by a stream
 template <typename T,
-          enable_if_t<classify_object<T>::value == object_category::other && !std::is_assignable<T &, int>::value,
+          enable_if_t<classify_object<T>::value == object_category::other && !std::is_assignable<T &, int>::value &&
+                          is_istreamable<T>::value,
                       detail::enabler> = detail::dummy>
 bool lexical_cast(const std::string &input, T &output) {
-    static_assert(is_istreamable<T>::value,
+    return from_stream(input, output);
+}
+
+/// Fallback overload that prints a human-readable error for types that we don't recognize and that don't have a
+/// user-supplied lexical_cast overload.
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::other && !std::is_assignable<T &, int>::value &&
+                          !is_istreamable<T>::value && !adl_detail::is_lexical_castable<T>::value,
+                      detail::enabler> = detail::dummy>
+bool lexical_cast(const std::string & /*input*/, T & /*output*/) {
+    static_assert(!std::is_same<T, T>::value,  // Can't just write false here.
                   "option object type must have a lexical cast overload or streaming input operator(>>) defined, if it "
                   "is convertible from another type use the add_option<T, XC>(...) with XC being the known type");
-    return from_stream(input, output);
+    return false;
 }
 
 /// Assign a value through lexical cast operations
@@ -7097,6 +7125,10 @@ class App {
     /// Check to see if a subcommand is part of this command (text version)
     CLI11_NODISCARD App *get_subcommand(std::string subcom) const;
 
+    /// Get a subcommand by name (noexcept non-const version)
+    /// returns null if subcommand doesn't exist
+    CLI11_NODISCARD App *get_subcommand_no_throw(std::string subcom) const noexcept;
+
     /// Get a pointer to subcommand by index
     CLI11_NODISCARD App *get_subcommand(int index = 0) const;
 
@@ -7271,8 +7303,9 @@ class App {
     }
 
     /// Check with name instead of pointer to see if subcommand was selected
-    CLI11_NODISCARD bool got_subcommand(std::string subcommand_name) const {
-        return get_subcommand(subcommand_name)->parsed_ > 0;
+    CLI11_NODISCARD bool got_subcommand(std::string subcommand_name) const noexcept {
+        App *sub = get_subcommand_no_throw(subcommand_name);
+        return (sub != nullptr) ? (sub->parsed_ > 0) : false;
     }
 
     /// Sets excluded options for the subcommand
@@ -7402,7 +7435,7 @@ class App {
     std::vector<Option *> get_options(const std::function<bool(Option *)> filter = {});
 
     /// Get an option by name (noexcept non-const version)
-    Option *get_option_no_throw(std::string option_name) noexcept;
+    CLI11_NODISCARD Option *get_option_no_throw(std::string option_name) noexcept;
 
     /// Get an option by name (noexcept const version)
     CLI11_NODISCARD const Option *get_option_no_throw(std::string option_name) const noexcept;
@@ -8056,8 +8089,8 @@ App::set_version_flag(std::string flag_name, std::function<std::string()> vfunc,
 
     // Empty name will simply remove the version flag
     if(!flag_name.empty()) {
-        version_ptr_ = add_flag_callback(
-            flag_name, [vfunc]() { throw(CLI::CallForVersion(vfunc(), 0)); }, version_help);
+        version_ptr_ =
+            add_flag_callback(flag_name, [vfunc]() { throw(CLI::CallForVersion(vfunc(), 0)); }, version_help);
         version_ptr_->configurable(false);
     }
 
@@ -8234,6 +8267,10 @@ CLI11_NODISCARD CLI11_INLINE App *App::get_subcommand(std::string subcom) const
     return subc;
 }
 
+CLI11_NODISCARD CLI11_INLINE App *App::get_subcommand_no_throw(std::string subcom) const noexcept {
+    return _find_subcommand(subcom, false, false);
+}
+
 CLI11_NODISCARD CLI11_INLINE App *App::get_subcommand(int index) const {
     if(index >= 0) {
         auto uindex = static_cast<unsigned>(index);
@@ -8573,7 +8610,7 @@ CLI11_INLINE std::vector<Option *> App::get_options(const std::function<bool(Opt
     return options;
 }
 
-CLI11_INLINE Option *App::get_option_no_throw(std::string option_name) noexcept {
+CLI11_NODISCARD CLI11_INLINE Option *App::get_option_no_throw(std::string option_name) noexcept {
     for(Option_p &opt : options_) {
         if(opt->check_name(option_name)) {
             return opt.get();
@@ -8913,11 +8950,9 @@ CLI11_INLINE void App::_process_env() {
     }
 
     for(App_p &sub : subcommands_) {
-        if(sub->get_name().empty() || !sub->parse_complete_callback_) {
-            if(sub->count_all() > 0) {
-                // only process environment variables if the callback has actually been triggered already
-                sub->_process_env();
-            }
+        if(sub->get_name().empty() || (sub->count_all() > 0 && !sub->parse_complete_callback_)) {
+            // only process environment variables if the callback has actually been triggered already
+            sub->_process_env();
         }
     }
 }
@@ -9220,12 +9255,8 @@ CLI11_INLINE void App::_parse_config(const std::vector<ConfigItem> &args) {
 CLI11_INLINE bool App::_parse_single_config(const ConfigItem &item, std::size_t level) {
 
     if(level < item.parents.size()) {
-        try {
-            auto *subcom = get_subcommand(item.parents.at(level));
-            return subcom->_parse_single_config(item, level + 1);
-        } catch(const OptionNotFound &) {
-            return false;
-        }
+        auto *subcom = get_subcommand_no_throw(item.parents.at(level));
+        return (subcom != nullptr) ? subcom->_parse_single_config(item, level + 1) : false;
     }
     // check for section open
     if(item.name == "++") {
@@ -9259,11 +9290,12 @@ CLI11_INLINE bool App::_parse_single_config(const ConfigItem &item, std::size_t
 
     if(op == nullptr) {
         // If the option was not present
-        if(get_allow_config_extras() == config_extras_mode::capture)
+        if(get_allow_config_extras() == config_extras_mode::capture) {
             // Should we worry about classifying the extras properly?
             missing_.emplace_back(detail::Classifier::NONE, item.fullname());
-        for(const auto &input : item.inputs) {
-            missing_.emplace_back(detail::Classifier::NONE, input);
+            for(const auto &input : item.inputs) {
+                missing_.emplace_back(detail::Classifier::NONE, input);
+            }
         }
         return false;
     }

From 030daeed5269be173cec2768124cfbc8059704ba Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Fri, 6 Dec 2024 20:09:31 +0200
Subject: [PATCH 159/305] thirdparty/fmt: bump to 11.0.2

---
 thirdparty/fmt/{LICENSE.rst => LICENSE} |    0
 thirdparty/fmt/args.h                   |  115 +-
 thirdparty/fmt/base.h                   | 3077 +++++++++++++++++++++++
 thirdparty/fmt/chrono.h                 |  478 ++--
 thirdparty/fmt/color.h                  |  193 +-
 thirdparty/fmt/compile.h                |  110 +-
 thirdparty/fmt/core.h                   | 2972 +---------------------
 thirdparty/fmt/format-inl.h             |  304 ++-
 thirdparty/fmt/format.h                 | 1356 +++++-----
 thirdparty/fmt/os.h                     |  188 +-
 thirdparty/fmt/ostream.h                |   84 +-
 thirdparty/fmt/printf.h                 |  253 +-
 thirdparty/fmt/ranges.h                 |  484 ++--
 thirdparty/fmt/std.h                    |  394 ++-
 thirdparty/fmt/xchar.h                  |  155 +-
 15 files changed, 5433 insertions(+), 4730 deletions(-)
 rename thirdparty/fmt/{LICENSE.rst => LICENSE} (100%)
 create mode 100644 thirdparty/fmt/base.h

diff --git a/thirdparty/fmt/LICENSE.rst b/thirdparty/fmt/LICENSE
similarity index 100%
rename from thirdparty/fmt/LICENSE.rst
rename to thirdparty/fmt/LICENSE
diff --git a/thirdparty/fmt/args.h b/thirdparty/fmt/args.h
index ad1654bbb..31a60e8fa 100644
--- a/thirdparty/fmt/args.h
+++ b/thirdparty/fmt/args.h
@@ -8,11 +8,13 @@
 #ifndef FMT_ARGS_H_
 #define FMT_ARGS_H_
 
-#include <functional>  // std::reference_wrapper
-#include <memory>      // std::unique_ptr
-#include <vector>
+#ifndef FMT_MODULE
+#  include <functional>  // std::reference_wrapper
+#  include <memory>      // std::unique_ptr
+#  include <vector>
+#endif
 
-#include "core.h"
+#include "format.h"  // std_string_view
 
 FMT_BEGIN_NAMESPACE
 
@@ -28,15 +30,18 @@ auto unwrap(const std::reference_wrapper<T>& v) -> const T& {
   return static_cast<const T&>(v);
 }
 
-class dynamic_arg_list {
-  // Workaround for clang's -Wweak-vtables. Unlike for regular classes, for
-  // templates it doesn't complain about inability to deduce single translation
-  // unit for placing vtable. So storage_node_base is made a fake template.
-  template <typename = void> struct node {
-    virtual ~node() = default;
-    std::unique_ptr<node<>> next;
-  };
+// node is defined outside dynamic_arg_list to workaround a C2504 bug in MSVC
+// 2022 (v17.10.0).
+//
+// Workaround for clang's -Wweak-vtables. Unlike for regular classes, for
+// templates it doesn't complain about inability to deduce single translation
+// unit for placing vtable. So node is made a fake template.
+template <typename = void> struct node {
+  virtual ~node() = default;
+  std::unique_ptr<node<>> next;
+};
 
+class dynamic_arg_list {
   template <typename T> struct typed_node : node<> {
     T value;
 
@@ -62,14 +67,10 @@ class dynamic_arg_list {
 }  // namespace detail
 
 /**
-  \rst
-  A dynamic version of `fmt::format_arg_store`.
-  It's equipped with a storage to potentially temporary objects which lifetimes
-  could be shorter than the format arguments object.
-
-  It can be implicitly converted into `~fmt::basic_format_args` for passing
-  into type-erased formatting functions such as `~fmt::vformat`.
-  \endrst
+ * A dynamic list of formatting arguments with storage.
+ *
+ * It can be implicitly converted into `fmt::basic_format_args` for passing
+ * into type-erased formatting functions such as `fmt::vformat`.
  */
 template <typename Context>
 class dynamic_format_arg_store
@@ -147,22 +148,20 @@ class dynamic_format_arg_store
   constexpr dynamic_format_arg_store() = default;
 
   /**
-    \rst
-    Adds an argument into the dynamic store for later passing to a formatting
-    function.
-
-    Note that custom types and string types (but not string views) are copied
-    into the store dynamically allocating memory if necessary.
-
-    **Example**::
-
-      fmt::dynamic_format_arg_store<fmt::format_context> store;
-      store.push_back(42);
-      store.push_back("abc");
-      store.push_back(1.5f);
-      std::string result = fmt::vformat("{} and {} and {}", store);
-    \endrst
-  */
+   * Adds an argument into the dynamic store for later passing to a formatting
+   * function.
+   *
+   * Note that custom types and string types (but not string views) are copied
+   * into the store dynamically allocating memory if necessary.
+   *
+   * **Example**:
+   *
+   *     fmt::dynamic_format_arg_store<fmt::format_context> store;
+   *     store.push_back(42);
+   *     store.push_back("abc");
+   *     store.push_back(1.5f);
+   *     std::string result = fmt::vformat("{} and {} and {}", store);
+   */
   template <typename T> void push_back(const T& arg) {
     if (detail::const_check(need_copy<T>::value))
       emplace_arg(dynamic_args_.push<stored_type<T>>(arg));
@@ -171,20 +170,18 @@ class dynamic_format_arg_store
   }
 
   /**
-    \rst
-    Adds a reference to the argument into the dynamic store for later passing to
-    a formatting function.
-
-    **Example**::
-
-      fmt::dynamic_format_arg_store<fmt::format_context> store;
-      char band[] = "Rolling Stones";
-      store.push_back(std::cref(band));
-      band[9] = 'c'; // Changing str affects the output.
-      std::string result = fmt::vformat("{}", store);
-      // result == "Rolling Scones"
-    \endrst
-  */
+   * Adds a reference to the argument into the dynamic store for later passing
+   * to a formatting function.
+   *
+   * **Example**:
+   *
+   *     fmt::dynamic_format_arg_store<fmt::format_context> store;
+   *     char band[] = "Rolling Stones";
+   *     store.push_back(std::cref(band));
+   *     band[9] = 'c'; // Changing str affects the output.
+   *     std::string result = fmt::vformat("{}", store);
+   *     // result == "Rolling Scones"
+   */
   template <typename T> void push_back(std::reference_wrapper<T> arg) {
     static_assert(
         need_copy<T>::value,
@@ -193,10 +190,10 @@ class dynamic_format_arg_store
   }
 
   /**
-    Adds named argument into the dynamic store for later passing to a formatting
-    function. ``std::reference_wrapper`` is supported to avoid copying of the
-    argument. The name is always copied into the store.
-  */
+   * Adds named argument into the dynamic store for later passing to a
+   * formatting function. `std::reference_wrapper` is supported to avoid
+   * copying of the argument. The name is always copied into the store.
+   */
   template <typename T>
   void push_back(const detail::named_arg<char_type, T>& arg) {
     const char_type* arg_name =
@@ -209,19 +206,15 @@ class dynamic_format_arg_store
     }
   }
 
-  /** Erase all elements from the store */
+  /// Erase all elements from the store.
   void clear() {
     data_.clear();
     named_info_.clear();
     dynamic_args_ = detail::dynamic_arg_list();
   }
 
-  /**
-    \rst
-    Reserves space to store at least *new_cap* arguments including
-    *new_cap_named* named arguments.
-    \endrst
-  */
+  /// Reserves space to store at least `new_cap` arguments including
+  /// `new_cap_named` named arguments.
   void reserve(size_t new_cap, size_t new_cap_named) {
     FMT_ASSERT(new_cap >= new_cap_named,
                "Set of arguments includes set of named arguments");
diff --git a/thirdparty/fmt/base.h b/thirdparty/fmt/base.h
new file mode 100644
index 000000000..627649425
--- /dev/null
+++ b/thirdparty/fmt/base.h
@@ -0,0 +1,3077 @@
+// Formatting library for C++ - the base API for char/UTF-8
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_BASE_H_
+#define FMT_BASE_H_
+
+#if defined(FMT_IMPORT_STD) && !defined(FMT_MODULE)
+#  define FMT_MODULE
+#endif
+
+#ifndef FMT_MODULE
+#  include <limits.h>  // CHAR_BIT
+#  include <stdio.h>   // FILE
+#  include <string.h>  // strlen
+
+// <cstddef> is also included transitively from <type_traits>.
+#  include <cstddef>      // std::byte
+#  include <type_traits>  // std::enable_if
+#endif
+
+// The fmt library version in the form major * 10000 + minor * 100 + patch.
+#define FMT_VERSION 110002
+
+// Detect compiler versions.
+#if defined(__clang__) && !defined(__ibmxl__)
+#  define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__)
+#else
+#  define FMT_CLANG_VERSION 0
+#endif
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER)
+#  define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
+#else
+#  define FMT_GCC_VERSION 0
+#endif
+#if defined(__ICL)
+#  define FMT_ICC_VERSION __ICL
+#elif defined(__INTEL_COMPILER)
+#  define FMT_ICC_VERSION __INTEL_COMPILER
+#else
+#  define FMT_ICC_VERSION 0
+#endif
+#if defined(_MSC_VER)
+#  define FMT_MSC_VERSION _MSC_VER
+#else
+#  define FMT_MSC_VERSION 0
+#endif
+
+// Detect standard library versions.
+#ifdef _GLIBCXX_RELEASE
+#  define FMT_GLIBCXX_RELEASE _GLIBCXX_RELEASE
+#else
+#  define FMT_GLIBCXX_RELEASE 0
+#endif
+#ifdef _LIBCPP_VERSION
+#  define FMT_LIBCPP_VERSION _LIBCPP_VERSION
+#else
+#  define FMT_LIBCPP_VERSION 0
+#endif
+
+#ifdef _MSVC_LANG
+#  define FMT_CPLUSPLUS _MSVC_LANG
+#else
+#  define FMT_CPLUSPLUS __cplusplus
+#endif
+
+// Detect __has_*.
+#ifdef __has_feature
+#  define FMT_HAS_FEATURE(x) __has_feature(x)
+#else
+#  define FMT_HAS_FEATURE(x) 0
+#endif
+#ifdef __has_include
+#  define FMT_HAS_INCLUDE(x) __has_include(x)
+#else
+#  define FMT_HAS_INCLUDE(x) 0
+#endif
+#ifdef __has_cpp_attribute
+#  define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
+#else
+#  define FMT_HAS_CPP_ATTRIBUTE(x) 0
+#endif
+
+#define FMT_HAS_CPP14_ATTRIBUTE(attribute) \
+  (FMT_CPLUSPLUS >= 201402L && FMT_HAS_CPP_ATTRIBUTE(attribute))
+
+#define FMT_HAS_CPP17_ATTRIBUTE(attribute) \
+  (FMT_CPLUSPLUS >= 201703L && FMT_HAS_CPP_ATTRIBUTE(attribute))
+
+// Detect C++14 relaxed constexpr.
+#ifdef FMT_USE_CONSTEXPR
+// Use the provided definition.
+#elif FMT_GCC_VERSION >= 600 && FMT_CPLUSPLUS >= 201402L
+// GCC only allows throw in constexpr since version 6:
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=67371.
+#  define FMT_USE_CONSTEXPR 1
+#elif FMT_ICC_VERSION
+#  define FMT_USE_CONSTEXPR 0  // https://github.com/fmtlib/fmt/issues/1628
+#elif FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VERSION >= 1912
+#  define FMT_USE_CONSTEXPR 1
+#else
+#  define FMT_USE_CONSTEXPR 0
+#endif
+#if FMT_USE_CONSTEXPR
+#  define FMT_CONSTEXPR constexpr
+#else
+#  define FMT_CONSTEXPR
+#endif
+
+// Detect consteval, C++20 constexpr extensions and std::is_constant_evaluated.
+#if !defined(__cpp_lib_is_constant_evaluated)
+#  define FMT_USE_CONSTEVAL 0
+#elif FMT_CPLUSPLUS < 201709L
+#  define FMT_USE_CONSTEVAL 0
+#elif FMT_GLIBCXX_RELEASE && FMT_GLIBCXX_RELEASE < 10
+#  define FMT_USE_CONSTEVAL 0
+#elif FMT_LIBCPP_VERSION && FMT_LIBCPP_VERSION < 10000
+#  define FMT_USE_CONSTEVAL 0
+#elif defined(__apple_build_version__) && __apple_build_version__ < 14000029L
+#  define FMT_USE_CONSTEVAL 0  // consteval is broken in Apple clang < 14.
+#elif FMT_MSC_VERSION && FMT_MSC_VERSION < 1929
+#  define FMT_USE_CONSTEVAL 0  // consteval is broken in MSVC VS2019 < 16.10.
+#elif defined(__cpp_consteval)
+#  define FMT_USE_CONSTEVAL 1
+#elif FMT_GCC_VERSION >= 1002 || FMT_CLANG_VERSION >= 1101
+#  define FMT_USE_CONSTEVAL 1
+#else
+#  define FMT_USE_CONSTEVAL 0
+#endif
+#if FMT_USE_CONSTEVAL
+#  define FMT_CONSTEVAL consteval
+#  define FMT_CONSTEXPR20 constexpr
+#else
+#  define FMT_CONSTEVAL
+#  define FMT_CONSTEXPR20
+#endif
+
+#if defined(FMT_USE_NONTYPE_TEMPLATE_ARGS)
+// Use the provided definition.
+#elif defined(__NVCOMPILER)
+#  define FMT_USE_NONTYPE_TEMPLATE_ARGS 0
+#elif FMT_GCC_VERSION >= 903 && FMT_CPLUSPLUS >= 201709L
+#  define FMT_USE_NONTYPE_TEMPLATE_ARGS 1
+#elif defined(__cpp_nontype_template_args) && \
+    __cpp_nontype_template_args >= 201911L
+#  define FMT_USE_NONTYPE_TEMPLATE_ARGS 1
+#elif FMT_CLANG_VERSION >= 1200 && FMT_CPLUSPLUS >= 202002L
+#  define FMT_USE_NONTYPE_TEMPLATE_ARGS 1
+#else
+#  define FMT_USE_NONTYPE_TEMPLATE_ARGS 0
+#endif
+
+#ifdef FMT_USE_CONCEPTS
+// Use the provided definition.
+#elif defined(__cpp_concepts)
+#  define FMT_USE_CONCEPTS 1
+#else
+#  define FMT_USE_CONCEPTS 0
+#endif
+
+// Check if exceptions are disabled.
+#ifdef FMT_EXCEPTIONS
+// Use the provided definition.
+#elif defined(__GNUC__) && !defined(__EXCEPTIONS)
+#  define FMT_EXCEPTIONS 0
+#elif FMT_MSC_VERSION && !_HAS_EXCEPTIONS
+#  define FMT_EXCEPTIONS 0
+#else
+#  define FMT_EXCEPTIONS 1
+#endif
+#if FMT_EXCEPTIONS
+#  define FMT_TRY try
+#  define FMT_CATCH(x) catch (x)
+#else
+#  define FMT_TRY if (true)
+#  define FMT_CATCH(x) if (false)
+#endif
+
+#if FMT_HAS_CPP17_ATTRIBUTE(fallthrough)
+#  define FMT_FALLTHROUGH [[fallthrough]]
+#elif defined(__clang__)
+#  define FMT_FALLTHROUGH [[clang::fallthrough]]
+#elif FMT_GCC_VERSION >= 700 && \
+    (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= 520)
+#  define FMT_FALLTHROUGH [[gnu::fallthrough]]
+#else
+#  define FMT_FALLTHROUGH
+#endif
+
+// Disable [[noreturn]] on MSVC/NVCC because of bogus unreachable code warnings.
+#if FMT_HAS_CPP_ATTRIBUTE(noreturn) && !FMT_MSC_VERSION && !defined(__NVCC__)
+#  define FMT_NORETURN [[noreturn]]
+#else
+#  define FMT_NORETURN
+#endif
+
+#ifndef FMT_NODISCARD
+#  if FMT_HAS_CPP17_ATTRIBUTE(nodiscard)
+#    define FMT_NODISCARD [[nodiscard]]
+#  else
+#    define FMT_NODISCARD
+#  endif
+#endif
+
+#ifdef FMT_DEPRECATED
+// Use the provided definition.
+#elif FMT_HAS_CPP14_ATTRIBUTE(deprecated)
+#  define FMT_DEPRECATED [[deprecated]]
+#else
+#  define FMT_DEPRECATED /* deprecated */
+#endif
+
+#ifdef FMT_INLINE
+// Use the provided definition.
+#elif FMT_GCC_VERSION || FMT_CLANG_VERSION
+#  define FMT_ALWAYS_INLINE inline __attribute__((always_inline))
+#else
+#  define FMT_ALWAYS_INLINE inline
+#endif
+// A version of FMT_INLINE to prevent code bloat in debug mode.
+#ifdef NDEBUG
+#  define FMT_INLINE FMT_ALWAYS_INLINE
+#else
+#  define FMT_INLINE inline
+#endif
+
+#if FMT_GCC_VERSION || FMT_CLANG_VERSION
+#  define FMT_VISIBILITY(value) __attribute__((visibility(value)))
+#else
+#  define FMT_VISIBILITY(value)
+#endif
+
+#ifndef FMT_GCC_PRAGMA
+// Workaround a _Pragma bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59884
+// and an nvhpc warning: https://github.com/fmtlib/fmt/pull/2582.
+#  if FMT_GCC_VERSION >= 504 && !defined(__NVCOMPILER)
+#    define FMT_GCC_PRAGMA(arg) _Pragma(arg)
+#  else
+#    define FMT_GCC_PRAGMA(arg)
+#  endif
+#endif
+
+// GCC < 5 requires this-> in decltype.
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 500
+#  define FMT_DECLTYPE_THIS this->
+#else
+#  define FMT_DECLTYPE_THIS
+#endif
+
+#if FMT_MSC_VERSION
+#  define FMT_MSC_WARNING(...) __pragma(warning(__VA_ARGS__))
+#  define FMT_UNCHECKED_ITERATOR(It) \
+    using _Unchecked_type = It  // Mark iterator as checked.
+#else
+#  define FMT_MSC_WARNING(...)
+#  define FMT_UNCHECKED_ITERATOR(It) using unchecked_type = It
+#endif
+
+#ifndef FMT_BEGIN_NAMESPACE
+#  define FMT_BEGIN_NAMESPACE \
+    namespace fmt {           \
+    inline namespace v11 {
+#  define FMT_END_NAMESPACE \
+    }                       \
+    }
+#endif
+
+#ifndef FMT_EXPORT
+#  define FMT_EXPORT
+#  define FMT_BEGIN_EXPORT
+#  define FMT_END_EXPORT
+#endif
+
+#if !defined(FMT_HEADER_ONLY) && defined(_WIN32)
+#  if defined(FMT_LIB_EXPORT)
+#    define FMT_API __declspec(dllexport)
+#  elif defined(FMT_SHARED)
+#    define FMT_API __declspec(dllimport)
+#  endif
+#elif defined(FMT_LIB_EXPORT) || defined(FMT_SHARED)
+#  define FMT_API FMT_VISIBILITY("default")
+#endif
+#ifndef FMT_API
+#  define FMT_API
+#endif
+
+#ifndef FMT_UNICODE
+#  define FMT_UNICODE 1
+#endif
+
+// Check if rtti is available.
+#ifndef FMT_USE_RTTI
+// __RTTI is for EDG compilers. _CPPRTTI is for MSVC.
+#  if defined(__GXX_RTTI) || FMT_HAS_FEATURE(cxx_rtti) || defined(_CPPRTTI) || \
+      defined(__INTEL_RTTI__) || defined(__RTTI)
+#    define FMT_USE_RTTI 1
+#  else
+#    define FMT_USE_RTTI 0
+#  endif
+#endif
+
+#define FMT_FWD(...) static_cast<decltype(__VA_ARGS__)&&>(__VA_ARGS__)
+
+// Enable minimal optimizations for more compact code in debug mode.
+FMT_GCC_PRAGMA("GCC push_options")
+#if !defined(__OPTIMIZE__) && !defined(__CUDACC__)
+FMT_GCC_PRAGMA("GCC optimize(\"Og\")")
+#endif
+
+FMT_BEGIN_NAMESPACE
+
+// Implementations of enable_if_t and other metafunctions for older systems.
+template <bool B, typename T = void>
+using enable_if_t = typename std::enable_if<B, T>::type;
+template <bool B, typename T, typename F>
+using conditional_t = typename std::conditional<B, T, F>::type;
+template <bool B> using bool_constant = std::integral_constant<bool, B>;
+template <typename T>
+using remove_reference_t = typename std::remove_reference<T>::type;
+template <typename T>
+using remove_const_t = typename std::remove_const<T>::type;
+template <typename T>
+using remove_cvref_t = typename std::remove_cv<remove_reference_t<T>>::type;
+template <typename T> struct type_identity {
+  using type = T;
+};
+template <typename T> using type_identity_t = typename type_identity<T>::type;
+template <typename T>
+using make_unsigned_t = typename std::make_unsigned<T>::type;
+template <typename T>
+using underlying_t = typename std::underlying_type<T>::type;
+
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 500
+// A workaround for gcc 4.8 to make void_t work in a SFINAE context.
+template <typename...> struct void_t_impl {
+  using type = void;
+};
+template <typename... T> using void_t = typename void_t_impl<T...>::type;
+#else
+template <typename...> using void_t = void;
+#endif
+
+struct monostate {
+  constexpr monostate() {}
+};
+
+// An enable_if helper to be used in template parameters which results in much
+// shorter symbols: https://godbolt.org/z/sWw4vP. Extra parentheses are needed
+// to workaround a bug in MSVC 2019 (see #1140 and #1186).
+#ifdef FMT_DOC
+#  define FMT_ENABLE_IF(...)
+#else
+#  define FMT_ENABLE_IF(...) fmt::enable_if_t<(__VA_ARGS__), int> = 0
+#endif
+
+// This is defined in base.h instead of format.h to avoid injecting in std.
+// It is a template to avoid undesirable implicit conversions to std::byte.
+#ifdef __cpp_lib_byte
+template <typename T, FMT_ENABLE_IF(std::is_same<T, std::byte>::value)>
+inline auto format_as(T b) -> unsigned char {
+  return static_cast<unsigned char>(b);
+}
+#endif
+
+namespace detail {
+// Suppresses "unused variable" warnings with the method described in
+// https://herbsutter.com/2009/10/18/mailbag-shutting-up-compiler-warnings/.
+// (void)var does not work on many Intel compilers.
+template <typename... T> FMT_CONSTEXPR void ignore_unused(const T&...) {}
+
+constexpr auto is_constant_evaluated(bool default_value = false) noexcept
+    -> bool {
+// Workaround for incompatibility between libstdc++ consteval-based
+// std::is_constant_evaluated() implementation and clang-14:
+// https://github.com/fmtlib/fmt/issues/3247.
+#if FMT_CPLUSPLUS >= 202002L && FMT_GLIBCXX_RELEASE >= 12 && \
+    (FMT_CLANG_VERSION >= 1400 && FMT_CLANG_VERSION < 1500)
+  ignore_unused(default_value);
+  return __builtin_is_constant_evaluated();
+#elif defined(__cpp_lib_is_constant_evaluated)
+  ignore_unused(default_value);
+  return std::is_constant_evaluated();
+#else
+  return default_value;
+#endif
+}
+
+// Suppresses "conditional expression is constant" warnings.
+template <typename T> constexpr auto const_check(T value) -> T { return value; }
+
+FMT_NORETURN FMT_API void assert_fail(const char* file, int line,
+                                      const char* message);
+
+#if defined(FMT_ASSERT)
+// Use the provided definition.
+#elif defined(NDEBUG)
+// FMT_ASSERT is not empty to avoid -Wempty-body.
+#  define FMT_ASSERT(condition, message) \
+    fmt::detail::ignore_unused((condition), (message))
+#else
+#  define FMT_ASSERT(condition, message)                                    \
+    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
+         ? (void)0                                                          \
+         : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
+#endif
+
+#ifdef FMT_USE_INT128
+// Do nothing.
+#elif defined(__SIZEOF_INT128__) && !defined(__NVCC__) && \
+    !(FMT_CLANG_VERSION && FMT_MSC_VERSION)
+#  define FMT_USE_INT128 1
+using int128_opt = __int128_t;  // An optional native 128-bit integer.
+using uint128_opt = __uint128_t;
+template <typename T> inline auto convert_for_visit(T value) -> T {
+  return value;
+}
+#else
+#  define FMT_USE_INT128 0
+#endif
+#if !FMT_USE_INT128
+enum class int128_opt {};
+enum class uint128_opt {};
+// Reduce template instantiations.
+template <typename T> auto convert_for_visit(T) -> monostate { return {}; }
+#endif
+
+// Casts a nonnegative integer to unsigned.
+template <typename Int>
+FMT_CONSTEXPR auto to_unsigned(Int value) -> make_unsigned_t<Int> {
+  FMT_ASSERT(std::is_unsigned<Int>::value || value >= 0, "negative value");
+  return static_cast<make_unsigned_t<Int>>(value);
+}
+
+// A heuristic to detect std::string and std::[experimental::]string_view.
+// It is mainly used to avoid dependency on <[experimental/]string_view>.
+template <typename T, typename Enable = void>
+struct is_std_string_like : std::false_type {};
+template <typename T>
+struct is_std_string_like<T, void_t<decltype(std::declval<T>().find_first_of(
+                                 typename T::value_type(), 0))>>
+    : std::is_convertible<decltype(std::declval<T>().data()),
+                          const typename T::value_type*> {};
+
+// Returns true iff the literal encoding is UTF-8.
+constexpr auto is_utf8_enabled() -> bool {
+  // Avoid an MSVC sign extension bug: https://github.com/fmtlib/fmt/pull/2297.
+  using uchar = unsigned char;
+  return sizeof("\u00A7") == 3 && uchar("\u00A7"[0]) == 0xC2 &&
+         uchar("\u00A7"[1]) == 0xA7;
+}
+constexpr auto use_utf8() -> bool {
+  return !FMT_MSC_VERSION || is_utf8_enabled();
+}
+
+static_assert(!FMT_UNICODE || use_utf8(),
+              "Unicode support requires compiling with /utf-8");
+
+template <typename Char> FMT_CONSTEXPR auto length(const Char* s) -> size_t {
+  size_t len = 0;
+  while (*s++) ++len;
+  return len;
+}
+
+template <typename Char>
+FMT_CONSTEXPR auto compare(const Char* s1, const Char* s2, std::size_t n)
+    -> int {
+  if (!is_constant_evaluated() && sizeof(Char) == 1) return memcmp(s1, s2, n);
+  for (; n != 0; ++s1, ++s2, --n) {
+    if (*s1 < *s2) return -1;
+    if (*s1 > *s2) return 1;
+  }
+  return 0;
+}
+
+namespace adl {
+using namespace std;
+
+template <typename Container>
+auto invoke_back_inserter()
+    -> decltype(back_inserter(std::declval<Container&>()));
+}  // namespace adl
+
+template <typename It, typename Enable = std::true_type>
+struct is_back_insert_iterator : std::false_type {};
+
+template <typename It>
+struct is_back_insert_iterator<
+    It, bool_constant<std::is_same<
+            decltype(adl::invoke_back_inserter<typename It::container_type>()),
+            It>::value>> : std::true_type {};
+
+// Extracts a reference to the container from *insert_iterator.
+template <typename OutputIt>
+inline auto get_container(OutputIt it) -> typename OutputIt::container_type& {
+  struct accessor : OutputIt {
+    accessor(OutputIt base) : OutputIt(base) {}
+    using OutputIt::container;
+  };
+  return *accessor(it).container;
+}
+}  // namespace detail
+
+// Checks whether T is a container with contiguous storage.
+template <typename T> struct is_contiguous : std::false_type {};
+
+/**
+ * An implementation of `std::basic_string_view` for pre-C++17. It provides a
+ * subset of the API. `fmt::basic_string_view` is used for format strings even
+ * if `std::basic_string_view` is available to prevent issues when a library is
+ * compiled with a different `-std` option than the client code (which is not
+ * recommended).
+ */
+FMT_EXPORT
+template <typename Char> class basic_string_view {
+ private:
+  const Char* data_;
+  size_t size_;
+
+ public:
+  using value_type = Char;
+  using iterator = const Char*;
+
+  constexpr basic_string_view() noexcept : data_(nullptr), size_(0) {}
+
+  /// Constructs a string reference object from a C string and a size.
+  constexpr basic_string_view(const Char* s, size_t count) noexcept
+      : data_(s), size_(count) {}
+
+  constexpr basic_string_view(std::nullptr_t) = delete;
+
+  /// Constructs a string reference object from a C string.
+  FMT_CONSTEXPR20
+  basic_string_view(const Char* s)
+      : data_(s),
+        size_(detail::const_check(std::is_same<Char, char>::value &&
+                                  !detail::is_constant_evaluated(false))
+                  ? strlen(reinterpret_cast<const char*>(s))
+                  : detail::length(s)) {}
+
+  /// Constructs a string reference from a `std::basic_string` or a
+  /// `std::basic_string_view` object.
+  template <typename S,
+            FMT_ENABLE_IF(detail::is_std_string_like<S>::value&& std::is_same<
+                          typename S::value_type, Char>::value)>
+  FMT_CONSTEXPR basic_string_view(const S& s) noexcept
+      : data_(s.data()), size_(s.size()) {}
+
+  /// Returns a pointer to the string data.
+  constexpr auto data() const noexcept -> const Char* { return data_; }
+
+  /// Returns the string size.
+  constexpr auto size() const noexcept -> size_t { return size_; }
+
+  constexpr auto begin() const noexcept -> iterator { return data_; }
+  constexpr auto end() const noexcept -> iterator { return data_ + size_; }
+
+  constexpr auto operator[](size_t pos) const noexcept -> const Char& {
+    return data_[pos];
+  }
+
+  FMT_CONSTEXPR void remove_prefix(size_t n) noexcept {
+    data_ += n;
+    size_ -= n;
+  }
+
+  FMT_CONSTEXPR auto starts_with(basic_string_view<Char> sv) const noexcept
+      -> bool {
+    return size_ >= sv.size_ && detail::compare(data_, sv.data_, sv.size_) == 0;
+  }
+  FMT_CONSTEXPR auto starts_with(Char c) const noexcept -> bool {
+    return size_ >= 1 && *data_ == c;
+  }
+  FMT_CONSTEXPR auto starts_with(const Char* s) const -> bool {
+    return starts_with(basic_string_view<Char>(s));
+  }
+
+  // Lexicographically compare this string reference to other.
+  FMT_CONSTEXPR auto compare(basic_string_view other) const -> int {
+    size_t str_size = size_ < other.size_ ? size_ : other.size_;
+    int result = detail::compare(data_, other.data_, str_size);
+    if (result == 0)
+      result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);
+    return result;
+  }
+
+  FMT_CONSTEXPR friend auto operator==(basic_string_view lhs,
+                                       basic_string_view rhs) -> bool {
+    return lhs.compare(rhs) == 0;
+  }
+  friend auto operator!=(basic_string_view lhs, basic_string_view rhs) -> bool {
+    return lhs.compare(rhs) != 0;
+  }
+  friend auto operator<(basic_string_view lhs, basic_string_view rhs) -> bool {
+    return lhs.compare(rhs) < 0;
+  }
+  friend auto operator<=(basic_string_view lhs, basic_string_view rhs) -> bool {
+    return lhs.compare(rhs) <= 0;
+  }
+  friend auto operator>(basic_string_view lhs, basic_string_view rhs) -> bool {
+    return lhs.compare(rhs) > 0;
+  }
+  friend auto operator>=(basic_string_view lhs, basic_string_view rhs) -> bool {
+    return lhs.compare(rhs) >= 0;
+  }
+};
+
+FMT_EXPORT
+using string_view = basic_string_view<char>;
+
+/// Specifies if `T` is a character type. Can be specialized by users.
+FMT_EXPORT
+template <typename T> struct is_char : std::false_type {};
+template <> struct is_char<char> : std::true_type {};
+
+namespace detail {
+
+// Constructs fmt::basic_string_view<Char> from types implicitly convertible
+// to it, deducing Char. Explicitly convertible types such as the ones returned
+// from FMT_STRING are intentionally excluded.
+template <typename Char, FMT_ENABLE_IF(is_char<Char>::value)>
+constexpr auto to_string_view(const Char* s) -> basic_string_view<Char> {
+  return s;
+}
+template <typename T, FMT_ENABLE_IF(is_std_string_like<T>::value)>
+constexpr auto to_string_view(const T& s)
+    -> basic_string_view<typename T::value_type> {
+  return s;
+}
+template <typename Char>
+constexpr auto to_string_view(basic_string_view<Char> s)
+    -> basic_string_view<Char> {
+  return s;
+}
+
+template <typename T, typename Enable = void>
+struct has_to_string_view : std::false_type {};
+// detail:: is intentional since to_string_view is not an extension point.
+template <typename T>
+struct has_to_string_view<
+    T, void_t<decltype(detail::to_string_view(std::declval<T>()))>>
+    : std::true_type {};
+
+template <typename Char, Char... C> struct string_literal {
+  static constexpr Char value[sizeof...(C)] = {C...};
+  constexpr operator basic_string_view<Char>() const {
+    return {value, sizeof...(C)};
+  }
+};
+#if FMT_CPLUSPLUS < 201703L
+template <typename Char, Char... C>
+constexpr Char string_literal<Char, C...>::value[sizeof...(C)];
+#endif
+
+enum class type {
+  none_type,
+  // Integer types should go first,
+  int_type,
+  uint_type,
+  long_long_type,
+  ulong_long_type,
+  int128_type,
+  uint128_type,
+  bool_type,
+  char_type,
+  last_integer_type = char_type,
+  // followed by floating-point types.
+  float_type,
+  double_type,
+  long_double_type,
+  last_numeric_type = long_double_type,
+  cstring_type,
+  string_type,
+  pointer_type,
+  custom_type
+};
+
+// Maps core type T to the corresponding type enum constant.
+template <typename T, typename Char>
+struct type_constant : std::integral_constant<type, type::custom_type> {};
+
+#define FMT_TYPE_CONSTANT(Type, constant) \
+  template <typename Char>                \
+  struct type_constant<Type, Char>        \
+      : std::integral_constant<type, type::constant> {}
+
+FMT_TYPE_CONSTANT(int, int_type);
+FMT_TYPE_CONSTANT(unsigned, uint_type);
+FMT_TYPE_CONSTANT(long long, long_long_type);
+FMT_TYPE_CONSTANT(unsigned long long, ulong_long_type);
+FMT_TYPE_CONSTANT(int128_opt, int128_type);
+FMT_TYPE_CONSTANT(uint128_opt, uint128_type);
+FMT_TYPE_CONSTANT(bool, bool_type);
+FMT_TYPE_CONSTANT(Char, char_type);
+FMT_TYPE_CONSTANT(float, float_type);
+FMT_TYPE_CONSTANT(double, double_type);
+FMT_TYPE_CONSTANT(long double, long_double_type);
+FMT_TYPE_CONSTANT(const Char*, cstring_type);
+FMT_TYPE_CONSTANT(basic_string_view<Char>, string_type);
+FMT_TYPE_CONSTANT(const void*, pointer_type);
+
+constexpr auto is_integral_type(type t) -> bool {
+  return t > type::none_type && t <= type::last_integer_type;
+}
+constexpr auto is_arithmetic_type(type t) -> bool {
+  return t > type::none_type && t <= type::last_numeric_type;
+}
+
+constexpr auto set(type rhs) -> int { return 1 << static_cast<int>(rhs); }
+constexpr auto in(type t, int set) -> bool {
+  return ((set >> static_cast<int>(t)) & 1) != 0;
+}
+
+// Bitsets of types.
+enum {
+  sint_set =
+      set(type::int_type) | set(type::long_long_type) | set(type::int128_type),
+  uint_set = set(type::uint_type) | set(type::ulong_long_type) |
+             set(type::uint128_type),
+  bool_set = set(type::bool_type),
+  char_set = set(type::char_type),
+  float_set = set(type::float_type) | set(type::double_type) |
+              set(type::long_double_type),
+  string_set = set(type::string_type),
+  cstring_set = set(type::cstring_type),
+  pointer_set = set(type::pointer_type)
+};
+}  // namespace detail
+
+/// Reports a format error at compile time or, via a `format_error` exception,
+/// at runtime.
+// This function is intentionally not constexpr to give a compile-time error.
+FMT_NORETURN FMT_API void report_error(const char* message);
+
+FMT_DEPRECATED FMT_NORETURN inline void throw_format_error(
+    const char* message) {
+  report_error(message);
+}
+
+/// String's character (code unit) type.
+template <typename S,
+          typename V = decltype(detail::to_string_view(std::declval<S>()))>
+using char_t = typename V::value_type;
+
+/**
+ * Parsing context consisting of a format string range being parsed and an
+ * argument counter for automatic indexing.
+ * You can use the `format_parse_context` type alias for `char` instead.
+ */
+FMT_EXPORT
+template <typename Char> class basic_format_parse_context {
+ private:
+  basic_string_view<Char> format_str_;
+  int next_arg_id_;
+
+  FMT_CONSTEXPR void do_check_arg_id(int id);
+
+ public:
+  using char_type = Char;
+  using iterator = const Char*;
+
+  explicit constexpr basic_format_parse_context(
+      basic_string_view<Char> format_str, int next_arg_id = 0)
+      : format_str_(format_str), next_arg_id_(next_arg_id) {}
+
+  /// Returns an iterator to the beginning of the format string range being
+  /// parsed.
+  constexpr auto begin() const noexcept -> iterator {
+    return format_str_.begin();
+  }
+
+  /// Returns an iterator past the end of the format string range being parsed.
+  constexpr auto end() const noexcept -> iterator { return format_str_.end(); }
+
+  /// Advances the begin iterator to `it`.
+  FMT_CONSTEXPR void advance_to(iterator it) {
+    format_str_.remove_prefix(detail::to_unsigned(it - begin()));
+  }
+
+  /// Reports an error if using the manual argument indexing; otherwise returns
+  /// the next argument index and switches to the automatic indexing.
+  FMT_CONSTEXPR auto next_arg_id() -> int {
+    if (next_arg_id_ < 0) {
+      report_error("cannot switch from manual to automatic argument indexing");
+      return 0;
+    }
+    int id = next_arg_id_++;
+    do_check_arg_id(id);
+    return id;
+  }
+
+  /// Reports an error if using the automatic argument indexing; otherwise
+  /// switches to the manual indexing.
+  FMT_CONSTEXPR void check_arg_id(int id) {
+    if (next_arg_id_ > 0) {
+      report_error("cannot switch from automatic to manual argument indexing");
+      return;
+    }
+    next_arg_id_ = -1;
+    do_check_arg_id(id);
+  }
+  FMT_CONSTEXPR void check_arg_id(basic_string_view<Char>) {
+    next_arg_id_ = -1;
+  }
+  FMT_CONSTEXPR void check_dynamic_spec(int arg_id);
+};
+
+FMT_EXPORT
+using format_parse_context = basic_format_parse_context<char>;
+
+namespace detail {
+// A parse context with extra data used only in compile-time checks.
+template <typename Char>
+class compile_parse_context : public basic_format_parse_context<Char> {
+ private:
+  int num_args_;
+  const type* types_;
+  using base = basic_format_parse_context<Char>;
+
+ public:
+  explicit FMT_CONSTEXPR compile_parse_context(
+      basic_string_view<Char> format_str, int num_args, const type* types,
+      int next_arg_id = 0)
+      : base(format_str, next_arg_id), num_args_(num_args), types_(types) {}
+
+  constexpr auto num_args() const -> int { return num_args_; }
+  constexpr auto arg_type(int id) const -> type { return types_[id]; }
+
+  FMT_CONSTEXPR auto next_arg_id() -> int {
+    int id = base::next_arg_id();
+    if (id >= num_args_) report_error("argument not found");
+    return id;
+  }
+
+  FMT_CONSTEXPR void check_arg_id(int id) {
+    base::check_arg_id(id);
+    if (id >= num_args_) report_error("argument not found");
+  }
+  using base::check_arg_id;
+
+  FMT_CONSTEXPR void check_dynamic_spec(int arg_id) {
+    detail::ignore_unused(arg_id);
+    if (arg_id < num_args_ && types_ && !is_integral_type(types_[arg_id]))
+      report_error("width/precision is not integer");
+  }
+};
+
+/// A contiguous memory buffer with an optional growing ability. It is an
+/// internal class and shouldn't be used directly, only via `memory_buffer`.
+template <typename T> class buffer {
+ private:
+  T* ptr_;
+  size_t size_;
+  size_t capacity_;
+
+  using grow_fun = void (*)(buffer& buf, size_t capacity);
+  grow_fun grow_;
+
+ protected:
+  // Don't initialize ptr_ since it is not accessed to save a few cycles.
+  FMT_MSC_WARNING(suppress : 26495)
+  FMT_CONSTEXPR20 buffer(grow_fun grow, size_t sz) noexcept
+      : size_(sz), capacity_(sz), grow_(grow) {}
+
+  constexpr buffer(grow_fun grow, T* p = nullptr, size_t sz = 0,
+                   size_t cap = 0) noexcept
+      : ptr_(p), size_(sz), capacity_(cap), grow_(grow) {}
+
+  FMT_CONSTEXPR20 ~buffer() = default;
+  buffer(buffer&&) = default;
+
+  /// Sets the buffer data and capacity.
+  FMT_CONSTEXPR void set(T* buf_data, size_t buf_capacity) noexcept {
+    ptr_ = buf_data;
+    capacity_ = buf_capacity;
+  }
+
+ public:
+  using value_type = T;
+  using const_reference = const T&;
+
+  buffer(const buffer&) = delete;
+  void operator=(const buffer&) = delete;
+
+  auto begin() noexcept -> T* { return ptr_; }
+  auto end() noexcept -> T* { return ptr_ + size_; }
+
+  auto begin() const noexcept -> const T* { return ptr_; }
+  auto end() const noexcept -> const T* { return ptr_ + size_; }
+
+  /// Returns the size of this buffer.
+  constexpr auto size() const noexcept -> size_t { return size_; }
+
+  /// Returns the capacity of this buffer.
+  constexpr auto capacity() const noexcept -> size_t { return capacity_; }
+
+  /// Returns a pointer to the buffer data (not null-terminated).
+  FMT_CONSTEXPR auto data() noexcept -> T* { return ptr_; }
+  FMT_CONSTEXPR auto data() const noexcept -> const T* { return ptr_; }
+
+  /// Clears this buffer.
+  void clear() { size_ = 0; }
+
+  // Tries resizing the buffer to contain `count` elements. If T is a POD type
+  // the new elements may not be initialized.
+  FMT_CONSTEXPR void try_resize(size_t count) {
+    try_reserve(count);
+    size_ = count <= capacity_ ? count : capacity_;
+  }
+
+  // Tries increasing the buffer capacity to `new_capacity`. It can increase the
+  // capacity by a smaller amount than requested but guarantees there is space
+  // for at least one additional element either by increasing the capacity or by
+  // flushing the buffer if it is full.
+  FMT_CONSTEXPR void try_reserve(size_t new_capacity) {
+    if (new_capacity > capacity_) grow_(*this, new_capacity);
+  }
+
+  FMT_CONSTEXPR void push_back(const T& value) {
+    try_reserve(size_ + 1);
+    ptr_[size_++] = value;
+  }
+
+  /// Appends data to the end of the buffer.
+  template <typename U> void append(const U* begin, const U* end) {
+    while (begin != end) {
+      auto count = to_unsigned(end - begin);
+      try_reserve(size_ + count);
+      auto free_cap = capacity_ - size_;
+      if (free_cap < count) count = free_cap;
+      // A loop is faster than memcpy on small sizes.
+      T* out = ptr_ + size_;
+      for (size_t i = 0; i < count; ++i) out[i] = begin[i];
+      size_ += count;
+      begin += count;
+    }
+  }
+
+  template <typename Idx> FMT_CONSTEXPR auto operator[](Idx index) -> T& {
+    return ptr_[index];
+  }
+  template <typename Idx>
+  FMT_CONSTEXPR auto operator[](Idx index) const -> const T& {
+    return ptr_[index];
+  }
+};
+
+struct buffer_traits {
+  explicit buffer_traits(size_t) {}
+  auto count() const -> size_t { return 0; }
+  auto limit(size_t size) -> size_t { return size; }
+};
+
+class fixed_buffer_traits {
+ private:
+  size_t count_ = 0;
+  size_t limit_;
+
+ public:
+  explicit fixed_buffer_traits(size_t limit) : limit_(limit) {}
+  auto count() const -> size_t { return count_; }
+  auto limit(size_t size) -> size_t {
+    size_t n = limit_ > count_ ? limit_ - count_ : 0;
+    count_ += size;
+    return size < n ? size : n;
+  }
+};
+
+// A buffer that writes to an output iterator when flushed.
+template <typename OutputIt, typename T, typename Traits = buffer_traits>
+class iterator_buffer : public Traits, public buffer<T> {
+ private:
+  OutputIt out_;
+  enum { buffer_size = 256 };
+  T data_[buffer_size];
+
+  static FMT_CONSTEXPR void grow(buffer<T>& buf, size_t) {
+    if (buf.size() == buffer_size) static_cast<iterator_buffer&>(buf).flush();
+  }
+
+  void flush() {
+    auto size = this->size();
+    this->clear();
+    const T* begin = data_;
+    const T* end = begin + this->limit(size);
+    while (begin != end) *out_++ = *begin++;
+  }
+
+ public:
+  explicit iterator_buffer(OutputIt out, size_t n = buffer_size)
+      : Traits(n), buffer<T>(grow, data_, 0, buffer_size), out_(out) {}
+  iterator_buffer(iterator_buffer&& other) noexcept
+      : Traits(other),
+        buffer<T>(grow, data_, 0, buffer_size),
+        out_(other.out_) {}
+  ~iterator_buffer() {
+    // Don't crash if flush fails during unwinding.
+    FMT_TRY { flush(); }
+    FMT_CATCH(...) {}
+  }
+
+  auto out() -> OutputIt {
+    flush();
+    return out_;
+  }
+  auto count() const -> size_t { return Traits::count() + this->size(); }
+};
+
+template <typename T>
+class iterator_buffer<T*, T, fixed_buffer_traits> : public fixed_buffer_traits,
+                                                    public buffer<T> {
+ private:
+  T* out_;
+  enum { buffer_size = 256 };
+  T data_[buffer_size];
+
+  static FMT_CONSTEXPR void grow(buffer<T>& buf, size_t) {
+    if (buf.size() == buf.capacity())
+      static_cast<iterator_buffer&>(buf).flush();
+  }
+
+  void flush() {
+    size_t n = this->limit(this->size());
+    if (this->data() == out_) {
+      out_ += n;
+      this->set(data_, buffer_size);
+    }
+    this->clear();
+  }
+
+ public:
+  explicit iterator_buffer(T* out, size_t n = buffer_size)
+      : fixed_buffer_traits(n), buffer<T>(grow, out, 0, n), out_(out) {}
+  iterator_buffer(iterator_buffer&& other) noexcept
+      : fixed_buffer_traits(other),
+        buffer<T>(static_cast<iterator_buffer&&>(other)),
+        out_(other.out_) {
+    if (this->data() != out_) {
+      this->set(data_, buffer_size);
+      this->clear();
+    }
+  }
+  ~iterator_buffer() { flush(); }
+
+  auto out() -> T* {
+    flush();
+    return out_;
+  }
+  auto count() const -> size_t {
+    return fixed_buffer_traits::count() + this->size();
+  }
+};
+
+template <typename T> class iterator_buffer<T*, T> : public buffer<T> {
+ public:
+  explicit iterator_buffer(T* out, size_t = 0)
+      : buffer<T>([](buffer<T>&, size_t) {}, out, 0, ~size_t()) {}
+
+  auto out() -> T* { return &*this->end(); }
+};
+
+// A buffer that writes to a container with the contiguous storage.
+template <typename OutputIt>
+class iterator_buffer<
+    OutputIt,
+    enable_if_t<detail::is_back_insert_iterator<OutputIt>::value &&
+                    is_contiguous<typename OutputIt::container_type>::value,
+                typename OutputIt::container_type::value_type>>
+    : public buffer<typename OutputIt::container_type::value_type> {
+ private:
+  using container_type = typename OutputIt::container_type;
+  using value_type = typename container_type::value_type;
+  container_type& container_;
+
+  static FMT_CONSTEXPR void grow(buffer<value_type>& buf, size_t capacity) {
+    auto& self = static_cast<iterator_buffer&>(buf);
+    self.container_.resize(capacity);
+    self.set(&self.container_[0], capacity);
+  }
+
+ public:
+  explicit iterator_buffer(container_type& c)
+      : buffer<value_type>(grow, c.size()), container_(c) {}
+  explicit iterator_buffer(OutputIt out, size_t = 0)
+      : iterator_buffer(get_container(out)) {}
+
+  auto out() -> OutputIt { return back_inserter(container_); }
+};
+
+// A buffer that counts the number of code units written discarding the output.
+template <typename T = char> class counting_buffer : public buffer<T> {
+ private:
+  enum { buffer_size = 256 };
+  T data_[buffer_size];
+  size_t count_ = 0;
+
+  static FMT_CONSTEXPR void grow(buffer<T>& buf, size_t) {
+    if (buf.size() != buffer_size) return;
+    static_cast<counting_buffer&>(buf).count_ += buf.size();
+    buf.clear();
+  }
+
+ public:
+  counting_buffer() : buffer<T>(grow, data_, 0, buffer_size) {}
+
+  auto count() -> size_t { return count_ + this->size(); }
+};
+}  // namespace detail
+
+template <typename Char>
+FMT_CONSTEXPR void basic_format_parse_context<Char>::do_check_arg_id(int id) {
+  // Argument id is only checked at compile-time during parsing because
+  // formatting has its own validation.
+  if (detail::is_constant_evaluated() &&
+      (!FMT_GCC_VERSION || FMT_GCC_VERSION >= 1200)) {
+    using context = detail::compile_parse_context<Char>;
+    if (id >= static_cast<context*>(this)->num_args())
+      report_error("argument not found");
+  }
+}
+
+template <typename Char>
+FMT_CONSTEXPR void basic_format_parse_context<Char>::check_dynamic_spec(
+    int arg_id) {
+  if (detail::is_constant_evaluated() &&
+      (!FMT_GCC_VERSION || FMT_GCC_VERSION >= 1200)) {
+    using context = detail::compile_parse_context<Char>;
+    static_cast<context*>(this)->check_dynamic_spec(arg_id);
+  }
+}
+
+FMT_EXPORT template <typename Context> class basic_format_arg;
+FMT_EXPORT template <typename Context> class basic_format_args;
+FMT_EXPORT template <typename Context> class dynamic_format_arg_store;
+
+// A formatter for objects of type T.
+FMT_EXPORT
+template <typename T, typename Char = char, typename Enable = void>
+struct formatter {
+  // A deleted default constructor indicates a disabled formatter.
+  formatter() = delete;
+};
+
+// Specifies if T has an enabled formatter specialization. A type can be
+// formattable even if it doesn't have a formatter e.g. via a conversion.
+template <typename T, typename Context>
+using has_formatter =
+    std::is_constructible<typename Context::template formatter_type<T>>;
+
+// An output iterator that appends to a buffer. It is used instead of
+// back_insert_iterator to reduce symbol sizes and avoid <iterator> dependency.
+template <typename T> class basic_appender {
+ private:
+  detail::buffer<T>* buffer_;
+
+  friend auto get_container(basic_appender app) -> detail::buffer<T>& {
+    return *app.buffer_;
+  }
+
+ public:
+  using iterator_category = int;
+  using value_type = T;
+  using difference_type = ptrdiff_t;
+  using pointer = T*;
+  using reference = T&;
+  using container_type = detail::buffer<T>;
+  FMT_UNCHECKED_ITERATOR(basic_appender);
+
+  FMT_CONSTEXPR basic_appender(detail::buffer<T>& buf) : buffer_(&buf) {}
+
+  auto operator=(T c) -> basic_appender& {
+    buffer_->push_back(c);
+    return *this;
+  }
+  auto operator*() -> basic_appender& { return *this; }
+  auto operator++() -> basic_appender& { return *this; }
+  auto operator++(int) -> basic_appender { return *this; }
+};
+
+using appender = basic_appender<char>;
+
+namespace detail {
+template <typename T>
+struct is_back_insert_iterator<basic_appender<T>> : std::true_type {};
+
+template <typename T, typename Enable = void>
+struct locking : std::true_type {};
+template <typename T>
+struct locking<T, void_t<typename formatter<remove_cvref_t<T>>::nonlocking>>
+    : std::false_type {};
+
+template <typename T = int> FMT_CONSTEXPR inline auto is_locking() -> bool {
+  return locking<T>::value;
+}
+template <typename T1, typename T2, typename... Tail>
+FMT_CONSTEXPR inline auto is_locking() -> bool {
+  return locking<T1>::value || is_locking<T2, Tail...>();
+}
+
+// An optimized version of std::copy with the output value type (T).
+template <typename T, typename InputIt, typename OutputIt,
+          FMT_ENABLE_IF(is_back_insert_iterator<OutputIt>::value)>
+auto copy(InputIt begin, InputIt end, OutputIt out) -> OutputIt {
+  get_container(out).append(begin, end);
+  return out;
+}
+
+template <typename T, typename InputIt, typename OutputIt,
+          FMT_ENABLE_IF(!is_back_insert_iterator<OutputIt>::value)>
+FMT_CONSTEXPR auto copy(InputIt begin, InputIt end, OutputIt out) -> OutputIt {
+  while (begin != end) *out++ = static_cast<T>(*begin++);
+  return out;
+}
+
+template <typename T, typename V, typename OutputIt>
+FMT_CONSTEXPR auto copy(basic_string_view<V> s, OutputIt out) -> OutputIt {
+  return copy<T>(s.begin(), s.end(), out);
+}
+
+template <typename Context, typename T>
+constexpr auto has_const_formatter_impl(T*)
+    -> decltype(typename Context::template formatter_type<T>().format(
+                    std::declval<const T&>(), std::declval<Context&>()),
+                true) {
+  return true;
+}
+template <typename Context>
+constexpr auto has_const_formatter_impl(...) -> bool {
+  return false;
+}
+template <typename T, typename Context>
+constexpr auto has_const_formatter() -> bool {
+  return has_const_formatter_impl<Context>(static_cast<T*>(nullptr));
+}
+
+template <typename It, typename Enable = std::true_type>
+struct is_buffer_appender : std::false_type {};
+template <typename It>
+struct is_buffer_appender<
+    It, bool_constant<
+            is_back_insert_iterator<It>::value &&
+            std::is_base_of<buffer<typename It::container_type::value_type>,
+                            typename It::container_type>::value>>
+    : std::true_type {};
+
+// Maps an output iterator to a buffer.
+template <typename T, typename OutputIt,
+          FMT_ENABLE_IF(!is_buffer_appender<OutputIt>::value)>
+auto get_buffer(OutputIt out) -> iterator_buffer<OutputIt, T> {
+  return iterator_buffer<OutputIt, T>(out);
+}
+template <typename T, typename OutputIt,
+          FMT_ENABLE_IF(is_buffer_appender<OutputIt>::value)>
+auto get_buffer(OutputIt out) -> buffer<T>& {
+  return get_container(out);
+}
+
+template <typename Buf, typename OutputIt>
+auto get_iterator(Buf& buf, OutputIt) -> decltype(buf.out()) {
+  return buf.out();
+}
+template <typename T, typename OutputIt>
+auto get_iterator(buffer<T>&, OutputIt out) -> OutputIt {
+  return out;
+}
+
+struct view {};
+
+template <typename Char, typename T> struct named_arg : view {
+  const Char* name;
+  const T& value;
+  named_arg(const Char* n, const T& v) : name(n), value(v) {}
+};
+
+template <typename Char> struct named_arg_info {
+  const Char* name;
+  int id;
+};
+
+template <typename T> struct is_named_arg : std::false_type {};
+template <typename T> struct is_statically_named_arg : std::false_type {};
+
+template <typename T, typename Char>
+struct is_named_arg<named_arg<Char, T>> : std::true_type {};
+
+template <bool B = false> constexpr auto count() -> size_t { return B ? 1 : 0; }
+template <bool B1, bool B2, bool... Tail> constexpr auto count() -> size_t {
+  return (B1 ? 1 : 0) + count<B2, Tail...>();
+}
+
+template <typename... Args> constexpr auto count_named_args() -> size_t {
+  return count<is_named_arg<Args>::value...>();
+}
+
+template <typename... Args>
+constexpr auto count_statically_named_args() -> size_t {
+  return count<is_statically_named_arg<Args>::value...>();
+}
+
+struct unformattable {};
+struct unformattable_char : unformattable {};
+struct unformattable_pointer : unformattable {};
+
+template <typename Char> struct string_value {
+  const Char* data;
+  size_t size;
+};
+
+template <typename Char> struct named_arg_value {
+  const named_arg_info<Char>* data;
+  size_t size;
+};
+
+template <typename Context> struct custom_value {
+  using parse_context = typename Context::parse_context_type;
+  void* value;
+  void (*format)(void* arg, parse_context& parse_ctx, Context& ctx);
+};
+
+// A formatting argument value.
+template <typename Context> class value {
+ public:
+  using char_type = typename Context::char_type;
+
+  union {
+    monostate no_value;
+    int int_value;
+    unsigned uint_value;
+    long long long_long_value;
+    unsigned long long ulong_long_value;
+    int128_opt int128_value;
+    uint128_opt uint128_value;
+    bool bool_value;
+    char_type char_value;
+    float float_value;
+    double double_value;
+    long double long_double_value;
+    const void* pointer;
+    string_value<char_type> string;
+    custom_value<Context> custom;
+    named_arg_value<char_type> named_args;
+  };
+
+  constexpr FMT_ALWAYS_INLINE value() : no_value() {}
+  constexpr FMT_ALWAYS_INLINE value(int val) : int_value(val) {}
+  constexpr FMT_ALWAYS_INLINE value(unsigned val) : uint_value(val) {}
+  constexpr FMT_ALWAYS_INLINE value(long long val) : long_long_value(val) {}
+  constexpr FMT_ALWAYS_INLINE value(unsigned long long val)
+      : ulong_long_value(val) {}
+  FMT_ALWAYS_INLINE value(int128_opt val) : int128_value(val) {}
+  FMT_ALWAYS_INLINE value(uint128_opt val) : uint128_value(val) {}
+  constexpr FMT_ALWAYS_INLINE value(float val) : float_value(val) {}
+  constexpr FMT_ALWAYS_INLINE value(double val) : double_value(val) {}
+  FMT_ALWAYS_INLINE value(long double val) : long_double_value(val) {}
+  constexpr FMT_ALWAYS_INLINE value(bool val) : bool_value(val) {}
+  constexpr FMT_ALWAYS_INLINE value(char_type val) : char_value(val) {}
+  FMT_CONSTEXPR FMT_ALWAYS_INLINE value(const char_type* val) {
+    string.data = val;
+    if (is_constant_evaluated()) string.size = {};
+  }
+  FMT_CONSTEXPR FMT_ALWAYS_INLINE value(basic_string_view<char_type> val) {
+    string.data = val.data();
+    string.size = val.size();
+  }
+  FMT_ALWAYS_INLINE value(const void* val) : pointer(val) {}
+  FMT_ALWAYS_INLINE value(const named_arg_info<char_type>* args, size_t size)
+      : named_args{args, size} {}
+
+  template <typename T> FMT_CONSTEXPR20 FMT_ALWAYS_INLINE value(T& val) {
+    using value_type = remove_const_t<T>;
+    // T may overload operator& e.g. std::vector<bool>::reference in libc++.
+#if defined(__cpp_if_constexpr)
+    if constexpr (std::is_same<decltype(&val), T*>::value)
+      custom.value = const_cast<value_type*>(&val);
+#endif
+    if (!is_constant_evaluated())
+      custom.value = const_cast<char*>(&reinterpret_cast<const char&>(val));
+    // Get the formatter type through the context to allow different contexts
+    // have different extension points, e.g. `formatter<T>` for `format` and
+    // `printf_formatter<T>` for `printf`.
+    custom.format = format_custom_arg<
+        value_type, typename Context::template formatter_type<value_type>>;
+  }
+  value(unformattable);
+  value(unformattable_char);
+  value(unformattable_pointer);
+
+ private:
+  // Formats an argument of a custom type, such as a user-defined class.
+  template <typename T, typename Formatter>
+  static void format_custom_arg(void* arg,
+                                typename Context::parse_context_type& parse_ctx,
+                                Context& ctx) {
+    auto f = Formatter();
+    parse_ctx.advance_to(f.parse(parse_ctx));
+    using qualified_type =
+        conditional_t<has_const_formatter<T, Context>(), const T, T>;
+    // format must be const for compatibility with std::format and compilation.
+    const auto& cf = f;
+    ctx.advance_to(cf.format(*static_cast<qualified_type*>(arg), ctx));
+  }
+};
+
+// To minimize the number of types we need to deal with, long is translated
+// either to int or to long long depending on its size.
+enum { long_short = sizeof(long) == sizeof(int) };
+using long_type = conditional_t<long_short, int, long long>;
+using ulong_type = conditional_t<long_short, unsigned, unsigned long long>;
+
+template <typename T> struct format_as_result {
+  template <typename U,
+            FMT_ENABLE_IF(std::is_enum<U>::value || std::is_class<U>::value)>
+  static auto map(U*) -> remove_cvref_t<decltype(format_as(std::declval<U>()))>;
+  static auto map(...) -> void;
+
+  using type = decltype(map(static_cast<T*>(nullptr)));
+};
+template <typename T> using format_as_t = typename format_as_result<T>::type;
+
+template <typename T>
+struct has_format_as
+    : bool_constant<!std::is_same<format_as_t<T>, void>::value> {};
+
+#define FMT_MAP_API FMT_CONSTEXPR FMT_ALWAYS_INLINE
+
+// Maps formatting arguments to core types.
+// arg_mapper reports errors by returning unformattable instead of using
+// static_assert because it's used in the is_formattable trait.
+template <typename Context> struct arg_mapper {
+  using char_type = typename Context::char_type;
+
+  FMT_MAP_API auto map(signed char val) -> int { return val; }
+  FMT_MAP_API auto map(unsigned char val) -> unsigned { return val; }
+  FMT_MAP_API auto map(short val) -> int { return val; }
+  FMT_MAP_API auto map(unsigned short val) -> unsigned { return val; }
+  FMT_MAP_API auto map(int val) -> int { return val; }
+  FMT_MAP_API auto map(unsigned val) -> unsigned { return val; }
+  FMT_MAP_API auto map(long val) -> long_type { return val; }
+  FMT_MAP_API auto map(unsigned long val) -> ulong_type { return val; }
+  FMT_MAP_API auto map(long long val) -> long long { return val; }
+  FMT_MAP_API auto map(unsigned long long val) -> unsigned long long {
+    return val;
+  }
+  FMT_MAP_API auto map(int128_opt val) -> int128_opt { return val; }
+  FMT_MAP_API auto map(uint128_opt val) -> uint128_opt { return val; }
+  FMT_MAP_API auto map(bool val) -> bool { return val; }
+
+  template <typename T, FMT_ENABLE_IF(std::is_same<T, char>::value ||
+                                      std::is_same<T, char_type>::value)>
+  FMT_MAP_API auto map(T val) -> char_type {
+    return val;
+  }
+  template <typename T, enable_if_t<(std::is_same<T, wchar_t>::value ||
+#ifdef __cpp_char8_t
+                                     std::is_same<T, char8_t>::value ||
+#endif
+                                     std::is_same<T, char16_t>::value ||
+                                     std::is_same<T, char32_t>::value) &&
+                                        !std::is_same<T, char_type>::value,
+                                    int> = 0>
+  FMT_MAP_API auto map(T) -> unformattable_char {
+    return {};
+  }
+
+  FMT_MAP_API auto map(float val) -> float { return val; }
+  FMT_MAP_API auto map(double val) -> double { return val; }
+  FMT_MAP_API auto map(long double val) -> long double { return val; }
+
+  FMT_MAP_API auto map(char_type* val) -> const char_type* { return val; }
+  FMT_MAP_API auto map(const char_type* val) -> const char_type* { return val; }
+  template <typename T, typename Char = char_t<T>,
+            FMT_ENABLE_IF(std::is_same<Char, char_type>::value &&
+                          !std::is_pointer<T>::value)>
+  FMT_MAP_API auto map(const T& val) -> basic_string_view<Char> {
+    return to_string_view(val);
+  }
+  template <typename T, typename Char = char_t<T>,
+            FMT_ENABLE_IF(!std::is_same<Char, char_type>::value &&
+                          !std::is_pointer<T>::value)>
+  FMT_MAP_API auto map(const T&) -> unformattable_char {
+    return {};
+  }
+
+  FMT_MAP_API auto map(void* val) -> const void* { return val; }
+  FMT_MAP_API auto map(const void* val) -> const void* { return val; }
+  FMT_MAP_API auto map(volatile void* val) -> const void* {
+    return const_cast<const void*>(val);
+  }
+  FMT_MAP_API auto map(const volatile void* val) -> const void* {
+    return const_cast<const void*>(val);
+  }
+  FMT_MAP_API auto map(std::nullptr_t val) -> const void* { return val; }
+
+  // Use SFINAE instead of a const T* parameter to avoid a conflict with the
+  // array overload.
+  template <
+      typename T,
+      FMT_ENABLE_IF(
+          std::is_pointer<T>::value || std::is_member_pointer<T>::value ||
+          std::is_function<typename std::remove_pointer<T>::type>::value ||
+          (std::is_array<T>::value &&
+           !std::is_convertible<T, const char_type*>::value))>
+  FMT_CONSTEXPR auto map(const T&) -> unformattable_pointer {
+    return {};
+  }
+
+  template <typename T, std::size_t N,
+            FMT_ENABLE_IF(!std::is_same<T, wchar_t>::value)>
+  FMT_MAP_API auto map(const T (&values)[N]) -> const T (&)[N] {
+    return values;
+  }
+
+  // Only map owning types because mapping views can be unsafe.
+  template <typename T, typename U = format_as_t<T>,
+            FMT_ENABLE_IF(std::is_arithmetic<U>::value)>
+  FMT_MAP_API auto map(const T& val) -> decltype(FMT_DECLTYPE_THIS map(U())) {
+    return map(format_as(val));
+  }
+
+  template <typename T, typename U = remove_const_t<T>>
+  struct formattable : bool_constant<has_const_formatter<U, Context>() ||
+                                     (has_formatter<U, Context>::value &&
+                                      !std::is_const<T>::value)> {};
+
+  template <typename T, FMT_ENABLE_IF(formattable<T>::value)>
+  FMT_MAP_API auto do_map(T& val) -> T& {
+    return val;
+  }
+  template <typename T, FMT_ENABLE_IF(!formattable<T>::value)>
+  FMT_MAP_API auto do_map(T&) -> unformattable {
+    return {};
+  }
+
+  // is_fundamental is used to allow formatters for extended FP types.
+  template <typename T, typename U = remove_const_t<T>,
+            FMT_ENABLE_IF(
+                (std::is_class<U>::value || std::is_enum<U>::value ||
+                 std::is_union<U>::value || std::is_fundamental<U>::value) &&
+                !has_to_string_view<U>::value && !is_char<U>::value &&
+                !is_named_arg<U>::value && !std::is_integral<U>::value &&
+                !std::is_arithmetic<format_as_t<U>>::value)>
+  FMT_MAP_API auto map(T& val) -> decltype(FMT_DECLTYPE_THIS do_map(val)) {
+    return do_map(val);
+  }
+
+  template <typename T, FMT_ENABLE_IF(is_named_arg<T>::value)>
+  FMT_MAP_API auto map(const T& named_arg)
+      -> decltype(FMT_DECLTYPE_THIS map(named_arg.value)) {
+    return map(named_arg.value);
+  }
+
+  auto map(...) -> unformattable { return {}; }
+};
+
+// A type constant after applying arg_mapper<Context>.
+template <typename T, typename Context>
+using mapped_type_constant =
+    type_constant<decltype(arg_mapper<Context>().map(std::declval<const T&>())),
+                  typename Context::char_type>;
+
+enum { packed_arg_bits = 4 };
+// Maximum number of arguments with packed types.
+enum { max_packed_args = 62 / packed_arg_bits };
+enum : unsigned long long { is_unpacked_bit = 1ULL << 63 };
+enum : unsigned long long { has_named_args_bit = 1ULL << 62 };
+
+template <typename It, typename T, typename Enable = void>
+struct is_output_iterator : std::false_type {};
+
+template <> struct is_output_iterator<appender, char> : std::true_type {};
+
+template <typename It, typename T>
+struct is_output_iterator<
+    It, T, void_t<decltype(*std::declval<It&>()++ = std::declval<T>())>>
+    : std::true_type {};
+
+// A type-erased reference to an std::locale to avoid a heavy <locale> include.
+class locale_ref {
+ private:
+  const void* locale_;  // A type-erased pointer to std::locale.
+
+ public:
+  constexpr locale_ref() : locale_(nullptr) {}
+  template <typename Locale> explicit locale_ref(const Locale& loc);
+
+  explicit operator bool() const noexcept { return locale_ != nullptr; }
+
+  template <typename Locale> auto get() const -> Locale;
+};
+
+template <typename> constexpr auto encode_types() -> unsigned long long {
+  return 0;
+}
+
+template <typename Context, typename Arg, typename... Args>
+constexpr auto encode_types() -> unsigned long long {
+  return static_cast<unsigned>(mapped_type_constant<Arg, Context>::value) |
+         (encode_types<Context, Args...>() << packed_arg_bits);
+}
+
+template <typename Context, typename... T, size_t NUM_ARGS = sizeof...(T)>
+constexpr unsigned long long make_descriptor() {
+  return NUM_ARGS <= max_packed_args ? encode_types<Context, T...>()
+                                     : is_unpacked_bit | NUM_ARGS;
+}
+
+// This type is intentionally undefined, only used for errors.
+template <typename T, typename Char>
+#if FMT_CLANG_VERSION && FMT_CLANG_VERSION <= 1500
+// https://github.com/fmtlib/fmt/issues/3796
+struct type_is_unformattable_for {
+};
+#else
+struct type_is_unformattable_for;
+#endif
+
+template <bool PACKED, typename Context, typename T, FMT_ENABLE_IF(PACKED)>
+FMT_CONSTEXPR auto make_arg(T& val) -> value<Context> {
+  using arg_type = remove_cvref_t<decltype(arg_mapper<Context>().map(val))>;
+
+  // Use enum instead of constexpr because the latter may generate code.
+  enum {
+    formattable_char = !std::is_same<arg_type, unformattable_char>::value
+  };
+  static_assert(formattable_char, "Mixing character types is disallowed.");
+
+  // Formatting of arbitrary pointers is disallowed. If you want to format a
+  // pointer cast it to `void*` or `const void*`. In particular, this forbids
+  // formatting of `[const] volatile char*` printed as bool by iostreams.
+  enum {
+    formattable_pointer = !std::is_same<arg_type, unformattable_pointer>::value
+  };
+  static_assert(formattable_pointer,
+                "Formatting of non-void pointers is disallowed.");
+
+  enum { formattable = !std::is_same<arg_type, unformattable>::value };
+#if defined(__cpp_if_constexpr)
+  if constexpr (!formattable)
+    type_is_unformattable_for<T, typename Context::char_type> _;
+#endif
+  static_assert(
+      formattable,
+      "Cannot format an argument. To make type T formattable provide a "
+      "formatter<T> specialization: https://fmt.dev/latest/api.html#udt");
+  return {arg_mapper<Context>().map(val)};
+}
+
+template <typename Context, typename T>
+FMT_CONSTEXPR auto make_arg(T& val) -> basic_format_arg<Context> {
+  auto arg = basic_format_arg<Context>();
+  arg.type_ = mapped_type_constant<T, Context>::value;
+  arg.value_ = make_arg<true, Context>(val);
+  return arg;
+}
+
+template <bool PACKED, typename Context, typename T, FMT_ENABLE_IF(!PACKED)>
+FMT_CONSTEXPR inline auto make_arg(T& val) -> basic_format_arg<Context> {
+  return make_arg<Context>(val);
+}
+
+template <typename Context, size_t NUM_ARGS>
+using arg_t = conditional_t<NUM_ARGS <= max_packed_args, value<Context>,
+                            basic_format_arg<Context>>;
+
+template <typename Char, typename T, FMT_ENABLE_IF(!is_named_arg<T>::value)>
+void init_named_arg(named_arg_info<Char>*, int& arg_index, int&, const T&) {
+  ++arg_index;
+}
+template <typename Char, typename T, FMT_ENABLE_IF(is_named_arg<T>::value)>
+void init_named_arg(named_arg_info<Char>* named_args, int& arg_index,
+                    int& named_arg_index, const T& arg) {
+  named_args[named_arg_index++] = {arg.name, arg_index++};
+}
+
+// An array of references to arguments. It can be implicitly converted to
+// `fmt::basic_format_args` for passing into type-erased formatting functions
+// such as `fmt::vformat`.
+template <typename Context, size_t NUM_ARGS, size_t NUM_NAMED_ARGS,
+          unsigned long long DESC>
+struct format_arg_store {
+  // args_[0].named_args points to named_args to avoid bloating format_args.
+  // +1 to workaround a bug in gcc 7.5 that causes duplicated-branches warning.
+  static constexpr size_t ARGS_ARR_SIZE = 1 + (NUM_ARGS != 0 ? NUM_ARGS : +1);
+
+  arg_t<Context, NUM_ARGS> args[ARGS_ARR_SIZE];
+  named_arg_info<typename Context::char_type> named_args[NUM_NAMED_ARGS];
+
+  template <typename... T>
+  FMT_MAP_API format_arg_store(T&... values)
+      : args{{named_args, NUM_NAMED_ARGS},
+             make_arg<NUM_ARGS <= max_packed_args, Context>(values)...} {
+    using dummy = int[];
+    int arg_index = 0, named_arg_index = 0;
+    (void)dummy{
+        0,
+        (init_named_arg(named_args, arg_index, named_arg_index, values), 0)...};
+  }
+
+  format_arg_store(format_arg_store&& rhs) {
+    args[0] = {named_args, NUM_NAMED_ARGS};
+    for (size_t i = 1; i < ARGS_ARR_SIZE; ++i) args[i] = rhs.args[i];
+    for (size_t i = 0; i < NUM_NAMED_ARGS; ++i)
+      named_args[i] = rhs.named_args[i];
+  }
+
+  format_arg_store(const format_arg_store& rhs) = delete;
+  format_arg_store& operator=(const format_arg_store& rhs) = delete;
+  format_arg_store& operator=(format_arg_store&& rhs) = delete;
+};
+
+// A specialization of format_arg_store without named arguments.
+// It is a plain struct to reduce binary size in debug mode.
+template <typename Context, size_t NUM_ARGS, unsigned long long DESC>
+struct format_arg_store<Context, NUM_ARGS, 0, DESC> {
+  // +1 to workaround a bug in gcc 7.5 that causes duplicated-branches warning.
+  arg_t<Context, NUM_ARGS> args[NUM_ARGS != 0 ? NUM_ARGS : +1];
+};
+
+}  // namespace detail
+FMT_BEGIN_EXPORT
+
+// A formatting argument. Context is a template parameter for the compiled API
+// where output can be unbuffered.
+template <typename Context> class basic_format_arg {
+ private:
+  detail::value<Context> value_;
+  detail::type type_;
+
+  template <typename ContextType, typename T>
+  friend FMT_CONSTEXPR auto detail::make_arg(T& value)
+      -> basic_format_arg<ContextType>;
+
+  friend class basic_format_args<Context>;
+  friend class dynamic_format_arg_store<Context>;
+
+  using char_type = typename Context::char_type;
+
+  template <typename, size_t, size_t, unsigned long long>
+  friend struct detail::format_arg_store;
+
+  basic_format_arg(const detail::named_arg_info<char_type>* args, size_t size)
+      : value_(args, size) {}
+
+ public:
+  class handle {
+   public:
+    explicit handle(detail::custom_value<Context> custom) : custom_(custom) {}
+
+    void format(typename Context::parse_context_type& parse_ctx,
+                Context& ctx) const {
+      custom_.format(custom_.value, parse_ctx, ctx);
+    }
+
+   private:
+    detail::custom_value<Context> custom_;
+  };
+
+  constexpr basic_format_arg() : type_(detail::type::none_type) {}
+
+  constexpr explicit operator bool() const noexcept {
+    return type_ != detail::type::none_type;
+  }
+
+  auto type() const -> detail::type { return type_; }
+
+  auto is_integral() const -> bool { return detail::is_integral_type(type_); }
+  auto is_arithmetic() const -> bool {
+    return detail::is_arithmetic_type(type_);
+  }
+
+  /**
+   * Visits an argument dispatching to the appropriate visit method based on
+   * the argument type. For example, if the argument type is `double` then
+   * `vis(value)` will be called with the value of type `double`.
+   */
+  template <typename Visitor>
+  FMT_CONSTEXPR FMT_INLINE auto visit(Visitor&& vis) const -> decltype(vis(0)) {
+    switch (type_) {
+    case detail::type::none_type:
+      break;
+    case detail::type::int_type:
+      return vis(value_.int_value);
+    case detail::type::uint_type:
+      return vis(value_.uint_value);
+    case detail::type::long_long_type:
+      return vis(value_.long_long_value);
+    case detail::type::ulong_long_type:
+      return vis(value_.ulong_long_value);
+    case detail::type::int128_type:
+      return vis(detail::convert_for_visit(value_.int128_value));
+    case detail::type::uint128_type:
+      return vis(detail::convert_for_visit(value_.uint128_value));
+    case detail::type::bool_type:
+      return vis(value_.bool_value);
+    case detail::type::char_type:
+      return vis(value_.char_value);
+    case detail::type::float_type:
+      return vis(value_.float_value);
+    case detail::type::double_type:
+      return vis(value_.double_value);
+    case detail::type::long_double_type:
+      return vis(value_.long_double_value);
+    case detail::type::cstring_type:
+      return vis(value_.string.data);
+    case detail::type::string_type:
+      using sv = basic_string_view<typename Context::char_type>;
+      return vis(sv(value_.string.data, value_.string.size));
+    case detail::type::pointer_type:
+      return vis(value_.pointer);
+    case detail::type::custom_type:
+      return vis(typename basic_format_arg<Context>::handle(value_.custom));
+    }
+    return vis(monostate());
+  }
+
+  auto format_custom(const char_type* parse_begin,
+                     typename Context::parse_context_type& parse_ctx,
+                     Context& ctx) -> bool {
+    if (type_ != detail::type::custom_type) return false;
+    parse_ctx.advance_to(parse_begin);
+    value_.custom.format(value_.custom.value, parse_ctx, ctx);
+    return true;
+  }
+};
+
+template <typename Visitor, typename Context>
+FMT_DEPRECATED FMT_CONSTEXPR auto visit_format_arg(
+    Visitor&& vis, const basic_format_arg<Context>& arg) -> decltype(vis(0)) {
+  return arg.visit(static_cast<Visitor&&>(vis));
+}
+
+/**
+ * A view of a collection of formatting arguments. To avoid lifetime issues it
+ * should only be used as a parameter type in type-erased functions such as
+ * `vformat`:
+ *
+ *     void vlog(fmt::string_view fmt, fmt::format_args args);  // OK
+ *     fmt::format_args args = fmt::make_format_args();  // Dangling reference
+ */
+template <typename Context> class basic_format_args {
+ public:
+  using size_type = int;
+  using format_arg = basic_format_arg<Context>;
+
+ private:
+  // A descriptor that contains information about formatting arguments.
+  // If the number of arguments is less or equal to max_packed_args then
+  // argument types are passed in the descriptor. This reduces binary code size
+  // per formatting function call.
+  unsigned long long desc_;
+  union {
+    // If is_packed() returns true then argument values are stored in values_;
+    // otherwise they are stored in args_. This is done to improve cache
+    // locality and reduce compiled code size since storing larger objects
+    // may require more code (at least on x86-64) even if the same amount of
+    // data is actually copied to stack. It saves ~10% on the bloat test.
+    const detail::value<Context>* values_;
+    const format_arg* args_;
+  };
+
+  constexpr auto is_packed() const -> bool {
+    return (desc_ & detail::is_unpacked_bit) == 0;
+  }
+  constexpr auto has_named_args() const -> bool {
+    return (desc_ & detail::has_named_args_bit) != 0;
+  }
+
+  FMT_CONSTEXPR auto type(int index) const -> detail::type {
+    int shift = index * detail::packed_arg_bits;
+    unsigned int mask = (1 << detail::packed_arg_bits) - 1;
+    return static_cast<detail::type>((desc_ >> shift) & mask);
+  }
+
+ public:
+  constexpr basic_format_args() : desc_(0), args_(nullptr) {}
+
+  /// Constructs a `basic_format_args` object from `format_arg_store`.
+  template <size_t NUM_ARGS, size_t NUM_NAMED_ARGS, unsigned long long DESC,
+            FMT_ENABLE_IF(NUM_ARGS <= detail::max_packed_args)>
+  constexpr FMT_ALWAYS_INLINE basic_format_args(
+      const detail::format_arg_store<Context, NUM_ARGS, NUM_NAMED_ARGS, DESC>&
+          store)
+      : desc_(DESC), values_(store.args + (NUM_NAMED_ARGS != 0 ? 1 : 0)) {}
+
+  template <size_t NUM_ARGS, size_t NUM_NAMED_ARGS, unsigned long long DESC,
+            FMT_ENABLE_IF(NUM_ARGS > detail::max_packed_args)>
+  constexpr basic_format_args(
+      const detail::format_arg_store<Context, NUM_ARGS, NUM_NAMED_ARGS, DESC>&
+          store)
+      : desc_(DESC), args_(store.args + (NUM_NAMED_ARGS != 0 ? 1 : 0)) {}
+
+  /// Constructs a `basic_format_args` object from `dynamic_format_arg_store`.
+  constexpr basic_format_args(const dynamic_format_arg_store<Context>& store)
+      : desc_(store.get_types()), args_(store.data()) {}
+
+  /// Constructs a `basic_format_args` object from a dynamic list of arguments.
+  constexpr basic_format_args(const format_arg* args, int count)
+      : desc_(detail::is_unpacked_bit | detail::to_unsigned(count)),
+        args_(args) {}
+
+  /// Returns the argument with the specified id.
+  FMT_CONSTEXPR auto get(int id) const -> format_arg {
+    format_arg arg;
+    if (!is_packed()) {
+      if (id < max_size()) arg = args_[id];
+      return arg;
+    }
+    if (static_cast<unsigned>(id) >= detail::max_packed_args) return arg;
+    arg.type_ = type(id);
+    if (arg.type_ == detail::type::none_type) return arg;
+    arg.value_ = values_[id];
+    return arg;
+  }
+
+  template <typename Char>
+  auto get(basic_string_view<Char> name) const -> format_arg {
+    int id = get_id(name);
+    return id >= 0 ? get(id) : format_arg();
+  }
+
+  template <typename Char>
+  FMT_CONSTEXPR auto get_id(basic_string_view<Char> name) const -> int {
+    if (!has_named_args()) return -1;
+    const auto& named_args =
+        (is_packed() ? values_[-1] : args_[-1].value_).named_args;
+    for (size_t i = 0; i < named_args.size; ++i) {
+      if (named_args.data[i].name == name) return named_args.data[i].id;
+    }
+    return -1;
+  }
+
+  auto max_size() const -> int {
+    unsigned long long max_packed = detail::max_packed_args;
+    return static_cast<int>(is_packed() ? max_packed
+                                        : desc_ & ~detail::is_unpacked_bit);
+  }
+};
+
+// A formatting context.
+class context {
+ private:
+  appender out_;
+  basic_format_args<context> args_;
+  detail::locale_ref loc_;
+
+ public:
+  /// The character type for the output.
+  using char_type = char;
+
+  using iterator = appender;
+  using format_arg = basic_format_arg<context>;
+  using parse_context_type = basic_format_parse_context<char>;
+  template <typename T> using formatter_type = formatter<T, char>;
+
+  /// Constructs a `basic_format_context` object. References to the arguments
+  /// are stored in the object so make sure they have appropriate lifetimes.
+  FMT_CONSTEXPR context(iterator out, basic_format_args<context> ctx_args,
+                        detail::locale_ref loc = {})
+      : out_(out), args_(ctx_args), loc_(loc) {}
+  context(context&&) = default;
+  context(const context&) = delete;
+  void operator=(const context&) = delete;
+
+  FMT_CONSTEXPR auto arg(int id) const -> format_arg { return args_.get(id); }
+  auto arg(string_view name) -> format_arg { return args_.get(name); }
+  FMT_CONSTEXPR auto arg_id(string_view name) -> int {
+    return args_.get_id(name);
+  }
+  auto args() const -> const basic_format_args<context>& { return args_; }
+
+  // Returns an iterator to the beginning of the output range.
+  FMT_CONSTEXPR auto out() -> iterator { return out_; }
+
+  // Advances the begin iterator to `it`.
+  void advance_to(iterator) {}
+
+  FMT_CONSTEXPR auto locale() -> detail::locale_ref { return loc_; }
+};
+
+template <typename OutputIt, typename Char> class generic_context;
+
+// Longer aliases for C++20 compatibility.
+template <typename OutputIt, typename Char>
+using basic_format_context =
+    conditional_t<std::is_same<OutputIt, appender>::value, context,
+                  generic_context<OutputIt, Char>>;
+using format_context = context;
+
+template <typename Char>
+using buffered_context = basic_format_context<basic_appender<Char>, Char>;
+
+template <typename T, typename Char = char>
+using is_formattable = bool_constant<!std::is_base_of<
+    detail::unformattable, decltype(detail::arg_mapper<buffered_context<Char>>()
+                                        .map(std::declval<T&>()))>::value>;
+
+#if FMT_USE_CONCEPTS
+template <typename T, typename Char = char>
+concept formattable = is_formattable<remove_reference_t<T>, Char>::value;
+#endif
+
+/**
+ * Constructs an object that stores references to arguments and can be
+ * implicitly converted to `format_args`. `Context` can be omitted in which case
+ * it defaults to `format_context`. See `arg` for lifetime considerations.
+ */
+// Take arguments by lvalue references to avoid some lifetime issues, e.g.
+//   auto args = make_format_args(std::string());
+template <typename Context = format_context, typename... T,
+          size_t NUM_ARGS = sizeof...(T),
+          size_t NUM_NAMED_ARGS = detail::count_named_args<T...>(),
+          unsigned long long DESC = detail::make_descriptor<Context, T...>(),
+          FMT_ENABLE_IF(NUM_NAMED_ARGS == 0)>
+constexpr FMT_ALWAYS_INLINE auto make_format_args(T&... args)
+    -> detail::format_arg_store<Context, NUM_ARGS, 0, DESC> {
+  return {{detail::make_arg<NUM_ARGS <= detail::max_packed_args, Context>(
+      args)...}};
+}
+
+#ifndef FMT_DOC
+template <typename Context = format_context, typename... T,
+          size_t NUM_NAMED_ARGS = detail::count_named_args<T...>(),
+          unsigned long long DESC =
+              detail::make_descriptor<Context, T...>() |
+              static_cast<unsigned long long>(detail::has_named_args_bit),
+          FMT_ENABLE_IF(NUM_NAMED_ARGS != 0)>
+constexpr auto make_format_args(T&... args)
+    -> detail::format_arg_store<Context, sizeof...(T), NUM_NAMED_ARGS, DESC> {
+  return {args...};
+}
+#endif
+
+/**
+ * Returns a named argument to be used in a formatting function.
+ * It should only be used in a call to a formatting function or
+ * `dynamic_format_arg_store::push_back`.
+ *
+ * **Example**:
+ *
+ *     fmt::print("The answer is {answer}.", fmt::arg("answer", 42));
+ */
+template <typename Char, typename T>
+inline auto arg(const Char* name, const T& arg) -> detail::named_arg<Char, T> {
+  static_assert(!detail::is_named_arg<T>(), "nested named arguments");
+  return {name, arg};
+}
+FMT_END_EXPORT
+
+/// An alias for `basic_format_args<format_context>`.
+// A separate type would result in shorter symbols but break ABI compatibility
+// between clang and gcc on ARM (#1919).
+FMT_EXPORT using format_args = basic_format_args<format_context>;
+
+// We cannot use enum classes as bit fields because of a gcc bug, so we put them
+// in namespaces instead (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61414).
+// Additionally, if an underlying type is specified, older gcc incorrectly warns
+// that the type is too small. Both bugs are fixed in gcc 9.3.
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 903
+#  define FMT_ENUM_UNDERLYING_TYPE(type)
+#else
+#  define FMT_ENUM_UNDERLYING_TYPE(type) : type
+#endif
+namespace align {
+enum type FMT_ENUM_UNDERLYING_TYPE(unsigned char){none, left, right, center,
+                                                  numeric};
+}
+using align_t = align::type;
+namespace sign {
+enum type FMT_ENUM_UNDERLYING_TYPE(unsigned char){none, minus, plus, space};
+}
+using sign_t = sign::type;
+
+namespace detail {
+
+template <typename Char>
+using unsigned_char = typename conditional_t<std::is_integral<Char>::value,
+                                             std::make_unsigned<Char>,
+                                             type_identity<unsigned>>::type;
+
+// Character (code unit) type is erased to prevent template bloat.
+struct fill_t {
+ private:
+  enum { max_size = 4 };
+  char data_[max_size] = {' '};
+  unsigned char size_ = 1;
+
+ public:
+  template <typename Char>
+  FMT_CONSTEXPR void operator=(basic_string_view<Char> s) {
+    auto size = s.size();
+    size_ = static_cast<unsigned char>(size);
+    if (size == 1) {
+      unsigned uchar = static_cast<unsigned_char<Char>>(s[0]);
+      data_[0] = static_cast<char>(uchar);
+      data_[1] = static_cast<char>(uchar >> 8);
+      return;
+    }
+    FMT_ASSERT(size <= max_size, "invalid fill");
+    for (size_t i = 0; i < size; ++i) data_[i] = static_cast<char>(s[i]);
+  }
+
+  FMT_CONSTEXPR void operator=(char c) {
+    data_[0] = c;
+    size_ = 1;
+  }
+
+  constexpr auto size() const -> size_t { return size_; }
+
+  template <typename Char> constexpr auto get() const -> Char {
+    using uchar = unsigned char;
+    return static_cast<Char>(static_cast<uchar>(data_[0]) |
+                             (static_cast<uchar>(data_[1]) << 8));
+  }
+
+  template <typename Char, FMT_ENABLE_IF(std::is_same<Char, char>::value)>
+  constexpr auto data() const -> const Char* {
+    return data_;
+  }
+  template <typename Char, FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
+  constexpr auto data() const -> const Char* {
+    return nullptr;
+  }
+};
+}  // namespace detail
+
+enum class presentation_type : unsigned char {
+  // Common specifiers:
+  none = 0,
+  debug = 1,   // '?'
+  string = 2,  // 's' (string, bool)
+
+  // Integral, bool and character specifiers:
+  dec = 3,  // 'd'
+  hex,      // 'x' or 'X'
+  oct,      // 'o'
+  bin,      // 'b' or 'B'
+  chr,      // 'c'
+
+  // String and pointer specifiers:
+  pointer = 3,  // 'p'
+
+  // Floating-point specifiers:
+  exp = 1,  // 'e' or 'E' (1 since there is no FP debug presentation)
+  fixed,    // 'f' or 'F'
+  general,  // 'g' or 'G'
+  hexfloat  // 'a' or 'A'
+};
+
+// Format specifiers for built-in and string types.
+struct format_specs {
+  int width;
+  int precision;
+  presentation_type type;
+  align_t align : 4;
+  sign_t sign : 3;
+  bool upper : 1;  // An uppercase version e.g. 'X' for 'x'.
+  bool alt : 1;    // Alternate form ('#').
+  bool localized : 1;
+  detail::fill_t fill;
+
+  constexpr format_specs()
+      : width(0),
+        precision(-1),
+        type(presentation_type::none),
+        align(align::none),
+        sign(sign::none),
+        upper(false),
+        alt(false),
+        localized(false) {}
+};
+
+namespace detail {
+
+enum class arg_id_kind { none, index, name };
+
+// An argument reference.
+template <typename Char> struct arg_ref {
+  FMT_CONSTEXPR arg_ref() : kind(arg_id_kind::none), val() {}
+
+  FMT_CONSTEXPR explicit arg_ref(int index)
+      : kind(arg_id_kind::index), val(index) {}
+  FMT_CONSTEXPR explicit arg_ref(basic_string_view<Char> name)
+      : kind(arg_id_kind::name), val(name) {}
+
+  FMT_CONSTEXPR auto operator=(int idx) -> arg_ref& {
+    kind = arg_id_kind::index;
+    val.index = idx;
+    return *this;
+  }
+
+  arg_id_kind kind;
+  union value {
+    FMT_CONSTEXPR value(int idx = 0) : index(idx) {}
+    FMT_CONSTEXPR value(basic_string_view<Char> n) : name(n) {}
+
+    int index;
+    basic_string_view<Char> name;
+  } val;
+};
+
+// Format specifiers with width and precision resolved at formatting rather
+// than parsing time to allow reusing the same parsed specifiers with
+// different sets of arguments (precompilation of format strings).
+template <typename Char = char> struct dynamic_format_specs : format_specs {
+  arg_ref<Char> width_ref;
+  arg_ref<Char> precision_ref;
+};
+
+// Converts a character to ASCII. Returns '\0' on conversion failure.
+template <typename Char, FMT_ENABLE_IF(std::is_integral<Char>::value)>
+constexpr auto to_ascii(Char c) -> char {
+  return c <= 0xff ? static_cast<char>(c) : '\0';
+}
+
+// Returns the number of code units in a code point or 1 on error.
+template <typename Char>
+FMT_CONSTEXPR auto code_point_length(const Char* begin) -> int {
+  if (const_check(sizeof(Char) != 1)) return 1;
+  auto c = static_cast<unsigned char>(*begin);
+  return static_cast<int>((0x3a55000000000000ull >> (2 * (c >> 3))) & 0x3) + 1;
+}
+
+// Return the result via the out param to workaround gcc bug 77539.
+template <bool IS_CONSTEXPR, typename T, typename Ptr = const T*>
+FMT_CONSTEXPR auto find(Ptr first, Ptr last, T value, Ptr& out) -> bool {
+  for (out = first; out != last; ++out) {
+    if (*out == value) return true;
+  }
+  return false;
+}
+
+template <>
+inline auto find<false, char>(const char* first, const char* last, char value,
+                              const char*& out) -> bool {
+  out =
+      static_cast<const char*>(memchr(first, value, to_unsigned(last - first)));
+  return out != nullptr;
+}
+
+// Parses the range [begin, end) as an unsigned integer. This function assumes
+// that the range is non-empty and the first character is a digit.
+template <typename Char>
+FMT_CONSTEXPR auto parse_nonnegative_int(const Char*& begin, const Char* end,
+                                         int error_value) noexcept -> int {
+  FMT_ASSERT(begin != end && '0' <= *begin && *begin <= '9', "");
+  unsigned value = 0, prev = 0;
+  auto p = begin;
+  do {
+    prev = value;
+    value = value * 10 + unsigned(*p - '0');
+    ++p;
+  } while (p != end && '0' <= *p && *p <= '9');
+  auto num_digits = p - begin;
+  begin = p;
+  int digits10 = static_cast<int>(sizeof(int) * CHAR_BIT * 3 / 10);
+  if (num_digits <= digits10) return static_cast<int>(value);
+  // Check for overflow.
+  unsigned max = INT_MAX;
+  return num_digits == digits10 + 1 &&
+                 prev * 10ull + unsigned(p[-1] - '0') <= max
+             ? static_cast<int>(value)
+             : error_value;
+}
+
+FMT_CONSTEXPR inline auto parse_align(char c) -> align_t {
+  switch (c) {
+  case '<':
+    return align::left;
+  case '>':
+    return align::right;
+  case '^':
+    return align::center;
+  }
+  return align::none;
+}
+
+template <typename Char> constexpr auto is_name_start(Char c) -> bool {
+  return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '_';
+}
+
+template <typename Char, typename Handler>
+FMT_CONSTEXPR auto do_parse_arg_id(const Char* begin, const Char* end,
+                                   Handler&& handler) -> const Char* {
+  Char c = *begin;
+  if (c >= '0' && c <= '9') {
+    int index = 0;
+    if (c != '0')
+      index = parse_nonnegative_int(begin, end, INT_MAX);
+    else
+      ++begin;
+    if (begin == end || (*begin != '}' && *begin != ':'))
+      report_error("invalid format string");
+    else
+      handler.on_index(index);
+    return begin;
+  }
+  if (!is_name_start(c)) {
+    report_error("invalid format string");
+    return begin;
+  }
+  auto it = begin;
+  do {
+    ++it;
+  } while (it != end && (is_name_start(*it) || ('0' <= *it && *it <= '9')));
+  handler.on_name({begin, to_unsigned(it - begin)});
+  return it;
+}
+
+template <typename Char, typename Handler>
+FMT_CONSTEXPR auto parse_arg_id(const Char* begin, const Char* end,
+                                Handler&& handler) -> const Char* {
+  FMT_ASSERT(begin != end, "");
+  Char c = *begin;
+  if (c != '}' && c != ':') return do_parse_arg_id(begin, end, handler);
+  handler.on_auto();
+  return begin;
+}
+
+template <typename Char> struct dynamic_spec_id_handler {
+  basic_format_parse_context<Char>& ctx;
+  arg_ref<Char>& ref;
+
+  FMT_CONSTEXPR void on_auto() {
+    int id = ctx.next_arg_id();
+    ref = arg_ref<Char>(id);
+    ctx.check_dynamic_spec(id);
+  }
+  FMT_CONSTEXPR void on_index(int id) {
+    ref = arg_ref<Char>(id);
+    ctx.check_arg_id(id);
+    ctx.check_dynamic_spec(id);
+  }
+  FMT_CONSTEXPR void on_name(basic_string_view<Char> id) {
+    ref = arg_ref<Char>(id);
+    ctx.check_arg_id(id);
+  }
+};
+
+// Parses [integer | "{" [arg_id] "}"].
+template <typename Char>
+FMT_CONSTEXPR auto parse_dynamic_spec(const Char* begin, const Char* end,
+                                      int& value, arg_ref<Char>& ref,
+                                      basic_format_parse_context<Char>& ctx)
+    -> const Char* {
+  FMT_ASSERT(begin != end, "");
+  if ('0' <= *begin && *begin <= '9') {
+    int val = parse_nonnegative_int(begin, end, -1);
+    if (val != -1)
+      value = val;
+    else
+      report_error("number is too big");
+  } else if (*begin == '{') {
+    ++begin;
+    auto handler = dynamic_spec_id_handler<Char>{ctx, ref};
+    if (begin != end) begin = parse_arg_id(begin, end, handler);
+    if (begin != end && *begin == '}') return ++begin;
+    report_error("invalid format string");
+  }
+  return begin;
+}
+
+template <typename Char>
+FMT_CONSTEXPR auto parse_precision(const Char* begin, const Char* end,
+                                   int& value, arg_ref<Char>& ref,
+                                   basic_format_parse_context<Char>& ctx)
+    -> const Char* {
+  ++begin;
+  if (begin == end || *begin == '}') {
+    report_error("invalid precision");
+    return begin;
+  }
+  return parse_dynamic_spec(begin, end, value, ref, ctx);
+}
+
+enum class state { start, align, sign, hash, zero, width, precision, locale };
+
+// Parses standard format specifiers.
+template <typename Char>
+FMT_CONSTEXPR auto parse_format_specs(const Char* begin, const Char* end,
+                                      dynamic_format_specs<Char>& specs,
+                                      basic_format_parse_context<Char>& ctx,
+                                      type arg_type) -> const Char* {
+  auto c = '\0';
+  if (end - begin > 1) {
+    auto next = to_ascii(begin[1]);
+    c = parse_align(next) == align::none ? to_ascii(*begin) : '\0';
+  } else {
+    if (begin == end) return begin;
+    c = to_ascii(*begin);
+  }
+
+  struct {
+    state current_state = state::start;
+    FMT_CONSTEXPR void operator()(state s, bool valid = true) {
+      if (current_state >= s || !valid)
+        report_error("invalid format specifier");
+      current_state = s;
+    }
+  } enter_state;
+
+  using pres = presentation_type;
+  constexpr auto integral_set = sint_set | uint_set | bool_set | char_set;
+  struct {
+    const Char*& begin;
+    dynamic_format_specs<Char>& specs;
+    type arg_type;
+
+    FMT_CONSTEXPR auto operator()(pres pres_type, int set) -> const Char* {
+      if (!in(arg_type, set)) {
+        if (arg_type == type::none_type) return begin;
+        report_error("invalid format specifier");
+      }
+      specs.type = pres_type;
+      return begin + 1;
+    }
+  } parse_presentation_type{begin, specs, arg_type};
+
+  for (;;) {
+    switch (c) {
+    case '<':
+    case '>':
+    case '^':
+      enter_state(state::align);
+      specs.align = parse_align(c);
+      ++begin;
+      break;
+    case '+':
+    case '-':
+    case ' ':
+      if (arg_type == type::none_type) return begin;
+      enter_state(state::sign, in(arg_type, sint_set | float_set));
+      switch (c) {
+      case '+':
+        specs.sign = sign::plus;
+        break;
+      case '-':
+        specs.sign = sign::minus;
+        break;
+      case ' ':
+        specs.sign = sign::space;
+        break;
+      }
+      ++begin;
+      break;
+    case '#':
+      if (arg_type == type::none_type) return begin;
+      enter_state(state::hash, is_arithmetic_type(arg_type));
+      specs.alt = true;
+      ++begin;
+      break;
+    case '0':
+      enter_state(state::zero);
+      if (!is_arithmetic_type(arg_type)) {
+        if (arg_type == type::none_type) return begin;
+        report_error("format specifier requires numeric argument");
+      }
+      if (specs.align == align::none) {
+        // Ignore 0 if align is specified for compatibility with std::format.
+        specs.align = align::numeric;
+        specs.fill = '0';
+      }
+      ++begin;
+      break;
+    case '1':
+    case '2':
+    case '3':
+    case '4':
+    case '5':
+    case '6':
+    case '7':
+    case '8':
+    case '9':
+    case '{':
+      enter_state(state::width);
+      begin = parse_dynamic_spec(begin, end, specs.width, specs.width_ref, ctx);
+      break;
+    case '.':
+      if (arg_type == type::none_type) return begin;
+      enter_state(state::precision,
+                  in(arg_type, float_set | string_set | cstring_set));
+      begin = parse_precision(begin, end, specs.precision, specs.precision_ref,
+                              ctx);
+      break;
+    case 'L':
+      if (arg_type == type::none_type) return begin;
+      enter_state(state::locale, is_arithmetic_type(arg_type));
+      specs.localized = true;
+      ++begin;
+      break;
+    case 'd':
+      return parse_presentation_type(pres::dec, integral_set);
+    case 'X':
+      specs.upper = true;
+      FMT_FALLTHROUGH;
+    case 'x':
+      return parse_presentation_type(pres::hex, integral_set);
+    case 'o':
+      return parse_presentation_type(pres::oct, integral_set);
+    case 'B':
+      specs.upper = true;
+      FMT_FALLTHROUGH;
+    case 'b':
+      return parse_presentation_type(pres::bin, integral_set);
+    case 'E':
+      specs.upper = true;
+      FMT_FALLTHROUGH;
+    case 'e':
+      return parse_presentation_type(pres::exp, float_set);
+    case 'F':
+      specs.upper = true;
+      FMT_FALLTHROUGH;
+    case 'f':
+      return parse_presentation_type(pres::fixed, float_set);
+    case 'G':
+      specs.upper = true;
+      FMT_FALLTHROUGH;
+    case 'g':
+      return parse_presentation_type(pres::general, float_set);
+    case 'A':
+      specs.upper = true;
+      FMT_FALLTHROUGH;
+    case 'a':
+      return parse_presentation_type(pres::hexfloat, float_set);
+    case 'c':
+      if (arg_type == type::bool_type) report_error("invalid format specifier");
+      return parse_presentation_type(pres::chr, integral_set);
+    case 's':
+      return parse_presentation_type(pres::string,
+                                     bool_set | string_set | cstring_set);
+    case 'p':
+      return parse_presentation_type(pres::pointer, pointer_set | cstring_set);
+    case '?':
+      return parse_presentation_type(pres::debug,
+                                     char_set | string_set | cstring_set);
+    case '}':
+      return begin;
+    default: {
+      if (*begin == '}') return begin;
+      // Parse fill and alignment.
+      auto fill_end = begin + code_point_length(begin);
+      if (end - fill_end <= 0) {
+        report_error("invalid format specifier");
+        return begin;
+      }
+      if (*begin == '{') {
+        report_error("invalid fill character '{'");
+        return begin;
+      }
+      auto align = parse_align(to_ascii(*fill_end));
+      enter_state(state::align, align != align::none);
+      specs.fill =
+          basic_string_view<Char>(begin, to_unsigned(fill_end - begin));
+      specs.align = align;
+      begin = fill_end + 1;
+    }
+    }
+    if (begin == end) return begin;
+    c = to_ascii(*begin);
+  }
+}
+
+template <typename Char, typename Handler>
+FMT_CONSTEXPR auto parse_replacement_field(const Char* begin, const Char* end,
+                                           Handler&& handler) -> const Char* {
+  struct id_adapter {
+    Handler& handler;
+    int arg_id;
+
+    FMT_CONSTEXPR void on_auto() { arg_id = handler.on_arg_id(); }
+    FMT_CONSTEXPR void on_index(int id) { arg_id = handler.on_arg_id(id); }
+    FMT_CONSTEXPR void on_name(basic_string_view<Char> id) {
+      arg_id = handler.on_arg_id(id);
+    }
+  };
+
+  ++begin;
+  if (begin == end) return handler.on_error("invalid format string"), end;
+  if (*begin == '}') {
+    handler.on_replacement_field(handler.on_arg_id(), begin);
+  } else if (*begin == '{') {
+    handler.on_text(begin, begin + 1);
+  } else {
+    auto adapter = id_adapter{handler, 0};
+    begin = parse_arg_id(begin, end, adapter);
+    Char c = begin != end ? *begin : Char();
+    if (c == '}') {
+      handler.on_replacement_field(adapter.arg_id, begin);
+    } else if (c == ':') {
+      begin = handler.on_format_specs(adapter.arg_id, begin + 1, end);
+      if (begin == end || *begin != '}')
+        return handler.on_error("unknown format specifier"), end;
+    } else {
+      return handler.on_error("missing '}' in format string"), end;
+    }
+  }
+  return begin + 1;
+}
+
+template <bool IS_CONSTEXPR, typename Char, typename Handler>
+FMT_CONSTEXPR void parse_format_string(basic_string_view<Char> format_str,
+                                       Handler&& handler) {
+  auto begin = format_str.data();
+  auto end = begin + format_str.size();
+  if (end - begin < 32) {
+    // Use a simple loop instead of memchr for small strings.
+    const Char* p = begin;
+    while (p != end) {
+      auto c = *p++;
+      if (c == '{') {
+        handler.on_text(begin, p - 1);
+        begin = p = parse_replacement_field(p - 1, end, handler);
+      } else if (c == '}') {
+        if (p == end || *p != '}')
+          return handler.on_error("unmatched '}' in format string");
+        handler.on_text(begin, p);
+        begin = ++p;
+      }
+    }
+    handler.on_text(begin, end);
+    return;
+  }
+  struct writer {
+    FMT_CONSTEXPR void operator()(const Char* from, const Char* to) {
+      if (from == to) return;
+      for (;;) {
+        const Char* p = nullptr;
+        if (!find<IS_CONSTEXPR>(from, to, Char('}'), p))
+          return handler_.on_text(from, to);
+        ++p;
+        if (p == to || *p != '}')
+          return handler_.on_error("unmatched '}' in format string");
+        handler_.on_text(from, p);
+        from = p + 1;
+      }
+    }
+    Handler& handler_;
+  } write = {handler};
+  while (begin != end) {
+    // Doing two passes with memchr (one for '{' and another for '}') is up to
+    // 2.5x faster than the naive one-pass implementation on big format strings.
+    const Char* p = begin;
+    if (*begin != '{' && !find<IS_CONSTEXPR>(begin + 1, end, Char('{'), p))
+      return write(begin, end);
+    write(begin, p);
+    begin = parse_replacement_field(p, end, handler);
+  }
+}
+
+template <typename T, bool = is_named_arg<T>::value> struct strip_named_arg {
+  using type = T;
+};
+template <typename T> struct strip_named_arg<T, true> {
+  using type = remove_cvref_t<decltype(T::value)>;
+};
+
+template <typename T, typename ParseContext>
+FMT_VISIBILITY("hidden")  // Suppress an ld warning on macOS (#3769).
+FMT_CONSTEXPR auto parse_format_specs(ParseContext& ctx)
+    -> decltype(ctx.begin()) {
+  using char_type = typename ParseContext::char_type;
+  using context = buffered_context<char_type>;
+  using mapped_type = conditional_t<
+      mapped_type_constant<T, context>::value != type::custom_type,
+      decltype(arg_mapper<context>().map(std::declval<const T&>())),
+      typename strip_named_arg<T>::type>;
+#if defined(__cpp_if_constexpr)
+  if constexpr (std::is_default_constructible<
+                    formatter<mapped_type, char_type>>::value) {
+    return formatter<mapped_type, char_type>().parse(ctx);
+  } else {
+    type_is_unformattable_for<T, char_type> _;
+    return ctx.begin();
+  }
+#else
+  return formatter<mapped_type, char_type>().parse(ctx);
+#endif
+}
+
+// Checks char specs and returns true iff the presentation type is char-like.
+FMT_CONSTEXPR inline auto check_char_specs(const format_specs& specs) -> bool {
+  if (specs.type != presentation_type::none &&
+      specs.type != presentation_type::chr &&
+      specs.type != presentation_type::debug) {
+    return false;
+  }
+  if (specs.align == align::numeric || specs.sign != sign::none || specs.alt)
+    report_error("invalid format specifier for char");
+  return true;
+}
+
+#if FMT_USE_NONTYPE_TEMPLATE_ARGS
+template <int N, typename T, typename... Args, typename Char>
+constexpr auto get_arg_index_by_name(basic_string_view<Char> name) -> int {
+  if constexpr (is_statically_named_arg<T>()) {
+    if (name == T::name) return N;
+  }
+  if constexpr (sizeof...(Args) > 0)
+    return get_arg_index_by_name<N + 1, Args...>(name);
+  (void)name;  // Workaround an MSVC bug about "unused" parameter.
+  return -1;
+}
+#endif
+
+template <typename... Args, typename Char>
+FMT_CONSTEXPR auto get_arg_index_by_name(basic_string_view<Char> name) -> int {
+#if FMT_USE_NONTYPE_TEMPLATE_ARGS
+  if constexpr (sizeof...(Args) > 0)
+    return get_arg_index_by_name<0, Args...>(name);
+#endif
+  (void)name;
+  return -1;
+}
+
+template <typename Char, typename... Args> class format_string_checker {
+ private:
+  using parse_context_type = compile_parse_context<Char>;
+  static constexpr int num_args = sizeof...(Args);
+
+  // Format specifier parsing function.
+  // In the future basic_format_parse_context will replace compile_parse_context
+  // here and will use is_constant_evaluated and downcasting to access the data
+  // needed for compile-time checks: https://godbolt.org/z/GvWzcTjh1.
+  using parse_func = const Char* (*)(parse_context_type&);
+
+  type types_[num_args > 0 ? static_cast<size_t>(num_args) : 1];
+  parse_context_type context_;
+  parse_func parse_funcs_[num_args > 0 ? static_cast<size_t>(num_args) : 1];
+
+ public:
+  explicit FMT_CONSTEXPR format_string_checker(basic_string_view<Char> fmt)
+      : types_{mapped_type_constant<Args, buffered_context<Char>>::value...},
+        context_(fmt, num_args, types_),
+        parse_funcs_{&parse_format_specs<Args, parse_context_type>...} {}
+
+  FMT_CONSTEXPR void on_text(const Char*, const Char*) {}
+
+  FMT_CONSTEXPR auto on_arg_id() -> int { return context_.next_arg_id(); }
+  FMT_CONSTEXPR auto on_arg_id(int id) -> int {
+    return context_.check_arg_id(id), id;
+  }
+  FMT_CONSTEXPR auto on_arg_id(basic_string_view<Char> id) -> int {
+#if FMT_USE_NONTYPE_TEMPLATE_ARGS
+    auto index = get_arg_index_by_name<Args...>(id);
+    if (index < 0) on_error("named argument is not found");
+    return index;
+#else
+    (void)id;
+    on_error("compile-time checks for named arguments require C++20 support");
+    return 0;
+#endif
+  }
+
+  FMT_CONSTEXPR void on_replacement_field(int id, const Char* begin) {
+    on_format_specs(id, begin, begin);  // Call parse() on empty specs.
+  }
+
+  FMT_CONSTEXPR auto on_format_specs(int id, const Char* begin, const Char*)
+      -> const Char* {
+    context_.advance_to(begin);
+    // id >= 0 check is a workaround for gcc 10 bug (#2065).
+    return id >= 0 && id < num_args ? parse_funcs_[id](context_) : begin;
+  }
+
+  FMT_NORETURN FMT_CONSTEXPR void on_error(const char* message) {
+    report_error(message);
+  }
+};
+
+// A base class for compile-time strings.
+struct compile_string {};
+
+template <typename S>
+using is_compile_string = std::is_base_of<compile_string, S>;
+
+// Reports a compile-time error if S is not a valid format string.
+template <typename..., typename S, FMT_ENABLE_IF(!is_compile_string<S>::value)>
+FMT_ALWAYS_INLINE void check_format_string(const S&) {
+#ifdef FMT_ENFORCE_COMPILE_STRING
+  static_assert(is_compile_string<S>::value,
+                "FMT_ENFORCE_COMPILE_STRING requires all format strings to use "
+                "FMT_STRING.");
+#endif
+}
+template <typename... Args, typename S,
+          FMT_ENABLE_IF(is_compile_string<S>::value)>
+void check_format_string(S format_str) {
+  using char_t = typename S::char_type;
+  FMT_CONSTEXPR auto s = basic_string_view<char_t>(format_str);
+  using checker = format_string_checker<char_t, remove_cvref_t<Args>...>;
+  FMT_CONSTEXPR bool error = (parse_format_string<true>(s, checker(s)), true);
+  ignore_unused(error);
+}
+
+// Report truncation to prevent silent data loss.
+inline void report_truncation(bool truncated) {
+  if (truncated) report_error("output is truncated");
+}
+
+// Use vformat_args and avoid type_identity to keep symbols short and workaround
+// a GCC <= 4.8 bug.
+template <typename Char = char> struct vformat_args {
+  using type = basic_format_args<buffered_context<Char>>;
+};
+template <> struct vformat_args<char> {
+  using type = format_args;
+};
+
+template <typename Char>
+void vformat_to(buffer<Char>& buf, basic_string_view<Char> fmt,
+                typename vformat_args<Char>::type args, locale_ref loc = {});
+
+FMT_API void vprint_mojibake(FILE*, string_view, format_args, bool = false);
+#ifndef _WIN32
+inline void vprint_mojibake(FILE*, string_view, format_args, bool) {}
+#endif
+
+template <typename T, typename Char, type TYPE> struct native_formatter {
+ private:
+  dynamic_format_specs<Char> specs_;
+
+ public:
+  using nonlocking = void;
+
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> const Char* {
+    if (ctx.begin() == ctx.end() || *ctx.begin() == '}') return ctx.begin();
+    auto end = parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx, TYPE);
+    if (const_check(TYPE == type::char_type)) check_char_specs(specs_);
+    return end;
+  }
+
+  template <type U = TYPE,
+            FMT_ENABLE_IF(U == type::string_type || U == type::cstring_type ||
+                          U == type::char_type)>
+  FMT_CONSTEXPR void set_debug_format(bool set = true) {
+    specs_.type = set ? presentation_type::debug : presentation_type::none;
+  }
+
+  template <typename FormatContext>
+  FMT_CONSTEXPR auto format(const T& val, FormatContext& ctx) const
+      -> decltype(ctx.out());
+};
+}  // namespace detail
+
+FMT_BEGIN_EXPORT
+
+// A formatter specialization for natively supported types.
+template <typename T, typename Char>
+struct formatter<T, Char,
+                 enable_if_t<detail::type_constant<T, Char>::value !=
+                             detail::type::custom_type>>
+    : detail::native_formatter<T, Char, detail::type_constant<T, Char>::value> {
+};
+
+template <typename Char = char> struct runtime_format_string {
+  basic_string_view<Char> str;
+};
+
+/// A compile-time format string.
+template <typename Char, typename... Args> class basic_format_string {
+ private:
+  basic_string_view<Char> str_;
+
+ public:
+  template <
+      typename S,
+      FMT_ENABLE_IF(
+          std::is_convertible<const S&, basic_string_view<Char>>::value ||
+          (detail::is_compile_string<S>::value &&
+           std::is_constructible<basic_string_view<Char>, const S&>::value))>
+  FMT_CONSTEVAL FMT_ALWAYS_INLINE basic_format_string(const S& s) : str_(s) {
+    static_assert(
+        detail::count<
+            (std::is_base_of<detail::view, remove_reference_t<Args>>::value &&
+             std::is_reference<Args>::value)...>() == 0,
+        "passing views as lvalues is disallowed");
+#if FMT_USE_CONSTEVAL
+    if constexpr (detail::count_named_args<Args...>() ==
+                  detail::count_statically_named_args<Args...>()) {
+      using checker =
+          detail::format_string_checker<Char, remove_cvref_t<Args>...>;
+      detail::parse_format_string<true>(str_, checker(s));
+    }
+#else
+    detail::check_format_string<Args...>(s);
+#endif
+  }
+  basic_format_string(runtime_format_string<Char> fmt) : str_(fmt.str) {}
+
+  FMT_ALWAYS_INLINE operator basic_string_view<Char>() const { return str_; }
+  auto get() const -> basic_string_view<Char> { return str_; }
+};
+
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
+// Workaround broken conversion on older gcc.
+template <typename...> using format_string = string_view;
+inline auto runtime(string_view s) -> string_view { return s; }
+#else
+template <typename... Args>
+using format_string = basic_format_string<char, type_identity_t<Args>...>;
+/**
+ * Creates a runtime format string.
+ *
+ * **Example**:
+ *
+ *     // Check format string at runtime instead of compile-time.
+ *     fmt::print(fmt::runtime("{:d}"), "I am not a number");
+ */
+inline auto runtime(string_view s) -> runtime_format_string<> { return {{s}}; }
+#endif
+
+/// Formats a string and writes the output to `out`.
+template <typename OutputIt,
+          FMT_ENABLE_IF(detail::is_output_iterator<remove_cvref_t<OutputIt>,
+                                                   char>::value)>
+auto vformat_to(OutputIt&& out, string_view fmt, format_args args)
+    -> remove_cvref_t<OutputIt> {
+  auto&& buf = detail::get_buffer<char>(out);
+  detail::vformat_to(buf, fmt, args, {});
+  return detail::get_iterator(buf, out);
+}
+
+/**
+ * Formats `args` according to specifications in `fmt`, writes the result to
+ * the output iterator `out` and returns the iterator past the end of the output
+ * range. `format_to` does not append a terminating null character.
+ *
+ * **Example**:
+ *
+ *     auto out = std::vector<char>();
+ *     fmt::format_to(std::back_inserter(out), "{}", 42);
+ */
+template <typename OutputIt, typename... T,
+          FMT_ENABLE_IF(detail::is_output_iterator<remove_cvref_t<OutputIt>,
+                                                   char>::value)>
+FMT_INLINE auto format_to(OutputIt&& out, format_string<T...> fmt, T&&... args)
+    -> remove_cvref_t<OutputIt> {
+  return vformat_to(FMT_FWD(out), fmt, fmt::make_format_args(args...));
+}
+
+template <typename OutputIt> struct format_to_n_result {
+  /// Iterator past the end of the output range.
+  OutputIt out;
+  /// Total (not truncated) output size.
+  size_t size;
+};
+
+template <typename OutputIt, typename... T,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
+auto vformat_to_n(OutputIt out, size_t n, string_view fmt, format_args args)
+    -> format_to_n_result<OutputIt> {
+  using traits = detail::fixed_buffer_traits;
+  auto buf = detail::iterator_buffer<OutputIt, char, traits>(out, n);
+  detail::vformat_to(buf, fmt, args, {});
+  return {buf.out(), buf.count()};
+}
+
+/**
+ * Formats `args` according to specifications in `fmt`, writes up to `n`
+ * characters of the result to the output iterator `out` and returns the total
+ * (not truncated) output size and the iterator past the end of the output
+ * range. `format_to_n` does not append a terminating null character.
+ */
+template <typename OutputIt, typename... T,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
+FMT_INLINE auto format_to_n(OutputIt out, size_t n, format_string<T...> fmt,
+                            T&&... args) -> format_to_n_result<OutputIt> {
+  return vformat_to_n(out, n, fmt, fmt::make_format_args(args...));
+}
+
+template <typename OutputIt, typename Sentinel = OutputIt>
+struct format_to_result {
+  /// Iterator pointing to just after the last successful write in the range.
+  OutputIt out;
+  /// Specifies if the output was truncated.
+  bool truncated;
+
+  FMT_CONSTEXPR operator OutputIt&() & {
+    detail::report_truncation(truncated);
+    return out;
+  }
+  FMT_CONSTEXPR operator const OutputIt&() const& {
+    detail::report_truncation(truncated);
+    return out;
+  }
+  FMT_CONSTEXPR operator OutputIt&&() && {
+    detail::report_truncation(truncated);
+    return static_cast<OutputIt&&>(out);
+  }
+};
+
+template <size_t N>
+auto vformat_to(char (&out)[N], string_view fmt, format_args args)
+    -> format_to_result<char*> {
+  auto result = vformat_to_n(out, N, fmt, args);
+  return {result.out, result.size > N};
+}
+
+template <size_t N, typename... T>
+FMT_INLINE auto format_to(char (&out)[N], format_string<T...> fmt, T&&... args)
+    -> format_to_result<char*> {
+  auto result = fmt::format_to_n(out, N, fmt, static_cast<T&&>(args)...);
+  return {result.out, result.size > N};
+}
+
+/// Returns the number of chars in the output of `format(fmt, args...)`.
+template <typename... T>
+FMT_NODISCARD FMT_INLINE auto formatted_size(format_string<T...> fmt,
+                                             T&&... args) -> size_t {
+  auto buf = detail::counting_buffer<>();
+  detail::vformat_to<char>(buf, fmt, fmt::make_format_args(args...), {});
+  return buf.count();
+}
+
+FMT_API void vprint(string_view fmt, format_args args);
+FMT_API void vprint(FILE* f, string_view fmt, format_args args);
+FMT_API void vprint_buffered(FILE* f, string_view fmt, format_args args);
+FMT_API void vprintln(FILE* f, string_view fmt, format_args args);
+
+/**
+ * Formats `args` according to specifications in `fmt` and writes the output
+ * to `stdout`.
+ *
+ * **Example**:
+ *
+ *     fmt::print("The answer is {}.", 42);
+ */
+template <typename... T>
+FMT_INLINE void print(format_string<T...> fmt, T&&... args) {
+  const auto& vargs = fmt::make_format_args(args...);
+  if (!detail::use_utf8()) return detail::vprint_mojibake(stdout, fmt, vargs);
+  return detail::is_locking<T...>() ? vprint_buffered(stdout, fmt, vargs)
+                                    : vprint(fmt, vargs);
+}
+
+/**
+ * Formats `args` according to specifications in `fmt` and writes the
+ * output to the file `f`.
+ *
+ * **Example**:
+ *
+ *     fmt::print(stderr, "Don't {}!", "panic");
+ */
+template <typename... T>
+FMT_INLINE void print(FILE* f, format_string<T...> fmt, T&&... args) {
+  const auto& vargs = fmt::make_format_args(args...);
+  if (!detail::use_utf8()) return detail::vprint_mojibake(f, fmt, vargs);
+  return detail::is_locking<T...>() ? vprint_buffered(f, fmt, vargs)
+                                    : vprint(f, fmt, vargs);
+}
+
+/// Formats `args` according to specifications in `fmt` and writes the output
+/// to the file `f` followed by a newline.
+template <typename... T>
+FMT_INLINE void println(FILE* f, format_string<T...> fmt, T&&... args) {
+  const auto& vargs = fmt::make_format_args(args...);
+  return detail::use_utf8() ? vprintln(f, fmt, vargs)
+                            : detail::vprint_mojibake(f, fmt, vargs, true);
+}
+
+/// Formats `args` according to specifications in `fmt` and writes the output
+/// to `stdout` followed by a newline.
+template <typename... T>
+FMT_INLINE void println(format_string<T...> fmt, T&&... args) {
+  return fmt::println(stdout, fmt, static_cast<T&&>(args)...);
+}
+
+FMT_END_EXPORT
+FMT_GCC_PRAGMA("GCC pop_options")
+FMT_END_NAMESPACE
+
+#ifdef FMT_HEADER_ONLY
+#  include "format.h"
+#endif
+#endif  // FMT_BASE_H_
diff --git a/thirdparty/fmt/chrono.h b/thirdparty/fmt/chrono.h
index 9d54574e1..c93123fd3 100644
--- a/thirdparty/fmt/chrono.h
+++ b/thirdparty/fmt/chrono.h
@@ -8,17 +8,19 @@
 #ifndef FMT_CHRONO_H_
 #define FMT_CHRONO_H_
 
-#include <algorithm>
-#include <chrono>
-#include <cmath>    // std::isfinite
-#include <cstring>  // std::memcpy
-#include <ctime>
-#include <iterator>
-#include <locale>
-#include <ostream>
-#include <type_traits>
-
-#include "ostream.h"  // formatbuf
+#ifndef FMT_MODULE
+#  include <algorithm>
+#  include <chrono>
+#  include <cmath>    // std::isfinite
+#  include <cstring>  // std::memcpy
+#  include <ctime>
+#  include <iterator>
+#  include <locale>
+#  include <ostream>
+#  include <type_traits>
+#endif
+
+#include "format.h"
 
 FMT_BEGIN_NAMESPACE
 
@@ -94,10 +96,8 @@ FMT_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec)
   return static_cast<To>(from);
 }
 
-/**
- * converts From to To, without loss. If the dynamic value of from
- * can't be converted to To without loss, ec is set.
- */
+/// Converts From to To, without loss. If the dynamic value of from
+/// can't be converted to To without loss, ec is set.
 template <typename To, typename From,
           FMT_ENABLE_IF(!std::is_same<From, To>::value &&
                         std::numeric_limits<From>::is_signed !=
@@ -185,9 +185,7 @@ FMT_CONSTEXPR auto safe_float_conversion(const From from, int& ec) -> To {
   return from;
 }
 
-/**
- * safe duration cast between integral durations
- */
+/// Safe duration cast between integral durations
 template <typename To, typename FromRep, typename FromPeriod,
           FMT_ENABLE_IF(std::is_integral<FromRep>::value),
           FMT_ENABLE_IF(std::is_integral<typename To::rep>::value)>
@@ -237,9 +235,7 @@ auto safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from,
   return ec ? To() : To(tocount);
 }
 
-/**
- * safe duration_cast between floating point durations
- */
+/// Safe duration_cast between floating point durations
 template <typename To, typename FromRep, typename FromPeriod,
           FMT_ENABLE_IF(std::is_floating_point<FromRep>::value),
           FMT_ENABLE_IF(std::is_floating_point<typename To::rep>::value)>
@@ -329,6 +325,39 @@ inline auto localtime_s(...) -> null<> { return null<>(); }
 inline auto gmtime_r(...) -> null<> { return null<>(); }
 inline auto gmtime_s(...) -> null<> { return null<>(); }
 
+// It is defined here and not in ostream.h because the latter has expensive
+// includes.
+template <typename Streambuf> class formatbuf : public Streambuf {
+ private:
+  using char_type = typename Streambuf::char_type;
+  using streamsize = decltype(std::declval<Streambuf>().sputn(nullptr, 0));
+  using int_type = typename Streambuf::int_type;
+  using traits_type = typename Streambuf::traits_type;
+
+  buffer<char_type>& buffer_;
+
+ public:
+  explicit formatbuf(buffer<char_type>& buf) : buffer_(buf) {}
+
+ protected:
+  // The put area is always empty. This makes the implementation simpler and has
+  // the advantage that the streambuf and the buffer are always in sync and
+  // sputc never writes into uninitialized memory. A disadvantage is that each
+  // call to sputc always results in a (virtual) call to overflow. There is no
+  // disadvantage here for sputn since this always results in a call to xsputn.
+
+  auto overflow(int_type ch) -> int_type override {
+    if (!traits_type::eq_int_type(ch, traits_type::eof()))
+      buffer_.push_back(static_cast<char_type>(ch));
+    return ch;
+  }
+
+  auto xsputn(const char_type* s, streamsize count) -> streamsize override {
+    buffer_.append(s, s + count);
+    return count;
+  }
+};
+
 inline auto get_classic_locale() -> const std::locale& {
   static const auto& locale = std::locale::classic();
   return locale;
@@ -362,11 +391,12 @@ void write_codecvt(codecvt_result<CodeUnit>& out, string_view in_buf,
 template <typename OutputIt>
 auto write_encoded_tm_str(OutputIt out, string_view in, const std::locale& loc)
     -> OutputIt {
-  if (detail::is_utf8() && loc != get_classic_locale()) {
+  if (detail::use_utf8() && loc != get_classic_locale()) {
     // char16_t and char32_t codecvts are broken in MSVC (linkage errors) and
     // gcc-4.
-#if FMT_MSC_VERSION != 0 || \
-    (defined(__GLIBCXX__) && !defined(_GLIBCXX_USE_DUAL_ABI))
+#if FMT_MSC_VERSION != 0 ||  \
+    (defined(__GLIBCXX__) && \
+     (!defined(_GLIBCXX_USE_DUAL_ABI) || _GLIBCXX_USE_DUAL_ABI == 0))
     // The _GLIBCXX_USE_DUAL_ABI macro is always defined in libstdc++ from gcc-5
     // and newer.
     using code_unit = wchar_t;
@@ -382,9 +412,9 @@ auto write_encoded_tm_str(OutputIt out, string_view in, const std::locale& loc)
         to_utf8<code_unit, basic_memory_buffer<char, unit_t::max_size * 4>>();
     if (!u.convert({unit.buf, to_unsigned(unit.end - unit.buf)}))
       FMT_THROW(format_error("failed to format time"));
-    return copy_str<char>(u.c_str(), u.c_str() + u.size(), out);
+    return copy<char>(u.c_str(), u.c_str() + u.size(), out);
   }
-  return copy_str<char>(in.data(), in.data() + in.size(), out);
+  return copy<char>(in.data(), in.data() + in.size(), out);
 }
 
 template <typename Char, typename OutputIt,
@@ -393,7 +423,7 @@ auto write_tm_str(OutputIt out, string_view sv, const std::locale& loc)
     -> OutputIt {
   codecvt_result<Char> unit;
   write_codecvt(unit, sv, loc);
-  return copy_str<Char>(unit.buf, unit.end, out);
+  return copy<Char>(unit.buf, unit.end, out);
 }
 
 template <typename Char, typename OutputIt,
@@ -482,9 +512,9 @@ auto to_time_t(
 FMT_BEGIN_EXPORT
 
 /**
-  Converts given time since epoch as ``std::time_t`` value into calendar time,
-  expressed in local time. Unlike ``std::localtime``, this function is
-  thread-safe on most platforms.
+ * Converts given time since epoch as `std::time_t` value into calendar time,
+ * expressed in local time. Unlike `std::localtime`, this function is
+ * thread-safe on most platforms.
  */
 inline auto localtime(std::time_t time) -> std::tm {
   struct dispatcher {
@@ -531,9 +561,9 @@ inline auto localtime(std::chrono::local_time<Duration> time) -> std::tm {
 #endif
 
 /**
-  Converts given time since epoch as ``std::time_t`` value into calendar time,
-  expressed in Coordinated Universal Time (UTC). Unlike ``std::gmtime``, this
-  function is thread-safe on most platforms.
+ * Converts given time since epoch as `std::time_t` value into calendar time,
+ * expressed in Coordinated Universal Time (UTC). Unlike `std::gmtime`, this
+ * function is thread-safe on most platforms.
  */
 inline auto gmtime(std::time_t time) -> std::tm {
   struct dispatcher {
@@ -646,12 +676,10 @@ enum class numeric_system {
 
 // Glibc extensions for formatting numeric values.
 enum class pad_type {
-  unspecified,
+  // Pad a numeric result string with zeros (the default).
+  zero,
   // Do not pad a numeric result string.
   none,
-  // Pad a numeric result string with zeros even if the conversion specifier
-  // character uses space-padding by default.
-  zero,
   // Pad a numeric result string with spaces.
   space,
 };
@@ -659,7 +687,7 @@ enum class pad_type {
 template <typename OutputIt>
 auto write_padding(OutputIt out, pad_type pad, int width) -> OutputIt {
   if (pad == pad_type::none) return out;
-  return std::fill_n(out, width, pad == pad_type::space ? ' ' : '0');
+  return detail::fill_n(out, width, pad == pad_type::space ? ' ' : '0');
 }
 
 template <typename OutputIt>
@@ -675,8 +703,8 @@ FMT_CONSTEXPR auto parse_chrono_format(const Char* begin, const Char* end,
   if (begin == end || *begin == '}') return begin;
   if (*begin != '%') FMT_THROW(format_error("invalid format"));
   auto ptr = begin;
-  pad_type pad = pad_type::unspecified;
   while (ptr != end) {
+    pad_type pad = pad_type::zero;
     auto c = *ptr;
     if (c == '}') break;
     if (c != '%') {
@@ -696,10 +724,6 @@ FMT_CONSTEXPR auto parse_chrono_format(const Char* begin, const Char* end,
       pad = pad_type::none;
       ++ptr;
       break;
-    case '0':
-      pad = pad_type::zero;
-      ++ptr;
-      break;
     }
     if (ptr == end) FMT_THROW(format_error("invalid format"));
     c = *ptr++;
@@ -759,22 +783,22 @@ FMT_CONSTEXPR auto parse_chrono_format(const Char* begin, const Char* end,
       break;
     // Day of the year/month:
     case 'U':
-      handler.on_dec0_week_of_year(numeric_system::standard);
+      handler.on_dec0_week_of_year(numeric_system::standard, pad);
       break;
     case 'W':
-      handler.on_dec1_week_of_year(numeric_system::standard);
+      handler.on_dec1_week_of_year(numeric_system::standard, pad);
       break;
     case 'V':
-      handler.on_iso_week_of_year(numeric_system::standard);
+      handler.on_iso_week_of_year(numeric_system::standard, pad);
       break;
     case 'j':
       handler.on_day_of_year();
       break;
     case 'd':
-      handler.on_day_of_month(numeric_system::standard);
+      handler.on_day_of_month(numeric_system::standard, pad);
       break;
     case 'e':
-      handler.on_day_of_month_space(numeric_system::standard);
+      handler.on_day_of_month(numeric_system::standard, pad_type::space);
       break;
     // Hour, minute, second:
     case 'H':
@@ -871,19 +895,19 @@ FMT_CONSTEXPR auto parse_chrono_format(const Char* begin, const Char* end,
         handler.on_dec_month(numeric_system::alternative);
         break;
       case 'U':
-        handler.on_dec0_week_of_year(numeric_system::alternative);
+        handler.on_dec0_week_of_year(numeric_system::alternative, pad);
         break;
       case 'W':
-        handler.on_dec1_week_of_year(numeric_system::alternative);
+        handler.on_dec1_week_of_year(numeric_system::alternative, pad);
         break;
       case 'V':
-        handler.on_iso_week_of_year(numeric_system::alternative);
+        handler.on_iso_week_of_year(numeric_system::alternative, pad);
         break;
       case 'd':
-        handler.on_day_of_month(numeric_system::alternative);
+        handler.on_day_of_month(numeric_system::alternative, pad);
         break;
       case 'e':
-        handler.on_day_of_month_space(numeric_system::alternative);
+        handler.on_day_of_month(numeric_system::alternative, pad_type::space);
         break;
       case 'w':
         handler.on_dec0_weekday(numeric_system::alternative);
@@ -936,12 +960,19 @@ template <typename Derived> struct null_chrono_spec_handler {
   FMT_CONSTEXPR void on_abbr_month() { unsupported(); }
   FMT_CONSTEXPR void on_full_month() { unsupported(); }
   FMT_CONSTEXPR void on_dec_month(numeric_system) { unsupported(); }
-  FMT_CONSTEXPR void on_dec0_week_of_year(numeric_system) { unsupported(); }
-  FMT_CONSTEXPR void on_dec1_week_of_year(numeric_system) { unsupported(); }
-  FMT_CONSTEXPR void on_iso_week_of_year(numeric_system) { unsupported(); }
+  FMT_CONSTEXPR void on_dec0_week_of_year(numeric_system, pad_type) {
+    unsupported();
+  }
+  FMT_CONSTEXPR void on_dec1_week_of_year(numeric_system, pad_type) {
+    unsupported();
+  }
+  FMT_CONSTEXPR void on_iso_week_of_year(numeric_system, pad_type) {
+    unsupported();
+  }
   FMT_CONSTEXPR void on_day_of_year() { unsupported(); }
-  FMT_CONSTEXPR void on_day_of_month(numeric_system) { unsupported(); }
-  FMT_CONSTEXPR void on_day_of_month_space(numeric_system) { unsupported(); }
+  FMT_CONSTEXPR void on_day_of_month(numeric_system, pad_type) {
+    unsupported();
+  }
   FMT_CONSTEXPR void on_24_hour(numeric_system) { unsupported(); }
   FMT_CONSTEXPR void on_12_hour(numeric_system) { unsupported(); }
   FMT_CONSTEXPR void on_minute(numeric_system) { unsupported(); }
@@ -979,12 +1010,11 @@ struct tm_format_checker : null_chrono_spec_handler<tm_format_checker> {
   FMT_CONSTEXPR void on_abbr_month() {}
   FMT_CONSTEXPR void on_full_month() {}
   FMT_CONSTEXPR void on_dec_month(numeric_system) {}
-  FMT_CONSTEXPR void on_dec0_week_of_year(numeric_system) {}
-  FMT_CONSTEXPR void on_dec1_week_of_year(numeric_system) {}
-  FMT_CONSTEXPR void on_iso_week_of_year(numeric_system) {}
+  FMT_CONSTEXPR void on_dec0_week_of_year(numeric_system, pad_type) {}
+  FMT_CONSTEXPR void on_dec1_week_of_year(numeric_system, pad_type) {}
+  FMT_CONSTEXPR void on_iso_week_of_year(numeric_system, pad_type) {}
   FMT_CONSTEXPR void on_day_of_year() {}
-  FMT_CONSTEXPR void on_day_of_month(numeric_system) {}
-  FMT_CONSTEXPR void on_day_of_month_space(numeric_system) {}
+  FMT_CONSTEXPR void on_day_of_month(numeric_system, pad_type) {}
   FMT_CONSTEXPR void on_24_hour(numeric_system, pad_type) {}
   FMT_CONSTEXPR void on_12_hour(numeric_system, pad_type) {}
   FMT_CONSTEXPR void on_minute(numeric_system, pad_type) {}
@@ -1061,9 +1091,10 @@ inline auto to_nonnegative_int(T value, Int upper) -> Int {
 }
 template <typename T, typename Int, FMT_ENABLE_IF(!std::is_integral<T>::value)>
 inline auto to_nonnegative_int(T value, Int upper) -> Int {
-  if (value < 0 || value > static_cast<T>(upper))
+  auto int_value = static_cast<Int>(value);
+  if (int_value < 0 || value > static_cast<T>(upper))
     FMT_THROW(format_error("invalid value"));
-  return static_cast<Int>(value);
+  return int_value;
 }
 
 constexpr auto pow10(std::uint32_t n) -> long long {
@@ -1115,22 +1146,27 @@ void write_fractional_seconds(OutputIt& out, Duration d, int precision = -1) {
     if (std::ratio_less<typename subsecond_precision::period,
                         std::chrono::seconds::period>::value) {
       *out++ = '.';
-      out = std::fill_n(out, leading_zeroes, '0');
+      out = detail::fill_n(out, leading_zeroes, '0');
       out = format_decimal<Char>(out, n, num_digits).end;
     }
-  } else {
+  } else if (precision > 0) {
     *out++ = '.';
     leading_zeroes = (std::min)(leading_zeroes, precision);
-    out = std::fill_n(out, leading_zeroes, '0');
     int remaining = precision - leading_zeroes;
-    if (remaining != 0 && remaining < num_digits) {
-      n /= to_unsigned(detail::pow10(to_unsigned(num_digits - remaining)));
-      out = format_decimal<Char>(out, n, remaining).end;
+    out = detail::fill_n(out, leading_zeroes, '0');
+    if (remaining < num_digits) {
+      int num_truncated_digits = num_digits - remaining;
+      n /= to_unsigned(detail::pow10(to_unsigned(num_truncated_digits)));
+      if (n) {
+        out = format_decimal<Char>(out, n, remaining).end;
+      }
       return;
     }
-    out = format_decimal<Char>(out, n, num_digits).end;
-    remaining -= num_digits;
-    out = std::fill_n(out, remaining, '0');
+    if (n) {
+      out = format_decimal<Char>(out, n, num_digits).end;
+      remaining -= num_digits;
+    }
+    out = detail::fill_n(out, remaining, '0');
   }
 }
 
@@ -1281,7 +1317,8 @@ class tm_writer {
     }
     uint32_or_64_or_128_t<long long> n = to_unsigned(year);
     const int num_digits = count_digits(n);
-    if (width > num_digits) out_ = std::fill_n(out_, width - num_digits, '0');
+    if (width > num_digits)
+      out_ = detail::fill_n(out_, width - num_digits, '0');
     out_ = format_decimal<Char>(out_, n, num_digits).end;
   }
   void write_year(long long year) {
@@ -1364,7 +1401,7 @@ class tm_writer {
   auto out() const -> OutputIt { return out_; }
 
   FMT_CONSTEXPR void on_text(const Char* begin, const Char* end) {
-    out_ = copy_str<Char>(begin, end, out_);
+    out_ = copy<Char>(begin, end, out_);
   }
 
   void on_abbr_weekday() {
@@ -1411,7 +1448,7 @@ class tm_writer {
       *out_++ = ' ';
       on_abbr_month();
       *out_++ = ' ';
-      on_day_of_month_space(numeric_system::standard);
+      on_day_of_month(numeric_system::standard, pad_type::space);
       *out_++ = ' ';
       on_iso_time();
       *out_++ = ' ';
@@ -1437,7 +1474,7 @@ class tm_writer {
     write_digit2_separated(buf, to_unsigned(tm_mon() + 1),
                            to_unsigned(tm_mday()),
                            to_unsigned(split_year_lower(tm_year())), '/');
-    out_ = copy_str<Char>(std::begin(buf), std::end(buf), out_);
+    out_ = copy<Char>(std::begin(buf), std::end(buf), out_);
   }
   void on_iso_date() {
     auto year = tm_year();
@@ -1453,7 +1490,7 @@ class tm_writer {
     write_digit2_separated(buf + 2, static_cast<unsigned>(year % 100),
                            to_unsigned(tm_mon() + 1), to_unsigned(tm_mday()),
                            '-');
-    out_ = copy_str<Char>(std::begin(buf) + offset, std::end(buf), out_);
+    out_ = copy<Char>(std::begin(buf) + offset, std::end(buf), out_);
   }
 
   void on_utc_offset(numeric_system ns) { format_utc_offset_impl(tm_, ns); }
@@ -1498,24 +1535,26 @@ class tm_writer {
     format_localized('m', 'O');
   }
 
-  void on_dec0_week_of_year(numeric_system ns) {
+  void on_dec0_week_of_year(numeric_system ns, pad_type pad) {
     if (is_classic_ || ns == numeric_system::standard)
-      return write2((tm_yday() + days_per_week - tm_wday()) / days_per_week);
+      return write2((tm_yday() + days_per_week - tm_wday()) / days_per_week,
+                    pad);
     format_localized('U', 'O');
   }
-  void on_dec1_week_of_year(numeric_system ns) {
+  void on_dec1_week_of_year(numeric_system ns, pad_type pad) {
     if (is_classic_ || ns == numeric_system::standard) {
       auto wday = tm_wday();
       write2((tm_yday() + days_per_week -
               (wday == 0 ? (days_per_week - 1) : (wday - 1))) /
-             days_per_week);
+                 days_per_week,
+             pad);
     } else {
       format_localized('W', 'O');
     }
   }
-  void on_iso_week_of_year(numeric_system ns) {
+  void on_iso_week_of_year(numeric_system ns, pad_type pad) {
     if (is_classic_ || ns == numeric_system::standard)
-      return write2(tm_iso_week_of_year());
+      return write2(tm_iso_week_of_year(), pad);
     format_localized('V', 'O');
   }
 
@@ -1529,20 +1568,11 @@ class tm_writer {
     write1(yday / 100);
     write2(yday % 100);
   }
-  void on_day_of_month(numeric_system ns) {
-    if (is_classic_ || ns == numeric_system::standard) return write2(tm_mday());
+  void on_day_of_month(numeric_system ns, pad_type pad) {
+    if (is_classic_ || ns == numeric_system::standard)
+      return write2(tm_mday(), pad);
     format_localized('d', 'O');
   }
-  void on_day_of_month_space(numeric_system ns) {
-    if (is_classic_ || ns == numeric_system::standard) {
-      auto mday = to_unsigned(tm_mday()) % 100;
-      const char* d2 = digits2(mday);
-      *out_++ = mday < 10 ? ' ' : d2[0];
-      *out_++ = d2[1];
-    } else {
-      format_localized('e', 'O');
-    }
-  }
 
   void on_24_hour(numeric_system ns, pad_type pad) {
     if (is_classic_ || ns == numeric_system::standard)
@@ -1586,7 +1616,7 @@ class tm_writer {
       char buf[8];
       write_digit2_separated(buf, to_unsigned(tm_hour12()),
                              to_unsigned(tm_min()), to_unsigned(tm_sec()), ':');
-      out_ = copy_str<Char>(std::begin(buf), std::end(buf), out_);
+      out_ = copy<Char>(std::begin(buf), std::end(buf), out_);
       *out_++ = ' ';
       on_am_pm();
     } else {
@@ -1601,7 +1631,7 @@ class tm_writer {
   void on_iso_time() {
     on_24_hour_time();
     *out_++ = ':';
-    on_second(numeric_system::standard, pad_type::unspecified);
+    on_second(numeric_system::standard, pad_type::zero);
   }
 
   void on_am_pm() {
@@ -1700,10 +1730,10 @@ auto format_duration_value(OutputIt out, Rep val, int) -> OutputIt {
 template <typename Char, typename Rep, typename OutputIt,
           FMT_ENABLE_IF(std::is_floating_point<Rep>::value)>
 auto format_duration_value(OutputIt out, Rep val, int precision) -> OutputIt {
-  auto specs = format_specs<Char>();
+  auto specs = format_specs();
   specs.precision = precision;
-  specs.type = precision >= 0 ? presentation_type::fixed_lower
-                              : presentation_type::general_lower;
+  specs.type =
+      precision >= 0 ? presentation_type::fixed : presentation_type::general;
   return write<Char>(out, val, specs);
 }
 
@@ -1744,8 +1774,10 @@ class get_locale {
 
  public:
   get_locale(bool localized, locale_ref loc) : has_locale_(localized) {
+#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
     if (localized)
       ::new (&locale_) std::locale(loc.template get<std::locale>());
+#endif
   }
   ~get_locale() {
     if (has_locale_) locale_.~locale();
@@ -1840,7 +1872,7 @@ struct chrono_formatter {
     }
   }
 
-  void write(Rep value, int width, pad_type pad = pad_type::unspecified) {
+  void write(Rep value, int width, pad_type pad = pad_type::zero) {
     write_sign();
     if (isnan(value)) return write_nan();
     uint32_or_64_or_128_t<int> n =
@@ -1890,11 +1922,10 @@ struct chrono_formatter {
   void on_iso_week_based_year() {}
   void on_iso_week_based_short_year() {}
   void on_dec_month(numeric_system) {}
-  void on_dec0_week_of_year(numeric_system) {}
-  void on_dec1_week_of_year(numeric_system) {}
-  void on_iso_week_of_year(numeric_system) {}
-  void on_day_of_month(numeric_system) {}
-  void on_day_of_month_space(numeric_system) {}
+  void on_dec0_week_of_year(numeric_system, pad_type) {}
+  void on_dec1_week_of_year(numeric_system, pad_type) {}
+  void on_iso_week_of_year(numeric_system, pad_type) {}
+  void on_day_of_month(numeric_system, pad_type) {}
 
   void on_day_of_year() {
     if (handle_nan_inf()) return;
@@ -1974,7 +2005,7 @@ struct chrono_formatter {
     on_24_hour_time();
     *out++ = ':';
     if (handle_nan_inf()) return;
-    on_second(numeric_system::standard, pad_type::unspecified);
+    on_second(numeric_system::standard, pad_type::zero);
   }
 
   void on_am_pm() {
@@ -1997,53 +2028,215 @@ struct chrono_formatter {
 
 #if defined(__cpp_lib_chrono) && __cpp_lib_chrono >= 201907
 using weekday = std::chrono::weekday;
+using day = std::chrono::day;
+using month = std::chrono::month;
+using year = std::chrono::year;
+using year_month_day = std::chrono::year_month_day;
 #else
 // A fallback version of weekday.
 class weekday {
  private:
-  unsigned char value;
+  unsigned char value_;
 
  public:
   weekday() = default;
-  explicit constexpr weekday(unsigned wd) noexcept
-      : value(static_cast<unsigned char>(wd != 7 ? wd : 0)) {}
-  constexpr auto c_encoding() const noexcept -> unsigned { return value; }
+  constexpr explicit weekday(unsigned wd) noexcept
+      : value_(static_cast<unsigned char>(wd != 7 ? wd : 0)) {}
+  constexpr auto c_encoding() const noexcept -> unsigned { return value_; }
+};
+
+class day {
+ private:
+  unsigned char value_;
+
+ public:
+  day() = default;
+  constexpr explicit day(unsigned d) noexcept
+      : value_(static_cast<unsigned char>(d)) {}
+  constexpr explicit operator unsigned() const noexcept { return value_; }
+};
+
+class month {
+ private:
+  unsigned char value_;
+
+ public:
+  month() = default;
+  constexpr explicit month(unsigned m) noexcept
+      : value_(static_cast<unsigned char>(m)) {}
+  constexpr explicit operator unsigned() const noexcept { return value_; }
+};
+
+class year {
+ private:
+  int value_;
+
+ public:
+  year() = default;
+  constexpr explicit year(int y) noexcept : value_(y) {}
+  constexpr explicit operator int() const noexcept { return value_; }
 };
 
-class year_month_day {};
+class year_month_day {
+ private:
+  fmt::year year_;
+  fmt::month month_;
+  fmt::day day_;
+
+ public:
+  year_month_day() = default;
+  constexpr year_month_day(const year& y, const month& m, const day& d) noexcept
+      : year_(y), month_(m), day_(d) {}
+  constexpr auto year() const noexcept -> fmt::year { return year_; }
+  constexpr auto month() const noexcept -> fmt::month { return month_; }
+  constexpr auto day() const noexcept -> fmt::day { return day_; }
+};
 #endif
 
-// A rudimentary weekday formatter.
-template <typename Char> struct formatter<weekday, Char> {
+template <typename Char>
+struct formatter<weekday, Char> : private formatter<std::tm, Char> {
  private:
-  bool localized = false;
+  bool localized_ = false;
+  bool use_tm_formatter_ = false;
 
  public:
   FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
       -> decltype(ctx.begin()) {
-    auto begin = ctx.begin(), end = ctx.end();
-    if (begin != end && *begin == 'L') {
-      ++begin;
-      localized = true;
+    auto it = ctx.begin(), end = ctx.end();
+    if (it != end && *it == 'L') {
+      ++it;
+      localized_ = true;
+      return it;
     }
-    return begin;
+    use_tm_formatter_ = it != end && *it != '}';
+    return use_tm_formatter_ ? formatter<std::tm, Char>::parse(ctx) : it;
   }
 
   template <typename FormatContext>
   auto format(weekday wd, FormatContext& ctx) const -> decltype(ctx.out()) {
     auto time = std::tm();
     time.tm_wday = static_cast<int>(wd.c_encoding());
-    detail::get_locale loc(localized, ctx.locale());
+    if (use_tm_formatter_) return formatter<std::tm, Char>::format(time, ctx);
+    detail::get_locale loc(localized_, ctx.locale());
     auto w = detail::tm_writer<decltype(ctx.out()), Char>(loc, ctx.out(), time);
     w.on_abbr_weekday();
     return w.out();
   }
 };
 
+template <typename Char>
+struct formatter<day, Char> : private formatter<std::tm, Char> {
+ private:
+  bool use_tm_formatter_ = false;
+
+ public:
+  FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
+      -> decltype(ctx.begin()) {
+    auto it = ctx.begin(), end = ctx.end();
+    use_tm_formatter_ = it != end && *it != '}';
+    return use_tm_formatter_ ? formatter<std::tm, Char>::parse(ctx) : it;
+  }
+
+  template <typename FormatContext>
+  auto format(day d, FormatContext& ctx) const -> decltype(ctx.out()) {
+    auto time = std::tm();
+    time.tm_mday = static_cast<int>(static_cast<unsigned>(d));
+    if (use_tm_formatter_) return formatter<std::tm, Char>::format(time, ctx);
+    detail::get_locale loc(false, ctx.locale());
+    auto w = detail::tm_writer<decltype(ctx.out()), Char>(loc, ctx.out(), time);
+    w.on_day_of_month(detail::numeric_system::standard, detail::pad_type::zero);
+    return w.out();
+  }
+};
+
+template <typename Char>
+struct formatter<month, Char> : private formatter<std::tm, Char> {
+ private:
+  bool localized_ = false;
+  bool use_tm_formatter_ = false;
+
+ public:
+  FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
+      -> decltype(ctx.begin()) {
+    auto it = ctx.begin(), end = ctx.end();
+    if (it != end && *it == 'L') {
+      ++it;
+      localized_ = true;
+      return it;
+    }
+    use_tm_formatter_ = it != end && *it != '}';
+    return use_tm_formatter_ ? formatter<std::tm, Char>::parse(ctx) : it;
+  }
+
+  template <typename FormatContext>
+  auto format(month m, FormatContext& ctx) const -> decltype(ctx.out()) {
+    auto time = std::tm();
+    time.tm_mon = static_cast<int>(static_cast<unsigned>(m)) - 1;
+    if (use_tm_formatter_) return formatter<std::tm, Char>::format(time, ctx);
+    detail::get_locale loc(localized_, ctx.locale());
+    auto w = detail::tm_writer<decltype(ctx.out()), Char>(loc, ctx.out(), time);
+    w.on_abbr_month();
+    return w.out();
+  }
+};
+
+template <typename Char>
+struct formatter<year, Char> : private formatter<std::tm, Char> {
+ private:
+  bool use_tm_formatter_ = false;
+
+ public:
+  FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
+      -> decltype(ctx.begin()) {
+    auto it = ctx.begin(), end = ctx.end();
+    use_tm_formatter_ = it != end && *it != '}';
+    return use_tm_formatter_ ? formatter<std::tm, Char>::parse(ctx) : it;
+  }
+
+  template <typename FormatContext>
+  auto format(year y, FormatContext& ctx) const -> decltype(ctx.out()) {
+    auto time = std::tm();
+    time.tm_year = static_cast<int>(y) - 1900;
+    if (use_tm_formatter_) return formatter<std::tm, Char>::format(time, ctx);
+    detail::get_locale loc(false, ctx.locale());
+    auto w = detail::tm_writer<decltype(ctx.out()), Char>(loc, ctx.out(), time);
+    w.on_year(detail::numeric_system::standard);
+    return w.out();
+  }
+};
+
+template <typename Char>
+struct formatter<year_month_day, Char> : private formatter<std::tm, Char> {
+ private:
+  bool use_tm_formatter_ = false;
+
+ public:
+  FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
+      -> decltype(ctx.begin()) {
+    auto it = ctx.begin(), end = ctx.end();
+    use_tm_formatter_ = it != end && *it != '}';
+    return use_tm_formatter_ ? formatter<std::tm, Char>::parse(ctx) : it;
+  }
+
+  template <typename FormatContext>
+  auto format(year_month_day val, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    auto time = std::tm();
+    time.tm_year = static_cast<int>(val.year()) - 1900;
+    time.tm_mon = static_cast<int>(static_cast<unsigned>(val.month())) - 1;
+    time.tm_mday = static_cast<int>(static_cast<unsigned>(val.day()));
+    if (use_tm_formatter_) return formatter<std::tm, Char>::format(time, ctx);
+    detail::get_locale loc(true, ctx.locale());
+    auto w = detail::tm_writer<decltype(ctx.out()), Char>(loc, ctx.out(), time);
+    w.on_iso_date();
+    return w.out();
+  }
+};
+
 template <typename Rep, typename Period, typename Char>
 struct formatter<std::chrono::duration<Rep, Period>, Char> {
  private:
-  format_specs<Char> specs_;
+  format_specs specs_;
   detail::arg_ref<Char> width_ref_;
   detail::arg_ref<Char> precision_ref_;
   bool localized_ = false;
@@ -2117,27 +2310,26 @@ struct formatter<std::chrono::time_point<std::chrono::system_clock, Duration>,
   template <typename FormatContext>
   auto format(std::chrono::time_point<std::chrono::system_clock, Duration> val,
               FormatContext& ctx) const -> decltype(ctx.out()) {
+    std::tm tm = gmtime(val);
     using period = typename Duration::period;
     if (detail::const_check(
-            period::num != 1 || period::den != 1 ||
-            std::is_floating_point<typename Duration::rep>::value)) {
-      const auto epoch = val.time_since_epoch();
-      auto subsecs = detail::fmt_duration_cast<Duration>(
-          epoch - detail::fmt_duration_cast<std::chrono::seconds>(epoch));
-
-      if (subsecs.count() < 0) {
-        auto second =
-            detail::fmt_duration_cast<Duration>(std::chrono::seconds(1));
-        if (epoch.count() < ((Duration::min)() + second).count())
-          FMT_THROW(format_error("duration is too small"));
-        subsecs += second;
-        val -= second;
-      }
-
-      return formatter<std::tm, Char>::do_format(gmtime(val), ctx, &subsecs);
+            period::num == 1 && period::den == 1 &&
+            !std::is_floating_point<typename Duration::rep>::value)) {
+      return formatter<std::tm, Char>::format(tm, ctx);
     }
-
-    return formatter<std::tm, Char>::format(gmtime(val), ctx);
+    Duration epoch = val.time_since_epoch();
+    Duration subsecs = detail::fmt_duration_cast<Duration>(
+        epoch - detail::fmt_duration_cast<std::chrono::seconds>(epoch));
+    if (subsecs.count() < 0) {
+      auto second =
+          detail::fmt_duration_cast<Duration>(std::chrono::seconds(1));
+      if (tm.tm_sec != 0)
+        --tm.tm_sec;
+      else
+        tm = gmtime(val - second);
+      subsecs += detail::fmt_duration_cast<Duration>(std::chrono::seconds(1));
+    }
+    return formatter<std::tm, Char>::do_format(tm, ctx, &subsecs);
   }
 };
 
@@ -2185,7 +2377,7 @@ struct formatter<std::chrono::time_point<std::chrono::utc_clock, Duration>,
 
 template <typename Char> struct formatter<std::tm, Char> {
  private:
-  format_specs<Char> specs_;
+  format_specs specs_;
   detail::arg_ref<Char> width_ref_;
 
  protected:
diff --git a/thirdparty/fmt/color.h b/thirdparty/fmt/color.h
index 367849a86..f0e9dd94e 100644
--- a/thirdparty/fmt/color.h
+++ b/thirdparty/fmt/color.h
@@ -227,7 +227,7 @@ struct color_type {
 };
 }  // namespace detail
 
-/** A text style consisting of foreground and background colors and emphasis. */
+/// A text style consisting of foreground and background colors and emphasis.
 class text_style {
  public:
   FMT_CONSTEXPR text_style(emphasis em = emphasis()) noexcept
@@ -239,7 +239,7 @@ class text_style {
       foreground_color = rhs.foreground_color;
     } else if (rhs.set_foreground_color) {
       if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb)
-        FMT_THROW(format_error("can't OR a terminal color"));
+        report_error("can't OR a terminal color");
       foreground_color.value.rgb_color |= rhs.foreground_color.value.rgb_color;
     }
 
@@ -248,7 +248,7 @@ class text_style {
       background_color = rhs.background_color;
     } else if (rhs.set_background_color) {
       if (!background_color.is_rgb || !rhs.background_color.is_rgb)
-        FMT_THROW(format_error("can't OR a terminal color"));
+        report_error("can't OR a terminal color");
       background_color.value.rgb_color |= rhs.background_color.value.rgb_color;
     }
 
@@ -310,13 +310,13 @@ class text_style {
   emphasis ems;
 };
 
-/** Creates a text style from the foreground (text) color. */
+/// Creates a text style from the foreground (text) color.
 FMT_CONSTEXPR inline auto fg(detail::color_type foreground) noexcept
     -> text_style {
   return text_style(true, foreground);
 }
 
-/** Creates a text style from the background color. */
+/// Creates a text style from the background color.
 FMT_CONSTEXPR inline auto bg(detail::color_type background) noexcept
     -> text_style {
   return text_style(false, background);
@@ -390,8 +390,8 @@ template <typename Char> struct ansi_color_escape {
   FMT_CONSTEXPR operator const Char*() const noexcept { return buffer; }
 
   FMT_CONSTEXPR auto begin() const noexcept -> const Char* { return buffer; }
-  FMT_CONSTEXPR_CHAR_TRAITS auto end() const noexcept -> const Char* {
-    return buffer + std::char_traits<Char>::length(buffer);
+  FMT_CONSTEXPR20 auto end() const noexcept -> const Char* {
+    return buffer + basic_string_view<Char>(buffer).size();
   }
 
  private:
@@ -441,9 +441,9 @@ template <typename T> struct styled_arg : detail::view {
 };
 
 template <typename Char>
-void vformat_to(buffer<Char>& buf, const text_style& ts,
-                basic_string_view<Char> format_str,
-                basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+void vformat_to(
+    buffer<Char>& buf, const text_style& ts, basic_string_view<Char> format_str,
+    basic_format_args<buffered_context<type_identity_t<Char>>> args) {
   bool has_style = false;
   if (ts.has_emphasis()) {
     has_style = true;
@@ -466,121 +466,92 @@ void vformat_to(buffer<Char>& buf, const text_style& ts,
 
 }  // namespace detail
 
-inline void vprint(std::FILE* f, const text_style& ts, string_view fmt,
+inline void vprint(FILE* f, const text_style& ts, string_view fmt,
                    format_args args) {
-  // Legacy wide streams are not supported.
   auto buf = memory_buffer();
   detail::vformat_to(buf, ts, fmt, args);
-  if (detail::is_utf8()) {
-    detail::print(f, string_view(buf.begin(), buf.size()));
-    return;
-  }
-  buf.push_back('\0');
-  int result = std::fputs(buf.data(), f);
-  if (result < 0)
-    FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
+  print(f, FMT_STRING("{}"), string_view(buf.begin(), buf.size()));
 }
 
 /**
-  \rst
-  Formats a string and prints it to the specified file stream using ANSI
-  escape sequences to specify text formatting.
-
-  **Example**::
-
-    fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
-               "Elapsed time: {0:.2f} seconds", 1.23);
-  \endrst
+ * Formats a string and prints it to the specified file stream using ANSI
+ * escape sequences to specify text formatting.
+ *
+ * **Example**:
+ *
+ *     fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
+ *                "Elapsed time: {0:.2f} seconds", 1.23);
  */
-template <typename S, typename... Args,
-          FMT_ENABLE_IF(detail::is_string<S>::value)>
-void print(std::FILE* f, const text_style& ts, const S& format_str,
-           const Args&... args) {
-  vprint(f, ts, format_str,
-         fmt::make_format_args<buffer_context<char_t<S>>>(args...));
+template <typename... T>
+void print(FILE* f, const text_style& ts, format_string<T...> fmt,
+           T&&... args) {
+  vprint(f, ts, fmt, fmt::make_format_args(args...));
 }
 
 /**
-  \rst
-  Formats a string and prints it to stdout using ANSI escape sequences to
-  specify text formatting.
-
-  **Example**::
-
-    fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
-               "Elapsed time: {0:.2f} seconds", 1.23);
-  \endrst
+ * Formats a string and prints it to stdout using ANSI escape sequences to
+ * specify text formatting.
+ *
+ * **Example**:
+ *
+ *     fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
+ *                "Elapsed time: {0:.2f} seconds", 1.23);
  */
-template <typename S, typename... Args,
-          FMT_ENABLE_IF(detail::is_string<S>::value)>
-void print(const text_style& ts, const S& format_str, const Args&... args) {
-  return print(stdout, ts, format_str, args...);
+template <typename... T>
+void print(const text_style& ts, format_string<T...> fmt, T&&... args) {
+  return print(stdout, ts, fmt, std::forward<T>(args)...);
 }
 
-template <typename S, typename Char = char_t<S>>
-inline auto vformat(
-    const text_style& ts, const S& format_str,
-    basic_format_args<buffer_context<type_identity_t<Char>>> args)
-    -> std::basic_string<Char> {
-  basic_memory_buffer<Char> buf;
-  detail::vformat_to(buf, ts, detail::to_string_view(format_str), args);
+inline auto vformat(const text_style& ts, string_view fmt, format_args args)
+    -> std::string {
+  auto buf = memory_buffer();
+  detail::vformat_to(buf, ts, fmt, args);
   return fmt::to_string(buf);
 }
 
 /**
-  \rst
-  Formats arguments and returns the result as a string using ANSI
-  escape sequences to specify text formatting.
-
-  **Example**::
-
-    #include <fmt/color.h>
-    std::string message = fmt::format(fmt::emphasis::bold | fg(fmt::color::red),
-                                      "The answer is {}", 42);
-  \endrst
-*/
-template <typename S, typename... Args, typename Char = char_t<S>>
-inline auto format(const text_style& ts, const S& format_str,
-                   const Args&... args) -> std::basic_string<Char> {
-  return fmt::vformat(ts, detail::to_string_view(format_str),
-                      fmt::make_format_args<buffer_context<Char>>(args...));
+ * Formats arguments and returns the result as a string using ANSI escape
+ * sequences to specify text formatting.
+ *
+ * **Example**:
+ *
+ * ```
+ * #include <fmt/color.h>
+ * std::string message = fmt::format(fmt::emphasis::bold | fg(fmt::color::red),
+ *                                   "The answer is {}", 42);
+ * ```
+ */
+template <typename... T>
+inline auto format(const text_style& ts, format_string<T...> fmt, T&&... args)
+    -> std::string {
+  return fmt::vformat(ts, fmt, fmt::make_format_args(args...));
 }
 
-/**
-  Formats a string with the given text_style and writes the output to ``out``.
- */
-template <typename OutputIt, typename Char,
-          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value)>
-auto vformat_to(OutputIt out, const text_style& ts,
-                basic_string_view<Char> format_str,
-                basic_format_args<buffer_context<type_identity_t<Char>>> args)
-    -> OutputIt {
-  auto&& buf = detail::get_buffer<Char>(out);
-  detail::vformat_to(buf, ts, format_str, args);
+/// Formats a string with the given text_style and writes the output to `out`.
+template <typename OutputIt,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
+auto vformat_to(OutputIt out, const text_style& ts, string_view fmt,
+                format_args args) -> OutputIt {
+  auto&& buf = detail::get_buffer<char>(out);
+  detail::vformat_to(buf, ts, fmt, args);
   return detail::get_iterator(buf, out);
 }
 
 /**
-  \rst
-  Formats arguments with the given text_style, writes the result to the output
-  iterator ``out`` and returns the iterator past the end of the output range.
-
-  **Example**::
-
-    std::vector<char> out;
-    fmt::format_to(std::back_inserter(out),
-                   fmt::emphasis::bold | fg(fmt::color::red), "{}", 42);
-  \endrst
-*/
-template <
-    typename OutputIt, typename S, typename... Args,
-    bool enable = detail::is_output_iterator<OutputIt, char_t<S>>::value &&
-                  detail::is_string<S>::value>
-inline auto format_to(OutputIt out, const text_style& ts, const S& format_str,
-                      Args&&... args) ->
-    typename std::enable_if<enable, OutputIt>::type {
-  return vformat_to(out, ts, detail::to_string_view(format_str),
-                    fmt::make_format_args<buffer_context<char_t<S>>>(args...));
+ * Formats arguments with the given text style, writes the result to the output
+ * iterator `out` and returns the iterator past the end of the output range.
+ *
+ * **Example**:
+ *
+ *     std::vector<char> out;
+ *     fmt::format_to(std::back_inserter(out),
+ *                    fmt::emphasis::bold | fg(fmt::color::red), "{}", 42);
+ */
+template <typename OutputIt, typename... T,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
+inline auto format_to(OutputIt out, const text_style& ts,
+                      format_string<T...> fmt, T&&... args) -> OutputIt {
+  return vformat_to(out, ts, fmt, fmt::make_format_args(args...));
 }
 
 template <typename T, typename Char>
@@ -620,16 +591,14 @@ struct formatter<detail::styled_arg<T>, Char> : formatter<T, Char> {
 };
 
 /**
-  \rst
-  Returns an argument that will be formatted using ANSI escape sequences,
-  to be used in a formatting function.
-
-  **Example**::
-
-    fmt::print("Elapsed time: {0:.2f} seconds",
-               fmt::styled(1.23, fmt::fg(fmt::color::green) |
-                                 fmt::bg(fmt::color::blue)));
-  \endrst
+ * Returns an argument that will be formatted using ANSI escape sequences,
+ * to be used in a formatting function.
+ *
+ * **Example**:
+ *
+ *     fmt::print("Elapsed time: {0:.2f} seconds",
+ *                fmt::styled(1.23, fmt::fg(fmt::color::green) |
+ *                                  fmt::bg(fmt::color::blue)));
  */
 template <typename T>
 FMT_CONSTEXPR auto styled(const T& value, text_style ts)
diff --git a/thirdparty/fmt/compile.h b/thirdparty/fmt/compile.h
index 3b3f166e0..b2afc2c30 100644
--- a/thirdparty/fmt/compile.h
+++ b/thirdparty/fmt/compile.h
@@ -8,39 +8,41 @@
 #ifndef FMT_COMPILE_H_
 #define FMT_COMPILE_H_
 
+#ifndef FMT_MODULE
+#  include <iterator>  // std::back_inserter
+#endif
+
 #include "format.h"
 
 FMT_BEGIN_NAMESPACE
+
+// A compile-time string which is compiled into fast formatting code.
+FMT_EXPORT class compiled_string {};
+
 namespace detail {
 
-template <typename Char, typename InputIt>
-FMT_CONSTEXPR inline auto copy_str(InputIt begin, InputIt end,
-                                   counting_iterator it) -> counting_iterator {
+template <typename T, typename InputIt>
+FMT_CONSTEXPR inline auto copy(InputIt begin, InputIt end, counting_iterator it)
+    -> counting_iterator {
   return it + (end - begin);
 }
 
-// A compile-time string which is compiled into fast formatting code.
-class compiled_string {};
-
 template <typename S>
 struct is_compiled_string : std::is_base_of<compiled_string, S> {};
 
 /**
-  \rst
-  Converts a string literal *s* into a format string that will be parsed at
-  compile time and converted into efficient formatting code. Requires C++17
-  ``constexpr if`` compiler support.
-
-  **Example**::
-
-    // Converts 42 into std::string using the most efficient method and no
-    // runtime format string processing.
-    std::string s = fmt::format(FMT_COMPILE("{}"), 42);
-  \endrst
+ * Converts a string literal `s` into a format string that will be parsed at
+ * compile time and converted into efficient formatting code. Requires C++17
+ * `constexpr if` compiler support.
+ *
+ * **Example**:
+ *
+ *     // Converts 42 into std::string using the most efficient method and no
+ *     // runtime format string processing.
+ *     std::string s = fmt::format(FMT_COMPILE("{}"), 42);
  */
 #if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
-#  define FMT_COMPILE(s) \
-    FMT_STRING_IMPL(s, fmt::detail::compiled_string, explicit)
+#  define FMT_COMPILE(s) FMT_STRING_IMPL(s, fmt::compiled_string, explicit)
 #else
 #  define FMT_COMPILE(s) FMT_STRING(s)
 #endif
@@ -144,9 +146,9 @@ template <typename Char, typename T, int N> struct field {
   template <typename OutputIt, typename... Args>
   constexpr OutputIt format(OutputIt out, const Args&... args) const {
     const T& arg = get_arg_checked<T, N>(args...);
-    if constexpr (std::is_convertible_v<T, basic_string_view<Char>>) {
+    if constexpr (std::is_convertible<T, basic_string_view<Char>>::value) {
       auto s = basic_string_view<Char>(arg);
-      return copy_str<Char>(s.begin(), s.end(), out);
+      return copy<Char>(s.begin(), s.end(), out);
     }
     return write<Char>(out, arg);
   }
@@ -236,13 +238,12 @@ constexpr size_t parse_text(basic_string_view<Char> str, size_t pos) {
 }
 
 template <typename Args, size_t POS, int ID, typename S>
-constexpr auto compile_format_string(S format_str);
+constexpr auto compile_format_string(S fmt);
 
 template <typename Args, size_t POS, int ID, typename T, typename S>
-constexpr auto parse_tail(T head, S format_str) {
-  if constexpr (POS !=
-                basic_string_view<typename S::char_type>(format_str).size()) {
-    constexpr auto tail = compile_format_string<Args, POS, ID>(format_str);
+constexpr auto parse_tail(T head, S fmt) {
+  if constexpr (POS != basic_string_view<typename S::char_type>(fmt).size()) {
+    constexpr auto tail = compile_format_string<Args, POS, ID>(fmt);
     if constexpr (std::is_same<remove_cvref_t<decltype(tail)>,
                                unknown_format>())
       return tail;
@@ -313,14 +314,13 @@ struct field_type<T, enable_if_t<detail::is_named_arg<T>::value>> {
 
 template <typename T, typename Args, size_t END_POS, int ARG_INDEX, int NEXT_ID,
           typename S>
-constexpr auto parse_replacement_field_then_tail(S format_str) {
+constexpr auto parse_replacement_field_then_tail(S fmt) {
   using char_type = typename S::char_type;
-  constexpr auto str = basic_string_view<char_type>(format_str);
+  constexpr auto str = basic_string_view<char_type>(fmt);
   constexpr char_type c = END_POS != str.size() ? str[END_POS] : char_type();
   if constexpr (c == '}') {
     return parse_tail<Args, END_POS + 1, NEXT_ID>(
-        field<char_type, typename field_type<T>::type, ARG_INDEX>(),
-        format_str);
+        field<char_type, typename field_type<T>::type, ARG_INDEX>(), fmt);
   } else if constexpr (c != ':') {
     FMT_THROW(format_error("expected ':'"));
   } else {
@@ -333,7 +333,7 @@ constexpr auto parse_replacement_field_then_tail(S format_str) {
       return parse_tail<Args, result.end + 1, result.next_arg_id>(
           spec_field<char_type, typename field_type<T>::type, ARG_INDEX>{
               result.fmt},
-          format_str);
+          fmt);
     }
   }
 }
@@ -341,22 +341,21 @@ constexpr auto parse_replacement_field_then_tail(S format_str) {
 // Compiles a non-empty format string and returns the compiled representation
 // or unknown_format() on unrecognized input.
 template <typename Args, size_t POS, int ID, typename S>
-constexpr auto compile_format_string(S format_str) {
+constexpr auto compile_format_string(S fmt) {
   using char_type = typename S::char_type;
-  constexpr auto str = basic_string_view<char_type>(format_str);
+  constexpr auto str = basic_string_view<char_type>(fmt);
   if constexpr (str[POS] == '{') {
     if constexpr (POS + 1 == str.size())
       FMT_THROW(format_error("unmatched '{' in format string"));
     if constexpr (str[POS + 1] == '{') {
-      return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), format_str);
+      return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), fmt);
     } else if constexpr (str[POS + 1] == '}' || str[POS + 1] == ':') {
       static_assert(ID != manual_indexing_id,
                     "cannot switch from manual to automatic argument indexing");
       constexpr auto next_id =
           ID != manual_indexing_id ? ID + 1 : manual_indexing_id;
       return parse_replacement_field_then_tail<get_type<ID, Args>, Args,
-                                               POS + 1, ID, next_id>(
-          format_str);
+                                               POS + 1, ID, next_id>(fmt);
     } else {
       constexpr auto arg_id_result =
           parse_arg_id<ID>(str.data() + POS + 1, str.data() + str.size());
@@ -372,7 +371,7 @@ constexpr auto compile_format_string(S format_str) {
         return parse_replacement_field_then_tail<get_type<arg_index, Args>,
                                                  Args, arg_id_end_pos,
                                                  arg_index, manual_indexing_id>(
-            format_str);
+            fmt);
       } else if constexpr (arg_id_result.arg_id.kind == arg_id_kind::name) {
         constexpr auto arg_index =
             get_arg_index_by_name(arg_id_result.arg_id.val.name, Args{});
@@ -381,11 +380,11 @@ constexpr auto compile_format_string(S format_str) {
               ID != manual_indexing_id ? ID + 1 : manual_indexing_id;
           return parse_replacement_field_then_tail<
               decltype(get_type<arg_index, Args>::value), Args, arg_id_end_pos,
-              arg_index, next_id>(format_str);
+              arg_index, next_id>(fmt);
         } else if constexpr (c == '}') {
           return parse_tail<Args, arg_id_end_pos + 1, ID>(
               runtime_named_field<char_type>{arg_id_result.arg_id.val.name},
-              format_str);
+              fmt);
         } else if constexpr (c == ':') {
           return unknown_format();  // no type info for specs parsing
         }
@@ -394,29 +393,26 @@ constexpr auto compile_format_string(S format_str) {
   } else if constexpr (str[POS] == '}') {
     if constexpr (POS + 1 == str.size())
       FMT_THROW(format_error("unmatched '}' in format string"));
-    return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), format_str);
+    return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), fmt);
   } else {
     constexpr auto end = parse_text(str, POS + 1);
     if constexpr (end - POS > 1) {
-      return parse_tail<Args, end, ID>(make_text(str, POS, end - POS),
-                                       format_str);
+      return parse_tail<Args, end, ID>(make_text(str, POS, end - POS), fmt);
     } else {
-      return parse_tail<Args, end, ID>(code_unit<char_type>{str[POS]},
-                                       format_str);
+      return parse_tail<Args, end, ID>(code_unit<char_type>{str[POS]}, fmt);
     }
   }
 }
 
 template <typename... Args, typename S,
           FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
-constexpr auto compile(S format_str) {
-  constexpr auto str = basic_string_view<typename S::char_type>(format_str);
+constexpr auto compile(S fmt) {
+  constexpr auto str = basic_string_view<typename S::char_type>(fmt);
   if constexpr (str.size() == 0) {
     return detail::make_text(str, 0, 0);
   } else {
     constexpr auto result =
-        detail::compile_format_string<detail::type_list<Args...>, 0, 0>(
-            format_str);
+        detail::compile_format_string<detail::type_list<Args...>, 0, 0>(fmt);
     return result;
   }
 }
@@ -488,35 +484,33 @@ FMT_CONSTEXPR OutputIt format_to(OutputIt out, const S&, Args&&... args) {
 
 template <typename OutputIt, typename S, typename... Args,
           FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
-auto format_to_n(OutputIt out, size_t n, const S& format_str, Args&&... args)
+auto format_to_n(OutputIt out, size_t n, const S& fmt, Args&&... args)
     -> format_to_n_result<OutputIt> {
   using traits = detail::fixed_buffer_traits;
   auto buf = detail::iterator_buffer<OutputIt, char, traits>(out, n);
-  fmt::format_to(std::back_inserter(buf), format_str,
-                 std::forward<Args>(args)...);
+  fmt::format_to(std::back_inserter(buf), fmt, std::forward<Args>(args)...);
   return {buf.out(), buf.count()};
 }
 
 template <typename S, typename... Args,
           FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
-FMT_CONSTEXPR20 auto formatted_size(const S& format_str, const Args&... args)
+FMT_CONSTEXPR20 auto formatted_size(const S& fmt, const Args&... args)
     -> size_t {
-  return fmt::format_to(detail::counting_iterator(), format_str, args...)
-      .count();
+  return fmt::format_to(detail::counting_iterator(), fmt, args...).count();
 }
 
 template <typename S, typename... Args,
           FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
-void print(std::FILE* f, const S& format_str, const Args&... args) {
+void print(std::FILE* f, const S& fmt, const Args&... args) {
   memory_buffer buffer;
-  fmt::format_to(std::back_inserter(buffer), format_str, args...);
+  fmt::format_to(std::back_inserter(buffer), fmt, args...);
   detail::print(f, {buffer.data(), buffer.size()});
 }
 
 template <typename S, typename... Args,
           FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
-void print(const S& format_str, const Args&... args) {
-  print(stdout, format_str, args...);
+void print(const S& fmt, const Args&... args) {
+  print(stdout, fmt, args...);
 }
 
 #if FMT_USE_NONTYPE_TEMPLATE_ARGS
diff --git a/thirdparty/fmt/core.h b/thirdparty/fmt/core.h
index b51c1406a..8ca735f0c 100644
--- a/thirdparty/fmt/core.h
+++ b/thirdparty/fmt/core.h
@@ -1,2969 +1,5 @@
-// Formatting library for C++ - the core API for char/UTF-8
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
+// This file is only provided for compatibility and may be removed in future
+// versions. Use fmt/base.h if you don't need fmt::format and fmt/format.h
+// otherwise.
 
-#ifndef FMT_CORE_H_
-#define FMT_CORE_H_
-
-#include <cstddef>  // std::byte
-#include <cstdio>   // std::FILE
-#include <cstring>  // std::strlen
-#include <iterator>
-#include <limits>
-#include <memory>  // std::addressof
-#include <string>
-#include <type_traits>
-
-// The fmt library version in the form major * 10000 + minor * 100 + patch.
-#define FMT_VERSION 100201
-
-#if defined(__clang__) && !defined(__ibmxl__)
-#  define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__)
-#else
-#  define FMT_CLANG_VERSION 0
-#endif
-
-#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER) && \
-    !defined(__NVCOMPILER)
-#  define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
-#else
-#  define FMT_GCC_VERSION 0
-#endif
-
-#ifndef FMT_GCC_PRAGMA
-// Workaround _Pragma bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59884.
-#  if FMT_GCC_VERSION >= 504
-#    define FMT_GCC_PRAGMA(arg) _Pragma(arg)
-#  else
-#    define FMT_GCC_PRAGMA(arg)
-#  endif
-#endif
-
-#ifdef __ICL
-#  define FMT_ICC_VERSION __ICL
-#elif defined(__INTEL_COMPILER)
-#  define FMT_ICC_VERSION __INTEL_COMPILER
-#else
-#  define FMT_ICC_VERSION 0
-#endif
-
-#ifdef _MSC_VER
-#  define FMT_MSC_VERSION _MSC_VER
-#  define FMT_MSC_WARNING(...) __pragma(warning(__VA_ARGS__))
-#else
-#  define FMT_MSC_VERSION 0
-#  define FMT_MSC_WARNING(...)
-#endif
-
-#ifdef _MSVC_LANG
-#  define FMT_CPLUSPLUS _MSVC_LANG
-#else
-#  define FMT_CPLUSPLUS __cplusplus
-#endif
-
-#ifdef __has_feature
-#  define FMT_HAS_FEATURE(x) __has_feature(x)
-#else
-#  define FMT_HAS_FEATURE(x) 0
-#endif
-
-#if defined(__has_include) || FMT_ICC_VERSION >= 1600 || FMT_MSC_VERSION > 1900
-#  define FMT_HAS_INCLUDE(x) __has_include(x)
-#else
-#  define FMT_HAS_INCLUDE(x) 0
-#endif
-
-#ifdef __has_cpp_attribute
-#  define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
-#else
-#  define FMT_HAS_CPP_ATTRIBUTE(x) 0
-#endif
-
-#define FMT_HAS_CPP14_ATTRIBUTE(attribute) \
-  (FMT_CPLUSPLUS >= 201402L && FMT_HAS_CPP_ATTRIBUTE(attribute))
-
-#define FMT_HAS_CPP17_ATTRIBUTE(attribute) \
-  (FMT_CPLUSPLUS >= 201703L && FMT_HAS_CPP_ATTRIBUTE(attribute))
-
-// Check if relaxed C++14 constexpr is supported.
-// GCC doesn't allow throw in constexpr until version 6 (bug 67371).
-#ifndef FMT_USE_CONSTEXPR
-#  if (FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VERSION >= 1912 || \
-       (FMT_GCC_VERSION >= 600 && FMT_CPLUSPLUS >= 201402L)) &&             \
-      !FMT_ICC_VERSION && (!defined(__NVCC__) || FMT_CPLUSPLUS >= 202002L)
-#    define FMT_USE_CONSTEXPR 1
-#  else
-#    define FMT_USE_CONSTEXPR 0
-#  endif
-#endif
-#if FMT_USE_CONSTEXPR
-#  define FMT_CONSTEXPR constexpr
-#else
-#  define FMT_CONSTEXPR
-#endif
-
-#if (FMT_CPLUSPLUS >= 202002L ||                                \
-     (FMT_CPLUSPLUS >= 201709L && FMT_GCC_VERSION >= 1002)) &&  \
-    ((!defined(_GLIBCXX_RELEASE) || _GLIBCXX_RELEASE >= 10) &&  \
-     (!defined(_LIBCPP_VERSION) || _LIBCPP_VERSION >= 10000) && \
-     (!FMT_MSC_VERSION || FMT_MSC_VERSION >= 1928)) &&          \
-    defined(__cpp_lib_is_constant_evaluated)
-#  define FMT_CONSTEXPR20 constexpr
-#else
-#  define FMT_CONSTEXPR20
-#endif
-
-// Check if constexpr std::char_traits<>::{compare,length} are supported.
-#if defined(__GLIBCXX__)
-#  if FMT_CPLUSPLUS >= 201703L && defined(_GLIBCXX_RELEASE) && \
-      _GLIBCXX_RELEASE >= 7  // GCC 7+ libstdc++ has _GLIBCXX_RELEASE.
-#    define FMT_CONSTEXPR_CHAR_TRAITS constexpr
-#  endif
-#elif defined(_LIBCPP_VERSION) && FMT_CPLUSPLUS >= 201703L && \
-    _LIBCPP_VERSION >= 4000
-#  define FMT_CONSTEXPR_CHAR_TRAITS constexpr
-#elif FMT_MSC_VERSION >= 1914 && FMT_CPLUSPLUS >= 201703L
-#  define FMT_CONSTEXPR_CHAR_TRAITS constexpr
-#endif
-#ifndef FMT_CONSTEXPR_CHAR_TRAITS
-#  define FMT_CONSTEXPR_CHAR_TRAITS
-#endif
-
-// Check if exceptions are disabled.
-#ifndef FMT_EXCEPTIONS
-#  if (defined(__GNUC__) && !defined(__EXCEPTIONS)) || \
-      (FMT_MSC_VERSION && !_HAS_EXCEPTIONS)
-#    define FMT_EXCEPTIONS 0
-#  else
-#    define FMT_EXCEPTIONS 1
-#  endif
-#endif
-
-// Disable [[noreturn]] on MSVC/NVCC because of bogus unreachable code warnings.
-#if FMT_EXCEPTIONS && FMT_HAS_CPP_ATTRIBUTE(noreturn) && !FMT_MSC_VERSION && \
-    !defined(__NVCC__)
-#  define FMT_NORETURN [[noreturn]]
-#else
-#  define FMT_NORETURN
-#endif
-
-#ifndef FMT_NODISCARD
-#  if FMT_HAS_CPP17_ATTRIBUTE(nodiscard)
-#    define FMT_NODISCARD [[nodiscard]]
-#  else
-#    define FMT_NODISCARD
-#  endif
-#endif
-
-#ifndef FMT_INLINE
-#  if FMT_GCC_VERSION || FMT_CLANG_VERSION
-#    define FMT_INLINE inline __attribute__((always_inline))
-#  else
-#    define FMT_INLINE inline
-#  endif
-#endif
-
-#ifdef _MSC_VER
-#  define FMT_UNCHECKED_ITERATOR(It) \
-    using _Unchecked_type = It  // Mark iterator as checked.
-#else
-#  define FMT_UNCHECKED_ITERATOR(It) using unchecked_type = It
-#endif
-
-#ifndef FMT_BEGIN_NAMESPACE
-#  define FMT_BEGIN_NAMESPACE \
-    namespace fmt {           \
-    inline namespace v10 {
-#  define FMT_END_NAMESPACE \
-    }                       \
-    }
-#endif
-
-#ifndef FMT_EXPORT
-#  define FMT_EXPORT
-#  define FMT_BEGIN_EXPORT
-#  define FMT_END_EXPORT
-#endif
-
-#if FMT_GCC_VERSION || FMT_CLANG_VERSION
-#  define FMT_VISIBILITY(value) __attribute__((visibility(value)))
-#else
-#  define FMT_VISIBILITY(value)
-#endif
-
-#if !defined(FMT_HEADER_ONLY) && defined(_WIN32)
-#  if defined(FMT_LIB_EXPORT)
-#    define FMT_API __declspec(dllexport)
-#  elif defined(FMT_SHARED)
-#    define FMT_API __declspec(dllimport)
-#  endif
-#elif defined(FMT_LIB_EXPORT) || defined(FMT_SHARED)
-#  define FMT_API FMT_VISIBILITY("default")
-#endif
-#ifndef FMT_API
-#  define FMT_API
-#endif
-
-// libc++ supports string_view in pre-c++17.
-#if FMT_HAS_INCLUDE(<string_view>) && \
-    (FMT_CPLUSPLUS >= 201703L || defined(_LIBCPP_VERSION))
-#  include <string_view>
-#  define FMT_USE_STRING_VIEW
-#elif FMT_HAS_INCLUDE("experimental/string_view") && FMT_CPLUSPLUS >= 201402L
-#  include <experimental/string_view>
-#  define FMT_USE_EXPERIMENTAL_STRING_VIEW
-#endif
-
-#ifndef FMT_UNICODE
-#  define FMT_UNICODE !FMT_MSC_VERSION
-#endif
-
-#ifndef FMT_CONSTEVAL
-#  if ((FMT_GCC_VERSION >= 1000 || FMT_CLANG_VERSION >= 1101) && \
-       (!defined(__apple_build_version__) ||                     \
-        __apple_build_version__ >= 14000029L) &&                 \
-       FMT_CPLUSPLUS >= 202002L) ||                              \
-      (defined(__cpp_consteval) &&                               \
-       (!FMT_MSC_VERSION || FMT_MSC_VERSION >= 1929))
-// consteval is broken in MSVC before VS2019 version 16.10 and Apple clang
-// before 14.
-#    define FMT_CONSTEVAL consteval
-#    define FMT_HAS_CONSTEVAL
-#  else
-#    define FMT_CONSTEVAL
-#  endif
-#endif
-
-#ifndef FMT_USE_NONTYPE_TEMPLATE_ARGS
-#  if defined(__cpp_nontype_template_args) &&                  \
-      ((FMT_GCC_VERSION >= 903 && FMT_CPLUSPLUS >= 201709L) || \
-       __cpp_nontype_template_args >= 201911L) &&              \
-      !defined(__NVCOMPILER) && !defined(__LCC__)
-#    define FMT_USE_NONTYPE_TEMPLATE_ARGS 1
-#  else
-#    define FMT_USE_NONTYPE_TEMPLATE_ARGS 0
-#  endif
-#endif
-
-// GCC < 5 requires this-> in decltype
-#ifndef FMT_DECLTYPE_THIS
-#  if FMT_GCC_VERSION && FMT_GCC_VERSION < 500
-#    define FMT_DECLTYPE_THIS this->
-#  else
-#    define FMT_DECLTYPE_THIS
-#  endif
-#endif
-
-// Enable minimal optimizations for more compact code in debug mode.
-FMT_GCC_PRAGMA("GCC push_options")
-#if !defined(__OPTIMIZE__) && !defined(__NVCOMPILER) && !defined(__LCC__) && \
-    !defined(__CUDACC__)
-FMT_GCC_PRAGMA("GCC optimize(\"Og\")")
-#endif
-
-FMT_BEGIN_NAMESPACE
-
-// Implementations of enable_if_t and other metafunctions for older systems.
-template <bool B, typename T = void>
-using enable_if_t = typename std::enable_if<B, T>::type;
-template <bool B, typename T, typename F>
-using conditional_t = typename std::conditional<B, T, F>::type;
-template <bool B> using bool_constant = std::integral_constant<bool, B>;
-template <typename T>
-using remove_reference_t = typename std::remove_reference<T>::type;
-template <typename T>
-using remove_const_t = typename std::remove_const<T>::type;
-template <typename T>
-using remove_cvref_t = typename std::remove_cv<remove_reference_t<T>>::type;
-template <typename T> struct type_identity {
-  using type = T;
-};
-template <typename T> using type_identity_t = typename type_identity<T>::type;
-template <typename T>
-using underlying_t = typename std::underlying_type<T>::type;
-
-// Checks whether T is a container with contiguous storage.
-template <typename T> struct is_contiguous : std::false_type {};
-template <typename Char>
-struct is_contiguous<std::basic_string<Char>> : std::true_type {};
-
-struct monostate {
-  constexpr monostate() {}
-};
-
-// An enable_if helper to be used in template parameters which results in much
-// shorter symbols: https://godbolt.org/z/sWw4vP. Extra parentheses are needed
-// to workaround a bug in MSVC 2019 (see #1140 and #1186).
-#ifdef FMT_DOC
-#  define FMT_ENABLE_IF(...)
-#else
-#  define FMT_ENABLE_IF(...) fmt::enable_if_t<(__VA_ARGS__), int> = 0
-#endif
-
-// This is defined in core.h instead of format.h to avoid injecting in std.
-// It is a template to avoid undesirable implicit conversions to std::byte.
-#ifdef __cpp_lib_byte
-template <typename T, FMT_ENABLE_IF(std::is_same<T, std::byte>::value)>
-inline auto format_as(T b) -> unsigned char {
-  return static_cast<unsigned char>(b);
-}
-#endif
-
-namespace detail {
-// Suppresses "unused variable" warnings with the method described in
-// https://herbsutter.com/2009/10/18/mailbag-shutting-up-compiler-warnings/.
-// (void)var does not work on many Intel compilers.
-template <typename... T> FMT_CONSTEXPR void ignore_unused(const T&...) {}
-
-constexpr FMT_INLINE auto is_constant_evaluated(
-    bool default_value = false) noexcept -> bool {
-// Workaround for incompatibility between libstdc++ consteval-based
-// std::is_constant_evaluated() implementation and clang-14.
-// https://github.com/fmtlib/fmt/issues/3247
-#if FMT_CPLUSPLUS >= 202002L && defined(_GLIBCXX_RELEASE) && \
-    _GLIBCXX_RELEASE >= 12 &&                                \
-    (FMT_CLANG_VERSION >= 1400 && FMT_CLANG_VERSION < 1500)
-  ignore_unused(default_value);
-  return __builtin_is_constant_evaluated();
-#elif defined(__cpp_lib_is_constant_evaluated)
-  ignore_unused(default_value);
-  return std::is_constant_evaluated();
-#else
-  return default_value;
-#endif
-}
-
-// Suppresses "conditional expression is constant" warnings.
-template <typename T> constexpr FMT_INLINE auto const_check(T value) -> T {
-  return value;
-}
-
-FMT_NORETURN FMT_API void assert_fail(const char* file, int line,
-                                      const char* message);
-
-#ifndef FMT_ASSERT
-#  ifdef NDEBUG
-// FMT_ASSERT is not empty to avoid -Wempty-body.
-#    define FMT_ASSERT(condition, message) \
-      fmt::detail::ignore_unused((condition), (message))
-#  else
-#    define FMT_ASSERT(condition, message)                                    \
-      ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
-           ? (void)0                                                          \
-           : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
-#  endif
-#endif
-
-#if defined(FMT_USE_STRING_VIEW)
-template <typename Char> using std_string_view = std::basic_string_view<Char>;
-#elif defined(FMT_USE_EXPERIMENTAL_STRING_VIEW)
-template <typename Char>
-using std_string_view = std::experimental::basic_string_view<Char>;
-#else
-template <typename T> struct std_string_view {};
-#endif
-
-#ifdef FMT_USE_INT128
-// Do nothing.
-#elif defined(__SIZEOF_INT128__) && !defined(__NVCC__) && \
-    !(FMT_CLANG_VERSION && FMT_MSC_VERSION)
-#  define FMT_USE_INT128 1
-using int128_opt = __int128_t;  // An optional native 128-bit integer.
-using uint128_opt = __uint128_t;
-template <typename T> inline auto convert_for_visit(T value) -> T {
-  return value;
-}
-#else
-#  define FMT_USE_INT128 0
-#endif
-#if !FMT_USE_INT128
-enum class int128_opt {};
-enum class uint128_opt {};
-// Reduce template instantiations.
-template <typename T> auto convert_for_visit(T) -> monostate { return {}; }
-#endif
-
-// Casts a nonnegative integer to unsigned.
-template <typename Int>
-FMT_CONSTEXPR auto to_unsigned(Int value) ->
-    typename std::make_unsigned<Int>::type {
-  FMT_ASSERT(std::is_unsigned<Int>::value || value >= 0, "negative value");
-  return static_cast<typename std::make_unsigned<Int>::type>(value);
-}
-
-FMT_CONSTEXPR inline auto is_utf8() -> bool {
-  FMT_MSC_WARNING(suppress : 4566) constexpr unsigned char section[] = "\u00A7";
-
-  // Avoid buggy sign extensions in MSVC's constant evaluation mode (#2297).
-  using uchar = unsigned char;
-  return FMT_UNICODE || (sizeof(section) == 3 && uchar(section[0]) == 0xC2 &&
-                         uchar(section[1]) == 0xA7);
-}
-}  // namespace detail
-
-/**
-  An implementation of ``std::basic_string_view`` for pre-C++17. It provides a
-  subset of the API. ``fmt::basic_string_view`` is used for format strings even
-  if ``std::string_view`` is available to prevent issues when a library is
-  compiled with a different ``-std`` option than the client code (which is not
-  recommended).
- */
-FMT_EXPORT
-template <typename Char> class basic_string_view {
- private:
-  const Char* data_;
-  size_t size_;
-
- public:
-  using value_type = Char;
-  using iterator = const Char*;
-
-  constexpr basic_string_view() noexcept : data_(nullptr), size_(0) {}
-
-  /** Constructs a string reference object from a C string and a size. */
-  constexpr basic_string_view(const Char* s, size_t count) noexcept
-      : data_(s), size_(count) {}
-
-  /**
-    \rst
-    Constructs a string reference object from a C string computing
-    the size with ``std::char_traits<Char>::length``.
-    \endrst
-   */
-  FMT_CONSTEXPR_CHAR_TRAITS
-  FMT_INLINE
-  basic_string_view(const Char* s)
-      : data_(s),
-        size_(detail::const_check(std::is_same<Char, char>::value &&
-                                  !detail::is_constant_evaluated(true))
-                  ? std::strlen(reinterpret_cast<const char*>(s))
-                  : std::char_traits<Char>::length(s)) {}
-
-  /** Constructs a string reference from a ``std::basic_string`` object. */
-  template <typename Traits, typename Alloc>
-  FMT_CONSTEXPR basic_string_view(
-      const std::basic_string<Char, Traits, Alloc>& s) noexcept
-      : data_(s.data()), size_(s.size()) {}
-
-  template <typename S, FMT_ENABLE_IF(std::is_same<
-                                      S, detail::std_string_view<Char>>::value)>
-  FMT_CONSTEXPR basic_string_view(S s) noexcept
-      : data_(s.data()), size_(s.size()) {}
-
-  /** Returns a pointer to the string data. */
-  constexpr auto data() const noexcept -> const Char* { return data_; }
-
-  /** Returns the string size. */
-  constexpr auto size() const noexcept -> size_t { return size_; }
-
-  constexpr auto begin() const noexcept -> iterator { return data_; }
-  constexpr auto end() const noexcept -> iterator { return data_ + size_; }
-
-  constexpr auto operator[](size_t pos) const noexcept -> const Char& {
-    return data_[pos];
-  }
-
-  FMT_CONSTEXPR void remove_prefix(size_t n) noexcept {
-    data_ += n;
-    size_ -= n;
-  }
-
-  FMT_CONSTEXPR_CHAR_TRAITS auto starts_with(
-      basic_string_view<Char> sv) const noexcept -> bool {
-    return size_ >= sv.size_ &&
-           std::char_traits<Char>::compare(data_, sv.data_, sv.size_) == 0;
-  }
-  FMT_CONSTEXPR_CHAR_TRAITS auto starts_with(Char c) const noexcept -> bool {
-    return size_ >= 1 && std::char_traits<Char>::eq(*data_, c);
-  }
-  FMT_CONSTEXPR_CHAR_TRAITS auto starts_with(const Char* s) const -> bool {
-    return starts_with(basic_string_view<Char>(s));
-  }
-
-  // Lexicographically compare this string reference to other.
-  FMT_CONSTEXPR_CHAR_TRAITS auto compare(basic_string_view other) const -> int {
-    size_t str_size = size_ < other.size_ ? size_ : other.size_;
-    int result = std::char_traits<Char>::compare(data_, other.data_, str_size);
-    if (result == 0)
-      result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);
-    return result;
-  }
-
-  FMT_CONSTEXPR_CHAR_TRAITS friend auto operator==(basic_string_view lhs,
-                                                   basic_string_view rhs)
-      -> bool {
-    return lhs.compare(rhs) == 0;
-  }
-  friend auto operator!=(basic_string_view lhs, basic_string_view rhs) -> bool {
-    return lhs.compare(rhs) != 0;
-  }
-  friend auto operator<(basic_string_view lhs, basic_string_view rhs) -> bool {
-    return lhs.compare(rhs) < 0;
-  }
-  friend auto operator<=(basic_string_view lhs, basic_string_view rhs) -> bool {
-    return lhs.compare(rhs) <= 0;
-  }
-  friend auto operator>(basic_string_view lhs, basic_string_view rhs) -> bool {
-    return lhs.compare(rhs) > 0;
-  }
-  friend auto operator>=(basic_string_view lhs, basic_string_view rhs) -> bool {
-    return lhs.compare(rhs) >= 0;
-  }
-};
-
-FMT_EXPORT
-using string_view = basic_string_view<char>;
-
-/** Specifies if ``T`` is a character type. Can be specialized by users. */
-FMT_EXPORT
-template <typename T> struct is_char : std::false_type {};
-template <> struct is_char<char> : std::true_type {};
-
-namespace detail {
-
-// A base class for compile-time strings.
-struct compile_string {};
-
-template <typename S>
-struct is_compile_string : std::is_base_of<compile_string, S> {};
-
-template <typename Char, FMT_ENABLE_IF(is_char<Char>::value)>
-FMT_INLINE auto to_string_view(const Char* s) -> basic_string_view<Char> {
-  return s;
-}
-template <typename Char, typename Traits, typename Alloc>
-inline auto to_string_view(const std::basic_string<Char, Traits, Alloc>& s)
-    -> basic_string_view<Char> {
-  return s;
-}
-template <typename Char>
-constexpr auto to_string_view(basic_string_view<Char> s)
-    -> basic_string_view<Char> {
-  return s;
-}
-template <typename Char,
-          FMT_ENABLE_IF(!std::is_empty<std_string_view<Char>>::value)>
-inline auto to_string_view(std_string_view<Char> s) -> basic_string_view<Char> {
-  return s;
-}
-template <typename S, FMT_ENABLE_IF(is_compile_string<S>::value)>
-constexpr auto to_string_view(const S& s)
-    -> basic_string_view<typename S::char_type> {
-  return basic_string_view<typename S::char_type>(s);
-}
-void to_string_view(...);
-
-// Specifies whether S is a string type convertible to fmt::basic_string_view.
-// It should be a constexpr function but MSVC 2017 fails to compile it in
-// enable_if and MSVC 2015 fails to compile it as an alias template.
-// ADL is intentionally disabled as to_string_view is not an extension point.
-template <typename S>
-struct is_string
-    : std::is_class<decltype(detail::to_string_view(std::declval<S>()))> {};
-
-template <typename S, typename = void> struct char_t_impl {};
-template <typename S> struct char_t_impl<S, enable_if_t<is_string<S>::value>> {
-  using result = decltype(to_string_view(std::declval<S>()));
-  using type = typename result::value_type;
-};
-
-enum class type {
-  none_type,
-  // Integer types should go first,
-  int_type,
-  uint_type,
-  long_long_type,
-  ulong_long_type,
-  int128_type,
-  uint128_type,
-  bool_type,
-  char_type,
-  last_integer_type = char_type,
-  // followed by floating-point types.
-  float_type,
-  double_type,
-  long_double_type,
-  last_numeric_type = long_double_type,
-  cstring_type,
-  string_type,
-  pointer_type,
-  custom_type
-};
-
-// Maps core type T to the corresponding type enum constant.
-template <typename T, typename Char>
-struct type_constant : std::integral_constant<type, type::custom_type> {};
-
-#define FMT_TYPE_CONSTANT(Type, constant) \
-  template <typename Char>                \
-  struct type_constant<Type, Char>        \
-      : std::integral_constant<type, type::constant> {}
-
-FMT_TYPE_CONSTANT(int, int_type);
-FMT_TYPE_CONSTANT(unsigned, uint_type);
-FMT_TYPE_CONSTANT(long long, long_long_type);
-FMT_TYPE_CONSTANT(unsigned long long, ulong_long_type);
-FMT_TYPE_CONSTANT(int128_opt, int128_type);
-FMT_TYPE_CONSTANT(uint128_opt, uint128_type);
-FMT_TYPE_CONSTANT(bool, bool_type);
-FMT_TYPE_CONSTANT(Char, char_type);
-FMT_TYPE_CONSTANT(float, float_type);
-FMT_TYPE_CONSTANT(double, double_type);
-FMT_TYPE_CONSTANT(long double, long_double_type);
-FMT_TYPE_CONSTANT(const Char*, cstring_type);
-FMT_TYPE_CONSTANT(basic_string_view<Char>, string_type);
-FMT_TYPE_CONSTANT(const void*, pointer_type);
-
-constexpr auto is_integral_type(type t) -> bool {
-  return t > type::none_type && t <= type::last_integer_type;
-}
-constexpr auto is_arithmetic_type(type t) -> bool {
-  return t > type::none_type && t <= type::last_numeric_type;
-}
-
-constexpr auto set(type rhs) -> int { return 1 << static_cast<int>(rhs); }
-constexpr auto in(type t, int set) -> bool {
-  return ((set >> static_cast<int>(t)) & 1) != 0;
-}
-
-// Bitsets of types.
-enum {
-  sint_set =
-      set(type::int_type) | set(type::long_long_type) | set(type::int128_type),
-  uint_set = set(type::uint_type) | set(type::ulong_long_type) |
-             set(type::uint128_type),
-  bool_set = set(type::bool_type),
-  char_set = set(type::char_type),
-  float_set = set(type::float_type) | set(type::double_type) |
-              set(type::long_double_type),
-  string_set = set(type::string_type),
-  cstring_set = set(type::cstring_type),
-  pointer_set = set(type::pointer_type)
-};
-
-// DEPRECATED!
-FMT_NORETURN FMT_API void throw_format_error(const char* message);
-
-struct error_handler {
-  constexpr error_handler() = default;
-
-  // This function is intentionally not constexpr to give a compile-time error.
-  FMT_NORETURN void on_error(const char* message) {
-    throw_format_error(message);
-  }
-};
-}  // namespace detail
-
-/** Throws ``format_error`` with a given message. */
-using detail::throw_format_error;
-
-/** String's character type. */
-template <typename S> using char_t = typename detail::char_t_impl<S>::type;
-
-/**
-  \rst
-  Parsing context consisting of a format string range being parsed and an
-  argument counter for automatic indexing.
-  You can use the ``format_parse_context`` type alias for ``char`` instead.
-  \endrst
- */
-FMT_EXPORT
-template <typename Char> class basic_format_parse_context {
- private:
-  basic_string_view<Char> format_str_;
-  int next_arg_id_;
-
-  FMT_CONSTEXPR void do_check_arg_id(int id);
-
- public:
-  using char_type = Char;
-  using iterator = const Char*;
-
-  explicit constexpr basic_format_parse_context(
-      basic_string_view<Char> format_str, int next_arg_id = 0)
-      : format_str_(format_str), next_arg_id_(next_arg_id) {}
-
-  /**
-    Returns an iterator to the beginning of the format string range being
-    parsed.
-   */
-  constexpr auto begin() const noexcept -> iterator {
-    return format_str_.begin();
-  }
-
-  /**
-    Returns an iterator past the end of the format string range being parsed.
-   */
-  constexpr auto end() const noexcept -> iterator { return format_str_.end(); }
-
-  /** Advances the begin iterator to ``it``. */
-  FMT_CONSTEXPR void advance_to(iterator it) {
-    format_str_.remove_prefix(detail::to_unsigned(it - begin()));
-  }
-
-  /**
-    Reports an error if using the manual argument indexing; otherwise returns
-    the next argument index and switches to the automatic indexing.
-   */
-  FMT_CONSTEXPR auto next_arg_id() -> int {
-    if (next_arg_id_ < 0) {
-      detail::throw_format_error(
-          "cannot switch from manual to automatic argument indexing");
-      return 0;
-    }
-    int id = next_arg_id_++;
-    do_check_arg_id(id);
-    return id;
-  }
-
-  /**
-    Reports an error if using the automatic argument indexing; otherwise
-    switches to the manual indexing.
-   */
-  FMT_CONSTEXPR void check_arg_id(int id) {
-    if (next_arg_id_ > 0) {
-      detail::throw_format_error(
-          "cannot switch from automatic to manual argument indexing");
-      return;
-    }
-    next_arg_id_ = -1;
-    do_check_arg_id(id);
-  }
-  FMT_CONSTEXPR void check_arg_id(basic_string_view<Char>) {}
-  FMT_CONSTEXPR void check_dynamic_spec(int arg_id);
-};
-
-FMT_EXPORT
-using format_parse_context = basic_format_parse_context<char>;
-
-namespace detail {
-// A parse context with extra data used only in compile-time checks.
-template <typename Char>
-class compile_parse_context : public basic_format_parse_context<Char> {
- private:
-  int num_args_;
-  const type* types_;
-  using base = basic_format_parse_context<Char>;
-
- public:
-  explicit FMT_CONSTEXPR compile_parse_context(
-      basic_string_view<Char> format_str, int num_args, const type* types,
-      int next_arg_id = 0)
-      : base(format_str, next_arg_id), num_args_(num_args), types_(types) {}
-
-  constexpr auto num_args() const -> int { return num_args_; }
-  constexpr auto arg_type(int id) const -> type { return types_[id]; }
-
-  FMT_CONSTEXPR auto next_arg_id() -> int {
-    int id = base::next_arg_id();
-    if (id >= num_args_) throw_format_error("argument not found");
-    return id;
-  }
-
-  FMT_CONSTEXPR void check_arg_id(int id) {
-    base::check_arg_id(id);
-    if (id >= num_args_) throw_format_error("argument not found");
-  }
-  using base::check_arg_id;
-
-  FMT_CONSTEXPR void check_dynamic_spec(int arg_id) {
-    detail::ignore_unused(arg_id);
-#if !defined(__LCC__)
-    if (arg_id < num_args_ && types_ && !is_integral_type(types_[arg_id]))
-      throw_format_error("width/precision is not integer");
-#endif
-  }
-};
-
-// Extracts a reference to the container from back_insert_iterator.
-template <typename Container>
-inline auto get_container(std::back_insert_iterator<Container> it)
-    -> Container& {
-  using base = std::back_insert_iterator<Container>;
-  struct accessor : base {
-    accessor(base b) : base(b) {}
-    using base::container;
-  };
-  return *accessor(it).container;
-}
-
-template <typename Char, typename InputIt, typename OutputIt>
-FMT_CONSTEXPR auto copy_str(InputIt begin, InputIt end, OutputIt out)
-    -> OutputIt {
-  while (begin != end) *out++ = static_cast<Char>(*begin++);
-  return out;
-}
-
-template <typename Char, typename T, typename U,
-          FMT_ENABLE_IF(
-              std::is_same<remove_const_t<T>, U>::value&& is_char<U>::value)>
-FMT_CONSTEXPR auto copy_str(T* begin, T* end, U* out) -> U* {
-  if (is_constant_evaluated()) return copy_str<Char, T*, U*>(begin, end, out);
-  auto size = to_unsigned(end - begin);
-  if (size > 0) memcpy(out, begin, size * sizeof(U));
-  return out + size;
-}
-
-/**
-  \rst
-  A contiguous memory buffer with an optional growing ability. It is an internal
-  class and shouldn't be used directly, only via `~fmt::basic_memory_buffer`.
-  \endrst
- */
-template <typename T> class buffer {
- private:
-  T* ptr_;
-  size_t size_;
-  size_t capacity_;
-
- protected:
-  // Don't initialize ptr_ since it is not accessed to save a few cycles.
-  FMT_MSC_WARNING(suppress : 26495)
-  FMT_CONSTEXPR buffer(size_t sz) noexcept : size_(sz), capacity_(sz) {}
-
-  FMT_CONSTEXPR20 buffer(T* p = nullptr, size_t sz = 0, size_t cap = 0) noexcept
-      : ptr_(p), size_(sz), capacity_(cap) {}
-
-  FMT_CONSTEXPR20 ~buffer() = default;
-  buffer(buffer&&) = default;
-
-  /** Sets the buffer data and capacity. */
-  FMT_CONSTEXPR void set(T* buf_data, size_t buf_capacity) noexcept {
-    ptr_ = buf_data;
-    capacity_ = buf_capacity;
-  }
-
-  /** Increases the buffer capacity to hold at least *capacity* elements. */
-  // DEPRECATED!
-  virtual FMT_CONSTEXPR20 void grow(size_t capacity) = 0;
-
- public:
-  using value_type = T;
-  using const_reference = const T&;
-
-  buffer(const buffer&) = delete;
-  void operator=(const buffer&) = delete;
-
-  FMT_INLINE auto begin() noexcept -> T* { return ptr_; }
-  FMT_INLINE auto end() noexcept -> T* { return ptr_ + size_; }
-
-  FMT_INLINE auto begin() const noexcept -> const T* { return ptr_; }
-  FMT_INLINE auto end() const noexcept -> const T* { return ptr_ + size_; }
-
-  /** Returns the size of this buffer. */
-  constexpr auto size() const noexcept -> size_t { return size_; }
-
-  /** Returns the capacity of this buffer. */
-  constexpr auto capacity() const noexcept -> size_t { return capacity_; }
-
-  /** Returns a pointer to the buffer data (not null-terminated). */
-  FMT_CONSTEXPR auto data() noexcept -> T* { return ptr_; }
-  FMT_CONSTEXPR auto data() const noexcept -> const T* { return ptr_; }
-
-  /** Clears this buffer. */
-  void clear() { size_ = 0; }
-
-  // Tries resizing the buffer to contain *count* elements. If T is a POD type
-  // the new elements may not be initialized.
-  FMT_CONSTEXPR20 void try_resize(size_t count) {
-    try_reserve(count);
-    size_ = count <= capacity_ ? count : capacity_;
-  }
-
-  // Tries increasing the buffer capacity to *new_capacity*. It can increase the
-  // capacity by a smaller amount than requested but guarantees there is space
-  // for at least one additional element either by increasing the capacity or by
-  // flushing the buffer if it is full.
-  FMT_CONSTEXPR20 void try_reserve(size_t new_capacity) {
-    if (new_capacity > capacity_) grow(new_capacity);
-  }
-
-  FMT_CONSTEXPR20 void push_back(const T& value) {
-    try_reserve(size_ + 1);
-    ptr_[size_++] = value;
-  }
-
-  /** Appends data to the end of the buffer. */
-  template <typename U> void append(const U* begin, const U* end);
-
-  template <typename Idx> FMT_CONSTEXPR auto operator[](Idx index) -> T& {
-    return ptr_[index];
-  }
-  template <typename Idx>
-  FMT_CONSTEXPR auto operator[](Idx index) const -> const T& {
-    return ptr_[index];
-  }
-};
-
-struct buffer_traits {
-  explicit buffer_traits(size_t) {}
-  auto count() const -> size_t { return 0; }
-  auto limit(size_t size) -> size_t { return size; }
-};
-
-class fixed_buffer_traits {
- private:
-  size_t count_ = 0;
-  size_t limit_;
-
- public:
-  explicit fixed_buffer_traits(size_t limit) : limit_(limit) {}
-  auto count() const -> size_t { return count_; }
-  auto limit(size_t size) -> size_t {
-    size_t n = limit_ > count_ ? limit_ - count_ : 0;
-    count_ += size;
-    return size < n ? size : n;
-  }
-};
-
-// A buffer that writes to an output iterator when flushed.
-template <typename OutputIt, typename T, typename Traits = buffer_traits>
-class iterator_buffer final : public Traits, public buffer<T> {
- private:
-  OutputIt out_;
-  enum { buffer_size = 256 };
-  T data_[buffer_size];
-
- protected:
-  FMT_CONSTEXPR20 void grow(size_t) override {
-    if (this->size() == buffer_size) flush();
-  }
-
-  void flush() {
-    auto size = this->size();
-    this->clear();
-    out_ = copy_str<T>(data_, data_ + this->limit(size), out_);
-  }
-
- public:
-  explicit iterator_buffer(OutputIt out, size_t n = buffer_size)
-      : Traits(n), buffer<T>(data_, 0, buffer_size), out_(out) {}
-  iterator_buffer(iterator_buffer&& other)
-      : Traits(other), buffer<T>(data_, 0, buffer_size), out_(other.out_) {}
-  ~iterator_buffer() { flush(); }
-
-  auto out() -> OutputIt {
-    flush();
-    return out_;
-  }
-  auto count() const -> size_t { return Traits::count() + this->size(); }
-};
-
-template <typename T>
-class iterator_buffer<T*, T, fixed_buffer_traits> final
-    : public fixed_buffer_traits,
-      public buffer<T> {
- private:
-  T* out_;
-  enum { buffer_size = 256 };
-  T data_[buffer_size];
-
- protected:
-  FMT_CONSTEXPR20 void grow(size_t) override {
-    if (this->size() == this->capacity()) flush();
-  }
-
-  void flush() {
-    size_t n = this->limit(this->size());
-    if (this->data() == out_) {
-      out_ += n;
-      this->set(data_, buffer_size);
-    }
-    this->clear();
-  }
-
- public:
-  explicit iterator_buffer(T* out, size_t n = buffer_size)
-      : fixed_buffer_traits(n), buffer<T>(out, 0, n), out_(out) {}
-  iterator_buffer(iterator_buffer&& other)
-      : fixed_buffer_traits(other),
-        buffer<T>(std::move(other)),
-        out_(other.out_) {
-    if (this->data() != out_) {
-      this->set(data_, buffer_size);
-      this->clear();
-    }
-  }
-  ~iterator_buffer() { flush(); }
-
-  auto out() -> T* {
-    flush();
-    return out_;
-  }
-  auto count() const -> size_t {
-    return fixed_buffer_traits::count() + this->size();
-  }
-};
-
-template <typename T> class iterator_buffer<T*, T> final : public buffer<T> {
- protected:
-  FMT_CONSTEXPR20 void grow(size_t) override {}
-
- public:
-  explicit iterator_buffer(T* out, size_t = 0) : buffer<T>(out, 0, ~size_t()) {}
-
-  auto out() -> T* { return &*this->end(); }
-};
-
-// A buffer that writes to a container with the contiguous storage.
-template <typename Container>
-class iterator_buffer<std::back_insert_iterator<Container>,
-                      enable_if_t<is_contiguous<Container>::value,
-                                  typename Container::value_type>>
-    final : public buffer<typename Container::value_type> {
- private:
-  Container& container_;
-
- protected:
-  FMT_CONSTEXPR20 void grow(size_t capacity) override {
-    container_.resize(capacity);
-    this->set(&container_[0], capacity);
-  }
-
- public:
-  explicit iterator_buffer(Container& c)
-      : buffer<typename Container::value_type>(c.size()), container_(c) {}
-  explicit iterator_buffer(std::back_insert_iterator<Container> out, size_t = 0)
-      : iterator_buffer(get_container(out)) {}
-
-  auto out() -> std::back_insert_iterator<Container> {
-    return std::back_inserter(container_);
-  }
-};
-
-// A buffer that counts the number of code units written discarding the output.
-template <typename T = char> class counting_buffer final : public buffer<T> {
- private:
-  enum { buffer_size = 256 };
-  T data_[buffer_size];
-  size_t count_ = 0;
-
- protected:
-  FMT_CONSTEXPR20 void grow(size_t) override {
-    if (this->size() != buffer_size) return;
-    count_ += this->size();
-    this->clear();
-  }
-
- public:
-  counting_buffer() : buffer<T>(data_, 0, buffer_size) {}
-
-  auto count() -> size_t { return count_ + this->size(); }
-};
-}  // namespace detail
-
-template <typename Char>
-FMT_CONSTEXPR void basic_format_parse_context<Char>::do_check_arg_id(int id) {
-  // Argument id is only checked at compile-time during parsing because
-  // formatting has its own validation.
-  if (detail::is_constant_evaluated() &&
-      (!FMT_GCC_VERSION || FMT_GCC_VERSION >= 1200)) {
-    using context = detail::compile_parse_context<Char>;
-    if (id >= static_cast<context*>(this)->num_args())
-      detail::throw_format_error("argument not found");
-  }
-}
-
-template <typename Char>
-FMT_CONSTEXPR void basic_format_parse_context<Char>::check_dynamic_spec(
-    int arg_id) {
-  if (detail::is_constant_evaluated() &&
-      (!FMT_GCC_VERSION || FMT_GCC_VERSION >= 1200)) {
-    using context = detail::compile_parse_context<Char>;
-    static_cast<context*>(this)->check_dynamic_spec(arg_id);
-  }
-}
-
-FMT_EXPORT template <typename Context> class basic_format_arg;
-FMT_EXPORT template <typename Context> class basic_format_args;
-FMT_EXPORT template <typename Context> class dynamic_format_arg_store;
-
-// A formatter for objects of type T.
-FMT_EXPORT
-template <typename T, typename Char = char, typename Enable = void>
-struct formatter {
-  // A deleted default constructor indicates a disabled formatter.
-  formatter() = delete;
-};
-
-// Specifies if T has an enabled formatter specialization. A type can be
-// formattable even if it doesn't have a formatter e.g. via a conversion.
-template <typename T, typename Context>
-using has_formatter =
-    std::is_constructible<typename Context::template formatter_type<T>>;
-
-// An output iterator that appends to a buffer.
-// It is used to reduce symbol sizes for the common case.
-class appender : public std::back_insert_iterator<detail::buffer<char>> {
-  using base = std::back_insert_iterator<detail::buffer<char>>;
-
- public:
-  using std::back_insert_iterator<detail::buffer<char>>::back_insert_iterator;
-  appender(base it) noexcept : base(it) {}
-  FMT_UNCHECKED_ITERATOR(appender);
-
-  auto operator++() noexcept -> appender& { return *this; }
-  auto operator++(int) noexcept -> appender { return *this; }
-};
-
-namespace detail {
-
-template <typename Context, typename T>
-constexpr auto has_const_formatter_impl(T*)
-    -> decltype(typename Context::template formatter_type<T>().format(
-                    std::declval<const T&>(), std::declval<Context&>()),
-                true) {
-  return true;
-}
-template <typename Context>
-constexpr auto has_const_formatter_impl(...) -> bool {
-  return false;
-}
-template <typename T, typename Context>
-constexpr auto has_const_formatter() -> bool {
-  return has_const_formatter_impl<Context>(static_cast<T*>(nullptr));
-}
-
-template <typename T>
-using buffer_appender = conditional_t<std::is_same<T, char>::value, appender,
-                                      std::back_insert_iterator<buffer<T>>>;
-
-// Maps an output iterator to a buffer.
-template <typename T, typename OutputIt>
-auto get_buffer(OutputIt out) -> iterator_buffer<OutputIt, T> {
-  return iterator_buffer<OutputIt, T>(out);
-}
-template <typename T, typename Buf,
-          FMT_ENABLE_IF(std::is_base_of<buffer<char>, Buf>::value)>
-auto get_buffer(std::back_insert_iterator<Buf> out) -> buffer<char>& {
-  return get_container(out);
-}
-
-template <typename Buf, typename OutputIt>
-FMT_INLINE auto get_iterator(Buf& buf, OutputIt) -> decltype(buf.out()) {
-  return buf.out();
-}
-template <typename T, typename OutputIt>
-auto get_iterator(buffer<T>&, OutputIt out) -> OutputIt {
-  return out;
-}
-
-struct view {};
-
-template <typename Char, typename T> struct named_arg : view {
-  const Char* name;
-  const T& value;
-  named_arg(const Char* n, const T& v) : name(n), value(v) {}
-};
-
-template <typename Char> struct named_arg_info {
-  const Char* name;
-  int id;
-};
-
-template <typename T, typename Char, size_t NUM_ARGS, size_t NUM_NAMED_ARGS>
-struct arg_data {
-  // args_[0].named_args points to named_args_ to avoid bloating format_args.
-  // +1 to workaround a bug in gcc 7.5 that causes duplicated-branches warning.
-  T args_[1 + (NUM_ARGS != 0 ? NUM_ARGS : +1)];
-  named_arg_info<Char> named_args_[NUM_NAMED_ARGS];
-
-  template <typename... U>
-  arg_data(const U&... init) : args_{T(named_args_, NUM_NAMED_ARGS), init...} {}
-  arg_data(const arg_data& other) = delete;
-  auto args() const -> const T* { return args_ + 1; }
-  auto named_args() -> named_arg_info<Char>* { return named_args_; }
-};
-
-template <typename T, typename Char, size_t NUM_ARGS>
-struct arg_data<T, Char, NUM_ARGS, 0> {
-  // +1 to workaround a bug in gcc 7.5 that causes duplicated-branches warning.
-  T args_[NUM_ARGS != 0 ? NUM_ARGS : +1];
-
-  template <typename... U>
-  FMT_CONSTEXPR FMT_INLINE arg_data(const U&... init) : args_{init...} {}
-  FMT_CONSTEXPR FMT_INLINE auto args() const -> const T* { return args_; }
-  FMT_CONSTEXPR FMT_INLINE auto named_args() -> std::nullptr_t {
-    return nullptr;
-  }
-};
-
-template <typename Char>
-inline void init_named_args(named_arg_info<Char>*, int, int) {}
-
-template <typename T> struct is_named_arg : std::false_type {};
-template <typename T> struct is_statically_named_arg : std::false_type {};
-
-template <typename T, typename Char>
-struct is_named_arg<named_arg<Char, T>> : std::true_type {};
-
-template <typename Char, typename T, typename... Tail,
-          FMT_ENABLE_IF(!is_named_arg<T>::value)>
-void init_named_args(named_arg_info<Char>* named_args, int arg_count,
-                     int named_arg_count, const T&, const Tail&... args) {
-  init_named_args(named_args, arg_count + 1, named_arg_count, args...);
-}
-
-template <typename Char, typename T, typename... Tail,
-          FMT_ENABLE_IF(is_named_arg<T>::value)>
-void init_named_args(named_arg_info<Char>* named_args, int arg_count,
-                     int named_arg_count, const T& arg, const Tail&... args) {
-  named_args[named_arg_count++] = {arg.name, arg_count};
-  init_named_args(named_args, arg_count + 1, named_arg_count, args...);
-}
-
-template <typename... Args>
-FMT_CONSTEXPR FMT_INLINE void init_named_args(std::nullptr_t, int, int,
-                                              const Args&...) {}
-
-template <bool B = false> constexpr auto count() -> size_t { return B ? 1 : 0; }
-template <bool B1, bool B2, bool... Tail> constexpr auto count() -> size_t {
-  return (B1 ? 1 : 0) + count<B2, Tail...>();
-}
-
-template <typename... Args> constexpr auto count_named_args() -> size_t {
-  return count<is_named_arg<Args>::value...>();
-}
-
-template <typename... Args>
-constexpr auto count_statically_named_args() -> size_t {
-  return count<is_statically_named_arg<Args>::value...>();
-}
-
-struct unformattable {};
-struct unformattable_char : unformattable {};
-struct unformattable_pointer : unformattable {};
-
-template <typename Char> struct string_value {
-  const Char* data;
-  size_t size;
-};
-
-template <typename Char> struct named_arg_value {
-  const named_arg_info<Char>* data;
-  size_t size;
-};
-
-template <typename Context> struct custom_value {
-  using parse_context = typename Context::parse_context_type;
-  void* value;
-  void (*format)(void* arg, parse_context& parse_ctx, Context& ctx);
-};
-
-// A formatting argument value.
-template <typename Context> class value {
- public:
-  using char_type = typename Context::char_type;
-
-  union {
-    monostate no_value;
-    int int_value;
-    unsigned uint_value;
-    long long long_long_value;
-    unsigned long long ulong_long_value;
-    int128_opt int128_value;
-    uint128_opt uint128_value;
-    bool bool_value;
-    char_type char_value;
-    float float_value;
-    double double_value;
-    long double long_double_value;
-    const void* pointer;
-    string_value<char_type> string;
-    custom_value<Context> custom;
-    named_arg_value<char_type> named_args;
-  };
-
-  constexpr FMT_INLINE value() : no_value() {}
-  constexpr FMT_INLINE value(int val) : int_value(val) {}
-  constexpr FMT_INLINE value(unsigned val) : uint_value(val) {}
-  constexpr FMT_INLINE value(long long val) : long_long_value(val) {}
-  constexpr FMT_INLINE value(unsigned long long val) : ulong_long_value(val) {}
-  FMT_INLINE value(int128_opt val) : int128_value(val) {}
-  FMT_INLINE value(uint128_opt val) : uint128_value(val) {}
-  constexpr FMT_INLINE value(float val) : float_value(val) {}
-  constexpr FMT_INLINE value(double val) : double_value(val) {}
-  FMT_INLINE value(long double val) : long_double_value(val) {}
-  constexpr FMT_INLINE value(bool val) : bool_value(val) {}
-  constexpr FMT_INLINE value(char_type val) : char_value(val) {}
-  FMT_CONSTEXPR FMT_INLINE value(const char_type* val) {
-    string.data = val;
-    if (is_constant_evaluated()) string.size = {};
-  }
-  FMT_CONSTEXPR FMT_INLINE value(basic_string_view<char_type> val) {
-    string.data = val.data();
-    string.size = val.size();
-  }
-  FMT_INLINE value(const void* val) : pointer(val) {}
-  FMT_INLINE value(const named_arg_info<char_type>* args, size_t size)
-      : named_args{args, size} {}
-
-  template <typename T> FMT_CONSTEXPR20 FMT_INLINE value(T& val) {
-    using value_type = remove_const_t<T>;
-    custom.value = const_cast<value_type*>(std::addressof(val));
-    // Get the formatter type through the context to allow different contexts
-    // have different extension points, e.g. `formatter<T>` for `format` and
-    // `printf_formatter<T>` for `printf`.
-    custom.format = format_custom_arg<
-        value_type, typename Context::template formatter_type<value_type>>;
-  }
-  value(unformattable);
-  value(unformattable_char);
-  value(unformattable_pointer);
-
- private:
-  // Formats an argument of a custom type, such as a user-defined class.
-  template <typename T, typename Formatter>
-  static void format_custom_arg(void* arg,
-                                typename Context::parse_context_type& parse_ctx,
-                                Context& ctx) {
-    auto f = Formatter();
-    parse_ctx.advance_to(f.parse(parse_ctx));
-    using qualified_type =
-        conditional_t<has_const_formatter<T, Context>(), const T, T>;
-    // Calling format through a mutable reference is deprecated.
-    ctx.advance_to(f.format(*static_cast<qualified_type*>(arg), ctx));
-  }
-};
-
-// To minimize the number of types we need to deal with, long is translated
-// either to int or to long long depending on its size.
-enum { long_short = sizeof(long) == sizeof(int) };
-using long_type = conditional_t<long_short, int, long long>;
-using ulong_type = conditional_t<long_short, unsigned, unsigned long long>;
-
-template <typename T> struct format_as_result {
-  template <typename U,
-            FMT_ENABLE_IF(std::is_enum<U>::value || std::is_class<U>::value)>
-  static auto map(U*) -> remove_cvref_t<decltype(format_as(std::declval<U>()))>;
-  static auto map(...) -> void;
-
-  using type = decltype(map(static_cast<T*>(nullptr)));
-};
-template <typename T> using format_as_t = typename format_as_result<T>::type;
-
-template <typename T>
-struct has_format_as
-    : bool_constant<!std::is_same<format_as_t<T>, void>::value> {};
-
-// Maps formatting arguments to core types.
-// arg_mapper reports errors by returning unformattable instead of using
-// static_assert because it's used in the is_formattable trait.
-template <typename Context> struct arg_mapper {
-  using char_type = typename Context::char_type;
-
-  FMT_CONSTEXPR FMT_INLINE auto map(signed char val) -> int { return val; }
-  FMT_CONSTEXPR FMT_INLINE auto map(unsigned char val) -> unsigned {
-    return val;
-  }
-  FMT_CONSTEXPR FMT_INLINE auto map(short val) -> int { return val; }
-  FMT_CONSTEXPR FMT_INLINE auto map(unsigned short val) -> unsigned {
-    return val;
-  }
-  FMT_CONSTEXPR FMT_INLINE auto map(int val) -> int { return val; }
-  FMT_CONSTEXPR FMT_INLINE auto map(unsigned val) -> unsigned { return val; }
-  FMT_CONSTEXPR FMT_INLINE auto map(long val) -> long_type { return val; }
-  FMT_CONSTEXPR FMT_INLINE auto map(unsigned long val) -> ulong_type {
-    return val;
-  }
-  FMT_CONSTEXPR FMT_INLINE auto map(long long val) -> long long { return val; }
-  FMT_CONSTEXPR FMT_INLINE auto map(unsigned long long val)
-      -> unsigned long long {
-    return val;
-  }
-  FMT_CONSTEXPR FMT_INLINE auto map(int128_opt val) -> int128_opt {
-    return val;
-  }
-  FMT_CONSTEXPR FMT_INLINE auto map(uint128_opt val) -> uint128_opt {
-    return val;
-  }
-  FMT_CONSTEXPR FMT_INLINE auto map(bool val) -> bool { return val; }
-
-  template <typename T, FMT_ENABLE_IF(std::is_same<T, char>::value ||
-                                      std::is_same<T, char_type>::value)>
-  FMT_CONSTEXPR FMT_INLINE auto map(T val) -> char_type {
-    return val;
-  }
-  template <typename T, enable_if_t<(std::is_same<T, wchar_t>::value ||
-#ifdef __cpp_char8_t
-                                     std::is_same<T, char8_t>::value ||
-#endif
-                                     std::is_same<T, char16_t>::value ||
-                                     std::is_same<T, char32_t>::value) &&
-                                        !std::is_same<T, char_type>::value,
-                                    int> = 0>
-  FMT_CONSTEXPR FMT_INLINE auto map(T) -> unformattable_char {
-    return {};
-  }
-
-  FMT_CONSTEXPR FMT_INLINE auto map(float val) -> float { return val; }
-  FMT_CONSTEXPR FMT_INLINE auto map(double val) -> double { return val; }
-  FMT_CONSTEXPR FMT_INLINE auto map(long double val) -> long double {
-    return val;
-  }
-
-  FMT_CONSTEXPR FMT_INLINE auto map(char_type* val) -> const char_type* {
-    return val;
-  }
-  FMT_CONSTEXPR FMT_INLINE auto map(const char_type* val) -> const char_type* {
-    return val;
-  }
-  template <typename T,
-            FMT_ENABLE_IF(is_string<T>::value && !std::is_pointer<T>::value &&
-                          std::is_same<char_type, char_t<T>>::value)>
-  FMT_CONSTEXPR FMT_INLINE auto map(const T& val)
-      -> basic_string_view<char_type> {
-    return to_string_view(val);
-  }
-  template <typename T,
-            FMT_ENABLE_IF(is_string<T>::value && !std::is_pointer<T>::value &&
-                          !std::is_same<char_type, char_t<T>>::value)>
-  FMT_CONSTEXPR FMT_INLINE auto map(const T&) -> unformattable_char {
-    return {};
-  }
-
-  FMT_CONSTEXPR FMT_INLINE auto map(void* val) -> const void* { return val; }
-  FMT_CONSTEXPR FMT_INLINE auto map(const void* val) -> const void* {
-    return val;
-  }
-  FMT_CONSTEXPR FMT_INLINE auto map(std::nullptr_t val) -> const void* {
-    return val;
-  }
-
-  // Use SFINAE instead of a const T* parameter to avoid a conflict with the
-  // array overload.
-  template <
-      typename T,
-      FMT_ENABLE_IF(
-          std::is_pointer<T>::value || std::is_member_pointer<T>::value ||
-          std::is_function<typename std::remove_pointer<T>::type>::value ||
-          (std::is_array<T>::value &&
-           !std::is_convertible<T, const char_type*>::value))>
-  FMT_CONSTEXPR auto map(const T&) -> unformattable_pointer {
-    return {};
-  }
-
-  template <typename T, std::size_t N,
-            FMT_ENABLE_IF(!std::is_same<T, wchar_t>::value)>
-  FMT_CONSTEXPR FMT_INLINE auto map(const T (&values)[N]) -> const T (&)[N] {
-    return values;
-  }
-
-  // Only map owning types because mapping views can be unsafe.
-  template <typename T, typename U = format_as_t<T>,
-            FMT_ENABLE_IF(std::is_arithmetic<U>::value)>
-  FMT_CONSTEXPR FMT_INLINE auto map(const T& val)
-      -> decltype(FMT_DECLTYPE_THIS map(U())) {
-    return map(format_as(val));
-  }
-
-  template <typename T, typename U = remove_const_t<T>>
-  struct formattable : bool_constant<has_const_formatter<U, Context>() ||
-                                     (has_formatter<U, Context>::value &&
-                                      !std::is_const<T>::value)> {};
-
-  template <typename T, FMT_ENABLE_IF(formattable<T>::value)>
-  FMT_CONSTEXPR FMT_INLINE auto do_map(T& val) -> T& {
-    return val;
-  }
-  template <typename T, FMT_ENABLE_IF(!formattable<T>::value)>
-  FMT_CONSTEXPR FMT_INLINE auto do_map(T&) -> unformattable {
-    return {};
-  }
-
-  template <typename T, typename U = remove_const_t<T>,
-            FMT_ENABLE_IF((std::is_class<U>::value || std::is_enum<U>::value ||
-                           std::is_union<U>::value) &&
-                          !is_string<U>::value && !is_char<U>::value &&
-                          !is_named_arg<U>::value &&
-                          !std::is_arithmetic<format_as_t<U>>::value)>
-  FMT_CONSTEXPR FMT_INLINE auto map(T& val)
-      -> decltype(FMT_DECLTYPE_THIS do_map(val)) {
-    return do_map(val);
-  }
-
-  template <typename T, FMT_ENABLE_IF(is_named_arg<T>::value)>
-  FMT_CONSTEXPR FMT_INLINE auto map(const T& named_arg)
-      -> decltype(FMT_DECLTYPE_THIS map(named_arg.value)) {
-    return map(named_arg.value);
-  }
-
-  auto map(...) -> unformattable { return {}; }
-};
-
-// A type constant after applying arg_mapper<Context>.
-template <typename T, typename Context>
-using mapped_type_constant =
-    type_constant<decltype(arg_mapper<Context>().map(std::declval<const T&>())),
-                  typename Context::char_type>;
-
-enum { packed_arg_bits = 4 };
-// Maximum number of arguments with packed types.
-enum { max_packed_args = 62 / packed_arg_bits };
-enum : unsigned long long { is_unpacked_bit = 1ULL << 63 };
-enum : unsigned long long { has_named_args_bit = 1ULL << 62 };
-
-template <typename Char, typename InputIt>
-auto copy_str(InputIt begin, InputIt end, appender out) -> appender {
-  get_container(out).append(begin, end);
-  return out;
-}
-template <typename Char, typename InputIt>
-auto copy_str(InputIt begin, InputIt end,
-              std::back_insert_iterator<std::string> out)
-    -> std::back_insert_iterator<std::string> {
-  get_container(out).append(begin, end);
-  return out;
-}
-
-template <typename Char, typename R, typename OutputIt>
-FMT_CONSTEXPR auto copy_str(R&& rng, OutputIt out) -> OutputIt {
-  return detail::copy_str<Char>(rng.begin(), rng.end(), out);
-}
-
-#if FMT_GCC_VERSION && FMT_GCC_VERSION < 500
-// A workaround for gcc 4.8 to make void_t work in a SFINAE context.
-template <typename...> struct void_t_impl {
-  using type = void;
-};
-template <typename... T> using void_t = typename void_t_impl<T...>::type;
-#else
-template <typename...> using void_t = void;
-#endif
-
-template <typename It, typename T, typename Enable = void>
-struct is_output_iterator : std::false_type {};
-
-template <typename It, typename T>
-struct is_output_iterator<
-    It, T,
-    void_t<typename std::iterator_traits<It>::iterator_category,
-           decltype(*std::declval<It>() = std::declval<T>())>>
-    : std::true_type {};
-
-template <typename It> struct is_back_insert_iterator : std::false_type {};
-template <typename Container>
-struct is_back_insert_iterator<std::back_insert_iterator<Container>>
-    : std::true_type {};
-
-// A type-erased reference to an std::locale to avoid a heavy <locale> include.
-class locale_ref {
- private:
-  const void* locale_;  // A type-erased pointer to std::locale.
-
- public:
-  constexpr FMT_INLINE locale_ref() : locale_(nullptr) {}
-  template <typename Locale> explicit locale_ref(const Locale& loc);
-
-  explicit operator bool() const noexcept { return locale_ != nullptr; }
-
-  template <typename Locale> auto get() const -> Locale;
-};
-
-template <typename> constexpr auto encode_types() -> unsigned long long {
-  return 0;
-}
-
-template <typename Context, typename Arg, typename... Args>
-constexpr auto encode_types() -> unsigned long long {
-  return static_cast<unsigned>(mapped_type_constant<Arg, Context>::value) |
-         (encode_types<Context, Args...>() << packed_arg_bits);
-}
-
-#if defined(__cpp_if_constexpr)
-// This type is intentionally undefined, only used for errors
-template <typename T, typename Char> struct type_is_unformattable_for;
-#endif
-
-template <bool PACKED, typename Context, typename T, FMT_ENABLE_IF(PACKED)>
-FMT_CONSTEXPR FMT_INLINE auto make_arg(T& val) -> value<Context> {
-  using arg_type = remove_cvref_t<decltype(arg_mapper<Context>().map(val))>;
-
-  constexpr bool formattable_char =
-      !std::is_same<arg_type, unformattable_char>::value;
-  static_assert(formattable_char, "Mixing character types is disallowed.");
-
-  // Formatting of arbitrary pointers is disallowed. If you want to format a
-  // pointer cast it to `void*` or `const void*`. In particular, this forbids
-  // formatting of `[const] volatile char*` printed as bool by iostreams.
-  constexpr bool formattable_pointer =
-      !std::is_same<arg_type, unformattable_pointer>::value;
-  static_assert(formattable_pointer,
-                "Formatting of non-void pointers is disallowed.");
-
-  constexpr bool formattable = !std::is_same<arg_type, unformattable>::value;
-#if defined(__cpp_if_constexpr)
-  if constexpr (!formattable) {
-    type_is_unformattable_for<T, typename Context::char_type> _;
-  }
-#endif
-  static_assert(
-      formattable,
-      "Cannot format an argument. To make type T formattable provide a "
-      "formatter<T> specialization: https://fmt.dev/latest/api.html#udt");
-  return {arg_mapper<Context>().map(val)};
-}
-
-template <typename Context, typename T>
-FMT_CONSTEXPR auto make_arg(T& val) -> basic_format_arg<Context> {
-  auto arg = basic_format_arg<Context>();
-  arg.type_ = mapped_type_constant<T, Context>::value;
-  arg.value_ = make_arg<true, Context>(val);
-  return arg;
-}
-
-template <bool PACKED, typename Context, typename T, FMT_ENABLE_IF(!PACKED)>
-FMT_CONSTEXPR inline auto make_arg(T& val) -> basic_format_arg<Context> {
-  return make_arg<Context>(val);
-}
-}  // namespace detail
-FMT_BEGIN_EXPORT
-
-// A formatting argument. Context is a template parameter for the compiled API
-// where output can be unbuffered.
-template <typename Context> class basic_format_arg {
- private:
-  detail::value<Context> value_;
-  detail::type type_;
-
-  template <typename ContextType, typename T>
-  friend FMT_CONSTEXPR auto detail::make_arg(T& value)
-      -> basic_format_arg<ContextType>;
-
-  template <typename Visitor, typename Ctx>
-  friend FMT_CONSTEXPR auto visit_format_arg(Visitor&& vis,
-                                             const basic_format_arg<Ctx>& arg)
-      -> decltype(vis(0));
-
-  friend class basic_format_args<Context>;
-  friend class dynamic_format_arg_store<Context>;
-
-  using char_type = typename Context::char_type;
-
-  template <typename T, typename Char, size_t NUM_ARGS, size_t NUM_NAMED_ARGS>
-  friend struct detail::arg_data;
-
-  basic_format_arg(const detail::named_arg_info<char_type>* args, size_t size)
-      : value_(args, size) {}
-
- public:
-  class handle {
-   public:
-    explicit handle(detail::custom_value<Context> custom) : custom_(custom) {}
-
-    void format(typename Context::parse_context_type& parse_ctx,
-                Context& ctx) const {
-      custom_.format(custom_.value, parse_ctx, ctx);
-    }
-
-   private:
-    detail::custom_value<Context> custom_;
-  };
-
-  constexpr basic_format_arg() : type_(detail::type::none_type) {}
-
-  constexpr explicit operator bool() const noexcept {
-    return type_ != detail::type::none_type;
-  }
-
-  auto type() const -> detail::type { return type_; }
-
-  auto is_integral() const -> bool { return detail::is_integral_type(type_); }
-  auto is_arithmetic() const -> bool {
-    return detail::is_arithmetic_type(type_);
-  }
-
-  FMT_INLINE auto format_custom(const char_type* parse_begin,
-                                typename Context::parse_context_type& parse_ctx,
-                                Context& ctx) -> bool {
-    if (type_ != detail::type::custom_type) return false;
-    parse_ctx.advance_to(parse_begin);
-    value_.custom.format(value_.custom.value, parse_ctx, ctx);
-    return true;
-  }
-};
-
-/**
-  \rst
-  Visits an argument dispatching to the appropriate visit method based on
-  the argument type. For example, if the argument type is ``double`` then
-  ``vis(value)`` will be called with the value of type ``double``.
-  \endrst
- */
-// DEPRECATED!
-template <typename Visitor, typename Context>
-FMT_CONSTEXPR FMT_INLINE auto visit_format_arg(
-    Visitor&& vis, const basic_format_arg<Context>& arg) -> decltype(vis(0)) {
-  switch (arg.type_) {
-  case detail::type::none_type:
-    break;
-  case detail::type::int_type:
-    return vis(arg.value_.int_value);
-  case detail::type::uint_type:
-    return vis(arg.value_.uint_value);
-  case detail::type::long_long_type:
-    return vis(arg.value_.long_long_value);
-  case detail::type::ulong_long_type:
-    return vis(arg.value_.ulong_long_value);
-  case detail::type::int128_type:
-    return vis(detail::convert_for_visit(arg.value_.int128_value));
-  case detail::type::uint128_type:
-    return vis(detail::convert_for_visit(arg.value_.uint128_value));
-  case detail::type::bool_type:
-    return vis(arg.value_.bool_value);
-  case detail::type::char_type:
-    return vis(arg.value_.char_value);
-  case detail::type::float_type:
-    return vis(arg.value_.float_value);
-  case detail::type::double_type:
-    return vis(arg.value_.double_value);
-  case detail::type::long_double_type:
-    return vis(arg.value_.long_double_value);
-  case detail::type::cstring_type:
-    return vis(arg.value_.string.data);
-  case detail::type::string_type:
-    using sv = basic_string_view<typename Context::char_type>;
-    return vis(sv(arg.value_.string.data, arg.value_.string.size));
-  case detail::type::pointer_type:
-    return vis(arg.value_.pointer);
-  case detail::type::custom_type:
-    return vis(typename basic_format_arg<Context>::handle(arg.value_.custom));
-  }
-  return vis(monostate());
-}
-
-// Formatting context.
-template <typename OutputIt, typename Char> class basic_format_context {
- private:
-  OutputIt out_;
-  basic_format_args<basic_format_context> args_;
-  detail::locale_ref loc_;
-
- public:
-  using iterator = OutputIt;
-  using format_arg = basic_format_arg<basic_format_context>;
-  using format_args = basic_format_args<basic_format_context>;
-  using parse_context_type = basic_format_parse_context<Char>;
-  template <typename T> using formatter_type = formatter<T, Char>;
-
-  /** The character type for the output. */
-  using char_type = Char;
-
-  basic_format_context(basic_format_context&&) = default;
-  basic_format_context(const basic_format_context&) = delete;
-  void operator=(const basic_format_context&) = delete;
-  /**
-    Constructs a ``basic_format_context`` object. References to the arguments
-    are stored in the object so make sure they have appropriate lifetimes.
-   */
-  constexpr basic_format_context(OutputIt out, format_args ctx_args,
-                                 detail::locale_ref loc = {})
-      : out_(out), args_(ctx_args), loc_(loc) {}
-
-  constexpr auto arg(int id) const -> format_arg { return args_.get(id); }
-  FMT_CONSTEXPR auto arg(basic_string_view<Char> name) -> format_arg {
-    return args_.get(name);
-  }
-  FMT_CONSTEXPR auto arg_id(basic_string_view<Char> name) -> int {
-    return args_.get_id(name);
-  }
-  auto args() const -> const format_args& { return args_; }
-
-  // DEPRECATED!
-  FMT_CONSTEXPR auto error_handler() -> detail::error_handler { return {}; }
-  void on_error(const char* message) { error_handler().on_error(message); }
-
-  // Returns an iterator to the beginning of the output range.
-  FMT_CONSTEXPR auto out() -> iterator { return out_; }
-
-  // Advances the begin iterator to ``it``.
-  void advance_to(iterator it) {
-    if (!detail::is_back_insert_iterator<iterator>()) out_ = it;
-  }
-
-  FMT_CONSTEXPR auto locale() -> detail::locale_ref { return loc_; }
-};
-
-template <typename Char>
-using buffer_context =
-    basic_format_context<detail::buffer_appender<Char>, Char>;
-using format_context = buffer_context<char>;
-
-template <typename T, typename Char = char>
-using is_formattable = bool_constant<!std::is_base_of<
-    detail::unformattable, decltype(detail::arg_mapper<buffer_context<Char>>()
-                                        .map(std::declval<T&>()))>::value>;
-
-/**
-  \rst
-  An array of references to arguments. It can be implicitly converted into
-  `~fmt::basic_format_args` for passing into type-erased formatting functions
-  such as `~fmt::vformat`.
-  \endrst
- */
-template <typename Context, typename... Args>
-class format_arg_store
-#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
-    // Workaround a GCC template argument substitution bug.
-    : public basic_format_args<Context>
-#endif
-{
- private:
-  static const size_t num_args = sizeof...(Args);
-  static constexpr size_t num_named_args = detail::count_named_args<Args...>();
-  static const bool is_packed = num_args <= detail::max_packed_args;
-
-  using value_type = conditional_t<is_packed, detail::value<Context>,
-                                   basic_format_arg<Context>>;
-
-  detail::arg_data<value_type, typename Context::char_type, num_args,
-                   num_named_args>
-      data_;
-
-  friend class basic_format_args<Context>;
-
-  static constexpr unsigned long long desc =
-      (is_packed ? detail::encode_types<Context, Args...>()
-                 : detail::is_unpacked_bit | num_args) |
-      (num_named_args != 0
-           ? static_cast<unsigned long long>(detail::has_named_args_bit)
-           : 0);
-
- public:
-  template <typename... T>
-  FMT_CONSTEXPR FMT_INLINE format_arg_store(T&... args)
-      :
-#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
-        basic_format_args<Context>(*this),
-#endif
-        data_{detail::make_arg<is_packed, Context>(args)...} {
-    if (detail::const_check(num_named_args != 0))
-      detail::init_named_args(data_.named_args(), 0, 0, args...);
-  }
-};
-
-/**
-  \rst
-  Constructs a `~fmt::format_arg_store` object that contains references to
-  arguments and can be implicitly converted to `~fmt::format_args`. `Context`
-  can be omitted in which case it defaults to `~fmt::format_context`.
-  See `~fmt::arg` for lifetime considerations.
-  \endrst
- */
-// Arguments are taken by lvalue references to avoid some lifetime issues.
-template <typename Context = format_context, typename... T>
-constexpr auto make_format_args(T&... args)
-    -> format_arg_store<Context, remove_cvref_t<T>...> {
-  return {args...};
-}
-
-/**
-  \rst
-  Returns a named argument to be used in a formatting function.
-  It should only be used in a call to a formatting function or
-  `dynamic_format_arg_store::push_back`.
-
-  **Example**::
-
-    fmt::print("Elapsed time: {s:.2f} seconds", fmt::arg("s", 1.23));
-  \endrst
- */
-template <typename Char, typename T>
-inline auto arg(const Char* name, const T& arg) -> detail::named_arg<Char, T> {
-  static_assert(!detail::is_named_arg<T>(), "nested named arguments");
-  return {name, arg};
-}
-FMT_END_EXPORT
-
-/**
-  \rst
-  A view of a collection of formatting arguments. To avoid lifetime issues it
-  should only be used as a parameter type in type-erased functions such as
-  ``vformat``::
-
-    void vlog(string_view format_str, format_args args);  // OK
-    format_args args = make_format_args();  // Error: dangling reference
-  \endrst
- */
-template <typename Context> class basic_format_args {
- public:
-  using size_type = int;
-  using format_arg = basic_format_arg<Context>;
-
- private:
-  // A descriptor that contains information about formatting arguments.
-  // If the number of arguments is less or equal to max_packed_args then
-  // argument types are passed in the descriptor. This reduces binary code size
-  // per formatting function call.
-  unsigned long long desc_;
-  union {
-    // If is_packed() returns true then argument values are stored in values_;
-    // otherwise they are stored in args_. This is done to improve cache
-    // locality and reduce compiled code size since storing larger objects
-    // may require more code (at least on x86-64) even if the same amount of
-    // data is actually copied to stack. It saves ~10% on the bloat test.
-    const detail::value<Context>* values_;
-    const format_arg* args_;
-  };
-
-  constexpr auto is_packed() const -> bool {
-    return (desc_ & detail::is_unpacked_bit) == 0;
-  }
-  auto has_named_args() const -> bool {
-    return (desc_ & detail::has_named_args_bit) != 0;
-  }
-
-  FMT_CONSTEXPR auto type(int index) const -> detail::type {
-    int shift = index * detail::packed_arg_bits;
-    unsigned int mask = (1 << detail::packed_arg_bits) - 1;
-    return static_cast<detail::type>((desc_ >> shift) & mask);
-  }
-
-  constexpr FMT_INLINE basic_format_args(unsigned long long desc,
-                                         const detail::value<Context>* values)
-      : desc_(desc), values_(values) {}
-  constexpr basic_format_args(unsigned long long desc, const format_arg* args)
-      : desc_(desc), args_(args) {}
-
- public:
-  constexpr basic_format_args() : desc_(0), args_(nullptr) {}
-
-  /**
-   \rst
-   Constructs a `basic_format_args` object from `~fmt::format_arg_store`.
-   \endrst
-   */
-  template <typename... Args>
-  constexpr FMT_INLINE basic_format_args(
-      const format_arg_store<Context, Args...>& store)
-      : basic_format_args(format_arg_store<Context, Args...>::desc,
-                          store.data_.args()) {}
-
-  /**
-   \rst
-   Constructs a `basic_format_args` object from
-   `~fmt::dynamic_format_arg_store`.
-   \endrst
-   */
-  constexpr FMT_INLINE basic_format_args(
-      const dynamic_format_arg_store<Context>& store)
-      : basic_format_args(store.get_types(), store.data()) {}
-
-  /**
-   \rst
-   Constructs a `basic_format_args` object from a dynamic set of arguments.
-   \endrst
-   */
-  constexpr basic_format_args(const format_arg* args, int count)
-      : basic_format_args(detail::is_unpacked_bit | detail::to_unsigned(count),
-                          args) {}
-
-  /** Returns the argument with the specified id. */
-  FMT_CONSTEXPR auto get(int id) const -> format_arg {
-    format_arg arg;
-    if (!is_packed()) {
-      if (id < max_size()) arg = args_[id];
-      return arg;
-    }
-    if (id >= detail::max_packed_args) return arg;
-    arg.type_ = type(id);
-    if (arg.type_ == detail::type::none_type) return arg;
-    arg.value_ = values_[id];
-    return arg;
-  }
-
-  template <typename Char>
-  auto get(basic_string_view<Char> name) const -> format_arg {
-    int id = get_id(name);
-    return id >= 0 ? get(id) : format_arg();
-  }
-
-  template <typename Char>
-  auto get_id(basic_string_view<Char> name) const -> int {
-    if (!has_named_args()) return -1;
-    const auto& named_args =
-        (is_packed() ? values_[-1] : args_[-1].value_).named_args;
-    for (size_t i = 0; i < named_args.size; ++i) {
-      if (named_args.data[i].name == name) return named_args.data[i].id;
-    }
-    return -1;
-  }
-
-  auto max_size() const -> int {
-    unsigned long long max_packed = detail::max_packed_args;
-    return static_cast<int>(is_packed() ? max_packed
-                                        : desc_ & ~detail::is_unpacked_bit);
-  }
-};
-
-/** An alias to ``basic_format_args<format_context>``. */
-// A separate type would result in shorter symbols but break ABI compatibility
-// between clang and gcc on ARM (#1919).
-FMT_EXPORT using format_args = basic_format_args<format_context>;
-
-// We cannot use enum classes as bit fields because of a gcc bug, so we put them
-// in namespaces instead (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61414).
-// Additionally, if an underlying type is specified, older gcc incorrectly warns
-// that the type is too small. Both bugs are fixed in gcc 9.3.
-#if FMT_GCC_VERSION && FMT_GCC_VERSION < 903
-#  define FMT_ENUM_UNDERLYING_TYPE(type)
-#else
-#  define FMT_ENUM_UNDERLYING_TYPE(type) : type
-#endif
-namespace align {
-enum type FMT_ENUM_UNDERLYING_TYPE(unsigned char){none, left, right, center,
-                                                  numeric};
-}
-using align_t = align::type;
-namespace sign {
-enum type FMT_ENUM_UNDERLYING_TYPE(unsigned char){none, minus, plus, space};
-}
-using sign_t = sign::type;
-
-namespace detail {
-
-// Workaround an array initialization issue in gcc 4.8.
-template <typename Char> struct fill_t {
- private:
-  enum { max_size = 4 };
-  Char data_[max_size] = {Char(' '), Char(0), Char(0), Char(0)};
-  unsigned char size_ = 1;
-
- public:
-  FMT_CONSTEXPR void operator=(basic_string_view<Char> s) {
-    auto size = s.size();
-    FMT_ASSERT(size <= max_size, "invalid fill");
-    for (size_t i = 0; i < size; ++i) data_[i] = s[i];
-    size_ = static_cast<unsigned char>(size);
-  }
-
-  constexpr auto size() const -> size_t { return size_; }
-  constexpr auto data() const -> const Char* { return data_; }
-
-  FMT_CONSTEXPR auto operator[](size_t index) -> Char& { return data_[index]; }
-  FMT_CONSTEXPR auto operator[](size_t index) const -> const Char& {
-    return data_[index];
-  }
-};
-}  // namespace detail
-
-enum class presentation_type : unsigned char {
-  none,
-  dec,             // 'd'
-  oct,             // 'o'
-  hex_lower,       // 'x'
-  hex_upper,       // 'X'
-  bin_lower,       // 'b'
-  bin_upper,       // 'B'
-  hexfloat_lower,  // 'a'
-  hexfloat_upper,  // 'A'
-  exp_lower,       // 'e'
-  exp_upper,       // 'E'
-  fixed_lower,     // 'f'
-  fixed_upper,     // 'F'
-  general_lower,   // 'g'
-  general_upper,   // 'G'
-  chr,             // 'c'
-  string,          // 's'
-  pointer,         // 'p'
-  debug            // '?'
-};
-
-// Format specifiers for built-in and string types.
-template <typename Char = char> struct format_specs {
-  int width;
-  int precision;
-  presentation_type type;
-  align_t align : 4;
-  sign_t sign : 3;
-  bool alt : 1;  // Alternate form ('#').
-  bool localized : 1;
-  detail::fill_t<Char> fill;
-
-  constexpr format_specs()
-      : width(0),
-        precision(-1),
-        type(presentation_type::none),
-        align(align::none),
-        sign(sign::none),
-        alt(false),
-        localized(false) {}
-};
-
-namespace detail {
-
-enum class arg_id_kind { none, index, name };
-
-// An argument reference.
-template <typename Char> struct arg_ref {
-  FMT_CONSTEXPR arg_ref() : kind(arg_id_kind::none), val() {}
-
-  FMT_CONSTEXPR explicit arg_ref(int index)
-      : kind(arg_id_kind::index), val(index) {}
-  FMT_CONSTEXPR explicit arg_ref(basic_string_view<Char> name)
-      : kind(arg_id_kind::name), val(name) {}
-
-  FMT_CONSTEXPR auto operator=(int idx) -> arg_ref& {
-    kind = arg_id_kind::index;
-    val.index = idx;
-    return *this;
-  }
-
-  arg_id_kind kind;
-  union value {
-    FMT_CONSTEXPR value(int idx = 0) : index(idx) {}
-    FMT_CONSTEXPR value(basic_string_view<Char> n) : name(n) {}
-
-    int index;
-    basic_string_view<Char> name;
-  } val;
-};
-
-// Format specifiers with width and precision resolved at formatting rather
-// than parsing time to allow reusing the same parsed specifiers with
-// different sets of arguments (precompilation of format strings).
-template <typename Char = char>
-struct dynamic_format_specs : format_specs<Char> {
-  arg_ref<Char> width_ref;
-  arg_ref<Char> precision_ref;
-};
-
-// Converts a character to ASCII. Returns '\0' on conversion failure.
-template <typename Char, FMT_ENABLE_IF(std::is_integral<Char>::value)>
-constexpr auto to_ascii(Char c) -> char {
-  return c <= 0xff ? static_cast<char>(c) : '\0';
-}
-template <typename Char, FMT_ENABLE_IF(std::is_enum<Char>::value)>
-constexpr auto to_ascii(Char c) -> char {
-  return c <= 0xff ? static_cast<char>(c) : '\0';
-}
-
-// Returns the number of code units in a code point or 1 on error.
-template <typename Char>
-FMT_CONSTEXPR auto code_point_length(const Char* begin) -> int {
-  if (const_check(sizeof(Char) != 1)) return 1;
-  auto c = static_cast<unsigned char>(*begin);
-  return static_cast<int>((0x3a55000000000000ull >> (2 * (c >> 3))) & 0x3) + 1;
-}
-
-// Return the result via the out param to workaround gcc bug 77539.
-template <bool IS_CONSTEXPR, typename T, typename Ptr = const T*>
-FMT_CONSTEXPR auto find(Ptr first, Ptr last, T value, Ptr& out) -> bool {
-  for (out = first; out != last; ++out) {
-    if (*out == value) return true;
-  }
-  return false;
-}
-
-template <>
-inline auto find<false, char>(const char* first, const char* last, char value,
-                              const char*& out) -> bool {
-  out = static_cast<const char*>(
-      std::memchr(first, value, to_unsigned(last - first)));
-  return out != nullptr;
-}
-
-// Parses the range [begin, end) as an unsigned integer. This function assumes
-// that the range is non-empty and the first character is a digit.
-template <typename Char>
-FMT_CONSTEXPR auto parse_nonnegative_int(const Char*& begin, const Char* end,
-                                         int error_value) noexcept -> int {
-  FMT_ASSERT(begin != end && '0' <= *begin && *begin <= '9', "");
-  unsigned value = 0, prev = 0;
-  auto p = begin;
-  do {
-    prev = value;
-    value = value * 10 + unsigned(*p - '0');
-    ++p;
-  } while (p != end && '0' <= *p && *p <= '9');
-  auto num_digits = p - begin;
-  begin = p;
-  if (num_digits <= std::numeric_limits<int>::digits10)
-    return static_cast<int>(value);
-  // Check for overflow.
-  const unsigned max = to_unsigned((std::numeric_limits<int>::max)());
-  return num_digits == std::numeric_limits<int>::digits10 + 1 &&
-                 prev * 10ull + unsigned(p[-1] - '0') <= max
-             ? static_cast<int>(value)
-             : error_value;
-}
-
-FMT_CONSTEXPR inline auto parse_align(char c) -> align_t {
-  switch (c) {
-  case '<':
-    return align::left;
-  case '>':
-    return align::right;
-  case '^':
-    return align::center;
-  }
-  return align::none;
-}
-
-template <typename Char> constexpr auto is_name_start(Char c) -> bool {
-  return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '_';
-}
-
-template <typename Char, typename Handler>
-FMT_CONSTEXPR auto do_parse_arg_id(const Char* begin, const Char* end,
-                                   Handler&& handler) -> const Char* {
-  Char c = *begin;
-  if (c >= '0' && c <= '9') {
-    int index = 0;
-    constexpr int max = (std::numeric_limits<int>::max)();
-    if (c != '0')
-      index = parse_nonnegative_int(begin, end, max);
-    else
-      ++begin;
-    if (begin == end || (*begin != '}' && *begin != ':'))
-      throw_format_error("invalid format string");
-    else
-      handler.on_index(index);
-    return begin;
-  }
-  if (!is_name_start(c)) {
-    throw_format_error("invalid format string");
-    return begin;
-  }
-  auto it = begin;
-  do {
-    ++it;
-  } while (it != end && (is_name_start(*it) || ('0' <= *it && *it <= '9')));
-  handler.on_name({begin, to_unsigned(it - begin)});
-  return it;
-}
-
-template <typename Char, typename Handler>
-FMT_CONSTEXPR FMT_INLINE auto parse_arg_id(const Char* begin, const Char* end,
-                                           Handler&& handler) -> const Char* {
-  FMT_ASSERT(begin != end, "");
-  Char c = *begin;
-  if (c != '}' && c != ':') return do_parse_arg_id(begin, end, handler);
-  handler.on_auto();
-  return begin;
-}
-
-template <typename Char> struct dynamic_spec_id_handler {
-  basic_format_parse_context<Char>& ctx;
-  arg_ref<Char>& ref;
-
-  FMT_CONSTEXPR void on_auto() {
-    int id = ctx.next_arg_id();
-    ref = arg_ref<Char>(id);
-    ctx.check_dynamic_spec(id);
-  }
-  FMT_CONSTEXPR void on_index(int id) {
-    ref = arg_ref<Char>(id);
-    ctx.check_arg_id(id);
-    ctx.check_dynamic_spec(id);
-  }
-  FMT_CONSTEXPR void on_name(basic_string_view<Char> id) {
-    ref = arg_ref<Char>(id);
-    ctx.check_arg_id(id);
-  }
-};
-
-// Parses [integer | "{" [arg_id] "}"].
-template <typename Char>
-FMT_CONSTEXPR auto parse_dynamic_spec(const Char* begin, const Char* end,
-                                      int& value, arg_ref<Char>& ref,
-                                      basic_format_parse_context<Char>& ctx)
-    -> const Char* {
-  FMT_ASSERT(begin != end, "");
-  if ('0' <= *begin && *begin <= '9') {
-    int val = parse_nonnegative_int(begin, end, -1);
-    if (val != -1)
-      value = val;
-    else
-      throw_format_error("number is too big");
-  } else if (*begin == '{') {
-    ++begin;
-    auto handler = dynamic_spec_id_handler<Char>{ctx, ref};
-    if (begin != end) begin = parse_arg_id(begin, end, handler);
-    if (begin != end && *begin == '}') return ++begin;
-    throw_format_error("invalid format string");
-  }
-  return begin;
-}
-
-template <typename Char>
-FMT_CONSTEXPR auto parse_precision(const Char* begin, const Char* end,
-                                   int& value, arg_ref<Char>& ref,
-                                   basic_format_parse_context<Char>& ctx)
-    -> const Char* {
-  ++begin;
-  if (begin == end || *begin == '}') {
-    throw_format_error("invalid precision");
-    return begin;
-  }
-  return parse_dynamic_spec(begin, end, value, ref, ctx);
-}
-
-enum class state { start, align, sign, hash, zero, width, precision, locale };
-
-// Parses standard format specifiers.
-template <typename Char>
-FMT_CONSTEXPR FMT_INLINE auto parse_format_specs(
-    const Char* begin, const Char* end, dynamic_format_specs<Char>& specs,
-    basic_format_parse_context<Char>& ctx, type arg_type) -> const Char* {
-  auto c = '\0';
-  if (end - begin > 1) {
-    auto next = to_ascii(begin[1]);
-    c = parse_align(next) == align::none ? to_ascii(*begin) : '\0';
-  } else {
-    if (begin == end) return begin;
-    c = to_ascii(*begin);
-  }
-
-  struct {
-    state current_state = state::start;
-    FMT_CONSTEXPR void operator()(state s, bool valid = true) {
-      if (current_state >= s || !valid)
-        throw_format_error("invalid format specifier");
-      current_state = s;
-    }
-  } enter_state;
-
-  using pres = presentation_type;
-  constexpr auto integral_set = sint_set | uint_set | bool_set | char_set;
-  struct {
-    const Char*& begin;
-    dynamic_format_specs<Char>& specs;
-    type arg_type;
-
-    FMT_CONSTEXPR auto operator()(pres pres_type, int set) -> const Char* {
-      if (!in(arg_type, set)) {
-        if (arg_type == type::none_type) return begin;
-        throw_format_error("invalid format specifier");
-      }
-      specs.type = pres_type;
-      return begin + 1;
-    }
-  } parse_presentation_type{begin, specs, arg_type};
-
-  for (;;) {
-    switch (c) {
-    case '<':
-    case '>':
-    case '^':
-      enter_state(state::align);
-      specs.align = parse_align(c);
-      ++begin;
-      break;
-    case '+':
-    case '-':
-    case ' ':
-      if (arg_type == type::none_type) return begin;
-      enter_state(state::sign, in(arg_type, sint_set | float_set));
-      switch (c) {
-      case '+':
-        specs.sign = sign::plus;
-        break;
-      case '-':
-        specs.sign = sign::minus;
-        break;
-      case ' ':
-        specs.sign = sign::space;
-        break;
-      }
-      ++begin;
-      break;
-    case '#':
-      if (arg_type == type::none_type) return begin;
-      enter_state(state::hash, is_arithmetic_type(arg_type));
-      specs.alt = true;
-      ++begin;
-      break;
-    case '0':
-      enter_state(state::zero);
-      if (!is_arithmetic_type(arg_type)) {
-        if (arg_type == type::none_type) return begin;
-        throw_format_error("format specifier requires numeric argument");
-      }
-      if (specs.align == align::none) {
-        // Ignore 0 if align is specified for compatibility with std::format.
-        specs.align = align::numeric;
-        specs.fill[0] = Char('0');
-      }
-      ++begin;
-      break;
-    case '1':
-    case '2':
-    case '3':
-    case '4':
-    case '5':
-    case '6':
-    case '7':
-    case '8':
-    case '9':
-    case '{':
-      enter_state(state::width);
-      begin = parse_dynamic_spec(begin, end, specs.width, specs.width_ref, ctx);
-      break;
-    case '.':
-      if (arg_type == type::none_type) return begin;
-      enter_state(state::precision,
-                  in(arg_type, float_set | string_set | cstring_set));
-      begin = parse_precision(begin, end, specs.precision, specs.precision_ref,
-                              ctx);
-      break;
-    case 'L':
-      if (arg_type == type::none_type) return begin;
-      enter_state(state::locale, is_arithmetic_type(arg_type));
-      specs.localized = true;
-      ++begin;
-      break;
-    case 'd':
-      return parse_presentation_type(pres::dec, integral_set);
-    case 'o':
-      return parse_presentation_type(pres::oct, integral_set);
-    case 'x':
-      return parse_presentation_type(pres::hex_lower, integral_set);
-    case 'X':
-      return parse_presentation_type(pres::hex_upper, integral_set);
-    case 'b':
-      return parse_presentation_type(pres::bin_lower, integral_set);
-    case 'B':
-      return parse_presentation_type(pres::bin_upper, integral_set);
-    case 'a':
-      return parse_presentation_type(pres::hexfloat_lower, float_set);
-    case 'A':
-      return parse_presentation_type(pres::hexfloat_upper, float_set);
-    case 'e':
-      return parse_presentation_type(pres::exp_lower, float_set);
-    case 'E':
-      return parse_presentation_type(pres::exp_upper, float_set);
-    case 'f':
-      return parse_presentation_type(pres::fixed_lower, float_set);
-    case 'F':
-      return parse_presentation_type(pres::fixed_upper, float_set);
-    case 'g':
-      return parse_presentation_type(pres::general_lower, float_set);
-    case 'G':
-      return parse_presentation_type(pres::general_upper, float_set);
-    case 'c':
-      if (arg_type == type::bool_type)
-        throw_format_error("invalid format specifier");
-      return parse_presentation_type(pres::chr, integral_set);
-    case 's':
-      return parse_presentation_type(pres::string,
-                                     bool_set | string_set | cstring_set);
-    case 'p':
-      return parse_presentation_type(pres::pointer, pointer_set | cstring_set);
-    case '?':
-      return parse_presentation_type(pres::debug,
-                                     char_set | string_set | cstring_set);
-    case '}':
-      return begin;
-    default: {
-      if (*begin == '}') return begin;
-      // Parse fill and alignment.
-      auto fill_end = begin + code_point_length(begin);
-      if (end - fill_end <= 0) {
-        throw_format_error("invalid format specifier");
-        return begin;
-      }
-      if (*begin == '{') {
-        throw_format_error("invalid fill character '{'");
-        return begin;
-      }
-      auto align = parse_align(to_ascii(*fill_end));
-      enter_state(state::align, align != align::none);
-      specs.fill = {begin, to_unsigned(fill_end - begin)};
-      specs.align = align;
-      begin = fill_end + 1;
-    }
-    }
-    if (begin == end) return begin;
-    c = to_ascii(*begin);
-  }
-}
-
-template <typename Char, typename Handler>
-FMT_CONSTEXPR auto parse_replacement_field(const Char* begin, const Char* end,
-                                           Handler&& handler) -> const Char* {
-  struct id_adapter {
-    Handler& handler;
-    int arg_id;
-
-    FMT_CONSTEXPR void on_auto() { arg_id = handler.on_arg_id(); }
-    FMT_CONSTEXPR void on_index(int id) { arg_id = handler.on_arg_id(id); }
-    FMT_CONSTEXPR void on_name(basic_string_view<Char> id) {
-      arg_id = handler.on_arg_id(id);
-    }
-  };
-
-  ++begin;
-  if (begin == end) return handler.on_error("invalid format string"), end;
-  if (*begin == '}') {
-    handler.on_replacement_field(handler.on_arg_id(), begin);
-  } else if (*begin == '{') {
-    handler.on_text(begin, begin + 1);
-  } else {
-    auto adapter = id_adapter{handler, 0};
-    begin = parse_arg_id(begin, end, adapter);
-    Char c = begin != end ? *begin : Char();
-    if (c == '}') {
-      handler.on_replacement_field(adapter.arg_id, begin);
-    } else if (c == ':') {
-      begin = handler.on_format_specs(adapter.arg_id, begin + 1, end);
-      if (begin == end || *begin != '}')
-        return handler.on_error("unknown format specifier"), end;
-    } else {
-      return handler.on_error("missing '}' in format string"), end;
-    }
-  }
-  return begin + 1;
-}
-
-template <bool IS_CONSTEXPR, typename Char, typename Handler>
-FMT_CONSTEXPR FMT_INLINE void parse_format_string(
-    basic_string_view<Char> format_str, Handler&& handler) {
-  auto begin = format_str.data();
-  auto end = begin + format_str.size();
-  if (end - begin < 32) {
-    // Use a simple loop instead of memchr for small strings.
-    const Char* p = begin;
-    while (p != end) {
-      auto c = *p++;
-      if (c == '{') {
-        handler.on_text(begin, p - 1);
-        begin = p = parse_replacement_field(p - 1, end, handler);
-      } else if (c == '}') {
-        if (p == end || *p != '}')
-          return handler.on_error("unmatched '}' in format string");
-        handler.on_text(begin, p);
-        begin = ++p;
-      }
-    }
-    handler.on_text(begin, end);
-    return;
-  }
-  struct writer {
-    FMT_CONSTEXPR void operator()(const Char* from, const Char* to) {
-      if (from == to) return;
-      for (;;) {
-        const Char* p = nullptr;
-        if (!find<IS_CONSTEXPR>(from, to, Char('}'), p))
-          return handler_.on_text(from, to);
-        ++p;
-        if (p == to || *p != '}')
-          return handler_.on_error("unmatched '}' in format string");
-        handler_.on_text(from, p);
-        from = p + 1;
-      }
-    }
-    Handler& handler_;
-  } write = {handler};
-  while (begin != end) {
-    // Doing two passes with memchr (one for '{' and another for '}') is up to
-    // 2.5x faster than the naive one-pass implementation on big format strings.
-    const Char* p = begin;
-    if (*begin != '{' && !find<IS_CONSTEXPR>(begin + 1, end, Char('{'), p))
-      return write(begin, end);
-    write(begin, p);
-    begin = parse_replacement_field(p, end, handler);
-  }
-}
-
-template <typename T, bool = is_named_arg<T>::value> struct strip_named_arg {
-  using type = T;
-};
-template <typename T> struct strip_named_arg<T, true> {
-  using type = remove_cvref_t<decltype(T::value)>;
-};
-
-template <typename T, typename ParseContext>
-FMT_CONSTEXPR auto parse_format_specs(ParseContext& ctx)
-    -> decltype(ctx.begin()) {
-  using char_type = typename ParseContext::char_type;
-  using context = buffer_context<char_type>;
-  using mapped_type = conditional_t<
-      mapped_type_constant<T, context>::value != type::custom_type,
-      decltype(arg_mapper<context>().map(std::declval<const T&>())),
-      typename strip_named_arg<T>::type>;
-#if defined(__cpp_if_constexpr)
-  if constexpr (std::is_default_constructible<
-                    formatter<mapped_type, char_type>>::value) {
-    return formatter<mapped_type, char_type>().parse(ctx);
-  } else {
-    type_is_unformattable_for<T, char_type> _;
-    return ctx.begin();
-  }
-#else
-  return formatter<mapped_type, char_type>().parse(ctx);
-#endif
-}
-
-// Checks char specs and returns true iff the presentation type is char-like.
-template <typename Char>
-FMT_CONSTEXPR auto check_char_specs(const format_specs<Char>& specs) -> bool {
-  if (specs.type != presentation_type::none &&
-      specs.type != presentation_type::chr &&
-      specs.type != presentation_type::debug) {
-    return false;
-  }
-  if (specs.align == align::numeric || specs.sign != sign::none || specs.alt)
-    throw_format_error("invalid format specifier for char");
-  return true;
-}
-
-#if FMT_USE_NONTYPE_TEMPLATE_ARGS
-template <int N, typename T, typename... Args, typename Char>
-constexpr auto get_arg_index_by_name(basic_string_view<Char> name) -> int {
-  if constexpr (is_statically_named_arg<T>()) {
-    if (name == T::name) return N;
-  }
-  if constexpr (sizeof...(Args) > 0)
-    return get_arg_index_by_name<N + 1, Args...>(name);
-  (void)name;  // Workaround an MSVC bug about "unused" parameter.
-  return -1;
-}
-#endif
-
-template <typename... Args, typename Char>
-FMT_CONSTEXPR auto get_arg_index_by_name(basic_string_view<Char> name) -> int {
-#if FMT_USE_NONTYPE_TEMPLATE_ARGS
-  if constexpr (sizeof...(Args) > 0)
-    return get_arg_index_by_name<0, Args...>(name);
-#endif
-  (void)name;
-  return -1;
-}
-
-template <typename Char, typename... Args> class format_string_checker {
- private:
-  using parse_context_type = compile_parse_context<Char>;
-  static constexpr int num_args = sizeof...(Args);
-
-  // Format specifier parsing function.
-  // In the future basic_format_parse_context will replace compile_parse_context
-  // here and will use is_constant_evaluated and downcasting to access the data
-  // needed for compile-time checks: https://godbolt.org/z/GvWzcTjh1.
-  using parse_func = const Char* (*)(parse_context_type&);
-
-  type types_[num_args > 0 ? static_cast<size_t>(num_args) : 1];
-  parse_context_type context_;
-  parse_func parse_funcs_[num_args > 0 ? static_cast<size_t>(num_args) : 1];
-
- public:
-  explicit FMT_CONSTEXPR format_string_checker(basic_string_view<Char> fmt)
-      : types_{mapped_type_constant<Args, buffer_context<Char>>::value...},
-        context_(fmt, num_args, types_),
-        parse_funcs_{&parse_format_specs<Args, parse_context_type>...} {}
-
-  FMT_CONSTEXPR void on_text(const Char*, const Char*) {}
-
-  FMT_CONSTEXPR auto on_arg_id() -> int { return context_.next_arg_id(); }
-  FMT_CONSTEXPR auto on_arg_id(int id) -> int {
-    return context_.check_arg_id(id), id;
-  }
-  FMT_CONSTEXPR auto on_arg_id(basic_string_view<Char> id) -> int {
-#if FMT_USE_NONTYPE_TEMPLATE_ARGS
-    auto index = get_arg_index_by_name<Args...>(id);
-    if (index < 0) on_error("named argument is not found");
-    return index;
-#else
-    (void)id;
-    on_error("compile-time checks for named arguments require C++20 support");
-    return 0;
-#endif
-  }
-
-  FMT_CONSTEXPR void on_replacement_field(int id, const Char* begin) {
-    on_format_specs(id, begin, begin);  // Call parse() on empty specs.
-  }
-
-  FMT_CONSTEXPR auto on_format_specs(int id, const Char* begin, const Char*)
-      -> const Char* {
-    context_.advance_to(begin);
-    // id >= 0 check is a workaround for gcc 10 bug (#2065).
-    return id >= 0 && id < num_args ? parse_funcs_[id](context_) : begin;
-  }
-
-  FMT_CONSTEXPR void on_error(const char* message) {
-    throw_format_error(message);
-  }
-};
-
-// Reports a compile-time error if S is not a valid format string.
-template <typename..., typename S, FMT_ENABLE_IF(!is_compile_string<S>::value)>
-FMT_INLINE void check_format_string(const S&) {
-#ifdef FMT_ENFORCE_COMPILE_STRING
-  static_assert(is_compile_string<S>::value,
-                "FMT_ENFORCE_COMPILE_STRING requires all format strings to use "
-                "FMT_STRING.");
-#endif
-}
-template <typename... Args, typename S,
-          FMT_ENABLE_IF(is_compile_string<S>::value)>
-void check_format_string(S format_str) {
-  using char_t = typename S::char_type;
-  FMT_CONSTEXPR auto s = basic_string_view<char_t>(format_str);
-  using checker = format_string_checker<char_t, remove_cvref_t<Args>...>;
-  FMT_CONSTEXPR bool error = (parse_format_string<true>(s, checker(s)), true);
-  ignore_unused(error);
-}
-
-template <typename Char = char> struct vformat_args {
-  using type = basic_format_args<
-      basic_format_context<std::back_insert_iterator<buffer<Char>>, Char>>;
-};
-template <> struct vformat_args<char> {
-  using type = format_args;
-};
-
-// Use vformat_args and avoid type_identity to keep symbols short.
-template <typename Char>
-void vformat_to(buffer<Char>& buf, basic_string_view<Char> fmt,
-                typename vformat_args<Char>::type args, locale_ref loc = {});
-
-FMT_API void vprint_mojibake(std::FILE*, string_view, format_args);
-#ifndef _WIN32
-inline void vprint_mojibake(std::FILE*, string_view, format_args) {}
-#endif
-}  // namespace detail
-
-FMT_BEGIN_EXPORT
-
-// A formatter specialization for natively supported types.
-template <typename T, typename Char>
-struct formatter<T, Char,
-                 enable_if_t<detail::type_constant<T, Char>::value !=
-                             detail::type::custom_type>> {
- private:
-  detail::dynamic_format_specs<Char> specs_;
-
- public:
-  template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> const Char* {
-    auto type = detail::type_constant<T, Char>::value;
-    auto end =
-        detail::parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx, type);
-    if (type == detail::type::char_type) detail::check_char_specs(specs_);
-    return end;
-  }
-
-  template <detail::type U = detail::type_constant<T, Char>::value,
-            FMT_ENABLE_IF(U == detail::type::string_type ||
-                          U == detail::type::cstring_type ||
-                          U == detail::type::char_type)>
-  FMT_CONSTEXPR void set_debug_format(bool set = true) {
-    specs_.type = set ? presentation_type::debug : presentation_type::none;
-  }
-
-  template <typename FormatContext>
-  FMT_CONSTEXPR auto format(const T& val, FormatContext& ctx) const
-      -> decltype(ctx.out());
-};
-
-template <typename Char = char> struct runtime_format_string {
-  basic_string_view<Char> str;
-};
-
-/** A compile-time format string. */
-template <typename Char, typename... Args> class basic_format_string {
- private:
-  basic_string_view<Char> str_;
-
- public:
-  template <typename S,
-            FMT_ENABLE_IF(
-                std::is_convertible<const S&, basic_string_view<Char>>::value)>
-  FMT_CONSTEVAL FMT_INLINE basic_format_string(const S& s) : str_(s) {
-    static_assert(
-        detail::count<
-            (std::is_base_of<detail::view, remove_reference_t<Args>>::value &&
-             std::is_reference<Args>::value)...>() == 0,
-        "passing views as lvalues is disallowed");
-#ifdef FMT_HAS_CONSTEVAL
-    if constexpr (detail::count_named_args<Args...>() ==
-                  detail::count_statically_named_args<Args...>()) {
-      using checker =
-          detail::format_string_checker<Char, remove_cvref_t<Args>...>;
-      detail::parse_format_string<true>(str_, checker(s));
-    }
-#else
-    detail::check_format_string<Args...>(s);
-#endif
-  }
-  basic_format_string(runtime_format_string<Char> fmt) : str_(fmt.str) {}
-
-  FMT_INLINE operator basic_string_view<Char>() const { return str_; }
-  FMT_INLINE auto get() const -> basic_string_view<Char> { return str_; }
-};
-
-#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
-// Workaround broken conversion on older gcc.
-template <typename...> using format_string = string_view;
-inline auto runtime(string_view s) -> string_view { return s; }
-#else
-template <typename... Args>
-using format_string = basic_format_string<char, type_identity_t<Args>...>;
-/**
-  \rst
-  Creates a runtime format string.
-
-  **Example**::
-
-    // Check format string at runtime instead of compile-time.
-    fmt::print(fmt::runtime("{:d}"), "I am not a number");
-  \endrst
- */
-inline auto runtime(string_view s) -> runtime_format_string<> { return {{s}}; }
-#endif
-
-FMT_API auto vformat(string_view fmt, format_args args) -> std::string;
-
-/**
-  \rst
-  Formats ``args`` according to specifications in ``fmt`` and returns the result
-  as a string.
-
-  **Example**::
-
-    #include <fmt/core.h>
-    std::string message = fmt::format("The answer is {}.", 42);
-  \endrst
-*/
-template <typename... T>
-FMT_NODISCARD FMT_INLINE auto format(format_string<T...> fmt, T&&... args)
-    -> std::string {
-  return vformat(fmt, fmt::make_format_args(args...));
-}
-
-/** Formats a string and writes the output to ``out``. */
-template <typename OutputIt,
-          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
-auto vformat_to(OutputIt out, string_view fmt, format_args args) -> OutputIt {
-  auto&& buf = detail::get_buffer<char>(out);
-  detail::vformat_to(buf, fmt, args, {});
-  return detail::get_iterator(buf, out);
-}
-
-/**
- \rst
- Formats ``args`` according to specifications in ``fmt``, writes the result to
- the output iterator ``out`` and returns the iterator past the end of the output
- range. `format_to` does not append a terminating null character.
-
- **Example**::
-
-   auto out = std::vector<char>();
-   fmt::format_to(std::back_inserter(out), "{}", 42);
- \endrst
- */
-template <typename OutputIt, typename... T,
-          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
-FMT_INLINE auto format_to(OutputIt out, format_string<T...> fmt, T&&... args)
-    -> OutputIt {
-  return vformat_to(out, fmt, fmt::make_format_args(args...));
-}
-
-template <typename OutputIt> struct format_to_n_result {
-  /** Iterator past the end of the output range. */
-  OutputIt out;
-  /** Total (not truncated) output size. */
-  size_t size;
-};
-
-template <typename OutputIt, typename... T,
-          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
-auto vformat_to_n(OutputIt out, size_t n, string_view fmt, format_args args)
-    -> format_to_n_result<OutputIt> {
-  using traits = detail::fixed_buffer_traits;
-  auto buf = detail::iterator_buffer<OutputIt, char, traits>(out, n);
-  detail::vformat_to(buf, fmt, args, {});
-  return {buf.out(), buf.count()};
-}
-
-/**
-  \rst
-  Formats ``args`` according to specifications in ``fmt``, writes up to ``n``
-  characters of the result to the output iterator ``out`` and returns the total
-  (not truncated) output size and the iterator past the end of the output range.
-  `format_to_n` does not append a terminating null character.
-  \endrst
- */
-template <typename OutputIt, typename... T,
-          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
-FMT_INLINE auto format_to_n(OutputIt out, size_t n, format_string<T...> fmt,
-                            T&&... args) -> format_to_n_result<OutputIt> {
-  return vformat_to_n(out, n, fmt, fmt::make_format_args(args...));
-}
-
-/** Returns the number of chars in the output of ``format(fmt, args...)``. */
-template <typename... T>
-FMT_NODISCARD FMT_INLINE auto formatted_size(format_string<T...> fmt,
-                                             T&&... args) -> size_t {
-  auto buf = detail::counting_buffer<>();
-  detail::vformat_to<char>(buf, fmt, fmt::make_format_args(args...), {});
-  return buf.count();
-}
-
-FMT_API void vprint(string_view fmt, format_args args);
-FMT_API void vprint(std::FILE* f, string_view fmt, format_args args);
-
-/**
-  \rst
-  Formats ``args`` according to specifications in ``fmt`` and writes the output
-  to ``stdout``.
-
-  **Example**::
-
-    fmt::print("Elapsed time: {0:.2f} seconds", 1.23);
-  \endrst
- */
-template <typename... T>
-FMT_INLINE void print(format_string<T...> fmt, T&&... args) {
-  const auto& vargs = fmt::make_format_args(args...);
-  return detail::is_utf8() ? vprint(fmt, vargs)
-                           : detail::vprint_mojibake(stdout, fmt, vargs);
-}
-
-/**
-  \rst
-  Formats ``args`` according to specifications in ``fmt`` and writes the
-  output to the file ``f``.
-
-  **Example**::
-
-    fmt::print(stderr, "Don't {}!", "panic");
-  \endrst
- */
-template <typename... T>
-FMT_INLINE void print(std::FILE* f, format_string<T...> fmt, T&&... args) {
-  const auto& vargs = fmt::make_format_args(args...);
-  return detail::is_utf8() ? vprint(f, fmt, vargs)
-                           : detail::vprint_mojibake(f, fmt, vargs);
-}
-
-/**
-  Formats ``args`` according to specifications in ``fmt`` and writes the
-  output to the file ``f`` followed by a newline.
- */
-template <typename... T>
-FMT_INLINE void println(std::FILE* f, format_string<T...> fmt, T&&... args) {
-  return fmt::print(f, "{}\n", fmt::format(fmt, std::forward<T>(args)...));
-}
-
-/**
-  Formats ``args`` according to specifications in ``fmt`` and writes the output
-  to ``stdout`` followed by a newline.
- */
-template <typename... T>
-FMT_INLINE void println(format_string<T...> fmt, T&&... args) {
-  return fmt::println(stdout, fmt, std::forward<T>(args)...);
-}
-
-FMT_END_EXPORT
-FMT_GCC_PRAGMA("GCC pop_options")
-FMT_END_NAMESPACE
-
-#ifdef FMT_HEADER_ONLY
-#  include "format.h"
-#endif
-#endif  // FMT_CORE_H_
+#include "format.h"
diff --git a/thirdparty/fmt/format-inl.h b/thirdparty/fmt/format-inl.h
index efac5d1f8..a887483b6 100644
--- a/thirdparty/fmt/format-inl.h
+++ b/thirdparty/fmt/format-inl.h
@@ -8,17 +8,19 @@
 #ifndef FMT_FORMAT_INL_H_
 #define FMT_FORMAT_INL_H_
 
-#include <algorithm>
-#include <cerrno>  // errno
-#include <climits>
-#include <cmath>
-#include <exception>
-
-#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
-#  include <locale>
+#ifndef FMT_MODULE
+#  include <algorithm>
+#  include <cerrno>  // errno
+#  include <climits>
+#  include <cmath>
+#  include <exception>
+
+#  if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
+#    include <locale>
+#  endif
 #endif
 
-#if defined(_WIN32) && !defined(FMT_WINDOWS_NO_WCHAR)
+#if defined(_WIN32) && !defined(FMT_USE_WRITE_CONSOLE)
 #  include <io.h>  // _isatty
 #endif
 
@@ -36,10 +38,6 @@ FMT_FUNC void assert_fail(const char* file, int line, const char* message) {
   std::terminate();
 }
 
-FMT_FUNC void throw_format_error(const char* message) {
-  FMT_THROW(format_error(message));
-}
-
 FMT_FUNC void format_error_code(detail::buffer<char>& out, int error_code,
                                 string_view message) noexcept {
   // Report error code making sure that the output fits into
@@ -56,7 +54,7 @@ FMT_FUNC void format_error_code(detail::buffer<char>& out, int error_code,
     ++error_code_size;
   }
   error_code_size += detail::to_unsigned(detail::count_digits(abs_value));
-  auto it = buffer_appender<char>(out);
+  auto it = appender(out);
   if (message.size() <= inline_buffer_size - error_code_size)
     fmt::format_to(it, FMT_STRING("{}{}"), message, SEP);
   fmt::format_to(it, FMT_STRING("{}{}"), ERROR_STR, error_code);
@@ -113,8 +111,12 @@ template <typename Char> FMT_FUNC Char decimal_point_impl(locale_ref) {
 #endif
 
 FMT_FUNC auto write_loc(appender out, loc_value value,
-                        const format_specs<>& specs, locale_ref loc) -> bool {
-#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
+                        const format_specs& specs, locale_ref loc) -> bool {
+#ifdef FMT_STATIC_THOUSANDS_SEPARATOR
+  value.visit(loc_writer<>{
+      out, specs, std::string(1, FMT_STATIC_THOUSANDS_SEPARATOR), "\3", "."});
+  return true;
+#else
   auto locale = loc.get<std::locale>();
   // We cannot use the num_put<char> facet because it may produce output in
   // a wrong encoding.
@@ -123,10 +125,13 @@ FMT_FUNC auto write_loc(appender out, loc_value value,
     return std::use_facet<facet>(locale).put(out, value, specs);
   return facet(locale).put(out, value, specs);
 #endif
-  return false;
 }
 }  // namespace detail
 
+FMT_FUNC void report_error(const char* message) {
+  FMT_THROW(format_error(message));
+}
+
 template <typename Locale> typename Locale::id format_facet<Locale>::id;
 
 #ifndef FMT_STATIC_THOUSANDS_SEPARATOR
@@ -138,7 +143,7 @@ template <typename Locale> format_facet<Locale>::format_facet(Locale& loc) {
 
 template <>
 FMT_API FMT_FUNC auto format_facet<std::locale>::do_put(
-    appender out, loc_value val, const format_specs<>& specs) const -> bool {
+    appender out, loc_value val, const format_specs& specs) const -> bool {
   return val.visit(
       detail::loc_writer<>{out, specs, separator_, grouping_, decimal_point_});
 }
@@ -1411,7 +1416,7 @@ FMT_FUNC void format_system_error(detail::buffer<char>& out, int error_code,
                                   const char* message) noexcept {
   FMT_TRY {
     auto ec = std::error_code(error_code, std::generic_category());
-    write(std::back_inserter(out), std::system_error(ec, message).what());
+    detail::write(appender(out), std::system_error(ec, message).what());
     return;
   }
   FMT_CATCH(...) {}
@@ -1432,9 +1437,242 @@ FMT_FUNC auto vformat(string_view fmt, format_args args) -> std::string {
 }
 
 namespace detail {
-#if !defined(_WIN32) || defined(FMT_WINDOWS_NO_WCHAR)
+
+template <typename T> struct span {
+  T* data;
+  size_t size;
+};
+
+template <typename F> auto flockfile(F* f) -> decltype(_lock_file(f)) {
+  _lock_file(f);
+}
+template <typename F> auto funlockfile(F* f) -> decltype(_unlock_file(f)) {
+  _unlock_file(f);
+}
+
+#ifndef getc_unlocked
+template <typename F> auto getc_unlocked(F* f) -> decltype(_fgetc_nolock(f)) {
+  return _fgetc_nolock(f);
+}
+#endif
+
+template <typename F = FILE, typename Enable = void>
+struct has_flockfile : std::false_type {};
+
+template <typename F>
+struct has_flockfile<F, void_t<decltype(flockfile(&std::declval<F&>()))>>
+    : std::true_type {};
+
+// A FILE wrapper. F is FILE defined as a template parameter to make system API
+// detection work.
+template <typename F> class file_base {
+ public:
+  F* file_;
+
+ public:
+  file_base(F* file) : file_(file) {}
+  operator F*() const { return file_; }
+
+  // Reads a code unit from the stream.
+  auto get() -> int {
+    int result = getc_unlocked(file_);
+    if (result == EOF && ferror(file_) != 0)
+      FMT_THROW(system_error(errno, FMT_STRING("getc failed")));
+    return result;
+  }
+
+  // Puts the code unit back into the stream buffer.
+  void unget(char c) {
+    if (ungetc(c, file_) == EOF)
+      FMT_THROW(system_error(errno, FMT_STRING("ungetc failed")));
+  }
+
+  void flush() { fflush(this->file_); }
+};
+
+// A FILE wrapper for glibc.
+template <typename F> class glibc_file : public file_base<F> {
+ private:
+  enum {
+    line_buffered = 0x200,  // _IO_LINE_BUF
+    unbuffered = 2          // _IO_UNBUFFERED
+  };
+
+ public:
+  using file_base<F>::file_base;
+
+  auto is_buffered() const -> bool {
+    return (this->file_->_flags & unbuffered) == 0;
+  }
+
+  void init_buffer() {
+    if (this->file_->_IO_write_ptr) return;
+    // Force buffer initialization by placing and removing a char in a buffer.
+    putc_unlocked(0, this->file_);
+    --this->file_->_IO_write_ptr;
+  }
+
+  // Returns the file's read buffer.
+  auto get_read_buffer() const -> span<const char> {
+    auto ptr = this->file_->_IO_read_ptr;
+    return {ptr, to_unsigned(this->file_->_IO_read_end - ptr)};
+  }
+
+  // Returns the file's write buffer.
+  auto get_write_buffer() const -> span<char> {
+    auto ptr = this->file_->_IO_write_ptr;
+    return {ptr, to_unsigned(this->file_->_IO_buf_end - ptr)};
+  }
+
+  void advance_write_buffer(size_t size) { this->file_->_IO_write_ptr += size; }
+
+  bool needs_flush() const {
+    if ((this->file_->_flags & line_buffered) == 0) return false;
+    char* end = this->file_->_IO_write_end;
+    return memchr(end, '\n', to_unsigned(this->file_->_IO_write_ptr - end));
+  }
+
+  void flush() { fflush_unlocked(this->file_); }
+};
+
+// A FILE wrapper for Apple's libc.
+template <typename F> class apple_file : public file_base<F> {
+ private:
+  enum {
+    line_buffered = 1,  // __SNBF
+    unbuffered = 2      // __SLBF
+  };
+
+ public:
+  using file_base<F>::file_base;
+
+  auto is_buffered() const -> bool {
+    return (this->file_->_flags & unbuffered) == 0;
+  }
+
+  void init_buffer() {
+    if (this->file_->_p) return;
+    // Force buffer initialization by placing and removing a char in a buffer.
+    putc_unlocked(0, this->file_);
+    --this->file_->_p;
+    ++this->file_->_w;
+  }
+
+  auto get_read_buffer() const -> span<const char> {
+    return {reinterpret_cast<char*>(this->file_->_p),
+            to_unsigned(this->file_->_r)};
+  }
+
+  auto get_write_buffer() const -> span<char> {
+    return {reinterpret_cast<char*>(this->file_->_p),
+            to_unsigned(this->file_->_bf._base + this->file_->_bf._size -
+                        this->file_->_p)};
+  }
+
+  void advance_write_buffer(size_t size) {
+    this->file_->_p += size;
+    this->file_->_w -= size;
+  }
+
+  bool needs_flush() const {
+    if ((this->file_->_flags & line_buffered) == 0) return false;
+    return memchr(this->file_->_p + this->file_->_w, '\n',
+                  to_unsigned(-this->file_->_w));
+  }
+};
+
+// A fallback FILE wrapper.
+template <typename F> class fallback_file : public file_base<F> {
+ private:
+  char next_;  // The next unconsumed character in the buffer.
+  bool has_next_ = false;
+
+ public:
+  using file_base<F>::file_base;
+
+  auto is_buffered() const -> bool { return false; }
+  auto needs_flush() const -> bool { return false; }
+  void init_buffer() {}
+
+  auto get_read_buffer() const -> span<const char> {
+    return {&next_, has_next_ ? 1u : 0u};
+  }
+
+  auto get_write_buffer() const -> span<char> { return {nullptr, 0}; }
+
+  void advance_write_buffer(size_t) {}
+
+  auto get() -> int {
+    has_next_ = false;
+    return file_base<F>::get();
+  }
+
+  void unget(char c) {
+    file_base<F>::unget(c);
+    next_ = c;
+    has_next_ = true;
+  }
+};
+
+#ifndef FMT_USE_FALLBACK_FILE
+#  define FMT_USE_FALLBACK_FILE 1
+#endif
+
+template <typename F,
+          FMT_ENABLE_IF(sizeof(F::_p) != 0 && !FMT_USE_FALLBACK_FILE)>
+auto get_file(F* f, int) -> apple_file<F> {
+  return f;
+}
+template <typename F,
+          FMT_ENABLE_IF(sizeof(F::_IO_read_ptr) != 0 && !FMT_USE_FALLBACK_FILE)>
+inline auto get_file(F* f, int) -> glibc_file<F> {
+  return f;
+}
+
+inline auto get_file(FILE* f, ...) -> fallback_file<FILE> { return f; }
+
+using file_ref = decltype(get_file(static_cast<FILE*>(nullptr), 0));
+
+template <typename F = FILE, typename Enable = void>
+class file_print_buffer : public buffer<char> {
+ public:
+  explicit file_print_buffer(F*) : buffer(nullptr, size_t()) {}
+};
+
+template <typename F>
+class file_print_buffer<F, enable_if_t<has_flockfile<F>::value>>
+    : public buffer<char> {
+ private:
+  file_ref file_;
+
+  static void grow(buffer<char>& base, size_t) {
+    auto& self = static_cast<file_print_buffer&>(base);
+    self.file_.advance_write_buffer(self.size());
+    if (self.file_.get_write_buffer().size == 0) self.file_.flush();
+    auto buf = self.file_.get_write_buffer();
+    FMT_ASSERT(buf.size > 0, "");
+    self.set(buf.data, buf.size);
+    self.clear();
+  }
+
+ public:
+  explicit file_print_buffer(F* f) : buffer(grow, size_t()), file_(f) {
+    flockfile(f);
+    file_.init_buffer();
+    auto buf = file_.get_write_buffer();
+    set(buf.data, buf.size);
+  }
+  ~file_print_buffer() {
+    file_.advance_write_buffer(size());
+    bool flush = file_.needs_flush();
+    F* f = file_;    // Make funlockfile depend on the template parameter F
+    funlockfile(f);  // for the system API detection to work.
+    if (flush) fflush(file_);
+  }
+};
+
+#if !defined(_WIN32) || defined(FMT_USE_WRITE_CONSOLE)
 FMT_FUNC auto write_console(int, string_view) -> bool { return false; }
-FMT_FUNC auto write_console(std::FILE*, string_view) -> bool { return false; }
 #else
 using dword = conditional_t<sizeof(long) == 4, unsigned long, unsigned>;
 extern "C" __declspec(dllimport) int __stdcall WriteConsoleW(  //
@@ -1445,23 +1683,21 @@ FMT_FUNC bool write_console(int fd, string_view text) {
   return WriteConsoleW(reinterpret_cast<void*>(_get_osfhandle(fd)), u16.c_str(),
                        static_cast<dword>(u16.size()), nullptr, nullptr) != 0;
 }
-
-FMT_FUNC auto write_console(std::FILE* f, string_view text) -> bool {
-  return write_console(_fileno(f), text);
-}
 #endif
 
 #ifdef _WIN32
 // Print assuming legacy (non-Unicode) encoding.
-FMT_FUNC void vprint_mojibake(std::FILE* f, string_view fmt, format_args args) {
+FMT_FUNC void vprint_mojibake(std::FILE* f, string_view fmt, format_args args,
+                              bool newline) {
   auto buffer = memory_buffer();
   detail::vformat_to(buffer, fmt, args);
+  if (newline) buffer.push_back('\n');
   fwrite_fully(buffer.data(), buffer.size(), f);
 }
 #endif
 
 FMT_FUNC void print(std::FILE* f, string_view text) {
-#ifdef _WIN32
+#if defined(_WIN32) && !defined(FMT_USE_WRITE_CONSOLE)
   int fd = _fileno(f);
   if (_isatty(fd)) {
     std::fflush(f);
@@ -1472,9 +1708,23 @@ FMT_FUNC void print(std::FILE* f, string_view text) {
 }
 }  // namespace detail
 
+FMT_FUNC void vprint_buffered(std::FILE* f, string_view fmt, format_args args) {
+  auto buffer = memory_buffer();
+  detail::vformat_to(buffer, fmt, args);
+  detail::print(f, {buffer.data(), buffer.size()});
+}
+
 FMT_FUNC void vprint(std::FILE* f, string_view fmt, format_args args) {
+  if (!detail::file_ref(f).is_buffered() || !detail::has_flockfile<>())
+    return vprint_buffered(f, fmt, args);
+  auto&& buffer = detail::file_print_buffer<>(f);
+  return detail::vformat_to(buffer, fmt, args);
+}
+
+FMT_FUNC void vprintln(std::FILE* f, string_view fmt, format_args args) {
   auto buffer = memory_buffer();
   detail::vformat_to(buffer, fmt, args);
+  buffer.push_back('\n');
   detail::print(f, {buffer.data(), buffer.size()});
 }
 
diff --git a/thirdparty/fmt/format.h b/thirdparty/fmt/format.h
index 7637c8a0d..67f0ab739 100644
--- a/thirdparty/fmt/format.h
+++ b/thirdparty/fmt/format.h
@@ -33,20 +33,39 @@
 #ifndef FMT_FORMAT_H_
 #define FMT_FORMAT_H_
 
-#include <cmath>             // std::signbit
-#include <cstdint>           // uint32_t
-#include <cstring>           // std::memcpy
-#include <initializer_list>  // std::initializer_list
-#include <limits>            // std::numeric_limits
-#include <memory>            // std::uninitialized_copy
-#include <stdexcept>         // std::runtime_error
-#include <system_error>      // std::system_error
-
-#ifdef __cpp_lib_bit_cast
-#  include <bit>  // std::bit_cast
+#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#  define _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#  define FMT_REMOVE_TRANSITIVE_INCLUDES
 #endif
 
-#include "core.h"
+#include "base.h"
+
+#ifndef FMT_MODULE
+#  include <cmath>             // std::signbit
+#  include <cstdint>           // uint32_t
+#  include <cstring>           // std::memcpy
+#  include <initializer_list>  // std::initializer_list
+#  include <limits>            // std::numeric_limits
+#  if defined(__GLIBCXX__) && !defined(_GLIBCXX_USE_DUAL_ABI)
+// Workaround for pre gcc 5 libstdc++.
+#    include <memory>  // std::allocator_traits
+#  endif
+#  include <stdexcept>     // std::runtime_error
+#  include <string>        // std::string
+#  include <system_error>  // std::system_error
+
+// Checking FMT_CPLUSPLUS for warning suppression in MSVC.
+#  if FMT_HAS_INCLUDE(<bit>) && FMT_CPLUSPLUS > 201703L
+#    include <bit>  // std::bit_cast
+#  endif
+
+// libc++ supports string_view in pre-c++17.
+#  if FMT_HAS_INCLUDE(<string_view>) && \
+      (FMT_CPLUSPLUS >= 201703L || defined(_LIBCPP_VERSION))
+#    include <string_view>
+#    define FMT_USE_STRING_VIEW
+#  endif
+#endif  // FMT_MODULE
 
 #if defined __cpp_inline_variables && __cpp_inline_variables >= 201606L
 #  define FMT_INLINE_VARIABLE inline
@@ -54,36 +73,11 @@
 #  define FMT_INLINE_VARIABLE
 #endif
 
-#if FMT_HAS_CPP17_ATTRIBUTE(fallthrough)
-#  define FMT_FALLTHROUGH [[fallthrough]]
-#elif defined(__clang__)
-#  define FMT_FALLTHROUGH [[clang::fallthrough]]
-#elif FMT_GCC_VERSION >= 700 && \
-    (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= 520)
-#  define FMT_FALLTHROUGH [[gnu::fallthrough]]
-#else
-#  define FMT_FALLTHROUGH
-#endif
-
-#ifndef FMT_DEPRECATED
-#  if FMT_HAS_CPP14_ATTRIBUTE(deprecated) || FMT_MSC_VERSION >= 1900
-#    define FMT_DEPRECATED [[deprecated]]
-#  else
-#    if (defined(__GNUC__) && !defined(__LCC__)) || defined(__clang__)
-#      define FMT_DEPRECATED __attribute__((deprecated))
-#    elif FMT_MSC_VERSION
-#      define FMT_DEPRECATED __declspec(deprecated)
-#    else
-#      define FMT_DEPRECATED /* deprecated */
-#    endif
-#  endif
-#endif
-
 #ifndef FMT_NO_UNIQUE_ADDRESS
 #  if FMT_CPLUSPLUS >= 202002L
 #    if FMT_HAS_CPP_ATTRIBUTE(no_unique_address)
 #      define FMT_NO_UNIQUE_ADDRESS [[no_unique_address]]
-// VS2019 v16.10 and later except clang-cl (https://reviews.llvm.org/D110485)
+// VS2019 v16.10 and later except clang-cl (https://reviews.llvm.org/D110485).
 #    elif (FMT_MSC_VERSION >= 1929) && !FMT_CLANG_VERSION
 #      define FMT_NO_UNIQUE_ADDRESS [[msvc::no_unique_address]]
 #    endif
@@ -112,6 +106,13 @@
 #  define FMT_NOINLINE
 #endif
 
+namespace std {
+template <> struct iterator_traits<fmt::appender> {
+  using iterator_category = output_iterator_tag;
+  using value_type = char;
+};
+}  // namespace std
+
 #ifndef FMT_THROW
 #  if FMT_EXCEPTIONS
 #    if FMT_MSC_VERSION || defined(__NVCC__)
@@ -135,14 +136,6 @@ FMT_END_NAMESPACE
 #  endif
 #endif
 
-#if FMT_EXCEPTIONS
-#  define FMT_TRY try
-#  define FMT_CATCH(x) catch (x)
-#else
-#  define FMT_TRY if (true)
-#  define FMT_CATCH(x) if (false)
-#endif
-
 #ifndef FMT_MAYBE_UNUSED
 #  if FMT_HAS_CPP17_ATTRIBUTE(maybe_unused)
 #    define FMT_MAYBE_UNUSED [[maybe_unused]]
@@ -277,6 +270,11 @@ FMT_END_NAMESPACE
 #endif
 
 FMT_BEGIN_NAMESPACE
+
+template <typename Char, typename Traits, typename Allocator>
+struct is_contiguous<std::basic_string<Char, Traits, Allocator>>
+    : std::true_type {};
+
 namespace detail {
 
 FMT_CONSTEXPR inline void abort_fuzzing_if(bool condition) {
@@ -286,16 +284,10 @@ FMT_CONSTEXPR inline void abort_fuzzing_if(bool condition) {
 #endif
 }
 
-template <typename CharT, CharT... C> struct string_literal {
-  static constexpr CharT value[sizeof...(C)] = {C...};
-  constexpr operator basic_string_view<CharT>() const {
-    return {value, sizeof...(C)};
-  }
-};
-
-#if FMT_CPLUSPLUS < 201703L
-template <typename CharT, CharT... C>
-constexpr CharT string_literal<CharT, C...>::value[sizeof...(C)];
+#if defined(FMT_USE_STRING_VIEW)
+template <typename Char> using std_string_view = std::basic_string_view<Char>;
+#else
+template <typename T> struct std_string_view {};
 #endif
 
 // Implementation of std::bit_cast for pre-C++20.
@@ -454,7 +446,8 @@ template <typename T> constexpr auto num_bits() -> int {
 }
 // std::numeric_limits<T>::digits may return 0 for 128-bit ints.
 template <> constexpr auto num_bits<int128_opt>() -> int { return 128; }
-template <> constexpr auto num_bits<uint128_t>() -> int { return 128; }
+template <> constexpr auto num_bits<uint128_opt>() -> int { return 128; }
+template <> constexpr auto num_bits<uint128_fallback>() -> int { return 128; }
 
 // A heterogeneous bit_cast used for converting 96-bit long double to uint128_t
 // and 128-bit pointers to uint128_fallback.
@@ -523,21 +516,22 @@ inline auto get_data(Container& c) -> typename Container::value_type* {
 
 // Attempts to reserve space for n extra characters in the output range.
 // Returns a pointer to the reserved range or a reference to it.
-template <typename Container, FMT_ENABLE_IF(is_contiguous<Container>::value)>
+template <typename OutputIt,
+          FMT_ENABLE_IF(is_back_insert_iterator<OutputIt>::value&&
+                            is_contiguous<typename OutputIt::container>::value)>
 #if FMT_CLANG_VERSION >= 307 && !FMT_ICC_VERSION
 __attribute__((no_sanitize("undefined")))
 #endif
 inline auto
-reserve(std::back_insert_iterator<Container> it, size_t n) ->
-    typename Container::value_type* {
-  Container& c = get_container(it);
+reserve(OutputIt it, size_t n) -> typename OutputIt::value_type* {
+  auto& c = get_container(it);
   size_t size = c.size();
   c.resize(size + n);
   return get_data(c) + size;
 }
 
 template <typename T>
-inline auto reserve(buffer_appender<T> it, size_t n) -> buffer_appender<T> {
+inline auto reserve(basic_appender<T> it, size_t n) -> basic_appender<T> {
   buffer<T>& buf = get_container(it);
   buf.try_reserve(buf.size() + n);
   return it;
@@ -556,18 +550,21 @@ template <typename T, typename OutputIt>
 constexpr auto to_pointer(OutputIt, size_t) -> T* {
   return nullptr;
 }
-template <typename T> auto to_pointer(buffer_appender<T> it, size_t n) -> T* {
+template <typename T> auto to_pointer(basic_appender<T> it, size_t n) -> T* {
   buffer<T>& buf = get_container(it);
   auto size = buf.size();
+  buf.try_reserve(size + n);
   if (buf.capacity() < size + n) return nullptr;
   buf.try_resize(size + n);
   return buf.data() + size;
 }
 
-template <typename Container, FMT_ENABLE_IF(is_contiguous<Container>::value)>
-inline auto base_iterator(std::back_insert_iterator<Container> it,
-                          typename Container::value_type*)
-    -> std::back_insert_iterator<Container> {
+template <typename OutputIt,
+          FMT_ENABLE_IF(is_back_insert_iterator<OutputIt>::value&&
+                            is_contiguous<typename OutputIt::container>::value)>
+inline auto base_iterator(OutputIt it,
+                          typename OutputIt::container_type::value_type*)
+    -> OutputIt {
   return it;
 }
 
@@ -593,16 +590,10 @@ FMT_CONSTEXPR20 auto fill_n(T* out, Size count, char value) -> T* {
   return out + count;
 }
 
-#ifdef __cpp_char8_t
-using char8_type = char8_t;
-#else
-enum char8_type : unsigned char {};
-#endif
-
 template <typename OutChar, typename InputIt, typename OutputIt>
-FMT_CONSTEXPR FMT_NOINLINE auto copy_str_noinline(InputIt begin, InputIt end,
-                                                  OutputIt out) -> OutputIt {
-  return copy_str<OutChar>(begin, end, out);
+FMT_CONSTEXPR FMT_NOINLINE auto copy_noinline(InputIt begin, InputIt end,
+                                              OutputIt out) -> OutputIt {
+  return copy<OutChar>(begin, end, out);
 }
 
 // A public domain branchless UTF-8 decoder by Christopher Wellons:
@@ -683,7 +674,7 @@ FMT_CONSTEXPR void for_each_codepoint(string_view s, F f) {
   }
   if (auto num_chars_left = s.data() + s.size() - p) {
     char buf[2 * block_size - 1] = {};
-    copy_str<char>(p, p + num_chars_left, buf);
+    copy<char>(p, p + num_chars_left, buf);
     const char* buf_ptr = buf;
     do {
       auto end = decode(buf_ptr, p);
@@ -734,11 +725,6 @@ FMT_CONSTEXPR inline auto compute_width(string_view s) -> size_t {
   return num_code_points;
 }
 
-inline auto compute_width(basic_string_view<char8_type> s) -> size_t {
-  return compute_width(
-      string_view(reinterpret_cast<const char*>(s.data()), s.size()));
-}
-
 template <typename Char>
 inline auto code_point_index(basic_string_view<Char> s, size_t n) -> size_t {
   size_t size = s.size();
@@ -760,12 +746,6 @@ inline auto code_point_index(string_view s, size_t n) -> size_t {
   return result;
 }
 
-inline auto code_point_index(basic_string_view<char8_type> s, size_t n)
-    -> size_t {
-  return code_point_index(
-      string_view(reinterpret_cast<const char*>(s.data()), s.size()), n);
-}
-
 template <typename T> struct is_integral : std::is_integral<T> {};
 template <> struct is_integral<int128_opt> : std::true_type {};
 template <> struct is_integral<uint128_t> : std::true_type {};
@@ -791,28 +771,22 @@ using is_integer =
 #  define FMT_USE_LONG_DOUBLE 1
 #endif
 
-#ifndef FMT_USE_FLOAT128
-#  ifdef __clang__
-// Clang emulates GCC, so it has to appear early.
-#    if FMT_HAS_INCLUDE(<quadmath.h>)
-#      define FMT_USE_FLOAT128 1
-#    endif
-#  elif defined(__GNUC__)
-// GNU C++:
-#    if defined(_GLIBCXX_USE_FLOAT128) && !defined(__STRICT_ANSI__)
-#      define FMT_USE_FLOAT128 1
-#    endif
-#  endif
-#  ifndef FMT_USE_FLOAT128
-#    define FMT_USE_FLOAT128 0
-#  endif
+#if defined(FMT_USE_FLOAT128)
+// Use the provided definition.
+#elif FMT_CLANG_VERSION && FMT_HAS_INCLUDE(<quadmath.h>)
+#  define FMT_USE_FLOAT128 1
+#elif FMT_GCC_VERSION && defined(_GLIBCXX_USE_FLOAT128) && \
+    !defined(__STRICT_ANSI__)
+#  define FMT_USE_FLOAT128 1
+#else
+#  define FMT_USE_FLOAT128 0
 #endif
-
 #if FMT_USE_FLOAT128
 using float128 = __float128;
 #else
 using float128 = void;
 #endif
+
 template <typename T> using is_float128 = std::is_same<T, float128>;
 
 template <typename T>
@@ -831,20 +805,6 @@ using is_double_double = bool_constant<std::numeric_limits<T>::digits == 106>;
 #  define FMT_USE_FULL_CACHE_DRAGONBOX 0
 #endif
 
-template <typename T>
-template <typename U>
-void buffer<T>::append(const U* begin, const U* end) {
-  while (begin != end) {
-    auto count = to_unsigned(end - begin);
-    try_reserve(size_ + count);
-    auto free_cap = capacity_ - size_;
-    if (free_cap < count) count = free_cap;
-    std::uninitialized_copy_n(begin, count, ptr_ + size_);
-    size_ += count;
-    begin += count;
-  }
-}
-
 template <typename T, typename Enable = void>
 struct is_locale : std::false_type {};
 template <typename T>
@@ -858,29 +818,21 @@ FMT_BEGIN_EXPORT
 enum { inline_buffer_size = 500 };
 
 /**
-  \rst
-  A dynamically growing memory buffer for trivially copyable/constructible types
-  with the first ``SIZE`` elements stored in the object itself.
-
-  You can use the ``memory_buffer`` type alias for ``char`` instead.
-
-  **Example**::
-
-     auto out = fmt::memory_buffer();
-     fmt::format_to(std::back_inserter(out), "The answer is {}.", 42);
-
-  This will append the following output to the ``out`` object:
-
-  .. code-block:: none
-
-     The answer is 42.
-
-  The output can be converted to an ``std::string`` with ``to_string(out)``.
-  \endrst
+ * A dynamically growing memory buffer for trivially copyable/constructible
+ * types with the first `SIZE` elements stored in the object itself. Most
+ * commonly used via the `memory_buffer` alias for `char`.
+ *
+ * **Example**:
+ *
+ *     auto out = fmt::memory_buffer();
+ *     fmt::format_to(std::back_inserter(out), "The answer is {}.", 42);
+ *
+ * This will append "The answer is 42." to `out`. The buffer content can be
+ * converted to `std::string` with `to_string(out)`.
  */
 template <typename T, size_t SIZE = inline_buffer_size,
           typename Allocator = std::allocator<T>>
-class basic_memory_buffer final : public detail::buffer<T> {
+class basic_memory_buffer : public detail::buffer<T> {
  private:
   T store_[SIZE];
 
@@ -893,28 +845,28 @@ class basic_memory_buffer final : public detail::buffer<T> {
     if (data != store_) alloc_.deallocate(data, this->capacity());
   }
 
- protected:
-  FMT_CONSTEXPR20 void grow(size_t size) override {
+  static FMT_CONSTEXPR20 void grow(detail::buffer<T>& buf, size_t size) {
     detail::abort_fuzzing_if(size > 5000);
-    const size_t max_size = std::allocator_traits<Allocator>::max_size(alloc_);
-    size_t old_capacity = this->capacity();
+    auto& self = static_cast<basic_memory_buffer&>(buf);
+    const size_t max_size =
+        std::allocator_traits<Allocator>::max_size(self.alloc_);
+    size_t old_capacity = buf.capacity();
     size_t new_capacity = old_capacity + old_capacity / 2;
     if (size > new_capacity)
       new_capacity = size;
     else if (new_capacity > max_size)
       new_capacity = size > max_size ? size : max_size;
-    T* old_data = this->data();
-    T* new_data =
-        std::allocator_traits<Allocator>::allocate(alloc_, new_capacity);
+    T* old_data = buf.data();
+    T* new_data = self.alloc_.allocate(new_capacity);
     // Suppress a bogus -Wstringop-overflow in gcc 13.1 (#3481).
-    detail::assume(this->size() <= new_capacity);
+    detail::assume(buf.size() <= new_capacity);
     // The following code doesn't throw, so the raw pointer above doesn't leak.
-    std::uninitialized_copy_n(old_data, this->size(), new_data);
-    this->set(new_data, new_capacity);
+    memcpy(new_data, old_data, buf.size() * sizeof(T));
+    self.set(new_data, new_capacity);
     // deallocate must not throw according to the standard, but even if it does,
     // the buffer already uses the new storage and will deallocate it in
     // destructor.
-    if (old_data != store_) alloc_.deallocate(old_data, old_capacity);
+    if (old_data != self.store_) self.alloc_.deallocate(old_data, old_capacity);
   }
 
  public:
@@ -923,7 +875,7 @@ class basic_memory_buffer final : public detail::buffer<T> {
 
   FMT_CONSTEXPR20 explicit basic_memory_buffer(
       const Allocator& alloc = Allocator())
-      : alloc_(alloc) {
+      : detail::buffer<T>(grow), alloc_(alloc) {
     this->set(store_, SIZE);
     if (detail::is_constant_evaluated()) detail::fill_n(store_, SIZE, T());
   }
@@ -937,7 +889,7 @@ class basic_memory_buffer final : public detail::buffer<T> {
     size_t size = other.size(), capacity = other.capacity();
     if (data == other.store_) {
       this->set(store_, capacity);
-      detail::copy_str<T>(other.store_, other.store_ + size, store_);
+      detail::copy<T>(other.store_, other.store_ + size, store_);
     } else {
       this->set(data, capacity);
       // Set pointer to the inline array so that delete is not called
@@ -949,21 +901,14 @@ class basic_memory_buffer final : public detail::buffer<T> {
   }
 
  public:
-  /**
-    \rst
-    Constructs a :class:`fmt::basic_memory_buffer` object moving the content
-    of the other object to it.
-    \endrst
-   */
-  FMT_CONSTEXPR20 basic_memory_buffer(basic_memory_buffer&& other) noexcept {
+  /// Constructs a `basic_memory_buffer` object moving the content of the other
+  /// object to it.
+  FMT_CONSTEXPR20 basic_memory_buffer(basic_memory_buffer&& other) noexcept
+      : detail::buffer<T>(grow) {
     move(other);
   }
 
-  /**
-    \rst
-    Moves the content of the other ``basic_memory_buffer`` object to this one.
-    \endrst
-   */
+  /// Moves the content of the other `basic_memory_buffer` object to this one.
   auto operator=(basic_memory_buffer&& other) noexcept -> basic_memory_buffer& {
     FMT_ASSERT(this != &other, "");
     deallocate();
@@ -974,13 +919,11 @@ class basic_memory_buffer final : public detail::buffer<T> {
   // Returns a copy of the allocator associated with this buffer.
   auto get_allocator() const -> Allocator { return alloc_; }
 
-  /**
-    Resizes the buffer to contain *count* elements. If T is a POD type new
-    elements may not be initialized.
-   */
+  /// Resizes the buffer to contain `count` elements. If T is a POD type new
+  /// elements may not be initialized.
   FMT_CONSTEXPR20 void resize(size_t count) { this->try_resize(count); }
 
-  /** Increases the buffer capacity to *new_capacity*. */
+  /// Increases the buffer capacity to `new_capacity`.
   void reserve(size_t new_capacity) { this->try_reserve(new_capacity); }
 
   using detail::buffer<T>::append;
@@ -999,7 +942,6 @@ struct is_contiguous<basic_memory_buffer<T, SIZE, Allocator>> : std::true_type {
 FMT_END_EXPORT
 namespace detail {
 FMT_API auto write_console(int fd, string_view text) -> bool;
-FMT_API auto write_console(std::FILE* f, string_view text) -> bool;
 FMT_API void print(std::FILE*, string_view);
 }  // namespace detail
 
@@ -1010,7 +952,7 @@ FMT_BEGIN_EXPORT
 #  pragma clang diagnostic ignored "-Wweak-vtables"
 #endif
 
-/** An error reported from a formatting function. */
+/// An error reported from a formatting function.
 class FMT_SO_VISIBILITY("default") format_error : public std::runtime_error {
  public:
   using std::runtime_error::runtime_error;
@@ -1020,8 +962,8 @@ namespace detail_exported {
 #if FMT_USE_NONTYPE_TEMPLATE_ARGS
 template <typename Char, size_t N> struct fixed_string {
   constexpr fixed_string(const Char (&str)[N]) {
-    detail::copy_str<Char, const Char*, Char*>(static_cast<const Char*>(str),
-                                               str + N, data);
+    detail::copy<Char, const Char*, Char*>(static_cast<const Char*>(str),
+                                           str + N, data);
   }
   Char data[N] = {};
 };
@@ -1036,12 +978,57 @@ constexpr auto compile_string_to_view(const Char (&s)[N])
   return {s, N - (std::char_traits<Char>::to_int_type(s[N - 1]) == 0 ? 1 : 0)};
 }
 template <typename Char>
-constexpr auto compile_string_to_view(detail::std_string_view<Char> s)
+constexpr auto compile_string_to_view(basic_string_view<Char> s)
     -> basic_string_view<Char> {
-  return {s.data(), s.size()};
+  return s;
 }
 }  // namespace detail_exported
 
+// A generic formatting context with custom output iterator and character
+// (code unit) support. Char is the format string code unit type which can be
+// different from OutputIt::value_type.
+template <typename OutputIt, typename Char> class generic_context {
+ private:
+  OutputIt out_;
+  basic_format_args<generic_context> args_;
+  detail::locale_ref loc_;
+
+ public:
+  using char_type = Char;
+  using iterator = OutputIt;
+  using parse_context_type = basic_format_parse_context<Char>;
+  template <typename T> using formatter_type = formatter<T, Char>;
+
+  constexpr generic_context(OutputIt out,
+                            basic_format_args<generic_context> ctx_args,
+                            detail::locale_ref loc = {})
+      : out_(out), args_(ctx_args), loc_(loc) {}
+  generic_context(generic_context&&) = default;
+  generic_context(const generic_context&) = delete;
+  void operator=(const generic_context&) = delete;
+
+  constexpr auto arg(int id) const -> basic_format_arg<generic_context> {
+    return args_.get(id);
+  }
+  auto arg(basic_string_view<Char> name) -> basic_format_arg<generic_context> {
+    return args_.get(name);
+  }
+  FMT_CONSTEXPR auto arg_id(basic_string_view<Char> name) -> int {
+    return args_.get_id(name);
+  }
+  auto args() const -> const basic_format_args<generic_context>& {
+    return args_;
+  }
+
+  FMT_CONSTEXPR auto out() -> iterator { return out_; }
+
+  void advance_to(iterator it) {
+    if (!detail::is_back_insert_iterator<iterator>()) out_ = it;
+  }
+
+  FMT_CONSTEXPR auto locale() -> detail::locale_ref { return loc_; }
+};
+
 class loc_value {
  private:
   basic_format_arg<format_context> value_;
@@ -1054,7 +1041,7 @@ class loc_value {
   loc_value(T) {}
 
   template <typename Visitor> auto visit(Visitor&& vis) -> decltype(vis(0)) {
-    return visit_format_arg(vis, value_);
+    return value_.visit(vis);
   }
 };
 
@@ -1068,7 +1055,7 @@ template <typename Locale> class format_facet : public Locale::facet {
 
  protected:
   virtual auto do_put(appender out, loc_value val,
-                      const format_specs<>& specs) const -> bool;
+                      const format_specs& specs) const -> bool;
 
  public:
   static FMT_API typename Locale::id id;
@@ -1081,12 +1068,14 @@ template <typename Locale> class format_facet : public Locale::facet {
         grouping_(g.begin(), g.end()),
         decimal_point_(decimal_point) {}
 
-  auto put(appender out, loc_value val, const format_specs<>& specs) const
+  auto put(appender out, loc_value val, const format_specs& specs) const
       -> bool {
     return do_put(out, val, specs);
   }
 };
 
+FMT_END_EXPORT
+
 namespace detail {
 
 // Returns true if value is negative, false otherwise.
@@ -1138,7 +1127,7 @@ template <typename Char, typename Sign> constexpr auto sign(Sign s) -> Char {
 #if !FMT_GCC_VERSION || FMT_GCC_VERSION >= 604
   static_assert(std::is_same<Sign, sign_t>::value, "");
 #endif
-  return static_cast<Char>("\0-+ "[s]);
+  return static_cast<char>(((' ' << 24) | ('+' << 16) | ('-' << 8)) >> (s * 8));
 }
 
 template <typename T> FMT_CONSTEXPR auto count_digits_fallback(T n) -> int {
@@ -1186,9 +1175,7 @@ inline auto do_count_digits(uint64_t n) -> int {
 // except for n == 0 in which case count_digits returns 1.
 FMT_CONSTEXPR20 inline auto count_digits(uint64_t n) -> int {
 #ifdef FMT_BUILTIN_CLZLL
-  if (!is_constant_evaluated()) {
-    return do_count_digits(n);
-  }
+  if (!is_constant_evaluated()) return do_count_digits(n);
 #endif
   return count_digits_fallback(n);
 }
@@ -1334,7 +1321,7 @@ FMT_CONSTEXPR inline auto format_decimal(Iterator out, UInt value, int size)
   // Buffer is large enough to hold all digits (digits10 + 1).
   Char buffer[digits10<UInt>() + 1] = {};
   auto end = format_decimal(buffer, value, size).end;
-  return {out, detail::copy_str_noinline<Char>(buffer, end, out)};
+  return {out, detail::copy_noinline<Char>(buffer, end, out)};
 }
 
 template <unsigned BASE_BITS, typename Char, typename UInt>
@@ -1361,7 +1348,7 @@ FMT_CONSTEXPR inline auto format_uint(It out, UInt value, int num_digits,
   // Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
   char buffer[num_bits<UInt>() / BASE_BITS + 1] = {};
   format_uint<BASE_BITS>(buffer, value, num_digits, upper);
-  return detail::copy_str_noinline<Char>(buffer, buffer + num_digits, out);
+  return detail::copy_noinline<Char>(buffer, buffer + num_digits, out);
 }
 
 // A converter from UTF-8 to UTF-16.
@@ -1711,23 +1698,23 @@ constexpr auto convert_float(T value) -> convert_float_result<T> {
   return static_cast<convert_float_result<T>>(value);
 }
 
-template <typename OutputIt, typename Char>
-FMT_NOINLINE FMT_CONSTEXPR auto fill(OutputIt it, size_t n,
-                                     const fill_t<Char>& fill) -> OutputIt {
+template <typename Char, typename OutputIt>
+FMT_NOINLINE FMT_CONSTEXPR auto fill(OutputIt it, size_t n, const fill_t& fill)
+    -> OutputIt {
   auto fill_size = fill.size();
-  if (fill_size == 1) return detail::fill_n(it, n, fill[0]);
-  auto data = fill.data();
-  for (size_t i = 0; i < n; ++i)
-    it = copy_str<Char>(data, data + fill_size, it);
+  if (fill_size == 1) return detail::fill_n(it, n, fill.template get<Char>());
+  if (const Char* data = fill.template data<Char>()) {
+    for (size_t i = 0; i < n; ++i) it = copy<Char>(data, data + fill_size, it);
+  }
   return it;
 }
 
 // Writes the output of f, padded according to format specifications in specs.
 // size: output size in code units.
 // width: output display width in (terminal) column positions.
-template <align::type align = align::left, typename OutputIt, typename Char,
+template <typename Char, align::type align = align::left, typename OutputIt,
           typename F>
-FMT_CONSTEXPR auto write_padded(OutputIt out, const format_specs<Char>& specs,
+FMT_CONSTEXPR auto write_padded(OutputIt out, const format_specs& specs,
                                 size_t size, size_t width, F&& f) -> OutputIt {
   static_assert(align == align::left || align == align::right, "");
   unsigned spec_width = to_unsigned(specs.width);
@@ -1738,31 +1725,31 @@ FMT_CONSTEXPR auto write_padded(OutputIt out, const format_specs<Char>& specs,
   size_t left_padding = padding >> shifts[specs.align];
   size_t right_padding = padding - left_padding;
   auto it = reserve(out, size + padding * specs.fill.size());
-  if (left_padding != 0) it = fill(it, left_padding, specs.fill);
+  if (left_padding != 0) it = fill<Char>(it, left_padding, specs.fill);
   it = f(it);
-  if (right_padding != 0) it = fill(it, right_padding, specs.fill);
+  if (right_padding != 0) it = fill<Char>(it, right_padding, specs.fill);
   return base_iterator(out, it);
 }
 
-template <align::type align = align::left, typename OutputIt, typename Char,
+template <typename Char, align::type align = align::left, typename OutputIt,
           typename F>
-constexpr auto write_padded(OutputIt out, const format_specs<Char>& specs,
+constexpr auto write_padded(OutputIt out, const format_specs& specs,
                             size_t size, F&& f) -> OutputIt {
-  return write_padded<align>(out, specs, size, size, f);
+  return write_padded<Char, align>(out, specs, size, size, f);
 }
 
-template <align::type align = align::left, typename Char, typename OutputIt>
+template <typename Char, align::type align = align::left, typename OutputIt>
 FMT_CONSTEXPR auto write_bytes(OutputIt out, string_view bytes,
-                               const format_specs<Char>& specs) -> OutputIt {
-  return write_padded<align>(
+                               const format_specs& specs = {}) -> OutputIt {
+  return write_padded<Char, align>(
       out, specs, bytes.size(), [bytes](reserve_iterator<OutputIt> it) {
         const char* data = bytes.data();
-        return copy_str<Char>(data, data + bytes.size(), it);
+        return copy<Char>(data, data + bytes.size(), it);
       });
 }
 
 template <typename Char, typename OutputIt, typename UIntPtr>
-auto write_ptr(OutputIt out, UIntPtr value, const format_specs<Char>* specs)
+auto write_ptr(OutputIt out, UIntPtr value, const format_specs* specs)
     -> OutputIt {
   int num_digits = count_digits<4>(value);
   auto size = to_unsigned(num_digits) + size_t(2);
@@ -1771,7 +1758,7 @@ auto write_ptr(OutputIt out, UIntPtr value, const format_specs<Char>* specs)
     *it++ = static_cast<Char>('x');
     return format_uint<4, Char>(it, value, num_digits);
   };
-  return specs ? write_padded<align::right>(out, *specs, size, write)
+  return specs ? write_padded<Char, align::right>(out, *specs, size, write)
                : base_iterator(out, write(reserve(out, size)));
 }
 
@@ -1789,17 +1776,11 @@ template <typename Char> struct find_escape_result {
   uint32_t cp;
 };
 
-template <typename Char>
-using make_unsigned_char =
-    typename conditional_t<std::is_integral<Char>::value,
-                           std::make_unsigned<Char>,
-                           type_identity<uint32_t>>::type;
-
 template <typename Char>
 auto find_escape(const Char* begin, const Char* end)
     -> find_escape_result<Char> {
   for (; begin != end; ++begin) {
-    uint32_t cp = static_cast<make_unsigned_char<Char>>(*begin);
+    uint32_t cp = static_cast<unsigned_char<Char>>(*begin);
     if (const_check(sizeof(Char) == 1) && cp >= 0x80) continue;
     if (needs_escape(cp)) return {begin, begin + 1, cp};
   }
@@ -1808,7 +1789,7 @@ auto find_escape(const Char* begin, const Char* end)
 
 inline auto find_escape(const char* begin, const char* end)
     -> find_escape_result<char> {
-  if (!is_utf8()) return find_escape<char>(begin, end);
+  if (!use_utf8()) return find_escape<char>(begin, end);
   auto result = find_escape_result<char>{end, nullptr, 0};
   for_each_codepoint(string_view(begin, to_unsigned(end - begin)),
                      [&](uint32_t cp, string_view sv) {
@@ -1836,14 +1817,12 @@ inline auto find_escape(const char* begin, const char* end)
   }()
 
 /**
-  \rst
-  Constructs a compile-time format string from a string literal *s*.
-
-  **Example**::
-
-    // A compile-time error because 'd' is an invalid specifier for strings.
-    std::string s = fmt::format(FMT_STRING("{:d}"), "foo");
-  \endrst
+ * Constructs a compile-time format string from a string literal `s`.
+ *
+ * **Example**:
+ *
+ *     // A compile-time error because 'd' is an invalid specifier for strings.
+ *     std::string s = fmt::format(FMT_STRING("{:d}"), "foo");
  */
 #define FMT_STRING(s) FMT_STRING_IMPL(s, fmt::detail::compile_string, )
 
@@ -1854,7 +1833,7 @@ auto write_codepoint(OutputIt out, char prefix, uint32_t cp) -> OutputIt {
   Char buf[width];
   fill_n(buf, width, static_cast<Char>('0'));
   format_uint<4>(buf, cp, width);
-  return copy_str<Char>(buf, buf + width, out);
+  return copy<Char>(buf, buf + width, out);
 }
 
 template <typename OutputIt, typename Char>
@@ -1882,15 +1861,11 @@ auto write_escaped_cp(OutputIt out, const find_escape_result<Char>& escape)
     *out++ = static_cast<Char>('\\');
     break;
   default:
-    if (escape.cp < 0x100) {
-      return write_codepoint<2, Char>(out, 'x', escape.cp);
-    }
-    if (escape.cp < 0x10000) {
+    if (escape.cp < 0x100) return write_codepoint<2, Char>(out, 'x', escape.cp);
+    if (escape.cp < 0x10000)
       return write_codepoint<4, Char>(out, 'u', escape.cp);
-    }
-    if (escape.cp < 0x110000) {
+    if (escape.cp < 0x110000)
       return write_codepoint<8, Char>(out, 'U', escape.cp);
-    }
     for (Char escape_char : basic_string_view<Char>(
              escape.begin, to_unsigned(escape.end - escape.begin))) {
       out = write_codepoint<2, Char>(out, 'x',
@@ -1909,7 +1884,7 @@ auto write_escaped_string(OutputIt out, basic_string_view<Char> str)
   auto begin = str.begin(), end = str.end();
   do {
     auto escape = find_escape(begin, end);
-    out = copy_str<Char>(begin, escape.begin, out);
+    out = copy<Char>(begin, escape.begin, out);
     begin = escape.end;
     if (!begin) break;
     out = write_escaped_cp<OutputIt, Char>(out, escape);
@@ -1936,24 +1911,23 @@ auto write_escaped_char(OutputIt out, Char v) -> OutputIt {
 
 template <typename Char, typename OutputIt>
 FMT_CONSTEXPR auto write_char(OutputIt out, Char value,
-                              const format_specs<Char>& specs) -> OutputIt {
+                              const format_specs& specs) -> OutputIt {
   bool is_debug = specs.type == presentation_type::debug;
-  return write_padded(out, specs, 1, [=](reserve_iterator<OutputIt> it) {
+  return write_padded<Char>(out, specs, 1, [=](reserve_iterator<OutputIt> it) {
     if (is_debug) return write_escaped_char(it, value);
     *it++ = value;
     return it;
   });
 }
 template <typename Char, typename OutputIt>
-FMT_CONSTEXPR auto write(OutputIt out, Char value,
-                         const format_specs<Char>& specs, locale_ref loc = {})
-    -> OutputIt {
+FMT_CONSTEXPR auto write(OutputIt out, Char value, const format_specs& specs,
+                         locale_ref loc = {}) -> OutputIt {
   // char is formatted as unsigned char for consistency across platforms.
   using unsigned_type =
       conditional_t<std::is_same<Char, char>::value, unsigned char, unsigned>;
   return check_char_specs(specs)
-             ? write_char(out, value, specs)
-             : write(out, static_cast<unsigned_type>(value), specs, loc);
+             ? write_char<Char>(out, value, specs)
+             : write<Char>(out, static_cast<unsigned_type>(value), specs, loc);
 }
 
 // Data for write_int that doesn't depend on output iterator type. It is used to
@@ -1963,7 +1937,7 @@ template <typename Char> struct write_int_data {
   size_t padding;
 
   FMT_CONSTEXPR write_int_data(int num_digits, unsigned prefix,
-                               const format_specs<Char>& specs)
+                               const format_specs& specs)
       : size((prefix >> 24) + to_unsigned(num_digits)), padding(0) {
     if (specs.align == align::numeric) {
       auto width = to_unsigned(specs.width);
@@ -1982,10 +1956,10 @@ template <typename Char> struct write_int_data {
 //   <left-padding><prefix><numeric-padding><digits><right-padding>
 // where <digits> are written by write_digits(it).
 // prefix contains chars in three lower bytes and the size in the fourth byte.
-template <typename OutputIt, typename Char, typename W>
+template <typename Char, typename OutputIt, typename W>
 FMT_CONSTEXPR FMT_INLINE auto write_int(OutputIt out, int num_digits,
                                         unsigned prefix,
-                                        const format_specs<Char>& specs,
+                                        const format_specs& specs,
                                         W write_digits) -> OutputIt {
   // Slightly faster check for specs.width == 0 && specs.precision == -1.
   if ((specs.width | (specs.precision + 1)) == 0) {
@@ -1997,7 +1971,7 @@ FMT_CONSTEXPR FMT_INLINE auto write_int(OutputIt out, int num_digits,
     return base_iterator(out, write_digits(it));
   }
   auto data = write_int_data<Char>(num_digits, prefix, specs);
-  return write_padded<align::right>(
+  return write_padded<Char, align::right>(
       out, specs, data.size, [=](reserve_iterator<OutputIt> it) {
         for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8)
           *it++ = static_cast<Char>(p & 0xff);
@@ -2060,9 +2034,8 @@ template <typename Char> class digit_grouping {
     for (int i = 0, sep_index = static_cast<int>(separators.size() - 1);
          i < num_digits; ++i) {
       if (num_digits - i == separators[sep_index]) {
-        out =
-            copy_str<Char>(thousands_sep_.data(),
-                           thousands_sep_.data() + thousands_sep_.size(), out);
+        out = copy<Char>(thousands_sep_.data(),
+                         thousands_sep_.data() + thousands_sep_.size(), out);
         --sep_index;
       }
       *out++ = static_cast<Char>(digits[to_unsigned(i)]);
@@ -2079,37 +2052,27 @@ FMT_CONSTEXPR inline void prefix_append(unsigned& prefix, unsigned value) {
 // Writes a decimal integer with digit grouping.
 template <typename OutputIt, typename UInt, typename Char>
 auto write_int(OutputIt out, UInt value, unsigned prefix,
-               const format_specs<Char>& specs,
-               const digit_grouping<Char>& grouping) -> OutputIt {
+               const format_specs& specs, const digit_grouping<Char>& grouping)
+    -> OutputIt {
   static_assert(std::is_same<uint64_or_128_t<UInt>, UInt>::value, "");
   int num_digits = 0;
   auto buffer = memory_buffer();
   switch (specs.type) {
+  default:
+    FMT_ASSERT(false, "");
+    FMT_FALLTHROUGH;
   case presentation_type::none:
-  case presentation_type::dec: {
+  case presentation_type::dec:
     num_digits = count_digits(value);
     format_decimal<char>(appender(buffer), value, num_digits);
     break;
-  }
-  case presentation_type::hex_lower:
-  case presentation_type::hex_upper: {
-    bool upper = specs.type == presentation_type::hex_upper;
+  case presentation_type::hex:
     if (specs.alt)
-      prefix_append(prefix, unsigned(upper ? 'X' : 'x') << 8 | '0');
+      prefix_append(prefix, unsigned(specs.upper ? 'X' : 'x') << 8 | '0');
     num_digits = count_digits<4>(value);
-    format_uint<4, char>(appender(buffer), value, num_digits, upper);
-    break;
-  }
-  case presentation_type::bin_lower:
-  case presentation_type::bin_upper: {
-    bool upper = specs.type == presentation_type::bin_upper;
-    if (specs.alt)
-      prefix_append(prefix, unsigned(upper ? 'B' : 'b') << 8 | '0');
-    num_digits = count_digits<1>(value);
-    format_uint<1, char>(appender(buffer), value, num_digits);
+    format_uint<4, char>(appender(buffer), value, num_digits, specs.upper);
     break;
-  }
-  case presentation_type::oct: {
+  case presentation_type::oct:
     num_digits = count_digits<3>(value);
     // Octal prefix '0' is counted as a digit, so only add it if precision
     // is not greater than the number of digits.
@@ -2117,16 +2080,19 @@ auto write_int(OutputIt out, UInt value, unsigned prefix,
       prefix_append(prefix, '0');
     format_uint<3, char>(appender(buffer), value, num_digits);
     break;
-  }
+  case presentation_type::bin:
+    if (specs.alt)
+      prefix_append(prefix, unsigned(specs.upper ? 'B' : 'b') << 8 | '0');
+    num_digits = count_digits<1>(value);
+    format_uint<1, char>(appender(buffer), value, num_digits);
+    break;
   case presentation_type::chr:
-    return write_char(out, static_cast<Char>(value), specs);
-  default:
-    throw_format_error("invalid format specifier");
+    return write_char<Char>(out, static_cast<Char>(value), specs);
   }
 
   unsigned size = (prefix != 0 ? prefix >> 24 : 0) + to_unsigned(num_digits) +
                   to_unsigned(grouping.count_separators(num_digits));
-  return write_padded<align::right>(
+  return write_padded<Char, align::right>(
       out, specs, size, size, [&](reserve_iterator<OutputIt> it) {
         for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8)
           *it++ = static_cast<Char>(p & 0xff);
@@ -2135,11 +2101,11 @@ auto write_int(OutputIt out, UInt value, unsigned prefix,
 }
 
 // Writes a localized value.
-FMT_API auto write_loc(appender out, loc_value value,
-                       const format_specs<>& specs, locale_ref loc) -> bool;
-template <typename OutputIt, typename Char>
-inline auto write_loc(OutputIt, loc_value, const format_specs<Char>&,
-                      locale_ref) -> bool {
+FMT_API auto write_loc(appender out, loc_value value, const format_specs& specs,
+                       locale_ref loc) -> bool;
+template <typename OutputIt>
+inline auto write_loc(OutputIt, loc_value, const format_specs&, locale_ref)
+    -> bool {
   return false;
 }
 
@@ -2165,8 +2131,8 @@ FMT_CONSTEXPR auto make_write_int_arg(T value, sign_t sign)
 }
 
 template <typename Char = char> struct loc_writer {
-  buffer_appender<Char> out;
-  const format_specs<Char>& specs;
+  basic_appender<Char> out;
+  const format_specs& specs;
   std::basic_string<Char> sep;
   std::string grouping;
   std::basic_string<Char> decimal_point;
@@ -2187,87 +2153,86 @@ template <typename Char = char> struct loc_writer {
 
 template <typename Char, typename OutputIt, typename T>
 FMT_CONSTEXPR FMT_INLINE auto write_int(OutputIt out, write_int_arg<T> arg,
-                                        const format_specs<Char>& specs,
-                                        locale_ref) -> OutputIt {
+                                        const format_specs& specs, locale_ref)
+    -> OutputIt {
   static_assert(std::is_same<T, uint32_or_64_or_128_t<T>>::value, "");
   auto abs_value = arg.abs_value;
   auto prefix = arg.prefix;
   switch (specs.type) {
+  default:
+    FMT_ASSERT(false, "");
+    FMT_FALLTHROUGH;
   case presentation_type::none:
   case presentation_type::dec: {
-    auto num_digits = count_digits(abs_value);
-    return write_int(
+    int num_digits = count_digits(abs_value);
+    return write_int<Char>(
         out, num_digits, prefix, specs, [=](reserve_iterator<OutputIt> it) {
           return format_decimal<Char>(it, abs_value, num_digits).end;
         });
   }
-  case presentation_type::hex_lower:
-  case presentation_type::hex_upper: {
-    bool upper = specs.type == presentation_type::hex_upper;
+  case presentation_type::hex: {
     if (specs.alt)
-      prefix_append(prefix, unsigned(upper ? 'X' : 'x') << 8 | '0');
+      prefix_append(prefix, unsigned(specs.upper ? 'X' : 'x') << 8 | '0');
     int num_digits = count_digits<4>(abs_value);
-    return write_int(
+    return write_int<Char>(
         out, num_digits, prefix, specs, [=](reserve_iterator<OutputIt> it) {
-          return format_uint<4, Char>(it, abs_value, num_digits, upper);
+          return format_uint<4, Char>(it, abs_value, num_digits, specs.upper);
         });
   }
-  case presentation_type::bin_lower:
-  case presentation_type::bin_upper: {
-    bool upper = specs.type == presentation_type::bin_upper;
-    if (specs.alt)
-      prefix_append(prefix, unsigned(upper ? 'B' : 'b') << 8 | '0');
-    int num_digits = count_digits<1>(abs_value);
-    return write_int(out, num_digits, prefix, specs,
-                     [=](reserve_iterator<OutputIt> it) {
-                       return format_uint<1, Char>(it, abs_value, num_digits);
-                     });
-  }
   case presentation_type::oct: {
     int num_digits = count_digits<3>(abs_value);
     // Octal prefix '0' is counted as a digit, so only add it if precision
     // is not greater than the number of digits.
     if (specs.alt && specs.precision <= num_digits && abs_value != 0)
       prefix_append(prefix, '0');
-    return write_int(out, num_digits, prefix, specs,
-                     [=](reserve_iterator<OutputIt> it) {
-                       return format_uint<3, Char>(it, abs_value, num_digits);
-                     });
+    return write_int<Char>(
+        out, num_digits, prefix, specs, [=](reserve_iterator<OutputIt> it) {
+          return format_uint<3, Char>(it, abs_value, num_digits);
+        });
+  }
+  case presentation_type::bin: {
+    if (specs.alt)
+      prefix_append(prefix, unsigned(specs.upper ? 'B' : 'b') << 8 | '0');
+    int num_digits = count_digits<1>(abs_value);
+    return write_int<Char>(
+        out, num_digits, prefix, specs, [=](reserve_iterator<OutputIt> it) {
+          return format_uint<1, Char>(it, abs_value, num_digits);
+        });
   }
   case presentation_type::chr:
-    return write_char(out, static_cast<Char>(abs_value), specs);
-  default:
-    throw_format_error("invalid format specifier");
+    return write_char<Char>(out, static_cast<Char>(abs_value), specs);
   }
-  return out;
 }
 template <typename Char, typename OutputIt, typename T>
-FMT_CONSTEXPR FMT_NOINLINE auto write_int_noinline(
-    OutputIt out, write_int_arg<T> arg, const format_specs<Char>& specs,
-    locale_ref loc) -> OutputIt {
-  return write_int(out, arg, specs, loc);
+FMT_CONSTEXPR FMT_NOINLINE auto write_int_noinline(OutputIt out,
+                                                   write_int_arg<T> arg,
+                                                   const format_specs& specs,
+                                                   locale_ref loc) -> OutputIt {
+  return write_int<Char>(out, arg, specs, loc);
 }
-template <typename Char, typename OutputIt, typename T,
+template <typename Char, typename T,
           FMT_ENABLE_IF(is_integral<T>::value &&
                         !std::is_same<T, bool>::value &&
-                        std::is_same<OutputIt, buffer_appender<Char>>::value)>
-FMT_CONSTEXPR FMT_INLINE auto write(OutputIt out, T value,
-                                    const format_specs<Char>& specs,
-                                    locale_ref loc) -> OutputIt {
+                        !std::is_same<T, Char>::value)>
+FMT_CONSTEXPR FMT_INLINE auto write(basic_appender<Char> out, T value,
+                                    const format_specs& specs, locale_ref loc)
+    -> basic_appender<Char> {
   if (specs.localized && write_loc(out, value, specs, loc)) return out;
-  return write_int_noinline(out, make_write_int_arg(value, specs.sign), specs,
-                            loc);
+  return write_int_noinline<Char>(out, make_write_int_arg(value, specs.sign),
+                                  specs, loc);
 }
 // An inlined version of write used in format string compilation.
 template <typename Char, typename OutputIt, typename T,
           FMT_ENABLE_IF(is_integral<T>::value &&
                         !std::is_same<T, bool>::value &&
-                        !std::is_same<OutputIt, buffer_appender<Char>>::value)>
+                        !std::is_same<T, Char>::value &&
+                        !std::is_same<OutputIt, basic_appender<Char>>::value)>
 FMT_CONSTEXPR FMT_INLINE auto write(OutputIt out, T value,
-                                    const format_specs<Char>& specs,
-                                    locale_ref loc) -> OutputIt {
+                                    const format_specs& specs, locale_ref loc)
+    -> OutputIt {
   if (specs.localized && write_loc(out, value, specs, loc)) return out;
-  return write_int(out, make_write_int_arg(value, specs.sign), specs, loc);
+  return write_int<Char>(out, make_write_int_arg(value, specs.sign), specs,
+                         loc);
 }
 
 // An output iterator that counts the number of objects written to it and
@@ -2312,40 +2277,41 @@ class counting_iterator {
 
 template <typename Char, typename OutputIt>
 FMT_CONSTEXPR auto write(OutputIt out, basic_string_view<Char> s,
-                         const format_specs<Char>& specs) -> OutputIt {
+                         const format_specs& specs) -> OutputIt {
   auto data = s.data();
   auto size = s.size();
   if (specs.precision >= 0 && to_unsigned(specs.precision) < size)
     size = code_point_index(s, to_unsigned(specs.precision));
   bool is_debug = specs.type == presentation_type::debug;
   size_t width = 0;
+
+  if (is_debug) size = write_escaped_string(counting_iterator{}, s).count();
+
   if (specs.width != 0) {
     if (is_debug)
-      width = write_escaped_string(counting_iterator{}, s).count();
+      width = size;
     else
       width = compute_width(basic_string_view<Char>(data, size));
   }
-  return write_padded(out, specs, size, width,
-                      [=](reserve_iterator<OutputIt> it) {
-                        if (is_debug) return write_escaped_string(it, s);
-                        return copy_str<Char>(data, data + size, it);
-                      });
+  return write_padded<Char>(out, specs, size, width,
+                            [=](reserve_iterator<OutputIt> it) {
+                              if (is_debug) return write_escaped_string(it, s);
+                              return copy<Char>(data, data + size, it);
+                            });
 }
 template <typename Char, typename OutputIt>
 FMT_CONSTEXPR auto write(OutputIt out,
                          basic_string_view<type_identity_t<Char>> s,
-                         const format_specs<Char>& specs, locale_ref)
-    -> OutputIt {
-  return write(out, s, specs);
+                         const format_specs& specs, locale_ref) -> OutputIt {
+  return write<Char>(out, s, specs);
 }
 template <typename Char, typename OutputIt>
-FMT_CONSTEXPR auto write(OutputIt out, const Char* s,
-                         const format_specs<Char>& specs, locale_ref)
-    -> OutputIt {
+FMT_CONSTEXPR auto write(OutputIt out, const Char* s, const format_specs& specs,
+                         locale_ref) -> OutputIt {
   if (specs.type == presentation_type::pointer)
     return write_ptr<Char>(out, bit_cast<uintptr_t>(s), &specs);
-  if (!s) throw_format_error("string pointer is null");
-  return write(out, basic_string_view<Char>(s), specs, {});
+  if (!s) report_error("string pointer is null");
+  return write<Char>(out, basic_string_view<Char>(s), specs, {});
 }
 
 template <typename Char, typename OutputIt, typename T,
@@ -2359,21 +2325,19 @@ FMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt {
   if (negative) abs_value = ~abs_value + 1;
   int num_digits = count_digits(abs_value);
   auto size = (negative ? 1 : 0) + static_cast<size_t>(num_digits);
-  auto it = reserve(out, size);
-  if (auto ptr = to_pointer<Char>(it, size)) {
+  if (auto ptr = to_pointer<Char>(out, size)) {
     if (negative) *ptr++ = static_cast<Char>('-');
     format_decimal<Char>(ptr, abs_value, num_digits);
     return out;
   }
-  if (negative) *it++ = static_cast<Char>('-');
-  it = format_decimal<Char>(it, abs_value, num_digits).end;
-  return base_iterator(out, it);
+  if (negative) *out++ = static_cast<Char>('-');
+  return format_decimal<Char>(out, abs_value, num_digits).end;
 }
 
 // DEPRECATED!
 template <typename Char>
 FMT_CONSTEXPR auto parse_align(const Char* begin, const Char* end,
-                               format_specs<Char>& specs) -> const Char* {
+                               format_specs& specs) -> const Char* {
   FMT_ASSERT(begin != end, "");
   auto align = align::none;
   auto p = begin + code_point_length(begin);
@@ -2395,10 +2359,10 @@ FMT_CONSTEXPR auto parse_align(const Char* begin, const Char* end,
         auto c = *begin;
         if (c == '}') return begin;
         if (c == '{') {
-          throw_format_error("invalid fill character '{'");
+          report_error("invalid fill character '{'");
           return begin;
         }
-        specs.fill = {begin, to_unsigned(p - begin)};
+        specs.fill = basic_string_view<Char>(begin, to_unsigned(p - begin));
         begin = p + 1;
       } else {
         ++begin;
@@ -2417,58 +2381,40 @@ FMT_CONSTEXPR auto parse_align(const Char* begin, const Char* end,
 enum class float_format : unsigned char {
   general,  // General: exponent notation or fixed point based on magnitude.
   exp,      // Exponent notation with the default precision of 6, e.g. 1.2e-3.
-  fixed,    // Fixed point with the default precision of 6, e.g. 0.0012.
-  hex
+  fixed     // Fixed point with the default precision of 6, e.g. 0.0012.
 };
 
 struct float_specs {
   int precision;
   float_format format : 8;
   sign_t sign : 8;
-  bool upper : 1;
   bool locale : 1;
   bool binary32 : 1;
   bool showpoint : 1;
 };
 
-template <typename Char>
-FMT_CONSTEXPR auto parse_float_type_spec(const format_specs<Char>& specs)
+// DEPRECATED!
+FMT_CONSTEXPR inline auto parse_float_type_spec(const format_specs& specs)
     -> float_specs {
   auto result = float_specs();
   result.showpoint = specs.alt;
   result.locale = specs.localized;
   switch (specs.type) {
-  case presentation_type::none:
-    result.format = float_format::general;
-    break;
-  case presentation_type::general_upper:
-    result.upper = true;
+  default:
     FMT_FALLTHROUGH;
-  case presentation_type::general_lower:
+  case presentation_type::none:
     result.format = float_format::general;
     break;
-  case presentation_type::exp_upper:
-    result.upper = true;
-    FMT_FALLTHROUGH;
-  case presentation_type::exp_lower:
+  case presentation_type::exp:
     result.format = float_format::exp;
     result.showpoint |= specs.precision != 0;
     break;
-  case presentation_type::fixed_upper:
-    result.upper = true;
-    FMT_FALLTHROUGH;
-  case presentation_type::fixed_lower:
+  case presentation_type::fixed:
     result.format = float_format::fixed;
     result.showpoint |= specs.precision != 0;
     break;
-  case presentation_type::hexfloat_upper:
-    result.upper = true;
-    FMT_FALLTHROUGH;
-  case presentation_type::hexfloat_lower:
-    result.format = float_format::hex;
-    break;
-  default:
-    throw_format_error("invalid format specifier");
+  case presentation_type::general:
+    result.format = float_format::general;
     break;
   }
   return result;
@@ -2476,21 +2422,21 @@ FMT_CONSTEXPR auto parse_float_type_spec(const format_specs<Char>& specs)
 
 template <typename Char, typename OutputIt>
 FMT_CONSTEXPR20 auto write_nonfinite(OutputIt out, bool isnan,
-                                     format_specs<Char> specs,
-                                     const float_specs& fspecs) -> OutputIt {
+                                     format_specs specs, sign_t sign)
+    -> OutputIt {
   auto str =
-      isnan ? (fspecs.upper ? "NAN" : "nan") : (fspecs.upper ? "INF" : "inf");
+      isnan ? (specs.upper ? "NAN" : "nan") : (specs.upper ? "INF" : "inf");
   constexpr size_t str_size = 3;
-  auto sign = fspecs.sign;
   auto size = str_size + (sign ? 1 : 0);
   // Replace '0'-padding with space for non-finite values.
   const bool is_zero_fill =
-      specs.fill.size() == 1 && *specs.fill.data() == static_cast<Char>('0');
-  if (is_zero_fill) specs.fill[0] = static_cast<Char>(' ');
-  return write_padded(out, specs, size, [=](reserve_iterator<OutputIt> it) {
-    if (sign) *it++ = detail::sign<Char>(sign);
-    return copy_str<Char>(str, str + str_size, it);
-  });
+      specs.fill.size() == 1 && specs.fill.template get<Char>() == '0';
+  if (is_zero_fill) specs.fill = ' ';
+  return write_padded<Char>(out, specs, size,
+                            [=](reserve_iterator<OutputIt> it) {
+                              if (sign) *it++ = detail::sign<Char>(sign);
+                              return copy<Char>(str, str + str_size, it);
+                            });
 }
 
 // A decimal floating-point number significand * pow(10, exp).
@@ -2511,7 +2457,7 @@ inline auto get_significand_size(const dragonbox::decimal_fp<T>& f) -> int {
 template <typename Char, typename OutputIt>
 constexpr auto write_significand(OutputIt out, const char* significand,
                                  int significand_size) -> OutputIt {
-  return copy_str<Char>(significand, significand + significand_size, out);
+  return copy<Char>(significand, significand + significand_size, out);
 }
 template <typename Char, typename OutputIt, typename UInt>
 inline auto write_significand(OutputIt out, UInt significand,
@@ -2564,19 +2510,19 @@ inline auto write_significand(OutputIt out, UInt significand,
   Char buffer[digits10<UInt>() + 2];
   auto end = write_significand(buffer, significand, significand_size,
                                integral_size, decimal_point);
-  return detail::copy_str_noinline<Char>(buffer, end, out);
+  return detail::copy_noinline<Char>(buffer, end, out);
 }
 
 template <typename OutputIt, typename Char>
 FMT_CONSTEXPR auto write_significand(OutputIt out, const char* significand,
                                      int significand_size, int integral_size,
                                      Char decimal_point) -> OutputIt {
-  out = detail::copy_str_noinline<Char>(significand,
-                                        significand + integral_size, out);
+  out = detail::copy_noinline<Char>(significand, significand + integral_size,
+                                    out);
   if (!decimal_point) return out;
   *out++ = decimal_point;
-  return detail::copy_str_noinline<Char>(significand + integral_size,
-                                         significand + significand_size, out);
+  return detail::copy_noinline<Char>(significand + integral_size,
+                                     significand + significand_size, out);
 }
 
 template <typename OutputIt, typename Char, typename T, typename Grouping>
@@ -2589,18 +2535,18 @@ FMT_CONSTEXPR20 auto write_significand(OutputIt out, T significand,
                              decimal_point);
   }
   auto buffer = basic_memory_buffer<Char>();
-  write_significand(buffer_appender<Char>(buffer), significand,
-                    significand_size, integral_size, decimal_point);
+  write_significand(basic_appender<Char>(buffer), significand, significand_size,
+                    integral_size, decimal_point);
   grouping.apply(
       out, basic_string_view<Char>(buffer.data(), to_unsigned(integral_size)));
-  return detail::copy_str_noinline<Char>(buffer.data() + integral_size,
-                                         buffer.end(), out);
+  return detail::copy_noinline<Char>(buffer.data() + integral_size,
+                                     buffer.end(), out);
 }
 
-template <typename OutputIt, typename DecimalFP, typename Char,
+template <typename Char, typename OutputIt, typename DecimalFP,
           typename Grouping = digit_grouping<Char>>
 FMT_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& f,
-                                    const format_specs<Char>& specs,
+                                    const format_specs& specs,
                                     float_specs fspecs, locale_ref loc)
     -> OutputIt {
   auto significand = f.significand;
@@ -2637,7 +2583,7 @@ FMT_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& f,
     if (abs_output_exp >= 100) exp_digits = abs_output_exp >= 1000 ? 4 : 3;
 
     size += to_unsigned((decimal_point ? 1 : 0) + 2 + exp_digits);
-    char exp_char = fspecs.upper ? 'E' : 'e';
+    char exp_char = specs.upper ? 'E' : 'e';
     auto write = [=](iterator it) {
       if (sign) *it++ = detail::sign<Char>(sign);
       // Insert a decimal point after the first digit and add an exponent.
@@ -2647,8 +2593,9 @@ FMT_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& f,
       *it++ = static_cast<Char>(exp_char);
       return write_exponent<Char>(output_exp, it);
     };
-    return specs.width > 0 ? write_padded<align::right>(out, specs, size, write)
-                           : base_iterator(out, write(reserve(out, size)));
+    return specs.width > 0
+               ? write_padded<Char, align::right>(out, specs, size, write)
+               : base_iterator(out, write(reserve(out, size)));
   }
 
   int exp = f.exponent + significand_size;
@@ -2664,7 +2611,7 @@ FMT_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& f,
     }
     auto grouping = Grouping(loc, fspecs.locale);
     size += to_unsigned(grouping.count_separators(exp));
-    return write_padded<align::right>(out, specs, size, [&](iterator it) {
+    return write_padded<Char, align::right>(out, specs, size, [&](iterator it) {
       if (sign) *it++ = detail::sign<Char>(sign);
       it = write_significand<Char>(it, significand, significand_size,
                                    f.exponent, grouping);
@@ -2678,7 +2625,7 @@ FMT_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& f,
     size += 1 + to_unsigned(num_zeros > 0 ? num_zeros : 0);
     auto grouping = Grouping(loc, fspecs.locale);
     size += to_unsigned(grouping.count_separators(exp));
-    return write_padded<align::right>(out, specs, size, [&](iterator it) {
+    return write_padded<Char, align::right>(out, specs, size, [&](iterator it) {
       if (sign) *it++ = detail::sign<Char>(sign);
       it = write_significand(it, significand, significand_size, exp,
                              decimal_point, grouping);
@@ -2693,7 +2640,7 @@ FMT_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& f,
   }
   bool pointy = num_zeros != 0 || significand_size != 0 || fspecs.showpoint;
   size += 1 + (pointy ? 1 : 0) + to_unsigned(num_zeros);
-  return write_padded<align::right>(out, specs, size, [&](iterator it) {
+  return write_padded<Char, align::right>(out, specs, size, [&](iterator it) {
     if (sign) *it++ = detail::sign<Char>(sign);
     *it++ = zero;
     if (!pointy) return it;
@@ -2717,22 +2664,21 @@ template <typename Char> class fallback_digit_grouping {
   }
 };
 
-template <typename OutputIt, typename DecimalFP, typename Char>
+template <typename Char, typename OutputIt, typename DecimalFP>
 FMT_CONSTEXPR20 auto write_float(OutputIt out, const DecimalFP& f,
-                                 const format_specs<Char>& specs,
-                                 float_specs fspecs, locale_ref loc)
-    -> OutputIt {
+                                 const format_specs& specs, float_specs fspecs,
+                                 locale_ref loc) -> OutputIt {
   if (is_constant_evaluated()) {
-    return do_write_float<OutputIt, DecimalFP, Char,
+    return do_write_float<Char, OutputIt, DecimalFP,
                           fallback_digit_grouping<Char>>(out, f, specs, fspecs,
                                                          loc);
   } else {
-    return do_write_float(out, f, specs, fspecs, loc);
+    return do_write_float<Char>(out, f, specs, fspecs, loc);
   }
 }
 
 template <typename T> constexpr auto isnan(T value) -> bool {
-  return !(value >= value);  // std::isnan doesn't support __float128.
+  return value != value;  // std::isnan doesn't support __float128.
 }
 
 template <typename T, typename Enable = void>
@@ -2878,7 +2824,7 @@ class bigint {
     auto size = other.bigits_.size();
     bigits_.resize(size);
     auto data = other.bigits_.data();
-    copy_str<bigit>(data, data + size, bigits_.data());
+    copy<bigit>(data, data + size, bigits_.data());
     exp_ = other.exp_;
   }
 
@@ -3014,7 +2960,7 @@ class bigint {
     bigits_.resize(to_unsigned(num_bigits + exp_difference));
     for (int i = num_bigits - 1, j = i + exp_difference; i >= 0; --i, --j)
       bigits_[j] = bigits_[i];
-    std::uninitialized_fill_n(bigits_.data(), exp_difference, 0u);
+    memset(bigits_.data(), 0, to_unsigned(exp_difference) * sizeof(bigit));
     exp_ -= exp_difference;
   }
 
@@ -3139,8 +3085,11 @@ FMT_CONSTEXPR20 inline void format_dragon(basic_fp<uint128_t> value,
   // Generate the given number of digits.
   exp10 -= num_digits - 1;
   if (num_digits <= 0) {
-    denominator *= 10;
-    auto digit = add_compare(numerator, numerator, denominator) > 0 ? '1' : '0';
+    auto digit = '0';
+    if (num_digits == 0) {
+      denominator *= 10;
+      digit = add_compare(numerator, numerator, denominator) > 0 ? '1' : '0';
+    }
     buf.push_back(digit);
     return;
   }
@@ -3177,8 +3126,8 @@ FMT_CONSTEXPR20 inline void format_dragon(basic_fp<uint128_t> value,
 
 // Formats a floating-point number using the hexfloat format.
 template <typename Float, FMT_ENABLE_IF(!is_double_double<Float>::value)>
-FMT_CONSTEXPR20 void format_hexfloat(Float value, int precision,
-                                     float_specs specs, buffer<char>& buf) {
+FMT_CONSTEXPR20 void format_hexfloat(Float value, format_specs specs,
+                                     buffer<char>& buf) {
   // float is passed as double to reduce the number of instantiations and to
   // simplify implementation.
   static_assert(!std::is_same<Float, float>::value, "");
@@ -3206,8 +3155,8 @@ FMT_CONSTEXPR20 void format_hexfloat(Float value, int precision,
   if (leading_xdigit > 1) f.e -= (32 - countl_zero(leading_xdigit) - 1);
 
   int print_xdigits = num_xdigits - 1;
-  if (precision >= 0 && print_xdigits > precision) {
-    const int shift = ((print_xdigits - precision - 1) * 4);
+  if (specs.precision >= 0 && print_xdigits > specs.precision) {
+    const int shift = ((print_xdigits - specs.precision - 1) * 4);
     const auto mask = carrier_uint(0xF) << shift;
     const auto v = static_cast<uint32_t>((f.f & mask) >> shift);
 
@@ -3226,7 +3175,7 @@ FMT_CONSTEXPR20 void format_hexfloat(Float value, int precision,
       }
     }
 
-    print_xdigits = precision;
+    print_xdigits = specs.precision;
   }
 
   char xdigits[num_bits<carrier_uint>() / 4];
@@ -3239,10 +3188,10 @@ FMT_CONSTEXPR20 void format_hexfloat(Float value, int precision,
   buf.push_back('0');
   buf.push_back(specs.upper ? 'X' : 'x');
   buf.push_back(xdigits[0]);
-  if (specs.showpoint || print_xdigits > 0 || print_xdigits < precision)
+  if (specs.alt || print_xdigits > 0 || print_xdigits < specs.precision)
     buf.push_back('.');
   buf.append(xdigits + 1, xdigits + 1 + print_xdigits);
-  for (; print_xdigits < precision; ++print_xdigits) buf.push_back('0');
+  for (; print_xdigits < specs.precision; ++print_xdigits) buf.push_back('0');
 
   buf.push_back(specs.upper ? 'P' : 'p');
 
@@ -3258,9 +3207,9 @@ FMT_CONSTEXPR20 void format_hexfloat(Float value, int precision,
 }
 
 template <typename Float, FMT_ENABLE_IF(is_double_double<Float>::value)>
-FMT_CONSTEXPR20 void format_hexfloat(Float value, int precision,
-                                     float_specs specs, buffer<char>& buf) {
-  format_hexfloat(static_cast<double>(value), precision, specs, buf);
+FMT_CONSTEXPR20 void format_hexfloat(Float value, format_specs specs,
+                                     buffer<char>& buf) {
+  format_hexfloat(static_cast<double>(value), specs, buf);
 }
 
 constexpr auto fractional_part_rounding_thresholds(int index) -> uint32_t {
@@ -3312,11 +3261,11 @@ FMT_CONSTEXPR20 auto format_float(Float value, int precision, float_specs specs,
     // Use Dragonbox for the shortest format.
     if (specs.binary32) {
       auto dec = dragonbox::to_decimal(static_cast<float>(value));
-      write<char>(buffer_appender<char>(buf), dec.significand);
+      write<char>(appender(buf), dec.significand);
       return dec.exponent;
     }
     auto dec = dragonbox::to_decimal(static_cast<double>(value));
-    write<char>(buffer_appender<char>(buf), dec.significand);
+    write<char>(appender(buf), dec.significand);
     return dec.exponent;
   } else {
     // Extract significand bits and exponent bits.
@@ -3583,97 +3532,101 @@ FMT_CONSTEXPR20 auto format_float(Float value, int precision, float_specs specs,
   }
   return exp;
 }
+
 template <typename Char, typename OutputIt, typename T>
-FMT_CONSTEXPR20 auto write_float(OutputIt out, T value,
-                                 format_specs<Char> specs, locale_ref loc)
-    -> OutputIt {
-  float_specs fspecs = parse_float_type_spec(specs);
-  fspecs.sign = specs.sign;
+FMT_CONSTEXPR20 auto write_float(OutputIt out, T value, format_specs specs,
+                                 locale_ref loc) -> OutputIt {
+  sign_t sign = specs.sign;
   if (detail::signbit(value)) {  // value < 0 is false for NaN so use signbit.
-    fspecs.sign = sign::minus;
+    sign = sign::minus;
     value = -value;
-  } else if (fspecs.sign == sign::minus) {
-    fspecs.sign = sign::none;
+  } else if (sign == sign::minus) {
+    sign = sign::none;
   }
 
   if (!detail::isfinite(value))
-    return write_nonfinite(out, detail::isnan(value), specs, fspecs);
+    return write_nonfinite<Char>(out, detail::isnan(value), specs, sign);
 
-  if (specs.align == align::numeric && fspecs.sign) {
+  if (specs.align == align::numeric && sign) {
     auto it = reserve(out, 1);
-    *it++ = detail::sign<Char>(fspecs.sign);
+    *it++ = detail::sign<Char>(sign);
     out = base_iterator(out, it);
-    fspecs.sign = sign::none;
+    sign = sign::none;
     if (specs.width != 0) --specs.width;
   }
 
   memory_buffer buffer;
-  if (fspecs.format == float_format::hex) {
-    if (fspecs.sign) buffer.push_back(detail::sign<char>(fspecs.sign));
-    format_hexfloat(convert_float(value), specs.precision, fspecs, buffer);
-    return write_bytes<align::right>(out, {buffer.data(), buffer.size()},
-                                     specs);
+  if (specs.type == presentation_type::hexfloat) {
+    if (sign) buffer.push_back(detail::sign<char>(sign));
+    format_hexfloat(convert_float(value), specs, buffer);
+    return write_bytes<Char, align::right>(out, {buffer.data(), buffer.size()},
+                                           specs);
   }
+
   int precision = specs.precision >= 0 || specs.type == presentation_type::none
                       ? specs.precision
                       : 6;
-  if (fspecs.format == float_format::exp) {
+  if (specs.type == presentation_type::exp) {
     if (precision == max_value<int>())
-      throw_format_error("number is too big");
+      report_error("number is too big");
     else
       ++precision;
-  } else if (fspecs.format != float_format::fixed && precision == 0) {
+  } else if (specs.type != presentation_type::fixed && precision == 0) {
     precision = 1;
   }
+  float_specs fspecs = parse_float_type_spec(specs);
+  fspecs.sign = sign;
   if (const_check(std::is_same<T, float>())) fspecs.binary32 = true;
   int exp = format_float(convert_float(value), precision, fspecs, buffer);
   fspecs.precision = precision;
   auto f = big_decimal_fp{buffer.data(), static_cast<int>(buffer.size()), exp};
-  return write_float(out, f, specs, fspecs, loc);
+  return write_float<Char>(out, f, specs, fspecs, loc);
 }
 
 template <typename Char, typename OutputIt, typename T,
           FMT_ENABLE_IF(is_floating_point<T>::value)>
-FMT_CONSTEXPR20 auto write(OutputIt out, T value, format_specs<Char> specs,
+FMT_CONSTEXPR20 auto write(OutputIt out, T value, format_specs specs,
                            locale_ref loc = {}) -> OutputIt {
   if (const_check(!is_supported_floating_point(value))) return out;
   return specs.localized && write_loc(out, value, specs, loc)
              ? out
-             : write_float(out, value, specs, loc);
+             : write_float<Char>(out, value, specs, loc);
 }
 
 template <typename Char, typename OutputIt, typename T,
           FMT_ENABLE_IF(is_fast_float<T>::value)>
 FMT_CONSTEXPR20 auto write(OutputIt out, T value) -> OutputIt {
-  if (is_constant_evaluated()) return write(out, value, format_specs<Char>());
+  if (is_constant_evaluated()) return write<Char>(out, value, format_specs());
   if (const_check(!is_supported_floating_point(value))) return out;
 
-  auto fspecs = float_specs();
+  auto sign = sign_t::none;
   if (detail::signbit(value)) {
-    fspecs.sign = sign::minus;
+    sign = sign::minus;
     value = -value;
   }
 
-  constexpr auto specs = format_specs<Char>();
+  constexpr auto specs = format_specs();
   using floaty = conditional_t<std::is_same<T, long double>::value, double, T>;
   using floaty_uint = typename dragonbox::float_info<floaty>::carrier_uint;
   floaty_uint mask = exponent_mask<floaty>();
   if ((bit_cast<floaty_uint>(value) & mask) == mask)
-    return write_nonfinite(out, std::isnan(value), specs, fspecs);
+    return write_nonfinite<Char>(out, std::isnan(value), specs, sign);
 
+  auto fspecs = float_specs();
+  fspecs.sign = sign;
   auto dec = dragonbox::to_decimal(static_cast<floaty>(value));
-  return write_float(out, dec, specs, fspecs, {});
+  return write_float<Char>(out, dec, specs, fspecs, {});
 }
 
 template <typename Char, typename OutputIt, typename T,
           FMT_ENABLE_IF(is_floating_point<T>::value &&
                         !is_fast_float<T>::value)>
 inline auto write(OutputIt out, T value) -> OutputIt {
-  return write(out, value, format_specs<Char>());
+  return write<Char>(out, value, format_specs());
 }
 
 template <typename Char, typename OutputIt>
-auto write(OutputIt out, monostate, format_specs<Char> = {}, locale_ref = {})
+auto write(OutputIt out, monostate, format_specs = {}, locale_ref = {})
     -> OutputIt {
   FMT_ASSERT(false, "");
   return out;
@@ -3682,13 +3635,11 @@ auto write(OutputIt out, monostate, format_specs<Char> = {}, locale_ref = {})
 template <typename Char, typename OutputIt>
 FMT_CONSTEXPR auto write(OutputIt out, basic_string_view<Char> value)
     -> OutputIt {
-  auto it = reserve(out, value.size());
-  it = copy_str_noinline<Char>(value.begin(), value.end(), it);
-  return base_iterator(out, it);
+  return copy_noinline<Char>(value.begin(), value.end(), out);
 }
 
 template <typename Char, typename OutputIt, typename T,
-          FMT_ENABLE_IF(is_string<T>::value)>
+          FMT_ENABLE_IF(has_to_string_view<T>::value)>
 constexpr auto write(OutputIt out, const T& value) -> OutputIt {
   return write<Char>(out, to_string_view(value));
 }
@@ -3707,13 +3658,12 @@ FMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt {
 
 template <typename Char, typename OutputIt, typename T,
           FMT_ENABLE_IF(std::is_same<T, bool>::value)>
-FMT_CONSTEXPR auto write(OutputIt out, T value,
-                         const format_specs<Char>& specs = {}, locale_ref = {})
-    -> OutputIt {
+FMT_CONSTEXPR auto write(OutputIt out, T value, const format_specs& specs = {},
+                         locale_ref = {}) -> OutputIt {
   return specs.type != presentation_type::none &&
                  specs.type != presentation_type::string
-             ? write(out, value ? 1 : 0, specs, {})
-             : write_bytes(out, value ? "true" : "false", specs);
+             ? write<Char>(out, value ? 1 : 0, specs, {})
+             : write_bytes<Char>(out, value ? "true" : "false", specs);
 }
 
 template <typename Char, typename OutputIt>
@@ -3724,16 +3674,15 @@ FMT_CONSTEXPR auto write(OutputIt out, Char value) -> OutputIt {
 }
 
 template <typename Char, typename OutputIt>
-FMT_CONSTEXPR_CHAR_TRAITS auto write(OutputIt out, const Char* value)
-    -> OutputIt {
+FMT_CONSTEXPR20 auto write(OutputIt out, const Char* value) -> OutputIt {
   if (value) return write(out, basic_string_view<Char>(value));
-  throw_format_error("string pointer is null");
+  report_error("string pointer is null");
   return out;
 }
 
 template <typename Char, typename OutputIt, typename T,
           FMT_ENABLE_IF(std::is_same<T, void>::value)>
-auto write(OutputIt out, const T* value, const format_specs<Char>& specs = {},
+auto write(OutputIt out, const T* value, const format_specs& specs = {},
            locale_ref = {}) -> OutputIt {
   return write_ptr<Char>(out, bit_cast<uintptr_t>(value), &specs);
 }
@@ -3742,7 +3691,7 @@ auto write(OutputIt out, const T* value, const format_specs<Char>& specs = {},
 template <typename Char, typename OutputIt, typename T,
           typename Context = basic_format_context<OutputIt, Char>>
 FMT_CONSTEXPR auto write(OutputIt out, const T& value) -> enable_if_t<
-    std::is_class<T>::value && !is_string<T>::value &&
+    std::is_class<T>::value && !has_to_string_view<T>::value &&
         !is_floating_point<T>::value && !std::is_same<T, Char>::value &&
         !std::is_same<T, remove_cvref_t<decltype(arg_mapper<Context>().map(
                              value))>>::value,
@@ -3753,7 +3702,9 @@ FMT_CONSTEXPR auto write(OutputIt out, const T& value) -> enable_if_t<
 template <typename Char, typename OutputIt, typename T,
           typename Context = basic_format_context<OutputIt, Char>>
 FMT_CONSTEXPR auto write(OutputIt out, const T& value)
-    -> enable_if_t<mapped_type_constant<T, Context>::value == type::custom_type,
+    -> enable_if_t<mapped_type_constant<T, Context>::value ==
+                           type::custom_type &&
+                       !std::is_fundamental<T>::value,
                    OutputIt> {
   auto formatter = typename Context::template formatter_type<T>();
   auto parse_ctx = typename Context::parse_context_type({});
@@ -3765,8 +3716,8 @@ FMT_CONSTEXPR auto write(OutputIt out, const T& value)
 // An argument visitor that formats the argument and writes it via the output
 // iterator. It's a class and not a generic lambda for compatibility with C++11.
 template <typename Char> struct default_arg_formatter {
-  using iterator = buffer_appender<Char>;
-  using context = buffer_context<Char>;
+  using iterator = basic_appender<Char>;
+  using context = buffered_context<Char>;
 
   iterator out;
   basic_format_args<context> args;
@@ -3784,16 +3735,16 @@ template <typename Char> struct default_arg_formatter {
 };
 
 template <typename Char> struct arg_formatter {
-  using iterator = buffer_appender<Char>;
-  using context = buffer_context<Char>;
+  using iterator = basic_appender<Char>;
+  using context = buffered_context<Char>;
 
   iterator out;
-  const format_specs<Char>& specs;
+  const format_specs& specs;
   locale_ref locale;
 
   template <typename T>
   FMT_CONSTEXPR FMT_INLINE auto operator()(T value) -> iterator {
-    return detail::write(out, value, specs, locale);
+    return detail::write<Char>(out, value, specs, locale);
   }
   auto operator()(typename basic_format_arg<context>::handle) -> iterator {
     // User-defined types are handled separately because they require access
@@ -3805,13 +3756,13 @@ template <typename Char> struct arg_formatter {
 struct width_checker {
   template <typename T, FMT_ENABLE_IF(is_integer<T>::value)>
   FMT_CONSTEXPR auto operator()(T value) -> unsigned long long {
-    if (is_negative(value)) throw_format_error("negative width");
+    if (is_negative(value)) report_error("negative width");
     return static_cast<unsigned long long>(value);
   }
 
   template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
   FMT_CONSTEXPR auto operator()(T) -> unsigned long long {
-    throw_format_error("width is not integer");
+    report_error("width is not integer");
     return 0;
   }
 };
@@ -3819,29 +3770,28 @@ struct width_checker {
 struct precision_checker {
   template <typename T, FMT_ENABLE_IF(is_integer<T>::value)>
   FMT_CONSTEXPR auto operator()(T value) -> unsigned long long {
-    if (is_negative(value)) throw_format_error("negative precision");
+    if (is_negative(value)) report_error("negative precision");
     return static_cast<unsigned long long>(value);
   }
 
   template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
   FMT_CONSTEXPR auto operator()(T) -> unsigned long long {
-    throw_format_error("precision is not integer");
+    report_error("precision is not integer");
     return 0;
   }
 };
 
 template <typename Handler, typename FormatArg>
 FMT_CONSTEXPR auto get_dynamic_spec(FormatArg arg) -> int {
-  unsigned long long value = visit_format_arg(Handler(), arg);
-  if (value > to_unsigned(max_value<int>()))
-    throw_format_error("number is too big");
+  unsigned long long value = arg.visit(Handler());
+  if (value > to_unsigned(max_value<int>())) report_error("number is too big");
   return static_cast<int>(value);
 }
 
 template <typename Context, typename ID>
 FMT_CONSTEXPR auto get_arg(Context& ctx, ID id) -> decltype(ctx.arg(id)) {
   auto arg = ctx.arg(id);
-  if (!arg) ctx.on_error("argument not found");
+  if (!arg) report_error("argument not found");
   return arg;
 }
 
@@ -3901,7 +3851,7 @@ template <typename Char> struct udl_arg {
 
 template <typename Locale, typename Char>
 auto vformat(const Locale& loc, basic_string_view<Char> fmt,
-             basic_format_args<buffer_context<type_identity_t<Char>>> args)
+             typename detail::vformat_args<Char>::type args)
     -> std::basic_string<Char> {
   auto buf = basic_memory_buffer<Char>();
   detail::vformat_to(buf, fmt, args, detail::locale_ref(loc));
@@ -3913,29 +3863,29 @@ using format_func = void (*)(detail::buffer<char>&, int, const char*);
 FMT_API void format_error_code(buffer<char>& out, int error_code,
                                string_view message) noexcept;
 
+using fmt::report_error;
 FMT_API void report_error(format_func func, int error_code,
                           const char* message) noexcept;
 }  // namespace detail
 
+FMT_BEGIN_EXPORT
 FMT_API auto vsystem_error(int error_code, string_view format_str,
                            format_args args) -> std::system_error;
 
 /**
-  \rst
-  Constructs :class:`std::system_error` with a message formatted with
-  ``fmt::format(fmt, args...)``.
-  *error_code* is a system error code as given by ``errno``.
-
-  **Example**::
-
-    // This throws std::system_error with the description
-    //   cannot open file 'madeup': No such file or directory
-    // or similar (system message may vary).
-    const char* filename = "madeup";
-    std::FILE* file = std::fopen(filename, "r");
-    if (!file)
-      throw fmt::system_error(errno, "cannot open file '{}'", filename);
-  \endrst
+ * Constructs `std::system_error` with a message formatted with
+ * `fmt::format(fmt, args...)`.
+ * `error_code` is a system error code as given by `errno`.
+ *
+ * **Example**:
+ *
+ *     // This throws std::system_error with the description
+ *     //   cannot open file 'madeup': No such file or directory
+ *     // or similar (system message may vary).
+ *     const char* filename = "madeup";
+ *     std::FILE* file = std::fopen(filename, "r");
+ *     if (!file)
+ *       throw fmt::system_error(errno, "cannot open file '{}'", filename);
  */
 template <typename... T>
 auto system_error(int error_code, format_string<T...> fmt, T&&... args)
@@ -3944,20 +3894,17 @@ auto system_error(int error_code, format_string<T...> fmt, T&&... args)
 }
 
 /**
-  \rst
-  Formats an error message for an error returned by an operating system or a
-  language runtime, for example a file opening error, and writes it to *out*.
-  The format is the same as the one used by ``std::system_error(ec, message)``
-  where ``ec`` is ``std::error_code(error_code, std::generic_category()})``.
-  It is implementation-defined but normally looks like:
-
-  .. parsed-literal::
-     *<message>*: *<system-message>*
-
-  where *<message>* is the passed message and *<system-message>* is the system
-  message corresponding to the error code.
-  *error_code* is a system error code as given by ``errno``.
-  \endrst
+ * Formats an error message for an error returned by an operating system or a
+ * language runtime, for example a file opening error, and writes it to `out`.
+ * The format is the same as the one used by `std::system_error(ec, message)`
+ * where `ec` is `std::error_code(error_code, std::generic_category())`.
+ * It is implementation-defined but normally looks like:
+ *
+ *     <message>: <system-message>
+ *
+ * where `<message>` is the passed message and `<system-message>` is the system
+ * message corresponding to the error code.
+ * `error_code` is a system error code as given by `errno`.
  */
 FMT_API void format_system_error(detail::buffer<char>& out, int error_code,
                                  const char* message) noexcept;
@@ -3966,7 +3913,7 @@ FMT_API void format_system_error(detail::buffer<char>& out, int error_code,
 // Can be used to report errors from destructors.
 FMT_API void report_system_error(int error_code, const char* message) noexcept;
 
-/** Fast integer formatter. */
+/// A fast integer formatter.
 class format_int {
  private:
   // Buffer should be large enough to hold all digits (digits10 + 1),
@@ -3975,12 +3922,14 @@ class format_int {
   mutable char buffer_[buffer_size];
   char* str_;
 
-  template <typename UInt> auto format_unsigned(UInt value) -> char* {
+  template <typename UInt>
+  FMT_CONSTEXPR20 auto format_unsigned(UInt value) -> char* {
     auto n = static_cast<detail::uint32_or_64_or_128_t<UInt>>(value);
     return detail::format_decimal(buffer_, n, buffer_size - 1).begin;
   }
 
-  template <typename Int> auto format_signed(Int value) -> char* {
+  template <typename Int>
+  FMT_CONSTEXPR20 auto format_signed(Int value) -> char* {
     auto abs_value = static_cast<detail::uint32_or_64_or_128_t<Int>>(value);
     bool negative = value < 0;
     if (negative) abs_value = 0 - abs_value;
@@ -3990,39 +3939,35 @@ class format_int {
   }
 
  public:
-  explicit format_int(int value) : str_(format_signed(value)) {}
-  explicit format_int(long value) : str_(format_signed(value)) {}
-  explicit format_int(long long value) : str_(format_signed(value)) {}
-  explicit format_int(unsigned value) : str_(format_unsigned(value)) {}
-  explicit format_int(unsigned long value) : str_(format_unsigned(value)) {}
-  explicit format_int(unsigned long long value)
+  explicit FMT_CONSTEXPR20 format_int(int value) : str_(format_signed(value)) {}
+  explicit FMT_CONSTEXPR20 format_int(long value)
+      : str_(format_signed(value)) {}
+  explicit FMT_CONSTEXPR20 format_int(long long value)
+      : str_(format_signed(value)) {}
+  explicit FMT_CONSTEXPR20 format_int(unsigned value)
+      : str_(format_unsigned(value)) {}
+  explicit FMT_CONSTEXPR20 format_int(unsigned long value)
+      : str_(format_unsigned(value)) {}
+  explicit FMT_CONSTEXPR20 format_int(unsigned long long value)
       : str_(format_unsigned(value)) {}
 
-  /** Returns the number of characters written to the output buffer. */
-  auto size() const -> size_t {
+  /// Returns the number of characters written to the output buffer.
+  FMT_CONSTEXPR20 auto size() const -> size_t {
     return detail::to_unsigned(buffer_ - str_ + buffer_size - 1);
   }
 
-  /**
-    Returns a pointer to the output buffer content. No terminating null
-    character is appended.
-   */
-  auto data() const -> const char* { return str_; }
+  /// Returns a pointer to the output buffer content. No terminating null
+  /// character is appended.
+  FMT_CONSTEXPR20 auto data() const -> const char* { return str_; }
 
-  /**
-    Returns a pointer to the output buffer content with terminating null
-    character appended.
-   */
-  auto c_str() const -> const char* {
+  /// Returns a pointer to the output buffer content with terminating null
+  /// character appended.
+  FMT_CONSTEXPR20 auto c_str() const -> const char* {
     buffer_[buffer_size - 1] = '\0';
     return str_;
   }
 
-  /**
-    \rst
-    Returns the content of the output buffer as an ``std::string``.
-    \endrst
-   */
+  /// Returns the content of the output buffer as an `std::string`.
   auto str() const -> std::string { return std::string(str_, size()); }
 };
 
@@ -4031,14 +3976,19 @@ struct formatter<T, Char, enable_if_t<detail::has_format_as<T>::value>>
     : formatter<detail::format_as_t<T>, Char> {
   template <typename FormatContext>
   auto format(const T& value, FormatContext& ctx) const -> decltype(ctx.out()) {
-    using base = formatter<detail::format_as_t<T>, Char>;
-    return base::format(format_as(value), ctx);
+    auto&& val = format_as(value);  // Make an lvalue reference for format.
+    return formatter<detail::format_as_t<T>, Char>::format(val, ctx);
   }
 };
 
-#define FMT_FORMAT_AS(Type, Base) \
-  template <typename Char>        \
-  struct formatter<Type, Char> : formatter<Base, Char> {}
+#define FMT_FORMAT_AS(Type, Base)                                              \
+  template <typename Char>                                                     \
+  struct formatter<Type, Char> : formatter<Base, Char> {                       \
+    template <typename FormatContext>                                          \
+    auto format(Type value, FormatContext& ctx) const -> decltype(ctx.out()) { \
+      return formatter<Base, Char>::format(value, ctx);                        \
+    }                                                                          \
+  }
 
 FMT_FORMAT_AS(signed char, int);
 FMT_FORMAT_AS(unsigned char, unsigned);
@@ -4047,44 +3997,36 @@ FMT_FORMAT_AS(unsigned short, unsigned);
 FMT_FORMAT_AS(long, detail::long_type);
 FMT_FORMAT_AS(unsigned long, detail::ulong_type);
 FMT_FORMAT_AS(Char*, const Char*);
-FMT_FORMAT_AS(std::basic_string<Char>, basic_string_view<Char>);
 FMT_FORMAT_AS(std::nullptr_t, const void*);
 FMT_FORMAT_AS(detail::std_string_view<Char>, basic_string_view<Char>);
 FMT_FORMAT_AS(void*, const void*);
 
+template <typename Char, typename Traits, typename Allocator>
+class formatter<std::basic_string<Char, Traits, Allocator>, Char>
+    : public formatter<basic_string_view<Char>, Char> {};
+
 template <typename Char, size_t N>
 struct formatter<Char[N], Char> : formatter<basic_string_view<Char>, Char> {};
 
 /**
-  \rst
-  Converts ``p`` to ``const void*`` for pointer formatting.
-
-  **Example**::
-
-    auto s = fmt::format("{}", fmt::ptr(p));
-  \endrst
+ * Converts `p` to `const void*` for pointer formatting.
+ *
+ * **Example**:
+ *
+ *     auto s = fmt::format("{}", fmt::ptr(p));
  */
 template <typename T> auto ptr(T p) -> const void* {
   static_assert(std::is_pointer<T>::value, "");
   return detail::bit_cast<const void*>(p);
 }
-template <typename T, typename Deleter>
-auto ptr(const std::unique_ptr<T, Deleter>& p) -> const void* {
-  return p.get();
-}
-template <typename T> auto ptr(const std::shared_ptr<T>& p) -> const void* {
-  return p.get();
-}
 
 /**
-  \rst
-  Converts ``e`` to the underlying type.
-
-  **Example**::
-
-    enum class color { red, green, blue };
-    auto s = fmt::format("{}", fmt::underlying(color::red));
-  \endrst
+ * Converts `e` to the underlying type.
+ *
+ * **Example**:
+ *
+ *     enum class color { red, green, blue };
+ *     auto s = fmt::format("{}", fmt::underlying(color::red));
  */
 template <typename Enum>
 constexpr auto underlying(Enum e) noexcept -> underlying_t<Enum> {
@@ -4119,12 +4061,13 @@ template <> struct formatter<bytes> {
   }
 
   template <typename FormatContext>
-  auto format(bytes b, FormatContext& ctx) -> decltype(ctx.out()) {
-    detail::handle_dynamic_spec<detail::width_checker>(specs_.width,
-                                                       specs_.width_ref, ctx);
+  auto format(bytes b, FormatContext& ctx) const -> decltype(ctx.out()) {
+    auto specs = specs_;
+    detail::handle_dynamic_spec<detail::width_checker>(specs.width,
+                                                       specs.width_ref, ctx);
     detail::handle_dynamic_spec<detail::precision_checker>(
-        specs_.precision, specs_.precision_ref, ctx);
-    return detail::write_bytes(ctx.out(), b.data_, specs_);
+        specs.precision, specs.precision_ref, ctx);
+    return detail::write_bytes<char>(ctx.out(), b.data_, specs);
   }
 };
 
@@ -4134,15 +4077,13 @@ template <typename T> struct group_digits_view {
 };
 
 /**
-  \rst
-  Returns a view that formats an integer value using ',' as a locale-independent
-  thousands separator.
-
-  **Example**::
-
-    fmt::print("{}", fmt::group_digits(12345));
-    // Output: "12,345"
-  \endrst
+ * Returns a view that formats an integer value using ',' as a
+ * locale-independent thousands separator.
+ *
+ * **Example**:
+ *
+ *     fmt::print("{}", fmt::group_digits(12345));
+ *     // Output: "12,345"
  */
 template <typename T> auto group_digits(T value) -> group_digits_view<T> {
   return {value};
@@ -4160,45 +4101,51 @@ template <typename T> struct formatter<group_digits_view<T>> : formatter<T> {
   }
 
   template <typename FormatContext>
-  auto format(group_digits_view<T> t, FormatContext& ctx)
+  auto format(group_digits_view<T> t, FormatContext& ctx) const
       -> decltype(ctx.out()) {
-    detail::handle_dynamic_spec<detail::width_checker>(specs_.width,
-                                                       specs_.width_ref, ctx);
+    auto specs = specs_;
+    detail::handle_dynamic_spec<detail::width_checker>(specs.width,
+                                                       specs.width_ref, ctx);
     detail::handle_dynamic_spec<detail::precision_checker>(
-        specs_.precision, specs_.precision_ref, ctx);
+        specs.precision, specs.precision_ref, ctx);
+    auto arg = detail::make_write_int_arg(t.value, specs.sign);
     return detail::write_int(
-        ctx.out(), static_cast<detail::uint64_or_128_t<T>>(t.value), 0, specs_,
-        detail::digit_grouping<char>("\3", ","));
+        ctx.out(), static_cast<detail::uint64_or_128_t<T>>(arg.abs_value),
+        arg.prefix, specs, detail::digit_grouping<char>("\3", ","));
   }
 };
 
-template <typename T> struct nested_view {
-  const formatter<T>* fmt;
+template <typename T, typename Char> struct nested_view {
+  const formatter<T, Char>* fmt;
   const T* value;
 };
 
-template <typename T> struct formatter<nested_view<T>> {
-  FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> const char* {
+template <typename T, typename Char>
+struct formatter<nested_view<T, Char>, Char> {
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
     return ctx.begin();
   }
-  auto format(nested_view<T> view, format_context& ctx) const
+  template <typename FormatContext>
+  auto format(nested_view<T, Char> view, FormatContext& ctx) const
       -> decltype(ctx.out()) {
     return view.fmt->format(*view.value, ctx);
   }
 };
 
-template <typename T> struct nested_formatter {
+template <typename T, typename Char = char> struct nested_formatter {
  private:
   int width_;
-  detail::fill_t<char> fill_;
+  detail::fill_t fill_;
   align_t align_ : 4;
-  formatter<T> formatter_;
+  formatter<T, Char> formatter_;
 
  public:
   constexpr nested_formatter() : width_(0), align_(align_t::none) {}
 
-  FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> const char* {
-    auto specs = detail::dynamic_format_specs<char>();
+  FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
+      -> decltype(ctx.begin()) {
+    auto specs = detail::dynamic_format_specs<Char>();
     auto it = parse_format_specs(ctx.begin(), ctx.end(), specs, ctx,
                                  detail::type::none_type);
     width_ = specs.width;
@@ -4208,111 +4155,30 @@ template <typename T> struct nested_formatter {
     return formatter_.parse(ctx);
   }
 
-  template <typename F>
-  auto write_padded(format_context& ctx, F write) const -> decltype(ctx.out()) {
+  template <typename FormatContext, typename F>
+  auto write_padded(FormatContext& ctx, F write) const -> decltype(ctx.out()) {
     if (width_ == 0) return write(ctx.out());
-    auto buf = memory_buffer();
-    write(std::back_inserter(buf));
-    auto specs = format_specs<>();
+    auto buf = basic_memory_buffer<Char>();
+    write(basic_appender<Char>(buf));
+    auto specs = format_specs();
     specs.width = width_;
     specs.fill = fill_;
     specs.align = align_;
-    return detail::write(ctx.out(), string_view(buf.data(), buf.size()), specs);
+    return detail::write<Char>(
+        ctx.out(), basic_string_view<Char>(buf.data(), buf.size()), specs);
   }
 
-  auto nested(const T& value) const -> nested_view<T> {
-    return nested_view<T>{&formatter_, &value};
-  }
-};
-
-// DEPRECATED! join_view will be moved to ranges.h.
-template <typename It, typename Sentinel, typename Char = char>
-struct join_view : detail::view {
-  It begin;
-  Sentinel end;
-  basic_string_view<Char> sep;
-
-  join_view(It b, Sentinel e, basic_string_view<Char> s)
-      : begin(b), end(e), sep(s) {}
-};
-
-template <typename It, typename Sentinel, typename Char>
-struct formatter<join_view<It, Sentinel, Char>, Char> {
- private:
-  using value_type =
-#ifdef __cpp_lib_ranges
-      std::iter_value_t<It>;
-#else
-      typename std::iterator_traits<It>::value_type;
-#endif
-  formatter<remove_cvref_t<value_type>, Char> value_formatter_;
-
- public:
-  template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> const Char* {
-    return value_formatter_.parse(ctx);
-  }
-
-  template <typename FormatContext>
-  auto format(const join_view<It, Sentinel, Char>& value,
-              FormatContext& ctx) const -> decltype(ctx.out()) {
-    auto it = value.begin;
-    auto out = ctx.out();
-    if (it != value.end) {
-      out = value_formatter_.format(*it, ctx);
-      ++it;
-      while (it != value.end) {
-        out = detail::copy_str<Char>(value.sep.begin(), value.sep.end(), out);
-        ctx.advance_to(out);
-        out = value_formatter_.format(*it, ctx);
-        ++it;
-      }
-    }
-    return out;
+  auto nested(const T& value) const -> nested_view<T, Char> {
+    return nested_view<T, Char>{&formatter_, &value};
   }
 };
 
 /**
-  Returns a view that formats the iterator range `[begin, end)` with elements
-  separated by `sep`.
- */
-template <typename It, typename Sentinel>
-auto join(It begin, Sentinel end, string_view sep) -> join_view<It, Sentinel> {
-  return {begin, end, sep};
-}
-
-/**
-  \rst
-  Returns a view that formats `range` with elements separated by `sep`.
-
-  **Example**::
-
-    std::vector<int> v = {1, 2, 3};
-    fmt::print("{}", fmt::join(v, ", "));
-    // Output: "1, 2, 3"
-
-  ``fmt::join`` applies passed format specifiers to the range elements::
-
-    fmt::print("{:02}", fmt::join(v, ", "));
-    // Output: "01, 02, 03"
-  \endrst
- */
-template <typename Range>
-auto join(Range&& range, string_view sep)
-    -> join_view<detail::iterator_t<Range>, detail::sentinel_t<Range>> {
-  return join(std::begin(range), std::end(range), sep);
-}
-
-/**
-  \rst
-  Converts *value* to ``std::string`` using the default format for type *T*.
-
-  **Example**::
-
-    #include <fmt/format.h>
-
-    std::string answer = fmt::to_string(42);
-  \endrst
+ * Converts `value` to `std::string` using the default format for type `T`.
+ *
+ * **Example**:
+ *
+ *     std::string answer = fmt::to_string(42);
  */
 template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value &&
                                     !detail::has_format_as<T>::value)>
@@ -4353,20 +4219,20 @@ namespace detail {
 template <typename Char>
 void vformat_to(buffer<Char>& buf, basic_string_view<Char> fmt,
                 typename vformat_args<Char>::type args, locale_ref loc) {
-  auto out = buffer_appender<Char>(buf);
+  auto out = basic_appender<Char>(buf);
   if (fmt.size() == 2 && equal2(fmt.data(), "{}")) {
     auto arg = args.get(0);
-    if (!arg) throw_format_error("argument not found");
-    visit_format_arg(default_arg_formatter<Char>{out, args, loc}, arg);
+    if (!arg) report_error("argument not found");
+    arg.visit(default_arg_formatter<Char>{out, args, loc});
     return;
   }
 
-  struct format_handler : error_handler {
+  struct format_handler {
     basic_format_parse_context<Char> parse_context;
-    buffer_context<Char> context;
+    buffered_context<Char> context;
 
-    format_handler(buffer_appender<Char> p_out, basic_string_view<Char> str,
-                   basic_format_args<buffer_context<Char>> p_args,
+    format_handler(basic_appender<Char> p_out, basic_string_view<Char> str,
+                   basic_format_args<buffered_context<Char>> p_args,
                    locale_ref p_loc)
         : parse_context(str), context(p_out, p_args, p_loc) {}
 
@@ -4379,20 +4245,20 @@ void vformat_to(buffer<Char>& buf, basic_string_view<Char> fmt,
       return parse_context.next_arg_id();
     }
     FMT_CONSTEXPR auto on_arg_id(int id) -> int {
-      return parse_context.check_arg_id(id), id;
+      parse_context.check_arg_id(id);
+      return id;
     }
     FMT_CONSTEXPR auto on_arg_id(basic_string_view<Char> id) -> int {
+      parse_context.check_arg_id(id);
       int arg_id = context.arg_id(id);
-      if (arg_id < 0) throw_format_error("argument not found");
+      if (arg_id < 0) report_error("argument not found");
       return arg_id;
     }
 
     FMT_INLINE void on_replacement_field(int id, const Char*) {
       auto arg = get_arg(context, id);
-      context.advance_to(visit_format_arg(
-          default_arg_formatter<Char>{context.out(), context.args(),
-                                      context.locale()},
-          arg));
+      context.advance_to(arg.visit(default_arg_formatter<Char>{
+          context.out(), context.args(), context.locale()}));
     }
 
     auto on_format_specs(int id, const Char* begin, const Char* end)
@@ -4408,11 +4274,13 @@ void vformat_to(buffer<Char>& buf, basic_string_view<Char> fmt,
       detail::handle_dynamic_spec<detail::precision_checker>(
           specs.precision, specs.precision_ref, context);
       if (begin == end || *begin != '}')
-        throw_format_error("missing '}' in format string");
-      auto f = arg_formatter<Char>{context.out(), specs, context.locale()};
-      context.advance_to(visit_format_arg(f, arg));
+        report_error("missing '}' in format string");
+      context.advance_to(arg.visit(
+          arg_formatter<Char>{context.out(), specs, context.locale()}));
       return begin;
     }
+
+    FMT_NORETURN void on_error(const char* message) { report_error(message); }
   };
   detail::parse_format_string<false>(fmt, format_handler(out, fmt, args, loc));
 }
@@ -4431,19 +4299,41 @@ extern template FMT_API auto decimal_point_impl(locale_ref) -> char;
 extern template FMT_API auto decimal_point_impl(locale_ref) -> wchar_t;
 #endif  // FMT_HEADER_ONLY
 
+FMT_END_EXPORT
+
+template <typename T, typename Char, type TYPE>
+template <typename FormatContext>
+FMT_CONSTEXPR FMT_INLINE auto native_formatter<T, Char, TYPE>::format(
+    const T& val, FormatContext& ctx) const -> decltype(ctx.out()) {
+  if (specs_.width_ref.kind == arg_id_kind::none &&
+      specs_.precision_ref.kind == arg_id_kind::none) {
+    return write<Char>(ctx.out(), val, specs_, ctx.locale());
+  }
+  auto specs = specs_;
+  handle_dynamic_spec<width_checker>(specs.width, specs.width_ref, ctx);
+  handle_dynamic_spec<precision_checker>(specs.precision, specs.precision_ref,
+                                         ctx);
+  return write<Char>(ctx.out(), val, specs, ctx.locale());
+}
+
 }  // namespace detail
 
+FMT_BEGIN_EXPORT
+
+template <typename Char>
+struct formatter<detail::float128, Char>
+    : detail::native_formatter<detail::float128, Char,
+                               detail::type::float_type> {};
+
 #if FMT_USE_USER_DEFINED_LITERALS
 inline namespace literals {
 /**
-  \rst
-  User-defined literal equivalent of :func:`fmt::arg`.
-
-  **Example**::
-
-    using namespace fmt::literals;
-    fmt::print("Elapsed time: {s:.2f} seconds", "s"_a=1.23);
-  \endrst
+ * User-defined literal equivalent of `fmt::arg`.
+ *
+ * **Example**:
+ *
+ *     using namespace fmt::literals;
+ *     fmt::print("The answer is {answer}.", "answer"_a=42);
  */
 #  if FMT_USE_NONTYPE_TEMPLATE_ARGS
 template <detail_exported::fixed_string Str> constexpr auto operator""_a() {
@@ -4458,6 +4348,23 @@ constexpr auto operator""_a(const char* s, size_t) -> detail::udl_arg<char> {
 }  // namespace literals
 #endif  // FMT_USE_USER_DEFINED_LITERALS
 
+FMT_API auto vformat(string_view fmt, format_args args) -> std::string;
+
+/**
+ * Formats `args` according to specifications in `fmt` and returns the result
+ * as a string.
+ *
+ * **Example**:
+ *
+ *     #include <fmt/format.h>
+ *     std::string message = fmt::format("The answer is {}.", 42);
+ */
+template <typename... T>
+FMT_NODISCARD FMT_INLINE auto format(format_string<T...> fmt, T&&... args)
+    -> std::string {
+  return vformat(fmt, fmt::make_format_args(args...));
+}
+
 template <typename Locale, FMT_ENABLE_IF(detail::is_locale<Locale>::value)>
 inline auto vformat(const Locale& loc, string_view fmt, format_args args)
     -> std::string {
@@ -4503,26 +4410,6 @@ FMT_NODISCARD FMT_INLINE auto formatted_size(const Locale& loc,
 
 FMT_END_EXPORT
 
-template <typename T, typename Char>
-template <typename FormatContext>
-FMT_CONSTEXPR FMT_INLINE auto
-formatter<T, Char,
-          enable_if_t<detail::type_constant<T, Char>::value !=
-                      detail::type::custom_type>>::format(const T& val,
-                                                          FormatContext& ctx)
-    const -> decltype(ctx.out()) {
-  if (specs_.width_ref.kind == detail::arg_id_kind::none &&
-      specs_.precision_ref.kind == detail::arg_id_kind::none) {
-    return detail::write<Char>(ctx.out(), val, specs_, ctx.locale());
-  }
-  auto specs = specs_;
-  detail::handle_dynamic_spec<detail::width_checker>(specs.width,
-                                                     specs.width_ref, ctx);
-  detail::handle_dynamic_spec<detail::precision_checker>(
-      specs.precision, specs.precision_ref, ctx);
-  return detail::write<Char>(ctx.out(), val, specs, ctx.locale());
-}
-
 FMT_END_NAMESPACE
 
 #ifdef FMT_HEADER_ONLY
@@ -4532,4 +4419,9 @@ FMT_END_NAMESPACE
 #  define FMT_FUNC
 #endif
 
+// Restore _LIBCPP_REMOVE_TRANSITIVE_INCLUDES.
+#ifdef FMT_REMOVE_TRANSITIVE_INCLUDES
+#  undef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#endif
+
 #endif  // FMT_FORMAT_H_
diff --git a/thirdparty/fmt/os.h b/thirdparty/fmt/os.h
index 3c7b3ccb4..5c85ea08f 100644
--- a/thirdparty/fmt/os.h
+++ b/thirdparty/fmt/os.h
@@ -8,18 +8,18 @@
 #ifndef FMT_OS_H_
 #define FMT_OS_H_
 
-#include <cerrno>
-#include <cstddef>
-#include <cstdio>
-#include <system_error>  // std::system_error
-
 #include "format.h"
 
-#if defined __APPLE__ || defined(__FreeBSD__)
+#ifndef FMT_MODULE
+#  include <cerrno>
+#  include <cstddef>
+#  include <cstdio>
+#  include <system_error>  // std::system_error
+
 #  if FMT_HAS_INCLUDE(<xlocale.h>)
-#    include <xlocale.h>  // for LC_NUMERIC_MASK on OS X
+#    include <xlocale.h>  // LC_NUMERIC_MASK on macOS
 #  endif
-#endif
+#endif  // FMT_MODULE
 
 #ifndef FMT_USE_FCNTL
 // UWP doesn't provide _pipe.
@@ -77,46 +77,33 @@ FMT_BEGIN_NAMESPACE
 FMT_BEGIN_EXPORT
 
 /**
-  \rst
-  A reference to a null-terminated string. It can be constructed from a C
-  string or ``std::string``.
-
-  You can use one of the following type aliases for common character types:
-
-  +---------------+-----------------------------+
-  | Type          | Definition                  |
-  +===============+=============================+
-  | cstring_view  | basic_cstring_view<char>    |
-  +---------------+-----------------------------+
-  | wcstring_view | basic_cstring_view<wchar_t> |
-  +---------------+-----------------------------+
-
-  This class is most useful as a parameter type to allow passing
-  different types of strings to a function, for example::
-
-    template <typename... Args>
-    std::string format(cstring_view format_str, const Args & ... args);
-
-    format("{}", 42);
-    format(std::string("{}"), 42);
-  \endrst
+ * A reference to a null-terminated string. It can be constructed from a C
+ * string or `std::string`.
+ *
+ * You can use one of the following type aliases for common character types:
+ *
+ * +---------------+-----------------------------+
+ * | Type          | Definition                  |
+ * +===============+=============================+
+ * | cstring_view  | basic_cstring_view<char>    |
+ * +---------------+-----------------------------+
+ * | wcstring_view | basic_cstring_view<wchar_t> |
+ * +---------------+-----------------------------+
+ *
+ * This class is most useful as a parameter type for functions that wrap C APIs.
  */
 template <typename Char> class basic_cstring_view {
  private:
   const Char* data_;
 
  public:
-  /** Constructs a string reference object from a C string. */
+  /// Constructs a string reference object from a C string.
   basic_cstring_view(const Char* s) : data_(s) {}
 
-  /**
-    \rst
-    Constructs a string reference from an ``std::string`` object.
-    \endrst
-   */
+  /// Constructs a string reference from an `std::string` object.
   basic_cstring_view(const std::basic_string<Char>& s) : data_(s.c_str()) {}
 
-  /** Returns the pointer to a C string. */
+  /// Returns the pointer to a C string.
   auto c_str() const -> const Char* { return data_; }
 };
 
@@ -135,33 +122,30 @@ FMT_API std::system_error vwindows_error(int error_code, string_view format_str,
                                          format_args args);
 
 /**
- \rst
- Constructs a :class:`std::system_error` object with the description
- of the form
-
- .. parsed-literal::
-   *<message>*: *<system-message>*
-
- where *<message>* is the formatted message and *<system-message>* is the
- system message corresponding to the error code.
- *error_code* is a Windows error code as given by ``GetLastError``.
- If *error_code* is not a valid error code such as -1, the system message
- will look like "error -1".
-
- **Example**::
-
-   // This throws a system_error with the description
-   //   cannot open file 'madeup': The system cannot find the file specified.
-   // or similar (system message may vary).
-   const char *filename = "madeup";
-   LPOFSTRUCT of = LPOFSTRUCT();
-   HFILE file = OpenFile(filename, &of, OF_READ);
-   if (file == HFILE_ERROR) {
-     throw fmt::windows_error(GetLastError(),
-                              "cannot open file '{}'", filename);
-   }
- \endrst
-*/
+ * Constructs a `std::system_error` object with the description of the form
+ *
+ *     <message>: <system-message>
+ *
+ * where `<message>` is the formatted message and `<system-message>` is the
+ * system message corresponding to the error code.
+ * `error_code` is a Windows error code as given by `GetLastError`.
+ * If `error_code` is not a valid error code such as -1, the system message
+ * will look like "error -1".
+ *
+ * **Example**:
+ *
+ *     // This throws a system_error with the description
+ *     //   cannot open file 'madeup': The system cannot find the file
+ * specified.
+ *     // or similar (system message may vary).
+ *     const char *filename = "madeup";
+ *     LPOFSTRUCT of = LPOFSTRUCT();
+ *     HFILE file = OpenFile(filename, &of, OF_READ);
+ *     if (file == HFILE_ERROR) {
+ *       throw fmt::windows_error(GetLastError(),
+ *                                "cannot open file '{}'", filename);
+ *     }
+ */
 template <typename... Args>
 std::system_error windows_error(int error_code, string_view message,
                                 const Args&... args) {
@@ -227,17 +211,16 @@ class buffered_file {
 
   FMT_API auto descriptor() const -> int;
 
-  void vprint(string_view format_str, format_args args) {
-    fmt::vprint(file_, format_str, args);
-  }
-
-  template <typename... Args>
-  inline void print(string_view format_str, const Args&... args) {
-    vprint(format_str, fmt::make_format_args(args...));
+  template <typename... T>
+  inline void print(string_view fmt, const T&... args) {
+    const auto& vargs = fmt::make_format_args(args...);
+    detail::is_locking<T...>() ? fmt::vprint_buffered(file_, fmt, vargs)
+                               : fmt::vprint(file_, fmt, vargs);
   }
 };
 
 #if FMT_USE_FCNTL
+
 // A file. Closed file is represented by a file object with descriptor -1.
 // Methods that are not declared with noexcept may throw
 // fmt::system_error in case of failure. Note that some errors such as
@@ -251,6 +234,8 @@ class FMT_API file {
   // Constructs a file object with a given descriptor.
   explicit file(int fd) : fd_(fd) {}
 
+  friend struct pipe;
+
  public:
   // Possible values for the oflag argument to the constructor.
   enum {
@@ -313,11 +298,6 @@ class FMT_API file {
   // necessary.
   void dup2(int fd, std::error_code& ec) noexcept;
 
-  // Creates a pipe setting up read_end and write_end file objects for reading
-  // and writing respectively.
-  // DEPRECATED! Taking files as out parameters is deprecated.
-  static void pipe(file& read_end, file& write_end);
-
   // Creates a buffered_file object associated with this file and detaches
   // this file object from the file.
   auto fdopen(const char* mode) -> buffered_file;
@@ -329,6 +309,15 @@ class FMT_API file {
 #  endif
 };
 
+struct FMT_API pipe {
+  file read_end;
+  file write_end;
+
+  // Creates a pipe setting up read_end and write_end file objects for reading
+  // and writing respectively.
+  pipe();
+};
+
 // Returns the memory page size.
 auto getpagesize() -> long;
 
@@ -370,13 +359,14 @@ struct ostream_params {
 };
 
 class file_buffer final : public buffer<char> {
+ private:
   file file_;
 
-  FMT_API void grow(size_t) override;
+  FMT_API static void grow(buffer<char>& buf, size_t);
 
  public:
   FMT_API file_buffer(cstring_view path, const ostream_params& params);
-  FMT_API file_buffer(file_buffer&& other);
+  FMT_API file_buffer(file_buffer&& other) noexcept;
   FMT_API ~file_buffer();
 
   void flush() {
@@ -393,11 +383,10 @@ class file_buffer final : public buffer<char> {
 
 }  // namespace detail
 
-// Added {} below to work around default constructor error known to
-// occur in Xcode versions 7.2.1 and 8.2.1.
-constexpr detail::buffer_size buffer_size{};
+constexpr auto buffer_size = detail::buffer_size();
 
-/** A fast output stream which is not thread-safe. */
+/// A fast output stream for writing from a single thread. Writing from
+/// multiple threads without external synchronization may result in a data race.
 class FMT_API ostream {
  private:
   FMT_MSC_WARNING(suppress : 4251)
@@ -418,30 +407,25 @@ class FMT_API ostream {
 
   void close() { buffer_.close(); }
 
-  /**
-    Formats ``args`` according to specifications in ``fmt`` and writes the
-    output to the file.
-   */
+  /// Formats `args` according to specifications in `fmt` and writes the
+  /// output to the file.
   template <typename... T> void print(format_string<T...> fmt, T&&... args) {
-    vformat_to(std::back_inserter(buffer_), fmt,
-               fmt::make_format_args(args...));
+    vformat_to(appender(buffer_), fmt, fmt::make_format_args(args...));
   }
 };
 
 /**
-  \rst
-  Opens a file for writing. Supported parameters passed in *params*:
-
-  * ``<integer>``: Flags passed to `open
-    <https://pubs.opengroup.org/onlinepubs/007904875/functions/open.html>`_
-    (``file::WRONLY | file::CREATE | file::TRUNC`` by default)
-  * ``buffer_size=<integer>``: Output buffer size
-
-  **Example**::
-
-    auto out = fmt::output_file("guide.txt");
-    out.print("Don't {}", "Panic");
-  \endrst
+ * Opens a file for writing. Supported parameters passed in `params`:
+ *
+ * - `<integer>`: Flags passed to [open](
+ *   https://pubs.opengroup.org/onlinepubs/007904875/functions/open.html)
+ *   (`file::WRONLY | file::CREATE | file::TRUNC` by default)
+ * - `buffer_size=<integer>`: Output buffer size
+ *
+ * **Example**:
+ *
+ *     auto out = fmt::output_file("guide.txt");
+ *     out.print("Don't {}", "Panic");
  */
 template <typename... T>
 inline auto output_file(cstring_view path, T... params) -> ostream {
diff --git a/thirdparty/fmt/ostream.h b/thirdparty/fmt/ostream.h
index 26fb3b5ac..98faef659 100644
--- a/thirdparty/fmt/ostream.h
+++ b/thirdparty/fmt/ostream.h
@@ -8,7 +8,9 @@
 #ifndef FMT_OSTREAM_H_
 #define FMT_OSTREAM_H_
 
-#include <fstream>  // std::filebuf
+#ifndef FMT_MODULE
+#  include <fstream>  // std::filebuf
+#endif
 
 #ifdef _WIN32
 #  ifdef __GLIBCXX__
@@ -18,42 +20,11 @@
 #  include <io.h>
 #endif
 
-#include "format.h"
+#include "chrono.h"  // formatbuf
 
 FMT_BEGIN_NAMESPACE
 namespace detail {
 
-template <typename Streambuf> class formatbuf : public Streambuf {
- private:
-  using char_type = typename Streambuf::char_type;
-  using streamsize = decltype(std::declval<Streambuf>().sputn(nullptr, 0));
-  using int_type = typename Streambuf::int_type;
-  using traits_type = typename Streambuf::traits_type;
-
-  buffer<char_type>& buffer_;
-
- public:
-  explicit formatbuf(buffer<char_type>& buf) : buffer_(buf) {}
-
- protected:
-  // The put area is always empty. This makes the implementation simpler and has
-  // the advantage that the streambuf and the buffer are always in sync and
-  // sputc never writes into uninitialized memory. A disadvantage is that each
-  // call to sputc always results in a (virtual) call to overflow. There is no
-  // disadvantage here for sputn since this always results in a call to xsputn.
-
-  auto overflow(int_type ch) -> int_type override {
-    if (!traits_type::eq_int_type(ch, traits_type::eof()))
-      buffer_.push_back(static_cast<char_type>(ch));
-    return ch;
-  }
-
-  auto xsputn(const char_type* s, streamsize count) -> streamsize override {
-    buffer_.append(s, s + count);
-    return count;
-  }
-};
-
 // Generate a unique explicit instantion in every translation unit using a tag
 // type in an anonymous namespace.
 namespace {
@@ -73,12 +44,12 @@ auto get_file(std::filebuf&) -> FILE*;
 inline auto write_ostream_unicode(std::ostream& os, fmt::string_view data)
     -> bool {
   FILE* f = nullptr;
-#if FMT_MSC_VERSION
+#if FMT_MSC_VERSION && FMT_USE_RTTI
   if (auto* buf = dynamic_cast<std::filebuf*>(os.rdbuf()))
     f = get_file(*buf);
   else
     return false;
-#elif defined(_WIN32) && defined(__GLIBCXX__)
+#elif defined(_WIN32) && defined(__GLIBCXX__) && FMT_USE_RTTI
   auto* rdbuf = os.rdbuf();
   if (auto* sfbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf<char>*>(rdbuf))
     f = sfbuf->file();
@@ -143,9 +114,8 @@ template <typename Char>
 struct basic_ostream_formatter : formatter<basic_string_view<Char>, Char> {
   void set_debug_format() = delete;
 
-  template <typename T, typename OutputIt>
-  auto format(const T& value, basic_format_context<OutputIt, Char>& ctx) const
-      -> OutputIt {
+  template <typename T, typename Context>
+  auto format(const T& value, Context& ctx) const -> decltype(ctx.out()) {
     auto buffer = basic_memory_buffer<Char>();
     detail::format_value(buffer, value);
     return formatter<basic_string_view<Char>, Char>::format(
@@ -158,22 +128,20 @@ using ostream_formatter = basic_ostream_formatter<char>;
 template <typename T, typename Char>
 struct formatter<detail::streamed_view<T>, Char>
     : basic_ostream_formatter<Char> {
-  template <typename OutputIt>
-  auto format(detail::streamed_view<T> view,
-              basic_format_context<OutputIt, Char>& ctx) const -> OutputIt {
+  template <typename Context>
+  auto format(detail::streamed_view<T> view, Context& ctx) const
+      -> decltype(ctx.out()) {
     return basic_ostream_formatter<Char>::format(view.value, ctx);
   }
 };
 
 /**
-  \rst
-  Returns a view that formats `value` via an ostream ``operator<<``.
-
-  **Example**::
-
-    fmt::print("Current thread id: {}\n",
-               fmt::streamed(std::this_thread::get_id()));
-  \endrst
+ * Returns a view that formats `value` via an ostream `operator<<`.
+ *
+ * **Example**:
+ *
+ *     fmt::print("Current thread id: {}\n",
+ *                fmt::streamed(std::this_thread::get_id()));
  */
 template <typename T>
 constexpr auto streamed(const T& value) -> detail::streamed_view<T> {
@@ -194,7 +162,7 @@ inline void vprint_directly(std::ostream& os, string_view format_str,
 FMT_EXPORT template <typename Char>
 void vprint(std::basic_ostream<Char>& os,
             basic_string_view<type_identity_t<Char>> format_str,
-            basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+            typename detail::vformat_args<Char>::type args) {
   auto buffer = basic_memory_buffer<Char>();
   detail::vformat_to(buffer, format_str, args);
   if (detail::write_ostream_unicode(os, {buffer.data(), buffer.size()})) return;
@@ -202,18 +170,16 @@ void vprint(std::basic_ostream<Char>& os,
 }
 
 /**
-  \rst
-  Prints formatted data to the stream *os*.
-
-  **Example**::
-
-    fmt::print(cerr, "Don't {}!", "panic");
-  \endrst
+ * Prints formatted data to the stream `os`.
+ *
+ * **Example**:
+ *
+ *     fmt::print(cerr, "Don't {}!", "panic");
  */
 FMT_EXPORT template <typename... T>
 void print(std::ostream& os, format_string<T...> fmt, T&&... args) {
   const auto& vargs = fmt::make_format_args(args...);
-  if (detail::is_utf8())
+  if (detail::use_utf8())
     vprint(os, fmt, vargs);
   else
     detail::vprint_directly(os, fmt, vargs);
@@ -224,7 +190,7 @@ template <typename... Args>
 void print(std::wostream& os,
            basic_format_string<wchar_t, type_identity_t<Args>...> fmt,
            Args&&... args) {
-  vprint(os, fmt, fmt::make_format_args<buffer_context<wchar_t>>(args...));
+  vprint(os, fmt, fmt::make_format_args<buffered_context<wchar_t>>(args...));
 }
 
 FMT_EXPORT template <typename... T>
diff --git a/thirdparty/fmt/printf.h b/thirdparty/fmt/printf.h
index 07e81577c..072cc6b30 100644
--- a/thirdparty/fmt/printf.h
+++ b/thirdparty/fmt/printf.h
@@ -8,8 +8,10 @@
 #ifndef FMT_PRINTF_H_
 #define FMT_PRINTF_H_
 
-#include <algorithm>  // std::max
-#include <limits>     // std::numeric_limits
+#ifndef FMT_MODULE
+#  include <algorithm>  // std::max
+#  include <limits>     // std::numeric_limits
+#endif
 
 #include "format.h"
 
@@ -22,7 +24,7 @@ template <typename T> struct printf_formatter {
 
 template <typename Char> class basic_printf_context {
  private:
-  detail::buffer_appender<Char> out_;
+  basic_appender<Char> out_;
   basic_format_args<basic_printf_context> args_;
 
   static_assert(std::is_same<Char, char>::value ||
@@ -34,28 +36,20 @@ template <typename Char> class basic_printf_context {
   using parse_context_type = basic_format_parse_context<Char>;
   template <typename T> using formatter_type = printf_formatter<T>;
 
-  /**
-    \rst
-    Constructs a ``printf_context`` object. References to the arguments are
-    stored in the context object so make sure they have appropriate lifetimes.
-    \endrst
-   */
-  basic_printf_context(detail::buffer_appender<Char> out,
+  /// Constructs a `printf_context` object. References to the arguments are
+  /// stored in the context object so make sure they have appropriate lifetimes.
+  basic_printf_context(basic_appender<Char> out,
                        basic_format_args<basic_printf_context> args)
       : out_(out), args_(args) {}
 
-  auto out() -> detail::buffer_appender<Char> { return out_; }
-  void advance_to(detail::buffer_appender<Char>) {}
+  auto out() -> basic_appender<Char> { return out_; }
+  void advance_to(basic_appender<Char>) {}
 
   auto locale() -> detail::locale_ref { return {}; }
 
   auto arg(int id) const -> basic_format_arg<basic_printf_context> {
     return args_.get(id);
   }
-
-  FMT_CONSTEXPR void on_error(const char* message) {
-    detail::error_handler().on_error(message);
-  }
 };
 
 namespace detail {
@@ -64,7 +58,7 @@ namespace detail {
 // signed and unsigned integers.
 template <bool IsSigned> struct int_checker {
   template <typename T> static auto fits_in_int(T value) -> bool {
-    unsigned max = max_value<int>();
+    unsigned max = to_unsigned(max_value<int>());
     return value <= max;
   }
   static auto fits_in_int(bool) -> bool { return true; }
@@ -82,13 +76,13 @@ struct printf_precision_handler {
   template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
   auto operator()(T value) -> int {
     if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
-      throw_format_error("number is too big");
+      report_error("number is too big");
     return (std::max)(static_cast<int>(value), 0);
   }
 
   template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
   auto operator()(T) -> int {
-    throw_format_error("precision is not integer");
+    report_error("precision is not integer");
     return 0;
   }
 };
@@ -165,7 +159,7 @@ template <typename T, typename Context> class arg_converter {
 // unsigned).
 template <typename T, typename Context, typename Char>
 void convert_arg(basic_format_arg<Context>& arg, Char type) {
-  visit_format_arg(arg_converter<T, Context>(arg, type), arg);
+  arg.visit(arg_converter<T, Context>(arg, type));
 }
 
 // Converts an integer argument to char for printf.
@@ -195,12 +189,12 @@ template <typename Char> struct get_cstring {
 
 // Checks if an argument is a valid printf width specifier and sets
 // left alignment if it is negative.
-template <typename Char> class printf_width_handler {
+class printf_width_handler {
  private:
-  format_specs<Char>& specs_;
+  format_specs& specs_;
 
  public:
-  explicit printf_width_handler(format_specs<Char>& specs) : specs_(specs) {}
+  explicit printf_width_handler(format_specs& specs) : specs_(specs) {}
 
   template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
   auto operator()(T value) -> unsigned {
@@ -209,14 +203,14 @@ template <typename Char> class printf_width_handler {
       specs_.align = align::left;
       width = 0 - width;
     }
-    unsigned int_max = max_value<int>();
-    if (width > int_max) throw_format_error("number is too big");
+    unsigned int_max = to_unsigned(max_value<int>());
+    if (width > int_max) report_error("number is too big");
     return static_cast<unsigned>(width);
   }
 
   template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
   auto operator()(T) -> unsigned {
-    throw_format_error("width is not integer");
+    report_error("width is not integer");
     return 0;
   }
 };
@@ -224,12 +218,12 @@ template <typename Char> class printf_width_handler {
 // Workaround for a bug with the XL compiler when initializing
 // printf_arg_formatter's base class.
 template <typename Char>
-auto make_arg_formatter(buffer_appender<Char> iter, format_specs<Char>& s)
+auto make_arg_formatter(basic_appender<Char> iter, format_specs& s)
     -> arg_formatter<Char> {
   return {iter, s, locale_ref()};
 }
 
-// The ``printf`` argument formatter.
+// The `printf` argument formatter.
 template <typename Char>
 class printf_arg_formatter : public arg_formatter<Char> {
  private:
@@ -241,11 +235,11 @@ class printf_arg_formatter : public arg_formatter<Char> {
   void write_null_pointer(bool is_string = false) {
     auto s = this->specs;
     s.type = presentation_type::none;
-    write_bytes(this->out, is_string ? "(null)" : "(nil)", s);
+    write_bytes<Char>(this->out, is_string ? "(null)" : "(nil)", s);
   }
 
  public:
-  printf_arg_formatter(buffer_appender<Char> iter, format_specs<Char>& s,
+  printf_arg_formatter(basic_appender<Char> iter, format_specs& s,
                        context_type& ctx)
       : base(make_arg_formatter(iter, s)), context_(ctx) {}
 
@@ -259,19 +253,18 @@ class printf_arg_formatter : public arg_formatter<Char> {
       base::operator()(value);
       return;
     }
-    format_specs<Char> fmt_specs = this->specs;
-    if (fmt_specs.type != presentation_type::none &&
-        fmt_specs.type != presentation_type::chr) {
+    format_specs s = this->specs;
+    if (s.type != presentation_type::none && s.type != presentation_type::chr) {
       return (*this)(static_cast<int>(value));
     }
-    fmt_specs.sign = sign::none;
-    fmt_specs.alt = false;
-    fmt_specs.fill[0] = ' ';  // Ignore '0' flag for char types.
+    s.sign = sign::none;
+    s.alt = false;
+    s.fill = ' ';  // Ignore '0' flag for char types.
     // align::numeric needs to be overwritten here since the '0' flag is
     // ignored for non-numeric types
-    if (fmt_specs.align == align::none || fmt_specs.align == align::numeric)
-      fmt_specs.align = align::right;
-    write<Char>(this->out, static_cast<Char>(value), fmt_specs);
+    if (s.align == align::none || s.align == align::numeric)
+      s.align = align::right;
+    write<Char>(this->out, static_cast<Char>(value), s);
   }
 
   template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
@@ -279,7 +272,6 @@ class printf_arg_formatter : public arg_formatter<Char> {
     base::operator()(value);
   }
 
-  /** Formats a null-terminated C string. */
   void operator()(const char* value) {
     if (value)
       base::operator()(value);
@@ -287,7 +279,6 @@ class printf_arg_formatter : public arg_formatter<Char> {
       write_null_pointer(this->specs.type != presentation_type::pointer);
   }
 
-  /** Formats a null-terminated wide C string. */
   void operator()(const wchar_t* value) {
     if (value)
       base::operator()(value);
@@ -297,7 +288,6 @@ class printf_arg_formatter : public arg_formatter<Char> {
 
   void operator()(basic_string_view<Char> value) { base::operator()(value); }
 
-  /** Formats a pointer. */
   void operator()(const void* value) {
     if (value)
       base::operator()(value);
@@ -305,7 +295,6 @@ class printf_arg_formatter : public arg_formatter<Char> {
       write_null_pointer();
   }
 
-  /** Formats an argument of a custom (user-defined) type. */
   void operator()(typename basic_format_arg<context_type>::handle handle) {
     auto parse_ctx = basic_format_parse_context<Char>({});
     handle.format(parse_ctx, context_);
@@ -313,7 +302,7 @@ class printf_arg_formatter : public arg_formatter<Char> {
 };
 
 template <typename Char>
-void parse_flags(format_specs<Char>& specs, const Char*& it, const Char* end) {
+void parse_flags(format_specs& specs, const Char*& it, const Char* end) {
   for (; it != end; ++it) {
     switch (*it) {
     case '-':
@@ -323,7 +312,7 @@ void parse_flags(format_specs<Char>& specs, const Char*& it, const Char* end) {
       specs.sign = sign::plus;
       break;
     case '0':
-      specs.fill[0] = '0';
+      specs.fill = '0';
       break;
     case ' ':
       if (specs.sign != sign::plus) specs.sign = sign::space;
@@ -338,7 +327,7 @@ void parse_flags(format_specs<Char>& specs, const Char*& it, const Char* end) {
 }
 
 template <typename Char, typename GetArg>
-auto parse_header(const Char*& it, const Char* end, format_specs<Char>& specs,
+auto parse_header(const Char*& it, const Char* end, format_specs& specs,
                   GetArg get_arg) -> int {
   int arg_index = -1;
   Char c = *it;
@@ -350,11 +339,11 @@ auto parse_header(const Char*& it, const Char* end, format_specs<Char>& specs,
       ++it;
       arg_index = value != -1 ? value : max_value<int>();
     } else {
-      if (c == '0') specs.fill[0] = '0';
+      if (c == '0') specs.fill = '0';
       if (value != 0) {
         // Nonzero value means that we parsed width and don't need to
         // parse it or flags again, so return now.
-        if (value == -1) throw_format_error("number is too big");
+        if (value == -1) report_error("number is too big");
         specs.width = value;
         return arg_index;
       }
@@ -365,17 +354,17 @@ auto parse_header(const Char*& it, const Char* end, format_specs<Char>& specs,
   if (it != end) {
     if (*it >= '0' && *it <= '9') {
       specs.width = parse_nonnegative_int(it, end, -1);
-      if (specs.width == -1) throw_format_error("number is too big");
+      if (specs.width == -1) report_error("number is too big");
     } else if (*it == '*') {
       ++it;
-      specs.width = static_cast<int>(visit_format_arg(
-          detail::printf_width_handler<Char>(specs), get_arg(-1)));
+      specs.width = static_cast<int>(
+          get_arg(-1).visit(detail::printf_width_handler(specs)));
     }
   }
   return arg_index;
 }
 
-inline auto parse_printf_presentation_type(char c, type t)
+inline auto parse_printf_presentation_type(char c, type t, bool& upper)
     -> presentation_type {
   using pt = presentation_type;
   constexpr auto integral_set = sint_set | uint_set | bool_set | char_set;
@@ -384,26 +373,31 @@ inline auto parse_printf_presentation_type(char c, type t)
     return in(t, integral_set) ? pt::dec : pt::none;
   case 'o':
     return in(t, integral_set) ? pt::oct : pt::none;
-  case 'x':
-    return in(t, integral_set) ? pt::hex_lower : pt::none;
   case 'X':
-    return in(t, integral_set) ? pt::hex_upper : pt::none;
-  case 'a':
-    return in(t, float_set) ? pt::hexfloat_lower : pt::none;
-  case 'A':
-    return in(t, float_set) ? pt::hexfloat_upper : pt::none;
-  case 'e':
-    return in(t, float_set) ? pt::exp_lower : pt::none;
+    upper = true;
+    FMT_FALLTHROUGH;
+  case 'x':
+    return in(t, integral_set) ? pt::hex : pt::none;
   case 'E':
-    return in(t, float_set) ? pt::exp_upper : pt::none;
-  case 'f':
-    return in(t, float_set) ? pt::fixed_lower : pt::none;
+    upper = true;
+    FMT_FALLTHROUGH;
+  case 'e':
+    return in(t, float_set) ? pt::exp : pt::none;
   case 'F':
-    return in(t, float_set) ? pt::fixed_upper : pt::none;
-  case 'g':
-    return in(t, float_set) ? pt::general_lower : pt::none;
+    upper = true;
+    FMT_FALLTHROUGH;
+  case 'f':
+    return in(t, float_set) ? pt::fixed : pt::none;
   case 'G':
-    return in(t, float_set) ? pt::general_upper : pt::none;
+    upper = true;
+    FMT_FALLTHROUGH;
+  case 'g':
+    return in(t, float_set) ? pt::general : pt::none;
+  case 'A':
+    upper = true;
+    FMT_FALLTHROUGH;
+  case 'a':
+    return in(t, float_set) ? pt::hexfloat : pt::none;
   case 'c':
     return in(t, integral_set) ? pt::chr : pt::none;
   case 's':
@@ -418,7 +412,7 @@ inline auto parse_printf_presentation_type(char c, type t)
 template <typename Char, typename Context>
 void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
              basic_format_args<Context> args) {
-  using iterator = buffer_appender<Char>;
+  using iterator = basic_appender<Char>;
   auto out = iterator(buf);
   auto context = basic_printf_context<Char>(out, args);
   auto parse_ctx = basic_format_parse_context<Char>(format);
@@ -449,12 +443,12 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
     }
     write(out, basic_string_view<Char>(start, to_unsigned(it - 1 - start)));
 
-    auto specs = format_specs<Char>();
+    auto specs = format_specs();
     specs.align = align::right;
 
     // Parse argument index, flags and width.
     int arg_index = parse_header(it, end, specs, get_arg);
-    if (arg_index == 0) throw_format_error("argument not found");
+    if (arg_index == 0) report_error("argument not found");
 
     // Parse precision.
     if (it != end && *it == '.') {
@@ -464,8 +458,8 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
         specs.precision = parse_nonnegative_int(it, end, 0);
       } else if (c == '*') {
         ++it;
-        specs.precision = static_cast<int>(
-            visit_format_arg(printf_precision_handler(), get_arg(-1)));
+        specs.precision =
+            static_cast<int>(get_arg(-1).visit(printf_precision_handler()));
       } else {
         specs.precision = 0;
       }
@@ -476,23 +470,23 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
     // specified, the '0' flag is ignored
     if (specs.precision >= 0 && arg.is_integral()) {
       // Ignore '0' for non-numeric types or if '-' present.
-      specs.fill[0] = ' ';
+      specs.fill = ' ';
     }
     if (specs.precision >= 0 && arg.type() == type::cstring_type) {
-      auto str = visit_format_arg(get_cstring<Char>(), arg);
+      auto str = arg.visit(get_cstring<Char>());
       auto str_end = str + specs.precision;
       auto nul = std::find(str, str_end, Char());
       auto sv = basic_string_view<Char>(
           str, to_unsigned(nul != str_end ? nul - str : specs.precision));
       arg = make_arg<basic_printf_context<Char>>(sv);
     }
-    if (specs.alt && visit_format_arg(is_zero_int(), arg)) specs.alt = false;
-    if (specs.fill[0] == '0') {
+    if (specs.alt && arg.visit(is_zero_int())) specs.alt = false;
+    if (specs.fill.template get<Char>() == '0') {
       if (arg.is_arithmetic() && specs.align != align::left)
         specs.align = align::numeric;
       else
-        specs.fill[0] = ' ';  // Ignore '0' flag for non-numeric types or if '-'
-                              // flag is also present.
+        specs.fill = ' ';  // Ignore '0' flag for non-numeric types or if '-'
+                           // flag is also present.
     }
 
     // Parse length and convert the argument to the required type.
@@ -536,7 +530,7 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
     }
 
     // Parse type.
-    if (it == end) throw_format_error("invalid format string");
+    if (it == end) report_error("invalid format string");
     char type = static_cast<char>(*it++);
     if (arg.is_integral()) {
       // Normalize type.
@@ -546,18 +540,20 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
         type = 'd';
         break;
       case 'c':
-        visit_format_arg(char_converter<basic_printf_context<Char>>(arg), arg);
+        arg.visit(char_converter<basic_printf_context<Char>>(arg));
         break;
       }
     }
-    specs.type = parse_printf_presentation_type(type, arg.type());
+    bool upper = false;
+    specs.type = parse_printf_presentation_type(type, arg.type(), upper);
     if (specs.type == presentation_type::none)
-      throw_format_error("invalid format specifier");
+      report_error("invalid format specifier");
+    specs.upper = upper;
 
     start = it;
 
     // Format argument.
-    visit_format_arg(printf_arg_formatter<Char>(out, specs, context), arg);
+    arg.visit(printf_arg_formatter<Char>(out, specs, context));
   }
   write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
 }
@@ -569,29 +565,21 @@ using wprintf_context = basic_printf_context<wchar_t>;
 using printf_args = basic_format_args<printf_context>;
 using wprintf_args = basic_format_args<wprintf_context>;
 
-/**
-  \rst
-  Constructs an `~fmt::format_arg_store` object that contains references to
-  arguments and can be implicitly converted to `~fmt::printf_args`.
-  \endrst
- */
-template <typename... T>
-inline auto make_printf_args(const T&... args)
-    -> format_arg_store<printf_context, T...> {
-  return {args...};
+/// Constructs an `format_arg_store` object that contains references to
+/// arguments and can be implicitly converted to `printf_args`.
+template <typename Char = char, typename... T>
+inline auto make_printf_args(T&... args)
+    -> decltype(fmt::make_format_args<basic_printf_context<Char>>(args...)) {
+  return fmt::make_format_args<basic_printf_context<Char>>(args...);
 }
 
-// DEPRECATED!
-template <typename... T>
-inline auto make_wprintf_args(const T&... args)
-    -> format_arg_store<wprintf_context, T...> {
-  return {args...};
-}
+template <typename Char> struct vprintf_args {
+  using type = basic_format_args<basic_printf_context<Char>>;
+};
 
 template <typename Char>
-inline auto vsprintf(
-    basic_string_view<Char> fmt,
-    basic_format_args<basic_printf_context<type_identity_t<Char>>> args)
+inline auto vsprintf(basic_string_view<Char> fmt,
+                     typename vprintf_args<Char>::type args)
     -> std::basic_string<Char> {
   auto buf = basic_memory_buffer<Char>();
   detail::vprintf(buf, fmt, args);
@@ -599,26 +587,22 @@ inline auto vsprintf(
 }
 
 /**
-  \rst
-  Formats arguments and returns the result as a string.
-
-  **Example**::
-
-    std::string message = fmt::sprintf("The answer is %d", 42);
-  \endrst
-*/
-template <typename S, typename... T,
-          typename Char = enable_if_t<detail::is_string<S>::value, char_t<S>>>
+ * Formats `args` according to specifications in `fmt` and returns the result
+ * as as string.
+ *
+ * **Example**:
+ *
+ *     std::string message = fmt::sprintf("The answer is %d", 42);
+ */
+template <typename S, typename... T, typename Char = char_t<S>>
 inline auto sprintf(const S& fmt, const T&... args) -> std::basic_string<Char> {
   return vsprintf(detail::to_string_view(fmt),
                   fmt::make_format_args<basic_printf_context<Char>>(args...));
 }
 
 template <typename Char>
-inline auto vfprintf(
-    std::FILE* f, basic_string_view<Char> fmt,
-    basic_format_args<basic_printf_context<type_identity_t<Char>>> args)
-    -> int {
+inline auto vfprintf(std::FILE* f, basic_string_view<Char> fmt,
+                     typename vprintf_args<Char>::type args) -> int {
   auto buf = basic_memory_buffer<Char>();
   detail::vprintf(buf, fmt, args);
   size_t size = buf.size();
@@ -628,36 +612,33 @@ inline auto vfprintf(
 }
 
 /**
-  \rst
-  Prints formatted data to the file *f*.
-
-  **Example**::
-
-    fmt::fprintf(stderr, "Don't %s!", "panic");
-  \endrst
+ * Formats `args` according to specifications in `fmt` and writes the output
+ * to `f`.
+ *
+ * **Example**:
+ *
+ *     fmt::fprintf(stderr, "Don't %s!", "panic");
  */
 template <typename S, typename... T, typename Char = char_t<S>>
 inline auto fprintf(std::FILE* f, const S& fmt, const T&... args) -> int {
   return vfprintf(f, detail::to_string_view(fmt),
-                  fmt::make_format_args<basic_printf_context<Char>>(args...));
+                  make_printf_args<Char>(args...));
 }
 
 template <typename Char>
-FMT_DEPRECATED inline auto vprintf(
-    basic_string_view<Char> fmt,
-    basic_format_args<basic_printf_context<type_identity_t<Char>>> args)
+FMT_DEPRECATED inline auto vprintf(basic_string_view<Char> fmt,
+                                   typename vprintf_args<Char>::type args)
     -> int {
   return vfprintf(stdout, fmt, args);
 }
 
 /**
-  \rst
-  Prints formatted data to ``stdout``.
-
-  **Example**::
-
-    fmt::printf("Elapsed time: %.2f seconds", 1.23);
-  \endrst
+ * Formats `args` according to specifications in `fmt` and writes the output
+ * to `stdout`.
+ *
+ * **Example**:
+ *
+ *   fmt::printf("Elapsed time: %.2f seconds", 1.23);
  */
 template <typename... T>
 inline auto printf(string_view fmt, const T&... args) -> int {
@@ -666,7 +647,7 @@ inline auto printf(string_view fmt, const T&... args) -> int {
 template <typename... T>
 FMT_DEPRECATED inline auto printf(basic_string_view<wchar_t> fmt,
                                   const T&... args) -> int {
-  return vfprintf(stdout, fmt, make_wprintf_args(args...));
+  return vfprintf(stdout, fmt, make_printf_args<wchar_t>(args...));
 }
 
 FMT_END_EXPORT
diff --git a/thirdparty/fmt/ranges.h b/thirdparty/fmt/ranges.h
index 3638fffb8..0d3dfbd8d 100644
--- a/thirdparty/fmt/ranges.h
+++ b/thirdparty/fmt/ranges.h
@@ -8,67 +8,31 @@
 #ifndef FMT_RANGES_H_
 #define FMT_RANGES_H_
 
-#include <initializer_list>
-#include <tuple>
-#include <type_traits>
+#ifndef FMT_MODULE
+#  include <initializer_list>
+#  include <iterator>
+#  include <string>
+#  include <tuple>
+#  include <type_traits>
+#  include <utility>
+#endif
 
 #include "format.h"
 
 FMT_BEGIN_NAMESPACE
 
-namespace detail {
-
-template <typename Range, typename OutputIt>
-auto copy(const Range& range, OutputIt out) -> OutputIt {
-  for (auto it = range.begin(), end = range.end(); it != end; ++it)
-    *out++ = *it;
-  return out;
-}
-
-template <typename OutputIt>
-auto copy(const char* str, OutputIt out) -> OutputIt {
-  while (*str) *out++ = *str++;
-  return out;
-}
-
-template <typename OutputIt> auto copy(char ch, OutputIt out) -> OutputIt {
-  *out++ = ch;
-  return out;
-}
-
-template <typename OutputIt> auto copy(wchar_t ch, OutputIt out) -> OutputIt {
-  *out++ = ch;
-  return out;
-}
-
-// Returns true if T has a std::string-like interface, like std::string_view.
-template <typename T> class is_std_string_like {
-  template <typename U>
-  static auto check(U* p)
-      -> decltype((void)p->find('a'), p->length(), (void)p->data(), int());
-  template <typename> static void check(...);
-
- public:
-  static constexpr const bool value =
-      is_string<T>::value ||
-      std::is_convertible<T, std_string_view<char>>::value ||
-      !std::is_void<decltype(check<T>(nullptr))>::value;
-};
+FMT_EXPORT
+enum class range_format { disabled, map, set, sequence, string, debug_string };
 
-template <typename Char>
-struct is_std_string_like<fmt::basic_string_view<Char>> : std::true_type {};
+namespace detail {
 
 template <typename T> class is_map {
   template <typename U> static auto check(U*) -> typename U::mapped_type;
   template <typename> static void check(...);
 
  public:
-#ifdef FMT_FORMAT_MAP_AS_LIST  // DEPRECATED!
-  static constexpr const bool value = false;
-#else
   static constexpr const bool value =
       !std::is_void<decltype(check<T>(nullptr))>::value;
-#endif
 };
 
 template <typename T> class is_set {
@@ -76,12 +40,8 @@ template <typename T> class is_set {
   template <typename> static void check(...);
 
  public:
-#ifdef FMT_FORMAT_SET_AS_LIST  // DEPRECATED!
-  static constexpr const bool value = false;
-#else
   static constexpr const bool value =
       !std::is_void<decltype(check<T>(nullptr))>::value && !is_map<T>::value;
-#endif
 };
 
 template <typename... Ts> struct conditional_helper {};
@@ -110,17 +70,17 @@ template <typename T, typename Enable = void>
 struct has_member_fn_begin_end_t : std::false_type {};
 
 template <typename T>
-struct has_member_fn_begin_end_t<T, void_t<decltype(std::declval<T>().begin()),
+struct has_member_fn_begin_end_t<T, void_t<decltype(*std::declval<T>().begin()),
                                            decltype(std::declval<T>().end())>>
     : std::true_type {};
 
-// Member function overload
+// Member function overloads.
 template <typename T>
 auto range_begin(T&& rng) FMT_DECLTYPE_RETURN(static_cast<T&&>(rng).begin());
 template <typename T>
 auto range_end(T&& rng) FMT_DECLTYPE_RETURN(static_cast<T&&>(rng).end());
 
-// ADL overload. Only participates in overload resolution if member functions
+// ADL overloads. Only participate in overload resolution if member functions
 // are not found.
 template <typename T>
 auto range_begin(T&& rng)
@@ -141,16 +101,16 @@ struct has_mutable_begin_end : std::false_type {};
 
 template <typename T>
 struct has_const_begin_end<
-    T,
-    void_t<
-        decltype(detail::range_begin(std::declval<const remove_cvref_t<T>&>())),
-        decltype(detail::range_end(std::declval<const remove_cvref_t<T>&>()))>>
+    T, void_t<decltype(*detail::range_begin(
+                  std::declval<const remove_cvref_t<T>&>())),
+              decltype(detail::range_end(
+                  std::declval<const remove_cvref_t<T>&>()))>>
     : std::true_type {};
 
 template <typename T>
 struct has_mutable_begin_end<
-    T, void_t<decltype(detail::range_begin(std::declval<T>())),
-              decltype(detail::range_end(std::declval<T>())),
+    T, void_t<decltype(*detail::range_begin(std::declval<T&>())),
+              decltype(detail::range_end(std::declval<T&>())),
               // the extra int here is because older versions of MSVC don't
               // SFINAE properly unless there are distinct types
               int>> : std::true_type {};
@@ -206,12 +166,13 @@ class is_tuple_formattable_ {
   static constexpr const bool value = false;
 };
 template <typename T, typename C> class is_tuple_formattable_<T, C, true> {
-  template <std::size_t... Is>
-  static auto check2(index_sequence<Is...>,
-                     integer_sequence<bool, (Is == Is)...>) -> std::true_type;
-  static auto check2(...) -> std::false_type;
-  template <std::size_t... Is>
-  static auto check(index_sequence<Is...>) -> decltype(check2(
+  template <size_t... Is>
+  static auto all_true(index_sequence<Is...>,
+                       integer_sequence<bool, (Is >= 0)...>) -> std::true_type;
+  static auto all_true(...) -> std::false_type;
+
+  template <size_t... Is>
+  static auto check(index_sequence<Is...>) -> decltype(all_true(
       index_sequence<Is...>{},
       integer_sequence<bool,
                        (is_formattable<typename std::tuple_element<Is, T>::type,
@@ -292,6 +253,18 @@ FMT_CONSTEXPR auto maybe_set_debug_format(Formatter& f, bool set)
 template <typename Formatter>
 FMT_CONSTEXPR void maybe_set_debug_format(Formatter&, ...) {}
 
+template <typename T>
+struct range_format_kind_
+    : std::integral_constant<range_format,
+                             std::is_same<uncvref_type<T>, T>::value
+                                 ? range_format::disabled
+                             : is_map<T>::value ? range_format::map
+                             : is_set<T>::value ? range_format::set
+                                                : range_format::sequence> {};
+
+template <range_format K>
+using range_format_constant = std::integral_constant<range_format, K>;
+
 // These are not generic lambdas for compatibility with C++11.
 template <typename ParseContext> struct parse_empty_specs {
   template <typename Formatter> FMT_CONSTEXPR void operator()(Formatter& f) {
@@ -305,8 +278,7 @@ template <typename FormatContext> struct format_tuple_element {
 
   template <typename T>
   void operator()(const formatter<T, char_type>& f, const T& v) {
-    if (i > 0)
-      ctx.advance_to(detail::copy_str<char_type>(separator, ctx.out()));
+    if (i > 0) ctx.advance_to(detail::copy<char_type>(separator, ctx.out()));
     ctx.advance_to(f.format(v, ctx));
     ++i;
   }
@@ -358,8 +330,7 @@ struct formatter<Tuple, Char,
   template <typename ParseContext>
   FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
     auto it = ctx.begin();
-    if (it != ctx.end() && *it != '}')
-      FMT_THROW(format_error("invalid format specifier"));
+    if (it != ctx.end() && *it != '}') report_error("invalid format specifier");
     detail::for_each(formatters_, detail::parse_empty_specs<ParseContext>{ctx});
     return it;
   }
@@ -367,19 +338,17 @@ struct formatter<Tuple, Char,
   template <typename FormatContext>
   auto format(const Tuple& value, FormatContext& ctx) const
       -> decltype(ctx.out()) {
-    ctx.advance_to(detail::copy_str<Char>(opening_bracket_, ctx.out()));
+    ctx.advance_to(detail::copy<Char>(opening_bracket_, ctx.out()));
     detail::for_each2(
         formatters_, value,
         detail::format_tuple_element<FormatContext>{0, ctx, separator_});
-    return detail::copy_str<Char>(closing_bracket_, ctx.out());
+    return detail::copy<Char>(closing_bracket_, ctx.out());
   }
 };
 
 template <typename T, typename Char> struct is_range {
   static constexpr const bool value =
-      detail::is_range_<T>::value && !detail::is_std_string_like<T>::value &&
-      !std::is_convertible<T, std::basic_string<Char>>::value &&
-      !std::is_convertible<T, detail::std_string_view<Char>>::value;
+      detail::is_range_<T>::value && !detail::has_to_string_view<T>::value;
 };
 
 namespace detail {
@@ -401,8 +370,8 @@ template <typename Context> struct range_mapper {
 
 template <typename Char, typename Element>
 using range_formatter_type =
-    formatter<remove_cvref_t<decltype(range_mapper<buffer_context<Char>>{}.map(
-                  std::declval<Element>()))>,
+    formatter<remove_cvref_t<decltype(range_mapper<buffered_context<Char>>{}
+                                          .map(std::declval<Element>()))>,
               Char>;
 
 template <typename R>
@@ -438,6 +407,24 @@ struct range_formatter<
       detail::string_literal<Char, '['>{};
   basic_string_view<Char> closing_bracket_ =
       detail::string_literal<Char, ']'>{};
+  bool is_debug = false;
+
+  template <typename Output, typename It, typename Sentinel, typename U = T,
+            FMT_ENABLE_IF(std::is_same<U, Char>::value)>
+  auto write_debug_string(Output& out, It it, Sentinel end) const -> Output {
+    auto buf = basic_memory_buffer<Char>();
+    for (; it != end; ++it) buf.push_back(*it);
+    auto specs = format_specs();
+    specs.type = presentation_type::debug;
+    return detail::write<Char>(
+        out, basic_string_view<Char>(buf.data(), buf.size()), specs);
+  }
+
+  template <typename Output, typename It, typename Sentinel, typename U = T,
+            FMT_ENABLE_IF(!std::is_same<U, Char>::value)>
+  auto write_debug_string(Output& out, It, Sentinel) const -> Output {
+    return out;
+  }
 
  public:
   FMT_CONSTEXPR range_formatter() {}
@@ -460,17 +447,37 @@ struct range_formatter<
   FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
     auto it = ctx.begin();
     auto end = ctx.end();
+    detail::maybe_set_debug_format(underlying_, true);
+    if (it == end) return underlying_.parse(ctx);
 
-    if (it != end && *it == 'n') {
+    switch (detail::to_ascii(*it)) {
+    case 'n':
       set_brackets({}, {});
       ++it;
+      break;
+    case '?':
+      is_debug = true;
+      set_brackets({}, {});
+      ++it;
+      if (it == end || *it != 's') report_error("invalid format specifier");
+      FMT_FALLTHROUGH;
+    case 's':
+      if (!std::is_same<T, Char>::value)
+        report_error("invalid format specifier");
+      if (!is_debug) {
+        set_brackets(detail::string_literal<Char, '"'>{},
+                     detail::string_literal<Char, '"'>{});
+        set_separator({});
+        detail::maybe_set_debug_format(underlying_, false);
+      }
+      ++it;
+      return it;
     }
 
     if (it != end && *it != '}') {
-      if (*it != ':') FMT_THROW(format_error("invalid format specifier"));
+      if (*it != ':') report_error("invalid format specifier");
+      detail::maybe_set_debug_format(underlying_, false);
       ++it;
-    } else {
-      detail::maybe_set_debug_format(underlying_, true);
     }
 
     ctx.advance_to(it);
@@ -479,67 +486,151 @@ struct range_formatter<
 
   template <typename R, typename FormatContext>
   auto format(R&& range, FormatContext& ctx) const -> decltype(ctx.out()) {
-    detail::range_mapper<buffer_context<Char>> mapper;
+    auto mapper = detail::range_mapper<buffered_context<Char>>();
     auto out = ctx.out();
-    out = detail::copy_str<Char>(opening_bracket_, out);
-    int i = 0;
     auto it = detail::range_begin(range);
     auto end = detail::range_end(range);
+    if (is_debug) return write_debug_string(out, std::move(it), end);
+
+    out = detail::copy<Char>(opening_bracket_, out);
+    int i = 0;
     for (; it != end; ++it) {
-      if (i > 0) out = detail::copy_str<Char>(separator_, out);
+      if (i > 0) out = detail::copy<Char>(separator_, out);
       ctx.advance_to(out);
-      auto&& item = *it;
+      auto&& item = *it;  // Need an lvalue
       out = underlying_.format(mapper.map(item), ctx);
       ++i;
     }
-    out = detail::copy_str<Char>(closing_bracket_, out);
+    out = detail::copy<Char>(closing_bracket_, out);
     return out;
   }
 };
 
-enum class range_format { disabled, map, set, sequence, string, debug_string };
+FMT_EXPORT
+template <typename T, typename Char, typename Enable = void>
+struct range_format_kind
+    : conditional_t<
+          is_range<T, Char>::value, detail::range_format_kind_<T>,
+          std::integral_constant<range_format, range_format::disabled>> {};
 
-namespace detail {
-template <typename T>
-struct range_format_kind_
-    : std::integral_constant<range_format,
-                             std::is_same<uncvref_type<T>, T>::value
-                                 ? range_format::disabled
-                             : is_map<T>::value ? range_format::map
-                             : is_set<T>::value ? range_format::set
-                                                : range_format::sequence> {};
+template <typename R, typename Char>
+struct formatter<
+    R, Char,
+    enable_if_t<conjunction<
+        bool_constant<
+            range_format_kind<R, Char>::value != range_format::disabled &&
+            range_format_kind<R, Char>::value != range_format::map &&
+            range_format_kind<R, Char>::value != range_format::string &&
+            range_format_kind<R, Char>::value != range_format::debug_string>
+// Workaround a bug in MSVC 2015 and earlier.
+#if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1910
+        ,
+        detail::is_formattable_delayed<R, Char>
+#endif
+        >::value>> {
+ private:
+  using range_type = detail::maybe_const_range<R>;
+  range_formatter<detail::uncvref_type<range_type>, Char> range_formatter_;
 
-template <range_format K, typename R, typename Char, typename Enable = void>
-struct range_default_formatter;
+ public:
+  using nonlocking = void;
+
+  FMT_CONSTEXPR formatter() {
+    if (detail::const_check(range_format_kind<R, Char>::value !=
+                            range_format::set))
+      return;
+    range_formatter_.set_brackets(detail::string_literal<Char, '{'>{},
+                                  detail::string_literal<Char, '}'>{});
+  }
 
-template <range_format K>
-using range_format_constant = std::integral_constant<range_format, K>;
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return range_formatter_.parse(ctx);
+  }
 
-template <range_format K, typename R, typename Char>
-struct range_default_formatter<
-    K, R, Char,
-    enable_if_t<(K == range_format::sequence || K == range_format::map ||
-                 K == range_format::set)>> {
-  using range_type = detail::maybe_const_range<R>;
-  range_formatter<detail::uncvref_type<range_type>, Char> underlying_;
+  template <typename FormatContext>
+  auto format(range_type& range, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    return range_formatter_.format(range, ctx);
+  }
+};
+
+// A map formatter.
+template <typename R, typename Char>
+struct formatter<
+    R, Char,
+    enable_if_t<range_format_kind<R, Char>::value == range_format::map>> {
+ private:
+  using map_type = detail::maybe_const_range<R>;
+  using element_type = detail::uncvref_type<map_type>;
 
-  FMT_CONSTEXPR range_default_formatter() { init(range_format_constant<K>()); }
+  decltype(detail::tuple::get_formatters<element_type, Char>(
+      detail::tuple_index_sequence<element_type>())) formatters_;
+  bool no_delimiters_ = false;
 
-  FMT_CONSTEXPR void init(range_format_constant<range_format::set>) {
-    underlying_.set_brackets(detail::string_literal<Char, '{'>{},
-                             detail::string_literal<Char, '}'>{});
+ public:
+  FMT_CONSTEXPR formatter() {}
+
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    auto it = ctx.begin();
+    auto end = ctx.end();
+    if (it != end) {
+      if (detail::to_ascii(*it) == 'n') {
+        no_delimiters_ = true;
+        ++it;
+      }
+      if (it != end && *it != '}') {
+        if (*it != ':') report_error("invalid format specifier");
+        ++it;
+      }
+      ctx.advance_to(it);
+    }
+    detail::for_each(formatters_, detail::parse_empty_specs<ParseContext>{ctx});
+    return it;
   }
 
-  FMT_CONSTEXPR void init(range_format_constant<range_format::map>) {
-    underlying_.set_brackets(detail::string_literal<Char, '{'>{},
-                             detail::string_literal<Char, '}'>{});
-    underlying_.underlying().set_brackets({}, {});
-    underlying_.underlying().set_separator(
-        detail::string_literal<Char, ':', ' '>{});
+  template <typename FormatContext>
+  auto format(map_type& map, FormatContext& ctx) const -> decltype(ctx.out()) {
+    auto out = ctx.out();
+    basic_string_view<Char> open = detail::string_literal<Char, '{'>{};
+    if (!no_delimiters_) out = detail::copy<Char>(open, out);
+    int i = 0;
+    auto mapper = detail::range_mapper<buffered_context<Char>>();
+    basic_string_view<Char> sep = detail::string_literal<Char, ',', ' '>{};
+    for (auto&& value : map) {
+      if (i > 0) out = detail::copy<Char>(sep, out);
+      ctx.advance_to(out);
+      detail::for_each2(formatters_, mapper.map(value),
+                        detail::format_tuple_element<FormatContext>{
+                            0, ctx, detail::string_literal<Char, ':', ' '>{}});
+      ++i;
+    }
+    basic_string_view<Char> close = detail::string_literal<Char, '}'>{};
+    if (!no_delimiters_) out = detail::copy<Char>(close, out);
+    return out;
   }
+};
 
-  FMT_CONSTEXPR void init(range_format_constant<range_format::sequence>) {}
+// A (debug_)string formatter.
+template <typename R, typename Char>
+struct formatter<
+    R, Char,
+    enable_if_t<range_format_kind<R, Char>::value == range_format::string ||
+                range_format_kind<R, Char>::value ==
+                    range_format::debug_string>> {
+ private:
+  using range_type = detail::maybe_const_range<R>;
+  using string_type =
+      conditional_t<std::is_constructible<
+                        detail::std_string_view<Char>,
+                        decltype(detail::range_begin(std::declval<R>())),
+                        decltype(detail::range_end(std::declval<R>()))>::value,
+                    detail::std_string_view<Char>, std::basic_string<Char>>;
 
+  formatter<string_type, Char> underlying_;
+
+ public:
   template <typename ParseContext>
   FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
     return underlying_.parse(ctx);
@@ -548,32 +639,98 @@ struct range_default_formatter<
   template <typename FormatContext>
   auto format(range_type& range, FormatContext& ctx) const
       -> decltype(ctx.out()) {
-    return underlying_.format(range, ctx);
+    auto out = ctx.out();
+    if (detail::const_check(range_format_kind<R, Char>::value ==
+                            range_format::debug_string))
+      *out++ = '"';
+    out = underlying_.format(
+        string_type{detail::range_begin(range), detail::range_end(range)}, ctx);
+    if (detail::const_check(range_format_kind<R, Char>::value ==
+                            range_format::debug_string))
+      *out++ = '"';
+    return out;
   }
 };
-}  // namespace detail
 
-template <typename T, typename Char, typename Enable = void>
-struct range_format_kind
-    : conditional_t<
-          is_range<T, Char>::value, detail::range_format_kind_<T>,
-          std::integral_constant<range_format, range_format::disabled>> {};
+template <typename It, typename Sentinel, typename Char = char>
+struct join_view : detail::view {
+  It begin;
+  Sentinel end;
+  basic_string_view<Char> sep;
 
-template <typename R, typename Char>
-struct formatter<
-    R, Char,
-    enable_if_t<conjunction<bool_constant<range_format_kind<R, Char>::value !=
-                                          range_format::disabled>
-// Workaround a bug in MSVC 2015 and earlier.
-#if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1910
-                            ,
-                            detail::is_formattable_delayed<R, Char>
+  join_view(It b, Sentinel e, basic_string_view<Char> s)
+      : begin(std::move(b)), end(e), sep(s) {}
+};
+
+template <typename It, typename Sentinel, typename Char>
+struct formatter<join_view<It, Sentinel, Char>, Char> {
+ private:
+  using value_type =
+#ifdef __cpp_lib_ranges
+      std::iter_value_t<It>;
+#else
+      typename std::iterator_traits<It>::value_type;
 #endif
-                            >::value>>
-    : detail::range_default_formatter<range_format_kind<R, Char>::value, R,
-                                      Char> {
+  formatter<remove_cvref_t<value_type>, Char> value_formatter_;
+
+  using view_ref = conditional_t<std::is_copy_constructible<It>::value,
+                                 const join_view<It, Sentinel, Char>&,
+                                 join_view<It, Sentinel, Char>&&>;
+
+ public:
+  using nonlocking = void;
+
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> const Char* {
+    return value_formatter_.parse(ctx);
+  }
+
+  template <typename FormatContext>
+  auto format(view_ref& value, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    auto it = std::forward<view_ref>(value).begin;
+    auto out = ctx.out();
+    if (it == value.end) return out;
+    out = value_formatter_.format(*it, ctx);
+    ++it;
+    while (it != value.end) {
+      out = detail::copy<Char>(value.sep.begin(), value.sep.end(), out);
+      ctx.advance_to(out);
+      out = value_formatter_.format(*it, ctx);
+      ++it;
+    }
+    return out;
+  }
 };
 
+/// Returns a view that formats the iterator range `[begin, end)` with elements
+/// separated by `sep`.
+template <typename It, typename Sentinel>
+auto join(It begin, Sentinel end, string_view sep) -> join_view<It, Sentinel> {
+  return {std::move(begin), end, sep};
+}
+
+/**
+ * Returns a view that formats `range` with elements separated by `sep`.
+ *
+ * **Example**:
+ *
+ *     auto v = std::vector<int>{1, 2, 3};
+ *     fmt::print("{}", fmt::join(v, ", "));
+ *     // Output: 1, 2, 3
+ *
+ * `fmt::join` applies passed format specifiers to the range elements:
+ *
+ *     fmt::print("{:02}", fmt::join(v, ", "));
+ *     // Output: 01, 02, 03
+ */
+template <typename Range>
+auto join(Range&& r, string_view sep)
+    -> join_view<decltype(detail::range_begin(r)),
+                 decltype(detail::range_end(r))> {
+  return {detail::range_begin(r), detail::range_end(r), sep};
+}
+
 template <typename Char, typename... T> struct tuple_join_view : detail::view {
   const std::tuple<T...>& tuple;
   basic_string_view<Char> sep;
@@ -623,7 +780,7 @@ struct formatter<tuple_join_view<Char, T...>, Char> {
     if (N > 1) {
       auto end1 = do_parse(ctx, std::integral_constant<size_t, N - 1>());
       if (end != end1)
-        FMT_THROW(format_error("incompatible format specs for tuple elements"));
+        report_error("incompatible format specs for tuple elements");
     }
 #endif
     return end;
@@ -642,12 +799,10 @@ struct formatter<tuple_join_view<Char, T...>, Char> {
       typename FormatContext::iterator {
     auto out = std::get<sizeof...(T) - N>(formatters_)
                    .format(std::get<sizeof...(T) - N>(value.tuple), ctx);
-    if (N > 1) {
-      out = std::copy(value.sep.begin(), value.sep.end(), out);
-      ctx.advance_to(out);
-      return do_format(value, ctx, std::integral_constant<size_t, N - 1>());
-    }
-    return out;
+    if (N <= 1) return out;
+    out = detail::copy<Char>(value.sep, out);
+    ctx.advance_to(out);
+    return do_format(value, ctx, std::integral_constant<size_t, N - 1>());
   }
 };
 
@@ -692,15 +847,13 @@ struct formatter<
 FMT_BEGIN_EXPORT
 
 /**
-  \rst
-  Returns an object that formats `tuple` with elements separated by `sep`.
-
-  **Example**::
-
-    std::tuple<int, char> t = {1, 'a'};
-    fmt::print("{}", fmt::join(t, ", "));
-    // Output: "1, a"
-  \endrst
+ * Returns an object that formats `std::tuple` with elements separated by `sep`.
+ *
+ * **Example**:
+ *
+ *     auto t = std::tuple<int, char>{1, 'a'};
+ *     fmt::print("{}", fmt::join(t, ", "));
+ *     // Output: 1, a
  */
 template <typename... T>
 FMT_CONSTEXPR auto join(const std::tuple<T...>& tuple, string_view sep)
@@ -708,23 +861,14 @@ FMT_CONSTEXPR auto join(const std::tuple<T...>& tuple, string_view sep)
   return {tuple, sep};
 }
 
-template <typename... T>
-FMT_CONSTEXPR auto join(const std::tuple<T...>& tuple,
-                        basic_string_view<wchar_t> sep)
-    -> tuple_join_view<wchar_t, T...> {
-  return {tuple, sep};
-}
-
 /**
-  \rst
-  Returns an object that formats `initializer_list` with elements separated by
-  `sep`.
-
-  **Example**::
-
-    fmt::print("{}", fmt::join({1, 2, 3}, ", "));
-    // Output: "1, 2, 3"
-  \endrst
+ * Returns an object that formats `std::initializer_list` with elements
+ * separated by `sep`.
+ *
+ * **Example**:
+ *
+ *     fmt::print("{}", fmt::join({1, 2, 3}, ", "));
+ *     // Output: "1, 2, 3"
  */
 template <typename T>
 auto join(std::initializer_list<T> list, string_view sep)
diff --git a/thirdparty/fmt/std.h b/thirdparty/fmt/std.h
index 7cff11592..fb43940bc 100644
--- a/thirdparty/fmt/std.h
+++ b/thirdparty/fmt/std.h
@@ -8,38 +8,46 @@
 #ifndef FMT_STD_H_
 #define FMT_STD_H_
 
-#include <atomic>
-#include <bitset>
-#include <cstdlib>
-#include <exception>
-#include <memory>
-#include <thread>
-#include <type_traits>
-#include <typeinfo>
-#include <utility>
-#include <vector>
-
 #include "format.h"
 #include "ostream.h"
 
-#if FMT_HAS_INCLUDE(<version>)
-#  include <version>
-#endif
-// Checking FMT_CPLUSPLUS for warning suppression in MSVC.
-#if FMT_CPLUSPLUS >= 201703L
-#  if FMT_HAS_INCLUDE(<filesystem>)
-#    include <filesystem>
+#ifndef FMT_MODULE
+#  include <atomic>
+#  include <bitset>
+#  include <complex>
+#  include <cstdlib>
+#  include <exception>
+#  include <memory>
+#  include <thread>
+#  include <type_traits>
+#  include <typeinfo>
+#  include <utility>
+#  include <vector>
+
+// Check FMT_CPLUSPLUS to suppress a bogus warning in MSVC.
+#  if FMT_CPLUSPLUS >= 201703L
+#    if FMT_HAS_INCLUDE(<filesystem>)
+#      include <filesystem>
+#    endif
+#    if FMT_HAS_INCLUDE(<variant>)
+#      include <variant>
+#    endif
+#    if FMT_HAS_INCLUDE(<optional>)
+#      include <optional>
+#    endif
 #  endif
-#  if FMT_HAS_INCLUDE(<variant>)
-#    include <variant>
+// Use > instead of >= in the version check because <source_location> may be
+// available after C++17 but before C++20 is marked as implemented.
+#  if FMT_CPLUSPLUS > 201703L && FMT_HAS_INCLUDE(<source_location>)
+#    include <source_location>
 #  endif
-#  if FMT_HAS_INCLUDE(<optional>)
-#    include <optional>
+#  if FMT_CPLUSPLUS > 202002L && FMT_HAS_INCLUDE(<expected>)
+#    include <expected>
 #  endif
-#endif
+#endif  // FMT_MODULE
 
-#if FMT_CPLUSPLUS > 201703L && FMT_HAS_INCLUDE(<source_location>)
-#  include <source_location>
+#if FMT_HAS_INCLUDE(<version>)
+#  include <version>
 #endif
 
 // GCC 4 does not support FMT_HAS_INCLUDE.
@@ -52,17 +60,6 @@
 #  endif
 #endif
 
-// Check if typeid is available.
-#ifndef FMT_USE_TYPEID
-// __RTTI is for EDG compilers. In MSVC typeid is available without RTTI.
-#  if defined(__GXX_RTTI) || FMT_HAS_FEATURE(cxx_rtti) || FMT_MSC_VERSION || \
-      defined(__INTEL_RTTI__) || defined(__RTTI)
-#    define FMT_USE_TYPEID 1
-#  else
-#    define FMT_USE_TYPEID 0
-#  endif
-#endif
-
 // For older Xcode versions, __cpp_lib_xxx flags are inaccurately defined.
 #ifndef FMT_CPP_LIB_FILESYSTEM
 #  ifdef __cpp_lib_filesystem
@@ -117,7 +114,7 @@ void write_escaped_path(basic_memory_buffer<Char>& quoted,
 FMT_EXPORT
 template <typename Char> struct formatter<std::filesystem::path, Char> {
  private:
-  format_specs<Char> specs_;
+  format_specs specs_;
   detail::arg_ref<Char> width_ref_;
   bool debug_ = false;
   char path_type_ = 0;
@@ -137,18 +134,16 @@ template <typename Char> struct formatter<std::filesystem::path, Char> {
       debug_ = true;
       ++it;
     }
-    if (it != end && (*it == 'g')) path_type_ = *it++;
+    if (it != end && (*it == 'g')) path_type_ = detail::to_ascii(*it++);
     return it;
   }
 
   template <typename FormatContext>
   auto format(const std::filesystem::path& p, FormatContext& ctx) const {
     auto specs = specs_;
-#  ifdef _WIN32
-    auto path_string = !path_type_ ? p.native() : p.generic_wstring();
-#  else
-    auto path_string = !path_type_ ? p.native() : p.generic_string();
-#  endif
+    auto path_string =
+        !path_type_ ? p.native()
+                    : p.generic_string<std::filesystem::path::value_type>();
 
     detail::handle_dynamic_spec<detail::width_checker>(specs.width, width_ref_,
                                                        ctx);
@@ -163,6 +158,22 @@ template <typename Char> struct formatter<std::filesystem::path, Char> {
                          specs);
   }
 };
+
+class path : public std::filesystem::path {
+ public:
+  auto display_string() const -> std::string {
+    const std::filesystem::path& base = *this;
+    return fmt::format(FMT_STRING("{}"), base);
+  }
+  auto system_string() const -> std::string { return string(); }
+
+  auto generic_display_string() const -> std::string {
+    const std::filesystem::path& base = *this;
+    return fmt::format(FMT_STRING("{:g}"), base);
+  }
+  auto generic_system_string() const -> std::string { return generic_string(); }
+};
+
 FMT_END_NAMESPACE
 #endif  // FMT_CPP_LIB_FILESYSTEM
 
@@ -242,6 +253,56 @@ struct formatter<std::optional<T>, Char,
 FMT_END_NAMESPACE
 #endif  // __cpp_lib_optional
 
+#if defined(__cpp_lib_expected) || FMT_CPP_LIB_VARIANT
+
+FMT_BEGIN_NAMESPACE
+namespace detail {
+
+template <typename Char, typename OutputIt, typename T>
+auto write_escaped_alternative(OutputIt out, const T& v) -> OutputIt {
+  if constexpr (has_to_string_view<T>::value)
+    return write_escaped_string<Char>(out, detail::to_string_view(v));
+  if constexpr (std::is_same_v<T, Char>) return write_escaped_char(out, v);
+  return write<Char>(out, v);
+}
+
+}  // namespace detail
+
+FMT_END_NAMESPACE
+#endif
+
+#ifdef __cpp_lib_expected
+FMT_BEGIN_NAMESPACE
+
+FMT_EXPORT
+template <typename T, typename E, typename Char>
+struct formatter<std::expected<T, E>, Char,
+                 std::enable_if_t<is_formattable<T, Char>::value &&
+                                  is_formattable<E, Char>::value>> {
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  template <typename FormatContext>
+  auto format(const std::expected<T, E>& value, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    auto out = ctx.out();
+
+    if (value.has_value()) {
+      out = detail::write<Char>(out, "expected(");
+      out = detail::write_escaped_alternative<Char>(out, *value);
+    } else {
+      out = detail::write<Char>(out, "unexpected(");
+      out = detail::write_escaped_alternative<Char>(out, value.error());
+    }
+    *out++ = ')';
+    return out;
+  }
+};
+FMT_END_NAMESPACE
+#endif  // __cpp_lib_expected
+
 #ifdef __cpp_lib_source_location
 FMT_BEGIN_NAMESPACE
 FMT_EXPORT
@@ -291,16 +352,6 @@ template <typename T, typename C> class is_variant_formattable_ {
       decltype(check(variant_index_sequence<T>{}))::value;
 };
 
-template <typename Char, typename OutputIt, typename T>
-auto write_variant_alternative(OutputIt out, const T& v) -> OutputIt {
-  if constexpr (is_string<T>::value)
-    return write_escaped_string<Char>(out, detail::to_string_view(v));
-  else if constexpr (std::is_same_v<T, Char>)
-    return write_escaped_char(out, v);
-  else
-    return write<Char>(out, v);
-}
-
 }  // namespace detail
 
 template <typename T> struct is_variant_like {
@@ -346,7 +397,7 @@ struct formatter<
     FMT_TRY {
       std::visit(
           [&](const auto& v) {
-            out = detail::write_variant_alternative<Char>(out, v);
+            out = detail::write_escaped_alternative<Char>(out, v);
           },
           value);
     }
@@ -372,13 +423,102 @@ template <typename Char> struct formatter<std::error_code, Char> {
   FMT_CONSTEXPR auto format(const std::error_code& ec, FormatContext& ctx) const
       -> decltype(ctx.out()) {
     auto out = ctx.out();
-    out = detail::write_bytes(out, ec.category().name(), format_specs<Char>());
+    out = detail::write_bytes<Char>(out, ec.category().name(), format_specs());
     out = detail::write<Char>(out, Char(':'));
     out = detail::write<Char>(out, ec.value());
     return out;
   }
 };
 
+#if FMT_USE_RTTI
+namespace detail {
+
+template <typename Char, typename OutputIt>
+auto write_demangled_name(OutputIt out, const std::type_info& ti) -> OutputIt {
+#  ifdef FMT_HAS_ABI_CXA_DEMANGLE
+  int status = 0;
+  std::size_t size = 0;
+  std::unique_ptr<char, void (*)(void*)> demangled_name_ptr(
+      abi::__cxa_demangle(ti.name(), nullptr, &size, &status), &std::free);
+
+  string_view demangled_name_view;
+  if (demangled_name_ptr) {
+    demangled_name_view = demangled_name_ptr.get();
+
+    // Normalization of stdlib inline namespace names.
+    // libc++ inline namespaces.
+    //  std::__1::*       -> std::*
+    //  std::__1::__fs::* -> std::*
+    // libstdc++ inline namespaces.
+    //  std::__cxx11::*             -> std::*
+    //  std::filesystem::__cxx11::* -> std::filesystem::*
+    if (demangled_name_view.starts_with("std::")) {
+      char* begin = demangled_name_ptr.get();
+      char* to = begin + 5;  // std::
+      for (char *from = to, *end = begin + demangled_name_view.size();
+           from < end;) {
+        // This is safe, because demangled_name is NUL-terminated.
+        if (from[0] == '_' && from[1] == '_') {
+          char* next = from + 1;
+          while (next < end && *next != ':') next++;
+          if (next[0] == ':' && next[1] == ':') {
+            from = next + 2;
+            continue;
+          }
+        }
+        *to++ = *from++;
+      }
+      demangled_name_view = {begin, detail::to_unsigned(to - begin)};
+    }
+  } else {
+    demangled_name_view = string_view(ti.name());
+  }
+  return detail::write_bytes<Char>(out, demangled_name_view);
+#  elif FMT_MSC_VERSION
+  const string_view demangled_name(ti.name());
+  for (std::size_t i = 0; i < demangled_name.size(); ++i) {
+    auto sub = demangled_name;
+    sub.remove_prefix(i);
+    if (sub.starts_with("enum ")) {
+      i += 4;
+      continue;
+    }
+    if (sub.starts_with("class ") || sub.starts_with("union ")) {
+      i += 5;
+      continue;
+    }
+    if (sub.starts_with("struct ")) {
+      i += 6;
+      continue;
+    }
+    if (*sub.begin() != ' ') *out++ = *sub.begin();
+  }
+  return out;
+#  else
+  return detail::write_bytes<Char>(out, string_view(ti.name()));
+#  endif
+}
+
+}  // namespace detail
+
+FMT_EXPORT
+template <typename Char>
+struct formatter<std::type_info, Char  // DEPRECATED! Mixing code unit types.
+                 > {
+ public:
+  FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
+      -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  template <typename Context>
+  auto format(const std::type_info& ti, Context& ctx) const
+      -> decltype(ctx.out()) {
+    return detail::write_demangled_name<Char>(ctx.out(), ti);
+  }
+};
+#endif
+
 FMT_EXPORT
 template <typename T, typename Char>
 struct formatter<
@@ -395,74 +535,23 @@ struct formatter<
     if (it == end || *it == '}') return it;
     if (*it == 't') {
       ++it;
-      with_typename_ = FMT_USE_TYPEID != 0;
+      with_typename_ = FMT_USE_RTTI != 0;
     }
     return it;
   }
 
-  template <typename OutputIt>
-  auto format(const std::exception& ex,
-              basic_format_context<OutputIt, Char>& ctx) const -> OutputIt {
-    format_specs<Char> spec;
+  template <typename Context>
+  auto format(const std::exception& ex, Context& ctx) const
+      -> decltype(ctx.out()) {
     auto out = ctx.out();
-    if (!with_typename_)
-      return detail::write_bytes(out, string_view(ex.what()), spec);
-
-#if FMT_USE_TYPEID
-    const std::type_info& ti = typeid(ex);
-#  ifdef FMT_HAS_ABI_CXA_DEMANGLE
-    int status = 0;
-    std::size_t size = 0;
-    std::unique_ptr<char, void (*)(void*)> demangled_name_ptr(
-        abi::__cxa_demangle(ti.name(), nullptr, &size, &status), &std::free);
-
-    string_view demangled_name_view;
-    if (demangled_name_ptr) {
-      demangled_name_view = demangled_name_ptr.get();
-
-      // Normalization of stdlib inline namespace names.
-      // libc++ inline namespaces.
-      //  std::__1::*       -> std::*
-      //  std::__1::__fs::* -> std::*
-      // libstdc++ inline namespaces.
-      //  std::__cxx11::*             -> std::*
-      //  std::filesystem::__cxx11::* -> std::filesystem::*
-      if (demangled_name_view.starts_with("std::")) {
-        char* begin = demangled_name_ptr.get();
-        char* to = begin + 5;  // std::
-        for (char *from = to, *end = begin + demangled_name_view.size();
-             from < end;) {
-          // This is safe, because demangled_name is NUL-terminated.
-          if (from[0] == '_' && from[1] == '_') {
-            char* next = from + 1;
-            while (next < end && *next != ':') next++;
-            if (next[0] == ':' && next[1] == ':') {
-              from = next + 2;
-              continue;
-            }
-          }
-          *to++ = *from++;
-        }
-        demangled_name_view = {begin, detail::to_unsigned(to - begin)};
-      }
-    } else {
-      demangled_name_view = string_view(ti.name());
+#if FMT_USE_RTTI
+    if (with_typename_) {
+      out = detail::write_demangled_name<Char>(out, typeid(ex));
+      *out++ = ':';
+      *out++ = ' ';
     }
-    out = detail::write_bytes(out, demangled_name_view, spec);
-#  elif FMT_MSC_VERSION
-    string_view demangled_name_view(ti.name());
-    if (demangled_name_view.starts_with("class "))
-      demangled_name_view.remove_prefix(6);
-    else if (demangled_name_view.starts_with("struct "))
-      demangled_name_view.remove_prefix(7);
-    out = detail::write_bytes(out, demangled_name_view, spec);
-#  else
-    out = detail::write_bytes(out, string_view(ti.name()), spec);
-#  endif
-    *out++ = ':';
-    *out++ = ' ';
-    return detail::write_bytes(out, string_view(ex.what()), spec);
 #endif
+    return detail::write_bytes<Char>(out, string_view(ex.what()));
   }
 };
 
@@ -509,6 +598,14 @@ struct formatter<BitRef, Char,
   }
 };
 
+template <typename T, typename Deleter>
+auto ptr(const std::unique_ptr<T, Deleter>& p) -> const void* {
+  return p.get();
+}
+template <typename T> auto ptr(const std::shared_ptr<T>& p) -> const void* {
+  return p.get();
+}
+
 FMT_EXPORT
 template <typename T, typename Char>
 struct formatter<std::atomic<T>, Char,
@@ -533,5 +630,70 @@ struct formatter<std::atomic_flag, Char> : formatter<bool, Char> {
 };
 #endif  // __cpp_lib_atomic_flag_test
 
+FMT_EXPORT
+template <typename T, typename Char> struct formatter<std::complex<T>, Char> {
+ private:
+  detail::dynamic_format_specs<Char> specs_;
+
+  template <typename FormatContext, typename OutputIt>
+  FMT_CONSTEXPR auto do_format(const std::complex<T>& c,
+                               detail::dynamic_format_specs<Char>& specs,
+                               FormatContext& ctx, OutputIt out) const
+      -> OutputIt {
+    if (c.real() != 0) {
+      *out++ = Char('(');
+      out = detail::write<Char>(out, c.real(), specs, ctx.locale());
+      specs.sign = sign::plus;
+      out = detail::write<Char>(out, c.imag(), specs, ctx.locale());
+      if (!detail::isfinite(c.imag())) *out++ = Char(' ');
+      *out++ = Char('i');
+      *out++ = Char(')');
+      return out;
+    }
+    out = detail::write<Char>(out, c.imag(), specs, ctx.locale());
+    if (!detail::isfinite(c.imag())) *out++ = Char(' ');
+    *out++ = Char('i');
+    return out;
+  }
+
+ public:
+  FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
+      -> decltype(ctx.begin()) {
+    if (ctx.begin() == ctx.end() || *ctx.begin() == '}') return ctx.begin();
+    return parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx,
+                              detail::type_constant<T, Char>::value);
+  }
+
+  template <typename FormatContext>
+  auto format(const std::complex<T>& c, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    auto specs = specs_;
+    if (specs.width_ref.kind != detail::arg_id_kind::none ||
+        specs.precision_ref.kind != detail::arg_id_kind::none) {
+      detail::handle_dynamic_spec<detail::width_checker>(specs.width,
+                                                         specs.width_ref, ctx);
+      detail::handle_dynamic_spec<detail::precision_checker>(
+          specs.precision, specs.precision_ref, ctx);
+    }
+
+    if (specs.width == 0) return do_format(c, specs, ctx, ctx.out());
+    auto buf = basic_memory_buffer<Char>();
+
+    auto outer_specs = format_specs();
+    outer_specs.width = specs.width;
+    outer_specs.fill = specs.fill;
+    outer_specs.align = specs.align;
+
+    specs.width = 0;
+    specs.fill = {};
+    specs.align = align::none;
+
+    do_format(c, specs, ctx, basic_appender<Char>(buf));
+    return detail::write<Char>(ctx.out(),
+                               basic_string_view<Char>(buf.data(), buf.size()),
+                               outer_specs);
+  }
+};
+
 FMT_END_NAMESPACE
 #endif  // FMT_STD_H_
diff --git a/thirdparty/fmt/xchar.h b/thirdparty/fmt/xchar.h
index f609c5c41..b1f39ed22 100644
--- a/thirdparty/fmt/xchar.h
+++ b/thirdparty/fmt/xchar.h
@@ -8,12 +8,15 @@
 #ifndef FMT_XCHAR_H_
 #define FMT_XCHAR_H_
 
-#include <cwchar>
-
+#include "color.h"
 #include "format.h"
+#include "ranges.h"
 
-#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
-#  include <locale>
+#ifndef FMT_MODULE
+#  include <cwchar>
+#  if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
+#    include <locale>
+#  endif
 #endif
 
 FMT_BEGIN_NAMESPACE
@@ -22,9 +25,24 @@ namespace detail {
 template <typename T>
 using is_exotic_char = bool_constant<!std::is_same<T, char>::value>;
 
-inline auto write_loc(std::back_insert_iterator<detail::buffer<wchar_t>> out,
-                      loc_value value, const format_specs<wchar_t>& specs,
-                      locale_ref loc) -> bool {
+template <typename S, typename = void> struct format_string_char {};
+
+template <typename S>
+struct format_string_char<
+    S, void_t<decltype(sizeof(detail::to_string_view(std::declval<S>())))>> {
+  using type = char_t<S>;
+};
+
+template <typename S>
+struct format_string_char<S, enable_if_t<is_compile_string<S>::value>> {
+  using type = typename S::char_type;
+};
+
+template <typename S>
+using format_string_char_t = typename format_string_char<S>::type;
+
+inline auto write_loc(basic_appender<wchar_t> out, loc_value value,
+                      const format_specs& specs, locale_ref loc) -> bool {
 #ifndef FMT_STATIC_THOUSANDS_SEPARATOR
   auto& numpunct =
       std::use_facet<std::numpunct<wchar_t>>(loc.get<std::locale>());
@@ -41,7 +59,7 @@ FMT_BEGIN_EXPORT
 
 using wstring_view = basic_string_view<wchar_t>;
 using wformat_parse_context = basic_format_parse_context<wchar_t>;
-using wformat_context = buffer_context<wchar_t>;
+using wformat_context = buffered_context<wchar_t>;
 using wformat_args = basic_format_args<wformat_context>;
 using wmemory_buffer = basic_memory_buffer<wchar_t>;
 
@@ -58,14 +76,18 @@ inline auto runtime(wstring_view s) -> runtime_format_string<wchar_t> {
 #endif
 
 template <> struct is_char<wchar_t> : std::true_type {};
-template <> struct is_char<detail::char8_type> : std::true_type {};
 template <> struct is_char<char16_t> : std::true_type {};
 template <> struct is_char<char32_t> : std::true_type {};
 
+#ifdef __cpp_char8_t
+template <>
+struct is_char<char8_t> : bool_constant<detail::is_utf8_enabled()> {};
+#endif
+
 template <typename... T>
-constexpr auto make_wformat_args(const T&... args)
-    -> format_arg_store<wformat_context, T...> {
-  return {args...};
+constexpr auto make_wformat_args(T&... args)
+    -> decltype(fmt::make_format_args<wformat_context>(args...)) {
+  return fmt::make_format_args<wformat_context>(args...);
 }
 
 inline namespace literals {
@@ -96,9 +118,15 @@ auto join(std::initializer_list<T> list, wstring_view sep)
   return join(std::begin(list), std::end(list), sep);
 }
 
+template <typename... T>
+auto join(const std::tuple<T...>& tuple, basic_string_view<wchar_t> sep)
+    -> tuple_join_view<wchar_t, T...> {
+  return {tuple, sep};
+}
+
 template <typename Char, FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
 auto vformat(basic_string_view<Char> format_str,
-             basic_format_args<buffer_context<type_identity_t<Char>>> args)
+             typename detail::vformat_args<Char>::type args)
     -> std::basic_string<Char> {
   auto buf = basic_memory_buffer<Char>();
   detail::vformat_to(buf, format_str, args);
@@ -110,63 +138,74 @@ auto format(wformat_string<T...> fmt, T&&... args) -> std::wstring {
   return vformat(fmt::wstring_view(fmt), fmt::make_wformat_args(args...));
 }
 
+template <typename OutputIt, typename... T>
+auto format_to(OutputIt out, wformat_string<T...> fmt, T&&... args)
+    -> OutputIt {
+  return vformat_to(out, fmt::wstring_view(fmt),
+                    fmt::make_wformat_args(args...));
+}
+
 // Pass char_t as a default template parameter instead of using
 // std::basic_string<char_t<S>> to reduce the symbol size.
-template <typename S, typename... T, typename Char = char_t<S>,
+template <typename S, typename... T,
+          typename Char = detail::format_string_char_t<S>,
           FMT_ENABLE_IF(!std::is_same<Char, char>::value &&
                         !std::is_same<Char, wchar_t>::value)>
 auto format(const S& format_str, T&&... args) -> std::basic_string<Char> {
   return vformat(detail::to_string_view(format_str),
-                 fmt::make_format_args<buffer_context<Char>>(args...));
+                 fmt::make_format_args<buffered_context<Char>>(args...));
 }
 
-template <typename Locale, typename S, typename Char = char_t<S>,
+template <typename Locale, typename S,
+          typename Char = detail::format_string_char_t<S>,
           FMT_ENABLE_IF(detail::is_locale<Locale>::value&&
                             detail::is_exotic_char<Char>::value)>
-inline auto vformat(
-    const Locale& loc, const S& format_str,
-    basic_format_args<buffer_context<type_identity_t<Char>>> args)
+inline auto vformat(const Locale& loc, const S& format_str,
+                    typename detail::vformat_args<Char>::type args)
     -> std::basic_string<Char> {
   return detail::vformat(loc, detail::to_string_view(format_str), args);
 }
 
-template <typename Locale, typename S, typename... T, typename Char = char_t<S>,
+template <typename Locale, typename S, typename... T,
+          typename Char = detail::format_string_char_t<S>,
           FMT_ENABLE_IF(detail::is_locale<Locale>::value&&
                             detail::is_exotic_char<Char>::value)>
 inline auto format(const Locale& loc, const S& format_str, T&&... args)
     -> std::basic_string<Char> {
-  return detail::vformat(loc, detail::to_string_view(format_str),
-                         fmt::make_format_args<buffer_context<Char>>(args...));
+  return detail::vformat(
+      loc, detail::to_string_view(format_str),
+      fmt::make_format_args<buffered_context<Char>>(args...));
 }
 
-template <typename OutputIt, typename S, typename Char = char_t<S>,
+template <typename OutputIt, typename S,
+          typename Char = detail::format_string_char_t<S>,
           FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
                             detail::is_exotic_char<Char>::value)>
 auto vformat_to(OutputIt out, const S& format_str,
-                basic_format_args<buffer_context<type_identity_t<Char>>> args)
-    -> OutputIt {
+                typename detail::vformat_args<Char>::type args) -> OutputIt {
   auto&& buf = detail::get_buffer<Char>(out);
   detail::vformat_to(buf, detail::to_string_view(format_str), args);
   return detail::get_iterator(buf, out);
 }
 
 template <typename OutputIt, typename S, typename... T,
-          typename Char = char_t<S>,
-          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
-                            detail::is_exotic_char<Char>::value)>
+          typename Char = detail::format_string_char_t<S>,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value &&
+                        !std::is_same<Char, char>::value &&
+                        !std::is_same<Char, wchar_t>::value)>
 inline auto format_to(OutputIt out, const S& fmt, T&&... args) -> OutputIt {
   return vformat_to(out, detail::to_string_view(fmt),
-                    fmt::make_format_args<buffer_context<Char>>(args...));
+                    fmt::make_format_args<buffered_context<Char>>(args...));
 }
 
 template <typename Locale, typename S, typename OutputIt, typename... Args,
-          typename Char = char_t<S>,
+          typename Char = detail::format_string_char_t<S>,
           FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
                             detail::is_locale<Locale>::value&&
                                 detail::is_exotic_char<Char>::value)>
-inline auto vformat_to(
-    OutputIt out, const Locale& loc, const S& format_str,
-    basic_format_args<buffer_context<type_identity_t<Char>>> args) -> OutputIt {
+inline auto vformat_to(OutputIt out, const Locale& loc, const S& format_str,
+                       typename detail::vformat_args<Char>::type args)
+    -> OutputIt {
   auto&& buf = detail::get_buffer<Char>(out);
   vformat_to(buf, detail::to_string_view(format_str), args,
              detail::locale_ref(loc));
@@ -174,7 +213,7 @@ inline auto vformat_to(
 }
 
 template <typename OutputIt, typename Locale, typename S, typename... T,
-          typename Char = char_t<S>,
+          typename Char = detail::format_string_char_t<S>,
           bool enable = detail::is_output_iterator<OutputIt, Char>::value &&
                         detail::is_locale<Locale>::value &&
                         detail::is_exotic_char<Char>::value>
@@ -182,15 +221,15 @@ inline auto format_to(OutputIt out, const Locale& loc, const S& format_str,
                       T&&... args) ->
     typename std::enable_if<enable, OutputIt>::type {
   return vformat_to(out, loc, detail::to_string_view(format_str),
-                    fmt::make_format_args<buffer_context<Char>>(args...));
+                    fmt::make_format_args<buffered_context<Char>>(args...));
 }
 
 template <typename OutputIt, typename Char, typename... Args,
           FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
                             detail::is_exotic_char<Char>::value)>
-inline auto vformat_to_n(
-    OutputIt out, size_t n, basic_string_view<Char> format_str,
-    basic_format_args<buffer_context<type_identity_t<Char>>> args)
+inline auto vformat_to_n(OutputIt out, size_t n,
+                         basic_string_view<Char> format_str,
+                         typename detail::vformat_args<Char>::type args)
     -> format_to_n_result<OutputIt> {
   using traits = detail::fixed_buffer_traits;
   auto buf = detail::iterator_buffer<OutputIt, Char, traits>(out, n);
@@ -199,21 +238,22 @@ inline auto vformat_to_n(
 }
 
 template <typename OutputIt, typename S, typename... T,
-          typename Char = char_t<S>,
+          typename Char = detail::format_string_char_t<S>,
           FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
                             detail::is_exotic_char<Char>::value)>
 inline auto format_to_n(OutputIt out, size_t n, const S& fmt, T&&... args)
     -> format_to_n_result<OutputIt> {
-  return vformat_to_n(out, n, detail::to_string_view(fmt),
-                      fmt::make_format_args<buffer_context<Char>>(args...));
+  return vformat_to_n(out, n, fmt::basic_string_view<Char>(fmt),
+                      fmt::make_format_args<buffered_context<Char>>(args...));
 }
 
-template <typename S, typename... T, typename Char = char_t<S>,
+template <typename S, typename... T,
+          typename Char = detail::format_string_char_t<S>,
           FMT_ENABLE_IF(detail::is_exotic_char<Char>::value)>
 inline auto formatted_size(const S& fmt, T&&... args) -> size_t {
   auto buf = detail::counting_buffer<Char>();
   detail::vformat_to(buf, detail::to_string_view(fmt),
-                     fmt::make_format_args<buffer_context<Char>>(args...));
+                     fmt::make_format_args<buffered_context<Char>>(args...));
   return buf.count();
 }
 
@@ -247,9 +287,32 @@ template <typename... T> void println(wformat_string<T...> fmt, T&&... args) {
   return print(L"{}\n", fmt::format(fmt, std::forward<T>(args)...));
 }
 
-/**
-  Converts *value* to ``std::wstring`` using the default format for type *T*.
- */
+inline auto vformat(const text_style& ts, wstring_view fmt, wformat_args args)
+    -> std::wstring {
+  auto buf = wmemory_buffer();
+  detail::vformat_to(buf, ts, fmt, args);
+  return fmt::to_string(buf);
+}
+
+template <typename... T>
+inline auto format(const text_style& ts, wformat_string<T...> fmt, T&&... args)
+    -> std::wstring {
+  return fmt::vformat(ts, fmt, fmt::make_wformat_args(args...));
+}
+
+template <typename... T>
+FMT_DEPRECATED void print(std::FILE* f, const text_style& ts,
+                          wformat_string<T...> fmt, const T&... args) {
+  vprint(f, ts, fmt, fmt::make_wformat_args(args...));
+}
+
+template <typename... T>
+FMT_DEPRECATED void print(const text_style& ts, wformat_string<T...> fmt,
+                          const T&... args) {
+  return print(stdout, ts, fmt, args...);
+}
+
+/// Converts `value` to `std::wstring` using the default format for type `T`.
 template <typename T> inline auto to_wstring(const T& value) -> std::wstring {
   return format(FMT_STRING(L"{}"), value);
 }

From 646ad2e8403d202ea513c1ff73e4a818418f47a0 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Fri, 6 Dec 2024 20:14:11 +0200
Subject: [PATCH 160/305] lib/utils: include fmt/xchar.h

Needed for 'join'
---
 lib/utils/mu-utils.hh | 1 +
 1 file changed, 1 insertion(+)

diff --git a/lib/utils/mu-utils.hh b/lib/utils/mu-utils.hh
index f3817f39f..4e1da9c2a 100644
--- a/lib/utils/mu-utils.hh
+++ b/lib/utils/mu-utils.hh
@@ -43,6 +43,7 @@
 #include <fmt/core.h>
 #include <fmt/chrono.h>
 #include <fmt/ostream.h>
+#include <fmt/xchar.h>
 
 namespace Mu {
 

From 0e0d4a0cb60f6ce66dd6a07084adb6a1ec72d1d0 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 7 Dec 2024 12:14:55 +0200
Subject: [PATCH 161/305] mu-sexp: add -unix output for json tstamps

The json output (for mu-find etc.) just showed the converted sexp
output, including the clumsy emacs-style tstamps (for changed/date).

Add unix timestamps as well, which are easier to work with outside
emacs.

This handles #2770.
---
 lib/utils/mu-sexp.cc | 31 ++++++++++++++++++++++++++-----
 1 file changed, 26 insertions(+), 5 deletions(-)

diff --git a/lib/utils/mu-sexp.cc b/lib/utils/mu-sexp.cc
index 47510d1b1..8434f986e 100644
--- a/lib/utils/mu-sexp.cc
+++ b/lib/utils/mu-sexp.cc
@@ -1,5 +1,5 @@
 /*
-** Copyright (C) 2022-2023 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2022-2024 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify it
 ** under the terms of the GNU General Public License as published by the
@@ -60,15 +60,18 @@ parse_list(const std::string& expr, size_t& pos)
 	Sexp lst{};
 
 	++pos;
-	while (expr[pos] != ')' && pos != expr.size()) {
+	while (pos < expr.size() && expr[pos] != ')') {
 		if (auto&& item = parse(expr, pos); item)
 			lst.add(std::move(*item));
 		else
 			return Err(item.error());
 	}
 
-	if (expr[pos] != ')')
+	if (pos >= expr.size())
+		return Err(parsing_error(pos, "expected: ')'"));
+	else if (expr[pos] != ')')
 		return Err(parsing_error(pos, "expected: ')' but got '{}'", expr[pos]));
+
 	++pos;
 	return Ok(std::move(lst));
 }
@@ -209,6 +212,17 @@ Sexp::to_string(Format fopts) const
 
 // LCOV_EXCL_START
 
+// convert emacs-timestamp (a list) to a unix-tstamp
+static uint64_t
+unix_tstamp(const Sexp& emacs_tstamp)
+{
+	if (!emacs_tstamp.listp() || emacs_tstamp.list().size() < 2)
+		throw std::runtime_error("unexpected type");
+
+	const auto& lst{emacs_tstamp.list()};
+	return (lst.at(0).number() << 16) | lst.at(1).number();
+}
+
 std::string
 Sexp::to_json_string(Format fopts) const
 {
@@ -222,11 +236,18 @@ Sexp::to_json_string(Format fopts) const
 			auto it{list().begin()};
 			bool first{true};
 			while (it != list().end()) {
-				sstrm << (first ? "" : ",")  << quote(it->symbol().name) << ":";
+				const auto key{it->symbol().name};
+				sstrm << (first ? "" : ",")  << quote(key) << ":";
 				++it;
-				sstrm << it->to_json_string();
+				const auto emacs_tstamp{*it};
+				sstrm << emacs_tstamp.to_json_string();
 				++it;
 				first = false;
+				// special-case: tstamp-fields also get a "unix" value,
+				// which are easier to work with than the "emacs" timestamps
+				if (key == ":date" || key == ":changed")
+					sstrm << "," << quote(key + "-unix") << ":"
+					      << unix_tstamp(emacs_tstamp);
 			}
 			sstrm << "}";
 			if (any_of(fopts & Format::SplitList))

From 5257ebcdf5223e7a79672fb8f9825ddd0241e92d Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 7 Dec 2024 19:40:33 +0200
Subject: [PATCH 162/305] mu4e-draft: add some logging to
 mu4e--set-parent-flags

Also a little refactoring.

This should hopefully help with diagnosing #2478.
---
 mu4e/mu4e-draft.el | 44 ++++++++++++++++++++++++++------------------
 1 file changed, 26 insertions(+), 18 deletions(-)

diff --git a/mu4e/mu4e-draft.el b/mu4e/mu4e-draft.el
index c44ccae3a..884d5d53e 100644
--- a/mu4e/mu4e-draft.el
+++ b/mu4e/mu4e-draft.el
@@ -387,26 +387,34 @@ also marked as Seen.
 
 Function assumes that it is executed in the context of the
 message buffer."
+  ;; note that we can't use mu4e-compose-parent-message here, since it
+  ;; no longer available when editing a draft. So we scan the outgoing
+  ;; message for the information.
   (when-let* ((buf (find-file-noselect path)))
     (with-current-buffer buf
-      (let ((in-reply-to (message-field-value "in-reply-to"))
-            (forwarded-from)
-            (references (message-field-value "references")))
-        (unless in-reply-to
-          (when references
-            (with-temp-buffer ;; inspired by `message-shorten-references'.
-              (insert references)
-              (goto-char (point-min))
-              (let ((refs))
-                (while (re-search-forward "<[^ <]+@[^ <]+>" nil t)
-                  (push (match-string 0) refs))
-                ;; the last will be the first
-                (setq forwarded-from (car refs))))))
-        ;; remove the <> and update the flags on the server-side.
-        (when (and in-reply-to (string-match "<\\(.*\\)>" in-reply-to))
-          (mu4e--server-move (match-string 1 in-reply-to) nil "+R-N"))
-        (when (and forwarded-from (string-match "<\\(.*\\)>" forwarded-from))
-          (mu4e--server-move (match-string 1 forwarded-from) nil "+P-N"))))))
+      (let* ((in-reply-to (message-field-value "in-reply-to"))
+             (references (message-field-value "references"))
+             (forwarded-from
+              (unless (or in-reply-to (not references))
+                (with-temp-buffer ;; inspired by `message-shorten-references'.
+                  (insert references)
+                  (goto-char (point-min))
+                  (let ((refs))
+                    (while (re-search-forward "<[^ <]+@[^ <]+>" nil t)
+                      (push (match-string 0) refs))
+                    (car refs))))) ;; the last shall be the first
+             ;; remove the <>
+             (in-reply-to (and in-reply-to (string-match "<\\(.*\\)>" in-reply-to)
+                               (match-string 1 in-reply-to)))
+             (forwarded-from (and forwarded-from (string-match "<\\(.*\\)>" forwarded-from)
+                                  (match-string 1 forwarded-from))))
+        ;; mark parents.
+        (when in-reply-to
+          (mu4e-log 'misc "mark %s as Replied" in-reply-to)
+          (mu4e--server-move in-reply-to nil "+R-N"))
+        (when forwarded-from
+          (mu4e-log 'misc "mark %s as Passed (forwarded)" forwarded-from)
+          (mu4e--server-move forwarded-from nil "+P-N"))))))
 
 (defun mu4e--compose-after-save()
   "Function called immediately after the draft buffer is saved."

From 619873215455576d515477c53210c9107a334fb5 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 7 Dec 2024 19:42:28 +0200
Subject: [PATCH 163/305] NEWS.org: update

---
 NEWS.org | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/NEWS.org b/NEWS.org
index 7657716af..8b2f1b611 100644
--- a/NEWS.org
+++ b/NEWS.org
@@ -23,6 +23,10 @@
     There's also a new combination-field ~related:~ which combines ~references:~ and
     ~msgid:~.
 
+  - The ~--format=json~ output for *mu find* now includes "unix-style" timestamps
+    for ~:date~ and ~:changed~ (~:date-unix~ and ~:changed-unix~, respectively) which
+    are a bit easier to manipulate than the emacs-style timestamps.
+
   - message composition has been completely reworked to avoid a number of
     problems user reported. It is now directly uses the Gnus machinery, but
     integrate inside mu4e.
@@ -57,7 +61,7 @@
 *** mu
 
     - new command ~mu move~ to move messages across maildirs and/or change their
-      flags. See the manpage for all the details.
+      flags. See the man-page for all the details.
 
     - ~mu~ commands ~extract~ ~verify~ and ~view~ can now read the message from
       standard input; see their man-pages for details

From dee7e5951c500053b6fed206fde14c391dab7236 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Mon, 9 Dec 2024 19:41:58 +0200
Subject: [PATCH 164/305] utils-file: add unit-test for expand_file

---
 lib/utils/mu-utils-file.cc | 41 ++++++++++++++++++++------------------
 1 file changed, 22 insertions(+), 19 deletions(-)

diff --git a/lib/utils/mu-utils-file.cc b/lib/utils/mu-utils-file.cc
index 3daea34a3..bd581026a 100644
--- a/lib/utils/mu-utils-file.cc
+++ b/lib/utils/mu-utils-file.cc
@@ -351,7 +351,6 @@ Mu::play (const std::string& path)
 }
 /* LCOV_EXCL_STOP*/
 
-
 Result<std::string>
 expand_path_real(const std::string& str)
 {
@@ -366,7 +365,8 @@ expand_path_real(const std::string& str)
 		return Err(Error::Code::File, "cannot expand {}; err={}", str, res);
 	else if (auto&n = result.we_wordc; n != 1) {
 		wordfree(&result);
-		return Err(Error::Code::File, "expected 1 expansions, but got {} for {}", n, str);
+		return Err(Error::Code::File,
+			   "expected 1 expansion, but got {} for '{}'", n, str);
 	}
 
 	std::string expanded{result.we_wordv[0]};
@@ -488,8 +488,17 @@ test_runtime_paths()
 	assert_equal(runtime_path(RuntimePath::Bookmarks, tdir.path()),
 		     join_paths(tdir.path(), "bookmarks"));
 	assert_equal(runtime_path(RuntimePath::Config, tdir.path()), tdir.path());
-	assert_equal(runtime_path(RuntimePath::Scripts, tdir.path()),
-		     join_paths(tdir.path(), "scripts"));
+	assert_equal(runtime_path(RuntimePath::Scripts, tdir.path()),join_paths(tdir.path(), "scripts"));
+}
+
+
+static void
+test_expand_path()
+{
+	g_assert_true(!!g_get_home_dir());
+	const std::string homedir{g_get_home_dir()};
+
+	assert_equal(join_paths(homedir, "boo"), expand_path("~/boo").value());
 }
 
 int
@@ -498,22 +507,16 @@ main(int argc, char* argv[])
 	mu_test_init(&argc, &argv);
 
 	/* check_dir */
-	g_test_add_func("/utils/check-dir-01",
-			test_check_dir_01);
-	g_test_add_func("/utils/check-dir-02",
-			test_check_dir_02);
-	g_test_add_func("/utils/check-dir-03",
-			test_check_dir_03);
-	g_test_add_func("/utils/check-dir-04",
-			test_check_dir_04);
-	g_test_add_func("/utils/determine-dtype-with-lstat",
+	g_test_add_func("/utils/file/check-dir-01", test_check_dir_01);
+	g_test_add_func("/utils/file/check-dir-02", test_check_dir_02);
+	g_test_add_func("/utils/file/check-dir-03", test_check_dir_03);
+	g_test_add_func("/utils/file/check-dir-04", test_check_dir_04);
+	g_test_add_func("/utils/file/determine-dtype-with-lstat",
 			test_determine_dtype_with_lstat);
-	g_test_add_func("/utils/program-in-path",
-			test_program_in_path);
-	g_test_add_func("/utils/join-paths",
-			test_join_paths);
-	g_test_add_func("/utils/runtime-paths",
-			test_runtime_paths);
+	g_test_add_func("/utils/file/program-in-path", test_program_in_path);
+	g_test_add_func("/utils/file/join-paths", test_join_paths);
+	g_test_add_func("/utils/file/runtime-paths", test_runtime_paths);
+	g_test_add_func("/utils/file/expand-path", test_expand_path);
 
 	return g_test_run();
 }

From d8d5e4cca54891e46eef124f3b559e2a878ce74a Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Mon, 9 Dec 2024 20:02:40 +0200
Subject: [PATCH 165/305] options: do not canonicalize maildir-path

This doesn't play well with shells that don't expand options (such as
bash) in combination with "ExpandPath".

Fixes #2793.
---
 mu/mu-options.cc | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/mu/mu-options.cc b/mu/mu-options.cc
index d01c824e2..40a8c12a9 100644
--- a/mu/mu-options.cc
+++ b/mu/mu-options.cc
@@ -456,11 +456,12 @@ sub_init(CLI::App& sub, Options& opts)
 			return {};
 	});
 
-	sub.add_option("--maildir,-m", opts.init.maildir, "Top of the maildir")
+	sub.add_option("--maildir,-m", opts.init.maildir, "Root maildir")
 		->type_name("<maildir>")
 		->default_val(default_mdir)
-		->transform(ExpandPath, "expand maildir path")
-		->transform(CanonicalizePath, "canonicalize maildir path");
+		->transform(ExpandPath, "expand maildir path");
+	// don't attempt to canonicalize; in bash this breaks together with
+	// expand path.
 	sub.add_option("--my-address", opts.init.my_addresses,
 		       "Personal e-mail address or regexp")
 		->type_name("<address>");
@@ -513,7 +514,6 @@ sub_move(CLI::App& sub, Options& opts)
 	sub.add_option("source", opts.move.src, "Message file to move")
 		->type_name("<message-path>")
 		->transform(ExpandPath, "expand source path")
-		->transform(CanonicalizePath, "canonicalize source path")
 		->required();
 	sub.add_option("destination", opts.move.dest,
 		       "Destination maildir")

From 18fe56a742981a1ed7c2df3a723e6bb41fde73a4 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Mon, 9 Dec 2024 20:39:27 +0200
Subject: [PATCH 166/305] mu4e-view: cosmetics

---
 mu4e/mu4e-view.el | 14 ++++----------
 1 file changed, 4 insertions(+), 10 deletions(-)

diff --git a/mu4e/mu4e-view.el b/mu4e/mu4e-view.el
index 4f719d3ad..e366b672c 100644
--- a/mu4e/mu4e-view.el
+++ b/mu4e/mu4e-view.el
@@ -183,11 +183,9 @@ previous header."
    (mu4e~headers-move (- (or n 1)))))
 
 (defun mu4e--view-prev-or-next (func backwards)
-  "Move point to the next or previous message.
-Go to the previous message if BACKWARDS is non-nil.
-unread message header in the headers buffer connected with this
-message view. If this succeeds, return the new docid. Otherwise,
-return nil."
+  "Move point to the next or previous message and invoke FUNC.
+Go to the previous message if BACKWARDS is non-nil. If this
+succeeds, return the new docid. Otherwise, return nil."
   (mu4e--view-in-headers-context (funcall func backwards))
   (mu4e-select-other-view)
   (mu4e-headers-view-message))
@@ -231,7 +229,6 @@ If this succeeds, return the new docid. Otherwise, return nil."
   (interactive)
   (mu4e--view-in-headers-context (mu4e-thread-fold-toggle-all)))
 
-
 ;;; Interactive functions
 (defun mu4e-view-action (&optional msg)
   "Ask user for some action to apply on MSG, then do it.
@@ -1018,7 +1015,7 @@ This is useful for advising some Gnus-functionality that does not work in mu4e."
   "Keymap for mu4e-view mode.")
 
 (easy-menu-define mu4e-view-mode-menu
-  mu4e-view-mode-map "Menu for mu4e's view-mode."
+  mu4e-view-mode-map "Menu for mu4e's view mode."
   (append
    '("View"
      "--"
@@ -1109,7 +1106,6 @@ Article Treatment' for more options."
   (interactive)
   (funcall (mu4e-read-option "Massage: " mu4e-view-massage-options)))
 
-
 (defun mu4e-view-toggle-html ()
   "Toggle html-display of the first html-part found."
   (interactive)
@@ -1128,7 +1124,6 @@ Article Treatment' for more options."
                         gnus-article-mime-handle-alist)))
         (gnus-article-inline-part (car html-part))
       (mu4e-warn "Cannot switch; no html and/or text part in this message"))))
-
 ;;; Bug Reference mode support
 
 ;; Due to mu4e's view buffer handling (mu4e-view-mode is called long before the
@@ -1169,6 +1164,5 @@ GROUP-REGEXP and each header value against HEADER-REGEXP in
   (add-hook 'bug-reference-auto-setup-functions
             #'mu4e--view-try-setup-bug-reference-mode))
 
-
 (provide 'mu4e-view)
 ;;; mu4e-view.el ends here

From 1e940c81e8f1385a1189f93a63672fe497a71249 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Mon, 9 Dec 2024 21:02:33 +0200
Subject: [PATCH 167/305] mu4e-view: add mu4e-view-jump-to-mime-part

This allows for jumping to the MIME-part by number; a thin wrapper over
the Gnus functionality.
---
 mu4e/mu4e-view.el | 6 ++++++
 mu4e/mu4e.texi    | 5 +++++
 2 files changed, 11 insertions(+)

diff --git a/mu4e/mu4e-view.el b/mu4e/mu4e-view.el
index e366b672c..3c7220c93 100644
--- a/mu4e/mu4e-view.el
+++ b/mu4e/mu4e-view.el
@@ -853,6 +853,11 @@ Note that for some messages, this can trigger high CPU load."
         (list handle attendee))
   handle-attendee))
 
+(defun mu4e-view-jump-to-mime-part (number)
+  "Jump to MIME-part with NUMBER."
+  (interactive "P")
+  (call-interactively #'gnus-article-jump-to-part number))
+
 (defun mu4e--view-mode-p ()
   "Is the buffer in mu4e-view-mode or one of its descendants?"
   (or (eq major-mode 'mu4e-view-mode)
@@ -925,6 +930,7 @@ This is useful for advising some Gnus-functionality that does not work in mu4e."
     (define-key map "a" #'mu4e-view-action)
     (define-key map "A" #'mu4e-view-mime-part-action)
     (define-key map "e" #'mu4e-view-save-attachments)
+    (define-key map "J" #'mu4e-view-jump-to-mime-part)
 
     ;; change the number of headers
     (define-key map (kbd "C-+") #'mu4e-headers-split-view-grow)
diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index 9d92e83be..781dbdf37 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -1420,6 +1420,7 @@ e            extract (save) one or more attachments (asks for numbers)
 (or: <mouse-2> or S-RET with point on attachment)
 a            execute some custom action on the message
 A            execute some custom action on the message's MIME-parts
+J            jump to MIME part by its number
 
 misc
 ----
@@ -1475,6 +1476,10 @@ even clearer by indicating them in the message itself, using:
 (setq gnus-unbuttonized-mime-types nil)
 @end lisp
 
+Note that you can jump to the relevant MIME-parts using
+@code{mu4e-view-jump-to-mime-part}, which ask for the number or uses the
+prefix-argument.
+
 @subsection Inline images
 When you run Emacs in graphical mode, by default images attached to
 messages are shown inline in the message view buffer.

From 3accb5f2f568ab62b9f1986cd71ee42b440e380f Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Mon, 9 Dec 2024 21:54:57 +0200
Subject: [PATCH 168/305] NEWS.org: improve

---
 NEWS.org | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/NEWS.org b/NEWS.org
index 8b2f1b611..9c6d201af 100644
--- a/NEWS.org
+++ b/NEWS.org
@@ -28,8 +28,8 @@
     are a bit easier to manipulate than the emacs-style timestamps.
 
   - message composition has been completely reworked to avoid a number of
-    problems user reported. It is now directly uses the Gnus machinery, but
-    integrate inside mu4e.
+    problems that users reported. It is now directly uses the Gnus machinery,
+    integrated with mu4e.
 
   - with 1.12.7, ~mu~ indexing is single-threaded again, to avoid cases of
     database-corruption. In *mu4e* that means you need to _wait_ until indexing is

From 884b3e03c9cb522ffc614f7d334e6c1263614474 Mon Sep 17 00:00:00 2001
From: Hong Xu <hong@topbug.net>
Date: Tue, 10 Dec 2024 20:08:43 -0800
Subject: [PATCH 169/305] Fix a potentially misnamed function

`(add-hook 'mu4e-thread-mode-hook #'mu4e-thread-fold-apply-all)` doesn't
seem to fold threads. Did you mean `(add-hook 'mu4e-thread-mode-hook #'mu4e-thread-fold-all)`?
---
 mu4e/mu4e.texi | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index 781dbdf37..5c32bdf95 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -1130,7 +1130,7 @@ conflicting key bindings.
 
 If you want to automatically fold all threads after a query, you can use a hook:
 @lisp
-  (add-hook 'mu4e-thread-mode-hook #'mu4e-thread-fold-apply-all)
+  (add-hook 'mu4e-thread-mode-hook #'mu4e-thread-fold-all)
 @end lisp
 
 By default, single-child threads are @emph{not} collapsed, since it would result

From bd6a862f209cfa42ac160aa720f5da79e0c5c5c7 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Thu, 12 Dec 2024 23:16:37 +0200
Subject: [PATCH 170/305] mu4e: add mu4e-trash-without-flag

Allow trashing with adding the T flag.
---
 mu4e/mu4e-mark.el | 15 ++++++++++++++-
 mu4e/mu4e.texi    | 39 +++++++++++++++++++++++++--------------
 2 files changed, 39 insertions(+), 15 deletions(-)

diff --git a/mu4e/mu4e-mark.el b/mu4e/mu4e-mark.el
index aa4271cf3..411cd1464 100644
--- a/mu4e/mu4e-mark.el
+++ b/mu4e/mu4e-mark.el
@@ -68,6 +68,18 @@ of message, showing the target makes this quite a bit
 slower (showing the target uses Emacs overlays, which can be slow
 when overused).")
 
+(defvar mu4e-trash-without-flag nil
+  "Non-nil means avoid adding the Maildir T flag when trashing.
+
+When \"trashing\" a message, it is moved to the \"trash\"-folder.
+Furthermore, as per the Maildir-spec, the \"T\" flag is added to
+its filename. This marks it for *manual* removal later.
+
+Some message retrieval and IMAP synchronization tools, however,
+interpret this flag instead as a trigger for *automatic* removal,
+may not be what the user expects. If, so set the flag to non-nil.
+This makes the \"trashing\" merely a move the trash-folder.")
+
 ;;; Insert stuff
 
 (defvar mu4e--mark-map nil
@@ -160,7 +172,8 @@ The current buffer must be either a headers or view buffer."
      :dyn-target (lambda (target msg) (mu4e-get-trash-folder msg))
      :action (lambda (docid msg target)
                (mu4e--server-move docid
-                                  (mu4e--mark-check-target target) "+T-N")))
+                                  (mu4e--mark-check-target target)
+                                  (if mu4e-trash-without-flag "-N" "+T-N"))))
     (unflag
      :char    ("-" . "➖")
      :prompt "-unflag"
diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index 781dbdf37..76fc15295 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -2337,7 +2337,7 @@ can happen in both the @ref{Headers view} and the @ref{Message view}.
 * Marking messages::Selecting message do something with them
 * What to mark for::What can we do with them
 * Executing the marks::Do it
-* Trashing messages::Exceptions for mailboxes like Gmail
+* Trashing messages::Marking messages for removal
 * Leaving the headers buffer::Handling marks automatically when leaving
 * Built-in marking functions::Helper functions for dealing with them
 * Custom mark functions::Define your own mark function
@@ -2418,14 +2418,17 @@ arguments, the mark and the message itself.
 @node Trashing messages
 @section Trashing messages
 
-For regular mailboxes, trashing works like other marks: when executed,
-the message is flagged as trashed.  Depending on your mailbox provider,
-the trash flag is used to automatically move the message to the trash
-folder (@code{mu4e-trash-folder}) for instance.
+When ``trashing'' a message, it is moved to a trash-folder (i.e.,
+@code{mu4e-trash-folder}) and is flagged as ``trashed'' (a ``T'' is added to its
+filename).
 
-Some mailboxes behave differently however and they don't interpret the
-trash flag.  In cases like Gmail, the message must be @emph{moved} to
-the trash folder and the trash flag must not be used.
+Following the Maildir specification, this flag is to be interpreted as ``marked
+for manual removal later''. However, some mail retrieval and IMAP
+synchronization programs interpret this instead as a trigger for
+@emph{immediate} removal.
+
+For such cases, you can influence @t{mu4e}'s behavior; see
+@code{mu4e-trash-without-flag}.
 
 @node Leaving the headers buffer
 @section Leaving the headers buffer
@@ -4223,12 +4226,19 @@ seems to work quite well.
 @subsection How can I disable the @t{Indexing...} messages?
 Set the variable @code{mu4e-hide-index-messages} to non-@t{nil}.
 
-@subsection IMAP-synchronization and file-name changes
-Some IMAP-synchronization programs such as @t{mbsync} (but not
-@t{offlineimap}) don't like it when message files do not change their
-names when they are moved to different folders. @t{mu4e} can attempt to
-help with this - you can set the variable
-@code{mu4e-change-filenames-when-moving} to non-@t{nil}.
+@subsection IMAP-synchronization
+
+Some IMAP-synchronization programs such as @t{mbsync} (but not @t{offlineimap})
+don't like it when message files do not change their names when they are moved
+to different folders. @t{mu4e} can attempt to help with this - you can set the
+variable @code{mu4e-change-filenames-when-moving} to non-@t{nil}.
+
+Also, some of these programs may interpret the ``trash'' flag differently; see
+@code{mu4e-trash-without-flag} for how to influence that.
+
+Finally, we would warn against synchronizing the ``Drafts'' folder; the messages
+in @t{mu4e}'s draft are in @t{mu4e}'s (i.e., Gnus') format, which is not
+necessarily usable by other clients.
 
 @subsection @command{offlineimap} and UTF-7
 @command{offlineimap} uses IMAP's UTF-7 for encoding non-ascii folder
@@ -4240,6 +4250,7 @@ see @uref{https://github.com/djcb/mu/issues/68#issuecomment-8598652,this
 ticket}.
 
 @subsection @command{mbsync} or @command{offlineimap} do not sync properly
+
 Unfortunately, @command{mbsync} and/or @command{offlineimap} do not
 always agree with @t{mu} about the meaning of various Maildir-flags. If
 you encounter unexpected behavior, it is recommended you check before

From d7078ad09c47e8849a9c923e2ded5ee2f9feeee0 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 14 Dec 2024 11:40:27 +0200
Subject: [PATCH 171/305] NEWS.org: update

---
 NEWS.org | 21 +++++++++++++++++----
 1 file changed, 17 insertions(+), 4 deletions(-)

diff --git a/NEWS.org b/NEWS.org
index 9c6d201af..30cc5d6a7 100644
--- a/NEWS.org
+++ b/NEWS.org
@@ -13,6 +13,8 @@
 
   - many documentation improvements
 
+*** mu
+
   - you can now search for messages that have a given message-id in their
     ~References:~ or ~In-Reply-To:~ headers, e.g.
     #+begin_example
@@ -27,10 +29,6 @@
     for ~:date~ and ~:changed~ (~:date-unix~ and ~:changed-unix~, respectively) which
     are a bit easier to manipulate than the emacs-style timestamps.
 
-  - message composition has been completely reworked to avoid a number of
-    problems that users reported. It is now directly uses the Gnus machinery,
-    integrated with mu4e.
-
   - with 1.12.7, ~mu~ indexing is single-threaded again, to avoid cases of
     database-corruption. In *mu4e* that means you need to _wait_ until indexing is
     ready before you can continue (*mu4e* will warn you).
@@ -43,6 +41,21 @@
     in the mu4e version in its main-page; however, since this is optional no
     longer, the suffix has been removed.
 
+*** mu4e
+
+  - message composition has been completely reworked to avoid a number of
+    problems that users reported. It is now directly uses the Gnus machinery,
+    integrated with mu4e.
+
+  - a new variable ~mu4e-trash-without-flag~, which, when set to non-nil makes
+    trashing _not_ add the the Maildir ~T~ flag. See its docstring for details.
+
+  - new variable ~mu4e-uniquify-save-file-name-function~ to influence the way ~mu4e~
+    creates unique file names when saving. See its docstring for details.
+
+  - new command ~mu4e-view-jump-to-mime-part~ for jumping to MIME-part by its
+    number.
+
 * 1.12 (released on February 24, 2024)
 
 ** Some highlights

From 88e4beaaa6fc2c46890a3f4505adbfd8c10bd64b Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 15 Dec 2024 10:51:31 +0200
Subject: [PATCH 172/305] mu4e.texi: update

Some update regarding replying unquoted contacts and some small
cleanups.
---
 mu4e/mu4e.texi | 58 ++++++++++++++++++++++++++------------------------
 1 file changed, 30 insertions(+), 28 deletions(-)

diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index 76fc15295..917d9d6dd 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -4361,6 +4361,18 @@ See @ref{Compose hooks}.
 Since @code{mu4e-compose-mode} derives from @xref{(message) Top}, you can re-use
 many (though not @emph{all} of its facilities.
 
+@subsection Replying to unquoted contacts with commas in their name
+
+Senders may have commas in their RFC2047-encoded name without using the needed
+quoting, for instance @t{From: Foo, the great Bar <foo@@bar.com>} instead of
+@t{From: "Foo, the great Bar" <foo@@bar.com>}.
+
+By default, when replying to such messages, @t{mu4e} then interprets the address
+as @emph{multiple} contacts. To avoid that, you can add to your configuration:
+@lisp
+(setq rfc2047-quote-decoded-words-containing-tspecials t)
+@end lisp
+
 @subsection How can I easily include attachments in the messages I write?
 You can drag-and-drop from your desktop; alternatively, you can use @ref{(emacs)
 Dired}.
@@ -4396,7 +4408,9 @@ values of @var{mu4e-compose-complete-only-personal},
 (setq message-kill-buffer-on-exit t)
 @end lisp
 
-@subsection Sending big messages is slow and blocks emacs --- what can I do about it?
+@subsection Sending big messages is slow and blocks Emacs
+
+And what can I do about it?
 
 For this, there's @uref{https://github.com/jwiegley/emacs-async,emacs-async}
 (also available from the Emacs package repository); add the following snippet to
@@ -4426,7 +4440,11 @@ Sending...done
 The first and final messages are the most important, and there may be
 considerable time between them, depending on the size of the message.
 
-@subsection Is it possible to view headers and messages, or compose new ones, in a separate frame or window?
+@subsection Using a separate frame or window for composing.
+
+Is it possible to view headers and messages, or compose new ones, in a separate
+frame or window?
+
 Yes. There is built-in support for composing messages in a new frame or window.
 Either use Emacs' standard @t{compose-mail-other-frame} (@kbd{C-x 5 m}) and
 @t{compose-mail-other-window} (@kbd{C-x 4 m}) if you have set up @t{mu4e} as your Emacs
@@ -4437,12 +4455,11 @@ docstring) which you can customize to influence how @t{mu4e} creates new
 messages.
 
 @subsection How can I apply format=flowed to my outgoing messages?
-This enables receiving clients that support this feature to reflow
-paragraphs. Plain text emails with @t{Content-Type: text/plain;
-format=flowed} can be reflowed (i.e. line endings removed, paragraphs
-refilled) by receiving clients that support this standard. Clients
-that don't support this, show them as is, which means this feature is
-truly non-invasive.
+
+Plain text emails with @t{Content-Type: text/plain; format=flowed} can be
+re-flowed (i.e. line endings removed, paragraphs refilled) by receiving clients
+that support this standard. Clients that don't support this, show them as is,
+which means this feature is truly non-invasive.
 
 Here's an explanatory blog post which also shows why this is a desirable
 feature: @url{https://mathiasbynens.be/notes/gmail-plain-text} (if you don't
@@ -4462,26 +4479,11 @@ message of as a long line (i.e. without carriage return). If you introduce
 unwanted newlines in your paragraph, use @kbd{M-q} to reformat it as a single
 line.
 
-If you want to send the message with paragraphs on single lines but
-without @t{format=flowed} (because, say, the receiver does not
-understand the latter as it is the case for Google or Github), use
-@kbd{M-x use-hard-newlines} (to turn @code{use-hard-newlines} off) or
-uncheck the box @t{format=flowed} in the @t{Text} menu when composing a
-message.
-
-@subsection How can I force images to be shown at the end of my messages, regardless of where I insert them?
-User Marcin Borkowski has a solution:
-@lisp
-(defun mml-attach-file--go-to-eob (orig-fun &rest args)
-  "Go to the end of buffer before attaching files."
-  (save-excursion
-    (save-restriction
-      (widen)
-      (goto-char (point-max))
-      (apply orig-fun args))))
-
-(advice-add 'mml-attach-file :around #'mml-attach-file--go-to-eob)
-@end lisp
+If you want to send the message with paragraphs on single lines but without
+@t{format=flowed} (because, say, the receiver does not understand the latter as
+it is the case for Google or Github), use @kbd{M-x use-hard-newlines} (to turn
+@code{use-hard-newlines} off) or uncheck the box @t{format=flowed} in the
+@t{Text} menu when composing a message.
 
 @subsection How can I avoid Outlook display issues?
 

From 407c6189f46957d60a17c8a489637dbfe334ddfa Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 17 Dec 2024 20:33:28 +0200
Subject: [PATCH 173/305] doc: updates

---
 mu4e/mu4e-folders.el | 33 +++++++++++++++++++--------------
 mu4e/mu4e.texi       |  7 +++----
 2 files changed, 22 insertions(+), 18 deletions(-)

diff --git a/mu4e/mu4e-folders.el b/mu4e/mu4e-folders.el
index 330264ae5..09fdfa552 100644
--- a/mu4e/mu4e-folders.el
+++ b/mu4e/mu4e-folders.el
@@ -1,6 +1,6 @@
-;;; mu4e-folders.el --- Dealing with maildirs & folders -*- lexical-binding: t -*-
+;;; mu4e-folders.el --- Maildirs & folders -*- lexical-binding: t -*-
 
-;; Copyright (C) 2021-2023 Dirk-Jan C. Binnema
+;; Copyright (C) 2021-2024 Dirk-Jan C. Binnema
 
 ;; Author: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ;; Maintainer: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
@@ -28,7 +28,7 @@
 (require 'mu4e-helpers)
 (require 'mu4e-context)
 (require 'mu4e-server)
-
+
 ;;; Customization
 (defgroup mu4e-folders nil
   "Special folders."
@@ -36,12 +36,18 @@
 
 (defcustom mu4e-drafts-folder "/drafts"
   "Folder for draft messages, relative to the root maildir.
-For instance, \"/drafts\". Instead of a string, may also be a
-function that takes a message (a msg plist, see
-`mu4e-message-field'), and returns a folder. Note, the message
-parameter refers to the original message being replied to / being
-forwarded / re-edited and is nil otherwise. `mu4e-drafts-folder'
-is only evaluated once."
+For instance, \"/drafts\".
+
+Instead of a string, may also be a function that takes a
+message (a msg plist, see `mu4e-message-field'), and returns a
+folder. Note, the message parameter refers to the original
+message being replied to / being forwarded / re-edited and is nil
+otherwise. `mu4e-drafts-folder' is only evaluated once.
+
+The form of draft messages is not necessarily compatible with
+other e-mail programs, e.g. when it involves attachments and the
+like.
+"
   :type '(choice
           (string :tag "Folder name")
           (function :tag "Function return folder name"))
@@ -98,8 +104,7 @@ Each of the list elements is a plist with at least:
 
 Optionally, you can add the following:
 `:name' - name of the maildir to be displayed in main-view.
-`:hide'  - if t, the shortcut is hidden from the main-view and
-speedbar.
+`:hide'  - if t, the shortcut is hidden from the main-view.
 `:hide-unread' - do not show the counts of unread/total number
  of matches for the maildir in the main-view, and is implied
 from `:hide'.
@@ -162,7 +167,7 @@ mime-type are nil."
 (defvar mu4e-maildir-list nil
   "Cached list of maildirs.")
 
-
+
 (defun mu4e-maildir-shortcuts ()
   "Get `mu4e-maildir-shortcuts' in the (new) format.
 Converts from the old format if needed."
@@ -284,8 +289,8 @@ Offer to create it if it does not exist yet."
 This is based on the variable `mu4e-attachment-dir', which is either:
 - if is a string, used it as-is
 -  a function taking two string parameters, both of which can be nil:
-    (1) a filename or a URL
-    (2) a mime-type (such as \"text/plain\"."
+    (1) FNAME, a filename or a URL
+    (2) MIMETYPE, a mime-type (such as \"text/plain\"."
   (let ((dir
          (cond
           ((stringp mu4e-attachment-dir)
diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index 917d9d6dd..739a573f6 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -523,10 +523,9 @@ If the mail-retrieval process returns with a non-zero exit code,
 is set to @code{nil}), but then try to index your maildirs anyway
 (unless @code{mu4e-index-update-error-continue} is set to @code{nil}).
 
-Reason for these defaults is that some of the mail-retrieval programs
-may return non-zero, even when the updating process succeeded; however,
-it is hard to tell such pseudo-errors from real ones like `login
-failed'.
+Reason for these defaults is that some of the mail-retrieval programs may return
+non-zero, even when the updating process succeeded; however, it is hard to tell
+such pseudo-errors from real ones like @t{login failed}.
 
 If you need more refinement, it may be useful to wrap the mail-retrieval
 program in a shell-script, for example @t{fetchmail} returns 1 to

From 8c0f136a50420ef20656fbff40caebafd3c184f5 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 17 Dec 2024 22:05:03 +0200
Subject: [PATCH 174/305] build: bump version to 1.12.8

---
 meson.build | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/meson.build b/meson.build
index 98b3f5304..e17058476 100644
--- a/meson.build
+++ b/meson.build
@@ -17,7 +17,7 @@
 ################################################################################
 # project setup
 project('mu', ['c', 'cpp'],
-        version: '1.12.7',
+        version: '1.12.8',
         meson_version: '>= 0.56.0',
         license: 'GPL-3.0-or-later',
         default_options : [
@@ -28,7 +28,7 @@ project('mu', ['c', 'cpp'],
 
 # hard-code the date here (for reproducibility); we derive the dates used in e.g.
 # documentation from this.
-mu_date='2024-10-27'
+mu_date='2024-12-17'
 
 # installation paths
 prefixdir = get_option('prefix')

From a703f002143b7167beb4fb10c71a497c8ed5b2f9 Mon Sep 17 00:00:00 2001
From: Thiago Jung Bauermann <bauermann@kolabnow.com>
Date: Fri, 3 Jan 2025 15:17:37 -0300
Subject: [PATCH 175/305] guile: tests: Fix encoding of "atomic" message
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

It's stated to be US-ASCII with 7-bit encoding, but it contains the
UTF-8 character '—'.

Fixing the encoding very slightly changes the average size of messages
reported by mu:average, so adjust the new expected value.
---
 guile/tests/test-mu-guile.scm        | 4 ++--
 testdata/testdir2/wom_bat/cur/atomic | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/guile/tests/test-mu-guile.scm b/guile/tests/test-mu-guile.scm
index afa4f48c6..975d3d715 100755
--- a/guile/tests/test-mu-guile.scm
+++ b/guile/tests/test-mu-guile.scm
@@ -83,7 +83,7 @@ exec guile -e main -s $0 $@
     (str-equal-or-exit (mu:subject msg) "atoms")
     (str-equal-or-exit (mu:to      msg) "Democritus <demo@example.com>")
     (str-equal-or-exit (mu:from    msg) "Richard P. Feynman <rpf@example.com>")
-    ;;(str-equal-or-exit (mu:header msg "Content-transfer-encoding") "7BIT")
+    ;;(str-equal-or-exit (mu:header msg "Content-Transfer-Encoding") "8bit")
 
     (if (not (equal? (mu:priority msg) mu:prio:high))
       (error-exit "Expected ~a, got ~a"  (mu:priority msg) mu:prio:high))))
@@ -97,7 +97,7 @@ exec guile -e main -s $0 $@
 (define (test-stats)
   "Test statistical functions."
   ;; average
-  (num-equal-or-exit (mu:average mu:size) 82601/14)
+  (num-equal-or-exit (mu:average mu:size) 41299/7)
   (num-equal-or-exit (floor (mu:stddev mu:size)) 12637.0)
   (num-equal-or-exit (mu:max mu:size) 46308)
   (num-equal-or-exit (mu:min mu:size) 111))
diff --git a/testdata/testdir2/wom_bat/cur/atomic b/testdata/testdir2/wom_bat/cur/atomic
index c3c679200..44eac88da 100644
--- a/testdata/testdir2/wom_bat/cur/atomic
+++ b/testdata/testdir2/wom_bat/cur/atomic
@@ -4,8 +4,8 @@ Subject: atoms
 To: "Democritus" <demo@example.com>
 Message-id: <3BE9E6535E302944823E7A1A20D852173@msg.id>
 MIME-version: 1.0
-Content-type: text/plain; charset=us-ascii
-Content-transfer-encoding: 7BIT
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
 Precedence: high
 
 If, in some cataclysm, all scientific knowledge were to be destroyed,

From 606f4be74b1a1f5de74752fdcc7b33872c38b1fb Mon Sep 17 00:00:00 2001
From: Thiago Jung Bauermann <bauermann@kolabnow.com>
Date: Thu, 2 Jan 2025 14:01:35 -0300
Subject: [PATCH 176/305] guile: Fix the mu:body message method

Somewhere along the way, the body-txt and body-html fields were merged
into a single body field. Later, commit 8eac3922215c ("guile: re-enable
the guile support") finally removed support for Field::Id::BodyHtml from
mu:c:get-field.

Unfortunately mu.scm and the documentation are still stuck in the past, so
update them. mu:body-txt is now a synonym for mu:body, and mu:body-html
always returns #f.

I wanted to add a mu:body test also for the rfc822.1 message, but there's
currently a bug where its body text is is duplicated (issue #2802), so the
test would fail.
---
 guile/examples/org2mu4e       |  2 +-
 guile/mu-guile.texi           |  3 +--
 guile/mu.scm                  | 19 +++++++++++++++----
 guile/tests/test-mu-guile.scm | 16 ++++++++++++++++
 4 files changed, 33 insertions(+), 7 deletions(-)

diff --git a/guile/examples/org2mu4e b/guile/examples/org2mu4e
index 3556b9a28..e7f10ad36 100755
--- a/guile/examples/org2mu4e
+++ b/guile/examples/org2mu4e
@@ -43,7 +43,7 @@ exec guile -e main -s $0 $@
     (org-mu4e-link msg)
     (if tag (string-concatenate `(":" ,tag "::")) "")
     (or (mu:from msg) "?")
-    (let ((body (mu:body-txt msg)))
+    (let ((body (mu:body msg)))
       (if (not body) ;; get a 'summary' of the body text
 	"<no plain-text body>"
 	(string-map
diff --git a/guile/mu-guile.texi b/guile/mu-guile.texi
index 9eae2feee..a5c24b9e8 100644
--- a/guile/mu-guile.texi
+++ b/guile/mu-guile.texi
@@ -391,8 +391,7 @@ properties, please refer to the @t{mu-find} man-page.
 
 @itemize
 @item @code{(mu:bcc msg)}: the @t{Bcc} field of the message, or @t{#f} if there is none
-@item @code{(mu:body-html msg)}: : the html body of the message, or @t{#f} if there is none
-@item @code{(mu:body-txt msg)}: the plain-text body of the message, or @t{#f} if there is none
+@item @code{(mu:body msg)}: the body of the message, or @t{#f} if there is none
 @item @code{(mu:cc msg)}: the @t{Bcc} field of the message, or @t{#f} if there is none
 @item @code{(mu:date msg)}: the @t{Date} field of the message, or 0 if there is none
 @item @code{(mu:flags msg)}: list of message-flags for this message
diff --git a/guile/mu.scm b/guile/mu.scm
index 08eae1fa4..31eca41ae 100644
--- a/guile/mu.scm
+++ b/guile/mu.scm
@@ -38,8 +38,7 @@
     mu:header
     ;; message accessors
     mu:field:bcc
-    mu:field:body-html
-    mu:field:body-txt
+    mu:field:body
     mu:field:cc
     mu:field:date
     mu:field:flags
@@ -54,6 +53,9 @@
     mu:field:tags
     mu:field:timestamp
     mu:field:to
+    ;; deprecated message accessors
+    mu:body-html
+    mu:body-txt
     ;; contact funcs
     mu:name
     mu:email
@@ -125,8 +127,7 @@
 	(export method-name)))))
 
 (define-getter mu:bcc	     mu:field:bcc)
-(define-getter mu:body-html  mu:field:body-html)
-(define-getter mu:body-txt   mu:field:body-txt)
+(define-getter mu:body	     mu:field:body)
 (define-getter mu:cc	     mu:field:cc)
 (define-getter mu:date	     mu:field:date)
 (define-getter mu:flags	     mu:field:flags)
@@ -142,6 +143,16 @@
 (define-getter mu:timestamp  mu:field:timestamp)
 (define-getter mu:to	     mu:field:to)
 
+(define-method (mu:body-html (msg <mu:message>))
+  "The HTML body isn't stored separately anymore, so this method can't return
+anything useful. We keep it for backwards compatibility."
+  #f)
+
+(define-method (mu:body-txt (msg <mu:message>))
+  "The text body isn't stored separately anymore. This method is now a synonym
+for mu:body."
+  (mu:body msg))
+
 (define-method (mu:header (msg <mu:message>) (hdr <string>))
   "Get an arbitrary header HDR from message MSG; return #f if it does
 not exist."
diff --git a/guile/tests/test-mu-guile.scm b/guile/tests/test-mu-guile.scm
index 975d3d715..ed00f1e3b 100755
--- a/guile/tests/test-mu-guile.scm
+++ b/guile/tests/test-mu-guile.scm
@@ -84,6 +84,22 @@ exec guile -e main -s $0 $@
     (str-equal-or-exit (mu:to      msg) "Democritus <demo@example.com>")
     (str-equal-or-exit (mu:from    msg) "Richard P. Feynman <rpf@example.com>")
     ;;(str-equal-or-exit (mu:header msg "Content-Transfer-Encoding") "8bit")
+    (str-equal-or-exit (mu:body msg)
+                       (string-join
+                        '("If, in some cataclysm, all scientific knowledge were to be destroyed,"
+                          "and only one sentence passed on to the next generation of creatures,"
+                          "what statement would contain the most information in the fewest words?"
+                          "I believe it is the atomic hypothesis (or atomic fact, or whatever you"
+                          "wish to call it) that all things are made of atoms — little particles"
+                          "that move around in perpetual motion, attracting each other when they"
+                          "are a little distance apart, but repelling upon being squeezed into"
+                          "one another. In that one sentence you will see an enormous amount of"
+                          "information about the world, if just a little imagination and thinking"
+                          "are applied.\n") "\n"))
+    (str-equal-or-exit (mu:body-txt msg) (mu:body msg))
+    (let ((got (mu:body-html msg)))
+      (if got
+          (error-exit "Expected #f, got ~a" got)))
 
     (if (not (equal? (mu:priority msg) mu:prio:high))
       (error-exit "Expected ~a, got ~a"  (mu:priority msg) mu:prio:high))))

From 51137998dbc70d2513b77498408ef1ec57a374de Mon Sep 17 00:00:00 2001
From: Thiago Jung Bauermann <bauermann@kolabnow.com>
Date: Fri, 3 Jan 2025 14:33:42 -0300
Subject: [PATCH 177/305] mu4e: Update references to :body-txt and :body-html

Most are in comments, but one is in code.
---
 mu4e/mu4e-message.el | 17 ++++++++---------
 mu4e/mu4e-server.el  |  2 +-
 2 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/mu4e/mu4e-message.el b/mu4e/mu4e-message.el
index e42ed4557..80ab1ba6b 100644
--- a/mu4e/mu4e-message.el
+++ b/mu4e/mu4e-message.el
@@ -71,8 +71,8 @@ Some notes on the format:
   the MIME-part), :name (the file name, if any), :mime-type (the
   MIME-type, if any) and :size (the size in bytes, if any).
 - Messages in the Headers view come from the database and do not have
-  :attachments, :body-txt or :body-html fields. Message in the
-  Message view use the actual message file, and do include these fields."
+  :attachments or :body fields. Message in the Message view use the
+  actual message file, and do include these fields."
   ;; after all this documentation, the spectacular implementation
   (if msg
       (plist-get msg field)
@@ -81,18 +81,17 @@ Some notes on the format:
 (defsubst mu4e-message-field (msg field)
   "Retrieve FIELD from message plist MSG.
 Like `mu4e-message-field-nil', but will sanitize nil values:
-- all string field except body-txt/body-html: nil -> \"\"
-- numeric fields + dates                    : nil -> 0
-- all others                                : return the value
-Thus, function will return nil for empty lists, non-existing body-txt
-or body-html."
+- all string field except body: nil -> \"\"
+- numeric fields + dates      : nil -> 0
+- all others                  : return the value
+Thus, function will return nil for empty lists, or non-existing body."
   (let ((val (mu4e-message-field-raw msg field)))
     (cond
      (val
       val)   ;; non-nil -> just return it
      ((member field '(:subject :message-id :path :maildir :in-reply-to))
-      "")    ;; string fields except body-txt, body-html: nil -> ""
-     ((member field '(:body-html :body-txt))
+      "")    ;; string fields except body: nil -> ""
+     ((member field '(:body))
       val)
      ((member field '(:docid :size))
       0)     ;; numeric type: nil -> 0
diff --git a/mu4e/mu4e-server.el b/mu4e/mu4e-server.el
index b62a4ab6e..31b2dcba0 100644
--- a/mu4e/mu4e-server.el
+++ b/mu4e/mu4e-server.el
@@ -323,7 +323,7 @@ The server output is as follows:
   3. a view looks like:
   (:view <msg-sexp>)
   => the <msg-sexp> (see 2.) will be passed to `mu4e-view-func'.
-     the <msg-sexp> also contains :body-txt and/or :body-html
+     the <msg-sexp> also contains :body
 
   4. a database update looks like:
   (:update <msg-sexp> :move <nil-or-t>)

From f0a25df45ead97b252aad5ca0fb71229bd26e6ce Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Fri, 27 Dec 2024 18:54:56 +0200
Subject: [PATCH 178/305] IDEAS.org: add multiple-reply-at-once-idea

Fixes #2799.
---
 IDEAS.org | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/IDEAS.org b/IDEAS.org
index b34936410..3fc37c35e 100644
--- a/IDEAS.org
+++ b/IDEAS.org
@@ -59,7 +59,13 @@ future.
   https://github.com/djcb/mu/issues/2768
 
 - Org-link type for any message matching some reference
-  See: https://github.com/djcb/mu/issues/2787
+  See: https://github.com/djcb/mu/issues/2787.
+  Some first steps implemented (searching for references).
+
+- Reply/forward/... to multiple messages at once. This is sometimes useful, and
+  Gnus supports. Does not seem trivial to re-use the Gnus code... (see
+  ~gnus-summary-work-articles~ etc.).
+  https://github.com/djcb/mu/issues/2799
 
 * Done
 

From 0bec3ed24aad0b50a5af0e641b4107f67a9bc154 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 28 Dec 2024 11:39:19 +0200
Subject: [PATCH 179/305] NEWS.org: update

---
 NEWS.org | 29 ++++++++++++++++++-----------
 1 file changed, 18 insertions(+), 11 deletions(-)

diff --git a/NEWS.org b/NEWS.org
index 30cc5d6a7..21531febf 100644
--- a/NEWS.org
+++ b/NEWS.org
@@ -3,11 +3,15 @@
 
 * 1.12 (post 1.12.0 updates)
 
- The 1.12 series has been the stable one for a fairly long time, and gained some
- changes in mean-time. Most of the changes are for big bugs, but some small new
- features are available as well. We decided to put off a new development series
- (1.13 -> 1.14) until incompatible changes are required; for now working in the
- 1.12 series seems a good way to get improvements to users more quickly.
+ The 1.12 series has been stable for a fairly long time, and gained some changes
+ in mean-time. Most of the changes are for big bugs, but some small new features
+ are available as well.
+
+ We decided to put off a new development series (1.13 -> 1.14) until
+ incompatible changes are required; for now working in the 1.12 series seems a
+ good way to get improvements to users more quickly.
+
+ The changes include:
 
   - many bug fixes
 
@@ -27,7 +31,9 @@
 
   - The ~--format=json~ output for *mu find* now includes "unix-style" timestamps
     for ~:date~ and ~:changed~ (~:date-unix~ and ~:changed-unix~, respectively) which
-    are a bit easier to manipulate than the emacs-style timestamps.
+    represent the time as a simple number (number of seconds since epoch), which
+    is a bit easier to manipulate than the emacs-style timestamps (same value,
+    but expressed as a list).
 
   - with 1.12.7, ~mu~ indexing is single-threaded again, to avoid cases of
     database-corruption. In *mu4e* that means you need to _wait_ until indexing is
@@ -61,9 +67,10 @@
 ** Some highlights
 
   - Significant speedups in both ~mu~ and ~mu4e~
-  - Reworked message composition, closer to its Gnus origins which adds many of its features
-  - Overhauled the query parser; squashing a number of bugs/limitations, incl. dealing
-    with CJK messages
+  - Reworked message composition, closer to its Gnus origins which adds many of
+    its features
+  - Overhauled the query parser; squashing a number of bugs/limitations, incl.
+    dealing with CJK messages
   - Experimental folding of message threads
   - Better and faster indexing of HTML messages
   - Experimental search by (human) language wit CLD2
@@ -165,8 +172,8 @@
 
     - The special mailing list handling is gone; ~mu4e-compose-reply~ and
       ~mu4e-compose-wide-reply~ should take care of that. There's also
-      ~message-reply-to-function~ for ultimate control; see [[info:(message)
-      Reply][info (message) Reply]] for details.
+      ~message-reply-to-function~ for ultimate control; see [[info:(message) Reply][info (message) Reply]]
+      for details.
 
     - ~mu4e-compose-in-new-frame~ has been generalized (in a backward-compatible
       way) to ~mu4e-compose-switch~, which lets you decide whether a message

From b3891600663c7d00a92eb429845af63e8305306a Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 5 Jan 2025 22:14:46 +0200
Subject: [PATCH 180/305] mu4e-server: cosmetics

---
 mu4e/mu4e-server.el | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/mu4e/mu4e-server.el b/mu4e/mu4e-server.el
index 31b2dcba0..d1b1c155b 100644
--- a/mu4e/mu4e-server.el
+++ b/mu4e/mu4e-server.el
@@ -1,6 +1,6 @@
 ;;; mu4e-server.el --- Control mu server from mu4e -*- lexical-binding: t -*-
 
-;; Copyright (C) 2011-2024 Dirk-Jan C. Binnema
+;; Copyright (C) 2011-2025 Dirk-Jan C. Binnema
 
 ;; Author: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ;; Maintainer: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
@@ -93,11 +93,9 @@ stop/start mu4e."
   :group 'mu4e
   :safe  'booleanp)
 
-
 ;; Cached data
 (defvar mu4e-maildir-list)
 
-
 ;; Handlers are not strictly internal, but are not meant
 ;; for overriding outside mu4e. The are mainly for breaking
 ;; dependency cycles.
@@ -151,7 +149,6 @@ from the server process.")
   "A function called for each (:contacts (<list-of-contacts>))
 sexp received from the server process.")
 
-
 ;;; Dealing with Server properties
 (defvar mu4e--server-props nil
   "Metadata we receive from the mu4e server.")
@@ -193,7 +190,6 @@ for bookmarks and maildirs.")
   "Are we using Xapian in single-threaded mode?"
   (plist-get mu4e--server-props :xapian-single-threaded))
 
-
 ;;; Handling raw server data
 
 (defvar mu4e--server-buf nil
@@ -218,7 +214,6 @@ Match 1 will be the length (in hex).")
 
 (defvar mu4e--server-indexing nil "Currently indexing?")
 
-
 (defun mu4e-running-p ()
   "Whether mu4e is running.
 Checks whether the server process is live."
@@ -719,6 +714,5 @@ will be delivered to the function registered as `mu4e-view-func'."
      ;; because mbsync seems to get confused.
      :rename  ,(and mu4e-change-filenames-when-moving t))))
 
-
 (provide 'mu4e-server)
 ;;; mu4e-server.el ends here

From 5f8e0b71f091836c07be67e40402c3dbd8389ba7 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 5 Jan 2025 22:41:24 +0200
Subject: [PATCH 181/305] server: make parsed queries available to mu4e

Basically, make the "mu find .... --analyze" information available in
mu4e, through a function mu4e-server-last-query.

This is shows the query as the server saw it, as well as the parse
s-expressions. This can be useful to see how some query is interpreted.
---
 lib/mu-server.cc    | 10 ++++++++--
 mu4e/mu4e-server.el | 22 ++++++++++++++++++++--
 2 files changed, 28 insertions(+), 4 deletions(-)

diff --git a/lib/mu-server.cc b/lib/mu-server.cc
index 6048b7072..4862f7a9a 100644
--- a/lib/mu-server.cc
+++ b/lib/mu-server.cc
@@ -1,5 +1,5 @@
 /*
-** Copyright (C) 2020-2023 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2020-2025 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify it
 ** under the terms of the GNU General Public License as published by the
@@ -39,6 +39,7 @@
 
 #include "mu-maildir.hh"
 #include "mu-query.hh"
+#include "mu-query-parser.hh"
 #include "mu-store.hh"
 
 #include "utils/mu-utils.hh"
@@ -703,7 +704,12 @@ Server::Private::find_handler(const Command& cmd)
 	output_sexp(Sexp().put_props(":erase", Sexp::t_sym));
 	const auto bsize{static_cast<size_t>(batch_size)};
 	const auto foundnum = output_results(*qres, bsize);
-	output_sexp(Sexp().put_props(":found", foundnum));
+
+	output_sexp(Sexp().put_props(
+			    ":found", foundnum,
+			    ":query", q,
+			    ":query-sexp", parse_query(q, false/*!expand*/).to_string(),
+			    ":query-sexp-expanded", parse_query(q, true/*expand*/).to_string()));
 }
 
 void
diff --git a/mu4e/mu4e-server.el b/mu4e/mu4e-server.el
index d1b1c155b..85ba03291 100644
--- a/mu4e/mu4e-server.el
+++ b/mu4e/mu4e-server.el
@@ -175,7 +175,7 @@ sexp received from the server process.")
            (plist-get mu4e--server-props :version))
       (mu4e-error "Version unknown; did you start mu4e?")))
 
-;;; remember queries result.
+;;; remember query results.
 (defvar mu4e--server-query-items nil
   "Query items results we receive from the mu4e server.
 Those are the results from the counting-queries
@@ -185,6 +185,22 @@ for bookmarks and maildirs.")
   "Get the latest server query items."
   mu4e--server-query-items)
 
+(defvar mu4e--server-query nil
+  "Last query executed by the server.
+This is a plist, see `mu4e-server-last-query' for details.")
+
+(defun mu4e-server-last-query ()
+  "Get a plist with information about the last server-query.
+
+This has the following fields:
+- :query: this is the last query the server executed (a string)
+- :query-sexp: this is that last query as processed by the query engine
+  (an s-expression as a string)
+- :query-sexp-expanded: like last-query-sexp, but with combination fields
+   expanded."
+  (cl-remf mu4e--server-query :found) ;; there's no plist-delete
+  mu4e--server-query)
+
 ;; temporary
 (defun mu4e--server-xapian-single-threaded-p()
   "Are we using Xapian in single-threaded mode?"
@@ -278,7 +294,7 @@ This for the few sexps we get from the mu server that support
 (defun mu4e--server-filter (_proc str)
   "Filter string STR from PROC.
 This processes the \"mu server\" output. It accumulates the
-strings into valid sexpsv and evaluating those.
+strings into valid s-expressions and evaluates those.
 
 The server output is as follows:
 
@@ -349,6 +365,8 @@ The server output is as follows:
 
          ;; the found sexp, we receive after getting all the headers
          ((plist-get sexp :found)
+          ;; capture the query-info
+          (setq mu4e--server-query sexp)
           (funcall mu4e-found-func (plist-get sexp :found)))
 
          ;; viewing a specific message

From f54e0c0476b4d0df3d58bcbf01916a6af8cca65e Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 5 Jan 2025 22:45:11 +0200
Subject: [PATCH 182/305] mu-query-parser: cosmetic

---
 lib/mu-query-parser.hh | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/lib/mu-query-parser.hh b/lib/mu-query-parser.hh
index 72b23a7d0..79c5e46b7 100644
--- a/lib/mu-query-parser.hh
+++ b/lib/mu-query-parser.hh
@@ -80,7 +80,8 @@ Sexp process_query(const std::string& expr);
  * processes the tokens into a Sexp. This sexp is meant to be human-readable.
  *
  * @param expr a search expression
- * @param expand whether to expand meta-fields (such as '_', 'recip', 'contacts')
+ * @param expand whether to expand combination-fields (such as '_', 'recip',
+ * 'contacts')
  *
  * @return Sexp with the parse tree
  */

From 5e2b7d52b24d3f3a9ea4273cef91d1170f9ccb78 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 5 Jan 2025 22:45:39 +0200
Subject: [PATCH 183/305] mu-query.7: update documentation

In particular, regex searches.
---
 man/mu-query.7.org | 168 +++++++++++++++++++++++++++++++++------------
 1 file changed, 125 insertions(+), 43 deletions(-)

diff --git a/man/mu-query.7.org b/man/mu-query.7.org
index 0cb1cd3c5..694a56ebd 100644
--- a/man/mu-query.7.org
+++ b/man/mu-query.7.org
@@ -18,48 +18,87 @@ provide examples. As a companion to this, we recommend the *mu info fields*
 command to get an up-to-date list of the available fields and flags.
 
 Furthermore, *mu find* provides the *--analyze* option, which shows how *mu*
-interprets your query; see the *ANALYZING QUERIES* section below.
+interprets your query; similarly, mu4e has a command. mu4e-analyze-last-query.
+See the *ANALYZING QUERIES* section for further details.
 
 *NOTE:* if you use queries on the command-line (say, for *mu find*), you need to
 quote any characters that would otherwise be interpreted by the shell, such as
-*""*, *(* and *)* and whitespace.
+'"', '*', '(' and ')'. The details are shell-specific. In case of doubt, the
+*--analyze* option can be useful.
 
 * TERMS
 
 The basic building blocks of a query are *terms*; these are just normal words like
-`banana' or `hello', or words prefixed with a field-name which makes them apply
+"banana" or "hello", or words prefixed with a field-name which makes them apply
 to just that field. See *mu info fields* for all the available fields.
 
 Some example queries:
+
 #+begin_example
 vacation
 subject:capybara
 maildir:/inbox
 #+end_example
 
-Terms without an explicit field-prefix, (like `vacation' above) are interpreted
-like:
+Terms without an explicit field-prefix, (like "vacation" above) are interpreted
+as:
+
 #+begin_example
 to:vacation or subject:vacation or body:vacation or ...
 #+end_example
 
-The language is case-insensitive for terms and attempts to `flatten' diacritics,
+The language is case-insensitive for terms and attempts to "flatten" diacritics,
 so =angtrom= matches =Ångström=.
 
-If terms contain whitespace, they need to be quoted:
+If terms contain whitespace, they need to be quoted.
+
 #+begin_example
 subject:"hi there"
 #+end_example
+
 This is a so-called =phrase query=, which means that we match against subjects
-that contain the literal phrase "hi there". Phrase queries only work for fields
-that are /indexed/, i.e., fields with *index* in the *mu info fields* search column.
+that contain the literal phrase "hi there". Phrase queries only work for certain
+fields; they have the word *phrase* in their *mu info fields* search column.
+
+** Quoting queries for the shell
+
+Remember that you need to escape the quotes for a search query when using this
+from the command-line; otherwise, the shell (or most shells) process the queries
+and *mu* never sees them.
+
+In this case, that means the difference between search for a subject "hi there"
+versus and subject "hi" and some word "there" that can appear in any of the
+combination fields for <empty> (combination fields are discussed below).
+
+We can use the mentioned *--analyze* option to show the difference:
 
-Remember that you need to escape those quotes when using this from the
-command-line:
 #+begin_example
-mu find subject:\\"hi there\\"
+mu find subject:"hi there" --analyze
+* query:
+  subject:hi there
+* parsed query:
+  (and (subject "hi") (_ "there"))
+* parsed query (expanded):
+  (and (subject "hi") (or (to "there") (cc "there") (bcc "there") (from "there") (subject "there") (body "there") (embed "there")))
+* Xapian query:
+  Query((Shi AND (Tthere OR Cthere OR Hthere OR Fthere OR Sthere OR Bthere OR Ethere)))
 #+end_example
 
+And with quotes escaped:
+
+#+begin_example
+mu find subject:\"hi there\" --analyze
+* query:
+  subject:"hi there"
+* parsed query:
+  (or (subject "hi there") (subject (phrase "hi there")))
+* Xapian query:
+  Query((Shi there OR (Shi PHRASE 2 Sthere)))
+#+end_example
+
+We won't dwell on the details of the *--analyze* output here, but hopefully this
+illustrates the difference between quoted and unquoted queries.
+
 * LOGICAL OPERATORS
 
 We can combine terms with logical operators -- binary ones: *and*, *or*, *xor* and the
@@ -81,37 +120,72 @@ subject:chip AND subject:dale
 #+end_example
 are equivalent. For readability, we recommend the second version.
 
-Note that a =pure not= - e.g. searching for *not apples* is quite a `heavy' query.
+Note that a =pure not= - e.g. searching for *not apples* is quite a "heavy" query.
+
+*  WILDCARDS
 
-* REGULAR EXPRESSIONS AND WILDCARDS
+Wildcards are a Xapian built-in mechanism for matching.
 
-The language supports matching basic PCRE regular expressions, see {{{man-link(pcre,3)}}}.
+A search term with a rightmost *** (and =only= in that position) matches any term
+that starts with the part before the ***; they are less powerful than regular
+expressions, but also much faster:
 
-Regular expressions are enclosed in *//*. Some examples:
+An example:
+#+begin_example
+$ mu find "hello*"
+#+end_example
+
+Quoting the "hello*" is recommended; some shells (but not all) would otherwise
+expand the '*' to all files in the current directory.
+
+* REGULAR EXPRESSIONS
+
+The query language supports matching basic PCRE regular expressions, as per
+{{{man-link(pcre,3)}}}, with some limitations.
+
+Regular expressions are enclosed in *//*. For example:
 
 #+begin_example
 subject:/h.llo/		# match hallo, hello, ...
-subject:/
 #+end_example
 
-Note the difference between `maildir:/foo' and `maildir:/foo/'; the former
-matches messages in the `/foo' maildir, while the latter matches all messages in
-all maildirs that match `foo', such as `/foo', `/bar/cuux/foo', `/fooishbar'
-etc.
+Note the difference between "maildir:/foo" and "maildir:/foo/"; the former
+matches messages in the "/foo" maildir, while the latter matches all messages in
+all maildirs that match "foo", such as "/foo", "/bar/cuux/foo", "/fooishbar",
+and so on.
+
+Regular expressions are more powerful than wildcards, but are also much slower.
+Moreover, their behavior in *mu* can be a bit confusing, due to some
+implementation details. See below for some of the caveats.
 
-Wildcards are another mechanism for matching where a term with a rightmost ***
-(and =only= in that position) matches any term that starts with the part before
-the ***; they are therefore less powerful than regular expressions, but also much
-faster:
+** Whitespace in regular expression literals
+
+To avoid ambiguities in the query parsing, regular express *must not* contain
+whitespace, so the search for a message with subject "hello world", you can write
 #+begin_example
-foo*
+mu find 'subject:/hello\\040world/'
 #+end_example
-is equivalent to
+(with the \040 specifying a space in the regular expression, and and extra '\'
+to escape it). In many cases,
 #+begin_example
-/foo.*/
+mu find 'subject:/hello.world/'
 #+end_example
+may be good enough, and easier to type.
+
+** Anchors in regular expressions
+
+Since the underlying Xapian database does not support regular expressions (it
+does support wildcards), *mu* implements the regular-expression search by matching
+the user's regular expression against all "terms" (words or phrases) that in the
+database for a given field.
 
-Regular expressions can be useful, but are relatively slow.
+That implementation detail explain why "anchored" regular expressions (with *^*
+and *$* to mark begin/end, respectively) can get unexpected results.
+
+Suppose you want to match all messages that start with "pie", and you search
+with *subject:/^pie/*. This /also/ matches messages with subject "apple pie", since
+both those words are indexed as terms separately (as well as phrases), and thus
+"^pie" matches as well for a message with subject "apple pie".
 
 * FIELDS
 
@@ -208,10 +282,10 @@ an open range.
 Dates are expressed in local time and using ISO-8601 format (YYYY-MM-DD
 HH:MM:SS); you can leave out the right part and *mu* adds the rest, depending on
 whether this is the beginning or end of the range (e.g., as a lower bound,
-`2015' would be interpreted as the start of that year; as an upper bound as the
+"2015" would be interpreted as the start of that year; as an upper bound as the
 end of the year).
 
-You can use `/' , `.', `-', `:' and `T' to make dates more human-readable.
+You can use `/' , `.', `-', `:' and "T" to make dates more human-readable.
 
 Some examples:
 #+begin_example
@@ -222,13 +296,13 @@ date:2015-06-01..
 date:2016..2016
 #+end_example
 
-You can also use the special `dates' *now* and *today*:
+You can also use the special "dates" *now* and *today*:
 #+begin_example
 date:20170505..now
 date:today..
 #+end_example
 
-Finally, you can use relative `ago' times which express some time before now and
+Finally, you can use relative "ago" times which express some time before now and
 consist of a number followed by a unit, with units *s* for seconds, *M* for minutes,
 *h* for hours, *d* for days, *w* for week, *m* for months and *y* for years. Some
 examples:
@@ -315,7 +389,7 @@ find it (and all the other messages in that same maildir) with:
 maildir:/lists/running
 #+end_example
 
-Note the starting `/'. If you want to match mails in the `root' maildir, you can
+Note the starting `/'. If you want to match mails in the "root" maildir, you can
 do with a single `/':
 #+begin_example
 maildir:/
@@ -343,7 +417,7 @@ queries using various logical operators, parentheses and so on, but in the
 author's experience, it's usually faster to find a message with a simple query
 just searching for some words.
 
-Find all messages with both `bee' and `bird' (in any field)
+Find all messages with both "bee" and "bird" (in any field)
 #+begin_example
 bee AND bird
 #+end_example
@@ -353,12 +427,12 @@ Find all messages with either Frodo or Sam:
 Frodo OR Sam
 #+end_example
 
-Find all messages with the `wombat' as subject, and `capybara' anywhere:
+Find all messages with the "wombat" as subject, and "capybara" anywhere:
 #+begin_example
 subject:wombat and capybara
 #+end_example
 
-Find all messages in the `Archive' folder from Fred:
+Find all messages in the "Archive" folder from Fred:
 #+begin_example
 from:fred and maildir:/Archive
 #+end_example
@@ -385,7 +459,7 @@ Find a messages with the given message-id:
 msgid:CAE56pjGU2oNxN-wWku69@mail.gmail.com
 #+end_example
 
-Find all messages written in Dutch or German with the word `hallo':
+Find all messages written in Dutch or German with the word "hallo":
 #+begin_example
 hallo and (lang:nl or lang:de)
 #+end_example
@@ -395,14 +469,18 @@ for "cld2-support*.
 
 * ANALZYING QUERIES
 
-Despite all the excellent documentation, in some cases it can be non-obvious how
-*mu* interprets your query. For that, you can ask *mu* to analyze the query -- that
-is, show how *mu* interprets the query.
+Despite all the excellent documentation, in some cases it can be non-obvious to
+understand how *mu* interprets your query, especially when shell interpretation is
+involved as well.
+
+For that, you can ask *mu* to analyze the
+query -- that is, show how *mu* interprets the query. We already saw an example of
+this.
 
 This uses the the *--analyze* option to *mu find*.
 #+begin_example
 $ mu find subject:wombat AND date:3m.. size:..2000  --analyze
-,* query:
+,*query:
   subject:wombat AND date:3m.. size:..2000
 ,* parsed query:
   (and (subject "wombat") (date (range "2023-05-30T06:10:09Z" "")) (size (range "" "2000")))
@@ -411,7 +489,11 @@ $ mu find subject:wombat AND date:3m.. size:..2000  --analyze
 #+end_example
 
 The ~parsed query~ is usually the most useful one for understanding how *mu*
-interprets your query.
+interprets your query; it shows the query as *mu* sees it, in s-expression
+notation.
+
+In *mu4e* there is the *mu4e-analyze-last-query* command, which provides similar
+information.
 
 #+include: "prefooter.inc" :minlevel 1
 

From 0f49fa055c1f55204b88c6b547a3f95feba4128a Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 7 Jan 2025 22:11:53 +0200
Subject: [PATCH 184/305] mu4e: add mu4e-analyze-last-query

Add some mu4e command to show the query as analyzed by the server.
---
 mu4e/mu4e-helpers.el | 24 ++++++++++++++++++++----
 mu4e/mu4e-server.el  | 14 ++++++++++++--
 mu4e/mu4e-window.el  | 11 +++++++----
 mu4e/mu4e.texi       |  9 ++++++---
 4 files changed, 45 insertions(+), 13 deletions(-)

diff --git a/mu4e/mu4e-helpers.el b/mu4e/mu4e-helpers.el
index c96509b58..d756b81e5 100644
--- a/mu4e/mu4e-helpers.el
+++ b/mu4e/mu4e-helpers.el
@@ -1,6 +1,6 @@
 ;;; mu4e-helpers.el --- Helper functions -*- lexical-binding: t -*-
 
-;; Copyright (C) 2022-2024  Dirk-Jan C. Binnema
+;; Copyright (C) 2022-2025 Dirk-Jan C. Binnema
 
 ;; Author: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ;; Maintainer: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
@@ -68,8 +68,7 @@ might want to add something like the following in your configuration.
   :group 'mu4e)
 
 (defcustom mu4e-read-option-use-builtin t
-  "Whether to use mu4e's traditional completion for
-`mu4e-read-option'.
+  "Whether to use mu4e's traditional completion for `mu4e-read-option'.
 
 If nil, use the value of `mu4e-completing-read-function', integrated
 into mu4e.
@@ -546,6 +545,23 @@ Or go to the top level if there is none."
   (when-let* ((msgid (bookmark-prop-get bookmark 'message-id)))
     (mu4e-view-message-with-message-id msgid)))
 
+(defun mu4e--popup-lisp-buffer (bufname data)
+  "Show or hide an s-expression string in a popup-buffer.
+BUFNAME is the name of the buffer, and DATA is lisp-data, if any."
+  (if-let* ((win (get-buffer-window bufname)))
+      (delete-window win)
+    (when data
+      (when (buffer-live-p bufname)
+        (kill-buffer bufname))
+      (with-current-buffer-window
+          (get-buffer-create bufname) nil nil
+        ;; sadly, the default indentation for plists
+        ;; is not very nice, and I failed to overwrite it
+        (lisp-mode)
+        (insert (pp-to-string data))
+        ;; add basic `quit-window' bindings
+        (view-mode 1)))))
+
 ;;; Macros
 
 (defmacro mu4e-setq-if-nil (var val)
@@ -566,7 +582,7 @@ COMPONENTS."
 
 (defun mu4e-string-replace (from-string to-string in-string)
   "Replace FROM-STRING with TO-STRING in IN-STRING each time it occurs.
-Mu4e version of emacs 28's string-replace."
+Mu4e's version of Emacs 28's `string-replace'."
   (replace-regexp-in-string (regexp-quote from-string)
                             to-string in-string nil 'literal))
 
diff --git a/mu4e/mu4e-server.el b/mu4e/mu4e-server.el
index 85ba03291..02942af3e 100644
--- a/mu4e/mu4e-server.el
+++ b/mu4e/mu4e-server.el
@@ -196,11 +196,21 @@ This has the following fields:
 - :query: this is the last query the server executed (a string)
 - :query-sexp: this is that last query as processed by the query engine
   (an s-expression as a string)
-- :query-sexp-expanded: like last-query-sexp, but with combination fields
-   expanded."
+- :query-sexp-expanded: like :query-sexp, but with combination fields
+   expanded (if any)."
   (cl-remf mu4e--server-query :found) ;; there's no plist-delete
   mu4e--server-query)
 
+(defvar mu4e--last-query-buffer-name)
+(defun mu4e-analyze-last-query ()
+  "Pop-up a buffer with the most recent query as the server saw it.
+See `mu4e-server-last-query' for the fields.
+It is the mu4e-version of \"mu find <query> --analyze\"."
+  (interactive)
+  (mu4e--popup-lisp-buffer
+   mu4e--last-query-buffer-name
+   (mu4e-server-last-query)))
+
 ;; temporary
 (defun mu4e--server-xapian-single-threaded-p()
   "Are we using Xapian in single-threaded mode?"
diff --git a/mu4e/mu4e-window.el b/mu4e/mu4e-window.el
index 8437b0980..a172144de 100644
--- a/mu4e/mu4e-window.el
+++ b/mu4e/mu4e-window.el
@@ -1,7 +1,7 @@
 ;;; mu4e-window.el --- Window management -*- lexical-binding: t; -*-
 
 ;; Copyright (C) 2022  Mickey Petersen
-;; Copyright (C) 2023-2024 Dirk-Jan C. Binnema
+;; Copyright (C) 2023-2025 Dirk-Jan C. Binnema
 
 ;; Author: Mickey Petersen <mickey@masteringemacs.org>
 ;; Keywords: mail
@@ -26,7 +26,10 @@
 ;;; Buffer names for internal use
 
 (defconst mu4e--sexp-buffer-name "*mu4e-sexp-at-point*"
-  "Buffer name for sexp buffers.")
+  "Name for the buffer which shows the sexp for the message-at-point.")
+
+(defconst mu4e--last-query-buffer-name "*mu4e-last-query*"
+  "Name for the buffer which shows the last server-query.")
 
 (defvar mu4e-main-buffer-name "*mu4e-main*"
   "Name of the mu4e main buffer.")
@@ -77,14 +80,14 @@ function; this is no longer supported; instead you can use
   :group 'mu4e-headers)
 
 (defcustom mu4e-headers-visible-lines 10
-  "Number of lines to display in the header view when using the
+  "Number of lines to display in the headers view (horizontal split-view).
 horizontal split-view. This includes the header-line at the top,
 and the mode-line."
   :type 'integer
   :group 'mu4e-headers)
 
 (defcustom mu4e-headers-visible-columns 30
-  "Number of columns to display for the header view when using the
+  "Number of columns to display for the header view (vertical split-view).
 vertical split-view."
   :type 'integer
   :group 'mu4e-headers)
diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index 739a573f6..6a5045caa 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -1975,9 +1975,12 @@ see @ref{Sorting and threading}.
 @section Queries
 
 @t{mu4e} queries are the same as the ones that @t{mu find}
-understands@footnote{with the caveat that command-line queries are
-subject to the shell's interpretation before @t{mu} sees them}. You can
-consult the @code{mu-query} man page for the details.
+understands@footnote{with the caveat that command-line queries are subject to
+the shell's interpretation before @t{mu} sees them}. You can consult the
+@code{mu-query} man-page for the details. In addition, @t{mu4e} provides a
+command @code{mu4e-analyze-last-query}, which shows how the @t{mu} server has
+interpreted the query, similar to what the the @t{--analyze} option does for
+@t{mu find}.
 
 Additionally, @t{mu4e} supports @kbd{TAB}-completion for queries. There
 there is completion for all search keywords such as @code{and},

From 21d9819eda6444ffa07f8c8c12864d56b6205652 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 7 Jan 2025 22:28:07 +0200
Subject: [PATCH 185/305] NEWS.org: updated

---
 NEWS.org | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/NEWS.org b/NEWS.org
index 21531febf..15bc7b285 100644
--- a/NEWS.org
+++ b/NEWS.org
@@ -62,6 +62,10 @@
   - new command ~mu4e-view-jump-to-mime-part~ for jumping to MIME-part by its
     number.
 
+  - new command ~mu4e-analyze-last-query~ which shows information about how the
+    server interpreted the last query; this can be useful if you don't get the
+    result you expected.
+
 * 1.12 (released on February 24, 2024)
 
 ** Some highlights

From e2cd37eaf55913e055071d7cf15bbdeddb5d27e4 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Mon, 13 Jan 2025 22:11:58 +0200
Subject: [PATCH 186/305] mu-info: add example for ref:, thread:

---
 lib/message/mu-fields.hh | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/message/mu-fields.hh b/lib/message/mu-fields.hh
index afa40362d..62c79e024 100644
--- a/lib/message/mu-fields.hh
+++ b/lib/message/mu-fields.hh
@@ -399,7 +399,7 @@ static constexpr std::array<Field, Field::id_size()>
 		Field::Type::StringList,
 		"references", "ref",
 		"References to related messages",
-		{},
+		"ref:E1rQJDx123@example.com",
 		'r',
 		Field::Flag::Value |
 		Field::Flag::BooleanTerm |
@@ -444,7 +444,7 @@ static constexpr std::array<Field, Field::id_size()>
 		Field::Type::String,
 		"thread", {},
 		"Thread a message belongs to",
-		{},
+		"thread:abcde789@example.com",
 		'w',
 		Field::Flag::BooleanTerm |
 		Field::Flag::Value

From 74108100d69a386cef78f649dc637cebc8610ba7 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Wed, 15 Jan 2025 19:24:32 +0200
Subject: [PATCH 187/305] build: include IDEAS.org, mu4e command

Include the IDEAS.org with installed data; add a command mu4e-ideas.
---
 meson.build       | 5 +++--
 mu4e/meson.build  | 3 ++-
 mu4e/mu4e-main.el | 7 ++++++-
 3 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/meson.build b/meson.build
index e17058476..e8cebe9cd 100644
--- a/meson.build
+++ b/meson.build
@@ -1,4 +1,4 @@
-## Copyright (C) 2022-2024 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+## Copyright (C) 2022-2025 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ##
 ## This program is free software; you can redistribute it and/or modify
 ## it under the terms of the GNU General Public License as published by
@@ -282,7 +282,8 @@ configure_file(input: join_paths(build_aux, 'version.texi.in'),
 
 ################################################################################
 # install some data files
-install_data('NEWS.org', install_dir : join_paths(datadir,'doc', 'mu'))
+install_data('NEWS.org', 'IDEAS.org',
+             install_dir : join_paths(datadir, 'doc', 'mu'))
 
 ################################################################################
 # subdirs
diff --git a/mu4e/meson.build b/mu4e/meson.build
index 664946af3..da3e2daa7 100644
--- a/mu4e/meson.build
+++ b/mu4e/meson.build
@@ -1,4 +1,4 @@
-## Copyright (C) 2022-2024 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+## Copyright (C) 2022-2025 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ##
 ## This program is free software; you can redistribute it and/or modify
 ## it under the terms of the GNU General Public License as published by
@@ -88,6 +88,7 @@ foreach src : mu4e_srcs
   # see: https://debbugs.gnu.org/db/47/47987.html
   configure_file(input: src, output:'@BASENAME@.el', copy:true,
                  install_mode: 'r--r--r--')
+  # seems meson ignores 'install_mode' for copy (1.5.1, 1.6.1)
 
   custom_target(src.underscorify() + '_el',
                 build_by_default: true,
diff --git a/mu4e/mu4e-main.el b/mu4e/mu4e-main.el
index a4c879463..5a04cc7d8 100644
--- a/mu4e/mu4e-main.el
+++ b/mu4e/mu4e-main.el
@@ -89,10 +89,15 @@ the personal addresses."
   (mu4e-info (mu4e-join-paths mu4e-doc-dir "mu4e-about.org")))
 
 (defun mu4e-news ()
-  "Show page with news for the current version of mu4e."
+  "Show news for the current version of mu and mu4e."
   (interactive)
   (mu4e-info (mu4e-join-paths mu4e-doc-dir "NEWS.org")))
 
+(defun mu4e-ideas ()
+  "Show development ideas for mu and mu4e."
+  (interactive)
+  (mu4e-info (mu4e-join-paths mu4e-doc-dir "IDEAS.org")))
+
 (defun mu4e-baseline-time ()
   "Show the baseline time."
   (interactive)

From 29816d595279b20e8ec1d5e05eabc89058435a97 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Wed, 15 Jan 2025 22:02:05 +0200
Subject: [PATCH 188/305] mu4e: improve mu4e--message-is-yours-p

Ensure we can use both from headers view and message view.

This helps with "supersede".
---
 mu4e/mu4e-draft.el | 25 +++++++++++++++++--------
 1 file changed, 17 insertions(+), 8 deletions(-)

diff --git a/mu4e/mu4e-draft.el b/mu4e/mu4e-draft.el
index 884d5d53e..47a72ef14 100644
--- a/mu4e/mu4e-draft.el
+++ b/mu4e/mu4e-draft.el
@@ -1,6 +1,6 @@
 ;;; mu4e-draft.el --- Helpers for m4e-compose -*- lexical-binding: t -*-
 
-;; Copyright (C) 2024 Dirk-Jan C. Binnema
+;; Copyright (C) 2024-2025 Dirk-Jan C. Binnema
 
 ;; Author: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ;; Maintainer: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
@@ -498,12 +498,18 @@ Creates a buffer NAME and returns it."
   (setq mu4e--message-buf (current-buffer)))
 
 (defun mu4e--message-is-yours-p ()
-  "Mu4e's override for `message-is-yours-p'."
-  (seq-some (lambda (field)
-              (if-let* ((recip (message-field-value field)))
-                  (mu4e-personal-or-alternative-address-p
-                   (car (mail-header-parse-address recip)))))
-            '("From" "Sender")))
+  "Did you send the message we're responding to?
+Mu4e's override for `message-is-yours-p'. This only considers the
+From: address, not the Sender: address.
+
+Note that we check the parent, message-at-point so this should
+work both in headers-view and message-view."
+  (seq-some (lambda (addr)
+              (mu4e-personal-or-alternative-address-p addr))
+            (seq-map (lambda (addr) (plist-get addr :email))
+                     (plist-get (or mu4e-compose-parent-message
+                                    (mu4e-message-at-point 'noerror))
+                                :from))))
 
 (defmacro mu4e--validate-hidden-buffer (&rest body)
   "Macro to evaluate BODY and asserts that it yields a valid buffer.
@@ -765,7 +771,10 @@ but note the different order."
    (lambda ()
      (let ( ;; only needed for Fwd. Gnus has a bad default.
            (message-make-forward-subject-function
-            (list #'message-forward-subject-fwd)))
+            (list #'message-forward-subject-fwd))
+           ;; e.g. supersede needs parent for 'message-is-yours-p
+           (mu4e-compose-parent-message parent)
+           (mu4e-compose-type compose-type))
        (insert (mu4e--decoded-message parent))
        ;; let's make sure we don't use message-reply-headers from
        ;; some unrelated message.

From a93a41f8ee8f5144069d8a7e9bcd7d0b76cc6ed8 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Wed, 15 Jan 2025 23:02:47 +0200
Subject: [PATCH 189/305] mu4e: implement experimental transient menu

Add a first version of a "transient" menu for mu4e. It's just a starting
point. It's not yet bound to any key, but you could e.g. add

(require 'mu4e-transient)
(global-set-key (kbd "C-c m") #'mu4e-transient-menu)
---
 meson.build            |  3 +-
 mu4e/meson.build       |  7 ++++
 mu4e/mu4e-transient.el | 80 ++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 89 insertions(+), 1 deletion(-)
 create mode 100644 mu4e/mu4e-transient.el

diff --git a/meson.build b/meson.build
index e8cebe9cd..071a63f7b 100644
--- a/meson.build
+++ b/meson.build
@@ -294,8 +294,9 @@ subdir('mu')
 # emacs -- needed for mu4e compilation
 emacs_name=get_option('emacs')
 emacs_min_version='26.3'
-emacs=find_program([emacs_name], version: '>='+emacs_min_version, required:false)
+emacs=find_program([emacs_name], version: '>=' + emacs_min_version, required:false)
 if emacs.found()
+  emacs28 = find_program([emacs_name], version: '>=28', required:false)
   subdir('man')
   subdir('mu4e')
 else
diff --git a/mu4e/meson.build b/mu4e/meson.build
index da3e2daa7..cfccce12d 100644
--- a/mu4e/meson.build
+++ b/mu4e/meson.build
@@ -72,6 +72,13 @@ mu4e_srcs=[
   'mu4e-window.el'
 ]
 
+# emacs 28 is guaranteed to have transient
+# not very elegant, but
+# https://stackoverflow.com/questions/49221792/byte-compile-file-only-when-library-is-found
+if emacs28.found()
+  mu4e_srcs += 'mu4e-transient.el'
+endif
+
 # note, we cannot compile mu4e-config.el without incurring
 #  WARNING: Source item
 #   '[...]/build/mu4e/mu4e-meta.el' cannot be converted to File object, because
diff --git a/mu4e/mu4e-transient.el b/mu4e/mu4e-transient.el
new file mode 100644
index 000000000..83226741a
--- /dev/null
+++ b/mu4e/mu4e-transient.el
@@ -0,0 +1,80 @@
+;;; mu4e-transient.el --- -*- coding: utf-8; lexical-binding: t -*-
+;;
+;; Copyright (C) 2025 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+
+;;; Commentary:
+;;;
+;;; Define "transients" for some mu4e menus.
+
+;;; Code:
+(require 'mu4e)
+(require 'mu4e-bookmarks)
+(require 'mu4e-compose)
+(require 'mu4e-draft)
+
+(require 'transient)
+
+(transient-define-prefix mu4e-transient-menu-docs-links()
+  "Mu4e documentation menu."
+  [["Documentation"
+    ("A" "About mu4e"          mu4e-about)
+    ("N" "News"                mu4e-news)
+    ("I" "Ideas"               mu4e-ideas)
+    ("H" "Manual"              mu4e-display-manual)
+    ("o" "Online manual" (lambda ()  (interactive)
+                           (browse-url "https://www.djcbsoftware.nl/code/mu/mu4e/")))]
+   ["Links"
+    ("h" "Mu homepage"  (lambda () (interactive)
+                          (browse-url "https://www.djcbsoftware.nl/code/mu/")))
+    ("m" "Mu4e homepage" (lambda () (interactive)
+                           (browse-url "https://www.djcbsoftware.nl/code/mu/")))
+    ("r" "Mu repository" (lambda ()  (interactive)
+                           (browse-url "https://github.com/djcb/mu/")))
+    ("o" "Mu Issues"     (lambda ()  (interactive)
+                           (browse-url "https://github.com/djcb/mu/issues")))]])
+
+(transient-define-prefix mu4e-transient-menu-debug()
+  "Mu4e debugging menu."
+  [["Debugging"
+    ("$" "Toggle logging" mu4e-toggle-logging)
+    ("," "Message sexp"   mu4e-sexp-at-point
+     :inapt-if-not (lambda () (mu4e-message-at-point 'nowarn)))
+    ("l" "Last query sexp" mu4e-analyze-last-query)]])
+
+(transient-define-prefix mu4e-transient-menu()
+  "Mu4e main menu."
+  [["Basics"
+    ("M" "Main menu"           mu4e)
+    ("U" "Update mail"         mu4e-update-mail-and-index)
+    (";" "Switch context"      mu4e-context-switch
+     :inapt-if-nil mu4e-contexts)
+    ("M-q" "Quit mu4e"         mu4e-quit)]
+   ["Search"
+    ("b" "Bookmark"            mu4e-search-bookmark)
+    ("j" "Maildir"             mu4e-search-maildir)
+    ("c" "Choose query"        mu4e-search-query)
+    ("s" "Search"              mu4e-search-query)]
+   ["Composition"
+    ("C" "New mail"            mu4e-compose-new)]
+   ["" ;; composition that requires an existing message
+    :if           (lambda () (memq major-mode '(mu4e-headers-mode mu4e-view-mode)))
+    :inapt-if-not (lambda () (mu4e-message-at-point 'nowarn))
+    ("R" "Reply"               mu4e-compose-reply)
+    ("W" "Reply-to-all"        mu4e-compose-wide-reply)
+    ("F" "Forward"             mu4e-compose-forward)
+    ;; only draft messages can be edited
+    ("E" "Edit draft"          mu4e-compose-edit
+     :inapt-if-not (lambda ()
+           (member 'draft
+                   (mu4e-message-field
+                    (mu4e-message-at-point 'nowarn) :flags))))
+    ;; you can only supersede your own messages
+    ("S" "Supersede"           mu4e-compose-supersede
+     :inapt-if-not mu4e--message-is-yours-p)
+    ("X" "Resend"          mu4e-compose-resend)]
+   ["Misc"
+    ("d" "Docs & links"    mu4e-transient-menu-docs-links)
+    ("D" "Debugging"       mu4e-transient-menu-debug)]])
+
+(provide 'mu4e-transient)
+;;; mu4e-transient.el ends here

From 5ab6d6c6c35bf7c6ee0fc58fda70946943fa0cf1 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Mon, 20 Jan 2025 20:40:21 +0200
Subject: [PATCH 190/305] mu-find: use correct summary-len

---
 mu/mu-cmd-find.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mu/mu-cmd-find.cc b/mu/mu-cmd-find.cc
index cd48e8fc0..ba7f779cd 100644
--- a/mu/mu-cmd-find.cc
+++ b/mu/mu-cmd-find.cc
@@ -347,7 +347,7 @@ output_plain(const Option<Message>& msg, const OutputInfo& info,
 
 	output_plain_fields(*msg, opts.find.fields, !opts.nocolor, opts.find.threads);
 
-	if (opts.view.summary_len)
+	if (opts.find.summary_len)
 		print_summary(*msg, opts);
 
 	return Ok();

From 71101c3ee47d66acfd32a089e7d2f0bd75adbfeb Mon Sep 17 00:00:00 2001
From: Joseph Turner <joseph@breatheoutbreathe.in>
Date: Sat, 21 Dec 2024 12:54:31 -0800
Subject: [PATCH 191/305] mu4e-org: autoload org-link-set-parameters

With this change, mu4e: links now load mu4e if it wasn't loaded already.
---
 mu4e/mu4e-org.el | 1 +
 1 file changed, 1 insertion(+)

diff --git a/mu4e/mu4e-org.el b/mu4e/mu4e-org.el
index be24e3286..97348c120 100644
--- a/mu4e/mu4e-org.el
+++ b/mu4e/mu4e-org.el
@@ -142,6 +142,7 @@ it with org)."
   (org-capture))
 
 ;; install mu4e-link support.
+;;;###autoload
 (org-link-set-parameters "mu4e"
                          :follow #'mu4e-org-open
                          :store  #'mu4e-org-store-link)

From b8bb92241b21e3a69e653dca1bcb676730e1c0c4 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Thu, 23 Jan 2025 08:38:55 +0200
Subject: [PATCH 192/305] mu4e: add autoload cookie for mu4e-org-store-link

---
 mu4e/mu4e-org.el | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/mu4e/mu4e-org.el b/mu4e/mu4e-org.el
index 97348c120..03932bb11 100644
--- a/mu4e/mu4e-org.el
+++ b/mu4e/mu4e-org.el
@@ -104,6 +104,7 @@ If MSG is non-nil, store a link to MSG, otherwise use `mu4e-message-at-point'."
                   :description       ,(funcall mu4e-org-link-desc-func msg))))
     (apply #'mu4e--org-link-store-props props)))
 
+;;;###autoload
 (defun mu4e-org-store-link ()
   "Store a link to a mu4e message or query.
 It links to the last known query when in `mu4e-headers-mode' with
@@ -133,6 +134,7 @@ the query (for links starting with \"query:\")."
     (mu4e-search (match-string 1 link) current-prefix-arg))
    (t (mu4e-error "Unrecognized link type '%s'" link))))
 
+;;;###autoload
 (defun mu4e-org-store-and-capture ()
   "Store a link to the current message or query.
 \(depending on `mu4e-org-link-query-in-headers-mode', and capture

From 87b1e8e0bfd22c2814dcc60fd5108a4c07fe0ece Mon Sep 17 00:00:00 2001
From: Joseph Turner <joseph@breatheoutbreathe.in>
Date: Wed, 22 Jan 2025 22:18:16 -0800
Subject: [PATCH 193/305] mu4e-compose: fix docstring

---
 mu4e/mu4e-compose.el | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mu4e/mu4e-compose.el b/mu4e/mu4e-compose.el
index 570f1afce..d1c4dade5 100644
--- a/mu4e/mu4e-compose.el
+++ b/mu4e/mu4e-compose.el
@@ -86,7 +86,7 @@ by sending, postponing, exiting or killing it.
 This multiplexes the `message-mode' hooks `message-send-actions',
 `message-postpone-actions', `message-exit-actions' and
 `message-kill-actions', and the hook is run with a variable
-`mu4e-compose-post-trigger' set correspondingly to a symbol,
+`mu4e-message-post-action' set correspondingly to a symbol,
 `send', `postpone', `exit' or `kill'."
   :type 'hook
   :group 'mu4e-compose)

From 8e33657cc74e1bb8aede41da3d1958a1a932501a Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Thu, 23 Jan 2025 14:00:40 +0200
Subject: [PATCH 194/305] mu4e: remove autoload cookie for
 org-link-set-parameters

Seems it causes problems.
---
 mu4e/mu4e-org.el | 1 -
 1 file changed, 1 deletion(-)

diff --git a/mu4e/mu4e-org.el b/mu4e/mu4e-org.el
index 03932bb11..47dbc9b01 100644
--- a/mu4e/mu4e-org.el
+++ b/mu4e/mu4e-org.el
@@ -144,7 +144,6 @@ it with org)."
   (org-capture))
 
 ;; install mu4e-link support.
-;;;###autoload
 (org-link-set-parameters "mu4e"
                          :follow #'mu4e-org-open
                          :store  #'mu4e-org-store-link)

From 82fd77c3ededcff419aa06ee306dd6c8f7c4801a Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Thu, 23 Jan 2025 21:36:02 +0200
Subject: [PATCH 195/305] mu4e-transient: update

Still experimental, but a few improvements.
---
 mu4e/mu4e-transient.el | 116 +++++++++++++++++++++++++++++++++++------
 1 file changed, 100 insertions(+), 16 deletions(-)

diff --git a/mu4e/mu4e-transient.el b/mu4e/mu4e-transient.el
index 83226741a..6877bc38d 100644
--- a/mu4e/mu4e-transient.el
+++ b/mu4e/mu4e-transient.el
@@ -4,17 +4,52 @@
 
 ;;; Commentary:
 ;;;
-;;; Define "transients" for some mu4e menus.
+;;; Define "transients" for some mu4e functionality.
 
 ;;; Code:
 (require 'mu4e)
 (require 'mu4e-bookmarks)
 (require 'mu4e-compose)
 (require 'mu4e-draft)
+(require 'mu4e-headers)
+(require 'mu4e-helpers)
 
 (require 'transient)
 
-(transient-define-prefix mu4e-transient-menu-docs-links()
+;; Helpers.
+
+(defun mu4e--toggle-description(name val)
+  "Return a string for a transient toggle with NAME.
+Show On/Off based on value VAL."
+  (concat name " "
+          (propertize (if val "On " "Off")
+                      'face 'transient-value)))
+
+(defmacro mu4e--define-toggle-suffix (name symbol &optional toggle-func)
+  "Define a transient suffix to toggle some value.
+Show the suffix with NAME. SYMBOL is the symbol for the value to
+toggle.
+
+TOGGLE-FUNC is the function to do the toggling. If nil, a simple
+toggle-function is created."
+  (let* ((symname (symbol-name symbol))
+         (ifname (intern (format "mu4e--suffix-toggle-%s" symname)))
+         (docstring (format "Toggle the value of `%s'" symname))
+         (toggle-func (or toggle-func
+                          `(lambda ()
+                             (interactive)
+                             (setq ,symbol (not ,symbol))))))
+    `(progn
+       (transient-define-suffix ,ifname () ,docstring
+         :transient t
+         :if (lambda () (boundp (quote ,symbol)))
+         :description (lambda () (mu4e--toggle-description ,name ,symbol))
+         (interactive)
+         (call-interactively ,toggle-func)))))
+
+;; Transients
+
+(transient-define-prefix mu4e--prefix-docs-links()
   "Mu4e documentation menu."
   [["Documentation"
     ("A" "About mu4e"          mu4e-about)
@@ -33,13 +68,58 @@
     ("o" "Mu Issues"     (lambda ()  (interactive)
                            (browse-url "https://github.com/djcb/mu/issues")))]])
 
-(transient-define-prefix mu4e-transient-menu-debug()
-  "Mu4e debugging menu."
-  [["Debugging"
-    ("$" "Toggle logging" mu4e-toggle-logging)
+(mu4e--define-toggle-suffix "Debug client" mu4e-debug #'mu4e-toggle-logging)
+(mu4e--define-toggle-suffix "Debug server" mu4e-mu-debug)
+(mu4e--define-toggle-suffix "Report render-time" mu4e-headers-report-render-time)
+(mu4e--define-toggle-suffix "Temp-file optimization" mu4e-mu-allow-temp-file)
+
+(transient-define-prefix mu4e--prefix-debug-tweaks()
+  "Mu4e debugging and tweaks menu."
+  [["Debug"
+    ("$" mu4e--suffix-toggle-mu4e-debug)
+    ("r" mu4e--suffix-toggle-mu4e-headers-report-render-time)
+    ("L" "Toggle logging" mu4e-toggle-logging)
+    ("l" "Log buffer" mu4e-show-log)]
+   ["Info"
     ("," "Message sexp"   mu4e-sexp-at-point
      :inapt-if-not (lambda () (mu4e-message-at-point 'nowarn)))
-    ("l" "Last query sexp" mu4e-analyze-last-query)]])
+    ("a" "Analyze query" mu4e-analyze-last-query)
+    ("c" "Known contacts"  mu4e-contacts-info)]
+   ["Server (needs restart)"
+    ("d" mu4e--suffix-toggle-mu4e-mu-debug)
+    ("t" mu4e--suffix-toggle-mu4e-mu-allow-temp-file)]])
+
+(mu4e--define-toggle-suffix "format=flowed" mu4e-compose-format-flowed)
+(mu4e--define-toggle-suffix "Forward as MIME" message-forward-as-mime)
+
+;; (transient-define-suffix mu4e--suffix-message-forward-show-mml (args)
+;;   "Show MML when forwarding?
+;; See `message-forward-show-mml' for details."
+;;   :transient t
+;;   :description (lambda ()
+;;                  (let ((val (pcase message-forward-as-mime
+;;                               ('nil "Off")
+;;                               ('best "Best")
+;;                               (_    "On")))))
+;;                  (concat "Show MML "
+;;                          (propertize  val 'face 'transient-value)))
+;;   ;;:choices '("On" "Off" "Best")
+
+;;   )
+
+;;(setq message-forward-as-mime 'best)
+
+;;(mu4e--define-toggle-suffix "Show MML"  message-forward-show-mml)
+
+(transient-define-prefix mu4e--prefix-compose-options()
+  "Mu4e debugging menu."
+  [["Formatting"
+    ("f" mu4e--suffix-toggle-mu4e-compose-format-flowed)]
+   ["Forwarding"
+    ("m" mu4e--suffix-toggle-message-forward-as-mime)
+    ;; handle 'best'
+    ;;("M" mu4e--suffix-toggle-message-forward-show-mml)
+    ]])
 
 (transient-define-prefix mu4e-transient-menu()
   "Mu4e main menu."
@@ -53,28 +133,32 @@
     ("b" "Bookmark"            mu4e-search-bookmark)
     ("j" "Maildir"             mu4e-search-maildir)
     ("c" "Choose query"        mu4e-search-query)
-    ("s" "Search"              mu4e-search-query)]
+    ("s" "Search"              mu4e-search)]
    ["Composition"
-    ("C" "New mail"            mu4e-compose-new)]
+    ("C" "New mail"            mu4e-compose-new)
+    ("o" "Options..."          mu4e--prefix-compose-options)
+    ]
    ["" ;; composition that requires an existing message
-    :if           (lambda () (memq major-mode '(mu4e-headers-mode mu4e-view-mode)))
-    :inapt-if-not (lambda () (mu4e-message-at-point 'nowarn))
+    :if           (lambda ()
+                    (memq major-mode '(mu4e-headers-mode mu4e-view-mode)))
+    :inapt-if-not (lambda ()
+                    (mu4e-message-at-point 'nowarn))
     ("R" "Reply"               mu4e-compose-reply)
     ("W" "Reply-to-all"        mu4e-compose-wide-reply)
     ("F" "Forward"             mu4e-compose-forward)
     ;; only draft messages can be edited
     ("E" "Edit draft"          mu4e-compose-edit
      :inapt-if-not (lambda ()
-           (member 'draft
-                   (mu4e-message-field
-                    (mu4e-message-at-point 'nowarn) :flags))))
+                     (member 'draft
+                             (mu4e-message-field
+                              (mu4e-message-at-point 'nowarn) :flags))))
     ;; you can only supersede your own messages
     ("S" "Supersede"           mu4e-compose-supersede
      :inapt-if-not mu4e--message-is-yours-p)
     ("X" "Resend"          mu4e-compose-resend)]
    ["Misc"
-    ("d" "Docs & links"    mu4e-transient-menu-docs-links)
-    ("D" "Debugging"       mu4e-transient-menu-debug)]])
+    ("d" "Docs & links"      mu4e--prefix-docs-links)
+    ("D" "Debug/tweaks..."   mu4e--prefix-debug-tweaks)]])
 
 (provide 'mu4e-transient)
 ;;; mu4e-transient.el ends here

From 6e07c1f0c756f5c852a5cbd43ba4e79f795ce1a9 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Thu, 23 Jan 2025 20:35:41 +0200
Subject: [PATCH 196/305] mu4e.texi: mention transient + update bug info

---
 mu4e/mu4e.texi | 33 ++++++++++++++++++++++++++++++---
 1 file changed, 30 insertions(+), 3 deletions(-)

diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index 0ea7db2db..0d1da2271 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -195,13 +195,27 @@ have some idea on how it could work better. To report this, you can use the
 following information:
 
 @itemize
-@item what did you expect or wish to happen? what actually happened?
-@item can you provide some exact steps to reproduce?
-@item what version of @t{mu4e} and @t{emacs} were you using? What operating system?
+@item What did you expect or wish to happen? what actually happened?
+Please describe in detail what you saw. Also, try some related scenarios and
+whether the problem either @emph{always} happens, or only @emph{sometimes}.
+E.g., it might happen with only one particular type of message
+@item Provide some exact steps to reproduce?
+In particular, some minimal steps, starting from @t{emacs -Q} and with minimal
+configuration. If the problem is easily producible, it may be easily fixable as
+well; but if it's some subtle interaction in a highly complex setup, we cannot
+do much.
+@item hat version of @t{mu4e} and @t{emacs} were you using? What operating system?
+Always try with up-to-date versions. And please use the 'normal' @t{mu4e} for
+reproducing your problem, not the ``remix'' version that some Emacs
+``distributions'' use, such as ``Doom Emacs''.
 @item can you reproduce it with @command{emacs -q} and only loading @t{mu4e}?
 @item if the problem is related to some specific message, please include the raw message file (appropriately anonymized, of course)
 @end itemize
 
+In general, imagine you would be the person receiving the bug-report, and think
+about the information you would need to diagnose the problem.
+
+
 @node Getting started
 @chapter Getting started
 
@@ -3253,6 +3267,7 @@ ways. Here we focus on Emacs built-ins; for dealing with external tools,
 @menu
 * Default email client::Making mu4e the default emacs e-mail program
 * Modeline::Showing mu4e's status in the modeline
+* Transient::Transient menus for mu4e
 * Desktop notifications::Get desktop notifications for new mail
 * Emacs bookmarks::Using Emacs' bookmark system
 * Eldoc::Information about the current header in the echo area
@@ -3353,6 +3368,18 @@ you read messages; but going back to the main view (with @kbd{M-x mu4e} resets
 the counts to latest known ones. When in the main-view, you can use
 @code{revert-buffer} (@kbd{g}) to reset the counters explicitly.
 
+@node Transient
+@section Transient
+@cindex transient
+
+@t{mu4e} has experimental support for the ``transient'' menus, as per
+@xref{(transient) Top}. Because ``transient'' is not automatically available in
+all Emacs version that @t{mu4e} support, you need to manually enable it:
+@lisp
+(when (require 'mu4e-transient nil 'noerror)
+  (global-set-key (kbd "C-c m")  mu  #'mu4e-transient-menu))
+@end lisp
+
 @node Desktop notifications
 @section Desktop notifications
 @cindex desktop notifications

From 1ceefa45e7525726c627b7e68ba6aed88d9b0774 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Thu, 23 Jan 2025 21:44:28 +0200
Subject: [PATCH 197/305] IDEAS.org: update

---
 IDEAS.org | 56 ++++++++++++++++++++++++++++++-------------------------
 1 file changed, 31 insertions(+), 25 deletions(-)

diff --git a/IDEAS.org b/IDEAS.org
index 3fc37c35e..1b5806d81 100644
--- a/IDEAS.org
+++ b/IDEAS.org
@@ -5,6 +5,33 @@ Ideas for future enhancements. We collect those here so they don't clutter up
 the Github issue list, i.e. without any clear plan for adding in the near
 future.
 
+** mu
+
+- Support indexing PDF (and other) attachments. This can be done extending
+  process_message_part in mu-message.cc; instead of using something
+  PDF-specific, we could pipe a PDF through some tool to extract text; and we'd
+  need some way for users to specify a MIME-type => tool mapping  (in Config).
+  https://github.com/djcb/mu/issues/2117
+
+- Include "message summary" in message information, for display in the headers
+  buffer: https://github.com/djcb/mu/issues/1821 It's not so easy to get a
+  useful one line description... perhaps the first line after the "Dear x,"?
+  Moreover, this requires new functionality on the headers-view side as well.
+
+- Try to guess the encodings; sometimes people send messages that e.g., claim
+  they are ISO-8859-1 but actually use windows-1252, resulting in some
+  characters being shown incorrectly. Perhaps best solved by GMime, but maybe mu
+  can do something. https://github.com/djcb/mu/issues/2700
+
+- More sorting options: in mu4e, display the messages from old-to-new (still get
+  the newest though) https://github.com/djcb/mu/issues/2759. Or, from
+  new-to-old, reversed in thread: https://github.com/djcb/mu/issues/2807
+
+- perhaps use =--personal-addres= instead of =--my-address= for consistency
+  https://github.com/djcb/mu/issues/2806
+
+** mu4e
+
 - Support automatic handling for List-Unsubscribe headers and more in general,
   handle mailing-list commands https://github.com/djcb/mu/issues/2623 and
   https://github.com/djcb/mu/issues/2724 This seems useful, but probably
@@ -19,38 +46,14 @@ future.
   https://github.com/djcb/mu/issues/2308
   Shouldn't be _too_ hard, for someone that uses the functionality.
 
-- Include "message summary" in message information, for display in the headers
-  buffer: https://github.com/djcb/mu/issues/1821 It's not so easy to get a
-  useful one line description... perhaps the first line after the "Dear x,"?
-  Moreover, this requires new functionality on the headers-view side as well.
-
-- Support indexing PDF (and other) attachments. This can be done extending
-  process_message_part in mu-message.cc; instead of using something
-  PDF-specific, we could pipe a PDF through some tool to extract text; and we'd
-  need some way for users to specify a MIME-type => tool mapping  (in Config).
-  https://github.com/djcb/mu/issues/2117
-
 - Support "aggregate actions" apply to a set of messages, e.g. apply patch-set
   in a set of messages. That'll require some advanced scripting, maybe using
   Guile.
   https://github.com/djcb/mu/issues/301
   https://github.com/djcb/mu/issues/2704
 
-- Try to guess the encodings; sometimes people send messages that e.g., claim
-  they are ISO-8859-1 but actually use windows-1252, resulting in some
-  characters being shown incorrectly. Perhaps best solved by GMime, but maybe mu
-  can do something. https://github.com/djcb/mu/issues/2700
-
-- Revamp the Guile support; mu has support Guile scripting for a long time, but
-  it's gone a bit stale, and the API is not very nice. It'd be nice to revamp
-  this support, so it becomes more widely useful.
-  https://github.com/djcb/mu/issues/1982
-
-- Display the messages from old-to-new (still get the newest though)
-  https://github.com/djcb/mu/issues/2759
-
 - Make sorting stable if there are multiple messages with the same date. We
-  _could_ do this by adding some random millisecs to each messasge's timestamp; _or_
+  _could_ do this by adding some random millisecs to each message's timestamp; _or_
   complicating the search (i.e., the message hash?). Maybe leave as is?
   https://github.com/djcb/mu/issues/2527
 
@@ -67,6 +70,9 @@ future.
   ~gnus-summary-work-articles~ etc.).
   https://github.com/djcb/mu/issues/2799
 
+- Add some way to add a quick bookmark for (e.g.)  the current thread
+  https://github.com/djcb/mu/issues/2804
+
 * Done
 
 - Support mu4e-mark-handle-when also for when leaving emacs

From 9fdfd61a3ce475500819f0aece7b4b982629589c Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 25 Jan 2025 00:19:39 +0200
Subject: [PATCH 198/305] mu4e.el: cosmetics

---
 mu4e/mu4e.el | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/mu4e/mu4e.el b/mu4e/mu4e.el
index 621b21d12..05947590e 100644
--- a/mu4e/mu4e.el
+++ b/mu4e/mu4e.el
@@ -1,6 +1,6 @@
 ;;; mu4e.el --- Mu4e, the mu mail user agent -*- lexical-binding: t -*-
 
-;; Copyright (C) 2011-2024 Dirk-Jan C. Binnema
+;; Copyright (C) 2011-2025 Dirk-Jan C. Binnema
 
 ;; Author: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ;; Maintainer: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
@@ -45,7 +45,6 @@
 (require 'mu4e-notification)
 (require 'mu4e-server)     ;; communication with backend
 
-
 
 (when mu4e-speedbar-support
   (require 'mu4e-speedbar)) ;; support for speedbar
@@ -56,7 +55,6 @@
 ;; desktop-save-mode; so let's turn that off.
 (with-eval-after-load 'desktop
   (eval '(add-to-list 'desktop-modes-not-to-save 'mu4e-compose-mode)))
-
 
 ;;;###autoload
 (defun mu4e (&optional background)
@@ -86,7 +84,6 @@ Otherwise, completely quit mu4e, including automatic updating."
         (when (y-or-n-p (mu4e-format "Are you sure you want to quit?"))
           (mu4e--stop))
       (mu4e--stop))))
-
 ;;; Internals
 
 (defun mu4e--check-requirements ()
@@ -191,7 +188,7 @@ Otherwise, check requirements, then start mu4e. When successful, invoke
                        '(mu4e-headers-mode mu4e-view-mode mu4e-main-mode))
            (kill-buffer)))))
    (buffer-list)))
-
+
 ;;; Handlers
 (defun mu4e--default-handler (&rest args)
   "Dummy handler function with arbitrary ARGS."

From a33530e9179743bea41d06b248cdb9be4f2e5e9f Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 25 Jan 2025 14:58:58 +0200
Subject: [PATCH 199/305] mu.1.org: update COLOR information

---
 man/mu.1.org | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/man/mu.1.org b/man/mu.1.org
index d3b949841..80f36290e 100644
--- a/man/mu.1.org
+++ b/man/mu.1.org
@@ -54,8 +54,14 @@ man-page as well.
 
 * COLORS
 
-Some *mu* commands support colorized output, and do so by default. If you don't
-want colors, you can use *--nocolor*.
+Some *mu* commands support colorized output, and do so by default when writing to
+a TTY (roughly, to a screen). When not writing to a TTY, for instance when
+redirection the output to a file or using a pipe, the default is to *not* show
+output.
+
+If you don no want colors, you can use *--nocolor*.
+
+If you want colors even when it is not the default, use *--nocolor=false*.
 
 * ENCODING
 

From 7f76c69879f1f07a34e25946d56e340bb2a477d7 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 25 Jan 2025 15:23:34 +0200
Subject: [PATCH 200/305] mu4e: auto start mu4e when sending command

Start mu4e if not already; with the transient menus it's easier possible
to try to do things with mu4e before it is started, so handle that
automatically.
---
 mu4e/mu4e-server.el | 14 +++++++-------
 mu4e/mu4e.el        |  8 ++++++--
 2 files changed, 13 insertions(+), 9 deletions(-)

diff --git a/mu4e/mu4e-server.el b/mu4e/mu4e-server.el
index 02942af3e..bdf32f4f4 100644
--- a/mu4e/mu4e-server.el
+++ b/mu4e/mu4e-server.el
@@ -211,11 +211,6 @@ It is the mu4e-version of \"mu find <query> --analyze\"."
    mu4e--last-query-buffer-name
    (mu4e-server-last-query)))
 
-;; temporary
-(defun mu4e--server-xapian-single-threaded-p()
-  "Are we using Xapian in single-threaded mode?"
-  (plist-get mu4e--server-props :xapian-single-threaded))
-
 ;;; Handling raw server data
 
 (defvar mu4e--server-buf nil
@@ -300,7 +295,6 @@ This for the few sexps we get from the mu server that support
           (read (current-buffer)))
       val)))
 
-
 (defun mu4e--server-filter (_proc str)
   "Filter string STR from PROC.
 This processes the \"mu server\" output. It accumulates the
@@ -565,12 +559,18 @@ You cannot run the repl when mu4e is running (or vice-versa)."
      (t
       (error "Something bad happened to the mu server process")))))
 
+(declare-function mu4e "mu4e")
+(defvar mu4e--initialized)
+
 (defun mu4e--server-call-mu (form)
   "Call the mu server with some command FORM."
+  (unless mu4e--initialized
+    (mu4e 'background))
+  ;; ensure the server is running as well
   (unless (mu4e-running-p)
     (mu4e--server-start))
   ;; in single-threaded mode, mu can't accept our command right now.
-  (when (and (mu4e--server-xapian-single-threaded-p) mu4e--server-indexing)
+  (when mu4e--server-indexing
     (mu4e-message "Cannot handle command while indexing, please retry later."))
   (let* ((print-length nil) (print-level nil)
          (cmd (format "%S" form)))
diff --git a/mu4e/mu4e.el b/mu4e/mu4e.el
index 05947590e..a89ea4d87 100644
--- a/mu4e/mu4e.el
+++ b/mu4e/mu4e.el
@@ -56,13 +56,16 @@
 (with-eval-after-load 'desktop
   (eval '(add-to-list 'desktop-modes-not-to-save 'mu4e-compose-mode)))
 
+(defvar mu4e--initialized nil
+  "Is mu4e initialized? Only needed once per session.")
+
 ;;;###autoload
 (defun mu4e (&optional background)
   "If mu4e is not running yet, start it.
 Then, show the main window, unless BACKGROUND (prefix-argument)
 is non-nil."
   (interactive "P")
-  (if (not (mu4e-running-p))
+  (if (not mu4e--initialized)
       (progn
         (mu4e--init-handlers)
         (mu4e--start (unless background #'mu4e--main-view)))
@@ -148,12 +151,13 @@ Otherwise, check requirements, then start mu4e. When successful, invoke
   (mu4e-modeline-mode (if mu4e-modeline-support 1 -1))
   ;; redraw main buffer if there is one.
   (add-hook 'mu4e-query-items-updated-hook #'mu4e--main-redraw)
-  (mu4e--query-items-refresh 'reset-baseline)
+  (setq mu4e--initialized t) ;; last before we call the server.
   (mu4e--server-ping)
   ;; ask for the maildir-list
   (mu4e--server-data 'maildirs)
   ;; maybe request the list of contacts, automatically refreshed after
   ;; re-indexing
+  (mu4e--query-items-refresh 'reset-baseline)
   (unless mu4e--contacts-set
     (mu4e--request-contacts-maybe)))
 

From 09965b2d09cffc02dd1f22da66cd138813127905 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 2 Feb 2025 11:38:32 +0200
Subject: [PATCH 201/305] test: add unit-tests for related/new/skip-dups

Test the interaction between related/new/skipped-duplicates. Seems to
work as expected.
---
 lib/tests/test-mu-store-query.cc | 72 +++++++++++++++++++++++++++++++-
 1 file changed, 71 insertions(+), 1 deletion(-)

diff --git a/lib/tests/test-mu-store-query.cc b/lib/tests/test-mu-store-query.cc
index ca4273b47..c79c43f16 100644
--- a/lib/tests/test-mu-store-query.cc
+++ b/lib/tests/test-mu-store-query.cc
@@ -1,5 +1,5 @@
 /*
-** Copyright (C) 2022-2024 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2022-2025 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify it
 ** under the terms of the GNU General Public License as published by the
@@ -422,6 +422,74 @@ Child
 	}
 }
 
+static void
+test_dups_related_new()
+{
+	TestMap test_msgs;
+/* child (dup vv) */
+	test_msgs.insert({"inbox/new/msg2:1,S",
+			 R"(Message-Id: <edcba@foo.bar>
+In-Reply-To: <abcde@foo.bar>
+From: "Foo Example" <bar@example.com>
+Date: Sat, 06 Aug 2022 13:01:54 -0700
+To: example@example.com
+Subject: Re: test1
+
+Child
+)"});
+	test_msgs.insert({"inbox/new/msg3:1,S",
+R"(Message-Id: <edcba@foo.bar>
+In-Reply-To: <abcde@foo.bar>
+From: "Foo Example" <bar@example.com>
+Date: Sat, 06 Aug 2022 13:01:54 -0700
+To: example@example.com
+Subject: Re: test1
+
+Child
+)"});
+/* child (dup ^^); different file  */
+
+       TempDir tdir;
+       const auto store{make_test_store(tdir.path(), test_msgs, {})};
+	{
+		auto qr = store.run_query("flag:new", Field::Id::Date,
+					  QueryFlags::None);
+		g_assert_true(!!qr);
+		g_assert_false(qr->empty());
+		g_assert_cmpuint(qr->size(), ==, 2);
+	}
+
+	{
+		// direct matches
+		auto qr = store.run_query("flags:new", Field::Id::Date,
+					  QueryFlags::SkipDuplicates);
+		g_assert_true(!!qr);
+		g_assert_false(qr->empty());
+		g_assert_cmpuint(qr->size(), ==, 1);
+	}
+
+	{
+		// direct matches
+		auto qr = store.run_query("flags:new", Field::Id::Date,
+					  QueryFlags::IncludeRelated);
+		g_assert_true(!!qr);
+		g_assert_false(qr->empty());
+		g_assert_cmpuint(qr->size(), ==, 2);
+	}
+
+
+	{
+		// direct matches
+		auto qr = store.run_query("flags:new", Field::Id::Date,
+					  QueryFlags::SkipDuplicates | QueryFlags::IncludeRelated);
+		g_assert_true(!!qr);
+		g_assert_false(qr->empty());
+		g_assert_cmpuint(qr->size(), ==, 1);
+	}
+
+}
+
+
 
 static void
 test_related_missing_root()
@@ -972,6 +1040,8 @@ main(int argc, char* argv[])
 			test_related);
 	g_test_add_func("/store/query/dups-related",
 			test_dups_related);
+	g_test_add_func("/store/query/dups-related-new",
+			test_dups_related_new);
 	g_test_add_func("/store/query/related-missing-root",
 			test_related_missing_root);
 	g_test_add_func("/store/query/body-matricula",

From c6f9820d19f5a3fca0dda621a4a160af795493c4 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 2 Feb 2025 12:09:03 +0200
Subject: [PATCH 202/305] mu4e-window: fix typo

---
 mu4e/mu4e-window.el | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/mu4e/mu4e-window.el b/mu4e/mu4e-window.el
index a172144de..5a3c7f149 100644
--- a/mu4e/mu4e-window.el
+++ b/mu4e/mu4e-window.el
@@ -369,7 +369,7 @@ This function is best called from the hook
   (unless (mu4e-current-buffer-type-p 'view)
     (mu4e-error "Cannot resize as this is not a valid view buffer"))
   (when-let* ((win (and mu4e-linked-headers-buffer
-                          (get-buffer-window mu4e-linked-headers-buffer)))
+                        (get-buffer-window mu4e-linked-headers-buffer))))
     ;; This can fail for any number of reasons. If it does, we do
     ;; nothing. If the user has customized the window display we may
     ;; find it impossible to resize the window, and that should not be
@@ -380,7 +380,7 @@ This function is best called from the hook
                                    (window-width win nil))
                             t t nil))
             ((eq mu4e-split-view 'horizontal)
-             (set-window-text-height win mu4e-headers-visible-lines)))))))
+             (set-window-text-height win mu4e-headers-visible-lines))))))
 
 (provide 'mu4e-window)
 ;;; mu4e-window.el ends here

From 08732dab681b18b0ddb95b88e0709666432a997f Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 4 Feb 2025 21:06:17 +0200
Subject: [PATCH 203/305] mu4e.texi: add example for sent-mail / org-wait

---
 mu4e/mu4e.texi | 81 +++++++++++++++++++++++++++++++++-----------------
 1 file changed, 54 insertions(+), 27 deletions(-)

diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index 0d1da2271..ec5caed0c 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -3271,13 +3271,12 @@ ways. Here we focus on Emacs built-ins; for dealing with external tools,
 * Desktop notifications::Get desktop notifications for new mail
 * Emacs bookmarks::Using Emacs' bookmark system
 * Eldoc::Information about the current header in the echo area
-* Org-mode links::Adding mu4e to your organized life
+* Org-mode::Adding mu4e to your organized life
 * iCalendar::Enabling iCalendar invite processing
 * Speedbar::A special frame with your folders
 * Dired:: Attaching files using @t{dired}
 @end menu
 
-
 @node Default email client
 @section Default email client
 
@@ -3420,33 +3419,34 @@ thus the bookmarks stay valid even if you move the message around.
 It is possible to get information about the current header in the echo-area.
 You can enable this by setting @t{mu4e-eldoc-support} to non-@t{nil}.
 
-@node Org-mode links
-@section Org-mode links
+@node Org-mode
+
+Org-mode is a popular and powerful way to deal with todo-lists, agendas inside
+Emacs. It's only natural to integrate it with @t{mu4e}, and
+
+@subsection Org-mode links
 
-It can be useful to include links to e-mail messages or search queries
-in your org-mode files. @t{mu4e} supports this by default, unless you
-set @t{mu4e-support-org} to @code{nil}.
+It can be useful to include links to e-mail messages or search queries in your
+org-mode files. @t{mu4e} supports this by default, unless you set
+@t{mu4e-support-org} to @code{nil}.
 
-You can use the normal @t{org-mode} mechanisms to store links:
-@kbd{M-x org-store-link} stores a link to a particular message when
-you are in @ref{Message view}. When you are in @ref{Headers view},
-@kbd{M-x org-store-link} links to the @emph{query} if
-@code{mu4e-org-link-query-in-headers-mode} is non-@code{nil}, and to
-the particular message otherwise (which is the default). You can
-customize the link description using @code{mu4e-org-link-desc-func}.
+You can use the normal @t{org-mode} mechanisms to store links: @kbd{M-x
+org-store-link} stores a link to a particular message when you are in
+@ref{Message view}. When you are in @ref{Headers view}, @kbd{M-x org-store-link}
+links to the @emph{query} if @code{mu4e-org-link-query-in-headers-mode} is
+non-@code{nil}, and to the particular message otherwise (which is the default).
+You can customize the link description using @code{mu4e-org-link-desc-func}.
 
 You can insert this link later with @kbd{M-x org-insert-link}. From
-@t{org-mode}, you can go to the query or message the link points to
-with either @kbd{M-x org-agenda-open-link} in agenda buffers, or
-@kbd{M-x org-open-at-point} elsewhere --- both typically bound to
-@kbd{C-c C-o}.
-
-You can also directly @emph{capture} such links --- for example, to
-add e-mail messages to your todo-list. For that, @t{mu4e-org} has a
-function @code{mu4e-org-store-and-capture}. This captures the
-message-at-point (or header --- see the discussion on
-@code{mu4e-org-link-query-in-headers-mode} above), then calls
-@t{org-mode}'s capture functionality.
+@t{org-mode}, you can go to the query or message the link points to with either
+@kbd{M-x org-agenda-open-link} in agenda buffers, or @kbd{M-x org-open-at-point}
+elsewhere --- both typically bound to @kbd{C-c C-o}.
+
+You can also directly @emph{capture} such links --- for example, to add e-mail
+messages to your todo-list. For that, @t{mu4e-org} has a function
+@code{mu4e-org-store-and-capture}. This captures the message-at-point (or header
+--- see the discussion on @code{mu4e-org-link-query-in-headers-mode} above),
+then calls @t{org-mode}'s capture functionality.
 
 You can add some specific capture-template for this. In your capture
 templates, the following mu4e-specific values are available:
@@ -3482,6 +3482,35 @@ key-bindings for that in headers and view mode:
   (define-key mu4e-view-mode-map    (kbd "C-c c") 'mu4e-org-store-and-capture)
 @end lisp
 
+@subsection Tracking sent mail
+
+To build on the above, it can be useful to automatically track outgoing e-mail
+so you can follow-up later.
+
+One way to do this is to first add a template to @t{org-capture-templates}:
+@lisp
+("wm" "To-do" entry (file+headline "~/Org/todo.org" "Waiting for")
+ "* WAIT [[mu4e:msgid:%(eval sent-message-id)][%(eval sent-subject)]]\n\t%u"
+ :immediate-finish t)
+@end lisp
+
+Then invoke this template from @t{sent-hook}:
+@lisp
+(defun my-org-wait-for-sent-mail ()
+  "Capture the outgoing mail."
+  (interactive)
+  (let* ((sent-message-id
+          (replace-regexp-in-string
+           "[<>]" "" (message-fetch-field "Message-Id")))
+         (sent-subject (or (message-fetch-field "Subject") "No subject")))
+    (org-capture nil "wm")))
+
+(add-hook 'sent-hook #'my-org-wait-for-sent-mail)
+@end lisp
+
+All of the above likely needs tweaking for your particular setup, but should
+hopefully give some inspiration.
+
 @node iCalendar
 @section iCalendar
 
@@ -3700,8 +3729,6 @@ After this, you should be able to:
 @item View the BBDB contact while viewing a message
 @end itemize
 
-
-
 @node Sauron
 @section Sauron
 

From 4808ff970d6a034e91097228e0db5365afe93a49 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 4 Feb 2025 21:31:19 +0200
Subject: [PATCH 204/305] mu4e.texi: update build instructions

---
 mu4e/mu4e.texi | 15 ++++++---------
 1 file changed, 6 insertions(+), 9 deletions(-)

diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index ec5caed0c..db75c9b08 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -298,7 +298,6 @@ $ sudo dnf install git meson gmime30-devel xapian-core-devel emacs
 @item Otherwise, install the equivalent of the above on your system
 @end itemize
 
-
 @subsection Getting mu
 
 The next step is to get the @t{mu} sources. There are two alternatives:
@@ -315,18 +314,16 @@ What all that in place, let's build and install @t{mu} and @t{mu4e}.
 Enter the directory where you unpacked or cloned @t{mu}. Then:
 
 @example
-$ ./autogen.sh && make
-$ sudo make install
+$ meson setup build
+$ meson compile -C build
+$ meson install -C build
 @end example
 
-Note: if you are familiar with @t{meson}, you can of course use its
-commands directly; the @t{make} commands are just a thin wrapper around
-that; so, this also works:
+For old-time's sake, alternatively you can do:
 
 @example
-$ meson setup build
-$ meson compile -C build
-$ meson install -C build
+$ ./autogen.sh && make
+$ sudo make install
 @end example
 
 @subsection Installation

From 4b691f97ccfa5aa6e07623b41a77d869ee985a7b Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 4 Feb 2025 21:40:00 +0200
Subject: [PATCH 205/305] mu4e.texi: update FAQ

---
 mu4e/mu4e.texi | 23 +++++++++++++++--------
 1 file changed, 15 insertions(+), 8 deletions(-)

diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index db75c9b08..2579909b0 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -4150,9 +4150,10 @@ reasons). Note that quitting @t{mu4e} or invoking @t{mu4e-update-mail-and-index}
 and @t{mu4e-update-index} trigger committing to disk as a side-effect.
 @item different options:
 @t{mu4e} defaults to having @t{mu4e-headers-include-related}, and
-@t{mu4e-headers-results-limit} set to 500. However, the command-line
-@command{mu find}'s corresponding @t{--include-related} is false, and
-there's no limit (@t{--maxnum}).
+@t{mu4e-headers-results-limit} set to 500. However, the command-line @command{mu
+find}'s corresponding @t{--include-related} is false, and there's no limit
+(@t{--maxnum}). Furthermore, @t{mu find} by default includes duplicate messages,
+while @t{mu4e} does not (see @t{--skip-dups}/@t{mu4e-search-skip-duplicates}.
 @item reverse sorting:
 The results may be different when @t{mu4e} and @command{mu find} do
 not both sort their results in the same direction.
@@ -4238,17 +4239,23 @@ Note that Emacs 29 obsoletes this variable.
 @section Retrieving mail
 
 @subsection How can I get notifications when receiving mail?
-There is @code{mu4e-index-updated-hook}, which gets triggered when the
-indexing process triggered sees an update (not just new mail though). To
-use this hook, put something like the following in your setup (assuming
-you have @t{aplay} and some soundfile, change as needed):
+
+The recommended way is to use @t{mu4e}'s built-in notification system, see
+@ref{Desktop notifications}.
+
+Alternatively, you can set things up manually.
+
+There is @code{mu4e-index-updated-hook}, which gets triggered when the indexing
+process triggered sees an update (not just new mail though). To use this hook,
+put something like the following in your setup (assuming you have @t{aplay} and
+some soundfile, change as needed):
 @lisp
 (add-hook 'mu4e-index-updated-hook
   (defun new-mail-sound ()
     (shell-command "aplay ~/Sounds/boing.wav&")))
 @end lisp
 
-@subsection I'm getting mail through a local mailserver. What should I use for @code{mu4e-get-mail-command}?
+@subsection I'm getting mail through a local mail-server. What should I use for @code{mu4e-get-mail-command}?
 Use the literal string @t{"true"} (or don't do anything, it's the
 default) which then uses @t{/bin/true} (a command that does nothing and
 always succeeds). This makes getting mail a no-op, but the messages are

From 055cb774e060abfe71ee80f18bf248d5c7fe7b39 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 4 Feb 2025 22:12:00 +0200
Subject: [PATCH 206/305] mu4e: show short counts next to maildir/bookmark
 entry

When you ask for bookmarks or maildirs through mu4e-ask-bookmark,
mu4e-ask-maildir, the counts are displayed in the (default) completions
next to the maildirs. This is a shorter version of the full display,
just showing either the delta or the number of unread messages, if any.
If you don't want to see these counts, there is mu4e-hide-short-counts.
---
 NEWS.org                 |  5 +++++
 mu4e/mu4e-bookmarks.el   | 34 +++++++++++++++++++++++-----------
 mu4e/mu4e-context.el     |  8 +++++---
 mu4e/mu4e-folders.el     | 35 +++++++++++++++++++++++++++--------
 mu4e/mu4e-query-items.el | 34 +++++++++++++++++++++++++++++++---
 mu4e/mu4e-search.el      |  2 +-
 mu4e/mu4e.texi           | 11 ++++++++++-
 7 files changed, 102 insertions(+), 27 deletions(-)

diff --git a/NEWS.org b/NEWS.org
index 15bc7b285..a28751bbe 100644
--- a/NEWS.org
+++ b/NEWS.org
@@ -66,6 +66,11 @@
     server interpreted the last query; this can be useful if you don't get the
     result you expected.
 
+  - When you ask for bookmarks or maildirs through ~mu4e-ask-bookmark~ or
+    ~mu4e-ask-maildir~, unread counts are displayed in the (default) completions UI
+    next to the maildir or bookmark. If you don't want to see these counts, set
+    ~mu4e-hide-short-counts~ to non-~nil~.
+
 * 1.12 (released on February 24, 2024)
 
 ** Some highlights
diff --git a/mu4e/mu4e-bookmarks.el b/mu4e/mu4e-bookmarks.el
index ee071df2f..f118133f6 100644
--- a/mu4e/mu4e-bookmarks.el
+++ b/mu4e/mu4e-bookmarks.el
@@ -1,6 +1,6 @@
 ;;; mu4e-bookmarks.el --- Bookmarks handling -*- lexical-binding: t -*-
 
-;; Copyright (C) 2011-2023 Dirk-Jan C. Binnema
+;; Copyright (C) 2011-2025 Dirk-Jan C. Binnema
 
 ;; Author: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ;; Maintainer: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
@@ -28,7 +28,6 @@
 (require 'mu4e-folders)
 (require 'mu4e-query-items)
 
-
 ;;; Configuration
 
 (defgroup mu4e-bookmarks nil
@@ -79,19 +78,33 @@ query."
   :type '(repeat (plist))
   :group 'mu4e-bookmarks)
 
+(declare-function mu4e-query-items "mu4e-query-items")
+(declare-function mu4e--query-item-display-short-counts "mu4e-query-items")
 
 (defun mu4e-ask-bookmark (prompt)
   "Ask user for bookmark using PROMPT.
 Return the corresponding query. The bookmark are as defined in
-`mu4e-bookmarks'."
+`mu4e-bookmarks'.
+
+The names of the bookmarks are displayed in the minibuffer,
+suffixed with the short version of the unread counts, as per
+`mu4e--query-item-display-short-counts'."
   (unless (mu4e-bookmarks) (mu4e-error "No bookmarks defined"))
-  (let* ((bmarks (seq-map (lambda (bm)
-                            (cons (format "%c%s"
-                                          (plist-get bm :key)
-                                          (plist-get bm :name))
-                                  (plist-get bm :query)))
-                          (mu4e-filter-single-key (mu4e-bookmarks)))))
-    (mu4e-read-option prompt bmarks)))
+  (let* ((bmarks
+          (seq-map
+           (lambda (bm) ;; find query-item for bookmark
+             (let* ((qitem (seq-find
+                           (lambda (qitem)
+                             (equal (plist-get bm :query) (plist-get qitem :query)))
+                           (mu4e-query-items 'bookmarks)))
+                    (unreads (mu4e--query-item-display-short-counts qitem)))
+               (cons (format "%c%s%s"
+                             (plist-get bm :key)
+                             (plist-get bm :name)
+                             unreads)
+                     (plist-get bm :query))))
+          (mu4e-filter-single-key (mu4e-bookmarks)))))
+  (mu4e-read-option prompt bmarks)))
 
 (defun mu4e-get-bookmark-query (kar)
   "Get the corresponding bookmarked query for shortcut KAR.
@@ -190,6 +203,5 @@ one, creates a propertized string for display in the modeline."
                            (mouse-1 . mu4e-jump-to-favorite)
                            (mouse-2 . mu4e-jump-to-favorite)
                            (mouse-3 . mu4e-jump-to-favorite))))))
-
 (provide 'mu4e-bookmarks)
 ;;; mu4e-bookmarks.el ends here
diff --git a/mu4e/mu4e-context.el b/mu4e/mu4e-context.el
index e35ef78ba..735eef372 100644
--- a/mu4e/mu4e-context.el
+++ b/mu4e/mu4e-context.el
@@ -1,6 +1,6 @@
 ;;; mu4e-context.el --- Switching between settings -*- lexical-binding: t -*-
 
-;; Copyright (C) 2015-2023 Dirk-Jan C. Binnema
+;; Copyright (C) 2015-2025 Dirk-Jan C. Binnema
 
 ;; Author: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ;; Maintainer: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
@@ -87,6 +87,9 @@ none."
 (cl-defstruct mu4e-context
   "A mu4e context object with the following members:
 - `name': the name of the context, eg. \"Work\" or \"Private\".
+   When using mu4e's default completion, it uses the first letter of
+   the name for this, so you should ensure those are different for
+   all contexts.
 - `enter-func': a parameterless function invoked when entering
   this context, or nil
 - `leave-func':a parameterless function invoked when leaving this
@@ -104,7 +107,6 @@ none."
   ;; if it matches, nil otherwise
   vars) ;; alist of variables.
 
-
 (defun mu4e--context-ask-user (prompt)
   "Let user choose some context based on its name with PROMPT."
   (when mu4e-contexts
@@ -168,7 +170,7 @@ match, return the first. For MSG and POLICY, see
                      nil (mu4e-context-name context))))))
 
 (defun mu4e-context-determine (msg &optional policy)
-  "Return the first context where match-func evaluate to non-nil.
+  "Return first context for which match-func returns non-nil.
 
 MSG points to the plist for the message replied to or forwarded,
 or nil if there is no such MSG; similar to what
diff --git a/mu4e/mu4e-folders.el b/mu4e/mu4e-folders.el
index 09fdfa552..fad001e4f 100644
--- a/mu4e/mu4e-folders.el
+++ b/mu4e/mu4e-folders.el
@@ -177,6 +177,16 @@ Converts from the old format if needed."
                item))
            mu4e-maildir-shortcuts))
 
+(declare-function mu4e-query-items "mu4e-query-items")
+(declare-function mu4e--query-item-display-short-counts "mu4e-query-items")
+
+(defun mu4e--query-item-for-maildir-shortcut (mds)
+  "Find the corresponding query-item for some maildir shortcut MDS.
+This is based on their query. Return nil if not found."
+  (seq-find (lambda (qitem)
+              (equal (plist-get qitem :maildir) (plist-get mds :maildir)))
+            (mu4e-query-items 'maildirs)))
+
 ;; the standard folders can be functions too
 (defun mu4e--get-folder (foldervar msg)
   "Within the mu-context of MSG, get message folder FOLDERVAR.
@@ -231,7 +241,7 @@ to create it; otherwise return nil."
   (let ((seems-to-exist (file-directory-p dir)))
     (when (or seems-to-exist
               (yes-or-no-p (mu4e-format "%s does not exist yet. Create now?" dir)))
-      ;; even when the maildir already seems to exist, call mkdir for a deeper
+      ;; even when the maildir already seems to exist, call mkdir for a deepe
       ;; check. However only get an update when the maildir is totally new.
       (mu4e--server-mkdir dir (not seems-to-exist))
       t)))
@@ -245,14 +255,23 @@ to create it; otherwise return nil."
 
 If the special shortcut \"o\" (for _o_ther) is used, or
 if (mu4e-maildir-shortcuts) evaluates to nil, let user choose
-from all maildirs under `mu4e-maildir'."
+from all maildirs under `mu4e-maildir'.
+
+The names of the maildirs are displayed in the minibuffer,
+suffixed with the short version of the unread counts, as per
+`mu4e--query-item-display-short-counts'."
   (let* ((options
-         (seq-map (lambda (md)
-                    (cons
-                     (format "%c%s" (plist-get md :key)
-                             (or (plist-get md :name)
-                                 (plist-get md :maildir)))
-                     (plist-get md :maildir)))
+         (seq-map
+          (lambda (md)
+            (let* ((qitem (mu4e--query-item-for-maildir-shortcut md))
+                   (unreads (mu4e--query-item-display-short-counts qitem)))
+              (cons
+               (format "%c%s%s"
+                       (plist-get md :key)
+                       (or (plist-get md :name)
+                           (plist-get md :maildir))
+                       unreads)
+               (plist-get md :maildir))))
                   (mu4e-filter-single-key (mu4e-maildir-shortcuts))))
         (response
          (if (not options)
diff --git a/mu4e/mu4e-query-items.el b/mu4e/mu4e-query-items.el
index b420155b2..90aad7e39 100644
--- a/mu4e/mu4e-query-items.el
+++ b/mu4e/mu4e-query-items.el
@@ -1,6 +1,6 @@
 ;;; mu4e-query-items.el --- Manage query results -*- lexical-binding: t -*-
 
-;; Copyright (C) 2023-2024 Dirk-Jan C. Binnema
+;; Copyright (C) 2023-2025 Dirk-Jan C. Binnema
 
 ;; Author: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ;; Maintainer: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
@@ -61,6 +61,12 @@ incorrect results for the various unread counts."
   :type 'function
   :group 'mu4e-search)
 
+(defcustom mu4e-hide-short-counts nil
+  "Hide the short count of unread messages.
+As used in `mu4e-ask-bookmark' and `mu4e-ask-folder'."
+  :type 'boolean
+  :group 'mu4e)
+
 (defvar mu4e--query-items-baseline nil
   "Some previous version of the query-items.
 This is used as the baseline to track updates by comparing it to
@@ -98,7 +104,9 @@ If ITEMS does not yet have a favorite item, pick the first."
 (declare-function mu4e-maildir-shortcuts "mu4e-folders")
 
 (defun mu4e--query-item-display-counts (item)
-  "Get the count display string for some query-data ITEM."
+  "Get the count display string for some query-data ITEM.
+If the items has its `:hide-unread' at a non-nil value, return
+an empty string."
   ;; purely for display, but we need it in the main menu, modeline
   ;; so let's keep it consistent.
   (cl-destructuring-bind (&key unread hide-unread delta-unread count
@@ -116,6 +124,25 @@ If ITEMS does not yet have a favorite item, pick the first."
        (propertize (number-to-string count)
                    'help-echo "Total number")))))
 
+(defun mu4e--query-item-display-short-counts (item)
+  "Get the short count display string for some query-data ITEM.
+This gets the delta if it is greater than zero. Otherwise, the
+total unread count if is greater than zero. Otherwise, an empty
+string.
+
+If the items has its `:hide-unread' at a non-nil value, or if
+`mu4e-hide-short-counts' is non-nil, returns an empty string."
+  (cl-destructuring-bind (&key unread hide-unread delta-unread
+                               &allow-other-keys) item
+    (if (or hide-unread mu4e-hide-short-counts)
+        ""
+      (concat
+       (if (> (or delta-unread 0) 0)
+           (concat "(" (propertize (format "+%d" delta-unread) 'face 'mu4e-unread-face) ")")
+         (if (> (or unread 0) 0)
+             (concat "(" (propertize (format "%d" unread) 'face 'mu4e-header-key-face) ")")
+           ""))))))
+
 (defun mu4e--query-items-refresh (&optional reset-baseline)
   "Get the latest query data from the mu4e server.
 With RESET-BASELINE, reset the baseline first."
@@ -210,7 +237,8 @@ bookmark or maildir."
        ;; useful for debugging.
        (unless (string= query effective-query)
          (plist-put value :effective-query effective-query))
-
+       ;;for matching maildir shortcuts
+       (when maildir (plist-put value :maildir maildir))
        ;; nil props bring me discomfort
        (when (plist-get item :favorite)
          (plist-put value :favorite t))
diff --git a/mu4e/mu4e-search.el b/mu4e/mu4e-search.el
index 2fdb8ee47..f72d9da26 100644
--- a/mu4e/mu4e-search.el
+++ b/mu4e/mu4e-search.el
@@ -1,6 +1,6 @@
 ;;; mu4e-search.el --- Search-related functions -*- lexical-binding: t -*-
 
-;; Copyright (C) 2021,2024 Dirk-Jan C. Binnema
+;; Copyright (C) 2021-2025 Dirk-Jan C. Binnema
 
 ;; Author: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ;; Maintainer: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index 2579909b0..3261e4f87 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -847,7 +847,7 @@ attention:
   ;; bookmark for message that require quick attention
   '( :name "Urgent"
      :key  ?u
-     :query "maildir:/inbox AND from:boss@@exmaple.com"))
+     :query "maildir:/inbox AND from:boss@@example.com"))
 @end lisp
 
 Note that @t{mu4e} resets the baseline when you are interacting with it (for
@@ -859,6 +859,13 @@ as being a special kind of bookmark query that matches a Maildir. You can
 configure this using the variable @code{mu4e-maildir-shortcuts}; see its
 docstring and @ref{Maildir searches} for more details.
 
+When you ask for bookmarks or maildirs through @code{mu4e-ask-bookmark},
+@code{mu4e-ask-maildir}, the counts are displayed in the (default) completions
+next to the maildir or bookmark entry. This is a shorter version of the full
+display, just showing either the delta or the number of unread messages, if any.
+If you do not want to see these counts, set @t{mu4e-hide-short-counts} to
+non-@t{nil}.
+
 @node Miscellaneous
 @section Miscellaneous
 
@@ -2610,6 +2617,8 @@ Let's see what's contained in a context. Most of it is optional.
 A @code{mu4e-context} is Lisp object with the following members:
 @itemize
 @item @t{name}: the name of the context, e.g. @t{work} or @t{private}
+in the default completion UI, @t{mu4e} uses the first letter of the context to
+select them, so you should ensure all start with a different letter
 @item @t{vars}:
 an association-list (alist) of variable settings for this account.
 @item @t{enter-func}:

From d33adc923ce61f0bacc024824d5db2ee41f1ac08 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Wed, 5 Feb 2025 20:14:36 +0200
Subject: [PATCH 207/305] build: tweaks

---
 Makefile    | 3 ++-
 meson.build | 3 +--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Makefile b/Makefile
index 662eda7dc..c86a17e8b 100644
--- a/Makefile
+++ b/Makefile
@@ -1,4 +1,4 @@
-## Copyright (C) 2008-2023 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+## Copyright (C) 2008-2025 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ##
 ## This program is free software; you can redistribute it and/or modify
 ## it under the terms of the GNU General Public License as published by
@@ -41,6 +41,7 @@ ifneq (${MU_HACKER},)
 MESON_FLAGS:=$(MESON_FLAGS) '-Dbuildtype=debug'    \
 			    '-Db_sanitize=address' \
 			    '-Dreadline=enabled'   \
+			    '-Dcpp_debugstl=enabled' \
 			    '-Dcpp_std=c++23'
 endif
 
diff --git a/meson.build b/meson.build
index 071a63f7b..36cc4c696 100644
--- a/meson.build
+++ b/meson.build
@@ -290,7 +290,6 @@ install_data('NEWS.org', 'IDEAS.org',
 subdir('lib')
 subdir('mu')
 
-
 # emacs -- needed for mu4e compilation
 emacs_name=get_option('emacs')
 emacs_min_version='26.3'
@@ -319,7 +318,7 @@ config_h_data.set_quoted('MU_PROGRAM', mu.full_path())
 configure_file(output : 'config.h', configuration : config_h_data)
 
 if gmime_dep.version() == '3.2.13'
-  warning('gmime version 3.2.13 detected, which as a decoding bug')
+  warning('gmime version 3.2.13 detected, which has a decoding bug')
   warning('See: https://github.com/jstedfast/gmime/issues/133')
 endif
 

From c0887603c55be3621b2ddcaead6ae7537639f6a7 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Wed, 5 Feb 2025 21:16:15 +0200
Subject: [PATCH 208/305] guile: avoid body duplication

In message, don't re-fill when unneeded. Add tests.

Fixes #2802.
---
 guile/mu-guile-message.cc     |  2 +-
 guile/tests/test-mu-guile.scm | 29 ++++++++++++++++-------------
 lib/message/mu-message.cc     | 12 +++++++++++-
 3 files changed, 28 insertions(+), 15 deletions(-)

diff --git a/guile/mu-guile-message.cc b/guile/mu-guile-message.cc
index 281ed7c48..24223c30d 100644
--- a/guile/mu-guile-message.cc
+++ b/guile/mu-guile-message.cc
@@ -333,7 +333,7 @@ SCM_DEFINE(get_parts,
 		attlist = scm_cons(elm, attlist);
 	}
 
-	/* explicitly close the file backend, so we won't run of fds */
+	/* explicitly close the file backend, so we won't run out of fds */
 	msg->unload_mime_message();
 
 	return attlist;
diff --git a/guile/tests/test-mu-guile.scm b/guile/tests/test-mu-guile.scm
index ed00f1e3b..7926d112b 100755
--- a/guile/tests/test-mu-guile.scm
+++ b/guile/tests/test-mu-guile.scm
@@ -74,10 +74,13 @@ exec guile -e main -s $0 $@
     (str-equal-or-exit (mu:subject msg) "Fwd: rfc822")
     (str-equal-or-exit (mu:to msg) "martin")
     (str-equal-or-exit (mu:from msg) "foobar <foo@example.com>")
+    (str-equal-or-exit (mu:body msg) "Hello world, forwarding some RFC822 message\n")
     (str-equal-or-exit (mu:header msg "X-Mailer") "Ximian Evolution 1.4.5")
+    ;; issue #2802
+    (str-equal-or-exit (mu:body msg) "Hello world, forwarding some RFC822 message\n")
 
     (if (not (equal? (mu:priority msg) mu:prio:normal))
-      (error-exit "Expected ~A, got ~A"  (mu:priority msg) mu:prio:normal)))
+	(error-exit "Expected ~A, got ~A"  (mu:priority msg) mu:prio:normal)))
 
   (let ((msg (car (mu:message-list "atoms"))))
     (str-equal-or-exit (mu:subject msg) "atoms")
@@ -85,21 +88,21 @@ exec guile -e main -s $0 $@
     (str-equal-or-exit (mu:from    msg) "Richard P. Feynman <rpf@example.com>")
     ;;(str-equal-or-exit (mu:header msg "Content-Transfer-Encoding") "8bit")
     (str-equal-or-exit (mu:body msg)
-                       (string-join
-                        '("If, in some cataclysm, all scientific knowledge were to be destroyed,"
-                          "and only one sentence passed on to the next generation of creatures,"
-                          "what statement would contain the most information in the fewest words?"
-                          "I believe it is the atomic hypothesis (or atomic fact, or whatever you"
-                          "wish to call it) that all things are made of atoms — little particles"
-                          "that move around in perpetual motion, attracting each other when they"
-                          "are a little distance apart, but repelling upon being squeezed into"
-                          "one another. In that one sentence you will see an enormous amount of"
-                          "information about the world, if just a little imagination and thinking"
-                          "are applied.\n") "\n"))
+		       (string-join
+			'("If, in some cataclysm, all scientific knowledge were to be destroyed,"
+			  "and only one sentence passed on to the next generation of creatures,"
+			  "what statement would contain the most information in the fewest words?"
+			  "I believe it is the atomic hypothesis (or atomic fact, or whatever you"
+			  "wish to call it) that all things are made of atoms — little particles"
+			  "that move around in perpetual motion, attracting each other when they"
+			  "are a little distance apart, but repelling upon being squeezed into"
+			  "one another. In that one sentence you will see an enormous amount of"
+			  "information about the world, if just a little imagination and thinking"
+			  "are applied.\n") "\n"))
     (str-equal-or-exit (mu:body-txt msg) (mu:body msg))
     (let ((got (mu:body-html msg)))
       (if got
-          (error-exit "Expected #f, got ~a" got)))
+	  (error-exit "Expected #f, got ~a" got)))
 
     (if (not (equal? (mu:priority msg) mu:prio:high))
       (error-exit "Expected ~a, got ~a"  (mu:priority msg) mu:prio:high))))
diff --git a/lib/message/mu-message.cc b/lib/message/mu-message.cc
index ee5929805..3d4d2df20 100644
--- a/lib/message/mu-message.cc
+++ b/lib/message/mu-message.cc
@@ -72,6 +72,10 @@ struct Message::Private {
 
 	Option<std::string> language; /* body ISO language code */
 
+	// after unload_mime_message, we don't need to re-parse the message.
+	// issue #2802.
+	bool document_filled{};
+
 private:
 	Document::Options doc_opts(Message::Options mopts) {
 		return any_of(opts & Message::Options::SupportNgrams) ?
@@ -675,6 +679,10 @@ doc_add_reply_to(Document& doc, const MimeMessage& mime_msg)
 static void
 fill_document(Message::Private& priv)
 {
+	if (priv.document_filled) {
+		return; // nothing to do.
+	}
+
 	/* hunt & gather info from message tree */
 	Document& doc{priv.doc};
 	MimeMessage& mime_msg{priv.mime_msg.value()};
@@ -691,7 +699,7 @@ fill_document(Message::Private& priv)
 	doc_add_list_post(doc, mime_msg); /* only in sexp */
 	doc_add_reply_to(doc, mime_msg);  /* only in sexp */
 
-	field_for_each([&](auto&& field) {
+	field_for_each([&](const auto& field) {
 		/* insist on explicitly handling each */
 #pragma GCC diagnostic push
 #pragma GCC diagnostic error "-Wswitch"
@@ -775,6 +783,8 @@ fill_document(Message::Private& priv)
 #pragma GCC diagnostic pop
 
 	});
+
+	priv.document_filled = true;
 }
 
 Option<std::string>

From 1858d8088334a915e2d5440a340fa6d80a78872f Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Wed, 5 Feb 2025 21:18:48 +0200
Subject: [PATCH 209/305] guile: update issue template

---
 .github/ISSUE_TEMPLATE/guile.md | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/.github/ISSUE_TEMPLATE/guile.md b/.github/ISSUE_TEMPLATE/guile.md
index 020b849b1..c55fbf972 100644
--- a/.github/ISSUE_TEMPLATE/guile.md
+++ b/.github/ISSUE_TEMPLATE/guile.md
@@ -8,7 +8,12 @@ assignees: ''
 ---
 
 **Describe the item**
-A clear and concise description of what you expected or wished to happen and what actually happened while using mu-guile.
+
+A clear and concise description of what you expected or wished to happen and
+what actually happened while using `mu-guile`.
+
+Note: `mu-guile` has been deprecated for quite some time, and will be removed in
+the future.
 
 **To Reproduce**
 Steps to reproduce the behavior.
@@ -17,4 +22,4 @@ Steps to reproduce the behavior.
 Please describe the versions of OS, Emacs, mu/mu4e etc. you are using.
 
 **Checklist**
-- [ ] you are running either the latest 1.4.x release, or a 1.5.11+ development release (otherwise, please upgrade).
+- [ ] you are running either the latest 1.12.x release, or `master`

From aad5fc7df5f465e9b320764a43640838bd733050 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Wed, 5 Feb 2025 21:07:14 +0200
Subject: [PATCH 210/305] mu-server: minor cleanups

---
 lib/mu-server.cc | 15 ++-------------
 1 file changed, 2 insertions(+), 13 deletions(-)

diff --git a/lib/mu-server.cc b/lib/mu-server.cc
index 4862f7a9a..67d48d278 100644
--- a/lib/mu-server.cc
+++ b/lib/mu-server.cc
@@ -27,8 +27,6 @@
 #include <string>
 #include <algorithm>
 #include <atomic>
-#include <thread>
-#include <mutex>
 #include <variant>
 #include <functional>
 
@@ -123,7 +121,6 @@ struct OutputStream {
 };
 
 
-
 /// @brief object to manage the server-context for all commands.
 struct Server::Private {
 	Private(Store& store, const Server::Options& opts, Output output)
@@ -135,8 +132,6 @@ struct Server::Private {
 
 	~Private() {
 		indexer().stop();
-		if (index_thread_.joinable())
-			index_thread_.join();
 		if (!tmp_dir_.empty())
 			remove_directory(tmp_dir_);
 	}
@@ -215,7 +210,6 @@ struct Server::Private {
 	Server::Output		output_;
 	const CommandHandler	command_handler_;
 	std::atomic<bool>       keep_going_{};
-	std::thread		index_thread_;
 	std::string		tmp_dir_;
 };
 
@@ -282,7 +276,6 @@ msg_sexp_str(const Message& msg, Store::Id docid, const Option<QueryMatch&> qm)
 	return sexpstr;
 }
 
-
 CommandHandler::CommandInfoMap
 Server::Private::make_command_map()
 {
@@ -572,7 +565,6 @@ Server::Private::data_handler(const Command& cmd)
 			"invalid request type '{}'", request_type);
 }
 
-
 /*
  * creating a message object just to get a path seems a bit excessive maybe
  * mu_store_get_path could be added if this turns out to be a problem
@@ -648,7 +640,6 @@ Server::Private::output_results(const QueryResults& qres, size_t batch_size) con
 	return n;
 }
 
-
 void
 Server::Private::find_handler(const Command& cmd)
 {
@@ -791,10 +782,9 @@ Server::Private::index_handler(const Command& cmd)
 	// ignore .noupdate with an empty store.
 	conf.ignore_noupdate = store().empty();
 
-	// nothing to do
-	if (indexer().is_running()) {
+	if (indexer().is_running()) // already
 		throw Error{Error::Code::Xapian, "indexer is already running"};
-	}
+
 	do_index(conf);
 }
 
@@ -991,7 +981,6 @@ Server::Private::queries_handler(const Command& cmd)
 	output_sexp(Sexp(":queries"_sym, std::move(qresults)));
 }
 
-
 void
 Server::Private::quit_handler(const Command& cmd)
 {

From 990cb768f262b2820bbceb45303c0ace79a117bc Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Thu, 6 Feb 2025 18:42:32 +0200
Subject: [PATCH 211/305] mu4e-lists: cosmetics

Minor cleanups
---
 mu4e/mu4e-lists.el | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/mu4e/mu4e-lists.el b/mu4e/mu4e-lists.el
index 43181cd54..a454e7a64 100644
--- a/mu4e/mu4e-lists.el
+++ b/mu4e/mu4e-lists.el
@@ -1,6 +1,6 @@
-;;; mu4e-lists.el --- Get names for mailing lists -*- lexical-binding: t -*-
+;;; mu4e-lists.el --- Dealing with mailing lists -*- lexical-binding: t -*-
 
-;; Copyright (C) 2011-2023 Dirk-Jan C. Binnema
+;; Copyright (C) 2011-2025 Dirk-Jan C. Binnema
 
 ;; Author: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ;; Maintainer: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
@@ -28,9 +28,8 @@
 ;;; Code:
 (require 'mu4e-message)
 (require 'mu4e-helpers)
-
 
- ;;; Helpers
+;;; Helpers
 (defmacro mu4e-message-id-url(base-url)
   "Construct lambda to get an archive URL for message.
 This is based on some BASE-URL to which the message-id is concatenated;
@@ -38,11 +37,11 @@ e.g. public-inbox-based archives."
   `(lambda (msg) (concat ,base-url "/" (plist-get msg :message-id))))
 
 (defmacro mu4e-x-seq-url (base-url)
-  "Construct x-seq archive URL for MSG or nil if not found."
+  "Construct x-seq archive URL for MSG or nil if not found.
+Use BASE-URL as the prefix."
   `(lambda (msg)
      (when-let* ((xseq (mu4e-fetch-field msg "X-Seq")))
        (concat ,base-url "/" xseq))))
-
 ;;; Configuration
 (defvar mu4e-mailing-lists
   `( (:list-id "bbdb-info.lists.sourceforge.net"         :name "BBDB")
@@ -141,10 +140,9 @@ Based on the current value of `mu4e-mailing-lists' and
 Return nil if not found."
   (unless mu4e--lists-hash (mu4e-mailing-list-info-refresh))
   (gethash list-id mu4e--lists-hash))
-
 
 (defun mu4e-get-mailing-list-shortname (list-id)
-  "Get the shortname for a mailing-list with list-id LIST-ID.
+  "Get the short-name for a mailing-list with list-id LIST-ID.
 Either we know about this mailing list, or otherwise
 we guess one."
   (or  ;; 1. perhaps we have it in one of our lists?

From 355ec62fea6f9dfb25c9a294e2e231c83c53448d Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Thu, 6 Feb 2025 19:43:53 +0200
Subject: [PATCH 212/305] mu4e-message: cleanups, add mu4e-message-p

---
 mu4e/mu4e-message.el | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/mu4e/mu4e-message.el b/mu4e/mu4e-message.el
index 80ab1ba6b..819b28f64 100644
--- a/mu4e/mu4e-message.el
+++ b/mu4e/mu4e-message.el
@@ -1,6 +1,6 @@
 ;;; mu4e-message.el --- Working with mu4e-message plists -*- lexical-binding: t -*-
 
-;; Copyright (C) 2012-2024 Dirk-Jan C. Binnema
+;; Copyright (C) 2012-2025 Dirk-Jan C. Binnema
 
 ;; Author: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ;; Maintainer: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
@@ -40,7 +40,7 @@
 
 ;;; Message fields
 
-(defsubst mu4e-message-field-raw (msg field)
+(defun mu4e-message-field-raw (msg field)
   "Retrieve FIELD from message plist MSG.
 
 See \"mu fields\" for the full list of field, in particular the
@@ -78,7 +78,7 @@ Some notes on the format:
       (plist-get msg field)
     (mu4e-error "Message must be non-nil")))
 
-(defsubst mu4e-message-field (msg field)
+(defun mu4e-message-field (msg field)
   "Retrieve FIELD from message plist MSG.
 Like `mu4e-message-field-nil', but will sanitize nil values:
 - all string field except body: nil -> \"\"
@@ -98,11 +98,11 @@ Thus, function will return nil for empty lists, or non-existing body."
      (t
       val)))) ;; otherwise, just return nil
 
-(defsubst mu4e-message-has-field (msg field)
+(defun mu4e-message-has-field (msg field)
   "If MSG has a FIELD return t, nil otherwise."
   (plist-member msg field))
 
-(defsubst mu4e-message-at-point (&optional noerror)
+(defun mu4e-message-at-point (&optional noerror)
   "Get the message s-expression for the message at point.
 Either the headers buffer or the view buffer, or nil if there is
 no such message. If optional NOERROR is non-nil, do not raise an
@@ -112,6 +112,11 @@ error when there is no message at point."
        ((eq major-mode 'mu4e-view-mode) mu4e--view-message))
       (unless noerror (mu4e-warn "No message at point"))))
 
+(defun mu4e-message-p ()
+  "Are we on a message?
+Either in headers or view mode."
+  (mu4e-message-at-point 'no-error))
+
 (defsubst mu4e-message-field-at-point (field)
   "Get the field FIELD from the message at point.
 This is equivalent to:

From 207ed683d66d9cf59b8f771346f418d64d869b5c Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Thu, 6 Feb 2025 23:44:29 +0200
Subject: [PATCH 213/305] mu4e-view: create fake original-article-buffer

That allow for using more Gnus functionality, such as mailing-list support.
---
 mu4e/mu4e-view.el | 79 +++++++++++++++++++++++++++++++----------------
 1 file changed, 52 insertions(+), 27 deletions(-)

diff --git a/mu4e/mu4e-view.el b/mu4e/mu4e-view.el
index 3c7220c93..8424a2c37 100644
--- a/mu4e/mu4e-view.el
+++ b/mu4e/mu4e-view.el
@@ -1,6 +1,6 @@
 ;;; mu4e-view.el --- Mode for viewing e-mail messages -*- lexical-binding: t -*-
 
-;; Copyright (C) 2021-2024 Dirk-Jan C. Binnema
+;; Copyright (C) 2021-2025 Dirk-Jan C. Binnema
 
 ;; Author: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ;; Maintainer: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
@@ -97,8 +97,6 @@ The first letter of NAME is used as a shortcut character."
   :type 'integer
   :group 'mu4e-view)
 
-
-
 (defconst mu4e--view-raw-buffer-name " *mu4e-raw-view*"
   "Name for the raw message view buffer.")
 
@@ -594,6 +592,30 @@ message."
 (defvar gnus-icalendar-additional-identities)
 (defvar-local mu4e--view-rendering nil)
 
+(defun mu4e--fake-original-article-buffer ()
+  "Create a fake original gnus article buffer.
+
+With this, some Gnus commands that require an original message
+buffer can work, e.g. for dealing with mailing-lists. We only
+store the headers, not the body, to save some memory, as we don't
+need the body.
+
+This must be called while in the raw message buffer."
+   (message-narrow-to-headers-or-head)
+   (let ((headers (buffer-string)))
+     (widen)
+     (with-current-buffer
+         (get-buffer-create gnus-original-article-buffer 'no-hooks)
+       (erase-buffer)
+       (insert headers)
+       (current-buffer))))
+
+(defun mu4e--original-article-field (field)
+  "Get FIELD from the original article."
+  (when (bufferp gnus-original-article-buffer)
+    (with-current-buffer gnus-original-article-buffer
+      (gnus-fetch-field field))))
+
 (defun mu4e-view (msg)
   "Display the message MSG in a new buffer, and keep in sync with HDRSBUF.
 \"In sync\" here means that moving to the next/previous message
@@ -611,7 +633,7 @@ As a side-effect, a message that is being viewed loses its
   ;; Unfortunately that does create its own issues: namely ensuring
   ;; buffer-local state that *must* survive is correctly copied
   ;; across.
-  (let ((linked-headers-buffer))
+  (let ((linked-headers-buffer) (orig-art-buf))
     (when-let* ((existing-buffer (mu4e-get-view-buffer nil nil)))
       ;; required; this state must carry over from the killed buffer
       ;; to the new one.
@@ -633,34 +655,37 @@ As a side-effect, a message that is being viewed loses its
         (erase-buffer)
         (insert-file-contents-literally
          (mu4e-message-readable-path msg) nil nil nil t)
+        ;; set up an original-article-buffer, gnus wants it.
+        (setq orig-art-buf (mu4e--fake-original-article-buffer))
         ;; some messages have ^M which causes various rendering
         ;; problems later (#2260, #2508), so let's remove those
         (article-remove-cr)
         (setq-local mu4e--view-message msg)
         (ignore-errors
           (mu4e--view-render-buffer msg)))
-      (mu4e-loading-mode 0)))
-  (unless (mu4e--view-detached-p gnus-article-buffer)
-    (with-current-buffer mu4e-linked-headers-buffer
-      ;; We need this here as we want to avoid displaying the buffer until
-      ;; the last possible moment --- after the message is rendered in the
-      ;; view buffer.
-      ;;
-      ;; Otherwise, `mu4e-display-buffer' may adjust the view buffer's
-      ;; window height based on a buffer that has no text in it yet!
-      (setq-local mu4e~headers-view-win
-                  (mu4e-display-buffer gnus-article-buffer nil))
-      (unless (window-live-p mu4e~headers-view-win)
-        (mu4e-error "Cannot get a message view"))
-      (select-window mu4e~headers-view-win)))
-  (with-current-buffer gnus-article-buffer
-    (let ((inhibit-read-only t))
-      (run-hooks 'mu4e-view-rendered-hook))
-    ;; support bookmarks.
-    (setq-local bookmark-make-record-function
-                #'mu4e--make-bookmark-record)
-    ;; only needed on some setups; #2683
-    (goto-char (point-min))))
+      (mu4e-loading-mode 0))
+    (unless (mu4e--view-detached-p gnus-article-buffer)
+      (with-current-buffer mu4e-linked-headers-buffer
+        ;; We need this here as we want to avoid displaying the buffer until
+        ;; the last possible moment --- after the message is rendered in the
+        ;; view buffer.
+        ;;
+        ;; Otherwise, `mu4e-display-buffer' may adjust the view buffer's
+        ;; window height based on a buffer that has no text in it yet!
+        (setq-local mu4e~headers-view-win
+                    (mu4e-display-buffer gnus-article-buffer nil))
+        (unless (window-live-p mu4e~headers-view-win)
+          (mu4e-error "Cannot get a message view"))
+        (select-window mu4e~headers-view-win)))
+    (with-current-buffer gnus-article-buffer
+      (let ((inhibit-read-only t))
+        (run-hooks 'mu4e-view-rendered-hook))
+      ;; support bookmarks.
+      (setq-local bookmark-make-record-function
+                  #'mu4e--make-bookmark-record
+                  gnus-original-article orig-art-buf)
+      ;; only needed on some setups; #2683
+      (goto-char (point-min)))))
 
 (defun mu4e-view-message-text (msg)
   "Return the rendered MSG as a string."
@@ -710,7 +735,7 @@ determine which browser function to use."
 
 (defun mu4e--view-render-buffer (msg)
   "Render current buffer with MSG using Gnus' article mode."
-  (setq gnus-summary-buffer (get-buffer-create " *appease-gnus*"))
+  (setq-local gnus-summary-buffer (get-buffer-create " *appease-gnus*"))
   (let* ((inhibit-read-only t)
          (max-specpdl-size mu4e-view-max-specpdl-size)
          (mm-decrypt-option 'known)

From 58374d55091eefa00c4626e993be575499cb73ed Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Thu, 6 Feb 2025 23:45:24 +0200
Subject: [PATCH 214/305] mu4e-transient: improvements

Still experimental of course; rework a bit and add support for mailing-lists.
---
 mu4e/mu4e-transient.el | 66 +++++++++++++++++++++++++++++-------------
 1 file changed, 46 insertions(+), 20 deletions(-)

diff --git a/mu4e/mu4e-transient.el b/mu4e/mu4e-transient.el
index 6877bc38d..8dd06364a 100644
--- a/mu4e/mu4e-transient.el
+++ b/mu4e/mu4e-transient.el
@@ -14,6 +14,8 @@
 (require 'mu4e-headers)
 (require 'mu4e-helpers)
 
+(require 'gnus-ml)
+
 (require 'transient)
 
 ;; Helpers.
@@ -121,44 +123,68 @@ toggle-function is created."
     ;;("M" mu4e--suffix-toggle-message-forward-show-mml)
     ]])
 
+(transient-define-prefix mu4e--prefix-mailing-list()
+  "Mu4e documentation menu."
+  [[
+    :description
+    (lambda ()
+      (let* ((msg (mu4e-message-at-point 'no-error))
+             (ml (plist-get msg :list)))
+        (format "Mailing list %s" (or ml ""))))
+    ("s" "subscribe"   gnus-mailing-list-subscribe)
+    ("u" "unsubscribe" gnus-mailing-list-unsubscribe)
+    ("h" "help"        gnus-mailing-list-help)
+    ;;("a" "archive")
+]])
+
 (transient-define-prefix mu4e-transient-menu()
   "Mu4e main menu."
-  [["Basics"
-    ("M" "Main menu"           mu4e)
+  [["Main"
+    ("M" "Main screen"         mu4e)
     ("U" "Update mail"         mu4e-update-mail-and-index)
-    (";" "Switch context"      mu4e-context-switch
-     :inapt-if-nil mu4e-contexts)
-    ("M-q" "Quit mu4e"         mu4e-quit)]
+    (";" "Change context"      mu4e-context-switch
+     :inapt-if-nil mu4e-contexts
+     :description
+     (lambda ()
+       (let ((ctx (mu4e-context-current)))
+         (format "Context %s"
+                 (if ctx (propertize (mu4e-context-name ctx)
+                                     'face 'transient-value) "")))))
+    ("d" "Docs & links"      mu4e--prefix-docs-links)
+    ("D" "Debug/tweaks..."   mu4e--prefix-debug-tweaks)
+    ("M-q" "Quit"             mu4e-quit)]
    ["Search"
     ("b" "Bookmark"            mu4e-search-bookmark)
     ("j" "Maildir"             mu4e-search-maildir)
     ("c" "Choose query"        mu4e-search-query)
     ("s" "Search"              mu4e-search)]
    ["Composition"
-    ("C" "New mail"            mu4e-compose-new)
-    ("o" "Options..."          mu4e--prefix-compose-options)
-    ]
-   ["" ;; composition that requires an existing message
-    :if           (lambda ()
-                    (memq major-mode '(mu4e-headers-mode mu4e-view-mode)))
-    :inapt-if-not (lambda ()
-                    (mu4e-message-at-point 'nowarn))
-    ("R" "Reply"               mu4e-compose-reply)
-    ("W" "Reply-to-all"        mu4e-compose-wide-reply)
-    ("F" "Forward"             mu4e-compose-forward)
+    ("C" "New message"         mu4e-compose-new)
+    ("R" "Reply"               mu4e-compose-reply :if mu4e-message-p)
+    ("W" "Reply-to-all"        mu4e-compose-wide-reply :if mu4e-message-p)
+    ("F" "Forward"             mu4e-compose-forward :if mu4e-message-p)
     ;; only draft messages can be edited
     ("E" "Edit draft"          mu4e-compose-edit
+     :if mu4e-message-p
      :inapt-if-not (lambda ()
                      (member 'draft
                              (mu4e-message-field
                               (mu4e-message-at-point 'nowarn) :flags))))
     ;; you can only supersede your own messages
     ("S" "Supersede"           mu4e-compose-supersede
+     :if mu4e-message-p
      :inapt-if-not mu4e--message-is-yours-p)
-    ("X" "Resend"          mu4e-compose-resend)]
-   ["Misc"
-    ("d" "Docs & links"      mu4e--prefix-docs-links)
-    ("D" "Debug/tweaks..."   mu4e--prefix-debug-tweaks)]])
+    ("X" "Resend"          mu4e-compose-resend :if mu4e-message-p)
+    ("o" "Options..."      mu4e--prefix-compose-options)]
+   ["" ;; composition that requires an existing message
+    :if           (lambda ()
+                    (memq major-mode '(mu4e-headers-mode mu4e-view-mode)))
+    :inapt-if-not (lambda ()
+                    (mu4e-message-at-point 'nowarn))
+    ]
+   ["View"
+    :if (lambda () (eq major-mode 'mu4e-view-mode))
+    ("m" "Mailing list..."  mu4e--prefix-mailing-list)]])
 
 (provide 'mu4e-transient)
 ;;; mu4e-transient.el ends here

From f20cfc69da1dc660ba0d8b645181fe1d0e2b5801 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Fri, 7 Feb 2025 20:23:17 +0200
Subject: [PATCH 215/305] mu4e-main: cosmetics

---
 mu4e/mu4e-main.el | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/mu4e/mu4e-main.el b/mu4e/mu4e-main.el
index 5a04cc7d8..56dc82f2a 100644
--- a/mu4e/mu4e-main.el
+++ b/mu4e/mu4e-main.el
@@ -1,6 +1,6 @@
 ;;; mu4e-main.el --- The Main interface for mu4e -*- lexical-binding: t -*-
 
-;; Copyright (C) 2011-2024 Dirk-Jan C. Binnema
+;; Copyright (C) 2011-2025 Dirk-Jan C. Binnema
 
 ;; Author: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ;; Maintainer: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
@@ -42,7 +42,6 @@
 
 (require 'cl-lib)
 
-
 ;; Configuration
 
 (defcustom mu4e-main-hide-personal-addresses nil
@@ -64,7 +63,6 @@ the personal addresses."
   :type 'hook
   :group 'mu4e-main)
 
-
 ;;; Mode
 (define-derived-mode mu4e-org-mode org-mode "mu4e:org"
   "Major mode for mu4e documents.")
@@ -237,7 +235,7 @@ for aligning them."
                   (list #'mu4e-search-maildir #'mu4e-search
                         query))
                  ((eq item-type 'bookmarks)
-                  (list #'mu4e-search-bookmark #'mu4e-search-bookmark
+                 (list #'mu4e-search-bookmark #'mu4e-search-bookmark
                         (mu4e-get-bookmark-query key)))
                  (t
                   (mu4e-error "Invalid item-type %s" item-type)))))

From 8372be17dd839bc2c5b228b0c7bf1f2f0bc742fd Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Fri, 7 Feb 2025 21:25:07 +0200
Subject: [PATCH 216/305] mu-server: more info for mu4e-analyze-last-query

Include the search parameters besides the query.
---
 lib/mu-server.cc | 22 ++++++++++++++++------
 1 file changed, 16 insertions(+), 6 deletions(-)

diff --git a/lib/mu-server.cc b/lib/mu-server.cc
index 67d48d278..4aaa0a8f1 100644
--- a/lib/mu-server.cc
+++ b/lib/mu-server.cc
@@ -670,14 +670,23 @@ Server::Private::find_handler(const Command& cmd)
 		throw Error{Error::Code::InvalidArgument, "invalid batch-size {}", batch_size};
 
 	auto qflags{QueryFlags::SkipUnreadable}; // don't show unreadables.
-	if (descending)
+	Sexp resprops;
+	if (descending) {
 		qflags |= QueryFlags::Descending;
-	if (skip_dups)
+		resprops.put_props(":reverse", Sexp::t_sym);
+	}
+	if (skip_dups) {
 		qflags |= QueryFlags::SkipDuplicates;
-	if (include_related)
+		resprops.put_props(":skip-dups", Sexp::t_sym);
+	}
+	if (include_related) {
 		qflags |= QueryFlags::IncludeRelated;
-	if (threads)
+		resprops.put_props(":include-related", Sexp::t_sym);
+	}
+	if (threads) {
 		qflags |= QueryFlags::Threading;
+		resprops.put_props(":threads", Sexp::t_sym);
+	}
 
 	StopWatch sw{mu_format("{} (indexing: {})", __func__,
 			       indexer().is_running() ? "yes" :  "no")};
@@ -696,11 +705,12 @@ Server::Private::find_handler(const Command& cmd)
 	const auto bsize{static_cast<size_t>(batch_size)};
 	const auto foundnum = output_results(*qres, bsize);
 
-	output_sexp(Sexp().put_props(
+	output_sexp(resprops.put_props(
 			    ":found", foundnum,
 			    ":query", q,
 			    ":query-sexp", parse_query(q, false/*!expand*/).to_string(),
-			    ":query-sexp-expanded", parse_query(q, true/*expand*/).to_string()));
+			    ":query-sexp-expanded", parse_query(q, true/*expand*/).to_string(),
+			    ":maxnum", maxnum));
 }
 
 void

From cd3cb648930bf23592a206cd44532d6623cb3ccd Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Fri, 7 Feb 2025 23:43:06 +0200
Subject: [PATCH 217/305] update docs

---
 IDEAS.org      | 22 +++++++++++++---------
 NEWS.org       | 20 +++++++++++++++++---
 mu4e/mu4e.texi | 16 ++++++++++++++++
 3 files changed, 46 insertions(+), 12 deletions(-)

diff --git a/IDEAS.org b/IDEAS.org
index 1b5806d81..c3ccc512f 100644
--- a/IDEAS.org
+++ b/IDEAS.org
@@ -32,11 +32,6 @@ future.
 
 ** mu4e
 
-- Support automatic handling for List-Unsubscribe headers and more in general,
-  handle mailing-list commands https://github.com/djcb/mu/issues/2623 and
-  https://github.com/djcb/mu/issues/2724 This seems useful, but probably
-  requires a lot of testing to get right. Can we re-use the Gnus code for this?
-
 - Allow for *muting* messages https://github.com/djcb/mu/issues/636 Useful;
   probably need to do this by *remembering* the thread-id of muted messages; and
   management (unmute etc.). Perhaps at the mu side, a list of thread-id to add
@@ -61,12 +56,12 @@ future.
   invisible unicode to fool crm-separator?
   https://github.com/djcb/mu/issues/2768
 
-- Org-link type for any message matching some reference
-  See: https://github.com/djcb/mu/issues/2787.
-  Some first steps implemented (searching for references).
+- Org-link type for any message matching some reference See:
+  https://github.com/djcb/mu/issues/2787. Some first steps implemented
+  (searching for references).
 
 - Reply/forward/... to multiple messages at once. This is sometimes useful, and
-  Gnus supports. Does not seem trivial to re-use the Gnus code... (see
+  Gnus supports it. Does not seem trivial to re-use the Gnus code... (see
   ~gnus-summary-work-articles~ etc.).
   https://github.com/djcb/mu/issues/2799
 
@@ -78,3 +73,12 @@ future.
 - Support mu4e-mark-handle-when also for when leaving emacs
   (kill-emacs-query-functions).
   https://github.com/djcb/mu/issues/2649
+
+- Support automatic handling for List-Unsubscribe headers and more in general,
+  handle mailing-list commands https://github.com/djcb/mu/issues/2623 and
+  https://github.com/djcb/mu/issues/2724 This seems useful, but probably
+  requires a lot of testing to get right. Can we re-use the Gnus code for this?
+
+  Yes: this is implemented now, in 1.12.9. Various Gnus' mailing list commands
+  are now available in the mu4e message view as well, such as
+  ~gnus-mailing-list-subscribe~, ~gnus-mailing-list-unsubscribe~.
diff --git a/NEWS.org b/NEWS.org
index a28751bbe..8b269fcac 100644
--- a/NEWS.org
+++ b/NEWS.org
@@ -67,9 +67,23 @@
     result you expected.
 
   - When you ask for bookmarks or maildirs through ~mu4e-ask-bookmark~ or
-    ~mu4e-ask-maildir~, unread counts are displayed in the (default) completions UI
-    next to the maildir or bookmark. If you don't want to see these counts, set
-    ~mu4e-hide-short-counts~ to non-~nil~.
+    ~mu4e-ask-maildir~, unread counts are displayed in the (default) completions
+    UI next to the maildir or bookmark. If you don't want to see these counts,
+    set ~mu4e-hide-short-counts~ to non-~nil~.
+
+  - A (experimental) "transient" menu has been added for mu4e. You can use
+    it e.g., with something like:
+
+    #+begin_src elisp
+      (require 'mu4e-transient)
+      (global-set-key (kbd "C-c m") #'mu4e-transient-menu)
+    #+end_src
+    This is will change/improve, but is already quite useful.
+
+  - Various Gnus' mailing list commands are now available in the mu4e message
+    view as well, such as ~gnus-mailing-list-subscribe~,
+    ~gnus-mailing-list-unsubscribe~.
+
 
 * 1.12 (released on February 24, 2024)
 
diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index 3261e4f87..087cbb314 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -1319,6 +1319,7 @@ from @t{gnus-article-mode}.
 * Custom headers: MSGV Custom headers. Your very own headers
 * Actions: MSGV Actions. Defining and using actions
 * Detaching & reattaching: MSGV Detaching and reattaching. Multiple message views.
+* Mailing lists: MSGV Mailing lists. Subscribing and unsubscribing.
 @end menu
 
 @node MSGV Overview
@@ -1639,6 +1640,21 @@ You can @emph{tear off} the window a message is in and place it in a
 new frame by typing @key{C-x w ^ f}. You can also detach a window and
 put it in its own tab with @key{C-x w ^ t}.
 
+@node MSGV Mailing lists
+@section Mailing lists
+
+In the message view (but not the headers vies), @t{mu4e} supports various
+commands for dealing with mailing-lists, such as subscribing and unsubscribing.
+
+@itemize
+@item @code{gnus-mailing-list-subscribe}: subscribe to mailing-list
+@item @code{gnus-mailing-list-unsubscribe}: unsubscribe from mailing-list
+@item @code{gnus-mailing-list-help}: request help for mailing-list
+@end itemize
+
+These commands depend on the current message to contain the necessary
+information for these commands.
+
 @node Composer
 @chapter Composer
 

From 7baf1bf5e56f5f6e45f080021f4ade4f30e623ff Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Thu, 13 Feb 2025 22:48:03 +0200
Subject: [PATCH 218/305] mu: remove empty refs + unit-test

Some message can have an _empty_ message-id, e.g. with:
  In-Reply-To: <>
which we weren't filter out.

This would yield and _empty_ Thread-Id, in mu-message.cc

And this would make mu-query believe it had no matches in the first
query, in Query::Private::run_related, and effectively throw away the
results. (Xapian using empty string both for a "not found" result, and
"found an empty string doesn't help either).

So, avoid having an empty reference. Also add a unit-test.

Fixes #2812.
---
 lib/message/mu-mime-object.cc    |  9 ++++--
 lib/tests/test-mu-store-query.cc | 53 ++++++++++++++++++++++++++++++++
 2 files changed, 59 insertions(+), 3 deletions(-)

diff --git a/lib/message/mu-mime-object.cc b/lib/message/mu-mime-object.cc
index a75da5bed..37b9020c2 100644
--- a/lib/message/mu-mime-object.cc
+++ b/lib/message/mu-mime-object.cc
@@ -1,5 +1,5 @@
 /*
-** Copyright (C) 2022-2023 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2022-2025 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify it
 ** under the terms of the GNU General Public License as published by the
@@ -426,7 +426,10 @@ MimeMessage::references() const noexcept
 		return seq_some(seq, [&](auto&& str) { return ref == str; });
 	};
 
-	auto is_fake = [](auto&& msgid) {
+	auto on_blacklist = [](auto&& msgid) {
+		// don't include empty message-ids
+		if (!*msgid)
+			return true;
 		// this is bit ugly; protonmail injects fake References which
 		// can otherwise screw up threading.
 		if (g_str_has_suffix(msgid, "protonmail.internalid"))
@@ -447,7 +450,7 @@ MimeMessage::references() const noexcept
 
 		for (auto i = 0; i != g_mime_references_length(mime_refs); ++i) {
 			const auto msgid{g_mime_references_get_message_id(mime_refs, i)};
-			if (msgid && !is_dup(refs, msgid) && !is_fake(msgid))
+			if (msgid && !is_dup(refs, msgid) && !on_blacklist(msgid))
 				refs.emplace_back(msgid);
 		}
 		g_mime_references_free(mime_refs);
diff --git a/lib/tests/test-mu-store-query.cc b/lib/tests/test-mu-store-query.cc
index c79c43f16..0baa7992b 100644
--- a/lib/tests/test-mu-store-query.cc
+++ b/lib/tests/test-mu-store-query.cc
@@ -919,6 +919,57 @@ Boo!
 }
 
 
+static void
+test_related_empty_in_reply_to()
+{
+	g_test_bug("2812");
+	// test message sent to self, and copy of received msg.
+
+	const auto test_msg = R"(From: "Edward Mallory" <ed@leviathan.gb>
+To: "Russ Hildebrandt <russ@example.com>
+Subject: New Prospect
+Date: Wed, 07 Dec 2022 18:38:06 +0200
+Message-ID: <875ysdfentbhg.fsf@djcbsoftware.nl>
+MIME-Version: 1.0
+In-Reply-To: <>
+Content-Type: text/plain
+
+Boo!
+)";
+	const TestMap test_msgs = {
+		{"inbox/cur/msg1", test_msg }};
+
+	TempDir tdir;
+	auto store{make_test_store(tdir.path(), test_msgs, {})};
+
+	g_assert_cmpuint(store.size(), ==, 1);
+
+	// normal query should give 1
+	{
+		auto qr = store.run_query("maildir:/inbox", Field::Id::Date,
+					  QueryFlags::None);
+		assert_valid_result(qr);
+		g_assert_cmpuint(qr->size(), ==, 1);
+	}
+
+	// a related query should also give 1
+	{
+		auto qr = store.run_query("maildir:/inbox", Field::Id::Date,
+					  QueryFlags::IncludeRelated);
+		assert_valid_result(qr);
+		g_assert_cmpuint(qr->size(), ==, 1);
+	}
+
+	// a related/threading query should also give 1
+	{
+		auto qr = store.run_query("maildir:/inbox", Field::Id::Date,
+					  QueryFlags::IncludeRelated | QueryFlags::Threading);
+		assert_valid_result(qr);
+		g_assert_cmpuint(qr->size(), ==, 1);
+	}
+}
+
+
 static void
 test_html()
 {
@@ -1056,6 +1107,8 @@ main(int argc, char* argv[])
 			test_subject_kata_containers);
 	g_test_add_func("/store/query/related-dup-threaded",
 			test_related_dup_threaded);
+	g_test_add_func("/store/query/related-empty-in-reply-to",
+			test_related_empty_in_reply_to);
 	g_test_add_func("/store/query/html",
 			test_html);
 	g_test_add_func("/store/query/ngrams",

From 3dbd8b97637e0b46943251a49f6897987cc019fb Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 16 Feb 2025 17:25:57 +0200
Subject: [PATCH 219/305] mu4e: handle conversion from pcre regexps

mu server uses PCRE-compatible regular expressions, but mu4e needs
Emacs-style. In simple cases, the two are the same, but when it gets
slightly more complicated they do not.

E.g.,
  (foo|bar) => \(foo\|bar\)

Mu4e can do the conversion automatically, but for this the pcre2el
package (available in MELPA) is required, and is used if user installs
is. Anyway, this code implements the automatic conversion and adds some
documentation.

Fixes #2816.
---
 NEWS.org              |  4 +++
 man/mu-init.1.org     |  9 ++++++
 mu4e/mu4e-contacts.el | 66 +++++++++++++++++++++++++++++++++----------
 mu4e/mu4e-server.el   |  9 +++++-
 mu4e/mu4e.texi        | 18 ++++++++++--
 5 files changed, 87 insertions(+), 19 deletions(-)

diff --git a/NEWS.org b/NEWS.org
index 8b269fcac..ffd0a19b6 100644
--- a/NEWS.org
+++ b/NEWS.org
@@ -84,6 +84,10 @@
     view as well, such as ~gnus-mailing-list-subscribe~,
     ~gnus-mailing-list-unsubscribe~.
 
+  - The mu server uses PCRE-compatible regexps (for addresses), which are not
+    necessarily compatible with Emacs regular expressions. However, mu4e can now
+    automatically translate; this depends on the ~pcre2el~ package which the user
+    should install when using regular expression-addresses.
 
 * 1.12 (released on February 24, 2024)
 
diff --git a/man/mu-init.1.org b/man/mu-init.1.org
index d790f2f5e..b98cdb5e2 100644
--- a/man/mu-init.1.org
+++ b/man/mu-init.1.org
@@ -39,6 +39,15 @@ _email-address-or-regex_ can be either a plain e-mail address (such as
 for details), wrapped in */* (such as =/foo-.*@example\\.com/=). Depending on your
 shell, the argument may need to be quoted.
 
+A note of warning for *mu4e* users: any regular-expressions used with
+=--with-address= are also used by *mu4e*. Unfortunately, PCRE regular expressions
+are *not* generally compatible with Emacs regular expressions. For instance,
+*(foo|bar)* in PCRE syntax has *\(foo\|bar\)* as its Emacs equivalent.
+
+The good news is that *mu4e* can automatically translate the regular-expressions,
+if you allow it to, by installing the *pcre2el* Elisp package. See the *mu4e*
+documentation for further details.
+
 ** --ignored-address _email-address-or-regex_
 Specifies that some e-mail address is to be ignored from the contacts-cache (the
 option can be used multiple times). Such addresses then cannot be found with
diff --git a/mu4e/mu4e-contacts.el b/mu4e/mu4e-contacts.el
index 6a18ac1a4..1a63d403c 100644
--- a/mu4e/mu4e-contacts.el
+++ b/mu4e/mu4e-contacts.el
@@ -1,6 +1,6 @@
 ;;; mu4e-contacts.el --- Dealing with contacts -*- lexical-binding: t -*-
 
-;; Copyright (C) 2022-2024 Dirk-Jan C. Binnema
+;; Copyright (C) 2022-2025 Dirk-Jan C. Binnema
 
 ;; Author: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ;; Maintainer: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
@@ -22,14 +22,19 @@
 
 ;;; Commentary:
 
-;; Utility functions used in the mu4e
+;; Functions and configuration for dealing with contacts in mu4e.
 
 ;;; Code:
 (require 'cl-lib)
 (require 'message)
+
+;; opportunistic; if we have it, try convert pcre-style regexps (from the mu
+;; server) to emacs-style.
+(require 'pcre2el nil 'noerror)
+
+
 (require 'mu4e-helpers)
 (require 'mu4e-update)
-
 
 ;;; Configuration
 (defcustom mu4e-compose-complete-addresses t
@@ -114,23 +119,59 @@ predicate function. A value of nil keeps all the addresses."
           (repeat string))
   :group 'mu4e-compose)
 
-
 ;;; Internal variables
 (defvar mu4e--contacts-tstamp "0"
   "Timestamp for the most recent contacts update." )
 
 (defvar mu4e--contacts-set nil
   "Set with the full contact addresses for autocompletion.")
-
+
+(defun mu4e-rx-pcre-to-emacs (pcre-rx)
+  "Convert a PCRE regular-expression PCRE-RX to Emacs-style.
+
+This depends on the \"pcre2el\" package being available. If not,
+simply returns its argument. The same happen for
+regular-expressions that cannot be converted. See the pcre2el
+documentation for further details."
+  (let ((emacs-rx
+         (if (fboundp 'pcre-to-elisp)
+             (with-demoted-errors "pcre2el error: %S"
+               (pcre-to-elisp pcre-rx))
+           pcre-rx)))
+    (unless (string= pcre-rx emacs-rx)
+     (mu4e-log 'misc "converted %s => %s" pcre-rx emacs-rx))
+    emacs-rx))
+
+(defun mu4e--grab-rx-addr(addr)
+  "Grab the regexp address (if any) from ADDR.
+Address string ADDR is either a normal address like
+\"foo@example.com\", or a regex-address like
+\"/(foo|bar)@example\\.com/\". In the former case, return nil,
+and in latter case, return the part between the slashes."
+  (save-match-data
+    (when (string-match "^/\\(.*\\)/$" addr)
+      (match-string 1 addr))))
+
+(defun mu4e--massage-addresses (addrs)
+  "Convert list of addresses ADDRS into Emacs compatible.
+This means any regexp-addresses are converted from PCRE to Emacs.
+Other addresses remain unchanged."
+  (seq-map
+   (lambda (addr)
+     (if-let* ((rxaddr (mu4e--grab-rx-addr addr)))
+         (concat "/" (mu4e-rx-pcre-to-emacs rxaddr) "/")
+       addr))
+   addrs))
+
 ;;; user mail address
 (defun mu4e-personal-addresses (&optional no-regexp)
   "Get the list user's personal addresses, as passed to \"mu init\".
 
 The address are either plain e-mail addresses or regexps (strings
- wrapped / /). When NO-REGEXP is non-nil, do not include regexp
- address patterns (if any)."
+wrapped in / /). When NO-REGEXP is non-nil, do not include regexp
+address patterns (if any)."
   (seq-remove
-   (lambda (addr) (and no-regexp (string-match-p "^/.*/" addr)))
+   (lambda (addr) (and no-regexp (mu4e--grab-rx-addr addr)))
    (when-let* ((props (mu4e-server-properties)))
      (plist-get props :personal-addresses))))
 
@@ -142,14 +183,11 @@ with both the plain addresses and /regular expressions/."
   (when addr
     (seq-find
      (lambda (m)
-       (if (string-match "/\\(.*\\)/" m)
-           (let ((rx (match-string 1 m))
-                 (case-fold-search t))
-             (string-match rx addr))
+       (if-let* ((rxaddr (mu4e--grab-rx-addr m)) (case-fold-search t))
+           (string-match rxaddr addr)
          (eq t (compare-strings addr nil nil m nil nil 'case-insensitive))))
      (mu4e-personal-addresses))))
 
-
 (defun mu4e-personal-or-alternative-address-p (addr)
   "Is ADDR either a personal or an alternative address?
 
@@ -179,7 +217,6 @@ See #2680 for further details."
   (or (and addr (string= addr ""))
       (mu4e-personal-or-alternative-address-p addr)))
 
-
 ;; Helpers
 
 ;;; RFC2822 handling of phrases in mail-addresses
@@ -247,7 +284,6 @@ case a phrase contains a quote, it will be escaped."
         (format "%s <%s>" (mu4e--rfc822-quote-phrase name) email)
       email)))
 
-
 (defun mu4e--update-contacts (contacts &optional tstamp)
   "Receive a sorted list of CONTACTS newer than TSTAMP.
 Update an internal set with it.
diff --git a/mu4e/mu4e-server.el b/mu4e/mu4e-server.el
index bdf32f4f4..92501eb51 100644
--- a/mu4e/mu4e-server.el
+++ b/mu4e/mu4e-server.el
@@ -242,6 +242,8 @@ Checks whether the server process is live."
        (memq (process-status mu4e--server-process)
              '(run open listen connect stop)) t))
 
+(declare-function mu4e--massage-addresses "mu4e-contacts")
+
 (defsubst mu4e--server-eat-sexp-from-buf ()
   "Eat the next s-expression from `mu4e--server-buf'.
 Note: this is a string, not an emacs-buffer. `mu4e--server-buf gets
@@ -383,7 +385,12 @@ The server output is as follows:
 
          ;; received a pong message
          ((plist-get sexp :pong)
-          (setq mu4e--server-props (plist-get sexp :props))
+          (let ((props (plist-get sexp :props)))
+            ;; attempt to translate the regex-style.
+            (plist-put props :personal-addresses
+                       (mu4e--massage-addresses
+                        (plist-get props :personal-addresses)))
+            (setq mu4e--server-props props))
           (funcall mu4e-pong-func sexp))
 
          ;; receive queries info
diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index 087cbb314..b642b34d5 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -403,9 +403,8 @@ You can add some e-mail addresses, so @t{mu} recognizes them as yours:
 indexing messages. If you want to change them, you need to @t{init}
 once again.
 
-The addresses may also be basic PCRE regular expressions, wrapped in
-slashes, for example:
-
+The addresses may also be basic PCRE regular expressions, wrapped in slashes,
+for example:
 @example
   $ mu init --maildir=~/Maildir '--my-address=/foo-.*@@example\.com/'
 @end example
@@ -413,6 +412,19 @@ slashes, for example:
 If you want to see the values for your message-store, you can use
 @command{mu info}.
 
+Note: unfortunately, PCRE regular expressions are not the same as Emacs regular
+expressions. Very simple ones match, but e.g. @t{(foo|bar)} in PCRE syntax is
+specified as @t{\(foo\|bar\)} in Emacs/@t{mu4e}.
+
+The good news is that @t{mu4e} can do the conversion automatically; however for
+this to work, users needs to install the @t{pcre2el} package (available in
+MELPA), and ensure it is available in @t{load-path} when Emacs runs (a normal
+package-installation takes care of this). After that, @t{mu4e} takes care of the
+translation automatically.
+
+It is possible to come up with complicated PCRE regular expressions that are not
+translatable; if necessary, experiment with @t{pcre2el} to avoid this.
+
 @node Indexing your messages
 @section Indexing your messages
 

From 9b87dcbb1f18ae3a4afc4767a7118cf7d6158bae Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 22 Feb 2025 10:59:32 +0200
Subject: [PATCH 220/305] mu4e-update.el: cosmetics

---
 mu4e/mu4e-update.el | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/mu4e/mu4e-update.el b/mu4e/mu4e-update.el
index 5bb9e1da1..a8aa0dfd4 100644
--- a/mu4e/mu4e-update.el
+++ b/mu4e/mu4e-update.el
@@ -1,6 +1,6 @@
 ;;; mu4e-update.el --- Update the mu4e message store -*- lexical-binding: t -*-
 
-;; Copyright (C) 2011-2023 Dirk-Jan C. Binnema
+;; Copyright (C) 2011-2025 Dirk-Jan C. Binnema
 
 ;; Author: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ;; Maintainer: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
@@ -29,7 +29,7 @@
 
 (require 'mu4e-helpers)
 (require 'mu4e-server)
-
+
 ;;; Customization
 
 (defcustom mu4e-get-mail-command "true"
@@ -138,7 +138,6 @@ If non-nil, this is a plist of the form:
   "Name of buffer with cloned from the last update buffer.
 Useful for diagnosing update problems.")
 
-
 ;;; Internal variables / const
 (defconst mu4e--update-name " *mu4e-update*"
   "Name of the process and buffer to update mail.")
@@ -152,7 +151,6 @@ Useful for diagnosing update problems.")
   "Query string for `mu4e-get-mail-command' password.")
 (defvar mu4e--get-mail-password-regexp "^Remote: Enter password: $"
   "Regexp for a `mu4e-get-mail-command' password query.")
-
 
 (defun mu4e--get-mail-process-filter (proc msg)
   "Filter the MSG output of the `mu4e-get-mail-command' PROC.

From 9b741eb6f075bf493cd2810a6a7e9ac1df1e5d3e Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 22 Feb 2025 11:13:30 +0200
Subject: [PATCH 221/305] mu4e: use mu4e--started for per-mu4e-run setup

There's mu4e--initialized which needs to run once per emacs session,
but we also  have some setup to do for each "run" (mu4e --> mu4e-quit).
For the latter, we use mu4e--started.

Fixes #2818.
---
 mu4e/mu4e.el | 26 ++++++++++++++++----------
 1 file changed, 16 insertions(+), 10 deletions(-)

diff --git a/mu4e/mu4e.el b/mu4e/mu4e.el
index a89ea4d87..d0bb91e5c 100644
--- a/mu4e/mu4e.el
+++ b/mu4e/mu4e.el
@@ -57,7 +57,12 @@
   (eval '(add-to-list 'desktop-modes-not-to-save 'mu4e-compose-mode)))
 
 (defvar mu4e--initialized nil
-  "Is mu4e initialized? Only needed once per session.")
+  "Is mu4e initialized? Only needed once per Emacs session.")
+
+(defvar mu4e--started nil
+  "Has mu4e been started?
+I.e. have we received the server pong? Needed whenever
+we (re)start mu4e.")
 
 ;;;###autoload
 (defun mu4e (&optional background)
@@ -65,10 +70,10 @@
 Then, show the main window, unless BACKGROUND (prefix-argument)
 is non-nil."
   (interactive "P")
-  (if (not mu4e--initialized)
-      (progn
-        (mu4e--init-handlers)
-        (mu4e--start (unless background #'mu4e--main-view)))
+  (when (not mu4e--initialized)
+    (mu4e--init-handlers))
+  (if (not mu4e--started)
+      (mu4e--start (unless background #'mu4e--main-view))
     ;; mu4e already running; show unless BACKGROUND
     (unless background
       (if (buffer-live-p (get-buffer mu4e-main-buffer-name))
@@ -117,6 +122,7 @@ Otherwise, completely quit mu4e, including automatic updating."
 (defun mu4e--pong-handler (_data func)
   "Handle \"pong\" responses from the mu server.
 Invoke FUNC if non-nil."
+  (setq mu4e--started t)
   (let ((doccount (plist-get (mu4e-server-properties) :doccount)))
     (mu4e--check-requirements)
     (when func (funcall func))
@@ -134,8 +140,8 @@ If `mu4e-contexts' have been defined, but we don't have a context
 yet, switch to the matching one, or none matches, the first. If
 mu4e is already running, invoke FUNC (if non-nil).
 
-Otherwise, check requirements, then start mu4e. When successful, invoke
- FUNC (if non-nil) afterwards."
+Otherwise, check requirements, then start mu4e. When successful,
+invoke FUNC (if available) afterwards."
   (unless (mu4e-context-current)
     (mu4e--context-autoswitch nil mu4e-context-policy))
   (setq mu4e-pong-func
@@ -143,7 +149,7 @@ Otherwise, check requirements, then start mu4e. When successful, invoke
   ;; show some notification?
   (when mu4e-notification-support
     (add-hook 'mu4e-query-items-updated-hook #'mu4e--notification))
-  ;; modeline support
+  ;; mode-line support
   (when mu4e-modeline-support
     (mu4e--modeline-register #'mu4e--bookmarks-modeline-item 'global)
     (mu4e-modeline-mode)
@@ -170,7 +176,8 @@ Otherwise, check requirements, then start mu4e. When successful, invoke
   (setq ;; clear some caches
    mu4e-maildir-list nil
    mu4e--contacts-set nil
-   mu4e--contacts-tstamp "0")
+   mu4e--contacts-tstamp "0"
+   mu4e--started nil)
 
   (remove-hook 'mu4e-query-items-updated-hook #'mu4e--main-redraw)
   (remove-hook 'mu4e-query-items-updated-hook #'mu4e--modeline-update)
@@ -263,6 +270,5 @@ chance."
 
   (mu4e-setq-if-nil mu4e-queries-func      #'mu4e--query-items-queries-handler))
 
-;;;
 (provide 'mu4e)
 ;;; mu4e.el ends here

From 8145df4ab30f6cd793e2cb9a268678321acb4f1e Mon Sep 17 00:00:00 2001
From: Daniel Colascione <dancol@dancol.org>
Date: Sat, 22 Feb 2025 14:53:15 -0500
Subject: [PATCH 222/305] Use named function, not lambda, for refresh timer

This change turns the mu4e refresh timer into a named function, making
M-x list-timers output display a name having to do with mu4e instead
of an inscrutable "anonymous lambda" line.
---
 mu4e/mu4e.el | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/mu4e/mu4e.el b/mu4e/mu4e.el
index d0bb91e5c..8eb0c4dc4 100644
--- a/mu4e/mu4e.el
+++ b/mu4e/mu4e.el
@@ -131,8 +131,9 @@ Invoke FUNC if non-nil."
     (when (and mu4e-update-interval (null mu4e--update-timer))
       (setq mu4e--update-timer
             (run-at-time 0 mu4e-update-interval
-                         (lambda () (mu4e-update-mail-and-index
-                                     mu4e-index-update-in-background)))))))
+                         (defun mu4e--refresh-timer ()
+                           (mu4e-update-mail-and-index
+                            mu4e-index-update-in-background)))))))
 
 (defun mu4e--start (&optional func)
   "Start mu4e.

From 7d03d5f32ae86ced52fbe1a5aa154d696a29708b Mon Sep 17 00:00:00 2001
From: Daniel Colascione <dancol@dancol.org>
Date: Sat, 22 Feb 2025 14:54:24 -0500
Subject: [PATCH 223/305] Call file-readable-p only on non-remote files

Calling file-readable-p before reading a message file is fine
when the file is local, but when it's a remote file, doing so incurs
an extra network round trip.  It's not really necessary to do so
either: if the file is missing, we'll fail in the insert-file-contents
below anyway, so we're missing out only on a nicer warning message.
---
 mu4e/mu4e-headers.el | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/mu4e/mu4e-headers.el b/mu4e/mu4e-headers.el
index c214ce894..92b6dda3b 100644
--- a/mu4e/mu4e-headers.el
+++ b/mu4e/mu4e-headers.el
@@ -1432,7 +1432,8 @@ If SUBTHREAD is non-nil, only apply to subthread."
     (mu4e-error "Must be in mu4e-headers-mode (%S)" major-mode))
   (let* ((msg (mu4e-message-at-point))
          (path (mu4e-message-field msg :path))
-         (_exists (or (file-readable-p  path)
+         (_exists (or (file-remote-p path)
+                      (file-readable-p path)
                       (mu4e-warn "No message at %s" path)))
          (docid (or (mu4e-message-field msg :docid)
                     (mu4e-warn "No message at point")))

From cdb619e4f59b74d9a504df9244f726345c74f4e0 Mon Sep 17 00:00:00 2001
From: Daniel Colascione <dancol@dancol.org>
Date: Sat, 22 Feb 2025 14:48:22 -0500
Subject: [PATCH 224/305] Improve performance of index cleanup: use readdir(3),
 not access(2)

This change makes index cleanup ~4x faster by changing how we
determine whether a file mentioned by the database still exists on
disk.  Previously, we'd call access(2) for each file the database
mentioned.  Doing so produced a lot of system call overhead.  Now, we
read the directory entries of the directories containing the files
whose existence we're checking, build a hash table from what we find,
then do the existence check against this hash table instead of
entering the kernel.

The semantics of the cleanup check do change subtly, however.
Previously, we checked whether the mentioned file was *readable*.
Now we check merely that it exists.  Extant but unreadable files in
maildirs should be rare.

BEFORE:

$ time mu index --lazy-check
lazily indexing maildir /home/dancol/Mail -> store /home/dancol/.cache/mu/xapian
/ indexing messages; checked: 0; updated/new: 0; cleaned-up: 0

real    0m19.310s
user    0m1.803s
sys     0m12.999s

AFTER:

$ time mu --debug index --lazy-check
lazily indexing maildir /home/dancol/Mail -> store /home/dancol/.cache/mu/xapian
- indexing messages; checked: 0; updated/new: 0; cleaned-up: 0

real    0m4.584s
user    0m2.433s
sys     0m2.133s
---
 lib/mu-indexer.cc | 32 +++++++++++++++++++++++++++++++-
 1 file changed, 31 insertions(+), 1 deletion(-)

diff --git a/lib/mu-indexer.cc b/lib/mu-indexer.cc
index 65fc0c6a2..0e1d8e725 100644
--- a/lib/mu-indexer.cc
+++ b/lib/mu-indexer.cc
@@ -29,6 +29,8 @@
 #include <condition_variable>
 #include <iostream>
 #include <atomic>
+#include <unordered_map>
+#include <unordered_set>
 #include <chrono>
 using namespace std::chrono_literals;
 
@@ -280,9 +282,37 @@ Indexer::Private::cleanup()
 
 	size_t                 n{};
 	std::vector<Store::Id> orphans; // store messages without files.
+
+	using DirFiles = std::unordered_set<std::string>;
+	std::unordered_map<std::string, DirFiles> dir_cache;
+
+	auto get_dir_files = [](const std::string& path) -> DirFiles {
+		DirFiles ret;
+		auto dir{::opendir(path.c_str())};
+		if (dir) {
+			struct dirent* dentry;
+			while ((dentry = ::readdir(dir))) {
+				ret.emplace(dentry->d_name);
+			}
+			::closedir(dir);
+		}
+
+		return ret;
+	};
+
+	auto is_file_present = [&](const std::string& path) -> bool {
+		std::string dir = dirname(path);
+		auto [it, inserted] = dir_cache.try_emplace(dir);
+		DirFiles& dir_files = it->second;
+		if (inserted) {
+			dir_files = get_dir_files(dir);
+		}
+		return dir_files.find(basename(path)) != dir_files.end();
+	};
+
 	store_.for_each_message_path([&](Store::Id id, const std::string& path) {
 		++n;
-		if (::access(path.c_str(), R_OK) != 0) {
+		if (!is_file_present(path)) {
 			mu_debug("cannot read {} (id={}); queuing for removal from store",
 				 path, id);
 			orphans.emplace_back(id);

From 18092c7ff9d3a9f478dc9fb305bdec63254d945a Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 23 Feb 2025 11:36:46 +0200
Subject: [PATCH 225/305] indexer: minor tweaking

---
 lib/mu-indexer.cc | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/lib/mu-indexer.cc b/lib/mu-indexer.cc
index 0e1d8e725..482812d92 100644
--- a/lib/mu-indexer.cc
+++ b/lib/mu-indexer.cc
@@ -1,5 +1,5 @@
 /*
-** Copyright (C) 2020-2023 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2020-2025 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify it
 ** under the terms of the GNU General Public License as published by the
@@ -22,12 +22,9 @@
 #include <config.h>
 
 #include <atomic>
-#include <algorithm>
 #include <mutex>
 #include <vector>
 #include <thread>
-#include <condition_variable>
-#include <iostream>
 #include <atomic>
 #include <unordered_map>
 #include <unordered_set>
@@ -286,11 +283,11 @@ Indexer::Private::cleanup()
 	using DirFiles = std::unordered_set<std::string>;
 	std::unordered_map<std::string, DirFiles> dir_cache;
 
-	auto get_dir_files = [](const std::string& path) -> DirFiles {
+	// get a set of file names in this directory.
+	const auto get_dir_files = [](const std::string& path) -> DirFiles {
 		DirFiles ret;
-		auto dir{::opendir(path.c_str())};
-		if (dir) {
-			struct dirent* dentry;
+		if (auto dir{::opendir(path.c_str())}; dir) {
+			dirent* dentry{};
 			while ((dentry = ::readdir(dir))) {
 				ret.emplace(dentry->d_name);
 			}
@@ -300,7 +297,8 @@ Indexer::Private::cleanup()
 		return ret;
 	};
 
-	auto is_file_present = [&](const std::string& path) -> bool {
+	// is the file present in our set?
+	const auto is_file_present = [&](const std::string& path) -> bool {
 		std::string dir = dirname(path);
 		auto [it, inserted] = dir_cache.try_emplace(dir);
 		DirFiles& dir_files = it->second;

From 2714aa5e8cd56dd05a59f706c6c42855fef16978 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Mon, 24 Feb 2025 19:29:01 +0200
Subject: [PATCH 226/305] mu4e-headers: remove existence check

This is already done on the server-side ("SkipUnreadable"), so we don't
need to replicate.
---
 mu4e/mu4e-headers.el | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/mu4e/mu4e-headers.el b/mu4e/mu4e-headers.el
index 92b6dda3b..a8f129ec6 100644
--- a/mu4e/mu4e-headers.el
+++ b/mu4e/mu4e-headers.el
@@ -1,6 +1,6 @@
 ;;; mu4e-headers.el --- Message headers -*- lexical-binding: t; coding:utf-8 -*-
 
-;; Copyright (C) 2011-2024 Dirk-Jan C. Binnema
+;; Copyright (C) 2011-2025 Dirk-Jan C. Binnema
 
 ;; Author: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ;; Maintainer: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
@@ -1431,10 +1431,6 @@ If SUBTHREAD is non-nil, only apply to subthread."
   (unless (eq major-mode 'mu4e-headers-mode)
     (mu4e-error "Must be in mu4e-headers-mode (%S)" major-mode))
   (let* ((msg (mu4e-message-at-point))
-         (path (mu4e-message-field msg :path))
-         (_exists (or (file-remote-p path)
-                      (file-readable-p path)
-                      (mu4e-warn "No message at %s" path)))
          (docid (or (mu4e-message-field msg :docid)
                     (mu4e-warn "No message at point")))
          (mark-as-read

From 200ada502615581aa8cb4c126a85fbbb4333d575 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 25 Feb 2025 18:04:17 +0200
Subject: [PATCH 227/305] mu4e.texi: update debugging information

---
 mu4e/mu4e.texi | 38 ++++++++++++++++++++------------------
 1 file changed, 20 insertions(+), 18 deletions(-)

diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index b642b34d5..3794ae176 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -5052,24 +5052,26 @@ they differ.
 @node Debugging
 @appendix Debugging
 
-As explained in @ref{How it works}, @t{mu4e} communicates with its
-backend (@t{mu server}) by sending commands and receiving responses
-(s-expressions).
-
-For debugging purposes, it can be very useful to see this data. For
-this reason, @t{mu4e} can log all these messages. Note that the
-`protocol' is documented to some extent in the @t{mu-server} manpage.
-
-You can enable (and disable) logging with @kbd{M-x
-mu4e-toggle-logging}. The log-buffer is called @t{*mu4e-log*}, and in
-the @ref{Main view}, @ref{Headers view} and @ref{Message view},
-there's a keybinding @key{$} that takes you there. You can quit it by
-pressing @key{q}.
-
-Logging can be a bit resource-intensive, so you may not want to leave
-it on all the time. By default, the log only maintains the most recent
-1200 lines. @t{mu} itself keeps a log as well, you can find it in
-@t{<MUHOME>/mu.log}, on Unix typically @t{~/.cache/mu/mu.log}.
+As explained in @ref{How it works}, @t{mu4e} communicates with its backend
+(@t{mu server}) by sending commands and receiving responses (s-expressions).
+
+For debugging purposes, it can be very useful to see this data. For this reason,
+@t{mu4e} can log all these messages. Note that the `protocol' is documented to
+some extent in the @t{mu-server} manpage.
+
+You can enable (and disable) logging with @kbd{M-x mu4e-toggle-logging}. The
+log-buffer is called @t{*mu4e-log*}, and in the @ref{Main view}, @ref{Headers
+view} and @ref{Message view}, there's a keybinding @key{$} that takes you there.
+You can quit it by pressing @key{q}.
+
+Logging can be a bit resource-intensive, so you may not want to leave it on all
+the time.
+
+@t{mu} itself keeps a log as well; depending on your system that could be in
+your @t{systemd} journal, @t{syslog} or in @t{<MUHOME>/mu.log}, on Unix
+typically @t{~/.cache/mu/mu.log}. To run the server in debug-mode, set
+@var{mu4e-mu-debug} to @t{t} (before starting the server).
+
 
 @node GNU Free Documentation License
 @appendix GNU Free Documentation License

From f5a8699993019e69f2649160ed509f0d3720b32c Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 25 Feb 2025 18:04:46 +0200
Subject: [PATCH 228/305] update NEWS.org

---
 NEWS.org | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/NEWS.org b/NEWS.org
index ffd0a19b6..6db67ddf1 100644
--- a/NEWS.org
+++ b/NEWS.org
@@ -47,6 +47,8 @@
     in the mu4e version in its main-page; however, since this is optional no
     longer, the suffix has been removed.
 
+  - the cleanup phase after indexing is significantly faster now
+
 *** mu4e
 
   - message composition has been completely reworked to avoid a number of
@@ -71,14 +73,14 @@
     UI next to the maildir or bookmark. If you don't want to see these counts,
     set ~mu4e-hide-short-counts~ to non-~nil~.
 
-  - A (experimental) "transient" menu has been added for mu4e. You can use
-    it e.g., with something like:
+  - A (experimental) "transient" menu has been added for mu4e. You can use it
+    e.g., with something like:
 
     #+begin_src elisp
       (require 'mu4e-transient)
       (global-set-key (kbd "C-c m") #'mu4e-transient-menu)
     #+end_src
-    This is will change/improve, but is already quite useful.
+    This will change/improve, but is already quite useful.
 
   - Various Gnus' mailing list commands are now available in the mu4e message
     view as well, such as ~gnus-mailing-list-subscribe~,

From 0ea6fd45a4bc575de7739c019c1c5f94a7850361 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Wed, 26 Feb 2025 18:44:32 +0200
Subject: [PATCH 229/305] update NEWS.org

---
 NEWS.org | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/NEWS.org b/NEWS.org
index 6db67ddf1..c099a0b1f 100644
--- a/NEWS.org
+++ b/NEWS.org
@@ -68,8 +68,8 @@
     server interpreted the last query; this can be useful if you don't get the
     result you expected.
 
-  - When you ask for bookmarks or maildirs through ~mu4e-ask-bookmark~ or
-    ~mu4e-ask-maildir~, unread counts are displayed in the (default) completions
+  - When you ask for bookmarks or maildirs through ~mu4e-search-bookmark~ or
+    ~mu4e-search-maildir~, unread counts are displayed in the (default) completions
     UI next to the maildir or bookmark. If you don't want to see these counts,
     set ~mu4e-hide-short-counts~ to non-~nil~.
 

From 60340c525d6c614ea4527de01baa8d926b89bb29 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Wed, 26 Feb 2025 18:44:51 +0200
Subject: [PATCH 230/305] build: bump version to 1.12.9

---
 Makefile    | 1 -
 meson.build | 6 ++----
 2 files changed, 2 insertions(+), 5 deletions(-)

diff --git a/Makefile b/Makefile
index c86a17e8b..c30a48e59 100644
--- a/Makefile
+++ b/Makefile
@@ -41,7 +41,6 @@ ifneq (${MU_HACKER},)
 MESON_FLAGS:=$(MESON_FLAGS) '-Dbuildtype=debug'    \
 			    '-Db_sanitize=address' \
 			    '-Dreadline=enabled'   \
-			    '-Dcpp_debugstl=enabled' \
 			    '-Dcpp_std=c++23'
 endif
 
diff --git a/meson.build b/meson.build
index 36cc4c696..4001cabd2 100644
--- a/meson.build
+++ b/meson.build
@@ -17,7 +17,7 @@
 ################################################################################
 # project setup
 project('mu', ['c', 'cpp'],
-        version: '1.12.8',
+        version: '1.12.9',
         meson_version: '>= 0.56.0',
         license: 'GPL-3.0-or-later',
         default_options : [
@@ -28,7 +28,7 @@ project('mu', ['c', 'cpp'],
 
 # hard-code the date here (for reproducibility); we derive the dates used in e.g.
 # documentation from this.
-mu_date='2024-12-17'
+mu_date='2025-02-26'
 
 # installation paths
 prefixdir = get_option('prefix')
@@ -322,8 +322,6 @@ if gmime_dep.version() == '3.2.13'
   warning('See: https://github.com/jstedfast/gmime/issues/133')
 endif
 
-
-
 # Local Variables:
 # indent-tabs-mode: nil
 # End:

From a7dcf04ba055188728d5ce00b1253aecfc3272f0 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Fri, 7 Mar 2025 16:11:48 +0100
Subject: [PATCH 231/305] mu4e-draft: ensure compose-type is available without
 parent

In non-parent messages, such as completely new message, ensure the
mu4e-compose-type is available during the initial composition, i.e.,
enlarge the let to cover the rest of `mu4e--prepare-draft'.
---
 mu4e/mu4e-draft.el | 58 +++++++++++++++++++++-------------------------
 1 file changed, 27 insertions(+), 31 deletions(-)

diff --git a/mu4e/mu4e-draft.el b/mu4e/mu4e-draft.el
index 47a72ef14..d65ab00fa 100644
--- a/mu4e/mu4e-draft.el
+++ b/mu4e/mu4e-draft.el
@@ -25,7 +25,6 @@
 ;; Implements various helper functions for mu4e-compose. This all
 ;; look a little convoluted since we need to subvert the gnus/message
 ;; functions a bit to work with mu4e.
-
 (require 'message)
 (require 'mu4e-config)
 (require 'mu4e-helpers)
@@ -735,32 +734,32 @@ Returns the new buffer."
   ;; run pre-hook early, so user can influence later steps.
   (let ((mu4e-compose-parent-message parent)
         (mu4e-compose-type compose-type))
-    (run-hooks 'mu4e-compose-pre-hook))
-
-  (mu4e--prepare-draft parent)
-  ;; evaluate BODY; this must yield a hidden, live buffer. This is evaluated in
-  ;; a temp buffer with contains the parent-message, if any. if there's a
-  ;; PARENT, load the corresponding message into a temp-buffer before calling
-  ;; compose-func
-  (let ((draft-buffer)
-        (oldframe (selected-frame))
-        (oldwinconf (current-window-configuration)))
-    (with-temp-buffer
-      ;; provide a temp buffer so the compose-func can do its thing
-      (setq draft-buffer (mu4e--validate-hidden-buffer (funcall compose-func)))
-      (with-current-buffer draft-buffer
-        ;; we have our basic buffer; turn it into a full mu4e composition
-        ;; buffer.
-        (mu4e--prepare-draft-buffer compose-type parent)))
-    ;; we're ready for composition; let's display it in the way user configured
-    ;; things: directly through display buffer (via pop-t or otherwise through
-    ;; mu4e-window.
-    (if (eq mu4e-compose-switch 'display-buffer)
-        (pop-to-buffer draft-buffer)
-      (mu4e-display-buffer draft-buffer 'do-select))
-    ;; prepare possible message actions (such as cleaning-up)
-    (mu4e--prepare-post oldframe oldwinconf)
-    draft-buffer))
+    (run-hooks 'mu4e-compose-pre-hook)
+
+    (mu4e--prepare-draft parent)
+    ;; evaluate BODY; this must yield a hidden, live buffer. This is evaluated in
+    ;; a temp buffer with contains the parent-message, if any. if there's a
+    ;; PARENT, load the corresponding message into a temp-buffer before calling
+    ;; compose-func
+    (let ((draft-buffer)
+          (oldframe (selected-frame))
+          (oldwinconf (current-window-configuration)))
+      (with-temp-buffer
+        ;; provide a temp buffer so the compose-func can do its thing
+        (setq draft-buffer (mu4e--validate-hidden-buffer (funcall compose-func)))
+        (with-current-buffer draft-buffer
+          ;; we have our basic buffer; turn it into a full mu4e composition
+          ;; buffer.
+          (mu4e--prepare-draft-buffer compose-type parent)))
+      ;; we're ready for composition; let's display it in the way user
+      ;; configured things: directly through display buffer (via pop-t or
+      ;; otherwise through mu4e-window.
+      (if (eq mu4e-compose-switch 'display-buffer)
+          (pop-to-buffer draft-buffer)
+        (mu4e-display-buffer draft-buffer 'do-select))
+      ;; prepare possible message actions (such as cleaning-up)
+      (mu4e--prepare-post oldframe oldwinconf)
+      draft-buffer)))
 
 (defun mu4e--draft-with-parent (compose-type parent compose-func)
   "Draft a message based on some parent message.
@@ -771,10 +770,7 @@ but note the different order."
    (lambda ()
      (let ( ;; only needed for Fwd. Gnus has a bad default.
            (message-make-forward-subject-function
-            (list #'message-forward-subject-fwd))
-           ;; e.g. supersede needs parent for 'message-is-yours-p
-           (mu4e-compose-parent-message parent)
-           (mu4e-compose-type compose-type))
+            (list #'message-forward-subject-fwd)))
        (insert (mu4e--decoded-message parent))
        ;; let's make sure we don't use message-reply-headers from
        ;; some unrelated message.

From 5608892349fa8442e7d61c1f34db738a057e0504 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 8 Mar 2025 11:39:10 +0200
Subject: [PATCH 232/305] mu4e-vars: cosmetic

---
 mu4e/mu4e-vars.el | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/mu4e/mu4e-vars.el b/mu4e/mu4e-vars.el
index 6a95c326a..09b88a149 100644
--- a/mu4e/mu4e-vars.el
+++ b/mu4e/mu4e-vars.el
@@ -1,6 +1,6 @@
 ;;; mu4e-vars.el --- Variables and faces for mu4e -*- lexical-binding: t -*-
 
-;; Copyright (C) 2011-2023 Dirk-Jan C. Binnema
+;; Copyright (C) 2011-2025 Dirk-Jan C. Binnema
 
 ;; Author: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ;; Maintainer: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
@@ -26,7 +26,7 @@
 
 (require 'message)
 (require 'mu4e-helpers)
-
+
 ;;; Configuration
 (defgroup mu4e nil
   "Mu4e - an email-client for Emacs."
@@ -75,7 +75,6 @@ and show some \"Loading\" banner."
   :type 'boolean
   :group 'mu4e)
 
-
 ;;; Faces
 
 (defgroup mu4e-faces nil

From a15e640eb79012fc241b491c411b11abe37d33b4 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 8 Mar 2025 11:36:40 +0200
Subject: [PATCH 233/305] mu4e: implement :hide-if-no-unread

Make mu4e-maildir-shortcut and mu4e-bookmarks understand a property
:hide-if-no-unread~, which hides the maildir/bookmark from the main-view
if there are no unread messages which the corresponding query.
---
 NEWS.org                 |  4 +++
 mu4e/mu4e-bookmarks.el   |  4 +++
 mu4e/mu4e-folders.el     |  6 +++-
 mu4e/mu4e-helpers.el     | 27 +++++++++++++++++
 mu4e/mu4e-main.el        | 14 +++++----
 mu4e/mu4e-query-items.el | 20 +++++--------
 mu4e/mu4e.texi           | 65 +++++++++++++++++++++++++++-------------
 7 files changed, 101 insertions(+), 39 deletions(-)

diff --git a/NEWS.org b/NEWS.org
index c099a0b1f..41ca105e2 100644
--- a/NEWS.org
+++ b/NEWS.org
@@ -91,6 +91,10 @@
     automatically translate; this depends on the ~pcre2el~ package which the user
     should install when using regular expression-addresses.
 
+  - ~mu4e-maildir-shortcuts~ and ~mu4e-bookmarks~ now understand a property
+    ~:hide-if-no-unread~, which hides the maildir/bookmark from the main-view if
+    there are no unread messages which the corresponding query.
+
 * 1.12 (released on February 24, 2024)
 
 ** Some highlights
diff --git a/mu4e/mu4e-bookmarks.el b/mu4e/mu4e-bookmarks.el
index f118133f6..37127e2fd 100644
--- a/mu4e/mu4e-bookmarks.el
+++ b/mu4e/mu4e-bookmarks.el
@@ -65,6 +65,10 @@ item must be unique among `mu4e-bookmarks' and
 `mu4e-maildir-shortcuts'.
 - `:hide' - if t, the bookmark is hidden from the main-view and
 speedbar.
+- `:hide-if-no-unread' - if t, the shortcut is hidden from
+   the main-view if it contains are no unread messages.
+
+You can also use:
 - `:hide-unread' - do not show the counts of
 unread/total number of matches for the query in the main-view.
 This can be useful if a bookmark uses a very slow query.
diff --git a/mu4e/mu4e-folders.el b/mu4e/mu4e-folders.el
index fad001e4f..22d1ee281 100644
--- a/mu4e/mu4e-folders.el
+++ b/mu4e/mu4e-folders.el
@@ -105,9 +105,13 @@ Each of the list elements is a plist with at least:
 Optionally, you can add the following:
 `:name' - name of the maildir to be displayed in main-view.
 `:hide'  - if t, the shortcut is hidden from the main-view.
+`:hide-if-no-unread' - if it t, the shortcut is hidden from
+ the main-view if it contains no unread messages.
+
+ You can also use:
 `:hide-unread' - do not show the counts of unread/total number
  of matches for the maildir in the main-view, and is implied
-from `:hide'.
+ from `:hide'.
 
 For backward compatibility, an older form is recognized as well:
 
diff --git a/mu4e/mu4e-helpers.el b/mu4e/mu4e-helpers.el
index d756b81e5..c5c7634f0 100644
--- a/mu4e/mu4e-helpers.el
+++ b/mu4e/mu4e-helpers.el
@@ -593,6 +593,33 @@ This is mu4e's version of Emacs 29's `plistp'."
   (let ((len (proper-list-p object)))
     (and len (zerop (% len 2)))))
 
+(defun mu4e-plist-do (func plist)
+  "Apply FUNC to each element in PLIST.
+FUNC receives to arguments: the key and its value."
+  (when plist
+    (funcall func (car plist) (cadr plist))
+    (mu4e-plist-do func (cddr plist))))
+
+(defun mu4e-plist-remove (plist prop)
+  "Remove PROP from PLIST.
+Returns the updated PLIST."
+  ;; inspired by org-plist-delete
+  (let (p)
+    (while plist
+      (if (not (eq prop (car plist)))
+          (setq p (plist-put p (car plist) (nth 1 plist))))
+      (setq plist (cddr plist)))
+    p))
+
+(defun mu4e-plist-remove-nils (plist)
+  "Remove all properties with value nil from PLIST."
+  (let (p)
+    (while plist
+      (when (cadr plist)
+        (setq p (plist-put p (car plist) (cadr plist))))
+      (setq plist (cddr plist)))
+    p))
+
 (defun mu4e--message-hide-headers ()
   "Hide headers based on the `message-hidden-headers' variable.
 This is mu4e's version of the post-emacs-28 `message-hide-headers',
diff --git a/mu4e/mu4e-main.el b/mu4e/mu4e-main.el
index 56dc82f2a..803c269a8 100644
--- a/mu4e/mu4e-main.el
+++ b/mu4e/mu4e-main.el
@@ -223,10 +223,11 @@ for aligning them."
   (mapconcat
    (lambda (item)
      (cl-destructuring-bind
-         (&key hide name key favorite query &allow-other-keys) item
+         (&key name key favorite query
+               hide hide-if-no-unread unread &allow-other-keys) item
        ;; hide items explicitly hidden, without key or wrong category.
-       (if hide
-           ""
+       (if (or hide (and hide-if-no-unread (zerop unread)))
+           "" ;; hide
          (let ((item-info
                 ;; note, we have a function for the binding,
                 ;; and perhaps a different one for the lambda.
@@ -235,7 +236,7 @@ for aligning them."
                   (list #'mu4e-search-maildir #'mu4e-search
                         query))
                  ((eq item-type 'bookmarks)
-                 (list #'mu4e-search-bookmark #'mu4e-search-bookmark
+                  (list #'mu4e-search-bookmark #'mu4e-search-bookmark
                         (mu4e-get-bookmark-query key)))
                  (t
                   (mu4e-error "Invalid item-type %s" item-type)))))
@@ -410,8 +411,9 @@ instead."
   (unless (file-directory-p smtpmail-queue-dir)
     (mu4e-error "`smtpmail-queue-dir' does not exist"))
   (setq smtpmail-queue-mail (not smtpmail-queue-mail))
-  (message (concat "Outgoing mail will now be "
-                   (if smtpmail-queue-mail "queued" "sent directly")))
+  (mu4e-message
+   (concat "Outgoing mail will now be "
+           (if smtpmail-queue-mail "queued" "sent directly")))
   (unless (or (eq mu4e-split-view 'single-window)
               (not (buffer-live-p (get-buffer mu4e-main-buffer-name))))
     (mu4e--main-redraw)))
diff --git a/mu4e/mu4e-query-items.el b/mu4e/mu4e-query-items.el
index 90aad7e39..1c5018c71 100644
--- a/mu4e/mu4e-query-items.el
+++ b/mu4e/mu4e-query-items.el
@@ -228,25 +228,21 @@ bookmark or maildir."
              (list
               :name         name
               :query        query
-              :key          (plist-get item :key)
               :count        count
               :unread       unread
               :delta-count  (- count baseline-count)
               :delta-unread delta-unread)))
        ;; remember the *effective* query too; we don't really need it, but
        ;; useful for debugging.
-       (unless (string= query effective-query)
-         (plist-put value :effective-query effective-query))
-       ;;for matching maildir shortcuts
-       (when maildir (plist-put value :maildir maildir))
+       (setq value (plist-put value :effective-query effective-query))
+       (setq value (plist-put value :maildir maildir))
+       ;; copy some other items from item.
+       (mu4e-plist-do (lambda (k v)
+                        (when (memq k '(:key :maildir :hide :hide-if-no-unread
+                                             :hide-unread))
+                          (setq value (plist-put value k v)))) item)
        ;; nil props bring me discomfort
-       (when (plist-get item :favorite)
-         (plist-put value :favorite t))
-       (when (plist-get item :hide)
-         (plist-put value :hide t))
-       (when (plist-get item :hide-unread)
-         (plist-put value :hide-unread t))
-       value))
+       (mu4e-plist-remove-nils value)))
    data))
 
 (defun mu4e-query-items (&optional type)
diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index 3794ae176..088ed2168 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -840,12 +840,15 @@ instance:
      :query "list:mu-discuss.googlegroups.com AND date:7d..now"))
 @end lisp
 
-There are optional keys @t{:hide} to hide the bookmark from the main menu, but
-still have it available (using @key{b})) and @t{:hide-unread} to avoid
-generating the unread-number; that can be useful if you have bookmarks for slow
-queries. Note that @t{:hide-unread} is implied when the query is not a string;
-this for the common case where the query function involves some user input,
-which would be disruptive in this case.
+There are optional keys @code{:hide} to hide the bookmark or maildirs from the
+main menu, but still have it available (using @key{b})), and
+@code{:hide-if-no-unread} to hide it if there are no unread messages.
+
+To customize the display, there is also @code{:hide-unread} to avoid generating
+the unread-number; that can be useful if you have bookmarks for slow queries.
+Note that @code{:hide-unread} is implied when the query is not a string; this
+for the common case where the query function involves some user input, which
+would be disruptive in this case.
 
 There is also the optional @code{:favorite} property, which at most one bookmark
 should have; this bookmark is highlighted in the main view, and its
@@ -2180,18 +2183,36 @@ be instructive:
   "List of pre-defined queries that are shown on the main screen.
 
 Each of the list elements is a plist with at least:
-:name  - the name of the query
-:query - the query expression
-:key   - the shortcut key.
-
-Optionally, you add the following:
-:hide  - if t, bookmark is hidden from the main-view and speedbar.
-:hide-unread - do not show the counts of unread/total number
- of matches for the query. This can be useful if a bookmark uses
- a very slow query. :hide-unread is implied from :hide.
-"
+`:name'  - the name of the query
+`:query' - the query expression string or function
+`:key'   - the shortcut key (single character)
+
+Optionally, you can add the following:
+
+- `:favorite' - if t, monitor the results of this query, and make
+it eligible for showing its status in the modeline. At most
+one bookmark should have this set to t (otherwise the _first_
+bookmark is the implicit favorite). The query for the `:favorite'
+item must be unique among `mu4e-bookmarks' and
+`mu4e-maildir-shortcuts'.
+- `:hide' - if t, the bookmark is hidden from the main-view and
+speedbar.
+- `:hide-if-no-unread' - if t, the shortcut is hidden from
+   the main-view if it contains are no unread messages.
+
+You can also use:
+- `:hide-unread' - do not show the counts of
+unread/total number of matches for the query in the main-view.
+This can be useful if a bookmark uses a very slow query.
+
+`:hide-unread' is implied from `:hide'.
+
+Note: for efficiency, queries used to determine the unread/all
+counts do not discard duplicate or unreadable messages. Thus, the
+numbers shown may differ from the number you get from a normal
+query."
   :type '(repeat (plist))
-  :group 'mu4e)
+  :group 'mu4e-bookmarks)
 @end lisp
 
 You can replace these or add your own items, by putting in your
@@ -2303,14 +2324,18 @@ maildirs (folders) very quickly --- for example, getting to the @t{/lists}
 folder only requires you to type @kbd{jl}, then change to @t{/work} with
 @kbd{jw}.
 
-While in queries you need to quote folder names (maildirs) with spaces in
-them, you should @emph{not} quote them when used in
-@code{mu4e-maildir-shortcuts}, since @t{mu4e} does that automatically for you.
+While in queries you need to quote folder names (maildirs) with spaces in them,
+you should @emph{not} quote them when used in @code{mu4e-maildir-shortcuts},
+since @t{mu4e} does that automatically for you.
 
 The very same shortcuts are used by @kbd{M-x mu4e-mark-for-move} (default
 shortcut @key{m}); so, for example, if you want to move a message to the
 @t{/archive} folder, you can do so by typing @kbd{ma}.
 
+For further customization, you can use @code{:hide}, @code{:hide-if-no-unread},
+@code{:hide-unread} and @code{:favorite} properties, just like for
+@ref{Bookmarks and Maildirs}.
+
 @node Other search functionality
 @section Other search functionality
 

From 770aa793cbff5a98734366763d3cee28d3827022 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 9 Mar 2025 08:52:36 +0200
Subject: [PATCH 234/305] mu4e-actions: add note about
 mu4e-action-git-apply-patch

See: https://github.com/djcb/mu/issues/2827

And some cosmetics.
---
 mu4e/mu4e-actions.el | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/mu4e/mu4e-actions.el b/mu4e/mu4e-actions.el
index 04757824d..d4fc4de58 100644
--- a/mu4e/mu4e-actions.el
+++ b/mu4e/mu4e-actions.el
@@ -1,6 +1,6 @@
 ;;; mu4e-actions.el --- Actions for messages/attachments -*- lexical-binding: t -*-
 
-;; Copyright (C) 2011-2023 Dirk-Jan C. Binnema
+;; Copyright (C) 2011-2025 Dirk-Jan C. Binnema
 
 ;; Author: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ;; Maintainer: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
@@ -35,7 +35,6 @@
 (require 'mu4e-search)
 (require 'mu4e-contacts)
 (require 'mu4e-lists)
-
 ;;; Count lines
 
 (defun mu4e-action-count-lines (msg)
@@ -58,7 +57,6 @@ Later, we can create an attachment based on this message with
   (setq mu4e-captured-message msg)
   (message "Message has been captured"))
 
-
 (defun mu4e-action-copy-message-file-path (msg)
   "Save the full path for the current MSG to the kill ring."
   (kill-new (mu4e-message-field msg :path)))
@@ -123,6 +121,7 @@ file where you store your org-contacts."
       (shell-command
        (format "git apply %s"
                (shell-quote-argument (mu4e-message-field msg :path)))))))
+;; does this work correctly? I.e.: https://github.com/djcb/mu/issues/2827
 
 (defun mu4e-action-git-apply-mbox (msg &optional signoff)
   "Apply `MSG' a git patch with optional `SIGNOFF'.
@@ -250,7 +249,6 @@ the message."
          msgid (and (eq major-mode 'mu4e-view-mode)
                     (not (eq mu4e-split-view 'single-window))))))))
 
-
 ;;; Mailing list URLS
 
 (defun mu4e-action-browse-list-archive (msg)

From a8fac834d3919bb8d6657e0bffbdae1b1eccfbef Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 9 Mar 2025 08:54:44 +0200
Subject: [PATCH 235/305] update IDEAS.org

---
 IDEAS.org | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/IDEAS.org b/IDEAS.org
index c3ccc512f..f0435d6d2 100644
--- a/IDEAS.org
+++ b/IDEAS.org
@@ -68,6 +68,17 @@ future.
 - Add some way to add a quick bookmark for (e.g.)  the current thread
   https://github.com/djcb/mu/issues/2804
 
+- Support running mu4e over tramp
+  https://github.com/djcb/mu/issues/2815
+  Seems this is mostly possible already:
+    1. set mu4e-mu-binary to a shell script that sshes into the mail machine
+    2. added a custom file-name-handler-alist handler that implements file
+       operations for my mail directory by proxying to tramp
+  But perhaps can be documented.
+
+- Allow for watching notifications externally, perhaps using alert.el
+  https://github.com/djcb/mu/issues/2825
+
 * Done
 
 - Support mu4e-mark-handle-when also for when leaving emacs

From 9364d25af7d8f8d00e077a29310b047b8c4b4336 Mon Sep 17 00:00:00 2001
From: Jeremy Sowden <jeremy@azazel.net>
Date: Sun, 9 Mar 2025 21:25:55 +0000
Subject: [PATCH 236/305] man: fix some single-quoted strings

Commit 721aadc140f2 ("man: change quoting style") replaced single-quoted strings
of the form:

    'lorem ipsum'

with:

    `lorem ipsum'

to prevent the possibility of single quotes appearing at the beginning of lines,
because these will be misinterpreted by troff.  However, changes to the man-page
sources in 1.12.9 reintroduced some of these, including one which does appear at
the beginning of a line in mu-query(7):

    '"', '*', '(' and ')'. The details are shell-specific. In case of doubt, the

which results in the following warning:

    troff:<standard input>:25: warning: macro '"',' not defined

and the omission of that line from the rendered paragraph:

    NOTE:  if  you  use  queries on the command-line (say, for mu find), you
    need to quote any characters that would otherwise be interpreted by  the
    shell, such as *--analyze option can be useful.

Use back-ticks for the opening quotes.

Fixes: 5e2b7d52b24d ("mu-query.7: update documentation")
Signed-off-by: Jeremy Sowden <jeremy@azazel.net>
---
 man/mu-query.7.org | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/man/mu-query.7.org b/man/mu-query.7.org
index 694a56ebd..d9c380ebe 100644
--- a/man/mu-query.7.org
+++ b/man/mu-query.7.org
@@ -23,7 +23,7 @@ See the *ANALYZING QUERIES* section for further details.
 
 *NOTE:* if you use queries on the command-line (say, for *mu find*), you need to
 quote any characters that would otherwise be interpreted by the shell, such as
-'"', '*', '(' and ')'. The details are shell-specific. In case of doubt, the
+`"', `*', `(' and `)'. The details are shell-specific. In case of doubt, the
 *--analyze* option can be useful.
 
 * TERMS
@@ -136,7 +136,7 @@ $ mu find "hello*"
 #+end_example
 
 Quoting the "hello*" is recommended; some shells (but not all) would otherwise
-expand the '*' to all files in the current directory.
+expand the `*' to all files in the current directory.
 
 * REGULAR EXPRESSIONS
 
@@ -165,7 +165,7 @@ whitespace, so the search for a message with subject "hello world", you can writ
 #+begin_example
 mu find 'subject:/hello\\040world/'
 #+end_example
-(with the \040 specifying a space in the regular expression, and and extra '\'
+(with the \040 specifying a space in the regular expression, and and extra `\'
 to escape it). In many cases,
 #+begin_example
 mu find 'subject:/hello.world/'

From 3dd922ff6ca10dcc9ff2cd12f57b1134f89c4ff3 Mon Sep 17 00:00:00 2001
From: Jeremy Sowden <jeremy@azazel.net>
Date: Mon, 10 Mar 2025 21:42:06 +0000
Subject: [PATCH 237/305] man: escape a couple of back-slashes
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Otherwise:

    (with the \040 specifying a space in the regular expression, and and extra '\' to escape it)

is rendered as:

    (with the $ 40 specifying a space in the regular expression, and and extra `$´ to escape it)

Fixes: 5e2b7d52b24d ("mu-query.7: update documentation")
Signed-off-by: Jeremy Sowden <jeremy@azazel.net>
---
 man/mu-query.7.org | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/man/mu-query.7.org b/man/mu-query.7.org
index d9c380ebe..a561793d3 100644
--- a/man/mu-query.7.org
+++ b/man/mu-query.7.org
@@ -165,7 +165,7 @@ whitespace, so the search for a message with subject "hello world", you can writ
 #+begin_example
 mu find 'subject:/hello\\040world/'
 #+end_example
-(with the \040 specifying a space in the regular expression, and and extra `\'
+(with the \\040 specifying a space in the regular expression, and and extra `\\'
 to escape it). In many cases,
 #+begin_example
 mu find 'subject:/hello.world/'

From c91e4ef515bbfac713980cbf786d7e2ee4965a00 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 23 Mar 2025 09:20:59 +0200
Subject: [PATCH 238/305] mu-sexp: fix c++23 warning for suffix operator

Space between operator"" and _xxx is deprecated.
---
 lib/utils/mu-sexp.hh | 2 +-
 meson.build          | 5 ++++-
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/lib/utils/mu-sexp.hh b/lib/utils/mu-sexp.hh
index 8127cbfe7..4ddd64f01 100644
--- a/lib/utils/mu-sexp.hh
+++ b/lib/utils/mu-sexp.hh
@@ -301,7 +301,7 @@ MU_ENABLE_BITOPS(Sexp::Format);
  * String-literal; allow for ":foo"_sym to be a symbol
  */
 static inline Sexp::Symbol
-operator"" _sym(const char* str, std::size_t n)
+operator""_sym(const char* str, std::size_t n)
 {
 	return Sexp::Symbol{str};
 }
diff --git a/meson.build b/meson.build
index 4001cabd2..d1c7b8bb3 100644
--- a/meson.build
+++ b/meson.build
@@ -62,7 +62,10 @@ extra_flags = [
   '-Wno-switch-enum',
   # assuming these are false alarm... (in fmt, with gcc13):
   '-Wno-array-bounds',
-  '-Wno-stringop-overflow',]
+  '-Wno-stringop-overflow',
+  # c++23, in tabulate.hpp (3rd-party)
+  '-Wno-deprecated-literal-operator'
+]
 
 if (cxx.get_id() == 'clang')
   extra_flags += [

From 4cda859eb8001342be30e46fdf2d9df7e39a5ee2 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 23 Mar 2025 17:09:03 +0200
Subject: [PATCH 239/305] mu-sexp: tighten definition of plistp

In a plist, we also require the first of each two element pairs to start
with ':'

Fixes #2830.
---
 lib/utils/mu-sexp.cc | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/lib/utils/mu-sexp.cc b/lib/utils/mu-sexp.cc
index 8434f986e..6a173b7c1 100644
--- a/lib/utils/mu-sexp.cc
+++ b/lib/utils/mu-sexp.cc
@@ -326,7 +326,9 @@ Sexp::plistp(Sexp::const_iterator b, Sexp::const_iterator e) const
 	else if (b + 1 == e)
 		return false;
 	else
-		return b->symbolp() && plistp(b + 2, e);
+		return b->symbolp() &&
+			b->symbol().name.starts_with(':')
+			&& plistp(b + 2, e);
 }
 
 

From d99785ed35ce030927abb75b30dd20dc3b127bc7 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 23 Mar 2025 09:30:59 +0200
Subject: [PATCH 240/305] mu4e.texi: fix compiler warning

---
 mu4e/mu4e.texi | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index 088ed2168..19005b320 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -3479,6 +3479,8 @@ It is possible to get information about the current header in the echo-area.
 You can enable this by setting @t{mu4e-eldoc-support} to non-@t{nil}.
 
 @node Org-mode
+@section Org-mode
+@cindex org-mode
 
 Org-mode is a popular and powerful way to deal with todo-lists, agendas inside
 Emacs. It's only natural to integrate it with @t{mu4e}, and

From 44ba631a349fc7ab08bb066e1629c36b696ace59 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 23 Mar 2025 19:43:07 +0200
Subject: [PATCH 241/305] mu-find: implement format=json2

Implement a new experimental json2 format for mu-find, which gets rid of
the ":" prefixes for fields, i.e., "subject" instead of ":subject".
Document it as well.
---
 NEWS.org             | 14 +++++++++-----
 lib/utils/mu-sexp.cc | 18 +++++++++++++-----
 lib/utils/mu-sexp.hh |  8 +++++---
 man/mu-find.1.org    | 21 ++++++++++++---------
 mu/mu-cmd-find.cc    |  8 ++++++--
 mu/mu-options.cc     |  5 ++++-
 mu/mu-options.hh     |  6 +++---
 7 files changed, 52 insertions(+), 28 deletions(-)

diff --git a/NEWS.org b/NEWS.org
index 41ca105e2..aa24075e7 100644
--- a/NEWS.org
+++ b/NEWS.org
@@ -35,6 +35,12 @@
     is a bit easier to manipulate than the emacs-style timestamps (same value,
     but expressed as a list).
 
+  - With 1.12.10, there is also an experimental ~--format=json2~, where key-names
+    are no longer prefixed with ~:~, so for example, "*subject"* instead of
+    "*:subject"*.
+
+  - With 1.12.9, the cleanup phase after indexing is significantly faster now
+
   - with 1.12.7, ~mu~ indexing is single-threaded again, to avoid cases of
     database-corruption. In *mu4e* that means you need to _wait_ until indexing is
     ready before you can continue (*mu4e* will warn you).
@@ -47,8 +53,6 @@
     in the mu4e version in its main-page; however, since this is optional no
     longer, the suffix has been removed.
 
-  - the cleanup phase after indexing is significantly faster now
-
 *** mu4e
 
   - message composition has been completely reworked to avoid a number of
@@ -69,9 +73,9 @@
     result you expected.
 
   - When you ask for bookmarks or maildirs through ~mu4e-search-bookmark~ or
-    ~mu4e-search-maildir~, unread counts are displayed in the (default) completions
-    UI next to the maildir or bookmark. If you don't want to see these counts,
-    set ~mu4e-hide-short-counts~ to non-~nil~.
+    ~mu4e-search-maildir~, unread counts are displayed in the (default)
+    completions UI next to the maildir or bookmark. If you don't want to see
+    these counts, set ~mu4e-hide-short-counts~ to non-~nil~.
 
   - A (experimental) "transient" menu has been added for mu4e. You can use it
     e.g., with something like:
diff --git a/lib/utils/mu-sexp.cc b/lib/utils/mu-sexp.cc
index 6a173b7c1..648e8ae20 100644
--- a/lib/utils/mu-sexp.cc
+++ b/lib/utils/mu-sexp.cc
@@ -228,6 +228,13 @@ Sexp::to_json_string(Format fopts) const
 {
 	std::stringstream sstrm;
 
+	const auto sym_name=[&](const std::string& sym) {
+		if (any_of(fopts & Format::NoColon) && sym[0] == ':')
+			return sym.substr(1); // remove colon
+		else
+			return sym;
+	};
+
 	switch (type()) {
 	case Type::List: {
 		// property-lists become JSON objects
@@ -237,16 +244,18 @@ Sexp::to_json_string(Format fopts) const
 			bool first{true};
 			while (it != list().end()) {
 				const auto key{it->symbol().name};
-				sstrm << (first ? "" : ",")  << quote(key) << ":";
+				sstrm << (first ? "" : ",")
+				      << quote(sym_name(key)) << ":";
 				++it;
 				const auto emacs_tstamp{*it};
-				sstrm << emacs_tstamp.to_json_string();
+				sstrm << emacs_tstamp.to_json_string(fopts);
 				++it;
 				first = false;
 				// special-case: tstamp-fields also get a "unix" value,
 				// which are easier to work with than the "emacs" timestamps
 				if (key == ":date" || key == ":changed")
-					sstrm << "," << quote(key + "-unix") << ":"
+					sstrm << "," << quote(sym_name(key) + "-unix")
+					      << ":"
 					      << unix_tstamp(emacs_tstamp);
 			}
 			sstrm << "}";
@@ -256,7 +265,7 @@ Sexp::to_json_string(Format fopts) const
 			sstrm << '[';
 			bool first{true};
 			for (auto&& child : list()) {
-				sstrm << (first ? "" : ", ") << child.to_json_string();
+				sstrm << (first ? "" : ", ") << child.to_json_string(fopts);
 				first = false;
 			}
 			sstrm << ']';
@@ -287,7 +296,6 @@ Sexp::to_json_string(Format fopts) const
 }
 
 
-
 Sexp&
 Sexp::del_prop(const std::string& pname)
 {
diff --git a/lib/utils/mu-sexp.hh b/lib/utils/mu-sexp.hh
index 4ddd64f01..8ffa39bcf 100644
--- a/lib/utils/mu-sexp.hh
+++ b/lib/utils/mu-sexp.hh
@@ -1,5 +1,5 @@
 /*
-** Copyright (C) 2020-2023 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2020-2025 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify it
 ** under the terms of the GNU General Public License as published by the
@@ -264,6 +264,8 @@ struct Sexp {
 		Default	  = 0,	/**< Nothing in particular */
 		SplitList = 1 << 0,	/**< Insert newline after list item */
 		TypeInfo  = 1 << 1, /**< Show type-info */
+		NoColon = 1 << 2, /**< In the Json output, remove the colon
+				       * prefixes for property keys */
 	};
 
 	/**
@@ -272,7 +274,7 @@ struct Sexp {
 	 * @return str
 	 */
 	std::string to_string(Format fopts=Format::Default) const;
-	std::string to_json_string(Format fopts=Format::Default) const;
+	std::string to_json_string(Format fopts) const;
 
 	Sexp& del_prop(const std::string& pname);
 
@@ -280,7 +282,7 @@ struct Sexp {
 	 * Some useful constants
 	 *
 	 */
-	static inline const auto nil_sym	= Sexp::Symbol{"nil"};
+	static inline const auto nil_sym = Sexp::Symbol{"nil"};
 	static inline const auto t_sym	= Sexp::Symbol{"t"};
 
 protected:
diff --git a/man/mu-find.1.org b/man/mu-find.1.org
index da3e4d710..dfb651351 100644
--- a/man/mu-find.1.org
+++ b/man/mu-find.1.org
@@ -34,8 +34,9 @@ would find all messages in 2009 with `snow' in the subject field, e.g:
 #+end_example
 
 Note, this the default, plain-text output, which is the default, so you don't
-have to use *--format=plain*. For other types of output (such as symlinks, XML or
-s-expressions), see the discussion in the *OPTIONS*-section below about *--format*.
+have to use *--format=plain*. For other types of output (such as symlinks, XML,
+s-expressions or JSON), see the discussion in the *OPTIONS*-section below about
+*--format*.
 
 The search pattern is taken as a command-line parameter. If the search
 parameter consists of multiple parts (as in the example) they are
@@ -114,13 +115,15 @@ Note, if you specify a sortfield, by default, messages are sorted in reverse
 choice, but for dates it may be more useful to sort in the opposite direction.
 
 ** -n, --maxnum _number_
+
 If _number_ > 0, display maximally that number of entries. If not specified, all
 matching entries are displayed.
 
 ** --summary-len _number_
+
 If _number_ > 0, use that number of lines of the message to provide a summary.
 
-** --format plain|links|xml|sexp
+** --format plain|links|xml|sexp|json|json2
 
 Output results in the specified format.
 
@@ -131,8 +134,13 @@ Output results in the specified format.
 - *xml* formats the search results as XML.
 - *sexp* formats the search results as an s-expression as used in Lisp programming
   environments.
+- *json* formats the output as JSON; it is a direct translation of the *sexp* format
+- *json2* is a slightly more idiomatic JSON, for now the only difference with *json*
+  is that the latter avoids the ':' prefix in key-names (e.g., "subject" instead
+  of ":subject"). *json2* is still experimental.
 
 ** --linksdir _dir_ and -c, --clearlinks
+
 When using *--format=links*, output the results as a maildir with symbolic links
 to the found messages. This enables easy integration with mail-clients (see
 below for more information). *mu* will create the maildir if it does not exist
@@ -152,6 +160,7 @@ it automatically inserts a _.noindex_ file, to exclude the directory from *mu
 index*.
 
 ** --after _timestamp_
+
 Only show messages whose message files were last modified (*mtime*) after
 _timestamp_. _timestamp_ is a UNIX *time_t* value, the number of seconds since
 1970-01-01 (in UTC).
@@ -279,8 +288,6 @@ After restarting Wanderlust, the virtual folders should appear.
 
 *mu find* output is encoded according to the locale for *--format=plain* (the
 default format), and UTF-8 for all other formats (=sexp=, =xml=).
-
-
 * PERFORMANCE
 
 Some notes on performance, comparing the timings between some recent releases;
@@ -289,7 +296,6 @@ taking the total number for 10 test runs.
 1. time (repeat 10 mu find "" -n 50000 > /dev/null)
 2. time (repeat 10 mu find "" -n 50000 --include-related --threads > /dev/null)
 
-
 #+ATTR_MAN: :disable-caption t
 |       release | time 1 (sec) | time 2 (sec) |
 |---------------+--------------+--------------|
@@ -299,9 +305,6 @@ taking the total number for 10 test runs.
 |          1.10 | 9.8s         | 30.6s        |
 | 1.11 (master) | 10.1s        | 29.5s        |
 
-
-
-
 #+include: "exit-code.inc" :minlevel 1
 
 #+include: "bugs.inc" :minlevel 1
diff --git a/mu/mu-cmd-find.cc b/mu/mu-cmd-find.cc
index ba7f779cd..3556b4545 100644
--- a/mu/mu-cmd-find.cc
+++ b/mu/mu-cmd-find.cc
@@ -1,5 +1,5 @@
  /*
-** Copyright (C) 2008-2024 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2008-2025 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify it
 ** under the terms of the GNU General Public License as published by the
@@ -383,7 +383,10 @@ output_json(const Option<Message>& msg, const OutputInfo& info, const Options& o
 	if (!msg)
 		return Ok();
 
-	mu_println("{}{}", msg->sexp().to_json_string(), info.last ? "" : ",");
+	const Sexp::Format frm{opts.find.format == Format::Json2 ?  Sexp::Format::NoColon :
+		Sexp::Format::Default};
+
+	mu_println("{}{}", msg->sexp().to_json_string(frm), info.last ? "" : ",");
 
 	return Ok();
 }
@@ -443,6 +446,7 @@ get_output_func(const Options& opts)
 	case Format::Sexp:
 		return output_sexp;
 	case Format::Json:
+	case Format::Json2:
 		return output_json;
 	default:
 		throw Error(Error::Code::Internal,
diff --git a/mu/mu-options.cc b/mu/mu-options.cc
index 40a8c12a9..1b58a28b0 100644
--- a/mu/mu-options.cc
+++ b/mu/mu-options.cc
@@ -1,5 +1,5 @@
 /*
-** Copyright (C) 2022-2024 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2022-2025 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify it
 ** under the terms of the GNU General Public License as published by the
@@ -339,6 +339,9 @@ sub_find(CLI::App& sub, Options& opts)
 			{ Format::Json,
 			  {"json", "JSON"}
 			},
+			{ Format::Json2,
+			  {"json2", "more idiomatic JSON"}
+			},
 		}};
 
 	sub.add_flag("--threads,-t", opts.find.threads,
diff --git a/mu/mu-options.hh b/mu/mu-options.hh
index fa440bf4b..643981263 100644
--- a/mu/mu-options.hh
+++ b/mu/mu-options.hh
@@ -1,5 +1,5 @@
 /*
-** Copyright (C) 2022-2023 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2022-2025 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify it
 ** under the terms of the GNU General Public License as published by the
@@ -149,7 +149,7 @@ struct Options {
 		std::string	bookmark;		/**<  use bookmark */
 		bool		analyze;		/**<  analyze query */
 
-		enum struct Format { Plain, Links, Xml, Json, Sexp, Exec };
+		enum struct Format { Plain, Links, Xml, Json, Json2, Sexp, Exec };
 		Format		format;			/**< Output format */
 		std::string	exec;			/**<  cmd to execute on matches */
 		bool		skip_dups;		/**< show only first with msg id */
@@ -256,7 +256,7 @@ struct Options {
 		bool	terminate;			/**< add \f between msgs in view */
 		OptSize summary_len;			/**< max # of lines for summary */
 
-		enum struct Format { Plain,  Sexp, Html };
+		enum struct Format { Plain, Sexp, Html };
 		Format format;				/**< output format*/
 
 		StringVec files;			/**< Message file(s) */

From 507ea8e18e7b7960d91f88a87bcb9de4da806afe Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 23 Mar 2025 20:22:56 +0200
Subject: [PATCH 242/305] mu-sexp: don't require > c++17

---
 lib/utils/mu-sexp.cc | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/utils/mu-sexp.cc b/lib/utils/mu-sexp.cc
index 648e8ae20..e11394f47 100644
--- a/lib/utils/mu-sexp.cc
+++ b/lib/utils/mu-sexp.cc
@@ -335,8 +335,8 @@ Sexp::plistp(Sexp::const_iterator b, Sexp::const_iterator e) const
 		return false;
 	else
 		return b->symbolp() &&
-			b->symbol().name.starts_with(':')
-			&& plistp(b + 2, e);
+			b->symbol().name[0] == ':' &&
+			plistp(b + 2, e);
 }
 
 

From da9ffc169f27eb3b4be2bca1562a43a0c0c980f8 Mon Sep 17 00:00:00 2001
From: Matteo Percivaldi <26527954+matperc@users.noreply.github.com>
Date: Fri, 4 Apr 2025 08:35:03 +0200
Subject: [PATCH 243/305] mu4e-notification: close notification once done

---
 mu4e/mu4e-notification.el | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/mu4e/mu4e-notification.el b/mu4e/mu4e-notification.el
index 1d47742f4..bb68b5b14 100644
--- a/mu4e/mu4e-notification.el
+++ b/mu4e/mu4e-notification.el
@@ -72,6 +72,11 @@ messages changed since the last notification and is greater than
 zero."
   (when-let* ((fav (mu4e-bookmark-favorite))
               (delta-unread (plist-get fav :delta-unread)))
+    (when (and (fboundp 'notifications-close-notification)
+               mu4e--notification-id
+               (zerop delta-unread))
+      (notifications-close-notification mu4e--notification-id)
+      (setq mu4e--notification-id nil))
     (when (and (> delta-unread 0)
                (not (= delta-unread mu4e--last-delta-unread)))
       (setq mu4e--last-delta-unread delta-unread) ;; update

From 0c7398d55cb4122cfee640b1a14b1c611717777b Mon Sep 17 00:00:00 2001
From: Danny Milosavljevic <dannym@friendly-machines.com>
Date: Sat, 5 Apr 2025 13:54:45 +0200
Subject: [PATCH 244/305] mu4e-compose: Heed shift-selection-mode for extending
 the selection.

Fixes #2836.
---
 mu4e/mu4e-compose.el | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/mu4e/mu4e-compose.el b/mu4e/mu4e-compose.el
index d1c4dade5..ead967b69 100644
--- a/mu4e/mu4e-compose.el
+++ b/mu4e/mu4e-compose.el
@@ -121,7 +121,7 @@ the beginning of the buffer.
 Push mark at previous position, unless either a
 \\[universal-argument] prefix ARG is supplied, or Transient Mark mode
 is enabled and the mark is active."
-  (interactive "P")
+  (interactive "^P")
   (or arg
       (region-active-p)
       (push-mark))
@@ -138,7 +138,7 @@ there, go to the end of the buffer.
 Push mark at previous position, unless either a
 \\[universal-argument] prefix ARG is supplied, or Transient Mark mode
 is enabled and the mark is active."
-  (interactive "P")
+  (interactive "^P")
   (or arg
       (region-active-p)
       (push-mark))

From bb76179e515094fcd71216c3b0d47c1753d5b075 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 12 Apr 2025 00:43:34 +0700
Subject: [PATCH 245/305] mu4e.texi: better document tagging actions

Remove some misleading old descriptions.

Cosmetics.

Fixes #2838
---
 mu4e/mu4e.texi | 72 ++++++++++++++++++++------------------------------
 1 file changed, 29 insertions(+), 43 deletions(-)

diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index 19005b320..0f65d09b3 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -2609,31 +2609,6 @@ If @code{:show-target} is @t{nil} the @t{DYN-TARGET} is shown (and
 @item @code{:action} --- the action to apply on the message when the mark is executed.
 @end itemize
 
-As an example, suppose we would like to add a mark for tagging messages
-(GMail-style). We can use the following code (after loading @t{mu4e}):
-
-@lisp
-(add-to-list 'mu4e-marks
-  '(tag
-     :char       "g"
-     :prompt     "gtag"
-     :ask-target (lambda () (read-string "What tag do you want to add? "))
-     :action     (lambda (docid msg target)
-                   (mu4e-action-retag-message msg (concat "+" target)))))
-@end lisp
-
-Adding elements to @code{mu4e-marks} (as in the example) allows you to use the
-mark in bulk operations (for example when tagging a whole thread); if you also
-want to add a key-binding for the headers view, you can use something like:
-
-@lisp
-(defun my-mu4e-mark-add-tag()
-  "Add a tag to the message at point."
-  (interactive)
-  (mu4e-headers-mark-and-next 'tag))
-
-(define-key mu4e-headers-mode-map (kbd "g") #'my-mu4e-mark-add-tag)
-@end lisp
 
 @node Contexts
 @chapter Contexts
@@ -2986,11 +2961,11 @@ compose a totally new message, the @code{msg} parameter is @code{nil}.
 @node Actions
 @chapter Actions
 
-@t{mu4e} lets you define custom actions for messages in @ref{Headers view}
-and for both messages and attachments in @ref{Message view}. Custom
-actions allow you to easily extend @t{mu4e} for specific needs --- for example,
-marking messages as spam in a spam filter or applying an attachment with a
-source code patch.
+@t{mu4e} lets you define custom actions for messages in @ref{Headers view} and
+for both messages and attachments in the @ref{Message view}. Custom actions
+allow you to easily extend @t{mu4e} for specific needs --- for example, marking
+messages as spam in a spam filter or applying an attachment with a source code
+patch.
 
 You can invoke the actions with key @key{a} for actions on messages, and key
 @key{A} for actions on attachments.
@@ -3033,16 +3008,16 @@ looks like:
 
 @noindent
 After you have defined your function, you can add it to the list of
-actions@footnote{Instead of defining the functions separately, you can
-obviously also add a @code{lambda}-function directly to the list; however,
-separate functions are easier to change}, either @code{mu4e-headers-actions},
-@code{mu4e-view-actions} or @code{mu4e-view-mime-part-actions}.  The
+actions@footnote{Instead of defining the functions separately, you can obviously
+also add a @code{lambda}-function directly to the list; however, separate
+functions are easier to change}, either @code{mu4e-headers-actions},
+@code{mu4e-view-actions} or @code{mu4e-view-mime-part-actions}. The
 format@footnote{Note, the format of the actions has changed since version
-0.9.8.4, and you must change your configuration to use the new format;
-@t{mu4e} warns you when you are using the old format.} of each action is a
-cons-cell, @code{(DESCRIPTION . VALUE)}; see below for some examples. If your
-shortcut is not also the first character of the description, simply prefix the
-description with that character.
+0.9.8.4, and you must change your configuration to use the new format; @t{mu4e}
+warns you when you are using the old format.} of each action is a cons-cell,
+@code{(DESCRIPTION . VALUE)}; see below for some examples. If your shortcut is
+not also the first character of the description, simply prefix the description
+with that character.
 
 Let's look at some examples.
 
@@ -3119,10 +3094,21 @@ Or another one, to import a calendar invitation into the venerable emacs diary:
 @node Example actions
 @section Example actions
 
-@t{mu4e} includes a number of example actions in the file
-@file{mu4e-actions.el} in the source distribution (see @kbd{C-h f
-mu4e-action-TAB}). For example, for viewing messages in an external web
-browser.
+@t{mu4e} includes a number of example actions in the file @file{mu4e-actions.el}
+in the source distribution (see @kbd{C-h f mu4e-action-TAB}). For example, for
+viewing messages in an external web browser or tagging.
+
+@cindex tagging
+It is easy to add such actions to your configuration; for instance, to enable
+@emph{tagging}@footnote{@t{mu4e} does not offer tagging by default since it
+mutates the message files, something that @t{mu}/@t{mu4e} generally try to
+avoid.} both in the message view and headers view, you could add:
+@lisp
+(add-to-list 'mu4e-headers-actions
+             '("Tag message" . mu4e-action-retag-message))
+(add-to-list 'mu4e-view-actions
+             '("Tag message" . mu4e-action-retag-message))
+@end lisp
 
 @node Extending mu4e
 @chapter Extending mu4e

From 17b85e8390e9b67089dd408592a0324c21e84016 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 12 Apr 2025 00:56:43 +0700
Subject: [PATCH 246/305] test-circular-symlink: loosen test a bit

Work-around some weirdness. No energy to do a root-cause analysis ;)

Fixes #2832.
---
 lib/tests/test-mu-store.cc | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/lib/tests/test-mu-store.cc b/lib/tests/test-mu-store.cc
index 9b0d59ae7..197375df5 100644
--- a/lib/tests/test-mu-store.cc
+++ b/lib/tests/test-mu-store.cc
@@ -497,6 +497,7 @@ test_store_circular_symlink(void)
 	allow_warnings();
 
 	g_test_bug("2517");
+	g_test_bug("2832");
 
 	auto testhome{unwrap(make_temp_dir())};
 	auto dbpath{runtime_path(RuntimePath::XapianDb, testhome)};
@@ -514,7 +515,7 @@ test_store_circular_symlink(void)
 	size_t n{};
 	while (store.indexer().is_running()) {
 		std::this_thread::sleep_for(100ms);
-		g_assert_cmpuint(n++,<=,25);
+		g_assert_cmpuint(n++,<=,27); // 25 should be enough but #2832...
 	}
 	// there will be a lot of dups....
 	g_assert_false(store.empty());

From 6f228fc50515aa92c51000d848c8bf91d487a376 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 16 Mar 2025 11:33:47 +0200
Subject: [PATCH 247/305] mu4e: clean up mu4e--make-query-items

Automatically copy all key-values from the source item.
---
 mu4e/mu4e-helpers.el     |  8 ++++++++
 mu4e/mu4e-query-items.el | 37 ++++++++++++++++---------------------
 2 files changed, 24 insertions(+), 21 deletions(-)

diff --git a/mu4e/mu4e-helpers.el b/mu4e/mu4e-helpers.el
index c5c7634f0..0f23dcf52 100644
--- a/mu4e/mu4e-helpers.el
+++ b/mu4e/mu4e-helpers.el
@@ -620,6 +620,14 @@ Returns the updated PLIST."
       (setq plist (cddr plist)))
     p))
 
+(defun mu4e-plist-put-many (plist &rest keyvals)
+  "Like `plist-put', but allow for multiple key-value pairs.
+PLIST is a property list, and KEYVALS are key value ... ."
+  (while keyvals
+    (plist-put plist (car keyvals) (cadr keyvals))
+    (setq keyvals (cdr keyvals)))
+  plist)
+
 (defun mu4e--message-hide-headers ()
   "Hide headers based on the `message-hidden-headers' variable.
 This is mu4e's version of the post-emacs-28 `message-hide-headers',
diff --git a/mu4e/mu4e-query-items.el b/mu4e/mu4e-query-items.el
index 1c5018c71..3c8edb96c 100644
--- a/mu4e/mu4e-query-items.el
+++ b/mu4e/mu4e-query-items.el
@@ -223,27 +223,22 @@ bookmark or maildir."
             (unread (or (plist-get last-results-item :unread) 0))
             (baseline-count  (or (plist-get baseline-item :count) count))
             (baseline-unread (or (plist-get baseline-item :unread) unread))
-            (delta-unread (- unread baseline-unread))
-            (value
-             (list
-              :name         name
-              :query        query
-              :count        count
-              :unread       unread
-              :delta-count  (- count baseline-count)
-              :delta-unread delta-unread)))
-       ;; remember the *effective* query too; we don't really need it, but
-       ;; useful for debugging.
-       (setq value (plist-put value :effective-query effective-query))
-       (setq value (plist-put value :maildir maildir))
-       ;; copy some other items from item.
-       (mu4e-plist-do (lambda (k v)
-                        (when (memq k '(:key :maildir :hide :hide-if-no-unread
-                                             :hide-unread))
-                          (setq value (plist-put value k v)))) item)
-       ;; nil props bring me discomfort
-       (mu4e-plist-remove-nils value)))
-   data))
+            (delta-unread (- unread baseline-unread)))
+       (mu4e-plist-remove-nils
+        (mu4e-plist-put-many
+         item
+         :name         name
+         :type         type
+         :query        query
+         :count        count
+         :unread       unread
+         :delta-count  (- count baseline-count)
+         :delta-unread delta-unread
+         :maildir      maildir
+         ;; remember the *effective* query too; we don't really need it, but
+         ;; useful for debugging.
+         :effective-query effective-query))))
+     data))
 
 (defun mu4e-query-items (&optional type)
   "Grab cached information about query items of some TYPE.

From a6c41f6262e2e02b0fd4dc8f380e7f0f6b3b19ea Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 16 Mar 2025 11:34:38 +0200
Subject: [PATCH 248/305] NEWS.org: merge new items with 1.12

Merge the new feature items into the 1.12 NEWS, prefixed with their
version.
---
 NEWS.org | 183 ++++++++++++++++++++++++++-----------------------------
 1 file changed, 86 insertions(+), 97 deletions(-)

diff --git a/NEWS.org b/NEWS.org
index aa24075e7..4df464a2f 100644
--- a/NEWS.org
+++ b/NEWS.org
@@ -1,105 +1,16 @@
 #+STARTUP:showall
 * NEWS (user visible changes & bigger non-visible ones)
 
-* 1.12 (post 1.12.0 updates)
-
- The 1.12 series has been stable for a fairly long time, and gained some changes
- in mean-time. Most of the changes are for big bugs, but some small new features
- are available as well.
-
- We decided to put off a new development series (1.13 -> 1.14) until
- incompatible changes are required; for now working in the 1.12 series seems a
- good way to get improvements to users more quickly.
-
- The changes include:
-
-  - many bug fixes
-
-  - many documentation improvements
-
-*** mu
-
-  - you can now search for messages that have a given message-id in their
-    ~References:~ or ~In-Reply-To:~ headers, e.g.
-    #+begin_example
-    mu find ref:0D9218A9-C7F5-4D50-B49C-FCE201114C9B@gmail.com
-    #+end_example
-    You do need to re-index the database for this to work though.
-
-    There's also a new combination-field ~related:~ which combines ~references:~ and
-    ~msgid:~.
-
-  - The ~--format=json~ output for *mu find* now includes "unix-style" timestamps
-    for ~:date~ and ~:changed~ (~:date-unix~ and ~:changed-unix~, respectively) which
-    represent the time as a simple number (number of seconds since epoch), which
-    is a bit easier to manipulate than the emacs-style timestamps (same value,
-    but expressed as a list).
-
-  - With 1.12.10, there is also an experimental ~--format=json2~, where key-names
-    are no longer prefixed with ~:~, so for example, "*subject"* instead of
-    "*:subject"*.
-
-  - With 1.12.9, the cleanup phase after indexing is significantly faster now
-
-  - with 1.12.7, ~mu~ indexing is single-threaded again, to avoid cases of
-    database-corruption. In *mu4e* that means you need to _wait_ until indexing is
-    ready before you can continue (*mu4e* will warn you).
-
-    If you see that warning often, perhaps your indexing is too slow; see the
-    section on "Speeding up indexing" in [[info:mu4e#Retrieval and indexing][Retrieval and indexing]] in the mu4e
-    manual.
-
-    Note: for a while, the single-threadedness was signified by an "-st" suffix
-    in the mu4e version in its main-page; however, since this is optional no
-    longer, the suffix has been removed.
-
-*** mu4e
-
-  - message composition has been completely reworked to avoid a number of
-    problems that users reported. It is now directly uses the Gnus machinery,
-    integrated with mu4e.
-
-  - a new variable ~mu4e-trash-without-flag~, which, when set to non-nil makes
-    trashing _not_ add the the Maildir ~T~ flag. See its docstring for details.
-
-  - new variable ~mu4e-uniquify-save-file-name-function~ to influence the way ~mu4e~
-    creates unique file names when saving. See its docstring for details.
-
-  - new command ~mu4e-view-jump-to-mime-part~ for jumping to MIME-part by its
-    number.
-
-  - new command ~mu4e-analyze-last-query~ which shows information about how the
-    server interpreted the last query; this can be useful if you don't get the
-    result you expected.
-
-  - When you ask for bookmarks or maildirs through ~mu4e-search-bookmark~ or
-    ~mu4e-search-maildir~, unread counts are displayed in the (default)
-    completions UI next to the maildir or bookmark. If you don't want to see
-    these counts, set ~mu4e-hide-short-counts~ to non-~nil~.
-
-  - A (experimental) "transient" menu has been added for mu4e. You can use it
-    e.g., with something like:
-
-    #+begin_src elisp
-      (require 'mu4e-transient)
-      (global-set-key (kbd "C-c m") #'mu4e-transient-menu)
-    #+end_src
-    This will change/improve, but is already quite useful.
-
-  - Various Gnus' mailing list commands are now available in the mu4e message
-    view as well, such as ~gnus-mailing-list-subscribe~,
-    ~gnus-mailing-list-unsubscribe~.
-
-  - The mu server uses PCRE-compatible regexps (for addresses), which are not
-    necessarily compatible with Emacs regular expressions. However, mu4e can now
-    automatically translate; this depends on the ~pcre2el~ package which the user
-    should install when using regular expression-addresses.
+* 1.12 (released on February 24, 2024)
 
-  - ~mu4e-maildir-shortcuts~ and ~mu4e-bookmarks~ now understand a property
-    ~:hide-if-no-unread~, which hides the maildir/bookmark from the main-view if
-    there are no unread messages which the corresponding query.
+  The 1.12 series has been stable for a fairly long time, and gained some
+  changes in mean-time. Most of the changes are for bug fixes and documentation
+  improvements, but new features are available as well. Those are listed below
+  the 1.12 changes, prefixed by the version in which they appeared.
 
-* 1.12 (released on February 24, 2024)
+  We decided to put off a new development series (1.13 -> 1.14) until
+  incompatible changes are required; for now working in the 1.12 series seems a
+  good way to get improvements to users more quickly.
 
 ** Some highlights
 
@@ -176,6 +87,46 @@
 
     - the build has been made reproducible
 
+    - 1.12.7: ~mu~ indexing is single-threaded again, to avoid cases of
+      database-corruption. In *mu4e* that means you need to _wait_ until indexing is
+      ready before you can continue (*mu4e* will warn you).
+
+      If you see that warning often, perhaps your indexing is too slow; see the
+      section on "Speeding up indexing" in [[info:mu4e#Retrieval and indexing][Retrieval and indexing]] in the mu4e
+      manual.
+
+      Note: for a while, the single-threadedness was signified by an "-st"
+      suffix
+      in the mu4e version in its main-page; however, since this is optional no
+      longer, the suffix has been removed.
+
+    - 1.12.8: The ~--format=json~ output for *mu find* now includes "unix-style"
+      timestamps for ~:date~ and ~:changed~ (~:date-unix~ and ~:changed-unix~,
+      respectively) which represent the time as a simple number (number of
+      seconds since epoch), which is a bit easier to manipulate than the
+      emacs-style timestamps (same value, but expressed as a list).
+
+    - 1.12.8: You can now search for messages that have a given message-id in
+      their ~References:~ or ~In-Reply-To:~ headers, e.g.
+      #+begin_example
+      mu find ref:0D9218A9-C7F5-4D50-B49C-FCE201114C9B@gmail.com
+      #+end_example
+      You do need to re-index the database for this to work though.
+
+      There's also a new combination-field ~related:~ which combines ~references:~
+      and ~msgid:~.
+
+    - 1.12.9: The mu server uses PCRE-compatible regexps (for addresses), which
+      are not necessarily compatible with Emacs regular expressions. However,
+      mu4e can now automatically translate; this depends on the ~pcre2el~ package
+      which the user should install when using regular expression-addresses.
+
+    - 1.12.9: the cleanup phase after indexing is significantly faster now
+
+    - 1.12.10: ~mu4e-maildir-shortcuts~ and ~mu4e-bookmarks~ now understand a
+      property ~:hide-if-no-unread~, which hides the maildir/bookmark from the
+      main-view if there are no unread messages which the corresponding query.
+
 *** mu4e
 
 **** message composer
@@ -184,6 +135,10 @@
       composer functions (e.g. the whole mu4e-specific draft setup is gone);
       this reduces code size and offers some new capabilities.
 
+      Message composition has been completely reworked to avoid a number of
+      problems that users reported. It is now directly uses the Gnus machinery,
+      integrated with mu4e.
+
       More of the ~message-~ functionality can be used now in ~mu4e~.
 
     - Variables ~mu4e-compose-signature~, ~mu4e-compose-cite-function~ are gone
@@ -281,6 +236,40 @@
 
     - ~mu4e~ now follows Emacs' ~package~ guidelines
 
+    - 1.12.8: new variable ~mu4e-uniquify-save-file-name-function~ to influence
+      the way ~mu4e~ creates unique file names when saving. See its docstring for
+      details.
+
+    - 1.12.8: new variable ~mu4e-uniquify-save-file-name-function~ to influence
+      the way ~mu4e~ creates unique file names when saving. See its docstring for
+      details.
+
+    - 1.12.8: a new variable ~mu4e-trash-without-flag~, which, when set to non-nil
+      makes trashing _not_ add the the Maildir ~T~ flag. See its docstring for
+      details.
+
+    - 1.12.9: A (experimental) "transient" menu has been added for mu4e. You can
+      use it e.g., with something like:
+
+      #+begin_src elisp
+	(require 'mu4e-transient)
+	(global-set-key (kbd "C-c m") #'mu4e-transient-menu)
+      #+end_src
+      This will change/improve, but is already quite useful.
+
+    - 1.12.9: new command ~mu4e-analyze-last-query~ which shows information about
+      how the server interpreted the last query; this can be useful if you don't
+      get the result you expected.
+
+    - 1.12.9: When you ask for bookmarks or maildirs through
+      ~mu4e-search-bookmark~ or ~mu4e-search-maildir~, unread counts are displayed
+      in the (default) completions UI next to the maildir or bookmark. If you
+      don't want to see these counts, set ~mu4e-hide-short-counts~ to non-~nil~.
+
+    - 1.12.9: Various Gnus' mailing list commands are now available in the mu4e
+      message view as well, such as ~gnus-mailing-list-subscribe~,
+      ~gnus-mailing-list-unsubscribe~.
+
 *** Contributors
 
     Thanks to our contributors - code committers belows, but also to everyone

From e534f8ae794780d6413a08ee6b8947302b9d138d Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 16 Mar 2025 16:29:40 +0200
Subject: [PATCH 249/305] mu4e: centralize docstring for mu4e-bookmarks

Refer to it in mu4e-maildir-shortcut, so we only have one place to
document the format.
---
 mu4e/mu4e-bookmarks.el |  6 ++++--
 mu4e/mu4e-folders.el   | 25 +++++++++----------------
 2 files changed, 13 insertions(+), 18 deletions(-)

diff --git a/mu4e/mu4e-bookmarks.el b/mu4e/mu4e-bookmarks.el
index 37127e2fd..af4442ae6 100644
--- a/mu4e/mu4e-bookmarks.el
+++ b/mu4e/mu4e-bookmarks.el
@@ -48,14 +48,16 @@
     ( :name "Messages with images"
       :query "mime:image/*"
       :key ?p))
-  "List of pre-defined queries that are shown on the main screen.
+  "List of predefined queries that are shown on the main screen.
 
 Each of the list elements is a plist with at least:
 `:name'  - the name of the query
 `:query' - the query expression string or function
+
+Likely, you also want to assign a shortcut key;
 `:key'   - the shortcut key (single character)
 
-Optionally, you can add the following:
+Furthermore, you can add the following:
 
 - `:favorite' - if t, monitor the results of this query, and make
 it eligible for showing its status in the modeline. At most
diff --git a/mu4e/mu4e-folders.el b/mu4e/mu4e-folders.el
index 22d1ee281..db74eba62 100644
--- a/mu4e/mu4e-folders.el
+++ b/mu4e/mu4e-folders.el
@@ -98,25 +98,18 @@ This makes it possible to quickly go to a particular
 maildir (folder), or quickly moving messages to them (e.g., for
 archiving or refiling).
 
-Each of the list elements is a plist with at least:
-`:maildir'  - the maildir for the shortcut (e.g. \"/archive\")
-`:key'      - the shortcut key.
+The format is the same as for `mu4e-bookmarks', with a few
+difference, so see its doc-strings for further details.
 
-Optionally, you can add the following:
-`:name' - name of the maildir to be displayed in main-view.
-`:hide'  - if t, the shortcut is hidden from the main-view.
-`:hide-if-no-unread' - if it t, the shortcut is hidden from
- the main-view if it contains no unread messages.
+The only field specific for `mu4e-maildir-shortcuts' is
+- `:maildir'  - the maildir for the shortcut (e.g., \"/archive\")
 
- You can also use:
-`:hide-unread' - do not show the counts of unread/total number
- of matches for the maildir in the main-view, and is implied
- from `:hide'.
+Example:
 
-For backward compatibility, an older form is recognized as well:
-
-   (maildir . key), where MAILDIR is a maildir (such as
-\"/archive/\"), and key is a single character.
+\\(setq mu4e-maildir-shortcuts
+       \\'( (:maildir \"/inbox\"       :key ?i :hide-if-no-unread t)
+            (:maildir \"/drafts\"      :key ?d :hide t)
+            (:maildir \"/sent\"        :key ?s :hide-unread t)))
 
 You can use these shortcuts in the headers and view buffers, for
 example with `mu4e-mark-for-move-quick' (or \"m\", by default) or

From a2a1838da49cb87fdeecdc8cb1774736e7398051 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 16 Mar 2025 18:38:09 +0200
Subject: [PATCH 250/305] mu-server: cleanup find prop handling

Rework the overly long find-handler.

Improve parsing of options, and return better return properties (for use
in mu4e).
---
 lib/mu-server.cc     | 131 ++++++++++++++++++++++++++++++-------------
 lib/utils/mu-sexp.hh |   5 +-
 2 files changed, 94 insertions(+), 42 deletions(-)

diff --git a/lib/mu-server.cc b/lib/mu-server.cc
index 4aaa0a8f1..0ea352f08 100644
--- a/lib/mu-server.cc
+++ b/lib/mu-server.cc
@@ -640,61 +640,121 @@ Server::Private::output_results(const QueryResults& qres, size_t batch_size) con
 	return n;
 }
 
-void
-Server::Private::find_handler(const Command& cmd)
+struct FindProps {
+	std::string query;
+	int batch_size{200};
+	int maxnum{-1};
+	Field::Id sort_field_id{Field::Id::Date};
+	QueryFlags flags{QueryFlags::SkipUnreadable};
+};
+// XXX: once we move to C++20, use designated initializers
+
+
+static const std::pair<QueryFlags, std::string> flags_props[] = {
+	{ QueryFlags::Descending, ":descending" },
+	{ QueryFlags::SkipDuplicates, ":skip-dups" },
+	{ QueryFlags::IncludeRelated, ":include-related" },
+	{ QueryFlags::Threading, ":threads" }
+};
+
+/**
+ * Determine the find search properties from a command object
+ *
+ * @param cmd the command
+ *
+ * @return structure with find properties
+ */
+static FindProps
+determine_find_props(const Command& cmd)
 {
-	const auto q{cmd.string_arg(":query").value_or("")};
-	const auto threads{cmd.boolean_arg(":threads")};
-	// perhaps let mu4e set this as frame-lines of the appropriate frame.
-	const auto batch_size{cmd.number_arg(":batch-size").value_or(200)};
-	const auto descending{cmd.boolean_arg(":descending")};
-	const auto maxnum{cmd.number_arg(":maxnum").value_or(-1) /*unlimited*/};
-	const auto skip_dups{cmd.boolean_arg(":skip-dups")};
-	const auto include_related{cmd.boolean_arg(":include-related")};
+	FindProps props{};
+
+	props.query = cmd.string_arg(":query").value_or("");
+	props.batch_size = cmd.number_arg(":batch-size").value_or(200);
+	if (props.batch_size < 1)
+		throw Error{Error::Code::InvalidArgument, "invalid batch-size {}", props.batch_size};
 
+	props.maxnum = cmd.number_arg(":maxnum").value_or(-1) /*unlimited*/;
+	if (props.maxnum < -1)
+		throw Error{Error::Code::InvalidArgument, "invalid max-num {}", props.maxnum};
+
+	const auto threads{cmd.boolean_arg(":threads")};
 	// complicated!
-	auto sort_field_id = std::invoke([&]()->Field::Id {
+	props.sort_field_id = std::invoke([&]()->Field::Id {
 		if (const auto arg = cmd.symbol_arg(":sortfield"); !arg)
 			return Field::Id::Date;
 		else if (arg->length() < 2)
-			throw Error{Error::Code::InvalidArgument, "invalid sort field '{}'",
+			throw Error{Error::Code::InvalidArgument, "invalid sort field parameter '{}'",
 				*arg};
 		else if (const auto field{field_from_name(arg->substr(1))}; !field)
+			// Note: mu4e gives us ':date' etc., hence the 'substr'
 			throw Error{Error::Code::InvalidArgument, "invalid sort field '{}'",
 				*arg};
+		else if (!field->is_sortable())
+			throw Error{Error::Code::InvalidArgument, "not a sortable field '{}'",
+				*arg};
+		else if (threads && field->id != Field::Id::Date)
+			throw Error{Error::Code::InvalidArgument,
+				     "with threads, you can only sort by date, not by '{}'", *arg};
 		else
 			return field->id;
 	});
 
-	if (batch_size < 1)
-		throw Error{Error::Code::InvalidArgument, "invalid batch-size {}", batch_size};
+	for (const auto& item: flags_props) {
+		if (cmd.boolean_arg(item.second))
+			props.flags |= item.first;
+	}
 
-	auto qflags{QueryFlags::SkipUnreadable}; // don't show unreadables.
+	return props;
+}
+
+/**
+ * Determine the result properties from the find results
+ *
+ * The result properties are passed back to the client
+ *
+ * @param props the find properties
+ *
+ * @return the result properties
+ */
+static Sexp
+determine_result_props(const FindProps& props, size_t found)
+{
 	Sexp resprops;
-	if (descending) {
-		qflags |= QueryFlags::Descending;
-		resprops.put_props(":reverse", Sexp::t_sym);
-	}
-	if (skip_dups) {
-		qflags |= QueryFlags::SkipDuplicates;
-		resprops.put_props(":skip-dups", Sexp::t_sym);
-	}
-	if (include_related) {
-		qflags |= QueryFlags::IncludeRelated;
-		resprops.put_props(":include-related", Sexp::t_sym);
-	}
-	if (threads) {
-		qflags |= QueryFlags::Threading;
-		resprops.put_props(":threads", Sexp::t_sym);
+
+	resprops.put_props(
+		":found", found,
+		":query", props.query,
+		":query-sexp", parse_query(props.query, false/*!expand*/),
+		":query-sexp-expanded", parse_query(props.query, true/*expand*/),
+		":maxnum", props.maxnum,
+		// mu4e expects ':'-prefixed sort-field, for historical reasons.
+		":sort-field", Sexp::Symbol{mu_format(":{}", field_from_id(props.sort_field_id).name)});
+
+	if (props.maxnum == -1)
+		resprops.put_props(":full", Sexp::t_sym);
+
+	for (const auto& item: flags_props) {
+		if (any_of(props.flags & item.first))
+			resprops.put_props(item.second, Sexp::t_sym);
 	}
 
+	return resprops;
+}
+
+void
+Server::Private::find_handler(const Command& cmd)
+{
+	const auto props = determine_find_props(cmd);
+
 	StopWatch sw{mu_format("{} (indexing: {})", __func__,
 			       indexer().is_running() ? "yes" :  "no")};
 
 	// we need to _lock_ the store while querying (which likely consists of
 	// multiple actual queries) + grabbing the results.
 	std::lock_guard l{store_.lock()};
-	auto qres{store_.run_query(q, sort_field_id, qflags, maxnum)};
+	auto qres{store_.run_query(props.query, props.sort_field_id,
+				   props.flags, props.maxnum)};
 	if (!qres)
 		throw Error(Error::Code::Query, "failed to run query: {}", qres.error().what());
 
@@ -702,15 +762,10 @@ Server::Private::find_handler(const Command& cmd)
 	 * knows it should erase the headers buffer. this will ensure that the
 	 * output of two finds will not be mixed. */
 	output_sexp(Sexp().put_props(":erase", Sexp::t_sym));
-	const auto bsize{static_cast<size_t>(batch_size)};
+	const auto bsize{static_cast<size_t>(props.batch_size)};
 	const auto foundnum = output_results(*qres, bsize);
 
-	output_sexp(resprops.put_props(
-			    ":found", foundnum,
-			    ":query", q,
-			    ":query-sexp", parse_query(q, false/*!expand*/).to_string(),
-			    ":query-sexp-expanded", parse_query(q, true/*expand*/).to_string(),
-			    ":maxnum", maxnum));
+	output_sexp(determine_result_props(props, foundnum));
 }
 
 void
diff --git a/lib/utils/mu-sexp.hh b/lib/utils/mu-sexp.hh
index 8ffa39bcf..d25cc6477 100644
--- a/lib/utils/mu-sexp.hh
+++ b/lib/utils/mu-sexp.hh
@@ -22,15 +22,12 @@
 
 #include "mu-utils.hh"
 
-#include <stdexcept>
 #include <vector>
 #include <string>
 #include <string_view>
 #include <iostream>
 #include <variant>
-#include <cinttypes>
 #include <ostream>
-#include <cassert>
 
 #include <utils/mu-result.hh>
 #include <utils/mu-option.hh>
@@ -55,7 +52,7 @@ struct Sexp {
 		Symbol(const std::string& s): name{s} {}
 		Symbol(std::string&& s): name(std::move(s)) {}
 		Symbol(const char* str): Symbol(std::string{str}) {}
-		Symbol(std::string_view sv): Symbol(std::string{sv}) {}
+		Symbol(const std::string_view& sv): Symbol(std::string{sv}) {}
 		operator const std::string&() const {return name; }
 		std::string name;
 

From 398cb0abd256cd97f26e558e782e9aabf87621e5 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 16 Mar 2025 19:02:24 +0200
Subject: [PATCH 251/305] mu4e-headers: cosmetics

Fix some flycheck warnings.
---
 mu4e/mu4e-headers.el | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/mu4e/mu4e-headers.el b/mu4e/mu4e-headers.el
index a8f129ec6..8e8bbbec2 100644
--- a/mu4e/mu4e-headers.el
+++ b/mu4e/mu4e-headers.el
@@ -53,7 +53,6 @@
 (declare-function mu4e-view       "mu4e-view")
 (declare-function mu4e--main-view  "mu4e-main")
 
-
 ;;; Configuration
 
 (defgroup mu4e-headers nil
@@ -217,7 +216,6 @@ When it is showing, respectively, From: or To:. It is a cons cell
 (defvar mu4e-headers-personal-mark  '("p" . "Ⓟ") "Personal.")
 (defvar mu4e-headers-calendar-mark  '("c" . "Ⓒ") "Calendar invitation.")
 
-
 ;;;; Graph drawing
 
 (defvar mu4e-headers-thread-mark-as-orphan 'first
@@ -550,9 +548,9 @@ e.g. \"mutt\"."
 (defsubst mu4e~headers-custom-field-value (msg field)
   "Show custom header FIELD for MSG, or raise error if not found."
   (let* ((item (or (assoc field mu4e-header-info-custom)
-                   (mu4e-error "field %S not found" field)))
+                   (mu4e-error "Field %S not found" field)))
          (func (or (plist-get (cdr-safe item) :function)
-                   (mu4e-error "no :function defined for field %S %S"
+                   (mu4e-error "No :function defined for field %S %S"
                                field (cdr item)))))
     (funcall func msg)))
 
@@ -846,7 +844,8 @@ true, do *not* update the query history stack."
      mu4e-search-include-related)))
 
 (defun mu4e~headers-benchmark-message (count)
-  "Get some report message for messaging search and rendering speed."
+  "Get some report message for messaging search and rendering speed.
+COUNT is the number of messages found."
   (if (and mu4e-headers-report-render-time
            mu4e~headers-search-start
            mu4e~headers-render-start
@@ -861,7 +860,7 @@ true, do *not* update the query history stack."
     ""))
 
 (defun mu4e~headers-found-handler (count)
-  "Create one=line description of the COUNT of headers found."
+  "Create one-line description of the COUNT of headers found."
   (when (buffer-live-p (mu4e-get-headers-buffer))
     (with-current-buffer (mu4e-get-headers-buffer)
       (save-excursion
@@ -1092,7 +1091,7 @@ true, do *not* update the query history stack."
       mu4e-headers-fields))))
 
 (defun mu4e~headers-maybe-auto-update ()
-  "Update the current headers buffer after indexing changes.
+  "Update the current headers buffer after indexing.
 
 Furthermore, `mu4e-headers-auto-update' is non-nil and there is
 no user-interaction ongoing.
@@ -1265,7 +1264,7 @@ corresponding header."
 
 
 (defun mu4e-headers-find-if (func &optional backward)
-  "Move to the header for which FUNC returns non-nil.
+  "Move to the header where FUNC yields non-nil.
 if BACKWARD is non-nil, search backwards.
 
 FUNC receives one argument, the message s-expression for the

From f5b9cf4cfb8b5ba405361bbb84be89ce3a095f7e Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 16 Mar 2025 21:26:43 +0200
Subject: [PATCH 252/305] mu4e-server: improve documentation

---
 mu4e/mu4e-server.el | 37 ++++++++++++++++++++++++-------------
 1 file changed, 24 insertions(+), 13 deletions(-)

diff --git a/mu4e/mu4e-server.el b/mu4e/mu4e-server.el
index 92501eb51..58c877a34 100644
--- a/mu4e/mu4e-server.el
+++ b/mu4e/mu4e-server.el
@@ -195,10 +195,17 @@ This is a plist, see `mu4e-server-last-query' for details.")
 This has the following fields:
 - :query: this is the last query the server executed (a string)
 - :query-sexp: this is that last query as processed by the query engine
-  (an s-expression as a string)
+  (an s-expression)
 - :query-sexp-expanded: like :query-sexp, but with combination fields
-   expanded (if any)."
-  (cl-remf mu4e--server-query :found) ;; there's no plist-delete
+   expanded (if any).
+
+It may also include fields describing the search properties of
+the executed query, such as:
+- :sort-field: the sort-field
+- :reverse: whether the sorting was in reverse order
+- :skip-dups: whether to skip duplicate messages
+- :threads: whether to show message threads
+- :maxnum: the maximum number of results."
   mu4e--server-query)
 
 (defvar mu4e--last-query-buffer-name)
@@ -435,7 +442,7 @@ The server output is as follows:
                    (plist-get sexp :error)
                    (plist-get sexp :message)))
 
-         (t (mu4e-message "Unexpected data from server [%S]" sexp)))
+         (t (mu4e-message "Unexpected data from server: %S" sexp)))
 
         (setq sexp (mu4e--server-eat-sexp-from-buf))))))
 
@@ -616,15 +623,19 @@ KIND is a symbol. Currently supported kinds: maildirs."
                                 include-related)
   "Run QUERY with THREADS SORTFIELD SORTDIR MAXNUM SKIP-DUPS INCLUDE-RELATED.
 
-If THREADS is non-nil, show results in threaded fashion,
+If THREADS is non-nil, show results in threaded fashion.
 SORTFIELD is a symbol describing the field to sort by (or nil);
-see `mu4e~headers-sortfield-choices'. If SORT is `descending',
-sort Z->A, if it's `ascending', sort A->Z. MAXNUM determines the
-maximum number of results to return, or nil for unlimited. If
-SKIP-DUPS is non-nil, show only one of duplicate messages (see
-`mu4e-headers-skip-duplicates'). If INCLUDE-RELATED is non-nil,
-include messages related to the messages matching the search
-query (see `mu4e-headers-include-related').
+see `mu4e~headers-sortfield-choices'. Note, since you can only
+sort by date when using threading, in the threading case,
+SORTFIELD is ignored and `date' us used.
+
+If SORT is `descending', sort Z->A, if it's `ascending', sort
+A->Z. MAXNUM determines the maximum number of results to return,
+or nil for unlimited. If SKIP-DUPS is non-nil, show only one of
+duplicate messages (see `mu4e-headers-skip-duplicates'). If
+INCLUDE-RELATED is non-nil, include messages related to the
+messages matching the search query (see
+`mu4e-headers-include-related').
 
 For each result found, a function is called, depending on the
 kind of result. The variables `mu4e-error-func' contain the
@@ -634,7 +645,7 @@ or an error."
    `(find
      :query ,query
      :threads ,(and threads t)
-     :sortfield ,sortfield
+     :sortfield ,(if threads :date sortfield)
      :descending ,(if (eq sortdir 'descending) t nil)
      :maxnum ,maxnum
      :skip-dups ,(and skip-dups t)

From a6d68a414637a34087afc67c67a9e0d8fceeaced Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 12 Apr 2025 15:23:52 +0700
Subject: [PATCH 253/305] mu4e-headers/search: use last-query information

Use the information from the last-query to update the modeline,
sorting-column etc.
---
 mu4e/mu4e-headers.el | 85 +++++++++++++++++++++++++-------------------
 mu4e/mu4e-search.el  | 30 ++++++++--------
 2 files changed, 65 insertions(+), 50 deletions(-)

diff --git a/mu4e/mu4e-headers.el b/mu4e/mu4e-headers.el
index 8e8bbbec2..c60458404 100644
--- a/mu4e/mu4e-headers.el
+++ b/mu4e/mu4e-headers.el
@@ -384,8 +384,6 @@ Returns the docid, or nil if there is none."
       (goto-char point))
     (get-text-property (line-beginning-position) 'docid)))
 
-
-
 (defun mu4e~headers-goto-docid (docid &optional to-mark)
   "Go to beginning of the line with DOCID.
 Nil if it cannot be found. If the optional TO-MARK is
@@ -1032,51 +1030,66 @@ COUNT is the number of messages found."
      )))
 
 ;;; Headers-mode and mode-map
+(defun mu4e~header-line-click (sortable threads)
+  "Return function for header-line clicks.
+If SORTABLE, handle the sorting; otherwise show a message that
+you cannot sort by this field. If THREADS, give a more
+informative error message."
+    (if (not sortable)
+        (if threads
+            (lambda (&optional e)
+              (interactive "e")
+              (mu4e-message "With threading, you can only sort by date"))
+          (lambda (&optional e)
+            (interactive "e")
+            (mu4e-message "Field is not sortable")))
+      (lambda (&optional e)
+        (interactive "e")
+        ;; getting the field, inspired by
+        ;; `tabulated-list-col-sort'
+        (let* ((obj (posn-object (event-start e)))
+               (field (and obj
+                           (get-text-property 0 'field (car obj)))))
+          ;; "t": if we're already sorted by field, the
+          ;; sort-order is changed
+          (mu4e-search-change-sorting field t)))))
 
 (defun mu4e~header-line-format ()
   "Get the format for the header line."
-  (let ((uparrow   (if mu4e-use-fancy-chars " ▲" " ^"))
-        (downarrow (if mu4e-use-fancy-chars " ▼" " V")))
+  (let* ((plist (mu4e-server-last-query)) ;; info about the last query
+         (reverse (plist-get plist :reverse))
+         (threads (plist-get plist :threads))
+         ;; with threads enabled,  we can only sort by ;date
+         (sort-field (if threads :date (plist-get plist :sort-field)))
+         (fields (append mu4e-header-info mu4e-header-info-custom))
+         (arrow (if reverse
+                    (if mu4e-use-fancy-chars " ▼" " V")
+                  (if mu4e-use-fancy-chars " ▲" " ^"))))
     (cons
      (make-string
       (+ mu4e--mark-fringe-len (floor (fringe-columns 'left t))) ?\s)
      (mapcar
       (lambda (item)
-        (let* (;; with threading enabled, we're necessarily sorting by date.
-               (sort-field (if mu4e-search-threads
-                               :date mu4e-search-sort-field))
-               (field (car item)) (width (cdr item))
-               (info (cdr (assoc field
-                                 (append mu4e-header-info
-                                         mu4e-header-info-custom))))
-               (sortable (plist-get info :sortable))
-               ;; if sortable, it is either t (when field is sortable itself)
-               ;; or a symbol (if another field is used for sorting)
-               (this-field (when sortable (if (booleanp sortable)
-                                              field
-                                            sortable)))
+        (let* ((field (car item)) (width (cdr item))
+               (info (cdr (assoc field fields)))
+               (sortable-info (plist-get info :sortable))
+               ;; the effective sort-field for this field is as per its info;
+               ;; if t, it's the field itself; otherwise it's either some
+               ;; _other_ field (for fields which are sorted by some other field), or nil
+               ;; for fields that cannot be sorted.
+               (field-sort-field
+                (if (eq sortable-info t) field sortable-info))
+               ;; only if we're actually looking at if for this column
+               (field-sort-field (and (eq field-sort-field sort-field) field-sort-field))
                (help (plist-get info :help))
                ;; triangle to mark the sorted-by column
                (arrow
-                (when (and sortable (eq this-field sort-field))
-                  (if (eq mu4e-search-sort-direction 'descending)
-                      downarrow
-                    uparrow)))
+                (when field-sort-field
+                  (if reverse downarrow uparrow)))
                (name (concat (plist-get info :shortname) arrow))
                (map (make-sparse-keymap)))
-          (when sortable
-            (define-key map [header-line mouse-1]
-                        (lambda (&optional e)
-                          ;; getting the field, inspired by
-                          ;; `tabulated-list-col-sort'
-                          (interactive "e")
-                          (let* ((obj (posn-object (event-start e)))
-                                 (field
-                                  (and obj
-                                       (get-text-property 0 'field (car obj)))))
-                            ;; "t": if we're already sorted by field, the
-                            ;; sort-order is changed
-                            (mu4e-search-change-sorting field t)))))
+          (define-key map [header-line mouse-1]
+                      (mu4e~header-line-click field-sort-field threads))
           (concat
            (propertize
             (if width
@@ -1085,8 +1098,8 @@ COUNT is the number of messages found."
               name)
             'face (when arrow 'bold)
             'help-echo help
-            'mouse-face (when sortable 'highlight)
-            'keymap (when sortable map)
+            'mouse-face (when field-sort-field 'highlight)
+            'keymap (when field-sort-field map)
             'field field) " ")))
       mu4e-headers-fields))))
 
diff --git a/mu4e/mu4e-search.el b/mu4e/mu4e-search.el
index f72d9da26..d3f1cbd1c 100644
--- a/mu4e/mu4e-search.el
+++ b/mu4e/mu4e-search.el
@@ -96,15 +96,17 @@ Example that hides all trashed messages:
 This can be used to toggle use of the predicate through
  `mu4e-search-toggle-property'.")
 
-
 (defcustom mu4e-search-sort-field :date
-  "Field to sort the headers by. A symbol:
-one of: `:date', `:subject', `:size', `:prio', `:from', `:to.',
-`:list'.
+  "Field to sort the headers by.
+
+You can use any field from `mu4e-header-info' with a non-nil
+`:sortable' in their information.
+
+The ':'-prefix is there for historical reasons.
 
-Note that when threading is enabled (through
-`mu4e-search-threads'), the headers are exclusively sorted
-chronologically (`:date') by the newest message in the thread."
+When threading is enabled (through `mu4e-search-threads'), the
+headers are exclusively sorted chronologically (`:date') by the
+newest message in the thread."
   :type '(radio (const :date)
                 (const :subject)
                 (const :size)
@@ -112,6 +114,8 @@ chronologically (`:date') by the newest message in the thread."
                 (const :from)
                 (const :to)
                 (const :list))
+  ;; this is not exhaustive; but the other ones don't make
+  ;; much sense as default sort-fields.
   :group 'mu4e-search)
 
 (defcustom mu4e-search-sort-direction 'descending
@@ -528,20 +532,18 @@ last search with the new setting."
 
 (defun mu4e--search-modeline-item ()
   "Get mu4e-search modeline item."
-  (let* ((label (lambda (label-cons)
+  (let* ((pinfo (mu4e-server-last-query))
+         (label (lambda (label-cons)
                   (if mu4e-use-fancy-chars
                       (cdr label-cons) (car label-cons))))
          (props
           `((,mu4e-search-full ,mu4e-search-full-label
              "Full search")
-            (,mu4e-search-include-related
-             ,mu4e-search-related-label
+            (,(plist-get pinfo :related) ,mu4e-search-related-label
              "Include related messages")
-            (,mu4e-search-threads
-             ,mu4e-search-threaded-label
+            (,(plist-get pinfo :threads) ,mu4e-search-threaded-label
              "Show message threads")
-            (,mu4e-search-skip-duplicates
-             ,mu4e-search-skip-duplicates-label
+            (,(plist-get pinfo :skip-dups) ,mu4e-search-skip-duplicates-label
              "Skip duplicate messages")
             (,mu4e-search-hide-enabled
              ,mu4e-search-hide-label

From 804c4b4cdafa45b250907dde2c4b2993ee41ae26 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 13 Apr 2025 13:37:04 +0300
Subject: [PATCH 254/305] mu4e-bookmarks/folders: allow -ask to return
 query-item

Instead of just the query-string or maildir name, allow
mu4e-ask-bookmark / mu4e-ask-folder to return the query-item, when a new
optional parameter QUERY-ITEM is non-nil.
---
 mu4e/mu4e-bookmarks.el | 16 +++++++----
 mu4e/mu4e-folders.el   | 60 +++++++++++++++++++++++-------------------
 2 files changed, 44 insertions(+), 32 deletions(-)

diff --git a/mu4e/mu4e-bookmarks.el b/mu4e/mu4e-bookmarks.el
index af4442ae6..0f3d186d4 100644
--- a/mu4e/mu4e-bookmarks.el
+++ b/mu4e/mu4e-bookmarks.el
@@ -87,11 +87,14 @@ query."
 (declare-function mu4e-query-items "mu4e-query-items")
 (declare-function mu4e--query-item-display-short-counts "mu4e-query-items")
 
-(defun mu4e-ask-bookmark (prompt)
+(defun mu4e-ask-bookmark (prompt &optional query-item)
   "Ask user for bookmark using PROMPT.
 Return the corresponding query. The bookmark are as defined in
 `mu4e-bookmarks'.
 
+If QUERY-ITEM is non-nil, return the full query-item rather than
+just the query-string.
+
 The names of the bookmarks are displayed in the minibuffer,
 suffixed with the short version of the unread counts, as per
 `mu4e--query-item-display-short-counts'."
@@ -107,10 +110,13 @@ suffixed with the short version of the unread counts, as per
                (cons (format "%c%s%s"
                              (plist-get bm :key)
                              (plist-get bm :name)
-                             unreads)
-                     (plist-get bm :query))))
-          (mu4e-filter-single-key (mu4e-bookmarks)))))
-  (mu4e-read-option prompt bmarks)))
+                             unreads) bm)))
+          (mu4e-filter-single-key (mu4e-bookmarks))))
+         (chosen (mu4e-read-option prompt bmarks)))
+    ;; return either the query string, or the corresponding query-item.
+    (if query-item
+        chosen
+      (plist-get chosen :query))))
 
 (defun mu4e-get-bookmark-query (kar)
   "Get the corresponding bookmarked query for shortcut KAR.
diff --git a/mu4e/mu4e-folders.el b/mu4e/mu4e-folders.el
index db74eba62..e9ca02b48 100644
--- a/mu4e/mu4e-folders.el
+++ b/mu4e/mu4e-folders.el
@@ -247,9 +247,13 @@ to create it; otherwise return nil."
   "Get maildirs under `mu4e-maildir'."
   mu4e-maildir-list)
 
-(defun mu4e-ask-maildir (prompt)
+
+(defun mu4e-ask-maildir (prompt &optional query-item)
   "Ask the user for a maildir (using PROMPT).
 
+If QUERY-ITEM is non-nil, return the full query-item rather than
+just the query-string.
+
 If the special shortcut \"o\" (for _o_ther) is used, or
 if (mu4e-maildir-shortcuts) evaluates to nil, let user choose
 from all maildirs under `mu4e-maildir'.
@@ -257,32 +261,34 @@ from all maildirs under `mu4e-maildir'.
 The names of the maildirs are displayed in the minibuffer,
 suffixed with the short version of the unread counts, as per
 `mu4e--query-item-display-short-counts'."
-  (let* ((options
-         (seq-map
-          (lambda (md)
-            (let* ((qitem (mu4e--query-item-for-maildir-shortcut md))
-                   (unreads (mu4e--query-item-display-short-counts qitem)))
-              (cons
-               (format "%c%s%s"
-                       (plist-get md :key)
-                       (or (plist-get md :name)
-                           (plist-get md :maildir))
-                       unreads)
-               (plist-get md :maildir))))
-                  (mu4e-filter-single-key (mu4e-maildir-shortcuts))))
-        (response
-         (if (not options)
-             'other
-           (mu4e-read-option prompt
-                             (append options
-                                     '(("oOther..." . other)))))))
-    (substring-no-properties
-     (if (eq response 'other)
-         (progn
-           (funcall mu4e-completing-read-function prompt
-                    (mu4e-get-maildirs) nil nil
-                    mu4e-maildir-initial-input))
-       response))))
+  (let* ((mdirs
+          (append
+           (seq-map
+            (lambda (md)
+              (let* ((qitem (mu4e--query-item-for-maildir-shortcut md))
+                     (unreads (mu4e--query-item-display-short-counts qitem)))
+                (cons
+                 (format "%c%s%s"
+                         (plist-get md :key)
+                         (or (plist-get md :name)
+                             (plist-get md :maildir))
+                         unreads) md)))
+            (mu4e-filter-single-key (mu4e-maildir-shortcuts)))
+           '(("oOther..." . other)))) ;; append "Other" pseudo-maildir
+         (chosen (mu4e-read-option prompt mdirs))
+         ;; special case: handle pseudo-maildir 'other
+         (chosen (if (eq chosen 'other)
+                     (list :maildir
+                           (substring-no-properties
+                            (funcall mu4e-completing-read-function prompt
+                                     (mu4e-get-maildirs) nil nil
+                                     mu4e-maildir-initial-input)))
+                   chosen)))
+    ;; return either the maildir (as a string), or the corresponding
+    ;; query-item.
+    (if query-item
+        chosen
+      (plist-get chosen :maildir))))
 
 (defun mu4e-ask-maildir-check-exists (prompt)
   "Like `mu4e-ask-maildir', PROMPT for existence of the maildir.

From 102dfa1bd45559e0c2b86fd4fcfa075b21301cca Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 13 Apr 2025 19:24:50 +0300
Subject: [PATCH 255/305] mu4e: silence emacs header cookie complaints

Update header-cookies to avoid emacs cookie complaints.

Fixes #2841
---
 mu4e/mu4e-config.el.in | 14 +++++++++++---
 mu4e/mu4e-headers.el   |  2 +-
 mu4e/mu4e.el           |  2 +-
 3 files changed, 13 insertions(+), 5 deletions(-)

diff --git a/mu4e/mu4e-config.el.in b/mu4e/mu4e-config.el.in
index 5f99db426..7c36d31ca 100644
--- a/mu4e/mu4e-config.el.in
+++ b/mu4e/mu4e-config.el.in
@@ -1,9 +1,17 @@
-;; auto-generated
+;;; mu4e-config.el --- configuration values -*- lexical-binding: t -*-
+
+;;; Commentary:
+
+;; Auto-generated configuration values
+
+;;; Code:
 
 (defconst mu4e-mu-version "@VERSION@"
-  "Required mu binary version; mu4e's version must agree with this.")
+  "Required mu binary version.
+mu4e's version must agree with this.")
 
 (defconst mu4e-doc-dir "@MU_DOC_DIR@"
-  "Mu4e's data-dir.")
+  "Directory for mu4e documentation.")
 
 (provide 'mu4e-config)
+;;; mu4e-config.el.in ends here
diff --git a/mu4e/mu4e-headers.el b/mu4e/mu4e-headers.el
index c60458404..e1d3f7c94 100644
--- a/mu4e/mu4e-headers.el
+++ b/mu4e/mu4e-headers.el
@@ -1,4 +1,4 @@
-;;; mu4e-headers.el --- Message headers -*- lexical-binding: t; coding:utf-8 -*-
+;;; mu4e-headers.el --- Message headers -*- lexical-binding: t  -*-
 
 ;; Copyright (C) 2011-2025 Dirk-Jan C. Binnema
 
diff --git a/mu4e/mu4e.el b/mu4e/mu4e.el
index 8eb0c4dc4..73a087e26 100644
--- a/mu4e/mu4e.el
+++ b/mu4e/mu4e.el
@@ -1,4 +1,4 @@
-;;; mu4e.el --- Mu4e, the mu mail user agent -*- lexical-binding: t -*-
+;;; mu4e.el ---  Mu-based mua for emacs -*- lexical-binding: t -*-
 
 ;; Copyright (C) 2011-2025 Dirk-Jan C. Binnema
 

From a7778fc333770fee49fef522532fb0f0f2b70e3f Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 13 Apr 2025 20:34:44 +0300
Subject: [PATCH 256/305] test-store: don't break on slow systems

The 'circular-symlink' test.
---
 lib/tests/test-mu-store.cc | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/lib/tests/test-mu-store.cc b/lib/tests/test-mu-store.cc
index 197375df5..ebc948e6d 100644
--- a/lib/tests/test-mu-store.cc
+++ b/lib/tests/test-mu-store.cc
@@ -515,7 +515,8 @@ test_store_circular_symlink(void)
 	size_t n{};
 	while (store.indexer().is_running()) {
 		std::this_thread::sleep_for(100ms);
-		g_assert_cmpuint(n++,<=,27); // 25 should be enough but #2832...
+		// 5 sec should be enough, even on the slowest supported systems..
+		g_assert_cmpuint(n++,<=,50);
 	}
 	// there will be a lot of dups....
 	g_assert_false(store.empty());

From 97a6bab35cd2e74cf9285407b103d980ddc1e9da Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 13 Apr 2025 20:56:58 +0300
Subject: [PATCH 257/305] mu4e-headers: fix column sorting

---
 mu4e/mu4e-headers.el | 48 +++++++++++++++++++++-----------------------
 1 file changed, 23 insertions(+), 25 deletions(-)

diff --git a/mu4e/mu4e-headers.el b/mu4e/mu4e-headers.el
index e1d3f7c94..d6d9b2dbb 100644
--- a/mu4e/mu4e-headers.el
+++ b/mu4e/mu4e-headers.el
@@ -1033,31 +1033,31 @@ COUNT is the number of messages found."
 (defun mu4e~header-line-click (sortable threads)
   "Return function for header-line clicks.
 If SORTABLE, handle the sorting; otherwise show a message that
-you cannot sort by this field. If THREADS, give a more
-informative error message."
-    (if (not sortable)
-        (if threads
-            (lambda (&optional e)
-              (interactive "e")
-              (mu4e-message "With threading, you can only sort by date"))
+you cannot sort by this field.
+
+If THREADS is non-nil, give a more informative error message."
+  (if (not sortable)
+      (if threads
           (lambda (&optional e)
             (interactive "e")
-            (mu4e-message "Field is not sortable")))
-      (lambda (&optional e)
-        (interactive "e")
-        ;; getting the field, inspired by
-        ;; `tabulated-list-col-sort'
-        (let* ((obj (posn-object (event-start e)))
-               (field (and obj
-                           (get-text-property 0 'field (car obj)))))
-          ;; "t": if we're already sorted by field, the
-          ;; sort-order is changed
-          (mu4e-search-change-sorting field t)))))
+            (mu4e-message "With threading, you can only sort by date"))
+        (lambda (&optional e)
+          (interactive "e")
+          (mu4e-message "Field is not sortable")))
+    (lambda (&optional e)
+      (interactive "e")
+      ;; getting the field, inspired by `tabulated-list-col-sort'
+      (let* ((obj (posn-object (event-start e)))
+             (field (and obj
+                         (get-text-property 0 'field (car obj)))))
+        ;; "t": if we're already sorted by field, the
+        ;; sort-order is changed
+        (mu4e-search-change-sorting field t)))))
 
 (defun mu4e~header-line-format ()
   "Get the format for the header line."
   (let* ((plist (mu4e-server-last-query)) ;; info about the last query
-         (reverse (plist-get plist :reverse))
+         (reverse (plist-get plist :descending))
          (threads (plist-get plist :threads))
          ;; with threads enabled,  we can only sort by ;date
          (sort-field (if threads :date (plist-get plist :sort-field)))
@@ -1080,13 +1080,11 @@ informative error message."
                (field-sort-field
                 (if (eq sortable-info t) field sortable-info))
                ;; only if we're actually looking at if for this column
-               (field-sort-field (and (eq field-sort-field sort-field) field-sort-field))
+               (current-sort-field (and (eq field-sort-field sort-field) field-sort-field))
                (help (plist-get info :help))
                ;; triangle to mark the sorted-by column
-               (arrow
-                (when field-sort-field
-                  (if reverse downarrow uparrow)))
-               (name (concat (plist-get info :shortname) arrow))
+               (name (concat (plist-get info :shortname)
+                             (if current-sort-field arrow "")))
                (map (make-sparse-keymap)))
           (define-key map [header-line mouse-1]
                       (mu4e~header-line-click field-sort-field threads))
@@ -1099,7 +1097,7 @@ informative error message."
             'face (when arrow 'bold)
             'help-echo help
             'mouse-face (when field-sort-field 'highlight)
-            'keymap (when field-sort-field map)
+            'keymap map
             'field field) " ")))
       mu4e-headers-fields))))
 

From 635f6f1bc278cc931b7d2bd98b51190b5819068b Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 15 Apr 2025 21:26:21 +0300
Subject: [PATCH 258/305] mu4e-folder: improve mu4e-maildir-shortcuts docstring

---
 mu4e/mu4e-folders.el | 25 +++++++++++++------------
 1 file changed, 13 insertions(+), 12 deletions(-)

diff --git a/mu4e/mu4e-folders.el b/mu4e/mu4e-folders.el
index e9ca02b48..d3d9dcf6c 100644
--- a/mu4e/mu4e-folders.el
+++ b/mu4e/mu4e-folders.el
@@ -94,22 +94,24 @@ nil otherwise."
 
 (defcustom mu4e-maildir-shortcuts nil
   "A list of maildir shortcuts.
-This makes it possible to quickly go to a particular
-maildir (folder), or quickly moving messages to them (e.g., for
-archiving or refiling).
 
-The format is the same as for `mu4e-bookmarks', with a few
-difference, so see its doc-strings for further details.
+Creating a shortcut makes it possible to quickly go to a
+particular maildir (folder), or quickly moving messages to
+them (e.g., for archiving or refiling).
 
-The only field specific for `mu4e-maildir-shortcuts' is
-- `:maildir'  - the maildir for the shortcut (e.g., \"/archive\")
+The format is mostly the same as for `mu4e-bookmarks', with a few
+difference, so see its doc-string for further details.
+
+The only field specific to `mu4e-maildir-shortcuts' is
+`:maildir', which is the property specifying the maildir for the
+shortcut (e.g., \"/archive\").
 
 Example:
 
-\\(setq mu4e-maildir-shortcuts
-       \\'( (:maildir \"/inbox\"       :key ?i :hide-if-no-unread t)
-            (:maildir \"/drafts\"      :key ?d :hide t)
-            (:maildir \"/sent\"        :key ?s :hide-unread t)))
+ (setq mu4e-maildir-shortcuts
+       '((:maildir \"/inbox\"     :key ?i :hide-if-no-unread t)
+         (:maildir \"/drafts\"    :key ?d :hide t)
+         (:maildir \"/sent\"      :key ?s :hide-unread t)))
 
 You can use these shortcuts in the headers and view buffers, for
 example with `mu4e-mark-for-move-quick' (or \"m\", by default) or
@@ -164,7 +166,6 @@ mime-type are nil."
 (defvar mu4e-maildir-list nil
   "Cached list of maildirs.")
 
-
 (defun mu4e-maildir-shortcuts ()
   "Get `mu4e-maildir-shortcuts' in the (new) format.
 Converts from the old format if needed."

From 5951c387b3b234247bd27c9d936936b03c0dc6a9 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 15 Apr 2025 19:35:46 +0300
Subject: [PATCH 259/305] mu4e-helpers: fix mu4e-plist-put-many

mu4e-plist-put-many was very broken, but somehow mu4e still somewhat
worked.
---
 mu4e/mu4e-helpers.el | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/mu4e/mu4e-helpers.el b/mu4e/mu4e-helpers.el
index 0f23dcf52..a623e1891 100644
--- a/mu4e/mu4e-helpers.el
+++ b/mu4e/mu4e-helpers.el
@@ -623,10 +623,11 @@ Returns the updated PLIST."
 (defun mu4e-plist-put-many (plist &rest keyvals)
   "Like `plist-put', but allow for multiple key-value pairs.
 PLIST is a property list, and KEYVALS are key value ... ."
-  (while keyvals
-    (plist-put plist (car keyvals) (cadr keyvals))
-    (setq keyvals (cdr keyvals)))
-  plist)
+  (let (p)
+    (while keyvals
+      (setq p (plist-put plist (car keyvals) (cadr keyvals)))
+      (setq keyvals (cddr keyvals)))
+    p))
 
 (defun mu4e--message-hide-headers ()
   "Hide headers based on the `message-hidden-headers' variable.

From e79874aafb2452a24d17dabef1c1d5e16f0dca9f Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Wed, 16 Apr 2025 23:46:21 +0300
Subject: [PATCH 260/305] mu4e-helpers: make mu4e-plist-put-many
 non-destructive

---
 mu4e/mu4e-helpers.el | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mu4e/mu4e-helpers.el b/mu4e/mu4e-helpers.el
index a623e1891..db6b21ee3 100644
--- a/mu4e/mu4e-helpers.el
+++ b/mu4e/mu4e-helpers.el
@@ -625,7 +625,7 @@ Returns the updated PLIST."
 PLIST is a property list, and KEYVALS are key value ... ."
   (let (p)
     (while keyvals
-      (setq p (plist-put plist (car keyvals) (cadr keyvals)))
+      (setq p (plist-put p (car keyvals) (cadr keyvals)))
       (setq keyvals (cddr keyvals)))
     p))
 

From faea3c35ad104b4d5b80b7013f9839763fc9dae4 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Thu, 17 Apr 2025 00:11:50 +0300
Subject: [PATCH 261/305] mu4e-helpers: tweak plist filtering

A little refactoring
---
 mu4e/mu4e-helpers.el | 33 +++++++++++++--------------------
 1 file changed, 13 insertions(+), 20 deletions(-)

diff --git a/mu4e/mu4e-helpers.el b/mu4e/mu4e-helpers.el
index db6b21ee3..002465dbd 100644
--- a/mu4e/mu4e-helpers.el
+++ b/mu4e/mu4e-helpers.el
@@ -588,37 +588,30 @@ Mu4e's version of Emacs 28's `string-replace'."
 
 (defun mu4e-plistp (object)
   "Non-nil if and only if OBJECT is a valid plist.
-
 This is mu4e's version of Emacs 29's `plistp'."
   (let ((len (proper-list-p object)))
     (and len (zerop (% len 2)))))
 
-(defun mu4e-plist-do (func plist)
-  "Apply FUNC to each element in PLIST.
-FUNC receives to arguments: the key and its value."
-  (when plist
-    (funcall func (car plist) (cadr plist))
-    (mu4e-plist-do func (cddr plist))))
-
-(defun mu4e-plist-remove (plist prop)
-  "Remove PROP from PLIST.
-Returns the updated PLIST."
-  ;; inspired by org-plist-delete
+(defun mu4e-plist-filter (plist pred)
+  "Return a plist for which a call to pred is non-nil.
+PLIST is some plist, and PRED is a function taking a key and
+value."
   (let (p)
     (while plist
-      (if (not (eq prop (car plist)))
-          (setq p (plist-put p (car plist) (nth 1 plist))))
+      (let ((key (car plist)) (val (cadr plist)))
+           (when (funcall pred key val)
+             (setq p (plist-put p key val))))
       (setq plist (cddr plist)))
     p))
 
+(defun mu4e-plist-remove (plist prop)
+  "Remove PROP from PLIST.
+Returns the updated PLIST."
+  (mu4e-plist-filter plist (lambda (k _v) (not (eq k prop)))))
+
 (defun mu4e-plist-remove-nils (plist)
   "Remove all properties with value nil from PLIST."
-  (let (p)
-    (while plist
-      (when (cadr plist)
-        (setq p (plist-put p (car plist) (cadr plist))))
-      (setq plist (cddr plist)))
-    p))
+  (mu4e-plist-filter plist (lambda (_k v) v)))
 
 (defun mu4e-plist-put-many (plist &rest keyvals)
   "Like `plist-put', but allow for multiple key-value pairs.

From 174c8aa57540cc41b3211ccf86d241879525a3fd Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Thu, 17 Apr 2025 00:12:41 +0300
Subject: [PATCH 262/305] mu4e-query-items: ensure :key is in results

This worked earlier accidentally....
---
 mu4e/mu4e-query-items.el | 1 +
 1 file changed, 1 insertion(+)

diff --git a/mu4e/mu4e-query-items.el b/mu4e/mu4e-query-items.el
index 3c8edb96c..8ae5e2d03 100644
--- a/mu4e/mu4e-query-items.el
+++ b/mu4e/mu4e-query-items.el
@@ -229,6 +229,7 @@ bookmark or maildir."
          item
          :name         name
          :type         type
+         :key          (plist-get item :key)
          :query        query
          :count        count
          :unread       unread

From 371216a9fe5043bf8928b497b77dafdae0c300a1 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Thu, 17 Apr 2025 18:35:31 +0300
Subject: [PATCH 263/305] mu4e-draft: ensure we only remove the message Date:

Narrow to headers first, or we may remove e.g. Date: headers in
forwarded messages.
---
 mu4e/mu4e-draft.el | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/mu4e/mu4e-draft.el b/mu4e/mu4e-draft.el
index d65ab00fa..57e0e6c52 100644
--- a/mu4e/mu4e-draft.el
+++ b/mu4e/mu4e-draft.el
@@ -362,7 +362,9 @@ appropriate sent-messages folder. If MSGPATH is nil, do nothing."
       (message-generate-headers '(Message-ID)))
     ;; older Emacsen (<= 28 perhaps?) won't update the Date
     ;; if there already is one; so make sure it's gone.
-    (message-remove-header "Date")
+    (save-restriction
+      (message-narrow-to-headers)
+      (message-remove-header "Date"))
     (message-generate-headers '(Date Subject From))
     (mu4e--delimit-headers 'undelimit))) ;; remove separator
 

From 9cd4d73212b0a302fbc007fb64083998ac00bfcf Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Wed, 23 Apr 2025 07:42:45 +0300
Subject: [PATCH 264/305] mu4e-folders: rework the mu4e-ask-maildir

Attempt to restore the old behaviour of _other_ when there are no maildir
shortcuts defined.

Should help for #2843.
---
 mu4e/mu4e-folders.el | 41 +++++++++++++++++++----------------------
 1 file changed, 19 insertions(+), 22 deletions(-)

diff --git a/mu4e/mu4e-folders.el b/mu4e/mu4e-folders.el
index d3d9dcf6c..cec99ae18 100644
--- a/mu4e/mu4e-folders.el
+++ b/mu4e/mu4e-folders.el
@@ -248,37 +248,36 @@ to create it; otherwise return nil."
   "Get maildirs under `mu4e-maildir'."
   mu4e-maildir-list)
 
-
 (defun mu4e-ask-maildir (prompt &optional query-item)
   "Ask the user for a maildir (using PROMPT).
 
 If QUERY-ITEM is non-nil, return the full query-item rather than
 just the query-string.
 
-If the special shortcut \"o\" (for _o_ther) is used, or
-if (mu4e-maildir-shortcuts) evaluates to nil, let user choose
-from all maildirs under `mu4e-maildir'.
+If the special shortcut \"o\" (for _o_ther) is used, or if there
+a no single-key elements in (mu4e-maildir-shortcuts), let user
+choose from all maildirs under `mu4e-maildir'.
 
 The names of the maildirs are displayed in the minibuffer,
 suffixed with the short version of the unread counts, as per
 `mu4e--query-item-display-short-counts'."
   (let* ((mdirs
-          (append
-           (seq-map
-            (lambda (md)
-              (let* ((qitem (mu4e--query-item-for-maildir-shortcut md))
-                     (unreads (mu4e--query-item-display-short-counts qitem)))
-                (cons
-                 (format "%c%s%s"
-                         (plist-get md :key)
-                         (or (plist-get md :name)
-                             (plist-get md :maildir))
-                         unreads) md)))
-            (mu4e-filter-single-key (mu4e-maildir-shortcuts)))
-           '(("oOther..." . other)))) ;; append "Other" pseudo-maildir
-         (chosen (mu4e-read-option prompt mdirs))
+          (seq-map
+           (lambda (md)
+             (let* ((qitem (mu4e--query-item-for-maildir-shortcut md))
+                    (unreads (mu4e--query-item-display-short-counts qitem)))
+               (cons
+                (format "%c%s%s"
+                        (plist-get md :key)
+                        (or (plist-get md :name)
+                            (plist-get md :maildir))
+                        unreads) md)))
+           (mu4e-filter-single-key (mu4e-maildir-shortcuts))))
          ;; special case: handle pseudo-maildir 'other
-         (chosen (if (eq chosen 'other)
+         (mdirs (and mdirs (append mdirs '(("oOther..." . other)))))
+         (chosen (and mdirs (mu4e-read-option prompt mdirs)))
+         ;; if chosen nothing or other, ask for more.
+         (chosen (if (or (not chosen) (eq chosen 'other))
                      (list :maildir
                            (substring-no-properties
                             (funcall mu4e-completing-read-function prompt
@@ -287,9 +286,7 @@ suffixed with the short version of the unread counts, as per
                    chosen)))
     ;; return either the maildir (as a string), or the corresponding
     ;; query-item.
-    (if query-item
-        chosen
-      (plist-get chosen :maildir))))
+    (if query-item chosen (plist-get chosen :maildir))))
 
 (defun mu4e-ask-maildir-check-exists (prompt)
   "Like `mu4e-ask-maildir', PROMPT for existence of the maildir.

From ddc5d00efc77b33710d205faddfc033a3920bf7a Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Wed, 23 Apr 2025 07:45:34 +0300
Subject: [PATCH 265/305] mu4e-folders: update docstrings

---
 mu4e/mu4e-folders.el | 36 +++++++++++++++++++++---------------
 1 file changed, 21 insertions(+), 15 deletions(-)

diff --git a/mu4e/mu4e-folders.el b/mu4e/mu4e-folders.el
index cec99ae18..1fc14b1c7 100644
--- a/mu4e/mu4e-folders.el
+++ b/mu4e/mu4e-folders.el
@@ -1,6 +1,6 @@
 ;;; mu4e-folders.el --- Maildirs & folders -*- lexical-binding: t -*-
 
-;; Copyright (C) 2021-2024 Dirk-Jan C. Binnema
+;; Copyright (C) 2021-2025 Dirk-Jan C. Binnema
 
 ;; Author: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ;; Maintainer: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
@@ -36,36 +36,40 @@
 
 (defcustom mu4e-drafts-folder "/drafts"
   "Folder for draft messages, relative to the root maildir.
+
 For instance, \"/drafts\".
 
-Instead of a string, may also be a function that takes a
+Instead of a string, can also be a function that takes a
 message (a msg plist, see `mu4e-message-field'), and returns a
 folder. Note, the message parameter refers to the original
 message being replied to / being forwarded / re-edited and is nil
-otherwise. `mu4e-drafts-folder' is only evaluated once.
+otherwise.
+
+`mu4e-drafts-folder' is only evaluated once.
 
-The form of draft messages is not necessarily compatible with
-other e-mail programs, e.g. when it involves attachments and the
-like.
-"
+Note: the format of draft messages is not necessarily fully
+compatible with other e-mail programs, e.g. when it involves
+attachments or other MIME-parts."
   :type '(choice
           (string :tag "Folder name")
-          (function :tag "Function return folder name"))
+          (function :tag "Function which returns a folder name"))
   :group 'mu4e-folders)
 
 (defcustom mu4e-refile-folder "/archive"
-  "Folder for refiling messages, relative to the root maildir.
+  "Folder for refiling, relative to the root maildir.
+
 For instance \"/Archive\". Instead of a string, may also be a
 function that takes a message (a msg plist, see
 `mu4e-message-field'), and returns a folder. Note that the
 message parameter refers to the message-at-point."
   :type '(choice
           (string :tag "Folder name")
-          (function :tag "Function return folder name"))
+          (function :tag "Function which returns a folder name"))
   :group 'mu4e-folders)
 
 (defcustom mu4e-sent-folder "/sent"
   "Folder for sent messages, relative to the root maildir.
+
 For instance, \"/Sent Items\". Instead of a string, may also be a
 function that takes a message (a msg plist, see
 `mu4e-message-field'), and returns a folder. Note that the
@@ -73,23 +77,25 @@ message parameter refers to the original message being replied to
 / being forwarded / re-edited, and is nil otherwise."
   :type '(choice
           (string :tag "Folder name")
-          (function :tag "Function return folder name"))
+          (function :tag "Function which returns a folder name"))
   :group 'mu4e-folders)
 
 (defcustom mu4e-trash-folder "/trash"
   "Folder for trashed messages, relative to the root maildir.
+
 For instance, \"/trash\". Instead of a string, may also be a
 function that takes a message (a msg plist, see
-`mu4e-message-field'), and returns a folder. When using
-`mu4e-trash-folder' in the headers view (when marking messages
-for trash). Note that the message parameter refers to the
+`mu4e-message-field'), and returns a folder.
+
+When using `mu4e-trash-folder' in the headers view (when marking
+messages for trash), the message parameter refers to the
 message-at-point. When using it when composing a message (see
 `mu4e-sent-messages-behavior'), this refers to the original
 message being replied to / being forwarded / re-edited, and is
 nil otherwise."
   :type '(choice
           (string :tag "Folder name")
-          (function :tag "Function return folder name"))
+          (function :tag "Function which returns a folder name"))
   :group 'mu4e-folders)
 
 (defcustom mu4e-maildir-shortcuts nil

From 481d976c8292923571216f72a8d026e1222e786d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Thomas=20M=C3=BChlbacher?= <tmuehlbacher@posteo.net>
Date: Thu, 24 Apr 2025 22:13:20 +0200
Subject: [PATCH 266/305] mu4e.texi: fix smart refiling example config

---
 mu4e/mu4e.texi | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index 0f65d09b3..04c2dab99 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -2895,9 +2895,8 @@ message. An example should clarify this:
          (mu4e-message-field msg :subject))
         "/football")
       ;; messages sent by me go to the sent folder
-      ((mu4e-message-sent-by-me msg
-         (mu4e-personal-addresses))
-        mu4e-sent-folder)
+      ((mu4e-message-sent-by-me msg)
+       mu4e-sent-folder)
       ;; everything else goes to /archive
       ;; important to have a catch-all at the end!
       (t  "/archive"))))

From 998a6448d502fcdc022816d719f730eb7d7d044e Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 3 May 2025 08:51:48 +0300
Subject: [PATCH 267/305] bump version to 1.12.10

---
 meson.build | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/meson.build b/meson.build
index d1c7b8bb3..36b95ba3b 100644
--- a/meson.build
+++ b/meson.build
@@ -17,7 +17,7 @@
 ################################################################################
 # project setup
 project('mu', ['c', 'cpp'],
-        version: '1.12.9',
+        version: '1.12.10',
         meson_version: '>= 0.56.0',
         license: 'GPL-3.0-or-later',
         default_options : [
@@ -28,7 +28,7 @@ project('mu', ['c', 'cpp'],
 
 # hard-code the date here (for reproducibility); we derive the dates used in e.g.
 # documentation from this.
-mu_date='2025-02-26'
+mu_date='2025-05-03'
 
 # installation paths
 prefixdir = get_option('prefix')

From 6c94f994a2b0b2729dd25a4ccb96832ade536a53 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 4 May 2025 16:27:46 +0300
Subject: [PATCH 268/305] mu4e.texi: fix mistaken @c

HT: https://github.com/djcb/mu/pull/2846
---
 mu4e/mu4e.texi | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index 04c2dab99..d178af906 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -1560,7 +1560,7 @@ E-mail messages can be though as a series of ``MIME-parts'', which are sections
 of the message. The most prominent is the 'body', that is the main message your
 are reading. Many e-mail messages also contains @emph{attachments}, which
 MIME-parts that contain files@footnote{Attachments come in two flavors:
-@c{inline} and @c{attachment}. @t{mu4e} does not distinguish between them when
+@t{inline} and @t{attachment}. @t{mu4e} does not distinguish between them when
 operating on them; everything that specifies a filename is considered an
 attachment}.
 

From f72559463609a88a15fcc14e1c6819366093130b Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Thu, 8 May 2025 09:24:51 +0300
Subject: [PATCH 269/305] mu4e-query-items: allow refreshing the cache

---
 mu4e/mu4e-query-items.el | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/mu4e/mu4e-query-items.el b/mu4e/mu4e-query-items.el
index 8ae5e2d03..4814cb0fa 100644
--- a/mu4e/mu4e-query-items.el
+++ b/mu4e/mu4e-query-items.el
@@ -241,13 +241,12 @@ bookmark or maildir."
          :effective-query effective-query))))
      data))
 
-(defun mu4e-query-items (&optional type)
+(defun mu4e-query-items (&optional type refresh)
   "Grab cached information about query items of some TYPE.
 
 TYPE is a symbol; either `bookmarks' or `maildirs', or nil for
 both, and returns a list of plists. The information is based on
 the last (cached) information known by mu4e.
-
 This combines:
 - the latest queries data (i.e., `(mu4e-server-query-items)')
 - baseline queries data (i.e. `mu4e-baseline') with the combined
@@ -266,8 +265,13 @@ Currently, the plist contains the following fields:
 There are some other fields for internal mu4e use, better not use
 those externally.
 
+If REFRESH is non-nil, clear caches first.
+
 For the various nuances with the unread count and baseline,
 please refer to info node `(mu4e) Bookmarks and Maildirs'."
+  (when refresh ; clear caches?
+    (setq mu4e--bookmark-items-cached nil
+          mu4e--maildir-items-cached nil))
   (cond
    ((equal type 'bookmarks)
     (or mu4e--bookmark-items-cached

From e39e135e6747d533dcc31de7998a25878aec9a4f Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Thu, 8 May 2025 09:25:17 +0300
Subject: [PATCH 270/305] mu4e-plist-put: add to existing keys

---
 mu4e/mu4e-helpers.el | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mu4e/mu4e-helpers.el b/mu4e/mu4e-helpers.el
index 002465dbd..e8ab70173 100644
--- a/mu4e/mu4e-helpers.el
+++ b/mu4e/mu4e-helpers.el
@@ -616,7 +616,7 @@ Returns the updated PLIST."
 (defun mu4e-plist-put-many (plist &rest keyvals)
   "Like `plist-put', but allow for multiple key-value pairs.
 PLIST is a property list, and KEYVALS are key value ... ."
-  (let (p)
+  (let ((p plist))
     (while keyvals
       (setq p (plist-put p (car keyvals) (cadr keyvals)))
       (setq keyvals (cddr keyvals)))

From 5d7cdda27fd165f32c6bde177bcbb0cb4c97da99 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 10 May 2025 10:49:41 +0300
Subject: [PATCH 271/305] mu4e.texi: improve docs on attachments

Be a bit more complete.

Fixes #2844.
---
 mu4e/mu4e.texi | 44 ++++++++++++++++++++++++++++++--------------
 1 file changed, 30 insertions(+), 14 deletions(-)

diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index d178af906..5e799a32e 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -1556,21 +1556,27 @@ mu4e-view-show-mime-parts}. This can be a little slow.
 @cindex attachments
 @cindex mime-parts
 
-E-mail messages can be though as a series of ``MIME-parts'', which are sections
-of the message. The most prominent is the 'body', that is the main message your
-are reading. Many e-mail messages also contains @emph{attachments}, which
-MIME-parts that contain files@footnote{Attachments come in two flavors:
-@t{inline} and @t{attachment}. @t{mu4e} does not distinguish between them when
-operating on them; everything that specifies a filename is considered an
-attachment}.
-
-To save such attachments as files on your file systems, @t{mu4e}'s message-view
+Typical e-mail messages can be thought of as a series of ``MIME-parts'', which
+are sections of the message. The most prominent of those parts is the 'body',
+which is the text of the message your are reading.
+
+Many e-mail messages also contain @emph{attachments}, which are MIME-parts that
+contain files@footnote{Attachments come in two flavors: @t{inline} and
+@t{attachment}. @t{mu4e} does not distinguish between the two when operating on
+them: everything that specifies a filename is considered an attachment}.
+
+To save such attachments as files on your computer, @t{mu4e}'s message-view
 offers the command @code{mu4e-view-save-attachments}; its default keybinding is
 @key{e} (think @emph{extract}).
 
+Note that when point is on the attachment label in the message, e.g., on
+something that looks like @t{[4. application/pdf; Some Document.pdf]...}, Gnus'
+binding for @kbd{e} prevails, which is @code{gnus-mime-view-part-externally}.
+You can of course customize this in the usual (Emacs) way.
+
 After invoking the command, you can enter the file names to save,
 comma-separated, with completion support. Press @key{RET} to save the chosen
-files to your file-system.
+attachments as files to your computer.
 
 @t{mu4e} determines the target directory using the variable
 @t{mu4e-attachment-dir} (which can be either file-system path or a function; see
@@ -1582,13 +1588,23 @@ active, which offers @code{mu4e-view-complete-all} (bound to @key{C-c C-a} to
 complete @emph{all} files@footnote{Except when using 'Helm'; in that case, use
 the Helm-mechanism for selecting multiple}.
 
+@code{mu4e-view-save-attachments} assumes unique filenames for the attachments,
+which is requirement of the underlying completion mechanism works. If there are
+duplicates, only one is recognized.
+
+Furthermore, file names that match @code{crm-separator} (by default, commas) are
+not supported (see @t{completing-read-multiple} for further details). For such
+corner-cases, it is recommended to use @code{mu4e-view-mime-part-action}
+instead, which does not have this limitation.
+
 @subsection MIME-parts
 
 Not all MIME-parts are message bodies or attachments, and it can be useful to
-operate on those other parts as well. For that there is
-@code{mu4e-view-mime-part-action} (default key-binding @key{A}). You can pass
-the number of the MIME-part (as seen in the message view) as a prefix argument;
-otherwise you get to get to choose from a completion menu.
+operate on those other parts as well.
+
+To do so, there is @code{mu4e-view-mime-part-action} (default key-binding
+@key{A}). You can pass the number of the MIME-part (as seen in the message view)
+as a prefix argument; otherwise you get to get to choose from a completion menu.
 
 After choosing one or more MIME-parts, you can specify an action to apply to
 them; see the variable @code{mu4e-view-mime-part-actions} for the possibilities.

From 9b5ed2d38ebd6b7590320a9ff9ee10e4feead34c Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 10 May 2025 11:20:21 +0300
Subject: [PATCH 272/305] bump version to 1.12.11

New stable update; mostly to fix #2847, but with some doc fixes as well.
---
 meson.build | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/meson.build b/meson.build
index 36b95ba3b..379f71190 100644
--- a/meson.build
+++ b/meson.build
@@ -17,7 +17,7 @@
 ################################################################################
 # project setup
 project('mu', ['c', 'cpp'],
-        version: '1.12.10',
+        version: '1.12.11',
         meson_version: '>= 0.56.0',
         license: 'GPL-3.0-or-later',
         default_options : [
@@ -28,7 +28,7 @@ project('mu', ['c', 'cpp'],
 
 # hard-code the date here (for reproducibility); we derive the dates used in e.g.
 # documentation from this.
-mu_date='2025-05-03'
+mu_date='2025-05-10'
 
 # installation paths
 prefixdir = get_option('prefix')

From c4b40101855cf9fb8463a824d2de838fc69d67dc Mon Sep 17 00:00:00 2001
From: jman-schief <82455740+jman-schief@users.noreply.github.com>
Date: Wed, 21 May 2025 13:45:42 +0200
Subject: [PATCH 273/305] Support dash when autocompleting maildirs

---
 mu4e/mu4e-search.el | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mu4e/mu4e-search.el b/mu4e/mu4e-search.el
index d3f1cbd1c..72203a013 100644
--- a/mu4e/mu4e-search.el
+++ b/mu4e/mu4e-search.el
@@ -412,7 +412,7 @@ status, STATUS."
           '("attach" "draft" "flagged" "list" "new" "passed" "replied"
             "seen" "trashed" "unread" "encrypted" "signed" "personal"
             "calendar")))
-   ((looking-back "maildir:\\([a-zA-Z0-9/.]*\\)" nil)
+   ((looking-back "maildir:\\([a-zA-Z0-9/.-]*\\)" nil)
     (list (match-beginning 1)
           (match-end 1)
           (mapcar (lambda (dir)

From acef5b23810e33a199e3f5d7efd20744384e2160 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 20 May 2025 21:57:40 +0300
Subject: [PATCH 274/305] mu4e: implement mu4e-emacs-bookmark-policy

Allow for creating Emacs bookmarks for either messages (as before & the
default), queries or as the user.
---
 NEWS.org             | 18 +++++++++----
 mu4e/mu4e-helpers.el | 39 +++++++++++-----------------
 mu4e/mu4e-search.el  | 62 ++++++++++++++++++++++++++++++++++++++++++--
 mu4e/mu4e.texi       | 16 +++++++-----
 4 files changed, 98 insertions(+), 37 deletions(-)

diff --git a/NEWS.org b/NEWS.org
index 4df464a2f..e25bec868 100644
--- a/NEWS.org
+++ b/NEWS.org
@@ -123,10 +123,6 @@
 
     - 1.12.9: the cleanup phase after indexing is significantly faster now
 
-    - 1.12.10: ~mu4e-maildir-shortcuts~ and ~mu4e-bookmarks~ now understand a
-      property ~:hide-if-no-unread~, which hides the maildir/bookmark from the
-      main-view if there are no unread messages which the corresponding query.
-
 *** mu4e
 
 **** message composer
@@ -230,7 +226,7 @@
     - links (in text-mode emails) are now clickable through <mouse-2>, to be
       consistent with eww.
 
-    - support new-mail notifications on MacOS out-of-the-box
+    - support new-mail notifications on MacOS/OSX out-of-the-box
 
     - allow sorting by tag
 
@@ -270,6 +266,18 @@
       message view as well, such as ~gnus-mailing-list-subscribe~,
       ~gnus-mailing-list-unsubscribe~.
 
+    - 1.12.10: ~mu4e-maildir-shortcuts~ and ~mu4e-bookmarks~ now understand a
+      property ~:hide-if-no-unread~, which hides the maildir/bookmark from the
+      main-view if there are no unread messages which the corresponding query.
+
+    - 1.12.10: ~mu4e-maildir-shortcuts~ and ~mu4e-bookmarks~ now understand a
+      property ~:hide-if-no-unread~, which hides the maildir/bookmark from the
+      main-view if there are no unread messages which the corresponding query.
+
+   - 1.12.12: it now possible to create Emacs bookmarks for both messages
+     (default) and queries. See the new variable ~mu4e-emacs-bookmark-policy~.
+
+
 *** Contributors
 
     Thanks to our contributors - code committers belows, but also to everyone
diff --git a/mu4e/mu4e-helpers.el b/mu4e/mu4e-helpers.el
index e8ab70173..17412182c 100644
--- a/mu4e/mu4e-helpers.el
+++ b/mu4e/mu4e-helpers.el
@@ -288,7 +288,7 @@ user can then choose by typing CHAR.  Example:
 User now will be presented with a list: \"Choose an animal:
    [M]onkey, [G]nu, [x]Moose\".
 
-If optional character KEY is provied, use that instead of asking
+If optional character KEY is provided, use that instead of asking
 the user.
 
 Function returns the value (cdr) of the matching cell."
@@ -520,30 +520,21 @@ Or go to the top level if there is none."
           ('mu4e-view-mode    "(mu4e)Message view")
           (_                  "mu4e"))))
 
+;;; Emacs bookmarks
+(defcustom mu4e-emacs-bookmark-policy 'message
+  "The policy to decide what kind of Emacs bookmark to create.
 
-;;; bookmarks
-(defun mu4e--make-bookmark-record ()
-  "Create a bookmark for the message at point."
-  (let* ((msg     (mu4e-message-at-point))
-         (subject (or (plist-get msg :subject) "No subject"))
-         (date	  (plist-get msg :date))
-         (date	  (if date (format-time-string "%F: " date) ""))
-         (title	  (format "%s%s" date subject))
-         (msgid	  (or (plist-get msg :message-id)
-                      (mu4e-error
-                       "Cannot bookmark message without message-id"))))
-    `(,title
-      ,@(bookmark-make-record-default 'no-file 'no-context)
-      (message-id . ,msgid)
-      (handler    . mu4e--jump-to-bookmark))))
-
-(declare-function mu4e-view-message-with-message-id "mu4e-view")
-(declare-function mu4e-message-at-point             "mu4e-message")
-
-(defun mu4e--jump-to-bookmark (bookmark)
-  "View the message referred to by BOOKMARK."
-  (when-let* ((msgid (bookmark-prop-get bookmark 'message-id)))
-    (mu4e-view-message-with-message-id msgid)))
+This applies to the Emacs bookmark system command `bookmark-set'.
+
+The policy is some symbol; you have the following choices:
+- `message': bookmark the message at point
+- `query': bookmark the most recent query
+- `ask': ask the user interactively"
+  :type '(choice
+          (const :tag "Bookmark query at point" message)
+          (const :tag "Bookmark the last query" query)
+          (const :tag "Ask user" ask))
+  :group 'mu4e)
 
 (defun mu4e--popup-lisp-buffer (bufname data)
   "Show or hide an s-expression string in a popup-buffer.
diff --git a/mu4e/mu4e-search.el b/mu4e/mu4e-search.el
index 72203a013..efcf68dae 100644
--- a/mu4e/mu4e-search.el
+++ b/mu4e/mu4e-search.el
@@ -617,8 +617,66 @@ query before submitting it."
                     (mu4e-warn "No query for %s" chosen))))
     (mu4e-search-bookmark query edit)))
 
+;; Emacs bookmark support.
+
+(declare-function mu4e-view-message-with-message-id "mu4e-view")
+(declare-function mu4e-message-at-point             "mu4e-message")
+(declare-function mu4e-search-bookmark              "mu4e-search")
+(declare-function mu4e-server-last-query            "mu4e-server")
+
+(defun mu4e--jump-to-bookmark (bmark)
+  "Handle Emacs bookmark BMARK for either message or query."
+  (let ((message-id (bookmark-prop-get bmark 'message-id))
+        (last-query (bookmark-prop-get bmark 'last-query)))
+    (cond
+     (message-id  (mu4e-view-message-with-message-id message-id))
+     (last-query  (mu4e-search-bookmark (plist-get last-query :query))))))
+
+(defun mu4e--make-bookmark-record ()
+  "Create an Emacs bookmark for the message at point.
+Not to be confused with a *mu4e* bookmark: this is about the
+standard Emacs bookmarking facility.
+
+Also see `mu4e-emacs-bookmark-policy'."
+  (let* ((policy mu4e-emacs-bookmark-policy)
+         (policy (if (member policy '(message query))
+                     policy
+                   (mu4e-read-option "What to bookmark? "
+                                     '(("mMessage at point" . message)
+                                       ("qLast query" . query)))))
+         (bmark (cons nil (bookmark-make-record-default
+                           'no-file 'no-context))))
+    (progn
+      (bookmark-prop-set bmark 'handler 'mu4e--jump-to-bookmark)
+      ;; add bookmark-type specifics.
+      (cond
+       ;; bookmark the last query (the full plist)
+       ((eq policy 'query)
+        (let* ((last-query (mu4e-server-last-query))
+               (title (plist-get last-query :query)))
+          (bookmark-prop-set bmark 'defaults (list (concat "Query: " title)))
+          (bookmark-prop-set bmark 'last-query last-query)))
+
+       ;; bookmark the message at point
+       ((eq policy 'message)
+        (let* ((msg     (mu4e-message-at-point))
+               (subject (or (plist-get msg :subject) "No subject"))
+               (date    (plist-get msg :date))
+               (date    (if date (format-time-string "%F: " date) ""))
+               (title   (format "%s%s" date subject))
+               (msgid   (or (plist-get msg :message-id)
+                            (mu4e-error
+                             "Cannot bookmark message without message-id"))))
+          (bookmark-prop-set bmark 'defaults (list title))
+          (bookmark-prop-set bmark 'message-id msgid)))
+       (t ;; something went awry
+        (mu4e-error "Invalid bookmark policy"))))
+    ;;
+    bmark))
+
+
 (defvar mu4e-search-minor-mode-map
-    (let ((map (make-sparse-keymap)))
+  (let ((map (make-sparse-keymap)))
     (define-key map "s" #'mu4e-search)
     (define-key map "S" #'mu4e-search-edit)
     (define-key map "/" #'mu4e-search-narrow)
@@ -637,7 +695,7 @@ query before submitting it."
 
     (define-key map "j" #'mu4e-search-maildir)
     map)
-    "Keymap for mu4e-search-minor-mode.")
+  "Keymap for mu4e-search-minor-mode.")
 
 (define-minor-mode mu4e-search-minor-mode
   "Mode for searching for messages."
diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index 5e799a32e..9a05eb09c 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -3464,13 +3464,17 @@ want tweak the details, have a look at @code{mu4e-notification-filter} and
 @section Emacs bookmarks
 @cindex Emacs bookmarks
 
-Note, Emacs bookmarks are not to be confused with mu4e's bookmarks; the former
-are a generic linking system across Emacs, while the latter are stored queries
-within @t{mu4e}.
+@t{mu4e} integrates with the Emacs bookmarks system, and allows you to create
+bookmarks with with @code{bookmark-set} for either message-at-point or the last
+query. The message links are based on the message's message-id, and thus the
+bookmarks stay valid even if you move the message around.
 
-@t{mu4e} supports linking to the message-at-point through the normal Emacs
-built-in bookmark system. The links are based on the message's message-id, and
-thus the bookmarks stay valid even if you move the message around.
+For deciding whether to link to message or query, you can customize
+@var{mu4e-emacs-bookmark-policy}.
+
+Emacs bookmarks are not to be confused with mu4e's bookmarks; the former are a
+generic linking system across Emacs, while the latter are stored queries within
+@t{mu4e}.
 
 @node Eldoc
 @section Eldoc

From ef71b5372f444777d40fcf6a5418c757755b1276 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Wed, 21 May 2025 20:18:13 +0300
Subject: [PATCH 275/305] mu4e: fix compiler warnings

---
 mu4e/mu4e-folders.el | 2 +-
 mu4e/mu4e-headers.el | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/mu4e/mu4e-folders.el b/mu4e/mu4e-folders.el
index 1fc14b1c7..30501324a 100644
--- a/mu4e/mu4e-folders.el
+++ b/mu4e/mu4e-folders.el
@@ -115,7 +115,7 @@ shortcut (e.g., \"/archive\").
 Example:
 
  (setq mu4e-maildir-shortcuts
-       '((:maildir \"/inbox\"     :key ?i :hide-if-no-unread t)
+     \='((:maildir \"/inbox\"     :key ?i :hide-if-no-unread t)
          (:maildir \"/drafts\"    :key ?d :hide t)
          (:maildir \"/sent\"      :key ?s :hide-unread t)))
 
diff --git a/mu4e/mu4e-headers.el b/mu4e/mu4e-headers.el
index d6d9b2dbb..bc63c85aa 100644
--- a/mu4e/mu4e-headers.el
+++ b/mu4e/mu4e-headers.el
@@ -1038,10 +1038,10 @@ you cannot sort by this field.
 If THREADS is non-nil, give a more informative error message."
   (if (not sortable)
       (if threads
-          (lambda (&optional e)
+          (lambda (&optional _e)
             (interactive "e")
             (mu4e-message "With threading, you can only sort by date"))
-        (lambda (&optional e)
+        (lambda (&optional  _e)
           (interactive "e")
           (mu4e-message "Field is not sortable")))
     (lambda (&optional e)

From f75e1203d4ba94ac405aa4cf7dc405a4a263133e Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Wed, 21 May 2025 20:18:43 +0300
Subject: [PATCH 276/305] mu: rename --my-address into --personal-address

This makes things a bit more uniform with all the places where we use
"personal".

--my-address remains as an alias for the command-line option.

Add unit test.

Resolves #2806.
---
 IDEAS.org          |  6 +++---
 lib/mu-server.cc   |  3 +--
 man/mu-cfind.1.org | 43 ++++++++++++++++++++++++++-----------------
 man/mu-init.1.org  |  5 +++--
 mu/mu-cmd-init.cc  | 39 ++++++++++++++++++++++++++++++++++++---
 mu/mu-options.cc   |  6 ++++--
 mu/mu-options.hh   |  2 +-
 mu4e/mu4e-main.el  |  2 +-
 mu4e/mu4e.texi     | 18 ++++++++++--------
 9 files changed, 85 insertions(+), 39 deletions(-)

diff --git a/IDEAS.org b/IDEAS.org
index f0435d6d2..5f1a7c85e 100644
--- a/IDEAS.org
+++ b/IDEAS.org
@@ -27,9 +27,6 @@ future.
   the newest though) https://github.com/djcb/mu/issues/2759. Or, from
   new-to-old, reversed in thread: https://github.com/djcb/mu/issues/2807
 
-- perhaps use =--personal-addres= instead of =--my-address= for consistency
-  https://github.com/djcb/mu/issues/2806
-
 ** mu4e
 
 - Allow for *muting* messages https://github.com/djcb/mu/issues/636 Useful;
@@ -93,3 +90,6 @@ future.
   Yes: this is implemented now, in 1.12.9. Various Gnus' mailing list commands
   are now available in the mu4e message view as well, such as
   ~gnus-mailing-list-subscribe~, ~gnus-mailing-list-unsubscribe~.
+
+- perhaps use =--personal-addres= instead of =--my-address= for consistency
+  https://github.com/djcb/mu/issues/2806 (done as per 1.12.12)
diff --git a/lib/mu-server.cc b/lib/mu-server.cc
index 0ea352f08..700f5e324 100644
--- a/lib/mu-server.cc
+++ b/lib/mu-server.cc
@@ -345,8 +345,7 @@ Server::Private::make_command_map()
 	cmap.emplace(
 	    "index",
 	    CommandInfo{
-		ArgMap{{":my-addresses", ArgInfo{Type::List, false, "list of 'my' addresses"}},
-		       {":cleanup",
+		ArgMap{{":cleanup",
 			ArgInfo{Type::Symbol,
 				false,
 				"whether to remove stale messages from the store"}},
diff --git a/man/mu-cfind.1.org b/man/mu-cfind.1.org
index c68058794..220d9f699 100644
--- a/man/mu-cfind.1.org
+++ b/man/mu-cfind.1.org
@@ -4,8 +4,8 @@
 
 * NAME
 
-mu-cfind - find contacts in the *mu* database and export them
-for use in other programs.
+mu-cfind - find contacts in the *mu* database and export them for use in other
+programs.
 
 * SYNOPSIS
 
@@ -14,15 +14,15 @@ for use in other programs.
 * DESCRIPTION
 
 *mu cfind* is the *mu* command for finding =contacts= (name and e-mail address of
-people who were either an e-mail's sender or receiver). There are different
-output formats available, for importing the contacts into other programs.
+people who were either an e-mail's sender or receiver). Different output formats
+are available, e.g., for importing the contacts into other programs.
 
 * SEARCHING CONTACTS
 
 When you index your messages (see *mu index*), *mu* creates a list of unique e-mail
-addresses found and the accompanying name, and caches this list. In case the
-same e-mail address is used with different names, the most recent non-empty name
-is used.
+addresses found and the accompanying name, and caches this list. If the same
+e-mail address is used with different names, the most recent non-empty name is
+used. If that is not the desired name, see *CORRECTING* below.
 
 *mu cfind* starts a search for contacts that match a =regular expression=. For
 example:
@@ -31,7 +31,7 @@ example:
 $ mu cfind '@gmail\.com'
 #+end_example
 
-would find all contacts with a gmail-address, while
+finds all contacts with a gmail-address, while
 
 #+begin_example
 $ mu cfind Mary
@@ -40,8 +40,8 @@ $ mu cfind Mary
 lists all contacts with Mary in either name or e-mail address.
 
 If you do not specify a search expression, *mu cfind* returns the full list of
-contacts. Note, *mu cfind* uses a cache with the e-mail information, which is
-populated during the indexing process.
+contacts. *mu cfind* uses a cache with the e-mail information, which is populated
+during the indexing process.
 
 The regular expressions are basic case-insensitive PCRE, see {{{man-link(pcre,3)}}}.
 
@@ -56,7 +56,7 @@ Sets the output format to the given value. The following are available:
 | plain       | default, simple list              |
 | mutt-alias  | mutt alias-format                 |
 | mutt-ab     | mutt external address book format |
-| wl          | wanderlust addressbook format     |
+| wl          | wanderlust address book format    |
 | org-contact | org-mode org-contact format       |
 | bbdb        | BBDB format                       |
 | csv         | comma-separated values [1]        |
@@ -69,9 +69,10 @@ any double-quote is replaced by a double-double quote (thus, "hello" become
 should only apply to name fields.
 
 ** -p, --personal
-Only show addresses seen in messages where one of `my' e-mail
-addresses was seen in one of the address fields; this is to exclude addresses
-only seen in mailing-list messages. See the *--my-address* parameter to *mu init*.
+Only show addresses seen in messages where at least one of personal e-mail
+addresses was seen in any of the address fields; this is to exclude addresses
+only seen in mailing-list messages. See the *--personal-address* parameter to *mu
+init* for specifying your personal e-mail addresses.
 
 ** --after _timestamp_
 Only show addresses last seen after _timestamp_. _timestamp_ is a UNIX
@@ -80,7 +81,7 @@ Only show addresses last seen after _timestamp_. _timestamp_ is a UNIX
 From the command line, you can use the *date* command to get this value. For
 example, only consider addresses last seen after 2020-06-01, you could specify
 #+begin_example
-  --after=`date +%s --date='2020-06-01'`
+  --after=$(date +%s --date='2020-06-01')
 #+end_example
 
 #+include: "muhome.inc" :minlevel 2
@@ -142,8 +143,8 @@ For this to work, add the following to your _muttrc_:
 set query_command = "mu cfind --format=mutt-ab '%s'"
 #+end_example
 
-Now, in mutt, you can search for e-mail addresses using the *query*-command,
-which is (by default) accessible by pressing *Q*.
+Now, in mutt, you can search for e-mail addresses using the *query*-command, which
+is (by default) accessible by pressing *Q*.
 
 * ENCODING
 
@@ -151,6 +152,14 @@ which is (by default) accessible by pressing *Q*.
 *--format=bbdb*. This is hard-coded to UTF-8, and as such specified in the
 output-file, so emacs/bbdb can handle things correctly, without guessing.
 
+
+* CORRECTING
+
+If you want to correct the name for a given contact, one trick is to manual
+create an e-mail message with some future date that has all the correct name /
+e-mail address combinations, and put this in the Maildir you use.
+
+
 #+include: "exit-code.inc" :minlevel 1
 
 #+include: "bugs.inc" :minlevel 1
diff --git a/man/mu-init.1.org b/man/mu-init.1.org
index b98cdb5e2..09681df39 100644
--- a/man/mu-init.1.org
+++ b/man/mu-init.1.org
@@ -25,7 +25,8 @@ if it is an existing directory. If neither of those can be used, the *--maildir*
 option is required; it must be an absolute path (but ~~/~ expansion is
 performed).
 
-** --my-address _email-address-or-regex_
+** --personal-address _email-address-or-regex_
+** --my-address _email-address-or-regex_  (alias)
 Specifies that some e-mail address is a personal address. The option can be used
 multiple times, to specify all your addresses.
 
@@ -54,7 +55,7 @@ option can be used multiple times). Such addresses then cannot be found with
 {{{man-link(mu-cfind,1)}}} or in the Mu4e contacts cache.
 
 _my-email-address_ can be either a plain e-mail address or a regexp, just like
-for the *--my-address* option.
+for the *--personal-address* option.
 
 ** --max-message-size _size_
 Specifies the maximum size for an e-mail message. Usually, the default of
diff --git a/mu/mu-cmd-init.cc b/mu/mu-cmd-init.cc
index 26a960092..8463ce7b2 100644
--- a/mu/mu-cmd-init.cc
+++ b/mu/mu-cmd-init.cc
@@ -1,5 +1,5 @@
 /*
-** Copyright (C) 2023 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2023-2025 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify it
 ** under the terms of the GNU General Public License as published by the
@@ -56,8 +56,8 @@ Mu::mu_cmd_init(const Options& opts)
 			conf.set<Config::Id::MaxMessageSize>(*opts.init.max_msg_size);
 		if (opts.init.batch_size && *opts.init.batch_size != 0)
 			conf.set<Config::Id::BatchSize>(*opts.init.batch_size);
-		if (!opts.init.my_addresses.empty())
-			conf.set<Config::Id::PersonalAddresses>(opts.init.my_addresses);
+		if (!opts.init.personal_addresses.empty())
+			conf.set<Config::Id::PersonalAddresses>(opts.init.personal_addresses);
 		if (!opts.init.ignored_addresses.empty())
 			conf.set<Config::Id::IgnoredAddresses>(opts.init.ignored_addresses);
 		if (opts.init.support_ngrams)
@@ -130,6 +130,38 @@ test_mu_init_maildir()
 	assert_equal(store.root_maildir(), MU_TESTMAILDIR2);
 }
 
+
+static void
+test_mu_init_personal()
+{
+	TempDir temp_dir{};
+
+	const auto mu_home{temp_dir.path()};
+
+	g_setenv("MAILDIR", MU_TESTMAILDIR2, 1);
+	auto res1 = run_command({MU_PROGRAM, "--quiet", "init",
+			"--muhome", mu_home, "--personal-address", "foo@example.com",
+			"--my-address", "bar@example.com", // backward compat
+			"--personal-address", "/h.llo@example\\.com/"});
+	assert_valid_command(res1);
+
+	auto&& store = unwrap(Store::make(join_paths(temp_dir.path(), "xapian")));
+	g_assert_true(store.empty());
+	assert_equal(store.root_maildir(), MU_TESTMAILDIR2);
+
+	const auto& ccache{store.contacts_cache()};
+
+	// just some basic tests to see the parameters made it through.
+
+	g_assert_true(ccache.is_personal("foo@example.com"));
+	g_assert_true(ccache.is_personal("bar@example.com"));
+	g_assert_true(ccache.is_personal("hello@example.com"));
+	g_assert_true(ccache.is_personal("hallo@example.com"));
+
+	g_assert_false(ccache.is_personal("faa@example.com"));
+	g_assert_false(ccache.is_personal("baa@example.com"));
+}
+
 int
 main(int argc, char* argv[])
 {
@@ -137,6 +169,7 @@ main(int argc, char* argv[])
 
 	g_test_add_func("/cmd/init/basic", test_mu_init_basic);
 	g_test_add_func("/cmd/init/maildir", test_mu_init_maildir);
+	g_test_add_func("/cmd/init/personal", test_mu_init_personal);
 
 	return g_test_run();
 }
diff --git a/mu/mu-options.cc b/mu/mu-options.cc
index 1b58a28b0..2b969321e 100644
--- a/mu/mu-options.cc
+++ b/mu/mu-options.cc
@@ -465,8 +465,9 @@ sub_init(CLI::App& sub, Options& opts)
 		->transform(ExpandPath, "expand maildir path");
 	// don't attempt to canonicalize; in bash this breaks together with
 	// expand path.
-	sub.add_option("--my-address", opts.init.my_addresses,
-		       "Personal e-mail address or regexp")
+	sub.add_option("--personal-address,--my-address",
+		       opts.init.personal_addresses,
+		       "Personal e-mail address or regexp (can be used multiple titmes)")
 		->type_name("<address>");
 	sub.add_option("--ignored-address", opts.init.ignored_addresses,
 		       "Ignored e-mail address or regexp")
@@ -481,6 +482,7 @@ sub_init(CLI::App& sub, Options& opts)
 	sub.add_flag("--reinit", opts.init.reinit,
 		       "Re-initialize database with current settings")
 		->excludes("--maildir")
+		->excludes("--personal-address")
 		->excludes("--my-address")
 		->excludes("--ignored-address")
 		->excludes("--max-message-size")
diff --git a/mu/mu-options.hh b/mu/mu-options.hh
index 643981263..bd5799a68 100644
--- a/mu/mu-options.hh
+++ b/mu/mu-options.hh
@@ -188,7 +188,7 @@ struct Options {
 	 */
 	struct Init {
 		std::string	maildir;		/**< where the mails are */
-		StringVec	my_addresses;		/**< personal e-mail addresses */
+		StringVec	personal_addresses;	/**< personal e-mail addresses */
 		StringVec	ignored_addresses;	/**< addresses to be ignored for
 							 * the contacts-cache */
 		OptSize		max_msg_size;		/**< max size for message files */
diff --git a/mu4e/mu4e-main.el b/mu4e/mu4e-main.el
index 803c269a8..8ba117901 100644
--- a/mu4e/mu4e-main.el
+++ b/mu4e/mu4e-main.el
@@ -354,7 +354,7 @@ Otherwise, do nothing."
             (mu4e-message (concat
                            "Tip: `user-mail-address' ('%s') is not part "
                            "of mu's addresses; add it with 'mu init
-                        --my-address='") user-mail-address)))
+                        --personal-address='") user-mail-address)))
         (goto-char pos)))))
 
 (defun mu4e--main-view-queue ()
diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index 9a05eb09c..43ee38ce7 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -395,18 +395,20 @@ following command:
 You can add some e-mail addresses, so @t{mu} recognizes them as yours:
 
 @example
-  $ mu init --maildir=~/Maildir --my-address=jim@@example.com \
-    --my-address=bob@@example.com
+  $ mu init --maildir=~/Maildir --personal-address=jim@@example.com \
+    --personal-address=bob@@example.com
 @end example
 
-@t{mu} remembers the maildir and your addresses and uses them when
-indexing messages. If you want to change them, you need to @t{init}
-once again.
+(An older synonym for @t{--personal-address} is @t{--my-address}, which is still
+supported).
+
+@t{mu} remembers the maildir and your addresses and uses them when indexing
+messages. If you want to change them, you need to @t{init} once again.
 
 The addresses may also be basic PCRE regular expressions, wrapped in slashes,
 for example:
 @example
-  $ mu init --maildir=~/Maildir '--my-address=/foo-.*@@example\.com/'
+  $ mu init --maildir=~/Maildir '--personal-address=/foo-.*@@example\.com/'
 @end example
 
 If you want to see the values for your message-store, you can use
@@ -1858,7 +1860,7 @@ only consider addresses that were seen in @emph{personal} messages ---
 that is, messages in which one of my e-mail addresses was seen in one
 of the address fields. This is to exclude mailing list posts. You can
 define what is considered `my e-mail address' using the
-@t{--my-address} parameter to @t{mu init}.
+@t{--personal-address} parameter to @t{mu init}.
 
 @item @code{mu4e-compose-complete-only-after} --- only consider e-mail
 addresses last seen after some date. Parameter is a string, parseable by
@@ -2009,7 +2011,7 @@ configuration:
 @item If you want to exclude your own e-mail addresses when ``replying to
 all'', set @code{message-dont-reply-to-names} to
 @code{mu4e-personal-or-alternative-address-p}. In order for this to work
-properly you need to pass your address to @command{mu init --my-address=} at
+properly you need to pass your address to @command{mu init --personal-address=} at
 database initialization time, and/or use @t{message-alternative-emails}.
 @end itemize
 

From 3e054523437a94adc4ba3966ff946134075080ef Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Thu, 22 May 2025 08:55:51 +0300
Subject: [PATCH 277/305] mu4e: headers/search refactor search a bit

Move some items from mu4e-headers (mu4e--search-execute) to mu4e-search. The
code in mu4e-headers should focus on the output, and mu4e-search on the search
itself.
---
 mu4e/mu4e-headers.el | 17 +++++------------
 mu4e/mu4e-search.el  | 14 ++++++++++----
 2 files changed, 15 insertions(+), 16 deletions(-)

diff --git a/mu4e/mu4e-headers.el b/mu4e/mu4e-headers.el
index bc63c85aa..dd5368bd1 100644
--- a/mu4e/mu4e-headers.el
+++ b/mu4e/mu4e-headers.el
@@ -800,15 +800,13 @@ present, don't do anything."
 If so, do not attempt to switch buffers. This variable is to be let-bound
 to t before \"automatic\" searches.")
 
-(defun mu4e--search-execute (expr ignore-history)
+(defun mu4e--search-execute (expr &optional _ignore-history)
   "Search for query EXPR.
 
-Switch to the output buffer for the results. If IGNORE-HISTORY is
-true, do *not* update the query history stack."
+Switch to the output buffer for the results."
   (let* ((buf (mu4e-get-headers-buffer nil t))
          (view-window mu4e~headers-view-win)
          (inhibit-read-only t)
-         (rewritten-expr (funcall mu4e-query-rewrite-function expr))
          (maxnum (unless mu4e-search-full mu4e-search-results-limit)))
     (with-current-buffer buf
       ;; NOTE: this resets all buffer-local variables, including
@@ -816,13 +814,8 @@ true, do *not* update the query history stack."
       ;; headers buffer already exists when `mu4e-get-headers-buffer'
       ;; is called.
       (mu4e-headers-mode)
-      (setq mu4e~headers-view-win view-window)
-      (unless ignore-history
-        ;; save the old present query to the history list
-        (when mu4e--search-last-query
-          (mu4e--search-push-query mu4e--search-last-query 'past)))
-      (setq mu4e--search-last-query rewritten-expr)
-      (setq list-buffers-directory rewritten-expr)
+      (setq mu4e~headers-view-win view-window
+            list-buffers-directory expr)
       (mu4e--modeline-update))
 
     ;; when the buffer is already visible, select it; otherwise,
@@ -833,7 +826,7 @@ true, do *not* update the query history stack."
     (mu4e~headers-clear mu4e~search-message)
     (setq mu4e~headers-search-start (float-time))
     (mu4e--server-find
-     rewritten-expr
+     expr
      mu4e-search-threads
      mu4e-search-sort-field
      mu4e-search-sort-direction
diff --git a/mu4e/mu4e-search.el b/mu4e/mu4e-search.el
index efcf68dae..0315ce899 100644
--- a/mu4e/mu4e-search.el
+++ b/mu4e/mu4e-search.el
@@ -202,13 +202,19 @@ with the favorite bookmark's query."
          (expr
           (if (or (null expr) edit)
               (mu4e-search-read-query prompt expr)
-            expr)))
+            expr))
+         (expr (if mu4e-query-rewrite-function ;; rewrite?
+                   (funcall mu4e-query-rewrite-function expr) expr)))
     (mu4e-mark-handle-when-leaving)
-    (mu4e--search-execute expr ignore-history)
+    ;; save the old present query to the history list?
+    (unless ignore-history
+      (when mu4e--search-last-query
+        (mu4e--search-push-query mu4e--search-last-query 'past)))
+    (mu4e--search-execute expr)
     (setq mu4e--search-msgid-target msgid
+          mu4e--search-last-query expr
           mu4e--search-view-target show)
-    (mu4e--search-maybe-reset-baseline expr)
-    (mu4e--modeline-update)))
+    (mu4e--search-maybe-reset-baseline expr)))
 
 (defun mu4e-search-edit ()
   "Edit the last search expression."

From ec3b55f2ab4e9997661fe774c459686394268f74 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 24 May 2025 16:05:05 +0300
Subject: [PATCH 278/305] message: retain non-file flags when moving

The content-flags won't change, and the unread-flag can be re-calculated.

Add a unit test, and some small doc improvements.

Fixes #2831.
---
 lib/message/mu-flags.hh   |  7 ++---
 lib/message/mu-message.cc |  8 +++++
 lib/message/mu-message.hh | 20 ++++++------
 lib/mu-store.hh           | 20 +++++++-----
 mu/mu-cmd-move.cc         | 65 +++++++++++++++++++++++++++++++++++++--
 5 files changed, 95 insertions(+), 25 deletions(-)

diff --git a/lib/message/mu-flags.hh b/lib/message/mu-flags.hh
index 8e424dd0f..ee01702c4 100644
--- a/lib/message/mu-flags.hh
+++ b/lib/message/mu-flags.hh
@@ -1,5 +1,5 @@
 /*
-** Copyright (C) 2022-2023 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2022-2025 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify it
 ** under the terms of the GNU General Public License as published by the
@@ -86,7 +86,7 @@ enum struct MessageFlagCategory {
 };
 
 /**
- * Info about invidual message flags
+ * Info about individual message flags
  *
  */
 struct MessageFlagInfo {
@@ -373,9 +373,6 @@ flags_maildir_file(Flags flags)
 	return flags;
 }
 
-
-
-
 /**
  * Return flags, where flags = new_flags but with unmutable_flag in the
  * result the same as in old_flags
diff --git a/lib/message/mu-message.cc b/lib/message/mu-message.cc
index 3d4d2df20..339abd14a 100644
--- a/lib/message/mu-message.cc
+++ b/lib/message/mu-message.cc
@@ -881,6 +881,14 @@ Message::update_after_move(const std::string& new_path,
 	priv_->doc.add(Field::Id::Path, new_path);
 	priv_->doc.add(Field::Id::Changed, priv_->ctime);
 
+	// note: content-flags are retained from the existing; the unread flag
+	// is implied. only file-flags are allowed for new_flags; anything else
+	// is filtered-out
+
+	new_flags = flags_maildir_file(new_flags);
+	new_flags |= flags_filter(flags(), MessageFlagCategory::Content);
+	new_flags = imply_unread(new_flags);
+
 	set_flags(new_flags);
 
 	if (const auto res = set_maildir(sanitize_maildir(new_maildir)); !res)
diff --git a/lib/message/mu-message.hh b/lib/message/mu-message.hh
index 9be909608..c6b69173d 100644
--- a/lib/message/mu-message.hh
+++ b/lib/message/mu-message.hh
@@ -1,5 +1,5 @@
 /*
-** Copyright (C) 2022-2024 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2022-2025 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify it
 ** under the terms of the GNU General Public License as published by the
@@ -292,11 +292,10 @@ public:
 	 */
 	Flags flags() const { return document().flags_value(); }
 
-
 	/**
-	 * Update the flags for this message. This is useful for flags
-	 * that can only be determined after the message has been created already,
-	 * such as the 'personal' flag.
+	 * Update the flags for this message. This is useful for flags that can
+	 * only be determined after the message has been created already, such
+	 * as the 'personal' flag.
 	 *
 	 * @param flags new flags.
 	 */
@@ -366,11 +365,14 @@ public:
 	 */
 	const Sexp& sexp() const;
 
-	/*
-	 * And some non-const message, for updating an existing
-	 * message after a file-system move.
+	/**
+	 * Update the message after a move
+	 *
+	 * @param new_path the new file-system path; non-file flags are ignored
+	 * @param new_maildir the new maildir
+	 * @param new_flags the new flags
 	 *
-	 * @return Ok or an error.
+	 * @return Ok() or some error.
 	 */
 	Result<void> update_after_move(const std::string& new_path,
 				       const std::string& new_maildir,
diff --git a/lib/mu-store.hh b/lib/mu-store.hh
index 24130de03..cc7946a5b 100644
--- a/lib/mu-store.hh
+++ b/lib/mu-store.hh
@@ -1,5 +1,5 @@
 /*
-** Copyright (C) 2024 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2017-2025 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify it
 ** under the terms of the GNU General Public License as published by the
@@ -306,20 +306,24 @@ public:
 	};
 
 	/**
-	 * Move a message both in the filesystem and in the store. After a successful move, the
-	 * message is updated.
+	 * Move a message both in the filesystem and in the store.
+	 *
+	 * After a successful move, the message is updated. A moved message gets
+	 * a new doc-id, since the message-path is a unique-id for the message
 	 *
 	 * @param id the id for some message
 	 * @param target_mdir the target maildir (if any)
 	 * @param new_flags new flags (if any)
 	 * @param opts move options
 	 *
-	 * @return Result, either an IdPathVec with ids and paths for the moved message(s) or some
-	 * error. Note that in case of success at least one message is returned, and only with
-	 * MoveOptions::DupFlags can it be more than one.
+	 * @return Result, either an IdPathVec with ids and paths for the moved
+	 * message(s) or some error. Note that in case of success at least one
+	 * message is returned, and only with MoveOptions::DupFlags can it be
+	 * more than one.
 	 *
-	 * The first element of the IdPathVec, is the main message that got move; any subsequent
-	 * (if any) are the duplicate paths, sorted by path-name.
+	 * The first element of the IdPathVec, is the main message that got
+	 * move; any subsequent (if any) are the duplicate paths, sorted by
+	 * path-name.
 	 */
 	Result<IdPathVec> move_message(Store::Id id,
 				       Option<const std::string&> target_mdir = Nothing,
diff --git a/mu/mu-cmd-move.cc b/mu/mu-cmd-move.cc
index 7ad7a483c..bdb398382 100644
--- a/mu/mu-cmd-move.cc
+++ b/mu/mu-cmd-move.cc
@@ -1,5 +1,5 @@
 /*
-** Copyright (C) 2023 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2023-2025 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify it
 ** under the terms of the GNU General Public License as published by the
@@ -28,7 +28,6 @@
 
 using namespace Mu;
 
-
 Result<void>
 Mu::mu_cmd_move(Mu::Store& store, const Options& opts)
 {
@@ -50,7 +49,6 @@ Mu::mu_cmd_move(Mu::Store& store, const Options& opts)
 			   "Must have at least one of destination and flags");
 	else if (!dest.empty()) {
 		const auto mdirs{store.maildirs()};
-
 		if (!seq_some(mdirs, [&](auto &&d){ return d == dest;}))
 			return Err(Error{Error::Code::InvalidArgument,
 					"No maildir '{}' in store", dest}
@@ -259,6 +257,65 @@ test_move_real()
 	}
 }
 
+
+static void
+test_move_retain_non_file_flags()
+{
+	g_test_bug("2831");
+
+	allow_warnings();
+
+	TempDir tdir;
+	const auto dbpath{runtime_path(RuntimePath::XapianDb, tdir.path())};
+
+	auto res = run_command0({CP_PROGRAM, "-r", MU_TESTMAILDIR, tdir.path()});
+	assert_valid_command(res);
+
+	const auto testpath{join_paths(tdir.path(), "testdir")};
+	const auto src{join_paths(testpath, "cur", "multimime!2,FS")};
+
+	Store::Id id{};
+	{
+		auto store = Store::make_new(dbpath, testpath, {});
+		assert_valid_result(store);
+		const auto idopt{store->add_message(src, true)};
+		g_assert_true(!!idopt);
+		id = *idopt;
+		const auto msg{store->find_message(id)};
+		g_assert_true(!!msg);
+		g_assert_true(msg->flags() == (Flags::Seen | Flags::Flagged | Flags::HasAttachment));
+	}
+
+	// make a message 'New'
+	const auto dst{join_paths(testpath, "new", "multimime")};
+	{
+		auto res = run_command0({MU_PROGRAM, "--debug", "move", "--muhome",
+				tdir.path(), src, "--flags", "N"});
+		assert_valid_command(res);
+		assert_equal(res->standard_out, dst + '\n');
+		// double-check it really moved.
+		g_assert_true(::access(dst.c_str(), F_OK) == 0);
+		g_assert_true(::access(src.c_str(), F_OK) != 0);
+	}
+
+	// re-open db
+	{
+		const auto store = Store::make(dbpath);
+		assert_valid_result(store);
+
+		const auto newid{store->find_message_id(dst)};
+		g_assert_true(!!newid);
+
+		const auto msg{store->find_message(*newid)};
+		g_assert_true(!!msg);
+
+		// check the old flags
+		const auto flags = msg->flags();
+		assert_equal(to_string(flags), to_string(Flags::New | Flags::Unread |
+							 Flags::HasAttachment));
+	}
+}
+
 int
 main(int argc, char* argv[])
 {
@@ -266,6 +323,8 @@ main(int argc, char* argv[])
 
 	g_test_add_func("/cmd/move/dry-run", test_move_dry_run);
 	g_test_add_func("/cmd/move/real", test_move_real);
+	g_test_add_func("/cmd/move/retain-non-file-flags",
+			test_move_retain_non_file_flags);
 
 	return g_test_run();
 

From 782e6cbe05f78ff95d86897b47aaec7a4f9fabaf Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 24 May 2025 17:18:54 +0300
Subject: [PATCH 279/305] mu4e.texi: mention keep-crlf

Add an entry to the FAQ for the keeping CRLF in
  mm-decode-content-transfer-encoding

Fixes #2849.
---
 mu4e/mu4e.texi | 49 ++++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 40 insertions(+), 9 deletions(-)

diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index 43ee38ce7..3014e3204 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -1558,9 +1558,13 @@ mu4e-view-show-mime-parts}. This can be a little slow.
 @cindex attachments
 @cindex mime-parts
 
-Typical e-mail messages can be thought of as a series of ``MIME-parts'', which
-are sections of the message. The most prominent of those parts is the 'body',
-which is the text of the message your are reading.
+Nowadays, typical e-mail messages can be thought of as a series of
+``MIME-parts'', which are sections of the message. The most prominent of those
+parts is the 'body', which is the main text of the message your are readings.
+
+Other MIME-parts in the messages include @emph{attachments}.
+
+@subsection Attachments
 
 Many e-mail messages also contain @emph{attachments}, which are MIME-parts that
 contain files@footnote{Attachments come in two flavors: @t{inline} and
@@ -1595,11 +1599,11 @@ which is requirement of the underlying completion mechanism works. If there are
 duplicates, only one is recognized.
 
 Furthermore, file names that match @code{crm-separator} (by default, commas) are
-not supported (see @t{completing-read-multiple} for further details). For such
-corner-cases, it is recommended to use @code{mu4e-view-mime-part-action}
+@emph{not} supported (see @t{completing-read-multiple} for further details). For
+such corner-cases, it is recommended to use @code{mu4e-view-mime-part-action}
 instead, which does not have this limitation.
 
-@subsection MIME-parts
+@subsection Other MIME-parts
 
 Not all MIME-parts are message bodies or attachments, and it can be useful to
 operate on those other parts as well.
@@ -4269,9 +4273,10 @@ Yes --- if you provide a prefix-argument (@key{C-u}), @t{mu4e} starts, but does
 not show the main-window.
 
 @subsection Does @t{mu4e} support searching for CJK (Chinese-Japanese-Korean) characters?
-Only partially. If you have @t{Xapian} 1.2.8 or newer, and set the environment
-variable @t{XAPIAN_CJK_NGRAM} to non-empty before indexing, both when using
-@t{mu} from the command-line and from @t{mu4e}.
+Yes. This is not enabled by default though, since this is fairly intrusive, and
+influences both indexing and querying. The enable this, pass
+@t{--support-ngrams} to @code{mu init}; see the @t{mu-init} manpage for further
+details.
 
 @subsection How can I customize the function to select a folder?
 The @t{mu4e-completing-read-function} variable can be customized to select a
@@ -4473,6 +4478,32 @@ your configuration (courtesy of user @t{kpachnis}):
       mml2015-sign-with-sender t)
 @end lisp
 
+
+@subsection Some plain-text attachments get corrupted, how can I avoid that?
+@t{mu4e} (or, more precisely, its Gnus helpers) automatically convert CR-LF
+(``Windows-style'') line-endings to Unix line endings for the text attachments.
+
+That is usually convenient, but can be problematic when attachments are
+mislabeled as text when they contain binary data: in that case, the conversion
+would result in invalid data.
+
+If you run into that problem, you can @t{advise} the responsible function:
+
+@lisp
+(defun mm-dcte-keep-crlf (args)
+  "Don't convert crlf->lf.
+Advise `mm-decode-content-transfer-encoding' to not perform the
+conversion."
+  (when (and (= (length args) 2)
+             (memq (nth 0 args) '(base64 x-uuencode x-uue x-binhex x-yenc))
+             (string-match "\\`text/" (nth 1 args)))
+    ;; fake the type, so no conversion happens
+    (setf (nth 1 args) "application/octet-stream"))
+  args)
+
+(advice-add 'mm-decode-content-transfer-encoding :filter-args #'mm-dcte-keep-crlf)
+@end lisp
+
 @node Writing messages
 @section Writing messages
 

From 452969355c19cfe5d90cee5d2507ed6d53b11a0c Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 24 May 2025 19:18:10 +0300
Subject: [PATCH 280/305] mu-test: add valgrind check

Make it a bit easier to skip some tests when running under valgrind.
---
 Makefile                   |  2 ++
 lib/utils/mu-test-utils.cc |  7 +++++++
 lib/utils/mu-test-utils.hh | 17 +++++++++++++++++
 3 files changed, 26 insertions(+)

diff --git a/Makefile b/Makefile
index c30a48e59..0a8c8cf00 100644
--- a/Makefile
+++ b/Makefile
@@ -93,6 +93,7 @@ $(BUILDDIR_VALGRIND):
 vg_opts:=--enable-debuginfod=no --leak-check=full --error-exitcode=1
 test-valgrind: export G_SLICE=always-malloc
 test-valgrind: export G_DEBUG=gc-friendly
+test-valgrind: export MU_VALGRIND=memcheck
 test-valgrind: build-valgrind
 	@$(MESON) test -C $(BUILDDIR_VALGRIND)			\
 		--wrap="$(VALGRIND) $(vg_opts)"			\
@@ -102,6 +103,7 @@ check-valgrind: test-valgrind
 
 # we do _not_ pass helgrind; but this seems to be a false-alarm
 #    https://gitlab.gnome.org/GNOME/glib/-/issues/2662
+test-helgrind: export MU_VALGRIND=helgrind
 test-helgrind: $(BUILDDIR_VALGRIND)
 	$(MESON) -C $(BUILDDIR_VALGRIND) test	\
 	--wrap="$(VALGRIND) --tool=helgrind --error-exitcode=1"	\
diff --git a/lib/utils/mu-test-utils.cc b/lib/utils/mu-test-utils.cc
index 0d4a149b5..0a2585926 100644
--- a/lib/utils/mu-test-utils.cc
+++ b/lib/utils/mu-test-utils.cc
@@ -42,6 +42,13 @@ Mu::mu_test_mu_hacker()
 {
 	return !!g_getenv("MU_HACKER");
 }
+
+bool
+Mu::mu_test_mu_valgrind()
+{
+	return !!g_getenv("MU_VALGRIND");
+}
+
 /* LCOV_EXCL_STOP*/
 
 
diff --git a/lib/utils/mu-test-utils.hh b/lib/utils/mu-test-utils.hh
index 051230add..f6f5e78b8 100644
--- a/lib/utils/mu-test-utils.hh
+++ b/lib/utils/mu-test-utils.hh
@@ -43,6 +43,23 @@ void mu_test_init(int *argc, char ***argv);
  */
 bool mu_test_mu_hacker();
 
+/**
+ * Are we running under Valgrind?
+ *
+ * @return true or false
+ */
+bool mu_test_mu_valgrind();
+
+/**
+ * Skip test when running under valgrind
+ */
+#define mu_test_skip_valgrind_return() do {				\
+		if (mu_test_mu_valgrind()) {				\
+			g_test_skip("skip (valgrind not supported)");	\
+			return;						\
+		}							\
+	} while(0)
+
 /**
  * set the timezone
  *

From e367f5b0d1930403cf894aa2dcb3af1e3f965779 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 24 May 2025 19:18:52 +0300
Subject: [PATCH 281/305] mu-scanner: improve ignore_dentry check

---
 lib/mu-scanner.cc | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/lib/mu-scanner.cc b/lib/mu-scanner.cc
index 7da9373fa..b49d8c2ff 100644
--- a/lib/mu-scanner.cc
+++ b/lib/mu-scanner.cc
@@ -100,10 +100,15 @@ ignore_dentry(const dentry_t& dentry)
 
 	/* ignore '.' and '..' and anything starting with '#' (emacs
 	 * auto-saves) */
-	if (d_name[0] == '\0' || d_name[0] == '#' ||
-	    (d_name[1] == '\0' && d_name[0] == '.') ||
-	    (d_name[2] == '\0' && d_name[0] == '.' && d_name[1] == '.'))
+	if (d_name[0] == '\0' || d_name[0] == '#')
 		return true;
+	else if (d_name[1] == '\0') {
+		if (d_name[0] == '.')
+			return true;
+	} else if (d_name[2] == '\0') {
+		if (d_name[0] == '.' && d_name[1] == '.')
+			return true;
+	}
 
 	switch (d_name[0]) {
 	case 't':

From cc1112d34285946076ebbe2ecbb8263c7546c459 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 24 May 2025 21:04:49 +0300
Subject: [PATCH 282/305] tests: skip some slow tests when valgrinding

---
 lib/mu-indexer.cc          | 4 ++++
 lib/tests/test-mu-store.cc | 5 ++++-
 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/lib/mu-indexer.cc b/lib/mu-indexer.cc
index 482812d92..be956ad73 100644
--- a/lib/mu-indexer.cc
+++ b/lib/mu-indexer.cc
@@ -489,6 +489,8 @@ test_index_basic()
 	g_assert_cmpuint(prog.updated,==, 0);
 	g_assert_cmpuint(prog.removed,==, 0);
 
+	mu_test_skip_valgrind_return();
+
 	Indexer::Config conf{};
 	conf.ignore_noupdate = true;
 
@@ -540,6 +542,8 @@ test_index_lazy()
 {
 	allow_warnings();
 
+	mu_test_skip_valgrind_return();
+
 	TempDir tdir;
 	auto store = Store::make_new(tdir.path(), MU_TESTMAILDIR2);
 	assert_valid_result(store);
diff --git a/lib/tests/test-mu-store.cc b/lib/tests/test-mu-store.cc
index ebc948e6d..c9b801398 100644
--- a/lib/tests/test-mu-store.cc
+++ b/lib/tests/test-mu-store.cc
@@ -492,13 +492,15 @@ Yes, that would be excellent.
 }
 
 static void
-test_store_circular_symlink(void)
+test_store_circular_symlink()
 {
 	allow_warnings();
 
 	g_test_bug("2517");
 	g_test_bug("2832");
 
+	mu_test_skip_valgrind_return();
+
 	auto testhome{unwrap(make_temp_dir())};
 	auto dbpath{runtime_path(RuntimePath::XapianDb, testhome)};
 
@@ -513,6 +515,7 @@ test_store_circular_symlink(void)
 	auto&& store = unwrap(Store::make_new(dbpath, testmdir));
 	store.indexer().start({});
 	size_t n{};
+
 	while (store.indexer().is_running()) {
 		std::this_thread::sleep_for(100ms);
 		// 5 sec should be enough, even on the slowest supported systems..

From 9f08397fddc546fbc41d0d4d33d8065c96bbf5d2 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 25 May 2025 08:39:46 +0300
Subject: [PATCH 283/305] NEWS.org: update

---
 NEWS.org | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/NEWS.org b/NEWS.org
index e25bec868..a5f9fa3dc 100644
--- a/NEWS.org
+++ b/NEWS.org
@@ -3,10 +3,10 @@
 
 * 1.12 (released on February 24, 2024)
 
-  The 1.12 series has been stable for a fairly long time, and gained some
-  changes in mean-time. Most of the changes are for bug fixes and documentation
-  improvements, but new features are available as well. Those are listed below
-  the 1.12 changes, prefixed by the version in which they appeared.
+  The 1.12 series has been "stable" for a fairly long time, and gained some
+  changes in the mean-time. Most of the changes are for bug fixes and
+  documentation improvements, but some new features are available as well. Those
+  are listed below, with the version in which they first appeared.
 
   We decided to put off a new development series (1.13 -> 1.14) until
   incompatible changes are required; for now working in the 1.12 series seems a
@@ -23,8 +23,7 @@
   - Better and faster indexing of HTML messages
   - Experimental search by (human) language wit CLD2
 
-  For details & more, see below. Note that a few minor new features were added
-  _after_ the initial 1.12.0.
+  For details & more, see below.
 
 *** mu
 
@@ -123,6 +122,11 @@
 
     - 1.12.9: the cleanup phase after indexing is significantly faster now
 
+    - 1.12.12: the ~--my-address~ parameter to ~--mu-init~ has been renamed into
+      ~--personal-address~, for consistency with the other places where we refer
+      to it as a personal address. ~--my-address~ is still supported as an alias,
+      for backward compatibility.
+
 *** mu4e
 
 **** message composer
@@ -277,7 +281,6 @@
    - 1.12.12: it now possible to create Emacs bookmarks for both messages
      (default) and queries. See the new variable ~mu4e-emacs-bookmark-policy~.
 
-
 *** Contributors
 
     Thanks to our contributors - code committers belows, but also to everyone

From 88ce65df40b39f82dedfeca4faa26d20f7713258 Mon Sep 17 00:00:00 2001
From: Sergey Trofimov <sarg@sarg.org.ru>
Date: Sun, 25 May 2025 09:59:11 +0200
Subject: [PATCH 284/305] mu4e-notification: ignore dbus errors

notifications protocol says that an empty dbus error message is sent
back when the notification to close no longer exists:
https://specifications.freedesktop.org/notification-spec/latest/protocol.html#command-close-notification

Some notification daemons don't signal errors, but others do (e.g.
EDNC). Adjust the code to be conformant to the spec.
---
 mu4e/mu4e-notification.el | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/mu4e/mu4e-notification.el b/mu4e/mu4e-notification.el
index bb68b5b14..3d76b1a3a 100644
--- a/mu4e/mu4e-notification.el
+++ b/mu4e/mu4e-notification.el
@@ -73,9 +73,11 @@ zero."
   (when-let* ((fav (mu4e-bookmark-favorite))
               (delta-unread (plist-get fav :delta-unread)))
     (when (and (fboundp 'notifications-close-notification)
+               (fboundp 'dbus-ignore-errors)
                mu4e--notification-id
                (zerop delta-unread))
-      (notifications-close-notification mu4e--notification-id)
+      (dbus-ignore-errors
+        (notifications-close-notification mu4e--notification-id))
       (setq mu4e--notification-id nil))
     (when (and (> delta-unread 0)
                (not (= delta-unread mu4e--last-delta-unread)))

From 668d5ffb99899b2b0c0e30f6a1b5772b4137bd94 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 25 May 2025 11:20:52 +0300
Subject: [PATCH 285/305] contacts/contacts-cache: cleanups

refactor code a bit; move sorting to Contact

remove unneeded hashing in Contact (just use the email address)
---
 lib/message/mu-contact.cc     |  10 ---
 lib/message/mu-contact.hh     | 153 ++++++++++++++++++++--------------
 lib/message/mu-mime-object.cc |   7 +-
 lib/mu-contacts-cache.cc      |  67 +++------------
 4 files changed, 105 insertions(+), 132 deletions(-)

diff --git a/lib/message/mu-contact.cc b/lib/message/mu-contact.cc
index c6439b066..22795db87 100644
--- a/lib/message/mu-contact.cc
+++ b/lib/message/mu-contact.cc
@@ -61,16 +61,6 @@ Mu::to_string(const Mu::Contacts& contacts)
 	return res;
 }
 
-size_t
-Mu::lowercase_hash(const std::string& s)
-{
-	std::size_t djb = 5381; // djb hash
-	for (const auto c : s)
-		djb = ((djb << 5) + djb) +
-			static_cast<size_t>(g_ascii_tolower(c));
-	return djb;
-}
-
 #ifdef BUILD_TESTS
 /*
  * Tests.
diff --git a/lib/message/mu-contact.hh b/lib/message/mu-contact.hh
index d417d4ec0..90052938e 100644
--- a/lib/message/mu-contact.hh
+++ b/lib/message/mu-contact.hh
@@ -1,5 +1,5 @@
 /*
-** Copyright (C) 2022 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2022-2025 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify it
 ** under the terms of the GNU General Public License as published by the
@@ -32,101 +32,118 @@
 #include <utils/mu-option.hh>
 #include "mu-fields.hh"
 
-struct _InternetAddressList;
-
 namespace Mu {
-
-/**
- * Get the hash value for a lowercase value of s; useful for email-addresses
- *
- * @param s a string
- *
- * @return a hash value.
- */
-size_t lowercase_hash(const std::string& s);
-
 struct Contact {
-	enum struct Type {
-		None, Sender, From, ReplyTo, To, Cc, Bcc
+	enum struct Type:char {
+		None='\0', Sender='s', From='f',
+		ReplyTo='r', To='t', Cc='c', Bcc='b'
 	};
 
 	/**
 	 * Construct a new Contact
 	 *
-	 * @param email_ email address
-	 * @param name_ name or empty
-	 * @param type_ contact field type
-	 * @param message_date_ data for the message for this contact
+	 * @param email email address
+	 * @param name name or empty
+	 * @param type contact field type
+	 * @param message_date data for the message for this contact
 	 */
-	Contact(const std::string& email_, const std::string& name_ = "",
-		Type type_ = Type::None, ::time_t message_date_ = 0)
-		: email{email_}, name{name_}, type{type_},
-		  message_date{message_date_}, personal{}, frequency{1}, tstamp{}
+	Contact(const std::string& email, const std::string& name = {},
+		Type type = {}, int64_t message_date ={})
+		: email{email}, name{name}, type{type},
+		  message_date{message_date}, personal{}, frequency{1}, tstamp{}
 		{ cleanup_name(); }
 
 	/**
 	 * Construct a new Contact
 	 *
-	 * @param email_ email address
-	 * @param name_ name or empty
-	 * @param message_date_ date of message this contact originate from
-	 * @param personal_ is this a personal contact?
-	 * @param freq_ how often was this contact seen?
-	 * @param tstamp_ timestamp for last change
+	 * @param email email address
+	 * @param name name or empty
+	 * @param message_date date of message this contact originate from
+	 * @param personal is this a personal contact?
+	 * @param freq how often was this contact seen?
+	 * @param tstamp timestamp for last change
 	 */
-	Contact(const std::string& email_, const std::string& name_,
-		       time_t message_date_, bool personal_, size_t freq_,
-		       int64_t tstamp_)
-	    : email{email_}, name{name_}, type{Type::None},
-	      message_date{message_date_}, personal{personal_}, frequency{freq_},
-	      tstamp{tstamp_}
-	{ cleanup_name();}
+	Contact(const std::string& email, const std::string& name,
+		int64_t message_date, bool personal, size_t freq,
+		int64_t tstamp)
+	    : email{email}, name{name}, type{},
+	      message_date{message_date}, personal{personal}, frequency{freq},
+	      tstamp{tstamp}
+	{ cleanup_name(); }
 
 	/**
 	 * Get the "display name" for this contact:
 	 *
-	 * If there's a non-empty name, it's Jane Doe <email@example.com>
-	 * otherwise it's just the e-mail address. Names with commas are quoted
+	 * If there is a non-empty name, it is of the form
+	 *   Jane Doe <email@example.com>
+	 * Otherwise it is just the e-mail address. Names with commas are quoted
 	 * (with the quotes escaped).
 	 *
 	 * @return the display name
 	 */
 	std::string display_name() const;
 
-
 	/**
 	 * Does the contact contain a valid email address as per
 	 *   https://html.spec.whatwg.org/multipage/input.html#valid-e-mail-address
 	 * ?
-	 *
 	 * @return true or false
 	 */
 	bool has_valid_email() const;
 
 	/**
-	 * Operator==; based on the hash values (ie. lowercase e-mail address)
+	 * Operator==; based on the e-mail address only
 	 *
 	 * @param rhs some other Contact
 	 *
-	 * @return true orf false.
+	 * @return true or false.
 	 */
 	bool operator== (const Contact& rhs) const noexcept {
-		return hash() == rhs.hash();
+		return email == rhs.email;
+	}
+	/**
+	 * Operator!=
+	 *
+	 * @param rhs some other Contact
+	 *
+	 * @return true or false.
+	 */
+	bool operator!= (const Contact& rhs) const noexcept {
+		return !(*this == rhs);
 	}
 
+	static constexpr int64_t RecentOffset{15 * 24 * 3600};
+	/**< Contacts seen after now - RecentOffset seconds are considered
+	 * "recent" */
+
 	/**
-	 * Get a hash-value for this contact, which gets lazily calculated. This
-	 * * is for use with container classes. This uses the _lowercase_ email
-	 * address.
+	 * operator<
+	 *
+	 * Less "relevant" contacts are smaller than more relevant.
+	 *
+	 * Used as a somewhat over-engineered way to sort by relevance
+	 *
+	 * This is currently used for the ordering in mu-cfind and
+	 * auto-completion in mu4e, if the various completion methods don't
+	 * override it...
 	 *
-	 * @return the hash
+	 * @param rhs some other contact
+	 *
+	 * @return true of false
 	 */
-	size_t hash() const {
-		static size_t cached_hash;
-		if (cached_hash == 0) {
-			cached_hash = lowercase_hash(email);
-		}
-		return  cached_hash;
+	bool operator<(const Contact& rhs) const noexcept {
+		// non-personal is less relevant.
+		if (personal != rhs.personal)
+			return personal < rhs.personal;
+		// older is less relevant for recent messages
+		if (message_date != rhs.message_date &&
+		    (message_date > recently() || rhs.message_date > recently()))
+		    return message_date < rhs.message_date;
+		// less frequent is less relevant
+		if (frequency != rhs.frequency)
+			return frequency < rhs.frequency;
+		// if all else fails, alphabetically
+		return email < rhs.email;
 	}
 
 	/**
@@ -153,18 +170,16 @@ struct Contact {
 #pragma GCC diagnostic pop
 	}
 
-
 	/*
 	 * data members
 	 */
-
-	std::string	email;		/**< Email address for this contact.Not empty */
-	std::string	name;		/**< Name for this contact; can be empty. */
-	Type		type;		/**< Type of contact */
-	int64_t		message_date;	/**< Date of the contact's message */
-	bool		personal;	/**<  A personal message? */
-	size_t		frequency;	/**< Frequency of this contact */
-	int64_t		tstamp;		/**< Timestamp for this contact (internal use) */
+	std::string	email{};	/**< Email address for this contact.Not empty */
+	std::string	name{};		 /**< Name for this contact; can be empty. */
+	Type		type{Type::None};/**< Type of contact */
+	int64_t		message_date{}; /**< Date of the contact's message */
+	bool		personal{};	/**<  A personal message? */
+	size_t		frequency{};	/**< Frequency of this contact */
+	int64_t		tstamp{};	/**< Timestamp for this contact (internal use) */
 
 private:
 	void cleanup_name() { // replace control characters by spaces.
@@ -172,6 +187,18 @@ private:
 			if (iscntrl(c))
 				c = ' ';
 	}
+
+	/**
+	 * Oldest timestamp considered "recent"
+	 *
+	 * This is arbitrary of course
+	 *
+	 * @return timestamp
+	 */
+	static int64_t recently() {
+		static const auto recent{::time({}) - RecentOffset};
+		return recent;
+	}
 };
 
 constexpr Option<Contact::Type>
@@ -212,7 +239,7 @@ std::string to_string(const Contacts& contacts);
  */
 template<> struct std::hash<Mu::Contact> {
 	std::size_t operator()(const Mu::Contact& c) const noexcept {
-		return c.hash();
+		return std::hash<std::string>{}(c.email);
 	}
 };
 
diff --git a/lib/message/mu-mime-object.cc b/lib/message/mu-mime-object.cc
index 37b9020c2..c835e1ee5 100644
--- a/lib/message/mu-mime-object.cc
+++ b/lib/message/mu-mime-object.cc
@@ -323,8 +323,7 @@ MimeMessage::make_from_text(const std::string& text)
 Option<int64_t>
 MimeMessage::date() const noexcept
 {
-	GDateTime *dt{g_mime_message_get_date(self())};
-	if (!dt)
+	if (/*const*/GDateTime *dt{g_mime_message_get_date(self())}; !dt)
 		return Nothing;
 	else
 		return g_date_time_to_unix(dt);
@@ -395,12 +394,10 @@ MimeMessage::contacts(Contact::Type ctype) const noexcept
 	contacts.reserve(lst_len);
 	for (auto i = 0; i != lst_len; ++i) {
 
-		auto&& addr{internet_address_list_get_address(addrs, i)};
+		const auto addr{internet_address_list_get_address(addrs, i)};
 		const auto name{internet_address_get_name(addr)};
-
 		if (G_UNLIKELY(!INTERNET_ADDRESS_IS_MAILBOX(addr)))
 			continue;
-
 		const auto email{internet_address_mailbox_get_addr (
 				INTERNET_ADDRESS_MAILBOX(addr))};
 		if (G_UNLIKELY(!email))
diff --git a/lib/mu-contacts-cache.cc b/lib/mu-contacts-cache.cc
index eaa5b1faf..017af2074 100644
--- a/lib/mu-contacts-cache.cc
+++ b/lib/mu-contacts-cache.cc
@@ -1,5 +1,5 @@
 /*
-** Copyright (C) 2019-2024 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2019-2025 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify it
 ** under the terms of the GNU General Public License as published by the
@@ -33,18 +33,7 @@
 
 using namespace Mu;
 
-struct EmailHash {
-	std::size_t operator()(const std::string& email) const {
-		return lowercase_hash(email);
-	}
-};
-struct EmailEqual {
-	bool operator()(const std::string& email1, const std::string& email2) const {
-		return lowercase_hash(email1) == lowercase_hash(email2);
-	}
-};
-
-using ContactUMap = std::unordered_map<const std::string, Contact, EmailHash, EmailEqual>;
+using ContactUMap = std::unordered_map<std::string, Contact>;
 struct ContactsCache::Private {
 	Private(Config& config_db)
 		:config_db_{config_db},
@@ -137,7 +126,7 @@ ContactsCache::Private::deserialize(const std::string& serialized) const
 		}
 		Contact ci(parts[0],                                                  // email
 			   std::move(parts[1]),                                       // name
-			   (time_t)g_ascii_strtoll(parts[3].c_str(), NULL, 10),       // message_date
+			   static_cast<int64_t>(g_ascii_strtoll(parts[3].c_str(), NULL, 10)),       // message_date
 			   parts[2][0] == '1' ? true : false,                         // personal
 			   (std::size_t)g_ascii_strtoll(parts[4].c_str(), NULL, 10),  // frequency
 			   g_get_monotonic_time());                                   // tstamp
@@ -147,7 +136,6 @@ ContactsCache::Private::deserialize(const std::string& serialized) const
 	return contacts;
 }
 
-
 void
 ContactsCache::Private::serialize() const
 {
@@ -287,41 +275,15 @@ ContactsCache::size() const
 
 
 /**
- * This is used for sorting the Contacts in order of relevance. A highly
- * specific algorithm, but the details don't matter _too_ much.
- *
- * This is currently used for the ordering in mu-cfind and auto-completion in
- * mu4e, if the various completion methods don't override it...
+* Wrapper to allow for Contact sorting
+* (needed due to reference_wrapper)
  */
-constexpr auto RecentOffset{15 * 24 * 3600};
 struct ContactLessThan {
-	ContactLessThan()
-	    : recently_{::time({}) - RecentOffset} {}
-
-	bool operator()(const Mu::Contact& ci1, const Mu::Contact& ci2) const {
-		// non-personal is less relevant.
-		if (ci1.personal != ci2.personal)
-			return ci1.personal < ci2.personal;
-
-		// older is less relevant for recent messages
-		if (std::max(ci1.message_date, ci2.message_date) > recently_ &&
-		    ci1.message_date != ci2.message_date)
-			return ci1.message_date < ci2.message_date;
-
-		// less frequent is less relevant
-		if (ci1.frequency != ci2.frequency)
-			return ci1.frequency < ci2.frequency;
-
-		// if all else fails, alphabetically
-		return ci1.email < ci2.email;
+	bool operator()(const Mu::Contact& c1, const Mu::Contact& c2) const {
+		return c1 < c2;
 	}
-	// only sort recently seen contacts by recency; approx 15 days.
-	// this changes during the lifetime, but that's all fine.
-	const time_t recently_;
 };
-
-using ContactSet = std::set<std::reference_wrapper<const Contact>,
-			    ContactLessThan>;
+using ContactSet = std::set<std::reference_wrapper<const Contact>, ContactLessThan>;
 
 void
 ContactsCache::for_each(const EachContactFunc& each_contact) const
@@ -382,6 +344,8 @@ ContactsCache::is_valid(const std::string& addr) const
 
 #include "utils/mu-test-utils.hh"
 
+constexpr auto RecentOffset = Contact::RecentOffset;
+
 static void
 test_mu_contacts_cache_base()
 {
@@ -406,10 +370,8 @@ test_mu_contacts_cache_base()
 	    Mu::Contact("foo.bar@example.com", "Foo", {}, 77777));
 	g_assert_cmpuint(contacts.size(), ==, 2);
 
-	contacts.add(
-	    Mu::Contact("Foo.Bar@Example.Com", "Foo", {}, 88888));
-	g_assert_cmpuint(contacts.size(), ==, 2);
-	// note: replaces first.
+	contacts.add(Mu::Contact("Foo.Bar@Example.Com", "Foo", {}, 88888));
+	g_assert_cmpuint(contacts.size(), ==, 3);
 
 	{
 		const auto info = contacts._find("bla@example.com");
@@ -417,9 +379,8 @@ test_mu_contacts_cache_base()
 	}
 
 	{
-		const auto info = contacts._find("foo.BAR@example.com");
+		const auto info = contacts._find("Foo.Bar@Example.Com");
 		g_assert_true(info);
-
 		g_assert_cmpstr(info->email.c_str(), ==, "Foo.Bar@Example.Com");
 	}
 
@@ -515,8 +476,6 @@ test_mu_contacts_cache_foreach()
 	}
 }
 
-
-
 static void
 test_mu_contacts_cache_sort()
 {

From 9496d6523d7cc38973457eba0f36439006bd3401 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 25 May 2025 16:16:57 +0300
Subject: [PATCH 286/305] lib: improve xapianizer / xapian_term

---
 lib/message/mu-fields.cc   | 10 ++++------
 lib/mu-query-xapianizer.cc | 11 ++++++-----
 2 files changed, 10 insertions(+), 11 deletions(-)

diff --git a/lib/message/mu-fields.cc b/lib/message/mu-fields.cc
index 040e68c88..7f53b6a75 100644
--- a/lib/message/mu-fields.cc
+++ b/lib/message/mu-fields.cc
@@ -79,17 +79,15 @@ Mu::field_is_combi(const std::string& name)
 std::string
 Field::xapian_term(const std::string& s) const
 {
-	const auto start{std::string(1U, xapian_prefix())};
-	if (const auto& size = s.size(); size == 0)
-		return start;
+	auto res{std::string(1U, xapian_prefix())};
+	if (s.empty())
+		return res;
 
-	std::string res{start};
 	res.reserve(s.size() + 10);
-
 	/* slightly optimized common pure-ascii. */
 	if (G_LIKELY(g_str_is_ascii(s.c_str()))) {
 		res += s;
-		for (auto i = 1; res[i]; ++i)
+		for (auto i = 1U; i != res.length(); ++i)
 			res[i] = g_ascii_tolower(res[i]);
 	} else
 		res += utf8_flatten(s);
diff --git a/lib/mu-query-xapianizer.cc b/lib/mu-query-xapianizer.cc
index 11aeee0e6..d18b6122d 100644
--- a/lib/mu-query-xapianizer.cc
+++ b/lib/mu-query-xapianizer.cc
@@ -109,17 +109,18 @@ phrase(const Field& field, Sexp&& s)
 static Result<Xapian::Query>
 regex(const Store& store, const Field& field, const std::string& rx_str)
 {
-	auto&& str{utf8_flatten(rx_str)};
-	auto&& rx{Regex::make(str, G_REGEX_OPTIMIZE)};
+	const auto str{utf8_flatten(rx_str)};
+	const auto rx{Regex::make(str, G_REGEX_OPTIMIZE)};
 	if (!rx) {
 		mu_warning("invalid regexp: '{}': {}", str, rx.error().what());
 		return Xapian::Query::MatchNothing;
 	}
 
 	std::vector<Xapian::Query> rxvec;
-	store.for_each_term(field.id, [&](auto&& str) {
-		if (auto&& val{str.data() + 1}; rx->matches(val))
-			rxvec.emplace_back(field.xapian_term(std::string_view{val}));
+	store.for_each_term(field.id, [&](const auto& term) {
+		std::string val{term.data() + 1};
+		if (rx->matches(val))
+			rxvec.emplace_back(field.xapian_term(val));
 		return true;
 	});
 

From cc10fbd22afe3212ae2f63ff80bbb1043ba4b518 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 31 May 2025 08:40:53 +0300
Subject: [PATCH 287/305] man: update mu-index manpage

Make it a bit more explicit what we ignore.
---
 man/mu-index.1.org | 53 +++++++++++++++++++++++-----------------------
 1 file changed, 27 insertions(+), 26 deletions(-)

diff --git a/man/mu-index.1.org b/man/mu-index.1.org
index af49eb023..57209220a 100644
--- a/man/mu-index.1.org
+++ b/man/mu-index.1.org
@@ -12,56 +12,57 @@ mu-index - index e-mail messages stored in Maildirs
 
 * DESCRIPTION
 
-*mu index* is the *mu* command for scanning the contents of Maildir directories and
+*mu index* is the *mu* command for scanning the messages in Maildir directories and
 storing the results in a Xapian database. The data can then be queried using
 {{{man-link(mu-find,1)}}}.
 
-Before the first time you run *mu index*, you must run *mu init* to initialize the
-database.
+Before you can run *mu index*, you must initialize *mu* and its database with
+{{{man-link(mu-init,1)}}}.
 
-*index* understands Maildirs as defined by Daniel Bernstein for
+*mu index* understands Maildirs as defined by Daniel Bernstein for
 {{{man-link(qmail,7)}}}. In addition, it understands recursive Maildirs
 (Maildirs within Maildirs), Maildir++. It also supports VFAT-based Maildirs
-which use *!* or *;* as the separators instead of *:*.
+which use "*!"* or "*;"* as the separators, instead of the standard "*:"*.
 
-E-mail messages which are not stored in something resembling a maildir
-leaf-directory (_cur_ and _new_) are ignored, as are the cache directories for
-_notmuch_ and _gnus_, and any dot-directory.
+E-mail messages are only considered for indexing if they reside in a directory
+named either ~cur~ or ~new~. The special (as per the Maildir-specification)
+directory ~tmp~ is ignored, as are some cache directories for some other
+mail-clients. Other directories are scanned recursively.
 
-Symlinks are followed, and the directories can be spread over multiple
-filesystems; however note that moving files around is much faster when multiple
-filesystems are not involved. Be careful to avoid self-referential symlinks!
+Symbolic links are followed, and the directories can be spread over multiple
+filesystems; however, note that moving files around is much faster when they all
+reside on a single file-system. Be careful to avoid self-referential symlinks!
 
-If there is a file called _.noindex_ in a directory, the contents of that
+If there is a file called ~.noindex~ in a directory, the contents of that
 directory and all of its subdirectories will be ignored. This can be useful to
 exclude certain directories from the indexing process, for example directories
 with spam-messages.
 
-If there is a file called _.noupdate_ in a directory, the contents of that
+If there is a file called ~.noupdate~ in a directory, the contents of that
 directory and all of its subdirectories will be ignored. This can be useful to
 speed up things you have some maildirs that never change.
 
-_.noupdate_ does not affect already-indexed messages: you can still search for
-them. _.noupdate_ is ignored when you start indexing with an empty database (such
+~.noupdate~ does not affect already-indexed messages: you can still search for
+them. ~.noupdate~ is ignored when you start indexing with an empty database (such
 as directly after *mu init*).
 
 There also the option *--lazy-check* which can greatly speed up indexing; see
 below for details.
 
-The first run of *mu index* may take a few minutes if you have a lot of mail (tens
-of thousands of messages). Fortunately, such a full scan needs to be done only
-once; after that it suffices to index the changes, which goes much faster. See
-the `PERFORMANCE (i,ii,iii)' below for more information.
+A first run of *mu index* may take a few minutes if you have a lot of mail (tens
+or hundreds of thousands of messages). Fortunately, such a full scan needs to be
+done only rarely; after that, it suffices to index just the changes, which goes
+much faster. See *PERFORMANCE (i,ii,iii)* below for more information.
 
-The optional `phase two' of the indexing-process is the removal of messages from
-the database for which there is no longer a corresponding file in the Maildir.
-If you do not want this, you can use *-n*, *--nocleanup*.
+The optional cleanup-phase of the indexing-process is the removal of messages
+from the database for which there is no longer a corresponding file in the
+Maildir. If you do not want this, you can use *-n*, *--nocleanup*.
 
 When *mu index* catches one of the signals *SIGINT*, *SIGHUP* or *SIGTERM* (e.g., when
 you press *Ctrl-C* during the indexing process), it attempts to shutdown
-gracefully; it tries to save and commit data, and close the database etc. If it
-receives another signal (e.g., when pressing Ctrl-C once more), *mu index* will
-terminate immediately.
+gracefully: save and commit data and close the database etc. If it receives
+another signal (e.g., when pressing Ctrl-C once more), *mu index* will terminate
+immediately.
 
 * INDEX OPTIONS
 
@@ -210,7 +211,7 @@ Indexing the the same 93000-message mail corpus with the last few releases:
 Quite some variation!
 
 Over time new features / refactoring can change the timings quite a bit. At
-least for now, the latest code is both the fastest and the most featureful!
+least for now, the latest code is both the fastest and the most feature-rich.
 
 #+include: "exit-code.inc" :minlevel 1
 

From f6235e95b903e17cfeb770b2af9cfb28bbce686b Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 31 May 2025 08:41:31 +0300
Subject: [PATCH 288/305] Makefile: turn off asan in when testing

It doesn't like Guile.
---
 Makefile | 1 -
 1 file changed, 1 deletion(-)

diff --git a/Makefile b/Makefile
index 0a8c8cf00..8ec2377af 100644
--- a/Makefile
+++ b/Makefile
@@ -39,7 +39,6 @@ endif
 # for the better error messages (esp. for fmt).
 ifneq (${MU_HACKER},)
 MESON_FLAGS:=$(MESON_FLAGS) '-Dbuildtype=debug'    \
-			    '-Db_sanitize=address' \
 			    '-Dreadline=enabled'   \
 			    '-Dcpp_std=c++23'
 endif

From c9b5755d682442bef93fc791f77a00b30173138a Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 31 May 2025 08:42:51 +0300
Subject: [PATCH 289/305] mu-cmd: update docstrings

---
 mu/mu-cmd.hh | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/mu/mu-cmd.hh b/mu/mu-cmd.hh
index 7b591f8fc..9b8740ecb 100644
--- a/mu/mu-cmd.hh
+++ b/mu/mu-cmd.hh
@@ -1,5 +1,5 @@
 /*
-** Copyright (C) 2008-2022-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2008-2025 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify it
 ** under the terms of the GNU General Public License as published by the
@@ -28,7 +28,6 @@
 
 namespace Mu {
 
-
 /**
  * Get message options from (sub)command options
  *
@@ -129,6 +128,7 @@ Result<void> mu_cmd_mkdir(const Options& opts);
 /**
  * execute the 'move' command
  *
+ * @param store message store object.
  * @param opts configuration options
  *
  * @return Ok() or some error
@@ -149,17 +149,14 @@ Result<void> mu_cmd_remove(Store& store, const Options& opt);
  * execute the 'script' command
  *
  * @param opts configuration options
- * @param err receives error information, or NULL
  *
  * @return Ok() or some error
  */
 Result<void> mu_cmd_script(const Options& opts);
 
-
 /**
  * execute the server command
  * @param opts configuration options
- * @param err receives error information, or NULL
  *
  * @return Ok() or some error
  */
@@ -187,7 +184,6 @@ Mu::Result<void> mu_cmd_view(const Options& opts);
  * execute some mu command, based on 'opts'
  *
  * @param opts configuration option
- * @param err receives error information, or NULL
  *
  * @return Ok() or some error
  */

From 154a68d948c9b3e5cdd1568844b40c8343ffeebf Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 31 May 2025 12:37:13 +0300
Subject: [PATCH 290/305] meson.build: tweak guile build

---
 meson.build | 29 +++++++++++++++++------------
 1 file changed, 17 insertions(+), 12 deletions(-)

diff --git a/meson.build b/meson.build
index 379f71190..a89cdaf36 100644
--- a/meson.build
+++ b/meson.build
@@ -210,9 +210,9 @@ host_system = host_machine.system()
 # soft dependencies
 #
 
-
+#
 # logging
-
+#
 # if we're on a linux machine, perhaps there's systemd/journald.
 # otherwise, we don't bother.
 if host_machine.system() == 'linux'
@@ -222,7 +222,9 @@ if cc.has_function('g_log_writer_syslog',dependencies: glib_dep)
   config_h_data.set('MAYBE_USE_SYSLOG', 1)
 endif
 
-# optionally, use Compact Language Detector2 if we can find it.
+#
+# use Compact Language Detector2 if we can find it
+#
 cld2_dep = meson.get_compiler('cpp').find_library('cld2', required: get_option('cld2'))
 if not get_option('cld2').disabled() and cld2_dep.found()
   config_h_data.set('HAVE_CLD2', 1)
@@ -230,7 +232,9 @@ else
   message('CLD2 not found or disabled; no support for language detection')
 endif
 
+#
 # guile
+
 guile_dep = dependency('guile-3.0', required: get_option('guile'))
 # allow for a custom guile-extension-dir
 if guile_dep.found()
@@ -291,6 +295,15 @@ install_data('NEWS.org', 'IDEAS.org',
 ################################################################################
 # subdirs
 subdir('lib')
+
+# this must happen _after_ subdir('lib')
+if not get_option('guile').disabled() and guile_dep.found()
+  config_h_data.set('BUILD_GUILE', 1)
+  config_h_data.set_quoted('GUILE_BINARY',
+                           guile_dep.get_variable(pkgconfig: 'guile'))
+  subdir('guile')
+endif
+
 subdir('mu')
 
 # emacs -- needed for mu4e compilation
@@ -302,15 +315,7 @@ if emacs.found()
   subdir('man')
   subdir('mu4e')
 else
-  message('emacs not found; not pre-compiling mu4e / generating manpages')
-endif
-
-if not get_option('guile').disabled() and guile_dep.found()
-  config_h_data.set('BUILD_GUILE', 1)
-  config_h_data.set_quoted('GUILE_BINARY',
-                           guile_dep.get_variable(pkgconfig: 'guile'))
-  #message('guile is disabled for now')
-  subdir('guile')
+  message('emacs not found; not pre-compiling mu4e / generating man-pages')
 endif
 
 config_h_data.set_quoted('MU_PROGRAM', mu.full_path())

From 155725ff748ec05c19c088fec0a2cb40758db8c1 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Wed, 4 Jun 2025 20:49:11 +0300
Subject: [PATCH 291/305] fdl.texi: only need one copy in source tree

No need for identical files in mu4e / guile dirs, move to build-aux.
---
 {guile => build-aux}/fdl.texi |   0
 meson.build                   |   2 +
 mu4e/fdl.texi                 | 451 ----------------------------------
 3 files changed, 2 insertions(+), 451 deletions(-)
 rename {guile => build-aux}/fdl.texi (100%)
 delete mode 100644 mu4e/fdl.texi

diff --git a/guile/fdl.texi b/build-aux/fdl.texi
similarity index 100%
rename from guile/fdl.texi
rename to build-aux/fdl.texi
diff --git a/meson.build b/meson.build
index a89cdaf36..c47663d7e 100644
--- a/meson.build
+++ b/meson.build
@@ -286,6 +286,8 @@ version_texi_data.set('UPDATEDYEAR', mu_year)
 configure_file(input: join_paths(build_aux, 'version.texi.in'),
                output: 'version.texi',
                configuration: version_texi_data)
+configure_file(input: join_paths(build_aux, 'fdl.texi'),
+               output: 'fdl.texi', copy:true)
 
 ################################################################################
 # install some data files
diff --git a/mu4e/fdl.texi b/mu4e/fdl.texi
deleted file mode 100644
index 96ce74ea1..000000000
--- a/mu4e/fdl.texi
+++ /dev/null
@@ -1,451 +0,0 @@
-@c The GNU Free Documentation License.
-@center Version 1.2, November 2002
-
-@c This file is intended to be included within another document,
-@c hence no sectioning command or @node.
-
-@display
-Copyright @copyright{} 2000,2001,2002 Free Software Foundation, Inc.
-51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
-
-Everyone is permitted to copy and distribute verbatim copies
-of this license document, but changing it is not allowed.
-@end display
-
-@enumerate 0
-@item
-PREAMBLE
-
-The purpose of this License is to make a manual, textbook, or other
-functional and useful document @dfn{free} in the sense of freedom: to
-assure everyone the effective freedom to copy and redistribute it,
-with or without modifying it, either commercially or noncommercially.
-Secondarily, this License preserves for the author and publisher a way
-to get credit for their work, while not being considered responsible
-for modifications made by others.
-
-This License is a kind of ``copyleft'', which means that derivative
-works of the document must themselves be free in the same sense.  It
-complements the GNU General Public License, which is a copyleft
-license designed for free software.
-
-We have designed this License in order to use it for manuals for free
-software, because free software needs free documentation: a free
-program should come with manuals providing the same freedoms that the
-software does.  But this License is not limited to software manuals;
-it can be used for any textual work, regardless of subject matter or
-whether it is published as a printed book.  We recommend this License
-principally for works whose purpose is instruction or reference.
-
-@item
-APPLICABILITY AND DEFINITIONS
-
-This License applies to any manual or other work, in any medium, that
-contains a notice placed by the copyright holder saying it can be
-distributed under the terms of this License.  Such a notice grants a
-world-wide, royalty-free license, unlimited in duration, to use that
-work under the conditions stated herein.  The ``Document'', below,
-refers to any such manual or work.  Any member of the public is a
-licensee, and is addressed as ``you''.  You accept the license if you
-copy, modify or distribute the work in a way requiring permission
-under copyright law.
-
-A ``Modified Version'' of the Document means any work containing the
-Document or a portion of it, either copied verbatim, or with
-modifications and/or translated into another language.
-
-A ``Secondary Section'' is a named appendix or a front-matter section
-of the Document that deals exclusively with the relationship of the
-publishers or authors of the Document to the Document's overall
-subject (or to related matters) and contains nothing that could fall
-directly within that overall subject.  (Thus, if the Document is in
-part a textbook of mathematics, a Secondary Section may not explain
-any mathematics.)  The relationship could be a matter of historical
-connection with the subject or with related matters, or of legal,
-commercial, philosophical, ethical or political position regarding
-them.
-
-The ``Invariant Sections'' are certain Secondary Sections whose titles
-are designated, as being those of Invariant Sections, in the notice
-that says that the Document is released under this License.  If a
-section does not fit the above definition of Secondary then it is not
-allowed to be designated as Invariant.  The Document may contain zero
-Invariant Sections.  If the Document does not identify any Invariant
-Sections then there are none.
-
-The ``Cover Texts'' are certain short passages of text that are listed,
-as Front-Cover Texts or Back-Cover Texts, in the notice that says that
-the Document is released under this License.  A Front-Cover Text may
-be at most 5 words, and a Back-Cover Text may be at most 25 words.
-
-A ``Transparent'' copy of the Document means a machine-readable copy,
-represented in a format whose specification is available to the
-general public, that is suitable for revising the document
-straightforwardly with generic text editors or (for images composed of
-pixels) generic paint programs or (for drawings) some widely available
-drawing editor, and that is suitable for input to text formatters or
-for automatic translation to a variety of formats suitable for input
-to text formatters.  A copy made in an otherwise Transparent file
-format whose markup, or absence of markup, has been arranged to thwart
-or discourage subsequent modification by readers is not Transparent.
-An image format is not Transparent if used for any substantial amount
-of text.  A copy that is not ``Transparent'' is called ``Opaque''.
-
-Examples of suitable formats for Transparent copies include plain
-@sc{ascii} without markup, Texinfo input format, La@TeX{} input
-format, @acronym{SGML} or @acronym{XML} using a publicly available
-@acronym{DTD}, and standard-conforming simple @acronym{HTML},
-PostScript or @acronym{PDF} designed for human modification.  Examples
-of transparent image formats include @acronym{PNG}, @acronym{XCF} and
-@acronym{JPG}.  Opaque formats include proprietary formats that can be
-read and edited only by proprietary word processors, @acronym{SGML} or
-@acronym{XML} for which the @acronym{DTD} and/or processing tools are
-not generally available, and the machine-generated @acronym{HTML},
-PostScript or @acronym{PDF} produced by some word processors for
-output purposes only.
-
-The ``Title Page'' means, for a printed book, the title page itself,
-plus such following pages as are needed to hold, legibly, the material
-this License requires to appear in the title page.  For works in
-formats which do not have any title page as such, ``Title Page'' means
-the text near the most prominent appearance of the work's title,
-preceding the beginning of the body of the text.
-
-A section ``Entitled XYZ'' means a named subunit of the Document whose
-title either is precisely XYZ or contains XYZ in parentheses following
-text that translates XYZ in another language.  (Here XYZ stands for a
-specific section name mentioned below, such as ``Acknowledgements'',
-``Dedications'', ``Endorsements'', or ``History''.)  To ``Preserve the Title''
-of such a section when you modify the Document means that it remains a
-section ``Entitled XYZ'' according to this definition.
-
-The Document may include Warranty Disclaimers next to the notice which
-states that this License applies to the Document.  These Warranty
-Disclaimers are considered to be included by reference in this
-License, but only as regards disclaiming warranties: any other
-implication that these Warranty Disclaimers may have is void and has
-no effect on the meaning of this License.
-
-@item
-VERBATIM COPYING
-
-You may copy and distribute the Document in any medium, either
-commercially or noncommercially, provided that this License, the
-copyright notices, and the license notice saying this License applies
-to the Document are reproduced in all copies, and that you add no other
-conditions whatsoever to those of this License.  You may not use
-technical measures to obstruct or control the reading or further
-copying of the copies you make or distribute.  However, you may accept
-compensation in exchange for copies.  If you distribute a large enough
-number of copies you must also follow the conditions in section 3.
-
-You may also lend copies, under the same conditions stated above, and
-you may publicly display copies.
-
-@item
-COPYING IN QUANTITY
-
-If you publish printed copies (or copies in media that commonly have
-printed covers) of the Document, numbering more than 100, and the
-Document's license notice requires Cover Texts, you must enclose the
-copies in covers that carry, clearly and legibly, all these Cover
-Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on
-the back cover.  Both covers must also clearly and legibly identify
-you as the publisher of these copies.  The front cover must present
-the full title with all words of the title equally prominent and
-visible.  You may add other material on the covers in addition.
-Copying with changes limited to the covers, as long as they preserve
-the title of the Document and satisfy these conditions, can be treated
-as verbatim copying in other respects.
-
-If the required texts for either cover are too voluminous to fit
-legibly, you should put the first ones listed (as many as fit
-reasonably) on the actual cover, and continue the rest onto adjacent
-pages.
-
-If you publish or distribute Opaque copies of the Document numbering
-more than 100, you must either include a machine-readable Transparent
-copy along with each Opaque copy, or state in or with each Opaque copy
-a computer-network location from which the general network-using
-public has access to download using public-standard network protocols
-a complete Transparent copy of the Document, free of added material.
-If you use the latter option, you must take reasonably prudent steps,
-when you begin distribution of Opaque copies in quantity, to ensure
-that this Transparent copy will remain thus accessible at the stated
-location until at least one year after the last time you distribute an
-Opaque copy (directly or through your agents or retailers) of that
-edition to the public.
-
-It is requested, but not required, that you contact the authors of the
-Document well before redistributing any large number of copies, to give
-them a chance to provide you with an updated version of the Document.
-
-@item
-MODIFICATIONS
-
-You may copy and distribute a Modified Version of the Document under
-the conditions of sections 2 and 3 above, provided that you release
-the Modified Version under precisely this License, with the Modified
-Version filling the role of the Document, thus licensing distribution
-and modification of the Modified Version to whoever possesses a copy
-of it.  In addition, you must do these things in the Modified Version:
-
-@enumerate A
-@item
-Use in the Title Page (and on the covers, if any) a title distinct
-from that of the Document, and from those of previous versions
-(which should, if there were any, be listed in the History section
-of the Document).  You may use the same title as a previous version
-if the original publisher of that version gives permission.
-
-@item
-List on the Title Page, as authors, one or more persons or entities
-responsible for authorship of the modifications in the Modified
-Version, together with at least five of the principal authors of the
-Document (all of its principal authors, if it has fewer than five),
-unless they release you from this requirement.
-
-@item
-State on the Title page the name of the publisher of the
-Modified Version, as the publisher.
-
-@item
-Preserve all the copyright notices of the Document.
-
-@item
-Add an appropriate copyright notice for your modifications
-adjacent to the other copyright notices.
-
-@item
-Include, immediately after the copyright notices, a license notice
-giving the public permission to use the Modified Version under the
-terms of this License, in the form shown in the Addendum below.
-
-@item
-Preserve in that license notice the full lists of Invariant Sections
-and required Cover Texts given in the Document's license notice.
-
-@item
-Include an unaltered copy of this License.
-
-@item
-Preserve the section Entitled ``History'', Preserve its Title, and add
-to it an item stating at least the title, year, new authors, and
-publisher of the Modified Version as given on the Title Page.  If
-there is no section Entitled ``History'' in the Document, create one
-stating the title, year, authors, and publisher of the Document as
-given on its Title Page, then add an item describing the Modified
-Version as stated in the previous sentence.
-
-@item
-Preserve the network location, if any, given in the Document for
-public access to a Transparent copy of the Document, and likewise
-the network locations given in the Document for previous versions
-it was based on.  These may be placed in the ``History'' section.
-You may omit a network location for a work that was published at
-least four years before the Document itself, or if the original
-publisher of the version it refers to gives permission.
-
-@item
-For any section Entitled ``Acknowledgements'' or ``Dedications'', Preserve
-the Title of the section, and preserve in the section all the
-substance and tone of each of the contributor acknowledgements and/or
-dedications given therein.
-
-@item
-Preserve all the Invariant Sections of the Document,
-unaltered in their text and in their titles.  Section numbers
-or the equivalent are not considered part of the section titles.
-
-@item
-Delete any section Entitled ``Endorsements''.  Such a section
-may not be included in the Modified Version.
-
-@item
-Do not retitle any existing section to be Entitled ``Endorsements'' or
-to conflict in title with any Invariant Section.
-
-@item
-Preserve any Warranty Disclaimers.
-@end enumerate
-
-If the Modified Version includes new front-matter sections or
-appendices that qualify as Secondary Sections and contain no material
-copied from the Document, you may at your option designate some or all
-of these sections as invariant.  To do this, add their titles to the
-list of Invariant Sections in the Modified Version's license notice.
-These titles must be distinct from any other section titles.
-
-You may add a section Entitled ``Endorsements'', provided it contains
-nothing but endorsements of your Modified Version by various
-parties---for example, statements of peer review or that the text has
-been approved by an organization as the authoritative definition of a
-standard.
-
-You may add a passage of up to five words as a Front-Cover Text, and a
-passage of up to 25 words as a Back-Cover Text, to the end of the list
-of Cover Texts in the Modified Version.  Only one passage of
-Front-Cover Text and one of Back-Cover Text may be added by (or
-through arrangements made by) any one entity.  If the Document already
-includes a cover text for the same cover, previously added by you or
-by arrangement made by the same entity you are acting on behalf of,
-you may not add another; but you may replace the old one, on explicit
-permission from the previous publisher that added the old one.
-
-The author(s) and publisher(s) of the Document do not by this License
-give permission to use their names for publicity for or to assert or
-imply endorsement of any Modified Version.
-
-@item
-COMBINING DOCUMENTS
-
-You may combine the Document with other documents released under this
-License, under the terms defined in section 4 above for modified
-versions, provided that you include in the combination all of the
-Invariant Sections of all of the original documents, unmodified, and
-list them all as Invariant Sections of your combined work in its
-license notice, and that you preserve all their Warranty Disclaimers.
-
-The combined work need only contain one copy of this License, and
-multiple identical Invariant Sections may be replaced with a single
-copy.  If there are multiple Invariant Sections with the same name but
-different contents, make the title of each such section unique by
-adding at the end of it, in parentheses, the name of the original
-author or publisher of that section if known, or else a unique number.
-Make the same adjustment to the section titles in the list of
-Invariant Sections in the license notice of the combined work.
-
-In the combination, you must combine any sections Entitled ``History''
-in the various original documents, forming one section Entitled
-``History''; likewise combine any sections Entitled ``Acknowledgements'',
-and any sections Entitled ``Dedications''.  You must delete all
-sections Entitled ``Endorsements.''
-
-@item
-COLLECTIONS OF DOCUMENTS
-
-You may make a collection consisting of the Document and other documents
-released under this License, and replace the individual copies of this
-License in the various documents with a single copy that is included in
-the collection, provided that you follow the rules of this License for
-verbatim copying of each of the documents in all other respects.
-
-You may extract a single document from such a collection, and distribute
-it individually under this License, provided you insert a copy of this
-License into the extracted document, and follow this License in all
-other respects regarding verbatim copying of that document.
-
-@item
-AGGREGATION WITH INDEPENDENT WORKS
-
-A compilation of the Document or its derivatives with other separate
-and independent documents or works, in or on a volume of a storage or
-distribution medium, is called an ``aggregate'' if the copyright
-resulting from the compilation is not used to limit the legal rights
-of the compilation's users beyond what the individual works permit.
-When the Document is included in an aggregate, this License does not
-apply to the other works in the aggregate which are not themselves
-derivative works of the Document.
-
-If the Cover Text requirement of section 3 is applicable to these
-copies of the Document, then if the Document is less than one half of
-the entire aggregate, the Document's Cover Texts may be placed on
-covers that bracket the Document within the aggregate, or the
-electronic equivalent of covers if the Document is in electronic form.
-Otherwise they must appear on printed covers that bracket the whole
-aggregate.
-
-@item
-TRANSLATION
-
-Translation is considered a kind of modification, so you may
-distribute translations of the Document under the terms of section 4.
-Replacing Invariant Sections with translations requires special
-permission from their copyright holders, but you may include
-translations of some or all Invariant Sections in addition to the
-original versions of these Invariant Sections.  You may include a
-translation of this License, and all the license notices in the
-Document, and any Warranty Disclaimers, provided that you also include
-the original English version of this License and the original versions
-of those notices and disclaimers.  In case of a disagreement between
-the translation and the original version of this License or a notice
-or disclaimer, the original version will prevail.
-
-If a section in the Document is Entitled ``Acknowledgements'',
-``Dedications'', or ``History'', the requirement (section 4) to Preserve
-its Title (section 1) will typically require changing the actual
-title.
-
-@item
-TERMINATION
-
-You may not copy, modify, sublicense, or distribute the Document except
-as expressly provided for under this License.  Any other attempt to
-copy, modify, sublicense or distribute the Document is void, and will
-automatically terminate your rights under this License.  However,
-parties who have received copies, or rights, from you under this
-License will not have their licenses terminated so long as such
-parties remain in full compliance.
-
-@item
-FUTURE REVISIONS OF THIS LICENSE
-
-The Free Software Foundation may publish new, revised versions
-of the GNU Free Documentation License from time to time.  Such new
-versions will be similar in spirit to the present version, but may
-differ in detail to address new problems or concerns.  See
-@uref{http://www.gnu.org/copyleft/}.
-
-Each version of the License is given a distinguishing version number.
-If the Document specifies that a particular numbered version of this
-License ``or any later version'' applies to it, you have the option of
-following the terms and conditions either of that specified version or
-of any later version that has been published (not as a draft) by the
-Free Software Foundation.  If the Document does not specify a version
-number of this License, you may choose any version ever published (not
-as a draft) by the Free Software Foundation.
-@end enumerate
-
-@page
-@heading ADDENDUM: How to use this License for your documents
-
-To use this License in a document you have written, include a copy of
-the License in the document and put the following copyright and
-license notices just after the title page:
-
-@smallexample
-@group
-  Copyright (C)  @var{year}  @var{your name}.
-  Permission is granted to copy, distribute and/or modify this document
-  under the terms of the GNU Free Documentation License, Version 1.2
-  or any later version published by the Free Software Foundation;
-  with no Invariant Sections, no Front-Cover Texts, and no Back-Cover
-  Texts.  A copy of the license is included in the section entitled ``GNU
-  Free Documentation License''.
-@end group
-@end smallexample
-
-If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts,
-replace the ``with@dots{}Texts.'' line with this:
-
-@smallexample
-@group
-    with the Invariant Sections being @var{list their titles}, with
-    the Front-Cover Texts being @var{list}, and with the Back-Cover Texts
-    being @var{list}.
-@end group
-@end smallexample
-
-If you have Invariant Sections without Cover Texts, or some other
-combination of the three, merge those two alternatives to suit the
-situation.
-
-If your document contains nontrivial examples of program code, we
-recommend releasing these examples in parallel under your choice of
-free software license, such as the GNU General Public License,
-to permit their use in free software.
-
-@c Local Variables:
-@c ispell-local-pdict: "ispell-dict"
-@c End:
-

From 15279767293ce424f43fc5329dd9f1aaf8b7670d Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Thu, 5 Jun 2025 19:31:53 +0300
Subject: [PATCH 292/305] mu-cfind/contacts-cache: refactor matching in
 for_each

Move some of the code in from the command-line tool to contacts-cache, for
possible re-use. Clean up a bit while doing so.
---
 lib/mu-contacts-cache.cc | 44 ++++++++++++++++++++++++++++++++++-
 lib/mu-contacts-cache.hh | 25 ++++++++++++++++++--
 mu/mu-cmd-cfind.cc       | 50 ++++++++--------------------------------
 3 files changed, 75 insertions(+), 44 deletions(-)

diff --git a/lib/mu-contacts-cache.cc b/lib/mu-contacts-cache.cc
index 017af2074..330d62501 100644
--- a/lib/mu-contacts-cache.cc
+++ b/lib/mu-contacts-cache.cc
@@ -285,7 +285,7 @@ struct ContactLessThan {
 };
 using ContactSet = std::set<std::reference_wrapper<const Contact>, ContactLessThan>;
 
-void
+Result<size_t>
 ContactsCache::for_each(const EachContactFunc& each_contact) const
 {
 	std::lock_guard<std::mutex> l_{priv_->mtx_};
@@ -296,10 +296,52 @@ ContactsCache::for_each(const EachContactFunc& each_contact) const
 		sorted.emplace(item.second);
 
 	// return in _reverse_ order, so we get the most relevant ones first.
+	size_t n{};
 	for (auto it = sorted.rbegin(); it != sorted.rend(); ++it) {
+		++n;
 		if (!each_contact(*it))
 			break;
 	}
+
+	return Ok(std::move(n));
+}
+
+Result<size_t>
+ContactsCache::for_each(const EachContactFunc& each_contact,
+			const std::string match_rx,
+			bool personal,
+			int64_t after,
+			size_t maxnum) const
+{
+	// get the pattern regex, if any.
+	const Result<Regex> rxres = match_rx.empty() ? Ok(Regex{}) :
+		Regex::make(match_rx, static_cast<GRegexCompileFlags>
+			    (G_REGEX_OPTIMIZE|G_REGEX_CASELESS));
+	if (!rxres)
+		return Err(rxres.error());
+
+	const Regex rx{*rxres};
+
+	size_t n{};
+	const auto res = for_each([&](const Contact& contact)->bool {
+		// filter for personal & "after"
+		if ((personal && !contact.personal) ||
+		    (after > contact.message_date))
+			return true; /* skip this contact */
+		// filter for regex, if any.
+		if (rx && !rx.matches(contact.name) && !rx.matches(contact.email))
+			return true; /* next */
+		// do we have enough matches?
+		if (maxnum != 0 && n >= maxnum)
+			return false; // terminate
+		++n;
+		return each_contact(contact);
+	});
+
+	if (res)
+		return Ok(std::move(n));
+	else
+		return Err(res.error());
 }
 
 static bool
diff --git a/lib/mu-contacts-cache.hh b/lib/mu-contacts-cache.hh
index d31c9dc35..a0a452ba0 100644
--- a/lib/mu-contacts-cache.hh
+++ b/lib/mu-contacts-cache.hh
@@ -1,5 +1,5 @@
 /*
-** Copyright (C) 2020-2022 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2020-2025 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify it
 ** under the terms of the GNU General Public License as published by the
@@ -158,9 +158,30 @@ public:
 	 * highest ranked contacts come first).
 	 *
 	 * @param each_contact function invoked for each contact
+	 *
+	 * @return The number of times the callback was invoked or some error
 	 */
-	void for_each(const EachContactFunc& each_contact) const;
+	Result<size_t> for_each(const EachContactFunc& each_contact) const;
 
+	/**
+	 * Invoke some callable for each contact, in _descending_ order of rank
+	 * (i.e., the highest ranked contacts come first).
+	 *
+	 * @param each_contact function invoked for each contact
+	 * @param match_rx string with regular expression or "" for none
+	 * @param personal if true, only include personal contacts
+	 *        (i.e., contacts seen in message in which a personal address
+	 *         was involved)
+	 * @param after only consider messages after this time_t (seconds since epoch)
+	 * @param maxnum maximum number of times the callback invoked
+	 *
+	 * @return The number of times the callback was invoked or some error
+	 */
+	Result<size_t> for_each(const EachContactFunc& each_contact,
+				const std::string match_rx,
+				bool personal = false,
+				int64_t after = 0,
+				size_t maxnum = 0) const;
 private:
 	struct Private;
 	std::unique_ptr<Private> priv_;
diff --git a/mu/mu-cmd-cfind.cc b/mu/mu-cmd-cfind.cc
index 9c61595f5..00727909d 100644
--- a/mu/mu-cmd-cfind.cc
+++ b/mu/mu-cmd-cfind.cc
@@ -1,5 +1,5 @@
 /*
-** Copyright (C) 2022-2023 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2022-2025 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify it
 ** under the terms of the GNU General Public License as published by the
@@ -16,8 +16,6 @@
 ** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 **
 */
-
-#include "config.h"
 #include "mu-cmd.hh"
 
 #include <cstdint>
@@ -260,64 +258,34 @@ Mu::mu_cmd_cfind(const Mu::Store& store, const Mu::Options& opts)
 	if (!output)
 		return Err(Error::Code::Internal,
 			   "missing output function");
-
-	// get the pattern regex, if any.
-	Regex rx{};
-	if (!opts.cfind.rx_pattern.empty()) {
-		if (auto&& res =  Regex::make(opts.cfind.rx_pattern,
-					      static_cast<GRegexCompileFlags>
-					      (G_REGEX_OPTIMIZE|G_REGEX_CASELESS)); !res)
-			return Err(std::move(res.error()));
-		else
-			rx = res.value();
-	}
-
 	nicks.clear();
-	store.contacts_cache().for_each([&](const Contact& contact)->bool {
-
-		if (opts.cfind.maxnum && num > *opts.cfind.maxnum)
-			return false; /* stop the loop */
-
-		if (!store.contacts_cache().is_valid(contact.email))
-			return true; /* next */
-
-		// filter for maxnum, personal  & "after"
-		if ((opts.cfind.personal && !contact.personal) ||
-		    (opts.cfind.after.value_or(0) > contact.message_date))
-			return true; /* next */
 
-		// filter for regex, if any.
-		if (rx) {
-			if (!rx.matches(contact.name) && !rx.matches(contact.email))
-				return true; /* next */
-		}
-
-		/* seems we have a match! display it. */
+	const auto res = store.contacts_cache().for_each([&](const Contact& contact)->bool {
 		const auto itype{num == 0 ? ItemType::Header : ItemType::Normal};
 		output(itype, contact, opts);
 		++num;
 		return true;
-	});
+	}, opts.cfind.rx_pattern, opts.cfind.personal,
+		opts.cfind.after.value_or(0),
+		opts.cfind.maxnum.value_or(0U));
 
-	if (num == 0)
+	if (!res)
+		return Err(res.error());
+	else if (*res == 0)
 		return Err(Error::Code::NoMatches, "no matching contacts found");
 
 	output(ItemType::Footer, Nothing, opts);
 	return Ok();
 }
 
-
-
-
 #ifdef BUILD_TESTS
 /*
  * Tests.
  *
  */
-
+#include "config.h"
 #include "utils/mu-test-utils.hh"
 
-
 static std::string test_mu_home;
 
 static void

From 151917ce51910a9e3fef1db8840a2121961eac28 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Thu, 5 Jun 2025 20:03:24 +0300
Subject: [PATCH 293/305] mu-maildir.cc: fix typo

Use the right #define in the dirent check. Seems we were always following the
slow path.
---
 lib/mu-maildir.cc | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/lib/mu-maildir.cc b/lib/mu-maildir.cc
index 5eef69e5e..53152e59e 100644
--- a/lib/mu-maildir.cc
+++ b/lib/mu-maildir.cc
@@ -1,5 +1,5 @@
 /*
-** Copyright (C) 2008-2023 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+** Copyright (C) 2008-2025 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 **
 ** This program is free software; you can redistribute it and/or modify it
 ** under the terms of the GNU General Public License as published by the
@@ -32,7 +32,6 @@
 #include <glib/gprintf.h>
 #include <gio/gio.h>
 
-#include "glibconfig.h"
 #include "mu-maildir.hh"
 #include "utils/mu-utils.hh"
 #include "utils/mu-utils-file.hh"
@@ -51,7 +50,7 @@ using namespace Mu;
 static unsigned char
 get_dtype(struct dirent* dentry, const std::string& path, bool use_lstat)
 {
-#ifdef HAVE_STRUCT_DIRENT_D_TYPE
+#ifdef HAVE_DIRENT_D_TYPE
 
 	if (dentry->d_type == DT_UNKNOWN)
 		goto slowpath;
@@ -61,7 +60,7 @@ get_dtype(struct dirent* dentry, const std::string& path, bool use_lstat)
 	return dentry->d_type; /* fastpath */
 
 slowpath:
-#endif /*HAVE_STRUCT_DIRENT_D_TYPE*/
+#endif /*HAVE_DIRENT_D_TYPE*/
 
 	return determine_dtype(path, use_lstat);
 }

From ceed7a2a72d68761431940c91659f05443301a7a Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Wed, 11 Jun 2025 11:24:19 +0300
Subject: [PATCH 294/305] README.org: update re: development branch

Fixes #2853.
---
 README.org | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/README.org b/README.org
index a78b205c3..1355d784a 100644
--- a/README.org
+++ b/README.org
@@ -11,11 +11,6 @@
 [[https://www.djcbsoftware.nl/code/mu/mu4e/Installation.html#Building-from-a-release-tarball-1][https://img.shields.io/badge/Platform-FreeBSD-8b3a3a?logo=freebsd&logoColor=c32136&.svg]]
 [[https://formulae.brew.sh/formula/mu#default][https://img.shields.io/badge/Platform-macOS-101010?logo=apple&logoColor=ffffff&.svg]]
 
- [ *Note*: you are looking at the *development* branch, which is where new code is
- being developed and tested, and which may occasionally break. Distributions and
- non-adventurous users are instead recommended to use the [[https://github.com/djcb/mu/tree/release/1.10][1.10 Release Branch]] or
- to pick up one of the [[https://github.com/djcb/mu/releases][1.10 Releases]]. ]
-
 Welcome to ~mu~!
 
 Latest development news: [[NEWS.org]].

From 8cded9d464f5c301356e82b59aa84729521fbc98 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Wed, 11 Jun 2025 20:33:50 +0300
Subject: [PATCH 295/305] mu4e.texi: improve dired note

---
 mu4e/mu4e.texi | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/mu4e/mu4e.texi b/mu4e/mu4e.texi
index 3014e3204..061fdfcbb 100644
--- a/mu4e/mu4e.texi
+++ b/mu4e/mu4e.texi
@@ -3706,9 +3706,9 @@ the @t{mu-discuss} mailing list by @emph{Stephen Eglen}).
 (add-hook 'dired-mode-hook 'turn-on-gnus-dired-mode)
 @end lisp
 
-Then, mark the file(s) in @t{dired} you would like to attach and press
-@t{C-c RET C-a}, and you'll be asked whether to attach them to an
-existing message, or create a new one.
+Then, mark the file(s) in @t{dired} you would like to attach and press @kbd{C-c
+RET C-a} or @code{gnus-dired-attach}, and you'll be asked whether to attach them
+to an existing message, or create a new one.
 
 @node Other tools
 @appendix Other tools

From 6441d26875ab254d667007cc229739c84ad9dec1 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Thu, 12 Jun 2025 23:37:32 +0300
Subject: [PATCH 296/305] mu4e-notification: avoid error when byte-compiled

Ensure eval-when-compile macro is defined
---
 mu4e/mu4e-notification.el | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/mu4e/mu4e-notification.el b/mu4e/mu4e-notification.el
index 3d76b1a3a..83bce829b 100644
--- a/mu4e/mu4e-notification.el
+++ b/mu4e/mu4e-notification.el
@@ -1,6 +1,6 @@
 ;;; mu4e-notification.el --- Mail notifications -*- lexical-binding: t-*-
 
-;; Copyright (C) 2023-2024 Dirk-Jan C. Binnema
+;; Copyright (C) 2023-2025 Dirk-Jan C. Binnema
 
 ;; Author: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ;; Maintainer: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
@@ -28,6 +28,8 @@
 (require 'mu4e-query-items)
 (require 'mu4e-bookmarks)
 
+(eval-when-compile (require 'dbus nil 'noerror))
+
 ;; for Emacs' built-in desktop notifications to work, we need
 ;; DBus
 (when (featurep 'dbus)

From eb75141d0a29d797885a18588da2d1dda9f254fc Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 14 Jun 2025 13:09:44 +0300
Subject: [PATCH 297/305] mu_utils: add to_string_char

Like to_string_gchar, but for malloc/free strings.
---
 lib/utils/mu-utils.hh | 19 ++++++++++++++++---
 1 file changed, 16 insertions(+), 3 deletions(-)

diff --git a/lib/utils/mu-utils.hh b/lib/utils/mu-utils.hh
index 4e1da9c2a..8ec1f17a1 100644
--- a/lib/utils/mu-utils.hh
+++ b/lib/utils/mu-utils.hh
@@ -462,9 +462,9 @@ to_string_view(const std::string& s)
 }
 
 /**
- * Consume a gchar and return a std::string
+ * Consume a gchar* and return a std::string
  *
- * @param str a gchar* (consumed/freed)
+ * @param str a gchar* (consumed/freed with g_free())
  *
  * @return a std::string, empty if gchar was {}
  */
@@ -475,7 +475,20 @@ to_string_gchar(gchar*&& str)
 	g_free(str);
 	return s;
 }
-
+/**
+ * Consume a char* and return a std::string
+ *
+ * @param str a gchar* (consumed/freed with ::free())
+ *
+ * @return a std::string, empty if gchar was {}
+ */
+static inline std::string
+to_string_char(char*&& str)
+{
+	std::string s(str?str:"");
+	::free(str);
+	return s;
+}
 
 /*
  * Lexnums are lexicographically sortable string representations of non-negative

From 7f274fe518cc7521c6a64f0526877ffbcf8570f3 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sun, 15 Jun 2025 10:52:24 +0300
Subject: [PATCH 298/305] mu-test: fix logging verbosity

We were logging _everything since the g_log_set_handler was only set for the
default domain, not "mu". Let's fix this.
---
 lib/utils/mu-test-utils.cc | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/lib/utils/mu-test-utils.cc b/lib/utils/mu-test-utils.cc
index 0a2585926..cbfad3832 100644
--- a/lib/utils/mu-test-utils.cc
+++ b/lib/utils/mu-test-utils.cc
@@ -104,9 +104,8 @@ Mu::mu_test_init(int *argc, char ***argv)
 
 	if (!g_test_verbose())
 		g_log_set_handler(
-			NULL,
-			(GLogLevelFlags)(G_LOG_LEVEL_MASK |
-					 G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION),
+			"mu",
+			(GLogLevelFlags)(G_LOG_LEVEL_MASK | G_LOG_FLAG_RECURSION),
 			(GLogFunc)black_hole, NULL);
 }
 

From f9c24c716653e81771c1f97e9c3a082a7863138d Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 31 May 2025 12:41:37 +0300
Subject: [PATCH 299/305] mu: add 'scm' command

Add the "scm" command, the way to get a Guile/Scheme shell.

This is experimental but will replace the current guile support in guile/ at
some point.
---
 meson.build       |  9 +++++++++
 meson_options.txt |  7 ++++++-
 mu/mu-cmd-info.cc | 16 ++++++++++++++--
 mu/mu-cmd.cc      | 19 ++++++++++++++++++-
 mu/mu-options.cc  | 14 +++++++++++++-
 mu/mu-options.hh  | 14 +++++++++++++-
 6 files changed, 73 insertions(+), 6 deletions(-)

diff --git a/meson.build b/meson.build
index c47663d7e..0a5cd583c 100644
--- a/meson.build
+++ b/meson.build
@@ -306,6 +306,15 @@ if not get_option('guile').disabled() and guile_dep.found()
   subdir('guile')
 endif
 
+# this must happen _after_ subdir('lib')
+if not get_option('scm').disabled() and guile_dep.found()
+  config_h_data.set('BUILD_SCM', 1)
+  subdir('scm')
+else
+  # dummy-dep.
+  mu_scm_dep = declare_dependency('', required:false)
+endif
+
 subdir('mu')
 
 # emacs -- needed for mu4e compilation
diff --git a/meson_options.txt b/meson_options.txt
index c0366bd88..35c74c96a 100644
--- a/meson_options.txt
+++ b/meson_options.txt
@@ -35,7 +35,7 @@ option('lispdir',
 
 
 #
-# guile
+# guile & scm
 #
 
 option('guile',
@@ -48,6 +48,11 @@ option('guile-extension-dir',
        type: 'string',
        description: 'custom install path for the guile extension module')
 
+option('scm',
+       type : 'feature',
+       value: 'auto',
+       description: 'build the guile scripting support (requires guile-3.x)')
+
 #
 # misc
 #
diff --git a/mu/mu-cmd-info.cc b/mu/mu-cmd-info.cc
index 257c90933..b52fef904 100644
--- a/mu/mu-cmd-info.cc
+++ b/mu/mu-cmd-info.cc
@@ -288,8 +288,20 @@ topic_mu(const Options& opts)
 			"yes"
 #else
 			"no"
-#endif
-		, "GNU Guile 3.x scripting support?"});
+#endif /*BUILD_GUILE*/
+		, "GNU Guile 3.x support (old)?"});
+
+	info.add_row({"scm-support",
+#if BUILD_SCM
+			"yes"
+#else
+			"no"
+#endif /*BUILD_SCM*/
+		, "GNU Guile 3.x support (new)?"});
+
+
+
+
 	info.add_row({"readline-support",
 #if HAVE_LIBREADLINE
 			"yes"
diff --git a/mu/mu-cmd.cc b/mu/mu-cmd.cc
index bcdca9855..d14c355f4 100644
--- a/mu/mu-cmd.cc
+++ b/mu/mu-cmd.cc
@@ -35,6 +35,10 @@
 #include "message/mu-message.hh"
 #include "message/mu-mime-object.hh"
 
+#if BUILD_GUILE
+#include "scm/mu-scm.hh"
+#endif/*BUILD_GUILE*/
+
 #include "utils/mu-error.hh"
 #include "utils/mu-utils-file.hh"
 #include "utils/mu-utils.hh"
@@ -43,7 +47,6 @@
 
 using namespace Mu;
 
-
 static Result<void>
 cmd_fields(const Options& opts)
 {
@@ -63,6 +66,17 @@ cmd_find(const Options& opts)
 		return mu_cmd_find(*store, opts);
 }
 
+static Result<void>
+cmd_scm(const Store& store, const Options& opts)
+{
+#if !BUILD_SCM
+	return Err(Error::Code::InvalidArgument,
+		   "scm/guile is not available in this build");
+#else
+	return Mu::Scm::run(Mu::Scm::Config{store, opts});
+#endif /*BUILD_SCM*/
+}
+
 
 static void
 show_usage(void)
@@ -133,6 +147,9 @@ Mu::mu_cmd_execute(const Options& opts) try {
 		return cmd_find(opts);
 	case Options::SubCommand::Info:
 		return with_readonly_store(mu_cmd_info, opts);
+	case Options::SubCommand::Scm:
+		return with_readonly_store(cmd_scm, opts);
+
 
 	/* writable store */
 
diff --git a/mu/mu-options.cc b/mu/mu-options.cc
index 2b969321e..418765045 100644
--- a/mu/mu-options.cc
+++ b/mu/mu-options.cc
@@ -545,7 +545,15 @@ sub_server(CLI::App& sub, Options& opts)
 	sub.add_flag("--allow-temp-file", opts.server.allow_temp_file,
 		     "Allow for the temp-file optimization")
 		->excludes("--commands");
+}
 
+static void
+sub_scm(CLI::App& sub, Options& opts)
+{
+	sub.add_option("script-path", opts.scm.script_path, "Path to script")
+		->type_name("<path>");
+	sub.add_option("script-args", opts.scm.params, "Parameters for script")
+		->type_name("<parameters>");
 }
 
 static void
@@ -665,9 +673,13 @@ AssocPairs<SubCommand, CommandInfo, Options::SubCommandNum> SubCommandInfos= {{
 		  {Category::NeedsWritableStore,
 		  "remove", "Remove message from file-system and database", sub_remove }
 		},
+		{ SubCommand::Scm,
+		  {Category::None,
+		   "scm", "Start Guile/Scheme shell",sub_scm}
+		},
 		{ SubCommand::Script,
 		  // Note: SubCommand::Script is special; there's no literal
-		// "script" subcommand, there subcommands for all the scripts.
+		// "script" subcommand, there are subcommands for all the scripts.
 		  {Category::None,
 		   "script", "Invoke a script", {}}
 		},
diff --git a/mu/mu-options.hh b/mu/mu-options.hh
index bd5799a68..0b110c8e1 100644
--- a/mu/mu-options.hh
+++ b/mu/mu-options.hh
@@ -40,6 +40,7 @@ struct Options {
 	using	SizeVec	     = std::vector<std::size_t>;
 	using	OptTStamp    = Option<std::time_t>;
 	using	OptFieldId   = Option<Field::Id>;
+	using   OptString    = Option<std::string>;
 	using	StringVec    = std::vector<std::string>;
 
 	/*
@@ -62,7 +63,7 @@ struct Options {
 
 	enum struct SubCommand {
 		Add, Cfind, Extract, Fields, Find, Help, Index,Info, Init, Mkdir,
-		Move, Remove, Script, Server, Verify, View,
+		Move, Remove, Scm, Script, Server, Verify, View,
 		// <private>
 		__count__
 	};
@@ -80,6 +81,7 @@ struct Options {
 			SubCommand::Mkdir,
 			SubCommand::Move,
 			SubCommand::Remove,
+			SubCommand::Scm,
 			SubCommand::Script,
 			SubCommand::Server,
 			SubCommand::Verify,
@@ -226,6 +228,16 @@ struct Options {
 		StringVec	files;			/**< Files to remove */
 	} remove;
 
+
+	/*
+	 * Scm
+	 */
+	struct Scm {
+		OptString script_path; /**< Path to script (optional) */
+		StringVec params;      /**< Parameters for script (after "--") */
+	} scm;
+
+
 	/*
 	 * Scripts (i.e., finding scriot)
 	 */

From 527d9322e93c14685aaba61d49125483397cd948 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 31 May 2025 12:44:13 +0300
Subject: [PATCH 300/305] scm: new guile/scheme bindings

This implements the new scm/guile bindings for mu, to replace the deprecated
guile/ (at some point in the future).

For now, we allow for creating a guile shell with mu support.
---
 mu/meson.build        |   2 +-
 scm/meson.build       |  58 +++++++
 scm/mu-scm-contact.cc |  36 ++++
 scm/mu-scm-contact.hh |  38 +++++
 scm/mu-scm-shell.scm  |  18 ++
 scm/mu-scm-store.cc   | 156 +++++++++++++++++
 scm/mu-scm-store.hh   |  30 ++++
 scm/mu-scm.cc         | 160 ++++++++++++++++++
 scm/mu-scm.hh         | 242 ++++++++++++++++++++++++++
 scm/mu-scm.scm        | 384 ++++++++++++++++++++++++++++++++++++++++++
 10 files changed, 1123 insertions(+), 1 deletion(-)
 create mode 100644 scm/meson.build
 create mode 100644 scm/mu-scm-contact.cc
 create mode 100644 scm/mu-scm-contact.hh
 create mode 100644 scm/mu-scm-shell.scm
 create mode 100644 scm/mu-scm-store.cc
 create mode 100644 scm/mu-scm-store.hh
 create mode 100644 scm/mu-scm.cc
 create mode 100644 scm/mu-scm.hh
 create mode 100644 scm/mu-scm.scm

diff --git a/mu/meson.build b/mu/meson.build
index 0ada1e5f9..28dd00ed7 100644
--- a/mu/meson.build
+++ b/mu/meson.build
@@ -34,7 +34,7 @@ mu = executable(
   'mu-cmd-view.cc',
   'mu-cmd.cc'
 ],
-  dependencies: [ glib_dep, gmime_dep, lib_mu_dep, thread_dep, config_h_dep ],
+  dependencies: [ glib_dep, gmime_dep, lib_mu_dep, mu_scm_dep, thread_dep, config_h_dep ],
   cpp_args: ['-DMU_SCRIPTS_DIR="'+ join_paths(datadir, 'mu', 'scripts') + '"'],
   install: true)
 #
diff --git a/scm/meson.build b/scm/meson.build
new file mode 100644
index 000000000..6681d5a7d
--- /dev/null
+++ b/scm/meson.build
@@ -0,0 +1,58 @@
+## Copyright (C) 2025 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+##
+## This program is free software; you can redistribute it and/or modify
+## it under the terms of the GNU General Public License as published by
+## the Free Software Foundation; either version 3 of the License, or
+## (at your option) any later version.
+##
+## This program is distributed in the hope that it will be useful,
+## but WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+## GNU General Public License for more details.
+##
+## You should have received a copy of the GNU General Public License
+## along with this program; if not, write to the Free Software Foundation,
+## Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+mu_scm_dir=join_paths(datadir, 'mu', 'scm')
+mu_scm_dir_arg='-DMU_SCM_DIR="' + mu_scm_dir + '"'
+
+lib_mu_scm=static_library(
+  'mu-scm',
+  [
+    'mu-scm.cc',
+    'mu-scm-contact.cc',
+    'mu-scm-store.cc'
+  ],
+  dependencies: [
+    guile_dep,
+    config_h_dep,
+    lib_mu_dep,
+    lib_mu_utils_dep,
+    lib_mu_message_dep],
+  install: false,
+  cpp_args: [mu_scm_dir_arg])
+
+install_data(['mu-scm.scm', 'mu-scm-shell.scm'], install_dir : mu_scm_dir)
+
+# note: top-level meson.build defines a dummy replacement for this.
+mu_scm_dep = declare_dependency(
+  link_with: lib_mu_scm,
+  dependencies: [guile_dep, lib_mu_dep, config_h_dep, thread_dep ],
+  include_directories:
+    include_directories(['.', '..']))
+
+if makeinfo.found()
+  custom_target('mu_scm_info',
+                input: 'mu-scm.texi',
+                output: 'mu-scm.info',
+                install: true,
+                install_dir: infodir,
+                command: [makeinfo,
+                          '-o', join_paths(meson.current_build_dir(), 'mu-scm.info'),
+                          join_paths(meson.current_source_dir(), 'mu-scm.texi'),
+                          '-I', join_paths(meson.current_build_dir(), '..')])
+  if install_info.found()
+    infodir = join_paths(get_option('prefix') / get_option('infodir'))
+    meson.add_install_script(install_info_script, infodir, 'mu-scm.info')
+  endif
+endif
diff --git a/scm/mu-scm-contact.cc b/scm/mu-scm-contact.cc
new file mode 100644
index 000000000..08fa3e0e2
--- /dev/null
+++ b/scm/mu-scm-contact.cc
@@ -0,0 +1,36 @@
+/*
+** Copyright (C) 2025 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+**
+** This program is free software; you can redistribute it and/or modify it
+** under the terms of the GNU General Public License as published by the
+** Free Software Foundation; either version 3, or (at your option) any
+** later version.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with this program; if not, write to the Free Software Foundation,
+** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+**
+*/
+
+
+#include "mu-scm-contact.hh"
+
+using namespace Mu::Scm;
+
+SCM
+Mu::Scm::to_scm(const Contact& contact)
+{
+	static SCM email{scm_from_utf8_symbol("email")};
+	static SCM name{scm_from_utf8_symbol("name")};
+
+	SCM alist = scm_acons(email, to_scm(contact.email), SCM_EOL);
+	if (!contact.name.empty())
+		alist = scm_acons(name, to_scm(contact.name), alist);
+
+	return alist;
+}
diff --git a/scm/mu-scm-contact.hh b/scm/mu-scm-contact.hh
new file mode 100644
index 000000000..9a5472dba
--- /dev/null
+++ b/scm/mu-scm-contact.hh
@@ -0,0 +1,38 @@
+/*
+** Copyright (C) 2025 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+**
+** This program is free software; you can redistribute it and/or modify it
+** under the terms of the GNU General Public License as published by the
+** Free Software Foundation; either version 3, or (at your option) any
+** later version.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with this program; if not, write to the Free Software Foundation,
+** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+**
+*/
+
+#ifndef MU_SCM_CONTACT_HH
+#define MU_SCM_CONTACT_HH
+
+#include "message/mu-contact.hh"
+#include "mu-scm.hh"
+
+namespace Mu::Scm {
+/**
+ * Convert a Contact to an SCM
+ *
+ * @param contact a contact
+ *
+ * @return SCM
+ */
+SCM to_scm(const Contact& contact);
+
+} // Mu::Scm
+
+#endif /*MU_SCM_CONTACT_HH*/
diff --git a/scm/mu-scm-shell.scm b/scm/mu-scm-shell.scm
new file mode 100644
index 000000000..0efe7f8f3
--- /dev/null
+++ b/scm/mu-scm-shell.scm
@@ -0,0 +1,18 @@
+;; Copyright (C) 2025 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+;;
+;; This program is free software; you can redistribute it and/or modify it
+;; under the terms of the GNU General Public License as published by the
+;; Free Software Foundation; either version 3, or (at your option) any
+;; later version.
+;;
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+;;
+;; You should have received a copy of the GNU General Public License
+;; along with this program; if not, write to the Free Software Foundation,
+;; Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+(display "Welcome to the mu shell!\n\n")
+(use-modules (mu))
diff --git a/scm/mu-scm-store.cc b/scm/mu-scm-store.cc
new file mode 100644
index 000000000..f11ef834f
--- /dev/null
+++ b/scm/mu-scm-store.cc
@@ -0,0 +1,156 @@
+/*
+** Copyright (C) 2025 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+**
+** This program is free software; you can redistribute it and/or modify it
+** under the terms of the GNU General Public License as published by the
+** Free Software Foundation; either version 3, or (at your option) any
+** later version.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with this program; if not, write to the Free Software Foundation,
+** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+**
+*/
+
+#include "mu-scm-store.hh"
+#include "mu-scm-contact.hh"
+
+using namespace Mu;
+using namespace Mu::Scm;
+
+// types
+namespace {
+static SCM store_type;
+static SCM default_store;
+static bool initialized;
+}
+
+static const Store&
+to_store(SCM scm)
+{
+	scm_assert_foreign_object_type(store_type, scm);
+	return *reinterpret_cast<Store*>(scm_foreign_object_ref(scm, 0));
+}
+
+static SCM
+subr_mcount(SCM store_scm)
+{
+	return to_scm(to_store(store_scm).size());
+}
+
+static SCM
+subr_cfind(SCM store_scm, SCM pattern_scm, SCM personal_scm, SCM after_scm, SCM max_results_scm)
+{
+	SCM contacts{SCM_EOL};
+	const auto pattern{from_scm<std::string>(pattern_scm)};
+	const auto personal{from_scm<bool>(personal_scm)};
+	const auto after{from_scm_with_default(after_scm, 0)};
+
+	// 0 means "unlimited"
+	const size_t maxnum = from_scm_with_default(max_results_scm, 0U);
+
+	to_store(store_scm).contacts_cache().for_each(
+		[&](const auto& contact)->bool {
+			contacts = scm_append_x(scm_list_2(contacts, scm_list_1(to_scm(contact))));
+			return true;
+		}, pattern, personal, after, maxnum);
+	return contacts;
+}
+
+static Field::Id
+to_sort_field_id(SCM field)
+{
+	if (scm_is_false(field))
+		return Field::Id::Date;
+
+	const auto sym{from_scm<std::string>(scm_symbol_to_string(field))};
+	if (const auto field_opt{field_from_name(sym)}; !field_opt) {
+		raise_error("invalid symbol", "mfind",
+			    "expected sort-field symbol, but got {}", sym);
+		return Field::Id::Date;
+	} else
+		return field_opt->id;
+}
+
+static SCM
+subr_mfind(SCM store_scm, SCM query_scm, SCM related_scm, SCM skip_dups_scm,
+	  SCM sort_field_scm, SCM reverse_scm, SCM max_results_scm)
+{
+	const auto& store{to_store(store_scm)};
+	const auto query{from_scm<std::string>(query_scm)};
+	const auto related(from_scm<bool>(related_scm));
+	const auto skip_dups(from_scm<bool>(skip_dups_scm));
+	const auto reverse(from_scm<bool>(reverse_scm));
+
+	SCM_ASSERT_TYPE(scm_is_false(sort_field_scm) || scm_is_symbol(sort_field_scm),
+			sort_field_scm, SCM_ARG5, __func__, "symbol or #f");
+
+	const auto sort_field_id = to_sort_field_id(sort_field_scm);
+
+	// 0 means "unlimited"
+	const size_t maxnum = from_scm_with_default(max_results_scm, 0U);
+
+	// XXX date/reverse/maxnum
+
+	const QueryFlags qflags = QueryFlags::SkipUnreadable |
+		(skip_dups ? QueryFlags::SkipDuplicates : QueryFlags::None) |
+		(related ? QueryFlags::IncludeRelated: QueryFlags::None ) |
+		(reverse ? QueryFlags::Descending : QueryFlags::None);
+
+	SCM msgs{SCM_EOL};
+	std::lock_guard lock{store.lock()};
+	const auto qres = store.run_query(query, sort_field_id, qflags, maxnum);
+
+	SCM_ASSERT(qres, query_scm, SCM_ARG1, __func__);
+
+	for (const auto& mi: *qres) {
+		if (auto plist{mi.document()->get_data()}; plist.empty())
+			continue;
+		else {
+			SCM scm_plist{scm_c_eval_string(("'" + plist).c_str())};
+			msgs = scm_append_x(scm_list_2( msgs, scm_list_1(scm_plist)));
+		}
+	}
+
+	return msgs;
+}
+
+static void
+init_subrs()
+{
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wcast-function-type"
+	scm_c_define_gsubr("store-mfind", 7/*req*/, 0/*opt*/, 0/*rst*/,
+			   reinterpret_cast<scm_t_subr>(subr_mfind));
+	scm_c_define_gsubr("store-mcount", 1/*req*/, 0/*opt*/, 0/*rst*/,
+			   reinterpret_cast<scm_t_subr>(subr_mcount));
+	scm_c_define_gsubr("store-cfind", 5/*req*/, 0/*opt*/, 0/*rst*/,
+			   reinterpret_cast<scm_t_subr>(subr_cfind));
+#pragma GCC diagnostic pop
+}
+
+
+void
+Mu::Scm::init_store(const Store& store)
+{
+	if (initialized)
+		return;
+
+	store_type = scm_make_foreign_object_type(
+		scm_from_utf8_symbol("store"),
+		scm_list_1 (scm_from_utf8_symbol("data")),
+		{}); // no finalizer
+
+	default_store = scm_make_foreign_object_1(
+		store_type, const_cast<Store*>(&store));
+	scm_c_define("default-store-object", default_store);
+
+	init_subrs();
+
+	initialized = true;
+}
diff --git a/scm/mu-scm-store.hh b/scm/mu-scm-store.hh
new file mode 100644
index 000000000..41396ba85
--- /dev/null
+++ b/scm/mu-scm-store.hh
@@ -0,0 +1,30 @@
+/*
+** Copyright (C) 2025 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+**
+** This program is free software; you can redistribute it and/or modify it
+** under the terms of the GNU General Public License as published by the
+** Free Software Foundation; either version 3, or (at your option) any
+** later version.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with this program; if not, write to the Free Software Foundation,
+** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+**
+*/
+
+#ifndef MU_SCM_STORE_HH
+#define MU_SCM_STORE_HH
+
+#include "lib/mu-store.hh"
+#include "mu-scm.hh"
+
+namespace Mu::Scm {
+void init_store(const Mu::Store& store);
+} // Mu::Scm
+
+#endif /*MU_SCM_STORE_HH*/
diff --git a/scm/mu-scm.cc b/scm/mu-scm.cc
new file mode 100644
index 000000000..10526e3fd
--- /dev/null
+++ b/scm/mu-scm.cc
@@ -0,0 +1,160 @@
+/*
+** Copyright (C) 2025 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+**
+** This program is free software; you can redistribute it and/or modify it
+** under the terms of the GNU General Public License as published by the
+** Free Software Foundation; either version 3, or (at your option) any
+** later version.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with this program; if not, write to the Free Software Foundation,
+** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+**
+*/
+
+#include "mu-scm.hh"
+
+#include <unistd.h>
+#include <errno.h>
+
+#include "mu-utils.hh"
+#include "config.h"
+
+#include "mu-scm-contact.hh"
+#include "mu-scm-store.hh"
+
+using namespace Mu;
+using namespace Mu::Scm;
+
+namespace {
+static const Mu::Scm::Config *config{};
+static SCM mu_mod; // The mu module
+}
+
+/**
+ * Create a plist for the relevant configuration items
+ *
+ * @param opts
+ */
+static void
+init_config (const Options& opts)
+{
+	scm_c_define("options",
+		     alist_add(
+			     SCM_EOL,
+			     make_symbol("mu-home"), opts.muhome,
+			     make_symbol("verbose"), opts.verbose,
+			     make_symbol("debug"), opts.debug,
+			     make_symbol("quiet"), opts.quiet));
+}
+
+static void
+init_module_mu(void* _data)
+{
+	init_config(config->options);
+	init_store(config->store);
+}
+
+static const Result<std::string>
+make_mu_scm_path(const std::string& fname) {
+
+	const std::string dir = []() {
+		if (const char *altpath{::getenv("MU_SCM_DIR")}; altpath)
+			return altpath;
+		else
+			return MU_SCM_DIR;
+	}();
+
+	auto fpath{join_paths(dir, fname)};
+	if (::access(fpath.c_str(), R_OK) != 0)
+		return Err(Error::Code::File, "cannot read {}: {}",
+			   fpath, ::strerror(errno));
+	else
+		return Ok(std::move(fpath));
+}
+
+namespace {
+static std::string mu_scm_path;
+static std::string mu_scm_shell_path;
+}
+
+
+static Result<void>
+prepare_run(const Mu::Scm::Config& conf)
+{
+	if (config)
+		return Err(Error{Error::Code::AccessDenied,
+				"already prepared"});
+	config = &conf;
+
+	// do a checks _before_ entering guile, so we get a bit more civilized
+	// error message.
+
+	if (const auto path = make_mu_scm_path("mu-scm.scm"); path)
+		mu_scm_path = *path;
+	else
+		return Err(path.error());
+
+	if (const auto path = make_mu_scm_path("mu-scm-shell.scm"); path)
+		mu_scm_shell_path = *path;
+	else
+		return Err(path.error());
+
+
+	if (config->options.scm.script_path) {
+		const auto path{config->options.scm.script_path->c_str()};
+		if (const auto res = ::access(path, R_OK); res != 0) {
+			return Err(Error::Code::InvalidArgument,
+				   "cannot read '{}': {}", path, ::strerror(errno));
+		}
+	}
+
+	return Ok();
+}
+
+Result<void>
+Mu::Scm::run(const Mu::Scm::Config& conf) {
+
+	if (const auto res = prepare_run(conf); !res)
+		return Err(res.error());
+
+	scm_boot_guile(0, {}, [](void *data, int argc, char **argv) {
+		mu_mod = scm_c_define_module ("mu", init_module_mu, {});
+
+		std::vector<const char*> args {
+			"mu",
+			"-l", mu_scm_path.c_str(),
+		};
+		std::string cmd;
+		const auto opts{config->options.scm};
+		// if a script-path was specified, run a script
+		if (opts.script_path) {
+			// XXX: couldn't get another combination of -l/-s/-e/-c to work
+			// a) invokes `main' with arguments, and
+			// b) exits (rather than drop to a shell)
+			// but, what works is to manually specify (main ....)
+			cmd = "(main " + quote(*opts.script_path);
+			for (const auto& scriptarg : opts.params)
+				cmd += " " + quote(scriptarg);
+			cmd += ")";
+			for (const auto& arg: {
+					"-l", opts.script_path->c_str(),
+					"-c", cmd.c_str()})
+				args.emplace_back(arg);
+		} else {
+			// otherwise, drop us into an interactive shell/repl (and
+			// shell spec)
+			args.emplace_back("-l");
+			args.emplace_back(mu_scm_shell_path.c_str());
+		}
+		/* ahem...*/
+		scm_shell(std::size(args), const_cast<char**>(args.data()));
+	}, {}); // never returns.
+
+	return Ok();
+}
diff --git a/scm/mu-scm.hh b/scm/mu-scm.hh
new file mode 100644
index 000000000..f015eaaf4
--- /dev/null
+++ b/scm/mu-scm.hh
@@ -0,0 +1,242 @@
+/*
+** Copyright (C) 2025 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+**
+** This program is free software; you can redistribute it and/or modify it
+** under the terms of the GNU General Public License as published by the
+** Free Software Foundation; either version 3, or (at your option) any
+** later version.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with this program; if not, write to the Free Software Foundation,
+** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+**
+*/
+
+
+#ifndef MU_SCM_HH
+#define MU_SCM_HH
+
+#include <string>
+#include <string_view>
+#include <type_traits>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wredundant-decls"
+#include <libguile.h>
+#pragma GCC diagnostic pop
+
+#include "utils/mu-result.hh"
+#include "mu/mu-options.hh"
+#include "mu-store.hh"
+
+/**
+ * Namespace for the Scm (Guile) subsystem
+ *
+ */
+namespace Mu::Scm {
+
+	/**
+	 * Configuration object
+	 *
+	 */
+	struct Config {
+		const Mu::Store& store;
+		const Options& options;
+	};
+
+	/**
+	 * Start a guile shell
+	 *
+	 * Initialize the Scm sub-system, then start a shell or run a script,
+	 * based on the configuration.
+	 *
+	 * @param conf a Config object
+	 *
+	 * @return Ok() or some error
+	 */
+	Result<void> run(const Config& conf);
+
+	/**
+	 * Helpers
+	 *
+	 * @{*/
+
+	// https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2593r0.html
+	template<typename T> struct always_false : std::false_type {};
+
+	template<typename T> constexpr bool is_char_array_v =
+		std::is_array_v<T> &&
+		std::is_same_v<std::remove_extent_t<T>, char>;
+
+	/**
+	 * Make SCM symbol from string-like value
+	 *
+	 * @param val some value
+	 *
+	 * @return an SCM symbol
+	 */
+	template<typename T>
+	SCM make_symbol(const T& val){
+		using Type = std::remove_const_t<T>; // *not* std::remove_const
+		if constexpr (std::is_same_v<Type, std::string> ||
+			      std::is_same_v<Type, std::string_view>)
+			return scm_from_utf8_symboln(val.data(), val.size());
+		else if constexpr (is_char_array_v<Type>|| std::is_same_v<Type, const char*>)
+			return scm_from_utf8_symbol(val);
+		else {
+			static_assert(always_false<Type>::value, "source type not supported");
+			return SCM_UNSPECIFIED;
+		}
+	}
+
+	/**
+	 * Get some C++ value from an SCM object, generically.
+	 *
+	 * @param ARG some SCM object
+	 *
+	 * @return C++ value
+	 */
+	template<typename T>
+	T from_scm(SCM ARG) {
+		using Type = std::remove_const_t<T>; // *not* std::remove_const
+		if constexpr (std::is_same_v<Type, std::string>) {
+			SCM_ASSERT(scm_string_p(ARG), ARG, SCM_ARG1, __func__);
+			auto str{scm_to_utf8_string(ARG)};
+			std::string res{str};
+			::free(str);
+			return res;
+		} else if constexpr (std::is_same_v<Type, char>) {
+			SCM_ASSERT(scm_char_p(ARG), ARG, SCM_ARG1, __func__);
+			return scm_to_char(ARG);
+		} else if constexpr (std::is_same_v<Type, bool>) {
+			SCM_ASSERT(scm_boolean_p(ARG), ARG, SCM_ARG1, __func__);
+			return scm_to_bool(ARG);
+		} else if constexpr (std::is_same_v<Type, int>) {
+			SCM_ASSERT(scm_is_signed_integer(ARG, std::numeric_limits<int>::min(),
+							   std::numeric_limits<int>::max()),
+				   ARG, SCM_ARG1, __func__);
+			return scm_to_int(ARG);
+		} else if constexpr (std::is_same_v<Type, uint>) {
+			SCM_ASSERT(scm_is_unsigned_integer(ARG, std::numeric_limits<uint>::min(),
+					   std::numeric_limits<uint>::max()),
+				   ARG,  SCM_ARG1, __func__);
+			return scm_to_uint(ARG);
+		} else if constexpr (std::is_same_v<Type, SCM>) {
+			return ARG;
+		} else {
+			static_assert(always_false<Type>::value, "target type not supported");
+			return {};
+		}
+	}
+	/**
+	 * Like from_SCM, but if ARG is boolean false, return default value.
+	 *
+	 * @param ARG argument
+	 * @param default_value default value
+	 *
+	 * @return value
+	 */
+	template<typename T>
+	T from_scm_with_default(SCM ARG, const T default_value) {
+		return (scm_is_bool(ARG) && scm_is_false(ARG)) ? default_value : from_scm<T>(ARG);
+	}
+
+
+	/**
+	 * Get some SCM from a C++ value, generically.
+	 *
+	 * @param val some C++ object
+	 *
+	 * @return an SCM
+	 */
+	template<typename T>
+	SCM to_scm(const T& val) {
+		using Type = std::remove_const_t<T>;
+		if constexpr (std::is_same_v<Type, std::string> ||
+			      std::is_same_v<Type, std::string_view>)
+			return scm_from_utf8_stringn(val.data(), val.size());
+		else if constexpr (is_char_array_v<Type>|| std::is_same_v<Type, const char*>)
+			return scm_from_utf8_string(val);
+		else if constexpr (std::is_same_v<Type, bool>)
+			return scm_from_bool(val);
+		else if constexpr (std::is_same_v<Type, size_t>)
+			return scm_from_size_t(val);
+		else if constexpr (std::is_same_v<Type, int64_t>)
+			return scm_from_int64(val);
+		else if constexpr (std::is_same_v<Type, uint64_t>)
+			return scm_from_uint64(val);
+		else if constexpr (std::is_same_v<Type, SCM>)
+			return val;
+		else {
+			static_assert(always_false<Type>::value,
+				      "source type not supported");
+			return SCM_UNSPECIFIED;
+		}
+	}
+
+	// base case.
+	static inline SCM alist_add(SCM alist) {
+		return alist;
+	}
+	/**
+	 * Add key-value pair to an alist
+	 *
+	 * This assumes that keys are unique ("acons")
+	 *
+	 * @param alist some alist
+	 * @param key key
+	 * @param val value
+	 * @param keyvals... 0 or more key, value parmeters
+	 *
+	 * @return the updated alist
+	 */
+	template<typename Key, typename Value, typename... KeyVals>
+	static inline SCM alist_add(SCM alist, const Key& key, const Value& val,
+				    KeyVals... keyvals) {
+		SCM res = scm_acons(to_scm(key), to_scm(val), alist);
+		return alist_add(res, std::forward<KeyVals>(keyvals)...);
+	}
+
+	/**
+	 * Make an SCM error
+	 *
+	 * @param err name of the error
+	 * @param subr function name
+	 * @param frm... args format string
+	 *
+	 * @return an error (type)
+	 */
+	template<typename...T>
+	void raise_error(const std::string& err,
+			 const std::string& subr,
+			 fmt::format_string<T...> frm, T&&... args) noexcept {
+		static SCM mu_scm_error = scm_from_utf8_symbol("mu-scm-error");
+		scm_error(mu_scm_error,
+			  subr.c_str(),
+			  fmt::format(frm, std::forward<T>(args)...).c_str(),
+			  SCM_BOOL_F, SCM_BOOL_F);
+	}
+
+	/**@}*/
+}
+
+
+/**
+ * SCM formatter, for use with fmt
+ *
+ * @param scm some object
+ *
+ * @return string representation of scm
+ */
+// static inline std::string format_as(SCM scm) {
+//	return Mu::Scm::from_scm<std::string>(scm_object_to_string(scm, SCM_UNSPECIFIED));
+// }
+// XXX doesn't work:
+//     "static assertion failed: Formatting of non-void pointers is disallowed"
+
+#endif /*MU_SCM_HH*/
diff --git a/scm/mu-scm.scm b/scm/mu-scm.scm
new file mode 100644
index 000000000..44350daa4
--- /dev/null
+++ b/scm/mu-scm.scm
@@ -0,0 +1,384 @@
+;; Copyright (C) 2025 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+;;
+;; This program is free software; you can redistribute it and/or modify it
+;; under the terms of the GNU General Public License as published by the
+;; Free Software Foundation; either version 3, or (at your option) any
+;; later version.
+;;
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+;;
+;; You should have received a copy of the GNU General Public License
+;; along with this program; if not, write to the Free Software Foundation,
+;; Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+;; Note: this Scheme code depends on being loaded as part of "mu scm"
+;; which does so automatically. It is not a general Guile module.
+
+(define-module (mu)
+  :use-module (oop goops)
+  :use-module (system foreign)
+  :use-module (ice-9 optargs)
+  #:export (
+  ;; classes
+  <store>
+  *default-store*
+
+  mfind
+  mcount
+  cfind
+
+  <message>
+  sexp
+
+  date
+  iso-date
+  last-change
+
+  message-id
+  path
+  priority
+  subject
+
+  language
+  size
+
+  ;; message flags / predicates
+  flags
+  flag?
+  draft?
+  flagged?
+  passed?
+  replied?
+  seen?
+  trashed?
+  new?
+  signed?
+  encrypted?
+  attach?
+  unread?
+  list?
+  personal?
+  calendar?
+
+  ;; contact fields
+  from
+  to
+  cc
+  bcc
+
+  ;; helpers
+  iso-date->time-t
+  time-t->iso-date))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; some helpers for dealing with plists / alists
+(define (plist-for-each func plist)
+  "Call FUNC for each key/value in the PLIST.
+PLIST is a property-list with alternating key and value.
+Stops when FUNC returns #f."
+  (when (and (not (null? plist))
+	     (func (car plist) (cadr plist)))
+    (plist-for-each func (cddr plist))))
+
+(define (plist-find plist key)
+  "Find the value for the first occurrence of KEY in PLIST.
+If not found, return #f."
+  (let ((val #f))
+    (plist-for-each
+     (lambda (k v)
+       (if (eq? k key)
+	   (begin
+	     (set! val v) #f)
+	   #t))
+     plist)
+    val))
+
+(define (decolonize-symbol sym)
+  "Remove :-prefix from symbol."
+  (let ((name (symbol->string sym)))
+    (if (string-prefix? ":" name)
+	(string->symbol (string-drop name 1))
+	sym)))
+
+(define (plist->alist plist)
+  "Convert a plist into an alist."
+  (let ((alist '()))
+    (plist-for-each
+     (lambda (k v)
+       (set! alist
+	     (append! alist
+		      (list (cons (decolonize-symbol k)
+				  v)))))
+     plist)
+    alist))
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Message
+;;
+;; A <message> is created from a message plist.
+
+;; In mu, we have store a plist sexp for each message in the database,
+;; for use with mu4e. But, that very plist is useful here as well.
+(define-class <message> ()
+  (plist #:init-keyword #:plist #:getter plist))
+
+;; using the plist as-is makes for O(n) access to the various fields
+
+(define-method (find-field (message <message>) field)
+  (plist-find (plist message) field))
+
+(define-method (sexp (message <message>))
+  "Get the s-expression (plist) for this MESSAGE.
+
+This is an internal data-structure, originally for use with mu4e, but useful
+here as well. However, the precise details are not part of mu-scm API."
+  (plist message))
+
+(define (emacs-time->epoch-secs lst)
+  "Convert emacs-style timestamp LST to a number of seconds since epoch.
+If LST is #f, return #f."
+  (if lst
+      (+ (ash (car lst) 16) (cadr lst))
+      #f))
+
+;; Accessor for the fields
+
+(define-method (subject (message <message>))
+  "Get the subject for MESSAGE or #f if not found."
+  (find-field message ':subject))
+
+(define-method (maildir (message <message>))
+  "Get the maildir for MESSAGE or #f if not found."
+  (find-field message ':maildir))
+
+(define-method (message-id (message <message>))
+  "Get the message-id for MESSAGE or #f if not found."
+  (find-field message ':message-id))
+
+(define-method (date (message <message>))
+  "Get the date for MESSAGE was sent.
+This is the number of seconds since epoch; #f if not found."
+  (emacs-time->epoch-secs (find-field message ':date)))
+
+(define-method (last-change (message <message>))
+  "Get the date for the last change to MESSAGE.
+This is the number of seconds since epoch; #f if not found."
+  (emacs-time->epoch-secs (find-field message ':changed)))
+
+(define-method (path (message <message>))
+  "Get the file-system path for MESSAGE.
+A symbol, either 'high, 'low or 'normal, or #f if not found."
+  (find-field message ':path))
+
+(define-method (priority (message <message>))
+  "Get the priority for MESSAGE.
+A symbol, either 'high, 'low or 'normal, or #f if not found."
+  (find-field message ':priority))
+
+(define-method (language (message <message>))
+  "Get the ISO-639-1 language code for the message as a symbol, if detected.
+Return #f otherwise."
+  (let ((lang (find-field message ':language)))
+    (if lang
+	(string->symbol lang)
+	#f)))
+;; if-let would be nice!
+
+(define-method (size (message <message>))
+  "Get the size of the message in bytes or #f if not available."
+  (find-field message ':size))
+
+;;  Flags.
+
+(define-method (flags (message <message>))
+  "Get the size of the message in bytes or #f if not available."
+  (find-field message ':flags))
+
+(define-method (flag? (message <message>) flag)
+  "Does MESSAGE have FLAG?."
+  (let ((flags
+	 (find-field message ':flags)))
+    (if flags
+	(if (member flag flags) #t #f)
+	#f)))
+
+(define-method (draft? (message <message>))
+  "Is MESSAGE a draft message?"
+  (flag? message 'draft))
+
+(define-method (flagged? (message <message>))
+  "Is MESSAGE flagged?"
+  (flag? message 'flagged))
+
+(define-method (passed? (message <message>))
+  "Has MESSAGE message been 'passed' (forwarded)?"
+  (flag? message 'passed))
+
+(define-method (replied? (message <message>))
+  "Has MESSAGE been replied to?"
+  (flag? message 'replied))
+
+(define-method (seen? (message <message>))
+  "Does MESSAGE been 'seen' (read)?"
+  (flag? message 'seen))
+
+(define-method (trashed? (message <message>))
+  "Has MESSAGE been trashed?"
+  (flag? message 'trashed))
+
+(define-method (new? (message <message>))
+  "Is MESSAGE new?"
+  (flag? message 'new))
+
+(define-method (signed? (message <message>))
+  "Has MESSAGE been cryptographically signed?"
+  (flag? message 'signed))
+
+(define-method (encrypted? (message <message>))
+  "Has MESSAGE been encrypted?"
+  (flag? message 'encrypted))
+
+(define-method (attach? (message <message>))
+  "Does MESSAGE have an attachment?"
+  (flag? message 'attach))
+
+(define-method (unread? (message <message>))
+  "Is MESSAGE unread?"
+  (flag? message 'unread))
+
+(define-method (list? (message <message>))
+  "Is MESSAGE from some mailing-list?"
+  (flag? message 'list))
+
+(define-method (personal? (message <message>))
+  "Is MESSAGE personal?"
+  (flag? message 'personal))
+
+(define-method (calendar? (message <message>))
+  "Does MESSAGE have a calender invitation?"
+  (flag? message 'calendar))
+
+(define-method (find-contact-field (message <message>) field)
+  "Get contact FIELD from MESSAGE as an alist.
+Helper method "
+  (let ((cs (find-field message field)))
+    (if cs
+	(map plist->alist cs)
+	#f)))
+
+(define-method (from (message <message>))
+  "Get the sender (the From: field) for MESSAGE or #f if not found."
+  (find-contact-field message ':from))
+
+(define-method (to (message <message>))
+  "Get the (intended) recipient for MESSAGE (the To: field) or #f if not found."
+  (find-contact-field message ':to))
+
+(define-method (cc (message <message>))
+  "Get the (intended) carbon-copy recipient for MESSAGE (the Cc: field) or #f if
+not found."
+  (find-contact-field message ':cc))
+
+(define-method (bcc (message <message>))
+  "Get the (intended) blind carbon-copy recipient for MESSAGE (the Bcc: field) or
+#f if not found."
+  (find-contact-field message ':bcc))
+
+;; Store
+;;
+;; Note: we have a *default-store*, which is the store we opened during
+;; startup; for now that's the only store supported, but we keep things
+;; open.
+;;
+;; Since it's the default store, we'd like to call the methods without
+;; explicitly using *default-store*; with GOOPS, we cannot pass a default for
+;; that, nor can we use keyword arguments (I think?). So use define* for that.
+
+;; the 'store-object' is a foreign object wrapping a const Store*.
+(define-class <store> ()
+  (store-object #:init-keyword #:store-object #:getter store-object))
+
+;;  not exported
+(define-method (make-store store-object)
+  "Make a store from some STORE-OBJECT."
+  (make <store> #:store-object store-object))
+
+(define *default-store*
+  ;; default-store-object is defined in mu-scm-store.cc
+  (make-store default-store-object))
+
+(define* (mfind query
+	       #:key
+	       (store *default-store*)
+	       (related? #f)
+	       (skip-dups? #f)
+	       (sort-field 'date)
+	       (reverse? #f)
+	       (max-results #f))
+   "Find messages matching some query. The query is mandatory,
+the other (keyword) arguments are optional.
+
+(mfind QUERY
+    #:store       *default-store*. Leave at default.
+    #:related?    include related messages?  Default: false
+    #:skip-dups?  skip duplicates? Default: false
+    #:sort-field? field to sort by, a symbol. Default: date
+    #:reverse?    sort in descending order (z-a)
+    #:max-results max. number of matches. Default: false (unlimited))."
+   (map (lambda (plist)
+	  (make <message> #:plist plist))
+	(store-mfind (store-object store) query
+		     related? skip-dups? sort-field reverse? max-results)))
+
+(define* (mcount
+	  #:key
+	  (store *default-store*))
+  "Get the number of messages."
+  (store-mcount (store-object store)))
+
+(define* (cfind pattern
+		#:key
+		(store *default-store*)
+		(personal? #f)
+		(after #f)
+		(max-results #f))
+  "Find contacts matching some regex pattern, similar to 'mu-cfind(1).
+The pattern is mandatory; the other (keyword) arguments are optional.
+(cfind PATTERN
+    #:store       *default-store*. Leave at default.
+    #:personal?   only include 'personal' contacts. Default: all
+    #:after       only include contacts last seen time_t: Default all
+    #:max-results max. number of matches. Default: false (unlimited))."
+  (store-cfind (store-object store) pattern personal? after max-results))
+
+
+;;; Helpers
+
+(define* (iso-date->time-t isodate)
+  "Convert an ISO-8601 ISODATE to a number of seconds since epoch.
+
+ISODATE is a string with the strftime format \"%FT%T\", i.e.,
+yyyy-mm-ddThh:mm:ss or any prefix there of. The 'T', ':', '-' or any non-numeric
+characters re optional.
+
+ISODATE is assumed to represent some UTC date."
+  (let* ((tmpl "00000101000000")
+	 (isodate (string-filter char-numeric? isodate)) ;; filter out 'T' ':' '-' etc
+	 (isodate					 ;; fill out isodate
+	  (if (> (string-length tmpl) (string-length isodate))
+	      (string-append isodate (substring tmpl (string-length isodate)))
+	      isodate)))
+    ;;(format #t "~a\n" isodate)
+    (car (mktime (car (strptime "%Y%m%d%H%M%S" isodate)) "Z"))))
+
+(define-method (time-t->iso-date time-t)
+  "Convert a time_t (second-since-epoch) value TIME-T to an ISO-8601
+string for the corresponding UTC time.
+
+If TIME-T is #f, return an empty string of the same length."
+  (if time-t
+      (strftime "%FT%T" (gmtime time-t))
+      "                   "))

From caeb2ab3c91eb7d88119381b93cada85b39cb4be Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Wed, 11 Jun 2025 19:50:38 +0300
Subject: [PATCH 301/305] scm: add some unit-tests

Some basic unit tests. More will follow.
---
 scm/meson.build     | 13 ++++++++
 scm/mu-scm-test.scm | 76 +++++++++++++++++++++++++++++++++++++++++++++
 scm/mu-scm.cc       | 55 ++++++++++++++++++++++++++++++++
 3 files changed, 144 insertions(+)
 create mode 100644 scm/mu-scm-test.scm

diff --git a/scm/meson.build b/scm/meson.build
index 6681d5a7d..a20785a8e 100644
--- a/scm/meson.build
+++ b/scm/meson.build
@@ -56,3 +56,16 @@ if makeinfo.found()
     meson.add_install_script(install_info_script, infodir, 'mu-scm.info')
   endif
 endif
+
+if not get_option('tests').disabled()
+
+  srcdir=meson.current_source_dir()
+  def_srcdir='-DMU_SCM_SRCDIR="' + srcdir + '"'
+
+  test('test-scm',
+       executable('test-scm',
+                  'mu-scm.cc',
+                  install: false,
+                  dependencies: [mu_scm_dep],
+                  cpp_args: [mu_scm_dir_arg, def_srcdir, '-DBUILD_TESTS']))
+endif
diff --git a/scm/mu-scm-test.scm b/scm/mu-scm-test.scm
new file mode 100644
index 000000000..d6c9325ee
--- /dev/null
+++ b/scm/mu-scm-test.scm
@@ -0,0 +1,76 @@
+;; unit tests
+
+(use-modules (mu) (srfi srfi-64))
+
+(define (test-basic)
+  (test-begin "test-basic")
+
+  (test-equal "mcount" 19 (mcount))
+  (test-equal "cfind" 29 (length (cfind "")))
+  (test-equal "mfind" 19 (length (mfind "")))
+
+  (test-end "test-basic"))
+
+(define (test-basic-mfind)
+
+  (test-begin "test-basic-mfind")
+
+  (let ((msg (car (mfind ""))))
+    ;; size
+    (test-equal 490 (size msg))
+    ;; message-id
+    (test-equal "abcd$efgh@example.com" (message-id msg))
+    ;; subject
+    (test-equal "Greetings from Lothlórien" (subject msg))
+    ;; from
+    (test-equal 1 (length (from msg)))
+    (let ((sender (car (from msg))))
+      (test-equal "Frodo Baggins" (assoc-ref sender 'name))
+      (test-equal "frodo@example.com" (assoc-ref sender 'email)))
+    ;; to
+    (test-equal 1 (length (to msg)))
+    (let ((recip (car (to msg))))
+      (test-equal "Bilbo Baggins" (assoc-ref recip 'name))
+      (test-equal "bilbo@anotherexample.com" (assoc-ref recip 'email)))
+
+    ;; no date
+    (test-assert (not (date msg)))
+
+    ;; flags
+    (test-equal '(unread) (flags msg))
+    (test-assert (unread? msg))
+    (test-assert (not (seen? msg)))
+    (test-assert (not (new? msg))))
+
+  (test-end "test-basic-mfind"))
+
+(define (test-mfind)
+  (test-begin "test-mfind")
+  (let ((msg (car (mfind "" #:sort-field 'date #:reverse? #t))))
+
+    (test-equal "test with multi to and cc" (subject msg) )
+    (test-equal "2016-05-15T16:57:25" (time-t->iso-date (date msg))))
+
+  (test-end "test-mfind"))
+
+(define (test-helpers)
+  (test-begin "test-helpers")
+  (test-equal 1750077792 (iso-date->time-t "2025-06-16T12:43:12"))
+  (test-equal 1750075200 (iso-date->time-t "2025-06-16T12"))
+
+  (test-equal "2025-06-16T12:43:12" (time-t->iso-date 1750077792))
+  (test-equal "                   " (time-t->iso-date #f))
+  (test-end "test-helpers"))
+
+(define* (main _ #:rest args)
+  (let ((runner (test-runner-simple)))
+    (test-with-runner runner
+      (test-begin "mu-scm-tests")
+
+      (test-basic)
+      (test-basic-mfind)
+      (test-mfind)
+      (test-helpers)
+
+      (test-end "mu-scm-tests")
+      (exit (test-runner-fail-count runner)))))
diff --git a/scm/mu-scm.cc b/scm/mu-scm.cc
index 10526e3fd..374716c24 100644
--- a/scm/mu-scm.cc
+++ b/scm/mu-scm.cc
@@ -158,3 +158,58 @@ Mu::Scm::run(const Mu::Scm::Config& conf) {
 
 	return Ok();
 }
+
+
+
+
+#ifdef BUILD_TESTS
+
+/*
+ * Tests.
+ *
+ */
+#include <config.h>
+#include <mu-store.hh>
+#include "utils/mu-test-utils.hh"
+
+
+static void
+test_scm_script()
+{
+	TempDir tempdir{};
+	const auto MuTestMaildir{ Mu::canonicalize_filename(MU_TESTMAILDIR, "/")};
+	auto store{Store::make_new(tempdir.path(), MuTestMaildir)};
+	assert_valid_result(store);
+
+	{
+		const auto res = store->indexer().start({}, true/*block*/);
+		g_assert_true(res);
+	}
+
+	Mu::Options opts{};
+	opts.scm.script_path = join_paths(MU_SCM_SRCDIR, "mu-scm-test.scm");
+
+	Mu::Scm::Config scm_conf {
+		.store = *store,
+		.options = opts
+	};
+
+	{
+		const auto res = Mu::Scm::run(scm_conf);
+		assert_valid_result(res);
+	}
+}
+
+int
+main(int argc, char* argv[])
+{
+	::setenv("MU_SCM_DIR", MU_SCM_SRCDIR, 1);
+
+	mu_test_init(&argc, &argv);
+
+	g_test_add_func("/scm/script", test_scm_script);
+
+	return g_test_run();
+}
+
+#endif /*BUILD_TESTS*/

From 24a6d7725ed326c277dfc350709043eda8de44f7 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Mon, 16 Jun 2025 17:40:29 +0300
Subject: [PATCH 302/305] mu-scm: add man-page

Not much yet.
---
 man/meson.build  |  5 +++--
 man/mu-scm.1.org | 44 ++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 47 insertions(+), 2 deletions(-)
 create mode 100644 man/mu-scm.1.org

diff --git a/man/meson.build b/man/meson.build
index ac56f78f1..f48677b0b 100644
--- a/man/meson.build
+++ b/man/meson.build
@@ -1,4 +1,4 @@
-## Copyright (C) 2021-2023 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
+## Copyright (C) 2021-2025 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ##
 ## This program is free software; you can redistribute it and/or modify
 ## it under the terms of the GNU General Public License as published by
@@ -43,7 +43,7 @@ foreach inc: incs
 endforeach
 
 # man-pages is org-format.
-man_orgs=[
+man_orgs = [
   'mu.1.org',
   'mu-add.1.org',
   'mu-bookmarks.5.org',
@@ -59,6 +59,7 @@ man_orgs=[
   'mu-move.1.org',
   'mu-query.7.org',
   'mu-remove.1.org',
+  'mu-scm.1.org',
   'mu-server.1.org',
   'mu-verify.1.org',
   'mu-view.1.org'
diff --git a/man/mu-scm.1.org b/man/mu-scm.1.org
new file mode 100644
index 000000000..2e8766bae
--- /dev/null
+++ b/man/mu-scm.1.org
@@ -0,0 +1,44 @@
+#+TITLE: MU SCM
+#+MAN_CLASS_OPTIONS: :section-id "@SECTION_ID@" :date "@MAN_DATE@"
+#+include: macros.inc
+
+* NAME
+
+*mu scm* - bindings and shell for the GNU Guile programming language.
+
+* SYNOPSIS
+
+*mu scm* [​_COMMON-OPTIONS_​]
+
+starts the GNU Guile shell.
+
+*mu scm* [​_COMMON-OPTIONS_​] [[​_COMMAND_​] -- [​_COMMAND-OPTIONS_​]]
+
+runs a GNU Guile script.
+
+* DESCRIPTION
+
+*mu scm* is the command to use the bindings to the GNU Guile programming language.
+It can either open a shell ("REPL") or run scripts.
+
+Using *mu scm*, you can script *mu*.
+
+#+include: "common-options.inc" :minlevel 1
+
+#+include: "exit-code.inc" :minlevel 1
+
+* ENVIRONMENT
+
+By default, *mu scm* expects its internal files to be found in
+~<prefix>/hare/mu/scm~. However, for development/testing you can set the
+environment variable *MU_SCM_DIR* to some alternative directory.
+
+* SEE ALSO
+
+The full documentation for *mu scm* is maintained as a Texinfo manual. If the *info*
+and *mu* programs are properly installed at your site, the command *info mu-scm*
+should give you access to the complete manual.
+
+http://www.schemers.org provides a general introduction to the Scheme language.
+
+#+include: "prefooter.inc" :minlevel 1

From a6245184412adf7b1d2aa6987c0e9e4b81d7f1bb Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Sat, 14 Jun 2025 13:18:22 +0300
Subject: [PATCH 303/305] mu-scm: add texinfo documentation

---
 scm/mu-scm.texi | 630 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 630 insertions(+)
 create mode 100644 scm/mu-scm.texi

diff --git a/scm/mu-scm.texi b/scm/mu-scm.texi
new file mode 100644
index 000000000..07fccbd9c
--- /dev/null
+++ b/scm/mu-scm.texi
@@ -0,0 +1,630 @@
+\input texinfo.tex    @c -*-texinfo-*-
+@c %**start of header
+@setfilename mu-scm.info
+@settitle Mu-SCM User Manual
+
+@c Use proper quote and backtick for code sections in PDF output
+@c Cf. Texinfo manual 14.2
+@set txicodequoteundirected
+@set txicodequotebacktick
+
+@documentencoding UTF-8
+@c %**end of header
+
+@include version.texi
+
+@copying
+Copyright @copyright{} 2025-@value{UPDATED-YEAR} Dirk-Jan C. Binnema
+
+@quotation
+Permission is granted to copy, distribute and/or modify this document
+under the terms of the GNU Free Documentation License, Version 1.3 or
+any later version published by the Free Software Foundation; with no
+Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.  A
+copy of the license is included in the section entitled ``GNU Free
+Documentation License.''
+@end quotation
+@end copying
+
+@titlepage
+@title Mu-SCM - extending @t{mu} with Guile Scheme
+@subtitle version  @value{VERSION}
+@author Dirk-Jan C. Binnema
+
+@c The following two commands start the copyright page.
+@page
+@vskip 0pt plus 1filll
+@insertcopying
+@end titlepage
+
+@dircategory The Algorithmic Language Scheme
+@direntry
+* Mu-SCM: (mu-scm).        Guile support for the mu e-mail search engine
+@end direntry
+
+@contents
+
+@ifnottex
+@node Top
+@top Mu-SCM Manual
+@end ifnottex
+
+@iftex
+@node Welcome to @t{mu-scm}
+@unnumbered Welcome to @t{mu-scm}
+@end iftex
+
+Welcome to @t{mu-scm}!
+
+@t{mu} is a program for indexing and searching your e-mails. It can do so in
+many different ways, but sometimes that may not be enough.
+
+@t{mu-scm} is made for such cases. It embeds the Guile programming language into
+@t{mu}. Guile is the @emph{GNU Ubiquitous Intelligent Language for Extensions} -
+a version of the @emph{Scheme} programming language, the official GNU extension
+language, and a member of the @emph{Lisp} family of programming languages --
+like emacs-lisp, @emph{Racket}, Common Lisp.
+
+@t{mu-scm} is replacing the older @t{mu-guile} bindings; some notable
+differences are:
+@itemize
+@item No separate 'module', instead use mu itself.
+This greatly reduces the number of 'moving parts' and mysterious errors for users
+@item Automatically set up a reasonable environment
+@t{mu scm} simply reuses the user's @t{mu} configuration, simplifying setup
+@item API improvements
+@t{mu-scm} has learned from @t{mu-guile} to make its APIs nicer to use
+@item However, some parts are missing...
+@t{mu-scm} does not yet support all that @t{mu-guile} did. It's just getting
+started.
+@end itemize
+
+If you're not familiar with Scheme or Lisp, @t{mu-scm} may be a fun way to learn
+a bit more! Note: @t{mu-scm} is brand new and rather @strong{experimental} for
+now, and APIs can still change without warning.
+
+@menu
+* Getting started::
+* Shell::
+* Scripts::
+* API Reference::
+
+Appendices
+* GNU Free Documentation License::  The license of this manual.
+
+Indices
+* Procedure Index::
+
+@end menu
+
+@node Getting started
+@chapter Getting started
+
+@menu
+* Using distributions::
+* Building it yourself::
+* Verifying support::
+@end menu
+
+This chapter walks you through the installation and basic setup.
+
+@node Using distributions
+@section Using distributions
+
+At the time of writing, no distributions ship with an SCM-enabled @t{mu} yet, so
+for now you need to build it yourself. Of course, this is fully optional.
+
+@node Building it yourself
+@section Building it yourself
+
+To build @t{mu} with SCM support, first you need to ensure you have installed
+the required Guile development packages. The details of getting those vary
+across environments / distributions, e.g.: on Fedora (as root):
+
+@example
+# dnf install guile30-devel
+@end example
+
+or on Debian/Ubuntu:
+@example
+$ sudo apt install guile-3.0-dev
+@end example
+
+With those packages in place, you can (re)build @t{mu} and @t{mu-scm} should be
+built automatically if you did @emph{not} explicitly disable it.
+
+Parts of @t{mu-scm} depend on @t{mu} being @emph{installed}, not just built;
+however, you can still use it un-installed as well by setting an environment
+variable @t{MU_SCM_DIR} to the source-directory, e.g.
+@t{/home/user/sources/mu/scm}.
+
+@node Verifying support
+@section Verifying support
+
+After installing @t{mu}, you can check the output of @command{mu info}. If
+@t{mu-scm} is available, in the table you should find a line:
+@example
+| scm-support      | yes     | GNU Guile 3.x support (new)?          |
+@end example
+
+@node Shell
+@chapter Shell
+
+This chapter discusses the @t{mu-scm}-powered shell.
+
+After installation (@xref{Getting started}), you can start the @t{mu-scm} shell
+by issuing:
+@example
+$ mu scm
+@end example
+
+This is the Guile
+REPL@footnote{@url{https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop}}
+customized for @t{mu}. In particular, it supports all the common @t{mu}
+command-line arguments for specifying where your @t{mu} stores its data and so
+on (see the @t{mu} and @t{mu scm} man-pages for details).
+
+@example
+$ mu scm
+[....]
+Welcome to the mu shell!
+
+GNU Guile 3.0.9
+Copyright (C) 1995-2023 Free Software Foundation, Inc.
+
+Guile comes with ABSOLUTELY NO WARRANTY; for details type `,show w'.
+This program is free software, and you are welcome to redistribute it
+under certain conditions; type `,show c' for details.
+
+Enter `,help' for help.
+scheme@@(guile-user)>
+@end example
+
+This shell is set-up for use with @t{mu} with the module imported and the
+message database loaded. So we can try some simple queries, using the
+@code{mfind} function, which mimics @t{mu find}@footnote{It is called @t{mfind}
+instead of @t{find} to avoid clashing with the core Guile function by that
+name.}
+@example
+scheme@@(guile-user)> (mfind "rhinoceros")
+$1 = (#<<message> 7f2aa671fce0>)
+@end example
+
+Which means we found one message matching @t{rhinoceros}. If you don't have such
+a message, try some different query. We can then inspect the message, using the
+@t{$1} temporary:
+
+@example
+scheme@@(guile-user)> (subject (car $1))
+$2 = "Important message about African animals"
+@end example
+
+@node Scripts
+@chapter Scripts
+
+In the @ref{Shell} chapter, we saw how you can use @t{mu-scm} interactively. In
+this also possible to run @emph{scripts}. Generally, you can invoke a script by
+passing its name to @command{mu scm}, for example:
+@example
+mu scm path/to/script/myscript.scm
+@end example
+
+@t{mu-scm} expects scripts to have a procedure @code{main} of the form:
+
+@deffn {Scheme Procedure} main script #:rest args
+@end deffn
+
+@t{main} receives the script (path) as its first argument, and any other
+arguments in the list @t{args}.
+
+Thus, an example script might look like:
+@lisp
+(use-modules (mu))
+
+(define* (main script #:rest args)
+  (format #t "running script ~a and arguments ~s\n" script args)
+  (for-each
+   (lambda (msg)
+     (format #t "~a ~a\n"
+             (time-t->iso-date (date msg))
+             (or (subject msg) "No subject")))
+   (mfind "hello AND date:2015.." #:max-results 5)))
+@end lisp
+
+You can run it like this:
+@example
+$ mu scm ~/myscript.scm some args 123
+running script /home/user/myscript.scm and arguments  ("some" "args" "123")
+2015-01-02T12:41:13 Happy 2015! It's Day 2 - How Are Those Resolutions Coming?
+2015-01-06T12:29:21 Brunch Sunday 11.1.
+2015-01-06T18:05:27 Moderator's spam report for mu-discuss@@googlegroups.com
+2015-01-13T11:37:27 Upvoted: The Story Behind the Users Who Make Reddit's Front Page
+2015-01-16T17:06:23 [mu] combining maildirs in query (#559)
+@end example
+
+Quite likely, your output will differ from the above.
+
+@node API Reference
+@chapter API Reference
+
+This chapter goes through the @t{mu-scm} API. For this, we need to understand a
+few key concepts, represented in some GOOP objects and other data-structures:
+
+@itemize
+@item the @t{<store>} represents the mu database with information about messages
+@item from the store, you can find @t{<message>} objects, each of which represent a specific message
+I.e., what you get from @code{mu find}
+@item the store also exposes tha contacts in the store as alists (``association lists'')
+I.e., the information from @code{mu cfind}
+@end itemize
+
+@menu
+* Store:: the database of all information
+* Message:: inspecting individual messages
+* Helpers:: some helper functions
+@end menu
+
+@node Store
+@section Store
+
+The store represents the @t{mu} database, i.e., the place where @t{mu index}
+stores information about messages and contacts.
+
+While you could theoretically have @emph{multiple} stores, for now @t{mu-scm}
+only supports a single one, which is the store you opened when you started
+@command{mu scm}. For completeness and possible future use, store-related
+methods do take a @t{#:store} parameter, but you can (in fact, @emph{must})
+leave it out, and use its default value.
+
+Hence, in the API descriptions below, we leave out the @t{#:store} argument.
+
+The store currently only exposes a few methods, described below.
+
+@deffn {Scheme Procedure} mfind query [#:related? #f] [#:skip-dups? #f] [#:sort-field 'date]
+       [#:reverse? #f] [#:max-results #f]
+@end deffn
+
+Perform a query for messages in the store, and return a list of message objects
+(@xref{Message}) for the matches.
+
+@itemize
+@item @t{query} is a Mu query; see @t{mu-query} man-page for details
+@item @t{#:related?} (optional) whether @emph{related} messages should be included
+This is similar to the @t{--include-related} parameter for @command{mu find}
+@item @t{#:skip-dups?} (optional) whether to exclude duplicate messages
+This is similar to the @t{--skip-dups} parameter for @command{mu find}
+@item @t{#:sort-field} (optional) a symbol, the message field to sort by
+You can sort by the fields (see @command{mu info fields} that have a @t{value=yes})
+@item @t{#:reverse?} (optional) whether to reverse the sort-direction (make it descending)
+@item @t{#:max-results} (optional) the maximum number of results
+By default, @emph{all} matches are returned
+@end itemize
+
+@t{mfind} mimics the @command{mu find} command-line command.
+
+Example usage:
+@lisp
+(mfind "capybara" #:skip-dups? #t #:sort-field 'subject)
+=> (#<<message> 7f3c8ac09c00> #<<message> 7f3c8ac09be0>)
+@end lisp
+
+@deffn {Scheme Procedure} cfind pattern [#:personal? #f] [#:after #f] [#:max-results #f]
+@end deffn
+
+Search for contacts in the store, and return a list of contacts for the matches.
+Each contact is an association list with at least a key (symbol @t{email}) with
+e-mail address as its value, and possibly a @t{name} key with the contact's
+name. In the future, other fields may be added.
+
+@itemize
+@item @t{pattern} is a basic case-insensitive PCRE-compatible regular expression
+see the @t{pcre(3)} man-page for details
+@item @t{#:personal} (optional) if true, only match @emph{personal} contacts
+A personal contact is a contact seen in message where ``you'' were an explicit
+sender or recipient, thus excluding mailing-list. Personal addresses are those
+that were specified at store creation time - see the @t{mu-init} man-page, in
+particular the @t{--personal-address} parameter
+@item @t{#:after} (optional) only include contacts last-seen after some time-point
+Specified as the number of seconds since epoch. Helper-function
+@code{iso-date->time-t} can be useful here.
+@item @t{#:max-results} (optional) the maximum number of results
+By default, @emph{all} matches are returned
+@end itemize
+
+@t{cfind} mimics the @command{mu cfind} command-line command.
+
+Example usage:
+@lisp
+(car (cfind "smith" #:personal? #t))
+=> ((name . "Hannibal Smith") (email . "jhs@@example.com"))
+@end lisp
+
+@deffn {Scheme Procedure} mcount
+@end deffn
+
+Returns the number of messages in the store.
+
+Example usage:
+@lisp
+(mcount)
+=> 140728
+@end lisp
+
+@node Message
+@section Message
+
+A message represents the information about some e-mail message whose information
+has been extracted and store in the @t{mu} store (database).
+
+You can retrieve lists of @t{<message>} objects with @t{mfind} method, as
+explained in @xref{Store}. In the following, we use some message-object
+@t{msg}, e.g.
+@lisp
+(define msg (car (mfind "hello")))
+@end lisp
+
+@subsection Basics
+
+@deffn {Scheme Procedure} subject message
+@end deffn
+Get the message subject, or @t{#f} if there is none.
+
+For example:
+@lisp
+(subject msg)
+=> "Hello!"
+@end lisp
+
+@deffn {Scheme Procedure} maildir message
+@end deffn
+Get the message subject, or @t{#f} if there is none.
+
+For example:
+@lisp
+(maildir msg)
+=> "/inbox"
+@end lisp
+
+@deffn {Scheme Procedure} path message
+@end deffn
+Get the file-system path for the the message.
+
+For example:
+@lisp
+(path msg)
+=> "/home/user/Maildir/archive/cur/1546942532.adb906ab91921e10.hyperion:2,DS"
+@end lisp
+
+@deffn {Scheme Procedure} message-id message
+@end deffn
+Get the message's @t{Message-ID} field, or @t{#f} if there is none.
+
+For example:
+@lisp
+(message-id msg)
+=> "87a15477-dd66-43e5-a722-81c545d6af19@@gmail.com"
+@end lisp
+
+@deffn {Scheme Procedure} date message
+@end deffn
+Get the message's @t{Date} field (the sent-date), or @t{#f} if there is none.
+@t{date} expressed the data as the number of seconds since epoch, @t{time_t}.
+
+As a convenience, @t{iso-date} expresses the date as an ISO-8601-compatible
+string or an empty string of the same length.
+
+For example:
+@lisp
+(date msg)
+=> 1750064431
+(iso-date msg)
+=> 2025-06-16T09:00:31
+@end lisp
+
+@subsection Contacts
+
+Message fields @t{To:}, @t{From:}, @t{Cc:} and @t{Bcc:} contain @emph{contacts}.
+@t{mu-scm} represents those as list of contact-alists, or contacts for short.
+Each contact is an alist with at least an @t{email} and optionally a @t{name}
+field. For instance:
+
+@lisp
+(to msg)
+=> (((name . "Hannibal Smith") (email . "jhs@@example.com"))
+    ((email . "murdock@@example.com")))
+@end lisp
+
+@deffn {Scheme Procedure} from message
+@end deffn
+Get the list of message senders (usually only one). Returns either a list
+of contacts or @t{#f}.
+
+@deffn {Scheme Procedure} to message
+@end deffn
+Get the message's intended @t{To:} recipients. Returns either
+a list of contacts or @t{#f} if not found.
+
+@deffn {Scheme Procedure} cc message
+@end deffn
+Get the message's intended carbon-copy @t{Cc:} recipients. Returns either a list
+of contacts or @t{#f} if not found.
+
+@deffn {Scheme Procedure} bcc message
+@end deffn
+Get the message's intended blind carbon-copy @t{Bcc:} recipients. Returns either
+a list of contacts or @t{#f} if not found.
+
+@subsection Flags
+
+Message can have a number of properties or @emph{flags}.
+
+@deffn {Scheme Procedure} flags message
+@end deffn
+Get the message's list of @emph{flags}. Flags are symbols, see @command{mu info
+fields} for the list of all flags.
+
+For example:
+@lisp
+(flags msg)
+=> (draft seen personal)
+@end lisp
+
+There are some helpers to check for the presence of specific flags:
+
+@deffn {Scheme Procedure} flag? message flag
+@end deffn
+Does the message have the given flag? @t{#t} or @t{#f}.
+
+For example:
+@lisp
+(flags? msg 'personal)
+=> #t
+(flags? msg 'calendar)
+=> #f
+@end lisp
+
+@deffn {Scheme Procedure} draft? message
+@end deffn
+Does the message have the @t{draft} flag? Returns @t{#t} or @t{#f}.
+
+@deffn {Scheme Procedure} flagged? message
+@end deffn
+Does the message have the @t{flagged} flag? Returns @t{#t} or @t{#f}.
+
+@deffn {Scheme Procedure} passed? message
+@end deffn
+Does the message have the @t{passed} flag? I.e., has it been forwarded?
+Returns @t{#t} or @t{#f}.
+
+@deffn {Scheme Procedure} replied? message
+@end deffn
+Does the message have the @t{replied} flag? Returns @t{#t} or @t{#f}.
+
+@deffn {Scheme Procedure} seen? message
+@end deffn
+Does the message have the @t{seen} flag? Returns @t{#t} or @t{#f}.
+
+@deffn {Scheme Procedure} trashed? message
+@end deffn
+Does the message have the @t{trashed} flag? I.e., has it been marked for
+removal? Returns @t{#t} or @t{#f}.
+
+@deffn {Scheme Procedure} new? message
+@end deffn
+Is this a new message? Returns @t{#t} or @t{#f}.
+
+@deffn {Scheme Procedure} signed? message
+@end deffn
+Is this a cryptographically signed message? Returns @t{#t} or @t{#f}.
+
+@deffn {Scheme Procedure} encrypted? message
+@end deffn
+Is this an encrypted message? Returns @t{#t} or @t{#f}.
+
+@deffn {Scheme Procedure} attach? message
+@end deffn
+Does the message have an attachment? Returns @t{#t} or @t{#f}.
+
+@deffn {Scheme Procedure} unread? message
+@end deffn
+Is this message unread? I.e., either new or not seen? Returns @t{#t} or @t{#f}.
+
+@deffn {Scheme Procedure} list? message
+@end deffn
+Is this a mailing-list message? Returns @t{#t} or @t{#f}.
+
+@deffn {Scheme Procedure} personal? message
+@end deffn
+Is this a personal message? Returns @t{#t} or @t{#f}.
+
+@deffn {Scheme Procedure} calendar? message
+@end deffn
+Does this message have a calendar invitation? Returns @t{#t} or @t{#f}.
+
+@subsection Miscellaneous
+
+@deffn {Scheme Procedure} last-change message
+@end deffn
+Get the time of the message's last change (through @t{mu}), or @t{#f} if there
+is none. The time is expressed the data as the number of seconds since epoch,
+@t{time_t}.
+
+For example:
+@lisp
+(last-change msg)
+=> 1703336567
+@end lisp
+
+@deffn {Scheme Procedure} priority message
+@end deffn
+Get the message's priority. This is symbol, either @t{high}, @t{normal} or
+@t{low}, or @t{#f} if not present.
+
+For example:
+@lisp
+(priority msg)
+=> normal
+@end lisp
+
+@deffn {Scheme Procedure} size message
+@end deffn
+Get the message's size in bytes.
+
+For example:
+@lisp
+(size msg)
+=> 2815
+@end lisp
+
+@deffn {Scheme Procedure} language message
+@end deffn
+Get the ISO-639-1 language code for message's primary language or @t{#f} if not
+found. This is available only if @t{mu} was built with CLD2 support, see
+@command{mu info}. The language code is represented as a symbol, such as @t{en},
+@t{nl} or @t{fi}.
+
+For example:
+@lisp
+(language msg)
+=> en
+@end lisp
+
+@c @deffn {Scheme Procedure} sexp message
+@c @end deffn
+@c Get the message's s-expression.
+
+@c @t{mu} caches an s-expression for each message; this was designed as an
+@c optimization for @t{mu4e}, but @t{mu-scm} uses it as well. The details of this
+@c s-expression (a property-list) are internal to @t{mu} (so do not base your next
+@c billion-dollar startup on it), but it can be useful for development and
+@c debugging.
+
+@node Helpers
+@section Helpers
+
+@deffn {Scheme Procedure} iso-date->time-t iso-date
+@end deffn
+Convert some ISO-8601 compatible time-point (assuming UTC) to a
+seconds-since-epoch @t{time_t} value. The ISO date is expected to be in the
+@t{strftime}-format @t{%F%T}, or any prefix thereof. Non-numerical characters
+are ignored.
+
+@deffn {Scheme Procedure} time-t->iso-date time-t
+@end deffn
+Convert a @t{time_t} value to an ISO-8601 compatible string (assuming UTC). If
+@t{time_t} is @t{#f}, return an empty string of the same length.
+
+@node GNU Free Documentation License
+@appendix GNU Free Documentation License
+
+@include fdl.texi
+
+@page
+@node Procedure Index
+@unnumbered Procedure Index
+
+This is an alphabetical list of all the procedures and macros in @t{mu-scm}.
+
+@printindex fn
+
+@bye

From ef502b77c6fdf5bb688d44d0b975b92ee6e66c81 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 17 Jun 2025 21:34:29 +0300
Subject: [PATCH 304/305] NEWS.org: update for scm

---
 NEWS.org | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/NEWS.org b/NEWS.org
index a5f9fa3dc..bce79ee7e 100644
--- a/NEWS.org
+++ b/NEWS.org
@@ -281,14 +281,20 @@
    - 1.12.12: it now possible to create Emacs bookmarks for both messages
      (default) and queries. See the new variable ~mu4e-emacs-bookmark-policy~.
 
+*** scm
+
+   - 1.12.12: add new guile/scheme binding in ~scm/~. These are to replace the
+     long-deprecated ~guile/~ bindings. For this is all rather new and
+     experimental, but the basics are there.
+
 *** Contributors
 
     Thanks to our contributors - code committers belows, but also to everyone
     who filed tickets, asked questions, answered them etc.
 
-    Babak Farrokhi, Christophe Troestler, Christoph Reichenbach, Daniel Fleischer,
-    David Edmondson, Davide Masserut, Dirk-Jan C. Binnema, Jeremy Sowden,
-    Lin Jian, Martin R. Albrecht, Nacho Barrientos, Nicholas Vollmer,
+    Babak Farrokhi, Christophe Troestler, Christoph Reichenbach, Daniel
+    Fleischer, David Edmondson, Davide Masserut, Dirk-Jan C. Binnema, Jeremy
+    Sowden, Lin Jian, Martin R. Albrecht, Nacho Barrientos, Nicholas Vollmer,
     Nicolas P. Rougier, ramon diaz-uriarte (at Phelsuma), reindert, Ruijie Yu,
     Sean Farley, stardiviner, Tassilo Horn and Thierry Volpiatto
 

From 417c070e274a093d702efb35fc51408175b801fa Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Tue, 24 Jun 2025 18:15:03 +0300
Subject: [PATCH 305/305] build: better handle non-guile build

---
 meson.build  | 2 +-
 mu/mu-cmd.cc | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/meson.build b/meson.build
index 0a5cd583c..80702eb48 100644
--- a/meson.build
+++ b/meson.build
@@ -312,7 +312,7 @@ if not get_option('scm').disabled() and guile_dep.found()
   subdir('scm')
 else
   # dummy-dep.
-  mu_scm_dep = declare_dependency('', required:false)
+  mu_scm_dep = declare_dependency()
 endif
 
 subdir('mu')
diff --git a/mu/mu-cmd.cc b/mu/mu-cmd.cc
index d14c355f4..586ed914c 100644
--- a/mu/mu-cmd.cc
+++ b/mu/mu-cmd.cc
@@ -35,9 +35,9 @@
 #include "message/mu-message.hh"
 #include "message/mu-mime-object.hh"
 
-#if BUILD_GUILE
+#if BUILD_GUILE || BUILD_SCM
 #include "scm/mu-scm.hh"
-#endif/*BUILD_GUILE*/
+#endif/*BUILD_GUILE || BUILD_SCM*/
 
 #include "utils/mu-error.hh"
 #include "utils/mu-utils-file.hh"