diff --git a/‎Sources/FluidAudio/TTS/KokoroAne/G2P/Mandarin/MandarinErhua.swift‎
Lines changed: 59 additions & 9 deletions b/‎Sources/FluidAudio/TTS/KokoroAne/G2P/Mandarin/MandarinErhua.swift‎
Lines changed: 59 additions & 9 deletions
diff --git a/‎Sources/FluidAudio/TTS/KokoroAne/G2P/Mandarin/MandarinG2P.swift‎
Lines changed: 33 additions & 15 deletions b/‎Sources/FluidAudio/TTS/KokoroAne/G2P/Mandarin/MandarinG2P.swift‎
Lines changed: 33 additions & 15 deletions
diff --git a/‎Sources/FluidAudio/TTS/KokoroAne/G2P/Mandarin/MandarinPinyinNormalizer.swift‎
Lines changed: 8 additions & 1 deletion b/‎Sources/FluidAudio/TTS/KokoroAne/G2P/Mandarin/MandarinPinyinNormalizer.swift‎
Lines changed: 8 additions & 1 deletion
@@ -13,22 +13,28 @@ import Foundation
 ///
 /// Boundary rules:
 ///
-///   * `儿` at index 0 of the sandhi buffer is *never* merged — keeps
-///     standalone words (`儿子 érzi`, `儿童 értóng`) intact.
+///   * Only a syllable flagged `isErhuaSuffix` folds. The flag is set by
+///     `MandarinG2P` from the source text via `isSuffix(word:preceding:)`:
+///     the character must be `儿` / `兒` (not `二`, `而`, `耳`, `尔`, which
+///     share the pinyin `er`), it must end its word or stand alone, and
+///     the word must not be one misaki keeps as a full `ér` (`女儿`,
+///     `婴儿`, `孤儿`, …).
+///   * `儿` at index 0 of the sandhi buffer is *never* merged — there is
+///     nothing to fold into.
 ///   * The preceding syllable must itself not be `er` — back-to-back
 ///     `er er` is left as two syllables.
-///   * Any non-`er` base is mergeable. The whitelist is intentionally
-///     loose; cases that misaki blocks (e.g. `儿` at the start of a
-///     polysyllabic word) are already filtered out by the
-///     `dict.phrases` / single-char lookup happening upstream.
+///
+/// misaki also skips words tagged `a`, `j` or `nr` by jieba's POS tagger;
+/// this pipeline has no POS tags, so the word lists carry the common
+/// cases instead.
 ///
 /// Operates in place on the same `pendingSyllables` buffer that
 /// `MandarinToneSandhi.apply` will see — invoke this *before* sandhi
 /// so 3+3 promotion considers the (now shorter) buffer.
 public enum MandarinErhua {
 
-    /// Fold trailing `er` syllables into their predecessors. Mutates
-    /// `syllables` in place; the merged-into syllable gains
+    /// Fold flagged trailing `er` syllables into their predecessors.
+    /// Mutates `syllables` in place; the merged-into syllable gains
     /// `erhua = true`, the trailing `er` is removed.
     public static func merge(_ syllables: inout [MandarinPinyinNormalizer.Syllable]) {
         guard syllables.count >= 2 else { return }
@@ -40,7 +46,7 @@ public enum MandarinErhua {
         while i >= 1 {
             let cur = syllables[i]
             let prev = syllables[i - 1]
-            if cur.base == "er" && shouldMergeInto(prev: prev) {
+            if cur.base == "er" && cur.isErhuaSuffix && shouldMergeInto(prev: prev) {
                 syllables[i - 1].erhua = true
                 syllables.remove(at: i)
                 // Advance past the now-merged anchor so an immediately
@@ -53,11 +59,55 @@ public enum MandarinErhua {
         }
     }
 
+    /// Whether the last character of `word` is an erhua suffix that may
+    /// fold into the syllable before it. `preceding` is the Hanzi already
+    /// in the sandhi buffer before `word`; it is only consulted when the
+    /// segmenter split `儿` off as a word of its own (`这` + `儿` when
+    /// `这儿` isn't in the phrase dict), which is the one case where the
+    /// syllable to fold into belongs to an earlier word.
+    ///
+    /// Mirrors misaki's rule: the character is `儿`, it is the last one of
+    /// its word, and neither the word nor its last two characters are in
+    /// `notErhua` unless the word is in `mustErhua`.
+    public static func isSuffix(word: [Character], preceding: [Character]) -> Bool {
+        guard let last = word.last, last == "儿" || last == "兒" else { return false }
+        // The syllable `儿` folds into, and the text the word lists see.
+        let context: [Character]
+        if word.count >= 2 {
+            context = word
+        } else {
+            guard !preceding.isEmpty else { return false }
+            context = Array(preceding.suffix(2)) + word
+        }
+        let normalized = String(context).replacingOccurrences(of: "兒", with: "儿")
+        if mustErhua.contains(normalized) { return true }
+        let tail2 = String(normalized.suffix(2))
+        let tail3 = String(normalized.suffix(3))
+        return !notErhua.contains(normalized) && !notErhua.contains(tail2) && !notErhua.contains(tail3)
+    }
+
     /// Whitelist for the merge predicate. Conservative on purpose —
     /// any non-empty, non-`er` base is allowed.
     private static func shouldMergeInto(
         prev: MandarinPinyinNormalizer.Syllable
     ) -> Bool {
         !prev.base.isEmpty && prev.base != "er"
     }
+
+    /// Words whose final `儿` is always read as erhua. From misaki's
+    /// `ZHFrontend.must_erhua`.
+    static let mustErhua: Set<String> = [
+        "小院儿", "胡同儿", "范儿", "老汉儿", "撒欢儿", "寻老礼儿", "妥妥儿", "媳妇儿",
+    ]
+
+    /// Words whose final `儿` keeps its own `ér` syllable — mostly `儿`
+    /// meaning "child" (`女儿`, `婴儿`) or part of a name (`红孩儿`).
+    /// From misaki's `ZHFrontend.not_erhua`.
+    static let notErhua: Set<String> = [
+        "虐儿", "为儿", "护儿", "瞒儿", "救儿", "替儿", "有儿", "一儿", "我儿", "俺儿", "妻儿",
+        "拐儿", "聋儿", "乞儿", "患儿", "幼儿", "孤儿", "婴儿", "婴幼儿", "连体儿", "脑瘫儿",
+        "流浪儿", "体弱儿", "混血儿", "蜜雪儿", "舫儿", "祖儿", "美儿", "应采儿", "可儿", "侄儿",
+        "孙儿", "侄孙儿", "女儿", "男儿", "红孩儿", "花儿", "虫儿", "马儿", "鸟儿", "猪儿", "猫儿",
+        "狗儿", "少儿",
+    ]
 }
@@ -28,9 +28,10 @@ import Foundation
 ///      encodes tone.
 ///   5. **Diacritic → digit** — each pinyin syllable is normalized to
 ///      `(base, tone)` via `MandarinPinyinNormalizer`.
-///   6. **Erhua merge** — `MandarinErhua.merge` folds trailing `儿`
+///   6. **Erhua merge** — `MandarinErhua.merge` folds a word-final `儿`
 ///      into the previous syllable so `小孩儿` emits a single
-///      r-coloured token (`ㄒㄧㄠ3ㄏㄞㄦ2`).
+///      r-coloured token (`ㄒㄧㄠ3ㄏㄞㄦ2`). Other characters read `er`
+///      (`二`, `而`, `耳`, `尔`) keep their own syllable.
 ///   7. **Tone sandhi** — 3+3 → 2+3, 不 / 一 contextual rules
 ///      (`MandarinToneSandhi`).
 ///   8. **Pinyin → Bopomofo** — `MandarinBopomofoMap.encode` produces
@@ -118,8 +119,12 @@ public struct MandarinG2P: Sendable {
 
         var output = ""
         var pendingSyllables: [MandarinPinyinNormalizer.Syllable] = []
+        // The Hanzi behind `pendingSyllables`, so the erhua pass can tell
+        // `儿` from `二` / `而` / `耳` / `尔`, which all read `er`.
+        var pendingHanzi: [Character] = []
 
         func flushPending() {
+            defer { pendingHanzi.removeAll(keepingCapacity: true) }
             guard !pendingSyllables.isEmpty else { return }
             // Order: erhua first (it shrinks the buffer), then sandhi
             // operates on the merged result so 3+3 promotion sees the
@@ -141,17 +146,30 @@ public struct MandarinG2P: Sendable {
 
         for seg in segments {
             switch seg {
-            case .pinyin(let list, _):
-                for py in list {
-                    pendingSyllables.append(MandarinPinyinNormalizer.normalize(py))
+            case .pinyin(let list, let word):
+                var syllables = list.map(MandarinPinyinNormalizer.normalize)
+                let chars = Array(word)
+                // Readings line up one per character; a phrase entry that
+                // doesn't leaves no character to check, so nothing folds.
+                if chars.count == syllables.count, let last = syllables.indices.last,
+                    syllables[last].base == "er",
+                    MandarinErhua.isSuffix(word: chars, preceding: pendingHanzi)
+                {
+                    syllables[last].isErhuaSuffix = true
                 }
+                pendingSyllables.append(contentsOf: syllables)
+                pendingHanzi.append(contentsOf: chars)
             case .syllables(let list):
                 // User-lexicon pinyin tokens — already in
                 // (base, tone) form. They join the same syllable buffer
                 // so sandhi runs across user/dict boundaries naturally
                 // (e.g. user word ending in tone-3 followed by dict
-                // word starting with tone-3 → 3+3 promotion).
+                // word starting with tone-3 → 3+3 promotion). They are
+                // taken literally for erhua: their `er` tokens stay
+                // unflagged, and a `儿` after them has no Hanzi context
+                // to fold by.
                 pendingSyllables.append(contentsOf: list)
+                pendingHanzi.removeAll(keepingCapacity: true)
             case .punctuation(let s):
                 // Sandhi never crosses punctuation; emit accumulated
                 // syllables first.
@@ -204,12 +222,12 @@ public struct MandarinG2P: Sendable {
     // MARK: - Segmentation
 
     enum Segment {
-        /// Diacritic-form pinyin syllables. `hanziCount` is the number
-        /// of Hanzi consumed from the input — needed by the polyphone
-        /// pass to know whether a segment is a single-char fallback
-        /// (eligible for g2pW override) or a phrase match (which the
-        /// dict already context-disambiguated).
-        case pinyin([String], hanziCount: Int)
+        /// Diacritic-form pinyin syllables for `word`, the Hanzi consumed
+        /// from the input. A one-character `word` is a single-char fallback
+        /// (eligible for g2pW override); a longer one is a phrase match,
+        /// which the dict already context-disambiguated. The text itself
+        /// is what lets the erhua pass tell `儿` from other `er` readings.
+        case pinyin([String], word: String)
         /// Pre-parsed syllables (user-lexicon source).
         case syllables([MandarinPinyinNormalizer.Syllable])
         case punctuation(String)  // ASCII punctuation passthrough.
@@ -271,7 +289,7 @@ public struct MandarinG2P: Sendable {
             for word in words {
                 let wordCharCount = word.count
                 if wordCharCount >= 2, let pinyin = dict.phrases[word] {
-                    segments.append(.pinyin(pinyin, hanziCount: wordCharCount))
+                    segments.append(.pinyin(pinyin, word: word))
                     offsetInRun += wordCharCount
                     continue
                 }
@@ -289,7 +307,7 @@ public struct MandarinG2P: Sendable {
                                 PolyphoneTarget(
                                     segmentIdx: segments.count, charPos: absPos))
                         }
-                        segments.append(.pinyin([pinyin[0]], hanziCount: 1))
+                        segments.append(.pinyin([pinyin[0]], word: String(ch)))
                     } else {
                         // Unknown char — fall through as literal so
                         // KokoroAneVocab can have a shot at it.
@@ -342,7 +360,7 @@ public struct MandarinG2P: Sendable {
                         if let pinyin = dict.phrases[candidate] {
                             flushHanziRun()
                             flushLiteral()
-                            segments.append(.pinyin(pinyin, hanziCount: len))
+                            segments.append(.pinyin(pinyin, word: candidate))
                             i += len
                             matched = true
                             break
 
@@ -22,11 +22,18 @@ public enum MandarinPinyinNormalizer {
         /// Set by `MandarinErhua.merge`; consumed by
         /// `MandarinBopomofoMap.encode` to append the `ㄦ` suffix.
         public var erhua: Bool
+        /// Whether this `er` syllable is the erhua suffix `儿` and may fold
+        /// into the syllable before it. Pinyin alone can't tell `儿` from
+        /// `二` / `而` / `耳` / `尔`, so `MandarinG2P` sets this from the
+        /// source text (see `MandarinErhua.isSuffix`); `MandarinErhua.merge`
+        /// only folds syllables that carry it.
+        public var isErhuaSuffix: Bool
 
-        public init(base: String, tone: Int, erhua: Bool = false) {
+        public init(base: String, tone: Int, erhua: Bool = false, isErhuaSuffix: Bool = false) {
             self.base = base
             self.tone = tone
             self.erhua = erhua
+            self.isErhuaSuffix = isErhuaSuffix
         }
     }