+    @State private var isBatteryCardExpanded = false

+            isBatteryCardExpanded = false

+        let startPercent = session.startBatteryPercent

+        let endPercent = session.endBatteryPercent ?? batteryPrediction?.predictedPercent

+        let isEstimatedEnd = session.endBatteryPercent == nil && batteryPrediction != nil

+        let showsPreview = startPercent != nil && endPercent != nil

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

+

+            // Header — always visible, tappable

+            HStack(spacing: 8) {

+                Text("Battery")

+                    .font(.headline)

+                Spacer(minLength: 0)

+                Image(systemName: "chevron.up")

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

+                    .foregroundColor(.secondary)

+                    .rotationEffect(.degrees(isBatteryCardExpanded ? 0 : -180))

+                    .animation(.easeInOut(duration: 0.2), value: isBatteryCardExpanded)

+            }

+            .contentShape(Rectangle())

+            .onTapGesture {

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

+                    isBatteryCardExpanded.toggle()

+            }

+            // Preview bar — always visible when there is enough data

+            if showsPreview, let start = startPercent, let end = endPercent {

+                batteryPreviewBar(

+                    startPercent: start,

+                    endPercent: end,

+                    checkpoints: session.checkpoints,

+                    isEstimatedEnd: isEstimatedEnd

+                )

+                .padding(.top, 10)

+            }

+

+            // Collapsible detail

+            if isBatteryCardExpanded {

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

+

+                    // Energy

+                        overviewStatCell(label: "Battery Energy", value: "\(displayedEnergyWh.format(decimalDigits: 3)) Wh")

+                        if let capacityEstimateWh = session.capacityEstimateWh {

+                            overviewStatCell(label: "Capacity Estimate", value: "\(capacityEstimateWh.format(decimalDigits: 2)) Wh")

+                    if abs(displayedEnergyWh - session.measuredEnergyWh) > 0.01 {

+                        MeterInfoRowView(label: "Measured Energy", value: "\(session.measuredEnergyWh.format(decimalDigits: 3)) Wh")

+                    }

+                    if let effectiveBatteryEnergyWh = session.effectiveBatteryEnergyWh,

+                       abs(effectiveBatteryEnergyWh - session.measuredEnergyWh) > 0.01 {

+                        MeterInfoRowView(label: "Effective Battery Energy", value: "\(effectiveBatteryEnergyWh.format(decimalDigits: 3)) Wh")

+                    }

+                    if let chargerID = session.chargerID,

+                       let charger = appData.chargedDeviceSummary(id: chargerID) {

+                        MeterInfoRowView(label: chargedDevice.hasMultipleChargingTransports ? "Wireless Charger" : "Charger", value: charger.name)

+                    }

+                    if let wirelessSessionHint = wirelessSessionHint(for: session) {

+                        Text(wirelessSessionHint)

+                            .font(.caption2)

+                            .foregroundColor(session.shouldWarnAboutLowWirelessEfficiency ? .orange : .secondary)

+                    }

+                    if let sessionWarning = sessionWarning(for: session) {

+                        Label(sessionWarning, systemImage: "exclamationmark.triangle")

+                            .font(.caption2)

+                            .foregroundColor(.orange)

+                    }

+

+                    // Battery percentages

+                    if startPercent != nil || session.endBatteryPercent != nil {

+                        Divider()

+                            if let v = startPercent {

+                                overviewStatCell(label: "Start Battery", value: "\(v.format(decimalDigits: 0))%")

+                            if let v = session.endBatteryPercent {

+                                overviewStatCell(label: "End Battery", value: "\(v.format(decimalDigits: 0))%")

+                        if session.batteryDeltaPercent != nil || session.targetBatteryPercent != nil {

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

+                                if let v = session.batteryDeltaPercent {

+                                    overviewStatCell(label: "Battery Delta", value: "\(v.format(decimalDigits: 0))%")

+                                }

+                                if let v = session.targetBatteryPercent {

+                                    overviewStatCell(label: "Target", value: "\(v.format(decimalDigits: 0))%")

+                                }

+                            }

+                        }

+                        if let batteryPrediction {

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

+                                overviewStatCell(label: "Predicted Battery", value: "\(batteryPrediction.predictedPercent.format(decimalDigits: 0))%")

+                            }

+                            Text(

+                                "Anchored to \(batteryPrediction.anchorDescription) at \(batteryPrediction.anchorPercent.format(decimalDigits: 0))% using \(batteryPrediction.estimatedCapacityWh.format(decimalDigits: 2)) Wh estimated capacity."

+                            )

+                            .font(.caption2)

+                            .foregroundColor(.secondary)

+

+                    // Checkpoints

+                    Divider()

+                    BatteryCheckpointSectionView(

+                        sessionID: session.id,

+                        checkpoints: session.checkpoints,

+                        message: session.status.isOpen

+                            ? "The checkpoint is stored on the active charge session and is used for capacity estimation and charge-level prediction."

+                            : "These checkpoints were saved with this closed session and feed capacity estimation and charge-level prediction.",

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

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

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

+                        effectiveEnergyWhOverride: hasMonitoringControls ? displayedEnergyWh : nil,

+                        onDelete: { checkpoint in

+                            pendingCheckpointDeletion = checkpoint

+                        }

+                    )

+                .padding(.top, 12)

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

+            }

+        }

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

+        .padding(18)

+        .meterCard(tint: .orange, fillOpacity: 0.18, strokeOpacity: 0.24)

+    }

+    private func batteryPreviewBar(

+        startPercent: Double,

+        endPercent: Double,

+        checkpoints: [ChargeCheckpointSummary],

+        isEstimatedEnd: Bool

+    ) -> some View {

+        let startFrac = CGFloat(max(0, min(startPercent, 100)) / 100)

+        let endFrac   = CGFloat(max(0, min(endPercent,   100)) / 100)

+        let color = batteryColor(for: endPercent)

+

+        return HStack(spacing: 6) {

+            Text("\(Int(startPercent.rounded()))%")

+                .font(.caption2.weight(.semibold))

+                .foregroundColor(.secondary)

+                .monospacedDigit()

+                .frame(minWidth: 26, alignment: .trailing)

+

+            GeometryReader { geo in

+                let w = geo.size.width

+                ZStack(alignment: .leading) {

+                    Capsule()

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

+

+                    Rectangle()

+                        .fill(color.opacity(isEstimatedEnd ? 0.45 : 0.72))

+                        .frame(width: max(w * (endFrac - startFrac), 3))

+                        .offset(x: w * startFrac)

+

+                    ForEach(checkpoints, id: \.id) { cp in

+                        let xFrac = CGFloat(max(0, min(cp.batteryPercent, 100)) / 100)

+                        let isFinal = cp.flag == .final

+                        Rectangle()

+                            .fill(Color.white.opacity(isFinal ? 0.95 : 0.70))

+                            .frame(width: isFinal ? 2.0 : 1.5, height: 10)

+                            .offset(x: w * xFrac - (isFinal ? 1.0 : 0.75))

+                }

+                .clipShape(Capsule())

+            }

+            .frame(height: 8)

+

+            HStack(spacing: 1) {

+                if isEstimatedEnd {

+                    Text("~")

+                        .font(.caption2)

+                        .foregroundColor(.secondary)

+                }

+                Text("\(Int(endPercent.rounded()))%")

+                    .font(.caption2.weight(.semibold))

+                    .foregroundColor(isEstimatedEnd ? .secondary : color)

+                    .monospacedDigit()

+            .frame(minWidth: 32, alignment: .leading)