⚡ perf: cut the work each redraw repeats

The status bar parsed its template character by character once per cell
and once more to decide whether a countdown was needed, for each of the
five tiers the adaptive ladder tries. That is two dozen passes over the
same string per rebuild, and a rebuild happens every second while a
template references {reset}. Parsing now happens once per build.

The log buffer re-encoded its whole 500-entry array and wrote it
atomically for every line, which with detailed logging is several per HTTP
request. Writes are coalesced to one every five seconds, with a flush on
shutdown and on clear; every line still reaches os_log as it happens, so
that is all a crash could lose.

LinkifiedText compiled a Regex per banner per body evaluation, the window
selection list recomputed the default selection twice per row, and the
hover cards cancelled and allocated a Task for every mouse-move point over
a card that was already showing.

Claude-Session: https://claude.ai/code/session_01CGckDFXvufWVmRH4uyE4z8

Author: gaborbernat

Sources/TokenMenuBarCore/Logging/LogBuffer.swift

@@ -52,8 +52,13 @@ public final class LogBuffer: @unchecked Sendable {
   public static let retention: TimeInterval = 7 * 86400
 
   private let lock = NSLock()
+  /// How long a line may sit in memory before it reaches disk. Every line goes to `os_log` as it happens, so this
+  /// only sets how much of the in-app log a crash could lose.
+  public static let flushInterval: TimeInterval = 5
   private var entries: [LogEntry] = []
   private var lastPrune: Date?
+  private var lastPersist: Date?
+  private var dirty = false
   private let fileURL: URL?
   private let clock: Clock
   private let osLog = Logger(subsystem: "dev.tox.token-menu-bar", category: "app")
@@ -102,11 +107,21 @@ public final class LogBuffer: @unchecked Sendable {
         entries.removeAll { $0.timestamp < cutoff }
         lastPrune = now
       }
-      persist()
+      dirty = true
+      // Persisting re-encodes the whole buffer and writes it atomically. With detailed logging on that is several
+      // hundred entries per HTTP request, so the writes are coalesced instead.
+      if lastPersist.map({ now.timeIntervalSince($0) >= Self.flushInterval }) ?? true { persist(now: now) }
     }
   }
 
-  private func persist() {
+  /// Writes anything still held in memory. Call before the app goes away or before reading the file back.
+  public func flush() {
+    lock.withLock { persist(now: clock.now()) }
+  }
+
+  private func persist(now: Date) {
+    lastPersist = now
+    dirty = false
     guard let fileURL, let data = try? JSONEncoder().encode(entries) else { return }
     try? FileManager.default.createDirectory(at: fileURL.deletingLastPathComponent(), withIntermediateDirectories: true)
     try? data.write(to: fileURL, options: .atomic)
@@ -123,7 +138,7 @@ public final class LogBuffer: @unchecked Sendable {
   public func clear() {
     lock.withLock {
       entries.removeAll()
-      persist()
+      persist(now: clock.now())
     }
   }
 

Sources/TokenMenuBarCore/StatusBar/StatusItemModel.swift

@@ -142,8 +142,8 @@ public enum StatusItemBuilder {
       return StatusItemModel(cells: [], iconTone: tone, showsIcon: true, countdownActive: false)
     }
     let format = input.effectiveFormat
-    let template = format.template ?? input.customTemplate
-    let countdown = format != .miniBars && StatusTemplate.referencesCountdown(template)
+    let template = StatusTemplate.compile(format.template ?? input.customTemplate)
+    let countdown = format != .miniBars && template.referencesCountdown
     var entries = input.selectedKeys.compactMap { key -> (WindowKey, ProviderSnapshot, QuotaWindow)? in
       guard let snapshot = input.snapshots[key.provider], let window = snapshot.window(key.windowID) else { return nil }
       return (key, snapshot, window)

Sources/TokenMenuBarCore/StatusBar/StatusTemplate.swift

@@ -79,13 +79,33 @@ public enum StatusTemplate {
     case newline
   }
 
+  /// A template parsed once. The status bar renders the same template for every cell, and again for every tier the
+  /// adaptive ladder tries, so parsing per render walked the string two dozen times per rebuild.
+  public struct Compiled: Sendable {
+    let tokens: [Token]
+    public let referencesCountdown: Bool
+
+    init(_ template: String) {
+      tokens = StatusTemplate.parse(template)
+      referencesCountdown = tokens.contains { $0 == .placeholder("reset") }
+    }
+  }
+
+  public static func compile(_ template: String) -> Compiled {
+    Compiled(template)
+  }
+
   public static func referencesCountdown(_ template: String) -> Bool {
-    parse(template).contains { $0 == .placeholder("reset") }
+    Compiled(template).referencesCountdown
   }
 
   public static func render(_ template: String, context: StatusCellContext) -> [[StatusRun]] {
+    render(Compiled(template), context: context)
+  }
+
+  public static func render(_ compiled: Compiled, context: StatusCellContext) -> [[StatusRun]] {
     var lines: [[StatusRun]] = [[]]
-    for token in parse(template) {
+    for token in compiled.tokens {
       switch token {
       case .newline: lines.append([])
       case .text(let text): lines[lines.count - 1].append(StatusRun(text: text, kind: .label))

Sources/TokenMenuBarUI/AppController.swift

@@ -228,6 +228,7 @@ public final class AppController {
     for observer in workspaceObservers { NSWorkspace.shared.notificationCenter.removeObserver(observer) }
     workspaceObservers.removeAll()
     dependencies.log.log("stopped")
+    dependencies.log.flush()
   }
 
   func installObservers() {

Sources/TokenMenuBarUI/Views/Components.swift

@@ -74,15 +74,30 @@ public struct LinkifiedText: View {
 
   public static func attributed(_ text: String) -> AttributedString {
     var result = AttributedString(text)
-    let pattern = try! Regex("https?://[^\\s)]+")
-    for match in text.matches(of: pattern) {
-      if let range = Range(match.range, in: result), let url = URL(string: String(text[match.range])) {
+    // Compiling a Regex costs more than scanning the string, and every banner does this on every body evaluation.
+    for span in links(in: text) {
+      if let range = Range(span, in: result), let url = URL(string: String(text[span])) {
         result[range].link = url
         result[range].underlineStyle = .single
       }
     }
     return result
   }
+
+  /// The `http://` and `https://` runs in `text`, each ending at the first space or closing bracket.
+  static func links(in text: String) -> [Range<String.Index>] {
+    var spans: [Range<String.Index>] = []
+    var cursor = text.startIndex
+    while let scheme = text.range(of: "http", range: cursor..<text.endIndex) {
+      cursor = scheme.upperBound
+      let rest = text[scheme.upperBound...]
+      guard rest.hasPrefix("://") || rest.hasPrefix("s://") else { continue }
+      let end = text[scheme.lowerBound...].firstIndex { $0.isWhitespace || $0 == ")" } ?? text.endIndex
+      spans.append(scheme.lowerBound..<end)
+      cursor = end
+    }
+    return spans
+  }
 }
 
 public struct ChipView: View {

Sources/TokenMenuBarUI/Views/HoverHelp.swift

@@ -11,8 +11,13 @@ public final class HoverState {
   public init() {}
 
   public func hover(_ active: Bool) {
+    // `onContinuousHover` reports every mouse-move point, so without these each one cancelled and allocated a task
+    // for a card that is already showing, or already on its way.
+    if active, presented || task != nil { return }
+    if !active, !presented, task == nil { return }
     task?.cancel()
     guard active else {
+      task = nil
       presented = false
       return
     }

Sources/TokenMenuBarUI/Views/SettingsTab.swift

@@ -266,6 +266,10 @@ public struct WindowSelectionList: View {
   }
 
   public var body: some View {
+    // Without the binding, every row recomputed the default selection twice: once for the toggle and once to decide
+    // whether it is the last one standing.
+    let selection = selection
+    let showsLabelField = settings.activeTemplate.contains("{label}")
     VStack(alignment: .leading, spacing: 4) {
       if rows.isEmpty {
         Text("Windows appear after the first successful refresh.").foregroundStyle(.secondary)
@@ -282,7 +286,7 @@ public struct WindowSelectionList: View {
             }
             .disabled(selection == [row.key])
             Text(Format.percent(row.window.usedPercent)).monospacedDigit().foregroundStyle(.secondary)
-            if settings.activeTemplate.contains("{label}") {
+            if showsLabelField {
               TextField(
                 "Label", text: Binding(get: { settings.shortLabels[row.key] ?? "" }, set: { setLabel(row.key, $0) })
               ).frame(width: 56)

Tests/TokenMenuBarUITests/ViewTests.swift

@@ -258,6 +258,10 @@ func findScrollView(_ view: NSView) -> NSScrollView? {
   #expect(inkFraction(Banner("plain"), width: 300, height: 60) > 0)
   let attributed = LinkifiedText.attributed("a https://x.y/z) b")
   #expect(attributed.runs.contains { $0.link != nil })
+  #expect(attributed.runs.compactMap(\.link?.absoluteString) == ["https://x.y/z"])
+  #expect(LinkifiedText.attributed("no link, http not a scheme").runs.allSatisfy { $0.link == nil })
+  let both = LinkifiedText.attributed("http://a.b and https://c.d/e")
+  #expect(both.runs.compactMap(\.link?.absoluteString) == ["http://a.b", "https://c.d/e"])
   var copied: [String] = []
   var opened: [URL] = []
   let chip = ChipView(