Fix vertical keyboard window focus

Ariver

2026-06-19 cb67d8b2fa9b9c9d30cd81d72b8737ee2baa44b6

 C1.source/Sources/Aligner/QuickSwitchRootView.swift

@@ -10,6 +10,8 @@

@MainActor
final class QuickSwitchRootView: NSView {
    private static let appShelfIndexSymbols = Array("1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ").map(String.init)

    private let backdropBlurView = NSVisualEffectView()
    private let layerHostView = NSView()
    private let backgroundLayer = CAGradientLayer()
@@ -67,8 +69,15 @@
    private var horizontalMasonryScrollOffset: CGFloat = 0
    private var currentSelection: QuickSwitchSelection?
    private var columnSelectionHistory: [Int: Int] = [:]
    private var keyboardFocusedAppGroupIndex: Int?
    private var keyboardFocusedWindowID: UInt32?
    private var keyboardCommandsApplied: [String] = []
    private var lastKeyboardCommand: String?
    private var lastKeyboardAppIndexCommand: String?
    private var lastBoundaryBounceAxis: String?
    private var lastBoundaryBounceDirection: String?
    private var boundaryBounceCount = 0
    private var selectionChangedByLastCommand: Bool?
    private var tabIgnoredCount = 0
    private var lastCommittedSelection: QuickSwitchSelection?
    private var lastCommitSource: QuickSwitchCommitSource?
@@ -218,6 +227,7 @@
    private enum HoverTargetSource: String {
        case event
        case debug
        case keyboard
    }

    private struct SpaceLaneSegmentLayers {
@@ -257,6 +267,7 @@
    private struct WaterfallColumnLayers {
        let column: QuickSwitchWaterfallColumnViewModel
        let containerLayer: CALayer
        let cardsClipLayer: CALayer
        let headerLayer: CALayer
        let appNameLayer: CATextLayer
        let countLayer: CATextLayer
@@ -346,6 +357,8 @@
        static let cardGap: CGFloat = 12
        static let revealPadding: CGFloat = 24
        static let horizontalRevealPadding: CGFloat = 0
        static let selectedCardScale: CGFloat = 1.015
        static let selectedCardScaleOverflow: CGFloat = cardHeight * (selectedCardScale - 1) / 2
    }

    private enum HorizontalMasonryMetrics {
@@ -447,6 +460,9 @@
        case TriggerKeyCode.tab:
            performKeyboardCommand("tab")
        default:
            if handleAppShelfIndexKey(event) {
                return
            }
            super.keyDown(with: event)
        }
    }
@@ -727,7 +743,8 @@
        if case .realScreenshot = resolution.source {
            let isSelected = card.item.window.id == effectiveSelection?.windowID
            let isHovered = card.item.window.id == hoveredWindowID
            card.shineLayer.opacity = shouldShowSelectedVisual(isSelected: isSelected, isHovered: isHovered) ? 1 : 0
            let isKeyboardFocused = card.item.window.id == keyboardFocusedWindowID
            card.shineLayer.opacity = (shouldShowSelectedVisual(isSelected: isSelected, isHovered: isHovered) || isKeyboardFocused) ? 1 : 0
        }
        needsLayout = true
    }
@@ -799,6 +816,16 @@
            columnSelectionHistory = columnSelectionHistory.filter { appGroupIndex, _ in
                viewModel?.waterfallColumns.contains { $0.appGroupIndex == appGroupIndex } == true
            }
            if let keyboardFocusedAppGroupIndex,
               viewModel?.waterfallColumns.contains(where: { $0.appGroupIndex == keyboardFocusedAppGroupIndex }) != true {
                self.keyboardFocusedAppGroupIndex = nil
            }
            if let keyboardFocusedWindowID,
               viewModel?.waterfallColumns.contains(where: { column in
                   column.windows.contains { $0.window.id == keyboardFocusedWindowID }
               }) != true {
                self.keyboardFocusedWindowID = nil
            }
            if let currentSelection {
                columnSelectionHistory[currentSelection.appGroupIndex] = currentSelection.windowIndex
            }
@@ -813,8 +840,15 @@
            screenshotSkippedReasonsByWindowID = [:]
            currentSelection = viewModel?.initialSelection
            columnSelectionHistory = [:]
            keyboardFocusedAppGroupIndex = nil
            keyboardFocusedWindowID = nil
            keyboardCommandsApplied = []
            lastKeyboardCommand = nil
            lastKeyboardAppIndexCommand = nil
            lastBoundaryBounceAxis = nil
            lastBoundaryBounceDirection = nil
            boundaryBounceCount = 0
            selectionChangedByLastCommand = nil
            tabIgnoredCount = 0
            lastCommittedSelection = nil
            lastCommitSource = nil
@@ -1233,8 +1267,15 @@
            "selectedAppGroupIndex": effectiveSelection?.appGroupIndex ?? NSNull(),
            "selectedWindowIndex": effectiveSelection?.windowIndex ?? NSNull(),
            "selectedWindowID": effectiveSelection?.windowID ?? NSNull(),
            "keyboardFocusedAppGroupIndex": keyboardFocusedAppGroupIndex ?? NSNull(),
            "keyboardFocusedWindowID": keyboardFocusedWindowID ?? NSNull(),
            "keyboardCommandsApplied": keyboardCommandsApplied,
            "lastKeyboardCommand": lastKeyboardCommand ?? NSNull(),
            "lastKeyboardAppIndexCommand": lastKeyboardAppIndexCommand ?? NSNull(),
            "lastBoundaryBounceAxis": lastBoundaryBounceAxis ?? NSNull(),
            "lastBoundaryBounceDirection": lastBoundaryBounceDirection ?? NSNull(),
            "boundaryBounceCount": boundaryBounceCount,
            "selectionChangedByLastCommand": selectionChangedByLastCommand ?? NSNull(),
            "tabIgnoredCount": tabIgnoredCount,
            "lastCommittedAppGroupIndex": lastCommittedSelection?.appGroupIndex ?? NSNull(),
            "lastCommittedWindowIndex": lastCommittedSelection?.windowIndex ?? NSNull(),
@@ -1307,21 +1348,47 @@
            .lowercased()
        guard !command.isEmpty else { return }

        if let indexSymbol = appShelfIndexSymbol(fromKeyboardCommand: command) {
            let recordedCommand = "app:\(indexSymbol)"
            recordKeyboardCommand(recordedCommand)
            if !focusAppShelfItemForKeyboard(indexSymbol: indexSymbol, commandLabel: recordedCommand) {
                selectionChangedByLastCommand = false
            }
            return
        }

        switch command {
        case "left":
            recordKeyboardCommand("left")
            moveSelection(.left)
            if isHorizontalMasonryMode {
                moveSelection(.left)
            } else if !moveKeyboardAppFocus(cycleForward: false) {
                selectionChangedByLastCommand = false
            }
        case "right":
            recordKeyboardCommand("right")
            moveSelection(.right)
            if isHorizontalMasonryMode {
                moveSelection(.right)
            } else if !moveKeyboardAppFocus(cycleForward: true) {
                selectionChangedByLastCommand = false
            }
        case "up":
            recordKeyboardCommand("up")
            moveSelection(.up)
            if isHorizontalMasonryMode {
                moveSelection(.up)
            } else {
                moveVerticalSelectionWithinFocusedColumn(.up)
            }
        case "down":
            recordKeyboardCommand("down")
            moveSelection(.down)
            if isHorizontalMasonryMode {
                moveSelection(.down)
            } else {
                moveVerticalSelectionWithinFocusedColumn(.down)
            }
        case "enter", "return", "commit":
            recordKeyboardCommand("enter")
            selectionChangedByLastCommand = false
            commitCurrentSelection()
        case "tab":
            if isHorizontalMasonryMode {
@@ -1330,15 +1397,243 @@
            } else {
                tabIgnoredCount += 1
                recordKeyboardCommand("tabIgnored")
                selectionChangedByLastCommand = false
            }
        default:
            recordKeyboardCommand("unknown:\(command)")
            selectionChangedByLastCommand = false
        }
    }

    private func recordKeyboardCommand(_ command: String) {
        lastKeyboardCommand = command
        keyboardCommandsApplied.append(command)
    }

    private func handleAppShelfIndexKey(_ event: NSEvent) -> Bool {
        guard !isHorizontalMasonryMode else { return false }
        let flags = event.modifierFlags.intersection(.deviceIndependentFlagsMask)
        guard flags.isDisjoint(with: [.command, .control]) else { return false }
        guard let characters = event.charactersIgnoringModifiers,
              let symbol = appShelfIndexSymbol(fromKeyboardCommand: characters)
        else {
            return false
        }

        performKeyboardCommand(symbol)
        return true
    }

    private func appShelfIndexSymbol(fromKeyboardCommand command: String) -> String? {
        var candidate = command.trimmingCharacters(in: .whitespacesAndNewlines).uppercased()
        for prefix in ["APP:", "APP-", "INDEX:", "INDEX-"] where candidate.hasPrefix(prefix) {
            candidate.removeFirst(prefix.count)
            break
        }
        guard candidate.count == 1,
              Self.appShelfIndexSymbols.contains(candidate)
        else {
            return nil
        }
        return candidate
    }

    private func focusAppShelfItemForKeyboard(indexSymbol: String, commandLabel: String) -> Bool {
        guard let ordinal = Self.appShelfIndexSymbols.firstIndex(of: indexSymbol),
              ordinal < appShelfItems.count
        else {
            return false
        }

        return focusAppShelfItemForKeyboard(
            appGroupIndex: appShelfItems[ordinal].item.appGroupIndex,
            appIndexCommand: commandLabel
        )
    }

    @discardableResult
    private func focusAppShelfItemForKeyboard(
        appGroupIndex: Int,
        appIndexCommand: String? = nil
    ) -> Bool {
        guard appShelfItems.contains(where: { $0.item.appGroupIndex == appGroupIndex }),
              waterfallColumns.contains(where: { $0.column.appGroupIndex == appGroupIndex })
        else {
            return false
        }

        keyboardFocusedAppGroupIndex = appGroupIndex
        keyboardFocusedWindowID = nil
        lastKeyboardAppIndexCommand = appIndexCommand
        selectionChangedByLastCommand = false
        clearKeyboardBoundaryFeedback()
        ensureAppShelfItemVisible(appGroupIndex)
        layoutSubtreeIfNeeded()
        hoverAppGroup(appGroupIndex, source: .keyboard)
        needsLayout = true
        return true
    }

    @discardableResult
    private func moveKeyboardAppFocus(cycleForward: Bool) -> Bool {
        let orderedAppGroupIndexes = appShelfItems.map(\.item.appGroupIndex)
        guard !orderedAppGroupIndexes.isEmpty else { return false }

        let currentAppGroupIndex = keyboardFocusedAppGroupIndex
            ?? appHoverTargetAppGroupIndex
            ?? effectiveSelection?.appGroupIndex
        let currentPosition = currentAppGroupIndex.flatMap { orderedAppGroupIndexes.firstIndex(of: $0) }
        let nextPosition = currentPosition.map { current in
            if cycleForward {
                return (current + 1) % orderedAppGroupIndexes.count
            }
            return (current - 1 + orderedAppGroupIndexes.count) % orderedAppGroupIndexes.count
        } ?? (cycleForward ? 0 : orderedAppGroupIndexes.count - 1)

        return focusAppShelfItemForKeyboard(appGroupIndex: orderedAppGroupIndexes[nextPosition])
    }

    private var appHoverTargetAppGroupIndex: Int? {
        guard case .app(let appGroupIndex) = hoverTarget else { return nil }
        return appGroupIndex
    }

    private func moveVerticalSelectionWithinFocusedColumn(_ direction: QuickSwitchKeyboardDirection) {
        guard direction == .up || direction == .down,
              let targetAppGroupIndex = verticalKeyboardNavigationAppGroupIndex(),
              let column = waterfallColumns.first(where: { $0.column.appGroupIndex == targetAppGroupIndex })
        else {
            DevelopmentDiagnostics.log("quickSwitch.view.moveVerticalSelection.blocked", [
                "direction": keyboardDirectionName(direction),
                "hasFocusedApp": keyboardFocusedAppGroupIndex != nil,
                "hasSelection": effectiveSelection != nil
            ])
            selectionChangedByLastCommand = false
            return
        }

        let cards = column.cards.sorted { $0.item.windowIndex < $1.item.windowIndex }
        guard !cards.isEmpty else {
            selectionChangedByLastCommand = false
            return
        }

        let previousSelection = effectiveSelection
        let nextSelection: QuickSwitchSelection
        if let current = previousSelection,
           current.appGroupIndex == targetAppGroupIndex,
           let currentPosition = cards.firstIndex(where: { $0.item.window.id == current.windowID }) {
            let nextPosition = currentPosition + (direction == .down ? 1 : -1)
            guard cards.indices.contains(nextPosition) else {
                keyboardFocusedAppGroupIndex = targetAppGroupIndex
                hoverAppGroup(targetAppGroupIndex, source: .keyboard)
                triggerKeyboardBoundaryFeedback(appGroupIndex: targetAppGroupIndex, direction: direction)
                DevelopmentDiagnostics.log("quickSwitch.view.moveVerticalSelection.boundary", [
                    "direction": keyboardDirectionName(direction),
                    "appGroupIndex": targetAppGroupIndex,
                    "windowIndex": current.windowIndex
                ])
                needsLayout = true
                return
            }
            nextSelection = selectionForCard(cards[nextPosition])
        } else {
            let rememberedWindowIndex = columnSelectionHistory[targetAppGroupIndex]
            let rememberedCard = rememberedWindowIndex.flatMap { windowIndex in
                cards.first { $0.item.windowIndex == windowIndex }
            }
            nextSelection = selectionForCard(rememberedCard ?? cards[0])
        }

        keyboardFocusedAppGroupIndex = targetAppGroupIndex
        currentSelection = nextSelection
        keyboardFocusedWindowID = nextSelection.windowID
        columnSelectionHistory[nextSelection.appGroupIndex] = nextSelection.windowIndex
        selectionChangedByLastCommand = previousSelection != nextSelection
        clearKeyboardBoundaryFeedback()
        hoverAppGroup(targetAppGroupIndex, source: .keyboard)
        ensureCurrentSelectionVisible(horizontalIntent: .alignWithAppShelf(animated: true))
        DevelopmentDiagnostics.log("quickSwitch.view.moveVerticalSelection", [
            "direction": keyboardDirectionName(direction),
            "appGroupIndex": nextSelection.appGroupIndex,
            "windowIndex": nextSelection.windowIndex,
            "windowID": nextSelection.windowID
        ])
        needsLayout = true
    }

    private func verticalKeyboardNavigationAppGroupIndex() -> Int? {
        if let keyboardFocusedAppGroupIndex,
           waterfallColumns.contains(where: { $0.column.appGroupIndex == keyboardFocusedAppGroupIndex }) {
            return keyboardFocusedAppGroupIndex
        }
        if let appHoverTargetAppGroupIndex,
           waterfallColumns.contains(where: { $0.column.appGroupIndex == appHoverTargetAppGroupIndex }) {
            return appHoverTargetAppGroupIndex
        }
        if let appGroupIndex = effectiveSelection?.appGroupIndex,
           waterfallColumns.contains(where: { $0.column.appGroupIndex == appGroupIndex }) {
            return appGroupIndex
        }
        return waterfallColumns.first?.column.appGroupIndex
    }

    private func clearKeyboardBoundaryFeedback() {
        lastBoundaryBounceAxis = nil
        lastBoundaryBounceDirection = nil
    }

    private func triggerKeyboardBoundaryFeedback(
        appGroupIndex: Int,
        direction: QuickSwitchKeyboardDirection
    ) {
        selectionChangedByLastCommand = false
        lastBoundaryBounceAxis = "vertical"
        lastBoundaryBounceDirection = keyboardDirectionName(direction)
        boundaryBounceCount += 1

        layoutSubtreeIfNeeded()
        guard let column = waterfallColumns.first(where: { $0.column.appGroupIndex == appGroupIndex }) else { return }

        let animationKey = "keyboardBoundaryBounce"
        column.containerLayer.removeAnimation(forKey: animationKey)
        if NSWorkspace.shared.accessibilityDisplayShouldReduceMotion {
            let pulse = CABasicAnimation(keyPath: "opacity")
            pulse.fromValue = 1
            pulse.toValue = 0.9
            pulse.duration = 0.12
            pulse.autoreverses = true
            pulse.timingFunction = CAMediaTimingFunction(name: .easeInEaseOut)
            column.containerLayer.add(pulse, forKey: animationKey)
            return
        }

        let currentY = column.containerLayer.presentation()?.position.y
            ?? column.containerLayer.position.y
        let delta: CGFloat = direction == .up ? 5 : -5
        let bounce = CAKeyframeAnimation(keyPath: "position.y")
        bounce.values = [currentY, currentY + delta, currentY]
        bounce.keyTimes = [0, 0.38, 1]
        bounce.timingFunctions = [
            CAMediaTimingFunction(name: .easeOut),
            CAMediaTimingFunction(name: .easeInEaseOut)
        ]
        bounce.duration = 0.23
        bounce.isRemovedOnCompletion = true
        column.containerLayer.add(bounce, forKey: animationKey)
    }

    private func keyboardDirectionName(_ direction: QuickSwitchKeyboardDirection) -> String {
        switch direction {
        case .left:
            return "left"
        case .right:
            return "right"
        case .up:
            return "up"
        case .down:
            return "down"
        }
    }

    private func performMouseCommand(_ rawCommand: String) {
@@ -1491,13 +1786,13 @@
        return command.hasPrefix("hover-")
    }

    private func hoverAppGroup(_ appGroupIndex: Int) {
    private func hoverAppGroup(_ appGroupIndex: Int, source: HoverTargetSource = .debug) {
        updateHoverState(
            appGroupIndex: appGroupIndex,
            windowID: nil,
            spaceID: nil,
            alignsWaterfallWithAppShelf: true,
            source: .debug
            source: source
        )
    }

@@ -1778,8 +2073,11 @@
        }

        columnSelectionHistory[current.appGroupIndex] = current.windowIndex
        let previousSelection = effectiveSelection
        currentSelection = next
        columnSelectionHistory[next.appGroupIndex] = next.windowIndex
        selectionChangedByLastCommand = previousSelection != next
        clearKeyboardBoundaryFeedback()
        ensureCurrentSelectionVisible(horizontalIntent: .alignWithAppShelf(animated: true))
        DevelopmentDiagnostics.log("quickSwitch.view.moveSelection", [
            "direction": String(describing: direction),
@@ -1802,8 +2100,11 @@
        }

        columnSelectionHistory[current.appGroupIndex] = current.windowIndex
        let previousSelection = effectiveSelection
        currentSelection = next
        columnSelectionHistory[next.appGroupIndex] = next.windowIndex
        selectionChangedByLastCommand = previousSelection != next
        clearKeyboardBoundaryFeedback()
        ensureCurrentSelectionVisible(horizontalIntent: .alignWithAppShelf(animated: true))
        DevelopmentDiagnostics.log("quickSwitch.view.moveHorizontalMasonrySelection", [
            "direction": String(describing: direction),
@@ -2481,8 +2782,13 @@
            container.borderColor = NSColor.separatorColor.withAlphaComponent(0.34).cgColor
            container.borderWidth = 1

            let cardsClip = CALayer()
            cardsClip.masksToBounds = true
            cardsClip.backgroundColor = NSColor.clear.cgColor

            let header = CALayer()
            header.backgroundColor = NSColor.controlBackgroundColor.withAlphaComponent(0.68).cgColor
            header.zPosition = 40

            let appName = makeTextLayer(
                string: column.app.name,
@@ -2499,6 +2805,10 @@
                alignment: .right
            )

            appName.zPosition = 42
            count.zPosition = 42

            container.addSublayer(cardsClip)
            container.addSublayer(header)
            container.addSublayer(appName)
            container.addSublayer(count)
@@ -2565,7 +2875,7 @@
                card.addSublayer(state)
                card.addSublayer(shine)
                card.addSublayer(closeButton.containerLayer)
                container.addSublayer(card)
                cardsClip.addSublayer(card)

                return WaterfallCardLayers(
                    item: window,
@@ -2586,6 +2896,7 @@
            return WaterfallColumnLayers(
                column: column,
                containerLayer: container,
                cardsClipLayer: cardsClip,
                headerLayer: header,
                appNameLayer: appName,
                countLayer: count,
@@ -3305,7 +3616,14 @@
                x: locationInWaterfallContent.x - column.containerLayer.frame.minX,
                y: locationInWaterfallContent.y - column.containerLayer.frame.minY
            )
            if let card = column.cards.first(where: { $0.containerLayer.frame.contains(locationInColumn) }) {
            guard column.cardsClipLayer.frame.contains(locationInColumn) else {
                continue
            }
            let locationInCardsClip = CGPoint(
                x: locationInColumn.x - column.cardsClipLayer.frame.minX,
                y: locationInColumn.y - column.cardsClipLayer.frame.minY
            )
            if let card = column.cards.first(where: { $0.containerLayer.frame.contains(locationInCardsClip) }) {
                return card
            }
        }
@@ -3543,15 +3861,14 @@
    }

    private func appShelfIndexText(forOrdinal ordinal: Int) -> String {
        let symbols = Array("1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ")
        guard ordinal >= 0 else { return "" }
        if ordinal < symbols.count {
            return String(symbols[ordinal])
        if ordinal < Self.appShelfIndexSymbols.count {
            return Self.appShelfIndexSymbols[ordinal]
        }

        let overflowIndex = ordinal - symbols.count
        let prefix = symbols[10 + (overflowIndex / 26) % 26]
        let suffix = symbols[10 + overflowIndex % 26]
        let overflowIndex = ordinal - Self.appShelfIndexSymbols.count
        let prefix = Self.appShelfIndexSymbols[10 + (overflowIndex / 26) % 26]
        let suffix = Self.appShelfIndexSymbols[10 + overflowIndex % 26]
        return "\(prefix)\(suffix)"
    }

@@ -3869,6 +4186,8 @@
            column.containerLayer.shadowOpacity = 0
            column.containerLayer.shadowRadius = 0
            column.containerLayer.shadowOffset = .zero
            column.cardsClipLayer.frame = column.containerLayer.bounds
            column.cardsClipLayer.masksToBounds = false
            column.headerLayer.isHidden = true
            column.appNameLayer.isHidden = true
            column.countLayer.isHidden = true
@@ -4008,6 +4327,14 @@
        column.countLayer.isHidden = false

        let bounds = column.containerLayer.bounds
        let cardsClipFrame = CGRect(
            x: 0,
            y: 0,
            width: bounds.width,
            height: max(1, bounds.height - WaterfallMetrics.headerHeight)
        )
        column.cardsClipLayer.frame = cardsClipFrame
        column.cardsClipLayer.masksToBounds = true
        let isSpaceFocused = spaceFocusWindowCount(for: column.column.appGroupIndex) > 0
        let isHovered = column.column.appGroupIndex == effectiveHoveredAppGroupIndex
        column.containerLayer.borderColor = (isSpaceFocused
@@ -4050,8 +4377,8 @@
        waterfallColumnScrollOffsets[appGroupIndex] = verticalOffset

        let cardWidth = max(1, bounds.width - WaterfallMetrics.columnHorizontalPadding * 2)
        let firstCardTop = bounds.height
            - WaterfallMetrics.headerHeight
        let firstCardTop = cardsClipFrame.height
            - WaterfallMetrics.selectedCardScaleOverflow
            - WaterfallMetrics.columnVerticalPadding
            + verticalOffset

@@ -4075,10 +4402,11 @@
        let bounds = card.containerLayer.bounds
        let isSelected = card.item.window.id == effectiveSelection?.windowID
        let isHovered = card.item.window.id == hoveredWindowID
        let isKeyboardFocused = card.item.window.id == keyboardFocusedWindowID
        let isAppLinked = isWaterfallCardAppLinked(card)
        applyWaterfallCardVisualState(
            card,
            selected: shouldShowSelectedVisual(isSelected: isSelected, isHovered: isHovered),
            selected: shouldShowSelectedVisual(isSelected: isSelected, isHovered: isHovered) || isKeyboardFocused,
            hovered: isHovered,
            appLinked: isAppLinked
        )
@@ -4184,7 +4512,7 @@
                    ? CGSize(width: 0, height: -5)
                    : .zero
        card.containerLayer.zPosition = selected ? 20 : hovered ? 12 : appLinked ? 10 : isSpaceFocused ? 8 : 0
        let focusedScale: CGFloat = selected ? 1.015 : isSpaceFocused ? 1.012 : 1.008
        let focusedScale: CGFloat = selected ? WaterfallMetrics.selectedCardScale : isSpaceFocused ? 1.012 : 1.008
        card.containerLayer.transform = (selected || hovered || isSpaceFocused)
            ? CATransform3DMakeScale(focusedScale, focusedScale, 1)
            : CATransform3DIdentity
@@ -4660,11 +4988,18 @@
                x: locationInWaterfallContent.x - column.containerLayer.frame.minX,
                y: locationInWaterfallContent.y - column.containerLayer.frame.minY
            )
            for card in column.cards where card.containerLayer.frame.contains(locationInColumn) {
            guard column.cardsClipLayer.frame.contains(locationInColumn) else {
                continue
            }
            let locationInCardsClip = CGPoint(
                x: locationInColumn.x - column.cardsClipLayer.frame.minX,
                y: locationInColumn.y - column.cardsClipLayer.frame.minY
            )
            for card in column.cards where card.containerLayer.frame.contains(locationInCardsClip) {
                guard card.closeButton.containerLayer.opacity > 0 else { continue }
                let locationInCard = CGPoint(
                    x: locationInColumn.x - card.containerLayer.frame.minX,
                    y: locationInColumn.y - card.containerLayer.frame.minY
                    x: locationInCardsClip.x - card.containerLayer.frame.minX,
                    y: locationInCardsClip.y - card.containerLayer.frame.minY
                )
                if card.closeButton.containerLayer.frame.insetBy(dx: -8, dy: -8).contains(locationInCard) {
                    return .window(
@@ -4706,11 +5041,13 @@
                x: waterfallLayer.frame.minX
                    + waterfallContentLayer.frame.minX
                    + column.containerLayer.frame.minX
                    + column.cardsClipLayer.frame.minX
                    + card.containerLayer.frame.minX
                    + card.closeButton.containerLayer.frame.midX,
                y: waterfallLayer.frame.minY
                    + waterfallContentLayer.frame.minY
                    + column.containerLayer.frame.minY
                    + column.cardsClipLayer.frame.minY
                    + card.containerLayer.frame.minY
                    + card.closeButton.containerLayer.frame.midY
            )
@@ -4838,7 +5175,7 @@
        )
        let contentHeight = CGFloat(column.cards.count) * WaterfallMetrics.cardHeight
            + CGFloat(max(0, column.cards.count - 1)) * WaterfallMetrics.cardGap
        return max(0, contentHeight - visibleHeight)
        return max(0, contentHeight - visibleHeight + WaterfallMetrics.selectedCardScaleOverflow * 2)
    }

    private func clampedWaterfallColumnOffset(_ offset: CGFloat, appGroupIndex: Int) -> CGFloat {
@@ -5261,10 +5598,13 @@
            let appGroupIndex = column.column.appGroupIndex
            let isHovered = appGroupIndex == effectiveHoveredAppGroupIndex
            let firstCardFrame = column.cards.first?.containerLayer.frame
            let headerToFirstCardGap = firstCardFrame.map {
            let visibleFirstCardFrame = firstCardFrame.map {
                $0.offsetBy(dx: column.cardsClipLayer.frame.minX, dy: column.cardsClipLayer.frame.minY)
            }
            let headerToFirstCardGap = visibleFirstCardFrame.map {
                column.headerLayer.frame.minY - $0.maxY
            }
            let topToFirstCardGap = firstCardFrame.map {
            let topToFirstCardGap = visibleFirstCardFrame.map {
                column.containerLayer.bounds.height - $0.maxY
            }

@@ -5282,6 +5622,8 @@
                "visibleFrame": dictionary(from: visibleFrame),
                "headerFrame": dictionary(from: column.headerLayer.frame),
                "headerBackgroundColor": colorDictionary(from: column.headerLayer.backgroundColor),
                "cardsClipFrame": dictionary(from: column.cardsClipLayer.frame),
                "cardsClipMasksToBounds": column.cardsClipLayer.masksToBounds,
                "headerToFirstCardGap": headerToFirstCardGap.map(Double.init) ?? NSNull(),
                "topToFirstCardGap": topToFirstCardGap.map(Double.init) ?? NSNull(),
                "appNameFrame": dictionary(from: column.appNameLayer.frame),
@@ -5346,8 +5688,8 @@
    private func waterfallCardReports(for column: WaterfallColumnLayers) -> [[String: Any]] {
        column.cards.map { card in
            let visibleFrame = card.containerLayer.frame.offsetBy(
                dx: column.containerLayer.frame.minX + waterfallContentLayer.frame.minX,
                dy: column.containerLayer.frame.minY
                dx: column.containerLayer.frame.minX + column.cardsClipLayer.frame.minX + waterfallContentLayer.frame.minX,
                dy: column.containerLayer.frame.minY + column.cardsClipLayer.frame.minY
            )
            let screenshotSource = screenshotSourcesByWindowID[card.item.window.id]

@@ -5365,6 +5707,7 @@
                "isFullscreen": card.item.window.isFullscreen,
                "identifierSource": "\(card.item.window.identifierSource)",
                "isSelected": card.item.window.id == effectiveSelection?.windowID,
                "isKeyboardFocused": card.item.window.id == keyboardFocusedWindowID,
                "visualStates": waterfallCardVisualStates(for: card),
                "thumbnailStrategy": thumbnailStrategyString(for: card.item.window),
                "screenshotSource": screenshotSourceString(screenshotSource, for: card.item.window),
@@ -5483,12 +5826,16 @@
        var states: [String] = []
        let isSelected = card.item.window.id == effectiveSelection?.windowID
        let isHovered = card.item.window.id == hoveredWindowID
        let isKeyboardFocused = card.item.window.id == keyboardFocusedWindowID
        let isAppLinked = isWaterfallCardAppLinked(card)
        if shouldShowSelectedVisual(isSelected: isSelected, isHovered: isHovered) {
        if shouldShowSelectedVisual(isSelected: isSelected, isHovered: isHovered) || isKeyboardFocused {
            states.append("selected")
        } else if isSelected {
            states.append("selectedVisualSuppressed")
        }
        if isKeyboardFocused {
            states.append("keyboardFocused")
        }
        if isHovered {
            states.append("hover")
        }