+		D28F11013C8E4A7A00A10011 /* MeterHomeTabView.swift in Sources */ = {isa = PBXBuildFile; fileRef = D28F11023C8E4A7A00A10012 /* MeterHomeTabView.swift */; };

+		D28F11033C8E4A7A00A10013 /* MeterLiveTabView.swift in Sources */ = {isa = PBXBuildFile; fileRef = D28F11043C8E4A7A00A10014 /* MeterLiveTabView.swift */; };

+		D28F11053C8E4A7A00A10015 /* MeterChartTabView.swift in Sources */ = {isa = PBXBuildFile; fileRef = D28F11063C8E4A7A00A10016 /* MeterChartTabView.swift */; };

+		D28F11073C8E4A7A00A10017 /* MeterSettingsTabView.swift in Sources */ = {isa = PBXBuildFile; fileRef = D28F11083C8E4A7A00A10018 /* MeterSettingsTabView.swift */; };

+		D28F11113C8E4A7A00A10021 /* MeterInfoCardView.swift in Sources */ = {isa = PBXBuildFile; fileRef = D28F11123C8E4A7A00A10022 /* MeterInfoCardView.swift */; };

+		D28F11133C8E4A7A00A10023 /* MeterInfoRowView.swift in Sources */ = {isa = PBXBuildFile; fileRef = D28F11143C8E4A7A00A10024 /* MeterInfoRowView.swift */; };

+		D28F11153C8E4A7A00A10025 /* MeterNameEditorView.swift in Sources */ = {isa = PBXBuildFile; fileRef = D28F11163C8E4A7A00A10026 /* MeterNameEditorView.swift */; };

+		D28F11173C8E4A7A00A10027 /* ScreenTimeoutEditorView.swift in Sources */ = {isa = PBXBuildFile; fileRef = D28F11183C8E4A7A00A10028 /* ScreenTimeoutEditorView.swift */; };

+		D28F11193C8E4A7A00A10029 /* ScreenBrightnessEditorView.swift in Sources */ = {isa = PBXBuildFile; fileRef = D28F111A3C8E4A7A00A1002A /* ScreenBrightnessEditorView.swift */; };

+		D28F11213C8E4A7A00A10031 /* MeterLiveMetricRange.swift in Sources */ = {isa = PBXBuildFile; fileRef = D28F11223C8E4A7A00A10032 /* MeterLiveMetricRange.swift */; };

+		D28F11233C8E4A7A00A10033 /* LoadResistanceIconView.swift in Sources */ = {isa = PBXBuildFile; fileRef = D28F11243C8E4A7A00A10034 /* LoadResistanceIconView.swift */; };

+		D28F11313C8E4A7A00A10041 /* MeterScreenControlButtonView.swift in Sources */ = {isa = PBXBuildFile; fileRef = D28F11323C8E4A7A00A10042 /* MeterScreenControlButtonView.swift */; };

+		D28F11333C8E4A7A00A10043 /* MeterCurrentScreenSummaryView.swift in Sources */ = {isa = PBXBuildFile; fileRef = D28F11343C8E4A7A00A10044 /* MeterCurrentScreenSummaryView.swift */; };

+		D28F11353C8E4A7A00A10045 /* ChargeRecordMetricsTableView.swift in Sources */ = {isa = PBXBuildFile; fileRef = D28F11363C8E4A7A00A10046 /* ChargeRecordMetricsTableView.swift */; };

+		D28F11393C8E4A7A00A10049 /* MeterConnectionStatusBadgeView.swift in Sources */ = {isa = PBXBuildFile; fileRef = D28F113A3C8E4A7A00A1004A /* MeterConnectionStatusBadgeView.swift */; };

+		D28F113B3C8E4A7A00A1004B /* MeterConnectionActionView.swift in Sources */ = {isa = PBXBuildFile; fileRef = D28F113C3C8E4A7A00A1004C /* MeterConnectionActionView.swift */; };

+		D28F113D3C8E4A7A00A1004D /* MeterOverviewSectionView.swift in Sources */ = {isa = PBXBuildFile; fileRef = D28F113E3C8E4A7A00A1004E /* MeterOverviewSectionView.swift */; };

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+		437D47CF2415F8CF00B7768E /* Meter */ = {

+				4383B469240FE4A600DAAEBF /* MeterView.swift */,

+				D28F113F3C8E4A7A00A1004F /* Components */,

+				D28F11093C8E4A7A00A10019 /* Tabs */,

+				D28F10013C8E4A7A00A10001 /* Sheets */,

+			path = Meter;

+		4383B463240EB66400DAAEBF /* Templates */ = {

+				4383B464240EB6B200DAAEBF /* UserDefault.swift */,

+			path = Templates;

+		4383B466240F842700DAAEBF /* DataTypes */ = {

+				4383B467240F845500DAAEBF /* MacAdress.swift */,

+			path = DataTypes;

+		43CBF653240BF3EB00255B8B = {

+				1C6B6B952A2D4F5100A0B001 /* Documentation */,

+				43CBF65E240BF3EB00255B8B /* USB Meter */,

+				43CBF65D240BF3EB00255B8B /* Products */,

+				4347F01B28D717C1007EE7B1 /* Frameworks */,

+		43CBF65D240BF3EB00255B8B /* Products */ = {

+				43CBF65C240BF3EB00255B8B /* USB Meter.app */,

+			name = Products;

+		43CBF65E240BF3EB00255B8B /* USB Meter */ = {

+				43CBF67A240C0D8A00255B8B /* USB Meter.entitlements */,

+				43CBF65F240BF3EB00255B8B /* AppDelegate.swift */,

+				43CBF661240BF3EB00255B8B /* SceneDelegate.swift */,

+				43CBF678240C047D00255B8B /* Model */,

+				43CBF679240C08C600255B8B /* Views */,

+				43CBF67F240D14AC00255B8B /* Extensions */,

+				4383B463240EB66400DAAEBF /* Templates */,

+				4383B466240F842700DAAEBF /* DataTypes */,

+				43CBF668240BF3ED00255B8B /* Assets.xcassets */,

+				43CBF66D240BF3ED00255B8B /* LaunchScreen.storyboard */,

+				43CBF670240BF3ED00255B8B /* Info.plist */,

+				43CBF66A240BF3ED00255B8B /* Preview Content */,

+			path = "USB Meter";

+		43CBF66A240BF3ED00255B8B /* Preview Content */ = {

+				43CBF66B240BF3ED00255B8B /* Preview Assets.xcassets */,

+			path = "Preview Content";

+		43CBF678240C047D00255B8B /* Model */ = {

+				4383B461240EB5E400DAAEBF /* AppData.swift */,

+				7396C8BB36F4E7F8E0CD8FF8 /* MeterNameStore.swift */,

+				43CBF676240C043E00255B8B /* BluetoothManager.swift */,

+				4383B45F240EB2D000DAAEBF /* Meter.swift */,

+				43ED78AD2420A0BE00974487 /* BluetoothSerial.swift */,

+				439D996424234B98008DE3AA /* BluetoothRadio.swift */,

+				4386958E2F6A4E3E008855A9 /* MeterCapabilities.swift */,

+				4386958A2F6A1001008855A9 /* UMProtocol.swift */,

+				4386958C2F6A1002008855A9 /* TC66Protocol.swift */,

+				438695882463F062008855A9 /* Measurements.swift */,

+				432EA6432445A559006FC905 /* ChartContext.swift */,

+			path = Model;

+		43CBF679240C08C600255B8B /* Views */ = {

+				43CBF666240BF3EB00255B8B /* ContentView.swift */,

+				AAD5F9BB2B1CC10000F8E4F9 /* Sidebar */,

+				56BA4CE53B6B2C4EBA42C81A /* MeterMappingDebugView.swift */,

+				4327461A24619CED0009BE4B /* MeterRowView.swift */,

+				437D47CF2415F8CF00B7768E /* Meter */,

+				D28F10023C8E4A7A00A10002 /* Components */,

+				4311E639241384960080EA59 /* DeviceHelpView.swift */,

+				AAD5F9A32B1CAC0700F8E4F9 /* MeterDetailView.swift */,

+			path = Views;

+		43CBF67F240D14AC00255B8B /* Extensions */ = {

+				43CBF680240D153000255B8B /* CBManagerState.swift */,

+				4351E7BA24685ACD00E798A3 /* CGPoint.swift */,

+				43874C7E2414F3F400525397 /* Float.swift */,

+				43F7792A2465AE1600745DF4 /* UIView.swift */,

+				43874C842415611200525397 /* Double.swift */,

+				43874C82241533AD00525397 /* Data.swift */,

+				437D47D22415FB7E00B7768E /* Decimal.swift */,

+				43554B3324444B0E004E66F5 /* Date.swift */,

+				438B9554246D2D7500E61AE7 /* Path.swift */,

+			path = Extensions;

+		AAD5F9BB2B1CC10000F8E4F9 /* Sidebar */ = {

+				AAD5F9B22B1CAC7A00F8E4F9 /* SidebarView.swift */,

+				43BE08E12F78F49500250EEC /* SidebarList */,

+			path = Sidebar;

+		D28F10013C8E4A7A00A10001 /* Sheets */ = {

+				4308CF89241777130002E80B /* DataGroups */,

+				43554B3024444983004E66F5 /* MeasurementSeries */,

+				D28F11273C8E4A7A00A10037 /* ChargeRecord */,

+			path = Sheets;

+		D28F10023C8E4A7A00A10002 /* Components */ = {

+				D28F10033C8E4A7A00A10003 /* Generic */,

+			path = Components;

+		D28F11093C8E4A7A00A10019 /* Tabs */ = {

+				D28F110A3C8E4A7A00A1001A /* Home */,

+				D28F110B3C8E4A7A00A1001B /* Live */,

+				D28F110C3C8E4A7A00A1001C /* Chart */,

+				D28F110D3C8E4A7A00A1001D /* Settings */,

+			path = Tabs;

+		D28F110A3C8E4A7A00A1001A /* Home */ = {

+				D28F11023C8E4A7A00A10012 /* MeterHomeTabView.swift */,

+				D28F111B3C8E4A7A00A1002B /* Subviews */,

+			path = Home;

+		D28F110B3C8E4A7A00A1001B /* Live */ = {

+				D28F11043C8E4A7A00A10014 /* MeterLiveTabView.swift */,

+				D28F11253C8E4A7A00A10035 /* Subviews */,

+			path = Live;

+		D28F110C3C8E4A7A00A1001C /* Chart */ = {

+				D28F11063C8E4A7A00A10016 /* MeterChartTabView.swift */,

+			path = Chart;

+		D28F110D3C8E4A7A00A1001D /* Settings */ = {

+				D28F11083C8E4A7A00A10018 /* MeterSettingsTabView.swift */,

+				D28F111C3C8E4A7A00A1002C /* Subviews */,

+			path = Settings;

+		D28F111B3C8E4A7A00A1002B /* Subviews */ = {

+				D28F113A3C8E4A7A00A1004A /* MeterConnectionStatusBadgeView.swift */,

+				D28F113C3C8E4A7A00A1004C /* MeterConnectionActionView.swift */,

+				D28F113E3C8E4A7A00A1004E /* MeterOverviewSectionView.swift */,

+			path = Subviews;

+		D28F111C3C8E4A7A00A1002C /* Subviews */ = {

+				D28F11163C8E4A7A00A10026 /* MeterNameEditorView.swift */,

+				D28F11183C8E4A7A00A10028 /* ScreenTimeoutEditorView.swift */,

+				D28F111A3C8E4A7A00A1002A /* ScreenBrightnessEditorView.swift */,

+				437D47D62415FDF300B7768E /* MeterScreenControlsView.swift */,

+				D28F11323C8E4A7A00A10042 /* MeterScreenControlButtonView.swift */,

+				D28F11343C8E4A7A00A10044 /* MeterCurrentScreenSummaryView.swift */,

+			path = Subviews;

+		D28F11253C8E4A7A00A10035 /* Subviews */ = {

+				437D47D02415F91B00B7768E /* MeterLiveContentView.swift */,

+				D28F11223C8E4A7A00A10032 /* MeterLiveMetricRange.swift */,

+				D28F11243C8E4A7A00A10034 /* LoadResistanceIconView.swift */,

+			path = Subviews;

+		D28F11263C8E4A7A00A10036 /* Subviews */ = {

+				4308CF8524176CAB0002E80B /* DataGroupRowView.swift */,

+			path = Subviews;

+		D28F11273C8E4A7A00A10037 /* ChargeRecord */ = {

+				437D47D42415FD8C00B7768E /* ChargeRecordSheetView.swift */,

+				D28F11383C8E4A7A00A10048 /* Subviews */,

+			path = ChargeRecord;

+		D28F11383C8E4A7A00A10048 /* Subviews */ = {

+				D28F11363C8E4A7A00A10046 /* ChargeRecordMetricsTableView.swift */,

+			path = Subviews;

+		D28F113F3C8E4A7A00A1004F /* Components */ = {

+				D28F11123C8E4A7A00A10022 /* MeterInfoCardView.swift */,

+				D28F11143C8E4A7A00A10024 /* MeterInfoRowView.swift */,

+				437F0AB62463108F005DEBEC /* MeasurementChartView.swift */,

+			path = Components;

+				SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";

+				SUPPORTS_MAC_DESIGNED_FOR_IPHONE_IPAD = NO;

+				SUPPORTS_XR_DESIGNED_FOR_IPHONE_IPAD = NO;

+				SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";

+				SUPPORTS_MAC_DESIGNED_FOR_IPHONE_IPAD = NO;

+				SUPPORTS_XR_DESIGNED_FOR_IPHONE_IPAD = NO;

+private enum PresentTrackingMode: CaseIterable, Hashable {

+    case keepDuration

+    case keepStartTimestamp

+}

+

+    @State private var selectedVisibleTimeRange: ClosedRange<Date>?

+    @State private var isPinnedToPresent: Bool = false

+    @State private var presentTrackingMode: PresentTrackingMode = .keepDuration

+        let availableTimeRange = availableSelectionTimeRange()

+        let visibleTimeRange = resolvedVisibleTimeRange(within: availableTimeRange)

+        let powerSeries = series(

+            for: measurements.power,

+            kind: .power,

+            minimumYSpan: minimumPowerSpan,

+            visibleTimeRange: visibleTimeRange

+        )

+        let voltageSeries = series(

+            for: measurements.voltage,

+            kind: .voltage,

+            minimumYSpan: minimumVoltageSpan,

+            visibleTimeRange: visibleTimeRange

+        )

+        let currentSeries = series(

+            for: measurements.current,

+            kind: .current,

+            minimumYSpan: minimumCurrentSpan,

+            visibleTimeRange: visibleTimeRange

+        )

+        let temperatureSeries = series(

+            for: measurements.temperature,

+            kind: .temperature,

+            minimumYSpan: minimumTemperatureSpan,

+            visibleTimeRange: visibleTimeRange

+        )

+        let selectorSeries = primarySeries.map { overviewSeries(for: $0.kind) }

+

+                            if let availableTimeRange,

+                               let selectorSeries,

+                               shouldShowRangeSelector(

+                                availableTimeRange: availableTimeRange,

+                                series: selectorSeries

+                               ) {

+                                TimeRangeSelectorView(

+                                    points: selectorSeries.points,

+                                    context: selectorSeries.context,

+                                    availableTimeRange: availableTimeRange,

+                                    accentColor: selectorSeries.kind.tint,

+                                    compactLayout: compactLayout,

+                                    minimumSelectionSpan: minimumTimeSpan,

+                                    selectedTimeRange: $selectedVisibleTimeRange,

+                                    isPinnedToPresent: $isPinnedToPresent,

+                                    presentTrackingMode: $presentTrackingMode

+                                )

+                            }

+        minimumYSpan: Double,

+        visibleTimeRange: ClosedRange<Date>? = nil

+        let points = filteredPoints(

+            measurement,

+            visibleTimeRange: visibleTimeRange

+        )

+        let xBounds = xBounds(

+            for: samplePoints,

+            visibleTimeRange: visibleTimeRange

+        )

+    private func overviewSeries(for kind: SeriesKind) -> SeriesData {

+        series(

+            for: measurement(for: kind),

+            kind: kind,

+            minimumYSpan: minimumYSpan(for: kind)

+        )

+    }

+

+    private func measurement(for kind: SeriesKind) -> Measurements.Measurement {

+        switch kind {

+        case .power:

+            return measurements.power

+        case .voltage:

+            return measurements.voltage

+        case .current:

+            return measurements.current

+        case .temperature:

+            return measurements.temperature

+        }

+    }

+

+    private func minimumYSpan(for kind: SeriesKind) -> Double {

+        switch kind {

+        case .power:

+            return minimumPowerSpan

+        case .voltage:

+            return minimumVoltageSpan

+        case .current:

+            return minimumCurrentSpan

+        case .temperature:

+            return minimumTemperatureSpan

+        }

+    }

+

+        let visibleTimeRange = activeVisibleTimeRange

+

+            return pinOrigin

+                ? powerAxisOrigin

+                : automaticYBounds(

+                    for: filteredSamplePoints(

+                        measurements.power,

+                        visibleTimeRange: visibleTimeRange

+                    ),

+                    minimumYSpan: minimumPowerSpan

+                ).lowerBound

+            return pinOrigin

+                ? voltageAxisOrigin

+                : automaticYBounds(

+                    for: filteredSamplePoints(

+                        measurements.voltage,

+                        visibleTimeRange: visibleTimeRange

+                    ),

+                    minimumYSpan: minimumVoltageSpan

+                ).lowerBound

+            return pinOrigin

+                ? currentAxisOrigin

+                : automaticYBounds(

+                    for: filteredSamplePoints(

+                        measurements.current,

+                        visibleTimeRange: visibleTimeRange

+                    ),

+                    minimumYSpan: minimumCurrentSpan

+                ).lowerBound

+            return pinOrigin

+                ? temperatureAxisOrigin

+                : automaticYBounds(

+                    for: filteredSamplePoints(

+                        measurements.temperature,

+                        visibleTimeRange: visibleTimeRange

+                    ),

+                    minimumYSpan: minimumTemperatureSpan

+                ).lowerBound

+    private var activeVisibleTimeRange: ClosedRange<Date>? {

+        resolvedVisibleTimeRange(within: availableSelectionTimeRange())

+    }

+

+    private func filteredPoints(

+        _ measurement: Measurements.Measurement,

+        visibleTimeRange: ClosedRange<Date>? = nil

+    ) -> [Measurements.Measurement.Point] {

+            guard timeRange?.contains(point.timestamp) ?? true else { return false }

+            return visibleTimeRange?.contains(point.timestamp) ?? true

+        }

+    }

+

+    private func filteredSamplePoints(

+        _ measurement: Measurements.Measurement,

+        visibleTimeRange: ClosedRange<Date>? = nil

+    ) -> [Measurements.Measurement.Point] {

+        filteredPoints(measurement, visibleTimeRange: visibleTimeRange).filter { point in

+            point.isSample

+        for samplePoints: [Measurements.Measurement.Point],

+        visibleTimeRange: ClosedRange<Date>? = nil

+        if let visibleTimeRange {

+            return normalizedTimeRange(visibleTimeRange)

+        }

+

+            return normalizedTimeRange(timeRange)

+        return normalizedTimeRange(lowerBound...upperBound)

+    }

+

+    private func availableSelectionTimeRange() -> ClosedRange<Date>? {

+        if let timeRange {

+            return normalizedTimeRange(timeRange)

+        }

+

+        let samplePoints = timelineSamplePoints()

+        guard let lowerBound = samplePoints.first?.timestamp else {

+            return nil

+        }

+

+        let upperBound = max(samplePoints.last?.timestamp ?? chartNow, chartNow)

+        return normalizedTimeRange(lowerBound...upperBound)

+    }

+

+    private func timelineSamplePoints() -> [Measurements.Measurement.Point] {

+        let candidates = [

+            filteredSamplePoints(measurements.power),

+            filteredSamplePoints(measurements.voltage),

+            filteredSamplePoints(measurements.current),

+            filteredSamplePoints(measurements.temperature)

+        ]

+

+        return candidates.first(where: { !$0.isEmpty }) ?? []

+    }

+

+    private func resolvedVisibleTimeRange(

+        within availableTimeRange: ClosedRange<Date>?

+    ) -> ClosedRange<Date>? {

+        guard let availableTimeRange else { return nil }

+        guard let selectedVisibleTimeRange else { return availableTimeRange }

+

+        if isPinnedToPresent {

+            let pinnedRange: ClosedRange<Date>

+

+            switch presentTrackingMode {

+            case .keepDuration:

+                let selectionSpan = selectedVisibleTimeRange.upperBound.timeIntervalSince(selectedVisibleTimeRange.lowerBound)

+                pinnedRange = availableTimeRange.upperBound.addingTimeInterval(-selectionSpan)...availableTimeRange.upperBound

+            case .keepStartTimestamp:

+                pinnedRange = selectedVisibleTimeRange.lowerBound...availableTimeRange.upperBound

+            }

+

+            return clampedTimeRange(pinnedRange, within: availableTimeRange)

+        }

+

+        return clampedTimeRange(selectedVisibleTimeRange, within: availableTimeRange)

+    }

+

+    private func clampedTimeRange(

+        _ candidateRange: ClosedRange<Date>,

+        within bounds: ClosedRange<Date>

+    ) -> ClosedRange<Date> {

+        let normalizedBounds = normalizedTimeRange(bounds)

+        let boundsSpan = normalizedBounds.upperBound.timeIntervalSince(normalizedBounds.lowerBound)

+

+        guard boundsSpan > 0 else {

+            return normalizedBounds

+        }

+

+        let minimumSpan = min(max(minimumTimeSpan, 0.1), boundsSpan)

+        let requestedSpan = min(

+            max(candidateRange.upperBound.timeIntervalSince(candidateRange.lowerBound), minimumSpan),

+            boundsSpan

+        )

+

+        if requestedSpan >= boundsSpan {

+            return normalizedBounds

+        }

+

+        var lowerBound = max(candidateRange.lowerBound, normalizedBounds.lowerBound)

+        var upperBound = min(candidateRange.upperBound, normalizedBounds.upperBound)

+

+        if upperBound.timeIntervalSince(lowerBound) < requestedSpan {

+            if lowerBound == normalizedBounds.lowerBound {

+                upperBound = lowerBound.addingTimeInterval(requestedSpan)

+            } else {

+                lowerBound = upperBound.addingTimeInterval(-requestedSpan)

+            }

+        }

+

+        if upperBound > normalizedBounds.upperBound {

+            let delta = upperBound.timeIntervalSince(normalizedBounds.upperBound)

+            upperBound = normalizedBounds.upperBound

+            lowerBound = lowerBound.addingTimeInterval(-delta)

+        if lowerBound < normalizedBounds.lowerBound {

+            let delta = normalizedBounds.lowerBound.timeIntervalSince(lowerBound)

+            lowerBound = normalizedBounds.lowerBound

+            upperBound = upperBound.addingTimeInterval(delta)

+        }

+

+        return lowerBound...upperBound

+    }

+

+    private func normalizedTimeRange(_ range: ClosedRange<Date>) -> ClosedRange<Date> {

+        let span = range.upperBound.timeIntervalSince(range.lowerBound)

+        guard span < minimumTimeSpan else { return range }

+

+        let expansion = (minimumTimeSpan - span) / 2

+        return range.lowerBound.addingTimeInterval(-expansion)...range.upperBound.addingTimeInterval(expansion)

+    }

+

+    private func shouldShowRangeSelector(

+        availableTimeRange: ClosedRange<Date>,

+        series: SeriesData

+    ) -> Bool {

+        series.samplePoints.count > 1 &&

+        availableTimeRange.upperBound.timeIntervalSince(availableTimeRange.lowerBound) > minimumTimeSpan

+        let visibleTimeRange = activeVisibleTimeRange

+

+            return snappedOriginValue(

+                filteredSamplePoints(

+                    measurements.power,

+                    visibleTimeRange: visibleTimeRange

+                ).map(\.value).min() ?? 0

+            )

+            return snappedOriginValue(

+                filteredSamplePoints(

+                    measurements.voltage,

+                    visibleTimeRange: visibleTimeRange

+                ).map(\.value).min() ?? 0

+            )

+            return snappedOriginValue(

+                filteredSamplePoints(

+                    measurements.current,

+                    visibleTimeRange: visibleTimeRange

+                ).map(\.value).min() ?? 0

+            )

+            return snappedOriginValue(

+                filteredSamplePoints(

+                    measurements.temperature,

+                    visibleTimeRange: visibleTimeRange

+                ).map(\.value).min() ?? 0

+            )

+private struct TimeRangeSelectorView: View {

+    private enum DragTarget {

+        case lowerBound

+        case upperBound

+        case window

+    }

+

+    private struct DragState {

+        let target: DragTarget

+        let initialRange: ClosedRange<Date>

+    }

+

+    let points: [Measurements.Measurement.Point]

+    let context: ChartContext

+    let availableTimeRange: ClosedRange<Date>

+    let accentColor: Color

+    let compactLayout: Bool

+    let minimumSelectionSpan: TimeInterval

+

+    @Binding var selectedTimeRange: ClosedRange<Date>?

+    @Binding var isPinnedToPresent: Bool

+    @Binding var presentTrackingMode: PresentTrackingMode

+    @State private var dragState: DragState?

+

+    private var totalSpan: TimeInterval {

+        availableTimeRange.upperBound.timeIntervalSince(availableTimeRange.lowerBound)

+    }

+

+    private var currentRange: ClosedRange<Date> {

+        resolvedSelectionRange()

+    }

+

+    private var trackHeight: CGFloat {

+        compactLayout ? 72 : 86

+    }

+

+    private var cornerRadius: CGFloat {

+        compactLayout ? 14 : 16

+    }

+

+    private var summaryFont: Font {

+        compactLayout ? .caption.weight(.semibold) : .footnote.weight(.semibold)

+    }

+

+    private var boundaryFont: Font {

+        compactLayout ? .caption.weight(.semibold) : .footnote.weight(.semibold)

+    }

+

+    private var symbolButtonSize: CGFloat {

+        compactLayout ? 28 : 32

+    }

+

+    var body: some View {

+        let coversFullRange = selectionCoversFullRange(currentRange)

+

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

+            if !coversFullRange || isPinnedToPresent {

+                HStack(spacing: 8) {

+                    alignmentButton(

+                        systemName: "arrow.left.to.line.compact",

+                        isActive: currentRange.lowerBound == availableTimeRange.lowerBound && !isPinnedToPresent,

+                        action: alignSelectionToLeadingEdge,

+                        accessibilityLabel: "Align selection to start"

+                    )

+

+                    alignmentButton(

+                        systemName: "arrow.right.to.line.compact",

+                        isActive: isPinnedToPresent || selectionTouchesPresent(currentRange),

+                        action: alignSelectionToTrailingEdge,

+                        accessibilityLabel: "Align selection to present"

+                    )

+

+                    Spacer(minLength: 0)

+

+                    if isPinnedToPresent {

+                        trackingModeToggleButton()

+                    }

+                }

+            }

+

+            GeometryReader { geometry in

+                let selectionFrame = selectionFrame(in: geometry.size)

+                let dimmingColor = Color(uiColor: .systemBackground).opacity(0.58)

+

+                ZStack(alignment: .topLeading) {

+                    RoundedRectangle(cornerRadius: cornerRadius, style: .continuous)

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

+

+                    Chart(

+                        points: points,

+                        context: context,

+                        areaChart: true,

+                        strokeColor: accentColor,

+                        areaFillColor: accentColor.opacity(0.22)

+                    )

+                    .opacity(0.94)

+                    .allowsHitTesting(false)

+

+                    Chart(

+                        points: points,

+                        context: context,

+                        strokeColor: accentColor.opacity(0.56)

+                    )

+                    .opacity(0.82)

+                    .allowsHitTesting(false)

+

+                    if selectionFrame.minX > 0 {

+                        Rectangle()

+                            .fill(dimmingColor)

+                            .frame(width: selectionFrame.minX, height: geometry.size.height)

+                            .allowsHitTesting(false)

+                    }

+

+                    if selectionFrame.maxX < geometry.size.width {

+                        Rectangle()

+                            .fill(dimmingColor)

+                            .frame(

+                                width: max(geometry.size.width - selectionFrame.maxX, 0),

+                                height: geometry.size.height

+                            )

+                            .offset(x: selectionFrame.maxX)

+                            .allowsHitTesting(false)

+                    }

+

+                    RoundedRectangle(cornerRadius: max(cornerRadius - 2, 10), style: .continuous)

+                        .fill(accentColor.opacity(0.18))

+                        .frame(width: max(selectionFrame.width, 2), height: geometry.size.height)

+                        .offset(x: selectionFrame.minX)

+                        .allowsHitTesting(false)

+

+                    RoundedRectangle(cornerRadius: max(cornerRadius - 2, 10), style: .continuous)

+                        .stroke(accentColor.opacity(0.52), lineWidth: 1.2)

+                        .frame(width: max(selectionFrame.width, 2), height: geometry.size.height)

+                        .offset(x: selectionFrame.minX)

+                        .allowsHitTesting(false)

+

+                    handleView(height: max(geometry.size.height - 18, 16))

+                        .offset(x: max(selectionFrame.minX + 6, 6), y: 9)

+                        .allowsHitTesting(false)

+

+                    handleView(height: max(geometry.size.height - 18, 16))

+                        .offset(x: max(selectionFrame.maxX - 12, 6), y: 9)

+                        .allowsHitTesting(false)

+                }

+                .clipShape(RoundedRectangle(cornerRadius: cornerRadius, style: .continuous))

+                .overlay(

+                    RoundedRectangle(cornerRadius: cornerRadius, style: .continuous)

+                        .stroke(Color.secondary.opacity(0.18), lineWidth: 1)

+                )

+                .contentShape(Rectangle())

+                .gesture(selectionGesture(totalWidth: geometry.size.width))

+            }

+            .frame(height: trackHeight)

+

+            HStack {

+                Text(boundaryLabel(for: availableTimeRange.lowerBound))

+                Spacer(minLength: 0)

+                Text(boundaryLabel(for: availableTimeRange.upperBound))

+            }

+            .font(boundaryFont)

+            .foregroundColor(.secondary)

+            .monospacedDigit()

+        }

+    }

+

+    private func handleView(height: CGFloat) -> some View {

+        Capsule(style: .continuous)

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

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

+            .shadow(color: .black.opacity(0.08), radius: 2, x: 0, y: 1)

+    }

+

+    private func alignmentButton(

+        systemName: String,

+        isActive: Bool,

+        action: @escaping () -> Void,

+        accessibilityLabel: String

+    ) -> some View {

+        Button(action: action) {

+            Image(systemName: systemName)

+                .font(.system(size: compactLayout ? 12 : 13, weight: .semibold))

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

+        }

+        .buttonStyle(.plain)

+        .foregroundColor(isActive ? .white : accentColor)

+        .background(

+            RoundedRectangle(cornerRadius: 9, style: .continuous)

+                .fill(isActive ? accentColor : accentColor.opacity(0.14))

+        )

+        .overlay(

+            RoundedRectangle(cornerRadius: 9, style: .continuous)

+                .stroke(accentColor.opacity(0.28), lineWidth: 1)

+        )

+        .accessibilityLabel(accessibilityLabel)

+    }

+

+    private func trackingModeToggleButton() -> some View {

+        Button {

+            presentTrackingMode = presentTrackingMode == .keepDuration

+                ? .keepStartTimestamp

+                : .keepDuration

+        } label: {

+            Image(systemName: trackingModeSymbolName)

+                .font(.system(size: compactLayout ? 12 : 13, weight: .semibold))

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

+        }

+        .buttonStyle(.plain)

+        .foregroundColor(.white)

+        .background(

+            RoundedRectangle(cornerRadius: 9, style: .continuous)

+                .fill(accentColor)

+        )

+        .overlay(

+            RoundedRectangle(cornerRadius: 9, style: .continuous)

+                .stroke(accentColor.opacity(0.28), lineWidth: 1)

+        )

+        .accessibilityLabel(trackingModeAccessibilityLabel)

+        .accessibilityHint("Toggles how the interval follows the present")

+    }

+

+    private var trackingModeSymbolName: String {

+        switch presentTrackingMode {

+        case .keepDuration:

+            return "arrow.left.and.right"

+        case .keepStartTimestamp:

+            return "arrow.left.to.line.compact"

+        }

+    }

+

+    private var trackingModeAccessibilityLabel: String {

+        switch presentTrackingMode {

+        case .keepDuration:

+            return "Follow present keeping span"

+        case .keepStartTimestamp:

+            return "Follow present keeping start"

+        }

+    }

+

+    private func alignSelectionToLeadingEdge() {

+        let alignedRange = normalizedSelectionRange(

+            availableTimeRange.lowerBound...currentRange.upperBound

+        )

+        applySelection(alignedRange, pinToPresent: false)

+    }

+

+    private func alignSelectionToTrailingEdge() {

+        let alignedRange = normalizedSelectionRange(

+            currentRange.lowerBound...availableTimeRange.upperBound

+        )

+        applySelection(alignedRange, pinToPresent: true)

+    }

+

+    private func selectionGesture(totalWidth: CGFloat) -> some Gesture {

+        DragGesture(minimumDistance: 0)

+            .onChanged { value in

+                updateSelectionDrag(value: value, totalWidth: totalWidth)

+            }

+            .onEnded { _ in

+                dragState = nil

+            }

+    }

+

+    private func updateSelectionDrag(

+        value: DragGesture.Value,

+        totalWidth: CGFloat

+    ) {

+        let startingRange = resolvedSelectionRange()

+

+        if dragState == nil {

+            dragState = DragState(

+                target: dragTarget(

+                    for: value.startLocation.x,

+                    selectionFrame: selectionFrame(for: startingRange, width: totalWidth)

+                ),

+                initialRange: startingRange

+            )

+        }

+

+        guard let dragState else { return }

+

+        let resultingRange = snappedToEdges(

+            adjustedRange(

+                from: dragState.initialRange,

+                target: dragState.target,

+                translationX: value.translation.width,

+                totalWidth: totalWidth

+            ),

+            target: dragState.target,

+            totalWidth: totalWidth

+        )

+

+        applySelection(

+            resultingRange,

+            pinToPresent: shouldKeepPresentPin(

+                during: dragState.target,

+                initialRange: dragState.initialRange,

+                resultingRange: resultingRange

+            ),

+        )

+    }

+

+    private func dragTarget(

+        for startX: CGFloat,

+        selectionFrame: CGRect

+    ) -> DragTarget {

+        let handleZone: CGFloat = compactLayout ? 20 : 24

+

+        if abs(startX - selectionFrame.minX) <= handleZone {

+            return .lowerBound

+        }

+

+        if abs(startX - selectionFrame.maxX) <= handleZone {

+            return .upperBound

+        }

+

+        if selectionFrame.contains(CGPoint(x: startX, y: selectionFrame.midY)) {

+            return .window

+        }

+

+        return startX < selectionFrame.minX ? .lowerBound : .upperBound

+    }

+

+    private func adjustedRange(

+        from initialRange: ClosedRange<Date>,

+        target: DragTarget,

+        translationX: CGFloat,

+        totalWidth: CGFloat

+    ) -> ClosedRange<Date> {

+        guard totalSpan > 0, totalWidth > 0 else {

+            return availableTimeRange

+        }

+

+        let delta = TimeInterval(translationX / totalWidth) * totalSpan

+        let minimumSpan = min(max(minimumSelectionSpan, 0.1), totalSpan)

+

+        switch target {

+        case .lowerBound:

+            let maximumLowerBound = initialRange.upperBound.addingTimeInterval(-minimumSpan)

+            let newLowerBound = min(

+                max(initialRange.lowerBound.addingTimeInterval(delta), availableTimeRange.lowerBound),

+                maximumLowerBound

+            )

+            return normalizedSelectionRange(newLowerBound...initialRange.upperBound)

+

+        case .upperBound:

+            let minimumUpperBound = initialRange.lowerBound.addingTimeInterval(minimumSpan)

+            let newUpperBound = max(

+                min(initialRange.upperBound.addingTimeInterval(delta), availableTimeRange.upperBound),

+                minimumUpperBound

+            )

+            return normalizedSelectionRange(initialRange.lowerBound...newUpperBound)

+

+        case .window:

+            let span = initialRange.upperBound.timeIntervalSince(initialRange.lowerBound)

+            guard span < totalSpan else { return availableTimeRange }

+

+            var lowerBound = initialRange.lowerBound.addingTimeInterval(delta)

+            var upperBound = initialRange.upperBound.addingTimeInterval(delta)

+

+            if lowerBound < availableTimeRange.lowerBound {

+                upperBound = upperBound.addingTimeInterval(

+                    availableTimeRange.lowerBound.timeIntervalSince(lowerBound)

+                )

+                lowerBound = availableTimeRange.lowerBound

+            }

+

+            if upperBound > availableTimeRange.upperBound {

+                lowerBound = lowerBound.addingTimeInterval(

+                    -upperBound.timeIntervalSince(availableTimeRange.upperBound)

+                )

+                upperBound = availableTimeRange.upperBound

+            }

+

+            return normalizedSelectionRange(lowerBound...upperBound)

+        }

+    }

+

+    private func snappedToEdges(

+        _ candidateRange: ClosedRange<Date>,

+        target: DragTarget,

+        totalWidth: CGFloat

+    ) -> ClosedRange<Date> {

+        guard totalSpan > 0 else {

+            return availableTimeRange

+        }

+

+        let snapInterval = edgeSnapInterval(for: totalWidth)

+        let selectionSpan = candidateRange.upperBound.timeIntervalSince(candidateRange.lowerBound)

+        var lowerBound = candidateRange.lowerBound

+        var upperBound = candidateRange.upperBound

+

+        if target != .upperBound,

+           lowerBound.timeIntervalSince(availableTimeRange.lowerBound) <= snapInterval {

+            lowerBound = availableTimeRange.lowerBound

+            if target == .window {

+                upperBound = lowerBound.addingTimeInterval(selectionSpan)

+            }

+        }

+

+        if target != .lowerBound,

+           availableTimeRange.upperBound.timeIntervalSince(upperBound) <= snapInterval {

+            upperBound = availableTimeRange.upperBound

+            if target == .window {

+                lowerBound = upperBound.addingTimeInterval(-selectionSpan)

+            }

+        }

+

+        return normalizedSelectionRange(lowerBound...upperBound)

+    }

+

+    private func edgeSnapInterval(

+        for totalWidth: CGFloat

+    ) -> TimeInterval {

+        guard totalWidth > 0 else { return minimumSelectionSpan }

+

+        let snapWidth = min(

+            max(compactLayout ? 18 : 22, totalWidth * 0.04),

+            totalWidth * 0.18

+        )

+        let intervalFromWidth = TimeInterval(snapWidth / totalWidth) * totalSpan

+        return min(

+            max(intervalFromWidth, minimumSelectionSpan * 0.5),

+            totalSpan / 4

+        )

+    }

+

+    private func resolvedSelectionRange() -> ClosedRange<Date> {

+        guard let selectedTimeRange else { return availableTimeRange }

+

+        if isPinnedToPresent {

+            switch presentTrackingMode {

+            case .keepDuration:

+                let selectionSpan = selectedTimeRange.upperBound.timeIntervalSince(selectedTimeRange.lowerBound)

+                return normalizedSelectionRange(

+                    availableTimeRange.upperBound.addingTimeInterval(-selectionSpan)...availableTimeRange.upperBound

+                )

+            case .keepStartTimestamp:

+                return normalizedSelectionRange(

+                    selectedTimeRange.lowerBound...availableTimeRange.upperBound

+                )

+            }

+        }

+

+        return normalizedSelectionRange(selectedTimeRange)

+    }

+

+    private func normalizedSelectionRange(

+        _ candidateRange: ClosedRange<Date>

+    ) -> ClosedRange<Date> {

+        let availableSpan = totalSpan

+        guard availableSpan > 0 else { return availableTimeRange }

+

+        let minimumSpan = min(max(minimumSelectionSpan, 0.1), availableSpan)

+        let requestedSpan = min(

+            max(candidateRange.upperBound.timeIntervalSince(candidateRange.lowerBound), minimumSpan),

+            availableSpan

+        )

+

+        if requestedSpan >= availableSpan {

+            return availableTimeRange

+        }

+

+        var lowerBound = max(candidateRange.lowerBound, availableTimeRange.lowerBound)

+        var upperBound = min(candidateRange.upperBound, availableTimeRange.upperBound)

+

+        if upperBound.timeIntervalSince(lowerBound) < requestedSpan {

+            if lowerBound == availableTimeRange.lowerBound {

+                upperBound = lowerBound.addingTimeInterval(requestedSpan)

+            } else {

+                lowerBound = upperBound.addingTimeInterval(-requestedSpan)

+            }

+        }

+

+        if upperBound > availableTimeRange.upperBound {

+            let delta = upperBound.timeIntervalSince(availableTimeRange.upperBound)

+            upperBound = availableTimeRange.upperBound

+            lowerBound = lowerBound.addingTimeInterval(-delta)

+        }

+

+        if lowerBound < availableTimeRange.lowerBound {

+            let delta = availableTimeRange.lowerBound.timeIntervalSince(lowerBound)

+            lowerBound = availableTimeRange.lowerBound

+            upperBound = upperBound.addingTimeInterval(delta)

+        }

+

+        return lowerBound...upperBound

+    }

+

+    private func shouldKeepPresentPin(

+        during target: DragTarget,

+        initialRange: ClosedRange<Date>,

+        resultingRange: ClosedRange<Date>

+    ) -> Bool {

+        let startedPinnedToPresent =

+            isPinnedToPresent ||

+            selectionCoversFullRange(initialRange)

+

+        guard startedPinnedToPresent else {

+            return selectionTouchesPresent(resultingRange)

+        }

+

+        switch target {

+        case .lowerBound:

+            return true

+        case .upperBound, .window:

+            return selectionTouchesPresent(resultingRange)

+        }

+    }

+

+    private func applySelection(

+        _ candidateRange: ClosedRange<Date>,

+        pinToPresent: Bool

+    ) {

+        let normalizedRange = normalizedSelectionRange(candidateRange)

+

+        if selectionCoversFullRange(normalizedRange) && !pinToPresent {

+            selectedTimeRange = nil

+        } else {

+            selectedTimeRange = normalizedRange

+        }

+

+        isPinnedToPresent = pinToPresent

+    }

+

+    private func selectionTouchesPresent(

+        _ range: ClosedRange<Date>

+    ) -> Bool {

+        let tolerance = max(0.5, minimumSelectionSpan * 0.25)

+        return abs(range.upperBound.timeIntervalSince(availableTimeRange.upperBound)) <= tolerance

+    }

+

+    private func selectionCoversFullRange(

+        _ range: ClosedRange<Date>

+    ) -> Bool {

+        let tolerance = max(0.5, minimumSelectionSpan * 0.25)

+        return abs(range.lowerBound.timeIntervalSince(availableTimeRange.lowerBound)) <= tolerance &&

+        abs(range.upperBound.timeIntervalSince(availableTimeRange.upperBound)) <= tolerance

+    }

+

+    private func selectionFrame(in size: CGSize) -> CGRect {

+        selectionFrame(for: currentRange, width: size.width)

+    }

+

+    private func selectionFrame(

+        for range: ClosedRange<Date>,

+        width: CGFloat

+    ) -> CGRect {

+        guard width > 0, totalSpan > 0 else {

+            return CGRect(origin: .zero, size: CGSize(width: width, height: trackHeight))

+        }

+

+        let minimumX = xPosition(for: range.lowerBound, width: width)

+        let maximumX = xPosition(for: range.upperBound, width: width)

+        return CGRect(

+            x: minimumX,

+            y: 0,

+            width: max(maximumX - minimumX, 2),

+            height: trackHeight

+        )

+    }

+

+    private func xPosition(for date: Date, width: CGFloat) -> CGFloat {

+        guard width > 0, totalSpan > 0 else { return 0 }

+

+        let offset = date.timeIntervalSince(availableTimeRange.lowerBound)

+        let normalizedOffset = min(max(offset / totalSpan, 0), 1)

+        return CGFloat(normalizedOffset) * width

+    }

+

+    private func boundaryLabel(for date: Date) -> String {

+        date.format(as: boundaryDateFormat)

+    }

+

+    private func selectionSummary(

+        for range: ClosedRange<Date>

+    ) -> String {

+        "\(range.lowerBound.format(as: summaryDateFormat)) - \(range.upperBound.format(as: summaryDateFormat))"

+    }

+

+    private var boundaryDateFormat: String {