perf: pane index, write debounce, one-pass pill

javierpr0 · javierpr0 · commit fbf0e8712125 · 2026-07-16T15:20:53.000-06:00
diff --git a/Notchy/AutocompleteEngine.swift b/Notchy/AutocompleteEngine.swift
@@ -30,6 +30,7 @@ class AutocompleteEngine {
         let lowercasedInput = input.lowercased()
 
         var scored: [AutocompleteSuggestion] = []
+        let now = Date()
 
         for cmd in commands {
             // Skip exact matches
@@ -52,7 +53,7 @@ class AutocompleteEngine {
             score += min(log2(Double(cmd.count) + 1) * 5, 30)
 
             // Recency bonus
-            let daysSinceUse = Date().timeIntervalSince(cmd.lastUsed) / 86400
+            let daysSinceUse = now.timeIntervalSince(cmd.lastUsed) / 86400
             if daysSinceUse < 1 {
                 score += 20
             } else if daysSinceUse < 7 {
diff --git a/Notchy/CommandStore.swift b/Notchy/CommandStore.swift
@@ -74,7 +74,37 @@ class CommandStore {
     /// Drain any in-flight async work so all queued writes finish before we
     /// return. Safe to call from any thread.
     func flushSync() {
-        queue.sync { /* serial fence */ }
+        queue.sync { drainPendingSaves() }
+    }
+
+    // MARK: - Debounced persistence (call only from within queue)
+
+    /// Directories with unsaved changes and the exact snapshot to persist.
+    /// Holding the data (not just the dirty flag) protects against the LRU
+    /// cache evicting a directory before its debounced save lands.
+    private var pendingSaves: [String: [StoredCommand]] = [:]
+    private var saveTimer: DispatchSourceTimer?
+
+    /// Coalesces the full-file JSON rewrite that used to run on every Enter.
+    /// Safe against quits: the willTerminate/willResignActive observers call
+    /// flushSync(), which drains pending saves synchronously.
+    private func scheduleSave(_ commands: [StoredCommand], for directory: String) {
+        pendingSaves[directory] = commands
+        guard saveTimer == nil else { return }
+        let timer = DispatchSource.makeTimerSource(queue: queue)
+        timer.schedule(deadline: .now() + 1.0)
+        timer.setEventHandler { [weak self] in self?.drainPendingSaves() }
+        timer.resume()
+        saveTimer = timer
+    }
+
+    private func drainPendingSaves() {
+        saveTimer?.cancel()
+        saveTimer = nil
+        for (directory, commands) in pendingSaves {
+            saveCommands(commands, for: directory)
+        }
+        pendingSaves.removeAll()
     }
 
     // MARK: - Public API
@@ -103,12 +133,7 @@ class CommandStore {
                 cmds = Array(cmds.prefix(Self.maxCommandsPerDirectory))
             }
             self.updateCache(directory: directory, commands: cmds)
-            // Persist immediately on the serial queue. The previous version
-            // debounced writes by 2s and relied on app-lifecycle notifications
-            // to flush — those notifications never fired because the
-            // selector-based observer required NSObject inheritance, so a
-            // burst of commands followed by a quit lost all of them.
-            self.saveCommands(cmds, for: directory)
+            self.scheduleSave(cmds, for: directory)
         }
     }
 
@@ -118,7 +143,7 @@ class CommandStore {
             var cmds = self._commands(for: directory)
             cmds.removeAll { $0.text == command }
             self.updateCache(directory: directory, commands: cmds)
-            self.saveCommands(cmds, for: directory)
+            self.scheduleSave(cmds, for: directory)
         }
     }
 
@@ -186,6 +211,11 @@ class CommandStore {
             touchCache(directory)
             return cached
         }
+        // A pending debounced save is fresher than the file on disk.
+        if let pending = pendingSaves[directory] {
+            updateCache(directory: directory, commands: pending)
+            return pending
+        }
         let loaded = loadCommands(for: directory)
         updateCache(directory: directory, commands: loaded)
         return loaded
diff --git a/Notchy/NotchWindow.swift b/Notchy/NotchWindow.swift
@@ -353,6 +353,8 @@ class NotchWindow: NSPanel {
             self?.proximityTick()
         }
         if let timer = hoverPollTimer {
+            // Let the system coalesce wakeups — hover latency tolerates 50ms.
+            timer.tolerance = 0.05
             RunLoop.main.add(timer, forMode: .common)
         }
     }
@@ -606,38 +608,43 @@ enum NotchDisplayState: Equatable {
 
     /// Hierarchy: .taskCompleted (always shown) > .waitingForInput > .working > .idle
     @MainActor static var current: NotchDisplayState {
-        let sessions = SessionStore.shared.sessions
-        if sessions.contains(where: { $0.terminalStatus == .taskCompleted }) {
-            return .taskCompleted
-        }
-        if sessions.contains(where: { $0.terminalStatus == .waitingForInput }) {
-            return .waitingForInput
-        }
-        if sessions.contains(where: { $0.terminalStatus == .working }) {
-            return .working
+        snapshot().state
+    }
+
+    /// Aggregate state + attention count in a single pass over the sessions.
+    /// `terminalStatus` recomputes over paneStatuses on each access, so the
+    /// pill computes this once per render instead of once per property access.
+    @MainActor static func snapshot() -> (state: NotchDisplayState, attentionCount: Int) {
+        var state = NotchDisplayState.idle
+        var count = 0
+        for session in SessionStore.shared.sessions {
+            switch session.terminalStatus {
+            case .taskCompleted:
+                state = .taskCompleted
+                count += 1
+            case .waitingForInput:
+                if state != .taskCompleted { state = .waitingForInput }
+                count += 1
+            case .working:
+                if state == .idle { state = .working }
+                count += 1
+            default:
+                break
+            }
         }
-        return .idle
-    }
-
-    /// Number of sessions currently demanding attention (working, waiting for
-    /// input, or just completed). Drives the count badge in the notch pill.
-    @MainActor static var attentionCount: Int {
-        SessionStore.shared.sessions.filter {
-            $0.terminalStatus == .working
-                || $0.terminalStatus == .waitingForInput
-                || $0.terminalStatus == .taskCompleted
-        }.count
+        return (state, count)
     }
 }
 
 // MARK: - Notch pill SwiftUI content
 
 struct NotchPillContent: View {
     var isHovering: Bool = false
-    private var displayState: NotchDisplayState { .current }
-    private var attentionCount: Int { NotchDisplayState.attentionCount }
 
     var body: some View {
+        // Single pass over sessions per render; each property access would
+        // otherwise re-scan the full session list.
+        let (displayState, attentionCount) = NotchDisplayState.snapshot()
         ZStack {
             HStack {
                 if displayState == .idle {
diff --git a/Notchy/SessionHistoryManager.swift b/Notchy/SessionHistoryManager.swift
@@ -62,10 +62,12 @@ class SessionHistoryManager {
     func appendData(_ data: Data, for sessionId: UUID) {
         guard !data.isEmpty else { return }
         queue.async { [self] in
-            if var pending = pendingWrites[sessionId] {
-                pending.data.append(data)
-                pendingWrites[sessionId] = pending
-                if pending.data.count >= Self.flushBytesThreshold {
+            if pendingWrites[sessionId] != nil {
+                // Append in place — pulling the struct out into a local first
+                // makes the Data multiply-referenced and forces a full
+                // copy-on-write of the accumulated buffer on every chunk.
+                pendingWrites[sessionId]!.data.append(data)
+                if pendingWrites[sessionId]!.data.count >= Self.flushBytesThreshold {
                     flushPending(for: sessionId)
                 }
             } else {
diff --git a/Notchy/SessionStore.swift b/Notchy/SessionStore.swift
@@ -215,7 +215,7 @@ class SessionStore {
     }
 
     func updateWorkingDirectory(_ paneId: UUID, directory: String) {
-        guard let index = sessions.firstIndex(where: { $0.splitRoot.containsPane(paneId) }) else { return }
+        guard let index = sessionIndex(forPane: paneId) else { return }
         let oldDir = sessions[index].splitRoot.workingDirectory(for: paneId)
         guard oldDir != directory else { return }
         sessions[index].splitRoot = sessions[index].splitRoot.updatingWorkingDirectory(paneId, to: directory)
@@ -386,19 +386,42 @@ class SessionStore {
         persistSessions()
     }
 
+    /// Cache mapping pane id → owning session id. Self-healing: every hit is
+    /// verified against the current split tree and any miss triggers a full
+    /// rebuild, so split/close/restore mutations never need to invalidate it.
+    /// Avoids a DFS over every session's split tree on each output event.
+    @ObservationIgnored private var paneToSessionCache: [UUID: UUID] = [:]
+
+    private func sessionIndex(forPane paneId: UUID) -> Int? {
+        if let sid = paneToSessionCache[paneId],
+           let index = sessions.firstIndex(where: { $0.id == sid }),
+           sessions[index].splitRoot.containsPane(paneId) {
+            return index
+        }
+        paneToSessionCache.removeAll(keepingCapacity: true)
+        for session in sessions {
+            for pane in session.splitRoot.allPaneIds {
+                paneToSessionCache[pane] = session.id
+            }
+        }
+        guard let sid = paneToSessionCache[paneId],
+              let index = sessions.firstIndex(where: { $0.id == sid }) else { return nil }
+        return index
+    }
+
     /// Flag a session as having unread output when a chunk arrives on a pane
     /// whose tab is not active. Idempotent: only mutates on the first chunk
     /// after the flag was cleared, so a busy background tab won't churn.
     func noteOutput(forPane paneId: UUID) {
-        guard let index = sessions.firstIndex(where: { $0.splitRoot.containsPane(paneId) }) else { return }
+        guard let index = sessionIndex(forPane: paneId) else { return }
         let sessionId = sessions[index].id
         guard sessionId != activeSessionId, !sessions[index].isSleeping else { return }
         guard !unreadSessionIds.contains(sessionId) else { return }
         unreadSessionIds.insert(sessionId)
     }
 
     func updateTerminalStatus(_ paneId: UUID, status: TerminalStatus) {
-        guard let index = sessions.firstIndex(where: { $0.splitRoot.containsPane(paneId) }) else { return }
+        guard let index = sessionIndex(forPane: paneId) else { return }
         // A sleeping session has no live terminals; any in-flight status callback
         // from a torn-down terminal must not resurrect paneStatuses.
         guard !sessions[index].isSleeping else { return }
@@ -740,7 +763,7 @@ class SessionStore {
     }
 
     func focusPane(_ paneId: UUID) {
-        guard let index = sessions.firstIndex(where: { $0.splitRoot.containsPane(paneId) }) else { return }
+        guard let index = sessionIndex(forPane: paneId) else { return }
         sessions[index].focusedPaneId = paneId
         TerminalManager.shared.focusTerminal(for: paneId)
     }
diff --git a/Notchy/TerminalManager.swift b/Notchy/TerminalManager.swift
@@ -360,11 +360,15 @@ class ClickThroughTerminalView: LocalProcessTerminalView {
 
         // Debounce status checks — the buffer can be mid-render when
         // dataReceived fires, causing transient misreads that flicker
-        // between .working and .idle.
-        statusDebounceTimer?.invalidate()
-        statusDebounceTimer = Timer.scheduledTimer(withTimeInterval: 0.15, repeats: false) { [weak self] _ in
-            guard let self else { return }
-            self.evaluateStatus(for: id)
+        // between .working and .idle. Pushing fireDate back reuses the
+        // timer instead of allocating a new one per chunk.
+        if let timer = statusDebounceTimer, timer.isValid {
+            timer.fireDate = Date().addingTimeInterval(0.15)
+        } else {
+            statusDebounceTimer = Timer.scheduledTimer(withTimeInterval: 0.15, repeats: false) { [weak self] _ in
+                guard let self else { return }
+                self.evaluateStatus(for: id)
+            }
         }
 
         // Trigger autocomplete evaluation
@@ -418,17 +422,21 @@ class ClickThroughTerminalView: LocalProcessTerminalView {
         return Self.sanitizeForDisplay(String(last.prefix(100)))
     }
 
+    // Compiled once — sanitizeForDisplay runs on every status evaluation.
+    private static let csiRegex = try? NSRegularExpression(pattern: "\u{001B}\\[[0-?]*[ -/]*[@-~]")
+    private static let oscRegex = try? NSRegularExpression(pattern: "\u{001B}\\][^\u{0007}\u{001B}]*[\u{0007}\u{001B}]")
+
     /// Removes ANSI escape sequences, control characters, and bidi-override
     /// codepoints so terminal output cannot spoof or break notification text.
     static func sanitizeForDisplay(_ input: String) -> String {
         var stripped = input
         // Strip CSI escape sequences (ESC [ ... letter)
-        if let regex = try? NSRegularExpression(pattern: "\u{001B}\\[[0-?]*[ -/]*[@-~]") {
+        if let regex = csiRegex {
             let range = NSRange(stripped.startIndex..., in: stripped)
             stripped = regex.stringByReplacingMatches(in: stripped, range: range, withTemplate: "")
         }
         // Strip OSC sequences (ESC ] ... BEL/ST)
-        if let regex = try? NSRegularExpression(pattern: "\u{001B}\\][^\u{0007}\u{001B}]*[\u{0007}\u{001B}]") {
+        if let regex = oscRegex {
             let range = NSRange(stripped.startIndex..., in: stripped)
             stripped = regex.stringByReplacingMatches(in: stripped, range: range, withTemplate: "")
         }
