@sriinnu/runic 2.0.0 → 2.11.1

package/Sources/Runic/Views/Menu/HourlyActivityChartMenuView.swift

@@ -1,228 +0,0 @@
-import Charts
-import RunicCore
-import SwiftUI
-
-/// Bar chart showing today's hourly usage — inspired by Tokex "Today by Hour".
-@MainActor
-struct HourlyActivityChartMenuView: View {
-    private struct HourBar: Identifiable {
-        let id: Int // hour 0-23
-        let hour: Int
-        let totalTokens: Int
-        let isPeak: Bool
-
-        var label: String {
-            if self.hour == 0 { return "12A" }
-            if self.hour < 12 { return "\(self.hour)A" }
-            if self.hour == 12 { return "12P" }
-            return "\(self.hour - 12)P"
-        }
-    }
-
-    private let hourlySummaries: [UsageLedgerHourlySummary]
-    private let width: CGFloat
-    @State private var selectedHour: Int?
-
-    init(hourlySummaries: [UsageLedgerHourlySummary], width: CGFloat) {
-        self.hourlySummaries = hourlySummaries
-        self.width = width
-    }
-
-    private static let barColor = RunicColors.chartColor(at: 0)
-    private static let peakColor = Color(nsColor: .systemYellow)
-
-    var body: some View {
-        let model = Self.makeModel(from: self.hourlySummaries)
-
-        VStack(alignment: .leading, spacing: RunicSpacing.sm) {
-            // Header
-            HStack(alignment: .firstTextBaseline) {
-                Text("Today by Hour")
-                    .font(RunicFont.subheadline)
-                    .fontWeight(.semibold)
-                Spacer()
-                if let peak = model.peakHour {
-                    Text("Peak \(peak.label)")
-                        .font(RunicFont.caption)
-                        .foregroundStyle(.secondary)
-                }
-            }
-
-            if model.bars.allSatisfy({ $0.totalTokens == 0 }) {
-                Text("No usage recorded today.")
-                    .font(RunicFont.footnote)
-                    .foregroundStyle(.secondary)
-                    .frame(height: 80)
-            } else {
-                Chart {
-                    ForEach(model.bars) { bar in
-                        BarMark(
-                            x: .value("Hour", bar.hour),
-                            y: .value("Tokens", bar.totalTokens))
-                            .foregroundStyle(bar.isPeak ? Self.peakColor : Self.barColor)
-                            .cornerRadius(RunicCornerRadius.xs)
-                    }
-                    if let selected = self.selectedHour,
-                       let bar = model.bars.first(where: { $0.hour == selected })
-                    {
-                        RuleMark(x: .value("Hour", selected))
-                            .lineStyle(StrokeStyle(lineWidth: 1, dash: [3, 2]))
-                            .foregroundStyle(Color(nsColor: .labelColor).opacity(0.3))
-                            .annotation(position: .top, spacing: 4) {
-                                Text(UsageFormatter.tokenCountString(bar.totalTokens))
-                                    .font(RunicFont.caption2)
-                                    .fontWeight(.medium)
-                                    .padding(.horizontal, 6)
-                                    .padding(.vertical, 2)
-                                    .background(
-                                        RoundedRectangle(cornerRadius: RunicCornerRadius.xs)
-                                            .fill(.ultraThinMaterial))
-                            }
-                    }
-                }
-                .chartXAxis {
-                    AxisMarks(values: [0, 6, 12, 18, 23]) { value in
-                        AxisValueLabel {
-                            if let hour = value.as(Int.self) {
-                                Text(Self.hourAxisLabel(hour))
-                                    .font(RunicFont.caption2)
-                                    .foregroundStyle(Color(nsColor: .tertiaryLabelColor))
-                            }
-                        }
-                    }
-                }
-                .chartYAxis {
-                    AxisMarks(position: .trailing) { value in
-                        AxisGridLine(stroke: StrokeStyle(lineWidth: 0.5, dash: [4, 3]))
-                            .foregroundStyle(Color(nsColor: .separatorColor).opacity(0.5))
-                        AxisValueLabel {
-                            if let tokens = value.as(Int.self) {
-                                Text(UsageFormatter.tokenCountString(tokens))
-                                    .font(RunicFont.caption2)
-                                    .foregroundStyle(Color(nsColor: .tertiaryLabelColor))
-                            }
-                        }
-                    }
-                }
-                .chartLegend(.hidden)
-                .frame(height: RunicSpacing.chartHeight - 30)
-                .chartOverlay { proxy in
-                    GeometryReader { geo in
-                        MouseLocationReader { location in
-                            self.updateHourSelection(location: location, proxy: proxy, geo: geo)
-                        }
-                        .frame(maxWidth: .infinity, maxHeight: .infinity)
-                        .contentShape(Rectangle())
-                    }
-                }
-
-                // Summary stats
-                HStack(spacing: RunicSpacing.md) {
-                    VStack(alignment: .leading, spacing: RunicSpacing.xxxs) {
-                        Text("Today")
-                            .font(RunicFont.caption2)
-                            .foregroundStyle(.tertiary)
-                        Text(UsageFormatter.tokenCountString(model.totalTokens))
-                            .font(RunicFont.caption)
-                            .fontWeight(.medium)
-                    }
-                    VStack(alignment: .leading, spacing: RunicSpacing.xxxs) {
-                        Text("Active hours")
-                            .font(RunicFont.caption2)
-                            .foregroundStyle(.tertiary)
-                        Text("\(model.activeHours)")
-                            .font(RunicFont.caption)
-                            .fontWeight(.medium)
-                    }
-                    if model.totalRequests > 0 {
-                        VStack(alignment: .leading, spacing: RunicSpacing.xxxs) {
-                            Text("Requests")
-                                .font(RunicFont.caption2)
-                                .foregroundStyle(.tertiary)
-                            Text("\(model.totalRequests)")
-                                .font(RunicFont.caption)
-                                .fontWeight(.medium)
-                        }
-                    }
-                }
-            }
-        }
-        .chartPanelStyle(width: self.width)
-        .accessibilityElement(children: .ignore)
-        .accessibilityLabel("Today by hour chart with \(model.activeHours) active hours")
-    }
-
-    // MARK: - Model
-
-    private struct HourlyModel {
-        let bars: [HourBar]
-        let peakHour: HourBar?
-        let totalTokens: Int
-        let activeHours: Int
-        let totalRequests: Int
-    }
-
-    private static func makeModel(from summaries: [UsageLedgerHourlySummary]) -> HourlyModel {
-        let calendar = Calendar.current
-        let todayStart = calendar.startOfDay(for: Date())
-
-        // Bucket by hour
-        var tokensByHour: [Int: Int] = [:]
-        var requestsByHour: [Int: Int] = [:]
-        for summary in summaries where summary.hourStart >= todayStart {
-            let hour = calendar.component(.hour, from: summary.hourStart)
-            tokensByHour[hour, default: 0] += summary.totals.totalTokens
-            requestsByHour[hour, default: 0] += summary.requestCount
-        }
-
-        let maxTokens = tokensByHour.values.max() ?? 0
-        var peakHour: HourBar?
-
-        let bars = (0..<24).map { hour in
-            let tokens = tokensByHour[hour] ?? 0
-            let isPeak = tokens > 0 && tokens == maxTokens
-            let bar = HourBar(id: hour, hour: hour, totalTokens: tokens, isPeak: isPeak)
-            if isPeak, tokens > 0 { peakHour = bar }
-            return bar
-        }
-
-        let totalTokens = tokensByHour.values.reduce(0, +)
-        let activeHours = tokensByHour.values.count(where: { $0 > 0 })
-        let totalRequests = requestsByHour.values.reduce(0, +)
-
-        return HourlyModel(
-            bars: bars,
-            peakHour: peakHour,
-            totalTokens: totalTokens,
-            activeHours: activeHours,
-            totalRequests: totalRequests)
-    }
-
-    private func updateHourSelection(
-        location: CGPoint?,
-        proxy: ChartProxy,
-        geo: GeometryProxy)
-    {
-        guard let location else {
-            if self.selectedHour != nil { self.selectedHour = nil }
-            return
-        }
-        guard let plotAnchor = proxy.plotFrame else { return }
-        let plotFrame = geo[plotAnchor]
-        guard plotFrame.contains(location) else {
-            if self.selectedHour != nil { self.selectedHour = nil }
-            return
-        }
-        let xInPlot = location.x - plotFrame.origin.x
-        guard let hour: Int = proxy.value(atX: xInPlot) else { return }
-        let clamped = max(0, min(23, hour))
-        if self.selectedHour != clamped { self.selectedHour = clamped }
-    }
-
-    private static func hourAxisLabel(_ hour: Int) -> String {
-        if hour == 0 { return "12AM" }
-        if hour < 12 { return "\(hour)AM" }
-        if hour == 12 { return "12PM" }
-        return "\(hour - 12)PM"
-    }
-}

package/Sources/Runic/Views/Menu/InlineUsageChartView.swift

@@ -1,157 +0,0 @@
-import Charts
-import RunicCore
-import SwiftUI
-
-/// Compact inline line chart displayed directly in the main menu card.
-/// Shows recent usage with a time-range segmented picker — inspired by Tokex.
-@MainActor
-struct InlineUsageChartView: View {
-    enum TimeRange: String, CaseIterable {
-        case threeDays = "3d"
-        case sevenDays = "7d"
-        case thirtyDays = "30d"
-        case quarter = "90d"
-        case year = "1y"
-
-        var cutoffInterval: TimeInterval {
-            switch self {
-            case .threeDays: -259_200
-            case .sevenDays: -604_800
-            case .thirtyDays: -2_592_000
-            case .quarter: -7_776_000
-            case .year: -31_536_000
-            }
-        }
-
-        var usesHourlyData: Bool {
-            false
-        }
-    }
-
-    private struct ChartPoint: Identifiable {
-        let id: String
-        let date: Date
-        let tokens: Int
-    }
-
-    let dailySummaries: [UsageLedgerDailySummary]
-    let hourlySummaries: [UsageLedgerHourlySummary]
-    let width: CGFloat
-    @State private var selectedRange: TimeRange = .sevenDays
-    @Environment(\.menuItemHighlighted) private var isHighlighted
-
-    private static let lineColor = RunicColors.chartColor(at: 0)
-
-    var body: some View {
-        let points = Self.dailyPoints(from: self.dailySummaries, range: self.selectedRange)
-
-        VStack(alignment: .leading, spacing: RunicSpacing.xs) {
-            // Time range picker
-            Picker("", selection: self.$selectedRange) {
-                ForEach(TimeRange.allCases, id: \.self) { range in
-                    Text(range.rawValue).tag(range)
-                }
-            }
-            .pickerStyle(.segmented)
-            .frame(maxWidth: .infinity)
-
-            // Chart area
-            if points.isEmpty {
-                HStack {
-                    Spacer()
-                    Text("No data")
-                        .font(RunicFont.caption2)
-                        .foregroundStyle(.tertiary)
-                    Spacer()
-                }
-                .frame(height: 70)
-            } else {
-                ZStack(alignment: .topTrailing) {
-                    Chart {
-                        ForEach(points) { point in
-                            AreaMark(
-                                x: .value("Time", point.date),
-                                y: .value("Tokens", point.tokens))
-                                .foregroundStyle(
-                                    LinearGradient(
-                                        colors: [
-                                            Self.lineColor.opacity(0.2),
-                                            Self.lineColor.opacity(0.02),
-                                        ],
-                                        startPoint: .top,
-                                        endPoint: .bottom))
-                                .interpolationMethod(.catmullRom)
-                            LineMark(
-                                x: .value("Time", point.date),
-                                y: .value("Tokens", point.tokens))
-                                .foregroundStyle(Self.lineColor)
-                                .lineStyle(StrokeStyle(lineWidth: 1.5))
-                                .interpolationMethod(.catmullRom)
-                        }
-                    }
-                    .chartYAxis {
-                        AxisMarks(position: .trailing, values: .automatic(desiredCount: 3)) { value in
-                            AxisGridLine(stroke: StrokeStyle(lineWidth: 0.3, dash: [3, 3]))
-                                .foregroundStyle(Color(nsColor: .separatorColor).opacity(0.3))
-                            AxisValueLabel {
-                                if let tokens = value.as(Int.self) {
-                                    Text(UsageFormatter.tokenCountString(tokens))
-                                        .font(RunicFont.system(size: 8))
-                                        .foregroundStyle(Color(nsColor: .tertiaryLabelColor))
-                                }
-                            }
-                        }
-                    }
-                    .chartXAxis {
-                        AxisMarks(values: .automatic(desiredCount: 4)) { _ in
-                            AxisValueLabel(format: self.xAxisFormat)
-                                .font(RunicFont.system(size: 8))
-                                .foregroundStyle(Color(nsColor: .tertiaryLabelColor))
-                        }
-                    }
-                    .chartLegend(.hidden)
-                    .frame(height: 70)
-
-                    // Peak badge
-                    if let peak = points.max(by: { $0.tokens < $1.tokens }), peak.tokens > 0 {
-                        Text("Peak \(UsageFormatter.tokenCountString(peak.tokens))")
-                            .font(RunicFont.system(size: 8, weight: .medium))
-                            .foregroundStyle(.secondary)
-                            .padding(.horizontal, 4)
-                            .padding(.vertical, 1)
-                            .background(
-                                Capsule(style: .continuous)
-                                    .fill(.ultraThinMaterial))
-                            .padding(4)
-                    }
-                }
-            }
-        }
-        .padding(.horizontal, MenuCardMetrics.horizontalPadding)
-        .padding(.vertical, RunicSpacing.xs)
-        .frame(minWidth: self.width, maxWidth: .infinity, alignment: .leading)
-        .accessibilityElement(children: .ignore)
-        .accessibilityLabel("Usage chart, \(self.selectedRange.rawValue) range, \(points.count) data points")
-    }
-
-    private var xAxisFormat: Date.FormatStyle {
-        if self.selectedRange.usesHourlyData {
-            return .dateTime.hour(.defaultDigits(amPM: .abbreviated))
-        }
-        return .dateTime.month(.abbreviated).day()
-    }
-
-    // MARK: - Data
-
-    private static func hourlyPoints(from summaries: [UsageLedgerHourlySummary], range: TimeRange) -> [ChartPoint] {
-        let cutoff = Date().addingTimeInterval(range.cutoffInterval)
-        let filtered = summaries.filter { $0.hourStart >= cutoff }.sorted { $0.hourStart < $1.hourStart }
-        return filtered.map { ChartPoint(id: $0.hourKey, date: $0.hourStart, tokens: $0.totals.totalTokens) }
-    }
-
-    private static func dailyPoints(from summaries: [UsageLedgerDailySummary], range: TimeRange) -> [ChartPoint] {
-        let cutoff = Date().addingTimeInterval(range.cutoffInterval)
-        let filtered = summaries.filter { $0.dayStart >= cutoff }.sorted { $0.dayStart < $1.dayStart }
-        return filtered.map { ChartPoint(id: $0.dayKey, date: $0.dayStart, tokens: $0.totals.totalTokens) }
-    }
-}

package/Sources/Runic/Views/Menu/MenuCardEntranceModifier.swift

@@ -1,63 +0,0 @@
-import SwiftUI
-
-/// Staggered fade+slide entrance animation for menu card sections.
-/// Each section slides up from a slight offset and fades in, with a delay
-/// proportional to its index for a cascading "liquid" reveal.
-struct MenuCardEntranceModifier: ViewModifier {
-    let index: Int
-    @State private var appeared = false
-
-    func body(content: Content) -> some View {
-        content
-            .opacity(self.appeared ? 1 : 0)
-            .offset(y: self.appeared ? 0 : 8)
-            .scaleEffect(self.appeared ? 1 : 0.97, anchor: .top)
-            .onAppear {
-                withAnimation(
-                    RunicAnimation.cardEntrance.delay(Double(self.index) * RunicAnimation.cardEntranceStagger))
-                {
-                    self.appeared = true
-                }
-            }
-    }
-}
-
-/// Subtle continuous shimmer sweep on glass surfaces.
-struct GlassShimmerModifier: ViewModifier {
-    @State private var shimmerPhase: CGFloat = -1
-
-    func body(content: Content) -> some View {
-        content
-            .overlay(
-                GeometryReader { geo in
-                    LinearGradient(
-                        stops: [
-                            .init(color: .clear, location: max(0, self.shimmerPhase - 0.15)),
-                            .init(color: .white.opacity(0.06), location: self.shimmerPhase),
-                            .init(color: .clear, location: min(1, self.shimmerPhase + 0.15)),
-                        ],
-                        startPoint: .leading,
-                        endPoint: .trailing)
-                        .frame(width: geo.size.width, height: geo.size.height)
-                        .allowsHitTesting(false)
-                }
-                .clipShape(RoundedRectangle(cornerRadius: RunicCornerRadius.lg, style: .continuous)))
-            .onAppear {
-                withAnimation(.easeInOut(duration: 2.0).delay(0.5)) {
-                    self.shimmerPhase = 1.2
-                }
-            }
-    }
-}
-
-extension View {
-    /// Apply staggered entrance animation. `index` controls the delay.
-    func menuCardEntrance(index: Int) -> some View {
-        self.modifier(MenuCardEntranceModifier(index: index))
-    }
-
-    /// Apply a single shimmer sweep across a glass surface.
-    func glassShimmer() -> some View {
-        self.modifier(GlassShimmerModifier())
-    }
-}

package/Sources/Runic/Views/Menu/MenuCardSidebarView.swift

@@ -1,248 +0,0 @@
-import AppKit
-import RunicCore
-import SwiftUI
-
-enum MenuCardSidebarMetrics {
-    struct Style {
-        let iconSize: CGFloat
-        let buttonSize: CGFloat
-        let spacing: CGFloat
-        let padding: CGFloat
-        let cornerRadius: CGFloat
-        let barHeight: CGFloat
-        let barInset: CGFloat
-
-        var width: CGFloat {
-            self.buttonSize + self.padding * 2
-        }
-    }
-
-    private static func smallStyle() -> Style {
-        Style(
-            iconSize: 18,
-            buttonSize: 26,
-            spacing: RunicSpacing.compact,
-            padding: RunicSpacing.xs,
-            cornerRadius: 7,
-            barHeight: 3,
-            barInset: RunicSpacing.xxs)
-    }
-
-    private static func mediumStyle() -> Style {
-        Style(
-            iconSize: 22,
-            buttonSize: 30,
-            spacing: RunicSpacing.xs,
-            padding: 10,
-            cornerRadius: RunicCornerRadius.md,
-            barHeight: 3,
-            barInset: RunicSpacing.xxs)
-    }
-
-    static func style(for providerCount: Int, iconSize: ProviderSwitcherIconSize) -> Style {
-        let needsCompact = providerCount >= 6
-        if needsCompact || iconSize == .small {
-            return self.smallStyle()
-        }
-        return self.mediumStyle()
-    }
-
-    static func sidebarWidth(for providerCount: Int, iconSize: ProviderSwitcherIconSize) -> CGFloat {
-        self.style(for: providerCount, iconSize: iconSize).width
-    }
-}
-
-struct ProviderSidebarMenuCardView<Content: View>: View {
-    let providers: [UsageProvider]
-    let selected: UsageProvider?
-    let totalWidth: CGFloat
-    let showIcons: Bool
-    let iconSize: ProviderSwitcherIconSize
-    let iconProvider: (UsageProvider, CGFloat) -> NSImage
-    let weeklyRemainingProvider: (UsageProvider) -> Double?
-    let onSelect: (UsageProvider) -> Void
-    @ViewBuilder let content: (CGFloat) -> Content
-
-    var body: some View {
-        let style = MenuCardSidebarMetrics.style(for: self.providers.count, iconSize: self.iconSize)
-        let sidebarWidth = style.width
-        let contentWidth = max(0, self.totalWidth - sidebarWidth)
-
-        // Content is the primary view that determines the height.
-        // The rail is placed as a background so its Rectangle fills
-        // stretch to match the content height instead of expanding
-        // to infinity during sizeThatFits measurement.
-        self.content(contentWidth)
-            .frame(width: contentWidth, alignment: .leading)
-            .padding(.leading, sidebarWidth)
-            .frame(width: self.totalWidth, alignment: .leading)
-            .background(alignment: .topLeading) {
-                ProviderSidebarRailView(
-                    providers: self.providers,
-                    selected: self.selected,
-                    showIcons: self.showIcons,
-                    style: style,
-                    iconProvider: self.iconProvider,
-                    weeklyRemainingProvider: self.weeklyRemainingProvider,
-                    onSelect: self.onSelect)
-                    .frame(width: sidebarWidth, alignment: .topLeading)
-            }
-    }
-}
-
-private struct ProviderSidebarRailView: View {
-    let providers: [UsageProvider]
-    let selected: UsageProvider?
-    let showIcons: Bool
-    let style: MenuCardSidebarMetrics.Style
-    let iconProvider: (UsageProvider, CGFloat) -> NSImage
-    let weeklyRemainingProvider: (UsageProvider) -> Double?
-    let onSelect: (UsageProvider) -> Void
-
-    @Environment(\.menuItemHighlighted) private var isHighlighted
-
-    private var railBackground: LinearGradient {
-        let base = Color(nsColor: .controlTextColor)
-            .opacity(self.isHighlighted ? RunicColors.Opacity.subtle : RunicColors.Opacity.nano)
-        return LinearGradient(
-            colors: [base, base.opacity(0.6)],
-            startPoint: .top,
-            endPoint: .bottom)
-    }
-
-    private var railGloss: LinearGradient {
-        let opacity = self.isHighlighted ? RunicColors.Opacity.light : RunicColors.Opacity.subtle
-        return LinearGradient(
-            colors: [Color.white.opacity(opacity), .clear],
-            startPoint: .topLeading,
-            endPoint: .bottomTrailing)
-    }
-
-    var body: some View {
-        ZStack(alignment: .topTrailing) {
-            Rectangle()
-                .fill(self.railBackground)
-            Rectangle()
-                .fill(self.railGloss)
-
-            if self.showIcons {
-                VStack(spacing: self.style.spacing) {
-                    ForEach(self.providers, id: \.self) { provider in
-                        ProviderSidebarIconButton(
-                            provider: provider,
-                            isSelected: provider == (self.selected ?? self.providers.first),
-                            icon: self.iconProvider(provider, self.style.iconSize),
-                            style: self.style,
-                            remainingPercent: self.weeklyRemainingProvider(provider),
-                            onSelect: { self.onSelect(provider) })
-                    }
-                }
-                .padding(.top, MenuCardMetrics.headerTopPadding + 4)
-                .padding(.bottom, MenuCardMetrics.tailPadding)
-                .padding(.horizontal, self.style.padding)
-            }
-
-            Rectangle()
-                .fill(Color(nsColor: .separatorColor)
-                    .opacity(self.isHighlighted ? RunicColors.Opacity.emphasis : RunicColors.Opacity.strong))
-                .frame(width: 1)
-                .padding(.top, MenuCardMetrics.headerTopPadding + 4)
-                .padding(.bottom, MenuCardMetrics.tailPadding)
-        }
-    }
-}
-
-private struct ProviderSidebarIconButton: View {
-    let provider: UsageProvider
-    let isSelected: Bool
-    let icon: NSImage
-    let style: MenuCardSidebarMetrics.Style
-    let remainingPercent: Double?
-    let onSelect: () -> Void
-
-    @Environment(\.menuItemHighlighted) private var isHighlighted
-
-    var body: some View {
-        Button(action: self.onSelect) {
-            ZStack {
-                RoundedRectangle(cornerRadius: self.style.cornerRadius, style: .continuous)
-                    .fill(self.backgroundColor)
-                    .overlay(
-                        RoundedRectangle(cornerRadius: self.style.cornerRadius, style: .continuous)
-                            .stroke(self.borderColor, lineWidth: self.isSelected ? 1 : 0))
-                    .overlay(
-                        RoundedRectangle(cornerRadius: self.style.cornerRadius, style: .continuous)
-                            .fill(self.glossOverlay)
-                            .opacity(self.isSelected ? 1 : 0.5))
-
-                Image(nsImage: self.icon)
-                    .resizable()
-                    .scaledToFit()
-                    .frame(width: self.style.iconSize, height: self.style.iconSize)
-                    .shadow(color: self.iconShadow, radius: self.isSelected ? 4 : 0, x: 0, y: 1)
-
-                if let remainingPercent, !self.isSelected {
-                    VStack {
-                        Spacer(minLength: 0)
-                        self.remainingBar(remainingPercent)
-                    }
-                    .padding(.bottom, self.style.barInset)
-                }
-            }
-            .frame(width: self.style.buttonSize, height: self.style.buttonSize)
-            .animation(RunicAnimation.highlight, value: self.isSelected)
-        }
-        .buttonStyle(.plain)
-        .accessibilityLabel(ProviderDescriptorRegistry.descriptor(for: self.provider).metadata.displayName)
-        .help(self.helpText)
-    }
-
-    private var backgroundColor: Color {
-        guard self.isSelected else { return Color.clear }
-        return self.brandColor.opacity(self.isHighlighted ? 0.32 : 0.22)
-    }
-
-    private var borderColor: Color {
-        guard self.isSelected else { return Color.clear }
-        return self.brandColor.opacity(self.isHighlighted ? 0.7 : 0.5)
-    }
-
-    private var iconShadow: Color {
-        guard self.isSelected else { return Color.clear }
-        return self.brandColor.opacity(self.isHighlighted ? 0.5 : 0.3)
-    }
-
-    private var brandColor: Color {
-        let color = ProviderDescriptorRegistry.descriptor(for: self.provider).branding.color
-        return Color(red: color.red, green: color.green, blue: color.blue)
-    }
-
-    private var glossOverlay: LinearGradient {
-        let opacity = self.isSelected ? 0.28 : 0.12
-        return LinearGradient(
-            colors: [Color.white.opacity(opacity), .clear],
-            startPoint: .topLeading,
-            endPoint: .bottomTrailing)
-    }
-
-    private var helpText: String {
-        let name = ProviderDescriptorRegistry.descriptor(for: self.provider).metadata.displayName
-        guard let remainingPercent else { return name }
-        let clamped = max(0, min(100, remainingPercent))
-        let percentText = String(format: "%.0f%%", clamped)
-        return "\(name) • Usage \(percentText)"
-    }
-
-    private func remainingBar(_ remainingPercent: Double) -> some View {
-        let ratio = CGFloat(max(0, min(1, remainingPercent / 100)))
-        let trackWidth = self.style.buttonSize - self.style.barInset * 2
-        return ZStack(alignment: .leading) {
-            Capsule()
-                .fill(Color(nsColor: .tertiaryLabelColor).opacity(RunicColors.Opacity.strong))
-            Capsule()
-                .fill(self.brandColor)
-                .frame(width: trackWidth * ratio)
-        }
-        .frame(width: trackWidth, height: self.style.barHeight)
-    }
-}