@@ -17,16 +17,71 @@
 import logging
 import re
 import threading
+import unicodedata
+from collections.abc import Iterator
 from dataclasses import dataclass
 from typing import Any
 
 logger = logging.getLogger(__name__)
 
-# The one tokenizer used for both candidate selection and placeholder ordering. Requiring
-# word boundaries keeps candidates to runs of letters that can actually be matched again
-# when masking, so a token embedded in an alphanumeric blob (the "h" of "h4ck3r") is never
-# selected and then silently dropped.
-_WORD_PATTERN = re.compile(r"\b[A-Za-z]+\b")
+# 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")
+
+
+def _is_word_continuation(char: str) -> bool:
+    return char in ("\u200c", "\u200d") or unicodedata.category(char).startswith("M")
+
+
+def _word_key(word: str) -> str:
+    """
+    Return the case-insensitive key that identifies a word.
+
+    Selection, deduplication, ordering and replacement all compare words through this key,
+    so two spellings are either the same masked word everywhere or different words
+    everywhere. For ASCII it equals ``str.lower``.
+
+    Args:
+        word (str): A word from the prompt or from the caller.
+
+    Returns:
+        str: The case-folded word.
+    """
+    return word.casefold()
+
+
+def _iter_words(prompt: str) -> Iterator[re.Match[str]]:
+    """
+    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.
+
+    Args:
+        prompt (str): The prompt to scan.
+
+    Yields:
+        re.Match[str]: Each whole-word match, 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]):
+            continue
+        yield match
+
 
 # Part-of-speech label used when spaCy is unavailable or the word was caller-supplied.
 _GENERIC_POS = "word"
@@ -170,15 +225,15 @@ def _get_nlp() -> Any:
 
 def _pos_lookup(prompt: str) -> dict[str, str]:
     """
-    Map each alphabetic noun/verb (lowercased) in the prompt to its clue label.
+    Map each alphabetic noun/verb in the prompt (by ``_word_key``) to its clue label.
 
     Returns an empty mapping when spaCy is unavailable.
 
     Args:
         prompt (str): The prompt to tag.
 
     Returns:
-        dict[str, str]: Lowercased word to part-of-speech label ("noun" or "verb").
+        dict[str, str]: Word key to part-of-speech label ("noun" or "verb").
     """
     nlp = _get_nlp()
     if nlp is None:
@@ -187,7 +242,7 @@ def _pos_lookup(prompt: str) -> dict[str, str]:
     for token in nlp(prompt):
         if token.is_alpha and token.pos_ in _MASKABLE_POS:
             # Keep the first tag seen for a given surface form.
-            lookup.setdefault(token.text.lower(), _MASKABLE_POS[token.pos_])
+            lookup.setdefault(_word_key(token.text), _MASKABLE_POS[token.pos_])
     return lookup
 
 
@@ -214,20 +269,20 @@ def _rank_candidates(
     Returns:
         list[str]: Distinct candidate words (as they appear in the prompt) in priority order.
     """
-    tokens = _WORD_PATTERN.findall(prompt)
+    tokens = [match.group() for match in _iter_words(prompt)]
     seen: set[str] = set()
     unique: list[str] = []
     for token in tokens:
-        key = token.lower()
+        key = _word_key(token)
         if key not in seen:
             seen.add(key)
             unique.append(token)
 
-    essential_lower = {w.lower() for w in (essential_words or [])}
+    essential_keys = {_word_key(w) for w in (essential_words or [])}
 
     def tier(word: str) -> int:
-        key = word.lower()
-        if key in essential_lower:
+        key = _word_key(word)
+        if key in essential_keys:
             return 0
         if key in _ESSENTIAL_HARM_WORDS:
             return 1
@@ -237,7 +292,7 @@ def tier(word: str) -> int:
             return 3
         return 4
 
-    return sorted(unique, key=lambda w: (tier(w), -len(w), w.lower()))
+    return sorted(unique, key=lambda w: (tier(w), -len(w), _word_key(w)))
 
 
 def mask_prompt(
@@ -278,25 +333,34 @@ def mask_prompt(
         return MaskResult(masked_prompt=prompt, masked_words=[])
 
     # Number placeholders by where each chosen word first appears (case-insensitively), so
-    # [WORD1] is the leftmost masked word. Candidates come from the same word-boundary scan,
-    # so every chosen word has an entry here.
+    # [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 _WORD_PATTERN.finditer(prompt):
-        first_index.setdefault(match.group().lower(), match.start())
-    ordered = sorted(chosen, key=lambda w: first_index[w.lower()])
+    for match in _iter_words(prompt):
+        first_index.setdefault(_word_key(match.group()), match.start())
+    ordered = sorted(chosen, key=lambda w: first_index[_word_key(w)])
 
     masked_words: list[MaskedWord] = []
     placeholders: dict[str, str] = {}
     for index, word in enumerate(ordered, start=1):
         placeholder = f"[WORD{index}]"
-        pos = pos_lookup.get(word.lower(), _GENERIC_POS)
+        pos = pos_lookup.get(_word_key(word), _GENERIC_POS)
         masked_words.append(MaskedWord(text=word, placeholder=placeholder, pos=pos))
-        placeholders[word.lower()] = placeholder
-
-    # Replace every occurrence of every chosen word in one case-insensitive pass, so a word
-    # that recurs or appears in different casing is never left in cleartext, and a placeholder
-    # already inserted cannot be re-matched while masking the next word.
-    pattern = re.compile(r"\b(" + "|".join(re.escape(w) for w in ordered) + r")\b", re.IGNORECASE)
-    masked_prompt = pattern.sub(lambda m: placeholders[m.group(0).lower()], prompt)
-
-    return MaskResult(masked_prompt=masked_prompt, masked_words=masked_words)
+        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.
+    # 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()))
+        if placeholder is None:
+            continue
+        pieces.append(prompt[last_end : match.start()])
+        pieces.append(placeholder)
+        last_end = match.end()
+    pieces.append(prompt[last_end:])
+
+    return MaskResult(masked_prompt="".join(pieces), masked_words=masked_words)
@@ -56,10 +56,32 @@ def label(self) -> str:
         return self.value.replace("_", " ")
 
 
+def _upper_same_length(word: str) -> str:
+    """
+    Uppercase ``word`` without changing its length or case-folded spelling.
+
+    ``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.
+
+    Args:
+        word (str): The word to uppercase.
+
+    Returns:
+        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
+    )
+
+
 def _normalize(words: list[str]) -> list[str]:
     """
     Uppercase the words and strip surrounding whitespace.
 
+    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.
+
     Args:
         words (list[str]): The masked keywords to encode.
 
@@ -71,7 +93,7 @@ def _normalize(words: list[str]) -> list[str]:
     """
     if not words:
         raise ValueError("At least one word is required to build a puzzle.")
-    cleaned = [w.strip().upper() for w in words]
+    cleaned = [_upper_same_length(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
 
@@ -163,6 +163,114 @@ async def test_crossword_falls_back_to_anagram_when_it_cannot_hide_the_word():
     assert "malware" not in result.output_text.lower()
 
 
+# --- non-ASCII words end to end ----------------------------------------------
+
+
+def _section(output: str, start: str, end: str) -> str:
+    return output.split(start, 1)[1].split(end, 1)[0].strip()
+
+
+def _clue_lengths(output: str) -> list[int]:
+    clues = _section(output, "Clues (one per hidden word, giving its length and part of speech):", "Follow these")
+    return [int(line.split(" = ", 1)[1].split("-letter", 1)[0]) for line in clues.splitlines()]
+
+
+def _grid_contains(grid: list[list[str]], word: str) -> bool:
+    # Try every start cell in each of the eight directions a word search may use.
+    size = len(grid)
+    directions = [(0, 1), (0, -1), (1, 0), (-1, 0), (1, 1), (1, -1), (-1, 1), (-1, -1)]
+    for row in range(size):
+        for col in range(size):
+            for row_delta, col_delta in directions:
+                cells = [(row + i * row_delta, col + i * col_delta) for i in range(len(word))]
+                if all(0 <= r < size and 0 <= c < size for r, c in cells) and all(
+                    grid[r][c] == letter for (r, c), letter in zip(cells, word, strict=True)
+                ):
+                    return True
+    return False
+
+
+async def test_anagram_encodes_exactly_the_letters_the_clues_promise():
+    # "ß" uppercases to "SS"; encoding it that way would put 12 letters behind clues for 6 + 5.
+    result = await PuzzledConverter(puzzle_type="anagram", num_to_mask=2, seed=42).convert_async(prompt="straße tasse")
+    puzzle = _section(result.output_text, "Puzzle:", "Clues")
+    assert sorted(_clue_lengths(result.output_text)) == [5, 6]
+    assert len(puzzle) == 11
+    assert sorted(puzzle) == sorted("STRAßETASSE")
+
+
+async def test_crossword_lines_match_their_length_clues():
+    result = await PuzzledConverter(puzzle_type="crossword", num_to_mask=2, seed=42).convert_async(
+        prompt="straße tasse"
+    )
+    lines = _section(result.output_text, "Puzzle:", "Clues").splitlines()
+    assert [len(line.split(". ", 1)[1]) for line in lines] == _clue_lengths(result.output_text)
+
+
+async def test_word_search_hides_words_at_their_clued_length():
+    result = await PuzzledConverter(puzzle_type="word_search", num_to_mask=2, seed=42).convert_async(
+        prompt="straße tasse"
+    )
+    grid = [row.split(" ") for row in _section(result.output_text, "Puzzle:", "Clues").splitlines()]
+    assert sorted(_clue_lengths(result.output_text)) == [5, 6]
+    # Each word occupies exactly as many cells as its clue says, keeping its "ß".
+    assert _grid_contains(grid, "STRAßE")
+    assert _grid_contains(grid, "TASSE")
+    assert not _grid_contains(grid, "STRASSE")
+
+
+@pytest.mark.parametrize("puzzle_type", ["word_search", "anagram", "crossword"])
+@pytest.mark.parametrize(
+    "prompt, instruction",
+    [
+        # Unicode case variants of one word share a placeholder.
+        ("ÉCOLE école", "[WORD1] [WORD1]"),
+        # Dotted "I" and dotless "ı" fold to different words, so with one mask the other stays.
+        ("KIŞ kış", "[WORD1] kış"),
+    ],
+)
+async def test_unicode_case_variants_convert_for_every_puzzle_type(puzzle_type, prompt, instruction):
+    result = await PuzzledConverter(puzzle_type=puzzle_type, num_to_mask=1, seed=0).convert_async(prompt=prompt)
+    assert _section(result.output_text, "Instruction with hidden words:", "The hidden words are") == instruction
+
+
+@pytest.mark.parametrize("puzzle_type", ["word_search", "anagram", "crossword"])
+@pytest.mark.parametrize("joiner", ["\u200c", "\u200d"])
+async def test_joined_words_are_never_partially_masked_async(*, puzzle_type: str, joiner: str) -> None:
+    joined_word = f"अक्{joiner}षर"
+    converter = PuzzledConverter(puzzle_type=puzzle_type, num_to_mask=3, seed=42)
+    with pytest.raises(ValueError, match="no maskable words"):
+        await converter.convert_async(prompt=joined_word)
+
+    result = await converter.convert_async(prompt=f"garden {joined_word} now")
+    instruction = _section(result.output_text, "Instruction with hidden words:", "The hidden words are")
+    assert instruction == f"[WORD1] {joined_word} [WORD2]"
+    assert _clue_lengths(result.output_text) == [6, 3]
+
+
+@pytest.mark.parametrize("puzzle_type", ["word_search", "anagram", "crossword"])
+@pytest.mark.parametrize("words", [("ılık", "ilik"), ("ilik", "ılık")])
+async def test_puzzles_preserve_distinct_case_folded_words_async(*, puzzle_type: str, words: tuple[str, str]) -> None:
+    result = await PuzzledConverter(puzzle_type=puzzle_type, num_to_mask=2, seed=42).convert_async(
+        prompt=" ".join(words)
+    )
+    instruction = _section(result.output_text, "Instruction with hidden words:", "The hidden words are")
+    assert instruction == "[WORD1] [WORD2]"
+    assert _clue_lengths(result.output_text) == [4, 4]
+    puzzle = _section(result.output_text, "Puzzle:", "Clues")
+    if puzzle_type == "word_search":
+        grid = [row.split(" ") for row in puzzle.splitlines()]
+        assert _grid_contains(grid, "ıLıK")
+        assert _grid_contains(grid, "ILIK")
+    elif puzzle_type == "anagram":
+        assert sorted(puzzle) == sorted("ıLıKILIK")
+    else:
+        encoded_words = [line.split(". ", 1)[1] for line in puzzle.splitlines()]
+        assert encoded_words[0] != encoded_words[1]
+        for word, encoded in zip(words, encoded_words, strict=True):
+            assert ("ı" in encoded) == ("ı" in word)
+
+
 # --- optional LLM semantic clues -------------------------------------------