Merge dev into main

.gitignore

@@ -51,6 +51,7 @@ playground.xcworkspace
 
 build/
 .build/
+.spm-cache/
 
 # CocoaPods
 #

MC1/Calculations/RFCalculator.swift

@@ -39,6 +39,46 @@ struct PathAnalysisResult: Equatable {
     let refractionK: Double
 
     var distanceKm: Double { distanceMeters / 1000 }
+
+    var worstObstructionPoint: ObstructionPoint? {
+        obstructionPoints.min(by: { $0.fresnelClearancePercent < $1.fresnelClearancePercent })
+    }
+
+    /// Returns the worst obstruction point per contiguous obstructed region.
+    /// Groups adjacent obstruction points by sample spacing, then picks the
+    /// lowest clearance point from each group — one per red bar in the terrain profile.
+    var peakObstructionPerRegion: [ObstructionPoint] {
+        guard obstructionPoints.count >= 2 else { return obstructionPoints }
+
+        // Find the smallest gap between consecutive points (= one sample step)
+        var minGap = Double.infinity
+        for i in 1..<obstructionPoints.count {
+            let gap = obstructionPoints[i].distanceFromAMeters - obstructionPoints[i - 1].distanceFromAMeters
+            if gap > 0 && gap < minGap { minGap = gap }
+        }
+        guard minGap.isFinite else { return [obstructionPoints[0]] }
+
+        // A gap > 2x the sample step means a non-obstructed sample separates two regions
+        let gapThreshold = minGap * 2.5
+
+        var regions: [ObstructionPoint] = []
+        var regionWorst = obstructionPoints[0]
+
+        for i in 1..<obstructionPoints.count {
+            let point = obstructionPoints[i]
+            let gap = point.distanceFromAMeters - obstructionPoints[i - 1].distanceFromAMeters
+
+            if gap > gapThreshold {
+                regions.append(regionWorst)
+                regionWorst = point
+            } else if point.fresnelClearancePercent < regionWorst.fresnelClearancePercent {
+                regionWorst = point
+            }
+        }
+        regions.append(regionWorst)
+
+        return regions
+    }
 }
 
 /// Elevation sample along the path

MC1/Extensions/BatteryInfo+Display.swift

@@ -5,6 +5,10 @@ import SwiftUI
 /// Consolidates LiPo voltage-to-percentage calculation previously duplicated in
 /// BLEStatusIndicatorView and DeviceInfoView.
 extension BatteryInfo {
+    /// Whether this reading represents a real battery.
+    /// 0mV indicates no battery hardware (e.g., mains-powered device with no ADC pin).
+    var isBatteryPresent: Bool { level > 0 }
+
     /// Battery voltage in volts (converted from millivolts)
     var voltage: Double {
         Double(level) / 1000.0

MC1/Extensions/CLLocationCoordinate2D+BoundingRegion.swift

@@ -0,0 +1,46 @@
+import CoreLocation
+import MapKit
+import MapLibre
+
+extension Array where Element == CLLocationCoordinate2D {
+    /// Computes a bounding `MKCoordinateRegion` that fits all coordinates with padding.
+    func boundingRegion(paddingMultiplier: Double = 1.5) -> MKCoordinateRegion? {
+        guard let first else { return nil }
+
+        var minLat = first.latitude, maxLat = first.latitude
+        var minLon = first.longitude, maxLon = first.longitude
+
+        for coord in dropFirst() {
+            minLat = Swift.min(minLat, coord.latitude)
+            maxLat = Swift.max(maxLat, coord.latitude)
+            minLon = Swift.min(minLon, coord.longitude)
+            maxLon = Swift.max(maxLon, coord.longitude)
+        }
+
+        return MKCoordinateRegion(
+            center: CLLocationCoordinate2D(
+                latitude: (minLat + maxLat) / 2,
+                longitude: (minLon + maxLon) / 2
+            ),
+            span: MKCoordinateSpan(
+                latitudeDelta: Swift.min(180, Swift.max(0.01, (maxLat - minLat) * paddingMultiplier)),
+                longitudeDelta: Swift.min(360, Swift.max(0.01, (maxLon - minLon) * paddingMultiplier))
+            )
+        )
+    }
+}
+
+extension MKCoordinateRegion {
+    func toMLNCoordinateBounds() -> MLNCoordinateBounds {
+        MLNCoordinateBounds(
+            sw: CLLocationCoordinate2D(
+                latitude: center.latitude - span.latitudeDelta / 2,
+                longitude: center.longitude - span.longitudeDelta / 2
+            ),
+            ne: CLLocationCoordinate2D(
+                latitude: center.latitude + span.latitudeDelta / 2,
+                longitude: center.longitude + span.longitudeDelta / 2
+            )
+        )
+    }
+}

MC1/Extensions/CLLocationCoordinate2D+Formatting.swift

@@ -0,0 +1,7 @@
+import CoreLocation
+
+extension CLLocationCoordinate2D {
+    var formattedString: String {
+        "\(latitude.formatted(.number.precision(.fractionLength(6)))), \(longitude.formatted(.number.precision(.fractionLength(6))))"
+    }
+}

MC1/Extensions/ContactDTO+Coordinate.swift

@@ -0,0 +1,8 @@
+import CoreLocation
+import MC1Services
+
+extension ContactDTO {
+    var coordinate: CLLocationCoordinate2D {
+        CLLocationCoordinate2D(latitude: latitude, longitude: longitude)
+    }
+}

MC1/Extensions/ContactType+Display.swift

@@ -0,0 +1,28 @@
+import MeshCore
+import SwiftUI
+
+extension ContactType {
+    var iconSystemName: String {
+        switch self {
+        case .chat: "person.fill"
+        case .repeater: "antenna.radiowaves.left.and.right"
+        case .room: "person.3.fill"
+        }
+    }
+
+    var displayColor: Color {
+        switch self {
+        case .chat: .blue
+        case .repeater: .green
+        case .room: .purple
+        }
+    }
+
+    var pinStyle: MapPoint.PinStyle {
+        switch self {
+        case .chat: .contactChat
+        case .repeater: .contactRepeater
+        case .room: .contactRoom
+        }
+    }
+}

MC1/Extensions/SNRQuality+Color.swift

@@ -1,14 +1,36 @@
 import MC1Services
 import SwiftUI
+import UIKit
 
 extension SNRQuality {
     /// SwiftUI color for signal quality indicators.
     var color: Color {
         switch self {
-        case .excellent: .green
-        case .good: .yellow
-        case .fair, .poor, .veryPoor: .red
+        case .excellent, .good: .green
+        case .fair: .yellow
+        case .poor: .red
         case .unknown: .secondary
         }
     }
+
+    /// UIKit color for MapKit renderers.
+    var uiColor: UIColor {
+        switch self {
+        case .excellent, .good: .systemGreen
+        case .fair: .systemYellow
+        case .poor: .systemRed
+        case .unknown: .systemGray
+        }
+    }
+
+    /// Localized display label for signal quality.
+    var localizedLabel: String {
+        switch self {
+        case .excellent: L10n.Chats.Chats.Signal.excellent
+        case .good: L10n.Chats.Chats.Signal.good
+        case .fair: L10n.Chats.Chats.Signal.fair
+        case .poor: L10n.Chats.Chats.Signal.poor
+        case .unknown: L10n.Chats.Chats.Path.Hop.signalUnknown
+        }
+    }
 }

MC1/Extensions/View+LiquidGlass.swift

@@ -21,6 +21,16 @@ extension View {
         }
     }
 
+    /// Applies glass button style on iOS 26+, falls back to bordered (secondary weight) on earlier versions
+    @ViewBuilder
+    func liquidGlassSecondaryButtonStyle() -> some View {
+        if #available(iOS 26.0, *) {
+            self.buttonStyle(.glass)
+        } else {
+            self.buttonStyle(.bordered)
+        }
+    }
+
     /// Applies prominent glass button style with tint on iOS 26+, falls back to borderedProminent on earlier versions
     @ViewBuilder
     func liquidGlassProminentButtonStyle() -> some View {

MC1/MC1App.swift

@@ -9,6 +9,7 @@ private let logger = Logger(subsystem: "com.mc1", category: "MC1App")
 @main
 struct MC1App: App {
     @State private var appState: AppState
+    @State private var awaitingDataProtection = false
     @Environment(\.scenePhase) private var scenePhase
 
     #if DEBUG
@@ -23,13 +24,32 @@ struct MC1App: App {
         do {
             container = try PersistenceStore.createContainer()
         } catch {
-            logger.fault("Container creation failed, retrying: \(error)")
+            logger.error("Container creation failed: \(error)")
+
+            if UIApplication.shared.isProtectedDataAvailable {
+                // Data is accessible — this is a genuine failure, not BFU.
+                // Retry once for transient file system issues.
+                logger.info("Retrying container creation")
+                do {
+                    container = try PersistenceStore.createContainer()
+                } catch {
+                    logger.fault("Container creation failed after retry: \(error)")
+                    fatalError("ModelContainer creation failed after retry while data is available")
+                }
+                _appState = State(initialValue: AppState(modelContainer: container))
+                return
+            }
+
+            // Before first unlock: the encrypted store is inaccessible. Create a throwaway
+            // in-memory container so the struct can initialize. The .task body will wait for
+            // data protection and replace this with the real store before doing any work.
+            logger.warning("Protected data unavailable (before first unlock), deferring initialization")
             do {
-                container = try PersistenceStore.createContainer()
+                container = try PersistenceStore.createContainer(inMemory: true)
             } catch {
-                logger.fault("Container creation failed after retry: \(error)")
-                fatalError("Unrecoverable: ModelContainer creation failed after retry")
+                fatalError("In-memory ModelContainer creation failed: \(error)")
             }
+            _awaitingDataProtection = State(initialValue: true)
         }
         _appState = State(initialValue: AppState(modelContainer: container))
     }
@@ -39,6 +59,18 @@ struct MC1App: App {
             ContentView()
                 .environment(\.appState, appState)
                 .task {
+                    if awaitingDataProtection {
+                        await waitForProtectedData()
+                        do {
+                            let container = try PersistenceStore.createContainer()
+                            appState = AppState(modelContainer: container)
+                            awaitingDataProtection = false
+                        } catch {
+                            logger.fault("Container creation failed after unlock: \(error)")
+                            fatalError("ModelContainer creation failed after protected data became available")
+                        }
+                    }
+
                     try? Tips.configure([
                         .displayFrequency(.immediate)
                     ])
@@ -90,6 +122,25 @@ struct MC1App: App {
     }
     #endif
 
+    private func waitForProtectedData() async {
+        guard !UIApplication.shared.isProtectedDataAvailable else { return }
+        let notification = UIApplication.protectedDataDidBecomeAvailableNotification
+        await withTaskGroup(of: Void.self) { group in
+            group.addTask {
+                for await _ in NotificationCenter.default.notifications(named: notification) {
+                    return
+                }
+            }
+            group.addTask {
+                while await !UIApplication.shared.isProtectedDataAvailable {
+                    try? await Task.sleep(for: .seconds(1))
+                }
+            }
+            await group.next()
+            group.cancelAll()
+        }
+    }
+
     private func handleScenePhaseChange(from oldPhase: ScenePhase, to newPhase: ScenePhase) {
         switch newPhase {
         case .active: