Flickering between workspaces on window close

[m12y]

When closing a window, if there is another window of that same application in another workspace, it will jump to that before jumping back quickly to where it should be (the workspace where the window was closed). It is a quick flicker, but still noticeable and jarring. This seems to happen for any application: Kitty, Chrome, Finder. I haven't found any other bug report or post describing this exact problem.

I am on the latest version of aerospace and macOS. This happens with the example config too.

[rickyz]

This has been a slight annoyance for me as well - repro steps (as mentioned above, Chrome can be just about any app here):

1. Open a Chrome window in workspace 1
2. Open exactly one Chrome window in workspace 2
3. Close the Chrome window on workspace 2

Step (3) unexpectedly switches to workspace 1. If workspace 2 has windows apart from Chrome, then step (3) causes a flicker where we rapidly switch to 1 then back to 2. This is jarring and also pollutes back-and-forth focus history.

I suspect this is due to this unfortunate built-in macOS behavior: https://discussions.apple.com/thread/253850777. I don't see a clean way to turn off that behavior, but I had some luck working around it with a change like this:

diff --git a/Sources/AppBundle/focusCache.swift b/Sources/AppBundle/focusCache.swift
index 2511606..620a5fd 100644
--- a/Sources/AppBundle/focusCache.swift
+++ b/Sources/AppBundle/focusCache.swift
@@ -5,7 +5,9 @@
 /// Alternative names: takeFocusFromMacOs, syncFocusFromMacOs
 @MainActor func updateFocusCache(_ nativeFocused: Window?) {
     if nativeFocused?.windowId != lastKnownNativeFocusedWindowId {
-        _ = nativeFocused?.focusWindow()
+        if nativeFocused?.visualWorkspace == focus.workspace {
+            _ = nativeFocused?.focusWindow()
+        }
         lastKnownNativeFocusedWindowId = nativeFocused?.windowId
     }
 }

The change disables syncing native focus to windows that are not on the currently focused space. This has the downside of breaking non-AeroSpace-aware application switching. For example, with this change, command-tab and command-backtick no longer trigger workspace switching. In addition, command-tab/command-backtick can transfer focus to a window that is hidden by AeroSpace, potentially allowing keyboard inputs to invisibly go to unexpected windows. Note that this is already possible today - if you switch from a non-empty workspace to an empty workspace, the previously focused window retains focus and receives keyboard input even though it has been hidden.

Personally, these tradeoffs are worth the benefit for me since I would like to do all of my application switching via AeroSpace. I actually prefer that command-tab switches apps without switching spaces, but I have to admit that the command-backtick behavior is not ideal.

fwiw, I also tried out a different option where we stop syncing cross-workspace native focus changes for a brief period after an app window is closed:

diff --git a/Sources/AppBundle/focusCache.swift b/Sources/AppBundle/focusCache.swift
index 2511606..1b8eb09 100644
--- a/Sources/AppBundle/focusCache.swift
+++ b/Sources/AppBundle/focusCache.swift
@@ -4,8 +4,16 @@
 ///                      (from nativeFocused to lastKnownNativeFocusedWindowId)
 /// Alternative names: takeFocusFromMacOs, syncFocusFromMacOs
 @MainActor func updateFocusCache(_ nativeFocused: Window?) {
-    if nativeFocused?.windowId != lastKnownNativeFocusedWindowId {
-        _ = nativeFocused?.focusWindow()
-        lastKnownNativeFocusedWindowId = nativeFocused?.windowId
+    if nativeFocused?.windowId == lastKnownNativeFocusedWindowId {
+        return
+    }
+    lastKnownNativeFocusedWindowId = nativeFocused?.windowId
+
+    guard let nativeFocused else {
+        return
+    }
+    if nativeFocused.visualWorkspace == focus.workspace  ||
+       .now >= nativeFocused.macAppUnsafe.disableCrossWorkspaceFocusUntil {
+        _ = nativeFocused.focusWindow()
     }
 }
diff --git a/Sources/AppBundle/tree/MacApp.swift b/Sources/AppBundle/tree/MacApp.swift
index 5e8ae65..180d83e 100644
--- a/Sources/AppBundle/tree/MacApp.swift
+++ b/Sources/AppBundle/tree/MacApp.swift
@@ -7,6 +7,8 @@ final class MacApp: AbstractApp {
     let axApp: AXUIElement
     let isZoom: Bool

+    var disableCrossWorkspaceFocusUntil: Date = .distantPast
+
     private var axObservers: [AxObserverWrapper] = [] // keep observers in memory

     private init(_ nsApp: NSRunningApplication, _ axApp: AXUIElement) {
diff --git a/Sources/AppBundle/tree/MacWindow.swift b/Sources/AppBundle/tree/MacWindow.swift
index afd561a..f070537 100644
--- a/Sources/AppBundle/tree/MacWindow.swift
+++ b/Sources/AppBundle/tree/MacWindow.swift
@@ -96,6 +96,10 @@ final class MacWindow: Window {
                     break // Don't switch back on popup destruction
             }
         }
+        // After closing a window, if there are other windows for the app, macOS will automatically focus one of them.
+        // If that window is on a different space, then this causes an unexpected space transition for the user. Avoid
+        // this by disabling syncing of cross-workspace native focus changes for the app for a brief period.
+        macApp.disableCrossWorkspaceFocusUntil = Date(timeIntervalSinceNow: 0.1)
     }

     private func observe(_ handler: AXObserverCallback, _ notifKey: String) -> Bool {

This works for me and preserves the existing command-tab/command-backtick behavior, but I do worry that these time-based mechanisms can behave jankily when things are slow.

Curious if folks have more thoughts on a good path for fixing this!