+		B0A000113C8F000100A10011 /* ChargerStandbyPowerStore.swift in Sources */ = {isa = PBXBuildFile; fileRef = B0A000013C8F000100A10001 /* ChargerStandbyPowerStore.swift */; };

+		B0A000123C8F000100A10012 /* ChargerStandbyPowerWizardView.swift in Sources */ = {isa = PBXBuildFile; fileRef = B0A000023C8F000100A10002 /* ChargerStandbyPowerWizardView.swift */; };

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

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

+				B0A000013C8F000100A10001 /* ChargerStandbyPowerStore.swift */,

+				B0A000023C8F000100A10002 /* ChargerStandbyPowerWizardView.swift */,

+				B0A000113C8F000100A10011 /* ChargerStandbyPowerStore.swift in Sources */,

+				B0A000123C8F000100A10012 /* ChargerStandbyPowerWizardView.swift in Sources */,

+    private let chargerStandbyPowerStore = ChargerStandbyPowerStore()

+    @Published private(set) var activeChargerStandbySessions: [String: ChargerStandbyPowerMonitorSession] = [:]

+    func chargerStandbyMeasurementSession(for meterMACAddress: String) -> ChargerStandbyPowerMonitorSession? {

+        activeChargerStandbySessions[Self.normalizedMACAddress(meterMACAddress)]

+    }

+

+    @discardableResult

+    func startChargerStandbyMeasurement(for chargerID: UUID, on meter: Meter) -> Bool {

+        guard chargedDeviceSummary(id: chargerID)?.isCharger == true else {

+            return false

+        }

+

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

+        if let existingSession = activeChargerStandbySessions[normalizedMAC] {

+            return existingSession.chargerID == chargerID

+        }

+

+        let session = ChargerStandbyPowerMonitorSession(chargerID: chargerID, meter: meter)

+        session.onChange = { [weak self] in

+            self?.scheduleObjectWillChange()

+        }

+        session.onStabilized = { [weak self, weak session] in

+            guard let self, let session else { return }

+            self.notifyChargerStandbyMeasurementReady(for: session)

+        }

+

+        activeChargerStandbySessions[normalizedMAC] = session

+        session.start()

+

+        // Starting a standby run on an available meter should also initiate the BLE link.

+        if meter.operationalState == .peripheralNotConnected {

+            meter.connect()

+        }

+

+        scheduleObjectWillChange()

+        return true

+    }

+

+    @discardableResult

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

+        let normalizedMAC = Self.normalizedMACAddress(meterMACAddress)

+        guard let session = activeChargerStandbySessions[normalizedMAC] else {

+            return false

+        }

+

+        session.stop()

+

+        guard save else {

+            activeChargerStandbySessions[normalizedMAC] = nil

+            scheduleObjectWillChange()

+            return true

+        }

+

+        guard let summary = session.makeSummary() else {

+            scheduleObjectWillChange()

+            return false

+        }

+

+        let didSave = chargerStandbyPowerStore.save(summary)

+        if didSave {

+            activeChargerStandbySessions[normalizedMAC] = nil

+            reloadChargedDevices()

+        } else {

+            scheduleObjectWillChange()

+        }

+

+        return didSave

+    }

+

+        if deletedDevice?.isCharger == true {

+            _ = chargerStandbyPowerStore.removeMeasurements(for: id)

+            for (meterMACAddress, session) in activeChargerStandbySessions where session.chargerID == id {

+                session.stop()

+                activeChargerStandbySessions[meterMACAddress] = nil

+            }

+        }

+

+        let standbyMeasurementsByChargerID = chargerStandbyPowerStore.measurementsByChargerID()

+        chargedDevices = (chargeInsightsStore?.fetchChargedDeviceSummaries() ?? []).map { chargedDevice in

+            chargedDevice.withStandbyPowerMeasurements(

+                standbyMeasurementsByChargerID[chargedDevice.id] ?? []

+            )

+        }

+    private func notifyChargerStandbyMeasurementReady(for session: ChargerStandbyPowerMonitorSession) {

+        guard let charger = chargedDeviceSummary(id: session.chargerID),

+              let statistics = session.statistics else {

+            return

+        }

+

+        let content = UNMutableNotificationContent()

+        content.title = "Standby baseline stabilised"

+        content.body = "\(charger.name) is holding around \(statistics.averagePowerWatts.format(decimalDigits: 3)) W. You can save the measurement when ready."

+        content.sound = .default

+        content.threadIdentifier = "charger-standby-\(charger.id.uuidString)"

+

+        let request = UNNotificationRequest(

+            identifier: "charger-standby-\(session.id.uuidString)",

+            content: content,

+            trigger: nil

+        )

+        UNUserNotificationCenter.current().add(request)

+        scheduleObjectWillChange()

+    }

+

+struct ChargerStandbyPowerSample: Identifiable, Hashable, Codable {

+    let timestamp: Date

+    let powerWatts: Double

+    let currentAmps: Double

+    let voltageVolts: Double

+

+    var id: TimeInterval {

+        timestamp.timeIntervalSince1970

+    }

+}

+

+struct ChargerStandbyPowerDistributionBin: Identifiable, Hashable {

+    let index: Int

+    let lowerBoundWatts: Double

+    let upperBoundWatts: Double

+    let count: Int

+    let relativeFrequency: Double

+

+    var id: Int { index }

+}

+

+struct ChargerStandbyPowerMeasurementStatistics: Hashable {

+    let sampleCount: Int

+    let observedDuration: TimeInterval

+    let averagePowerWatts: Double

+    let recentAveragePowerWatts: Double

+    let medianPowerWatts: Double

+    let minimumPowerWatts: Double

+    let maximumPowerWatts: Double

+    let standardDeviationPowerWatts: Double

+    let coefficientOfVariation: Double

+    let averageCurrentAmps: Double

+    let averageVoltageVolts: Double

+    let stabilityDeltaWatts: Double

+    let stabilityToleranceWatts: Double

+    let histogram: [ChargerStandbyPowerDistributionBin]

+

+    var projectedDailyEnergyWh: Double {

+        averagePowerWatts * 24

+    }

+

+    var projectedWeeklyEnergyWh: Double {

+        averagePowerWatts * 24 * 7

+    }

+

+    var projectedMonthlyEnergyWh: Double {

+        averagePowerWatts * 24 * 30

+    }

+

+    var projectedYearlyEnergyWh: Double {

+        averagePowerWatts * 24 * 365

+    }

+

+    var stabilityDeltaMilliwatts: Double {

+        stabilityDeltaWatts * 1000

+    }

+

+    var isStable: Bool {

+        sampleCount >= ChargerStandbyPowerMeasurementAnalyzer.minimumStableSampleCount

+        && stabilityDeltaWatts <= stabilityToleranceWatts

+    }

+}

+

+struct ChargerStandbyPowerMeasurementSummary: Identifiable, Hashable, Codable {

+    let id: UUID

+    let chargerID: UUID

+    let meterMACAddress: String

+    let meterName: String?

+    let meterModel: String?

+    let startedAt: Date

+    let endedAt: Date

+    let sampleCount: Int

+    let stabilizedAt: Date?

+    let averagePowerWatts: Double

+    let recentAveragePowerWatts: Double

+    let medianPowerWatts: Double

+    let minimumPowerWatts: Double

+    let maximumPowerWatts: Double

+    let standardDeviationPowerWatts: Double

+    let coefficientOfVariation: Double

+    let averageCurrentAmps: Double

+    let averageVoltageVolts: Double

+    let stabilityDeltaWatts: Double

+    let stabilityToleranceWatts: Double

+    let powerSamplesWatts: [Double]

+

+    var duration: TimeInterval {

+        endedAt.timeIntervalSince(startedAt)

+    }

+

+    var projectedDailyEnergyWh: Double {

+        averagePowerWatts * 24

+    }

+

+    var projectedWeeklyEnergyWh: Double {

+        averagePowerWatts * 24 * 7

+    }

+

+    var projectedMonthlyEnergyWh: Double {

+        averagePowerWatts * 24 * 30

+    }

+

+    var projectedYearlyEnergyWh: Double {

+        averagePowerWatts * 24 * 365

+    }

+

+    var isStable: Bool {

+        stabilizedAt != nil

+    }

+

+    var histogram: [ChargerStandbyPowerDistributionBin] {

+        ChargerStandbyPowerMeasurementAnalyzer.histogram(for: powerSamplesWatts)

+    }

+}

+

+enum ChargerStandbyPowerMeasurementAnalyzer {

+    static let minimumStableSampleCount = 45

+    static let recentSampleWindow = 20

+    static let minimumStabilityToleranceWatts = 0.003

+    static let relativeStabilityTolerance = 0.01

+

+    static func statistics(

+        from samples: [ChargerStandbyPowerSample],

+        startedAt: Date,

+        referenceDate: Date = Date()

+    ) -> ChargerStandbyPowerMeasurementStatistics? {

+        guard !samples.isEmpty else {

+            return nil

+        }

+

+        let powerValues = samples.map(\.powerWatts).filter(\.isFinite)

+        let currentValues = samples.map(\.currentAmps).filter(\.isFinite)

+        let voltageValues = samples.map(\.voltageVolts).filter(\.isFinite)

+

+        guard powerValues.isEmpty == false else {

+            return nil

+        }

+

+        let averagePower = mean(powerValues)

+        let recentWindow = min(recentSampleWindow, max(1, powerValues.count))

+        let recentAveragePower = mean(Array(powerValues.suffix(recentWindow)))

+        let stabilityDelta = abs(averagePower - recentAveragePower)

+        let stabilityTolerance = max(

+            minimumStabilityToleranceWatts,

+            abs(averagePower) * relativeStabilityTolerance

+        )

+

+        return ChargerStandbyPowerMeasurementStatistics(

+            sampleCount: powerValues.count,

+            observedDuration: max(referenceDate.timeIntervalSince(startedAt), 0),

+            averagePowerWatts: averagePower,

+            recentAveragePowerWatts: recentAveragePower,

+            medianPowerWatts: median(powerValues),

+            minimumPowerWatts: powerValues.min() ?? 0,

+            maximumPowerWatts: powerValues.max() ?? 0,

+            standardDeviationPowerWatts: standardDeviation(powerValues, mean: averagePower),

+            coefficientOfVariation: coefficientOfVariation(powerValues, mean: averagePower),

+            averageCurrentAmps: mean(currentValues),

+            averageVoltageVolts: mean(voltageValues),

+            stabilityDeltaWatts: stabilityDelta,

+            stabilityToleranceWatts: stabilityTolerance,

+            histogram: histogram(for: powerValues)

+        )

+    }

+

+    static func measurementSummary(

+        chargerID: UUID,

+        meterMACAddress: String,

+        meterName: String?,

+        meterModel: String?,

+        startedAt: Date,

+        endedAt: Date,

+        samples: [ChargerStandbyPowerSample],

+        stabilizedAt: Date?

+    ) -> ChargerStandbyPowerMeasurementSummary? {

+        guard let statistics = statistics(from: samples, startedAt: startedAt, referenceDate: endedAt) else {

+            return nil

+        }

+

+        return ChargerStandbyPowerMeasurementSummary(

+            id: UUID(),

+            chargerID: chargerID,

+            meterMACAddress: meterMACAddress,

+            meterName: meterName,

+            meterModel: meterModel,

+            startedAt: startedAt,

+            endedAt: endedAt,

+            sampleCount: statistics.sampleCount,

+            stabilizedAt: stabilizedAt,

+            averagePowerWatts: statistics.averagePowerWatts,

+            recentAveragePowerWatts: statistics.recentAveragePowerWatts,

+            medianPowerWatts: statistics.medianPowerWatts,

+            minimumPowerWatts: statistics.minimumPowerWatts,

+            maximumPowerWatts: statistics.maximumPowerWatts,

+            standardDeviationPowerWatts: statistics.standardDeviationPowerWatts,

+            coefficientOfVariation: statistics.coefficientOfVariation,

+            averageCurrentAmps: statistics.averageCurrentAmps,

+            averageVoltageVolts: statistics.averageVoltageVolts,

+            stabilityDeltaWatts: statistics.stabilityDeltaWatts,

+            stabilityToleranceWatts: statistics.stabilityToleranceWatts,

+            powerSamplesWatts: samples.map(\.powerWatts)

+        )

+    }

+

+    static func histogram(for values: [Double], preferredBinCount: Int? = nil) -> [ChargerStandbyPowerDistributionBin] {

+        let finiteValues = values.filter(\.isFinite)

+        guard finiteValues.isEmpty == false else {

+            return []

+        }

+

+        let minimum = finiteValues.min() ?? 0

+        let maximum = finiteValues.max() ?? 0

+        let spread = maximum - minimum

+        let binCount = preferredBinCount ?? min(18, max(8, Int(Double(finiteValues.count).squareRoot().rounded())))

+

+        guard spread > 0 else {

+            return [

+                ChargerStandbyPowerDistributionBin(

+                    index: 0,

+                    lowerBoundWatts: minimum,

+                    upperBoundWatts: maximum,

+                    count: finiteValues.count,

+                    relativeFrequency: 1

+                )

+            ]

+        }

+

+        let safeBinCount = max(1, binCount)

+        let binWidth = spread / Double(safeBinCount)

+        var counts = Array(repeating: 0, count: safeBinCount)

+

+        for value in finiteValues {

+            let normalizedIndex = Int(((value - minimum) / binWidth).rounded(.down))

+            let safeIndex = min(max(normalizedIndex, 0), safeBinCount - 1)

+            counts[safeIndex] += 1

+        }

+

+        return counts.enumerated().map { index, count in

+            let lowerBound = minimum + (Double(index) * binWidth)

+            let upperBound = index == safeBinCount - 1 ? maximum : lowerBound + binWidth

+

+            return ChargerStandbyPowerDistributionBin(

+                index: index,

+                lowerBoundWatts: lowerBound,

+                upperBoundWatts: upperBound,

+                count: count,

+                relativeFrequency: Double(count) / Double(finiteValues.count)

+            )

+        }

+    }

+

+    private static func mean(_ values: [Double]) -> Double {

+        guard values.isEmpty == false else {

+            return 0

+        }

+        return values.reduce(0, +) / Double(values.count)

+    }

+

+    private static func median(_ values: [Double]) -> Double {

+        guard values.isEmpty == false else {

+            return 0

+        }

+

+        let sorted = values.sorted()

+        let middleIndex = sorted.count / 2

+

+        if sorted.count.isMultiple(of: 2) {

+            return (sorted[middleIndex - 1] + sorted[middleIndex]) / 2

+        }

+

+        return sorted[middleIndex]

+    }

+

+    private static func standardDeviation(_ values: [Double], mean: Double) -> Double {

+        guard values.count > 1 else {

+            return 0

+        }

+

+        let variance = values.reduce(0) { partialResult, value in

+            let delta = value - mean

+            return partialResult + (delta * delta)

+        } / Double(values.count)

+

+        return variance.squareRoot()

+    }

+

+    private static func coefficientOfVariation(_ values: [Double], mean: Double) -> Double {

+        guard abs(mean) > 0.000_001 else {

+            return 0

+        }

+

+        return standardDeviation(values, mean: mean) / abs(mean)

+    }

+}

+

+    let standbyPowerMeasurements: [ChargerStandbyPowerMeasurementSummary]

+    var latestStandbyPowerMeasurement: ChargerStandbyPowerMeasurementSummary? {

+        standbyPowerMeasurements.first

+    }

+

+

+    func withStandbyPowerMeasurements(_ measurements: [ChargerStandbyPowerMeasurementSummary]) -> ChargedDeviceSummary {

+        ChargedDeviceSummary(

+            id: id,

+            qrIdentifier: qrIdentifier,

+            name: name,

+            deviceClass: deviceClass,

+            supportsChargingWhileOff: supportsChargingWhileOff,

+            chargingStateAvailability: chargingStateAvailability,

+            supportsWiredCharging: supportsWiredCharging,

+            supportsWirelessCharging: supportsWirelessCharging,

+            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,

+            lastAssociatedMeterMAC: lastAssociatedMeterMAC,

+            createdAt: createdAt,

+            updatedAt: updatedAt,

+            sessions: sessions,

+            capacityHistory: capacityHistory,

+            typicalCurve: typicalCurve,

+            standbyPowerMeasurements: measurements

+        )

+    }

+                    typicalCurve: buildTypicalCurve(from: sessionSummaries),

+                    standbyPowerMeasurements: []

+//

+//  ChargerStandbyPowerStore.swift

+//  USB Meter

+//

+//  Created by Codex on 13/04/2026.

+//

+

+import Foundation

+

+final class ChargerStandbyPowerStore {

+    private struct Snapshot: Codable {

+        var measurements: [ChargerStandbyPowerMeasurementSummary]

+    }

+

+    private let fileManager: FileManager

+    private let fileURL: URL

+    private let encoder: JSONEncoder

+    private let decoder: JSONDecoder

+

+    private var cachedMeasurements: [ChargerStandbyPowerMeasurementSummary]?

+

+    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("charger-standby-power.json", isDirectory: false)

+

+        encoder = JSONEncoder()

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

+        encoder.dateEncodingStrategy = .iso8601

+

+        decoder = JSONDecoder()

+        decoder.dateDecodingStrategy = .iso8601

+    }

+

+    func measurementsByChargerID() -> [UUID: [ChargerStandbyPowerMeasurementSummary]] {

+        Dictionary(grouping: loadMeasurements()) { $0.chargerID }

+            .mapValues { measurements in

+                measurements.sorted { lhs, rhs in

+                    if lhs.endedAt != rhs.endedAt {

+                        return lhs.endedAt > rhs.endedAt

+                    }

+                    return lhs.id.uuidString > rhs.id.uuidString

+                }

+            }

+    }

+

+    @discardableResult

+    func save(_ measurement: ChargerStandbyPowerMeasurementSummary) -> Bool {

+        var measurements = loadMeasurements()

+        measurements.append(measurement)

+        measurements.sort { lhs, rhs in

+            if lhs.endedAt != rhs.endedAt {

+                return lhs.endedAt > rhs.endedAt

+            }

+            return lhs.id.uuidString > rhs.id.uuidString

+        }

+

+        return persist(measurements)

+    }

+

+    @discardableResult

+    func removeMeasurements(for chargerID: UUID) -> Bool {

+        let previousMeasurements = loadMeasurements()

+        let filteredMeasurements = previousMeasurements.filter { $0.chargerID != chargerID }

+        guard filteredMeasurements.count != previousMeasurements.count else {

+            return true

+        }

+

+        return persist(filteredMeasurements)

+    }

+

+    private func loadMeasurements() -> [ChargerStandbyPowerMeasurementSummary] {

+        if let cachedMeasurements {

+            return cachedMeasurements

+        }

+

+        guard fileManager.fileExists(atPath: fileURL.path) else {

+            cachedMeasurements = []

+            return []

+        }

+

+        do {

+            let data = try Data(contentsOf: fileURL)

+            let snapshot = try decoder.decode(Snapshot.self, from: data)

+            cachedMeasurements = snapshot.measurements

+            return snapshot.measurements

+        } catch {

+            track("Failed to load charger standby power history: \(error.localizedDescription)")

+            cachedMeasurements = []

+            return []

+        }

+    }

+

+    @discardableResult

+    private func persist(_ measurements: [ChargerStandbyPowerMeasurementSummary]) -> Bool {

+        do {

+            try fileManager.createDirectory(

+                at: fileURL.deletingLastPathComponent(),

+                withIntermediateDirectories: true,

+                attributes: nil

+            )

+            let snapshot = Snapshot(measurements: measurements)

+            let data = try encoder.encode(snapshot)

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

+            cachedMeasurements = measurements

+            return true

+        } catch {

+            track("Failed to save charger standby power history: \(error.localizedDescription)")

+            return false

+        }

+    }

+}

+

+final class ChargerStandbyPowerMonitorSession: ObservableObject, Identifiable {

+    let id = UUID()

+    let chargerID: UUID

+    let meterMACAddress: String

+    let meterName: String

+    let meterModel: String

+    let startedAt: Date

+

+    @Published private(set) var samples: [ChargerStandbyPowerSample] = []

+    @Published private(set) var statistics: ChargerStandbyPowerMeasurementStatistics?

+    @Published private(set) var stabilizedAt: Date?

+    @Published private(set) var lastObservedAt: Date?

+    @Published private(set) var isRunning = false

+

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

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

+

+    private weak var meter: Meter?

+    private var timer: Timer?

+    private var hasTriggeredStabilityCallback = false

+    private let sampleInterval: TimeInterval = 1

+

+    init(chargerID: UUID, meter: Meter, startedAt: Date = Date()) {

+        self.chargerID = chargerID

+        meterMACAddress = meter.btSerial.macAddress.description

+        meterName = meter.name

+        meterModel = meter.deviceModelSummary

+        self.startedAt = startedAt

+        self.meter = meter

+    }

+

+    deinit {

+        stop()

+    }

+

+    var sampleCount: Int {

+        statistics?.sampleCount ?? samples.count

+    }

+

+    var hasSamples: Bool {

+        sampleCount > 0

+    }

+

+    var readinessDescription: String {

+        guard let statistics else {

+            if let meter {

+                switch meter.operationalState {

+                case .peripheralConnectionPending, .peripheralConnected, .peripheralReady, .comunicating:

+                    return "Connecting to meter"

+                case .peripheralNotConnected:

+                    return "Starting meter connection"

+                case .notPresent, .dataIsAvailable:

+                    break

+                }

+            }

+

+            return "Waiting for live samples"

+        }

+

+        if statistics.isStable {

+            return "Stable average reached"

+        }

+

+        return "Collecting baseline"

+    }

+

+    func start() {

+        guard isRunning == false else {

+            return

+        }

+

+        isRunning = true

+        captureSampleIfPossible(at: Date())

+

+        let timer = Timer(timeInterval: sampleInterval, repeats: true) { [weak self] _ in

+            self?.captureSampleIfPossible(at: Date())

+        }

+        self.timer = timer

+        RunLoop.main.add(timer, forMode: .common)

+        onChange?()

+    }

+

+    func stop() {

+        timer?.invalidate()

+        timer = nil

+        guard isRunning else {

+            return

+        }

+        isRunning = false

+        onChange?()

+    }

+

+    func makeSummary(endedAt: Date = Date()) -> ChargerStandbyPowerMeasurementSummary? {

+        ChargerStandbyPowerMeasurementAnalyzer.measurementSummary(

+            chargerID: chargerID,

+            meterMACAddress: meterMACAddress,

+            meterName: meterName,

+            meterModel: meterModel,

+            startedAt: startedAt,

+            endedAt: endedAt,

+            samples: samples,

+            stabilizedAt: stabilizedAt

+        )

+    }

+

+    private func captureSampleIfPossible(at timestamp: Date) {

+        defer {

+            statistics = ChargerStandbyPowerMeasurementAnalyzer.statistics(

+                from: samples,

+                startedAt: startedAt,

+                referenceDate: timestamp

+            )

+            onChange?()

+        }

+

+        guard let meter else {

+            return

+        }

+

+        guard meter.operationalState == .dataIsAvailable else {

+            return

+        }

+

+        let powerWatts = meter.power

+        let currentAmps = meter.current

+        let voltageVolts = meter.voltage

+

+        guard powerWatts.isFinite, currentAmps.isFinite, voltageVolts.isFinite else {

+            return

+        }

+

+        lastObservedAt = timestamp

+        samples.append(

+            ChargerStandbyPowerSample(

+                timestamp: timestamp,

+                powerWatts: powerWatts,

+                currentAmps: currentAmps,

+                voltageVolts: voltageVolts

+            )

+        )

+

+        if stabilizedAt == nil,

+           let refreshedStatistics = ChargerStandbyPowerMeasurementAnalyzer.statistics(

+               from: samples,

+               startedAt: startedAt,

+               referenceDate: timestamp

+           ),

+           refreshedStatistics.isStable {

+            stabilizedAt = timestamp

+            if hasTriggeredStabilityCallback == false {

+                hasTriggeredStabilityCallback = true

+                onStabilized?()

+            }

+        }

+    }

+}

+                        if chargedDevice.isCharger {

+                            standbyPowerCard(chargedDevice)

+                        }

+

+        if let latestStandbyPowerMeasurement = chargedDevice.latestStandbyPowerMeasurement {

+            MeterInfoRowView(

+                label: "Standby Power",

+                value: "\(latestStandbyPowerMeasurement.averagePowerWatts.format(decimalDigits: 3)) W"

+            )

+            MeterInfoRowView(

+                label: "Standby Projection",

+                value: standbyEnergyLabel(latestStandbyPowerMeasurement.projectedYearlyEnergyWh) + " / year"

+            )

+        }

+    private func standbyPowerCard(_ chargedDevice: ChargedDeviceSummary) -> some View {

+        let latestMeasurement = chargedDevice.latestStandbyPowerMeasurement

+

+        return MeterInfoCardView(

+            title: "Standby Power",

+            tint: .orange

+        ) {

+            if standbyMeasurementMeters.isEmpty {

+                Text("Connect a meter first. Standby measurement is launched from a live meter feed, so only currently available meters can be selected here.")

+                    .font(.footnote)

+                    .foregroundColor(.secondary)

+                    .frame(maxWidth: .infinity, alignment: .leading)

+            } else {

+                NavigationLink(

+                    destination: ChargerStandbyPowerWizardView(

+                        preferredChargerID: chargedDevice.id,

+                        locksChargerSelection: true

+                    )

+                ) {

+                    Label("New Measurement", systemImage: "plus.circle.fill")

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

+                        .foregroundColor(.orange)

+                }

+                .buttonStyle(.plain)

+            }

+

+            if let latestMeasurement {

+                Divider()

+

+                NavigationLink(

+                    destination: ChargerStandbyPowerMeasurementDetailView(

+                        chargerID: chargedDevice.id,

+                        measurementID: latestMeasurement.id

+                    )

+                ) {

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

+                        HStack {

+                            Text("Latest Measurement")

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

+                                .foregroundColor(.primary)

+                            Spacer()

+                            Text("\(latestMeasurement.averagePowerWatts.format(decimalDigits: 3)) W")

+                                .font(.subheadline.weight(.bold))

+                                .foregroundColor(.primary)

+                                .monospacedDigit()

+                        }

+

+                        Text(

+                            "\(latestMeasurement.endedAt.format()) • \(latestMeasurement.sampleCount) samples • \(standbyEnergyLabel(latestMeasurement.projectedYearlyEnergyWh)) / year"

+                        )

+                        .font(.caption)

+                        .foregroundColor(.secondary)

+                    }

+                }

+                .buttonStyle(.plain)

+            }

+

+            if chargedDevice.standbyPowerMeasurements.isEmpty == false {

+                Divider()

+

+                NavigationLink(

+                    destination: ChargerStandbyPowerMeasurementsView(chargerID: chargedDevice.id)

+                ) {

+                    Label("View Saved Measurements", systemImage: "clock.arrow.trianglehead.counterclockwise.rotate.90")

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

+                        .foregroundColor(.blue)

+                }

+                .buttonStyle(.plain)

+

+                Divider()

+

+                ForEach(Array(chargedDevice.standbyPowerMeasurements.prefix(3))) { measurement in

+                    NavigationLink(

+                        destination: ChargerStandbyPowerMeasurementDetailView(

+                            chargerID: chargedDevice.id,

+                            measurementID: measurement.id

+                        )

+                    ) {

+                        HStack {

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

+                                Text(measurement.endedAt.format())

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

+                                    .foregroundColor(.primary)

+                                Text("\(measurement.sampleCount) samples")

+                                    .font(.caption)

+                                    .foregroundColor(.secondary)

+                            }

+

+                            Spacer()

+

+                            Text("\(measurement.averagePowerWatts.format(decimalDigits: 3)) W")

+                                .font(.subheadline.weight(.bold))

+                                .foregroundColor(.primary)

+                                .monospacedDigit()

+                        }

+                    }

+                    .buttonStyle(.plain)

+

+                    if measurement.id != chargedDevice.standbyPowerMeasurements.prefix(3).last?.id {

+                        Divider()

+                    }

+                }

+            }

+        }

+    }

+

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

+        if wattHours >= 1000 {

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

+        }

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

+    }

+

+    private var standbyMeasurementMeters: [AppData.MeterSummary] {

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

+    }

+

+

+            if selectedChargedDevice != nil {

+                Divider()

+            }

+            standbyMeasurementSection

+

+    private var standbyMeasurementSection: some View {

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

+            HStack {

+                Text("Charger Standby Power")

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

+                Spacer()

+                Button(selectedCharger == nil ? "Select Charger" : "Change Charger") {

+                    chargerLibraryVisibility = true

+                }

+                .disabled(openChargeSession != nil)

+            }

+

+            if let selectedCharger {

+                HStack(alignment: .top, spacing: 12) {

+                    ChargedDeviceQRCodeView(

+                        qrIdentifier: selectedCharger.qrIdentifier,

+                        side: 62

+                    )

+

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

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

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

+

+                        Text(

+                            selectedCharger.latestStandbyPowerMeasurement.map {

+                                "Latest standby: \($0.averagePowerWatts.format(decimalDigits: 3)) W"

+                            } ?? "No standby baseline saved yet."

+                        )

+                        .font(.caption)

+                        .foregroundColor(.secondary)

+                    }

+                }

+

+                NavigationLink(

+                    destination: ChargerStandbyPowerWizardView(

+                        preferredMeterMACAddress: meterMACAddress,

+                        preferredChargerID: selectedCharger.id

+                    )

+                ) {

+                    Label("New Measurement", systemImage: "plus.circle.fill")

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

+                        .foregroundColor(.orange)

+                }

+                .buttonStyle(.plain)

+                .disabled(openChargeSession != nil)

+

+                if openChargeSession != nil {

+                    Text("Stop or pause the active charge session before starting a standby-power run on this meter.")

+                        .font(.caption)

+                        .foregroundColor(.secondary)

+                }

+            } else {

+                NavigationLink(

+                    destination: ChargerStandbyPowerWizardView(

+                        preferredMeterMACAddress: meterMACAddress

+                    )

+                ) {

+                    Label("New Measurement", systemImage: "plus.circle.fill")

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

+                        .foregroundColor(.orange)

+                }

+                .buttonStyle(.plain)

+

+                Text("Open the wizard and choose the charger there, or preselect one from Charge Record first.")

+                    .font(.caption)

+                    .foregroundColor(.secondary)

+            }

+        }

+    }

+

+//

+//  ChargerStandbyPowerWizardView.swift

+//  USB Meter

+//

+//  Created by Codex on 13/04/2026.

+//

+

+import SwiftUI

+

+struct ChargerStandbyPowerWizardView: View {

+    @EnvironmentObject private var appData: AppData

+

+    @State private var chargerLibraryVisibility = false

+    @State private var discardConfirmationVisibility = false

+    @State private var selectedMeterMACAddress: String?

+    @State private var selectedChargerID: UUID?

+

+    let preferredMeterMACAddress: String?

+    let preferredChargerID: UUID?

+    let locksChargerSelection: Bool

+

+    init(

+        preferredMeterMACAddress: String? = nil,

+        preferredChargerID: UUID? = nil,

+        locksChargerSelection: Bool = false

+    ) {

+        self.preferredMeterMACAddress = preferredMeterMACAddress

+        self.preferredChargerID = preferredChargerID

+        self.locksChargerSelection = locksChargerSelection

+        _selectedMeterMACAddress = State(initialValue: nil)

+        _selectedChargerID = State(initialValue: preferredChargerID)

+    }

+

+    var body: some View {

+        ScrollView {

+            VStack(spacing: 18) {

+                if let session = activeSession {

+                    activeMeasurementCard(session)

+                    liveSessionCard(session)

+                } else {

+                    newMeasurementWizardCard

+                }

+            }

+            .padding()

+        }

+        .background(

+            LinearGradient(

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

+                startPoint: .topLeading,

+                endPoint: .bottomTrailing

+            )

+            .ignoresSafeArea()

+        )

+        .navigationTitle(navigationTitleText)

+        .sheet(isPresented: $chargerLibraryVisibility) {

+            ChargedDeviceLibrarySheetView(

+                visibility: $chargerLibraryVisibility,

+                meterMACAddress: selectedMeterSummary?.macAddress ?? "",

+                meterTint: selectedMeter?.color ?? .orange,

+                mode: .charger

+            )

+            .environmentObject(appData)

+        }

+        .confirmationDialog(

+            "Discard the current standby measurement?",

+            isPresented: $discardConfirmationVisibility,

+            titleVisibility: .visible

+        ) {

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

+                if let activeSession {

+                    _ = appData.finishChargerStandbyMeasurement(for: activeSession.meterMACAddress, save: false)

+                }

+            }

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

+        } message: {

+            Text("The current sample set will be removed and nothing will be saved for this charger.")

+        }

+    }

+

+    private var liveMeterSummaries: [AppData.MeterSummary] {

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

+    }

+

+    private var availableChargers: [ChargedDeviceSummary] {

+        appData.chargerSummaries

+    }

+

+    private var preferredChargerMeterMACAddress: String? {

+        preferredChargerID.flatMap { appData.chargedDeviceSummary(id: $0)?.lastAssociatedMeterMAC }

+    }

+

+    private var activeSession: ChargerStandbyPowerMonitorSession? {

+        let candidateMACAddresses = [

+            selectedMeterMACAddress ?? "",

+            preferredMeterMACAddress ?? "",

+            preferredChargerMeterMACAddress ?? ""

+        ]

+        .filter { $0.isEmpty == false }

+

+        for macAddress in candidateMACAddresses {

+            if let session = appData.chargerStandbyMeasurementSession(for: macAddress) {

+                return session

+            }

+        }

+

+        for meterSummary in liveMeterSummaries {

+            if let session = appData.chargerStandbyMeasurementSession(for: meterSummary.macAddress) {

+                return session

+            }

+        }

+

+        return nil

+    }

+

+    private var suggestedMeterSummary: AppData.MeterSummary? {

+        if let preferredMeterMACAddress {

+            return liveMeterSummaries.first(where: { $0.macAddress == preferredMeterMACAddress })

+        }

+

+        if let preferredChargerMeterMACAddress {

+            return liveMeterSummaries.first(where: { $0.macAddress == preferredChargerMeterMACAddress })

+        }

+

+        return liveMeterSummaries.count == 1 ? liveMeterSummaries.first : nil

+    }

+

+    private var selectedMeterSummary: AppData.MeterSummary? {

+        if let activeSession {

+            return liveMeterSummaries.first(where: { $0.macAddress == activeSession.meterMACAddress })

+        }

+

+        guard let selectedMeterMACAddress else {

+            return nil

+        }

+

+        return liveMeterSummaries.first(where: { $0.macAddress == selectedMeterMACAddress })

+    }

+

+    private var selectedMeter: Meter? {

+        selectedMeterSummary?.meter

+    }

+

+    private var isChargerSelectionLocked: Bool {

+        locksChargerSelection || preferredChargerID != nil

+    }

+

+    private var meterSelectionBinding: Binding<String?> {

+        Binding(

+            get: { selectedMeterMACAddress },

+            set: { selectedMeterMACAddress = $0 }

+        )

+    }

+

+    private var selectedCharger: ChargedDeviceSummary? {

+        if let activeSession {

+            return appData.chargedDeviceSummary(id: activeSession.chargerID)

+        }

+

+        guard let selectedChargerID else {

+            return nil

+        }

+

+        return appData.chargedDeviceSummary(id: selectedChargerID)

+    }

+

+    private var chargerSelectionBinding: Binding<UUID?> {

+        Binding(

+            get: { selectedChargerID },

+            set: { selectedChargerID = $0 }

+        )

+    }

+

+    private var preferredChargerSummary: ChargedDeviceSummary? {

+        guard let preferredChargerID else {

+            return nil

+        }

+        return appData.chargedDeviceSummary(id: preferredChargerID)

+    }

+

+    private var navigationTitleText: String {

+        "New Standby Consumption Measurement"

+    }

+

+    private var wizardCardTitle: String {

+        if let selectedMeterSummary {

+            return selectedMeterSummary.displayName

+        }

+

+        if let suggestedMeterSummary {

+            return suggestedMeterSummary.displayName

+        }

+

+        return "Use Meter"

+    }

+

+    private var newMeasurementWizardCard: some View {

+        MeterInfoCardView(

+            title: wizardCardTitle,

+            tint: .orange

+        ) {

+            if liveMeterSummaries.isEmpty {

+                Text("Connect a live meter first. Standby measurement uses a live feed, so meter selection happens here in the wizard.")

+                    .font(.footnote)

+                    .foregroundColor(.secondary)

+                    .frame(maxWidth: .infinity, alignment: .leading)

+            } else {

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

+                    if isChargerSelectionLocked == false {

+                        HStack(spacing: 8) {

+                            Text("Charger")

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

+                            ContextInfoButton(

+                                title: "Charger",

+                                message: "Choose the charger whose standby consumption you want to measure in this run."

+                            )

+                        }

+

+                        if availableChargers.isEmpty {

+                            Text("No charger available yet. Open the charger library to create one first.")

+                                .font(.caption)

+                                .foregroundColor(.secondary)

+                        } else {

+                            Picker("Charger", selection: chargerSelectionBinding) {

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

+                                ForEach(availableChargers) { charger in

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

+                                }

+                            }

+                            .pickerStyle(.menu)

+                        }

+                    }

+

+                    HStack(spacing: 8) {

+                        Text("Use Meter")

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

+                        ContextInfoButton(

+                            title: "Use Meter",

+                            message: "Choose the live meter explicitly. Standby consumption can vary with the upstream source or when the charger is connected to a computer, so re-run after setup changes."

+                        )

+                    }

+

+                    Picker("Use Meter", selection: meterSelectionBinding) {

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

+                        ForEach(liveMeterSummaries) { meterSummary in

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

+                        }

+                    }

+                    .pickerStyle(.menu)

+                    .disabled(activeSession != nil)

+

+                    if activeSession == nil, let suggestedMeterSummary, selectedMeterSummary == nil {

+                        Text("Suggested from the current context: \(suggestedMeterSummary.displayName). Select it explicitly if this is the meter you want to use.")

+                            .font(.caption)

+                            .foregroundColor(.secondary)

+                    }

+

+                    HStack(spacing: 12) {

+                        if isChargerSelectionLocked == false {

+                            Button("Manage Charger Library") {

+                                chargerLibraryVisibility = true

+                            }

+                            .disabled(selectedMeter == nil)

+                        }

+

+                        Button("Start Measurement") {

+                            startMeasurement()

+                        }

+                        .disabled(selectedCharger == nil || selectedMeter == nil)

+                    }

+                    .buttonStyle(.borderedProminent)

+                }

+            }

+

+            if selectedMeter == nil {

+                Text("Choose the live meter explicitly before starting. The wizard no longer auto-confirms a suggested meter.")

+                    .font(.caption)

+                    .foregroundColor(.secondary)

+            } else if activeSession == nil, selectedCharger == nil {

+                Text("Select the charger you want to measure, then start the run.")

+                    .font(.caption)

+                    .foregroundColor(.secondary)

+            } else if activeSession == nil, selectedMeter?.operationalState != .dataIsAvailable {

+                Text("The wizard can start now, but samples will only be captured while live meter data is available.")

+                    .font(.caption)

+                    .foregroundColor(.secondary)

+            } else if let activeSession {

+                Text(

+                    "\(activeSession.readinessDescription) • \(formattedDuration(Date().timeIntervalSince(activeSession.startedAt))) • \(activeSession.sampleCount) samples"

+                )

+                .font(.caption)

+                .foregroundColor(.secondary)

+            }

+        }

+    }

+

+    private func activeMeasurementCard(_ session: ChargerStandbyPowerMonitorSession) -> some View {

+        MeterInfoCardView(

+            title: "Measurement Running",

+            infoMessage: "The run keeps collecting samples while this meter stays live. Save when you are happy with the sample set, or discard to cancel it.",

+            tint: .orange

+        ) {

+            MeterInfoRowView(label: "Meter", value: selectedMeterSummary?.displayName ?? session.meterMACAddress)

+            MeterInfoRowView(label: "Charger", value: selectedCharger?.name ?? "Selected charger")

+            MeterInfoRowView(label: "Status", value: session.readinessDescription)

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

+

+            HStack(spacing: 12) {

+                Button("Save Result") {

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

+                }

+                .disabled(session.hasSamples == false)

+

+                Button("Discard") {

+                    discardConfirmationVisibility = true

+                }

+                .foregroundColor(.red)

+            }

+            .buttonStyle(.borderedProminent)

+        }

+    }

+

+    private func liveSessionCard(_ session: ChargerStandbyPowerMonitorSession) -> some View {

+        VStack(spacing: 18) {

+            if let statistics = session.statistics {

+                stabilityCard(

+                    isStable: statistics.isStable,

+                    averagePowerWatts: statistics.averagePowerWatts,

+                    stabilityDeltaWatts: statistics.stabilityDeltaWatts,

+                    stabilityToleranceWatts: statistics.stabilityToleranceWatts,

+                    sampleCount: statistics.sampleCount

+                )

+

+                projectionCard(

+                    averagePowerWatts: statistics.averagePowerWatts,

+                    projectedDailyEnergyWh: statistics.projectedDailyEnergyWh,

+                    projectedWeeklyEnergyWh: statistics.projectedWeeklyEnergyWh,

+                    projectedMonthlyEnergyWh: statistics.projectedMonthlyEnergyWh,

+                    projectedYearlyEnergyWh: statistics.projectedYearlyEnergyWh

+                )

+

+                distributionCard(

+                    histogram: statistics.histogram,

+                    averagePowerWatts: statistics.averagePowerWatts,

+                    standardDeviationPowerWatts: statistics.standardDeviationPowerWatts,

+                    tint: .orange

+                )

+

+                statisticsCard(

+                    averagePowerWatts: statistics.averagePowerWatts,

+                    medianPowerWatts: statistics.medianPowerWatts,

+                    minimumPowerWatts: statistics.minimumPowerWatts,

+                    maximumPowerWatts: statistics.maximumPowerWatts,

+                    standardDeviationPowerWatts: statistics.standardDeviationPowerWatts,

+                    coefficientOfVariation: statistics.coefficientOfVariation,

+                    averageCurrentAmps: statistics.averageCurrentAmps,

+                    averageVoltageVolts: statistics.averageVoltageVolts

+                )

+            } else {

+                MeterInfoCardView(title: "Live Stats", tint: .orange) {

+                    Text("Waiting for the first valid power samples from the meter.")

+                        .font(.footnote)

+                        .foregroundColor(.secondary)

+                }

+            }

+        }

+    }

+

+    private func stabilityCard(

+        isStable: Bool,

+        averagePowerWatts: Double,

+        stabilityDeltaWatts: Double,

+        stabilityToleranceWatts: Double,

+        sampleCount: Int,

+        subtitle: String? = nil

+    ) -> some View {

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

+            HStack {

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

+                    Text(isStable ? "Enough Samples" : "Still Settling")

+                        .font(.headline)

+                    Text(subtitle ?? (isStable ? "The running average has stabilised." : "The wizard is still watching the average drift."))

+                        .font(.caption)

+                        .foregroundColor(.secondary)

+                }

+

+                Spacer()

+

+                Text(isStable ? "Ready" : "Live")

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

+                    .padding(.horizontal, 10)

+                    .padding(.vertical, 6)

+                    .foregroundColor(isStable ? .green : .orange)

+                    .meterCard(

+                        tint: isStable ? .green : .orange,

+                        fillOpacity: 0.10,