fix(display): skip relaunch wave on resolution-only screen-parameters changes (#569)

PR #529 (commit `1ed2ce67`, "feat: per-display menu bar spacing with dynamic apply") wired `DisplaySettingsManager.applyActiveDisplaySpacing` to `NSApplication.didChangeScreenParametersNotification` so each display's saved spacing follows the active menu bar around. That notification fires for every screen-parameter event though, including resolution changes, lid open/close, and GPU/sleep transitions on a display that is already connected. Each fire armed a preflight settling window and ran `applyOffset`, and any time the on-disk byHost values disagreed with the target (Control Center restart, sleep/wake clobber, mid-flight oscillation across profiles) the call escalated to a full relaunch wave even though the user had only changed a setting of the display, not changed to a different display.

`DisplaySettingsManager` now records the active menu bar display UUID inside `applyActiveDisplaySpacing` and the `didChangeScreenParametersNotification` sink compares the current UUID against that cache via a new `shouldSkipSpacingApply(currentActiveDisplayUUID:lastAppliedActiveDisplayUUID:)` static predicate. When the UUIDs match (the resolution/lid/GPU case) the sink logs "Active menu bar display unchanged" and returns; when they differ (laptop docked, active menu bar moved to another monitor, first event after launch) the existing apply path runs as before. The `$configurations` and external Settings-URI paths are untouched: those reflect deliberate user intent and continue to rely on the no-op guard in `MenuBarItemSpacingManager.applyOffset` to short-circuit when target equals on-disk.

Adds `ThawTests/DisplaySettingsManagerSpacingGateTests` with eight cases pinning the predicate (matching, differing, either-nil, both-nil, repeated-stable) and the field semantics on a fresh `DisplaySettingsManager` instance. The new file is picked up automatically by the `ThawTests` synchronized-folder reference so no project edits are required.

Fixes #551

Signed-off-by: Amir Zarrinkafsh <3339418+nightah@users.noreply.github.com>

Author: nightah

Thaw/Settings/Models/DisplaySettingsManager.swift

@@ -40,6 +40,12 @@ final class DisplaySettingsManager: ObservableObject {
     /// active-display configuration changes. Held weakly to avoid retain cycles.
     private weak var appState: AppState?
 
+    /// UUID of the active menu bar display the last time spacing was applied.
+    /// Used to skip didChangeScreenParametersNotification fires that only
+    /// reflect a resolution or other-parameter change on the same display.
+    /// Internal access so unit tests in ThawTests can seed and assert it.
+    var lastAppliedActiveDisplayUUID: String?
+
     /// Performs the initial setup of the manager.
     func performSetup(with appState: AppState) {
         self.appState = appState
@@ -162,6 +168,14 @@ final class DisplaySettingsManager: ObservableObject {
                 guard let self else { return }
                 diagLog.info("Screen parameters changed — \(NSScreen.screens.count) screen(s) connected")
                 captureCurrentlyConnectedDisplays()
+                let currentUUID = Bridging.getActiveMenuBarDisplayUUID()
+                if Self.shouldSkipSpacingApply(
+                    currentActiveDisplayUUID: currentUUID,
+                    lastAppliedActiveDisplayUUID: lastAppliedActiveDisplayUUID
+                ) {
+                    diagLog.info("Active menu bar display unchanged (\(currentUUID ?? "nil")); skipping spacing apply")
+                    return
+                }
                 applyActiveDisplaySpacing(reason: "screenParametersChanged")
             }
             .store(in: &c)
@@ -191,6 +205,22 @@ final class DisplaySettingsManager: ObservableObject {
         cancellables = c
     }
 
+    /// Returns true when a didChangeScreenParametersNotification fire should
+    /// be ignored because the active menu bar display has not changed
+    /// identity since the last spacing apply. A resolution change, lid
+    /// open/close, GPU/sleep transition, or other display-parameter event
+    /// that leaves the active display UUID the same is not a reason to
+    /// re-apply spacing (and risk a relaunch wave when on-disk values drift).
+    ///
+    /// Pure on its inputs, separated from the sink so it can be unit tested
+    /// without spinning up AppState or driving real screen events.
+    static func shouldSkipSpacingApply(
+        currentActiveDisplayUUID currentUUID: String?,
+        lastAppliedActiveDisplayUUID lastUUID: String?
+    ) -> Bool {
+        currentUUID == lastUUID
+    }
+
     /// Reads the active display's spacing offset, syncs it into
     /// spacingManager.offset, and triggers applyOffset. The no-op guard
     /// inside applyOffset skips when on-disk values already match, so this
@@ -200,6 +230,7 @@ final class DisplaySettingsManager: ObservableObject {
     /// moving them.
     private func applyActiveDisplaySpacing(reason: String) {
         guard let appState else { return }
+        lastAppliedActiveDisplayUUID = Bridging.getActiveMenuBarDisplayUUID()
         let desired = Int(configurationForActiveDisplay().itemSpacingOffset.rounded())
         appState.spacingManager.offset = desired
         Task { [weak self] in

ThawTests/DisplaySettingsManagerSpacingGateTests.swift

@@ -0,0 +1,81 @@
+//
+//  DisplaySettingsManagerSpacingGateTests.swift
+//  Project: Thaw
+//
+//  Copyright (Thaw) © 2026 Toni Förster
+//  Licensed under the GNU GPLv3
+//
+
+@testable import Thaw
+import XCTest
+
+@MainActor
+final class DisplaySettingsManagerSpacingGateTests: XCTestCase {
+
+    // MARK: - Predicate
+
+    func testPredicateSkipsWhenUUIDsMatch() {
+        XCTAssertTrue(DisplaySettingsManager.shouldSkipSpacingApply(
+            currentActiveDisplayUUID: "UUID-A",
+            lastAppliedActiveDisplayUUID: "UUID-A"
+        ))
+    }
+
+    func testPredicateDoesNotSkipWhenUUIDsDiffer() {
+        XCTAssertFalse(DisplaySettingsManager.shouldSkipSpacingApply(
+            currentActiveDisplayUUID: "UUID-B",
+            lastAppliedActiveDisplayUUID: "UUID-A"
+        ))
+    }
+
+    func testPredicateDoesNotSkipOnFirstApply() {
+        XCTAssertFalse(DisplaySettingsManager.shouldSkipSpacingApply(
+            currentActiveDisplayUUID: "UUID-A",
+            lastAppliedActiveDisplayUUID: nil
+        ))
+    }
+
+    func testPredicateDoesNotSkipWhenCurrentBecomesNil() {
+        XCTAssertFalse(DisplaySettingsManager.shouldSkipSpacingApply(
+            currentActiveDisplayUUID: nil,
+            lastAppliedActiveDisplayUUID: "UUID-A"
+        ))
+    }
+
+    func testPredicateSkipsWhenBothNil() {
+        XCTAssertTrue(DisplaySettingsManager.shouldSkipSpacingApply(
+            currentActiveDisplayUUID: nil,
+            lastAppliedActiveDisplayUUID: nil
+        ))
+    }
+
+    func testPredicateIsStableAcrossRepeatedCalls() {
+        for _ in 0..<10 {
+            XCTAssertTrue(DisplaySettingsManager.shouldSkipSpacingApply(
+                currentActiveDisplayUUID: "UUID-A",
+                lastAppliedActiveDisplayUUID: "UUID-A"
+            ))
+        }
+    }
+
+    // MARK: - Field semantics
+
+    func testFreshManagerHasNilLastAppliedUUID() {
+        let manager = DisplaySettingsManager()
+        XCTAssertNil(manager.lastAppliedActiveDisplayUUID)
+    }
+
+    func testSeededFieldDrivesPredicate() {
+        let manager = DisplaySettingsManager()
+        manager.lastAppliedActiveDisplayUUID = "UUID-A"
+
+        XCTAssertTrue(DisplaySettingsManager.shouldSkipSpacingApply(
+            currentActiveDisplayUUID: "UUID-A",
+            lastAppliedActiveDisplayUUID: manager.lastAppliedActiveDisplayUUID
+        ))
+        XCTAssertFalse(DisplaySettingsManager.shouldSkipSpacingApply(
+            currentActiveDisplayUUID: "UUID-B",
+            lastAppliedActiveDisplayUUID: manager.lastAppliedActiveDisplayUUID
+        ))
+    }
+}