@sriinnu/runic 1.0.0

package/Sources/Runic/Controllers/StatusItemController+Menu.swift

@@ -0,0 +1,1379 @@
+import AppKit
+import RunicCore
+import Observation
+import SwiftUI
+
+// MARK: - NSMenu construction
+
+extension StatusItemController {
+    static let menuCardBaseWidth: CGFloat = 310
+    private static let menuOpenPingDelay: Duration = PerformanceConstants.menuOpenPingDelay
+
+    func menuCardWidth(for providers: [UsageProvider], menu: NSMenu? = nil) -> CGFloat {
+        _ = menu
+        let baseWidth = Self.menuCardBaseWidth
+        guard self.usesSidebarSwitcher(for: providers) else { return baseWidth }
+        return baseWidth + MenuCardSidebarMetrics.sidebarWidth(
+            for: providers.count,
+            iconSize: self.settings.providerSwitcherIconSize)
+    }
+
+    func usesSidebarSwitcher(for providers: [UsageProvider]) -> Bool {
+        guard self.shouldMergeIcons, providers.count > 1 else { return false }
+        return self.settings.providerSwitcherLayout == .sidebar
+    }
+
+    func makeMenu() -> NSMenu {
+        guard self.shouldMergeIcons else {
+            return self.makeMenu(for: nil)
+        }
+        let menu = NSMenu()
+        menu.autoenablesItems = false
+        menu.delegate = self
+        return menu
+    }
+
+    func menuWillOpen(_ menu: NSMenu) {
+        if self.isHostedSubviewMenu(menu) {
+            self.refreshHostedSubviewHeights(in: menu)
+            self.openMenus[ObjectIdentifier(menu)] = menu
+            return
+        }
+        if menu.supermenu != nil {
+            return
+        }
+
+        var provider: UsageProvider?
+        if self.shouldMergeIcons {
+            self.selectedMenuProvider = self.resolvedMenuProvider()
+            self.lastMenuProvider = self.selectedMenuProvider ?? .codex
+            provider = self.selectedMenuProvider
+        } else {
+            if let menuProvider = self.menuProviders[ObjectIdentifier(menu)] {
+                self.lastMenuProvider = menuProvider
+                provider = menuProvider
+            } else if menu === self.fallbackMenu {
+                self.lastMenuProvider = self.store.enabledProviders().first ?? .codex
+                provider = nil
+            } else {
+                let resolved = self.store.enabledProviders().first ?? .codex
+                self.lastMenuProvider = resolved
+                provider = resolved
+            }
+        }
+
+        if self.menuNeedsRefresh(menu) {
+            self.populateMenu(menu, provider: provider)
+            self.markMenuFresh(menu)
+        }
+        self.refreshMenuCardHeights(in: menu)
+        self.openMenus[ObjectIdentifier(menu)] = menu
+        self.scheduleOpenMenuPing(for: menu)
+    }
+
+    func menuDidClose(_ menu: NSMenu) {
+        self.openMenus.removeValue(forKey: ObjectIdentifier(menu))
+        self.menuPingTasks.removeValue(forKey: ObjectIdentifier(menu))?.cancel()
+        for menuItem in menu.items {
+            (menuItem.view as? MenuCardHighlighting)?.setHighlighted(false)
+        }
+    }
+
+    func menu(_ menu: NSMenu, willHighlight item: NSMenuItem?) {
+        for menuItem in menu.items {
+            let highlighted = menuItem == item && menuItem.isEnabled
+            (menuItem.view as? MenuCardHighlighting)?.setHighlighted(highlighted)
+        }
+    }
+
+    func populateMenu(_ menu: NSMenu, provider: UsageProvider?) {
+        menu.removeAllItems()
+
+        let selectedProvider = provider
+        let enabledProviders = self.store.enabledProviders()
+        let menuWidth = self.menuCardWidth(for: enabledProviders, menu: menu)
+        let descriptor = MenuDescriptor.build(
+            provider: selectedProvider,
+            store: self.store,
+            settings: self.settings,
+            account: self.account,
+            updateReady: self.updater.updateStatus.isUpdateReady)
+        let dashboard = self.store.openAIDashboard
+        let currentProvider = selectedProvider ?? enabledProviders.first ?? .codex
+        let openAIWebEligible = currentProvider == .codex &&
+            self.store.openAIDashboardRequiresLogin == false &&
+            dashboard != nil
+        let hasCreditsHistory = openAIWebEligible && !(dashboard?.dailyBreakdown ?? []).isEmpty
+        let hasUsageBreakdown = openAIWebEligible && !(dashboard?.usageBreakdown ?? []).isEmpty
+        let hasCostHistory = self.settings.isCostUsageEffectivelyEnabled(for: currentProvider) &&
+            (self.store.tokenSnapshot(for: currentProvider)?.daily.isEmpty == false)
+        let hasOpenAIWebMenuItems = hasCreditsHistory || hasUsageBreakdown || hasCostHistory
+        var addedOpenAIWebItems = false
+
+        let useSidebarSwitcher = self.usesSidebarSwitcher(for: enabledProviders)
+        let sidebarConfig: MenuCardSidebarConfig? = if useSidebarSwitcher {
+            MenuCardSidebarConfig(
+                providers: enabledProviders,
+                selected: selectedProvider,
+                iconProvider: { [weak self] provider, iconSize in
+                    self?.switcherIcon(for: provider, size: iconSize) ?? NSImage()
+                },
+                weeklyRemainingProvider: { [weak self] provider in
+                    self?.switcherWeeklyRemaining(for: provider)
+                },
+                onSelect: { [weak self, weak menu] provider in
+                    guard let self, let menu else { return }
+                    self.selectedMenuProvider = provider
+                    self.lastMenuProvider = provider
+                    // Defer repopulation to avoid reentrancy: the SwiftUI button
+                    // that triggered this closure lives inside the menu item that
+                    // populateMenu will destroy via removeAllItems().
+                    Task { @MainActor [weak self, weak menu] in
+                        guard let self, let menu else { return }
+                        self.populateMenu(menu, provider: provider)
+                        self.markMenuFresh(menu)
+                        self.refreshMenuCardHeights(in: menu)
+                        self.applyIcon(phase: nil)
+                    }
+                })
+        } else {
+            nil
+        }
+
+        if self.shouldMergeIcons, enabledProviders.count > 1, !useSidebarSwitcher {
+            // Provider tab bar (Feature 6) — replaces plain switcher when available
+            let tabBarView = self.makeProviderTabBar(
+                providers: enabledProviders,
+                selected: selectedProvider,
+                width: menuWidth,
+                menu: menu)
+            if let tabBarView {
+                let hosting = MenuHostingView(rootView: tabBarView)
+                let controller = NSHostingController(rootView: tabBarView)
+                let size = controller.sizeThatFits(in: CGSize(width: menuWidth, height: .greatestFiniteMagnitude))
+                hosting.frame = NSRect(origin: .zero, size: NSSize(width: menuWidth, height: size.height))
+                let tabItem = NSMenuItem()
+                tabItem.view = hosting
+                tabItem.isEnabled = false
+                tabItem.representedObject = "providerTabBar"
+                menu.addItem(tabItem)
+            } else {
+                let switcherItem = self.makeProviderSwitcherItem(
+                    providers: enabledProviders,
+                    selected: selectedProvider,
+                    menu: menu)
+                menu.addItem(switcherItem)
+            }
+            menu.addItem(.separator())
+        }
+
+        // Overview tab — show all providers at a glance
+        if selectedProvider == nil, enabledProviders.count > 1 {
+            let overviewView = self.makeOverviewView(
+                providers: enabledProviders,
+                width: menuWidth)
+            let hosting = MenuHostingView(rootView: overviewView)
+            let controller = NSHostingController(rootView: overviewView)
+            let size = controller.sizeThatFits(in: CGSize(width: menuWidth, height: .greatestFiniteMagnitude))
+            hosting.frame = NSRect(origin: .zero, size: NSSize(width: menuWidth, height: size.height))
+            let overviewItem = NSMenuItem()
+            overviewItem.view = hosting
+            overviewItem.isEnabled = false
+            overviewItem.representedObject = "overviewCard"
+            menu.addItem(overviewItem)
+            menu.addItem(.separator())
+        }
+
+        if let model = self.menuCardModel(for: selectedProvider) {
+            if hasOpenAIWebMenuItems, !useSidebarSwitcher {
+                let webItems = OpenAIWebMenuItems(
+                    hasUsageBreakdown: hasUsageBreakdown,
+                    hasCreditsHistory: hasCreditsHistory,
+                    hasCostHistory: hasCostHistory)
+                self.addMenuCardSections(
+                    to: menu,
+                    model: model,
+                    provider: currentProvider,
+                    width: menuWidth,
+                    sidebar: sidebarConfig,
+                    webItems: webItems)
+                addedOpenAIWebItems = true
+            } else {
+                let cardView = self.menuCardContent(width: menuWidth, sidebar: sidebarConfig, showIcons: true) {
+                    UsageMenuCardView(model: model, width: $0)
+                }
+                menu.addItem(self.makeMenuCardItem(cardView, id: "menuCard", width: menuWidth))
+                if currentProvider == .codex, model.creditsText != nil {
+                    menu.addItem(self.makeBuyCreditsItem())
+                }
+                menu.addItem(.separator())
+            }
+        }
+
+        if hasOpenAIWebMenuItems {
+            if !addedOpenAIWebItems {
+                if hasUsageBreakdown {
+                    _ = self.addUsageBreakdownSubmenu(to: menu)
+                }
+                if hasCreditsHistory {
+                    _ = self.addCreditsHistorySubmenu(to: menu)
+                }
+                if hasCostHistory {
+                    _ = self.addCostHistorySubmenu(to: menu, provider: currentProvider)
+                }
+            }
+            menu.addItem(.separator())
+        }
+
+        // Timeline & activity chart submenus
+        let hasTimeline = self.addUsageTimelineSubmenu(to: menu, provider: currentProvider)
+        let hasHourly = self.addHourlyActivitySubmenu(to: menu, provider: currentProvider)
+        let hasWeekly = self.addWeeklyActivitySubmenu(to: menu, provider: currentProvider)
+        if hasTimeline || hasHourly || hasWeekly {
+            menu.addItem(.separator())
+        }
+
+        // Utilization & window comparison chart submenus
+        let hasUtilization = self.addSubscriptionUtilizationSubmenu(to: menu, provider: currentProvider)
+        let hasWindowComparison = self.addUsageWindowComparisonSubmenu(to: menu, provider: currentProvider)
+        if hasUtilization || hasWindowComparison {
+            menu.addItem(.separator())
+        }
+
+        // Project & model breakdown submenus
+        let hasProjectBreakdown = self.addProjectBreakdownSubmenu(to: menu, provider: currentProvider)
+        let hasModelBreakdown = self.addModelBreakdownSubmenu(to: menu, provider: currentProvider)
+        if hasProjectBreakdown || hasModelBreakdown {
+            menu.addItem(.separator())
+        }
+
+        // Export Usage submenu
+        self.addExportUsageSubmenu(to: menu)
+
+        // Custom providers section
+        self.addCustomProvidersSection(to: menu)
+
+        let actionableSections = descriptor.sections.filter { section in
+            section.entries.contains { entry in
+                if case .action = entry { return true }
+                return false
+            }
+        }
+        for (index, section) in actionableSections.enumerated() {
+            for entry in section.entries {
+                switch entry {
+                case let .text(text, style):
+                    let item = NSMenuItem(title: text, action: nil, keyEquivalent: "")
+                    item.isEnabled = false
+                    if style == .headline {
+                        let font = NSFont.systemFont(ofSize: NSFont.systemFontSize, weight: .semibold)
+                        item.attributedTitle = NSAttributedString(string: text, attributes: [.font: font])
+                    } else if style == .secondary {
+                        let font = NSFont.systemFont(ofSize: NSFont.smallSystemFontSize)
+                        item.attributedTitle = NSAttributedString(
+                            string: text,
+                            attributes: [.font: font, .foregroundColor: NSColor.secondaryLabelColor])
+                    }
+                    menu.addItem(item)
+                case let .action(title, action):
+                    if case .refresh = action {
+                        menu.addItem(self.makePersistentRefreshItem(title: title))
+                        break
+                    }
+                    let (selector, represented) = self.selector(for: action)
+                    let item = NSMenuItem(title: title, action: selector, keyEquivalent: "")
+                    item.target = self
+                    item.representedObject = represented
+                    if let iconName = action.systemImageName,
+                       let image = NSImage(systemSymbolName: iconName, accessibilityDescription: nil)
+                    {
+                        image.isTemplate = true
+                        image.size = NSSize(width: 16, height: 16)
+                        item.image = image
+                    }
+                    if case let .switchAccount(targetProvider) = action,
+                       let subtitle = self.switchAccountSubtitle(for: targetProvider)
+                    {
+                        item.isEnabled = false
+                        self.applySubtitle(subtitle, to: item, title: title)
+                    }
+                    menu.addItem(item)
+                case .divider:
+                    menu.addItem(.separator())
+                }
+            }
+            if index < actionableSections.count - 1 {
+                menu.addItem(.separator())
+            }
+        }
+    }
+
+    func makeMenu(for provider: UsageProvider?) -> NSMenu {
+        let menu = NSMenu()
+        menu.autoenablesItems = false
+        menu.delegate = self
+        if let provider {
+            self.menuProviders[ObjectIdentifier(menu)] = provider
+        }
+        return menu
+    }
+
+    private func makeProviderSwitcherItem(
+        providers: [UsageProvider],
+        selected: UsageProvider?,
+        menu: NSMenu) -> NSMenuItem
+    {
+        let view = ProviderSwitcherView(
+            providers: providers,
+            selected: selected,
+            width: self.menuCardWidth(for: providers, menu: menu),
+            showsIcons: self.settings.switcherShowsIcons,
+            iconSizePreference: self.settings.providerSwitcherIconSize,
+            iconProvider: { [weak self] provider, iconSize in
+                self?.switcherIcon(for: provider, size: iconSize) ?? NSImage()
+            },
+            weeklyRemainingProvider: { [weak self] provider in
+                self?.switcherWeeklyRemaining(for: provider)
+            },
+            onSelect: { [weak self, weak menu] provider in
+                guard let self, let menu else { return }
+                self.selectedMenuProvider = provider
+                self.lastMenuProvider = provider
+                self.populateMenu(menu, provider: provider)
+                self.markMenuFresh(menu)
+                self.refreshMenuCardHeights(in: menu)
+                self.applyIcon(phase: nil)
+            })
+        let item = NSMenuItem()
+        item.view = view
+        item.isEnabled = false
+        return item
+    }
+
+    private func makeProviderTabBar(
+        providers: [UsageProvider],
+        selected: UsageProvider?,
+        width: CGFloat,
+        menu: NSMenu) -> ProviderTabBarView?
+    {
+        guard providers.count > 1 else { return nil }
+        let overviewColor = Color(nsColor: .controlAccentColor)
+
+        var tabs: [ProviderTabBarView.TabItem] = [
+            ProviderTabBarView.TabItem(
+                id: "overview",
+                label: "Overview",
+                icon: nil,
+                provider: nil,
+                isSelected: selected == nil,
+                brandColor: overviewColor),
+        ]
+
+        for provider in providers {
+            let meta = self.store.metadata(for: provider)
+            let icon = ProviderBrandIcon.image(for: provider, size: 18)
+            let descriptor = ProviderDescriptorRegistry.descriptor(for: provider)
+            let brandColor = Color(
+                red: Double(descriptor.branding.color.red),
+                green: Double(descriptor.branding.color.green),
+                blue: Double(descriptor.branding.color.blue))
+            tabs.append(ProviderTabBarView.TabItem(
+                id: provider.rawValue,
+                label: Self.abbreviatedProviderName(meta.displayName),
+                icon: icon,
+                provider: provider,
+                isSelected: selected == provider,
+                brandColor: brandColor))
+        }
+
+        return ProviderTabBarView(
+            tabs: tabs,
+            width: width,
+            onSelect: { [weak self, weak menu] provider in
+                guard let self, let menu else { return }
+                self.selectedMenuProvider = provider
+                self.lastMenuProvider = provider
+                Task { @MainActor [weak self, weak menu] in
+                    guard let self, let menu else { return }
+                    self.populateMenu(menu, provider: provider)
+                    self.markMenuFresh(menu)
+                    self.refreshMenuCardHeights(in: menu)
+                    self.applyIcon(phase: nil)
+                }
+            })
+    }
+
+    private func makeOverviewView(
+        providers: [UsageProvider],
+        width: CGFloat) -> OverviewMenuView
+    {
+        let calendar = Calendar.current
+        let todayStart = calendar.startOfDay(for: Date())
+        let weekAgo = calendar.date(byAdding: .day, value: -7, to: todayStart) ?? todayStart
+        let formatter = DateFormatter()
+        formatter.dateFormat = "yyyy-MM-dd"
+        formatter.timeZone = TimeZone.current
+
+        var summaries: [OverviewMenuView.ProviderSummary] = []
+        var chartPoints: [OverviewMenuView.DailyPoint] = []
+        var totalToday = 0
+
+        for provider in providers {
+            let meta = self.store.metadata(for: provider)
+            let snapshot = self.store.snapshot(for: provider)
+            let icon = ProviderBrandIcon.image(for: provider, size: 16)
+            let descriptor = ProviderDescriptorRegistry.descriptor(for: provider)
+            let brandColor = Color(
+                red: Double(descriptor.branding.color.red),
+                green: Double(descriptor.branding.color.green),
+                blue: Double(descriptor.branding.color.blue))
+            let usedPercent = snapshot?.primary.usedPercent ?? 0
+            let todayTokens = self.store.ledgerDailySummary(for: provider)?.totals.totalTokens ?? 0
+            totalToday += todayTokens
+
+            let resetDesc = snapshot?.primary.resetDescription
+
+            summaries.append(OverviewMenuView.ProviderSummary(
+                id: provider.rawValue,
+                provider: provider,
+                name: meta.displayName,
+                icon: icon,
+                usedPercent: usedPercent,
+                todayTokens: todayTokens,
+                brandColor: brandColor,
+                resetDescription: resetDesc))
+
+            // Chart data — last 7 days
+            let dailySummaries = self.store.ledgerAllDailySummary(for: provider)
+            for summary in dailySummaries where summary.dayStart >= weekAgo {
+                chartPoints.append(OverviewMenuView.DailyPoint(
+                    id: "\(provider.rawValue)-\(summary.dayKey)",
+                    date: summary.dayStart,
+                    tokens: summary.totals.totalTokens,
+                    provider: meta.displayName))
+            }
+        }
+
+        // Only show providers with data
+        let activeSummaries = summaries.filter { $0.usedPercent > 0 || $0.todayTokens > 0 }
+
+        return OverviewMenuView(
+            summaries: activeSummaries.isEmpty ? summaries : activeSummaries,
+            chartPoints: chartPoints,
+            totalTodayTokens: totalToday,
+            width: width)
+    }
+
+    private static func abbreviatedProviderName(_ name: String) -> String {
+        if name.count <= 8 { return name }
+        // Abbreviate long names
+        let abbreviations: [String: String] = [
+            "Antigravity": "AntiG",
+            "OpenRouter": "ORouter",
+            "Perplexity": "Perplx",
+            "SambaNova": "SambaN",
+            "Azure OpenAI": "Azure",
+        ]
+        return abbreviations[name] ?? String(name.prefix(6))
+    }
+
+    private func resolvedMenuProvider() -> UsageProvider? {
+        let enabled = self.store.enabledProviders()
+        if enabled.isEmpty { return .codex }
+        if let selected = self.selectedMenuProvider, enabled.contains(selected) {
+            return selected
+        }
+        return enabled.first
+    }
+
+    private func menuNeedsRefresh(_ menu: NSMenu) -> Bool {
+        let key = ObjectIdentifier(menu)
+        return self.menuVersions[key] != self.menuContentVersion
+    }
+
+    private func markMenuFresh(_ menu: NSMenu) {
+        let key = ObjectIdentifier(menu)
+        self.menuVersions[key] = self.menuContentVersion
+    }
+
+    func refreshOpenMenusIfNeeded() {
+        guard !self.openMenus.isEmpty else { return }
+        for (key, menu) in self.openMenus {
+            guard key == ObjectIdentifier(menu) else {
+                self.openMenus.removeValue(forKey: key)
+                continue
+            }
+
+            if self.isHostedSubviewMenu(menu) {
+                self.refreshHostedSubviewHeights(in: menu)
+                continue
+            }
+
+            if self.menuNeedsRefresh(menu) {
+                let provider = self.menuProvider(for: menu)
+                self.populateMenu(menu, provider: provider)
+                self.markMenuFresh(menu)
+                self.refreshMenuCardHeights(in: menu)
+            }
+        }
+    }
+
+    private func menuProvider(for menu: NSMenu) -> UsageProvider? {
+        if self.shouldMergeIcons {
+            return self.selectedMenuProvider ?? self.resolvedMenuProvider()
+        }
+        if let provider = self.menuProviders[ObjectIdentifier(menu)] {
+            return provider
+        }
+        if menu === self.fallbackMenu {
+            return nil
+        }
+        return self.store.enabledProviders().first ?? .codex
+    }
+
+    private func scheduleOpenMenuPing(for menu: NSMenu) {
+        guard self.settings.refreshFrequency != .manual else { return }
+        Task { await self.store.refresh(trigger: .menuOpen) }
+        let key = ObjectIdentifier(menu)
+        self.menuPingTasks[key]?.cancel()
+        self.menuPingTasks[key] = Task { @MainActor [weak self, weak menu] in
+            guard let self, let menu else { return }
+            try? await Task.sleep(for: Self.menuOpenPingDelay)
+            guard !Task.isCancelled else { return }
+            guard self.openMenus[ObjectIdentifier(menu)] != nil else { return }
+            guard !self.store.isRefreshing else { return }
+            let provider = self.menuProvider(for: menu) ?? self.resolvedMenuProvider()
+            let isStale = provider.map { self.store.isStale(provider: $0) } ?? self.store.isStale
+            let hasSnapshot = provider.map { self.store.snapshot(for: $0) != nil } ?? true
+            guard isStale || !hasSnapshot else { return }
+            await self.store.refresh(trigger: .menuOpen)
+        }
+    }
+
+    func refreshMenuCardHeights(in menu: NSMenu) {
+        let cardItems = menu.items.filter { item in
+            (item.representedObject as? String)?.hasPrefix("menuCard") == true
+        }
+        for item in cardItems {
+            guard let view = item.view else { continue }
+            let width = self.menuCardWidth(for: self.store.enabledProviders(), menu: menu)
+            let height = self.menuCardHeight(for: view, width: width)
+            view.frame = NSRect(
+                origin: .zero,
+                size: NSSize(width: width, height: height))
+        }
+    }
+
+    private func switcherIcon(for provider: UsageProvider, size: CGFloat) -> NSImage {
+        if let brand = ProviderBrandIcon.image(for: provider, size: size) {
+            return brand
+        }
+
+        let snapshot = self.store.snapshot(for: provider)
+        let showUsed = self.settings.usageBarsShowUsed
+        let primary = showUsed ? snapshot?.primary.usedPercent : snapshot?.primary.remainingPercent
+        let weekly = showUsed ? snapshot?.secondary?.usedPercent : snapshot?.secondary?.remainingPercent
+        let credits = provider == .codex ? self.store.credits?.remaining : nil
+        let stale = self.store.isStale(provider: provider)
+        let style = self.store.style(for: provider)
+        let indicator = self.store.statusIndicator(for: provider)
+        let image = IconRenderer.makeIcon(
+            primaryRemaining: primary,
+            weeklyRemaining: weekly,
+            creditsRemaining: credits,
+            stale: stale,
+            style: style,
+            blink: 0,
+            wiggle: 0,
+            tilt: 0,
+            statusIndicator: indicator)
+        image.isTemplate = true
+        image.size = NSSize(width: size, height: size)
+        return image
+    }
+
+    private func switcherWeeklyRemaining(for provider: UsageProvider) -> Double? {
+        let snapshot = self.store.snapshot(for: provider)
+        let window: RateWindow? = if provider == .factory {
+            snapshot?.secondary ?? snapshot?.primary
+        } else {
+            snapshot?.primary ?? snapshot?.secondary
+        }
+        guard let window else { return nil }
+        if self.settings.usageBarsShowUsed {
+            return window.usedPercent
+        }
+        return window.remainingPercent
+    }
+
+    private func addExportUsageSubmenu(to menu: NSMenu) {
+        let exportItem = NSMenuItem(title: "Export Usage\u{2026}", action: nil, keyEquivalent: "")
+        if let image = NSImage(systemSymbolName: "square.and.arrow.up", accessibilityDescription: "Export") {
+            image.isTemplate = true
+            image.size = NSSize(width: 16, height: 16)
+            exportItem.image = image
+        }
+        let submenu = NSMenu(title: "Export Usage")
+        let csvItem = NSMenuItem(
+            title: "Export as CSV\u{2026}",
+            action: #selector(self.exportUsageCSV(_:)),
+            keyEquivalent: "")
+        csvItem.target = self
+        let jsonItem = NSMenuItem(
+            title: "Export as JSON\u{2026}",
+            action: #selector(self.exportUsageJSON(_:)),
+            keyEquivalent: "")
+        jsonItem.target = self
+        submenu.addItem(csvItem)
+        submenu.addItem(jsonItem)
+        exportItem.submenu = submenu
+        menu.addItem(exportItem)
+        menu.addItem(.separator())
+    }
+
+    private func selector(for action: MenuDescriptor.MenuAction) -> (Selector, Any?) {
+        switch action {
+        case .installUpdate: (#selector(self.installUpdate), nil)
+        case .refresh: (#selector(self.refreshNow), nil)
+        case .dashboard: (#selector(self.openDashboard), nil)
+        case .statusPage: (#selector(self.openStatusPage), nil)
+        case let .switchAccount(provider): (#selector(self.runSwitchAccount(_:)), provider.rawValue)
+        case .settings: (#selector(self.showSettingsGeneral), nil)
+        case .about: (#selector(self.showSettingsAbout), nil)
+        case .quit: (#selector(self.quit), nil)
+        case let .copyError(message): (#selector(self.copyError(_:)), message)
+        }
+    }
+
+    @objc func menuCardNoOp(_ sender: NSMenuItem) {
+        _ = sender
+    }
+
+    private func isHostedSubviewMenu(_ menu: NSMenu) -> Bool {
+        let ids: Set<String> = [
+            "usageBreakdownChart",
+            "creditsHistoryChart",
+            "costHistoryChart",
+            "projectBreakdownChart",
+            "modelBreakdownChart",
+        ]
+        return menu.items.contains { item in
+            guard let id = item.representedObject as? String else { return false }
+            return ids.contains(id)
+        }
+    }
+
+    private func refreshHostedSubviewHeights(in menu: NSMenu) {
+        let enabledProviders = self.store.enabledProviders()
+        let width = self.menuCardWidth(for: enabledProviders, menu: menu)
+
+        for item in menu.items {
+            guard let view = item.view else { continue }
+            view.frame = NSRect(origin: .zero, size: NSSize(width: width, height: 1))
+            view.layoutSubtreeIfNeeded()
+            let height = view.fittingSize.height
+            view.frame = NSRect(origin: .zero, size: NSSize(width: width, height: height))
+        }
+    }
+}
+
+// MARK: - ProviderSwitcherView (NSView-based segmented control)
+
+private final class ProviderSwitcherView: NSView {
+    private struct Segment {
+        let provider: UsageProvider
+        let image: NSImage
+        let title: String
+    }
+
+    private struct WeeklyIndicator {
+        let provider: UsageProvider
+        let track: NSView
+        let fill: NSView
+    }
+
+    private let segments: [Segment]
+    private let onSelect: (UsageProvider) -> Void
+    private let showsIcons: Bool
+    private let weeklyRemainingProvider: (UsageProvider) -> Double?
+    private var buttons: [NSButton] = []
+    private var weeklyIndicators: [ObjectIdentifier: WeeklyIndicator] = [:]
+    private var hoverTrackingArea: NSTrackingArea?
+    private var segmentWidths: [CGFloat] = []
+    private let selectedBackground = NSColor.controlAccentColor.cgColor
+    private let unselectedBackground = NSColor.clear.cgColor
+    private let selectedTextColor = NSColor.white
+    private let unselectedTextColor = NSColor.secondaryLabelColor
+    private let stackedIcons: Bool
+    private let useTwoRows: Bool
+    private let rowSpacing: CGFloat
+    private let rowHeight: CGFloat
+    private var preferredWidth: CGFloat = 0
+    private var hoveredButtonTag: Int?
+    private let lightModeOverlayLayer = CALayer()
+
+    init(
+        providers: [UsageProvider],
+        selected: UsageProvider?,
+        width: CGFloat,
+        showsIcons: Bool,
+        iconSizePreference: ProviderSwitcherIconSize,
+        iconProvider: (UsageProvider, CGFloat) -> NSImage,
+        weeklyRemainingProvider: @escaping (UsageProvider) -> Double?,
+        onSelect: @escaping (UsageProvider) -> Void)
+    {
+        let minimumGap: CGFloat = 1
+        let iconSize: CGFloat = iconSizePreference == .small ? 28 : 34
+        self.segments = providers.map { provider in
+            let fullTitle = Self.switcherTitle(for: provider)
+            let icon = iconProvider(provider, iconSize)
+            icon.size = NSSize(width: iconSize, height: iconSize)
+            return Segment(
+                provider: provider,
+                image: icon,
+                title: fullTitle)
+        }
+        self.onSelect = onSelect
+        self.showsIcons = showsIcons
+        self.weeklyRemainingProvider = weeklyRemainingProvider
+        self.stackedIcons = showsIcons && providers.count > 3
+        let initialOuterPadding = Self.switcherOuterPadding(
+            for: width,
+            count: self.segments.count,
+            minimumGap: minimumGap)
+        let initialMaxAllowedSegmentWidth = Self.maxAllowedUniformSegmentWidth(
+            for: width,
+            count: self.segments.count,
+            outerPadding: initialOuterPadding,
+            minimumGap: minimumGap)
+        self.useTwoRows = Self.shouldUseTwoRows(
+            count: self.segments.count,
+            maxAllowedSegmentWidth: initialMaxAllowedSegmentWidth,
+            stackedIcons: self.stackedIcons)
+        self.rowSpacing = self.stackedIcons ? 3 : 3
+        self.rowHeight = self.stackedIcons ? 56 : 42
+        let height: CGFloat = self.useTwoRows ? (self.rowHeight * 2 + self.rowSpacing) : self.rowHeight
+        self.preferredWidth = width
+        super.init(frame: NSRect(x: 0, y: 0, width: width, height: height))
+        Self.clearButtonWidthCache()
+        self.wantsLayer = true
+        self.layer?.masksToBounds = false
+        self.lightModeOverlayLayer.masksToBounds = false
+        self.layer?.insertSublayer(self.lightModeOverlayLayer, at: 0)
+        self.updateLightModeStyling()
+
+        let layoutCount = self.useTwoRows
+            ? Int(ceil(Double(self.segments.count) / 2.0))
+            : self.segments.count
+        let outerPadding: CGFloat = Self.switcherOuterPadding(
+            for: width,
+            count: layoutCount,
+            minimumGap: minimumGap)
+        let maxAllowedSegmentWidth = Self.maxAllowedUniformSegmentWidth(
+            for: width,
+            count: layoutCount,
+            outerPadding: outerPadding,
+            minimumGap: minimumGap)
+
+        func makeButton(index: Int, segment: Segment) -> NSButton {
+            let button: NSButton
+            if self.stackedIcons {
+                let stacked = StackedToggleButton(
+                    title: segment.title,
+                    image: segment.image,
+                    iconSize: iconSize,
+                    target: self,
+                    action: #selector(self.handleSelection(_:)))
+                button = stacked
+            } else if self.showsIcons {
+                let inline = InlineIconToggleButton(
+                    title: segment.title,
+                    image: segment.image,
+                    iconSize: iconSize,
+                    target: self,
+                    action: #selector(self.handleSelection(_:)))
+                button = inline
+            } else {
+                button = PaddedToggleButton(
+                    title: segment.title,
+                    target: self,
+                    action: #selector(self.handleSelection(_:)))
+            }
+            button.tag = index
+            if !self.showsIcons {
+                button.image = nil
+                button.imagePosition = .noImage
+            }
+
+            let remaining = self.weeklyRemainingProvider(segment.provider)
+            self.addWeeklyIndicator(to: button, provider: segment.provider, remainingPercent: remaining)
+            button.bezelStyle = .regularSquare
+            button.isBordered = false
+            button.controlSize = .small
+            button.font = NSFont.systemFont(ofSize: 12, weight: .medium)
+            button.setButtonType(.toggle)
+            button.contentTintColor = self.unselectedTextColor
+            button.alignment = .center
+            button.wantsLayer = true
+            button.layer?.cornerRadius = CGFloat(RunicCornerRadius.md)
+            button.state = (selected == segment.provider) ? .on : .off
+            button.toolTip = nil
+            button.translatesAutoresizingMaskIntoConstraints = false
+            self.buttons.append(button)
+            return button
+        }
+
+        for (index, segment) in self.segments.enumerated() {
+            let button = makeButton(index: index, segment: segment)
+            self.addSubview(button)
+        }
+
+        let uniformWidth: CGFloat
+        if self.useTwoRows || !self.stackedIcons {
+            uniformWidth = self.applyUniformSegmentWidth(maxAllowedWidth: maxAllowedSegmentWidth)
+            if uniformWidth > 0 {
+                self.segmentWidths = Array(repeating: uniformWidth, count: self.buttons.count)
+            }
+        } else {
+            self.segmentWidths = self.applyNonUniformSegmentWidths(
+                totalWidth: width,
+                outerPadding: outerPadding,
+                minimumGap: minimumGap)
+            uniformWidth = 0
+        }
+
+        self.applyLayout(
+            outerPadding: outerPadding,
+            minimumGap: minimumGap,
+            uniformWidth: uniformWidth)
+        if width > 0 {
+            self.preferredWidth = width
+            self.frame.size.width = width
+        }
+
+        self.updateButtonStyles()
+    }
+
+    override func layout() {
+        super.layout()
+        self.lightModeOverlayLayer.frame = self.bounds
+    }
+
+    override func viewDidChangeEffectiveAppearance() {
+        super.viewDidChangeEffectiveAppearance()
+        self.updateLightModeStyling()
+        self.updateButtonStyles()
+    }
+
+    override func viewDidMoveToWindow() {
+        super.viewDidMoveToWindow()
+        self.window?.acceptsMouseMovedEvents = true
+    }
+
+    override func updateTrackingAreas() {
+        super.updateTrackingAreas()
+
+        if let hoverTrackingArea {
+            self.removeTrackingArea(hoverTrackingArea)
+        }
+
+        let trackingArea = NSTrackingArea(
+            rect: .zero,
+            options: [
+                .activeAlways,
+                .inVisibleRect,
+                .mouseEnteredAndExited,
+                .mouseMoved,
+            ],
+            owner: self,
+            userInfo: nil)
+        self.addTrackingArea(trackingArea)
+        self.hoverTrackingArea = trackingArea
+    }
+
+    override func mouseMoved(with event: NSEvent) {
+        let location = self.convert(event.locationInWindow, from: nil)
+        let hoveredTag = self.buttons.first(where: { $0.frame.contains(location) })?.tag
+        guard hoveredTag != self.hoveredButtonTag else { return }
+        self.hoveredButtonTag = hoveredTag
+        self.updateButtonStyles()
+    }
+
+    override func mouseExited(with event: NSEvent) {
+        guard self.hoveredButtonTag != nil else { return }
+        self.hoveredButtonTag = nil
+        self.updateButtonStyles()
+    }
+
+    private func applyLayout(
+        outerPadding: CGFloat,
+        minimumGap: CGFloat,
+        uniformWidth: CGFloat)
+    {
+        if self.useTwoRows {
+            self.applyTwoRowLayout(
+                outerPadding: outerPadding,
+                minimumGap: minimumGap,
+                uniformWidth: uniformWidth)
+            return
+        }
+
+        if self.buttons.count == 2 {
+            let left = self.buttons[0]
+            let right = self.buttons[1]
+            let gap = right.leadingAnchor.constraint(greaterThanOrEqualTo: left.trailingAnchor, constant: minimumGap)
+            gap.priority = .defaultHigh
+            NSLayoutConstraint.activate([
+                left.leadingAnchor.constraint(equalTo: self.leadingAnchor, constant: outerPadding),
+                left.centerYAnchor.constraint(equalTo: self.centerYAnchor),
+                right.trailingAnchor.constraint(equalTo: self.trailingAnchor, constant: -outerPadding),
+                right.centerYAnchor.constraint(equalTo: self.centerYAnchor),
+                gap,
+            ])
+            return
+        }
+
+        if self.buttons.count == 3 {
+            let left = self.buttons[0]
+            let mid = self.buttons[1]
+            let right = self.buttons[2]
+
+            let leftGap = mid.leadingAnchor.constraint(greaterThanOrEqualTo: left.trailingAnchor, constant: minimumGap)
+            leftGap.priority = .defaultHigh
+            let rightGap = right.leadingAnchor.constraint(
+                greaterThanOrEqualTo: mid.trailingAnchor,
+                constant: minimumGap)
+            rightGap.priority = .defaultHigh
+
+            NSLayoutConstraint.activate([
+                left.leadingAnchor.constraint(equalTo: self.leadingAnchor, constant: outerPadding),
+                left.centerYAnchor.constraint(equalTo: self.centerYAnchor),
+                mid.centerXAnchor.constraint(equalTo: self.centerXAnchor),
+                mid.centerYAnchor.constraint(equalTo: self.centerYAnchor),
+                right.trailingAnchor.constraint(equalTo: self.trailingAnchor, constant: -outerPadding),
+                right.centerYAnchor.constraint(equalTo: self.centerYAnchor),
+                leftGap,
+                rightGap,
+            ])
+            return
+        }
+
+        if self.buttons.count >= 4 {
+            let widths = self.segmentWidths.isEmpty
+                ? self.buttons.map { ceil($0.fittingSize.width) }
+                : self.segmentWidths
+            let layoutWidth = self.preferredWidth > 0 ? self.preferredWidth : self.bounds.width
+            let availableWidth = max(0, layoutWidth - outerPadding * 2)
+            let gaps = max(1, widths.count - 1)
+            let computedGap = gaps > 0
+                ? max(minimumGap, (availableWidth - widths.reduce(0, +)) / CGFloat(gaps))
+                : 0
+            let rowContainer = NSView()
+            rowContainer.translatesAutoresizingMaskIntoConstraints = false
+            self.addSubview(rowContainer)
+
+            NSLayoutConstraint.activate([
+                rowContainer.topAnchor.constraint(equalTo: self.topAnchor),
+                rowContainer.bottomAnchor.constraint(equalTo: self.bottomAnchor),
+                rowContainer.leadingAnchor.constraint(equalTo: self.leadingAnchor, constant: outerPadding),
+                rowContainer.trailingAnchor.constraint(equalTo: self.trailingAnchor, constant: -outerPadding),
+            ])
+
+            var xOffset: CGFloat = 0
+            for (index, button) in self.buttons.enumerated() {
+                let width = index < widths.count ? widths[index] : 0
+                if self.stackedIcons {
+                    NSLayoutConstraint.activate([
+                        button.leadingAnchor.constraint(equalTo: rowContainer.leadingAnchor, constant: xOffset),
+                        button.topAnchor.constraint(equalTo: rowContainer.topAnchor),
+                    ])
+                } else {
+                    NSLayoutConstraint.activate([
+                        button.leadingAnchor.constraint(equalTo: rowContainer.leadingAnchor, constant: xOffset),
+                        button.centerYAnchor.constraint(equalTo: rowContainer.centerYAnchor),
+                    ])
+                }
+                xOffset += width + computedGap
+            }
+            return
+        }
+
+        if let first = self.buttons.first {
+            NSLayoutConstraint.activate([
+                first.centerXAnchor.constraint(equalTo: self.centerXAnchor),
+                first.centerYAnchor.constraint(equalTo: self.centerYAnchor),
+            ])
+        }
+    }
+
+    private func applyTwoRowLayout(
+        outerPadding: CGFloat,
+        minimumGap: CGFloat,
+        uniformWidth: CGFloat)
+    {
+        let splitIndex = Int(ceil(Double(self.buttons.count) / 2.0))
+        let topButtons = Array(self.buttons.prefix(splitIndex))
+        let bottomButtons = Array(self.buttons.dropFirst(splitIndex))
+
+        let columns = max(topButtons.count, bottomButtons.count)
+        let layoutWidth = self.preferredWidth > 0 ? self.preferredWidth : self.bounds.width
+        let availableWidth = max(0, layoutWidth - outerPadding * 2)
+        let gaps = max(1, columns - 1)
+        let totalWidth = uniformWidth * CGFloat(columns)
+        let computedGap = gaps > 0
+            ? max(minimumGap, (availableWidth - totalWidth) / CGFloat(gaps))
+            : 0
+        let gridContainer = NSView()
+        gridContainer.translatesAutoresizingMaskIntoConstraints = false
+        self.addSubview(gridContainer)
+
+        NSLayoutConstraint.activate([
+            gridContainer.topAnchor.constraint(equalTo: self.topAnchor),
+            gridContainer.bottomAnchor.constraint(equalTo: self.bottomAnchor),
+            gridContainer.leadingAnchor.constraint(equalTo: self.leadingAnchor, constant: outerPadding),
+            gridContainer.trailingAnchor.constraint(equalTo: self.trailingAnchor, constant: -outerPadding),
+        ])
+
+        let topRow = NSView()
+        topRow.translatesAutoresizingMaskIntoConstraints = false
+        gridContainer.addSubview(topRow)
+
+        let bottomRow = NSView()
+        bottomRow.translatesAutoresizingMaskIntoConstraints = false
+        gridContainer.addSubview(bottomRow)
+
+        NSLayoutConstraint.activate([
+            topRow.leadingAnchor.constraint(equalTo: gridContainer.leadingAnchor),
+            topRow.trailingAnchor.constraint(equalTo: gridContainer.trailingAnchor),
+            topRow.topAnchor.constraint(equalTo: gridContainer.topAnchor),
+            topRow.heightAnchor.constraint(equalToConstant: self.rowHeight),
+            bottomRow.leadingAnchor.constraint(equalTo: gridContainer.leadingAnchor),
+            bottomRow.trailingAnchor.constraint(equalTo: gridContainer.trailingAnchor),
+            bottomRow.bottomAnchor.constraint(equalTo: gridContainer.bottomAnchor),
+            bottomRow.heightAnchor.constraint(equalToConstant: self.rowHeight),
+            bottomRow.topAnchor.constraint(equalTo: topRow.bottomAnchor, constant: self.rowSpacing),
+        ])
+
+        for index in 0..<columns {
+            let xOffset = CGFloat(index) * (uniformWidth + computedGap)
+            if index < topButtons.count {
+                let button = topButtons[index]
+                NSLayoutConstraint.activate([
+                    button.leadingAnchor.constraint(equalTo: gridContainer.leadingAnchor, constant: xOffset),
+                    button.centerYAnchor.constraint(equalTo: topRow.centerYAnchor),
+                ])
+            }
+            if index < bottomButtons.count {
+                let button = bottomButtons[index]
+                NSLayoutConstraint.activate([
+                    button.leadingAnchor.constraint(equalTo: gridContainer.leadingAnchor, constant: xOffset),
+                    button.centerYAnchor.constraint(equalTo: bottomRow.centerYAnchor),
+                ])
+            }
+        }
+    }
+
+    private static func shouldUseTwoRows(
+        count: Int,
+        maxAllowedSegmentWidth: CGFloat,
+        stackedIcons: Bool) -> Bool
+    {
+        guard count > 1 else { return false }
+        let minimumComfortableAverage: CGFloat = stackedIcons ? 52 : 54
+        return maxAllowedSegmentWidth < minimumComfortableAverage
+    }
+
+    private static func switcherOuterPadding(for width: CGFloat, count: Int, minimumGap: CGFloat) -> CGFloat {
+        let preferred: CGFloat = MenuCardMetrics.horizontalPadding
+        let reduced: CGFloat = 8
+        let minimal: CGFloat = 6
+
+        func averageButtonWidth(outerPadding: CGFloat) -> CGFloat {
+            let available = width - outerPadding * 2 - minimumGap * CGFloat(max(0, count - 1))
+            guard count > 0 else { return 0 }
+            return available / CGFloat(count)
+        }
+
+        let minimumComfortableAverage: CGFloat = count >= 5 ? 50 : 56
+
+        if averageButtonWidth(outerPadding: preferred) >= minimumComfortableAverage { return preferred }
+        if averageButtonWidth(outerPadding: reduced) >= minimumComfortableAverage { return reduced }
+        return minimal
+    }
+
+    @available(*, unavailable)
+    required init?(coder: NSCoder) {
+        nil
+    }
+
+    override var intrinsicContentSize: NSSize {
+        NSSize(width: self.preferredWidth, height: self.frame.size.height)
+    }
+
+    @objc private func handleSelection(_ sender: NSButton) {
+        let index = sender.tag
+        guard self.segments.indices.contains(index) else { return }
+        for (idx, button) in self.buttons.enumerated() {
+            button.state = (idx == index) ? .on : .off
+        }
+        self.updateButtonStyles()
+        self.onSelect(self.segments[index].provider)
+    }
+
+    private func updateButtonStyles() {
+        for button in self.buttons {
+            let isSelected = button.state == .on
+            let isHovered = self.hoveredButtonTag == button.tag
+            button.contentTintColor = isSelected ? self.selectedTextColor : self.unselectedTextColor
+            button.layer?.backgroundColor = if isSelected {
+                self.selectedBackground
+            } else if isHovered {
+                self.hoverPlateColor()
+            } else {
+                self.unselectedBackground
+            }
+            self.updateWeeklyIndicatorVisibility(for: button)
+            (button as? StackedToggleButton)?.setContentTintColor(button.contentTintColor)
+            (button as? InlineIconToggleButton)?.setContentTintColor(button.contentTintColor)
+        }
+    }
+
+    private func isLightMode() -> Bool {
+        self.effectiveAppearance.bestMatch(from: [.aqua, .darkAqua]) == .aqua
+    }
+
+    private func updateLightModeStyling() {
+        guard self.isLightMode() else {
+            self.lightModeOverlayLayer.backgroundColor = nil
+            return
+        }
+        self.lightModeOverlayLayer.backgroundColor = NSColor.black.withAlphaComponent(0.035).cgColor
+    }
+
+    private func hoverPlateColor() -> CGColor {
+        if self.isLightMode() {
+            return NSColor.black.withAlphaComponent(0.095).cgColor
+        }
+        return NSColor.labelColor.withAlphaComponent(0.06).cgColor
+    }
+
+    private static var buttonWidthCache: [ObjectIdentifier: CGFloat] = [:]
+
+    private static func maxToggleWidth(for button: NSButton) -> CGFloat {
+        let buttonId = ObjectIdentifier(button)
+
+        if let cached = buttonWidthCache[buttonId] {
+            return cached
+        }
+
+        let originalState = button.state
+        defer { button.state = originalState }
+
+        button.state = .off
+        button.layoutSubtreeIfNeeded()
+        let offWidth = button.fittingSize.width
+
+        button.state = .on
+        button.layoutSubtreeIfNeeded()
+        let onWidth = button.fittingSize.width
+
+        let maxWidth = max(offWidth, onWidth)
+        self.buttonWidthCache[buttonId] = maxWidth
+        return maxWidth
+    }
+
+    private static func clearButtonWidthCache() {
+        self.buttonWidthCache.removeAll()
+    }
+
+    private func applyUniformSegmentWidth(maxAllowedWidth: CGFloat) -> CGFloat {
+        guard !self.buttons.isEmpty else { return 0 }
+
+        var desiredWidths: [CGFloat] = []
+        desiredWidths.reserveCapacity(self.buttons.count)
+
+        for (index, button) in self.buttons.enumerated() {
+            if self.stackedIcons,
+               self.segments.indices.contains(index)
+            {
+                let font = NSFont.systemFont(ofSize: NSFont.smallSystemFontSize)
+                let titleWidth = ceil((self.segments[index].title as NSString).size(withAttributes: [.font: font])
+                    .width)
+                let contentPadding: CGFloat = 6 + 6
+                let extraSlack: CGFloat = 1
+                desiredWidths.append(ceil(titleWidth + contentPadding + extraSlack))
+            } else {
+                desiredWidths.append(ceil(Self.maxToggleWidth(for: button)))
+            }
+        }
+
+        let maxDesired = desiredWidths.max() ?? 0
+        let evenMaxDesired = maxDesired.truncatingRemainder(dividingBy: 2) == 0 ? maxDesired : maxDesired + 1
+        let evenMaxAllowed = maxAllowedWidth > 0
+            ? (maxAllowedWidth.truncatingRemainder(dividingBy: 2) == 0 ? maxAllowedWidth : maxAllowedWidth - 1)
+            : 0
+        let finalWidth: CGFloat = if evenMaxAllowed > 0 {
+            min(evenMaxDesired, evenMaxAllowed)
+        } else {
+            evenMaxDesired
+        }
+
+        if finalWidth > 0 {
+            for button in self.buttons {
+                button.widthAnchor.constraint(equalToConstant: finalWidth).isActive = true
+            }
+        }
+
+        return finalWidth
+    }
+
+    @discardableResult
+    private func applyNonUniformSegmentWidths(
+        totalWidth: CGFloat,
+        outerPadding: CGFloat,
+        minimumGap: CGFloat) -> [CGFloat]
+    {
+        guard !self.buttons.isEmpty else { return [] }
+
+        let count = self.buttons.count
+        let available = totalWidth -
+            outerPadding * 2 -
+            minimumGap * CGFloat(max(0, count - 1))
+        guard available > 0 else { return [] }
+
+        func evenFloor(_ value: CGFloat) -> CGFloat {
+            var v = floor(value)
+            if Int(v) % 2 != 0 { v -= 1 }
+            return v
+        }
+
+        let desired = self.buttons.map { ceil(Self.maxToggleWidth(for: $0)) }
+        let desiredSum = desired.reduce(0, +)
+        let avg = floor(available / CGFloat(count))
+        let minWidth = max(24, min(40, avg))
+
+        var widths: [CGFloat]
+        if desiredSum <= available {
+            widths = desired
+        } else {
+            let totalCapacity = max(0, desiredSum - minWidth * CGFloat(count))
+            if totalCapacity <= 0 {
+                widths = Array(repeating: available / CGFloat(count), count: count)
+            } else {
+                let overflow = desiredSum - available
+                widths = desired.map { desiredWidth in
+                    let capacity = max(0, desiredWidth - minWidth)
+                    let shrink = overflow * (capacity / totalCapacity)
+                    return desiredWidth - shrink
+                }
+            }
+        }
+
+        widths = widths.map { max(minWidth, evenFloor($0)) }
+        var used = widths.reduce(0, +)
+
+        while available - used >= 2 {
+            if let best = widths.indices
+                .filter({ desired[$0] - widths[$0] >= 2 })
+                .max(by: { lhs, rhs in
+                    (desired[lhs] - widths[lhs]) < (desired[rhs] - widths[rhs])
+                })
+            {
+                widths[best] += 2
+                used += 2
+                continue
+            }
+
+            guard let best = widths.indices.min(by: { lhs, rhs in widths[lhs] < widths[rhs] }) else { break }
+            widths[best] += 2
+            used += 2
+        }
+
+        for (index, button) in self.buttons.enumerated() where index < widths.count {
+            button.widthAnchor.constraint(equalToConstant: widths[index]).isActive = true
+        }
+
+        return widths
+    }
+
+    private static func maxAllowedUniformSegmentWidth(
+        for totalWidth: CGFloat,
+        count: Int,
+        outerPadding: CGFloat,
+        minimumGap: CGFloat) -> CGFloat
+    {
+        guard count > 0 else { return 0 }
+        let available = totalWidth -
+            outerPadding * 2 -
+            minimumGap * CGFloat(max(0, count - 1))
+        guard available > 0 else { return 0 }
+        return floor(available / CGFloat(count))
+    }
+
+    private static func paddedImage(_ image: NSImage, leading: CGFloat) -> NSImage {
+        let size = NSSize(width: image.size.width + leading, height: image.size.height)
+        let newImage = NSImage(size: size)
+        newImage.lockFocus()
+        let y = (size.height - image.size.height) / 2
+        image.draw(
+            at: NSPoint(x: leading, y: y),
+            from: NSRect(origin: .zero, size: image.size),
+            operation: .sourceOver,
+            fraction: 1.0)
+        newImage.unlockFocus()
+        newImage.isTemplate = image.isTemplate
+        return newImage
+    }
+
+    private func addWeeklyIndicator(to view: NSView, provider: UsageProvider, remainingPercent: Double?) {
+        guard let remainingPercent else { return }
+
+        let track = NSView()
+        track.wantsLayer = true
+        track.layer?.backgroundColor = NSColor.tertiaryLabelColor.withAlphaComponent(CGFloat(RunicColors.Opacity.medium)).cgColor
+        track.layer?.cornerRadius = 3
+        track.layer?.masksToBounds = true
+        track.translatesAutoresizingMaskIntoConstraints = false
+        view.addSubview(track)
+
+        let fill = NSView()
+        fill.wantsLayer = true
+        fill.layer?.backgroundColor = Self.weeklyIndicatorColor(for: provider).cgColor
+        fill.layer?.cornerRadius = 3
+        fill.translatesAutoresizingMaskIntoConstraints = false
+        track.addSubview(fill)
+
+        let ratio = CGFloat(max(0, min(1, remainingPercent / 100)))
+
+        NSLayoutConstraint.activate([
+            track.leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: 6),
+            track.trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: -6),
+            track.bottomAnchor.constraint(equalTo: view.bottomAnchor, constant: -1),
+            track.heightAnchor.constraint(equalToConstant: 5),
+            fill.leadingAnchor.constraint(equalTo: track.leadingAnchor),
+            fill.topAnchor.constraint(equalTo: track.topAnchor),
+            fill.bottomAnchor.constraint(equalTo: track.bottomAnchor),
+        ])
+
+        fill.widthAnchor.constraint(equalTo: track.widthAnchor, multiplier: ratio).isActive = true
+
+        self.weeklyIndicators[ObjectIdentifier(view)] = WeeklyIndicator(provider: provider, track: track, fill: fill)
+        self.updateWeeklyIndicatorVisibility(for: view)
+    }
+
+    private func updateWeeklyIndicatorVisibility(for view: NSView) {
+        guard let indicator = self.weeklyIndicators[ObjectIdentifier(view)] else { return }
+        let isSelected = (view as? NSButton)?.state == .on
+        indicator.track.isHidden = isSelected
+        indicator.fill.isHidden = isSelected
+    }
+
+    private static func weeklyIndicatorColor(for provider: UsageProvider) -> NSColor {
+        let color = ProviderDescriptorRegistry.descriptor(for: provider).branding.color
+        return NSColor(deviceRed: color.red, green: color.green, blue: color.blue, alpha: 1)
+    }
+
+    private static func switcherTitle(for provider: UsageProvider) -> String {
+        ProviderDescriptorRegistry.descriptor(for: provider).metadata.displayName
+    }
+}