Refine charge session setup UI and polling · 7b7f34b

Refine charge session setup UI and polling
Browse files

bogdan committed a month ago

codex/restore-session-chart main

1 parent bff0f4d

commit 7b7f34b

Showing 5 changed files with 602 additions and 189 deletions

+53 -7

USB Meter/Model/AppData.swift

@@ -58,6 +58,8 @@ final class AppData : ObservableObject {
     private var chargeInsightsStore: ChargeInsightsStore?
     private let chargerStandbyPowerStore = ChargerStandbyPowerStore()
     private let chargeNotificationCoordinator = ChargeNotificationCoordinator()
+    private var meterSummariesCache: (version: Int, summaries: [MeterSummary])?
+    private var meterSummariesVersion: Int = 0
 
     init() {
         bluetoothManagerNotification = bluetoothManager.objectWillChange.sink { [weak self] _ in
@@ -66,7 +68,9 @@ final class AppData : ObservableObject {
         meterStoreObserver = NotificationCenter.default.publisher(for: .meterNameStoreDidChange)
             .receive(on: DispatchQueue.main)
             .sink { [weak self] _ in
+                self?.invalidateMeterSummaries()
                 self?.refreshMeterMetadata()
+                self?.scheduleObjectWillChange()
             }
         meterStoreCloudObserver = NotificationCenter.default.publisher(for: .meterNameStoreCloudStatusDidChange)
             .receive(on: DispatchQueue.main)
@@ -84,7 +88,11 @@ final class AppData : ObservableObject {
 
     @Published var enableRecordFeature: Bool = true
 
-    @Published var meters: [UUID:Meter] = [UUID:Meter]()
+    @Published var meters: [UUID:Meter] = [UUID:Meter]() {
+        didSet {
+            invalidateMeterSummaries()
+        }
+    }
     @Published private(set) var chargedDevices: [ChargedDeviceSummary] = []
     @Published private(set) var activeChargerStandbySessions: [String: ChargerStandbyPowerMonitorSession] = [:]
 
@@ -268,10 +276,12 @@ final class AppData : ObservableObject {
     }
 
     func activeChargeSessionSummary(for meterMACAddress: String) -> ChargeSessionSummary? {
-        if let cachedSummary = cachedActiveChargeSessionSummary(for: meterMACAddress) {
+        let normalizedMAC = Self.normalizedMACAddress(meterMACAddress)
+
+        if let cachedSummary = cachedActiveChargeSessionSummary(for: normalizedMAC) {
             return cachedSummary
         }
-        return chargeInsightsStore?.activeChargeSessionSummary(forMeterMACAddress: meterMACAddress)
+        return chargeInsightsStore?.activeChargeSessionSummary(forMeterMACAddress: normalizedMAC)
     }
 
     func chargerStandbyMeasurementSession(for meterMACAddress: String) -> ChargerStandbyPowerMonitorSession? {
@@ -516,14 +526,19 @@ final class AppData : ObservableObject {
             startsFromFlatBattery: startsFromFlatBattery
         ) ?? false
         if didSave {
-            reloadChargedDevices()
             meter.resetChargeRecordGraph()
-            if let activeSession = activeChargeSessionSummary(for: meter.btSerial.macAddress.description),
+            let activeSession = chargeInsightsStore?.activeChargeSessionSummary(
+                forMeterMACAddress: meter.btSerial.macAddress.description
+            )
+            if let activeSession,
                meter.supportsRecordingThreshold,
                activeSession.stopThresholdAmps > 0 {
                 meter.recordingTreshold = activeSession.stopThresholdAmps
             }
-            restoreChargeMonitoringStateIfNeeded(for: meter)
+            if let activeSession {
+                meter.restoreChargeMonitoringIfNeeded(from: activeSession)
+            }
+            reloadChargedDevices()
         }
         return didSave
     }
@@ -698,6 +713,19 @@ final class AppData : ObservableObject {
         return didDelete
     }
 
+    @discardableResult
+    func setSessionTrim(sessionID: UUID, start: Date?, end: Date?) -> Bool {
+        let didSave = chargeInsightsStore?.setSessionTrim(
+            sessionID: sessionID,
+            start: start,
+            end: end
+        ) ?? false
+        if didSave {
+            reloadChargedDevices()
+        }
+        return didSave
+    }
+
     @discardableResult
     func flushChargeInsights() -> Bool {
         let didFlushObservations = flushAllPendingChargeObservations()
@@ -837,11 +865,15 @@ final class AppData : ObservableObject {
     }
 
     var meterSummaries: [MeterSummary] {
+        if let meterSummariesCache, meterSummariesCache.version == meterSummariesVersion {
+            return meterSummariesCache.summaries
+        }
+
         let liveMetersByMAC = Dictionary(uniqueKeysWithValues: meters.values.map { ($0.btSerial.macAddress.description, $0) })
         let recordsByMAC = Dictionary(uniqueKeysWithValues: meterStore.allRecords().map { ($0.macAddress, $0) })
         let macAddresses = Set(recordsByMAC.keys).union(liveMetersByMAC.keys)
 
-        return macAddresses.map { macAddress in
+        let summaries = macAddresses.map { macAddress in
             let liveMeter = liveMetersByMAC[macAddress]
             let record = recordsByMAC[macAddress]
 
@@ -868,6 +900,9 @@ final class AppData : ObservableObject {
             }
             return lhs.macAddress < rhs.macAddress
         }
+
+        meterSummariesCache = (version: meterSummariesVersion, summaries: summaries)
+        return summaries
     }
 
     private func scheduleObjectWillChange() {
@@ -876,6 +911,11 @@ final class AppData : ObservableObject {
         }
     }
 
+    private func invalidateMeterSummaries() {
+        meterSummariesVersion += 1
+        meterSummariesCache = nil
+    }
+
     private func scheduleChargedDevicesReload(delay: TimeInterval = 0.15) {
         pendingChargedDevicesReloadWorkItem?.cancel()
 
@@ -1168,6 +1208,9 @@ final class AppData : ObservableObject {
 
     private func displayedSessionEnergyWh(for session: ChargeSessionSummary, on meter: Meter) -> Double {
         let storedEnergyWh = session.effectiveOrMeasuredEnergyWh
+        guard session.isTrimmed == false else {
+            return storedEnergyWh
+        }
         guard session.status.isOpen else {
             return storedEnergyWh
         }
@@ -1185,6 +1228,9 @@ final class AppData : ObservableObject {
 
     private func displayedSessionChargeAh(for session: ChargeSessionSummary, on meter: Meter) -> Double {
         let storedChargeAh = session.measuredChargeAh
+        guard session.isTrimmed == false else {
+            return storedChargeAh
+        }
         guard session.status.isOpen else {
             return storedChargeAh
         }


+175 -12

USB Meter/Model/ChargeInsightsStore.swift

View

+                    -    private static let persistedSamplesPerHour = 300
+                    +    private static let persistedSamplesPerHour = 360
+                         private static let aggregatedSampleBucketDuration = 3600.0 / Double(persistedSamplesPerHour)
+                         private let context: NSManagedObjectContext
+                             return didSave
+                    +    @discardableResult
+                    +    func setSessionTrim(sessionID: UUID, start: Date?, end: Date?) -> Bool {
+                    +        var didSave = false
+                    +        context.performAndWait {
+                    +            guard let session = fetchSessionObject(id: sessionID.uuidString) else {
+                    +                return
+                    +            }
+                    +            let sessionStart = dateValue(session, key: "startedAt") ?? Date.distantPast
+                    +            let sessionEnd   = dateValue(session, key: "endedAt")
+                    +                ?? dateValue(session, key: "lastObservedAt")
+                    +                ?? Date.distantFuture
+                    +            let effectiveStart = min(max(start ?? sessionStart, sessionStart), sessionEnd)
+                    +            let effectiveEnd   = max(min(end ?? sessionEnd, sessionEnd), effectiveStart)
+                    +            let persistedStart = effectiveStart == sessionStart ? nil : effectiveStart
+                    +            let persistedEnd   = effectiveEnd == sessionEnd ? nil : effectiveEnd
+                    +            let allSamples = fetchSessionSampleObjects(forSessionID: sessionID.uuidString)
+                    +                .compactMap { obj -> (timestamp: Date, energy: Double, charge: Double)? in
+                    +                    guard let ts = dateValue(obj, key: "timestamp") else { return nil }
+                    +                    return (
+                    +                        timestamp: ts,
+                    +                        energy: doubleValue(obj, key: "measuredEnergyWh"),
+                    +                        charge: doubleValue(obj, key: "measuredChargeAh")
+                    +                    )
+                    +                }
+                    +                .sorted { $0.timestamp < $1.timestamp }
+                    +            // Each sample stores cumulative energy since session start.
+                    +            // Trimmed energy = value at trimEnd  -  value just before trimStart.
+                    +            let baselineSample = allSamples.last { $0.timestamp <= effectiveStart }
+                    +            let endSample      = allSamples.last { $0.timestamp <= effectiveEnd }
+                    +            let baselineEnergy = baselineSample?.energy ?? 0
+                    +            let baselineCharge = baselineSample?.charge ?? 0
+                    +            if let endSample {
+                    +                let trimmedEnergy  = max(endSample.energy - baselineEnergy, 0)
+                    +                let trimmedCharge  = max(endSample.charge - baselineCharge, 0)
+                    +                session.setValue(trimmedEnergy, forKey: "measuredEnergyWh")
+                    +                session.setValue(trimmedCharge, forKey: "measuredChargeAh")
+                    +            } else {
+                    +                session.setValue(0, forKey: "measuredEnergyWh")
+                    +                session.setValue(0, forKey: "measuredChargeAh")
+                    +            }
+                    +            session.setValue(persistedStart, forKey: "trimStart")
+                    +            session.setValue(persistedEnd,   forKey: "trimEnd")
+                    +            session.setValue(Date(), forKey: "updatedAt")
+                    +            let checkpoints = fetchCheckpointObjects(forSessionID: sessionID.uuidString)
+                    +            for checkpoint in checkpoints {
+                    +                guard let timestamp = dateValue(checkpoint, key: "timestamp") else { continue }
+                    +                if timestamp < effectiveStart || timestamp > effectiveEnd {
+                    +                    context.delete(checkpoint)
+                    +                    continue
+                    +                }
+                    +                let checkpointSample = allSamples.last { $0.timestamp <= timestamp }
+                    +                let rebasedEnergy = max((checkpointSample?.energy ?? baselineEnergy) - baselineEnergy, 0)
+                    +                let rebasedCharge = max((checkpointSample?.charge ?? baselineCharge) - baselineCharge, 0)
+                    +                checkpoint.setValue(rebasedEnergy, forKey: "measuredEnergyWh")
+                    +                checkpoint.setValue(rebasedCharge, forKey: "measuredChargeAh")
+                    +            }
+                    +            let remainingCheckpoints = fetchCheckpointObjects(forSessionID: sessionID.uuidString)
+                    +                .sorted {
+                    +                    (dateValue($0, key: "timestamp") ?? .distantPast)
+                    +                        < (dateValue($1, key: "timestamp") ?? .distantPast)
+                    +                }
+                    +            let restoredInitialCheckpoint = remainingCheckpoints.first { checkpoint in
+                    +                let label = stringValue(checkpoint, key: "label")
+                    +                let timestamp = dateValue(checkpoint, key: "timestamp") ?? .distantFuture
+                    +                return ChargeCheckpointFlag.fromStoredLabel(label) == .initial || timestamp <= effectiveStart
+                    +            }
+                    +            if persistedStart == nil {
+                    +                if let restoredInitialCheckpoint,
+                    +                   let percent = optionalDoubleValue(restoredInitialCheckpoint, key: "batteryPercent"),
+                    +                   percent >= 0 {
+                    +                    session.setValue(percent, forKey: "startBatteryPercent")
+                    +                }
+                    +            } else {
+                    +                session.setValue(nil, forKey: "startBatteryPercent")
+                    +            }
+                    +            refreshCheckpointDerivedValues(for: session)
+                    +            if let chargedDeviceID = stringValue(session, key: "chargedDeviceID") {
+                    +                refreshDerivedMetrics(forChargedDeviceID: chargedDeviceID)
+                    +            }
+                    +            didSave = saveContext()
+                    +        }
+                    +        return didSave
+                    +    }
+                         @discardableResult
+                         func deleteChargeSession(id sessionID: UUID) -> Bool {
+                             var didSave = false
+                                     Anchor(
+                                         percent: startBatteryPercent,
+                                         energyWh: 0,
+                    -                    timestamp: dateValue(session, key: "startedAt") ?? Date.distantPast,
+                    +                    timestamp: dateValue(session, key: "trimStart")
+                    +                        ?? dateValue(session, key: "startedAt")
+                    +                        ?? Date.distantPast,
+                                         isCheckpoint: false
+                             session.setValue(wirelessResolution?.usesEstimated ?? false, forKey: "usesEstimatedWirelessEfficiency")
+                             session.setValue(wirelessResolution?.shouldWarn ?? false, forKey: "shouldWarnAboutLowWirelessEfficiency")
+                    -        guard
+                    -            let startBatteryPercent = optionalDoubleValue(session, key: "startBatteryPercent"),
+                    -            let endBatteryPercent = optionalDoubleValue(session, key: "endBatteryPercent")
+                    -        else {
+                    +        let supportsChargingWhileOff = boolValue(chargedDevice, key: "supportsChargingWhileOff")
+                    +        guard let effectiveBatteryEnergyWh, effectiveBatteryEnergyWh > 0 else {
+                                 session.setValue(nil, forKey: "capacityEstimateWh")
+                                 return
+                    -        guard startBatteryPercent >= 0, endBatteryPercent >= 0 else {
+                    +        struct CapacityAnchor {
+                    +            let percent: Double
+                    +            let energyWh: Double
+                    +            let timestamp: Date
+                    +        }
+                    +        var anchors: [CapacityAnchor] = []
+                    +        if let startBatteryPercent = optionalDoubleValue(session, key: "startBatteryPercent"),
+                    +           startBatteryPercent >= 0 {
+                    +            anchors.append(
+                    +                CapacityAnchor(
+                    +                    percent: startBatteryPercent,
+                    +                    energyWh: 0,
+                    +                    timestamp: dateValue(session, key: "trimStart")
+                    +                        ?? dateValue(session, key: "startedAt")
+                    +                        ?? Date.distantPast
+                    +                )
+                    +            )
+                    +        }
+                    +        if let sessionID = stringValue(session, key: "id") {
+                    +            anchors.append(
+                    +                contentsOf: fetchCheckpointObjects(forSessionID: sessionID).compactMap { checkpoint in
+                    +                    guard
+                    +                        let percent = optionalDoubleValue(checkpoint, key: "batteryPercent"),
+                    +                        percent >= 0,
+                    +                        let timestamp = dateValue(checkpoint, key: "timestamp")
+                    +                    else {
+                    +                        return nil
+                    +                    }
+                    +                    return CapacityAnchor(
+                    +                        percent: percent,
+                    +                        energyWh: doubleValue(checkpoint, key: "measuredEnergyWh"),
+                    +                        timestamp: timestamp
+                    +                    )
+                    +                }
+                    +            )
+                    +        }
+                    +        if let endBatteryPercent = optionalDoubleValue(session, key: "endBatteryPercent"),
+                    +           endBatteryPercent >= 0 {
+                    +            anchors.append(
+                    +                CapacityAnchor(
+                    +                    percent: endBatteryPercent,
+                    +                    energyWh: effectiveBatteryEnergyWh,
+                    +                    timestamp: dateValue(session, key: "endedAt")
+                    +                        ?? dateValue(session, key: "lastObservedAt")
+                    +                        ?? Date.distantPast
+                    +                )
+                    +            )
+                    +        }
+                    +        let sortedAnchors = anchors.sorted { lhs, rhs in
+                    +            if lhs.energyWh != rhs.energyWh {
+                    +                return lhs.energyWh < rhs.energyWh
+                    +            }
+                    +            return lhs.timestamp < rhs.timestamp
+                    +        }
+                    +        guard let firstAnchor = sortedAnchors.first,
+                    +              let lastAnchor = sortedAnchors.last else {
+                                 session.setValue(nil, forKey: "capacityEstimateWh")
+                                 return
+                    -        let percentDelta = endBatteryPercent - startBatteryPercent
+                    -        let supportsChargingWhileOff = boolValue(chargedDevice, key: "supportsChargingWhileOff")
+                    +        let percentDelta = lastAnchor.percent - firstAnchor.percent
+                    +        let energyDelta = lastAnchor.energyWh - firstAnchor.energyWh
+                    -        guard percentDelta >= 20, let effectiveBatteryEnergyWh, effectiveBatteryEnergyWh > 0 else {
+                    +        guard percentDelta >= 20, energyDelta > 0 else {
+                                 session.setValue(nil, forKey: "capacityEstimateWh")
+                                 return
+                    -        if !supportsChargingWhileOff && endBatteryPercent >= 99.5 {
+                    +        if !supportsChargingWhileOff && lastAnchor.percent >= 99.5 {
+                                 session.setValue(nil, forKey: "capacityEstimateWh")
+                                 return
+                    -        let capacityEstimateWh = effectiveBatteryEnergyWh / (percentDelta / 100)
+                    +        let capacityEstimateWh = energyDelta / (percentDelta / 100)
+                             session.setValue(capacityEstimateWh, forKey: "capacityEstimateWh")
+                                 completionConfirmationRequestedAt: dateValue(object, key: "completionConfirmationRequestedAt"),
+                                 completionContradictionPercent: optionalDoubleValue(object, key: "completionContradictionPercent"),
+                                 selectedDataGroup: optionalInt16Value(object, key: "selectedDataGroup").map(UInt8.init),
+                    +            trimStart: dateValue(object, key: "trimStart"),
+                    +            trimEnd: dateValue(object, key: "trimEnd"),
+                                 checkpoints: checkpointSummaries,
+                                 aggregatedSamples: sampleSummaries

+117 -40

USB Meter/Model/Meter.swift

View

+                     class Meter : NSObject, ObservableObject, Identifiable {
+                    +    private struct ChargeRecordRestoreSignature: Equatable {
+                    +        let sessionID: UUID
+                    +        let sampleCount: Int
+                    +        let lastSampleTimestamp: Date?
+                    +    }
+                         private static func shouldLogOperationalStateTransition(from oldValue: OperationalState, to newValue: OperationalState) -> Bool {
+                             switch (oldValue, newValue) {
+                         var btSerial: BluetoothSerial
+                    -    var measurements = Measurements()
+                    +    let measurements = Measurements()
+                    +    let chargeRecordMeasurements = Measurements()
+                         private let minimumLivePollingInterval: TimeInterval = 0.4
+                         private var commandQueue: [Data] = []
+                         private var pendingVolatileMemoryResetDeadline: Date?
+                         private var liveDataChanged = false
+                         private var restoredChargeSessionID: UUID?
+                    +    private var restoredChargeRecordSignature: ChargeRecordRestoreSignature?
+                         private var lastRecorderObservationAt: Date?
+                         @discardableResult
+                         private func handleMeasurementDiscontinuity(at timestamp: Date) {
+                             measurements.markDiscontinuity(at: timestamp)
+                    +        chargeRecordMeasurements.markDiscontinuity(at: timestamp)
+                             guard chargeRecordState == .active else { return }
+                             chargeRecordLastTimestamp = nil
+                             updateChargeRecord(at: dataDumpRequestTimestamp)
+                    -        if supportsRecordingView {
+                    -            measurements.captureEnergyValue(
+                    -                timestamp: dataDumpRequestTimestamp,
+                    -                value: recordedWH,
+                    -                groupID: .max
+                    -            )
+                    -        } else if let energySample = currentEnergySample() {
+                    -            measurements.captureEnergyValue(
+                    -                timestamp: dataDumpRequestTimestamp,
+                    -                value: energySample.value,
+                    -                groupID: energySample.groupID
+                    -            )
+                    +        captureLiveMeasurements(at: dataDumpRequestTimestamp, in: measurements)
+                    +        if chargeRecordState != .waitingForStart {
+                    +            captureLiveMeasurements(at: dataDumpRequestTimestamp, in: chargeRecordMeasurements)
+                    -        measurements.addValues(
+                    -            timestamp: dataDumpRequestTimestamp,
+                    -            power: power,
+                    -            voltage: voltage,
+                    -            current: current,
+                    -            temperature: displayedTemperatureValue,
+                    -            rssi: Double(btSerial.averageRSSI)
+                    -        )
+                             appData.observeChargeSnapshot(from: self, observedAt: dataDumpRequestTimestamp)
+                     //        DispatchQueue.global(qos: .userInitiated).asyncAfter( deadline: .now() + 0.33 ) {
+                     //            //track("\(name) - Scheduled new request.")
+                             chargeRecordLastTimestamp = nil
+                             chargeRecordLastCurrent = 0
+                             chargeRecordLastPower = 0
+                    +        restoredChargeSessionID = nil
+                    +        restoredChargeRecordSignature = nil
+                    +        chargeRecordMeasurements.resetSeries()
+                             objectWillChange.send()
+                         func resetChargeRecordGraph() {
+                    -        let cutoff = Date()
+                             resetChargeRecord()
+                    -        measurements.trim(before: cutoff)
+                         func restoreChargeRecordIfNeeded(from activeSession: ChargeSessionSummary) {
+                    -        guard chargeRecordState == .waitingForStart else { return }
+                    -        guard chargeRecordStartTimestamp == nil else { return }
+                    -        guard chargeRecordAH == 0, chargeRecordWH == 0, chargeRecordDuration == 0 else { return }
+                    -        measurements.restorePersistedChargeSessionSamplesIfNeeded(from: activeSession)
+                    -        chargeRecordState = .active
+                    -        chargeRecordAH = activeSession.measuredChargeAh
+                    -        chargeRecordWH = activeSession.measuredEnergyWh
+                    -        chargeRecordDuration = max(activeSession.effectiveDuration, 0)
+                    -        chargeRecordStopThreshold = activeSession.stopThresholdAmps
+                    -        chargeRecordStartTimestamp = activeSession.startedAt
+                    -        chargeRecordEndTimestamp = activeSession.lastObservedAt
+                    -        chargeRecordLastTimestamp = nil
+                    -        chargeRecordLastCurrent = 0
+                    -        chargeRecordLastPower = 0
+                    +        var didChange = false
+                    +        let restoreSignature = ChargeRecordRestoreSignature(
+                    +            sessionID: activeSession.id,
+                    +            sampleCount: activeSession.aggregatedSamples.count,
+                    +            lastSampleTimestamp: activeSession.aggregatedSamples.last?.timestamp
+                    +        )
+                    +        if restoreSignature != restoredChargeRecordSignature {
+                    +            chargeRecordMeasurements.restorePersistedChargeSessionSamplesIfNeeded(
+                    +                from: activeSession,
+                    +                replacingLiveBufferIfNeeded: activeSession.aggregatedSamples.isEmpty == false
+                    +            )
+                    +            if activeSession.aggregatedSamples.isEmpty == false {
+                    +                restoredChargeRecordSignature = restoreSignature
+                    +                didChange = true
+                    +            }
+                    +        }
+                    +        if chargeRecordState != .active {
+                    +            chargeRecordState = .active
+                    +            didChange = true
+                    +        }
+                    +        let resolvedChargeAH = max(chargeRecordAH, activeSession.measuredChargeAh)
+                    +        if resolvedChargeAH != chargeRecordAH {
+                    +            chargeRecordAH = resolvedChargeAH
+                    +            didChange = true
+                    +        }
+                    +        let resolvedChargeWH = max(chargeRecordWH, activeSession.measuredEnergyWh)
+                    +        if resolvedChargeWH != chargeRecordWH {
+                    +            chargeRecordWH = resolvedChargeWH
+                    +            didChange = true
+                    +        }
+                    +        let resolvedDuration = max(chargeRecordDuration, max(activeSession.effectiveDuration, 0))
+                    +        if resolvedDuration != chargeRecordDuration {
+                    +            chargeRecordDuration = resolvedDuration
+                    +            didChange = true
+                    +        }
+                    +        if chargeRecordStopThreshold != activeSession.stopThresholdAmps {
+                    +            chargeRecordStopThreshold = activeSession.stopThresholdAmps
+                    +            didChange = true
+                    +        }
+                    +        if let chargeRecordStartTimestamp {
+                    +            let restoredStart = min(chargeRecordStartTimestamp, activeSession.startedAt)
+                    +            if restoredStart != chargeRecordStartTimestamp {
+                    +                self.chargeRecordStartTimestamp = restoredStart
+                    +                didChange = true
+                    +            }
+                    +        } else {
+                    +            chargeRecordStartTimestamp = activeSession.startedAt
+                    +            didChange = true
+                    +        }
+                    +        if let chargeRecordEndTimestamp {
+                    +            let restoredEnd = max(chargeRecordEndTimestamp, activeSession.lastObservedAt)
+                    +            if restoredEnd != chargeRecordEndTimestamp {
+                    +                self.chargeRecordEndTimestamp = restoredEnd
+                    +                didChange = true
+                    +            }
+                    +        } else {
+                    +            chargeRecordEndTimestamp = activeSession.lastObservedAt
+                    +            didChange = true
+                    +        }
+                             if let selectedDataGroup = activeSession.selectedDataGroup {
+                    -            self.selectedDataGroup = selectedDataGroup
+                    +            if self.selectedDataGroup != selectedDataGroup {
+                    +                self.selectedDataGroup = selectedDataGroup
+                    +                didChange = true
+                    +            }
+                    -        objectWillChange.send()
+                    +        if didChange {
+                    +            objectWillChange.send()
+                    +        }
+                    +    }
+                    +    private func captureLiveMeasurements(at timestamp: Date, in destination: Measurements) {
+                    +        if supportsRecordingView {
+                    +            destination.captureEnergyValue(
+                    +                timestamp: timestamp,
+                    +                value: recordedWH,
+                    +                groupID: .max
+                    +            )
+                    +        } else if let energySample = currentEnergySample() {
+                    +            destination.captureEnergyValue(
+                    +                timestamp: timestamp,
+                    +                value: energySample.value,
+                    +                groupID: energySample.groupID
+                    +            )
+                    +        }
+                    +        destination.addValues(
+                    +            timestamp: timestamp,
+                    +            power: power,
+                    +            voltage: voltage,
+                    +            current: current,
+                    +            temperature: displayedTemperatureValue,
+                    +            rssi: Double(btSerial.averageRSSI)
+                    +        )
+                         func restoreChargeMonitoringIfNeeded(from activeSession: ChargeSessionSummary) {

+1 -43

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

View

+                     struct ChargeRecordSheetView: View {
+                         @Binding var visibility: Bool
+                    -    @EnvironmentObject private var appData: AppData
+                    -    @State private var chargedDeviceLibraryVisibility = false
+                    -    @State private var chargerLibraryVisibility = false
+                    -    @State private var deviceLibraryMACAddress = ""
+                    -    @State private var chargerLibraryMACAddress = ""
+                    -    @State private var chargedDeviceLibraryTint: Color = .orange
+                    -    @State private var chargerLibraryTint: Color = .pink
+                         var body: some View {
+                             NavigationView {
+                    -            MeterChargeRecordContentView(
+                    -                onSelectDevice: { mac, tint in
+                    -                    deviceLibraryMACAddress = mac
+                    -                    chargedDeviceLibraryTint = tint
+                    -                    chargedDeviceLibraryVisibility = true
+                    -                },
+                    -                onSelectCharger: { mac, tint in
+                    -                    chargerLibraryMACAddress = mac
+                    -                    chargerLibraryTint = tint
+                    -                    chargerLibraryVisibility = true
+                    -                }
+                    -            )
+                    +            MeterChargeRecordContentView()
+                                 .navigationTitle("Charge Record")
+                                 .navigationBarTitleDisplayMode(.inline)
+                                 .toolbar {
+                    -            .background(
+                    -                Group {
+                    -                    NavigationLink(isActive: $chargedDeviceLibraryVisibility) {
+                    -                        ChargedDeviceLibrarySheetView(
+                    -                            meterMACAddress: deviceLibraryMACAddress,
+                    -                            meterTint: chargedDeviceLibraryTint,
+                    -                            mode: .device,
+                    -                            standalone: false
+                    -                        )
+                    -                        .environmentObject(appData)
+                    -                    } label: { EmptyView() }
+                    -                    NavigationLink(isActive: $chargerLibraryVisibility) {
+                    -                        ChargedDeviceLibrarySheetView(
+                    -                            meterMACAddress: chargerLibraryMACAddress,
+                    -                            meterTint: chargerLibraryTint,
+                    -                            mode: .charger,
+                    -                            standalone: false
+                    -                        )
+                    -                        .environmentObject(appData)
+                    -                    } label: { EmptyView() }
+                    -                }
+                    -            )
+                             .navigationViewStyle(StackNavigationViewStyle())

+256 -87

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

View

@@ -10,44 +10,8 @@ struct MeterChargeRecordTabView: View, Equatable {
         true
     }
 
-    @EnvironmentObject private var appData: AppData
-
-    @State private var chargedDeviceLibraryVisibility = false
-    @State private var chargerLibraryVisibility = false
-    @State private var deviceLibraryMACAddress = ""
-    @State private var chargerLibraryMACAddress = ""
-    @State private var chargedDeviceLibraryTint: Color = .orange
-    @State private var chargerLibraryTint: Color = .pink
-
     var body: some View {
-        MeterChargeRecordContentView(
-            onSelectDevice: { mac, tint in
-                deviceLibraryMACAddress = mac
-                chargedDeviceLibraryTint = tint
-                chargedDeviceLibraryVisibility = true
-            },
-            onSelectCharger: { mac, tint in
-                chargerLibraryMACAddress = mac
-                chargerLibraryTint = tint
-                chargerLibraryVisibility = true
-            }
-        )
-        .sheet(isPresented: $chargedDeviceLibraryVisibility) {
-            ChargedDeviceLibrarySheetView(
-                meterMACAddress: deviceLibraryMACAddress,
-                meterTint: chargedDeviceLibraryTint,
-                mode: .device
-            )
-            .environmentObject(appData)
-        }
-        .sheet(isPresented: $chargerLibraryVisibility) {
-            ChargedDeviceLibrarySheetView(
-                meterMACAddress: chargerLibraryMACAddress,
-                meterTint: chargerLibraryTint,
-                mode: .charger
-            )
-            .environmentObject(appData)
-        }
+        MeterChargeRecordContentView()
     }
 }
 
@@ -134,9 +98,6 @@ struct MeterChargeRecordContentView: View {
         }
     }
 
-    let onSelectDevice: (String, Color) -> Void
-    let onSelectCharger: (String, Color) -> Void
-
     @EnvironmentObject private var appData: AppData
     @EnvironmentObject private var usbMeter: Meter
 
@@ -152,6 +113,16 @@ struct MeterChargeRecordContentView: View {
     @State private var initialCheckpoint = ""
     @State private var showsMeterTotalsInfo = false
     @State private var activeMode: ActiveMode = .chargeSession
+    @State private var detectedTrimWindow: ChargingWindowDetector.DetectedWindow?
+    @State private var trimBannerDismissedForSessionID: UUID?
+
+    private var shouldShowTrimBanner: Bool {
+        guard let session = openChargeSession,
+              session.isTrimmed == false,
+              trimBannerDismissedForSessionID != session.id else { return false }
+        guard let window = detectedTrimWindow else { return false }
+        return window.trimRatio > ChargingWindowDetector.significantTrimThreshold
+    }
 
     var body: some View {
         ScrollView {
@@ -161,8 +132,15 @@ struct MeterChargeRecordContentView: View {
                 if let openChargeSession {
                     chargingMonitorCard(openChargeSession)
 
-                    if let range = sessionChartTimeRange {
-                        sessionChartCard(timeRange: range, session: openChargeSession)
+                    if shouldShowTrimBanner {
+                        trimDetectionBanner(for: openChargeSession)
+                    }
+
+                    if shouldShowSessionChart(for: openChargeSession) {
+                        sessionChartCard(
+                            timeRange: sessionChartFixedTimeRange(for: openChargeSession),
+                            session: openChargeSession
+                        )
                     }
                 } else {
                     liveMeterStripView
@@ -202,16 +180,48 @@ struct MeterChargeRecordContentView: View {
             )
         }
         .onAppear {
+            syncActiveSessionRestore()
             syncDraftSelections()
+            runTrimDetection()
         }
         .onChange(of: selectedChargedDevice?.id) { _ in
             syncDraftSelections()
         }
         .onChange(of: openChargeSession?.id) { _ in
+            syncActiveSessionRestore()
             syncDraftSelections()
             showingInlineTargetEditor = false
             draftTargetText = ""
+            detectedTrimWindow = nil
+            trimBannerDismissedForSessionID = nil
+            runTrimDetection()
+        }
+        .onChange(of: openChargeSession?.aggregatedSamples.count) { _ in
+            syncActiveSessionRestore()
+            runTrimDetection()
+        }
+    }
+
+    private func syncActiveSessionRestore() {
+        guard let session = openChargeSession else { return }
+        guard session.status == .active else { return }
+        guard session.meterMACAddress == meterMACAddress else { return }
+        usbMeter.restoreChargeRecordIfNeeded(from: session)
+    }
+
+    private func runTrimDetection() {
+        guard let session = openChargeSession,
+              session.isTrimmed == false,
+              !session.aggregatedSamples.isEmpty else {
+            detectedTrimWindow = nil
+            return
         }
+        let sessionEnd = session.endedAt ?? session.lastObservedAt
+        detectedTrimWindow = ChargingWindowDetector.detect(
+            samples: session.aggregatedSamples,
+            sessionStart: session.startedAt,
+            sessionEnd: sessionEnd
+        )
     }
 
     // MARK: - Computed Properties
@@ -224,10 +234,38 @@ struct MeterChargeRecordContentView: View {
         appData.currentChargedDeviceSummary(for: meterMACAddress)
     }
 
+    private var availableChargedDevices: [ChargedDeviceSummary] {
+        appData.deviceSummaries
+    }
+
+    private var selectedChargedDeviceID: Binding<UUID?> {
+        Binding(
+            get: { selectedChargedDevice?.id },
+            set: { newValue in
+                guard let newValue else { return }
+                _ = appData.assignChargedDevice(newValue, to: meterMACAddress)
+            }
+        )
+    }
+
     private var selectedCharger: ChargedDeviceSummary? {
         appData.currentChargerSummary(for: meterMACAddress)
     }
 
+    private var availableChargers: [ChargedDeviceSummary] {
+        appData.chargerSummaries
+    }
+
+    private var selectedChargerID: Binding<UUID?> {
+        Binding(
+            get: { selectedCharger?.id },
+            set: { newValue in
+                guard let newValue else { return }
+                _ = appData.assignCharger(newValue, to: meterMACAddress)
+            }
+        )
+    }
+
     private var openChargeSession: ChargeSessionSummary? {
         appData.activeChargeSessionSummary(for: meterMACAddress)
     }
@@ -337,10 +375,26 @@ struct MeterChargeRecordContentView: View {
         }
     }
 
-    private var sessionChartTimeRange: ClosedRange<Date>? {
-        guard let openChargeSession else { return nil }
-        let end = openChargeSession.pausedAt ?? openChargeSession.lastObservedAt
-        return openChargeSession.startedAt...max(end, openChargeSession.startedAt)
+    private func shouldShowSessionChart(for session: ChargeSessionSummary) -> Bool {
+        sessionChartFixedTimeRange(for: session) != nil || usesChargeRecordBuffer(for: session)
+    }
+
+    private func sessionChartFixedTimeRange(for session: ChargeSessionSummary) -> ClosedRange<Date>? {
+        if usesChargeRecordBuffer(for: session) {
+            return nil
+        }
+        return session.effectiveTimeRange
+    }
+
+    private func sessionChartLiveTrimBounds(for session: ChargeSessionSummary) -> (lower: Date?, upper: Date?) {
+        guard usesChargeRecordBuffer(for: session) else {
+            return (nil, nil)
+        }
+        return (session.trimStart, session.trimEnd)
+    }
+
+    private func usesChargeRecordBuffer(for session: ChargeSessionSummary) -> Bool {
+        session.status.isOpen && session.meterMACAddress == meterMACAddress
     }
 
     private var showsWirelessChargerSection: Bool {
@@ -386,21 +440,29 @@ struct MeterChargeRecordContentView: View {
         VStack(alignment: .leading, spacing: 0) {
             // Device
             setupRow(icon: "iphone", iconColor: .blue) {
-                if let device = selectedChargedDevice {
-                    ChargedDeviceIdentityLabelView(chargedDevice: device, iconPointSize: 15)
-                        .font(.subheadline.weight(.semibold))
-                } else {
-                    Text("No device selected")
-                        .foregroundColor(.secondary)
-                        .font(.subheadline)
-                }
-                Spacer(minLength: 8)
-                Button(selectedChargedDevice == nil ? "Select" : "Change") {
-                    onSelectDevice(meterMACAddress, usbMeter.color)
+                Picker(selection: selectedChargedDeviceID) {
+                    Text("Choose device").tag(UUID?.none)
+                    ForEach(availableChargedDevices) { device in
+                        Text(device.name).tag(Optional(device.id))
+                    }
+                } label: {
+                    HStack(spacing: 8) {
+                        if let device = selectedChargedDevice {
+                            ChargedDeviceIdentityLabelView(chargedDevice: device, iconPointSize: 15)
+                                .font(.subheadline.weight(.semibold))
+                        } else {
+                            Text(availableChargedDevices.isEmpty ? "No devices available" : "Choose device")
+                                .foregroundColor(.secondary)
+                                .font(.subheadline)
+                        }
+                        Spacer(minLength: 8)
+                        Image(systemName: "chevron.up.chevron.down")
+                            .font(.caption.weight(.semibold))
+                            .foregroundColor(.secondary)
+                    }
                 }
-                .font(.caption.weight(.semibold))
-                .buttonStyle(.bordered)
-                .controlSize(.small)
+                .pickerStyle(.menu)
+                .disabled(availableChargedDevices.isEmpty)
             }
 
             // Charging type — only when device supports multiple
@@ -449,26 +511,34 @@ struct MeterChargeRecordContentView: View {
             if showsWirelessChargerSection {
                 Divider().padding(.leading, 46)
                 setupRow(icon: "antenna.radiowaves.left.and.right", iconColor: .teal) {
-                    if let charger = selectedCharger {
-                        ChargedDeviceIdentityLabelView(chargedDevice: charger, iconPointSize: 15)
-                            .font(.subheadline.weight(.semibold))
-                        if charger.chargerIdleCurrentAmps == nil {
-                            Image(systemName: "exclamationmark.triangle.fill")
-                                .foregroundColor(.orange)
-                                .font(.caption)
+                    Picker(selection: selectedChargerID) {
+                        Text("Choose charger").tag(UUID?.none)
+                        ForEach(availableChargers) { charger in
+                            Text(charger.name).tag(Optional(charger.id))
+                        }
+                    } label: {
+                        HStack(spacing: 8) {
+                            if let charger = selectedCharger {
+                                ChargedDeviceIdentityLabelView(chargedDevice: charger, iconPointSize: 15)
+                                    .font(.subheadline.weight(.semibold))
+                                if charger.chargerIdleCurrentAmps == nil {
+                                    Image(systemName: "exclamationmark.triangle.fill")
+                                        .foregroundColor(.orange)
+                                        .font(.caption)
+                                }
+                            } else {
+                                Text(availableChargers.isEmpty ? "No chargers available" : "Choose charger")
+                                    .foregroundColor(.secondary)
+                                    .font(.subheadline)
+                            }
+                            Spacer(minLength: 8)
+                            Image(systemName: "chevron.up.chevron.down")
+                                .font(.caption.weight(.semibold))
+                                .foregroundColor(.secondary)
                         }
-                    } else {
-                        Text("No charger selected")
-                            .foregroundColor(.secondary)
-                            .font(.subheadline)
-                    }
-                    Spacer(minLength: 8)
-                    Button(selectedCharger == nil ? "Select" : "Change") {
-                        onSelectCharger(meterMACAddress, usbMeter.color)
                     }
-                    .font(.caption.weight(.semibold))
-                    .buttonStyle(.bordered)
-                    .controlSize(.small)
+                    .pickerStyle(.menu)
+                    .disabled(availableChargers.isEmpty)
                 }
             }
 
@@ -758,7 +828,7 @@ struct MeterChargeRecordContentView: View {
     ) -> some View {
         let percent = prediction.predictedPercent
         let color = batteryColor(for: percent)
-        let duration = max(session.effectiveDuration, 0)
+        let duration = displayedSessionDuration(for: session)
         let rateWhPerSec: Double? = duration > 300 && displayedEnergyWh > 0.01
             ? displayedEnergyWh / duration
             : nil
@@ -908,6 +978,7 @@ struct MeterChargeRecordContentView: View {
         displayedEnergyWh: Double,
         hasPrediction: Bool
     ) -> some View {
+        let displayedDuration = displayedSessionDuration(for: session)
         let capacityFallback: Double? = hasPrediction ? nil : (
             session.capacityEstimateWh
                 ?? selectedChargedDevice?.estimatedBatteryCapacityWh(for: session.chargingTransportMode)
@@ -917,7 +988,7 @@ struct MeterChargeRecordContentView: View {
 
         return LazyVGrid(columns: columns, spacing: 8) {
             metricCell(label: "Energy", value: "\(displayedEnergyWh.format(decimalDigits: 3)) Wh", tint: .blue)
-            metricCell(label: "Duration", value: formatDuration(max(session.effectiveDuration, 0)), tint: .teal)
+            metricCell(label: "Duration", value: formatDuration(displayedDuration), tint: .teal)
 
             if shouldShowChargingTransport(for: session) {
                 metricCell(label: "Type", value: session.chargingTransportMode.title, tint: .orange)
@@ -1253,7 +1324,62 @@ struct MeterChargeRecordContentView: View {
         finalCheckpointText = next.format(decimalDigits: 0)
     }
 
-    private func sessionChartCard(timeRange: ClosedRange<Date>, session: ChargeSessionSummary) -> some View {
+    // MARK: - Trim Detection Banner
+
+    @ViewBuilder
+    private func trimDetectionBanner(for session: ChargeSessionSummary) -> some View {
+        if let window = detectedTrimWindow {
+            HStack(spacing: 12) {
+                Image(systemName: "scissors.circle.fill")
+                    .font(.title3)
+                    .foregroundColor(.blue)
+
+                VStack(alignment: .leading, spacing: 2) {
+                    Text("Charging ended early")
+                        .font(.subheadline.weight(.semibold))
+                    Text("Active charging detected between \(window.start.format(as: "HH:mm")) and \(window.end.format(as: "HH:mm")). The rest may be standby or another device.")
+                        .font(.caption)
+                        .foregroundColor(.secondary)
+                        .fixedSize(horizontal: false, vertical: true)
+                }
+
+                Spacer(minLength: 0)
+
+                VStack(spacing: 6) {
+                    Button("Apply") {
+                        _ = appData.setSessionTrim(
+                            sessionID: session.id,
+                            start: window.start,
+                            end: window.end
+                        )
+                        trimBannerDismissedForSessionID = session.id
+                    }
+                    .font(.caption.weight(.semibold))
+                    .buttonStyle(.borderedProminent)
+                    .controlSize(.small)
+                    .tint(.blue)
+
+                    Button {
+                        trimBannerDismissedForSessionID = session.id
+                    } label: {
+                        Image(systemName: "xmark")
+                            .font(.caption2.weight(.semibold))
+                            .foregroundColor(.secondary)
+                    }
+                    .buttonStyle(.plain)
+                }
+            }
+            .padding(14)
+            .background(
+                RoundedRectangle(cornerRadius: 14)
+                    .fill(Color.blue.opacity(0.10))
+                    .overlay(RoundedRectangle(cornerRadius: 14).stroke(Color.blue.opacity(0.22), lineWidth: 1))
+            )
+            .transition(.opacity.combined(with: .move(edge: .top)))
+        }
+    }
+
+    private func sessionChartCard(timeRange: ClosedRange<Date>?, session: ChargeSessionSummary) -> some View {
         VStack(alignment: .leading, spacing: 12) {
             HStack(spacing: 8) {
                 Image(systemName: "chart.xyaxis.line")
@@ -1262,8 +1388,11 @@ struct MeterChargeRecordContentView: View {
                     .font(.headline)
                 ContextInfoButton(
                     title: "Session Chart",
-                    message: "The chart is scoped to the explicit session window for \(session.sessionKind.shortTitle.lowercased()) charging."
+                    message: usesChargeRecordBuffer(for: session)
+                        ? "This chart combines the persisted session curve with current live data from this meter."
+                        : "This chart is scoped to the saved session window for \(session.sessionKind.shortTitle.lowercased()) charging."
                 )
+                Spacer(minLength: 0)
             }
 
             GeometryReader { geometry in
@@ -1275,10 +1404,41 @@ struct MeterChargeRecordContentView: View {
                     compactLayout: compactChartLayout,
                     availableSize: CGSize(width: chartWidth, height: chartHeight),
                     timeRange: timeRange,
-                    showsRangeSelector: false,
-                    rebasesEnergyToVisibleRangeStart: true
+                    timeRangeLowerBound: sessionChartLiveTrimBounds(for: session).lower,
+                    timeRangeUpperBound: sessionChartLiveTrimBounds(for: session).upper,
+                    showsRangeSelector: session.aggregatedSamples.isEmpty == false,
+                    rebasesEnergyToVisibleRangeStart: true,
+                    extendsTimelineToPresent: false,
+                    rangeSelectorConfiguration: session.aggregatedSamples.isEmpty
+                        ? nil
+                        : MeasurementChartRangeSelectorConfiguration(
+                            keepAction: MeasurementChartSelectionAction(
+                                title: compactChartLayout ? "Keep" : "Keep Selection",
+                                systemName: "scissors",
+                                tone: .destructive,
+                                handler: { range in
+                                    _ = appData.setSessionTrim(
+                                        sessionID: session.id,
+                                        start: range.lowerBound,
+                                        end: range.upperBound
+                                    )
+                                    trimBannerDismissedForSessionID = session.id
+                                }
+                            ),
+                            removeAction: nil,
+                            resetAction: MeasurementChartResetAction(
+                                title: compactChartLayout ? "Reset" : "Reset Trim",
+                                systemName: "arrow.counterclockwise",
+                                tone: .reversible,
+                                confirmationTitle: "Reset session trim?",
+                                confirmationButtonTitle: "Reset trim",
+                                handler: {
+                                    _ = appData.setSessionTrim(sessionID: session.id, start: nil, end: nil)
+                                }
+                            )
+                        )
                 )
-                .environmentObject(usbMeter.measurements)
+                .environmentObject(usbMeter.chargeRecordMeasurements)
                 .frame(maxWidth: .infinity, alignment: .topLeading)
             }
             .frame(height: 350)
@@ -1382,7 +1542,7 @@ struct MeterChargeRecordContentView: View {
         }
 
         rows.append(SessionMetricRow(label: "Energy", value: "\(displayedEnergyWh.format(decimalDigits: 3)) Wh"))
-        rows.append(SessionMetricRow(label: "Duration", value: formatDuration(max(session.effectiveDuration, 0))))
+        rows.append(SessionMetricRow(label: "Duration", value: formatDuration(displayedSessionDuration(for: session))))
         rows.append(SessionMetricRow(label: "Auto Stop", value: autoStopLabel(for: session)))
         return rows
     }
@@ -1401,6 +1561,7 @@ struct MeterChargeRecordContentView: View {
 
     private func displayedSessionEnergyWh(for session: ChargeSessionSummary) -> Double {
         let storedEnergyWh = session.effectiveOrMeasuredEnergyWh
+        guard session.isTrimmed == false else { return storedEnergyWh }
         guard session.status.isOpen else { return storedEnergyWh }
         guard session.meterMACAddress == meterMACAddress else { return storedEnergyWh }
         if let baselineEnergyWh = session.meterEnergyBaselineWh {
@@ -1411,6 +1572,7 @@ struct MeterChargeRecordContentView: View {
 
     private func displayedSessionChargeAh(for session: ChargeSessionSummary) -> Double {
         let storedChargeAh = session.measuredChargeAh
+        guard session.isTrimmed == false else { return storedChargeAh }
         guard session.status.isOpen else { return storedChargeAh }
         guard session.meterMACAddress == meterMACAddress else { return storedChargeAh }
         if let baselineChargeAh = session.meterChargeBaselineAh {
@@ -1419,6 +1581,14 @@ struct MeterChargeRecordContentView: View {
         return storedChargeAh
     }
 
+    private func displayedSessionDuration(for session: ChargeSessionSummary) -> TimeInterval {
+        let storedDuration = max(session.effectiveDuration, 0)
+        guard session.isTrimmed == false else { return storedDuration }
+        guard session.status.isOpen else { return storedDuration }
+        guard session.meterMACAddress == meterMACAddress else { return storedDuration }
+        return max(storedDuration, max(usbMeter.chargeRecordDuration, 0))
+    }
+
     private func formatDuration(_ duration: TimeInterval) -> String {
         let totalSeconds = Int(duration.rounded(.down))
         let hours = totalSeconds / 3600
@@ -1547,4 +1717,3 @@ struct MeterChargeRecordContentView: View {
         .buttonStyle(.plain)
     }
 }
-


	@@ -58,6 +58,8 @@ final class AppData : ObservableObject {
58	58	private var chargeInsightsStore: ChargeInsightsStore?
59	59	private let chargerStandbyPowerStore = ChargerStandbyPowerStore()
60	60	private let chargeNotificationCoordinator = ChargeNotificationCoordinator()
	61	+ private var meterSummariesCache: (version: Int, summaries: [MeterSummary])?
	62	+ private var meterSummariesVersion: Int = 0
61	63
62	64	init() {
63	65	bluetoothManagerNotification = bluetoothManager.objectWillChange.sink { [weak self] _ in
	@@ -66,7 +68,9 @@ final class AppData : ObservableObject {
66	68	meterStoreObserver = NotificationCenter.default.publisher(for: .meterNameStoreDidChange)
67	69	.receive(on: DispatchQueue.main)
68	70	.sink { [weak self] _ in
	71	+ self?.invalidateMeterSummaries()
69	72	self?.refreshMeterMetadata()
	73	+ self?.scheduleObjectWillChange()
70	74	}
71	75	meterStoreCloudObserver = NotificationCenter.default.publisher(for: .meterNameStoreCloudStatusDidChange)
72	76	.receive(on: DispatchQueue.main)
	@@ -84,7 +88,11 @@ final class AppData : ObservableObject {
84	88
85	89	@Published var enableRecordFeature: Bool = true
86	90
87		- @Published var meters: [UUID:Meter] = [UUID:Meter]()
	91	+ @Published var meters: [UUID:Meter] = [UUID:Meter]() {
	92	+ didSet {
	93	+ invalidateMeterSummaries()
	94	+ }
	95	+ }
88	96	@Published private(set) var chargedDevices: [ChargedDeviceSummary] = []
89	97	@Published private(set) var activeChargerStandbySessions: [String: ChargerStandbyPowerMonitorSession] = [:]
90	98
	@@ -268,10 +276,12 @@ final class AppData : ObservableObject {
268	276	}
269	277
270	278	func activeChargeSessionSummary(for meterMACAddress: String) -> ChargeSessionSummary? {
271		- if let cachedSummary = cachedActiveChargeSessionSummary(for: meterMACAddress) {
	279	+ let normalizedMAC = Self.normalizedMACAddress(meterMACAddress)
	280	+
	281	+ if let cachedSummary = cachedActiveChargeSessionSummary(for: normalizedMAC) {
272	282	return cachedSummary
273	283	}
274		- return chargeInsightsStore?.activeChargeSessionSummary(forMeterMACAddress: meterMACAddress)
	284	+ return chargeInsightsStore?.activeChargeSessionSummary(forMeterMACAddress: normalizedMAC)
275	285	}
276	286
277	287	func chargerStandbyMeasurementSession(for meterMACAddress: String) -> ChargerStandbyPowerMonitorSession? {
	@@ -516,14 +526,19 @@ final class AppData : ObservableObject {
516	526	startsFromFlatBattery: startsFromFlatBattery
517	527	) ?? false
518	528	if didSave {
519		- reloadChargedDevices()
520	529	meter.resetChargeRecordGraph()
521		- if let activeSession = activeChargeSessionSummary(for: meter.btSerial.macAddress.description),
	530	+ let activeSession = chargeInsightsStore?.activeChargeSessionSummary(
	531	+ forMeterMACAddress: meter.btSerial.macAddress.description
	532	+ )
	533	+ if let activeSession,
522	534	meter.supportsRecordingThreshold,
523	535	activeSession.stopThresholdAmps > 0 {
524	536	meter.recordingTreshold = activeSession.stopThresholdAmps
525	537	}
526		- restoreChargeMonitoringStateIfNeeded(for: meter)
	538	+ if let activeSession {
	539	+ meter.restoreChargeMonitoringIfNeeded(from: activeSession)
	540	+ }
	541	+ reloadChargedDevices()
527	542	}
528	543	return didSave
529	544	}
	@@ -698,6 +713,19 @@ final class AppData : ObservableObject {
698	713	return didDelete
699	714	}
700	715
	716	+ @discardableResult
	717	+ func setSessionTrim(sessionID: UUID, start: Date?, end: Date?) -> Bool {
	718	+ let didSave = chargeInsightsStore?.setSessionTrim(
	719	+ sessionID: sessionID,
	720	+ start: start,
	721	+ end: end
	722	+ ) ?? false
	723	+ if didSave {
	724	+ reloadChargedDevices()
	725	+ }
	726	+ return didSave
	727	+ }
	728	+
701	729	@discardableResult
702	730	func flushChargeInsights() -> Bool {
703	731	let didFlushObservations = flushAllPendingChargeObservations()
	@@ -837,11 +865,15 @@ final class AppData : ObservableObject {
837	865	}
838	866
839	867	var meterSummaries: [MeterSummary] {
	868	+ if let meterSummariesCache, meterSummariesCache.version == meterSummariesVersion {
	869	+ return meterSummariesCache.summaries
	870	+ }
	871	+
840	872	let liveMetersByMAC = Dictionary(uniqueKeysWithValues: meters.values.map { ($0.btSerial.macAddress.description, $0) })
841	873	let recordsByMAC = Dictionary(uniqueKeysWithValues: meterStore.allRecords().map { ($0.macAddress, $0) })
842	874	let macAddresses = Set(recordsByMAC.keys).union(liveMetersByMAC.keys)
843	875
844		- return macAddresses.map { macAddress in
	876	+ let summaries = macAddresses.map { macAddress in
845	877	let liveMeter = liveMetersByMAC[macAddress]
846	878	let record = recordsByMAC[macAddress]
847	879
	@@ -868,6 +900,9 @@ final class AppData : ObservableObject {
868	900	}
869	901	return lhs.macAddress < rhs.macAddress
870	902	}
	903	+
	904	+ meterSummariesCache = (version: meterSummariesVersion, summaries: summaries)
	905	+ return summaries
871	906	}
872	907
873	908	private func scheduleObjectWillChange() {
	@@ -876,6 +911,11 @@ final class AppData : ObservableObject {
876	911	}
877	912	}
878	913
	914	+ private func invalidateMeterSummaries() {
	915	+ meterSummariesVersion += 1
	916	+ meterSummariesCache = nil
	917	+ }
	918	+
879	919	private func scheduleChargedDevicesReload(delay: TimeInterval = 0.15) {
880	920	pendingChargedDevicesReloadWorkItem?.cancel()
881	921
	@@ -1168,6 +1208,9 @@ final class AppData : ObservableObject {
1168	1208
1169	1209	private func displayedSessionEnergyWh(for session: ChargeSessionSummary, on meter: Meter) -> Double {
1170	1210	let storedEnergyWh = session.effectiveOrMeasuredEnergyWh
	1211	+ guard session.isTrimmed == false else {
	1212	+ return storedEnergyWh
	1213	+ }
1171	1214	guard session.status.isOpen else {
1172	1215	return storedEnergyWh
1173	1216	}
	@@ -1185,6 +1228,9 @@ final class AppData : ObservableObject {
1185	1228
1186	1229	private func displayedSessionChargeAh(for session: ChargeSessionSummary, on meter: Meter) -> Double {
1187	1230	let storedChargeAh = session.measuredChargeAh
	1231	+ guard session.isTrimmed == false else {
	1232	+ return storedChargeAh
	1233	+ }
1188	1234	guard session.status.isOpen else {
1189	1235	return storedChargeAh
1190	1236	}

	@@ -10,44 +10,8 @@ struct MeterChargeRecordTabView: View, Equatable {
10	10	true
11	11	}
12	12
13		- @EnvironmentObject private var appData: AppData
14		-
15		- @State private var chargedDeviceLibraryVisibility = false
16		- @State private var chargerLibraryVisibility = false
17		- @State private var deviceLibraryMACAddress = ""
18		- @State private var chargerLibraryMACAddress = ""
19		- @State private var chargedDeviceLibraryTint: Color = .orange
20		- @State private var chargerLibraryTint: Color = .pink
21		-
22	13	var body: some View {
23		- MeterChargeRecordContentView(
24		- onSelectDevice: { mac, tint in
25		- deviceLibraryMACAddress = mac
26		- chargedDeviceLibraryTint = tint
27		- chargedDeviceLibraryVisibility = true
28		- },
29		- onSelectCharger: { mac, tint in
30		- chargerLibraryMACAddress = mac
31		- chargerLibraryTint = tint
32		- chargerLibraryVisibility = true
33		- }
34		- )
35		- .sheet(isPresented: $chargedDeviceLibraryVisibility) {
36		- ChargedDeviceLibrarySheetView(
37		- meterMACAddress: deviceLibraryMACAddress,
38		- meterTint: chargedDeviceLibraryTint,
39		- mode: .device
40		- )
41		- .environmentObject(appData)
42		- }
43		- .sheet(isPresented: $chargerLibraryVisibility) {
44		- ChargedDeviceLibrarySheetView(
45		- meterMACAddress: chargerLibraryMACAddress,
46		- meterTint: chargerLibraryTint,
47		- mode: .charger
48		- )
49		- .environmentObject(appData)
50		- }
	14	+ MeterChargeRecordContentView()
51	15	}
52	16	}
53	17
	@@ -134,9 +98,6 @@ struct MeterChargeRecordContentView: View {
134	98	}
135	99	}
136	100
137		- let onSelectDevice: (String, Color) -> Void
138		- let onSelectCharger: (String, Color) -> Void
139		-
140	101	@EnvironmentObject private var appData: AppData
141	102	@EnvironmentObject private var usbMeter: Meter
142	103
	@@ -152,6 +113,16 @@ struct MeterChargeRecordContentView: View {
152	113	@State private var initialCheckpoint = ""
153	114	@State private var showsMeterTotalsInfo = false
154	115	@State private var activeMode: ActiveMode = .chargeSession
	116	+ @State private var detectedTrimWindow: ChargingWindowDetector.DetectedWindow?
	117	+ @State private var trimBannerDismissedForSessionID: UUID?
	118	+
	119	+ private var shouldShowTrimBanner: Bool {
	120	+ guard let session = openChargeSession,
	121	+ session.isTrimmed == false,
	122	+ trimBannerDismissedForSessionID != session.id else { return false }
	123	+ guard let window = detectedTrimWindow else { return false }
	124	+ return window.trimRatio > ChargingWindowDetector.significantTrimThreshold
	125	+ }
155	126
156	127	var body: some View {
157	128	ScrollView {
	@@ -161,8 +132,15 @@ struct MeterChargeRecordContentView: View {
161	132	if let openChargeSession {
162	133	chargingMonitorCard(openChargeSession)
163	134
164		- if let range = sessionChartTimeRange {
165		- sessionChartCard(timeRange: range, session: openChargeSession)
	135	+ if shouldShowTrimBanner {
	136	+ trimDetectionBanner(for: openChargeSession)
	137	+ }
	138	+
	139	+ if shouldShowSessionChart(for: openChargeSession) {
	140	+ sessionChartCard(
	141	+ timeRange: sessionChartFixedTimeRange(for: openChargeSession),
	142	+ session: openChargeSession
	143	+ )
166	144	}
167	145	} else {
168	146	liveMeterStripView
	@@ -202,16 +180,48 @@ struct MeterChargeRecordContentView: View {
202	180	)
203	181	}
204	182	.onAppear {
	183	+ syncActiveSessionRestore()
205	184	syncDraftSelections()
	185	+ runTrimDetection()
206	186	}
207	187	.onChange(of: selectedChargedDevice?.id) { _ in
208	188	syncDraftSelections()
209	189	}
210	190	.onChange(of: openChargeSession?.id) { _ in
	191	+ syncActiveSessionRestore()
211	192	syncDraftSelections()
212	193	showingInlineTargetEditor = false
213	194	draftTargetText = ""
	195	+ detectedTrimWindow = nil
	196	+ trimBannerDismissedForSessionID = nil
	197	+ runTrimDetection()
	198	+ }
	199	+ .onChange(of: openChargeSession?.aggregatedSamples.count) { _ in
	200	+ syncActiveSessionRestore()
	201	+ runTrimDetection()
	202	+ }
	203	+ }
	204	+
	205	+ private func syncActiveSessionRestore() {
	206	+ guard let session = openChargeSession else { return }
	207	+ guard session.status == .active else { return }
	208	+ guard session.meterMACAddress == meterMACAddress else { return }
	209	+ usbMeter.restoreChargeRecordIfNeeded(from: session)
	210	+ }
	211	+
	212	+ private func runTrimDetection() {
	213	+ guard let session = openChargeSession,
	214	+ session.isTrimmed == false,
	215	+ !session.aggregatedSamples.isEmpty else {
	216	+ detectedTrimWindow = nil
	217	+ return
214	218	}
	219	+ let sessionEnd = session.endedAt ?? session.lastObservedAt
	220	+ detectedTrimWindow = ChargingWindowDetector.detect(
	221	+ samples: session.aggregatedSamples,
	222	+ sessionStart: session.startedAt,
	223	+ sessionEnd: sessionEnd
	224	+ )
215	225	}
216	226
217	227	// MARK: - Computed Properties
	@@ -224,10 +234,38 @@ struct MeterChargeRecordContentView: View {
224	234	appData.currentChargedDeviceSummary(for: meterMACAddress)
225	235	}
226	236
	237	+ private var availableChargedDevices: [ChargedDeviceSummary] {
	238	+ appData.deviceSummaries
	239	+ }
	240	+
	241	+ private var selectedChargedDeviceID: Binding<UUID?> {
	242	+ Binding(
	243	+ get: { selectedChargedDevice?.id },
	244	+ set: { newValue in
	245	+ guard let newValue else { return }
	246	+ _ = appData.assignChargedDevice(newValue, to: meterMACAddress)
	247	+ }
	248	+ )
	249	+ }
	250	+
227	251	private var selectedCharger: ChargedDeviceSummary? {
228	252	appData.currentChargerSummary(for: meterMACAddress)
229	253	}
230	254
	255	+ private var availableChargers: [ChargedDeviceSummary] {
	256	+ appData.chargerSummaries
	257	+ }
	258	+
	259	+ private var selectedChargerID: Binding<UUID?> {
	260	+ Binding(
	261	+ get: { selectedCharger?.id },
	262	+ set: { newValue in
	263	+ guard let newValue else { return }
	264	+ _ = appData.assignCharger(newValue, to: meterMACAddress)
	265	+ }
	266	+ )
	267	+ }
	268	+
231	269	private var openChargeSession: ChargeSessionSummary? {
232	270	appData.activeChargeSessionSummary(for: meterMACAddress)
233	271	}
	@@ -337,10 +375,26 @@ struct MeterChargeRecordContentView: View {
337	375	}
338	376	}
339	377
340		- private var sessionChartTimeRange: ClosedRange<Date>? {
341		- guard let openChargeSession else { return nil }
342		- let end = openChargeSession.pausedAt ?? openChargeSession.lastObservedAt
343		- return openChargeSession.startedAt...max(end, openChargeSession.startedAt)
	378	+ private func shouldShowSessionChart(for session: ChargeSessionSummary) -> Bool {
	379	+ sessionChartFixedTimeRange(for: session) != nil \|\| usesChargeRecordBuffer(for: session)
	380	+ }
	381	+
	382	+ private func sessionChartFixedTimeRange(for session: ChargeSessionSummary) -> ClosedRange<Date>? {
	383	+ if usesChargeRecordBuffer(for: session) {
	384	+ return nil
	385	+ }
	386	+ return session.effectiveTimeRange
	387	+ }
	388	+
	389	+ private func sessionChartLiveTrimBounds(for session: ChargeSessionSummary) -> (lower: Date?, upper: Date?) {
	390	+ guard usesChargeRecordBuffer(for: session) else {
	391	+ return (nil, nil)
	392	+ }
	393	+ return (session.trimStart, session.trimEnd)
	394	+ }
	395	+
	396	+ private func usesChargeRecordBuffer(for session: ChargeSessionSummary) -> Bool {
	397	+ session.status.isOpen && session.meterMACAddress == meterMACAddress
344	398	}
345	399
346	400	private var showsWirelessChargerSection: Bool {
	@@ -386,21 +440,29 @@ struct MeterChargeRecordContentView: View {
386	440	VStack(alignment: .leading, spacing: 0) {
387	441	// Device
388	442	setupRow(icon: "iphone", iconColor: .blue) {
389		- if let device = selectedChargedDevice {
390		- ChargedDeviceIdentityLabelView(chargedDevice: device, iconPointSize: 15)
391		- .font(.subheadline.weight(.semibold))
392		- } else {
393		- Text("No device selected")
394		- .foregroundColor(.secondary)
395		- .font(.subheadline)
396		- }
397		- Spacer(minLength: 8)
398		- Button(selectedChargedDevice == nil ? "Select" : "Change") {
399		- onSelectDevice(meterMACAddress, usbMeter.color)
	443	+ Picker(selection: selectedChargedDeviceID) {
	444	+ Text("Choose device").tag(UUID?.none)
	445	+ ForEach(availableChargedDevices) { device in
	446	+ Text(device.name).tag(Optional(device.id))
	447	+ }
	448	+ } label: {
	449	+ HStack(spacing: 8) {
	450	+ if let device = selectedChargedDevice {
	451	+ ChargedDeviceIdentityLabelView(chargedDevice: device, iconPointSize: 15)
	452	+ .font(.subheadline.weight(.semibold))
	453	+ } else {
	454	+ Text(availableChargedDevices.isEmpty ? "No devices available" : "Choose device")
	455	+ .foregroundColor(.secondary)
	456	+ .font(.subheadline)
	457	+ }
	458	+ Spacer(minLength: 8)
	459	+ Image(systemName: "chevron.up.chevron.down")
	460	+ .font(.caption.weight(.semibold))
	461	+ .foregroundColor(.secondary)
	462	+ }
400	463	}
401		- .font(.caption.weight(.semibold))
402		- .buttonStyle(.bordered)
403		- .controlSize(.small)
	464	+ .pickerStyle(.menu)
	465	+ .disabled(availableChargedDevices.isEmpty)
404	466	}
405	467
406	468	// Charging type — only when device supports multiple
	@@ -449,26 +511,34 @@ struct MeterChargeRecordContentView: View {
449	511	if showsWirelessChargerSection {
450	512	Divider().padding(.leading, 46)
451	513	setupRow(icon: "antenna.radiowaves.left.and.right", iconColor: .teal) {
452		- if let charger = selectedCharger {
453		- ChargedDeviceIdentityLabelView(chargedDevice: charger, iconPointSize: 15)
454		- .font(.subheadline.weight(.semibold))
455		- if charger.chargerIdleCurrentAmps == nil {
456		- Image(systemName: "exclamationmark.triangle.fill")
457		- .foregroundColor(.orange)
458		- .font(.caption)
	514	+ Picker(selection: selectedChargerID) {
	515	+ Text("Choose charger").tag(UUID?.none)
	516	+ ForEach(availableChargers) { charger in
	517	+ Text(charger.name).tag(Optional(charger.id))
	518	+ }
	519	+ } label: {
	520	+ HStack(spacing: 8) {
	521	+ if let charger = selectedCharger {
	522	+ ChargedDeviceIdentityLabelView(chargedDevice: charger, iconPointSize: 15)
	523	+ .font(.subheadline.weight(.semibold))
	524	+ if charger.chargerIdleCurrentAmps == nil {
	525	+ Image(systemName: "exclamationmark.triangle.fill")
	526	+ .foregroundColor(.orange)
	527	+ .font(.caption)
	528	+ }
	529	+ } else {
	530	+ Text(availableChargers.isEmpty ? "No chargers available" : "Choose charger")
	531	+ .foregroundColor(.secondary)
	532	+ .font(.subheadline)
	533	+ }
	534	+ Spacer(minLength: 8)
	535	+ Image(systemName: "chevron.up.chevron.down")
	536	+ .font(.caption.weight(.semibold))
	537	+ .foregroundColor(.secondary)
459	538	}
460		- } else {
461		- Text("No charger selected")
462		- .foregroundColor(.secondary)
463		- .font(.subheadline)
464		- }
465		- Spacer(minLength: 8)
466		- Button(selectedCharger == nil ? "Select" : "Change") {
467		- onSelectCharger(meterMACAddress, usbMeter.color)
468	539	}
469		- .font(.caption.weight(.semibold))
470		- .buttonStyle(.bordered)
471		- .controlSize(.small)
	540	+ .pickerStyle(.menu)
	541	+ .disabled(availableChargers.isEmpty)
472	542	}
473	543	}
474	544
	@@ -758,7 +828,7 @@ struct MeterChargeRecordContentView: View {
758	828	) -> some View {
759	829	let percent = prediction.predictedPercent
760	830	let color = batteryColor(for: percent)
761		- let duration = max(session.effectiveDuration, 0)
	831	+ let duration = displayedSessionDuration(for: session)
762	832	let rateWhPerSec: Double? = duration > 300 && displayedEnergyWh > 0.01
763	833	? displayedEnergyWh / duration
764	834	: nil
	@@ -908,6 +978,7 @@ struct MeterChargeRecordContentView: View {
908	978	displayedEnergyWh: Double,
909	979	hasPrediction: Bool
910	980	) -> some View {
	981	+ let displayedDuration = displayedSessionDuration(for: session)
911	982	let capacityFallback: Double? = hasPrediction ? nil : (
912	983	session.capacityEstimateWh
913	984	?? selectedChargedDevice?.estimatedBatteryCapacityWh(for: session.chargingTransportMode)
	@@ -917,7 +988,7 @@ struct MeterChargeRecordContentView: View {
917	988
918	989	return LazyVGrid(columns: columns, spacing: 8) {
919	990	metricCell(label: "Energy", value: "\(displayedEnergyWh.format(decimalDigits: 3)) Wh", tint: .blue)
920		- metricCell(label: "Duration", value: formatDuration(max(session.effectiveDuration, 0)), tint: .teal)
	991	+ metricCell(label: "Duration", value: formatDuration(displayedDuration), tint: .teal)
921	992
922	993	if shouldShowChargingTransport(for: session) {
923	994	metricCell(label: "Type", value: session.chargingTransportMode.title, tint: .orange)
	@@ -1253,7 +1324,62 @@ struct MeterChargeRecordContentView: View {
1253	1324	finalCheckpointText = next.format(decimalDigits: 0)
1254	1325	}
1255	1326
1256		- private func sessionChartCard(timeRange: ClosedRange<Date>, session: ChargeSessionSummary) -> some View {
	1327	+ // MARK: - Trim Detection Banner
	1328	+
	1329	+ @ViewBuilder
	1330	+ private func trimDetectionBanner(for session: ChargeSessionSummary) -> some View {
	1331	+ if let window = detectedTrimWindow {
	1332	+ HStack(spacing: 12) {
	1333	+ Image(systemName: "scissors.circle.fill")
	1334	+ .font(.title3)
	1335	+ .foregroundColor(.blue)
	1336	+
	1337	+ VStack(alignment: .leading, spacing: 2) {
	1338	+ Text("Charging ended early")
	1339	+ .font(.subheadline.weight(.semibold))
	1340	+ Text("Active charging detected between \(window.start.format(as: "HH:mm")) and \(window.end.format(as: "HH:mm")). The rest may be standby or another device.")
	1341	+ .font(.caption)
	1342	+ .foregroundColor(.secondary)
	1343	+ .fixedSize(horizontal: false, vertical: true)
	1344	+ }
	1345	+
	1346	+ Spacer(minLength: 0)
	1347	+
	1348	+ VStack(spacing: 6) {
	1349	+ Button("Apply") {
	1350	+ _ = appData.setSessionTrim(
	1351	+ sessionID: session.id,
	1352	+ start: window.start,
	1353	+ end: window.end
	1354	+ )
	1355	+ trimBannerDismissedForSessionID = session.id
	1356	+ }
	1357	+ .font(.caption.weight(.semibold))
	1358	+ .buttonStyle(.borderedProminent)
	1359	+ .controlSize(.small)
	1360	+ .tint(.blue)
	1361	+
	1362	+ Button {
	1363	+ trimBannerDismissedForSessionID = session.id
	1364	+ } label: {
	1365	+ Image(systemName: "xmark")
	1366	+ .font(.caption2.weight(.semibold))
	1367	+ .foregroundColor(.secondary)
	1368	+ }
	1369	+ .buttonStyle(.plain)
	1370	+ }
	1371	+ }
	1372	+ .padding(14)
	1373	+ .background(
	1374	+ RoundedRectangle(cornerRadius: 14)
	1375	+ .fill(Color.blue.opacity(0.10))
	1376	+ .overlay(RoundedRectangle(cornerRadius: 14).stroke(Color.blue.opacity(0.22), lineWidth: 1))
	1377	+ )
	1378	+ .transition(.opacity.combined(with: .move(edge: .top)))
	1379	+ }
	1380	+ }
	1381	+
	1382	+ private func sessionChartCard(timeRange: ClosedRange<Date>?, session: ChargeSessionSummary) -> some View {
1257	1383	VStack(alignment: .leading, spacing: 12) {
1258	1384	HStack(spacing: 8) {
1259	1385	Image(systemName: "chart.xyaxis.line")
	@@ -1262,8 +1388,11 @@ struct MeterChargeRecordContentView: View {
1262	1388	.font(.headline)
1263	1389	ContextInfoButton(
1264	1390	title: "Session Chart",
1265		- message: "The chart is scoped to the explicit session window for \(session.sessionKind.shortTitle.lowercased()) charging."
	1391	+ message: usesChargeRecordBuffer(for: session)
	1392	+ ? "This chart combines the persisted session curve with current live data from this meter."
	1393	+ : "This chart is scoped to the saved session window for \(session.sessionKind.shortTitle.lowercased()) charging."
1266	1394	)
	1395	+ Spacer(minLength: 0)
1267	1396	}
1268	1397
1269	1398	GeometryReader { geometry in
	@@ -1275,10 +1404,41 @@ struct MeterChargeRecordContentView: View {
1275	1404	compactLayout: compactChartLayout,
1276	1405	availableSize: CGSize(width: chartWidth, height: chartHeight),
1277	1406	timeRange: timeRange,
1278		- showsRangeSelector: false,
1279		- rebasesEnergyToVisibleRangeStart: true
	1407	+ timeRangeLowerBound: sessionChartLiveTrimBounds(for: session).lower,
	1408	+ timeRangeUpperBound: sessionChartLiveTrimBounds(for: session).upper,
	1409	+ showsRangeSelector: session.aggregatedSamples.isEmpty == false,
	1410	+ rebasesEnergyToVisibleRangeStart: true,
	1411	+ extendsTimelineToPresent: false,
	1412	+ rangeSelectorConfiguration: session.aggregatedSamples.isEmpty
	1413	+ ? nil
	1414	+ : MeasurementChartRangeSelectorConfiguration(
	1415	+ keepAction: MeasurementChartSelectionAction(
	1416	+ title: compactChartLayout ? "Keep" : "Keep Selection",
	1417	+ systemName: "scissors",
	1418	+ tone: .destructive,
	1419	+ handler: { range in
	1420	+ _ = appData.setSessionTrim(
	1421	+ sessionID: session.id,
	1422	+ start: range.lowerBound,
	1423	+ end: range.upperBound
	1424	+ )
	1425	+ trimBannerDismissedForSessionID = session.id
	1426	+ }
	1427	+ ),
	1428	+ removeAction: nil,
	1429	+ resetAction: MeasurementChartResetAction(
	1430	+ title: compactChartLayout ? "Reset" : "Reset Trim",
	1431	+ systemName: "arrow.counterclockwise",
	1432	+ tone: .reversible,
	1433	+ confirmationTitle: "Reset session trim?",
	1434	+ confirmationButtonTitle: "Reset trim",
	1435	+ handler: {
	1436	+ _ = appData.setSessionTrim(sessionID: session.id, start: nil, end: nil)
	1437	+ }
	1438	+ )
	1439	+ )
1280	1440	)
1281		- .environmentObject(usbMeter.measurements)
	1441	+ .environmentObject(usbMeter.chargeRecordMeasurements)
1282	1442	.frame(maxWidth: .infinity, alignment: .topLeading)
1283	1443	}
1284	1444	.frame(height: 350)
	@@ -1382,7 +1542,7 @@ struct MeterChargeRecordContentView: View {
1382	1542	}
1383	1543
1384	1544	rows.append(SessionMetricRow(label: "Energy", value: "\(displayedEnergyWh.format(decimalDigits: 3)) Wh"))
1385		- rows.append(SessionMetricRow(label: "Duration", value: formatDuration(max(session.effectiveDuration, 0))))
	1545	+ rows.append(SessionMetricRow(label: "Duration", value: formatDuration(displayedSessionDuration(for: session))))
1386	1546	rows.append(SessionMetricRow(label: "Auto Stop", value: autoStopLabel(for: session)))
1387	1547	return rows
1388	1548	}
	@@ -1401,6 +1561,7 @@ struct MeterChargeRecordContentView: View {
1401	1561
1402	1562	private func displayedSessionEnergyWh(for session: ChargeSessionSummary) -> Double {
1403	1563	let storedEnergyWh = session.effectiveOrMeasuredEnergyWh
	1564	+ guard session.isTrimmed == false else { return storedEnergyWh }
1404	1565	guard session.status.isOpen else { return storedEnergyWh }
1405	1566	guard session.meterMACAddress == meterMACAddress else { return storedEnergyWh }
1406	1567	if let baselineEnergyWh = session.meterEnergyBaselineWh {
	@@ -1411,6 +1572,7 @@ struct MeterChargeRecordContentView: View {
1411	1572
1412	1573	private func displayedSessionChargeAh(for session: ChargeSessionSummary) -> Double {
1413	1574	let storedChargeAh = session.measuredChargeAh
	1575	+ guard session.isTrimmed == false else { return storedChargeAh }
1414	1576	guard session.status.isOpen else { return storedChargeAh }
1415	1577	guard session.meterMACAddress == meterMACAddress else { return storedChargeAh }
1416	1578	if let baselineChargeAh = session.meterChargeBaselineAh {
	@@ -1419,6 +1581,14 @@ struct MeterChargeRecordContentView: View {
1419	1581	return storedChargeAh
1420	1582	}
1421	1583
	1584	+ private func displayedSessionDuration(for session: ChargeSessionSummary) -> TimeInterval {
	1585	+ let storedDuration = max(session.effectiveDuration, 0)
	1586	+ guard session.isTrimmed == false else { return storedDuration }
	1587	+ guard session.status.isOpen else { return storedDuration }
	1588	+ guard session.meterMACAddress == meterMACAddress else { return storedDuration }
	1589	+ return max(storedDuration, max(usbMeter.chargeRecordDuration, 0))
	1590	+ }
	1591	+
1422	1592	private func formatDuration(_ duration: TimeInterval) -> String {
1423	1593	let totalSeconds = Int(duration.rounded(.down))
1424	1594	let hours = totalSeconds / 3600
	@@ -1547,4 +1717,3 @@ struct MeterChargeRecordContentView: View {
1547	1717	.buttonStyle(.plain)
1548	1718	}
1549	1719	}
1550		-