@@ -0,0 +1,29 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT license.
+
+"""Shared letter units for PUZZLED clues and puzzle encodings."""
+
+import unicodedata
+
+
+def _is_combining_mark(char: str) -> bool:
+    return unicodedata.category(char).startswith("M")
+
+
+def _letter_units(word: str) -> list[str]:
+    """
+    Split a canonically composed word into letters with their combining marks attached.
+
+    Args:
+        word (str): The word or puzzle sequence to split.
+
+    Returns:
+        list[str]: One unit per letter, including any following combining marks.
+    """
+    letters: list[str] = []
+    for char in unicodedata.normalize("NFC", word):
+        if letters and _is_combining_mark(char):
+            letters[-1] += char
+        else:
+            letters.append(char)
+    return letters
@@ -15,25 +15,47 @@
 """
 
 import logging
-import re
 import threading
 import unicodedata
 from collections.abc import Iterator
 from dataclasses import dataclass
 from typing import Any
 
+import regex
+
+from pyrit.converter.puzzled._text import _is_combining_mark, _letter_units
+
 logger = logging.getLogger(__name__)
 
-# The one tokenizer used for candidate selection, placeholder ordering and replacement
-# (always through ``_iter_words``). Requiring word boundaries keeps candidates to whole
-# words, so a token embedded in an alphanumeric blob (the "h" of "h4ck3r") is never
-# selected. ``[^\W\d_]`` admits Unicode letters, so words such as "Schädlinge" or Cyrillic
-# words are candidates too; ``_iter_words`` then drops matches that are not all letters.
-_WORD_PATTERN = re.compile(r"\b[^\W\d_]+\b")
+# Scan complete tokens before rejecting numbers, underscores, joiners, or leading marks.
+# Rejecting a whole run prevents a mark from exposing a maskable prefix of an invalid token.
+_WORD_PATTERN = regex.compile(r"[\p{L}\p{M}\p{N}_\u200c\u200d]+")
+
+
+def _letter_count(word: str) -> int:
+    """
+    Return the number of letter units used by the puzzle builders.
+
+    Combining marks stay attached to their letters, so pointed "שָׁלוֹם" has four units
+    despite being written with seven code points. Canonically equivalent spellings use
+    the same units.
+
+    Args:
+        word (str): A word yielded by ``_iter_words``.
+
+    Returns:
+        int: The count of letters with their attached combining marks.
+    """
+    return len(_letter_units(word))
 
 
-def _is_word_continuation(char: str) -> bool:
-    return char in ("\u200c", "\u200d") or unicodedata.category(char).startswith("M")
+@dataclass(frozen=True)
+class _Word:
+    """A whole word of the prompt and the span it occupies."""
+
+    text: str
+    start: int
+    end: int
 
 
 def _word_key(word: str) -> str:
@@ -44,43 +66,42 @@ def _word_key(word: str) -> str:
     so two spellings are either the same masked word everywhere or different words
     everywhere. For ASCII it equals ``str.lower``.
 
+    Case folding alone is not stable across normalization forms: composed "café" and
+    decomposed "cafe\u0301" fold to different strings, which would make them two words and let
+    the alphabetical tie-break in ``_rank_candidates`` choose differently for the same prompt.
+    Normalize before folding to put marks in canonical order, and again afterward because
+    folding can produce decomposed text. This also keeps Greek case variants equivalent.
+
     Args:
         word (str): A word from the prompt or from the caller.
 
     Returns:
-        str: The case-folded word.
+        str: The case-folded word in composed form.
     """
-    return word.casefold()
+    return unicodedata.normalize("NFC", unicodedata.normalize("NFD", word).casefold())
 
 
-def _iter_words(prompt: str) -> Iterator[re.Match[str]]:
+def _iter_words(prompt: str) -> Iterator[_Word]:
     """
     Yield the maskable words of ``prompt``.
 
-    ``[^\\W\\d_]`` still admits characters that are numeric without being decimal digits,
-    such as "²" or "¼", so a match is kept only if every character is a letter. "abc²" is
-    therefore rejected whole, like "h4ck3r", rather than becoming a candidate.
-
-    ``\\w`` does not cover combining marks (Devanagari vowel signs, Hebrew and Arabic vowel
-    points, or the accents of NFD-decomposed text) or zero-width joiners and non-joiners.
-    These characters can continue a word even though ``\\b`` treats them as boundaries.
-    A match that touches one of them is only a fragment, so it is skipped as well.
+    Scan maximal runs of letters, combining marks, numbers, underscores, and joiners.
+    Keep only runs that start with a letter and contain only letters and attached marks.
+    This accepts pointed scripts and NFD accents without exposing fragments of tokens
+    such as "h4ck3r", "abc²", or a marked word followed by a digit or underscore.
+    Words containing joiners remain unmaskable.
 
     Args:
         prompt (str): The prompt to scan.
 
     Yields:
-        re.Match[str]: Each whole-word match, in order of appearance.
+        _Word: Each whole word, in order of appearance.
     """
     for match in _WORD_PATTERN.finditer(prompt):
-        if not match.group().isalpha():
-            continue
-        start, end = match.span()
-        if start > 0 and _is_word_continuation(prompt[start - 1]):
-            continue
-        if end < len(prompt) and _is_word_continuation(prompt[end]):
+        word = match.group()
+        if not word[0].isalpha() or not all(char.isalpha() or _is_combining_mark(char) for char in word):
             continue
-        yield match
+        yield _Word(text=word, start=match.start(), end=match.end())
 
 
 # Part-of-speech label used when spaCy is unavailable or the word was caller-supplied.
@@ -163,7 +184,7 @@ class MaskedWord:
     @property
     def clue(self) -> str:
         """The deterministic clue for this word, e.g. ``"9-letter noun"``."""
-        return f"{len(self.text)}-letter {self.pos}"
+        return f"{_letter_count(self.text)}-letter {self.pos}"
 
 
 @dataclass(frozen=True)
@@ -269,7 +290,7 @@ def _rank_candidates(
     Returns:
         list[str]: Distinct candidate words (as they appear in the prompt) in priority order.
     """
-    tokens = [match.group() for match in _iter_words(prompt)]
+    tokens = [word.text for word in _iter_words(prompt)]
     seen: set[str] = set()
     unique: list[str] = []
     for token in tokens:
@@ -292,7 +313,7 @@ def tier(word: str) -> int:
             return 3
         return 4
 
-    return sorted(unique, key=lambda w: (tier(w), -len(w), _word_key(w)))
+    return sorted(unique, key=lambda w: (tier(w), -_letter_count(w), _word_key(w)))
 
 
 def mask_prompt(
@@ -336,8 +357,8 @@ def mask_prompt(
     # [WORD1] is the leftmost masked word. Candidates come from the same scan, so every
     # chosen word has an entry here.
     first_index: dict[str, int] = {}
-    for match in _iter_words(prompt):
-        first_index.setdefault(_word_key(match.group()), match.start())
+    for word in _iter_words(prompt):
+        first_index.setdefault(_word_key(word.text), word.start)
     ordered = sorted(chosen, key=lambda w: first_index[_word_key(w)])
 
     masked_words: list[MaskedWord] = []
@@ -349,18 +370,17 @@ def mask_prompt(
         placeholders[_word_key(word)] = placeholder
 
     # Replace the word spans of the same scan, looked up by the same key. Every occurrence of
-    # a chosen word is masked whatever its casing, a fragment the scan skipped (next to a
-    # combining mark or joiner) is never masked, and every replaced span has a placeholder.
+    # a chosen word is masked whatever its casing, and every replaced span has a placeholder.
     # Building the result in one pass means an inserted placeholder can never be matched again.
     pieces: list[str] = []
     last_end = 0
-    for match in _iter_words(prompt):
-        placeholder = placeholders.get(_word_key(match.group()))
+    for word in _iter_words(prompt):
+        placeholder = placeholders.get(_word_key(word.text))
         if placeholder is None:
             continue
-        pieces.append(prompt[last_end : match.start()])
+        pieces.append(prompt[last_end : word.start])
         pieces.append(placeholder)
-        last_end = match.end()
+        last_end = word.end
     pieces.append(prompt[last_end:])
 
     return MaskResult(masked_prompt="".join(pieces), masked_words=masked_words)
@@ -15,6 +15,8 @@
 from collections import Counter
 from enum import Enum
 
+from pyrit.converter.puzzled._text import _letter_units
+
 # Eight placement directions for the word search: right, left, down, up, and the four
 # diagonals. Each is a (row_delta, col_delta) step.
 _DIRECTIONS = (
@@ -63,6 +65,7 @@ def _upper_same_length(word: str) -> str:
     ``str.upper`` expands some letters ("ß" becomes "SS", "ﬁ" becomes "FI"), which would make
     an encoded word longer than its clue. It also changes the case-folded spelling of dotless
     "ı" to "i", merging distinct words. Keep a character unchanged when either would happen.
+    Combining marks are retained, even when uppercasing would turn one into a letter.
 
     Args:
         word (str): The word to uppercase.
@@ -71,39 +74,42 @@ def _upper_same_length(word: str) -> str:
         str: The uppercased word, preserving its length and case-folded spelling.
     """
     return "".join(
-        upper if len(upper := char.upper()) == 1 and upper.casefold() == char.casefold() else char for char in word
+        upper if char.isalpha() and len(upper := char.upper()) == 1 and upper.casefold() == char.casefold() else char
+        for char in word
     )
 
 
-def _normalize(words: list[str]) -> list[str]:
+def _normalize(words: list[str]) -> list[list[str]]:
     """
-    Uppercase the words and strip surrounding whitespace.
+    Uppercase the words and split them into canonically composed letter units.
 
     Uppercasing keeps each word's length and case-folded spelling (see ``_upper_same_length``),
-    so every puzzle agrees with both the masker's length clue and its word identity.
+    and combining marks stay attached to their letters. Every puzzle uses the same units as
+    the masker's length clue.
 
     Args:
         words (list[str]): The masked keywords to encode.
 
     Returns:
-        list[str]: Cleaned, uppercased words.
+        list[list[str]]: Cleaned words, each split into letters with attached marks.
 
     Raises:
         ValueError: If ``words`` is empty or any word has no letters after cleaning.
     """
     if not words:
         raise ValueError("At least one word is required to build a puzzle.")
-    cleaned = [_upper_same_length(w.strip()) for w in words]
+    cleaned = [[_upper_same_length(letter) for letter in _letter_units(w.strip())] for w in words]
     if any(not w for w in cleaned):
         raise ValueError("Words must contain at least one non-whitespace character.")
     return cleaned
 
 
 def build_anagram(words: list[str], rng: random.Random) -> str:
     """
-    Concatenate the masked words and shuffle every character into one sequence.
+    Concatenate the masked words and shuffle their letter units into one sequence.
 
-    The model must both unscramble and re-segment the sequence into the original words.
+    Combining marks move with their letters. The model must both unscramble and re-segment
+    the sequence into the original words.
 
     Args:
         words (list[str]): The masked keywords to encode.
@@ -115,17 +121,17 @@ def build_anagram(words: list[str], rng: random.Random) -> str:
     Raises:
         ValueError: If ``words`` is empty or any word has no letters after cleaning.
     """
-    source = "".join(_normalize(words))
-    if len(source) <= 1 or len(set(source)) == 1:
+    letters = [letter for word in _normalize(words) for letter in word]
+    source = "".join(letters)
+    if len(letters) <= 1 or len(set(letters)) == 1:
         return source
 
-    letters = list(source)
     for _ in range(_MAX_ANAGRAM_SHUFFLES):
         rng.shuffle(letters)
         result = "".join(letters)
         if result != source:
             return result
-    return source[1:] + source[0]
+    return "".join(letters[1:] + letters[:1])
 
 
 def crossword_symbol_map(words: list[str]) -> dict[str, str]:
@@ -151,7 +157,7 @@ def crossword_symbol_map(words: list[str]) -> dict[str, str]:
     for word in normalized:
         for letter in set(word):
             words_per_letter[letter] += 1
-    total_frequency = Counter("".join(normalized))
+    total_frequency = Counter(letter for word in normalized for letter in word)
 
     shared = [letter for letter, count in words_per_letter.items() if count >= 2]
     shared.sort(key=lambda letter: (-words_per_letter[letter], -total_frequency[letter], letter))
@@ -177,20 +183,20 @@ def build_crossword(words: list[str]) -> str:
         ValueError: If ``words`` is empty or any word has no letters after cleaning.
     """
     normalized = _normalize(words)
-    mapping = crossword_symbol_map(normalized)
+    mapping = crossword_symbol_map(words)
     lines = []
     for index, word in enumerate(normalized, start=1):
         masked = "".join(mapping.get(letter, letter) for letter in word)
         lines.append(f"{index}. {masked}")
     return "\n".join(lines)
 
 
-def _grid_size(words: list[str]) -> int:
+def _grid_size(words: list[list[str]]) -> int:
     """
     Pick a square grid size large enough to place all words with room to spare.
 
     Args:
-        words (list[str]): The masked keywords to encode.
+        words (list[list[str]]): The masked keywords split into letter units.
 
     Returns:
         int: The side length of the square grid.
@@ -205,7 +211,7 @@ def _grid_size(words: list[str]) -> int:
 
 def _try_place(
     grid: list[list[str]],
-    word: str,
+    word: list[str],
     rng: random.Random,
 ) -> bool:
     """
@@ -215,7 +221,7 @@ def _try_place(
 
     Args:
         grid (list[list[str]]): The mutable grid; empty cells are the empty string.
-        word (str): The word to place.
+        word (list[str]): The letter units to place, one per cell.
         rng (random.Random): Randomness source.
 
     Returns:
@@ -260,7 +266,8 @@ def build_word_search(words: list[str], rng: random.Random) -> str:
         rng (random.Random): Randomness source (injected for reproducibility).
 
     Returns:
-        str: The grid, one row per line with letters separated by spaces.
+        str: The grid, one row per line with letter units separated by spaces. A cell may
+            include combining marks attached to its letter.
 
     Raises:
         ValueError: If ``words`` is empty, any word has no letters after cleaning, or the
 
@@ -68,6 +68,10 @@ class PuzzledConverter(Converter):
         - ``crossword``: shared letters across the masked words are replaced by symbols the model
           must deduce.
 
+    Each puzzle uses the same letter units as its clues: canonically equivalent spellings
+    are normalized, and combining marks stay attached to their letters during encoding.
+    Alphanumeric tokens, underscores, and words containing joiners are not partially masked.
+
     Keyword selection uses spaCy's ``en_core_web_sm`` model when it is installed and degrades to a
     length-based heuristic when it is not, so the converter has no hard dependency on spaCy. Run
     ``python -m spacy download en_core_web_sm`` to enable the paper's part-of-speech-aware