@@ -91,8 +91,9 @@ deprecations 1.3 and 1.4 announced, so if your test suite runs clean on
 Two things that check will not catch: four removals 1.4 never warned
 about (three raise on contact, the fourth only warns), and one that
 changes results silently — ``name == "John Smith"`` is now ``False``.
+Later 2.x releases add a few breaks of their own.
 `Migrating from HumanName <https://nameparser.readthedocs.io/en/latest/migrate.html>`__
-covers both, and translates a v1 customization into the new API whenever
+covers all of them, and translates a v1 customization into the new API whenever
 that's convenient for you.
 
 See the `release log <https://nameparser.readthedocs.io/en/latest/release_log.html>`__
 
@@ -81,12 +81,17 @@ itself cannot be stored:
     'MD PhD'
 
 That has held since 1.4.0. A credential whose words are not in the
-default vocabulary is reached by adding those words, not the phrase:
+default vocabulary is reached by adding those words, not the phrase.
+After a comma the defaults already read an unlisted all-caps run (see
+:ref:`all-caps-credentials`), so the difference shows at the end of a
+name:
 
 .. doctest::
 
+    >>> parse("John Smith LEED AP").suffix
+    ''
     >>> lex = Lexicon.default().add(suffix_acronyms={"leed", "ap"})
-    >>> Parser(lexicon=lex).parse("John Smith, LEED AP").suffix
+    >>> Parser(lexicon=lex).parse("John Smith LEED AP").suffix
     'LEED AP'
 
 Removing works the same way, and drops the word from recognition:
 
@@ -655,9 +655,9 @@ P3. Rationale: connective words ("y", "of the") bind name words into
     after it to the mixed-case rule rather than to the one-case fork,
     so a bare Latin capital there reads as an initial while its
     lowercase spelling joins — the one shape in which the name's OWN
-    words read differently in its two one-case spellings. So "JUAN
-    NÉE JR Y LOPEZ" reads middle "NÉE JR Y" with its "Y" an initial,
-    while "juan née jr y lopez" reads family "jr y lopez" with its
+    words read differently in its two one-case spellings. So "DR.
+    NÉE JUAN Y LOPEZ" reads middle "JUAN Y" with its "Y" an initial,
+    while "dr. née juan y lopez" reads family "juan y lopez" with its
     own "y" joined. A clause's words are read as they always were,
     and that is not an exception to this: such a letter still takes
     a different tag in the two spellings, so its case repair can
 
@@ -675,11 +675,33 @@ grep your fixtures for, with what 1.4 read:
   Berg``.
 - ``"Josep Carod i Rovira"`` (2.4) — ``i`` links two surnames in a
   mixed-case name: 1.4 read middle ``Carod i``, last ``Rovira``.
-- ``"John Smith X.Y.Z."`` (2.4) — an unlisted dotted credential after a
-  full name: 1.4 read last ``X.Y.Z.``, middle ``Smith``. ``"Jack
+- ``"Jane Smith N.C.C."`` (2.4) — an unlisted dotted credential after a
+  full name: 1.4 read last ``N.C.C.``, middle ``Smith``. ``"Jack
   X.Y.Z."`` is unchanged.
-- ``capitalize()`` on ``"john smith md"`` (2.4) — 1.4 wrote ``M.D.``;
-  ``md`` left the exceptions map and now repairs as an acronym.
+- ``"Jane Smith, LEED AP"`` (2.4) — an unlisted all-caps credential
+  after a comma: 1.4 read first ``LEED``, middle ``AP``, last ``Jane
+  Smith``.
+- ``"Eric H. Holder Jr. Attorney General"`` and ``"Eric H. Holder, Jr.,
+  Attorney General"`` (2.4) — a title after a credential is a title:
+  1.4 read middle ``H. Holder Jr. Attorney``, last ``General``, and
+  suffix ``Jr., Attorney General``.
+- ``"Steven Hardman, RN - CRNA"`` (2.4) — a credential after a comma
+  starts a run of credentials: 1.4 read first ``RN``, middle ``-``,
+  last ``Steven Hardman``, suffix ``CRNA``.
+- ``"John van der Berg Prof."`` (2.4) — 1.4 read last ``van der Berg
+  Prof.``.
+- ``"Liam Ó Murchú"`` (2.4) — the Irish particles ``Ó``, ``Ní`` and
+  ``Ua`` join the surname: 1.4 read middle ``Ó``, last ``Murchú``.
+- ``"Herra Väinö Johansson"`` (2.4) — salutations in Finnish,
+  Icelandic, Malay and other languages are titles: 1.4 read first
+  ``Herra``, middle ``Väinö``.
+- ``"山田 ﾀﾛｳ"`` (2.4) — halfwidth katakana reads as katakana: 1.4 read
+  first ``山田``, last ``ﾀﾛｳ``.
+- ``capitalize()`` on ``"john smith md"``, ``"john smith phd"`` and
+  ``"JANE DOE MBA"`` (2.4) — 1.4 wrote ``M.D.``, ``Ph.D.`` and ``Mba``;
+  credentials are now written the usual way (``MD``, ``PhD``, ``MBA``).
+- ``initials()`` on ``"john e smith"`` (2.4) — 1.4 gave ``j. s.``; a
+  one-letter connective read as an initial now contributes one.
 
 .. doctest::
 
@@ -700,9 +722,36 @@ grep your fixtures for, with what 1.4 read:
     'van der Berg'
     >>> HumanName("Josep Carod i Rovira").last
     'Carod i Rovira'
-    >>> HumanName("John Smith X.Y.Z.").suffix
-    'X.Y.Z.'
+    >>> HumanName("Jane Smith N.C.C.").suffix
+    'N.C.C.'
+    >>> HumanName("Jane Smith, LEED AP").suffix
+    'LEED AP'
+    >>> holder = HumanName("Eric H. Holder Jr. Attorney General")
+    >>> holder.title, holder.last, holder.suffix
+    ('Attorney General', 'Holder', 'Jr.')
+    >>> HumanName("Eric H. Holder, Jr., Attorney General").title
+    'Attorney General'
+    >>> HumanName("Steven Hardman, RN - CRNA").suffix
+    'RN - CRNA'
+    >>> HumanName("John van der Berg Prof.").last
+    'van der Berg'
+    >>> HumanName("Liam Ó Murchú").last
+    'Ó Murchú'
+    >>> HumanName("Herra Väinö Johansson").title
+    'Herra'
+    >>> HumanName("山田 ﾀﾛｳ").last
+    '山田'
     >>> md = HumanName("john smith md")
     >>> md.capitalize(force=True)
     >>> str(md)
     'John Smith MD'
+    >>> phd = HumanName("john smith phd")
+    >>> phd.capitalize()
+    >>> str(phd)
+    'John Smith PhD'
+    >>> mba = HumanName("JANE DOE MBA")
+    >>> mba.capitalize()
+    >>> str(mba)
+    'Jane Doe MBA'
+    >>> HumanName("john e smith").initials()
+    'j. e. s.'
@@ -56,8 +56,8 @@ Results
    continuation of the token before it
    — within one merged piece the tag is role-blind and every view
    joins the pair with a space, so it renders "Ph. D." as one
-   credential and ``Smith, Ph. D. Smith`` gives ``first_list``
-   ``['Ph. D.']``, and since #436 it also spans the pieces of one
+   piece in whatever role it lands — ``Ph. D., Jr.`` gives
+   ``last_list`` ``['Ph. D.']`` — and since #436 it also spans the pieces of one
    SUFFIX entry, the run of post-nominals the writer wrote without a
    comma — "MD PhD" — which is the half the suffix view alone reads
    and joins with a space instead of ", "). Every other tag is namespaced
 
@@ -46,7 +46,9 @@ Every piece of each is optional:
 A title written with a period (``Prof.``) is also read at the end of a
 name in forms 1 and 3 and at the end of the given name in form 2;
 written bare there (``Prof``), it is a name word, because many title
-words are also surnames.
+words are also surnames — unless a credential stands before it, which
+starts a run of post-nominals and titles (``John Smith PhD Prof`` reads
+title ``Prof``; see :ref:`trailing-titles`).
 
 The last two differ in what the comma is doing. In form 2 it separates
 the family name from the rest, so the family name comes first; in form
@@ -146,7 +148,7 @@ name to its full vocabulary set:
    * - :mod:`Suffixes <nameparser.config.suffixes>`
      - adjacent suffixes
      - ``suffix``
-     - ``John Smith PhD MD`` → ``PhD, MD``
+     - ``John Smith PhD MD`` → ``PhD MD``
    * - :mod:`Bound given names <nameparser.config.bound_given_names>`
      - the following word
      - ``given``
@@ -885,17 +887,21 @@ Because this is structural rather than vocabulary-driven, emptying
 At the end of a name
 ~~~~~~~~~~~~~~~~~~~~
 
-Only the leading slot INFERS. At the back of a name a period-marked
-word is read by vocabulary alone: a word the parser already knows as a
-post-nominal or as a title reads as one, and an unfamiliar abbreviation
-stays a name word.
+Only the leading slot INFERS. At the back of a name a word ending in a
+single period is read by vocabulary alone: a word the parser already
+knows as a post-nominal or as a title reads as one, and an unfamiliar
+abbreviation stays a name word. A word of two or more period-separated
+chunks is the exception, read as a credential by its shape (see
+:ref:`dotted-credentials`).
 
 .. doctest::
 
     >>> parse("John Smith Prof.").title
     'Prof.'
     >>> parse("John Smith Xyz.").family
     'Xyz.'
+    >>> parse("Jane Smith N.C.C.").suffix
+    'N.C.C.'
 
 That asymmetry is deliberate. The title vocabulary holds hundreds of
 words that are ordinary surnames — ``king``, ``judge``, ``bishop`` —
@@ -904,6 +910,16 @@ names their family field. The period is what separates the two: a
 trailing title word written *without* one is a name word, so
 ``parse("Mary Jane King").family`` is ``'King'``.
 
+A credential in front changes that. It starts a run of post-nominals
+and titles that lasts to the end of the name, so a bare title word
+behind it is a title:
+
+.. doctest::
+
+    >>> john_prof = parse("John Smith PhD Prof")
+    >>> (john_prof.title, john_prof.suffix)
+    ('Prof', 'PhD')
+
 Comparing names
 ----------------
 
 
@@ -594,9 +594,13 @@ class Lexicon:
     #: default list:
     #: :data:`~nameparser.config.suffixes.SUFFIX_WORDS`.
     suffix_words: frozenset[str] = frozenset()
-    #: Subset of suffix_acronyms counted as suffixes only when written
-    #: WITH periods -- their bare forms are common surnames ("ma",
-    #: "do": "Jack Ma" keeps his family name). Full default list:
+    #: Subset of suffix_acronyms whose bare forms are also common
+    #: surnames ("ma", "do"). Written with periods one is a suffix
+    #: outright; written bare, capitals decide in a mixed-case name
+    #: ("Jack MA" is the credential, "Jack Ma" keeps his family name)
+    #: and otherwise the word counts as a suffix only where a name
+    #: word is left beside it ("John Smith ma"), rules.md#S2. Full
+    #: default list:
     #: :data:`~nameparser.config.suffixes.SUFFIX_ACRONYMS_AMBIGUOUS`.
     suffix_acronyms_ambiguous: frozenset[str] = frozenset()
     #: Family-name particles that chain onto the following piece
@@ -888,7 +892,9 @@ def _edit(self, op: str, entries: Mapping[str, Iterable[str]]) -> Lexicon:
                 raise TypeError(
                     "capitalization_exceptions holds key->value pairs; "
                     "use dataclasses.replace(lexicon, "
-                    "capitalization_exceptions={...}) instead of "
+                    "capitalization_exceptions=(*lexicon."
+                    "capitalization_exceptions, ('key', 'KEY'))) "
+                    "instead of "
                     f"{op}()"
                 )
             if name not in _VOCAB_FIELDS: