@lattices/cli 0.4.1 → 0.4.5

package/app/Sources/WindowTiler.swift

@@ -51,10 +51,10 @@ final class WindowHighlight {
     private var fadeTimer: Timer?
 
     /// Flash a green border overlay at the given screen frame
-    func flash(frame: NSRect, duration: TimeInterval = 1.2) {
+    func flash(frame: NSRect, duration: TimeInterval = 0.9) {
         dismiss()
 
-        let inset: CGFloat = -8  // slightly larger than the window
+        let inset: CGFloat = -6  // slightly larger than the window
         let expandedFrame = frame.insetBy(dx: inset, dy: inset)
 
         let window = NSWindow(
@@ -110,22 +110,28 @@ final class WindowHighlight {
 
 private class HighlightBorderView: NSView {
     override func draw(_ dirtyRect: NSRect) {
-        let borderWidth: CGFloat = 4
+        let borderWidth: CGFloat = 3
         let cornerRadius: CGFloat = 12
 
         // Outer glow
         let glowRect = bounds.insetBy(dx: 1, dy: 1)
         let glowPath = NSBezierPath(roundedRect: glowRect, xRadius: cornerRadius + 2, yRadius: cornerRadius + 2)
-        glowPath.lineWidth = borderWidth + 4
-        NSColor(calibratedRed: 0.2, green: 0.9, blue: 0.4, alpha: 0.15).setStroke()
+        glowPath.lineWidth = borderWidth + 2
+        NSColor(calibratedRed: 0.2, green: 0.9, blue: 0.4, alpha: 0.07).setStroke()
         glowPath.stroke()
 
         // Main border
         let rect = bounds.insetBy(dx: borderWidth / 2 + 2, dy: borderWidth / 2 + 2)
         let path = NSBezierPath(roundedRect: rect, xRadius: cornerRadius, yRadius: cornerRadius)
         path.lineWidth = borderWidth
-        NSColor(calibratedRed: 0.2, green: 0.9, blue: 0.4, alpha: 0.9).setStroke()
+        NSColor(calibratedRed: 0.2, green: 0.9, blue: 0.4, alpha: 0.58).setStroke()
         path.stroke()
+
+        let innerRect = rect.insetBy(dx: 3, dy: 3)
+        let innerPath = NSBezierPath(roundedRect: innerRect, xRadius: max(cornerRadius - 3, 6), yRadius: max(cornerRadius - 3, 6))
+        innerPath.lineWidth = 1
+        NSColor.white.withAlphaComponent(0.10).setStroke()
+        innerPath.stroke()
     }
 }
 
@@ -588,6 +594,81 @@ enum WindowTiler {
         return Int(getActive(mainConn()))
     }
 
+    static func adjacentSpace(in spaces: [SpaceInfo], currentSpaceId: Int, offset: Int) -> SpaceInfo? {
+        guard let currentIndex = spaces.firstIndex(where: { $0.id == currentSpaceId }) else { return nil }
+        let targetIndex = currentIndex + offset
+        guard spaces.indices.contains(targetIndex) else { return nil }
+        return spaces[targetIndex]
+    }
+
+    private struct AdjacentSpaceContext {
+        let point: CGPoint
+        let display: DisplaySpaces
+        let activeSpaceId: Int
+        let currentSpaceId: Int
+        let target: SpaceInfo?
+    }
+
+    private static func adjacentSpaceContext(offset: Int, from cgPoint: CGPoint? = nil) -> AdjacentSpaceContext? {
+        let point = cgPoint ?? currentMouseCGPoint()
+        guard let display = displaySpaces(containing: point) else { return nil }
+        let activeSpaceId = getCurrentSpace()
+        let currentSpaceId = resolvedCurrentSpaceId(for: display, activeSpaceId: activeSpaceId)
+        let target = adjacentSpace(in: display.spaces, currentSpaceId: currentSpaceId, offset: offset)
+        return AdjacentSpaceContext(
+            point: point,
+            display: display,
+            activeSpaceId: activeSpaceId,
+            currentSpaceId: currentSpaceId,
+            target: target
+        )
+    }
+
+    static func adjacentSpaceTarget(offset: Int, from cgPoint: CGPoint? = nil) -> SpaceInfo? {
+        adjacentSpaceContext(offset: offset, from: cgPoint)?.target
+    }
+
+    @discardableResult
+    static func switchToAdjacentSpace(offset: Int, from cgPoint: CGPoint? = nil) -> Bool {
+        guard let context = adjacentSpaceContext(offset: offset, from: cgPoint) else {
+            DiagnosticLog.shared.warn("switchToAdjacentSpace: no adjacent space for offset \(offset) from \(formatCGPoint(cgPoint ?? currentMouseCGPoint()))")
+            return false
+        }
+
+        let spaces = context.display.spaces.map(\.id)
+        let targetText = context.target.map { String($0.id) } ?? "none"
+        DiagnosticLog.shared.info(
+            "switchToAdjacentSpace: offset=\(offset) point=\(formatCGPoint(context.point)) displayId=\(context.display.displayId) active=\(context.activeSpaceId) displayCurrent=\(context.display.currentSpaceId) resolved=\(context.currentSpaceId) target=\(targetText) spaces=\(spaces)"
+        )
+
+        if getDisplaySpaces().count == 1 {
+            if let finalSpaceId = switchToAdjacentSpaceViaSystemShortcut(
+                offset: offset,
+                displayId: context.display.displayId,
+                initialSpaceId: context.currentSpaceId
+            ) {
+                if let target = context.target, finalSpaceId != target.id {
+                    DiagnosticLog.shared.info("switchToAdjacentSpace: system shortcut changed \(context.currentSpaceId) → \(finalSpaceId) (expected \(target.id))")
+                } else {
+                    DiagnosticLog.shared.info("switchToAdjacentSpace: system shortcut changed \(context.currentSpaceId) → \(finalSpaceId)")
+                }
+                return true
+            }
+
+            guard let target = context.target else {
+                DiagnosticLog.shared.info("switchToAdjacentSpace: system shortcut stayed on \(context.currentSpaceId) and there is no adjacent space")
+                return false
+            }
+
+            DiagnosticLog.shared.warn("switchToAdjacentSpace: system shortcut stayed on \(context.currentSpaceId), falling back to SkyLight target \(target.id)")
+        }
+
+        guard let target = context.target else { return false }
+        let switched = switchToSpace(spaceId: target.id)
+        DiagnosticLog.shared.info("switchToAdjacentSpace: SkyLight \(switched ? "reached" : "missed") target \(target.id)")
+        return switched
+    }
+
     /// Find a window by its title tag and return its CGWindowID and owner PID
     static func findWindow(tag: String) -> (wid: UInt32, pid: pid_t)? {
         guard let windowList = CGWindowListCopyWindowInfo([.optionAll, .excludeDesktopElements], kCGNullWindowID) as? [[String: Any]] else {
@@ -614,10 +695,12 @@ enum WindowTiler {
         return result.map { $0.intValue }
     }
 
-    /// Switch a display to a specific Space
-    static func switchToSpace(spaceId: Int) {
+    /// Switch a display to a specific Space.
+    /// Returns true once the requested Space becomes current.
+    @discardableResult
+    static func switchToSpace(spaceId: Int, verify: Bool = true) -> Bool {
         guard let mainConn = CGS.mainConnectionID,
-              let setSpace = CGS.setCurrentSpace else { return }
+              let setSpace = CGS.setCurrentSpace else { return false }
 
         let cid = mainConn()
 
@@ -625,10 +708,37 @@ enum WindowTiler {
         let allDisplays = getDisplaySpaces()
         for display in allDisplays {
             if display.spaces.contains(where: { $0.id == spaceId }) {
+                let initialSpace = display.currentSpaceId
+                if initialSpace == spaceId {
+                    DiagnosticLog.shared.info("switchToSpace: display \(display.displayIndex) already on target \(spaceId)")
+                    return true
+                }
+
+                DiagnosticLog.shared.info(
+                    "switchToSpace: requesting \(spaceId) on display \(display.displayIndex) id=\(display.displayId) from \(initialSpace)"
+                )
                 setSpace(cid, display.displayId as CFString, UInt64(spaceId))
-                return
+                guard verify else { return true }
+
+                let deadline = Date().addingTimeInterval(0.45)
+                while Date() < deadline {
+                    usleep(30_000)
+                    let current = getDisplaySpaces().first(where: { $0.displayId == display.displayId })?.currentSpaceId ?? 0
+                    if current == spaceId {
+                        DiagnosticLog.shared.info("switchToSpace: display \(display.displayIndex) confirmed target \(spaceId)")
+                        return true
+                    }
+                }
+
+                DiagnosticLog.shared.warn(
+                    "switchToSpace: requested \(spaceId) on display \(display.displayIndex) from \(initialSpace), but current Space did not change"
+                )
+                return false
             }
         }
+
+        DiagnosticLog.shared.warn("switchToSpace: couldn't resolve display for space \(spaceId)")
+        return false
     }
 
     // MARK: - Move Window Between Spaces
@@ -1206,14 +1316,11 @@ enum WindowTiler {
     }
 
     /// Distribute ALL visible non-Lattices windows into a smart grid on the screen with the most windows.
-    static func distributeVisible() {
+    static func distributeVisible(reactivateLattices: Bool = true) {
         let diag = DiagnosticLog.shared
         let t = diag.startTimed("distributeVisible")
 
-        let allEntries = DesktopModel.shared.allWindows()
-        let visible = allEntries.filter { entry in
-            entry.isOnScreen && entry.app != "Lattices" && entry.frame.w > 50 && entry.frame.h > 50
-        }
+        let visible = visibleDistributableWindows()
 
         guard !visible.isEmpty else {
             diag.info("distributeVisible: no visible windows to distribute")
@@ -1223,7 +1330,59 @@ enum WindowTiler {
 
         let windows = visible.map { (wid: $0.wid, pid: $0.pid) }
         diag.info("distributeVisible: \(windows.count) windows")
-        batchRaiseAndDistribute(windows: windows)
+        batchRaiseAndDistribute(windows: windows, reactivateLattices: reactivateLattices)
+        diag.finish(t)
+    }
+
+    /// Distribute visible windows matching the frontmost app's broader type.
+    /// Example: when the active app is a terminal, grid all visible terminal windows on that display.
+    static func distributeVisibleByFrontmostType(reactivateLattices: Bool = true) {
+        let diag = DiagnosticLog.shared
+        let t = diag.startTimed("distributeVisibleByFrontmostType")
+
+        let visible = visibleDistributableWindows()
+        guard !visible.isEmpty else {
+            diag.info("distributeVisibleByFrontmostType: no visible windows to distribute")
+            diag.finish(t)
+            return
+        }
+
+        let frontmostAppName = NSWorkspace.shared.frontmostApplication?.localizedName
+        let anchor = frontmostAppName.flatMap { name in
+            visible.first { $0.app.localizedCaseInsensitiveCompare(name) == .orderedSame }
+        } ?? visible.first
+
+        guard let anchor else {
+            diag.info("distributeVisibleByFrontmostType: no anchor window resolved")
+            diag.finish(t)
+            return
+        }
+
+        let grouping = AppTypeClassifier.grouping(for: anchor.app)
+        let anchorScreen = screenForWindowFrame(anchor.frame)
+        let anchorScreenId = screenID(for: anchorScreen)
+
+        let sameScreenMatches = visible.filter { entry in
+            AppTypeClassifier.matches(entry.app, grouping: grouping) &&
+            screenID(for: screenForWindowFrame(entry.frame)) == anchorScreenId
+        }
+
+        let matches = sameScreenMatches.isEmpty
+            ? visible.filter { AppTypeClassifier.matches($0.app, grouping: grouping) }
+            : sameScreenMatches
+
+        guard !matches.isEmpty else {
+            diag.info("distributeVisibleByFrontmostType: no matches for \(grouping.label)")
+            diag.finish(t)
+            return
+        }
+
+        let ordered = sortWindowsForGrid(matches)
+        diag.info("distributeVisibleByFrontmostType: grouping=\(grouping.label) count=\(ordered.count) screen=\(anchorScreen.localizedName)")
+        batchRaiseAndDistribute(
+            windows: ordered.map { (wid: $0.wid, pid: $0.pid) },
+            reactivateLattices: reactivateLattices
+        )
         diag.finish(t)
     }
 
@@ -1685,7 +1844,11 @@ enum WindowTiler {
 
     /// Raise multiple windows and arrange in smart grid — single CG query, single AX query per process.
     /// If `region` is provided (fractional x, y, w, h), the grid is constrained to that sub-area.
-    static func batchRaiseAndDistribute(windows: [(wid: UInt32, pid: Int32)], region: (CGFloat, CGFloat, CGFloat, CGFloat)? = nil) {
+    static func batchRaiseAndDistribute(
+        windows: [(wid: UInt32, pid: Int32)],
+        region: (CGFloat, CGFloat, CGFloat, CGFloat)? = nil,
+        reactivateLattices: Bool = true
+    ) {
         guard !windows.isEmpty else { return }
         let diag = DiagnosticLog.shared
 
@@ -1744,91 +1907,99 @@ enum WindowTiler {
         }
 
         // Group by pid for AX queries, keep slot mapping
-        var widToSlot: [UInt32: Int] = [:]
-        for (i, win) in windows.enumerated() { widToSlot[win.wid] = i }
-
-        var byPid: [Int32: [(wid: UInt32, target: CGRect)]] = [:]
-        for (i, win) in windows.enumerated() {
-            byPid[win.pid, default: []].append((wid: win.wid, target: slots[i]))
+        var byPid: [Int32: [(slotIdx: Int, wid: UInt32, target: CGRect)]] = [:]
+        let moves: [(wid: UInt32, pid: Int32, frame: CGRect)] = windows.enumerated().map { index, win in
+            let target = slots[index]
+            byPid[win.pid, default: []].append((slotIdx: index, wid: win.wid, target: target))
+            return (wid: win.wid, pid: win.pid, frame: target)
         }
 
-        struct AXWin { let el: AXUIElement; let pos: CGPoint; let size: CGSize }
-
-        // Pass 1: Move all windows to target positions (no raise yet)
+        // Pass 1: Move all windows using exact wid→AX mapping.
         var moved = 0
         var failed: [UInt32] = []
         var resolvedAXElements: [(slotIdx: Int, el: AXUIElement)] = [] // for raise pass
+        var activatedPids = Set<Int32>()
+
+        let cid = _SLSMainConnectionID?()
+        if let cid { _ = _SLSDisableUpdate?(cid) }
 
         for (pid, windowMoves) in byPid {
             let appRef = AXUIElementCreateApplication(pid)
+            AXUIElementSetAttributeValue(appRef, "AXEnhancedUserInterface" as CFString, false as CFTypeRef)
+
             var windowsRef: CFTypeRef?
             let err = AXUIElementCopyAttributeValue(appRef, kAXWindowsAttribute as CFString, &windowsRef)
             guard err == .success, let axWindows = windowsRef as? [AXUIElement] else {
                 diag.warn("  AX query failed for pid=\(pid) err=\(err.rawValue)")
                 failed.append(contentsOf: windowMoves.map(\.wid))
+                AXUIElementSetAttributeValue(appRef, "AXEnhancedUserInterface" as CFString, true as CFTypeRef)
                 continue
             }
 
-            var axCache: [AXWin] = []
+            var axByWid: [UInt32: AXUIElement] = [:]
             for axWin in axWindows {
-                var posRef: CFTypeRef?; var sizeRef: CFTypeRef?
-                AXUIElementCopyAttributeValue(axWin, kAXPositionAttribute as CFString, &posRef)
-                AXUIElementCopyAttributeValue(axWin, kAXSizeAttribute as CFString, &sizeRef)
-                guard let pv = posRef, let sv = sizeRef else { continue }
-                var pos = CGPoint.zero; var size = CGSize.zero
-                AXValueGetValue(pv as! AXValue, .cgPoint, &pos)
-                AXValueGetValue(sv as! AXValue, .cgSize, &size)
-                axCache.append(AXWin(el: axWin, pos: pos, size: size))
+                var windowId: CGWindowID = 0
+                if _AXUIElementGetWindow(axWin, &windowId) == .success {
+                    axByWid[windowId] = axWin
+                }
             }
 
             for wm in windowMoves {
-                guard let cgRect = cgFrames[wm.wid] else {
-                    diag.warn("  wid=\(wm.wid): no CG frame, skipping")
-                    failed.append(wm.wid)
-                    continue
-                }
-                guard let ax = axCache.first(where: {
-                    abs(cgRect.origin.x - $0.pos.x) < 2 && abs(cgRect.origin.y - $0.pos.y) < 2 &&
-                    abs(cgRect.width - $0.size.width) < 2 && abs(cgRect.height - $0.size.height) < 2
-                }) else {
-                    diag.warn("  wid=\(wm.wid): CG frame (\(Int(cgRect.origin.x)),\(Int(cgRect.origin.y)) \(Int(cgRect.width))x\(Int(cgRect.height))) — no AX match among \(axCache.count) AX windows")
-                    for (j, axw) in axCache.enumerated() {
-                        diag.info("    AX[\(j)]: pos=(\(Int(axw.pos.x)),\(Int(axw.pos.y))) size=\(Int(axw.size.width))x\(Int(axw.size.height))")
+                guard let axWin = axByWid[wm.wid] else {
+                    if let cgRect = cgFrames[wm.wid] {
+                        diag.warn("  wid=\(wm.wid): CG frame (\(Int(cgRect.origin.x)),\(Int(cgRect.origin.y)) \(Int(cgRect.width))x\(Int(cgRect.height))) — no AX wid match")
+                    } else {
+                        diag.warn("  wid=\(wm.wid): no CG frame and no AX wid match")
                     }
                     failed.append(wm.wid)
                     continue
                 }
 
-                let slotIdx = widToSlot[wm.wid] ?? -1
-                // Move only — raise comes later
                 var newPos = CGPoint(x: wm.target.origin.x, y: wm.target.origin.y)
                 var newSize = CGSize(width: wm.target.width, height: wm.target.height)
-                let posOk = AXValueCreate(.cgPoint, &newPos).map {
-                    AXUIElementSetAttributeValue(ax.el, kAXPositionAttribute as CFString, $0)
+                let sizeErr1 = AXValueCreate(.cgSize, &newSize).map {
+                    AXUIElementSetAttributeValue(axWin, kAXSizeAttribute as CFString, $0)
+                }
+                let posErr = AXValueCreate(.cgPoint, &newPos).map {
+                    AXUIElementSetAttributeValue(axWin, kAXPositionAttribute as CFString, $0)
                 }
-                let sizeOk = AXValueCreate(.cgSize, &newSize).map {
-                    AXUIElementSetAttributeValue(ax.el, kAXSizeAttribute as CFString, $0)
+                let sizeErr2 = AXValueCreate(.cgSize, &newSize).map {
+                    AXUIElementSetAttributeValue(axWin, kAXSizeAttribute as CFString, $0)
                 }
-                diag.info("  Move[\(slotIdx)] wid=\(wm.wid): target=(\(Int(wm.target.origin.x)),\(Int(wm.target.origin.y))) \(Int(wm.target.width))x\(Int(wm.target.height)) posErr=\(posOk?.rawValue ?? -1) sizeErr=\(sizeOk?.rawValue ?? -1)")
-                resolvedAXElements.append((slotIdx: slotIdx, el: ax.el))
+                diag.info("  Move[\(wm.slotIdx)] wid=\(wm.wid): target=(\(Int(wm.target.origin.x)),\(Int(wm.target.origin.y))) \(Int(wm.target.width))x\(Int(wm.target.height)) sizeErr1=\(sizeErr1?.rawValue ?? -1) posErr=\(posErr?.rawValue ?? -1) sizeErr2=\(sizeErr2?.rawValue ?? -1)")
+                resolvedAXElements.append((slotIdx: wm.slotIdx, el: axWin))
                 moved += 1
             }
+
+            if !activatedPids.contains(pid) {
+                if let app = NSRunningApplication(processIdentifier: pid) {
+                    app.activate()
+                    activatedPids.insert(pid)
+                }
+            }
+
+            AXUIElementSetAttributeValue(appRef, "AXEnhancedUserInterface" as CFString, true as CFTypeRef)
         }
 
-        // Pass 2: Raise all windows in slot order so they all come to front
-        // Sort by slot index so the layout order is predictable
+        if let cid { _ = _SLSReenableUpdate?(cid) }
+
+        // Pass 2: Raise all windows in slot order after app activation so final z-order matches the grid.
         resolvedAXElements.sort { $0.slotIdx < $1.slotIdx }
         for item in resolvedAXElements {
             AXUIElementPerformAction(item.el, kAXRaiseAction as CFString)
+            AXUIElementSetAttributeValue(item.el, kAXMainAttribute as CFString, kCFBooleanTrue)
         }
         diag.info("  Raised \(resolvedAXElements.count) windows in slot order")
 
-        // Pass 3: Activate all apps so windows come to front of other apps
-        var activatedPids = Set<Int32>()
-        for win in windows {
-            if !activatedPids.contains(win.pid) {
-                if let app = NSRunningApplication(processIdentifier: win.pid) { app.activate() }
-                activatedPids.insert(win.pid)
+        // Verify and retry drifted windows once using the battle-tested batch mover.
+        let drifted = verifyMoves(moves)
+        if !drifted.isEmpty {
+            diag.warn("  Drifted after distribute: \(drifted.map(\.wid)) — retrying exact move path")
+            usleep(100_000)
+            batchMoveAndRaiseWindows(drifted)
+            let stillDrifted = verifyMoves(drifted)
+            if !stillDrifted.isEmpty {
+                diag.warn("  Still drifted after retry: \(stillDrifted.map(\.wid))")
             }
         }
 
@@ -1837,8 +2008,10 @@ enum WindowTiler {
         }
         DesktopModel.shared.markInteraction(wids: windows.map(\.wid))
         diag.success("batchRaiseAndDistribute: moved \(moved)/\(windows.count) [\(desc) grid]")
-        DispatchQueue.main.asyncAfter(deadline: .now() + 0.05) {
-            NSApp.activate(ignoringOtherApps: true)
+        if reactivateLattices {
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.05) {
+                NSApp.activate(ignoringOtherApps: true)
+            }
         }
     }
 
@@ -1997,8 +2170,98 @@ enum WindowTiler {
         }) ?? NSScreen.main ?? primaryScreen
     }
 
+    private static func currentMouseCGPoint() -> CGPoint {
+        let mouseLocation = NSEvent.mouseLocation
+        let primaryHeight = NSScreen.screens.first?.frame.height ?? 0
+        return CGPoint(x: mouseLocation.x, y: primaryHeight - mouseLocation.y)
+    }
+
+    private static func switchToAdjacentSpaceViaSystemShortcut(offset: Int, displayId: String, initialSpaceId: Int) -> Int? {
+        let keyCode: CGKeyCode = offset < 0 ? 123 : 124
+        let script = """
+        tell application "System Events"
+            key code \(keyCode) using control down
+        end tell
+        return "ok"
+        """
+        let result = ProcessQuery.shell(["/usr/bin/osascript", "-e", script])
+        if result != "ok" {
+            DiagnosticLog.shared.warn("switchToAdjacentSpace: system shortcut script did not complete for offset \(offset)")
+        }
+        return waitForSpaceChange(displayId: displayId, initialSpaceId: initialSpaceId, timeout: 1.2)
+    }
+
+    private static func waitForSpaceChange(displayId: String, initialSpaceId: Int, timeout: TimeInterval) -> Int? {
+        let deadline = Date().addingTimeInterval(timeout)
+        while Date() < deadline {
+            usleep(30_000)
+            let current = getDisplaySpaces().first(where: { $0.displayId == displayId })?.currentSpaceId ?? 0
+            if current != 0, current != initialSpaceId {
+                return current
+            }
+        }
+        return nil
+    }
+
+    private static func displaySpaces(containing cgPoint: CGPoint) -> DisplaySpaces? {
+        guard let screenIndex = screenIndex(for: cgPoint) else { return nil }
+        return getDisplaySpaces().first(where: { $0.displayIndex == screenIndex })
+    }
+
+    private static func resolvedCurrentSpaceId(for display: DisplaySpaces, activeSpaceId: Int) -> Int {
+        if display.spaces.contains(where: { $0.id == activeSpaceId }) {
+            return activeSpaceId
+        }
+        return display.currentSpaceId
+    }
+
+    private static func formatCGPoint(_ point: CGPoint) -> String {
+        "\(Int(point.x)),\(Int(point.y))"
+    }
+
+    private static func screenIndex(for cgPoint: CGPoint) -> Int? {
+        let primaryHeight = NSScreen.screens.first?.frame.height ?? 0
+        let nsPoint = NSPoint(x: cgPoint.x, y: primaryHeight - cgPoint.y)
+        return NSScreen.screens.firstIndex(where: { $0.frame.contains(nsPoint) })
+            ?? (NSScreen.main != nil ? 0 : nil)
+    }
+
     // MARK: - Private
 
+    private static func visibleDistributableWindows() -> [WindowEntry] {
+        DesktopModel.shared.allWindows().filter { entry in
+            entry.isOnScreen &&
+            entry.app != "Lattices" &&
+            entry.frame.w > 50 &&
+            entry.frame.h > 50
+        }
+    }
+
+    private static func sortWindowsForGrid(_ windows: [WindowEntry]) -> [WindowEntry] {
+        windows.sorted { lhs, rhs in
+            let rowTolerance = 40.0
+            let yDelta = lhs.frame.y - rhs.frame.y
+            if abs(yDelta) > rowTolerance {
+                return lhs.frame.y < rhs.frame.y
+            }
+
+            let xDelta = lhs.frame.x - rhs.frame.x
+            if abs(xDelta) > rowTolerance {
+                return lhs.frame.x < rhs.frame.x
+            }
+
+            return lhs.zIndex < rhs.zIndex
+        }
+    }
+
+    private static func screenID(for screen: NSScreen) -> String {
+        let key = NSDeviceDescriptionKey("NSScreenNumber")
+        if let number = screen.deviceDescription[key] as? NSNumber {
+            return number.stringValue
+        }
+        return screen.localizedName
+    }
+
     private static func tileAppleScript(app: String, tag: String, bounds: (Int, Int, Int, Int)) {
         let (x1, y1, x2, y2) = bounds
         let script = """