Pre-push review: iPad adaptive layout (T-1150)

diff --git a/Flux/Flux/Helpers/IPadLayoutGate.swift b/Flux/Flux/Helpers/IPadLayoutGate.swiftnew file mode 100644index 0000000..5a14b76--- /dev/null+++ b/Flux/Flux/Helpers/IPadLayoutGate.swift@@ -0,0 +1,21 @@+import SwiftUI++/// Central gate for the iPad regular-size-class layout. iPhone Plus/Max+/// landscape reports `.regular` horizontal size class but must keep the+/// iPhone shell (AC 7.1) — the idiom check makes that explicit. macOS+/// never qualifies; the gate returns `false` so the existing+/// `NavigationSplitView` shell and single-column screen layouts remain+/// untouched (AC 7.2).+///+/// Keeping this in one place means the regression guard ships from a+/// single site instead of drifting across `AppNavigationView`,+/// `DashboardView`, `HistoryView`, `DayDetailView`, and `SettingsView`.+enum IPadLayoutGate {+    static func isActive(hSizeClass: UserInterfaceSizeClass?) -> Bool {+        #if os(iOS)+        return UIDevice.current.userInterfaceIdiom == .pad && hSizeClass == .regular+        #else+        return false+        #endif+    }+}

diff --git a/Flux/Flux/Helpers/AdaptiveColumnsLayout.swift b/Flux/Flux/Helpers/AdaptiveColumnsLayout.swiftnew file mode 100644index 0000000..ad21993--- /dev/null+++ b/Flux/Flux/Helpers/AdaptiveColumnsLayout.swift@@ -0,0 +1,59 @@+import SwiftUI++/// Reflows children into 1, 2, or 3 columns based on the container width,+/// collapsing one column at large accessibility Dynamic Type sizes.+///+/// Width tiers (provisional — see specs/ipad-adaptive-layout/implementation.md):+/// `< 700` → 1 column, `700..<1000` → 2 columns, `≥ 1000` → 3 columns.+/// At `dynamicTypeSize >= .accessibility4` the column count drops by one+/// (never below 1) so cards retain a readable per-column width.+struct AdaptiveColumnsLayout<Content: View>: View {+    let spacing: CGFloat+    @ViewBuilder let content: () -> Content++    // Seed at 700pt — the 2-column tier. This is only rendered inside the+    // iPad regular shell (callers gate on `IPadLayoutGate`), where the+    // detail-column width is always in the 2- or 3-column range. Starting+    // at 1 column produced a visible 1-frame collapse on every appearance+    // before `onGeometryChange` delivered the real width; starting at the+    // 2-column tier means the snap-up to 3-column on iPad Pro 13" landscape+    // is the only visible reflow and is much less obtrusive.+    @State private var measuredWidth: CGFloat = 700+    @Environment(\.dynamicTypeSize) private var typeSize++    init(+        spacing: CGFloat = FluxTheme.Metrics.panelGap,+        @ViewBuilder content: @escaping () -> Content+    ) {+        self.spacing = spacing+        self.content = content+    }++    var body: some View {+        let cols = columnCount(width: measuredWidth, typeSize: typeSize)+        let columns = Array(+            repeating: GridItem(.flexible(), spacing: spacing, alignment: .top),+            count: cols+        )+        LazyVGrid(columns: columns, alignment: .leading, spacing: spacing) {+            content()+        }+        .onGeometryChange(for: CGFloat.self) { proxy in+            proxy.size.width+        } action: { newWidth in+            measuredWidth = newWidth+        }+    }++    func columnCount(width: CGFloat, typeSize: DynamicTypeSize) -> Int {+        let base: Int+        if width >= 1000 {+            base = 3+        } else if width >= 700 {+            base = 2+        } else {+            base = 1+        }+        return typeSize >= .accessibility4 ? max(1, base - 1) : base+    }+}

diff --git a/Flux/Flux/Navigation/FluxiPadRoot.swift b/Flux/Flux/Navigation/FluxiPadRoot.swiftnew file mode 100644index 0000000..0397bf8--- /dev/null+++ b/Flux/Flux/Navigation/FluxiPadRoot.swift@@ -0,0 +1,88 @@+#if !os(macOS)+import FluxCore+import SwiftData+import SwiftUI++/// iPad regular-size-class shell. A two-column `NavigationSplitView` with a+/// sidebar (Dashboard / Today / History) and a detail column hosting the+/// selected screen. Settings stays as a sheet, opened via a toolbar gear in+/// the detail column.+///+/// View-models are injected by `AppNavigationView`. They outlive a size-class+/// flip between this shell and `FluxiOSRoot` so cached fetch state and+/// in-flight refresh timers survive the transition (AC 6.4).+///+/// Compact-width fallbacks (Slide Over, narrow Split View) are not handled+/// here — `AppNavigationView.iOSRoot` gates on `usesPadShell` and renders+/// `FluxiOSRoot` at compact widths.+struct FluxiPadRoot: View {+    @Environment(\.modelContext) private var modelContext++    let apiClient: any FluxAPIClient+    @Binding var selectedScreen: Screen?+    @Binding var navigationPath: NavigationPath+    let dashboardViewModel: DashboardViewModel+    let historyViewModel: HistoryViewModel+    let todayDayDetailViewModel: DayDetailViewModel++    @State private var preferredCompactColumn: NavigationSplitViewColumn = .detail+    @State private var showingSettings = false++    var body: some View {+        NavigationSplitView(preferredCompactColumn: $preferredCompactColumn) {+            SidebarView(selection: $selectedScreen)+        } detail: {+            NavigationStack(path: $navigationPath) {+                detailContent+                    .toolbar {+                        ToolbarItem(placement: .primaryAction) {+                            Button {+                                showingSettings = true+                            } label: {+                                Label("Settings", systemImage: "gearshape")+                            }+                        }+                    }+            }+        }+        .navigationSplitViewStyle(.balanced)+        .sheet(isPresented: $showingSettings) {+            NavigationStack {+                SettingsView()+                    .toolbar {+                        ToolbarItem(placement: .topBarTrailing) {+                            Button("Done") { showingSettings = false }+                        }+                    }+            }+        }+    }++    @ViewBuilder+    private var detailContent: some View {+        switch selectedScreen ?? .dashboard {+        case .dashboard:+            DashboardView(viewModel: dashboardViewModel)+        case .today:+            DayDetailView(viewModel: todayDayDetailViewModel)+        case .history:+            HistoryView(+                viewModel: historyViewModel,+                makeDayDetailViewModel: { date in+                    DayDetailViewModel(date: date, apiClient: apiClient)+                }+            )+        case .settings:+            // Settings sheet is presented via the toolbar gear above; this+            // case should be unreachable on iPad regular because+            // Screen.sidebarVisible filters .settings out. Render a small+            // placeholder defensively rather than crashing.+            ContentUnavailableView(+                "Settings",+                systemImage: "gearshape",+                description: Text("Open Settings from the toolbar.")+            )+        }+    }+}+#endif

diff --git a/Flux/Flux/Navigation/SidebarTabSync.swift b/Flux/Flux/Navigation/SidebarTabSync.swiftnew file mode 100644index 0000000..2066700--- /dev/null+++ b/Flux/Flux/Navigation/SidebarTabSync.swift@@ -0,0 +1,31 @@+import Foundation++/// Pure helpers driving the bidirectional sidebar ↔ tab sync that+/// `AppNavigationView` runs across iPad size-class transitions. Two+/// trigger-aware functions instead of one symmetric reducer — the+/// onChange handler that fired tells us which side is canonical:+///+/// - The `selectedScreen` handler calls ``mappedIosTab`` to derive the+///   new tab from the new selection.+/// - The `iosTab` handler calls ``mappedSelectedScreen`` to derive the+///   new selection from the new tab.+///+/// Both helpers preserve `.settings` (no `FluxTab` counterpart) and+/// guard against feedback loops by returning the current value when+/// the other side already matches.++/// Computes the `FluxTab` that should mirror the given selected screen.+/// Returns `currentTab` unchanged when `selected` has no tab counterpart+/// (`.settings` or `nil`) — leaving the tab alone in that case keeps the+/// user out of an inconsistent state.+func mappedIosTab(for selected: Screen?, currentTab: FluxTab) -> FluxTab {+    selected?.tab ?? currentTab+}++/// Computes the `Screen?` that should mirror the given tab. Preserves a+/// `.settings` selection so a tab change does not knock the user out of+/// Settings; otherwise maps via ``Screen/init(tab:)``.+func mappedSelectedScreen(for tab: FluxTab, currentSelection: Screen?) -> Screen? {+    if currentSelection == .settings { return .settings }+    return Screen(tab: tab)+}

diff --git a/Flux/Flux/Navigation/AppNavigationView.swift b/Flux/Flux/Navigation/AppNavigationView.swiftindex 6b1fe08..108dc09 100644--- a/Flux/Flux/Navigation/AppNavigationView.swift+++ b/Flux/Flux/Navigation/AppNavigationView.swift@@ -6,6 +6,9 @@ import SwiftUI struct AppNavigationView: View {     @Environment(\.modelContext) private var modelContext     @Environment(\.scenePhase) private var scenePhase+    #if !os(macOS)+    @Environment(\.horizontalSizeClass) private var hSizeClass+    #endif      @State private var selectedScreen: Screen? = .dashboard     @State private var navigationPath = NavigationPath()@@ -13,6 +16,11 @@ struct AppNavigationView: View {     @State private var keychainService = KeychainService()     @State private var apiClient: (any FluxAPIClient)?     @State private var iosTab: FluxTab = .dashboard+    @State private var today: String = DateFormatting.todayDateString()+    @State private var dashboardViewModel: DashboardViewModel?+    @State private var historyViewModel: HistoryViewModel?+    @State private var todayDayDetailViewModel: DayDetailViewModel?+    @State private var credentialFingerprint: String?     @State private var pendingAuto: PendingAutoPresentation?     @State private var didEvaluateAutoPresentation = false     @State private var canonicalInstalledVersion: String = ""@@ -42,10 +50,17 @@ struct AppNavigationView: View {                     storedSelection = newScreen.rawValue                 }                 #endif+                let mapped = mappedIosTab(for: newScreen, currentTab: iosTab)+                if mapped != iosTab { iosTab = mapped }+            }+            .onChange(of: iosTab) { _, newTab in+                let mapped = mappedSelectedScreen(for: newTab, currentSelection: selectedScreen)+                if mapped != selectedScreen { selectedScreen = mapped }             }             .onChange(of: scenePhase) { _, newPhase in                 if newPhase == .active {                     reloadDependencies()+                    rolloverToday()                     // Replay any pending SoC alert registration (AC 1.7,                     // 2.4): a failed POST in registerDeviceIfNeeded leaves                     // the device record stashed locally; foregroundHook@@ -55,6 +70,13 @@ struct AppNavigationView: View {                     }                 }             }+            .task {+                while !Task.isCancelled {+                    try? await Task.sleep(for: .seconds(60))+                    if Task.isCancelled { return }+                    rolloverToday()+                }+            }             .onOpenURL { url in                 switch DeepLinkHandler.handle(url) {                 case let .navigate(screen):@@ -148,13 +170,32 @@ struct AppNavigationView: View {     #if !os(macOS)     @ViewBuilder     private var iOSRoot: some View {-        if let apiClient {-            FluxiOSRoot(apiClient: apiClient, tab: $iosTab)+        if let apiClient, let dashboardViewModel, let historyViewModel, let todayDayDetailViewModel {+            if usesPadShell {+                FluxiPadRoot(+                    apiClient: apiClient,+                    selectedScreen: $selectedScreen,+                    navigationPath: $navigationPath,+                    dashboardViewModel: dashboardViewModel,+                    historyViewModel: historyViewModel,+                    todayDayDetailViewModel: todayDayDetailViewModel+                )+                .modelContext(modelContext)+            } else {+                FluxiOSRoot(+                    apiClient: apiClient,+                    tab: $iosTab,+                    dashboardViewModel: dashboardViewModel,+                    historyViewModel: historyViewModel+                )                 .modelContext(modelContext)+            }         } else {             SettingsView(onSaved: handleSettingsSaved)         }     }++    private var usesPadShell: Bool { IPadLayoutGate.isActive(hSizeClass: hSizeClass) }     #endif      private var effectiveScreen: Screen {@@ -168,16 +209,64 @@ struct AppNavigationView: View {         reloadDependencies()     } +    private func rolloverToday() {+        let now = DateFormatting.todayDateString()+        guard now != today else { return }+        today = now+        if let todayDayDetailViewModel {+            Task { @MainActor in+                await todayDayDetailViewModel.setDate(now)+            }+        }+    }+     private func reloadDependencies() {-        let client = makeAPIClient()-        apiClient = client+        // Fingerprint the credentials so we only rebuild the API client and+        // the three hoisted VMs when the URL or token actually changes —+        // otherwise every scenePhase → .active foreground would discard+        // cached state and in-flight refresh timers (violating AC 6.4).+        let newFingerprint = currentCredentialFingerprint()+        let credentialsChanged = newFingerprint != credentialFingerprint+        credentialFingerprint = newFingerprint++        if credentialsChanged {+            let client = makeAPIClient()+            apiClient = client+            if let client {+                dashboardViewModel = DashboardViewModel(apiClient: client)+                historyViewModel = HistoryViewModel(apiClient: client, modelContext: modelContext)+                todayDayDetailViewModel = DayDetailViewModel(date: today, apiClient: client)+            } else {+                dashboardViewModel = nil+                historyViewModel = nil+                todayDayDetailViewModel = nil+            }+        }+         // Also binds SoCAlertsService so its CRUD calls don't throw .notConfigured.-        if let client {-            SoCAlertsService.shared.bind(apiClient: client)+        if let apiClient {+            SoCAlertsService.shared.bind(apiClient: apiClient)         }         selectedScreen = apiClient == nil ? .settings : (selectedScreen ?? .dashboard)     } +    /// Joins the trimmed API URL and the keychain token into a single+    /// string so `reloadDependencies()` can detect a credentials change+    /// by comparison instead of by API-client reference identity (the+    /// client is a class instance and `makeAPIClient()` returns a fresh+    /// one every call).+    private func currentCredentialFingerprint() -> String? {+        guard let urlString = UserDefaults.fluxAppGroup.apiURL?+                .trimmingCharacters(in: .whitespacesAndNewlines),+              !urlString.isEmpty,+              let token = keychainService.loadToken(),+              !token.isEmpty+        else {+            return nil+        }+        return "\(urlString)|\(token)"+    }+     private func makeAPIClient() -> (any FluxAPIClient)? {         guard let urlString = UserDefaults.fluxAppGroup.apiURL?.trimmingCharacters(in: .whitespacesAndNewlines),               let url = URL(string: urlString),@@ -190,17 +279,6 @@ struct AppNavigationView: View {     } } -private extension Screen {-    var tab: FluxTab? {-        switch self {-        case .dashboard: .dashboard-        case .today: .today-        case .history: .history-        case .settings: nil-        }-    }-}- #if os(macOS) private struct MacUnconfiguredView: View {     var body: some View {

diff --git a/Flux/Flux/Navigation/Screen.swift b/Flux/Flux/Navigation/Screen.swiftindex 9660e2f..bbe730f 100644--- a/Flux/Flux/Navigation/Screen.swift+++ b/Flux/Flux/Navigation/Screen.swift@@ -26,15 +26,26 @@ enum Screen: String, CaseIterable, Identifiable {         }     } +    /// macOS uses the Settings scene (⌘,); iPad regular uses the per-screen+    /// settings affordance. Neither shell wants a Settings sidebar row.     static var sidebarVisible: [Screen] {-        #if os(macOS)-        // macOS uses the Settings scene (⌘,) instead of an inline entry.-        return Screen.allCases.filter { $0 != .settings }-        #else-        // `.today` is a macOS-only sidebar entry per T-1081 polish; iOS-        // continues to reach Day Detail via the Dashboard's "Today detail"-        // button.-        return Screen.allCases.filter { $0 != .today }-        #endif+        Screen.allCases.filter { $0 != .settings }+    }++    var tab: FluxTab? {+        switch self {+        case .dashboard: .dashboard+        case .today: .today+        case .history: .history+        case .settings: nil+        }+    }++    init(tab: FluxTab) {+        switch tab {+        case .dashboard: self = .dashboard+        case .today: self = .today+        case .history: self = .history+        }     } }

diff --git a/Flux/Flux/Navigation/FluxiOSRoot.swift b/Flux/Flux/Navigation/FluxiOSRoot.swiftindex fb2ca29..60e4477 100644--- a/Flux/Flux/Navigation/FluxiOSRoot.swift+++ b/Flux/Flux/Navigation/FluxiOSRoot.swift@@ -8,10 +8,9 @@ import SwiftUI /// so there is no system tab bar — the navigation chrome is built from the /// V5 tokens. ///-/// The Dashboard view-model is held here so its 10s auto-refresh state and-/// last fetched payload survive tab switches; the Today and History-/// view-models reload cheaply when their tabs become visible, so they're-/// allowed to be reconstructed.+/// View-models are injected by `AppNavigationView` rather than constructed+/// here, so they survive a size-class flip between the iPhone shell and the+/// upcoming iPad sidebar shell (AC 6.4). /// /// Each tab owns its own `NavigationPath`. Tapping any tab in the tab bar /// pops that tab back to its root — including taps on the already-selected@@ -20,19 +19,26 @@ import SwiftUI struct FluxiOSRoot: View {     @Environment(\.modelContext) private var modelContext -    @State private var dashboardViewModel: DashboardViewModel     @State private var dashboardPath = NavigationPath()     @State private var todayPath = NavigationPath()     @State private var historyPath = NavigationPath()     @State private var showingSettings = false      let apiClient: any FluxAPIClient+    let dashboardViewModel: DashboardViewModel+    let historyViewModel: HistoryViewModel     @Binding var tab: FluxTab -    init(apiClient: any FluxAPIClient, tab: Binding<FluxTab>) {+    init(+        apiClient: any FluxAPIClient,+        tab: Binding<FluxTab>,+        dashboardViewModel: DashboardViewModel,+        historyViewModel: HistoryViewModel+    ) {         self.apiClient = apiClient         _tab = tab-        _dashboardViewModel = State(initialValue: DashboardViewModel(apiClient: apiClient))+        self.dashboardViewModel = dashboardViewModel+        self.historyViewModel = historyViewModel     }      var body: some View {@@ -62,8 +68,10 @@ struct FluxiOSRoot: View {             case .history:                 NavigationStack(path: $historyPath) {                     HistoryView(-                        apiClient: apiClient,-                        modelContext: modelContext,+                        viewModel: historyViewModel,+                        makeDayDetailViewModel: { date in+                            DayDetailViewModel(date: date, apiClient: apiClient)+                        },                         tab: $tab,                         onSettingsTap: { showingSettings = true },                         onTabActivate: handleTabActivate

diff --git a/Flux/Flux/DayDetail/DayDetailViewModel.swift b/Flux/Flux/DayDetail/DayDetailViewModel.swiftindex 01ff05a..3c08ac5 100644--- a/Flux/Flux/DayDetail/DayDetailViewModel.swift+++ b/Flux/Flux/DayDetail/DayDetailViewModel.swift@@ -53,11 +53,11 @@ final class DayDetailViewModel {     //     // INVARIANT (compiler no longer enforces this): the only access to     // this property from a non-MainActor context must be the-    // `cancel()` call in `deinit`. All read/write paths from-    // `updateCompare` and friends run on the main actor. If you add a-    // new access point, audit it against this rule — `nonisolated(unsafe)`-    // is the discipline that makes the storage safe; Swift no longer-    // checks it for you.+    // `cancel()` call in `deinit`. All MainActor read/write paths+    // (`updateCompare`, `setDate`) are safe. If you add a new access+    // point from a non-MainActor context, audit it against this rule —+    // `nonisolated(unsafe)` is the discipline that makes the storage+    // safe; Swift no longer checks it for you.     @ObservationIgnored     nonisolated(unsafe) private var comparisonTask: Task<Void, Never>? @@ -83,6 +83,25 @@ final class DayDetailViewModel {         DateFormatting.isToday(date, now: nowProvider())     } +    /// Used only by the iPad Today rollover path (T-1150). Reuses this VM+    /// across midnight so view-level state (chart highlight, note draft) is+    /// preserved; per-day fields are cleared explicitly. General date+    /// navigation constructs a fresh VM.+    func setDate(_ newDate: String) async {+        guard newDate != date else { return }+        comparisonTask?.cancel()+        date = newDate+        readings = []+        parsedReadings = []+        summary = nil+        peakPeriods = []+        dailyUsage = nil+        note = nil+        offpeakStats = .empty+        comparisonState = .off+        await loadDay()+    }+     func loadDay() async {         guard !isLoading else { return } 

diff --git a/Flux/Flux/DayDetail/DayDetailView.swift b/Flux/Flux/DayDetail/DayDetailView.swiftindex 0a7d290..1730be3 100644--- a/Flux/Flux/DayDetail/DayDetailView.swift+++ b/Flux/Flux/DayDetail/DayDetailView.swift@@ -1,10 +1,13 @@ import FluxCore import SwiftUI +// swiftlint:disable type_body_length+ /// V5 "Today" screen. Wraps the existing chart implementations /// (PowerChartView / BatteryPowerChartView / SOCChartView) in V5 panels and /// adds the Summary, Off-peak, and "five blocks" panels. struct DayDetailView: View {+    @Environment(\.horizontalSizeClass) private var hSizeClass     @State private var viewModel: DayDetailViewModel     @State private var showingSettings = false     @State private var editingNote = false@@ -55,45 +58,11 @@ struct DayDetailView: View {      var body: some View {         ScrollView {-            VStack(alignment: .leading, spacing: FluxTheme.Metrics.panelGap) {-                header-                DayNavigationHeader(viewModel: viewModel)-                DayDetailNoteSection(viewModel: viewModel, editingNote: $editingNote)--                CompareControl(-                    enabled: $compareEnabled,-                    period: comparePeriod,-                    unavailable: viewModel.comparisonState.isUnavailable-                )--                if let dailyUsage = viewModel.dailyUsage, !dailyUsage.blocks.isEmpty {-                    DayInFiveBlocksPanel(dailyUsage: dailyUsage,-                                         compare: viewModel.comparisonState)-                }--                contentSection--                SummaryBlock(-                    title: "Power",-                    trailing: trailingSummaryDate,-                    summary: viewModel.summary,-                    // Prefer the canonical server value (DaySummary now carries-                    // it for any date with an off-peak record); fall back to-                    // the readings-derived approximation when the server-                    // hasn't returned a split.-                    offpeakGridImport: viewModel.summary?.offpeakGridImportKwh ?? viewModel.offpeakStats.gridImportKwh,-                    showsBatteryCycle: false,-                    compare: viewModel.comparisonState-                )-                BatteryBlock(-                    batteryCharge: viewModel.summary?.eCharge,-                    batteryDischarge: viewModel.summary?.eDischarge,-                    lowestSOC: viewModel.offpeakStats.lowestSOC,-                    lowestSOCTimestamp: viewModel.offpeakStats.lowestSOCTimestamp-                )+            if usesRegularLayout {+                dayDetailContentRegular+            } else {+                dayDetailContent             }-            .padding(.horizontal, FluxTheme.Metrics.screenHorizontalPadding)-            .padding(.bottom, FluxTheme.Metrics.screenBottomPadding)         }         .scrollContentBackground(.hidden)         .fluxScreenBackground()@@ -144,6 +113,148 @@ struct DayDetailView: View {         }     } +    private var usesRegularLayout: Bool { IPadLayoutGate.isActive(hSizeClass: hSizeClass) }++    @ViewBuilder+    private var dayDetailContent: some View {+        VStack(alignment: .leading, spacing: FluxTheme.Metrics.panelGap) {+            header+            DayNavigationHeader(viewModel: viewModel)+            DayDetailNoteSection(viewModel: viewModel, editingNote: $editingNote)+            CompareControl(+                enabled: $compareEnabled,+                period: comparePeriod,+                unavailable: viewModel.comparisonState.isUnavailable+            )+            if let dailyUsage = viewModel.dailyUsage, !dailyUsage.blocks.isEmpty {+                DayInFiveBlocksPanel(dailyUsage: dailyUsage,+                                     compare: viewModel.comparisonState)+            }+            contentSection+            summaryBlock+            batteryBlock+        }+        .padding(.horizontal, FluxTheme.Metrics.screenHorizontalPadding)+        .padding(.bottom, FluxTheme.Metrics.screenBottomPadding)+    }++    @ViewBuilder+    private var dayDetailContentRegular: some View {+        VStack(alignment: .leading, spacing: FluxTheme.Metrics.panelGap) {+            header+            DayNavigationHeader(viewModel: viewModel)+            DayDetailNoteSection(viewModel: viewModel, editingNote: $editingNote)+            CompareControl(+                enabled: $compareEnabled,+                period: comparePeriod,+                unavailable: viewModel.comparisonState.isUnavailable+            )++            Grid(alignment: .topLeading, horizontalSpacing: FluxTheme.Metrics.panelGap,+                 verticalSpacing: FluxTheme.Metrics.panelGap) {+                GridRow {+                    summaryColumn+                    chartsColumn+                }+            }+        }+        .padding(.horizontal, FluxTheme.Metrics.screenHorizontalPadding)+        .padding(.bottom, FluxTheme.Metrics.screenBottomPadding)+    }++    @ViewBuilder+    private var summaryColumn: some View {+        let dailyUsage = viewModel.dailyUsage.flatMap { $0.blocks.isEmpty ? nil : $0 }+        VStack(alignment: .leading, spacing: FluxTheme.Metrics.panelGap) {+            if let dailyUsage {+                DayInFiveBlocksPanel(dailyUsage: dailyUsage,+                                     compare: viewModel.comparisonState)+            }+            summaryBlock+            batteryBlock+            if let dailyUsage {+                DailyUsageCard(dailyUsage: dailyUsage)+            }+            if !viewModel.peakPeriods.isEmpty {+                PeakUsageCard(periods: viewModel.peakPeriods)+            }+        }+    }++    @ViewBuilder+    private var chartsColumn: some View {+        VStack(alignment: .leading, spacing: FluxTheme.Metrics.panelGap) {+            if !viewModel.parsedReadings.isEmpty {+                if viewModel.hasPowerData {+                    DayDetailPanels.power(date: viewModel.date,+                                          readings: viewModel.parsedReadings,+                                          selectedDate: $powerSelected)+                    FluxPanel {+                        VStack(alignment: .leading, spacing: 0) {+                            FluxPanelHeader(label: "Battery Power", right: "kW")+                            BatteryPowerChartView(date: viewModel.date,+                                                  readings: viewModel.parsedReadings)+                        }+                    }+                    FluxPanel {+                        VStack(alignment: .leading, spacing: 0) {+                            FluxPanelHeader(label: "State of Charge", right: "%")+                            SOCChartView(date: viewModel.date,+                                         readings: viewModel.parsedReadings,+                                         summary: viewModel.summary)+                        }+                    }+                } else {+                    DayDetailMessagePanel(title: "Power charts unavailable",+                                          detail: "This day has fallback data with SOC readings only.")+                    DayDetailPanels.battery(date: viewModel.date,+                                            readings: viewModel.parsedReadings,+                                            summary: viewModel.summary,+                                            selectedDate: $batterySelected)+                }+            } else if let error = viewModel.error {+                DayDetailErrorPanel(error: error,+                                    showingSettings: $showingSettings,+                                    onRetry: { Task { await viewModel.loadDay() } })+            } else if viewModel.isLoading {+                FluxPanel {+                    HStack {+                        Spacer()+                        ProgressView("Loading day data…")+                            .tint(FluxTheme.Palette.primaryText)+                        Spacer()+                    }+                }+            }+        }+    }++    @ViewBuilder+    private var summaryBlock: some View {+        SummaryBlock(+            title: "Power",+            trailing: trailingSummaryDate,+            summary: viewModel.summary,+            // Prefer the canonical server value (DaySummary now carries it+            // for any date with an off-peak record); fall back to the+            // readings-derived approximation when the server hasn't returned+            // a split.+            offpeakGridImport: viewModel.summary?.offpeakGridImportKwh ?? viewModel.offpeakStats.gridImportKwh,+            showsBatteryCycle: false,+            compare: viewModel.comparisonState+        )+    }++    @ViewBuilder+    private var batteryBlock: some View {+        BatteryBlock(+            batteryCharge: viewModel.summary?.eCharge,+            batteryDischarge: viewModel.summary?.eDischarge,+            lowestSOC: viewModel.offpeakStats.lowestSOC,+            lowestSOCTimestamp: viewModel.offpeakStats.lowestSOCTimestamp+        )+    }+     @ViewBuilder     private var header: some View {         if let tabBinding {@@ -238,11 +349,28 @@ struct DayDetailView: View {     }  }+// swiftlint:enable type_body_length  #if DEBUG-#Preview {+#Preview("Compact") {+    NavigationStack {+        DayDetailView(date: MockFluxAPIClient.previewDate, apiClient: MockFluxAPIClient.preview)+    }+}++#Preview("Regular 770") {+    NavigationStack {+        DayDetailView(date: MockFluxAPIClient.previewDate, apiClient: MockFluxAPIClient.preview)+    }+    .frame(width: 770)+    .environment(\.horizontalSizeClass, .regular)+}++#Preview("Regular 1080") {     NavigationStack {         DayDetailView(date: MockFluxAPIClient.previewDate, apiClient: MockFluxAPIClient.preview)     }+    .frame(width: 1080)+    .environment(\.horizontalSizeClass, .regular) } #endif

diff --git a/Flux/Flux/Dashboard/DashboardView.swift b/Flux/Flux/Dashboard/DashboardView.swiftindex b8b89b7..e3ec9c6 100644--- a/Flux/Flux/Dashboard/DashboardView.swift+++ b/Flux/Flux/Dashboard/DashboardView.swift@@ -7,6 +7,7 @@ import SwiftUI /// the panels below. struct DashboardView: View {     @Environment(\.scenePhase) private var scenePhase+    @Environment(\.horizontalSizeClass) private var hSizeClass     @State private var viewModel: DashboardViewModel     @State private var showingSettings = false @@ -87,60 +88,106 @@ struct DashboardView: View {     @ViewBuilder     private var contentContainer: some View {         ScrollView {-            dashboardContent+            if usesRegularLayout {+                dashboardContentRegular+            } else {+                dashboardContent+            }         }         .scrollContentBackground(.hidden)         .scrollBounceBehavior(.basedOnSize)     } +    private var usesRegularLayout: Bool { IPadLayoutGate.isActive(hSizeClass: hSizeClass) }+     @ViewBuilder     private var dashboardContent: some View {         VStack(alignment: .leading, spacing: FluxTheme.Metrics.panelGap) {-            if let tabBinding {-                FluxScreenHeader(-                    selection: tabBinding,-                    onSettingsTap: onSettingsTap,-                    onTabActivate: onTabActivate-                )-            } else {-                legacyHeader+            headerSection+            if viewModel.error != nil {+                stalenessBanner             }+            heroPanel+            trioPanel+            summaryPanel+            batteryPanel+        }+        .padding(.horizontal, FluxTheme.Metrics.screenHorizontalPadding)+        .padding(.bottom, FluxTheme.Metrics.screenBottomPadding)+    } +    @ViewBuilder+    private var dashboardContentRegular: some View {+        VStack(alignment: .leading, spacing: FluxTheme.Metrics.panelGap) {+            headerSection             if viewModel.error != nil {                 stalenessBanner             }+            AdaptiveColumnsLayout {+                heroPanel+                trioPanel+            }+            summaryPanel+            AdaptiveColumnsLayout {+                batteryPanel+            }+        }+        .padding(.horizontal, FluxTheme.Metrics.screenHorizontalPadding)+        .padding(.bottom, FluxTheme.Metrics.screenBottomPadding)+    } -            DashboardHeroPanel(-                live: viewModel.status?.live,-                rolling15min: viewModel.status?.rolling15min+    @ViewBuilder+    private var headerSection: some View {+        if let tabBinding {+            FluxScreenHeader(+                selection: tabBinding,+                onSettingsTap: onSettingsTap,+                onTabActivate: onTabActivate             )+        } else {+            legacyHeader+        }+    } -            LiveTrioPanel(live: viewModel.status?.live)+    @ViewBuilder+    private var heroPanel: some View {+        DashboardHeroPanel(+            live: viewModel.status?.live,+            rolling15min: viewModel.status?.rolling15min+        )+    } -            SummaryBlock(-                todayEnergy: viewModel.status?.todayEnergy,-                offpeakGridImport: viewModel.status?.offpeak?.gridUsageKwh,-                showsBatteryCycle: false,-                avgLoadWatts: viewModel.status?.rolling15min?.avgLoad-            )+    @ViewBuilder+    private var trioPanel: some View {+        LiveTrioPanel(live: viewModel.status?.live)+    } -            // `low24h` tracks the lowest SoC since the last off-peak end-            // (per T-1084) — the existing "lowest since charged" signal-            // the V4 dashboard surfaced.-            BatteryBlock(-                title: nil,-                batteryCharge: viewModel.status?.todayEnergy?.eCharge,-                batteryDischarge: viewModel.status?.todayEnergy?.eDischarge,-                lowestSOC: viewModel.status?.battery?.low24h?.soc,-                lowestSOCTimestamp: (viewModel.status?.battery?.low24h?.timestamp)-                    .flatMap(DateFormatting.parseTimestamp),-                offpeakBatteryDeltaPercent: viewModel.status?.offpeak?.batteryDeltaPercent,-                showsOffpeakDelta: true,-                energyLeftKwh: energyLeftKwh-            )-        }-        .padding(.horizontal, FluxTheme.Metrics.screenHorizontalPadding)-        .padding(.bottom, FluxTheme.Metrics.screenBottomPadding)+    @ViewBuilder+    private var summaryPanel: some View {+        SummaryBlock(+            todayEnergy: viewModel.status?.todayEnergy,+            offpeakGridImport: viewModel.status?.offpeak?.gridUsageKwh,+            showsBatteryCycle: false,+            avgLoadWatts: viewModel.status?.rolling15min?.avgLoad+        )+    }++    // `low24h` tracks the lowest SoC since the last off-peak end (per+    // T-1084) — the existing "lowest since charged" signal the V4+    // dashboard surfaced.+    @ViewBuilder+    private var batteryPanel: some View {+        BatteryBlock(+            title: nil,+            batteryCharge: viewModel.status?.todayEnergy?.eCharge,+            batteryDischarge: viewModel.status?.todayEnergy?.eDischarge,+            lowestSOC: viewModel.status?.battery?.low24h?.soc,+            lowestSOCTimestamp: (viewModel.status?.battery?.low24h?.timestamp)+                .flatMap(DateFormatting.parseTimestamp),+            offpeakBatteryDeltaPercent: viewModel.status?.offpeak?.batteryDeltaPercent,+            showsOffpeakDelta: true,+            energyLeftKwh: energyLeftKwh+        )     }      private var energyLeftKwh: Double? {@@ -242,7 +289,13 @@ private enum DashboardEyebrowFormatter { }  #if DEBUG-#Preview {+#Preview("Compact") {+    DashboardView(apiClient: MockFluxAPIClient.preview)+}++#Preview("Regular 770") {     DashboardView(apiClient: MockFluxAPIClient.preview)+        .frame(width: 770)+        .environment(\.horizontalSizeClass, .regular) } #endif

diff --git a/Flux/Flux/History/HistoryView.swift b/Flux/Flux/History/HistoryView.swiftindex 11ddf20..40c681e 100644--- a/Flux/Flux/History/HistoryView.swift+++ b/Flux/Flux/History/HistoryView.swift@@ -2,7 +2,9 @@ import FluxCore import SwiftData import SwiftUI +// swiftlint:disable type_body_length struct HistoryView: View {+    @Environment(\.horizontalSizeClass) private var hSizeClass     @State private var viewModel: HistoryViewModel     @State private var selectedRange: Int = 7     @State private var showingSettings = false@@ -68,47 +70,11 @@ struct HistoryView: View {                 } else if viewModel.days.isEmpty, !viewModel.isLoading {                     emptyState                 } else {-                    let derived = viewModel.derived-                    let selectedDate = viewModel.selectedDay-                        .flatMap { DateFormatting.parseDayDate($0.date) }--                    VStack(alignment: .leading, spacing: 16) {-                        HistoryStatsOverviewCard(-                            summary: derived.summary,-                            entries: derived.solar,-                            onSelect: selectDay-                        )--                        HistorySolarCard(-                            entries: derived.solar,-                            summary: derived.summary,-                            selectedDate: selectedDate,-                            rangeDays: selectedRange,-                            onSelect: selectDay-                        )--                        HistoryGridUsageCard(-                            entries: derived.grid,-                            summary: derived.summary,-                            selectedDate: selectedDate,-                            rangeDays: selectedRange,-                            onSelect: selectDay-                        )--                        HistoryDailyUsageCard(-                            entries: derived.dailyUsage,-                            summary: derived.summary,-                            selectedDate: selectedDate,-                            rangeDays: selectedRange,-                            onSelect: selectDay-                        )--                        if let selectedDay = viewModel.selectedDay {-                            summaryCard(for: selectedDay)-                        }+                    if usesRegularLayout {+                        historyContentRegular+                    } else {+                        historyContent                     }-                    .opacity(viewModel.isLoading ? 0.5 : 1.0)-                    .animation(.easeInOut(duration: 0.15), value: viewModel.isLoading)                 }             }             .padding(.horizontal, FluxTheme.Metrics.screenHorizontalPadding)@@ -162,6 +128,86 @@ struct HistoryView: View {         #endif     } +    private var usesRegularLayout: Bool { IPadLayoutGate.isActive(hSizeClass: hSizeClass) }++    @ViewBuilder+    private var historyContent: some View {+        let derived = viewModel.derived+        let selectedDate = viewModel.selectedDay.flatMap { DateFormatting.parseDayDate($0.date) }+        VStack(alignment: .leading, spacing: 16) {+            statsOverviewCard(derived: derived)+            solarCard(derived: derived, selectedDate: selectedDate)+            gridUsageCard(derived: derived, selectedDate: selectedDate)+            dailyUsageCard(derived: derived, selectedDate: selectedDate)+            if let selectedDay = viewModel.selectedDay {+                summaryCard(for: selectedDay)+            }+        }+        .opacity(viewModel.isLoading ? 0.5 : 1.0)+        .animation(.easeInOut(duration: 0.15), value: viewModel.isLoading)+    }++    @ViewBuilder+    private var historyContentRegular: some View {+        let derived = viewModel.derived+        let selectedDate = viewModel.selectedDay.flatMap { DateFormatting.parseDayDate($0.date) }+        VStack(alignment: .leading, spacing: 16) {+            statsOverviewCard(derived: derived)+            AdaptiveColumnsLayout {+                solarCard(derived: derived, selectedDate: selectedDate)+                gridUsageCard(derived: derived, selectedDate: selectedDate)+                dailyUsageCard(derived: derived, selectedDate: selectedDate)+                if let selectedDay = viewModel.selectedDay {+                    summaryCard(for: selectedDay)+                }+            }+        }+        .opacity(viewModel.isLoading ? 0.5 : 1.0)+        .animation(.easeInOut(duration: 0.15), value: viewModel.isLoading)+    }++    @ViewBuilder+    private func statsOverviewCard(derived: HistoryViewModel.DerivedState) -> some View {+        HistoryStatsOverviewCard(+            summary: derived.summary,+            entries: derived.solar,+            onSelect: selectDay+        )+    }++    @ViewBuilder+    private func solarCard(derived: HistoryViewModel.DerivedState, selectedDate: Date?) -> some View {+        HistorySolarCard(+            entries: derived.solar,+            summary: derived.summary,+            selectedDate: selectedDate,+            rangeDays: selectedRange,+            onSelect: selectDay+        )+    }++    @ViewBuilder+    private func gridUsageCard(derived: HistoryViewModel.DerivedState, selectedDate: Date?) -> some View {+        HistoryGridUsageCard(+            entries: derived.grid,+            summary: derived.summary,+            selectedDate: selectedDate,+            rangeDays: selectedRange,+            onSelect: selectDay+        )+    }++    @ViewBuilder+    private func dailyUsageCard(derived: HistoryViewModel.DerivedState, selectedDate: Date?) -> some View {+        HistoryDailyUsageCard(+            entries: derived.dailyUsage,+            summary: derived.summary,+            selectedDate: selectedDate,+            rangeDays: selectedRange,+            onSelect: selectDay+        )+    }+     private func selectDay(_ dayID: String) {         if let day = viewModel.days.first(where: { $0.date == dayID }) {             viewModel.selectDay(day)@@ -253,6 +299,8 @@ struct HistoryView: View {     } } +// swiftlint:enable type_body_length+ enum HistoryRoute: Hashable {     case dayDetail(String) }@@ -267,12 +315,23 @@ private enum HistorySummaryDateFormatter { }  #if DEBUG-#Preview {+#Preview("Compact") {+    let configuration = ModelConfiguration(isStoredInMemoryOnly: true)+    // swiftlint:disable:next force_try+    let container = try! ModelContainer(for: CachedDayEnergy.self, configurations: configuration)+    NavigationStack {+        HistoryView(apiClient: MockFluxAPIClient.preview, modelContext: ModelContext(container))+    }+}++#Preview("Regular 770") {     let configuration = ModelConfiguration(isStoredInMemoryOnly: true)     // swiftlint:disable:next force_try     let container = try! ModelContainer(for: CachedDayEnergy.self, configurations: configuration)     NavigationStack {         HistoryView(apiClient: MockFluxAPIClient.preview, modelContext: ModelContext(container))     }+    .frame(width: 770)+    .environment(\.horizontalSizeClass, .regular) } #endif

diff --git a/Flux/Flux/Settings/SettingsView.swift b/Flux/Flux/Settings/SettingsView.swiftindex 9658bfb..b6946dc 100644--- a/Flux/Flux/Settings/SettingsView.swift+++ b/Flux/Flux/Settings/SettingsView.swift@@ -4,6 +4,7 @@ import SwiftUI @MainActor struct SettingsView: View {     @Environment(\.dismiss) private var dismiss+    @Environment(\.horizontalSizeClass) private var hSizeClass     @State private var viewModel: SettingsViewModel     @State private var showingManualWhatsNew = false     @State private var manualWhatsNewRelease: WhatsNewRelease?@@ -25,6 +26,7 @@ struct SettingsView: View {             macOSForm             #else             iOSForm+                .modifier(IPadFormWidthCap(hSizeClass: hSizeClass))             #endif         }         .onAppear {@@ -308,6 +310,28 @@ struct LiquidGlassSection<Content: View>: View { } #endif +#if !os(macOS)+/// Caps the Settings form to a comfortable 640pt reading width on iPad+/// regular size class. The double-frame trick centers the capped content+/// inside the full sheet width. At compact size class the modifier is a+/// no-op so iPhone retains the existing edge-to-edge form.+private struct IPadFormWidthCap: ViewModifier {+    let hSizeClass: UserInterfaceSizeClass?++    func body(content: Content) -> some View {+        if shouldApply {+            content+                .frame(maxWidth: 640)+                .frame(maxWidth: .infinity)+        } else {+            content+        }+    }++    private var shouldApply: Bool { IPadLayoutGate.isActive(hSizeClass: hSizeClass) }+}+#endif+ #Preview {     NavigationStack {         SettingsView()

diff --git a/Flux/FluxTests/AdaptiveColumnsLayoutTests.swift b/Flux/FluxTests/AdaptiveColumnsLayoutTests.swiftnew file mode 100644index 0000000..27d47d8--- /dev/null+++ b/Flux/FluxTests/AdaptiveColumnsLayoutTests.swift@@ -0,0 +1,59 @@+import SwiftUI+import Testing+@testable import Flux++@MainActor+struct AdaptiveColumnsLayoutTests {+    @Test+    func widthBelow700ReturnsSingleColumn() {+        let layout = AdaptiveColumnsLayout { EmptyView() }+        #expect(layout.columnCount(width: 699, typeSize: .large) == 1)+        #expect(layout.columnCount(width: 0, typeSize: .large) == 1)+    }++    @Test+    func widthAt700ReturnsTwoColumns() {+        let layout = AdaptiveColumnsLayout { EmptyView() }+        #expect(layout.columnCount(width: 700, typeSize: .large) == 2)+    }++    @Test+    func widthBelow1000ReturnsTwoColumns() {+        let layout = AdaptiveColumnsLayout { EmptyView() }+        #expect(layout.columnCount(width: 999, typeSize: .large) == 2)+    }++    @Test+    func widthAt1000ReturnsThreeColumns() {+        let layout = AdaptiveColumnsLayout { EmptyView() }+        #expect(layout.columnCount(width: 1000, typeSize: .large) == 3)+    }++    @Test+    func wideWidthStaysAtThreeColumns() {+        let layout = AdaptiveColumnsLayout { EmptyView() }+        #expect(layout.columnCount(width: 1600, typeSize: .large) == 3)+    }++    @Test+    func accessibility3KeepsBaseColumns() {+        let layout = AdaptiveColumnsLayout { EmptyView() }+        #expect(layout.columnCount(width: 700, typeSize: .accessibility3) == 2)+        #expect(layout.columnCount(width: 1000, typeSize: .accessibility3) == 3)+    }++    @Test+    func accessibility4DropsOneColumn() {+        let layout = AdaptiveColumnsLayout { EmptyView() }+        #expect(layout.columnCount(width: 700, typeSize: .accessibility4) == 1)+        #expect(layout.columnCount(width: 1000, typeSize: .accessibility4) == 2)+    }++    @Test+    func accessibility5DropsOneColumnAndNeverGoesBelowOne() {+        let layout = AdaptiveColumnsLayout { EmptyView() }+        #expect(layout.columnCount(width: 500, typeSize: .accessibility5) == 1)+        #expect(layout.columnCount(width: 700, typeSize: .accessibility5) == 1)+        #expect(layout.columnCount(width: 1000, typeSize: .accessibility5) == 2)+    }+}

diff --git a/Flux/FluxTests/ScreenTests.swift b/Flux/FluxTests/ScreenTests.swiftnew file mode 100644index 0000000..b85fced--- /dev/null+++ b/Flux/FluxTests/ScreenTests.swift@@ -0,0 +1,46 @@+import Testing+@testable import Flux++struct ScreenTests {+    @Test+    func everyFluxTabRoundTripsThroughScreen() {+        for tab in FluxTab.allCases {+            let screen = Screen(tab: tab)+            #expect(screen.tab == tab, "Screen(tab: \(tab)).tab should equal \(tab)")+        }+    }++    @Test+    func dashboardTabMapsToDashboardScreen() {+        #expect(Screen(tab: .dashboard) == .dashboard)+    }++    @Test+    func todayTabMapsToTodayScreen() {+        #expect(Screen(tab: .today) == .today)+    }++    @Test+    func historyTabMapsToHistoryScreen() {+        #expect(Screen(tab: .history) == .history)+    }++    @Test+    func sidebarVisibleExcludesSettings() {+        #expect(!Screen.sidebarVisible.contains(.settings))+    }++    #if !os(macOS)+    @Test+    func sidebarVisibleOnIOSIncludesDashboardTodayHistory() {+        #expect(Screen.sidebarVisible == [.dashboard, .today, .history])+    }+    #endif++    #if os(macOS)+    @Test+    func sidebarVisibleOnMacOSIncludesDashboardTodayHistory() {+        #expect(Screen.sidebarVisible == [.dashboard, .today, .history])+    }+    #endif+}

diff --git a/Flux/FluxTests/SidebarTabSyncTests.swift b/Flux/FluxTests/SidebarTabSyncTests.swiftnew file mode 100644index 0000000..f20b56c--- /dev/null+++ b/Flux/FluxTests/SidebarTabSyncTests.swift@@ -0,0 +1,95 @@+import Testing+@testable import Flux++struct SidebarTabSyncTests {+    // MARK: - mappedIosTab++    @Test+    func mappedIosTabReturnsMappedTabWhenSelectedHasOne() {+        for tab in FluxTab.allCases {+            let screen = Screen(tab: tab)+            #expect(mappedIosTab(for: screen, currentTab: .dashboard) == tab)+        }+    }++    @Test+    func mappedIosTabReturnsCurrentTabWhenSelectedIsNil() {+        #expect(mappedIosTab(for: nil, currentTab: .history) == .history)+        #expect(mappedIosTab(for: nil, currentTab: .today) == .today)+    }++    @Test+    func mappedIosTabReturnsCurrentTabWhenSelectedIsSettings() {+        // .settings has no FluxTab counterpart — keep the user's current tab+        // so flipping to Settings doesn't knock the tab bar to .dashboard.+        #expect(mappedIosTab(for: .settings, currentTab: .history) == .history)+    }++    // MARK: - mappedSelectedScreen++    @Test+    func mappedSelectedScreenReturnsCanonicalScreenForTab() {+        for tab in FluxTab.allCases {+            #expect(mappedSelectedScreen(for: tab, currentSelection: nil) == Screen(tab: tab))+        }+    }++    @Test+    func mappedSelectedScreenPreservesSettings() {+        #expect(mappedSelectedScreen(for: .history, currentSelection: .settings) == .settings)+        #expect(mappedSelectedScreen(for: .dashboard, currentSelection: .settings) == .settings)+    }++    @Test+    func mappedSelectedScreenIsIdempotentWhenSelectionAlreadyMatches() {+        for tab in FluxTab.allCases {+            let screen = Screen(tab: tab)+            #expect(mappedSelectedScreen(for: tab, currentSelection: screen) == screen)+        }+    }++    // MARK: - Two-handler convergence++    @Test+    func handlersConvergeOnSidebarClick() {+        // Sidebar click: selectedScreen → .dashboard from prior (.history, .history).+        // The selectedScreen handler writes iosTab; the iosTab handler then writes+        // selectedScreen but the value already matches so no further write.+        var selected: Screen? = .dashboard+        var tab: FluxTab = .history++        // Handler 1: selectedScreen change.+        tab = mappedIosTab(for: selected, currentTab: tab)+        #expect(tab == .dashboard)++        // Handler 2: iosTab change (fired by the write above).+        let next = mappedSelectedScreen(for: tab, currentSelection: selected)+        if next != selected { selected = next }+        #expect(selected == .dashboard)+    }++    @Test+    func handlersConvergeOnTabTap() {+        // Tab tap: iosTab → .history from prior (.dashboard, .dashboard).+        var selected: Screen? = .dashboard+        var tab: FluxTab = .history++        // Handler 2: iosTab change.+        selected = mappedSelectedScreen(for: tab, currentSelection: selected)+        #expect(selected == .history)++        // Handler 1: selectedScreen change.+        let nextTab = mappedIosTab(for: selected, currentTab: tab)+        if nextTab != tab { tab = nextTab }+        #expect(tab == .history)+    }++    @Test+    func everyFluxTabScreenPairRoundTrips() {+        for tab in FluxTab.allCases {+            let screen = Screen(tab: tab)+            #expect(mappedIosTab(for: screen, currentTab: tab) == tab)+            #expect(mappedSelectedScreen(for: tab, currentSelection: screen) == screen)+        }+    }+}

diff --git a/Flux/FluxTests/DayDetailViewModelSetDateTests.swift b/Flux/FluxTests/DayDetailViewModelSetDateTests.swiftnew file mode 100644index 0000000..a0fb1db--- /dev/null+++ b/Flux/FluxTests/DayDetailViewModelSetDateTests.swift@@ -0,0 +1,127 @@+import FluxCore+import Foundation+import Testing+@testable import Flux++@MainActor @Suite(.serialized)+struct DayDetailViewModelSetDateTests {+    @Test+    func setDateWithSameDateIsNoOp() async {+        let apiClient = SetDateMockAPIClient()+        apiClient.dayResult = .success(DayDetailResponse(+            date: "2026-04-15", readings: [], summary: nil, peakPeriods: nil, dailyUsage: nil+        ))+        let viewModel = DayDetailViewModel(date: "2026-04-15", apiClient: apiClient)+        await viewModel.loadDay()+        let initialCount = apiClient.fetchDayCount++        await viewModel.setDate("2026-04-15")++        #expect(apiClient.fetchDayCount == initialCount, "setDate with current date should not call the API")+        #expect(viewModel.date == "2026-04-15")+    }++    @Test+    func setDateCallsLoadDayExactlyOnce() async {+        let apiClient = SetDateMockAPIClient()+        apiClient.dayResultsByDate["2026-04-15"] = .success(DayDetailResponse(+            date: "2026-04-15", readings: [], summary: nil, peakPeriods: nil, dailyUsage: nil+        ))+        apiClient.dayResultsByDate["2026-04-16"] = .success(DayDetailResponse(+            date: "2026-04-16", readings: [], summary: nil, peakPeriods: nil, dailyUsage: nil+        ))+        let viewModel = DayDetailViewModel(date: "2026-04-15", apiClient: apiClient)+        await viewModel.loadDay()+        let countAfterFirstLoad = apiClient.fetchDayCount++        await viewModel.setDate("2026-04-16")++        #expect(apiClient.fetchDayCount == countAfterFirstLoad + 1)+        #expect(apiClient.fetchDayDates.last == "2026-04-16")+        #expect(viewModel.date == "2026-04-16")+    }++    @Test+    func setDateClearsPerDayFieldsBeforeReload() async {+        let apiClient = SetDateMockAPIClient()+        let readings = [TimeSeriesPoint(+            timestamp: "2026-04-15T00:00:00Z",+            ppv: 1200, pload: 500, pbat: -300, pgrid: -400, soc: 72+        )]+        let summary = DaySummary(+            epv: 8.2, eInput: 1.3, eOutput: 0.7, eCharge: 2.4, eDischarge: 3.6,+            socLow: 21, socLowTime: "2026-04-15T20:00:00Z"+        )+        let peaks = [PeakPeriod(start: "17:00", end: "18:00", avgLoadW: 3200, energyWh: 3200)]+        let dailyUsage = DailyUsage(blocks: [+            DailyUsageBlock(+                kind: .evening,+                start: "2026-04-15T08:30:00Z",+                end: "2026-04-15T14:00:00Z",+                totalKwh: 4.2,+                averageKwhPerHour: 0.85,+                percentOfDay: 50,+                status: .complete,+                boundarySource: .readings+            )+        ])+        apiClient.dayResultsByDate["2026-04-15"] = .success(DayDetailResponse(+            date: "2026-04-15",+            readings: readings,+            summary: summary,+            peakPeriods: peaks,+            dailyUsage: dailyUsage,+            note: "Day note"+        ))+        apiClient.dayResultsByDate["2026-04-16"] = .success(DayDetailResponse(+            date: "2026-04-16", readings: [], summary: nil, peakPeriods: nil, dailyUsage: nil+        ))++        let viewModel = DayDetailViewModel(date: "2026-04-15", apiClient: apiClient)+        await viewModel.loadDay()+        #expect(!viewModel.readings.isEmpty)+        #expect(viewModel.summary != nil)+        #expect(!viewModel.peakPeriods.isEmpty)+        #expect(viewModel.dailyUsage != nil)+        #expect(viewModel.note == "Day note")++        await viewModel.setDate("2026-04-16")++        #expect(viewModel.readings.isEmpty)+        #expect(viewModel.parsedReadings.isEmpty)+        #expect(viewModel.summary == nil)+        #expect(viewModel.peakPeriods.isEmpty)+        #expect(viewModel.dailyUsage == nil)+        #expect(viewModel.note == nil)+        #expect(viewModel.offpeakStats == .empty)+        #expect(viewModel.comparisonState == .off)+    }+}++private final class SetDateMockAPIClient: FluxAPIClient, @unchecked Sendable {+    var dayResult: Result<DayDetailResponse, Error> = .failure(FluxAPIError.notConfigured)+    var dayResultsByDate: [String: Result<DayDetailResponse, Error>] = [:]+    private(set) var fetchDayCount = 0+    private(set) var fetchDayDates: [String] = []++    func fetchStatus() async throws -> StatusResponse {+        throw FluxAPIError.notConfigured+    }++    func fetchHistory(days _: Int) async throws -> HistoryResponse {+        throw FluxAPIError.notConfigured+    }++    func fetchDay(date: String) async throws -> DayDetailResponse {+        fetchDayCount += 1+        fetchDayDates.append(date)+        if let result = dayResultsByDate[date] {+            return try result.get()+        }+        return try dayResult.get()+    }++    func saveNote(date _: String, text _: String) async throws -> NoteResponse {+        throw FluxAPIError.notConfigured+    }+}

diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 1f05952..61f8d8b 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -6,6 +6,14 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).  ## [Unreleased] +### Added++- **iPad adaptive layout** (T-1150). At regular horizontal size class on iPad — full-screen and ≥½ Split View on any iPad in the lineup — Flux now renders a `NavigationSplitView(.balanced)` with a Dashboard / Today / History sidebar and a detail column hosting the selected screen. Settings stays as a sheet, opened via a toolbar gear in the detail column. The three screens reflow into multi-column arrangements via a new `AdaptiveColumnsLayout` helper: Dashboard puts the battery hero and live trio side by side and reflows Summary / Battery (+ future blocks) through 2-col (≥ 700pt) or 3-col (≥ 1000pt) grids; History keeps the full-width stats overview on top and grids the Solar / Grid Usage / Daily Usage / selected-day summary cards; Day Detail switches to a two-column Grid with summary panels (Day-in-Five-Blocks, Summary, Battery, Daily Usage, Peak Usage) on the left and three stacked chart panels (Power, Battery Power, State of Charge) on the right, with the day navigation header, note section, and Compare control full width above the columns. The grid drops one column at Dynamic Type ≥ AX4 so cards retain a readable per-column width. The Settings sheet on iPad regular is capped to a 640pt-wide column centred in the sheet so form rows are not stretched edge-to-edge. At compact widths (Slide Over, ⅓ Split View) iPad falls back to the existing tab-bar shell, and iPhone Plus/Max landscape (which reports `.regular` horizontal but is not iPad) stays on the tab-bar shell via a `userInterfaceIdiom == .pad` gate. iPhone and macOS layouts are unchanged.++### Documentation++- **iPad adaptive layout spec** (T-1150). Implementation spec for swapping the stretched iPhone V5 shell on iPad for a `NavigationSplitView(.balanced)` sidebar at regular size class, with compact widths (Slide Over / narrow Split View) falling back to the existing tab-bar shell. Covers Dashboard / History / Day Detail multi-column layouts above 700 / 1000 pt detail widths, midnight rollover on the Today entry via a new `DayDetailViewModel.setDate(_:)`, and a `userInterfaceIdiom == .pad && hSizeClass == .regular` gate so iPhone Plus/Max landscape stays on the iPhone shell. See `specs/ipad-adaptive-layout/`.+ ## [1.3] - 2026-05-21  ### Added