nameparser 2.5.0__tar.gz → 2.6.0__tar.gz

{nameparser-2.5.0/nameparser.egg-info → nameparser-2.6.0}/PKG-INFO

@@ -1,12 +1,11 @@
 Metadata-Version: 2.4
 Name: nameparser
-Version: 2.5.0
+Version: 2.6.0
 Summary: A simple Python module for parsing human names into their individual components.
 Author-email: Derek Gulbranson <derek73@gmail.com>
-License: LGPL
+License-Expression: LGPL-2.1-or-later
 Keywords: names,parser
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL)
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
@@ -36,12 +35,12 @@ nameparser parses human names into seven fields — title, given, middle,
 family, suffix, nickname, maiden. Results are immutable, configuration is
 composable, and locale packs are opt-in.
 
-📣 **nameparser 2.5 is out.** It reads junior and senior written in 45
-languages (``Antonio Pavlović mlađi``), keeps a title written before a
-family comma out of the surname (``Dr. Smith, John``), reads Chinese and
-Japanese credential and office words (``田中社長``), and gives a lone first
-name followed by V, I or X its last name back (``Malcolm X``). The `release
-log <https://nameparser.readthedocs.io/en/latest/release_log.html>`__ has
+📣 **nameparser 2.6 is out.** It keeps surnames that earlier releases
+read as credentials (``Luo Si``, ``Maria de Sa``, ``Ram Bahadur B.K.``),
+reads ``Wm`` and ``Md`` as the given names they abbreviate, recognizes more credentials after a comma
+(``John Smith, MBChB``), and adds an opt-in reading for names with two
+family names (``Gabriel García Márquez``). The `release log
+<https://nameparser.readthedocs.io/en/latest/release_log.html>`__ has
 the details.
 
 Chinese, Japanese and Korean names written in their own scripts are read

{nameparser-2.5.0 → nameparser-2.6.0}/README.rst

@@ -7,12 +7,12 @@ nameparser parses human names into seven fields — title, given, middle,
 family, suffix, nickname, maiden. Results are immutable, configuration is
 composable, and locale packs are opt-in.
 
-📣 **nameparser 2.5 is out.** It reads junior and senior written in 45
-languages (``Antonio Pavlović mlađi``), keeps a title written before a
-family comma out of the surname (``Dr. Smith, John``), reads Chinese and
-Japanese credential and office words (``田中社長``), and gives a lone first
-name followed by V, I or X its last name back (``Malcolm X``). The `release
-log <https://nameparser.readthedocs.io/en/latest/release_log.html>`__ has
+📣 **nameparser 2.6 is out.** It keeps surnames that earlier releases
+read as credentials (``Luo Si``, ``Maria de Sa``, ``Ram Bahadur B.K.``),
+reads ``Wm`` and ``Md`` as the given names they abbreviate, recognizes more credentials after a comma
+(``John Smith, MBChB``), and adds an opt-in reading for names with two
+family names (``Gabriel García Márquez``). The `release log
+<https://nameparser.readthedocs.io/en/latest/release_log.html>`__ has
 the details.
 
 Chinese, Japanese and Korean names written in their own scripts are read

{nameparser-2.5.0 → nameparser-2.6.0}/nameparser/_config_shim.py

@@ -1048,6 +1048,7 @@ class Constants:
         from nameparser.config.maiden_markers import MAIDEN_MARKERS
         from nameparser.config.suffixes import GLUED_HONORIFICS
         from nameparser.config.surnames import KOREAN_SURNAMES
+        from nameparser.config.titles import AFTER_GIVEN_TITLES
         # Every set field and every capitalization_exceptions key passes
         # _v1_matchable BEFORE any set algebra below: an entry v1 could
         # never match, or one Lexicon folds to empty (#582), is dropped
@@ -1160,8 +1161,8 @@ class Constants:
                 particles=particles,
                 # complement translation: v1 marks the never-given subset;
                 # v2 marks the may-be-given subset. The trailing union keeps
-                # a config v1 accepted: particles.py asserts its own data has
-                # no word in both NON_GIVEN_NAME_PARTICLES and
+                # a config v1 accepted: the vocabulary build refuses a
+                # shipped word in both NON_GIVEN_NAME_PARTICLES and
                 # BOUND_GIVEN_NAMES, but nothing stops a caller adding one at
                 # runtime, and v1 then lets the bound rule win (leading "dos
                 # Santos Silva" parses first="dos Santos"). Treating such a
@@ -1207,6 +1208,14 @@ class Constants:
                 # stops mattering, the same rule ambiguous_acronyms gets
                 # against suffix_acronyms above.
                 honorific_tails=GLUED_HONORIFICS & suffix_words,
+                # likewise no v1 manager: the salutations ending a given
+                # part are 2.6 behavior (#835), so they ride in the
+                # snapshot only, and the one v1 knob that reaches them is
+                # deleting the title. Lexicon does not check this pair
+                # (classify reads a member only where it is a title too),
+                # so the intersection is kept for `_snapshot() ==
+                # Lexicon.default()` legibility, as conjunctions_ambiguous'.
+                after_given_titles=AFTER_GIVEN_TITLES & titles,
                 # TupleManager is dict[str, object] (v1 parity: values were
                 # never statically str-typed); every real entry is a str,
                 # same assumption _DelimiterManager's sentinel lookup makes.

{nameparser-2.5.0 → nameparser-2.6.0}/nameparser/_facade.py

@@ -700,10 +700,11 @@ class HumanName:
             if got or not words or not all(self._is_particle(w)
                                            for w in words):
                 return got
-            # rules/R3: "except the particles of a part whose every
-            # word is one, which are not acting as particles there"
-            # -- nothing survived
-            # the filter, so the whole group is particles. The
+            # rules/R3: "A part whose every word is a particle initials
+            # those particles: they are not acting as particles there"
+            # -- the Except bullet this quote opens; nothing survived
+            # the filter, so the whole group is particles
+            # (decisions/R3). The
             # facade's twin of the core's
             # UNJOINED_TAG. NOT pinned against it by the case runners,
             # which compare the seven role fields only (Case carries

{nameparser-2.5.0 → nameparser-2.6.0}/nameparser/_lexicon.py

@@ -25,7 +25,7 @@ _VOCAB_FIELDS = (
     "titles", "given_name_titles", "suffix_acronyms", "suffix_words",
     "suffix_acronyms_ambiguous", "particles", "particles_ambiguous",
     "conjunctions", "conjunctions_ambiguous", "bound_given_names",
-    "maiden_markers", "surnames", "honorific_tails",
+    "maiden_markers", "surnames", "honorific_tails", "after_given_titles",
 )
 
 #: (marker, base, why) triples. Each marker QUALIFIES how entries of
@@ -55,21 +55,19 @@ _VOCAB_FIELDS = (
 #:   as a tail would peel a period-gated word off a real name), and
 #:   nothing needs the acronym half: the shipped tails are CJK
 #:   honorifics, which are words.
-#:   The same relation is asserted a second time in config/suffixes.py,
-#:   over the raw GLUED_HONORIFICS/SUFFIX_WORDS constants at
-#:   import. The two are not redundant in the way they look: that one
-#:   is an `assert`, stripped under `python -O`, while the check here
-#:   raises unconditionally -- so under -O this is what still holds the
-#:   SHIPPED vocabulary to the invariant, as it is the only thing that
-#:   ever held a caller's own.
+#:   The shipped vocabulary holds the relation by construction: its
+#:   build puts a word in GLUED_HONORIFICS only through an `attached`
+#:   property on a word reading (tools/vocab/build.py). The check here
+#:   is the only thing that holds a caller's own.
 #:
-#: Two fields are deliberately NOT here and have no check of their own.
+#: Three fields are deliberately NOT here and have no check of their own.
 #: given_name_titles -- see the note in __post_init__ for why every
 #: attempt at one rejected working configurations. conjunctions_ambiguous
 #: -- an orphan is never consulted because both the classify fork and
 #: its ambiguity emitter require the base entry as well, so an orphan
 #: decides nothing, and AGENTS.md's invariants rule guards harm, not
-#: no-ops.
+#: no-ops. after_given_titles -- the same: classify tags a word from it
+#: only where the word is in titles too, so an orphan is never read.
 _SUBSET_FIELDS = (
     ("particles_ambiguous", "particles",
      "an orphan emits a spurious particle-or-given ambiguity"),
@@ -692,6 +690,15 @@ class Lexicon:
     #: vocabulary is. Full default list:
     #: :data:`~nameparser.config.suffixes.GLUED_HONORIFICS`.
     honorific_tails: frozenset[str] = frozenset()
+    #: Salutations that read as a title where one ENDS the given part
+    #: after a family comma, written bare: "Doe, Jane Mrs" reads title
+    #: "Mrs" where an office or rank word there stays a middle name
+    #: ("Doe, John King"), rules/H8. A period-marked title word reads as
+    #: a title there whether listed here or not (rules/H5). Entries need
+    #: not also be in ``titles``; one that is not is never consulted.
+    #: Full default list:
+    #: :data:`~nameparser.config.titles.AFTER_GIVEN_TITLES`.
+    after_given_titles: frozenset[str] = frozenset()
     #: Lowercase word -> case mask used by capitalized(): the word's
     #: own letters and digits, each in the case it takes ("phd" ->
     #: "PhD"), laid over the word as written, so the one entry
@@ -739,9 +746,10 @@ class Lexicon:
         # the expensive one -- three working configurations broken
         # across two attempts. Do not add a third.
         #
-        # The v2 form of particles.py's NON_GIVEN_NAME_PARTICLES-disjoint-
-        # from-BOUND_GIVEN_NAMES assertion. That module guards its own
-        # data at import; this guards vocabulary a caller supplies.
+        # The v2 form of the vocabulary build's check that a bound given
+        # name which is also a particle may be given (tools/vocab/build.py,
+        # check 9). The build guards the shipped data; this guards
+        # vocabulary a caller supplies.
         contradictory = (
             self.bound_given_names & self.particles) - self.particles_ambiguous
         if contradictory:
@@ -947,7 +955,8 @@ def _default_lexicon() -> Lexicon:
         SUFFIX_WORDS,
     )
     from nameparser.config.surnames import KOREAN_SURNAMES
-    from nameparser.config.titles import GIVEN_NAME_TITLES, TITLES
+    from nameparser.config.titles import (
+        AFTER_GIVEN_TITLES, GIVEN_NAME_TITLES, TITLES)
 
     # every vocabulary constant is a frozenset since #293, so each one
     # feeds its strictly-typed frozenset[str] field as it stands -- and
@@ -975,6 +984,7 @@ def _default_lexicon() -> Lexicon:
         maiden_markers=MAIDEN_MARKERS,
         surnames=KOREAN_SURNAMES,
         honorific_tails=GLUED_HONORIFICS,
+        after_given_titles=AFTER_GIVEN_TITLES,
         # pass canonical pair-tuples so this strictly-typed call site never
         # feeds a Mapping to the tuple-annotated field; __post_init__
         # still tolerates a Mapping at runtime for interactive use

{nameparser-2.5.0 → nameparser-2.6.0}/nameparser/_parser.py

@@ -41,7 +41,7 @@ class Parser:
     vocabulary DECLINES, so a locale pack's surnames always win where
     they match; returning None declines in turn and the token stays
     whole. Two promises narrow when one is supplied (the first is
-    rules/A1's Accepted clause):
+    rules/A1's Accepted bullet "The one exception to totality"):
     parse-totality gains its one exception -- an exception raised by
     the segmenter propagates, because a user-supplied callable's own
     error is a user-code error, not a content error -- and this Parser
@@ -215,7 +215,7 @@ class Parser:
             dropped = set(state.dropped)
             # Force the role BEFORE the entry pass: it keys on
             # Role.SUFFIX, and a bare value's sub-parse reads its words
-            # as a name ('MD PhD' is a title and a family there), so
+            # as a name ('RA PhD' is a title and a family there), so
             # inside the sub-parse it joined nothing. The sub-parse's
             # tags are KEPT, "joined" included: a within-piece mark
             # (the Ph. D. merge) is role-blind and right for every

{nameparser-2.5.0 → nameparser-2.6.0}/nameparser/_pipeline/_assemble.py

@@ -3,7 +3,7 @@
 Consumes: tokens (all roles set), dropped, ambiguities (by index;
 one carrying ``field_tail`` is worded from its word's final role,
 #626), and segments, for the part a withdrawn connective report's
-letter ends (rules/P3, #721).
+letter ends (rules/P8, #721).
 Produces: a validated ParsedName -- the constructor re-checks every
 invariant (span order/bounds, ambiguity subset), so a pipeline bug
 that would produce an invalid result dies HERE, not in a renderer
@@ -116,7 +116,7 @@ def assemble(state: ParseState) -> ParsedName:
                 and any(t.role in (Role.SUFFIX, Role.TITLE)
                         for t in materialized)):
             continue
-        # rules/P3: "unless no name word of its part stands to its
+        # rules/P8: "unless no name word of its part stands to its
         # right" -- nothing after the letter in its segment, or only
         # suffixes, titles, a maiden clause or a nickname: it connects
         # nothing, so the report goes (#721). Asked here for the reason

{nameparser-2.5.0 → nameparser-2.6.0}/nameparser/_pipeline/_assign.py

@@ -15,7 +15,7 @@ in the Han/Hiragana/Katakana repertoire the #272 kana license shares
 across pieces); token/piece tags; Lexicon only through tags already
 applied by classify (plus the leading-title period rule).
 
-Implements rules H2, H4, H5, H6, N3, O4, O5, S10, W4, and P6 after a family comma,
+Implements rules H2, H4, H5, H6, H7, H8, N3, O4, O5, S10, W4, and P6 after a family comma,
 of docs/design/rules/,
 each cited at its code below. Ports v1's assignment loops.
 NO_COMMA (per name_order):
@@ -78,8 +78,8 @@ group's head: the comma's own decision, #544's anchored members and
 not counted here. And
 at the one site that places a LONE name word, GIVEN_OR_FAMILY for the
 field the convention picked (O5, #449) and TITLE_OR_NAME for the two
-shapes where the doubt is whether a word is a title instead (H4,
-#491): the peel leaving one title-vocabulary word standing, and a
+shapes where the doubt is whether a word is a title instead (H4 and
+H7, #491): the peel leaving one title-vocabulary word standing, and a
 joined unit carrying title vocabulary.
 """
 from __future__ import annotations
@@ -339,8 +339,8 @@ def _assign_main(seg_idx: int, state: ParseState,
     # reads that word as the family name" (history: decisions/N3)
     # -- v1's p_len == 1 counted
     # the WHOLE segment before any title peeling -- 'Xyz. (Bud) Smith'
-    # has two pieces, so the title peel wins and Smith stays the given
-    # name (pinned live 2026-07-17)
+    # has two pieces, so the title peel wins and this rule declines;
+    # H1 then names Smith the family (rules/N3's title bullet)
     # The nickname scan sits LAST in the test: it is a generator, which
     # every interpreter resumes once per token (seven call events on
     # the reference name), and only a one-piece segment ever reads its
@@ -478,18 +478,20 @@ def _assign_main(seg_idx: int, state: ParseState,
         # Jr.' and "'Smitty' Jones Jr." ARE this convention -- and the
         # count comes off the peel rather than off name_pieces, which
         # is what keeps the carve-out above out of these branches.
-        # Title vocabulary in the unit makes the doubt H4's (is the
-        # WORD a title), anything else O5's (which FIELD it took), so
-        # only the second reads `field_undecided`.
+        # Title vocabulary in the unit makes the doubt H4's or H7's (is
+        # the WORD a title), anything else O5's (which FIELD it took),
+        # so only the second reads `field_undecided`.
         if peeled.names == 1 and not resolved.by_script:
             # rules/H4: "an input whose only remaining name word
             # after the title peel is itself title vocabulary reads
             # that word as the name by convention and reports
-            # `title-or-name`" (history: decisions/H4), and H4's
-            # join clause, stated at rules/O5 as its exception --
-            # one branch, its detail naming a field only in the join
-            # shape ('John of Prince', 'Attorney General of
-            # Minnesota'), where the unit is more than the title word.
+            # `title-or-name`" (history: decisions/H4), and
+            # rules/H7: "one name UNIT of more than one word carrying
+            # title vocabulary reports `title-or-name`" (history:
+            # decisions/H7, decisions/H4 #518) -- one branch, its detail
+            # naming a field only in H7's shape ('John of Prince',
+            # 'Attorney General of Minnesota'), where the unit is more
+            # than the title word.
             # A LONE title word never reaches here ('Dr.', 'Prince of
             # Wales'): the leading-title peel took the whole name.
             if any("vocab:title" in tokens[i].tags for i in head):
@@ -635,7 +637,7 @@ def _inside_a_credential_run(seg: Sequence[Sequence[int]],
                              tokens: list[WorkToken], given_at: int,
                              k: int, end: int,
                              ambiguities: list[PendingAmbiguity]) -> bool:
-    """rules/P6's third exception for the run `seg[k:end]`: a
+    """rules/P9 (P6's third exception) for the run `seg[k:end]`: a
     run assign read as post-nominals, with a credential read in
     front of it and another behind, stands INSIDE the credential run
     assign read whole rather than ending the name, so it keeps that
@@ -1257,7 +1259,11 @@ def assign(state: ParseState) -> ParseState:
             candidates = [k for k in range(n, len(pieces))
                           if k == n
                           or not reads_as_a_suffix(k, frozenset())]
-            kept = trailing_titles(candidates, pieces, ptags, tokens)
+            # rules/H8: "the word joins the title field, and the given
+            # part reads as it would without it" -- a bare salutation
+            # chains here as a period-marked title does
+            kept = trailing_titles(candidates, pieces, ptags, tokens,
+                                   salutations=True)
             walkable = frozenset(candidates)
             titled_idx = frozenset(candidates[kept:])
             for k in titled_idx:
@@ -1459,8 +1465,8 @@ def assign(state: ParseState) -> ParseState:
         # Berg'), or where everything behind it is post-nominal, which
         # leaves no family word to address -- H3's concern, by a
         # stricter test than H3's one-word give-back, so this is not
-        # `leading_titles` ('MD PhD Jr., John' keeps family 'MD', where
-        # 'MD PhD Jr. John' reads title 'MD'). A dual is a title wherever
+        # `leading_titles` ('RA PhD Jr., John' keeps family 'RA', where
+        # 'RA PhD Jr. John' reads title 'RA'). A dual is a title wherever
         # a name word follows it ('Rev. Sr. Smith, Mary').
         # `is_title_piece` is H5's vocabulary read, so the two slots that
         # refuse the shape agree on what a title word is.
@@ -1487,10 +1493,10 @@ def assign(state: ParseState) -> ParseState:
                    and "particle" not in tokens[fam_pieces[lead][0]].tags):
                 _set_roles(tokens, fam_pieces[lead], Role.TITLE)
                 lead += 1
-        # rules/P2: a particle "joins the words after it into one
-        # name part" -- so a particle that is suffix vocabulary too
-        # (vd, mc) with a name piece behind it in this part heads
-        # that name, and is not peeled from between two family words
+        # rules/P9: "a particle that is also suffix vocabulary heads
+        # the name word behind it" -- with a name piece behind it in
+        # this part (vd, mc), it heads that name, as P2's join does,
+        # and is not peeled from between two family words
         # (#573: 'SMITH VD MA, JOHN', where the uniform case left the
         # chain stopped before VD; 'SMITH VD JR, JOHN', a suffix word
         # behind it, keeps suffix 'VD JR'). Read here because only

{nameparser-2.5.0 → nameparser-2.6.0}/nameparser/_pipeline/_classify.py

@@ -17,7 +17,11 @@ honorific_tails, which script_segment consumes upstream; and, since
 which decide whether an UNLISTED dotted or all-caps token joins the
 ambiguous credential class by SHAPE (#516) -- the all-caps half here
 only under CapsSuffixes.EVERYWHERE, the default's part after a comma
-being tagged by `_comma.decide` when group binds it (#613). is_initial also consults
+being tagged by `_comma.decide` when group binds it (#613); and
+Policy.extra_suffix_delimiters, with the built-in semicolon
+(_vocab.delimiter_cores), so a word after the first comma with a
+delimiter glued to it is tagged as the word without it (rules/C10).
+is_initial also consults
 the _policy module's _NO_INITIALS constant. It is named apart from the
 fields above because it is not CONFIGURATION -- no Lexicon or Policy
 carries it and no caller can change it -- and not because it decides
@@ -26,6 +30,7 @@ nothing: the tags this stage writes do vary by it ('씨.' is not tagged
 
 Tags emitted -- stable (API): "particle", "conjunction", "initial";
 namespaced (unstable): "vocab:title", "vocab:given-title",
+"vocab:after-given-title",
 "vocab:suffix", "vocab:suffix-word", "vocab:suffix-ambiguous",
 "vocab:particle-ambiguous", "vocab:bound-given", "vocab:maiden-marker",
 "vocab:maiden-marker-cont"; and, in a namespace of its own,
@@ -62,7 +67,8 @@ from nameparser._pipeline._state import (
 )
 from nameparser._types import AmbiguityKind, Role
 from nameparser._pipeline._vocab import (
-    _INITIAL, caps_shape_candidate, composed_len, is_initial, is_one_case,
+    BUILTIN_SUFFIX_DELIMITERS, _INITIAL, caps_shape_candidate, composed_len,
+    delimiter_cores, glued_stem, is_initial, is_one_case, is_paired_initials,
     period_joined_vocab, suffix_as_written, tag_marker_runs,
 )
 from nameparser._pipeline._pieces import own_words
@@ -71,11 +77,11 @@ from nameparser._pipeline._pieces import own_words
 
 
 # rules/S2: "a trailing word of the suffix vocabulary reads as a
-# suffix — generational forms and credential acronyms alike, and an
-# ambiguous acronym written with its periods, one after each
-# letter or one after each of two or more letter chunks, counts
+# suffix — generational forms and credential acronyms alike" -- and
+# rules/S3: "an ambiguous acronym written with its periods, one after
+# each letter or one after each of two or more letter chunks, counts
 # unambiguously; a single trailing period is the abbreviation shape
-# any word can wear and does not" -- and: "a
+# any word can wear and does not" -- and rules/S4: "a
 # bare ambiguous acronym is consumed only when the name has words to
 # spare"
 def _tags_for(token: WorkToken, n: str, state: ParseState,
@@ -123,6 +129,10 @@ def _tags_for(token: WorkToken, n: str, state: ParseState,
         tags.add("vocab:title")
     if n in lex.given_name_titles:
         tags.add("vocab:given-title")
+    # rules/H8: "the word joins the title field" -- tagged only where the
+    # word is a title too, so an entry outside `titles` is inert
+    if n in lex.after_given_titles and n in lex.titles:
+        tags.add("vocab:after-given-title")
     if suffix_as_written(n, token.text, lex):
         tags.add("vocab:suffix")
     if n in lex.suffix_words:
@@ -136,12 +146,12 @@ def _tags_for(token: WorkToken, n: str, state: ParseState,
         tags.add("particle")
         if n in lex.particles_ambiguous:
             tags.add("vocab:particle-ambiguous")
-    # rules/P3: "a single-letter connective reads as an initial
+    # rules/P8: "a single-letter connective reads as an initial
     # where the writing says so: written as a bare Latin capital in a
     # name that is not written wholly in one case, or — in a name
     # written wholly in one case, where nothing says so — where the
     # letter is one the vocabulary marks as reading both ways"
-    # (#383/#479; history: decisions/P3)
+    # (#383/#479; history: decisions/P8)
     # one letter as the writer sees it: a decomposed 'й' is two code
     # points (#665), so non-ASCII text is counted composed, after the
     # C-level tests have declined everything else
@@ -204,8 +214,8 @@ def _tags_for(token: WorkToken, n: str, state: ParseState,
     # title as a whole ('Lt.Gov.', and by the ANY rule 'Mr.Smith');
     # else ANY suffix chunk makes it a suffix ('JD.CPA'). Title wins
     # (v1's continue). The third and fourth are 2.4's by-shape halves
-    # (#516; rules/S9: "An unlisted word joins the ambiguous class
-    # (S4) by SHAPE where the caller asks for it") and reach only a
+    # (#516; rules/S9: "joins the ambiguous class (S4) by SHAPE, in
+    # the positions each shape is admitted") and reach only a
     # token NO vocabulary claimed: a dotted token of two or more
     # alphabetic chunks, and -- where its switch is on -- an unlisted
     # all-caps word. They are an `elif` chain
@@ -255,7 +265,16 @@ def _tags_for(token: WorkToken, n: str, state: ParseState,
             # shipped ambiguous vocabulary carries no periods, so
             # nothing default changes.
             tags.add(SHAPE_ACRONYM_TAG)
-            if state.policy.unlisted_dotted_suffixes:
+            # rules/S3: "Paired initials are the exception, as C5 defines
+            # them, in a script that writes capitals" -- the shape
+            # tag alone, as with the switch off, so the trailing slots
+            # read them as a name word and report the fork; the comma
+            # restores the class tag where C5 reads them
+            # (decisions/S3 (#864)). Cased: a text with no case mapping
+            # is in a script without capitals ('พ.บ.').
+            if (state.policy.unlisted_dotted_suffixes
+                    and not (is_paired_initials(token.text)
+                             and token.text.upper() != token.text.lower())):
                 tags.add(AMBIGUOUS_ACRONYM_TAG)
         elif (state.policy.unlisted_caps_suffixes is CapsSuffixes.EVERYWHERE
                 and token.role is None
@@ -289,6 +308,16 @@ def _tags_for(token: WorkToken, n: str, state: ParseState,
     return frozenset(tags)
 
 
+#: The tags of a word that joins the word after it, which a delimiter
+#: glued to the word stands between (rules/C10). A particle's are among
+#: them though it also attaches backward (rules/P6): kept, it chained
+#: forward across the delimiter ('Berg, de; Smith' read family 'Berg de;
+#: Smith'), and blocking the forward joins alone would guard every site
+#: that reads the tag (decisions/C10).
+_JOINING_TAGS = frozenset({"particle", "conjunction",
+                           "vocab:particle-ambiguous", "vocab:bound-given"})
+
+
 def classify(state: ParseState) -> ParseState:
     # One fold per token, shared by the marker pass and the vocabulary
     # tags -- the shape suffix_as_written already asks for ("n is
@@ -325,15 +354,47 @@ def classify(state: ParseState) -> ParseState:
     whole_one_case = one_case and (
         len(own) == len(state.tokens)
         or is_one_case([t.text for t in state.tokens]))
+    # rules/C10: "the word keeps the delimiter in its text and reads as
+    # it would without it" -- tagged as the word without it ('MD;' as
+    # 'MD'), so every reading that asks a word's vocabulary asks the
+    # stem's; only where the delimiter "stands after the first comma",
+    # a semicolon before it being a word (decisions/C10, D15)
+    readers = list(state.tokens)
+    stemmed: set[int] = set()
+    if state.comma_offsets:
+        policy_cores = state.policy.extra_suffix_delimiters
+        cores = (BUILTIN_SUFFIX_DELIMITERS if not policy_cores
+                 else delimiter_cores(policy_cores))
+        first = state.comma_offsets[0]
+        for i, t in enumerate(state.tokens):
+            text = t.text
+            if t.span.start < first:
+                continue
+            for core in cores:
+                if core in text:
+                    stem = glued_stem(text, cores)
+                    if stem is not None:
+                        readers[i] = copy_with(t, text=stem)
+                        folded[i] = _normalize(stem)
+                        stemmed.add(i)
+                    break
     tokens = tuple(
         copy_with(
-            t, tags=_tags_for(t, folded[i], state, marker_tags.get(i),
+            t, tags=_tags_for(readers[i], folded[i], state, marker_tags.get(i),
                               one_case_own=one_case and i < clause_at
                               and t.role is None, one_case=one_case,
                               letter_one_case=whole_one_case or (
                                   one_case and i < clause_at
                                   and t.role is None)))
         for i, t in enumerate(state.tokens))
+    # A word with a delimiter glued to it joins no neighbour across the
+    # delimiter, so the stem's joining tags stay off it: 'y;' is no
+    # connective to the word after it (rules/C10: "no join, maiden
+    # clause or connective reaches across it")
+    if stemmed:
+        tokens = tuple(
+            copy_with(t, tags=t.tags - _JOINING_TAGS) if i in stemmed else t
+            for i, t in enumerate(tokens))
     # Delimited content whose vocabulary cannot settle it: extract's
     # escape sends an UNambiguous suffix straight through ("(MBA)" ->
     # suffix) and keeps everything else as a nickname, so an AMBIGUOUS
@@ -372,14 +433,14 @@ def classify(state: ParseState) -> ParseState:
         # hands classify tokens it did not build; no such path exists
         # today. `conjunctions` is the clause doing real work: it keeps
         # an orphan marker (a conjunctions_ambiguous entry no longer in
-        # conjunctions) inert rather than reported (decisions/P3).
+        # conjunctions) inert rather than reported (decisions/P8).
         # `i < clause_at and token.role is None` mirrors the fork's own
         # "own words" test above, for the same reason (rules/P3): a
         # clause's words were never eligible for the fork, so they must
         # never be eligible to report either. Emitted at the decision
         # site (mechanisms.md#AMBIGUITY-AT-THE-DECISION-SITE), per
         # token -- 'e and e e' emits twice; assemble withdraws the
-        # report on a letter no name word follows (rules/P3, #721).
+        # report on a letter no name word follows (rules/P8, #721).
         if (one_case and "initial" in token.tags
                 and folded[i] in state.lexicon.conjunctions_ambiguous
                 and folded[i] in state.lexicon.conjunctions