Fix three defects in the new ambiguity emitters

All three are mine, from the previous round, found by review.

1. Only one SUFFIX_OR_FAMILY survived per segment. ambiguous_pick was a
   single slot the peel loop overwrote, so "John Smith MA JD" made two
   coin-flips and reported one -- defeating the point of reporting.
   Collect them instead. The sibling SUFFIX_OR_NICKNAME emitter already
   did this correctly, so it was an oversight, not a design.

2. The detail string was wrong under two of three name orders. The
   comment claimed the unpeeled piece "stays the last name piece -- the
   family name under every order"; _name_positions maps a two-piece
   name to [FAMILY, GIVEN] under FAMILY_FIRST, so it is the GIVEN name
   there and the text said otherwise. Ambiguity.detail is public, so
   this misinformed callers. Now reads the role back after assignment.

3. Origin resolution was quadratic, and so was the check it fed.
   Resolving each ambiguity's offset rescanned every token, and
   ParsedName.__post_init__'s subset check then did `tok not in
   self.tokens` per referenced token -- O(ambiguities x tokens) twice
   over. Reachable because the new closer sweep can emit one ambiguity
   per delimiter character. Bisect over the (already sorted) token
   starts, and hash the token tuple once:

       ') ' * N     before      after
       N=1600       182 ms      12 ms
       N=3200        --         25 ms   (linear)

   The subset check was pre-existing but only became reachable at scale
   once ambiguities started carrying tokens.

Verified: differential harness 486 names, 2 intentional diffs, 0
unexplained. The review separately confirmed the 8147ac6 peel change
against 304 generated shapes under all three name orders -- 86 changed,
all 86 from disagreeing with v1 to matching it, 0 regressions.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: derek73

nameparser/_pipeline/_assign.py

@@ -124,9 +124,12 @@ def _assign_main(seg_idx: int, state: ParseState,
     # every piece is a strict suffix (v1's are_suffixes tail rule, with
     # the roman-numeral special: a final roman numeral after a
     # non-initial piece is a suffix)
-    # (piece, reading taken, reading declined) when the peel had to
-    # resolve a bare ambiguous acronym; both directions are guesses
-    ambiguous_pick: tuple[tuple[int, ...], str, str] | None = None
+    # every bare ambiguous acronym the peel had to resolve -- one
+    # coin-flip each, in either direction, so this collects rather than
+    # overwrites. The role each ends up with is read back after
+    # assignment, since which role "not peeled" means depends on
+    # name_order.
+    ambiguous_picks: list[tuple[int, ...]] = []
     k = len(rest)
     while k > 0:
         piece = pieces[rest[k - 1]]
@@ -151,15 +154,15 @@ def _assign_main(seg_idx: int, state: ParseState,
         bare_ambiguous = (len(piece) == 1
                           and "vocab:suffix-ambiguous" in tokens[piece[0]].tags)
         if bare_ambiguous and k - 1 >= 2:
-            ambiguous_pick = (piece, "a suffix", "an ordinary surname")
+            ambiguous_picks.append(piece)
             k -= 1
             continue
         if bare_ambiguous and k >= 2:
-            # not peeled, so it stays the last name piece -- the family
-            # name under every order. (k < 2 means it is the only piece
-            # left and lands in the given position, which is not the
-            # fork this reports.)
-            ambiguous_pick = (piece, "a family name", "a post-nominal")
+            # not peeled, so it stays the last NAME piece -- which role
+            # that is depends on name_order, so the detail reads it back
+            # below. (k < 2 means it is the only piece left, which is
+            # not the fork this reports.)
+            ambiguous_picks.append(piece)
         break
     name_pieces, suffix_pieces = rest[:k], rest[k:]
     if not name_pieces and suffix_pieces:
@@ -170,13 +173,19 @@ def _assign_main(seg_idx: int, state: ParseState,
         _set_roles(tokens, pieces[piece_idx], roles[pos])
     for piece_idx in suffix_pieces:
         _set_roles(tokens, pieces[piece_idx], Role.SUFFIX)
-    if ambiguous_pick is not None:
-        piece, taken, declined = ambiguous_pick
+    for piece in ambiguous_picks:
+        token = tokens[piece[0]]
+        # every pick was assigned a role just above; the fallback only
+        # keeps the wording sane if a future path reports before then
+        role = token.role.value if token.role is not None else "name"
+        taken, declined = (
+            ("a suffix", "a name part") if token.role is Role.SUFFIX
+            else (f"a {role} name", "a post-nominal"))
         ambiguities.append(PendingAmbiguity(
             AmbiguityKind.SUFFIX_OR_FAMILY,
-            f"{tokens[piece[0]].text!r} written without periods is both "
-            f"a post-nominal and a surname; read as {taken} rather than "
-            f"{declined}",
+            f"{token.text!r} written without periods is both a "
+            f"post-nominal and an ordinary name; read as {taken} "
+            f"rather than {declined}",
             tuple(piece)))
     # leading ambiguous particle read as a name (#121 surfaced)
     if name_pieces:

nameparser/_pipeline/_tokenize.py

@@ -18,6 +18,7 @@
 """
 from __future__ import annotations
 
+import bisect
 import dataclasses
 import re
 
@@ -97,11 +98,23 @@ def tokenize(state: ParseState) -> ParseState:
     # offset back out of its detail string. An offset inside a masked
     # region belongs to no token; those keep an empty tuple, which the
     # kind's contract already allows.
+    # Bisect rather than rescan: the closer sweep can emit one
+    # ambiguity per delimiter character, so a linear scan per ambiguity
+    # is quadratic on pathological input (') ' * 1600 spent 180ms here,
+    # against 9ms before the sweep existed). Spans are non-overlapping
+    # and sorted just above, so the candidate is the last token whose
+    # start is <= the offset.
+    starts = [t.span.start for t in tokens]
+
+    def _containing(offset: int) -> tuple[int, ...]:
+        i = bisect.bisect_right(starts, offset) - 1
+        if i >= 0 and offset < tokens[i].span.end:
+            return (i,)
+        return ()
+
     ambiguities = tuple(
-        a if a.origin is None else dataclasses.replace(
-            a, indices=tuple(
-                i for i, t in enumerate(tokens)
-                if t.span.start <= a.origin < t.span.end))
+        a if a.origin is None
+        else dataclasses.replace(a, indices=_containing(a.origin))
         for a in state.ambiguities)
     return dataclasses.replace(state, tokens=tuple(tokens),
                                comma_offsets=tuple(sorted(commas)),

nameparser/_types.py

@@ -369,12 +369,18 @@ def __post_init__(self) -> None:
                     f"offset {prev_end}"
                 )
             prev_end = tok.span.end
+        # Hash once rather than rescanning the tuple per referenced
+        # token: a name can carry an ambiguity per token (a string of
+        # stray delimiters does), and the linear form made construction
+        # quadratic in their product. Set membership uses the same value
+        # equality the tuple scan did -- Token is frozen and hashable.
+        known = set(self.tokens) if self.ambiguities else ()
         for amb in self.ambiguities:
             for tok in amb.tokens:
-                # `in` uses Token's value equality, not identity: this
-                # only guarantees a value-equal token exists in
+                # membership is by Token's value equality, not identity:
+                # this only guarantees a value-equal token exists in
                 # self.tokens, not that `tok` IS one of those objects.
-                if tok not in self.tokens:
+                if tok not in known:
                     raise ValueError(
                         f"Ambiguity token {tok.text!r} is not a subset of "
                         f"this ParsedName's tokens"

tests/v2/test_parser.py

@@ -211,3 +211,25 @@ def test_delimited_ambiguous_acronym_reports_suffix_or_nickname() -> None:
     assert [t.text for t in n.ambiguities[0].tokens] == ["JD"]
     # the unambiguous one decided on vocabulary, so it is not a guess
     assert parse("Andrew Perkins (MBA)").ambiguities == ()
+
+
+def test_every_ambiguous_acronym_in_a_name_is_reported() -> None:
+    # one coin-flip per acronym: a single-slot record dropped all but
+    # the last, which defeats the point of reporting at all
+    n = parse("John Smith MA JD")
+    assert n.suffix == "MA, JD"
+    assert [a.kind for a in n.ambiguities] == \
+        [AmbiguityKind.SUFFIX_OR_FAMILY] * 2
+    assert sorted(t.text for a in n.ambiguities for t in a.tokens) == \
+        ["JD", "MA"]
+
+
+def test_ambiguous_acronym_detail_names_the_role_it_got() -> None:
+    # the unpeeled piece is the last NAME piece, which is the family
+    # name only under GIVEN_FIRST -- FAMILY_FIRST puts it in given, so
+    # the detail has to follow the role actually assigned
+    fam_first = Parser(policy=Policy(name_order=FAMILY_FIRST))
+    n = fam_first.parse("Jack MA")
+    assert (n.family, n.given) == ("Jack", "MA")
+    assert "given name" in n.ambiguities[0].detail
+    assert "family name" not in n.ambiguities[0].detail