+		B0A000133C8F000100A10013 /* ConsumptionMonitorStore.swift in Sources */ = {isa = PBXBuildFile; fileRef = B0A000033C8F000100A10003 /* ConsumptionMonitorStore.swift */; };

+		B0A000143C8F000100A10014 /* ConsumptionMonitorView.swift in Sources */ = {isa = PBXBuildFile; fileRef = B0A000043C8F000100A10004 /* ConsumptionMonitorView.swift */; };

+		B0A000033C8F000100A10003 /* ConsumptionMonitorStore.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ConsumptionMonitorStore.swift; sourceTree = "<group>"; };

+		B0A000043C8F000100A10004 /* ConsumptionMonitorView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ConsumptionMonitorView.swift; sourceTree = "<group>"; };

+				B0A000033C8F000100A10003 /* ConsumptionMonitorStore.swift */,

+				B0A000043C8F000100A10004 /* ConsumptionMonitorView.swift */,

+				B0A000133C8F000100A10013 /* ConsumptionMonitorStore.swift in Sources */,

+				B0A000143C8F000100A10014 /* ConsumptionMonitorView.swift in Sources */,

+    private var consumptionMonitorStoreObserver: AnyCancellable?

+    private let consumptionMonitorStore = ConsumptionMonitorStore()

+        consumptionMonitorStoreObserver = NotificationCenter.default.publisher(for: .consumptionMonitorStoreDidChange)

+            .receive(on: DispatchQueue.main)

+            .sink { [weak self] _ in

+                self?.reloadChargedDevices()

+            }

+    @Published private(set) var activeConsumptionSessions: [String: ConsumptionMonitorLiveSession] = [:]

+        for powerbank in powerbanks {

+            if let session = (powerbank.sessionsAsSubject + powerbank.sessionsAsSource).first(where: { $0.id == id }) {

+                return session

+            }

+        }

+    // MARK: - Consumption Monitor

+

+    func consumptionMonitorSession(for meterMACAddress: String) -> ConsumptionMonitorLiveSession? {

+        activeConsumptionSessions[Self.normalizedMACAddress(meterMACAddress)]

+    }

+

+    @discardableResult

+    func startConsumptionMonitor(for deviceID: UUID, on meter: Meter) -> Bool {

+        let normalizedMAC = Self.normalizedMACAddress(meter.btSerial.macAddress.description)

+        if let existing = activeConsumptionSessions[normalizedMAC] {

+            return existing.chargedDeviceID == deviceID

+        }

+

+        let sessionID = UUID()

+        let now = Date()

+        let session = ConsumptionMonitorLiveSession(

+            sessionID: sessionID,

+            chargedDeviceID: deviceID,

+            meterMACAddress: meter.btSerial.macAddress.description,

+            startedAt: now

+        )

+

+        let meterSummary = meterSummaries.first { $0.macAddress == meter.btSerial.macAddress.description }

+        session.meterName = meterSummary?.displayName

+        session.meterModel = meterSummary?.modelSummary

+

+        session.onChange = { [weak self] in

+            self?.scheduleObjectWillChange()

+        }

+        session.onSample = { [weak self, weak session] sample in

+            guard let self, let session else { return }

+            self.consumptionMonitorStore.appendSample(sample, to: session.sessionID)

+        }

+

+        let initialRecord = ConsumptionMonitorSessionSummary(

+            id: sessionID,

+            chargedDeviceID: deviceID,

+            meterMACAddress: meter.btSerial.macAddress.description,

+            meterName: session.meterName,

+            meterModel: session.meterModel,

+            startedAt: now,

+            endedAt: nil,

+            samples: []

+        )

+        consumptionMonitorStore.save(initialRecord)

+

+        activeConsumptionSessions[normalizedMAC] = session

+        session.start()

+

+        if meter.operationalState == .peripheralNotConnected {

+            meter.connect()

+        }

+

+        reloadChargedDevices()

+        return true

+    }

+

+    @discardableResult

+    func stopConsumptionMonitor(for meterMACAddress: String, save: Bool) -> Bool {

+        let normalizedMAC = Self.normalizedMACAddress(meterMACAddress)

+        guard let session = activeConsumptionSessions[normalizedMAC] else { return false }

+

+        session.stop()

+        activeConsumptionSessions[normalizedMAC] = nil

+

+        if save {

+            consumptionMonitorStore.completeSession(id: session.sessionID, endedAt: Date())

+        } else {

+            consumptionMonitorStore.removeSession(id: session.sessionID, deviceID: session.chargedDeviceID)

+        }

+

+        reloadChargedDevices()

+        return true

+    }

+

+    @discardableResult

+    func deleteConsumptionSession(id: UUID, deviceID: UUID) -> Bool {

+        let didDelete = consumptionMonitorStore.removeSession(id: id, deviceID: deviceID)

+        if didDelete { reloadChargedDevices() }

+        return didDelete

+    }

+

+    @discardableResult

+    func startPowerbankChargeSession(

+        for meter: Meter,

+        powerbankID: UUID,

+        sourcePowerbankID: UUID? = nil,

+        initialBatteryPercent: Double?,

+        startsFromFlatBattery: Bool

+    ) -> Bool {

+        meter.resetMeterCountersForNewSession()

+

+        guard let snapshot = meter.chargingMonitorSnapshot else {

+            return false

+        }

+

+        let didSave = chargeInsightsStore?.startPowerbankSession(

+            for: snapshot,

+            powerbankID: powerbankID,

+            sourcePowerbankID: sourcePowerbankID,

+            autoStopEnabled: false,

+            initialBatteryPercent: initialBatteryPercent,

+            startsFromFlatBattery: startsFromFlatBattery

+        ) ?? false

+        if didSave {

+            meter.resetChargeRecordGraph()

+            if let activeSession = chargeInsightsStore?.activeChargeSessionSummary(

+                forMeterMACAddress: meter.btSerial.macAddress.description

+            ) {

+                meter.restoreChargeMonitoringIfNeeded(from: activeSession)

+            }

+            reloadChargedDevices()

+        }

+        return didSave

+    }

+

+

+        let normalizedMAC = Self.normalizedMACAddress(meter.btSerial.macAddress.description)

+        if let consumptionSession = activeConsumptionSessions[normalizedMAC] {

+            consumptionSession.observe(

+                powerWatts: snapshot.powerWatts,

+                currentAmps: snapshot.currentAmps,

+                voltageVolts: snapshot.voltageVolts,

+                observedAt: observedAt

+            )

+        }

+        let consumptionSessionsByDeviceID = consumptionMonitorStore.sessionsByDeviceID()

+                chargedDevice

+                    .withStandbyPowerMeasurements(standbyMeasurementsByChargerID[chargedDevice.id] ?? [])

+                    .withConsumptionSessions(consumptionSessionsByDeviceID[chargedDevice.id] ?? [])

+// MARK: - Consumption Monitor

+

+struct ConsumptionMonitorSample: Identifiable, Codable, Hashable {

+    var id: Int { bucketIndex }

+    let bucketIndex: Int

+    let timestamp: Date

+    let averagePowerWatts: Double

+    let averageCurrentAmps: Double

+    let averageVoltageVolts: Double

+    let sampleCount: Int

+    let cumulativeEnergyWh: Double

+}

+

+struct ConsumptionMonitorSessionSummary: Identifiable, Codable, Hashable {

+    let id: UUID

+    let chargedDeviceID: UUID

+    let meterMACAddress: String

+    let meterName: String?

+    let meterModel: String?

+    let startedAt: Date

+    var endedAt: Date?

+    var samples: [ConsumptionMonitorSample]

+

+    var isOpen: Bool { endedAt == nil }

+    var duration: TimeInterval { (endedAt ?? Date()).timeIntervalSince(startedAt) }

+    var totalEnergyWh: Double { samples.last?.cumulativeEnergyWh ?? 0 }

+    var sampleCount: Int { samples.count }

+

+    var averagePowerWatts: Double {

+        guard !samples.isEmpty else { return 0 }

+        return samples.map(\.averagePowerWatts).reduce(0, +) / Double(samples.count)

+    }

+    var minimumPowerWatts: Double { samples.map(\.averagePowerWatts).min() ?? 0 }

+    var maximumPowerWatts: Double { samples.map(\.averagePowerWatts).max() ?? 0 }

+    var averageCurrentAmps: Double {

+        guard !samples.isEmpty else { return 0 }

+        return samples.map(\.averageCurrentAmps).reduce(0, +) / Double(samples.count)

+    }

+    var averageVoltageVolts: Double {

+        guard !samples.isEmpty else { return 0 }

+        return samples.map(\.averageVoltageVolts).reduce(0, +) / Double(samples.count)

+    }

+

+    var projectedDailyEnergyWh: Double { averagePowerWatts * 24 }

+    var projectedWeeklyEnergyWh: Double { averagePowerWatts * 24 * 7 }

+    var projectedMonthlyEnergyWh: Double { averagePowerWatts * 24 * 30 }

+    var projectedYearlyEnergyWh: Double { averagePowerWatts * 24 * 365 }

+}

+

+    let consumptionSessions: [ConsumptionMonitorSessionSummary]

+            standbyPowerMeasurements: measurements,

+            consumptionSessions: consumptionSessions

+        )

+    }

+

+    func withConsumptionSessions(_ sessions: [ConsumptionMonitorSessionSummary]) -> ChargedDeviceSummary {

+        ChargedDeviceSummary(

+            id: id,

+            qrIdentifier: qrIdentifier,

+            name: name,

+            deviceClass: deviceClass,

+            deviceTemplateID: deviceTemplateID,

+            templateDefinition: templateDefinition,

+            profileID: profileID,

+            hasInternalSubject: hasInternalSubject,

+            supportsChargingWhileOff: supportsChargingWhileOff,

+            chargingStateAvailability: chargingStateAvailability,

+            supportsWiredCharging: supportsWiredCharging,

+            supportsWirelessCharging: supportsWirelessCharging,

+            chargerType: chargerType,

+            wirelessChargingProfile: wirelessChargingProfile,

+            configuredCompletionCurrents: configuredCompletionCurrents,

+            learnedCompletionCurrents: learnedCompletionCurrents,

+            wirelessChargerEfficiencyFactor: wirelessChargerEfficiencyFactor,

+            wiredChargeCompletionCurrentAmps: wiredChargeCompletionCurrentAmps,

+            wirelessChargeCompletionCurrentAmps: wirelessChargeCompletionCurrentAmps,

+            chargerObservedVoltageSelections: chargerObservedVoltageSelections,

+            chargerIdleCurrentAmps: chargerIdleCurrentAmps,

+            chargerEfficiencyFactor: chargerEfficiencyFactor,

+            chargerMaximumPowerWatts: chargerMaximumPowerWatts,

+            notes: notes,

+            minimumCurrentAmps: minimumCurrentAmps,

+            estimatedBatteryCapacityWh: estimatedBatteryCapacityWh,

+            wiredMinimumCurrentAmps: wiredMinimumCurrentAmps,

+            wirelessMinimumCurrentAmps: wirelessMinimumCurrentAmps,

+            wiredEstimatedBatteryCapacityWh: wiredEstimatedBatteryCapacityWh,

+            wirelessEstimatedBatteryCapacityWh: wirelessEstimatedBatteryCapacityWh,

+            createdAt: createdAt,

+            updatedAt: updatedAt,

+            sessions: self.sessions,

+            capacityHistory: capacityHistory,

+            typicalCurve: typicalCurve,

+            standbyPowerMeasurements: standbyPowerMeasurements,

+            consumptionSessions: sessions

+    @discardableResult

+    func startPowerbankSession(

+        for snapshot: ChargingMonitorSnapshot,

+        powerbankID: UUID,

+        sourcePowerbankID: UUID? = nil,

+        autoStopEnabled: Bool,

+        initialBatteryPercent: Double?,

+        startsFromFlatBattery: Bool

+    ) -> Bool {

+        if let initialBatteryPercent,

+           (initialBatteryPercent.isFinite == false || initialBatteryPercent < 0 || initialBatteryPercent > 100) {

+            return false

+        }

+

+        var didSave = false

+        context.performAndWait {

+            guard let powerbank = fetchPowerbankObject(id: powerbankID.uuidString) else {

+                return

+            }

+

+            guard fetchOpenSessionObject(forMeterMACAddress: snapshot.meterMACAddress) == nil else {

+                return

+            }

+

+            let powerbankSource = sourcePowerbankID == powerbankID

+                ? nil

+                : sourcePowerbankID.flatMap { fetchPowerbankObject(id: $0.uuidString) }

+            let stopThreshold = optionalDoubleValue(powerbank, key: "configuredCompletionCurrentAmps")

+                ?? optionalDoubleValue(powerbank, key: "learnedCompletionCurrentAmps")

+                ?? (snapshot.fallbackStopThresholdAmps > 0 ? snapshot.fallbackStopThresholdAmps : nil)

+

+            guard let session = createPowerbankSubjectSessionObject(

+                for: powerbank,

+                snapshot: snapshot,

+                stopThreshold: stopThreshold,

+                autoStopEnabled: autoStopEnabled

+            ) else {

+                return

+            }

+            if let powerbankSource, let powerbankIDString = stringValue(powerbankSource, key: "id") {

+                session.setValue(powerbankIDString, forKey: "sourcePowerbankID")

+            }

+

+            if startsFromFlatBattery {

+                session.setValue(unresolvedFlatBatteryPercent, forKey: "startBatteryPercent")

+                session.setValue(nil, forKey: "endBatteryPercent")

+            } else if let initialBatteryPercent {

+                guard insertBatteryCheckpoint(

+                    percent: initialBatteryPercent,

+                    flag: .initial,

+                    timestamp: snapshot.observedAt,

+                    subject: .powerbank,

+                    to: session

+                ) != nil else {

+                    return

+                }

+            }

+            didSave = saveContext()

+        }

+        return didSave

+    }

+

+                    standbyPowerMeasurements: [],

+                    consumptionSessions: []

+    private func createPowerbankSubjectSessionObject(

+        for powerbank: NSManagedObject,

+        snapshot: ChargingMonitorSnapshot,

+        stopThreshold: Double?,

+        autoStopEnabled: Bool

+    ) -> NSManagedObject? {

+        guard

+            let entity = NSEntityDescription.entity(forEntityName: EntityName.chargeSession, in: context),

+            let powerbankID = stringValue(powerbank, key: "id")

+        else {

+            return nil

+        }

+

+        let session = NSManagedObject(entity: entity, insertInto: context)

+        let now = snapshot.observedAt

+        session.setValue(UUID().uuidString, forKey: "id")

+        session.setValue(powerbankID, forKey: "chargedDeviceID")

+        session.setValue(powerbankID, forKey: "chargedPowerbankID")

+        session.setValue(nil, forKey: "chargerID")

+        session.setValue(snapshot.meterMACAddress, forKey: "meterMACAddress")

+        session.setValue(snapshot.meterName, forKey: "meterName")

+        session.setValue(snapshot.meterModel, forKey: "meterModel")

+        session.setValue(now, forKey: "startedAt")

+        session.setValue(now, forKey: "lastObservedAt")

+        session.setValue(ChargeSessionStatus.active.rawValue, forKey: "statusRawValue")

+        let usesMeterCounters = snapshot.meterEnergyCounterWh != nil || snapshot.meterChargeCounterAh != nil

+        session.setValue(

+            (usesMeterCounters ? ChargeSessionSourceMode.offline : .live).rawValue,

+            forKey: "sourceModeRawValue"

+        )

+        session.setValue(ChargingTransportMode.wired.rawValue, forKey: "chargingTransportRawValue")

+        session.setValue(ChargingStateMode.on.rawValue, forKey: "chargingStateRawValue")

+        session.setValue(autoStopEnabled, forKey: "autoStopEnabled")

+        session.setValue(stopThreshold ?? 0, forKey: "stopThresholdAmps")

+        session.setValue(snapshot.voltageVolts, forKey: "selectedSourceVoltageVolts")

+        session.setValue(snapshot.currentAmps, forKey: "lastObservedCurrentAmps")

+        session.setValue(snapshot.powerWatts, forKey: "lastObservedPowerWatts")

+        session.setValue(snapshot.voltageVolts, forKey: "lastObservedVoltageVolts")

+        session.setValue(

+            hasObservedChargeFlow(

+                currentAmps: snapshot.currentAmps,

+                chargingTransportMode: .wired,

+                charger: nil,

+                stopThreshold: stopThreshold

+            ),

+            forKey: "hasObservedChargeFlow"

+        )

+        session.setValue(snapshot.currentAmps, forKey: "minimumObservedCurrentAmps")

+        session.setValue(snapshot.currentAmps, forKey: "maximumObservedCurrentAmps")

+        session.setValue(snapshot.powerWatts, forKey: "maximumObservedPowerWatts")

+        session.setValue(snapshot.voltageVolts, forKey: "maximumObservedVoltageVolts")

+        session.setValue(false, forKey: "supportsChargingWhileOff")

+        if let selectedDataGroup = snapshot.selectedDataGroup {

+            session.setValue(Int16(selectedDataGroup), forKey: "selectedDataGroup")

+        }

+        if let meterEnergyCounterWh = snapshot.meterEnergyCounterWh {

+            session.setValue(meterEnergyCounterWh, forKey: "meterEnergyBaselineWh")

+            session.setValue(meterEnergyCounterWh, forKey: "meterLastEnergyWh")

+        }

+        if let meterChargeCounterAh = snapshot.meterChargeCounterAh {

+            session.setValue(meterChargeCounterAh, forKey: "meterChargeBaselineAh")

+            session.setValue(meterChargeCounterAh, forKey: "meterLastChargeAh")

+        }

+        if let meterRecordingDurationSeconds = snapshot.meterRecordingDurationSeconds {

+            setValue(meterRecordingDurationSeconds, on: session, key: "meterDurationBaselineSeconds")

+            setValue(meterRecordingDurationSeconds, on: session, key: "meterLastDurationSeconds")

+        }

+        session.setValue(now, forKey: "createdAt")

+        session.setValue(now, forKey: "updatedAt")

+

+        return session

+    }

+

+                subject: stringValue(session, key: "chargedPowerbankID") == nil ? .chargedDevice : .powerbank,

+            // Link to the charged powerbank when it is the session subject, otherwise

+            // to the source powerbank being monitored alongside a device session.

+            let powerbankID = stringValue(session, key: "chargedPowerbankID")

+                ?? stringValue(session, key: "sourcePowerbankID")

+            checkpoint.setValue(chargedDeviceID, forKey: "chargedDeviceID")

+        let tracksSessionSubject = subject == .chargedDevice || stringValue(session, key: "chargedPowerbankID") != nil

+        if tracksSessionSubject {

+            let chargedDeviceID = uuidValue(object, key: "chargedDeviceID") ?? uuidValue(object, key: "powerbankID"),

+//

+//  ConsumptionMonitorStore.swift

+//  USB Meter

+//

+

+import Foundation

+import Combine

+

+// MARK: - Store

+

+final class ConsumptionMonitorStore {

+    private struct Snapshot: Codable {

+        var sessions: [ConsumptionMonitorSessionSummary]

+    }

+

+    private enum Keys {

+        static let cloudSessions = "ConsumptionMonitorStore.sessions"

+    }

+

+    private let fileManager: FileManager

+    private let fileURL: URL

+    private let encoder: JSONEncoder

+    private let decoder: JSONDecoder

+    private let ubiquitousStore = NSUbiquitousKeyValueStore.default

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

+    private var ubiquitousObserver: NSObjectProtocol?

+    private var ubiquityIdentityObserver: NSObjectProtocol?

+

+    private var cachedSessions: [ConsumptionMonitorSessionSummary]?

+

+    init(fileManager: FileManager = .default) {

+        self.fileManager = fileManager

+

+        let applicationSupportURL = fileManager.urls(for: .applicationSupportDirectory, in: .userDomainMask).first

+            ?? fileManager.urls(for: .documentDirectory, in: .userDomainMask).first

+            ?? URL(fileURLWithPath: NSTemporaryDirectory(), isDirectory: true)

+

+        let directoryURL = applicationSupportURL.appendingPathComponent("ChargeInsights", isDirectory: true)

+        fileURL = directoryURL.appendingPathComponent("consumption-monitor.json", isDirectory: false)

+

+        encoder = JSONEncoder()

+        encoder.outputFormatting = [.prettyPrinted, .sortedKeys]

+        encoder.dateEncodingStrategy = .iso8601

+

+        decoder = JSONDecoder()

+        decoder.dateDecodingStrategy = .iso8601

+

+        ubiquitousObserver = NotificationCenter.default.addObserver(

+            forName: NSUbiquitousKeyValueStore.didChangeExternallyNotification,

+            object: ubiquitousStore,

+            queue: nil

+        ) { [weak self] notification in

+            self?.handleUbiquitousStoreChange(notification)

+        }

+

+        ubiquityIdentityObserver = NotificationCenter.default.addObserver(

+            forName: NSNotification.Name.NSUbiquityIdentityDidChange,

+            object: nil,

+            queue: nil

+        ) { [weak self] _ in

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

+        }

+

+        ubiquitousStore.synchronize()

+        syncLocalValuesToCloudIfPossible(reason: "startup")

+    }

+

+    func sessionsByDeviceID() -> [UUID: [ConsumptionMonitorSessionSummary]] {

+        Dictionary(grouping: loadSessions()) { $0.chargedDeviceID }

+            .mapValues { sessions in

+                sessions.sorted { lhs, rhs in

+                    (lhs.endedAt ?? .distantFuture) > (rhs.endedAt ?? .distantFuture)

+                }

+            }

+    }

+

+    @discardableResult

+    func save(_ session: ConsumptionMonitorSessionSummary) -> Bool {

+        var sessions = loadSessions()

+        if let index = sessions.firstIndex(where: { $0.id == session.id }) {

+            sessions[index] = session

+        } else {

+            sessions.append(session)

+        }

+        sessions.sort { lhs, rhs in

+            (lhs.endedAt ?? .distantFuture) > (rhs.endedAt ?? .distantFuture)

+        }

+        return persist(sessions)

+    }

+

+    @discardableResult

+    func appendSample(_ sample: ConsumptionMonitorSample, to sessionID: UUID) -> Bool {

+        var sessions = loadSessions()

+        guard let index = sessions.firstIndex(where: { $0.id == sessionID }) else {

+            return false

+        }

+        sessions[index].samples.append(sample)

+        return persist(sessions)

+    }

+

+    @discardableResult

+    func completeSession(id sessionID: UUID, endedAt: Date) -> Bool {

+        var sessions = loadSessions()

+        guard let index = sessions.firstIndex(where: { $0.id == sessionID }) else {

+            return false

+        }

+        sessions[index].endedAt = endedAt

+        sessions.sort { lhs, rhs in

+            (lhs.endedAt ?? .distantFuture) > (rhs.endedAt ?? .distantFuture)

+        }

+        return persist(sessions)

+    }

+

+    @discardableResult

+    func removeSession(id: UUID, deviceID: UUID) -> Bool {

+        let previous = loadSessions()

+        let filtered = previous.filter { !($0.id == id && $0.chargedDeviceID == deviceID) }

+        guard filtered.count != previous.count else { return true }

+        return persist(filtered)

+    }

+

+    @discardableResult

+    func removeSessions(for deviceID: UUID) -> Bool {

+        let previous = loadSessions()

+        let filtered = previous.filter { $0.chargedDeviceID != deviceID }

+        guard filtered.count != previous.count else { return true }

+        return persist(filtered)

+    }

+

+    func openSession(for meterMACAddress: String) -> ConsumptionMonitorSessionSummary? {

+        loadSessions().first { $0.isOpen && $0.meterMACAddress == meterMACAddress }

+    }

+

+    // MARK: - Private

+

+    private func loadSessions() -> [ConsumptionMonitorSessionSummary] {

+        if let cachedSessions { return cachedSessions }

+        let local = loadLocalSessions()

+        let cloud = loadCloudSessions()

+        let merged = merge(localSessions: local, cloudSessions: cloud)

+        cachedSessions = merged

+        return merged

+    }

+

+    private func loadLocalSessions() -> [ConsumptionMonitorSessionSummary] {

+        guard fileManager.fileExists(atPath: fileURL.path) else { return [] }

+        do {

+            let data = try Data(contentsOf: fileURL)

+            return try decoder.decode(Snapshot.self, from: data).sessions

+        } catch {

+            track("ConsumptionMonitorStore: failed to load local sessions: \(error.localizedDescription)")

+            return []

+        }

+    }

+

+    private func loadCloudSessions() -> [ConsumptionMonitorSessionSummary] {

+        guard isICloudDriveAvailable,

+              let data = ubiquitousStore.data(forKey: Keys.cloudSessions) else { return [] }

+        do {

+            return try decoder.decode(Snapshot.self, from: data).sessions

+        } catch {

+            track("ConsumptionMonitorStore: failed to decode cloud sessions: \(error.localizedDescription)")

+            return []

+        }

+    }

+

+    @discardableResult

+    private func persist(_ sessions: [ConsumptionMonitorSessionSummary]) -> Bool {

+        let didLocal = persistLocally(sessions)

+        let didCloud = persistToCloudIfPossible(sessions)

+        if didLocal || didCloud {

+            cachedSessions = sessions

+        }

+        return didLocal || didCloud

+    }

+

+    @discardableResult

+    private func persistLocally(_ sessions: [ConsumptionMonitorSessionSummary]) -> Bool {

+        do {

+            try fileManager.createDirectory(

+                at: fileURL.deletingLastPathComponent(),

+                withIntermediateDirectories: true,

+                attributes: nil

+            )

+            let data = try encoder.encode(Snapshot(sessions: sessions))

+            try data.write(to: fileURL, options: .atomic)

+            return true

+        } catch {

+            track("ConsumptionMonitorStore: failed to save locally: \(error.localizedDescription)")

+            return false

+        }

+    }

+

+    @discardableResult

+    private func persistToCloudIfPossible(_ sessions: [ConsumptionMonitorSessionSummary]) -> Bool {

+        guard isICloudDriveAvailable else { return false }

+        do {

+            let data = try encoder.encode(Snapshot(sessions: sessions))

+            ubiquitousStore.set(data, forKey: Keys.cloudSessions)

+            return ubiquitousStore.synchronize()

+        } catch {

+            track("ConsumptionMonitorStore: failed to sync to cloud: \(error.localizedDescription)")

+            return false

+        }

+    }

+

+    private func merge(

+        localSessions: [ConsumptionMonitorSessionSummary],

+        cloudSessions: [ConsumptionMonitorSessionSummary]

+    ) -> [ConsumptionMonitorSessionSummary] {

+        var byID: [UUID: ConsumptionMonitorSessionSummary] = [:]

+        for session in localSessions { byID[session.id] = session }

+        for session in cloudSessions {

+            if let existing = byID[session.id] {

+                // Keep the one with more samples or a definitive end time

+                if session.samples.count > existing.samples.count || (session.endedAt != nil && existing.endedAt == nil) {

+                    byID[session.id] = session

+                }

+            } else {

+                byID[session.id] = session

+            }

+        }

+        return byID.values.sorted { lhs, rhs in

+            (lhs.endedAt ?? .distantFuture) > (rhs.endedAt ?? .distantFuture)

+        }

+    }

+

+    private func syncLocalValuesToCloudIfPossible(reason: String) {

+        let sessions = loadLocalSessions()

+        guard !sessions.isEmpty else { return }

+        persistToCloudIfPossible(sessions)

+    }

+

+    private func handleUbiquitousStoreChange(_ notification: Notification) {

+        cachedSessions = nil

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

+    }

+

+    private var isICloudDriveAvailable: Bool {

+        FileManager.default.ubiquityIdentityToken != nil

+    }

+}

+

+extension Notification.Name {

+    static let consumptionMonitorStoreDidChange = Notification.Name("ConsumptionMonitorStore.DidChange")

+}

+

+// MARK: - Live Session

+

+final class ConsumptionMonitorLiveSession: ObservableObject {

+    static let bucketDurationSeconds: TimeInterval = 60

+

+    let sessionID: UUID

+    let chargedDeviceID: UUID

+    let meterMACAddress: String

+    let startedAt: Date

+

+    @Published private(set) var currentPowerWatts: Double = 0

+    @Published private(set) var currentCurrentAmps: Double = 0

+    @Published private(set) var currentVoltageVolts: Double = 0

+    @Published private(set) var committedSampleCount: Int = 0

+    @Published private(set) var committedSamples: [ConsumptionMonitorSample] = []

+    @Published private(set) var cumulativeEnergyWh: Double = 0

+    @Published private(set) var isRunning: Bool = false

+

+    var meterName: String?

+    var meterModel: String?

+    var onSample: ((ConsumptionMonitorSample) -> Void)?

+    var onChange: (() -> Void)?

+

+    private var flushTimer: Timer?

+    private var powerReadings: [(power: Double, current: Double, voltage: Double)] = []

+    private var lastObservationTime: Date?

+    private var nextBucketIndex: Int = 0

+

+    init(sessionID: UUID, chargedDeviceID: UUID, meterMACAddress: String, startedAt: Date) {

+        self.sessionID = sessionID

+        self.chargedDeviceID = chargedDeviceID

+        self.meterMACAddress = meterMACAddress

+        self.startedAt = startedAt

+    }

+

+    func start() {

+        guard !isRunning else { return }

+        isRunning = true

+        scheduleNextFlush()

+    }

+

+    func stop() {

+        isRunning = false

+        flushTimer?.invalidate()

+        flushTimer = nil

+        flushBucket()

+    }

+

+    func observe(powerWatts: Double, currentAmps: Double, voltageVolts: Double, observedAt: Date) {

+        currentPowerWatts = powerWatts

+        currentCurrentAmps = currentAmps

+        currentVoltageVolts = voltageVolts

+

+        if let last = lastObservationTime {

+            let dtHours = observedAt.timeIntervalSince(last) / 3600

+            cumulativeEnergyWh += powerWatts * dtHours

+        }

+        lastObservationTime = observedAt

+

+        powerReadings.append((powerWatts, currentAmps, voltageVolts))

+        onChange?()

+    }

+

+    var elapsedDuration: TimeInterval {

+        Date().timeIntervalSince(startedAt)

+    }

+

+    // MARK: - Private

+

+    private func scheduleNextFlush() {

+        flushTimer?.invalidate()

+        flushTimer = Timer.scheduledTimer(

+            withTimeInterval: Self.bucketDurationSeconds,

+            repeats: false

+        ) { [weak self] _ in

+            self?.flushBucket()

+            if self?.isRunning == true {

+                self?.scheduleNextFlush()

+            }

+        }

+    }

+

+    private func flushBucket() {

+        guard !powerReadings.isEmpty else { return }

+

+        let n = Double(powerReadings.count)

+        let avgPower = powerReadings.map(\.power).reduce(0, +) / n

+        let avgCurrent = powerReadings.map(\.current).reduce(0, +) / n

+        let avgVoltage = powerReadings.map(\.voltage).reduce(0, +) / n

+        let bucketIndex = nextBucketIndex

+        nextBucketIndex += 1

+

+        let sample = ConsumptionMonitorSample(

+            bucketIndex: bucketIndex,

+            timestamp: Date(),

+            averagePowerWatts: avgPower,

+            averageCurrentAmps: avgCurrent,

+            averageVoltageVolts: avgVoltage,

+            sampleCount: powerReadings.count,

+            cumulativeEnergyWh: cumulativeEnergyWh

+        )

+

+        powerReadings = []

+        committedSamples.append(sample)

+        committedSampleCount = nextBucketIndex

+        onSample?(sample)

+        onChange?()

+    }

+}

+//

+//  ConsumptionMonitorView.swift

+//  USB Meter

+//

+

+import SwiftUI

+import Charts

+

+// MARK: - Shared helpers (file-private)

+

+private func formattedDuration(_ duration: TimeInterval) -> String {

+    let formatter = DateComponentsFormatter()

+    formatter.allowedUnits = duration >= 3600 ? [.hour, .minute] : [.minute, .second]

+    formatter.unitsStyle = .abbreviated

+    formatter.zeroFormattingBehavior = .pad

+    return formatter.string(from: max(duration, 0)) ?? "0m"

+}

+

+private func energyLabel(_ wattHours: Double) -> String {

+    wattHours >= 1000

+        ? "\((wattHours / 1000).format(decimalDigits: 3)) kWh"

+        : "\(wattHours.format(decimalDigits: 2)) Wh"

+}

+

+@available(iOS 16, *)

+private func consumptionChart(samples: [ConsumptionMonitorSample], tint: Color) -> some View {

+    let duration = samples.last.map { $0.timestamp.timeIntervalSince(samples[0].timestamp) } ?? 0

+    return Chart(samples) { sample in

+        LineMark(

+            x: .value("Time", sample.timestamp),

+            y: .value("W", sample.averagePowerWatts)

+        )

+        .foregroundStyle(tint)

+        .interpolationMethod(.catmullRom)

+    }

+    .frame(height: 140)

+    .chartYScale(domain: .automatic(includesZero: false))

+    .chartXAxis {

+        if duration > 3600 {

+            AxisMarks(values: .stride(by: .hour)) { _ in

+                AxisGridLine()

+                AxisValueLabel(format: .dateTime.hour())

+            }

+        } else {

+            AxisMarks(values: .stride(by: .minute, count: 10)) { _ in

+                AxisGridLine()

+                AxisValueLabel(format: .dateTime.hour(.defaultDigits(amPM: .omitted)).minute())

+            }

+        }

+    }

+    .chartYAxis {

+        AxisMarks { value in

+            AxisGridLine()

+            AxisValueLabel {

+                if let v = value.as(Double.self) {

+                    Text("\(v.format(decimalDigits: 1)) W")

+                }

+            }

+        }

+    }

+}

+

+// MARK: - Main View

+

+struct ConsumptionMonitorView: View {

+    @EnvironmentObject private var appData: AppData

+

+    @State private var selectedMeterMACAddress: String?

+    @State private var selectedDeviceID: UUID?

+    @State private var discardConfirmationVisibility = false

+

+    let preferredMeterMACAddress: String?

+

+    init(preferredMeterMACAddress: String? = nil) {

+        self.preferredMeterMACAddress = preferredMeterMACAddress

+        _selectedMeterMACAddress = State(initialValue: preferredMeterMACAddress)

+    }

+

+    var body: some View {

+        ScrollView {

+            VStack(spacing: 18) {

+                if let session = activeSession {

+                    activeSessionCard(session)

+                    liveMetricsCard(session)

+                } else {

+                    setupCard

+                }

+                savedSessionsList

+            }

+            .padding()

+        }

+        .background(

+            LinearGradient(

+                colors: [.purple.opacity(0.16), Color.clear],

+                startPoint: .topLeading,

+                endPoint: .bottomTrailing

+            )

+            .ignoresSafeArea()

+        )

+        .navigationTitle("Consumption Monitor")

+        .navigationBarTitleDisplayMode(.inline)

+        .confirmationDialog(

+            "Stop and discard this session?",

+            isPresented: $discardConfirmationVisibility,

+            titleVisibility: .visible

+        ) {

+            Button("Discard", role: .destructive) {

+                if let session = activeSession {

+                    _ = appData.stopConsumptionMonitor(for: session.meterMACAddress, save: false)

+                }

+            }

+            Button("Cancel", role: .cancel) {}

+        } message: {

+            Text("The current session data will be lost and nothing will be saved.")

+        }

+    }

+

+    // MARK: - Computed

+

+    private var liveMeterSummaries: [AppData.MeterSummary] {

+        appData.meterSummaries.filter { $0.meter != nil }

+    }

+

+    private var availableDevices: [ChargedDeviceSummary] {

+        appData.deviceSummaries

+    }

+

+    private var activeSession: ConsumptionMonitorLiveSession? {

+        let candidates = [selectedMeterMACAddress, preferredMeterMACAddress].compactMap { $0 }

+        for mac in candidates {

+            if let session = appData.consumptionMonitorSession(for: mac) { return session }

+        }

+        for summary in liveMeterSummaries {

+            if let session = appData.consumptionMonitorSession(for: summary.macAddress) { return session }

+        }

+        return nil

+    }

+

+    private var selectedDevice: ChargedDeviceSummary? {

+        guard let id = selectedDeviceID else { return nil }

+        return availableDevices.first { $0.id == id }

+    }

+

+    private var selectedMeterSummary: AppData.MeterSummary? {

+        guard let mac = selectedMeterMACAddress else { return nil }

+        return liveMeterSummaries.first { $0.macAddress == mac }

+    }

+

+    private var savedSessions: [ConsumptionMonitorSessionSummary] {

+        guard let id = selectedDeviceID else { return [] }

+        return appData.chargedDeviceSummary(id: id)?.consumptionSessions.filter { !$0.isOpen } ?? []

+    }

+

+    private var canStart: Bool {

+        selectedDeviceID != nil && selectedMeterSummary != nil && activeSession == nil

+    }

+

+    // MARK: - Setup Card

+

+    private var setupCard: some View {

+        MeterInfoCardView(title: "New Session", tint: .purple) {

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

+                if liveMeterSummaries.isEmpty {

+                    Text("Connect a live meter first to start a consumption monitor session.")

+                        .font(.footnote)

+                        .foregroundColor(.secondary)

+                } else {

+                    Text("Device")

+                        .font(.subheadline.weight(.semibold))

+

+                    if availableDevices.isEmpty {

+                        Text("No devices available. Add a device in the sidebar first.")

+                            .font(.caption)

+                            .foregroundColor(.secondary)

+                    } else {

+                        Picker("Device", selection: $selectedDeviceID) {

+                            Text("Select Device").tag(Optional<UUID>.none)

+                            ForEach(availableDevices) { device in

+                                Text(device.name).tag(Optional(device.id))

+                            }

+                        }

+                        .pickerStyle(.menu)

+                    }

+

+                    Text("Meter")

+                        .font(.subheadline.weight(.semibold))

+

+                    Picker("Meter", selection: $selectedMeterMACAddress) {

+                        Text("Select Meter").tag(Optional<String>.none)

+                        ForEach(liveMeterSummaries) { summary in

+                            Text(summary.displayName).tag(Optional(summary.macAddress))

+                        }

+                    }

+                    .pickerStyle(.menu)

+

+                    Button("Start Session") {

+                        startSession()

+                    }

+                    .disabled(!canStart)

+                    .buttonStyle(.borderedProminent)

+                    .tint(.purple)

+                }

+            }

+

+            if activeSession == nil, selectedDevice != nil, selectedMeterSummary == nil {

+                Text("Select a meter to begin.")

+                    .font(.caption)

+                    .foregroundColor(.secondary)

+            } else if activeSession == nil, selectedMeterSummary != nil, selectedDevice == nil {

+                Text("Select the device you want to monitor.")

+                    .font(.caption)

+                    .foregroundColor(.secondary)

+            } else if activeSession == nil, canStart {

+                Text("Samples are recorded every 60 seconds at a rate of 60 per hour.")

+                    .font(.caption)

+                    .foregroundColor(.secondary)

+            }

+        }

+    }

+

+    // MARK: - Active Session Card

+

+    private func activeSessionCard(_ session: ConsumptionMonitorLiveSession) -> some View {

+        MeterInfoCardView(

+            title: "Session Running",

+            infoMessage: "Samples are stored every 60 seconds. The session persists across app restarts until you stop it.",

+            tint: .purple

+        ) {

+            if let device = appData.chargedDeviceSummary(id: session.chargedDeviceID) {

+                MeterInfoRowView(label: "Device", value: device.name)

+            }

+            if let summary = liveMeterSummaries.first(where: { $0.macAddress == session.meterMACAddress }) {

+                MeterInfoRowView(label: "Meter", value: summary.displayName)

+            }

+            MeterInfoRowView(label: "Duration", value: formattedDuration(session.elapsedDuration))

+            MeterInfoRowView(label: "Samples", value: "\(session.committedSampleCount) × 60 s")

+            MeterInfoRowView(label: "Total Energy", value: energyLabel(session.cumulativeEnergyWh))

+

+            HStack(spacing: 12) {

+                Button("Save & Stop") {

+                    _ = appData.stopConsumptionMonitor(for: session.meterMACAddress, save: true)

+                }

+                .disabled(session.committedSampleCount == 0)

+

+                Button("Discard") {

+                    discardConfirmationVisibility = true

+                }

+                .foregroundColor(.red)

+            }

+            .buttonStyle(.borderedProminent)

+            .tint(.purple)

+        }

+    }

+

+    // MARK: - Live Metrics Card

+

+    private func liveMetricsCard(_ session: ConsumptionMonitorLiveSession) -> some View {

+        VStack(spacing: 18) {

+            MeterInfoCardView(title: "Live Reading", tint: .indigo) {

+                MeterInfoRowView(label: "Power", value: "\(session.currentPowerWatts.format(decimalDigits: 3)) W")

+                MeterInfoRowView(label: "Current", value: "\(session.currentCurrentAmps.format(decimalDigits: 3)) A")

+                MeterInfoRowView(label: "Voltage", value: "\(session.currentVoltageVolts.format(decimalDigits: 3)) V")

+            }

+

+            if session.committedSamples.count >= 2 {

+                liveChartCard(session.committedSamples)

+            }

+

+            if session.cumulativeEnergyWh > 0 {

+                projectionCard(

+                    averagePowerWatts: session.cumulativeEnergyWh / max(session.elapsedDuration / 3600, 0.001),

+                    totalEnergyWh: session.cumulativeEnergyWh

+                )

+            }

+        }

+    }

+

+    @ViewBuilder

+    private func liveChartCard(_ samples: [ConsumptionMonitorSample]) -> some View {

+        if #available(iOS 16, *) {

+            MeterInfoCardView(title: "Power Over Time", tint: .purple) {

+                consumptionChart(samples: samples, tint: .purple)

+            }

+        }

+    }

+

+    // MARK: - Projections Card

+

+    private func projectionCard(averagePowerWatts: Double, totalEnergyWh: Double) -> some View {

+        MeterInfoCardView(title: "Consumption Projection", tint: .teal) {

+            MeterInfoRowView(label: "Average Power", value: "\(averagePowerWatts.format(decimalDigits: 3)) W")

+            MeterInfoRowView(label: "24 Hours", value: energyLabel(averagePowerWatts * 24))

+            MeterInfoRowView(label: "7 Days", value: energyLabel(averagePowerWatts * 24 * 7))

+            MeterInfoRowView(label: "30 Days", value: energyLabel(averagePowerWatts * 24 * 30))

+            MeterInfoRowView(label: "1 Year", value: energyLabel(averagePowerWatts * 24 * 365))

+        }

+    }

+

+    // MARK: - Saved Sessions List

+

+    @ViewBuilder

+    private var savedSessionsList: some View {

+        if !savedSessions.isEmpty {

+            MeterInfoCardView(title: "Saved Sessions", tint: .purple) {

+                ForEach(savedSessions) { session in

+                    NavigationLink(destination: ConsumptionSessionDetailView(session: session)) {

+                        HStack {

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

+                                Text(session.startedAt, style: .date)

+                                    .font(.subheadline.weight(.semibold))

+                                Text("\(formattedDuration(session.duration)) · \(energyLabel(session.totalEnergyWh)) total")

+                                    .font(.caption)

+                                    .foregroundColor(.secondary)

+                            }

+                            Spacer()

+                            Image(systemName: "chevron.right")

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

+                                .foregroundColor(.secondary)

+                        }

+                        .padding(.vertical, 4)

+                    }

+                    .buttonStyle(.plain)

+                }

+            }

+        }

+    }

+

+    // MARK: - Actions

+

+    private func startSession() {

+        guard let deviceID = selectedDeviceID,

+              let meterSummary = selectedMeterSummary,

+              let meter = meterSummary.meter else { return }

+        _ = appData.startConsumptionMonitor(for: deviceID, on: meter)

+    }

+}

+

+// MARK: - Session Detail

+

+struct ConsumptionSessionDetailView: View {

+    @EnvironmentObject private var appData: AppData

+

+    let session: ConsumptionMonitorSessionSummary

+

+    @State private var deleteConfirmationVisibility = false

+

+    var body: some View {

+        ScrollView {

+            VStack(spacing: 18) {

+                overviewCard

+                if session.averagePowerWatts > 0 {

+                    projectionCard

+                }

+                if session.samples.count >= 2 {

+                    chartCard

+                }

+                statsCard

+            }

+            .padding()

+        }

+        .background(

+            LinearGradient(

+                colors: [.purple.opacity(0.14), Color.clear],

+                startPoint: .topLeading,

+                endPoint: .bottomTrailing

+            )

+            .ignoresSafeArea()

+        )

+        .navigationTitle("Consumption Session")

+        .navigationBarTitleDisplayMode(.inline)

+        .toolbar {

+            ToolbarItem(placement: .destructiveAction) {

+                Button(role: .destructive) {

+                    deleteConfirmationVisibility = true

+                } label: {

+                    Image(systemName: "trash")

+                }

+            }

+        }

+        .confirmationDialog("Delete this session?", isPresented: $deleteConfirmationVisibility, titleVisibility: .visible) {

+            Button("Delete", role: .destructive) {

+                _ = appData.deleteConsumptionSession(id: session.id, deviceID: session.chargedDeviceID)

+            }

+            Button("Cancel", role: .cancel) {}

+        }

+    }

+

+    // MARK: - Cards

+

+    private var overviewCard: some View {

+        MeterInfoCardView(title: "Overview", tint: .purple) {

+            MeterInfoRowView(label: "Started", value: session.startedAt.formatted(date: .abbreviated, time: .shortened))

+            if let endedAt = session.endedAt {

+                MeterInfoRowView(label: "Ended", value: endedAt.formatted(date: .abbreviated, time: .shortened))

+            }

+            MeterInfoRowView(label: "Duration", value: formattedDuration(session.duration))

+            MeterInfoRowView(label: "Samples", value: "\(session.sampleCount) × 60 s")

+            MeterInfoRowView(label: "Total Energy", value: energyLabel(session.totalEnergyWh))

+            if let meterName = session.meterName {

+                MeterInfoRowView(label: "Meter", value: meterName)

+            }

+        }

+    }

+

+    private var projectionCard: some View {

+        MeterInfoCardView(title: "Consumption Projection", tint: .teal) {

+            MeterInfoRowView(label: "Average Power", value: "\(session.averagePowerWatts.format(decimalDigits: 3)) W")

+            MeterInfoRowView(label: "24 Hours", value: energyLabel(session.projectedDailyEnergyWh))

+            MeterInfoRowView(label: "7 Days", value: energyLabel(session.projectedWeeklyEnergyWh))

+            MeterInfoRowView(label: "30 Days", value: energyLabel(session.projectedMonthlyEnergyWh))

+            MeterInfoRowView(label: "1 Year", value: energyLabel(session.projectedYearlyEnergyWh))

+        }

+    }

+

+    private var statsCard: some View {

+        MeterInfoCardView(title: "Statistics", tint: .indigo) {

+            MeterInfoRowView(label: "Min Power", value: "\(session.minimumPowerWatts.format(decimalDigits: 3)) W")

+            MeterInfoRowView(label: "Max Power", value: "\(session.maximumPowerWatts.format(decimalDigits: 3)) W")

+            MeterInfoRowView(label: "Avg Current", value: "\(session.averageCurrentAmps.format(decimalDigits: 3)) A")

+            MeterInfoRowView(label: "Avg Voltage", value: "\(session.averageVoltageVolts.format(decimalDigits: 3)) V")

+        }

+    }

+

+    @ViewBuilder

+    private var chartCard: some View {

+        if #available(iOS 16, *) {

+            MeterInfoCardView(title: "Power Over Time", tint: .purple) {

+                consumptionChart(samples: session.samples, tint: .purple)

+            }

+        }

+    }

+}

+        appData.chargeSessionSummary(id: sessionID)

+            ?? chargedDevice?.sessions.first(where: { $0.id == sessionID })

+    }

+

+    private var chargedPowerbank: PowerbankSummary? {

+        guard let powerbankID = session?.chargedPowerbankID else {

+            return nil

+        }

+        return appData.powerbankSummaries.first { $0.id == powerbankID }

+            } else if let chargedPowerbank, let session {

+                powerbankContent(powerbank: chargedPowerbank, session: session)

+    private func powerbankContent(

+        powerbank: PowerbankSummary,

+        session: ChargeSessionSummary

+    ) -> some View {

+        ScrollView {

+            VStack(spacing: 16) {

+                powerbankSessionCard(powerbank: powerbank, session: session)

+

+                if shouldShowSessionChart(session) {

+                    powerbankChartCard(session)

+                }

+

+                if session.status.isOpen && !hasMonitoringControls {

+                    followerNoticeCard(session)

+                }

+            }

+            .padding(presentation == .embedded ? 16 : 20)

+        }

+        .background(

+            LinearGradient(

+                colors: [statusTint(for: session).opacity(0.14), Color.clear],

+                startPoint: .topLeading,

+                endPoint: .bottomTrailing

+            )

+            .ignoresSafeArea()

+        )

+        .navigationTitle(session.status.isOpen ? "Current Session" : "Session Details")

+        .navigationBarTitleDisplayMode(.inline)

+        .toolbar {

+            ToolbarItemGroup(placement: .primaryAction) {

+                if session.status.isOpen == false {

+                    Button(role: .destructive) {

+                        pendingSessionDeletion = session

+                    } label: {

+                        Image(systemName: "trash")

+                    }

+                    .help("Delete session")

+                }

+            }

+        }

+    }

+

+    private func powerbankSessionCard(

+        powerbank: PowerbankSummary,

+        session: ChargeSessionSummary

+    ) -> some View {

+        let displayedEnergyWh = displayedSessionEnergyWh(for: session)

+

+        return VStack(alignment: .leading, spacing: 14) {

+            HStack {

+                Label(powerbank.name, systemImage: powerbank.identitySymbolName)

+                    .font(.headline)

+

+                Spacer()

+

+                Text(session.status.title)

+                    .font(.caption.weight(.bold))

+                    .foregroundColor(monitoringStatusColor(for: session))

+                    .padding(.horizontal, 8)

+                    .padding(.vertical, 4)

+                    .meterCard(tint: monitoringStatusColor(for: session), fillOpacity: 0.18, strokeOpacity: 0.24, cornerRadius: 999)

+            }

+

+            LazyVGrid(columns: [GridItem(.flexible()), GridItem(.flexible())], spacing: 8) {

+                metricCell(label: "Energy", value: "\(displayedEnergyWh.format(decimalDigits: 3)) Wh", tint: .blue)

+                metricCell(label: "Duration", value: formatDuration(displayedSessionDuration(for: session)), tint: .teal)

+                metricCell(label: "Type", value: session.chargingTransportMode.title, tint: .orange)

+                metricCell(label: "Auto Stop", value: autoStopLabel(for: session), tint: .secondary)

+            }

+

+            if let sourcePowerbankID = session.sourcePowerbankID,

+               let sourcePowerbank = appData.powerbankSummaries.first(where: { $0.id == sourcePowerbankID }) {

+                MeterInfoRowView(label: "Source Powerbank", value: sourcePowerbank.name)

+            }

+

+            BatteryCheckpointSectionView(

+                sessionID: session.id,

+                checkpoints: session.checkpoints,

+                message: "Checkpoints are stored on the powerbank charge session and help estimate received capacity.",

+                canAddCheckpoint: hasMonitoringControls && appData.canAddBatteryCheckpoint(to: session.id),

+                canDeleteCheckpoint: hasMonitoringControls || session.status.isOpen == false,

+                requirementMessage: session.status.isOpen ? appData.batteryCheckpointCaptureRequirementMessage(for: session.id) : nil,

+                effectiveEnergyWhOverride: displayedEnergyWh,

+                onDelete: { checkpoint in

+                    pendingCheckpointDeletion = checkpoint

+                }

+            )

+

+            if showingStopConfirm {

+                stopConfirmPanel(session: session, displayedEnergyWh: displayedEnergyWh)

+            } else if hasMonitoringControls {

+                monitoringActionRow(session)

+            }

+        }

+        .padding(18)

+        .meterCard(tint: .green, fillOpacity: 0.14, strokeOpacity: 0.20)

+    }

+