+		E430FB6B7CB3E0D4189F6D7D /* MeterMappingDebugView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 56BA4CE53B6B2C4EBA42C81A /* MeterMappingDebugView.swift */; };

+		3407A133FADB8858DC2A1FED /* MeterNameStore.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7396C8BB36F4E7F8E0CD8FF8 /* MeterNameStore.swift */; };

+		56BA4CE53B6B2C4EBA42C81A /* MeterMappingDebugView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MeterMappingDebugView.swift; sourceTree = "<group>"; };

+		7396C8BB36F4E7F8E0CD8FF8 /* MeterNameStore.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MeterNameStore.swift; sourceTree = "<group>"; };

+				7396C8BB36F4E7F8E0CD8FF8 /* MeterNameStore.swift */,

+				56BA4CE53B6B2C4EBA42C81A /* MeterMappingDebugView.swift */,

+						SystemCapabilities = {

+							com.apple.iCloud = {

+								enabled = 1;

+							};

+						};

+				3407A133FADB8858DC2A1FED /* MeterNameStore.swift in Sources */,

+				E430FB6B7CB3E0D4189F6D7D /* MeterMappingDebugView.swift in Sources */,

+        logRuntimeICloudDiagnostics()

+    private func logRuntimeICloudDiagnostics() {

+        #if DEBUG

+        let hasUbiquityIdentityToken = FileManager.default.ubiquityIdentityToken != nil

+        track("Runtime iCloud diagnostics: ubiquityIdentityTokenAvailable=\(hasUbiquityIdentityToken)")

+        #endif

+    }

+

+    private var meterStoreObserver: AnyCancellable?

+    private var meterStoreCloudObserver: AnyCancellable?

+    private let meterStore = MeterNameStore.shared

+        meterStoreObserver = NotificationCenter.default.publisher(for: .meterNameStoreDidChange)

+            .receive(on: DispatchQueue.main)

+            .sink { [weak self] _ in

+                self?.refreshMeterMetadata()

+            }

+        meterStoreCloudObserver = NotificationCenter.default.publisher(for: .meterNameStoreCloudStatusDidChange)

+            .receive(on: DispatchQueue.main)

+            .sink { [weak self] _ in

+                self?.scheduleObjectWillChange()

+            }

+

+

+

+

+    var cloudAvailability: MeterNameStore.CloudAvailability {

+        meterStore.currentCloudAvailability

+    }

+

+    func meterName(for macAddress: String) -> String? {

+        meterStore.name(for: macAddress)

+    }

+

+    func setMeterName(_ name: String, for macAddress: String) {

+        meterStore.upsert(macAddress: macAddress, name: name, temperatureUnitRawValue: nil)

+    }

+

+    func temperatureUnitPreference(for macAddress: String) -> TemperatureUnitPreference {

+        let rawValue = meterStore.temperatureUnitRawValue(for: macAddress) ?? TemperatureUnitPreference.celsius.rawValue

+        return TemperatureUnitPreference(rawValue: rawValue) ?? .celsius

+    }

+

+    func setTemperatureUnitPreference(_ preference: TemperatureUnitPreference, for macAddress: String) {

+        meterStore.upsert(macAddress: macAddress, name: nil, temperatureUnitRawValue: preference.rawValue)

+

+    private func refreshMeterMetadata() {

+        DispatchQueue.main.async { [weak self] in

+            guard let self else { return }

+            var didUpdateAnyMeter = false

+            for meter in self.meters.values {

+                let mac = meter.btSerial.macAddress.description

+                let displayName = self.meterName(for: mac) ?? mac

+                if meter.name != displayName {

+                    meter.updateNameFromStore(displayName)

+                    didUpdateAnyMeter = true

+                }

+

+                let previousTemperaturePreference = meter.tc66TemperatureUnitPreference

+                meter.reloadTemperatureUnitPreference()

+                if meter.tc66TemperatureUnitPreference != previousTemperaturePreference {

+                    didUpdateAnyMeter = true

+                }

+            }

+

+            if didUpdateAnyMeter {

+                self.scheduleObjectWillChange()

+            }

+        }

+    }

+            let macAddress = meter.btSerial.macAddress.description

+            if meter.name == macAddress, let syncedName = appData.meterName(for: macAddress), syncedName != macAddress {

+                meter.updateNameFromStore(syncedName)

+            }

+    private var isSyncingNameFromStore = false

+

+    @Published var name: String {

+            guard !isSyncingNameFromStore else { return }

+            guard oldValue != name else { return }

+            appData.setMeterName(name, for: btSerial.macAddress.description)

+            appData.setTemperatureUnitPreference(tc66TemperatureUnitPreference, for: btSerial.macAddress.description)

+        name = appData.meterName(for: serialPort.macAddress.description) ?? serialPort.macAddress.description

+        let persistedPreference = appData.temperatureUnitPreference(for: btSerial.macAddress.description)

+    func updateNameFromStore(_ newName: String) {

+        guard newName != name else { return }

+        isSyncingNameFromStore = true

+        name = newName

+        isSyncingNameFromStore = false

+    }

+

+//  MeterNameStore.swift

+//  USB Meter

+//

+//  Created by Codex on 2026.

+//

+

+import Foundation

+

+final class MeterNameStore {

+    struct Record: Identifiable {

+        let macAddress: String

+        let customName: String?

+        let temperatureUnit: String?

+

+        var id: String {

+            macAddress

+        }

+    }

+

+    enum CloudAvailability: Equatable {

+        case unknown

+        case available

+        case noAccount

+        case error(String)

+

+        var helpTitle: String {

+            switch self {

+            case .unknown:

+                return "Cloud Sync Status Unknown"

+            case .available:

+                return "Cloud Sync Ready"

+            case .noAccount:

+                return "Enable iCloud Drive"

+            case .error:

+                return "Cloud Sync Error"

+            }

+        }

+

+        var helpMessage: String {

+            switch self {

+            case .unknown:

+                return "The app is still checking whether iCloud sync is available on this device."

+            case .available:

+                return "iCloud sync is available for meter names and TC66 temperature preferences."

+            case .noAccount:

+                return "Meter names and TC66 temperature preferences sync through iCloud Drive. The app keeps a local copy too, but cross-device sync stays off until iCloud Drive is available."

+            case .error(let description):

+                return "The app keeps local values, but iCloud sync reported an error: \(description)"

+            }

+        }

+    }

+

+    static let shared = MeterNameStore()

+

+    private enum Keys {

+        static let localMeterNames = "MeterNameStore.localMeterNames"

+        static let localTemperatureUnits = "MeterNameStore.localTemperatureUnits"

+        static let cloudMeterNames = "MeterNameStore.cloudMeterNames"

+        static let cloudTemperatureUnits = "MeterNameStore.cloudTemperatureUnits"

+    }

+

+    private let defaults = UserDefaults.standard

+    private let ubiquitousStore = NSUbiquitousKeyValueStore.default

+    private let workQueue = DispatchQueue(label: "MeterNameStore.Queue")

+    private var cloudAvailability: CloudAvailability = .unknown

+    private var ubiquitousObserver: NSObjectProtocol?

+    private var ubiquityIdentityObserver: NSObjectProtocol?

+

+    private init() {

+        ubiquitousObserver = NotificationCenter.default.addObserver(

+            forName: NSUbiquitousKeyValueStore.didChangeExternallyNotification,

+            object: ubiquitousStore,

+            queue: nil

+        ) { [weak self] notification in

+            self?.handleUbiquitousStoreChange(notification)

+        }

+

+        ubiquityIdentityObserver = NotificationCenter.default.addObserver(

+            forName: NSNotification.Name.NSUbiquityIdentityDidChange,

+            object: nil,

+            queue: nil

+        ) { [weak self] _ in

+            self?.refreshCloudAvailability(reason: "identity-changed")

+            self?.syncLocalValuesToCloudIfPossible(reason: "identity-changed")

+        }

+

+        refreshCloudAvailability(reason: "startup")

+        ubiquitousStore.synchronize()

+        syncLocalValuesToCloudIfPossible(reason: "startup")

+    }

+

+    var currentCloudAvailability: CloudAvailability {

+        workQueue.sync {

+            cloudAvailability

+        }

+    }

+

+    func name(for macAddress: String) -> String? {

+        let normalizedMAC = normalizedMACAddress(macAddress)

+        guard !normalizedMAC.isEmpty else { return nil }

+        return mergedDictionary(localKey: Keys.localMeterNames, cloudKey: Keys.cloudMeterNames)[normalizedMAC]

+    }

+

+    func temperatureUnitRawValue(for macAddress: String) -> String? {

+        let normalizedMAC = normalizedMACAddress(macAddress)

+        guard !normalizedMAC.isEmpty else { return nil }

+        return mergedDictionary(localKey: Keys.localTemperatureUnits, cloudKey: Keys.cloudTemperatureUnits)[normalizedMAC]

+    }

+

+    func upsert(macAddress: String, name: String?, temperatureUnitRawValue: String?) {

+        let normalizedMAC = normalizedMACAddress(macAddress)

+        guard !normalizedMAC.isEmpty else {

+            track("MeterNameStore ignored upsert with invalid MAC '\(macAddress)'")

+            return

+        }

+

+        var didChange = false

+

+        if let name {

+            didChange = updateDictionaryValue(

+                for: normalizedMAC,

+                value: normalizedName(name),

+                localKey: Keys.localMeterNames,

+                cloudKey: Keys.cloudMeterNames

+            ) || didChange

+        }

+

+        if let temperatureUnitRawValue {

+            didChange = updateDictionaryValue(

+                for: normalizedMAC,

+                value: normalizedTemperatureUnit(temperatureUnitRawValue),

+                localKey: Keys.localTemperatureUnits,

+                cloudKey: Keys.cloudTemperatureUnits

+            ) || didChange

+        }

+

+        if didChange {

+            notifyChange()

+        }

+    }

+

+    func allRecords() -> [Record] {

+        let names = mergedDictionary(localKey: Keys.localMeterNames, cloudKey: Keys.cloudMeterNames)

+        let temperatureUnits = mergedDictionary(localKey: Keys.localTemperatureUnits, cloudKey: Keys.cloudTemperatureUnits)

+        let macAddresses = Set(names.keys).union(temperatureUnits.keys)

+

+        return macAddresses.sorted().map { macAddress in

+            Record(

+                macAddress: macAddress,

+                customName: names[macAddress],

+                temperatureUnit: temperatureUnits[macAddress]

+            )

+        }

+    }

+

+    private func normalizedMACAddress(_ macAddress: String) -> String {

+        macAddress.trimmingCharacters(in: .whitespacesAndNewlines).uppercased()

+    }

+

+    private func normalizedName(_ name: String?) -> String? {

+        guard let trimmed = name?.trimmingCharacters(in: .whitespacesAndNewlines),

+              !trimmed.isEmpty else {

+            return nil

+        }

+        return trimmed

+    }

+

+    private func normalizedTemperatureUnit(_ value: String?) -> String? {

+        guard let trimmed = value?.trimmingCharacters(in: .whitespacesAndNewlines),

+              !trimmed.isEmpty else {

+            return nil

+        }

+        return trimmed

+    }

+

+    private func dictionary(for key: String, store: KeyValueReading) -> [String: String] {

+        (store.object(forKey: key) as? [String: String]) ?? [:]

+    }

+

+    private func mergedDictionary(localKey: String, cloudKey: String) -> [String: String] {

+        let localValues = dictionary(for: localKey, store: defaults)

+        let cloudValues = dictionary(for: cloudKey, store: ubiquitousStore)

+        return localValues.merging(cloudValues) { _, cloudValue in

+            cloudValue

+        }

+    }

+

+    @discardableResult

+    private func updateDictionaryValue(

+        for macAddress: String,

+        value: String?,

+        localKey: String,

+        cloudKey: String

+    ) -> Bool {

+        var localValues = dictionary(for: localKey, store: defaults)

+        let didChangeLocal = setDictionaryValue(&localValues, for: macAddress, value: value)

+        if didChangeLocal {

+            defaults.set(localValues, forKey: localKey)

+        }

+

+        var didChangeCloud = false

+        if isICloudDriveAvailable {

+            var cloudValues = dictionary(for: cloudKey, store: ubiquitousStore)

+            didChangeCloud = setDictionaryValue(&cloudValues, for: macAddress, value: value)

+            if didChangeCloud {

+                ubiquitousStore.set(cloudValues, forKey: cloudKey)

+                ubiquitousStore.synchronize()

+            }

+        }

+

+        return didChangeLocal || didChangeCloud

+    }

+

+    @discardableResult

+    private func setDictionaryValue(

+        _ dictionary: inout [String: String],

+        for macAddress: String,

+        value: String?

+    ) -> Bool {

+        let currentValue = dictionary[macAddress]

+        guard currentValue != value else { return false }

+        if let value {

+            dictionary[macAddress] = value

+        } else {

+            dictionary.removeValue(forKey: macAddress)

+        }

+        return true

+    }

+

+    private var isICloudDriveAvailable: Bool {

+        FileManager.default.ubiquityIdentityToken != nil

+    }

+

+    private func refreshCloudAvailability(reason: String) {

+        let newAvailability: CloudAvailability = isICloudDriveAvailable ? .available : .noAccount

+

+        var shouldNotify = false

+        workQueue.sync {

+            guard cloudAvailability != newAvailability else { return }

+            cloudAvailability = newAvailability

+            shouldNotify = true

+        }

+

+        guard shouldNotify else { return }

+        track("MeterNameStore iCloud availability (\(reason)): \(newAvailability)")

+        DispatchQueue.main.async {

+            NotificationCenter.default.post(name: .meterNameStoreCloudStatusDidChange, object: nil)

+        }

+    }

+

+    private func handleUbiquitousStoreChange(_ notification: Notification) {

+        refreshCloudAvailability(reason: "ubiquitous-store-change")

+        if let changedKeys = notification.userInfo?[NSUbiquitousKeyValueStoreChangedKeysKey] as? [String], !changedKeys.isEmpty {

+            track("MeterNameStore received ubiquitous changes for keys: \(changedKeys.joined(separator: ", "))")

+        }

+        notifyChange()

+    }

+

+    private func syncLocalValuesToCloudIfPossible(reason: String) {

+        guard isICloudDriveAvailable else {

+            refreshCloudAvailability(reason: reason)

+            return

+        }

+

+        let localNames = dictionary(for: Keys.localMeterNames, store: defaults)

+        let localTemperatureUnits = dictionary(for: Keys.localTemperatureUnits, store: defaults)

+

+        var cloudNames = dictionary(for: Keys.cloudMeterNames, store: ubiquitousStore)

+        var cloudTemperatureUnits = dictionary(for: Keys.cloudTemperatureUnits, store: ubiquitousStore)

+

+        let mergedNames = cloudNames.merging(localNames) { cloudValue, _ in

+            cloudValue

+        }

+        let mergedTemperatureUnits = cloudTemperatureUnits.merging(localTemperatureUnits) { cloudValue, _ in

+            cloudValue

+        }

+

+        var didChange = false

+        if cloudNames != mergedNames {

+            cloudNames = mergedNames

+            ubiquitousStore.set(cloudNames, forKey: Keys.cloudMeterNames)

+            didChange = true

+        }

+        if cloudTemperatureUnits != mergedTemperatureUnits {

+            cloudTemperatureUnits = mergedTemperatureUnits

+            ubiquitousStore.set(cloudTemperatureUnits, forKey: Keys.cloudTemperatureUnits)

+            didChange = true

+        }

+

+        refreshCloudAvailability(reason: reason)

+

+        if didChange {

+            ubiquitousStore.synchronize()

+            track("MeterNameStore pushed local fallback values into iCloud KVS (\(reason)).")

+            notifyChange()

+        }

+    }

+

+    private func notifyChange() {

+        DispatchQueue.main.async {

+            NotificationCenter.default.post(name: .meterNameStoreDidChange, object: nil)

+        }

+    }

+

+    deinit {

+        if let observer = ubiquitousObserver {

+            NotificationCenter.default.removeObserver(observer)

+        }

+        if let observer = ubiquityIdentityObserver {

+            NotificationCenter.default.removeObserver(observer)

+        }

+    }

+}

+

+private protocol KeyValueReading {

+    func object(forKey defaultName: String) -> Any?

+}

+

+extension UserDefaults: KeyValueReading {}

+extension NSUbiquitousKeyValueStore: KeyValueReading {}

+

+extension Notification.Name {

+    static let meterNameStoreDidChange = Notification.Name("MeterNameStoreDidChange")

+    static let meterNameStoreCloudStatusDidChange = Notification.Name("MeterNameStoreCloudStatusDidChange")

+}

+        case cloudSyncUnavailable

+            case .cloudSyncUnavailable:

+                return .indigo

+            case .cloudSyncUnavailable:

+                return "icloud.slash.fill"

+            case .cloudSyncUnavailable:

+                return "Sync Off"

+

+

+                    debugLink

+                if activeHelpAutoReason == .cloudSyncUnavailable {

+                    Button(action: openSettings) {

+                        sidebarLinkCard(

+                            title: "Open Settings",

+                            subtitle: "Check Apple ID, iCloud Drive, and any restrictions affecting Cloud sync.",

+                            symbol: "gearshape.fill",

+                            tint: .indigo

+                        )

+                    }

+                    .buttonStyle(.plain)

+                }

+

+    private var debugLink: some View {

+        NavigationLink(destination: MeterMappingDebugView()) {

+            sidebarLinkCard(

+                title: "Meter Mapping Debug",

+                subtitle: "Inspect the MAC ↔ name/TC66 table as seen by this device.",

+                symbol: "list.bullet.rectangle",

+                tint: .purple

+            )

+        }

+        .buttonStyle(.plain)

+    }

+

+        if shouldPromptForCloudSync {

+            return .cloudSyncUnavailable

+        }

+    private var shouldPromptForCloudSync: Bool {

+        switch appData.cloudAvailability {

+        case .noAccount, .error:

+            return true

+        case .unknown, .available:

+            return false

+        }

+    }

+

+        case .cloudSyncUnavailable:

+            return appData.cloudAvailability.helpMessage

+    private func openSettings() {

+        guard let settingsURL = URL(string: UIApplication.openSettingsURLString) else {

+            return

+        }

+        UIApplication.shared.open(settingsURL, options: [:], completionHandler: nil)

+    }

+

+        case .cloudSyncUnavailable:

+            return appData.cloudAvailability.helpTitle

+        case .cloudSyncUnavailable:

+            return appData.cloudAvailability.helpMessage

+//  MeterMappingDebugView.swift

+//  USB Meter

+//

+//  Created by Codex on 2026.

+//

+

+import SwiftUI

+

+struct MeterMappingDebugView: View {

+    @State private var records: [MeterNameRecord] = []

+    private let store = MeterNameStore.shared

+    private let changePublisher = NotificationCenter.default.publisher(for: .meterNameStoreDidChange)

+

+    var body: some View {

+        List(records) { record in

+            VStack(alignment: .leading, spacing: 6) {

+                Text(record.customName)

+                    .font(.headline)

+                Text(record.macAddress)

+                    .font(.caption.monospaced())

+                    .foregroundColor(.secondary)

+                HStack {

+                    Text("TC66 unit:")

+                        .font(.caption.weight(.semibold))

+                    Text(record.temperatureUnit)

+                        .font(.caption.monospaced())

+                        .foregroundColor(.blue)

+                }

+            }

+            .padding(.vertical, 8)

+        }

+        .listStyle(.insetGrouped)

+        .navigationTitle("Meter Name Mapping")

+        .onAppear(perform: reload)

+        .onReceive(changePublisher) { _ in reload() }

+        .toolbar {

+            Button("Refresh") {

+                reload()

+            }

+        }

+    }

+

+    private func reload() {

+        records = store.allRecords().map { record in

+            MeterNameRecord(

+                id: record.id,

+                macAddress: record.macAddress,

+                customName: record.customName ?? "<unnamed>",

+                temperatureUnit: record.temperatureUnit ?? "n/a"

+            )

+        }

+    }

+}

+

+private struct MeterNameRecord: Identifiable {

+    let id: String

+    let macAddress: String

+    let customName: String

+    let temperatureUnit: String

+}