+                // Log the error but do NOT destroy the store — wiping local data and

+                // waiting for a full CloudKit re-sync is far worse than a degraded launch.

+                NSLog(

+                    "Core Data store load failed (url=%@): %@ — %@",

+                    storeDescription.url?.path ?? "unknown",

+                    error.localizedDescription,

+                    error.userInfo

+                )

+struct ChargerStandbyPowerDistributionBin: Identifiable, Hashable, Codable {

+enum HistogramResolution: Int, CaseIterable, Identifiable {

+    case x1 = 1

+    case x2 = 2

+    case x4 = 4

+

+    var id: Int { rawValue }

+

+    var label: String {

+        switch self {

+        case .x1: return "1×"

+        case .x2: return "2×"

+        case .x4: return "4×"

+        }

+    }

+}

+

+    /// Histogram stored at 4× resolution. Use `histogram(resolution:)` to downsample for display.

+    let storedHistogram: [ChargerStandbyPowerDistributionBin]

+

+    // MARK: - Codable (with migration from legacy powerSamplesWatts)

+

+    private enum CodingKeys: String, CodingKey {

+        case id, chargerID, meterMACAddress, meterName, meterModel

+        case startedAt, endedAt, sampleCount, stabilizedAt

+        case averagePowerWatts, recentAveragePowerWatts, medianPowerWatts

+        case minimumPowerWatts, maximumPowerWatts, standardDeviationPowerWatts

+        case coefficientOfVariation, averageCurrentAmps, averageVoltageVolts

+        case stabilityDeltaWatts, stabilityToleranceWatts

+        case storedHistogram

+        case powerSamplesWatts // legacy – decode only

+    }

+

+    init(

+        id: UUID, chargerID: UUID, meterMACAddress: String, meterName: String?, meterModel: String?,

+        startedAt: Date, endedAt: Date, sampleCount: Int, stabilizedAt: Date?,

+        averagePowerWatts: Double, recentAveragePowerWatts: Double, medianPowerWatts: Double,

+        minimumPowerWatts: Double, maximumPowerWatts: Double, standardDeviationPowerWatts: Double,

+        coefficientOfVariation: Double, averageCurrentAmps: Double, averageVoltageVolts: Double,

+        stabilityDeltaWatts: Double, stabilityToleranceWatts: Double,

+        storedHistogram: [ChargerStandbyPowerDistributionBin]

+    ) {

+        self.id = id; self.chargerID = chargerID; self.meterMACAddress = meterMACAddress

+        self.meterName = meterName; self.meterModel = meterModel

+        self.startedAt = startedAt; self.endedAt = endedAt; self.sampleCount = sampleCount

+        self.stabilizedAt = stabilizedAt

+        self.averagePowerWatts = averagePowerWatts; self.recentAveragePowerWatts = recentAveragePowerWatts

+        self.medianPowerWatts = medianPowerWatts; self.minimumPowerWatts = minimumPowerWatts

+        self.maximumPowerWatts = maximumPowerWatts

+        self.standardDeviationPowerWatts = standardDeviationPowerWatts

+        self.coefficientOfVariation = coefficientOfVariation

+        self.averageCurrentAmps = averageCurrentAmps; self.averageVoltageVolts = averageVoltageVolts

+        self.stabilityDeltaWatts = stabilityDeltaWatts; self.stabilityToleranceWatts = stabilityToleranceWatts

+        self.storedHistogram = storedHistogram

+    }

+

+    init(from decoder: Decoder) throws {

+        let c = try decoder.container(keyedBy: CodingKeys.self)

+        id = try c.decode(UUID.self, forKey: .id)

+        chargerID = try c.decode(UUID.self, forKey: .chargerID)

+        meterMACAddress = try c.decode(String.self, forKey: .meterMACAddress)

+        meterName = try c.decodeIfPresent(String.self, forKey: .meterName)

+        meterModel = try c.decodeIfPresent(String.self, forKey: .meterModel)

+        startedAt = try c.decode(Date.self, forKey: .startedAt)

+        endedAt = try c.decode(Date.self, forKey: .endedAt)

+        sampleCount = try c.decode(Int.self, forKey: .sampleCount)

+        stabilizedAt = try c.decodeIfPresent(Date.self, forKey: .stabilizedAt)

+        averagePowerWatts = try c.decode(Double.self, forKey: .averagePowerWatts)

+        recentAveragePowerWatts = try c.decode(Double.self, forKey: .recentAveragePowerWatts)

+        medianPowerWatts = try c.decode(Double.self, forKey: .medianPowerWatts)

+        minimumPowerWatts = try c.decode(Double.self, forKey: .minimumPowerWatts)

+        maximumPowerWatts = try c.decode(Double.self, forKey: .maximumPowerWatts)

+        standardDeviationPowerWatts = try c.decode(Double.self, forKey: .standardDeviationPowerWatts)

+        coefficientOfVariation = try c.decode(Double.self, forKey: .coefficientOfVariation)

+        averageCurrentAmps = try c.decode(Double.self, forKey: .averageCurrentAmps)

+        averageVoltageVolts = try c.decode(Double.self, forKey: .averageVoltageVolts)

+        stabilityDeltaWatts = try c.decode(Double.self, forKey: .stabilityDeltaWatts)

+        stabilityToleranceWatts = try c.decode(Double.self, forKey: .stabilityToleranceWatts)

+

+        let decodedBins = try? c.decodeIfPresent([ChargerStandbyPowerDistributionBin].self, forKey: .storedHistogram)

+        if let decodedBins, !decodedBins.isEmpty {

+            storedHistogram = decodedBins

+        } else {

+            // Migrate from legacy raw samples format

+            let samples = (try? c.decodeIfPresent([Double].self, forKey: .powerSamplesWatts)) ?? []

+            let base = min(18, max(8, Int(Double(samples.count).squareRoot().rounded())))

+            storedHistogram = ChargerStandbyPowerMeasurementAnalyzer.histogram(

+                for: samples,

+                preferredBinCount: base * HistogramResolution.x4.rawValue

+            )

+        }

+    func encode(to encoder: Encoder) throws {

+        var c = encoder.container(keyedBy: CodingKeys.self)

+        try c.encode(id, forKey: .id)

+        try c.encode(chargerID, forKey: .chargerID)

+        try c.encode(meterMACAddress, forKey: .meterMACAddress)

+        try c.encodeIfPresent(meterName, forKey: .meterName)

+        try c.encodeIfPresent(meterModel, forKey: .meterModel)

+        try c.encode(startedAt, forKey: .startedAt)

+        try c.encode(endedAt, forKey: .endedAt)

+        try c.encode(sampleCount, forKey: .sampleCount)

+        try c.encodeIfPresent(stabilizedAt, forKey: .stabilizedAt)

+        try c.encode(averagePowerWatts, forKey: .averagePowerWatts)

+        try c.encode(recentAveragePowerWatts, forKey: .recentAveragePowerWatts)

+        try c.encode(medianPowerWatts, forKey: .medianPowerWatts)

+        try c.encode(minimumPowerWatts, forKey: .minimumPowerWatts)

+        try c.encode(maximumPowerWatts, forKey: .maximumPowerWatts)

+        try c.encode(standardDeviationPowerWatts, forKey: .standardDeviationPowerWatts)

+        try c.encode(coefficientOfVariation, forKey: .coefficientOfVariation)

+        try c.encode(averageCurrentAmps, forKey: .averageCurrentAmps)

+        try c.encode(averageVoltageVolts, forKey: .averageVoltageVolts)

+        try c.encode(stabilityDeltaWatts, forKey: .stabilityDeltaWatts)

+        try c.encode(stabilityToleranceWatts, forKey: .stabilityToleranceWatts)

+        try c.encode(storedHistogram, forKey: .storedHistogram)

+    }

+

+    // MARK: - Computed

+

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

+

+    /// Returns the histogram downsampled to the requested resolution.

+    /// The stored histogram is always at 4× so factor = 4 / resolution.rawValue.

+    func histogram(resolution: HistogramResolution = .x4) -> [ChargerStandbyPowerDistributionBin] {

+        let factor = HistogramResolution.x4.rawValue / resolution.rawValue

+        return ChargerStandbyPowerMeasurementAnalyzer.downsample(storedHistogram, factor: factor)

+    static let recentSampleWindow = 40

+    static let minimumStabilityToleranceWatts = 0.010

+    static let relativeStabilityTolerance = 0.05

+        let baseBinCount = min(18, max(8, Int(Double(powerValues.count).squareRoot().rounded())))

+        let liveHistogram = histogram(for: powerValues, preferredBinCount: baseBinCount * HistogramResolution.x4.rawValue)

+

+            histogram: liveHistogram

+            storedHistogram: statistics.histogram

+    /// Merges consecutive bins in groups of `factor`. Returns the input unchanged when factor ≤ 1.

+    static func downsample(

+        _ bins: [ChargerStandbyPowerDistributionBin],

+        factor: Int

+    ) -> [ChargerStandbyPowerDistributionBin] {

+        guard factor > 1, !bins.isEmpty else { return bins }

+        let totalCount = bins.reduce(0) { $0 + $1.count }

+        var result: [ChargerStandbyPowerDistributionBin] = []

+        var inputIndex = 0

+        var outputIndex = 0

+        while inputIndex < bins.count {

+            let group = Array(bins[inputIndex..<min(inputIndex + factor, bins.count)])

+            let mergedCount = group.reduce(0) { $0 + $1.count }

+            let relFreq = totalCount > 0 ? Double(mergedCount) / Double(totalCount) : 0

+            result.append(ChargerStandbyPowerDistributionBin(

+                index: outputIndex,

+                lowerBoundWatts: group.first!.lowerBoundWatts,

+                upperBoundWatts: group.last!.upperBoundWatts,

+                count: mergedCount,

+                relativeFrequency: relFreq

+            ))

+            inputIndex += factor

+            outputIndex += 1

+        }

+        return result

+    }

+

+    let isExpanded: Bool

+    let onToggle: () -> Void

+            if isExpanded {

+                // Library overview row — navigates to the full management library

+                NavigationLink(destination: SidebarChargedDeviceLibraryView(mode: mode)) {

+                    libraryRow

+                .transition(.opacity.combined(with: .move(edge: .top)))

+

+                ForEach(chargedDevices) { chargedDevice in

+                    NavigationLink(destination: ChargedDeviceDetailView(chargedDeviceID: chargedDevice.id)) {

+                        ChargedDeviceSidebarCardView(chargedDevice: chargedDevice)

+                    }

+                    .buttonStyle(.plain)

+                    .transition(.opacity.combined(with: .move(edge: .top)))

+                }

+            Button(action: onToggle) {

+                HStack(alignment: .firstTextBaseline, spacing: 4) {

+                    Image(systemName: "chevron.right")

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

+                        .foregroundColor(.secondary)

+                        .rotationEffect(.degrees(isExpanded ? 90 : 0))

+                        .animation(.easeInOut(duration: 0.22), value: isExpanded)

+                    Text(title)

+                        .font(.headline)

+                }

+            }

+            .buttonStyle(.plain)

+struct MeterInfoCardView<Content: View, TrailingActions: View>: View {

+    @ViewBuilder var trailingActions: TrailingActions

+        @ViewBuilder trailingActions: () -> TrailingActions = { EmptyView() },

+        self.trailingActions = trailingActions()

+                Spacer(minLength: 0)

+                trailingActions

+                    liveMeterStripView

+    // MARK: - Live Meter Strip (idle state)

+

+    private var liveMeterStripView: some View {

+        let columns = [GridItem(.flexible()), GridItem(.flexible()), GridItem(.flexible())]

+        return LazyVGrid(columns: columns, spacing: 8) {

+            metricCell(label: "Power", value: "\(usbMeter.power.format(decimalDigits: 2)) W", tint: .yellow)

+            metricCell(label: "Current", value: "\(usbMeter.current.format(decimalDigits: 3)) A", tint: .blue)

+            metricCell(label: "Voltage", value: "\(usbMeter.voltage.format(decimalDigits: 2)) V", tint: .teal)

+        }

+    }

+

+        let batteryPrediction = selectedChargedDevice?.batteryLevelPrediction(

+            for: openChargeSession,

+            effectiveEnergyWhOverride: displayedEnergyWh

+        )

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

+            // Orphaned session warning — device was deleted from library

+            if selectedChargedDevice == nil {

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

+                    Label("Device removed from library", systemImage: "exclamationmark.triangle.fill")

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

+                        .foregroundColor(.orange)

+                    Text("The device associated with this session no longer exists. Stop the session to close it.")

+                        .font(.caption)

+                        .foregroundColor(.secondary)

+                    Button("Stop Session") {

+                        finalCheckpointMode = .skip

+                        finalCheckpointText = ""

+                        _ = appData.stopChargeSession(

+                            sessionID: openChargeSession.id,

+                            finalBatteryPercent: nil

+                        )

+                    }

+                    .frame(maxWidth: .infinity)

+                    .padding(.vertical, 9)

+                    .meterCard(tint: .red, fillOpacity: 0.16, strokeOpacity: 0.22, cornerRadius: 12)

+                    .buttonStyle(.plain)

+                }

+                .padding(14)

+                .meterCard(tint: .orange, fillOpacity: 0.10, strokeOpacity: 0.16, cornerRadius: 16)

+            }

+

+            // Battery prediction gauge

+            if let batteryPrediction {

+                batteryGaugeSection(

+                    prediction: batteryPrediction,

+                    session: openChargeSession,

+                    displayedEnergyWh: displayedEnergyWh

+                )

+            }

+

+            // Metrics grid

+            sessionMetricsGrid(

+                for: openChargeSession,

+                displayedEnergyWh: displayedEnergyWh,

+                hasPrediction: batteryPrediction != nil

+                predictedPercent: batteryPrediction?.predictedPercent

+    // MARK: - Battery Gauge Section

+

+    private func batteryGaugeSection(

+        prediction: BatteryLevelPrediction,

+        session: ChargeSessionSummary,

+        displayedEnergyWh: Double

+    ) -> some View {

+        let percent = prediction.predictedPercent

+        let color = batteryColor(for: percent)

+        let duration = max(session.effectiveDuration, 0)

+        let rateWhPerSec: Double? = duration > 300 && displayedEnergyWh > 0.01

+            ? displayedEnergyWh / duration

+            : nil

+

+        let etaToFull: String? = {

+            guard let rate = rateWhPerSec, rate > 0.0001, percent < 98 else { return nil }

+            let remaining = max(prediction.estimatedCapacityWh - displayedEnergyWh, 0)

+            let seconds = remaining / rate

+            return seconds > 120 ? formatETA(seconds) : nil

+        }()

+

+        let etaToTarget: String? = {

+            guard let target = session.targetBatteryPercent, target > percent + 1,

+                  let rate = rateWhPerSec, rate > 0.0001 else { return nil }

+            let targetEnergyWh = (target / 100) * prediction.estimatedCapacityWh

+            let remaining = max(targetEnergyWh - displayedEnergyWh, 0)

+            let seconds = remaining / rate

+            return seconds > 120 ? formatETA(seconds) : nil

+        }()

+

+        return VStack(spacing: 10) {

+            HStack(alignment: .lastTextBaseline, spacing: 8) {

+                HStack(alignment: .lastTextBaseline, spacing: 3) {

+                    Text("\(Int(percent.rounded()))")

+                        .font(.system(size: 52, weight: .bold, design: .rounded))

+                        .foregroundColor(color)

+                        .monospacedDigit()

+                    Text("%")

+                        .font(.title2.weight(.semibold))

+                        .foregroundColor(color.opacity(0.8))

+                }

+                Spacer()

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

+                    Text("\(prediction.estimatedCapacityWh.format(decimalDigits: 2)) Wh")

+                        .font(.callout.weight(.bold))

+                        .foregroundColor(.orange)

+                        .monospacedDigit()

+                    Text("est. capacity")

+                        .font(.caption2)

+                        .foregroundColor(.secondary)

+                }

+            }

+

+            batteryProgressBar(

+                percent: percent,

+                startPercent: session.startBatteryPercent,

+                targetPercent: session.targetBatteryPercent

+            )

+

+            HStack(spacing: 14) {

+                if let etaToFull {

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

+                        HStack(spacing: 4) {

+                            Image(systemName: "clock.fill")

+                                .font(.caption)

+                                .foregroundColor(.green)

+                            Text(etaToFull)

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

+                        }

+                        Text("to full")

+                            .font(.caption2)

+                            .foregroundColor(.secondary)

+                    }

+                }

+                if let etaToTarget, let target = session.targetBatteryPercent {

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

+                        HStack(spacing: 4) {

+                            Image(systemName: "bell.badge.fill")

+                                .font(.caption)

+                                .foregroundColor(.indigo)

+                            Text(etaToTarget)

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

+                        }

+                        Text("to \(Int(target.rounded()))%")

+                            .font(.caption2)

+                            .foregroundColor(.secondary)

+                    }

+                }

+                Spacer()

+                Text("anchored to \(prediction.anchorDescription) at \(prediction.anchorPercent.format(decimalDigits: 0))%")

+                    .font(.caption2)

+                    .foregroundColor(.secondary)

+                    .multilineTextAlignment(.trailing)

+            }

+        }

+        .padding(14)

+        .meterCard(tint: color, fillOpacity: 0.10, strokeOpacity: 0.16, cornerRadius: 16)

+    }

+

+    private func batteryProgressBar(

+        percent: Double,

+        startPercent: Double?,

+        targetPercent: Double?

+    ) -> some View {

+        let color = batteryColor(for: percent)

+        return GeometryReader { geo in

+            let width = geo.size.width

+            ZStack(alignment: .leading) {

+                Capsule()

+                    .fill(Color.primary.opacity(0.10))

+                Rectangle()

+                    .fill(

+                        LinearGradient(

+                            colors: [color.opacity(0.6), color],

+                            startPoint: .leading,

+                            endPoint: .trailing

+                        )

+                    )

+                    .frame(width: max(width * CGFloat(percent / 100), 4))

+                    .animation(.easeInOut(duration: 0.4), value: percent)

+                if let start = startPercent, start > 2, start < 98 {

+                    Rectangle()

+                        .fill(Color.white.opacity(0.55))

+                        .frame(width: 2, height: 20)

+                        .offset(x: width * CGFloat(start / 100) - 1)

+                }

+                if let target = targetPercent {

+                    Rectangle()

+                        .fill(Color.indigo.opacity(0.9))

+                        .frame(width: 2.5, height: 20)

+                        .offset(x: width * CGFloat(target / 100) - 1.25)

+                }

+            }

+            .clipShape(Capsule())

+        }

+        .frame(height: 20)

+    }

+

+    private func batteryColor(for percent: Double) -> Color {

+        if percent >= 75 { return .green }

+        if percent >= 35 { return .orange }

+        return .red

+    }

+

+    private func formatETA(_ seconds: TimeInterval) -> String {

+        let totalMinutes = Int(seconds / 60)

+        if totalMinutes < 60 { return "\(totalMinutes)m" }

+        let hours = totalMinutes / 60

+        let minutes = totalMinutes % 60

+        return minutes == 0 ? "\(hours)h" : "\(hours)h \(minutes)m"

+    }

+

+    // MARK: - Session Metrics Grid

+

+    private func sessionMetricsGrid(

+        for session: ChargeSessionSummary,

+        displayedEnergyWh: Double,

+        hasPrediction: Bool

+    ) -> some View {

+        let capacityFallback: Double? = hasPrediction ? nil : (

+            session.capacityEstimateWh

+                ?? selectedChargedDevice?.estimatedBatteryCapacityWh(for: session.chargingTransportMode)

+                ?? selectedChargedDevice?.estimatedBatteryCapacityWh

+        )

+        let columns = [GridItem(.flexible()), GridItem(.flexible())]

+

+        return LazyVGrid(columns: columns, spacing: 8) {

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

+            metricCell(label: "Duration", value: formatDuration(max(session.effectiveDuration, 0)), tint: .teal)

+

+            if shouldShowChargingTransport(for: session) {

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

+            }

+            if shouldShowChargingState(for: session) {

+                metricCell(label: "Mode", value: session.chargingStateMode.title, tint: .purple)

+            }

+

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

+

+            if let capacity = capacityFallback {

+                metricCell(label: "Est. Capacity", value: "\(capacity.format(decimalDigits: 2)) Wh", tint: .orange)

+            }

+        }

+    }

+

+    private func metricCell(label: String, value: String, tint: Color) -> some View {

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

+            Text(label)

+                .font(.caption2)

+                .foregroundColor(.secondary)

+            Text(value)

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

+                .lineLimit(1)

+                .minimumScaleFactor(0.7)

+                .monospacedDigit()

+        }

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

+        .padding(.horizontal, 12)

+        .padding(.vertical, 10)

+        .meterCard(tint: tint, fillOpacity: 0.08, strokeOpacity: 0.12, cornerRadius: 12)

+    }

+

+import UniformTypeIdentifiers

+                StandbyPowerDistributionCard(

+// MARK: - Distribution card with resolution picker and CSV export

+

+private struct StandbyPowerDistributionCard: View {

+    let histogram: [ChargerStandbyPowerDistributionBin]

+    let averagePowerWatts: Double

+    let standardDeviationPowerWatts: Double

+    let tint: Color

+    var showExport: Bool = false

+

+    private func resolution(for width: CGFloat) -> HistogramResolution {

+        if width >= 600 { return .x4 }

+        if width >= 360 { return .x2 }

+        return .x1

+    }

+

+    private func displayedHistogram(width: CGFloat) -> [ChargerStandbyPowerDistributionBin] {

+        let factor = HistogramResolution.x4.rawValue / resolution(for: width).rawValue

+        return ChargerStandbyPowerMeasurementAnalyzer.downsample(histogram, factor: factor)

+    }

+

+    private var csvString: String {

+        var lines = ["Bin,Lower Bound (W),Upper Bound (W),Count,Relative Frequency (%)"]

+        for bin in histogram {

+            lines.append(

+                "\(bin.index + 1),"

+                + String(format: "%.6f", bin.lowerBoundWatts) + ","

+                + String(format: "%.6f", bin.upperBoundWatts) + ","

+                + "\(bin.count),"

+                + String(format: "%.4f", bin.relativeFrequency * 100)

+            )

+        }

+        return lines.joined(separator: "\n")

+    }

+

+    var body: some View {

+        MeterInfoCardView(

+            title: "Value Spread",

+            infoMessage: "Bars show how often each power interval appeared. The curve overlays a normal approximation around the observed mean and standard deviation.",

+            tint: tint,

+            trailingActions: {

+                if showExport {

+                    if #available(iOS 16, *) {

+                        ShareLink(

+                            item: DistributionCSVExport(content: csvString),

+                            preview: SharePreview("distribution.csv")

+                        ) {

+                            Image(systemName: "square.and.arrow.up")

+                                .font(.subheadline.weight(.medium))

+                                .foregroundStyle(.secondary)

+                        }

+                    } else {

+                        Button {

+                            exportCSVLegacy(csvString)

+                        } label: {

+                            Image(systemName: "square.and.arrow.up")

+                                .font(.subheadline.weight(.medium))

+                                .foregroundStyle(.secondary)

+                        }

+                    }

+                }

+            }

+        ) {

+            GeometryReader { proxy in

+                let bins = displayedHistogram(width: proxy.size.width)

+                StandbyPowerHistogramView(

+                    histogram: bins,

+                    averagePowerWatts: averagePowerWatts,

+                    standardDeviationPowerWatts: standardDeviationPowerWatts,

+                    tint: tint

+                )

+

+                if let firstBin = bins.first, let lastBin = bins.last {

+                    let midpointWatts = (firstBin.lowerBoundWatts + lastBin.upperBoundWatts) / 2

+                    VStack {

+                        Spacer()

+                        HStack {

+                            Text("\(firstBin.lowerBoundWatts.format(decimalDigits: 3)) W")

+                            Spacer()

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

+                            Spacer()

+                            Text("\(lastBin.upperBoundWatts.format(decimalDigits: 3)) W")

+                        }

+                        .font(.caption)

+                        .foregroundColor(.secondary)

+                        .monospacedDigit()

+                    }

+                }

+            }

+            .frame(height: 240)

+        }

+    }

+

+    private func exportCSVLegacy(_ csv: String) {

+        guard let windowScene = UIApplication.shared.connectedScenes

+            .compactMap({ $0 as? UIWindowScene }).first,

+              let rootVC = windowScene.windows.first?.rootViewController else { return }

+        let activityVC = UIActivityViewController(

+            activityItems: [csv],

+            applicationActivities: nil

+        )

+        rootVC.present(activityVC, animated: true)

+    }

+}

+

+@available(iOS 16, *)

+struct DistributionCSVExport: Transferable {

+    let content: String

+

+    static var transferRepresentation: some TransferRepresentation {

+        DataRepresentation(exportedContentType: .commaSeparatedText) { export in

+            Data(export.content.utf8)

+        }

+        .suggestedFileName("distribution")

+    }

+}

+

+// MARK: - Histogram bars + Gaussian curve

+

+                .navigationBarTitleDisplayMode(.inline)

+                    .navigationBarTitleDisplayMode(.inline)

+        StandbyPowerDistributionCard(

+            histogram: measurement.storedHistogram,

+            averagePowerWatts: measurement.averagePowerWatts,

+            standardDeviationPowerWatts: measurement.standardDeviationPowerWatts,

+            tint: .orange,

+            showExport: true

+        )

+    let isExpanded: Bool

+    let onToggle: () -> Void

+            if isExpanded {

+                if meters.isEmpty {

+                    Text(devicesEmptyStateText)

+                        .font(.footnote)

+                        .foregroundColor(.secondary)

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

+                        .padding(18)

+                        .meterCard(

+                            tint: isWaitingForFirstDiscovery ? .blue : .secondary,

+                            fillOpacity: 0.14,

+                            strokeOpacity: 0.20

+                        )

+                        .transition(.opacity.combined(with: .move(edge: .top)))

+                } else {

+                    ForEach(meters) { meterSummary in

+                        if let meter = meterSummary.meter {

+                            NavigationLink(destination: MeterView().environmentObject(meter)) {

+                                MeterRowView()

+                                    .environmentObject(meter)

+                            }

+                            .buttonStyle(.plain)

+                            .transition(.opacity.combined(with: .move(edge: .top)))

+                        } else {

+                            NavigationLink(destination: MeterDetailView(meterSummary: meterSummary)) {

+                                MeterCardView(meterSummary: meterSummary)

+                            }

+                            .buttonStyle(.plain)

+                            .transition(.opacity.combined(with: .move(edge: .top)))

+            Button(action: onToggle) {

+                HStack(alignment: .firstTextBaseline, spacing: 4) {

+                    Image(systemName: "chevron.right")

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

+                        .rotationEffect(.degrees(isExpanded ? 90 : 0))

+                        .animation(.easeInOut(duration: 0.22), value: isExpanded)

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

+                        Text("USB & Known Meters")

+                            .font(.headline)

+                        if meters.isEmpty == false {

+                            Text(sectionSubtitleText)

+                                .font(.caption)

+                                .foregroundColor(.secondary)

+                                .lineLimit(1)

+                        }

+                    }

+            .buttonStyle(.plain)

+    @State private var isUSBMetersExpanded = true

+    @State private var isDevicesExpanded = true

+    @State private var isChargersExpanded = true

+                isExpanded: isUSBMetersExpanded,

+                onToggle: {

+                    withAnimation(.easeInOut(duration: 0.22)) {

+                        isUSBMetersExpanded.toggle()

+                    }

+                },

+                isExpanded: isDevicesExpanded,

+                onToggle: {

+                    withAnimation(.easeInOut(duration: 0.22)) {

+                        isDevicesExpanded.toggle()

+                    }

+                },

+                isExpanded: isChargersExpanded,

+                onToggle: {

+                    withAnimation(.easeInOut(duration: 0.22)) {

+                        isChargersExpanded.toggle()

+                    }

+                },