react-native-tts-kit 0.1.0

package/ios/Supertonic/SupertonicSession.swift

@@ -0,0 +1,405 @@
+import Foundation
+import onnxruntime_objc
+
+enum SupertonicError: LocalizedError {
+    case modelMissing
+    case voiceMissing(String)
+    case textTooLong
+    case cancelled
+    case configMissing(String)
+
+    var errorDescription: String? {
+        switch self {
+        case .modelMissing: return "Supertonic asset bundle is missing. Call TTSKit.prefetchModel() first."
+        case .voiceMissing(let id): return "Voice \(id) is not available."
+        case .textTooLong: return "Input text exceeds the maximum length."
+        case .cancelled: return "Synthesis cancelled."
+        case .configMissing(let key): return "Required config key missing: \(key)."
+        }
+    }
+}
+
+private struct TTSConfig: Decodable {
+    struct AE: Decodable { let sample_rate: Int; let base_chunk_size: Int }
+    struct TTL: Decodable { let chunk_compress_factor: Int; let latent_dim: Int }
+    let ae: AE
+    let ttl: TTL
+}
+
+/// Real Supertonic inference pipeline (ported from `supertone-inc/supertonic/swift`).
+///
+/// Four ONNX sessions:
+///   1. duration_predictor → per-chunk duration in seconds
+///   2. text_encoder       → text embedding tensor
+///   3. vector_estimator   → iterative diffusion denoising (totalStep iterations)
+///   4. vocoder            → final waveform
+final class SupertonicSession {
+    private var env: ORTEnv?
+    private var dpSession: ORTSession?
+    private var encSession: ORTSession?
+    private var vecSession: ORTSession?
+    private var vocSession: ORTSession?
+    private var indexer: UnicodeIndexer?
+    private var voiceCache: [String: VoicePack] = [:]
+    private var config: TTSConfig?
+
+    private let cancelLock = NSLock()
+    private var _cancelled = false
+
+    var isReady: Bool { dpSession != nil && encSession != nil && vecSession != nil && vocSession != nil && indexer != nil && config != nil }
+    var sampleRate: Int { config?.ae.sample_rate ?? 24_000 }
+
+    func loadIfNeeded() throws {
+        guard !isReady else { return }
+        guard ModelLocator.modelExists() else { throw SupertonicError.modelMissing }
+
+        let env = try ORTEnv(loggingLevel: .warning)
+        let opts = try ORTSessionOptions()
+        try opts.setIntraOpNumThreads(2)
+        try opts.setGraphOptimizationLevel(.all)
+
+        self.env = env
+
+        // Per-file load + log. Without this, if one of the four sessions
+        // throws (e.g. fp16 type mismatch on vector_estimator) it's hard to
+        // tell from JS which file failed.
+        func loadSession(_ filename: String) throws -> ORTSession {
+            let path = ModelLocator.resolvedOnnxURL(for: filename).path
+            do {
+                let s = try ORTSession(env: env, modelPath: path, sessionOptions: opts)
+                NSLog("[ST.load] ok %@ (%@)", filename, ModelLocator.precision.rawValue)
+                return s
+            } catch {
+                NSLog("[ST.load] FAIL %@ (%@) at %@ — %@",
+                      filename, ModelLocator.precision.rawValue, path,
+                      String(describing: error))
+                throw error
+            }
+        }
+
+        self.dpSession  = try loadSession("duration_predictor.onnx")
+        self.encSession = try loadSession("text_encoder.onnx")
+        self.vecSession = try loadSession("vector_estimator.onnx")
+        self.vocSession = try loadSession("vocoder.onnx")
+
+        let cfgURL = ModelLocator.resolvedOnnxURL(for: "tts.json")
+        let cfgData = try Data(contentsOf: cfgURL)
+        self.config = try JSONDecoder().decode(TTSConfig.self, from: cfgData)
+
+        let idxURL = ModelLocator.resolvedOnnxURL(for: "unicode_indexer.json")
+        self.indexer = try UnicodeIndexer(url: idxURL)
+    }
+
+    func voicePack(for voiceId: String) throws -> VoicePack {
+        if let cached = voiceCache[voiceId] { return cached }
+        let url = ModelLocator.resolvedVoiceURL(for: voiceId)
+        guard FileManager.default.fileExists(atPath: url.path) else {
+            throw SupertonicError.voiceMissing(voiceId)
+        }
+        let pack = try VoicePack(voiceId: voiceId, url: url)
+        // Bound the cache. With 10 total voices we never actually evict in
+        // practice, but the cap means a future model expansion can't leak.
+        if voiceCache.count >= 8 {
+            voiceCache.removeAll()
+        }
+        voiceCache[voiceId] = pack
+        return pack
+    }
+
+    /// Warm the JSON-decode + tensor-allocation path for the most likely
+    /// first-tap voice. Called from `prefetch()` so the user's first `speak()`
+    /// doesn't pay the 50–150 ms voice-load cost mid-tap.
+    func prewarmDefaultVoice() {
+        try? _ = voicePack(for: "F1")
+    }
+
+    /// Drop all loaded sessions, indexer, voice tensors. Called from
+    /// `OnDestroy` so resources release deterministically rather than waiting
+    /// for ARC.
+    func tearDown() {
+        voiceCache.removeAll()
+        indexer = nil
+        config = nil
+        dpSession = nil
+        encSession = nil
+        vecSession = nil
+        vocSession = nil
+        env = nil
+    }
+
+    func beginRun() {
+        cancelLock.lock(); _cancelled = false; cancelLock.unlock()
+    }
+
+    func cancel() {
+        cancelLock.lock(); _cancelled = true; cancelLock.unlock()
+    }
+
+    private var isCancelled: Bool {
+        cancelLock.lock(); defer { cancelLock.unlock() }
+        return _cancelled
+    }
+
+    // MARK: - Inference
+
+    /// Synthesize a single (already-chunked) input. Returns float32 PCM in [-1, 1].
+    /// Use `synthesize` / `synthesizeStreaming` from the module layer; those handle chunking.
+    func synthesizeOne(text: String, lang: String, voiceId: String, totalStep: Int, speed: Double) throws -> [Float] {
+        // Per-stage timing. Logs once per call so the line count stays small;
+        // remove or guard with a debug flag before tagging a release if it
+        // turns out to be noisy.
+        let t0 = CFAbsoluteTimeGetCurrent()
+        func dMs(_ from: CFAbsoluteTime, _ to: CFAbsoluteTime) -> String {
+            String(format: "%.0f", (to - from) * 1000)
+        }
+
+        try loadIfNeeded()
+        let tLoad = CFAbsoluteTimeGetCurrent()
+        guard let cfg = config, env != nil, let indexer = indexer,
+              let dp = dpSession, let enc = encSession, let vec = vecSession, let voc = vocSession else {
+            throw SupertonicError.modelMissing
+        }
+        let voice = try voicePack(for: voiceId)
+        let tVoice = CFAbsoluteTimeGetCurrent()
+
+        let processed = TextFrontend.preprocess(text, lang: lang)
+        let textIds: [Int64] = indexer.encode(processed)
+        if textIds.isEmpty { return [] }
+        let bsz = 1
+        let textLen = textIds.count
+        let textMask: [Float] = Array(repeating: 1.0, count: textLen)
+        let tText = CFAbsoluteTimeGetCurrent()
+
+        if isCancelled { throw SupertonicError.cancelled }
+
+        let textIdsValue = try ORTValue(
+            tensorData: NSMutableData(bytes: textIds, length: textIds.count * MemoryLayout<Int64>.size),
+            elementType: .int64,
+            shape: [NSNumber(value: bsz), NSNumber(value: textLen)]
+        )
+        let textMaskValue = try ORTValue(
+            tensorData: NSMutableData(bytes: textMask, length: textMask.count * MemoryLayout<Float>.size),
+            elementType: .float,
+            shape: [NSNumber(value: bsz), NSNumber(value: 1), NSNumber(value: textLen)]
+        )
+
+        let tTensors = CFAbsoluteTimeGetCurrent()
+
+        // 1. Duration prediction.
+        let dpOut = try dp.run(
+            withInputs: ["text_ids": textIdsValue, "style_dp": voice.dpValue, "text_mask": textMaskValue],
+            outputNames: ["duration"],
+            runOptions: nil
+        )
+        guard let durValue = dpOut["duration"] else { throw SupertonicError.modelMissing }
+        let durData = try durValue.tensorData() as Data
+        var duration: [Float] = durData.withUnsafeBytes {
+            Array(UnsafeBufferPointer(start: $0.bindMemory(to: Float.self).baseAddress, count: durData.count / 4))
+        }
+        for i in 0..<duration.count { duration[i] /= Float(speed) }
+        let tDP = CFAbsoluteTimeGetCurrent()
+
+        if isCancelled { throw SupertonicError.cancelled }
+
+        // 2. Text encoder. Hold the ORTValue across the denoising loop —
+        // Swift ARC keeps it alive; the upstream Helper.swift reference uses
+        // the same pattern and works.
+        let encOut = try enc.run(
+            withInputs: ["text_ids": textIdsValue, "style_ttl": voice.ttlValue, "text_mask": textMaskValue],
+            outputNames: ["text_emb"],
+            runOptions: nil
+        )
+        guard let textEmb = encOut["text_emb"] else { throw SupertonicError.modelMissing }
+        let tEnc = CFAbsoluteTimeGetCurrent()
+
+        // 3. Sample initial noisy latent + mask.
+        let baseChunk = cfg.ae.base_chunk_size
+        let chunkCompress = cfg.ttl.chunk_compress_factor
+        let latentDimBase = cfg.ttl.latent_dim
+        let latentDim = latentDimBase * chunkCompress
+        let chunkSize = baseChunk * chunkCompress
+        let maxDur = duration.max() ?? 0
+        let wavLenMax = Int(maxDur * Float(cfg.ae.sample_rate))
+        let latentLen = (wavLenMax + chunkSize - 1) / chunkSize
+        let wavLengths = duration.map { Int($0 * Float(cfg.ae.sample_rate)) }
+        let latentLengths = wavLengths.map { ($0 + chunkSize - 1) / chunkSize }
+
+        var noisy = [Float](repeating: 0, count: bsz * latentDim * latentLen)
+        // Box-Muller -> gaussian noise, then masked.
+        var idx = 0
+        for b in 0..<bsz {
+            let lLen = latentLengths[b]
+            for d in 0..<latentDim {
+                for t in 0..<latentLen {
+                    if t < lLen {
+                        let u1 = Float.random(in: 1e-7...1.0)
+                        let u2 = Float.random(in: 0.0...1.0)
+                        noisy[idx] = sqrt(-2.0 * log(u1)) * cos(2.0 * .pi * u2)
+                    }
+                    idx += 1
+                }
+                _ = d
+            }
+            _ = b
+        }
+        var latentMask = [Float](repeating: 0, count: bsz * 1 * latentLen)
+        for b in 0..<bsz {
+            for t in 0..<latentLengths[b] {
+                latentMask[b * latentLen + t] = 1.0
+            }
+        }
+
+        let latentMaskValue = try ORTValue(
+            tensorData: NSMutableData(bytes: latentMask, length: latentMask.count * MemoryLayout<Float>.size),
+            elementType: .float,
+            shape: [NSNumber(value: bsz), NSNumber(value: 1), NSNumber(value: latentLen)]
+        )
+        let totalStepArr = [Float](repeating: Float(totalStep), count: bsz)
+        let totalStepValue = try ORTValue(
+            tensorData: NSMutableData(bytes: totalStepArr, length: totalStepArr.count * MemoryLayout<Float>.size),
+            elementType: .float,
+            shape: [NSNumber(value: bsz)]
+        )
+        let tNoise = CFAbsoluteTimeGetCurrent()
+
+        // 4. Denoising loop. Per-step time logged so we can see if the bottleneck
+        // is ramp-up (first step paying compile cost) vs. steady-state.
+        var stepTimes: [Double] = []
+        for step in 0..<totalStep {
+            let tStepStart = CFAbsoluteTimeGetCurrent()
+            if isCancelled { throw SupertonicError.cancelled }
+            let xtValue = try ORTValue(
+                tensorData: NSMutableData(bytes: noisy, length: noisy.count * MemoryLayout<Float>.size),
+                elementType: .float,
+                shape: [NSNumber(value: bsz), NSNumber(value: latentDim), NSNumber(value: latentLen)]
+            )
+            let curStepArr = [Float](repeating: Float(step), count: bsz)
+            let curStepValue = try ORTValue(
+                tensorData: NSMutableData(bytes: curStepArr, length: curStepArr.count * MemoryLayout<Float>.size),
+                elementType: .float,
+                shape: [NSNumber(value: bsz)]
+            )
+            let vecOut = try vec.run(
+                withInputs: [
+                    "noisy_latent": xtValue,
+                    "text_emb": textEmb,
+                    "style_ttl": voice.ttlValue,
+                    "latent_mask": latentMaskValue,
+                    "text_mask": textMaskValue,
+                    "current_step": curStepValue,
+                    "total_step": totalStepValue
+                ],
+                outputNames: ["denoised_latent"],
+                runOptions: nil
+            )
+            guard let denoised = vecOut["denoised_latent"] else { throw SupertonicError.modelMissing }
+            let dData = try denoised.tensorData() as Data
+            noisy = dData.withUnsafeBytes {
+                Array(UnsafeBufferPointer(start: $0.bindMemory(to: Float.self).baseAddress, count: dData.count / 4))
+            }
+            stepTimes.append((CFAbsoluteTimeGetCurrent() - tStepStart) * 1000)
+        }
+        let tDiffusion = CFAbsoluteTimeGetCurrent()
+
+        if isCancelled { throw SupertonicError.cancelled }
+
+        // 5. Vocoder.
+        let finalLatent = try ORTValue(
+            tensorData: NSMutableData(bytes: noisy, length: noisy.count * MemoryLayout<Float>.size),
+            elementType: .float,
+            shape: [NSNumber(value: bsz), NSNumber(value: latentDim), NSNumber(value: latentLen)]
+        )
+        let vocOut = try voc.run(
+            withInputs: ["latent": finalLatent],
+            outputNames: ["wav_tts"],
+            runOptions: nil
+        )
+        guard let wav = vocOut["wav_tts"] else { throw SupertonicError.modelMissing }
+        let wavData = try wav.tensorData() as Data
+        var wavSamples: [Float] = wavData.withUnsafeBytes {
+            Array(UnsafeBufferPointer(start: $0.bindMemory(to: Float.self).baseAddress, count: wavData.count / 4))
+        }
+
+        // Trim to actual duration to drop silence padding.
+        let trimLen = min(wavSamples.count, Int(duration[0] * Float(cfg.ae.sample_rate)))
+        if trimLen > 0 && trimLen < wavSamples.count {
+            wavSamples = Array(wavSamples.prefix(trimLen))
+        }
+        let tVoc = CFAbsoluteTimeGetCurrent()
+
+        // One-line summary so this is easy to grep in Xcode console: "[ST.timing]"
+        let totalMs = (tVoc - t0) * 1000
+        let stepSummary = stepTimes.enumerated()
+            .map { String(format: "%d:%.0f", $0.offset, $0.element) }
+            .joined(separator: " ")
+        NSLog("[ST.timing] total=\(String(format: "%.0f", totalMs))ms "
+            + "load=\(dMs(t0, tLoad)) voice=\(dMs(tLoad, tVoice)) "
+            + "text=\(dMs(tVoice, tText)) tensors=\(dMs(tText, tTensors)) "
+            + "dp=\(dMs(tTensors, tDP)) enc=\(dMs(tDP, tEnc)) "
+            + "noise=\(dMs(tEnc, tNoise)) diffusion=\(dMs(tNoise, tDiffusion)) "
+            + "voc=\(dMs(tDiffusion, tVoc)) "
+            + "chars=\(textIds.count) latentLen=\(latentLen) steps=[\(stepSummary)]")
+        return wavSamples
+    }
+
+    /// Single-shot synthesis with chunking + 0.3s silence between chunks.
+    func synthesize(text: String, lang: String, voiceId: String, totalStep: Int, speed: Double) throws -> [Float] {
+        beginRun()
+        let chunks = TextFrontend.chunk(text, lang: lang)
+        if chunks.isEmpty { return [] }
+        let silenceSamples = Int(0.3 * Double(sampleRate))
+        let silence = [Float](repeating: 0, count: silenceSamples)
+
+        var out: [Float] = []
+        for (i, c) in chunks.enumerated() {
+            if isCancelled { throw SupertonicError.cancelled }
+            let pcm = try synthesizeOne(text: c, lang: lang, voiceId: voiceId, totalStep: totalStep, speed: speed)
+            if i > 0 { out.append(contentsOf: silence) }
+            out.append(contentsOf: pcm)
+        }
+        return out
+    }
+
+    /// Streaming: emit one chunk per sentence-ish unit to keep TTFA low.
+    func synthesizeStreaming(
+        text: String,
+        lang: String,
+        voiceId: String,
+        totalStep: Int,
+        speed: Double,
+        onChunk: ([Float]) -> Void
+    ) throws {
+        let tStart = CFAbsoluteTimeGetCurrent()
+        try loadIfNeeded()
+        beginRun()
+        let chunks = TextFrontend.chunk(text, lang: lang)
+        var firstChunkLogged = false
+        for c in chunks {
+            if isCancelled { throw SupertonicError.cancelled }
+            let pcm = try synthesizeOne(text: c, lang: lang, voiceId: voiceId, totalStep: totalStep, speed: speed)
+            if !pcm.isEmpty {
+                if !firstChunkLogged {
+                    let ttfa = (CFAbsoluteTimeGetCurrent() - tStart) * 1000
+                    NSLog(String(format: "[ST.timing] TTFA=%.0fms (first chunk emitted, chunks=%d)", ttfa, chunks.count))
+                    firstChunkLogged = true
+                }
+                onChunk(pcm)
+            }
+        }
+    }
+
+    // MARK: - Bridge helpers
+
+    /// Converts float32 samples to little-endian PCM16 for transport across the JS bridge.
+    static func toPCM16(samples: [Float]) -> Data {
+        var out = Data(count: samples.count * 2)
+        out.withUnsafeMutableBytes { (raw: UnsafeMutableRawBufferPointer) in
+            let int16s = raw.bindMemory(to: Int16.self)
+            for i in 0..<samples.count {
+                let clamped = max(-1.0, min(1.0, samples[i]))
+                int16s[i] = Int16(clamped * 32767.0).littleEndian
+            }
+        }
+        return out
+    }
+}

package/ios/Supertonic/TextFrontend.swift

@@ -0,0 +1,216 @@
+import Foundation
+
+/// Self-contained text frontend for Supertonic.
+///
+/// Ported from `supertone-inc/supertonic/swift/Sources/Helper.swift` —
+/// keep this file in sync if upstream's preprocessing changes.
+///
+/// Key behaviors:
+///   1. NFKD-decompose text (`decomposedStringWithCompatibilityMapping`).
+///   2. Strip emoji + symbols, collapse whitespace, normalize punctuation spacing.
+///   3. Wrap with `<lang>...</lang>` markers.
+///   4. Tokenize: codepoint -> indexer[codepoint] -> Int64 token id.
+///      The `unicode_indexer.json` shipped alongside the model is a flat
+///      `[Int64]` array of length 2^16 (BMP); index by codepoint, get token id.
+///      Codepoints outside the array become -1 (the model's PAD/UNK).
+enum TextFrontend {
+    static let availableLangs: Set<String> = [
+        "en", "ko", "ja", "ar", "bg", "cs", "da", "de", "el", "es", "et", "fi",
+        "fr", "hi", "hr", "hu", "id", "it", "lt", "lv", "nl", "pl", "pt", "ro",
+        "ru", "sk", "sl", "sv", "tr", "uk", "vi"
+    ]
+
+    /// Per-language max chunk length (matches upstream).
+    static func maxChunkLength(for lang: String) -> Int {
+        return (lang == "ko" || lang == "ja") ? 120 : 300
+    }
+
+    /// Apply upstream's text normalization rules and wrap with `<lang>...</lang>`.
+    static func preprocess(_ text: String, lang: String) -> String {
+        precondition(availableLangs.contains(lang), "Unsupported language: \(lang)")
+
+        var s = text.decomposedStringWithCompatibilityMapping
+
+        // Strip wide-Unicode emoji blocks.
+        s = String(String.UnicodeScalarView(s.unicodeScalars.filter { scalar in
+            let v = scalar.value
+            return !((0x1F600...0x1F64F).contains(v) ||
+                     (0x1F300...0x1F5FF).contains(v) ||
+                     (0x1F680...0x1F6FF).contains(v) ||
+                     (0x1F700...0x1F77F).contains(v) ||
+                     (0x1F780...0x1F7FF).contains(v) ||
+                     (0x1F800...0x1F8FF).contains(v) ||
+                     (0x1F900...0x1F9FF).contains(v) ||
+                     (0x1FA00...0x1FA6F).contains(v) ||
+                     (0x1FA70...0x1FAFF).contains(v) ||
+                     (0x2600...0x26FF).contains(v) ||
+                     (0x2700...0x27BF).contains(v) ||
+                     (0x1F1E6...0x1F1FF).contains(v))
+        }))
+
+        let replacements: [(String, String)] = [
+            ("\u{2013}", "-"), ("\u{2011}", "-"), ("\u{2014}", "-"),
+            ("_", " "),
+            ("\u{201C}", "\""), ("\u{201D}", "\""),
+            ("\u{2018}", "'"), ("\u{2019}", "'"),
+            ("´", "'"), ("`", "'"),
+            ("[", " "), ("]", " "),
+            ("|", " "), ("/", " "), ("#", " "),
+            ("→", " "), ("←", " ")
+        ]
+        for (k, v) in replacements { s = s.replacingOccurrences(of: k, with: v) }
+
+        for sym in ["♥", "☆", "♡", "©", "\\"] {
+            s = s.replacingOccurrences(of: sym, with: "")
+        }
+
+        for (k, v) in [("@", " at "), ("e.g.,", "for example, "), ("i.e.,", "that is, ")] {
+            s = s.replacingOccurrences(of: k, with: v)
+        }
+
+        let punctSpacing = [(" ,", ","), (" .", "."), (" !", "!"), (" ?", "?"),
+                            (" ;", ";"), (" :", ":"), (" '", "'")]
+        for (k, v) in punctSpacing { s = s.replacingOccurrences(of: k, with: v) }
+
+        while s.contains("\"\"") { s = s.replacingOccurrences(of: "\"\"", with: "\"") }
+        while s.contains("''")   { s = s.replacingOccurrences(of: "''",   with: "'") }
+        while s.contains("``")   { s = s.replacingOccurrences(of: "``",   with: "`") }
+
+        let ws = try! NSRegularExpression(pattern: "\\s+")
+        s = ws.stringByReplacingMatches(
+            in: s,
+            range: NSRange(s.startIndex..., in: s),
+            withTemplate: " "
+        ).trimmingCharacters(in: .whitespacesAndNewlines)
+
+        if !s.isEmpty {
+            let endsWithPunct = try! NSRegularExpression(
+                pattern: "[.!?;:,'\"\\u201C\\u201D\\u2018\\u2019)\\]}…。」』】〉》›»]$"
+            )
+            if endsWithPunct.firstMatch(in: s, range: NSRange(s.startIndex..., in: s)) == nil {
+                s += "."
+            }
+        }
+        return "<\(lang)>\(s)</\(lang)>"
+    }
+
+    /// Sentence-aware chunking, mirrors `chunkText` in upstream Helper.swift.
+    /// Chunks at hard sentence boundaries; falls back to commas / spaces for
+    /// pathologically long inputs.
+    private static let abbreviations: Set<String> = [
+        "Dr.", "Mr.", "Mrs.", "Ms.", "Prof.", "Sr.", "Jr.",
+        "St.", "Ave.", "Rd.", "Blvd.", "Dept.", "Inc.", "Ltd.",
+        "Co.", "Corp.", "etc.", "vs.", "i.e.", "e.g.", "Ph.D."
+    ]
+
+    static func chunk(_ text: String, lang: String) -> [String] {
+        let maxLen = maxChunkLength(for: lang)
+        let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
+        if trimmed.isEmpty { return [] }
+
+        let paragraphs = splitParagraphs(trimmed)
+
+        var chunks: [String] = []
+        for p in paragraphs.isEmpty ? [trimmed] : paragraphs {
+            if p.count <= maxLen { chunks.append(p); continue }
+            chunks.append(contentsOf: greedyJoin(splitSentences(p), maxLen: maxLen))
+        }
+        return chunks.isEmpty ? [trimmed] : chunks
+    }
+
+    /// Split on `\n\s*\n+` — blank-line paragraph boundaries, mirroring
+    /// upstream Helper.swift / helper.py. The previous implementation used a
+    /// no-op ternary that never invoked the regex.
+    private static func splitParagraphs(_ text: String) -> [String] {
+        let regex = try! NSRegularExpression(pattern: "\\n\\s*\\n+")
+        let nsText = text as NSString
+        let fullRange = NSRange(location: 0, length: nsText.length)
+        let matches = regex.matches(in: text, range: fullRange)
+        if matches.isEmpty {
+            return [text].filter { !$0.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty }
+        }
+        var out: [String] = []
+        var cursor = 0
+        for m in matches {
+            let piece = nsText.substring(with: NSRange(location: cursor, length: m.range.location - cursor))
+            let trimmed = piece.trimmingCharacters(in: .whitespacesAndNewlines)
+            if !trimmed.isEmpty { out.append(trimmed) }
+            cursor = m.range.location + m.range.length
+        }
+        if cursor < nsText.length {
+            let tail = nsText.substring(from: cursor).trimmingCharacters(in: .whitespacesAndNewlines)
+            if !tail.isEmpty { out.append(tail) }
+        }
+        return out
+    }
+
+    /// Split into sentences. Now recognises Asian terminal punctuation
+    /// (`。！？`) which doesn't require trailing whitespace, so long
+    /// Japanese / Chinese strings actually chunk instead of collapsing into a
+    /// single oversized chunk that the model truncates.
+    private static func splitSentences(_ text: String) -> [String] {
+        // Latin-style: sentence-ender + whitespace.
+        // Asian-style: 。！？ — whitespace optional.
+        let regex = try! NSRegularExpression(pattern: "([.!?])\\s+|([。！？])")
+        let range = NSRange(text.startIndex..., in: text)
+        let matches = regex.matches(in: text, range: range)
+        if matches.isEmpty { return [text] }
+
+        var sentences: [String] = []
+        var lastEnd = text.startIndex
+
+        for m in matches {
+            guard let r = Range(m.range, in: text) else { continue }
+            let before = String(text[lastEnd..<r.lowerBound])
+            let punc = String(text[Range(NSRange(location: m.range.location, length: 1), in: text)!])
+            let combined = before.trimmingCharacters(in: .whitespaces) + punc
+            let isAbbrev = abbreviations.contains { combined.hasSuffix($0) }
+            if !isAbbrev {
+                sentences.append(String(text[lastEnd..<r.upperBound]))
+                lastEnd = r.upperBound
+            }
+        }
+        if lastEnd < text.endIndex { sentences.append(String(text[lastEnd...])) }
+        return sentences.isEmpty ? [text] : sentences
+    }
+
+    private static func greedyJoin(_ pieces: [String], maxLen: Int) -> [String] {
+        var out: [String] = []
+        var current = ""
+        for piece in pieces {
+            let p = piece.trimmingCharacters(in: .whitespacesAndNewlines)
+            if p.isEmpty { continue }
+            if current.isEmpty {
+                current = p
+            } else if current.count + 1 + p.count <= maxLen {
+                current += " " + p
+            } else {
+                out.append(current)
+                current = p
+            }
+        }
+        if !current.isEmpty { out.append(current) }
+        return out
+    }
+}
+
+/// Loads `unicode_indexer.json` and turns text into Int64 token IDs.
+final class UnicodeIndexer {
+    private let table: [Int64]
+
+    init(url: URL) throws {
+        let data = try Data(contentsOf: url, options: .mappedIfSafe)
+        self.table = try JSONDecoder().decode([Int64].self, from: data)
+    }
+
+    /// Encode a single string into Int64 token ids using NFKD codepoint indexing.
+    func encode(_ text: String) -> [Int64] {
+        var out: [Int64] = []
+        out.reserveCapacity(text.unicodeScalars.count)
+        for scalar in text.unicodeScalars {
+            let v = Int(scalar.value)
+            out.append(v < table.count ? table[v] : -1)
+        }
+        return out
+    }
+}

package/ios/Supertonic/VoicePack.swift

@@ -0,0 +1,51 @@
+import Foundation
+import onnxruntime_objc
+
+/// Loads a single voice style file from upstream's `voice_styles/<id>.json`.
+///
+/// Each file contains two 3D float tensors used by the duration predictor and
+/// the text encoder respectively:
+///
+/// ```json
+/// {
+///   "style_ttl": { "data": [[[…]]], "dims": [1, D1, D2], "type": "f32" },
+///   "style_dp":  { "data": [[[…]]], "dims": [1, D1, D2], "type": "f32" }
+/// }
+/// ```
+final class VoicePack {
+    let voiceId: String
+    let ttlValue: ORTValue
+    let dpValue: ORTValue
+
+    init(voiceId: String, url: URL) throws {
+        self.voiceId = voiceId
+        let data = try Data(contentsOf: url)
+        let decoded = try JSONDecoder().decode(VoiceStyleJSON.self, from: data)
+
+        let ttlFlat = decoded.style_ttl.data.flatMap { $0.flatMap { $0 } }
+        let ttlShape = decoded.style_ttl.dims.map { NSNumber(value: $0) }
+        self.ttlValue = try ORTValue(
+            tensorData: NSMutableData(bytes: ttlFlat, length: ttlFlat.count * MemoryLayout<Float>.size),
+            elementType: .float,
+            shape: ttlShape
+        )
+
+        let dpFlat = decoded.style_dp.data.flatMap { $0.flatMap { $0 } }
+        let dpShape = decoded.style_dp.dims.map { NSNumber(value: $0) }
+        self.dpValue = try ORTValue(
+            tensorData: NSMutableData(bytes: dpFlat, length: dpFlat.count * MemoryLayout<Float>.size),
+            elementType: .float,
+            shape: dpShape
+        )
+    }
+}
+
+private struct VoiceStyleJSON: Decodable {
+    struct Component: Decodable {
+        let data: [[[Float]]]
+        let dims: [Int]
+        let type: String
+    }
+    let style_ttl: Component
+    let style_dp: Component
+}