+# External Contributions

+

+This document tracks contributions made by collaborators outside the core project.

+Its purpose is to support ongoing evaluation of each contributor's work quality,

+patterns, and reliability over time.

+

+---

+

+## Contributor A — anonim, prieten al autorului

+

+Toate intervențiile cunoscute sunt în `AppData.swift`, `ChargeInsightsStore.swift`, și `Meter.swift`.

+

+---

+

+### Intervenție 1 — Fix lag UI la formulare (aprilie 2026)

+

+**Context:** La conectarea unui contor live, formularele din UI (typing, picker)

+deveneau iresponsive. `reloadChargedDevices()` rula sincron pe main thread la fiecare

+snapshot BLE (~1/s), blocând UIKit.

+

+**Commit:** `4f79218` *(înglobat cu Intervenția 2)*

+

+**Modificări introduse:**

+

+- `chargeInsightsReadStore` — context separat de citire (`privateQueueConcurrencyType`)

+- `chargedDevicesReloadQueue` — fetch mutat pe background queue

+- `chargedDevicesReloadGeneration` — counter de invalidare pentru fetch-uri async depășite

+

+**Bug introdus (descoperit ulterior):**

+

+Pattern-ul generation+invalidare era prea agresiv. Contorul era incrementat la fiecare

+apel `reloadChargedDevices()`, inclusiv cele declanșate în burst de

+`NSManagedObjectContextObjectsDidChange`. Orice fetch async dura >0ms → generația era

+deja depășită la finalizare → rezultatul era aruncat. Lista rămânea goală permanent

+atât timp cât un contor live era conectat, indiferent că SQLite conținea date reale.

+

+**Evaluare:** Problema identificată era reală. Soluția era funcțională în absența unui

+contor conectat (test static), dar s-a rupt sub load real. Eroare clasică de

+async invalidation, probabil netestat cu dispozitiv real.

+

+---

+

+### Intervenție 2 — Fix starvation reload (după aprilie 2026)

+

+**Context:** Lista de charged devices rămânea goală permanent când un contor era activ.

+Cauzat de bug-ul din Intervenția 1. Autorul a identificat și corectat singur problema.

+

+**Commit:** `4f79218`

+

+**Modificări introduse:**

+

+- Înlocuire generation counter cu pattern `inFlight`/`pending`

+  - `chargedDevicesReloadInFlight: Bool` — un singur fetch în zbor la un moment dat

+  - `chargedDevicesReloadPending: Bool` — cerere nouă marcată pentru după finalizare

+- `scheduleChargedDevicesReload(delay: 0.15)` — debounce pentru burst-uri de notificări

+

+**Evaluare:** Corect și complet. Soluția standard pentru problema dată. Nu introduce

+regresii. Diagnosticul era precis (cita dimensiunile exacte din SQLite: 10 devices,

+15 sesiuni, 49 checkpoints, 24.279 samples).

+

+---

+

+### Intervenție 3 — Optimizare CPU pe Catalyst (aprilie 2026)

+

+**Context:** Procesul Catalyst consuma CPU ridicat și constant. Identificat prin profiling.

+

+**Commits:** `406be0e` (împreună cu ajustări ulterioare ale intervalelor)

+

+**Cauze identificate de contributor:**

+

+1. BLE polling continuu — `dataDumpRequest()` recursiv imediat după fiecare răspuns

+2. Fiecare pachet BLE atingea CoreData/iCloud direct, cu reload UI frecvent

+3. `noteMeterSeen` scria în `MeterNameStore` la fiecare observație

+

+**Modificări introduse:**

+

+- `Meter.swift` — `minimumLivePollingInterval = 0.4s`; înlocuit recursie imediată cu

+  `scheduleNextLiveDataDumpRequest()` care respectă intervalul minim

+- `AppData.swift` — coalescere snapshot-uri BLE în memorie (`pendingChargeObservationSnapshots`);

+  flush periodic la 30s cu flush explicit la pause/stop/checkpoint/terminate;

+  throttle `noteMeterSeen` la 15s; observer schimbat din `ObjectsDidChange` → `DidSave`

+- `AppData.swift` — `writeContext` privat pentru `ChargeInsightsStore`

+  (anterior store-ul scria direct pe `viewContext`, i.e. main thread)

+- `ChargeInsightsStore.swift` — `maximumLiveIntegrationGap` 20s → 90s

+  (aliniat cu fereastra de coalescere de 30s)

+

+**Probleme rămase după livrare (rezolvate în același commit):**

+

+- Work item-ul de flush era dispatchat pe `DispatchQueue.main`; apela

+  `context.performAndWait` → bloca main thread la fiecare 30s (spike vizibil în profiler)

+- `flushPendingChargeObservation` chema explicit `reloadChargedDevices()`, iar observer-ul

+  DidSave chema și el `scheduleChargedDevicesReload()` — double reload per flush

+

+Aceste două probleme au fost remediate separat (fix în `406be0e`):

+flush-ul periodic mută scrierea CoreData pe `DispatchQueue.global(qos: .utility)`;

+reload-ul explicit eliminat din flush, lăsat exclusiv pe seama observer-ului DidSave.

+

+**Note privind originea problemelor rezolvate:**

+

+`NSManagedObjectContextObjectsDidChange` ca observer și `viewContext` pentru scrieri

+existau în codul proiectului **înainte** de orice intervenție a acestui contributor.

+Intervenția 3 rezolvă probleme de design preexistente, nu regresii proprii.

+Singura auto-corecție este `maximumLiveIntegrationGap`, ajustat pentru coalescing-ul

+introdus tot în această intervenție.

+

+**Evaluare:** Diagnostic corect pentru toate cele trei cauze. Modificările sunt

+coerente între ele. Livrarea conținea două bug-uri minore (main thread + double reload)

+care au necesitat remediere imediată, detectabile printr-un review atent al codului

+fără a fi nevoie de runtime. Efectul net: CPU redus de la consum constant la 0–4%

+cu spike-uri reziduale la ~30s (CloudKit sync inerent).

+

+---

+

+## Session Trim Feature — Buffer Restore Bug (pentru externalizare)

+

+### Contextul feature-ului

+

+S-a implementat un feature de "Session Trim": detectare automată a ferestrei reale de încărcare (ex: Apple Watch se încarcă 3h dar sesiunea rulează 16h overnight) + editor manual pentru trim. Feature-ul este complet implementat și compilează fără erori.

+

+**Există un bug pre-existent** care blochează funcționarea feature-ului și trebuie rezolvat separat.

+

+---

+

+### Bug: istoricul sesiunii se pierde la fiecare restart de aplicație

+

+**Simptom:** La restart cu sesiune activă, graficul afișează intervalul complet al sesiunii (ex: 16h) dar cu date doar din momentul reconectării BLE. Istoricul din Core Data nu este restaurat.

+

+**Consecință pentru trim:** Banner-ul de trim nu apare (se bazează pe `aggregatedSamples` gol), editorul de trim are graficul gol.

+

+---

+

+### Unde este problema

+

+**`Meter.restoreChargeRecordIfNeeded(from:)`** — `USB Meter/Model/Meter.swift`

+

+```swift

+func restoreChargeRecordIfNeeded(from activeSession: ChargeSessionSummary) {

+    guard chargeRecordState == .waitingForStart else { return }  // ← problema

+    guard chargeRecordStartTimestamp == nil else { return }

+    guard chargeRecordAH == 0, chargeRecordWH == 0, chargeRecordDuration == 0 else { return }

+

+    measurements.restorePersistedChargeSessionSamplesIfNeeded(from: activeSession)

+    ...

+}

+```

+

+**Race condition:** Datele BLE ajung înaintea completării `reloadChargedDevices` (async). La primul pachet BLE, `chargeRecordState` trece `waitingForStart → active`. Când `reloadChargedDevices` finalizează și încearcă restore, primul guard blochează — permanent pentru sesiunea curentă.

+

+**`Measurements.restorePersistedChargeSessionSamplesIfNeeded`** are propriul guard: returnează dacă vreun series este non-gol. Dacă se rezolvă problema de mai sus și datele BLE au umplut deja buffer-ul, acesta trebuie resetat înainte de restore — dar **numai dacă `aggregatedSamples` nu este gol**, altfel graficul rămâne gol definitiv.

+

+---

+

+### Lanțul de apel la pornire

+

+```text

+SceneDelegate.activateCloudDeviceSync

+  → AppData.activateChargeInsights        // setup writeContext + readContext

+  → AppData.scheduleChargedDevicesReload  // async, ~100–500ms

+

+[BLE se conectează, date ajung — pe main queue]

+  → Meter.processData → Meter.updateChargeRecord

+    → chargeRecordState = .active  // ← guard-ul din restore va bloca

+

+[reloadChargedDevices completează]

+  → AppData.restoreChargeMonitoringStateIfNeeded(for: meter)

+    → Meter.restoreChargeRecordIfNeeded(from: session)  // ← guard blochează

+```

+

+---

+

+### Fișiere modificate de feature (necommitted, diff disponibil)

+

+| Fișier | Modificare |

+| ------ | ---------- |

+| `USB Meter/Model/CKModel.xcdatamodeld/USB_Meter 15.xcdatamodel/` | Nou — adaugă `trimStart`/`trimEnd` opționale pe `ChargeSession` |

+| `USB Meter/Model/CKModel.xcdatamodeld/.xccurrentversion` | → v15 |

+| `USB Meter/Model/ChargingWindowDetector.swift` | Nou — detectează fereastra activă de încărcare |

+| `USB Meter/Views/Meter/Tabs/ChargeRecord/SessionTrimEditorView.swift` | Nou — editor trim cu drag handles |

+| `USB Meter/Model/ChargeInsightsModel.swift` | `trimStart`, `trimEnd`, `isTrimmed` pe `ChargeSessionSummary` |

+| `USB Meter/Model/ChargeInsightsStore.swift` | `setSessionTrim(sessionID:start:end:)` — recalculează energie, șterge checkpoints |

+| `USB Meter/Model/AppData.swift` | Wrapper `setSessionTrim` |

+| `USB Meter/Views/Meter/Tabs/ChargeRecord/MeterChargeRecordTabView.swift` | Banner detecție + sheet editor |

+| `USB Meter.xcodeproj/project.pbxproj` | Referințe fișiere noi |

+

+---

+

+## Tipare observate

+

+| | Interv. 1 | Interv. 2 | Interv. 3 |

+|---|---|---|---|

+| Diagnostic corect | Da | Da | Da |

+| Funcționează fără load real | Da | Da | Da |

+| Funcționează sub load real | Nu | Da | Parțial |

+| Auto-corecție necesară | — | Da (proprie) | Parțial (externă) |

+| Regresii introduse | Da (starvation) | Nu | Nu |

+

+**Observație recurentă:** Contribuțiile funcționează corect în condiții statice dar

+au tendința să rateze edge case-uri sub load real (contor live conectat). Testele

+înainte de livrare par să nu includă scenariul cu dispozitiv activ.

+- `External Contributions.md`

+  Log of contributions from external collaborators, with technical evaluation per intervention.

+		F20000036F5D4C95B6487F18 /* ChargingWindowDetector.swift in Sources */ = {isa = PBXBuildFile; fileRef = F20000016F5D4C95B6487F16 /* ChargingWindowDetector.swift */; };

+		F20000046F5D4C95B6487F19 /* SessionTrimEditorView.swift in Sources */ = {isa = PBXBuildFile; fileRef = F20000026F5D4C95B6487F17 /* SessionTrimEditorView.swift */; };

+		F10000016F5D4C95B6487F15 /* USB_Meter 15.xcdatamodel */ = {isa = PBXFileReference; lastKnownFileType = wrapper.xcdatamodel; path = "USB_Meter 15.xcdatamodel"; sourceTree = "<group>"; };

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

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

+				F20000016F5D4C95B6487F16 /* ChargingWindowDetector.swift */,

+				F20000026F5D4C95B6487F17 /* SessionTrimEditorView.swift */,

+				F20000036F5D4C95B6487F18 /* ChargingWindowDetector.swift in Sources */,

+				F20000046F5D4C95B6487F19 /* SessionTrimEditorView.swift in Sources */,

+				F10000016F5D4C95B6487F15 /* USB_Meter 15.xcdatamodel */,

+			currentVersion = F10000016F5D4C95B6487F15 /* USB_Meter 15.xcdatamodel */;

+	<string>USB_Meter 15.xcdatamodel</string>

+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>

+<model type="com.apple.IDECoreDataModeler.DataModel" documentVersion="1.0" lastSavedToolsVersion="23657" systemVersion="24G81" minimumToolsVersion="Automatic" sourceLanguage="Swift" usedWithCloudKit="YES">

+    <entity name="ChargedDevice" representedClassName="ChargedDevice" syncable="YES" codeGenerationType="class">

+        <attribute name="id" optional="YES" attributeType="String"/>

+        <attribute name="name" optional="YES" attributeType="String"/>

+        <attribute name="deviceClassRawValue" optional="YES" attributeType="String"/>

+        <attribute name="deviceTemplateID" optional="YES" attributeType="String"/>

+        <attribute name="supportsChargingWhileOff" optional="YES" attributeType="Boolean" defaultValueString="NO" usesScalarValueType="YES"/>

+        <attribute name="chargingStateAvailabilityRawValue" optional="YES" attributeType="String"/>

+        <attribute name="supportsWiredCharging" optional="YES" attributeType="Boolean" defaultValueString="YES" usesScalarValueType="YES"/>

+        <attribute name="supportsWirelessCharging" optional="YES" attributeType="Boolean" defaultValueString="NO" usesScalarValueType="YES"/>

+        <attribute name="preferredChargingTransportRawValue" optional="YES" attributeType="String"/>

+        <attribute name="wirelessChargingProfileRawValue" optional="YES" attributeType="String"/>

+        <attribute name="configuredCompletionCurrentsRawValue" optional="YES" attributeType="String"/>

+        <attribute name="learnedCompletionCurrentsRawValue" optional="YES" attributeType="String"/>

+        <attribute name="wiredChargeCompletionCurrentAmps" optional="YES" attributeType="Double" usesScalarValueType="YES"/>

+        <attribute name="wirelessChargeCompletionCurrentAmps" optional="YES" attributeType="Double" usesScalarValueType="YES"/>

+        <attribute name="minimumCurrentAmps" optional="YES" attributeType="Double" usesScalarValueType="YES"/>

+        <attribute name="estimatedBatteryCapacityWh" optional="YES" attributeType="Double" usesScalarValueType="YES"/>

+        <attribute name="wiredMinimumCurrentAmps" optional="YES" attributeType="Double" usesScalarValueType="YES"/>

+        <attribute name="wirelessMinimumCurrentAmps" optional="YES" attributeType="Double" usesScalarValueType="YES"/>

+        <attribute name="wiredEstimatedBatteryCapacityWh" optional="YES" attributeType="Double" usesScalarValueType="YES"/>

+        <attribute name="wirelessEstimatedBatteryCapacityWh" optional="YES" attributeType="Double" usesScalarValueType="YES"/>

+        <attribute name="wirelessChargerEfficiencyFactor" optional="YES" attributeType="Double" usesScalarValueType="YES"/>

+        <attribute name="chargerObservedVoltageSelectionsRawValue" optional="YES" attributeType="String"/>

+        <attribute name="chargerIdleCurrentAmps" optional="YES" attributeType="Double" usesScalarValueType="YES"/>

+        <attribute name="chargerEfficiencyFactor" optional="YES" attributeType="Double" usesScalarValueType="YES"/>

+        <attribute name="chargerMaximumPowerWatts" optional="YES" attributeType="Double" usesScalarValueType="YES"/>

+        <attribute name="qrIdentifier" optional="YES" attributeType="String"/>

+        <attribute name="lastAssociatedMeterMAC" optional="YES" attributeType="String"/>

+        <attribute name="notes" optional="YES" attributeType="String"/>

+        <attribute name="createdAt" optional="YES" attributeType="Date" usesScalarValueType="NO"/>

+        <attribute name="updatedAt" optional="YES" attributeType="Date" usesScalarValueType="NO"/>

+    </entity>

+    <entity name="ChargeSession" representedClassName="ChargeSession" syncable="YES" codeGenerationType="class">

+        <attribute name="id" optional="YES" attributeType="String"/>

+        <attribute name="chargedDeviceID" optional="YES" attributeType="String"/>

+        <attribute name="chargerID" optional="YES" attributeType="String"/>

+        <attribute name="meterMACAddress" optional="YES" attributeType="String"/>

+        <attribute name="meterName" optional="YES" attributeType="String"/>

+        <attribute name="meterModel" optional="YES" attributeType="String"/>

+        <attribute name="startedAt" optional="YES" attributeType="Date" usesScalarValueType="NO"/>

+        <attribute name="endedAt" optional="YES" attributeType="Date" usesScalarValueType="NO"/>

+        <attribute name="lastObservedAt" optional="YES" attributeType="Date" usesScalarValueType="NO"/>

+        <attribute name="pausedAt" optional="YES" attributeType="Date" usesScalarValueType="NO"/>

+        <attribute name="statusRawValue" optional="YES" attributeType="String"/>

+        <attribute name="sourceModeRawValue" optional="YES" attributeType="String"/>

+        <attribute name="chargingTransportRawValue" optional="YES" attributeType="String"/>

+        <attribute name="chargingStateRawValue" optional="YES" attributeType="String"/>

+        <attribute name="autoStopEnabled" optional="YES" attributeType="Boolean" defaultValueString="YES" usesScalarValueType="YES"/>

+        <attribute name="selectedDataGroup" optional="YES" attributeType="Integer 16" usesScalarValueType="YES"/>

+        <attribute name="meterEnergyBaselineWh" optional="YES" attributeType="Double" usesScalarValueType="YES"/>

+        <attribute name="meterChargeBaselineAh" optional="YES" attributeType="Double" usesScalarValueType="YES"/>

+        <attribute name="meterDurationBaselineSeconds" optional="YES" attributeType="Double" usesScalarValueType="YES"/>

+        <attribute name="meterLastEnergyWh" optional="YES" attributeType="Double" usesScalarValueType="YES"/>

+        <attribute name="meterLastChargeAh" optional="YES" attributeType="Double" usesScalarValueType="YES"/>

+        <attribute name="meterLastDurationSeconds" optional="YES" attributeType="Double" usesScalarValueType="YES"/>

+        <attribute name="measuredEnergyWh" optional="YES" attributeType="Double" defaultValueString="0.0" usesScalarValueType="YES"/>

+        <attribute name="effectiveBatteryEnergyWh" optional="YES" attributeType="Double" usesScalarValueType="YES"/>

+        <attribute name="measuredChargeAh" optional="YES" attributeType="Double" defaultValueString="0.0" usesScalarValueType="YES"/>

+        <attribute name="minimumObservedCurrentAmps" optional="YES" attributeType="Double" usesScalarValueType="YES"/>

+        <attribute name="maximumObservedCurrentAmps" optional="YES" attributeType="Double" usesScalarValueType="YES"/>

+        <attribute name="maximumObservedPowerWatts" optional="YES" attributeType="Double" usesScalarValueType="YES"/>

+        <attribute name="maximumObservedVoltageVolts" optional="YES" attributeType="Double" usesScalarValueType="YES"/>

+        <attribute name="selectedSourceVoltageVolts" optional="YES" attributeType="Double" usesScalarValueType="YES"/>

+        <attribute name="completionCurrentAmps" optional="YES" attributeType="Double" usesScalarValueType="YES"/>

+        <attribute name="stopThresholdAmps" optional="YES" attributeType="Double" defaultValueString="0.0" usesScalarValueType="YES"/>

+        <attribute name="startBatteryPercent" optional="YES" attributeType="Double" usesScalarValueType="YES"/>

+        <attribute name="endBatteryPercent" optional="YES" attributeType="Double" usesScalarValueType="YES"/>

+        <attribute name="capacityEstimateWh" optional="YES" attributeType="Double" usesScalarValueType="YES"/>

+        <attribute name="wirelessEfficiencyFactor" optional="YES" attributeType="Double" usesScalarValueType="YES"/>

+        <attribute name="usesEstimatedWirelessEfficiency" optional="YES" attributeType="Boolean" defaultValueString="NO" usesScalarValueType="YES"/>

+        <attribute name="shouldWarnAboutLowWirelessEfficiency" optional="YES" attributeType="Boolean" defaultValueString="NO" usesScalarValueType="YES"/>

+        <attribute name="supportsChargingWhileOff" optional="YES" attributeType="Boolean" defaultValueString="NO" usesScalarValueType="YES"/>

+        <attribute name="usedOfflineMeterCounters" optional="YES" attributeType="Boolean" defaultValueString="NO" usesScalarValueType="YES"/>

+        <attribute name="belowThresholdSince" optional="YES" attributeType="Date" usesScalarValueType="NO"/>

+        <attribute name="lastObservedCurrentAmps" optional="YES" attributeType="Double" defaultValueString="0.0" usesScalarValueType="YES"/>

+        <attribute name="lastObservedPowerWatts" optional="YES" attributeType="Double" defaultValueString="0.0" usesScalarValueType="YES"/>

+        <attribute name="lastObservedVoltageVolts" optional="YES" attributeType="Double" usesScalarValueType="YES"/>

+        <attribute name="hasObservedChargeFlow" optional="YES" attributeType="Boolean" defaultValueString="NO" usesScalarValueType="YES"/>

+        <attribute name="targetBatteryPercent" optional="YES" attributeType="Double" usesScalarValueType="YES"/>

+        <attribute name="targetBatteryAlertTriggeredAt" optional="YES" attributeType="Date" usesScalarValueType="NO"/>

+        <attribute name="requiresCompletionConfirmation" optional="YES" attributeType="Boolean" defaultValueString="NO" usesScalarValueType="YES"/>

+        <attribute name="completionConfirmationRequestedAt" optional="YES" attributeType="Date" usesScalarValueType="NO"/>

+        <attribute name="completionContradictionPercent" optional="YES" attributeType="Double" usesScalarValueType="YES"/>

+        <attribute name="completionConfirmationCooldownUntil" optional="YES" attributeType="Date" usesScalarValueType="NO"/>

+        <attribute name="trimStart" optional="YES" attributeType="Date" usesScalarValueType="NO"/>

+        <attribute name="trimEnd" optional="YES" attributeType="Date" usesScalarValueType="NO"/>

+        <attribute name="createdAt" optional="YES" attributeType="Date" usesScalarValueType="NO"/>

+        <attribute name="updatedAt" optional="YES" attributeType="Date" usesScalarValueType="NO"/>

+    </entity>

+    <entity name="ChargeCheckpoint" representedClassName="ChargeCheckpoint" syncable="YES" codeGenerationType="class">

+        <attribute name="id" optional="YES" attributeType="String"/>

+        <attribute name="sessionID" optional="YES" attributeType="String"/>

+        <attribute name="chargedDeviceID" optional="YES" attributeType="String"/>

+        <attribute name="timestamp" optional="YES" attributeType="Date" usesScalarValueType="NO"/>

+        <attribute name="batteryPercent" optional="YES" attributeType="Double" defaultValueString="0.0" usesScalarValueType="YES"/>

+        <attribute name="measuredEnergyWh" optional="YES" attributeType="Double" defaultValueString="0.0" usesScalarValueType="YES"/>

+        <attribute name="measuredChargeAh" optional="YES" attributeType="Double" defaultValueString="0.0" usesScalarValueType="YES"/>

+        <attribute name="currentAmps" optional="YES" attributeType="Double" defaultValueString="0.0" usesScalarValueType="YES"/>

+        <attribute name="voltageVolts" optional="YES" attributeType="Double" usesScalarValueType="YES"/>

+        <attribute name="label" optional="YES" attributeType="String"/>

+        <attribute name="createdAt" optional="YES" attributeType="Date" usesScalarValueType="NO"/>

+    </entity>

+    <entity name="ChargeSessionSample" representedClassName="ChargeSessionSample" syncable="NO" codeGenerationType="class">

+        <attribute name="id" optional="YES" attributeType="String"/>

+        <attribute name="sessionID" optional="YES" attributeType="String"/>

+        <attribute name="chargedDeviceID" optional="YES" attributeType="String"/>

+        <attribute name="bucketIndex" optional="YES" attributeType="Integer 32" usesScalarValueType="YES"/>

+        <attribute name="timestamp" optional="YES" attributeType="Date" usesScalarValueType="NO"/>

+        <attribute name="averageCurrentAmps" optional="YES" attributeType="Double" defaultValueString="0.0" usesScalarValueType="YES"/>

+        <attribute name="averageVoltageVolts" optional="YES" attributeType="Double" usesScalarValueType="YES"/>

+        <attribute name="averagePowerWatts" optional="YES" attributeType="Double" defaultValueString="0.0" usesScalarValueType="YES"/>

+        <attribute name="measuredEnergyWh" optional="YES" attributeType="Double" defaultValueString="0.0" usesScalarValueType="YES"/>

+        <attribute name="measuredChargeAh" optional="YES" attributeType="Double" defaultValueString="0.0" usesScalarValueType="YES"/>

+        <attribute name="sampleCount" optional="YES" attributeType="Integer 16" usesScalarValueType="YES"/>

+        <attribute name="createdAt" optional="YES" attributeType="Date" usesScalarValueType="NO"/>

+        <attribute name="updatedAt" optional="YES" attributeType="Date" usesScalarValueType="NO"/>

+    </entity>

+    <elements>

+        <element name="ChargedDevice" positionX="-72" positionY="-36" width="128" height="433"/>

+        <element name="ChargeSession" positionX="136" positionY="-36" width="128" height="883"/>

+        <element name="ChargeCheckpoint" positionX="344" positionY="-36" width="128" height="208"/>

+        <element name="ChargeSessionSample" positionX="552" positionY="-36" width="128" height="253"/>

+    </elements>

+</model>

+    let trimStart: Date?

+    let trimEnd: Date?

+    var effectiveTrimStart: Date { trimStart ?? startedAt }

+    var effectiveTrimEnd: Date { trimEnd ?? (endedAt ?? lastObservedAt) }

+    var isTrimmed: Bool { trimStart != nil || trimEnd != nil }

+    var effectiveTimeRange: ClosedRange<Date> {

+        let start = effectiveTrimStart

+        let end = max(effectiveTrimEnd, start)

+        return start...end

+    }

+    var displayedAggregatedSamples: [ChargeSessionSampleSummary] {

+        guard isTrimmed else { return aggregatedSamples }

+        let range = effectiveTimeRange

+        return aggregatedSamples.filter { range.contains($0.timestamp) }

+    }

+

+        if isTrimmed {

+            return max(effectiveTrimEnd.timeIntervalSince(effectiveTrimStart), 0)

+        }

+        return meterObservedDuration ?? duration

+                    timestamp: session.effectiveTrimStart,

+        var deviceIDToRefresh: String?

+

+            didSave = true

+            deviceIDToRefresh = stringValue(session, key: "chargedDeviceID")

+        }

+

+        if let deviceID = deviceIDToRefresh {

+            context.perform { [weak self] in

+                guard let self else { return }

+                self.refreshDerivedMetrics(forChargedDeviceID: deviceID)

+                self.saveContext()

+

+//

+//  ChargingWindowDetector.swift

+//  USB Meter

+//

+

+import Foundation

+

+enum ChargingWindowDetector {

+

+    struct DetectedWindow {

+        let start: Date

+        let end: Date

+        // How much shorter the window is vs total session (0..1). Higher = more trimming needed.

+        let trimRatio: Double

+    }

+

+    // Power above this threshold counts as "charging activity" (Watts)

+    private static let activityThreshold = 0.05

+    // A charging segment must last at least this long to be considered real

+    private static let minimumSegmentDuration: TimeInterval = 3 * 60

+    // Gaps shorter than this between active segments are bridged (e.g. brief wireless drop)

+    private static let mergeGapDuration: TimeInterval = 120

+    // Padding added before first and after last sample of the detected window

+    private static let padding: TimeInterval = 30

+    // Only surface detection when active window is shorter than this fraction of total session

+    // e.g. 0.30 means: show banner if active charging < 70% of total session time

+    static let significantTrimThreshold = 0.30

+

+    static func detect(

+        samples: [ChargeSessionSampleSummary],

+        sessionStart: Date,

+        sessionEnd: Date

+    ) -> DetectedWindow? {

+        guard !samples.isEmpty else { return nil }

+        let sorted = samples.sorted { $0.timestamp < $1.timestamp }

+

+        // Build contiguous active segments

+        struct Segment { var start: Date; var end: Date }

+        var segments: [Segment] = []

+        var segStart: Date?

+        var segEnd: Date?

+

+        for sample in sorted {

+            if sample.averagePowerWatts >= activityThreshold {

+                if segStart == nil { segStart = sample.timestamp }

+                segEnd = sample.timestamp

+            } else {

+                if let s = segStart, let e = segEnd {

+                    segments.append(Segment(start: s, end: e))

+                }

+                segStart = nil

+                segEnd = nil

+            }

+        }

+        if let s = segStart, let e = segEnd {

+            segments.append(Segment(start: s, end: e))

+        }

+

+        guard !segments.isEmpty else { return nil }

+

+        // Merge segments separated by short gaps

+        var merged: [Segment] = [segments[0]]

+        for seg in segments.dropFirst() {

+            let gap = seg.start.timeIntervalSince(merged[merged.count - 1].end)

+            if gap <= mergeGapDuration {

+                merged[merged.count - 1].end = seg.end

+            } else {

+                merged.append(seg)

+            }

+        }

+

+        // Filter out short segments

+        let significant = merged.filter {

+            $0.end.timeIntervalSince($0.start) >= minimumSegmentDuration

+        }

+

+        guard !significant.isEmpty else { return nil }

+

+        // Pick primary segment: the longest one

+        let primary = significant.max { a, b in

+            a.end.timeIntervalSince(a.start) < b.end.timeIntervalSince(b.start)

+        }!

+

+        let windowStart = max(sessionStart, primary.start.addingTimeInterval(-padding))

+        let windowEnd   = min(sessionEnd,   primary.end.addingTimeInterval(padding))

+

+        let sessionDuration = sessionEnd.timeIntervalSince(sessionStart)

+        let windowDuration  = windowEnd.timeIntervalSince(windowStart)

+        guard sessionDuration > 0 else { return nil }

+

+        let trimRatio = 1.0 - (windowDuration / sessionDuration)

+        return DetectedWindow(start: windowStart, end: windowEnd, trimRatio: trimRatio)

+    }

+}

+        from session: ChargeSessionSummary,

+        replacingLiveBufferIfNeeded: Bool = false

+        let hasExistingBuffer =

+            power.points.isEmpty == false ||

+            voltage.points.isEmpty == false ||

+            current.points.isEmpty == false ||

+            temperature.points.isEmpty == false ||

+            energy.points.isEmpty == false ||

+            rssi.points.isEmpty == false

+

+        guard hasExistingBuffer == false || replacingLiveBufferIfNeeded else {

+        let preservedEnergyCounterValue = lastEnergyCounterValue

+        let preservedEnergyGroupID = lastEnergyGroupID

+        let persistedRangeUpperBound = sortedSamples.last?.timestamp

+        if hasExistingBuffer {

+            flushPendingValues()

+        }

+

+        power.replacePoints(mergedRestoredPoints(

+            restored: restoredPoints(from: sortedSamples) { sample in

+                sample.averagePowerWatts

+            },

+            existing: power.points,

+            persistedRangeUpperBound: persistedRangeUpperBound

+        ))

+        current.replacePoints(mergedRestoredPoints(

+            restored: restoredPoints(from: sortedSamples) { sample in

+                sample.averageCurrentAmps

+            },

+            existing: current.points,

+            persistedRangeUpperBound: persistedRangeUpperBound

+        ))

+        voltage.replacePoints(mergedRestoredPoints(

+            restored: restoredPoints(from: sortedSamples) { sample in

+                sample.averageVoltageVolts

+            },

+            existing: voltage.points,

+            persistedRangeUpperBound: persistedRangeUpperBound

+        ))

+        energy.replacePoints(mergedRestoredPoints(

+            restored: restoredPoints(from: sortedSamples) { sample in

+                sample.measuredEnergyWh

+            },

+            existing: energy.points,

+            persistedRangeUpperBound: persistedRangeUpperBound

+        ))

+        temperature.replacePoints(

+            preservedTailPoints(

+                from: temperature.points,

+                after: persistedRangeUpperBound

+            )

+        )

+        rssi.replacePoints(

+            preservedTailPoints(

+                from: rssi.points,

+                after: persistedRangeUpperBound

+            )

+        )

+        lastEnergyCounterValue = hasExistingBuffer ? preservedEnergyCounterValue : nil

+        lastEnergyGroupID = hasExistingBuffer ? preservedEnergyGroupID : nil

+    private func mergedRestoredPoints(

+        restored: [Measurement.Point],

+        existing: [Measurement.Point],

+        persistedRangeUpperBound: Date?

+    ) -> [Measurement.Point] {

+        var merged = restored

+        let preservedTail = preservedTailPoints(from: existing, after: persistedRangeUpperBound)

+

+        guard preservedTail.isEmpty == false else {

+            return merged

+        }

+

+        if let tailFirst = preservedTail.first,

+           tailFirst.isSample,

+           let lastRestoredSample = merged.last(where: \.isSample),

+           lastRestoredSample.timestamp < tailFirst.timestamp {

+            merged.append(

+                Measurement.Point(

+                    id: merged.count,

+                    timestamp: tailFirst.timestamp,

+                    value: merged.last?.value ?? tailFirst.value,

+                    kind: .discontinuity

+                )

+            )

+        }

+

+        merged.append(contentsOf: preservedTail.enumerated().map { offset, point in

+            Measurement.Point(

+                id: merged.count + offset,

+                timestamp: point.timestamp,

+                value: point.value,

+                kind: point.kind

+            )

+        })

+        return merged

+    }

+

+    private func preservedTailPoints(

+        from existing: [Measurement.Point],

+        after persistedRangeUpperBound: Date?

+    ) -> [Measurement.Point] {

+        guard let persistedRangeUpperBound else {

+            return existing

+        }

+

+        let tail = existing.filter { $0.timestamp > persistedRangeUpperBound }

+        guard tail.isEmpty == false else {

+            return []

+        }

+

+        if let firstSampleIndex = tail.firstIndex(where: \.isSample) {

+            return Array(tail[firstSampleIndex...])

+        }

+

+        return []

+    }

+

+        let displayedSamples = session.displayedAggregatedSamples

+            from: displayedSamples,

+            from: displayedSamples,

+                    Text(session.isTrimmed

+                         ? "Showing the saved trim window at aggregated resolution."

+                         : (session.status.isOpen

+                            ? "Open session, persisted as aggregated samples."

+                            : "Most recent persisted session at aggregated resolution."))

+                Text("\(displayedSamples.count) points")

+        if session.isTrimmed {

+            components.append("Trimmed")

+        }

+enum MeasurementChartSelectorActionTone {

+    case reversible

+    case destructive

+    case destructiveProminent

+}

+

+struct MeasurementChartSelectionAction {

+    let title: String

+    let systemName: String

+    let tone: MeasurementChartSelectorActionTone

+    let handler: (ClosedRange<Date>) -> Void

+}

+

+struct MeasurementChartResetAction {

+    let title: String

+    let systemName: String

+    let tone: MeasurementChartSelectorActionTone

+    let confirmationTitle: String

+    let confirmationButtonTitle: String

+    let handler: () -> Void

+}

+

+struct MeasurementChartRangeSelectorConfiguration {

+    let keepAction: MeasurementChartSelectionAction

+    let removeAction: MeasurementChartSelectionAction?

+    let resetAction: MeasurementChartResetAction

+}

+

+    let extendsTimelineToPresent: Bool

+    let rangeSelectorConfiguration: MeasurementChartRangeSelectorConfiguration?

+    let timeRangeLowerBound: Date?

+    let timeRangeUpperBound: Date?

+        timeRangeLowerBound: Date? = nil,

+        timeRangeUpperBound: Date? = nil,

+        rebasesEnergyToVisibleRangeStart: Bool = false,

+        extendsTimelineToPresent: Bool = true,

+        rangeSelectorConfiguration: MeasurementChartRangeSelectorConfiguration? = nil

+        self.timeRangeLowerBound = timeRangeLowerBound

+        self.timeRangeUpperBound = timeRangeUpperBound

+        self.extendsTimelineToPresent = extendsTimelineToPresent

+        self.rangeSelectorConfiguration = rangeSelectorConfiguration

+                                    configuration: resolvedRangeSelectorConfiguration(),

+            guard extendsTimelineToPresent, timeRange == nil, timeRangeUpperBound == nil else { return }

+    private func resolvedRangeSelectorConfiguration() -> MeasurementChartRangeSelectorConfiguration {

+        if let rangeSelectorConfiguration {

+            return rangeSelectorConfiguration

+        }

+

+        return MeasurementChartRangeSelectorConfiguration(

+            keepAction: MeasurementChartSelectionAction(

+                title: compactLayout ? "Keep" : "Keep Selection",

+                systemName: "scissors",

+                tone: .destructive,

+                handler: trimBufferToSelection

+            ),

+            removeAction: MeasurementChartSelectionAction(

+                title: compactLayout ? "Cut" : "Remove Selection",

+                systemName: "minus.circle",

+                tone: .destructive,

+                handler: removeSelectionFromBuffer

+            ),

+            resetAction: MeasurementChartResetAction(

+                title: compactLayout ? "Reset" : "Reset Buffer",

+                systemName: "trash",

+                tone: .destructiveProminent,

+                confirmationTitle: "Reset captured measurements?",

+                confirmationButtonTitle: "Reset buffer",

+                handler: resetBuffer

+            )

+        )

+    }

+

+        let lowerBound = timeRangeLowerBound ?? samplePoints.first?.timestamp

+        guard let lowerBound else {

+        let latestSampleTimestamp = samplePoints.last?.timestamp

+        let resolvedUpperBound = timeRangeUpperBound ?? {

+            guard extendsTimelineToPresent else {

+                return latestSampleTimestamp ?? lowerBound

+            }

+            return max(latestSampleTimestamp ?? chartNow, chartNow)

+        }()

+        let upperBound = max(resolvedUpperBound, lowerBound)

+    let configuration: MeasurementChartRangeSelectorConfiguration

+                        title: configuration.keepAction.title,

+                        systemName: configuration.keepAction.systemName,

+                        tone: configuration.keepAction.tone,

+                            configuration.keepAction.handler(currentRange)

+                            resetSelectionState()

+                    if let removeAction = configuration.removeAction {

+                        actionButton(

+                            title: removeAction.title,

+                            systemName: removeAction.systemName,

+                            tone: removeAction.tone,

+                            action: {

+                                removeAction.handler(currentRange)

+                                resetSelectionState()

+                            }

+                        )

+                    }

+                    title: configuration.resetAction.title,

+                    systemName: configuration.resetAction.systemName,

+                    tone: configuration.resetAction.tone,

+            .confirmationDialog(configuration.resetAction.confirmationTitle, isPresented: $showResetConfirmation, titleVisibility: .visible) {

+                Button(configuration.resetAction.confirmationButtonTitle, role: .destructive) {

+                    configuration.resetAction.handler()

+                    resetSelectionState()

+        tone: MeasurementChartSelectorActionTone,

+    private func toneColor(for tone: MeasurementChartSelectorActionTone) -> Color {

+    private func actionButtonBackground(for tone: MeasurementChartSelectorActionTone) -> Color {

+    private func actionButtonBorder(for tone: MeasurementChartSelectorActionTone) -> Color {

+    private func resetSelectionState() {

+        selectedTimeRange = nil

+        isPinnedToPresent = false

+    }

+

+//

+//  SessionTrimEditorView.swift

+//  USB Meter

+//

+

+import SwiftUI

+

+struct SessionTrimEditorView: View {

+

+    let session: ChargeSessionSummary

+    let liveTimeRange: ClosedRange<Date>?

+    let onApply: (Date?, Date?) -> Void

+    let onDismiss: () -> Void

+

+    @State private var trimStart: Date

+    @State private var trimEnd: Date

+

+    private var fullStart: Date { liveTimeRange?.lowerBound ?? session.startedAt }

+    private var fullEnd: Date   { liveTimeRange?.upperBound ?? (session.endedAt ?? session.lastObservedAt) }

+    private var sessionDuration: TimeInterval { max(fullEnd.timeIntervalSince(fullStart), 1) }

+

+    private var startFraction: Double {

+        trimStart.timeIntervalSince(fullStart) / sessionDuration

+    }

+    private var endFraction: Double {

+        trimEnd.timeIntervalSince(fullStart) / sessionDuration

+    }

+

+    // Energy preview from cumulative sample values

+    private var previewEnergyWh: Double {

+        let sorted = session.aggregatedSamples.sorted { $0.timestamp < $1.timestamp }

+        let baseline = sorted.last { $0.timestamp <= trimStart }

+        guard let endSample = sorted.last(where: { $0.timestamp <= trimEnd }) else { return 0 }

+        return max(endSample.measuredEnergyWh - (baseline?.measuredEnergyWh ?? 0), 0)

+    }

+

+    private var trimmedDuration: TimeInterval {

+        max(trimEnd.timeIntervalSince(trimStart), 0)

+    }

+

+    private var checkpointsToRemove: [ChargeCheckpointSummary] {

+        session.checkpoints.filter { $0.timestamp < trimStart || $0.timestamp > trimEnd }

+    }

+

+    private var isModified: Bool {

+        trimStart != (session.trimStart ?? fullStart) ||

+        trimEnd   != (session.trimEnd   ?? fullEnd)

+    }

+

+    init(

+        session: ChargeSessionSummary,

+        detectedWindow: ChargingWindowDetector.DetectedWindow? = nil,

+        liveTimeRange: ClosedRange<Date>? = nil,

+        onApply: @escaping (Date?, Date?) -> Void,

+        onDismiss: @escaping () -> Void

+    ) {

+        self.session   = session

+        self.liveTimeRange = liveTimeRange

+        self.onApply   = onApply

+        self.onDismiss = onDismiss

+

+        let fullStart = liveTimeRange?.lowerBound ?? session.startedAt

+        let fullEnd = liveTimeRange?.upperBound ?? (session.endedAt ?? session.lastObservedAt)

+        let start = session.trimStart

+            ?? detectedWindow?.start

+            ?? fullStart

+        let end = session.trimEnd

+            ?? detectedWindow?.end

+            ?? fullEnd

+

+        _trimStart = State(initialValue: start)

+        _trimEnd   = State(initialValue: end)

+    }

+

+    var body: some View {

+        VStack(spacing: 0) {

+            header

+            ScrollView {

+                VStack(spacing: 16) {

+                    chartWithHandles

+                    rangeControls

+                    previewMetrics

+                    if !checkpointsToRemove.isEmpty {

+                        checkpointWarning

+                    }

+                }

+                .padding(16)

+            }

+            applyBar

+        }

+        .background(Color(.systemGroupedBackground).ignoresSafeArea())

+    }

+

+    // MARK: - Header

+

+    private var header: some View {

+        HStack {

+            Button("Cancel", action: onDismiss)

+                .foregroundColor(.secondary)

+            Spacer()

+            Text("Trim Session")

+                .font(.headline)

+            Spacer()

+            Button("Reset") {

+                withAnimation(.spring(response: 0.3)) {

+                    trimStart = fullStart

+                    trimEnd   = fullEnd

+                }

+            }

+            .foregroundColor(.orange)

+            .disabled(trimStart == fullStart && trimEnd == fullEnd)

+        }

+        .padding(.horizontal, 18)

+        .padding(.vertical, 14)

+        .background(.regularMaterial)

+    }

+

+    // MARK: - Chart with trim overlay

+

+    private var chartWithHandles: some View {

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

+            HStack(spacing: 6) {

+                Image(systemName: "scissors")

+                    .foregroundColor(.blue)

+                Text("Session Window")

+                    .font(.headline)

+            }

+

+            GeometryReader { geo in

+                let chartW = geo.size.width

+                ZStack(alignment: .topLeading) {

+                    // Background chart — full session

+                    MeasurementChartView(

+                        compactLayout: true,

+                        availableSize: geo.size,

+                        timeRange: fullStart...fullEnd,

+                        showsRangeSelector: false,

+                        rebasesEnergyToVisibleRangeStart: false

+                    )

+

+                    // Dimmed region before trimStart

+                    Rectangle()

+                        .fill(Color.black.opacity(0.35))

+                        .frame(width: max(startFraction * chartW, 0))

+                        .allowsHitTesting(false)

+

+                    // Dimmed region after trimEnd

+                    let endX = endFraction * chartW

+                    Rectangle()

+                        .fill(Color.black.opacity(0.35))

+                        .frame(width: max(chartW - endX, 0))

+                        .offset(x: endX)

+                        .allowsHitTesting(false)

+

+                    // Start handle

+                    trimHandle(

+                        color: .green,

+                        symbol: "arrow.right.to.line",

+                        xFraction: startFraction,

+                        chartWidth: chartW,

+                        onDrag: { dx in

+                            let newFrac = max(0, min(startFraction + dx / chartW, endFraction - 0.01))

+                            trimStart = fullStart.addingTimeInterval(newFrac * sessionDuration)

+                        }

+                    )

+

+                    // End handle

+                    trimHandle(

+                        color: .red,

+                        symbol: "arrow.left.to.line",

+                        xFraction: endFraction,

+                        chartWidth: chartW,

+                        onDrag: { dx in

+                            let newFrac = min(1, max(endFraction + dx / chartW, startFraction + 0.01))

+                            trimEnd = fullStart.addingTimeInterval(newFrac * sessionDuration)

+                        }

+                    )

+                }

+                .clipped()

+            }

+            .frame(height: 260)

+        }

+        .padding(16)

+        .background(RoundedRectangle(cornerRadius: 14).fill(Color(.secondarySystemGroupedBackground)))

+    }

+

+    @ViewBuilder

+    private func trimHandle(

+        color: Color,

+        symbol: String,

+        xFraction: Double,

+        chartWidth: CGFloat,

+        onDrag: @escaping (CGFloat) -> Void

+    ) -> some View {

+        let xPos = CGFloat(xFraction) * chartWidth

+

+        ZStack(alignment: .top) {

+            // Vertical line

+            Rectangle()

+                .fill(color)

+                .frame(width: 2)

+                .frame(maxHeight: .infinity)

+                .offset(x: xPos - 1)

+                .allowsHitTesting(false)

+

+            // Drag knob

+            Circle()

+                .fill(color)

+                .frame(width: 28, height: 28)

+                .overlay(

+                    Image(systemName: symbol)

+                        .font(.system(size: 11, weight: .bold))

+                        .foregroundColor(.white)

+                )

+                .shadow(radius: 3)

+                .offset(x: xPos - 14)

+                .gesture(

+                    DragGesture(minimumDistance: 0, coordinateSpace: .local)

+                        .onChanged { value in

+                            onDrag(value.translation.width)

+                        }

+                )

+        }

+    }

+

+    // MARK: - Range controls

+

+    private var rangeControls: some View {

+        VStack(spacing: 12) {

+            rangeRow(

+                label: "Start",

+                color: .green,

+                symbol: "arrow.right.to.line",

+                date: $trimStart,

+                sliderValue: Binding(

+                    get: { startFraction },

+                    set: { v in

+                        let clamped = max(0, min(v, endFraction - 0.01))

+                        trimStart = fullStart.addingTimeInterval(clamped * sessionDuration)

+                    }

+                )

+            )

+            rangeRow(

+                label: "End",

+                color: .red,

+                symbol: "arrow.left.to.line",

+                date: $trimEnd,

+                sliderValue: Binding(

+                    get: { endFraction },

+                    set: { v in

+                        let clamped = min(1, max(v, startFraction + 0.01))

+                        trimEnd = fullStart.addingTimeInterval(clamped * sessionDuration)

+                    }

+                )

+            )

+        }

+        .padding(16)

+        .background(RoundedRectangle(cornerRadius: 14).fill(Color(.secondarySystemGroupedBackground)))

+    }

+

+    private func rangeRow(

+        label: String,

+        color: Color,

+        symbol: String,

+        date: Binding<Date>,

+        sliderValue: Binding<Double>

+    ) -> some View {

+        VStack(spacing: 6) {

+            HStack {

+                Image(systemName: symbol)

+                    .foregroundColor(color)

+                    .frame(width: 20)

+                Text(label)

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

+                Spacer()

+                Text(date.wrappedValue.format())

+                    .font(.caption.monospacedDigit())

+                    .foregroundColor(.secondary)

+            }

+            Slider(value: sliderValue, in: 0...1)

+                .tint(color)

+        }

+    }

+

+    // MARK: - Preview metrics

+

+    private var previewMetrics: some View {

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

+            HStack(spacing: 6) {

+                Image(systemName: "waveform.path.ecg")

+                    .foregroundColor(.teal)

+                Text("Trimmed Metrics")

+                    .font(.headline)

+            }

+

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

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

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

+                previewCell(label: "Duration", value: formatDuration(trimmedDuration), tint: .teal)

+            }

+        }

+        .padding(16)

+        .background(RoundedRectangle(cornerRadius: 14).fill(Color(.secondarySystemGroupedBackground)))

+    }

+

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

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

+            Text(label)

+                .font(.caption)

+                .foregroundColor(.secondary)

+            Text(value)

+                .font(.system(.subheadline, design: .rounded).weight(.semibold))

+                .foregroundColor(tint)

+                .monospacedDigit()

+        }

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

+        .padding(10)

+        .background(RoundedRectangle(cornerRadius: 10).fill(tint.opacity(0.10)))

+    }

+

+    // MARK: - Checkpoint warning

+

+    private var checkpointWarning: some View {

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

+            Image(systemName: "exclamationmark.triangle.fill")

+                .foregroundColor(.orange)

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

+                Text("\(checkpointsToRemove.count) checkpoint\(checkpointsToRemove.count == 1 ? "" : "s") outside the selected window will be removed.")

+                    .font(.subheadline)

+                ForEach(checkpointsToRemove) { cp in

+                    Text("• \(cp.timestamp.format()) — \(cp.batteryPercent.format(decimalDigits: 0))%")

+                        .font(.caption)

+                        .foregroundColor(.secondary)

+                }

+            }

+        }

+        .padding(14)

+        .background(

+            RoundedRectangle(cornerRadius: 12)

+                .fill(Color.orange.opacity(0.12))

+                .overlay(RoundedRectangle(cornerRadius: 12).stroke(Color.orange.opacity(0.25), lineWidth: 1))

+        )

+    }

+

+    // MARK: - Apply bar

+

+    private var applyBar: some View {

+        VStack(spacing: 0) {

+            Divider()

+            Button {

+                let newStart = trimStart == fullStart ? nil : trimStart

+                let newEnd   = trimEnd   == fullEnd   ? nil : trimEnd

+                onApply(newStart, newEnd)

+            } label: {

+                Label("Apply Trim", systemImage: "scissors")

+                    .font(.body.weight(.semibold))

+                    .frame(maxWidth: .infinity)

+                    .padding(.vertical, 14)

+            }

+            .buttonStyle(.borderedProminent)

+            .tint(.blue)

+            .disabled(!isModified)