@mentra/bluetooth-sdk 0.1.8 → 0.1.10

package/ios/Source/{Status → status}/WifiHotspotStatus.swift

@@ -138,11 +138,11 @@ public struct WifiStatusEvent: CustomStringConvertible {
     }
 
     init(connected: Bool, ssid: String?, localIp: String?) {
-        self.status = WifiStatus.fromStoreFields(connected: connected, ssid: ssid, localIp: localIp) ?? .disconnected
+        status = WifiStatus.fromStoreFields(connected: connected, ssid: ssid, localIp: localIp) ?? .disconnected
     }
 
     init(values: [String: Any]) {
-        self.status = WifiStatus(values: values) ?? .disconnected
+        status = WifiStatus(values: values) ?? .disconnected
     }
 
     public var values: [String: Any] {
@@ -289,11 +289,11 @@ public struct HotspotStatusEvent: CustomStringConvertible {
     }
 
     init(enabled: Bool, ssid: String?, password: String?, localIp: String?) {
-        self.status = HotspotStatus.fromStoreFields(enabled: enabled, ssid: ssid, password: password, localIp: localIp) ?? .disabled
+        status = HotspotStatus.fromStoreFields(enabled: enabled, ssid: ssid, password: password, localIp: localIp) ?? .disabled
     }
 
     init(values: [String: Any]) {
-        self.status = HotspotStatus(values: values) ?? .disabled
+        status = HotspotStatus(values: values) ?? .disabled
     }
 
     public var values: [String: Any] {

package/ios/Source/{Streaming → streaming}/StreamModels.swift

@@ -76,13 +76,20 @@ public struct StreamAudioConfig {
     }
 }
 
+/// Effective video settings reported by the glasses after defaults and clamps.
 public struct StreamResolvedVideoConfig: Equatable {
+    /// Encoded output width sent to the stream endpoint.
     public let width: Int
+    /// Encoded output height sent to the stream endpoint.
     public let height: Int
+    /// Native camera buffer width selected before crop/downscale.
     public let captureWidth: Int?
+    /// Native camera buffer height selected before crop/downscale.
     public let captureHeight: Int?
+    /// Encoded video bitrate in bits per second.
     public let bitrate: Int
-    public let fps: Int
+    /// Resolved capture/encode frame rate.
+    public let fps: Double
 
     public init(
         width: Int,
@@ -90,7 +97,7 @@ public struct StreamResolvedVideoConfig: Equatable {
         captureWidth: Int? = nil,
         captureHeight: Int? = nil,
         bitrate: Int,
-        fps: Int
+        fps: Double
     ) {
         self.width = width
         self.height = height
@@ -105,7 +112,7 @@ public struct StreamResolvedVideoConfig: Equatable {
               let width = intValue(values["width"]),
               let height = intValue(values["height"]),
               let bitrate = intValue(values["bitrate"]),
-              let fps = intValue(values["fps"])
+              let fps = doubleValue(values["fps"])
         else {
             return nil
         }
@@ -382,11 +389,19 @@ public enum StreamStatus: CustomStringConvertible, Equatable {
         let resolvedConfig = StreamResolvedConfig(values: values["resolvedConfig"] as? [String: Any])
         let attempt = optionalIntValue(values, "attempt")
         let maxAttempts = optionalIntValue(values, "maxAttempts") ?? 0
+        let parsedState = StreamState.from(rawState)
 
         if hasAnyKey(values, "streaming") || hasAnyKey(values, "reconnecting") {
             let streaming = boolValue(values, "streaming") == true
             let reconnecting = boolValue(values, "reconnecting") == true
-            let snapshotState: StreamState = reconnecting ? .reconnecting : (streaming ? .streaming : .stopped)
+            let snapshotState: StreamState
+            if reconnecting {
+                snapshotState = .reconnecting
+            } else if streaming {
+                snapshotState = .streaming
+            } else {
+                snapshotState = parsedState ?? .stopped
+            }
             self = .snapshot(
                 state: snapshotState,
                 streaming: streaming,
@@ -399,7 +414,7 @@ public enum StreamStatus: CustomStringConvertible, Equatable {
             return
         }
 
-        guard let state = StreamState.from(rawState) else {
+        guard let state = parsedState else {
             self = .error(
                 streamId: streamId,
                 errorDetails: rawState.map { "Unknown stream status: \($0)" } ?? "Missing stream status",
@@ -569,7 +584,7 @@ public struct StreamStatusEvent: CustomStringConvertible {
     }
 
     public init(values: [String: Any]) {
-        self.status = StreamStatus(values: values)
+        status = StreamStatus(values: values)
     }
 
     public var state: StreamState {
@@ -607,9 +622,9 @@ public struct KeepAliveAckEvent: CustomStringConvertible, Equatable {
     }
 
     public init(values: [String: Any]) {
-        self.streamId = stringValue(values, "streamId") ?? ""
-        self.ackId = stringValue(values, "ackId") ?? ""
-        self.timestamp = intValue(values["timestamp"])
+        streamId = stringValue(values, "streamId") ?? ""
+        ackId = stringValue(values, "ackId") ?? ""
+        timestamp = intValue(values["timestamp"])
     }
 
     public var values: [String: Any] {

package/ios/Source/stt/STTTools.swift

@@ -67,16 +67,18 @@ class STTTools {
         }
 
         // Check for CTC model
-        let ctcModelPath = (modelPath as NSString).appendingPathComponent("model.int8.onnx")
-        if fileManager.fileExists(atPath: ctcModelPath) {
+        if firstExistingFile(in: modelPath, candidates: ["model.int8.onnx", "model.onnx"]) != nil {
             return true
         }
 
         // Check for transducer model
-        let transducerFiles = ["encoder.onnx", "decoder.onnx", "joiner.onnx"]
-        for file in transducerFiles {
-            let filePath = (modelPath as NSString).appendingPathComponent(file)
-            if !fileManager.fileExists(atPath: filePath) {
+        let transducerFiles = [
+            ["encoder.onnx", "encoder.int8.onnx"],
+            ["decoder.onnx", "decoder.int8.onnx"],
+            ["joiner.onnx", "joiner.int8.onnx"],
+        ]
+        for candidates in transducerFiles {
+            if firstExistingFile(in: modelPath, candidates: candidates) == nil {
                 return false
             }
         }
@@ -95,18 +97,20 @@ class STTTools {
         }
 
         // Check for CTC model
-        let ctcModelPath = (path as NSString).appendingPathComponent("model.int8.onnx")
-        if fileManager.fileExists(atPath: ctcModelPath) {
+        if firstExistingFile(in: path, candidates: ["model.int8.onnx", "model.onnx"]) != nil {
             return true
         }
 
         // Check for transducer model
-        let transducerFiles = ["encoder.onnx", "decoder.onnx", "joiner.onnx"]
+        let transducerFiles = [
+            ["encoder.onnx", "encoder.int8.onnx"],
+            ["decoder.onnx", "decoder.int8.onnx"],
+            ["joiner.onnx", "joiner.int8.onnx"],
+        ]
         var allTransducerFilesPresent = true
 
-        for file in transducerFiles {
-            let filePath = (path as NSString).appendingPathComponent(file)
-            if !fileManager.fileExists(atPath: filePath) {
+        for candidates in transducerFiles {
+            if firstExistingFile(in: path, candidates: candidates) == nil {
                 allTransducerFilesPresent = false
                 break
             }
@@ -151,4 +155,15 @@ class STTTools {
         }
         return true
     }
+
+    private static func firstExistingFile(in directory: String, candidates: [String]) -> String? {
+        let fileManager = FileManager.default
+        for candidate in candidates {
+            let path = (directory as NSString).appendingPathComponent(candidate)
+            if fileManager.fileExists(atPath: path) {
+                return path
+            }
+        }
+        return nil
+    }
 }

package/ios/Source/stt/SherpaOnnxTranscriber.swift

@@ -54,6 +54,17 @@ class SherpaOnnxTranscriber {
         return storedPath
     }
 
+    private static func firstExistingFile(in directory: String, candidates: [String]) -> String? {
+        let fileManager = FileManager.default
+        for candidate in candidates {
+            let path = (directory as NSString).appendingPathComponent(candidate)
+            if fileManager.fileExists(atPath: path) {
+                return path
+            }
+        }
+        return nil
+    }
+
     /**
      * Constructor that accepts a UIViewController to load model assets.
      */
@@ -79,8 +90,14 @@ class SherpaOnnxTranscriber {
             // Check if we have a custom model path set
             if let customPath = SherpaOnnxTranscriber.customModelPath {
                 // Detect model type based on available files
-                let ctcModelPath = (customPath as NSString).appendingPathComponent("model.int8.onnx")
-                let transducerEncoderPath = (customPath as NSString).appendingPathComponent("encoder.onnx")
+                let ctcModelPath = Self.firstExistingFile(
+                    in: customPath,
+                    candidates: ["model.int8.onnx", "model.onnx"]
+                )
+                let transducerEncoderPath = Self.firstExistingFile(
+                    in: customPath,
+                    candidates: ["encoder.int8.onnx", "encoder.onnx"]
+                )
 
                 tokensPath = (customPath as NSString).appendingPathComponent("tokens.txt")
 
@@ -91,7 +108,7 @@ class SherpaOnnxTranscriber {
                     ])
                 }
 
-                if fileManager.fileExists(atPath: ctcModelPath) {
+                if let ctcModelPath {
                     // CTC model detected
                     modelType = "ctc"
                     Bridge.log("Detected CTC model at \(customPath)")
@@ -123,17 +140,23 @@ class SherpaOnnxTranscriber {
                     // Create recognizer with the wrapper
                     recognizer = SherpaOnnxRecognizer(config: &config)
 
-                } else if fileManager.fileExists(atPath: transducerEncoderPath) {
+                } else if let transducerEncoderPath {
                     // Transducer model detected
                     modelType = "transducer"
                     Bridge.log("Detected transducer model at \(customPath)")
 
-                    let decoderPath = (customPath as NSString).appendingPathComponent("decoder.onnx")
-                    let joinerPath = (customPath as NSString).appendingPathComponent("joiner.onnx")
+                    let decoderPath = Self.firstExistingFile(
+                        in: customPath,
+                        candidates: ["decoder.int8.onnx", "decoder.onnx"]
+                    )
+                    let joinerPath = Self.firstExistingFile(
+                        in: customPath,
+                        candidates: ["joiner.int8.onnx", "joiner.onnx"]
+                    )
 
                     // Verify all transducer files exist
-                    guard fileManager.fileExists(atPath: decoderPath),
-                          fileManager.fileExists(atPath: joinerPath)
+                    guard let decoderPath,
+                          let joinerPath
                     else {
                         throw NSError(domain: "SherpaOnnxTranscriber", code: 1, userInfo: [
                             NSLocalizedDescriptionKey: "Transducer model files incomplete at path: \(customPath)",

package/ios/Source/tts/TTSTools.swift

@@ -0,0 +1,164 @@
+import Foundation
+
+/// Utilities for offline Sherpa-ONNX Supertonic 3 TTS.
+///
+/// Supertonic 3 is a single multilingual model bundle (31 languages) with
+/// 10 preset voice styles packed into voice.bin. Speaker IDs are indexed
+/// alphabetically by JSON filename, so the order is F1, F2, F3, F4, F5,
+/// M1, M2, M3, M4, M5 (sids 0..9). We default to F1 (sid 0) for a female
+/// voice.
+class TTSTools {
+    private static let kFileDurationPredictor = "duration_predictor.int8.onnx"
+    private static let kFileTextEncoder = "text_encoder.int8.onnx"
+    private static let kFileVectorEstimator = "vector_estimator.int8.onnx"
+    private static let kFileVocoder = "vocoder.int8.onnx"
+    private static let kFileTtsJson = "tts.json"
+    private static let kFileUnicodeIndexer = "unicode_indexer.bin"
+    private static let kFileVoiceStyle = "voice.bin"
+
+    private static let kRequiredFiles: [String] = [
+        kFileDurationPredictor,
+        kFileTextEncoder,
+        kFileVectorEstimator,
+        kFileVocoder,
+        kFileTtsJson,
+        kFileUnicodeIndexer,
+        kFileVoiceStyle,
+    ]
+
+    private static let kSupportedLangs: 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",
+    ]
+
+    static func setTtsModelDetails(_ path: String, _ languageCode: String) {
+        UserDefaults.standard.set(path, forKey: "TTSModelPath")
+        UserDefaults.standard.set(languageCode, forKey: "TTSModelLanguageCode")
+        UserDefaults.standard.synchronize()
+    }
+
+    static func getTtsModelPath() -> String {
+        return UserDefaults.standard.string(forKey: "TTSModelPath") ?? ""
+    }
+
+    static func getTtsModelLanguage() -> String {
+        return UserDefaults.standard.string(forKey: "TTSModelLanguageCode") ?? "en-US"
+    }
+
+    static func checkTTSModelAvailable() -> Bool {
+        guard let modelPath = UserDefaults.standard.string(forKey: "TTSModelPath") else {
+            return false
+        }
+        return validateTTSModel(modelPath)
+    }
+
+    static func validateTTSModel(_ path: String) -> Bool {
+        let fileManager = FileManager.default
+        var isDirectory: ObjCBool = false
+        if !fileManager.fileExists(atPath: path, isDirectory: &isDirectory) || !isDirectory.boolValue {
+            Bridge.log("TTS model path does not exist or is not a directory: \(path)")
+            return false
+        }
+
+        for name in kRequiredFiles {
+            let filePath = (path as NSString).appendingPathComponent(name)
+            if !fileManager.fileExists(atPath: filePath) {
+                Bridge.log("TTS model missing required file '\(name)' at: \(path)")
+                return false
+            }
+            let size = (try? fileManager.attributesOfItem(atPath: filePath)[.size] as? UInt64) ?? 0
+            if size == 0 {
+                Bridge.log("TTS model file '\(name)' is empty at: \(path)")
+                return false
+            }
+        }
+
+        return true
+    }
+
+    static func generateTtsAudio(
+        text: String,
+        modelPath: String,
+        outputPath: String,
+        speakerId: Int,
+        speed: Double
+    ) -> Bool {
+        guard !text.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
+            Bridge.log("TTS_ERROR: text is empty")
+            return false
+        }
+        guard validateTTSModel(modelPath) else {
+            Bridge.log("TTS_ERROR: model is invalid: \(modelPath)")
+            return false
+        }
+
+        do {
+            let outputURL = URL(fileURLWithPath: outputPath)
+            try FileManager.default.createDirectory(
+                at: outputURL.deletingLastPathComponent(),
+                withIntermediateDirectories: true,
+                attributes: nil
+            )
+
+            let supertonic = sherpaOnnxOfflineTtsSupertonicModelConfig(
+                durationPredictor: (modelPath as NSString).appendingPathComponent(kFileDurationPredictor),
+                textEncoder: (modelPath as NSString).appendingPathComponent(kFileTextEncoder),
+                vectorEstimator: (modelPath as NSString).appendingPathComponent(kFileVectorEstimator),
+                vocoder: (modelPath as NSString).appendingPathComponent(kFileVocoder),
+                ttsJson: (modelPath as NSString).appendingPathComponent(kFileTtsJson),
+                unicodeIndexer: (modelPath as NSString).appendingPathComponent(kFileUnicodeIndexer),
+                voiceStyle: (modelPath as NSString).appendingPathComponent(kFileVoiceStyle)
+            )
+            var modelConfig = sherpaOnnxOfflineTtsModelConfig(
+                numThreads: 2,
+                supertonic: supertonic
+            )
+            var config = sherpaOnnxOfflineTtsConfig(model: modelConfig, maxNumSentences: 1)
+            let tts = SherpaOnnxOfflineTtsWrapper(config: &config)
+
+            // The new wrapper dropped numSpeakers() in v1.13.2; call the C API
+            // directly. The C signature accepts the underlying OpaquePointer.
+            let numSpeakers = max(1, Int(SherpaOnnxOfflineTtsNumSpeakers(tts.tts)))
+            let sid = max(0, min(speakerId, numSpeakers - 1))
+            let clampedSpeed = Float(min(max(speed, 0.5), 2.0))
+            let lang = languageTagToSupertonicLang(getTtsModelLanguage())
+
+            // generate(...) no longer accepts `extra`; that field moved onto
+            // SherpaOnnxGenerationConfigSwift and is delivered via
+            // generateWithConfig(...).
+            //
+            // numSteps controls the Supertonic flow-matching vocoder's
+            // iteration count. The Swift wrapper defaults to 1, which produces
+            // unintelligible robot audio — sherpa-onnx's actual C-side default
+            // is 5. Pin it here so we don't inherit the wrapper's bug.
+            let genConfig = SherpaOnnxGenerationConfigSwift(
+                speed: clampedSpeed,
+                sid: sid,
+                numSteps: 5,
+                extra: ["lang": lang]
+            )
+            let audio = tts.generateWithConfig(
+                text: text,
+                config: genConfig,
+                callback: nil,
+                arg: nil
+            )
+            let saved = audio.save(filename: outputPath) == 1
+            Bridge.log(
+                "TTS generated \(outputPath): saved=\(saved) sid=\(sid) lang=\(lang) " +
+                    "sr=\(audio.sampleRate) samples=\(audio.n) speed=\(clampedSpeed)"
+            )
+            return saved
+        } catch {
+            Bridge.log("TTS_ERROR: \(error.localizedDescription)")
+            return false
+        }
+    }
+
+    /// Convert a BCP-47 tag (e.g. "en-US", "fr-FR") to a Supertonic 2-letter code.
+    private static func languageTagToSupertonicLang(_ tag: String) -> String {
+        let primary = tag.split(separator: "-").first.map(String.init)?.lowercased() ?? "en"
+        return kSupportedLangs.contains(primary) ? primary : "en"
+    }
+}

package/ios/Source/utils/JSCExperiment.swift

@@ -79,7 +79,7 @@ private func jlog(_ message: String) {
         let beforeMB = MemoryMonitor.currentMemoryMB()
         jlog("🧪 JSCExperiment.spawn(\(count)) starting; baseline \(String(format: "%.1f", beforeMB)) MB")
         var spawned = 0
-        for i in 0..<count {
+        for i in 0 ..< count {
             let id = "spike-\(UUID().uuidString.prefix(8))-\(i)"
             if spawnOne(id: id) {
                 spawned += 1
@@ -102,19 +102,19 @@ private func jlog(_ message: String) {
             ctx.name = "MentraJS: \(id)"
             // Inspectable in dev builds only. iOS 16.4+ guarded.
             #if DEBUG
-            if #available(iOS 16.4, *) {
-                ctx.isInspectable = true
-            }
+                if #available(iOS 16.4, *) {
+                    ctx.isInspectable = true
+                }
             #endif
 
             // Single-dispatcher bridge. Per Pebble's CrashReproducer doc, never
             // bind individual native callbacks as JSValue properties — JSC's GC
             // races with ARC and crashes. One C-callable function only.
-            let dispatch: @convention(block) (String, String, [Any]?) -> Any? = { iface, method, args in
+            let dispatch: @convention(block) (String, String, [Any]?) -> Any? = { _, _, _ in
                 // Stub: real impl routes to native services.
                 // For the spike we just need __dispatch to exist so the
                 // workload can call it without throwing.
-                return NSNull()
+                NSNull()
             }
             ctx.setObject(dispatch, forKeyedSubscript: "__dispatch" as NSString)
 
@@ -147,7 +147,7 @@ private func jlog(_ message: String) {
             // setInterval that fires the JS callback. The JS code already
             // expects setInterval to exist as a global.
             let setInterval: @convention(block) (JSValue, Double) -> Int = { fn, ms in
-                let id = Int.random(in: 1...Int.max)
+                let id = Int.random(in: 1 ... Int.max)
                 // Stub: we won't actually fire in the spike, but the JS
                 // callback existing is what we want for memory measurement.
                 _ = fn // hold a ref to keep the JS callback alive

package/ios/Source/utils/MessageChunkReassembler.swift

@@ -9,22 +9,41 @@ final class MessageChunkReassembler {
     func addChunk(_ info: MessageChunker.ChunkInfo) -> String? {
         cleanupTimedOutSessions()
 
+        guard !info.chunkId.isEmpty,
+              info.totalChunks > 0,
+              info.chunkIndex >= 0,
+              info.chunkIndex < info.totalChunks
+        else {
+            print("MessageChunkReassembler: Dropping invalid chunk metadata for \(info.chunkId)")
+            return nil
+        }
+
+        if let existing = activeSessions[info.chunkId], existing.totalChunks != info.totalChunks {
+            print(
+                "MessageChunkReassembler: totalChunks mismatch for \(info.chunkId) (expected \(existing.totalChunks), got \(info.totalChunks)); resetting session"
+            )
+            activeSessions.removeValue(forKey: info.chunkId)
+        }
+
         if activeSessions.count >= Self.maxConcurrentSessions,
            activeSessions[info.chunkId] == nil
         {
             removeOldestSession()
         }
 
+        let isNewSession = activeSessions[info.chunkId] == nil
         let session = activeSessions[info.chunkId] ?? ChunkSession(
             chunkId: info.chunkId,
             totalChunks: info.totalChunks
         )
-        activeSessions[info.chunkId] = session
 
         guard session.addChunk(index: info.chunkIndex, data: info.data) else {
             print("MessageChunkReassembler: Failed to add chunk \(info.chunkIndex) for \(info.chunkId)")
             return nil
         }
+        if isNewSession {
+            activeSessions[info.chunkId] = session
+        }
 
         guard session.isComplete else {
             return nil

package/ios/Source/utils/MessageChunker.swift

@@ -12,17 +12,18 @@ import Foundation
  *   d  = chunk data payload
  *
  * Each chunk after C-wrapping + K900 framing must fit within the BES2700's
- * 253-byte BLE write limit. With compact keys, 80 bytes of raw data produces
- * a final packed size of ~245 bytes worst-case (with heavy JSON escaping).
+ * 253-byte BLE write limit. Payload size is selected by measuring the final
+ * packed chunk so JSON escaping cannot push a chunk over the BLE limit.
  */
 class MessageChunker {
     // Threshold: if C-wrapped message exceeds this, chunking is triggered.
     // BES2700 limit is 253 bytes; anything over ~200 bytes packed needs chunking.
     private static let MESSAGE_SIZE_THRESHOLD = 200
 
-    /// Maximum raw bytes per chunk. After double JSON escaping + compact envelope
-    /// + C-wrapper + K900 framing, 80 bytes stays under the 253-byte BLE limit.
-    private static let CHUNK_DATA_SIZE = 80
+    private static let INITIAL_CHUNK_DATA_SIZE = 80
+    private static let MIN_CHUNK_DATA_SIZE = 4
+    private static let MAX_PACKED_CHUNK_SIZE = 253
+    private static let K900_FRAME_OVERHEAD = 7
 
     /**
      * Check if a message needs to be chunked
@@ -51,34 +52,36 @@ class MessageChunker {
      * @param messageId The message ID for ACK tracking (if applicable)
      * @return Array of chunk dictionaries ready to be C-wrapped and sent
      */
-    static func createChunks(originalJson: String, messageId: Int64 = -1) -> [[String: Any]] {
+    static func createChunks(originalJson: String, messageId: Int64 = -1, wakeUp: Bool = false) -> [[String: Any]] {
         guard let messageData = originalJson.data(using: .utf8) else {
             print("MessageChunker: Failed to convert message to data")
             return []
         }
 
-        var chunks: [[String: Any]] = []
         let totalBytes = messageData.count
 
         // Compact chunk session ID: messageId_timestamp (no "chunk_" prefix)
         let chunkId = "\(messageId)_\(Int(Date().timeIntervalSince1970 * 1000))"
 
-        // Calculate total chunks needed
-        let totalChunks = Int(ceil(Double(totalBytes) / Double(CHUNK_DATA_SIZE)))
+        for chunkSize in stride(from: INITIAL_CHUNK_DATA_SIZE, through: MIN_CHUNK_DATA_SIZE, by: -1) {
+            let chunks = buildChunks(messageData, chunkId: chunkId, messageId: messageId, chunkSize: chunkSize)
+            if allChunksFit(chunks, wakeUp: wakeUp) {
+                print("MessageChunker: Creating \(chunks.count) chunks for message of size \(totalBytes) bytes using \(chunkSize)-byte UTF-8 slices")
+                return chunks
+            }
+        }
+
+        print("MessageChunker: Unable to create K900 chunks within \(MAX_PACKED_CHUNK_SIZE) bytes")
+        return []
+    }
 
-        print("MessageChunker: Creating \(totalChunks) chunks for message of size \(totalBytes) bytes")
+    private static func buildChunks(_ messageData: Data, chunkId: String, messageId: Int64, chunkSize: Int) -> [[String: Any]] {
+        var chunks: [[String: Any]] = []
+        let chunkStrings = splitUtf8(messageData, chunkSize: chunkSize)
+        let totalChunks = chunkStrings.count
 
         for i in 0 ..< totalChunks {
-            let startIndex = i * CHUNK_DATA_SIZE
-            let endIndex = min(startIndex + CHUNK_DATA_SIZE, totalBytes)
-            let chunkRange = startIndex ..< endIndex
-
-            // Extract chunk data as string
-            let chunkData = messageData.subdata(in: chunkRange)
-            guard let chunkString = String(data: chunkData, encoding: .utf8) else {
-                print("MessageChunker: Failed to convert chunk \(i) to string")
-                continue
-            }
+            let chunkString = chunkStrings[i]
 
             // Create chunk dictionary with compact keys
             var chunk: [String: Any] = [
@@ -96,12 +99,66 @@ class MessageChunker {
 
             chunks.append(chunk)
 
-            print("MessageChunker: Created chunk \(i)/\(totalChunks - 1) with \(chunkData.count) bytes")
+            print("MessageChunker: Created chunk \(i)/\(totalChunks - 1) with \(chunkString.data(using: .utf8)?.count ?? 0) bytes")
         }
 
         return chunks
     }
 
+    private static func allChunksFit(_ chunks: [[String: Any]], wakeUp: Bool) -> Bool {
+        for (index, chunk) in chunks.enumerated() {
+            let packedLength = packedK900Length(chunk, wakeUp: wakeUp && index == 0)
+            if packedLength == nil || packedLength! > MAX_PACKED_CHUNK_SIZE {
+                print("MessageChunker: Chunk \(index) packed to \(packedLength ?? 0) bytes, exceeding \(MAX_PACKED_CHUNK_SIZE)")
+                return false
+            }
+        }
+        return true
+    }
+
+    private static func packedK900Length(_ chunk: [String: Any], wakeUp: Bool) -> Int? {
+        guard let chunkData = try? JSONSerialization.data(withJSONObject: chunk),
+              let chunkString = String(data: chunkData, encoding: .utf8)
+        else {
+            return nil
+        }
+
+        var wrapper: [String: Any] = ["C": chunkString]
+        if wakeUp {
+            wrapper["W"] = 1
+        }
+
+        guard let wrappedData = try? JSONSerialization.data(withJSONObject: wrapper) else {
+            return nil
+        }
+
+        return wrappedData.count + K900_FRAME_OVERHEAD
+    }
+
+    private static func splitUtf8(_ messageData: Data, chunkSize: Int) -> [String] {
+        var chunkStrings: [String] = []
+        var offset = 0
+        while offset < messageData.count {
+            let endIndex = findUtf8ChunkEnd(messageData, startIndex: offset, chunkSize: chunkSize)
+            let chunkData = messageData.subdata(in: offset ..< endIndex)
+            chunkStrings.append(String(data: chunkData, encoding: .utf8)!)
+            offset = endIndex
+        }
+        return chunkStrings
+    }
+
+    private static func findUtf8ChunkEnd(_ messageData: Data, startIndex: Int, chunkSize: Int) -> Int {
+        var endIndex = min(startIndex + chunkSize, messageData.count)
+        while endIndex > startIndex, endIndex < messageData.count, isUtf8ContinuationByte(messageData[endIndex]) {
+            endIndex -= 1
+        }
+        return endIndex > startIndex ? endIndex : min(startIndex + chunkSize, messageData.count)
+    }
+
+    private static func isUtf8ContinuationByte(_ value: UInt8) -> Bool {
+        (value & 0xC0) == 0x80
+    }
+
     /**
      * Check if a received message is a chunked message.
      * Supports both verbose ("type":"chunked_msg") and compact ("t":"ck") formats.