@sriinnu/runic 1.2.0 → 2.11.1

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

@@ -1,1407 +0,0 @@
-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
-            let windowLabel = snapshot?.primary.label?.trimmingCharacters(in: .whitespacesAndNewlines)
-            let topModel = self.store.ledgerTopModel(for: provider)
-            let topModelContext: String? = if let model = topModel?.model {
-                UsageFormatter.modelContextLabel(for: model)
-            } else {
-                Self.defaultContextLabel(for: provider)
-            }
-
-            summaries.append(OverviewMenuView.ProviderSummary(
-                id: provider.rawValue,
-                provider: provider,
-                name: meta.displayName,
-                icon: icon,
-                usedPercent: usedPercent,
-                todayTokens: todayTokens,
-                brandColor: brandColor,
-                resetDescription: resetDesc,
-                windowLabel: windowLabel,
-                topModelContext: topModelContext))
-
-            // 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,
-                    color: brandColor))
-            }
-        }
-
-        // 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,
-            totalProviders: UsageProvider.allCases.count,
-            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))
-    }
-
-    /// Default flagship model context window per provider, loaded from
-    /// `Resources/provider-context-windows.json`. Update the JSON to add/change
-    /// context windows without recompiling.
-    private static let defaultContextWindows: [String: Int] = {
-        struct Entry: Decodable { let contextK: Int }
-        guard let url = Bundle.main.url(forResource: "provider-context-windows", withExtension: "json"),
-              let data = try? Data(contentsOf: url),
-              let dict = try? JSONDecoder().decode([String: Entry].self, from: data)
-        else { return [:] }
-        return dict.mapValues(\.contextK)
-    }()
-
-    private static func defaultContextLabel(for provider: UsageProvider) -> String? {
-        guard let k = self.defaultContextWindows[provider.rawValue] else { return nil }
-        return k >= 1_000 ? "ctx \(k / 1_000)M" : "ctx \(k)K"
-    }
-
-    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
-    }
-}