@sriinnu/runic 1.2.0 → 2.11.1

package/Sources/Runic/Core/Rendering/IconRenderer.swift

@@ -1,1216 +0,0 @@
-import AppKit
-import RunicCore
-
-/// **IconRenderer** - Generates menubar status item icons with usage visualization
-///
-/// **Purpose:**
-/// Creates pixel-perfect 18×18pt (36×36px @2x) template images for the macOS menubar.
-/// Renders usage bars, stale indicators, and provider status into the icon.
-///
-/// **Responsibilities:**
-/// - Generate icons showing session/weekly usage patterns
-/// - Apply stale data dimming when data is > 5 minutes old
-/// - Cache rendered icons for performance (64 icon cache, 512 morph cache)
-/// - Support template (adapts to menubar theme) and vibrant appearances
-/// - Render loading animations and error states
-///
-/// **Performance:**
-/// - **O(1) icon cache lookup** via IconCacheKey hash
-/// - **O(1) morph cache** for animation frames
-/// - Cap cache sizes via `PerformanceConstants`
-/// - All rendering happens off main thread in `dispatchPrecondition(condition: .notOnQueue(.main))`
-///
-/// **Dependencies:**
-/// - `PerformanceConstants` - Cache sizes and timing
-/// - `UsageProvider` - Provider-specific rendering
-/// - `AppKit/CoreGraphics` - Image generation
-///
-/// **Usage:**
-/// ```swift
-/// let icon = IconRenderer.render(
-///     state: .usage(snap, status),
-///     indicator: .none,
-///     appearance: .template,
-///     dataMode: .remaining
-/// )
-/// statusItem.button?.image = icon
-/// ```
-
-enum IconAppearance: Sendable {
-    case template   // Adapts to menubar theme (light/dark mode)
-    case vibrant    // Full color rendering
-}
-
-enum IconDataMode: Sendable {
-    case remaining  // Show remaining quota
-    case used       // Show used quota
-}
-
-enum IconRenderer {
-    private static let creditsCap: Double = 1000
-    private static let baseSize = NSSize(width: 38, height: 22)
-    // Render to a 38×22 pt template (76×44 px at 2×) for better visibility.
-    private static let outputSize = NSSize(width: 38, height: 22)
-    private static let outputScale: CGFloat = 2
-    private static let canvasPx = Int(outputSize.width * outputScale)
-    
-    // Infinity symbol base template - loaded lazily from Resources
-    private static let waveLogoTemplate: NSImage? = {
-        guard let url = Bundle.main.url(forResource: "RunicMenubarIcon", withExtension: "svg"),
-              let image = NSImage(contentsOf: url) else {
-            return nil
-        }
-        return image
-    }()
-
-    private struct PixelGrid: Sendable {
-        let scale: CGFloat
-
-        func pt(_ px: Int) -> CGFloat {
-            CGFloat(px) / self.scale
-        }
-
-        func rect(x: Int, y: Int, w: Int, h: Int) -> CGRect {
-            CGRect(x: self.pt(x), y: self.pt(y), width: self.pt(w), height: self.pt(h))
-        }
-
-        func snapDelta(_ value: CGFloat) -> CGFloat {
-            (value * self.scale).rounded() / self.scale
-        }
-    }
-
-    private static let grid = PixelGrid(scale: outputScale)
-
-    private struct IconCacheKey: Hashable {
-        let primary: Int
-        let weekly: Int
-        let credits: Int
-        let stale: Bool
-        let style: Int
-        let indicator: Int
-        let appearance: Int
-        let dataMode: Int
-    }
-
-    private final class IconCacheStore: @unchecked Sendable {
-        private var cache: [IconCacheKey: NSImage] = [:]
-        private var order: [IconCacheKey] = []
-        private let lock = NSLock()
-
-        func cachedIcon(for key: IconCacheKey) -> NSImage? {
-            self.lock.lock()
-            defer { self.lock.unlock() }
-            guard let image = self.cache[key] else { return nil }
-            if let idx = self.order.firstIndex(of: key) {
-                self.order.remove(at: idx)
-                self.order.append(key)
-            }
-            return image
-        }
-
-        func storeIcon(_ image: NSImage, for key: IconCacheKey, limit: Int) {
-            self.lock.lock()
-            defer { self.lock.unlock() }
-            self.cache[key] = image
-            self.order.removeAll { $0 == key }
-            self.order.append(key)
-            while self.order.count > limit {
-                let oldest = self.order.removeFirst()
-                self.cache.removeValue(forKey: oldest)
-            }
-        }
-    }
-
-    private static let iconCacheStore = IconCacheStore()
-    private static let iconCacheLimit = PerformanceConstants.iconCacheSize
-    private static let morphBucketCount = 200
-    private static let morphCache = MorphCache(limit: PerformanceConstants.morphCacheSize)
-
-    private final class MorphCache: @unchecked Sendable {
-        private let cache = NSCache<NSNumber, NSImage>()
-
-        init(limit: Int) {
-            self.cache.countLimit = limit
-        }
-
-        func image(for key: NSNumber) -> NSImage? {
-            self.cache.object(forKey: key)
-        }
-
-        func set(_ image: NSImage, for key: NSNumber) {
-            self.cache.setObject(image, forKey: key)
-        }
-    }
-
-    private struct RectPx: Hashable, Sendable {
-        let x: Int
-        let y: Int
-        let w: Int
-        let h: Int
-
-        var midXPx: Int { self.x + self.w / 2 }
-        var midYPx: Int { self.y + self.h / 2 }
-
-        func rect() -> CGRect {
-            Self.grid.rect(x: self.x, y: self.y, w: self.w, h: self.h)
-        }
-
-        private static let grid = IconRenderer.grid
-    }
-
-    private enum SigilStyle {
-        case codex
-        case claude
-        case gemini
-        case antigravity
-        case cursor
-        case factory
-        case copilot
-        case minimax
-        case openrouter
-        case groq
-        case deepseek
-        case fireworks
-        case mistral
-        case perplexity
-        case kimi
-        case auggie
-        case together
-        case cohere
-        case xai
-        case cerebras
-        case sambanova
-        case azure
-        case bedrock
-        case vertexai
-        case zai
-        case qwen
-        case combined
-    }
-
-    // swiftlint:disable function_body_length
-    static func makeIcon(
-        primaryRemaining: Double?,
-        weeklyRemaining: Double?,
-        creditsRemaining: Double?,
-        stale: Bool,
-        style: IconStyle,
-        blink: CGFloat = 0,
-        wiggle: CGFloat = 0,
-        tilt: CGFloat = 0,
-        statusIndicator: ProviderStatusIndicator = .none,
-        appearance: IconAppearance = .template,
-        dataMode: IconDataMode = .remaining) -> NSImage
-    {
-        let shouldCache = blink <= 0.0001 && wiggle <= 0.0001 && tilt <= 0.0001
-        let render = {
-            self.renderImage(isTemplate: appearance == .template) {
-                let topValue = primaryRemaining
-                let bottomValue = weeklyRemaining
-                let creditsRatio = creditsRemaining.map { min($0 / Self.creditsCap * 100, 100) }
-                let pressure = Self.usagePressure(
-                    primary: topValue,
-                    weekly: bottomValue,
-                    credits: creditsRatio,
-                    dataMode: dataMode)
-                let accentColor = Self.vibrantAccentColor(pressure: pressure, stale: stale)
-                let baseColor = appearance == .template ? NSColor.labelColor : accentColor
-                
-                // Disable blink effect to prevent flicker
-                let opacityMultiplier = 1.0
-                
-                let fillColor = baseColor.withAlphaComponent((stale ? 0.55 : 1.0) * opacityMultiplier)
-                let baseAlpha: CGFloat = (stale ? 0.18 : (appearance == .template ? 0.28 : 0.38)) * opacityMultiplier
-                
-                let fillPercent = Self.iconFillPercent(
-                    primary: topValue,
-                    weekly: bottomValue,
-                    credits: creditsRatio,
-                    dataMode: dataMode)
-
-                Self.drawWaveLogo(
-                    fillPercent: fillPercent,
-                    baseColor: baseColor.withAlphaComponent(baseAlpha),
-                    fillColor: fillColor)
-
-                let overlayColor = appearance == .template
-                    ? NSColor.labelColor
-                    : NSColor.white.withAlphaComponent(0.92)
-                Self.drawStatusOverlay(indicator: statusIndicator, color: overlayColor)
-            }
-        }
-
-        if shouldCache {
-            let key = IconCacheKey(
-                primary: self.quantizedPercent(primaryRemaining),
-                weekly: self.quantizedPercent(weeklyRemaining),
-                credits: self.quantizedCredits(creditsRemaining),
-                stale: stale,
-                style: self.styleKey(style),
-                indicator: self.indicatorKey(statusIndicator),
-                appearance: self.appearanceKey(appearance),
-                dataMode: self.dataModeKey(dataMode))
-            if let cached = self.cachedIcon(for: key) {
-                return cached
-            }
-            let image = render()
-            self.storeIcon(image, for: key)
-            return image
-        }
-
-        return render()
-    }
-
-    // swiftlint:enable function_body_length
-
-    private static func sigilStyle(for style: IconStyle) -> SigilStyle {
-        switch style {
-        case .codex: return .codex
-        case .claude: return .claude
-        case .zai: return .zai
-        case .gemini: return .gemini
-        case .antigravity: return .antigravity
-        case .cursor: return .cursor
-        case .factory: return .factory
-        case .copilot: return .copilot
-        case .minimax: return .minimax
-        case .openrouter: return .openrouter
-        case .groq: return .groq
-        case .deepseek: return .deepseek
-        case .fireworks: return .fireworks
-        case .mistral: return .mistral
-        case .perplexity: return .perplexity
-        case .kimi: return .kimi
-        case .auggie: return .auggie
-        case .together: return .together
-        case .cohere: return .cohere
-        case .xai: return .xai
-        case .cerebras: return .cerebras
-        case .sambanova: return .sambanova
-        case .azure: return .azure
-        case .bedrock: return .bedrock
-        case .vertexai: return .vertexai
-        case .qwen: return .qwen
-        case .combined: return .combined
-        }
-    }
-
-    private static func chamferedPath(rectPx: RectPx, chamferPx: Int) -> NSBezierPath {
-        let rect = rectPx.rect()
-        let chamfer = Self.grid.pt(chamferPx)
-        let x = rect.minX
-        let y = rect.minY
-        let w = rect.width
-        let h = rect.height
-        let path = NSBezierPath()
-        path.move(to: NSPoint(x: x + chamfer, y: y))
-        path.line(to: NSPoint(x: x + w - chamfer, y: y))
-        path.line(to: NSPoint(x: x + w, y: y + chamfer))
-        path.line(to: NSPoint(x: x + w, y: y + h - chamfer))
-        path.line(to: NSPoint(x: x + w - chamfer, y: y + h))
-        path.line(to: NSPoint(x: x + chamfer, y: y + h))
-        path.line(to: NSPoint(x: x, y: y + h - chamfer))
-        path.line(to: NSPoint(x: x, y: y + chamfer))
-        path.close()
-        return path
-    }
-
-    private static func drawSigil(_ style: SigilStyle, in rectPx: RectPx) {
-        guard let ctx = NSGraphicsContext.current?.cgContext else { return }
-        let centerXPx = rectPx.midXPx
-        let centerYPx = rectPx.y + rectPx.h / 2
-
-        func point(x: Int, y: Int) -> NSPoint {
-            NSPoint(x: Self.grid.pt(x), y: Self.grid.pt(y))
-        }
-
-        ctx.saveGState()
-        ctx.setBlendMode(.clear)
-        ctx.setShouldAntialias(true)
-
-        switch style {
-        case .codex:
-            let eyeSizePx = 3
-            let eyeOffsetPx = 5
-            let leftEye = Self.grid.rect(
-                x: centerXPx - eyeOffsetPx - eyeSizePx / 2,
-                y: centerYPx - eyeSizePx / 2,
-                w: eyeSizePx,
-                h: eyeSizePx)
-            let rightEye = Self.grid.rect(
-                x: centerXPx + eyeOffsetPx - eyeSizePx / 2,
-                y: centerYPx - eyeSizePx / 2,
-                w: eyeSizePx,
-                h: eyeSizePx)
-            NSBezierPath(rect: leftEye).fill()
-            NSBezierPath(rect: rightEye).fill()
-        case .claude:
-            let slitWidthPx = 2
-            let slitHeightPx = 6
-            let slitOffsetPx = 5
-            let leftSlit = Self.grid.rect(
-                x: centerXPx - slitOffsetPx - slitWidthPx / 2,
-                y: centerYPx - slitHeightPx / 2,
-                w: slitWidthPx,
-                h: slitHeightPx)
-            let rightSlit = Self.grid.rect(
-                x: centerXPx + slitOffsetPx - slitWidthPx / 2,
-                y: centerYPx - slitHeightPx / 2,
-                w: slitWidthPx,
-                h: slitHeightPx)
-            NSBezierPath(rect: leftSlit).fill()
-            NSBezierPath(rect: rightSlit).fill()
-        case .gemini:
-            let diamondRadiusPx = 4
-            let cx = Self.grid.pt(centerXPx)
-            let cy = Self.grid.pt(centerYPx)
-            let r = Self.grid.pt(diamondRadiusPx)
-            let path = NSBezierPath()
-            path.move(to: NSPoint(x: cx, y: cy + r))
-            path.line(to: NSPoint(x: cx + r, y: cy))
-            path.line(to: NSPoint(x: cx, y: cy - r))
-            path.line(to: NSPoint(x: cx - r, y: cy))
-            path.close()
-            path.fill()
-        case .antigravity:
-            let dotSizePx = 4
-            let dotRect = Self.grid.rect(
-                x: centerXPx - dotSizePx / 2,
-                y: rectPx.y + rectPx.h - dotSizePx - 1,
-                w: dotSizePx,
-                h: dotSizePx)
-            NSBezierPath(ovalIn: dotRect).fill()
-        case .cursor:
-            let tipPx = 6
-            let baseXPx = centerXPx + 4
-            let path = NSBezierPath()
-            path.move(to: point(x: baseXPx, y: centerYPx))
-            path.line(to: point(x: baseXPx - tipPx, y: centerYPx + tipPx / 2))
-            path.line(to: point(x: baseXPx - tipPx, y: centerYPx - tipPx / 2))
-            path.close()
-            path.fill()
-        case .factory:
-            let armPx = 6
-            let thicknessPx = 2
-            let vertical = Self.grid.rect(
-                x: centerXPx - thicknessPx / 2,
-                y: centerYPx - armPx / 2,
-                w: thicknessPx,
-                h: armPx)
-            let horizontal = Self.grid.rect(
-                x: centerXPx - armPx / 2,
-                y: centerYPx - thicknessPx / 2,
-                w: armPx,
-                h: thicknessPx)
-            NSBezierPath(rect: vertical).fill()
-            NSBezierPath(rect: horizontal).fill()
-        case .copilot:
-            let eyeRadiusPx = 3
-            let eyeOffsetPx = 4
-            let leftEye = Self.grid.rect(
-                x: centerXPx - eyeOffsetPx - eyeRadiusPx,
-                y: centerYPx - eyeRadiusPx,
-                w: eyeRadiusPx * 2,
-                h: eyeRadiusPx * 2)
-            let rightEye = Self.grid.rect(
-                x: centerXPx + eyeOffsetPx - eyeRadiusPx,
-                y: centerYPx - eyeRadiusPx,
-                w: eyeRadiusPx * 2,
-                h: eyeRadiusPx * 2)
-            let bridge = Self.grid.rect(
-                x: centerXPx - 2,
-                y: centerYPx - 1,
-                w: 4,
-                h: 2)
-            NSBezierPath(ovalIn: leftEye).fill()
-            NSBezierPath(ovalIn: rightEye).fill()
-            NSBezierPath(rect: bridge).fill()
-        case .minimax:
-            let triWidthPx = 6
-            let triHeightPx = 5
-            let leftCx = centerXPx - 4
-            let rightCx = centerXPx + 4
-            let leftPath = NSBezierPath()
-            leftPath.move(to: point(x: leftCx, y: centerYPx + triHeightPx / 2))
-            leftPath.line(to: point(x: leftCx - triWidthPx / 2, y: centerYPx - triHeightPx / 2))
-            leftPath.line(to: point(x: leftCx + triWidthPx / 2, y: centerYPx - triHeightPx / 2))
-            leftPath.close()
-            let rightPath = NSBezierPath()
-            rightPath.move(to: point(x: rightCx, y: centerYPx + triHeightPx / 2))
-            rightPath.line(to: point(x: rightCx - triWidthPx / 2, y: centerYPx - triHeightPx / 2))
-            rightPath.line(to: point(x: rightCx + triWidthPx / 2, y: centerYPx - triHeightPx / 2))
-            rightPath.close()
-            leftPath.fill()
-            rightPath.fill()
-        case .openrouter:
-            let outerRadiusPx = 4
-            let innerRadiusPx = 2
-            let outerRect = Self.grid.rect(
-                x: centerXPx - outerRadiusPx,
-                y: centerYPx - outerRadiusPx,
-                w: outerRadiusPx * 2,
-                h: outerRadiusPx * 2)
-            let innerRect = Self.grid.rect(
-                x: centerXPx - innerRadiusPx,
-                y: centerYPx - innerRadiusPx,
-                w: innerRadiusPx * 2,
-                h: innerRadiusPx * 2)
-            let ring = NSBezierPath()
-            ring.appendOval(in: outerRect)
-            ring.appendOval(in: innerRect)
-            ring.windingRule = .evenOdd
-            ring.fill()
-        case .groq:
-            let slashWidthPx = 2
-            let slashHeightPx = 8
-            let path = NSBezierPath()
-            path.move(to: point(x: centerXPx - slashWidthPx, y: centerYPx - slashHeightPx / 2))
-            path.line(to: point(x: centerXPx, y: centerYPx - slashHeightPx / 2))
-            path.line(to: point(x: centerXPx + slashWidthPx, y: centerYPx + slashHeightPx / 2))
-            path.line(to: point(x: centerXPx, y: centerYPx + slashHeightPx / 2))
-            path.close()
-            path.fill()
-        case .deepseek:
-            let radiusPx = 4
-            let dotPx = 2
-            let outerRect = Self.grid.rect(
-                x: centerXPx - radiusPx,
-                y: centerYPx - radiusPx,
-                w: radiusPx * 2,
-                h: radiusPx * 2)
-            NSBezierPath(ovalIn: outerRect).fill()
-            let innerRect = Self.grid.rect(
-                x: centerXPx - dotPx / 2,
-                y: centerYPx - dotPx / 2,
-                w: dotPx,
-                h: dotPx)
-            NSBezierPath(ovalIn: innerRect).fill()
-        case .fireworks:
-            let armPx = 5
-            let armWidthPx = 2
-            let vertical = Self.grid.rect(
-                x: centerXPx - armWidthPx / 2,
-                y: centerYPx - armPx,
-                w: armWidthPx,
-                h: armPx * 2)
-            let horizontal = Self.grid.rect(
-                x: centerXPx - armPx,
-                y: centerYPx - armWidthPx / 2,
-                w: armPx * 2,
-                h: armWidthPx)
-            NSBezierPath(rect: vertical).fill()
-            NSBezierPath(rect: horizontal).fill()
-            let diag = NSBezierPath()
-            diag.move(to: point(x: centerXPx - 3, y: centerYPx - 3))
-            diag.line(to: point(x: centerXPx - 1, y: centerYPx - 3))
-            diag.line(to: point(x: centerXPx + 3, y: centerYPx + 1))
-            diag.line(to: point(x: centerXPx + 3, y: centerYPx + 3))
-            diag.line(to: point(x: centerXPx + 1, y: centerYPx + 3))
-            diag.line(to: point(x: centerXPx - 3, y: centerYPx - 1))
-            diag.close()
-            diag.fill()
-        case .mistral:
-            let barWidthPx = 2
-            let barGapPx = 1
-            let barHeightPx = 6
-            let totalWidth = barWidthPx * 3 + barGapPx * 2
-            let startX = centerXPx - totalWidth / 2
-            for idx in 0 ..< 3 {
-                let x = startX + idx * (barWidthPx + barGapPx)
-                let rect = Self.grid.rect(
-                    x: x,
-                    y: centerYPx - barHeightPx / 2 + (idx == 1 ? 1 : 0),
-                    w: barWidthPx,
-                    h: barHeightPx - (idx == 1 ? 2 : 0))
-                NSBezierPath(rect: rect).fill()
-            }
-        case .perplexity:
-            let loopRadiusPx = 4
-            let stemWidthPx = 2
-            let stemHeightPx = 5
-            let loopRect = Self.grid.rect(
-                x: centerXPx - loopRadiusPx,
-                y: centerYPx - loopRadiusPx,
-                w: loopRadiusPx * 2,
-                h: loopRadiusPx * 2)
-            let innerRect = Self.grid.rect(
-                x: centerXPx - 1,
-                y: centerYPx - 1,
-                w: 2,
-                h: 2)
-            let loop = NSBezierPath()
-            loop.appendOval(in: loopRect)
-            loop.appendOval(in: innerRect)
-            loop.windingRule = .evenOdd
-            loop.fill()
-            let stemRect = Self.grid.rect(
-                x: centerXPx + 1,
-                y: centerYPx - loopRadiusPx - stemHeightPx + 1,
-                w: stemWidthPx,
-                h: stemHeightPx)
-            NSBezierPath(rect: stemRect).fill()
-        case .kimi:
-            let ringRect = Self.grid.rect(
-                x: centerXPx - 4,
-                y: centerYPx - 4,
-                w: 8,
-                h: 8)
-            let coreRect = Self.grid.rect(
-                x: centerXPx - 1,
-                y: centerYPx - 1,
-                w: 2,
-                h: 2)
-            let ring = NSBezierPath()
-            ring.appendOval(in: ringRect)
-            ring.appendOval(in: coreRect)
-            ring.windingRule = .evenOdd
-            ring.fill()
-        case .auggie:
-            let armPx = 5
-            let left = NSBezierPath()
-            left.move(to: point(x: centerXPx - armPx, y: centerYPx - 3))
-            left.line(to: point(x: centerXPx - 1, y: centerYPx + 4))
-            left.line(to: point(x: centerXPx + 1, y: centerYPx + 4))
-            left.line(to: point(x: centerXPx - 3, y: centerYPx - 3))
-            left.close()
-            left.fill()
-            let right = NSBezierPath()
-            right.move(to: point(x: centerXPx + armPx, y: centerYPx - 3))
-            right.line(to: point(x: centerXPx + 1, y: centerYPx + 4))
-            right.line(to: point(x: centerXPx - 1, y: centerYPx + 4))
-            right.line(to: point(x: centerXPx + 3, y: centerYPx - 3))
-            right.close()
-            right.fill()
-        case .together:
-            let topRect = Self.grid.rect(
-                x: centerXPx - 4,
-                y: centerYPx + 1,
-                w: 8,
-                h: 2)
-            let bottomRect = Self.grid.rect(
-                x: centerXPx - 4,
-                y: centerYPx - 3,
-                w: 8,
-                h: 2)
-            let joinRect = Self.grid.rect(
-                x: centerXPx - 1,
-                y: centerYPx - 3,
-                w: 2,
-                h: 6)
-            NSBezierPath(rect: topRect).fill()
-            NSBezierPath(rect: bottomRect).fill()
-            NSBezierPath(rect: joinRect).fill()
-        case .cohere:
-            let outerRect = Self.grid.rect(
-                x: centerXPx - 4,
-                y: centerYPx - 4,
-                w: 8,
-                h: 8)
-            let innerRect = Self.grid.rect(
-                x: centerXPx - 2,
-                y: centerYPx - 2,
-                w: 4,
-                h: 4)
-            let cPath = NSBezierPath()
-            cPath.appendOval(in: outerRect)
-            cPath.appendOval(in: innerRect)
-            cPath.windingRule = .evenOdd
-            cPath.fill()
-            let cutRect = Self.grid.rect(
-                x: centerXPx + 1,
-                y: centerYPx - 4,
-                w: 4,
-                h: 8)
-            NSBezierPath(rect: cutRect).fill()
-        case .xai:
-            let left = NSBezierPath()
-            left.move(to: point(x: centerXPx - 4, y: centerYPx - 4))
-            left.line(to: point(x: centerXPx - 1, y: centerYPx - 1))
-            left.line(to: point(x: centerXPx - 4, y: centerYPx + 4))
-            left.line(to: point(x: centerXPx - 2, y: centerYPx + 4))
-            left.line(to: point(x: centerXPx + 1, y: centerYPx + 1))
-            left.line(to: point(x: centerXPx + 4, y: centerYPx + 4))
-            left.line(to: point(x: centerXPx + 4, y: centerYPx + 2))
-            left.line(to: point(x: centerXPx + 1, y: centerYPx - 1))
-            left.line(to: point(x: centerXPx + 4, y: centerYPx - 4))
-            left.line(to: point(x: centerXPx + 2, y: centerYPx - 4))
-            left.line(to: point(x: centerXPx - 1, y: centerYPx - 1))
-            left.line(to: point(x: centerXPx - 4, y: centerYPx - 4))
-            left.close()
-            left.fill()
-        case .cerebras:
-            let outerRect = Self.grid.rect(
-                x: centerXPx - 4,
-                y: centerYPx - 4,
-                w: 8,
-                h: 8)
-            let innerRect = Self.grid.rect(
-                x: centerXPx - 2,
-                y: centerYPx - 2,
-                w: 4,
-                h: 4)
-            let ring = NSBezierPath()
-            ring.appendOval(in: outerRect)
-            ring.appendOval(in: innerRect)
-            ring.windingRule = .evenOdd
-            ring.fill()
-            let notchRect = Self.grid.rect(
-                x: centerXPx + 1,
-                y: centerYPx - 2,
-                w: 4,
-                h: 4)
-            NSBezierPath(rect: notchRect).fill()
-        case .sambanova:
-            let topArc = NSBezierPath()
-            topArc.move(to: point(x: centerXPx - 4, y: centerYPx + 3))
-            topArc.curve(
-                to: point(x: centerXPx + 4, y: centerYPx + 3),
-                controlPoint1: point(x: centerXPx - 1, y: centerYPx + 6),
-                controlPoint2: point(x: centerXPx + 1, y: centerYPx + 6))
-            topArc.line(to: point(x: centerXPx + 4, y: centerYPx + 1))
-            topArc.curve(
-                to: point(x: centerXPx - 4, y: centerYPx + 1),
-                controlPoint1: point(x: centerXPx + 1, y: centerYPx + 4),
-                controlPoint2: point(x: centerXPx - 1, y: centerYPx + 4))
-            topArc.close()
-            topArc.fill()
-            let bottomArc = NSBezierPath()
-            bottomArc.move(to: point(x: centerXPx + 4, y: centerYPx - 3))
-            bottomArc.curve(
-                to: point(x: centerXPx - 4, y: centerYPx - 3),
-                controlPoint1: point(x: centerXPx + 1, y: centerYPx - 6),
-                controlPoint2: point(x: centerXPx - 1, y: centerYPx - 6))
-            bottomArc.line(to: point(x: centerXPx - 4, y: centerYPx - 1))
-            bottomArc.curve(
-                to: point(x: centerXPx + 4, y: centerYPx - 1),
-                controlPoint1: point(x: centerXPx - 1, y: centerYPx - 4),
-                controlPoint2: point(x: centerXPx + 1, y: centerYPx - 4))
-            bottomArc.close()
-            bottomArc.fill()
-        case .azure:
-            let outerRect = Self.grid.rect(
-                x: centerXPx - 4,
-                y: centerYPx - 4,
-                w: 8,
-                h: 8)
-            let innerRect = Self.grid.rect(
-                x: centerXPx - 2,
-                y: centerYPx - 2,
-                w: 4,
-                h: 4)
-            let ring = NSBezierPath()
-            ring.appendOval(in: outerRect)
-            ring.appendOval(in: innerRect)
-            ring.windingRule = .evenOdd
-            ring.fill()
-            let slash = NSBezierPath()
-            slash.move(to: point(x: centerXPx - 5, y: centerYPx - 1))
-            slash.line(to: point(x: centerXPx - 3, y: centerYPx - 3))
-            slash.line(to: point(x: centerXPx + 5, y: centerYPx + 5))
-            slash.line(to: point(x: centerXPx + 3, y: centerYPx + 7))
-            slash.close()
-            slash.fill()
-        case .bedrock:
-            let top = NSBezierPath()
-            top.move(to: point(x: centerXPx - 4, y: centerYPx + 2))
-            top.line(to: point(x: centerXPx, y: centerYPx + 6))
-            top.line(to: point(x: centerXPx + 4, y: centerYPx + 2))
-            top.line(to: point(x: centerXPx + 2, y: centerYPx))
-            top.line(to: point(x: centerXPx, y: centerYPx + 2))
-            top.line(to: point(x: centerXPx - 2, y: centerYPx))
-            top.close()
-            top.fill()
-            let bottom = NSBezierPath()
-            bottom.move(to: point(x: centerXPx - 4, y: centerYPx - 2))
-            bottom.line(to: point(x: centerXPx, y: centerYPx - 6))
-            bottom.line(to: point(x: centerXPx + 4, y: centerYPx - 2))
-            bottom.line(to: point(x: centerXPx + 2, y: centerYPx))
-            bottom.line(to: point(x: centerXPx, y: centerYPx - 2))
-            bottom.line(to: point(x: centerXPx - 2, y: centerYPx))
-            bottom.close()
-            bottom.fill()
-        case .vertexai:
-            let diamond = NSBezierPath()
-            diamond.move(to: point(x: centerXPx, y: centerYPx + 6))
-            diamond.line(to: point(x: centerXPx + 5, y: centerYPx))
-            diamond.line(to: point(x: centerXPx, y: centerYPx - 6))
-            diamond.line(to: point(x: centerXPx - 5, y: centerYPx))
-            diamond.close()
-            diamond.fill()
-        case .zai:
-            let slashGapPx = 3
-            let slashWidthPx = 2
-            let slashHeightPx = 7
-            let leftPath = NSBezierPath()
-            leftPath.move(to: point(x: centerXPx - slashGapPx, y: centerYPx - slashHeightPx / 2))
-            leftPath.line(to: point(x: centerXPx - slashGapPx + slashWidthPx, y: centerYPx - slashHeightPx / 2))
-            leftPath.line(to: point(x: centerXPx - slashGapPx + slashWidthPx + 2, y: centerYPx + slashHeightPx / 2))
-            leftPath.line(to: point(x: centerXPx - slashGapPx + 2, y: centerYPx + slashHeightPx / 2))
-            leftPath.close()
-            let rightPath = NSBezierPath()
-            rightPath.move(to: point(x: centerXPx + slashGapPx, y: centerYPx - slashHeightPx / 2))
-            rightPath.line(to: point(x: centerXPx + slashGapPx + slashWidthPx, y: centerYPx - slashHeightPx / 2))
-            rightPath.line(to: point(x: centerXPx + slashGapPx + slashWidthPx + 2, y: centerYPx + slashHeightPx / 2))
-            rightPath.line(to: point(x: centerXPx + slashGapPx + 2, y: centerYPx + slashHeightPx / 2))
-            rightPath.close()
-            leftPath.fill()
-            rightPath.fill()
-        case .qwen:
-            // Stylised "Q" ring -- outer circle punch with inner cutout.
-            let ringOuter = 5
-            let ringInner = 3
-            let outerRect = Self.grid.rect(
-                x: centerXPx - ringOuter,
-                y: centerYPx - ringOuter,
-                w: ringOuter * 2,
-                h: ringOuter * 2)
-            let innerRect = Self.grid.rect(
-                x: centerXPx - ringInner,
-                y: centerYPx - ringInner,
-                w: ringInner * 2,
-                h: ringInner * 2)
-            NSBezierPath(ovalIn: outerRect).fill()
-            ctx.setBlendMode(.normal)
-            NSGraphicsContext.current?.cgContext.setFillColor(NSColor.clear.cgColor)
-            ctx.setBlendMode(.clear)
-            NSBezierPath(ovalIn: innerRect).fill()
-        case .combined:
-            let diamondRadiusPx = 4
-            let cx = Self.grid.pt(centerXPx)
-            let cy = Self.grid.pt(centerYPx)
-            let r = Self.grid.pt(diamondRadiusPx)
-            let path = NSBezierPath()
-            path.move(to: NSPoint(x: cx, y: cy + r))
-            path.line(to: NSPoint(x: cx + r, y: cy))
-            path.line(to: NSPoint(x: cx, y: cy - r))
-            path.line(to: NSPoint(x: cx - r, y: cy))
-            path.close()
-            path.fill()
-        }
-
-        ctx.restoreGState()
-    }
-
-    /// Morph helper: unbraids a simplified knot into our bar icon.
-    static func makeMorphIcon(
-        progress: Double,
-        style: IconStyle,
-        appearance: IconAppearance = .template) -> NSImage
-    {
-        let clamped = max(0, min(progress, 1))
-        let key = self.morphCacheKey(progress: clamped, style: style, appearance: appearance)
-        if let cached = self.morphCache.image(for: key) {
-            return cached
-        }
-        let baseColor = appearance == .template
-            ? NSColor.labelColor
-            : self.vibrantAccentColor(pressure: 0.15, stale: false)
-        let image = self.renderImage(isTemplate: appearance == .template) {
-            self.drawUnbraidMorph(t: clamped, style: style, color: baseColor, appearance: appearance)
-        }
-        self.morphCache.set(image, for: key)
-        return image
-    }
-
-    private static func iconFillPercent(
-        primary: Double?,
-        weekly: Double?,
-        credits: Double?,
-        dataMode: IconDataMode) -> Double
-    {
-        let value = primary ?? weekly ?? credits
-        guard let value else { return 0 }
-        let clamped = max(0, min(value / 100, 1))
-        switch dataMode {
-        case .remaining:
-            return clamped
-        case .used:
-            return clamped
-        }
-    }
-
-    private static func drawWaveLogo(
-        fillPercent: Double,
-        baseColor: NSColor,
-        fillColor: NSColor)
-    {
-        guard let waveLogo = self.waveLogoTemplate,
-              let ctx = NSGraphicsContext.current?.cgContext else {
-            return
-        }
-
-        let rect = CGRect(origin: .zero, size: self.outputSize)
-        let clamped = max(0, min(fillPercent, 1))
-
-        // Base silhouette
-        ctx.saveGState()
-        waveLogo.draw(in: rect, from: .zero, operation: .sourceOver, fraction: 1.0)
-        ctx.setBlendMode(.sourceIn)
-        baseColor.setFill()
-        ctx.fill(rect)
-        ctx.restoreGState()
-
-        // Usage fill: left-to-right reveal within the infinity symbol.
-        guard clamped > 0 else { return }
-        ctx.saveGState()
-        waveLogo.draw(in: rect, from: .zero, operation: .sourceOver, fraction: 1.0)
-        ctx.setBlendMode(.sourceIn)
-        fillColor.setFill()
-        let fillRect = CGRect(x: rect.minX, y: rect.minY, width: rect.width * clamped, height: rect.height)
-        ctx.fill(fillRect)
-        ctx.restoreGState()
-    }
-
-    private static func usagePressure(
-        primary: Double?,
-        weekly: Double?,
-        credits: Double?,
-        dataMode: IconDataMode) -> Double
-    {
-        let values = [primary, weekly, credits].compactMap { $0 }
-        guard !values.isEmpty else { return 0 }
-        let normalized = values.map { max(0, min($0 / 100, 1)) }
-        switch dataMode {
-        case .used:
-            return normalized.max() ?? 0
-        case .remaining:
-            let minRemaining = normalized.min() ?? 1
-            return max(0, min(1, 1 - minRemaining))
-        }
-    }
-
-    private static func vibrantAccentColor(pressure: Double, stale: Bool) -> NSColor {
-        let clamped = CGFloat(max(0, min(pressure, 1)))
-        let safe = NSColor(calibratedRed: 0.12, green: 0.86, blue: 0.78, alpha: 1)
-        let warn = NSColor(calibratedRed: 1.00, green: 0.72, blue: 0.30, alpha: 1)
-        let hot = NSColor(calibratedRed: 1.00, green: 0.31, blue: 0.44, alpha: 1)
-        let color: NSColor
-        if clamped <= 0.5 {
-            color = self.mixColor(safe, warn, p: clamped / 0.5)
-        } else {
-            color = self.mixColor(warn, hot, p: (clamped - 0.5) / 0.5)
-        }
-        if stale {
-            return color.withAlphaComponent(0.72)
-        }
-        return color
-    }
-
-    private static func mixColor(_ a: NSColor, _ b: NSColor, p: CGFloat) -> NSColor {
-        guard let ca = a.usingColorSpace(.deviceRGB),
-              let cb = b.usingColorSpace(.deviceRGB)
-        else {
-            return a
-        }
-        let clamped = max(0, min(p, 1))
-        let red = ca.redComponent + (cb.redComponent - ca.redComponent) * clamped
-        let green = ca.greenComponent + (cb.greenComponent - ca.greenComponent) * clamped
-        let blue = ca.blueComponent + (cb.blueComponent - ca.blueComponent) * clamped
-        let alpha = ca.alphaComponent + (cb.alphaComponent - ca.alphaComponent) * clamped
-        return NSColor(calibratedRed: red, green: green, blue: blue, alpha: alpha)
-    }
-
-    private static func quantizedPercent(_ value: Double?) -> Int {
-        guard let value else { return -1 }
-        return Int((value * 10).rounded())
-    }
-
-    private static func quantizedCredits(_ value: Double?) -> Int {
-        guard let value else { return -1 }
-        let clamped = max(0, min(value, self.creditsCap))
-        return Int((clamped * 10).rounded())
-    }
-
-    private static func styleKey(_ style: IconStyle) -> Int {
-        switch style {
-        case .codex: 0
-        case .claude: 1
-        case .zai: 2
-        case .gemini: 3
-        case .antigravity: 4
-        case .cursor: 5
-        case .factory: 6
-        case .copilot: 7
-        case .minimax: 8
-        case .openrouter: 9
-        case .groq: 10
-        case .deepseek: 11
-        case .fireworks: 12
-        case .mistral: 13
-        case .perplexity: 14
-        case .kimi: 15
-        case .auggie: 16
-        case .together: 17
-        case .cohere: 18
-        case .xai: 19
-        case .cerebras: 20
-        case .sambanova: 21
-        case .azure: 22
-        case .bedrock: 23
-        case .vertexai: 24
-        case .qwen: 25
-        case .combined: 99
-        }
-    }
-
-    private static func indicatorKey(_ indicator: ProviderStatusIndicator) -> Int {
-        switch indicator {
-        case .none: 0
-        case .minor: 1
-        case .major: 2
-        case .critical: 3
-        case .maintenance: 4
-        case .unknown: 5
-        }
-    }
-
-    private static func appearanceKey(_ appearance: IconAppearance) -> Int {
-        switch appearance {
-        case .template: 0
-        case .vibrant: 1
-        }
-    }
-
-    private static func dataModeKey(_ mode: IconDataMode) -> Int {
-        switch mode {
-        case .remaining: 0
-        case .used: 1
-        }
-    }
-
-    private static func morphCacheKey(
-        progress: Double,
-        style: IconStyle,
-        appearance: IconAppearance) -> NSNumber
-    {
-        let bucket = Int((progress * Double(self.morphBucketCount)).rounded())
-        let key = self.styleKey(style) * 10000 + self.appearanceKey(appearance) * 1000 + bucket
-        return NSNumber(value: key)
-    }
-
-    private static func cachedIcon(for key: IconCacheKey) -> NSImage? {
-        self.iconCacheStore.cachedIcon(for: key)
-    }
-
-    private static func storeIcon(_ image: NSImage, for key: IconCacheKey) {
-        self.iconCacheStore.storeIcon(image, for: key, limit: self.iconCacheLimit)
-    }
-
-    private static func drawUnbraidMorph(
-        t: Double,
-        style: IconStyle,
-        color: NSColor,
-        appearance: IconAppearance)
-    {
-        let t = CGFloat(max(0, min(t, 1)))
-        let size = Self.baseSize
-        let center = CGPoint(x: size.width / 2, y: size.height / 2)
-        let baseColor = color
-
-        struct Segment {
-            let startCenter: CGPoint
-            let endCenter: CGPoint
-            let startAngle: CGFloat
-            let endAngle: CGFloat
-            let startLength: CGFloat
-            let endLength: CGFloat
-            let startThickness: CGFloat
-            let endThickness: CGFloat
-            let fadeOut: Bool
-        }
-
-        let segments: [Segment] = [
-            // Upper ribbon -> top bar
-            .init(
-                startCenter: center.offset(dx: 0, dy: 2),
-                endCenter: CGPoint(x: center.x, y: 9.0),
-                startAngle: -30,
-                endAngle: 0,
-                startLength: 16,
-                endLength: 14,
-                startThickness: 3.4,
-                endThickness: 3.0,
-                fadeOut: false),
-            // Lower ribbon -> bottom bar
-            .init(
-                startCenter: center.offset(dx: 0, dy: -2),
-                endCenter: CGPoint(x: center.x, y: 4.0),
-                startAngle: 210,
-                endAngle: 0,
-                startLength: 16,
-                endLength: 12,
-                startThickness: 3.4,
-                endThickness: 2.4,
-                fadeOut: false),
-            // Side ribbon fades away
-            .init(
-                startCenter: center,
-                endCenter: center.offset(dx: 0, dy: 6),
-                startAngle: 90,
-                endAngle: 0,
-                startLength: 16,
-                endLength: 8,
-                startThickness: 3.4,
-                endThickness: 1.8,
-                fadeOut: true),
-        ]
-
-        for seg in segments {
-            let p = seg.fadeOut ? t * 1.1 : t
-            let c = seg.startCenter.lerp(to: seg.endCenter, p: p)
-            let angle = seg.startAngle.lerp(to: seg.endAngle, p: p)
-            let length = seg.startLength.lerp(to: seg.endLength, p: p)
-            let thickness = seg.startThickness.lerp(to: seg.endThickness, p: p)
-            let alpha = seg.fadeOut ? (1 - p) : 1
-
-            self.drawRoundedRibbon(
-                center: c,
-                length: length,
-                thickness: thickness,
-                angle: angle,
-                color: baseColor.withAlphaComponent(alpha))
-        }
-
-        // Cross-fade in bar fill emphasis near the end of the morph.
-        if t > 0.55 {
-            let barT = (t - 0.55) / 0.45
-            let bars = self.makeIcon(
-                primaryRemaining: 100,
-                weeklyRemaining: 100,
-                creditsRemaining: nil,
-                stale: false,
-                style: style,
-                appearance: appearance)
-            bars.draw(in: CGRect(origin: .zero, size: size), from: .zero, operation: .sourceOver, fraction: barT)
-        }
-    }
-
-    private static func drawRoundedRibbon(
-        center: CGPoint,
-        length: CGFloat,
-        thickness: CGFloat,
-        angle: CGFloat,
-        color: NSColor)
-    {
-        var transform = AffineTransform.identity
-        transform.translate(x: center.x, y: center.y)
-        transform.rotate(byDegrees: angle)
-        transform.translate(x: -center.x, y: -center.y)
-
-        let rect = CGRect(
-            x: center.x - length / 2,
-            y: center.y - thickness / 2,
-            width: length,
-            height: thickness)
-
-        let path = NSBezierPath(roundedRect: rect, xRadius: thickness / 2, yRadius: thickness / 2)
-        path.transform(using: transform)
-        color.setFill()
-        path.fill()
-    }
-
-    private static func drawStatusOverlay(indicator: ProviderStatusIndicator, color: NSColor) {
-        guard indicator.hasIssue else { return }
-        switch indicator {
-        case .minor, .maintenance:
-            let size: CGFloat = 4
-            let rect = Self.snapRect(
-                x: Self.baseSize.width - size - 2,
-                y: 2,
-                width: size,
-                height: size)
-            let path = NSBezierPath(ovalIn: rect)
-            color.setFill()
-            path.fill()
-        case .major, .critical, .unknown:
-            let lineRect = Self.snapRect(
-                x: Self.baseSize.width - 6,
-                y: 4,
-                width: 2.0,
-                height: 6)
-            let linePath = NSBezierPath(roundedRect: lineRect, xRadius: 1, yRadius: 1)
-            color.setFill()
-            linePath.fill()
-
-            let dotRect = Self.snapRect(
-                x: Self.baseSize.width - 6,
-                y: 2,
-                width: 2.0,
-                height: 2.0)
-            NSBezierPath(ovalIn: dotRect).fill()
-        case .none:
-            break
-        }
-    }
-
-    private static func withScaledContext(_ draw: () -> Void) {
-        guard let ctx = NSGraphicsContext.current?.cgContext else {
-            draw()
-            return
-        }
-        ctx.saveGState()
-        ctx.setShouldAntialias(true)
-        ctx.interpolationQuality = .none
-        draw()
-        ctx.restoreGState()
-    }
-
-    private static func snap(_ value: CGFloat) -> CGFloat {
-        (value * self.outputScale).rounded() / self.outputScale
-    }
-
-    private static func snapRect(x: CGFloat, y: CGFloat, width: CGFloat, height: CGFloat) -> CGRect {
-        CGRect(x: self.snap(x), y: self.snap(y), width: self.snap(width), height: self.snap(height))
-    }
-
-    private static func renderImage(isTemplate: Bool, _ draw: () -> Void) -> NSImage {
-        let image = NSImage(size: Self.outputSize)
-
-        if let rep = NSBitmapImageRep(
-            bitmapDataPlanes: nil,
-            pixelsWide: Int(Self.outputSize.width * Self.outputScale),
-            pixelsHigh: Int(Self.outputSize.height * Self.outputScale),
-            bitsPerSample: 8,
-            samplesPerPixel: 4,
-            hasAlpha: true,
-            isPlanar: false,
-            colorSpaceName: .deviceRGB,
-            bytesPerRow: 0,
-            bitsPerPixel: 0)
-        {
-            rep.size = Self.outputSize // points
-            image.addRepresentation(rep)
-
-            NSGraphicsContext.saveGraphicsState()
-            if let ctx = NSGraphicsContext(bitmapImageRep: rep) {
-                NSGraphicsContext.current = ctx
-                Self.withScaledContext(draw)
-            }
-            NSGraphicsContext.restoreGraphicsState()
-        } else {
-            // Fallback to legacy focus if the bitmap rep fails for any reason.
-            image.lockFocus()
-            Self.withScaledContext(draw)
-            image.unlockFocus()
-        }
-
-        image.isTemplate = isTemplate
-        return image
-    }
-}
-
-extension CGPoint {
-    fileprivate func lerp(to other: CGPoint, p: CGFloat) -> CGPoint {
-        CGPoint(x: self.x + (other.x - self.x) * p, y: self.y + (other.y - self.y) * p)
-    }
-
-    fileprivate func offset(dx: CGFloat, dy: CGFloat) -> CGPoint {
-        CGPoint(x: self.x + dx, y: self.y + dy)
-    }
-}
-
-extension CGFloat {
-    fileprivate func lerp(to other: CGFloat, p: CGFloat) -> CGFloat {
-        self + (other - self) * p
-    }
-}