diff --git a/RelNotes/2.50.0.adoc b/RelNotes/2.50.0.adoc
index 50e3027..1905c61 100644
--- a/RelNotes/2.50.0.adoc
+++ b/RelNotes/2.50.0.adoc
@@ -17,6 +17,26 @@
 
  * "git fsck" becomes more careful when checking the refs.
 
+ * "git fast-export | git fast-import" learns to deal with commit and
+   tag objects with embedded signatures a bit better.
+
+ * The code paths to check whether a refname X is available (by seeing
+   if another ref X/Y exists, etc.) have been optimized.
+
+ * First step of deprecating and removing merge-recursive.
+
+ * In protocol v2 where the refs advertisement is constrained, we try
+   to tell the server side not to limit the advertisement when there
+   is no specific need to, which has been the source of confusion and
+   recent bugs.  Revamp the logic to simplify.
+
+ * Update meson based build procedure for breaking changes support.
+
+ * Enable -Wunreachable-code for developer builds.
+
+ * Build update.
+   (merge 7c8cd9c158 es/meson-building-docs-requires-perl later to maint).
+
 
 Fixes since v2.49
 -----------------
@@ -30,5 +50,19 @@
    when certain renames are involved.
    (merge 3adba40858 en/merge-process-renames-crash-fix later to maint).
 
+ * Certain "cruft" objects would have never been refreshed when there
+   are multiple cruft packs in the repository, which has been
+   corrected.
+   (merge 08f612ba70 tb/multi-cruft-pack-refresh-fix later to maint).
+
+ * The xdiff code on 32-bit platform misbehaved when an insanely large
+   context size is given, which has been corrected.
+   (merge d39e28e68c rs/xdiff-context-length-fix later to maint).
+
  * Other code cleanup, docfix, build fix, etc.
    (merge 227c4f33a0 ja/doc-block-delimiter-markup-fix later to maint).
+   (merge 2bfd3b3685 ab/decorate-code-cleanup later to maint).
+   (merge 5337daddc7 am/dir-dedup-decl-of-repository later to maint).
+   (merge 554051d691 en/diff-rename-follow-fix later to maint).
+   (merge a18c18b470 en/random-cleanups later to maint).
+   (merge 5af21c9acb hj/doc-rev-list-ancestry-fix later to maint).
diff --git a/git-fast-export.adoc b/git-fast-export.adoc
index 752e4b9..413a527 100644
--- a/git-fast-export.adoc
+++ b/git-fast-export.adoc
@@ -27,17 +27,33 @@
 	Insert 'progress' statements every <n> objects, to be shown by
 	'git fast-import' during import.
 
---signed-tags=(verbatim|warn|warn-strip|strip|abort)::
+--signed-tags=(verbatim|warn-verbatim|warn-strip|strip|abort)::
 	Specify how to handle signed tags.  Since any transformation
-	after the export can change the tag names (which can also happen
-	when excluding revisions) the signatures will not match.
+	after the export (or during the export, such as excluding
+	revisions) can change the hashes being signed, the signatures
+	may become invalid.
 +
 When asking to 'abort' (which is the default), this program will die
 when encountering a signed tag.  With 'strip', the tags will silently
 be made unsigned, with 'warn-strip' they will be made unsigned but a
 warning will be displayed, with 'verbatim', they will be silently
-exported and with 'warn', they will be exported, but you will see a
-warning.
+exported and with 'warn-verbatim' (or 'warn', a deprecated synonym),
+they will be exported, but you will see a warning.  'verbatim' and
+'warn-verbatim' should only be used if you know that no transformation
+affecting tags or any commit in their history will be performed by you
+or by fast-export or fast-import, or if you do not care that the
+resulting tag will have an invalid signature.
+
+--signed-commits=(verbatim|warn-verbatim|warn-strip|strip|abort)::
+	Specify how to handle signed commits.  Behaves exactly as
+	'--signed-tags', but for commits.  Default is 'abort'.
++
+Earlier versions this command that did not have '--signed-commits'
+behaved as if '--signed-commits=strip'.  As an escape hatch for users
+of tools that call 'git fast-export' but do not yet support
+'--signed-commits', you may set the environment variable
+'FAST_EXPORT_SIGNED_COMMITS_NOABORT=1' in order to change the default
+from 'abort' to 'warn-strip'.
 
 --tag-of-filtered-object=(abort|drop|rewrite)::
 	Specify how to handle tags whose tagged object is filtered out.
diff --git a/git-fast-export.html b/git-fast-export.html
index 1a784ee..fd6b4ee 100644
--- a/git-fast-export.html
+++ b/git-fast-export.html
@@ -481,18 +481,36 @@
 <p>Insert <em>progress</em> statements every &lt;n&gt; objects, to be shown by
 <em>git fast-import</em> during import.</p>
 </dd>
-<dt class="hdlist1">--signed-tags=(verbatim|warn|warn-strip|strip|abort)</dt>
+<dt class="hdlist1">--signed-tags=(verbatim|warn-verbatim|warn-strip|strip|abort)</dt>
 <dd>
 <p>Specify how to handle signed tags.  Since any transformation
-after the export can change the tag names (which can also happen
-when excluding revisions) the signatures will not match.</p>
+after the export (or during the export, such as excluding
+revisions) can change the hashes being signed, the signatures
+may become invalid.</p>
 <div class="paragraph">
 <p>When asking to <em>abort</em> (which is the default), this program will die
 when encountering a signed tag.  With <em>strip</em>, the tags will silently
 be made unsigned, with <em>warn-strip</em> they will be made unsigned but a
 warning will be displayed, with <em>verbatim</em>, they will be silently
-exported and with <em>warn</em>, they will be exported, but you will see a
-warning.</p>
+exported and with <em>warn-verbatim</em> (or <em>warn</em>, a deprecated synonym),
+they will be exported, but you will see a warning.  <em>verbatim</em> and
+<em>warn-verbatim</em> should only be used if you know that no transformation
+affecting tags or any commit in their history will be performed by you
+or by fast-export or fast-import, or if you do not care that the
+resulting tag will have an invalid signature.</p>
+</div>
+</dd>
+<dt class="hdlist1">--signed-commits=(verbatim|warn-verbatim|warn-strip|strip|abort)</dt>
+<dd>
+<p>Specify how to handle signed commits.  Behaves exactly as
+<em>--signed-tags</em>, but for commits.  Default is <em>abort</em>.</p>
+<div class="paragraph">
+<p>Earlier versions this command that did not have <em>--signed-commits</em>
+behaved as if <em>--signed-commits=strip</em>.  As an escape hatch for users
+of tools that call <em>git fast-export</em> but do not yet support
+<em>--signed-commits</em>, you may set the environment variable
+<em>FAST_EXPORT_SIGNED_COMMITS_NOABORT=1</em> in order to change the default
+from <em>abort</em> to <em>warn-strip</em>.</p>
 </div>
 </dd>
 <dt class="hdlist1">--tag-of-filtered-object=(abort|drop|rewrite)</dt>
@@ -798,7 +816,7 @@
 </div>
 <div id="footer">
 <div id="footer-text">
-Last updated 2025-02-14 21:38:14 -0800
+Last updated 2025-03-29 17:09:47 +0900
 </div>
 </div>
 </body>
diff --git a/git-fast-import.adoc b/git-fast-import.adoc
index 58a2eaa..7b107f5 100644
--- a/git-fast-import.adoc
+++ b/git-fast-import.adoc
@@ -431,13 +431,22 @@
 Create or update a branch with a new commit, recording one logical
 change to the project.
 
+////
+Yes, it's intentional that the 'gpgsig' line doesn't have a trailing
+`LF`; the definition of `data` has a byte-count prefix, so it
+doesn't need an `LF` to act as a terminator (and `data` also already
+includes an optional trailing `LF?` just in case you want to include
+one).
+////
+
 ....
 	'commit' SP <ref> LF
 	mark?
 	original-oid?
 	('author' (SP <name>)? SP LT <email> GT SP <when> LF)?
 	'committer' (SP <name>)? SP LT <email> GT SP <when> LF
-	('encoding' SP <encoding>)?
+	('gpgsig' SP <alg> LF data)?
+	('encoding' SP <encoding> LF)?
 	data
 	('from' SP <commit-ish> LF)?
 	('merge' SP <commit-ish> LF)*
@@ -505,6 +514,15 @@
 See ``Date Formats'' above for the set of supported formats, and
 their syntax.
 
+`gpgsig`
+^^^^^^^^
+
+The optional `gpgsig` command is used to include a PGP/GPG signature
+that signs the commit data.
+
+Here <alg> specifies which hashing algorithm is used for this
+signature, either `sha1` or `sha256`.
+
 `encoding`
 ^^^^^^^^^^
 The optional `encoding` command indicates the encoding of the commit
diff --git a/git-fast-import.html b/git-fast-import.html
index 09c360e..6dbaa69 100644
--- a/git-fast-import.html
+++ b/git-fast-import.html
@@ -998,7 +998,8 @@
         original-oid?
         ('author' (SP &lt;name&gt;)? SP LT &lt;email&gt; GT SP &lt;when&gt; LF)?
         'committer' (SP &lt;name&gt;)? SP LT &lt;email&gt; GT SP &lt;when&gt; LF
-        ('encoding' SP &lt;encoding&gt;)?
+        ('gpgsig' SP &lt;alg&gt; LF data)?
+        ('encoding' SP &lt;encoding&gt; LF)?
         data
         ('from' SP &lt;commit-ish&gt; LF)?
         ('merge' SP &lt;commit-ish&gt; LF)*
@@ -1078,6 +1079,17 @@
 </div>
 </div>
 <div class="sect3">
+<h4 id="_gpgsig"><code>gpgsig</code></h4>
+<div class="paragraph">
+<p>The optional <code>gpgsig</code> command is used to include a PGP/GPG signature
+that signs the commit data.</p>
+</div>
+<div class="paragraph">
+<p>Here &lt;alg&gt; specifies which hashing algorithm is used for this
+signature, either <code>sha1</code> or <code>sha256</code>.</p>
+</div>
+</div>
+<div class="sect3">
 <h4 id="_encoding"><code>encoding</code></h4>
 <div class="paragraph">
 <p>The optional <code>encoding</code> command indicates the encoding of the commit
@@ -2547,7 +2559,7 @@
 </div>
 <div id="footer">
 <div id="footer-text">
-Last updated 2025-02-14 21:38:14 -0800
+Last updated 2025-03-29 17:09:47 +0900
 </div>
 </div>
 </body>
diff --git a/git-log.html b/git-log.html
index 550dfcc..242da4b 100644
--- a/git-log.html
+++ b/git-log.html
@@ -1437,7 +1437,7 @@
 <div class="content">
 <pre>                E
                  \
-                  G---H---I---J
+              C---G---H---I---J
                                \
                                 L--M</pre>
 </div>
@@ -4405,7 +4405,7 @@
 </div>
 <div id="footer">
 <div id="footer-text">
-Last updated 2025-02-14 21:38:14 -0800
+Last updated 2025-02-15 14:38:14 +0900
 </div>
 </div>
 </body>
diff --git a/git-merge.html b/git-merge.html
index 57f1d8b..0c3b97e 100644
--- a/git-merge.html
+++ b/git-merge.html
@@ -1261,6 +1261,12 @@
 <dd>
 <p>Deprecated synonym for <code>find-renames=</code><em>&lt;n&gt;</em>.</p>
 </dd>
+<dt class="hdlist1">no-renames</dt>
+<dd>
+<p>Turn off rename detection. This overrides the <code>merge.renames</code>
+configuration variable.
+See also <a href="git-diff.html">git-diff(1)</a> <code>--no-renames</code>.</p>
+</dd>
 <dt class="hdlist1">subtree[=&lt;path&gt;]</dt>
 <dd>
 <p>This option is a more advanced form of <em>subtree</em> strategy, where
@@ -1292,7 +1298,7 @@
 </div>
 <div class="paragraph">
 <p>The <em>recursive</em> strategy takes the same options as <em>ort</em>.  However,
-there are three additional options that <em>ort</em> ignores (not documented
+there are two additional options that <em>ort</em> ignores (not documented
 above) that are potentially useful with the <em>recursive</em> strategy:</p>
 </div>
 <div class="dlist">
@@ -1310,12 +1316,6 @@
 specifically uses <code>diff-algorithm=histogram</code>, while <code>recursive</code>
 defaults to the <code>diff.algorithm</code> config setting.</p>
 </dd>
-<dt class="hdlist1">no-renames</dt>
-<dd>
-<p>Turn off rename detection. This overrides the <code>merge.renames</code>
-configuration variable.
-See also <a href="git-diff.html">git-diff(1)</a> <code>--no-renames</code>.</p>
-</dd>
 </dl>
 </div>
 </dd>
@@ -1718,7 +1718,7 @@
 </div>
 <div id="footer">
 <div id="footer-text">
-Last updated 2025-02-14 21:38:14 -0800
+Last updated 2025-02-15 14:38:14 +0900
 </div>
 </div>
 </body>
diff --git a/git-pull.html b/git-pull.html
index 7f09e8e..c26d5c3 100644
--- a/git-pull.html
+++ b/git-pull.html
@@ -1592,6 +1592,12 @@
 <dd>
 <p>Deprecated synonym for <code>find-renames=</code><em>&lt;n&gt;</em>.</p>
 </dd>
+<dt class="hdlist1">no-renames</dt>
+<dd>
+<p>Turn off rename detection. This overrides the <code>merge.renames</code>
+configuration variable.
+See also <a href="git-diff.html">git-diff(1)</a> <code>--no-renames</code>.</p>
+</dd>
 <dt class="hdlist1">subtree[=&lt;path&gt;]</dt>
 <dd>
 <p>This option is a more advanced form of <em>subtree</em> strategy, where
@@ -1623,7 +1629,7 @@
 </div>
 <div class="paragraph">
 <p>The <em>recursive</em> strategy takes the same options as <em>ort</em>.  However,
-there are three additional options that <em>ort</em> ignores (not documented
+there are two additional options that <em>ort</em> ignores (not documented
 above) that are potentially useful with the <em>recursive</em> strategy:</p>
 </div>
 <div class="dlist">
@@ -1641,12 +1647,6 @@
 specifically uses <code>diff-algorithm=histogram</code>, while <code>recursive</code>
 defaults to the <code>diff.algorithm</code> config setting.</p>
 </dd>
-<dt class="hdlist1">no-renames</dt>
-<dd>
-<p>Turn off rename detection. This overrides the <code>merge.renames</code>
-configuration variable.
-See also <a href="git-diff.html">git-diff(1)</a> <code>--no-renames</code>.</p>
-</dd>
 </dl>
 </div>
 </dd>
@@ -1887,7 +1887,7 @@
 </div>
 <div id="footer">
 <div id="footer-text">
-Last updated 2025-02-14 21:38:14 -0800
+Last updated 2025-02-15 14:38:14 +0900
 </div>
 </div>
 </body>
diff --git a/git-rebase.html b/git-rebase.html
index 9374344..948e02f 100644
--- a/git-rebase.html
+++ b/git-rebase.html
@@ -1649,6 +1649,12 @@
 <dd>
 <p>Deprecated synonym for <code>find-renames=</code><em>&lt;n&gt;</em>.</p>
 </dd>
+<dt class="hdlist1">no-renames</dt>
+<dd>
+<p>Turn off rename detection. This overrides the <code>merge.renames</code>
+configuration variable.
+See also <a href="git-diff.html">git-diff(1)</a> <code>--no-renames</code>.</p>
+</dd>
 <dt class="hdlist1">subtree[=&lt;path&gt;]</dt>
 <dd>
 <p>This option is a more advanced form of <em>subtree</em> strategy, where
@@ -1680,7 +1686,7 @@
 </div>
 <div class="paragraph">
 <p>The <em>recursive</em> strategy takes the same options as <em>ort</em>.  However,
-there are three additional options that <em>ort</em> ignores (not documented
+there are two additional options that <em>ort</em> ignores (not documented
 above) that are potentially useful with the <em>recursive</em> strategy:</p>
 </div>
 <div class="dlist">
@@ -1698,12 +1704,6 @@
 specifically uses <code>diff-algorithm=histogram</code>, while <code>recursive</code>
 defaults to the <code>diff.algorithm</code> config setting.</p>
 </dd>
-<dt class="hdlist1">no-renames</dt>
-<dd>
-<p>Turn off rename detection. This overrides the <code>merge.renames</code>
-configuration variable.
-See also <a href="git-diff.html">git-diff(1)</a> <code>--no-renames</code>.</p>
-</dd>
 </dl>
 </div>
 </dd>
@@ -2496,7 +2496,7 @@
 </div>
 <div id="footer">
 <div id="footer-text">
-Last updated 2025-02-25 15:22:04 -0800
+Last updated 2025-03-26 16:41:02 +0900
 </div>
 </div>
 </body>
diff --git a/git-replay.html b/git-replay.html
index a6e21d0..8792ffe 100644
--- a/git-replay.html
+++ b/git-replay.html
@@ -1266,7 +1266,7 @@
 <div class="content">
 <pre>                E
                  \
-                  G---H---I---J
+              C---G---H---I---J
                                \
                                 L--M</pre>
 </div>
@@ -1912,7 +1912,7 @@
 </div>
 <div id="footer">
 <div id="footer-text">
-Last updated 2025-02-14 21:38:14 -0800
+Last updated 2025-02-15 14:38:14 +0900
 </div>
 </div>
 </body>
diff --git a/git-rev-list.html b/git-rev-list.html
index 3c790d6..1b56a3c 100644
--- a/git-rev-list.html
+++ b/git-rev-list.html
@@ -1304,7 +1304,7 @@
 <div class="content">
 <pre>                E
                  \
-                  G---H---I---J
+              C---G---H---I---J
                                \
                                 L--M</pre>
 </div>
@@ -2989,7 +2989,7 @@
 </div>
 <div id="footer">
 <div id="footer-text">
-Last updated 2025-02-14 21:38:14 -0800
+Last updated 2025-02-15 14:38:14 +0900
 </div>
 </div>
 </body>
diff --git a/git-shortlog.html b/git-shortlog.html
index c02f1bd..7cef6da 100644
--- a/git-shortlog.html
+++ b/git-shortlog.html
@@ -1359,7 +1359,7 @@
 <div class="content">
 <pre>                E
                  \
-                  G---H---I---J
+              C---G---H---I---J
                                \
                                 L--M</pre>
 </div>
@@ -1565,7 +1565,7 @@
 </div>
 <div id="footer">
 <div id="footer-text">
-Last updated 2025-02-14 21:38:14 -0800
+Last updated 2025-02-15 14:38:14 +0900
 </div>
 </div>
 </body>
diff --git a/merge-strategies.adoc b/merge-strategies.adoc
index 93822eb..59f5ae3 100644
--- a/merge-strategies.adoc
+++ b/merge-strategies.adoc
@@ -82,6 +82,11 @@
 rename-threshold=<n>;;
 	Deprecated synonym for `find-renames=<n>`.
 
+no-renames;;
+	Turn off rename detection. This overrides the `merge.renames`
+	configuration variable.
+	See also linkgit:git-diff[1] `--no-renames`.
+
 subtree[=<path>];;
 	This option is a more advanced form of 'subtree' strategy, where
 	the strategy makes a guess on how two trees must be shifted to
@@ -107,7 +112,7 @@
 strategy.
 +
 The 'recursive' strategy takes the same options as 'ort'.  However,
-there are three additional options that 'ort' ignores (not documented
+there are two additional options that 'ort' ignores (not documented
 above) that are potentially useful with the 'recursive' strategy:
 
 patience;;
@@ -121,11 +126,6 @@
 	specifically uses `diff-algorithm=histogram`, while `recursive`
 	defaults to the `diff.algorithm` config setting.
 
-no-renames;;
-	Turn off rename detection. This overrides the `merge.renames`
-	configuration variable.
-	See also linkgit:git-diff[1] `--no-renames`.
-
 resolve::
 	This can only resolve two heads (i.e. the current branch
 	and another branch you pulled from) using a 3-way merge
diff --git a/rev-list-options.adoc b/rev-list-options.adoc
index 9d020e3..1c403c1 100644
--- a/rev-list-options.adoc
+++ b/rev-list-options.adoc
@@ -642,7 +642,7 @@
 -----------------------------------------------------------------------
 		E
 		 \
-		  G---H---I---J
+	      C---G---H---I---J
 			       \
 				L--M
 -----------------------------------------------------------------------
