@elizaos/capacitor-bun-runtime 2.0.11-beta.7

package/ios/Sources/ElizaBunRuntimePlugin/kokoro/KokoroCoreMlJapanesePhonemizer.swift

@@ -0,0 +1,209 @@
+import Foundation
+
+/// Japanese text-to-phoneme conversion for Kokoro TTS.
+///
+/// Pipeline: Japanese text → CFStringTokenizer (word segmentation + readings)
+///           → katakana → IPA via M2P table → P2R romanization
+///
+/// Uses Apple's built-in Japanese morphological analysis — no MeCab dependency.
+/// M2P katakana-to-IPA table covers standard and extended katakana (193 entries).
+final class JapanesePhonemizer {
+
+    // MARK: - Katakana → IPA (M2P)
+
+    /// Digraph mappings (two-character katakana → IPA). Checked before single chars.
+    private static let digraphs: [String: String] = [
+        "イェ": "je",
+        "ウィ": "wi", "ウゥ": "wu", "ウェ": "we", "ウォ": "wo",
+        "キィ": "kyi", "キェ": "kye", "キャ": "kya", "キュ": "kyu", "キョ": "kyo",
+        "ギィ": "gyi", "ギェ": "gye", "ギャ": "gya", "ギュ": "gyu", "ギョ": "gyo",
+        "クァ": "kwa", "クィ": "kwi", "クゥ": "kwu", "クェ": "kwe", "クォ": "kwo", "クヮ": "kwa",
+        "グァ": "gwa", "グィ": "gwi", "グゥ": "gwu", "グェ": "gwe", "グォ": "gwo", "グヮ": "gwa",
+        "シェ": "she", "シャ": "sha", "シュ": "shu", "ショ": "sho",
+        "ジェ": "je", "ジャ": "ja", "ジュ": "ju", "ジョ": "jo",
+        "スィ": "si", "ズィ": "zi",
+        "チェ": "che", "チャ": "cha", "チュ": "chu", "チョ": "cho",
+        "ヂェ": "je", "ヂャ": "ja", "ヂュ": "ju", "ヂョ": "jo",
+        "ツァ": "tsa", "ツィ": "tsi", "ツェ": "tse", "ツォ": "tso",
+        "ティ": "ti", "テェ": "tye", "テャ": "tya", "テュ": "tyu", "テョ": "tyo",
+        "ディ": "di", "デェ": "dye", "デャ": "dya", "デュ": "dyu", "デョ": "dyo",
+        "トゥ": "tu", "ドゥ": "du",
+        "ニィ": "nyi", "ニェ": "nye", "ニャ": "nya", "ニュ": "nyu", "ニョ": "nyo",
+        "ヒィ": "hyi", "ヒェ": "hye", "ヒャ": "hya", "ヒュ": "hyu", "ヒョ": "hyo",
+        "ビィ": "byi", "ビェ": "bye", "ビャ": "bya", "ビュ": "byu", "ビョ": "byo",
+        "ピィ": "pyi", "ピェ": "pye", "ピャ": "pya", "ピュ": "pyu", "ピョ": "pyo",
+        "ファ": "fa", "フィ": "fi", "フェ": "fe", "フォ": "fo",
+        "ミィ": "myi", "ミェ": "mye", "ミャ": "mya", "ミュ": "myu", "ミョ": "myo",
+        "リィ": "ryi", "リェ": "rye", "リャ": "rya", "リュ": "ryu", "リョ": "ryo",
+        "ヴァ": "va", "ヴィ": "vi", "ヴェ": "ve", "ヴォ": "vo",
+        "ヴャ": "bya", "ヴュ": "byu", "ヴョ": "byo",
+    ]
+
+    /// Single katakana → IPA mappings.
+    private static let singles: [Character: String] = [
+        "ァ": "a", "ア": "a", "ィ": "i", "イ": "i",
+        "ゥ": "u", "ウ": "u", "ェ": "e", "エ": "e",
+        "ォ": "o", "オ": "o",
+        "カ": "ka", "ガ": "ga", "キ": "ki", "ギ": "gi",
+        "ク": "ku", "グ": "gu", "ケ": "ke", "ゲ": "ge",
+        "コ": "ko", "ゴ": "go",
+        "サ": "sa", "ザ": "za", "シ": "shi", "ジ": "ji",
+        "ス": "su", "ズ": "zu", "セ": "se", "ゼ": "ze",
+        "ソ": "so", "ゾ": "zo",
+        "タ": "ta", "ダ": "da", "チ": "chi", "ヂ": "ji",
+        "ツ": "tsu", "ヅ": "zu", "テ": "te", "デ": "de",
+        "ト": "to", "ド": "do",
+        "ナ": "na", "ニ": "ni", "ヌ": "nu", "ネ": "ne", "ノ": "no",
+        "ハ": "ha", "バ": "ba", "パ": "pa",
+        "ヒ": "hi", "ビ": "bi", "ピ": "pi",
+        "フ": "fu", "ブ": "bu", "プ": "pu",
+        "ヘ": "he", "ベ": "be", "ペ": "pe",
+        "ホ": "ho", "ボ": "bo", "ポ": "po",
+        "マ": "ma", "ミ": "mi", "ム": "mu", "メ": "me", "モ": "mo",
+        "ャ": "ya", "ヤ": "ya", "ュ": "yu", "ユ": "yu",
+        "ョ": "yo", "ヨ": "yo",
+        "ラ": "ra", "リ": "ri", "ル": "ru", "レ": "re", "ロ": "ro",
+        "ヮ": "wa", "ワ": "wa", "ヰ": "i", "ヱ": "e", "ヲ": "o",
+        "ヴ": "vu", "ヵ": "ka", "ヶ": "ke",
+        "ヷ": "va", "ヸ": "vi", "ヹ": "ve", "ヺ": "vo",
+        "ッ": "ʔ", "ン": "ɴ", "ー": "ː",
+    ]
+
+    // MARK: - Japanese Punctuation
+
+    private static let punctuationMap: [Character: String] = [
+        "「": "\"", "」": "\"", "『": "\"", "』": "\"",
+        "【": "\"", "】": "\"", "〈": "\"", "〉": "\"",
+        "《": "\"", "》": "\"", "«": "\"", "»": "\"",
+        "、": ",", "。": ".", "！": "!", "？": "?",
+        "（": "(", "）": ")", "：": ":", "；": ";",
+    ]
+
+    // MARK: - Public API
+
+    /// Convert Japanese text to phoneme string for Kokoro TTS.
+    func phonemize(_ text: String) -> String {
+        let locale = Locale(identifier: "ja_JP") as CFLocale
+        let cfText = text as CFString
+        let length = CFStringGetLength(cfText)
+        guard length > 0 else { return "" }
+
+        let tokenizer = CFStringTokenizerCreate(nil, cfText, CFRangeMake(0, length),
+                                                 kCFStringTokenizerUnitWord, locale)
+
+        // Collect tokens with their positions
+        var tokens: [(range: NSRange, word: String, reading: String?)] = []
+        var tokenResult = CFStringTokenizerAdvanceToNextToken(tokenizer)
+        while tokenResult != [] {
+            let range = CFStringTokenizerGetCurrentTokenRange(tokenizer)
+            let latin = CFStringTokenizerCopyCurrentTokenAttribute(
+                tokenizer, kCFStringTokenizerAttributeLatinTranscription) as? String
+            let nsRange = NSRange(location: range.location, length: range.length)
+            let word = (text as NSString).substring(with: nsRange)
+            tokens.append((range: nsRange, word: word, reading: latin))
+            tokenResult = CFStringTokenizerAdvanceToNextToken(tokenizer)
+        }
+
+        var result = ""
+        var lastWasWord = false
+        var cursor = 0
+
+        for token in tokens {
+            // Handle gaps (punctuation, whitespace) between tokens
+            if token.range.location > cursor {
+                let gapStart = text.index(text.startIndex, offsetBy: cursor)
+                let gapEnd = text.index(text.startIndex, offsetBy: token.range.location)
+                for ch in text[gapStart..<gapEnd] {
+                    if let punct = Self.punctuationMap[ch] {
+                        result += punct
+                        lastWasWord = false
+                    } else if ch.isPunctuation || ch.isSymbol {
+                        if let ascii = Self.asciiPunct(ch) { result += ascii }
+                        lastWasWord = false
+                    } else if ch.isWhitespace {
+                        lastWasWord = false
+                    }
+                }
+            }
+
+            if let reading = token.reading {
+                if lastWasWord { result += " " }
+                // Convert romaji reading to katakana, then to IPA
+                let katakana = Self.romajiToKatakana(reading)
+                result += Self.katakanaToPhonemes(katakana)
+                lastWasWord = true
+            }
+
+            cursor = token.range.location + token.range.length
+        }
+
+        // Trailing punctuation
+        if cursor < (text as NSString).length {
+            let remaining = (text as NSString).substring(from: cursor)
+            for ch in remaining {
+                if let punct = Self.punctuationMap[ch] {
+                    result += punct
+                } else if ch.isPunctuation || ch.isSymbol {
+                    if let ascii = Self.asciiPunct(ch) { result += ascii }
+                }
+            }
+        }
+
+        return result
+    }
+
+    // MARK: - Katakana → Phonemes
+
+    /// Convert katakana string to phoneme string using M2P table.
+    static func katakanaToPhonemes(_ katakana: String) -> String {
+        var result = ""
+        let chars = Array(katakana)
+        var i = 0
+
+        while i < chars.count {
+            // Try digraph first (two characters)
+            if i + 1 < chars.count {
+                let pair = String(chars[i]) + String(chars[i + 1])
+                if let phoneme = digraphs[pair] {
+                    result += phoneme
+                    i += 2
+                    continue
+                }
+            }
+
+            // Single character
+            if let phoneme = singles[chars[i]] {
+                result += phoneme
+            }
+            // Skip unknown characters silently
+            i += 1
+        }
+
+        return result
+    }
+
+    // MARK: - Romaji → Katakana
+
+    /// Convert romaji to katakana for M2P lookup.
+    /// Uses CFStringTransform (Apple's built-in Latin→Katakana).
+    static func romajiToKatakana(_ romaji: String) -> String {
+        let mutable = NSMutableString(string: romaji)
+        CFStringTransform(mutable, nil, kCFStringTransformLatinKatakana, false)
+        return mutable as String
+    }
+
+    // MARK: - Helpers
+
+    private static func asciiPunct(_ ch: Character) -> String? {
+        switch ch {
+        case ",": return ","
+        case ".": return "."
+        case "!": return "!"
+        case "?": return "?"
+        case ";": return ";"
+        case ":": return ":"
+        case "-": return "-"
+        default: return nil
+        }
+    }
+}

package/ios/Sources/ElizaBunRuntimePlugin/kokoro/KokoroCoreMlLatinPhonemizer.swift

@@ -0,0 +1,374 @@
+import Foundation
+
+/// Grapheme-to-phoneme conversion for Latin-script languages (French, Spanish, Portuguese, Italian, German).
+///
+/// Rule-based orthography→IPA conversion. Each language has specific rules for
+/// digraphs, accent handling, and context-dependent pronunciation.
+final class LatinPhonemizer {
+
+    enum Language {
+        case french, spanish, portuguese, italian
+    }
+
+    private let language: Language
+
+    init(language: Language) {
+        self.language = language
+    }
+
+    // MARK: - Public API
+
+    func phonemize(_ text: String) -> String {
+        let words = tokenize(text)
+        var result = ""
+        var lastWasWord = false
+
+        for token in words {
+            switch token {
+            case .word(let w):
+                if lastWasWord { result += " " }
+                result += convertWord(w.lowercased())
+                lastWasWord = true
+            case .punctuation(let p):
+                result += p
+                lastWasWord = false
+            case .space:
+                lastWasWord = false
+            }
+        }
+
+        return result
+    }
+
+    // MARK: - Tokenization
+
+    private enum Token {
+        case word(String)
+        case punctuation(String)
+        case space
+    }
+
+    private func tokenize(_ text: String) -> [Token] {
+        var tokens: [Token] = []
+        var current = ""
+
+        for ch in text {
+            if ch.isWhitespace {
+                if !current.isEmpty { tokens.append(.word(current)); current = "" }
+                tokens.append(.space)
+            } else if ch.isLetter || ch == "'" || ch == "'" || ch == "-" {
+                current.append(ch)
+            } else if ch.isPunctuation || ch.isSymbol {
+                if !current.isEmpty { tokens.append(.word(current)); current = "" }
+                tokens.append(.punctuation(String(ch)))
+            } else {
+                current.append(ch)
+            }
+        }
+        if !current.isEmpty { tokens.append(.word(current)) }
+
+        return tokens
+    }
+
+    // MARK: - Word Conversion
+
+    /// Public word-level phonemization for dictionary fallback.
+    func phonemizeWord(_ word: String) -> String {
+        return convertWord(word.lowercased())
+    }
+
+    private func convertWord(_ word: String) -> String {
+        var ipa: String
+        switch language {
+        case .french: ipa = frenchToIPA(word)
+        case .spanish: ipa = spanishToIPA(word)
+        case .portuguese: ipa = portugueseToIPA(word)
+        case .italian: ipa = italianToIPA(word)
+        }
+
+        // Apply E2M mappings to match Kokoro's training format.
+        // Kokoro was trained with espeak-ng output post-processed by misaki.
+        // These replace multi-char IPA sequences with single-char equivalents.
+        for (from, to) in Self.e2mMappings {
+            ipa = ipa.replacingOccurrences(of: from, with: to)
+        }
+
+        // Add primary stress mark for multi-syllable words.
+        if ipa.count >= 4 {
+            return "ˈ" + ipa
+        }
+        return ipa
+    }
+
+    // MARK: - E2M Post-Processing (Kokoro Training Format)
+
+    /// Mappings from standard IPA to Kokoro's internal format.
+    /// Sorted longest-first for correct greedy replacement.
+    private static let e2mMappings: [(from: String, to: String)] = [
+        // Affricates → ligatures (multi-char to single)
+        ("dʒ", "ʤ"), ("tʃ", "ʧ"), ("dz", "ʣ"),
+        // Consonant normalizations
+        ("ʁ", "ɹ"),     // French/German uvular → alveolar approximant
+        ("ɐ", "ə"),     // Near-open central → schwa
+    ]
+
+    // MARK: - French G2P
+
+    /// French grapheme-to-phoneme rules.
+    /// Nasals only before consonants (not before vowels or n/m).
+    private static let frenchRules: [(pattern: String, ipa: String)] = [
+        // Trigraphs / special combos
+        ("eau", "oː"), ("aux", "oː"), ("eux", "øː"), ("oeu", "œː"),
+        ("ain", "ɛ̃"), ("ein", "ɛ̃"), ("oin", "wɛ̃"),
+        ("ien", "jɛ̃"), ("ion", "jɔ̃"),
+        // Digraphs
+        ("ou", "uː"), ("oi", "waː"), ("ai", "ɛː"), ("ei", "ɛː"),
+        ("au", "oː"), ("eu", "øː"), ("ch", "ʃ"), ("ph", "f"),
+        ("th", "t"), ("gn", "ɲ"), ("qu", "k"), ("gu", "ɡ"),
+        ("ll", "l"), ("ss", "s"), ("tt", "t"), ("nn", "n"),
+        ("mm", "m"), ("pp", "p"), ("rr", "ʁ"), ("ff", "f"),
+        // Accented vowels
+        ("é", "eː"), ("è", "ɛː"), ("ê", "ɛː"), ("ë", "ɛ"),
+        ("à", "aː"), ("â", "ɑː"), ("ù", "yː"), ("û", "yː"),
+        ("î", "iː"), ("ï", "i"), ("ô", "oː"), ("ü", "yː"),
+        ("ç", "s"), ("œ", "œ"),
+        // Basic
+        ("a", "a"), ("b", "b"), ("c", "k"), ("d", "d"), ("e", "ə"),
+        ("f", "f"), ("g", "ɡ"), ("h", ""), ("i", "i"), ("j", "ʒ"),
+        ("k", "k"), ("l", "l"), ("m", "m"), ("n", "n"), ("o", "o"),
+        ("p", "p"), ("r", "ʁ"), ("s", "s"), ("t", "t"), ("u", "y"),
+        ("v", "v"), ("w", "w"), ("x", "ks"), ("y", "i"), ("z", "z"),
+    ]
+
+    private func frenchToIPA(_ word: String) -> String {
+        var result = ""
+        let chars = Array(word)
+        var i = 0
+
+        while i < chars.count {
+            var matched = false
+
+            // Context-dependent: c before e/i/y = s, g before e/i = ʒ
+            if i + 1 < chars.count {
+                let next = chars[i + 1]
+                if chars[i] == "c" && "eiéèêëîïy".contains(next) {
+                    result += "s"
+                    i += 1
+                    continue
+                }
+                if chars[i] == "g" && "eiéèêëîïy".contains(next) {
+                    result += "ʒ"
+                    i += 1
+                    continue
+                }
+            }
+
+            // Nasal vowels: on/an/en/in/un before consonant (not before vowel or n/m)
+            if i + 1 < chars.count {
+                let pair = String(chars[i...i+1])
+                let afterNasal: Character? = (i + 2 < chars.count) ? chars[i + 2] : nil
+                let nasalFollowedByVowelOrNM = afterNasal != nil && "aeiouyéèêëàâùûîïôüœ".contains(afterNasal!) || afterNasal == "n" || afterNasal == "m"
+                if !nasalFollowedByVowelOrNM {
+                    switch pair {
+                    case "on", "om": result += "ɔ̃"; i += 2; continue
+                    case "an", "am": result += "ɑ̃"; i += 2; continue
+                    case "en", "em": result += "ɑ̃"; i += 2; continue
+                    case "in", "im": result += "ɛ̃"; i += 2; continue
+                    case "un", "um": result += "œ̃"; i += 2; continue
+                    default: break
+                    }
+                }
+            }
+
+            // Try longest match first (3, 2, 1 chars)
+            for len in stride(from: min(3, chars.count - i), through: 1, by: -1) {
+                let substr = String(chars[i..<i+len])
+                if let rule = Self.frenchRules.first(where: { $0.pattern == substr }) {
+                    result += rule.ipa
+                    i += len
+                    matched = true
+                    break
+                }
+            }
+            if !matched {
+                result += String(chars[i])
+                i += 1
+            }
+        }
+
+        // Drop silent final consonants (French rule: d, t, s, x, z, p are silent at end)
+        if result.count > 1 {
+            let last = result.last!
+            if "dtsxzp".contains(last) {
+                result = String(result.dropLast())
+            }
+        }
+
+        return result
+    }
+
+    // MARK: - Spanish G2P
+
+    /// Spanish is very regular — nearly 1:1 grapheme-to-phoneme.
+    private static let spanishRules: [(pattern: String, ipa: String)] = [
+        // Digraphs
+        ("ch", "tʃ"), ("ll", "ʝ"), ("rr", "rː"), ("qu", "k"),
+        ("gu", "ɡ"), ("gü", "ɡw"),
+        ("ñ", "ɲ"),
+        // Accented vowels (stressed — add length)
+        ("á", "aː"), ("é", "eː"), ("í", "iː"), ("ó", "oː"), ("ú", "uː"), ("ü", "w"),
+        // Basic
+        ("a", "a"), ("b", "b"), ("c", "k"), ("d", "d"), ("e", "e"),
+        ("f", "f"), ("g", "ɡ"), ("h", ""), ("i", "i"), ("j", "x"),
+        ("k", "k"), ("l", "l"), ("m", "m"), ("n", "n"), ("o", "o"),
+        ("p", "p"), ("r", "ɾ"), ("s", "s"), ("t", "t"), ("u", "u"),
+        ("v", "b"), ("w", "w"), ("x", "ks"), ("y", "ʝ"), ("z", "θ"),
+    ]
+
+    private func spanishToIPA(_ word: String) -> String {
+        var result = ""
+        let chars = Array(word)
+        var i = 0
+
+        while i < chars.count {
+            // Context: c before e/i = θ, g before e/i = x
+            if i + 1 < chars.count {
+                if chars[i] == "c" && "eiéí".contains(chars[i+1]) {
+                    result += "θ"
+                    i += 1
+                    continue
+                }
+                if chars[i] == "g" && "eiéí".contains(chars[i+1]) {
+                    result += "x"
+                    i += 1
+                    continue
+                }
+            }
+
+            var matched = false
+            for len in stride(from: min(2, chars.count - i), through: 1, by: -1) {
+                let substr = String(chars[i..<i+len])
+                if let rule = Self.spanishRules.first(where: { $0.pattern == substr }) {
+                    result += rule.ipa
+                    i += len
+                    matched = true
+                    break
+                }
+            }
+            if !matched {
+                result += String(chars[i])
+                i += 1
+            }
+        }
+
+        return result
+    }
+
+    // MARK: - Portuguese G2P
+
+    private static let portugueseRules: [(pattern: String, ipa: String)] = [
+        // Digraphs / trigraphs
+        ("ção", "saːw̃"), ("ções", "sõːjs"), ("nh", "ɲ"), ("lh", "ʎ"),
+        ("ch", "ʃ"), ("qu", "k"), ("gu", "ɡ"), ("rr", "ʁː"),
+        ("ss", "s"), ("sc", "s"),
+        // Explicit nasal diphthongs
+        ("ão", "aːw̃"), ("ãe", "aːj̃"), ("õe", "oːj̃"),
+        // Accented
+        ("á", "aː"), ("â", "ɐː"), ("ã", "ɐ̃ː"), ("é", "ɛː"), ("ê", "eː"),
+        ("í", "iː"), ("ó", "ɔː"), ("ô", "oː"), ("õ", "õː"), ("ú", "uː"),
+        ("ç", "s"),
+        // Diphthongs
+        ("ou", "oː"), ("ei", "eːj"), ("ai", "aːj"), ("oi", "oːj"),
+        // Basic
+        ("a", "a"), ("b", "b"), ("c", "k"), ("d", "d"), ("e", "e"),
+        ("f", "f"), ("g", "ɡ"), ("h", ""), ("i", "i"), ("j", "ʒ"),
+        ("k", "k"), ("l", "l"), ("m", "m"), ("n", "n"), ("o", "o"),
+        ("p", "p"), ("r", "ɾ"), ("s", "s"), ("t", "t"), ("u", "u"),
+        ("v", "v"), ("w", "w"), ("x", "ʃ"), ("y", "i"), ("z", "z"),
+    ]
+
+    private func portugueseToIPA(_ word: String) -> String {
+        var result = ""
+        let chars = Array(word)
+        var i = 0
+
+        while i < chars.count {
+            // Context: c before e/i = s
+            if i + 1 < chars.count && chars[i] == "c" && "eiéí".contains(chars[i+1]) {
+                result += "s"
+                i += 1
+                continue
+            }
+
+            var matched = false
+            for len in stride(from: min(4, chars.count - i), through: 1, by: -1) {
+                let substr = String(chars[i..<i+len])
+                if let rule = Self.portugueseRules.first(where: { $0.pattern == substr }) {
+                    result += rule.ipa
+                    i += len
+                    matched = true
+                    break
+                }
+            }
+            if !matched {
+                result += String(chars[i])
+                i += 1
+            }
+        }
+
+        return result
+    }
+
+    // MARK: - Italian G2P
+
+    /// Italian is highly regular — nearly 1:1 grapheme-to-phoneme.
+    /// Main exceptions: c/g before e/i, gl, gn, sc digraphs.
+    private static let italianRules: [(pattern: String, ipa: String)] = [
+        // Trigraphs
+        ("gli", "ʎi"), ("sce", "ʃe"), ("sci", "ʃi"),
+        ("ghi", "ɡi"), ("ghe", "ɡe"), ("chi", "ki"), ("che", "ke"),
+        // Digraphs
+        ("gn", "ɲ"), ("gl", "ʎ"), ("sc", "sk"),
+        ("gh", "ɡ"), ("ch", "k"), ("qu", "kw"),
+        ("ci", "tʃi"), ("ce", "tʃe"),
+        ("gi", "dʒi"), ("ge", "dʒe"),
+        ("zz", "tːs"), ("ss", "sː"), ("rr", "rː"), ("ll", "lː"),
+        ("nn", "nː"), ("mm", "mː"), ("pp", "pː"), ("tt", "tː"),
+        ("cc", "kː"), ("ff", "fː"), ("bb", "bː"), ("dd", "dː"),
+        ("gg", "ɡː"),
+        // Accented vowels
+        ("à", "a"), ("è", "ɛ"), ("é", "e"), ("ì", "i"), ("ò", "ɔ"), ("ó", "o"), ("ù", "u"),
+        // Basic — Italian vowels are pure, consonants are straightforward
+        ("a", "a"), ("b", "b"), ("c", "k"), ("d", "d"), ("e", "e"),
+        ("f", "f"), ("g", "ɡ"), ("h", ""), ("i", "i"), ("j", "j"),
+        ("k", "k"), ("l", "l"), ("m", "m"), ("n", "n"), ("o", "o"),
+        ("p", "p"), ("r", "r"), ("s", "s"), ("t", "t"), ("u", "u"),
+        ("v", "v"), ("w", "w"), ("x", "ks"), ("y", "i"), ("z", "ts"),
+    ]
+
+    private func italianToIPA(_ word: String) -> String {
+        var result = ""
+        let chars = Array(word)
+        var i = 0
+
+        while i < chars.count {
+            var matched = false
+            for len in stride(from: min(3, chars.count - i), through: 1, by: -1) {
+                let substr = String(chars[i..<i+len])
+                if let rule = Self.italianRules.first(where: { $0.pattern == substr }) {
+                    result += rule.ipa
+                    i += len
+                    matched = true
+                    break
+                }
+            }
+            if !matched {
+                result += String(chars[i])
+                i += 1
+            }
+        }
+
+        return result
+    }
+
+}

package/ios/Sources/ElizaBunRuntimePlugin/kokoro/KokoroCoreMlModel.swift

@@ -0,0 +1,87 @@
+import CoreML
+import Foundation
+
+/// CoreML wrapper for Kokoro-82M end-to-end TTS inference.
+///
+/// Loads a single pre-compiled `kokoro_5s.mlmodelc` that runs the full pipeline
+/// (BERT → duration → alignment → prosody → decoder) in one CoreML call.
+class KokoroNetwork {
+
+    private let e2eModel: MLModel
+
+    /// Load E2E CoreML model from cache directory.
+    init(directory: URL, computeUnits: MLComputeUnits = .all) throws {
+        let config = MLModelConfiguration()
+        config.computeUnits = computeUnits
+
+        let e2eNames = ["kokoro_5s", "kokoro_10s", "kokoro_15s", "kokoro"]
+        var loaded: MLModel?
+        for name in e2eNames {
+            let url = directory.appendingPathComponent("\(name).mlmodelc", isDirectory: true)
+            if FileManager.default.fileExists(atPath: url.path) {
+                loaded = try MLModel(contentsOf: url, configuration: config)
+                break
+            }
+        }
+
+        guard let model = loaded else {
+            throw AudioModelError.modelLoadFailed(
+                modelId: "kokoro",
+                reason: "No Kokoro E2E model found in \(directory.path)")
+        }
+        e2eModel = model
+    }
+
+    // MARK: - E2E Inference
+
+    struct E2EOutput {
+        let audio: MLMultiArray
+        let audioLengthSamples: Int
+        let predDur: MLMultiArray
+    }
+
+    func predictE2E(
+        inputIds: MLMultiArray,
+        attentionMask: MLMultiArray,
+        refS: MLMultiArray,
+        speed: MLMultiArray? = nil
+    ) throws -> E2EOutput {
+        let randomPhases = try MLMultiArray(shape: [1, 9], dataType: .float32)
+        for i in 0..<9 { randomPhases[i] = NSNumber(value: Float.random(in: 0..<1)) }
+
+        let speedInput = speed ?? {
+            let s = try! MLMultiArray(shape: [1], dataType: .float32)
+            s[0] = NSNumber(value: Float(1.0))
+            return s
+        }()
+
+        let dict: [String: MLFeatureValue] = [
+            "input_ids": MLFeatureValue(multiArray: inputIds),
+            "attention_mask": MLFeatureValue(multiArray: attentionMask),
+            "ref_s": MLFeatureValue(multiArray: refS),
+            "random_phases": MLFeatureValue(multiArray: randomPhases),
+            "speed": MLFeatureValue(multiArray: speedInput),
+        ]
+
+        let input = try MLDictionaryFeatureProvider(dictionary: dict)
+        let output = try e2eModel.prediction(from: input)
+
+        guard let audio = output.featureValue(for: "audio")?.multiArrayValue,
+              let audioLen = output.featureValue(for: "audio_length_samples")?.multiArrayValue,
+              let predDur = output.featureValue(for: "pred_dur")?.multiArrayValue else {
+            throw AudioModelError.inferenceFailed(
+                operation: "kokoro-e2e", reason: "Missing output tensors")
+        }
+
+        let lengthSamples: Int
+        if #available(iOS 16.0, *), audioLen.dataType == .float16 {
+            lengthSamples = Int(Float(audioLen.dataPointer.assumingMemoryBound(to: Float16.self).pointee))
+        } else if audioLen.dataType == .int32 {
+            lengthSamples = Int(audioLen.dataPointer.assumingMemoryBound(to: Int32.self).pointee)
+        } else {
+            lengthSamples = Int(audioLen.dataPointer.assumingMemoryBound(to: Float.self).pointee)
+        }
+
+        return E2EOutput(audio: audio, audioLengthSamples: lengthSamples, predDur: predDur)
+    }
+}