Refine charge session monitoring flow · c086d02

Refine charge session monitoring flow
Browse files

bogdan committed a month ago

codex/restore-session-chart main

1 parent 16dd590

commit c086d02

Showing 28 changed files with 1792 additions and 837 deletions

+3 -1

USB Meter.xcodeproj/project.pbxproj

@@ -130,6 +130,7 @@
 		C100001C3C8E4A7A00A1001C /* USB_Meter 7.xcdatamodel */ = {isa = PBXFileReference; lastKnownFileType = wrapper.xcdatamodel; path = "USB_Meter 7.xcdatamodel"; sourceTree = "<group>"; };
 		C100001D3C8E4A7A00A1001D /* USB_Meter 8.xcdatamodel */ = {isa = PBXFileReference; lastKnownFileType = wrapper.xcdatamodel; path = "USB_Meter 8.xcdatamodel"; sourceTree = "<group>"; };
 		C100001E3C8E4A7A00A1001E /* USB_Meter 9.xcdatamodel */ = {isa = PBXFileReference; lastKnownFileType = wrapper.xcdatamodel; path = "USB_Meter 9.xcdatamodel"; sourceTree = "<group>"; };
+		C10000223C8E4A7A00A10022 /* USB_Meter 10.xcdatamodel */ = {isa = PBXFileReference; lastKnownFileType = wrapper.xcdatamodel; path = "USB_Meter 10.xcdatamodel"; sourceTree = "<group>"; };
 		430CB4FB245E07EB006525C2 /* ChevronView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ChevronView.swift; sourceTree = "<group>"; };
 		4311E639241384960080EA59 /* DeviceHelpView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = DeviceHelpView.swift; sourceTree = "<group>"; };
 		4327461A24619CED0009BE4B /* MeterRowView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MeterRowView.swift; sourceTree = "<group>"; };
@@ -829,8 +830,9 @@
 				C100001C3C8E4A7A00A1001C /* USB_Meter 7.xcdatamodel */,
 				C100001D3C8E4A7A00A1001D /* USB_Meter 8.xcdatamodel */,
 				C100001E3C8E4A7A00A1001E /* USB_Meter 9.xcdatamodel */,
+				C10000223C8E4A7A00A10022 /* USB_Meter 10.xcdatamodel */,
 			);
-			currentVersion = C100001E3C8E4A7A00A1001E /* USB_Meter 9.xcdatamodel */;
+			currentVersion = C10000223C8E4A7A00A10022 /* USB_Meter 10.xcdatamodel */;
 			path = CKModel.xcdatamodeld;
 			sourceTree = "<group>";
 			versionGroupType = wrapper.xcdatamodel;


+1 -1

USB Meter/AppDelegate.swift

View

@@ -233,7 +233,7 @@ class AppDelegate: UIResponder, UIApplicationDelegate, UNUserNotificationCenterD
         }
 
         container.viewContext.automaticallyMergesChangesFromParent = true
-        container.viewContext.mergePolicy = NSMergeByPropertyStoreTrumpMergePolicy
+        container.viewContext.mergePolicy = NSMergeByPropertyObjectTrumpMergePolicy
         return container
     }()
 


+152 -25

USB Meter/Model/AppData.swift

View

@@ -12,6 +12,15 @@ import CoreBluetooth
 import CoreData
 import UserNotifications
 
+struct BatteryCheckpointPlausibilityWarning: Identifiable, Hashable {
+    let title: String
+    let message: String
+
+    var id: String {
+        "\(title)\n\(message)"
+    }
+}
+
 final class AppData : ObservableObject {
     struct MeterSummary: Identifiable {
         let macAddress: String
@@ -77,7 +86,7 @@ final class AppData : ObservableObject {
         }
 
         context.automaticallyMergesChangesFromParent = true
-        context.mergePolicy = NSMergeByPropertyStoreTrumpMergePolicy
+        context.mergePolicy = NSMergeByPropertyObjectTrumpMergePolicy
         chargeInsightsStore = ChargeInsightsStore(context: context)
 
         chargeInsightsStoreObserver = NotificationCenter.default.publisher(
@@ -143,6 +152,15 @@ final class AppData : ObservableObject {
         chargedDevices.first(where: { $0.id == id })
     }
 
+    func chargeSessionSummary(id: UUID) -> ChargeSessionSummary? {
+        for chargedDevice in chargedDevices {
+            if let session = chargedDevice.sessions.first(where: { $0.id == id }) {
+                return session
+            }
+        }
+        return nil
+    }
+
     func chargedDevices(for meterMACAddress: String) -> [ChargedDeviceSummary] {
         let normalizedMAC = meterMACAddress.trimmingCharacters(in: .whitespacesAndNewlines).uppercased()
         return chargedDevices.filter { chargedDevice in
@@ -201,25 +219,23 @@ final class AppData : ObservableObject {
     }
 
     @discardableResult
-    func createChargedDevice(
+    func createDevice(
         name: String,
         deviceClass: ChargedDeviceClass,
         chargingStateAvailability: ChargingStateAvailability,
         supportsWiredCharging: Bool,
         supportsWirelessCharging: Bool,
-        preferredChargingTransportMode: ChargingTransportMode,
         wirelessChargingProfile: WirelessChargingProfile,
         configuredCompletionCurrents: [ChargeSessionKind: Double],
         notes: String?,
         meterMACAddress: String?
     ) -> Bool {
-        let didSave = chargeInsightsStore?.createChargedDevice(
+        let didSave = chargeInsightsStore?.createDevice(
             name: name,
             deviceClass: deviceClass,
             chargingStateAvailability: chargingStateAvailability,
             supportsWiredCharging: supportsWiredCharging,
             supportsWirelessCharging: supportsWirelessCharging,
-            preferredChargingTransportMode: preferredChargingTransportMode,
             wirelessChargingProfile: wirelessChargingProfile,
             configuredCompletionCurrents: configuredCompletionCurrents,
             notes: notes,
@@ -234,26 +250,43 @@ final class AppData : ObservableObject {
     }
 
     @discardableResult
-    func updateChargedDevice(
+    func createCharger(
+        name: String,
+        notes: String?,
+        meterMACAddress: String?
+    ) -> Bool {
+        let didSave = chargeInsightsStore?.createCharger(
+            name: name,
+            notes: notes,
+            assignTo: meterMACAddress
+        ) ?? false
+
+        if didSave {
+            reloadChargedDevices()
+        }
+
+        return didSave
+    }
+
+    @discardableResult
+    func updateDevice(
         id: UUID,
         name: String,
         deviceClass: ChargedDeviceClass,
         chargingStateAvailability: ChargingStateAvailability,
         supportsWiredCharging: Bool,
         supportsWirelessCharging: Bool,
-        preferredChargingTransportMode: ChargingTransportMode,
         wirelessChargingProfile: WirelessChargingProfile,
         configuredCompletionCurrents: [ChargeSessionKind: Double],
         notes: String?
     ) -> Bool {
-        let didSave = chargeInsightsStore?.updateChargedDevice(
+        let didSave = chargeInsightsStore?.updateDevice(
             id: id,
             name: name,
             deviceClass: deviceClass,
             chargingStateAvailability: chargingStateAvailability,
             supportsWiredCharging: supportsWiredCharging,
             supportsWirelessCharging: supportsWirelessCharging,
-            preferredChargingTransportMode: preferredChargingTransportMode,
             wirelessChargingProfile: wirelessChargingProfile,
             configuredCompletionCurrents: configuredCompletionCurrents,
             notes: notes
@@ -267,10 +300,15 @@ final class AppData : ObservableObject {
     }
 
     @discardableResult
-    func setChargingTransportMode(_ chargingTransportMode: ChargingTransportMode, for meter: Meter) -> Bool {
-        let didSave = chargeInsightsStore?.setChargingTransportMode(
-            chargingTransportMode,
-            for: meter.btSerial.macAddress.description
+    func updateCharger(
+        id: UUID,
+        name: String,
+        notes: String?
+    ) -> Bool {
+        let didSave = chargeInsightsStore?.updateCharger(
+            id: id,
+            name: name,
+            notes: notes
         ) ?? false
 
         if didSave {
@@ -298,6 +336,16 @@ final class AppData : ObservableObject {
         return didSave
     }
 
+    func restoreChargeMonitoringStateIfNeeded(for meter: Meter) {
+        guard let activeSession = activeChargeSessionSummary(for: meter.btSerial.macAddress.description) else {
+            return
+        }
+        guard activeSession.status == .active else {
+            return
+        }
+        meter.restoreChargeMonitoringIfNeeded(from: activeSession)
+    }
+
     @discardableResult
     func startChargeSession(
         for meter: Meter,
@@ -306,7 +354,8 @@ final class AppData : ObservableObject {
         chargingTransportMode: ChargingTransportMode,
         chargingStateMode: ChargingStateMode,
         autoStopEnabled: Bool,
-        initialBatteryPercent: Double
+        initialBatteryPercent: Double?,
+        startsFromFlatBattery: Bool
     ) -> Bool {
         guard let snapshot = meter.chargingMonitorSnapshot else {
             return false
@@ -319,10 +368,18 @@ final class AppData : ObservableObject {
             chargingTransportMode: chargingTransportMode,
             chargingStateMode: chargingStateMode,
             autoStopEnabled: autoStopEnabled,
-            initialBatteryPercent: initialBatteryPercent
+            initialBatteryPercent: initialBatteryPercent,
+            startsFromFlatBattery: startsFromFlatBattery
         ) ?? false
         if didSave {
             reloadChargedDevices()
+            meter.resetChargeRecordGraph()
+            if let activeSession = activeChargeSessionSummary(for: meter.btSerial.macAddress.description),
+               meter.supportsRecordingThreshold,
+               activeSession.stopThresholdAmps > 0 {
+                meter.recordingTreshold = activeSession.stopThresholdAmps
+            }
+            restoreChargeMonitoringStateIfNeeded(for: meter)
         }
         return didSave
     }
@@ -404,6 +461,30 @@ final class AppData : ObservableObject {
         return didSave
     }
 
+    func batteryCheckpointPlausibilityWarning(
+        percent: Double,
+        for sessionID: UUID
+    ) -> BatteryCheckpointPlausibilityWarning? {
+        guard let session = chargeSessionSummary(id: sessionID) else {
+            return nil
+        }
+        return batteryCheckpointPlausibilityWarning(percent: percent, for: session)
+    }
+
+    @discardableResult
+    func deleteBatteryCheckpoint(checkpointID: UUID, for sessionID: UUID) -> Bool {
+        let didDelete = chargeInsightsStore?.deleteBatteryCheckpoint(
+            id: checkpointID,
+            from: sessionID
+        ) ?? false
+
+        if didDelete {
+            reloadChargedDevices()
+        }
+
+        return didDelete
+    }
+
     @discardableResult
     func flushChargeInsights() -> Bool {
         let didSave = chargeInsightsStore?.flushPendingChanges() ?? false
@@ -531,16 +612,6 @@ final class AppData : ObservableObject {
         return didDelete
     }
 
-    func restoreChargeMonitoringStateIfNeeded(for meter: Meter) {
-        guard let activeSession = activeChargeSessionSummary(for: meter.btSerial.macAddress.description) else {
-            return
-        }
-        guard activeSession.status == .active else {
-            return
-        }
-        meter.restoreChargeMonitoringIfNeeded(from: activeSession)
-    }
-
     var meterSummaries: [MeterSummary] {
         let liveMetersByMAC = Dictionary(uniqueKeysWithValues: meters.values.map { ($0.btSerial.macAddress.description, $0) })
         let recordsByMAC = Dictionary(uniqueKeysWithValues: meterStore.allRecords().map { ($0.macAddress, $0) })
@@ -619,6 +690,62 @@ final class AppData : ObservableObject {
             }
         }
     }
+
+    private func batteryCheckpointPlausibilityWarning(
+        percent: Double,
+        for session: ChargeSessionSummary
+    ) -> BatteryCheckpointPlausibilityWarning? {
+        guard percent.isFinite, percent >= 0, percent <= 100 else {
+            return nil
+        }
+
+        let sortedCheckpoints = session.checkpoints.sorted { lhs, rhs in
+            if lhs.timestamp != rhs.timestamp {
+                return lhs.timestamp < rhs.timestamp
+            }
+            if lhs.measuredEnergyWh != rhs.measuredEnergyWh {
+                return lhs.measuredEnergyWh < rhs.measuredEnergyWh
+            }
+            return lhs.id.uuidString < rhs.id.uuidString
+        }
+
+        if let lastCheckpoint = sortedCheckpoints.last,
+           percent < lastCheckpoint.batteryPercent - 1.5 {
+            return BatteryCheckpointPlausibilityWarning(
+                title: "Checkpoint Goes Backwards",
+                message: "The latest checkpoint is \(lastCheckpoint.batteryPercent.format(decimalDigits: 0))% at \(lastCheckpoint.timestamp.format()). A new value of \(percent.format(decimalDigits: 0))% is unexpectedly lower while the session is still charging."
+            )
+        }
+
+        guard let chargedDevice = chargedDeviceSummary(id: session.chargedDeviceID),
+              let prediction = chargedDevice.batteryLevelPrediction(for: session)
+        else {
+            return nil
+        }
+
+        let predictionGap = percent - prediction.predictedPercent
+        guard abs(predictionGap) >= 4 else {
+            return nil
+        }
+
+        let direction = predictionGap > 0 ? "above" : "below"
+        let gapText = abs(predictionGap).format(decimalDigits: 0)
+        let predictedText = prediction.predictedPercent.format(decimalDigits: 0)
+
+        if let lastCheckpoint = sortedCheckpoints.last {
+            let effectiveEnergyWh = session.effectiveBatteryEnergyWh ?? session.measuredEnergyWh
+            let energyDeltaWh = max(effectiveEnergyWh - lastCheckpoint.measuredEnergyWh, 0)
+            return BatteryCheckpointPlausibilityWarning(
+                title: "Checkpoint Looks Implausible",
+                message: "This value is about \(gapText) percentage points \(direction) the predicted \(predictedText)% based on \(prediction.anchorDescription). Since the last checkpoint at \(lastCheckpoint.batteryPercent.format(decimalDigits: 0))%, only \(energyDeltaWh.format(decimalDigits: 2)) Wh were added."
+            )
+        }
+
+        return BatteryCheckpointPlausibilityWarning(
+            title: "Checkpoint Looks Implausible",
+            message: "This value is about \(gapText) percentage points \(direction) the predicted \(predictedText)% based on \(prediction.anchorDescription). Save it only if the device gauge really jumped that much."
+        )
+    }
 }
 
 extension AppData.MeterSummary {


+120 -15

USB Meter/Model/ChargeInsightsModel.swift

View

	@@ -7,6 +7,40 @@
7	7
8	8	import Foundation
9	9
	10	+enum ChargedDeviceKind: String, Identifiable {
	11	+ case device
	12	+ case charger
	13	+
	14	+ var id: String { rawValue }
	15	+
	16	+ var title: String {
	17	+ switch self {
	18	+ case .device:
	19	+ return "Device"
	20	+ case .charger:
	21	+ return "Charger"
	22	+ }
	23	+ }
	24	+
	25	+ var pluralTitle: String {
	26	+ switch self {
	27	+ case .device:
	28	+ return "Devices"
	29	+ case .charger:
	30	+ return "Chargers"
	31	+ }
	32	+ }
	33	+
	34	+ var symbolName: String {
	35	+ switch self {
	36	+ case .device:
	37	+ return "iphone"
	38	+ case .charger:
	39	+ return "bolt.horizontal.circle"
	40	+ }
	41	+ }
	42	+}
	43	+
10	44	enum ChargedDeviceClass: String, CaseIterable, Identifiable {
11	45	case iphone
12	46	case watch
	@@ -16,6 +50,14 @@ enum ChargedDeviceClass: String, CaseIterable, Identifiable {
16	50
17	51	var id: String { rawValue }
18	52
	53	+ static var deviceCases: [ChargedDeviceClass] {
	54	+ allCases.filter { $0 != .charger }
	55	+ }
	56	+
	57	+ var kind: ChargedDeviceKind {
	58	+ self == .charger ? .charger : .device
	59	+ }
	60	+
19	61	var title: String {
20	62	switch self {
21	63	case .iphone:
	@@ -318,6 +360,8 @@ struct ChargeSessionSummary: Identifiable, Hashable {
318	360	let measuredEnergyWh: Double
319	361	let effectiveBatteryEnergyWh: Double?
320	362	let measuredChargeAh: Double
	363	+ let meterEnergyBaselineWh: Double?
	364	+ let meterChargeBaselineAh: Double?
321	365	let minimumObservedCurrentAmps: Double?
322	366	let maximumObservedCurrentAmps: Double?
323	367	let maximumObservedPowerWatts: Double?
	@@ -358,7 +402,8 @@ struct ChargeSessionSummary: Identifiable, Hashable {
358	402	}
359	403
360	404	var batteryDeltaPercent: Double? {
361		- guard let startBatteryPercent, let endBatteryPercent else { return nil }
	405	+ guard let startBatteryPercent, let endBatteryPercent,
	406	+ startBatteryPercent >= 0, endBatteryPercent >= 0 else { return nil }
362	407	return endBatteryPercent - startBatteryPercent
363	408	}
364	409
	@@ -383,6 +428,40 @@ struct BatteryLevelPrediction: Hashable {
383	428	let anchorDescription: String
384	429	}
385	430
	431	+enum BatteryLevelPredictionTuning {
	432	+ static let checkpointSettleDuration: TimeInterval = 10 * 60
	433	+
	434	+ static func predictedPercent(
	435	+ anchorPercent: Double,
	436	+ anchorEnergyWh: Double,
	437	+ anchorTimestamp: Date,
	438	+ anchorIsCheckpoint: Bool,
	439	+ effectiveEnergyWh: Double,
	440	+ referenceTimestamp: Date,
	441	+ estimatedCapacityWh: Double
	442	+ ) -> Double {
	443	+ let energyDeltaWh = max(effectiveEnergyWh - anchorEnergyWh, 0)
	444	+ let rawGainPercent = (energyDeltaWh / estimatedCapacityWh) * 100
	445	+ let stabilizedGainPercent: Double
	446	+
	447	+ if anchorIsCheckpoint {
	448	+ let elapsedSinceAnchor = max(referenceTimestamp.timeIntervalSince(anchorTimestamp), 0)
	449	+ let settleProgress = min(max(elapsedSinceAnchor / checkpointSettleDuration, 0), 1)
	450	+ stabilizedGainPercent = rawGainPercent * settleProgress
	451	+ } else {
	452	+ stabilizedGainPercent = rawGainPercent
	453	+ }
	454	+
	455	+ return min(
	456	+ 100,
	457	+ max(
	458	+ 0,
	459	+ anchorPercent + stabilizedGainPercent
	460	+ )
	461	+ )
	462	+ }
	463	+}
	464	+
386	465	struct CapacityTrendPoint: Identifiable, Hashable {
387	466	let sessionID: UUID
388	467	let timestamp: Date
	@@ -410,7 +489,6 @@ struct ChargedDeviceSummary: Identifiable, Hashable {
410	489	let chargingStateAvailability: ChargingStateAvailability
411	490	let supportsWiredCharging: Bool
412	491	let supportsWirelessCharging: Bool
413		- let preferredChargingTransportMode: ChargingTransportMode
414	492	let wirelessChargingProfile: WirelessChargingProfile
415	493	let configuredCompletionCurrents: [ChargeSessionKind: Double]
416	494	let learnedCompletionCurrents: [ChargeSessionKind: Double]
	@@ -439,6 +517,18 @@ struct ChargedDeviceSummary: Identifiable, Hashable {
439	517	deviceClass == .charger
440	518	}
441	519
	520	+ var kind: ChargedDeviceKind {
	521	+ deviceClass.kind
	522	+ }
	523	+
	524	+ var identityTitle: String {
	525	+ isCharger ? kind.title : deviceClass.title
	526	+ }
	527	+
	528	+ var identitySymbolName: String {
	529	+ isCharger ? kind.symbolName : deviceClass.symbolName
	530	+ }
	531	+
442	532	var activeSession: ChargeSessionSummary? {
443	533	sessions.first(where: \.isOpen)
444	534	}
	@@ -459,7 +549,7 @@ struct ChargedDeviceSummary: Identifiable, Hashable {
459	549	if supportsWirelessCharging {
460	550	modes.append(.wireless)
461	551	}
462		- return modes.isEmpty ? [preferredChargingTransportMode] : modes
	552	+ return modes
463	553	}
464	554
465	555	var supportedChargingStateModes: [ChargingStateMode] {
	@@ -544,7 +634,10 @@ struct ChargedDeviceSummary: Identifiable, Hashable {
544	634	?? minimumCurrentAmps
545	635	}
546	636
547		- func batteryLevelPrediction(for session: ChargeSessionSummary) -> BatteryLevelPrediction? {
	637	+ func batteryLevelPrediction(
	638	+ for session: ChargeSessionSummary,
	639	+ effectiveEnergyWhOverride: Double? = nil
	640	+ ) -> BatteryLevelPrediction? {
548	641	let estimatedCapacityWh = session.capacityEstimateWh
549	642	?? estimatedBatteryCapacityWh(for: session.chargingTransportMode)
550	643	?? estimatedBatteryCapacityWh
	@@ -553,22 +646,28 @@ struct ChargedDeviceSummary: Identifiable, Hashable {
553	646	return nil
554	647	}
555	648
556		- let effectiveEnergyWh = session.effectiveBatteryEnergyWh ?? session.measuredEnergyWh
	649	+ let effectiveEnergyWh = effectiveEnergyWhOverride
	650	+ ?? session.effectiveBatteryEnergyWh
	651	+ ?? session.measuredEnergyWh
557	652
558	653	struct Anchor {
559	654	let percent: Double
560	655	let energyWh: Double
	656	+ let timestamp: Date
561	657	let description: String
	658	+ let isCheckpoint: Bool
562	659	}
563	660
564	661	var anchors: [Anchor] = []
565	662
566		- if let startBatteryPercent = session.startBatteryPercent {
	663	+ if let startBatteryPercent = session.startBatteryPercent, startBatteryPercent >= 0 {
567	664	anchors.append(
568	665	Anchor(
569	666	percent: startBatteryPercent,
570	667	energyWh: 0,
571		- description: "session start"
	668	+ timestamp: session.startedAt,
	669	+ description: "session start",
	670	+ isCheckpoint: false
572	671	)
573	672	)
574	673	}
	@@ -581,12 +680,17 @@ struct ChargedDeviceSummary: Identifiable, Hashable {
581	680	}
582	681	return lhs.timestamp < rhs.timestamp
583	682	}
	683	+ .filter { checkpoint in
	684	+ checkpoint.batteryPercent >= 0
	685	+ }
584	686	.map { checkpoint in
585	687	let trimmedLabel = checkpoint.label?.trimmingCharacters(in: .whitespacesAndNewlines)
586	688	return Anchor(
587	689	percent: checkpoint.batteryPercent,
588	690	energyWh: checkpoint.measuredEnergyWh,
589		- description: trimmedLabel.map { "checkpoint \($0)" } ?? "last checkpoint"
	691	+ timestamp: checkpoint.timestamp,
	692	+ description: trimmedLabel.map { "checkpoint \($0)" } ?? "last checkpoint",
	693	+ isCheckpoint: true
590	694	)
591	695	}
592	696	)
	@@ -597,13 +701,14 @@ struct ChargedDeviceSummary: Identifiable, Hashable {
597	701
598	702	let eligibleAnchors = anchors.filter { $0.energyWh <= effectiveEnergyWh + 0.05 }
599	703	let anchor = eligibleAnchors.last ?? anchors.first!
600		- let energyDeltaWh = max(effectiveEnergyWh - anchor.energyWh, 0)
601		- let predictedPercent = min(
602		- 100,
603		- max(
604		- 0,
605		- anchor.percent + ((energyDeltaWh / estimatedCapacityWh) * 100)
606		- )
	704	+ let predictedPercent = BatteryLevelPredictionTuning.predictedPercent(
	705	+ anchorPercent: anchor.percent,
	706	+ anchorEnergyWh: anchor.energyWh,
	707	+ anchorTimestamp: anchor.timestamp,
	708	+ anchorIsCheckpoint: anchor.isCheckpoint,
	709	+ effectiveEnergyWh: effectiveEnergyWh,
	710	+ referenceTimestamp: session.lastObservedAt,
	711	+ estimatedCapacityWh: estimatedCapacityWh
607	712	)
608	713
609	714	return BatteryLevelPrediction(

+297 -149

USB Meter/Model/ChargeInsightsStore.swift

View

@@ -37,6 +37,7 @@ final class ChargeInsightsStore {
     private let stopDetectionHoldDuration: TimeInterval = 20
     private let maximumLiveIntegrationGap: TimeInterval = 20
     private let activeSessionSaveInterval: TimeInterval = 15
+    private let aggregatedSampleSaveInterval: TimeInterval = 5
     private let counterDecreaseTolerance = 0.002
     private let completionConfirmationCooldown: TimeInterval = 15 * 60
     private let pausedSessionTimeout: TimeInterval = 10 * 60
@@ -45,6 +46,7 @@ final class ChargeInsightsStore {
     private let minimumWirelessEfficiencyFactor = 0.35
     private let maximumWirelessEfficiencyFactor = 0.95
     private let lowWirelessEfficiencyThreshold = 0.72
+    private let unresolvedFlatBatteryPercent = -1.0
 
     init(context: NSManagedObjectContext) {
         self.context = context
@@ -67,18 +69,18 @@ final class ChargeInsightsStore {
     }
 
     @discardableResult
-    func createChargedDevice(
+    func createDevice(
         name: String,
         deviceClass: ChargedDeviceClass,
         chargingStateAvailability: ChargingStateAvailability,
         supportsWiredCharging: Bool,
         supportsWirelessCharging: Bool,
-        preferredChargingTransportMode: ChargingTransportMode,
         wirelessChargingProfile: WirelessChargingProfile,
         configuredCompletionCurrents: [ChargeSessionKind: Double],
         notes: String?,
         assignTo meterMACAddress: String?
     ) -> Bool {
+        guard deviceClass.kind == .device else { return false }
         let normalizedName = normalizedText(name)
         guard !normalizedName.isEmpty else { return false }
         guard supportsWiredCharging || supportsWirelessCharging else { return false }
@@ -98,14 +100,6 @@ final class ChargeInsightsStore {
             object.setValue(chargingStateAvailability.supportsChargingWhileOff, forKey: "supportsChargingWhileOff")
             object.setValue(supportsWiredCharging, forKey: "supportsWiredCharging")
             object.setValue(supportsWirelessCharging, forKey: "supportsWirelessCharging")
-            object.setValue(
-                resolvedPreferredChargingTransportMode(
-                    preferredChargingTransportMode,
-                    supportsWiredCharging: supportsWiredCharging,
-                    supportsWirelessCharging: supportsWirelessCharging
-                ).rawValue,
-                forKey: "preferredChargingTransportRawValue"
-            )
             object.setValue(wirelessChargingProfile.rawValue, forKey: "wirelessChargingProfileRawValue")
             object.setValue(encodedCompletionCurrents(configuredCompletionCurrents), forKey: "configuredCompletionCurrentsRawValue")
             object.setValue(legacyConfiguredCompletionCurrent(for: configuredCompletionCurrents, chargingTransportMode: .wired), forKey: "wiredChargeCompletionCurrentAmps")
@@ -121,18 +115,56 @@ final class ChargeInsightsStore {
     }
 
     @discardableResult
-    func updateChargedDevice(
+    func createCharger(
+        name: String,
+        notes: String?,
+        assignTo meterMACAddress: String?
+    ) -> Bool {
+        let normalizedName = normalizedText(name)
+        guard !normalizedName.isEmpty else { return false }
+
+        var didSave = false
+        context.performAndWait {
+            guard let entity = NSEntityDescription.entity(forEntityName: EntityName.chargedDevice, in: context) else {
+                return
+            }
+
+            let object = NSManagedObject(entity: entity, insertInto: context)
+            let now = Date()
+            object.setValue(UUID().uuidString, forKey: "id")
+            object.setValue(normalizedName, forKey: "name")
+            object.setValue(ChargedDeviceClass.charger.rawValue, forKey: "deviceClassRawValue")
+            object.setValue(ChargingStateAvailability.onOnly.rawValue, forKey: "chargingStateAvailabilityRawValue")
+            object.setValue(false, forKey: "supportsChargingWhileOff")
+            object.setValue(false, forKey: "supportsWiredCharging")
+            object.setValue(true, forKey: "supportsWirelessCharging")
+            object.setValue(WirelessChargingProfile.genericQi.rawValue, forKey: "wirelessChargingProfileRawValue")
+            object.setValue(encodedCompletionCurrents([:]), forKey: "configuredCompletionCurrentsRawValue")
+            object.setValue(nil, forKey: "wiredChargeCompletionCurrentAmps")
+            object.setValue(nil, forKey: "wirelessChargeCompletionCurrentAmps")
+            object.setValue(normalizedOptionalText(notes), forKey: "notes")
+            object.setValue(generateQRIdentifier(), forKey: "qrIdentifier")
+            object.setValue(normalizedOptionalText(meterMACAddress), forKey: "lastAssociatedMeterMAC")
+            object.setValue(now, forKey: "createdAt")
+            object.setValue(now, forKey: "updatedAt")
+            didSave = saveContext()
+        }
+        return didSave
+    }
+
+    @discardableResult
+    func updateDevice(
         id: UUID,
         name: String,
         deviceClass: ChargedDeviceClass,
         chargingStateAvailability: ChargingStateAvailability,
         supportsWiredCharging: Bool,
         supportsWirelessCharging: Bool,
-        preferredChargingTransportMode: ChargingTransportMode,
         wirelessChargingProfile: WirelessChargingProfile,
         configuredCompletionCurrents: [ChargeSessionKind: Double],
         notes: String?
     ) -> Bool {
+        guard deviceClass.kind == .device else { return false }
         let normalizedName = normalizedText(name)
         guard !normalizedName.isEmpty else { return false }
         guard supportsWiredCharging || supportsWirelessCharging else { return false }
@@ -142,17 +174,14 @@ final class ChargeInsightsStore {
             guard let object = fetchChargedDeviceObject(id: id.uuidString) else {
                 return
             }
+            guard isChargerObject(object) == false else {
+                return
+            }
 
             let previousSupportsChargingWhileOff = boolValue(object, key: "supportsChargingWhileOff")
             let previousChargingStateAvailability = self.chargingStateAvailability(for: object)
             let previousSupportsWiredCharging = self.supportsWiredCharging(for: object)
             let previousSupportsWirelessCharging = self.supportsWirelessCharging(for: object)
-            let previousPreferredChargingTransportMode = self.preferredChargingTransportMode(for: object)
-            let resolvedPreferredTransportMode = resolvedPreferredChargingTransportMode(
-                preferredChargingTransportMode,
-                supportsWiredCharging: supportsWiredCharging,
-                supportsWirelessCharging: supportsWirelessCharging
-            )
             let now = Date()
 
             object.setValue(normalizedName, forKey: "name")
@@ -161,7 +190,6 @@ final class ChargeInsightsStore {
             object.setValue(chargingStateAvailability.supportsChargingWhileOff, forKey: "supportsChargingWhileOff")
             object.setValue(supportsWiredCharging, forKey: "supportsWiredCharging")
             object.setValue(supportsWirelessCharging, forKey: "supportsWirelessCharging")
-            object.setValue(resolvedPreferredTransportMode.rawValue, forKey: "preferredChargingTransportRawValue")
             object.setValue(wirelessChargingProfile.rawValue, forKey: "wirelessChargingProfileRawValue")
             object.setValue(encodedCompletionCurrents(configuredCompletionCurrents), forKey: "configuredCompletionCurrentsRawValue")
             object.setValue(legacyConfiguredCompletionCurrent(for: configuredCompletionCurrents, chargingTransportMode: .wired), forKey: "wiredChargeCompletionCurrentAmps")
@@ -175,7 +203,6 @@ final class ChargeInsightsStore {
                 || previousChargingStateAvailability != chargingStateAvailability
                 || previousSupportsWiredCharging != supportsWiredCharging
                 || previousSupportsWirelessCharging != supportsWirelessCharging
-                || previousPreferredChargingTransportMode != resolvedPreferredTransportMode
 
             if shouldRecalculateSessionCapacity || shouldRefreshActiveSessions {
                 let sessions = fetchSessions(forChargedDeviceID: id.uuidString)
@@ -227,6 +254,33 @@ final class ChargeInsightsStore {
         return didSave
     }
 
+    @discardableResult
+    func updateCharger(
+        id: UUID,
+        name: String,
+        notes: String?
+    ) -> Bool {
+        let normalizedName = normalizedText(name)
+        guard !normalizedName.isEmpty else { return false }
+
+        var didSave = false
+        context.performAndWait {
+            guard let object = fetchChargedDeviceObject(id: id.uuidString) else {
+                return
+            }
+            guard isChargerObject(object) else {
+                return
+            }
+
+            object.setValue(normalizedName, forKey: "name")
+            object.setValue(normalizedOptionalText(notes), forKey: "notes")
+            object.setValue(Date(), forKey: "updatedAt")
+            didSave = saveContext()
+        }
+
+        return didSave
+    }
+
     @discardableResult
     func assignChargedDevice(id: UUID, to meterMACAddress: String) -> Bool {
         assign(itemWithID: id, to: meterMACAddress, kind: .chargedDevice)
@@ -288,60 +342,6 @@ final class ChargeInsightsStore {
         return didSave
     }
 
-    @discardableResult
-    func setChargingTransportMode(_ chargingTransportMode: ChargingTransportMode, for meterMACAddress: String) -> Bool {
-        let normalizedMAC = normalizedMACAddress(meterMACAddress)
-        guard !normalizedMAC.isEmpty else { return false }
-
-        var didSave = false
-        context.performAndWait {
-            let openSession = fetchOpenSessionObject(forMeterMACAddress: normalizedMAC)
-            let device = (openSession.flatMap { stringValue($0, key: "chargedDeviceID") }.flatMap(fetchChargedDeviceObject(id:)))
-                ?? resolvedDeviceObject(for: normalizedMAC)
-
-            guard let device else {
-                return
-            }
-
-            let resolvedMode = resolvedPreferredChargingTransportMode(
-                chargingTransportMode,
-                supportsWiredCharging: supportsWiredCharging(for: device),
-                supportsWirelessCharging: supportsWirelessCharging(for: device)
-            )
-            let charger = resolvedMode == .wireless ? resolvedChargerObject(for: normalizedMAC) : nil
-            guard resolvedMode == .wired || charger != nil else {
-                return
-            }
-
-            device.setValue(resolvedMode.rawValue, forKey: "preferredChargingTransportRawValue")
-            device.setValue(Date(), forKey: "updatedAt")
-
-            if let openSession {
-                let chargingStateMode = resolvedChargingStateMode(
-                    chargingStateMode(for: openSession),
-                    availability: chargingStateAvailability(for: device)
-                )
-                openSession.setValue(resolvedMode.rawValue, forKey: "chargingTransportRawValue")
-                openSession.setValue(charger.flatMap { stringValue($0, key: "id") }, forKey: "chargerID")
-                openSession.setValue(
-                    resolvedStopThreshold(
-                        for: device,
-                        chargingTransportMode: resolvedMode,
-                        chargingStateMode: chargingStateMode,
-                        charger: charger,
-                        fallback: optionalDoubleValue(openSession, key: "stopThresholdAmps")
-                    ) ?? 0,
-                    forKey: "stopThresholdAmps"
-                )
-                openSession.setValue(Date(), forKey: "updatedAt")
-            }
-
-            didSave = saveContext()
-        }
-
-        return didSave
-    }
-
     @discardableResult
     func startSession(
         for snapshot: ChargingMonitorSnapshot,
@@ -350,9 +350,11 @@ final class ChargeInsightsStore {
         chargingTransportMode: ChargingTransportMode,
         chargingStateMode: ChargingStateMode,
         autoStopEnabled: Bool,
-        initialBatteryPercent: Double
+        initialBatteryPercent: Double?,
+        startsFromFlatBattery: Bool
     ) -> Bool {
-        guard initialBatteryPercent.isFinite, initialBatteryPercent >= 0, initialBatteryPercent <= 100 else {
+        if let initialBatteryPercent,
+           (initialBatteryPercent.isFinite == false || initialBatteryPercent < 0 || initialBatteryPercent > 100) {
             return false
         }
 
@@ -361,6 +363,9 @@ final class ChargeInsightsStore {
             guard let chargedDevice = fetchChargedDeviceObject(id: chargedDeviceID.uuidString) else {
                 return
             }
+            guard isChargerObject(chargedDevice) == false else {
+                return
+            }
 
             guard fetchOpenSessionObject(forMeterMACAddress: snapshot.meterMACAddress) == nil else {
                 return
@@ -378,16 +383,19 @@ final class ChargeInsightsStore {
             let charger = resolvedChargingTransportMode == .wireless
                 ? chargerID.flatMap { fetchChargedDeviceObject(id: $0.uuidString) }
                 : nil
+            if let charger, isChargerObject(charger) == false {
+                return
+            }
             guard resolvedChargingTransportMode == .wired || charger != nil else {
                 return
             }
-            let stopThreshold = autoStopEnabled ? resolvedStopThreshold(
+            let stopThreshold = resolvedStopThreshold(
                 for: chargedDevice,
                 chargingTransportMode: resolvedChargingTransportMode,
                 chargingStateMode: resolvedChargingStateMode,
                 charger: charger,
-                fallback: nil
-            ) : nil
+                fallback: snapshot.fallbackStopThresholdAmps > 0 ? snapshot.fallbackStopThresholdAmps : nil
+            )
             guard let session = createSessionObject(
                 for: chargedDevice,
                 charger: charger,
@@ -400,13 +408,18 @@ final class ChargeInsightsStore {
                 return
             }
 
-            guard insertBatteryCheckpoint(
-                percent: initialBatteryPercent,
-                label: "Start",
-                timestamp: snapshot.observedAt,
-                to: session
-            ) != nil else {
-                return
+            if startsFromFlatBattery {
+                session.setValue(unresolvedFlatBatteryPercent, forKey: "startBatteryPercent")
+                session.setValue(nil, forKey: "endBatteryPercent")
+            } else if let initialBatteryPercent {
+                guard insertBatteryCheckpoint(
+                    percent: initialBatteryPercent,
+                    label: "Start",
+                    timestamp: snapshot.observedAt,
+                    to: session
+                ) != nil else {
+                    return
+                }
             }
             didSave = saveContext()
         }
@@ -577,6 +590,39 @@ final class ChargeInsightsStore {
         return didSave
     }
 
+    @discardableResult
+    func deleteBatteryCheckpoint(
+        id checkpointID: UUID,
+        from sessionID: UUID
+    ) -> Bool {
+        var didSave = false
+        context.performAndWait {
+            guard let session = fetchSessionObject(id: sessionID.uuidString),
+                  let checkpoint = fetchCheckpointObject(
+                    id: checkpointID.uuidString,
+                    sessionID: sessionID.uuidString
+                  ) else {
+                return
+            }
+
+            let chargedDeviceID = stringValue(session, key: "chargedDeviceID")
+            context.delete(checkpoint)
+            refreshCheckpointDerivedValues(for: session)
+
+            guard saveContext() else {
+                return
+            }
+
+            if let chargedDeviceID {
+                refreshDerivedMetrics(forChargedDeviceID: chargedDeviceID)
+                didSave = saveContext()
+            } else {
+                didSave = true
+            }
+        }
+        return didSave
+    }
+
     @discardableResult
     func setTargetBatteryPercent(_ percent: Double?, for sessionID: UUID) -> Bool {
         if let percent, (!percent.isFinite || percent <= 0 || percent > 100) {
@@ -769,10 +815,14 @@ final class ChargeInsightsStore {
             )
 
             update(session: session, with: snapshot, stopThreshold: stopThreshold, charger: charger)
-            updateAggregatedSample(session: session, with: snapshot)
+            let aggregatedSample = updateAggregatedSample(session: session, with: snapshot)
 
             let saveReason = saveReason(for: session, observedAt: snapshot.observedAt)
-            guard saveReason != .none else {
+            let shouldPersistAggregatedCurve = aggregatedSample.map {
+                shouldPersistAggregatedSample($0, observedAt: snapshot.observedAt)
+            } ?? false
+
+            guard saveReason != .none || shouldPersistAggregatedCurve else {
                 return
             }
 
@@ -855,7 +905,6 @@ final class ChargeInsightsStore {
                     chargingStateAvailability: chargingStateAvailability(for: device),
                     supportsWiredCharging: supportsWiredCharging(for: device),
                     supportsWirelessCharging: supportsWirelessCharging(for: device),
-                    preferredChargingTransportMode: preferredChargingTransportMode(for: device),
                     wirelessChargingProfile: wirelessChargingProfile(for: device),
                     configuredCompletionCurrents: decodedCompletionCurrents(from: device, key: "configuredCompletionCurrentsRawValue"),
                     learnedCompletionCurrents: decodedCompletionCurrents(from: device, key: "learnedCompletionCurrentsRawValue"),
@@ -917,11 +966,22 @@ final class ChargeInsightsStore {
         let normalizedMAC = normalizedMACAddress(meterMACAddress)
         guard !normalizedMAC.isEmpty else { return nil }
 
-        return fetchChargedDeviceSummaries()
-            .flatMap(\.sessions)
-            .first(where: {
-                $0.status.isOpen && $0.meterMACAddress == normalizedMAC
-            })
+        var summary: ChargeSessionSummary?
+
+        context.performAndWait {
+            guard let session = fetchActiveSessionObject(forMeterMACAddress: normalizedMAC),
+                  let sessionID = stringValue(session, key: "id") else {
+                return
+            }
+
+            summary = makeSessionSummary(
+                from: session,
+                checkpoints: fetchCheckpointObjects(forSessionID: sessionID),
+                samples: fetchSessionSampleObjects(forSessionID: sessionID)
+            )
+        }
+
+        return summary
     }
 
     private func createSessionObject(
@@ -951,7 +1011,11 @@ final class ChargeInsightsStore {
         session.setValue(now, forKey: "startedAt")
         session.setValue(now, forKey: "lastObservedAt")
         session.setValue(ChargeSessionStatus.active.rawValue, forKey: "statusRawValue")
-        session.setValue(ChargeSessionSourceMode.live.rawValue, forKey: "sourceModeRawValue")
+        let usesMeterCounters = snapshot.meterEnergyCounterWh != nil || snapshot.meterChargeCounterAh != nil
+        session.setValue(
+            (usesMeterCounters ? ChargeSessionSourceMode.offline : .live).rawValue,
+            forKey: "sourceModeRawValue"
+        )
         session.setValue(chargingTransportMode.rawValue, forKey: "chargingTransportRawValue")
         session.setValue(chargingStateMode.rawValue, forKey: "chargingStateRawValue")
         session.setValue(autoStopEnabled, forKey: "autoStopEnabled")
@@ -995,7 +1059,6 @@ final class ChargeInsightsStore {
         session.setValue(now, forKey: "updatedAt")
 
         chargedDevice.setValue(snapshot.meterMACAddress, forKey: "lastAssociatedMeterMAC")
-        chargedDevice.setValue(chargingTransportMode.rawValue, forKey: "preferredChargingTransportRawValue")
         chargedDevice.setValue(now, forKey: "updatedAt")
         return session
     }
@@ -1043,11 +1106,9 @@ final class ChargeInsightsStore {
 
             if meterEnergyCounterWh + counterDecreaseTolerance >= baselineEnergy {
                 let offlineEnergy = meterEnergyCounterWh - baselineEnergy
-                if offlineEnergy > measuredEnergyWh {
-                    measuredEnergyWh = offlineEnergy
-                }
+                measuredEnergyWh = max(offlineEnergy, 0)
                 usedOfflineMeterCounters = true
-                sourceMode = sourceMode == .live && measuredEnergyWh > 0 ? .blended : .offline
+                sourceMode = .offline
             } else if let lastEnergy, meterEnergyCounterWh > lastEnergy {
                 let delta = meterEnergyCounterWh - lastEnergy
                 if delta > 0 {
@@ -1068,9 +1129,7 @@ final class ChargeInsightsStore {
 
             if meterChargeCounterAh + counterDecreaseTolerance >= baselineCharge {
                 let offlineCharge = meterChargeCounterAh - baselineCharge
-                if offlineCharge > measuredChargeAh {
-                    measuredChargeAh = offlineCharge
-                }
+                measuredChargeAh = max(offlineCharge, 0)
                 usedOfflineMeterCounters = true
             } else if let lastCharge, meterChargeCounterAh > lastCharge {
                 let delta = meterChargeCounterAh - lastCharge
@@ -1171,14 +1230,14 @@ final class ChargeInsightsStore {
     private func updateAggregatedSample(
         session: NSManagedObject,
         with snapshot: ChargingMonitorSnapshot
-    ) {
+    ) -> NSManagedObject? {
         guard
             let sessionID = stringValue(session, key: "id"),
             let chargedDeviceID = stringValue(session, key: "chargedDeviceID"),
             let startedAt = dateValue(session, key: "startedAt"),
             let entity = NSEntityDescription.entity(forEntityName: EntityName.chargeSessionSample, in: context)
         else {
-            return
+            return nil
         }
 
         let elapsed = max(snapshot.observedAt.timeIntervalSince(startedAt), 0)
@@ -1229,6 +1288,7 @@ final class ChargeInsightsStore {
         sample.setValue(Int16(updatedCount), forKey: "sampleCount")
         sample.setValue(dateValue(sample, key: "createdAt") ?? snapshot.observedAt, forKey: "createdAt")
         sample.setValue(snapshot.observedAt, forKey: "updatedAt")
+        return sample
     }
 
     private func maybeTriggerTargetBatteryAlert(for session: NSManagedObject, observedAt: Date) {
@@ -1398,11 +1458,21 @@ final class ChargeInsightsStore {
         struct Anchor {
             let percent: Double
             let energyWh: Double
+            let timestamp: Date
+            let isCheckpoint: Bool
         }
 
         var anchors: [Anchor] = []
-        if let startBatteryPercent = optionalDoubleValue(session, key: "startBatteryPercent") {
-            anchors.append(Anchor(percent: startBatteryPercent, energyWh: 0))
+        if let startBatteryPercent = optionalDoubleValue(session, key: "startBatteryPercent"),
+           startBatteryPercent >= 0 {
+            anchors.append(
+                Anchor(
+                    percent: startBatteryPercent,
+                    energyWh: 0,
+                    timestamp: dateValue(session, key: "startedAt") ?? Date.distantPast,
+                    isCheckpoint: false
+                )
+            )
         }
 
         let checkpointAnchors = fetchCheckpointObjects(forSessionID: sessionID)
@@ -1413,7 +1483,15 @@ final class ChargeInsightsStore {
                 }
                 return lhs.timestamp < rhs.timestamp
             }
-            .map { Anchor(percent: $0.batteryPercent, energyWh: $0.measuredEnergyWh) }
+            .filter { $0.batteryPercent >= 0 }
+            .map {
+                Anchor(
+                    percent: $0.batteryPercent,
+                    energyWh: $0.measuredEnergyWh,
+                    timestamp: $0.timestamp,
+                    isCheckpoint: true
+                )
+            }
         anchors.append(contentsOf: checkpointAnchors)
 
         guard !anchors.isEmpty else {
@@ -1421,12 +1499,14 @@ final class ChargeInsightsStore {
         }
 
         let anchor = anchors.filter { $0.energyWh <= measuredEnergyWh + 0.05 }.last ?? anchors.first!
-        return min(
-            100,
-            max(
-                0,
-                anchor.percent + (((measuredEnergyWh - anchor.energyWh) / estimatedCapacityWh) * 100)
-            )
+        return BatteryLevelPredictionTuning.predictedPercent(
+            anchorPercent: anchor.percent,
+            anchorEnergyWh: anchor.energyWh,
+            anchorTimestamp: anchor.timestamp,
+            anchorIsCheckpoint: anchor.isCheckpoint,
+            effectiveEnergyWh: measuredEnergyWh,
+            referenceTimestamp: dateValue(session, key: "lastObservedAt") ?? anchor.timestamp,
+            estimatedCapacityWh: estimatedCapacityWh
         )
     }
 
@@ -1481,6 +1561,11 @@ final class ChargeInsightsStore {
             return
         }
 
+        guard startBatteryPercent >= 0, endBatteryPercent >= 0 else {
+            session.setValue(nil, forKey: "capacityEstimateWh")
+            return
+        }
+
         let percentDelta = endBatteryPercent - startBatteryPercent
         let supportsChargingWhileOff = boolValue(chargedDevice, key: "supportsChargingWhileOff")
 
@@ -1531,16 +1616,38 @@ final class ChargeInsightsStore {
         checkpoint.setValue(normalizedOptionalText(label), forKey: "label")
         checkpoint.setValue(timestamp, forKey: "createdAt")
 
-        if session.value(forKey: "startBatteryPercent") == nil {
+        let existingStartBatteryPercent = optionalDoubleValue(session, key: "startBatteryPercent")
+        if existingStartBatteryPercent == nil || ((existingStartBatteryPercent ?? 0) < 0 && percent > 0) {
             session.setValue(percent, forKey: "startBatteryPercent")
         }
-        session.setValue(percent, forKey: "endBatteryPercent")
+        if (existingStartBatteryPercent ?? 0) >= 0 || percent > 0 {
+            session.setValue(percent, forKey: "endBatteryPercent")
+        }
         session.setValue(timestamp, forKey: "updatedAt")
         updateCapacityEstimate(for: session)
 
         return chargedDeviceID
     }
 
+    private func refreshCheckpointDerivedValues(for session: NSManagedObject) {
+        guard let sessionID = stringValue(session, key: "id") else {
+            return
+        }
+
+        let remainingCheckpoints = fetchCheckpointObjects(forSessionID: sessionID)
+        if let latestCheckpoint = remainingCheckpoints.last {
+            session.setValue(doubleValue(latestCheckpoint, key: "batteryPercent"), forKey: "endBatteryPercent")
+        } else if let startBatteryPercent = optionalDoubleValue(session, key: "startBatteryPercent"),
+                  startBatteryPercent >= 0 {
+            session.setValue(startBatteryPercent, forKey: "endBatteryPercent")
+        } else {
+            session.setValue(nil, forKey: "endBatteryPercent")
+        }
+
+        session.setValue(Date(), forKey: "updatedAt")
+        updateCapacityEstimate(for: session)
+    }
+
     @discardableResult
     private func addBatteryCheckpoint(
         percent: Double,
@@ -1603,7 +1710,7 @@ final class ChargeInsightsStore {
         }
 
         guard let wiredCapacityWh = optionalDoubleValue(chargedDevice, key: "wiredEstimatedBatteryCapacityWh")
-            ?? ((preferredChargingTransportMode(for: chargedDevice) == .wired)
+            ?? ((fallbackChargingTransportMode(for: chargedDevice) == .wired)
                 ? optionalDoubleValue(chargedDevice, key: "estimatedBatteryCapacityWh")
                 : nil),
               wiredCapacityWh > 0
@@ -1670,7 +1777,7 @@ final class ChargeInsightsStore {
         let chargerEfficiency = deviceClass == .charger ? derivedChargerEfficiency(from: sessions) : nil
         let chargerMaximumPower = deviceClass == .charger ? derivedMaximumPower(from: sessions) : nil
 
-        let preferredChargingTransportMode = preferredChargingTransportMode(for: chargedDevice)
+        let preferredChargingTransportMode = fallbackChargingTransportMode(for: chargedDevice)
         let preferredChargingStateMode = chargingStateAvailability.supportedModes.first ?? .on
         let preferredMinimumCurrent: Double?
         let preferredCapacity: Double?
@@ -1691,19 +1798,19 @@ final class ChargeInsightsStore {
             preferredCapacity = wirelessCapacity ?? wiredCapacity
         }
 
-        chargedDevice.setValue(wiredMinimumCurrent, forKey: "wiredMinimumCurrentAmps")
-        chargedDevice.setValue(wirelessMinimumCurrent, forKey: "wirelessMinimumCurrentAmps")
-        chargedDevice.setValue(encodedCompletionCurrents(learnedCompletionCurrents), forKey: "learnedCompletionCurrentsRawValue")
-        chargedDevice.setValue(wiredCapacity, forKey: "wiredEstimatedBatteryCapacityWh")
-        chargedDevice.setValue(wirelessCapacity, forKey: "wirelessEstimatedBatteryCapacityWh")
-        chargedDevice.setValue(wirelessEfficiency, forKey: "wirelessChargerEfficiencyFactor")
-        chargedDevice.setValue(encodedObservedVoltageSelections(chargerObservedVoltages), forKey: "chargerObservedVoltageSelectionsRawValue")
-        chargedDevice.setValue(chargerIdleCurrent, forKey: "chargerIdleCurrentAmps")
-        chargedDevice.setValue(chargerEfficiency, forKey: "chargerEfficiencyFactor")
-        chargedDevice.setValue(chargerMaximumPower, forKey: "chargerMaximumPowerWatts")
-        chargedDevice.setValue(preferredMinimumCurrent, forKey: "minimumCurrentAmps")
-        chargedDevice.setValue(preferredCapacity, forKey: "estimatedBatteryCapacityWh")
-        chargedDevice.setValue(Date(), forKey: "updatedAt")
+        setValue(wiredMinimumCurrent, on: chargedDevice, key: "wiredMinimumCurrentAmps")
+        setValue(wirelessMinimumCurrent, on: chargedDevice, key: "wirelessMinimumCurrentAmps")
+        setValue(encodedCompletionCurrents(learnedCompletionCurrents), on: chargedDevice, key: "learnedCompletionCurrentsRawValue")
+        setValue(wiredCapacity, on: chargedDevice, key: "wiredEstimatedBatteryCapacityWh")
+        setValue(wirelessCapacity, on: chargedDevice, key: "wirelessEstimatedBatteryCapacityWh")
+        setValue(wirelessEfficiency, on: chargedDevice, key: "wirelessChargerEfficiencyFactor")
+        setValue(encodedObservedVoltageSelections(chargerObservedVoltages), on: chargedDevice, key: "chargerObservedVoltageSelectionsRawValue")
+        setValue(chargerIdleCurrent, on: chargedDevice, key: "chargerIdleCurrentAmps")
+        setValue(chargerEfficiency, on: chargedDevice, key: "chargerEfficiencyFactor")
+        setValue(chargerMaximumPower, on: chargedDevice, key: "chargerMaximumPowerWatts")
+        setValue(preferredMinimumCurrent, on: chargedDevice, key: "minimumCurrentAmps")
+        setValue(preferredCapacity, on: chargedDevice, key: "estimatedBatteryCapacityWh")
+        setValue(Date(), on: chargedDevice, key: "updatedAt")
     }
 
     private func buildCapacityHistory(from sessions: [ChargeSessionSummary]) -> [CapacityTrendPoint] {
@@ -1836,6 +1943,8 @@ final class ChargeInsightsStore {
             measuredEnergyWh: doubleValue(object, key: "measuredEnergyWh"),
             effectiveBatteryEnergyWh: optionalDoubleValue(object, key: "effectiveBatteryEnergyWh"),
             measuredChargeAh: doubleValue(object, key: "measuredChargeAh"),
+            meterEnergyBaselineWh: optionalDoubleValue(object, key: "meterEnergyBaselineWh"),
+            meterChargeBaselineAh: optionalDoubleValue(object, key: "meterChargeBaselineAh"),
             minimumObservedCurrentAmps: optionalDoubleValue(object, key: "minimumObservedCurrentAmps"),
             maximumObservedCurrentAmps: optionalDoubleValue(object, key: "maximumObservedCurrentAmps"),
             maximumObservedPowerWatts: optionalDoubleValue(object, key: "maximumObservedPowerWatts"),
@@ -1963,6 +2072,13 @@ final class ChargeInsightsStore {
         return (try? context.fetch(request)) ?? []
     }
 
+    private func fetchCheckpointObject(id: String, sessionID: String) -> NSManagedObject? {
+        let request = NSFetchRequest<NSManagedObject>(entityName: EntityName.chargeCheckpoint)
+        request.predicate = NSPredicate(format: "id == %@ AND sessionID == %@", id, sessionID)
+        request.fetchLimit = 1
+        return (try? context.fetch(request))?.first
+    }
+
     private func fetchCheckpointObjects(forSessionID sessionID: String) -> [NSManagedObject] {
         let request = NSFetchRequest<NSManagedObject>(entityName: EntityName.chargeCheckpoint)
         request.predicate = NSPredicate(format: "sessionID == %@", sessionID)
@@ -2028,11 +2144,14 @@ final class ChargeInsightsStore {
         request.sortDescriptors = [NSSortDescriptor(key: "updatedAt", ascending: false)]
         let matches = (try? context.fetch(request)) ?? []
         return matches.first { object in
-            let isCharger = ChargedDeviceClass(rawValue: stringValue(object, key: "deviceClassRawValue") ?? "") == .charger
-            return isCharger == expectsChargerClass
+            isChargerObject(object) == expectsChargerClass
         }
     }
 
+    private func isChargerObject(_ object: NSManagedObject) -> Bool {
+        ChargedDeviceClass(rawValue: stringValue(object, key: "deviceClassRawValue") ?? "") == .charger
+    }
+
     private func fetchChargedDeviceObject(id: String) -> NSManagedObject? {
         let request = NSFetchRequest<NSManagedObject>(entityName: EntityName.chargedDevice)
         request.predicate = NSPredicate(format: "id == %@", id)
@@ -2090,12 +2209,11 @@ final class ChargeInsightsStore {
         return max(resolvedCurrent, 0.01)
     }
 
-    private func preferredChargingTransportMode(for chargedDevice: NSManagedObject) -> ChargingTransportMode {
+    private func fallbackChargingTransportMode(for chargedDevice: NSManagedObject) -> ChargingTransportMode {
         let supportsWiredCharging = supportsWiredCharging(for: chargedDevice)
         let supportsWirelessCharging = supportsWirelessCharging(for: chargedDevice)
-        let persistedMode = chargingTransportModeValue(chargedDevice, key: "preferredChargingTransportRawValue") ?? .wired
         return resolvedPreferredChargingTransportMode(
-            persistedMode,
+            .wired,
             supportsWiredCharging: supportsWiredCharging,
             supportsWirelessCharging: supportsWirelessCharging
         )
@@ -2425,7 +2543,7 @@ final class ChargeInsightsStore {
 
         if let chargedDeviceID = stringValue(session, key: "chargedDeviceID"),
            let chargedDevice = fetchChargedDeviceObject(id: chargedDeviceID) {
-            return preferredChargingTransportMode(for: chargedDevice)
+            return fallbackChargingTransportMode(for: chargedDevice)
         }
 
         return .wired
@@ -2477,6 +2595,22 @@ final class ChargeInsightsStore {
         return .none
     }
 
+    private func shouldPersistAggregatedSample(
+        _ sample: NSManagedObject,
+        observedAt: Date
+    ) -> Bool {
+        if sample.isInserted {
+            return true
+        }
+
+        let committedValues = sample.committedValues(forKeys: ["updatedAt"])
+        let lastPersistedAt = (committedValues["updatedAt"] as? Date)
+            ?? dateValue(sample, key: "createdAt")
+            ?? observedAt
+
+        return observedAt.timeIntervalSince(lastPersistedAt) >= aggregatedSampleSaveInterval
+    }
+
     private func generateQRIdentifier() -> String {
         "device:\(UUID().uuidString)"
     }
@@ -2508,59 +2642,73 @@ final class ChargeInsightsStore {
         normalizedText(macAddress).uppercased()
     }
 
+    private func rawValue(_ object: NSManagedObject, key: String) -> Any? {
+        guard object.entity.propertiesByName[key] != nil else {
+            return nil
+        }
+        return object.value(forKey: key)
+    }
+
+    private func setValue(_ value: Any?, on object: NSManagedObject, key: String) {
+        guard object.entity.propertiesByName[key] != nil else {
+            return
+        }
+        object.setValue(value, forKey: key)
+    }
+
     private func stringValue(_ object: NSManagedObject, key: String) -> String? {
-        guard let value = object.value(forKey: key) as? String else { return nil }
+        guard let value = rawValue(object, key: key) as? String else { return nil }
         let normalized = normalizedOptionalText(value)
         return normalized
     }
 
     private func dateValue(_ object: NSManagedObject, key: String) -> Date? {
-        object.value(forKey: key) as? Date
+        rawValue(object, key: key) as? Date
     }
 
     private func doubleValue(_ object: NSManagedObject, key: String) -> Double {
-        if let value = object.value(forKey: key) as? Double {
+        if let value = rawValue(object, key: key) as? Double {
             return value
         }
-        if let value = object.value(forKey: key) as? NSNumber {
+        if let value = rawValue(object, key: key) as? NSNumber {
             return value.doubleValue
         }
         return 0
     }
 
     private func optionalDoubleValue(_ object: NSManagedObject, key: String) -> Double? {
-        let rawValue = object.value(forKey: key)
-        if rawValue == nil {
+        let value = rawValue(object, key: key)
+        if value == nil {
             return nil
         }
         return doubleValue(object, key: key)
     }
 
     private func optionalInt16Value(_ object: NSManagedObject, key: String) -> Int16? {
-        if let value = object.value(forKey: key) as? Int16 {
+        if let value = rawValue(object, key: key) as? Int16 {
             return value
         }
-        if let value = object.value(forKey: key) as? NSNumber {
+        if let value = rawValue(object, key: key) as? NSNumber {
             return value.int16Value
         }
         return nil
     }
 
     private func optionalInt32Value(_ object: NSManagedObject, key: String) -> Int32? {
-        if let value = object.value(forKey: key) as? Int32 {
+        if let value = rawValue(object, key: key) as? Int32 {
             return value
         }
-        if let value = object.value(forKey: key) as? NSNumber {
+        if let value = rawValue(object, key: key) as? NSNumber {
             return value.int32Value
         }
         return nil
     }
 
     private func boolValue(_ object: NSManagedObject, key: String) -> Bool {
-        if let value = object.value(forKey: key) as? Bool {
+        if let value = rawValue(object, key: key) as? Bool {
             return value
         }
-        if let value = object.value(forKey: key) as? NSNumber {
+        if let value = rawValue(object, key: key) as? NSNumber {
             return value.boolValue
         }
         return false


+3 -0

USB Meter/Model/Measurements.swift

View

@@ -405,6 +405,9 @@ class Measurements : ObservableObject {
             let delta = value - lastEnergyCounterValue
             if delta > energyResetEpsilon {
                 accumulatedEnergyValue += delta
+            } else if delta < -energyResetEpsilon {
+                energy.addDiscontinuity(timestamp: timestamp)
+                accumulatedEnergyValue = 0
             }
         }
 


+16 -6

USB Meter/Model/Meter.swift

View

@@ -620,7 +620,11 @@ class Meter : NSObject, ObservableObject, Identifiable {
     }
 
     func chargingMonitorSnapshot(at observedAt: Date) -> ChargingMonitorSnapshot? {
-        ChargingMonitorSnapshot(
+        let usesNativeRecordingCounters = supportsRecordingView
+        let nativeChargeCounter = usesNativeRecordingCounters ? recordedAH : nil
+        let nativeEnergyCounter = usesNativeRecordingCounters ? recordedWH : nil
+
+        return ChargingMonitorSnapshot(
             meterMACAddress: btSerial.macAddress.description,
             meterName: name,
             meterModel: deviceModelSummary,
@@ -628,10 +632,10 @@ class Meter : NSObject, ObservableObject, Identifiable {
             voltageVolts: voltage,
             currentAmps: current,
             powerWatts: power,
-            selectedDataGroup: currentEnergySample()?.groupID ?? currentChargeSample()?.groupID,
-            meterChargeCounterAh: currentChargeSample()?.value,
-            meterEnergyCounterWh: currentEnergySample()?.value,
-            fallbackStopThresholdAmps: chargeRecordStopThreshold
+            selectedDataGroup: usesNativeRecordingCounters ? nil : (currentEnergySample()?.groupID ?? currentChargeSample()?.groupID),
+            meterChargeCounterAh: nativeChargeCounter ?? currentChargeSample()?.value,
+            meterEnergyCounterWh: nativeEnergyCounter ?? currentEnergySample()?.value,
+            fallbackStopThresholdAmps: supportsRecordingThreshold ? recordingTreshold : chargeRecordStopThreshold
         )
     }
 
@@ -788,7 +792,13 @@ class Meter : NSObject, ObservableObject, Identifiable {
             }
         }
         updateChargeRecord(at: dataDumpRequestTimestamp)
-        if let energySample = currentEnergySample() {
+        if supportsRecordingView {
+            measurements.captureEnergyValue(
+                timestamp: dataDumpRequestTimestamp,
+                value: recordedWH,
+                groupID: .max
+            )
+        } else if let energySample = currentEnergySample() {
             measurements.captureEnergyValue(
                 timestamp: dataDumpRequestTimestamp,
                 value: energySample.value,


+56 -17

USB Meter/Views/ChargedDevices/BatteryCheckpointEditorSheetView.swift

View

+                         @State private var batteryPercent = ""
+                         @State private var label = ""
+                    +    @State private var confirmationWarning: BatteryCheckpointPlausibilityWarning?
+                    +    private var activeSession: ChargeSessionSummary? {
+                    +        appData.activeChargeSessionSummary(for: meter.btSerial.macAddress.description)
+                    +    }
+                    +    private var plausibilityWarning: BatteryCheckpointPlausibilityWarning? {
+                    +        guard let percent = Double(batteryPercent),
+                    +              let activeSession else {
+                    +            return nil
+                    +        }
+                    +        return appData.batteryCheckpointPlausibilityWarning(percent: percent, for: activeSession.id)
+                    +    }
+                         var body: some View {
+                             NavigationView {
+                                 Form {
+                    -                Section(header: Text("Checkpoint")) {
+                    +                Section(
+                    +                    header: ContextInfoHeader(
+                    +                        title: "Checkpoint",
+                    +                        message: "The checkpoint is stored on the active charge session and later used for capacity estimation and the typical charge curve."
+                    +                    )
+                    +                ) {
+                                         TextField("Battery %", text: $batteryPercent)
+                                             .keyboardType(.decimalPad)
+                                         TextField("Label (optional)", text: $label)
+                    -                Section {
+                    -                    Text("The checkpoint is stored on the active charge session and later used for capacity estimation and the typical charge curve.")
+                    -                        .font(.footnote)
+                    -                        .foregroundColor(.secondary)
+                    +                if let plausibilityWarning {
+                    +                    Section(header: Text(plausibilityWarning.title)) {
+                    +                        Text(plausibilityWarning.message)
+                    +                            .font(.footnote)
+                    +                            .foregroundColor(.orange)
+                    +                    }
+                                 .navigationTitle("Battery Checkpoint")
+                                     ToolbarItem(placement: .confirmationAction) {
+                                         Button("Save") {
+                    -                        guard let percent = Double(batteryPercent) else {
+                    -                            return
+                    -                        }
+                    -                        let didSave = appData.addBatteryCheckpoint(
+                    -                            percent: percent,
+                    -                            label: label,
+                    -                            for: meter
+                    -                        )
+                    -                        if didSave {
+                    -                            dismiss()
+                    -                        }
+                    +                        saveCheckpoint()
+                                         .disabled(
+                                             (Double(batteryPercent) ?? -1) < 0
+                             .navigationViewStyle(StackNavigationViewStyle())
+                    +        .alert(item: $confirmationWarning) { warning in
+                    +            Alert(
+                    +                title: Text(warning.title),
+                    +                message: Text(warning.message),
+                    +                primaryButton: .destructive(Text("Save Anyway")) {
+                    +                    saveCheckpoint(forceOverride: true)
+                    +                },
+                    +                secondaryButton: .cancel()
+                    +            )
+                    +        }
+                    +    }
+                    +    private func saveCheckpoint(forceOverride: Bool = false) {
+                    +        guard let percent = Double(batteryPercent) else {
+                    +            return
+                    +        }
+                    +        if !forceOverride, let plausibilityWarning {
+                    +            confirmationWarning = plausibilityWarning
+                    +            return
+                    +        }
+                    +        let didSave = appData.addBatteryCheckpoint(
+                    +            percent: percent,
+                    +            label: label,
+                    +            for: meter
+                    +        )
+                    +        if didSave {
+                    +            dismiss()
+                    +        }

+165 -119

USB Meter/Views/ChargedDevices/ChargedDeviceDetailView.swift

View

+                                 if let chargedDevice = appData.chargedDeviceSummary(id: chargedDeviceID) {
+                                     ChargedDeviceEditorSheetView(
+                                         meterMACAddress: nil,
+                    +                    kind: chargedDevice.kind,
+                                         chargedDevice: chargedDevice
+                                     .environmentObject(appData)
+                                 ChargedDeviceQRCodeView(qrIdentifier: chargedDevice.qrIdentifier, side: 118)
+                                 VStack(alignment: .leading, spacing: 10) {
+                    -                Label(chargedDevice.name, systemImage: chargedDevice.deviceClass.symbolName)
+                    +                Label(chargedDevice.name, systemImage: chargedDevice.identitySymbolName)
+                                         .font(.title3.weight(.bold))
+                    -                Text(chargedDevice.deviceClass.title)
+                    +                Text(chargedDevice.identityTitle)
+                                         .font(.subheadline.weight(.semibold))
+                                         .foregroundColor(.secondary)
+                         private func insightsCard(_ chargedDevice: ChargedDeviceSummary) -> some View {
+                             MeterInfoCardView(title: "Insights", tint: tint(for: chargedDevice)) {
+                    +            if chargedDevice.isCharger {
+                    +                chargerInsights(chargedDevice)
+                    +            } else {
+                    +                deviceInsights(chargedDevice)
+                    +            }
+                    +            if let notes = chargedDevice.notes, !notes.isEmpty {
+                    +                Divider()
+                    +                Text(notes)
+                    +                    .font(.footnote)
+                    +                    .foregroundColor(.secondary)
+                    +                    .frame(maxWidth: .infinity, alignment: .leading)
+                    +            }
+                    +        }
+                    +    }
+                    +    @ViewBuilder
+                    +    private func deviceInsights(_ chargedDevice: ChargedDeviceSummary) -> some View {
+                    +        MeterInfoRowView(
+                    +            label: "Charge Modes",
+                    +            value: chargedDevice.chargingStateAvailability.title
+                    +        )
+                    +        MeterInfoRowView(
+                    +            label: "Charging Support",
+                    +            value: chargedDevice.supportedChargingModes.map(\.title).joined(separator: " + ")
+                    +        )
+                    +        if chargedDevice.supportsWirelessCharging {
+                                 MeterInfoRowView(
+                    -                label: "Charge Modes",
+                    -                value: chargedDevice.chargingStateAvailability.title
+                    +                label: "Wireless Profile",
+                    +                value: chargedDevice.wirelessChargingProfile.title
+                    +        }
+                    +        ForEach(completionSessionKinds(for: chargedDevice), id: \.rawValue) { sessionKind in
+                                 MeterInfoRowView(
+                    -                label: "Charging Support",
+                    -                value: chargedDevice.supportedChargingModes.map(\.title).joined(separator: " + ")
+                    +                label: "\(sessionKind.shortTitle) Stop Current",
+                    +                value: completionCurrentDescription(for: chargedDevice, sessionKind: sessionKind)
+                    +        }
+                    +        MeterInfoRowView(
+                    +            label: "Estimated Capacity",
+                    +            value: chargedDevice.estimatedBatteryCapacityWh.map { "\($0.format(decimalDigits: 2)) Wh" } ?? "Not enough data"
+                    +        )
+                    +        if let wiredCapacity = chargedDevice.wiredEstimatedBatteryCapacityWh {
+                                 MeterInfoRowView(
+                    -                label: "Preferred Session Type",
+                    -                value: chargedDevice.preferredChargingTransportMode.title
+                    +                label: "Wired Capacity",
+                    +                value: "\(wiredCapacity.format(decimalDigits: 2)) Wh"
+                    -            if chargedDevice.supportsWirelessCharging {
+                    -                MeterInfoRowView(
+                    -                    label: "Wireless Profile",
+                    -                    value: chargedDevice.wirelessChargingProfile.title
+                    -                )
+                    -            }
+                    +        }
+                    +        if let wirelessCapacity = chargedDevice.wirelessEstimatedBatteryCapacityWh {
+                    +            MeterInfoRowView(
+                    +                label: "Wireless Capacity",
+                    +                value: "\(wirelessCapacity.format(decimalDigits: 2)) Wh"
+                    +            )
+                    +        }
+                    +        if let wirelessEfficiencyFactor = chargedDevice.wirelessChargerEfficiencyFactor {
+                    +            MeterInfoRowView(
+                    +                label: "Wireless Efficiency",
+                    +                value: "\(Int((wirelessEfficiencyFactor * 100).rounded()))%"
+                    +            )
+                    +        }
+                    +        MeterInfoRowView(
+                    +            label: "End-of-Charge Current",
+                    +            value: chargedDevice.minimumCurrentAmps.map { "\($0.format(decimalDigits: 2)) A" } ?? "Learning"
+                    +        )
+                    +        MeterInfoRowView(
+                    +            label: "Charge Sessions",
+                    +            value: "\(chargedDevice.sessionCount)"
+                    +        )
+                    +    }
+                    -            ForEach(completionSessionKinds(for: chargedDevice), id: \.rawValue) { sessionKind in
+                    -                MeterInfoRowView(
+                    -                    label: "\(sessionKind.shortTitle) Stop Current",
+                    -                    value: completionCurrentDescription(for: chargedDevice, sessionKind: sessionKind)
+                    -                )
+                    -            }
+                    +    @ViewBuilder
+                    +    private func chargerInsights(_ chargedDevice: ChargedDeviceSummary) -> some View {
+                    +        if !chargedDevice.chargerObservedVoltageSelections.isEmpty {
+                                 MeterInfoRowView(
+                    -                label: "Estimated Capacity",
+                    -                value: chargedDevice.estimatedBatteryCapacityWh.map { "\($0.format(decimalDigits: 2)) Wh" } ?? "Not enough data"
+                    +                label: "Observed Voltages",
+                    +                value: chargedDevice.chargerObservedVoltageSelections
+                    +                    .map { "\($0.format(decimalDigits: 1)) V" }
+                    +                    .joined(separator: ", ")
+                    -            if let wiredCapacity = chargedDevice.wiredEstimatedBatteryCapacityWh {
+                    -                MeterInfoRowView(
+                    -                    label: "Wired Capacity",
+                    -                    value: "\(wiredCapacity.format(decimalDigits: 2)) Wh"
+                    -                )
+                    -            }
+                    -            if let wirelessCapacity = chargedDevice.wirelessEstimatedBatteryCapacityWh {
+                    -                MeterInfoRowView(
+                    -                    label: "Wireless Capacity",
+                    -                    value: "\(wirelessCapacity.format(decimalDigits: 2)) Wh"
+                    -                )
+                    -            }
+                    -            if let wirelessEfficiencyFactor = chargedDevice.wirelessChargerEfficiencyFactor {
+                    -                MeterInfoRowView(
+                    -                    label: "Wireless Efficiency",
+                    -                    value: "\(Int((wirelessEfficiencyFactor * 100).rounded()))%"
+                    -                )
+                    -            }
+                    -            if chargedDevice.isCharger {
+                    -                Divider()
+                    -                if !chargedDevice.chargerObservedVoltageSelections.isEmpty {
+                    -                    MeterInfoRowView(
+                    -                        label: "Observed Voltages",
+                    -                        value: chargedDevice.chargerObservedVoltageSelections
+                    -                            .map { "\($0.format(decimalDigits: 1)) V" }
+                    -                            .joined(separator: ", ")
+                    -                    )
+                    -                }
+                    -                if let chargerIdleCurrentAmps = chargedDevice.chargerIdleCurrentAmps {
+                    -                    MeterInfoRowView(
+                    -                        label: "Idle Current",
+                    -                        value: "\(chargerIdleCurrentAmps.format(decimalDigits: 2)) A"
+                    -                    )
+                    -                }
+                    -                if let chargerEfficiencyFactor = chargedDevice.chargerEfficiencyFactor {
+                    -                    MeterInfoRowView(
+                    -                        label: "Efficiency",
+                    -                        value: "\(Int((chargerEfficiencyFactor * 100).rounded()))%"
+                    -                    )
+                    -                }
+                    -                if let chargerMaximumPowerWatts = chargedDevice.chargerMaximumPowerWatts {
+                    -                    MeterInfoRowView(
+                    -                        label: "Max Power",
+                    -                        value: "\(chargerMaximumPowerWatts.format(decimalDigits: 2)) W"
+                    -                    )
+                    -                }
+                    -                if chargedDevice.chargerIdleCurrentAmps == nil {
+                    -                    Text("Idle current is missing. Wireless sessions that use this charger can still be recorded, but they cannot learn or auto-apply the wireless stop threshold yet.")
+                    -                        .font(.caption2)
+                    -                        .foregroundColor(.orange)
+                    -                }
+                    -            }
+                    +        }
+                    +        if let chargerIdleCurrentAmps = chargedDevice.chargerIdleCurrentAmps {
+                                 MeterInfoRowView(
+                    -                label: "End-of-Charge Current",
+                    -                value: chargedDevice.minimumCurrentAmps.map { "\($0.format(decimalDigits: 2)) A" } ?? "Learning"
+                    +                label: "Idle Current",
+                    +                value: "\(chargerIdleCurrentAmps.format(decimalDigits: 2)) A"
+                    +        }
+                    +        if let chargerEfficiencyFactor = chargedDevice.chargerEfficiencyFactor {
+                                 MeterInfoRowView(
+                    -                label: "Charge Sessions",
+                    -                value: "\(chargedDevice.sessionCount)"
+                    +                label: "Efficiency",
+                    +                value: "\(Int((chargerEfficiencyFactor * 100).rounded()))%"
+                    +        }
+                    +        if let chargerMaximumPowerWatts = chargedDevice.chargerMaximumPowerWatts {
+                    +            MeterInfoRowView(
+                    +                label: "Max Power",
+                    +                value: "\(chargerMaximumPowerWatts.format(decimalDigits: 2)) W"
+                    +            )
+                    +        }
+                    +        MeterInfoRowView(
+                    +            label: "Wireless Sessions",
+                    +            value: "\(chargedDevice.sessionCount)"
+                    +        )
+                    -            if let notes = chargedDevice.notes, !notes.isEmpty {
+                    -                Divider()
+                    -                Text(notes)
+                    -                    .font(.footnote)
+                    -                    .foregroundColor(.secondary)
+                    -                    .frame(maxWidth: .infinity, alignment: .leading)
+                    -            }
+                    +        if chargedDevice.chargerIdleCurrentAmps == nil {
+                    +            Text("Idle current is missing. Wireless sessions that use this charger can still be recorded, but they cannot learn or auto-apply the wireless stop threshold yet.")
+                    +                .font(.caption2)
+                    +                .foregroundColor(.orange)
+                                    abs(effectiveBatteryEnergyWh - activeSession.measuredEnergyWh) > 0.01 {
+                                     MeterInfoRowView(label: "Charger Energy", value: "\(activeSession.measuredEnergyWh.format(decimalDigits: 3)) Wh")
+                    -            MeterInfoRowView(label: "Charge", value: "\(activeSession.measuredChargeAh.format(decimalDigits: 3)) Ah")
+                                 MeterInfoRowView(label: "Auto Stop", value: autoStopDescription(for: activeSession))
+                                 MeterInfoRowView(label: "Source", value: activeSession.sourceMode.title)
+                                 if chargedDevice.isCharger == false,
+                             return VStack(alignment: .leading, spacing: 14) {
+                                 HStack(alignment: .firstTextBaseline) {
+                                     VStack(alignment: .leading, spacing: 4) {
+                    -                    Text("Stored Session Curve")
+                    -                        .font(.headline)
+                    +                    HStack(spacing: 8) {
+                    +                        Text("Stored Session Curve")
+                    +                            .font(.headline)
+                    +                        ContextInfoButton(
+                    +                            title: "Stored Session Curve",
+                    +                            message: "Database storage and iCloud sync use 300 aggregated points per hour. Active sessions persist their partial aggregated curve continuously, so a reconnect or restart can restore the stored progress."
+                    +                        )
+                    +                    }
+                                         Text(session.status.isOpen ? "Open session, persisted as aggregated samples." : "Most recent persisted session at aggregated resolution.")
+                                             .font(.caption)
+                                             .foregroundColor(.secondary)
+                    -            Text("Database storage and iCloud sync use 300 aggregated points per hour. The live recording session still keeps the original in-memory samples while charging is in progress.")
+                    -                .font(.caption)
+                    -                .foregroundColor(.secondary)
+                             .frame(maxWidth: .infinity, alignment: .leading)
+                             .padding(18)
+                         private func sessionsCard(_ chargedDevice: ChargedDeviceSummary) -> some View {
+                             VStack(alignment: .leading, spacing: 12) {
+                    -            Text("Charge Sessions")
+                    -                .font(.headline)
+                    -            Text("Use these summaries to spot odd sessions quickly before they influence device estimates.")
+                    -                .font(.caption)
+                    -                .foregroundColor(.secondary)
+                    +            HStack(spacing: 8) {
+                    +                Text("Charge Sessions")
+                    +                    .font(.headline)
+                    +                ContextInfoButton(
+                    +                    title: "Charge Sessions",
+                    +                    message: "Use these summaries to spot odd sessions quickly before they influence device estimates."
+                    +                )
+                    +            }
+                                 ForEach(chargedDevice.sessions, id: \.id) { session in
+                                     VStack(alignment: .leading, spacing: 6) {
+                                                 value: "\(selectedSourceVoltageVolts.format(decimalDigits: 2)) V"
+                    -                    if let selectedDataGroup = session.selectedDataGroup {
+                    -                        MeterInfoRowView(
+                    -                            label: "Data Group",
+                    -                            value: "#\(selectedDataGroup)"
+                    -                        )
+                    -                    }
+                                         if chargedDevice.isCharger == false,
+                                            let chargerID = session.chargerID,
+                                            let charger = appData.chargedDeviceSummary(id: chargerID) {
+                         @State private var batteryPercent = ""
+                         @State private var label = ""
+                    +    @State private var confirmationWarning: BatteryCheckpointPlausibilityWarning?
+                    +    private var plausibilityWarning: BatteryCheckpointPlausibilityWarning? {
+                    +        guard let percent = Double(batteryPercent) else {
+                    +            return nil
+                    +        }
+                    +        return appData.batteryCheckpointPlausibilityWarning(percent: percent, for: sessionID)
+                    +    }
+                         var body: some View {
+                             NavigationView {
+                                 Form {
+                    -                Section(header: Text("Checkpoint")) {
+                    +                Section(
+                    +                    header: ContextInfoHeader(
+                    +                        title: "Checkpoint",
+                    +                        message: "The checkpoint is stored on the active charge session and is used for capacity estimation and charge-level prediction."
+                    +                    )
+                    +                ) {
+                                         TextField("Battery %", text: $batteryPercent)
+                                             .keyboardType(.decimalPad)
+                                         TextField("Label (optional)", text: $label)
+                    -                Section {
+                    -                    Text("The checkpoint is stored on the active charge session and is used for capacity estimation and charge-level prediction.")
+                    -                        .font(.footnote)
+                    -                        .foregroundColor(.secondary)
+                    +                if let plausibilityWarning {
+                    +                    Section(header: Text(plausibilityWarning.title)) {
+                    +                        Text(plausibilityWarning.message)
+                    +                            .font(.footnote)
+                    +                            .foregroundColor(.orange)
+                    +                    }
+                                 .navigationTitle("Battery Checkpoint")
+                                     ToolbarItem(placement: .confirmationAction) {
+                                         Button("Save") {
+                    -                        guard let percent = Double(batteryPercent) else {
+                    -                            return
+                    -                        }
+                    -                        if appData.addBatteryCheckpoint(percent: percent, label: label, for: sessionID) {
+                    -                            dismiss()
+                    -                        }
+                    +                        saveCheckpoint()
+                                         .disabled(
+                                             (Double(batteryPercent) ?? -1) < 0
+                             .navigationViewStyle(StackNavigationViewStyle())
+                    +        .alert(item: $confirmationWarning) { warning in
+                    +            Alert(
+                    +                title: Text(warning.title),
+                    +                message: Text(warning.message),
+                    +                primaryButton: .destructive(Text("Save Anyway")) {
+                    +                    saveCheckpoint(forceOverride: true)
+                    +                },
+                    +                secondaryButton: .cancel()
+                    +            )
+                    +        }
+                    +    }
+                    +    private func saveCheckpoint(forceOverride: Bool = false) {
+                    +        guard let percent = Double(batteryPercent) else {
+                    +            return
+                    +        }
+                    +        if !forceOverride, let plausibilityWarning {
+                    +            confirmationWarning = plausibilityWarning
+                    +            return
+                    +        }
+                    +        if appData.addBatteryCheckpoint(percent: percent, label: label, for: sessionID) {
+                    +            dismiss()
+                    +        }
+                         var body: some View {
+                             NavigationView {
+                                 Form {
+                    -                Section(header: Text("Target Level")) {
+                    +                Section(
+                    +                    header: ContextInfoHeader(
+                    +                        title: "Target Level",
+                    +                        message: "A local notification will be generated on synced devices when the estimated battery level reaches this target."
+                    +                    )
+                    +                ) {
+                                         VStack(alignment: .leading, spacing: 12) {
+                                             Text("\(targetPercent.format(decimalDigits: 0))%")
+                                                 .font(.title3.weight(.bold))
+                                             Slider(value: $targetPercent, in: 20...100, step: 1)
+                    -                        Text("A local notification will be generated on synced devices when the estimated battery level reaches this target.")
+                    -                            .font(.footnote)
+                    -                            .foregroundColor(.secondary)

+200 -161

USB Meter/Views/ChargedDevices/ChargedDeviceEditorSheetView.swift

View

+                         let meterMACAddress: String?
+                         let chargedDevice: ChargedDeviceSummary?
+                    -    let suggestedDeviceClass: ChargedDeviceClass?
+                    +    let kind: ChargedDeviceKind
+                         @State private var name: String
+                         @State private var deviceClass: ChargedDeviceClass
+                         @State private var chargingStateAvailability: ChargingStateAvailability
+                         @State private var supportsWiredCharging: Bool
+                         @State private var supportsWirelessCharging: Bool
+                    -    @State private var preferredChargingTransportMode: ChargingTransportMode
+                         @State private var wirelessChargingProfile: WirelessChargingProfile
+                         @State private var completionCurrentTexts: [ChargeSessionKind: String]
+                         @State private var notes: String
+                         init(
+                             meterMACAddress: String?,
+                    -        chargedDevice: ChargedDeviceSummary? = nil,
+                    -        suggestedDeviceClass: ChargedDeviceClass? = nil
+                    +        kind: ChargedDeviceKind,
+                    +        chargedDevice: ChargedDeviceSummary? = nil
+                         ) {
+                             self.meterMACAddress = meterMACAddress
+                             self.chargedDevice = chargedDevice
+                    -        self.suggestedDeviceClass = suggestedDeviceClass
+                    -        let initialDeviceClass = chargedDevice?.deviceClass ?? suggestedDeviceClass ?? .iphone
+                    +        let resolvedKind = chargedDevice?.kind ?? kind
+                    +        self.kind = resolvedKind
+                    +        let initialDeviceClass = chargedDevice?.deviceClass ?? (resolvedKind == .charger ? .charger : .iphone)
+                             _name = State(initialValue: chargedDevice?.name ?? "")
+                             _deviceClass = State(initialValue: initialDeviceClass)
+                    -        _chargingStateAvailability = State(initialValue: chargedDevice?.chargingStateAvailability ?? Self.suggestedChargingStateAvailability(for: initialDeviceClass))
+                    +        _chargingStateAvailability = State(
+                    +            initialValue: chargedDevice?.chargingStateAvailability ?? Self.suggestedChargingStateAvailability(for: initialDeviceClass)
+                    +        )
+                             _supportsWiredCharging = State(initialValue: chargedDevice?.supportsWiredCharging ?? true)
+                             _supportsWirelessCharging = State(initialValue: chargedDevice?.supportsWirelessCharging ?? true)
+                    -        _preferredChargingTransportMode = State(initialValue: chargedDevice?.preferredChargingTransportMode ?? .wired)
+                             _wirelessChargingProfile = State(initialValue: chargedDevice?.wirelessChargingProfile ?? .genericQi)
+                    -        _completionCurrentTexts = State(
+                    -            initialValue: Self.makeCompletionCurrentTexts(for: chargedDevice)
+                    -        )
+                    +        _completionCurrentTexts = State(initialValue: Self.makeCompletionCurrentTexts(for: chargedDevice))
+                             _notes = State(initialValue: chargedDevice?.notes ?? "")
+                         var body: some View {
+                             NavigationView {
+                                 Form {
+                    -                Section(header: Text("Identity")) {
+                    -                    TextField("Name", text: $name)
+                    -                    Picker("Class", selection: $deviceClass) {
+                    -                        ForEach(ChargedDeviceClass.allCases) { deviceClass in
+                    -                            Label(deviceClass.title, systemImage: deviceClass.symbolName)
+                    -                                .tag(deviceClass)
+                    -                        }
+                    -                    }
+                    -                    if let chargedDevice {
+                    -                        Text(chargedDevice.qrIdentifier)
+                    -                            .font(.caption.monospaced())
+                    -                            .foregroundColor(.secondary)
+                    -                            .textSelection(.enabled)
+                    -                    }
+                    -                }
+                    -                Section(header: Text("Charge Behaviour")) {
+                    -                    Picker("Session Modes", selection: $chargingStateAvailability) {
+                    -                        ForEach(ChargingStateAvailability.allCases) { availability in
+                    -                            Text(availability.title)
+                    -                                .tag(availability)
+                    -                        }
+                    -                    }
+                    -                    Text(chargingStateAvailability.description)
+                    -                        .font(.footnote)
+                    -                        .foregroundColor(.secondary)
+                    -                }
+                    -                Section(header: Text("Charging Support")) {
+                    -                    Toggle("Supports wired charging", isOn: $supportsWiredCharging)
+                    -                    Toggle("Supports wireless charging", isOn: $supportsWirelessCharging)
+                    -                    if supportsWirelessCharging {
+                    -                        Picker("Wireless profile", selection: $wirelessChargingProfile) {
+                    -                            ForEach(WirelessChargingProfile.allCases) { profile in
+                    -                                Text(profile.title)
+                    -                                    .tag(profile)
+                    -                            }
+                    -                        }
+                    -                        Text(wirelessChargingProfile.description)
+                    -                            .font(.footnote)
+                    -                            .foregroundColor(.secondary)
+                    -                    }
+                    -                    if !supportedChargingModes.isEmpty {
+                    -                        Picker("Default session type", selection: preferredChargingTransportBinding) {
+                    -                            ForEach(supportedChargingModes) { chargingTransportMode in
+                    -                                Label(chargingTransportMode.title, systemImage: chargingTransportMode.symbolName)
+                    -                                    .tag(chargingTransportMode)
+                    -                            }
+                    -                        }
+                    -                    } else {
+                    -                        Text("Enable at least one charging method.")
+                    -                            .font(.footnote)
+                    -                            .foregroundColor(.secondary)
+                    -                    }
+                    +                identitySection
+                    +                if kind == .device {
+                    +                    deviceChargeBehaviourSection
+                    +                    deviceChargingSupportSection
+                    +                    deviceCompletionSection
+                    +                } else {
+                    +                    chargerInformationSection
+                    -                Section(header: Text("Charge Completion")) {
+                    -                    if applicableSessionKinds.isEmpty {
+                    -                        Text("Enable at least one charging method to configure stop currents.")
+                    -                            .font(.footnote)
+                    -                            .foregroundColor(.secondary)
+                    -                    } else {
+                    -                        ForEach(applicableSessionKinds) { sessionKind in
+                    -                            VStack(alignment: .leading, spacing: 6) {
+                    -                                TextField(
+                    -                                    "\(sessionKind.shortTitle) completion current (A)",
+                    -                                    text: completionCurrentTextBinding(for: sessionKind)
+                    -                                )
+                    -                                .keyboardType(.decimalPad)
+                    -                                Text("Leave empty to keep learning this threshold from sessions of the same type.")
+                    -                                    .font(.caption)
+                    -                                    .foregroundColor(.secondary)
+                    -                            }
+                    -                            .padding(.vertical, 2)
+                    -                        }
+                    -                    }
+                    -                }
+                    -                Section(header: Text("Notes")) {
+                    -                    TextField("Optional notes", text: $notes)
+                    -                }
+                    +                notesSection
+                                 .navigationTitle(editorTitle)
+                                 .navigationBarTitleDisplayMode(.inline)
+                                     ToolbarItem(placement: .confirmationAction) {
+                                         Button(saveButtonTitle) {
+                    -                        let configuredCompletionCurrents = parsedCompletionCurrents
+                    -                        let didSave: Bool
+                    -                        if let chargedDevice {
+                    -                            didSave = appData.updateChargedDevice(
+                    -                                id: chargedDevice.id,
+                    -                                name: name,
+                    -                                deviceClass: deviceClass,
+                    -                                chargingStateAvailability: chargingStateAvailability,
+                    -                                supportsWiredCharging: supportsWiredCharging,
+                    -                                supportsWirelessCharging: supportsWirelessCharging,
+                    -                                preferredChargingTransportMode: resolvedPreferredChargingTransportMode,
+                    -                                wirelessChargingProfile: wirelessChargingProfile,
+                    -                                configuredCompletionCurrents: configuredCompletionCurrents,
+                    -                                notes: notes
+                    -                            )
+                    -                        } else {
+                    -                            didSave = appData.createChargedDevice(
+                    -                                name: name,
+                    -                                deviceClass: deviceClass,
+                    -                                chargingStateAvailability: chargingStateAvailability,
+                    -                                supportsWiredCharging: supportsWiredCharging,
+                    -                                supportsWirelessCharging: supportsWirelessCharging,
+                    -                                preferredChargingTransportMode: resolvedPreferredChargingTransportMode,
+                    -                                wirelessChargingProfile: wirelessChargingProfile,
+                    -                                configuredCompletionCurrents: configuredCompletionCurrents,
+                    -                                notes: notes,
+                    -                                meterMACAddress: meterMACAddress
+                    -                            )
+                    -                        }
+                    -                        if didSave {
+                    -                            dismiss()
+                    -                        }
+                    +                        save()
+                    -                    .disabled(
+                    -                        name.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+                    -                            || (!supportsWiredCharging && !supportsWirelessCharging)
+                    -                            || hasInvalidCompletionCurrentEntry
+                    -                    )
+                    +                    .disabled(!canSave)
+                             .navigationViewStyle(StackNavigationViewStyle())
+                             .onChange(of: deviceClass) { newValue in
+                    +            guard kind == .device else {
+                    +                return
+                    +            }
+                                 applySuggestedChargingSupport(for: newValue)
+                             .onAppear {
+                    -            guard chargedDevice == nil else {
+                    +            guard kind == .device, chargedDevice == nil else {
+                                     return
+                                 applySuggestedChargingSupport(for: deviceClass)
+                    +    private var identitySection: some View {
+                    +        Section(header: Text("Identity")) {
+                    +            TextField(kind == .charger ? "Charger name" : "Name", text: $name)
+                    +            if kind == .device {
+                    +                Picker("Class", selection: $deviceClass) {
+                    +                    ForEach(ChargedDeviceClass.deviceCases) { deviceClass in
+                    +                        Label(deviceClass.title, systemImage: deviceClass.symbolName)
+                    +                            .tag(deviceClass)
+                    +                    }
+                    +                }
+                    +            }
+                    +            if let chargedDevice {
+                    +                Text(chargedDevice.qrIdentifier)
+                    +                    .font(.caption.monospaced())
+                    +                    .foregroundColor(.secondary)
+                    +                    .textSelection(.enabled)
+                    +            }
+                    +        }
+                    +    }
+                    +    private var deviceChargeBehaviourSection: some View {
+                    +        Section(
+                    +            header: ContextInfoHeader(
+                    +                title: "Charge Behaviour",
+                    +                message: "Choose whether sessions for this device are recorded only while it is on, only while it is off, or explicitly in either state."
+                    +            )
+                    +        ) {
+                    +            Picker("Session Modes", selection: $chargingStateAvailability) {
+                    +                ForEach(ChargingStateAvailability.allCases) { availability in
+                    +                    Text(availability.title)
+                    +                        .tag(availability)
+                    +                }
+                    +            }
+                    +        }
+                    +    }
+                    +    private var deviceChargingSupportSection: some View {
+                    +        Section(
+                    +            header: ContextInfoHeader(
+                    +                title: "Charging Support",
+                    +                message: "Enable the charging methods this device actually supports. Wireless devices can also keep a dedicated profile so learning stays separate."
+                    +            )
+                    +        ) {
+                    +            Toggle("Supports wired charging", isOn: $supportsWiredCharging)
+                    +            Toggle("Supports wireless charging", isOn: $supportsWirelessCharging)
+                    +            if supportsWirelessCharging {
+                    +                Picker("Wireless profile", selection: $wirelessChargingProfile) {
+                    +                    ForEach(WirelessChargingProfile.allCases) { profile in
+                    +                        Text(profile.title)
+                    +                            .tag(profile)
+                    +                    }
+                    +                }
+                    +            }
+                    +            if supportedChargingModes.isEmpty {
+                    +                Text("Enable at least one charging method.")
+                    +                    .font(.footnote)
+                    +                    .foregroundColor(.secondary)
+                    +            }
+                    +        }
+                    +    }
+                    +    private var deviceCompletionSection: some View {
+                    +        Section(
+                    +            header: ContextInfoHeader(
+                    +                title: "Charge Completion",
+                    +                message: "Completion currents can be set per session type. Leave a value empty to keep learning that threshold automatically from sessions of the same type."
+                    +            )
+                    +        ) {
+                    +            if applicableSessionKinds.isEmpty {
+                    +                Text("Enable at least one charging method to configure stop currents.")
+                    +                    .font(.footnote)
+                    +                    .foregroundColor(.secondary)
+                    +            } else {
+                    +                ForEach(applicableSessionKinds) { sessionKind in
+                    +                    VStack(alignment: .leading, spacing: 6) {
+                    +                        TextField(
+                    +                            "\(sessionKind.shortTitle) completion current (A)",
+                    +                            text: completionCurrentTextBinding(for: sessionKind)
+                    +                        )
+                    +                        .keyboardType(.decimalPad)
+                    +                    }
+                    +                    .padding(.vertical, 2)
+                    +                }
+                    +            }
+                    +        }
+                    +    }
+                    +    private var chargerInformationSection: some View {
+                    +        Section(
+                    +            header: ContextInfoHeader(
+                    +                title: "Charger",
+                    +                message: "Chargers are edited separately from devices. Their charge-session metrics are learned automatically from wireless sessions."
+                    +            )
+                    +        ) {
+                    +            EmptyView()
+                    +        }
+                    +    }
+                    +    private var notesSection: some View {
+                    +        Section(header: Text("Notes")) {
+                    +            TextField("Optional notes", text: $notes)
+                    +        }
+                    +    }
+                         private var editorTitle: String {
+                             if chargedDevice == nil {
+                    -            return deviceClass == .charger ? "New Charger" : "New Device"
+                    +            return "New \(kind.title)"
+                    -        return chargedDevice?.isCharger == true ? "Edit Charger" : "Edit Device"
+                    +        return "Edit \(kind.title)"
+                         private var saveButtonTitle: String {
+                             chargedDevice == nil ? "Save" : "Update"
+                    +    private var canSave: Bool {
+                    +        let hasValidName = name.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty == false
+                    +        guard kind == .device else {
+                    +            return hasValidName
+                    +        }
+                    +        return hasValidName
+                    +            && (supportsWiredCharging || supportsWirelessCharging)
+                    +            && !hasInvalidCompletionCurrentEntry
+                    +    }
+                         private var supportedChargingModes: [ChargingTransportMode] {
+                             var modes: [ChargingTransportMode] = []
+                             if supportsWiredCharging {
+                    -    private var resolvedPreferredChargingTransportMode: ChargingTransportMode {
+                    -        if supportedChargingModes.contains(preferredChargingTransportMode) {
+                    -            return preferredChargingTransportMode
+                    -        }
+                    -        return supportsWiredCharging ? .wired : .wireless
+                    -    }
+                    -    private var preferredChargingTransportBinding: Binding<ChargingTransportMode> {
+                    -        Binding(
+                    -            get: { resolvedPreferredChargingTransportMode },
+                    -            set: { preferredChargingTransportMode = $0 }
+                    -        )
+                    -    }
+                         private func completionCurrentTextBinding(for sessionKind: ChargeSessionKind) -> Binding<String> {
+                             Binding(
+                                 get: { completionCurrentTexts[sessionKind] ?? "" },
+                    +    private func save() {
+                    +        let didSave: Bool
+                    +        if kind == .charger {
+                    +            if let chargedDevice {
+                    +                didSave = appData.updateCharger(
+                    +                    id: chargedDevice.id,
+                    +                    name: name,
+                    +                    notes: notes
+                    +                )
+                    +            } else {
+                    +                didSave = appData.createCharger(
+                    +                    name: name,
+                    +                    notes: notes,
+                    +                    meterMACAddress: meterMACAddress
+                    +                )
+                    +            }
+                    +        } else {
+                    +            let configuredCompletionCurrents = parsedCompletionCurrents
+                    +            if let chargedDevice {
+                    +                didSave = appData.updateDevice(
+                    +                    id: chargedDevice.id,
+                    +                    name: name,
+                    +                    deviceClass: deviceClass,
+                    +                    chargingStateAvailability: chargingStateAvailability,
+                    +                    supportsWiredCharging: supportsWiredCharging,
+                    +                    supportsWirelessCharging: supportsWirelessCharging,
+                    +                    wirelessChargingProfile: wirelessChargingProfile,
+                    +                    configuredCompletionCurrents: configuredCompletionCurrents,
+                    +                    notes: notes
+                    +                )
+                    +            } else {
+                    +                didSave = appData.createDevice(
+                    +                    name: name,
+                    +                    deviceClass: deviceClass,
+                    +                    chargingStateAvailability: chargingStateAvailability,
+                    +                    supportsWiredCharging: supportsWiredCharging,
+                    +                    supportsWirelessCharging: supportsWirelessCharging,
+                    +                    wirelessChargingProfile: wirelessChargingProfile,
+                    +                    configuredCompletionCurrents: configuredCompletionCurrents,
+                    +                    notes: notes,
+                    +                    meterMACAddress: meterMACAddress
+                    +                )
+                    +            }
+                    +        }
+                    +        if didSave {
+                    +            dismiss()
+                    +        }
+                    +    }
+                         private func applySuggestedChargingSupport(for deviceClass: ChargedDeviceClass) {
+                             if chargedDevice != nil {
+                                 return
+                             case .iphone:
+                                 supportsWiredCharging = true
+                                 supportsWirelessCharging = true
+                    -            preferredChargingTransportMode = .wired
+                             case .watch:
+                                 supportsWiredCharging = false
+                                 supportsWirelessCharging = true
+                    -            preferredChargingTransportMode = .wireless
+                             case .powerbank:
+                                 supportsWiredCharging = true
+                                 supportsWirelessCharging = false
+                    -            preferredChargingTransportMode = .wired
+                             case .charger:
+                    -            supportsWiredCharging = true
+                    +            supportsWiredCharging = false
+                                 supportsWirelessCharging = true
+                    -            preferredChargingTransportMode = .wireless
+                             case .other:
+                                 supportsWiredCharging = true
+                                 supportsWirelessCharging = false
+                    -            preferredChargingTransportMode = .wired
+                                 return .onOnly
+                             case .powerbank:
+                                 return .offOnly
+                    -        case .charger:
+                    -            return .onOnly
+                    -        case .other:
+                    +        case .charger, .other:
+                                 return .onOnly

+54 -35

USB Meter/Views/ChargedDevices/ChargedDeviceLibrarySheetView.swift

View

@@ -11,30 +11,30 @@ enum ChargedDeviceLibraryMode {
     case device
     case charger
 
-    var title: String {
+    var kind: ChargedDeviceKind {
         switch self {
         case .device:
-            return "Devices"
+            return .device
         case .charger:
-            return "Chargers"
+            return .charger
         }
     }
 
-    var singularTitle: String {
+    var title: String {
         switch self {
         case .device:
-            return "Device"
+            return "Devices"
         case .charger:
-            return "Charger"
+            return "Chargers"
         }
     }
 
-    var suggestedClass: ChargedDeviceClass {
+    var singularTitle: String {
         switch self {
         case .device:
-            return .iphone
+            return "Device"
         case .charger:
-            return .charger
+            return "Charger"
         }
     }
 }
@@ -56,11 +56,14 @@ struct ChargedDeviceLibrarySheetView: View {
             List {
                 if displayedChargedDevices.isEmpty {
                     VStack(alignment: .leading, spacing: 10) {
-                        Text("No \(mode.title.lowercased()) yet.")
-                            .font(.headline)
-                        Text(emptyStateDescription)
-                            .font(.footnote)
-                            .foregroundColor(.secondary)
+                        HStack(spacing: 8) {
+                            Text("No \(mode.title.lowercased()) yet.")
+                                .font(.headline)
+                            ContextInfoButton(
+                                title: mode.title,
+                                message: emptyStateDescription
+                            )
+                        }
                     }
                     .padding(.vertical, 10)
                     .listRowBackground(Color.clear)
@@ -88,7 +91,7 @@ struct ChargedDeviceLibrarySheetView: View {
                             Button {
                                 editingChargedDevice = chargedDevice
                             } label: {
-                                Label("Edit Device", systemImage: "pencil")
+                                Label("Edit \(mode.singularTitle)", systemImage: "pencil")
                             }
                         }
                     }
@@ -122,15 +125,15 @@ struct ChargedDeviceLibrarySheetView: View {
         .sheet(isPresented: $editorVisibility) {
             ChargedDeviceEditorSheetView(
                 meterMACAddress: meterMACAddress,
-                suggestedDeviceClass: mode.suggestedClass
+                kind: mode.kind
             )
                 .environmentObject(appData)
         }
         .sheet(item: $editingChargedDevice) { chargedDevice in
             ChargedDeviceEditorSheetView(
                 meterMACAddress: nil,
-                chargedDevice: chargedDevice,
-                suggestedDeviceClass: mode.suggestedClass
+                kind: mode.kind,
+                chargedDevice: chargedDevice
             )
             .environmentObject(appData)
         }
@@ -183,7 +186,7 @@ private struct ChargedDeviceLibraryRowView: View {
 
             VStack(alignment: .leading, spacing: 6) {
                 HStack {
-                    Label(chargedDevice.name, systemImage: chargedDevice.deviceClass.symbolName)
+                    Label(chargedDevice.name, systemImage: chargedDevice.identitySymbolName)
                         .font(.headline)
                         .foregroundColor(.primary)
                     Spacer()
@@ -193,28 +196,44 @@ private struct ChargedDeviceLibraryRowView: View {
                     }
                 }
 
-                Text(chargedDevice.deviceClass.title)
+                Text(chargedDevice.identityTitle)
                     .font(.caption.weight(.semibold))
                     .foregroundColor(.secondary)
 
-                Text(chargedDevice.supportedChargingModes.map(\.title).joined(separator: " + "))
-                    .font(.caption2)
-                    .foregroundColor(.secondary)
-
-                if let capacity = chargedDevice.estimatedBatteryCapacityWh {
-                    Text("Estimated capacity: \(capacity.format(decimalDigits: 2)) Wh")
-                        .font(.caption)
-                        .foregroundColor(.secondary)
-                } else if chargedDevice.isCharger, let chargerMaximumPowerWatts = chargedDevice.chargerMaximumPowerWatts {
-                    Text("Max power: \(chargerMaximumPowerWatts.format(decimalDigits: 2)) W")
-                        .font(.caption)
+                if chargedDevice.isCharger {
+                    if !chargedDevice.chargerObservedVoltageSelections.isEmpty {
+                        Text(
+                            chargedDevice.chargerObservedVoltageSelections
+                                .map { "\($0.format(decimalDigits: 1)) V" }
+                                .joined(separator: ", ")
+                        )
+                        .font(.caption2)
                         .foregroundColor(.secondary)
-                }
-
-                if let minimumCurrent = chargedDevice.resolvedCompletionCurrentAmps(for: chargedDevice.preferredChargingTransportMode) {
-                    Text("Completion current: \(minimumCurrent.format(decimalDigits: 2)) A")
+                    } else if let chargerMaximumPowerWatts = chargedDevice.chargerMaximumPowerWatts {
+                        Text("Max power: \(chargerMaximumPowerWatts.format(decimalDigits: 2)) W")
+                            .font(.caption2)
+                            .foregroundColor(.secondary)
+                    } else {
+                        Text("Wireless charger")
+                            .font(.caption2)
+                            .foregroundColor(.secondary)
+                    }
+                } else {
+                    Text(chargedDevice.supportedChargingModes.map(\.title).joined(separator: " + "))
                         .font(.caption2)
                         .foregroundColor(.secondary)
+
+                    if let capacity = chargedDevice.estimatedBatteryCapacityWh {
+                        Text("Estimated capacity: \(capacity.format(decimalDigits: 2)) Wh")
+                            .font(.caption)
+                            .foregroundColor(.secondary)
+                    }
+
+                    if let minimumCurrent = chargedDevice.minimumCurrentAmps {
+                        Text("Completion current: \(minimumCurrent.format(decimalDigits: 2)) A")
+                            .font(.caption2)
+                            .foregroundColor(.secondary)
+                    }
                 }
             }
         }


+23 -15

USB Meter/Views/ChargedDevices/SidebarChargedDevicesSectionView.swift

View

@@ -63,7 +63,7 @@ private struct ChargedDeviceSidebarCardView: View {
 
             VStack(alignment: .leading, spacing: 6) {
                 HStack {
-                    Label(chargedDevice.name, systemImage: chargedDevice.deviceClass.symbolName)
+                    Label(chargedDevice.name, systemImage: chargedDevice.identitySymbolName)
                         .font(.headline)
                     if chargedDevice.activeSession != nil {
                         Spacer()
@@ -73,26 +73,34 @@ private struct ChargedDeviceSidebarCardView: View {
                     }
                 }
 
-                Text(chargedDevice.deviceClass.title)
+                Text(chargedDevice.identityTitle)
                     .font(.caption.weight(.semibold))
                     .foregroundColor(.secondary)
 
-                Text(chargedDevice.supportedChargingModes.map(\.title).joined(separator: " + "))
-                    .font(.caption2)
-                    .foregroundColor(.secondary)
-
-                if let estimatedCapacityWh = chargedDevice.estimatedBatteryCapacityWh {
-                    Text("Capacity: \(estimatedCapacityWh.format(decimalDigits: 2)) Wh")
-                        .font(.caption2)
-                        .foregroundColor(.secondary)
-                } else if chargedDevice.isCharger, let chargerMaximumPowerWatts = chargedDevice.chargerMaximumPowerWatts {
-                    Text("Max power: \(chargerMaximumPowerWatts.format(decimalDigits: 2)) W")
-                        .font(.caption2)
-                        .foregroundColor(.secondary)
+                if chargedDevice.isCharger {
+                    if let chargerMaximumPowerWatts = chargedDevice.chargerMaximumPowerWatts {
+                        Text("Max power: \(chargerMaximumPowerWatts.format(decimalDigits: 2)) W")
+                            .font(.caption2)
+                            .foregroundColor(.secondary)
+                    } else {
+                        Text("Wireless charger")
+                            .font(.caption2)
+                            .foregroundColor(.secondary)
+                    }
                 } else {
-                    Text("Capacity: learning")
+                    Text(chargedDevice.supportedChargingModes.map(\.title).joined(separator: " + "))
                         .font(.caption2)
                         .foregroundColor(.secondary)
+
+                    if let estimatedCapacityWh = chargedDevice.estimatedBatteryCapacityWh {
+                        Text("Capacity: \(estimatedCapacityWh.format(decimalDigits: 2)) Wh")
+                            .font(.caption2)
+                            .foregroundColor(.secondary)
+                    } else {
+                        Text("Capacity: learning")
+                            .font(.caption2)
+                            .foregroundColor(.secondary)
+                    }
                 }
             }
         }


+54 -0

USB Meter/Views/Components/Generic/ChevronView.swift

View

+                    +struct ContextInfoButton: View {
+                    +    let title: String
+                    +    let message: String
+                    +    let popoverWidth: CGFloat
+                    +    @State private var showsPopover = false
+                    +    init(
+                    +        title: String,
+                    +        message: String,
+                    +        popoverWidth: CGFloat = 280
+                    +    ) {
+                    +        self.title = title
+                    +        self.message = message
+                    +        self.popoverWidth = popoverWidth
+                    +    }
+                    +    var body: some View {
+                    +        Button {
+                    +            showsPopover.toggle()
+                    +        } label: {
+                    +            Image(systemName: "info.circle")
+                    +                .font(.body.weight(.semibold))
+                    +                .foregroundColor(.secondary)
+                    +        }
+                    +        .buttonStyle(.plain)
+                    +        .accessibilityLabel("\(title) info")
+                    +        .popover(isPresented: $showsPopover, arrowEdge: .top) {
+                    +            VStack(alignment: .leading, spacing: 10) {
+                    +                Text(title)
+                    +                    .font(.headline)
+                    +                Text(message)
+                    +                    .font(.body)
+                    +                    .fixedSize(horizontal: false, vertical: true)
+                    +            }
+                    +            .padding(16)
+                    +            .frame(width: popoverWidth, alignment: .leading)
+                    +        }
+                    +    }
+                    +}
+                    +struct ContextInfoHeader: View {
+                    +    let title: String
+                    +    let message: String
+                    +    var body: some View {
+                    +        HStack(spacing: 8) {
+                    +            Text(title)
+                    +            Spacer(minLength: 0)
+                    +            ContextInfoButton(title: title, message: message)
+                    +        }
+                    +    }
+                    +}

+50 -4

USB Meter/Views/Meter/Components/MeasurementChartView.swift

View

@@ -97,6 +97,8 @@ struct MeasurementChartView: View {
 
     let compactLayout: Bool
     let availableSize: CGSize
+    let showsRangeSelector: Bool
+    let rebasesEnergyToVisibleRangeStart: Bool
     
     @EnvironmentObject private var measurements: Measurements
     @Environment(\.horizontalSizeClass) private var horizontalSizeClass
@@ -128,11 +130,15 @@ struct MeasurementChartView: View {
     init(
         compactLayout: Bool = false,
         availableSize: CGSize = .zero,
-        timeRange: ClosedRange<Date>? = nil
+        timeRange: ClosedRange<Date>? = nil,
+        showsRangeSelector: Bool = true,
+        rebasesEnergyToVisibleRangeStart: Bool = false
     ) {
         self.compactLayout = compactLayout
         self.availableSize = availableSize
         self.timeRange = timeRange
+        self.showsRangeSelector = showsRangeSelector
+        self.rebasesEnergyToVisibleRangeStart = rebasesEnergyToVisibleRangeStart
     }
 
     private var axisColumnWidth: CGFloat {
@@ -153,6 +159,16 @@ struct MeasurementChartView: View {
         return isLargeDisplay ? 36 : 28
     }
 
+    private var belowXAxisControlsHeight: CGFloat {
+        if usesCompactLandscapeOriginControls {
+            return 40
+        }
+        if compactLayout {
+            return 46
+        }
+        return isLargeDisplay ? 58 : 50
+    }
+
     private var isPortraitLayout: Bool {
         guard availableSize != .zero else { return verticalSizeClass != .compact }
         return availableSize.height >= availableSize.width
@@ -280,7 +296,13 @@ struct MeasurementChartView: View {
                     chartToggleBar()
 
                     GeometryReader { geometry in
-                        let plotHeight = max(geometry.size.height - xAxisHeight, compactLayout ? 180 : 220)
+                        let reservedBottomHeight =
+                            xAxisHeight
+                            + (originControlsPlacement == .belowXAxisLegend ? belowXAxisControlsHeight + 6 : 0)
+                        let plotHeight = max(
+                            geometry.size.height - reservedBottomHeight,
+                            compactLayout ? 180 : 220
+                        )
 
                         VStack(spacing: 6) {
                             HStack(spacing: chartSectionSpacing) {
@@ -363,7 +385,8 @@ struct MeasurementChartView: View {
                                 }
                             }
 
-                            if let availableTimeRange,
+                            if showsRangeSelector,
+                               let availableTimeRange,
                                let selectorSeries,
                                shouldShowRangeSelector(
                                 availableTimeRange: availableTimeRange,
@@ -879,7 +902,8 @@ struct MeasurementChartView: View {
             measurement,
             visibleTimeRange: visibleTimeRange
         )
-        let points = smoothedPoints(from: rawPoints)
+        let normalizedRawPoints = normalizedPoints(rawPoints, for: kind)
+        let points = smoothedPoints(from: normalizedRawPoints)
         let samplePoints = points.filter { $0.isSample }
         let context = ChartContext()
 
@@ -921,6 +945,28 @@ struct MeasurementChartView: View {
         )
     }
 
+    private func normalizedPoints(
+        _ points: [Measurements.Measurement.Point],
+        for kind: SeriesKind
+    ) -> [Measurements.Measurement.Point] {
+        guard kind == .energy, rebasesEnergyToVisibleRangeStart else {
+            return points
+        }
+
+        guard let baseline = points.first(where: \.isSample)?.value else {
+            return points
+        }
+
+        return points.enumerated().map { index, point in
+            Measurements.Measurement.Point(
+                id: point.id == index ? point.id : index,
+                timestamp: point.timestamp,
+                value: point.value - baseline,
+                kind: point.kind
+            )
+        }
+    }
+
     private func overviewSeries(for kind: SeriesKind) -> SeriesData {
         series(
             for: measurement(for: kind),


+21 -3

USB Meter/Views/Meter/Components/MeterInfoCardView.swift

View

@@ -7,17 +7,35 @@ import SwiftUI
 
 struct MeterInfoCardView<Content: View>: View {
     let title: String
+    let infoMessage: String?
     let tint: Color
     @ViewBuilder var content: Content
 
+    init(
+        title: String,
+        infoMessage: String? = nil,
+        tint: Color,
+        @ViewBuilder content: () -> Content
+    ) {
+        self.title = title
+        self.infoMessage = infoMessage
+        self.tint = tint
+        self.content = content()
+    }
+
     var body: some View {
         VStack(alignment: .leading, spacing: 12) {
-            Text(title)
-                .font(.headline)
+            HStack(spacing: 8) {
+                Text(title)
+                    .font(.headline)
+                if let infoMessage {
+                    ContextInfoButton(title: title, message: infoMessage)
+                }
+            }
             content
         }
         .frame(maxWidth: .infinity, alignment: .leading)
         .padding(18)
         .meterCard(tint: tint, fillOpacity: 0.18, strokeOpacity: 0.24)
     }
-}
+}


+6 -4

USB Meter/Views/Meter/Sheets/ChargeRecord/ChargeRecordSheetView.swift

View

@@ -46,14 +46,16 @@ struct BatteryTargetNotificationEditorSheetView: View {
     var body: some View {
         NavigationView {
             Form {
-                Section(header: Text("Target Level")) {
+                Section(
+                    header: ContextInfoHeader(
+                        title: "Target Level",
+                        message: "A local notification will be generated on synced devices when the estimated battery level reaches this target."
+                    )
+                ) {
                     VStack(alignment: .leading, spacing: 12) {
                         Text("\(targetPercent.format(decimalDigits: 0))%")
                             .font(.title3.weight(.bold))
                         Slider(value: $targetPercent, in: 20...100, step: 1)
-                        Text("A local notification will be generated on synced devices when the estimated battery level reaches this target.")
-                            .font(.footnote)
-                            .foregroundColor(.secondary)
                     }
                 }
             }


+11 -7

USB Meter/Views/Meter/Sheets/DataGroups/DataGroupsSheetView.swift

View

@@ -16,7 +16,7 @@ struct DataGroupsSheetView: View {
     var body: some View {
         NavigationView {
             GeometryReader { box in
-                let columnTitles = [usbMeter.supportsDataGroupCommands ? "Group" : "Memory", "Ah"]
+                let columnTitles = [usbMeter.supportsDataGroupCommands ? "Group" : "Memory"]
                     + (usbMeter.showsDataGroupEnergy ? ["Wh"] : [])
                     + (usbMeter.supportsDataGroupCommands ? ["Clear"] : [])
                 let columnWidth = (box.size.width - 60) / CGFloat(columnTitles.count)
@@ -24,12 +24,16 @@ struct DataGroupsSheetView: View {
                 ScrollView {
                     VStack(alignment: .leading, spacing: 14) {
                         VStack(alignment: .leading, spacing: 8) {
-                            Text(usbMeter.dataGroupsTitle)
-                                .font(.system(.title3, design: .rounded).weight(.bold))
-                            if let hint = usbMeter.dataGroupsHint {
-                                Text(hint)
-                                    .font(.footnote)
-                                    .foregroundColor(.secondary)
+                            HStack {
+                                Text(usbMeter.dataGroupsTitle)
+                                    .font(.system(.title3, design: .rounded).weight(.bold))
+                                if let hint = usbMeter.dataGroupsHint {
+                                    ContextInfoButton(
+                                        title: usbMeter.dataGroupsTitle,
+                                        message: hint
+                                    )
+                                }
+                                Spacer(minLength: 0)
                             }
                         }
                         .padding(18)


+1 -6

USB Meter/Views/Meter/Sheets/DataGroups/Subviews/DataGroupRowView.swift

View

@@ -34,12 +34,7 @@ struct DataGroupRowView: View {
                         .fontWeight(.semibold)
                 }
             }
-            
-            cell(width: width) {
-                Text("\(usbMeter.dataGroupRecords[Int(id)]!.ah.format(decimalDigits: 3))")
-                    .monospacedDigit()
-            }
-            
+
             if showsEnergy {
                 cell(width: width) {
                     Text("\(usbMeter.dataGroupRecords[Int(id)]!.wh.format(decimalDigits: 3))")


+9 -5

USB Meter/Views/Meter/Sheets/MeasurementSeries/MeasurementSeriesSheetView.swift

View

@@ -21,11 +21,15 @@ struct MeasurementSeriesSheetView: View {
             ScrollView {
                 VStack(alignment: .leading, spacing: 14) {
                     VStack(alignment: .leading, spacing: 8) {
-                        Text("Measurement Series")
-                            .font(.system(.title3, design: .rounded).weight(.bold))
-                        Text("Buffered measurement series captured from the meter for analysis, charts, and correlations.")
-                            .font(.footnote)
-                            .foregroundColor(.secondary)
+                        HStack {
+                            Text("Measurement Series")
+                                .font(.system(.title3, design: .rounded).weight(.bold))
+                            ContextInfoButton(
+                                title: "Measurement Series",
+                                message: "Buffered measurement series captured from the meter for analysis, charts, and correlations."
+                            )
+                            Spacer(minLength: 0)
+                        }
                     }
                     .padding(18)
                     .meterCard(tint: .blue, fillOpacity: 0.18, strokeOpacity: 0.24)


+420 -173

USB Meter/Views/Meter/Tabs/ChargeRecord/MeterChargeRecordTabView.swift

View

	@@ -12,6 +12,25 @@ struct MeterChargeRecordTabView: View {
12	12	}
13	13
14	14	struct MeterChargeRecordContentView: View {
	15	+ private enum InitialCheckpointMode: String, CaseIterable, Identifiable {
	16	+ case known
	17	+ case unknown
	18	+ case flat
	19	+
	20	+ var id: String { rawValue }
	21	+
	22	+ var title: String {
	23	+ switch self {
	24	+ case .known:
	25	+ return "Known"
	26	+ case .unknown:
	27	+ return "Unknown"
	28	+ case .flat:
	29	+ return "Flat"
	30	+ }
	31	+ }
	32	+ }
	33	+
15	34	@EnvironmentObject private var appData: AppData
16	35	@EnvironmentObject private var usbMeter: Meter
17	36
	@@ -21,10 +40,60 @@ struct MeterChargeRecordContentView: View {
21	40	@State private var editingChargedDevice: ChargedDeviceSummary?
22	41	@State private var targetNotificationEditorVisibility = false
23	42	@State private var pendingStopRequest: ChargeSessionStopRequest?
	43	+ @State private var pendingCheckpointDeletion: ChargeCheckpointSummary?
24	44	@State private var draftChargingTransportMode: ChargingTransportMode?
25	45	@State private var draftChargingStateMode: ChargingStateMode?
26		- @State private var draftAutoStopEnabled = true
	46	+ @State private var initialCheckpointMode: InitialCheckpointMode = .known
27	47	@State private var initialCheckpoint = ""
	48	+ @State private var showsMeterTotalsInfo = false
	49	+
	50	+ private enum SessionStartRequirement: Identifiable {
	51	+ case existingSession
	52	+ case device
	53	+ case chargingType
	54	+ case chargingMode
	55	+ case charger
	56	+ case initialCheckpointEmpty
	57	+ case initialCheckpointInvalid
	58	+
	59	+ var id: String {
	60	+ switch self {
	61	+ case .existingSession:
	62	+ return "existing-session"
	63	+ case .device:
	64	+ return "device"
	65	+ case .chargingType:
	66	+ return "charging-type"
	67	+ case .chargingMode:
	68	+ return "charging-mode"
	69	+ case .charger:
	70	+ return "charger"
	71	+ case .initialCheckpointEmpty:
	72	+ return "initial-checkpoint-empty"
	73	+ case .initialCheckpointInvalid:
	74	+ return "initial-checkpoint-invalid"
	75	+ }
	76	+ }
	77	+
	78	+ var message: String {
	79	+ switch self {
	80	+ case .existingSession:
	81	+ return "Stop or pause the current session before starting another one."
	82	+ case .device:
	83	+ return "Select the device that is charging."
	84	+ case .chargingType:
	85	+ return "Choose the charging type for this session."
	86	+ case .chargingMode:
	87	+ return "Choose whether the device is on or off for this session."
	88	+ case .charger:
	89	+ return "Select the wireless charger used in this session."
	90	+ case .initialCheckpointEmpty:
	91	+ return "Enter the initial battery percentage."
	92	+ case .initialCheckpointInvalid:
	93	+ return "Initial battery percentage must be between 0 and 100."
	94	+ }
	95	+ }
	96	+ }
28	97
29	98	var body: some View {
30	99	ScrollView {
	@@ -35,12 +104,14 @@ struct MeterChargeRecordContentView: View {
35	104	if let openChargeSession {
36	105	chargingMonitorCard(openChargeSession)
37	106
	107	+ if showsMeterTotalsCard {
	108	+ meterTotalsCard
	109	+ }
	110	+
38	111	if let sessionChartTimeRange {
39	112	sessionChartCard(timeRange: sessionChartTimeRange, session: openChargeSession)
40	113	}
41		- }
42		-
43		- if usbMeter.supportsDataGroupCommands \|\| usbMeter.recordedAH > 0 \|\| usbMeter.recordedWH > 0 \|\| usbMeter.recordingDuration > 0 {
	114	+ } else if showsMeterTotalsCard {
44	115	meterTotalsCard
45	116	}
46	117	}
	@@ -80,6 +151,7 @@ struct MeterChargeRecordContentView: View {
80	151	.sheet(item: $editingChargedDevice) { chargedDevice in
81	152	ChargedDeviceEditorSheetView(
82	153	meterMACAddress: nil,
	154	+ kind: chargedDevice.kind,
83	155	chargedDevice: chargedDevice
84	156	)
85	157	.environmentObject(appData)
	@@ -102,6 +174,21 @@ struct MeterChargeRecordContentView: View {
102	174	)
103	175	.environmentObject(appData)
104	176	}
	177	+ .alert(item: $pendingCheckpointDeletion) { checkpoint in
	178	+ Alert(
	179	+ title: Text("Delete Battery Checkpoint"),
	180	+ message: Text("Remove the checkpoint at \(checkpoint.timestamp.format()) with \(checkpoint.batteryPercent.format(decimalDigits: 0))% from this session?"),
	181	+ primaryButton: .destructive(Text("Delete")) {
	182	+ if let openChargeSession {
	183	+ _ = appData.deleteBatteryCheckpoint(
	184	+ checkpointID: checkpoint.id,
	185	+ for: openChargeSession.id
	186	+ )
	187	+ }
	188	+ },
	189	+ secondaryButton: .cancel()
	190	+ )
	191	+ }
105	192	.onAppear {
106	193	syncDraftSelections()
107	194	}
	@@ -129,6 +216,14 @@ struct MeterChargeRecordContentView: View {
129	216	appData.activeChargeSessionSummary(for: meterMACAddress)
130	217	}
131	218
	219	+ private var showsMeterTotalsCard: Bool {
	220	+ usbMeter.supportsRecordingView
	221	+ \|\| usbMeter.supportsDataGroupCommands
	222	+ \|\| usbMeter.recordedAH > 0
	223	+ \|\| usbMeter.recordedWH > 0
	224	+ \|\| usbMeter.recordingDuration > 0
	225	+ }
	226	+
132	227	private var selectedDraftTransportMode: ChargingTransportMode? {
133	228	openChargeSession?.chargingTransportMode ?? draftChargingTransportMode
134	229	}
	@@ -137,31 +232,10 @@ struct MeterChargeRecordContentView: View {
137	232	openChargeSession?.chargingStateMode ?? draftChargingStateMode
138	233	}
139	234
140		- private var selectedDraftSessionKind: ChargeSessionKind? {
141		- guard let chargingTransportMode = selectedDraftTransportMode,
142		- let chargingStateMode = selectedDraftChargingStateMode else {
143		- return nil
144		- }
145		-
146		- return ChargeSessionKind(
147		- chargingTransportMode: chargingTransportMode,
148		- chargingStateMode: chargingStateMode
149		- )
150		- }
151		-
152		- private var selectedDraftStopThreshold: Double? {
153		- guard let selectedChargedDevice,
154		- let chargingTransportMode = selectedDraftTransportMode else {
	235	+ private var initialCheckpointValue: Double? {
	236	+ guard initialCheckpointMode == .known else {
155	237	return nil
156	238	}
157		-
158		- return selectedChargedDevice.resolvedCompletionCurrentAmps(
159		- for: chargingTransportMode,
160		- chargingStateMode: selectedDraftChargingStateMode
161		- )
162		- }
163		-
164		- private var initialCheckpointValue: Double? {
165	239	let normalized = initialCheckpoint
166	240	.trimmingCharacters(in: .whitespacesAndNewlines)
167	241	.replacingOccurrences(of: ",", with: ".")
	@@ -171,6 +245,14 @@ struct MeterChargeRecordContentView: View {
171	245	return value
172	246	}
173	247
	248	+ private var hasInitialCheckpointInput: Bool {
	249	+ initialCheckpoint.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty == false
	250	+ }
	251	+
	252	+ private var shouldRequireInitialCheckpoint: Bool {
	253	+ initialCheckpointMode == .known
	254	+ }
	255	+
174	256	private var requiresExplicitTransportSelection: Bool {
175	257	(selectedChargedDevice?.supportedChargingModes.count ?? 0) > 1
176	258	}
	@@ -179,28 +261,53 @@ struct MeterChargeRecordContentView: View {
179	261	(selectedChargedDevice?.supportedChargingStateModes.count ?? 0) > 1
180	262	}
181	263
182		- private var canStartSession: Bool {
183		- guard openChargeSession == nil,
184		- let selectedChargedDevice,
185		- let chargingTransportMode = selectedDraftTransportMode,
186		- let chargingStateMode = selectedDraftChargingStateMode,
187		- let initialCheckpointValue else {
188		- return false
	264	+ private var startRequirements: [SessionStartRequirement] {
	265	+ var requirements: [SessionStartRequirement] = []
	266	+
	267	+ if openChargeSession != nil {
	268	+ requirements.append(.existingSession)
189	269	}
190	270
191		- guard selectedChargedDevice.supportedChargingModes.contains(chargingTransportMode) else {
192		- return false
	271	+ guard let selectedChargedDevice else {
	272	+ requirements.append(.device)
	273	+ return requirements
193	274	}
194	275
195		- guard selectedChargedDevice.supportedChargingStateModes.contains(chargingStateMode) else {
196		- return false
	276	+ guard let chargingTransportMode = selectedDraftTransportMode else {
	277	+ requirements.append(.chargingType)
	278	+ return requirements
197	279	}
198	280
199		- if chargingTransportMode == .wireless {
200		- return selectedCharger != nil
	281	+ if selectedChargedDevice.supportedChargingModes.contains(chargingTransportMode) == false {
	282	+ requirements.append(.chargingType)
201	283	}
202	284
203		- return true
	285	+ guard let chargingStateMode = selectedDraftChargingStateMode else {
	286	+ requirements.append(.chargingMode)
	287	+ return requirements
	288	+ }
	289	+
	290	+ if selectedChargedDevice.supportedChargingStateModes.contains(chargingStateMode) == false {
	291	+ requirements.append(.chargingMode)
	292	+ }
	293	+
	294	+ if chargingTransportMode == .wireless, selectedCharger == nil {
	295	+ requirements.append(.charger)
	296	+ }
	297	+
	298	+ if shouldRequireInitialCheckpoint {
	299	+ if hasInitialCheckpointInput == false {
	300	+ requirements.append(.initialCheckpointEmpty)
	301	+ } else if initialCheckpointValue == nil {
	302	+ requirements.append(.initialCheckpointInvalid)
	303	+ }
	304	+ }
	305	+
	306	+ return requirements
	307	+ }
	308	+
	309	+ private var canStartSession: Bool {
	310	+ startRequirements.isEmpty
204	311	}
205	312
206	313	private var headerStatusTitle: String {
	@@ -236,51 +343,15 @@ struct MeterChargeRecordContentView: View {
236	343	return openChargeSession.startedAt...max(end, openChargeSession.startedAt)
237	344	}
238	345
239		- private var draftAutoStopDescription: String {
240		- guard let chargingTransportMode = selectedDraftTransportMode else {
241		- return "Choose the charging type before starting the session."
242		- }
243		-
244		- if chargingTransportMode == .wireless, selectedCharger == nil {
245		- return "Wireless sessions need a selected charger before they can start."
246		- }
247		-
248		- if draftAutoStopEnabled == false {
249		- return "The session starts open-ended and will stop only when you pause or stop it manually."
250		- }
251		-
252		- if let setupWarning = setupWirelessThresholdWarning {
253		- return setupWarning
254		- }
255		-
256		- if let selectedDraftSessionKind, let selectedDraftStopThreshold {
257		- return "Auto-stop is ready for \(selectedDraftSessionKind.shortTitle.lowercased()) sessions at about \(selectedDraftStopThreshold.format(decimalDigits: 2)) A."
258		- }
259		-
260		- return "No stop threshold is known for this charging type yet, so the session starts open-ended."
261		- }
262		-
263		- private var setupWirelessThresholdWarning: String? {
264		- guard selectedDraftTransportMode == .wireless else {
265		- return nil
266		- }
267		-
268		- guard let selectedCharger else {
269		- return nil
270		- }
271		-
272		- guard selectedCharger.chargerIdleCurrentAmps == nil else {
273		- return nil
274		- }
275		-
276		- return "This charger has no idle-current measurement. Wireless sessions can still be recorded, but they cannot learn or auto-apply the final stop threshold yet."
277		- }
278		-
279	346	private var headerCard: some View {
280	347	VStack(alignment: .leading, spacing: 8) {
281	348	HStack {
282	349	Text("Charging Session")
283	350	.font(.system(.title3, design: .rounded).weight(.bold))
	351	+ ContextInfoButton(
	352	+ title: "Charging Session",
	353	+ message: "Recording starts only after the device, charging type, charging mode, and initial checkpoint are explicit."
	354	+ )
284	355	Spacer()
285	356	Text(headerStatusTitle)
286	357	.font(.caption.weight(.bold))
	@@ -295,9 +366,6 @@ struct MeterChargeRecordContentView: View {
295	366	)
296	367	}
297	368
298		- Text("Recording starts only after the device, charging type, charging mode, and initial checkpoint are explicit.")
299		- .font(.footnote)
300		- .foregroundColor(.secondary)
301	369	}
302	370	.frame(maxWidth: .infinity)
303	371	.padding(18)
	@@ -309,6 +377,10 @@ struct MeterChargeRecordContentView: View {
309	377	HStack {
310	378	Text(openChargeSession == nil ? "Session Setup" : "Session Context")
311	379	.font(.headline)
	380	+ ContextInfoButton(
	381	+ title: openChargeSession == nil ? "Session Setup" : "Session Context",
	382	+ message: "Select or create the device you are charging. Sessions, checkpoints, curve learning, and wireless charger warnings all depend on that explicit selection."
	383	+ )
312	384	Spacer()
313	385	Button("Library") {
314	386	chargedDeviceLibraryVisibility = true
	@@ -331,9 +403,7 @@ struct MeterChargeRecordContentView: View {
331	403	.meterCard(tint: .blue, fillOpacity: 0.16, strokeOpacity: 0.22, cornerRadius: 14)
332	404	.buttonStyle(.plain)
333	405	} else {
334		- Text("Select or create the device you are charging. Sessions, checkpoints, curve learning, and wireless charger warnings all depend on that explicit selection.")
335		- .font(.footnote)
336		- .foregroundColor(.secondary)
	406	+ EmptyView()
337	407	}
338	408	}
339	409	.padding(18)
	@@ -349,10 +419,10 @@ struct MeterChargeRecordContentView: View {
349	419	)
350	420
351	421	VStack(alignment: .leading, spacing: 8) {
352		- Label(chargedDevice.name, systemImage: chargedDevice.deviceClass.symbolName)
	422	+ Label(chargedDevice.name, systemImage: chargedDevice.identitySymbolName)
353	423	.font(.headline)
354	424
355		- Text(chargedDevice.deviceClass.title)
	425	+ Text(chargedDevice.identityTitle)
356	426	.font(.caption.weight(.semibold))
357	427	.foregroundColor(.secondary)
358	428
	@@ -364,18 +434,8 @@ struct MeterChargeRecordContentView: View {
364	434	.font(.caption2)
365	435	.foregroundColor(.secondary)
366	436
367		- if let selectedDraftSessionKind,
368		- let threshold = chargedDevice.resolvedCompletionCurrentAmps(
369		- for: selectedDraftSessionKind.chargingTransportMode,
370		- chargingStateMode: selectedDraftSessionKind.chargingStateMode
371		- ) {
372		- Text("\(selectedDraftSessionKind.shortTitle) stop current: \(threshold.format(decimalDigits: 2)) A")
373		- .font(.caption2)
374		- .foregroundColor(.secondary)
375		- } else if let estimatedCapacity = chargedDevice.estimatedBatteryCapacityWh(
376		- for: chargedDevice.preferredChargingTransportMode
377		- ) {
378		- Text("Estimated \(chargedDevice.preferredChargingTransportMode.title.lowercased()) capacity: \(estimatedCapacity.format(decimalDigits: 2)) Wh")
	437	+ if let estimatedCapacity = chargedDevice.estimatedBatteryCapacityWh {
	438	+ Text("Estimated capacity: \(estimatedCapacity.format(decimalDigits: 2)) Wh")
379	439	.font(.caption2)
380	440	.foregroundColor(.secondary)
381	441	}
	@@ -398,13 +458,17 @@ struct MeterChargeRecordContentView: View {
398	458	Text("Charging Type")
399	459	.font(.subheadline.weight(.semibold))
400	460
401		- Picker("Charging Type", selection: $draftChargingTransportMode) {
402		- ForEach(chargedDevice.supportedChargingModes) { chargingTransportMode in
403		- Label(chargingTransportMode.title, systemImage: chargingTransportMode.symbolName)
404		- .tag(Optional(chargingTransportMode))
	461	+ compactSelectionMenu(
	462	+ title: draftChargingTransportMode?.title ?? "Choose",
	463	+ options: chargedDevice.supportedChargingModes.map { chargingTransportMode in
	464	+ CompactSelectionOption(
	465	+ id: chargingTransportMode.id,
	466	+ title: chargingTransportMode.title,
	467	+ isSelected: draftChargingTransportMode == chargingTransportMode,
	468	+ action: { draftChargingTransportMode = chargingTransportMode }
	469	+ )
405	470	}
406		- }
407		- .pickerStyle(.segmented)
	471	+ )
408	472
409	473	if draftChargingTransportMode == nil {
410	474	Text("Pick the charging type explicitly before starting.")
	@@ -425,13 +489,17 @@ struct MeterChargeRecordContentView: View {
425	489	Text("Charging Mode")
426	490	.font(.subheadline.weight(.semibold))
427	491
428		- Picker("Charging Mode", selection: $draftChargingStateMode) {
429		- ForEach(chargedDevice.supportedChargingStateModes) { chargingStateMode in
430		- Text(chargingStateMode.title)
431		- .tag(Optional(chargingStateMode))
	492	+ compactSelectionMenu(
	493	+ title: draftChargingStateMode?.title ?? "Choose",
	494	+ options: chargedDevice.supportedChargingStateModes.map { chargingStateMode in
	495	+ CompactSelectionOption(
	496	+ id: chargingStateMode.id,
	497	+ title: chargingStateMode.title,
	498	+ isSelected: draftChargingStateMode == chargingStateMode,
	499	+ action: { draftChargingStateMode = chargingStateMode }
	500	+ )
432	501	}
433		- }
434		- .pickerStyle(.segmented)
	502	+ )
435	503
436	504	if draftChargingStateMode == nil {
437	505	Text("Pick whether the device is on or off for this session.")
	@@ -448,22 +516,84 @@ struct MeterChargeRecordContentView: View {
448	516	}
449	517
450	518	VStack(alignment: .leading, spacing: 8) {
451		- Text("Initial Checkpoint")
452		- .font(.subheadline.weight(.semibold))
	519	+ HStack(spacing: 8) {
	520	+ Text("Initial Checkpoint")
	521	+ .font(.subheadline.weight(.semibold))
	522	+ ContextInfoButton(
	523	+ title: "Initial Checkpoint",
	524	+ message: "Use the battery level shown by the device right now when it is known. A known checkpoint improves battery prediction and capacity learning, but the session can also start without one when the level is unavailable."
	525	+ )
	526	+ }
453	527
454		- TextField("Battery %", text: $initialCheckpoint)
455		- .keyboardType(.decimalPad)
	528	+ compactSelectionMenu(
	529	+ title: initialCheckpointMode.title,
	530	+ options: InitialCheckpointMode.allCases.map { mode in
	531	+ CompactSelectionOption(
	532	+ id: mode.id,
	533	+ title: mode.title,
	534	+ isSelected: initialCheckpointMode == mode,
	535	+ action: { initialCheckpointMode = mode }
	536	+ )
	537	+ }
	538	+ )
	539	+
	540	+ if initialCheckpointMode == .known {
	541	+ HStack(spacing: 10) {
	542	+ Button {
	543	+ adjustInitialCheckpoint(by: -1)
	544	+ } label: {
	545	+ Image(systemName: "minus.circle")
	546	+ .font(.title3)
	547	+ }
	548	+ .buttonStyle(.plain)
	549	+
	550	+ TextField("Battery %", text: $initialCheckpoint)
	551	+ .keyboardType(.decimalPad)
	552	+ .textFieldStyle(.roundedBorder)
	553	+ .frame(width: 92)
	554	+
	555	+ Text("%")
	556	+ .font(.subheadline.weight(.semibold))
	557	+ .foregroundColor(.secondary)
	558	+
	559	+ Button {
	560	+ adjustInitialCheckpoint(by: 1)
	561	+ } label: {
	562	+ Image(systemName: "plus.circle")
	563	+ .font(.title3)
	564	+ }
	565	+ .buttonStyle(.plain)
	566	+
	567	+ Spacer()
	568	+ }
	569	+ } else {
	570	+ Text(
	571	+ initialCheckpointMode == .flat
	572	+ ? "Use Flat when the device does not turn on yet. Predictions and capacity estimates stay off until you record a positive battery level."
	573	+ : "Start without an initial battery checkpoint only when the level cannot be read reliably, for example on a device without display."
	574	+ )
	575	+ .font(.caption2)
	576	+ .foregroundColor(.orange)
	577	+ }
456	578
457		- Text("The session starts only after this first checkpoint is recorded.")
458		- .font(.caption2)
459		- .foregroundColor(.secondary)
460	579	}
461	580
462		- Toggle("Auto-stop when the type already has a stop threshold", isOn: $draftAutoStopEnabled)
	581	+ VStack(alignment: .leading, spacing: 8) {
	582	+ Text("Start Requirements")
	583	+ .font(.subheadline.weight(.semibold))
463	584
464		- Text(draftAutoStopDescription)
465		- .font(.footnote)
466		- .foregroundColor(setupWirelessThresholdWarning == nil ? .secondary : .orange)
	585	+ if startRequirements.isEmpty {
	586	+ Label("Everything needed to start is ready.", systemImage: "checkmark.circle.fill")
	587	+ .font(.caption)
	588	+ .foregroundColor(.green)
	589	+ } else {
	590	+ ForEach(startRequirements) { requirement in
	591	+ Label(requirement.message, systemImage: "exclamationmark.circle")
	592	+ .font(.caption)
	593	+ .foregroundColor(.orange)
	594	+ }
	595	+ }
	596	+ }
467	597
468	598	Button("Start Session") {
469	599	startSession()
	@@ -496,7 +626,7 @@ struct MeterChargeRecordContentView: View {
496	626	)
497	627
498	628	VStack(alignment: .leading, spacing: 6) {
499		- Label(selectedCharger.name, systemImage: selectedCharger.deviceClass.symbolName)
	629	+ Label(selectedCharger.name, systemImage: selectedCharger.identitySymbolName)
500	630	.font(.subheadline.weight(.semibold))
501	631
502	632	if let chargerMaximumPowerWatts = selectedCharger.chargerMaximumPowerWatts {
	@@ -525,21 +655,38 @@ struct MeterChargeRecordContentView: View {
525	655	}
526	656
527	657	private func chargingMonitorCard(_ openChargeSession: ChargeSessionSummary) -> some View {
528		- VStack(alignment: .leading, spacing: 12) {
529		- Text("Charging Monitor")
530		- .font(.headline)
	658	+ let displayedEnergyWh = displayedSessionEnergyWh(for: openChargeSession)
	659	+
	660	+ return VStack(alignment: .leading, spacing: 12) {
	661	+ HStack(spacing: 8) {
	662	+ Text("Charging Monitor")
	663	+ .font(.headline)
	664	+ ContextInfoButton(
	665	+ title: "Charging Monitor",
	666	+ message: "The monitor keeps the session explicit: it never auto-selects another device or charger, and it never starts a new session on its own."
	667	+ )
	668	+ }
531	669
532	670	ChargeRecordMetricsTableView(
533	671	labels: ["Type", "Mode", "Energy", "Auto Stop"],
534	672	values: [
535	673	openChargeSession.chargingTransportMode.title,
536	674	openChargeSession.chargingStateMode.title,
537		- "\(openChargeSession.effectiveOrMeasuredEnergyWh.format(decimalDigits: 3)) Wh",
	675	+ "\(displayedEnergyWh.format(decimalDigits: 3)) Wh",
538	676	autoStopLabel(for: openChargeSession)
539	677	]
540	678	)
541	679
542		- if let batteryPrediction = selectedChargedDevice?.batteryLevelPrediction(for: openChargeSession) {
	680	+ if openChargeSession.stopThresholdAmps > 0 {
	681	+ Text("Meter monitor threshold: \(openChargeSession.stopThresholdAmps.format(decimalDigits: 2)) A")
	682	+ .font(.caption)
	683	+ .foregroundColor(.secondary)
	684	+ }
	685	+
	686	+ if let batteryPrediction = selectedChargedDevice?.batteryLevelPrediction(
	687	+ for: openChargeSession,
	688	+ effectiveEnergyWhOverride: displayedEnergyWh
	689	+ ) {
543	690	VStack(alignment: .leading, spacing: 4) {
544	691	Text("Predicted battery level: \(batteryPrediction.predictedPercent.format(decimalDigits: 0))%")
545	692	.font(.caption.weight(.semibold))
	@@ -634,11 +781,12 @@ struct MeterChargeRecordContentView: View {
634	781	.buttonStyle(.plain)
635	782
636	783	if !openChargeSession.checkpoints.isEmpty {
	784	+ let recentCheckpoints = Array(openChargeSession.checkpoints.suffix(6).reversed())
637	785	VStack(alignment: .leading, spacing: 8) {
638	786	Text("Battery Checkpoints")
639	787	.font(.subheadline.weight(.semibold))
640	788
641		- ForEach(openChargeSession.checkpoints.suffix(4), id: \.id) { checkpoint in
	789	+ ForEach(recentCheckpoints, id: \.id) { checkpoint in
642	790	HStack {
643	791	Text(checkpoint.timestamp.format())
644	792	.font(.caption2)
	@@ -651,14 +799,18 @@ struct MeterChargeRecordContentView: View {
651	799	Text("\(checkpoint.measuredEnergyWh.format(decimalDigits: 2)) Wh")
652	800	.font(.caption2)
653	801	.foregroundColor(.secondary)
	802	+ Button {
	803	+ pendingCheckpointDeletion = checkpoint
	804	+ } label: {
	805	+ Image(systemName: "trash")
	806	+ .font(.caption.weight(.semibold))
	807	+ .foregroundColor(.red)
	808	+ }
	809	+ .buttonStyle(.plain)
654	810	}
655	811	}
656	812	}
657	813	}
658		-
659		- Text("The monitor keeps the session explicit: it never auto-selects another device or charger, and it never starts a new session on its own.")
660		- .font(.footnote)
661		- .foregroundColor(.secondary)
662	814	}
663	815	.padding(18)
664	816	.meterCard(tint: .green, fillOpacity: 0.14, strokeOpacity: 0.20)
	@@ -709,16 +861,31 @@ struct MeterChargeRecordContentView: View {
709	861	session: ChargeSessionSummary
710	862	) -> some View {
711	863	VStack(alignment: .leading, spacing: 12) {
712		- Text("Session Chart")
713		- .font(.headline)
	864	+ HStack(spacing: 8) {
	865	+ Text("Session Chart")
	866	+ .font(.headline)
	867	+ ContextInfoButton(
	868	+ title: "Session Chart",
	869	+ message: "The chart is scoped to the explicit session window for \(session.sessionKind.shortTitle.lowercased()) charging."
	870	+ )
	871	+ }
714	872
715		- MeasurementChartView(timeRange: timeRange)
	873	+ GeometryReader { geometry in
	874	+ let chartWidth = max(geometry.size.width, 1)
	875	+ let compactChartLayout = chartWidth < 760
	876	+ let chartHeight = compactChartLayout ? 290.0 : 350.0
	877	+
	878	+ MeasurementChartView(
	879	+ compactLayout: compactChartLayout,
	880	+ availableSize: CGSize(width: chartWidth, height: chartHeight),
	881	+ timeRange: timeRange,
	882	+ showsRangeSelector: false,
	883	+ rebasesEnergyToVisibleRangeStart: true
	884	+ )
716	885	.environmentObject(usbMeter.measurements)
717		- .frame(minHeight: 220)
718		-
719		- Text("The chart is scoped to the explicit session window for \(session.sessionKind.shortTitle.lowercased()) charging.")
720		- .font(.footnote)
721		- .foregroundColor(.secondary)
	886	+ .frame(maxWidth: .infinity, alignment: .topLeading)
	887	+ }
	888	+ .frame(height: 350)
722	889	}
723	890	.padding(18)
724	891	.meterCard(tint: .blue, fillOpacity: 0.14, strokeOpacity: 0.20)
	@@ -726,32 +893,42 @@ struct MeterChargeRecordContentView: View {
726	893
727	894	private var meterTotalsCard: some View {
728	895	VStack(alignment: .leading, spacing: 12) {
729		- Text("Meter Totals")
730		- .font(.headline)
	896	+ HStack(spacing: 8) {
	897	+ Text("Meter Recorder")
	898	+ .font(.headline)
	899	+
	900	+ Spacer(minLength: 0)
	901	+
	902	+ Button {
	903	+ showsMeterTotalsInfo.toggle()
	904	+ } label: {
	905	+ Image(systemName: "info.circle")
	906	+ .font(.body.weight(.semibold))
	907	+ .foregroundColor(.secondary)
	908	+ }
	909	+ .buttonStyle(.plain)
	910	+ .accessibilityLabel("Meter recorder info")
	911	+ .popover(isPresented: $showsMeterTotalsInfo, arrowEdge: .top) {
	912	+ VStack(alignment: .leading, spacing: 10) {
	913	+ Text("Meter Recorder")
	914	+ .font(.headline)
	915	+ Text("These values come directly from the meter's built-in recorder. Keep them visible while comparing the app session against what the meter captured on its own.")
	916	+ .font(.body)
	917	+ .fixedSize(horizontal: false, vertical: true)
	918	+ }
	919	+ .padding(16)
	920	+ .frame(width: 280, alignment: .leading)
	921	+ }
	922	+ }
731	923
732	924	ChargeRecordMetricsTableView(
733		- labels: ["Capacity", "Energy", "Duration", "Meter Threshold"],
	925	+ labels: ["Energy", "Duration", "Meter Threshold"],
734	926	values: [
735		- "\(usbMeter.recordedAH.format(decimalDigits: 3)) Ah",
736	927	"\(usbMeter.recordedWH.format(decimalDigits: 3)) Wh",
737	928	usbMeter.recordingDurationDescription,
738	929	usbMeter.supportsRecordingThreshold ? "\(usbMeter.recordingTreshold.format(decimalDigits: 2)) A" : "Read-only"
739	930	]
740	931	)
741		-
742		- Text("These values come directly from the meter and remain separate from the explicit app session controls.")
743		- .font(.footnote)
744		- .foregroundColor(.secondary)
745		-
746		- if usbMeter.supportsDataGroupCommands {
747		- Button("Reset Active Group") {
748		- usbMeter.clear()
749		- }
750		- .frame(maxWidth: .infinity)
751		- .padding(.vertical, 10)
752		- .meterCard(tint: .red, fillOpacity: 0.16, strokeOpacity: 0.22, cornerRadius: 14)
753		- .buttonStyle(.plain)
754		- }
755	932	}
756	933	.padding(18)
757	934	.meterCard(tint: .teal, fillOpacity: 0.14, strokeOpacity: 0.20)
	@@ -775,6 +952,23 @@ struct MeterChargeRecordContentView: View {
775	952	return "Learning"
776	953	}
777	954
	955	+ private func displayedSessionEnergyWh(for session: ChargeSessionSummary) -> Double {
	956	+ let storedEnergyWh = session.effectiveOrMeasuredEnergyWh
	957	+ guard session.status.isOpen else {
	958	+ return storedEnergyWh
	959	+ }
	960	+
	961	+ guard session.meterMACAddress == meterMACAddress else {
	962	+ return storedEnergyWh
	963	+ }
	964	+
	965	+ if let baselineEnergyWh = session.meterEnergyBaselineWh {
	966	+ return max(storedEnergyWh, max(usbMeter.recordedWH - baselineEnergyWh, 0))
	967	+ }
	968	+
	969	+ return storedEnergyWh
	970	+ }
	971	+
778	972	private func sessionWarning(for session: ChargeSessionSummary) -> String? {
779	973	guard session.chargingTransportMode == .wireless,
780	974	let chargerID = session.chargerID,
	@@ -792,8 +986,7 @@ struct MeterChargeRecordContentView: View {
792	986	private func startSession() {
793	987	guard let selectedChargedDevice,
794	988	let chargingTransportMode = selectedDraftTransportMode,
795		- let chargingStateMode = selectedDraftChargingStateMode,
796		- let initialCheckpointValue else {
	989	+ let chargingStateMode = selectedDraftChargingStateMode else {
797	990	return
798	991	}
799	992
	@@ -804,27 +997,37 @@ struct MeterChargeRecordContentView: View {
804	997	chargerID: chargerID,
805	998	chargingTransportMode: chargingTransportMode,
806	999	chargingStateMode: chargingStateMode,
807		- autoStopEnabled: draftAutoStopEnabled,
808		- initialBatteryPercent: initialCheckpointValue
	1000	+ autoStopEnabled: false,
	1001	+ initialBatteryPercent: initialCheckpointMode == .known ? initialCheckpointValue : nil,
	1002	+ startsFromFlatBattery: initialCheckpointMode == .flat
809	1003	)
810	1004
811	1005	if didStart {
812	1006	initialCheckpoint = ""
	1007	+ initialCheckpointMode = .known
	1008	+ }
	1009	+ }
	1010	+
	1011	+ private func adjustInitialCheckpoint(by delta: Double) {
	1012	+ guard initialCheckpointMode == .known else {
	1013	+ return
813	1014	}
	1015	+
	1016	+ let currentValue = initialCheckpointValue ?? 0
	1017	+ let nextValue = min(max(currentValue + delta, 0), 100)
	1018	+ initialCheckpoint = nextValue.format(decimalDigits: 0)
814	1019	}
815	1020
816	1021	private func syncDraftSelections() {
817	1022	guard let selectedChargedDevice else {
818	1023	draftChargingTransportMode = nil
819	1024	draftChargingStateMode = nil
820		- draftAutoStopEnabled = true
821	1025	return
822	1026	}
823	1027
824	1028	if let openChargeSession {
825	1029	draftChargingTransportMode = openChargeSession.chargingTransportMode
826	1030	draftChargingStateMode = openChargeSession.chargingStateMode
827		- draftAutoStopEnabled = openChargeSession.autoStopEnabled
828	1031	return
829	1032	}
830	1033
	@@ -842,10 +1045,53 @@ struct MeterChargeRecordContentView: View {
842	1045	draftChargingTransportMode = selectedChargedDevice.supportedChargingModes.first
843	1046	}
844	1047
845		- if selectedChargedDevice.supportedChargingStateModes.count == 1 {
	1048	+ if let draftChargingTransportMode {
	1049	+ draftChargingStateMode = draftChargingStateMode
	1050	+ ?? selectedChargedDevice.defaultChargingStateMode(for: draftChargingTransportMode)
	1051	+ } else if selectedChargedDevice.supportedChargingStateModes.count == 1 {
846	1052	draftChargingStateMode = selectedChargedDevice.supportedChargingStateModes.first
847	1053	}
848	1054	}
	1055	+
	1056	+ private struct CompactSelectionOption: Identifiable {
	1057	+ let id: String
	1058	+ let title: String
	1059	+ let isSelected: Bool
	1060	+ let action: () -> Void
	1061	+ }
	1062	+
	1063	+ private func compactSelectionMenu(
	1064	+ title: String,
	1065	+ options: [CompactSelectionOption]
	1066	+ ) -> some View {
	1067	+ Menu {
	1068	+ ForEach(options) { option in
	1069	+ Button {
	1070	+ option.action()
	1071	+ } label: {
	1072	+ if option.isSelected {
	1073	+ Label(option.title, systemImage: "checkmark")
	1074	+ } else {
	1075	+ Text(option.title)
	1076	+ }
	1077	+ }
	1078	+ }
	1079	+ } label: {
	1080	+ HStack(spacing: 8) {
	1081	+ Text(title)
	1082	+ .foregroundColor(.primary)
	1083	+ Spacer()
	1084	+ Image(systemName: "chevron.up.chevron.down")
	1085	+ .font(.caption.weight(.semibold))
	1086	+ .foregroundColor(.secondary)
	1087	+ }
	1088	+ .padding(.horizontal, 12)
	1089	+ .padding(.vertical, 9)
	1090	+ .frame(width: 180, alignment: .leading)
	1091	+ .meterCard(tint: .secondary, fillOpacity: 0.08, strokeOpacity: 0.14, cornerRadius: 12)
	1092	+ }
	1093	+ .buttonStyle(.plain)
	1094	+ }
849	1095	}
850	1096
851	1097	struct ChargeSessionCompletionSheetView: View {
	@@ -863,17 +1109,18 @@ struct ChargeSessionCompletionSheetView: View {
863	1109	var body: some View {
864	1110	NavigationView {
865	1111	Form {
866		- Section(header: Text("Final Checkpoint")) {
	1112	+ Section(
	1113	+ header: ContextInfoHeader(
	1114	+ title: "Final Checkpoint",
	1115	+ message: explanation
	1116	+ )
	1117	+ ) {
867	1118	TextField("Battery %", text: $batteryPercent)
868	1119	.keyboardType(.decimalPad)
869	1120	TextField("Label", text: $label)
870	1121	}
871	1122
872	1123	Section {
873		- Text(explanation)
874		- .font(.footnote)
875		- .foregroundColor(.secondary)
876		-
877	1124	if let sessionWarning {
878	1125	Text(sessionWarning)
879	1126	.font(.footnote)

+10 -7

USB Meter/Views/Meter/Tabs/DataGroups/MeterDataGroupsTabView.swift

View

@@ -10,7 +10,7 @@ struct MeterDataGroupsTabView: View {
 
     var body: some View {
         GeometryReader { box in
-            let columnTitles = [usbMeter.supportsDataGroupCommands ? "Group" : "Memory", "Ah"]
+            let columnTitles = [usbMeter.supportsDataGroupCommands ? "Group" : "Memory"]
                 + (usbMeter.showsDataGroupEnergy ? ["Wh"] : [])
                 + (usbMeter.supportsDataGroupCommands ? ["Clear"] : [])
             let columnWidth = (box.size.width - 60) / CGFloat(columnTitles.count)
@@ -18,12 +18,15 @@ struct MeterDataGroupsTabView: View {
             ScrollView {
                 VStack(alignment: .leading, spacing: 14) {
                     VStack(alignment: .leading, spacing: 8) {
-                        Text(usbMeter.dataGroupsTitle)
-                            .font(.system(.title3, design: .rounded).weight(.bold))
-                        if let hint = usbMeter.dataGroupsHint {
-                            Text(hint)
-                                .font(.footnote)
-                                .foregroundColor(.secondary)
+                        HStack(spacing: 8) {
+                            Text(usbMeter.dataGroupsTitle)
+                                .font(.system(.title3, design: .rounded).weight(.bold))
+                            if let hint = usbMeter.dataGroupsHint {
+                                ContextInfoButton(
+                                    title: usbMeter.dataGroupsTitle,
+                                    message: hint
+                                )
+                            }
                         }
                     }
                     .padding(18)


+12 -6

USB Meter/Views/Meter/Tabs/Home/Subviews/MeterOverviewSectionView.swift

View

@@ -12,9 +12,20 @@ import SwiftUI
 struct MeterOverviewSectionView: View {
     let meter: Meter
 
+    private var overviewInfoMessage: String? {
+        guard meter.operationalState != .dataIsAvailable else {
+            return nil
+        }
+        return "Connect to the meter to load firmware, serial, and boot details."
+    }
+
     var body: some View {
         VStack(spacing: 14) {
-            MeterInfoCardView(title: "Overview", tint: meter.color) {
+            MeterInfoCardView(
+                title: "Overview",
+                infoMessage: overviewInfoMessage,
+                tint: meter.color
+            ) {
                 MeterInfoRowView(label: "Name", value: meter.name)
                 MeterInfoRowView(label: "Device Model", value: meter.deviceModelName)
                 MeterInfoRowView(label: "Advertised Model", value: meter.modelString)
@@ -36,11 +47,6 @@ struct MeterOverviewSectionView: View {
                     if meter.bootCount != 0 {
                         MeterInfoRowView(label: "Boot Count", value: "\(meter.bootCount)")
                     }
-                } else {
-                    Text("Connect to the meter to load firmware, serial, and boot details.")
-                        .font(.footnote)
-                        .foregroundColor(.secondary)
-                        .multilineTextAlignment(.leading)
                 }
             }
 


+35 -22

USB Meter/Views/Meter/Tabs/Live/Subviews/MeterLiveContentView.swift

View

@@ -394,11 +394,14 @@ private struct PowerAverageSheetView: View {
             ScrollView {
                 VStack(alignment: .leading, spacing: 14) {
                     VStack(alignment: .leading, spacing: 8) {
-                        Text("Power Average")
-                            .font(.system(.title3, design: .rounded).weight(.bold))
-                        Text("Inspect the recent power buffer, choose how many values to include, and compute the average power over that window.")
-                            .font(.footnote)
-                            .foregroundColor(.secondary)
+                        HStack(spacing: 8) {
+                            Text("Power Average")
+                                .font(.system(.title3, design: .rounded).weight(.bold))
+                            ContextInfoButton(
+                                title: "Power Average",
+                                message: "Inspect the recent power buffer, choose how many values to include, and compute the average power over that window."
+                            )
+                        }
                     }
                     .padding(18)
                     .meterCard(tint: .pink, fillOpacity: 0.18, strokeOpacity: 0.24)
@@ -435,11 +438,11 @@ private struct PowerAverageSheetView: View {
                         }
                     }
 
-                    MeterInfoCardView(title: "Buffer Actions", tint: .secondary) {
-                        Text("Reset clears the captured live measurement buffer for power, energy, voltage, current, temperature, and RSSI.")
-                            .font(.footnote)
-                            .foregroundColor(.secondary)
-
+                    MeterInfoCardView(
+                        title: "Buffer Actions",
+                        infoMessage: "Reset clears the captured live measurement buffer for power, energy, voltage, current, temperature, and RSSI.",
+                        tint: .secondary
+                    ) {
                         Button("Reset Buffer") {
                             measurements.resetSeries()
                             selectedSampleCount = defaultSampleCount(bufferedSamples: measurements.powerSampleCount(flushPendingValues: false))
@@ -533,11 +536,14 @@ private struct RSSIHistorySheetView: View {
             ScrollView {
                 VStack(alignment: .leading, spacing: 14) {
                     VStack(alignment: .leading, spacing: 8) {
-                        Text("RSSI History")
-                            .font(.system(.title3, design: .rounded).weight(.bold))
-                        Text("Signal strength captured over time while the meter stays connected.")
-                            .font(.footnote)
-                            .foregroundColor(.secondary)
+                        HStack(spacing: 8) {
+                            Text("RSSI History")
+                                .font(.system(.title3, design: .rounded).weight(.bold))
+                            ContextInfoButton(
+                                title: "RSSI History",
+                                message: "Signal strength captured over time while the meter stays connected."
+                            )
+                        }
                     }
                     .padding(18)
                     .meterCard(tint: .mint, fillOpacity: 0.18, strokeOpacity: 0.24)
@@ -717,11 +723,14 @@ private struct EnergyProjectionSheetView: View {
             ScrollView {
                 VStack(alignment: .leading, spacing: 14) {
                     VStack(alignment: .leading, spacing: 8) {
-                        Text("Energy Projections")
-                            .font(.system(.title3, design: .rounded).weight(.bold))
-                        Text("Projected consumption is estimated from multiple real windows in the live buffer. A method is shown only when that full interval exists in the recent continuous data.")
-                            .font(.footnote)
-                            .foregroundColor(.secondary)
+                        HStack(spacing: 8) {
+                            Text("Energy Projections")
+                                .font(.system(.title3, design: .rounded).weight(.bold))
+                            ContextInfoButton(
+                                title: "Energy Projections",
+                                message: "Projected consumption is estimated from multiple real windows in the live buffer. A method is shown only when that full interval exists in the recent continuous data."
+                            )
+                        }
                     }
                     .padding(18)
                     .meterCard(tint: .teal, fillOpacity: 0.18, strokeOpacity: 0.24)
@@ -751,9 +760,13 @@ private struct EnergyProjectionSheetView: View {
                         }
                     }
 
-                    MeterInfoCardView(title: "Projection Method", tint: .teal) {
+                    MeterInfoCardView(
+                        title: "Projection Method",
+                        infoMessage: "Projection methods appear after the live buffer contains at least one continuous interval with enough data to estimate a rate.",
+                        tint: .teal
+                    ) {
                         if projectionVariants.isEmpty {
-                            Text("Projection methods appear after the live buffer contains at least one continuous interval with enough data to estimate a rate.")
+                            Text("No projection methods available yet.")
                                 .font(.footnote)
                                 .foregroundColor(.secondary)
                         } else {


+26 -25

USB Meter/Views/Meter/Tabs/Settings/MeterSettingsTabView.swift

View

@@ -39,10 +39,11 @@ struct MeterSettingsTabView: View {
                     }
 
                     if meter.operationalState == .dataIsAvailable && meter.supportsManualTemperatureUnitSelection {
-                        settingsCard(title: "Meter Temperature Unit", tint: .orange) {
-                            Text("TC66 temperature is shown as degrees without assuming Celsius or Fahrenheit. Keep this matched to the unit configured on the device so you can interpret the reading correctly.")
-                                .font(.footnote)
-                                .foregroundColor(.secondary)
+                    settingsCard(
+                        title: "Meter Temperature Unit",
+                        infoMessage: "TC66 temperature is shown as degrees without assuming Celsius or Fahrenheit. Keep this matched to the unit configured on the device so you can interpret the reading correctly.",
+                        tint: .orange
+                    ) {
                             Picker("", selection: $meter.tc66TemperatureUnitPreference) {
                                 ForEach(TemperatureUnitPreference.allCases) { unit in
                                     Text(unit.title).tag(unit)
@@ -53,29 +54,23 @@ struct MeterSettingsTabView: View {
                     }
 
                     if meter.operationalState == .dataIsAvailable && meter.model == .TC66C {
-                        settingsCard(title: "Screen Reporting", tint: .orange) {
+                        settingsCard(
+                            title: "Screen Reporting",
+                            infoMessage: "TC66 is the exception: it does not report the current screen in the payload, so the app keeps this note here instead of showing it on the home screen.",
+                            tint: .orange
+                        ) {
                             MeterInfoRowView(label: "Current Screen", value: "Not Reported")
-                            Text("TC66 is the exception: it does not report the current screen in the payload, so the app keeps this note here instead of showing it on the home screen.")
-                                .font(.footnote)
-                                .foregroundColor(.secondary)
                         }
                     }
 
                     if meter.operationalState == .dataIsAvailable {
                         settingsCard(
                             title: meter.reportsCurrentScreenIndex ? "Screen Controls" : "Page Controls",
+                            infoMessage: meter.reportsCurrentScreenIndex
+                                ? "Use these controls when you want to change the screen shown on the device without crowding the main meter view."
+                                : "Use these controls when you want to switch device pages without crowding the main meter view.",
                             tint: .indigo
                         ) {
-                            if meter.reportsCurrentScreenIndex {
-                                Text("Use these controls when you want to change the screen shown on the device without crowding the main meter view.")
-                                    .font(.footnote)
-                                    .foregroundColor(.secondary)
-                            } else {
-                                Text("Use these controls when you want to switch device pages without crowding the main meter view.")
-                                    .font(.footnote)
-                                    .foregroundColor(.secondary)
-                            }
-
                             MeterScreenControlsView(showsHeader: false)
                         }
                     }
@@ -110,11 +105,11 @@ struct MeterSettingsTabView: View {
                         }
                     }
 
-                    settingsCard(title: "Danger Zone", tint: .red) {
-                        Text("Delete this meter from the sidebar and clear its saved metadata. If the device is still nearby, it can appear again after a fresh Bluetooth discovery.")
-                            .font(.footnote)
-                            .foregroundColor(.secondary)
-
+                    settingsCard(
+                        title: "Danger Zone",
+                        infoMessage: "Delete this meter from the sidebar and clear its saved metadata. If the device is still nearby, it can appear again after a fresh Bluetooth discovery.",
+                        tint: .red
+                    ) {
                         Button("Delete Meter") {
                             deleteConfirmationVisibility = true
                         }
@@ -186,12 +181,18 @@ struct MeterSettingsTabView: View {
 
     private func settingsCard<Content: View>(
         title: String,
+        infoMessage: String? = nil,
         tint: Color,
         @ViewBuilder content: () -> Content
     ) -> some View {
         VStack(alignment: .leading, spacing: 12) {
-            Text(title)
-                .font(.headline)
+            HStack(spacing: 8) {
+                Text(title)
+                    .font(.headline)
+                if let infoMessage {
+                    ContextInfoButton(title: title, message: infoMessage)
+                }
+            }
             content()
         }
         .padding(18)


+34 -20

USB Meter/Views/MeterDetailView.swift

View

@@ -76,8 +76,14 @@ struct MeterDetailView: View {
 
     private var statusCard: some View {
         VStack(alignment: .leading, spacing: 10) {
-            Text("Status")
-                .font(.headline)
+            HStack(spacing: 8) {
+                Text("Status")
+                    .font(.headline)
+                ContextInfoButton(
+                    title: "Status",
+                    message: "The meter is not currently connected. Bring it within Bluetooth range or wake it up to open live diagnostics."
+                )
+            }
             HStack(spacing: 8) {
                 Circle()
                     .fill(meterSummary.tint)
@@ -86,9 +92,6 @@ struct MeterDetailView: View {
                     .font(.caption.weight(.semibold))
                     .foregroundColor(.secondary)
             }
-            Text("The meter is not currently connected. Bring it within Bluetooth range or wake it up to open live diagnostics.")
-                .font(.caption)
-                .foregroundColor(.secondary)
         }
         .frame(maxWidth: .infinity, alignment: .leading)
         .padding(18)
@@ -113,11 +116,17 @@ struct MeterDetailView: View {
         let chargedDevices = appData.chargedDevices(for: meterSummary.macAddress)
 
         return VStack(alignment: .leading, spacing: 10) {
-            Text("Devices")
-                .font(.headline)
+            HStack(spacing: 8) {
+                Text("Devices")
+                    .font(.headline)
+                ContextInfoButton(
+                    title: "Devices",
+                    message: "Link devices to this meter from Charge Record to keep capacity learning and charge curves tied to the right hardware."
+                )
+            }
 
             if chargedDevices.isEmpty {
-                Text("No devices are linked to this meter yet. Connect it, open Charge Record, and select the device being charged to start learning capacity and charge curves.")
+                Text("No devices linked yet.")
                     .font(.caption)
                     .foregroundColor(.secondary)
             } else {
@@ -127,7 +136,7 @@ struct MeterDetailView: View {
                             ChargedDeviceQRCodeView(qrIdentifier: chargedDevice.qrIdentifier, side: 52)
 
                             VStack(alignment: .leading, spacing: 4) {
-                                Label(chargedDevice.name, systemImage: chargedDevice.deviceClass.symbolName)
+                                Label(chargedDevice.name, systemImage: chargedDevice.identitySymbolName)
                                     .font(.subheadline.weight(.semibold))
                                 Text(chargedDevice.estimatedBatteryCapacityWh.map { "\($0.format(decimalDigits: 2)) Wh" } ?? "Capacity: learning")
                                     .font(.caption)
@@ -150,11 +159,17 @@ struct MeterDetailView: View {
         let chargers = appData.chargers(for: meterSummary.macAddress)
 
         return VStack(alignment: .leading, spacing: 10) {
-            Text("Chargers")
-                .font(.headline)
+            HStack(spacing: 8) {
+                Text("Chargers")
+                    .font(.headline)
+                ContextInfoButton(
+                    title: "Chargers",
+                    message: "Link chargers to this meter for wireless sessions so the app can keep charger-specific learning and efficiency data separate."
+                )
+            }
 
             if chargers.isEmpty {
-                Text("No chargers are linked to this meter yet. Pick one from Charge Record when you monitor a wireless charging session.")
+                Text("No chargers linked yet.")
                     .font(.caption)
                     .foregroundColor(.secondary)
             } else {
@@ -164,7 +179,7 @@ struct MeterDetailView: View {
                             ChargedDeviceQRCodeView(qrIdentifier: charger.qrIdentifier, side: 52)
 
                             VStack(alignment: .leading, spacing: 4) {
-                                Label(charger.name, systemImage: charger.deviceClass.symbolName)
+                                Label(charger.name, systemImage: charger.identitySymbolName)
                                     .font(.subheadline.weight(.semibold))
                                 Text(charger.chargerMaximumPowerWatts.map { "Max power: \($0.format(decimalDigits: 2)) W" } ?? "Wireless charger")
                                     .font(.caption)
@@ -233,7 +248,12 @@ struct MeterEditorSheetView: View {
     var body: some View {
         NavigationView {
             Form {
-                Section(header: Text("Identity")) {
+                Section(
+                    header: ContextInfoHeader(
+                        title: "Identity",
+                        message: "Use the real BLE MAC address format `AA:BB:CC:DD:EE:FF`. Saved meters remain visible in the sidebar even when they are currently offline."
+                    )
+                ) {
                     TextField("Display name", text: $customName)
                     TextField("MAC Address", text: $macAddress)
                         .textInputAutocapitalization(.characters)
@@ -249,12 +269,6 @@ struct MeterEditorSheetView: View {
 
                     TextField("Advertised name", text: $advertisedName)
                 }
-
-                Section {
-                    Text("Use the real BLE MAC address format `AA:BB:CC:DD:EE:FF`. Saved meters remain visible in the sidebar even when they are currently offline.")
-                        .font(.footnote)
-                        .foregroundColor(.secondary)
-                }
             }
             .navigationTitle(existingMeterSummary == nil ? "New Meter" : "Edit Meter")
             .navigationBarTitleDisplayMode(.inline)


+4 -4

USB Meter/Views/MeterMappingDebugView.swift

View

@@ -17,16 +17,16 @@ struct MeterMappingDebugView: View {
                 VStack(alignment: .leading, spacing: 8) {
                     Text(store.currentCloudAvailability.helpTitle)
                         .font(.headline)
-                    Text("This screen is limited to meter sync metadata visible on this device through the local store and iCloud KVS.")
-                        .font(.caption)
-                        .foregroundColor(.secondary)
                     Text(store.currentCloudAvailability.helpMessage)
                         .font(.caption)
                         .foregroundColor(.secondary)
                 }
                 .padding(.vertical, 6)
             } header: {
-                Text("Sync Status")
+                ContextInfoHeader(
+                    title: "Sync Status",
+                    message: "This screen is limited to meter sync metadata visible on this device through the local store and iCloud KVS."
+                )
             }
 
             Section {


+7 -5

USB Meter/Views/Sidebar/SidebarList/Sections/Help/Components/SidebarBluetoothStatusCardView.swift

View

@@ -11,20 +11,22 @@ struct SidebarBluetoothStatusCardView: View {
 
     var body: some View {
         VStack(alignment: .leading, spacing: 6) {
-            HStack {
+            HStack(spacing: 8) {
                 Label("Bluetooth", systemImage: "bolt.horizontal.circle.fill")
                     .font(.footnote.weight(.semibold))
                     .foregroundColor(tint)
+                ContextInfoButton(
+                    title: "Bluetooth",
+                    message: "Refer to this adapter state while walking through the Bluetooth and Device troubleshooting steps.",
+                    popoverWidth: 300
+                )
                 Spacer()
                 Text(statusText)
                     .font(.caption.weight(.semibold))
                     .foregroundColor(.secondary)
             }
-            Text("Refer to this adapter state while walking through the Bluetooth and Device troubleshooting steps.")
-                .font(.caption2)
-                .foregroundColor(.secondary)
         }
         .padding(14)
         .meterCard(tint: tint, fillOpacity: 0.22, strokeOpacity: 0.26, cornerRadius: 18)
     }
-}
+}


+2 -2

USB Meter/Views/Sidebar/SidebarView.swift

View

@@ -60,13 +60,13 @@ struct SidebarView: View {
             case .device:
                 ChargedDeviceEditorSheetView(
                     meterMACAddress: nil,
-                    suggestedDeviceClass: .iphone
+                    kind: .device
                 )
                 .environmentObject(appData)
             case .charger:
                 ChargedDeviceEditorSheetView(
                     meterMACAddress: nil,
-                    suggestedDeviceClass: .charger
+                    kind: .charger
                 )
                 .environmentObject(appData)
             }


	@@ -130,6 +130,7 @@
130	130	C100001C3C8E4A7A00A1001C /* USB_Meter 7.xcdatamodel */ = {isa = PBXFileReference; lastKnownFileType = wrapper.xcdatamodel; path = "USB_Meter 7.xcdatamodel"; sourceTree = "<group>"; };
131	131	C100001D3C8E4A7A00A1001D /* USB_Meter 8.xcdatamodel */ = {isa = PBXFileReference; lastKnownFileType = wrapper.xcdatamodel; path = "USB_Meter 8.xcdatamodel"; sourceTree = "<group>"; };
132	132	C100001E3C8E4A7A00A1001E /* USB_Meter 9.xcdatamodel */ = {isa = PBXFileReference; lastKnownFileType = wrapper.xcdatamodel; path = "USB_Meter 9.xcdatamodel"; sourceTree = "<group>"; };
	133	+ C10000223C8E4A7A00A10022 /* USB_Meter 10.xcdatamodel */ = {isa = PBXFileReference; lastKnownFileType = wrapper.xcdatamodel; path = "USB_Meter 10.xcdatamodel"; sourceTree = "<group>"; };
133	134	430CB4FB245E07EB006525C2 /* ChevronView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ChevronView.swift; sourceTree = "<group>"; };
134	135	4311E639241384960080EA59 /* DeviceHelpView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = DeviceHelpView.swift; sourceTree = "<group>"; };
135	136	4327461A24619CED0009BE4B /* MeterRowView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MeterRowView.swift; sourceTree = "<group>"; };
	@@ -829,8 +830,9 @@
829	830	C100001C3C8E4A7A00A1001C /* USB_Meter 7.xcdatamodel */,
830	831	C100001D3C8E4A7A00A1001D /* USB_Meter 8.xcdatamodel */,
831	832	C100001E3C8E4A7A00A1001E /* USB_Meter 9.xcdatamodel */,
	833	+ C10000223C8E4A7A00A10022 /* USB_Meter 10.xcdatamodel */,
832	834	);
833		- currentVersion = C100001E3C8E4A7A00A1001E /* USB_Meter 9.xcdatamodel */;
	835	+ currentVersion = C10000223C8E4A7A00A10022 /* USB_Meter 10.xcdatamodel */;
834	836	path = CKModel.xcdatamodeld;
835	837	sourceTree = "<group>";
836	838	versionGroupType = wrapper.xcdatamodel;

	@@ -233,7 +233,7 @@ class AppDelegate: UIResponder, UIApplicationDelegate, UNUserNotificationCenterD
233	233	}
234	234
235	235	container.viewContext.automaticallyMergesChangesFromParent = true
236		- container.viewContext.mergePolicy = NSMergeByPropertyStoreTrumpMergePolicy
	236	+ container.viewContext.mergePolicy = NSMergeByPropertyObjectTrumpMergePolicy
237	237	return container
238	238	}()
239	239

	@@ -12,6 +12,15 @@ import CoreBluetooth
12	12	import CoreData
13	13	import UserNotifications
14	14
	15	+struct BatteryCheckpointPlausibilityWarning: Identifiable, Hashable {
	16	+ let title: String
	17	+ let message: String
	18	+
	19	+ var id: String {
	20	+ "\(title)\n\(message)"
	21	+ }
	22	+}
	23	+
15	24	final class AppData : ObservableObject {
16	25	struct MeterSummary: Identifiable {
17	26	let macAddress: String
	@@ -77,7 +86,7 @@ final class AppData : ObservableObject {
77	86	}
78	87
79	88	context.automaticallyMergesChangesFromParent = true
80		- context.mergePolicy = NSMergeByPropertyStoreTrumpMergePolicy
	89	+ context.mergePolicy = NSMergeByPropertyObjectTrumpMergePolicy
81	90	chargeInsightsStore = ChargeInsightsStore(context: context)
82	91
83	92	chargeInsightsStoreObserver = NotificationCenter.default.publisher(
	@@ -143,6 +152,15 @@ final class AppData : ObservableObject {
143	152	chargedDevices.first(where: { $0.id == id })
144	153	}
145	154
	155	+ func chargeSessionSummary(id: UUID) -> ChargeSessionSummary? {
	156	+ for chargedDevice in chargedDevices {
	157	+ if let session = chargedDevice.sessions.first(where: { $0.id == id }) {
	158	+ return session
	159	+ }
	160	+ }
	161	+ return nil
	162	+ }
	163	+
146	164	func chargedDevices(for meterMACAddress: String) -> [ChargedDeviceSummary] {
147	165	let normalizedMAC = meterMACAddress.trimmingCharacters(in: .whitespacesAndNewlines).uppercased()
148	166	return chargedDevices.filter { chargedDevice in
	@@ -201,25 +219,23 @@ final class AppData : ObservableObject {
201	219	}
202	220
203	221	@discardableResult
204		- func createChargedDevice(
	222	+ func createDevice(
205	223	name: String,
206	224	deviceClass: ChargedDeviceClass,
207	225	chargingStateAvailability: ChargingStateAvailability,
208	226	supportsWiredCharging: Bool,
209	227	supportsWirelessCharging: Bool,
210		- preferredChargingTransportMode: ChargingTransportMode,
211	228	wirelessChargingProfile: WirelessChargingProfile,
212	229	configuredCompletionCurrents: [ChargeSessionKind: Double],
213	230	notes: String?,
214	231	meterMACAddress: String?
215	232	) -> Bool {
216		- let didSave = chargeInsightsStore?.createChargedDevice(
	233	+ let didSave = chargeInsightsStore?.createDevice(
217	234	name: name,
218	235	deviceClass: deviceClass,
219	236	chargingStateAvailability: chargingStateAvailability,
220	237	supportsWiredCharging: supportsWiredCharging,
221	238	supportsWirelessCharging: supportsWirelessCharging,
222		- preferredChargingTransportMode: preferredChargingTransportMode,
223	239	wirelessChargingProfile: wirelessChargingProfile,
224	240	configuredCompletionCurrents: configuredCompletionCurrents,
225	241	notes: notes,
	@@ -234,26 +250,43 @@ final class AppData : ObservableObject {
234	250	}
235	251
236	252	@discardableResult
237		- func updateChargedDevice(
	253	+ func createCharger(
	254	+ name: String,
	255	+ notes: String?,
	256	+ meterMACAddress: String?
	257	+ ) -> Bool {
	258	+ let didSave = chargeInsightsStore?.createCharger(
	259	+ name: name,
	260	+ notes: notes,
	261	+ assignTo: meterMACAddress
	262	+ ) ?? false
	263	+
	264	+ if didSave {
	265	+ reloadChargedDevices()
	266	+ }
	267	+
	268	+ return didSave
	269	+ }
	270	+
	271	+ @discardableResult
	272	+ func updateDevice(
238	273	id: UUID,
239	274	name: String,
240	275	deviceClass: ChargedDeviceClass,
241	276	chargingStateAvailability: ChargingStateAvailability,
242	277	supportsWiredCharging: Bool,
243	278	supportsWirelessCharging: Bool,
244		- preferredChargingTransportMode: ChargingTransportMode,
245	279	wirelessChargingProfile: WirelessChargingProfile,
246	280	configuredCompletionCurrents: [ChargeSessionKind: Double],
247	281	notes: String?
248	282	) -> Bool {
249		- let didSave = chargeInsightsStore?.updateChargedDevice(
	283	+ let didSave = chargeInsightsStore?.updateDevice(
250	284	id: id,
251	285	name: name,
252	286	deviceClass: deviceClass,
253	287	chargingStateAvailability: chargingStateAvailability,
254	288	supportsWiredCharging: supportsWiredCharging,
255	289	supportsWirelessCharging: supportsWirelessCharging,
256		- preferredChargingTransportMode: preferredChargingTransportMode,
257	290	wirelessChargingProfile: wirelessChargingProfile,
258	291	configuredCompletionCurrents: configuredCompletionCurrents,
259	292	notes: notes
	@@ -267,10 +300,15 @@ final class AppData : ObservableObject {
267	300	}
268	301
269	302	@discardableResult
270		- func setChargingTransportMode(_ chargingTransportMode: ChargingTransportMode, for meter: Meter) -> Bool {
271		- let didSave = chargeInsightsStore?.setChargingTransportMode(
272		- chargingTransportMode,
273		- for: meter.btSerial.macAddress.description
	303	+ func updateCharger(
	304	+ id: UUID,
	305	+ name: String,
	306	+ notes: String?
	307	+ ) -> Bool {
	308	+ let didSave = chargeInsightsStore?.updateCharger(
	309	+ id: id,
	310	+ name: name,
	311	+ notes: notes
274	312	) ?? false
275	313
276	314	if didSave {
	@@ -298,6 +336,16 @@ final class AppData : ObservableObject {
298	336	return didSave
299	337	}
300	338
	339	+ func restoreChargeMonitoringStateIfNeeded(for meter: Meter) {
	340	+ guard let activeSession = activeChargeSessionSummary(for: meter.btSerial.macAddress.description) else {
	341	+ return
	342	+ }
	343	+ guard activeSession.status == .active else {
	344	+ return
	345	+ }
	346	+ meter.restoreChargeMonitoringIfNeeded(from: activeSession)
	347	+ }
	348	+
301	349	@discardableResult
302	350	func startChargeSession(
303	351	for meter: Meter,
	@@ -306,7 +354,8 @@ final class AppData : ObservableObject {
306	354	chargingTransportMode: ChargingTransportMode,
307	355	chargingStateMode: ChargingStateMode,
308	356	autoStopEnabled: Bool,
309		- initialBatteryPercent: Double
	357	+ initialBatteryPercent: Double?,
	358	+ startsFromFlatBattery: Bool
310	359	) -> Bool {
311	360	guard let snapshot = meter.chargingMonitorSnapshot else {
312	361	return false
	@@ -319,10 +368,18 @@ final class AppData : ObservableObject {
319	368	chargingTransportMode: chargingTransportMode,
320	369	chargingStateMode: chargingStateMode,
321	370	autoStopEnabled: autoStopEnabled,
322		- initialBatteryPercent: initialBatteryPercent
	371	+ initialBatteryPercent: initialBatteryPercent,
	372	+ startsFromFlatBattery: startsFromFlatBattery
323	373	) ?? false
324	374	if didSave {
325	375	reloadChargedDevices()
	376	+ meter.resetChargeRecordGraph()
	377	+ if let activeSession = activeChargeSessionSummary(for: meter.btSerial.macAddress.description),
	378	+ meter.supportsRecordingThreshold,
	379	+ activeSession.stopThresholdAmps > 0 {
	380	+ meter.recordingTreshold = activeSession.stopThresholdAmps
	381	+ }
	382	+ restoreChargeMonitoringStateIfNeeded(for: meter)
326	383	}
327	384	return didSave
328	385	}
	@@ -404,6 +461,30 @@ final class AppData : ObservableObject {
404	461	return didSave
405	462	}
406	463
	464	+ func batteryCheckpointPlausibilityWarning(
	465	+ percent: Double,
	466	+ for sessionID: UUID
	467	+ ) -> BatteryCheckpointPlausibilityWarning? {
	468	+ guard let session = chargeSessionSummary(id: sessionID) else {
	469	+ return nil
	470	+ }
	471	+ return batteryCheckpointPlausibilityWarning(percent: percent, for: session)
	472	+ }
	473	+
	474	+ @discardableResult
	475	+ func deleteBatteryCheckpoint(checkpointID: UUID, for sessionID: UUID) -> Bool {
	476	+ let didDelete = chargeInsightsStore?.deleteBatteryCheckpoint(
	477	+ id: checkpointID,
	478	+ from: sessionID
	479	+ ) ?? false
	480	+
	481	+ if didDelete {
	482	+ reloadChargedDevices()
	483	+ }
	484	+
	485	+ return didDelete
	486	+ }
	487	+
407	488	@discardableResult
408	489	func flushChargeInsights() -> Bool {
409	490	let didSave = chargeInsightsStore?.flushPendingChanges() ?? false
	@@ -531,16 +612,6 @@ final class AppData : ObservableObject {
531	612	return didDelete
532	613	}
533	614
534		- func restoreChargeMonitoringStateIfNeeded(for meter: Meter) {
535		- guard let activeSession = activeChargeSessionSummary(for: meter.btSerial.macAddress.description) else {
536		- return
537		- }
538		- guard activeSession.status == .active else {
539		- return
540		- }
541		- meter.restoreChargeMonitoringIfNeeded(from: activeSession)
542		- }
543		-
544	615	var meterSummaries: [MeterSummary] {
545	616	let liveMetersByMAC = Dictionary(uniqueKeysWithValues: meters.values.map { ($0.btSerial.macAddress.description, $0) })
546	617	let recordsByMAC = Dictionary(uniqueKeysWithValues: meterStore.allRecords().map { ($0.macAddress, $0) })
	@@ -619,6 +690,62 @@ final class AppData : ObservableObject {
619	690	}
620	691	}
621	692	}
	693	+
	694	+ private func batteryCheckpointPlausibilityWarning(
	695	+ percent: Double,
	696	+ for session: ChargeSessionSummary
	697	+ ) -> BatteryCheckpointPlausibilityWarning? {
	698	+ guard percent.isFinite, percent >= 0, percent <= 100 else {
	699	+ return nil
	700	+ }
	701	+
	702	+ let sortedCheckpoints = session.checkpoints.sorted { lhs, rhs in
	703	+ if lhs.timestamp != rhs.timestamp {
	704	+ return lhs.timestamp < rhs.timestamp
	705	+ }
	706	+ if lhs.measuredEnergyWh != rhs.measuredEnergyWh {
	707	+ return lhs.measuredEnergyWh < rhs.measuredEnergyWh
	708	+ }
	709	+ return lhs.id.uuidString < rhs.id.uuidString
	710	+ }
	711	+
	712	+ if let lastCheckpoint = sortedCheckpoints.last,
	713	+ percent < lastCheckpoint.batteryPercent - 1.5 {
	714	+ return BatteryCheckpointPlausibilityWarning(
	715	+ title: "Checkpoint Goes Backwards",
	716	+ message: "The latest checkpoint is \(lastCheckpoint.batteryPercent.format(decimalDigits: 0))% at \(lastCheckpoint.timestamp.format()). A new value of \(percent.format(decimalDigits: 0))% is unexpectedly lower while the session is still charging."
	717	+ )
	718	+ }
	719	+
	720	+ guard let chargedDevice = chargedDeviceSummary(id: session.chargedDeviceID),
	721	+ let prediction = chargedDevice.batteryLevelPrediction(for: session)
	722	+ else {
	723	+ return nil
	724	+ }
	725	+
	726	+ let predictionGap = percent - prediction.predictedPercent
	727	+ guard abs(predictionGap) >= 4 else {
	728	+ return nil
	729	+ }
	730	+
	731	+ let direction = predictionGap > 0 ? "above" : "below"
	732	+ let gapText = abs(predictionGap).format(decimalDigits: 0)
	733	+ let predictedText = prediction.predictedPercent.format(decimalDigits: 0)
	734	+
	735	+ if let lastCheckpoint = sortedCheckpoints.last {
	736	+ let effectiveEnergyWh = session.effectiveBatteryEnergyWh ?? session.measuredEnergyWh
	737	+ let energyDeltaWh = max(effectiveEnergyWh - lastCheckpoint.measuredEnergyWh, 0)
	738	+ return BatteryCheckpointPlausibilityWarning(
	739	+ title: "Checkpoint Looks Implausible",
	740	+ message: "This value is about \(gapText) percentage points \(direction) the predicted \(predictedText)% based on \(prediction.anchorDescription). Since the last checkpoint at \(lastCheckpoint.batteryPercent.format(decimalDigits: 0))%, only \(energyDeltaWh.format(decimalDigits: 2)) Wh were added."
	741	+ )
	742	+ }
	743	+
	744	+ return BatteryCheckpointPlausibilityWarning(
	745	+ title: "Checkpoint Looks Implausible",
	746	+ message: "This value is about \(gapText) percentage points \(direction) the predicted \(predictedText)% based on \(prediction.anchorDescription). Save it only if the device gauge really jumped that much."
	747	+ )
	748	+ }
622	749	}
623	750
624	751	extension AppData.MeterSummary {

	@@ -405,6 +405,9 @@ class Measurements : ObservableObject {
405	405	let delta = value - lastEnergyCounterValue
406	406	if delta > energyResetEpsilon {
407	407	accumulatedEnergyValue += delta
	408	+ } else if delta < -energyResetEpsilon {
	409	+ energy.addDiscontinuity(timestamp: timestamp)
	410	+ accumulatedEnergyValue = 0
408	411	}
409	412	}
410	413

	@@ -620,7 +620,11 @@ class Meter : NSObject, ObservableObject, Identifiable {
620	620	}
621	621
622	622	func chargingMonitorSnapshot(at observedAt: Date) -> ChargingMonitorSnapshot? {
623		- ChargingMonitorSnapshot(
	623	+ let usesNativeRecordingCounters = supportsRecordingView
	624	+ let nativeChargeCounter = usesNativeRecordingCounters ? recordedAH : nil
	625	+ let nativeEnergyCounter = usesNativeRecordingCounters ? recordedWH : nil
	626	+
	627	+ return ChargingMonitorSnapshot(
624	628	meterMACAddress: btSerial.macAddress.description,
625	629	meterName: name,
626	630	meterModel: deviceModelSummary,
	@@ -628,10 +632,10 @@ class Meter : NSObject, ObservableObject, Identifiable {
628	632	voltageVolts: voltage,
629	633	currentAmps: current,
630	634	powerWatts: power,
631		- selectedDataGroup: currentEnergySample()?.groupID ?? currentChargeSample()?.groupID,
632		- meterChargeCounterAh: currentChargeSample()?.value,
633		- meterEnergyCounterWh: currentEnergySample()?.value,
634		- fallbackStopThresholdAmps: chargeRecordStopThreshold
	635	+ selectedDataGroup: usesNativeRecordingCounters ? nil : (currentEnergySample()?.groupID ?? currentChargeSample()?.groupID),
	636	+ meterChargeCounterAh: nativeChargeCounter ?? currentChargeSample()?.value,
	637	+ meterEnergyCounterWh: nativeEnergyCounter ?? currentEnergySample()?.value,
	638	+ fallbackStopThresholdAmps: supportsRecordingThreshold ? recordingTreshold : chargeRecordStopThreshold
635	639	)
636	640	}
637	641
	@@ -788,7 +792,13 @@ class Meter : NSObject, ObservableObject, Identifiable {
788	792	}
789	793	}
790	794	updateChargeRecord(at: dataDumpRequestTimestamp)
791		- if let energySample = currentEnergySample() {
	795	+ if supportsRecordingView {
	796	+ measurements.captureEnergyValue(
	797	+ timestamp: dataDumpRequestTimestamp,
	798	+ value: recordedWH,
	799	+ groupID: .max
	800	+ )
	801	+ } else if let energySample = currentEnergySample() {
792	802	measurements.captureEnergyValue(
793	803	timestamp: dataDumpRequestTimestamp,
794	804	value: energySample.value,

	@@ -11,30 +11,30 @@ enum ChargedDeviceLibraryMode {
11	11	case device
12	12	case charger
13	13
14		- var title: String {
	14	+ var kind: ChargedDeviceKind {
15	15	switch self {
16	16	case .device:
17		- return "Devices"
	17	+ return .device
18	18	case .charger:
19		- return "Chargers"
	19	+ return .charger
20	20	}
21	21	}
22	22
23		- var singularTitle: String {
	23	+ var title: String {
24	24	switch self {
25	25	case .device:
26		- return "Device"
	26	+ return "Devices"
27	27	case .charger:
28		- return "Charger"
	28	+ return "Chargers"
29	29	}
30	30	}
31	31
32		- var suggestedClass: ChargedDeviceClass {
	32	+ var singularTitle: String {
33	33	switch self {
34	34	case .device:
35		- return .iphone
	35	+ return "Device"
36	36	case .charger:
37		- return .charger
	37	+ return "Charger"
38	38	}
39	39	}
40	40	}
	@@ -56,11 +56,14 @@ struct ChargedDeviceLibrarySheetView: View {
56	56	List {
57	57	if displayedChargedDevices.isEmpty {
58	58	VStack(alignment: .leading, spacing: 10) {
59		- Text("No \(mode.title.lowercased()) yet.")
60		- .font(.headline)
61		- Text(emptyStateDescription)
62		- .font(.footnote)
63		- .foregroundColor(.secondary)
	59	+ HStack(spacing: 8) {
	60	+ Text("No \(mode.title.lowercased()) yet.")
	61	+ .font(.headline)
	62	+ ContextInfoButton(
	63	+ title: mode.title,
	64	+ message: emptyStateDescription
	65	+ )
	66	+ }
64	67	}
65	68	.padding(.vertical, 10)
66	69	.listRowBackground(Color.clear)
	@@ -88,7 +91,7 @@ struct ChargedDeviceLibrarySheetView: View {
88	91	Button {
89	92	editingChargedDevice = chargedDevice
90	93	} label: {
91		- Label("Edit Device", systemImage: "pencil")
	94	+ Label("Edit \(mode.singularTitle)", systemImage: "pencil")
92	95	}
93	96	}
94	97	}
	@@ -122,15 +125,15 @@ struct ChargedDeviceLibrarySheetView: View {
122	125	.sheet(isPresented: $editorVisibility) {
123	126	ChargedDeviceEditorSheetView(
124	127	meterMACAddress: meterMACAddress,
125		- suggestedDeviceClass: mode.suggestedClass
	128	+ kind: mode.kind
126	129	)
127	130	.environmentObject(appData)
128	131	}
129	132	.sheet(item: $editingChargedDevice) { chargedDevice in
130	133	ChargedDeviceEditorSheetView(
131	134	meterMACAddress: nil,
132		- chargedDevice: chargedDevice,
133		- suggestedDeviceClass: mode.suggestedClass
	135	+ kind: mode.kind,
	136	+ chargedDevice: chargedDevice
134	137	)
135	138	.environmentObject(appData)
136	139	}
	@@ -183,7 +186,7 @@ private struct ChargedDeviceLibraryRowView: View {
183	186
184	187	VStack(alignment: .leading, spacing: 6) {
185	188	HStack {
186		- Label(chargedDevice.name, systemImage: chargedDevice.deviceClass.symbolName)
	189	+ Label(chargedDevice.name, systemImage: chargedDevice.identitySymbolName)
187	190	.font(.headline)
188	191	.foregroundColor(.primary)
189	192	Spacer()
	@@ -193,28 +196,44 @@ private struct ChargedDeviceLibraryRowView: View {
193	196	}
194	197	}
195	198
196		- Text(chargedDevice.deviceClass.title)
	199	+ Text(chargedDevice.identityTitle)
197	200	.font(.caption.weight(.semibold))
198	201	.foregroundColor(.secondary)
199	202
200		- Text(chargedDevice.supportedChargingModes.map(\.title).joined(separator: " + "))
201		- .font(.caption2)
202		- .foregroundColor(.secondary)
203		-
204		- if let capacity = chargedDevice.estimatedBatteryCapacityWh {
205		- Text("Estimated capacity: \(capacity.format(decimalDigits: 2)) Wh")
206		- .font(.caption)
207		- .foregroundColor(.secondary)
208		- } else if chargedDevice.isCharger, let chargerMaximumPowerWatts = chargedDevice.chargerMaximumPowerWatts {
209		- Text("Max power: \(chargerMaximumPowerWatts.format(decimalDigits: 2)) W")
210		- .font(.caption)
	203	+ if chargedDevice.isCharger {
	204	+ if !chargedDevice.chargerObservedVoltageSelections.isEmpty {
	205	+ Text(
	206	+ chargedDevice.chargerObservedVoltageSelections
	207	+ .map { "\($0.format(decimalDigits: 1)) V" }
	208	+ .joined(separator: ", ")
	209	+ )
	210	+ .font(.caption2)
211	211	.foregroundColor(.secondary)
212		- }
213		-
214		- if let minimumCurrent = chargedDevice.resolvedCompletionCurrentAmps(for: chargedDevice.preferredChargingTransportMode) {
215		- Text("Completion current: \(minimumCurrent.format(decimalDigits: 2)) A")
	212	+ } else if let chargerMaximumPowerWatts = chargedDevice.chargerMaximumPowerWatts {
	213	+ Text("Max power: \(chargerMaximumPowerWatts.format(decimalDigits: 2)) W")
	214	+ .font(.caption2)
	215	+ .foregroundColor(.secondary)
	216	+ } else {
	217	+ Text("Wireless charger")
	218	+ .font(.caption2)
	219	+ .foregroundColor(.secondary)
	220	+ }
	221	+ } else {
	222	+ Text(chargedDevice.supportedChargingModes.map(\.title).joined(separator: " + "))
216	223	.font(.caption2)
217	224	.foregroundColor(.secondary)
	225	+
	226	+ if let capacity = chargedDevice.estimatedBatteryCapacityWh {
	227	+ Text("Estimated capacity: \(capacity.format(decimalDigits: 2)) Wh")
	228	+ .font(.caption)
	229	+ .foregroundColor(.secondary)
	230	+ }
	231	+
	232	+ if let minimumCurrent = chargedDevice.minimumCurrentAmps {
	233	+ Text("Completion current: \(minimumCurrent.format(decimalDigits: 2)) A")
	234	+ .font(.caption2)
	235	+ .foregroundColor(.secondary)
	236	+ }
218	237	}
219	238	}
220	239	}

	@@ -63,7 +63,7 @@ private struct ChargedDeviceSidebarCardView: View {
63	63
64	64	VStack(alignment: .leading, spacing: 6) {
65	65	HStack {
66		- Label(chargedDevice.name, systemImage: chargedDevice.deviceClass.symbolName)
	66	+ Label(chargedDevice.name, systemImage: chargedDevice.identitySymbolName)
67	67	.font(.headline)
68	68	if chargedDevice.activeSession != nil {
69	69	Spacer()
	@@ -73,26 +73,34 @@ private struct ChargedDeviceSidebarCardView: View {
73	73	}
74	74	}
75	75
76		- Text(chargedDevice.deviceClass.title)
	76	+ Text(chargedDevice.identityTitle)
77	77	.font(.caption.weight(.semibold))
78	78	.foregroundColor(.secondary)
79	79
80		- Text(chargedDevice.supportedChargingModes.map(\.title).joined(separator: " + "))
81		- .font(.caption2)
82		- .foregroundColor(.secondary)
83		-
84		- if let estimatedCapacityWh = chargedDevice.estimatedBatteryCapacityWh {
85		- Text("Capacity: \(estimatedCapacityWh.format(decimalDigits: 2)) Wh")
86		- .font(.caption2)
87		- .foregroundColor(.secondary)
88		- } else if chargedDevice.isCharger, let chargerMaximumPowerWatts = chargedDevice.chargerMaximumPowerWatts {
89		- Text("Max power: \(chargerMaximumPowerWatts.format(decimalDigits: 2)) W")
90		- .font(.caption2)
91		- .foregroundColor(.secondary)
	80	+ if chargedDevice.isCharger {
	81	+ if let chargerMaximumPowerWatts = chargedDevice.chargerMaximumPowerWatts {
	82	+ Text("Max power: \(chargerMaximumPowerWatts.format(decimalDigits: 2)) W")
	83	+ .font(.caption2)
	84	+ .foregroundColor(.secondary)
	85	+ } else {
	86	+ Text("Wireless charger")
	87	+ .font(.caption2)
	88	+ .foregroundColor(.secondary)
	89	+ }
92	90	} else {
93		- Text("Capacity: learning")
	91	+ Text(chargedDevice.supportedChargingModes.map(\.title).joined(separator: " + "))
94	92	.font(.caption2)
95	93	.foregroundColor(.secondary)
	94	+
	95	+ if let estimatedCapacityWh = chargedDevice.estimatedBatteryCapacityWh {
	96	+ Text("Capacity: \(estimatedCapacityWh.format(decimalDigits: 2)) Wh")
	97	+ .font(.caption2)
	98	+ .foregroundColor(.secondary)
	99	+ } else {
	100	+ Text("Capacity: learning")
	101	+ .font(.caption2)
	102	+ .foregroundColor(.secondary)
	103	+ }
96	104	}
97	105	}
98	106	}

	@@ -97,6 +97,8 @@ struct MeasurementChartView: View {
97	97
98	98	let compactLayout: Bool
99	99	let availableSize: CGSize
	100	+ let showsRangeSelector: Bool
	101	+ let rebasesEnergyToVisibleRangeStart: Bool
100	102
101	103	@EnvironmentObject private var measurements: Measurements
102	104	@Environment(\.horizontalSizeClass) private var horizontalSizeClass
	@@ -128,11 +130,15 @@ struct MeasurementChartView: View {
128	130	init(
129	131	compactLayout: Bool = false,
130	132	availableSize: CGSize = .zero,
131		- timeRange: ClosedRange<Date>? = nil
	133	+ timeRange: ClosedRange<Date>? = nil,
	134	+ showsRangeSelector: Bool = true,
	135	+ rebasesEnergyToVisibleRangeStart: Bool = false
132	136	) {
133	137	self.compactLayout = compactLayout
134	138	self.availableSize = availableSize
135	139	self.timeRange = timeRange
	140	+ self.showsRangeSelector = showsRangeSelector
	141	+ self.rebasesEnergyToVisibleRangeStart = rebasesEnergyToVisibleRangeStart
136	142	}
137	143
138	144	private var axisColumnWidth: CGFloat {
	@@ -153,6 +159,16 @@ struct MeasurementChartView: View {
153	159	return isLargeDisplay ? 36 : 28
154	160	}
155	161
	162	+ private var belowXAxisControlsHeight: CGFloat {
	163	+ if usesCompactLandscapeOriginControls {
	164	+ return 40
	165	+ }
	166	+ if compactLayout {
	167	+ return 46
	168	+ }
	169	+ return isLargeDisplay ? 58 : 50
	170	+ }
	171	+
156	172	private var isPortraitLayout: Bool {
157	173	guard availableSize != .zero else { return verticalSizeClass != .compact }
158	174	return availableSize.height >= availableSize.width
	@@ -280,7 +296,13 @@ struct MeasurementChartView: View {
280	296	chartToggleBar()
281	297
282	298	GeometryReader { geometry in
283		- let plotHeight = max(geometry.size.height - xAxisHeight, compactLayout ? 180 : 220)
	299	+ let reservedBottomHeight =
	300	+ xAxisHeight
	301	+ + (originControlsPlacement == .belowXAxisLegend ? belowXAxisControlsHeight + 6 : 0)
	302	+ let plotHeight = max(
	303	+ geometry.size.height - reservedBottomHeight,
	304	+ compactLayout ? 180 : 220
	305	+ )
284	306
285	307	VStack(spacing: 6) {
286	308	HStack(spacing: chartSectionSpacing) {
	@@ -363,7 +385,8 @@ struct MeasurementChartView: View {
363	385	}
364	386	}
365	387
366		- if let availableTimeRange,
	388	+ if showsRangeSelector,
	389	+ let availableTimeRange,
367	390	let selectorSeries,
368	391	shouldShowRangeSelector(
369	392	availableTimeRange: availableTimeRange,
	@@ -879,7 +902,8 @@ struct MeasurementChartView: View {
879	902	measurement,
880	903	visibleTimeRange: visibleTimeRange
881	904	)
882		- let points = smoothedPoints(from: rawPoints)
	905	+ let normalizedRawPoints = normalizedPoints(rawPoints, for: kind)
	906	+ let points = smoothedPoints(from: normalizedRawPoints)
883	907	let samplePoints = points.filter { $0.isSample }
884	908	let context = ChartContext()
885	909
	@@ -921,6 +945,28 @@ struct MeasurementChartView: View {
921	945	)
922	946	}
923	947
	948	+ private func normalizedPoints(
	949	+ _ points: [Measurements.Measurement.Point],
	950	+ for kind: SeriesKind
	951	+ ) -> [Measurements.Measurement.Point] {
	952	+ guard kind == .energy, rebasesEnergyToVisibleRangeStart else {
	953	+ return points
	954	+ }
	955	+
	956	+ guard let baseline = points.first(where: \.isSample)?.value else {
	957	+ return points
	958	+ }
	959	+
	960	+ return points.enumerated().map { index, point in
	961	+ Measurements.Measurement.Point(
	962	+ id: point.id == index ? point.id : index,
	963	+ timestamp: point.timestamp,
	964	+ value: point.value - baseline,
	965	+ kind: point.kind
	966	+ )
	967	+ }
	968	+ }
	969	+
924	970	private func overviewSeries(for kind: SeriesKind) -> SeriesData {
925	971	series(
926	972	for: measurement(for: kind),

	@@ -7,17 +7,35 @@ import SwiftUI
7	7
8	8	struct MeterInfoCardView<Content: View>: View {
9	9	let title: String
	10	+ let infoMessage: String?
10	11	let tint: Color
11	12	@ViewBuilder var content: Content
12	13
	14	+ init(
	15	+ title: String,
	16	+ infoMessage: String? = nil,
	17	+ tint: Color,
	18	+ @ViewBuilder content: () -> Content
	19	+ ) {
	20	+ self.title = title
	21	+ self.infoMessage = infoMessage
	22	+ self.tint = tint
	23	+ self.content = content()
	24	+ }
	25	+
13	26	var body: some View {
14	27	VStack(alignment: .leading, spacing: 12) {
15		- Text(title)
16		- .font(.headline)
	28	+ HStack(spacing: 8) {
	29	+ Text(title)
	30	+ .font(.headline)
	31	+ if let infoMessage {
	32	+ ContextInfoButton(title: title, message: infoMessage)
	33	+ }
	34	+ }
17	35	content
18	36	}
19	37	.frame(maxWidth: .infinity, alignment: .leading)
20	38	.padding(18)
21	39	.meterCard(tint: tint, fillOpacity: 0.18, strokeOpacity: 0.24)
22	40	}
23		-}
	41	+}

	@@ -46,14 +46,16 @@ struct BatteryTargetNotificationEditorSheetView: View {
46	46	var body: some View {
47	47	NavigationView {
48	48	Form {
49		- Section(header: Text("Target Level")) {
	49	+ Section(
	50	+ header: ContextInfoHeader(
	51	+ title: "Target Level",
	52	+ message: "A local notification will be generated on synced devices when the estimated battery level reaches this target."
	53	+ )
	54	+ ) {
50	55	VStack(alignment: .leading, spacing: 12) {
51	56	Text("\(targetPercent.format(decimalDigits: 0))%")
52	57	.font(.title3.weight(.bold))
53	58	Slider(value: $targetPercent, in: 20...100, step: 1)
54		- Text("A local notification will be generated on synced devices when the estimated battery level reaches this target.")
55		- .font(.footnote)
56		- .foregroundColor(.secondary)
57	59	}
58	60	}
59	61	}

	@@ -16,7 +16,7 @@ struct DataGroupsSheetView: View {
16	16	var body: some View {
17	17	NavigationView {
18	18	GeometryReader { box in
19		- let columnTitles = [usbMeter.supportsDataGroupCommands ? "Group" : "Memory", "Ah"]
	19	+ let columnTitles = [usbMeter.supportsDataGroupCommands ? "Group" : "Memory"]
20	20	+ (usbMeter.showsDataGroupEnergy ? ["Wh"] : [])
21	21	+ (usbMeter.supportsDataGroupCommands ? ["Clear"] : [])
22	22	let columnWidth = (box.size.width - 60) / CGFloat(columnTitles.count)
	@@ -24,12 +24,16 @@ struct DataGroupsSheetView: View {
24	24	ScrollView {
25	25	VStack(alignment: .leading, spacing: 14) {
26	26	VStack(alignment: .leading, spacing: 8) {
27		- Text(usbMeter.dataGroupsTitle)
28		- .font(.system(.title3, design: .rounded).weight(.bold))
29		- if let hint = usbMeter.dataGroupsHint {
30		- Text(hint)
31		- .font(.footnote)
32		- .foregroundColor(.secondary)
	27	+ HStack {
	28	+ Text(usbMeter.dataGroupsTitle)
	29	+ .font(.system(.title3, design: .rounded).weight(.bold))
	30	+ if let hint = usbMeter.dataGroupsHint {
	31	+ ContextInfoButton(
	32	+ title: usbMeter.dataGroupsTitle,
	33	+ message: hint
	34	+ )
	35	+ }
	36	+ Spacer(minLength: 0)
33	37	}
34	38	}
35	39	.padding(18)

	@@ -34,12 +34,7 @@ struct DataGroupRowView: View {
34	34	.fontWeight(.semibold)
35	35	}
36	36	}
37		-
38		- cell(width: width) {
39		- Text("\(usbMeter.dataGroupRecords[Int(id)]!.ah.format(decimalDigits: 3))")
40		- .monospacedDigit()
41		- }
42		-
	37	+
43	38	if showsEnergy {
44	39	cell(width: width) {
45	40	Text("\(usbMeter.dataGroupRecords[Int(id)]!.wh.format(decimalDigits: 3))")

	@@ -21,11 +21,15 @@ struct MeasurementSeriesSheetView: View {
21	21	ScrollView {
22	22	VStack(alignment: .leading, spacing: 14) {
23	23	VStack(alignment: .leading, spacing: 8) {
24		- Text("Measurement Series")
25		- .font(.system(.title3, design: .rounded).weight(.bold))
26		- Text("Buffered measurement series captured from the meter for analysis, charts, and correlations.")
27		- .font(.footnote)
28		- .foregroundColor(.secondary)
	24	+ HStack {
	25	+ Text("Measurement Series")
	26	+ .font(.system(.title3, design: .rounded).weight(.bold))
	27	+ ContextInfoButton(
	28	+ title: "Measurement Series",
	29	+ message: "Buffered measurement series captured from the meter for analysis, charts, and correlations."
	30	+ )
	31	+ Spacer(minLength: 0)
	32	+ }
29	33	}
30	34	.padding(18)
31	35	.meterCard(tint: .blue, fillOpacity: 0.18, strokeOpacity: 0.24)

	@@ -10,7 +10,7 @@ struct MeterDataGroupsTabView: View {
10	10
11	11	var body: some View {
12	12	GeometryReader { box in
13		- let columnTitles = [usbMeter.supportsDataGroupCommands ? "Group" : "Memory", "Ah"]
	13	+ let columnTitles = [usbMeter.supportsDataGroupCommands ? "Group" : "Memory"]
14	14	+ (usbMeter.showsDataGroupEnergy ? ["Wh"] : [])
15	15	+ (usbMeter.supportsDataGroupCommands ? ["Clear"] : [])
16	16	let columnWidth = (box.size.width - 60) / CGFloat(columnTitles.count)
	@@ -18,12 +18,15 @@ struct MeterDataGroupsTabView: View {
18	18	ScrollView {
19	19	VStack(alignment: .leading, spacing: 14) {
20	20	VStack(alignment: .leading, spacing: 8) {
21		- Text(usbMeter.dataGroupsTitle)
22		- .font(.system(.title3, design: .rounded).weight(.bold))
23		- if let hint = usbMeter.dataGroupsHint {
24		- Text(hint)
25		- .font(.footnote)
26		- .foregroundColor(.secondary)
	21	+ HStack(spacing: 8) {
	22	+ Text(usbMeter.dataGroupsTitle)
	23	+ .font(.system(.title3, design: .rounded).weight(.bold))
	24	+ if let hint = usbMeter.dataGroupsHint {
	25	+ ContextInfoButton(
	26	+ title: usbMeter.dataGroupsTitle,
	27	+ message: hint
	28	+ )
	29	+ }
27	30	}
28	31	}
29	32	.padding(18)

	@@ -12,9 +12,20 @@ import SwiftUI
12	12	struct MeterOverviewSectionView: View {
13	13	let meter: Meter
14	14
	15	+ private var overviewInfoMessage: String? {
	16	+ guard meter.operationalState != .dataIsAvailable else {
	17	+ return nil
	18	+ }
	19	+ return "Connect to the meter to load firmware, serial, and boot details."
	20	+ }
	21	+
15	22	var body: some View {
16	23	VStack(spacing: 14) {
17		- MeterInfoCardView(title: "Overview", tint: meter.color) {
	24	+ MeterInfoCardView(
	25	+ title: "Overview",
	26	+ infoMessage: overviewInfoMessage,
	27	+ tint: meter.color
	28	+ ) {
18	29	MeterInfoRowView(label: "Name", value: meter.name)
19	30	MeterInfoRowView(label: "Device Model", value: meter.deviceModelName)
20	31	MeterInfoRowView(label: "Advertised Model", value: meter.modelString)
	@@ -36,11 +47,6 @@ struct MeterOverviewSectionView: View {
36	47	if meter.bootCount != 0 {
37	48	MeterInfoRowView(label: "Boot Count", value: "\(meter.bootCount)")
38	49	}
39		- } else {
40		- Text("Connect to the meter to load firmware, serial, and boot details.")
41		- .font(.footnote)
42		- .foregroundColor(.secondary)
43		- .multilineTextAlignment(.leading)
44	50	}
45	51	}
46	52

	@@ -394,11 +394,14 @@ private struct PowerAverageSheetView: View {
394	394	ScrollView {
395	395	VStack(alignment: .leading, spacing: 14) {
396	396	VStack(alignment: .leading, spacing: 8) {
397		- Text("Power Average")
398		- .font(.system(.title3, design: .rounded).weight(.bold))
399		- Text("Inspect the recent power buffer, choose how many values to include, and compute the average power over that window.")
400		- .font(.footnote)
401		- .foregroundColor(.secondary)
	397	+ HStack(spacing: 8) {
	398	+ Text("Power Average")
	399	+ .font(.system(.title3, design: .rounded).weight(.bold))
	400	+ ContextInfoButton(
	401	+ title: "Power Average",
	402	+ message: "Inspect the recent power buffer, choose how many values to include, and compute the average power over that window."
	403	+ )
	404	+ }
402	405	}
403	406	.padding(18)
404	407	.meterCard(tint: .pink, fillOpacity: 0.18, strokeOpacity: 0.24)
	@@ -435,11 +438,11 @@ private struct PowerAverageSheetView: View {
435	438	}
436	439	}
437	440
438		- MeterInfoCardView(title: "Buffer Actions", tint: .secondary) {
439		- Text("Reset clears the captured live measurement buffer for power, energy, voltage, current, temperature, and RSSI.")
440		- .font(.footnote)
441		- .foregroundColor(.secondary)
442		-
	441	+ MeterInfoCardView(
	442	+ title: "Buffer Actions",
	443	+ infoMessage: "Reset clears the captured live measurement buffer for power, energy, voltage, current, temperature, and RSSI.",
	444	+ tint: .secondary
	445	+ ) {
443	446	Button("Reset Buffer") {
444	447	measurements.resetSeries()
445	448	selectedSampleCount = defaultSampleCount(bufferedSamples: measurements.powerSampleCount(flushPendingValues: false))
	@@ -533,11 +536,14 @@ private struct RSSIHistorySheetView: View {
533	536	ScrollView {
534	537	VStack(alignment: .leading, spacing: 14) {
535	538	VStack(alignment: .leading, spacing: 8) {
536		- Text("RSSI History")
537		- .font(.system(.title3, design: .rounded).weight(.bold))
538		- Text("Signal strength captured over time while the meter stays connected.")
539		- .font(.footnote)
540		- .foregroundColor(.secondary)
	539	+ HStack(spacing: 8) {
	540	+ Text("RSSI History")
	541	+ .font(.system(.title3, design: .rounded).weight(.bold))
	542	+ ContextInfoButton(
	543	+ title: "RSSI History",
	544	+ message: "Signal strength captured over time while the meter stays connected."
	545	+ )
	546	+ }
541	547	}
542	548	.padding(18)
543	549	.meterCard(tint: .mint, fillOpacity: 0.18, strokeOpacity: 0.24)
	@@ -717,11 +723,14 @@ private struct EnergyProjectionSheetView: View {
717	723	ScrollView {
718	724	VStack(alignment: .leading, spacing: 14) {
719	725	VStack(alignment: .leading, spacing: 8) {
720		- Text("Energy Projections")
721		- .font(.system(.title3, design: .rounded).weight(.bold))
722		- Text("Projected consumption is estimated from multiple real windows in the live buffer. A method is shown only when that full interval exists in the recent continuous data.")
723		- .font(.footnote)
724		- .foregroundColor(.secondary)
	726	+ HStack(spacing: 8) {
	727	+ Text("Energy Projections")
	728	+ .font(.system(.title3, design: .rounded).weight(.bold))
	729	+ ContextInfoButton(
	730	+ title: "Energy Projections",
	731	+ message: "Projected consumption is estimated from multiple real windows in the live buffer. A method is shown only when that full interval exists in the recent continuous data."
	732	+ )
	733	+ }
725	734	}
726	735	.padding(18)
727	736	.meterCard(tint: .teal, fillOpacity: 0.18, strokeOpacity: 0.24)
	@@ -751,9 +760,13 @@ private struct EnergyProjectionSheetView: View {
751	760	}
752	761	}
753	762
754		- MeterInfoCardView(title: "Projection Method", tint: .teal) {
	763	+ MeterInfoCardView(
	764	+ title: "Projection Method",
	765	+ infoMessage: "Projection methods appear after the live buffer contains at least one continuous interval with enough data to estimate a rate.",
	766	+ tint: .teal
	767	+ ) {
755	768	if projectionVariants.isEmpty {
756		- Text("Projection methods appear after the live buffer contains at least one continuous interval with enough data to estimate a rate.")
	769	+ Text("No projection methods available yet.")
757	770	.font(.footnote)
758	771	.foregroundColor(.secondary)
759	772	} else {

	@@ -39,10 +39,11 @@ struct MeterSettingsTabView: View {
39	39	}
40	40
41	41	if meter.operationalState == .dataIsAvailable && meter.supportsManualTemperatureUnitSelection {
42		- settingsCard(title: "Meter Temperature Unit", tint: .orange) {
43		- Text("TC66 temperature is shown as degrees without assuming Celsius or Fahrenheit. Keep this matched to the unit configured on the device so you can interpret the reading correctly.")
44		- .font(.footnote)
45		- .foregroundColor(.secondary)
	42	+ settingsCard(
	43	+ title: "Meter Temperature Unit",
	44	+ infoMessage: "TC66 temperature is shown as degrees without assuming Celsius or Fahrenheit. Keep this matched to the unit configured on the device so you can interpret the reading correctly.",
	45	+ tint: .orange
	46	+ ) {
46	47	Picker("", selection: $meter.tc66TemperatureUnitPreference) {
47	48	ForEach(TemperatureUnitPreference.allCases) { unit in
48	49	Text(unit.title).tag(unit)
	@@ -53,29 +54,23 @@ struct MeterSettingsTabView: View {
53	54	}
54	55
55	56	if meter.operationalState == .dataIsAvailable && meter.model == .TC66C {
56		- settingsCard(title: "Screen Reporting", tint: .orange) {
	57	+ settingsCard(
	58	+ title: "Screen Reporting",
	59	+ infoMessage: "TC66 is the exception: it does not report the current screen in the payload, so the app keeps this note here instead of showing it on the home screen.",
	60	+ tint: .orange
	61	+ ) {
57	62	MeterInfoRowView(label: "Current Screen", value: "Not Reported")
58		- Text("TC66 is the exception: it does not report the current screen in the payload, so the app keeps this note here instead of showing it on the home screen.")
59		- .font(.footnote)
60		- .foregroundColor(.secondary)
61	63	}
62	64	}
63	65
64	66	if meter.operationalState == .dataIsAvailable {
65	67	settingsCard(
66	68	title: meter.reportsCurrentScreenIndex ? "Screen Controls" : "Page Controls",
	69	+ infoMessage: meter.reportsCurrentScreenIndex
	70	+ ? "Use these controls when you want to change the screen shown on the device without crowding the main meter view."
	71	+ : "Use these controls when you want to switch device pages without crowding the main meter view.",
67	72	tint: .indigo
68	73	) {
69		- if meter.reportsCurrentScreenIndex {
70		- Text("Use these controls when you want to change the screen shown on the device without crowding the main meter view.")
71		- .font(.footnote)
72		- .foregroundColor(.secondary)
73		- } else {
74		- Text("Use these controls when you want to switch device pages without crowding the main meter view.")
75		- .font(.footnote)
76		- .foregroundColor(.secondary)
77		- }
78		-
79	74	MeterScreenControlsView(showsHeader: false)
80	75	}
81	76	}
	@@ -110,11 +105,11 @@ struct MeterSettingsTabView: View {
110	105	}
111	106	}
112	107
113		- settingsCard(title: "Danger Zone", tint: .red) {
114		- Text("Delete this meter from the sidebar and clear its saved metadata. If the device is still nearby, it can appear again after a fresh Bluetooth discovery.")
115		- .font(.footnote)
116		- .foregroundColor(.secondary)
117		-
	108	+ settingsCard(
	109	+ title: "Danger Zone",
	110	+ infoMessage: "Delete this meter from the sidebar and clear its saved metadata. If the device is still nearby, it can appear again after a fresh Bluetooth discovery.",
	111	+ tint: .red
	112	+ ) {
118	113	Button("Delete Meter") {
119	114	deleteConfirmationVisibility = true
120	115	}
	@@ -186,12 +181,18 @@ struct MeterSettingsTabView: View {
186	181
187	182	private func settingsCard<Content: View>(
188	183	title: String,
	184	+ infoMessage: String? = nil,
189	185	tint: Color,
190	186	@ViewBuilder content: () -> Content
191	187	) -> some View {
192	188	VStack(alignment: .leading, spacing: 12) {
193		- Text(title)
194		- .font(.headline)
	189	+ HStack(spacing: 8) {
	190	+ Text(title)
	191	+ .font(.headline)
	192	+ if let infoMessage {
	193	+ ContextInfoButton(title: title, message: infoMessage)
	194	+ }
	195	+ }
195	196	content()
196	197	}
197	198	.padding(18)

	@@ -76,8 +76,14 @@ struct MeterDetailView: View {
76	76
77	77	private var statusCard: some View {
78	78	VStack(alignment: .leading, spacing: 10) {
79		- Text("Status")
80		- .font(.headline)
	79	+ HStack(spacing: 8) {
	80	+ Text("Status")
	81	+ .font(.headline)
	82	+ ContextInfoButton(
	83	+ title: "Status",
	84	+ message: "The meter is not currently connected. Bring it within Bluetooth range or wake it up to open live diagnostics."
	85	+ )
	86	+ }
81	87	HStack(spacing: 8) {
82	88	Circle()
83	89	.fill(meterSummary.tint)
	@@ -86,9 +92,6 @@ struct MeterDetailView: View {
86	92	.font(.caption.weight(.semibold))
87	93	.foregroundColor(.secondary)
88	94	}
89		- Text("The meter is not currently connected. Bring it within Bluetooth range or wake it up to open live diagnostics.")
90		- .font(.caption)
91		- .foregroundColor(.secondary)
92	95	}
93	96	.frame(maxWidth: .infinity, alignment: .leading)
94	97	.padding(18)
	@@ -113,11 +116,17 @@ struct MeterDetailView: View {
113	116	let chargedDevices = appData.chargedDevices(for: meterSummary.macAddress)
114	117
115	118	return VStack(alignment: .leading, spacing: 10) {
116		- Text("Devices")
117		- .font(.headline)
	119	+ HStack(spacing: 8) {
	120	+ Text("Devices")
	121	+ .font(.headline)
	122	+ ContextInfoButton(
	123	+ title: "Devices",
	124	+ message: "Link devices to this meter from Charge Record to keep capacity learning and charge curves tied to the right hardware."
	125	+ )
	126	+ }
118	127
119	128	if chargedDevices.isEmpty {
120		- Text("No devices are linked to this meter yet. Connect it, open Charge Record, and select the device being charged to start learning capacity and charge curves.")
	129	+ Text("No devices linked yet.")
121	130	.font(.caption)
122	131	.foregroundColor(.secondary)
123	132	} else {
	@@ -127,7 +136,7 @@ struct MeterDetailView: View {
127	136	ChargedDeviceQRCodeView(qrIdentifier: chargedDevice.qrIdentifier, side: 52)
128	137
129	138	VStack(alignment: .leading, spacing: 4) {
130		- Label(chargedDevice.name, systemImage: chargedDevice.deviceClass.symbolName)
	139	+ Label(chargedDevice.name, systemImage: chargedDevice.identitySymbolName)
131	140	.font(.subheadline.weight(.semibold))
132	141	Text(chargedDevice.estimatedBatteryCapacityWh.map { "\($0.format(decimalDigits: 2)) Wh" } ?? "Capacity: learning")
133	142	.font(.caption)
	@@ -150,11 +159,17 @@ struct MeterDetailView: View {
150	159	let chargers = appData.chargers(for: meterSummary.macAddress)
151	160
152	161	return VStack(alignment: .leading, spacing: 10) {
153		- Text("Chargers")
154		- .font(.headline)
	162	+ HStack(spacing: 8) {
	163	+ Text("Chargers")
	164	+ .font(.headline)
	165	+ ContextInfoButton(
	166	+ title: "Chargers",
	167	+ message: "Link chargers to this meter for wireless sessions so the app can keep charger-specific learning and efficiency data separate."
	168	+ )
	169	+ }
155	170
156	171	if chargers.isEmpty {
157		- Text("No chargers are linked to this meter yet. Pick one from Charge Record when you monitor a wireless charging session.")
	172	+ Text("No chargers linked yet.")
158	173	.font(.caption)
159	174	.foregroundColor(.secondary)
160	175	} else {
	@@ -164,7 +179,7 @@ struct MeterDetailView: View {
164	179	ChargedDeviceQRCodeView(qrIdentifier: charger.qrIdentifier, side: 52)
165	180
166	181	VStack(alignment: .leading, spacing: 4) {
167		- Label(charger.name, systemImage: charger.deviceClass.symbolName)
	182	+ Label(charger.name, systemImage: charger.identitySymbolName)
168	183	.font(.subheadline.weight(.semibold))
169	184	Text(charger.chargerMaximumPowerWatts.map { "Max power: \($0.format(decimalDigits: 2)) W" } ?? "Wireless charger")
170	185	.font(.caption)
	@@ -233,7 +248,12 @@ struct MeterEditorSheetView: View {
233	248	var body: some View {
234	249	NavigationView {
235	250	Form {
236		- Section(header: Text("Identity")) {
	251	+ Section(
	252	+ header: ContextInfoHeader(
	253	+ title: "Identity",
	254	+ message: "Use the real BLE MAC address format `AA:BB:CC:DD:EE:FF`. Saved meters remain visible in the sidebar even when they are currently offline."
	255	+ )
	256	+ ) {
237	257	TextField("Display name", text: $customName)
238	258	TextField("MAC Address", text: $macAddress)
239	259	.textInputAutocapitalization(.characters)
	@@ -249,12 +269,6 @@ struct MeterEditorSheetView: View {
249	269
250	270	TextField("Advertised name", text: $advertisedName)
251	271	}
252		-
253		- Section {
254		- Text("Use the real BLE MAC address format `AA:BB:CC:DD:EE:FF`. Saved meters remain visible in the sidebar even when they are currently offline.")
255		- .font(.footnote)
256		- .foregroundColor(.secondary)
257		- }
258	272	}
259	273	.navigationTitle(existingMeterSummary == nil ? "New Meter" : "Edit Meter")
260	274	.navigationBarTitleDisplayMode(.inline)

	@@ -17,16 +17,16 @@ struct MeterMappingDebugView: View {
17	17	VStack(alignment: .leading, spacing: 8) {
18	18	Text(store.currentCloudAvailability.helpTitle)
19	19	.font(.headline)
20		- Text("This screen is limited to meter sync metadata visible on this device through the local store and iCloud KVS.")
21		- .font(.caption)
22		- .foregroundColor(.secondary)
23	20	Text(store.currentCloudAvailability.helpMessage)
24	21	.font(.caption)
25	22	.foregroundColor(.secondary)
26	23	}
27	24	.padding(.vertical, 6)
28	25	} header: {
29		- Text("Sync Status")
	26	+ ContextInfoHeader(
	27	+ title: "Sync Status",
	28	+ message: "This screen is limited to meter sync metadata visible on this device through the local store and iCloud KVS."
	29	+ )
30	30	}
31	31
32	32	Section {

	@@ -11,20 +11,22 @@ struct SidebarBluetoothStatusCardView: View {
11	11
12	12	var body: some View {
13	13	VStack(alignment: .leading, spacing: 6) {
14		- HStack {
	14	+ HStack(spacing: 8) {
15	15	Label("Bluetooth", systemImage: "bolt.horizontal.circle.fill")
16	16	.font(.footnote.weight(.semibold))
17	17	.foregroundColor(tint)
	18	+ ContextInfoButton(
	19	+ title: "Bluetooth",
	20	+ message: "Refer to this adapter state while walking through the Bluetooth and Device troubleshooting steps.",
	21	+ popoverWidth: 300
	22	+ )
18	23	Spacer()
19	24	Text(statusText)
20	25	.font(.caption.weight(.semibold))
21	26	.foregroundColor(.secondary)
22	27	}
23		- Text("Refer to this adapter state while walking through the Bluetooth and Device troubleshooting steps.")
24		- .font(.caption2)
25		- .foregroundColor(.secondary)
26	28	}
27	29	.padding(14)
28	30	.meterCard(tint: tint, fillOpacity: 0.22, strokeOpacity: 0.26, cornerRadius: 18)
29	31	}
30		-}
	32	+}

	@@ -60,13 +60,13 @@ struct SidebarView: View {
60	60	case .device:
61	61	ChargedDeviceEditorSheetView(
62	62	meterMACAddress: nil,
63		- suggestedDeviceClass: .iphone
	63	+ kind: .device
64	64	)
65	65	.environmentObject(appData)
66	66	case .charger:
67	67	ChargedDeviceEditorSheetView(
68	68	meterMACAddress: nil,
69		- suggestedDeviceClass: .charger
	69	+ kind: .charger
70	70	)
71	71	.environmentObject(appData)
72	72	}