crazy-macs/aligner.git

			@@ -1,5 +1,6 @@
			import AppKit
			import QuartzCore
			import Darwin
			import AlignerCore

			enum QuickSwitchCommitSource: String {
			@@ -9,9 +10,25 @@

			@MainActor
			final class QuickSwitchRootView: NSView {
			private static let appShelfIndexSymbols = Array("1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ").map(String.init)
			private static let windowIndexKeyPendingInterval: CFTimeInterval = 0.8
			private static let appShelfIndexKeyCodes: [String: UInt16] = [
			"1": 18, "2": 19, "3": 20, "4": 21, "5": 23,
			"6": 22, "7": 26, "8": 28, "9": 25, "0": 29,
			"A": 0, "B": 11, "C": 8, "D": 2, "E": 14, "F": 3,
			"G": 5, "H": 4, "I": 34, "J": 38, "K": 40, "L": 37,
			"M": 46, "N": 45, "O": 31, "P": 35, "Q": 12, "R": 15,
			"S": 1, "T": 17, "U": 32, "V": 9, "W": 13, "X": 7,
			"Y": 16, "Z": 6
			]

			private let backdropBlurView = NSVisualEffectView()
			private let layerHostView = NSView()
			private let backgroundLayer = CAGradientLayer()
			private let darkAmbientLeftLayer = CAGradientLayer()
			private let darkAmbientCenterLayer = CAGradientLayer()
			private let darkAmbientRightLayer = CAGradientLayer()
			private let darkVignetteLayer = CAGradientLayer()
			private let safeAreaFillLayer = CALayer()
			private let glassLayer = CALayer()
			private let laneLayer = CALayer()
			@@ -20,11 +37,19 @@
			private let appShelfContentLayer = CALayer()
			private let waterfallLayer = CALayer()
			private let waterfallContentLayer = CALayer()
			private lazy var closeConfirmationLayers = makeCloseConfirmationLayers()
			private let closeFeedbackLayer = CALayer()
			private let closeFeedbackTextLayer = CATextLayer()
			private let viewModeToggleButtonLayer = CALayer()
			private let viewModeToggleIconLayer = CALayer()
			private let themeToggleButtonLayer = CALayer()
			private let themeToggleIconLayer = CALayer()
			private let appIconProvider: any AppIconProviderProtocol = WorkspaceAppIconProvider()
			private let skeletonThumbnailProvider = NativeSkeletonThumbnailProvider(size: NSSize(width: 160, height: 96))
			private var screenshotSourcesByWindowID: [UInt32: ScreenshotResolutionSource] = [:]
			private var screenshotSkippedReasonsByWindowID: [UInt32: String] = [:]
			private var currentViewModel: QuickSwitchViewModel?
			private var spaceLaneDisplayGroups: [SpaceLaneDisplayGroupLayers] = []
			private var spaceLaneSegments: [SpaceLaneSegmentLayers] = []
			private var spaceLaneContentWidth: CGFloat = 0
			private var spaceLaneScrollOffset: CGFloat = 0
			@@ -33,20 +58,54 @@
			private var appShelfContentWidth: CGFloat = 0
			private var appShelfScrollOffset: CGFloat = 0
			private var appShelfTrackingArea: NSTrackingArea?
			private var lastKnownMouseWindowLocation: CGPoint?
			private var hoveredAppGroupIndex: Int?
			private var hoveredWindowID: UInt32?
			private var hoveredSpaceID: UInt64?
			private var hoveredCloseTarget: CloseTarget?
			private var pendingCloseTarget: CloseTarget?
			private var pendingCloseRequest: QuickSwitchCloseRequest?
			private var pendingCloseOptOut = false
			private var closeConfirmationArrowEdge: CloseConfirmationArrowEdge?
			private var closeConfirmationRequired = true
			private var closeFeedback: CloseFeedback?
			private var closeFeedbackHideTask: Task<Void, Never>?
			private var isViewModeToggleButtonHovered = false
			private var suppressViewModeToggleHoverPreview = false
			private var isThemeToggleButtonHovered = false
			private var suppressThemeToggleHoverPreview = false
			private var hoverTarget: HoverTarget = .none
			private var hoverTargetSource: HoverTargetSource = .event
			private var hoveredSpaceLaneID: UInt64?
			private var focusedSpaceID: UInt64?
			private var debugHoveredAppGroupIndex: Int?
			private var waterfallColumns: [WaterfallColumnLayers] = []
			private var waterfallViewMode: QuickSwitchWaterfallViewMode = .verticalColumns
			private var themePreference: ThemePreference = .light
			private var waterfallContentWidth: CGFloat = 0
			private var waterfallScrollOffset: CGFloat = 0
			private var waterfallColumnScrollOffsets: [Int: CGFloat] = [:]
			private var horizontalMasonryContentHeight: CGFloat = 0
			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 appShelfIndexKeyDownCount = 0
			private var lastAppShelfIndexKeySymbol: String?
			private var windowIndexKeyPending: WindowIndexKeyPending?
			private var windowIndexKeyPendingClearTask: Task<Void, Never>?
			private var lastWindowIndexKeyCommand: String?
			private var lastWindowIndexKeyCommitCode: String?
			private var windowShortcutFilterPhase: WindowShortcutFilterPhase = .none
			private var lastWindowShortcutPreCommitFilterSnapshot: WindowShortcutPreCommitFilterSnapshot?
			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?
			@@ -63,8 +122,168 @@
			private var keyboardResponseLatencyMilliseconds: [Double] = []
			private var mouseResponseLatencyMilliseconds: [Double] = []
			private var hoverResponseLatencyMilliseconds: [Double] = []
			private var lastProjectionTransitionMovedLayerCount = 0
			private var lastProjectionTransitionFadeInLayerCount = 0
			private var lastProjectionTransitionFadeOutLayerCount = 0
			private var lastProjectionTransitionDurationMilliseconds: Double = 0
			private var suppressEventInput = false
			private var suppressEventBackgroundClicks = false
			var onEscape: (() -> Void)?
			var onCommitSelection: ((QuickSwitchSelection, QuickSwitchCommitSource) -> Void)?
			var onSpaceLaneClick: ((UInt64, Int) -> Void)?
			var onBackgroundClick: (() -> Bool)?
			var onToggleWaterfallViewMode: (() -> Void)?
			var onToggleTheme: (() -> Void)?
			var onRequestClose: ((QuickSwitchCloseRequest) -> Void)?
			var onCloseConfirmationDisabled: (() -> Void)?

			private enum CloseTarget: Equatable {
			case app(appGroupIndex: Int)
			case window(appGroupIndex: Int, windowIndex: Int, windowID: UInt32)

			var kindDescription: String {
			switch self {
			case .app:
			return "app"
			case .window:
			return "window"
			}
			}
			}

			private struct CloseButtonLayers {
			let containerLayer: CALayer
			let glyphLayer: CAShapeLayer
			}

			private struct CloseConfirmationLayers {
			let containerLayer: CALayer
			let backgroundLayer: CAShapeLayer
			let titleLayer: CATextLayer
			let messageLayer: CATextLayer
			let checkboxLayer: CALayer
			let checkboxMarkLayer: CATextLayer
			let checkboxLabelLayer: CATextLayer
			let confirmButtonLayer: CALayer
			let confirmButtonTextLayer: CATextLayer
			let cancelButtonLayer: CALayer
			let cancelButtonTextLayer: CATextLayer
			}

			private struct CloseFeedback: Equatable, Sendable {
			enum Kind: String, Sendable {
			case progress
			case failure
			}

			let kind: Kind
			let message: String
			let targetKind: String
			let appGroupIndex: Int
			let windowID: UInt32?
			}

			private enum CloseConfirmationArrowEdge: String {
			case left
			case right
			}

			private enum HoverTarget: Equatable {
			case none
			case space(UInt64)
			case app(Int)
			case window(appGroupIndex: Int, windowID: UInt32, spaceID: UInt64?)

			var kindDescription: String {
			switch self {
			case .none:
			return "none"
			case .space:
			return "space"
			case .app:
			return "app"
			case .window:
			return "window"
			}
			}

			var appGroupIndex: Int? {
			switch self {
			case .app(let appGroupIndex):
			return appGroupIndex
			case .window(let appGroupIndex, _, _):
			return appGroupIndex
			case .none, .space:
			return nil
			}
			}

			var windowID: UInt32? {
			switch self {
			case .window(_, let windowID, _):
			return windowID
			case .none, .space, .app:
			return nil
			}
			}

			var spaceID: UInt64? {
			switch self {
			case .space(let spaceID):
			return spaceID
			case .window(_, _, let spaceID):
			return spaceID
			case .none, .app:
			return nil
			}
			}

			var spaceLaneID: UInt64? {
			guard case .space(let spaceID) = self else { return nil }
			return spaceID
			}

			var shouldAlignWaterfallWithAppShelf: Bool {
			switch self {
			case .app:
			return true
			case .none, .space, .window:
			return false
			}
			}
			}

			private enum HoverTargetSource: String {
			case event
			case debug
			case keyboard
			}

			private enum HorizontalKeyboardFocusKind: String {
			case app
			case window
			}

			private struct HorizontalKeyboardFocusNode {
			let kind: HorizontalKeyboardFocusKind
			let appGroupIndex: Int
			let windowIndex: Int?
			let windowID: UInt32?
			let spaceID: UInt64?
			let frame: CGRect
			let order: Int

			var center: CGPoint {
			CGPoint(x: frame.midX, y: frame.midY)
			}

			func matches(_ other: HorizontalKeyboardFocusNode) -> Bool {
			kind == other.kind
			&& appGroupIndex == other.appGroupIndex
			&& windowIndex == other.windowIndex
			&& windowID == other.windowID
			}
			}

			private struct SpaceLaneSegmentLayers {
			let space: QuickSwitchSpaceViewModel
			@@ -72,18 +291,27 @@
			let labelLayer: CATextLayer
			let countLayer: CATextLayer
			let appLayer: CATextLayer
			let splitAppLayers: [CATextLayer]
			let windowBlocks: [CALayer]
			let fullscreenMarkerLayer: CALayer?
			}

			private struct SpaceLaneDisplayGroupLayers {
			let display: QuickSwitchDisplayViewModel
			let containerLayer: CALayer
			let segments: [SpaceLaneSegmentLayers]
			}

			private struct AppShelfItemLayers {
			let item: QuickSwitchAppShelfItemViewModel
			let containerLayer: CALayer
			let backgroundLayer: CALayer
			let indexLayer: CATextLayer
			let iconLayer: CALayer
			let labelLayer: CATextLayer
			let badgeLayer: CATextLayer
			let selectedIndicatorLayer: CALayer
			let closeButton: CloseButtonLayers
			}

			private struct AppShelfLayout {
			@@ -94,6 +322,7 @@
			private struct WaterfallColumnLayers {
			let column: QuickSwitchWaterfallColumnViewModel
			let containerLayer: CALayer
			let cardsClipLayer: CALayer
			let headerLayer: CALayer
			let appNameLayer: CATextLayer
			let countLayer: CATextLayer
			@@ -103,12 +332,77 @@
			private struct WaterfallCardLayers {
			let item: QuickSwitchWindowCardViewModel
			let containerLayer: CALayer
			let titleBarLayer: CALayer
			let titleLayer: CATextLayer
			let metaLayer: CATextLayer
			let thumbnailLayer: CALayer
			let appIconLayer: CALayer
			let stateLayer: CATextLayer
			let shineLayer: CAGradientLayer
			let closeButton: CloseButtonLayers
			}

			private struct WindowIndexKeyPending {
			let appSymbol: String
			let appGroupIndex: Int
			let startedAt: CFTimeInterval
			}

			private enum WindowShortcutFilterPhase: String {
			case none
			case appPending
			case targetPreCommit
			case invalid
			case expired
			}

			private enum WindowShortcutFilterState: String {
			case none
			case matched
			case dimmed
			case target
			}

			private struct WindowShortcutPreCommitFilterSnapshot {
			let targetCode: String
			let targetWindowID: UInt32
			let matchedWindowIDs: [UInt32]
			let dimmedWindowIDs: [UInt32]

			var reportDictionary: [String: Any] {
			[
			"phase": WindowShortcutFilterPhase.targetPreCommit.rawValue,
			"targetCode": targetCode,
			"targetWindowID": Int(targetWindowID),
			"matchedWindowIDs": matchedWindowIDs.map(Int.init),
			"dimmedWindowIDs": dimmedWindowIDs.map(Int.init)
			]
			}
			}

			private struct WindowShortcutFilterReport {
			let active: Bool
			let phase: WindowShortcutFilterPhase
			let pendingAppGroupIndex: Int?
			let prefix: String?
			let matchedWindowIDs: [UInt32]
			let dimmedWindowIDs: [UInt32]
			}

			private struct ProjectionLayerSnapshot {
			let layer: CALayer
			let frame: CGRect
			}

			private struct ProjectionColumnSnapshot {
			let layer: CALayer
			let frame: CGRect
			let cardsByWindowID: [UInt32: ProjectionLayerSnapshot]
			}

			private struct ProjectionTransitionSnapshot {
			let appShelfItemsByAppGroupIndex: [Int: ProjectionLayerSnapshot]
			let waterfallColumnsByAppGroupIndex: [Int: ProjectionColumnSnapshot]
			}

			private enum AppShelfMetrics {
			@@ -119,6 +413,31 @@
			static let normalGap: CGFloat = 16
			static let minGap: CGFloat = 8
			static let maxRows = 2
			static let indexFontSize: CGFloat = 16
			static let compressedIndexFontSize: CGFloat = 14
			static let indexWidth: CGFloat = 18
			static let indexHeight: CGFloat = 24
			static let magneticFirstNeighborInfluence: CGFloat = 0
			static let magneticSecondNeighborInfluence: CGFloat = 0
			static let magneticHoverLift: CGFloat = 4
			static let magneticFirstNeighborLift: CGFloat = 0
			static let magneticSecondNeighborLift: CGFloat = 0
			static let magneticAnimationDuration: CFTimeInterval = 0.16
			static let magneticAnimationTimingName = CAMediaTimingFunctionName.easeOut
			static let closeButtonHitOutset: CGFloat = 0
			}

			private struct AppShelfMagneticState {
			let influence: CGFloat
			let lift: CGFloat

			var isActive: Bool {
			influence > 0
			}

			var isNeighbor: Bool {
			influence > 0 && influence < 1
			}
			}

			private enum RootLayoutMetrics {
			@@ -129,16 +448,162 @@
			static let bottomMargin: CGFloat = 34
			}

			private enum ViewModeToggleMetrics {
			static let hitSize: CGFloat = 34
			static let visualSize: CGFloat = 30
			static let cornerRadius: CGFloat = 9
			static let iconInset: CGFloat = 7
			static let glyphLineWidth: CGFloat = 1.65
			static let glyphCornerRadius: CGFloat = 2.1
			static let selectedShadowRadius: CGFloat = 10
			static let idleShadowRadius: CGFloat = 5
			}

			private enum ViewModeToggleVisualState: String {
			case horizontalAvailable = "H1"
			case horizontalSelected = "H2"
			case verticalAvailable = "Z1"
			case verticalSelected = "Z2"
			}

			private enum ThemeToggleMetrics {
			static let buttonGap: CGFloat = 10
			}

			private enum QuickSwitchResolvedTheme: String {
			case light
			case dark
			}

			private struct QuickSwitchThemePalette {
			let resolvedTheme: QuickSwitchResolvedTheme
			let backgroundGradientColors: [NSColor]
			let safeAreaFill: NSColor
			let displayGroupBackground: NSColor
			let spaceLanePrimaryText: NSColor
			let spaceLaneSecondaryText: NSColor
			let columnBackground: NSColor
			let columnBorder: NSColor
			let columnHeaderBackground: NSColor
			let columnHeaderHoverBackground: NSColor
			let columnHeaderSpaceFocusedBackground: NSColor
			let columnText: NSColor
			let columnSecondaryText: NSColor
			let cardBackground: NSColor
			let cardSelectedBackground: NSColor
			let cardText: NSColor
			let cardSecondaryText: NSColor
			let appShelfLabelText: NSColor
			let appShelfIndexText: NSColor
			let appShelfIndexHighlightedText: NSColor
			let appShelfBackgroundSelected: NSColor
			let appShelfBackgroundHovered: NSColor
			let appShelfBackgroundSpaceFocused: NSColor
			let closeFeedbackBackground: NSColor
			let closeFeedbackBorder: NSColor
			let closeFeedbackText: NSColor
			let shinePeak: NSColor

			static func palette(for theme: QuickSwitchResolvedTheme) -> QuickSwitchThemePalette {
			switch theme {
			case .light:
			return QuickSwitchThemePalette(
			resolvedTheme: .light,
			backgroundGradientColors: [
			NSColor.windowBackgroundColor.withAlphaComponent(0.58),
			NSColor.controlBackgroundColor.withAlphaComponent(0.48)
			],
			safeAreaFill: .black,
			displayGroupBackground: NSColor.windowBackgroundColor,
			spaceLanePrimaryText: .labelColor,
			spaceLaneSecondaryText: .secondaryLabelColor,
			columnBackground: NSColor.controlBackgroundColor.withAlphaComponent(0.56),
			columnBorder: NSColor.separatorColor.withAlphaComponent(0.24),
			columnHeaderBackground: NSColor.controlBackgroundColor.withAlphaComponent(0.52),
			columnHeaderHoverBackground: NSColor.systemGray.withAlphaComponent(0.22),
			columnHeaderSpaceFocusedBackground: NSColor.systemFill.withAlphaComponent(0.10),
			columnText: .labelColor,
			columnSecondaryText: .secondaryLabelColor,
			cardBackground: NSColor.windowBackgroundColor.withAlphaComponent(0.82),
			cardSelectedBackground: NSColor.windowBackgroundColor.withAlphaComponent(0.94),
			cardText: .labelColor,
			cardSecondaryText: .secondaryLabelColor,
			appShelfLabelText: .secondaryLabelColor,
			appShelfIndexText: NSColor.labelColor.withAlphaComponent(0.48),
			appShelfIndexHighlightedText: NSColor.labelColor.withAlphaComponent(0.58),
			appShelfBackgroundSelected: NSColor.controlAccentColor.withAlphaComponent(0.14),
			appShelfBackgroundHovered: NSColor.controlAccentColor.withAlphaComponent(0.13),
			appShelfBackgroundSpaceFocused: NSColor.controlAccentColor.withAlphaComponent(0.14),
			closeFeedbackBackground: NSColor.windowBackgroundColor.withAlphaComponent(0.94),
			closeFeedbackBorder: NSColor.separatorColor.withAlphaComponent(0.28),
			closeFeedbackText: NSColor.secondaryLabelColor.withAlphaComponent(0.96),
			shinePeak: NSColor.white.withAlphaComponent(0.16)
			)
			case .dark:
			return QuickSwitchThemePalette(
			resolvedTheme: .dark,
			backgroundGradientColors: [
			NSColor(calibratedRed: 5 / 255, green: 8 / 255, blue: 20 / 255, alpha: 1),
			NSColor(calibratedRed: 15 / 255, green: 24 / 255, blue: 54 / 255, alpha: 1),
			NSColor(calibratedRed: 3 / 255, green: 42 / 255, blue: 52 / 255, alpha: 1),
			NSColor(calibratedRed: 2 / 255, green: 6 / 255, blue: 13 / 255, alpha: 1)
			],
			safeAreaFill: .black,
			displayGroupBackground: NSColor(calibratedRed: 14 / 255, green: 24 / 255, blue: 39 / 255, alpha: 0.72),
			spaceLanePrimaryText: NSColor.white.withAlphaComponent(0.88),
			spaceLaneSecondaryText: NSColor.white.withAlphaComponent(0.56),
			columnBackground: NSColor(calibratedRed: 92 / 255, green: 97 / 255, blue: 111 / 255, alpha: 0.72),
			columnBorder: NSColor.white.withAlphaComponent(0.20),
			columnHeaderBackground: NSColor(calibratedRed: 104 / 255, green: 111 / 255, blue: 126 / 255, alpha: 0.70),
			columnHeaderHoverBackground: NSColor(calibratedRed: 185 / 255, green: 190 / 255, blue: 205 / 255, alpha: 0.32),
			columnHeaderSpaceFocusedBackground: NSColor(calibratedRed: 92 / 255, green: 171 / 255, blue: 255 / 255, alpha: 0.16),
			columnText: NSColor.black.withAlphaComponent(0.82),
			columnSecondaryText: NSColor.black.withAlphaComponent(0.46),
			cardBackground: NSColor.white.withAlphaComponent(0.90),
			cardSelectedBackground: NSColor.white.withAlphaComponent(0.96),
			cardText: NSColor.black.withAlphaComponent(0.86),
			cardSecondaryText: NSColor.black.withAlphaComponent(0.52),
			appShelfLabelText: NSColor.white.withAlphaComponent(0.66),
			appShelfIndexText: NSColor.white.withAlphaComponent(0.40),
			appShelfIndexHighlightedText: NSColor.white.withAlphaComponent(0.58),
			appShelfBackgroundSelected: NSColor(calibratedRed: 92 / 255, green: 171 / 255, blue: 255 / 255, alpha: 0.22),
			appShelfBackgroundHovered: NSColor(calibratedRed: 92 / 255, green: 171 / 255, blue: 255 / 255, alpha: 0.18),
			appShelfBackgroundSpaceFocused: NSColor(calibratedRed: 92 / 255, green: 171 / 255, blue: 255 / 255, alpha: 0.20),
			closeFeedbackBackground: NSColor(calibratedRed: 36 / 255, green: 43 / 255, blue: 58 / 255, alpha: 0.96),
			closeFeedbackBorder: NSColor.white.withAlphaComponent(0.18),
			closeFeedbackText: NSColor.white.withAlphaComponent(0.76),
			shinePeak: NSColor.white.withAlphaComponent(0.10)
			)
			}
			}
			}

			private enum WaterfallMetrics {
			static let gap: CGFloat = 16
			static let columnWidth: CGFloat = 252
			static let columnMinWidth: CGFloat = 220
			static let columnMaxWidth: CGFloat = 292
			static let columnPadding: CGFloat = 12
			static let contentHorizontalPadding: CGFloat = 0
			static let columnHorizontalPadding: CGFloat = 0
			static let columnVerticalPadding: CGFloat = 0
			static let columnHeaderTextInset: CGFloat = 12
			static let headerHeight: CGFloat = 34
			static let cardHeight: CGFloat = 118
			static let cardHeight: CGFloat = 138
			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 {
			static let horizontalPadding: CGFloat = 12
			static let verticalPadding: CGFloat = 0
			static let horizontalGap: CGFloat = 16
			static let verticalGap: CGFloat = WaterfallMetrics.cardGap
			static let cardMinWidth: CGFloat = 220
			static let cardMaxWidth: CGFloat = 320
			static let cardHeight: CGFloat = WaterfallMetrics.cardHeight
			}

			private enum WaterfallHorizontalIntent {
			@@ -150,6 +615,16 @@
			static let tolerance: CGFloat = 1
			static let animationDuration: CFTimeInterval = 0.18
			static let animationTimingName = CAMediaTimingFunctionName.easeOut
			}

			private enum SpaceLaneMetrics {
			static let horizontalPadding: CGFloat = 0
			static let groupGap: CGFloat = 36
			static let groupHorizontalPadding: CGFloat = 24
			static let groupVerticalPadding: CGFloat = 6
			static let segmentGap: CGFloat = 12
			static let segmentMinWidth: CGFloat = 96
			static let segmentMaxWidth: CGFloat = 150
			}

			override init(frame frameRect: NSRect) {
			@@ -181,7 +656,7 @@

			let trackingArea = NSTrackingArea(
			rect: bounds,
			options: [.activeInKeyWindow, .mouseMoved, .mouseEnteredAndExited, .inVisibleRect],
			options: [.activeAlways, .mouseMoved, .mouseEnteredAndExited, .inVisibleRect],
			owner: self,
			userInfo: nil
			)
			@@ -197,6 +672,13 @@
			}

			override func keyDown(with event: NSEvent) {
			if suppressEventInput {
			DevelopmentDiagnostics.log("quickSwitch.view.keyDown.ignoredForDebugSequence", [
			"keyCode": event.keyCode
			])
			return
			}

			switch event.keyCode {
			case TriggerKeyCode.escape where Self.shouldDismissOnEscape(event):
			onEscape?()
			@@ -213,11 +695,17 @@
			case TriggerKeyCode.tab:
			performKeyboardCommand("tab")
			default:
			if handleAppShelfIndexKey(event) {
			return
			}
			super.keyDown(with: event)
			}
			}

			override func scrollWheel(with event: NSEvent) {
			clearWindowIndexKeyPending()
			refreshHoverTarget(at: event.locationInWindow)

			let dominantDelta = abs(event.scrollingDeltaX) >= abs(event.scrollingDeltaY)
			? event.scrollingDeltaX
			: event.scrollingDeltaY
			@@ -237,6 +725,15 @@
			}

			if shouldScrollWaterfall(for: event) {
			if isHorizontalMasonryMode {
			let currentOffset = horizontalMasonryScrollOffset
			horizontalMasonryScrollOffset = clampedHorizontalMasonryOffset(
			currentOffset - event.scrollingDeltaY
			)
			needsLayout = true
			return
			}

			if abs(event.scrollingDeltaX) >= abs(event.scrollingDeltaY), waterfallAlignmentScrollable {
			waterfallScrollOffset = clampedWaterfallAlignmentOffset(waterfallScrollOffset - event.scrollingDeltaX)
			needsLayout = true
			@@ -262,73 +759,137 @@

			override func mouseMoved(with event: NSEvent) {
			guard debugHoveredAppGroupIndex == nil else { return }
			lastKnownMouseWindowLocation = event.locationInWindow
			clearWindowIndexKeyPending()

			if let segment = spaceLaneSegment(at: event.locationInWindow) {
			hoverSpaceLaneSegment(segment)
			let toggleHovered = viewModeToggleButtonContains(windowLocation: event.locationInWindow)
			let themeHovered = themeToggleButtonContains(windowLocation: event.locationInWindow)
			if !toggleHovered {
			suppressViewModeToggleHoverPreview = false
			}
			if !themeHovered {
			suppressThemeToggleHoverPreview = false
			}
			let shouldShowToggleHoverPreview = toggleHovered && !suppressViewModeToggleHoverPreview
			if isViewModeToggleButtonHovered != shouldShowToggleHoverPreview {
			isViewModeToggleButtonHovered = shouldShowToggleHoverPreview
			needsLayout = true
			}
			let shouldShowThemeHoverPreview = themeHovered && !suppressThemeToggleHoverPreview
			if isThemeToggleButtonHovered != shouldShowThemeHoverPreview {
			isThemeToggleButtonHovered = shouldShowThemeHoverPreview
			needsLayout = true
			}
			if toggleHovered \|\| themeHovered {
			hoveredCloseTarget = nil
			setHoverTarget(.none)
			return
			}

			if let card = waterfallCard(at: event.locationInWindow) {
			hoveredSpaceLaneID = nil
			updateHoverState(
			appGroupIndex: card.item.appGroupIndex,
			windowID: card.item.window.id,
			spaceID: card.item.primarySpaceID
			)
			return
			let closeTarget = closeButtonTarget(at: event.locationInWindow)
			if hoveredCloseTarget != closeTarget {
			hoveredCloseTarget = closeTarget
			needsLayout = true
			}

			if let item = appShelfItem(at: event.locationInWindow) {
			hoveredSpaceLaneID = nil
			updateHoverState(
			appGroupIndex: item.item.appGroupIndex,
			windowID: nil,
			spaceID: nil,
			alignsWaterfallWithAppShelf: true
			)
			return
			}

			hoveredSpaceLaneID = nil
			updateHoverState(appGroupIndex: nil, windowID: nil, spaceID: nil)
			refreshHoverTarget(at: event.locationInWindow)
			}

			override func mouseExited(with event: NSEvent) {
			guard debugHoveredAppGroupIndex == nil else { return }
			hoveredSpaceLaneID = nil
			updateHoverState(appGroupIndex: nil, windowID: nil, spaceID: nil)
			lastKnownMouseWindowLocation = nil
			clearWindowIndexKeyPending()
			isViewModeToggleButtonHovered = false
			suppressViewModeToggleHoverPreview = false
			isThemeToggleButtonHovered = false
			suppressThemeToggleHoverPreview = false
			hoveredCloseTarget = nil
			setHoverTarget(.none)
			}

			override func mouseDown(with event: NSEvent) {
			if let card = waterfallCard(at: event.locationInWindow) {
			if suppressEventInput {
			DevelopmentDiagnostics.log("quickSwitch.view.mouseDown.ignoredForDebugSequence", [
			"x": event.locationInWindow.x,
			"y": event.locationInWindow.y,
			"bounds": NSStringFromRect(bounds)
			])
			return
			}

			if handleMouseDown(at: event.locationInWindow, clickCount: max(1, event.clickCount), allowBackgroundClick: true) {
			return
			}

			super.mouseDown(with: event)
			}

			@discardableResult
			private func handleMouseDown(at windowLocation: CGPoint, clickCount: Int, allowBackgroundClick: Bool) -> Bool {
			clearWindowIndexKeyPending()

			if handleCloseConfirmationMouseDown(at: windowLocation) {
			return true
			}

			if viewModeToggleButtonContains(windowLocation: windowLocation) {
			clickViewModeToggleButton(source: "mouse")
			return true
			}

			if themeToggleButtonContains(windowLocation: windowLocation) {
			clickThemeToggleButton(source: "mouse")
			return true
			}

			if let closeTarget = waterfallCloseButtonTarget(at: windowLocation) {
			beginCloseConfirmation(for: closeTarget)
			return true
			}

			if let card = waterfallCard(at: windowLocation) {
			clickWindowCard(card)
			return
			return true
			}

			if let segment = spaceLaneSegment(at: event.locationInWindow) {
			clickSpaceLaneSegment(segment)
			return
			if let segment = spaceLaneSegment(at: windowLocation) {
			clickSpaceLaneSegment(segment, clickCount: max(1, clickCount))
			return true
			}

			if let item = appShelfItem(at: event.locationInWindow) {
			if let item = appShelfIconItem(at: windowLocation) {
			if let closeTarget = appShelfCloseButtonTarget(at: windowLocation) {
			beginCloseConfirmation(for: closeTarget)
			} else {
			clickAppShelfItem(item)
			}
			return true
			}

			if let closeTarget = closeButtonTarget(at: windowLocation) {
			beginCloseConfirmation(for: closeTarget)
			return true
			}

			if let item = appShelfItem(at: windowLocation) {
			clickAppShelfItem(item)
			return
			return true
			}

			DevelopmentDiagnostics.log("quickSwitch.view.mouseDown.miss", [
			"x": event.locationInWindow.x,
			"y": event.locationInWindow.y,
			"x": windowLocation.x,
			"y": windowLocation.y,
			"bounds": NSStringFromRect(bounds)
			])
			super.mouseDown(with: event)
			if allowBackgroundClick, !suppressEventBackgroundClicks, onBackgroundClick?() == true {
			return true
			}
			return false
			}

			func setDebugHoveredAppGroupIndex(_ index: Int?) {
			debugHoveredAppGroupIndex = index
			setHoverTarget(.none, source: .debug)
			hoveredAppGroupIndex = index
			hoveredWindowID = nil
			hoveredSpaceID = nil
			hoveredSpaceLaneID = nil
			needsLayout = true
			}

			@@ -338,11 +899,49 @@
			layoutSubtreeIfNeeded()
			for command in commands {
			let measurementStart = CACurrentMediaTime()
			performKeyboardCommand(command)
			if !performDebugPhysicalIndexKeyCommand(command) {
			performKeyboardCommand(command)
			}
			layoutSubtreeIfNeeded()
			CATransaction.flush()
			keyboardResponseLatencyMilliseconds.append(milliseconds(since: measurementStart))
			}
			}

			private func performDebugPhysicalIndexKeyCommand(_ rawCommand: String) -> Bool {
			let command = rawCommand.trimmingCharacters(in: .whitespacesAndNewlines)
			let uppercased = command.uppercased()
			let prefixes = ["PHYSICAL-INDEX:", "PHYSICAL-INDEX-", "KEYDOWN:", "KEYDOWN-"]
			guard let prefix = prefixes.first(where: { uppercased.hasPrefix($0) }) else {
			return false
			}

			let symbolStart = command.index(command.startIndex, offsetBy: prefix.count)
			guard let symbol = appShelfIndexSymbol(fromKeyboardCommand: String(command[symbolStart...])),
			let keyCode = Self.appShelfIndexKeyCodes[symbol],
			let event = NSEvent.keyEvent(
			with: .keyDown,
			location: .zero,
			modifierFlags: [.option],
			timestamp: ProcessInfo.processInfo.systemUptime,
			windowNumber: window?.windowNumber ?? 0,
			context: nil,
			characters: symbol.lowercased(),
			charactersIgnoringModifiers: symbol.lowercased(),
			isARepeat: false,
			keyCode: keyCode
			)
			else {
			recordKeyboardCommand("invalidPhysicalIndex:\(command)")
			selectionChangedByLastCommand = false
			return true
			}

			let previousSuppressEventInput = suppressEventInput
			suppressEventInput = false
			keyDown(with: event)
			suppressEventInput = previousSuppressEventInput
			return true
			}

			func performDebugMouseCommands(_ commands: [String]) {
			@@ -359,7 +958,19 @@
			if isHoverCommand(command) {
			hoverResponseLatencyMilliseconds.append(elapsed)
			}
			if lastCommitSource == .mouse {
			break
			}
			}
			}

			func setSuppressEventBackgroundClicks(_ suppressed: Bool) {
			suppressEventBackgroundClicks = suppressed
			}

			func setSuppressEventInput(_ suppressed: Bool) {
			suppressEventInput = suppressed
			suppressEventBackgroundClicks = suppressed
			}

			func beginPerformanceFirstFrameMeasurement() {
			@@ -383,6 +994,74 @@
			hoverResponseLatencyMilliseconds = []
			}

			func setCloseConfirmationRequired(_ required: Bool) {
			closeConfirmationRequired = required
			if !required {
			pendingCloseTarget = nil
			pendingCloseRequest = nil
			pendingCloseOptOut = false
			closeConfirmationLayers.containerLayer.isHidden = true
			closeConfirmationArrowEdge = nil
			}
			needsLayout = true
			}

			func setWaterfallViewMode(_ mode: QuickSwitchWaterfallViewMode) {
			guard waterfallViewMode != mode else { return }

			waterfallViewMode = mode
			waterfallScrollOffset = 0
			waterfallColumnScrollOffsets = [:]
			horizontalMasonryScrollOffset = 0
			horizontalMasonryContentHeight = 0
			needsLayout = true
			}

			func setTheme(_ theme: ThemePreference) {
			let normalizedTheme = Self.normalizedQuickSwitchTheme(theme)
			guard themePreference != normalizedTheme else { return }

			themePreference = normalizedTheme
			applyThemeToBackdrop()
			needsLayout = true
			}

			func showCloseProgress(for request: QuickSwitchCloseRequest) {
			setCloseFeedback(
			CloseFeedback(
			kind: .progress,
			message: "正在关闭...",
			targetKind: request.kindDescription,
			appGroupIndex: request.appGroupIndex,
			windowID: request.windowID
			),
			autoHideAfter: nil
			)
			}

			func showCloseFailure(message: String, for request: QuickSwitchCloseRequest) {
			setCloseFeedback(
			CloseFeedback(
			kind: .failure,
			message: message,
			targetKind: request.kindDescription,
			appGroupIndex: request.appGroupIndex,
			windowID: request.windowID
			),
			autoHideAfter: 2.75
			)
			}

			func clearCloseFeedback() {
			closeFeedbackHideTask?.cancel()
			closeFeedbackHideTask = nil
			closeFeedback = nil
			closeFeedbackLayer.isHidden = true
			closeFeedbackLayer.opacity = 0
			closeFeedbackTextLayer.string = ""
			needsLayout = true
			}

			func applyScreenshot(_ resolution: ScreenshotResolution, for windowID: UInt32) {
			screenshotSkippedReasonsByWindowID[windowID] = nil
			screenshotSourcesByWindowID[windowID] = resolution.source
			@@ -390,7 +1069,10 @@
			guard let card = waterfallCardsByWindowID()[windowID] else { return }
			card.thumbnailLayer.contents = resolution.image
			if case .realScreenshot = resolution.source {
			card.shineLayer.opacity = card.item.window.id == effectiveSelection?.windowID ? 1 : 0
			let isSelected = card.item.window.id == effectiveSelection?.windowID
			let isHovered = card.item.window.id == hoveredWindowID
			let isKeyboardFocused = card.item.window.id == keyboardFocusedWindowID
			card.shineLayer.opacity = (shouldShowSelectedVisual(isSelected: isSelected, isHovered: isHovered) \|\| isKeyboardFocused) ? 1 : 0
			}
			needsLayout = true
			}
			@@ -407,43 +1089,405 @@
			}
			}

			func effectiveSelectionForProjection() -> QuickSwitchSelection? {
			effectiveSelection
			}

			func apply(viewModel: QuickSwitchViewModel?) {
			apply(viewModel: viewModel, preservingInteractionState: false, animatedProjection: false)
			}

			func applyProjected(viewModel: QuickSwitchViewModel?) {
			apply(viewModel: viewModel, preservingInteractionState: true, animatedProjection: true)
			}

			func hoverNextAppGroupIndex(cycleForward: Bool = true) -> Bool {
			guard !appShelfItems.isEmpty else {
			return false
			}

			let orderedIndexes = appShelfItems.map(\.item.appGroupIndex)
			let sortedIndexes = orderedIndexes

			var currentIndexPosition: Int?
			if let currentHovered = effectiveHoveredAppGroupIndex {
			currentIndexPosition = sortedIndexes.firstIndex(of: currentHovered)
			}

			let nextPosition = currentIndexPosition.map { current in
			if cycleForward {
			(current + 1) % sortedIndexes.count
			} else {
			(current - 1 + sortedIndexes.count) % sortedIndexes.count
			}
			} ?? 0

			let nextAppGroupIndex = sortedIndexes[nextPosition]
			hoverAppGroup(nextAppGroupIndex)
			return true
			}

			private func apply(
			viewModel: QuickSwitchViewModel?,
			preservingInteractionState: Bool,
			animatedProjection: Bool
			) {
			let preservedWindowThumbnails = preservingInteractionState ? cachedThumbnailsByWindowID() : [:]
			let transitionSnapshot = animatedProjection ? captureProjectionTransitionSnapshot() : nil
			if !animatedProjection {
			resetProjectionTransitionReport()
			}
			currentViewModel = viewModel
			screenshotSourcesByWindowID = [:]
			screenshotSkippedReasonsByWindowID = [:]
			currentSelection = viewModel?.initialSelection
			columnSelectionHistory = [:]
			keyboardCommandsApplied = []
			lastKeyboardCommand = nil
			tabIgnoredCount = 0
			lastCommittedSelection = nil
			lastCommitSource = nil
			mouseCommandsApplied = []
			lastMouseCommand = nil
			lastClickedAppGroupIndex = nil
			lastAppShelfClickChangedSelection = nil
			lastClickedWindowID = nil
			lastSpaceFocusedAppGroupIndex = nil
			lastSpaceLaneClickSpaceID = nil
			lastAppShelfScrollSyncedAppGroupIndex = nil
			hoveredWindowID = nil
			hoveredSpaceID = nil
			hoveredSpaceLaneID = nil
			focusedSpaceID = nil
			if debugHoveredAppGroupIndex == nil {
			hoveredAppGroupIndex = nil

			if preservingInteractionState {
			currentSelection = validSelection(currentSelection, in: viewModel) ?? viewModel?.initialSelection
			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
			}
			hoveredCloseTarget = nil
			pendingCloseTarget = nil
			pendingCloseRequest = nil
			pendingCloseOptOut = false
			closeConfirmationLayers.containerLayer.isHidden = true
			closeConfirmationArrowEdge = nil
			} else {
			screenshotSourcesByWindowID = [:]
			screenshotSkippedReasonsByWindowID = [:]
			currentSelection = viewModel?.initialSelection
			columnSelectionHistory = [:]
			keyboardFocusedAppGroupIndex = nil
			keyboardFocusedWindowID = nil
			keyboardCommandsApplied = []
			lastKeyboardCommand = nil
			lastKeyboardAppIndexCommand = nil
			appShelfIndexKeyDownCount = 0
			lastAppShelfIndexKeySymbol = nil
			clearWindowIndexKeyPending()
			lastWindowIndexKeyCommand = nil
			lastWindowIndexKeyCommitCode = nil
			windowShortcutFilterPhase = .none
			lastWindowShortcutPreCommitFilterSnapshot = nil
			lastBoundaryBounceAxis = nil
			lastBoundaryBounceDirection = nil
			boundaryBounceCount = 0
			selectionChangedByLastCommand = nil
			tabIgnoredCount = 0
			lastCommittedSelection = nil
			lastCommitSource = nil
			mouseCommandsApplied = []
			lastMouseCommand = nil
			lastClickedAppGroupIndex = nil
			lastAppShelfClickChangedSelection = nil
			lastClickedWindowID = nil
			lastSpaceFocusedAppGroupIndex = nil
			lastSpaceLaneClickSpaceID = nil
			lastAppShelfScrollSyncedAppGroupIndex = nil
			waterfallScrollOffset = 0
			waterfallColumnScrollOffsets = [:]
			horizontalMasonryScrollOffset = 0
			horizontalMasonryContentHeight = 0
			focusedSpaceID = nil
			hoveredCloseTarget = nil
			pendingCloseTarget = nil
			pendingCloseRequest = nil
			pendingCloseOptOut = false
			closeConfirmationLayers.containerLayer.isHidden = true
			closeConfirmationArrowEdge = nil
			clearCloseFeedback()
			setHoverTarget(.none)
			hoveredAppGroupIndex = debugHoveredAppGroupIndex
			}

			if let currentSelection {
			columnSelectionHistory[currentSelection.appGroupIndex] = currentSelection.windowIndex
			}
			rebuildSpaceLaneSegments()
			rebuildAppShelfItems()
			rebuildWaterfallColumns()

			if preservingInteractionState {
			restoreThumbnailsFromCache(preservedWindowThumbnails)
			}

			needsLayout = true
			ensureCurrentSelectionVisible(horizontalIntent: .alignWithAppShelf(animated: false))
			refreshHoverTargetAfterViewRebuild()
			needsLayout = true
			if animatedProjection, let transitionSnapshot {
			layoutSubtreeIfNeeded()
			applyProjectionTransitionAnimations(from: transitionSnapshot)
			}
			}

			private func cachedThumbnailsByWindowID() -> [UInt32: Any] {
			var snapshots: [UInt32: Any] = [:]

			for card in waterfallCardsByWindowID().values {
			snapshots[card.item.window.id] = card.thumbnailLayer.contents
			}

			return snapshots
			}

			private func restoreThumbnailsFromCache(_ cachedThumbnails: [UInt32: Any]) {
			for card in waterfallCardsByWindowID().values {
			if let thumbnail = cachedThumbnails[card.item.window.id] {
			card.thumbnailLayer.contents = thumbnail
			}
			}
			}

			private func validSelection(
			_ selection: QuickSwitchSelection?,
			in viewModel: QuickSwitchViewModel?
			) -> QuickSwitchSelection? {
			guard let selection, let viewModel else { return nil }

			for column in viewModel.waterfallColumns {
			if let card = column.windows.first(where: { $0.window.id == selection.windowID }) {
			return QuickSwitchSelection(
			appGroupIndex: card.appGroupIndex,
			windowIndex: card.windowIndex,
			windowID: card.window.id
			)
			}
			}

			return nil
			}

			private func captureProjectionTransitionSnapshot() -> ProjectionTransitionSnapshot {
			ProjectionTransitionSnapshot(
			appShelfItemsByAppGroupIndex: Dictionary(
			uniqueKeysWithValues: appShelfItems.map { item in
			(
			item.item.appGroupIndex,
			ProjectionLayerSnapshot(
			layer: item.containerLayer,
			frame: item.containerLayer.frame
			)
			)
			}
			),
			waterfallColumnsByAppGroupIndex: Dictionary(
			uniqueKeysWithValues: waterfallColumns.map { column in
			(
			column.column.appGroupIndex,
			ProjectionColumnSnapshot(
			layer: column.containerLayer,
			frame: column.containerLayer.frame,
			cardsByWindowID: Dictionary(
			uniqueKeysWithValues: column.cards.map { card in
			(
			card.item.window.id,
			ProjectionLayerSnapshot(
			layer: card.containerLayer,
			frame: card.containerLayer.frame
			)
			)
			}
			)
			)
			)
			}
			)
			)
			}

			private func applyProjectionTransitionAnimations(from snapshot: ProjectionTransitionSnapshot) {
			let reduceMotion = NSWorkspace.shared.accessibilityDisplayShouldReduceMotion
			let duration: CFTimeInterval = reduceMotion ? 0.12 : 0.21
			let timing = CAMediaTimingFunction(name: reduceMotion ? .linear : .easeOut)
			var movedLayerCount = 0
			var fadeInLayerCount = 0
			var fadeOutLayerCount = 0

			for item in appShelfItems {
			guard let oldSnapshot = snapshot.appShelfItemsByAppGroupIndex[item.item.appGroupIndex] else {
			if addFadeInAnimation(to: item.containerLayer, duration: duration, timing: timing) {
			fadeInLayerCount += 1
			}
			continue
			}
			if addPositionAnimation(to: item.containerLayer, from: oldSnapshot.frame, duration: duration, timing: timing) {
			movedLayerCount += 1
			}
			}

			let visibleAppGroupIndexes = Set(appShelfItems.map(\.item.appGroupIndex))
			for (appGroupIndex, oldSnapshot) in snapshot.appShelfItemsByAppGroupIndex
			where !visibleAppGroupIndexes.contains(appGroupIndex) {
			if addFadeOutSnapshot(
			oldSnapshot,
			to: appShelfContentLayer,
			frame: oldSnapshot.frame,
			duration: duration,
			timing: timing
			) {
			fadeOutLayerCount += 1
			}
			}

			for column in waterfallColumns {
			guard let oldSnapshot = snapshot.waterfallColumnsByAppGroupIndex[column.column.appGroupIndex] else {
			if addFadeInAnimation(to: column.containerLayer, duration: duration, timing: timing) {
			fadeInLayerCount += 1
			}
			continue
			}
			if addPositionAnimation(to: column.containerLayer, from: oldSnapshot.frame, duration: duration, timing: timing) {
			movedLayerCount += 1
			}

			for card in column.cards {
			guard let oldCardSnapshot = oldSnapshot.cardsByWindowID[card.item.window.id] else {
			if addFadeInAnimation(to: card.containerLayer, duration: duration, timing: timing) {
			fadeInLayerCount += 1
			}
			continue
			}
			if addPositionAnimation(to: card.containerLayer, from: oldCardSnapshot.frame, duration: duration, timing: timing) {
			movedLayerCount += 1
			}
			}
			}

			let visibleColumnsByAppGroupIndex = Dictionary(
			uniqueKeysWithValues: waterfallColumns.map { ($0.column.appGroupIndex, $0) }
			)
			for (appGroupIndex, oldSnapshot) in snapshot.waterfallColumnsByAppGroupIndex {
			guard let visibleColumn = visibleColumnsByAppGroupIndex[appGroupIndex] else {
			if addFadeOutSnapshot(
			ProjectionLayerSnapshot(layer: oldSnapshot.layer, frame: oldSnapshot.frame),
			to: waterfallContentLayer,
			frame: oldSnapshot.frame,
			duration: duration,
			timing: timing
			) {
			fadeOutLayerCount += 1
			}
			continue
			}

			let visibleWindowIDs = Set(visibleColumn.cards.map(\.item.window.id))
			for (windowID, oldCardSnapshot) in oldSnapshot.cardsByWindowID
			where !visibleWindowIDs.contains(windowID) {
			let absoluteFrame = oldCardSnapshot.frame.offsetBy(
			dx: oldSnapshot.frame.minX,
			dy: oldSnapshot.frame.minY
			)
			if addFadeOutSnapshot(
			oldCardSnapshot,
			to: waterfallContentLayer,
			frame: absoluteFrame,
			duration: duration,
			timing: timing
			) {
			fadeOutLayerCount += 1
			}
			}
			}

			lastProjectionTransitionMovedLayerCount = movedLayerCount
			lastProjectionTransitionFadeInLayerCount = fadeInLayerCount
			lastProjectionTransitionFadeOutLayerCount = fadeOutLayerCount
			lastProjectionTransitionDurationMilliseconds = duration * 1_000
			}

			private func resetProjectionTransitionReport() {
			lastProjectionTransitionMovedLayerCount = 0
			lastProjectionTransitionFadeInLayerCount = 0
			lastProjectionTransitionFadeOutLayerCount = 0
			lastProjectionTransitionDurationMilliseconds = 0
			}

			@discardableResult
			private func addPositionAnimation(
			to layer: CALayer,
			from oldFrame: CGRect,
			duration: CFTimeInterval,
			timing: CAMediaTimingFunction
			) -> Bool {
			let oldPosition = CGPoint(x: oldFrame.midX, y: oldFrame.midY)
			let newPosition = layer.position
			guard abs(oldPosition.x - newPosition.x) > 0.5 \|\| abs(oldPosition.y - newPosition.y) > 0.5 else {
			return false
			}

			let animation = CABasicAnimation(keyPath: "position")
			animation.fromValue = oldPosition
			animation.toValue = newPosition
			animation.duration = duration
			animation.timingFunction = timing
			animation.isRemovedOnCompletion = true
			layer.add(animation, forKey: "quickSwitchProjectionPosition")
			return true
			}

			@discardableResult
			private func addFadeInAnimation(
			to layer: CALayer,
			duration: CFTimeInterval,
			timing: CAMediaTimingFunction
			) -> Bool {
			let animation = CABasicAnimation(keyPath: "opacity")
			animation.fromValue = 0
			animation.toValue = layer.opacity
			animation.duration = duration
			animation.timingFunction = timing
			animation.isRemovedOnCompletion = true
			layer.add(animation, forKey: "quickSwitchProjectionFadeIn")
			return true
			}

			@discardableResult
			private func addFadeOutSnapshot(
			_ snapshot: ProjectionLayerSnapshot,
			to parentLayer: CALayer,
			frame: CGRect,
			duration: CFTimeInterval,
			timing: CAMediaTimingFunction
			) -> Bool {
			let layer = snapshot.layer
			layer.removeAllAnimations()
			layer.removeFromSuperlayer()
			CATransaction.begin()
			CATransaction.setDisableActions(true)
			layer.frame = frame
			layer.opacity = max(layer.opacity, 0.01)
			layer.zPosition = max(layer.zPosition, 240)
			parentLayer.addSublayer(layer)
			CATransaction.commit()

			let animation = CABasicAnimation(keyPath: "opacity")
			animation.fromValue = layer.opacity
			animation.toValue = 0
			animation.duration = duration
			animation.timingFunction = timing
			animation.isRemovedOnCompletion = true
			CATransaction.begin()
			CATransaction.setDisableActions(true)
			layer.opacity = 0
			CATransaction.commit()
			layer.add(animation, forKey: "quickSwitchProjectionFadeOut")

			DispatchQueue.main.asyncAfter(deadline: .now() + duration + 0.05) { [weak layer] in
			layer?.removeFromSuperlayer()
			}
			return true
			}

			func reportDictionary() -> [String: Any] {
			@@ -455,6 +1499,7 @@
			let firstFrameGatePassed = firstFrameP95.map { $0 < 150 } ?? false
			let keyboardGatePassed = keyboardP95.map { $0 < 50 } ?? false
			let hoverGatePassed = hoverP95.map { $0 <= 32 } ?? false
			let shortcutFilterReport = makeWindowShortcutFilterReport()

			return [
			"viewClass": String(describing: Self.self),
			@@ -467,17 +1512,56 @@
			"glassBorderWidth": Double(glassLayer.borderWidth),
			"glassShadowOpacity": Double(glassLayer.shadowOpacity),
			"spaceLaneFrame": dictionary(from: laneLayer.frame),
			"spaceLaneBackgroundColor": colorDictionary(from: laneLayer.backgroundColor),
			"spaceLaneCornerRadius": Double(laneLayer.cornerRadius),
			"spaceLaneContentWidth": Double(spaceLaneContentWidth),
			"spaceLaneVisibleWidth": Double(laneLayer.bounds.width),
			"spaceLaneMaxScrollOffset": Double(spaceLaneMaxScrollOffset),
			"spaceLaneScrollable": spaceLaneMaxScrollOffset > 0,
			"spaceLaneDisplayGroupCount": spaceLaneDisplayGroups.count,
			"spaceLaneDisplayGroups": spaceLaneDisplayGroupReports(),
			"spaceLaneSegmentCount": spaceLaneSegments.count,
			"spaceLaneLabels": currentViewModel?.displays.flatMap { $0.spaces.map(\.label) } ?? [],
			"spaceLaneSegments": spaceLaneSegmentReports(),
			"hoverTargetKind": hoverTarget.kindDescription,
			"hoverTargetSource": hoverTargetSource.rawValue,
			"spaceLaneHoveredSpaceID": hoveredSpaceLaneID ?? NSNull(),
			"spaceLaneFocusedSpaceID": focusedSpaceID ?? NSNull(),
			"activeSpaceFocusID": activeSpaceFocusID ?? NSNull(),
			"spaceFilterLockedSpaceID": currentViewModel?.lockedSpaceID ?? NSNull(),
			"spaceFilterActive": currentViewModel?.lockedSpaceID != nil,
			"viewModeToggleButtonVisible": !viewModeToggleButtonLayer.isHidden,
			"viewModeToggleButtonHovered": isViewModeToggleButtonHovered,
			"viewModeToggleHoverPreviewSuppressed": suppressViewModeToggleHoverPreview,
			"viewModeToggleButtonFrame": dictionary(from: viewModeToggleButtonLayer.frame),
			"viewModeToggleHitSize": Double(ViewModeToggleMetrics.hitSize),
			"viewModeToggleVisualSize": Double(ViewModeToggleMetrics.visualSize),
			"viewModeToggleCurrentMode": waterfallViewMode.rawValue,
			"viewModeToggleTargetMode": nextWaterfallViewMode.rawValue,
			"viewModeToggleIconKind": viewModeToggleIconKind,
			"viewModeToggleVisualState": viewModeToggleVisualState.rawValue,
			"viewModeToggleStandardBlueColor": colorDictionary(from: viewModeToggleBlueColor.cgColor),
			"viewModeToggleGlyphLineWidth": Double(ViewModeToggleMetrics.glyphLineWidth),
			"viewModeToggleAccessibilityLabel": viewModeToggleAccessibilityLabel,
			"themeCurrentPreference": themePreference.rawValue,
			"themeResolved": resolvedTheme.rawValue,
			"themeNextPreference": nextThemePreference.rawValue,
			"themeToggleButtonVisible": !themeToggleButtonLayer.isHidden,
			"themeToggleButtonHovered": isThemeToggleButtonHovered,
			"themeToggleHoverPreviewSuppressed": suppressThemeToggleHoverPreview,
			"themeToggleButtonFrame": dictionary(from: themeToggleButtonLayer.frame),
			"themeToggleHitSize": Double(ViewModeToggleMetrics.hitSize),
			"themeToggleVisualSize": Double(ViewModeToggleMetrics.visualSize),
			"themeToggleIconKind": "halfDisk",
			"themeToggleAccessibilityLabel": themeToggleAccessibilityLabel,
			"darkBackdropLayerCount": darkBackdropLayerCount,
			"darkBackdropLayersVisible": darkBackdropLayersVisible,
			"darkBackdropBackgroundGradientColors": backgroundGradientColorReports(),
			"settingsButtonVisible": false,
			"spaceFocusAppGroupIndexes": spaceFocusedAppGroupIndexes(),
			"appHoverAssociatedSpaceIDs": appHoverAssociatedSpaceIDs.sorted(),
			"appHoverAssociatedSpaceLabels": appHoverAssociatedSpaceLabels,
			"windowHoverAssociatedSpaceID": windowHoverAssociatedSpaceID ?? NSNull(),
			"lastSpaceFocusedAppGroupIndex": lastSpaceFocusedAppGroupIndex ?? NSNull(),
			"lastSpaceLaneClickSpaceID": lastSpaceLaneClickSpaceID ?? NSNull(),
			"lastAppShelfScrollSyncedAppGroupIndex": lastAppShelfScrollSyncedAppGroupIndex ?? NSNull(),
			@@ -503,15 +1587,29 @@
			"appShelfHoverIconSize": Double(AppShelfMetrics.hoverIconSize),
			"appShelfSelectedIconSize": Double(AppShelfMetrics.selectedIconSize),
			"appShelfMinIconSize": Double(AppShelfMetrics.minIconSize),
			"appShelfMagneticHoverEnabled": appShelfMagneticHoverEnabled,
			"appShelfMagneticFirstNeighborInfluence": Double(AppShelfMetrics.magneticFirstNeighborInfluence),
			"appShelfMagneticSecondNeighborInfluence": Double(AppShelfMetrics.magneticSecondNeighborInfluence),
			"appShelfMagneticHoverLift": Double(AppShelfMetrics.magneticHoverLift),
			"appShelfMagneticFirstNeighborLift": Double(AppShelfMetrics.magneticFirstNeighborLift),
			"appShelfMagneticSecondNeighborLift": Double(AppShelfMetrics.magneticSecondNeighborLift),
			"appShelfMagneticAnimationDurationMilliseconds": Double(AppShelfMetrics.magneticAnimationDuration * 1_000),
			"appShelfMagneticAnimationTimingName": AppShelfMetrics.magneticAnimationTimingName.rawValue,
			"appShelfItems": appShelfItemReports(),
			"waterfallFrame": dictionary(from: waterfallLayer.frame),
			"waterfallViewMode": waterfallViewMode.rawValue,
			"waterfallContentWidth": Double(waterfallContentWidth),
			"waterfallVisibleWidth": Double(waterfallLayer.bounds.width),
			"waterfallScrollOffset": Double(waterfallScrollOffset),
			"waterfallMaxScrollOffset": Double(waterfallMaxScrollOffset),
			"horizontalMasonryContentHeight": Double(horizontalMasonryContentHeight),
			"horizontalMasonryScrollOffset": Double(horizontalMasonryScrollOffset),
			"horizontalMasonryMaxScrollOffset": Double(horizontalMasonryMaxScrollOffset),
			"horizontalMasonryScrollable": horizontalMasonryMaxScrollOffset > 0,
			"waterfallAlignmentMinScrollOffset": Double(waterfallAlignmentScrollRange.lowerBound),
			"waterfallAlignmentMaxScrollOffset": Double(waterfallAlignmentScrollRange.upperBound),
			"waterfallScrollable": waterfallAlignmentScrollable,
			"waterfallScrollable": waterfallMaxScrollOffset > 0,
			"waterfallAlignmentScrollable": waterfallAlignmentScrollable,
			"waterfallColumnCount": waterfallColumns.count,
			"waterfallColumnNames": waterfallColumns.map(\.column.app.name),
			"waterfallClipsToBounds": waterfallLayer.masksToBounds,
			@@ -520,12 +1618,39 @@
			"waterfallAlignmentTolerance": Double(WaterfallAlignmentMetrics.tolerance),
			"waterfallAlignmentAnimationDurationMilliseconds": Double(WaterfallAlignmentMetrics.animationDuration * 1_000),
			"waterfallAlignmentAnimationTimingName": "easeOut",
			"projectionTransitionMovedLayerCount": lastProjectionTransitionMovedLayerCount,
			"projectionTransitionFadeInLayerCount": lastProjectionTransitionFadeInLayerCount,
			"projectionTransitionFadeOutLayerCount": lastProjectionTransitionFadeOutLayerCount,
			"projectionTransitionDurationMilliseconds": lastProjectionTransitionDurationMilliseconds,
			"reduceMotionEffective": NSWorkspace.shared.accessibilityDisplayShouldReduceMotion,
			"selectedAppGroupIndex": effectiveSelection?.appGroupIndex ?? NSNull(),
			"selectedWindowIndex": effectiveSelection?.windowIndex ?? NSNull(),
			"selectedWindowID": effectiveSelection?.windowID ?? NSNull(),
			"keyboardFocusedAppGroupIndex": keyboardFocusedAppGroupIndex ?? NSNull(),
			"keyboardFocusedWindowID": keyboardFocusedWindowID ?? NSNull(),
			"horizontalAppDefaultWindowID": horizontalAppDefaultWindowID ?? NSNull(),
			"keyboardCommandsApplied": keyboardCommandsApplied,
			"lastKeyboardCommand": lastKeyboardCommand ?? NSNull(),
			"lastKeyboardAppIndexCommand": lastKeyboardAppIndexCommand ?? NSNull(),
			"appShelfIndexKeyDownCount": appShelfIndexKeyDownCount,
			"lastAppShelfIndexKeySymbol": lastAppShelfIndexKeySymbol ?? NSNull(),
			"windowIndexKeyPendingAppGroupIndex": windowIndexKeyPending?.appGroupIndex ?? NSNull(),
			"windowIndexKeyPendingAppSymbol": windowIndexKeyPending?.appSymbol ?? NSNull(),
			"lastWindowIndexKeyCommand": lastWindowIndexKeyCommand ?? NSNull(),
			"lastWindowIndexKeyCommitCode": lastWindowIndexKeyCommitCode ?? NSNull(),
			"windowShortcutFilterActive": shortcutFilterReport.active,
			"windowShortcutFilterPhase": shortcutFilterReport.phase.rawValue,
			"windowShortcutFilterPendingAppGroupIndex": shortcutFilterReport.pendingAppGroupIndex ?? NSNull(),
			"windowShortcutFilterPrefix": shortcutFilterReport.prefix ?? NSNull(),
			"windowShortcutFilterMatchedCount": shortcutFilterReport.matchedWindowIDs.count,
			"windowShortcutFilterDimmedCount": shortcutFilterReport.dimmedWindowIDs.count,
			"windowShortcutFilterMatchedWindowIDs": shortcutFilterReport.matchedWindowIDs.map(Int.init),
			"windowShortcutFilterDimmedWindowIDs": shortcutFilterReport.dimmedWindowIDs.map(Int.init),
			"lastWindowShortcutPreCommitFilterSnapshot": lastWindowShortcutPreCommitFilterSnapshot?.reportDictionary ?? NSNull(),
			"lastBoundaryBounceAxis": lastBoundaryBounceAxis ?? NSNull(),
			"lastBoundaryBounceDirection": lastBoundaryBounceDirection ?? NSNull(),
			"boundaryBounceCount": boundaryBounceCount,
			"selectionChangedByLastCommand": selectionChangedByLastCommand ?? NSNull(),
			"tabIgnoredCount": tabIgnoredCount,
			"lastCommittedAppGroupIndex": lastCommittedSelection?.appGroupIndex ?? NSNull(),
			"lastCommittedWindowIndex": lastCommittedSelection?.windowIndex ?? NSNull(),
			@@ -534,6 +1659,20 @@
			"hoveredAppGroupIndex": effectiveHoveredAppGroupIndex ?? NSNull(),
			"hoveredWindowID": hoveredWindowID ?? NSNull(),
			"hoveredSpaceID": hoveredSpaceID ?? NSNull(),
			"hoveredCloseTargetKind": hoveredCloseTarget?.kindDescription ?? NSNull(),
			"pendingCloseTargetKind": pendingCloseTarget?.kindDescription ?? NSNull(),
			"pendingCloseOptOut": pendingCloseOptOut,
			"closeConfirmationRequired": closeConfirmationRequired,
			"closeConfirmationVisible": !closeConfirmationLayers.containerLayer.isHidden,
			"closeConfirmationFrame": dictionary(from: closeConfirmationLayers.containerLayer.frame),
			"closeConfirmationArrowEdge": closeConfirmationArrowEdge?.rawValue ?? NSNull(),
			"closeFeedbackVisible": closeFeedback != nil && !closeFeedbackLayer.isHidden,
			"closeFeedbackKind": closeFeedback?.kind.rawValue ?? NSNull(),
			"closeFeedbackMessage": closeFeedback?.message ?? NSNull(),
			"closeFeedbackTargetKind": closeFeedback?.targetKind ?? NSNull(),
			"closeFeedbackAppGroupIndex": closeFeedback?.appGroupIndex ?? NSNull(),
			"closeFeedbackWindowID": closeFeedback?.windowID ?? NSNull(),
			"closeFeedbackFrame": dictionary(from: closeFeedbackLayer.frame),
			"mouseCommandsApplied": mouseCommandsApplied,
			"lastMouseCommand": lastMouseCommand ?? NSNull(),
			"lastClickedAppGroupIndex": lastClickedAppGroupIndex ?? NSNull(),
			@@ -584,27 +1723,68 @@
			.lowercased()
			guard !command.isEmpty else { return }

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

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

			@@ -613,11 +1793,407 @@
			keyboardCommandsApplied.append(command)
			}

			private func handleAppShelfIndexKey(_ event: NSEvent) -> Bool {
			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
			}

			appShelfIndexKeyDownCount += 1
			lastAppShelfIndexKeySymbol = symbol
			if flags.contains(.option), handleWindowIndexKey(symbol: symbol) {
			return true
			}
			clearWindowIndexKeyPending()
			performKeyboardCommand(symbol)
			return true
			}

			private func handleWindowIndexKey(symbol: String) -> Bool {
			let now = CACurrentMediaTime()
			if let pending = validWindowIndexKeyPending(now: now) {
			let code = "\(pending.appSymbol)\(symbol)"
			if let card = waterfallCard(appGroupIndex: pending.appGroupIndex, windowIndexSymbol: symbol) {
			recordKeyboardCommand("window:\(code)")
			lastWindowIndexKeyCommand = "window:\(code)"
			lastWindowIndexKeyCommitCode = code
			lastWindowShortcutPreCommitFilterSnapshot = makeWindowShortcutPreCommitFilterSnapshot(
			target: card,
			code: code
			)
			windowShortcutFilterPhase = .targetPreCommit
			clearWindowIndexKeyPending(resetShortcutFilter: false)
			commitKeyboardWindowCard(card, trigger: "windowIndexKey")
			return true
			}

			recordKeyboardCommand("windowInvalid:\(code)")
			lastWindowIndexKeyCommand = "windowInvalid:\(code)"
			lastWindowIndexKeyCommitCode = nil
			windowShortcutFilterPhase = .invalid
			lastWindowShortcutPreCommitFilterSnapshot = nil
			selectionChangedByLastCommand = false
			clearWindowIndexKeyPending(resetShortcutFilter: false)
			return true
			}

			let recordedCommand = "app:\(symbol)"
			recordKeyboardCommand(recordedCommand)
			lastWindowIndexKeyCommand = nil
			lastWindowIndexKeyCommitCode = nil
			if focusAppShelfItemForKeyboard(indexSymbol: symbol, commandLabel: recordedCommand),
			let ordinal = Self.appShelfIndexSymbols.firstIndex(of: symbol),
			ordinal < appShelfItems.count {
			let appGroupIndex = appShelfItems[ordinal].item.appGroupIndex
			if let card = singleVisibleWaterfallCard(appGroupIndex: appGroupIndex) {
			recordKeyboardCommand("windowSingle:\(symbol)")
			lastWindowIndexKeyCommand = "windowSingle:\(symbol)"
			lastWindowIndexKeyCommitCode = symbol
			lastWindowShortcutPreCommitFilterSnapshot = nil
			clearWindowIndexKeyPending()
			commitKeyboardWindowCard(card, trigger: "windowIndexSingleApp")
			} else {
			setWindowIndexKeyPending(
			appSymbol: symbol,
			appGroupIndex: appGroupIndex,
			startedAt: now
			)
			}
			} else {
			selectionChangedByLastCommand = false
			clearWindowIndexKeyPending()
			}
			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
			)
			}

			private func validWindowIndexKeyPending(now: CFTimeInterval) -> WindowIndexKeyPending? {
			guard let pending = windowIndexKeyPending else { return nil }
			guard now - pending.startedAt <= Self.windowIndexKeyPendingInterval else {
			clearWindowIndexKeyPending()
			return nil
			}
			return pending
			}

			private func setWindowIndexKeyPending(appSymbol: String, appGroupIndex: Int, startedAt: CFTimeInterval) {
			windowIndexKeyPendingClearTask?.cancel()
			windowIndexKeyPending = WindowIndexKeyPending(
			appSymbol: appSymbol,
			appGroupIndex: appGroupIndex,
			startedAt: startedAt
			)
			windowShortcutFilterPhase = .appPending
			lastWindowShortcutPreCommitFilterSnapshot = nil
			needsLayout = true
			windowIndexKeyPendingClearTask = Task { @MainActor [weak self] in
			do {
			try await Task.sleep(nanoseconds: UInt64(Self.windowIndexKeyPendingInterval * 1_000_000_000))
			} catch {
			return
			}
			guard let self,
			let pending = self.windowIndexKeyPending,
			pending.appSymbol == appSymbol,
			pending.appGroupIndex == appGroupIndex,
			pending.startedAt == startedAt
			else {
			return
			}
			self.windowIndexKeyPending = nil
			self.windowIndexKeyPendingClearTask = nil
			self.windowShortcutFilterPhase = .expired
			self.lastWindowShortcutPreCommitFilterSnapshot = nil
			self.needsLayout = true
			}
			}

			private func clearWindowIndexKeyPending(resetShortcutFilter: Bool = true) {
			let hadFilterState = windowIndexKeyPending != nil
			\|\| windowShortcutFilterPhase != .none
			\|\| lastWindowShortcutPreCommitFilterSnapshot != nil
			windowIndexKeyPendingClearTask?.cancel()
			windowIndexKeyPendingClearTask = nil
			windowIndexKeyPending = nil
			if resetShortcutFilter {
			windowShortcutFilterPhase = .none
			lastWindowShortcutPreCommitFilterSnapshot = nil
			}
			if hadFilterState {
			needsLayout = true
			}
			}

			@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()
			if isHorizontalMasonryMode {
			_ = selectHorizontalMasonryDefaultWindowForApp(appGroupIndex)
			}
			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 var horizontalAppDefaultWindowID: UInt32? {
			guard isHorizontalMasonryMode,
			case .app(let appGroupIndex) = hoverTarget
			else {
			return nil
			}
			return firstHorizontalMasonryCard(for: appGroupIndex)?.item.window.id
			}

			private func firstHorizontalMasonryCard(for appGroupIndex: Int) -> WaterfallCardLayers? {
			waterfallColumns
			.first { $0.column.appGroupIndex == appGroupIndex }?
			.cards
			.sorted { $0.item.windowIndex < $1.item.windowIndex }
			.first
			}

			private func isHorizontalAppDefaultCard(_ card: WaterfallCardLayers) -> Bool {
			guard isHorizontalMasonryMode,
			card.item.window.id == horizontalAppDefaultWindowID
			else {
			return false
			}
			return true
			}

			@discardableResult
			private func selectHorizontalMasonryDefaultWindowForApp(
			_ appGroupIndex: Int,
			recordsSelectionChange: Bool = false
			) -> QuickSwitchSelection? {
			guard isHorizontalMasonryMode,
			let card = firstHorizontalMasonryCard(for: appGroupIndex)
			else {
			return nil
			}

			let previousSelection = effectiveSelection
			let selection = selectionForCard(card)
			currentSelection = selection
			columnSelectionHistory[selection.appGroupIndex] = selection.windowIndex
			if recordsSelectionChange {
			selectionChangedByLastCommand = previousSelection != selection
			}
			return selection
			}

			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) {
			let command = rawCommand
			.trimmingCharacters(in: .whitespacesAndNewlines)
			.lowercased()
			guard !command.isEmpty else { return }
			clearWindowIndexKeyPending()

			let parts = command.split(separator: ":").map(String.init)
			switch parts.first {
			@@ -628,6 +2204,11 @@
			}
			recordMouseCommand("hover-app:\(appGroupIndex)")
			hoverAppGroup(appGroupIndex)
			case "reapply-view-model":
			if let currentViewModel {
			apply(viewModel: currentViewModel)
			}
			recordMouseCommand("reapply-view-model")
			case "click-app" where parts.count == 2:
			guard let appGroupIndex = Int(parts[1]) else {
			recordMouseCommand("invalid:\(command)")
			@@ -635,6 +2216,34 @@
			}
			recordMouseCommand("click-app:\(appGroupIndex)")
			clickAppShelfItem(appGroupIndex: appGroupIndex)
			case "click-app-center" where parts.count == 2:
			guard let appGroupIndex = Int(parts[1]) else {
			recordMouseCommand("invalid:\(command)")
			return
			}
			recordMouseCommand("click-app-center:\(appGroupIndex)")
			clickAppShelfItemViaMouse(appGroupIndex: appGroupIndex, probe: .iconCenter)
			case "click-app-near-close" where parts.count == 2:
			guard let appGroupIndex = Int(parts[1]) else {
			recordMouseCommand("invalid:\(command)")
			return
			}
			recordMouseCommand("click-app-near-close:\(appGroupIndex)")
			clickAppShelfItemViaMouse(appGroupIndex: appGroupIndex, probe: .nearCloseOutsideHit)
			case "hover-app-close" where parts.count == 2:
			guard let appGroupIndex = Int(parts[1]) else {
			recordMouseCommand("invalid:\(command)")
			return
			}
			recordMouseCommand("hover-app-close:\(appGroupIndex)")
			hoverAppCloseButton(appGroupIndex)
			case "click-app-close" where parts.count == 2:
			guard let appGroupIndex = Int(parts[1]) else {
			recordMouseCommand("invalid:\(command)")
			return
			}
			recordMouseCommand("click-app-close:\(appGroupIndex)")
			clickAppCloseButton(appGroupIndex)
			case "scroll-app-shelf" where parts.count == 2:
			guard let targetOffset = Double(parts[1]) else {
			recordMouseCommand("invalid:\(command)")
			@@ -649,7 +2258,7 @@
			}
			recordMouseCommand("hover-space:\(spaceID)")
			if let segment = spaceLaneSegment(spaceID: spaceID) {
			hoverSpaceLaneSegment(segment)
			hoverSpaceLaneSegment(segment, source: .debug)
			}
			case "click-space" where parts.count == 2:
			guard let spaceID = UInt64(parts[1]) else {
			@@ -658,8 +2267,41 @@
			}
			recordMouseCommand("click-space:\(spaceID)")
			if let segment = spaceLaneSegment(spaceID: spaceID) {
			clickSpaceLaneSegment(segment)
			clickSpaceLaneSegment(segment, clickCount: 1)
			}
			case "double-click-space" where parts.count == 2:
			guard let spaceID = UInt64(parts[1]) else {
			recordMouseCommand("invalid:\(command)")
			return
			}
			recordMouseCommand("double-click-space:\(spaceID)")
			if let segment = spaceLaneSegment(spaceID: spaceID) {
			clickSpaceLaneSegment(segment, clickCount: 1)
			clickSpaceLaneSegment(segment, clickCount: 2)
			}
			case "click-background":
			recordMouseCommand("click-background")
			_ = onBackgroundClick?()
			case "hover-view-toggle":
			recordMouseCommand("hover-view-toggle")
			suppressViewModeToggleHoverPreview = false
			isViewModeToggleButtonHovered = true
			isThemeToggleButtonHovered = false
			hoveredCloseTarget = nil
			setHoverTarget(.none, source: .debug)
			case "click-view-toggle", "click-settings":
			recordMouseCommand("click-view-toggle")
			clickViewModeToggleButton(source: "debug")
			case "hover-theme-toggle":
			recordMouseCommand("hover-theme-toggle")
			suppressThemeToggleHoverPreview = false
			isThemeToggleButtonHovered = true
			isViewModeToggleButtonHovered = false
			hoveredCloseTarget = nil
			setHoverTarget(.none, source: .debug)
			case "click-theme-toggle":
			recordMouseCommand("click-theme-toggle")
			clickThemeToggleButton(source: "debug")
			case "hover-card" where parts.count == 3:
			guard let appGroupIndex = Int(parts[1]), let windowIndex = Int(parts[2]) else {
			recordMouseCommand("invalid:\(command)")
			@@ -667,7 +2309,7 @@
			}
			recordMouseCommand("hover-card:\(appGroupIndex):\(windowIndex)")
			if let card = waterfallCard(appGroupIndex: appGroupIndex, windowIndex: windowIndex) {
			hoverWindowCard(card)
			hoverWindowCard(card, source: .debug)
			}
			case "click-card" where parts.count == 3:
			guard let appGroupIndex = Int(parts[1]), let windowIndex = Int(parts[2]) else {
			@@ -678,6 +2320,38 @@
			if let card = waterfallCard(appGroupIndex: appGroupIndex, windowIndex: windowIndex) {
			clickWindowCard(card)
			}
			case "click-card-id" where parts.count == 2:
			guard let windowID = UInt32(parts[1]) else {
			recordMouseCommand("invalid:\(command)")
			return
			}
			recordMouseCommand("click-card-id:\(windowID)")
			if let card = waterfallCard(windowID: windowID) {
			clickWindowCard(card)
			}
			case "hover-card-close" where parts.count == 3:
			guard let appGroupIndex = Int(parts[1]), let windowIndex = Int(parts[2]) else {
			recordMouseCommand("invalid:\(command)")
			return
			}
			recordMouseCommand("hover-card-close:\(appGroupIndex):\(windowIndex)")
			hoverCardCloseButton(appGroupIndex: appGroupIndex, windowIndex: windowIndex)
			case "click-card-close" where parts.count == 3:
			guard let appGroupIndex = Int(parts[1]), let windowIndex = Int(parts[2]) else {
			recordMouseCommand("invalid:\(command)")
			return
			}
			recordMouseCommand("click-card-close:\(appGroupIndex):\(windowIndex)")
			clickCardCloseButton(appGroupIndex: appGroupIndex, windowIndex: windowIndex)
			case "toggle-close-optout":
			recordMouseCommand("toggle-close-optout")
			toggleCloseConfirmationOptOut()
			case "confirm-close":
			recordMouseCommand("confirm-close")
			confirmPendingClose()
			case "cancel-close":
			recordMouseCommand("cancel-close")
			cancelPendingClose()
			default:
			recordMouseCommand("unknown:\(command)")
			}
			@@ -695,42 +2369,77 @@
			return command.hasPrefix("hover-")
			}

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

			private func hoverWindowCard(_ card: WaterfallCardLayers) {
			hoveredSpaceLaneID = nil
			private func hoverAppCloseButton(_ appGroupIndex: Int) {
			hoverAppGroup(appGroupIndex)
			hoveredCloseTarget = .app(appGroupIndex: appGroupIndex)
			needsLayout = true
			}

			private func clickAppCloseButton(_ appGroupIndex: Int) {
			hoverAppCloseButton(appGroupIndex)
			beginCloseConfirmation(for: .app(appGroupIndex: appGroupIndex))
			}

			private func hoverWindowCard(_ card: WaterfallCardLayers, source: HoverTargetSource = .event) {
			updateHoverState(
			appGroupIndex: card.item.appGroupIndex,
			windowID: card.item.window.id,
			spaceID: card.item.primarySpaceID
			spaceID: card.item.primarySpaceID,
			source: source
			)
			}

			private func hoverSpaceLaneSegment(_ segment: SpaceLaneSegmentLayers) {
			focusSpace(segment.space.id, persistent: false)
			private func hoverCardCloseButton(appGroupIndex: Int, windowIndex: Int) {
			guard let card = waterfallCard(appGroupIndex: appGroupIndex, windowIndex: windowIndex) else { return }
			hoverWindowCard(card, source: .debug)
			hoveredCloseTarget = .window(
			appGroupIndex: appGroupIndex,
			windowIndex: windowIndex,
			windowID: card.item.window.id
			)
			needsLayout = true
			}

			private func clickSpaceLaneSegment(_ segment: SpaceLaneSegmentLayers) {
			private func clickCardCloseButton(appGroupIndex: Int, windowIndex: Int) {
			guard let card = waterfallCard(appGroupIndex: appGroupIndex, windowIndex: windowIndex) else { return }
			hoverCardCloseButton(appGroupIndex: appGroupIndex, windowIndex: windowIndex)
			beginCloseConfirmation(
			for: .window(
			appGroupIndex: appGroupIndex,
			windowIndex: windowIndex,
			windowID: card.item.window.id
			)
			)
			}

			private func hoverSpaceLaneSegment(_ segment: SpaceLaneSegmentLayers, source: HoverTargetSource = .event) {
			focusSpace(segment.space.id, persistent: false, source: source)
			}

			private func clickSpaceLaneSegment(_ segment: SpaceLaneSegmentLayers, clickCount: Int = 1) {
			DevelopmentDiagnostics.log("quickSwitch.view.clickSpaceLane", [
			"spaceID": segment.space.id,
			"label": segment.space.label
			"label": segment.space.label,
			"clickCount": clickCount
			])
			focusSpace(segment.space.id, persistent: true)
			lastSpaceLaneClickSpaceID = segment.space.id
			onSpaceLaneClick?(segment.space.id, clickCount)
			lastSpaceLaneClickSpaceID = segment.space.id
			}

			private func focusSpace(_ spaceID: UInt64, persistent: Bool) {
			hoveredAppGroupIndex = nil
			hoveredWindowID = nil
			hoveredSpaceID = spaceID
			hoveredSpaceLaneID = spaceID
			private func focusSpace(_ spaceID: UInt64, persistent: Bool, source: HoverTargetSource = .event) {
			setHoverTarget(.space(spaceID), source: source)
			if persistent {
			focusedSpaceID = spaceID
			lastSpaceLaneClickSpaceID = spaceID
			@@ -774,12 +2483,72 @@
			columnSelectionHistory[nextSelection.appGroupIndex] = nextSelection.windowIndex
			lastAppShelfClickChangedSelection = previousSelection != nextSelection
			ensureWaterfallSelectionVisible(nextSelection, horizontalIntent: .alignWithAppShelf(animated: true))
			updateHoverState(appGroupIndex: appGroupIndex, windowID: nil, spaceID: nil)
			commitWindowCard(firstCard, trigger: "appShelf")
			} else {
			lastAppShelfClickChangedSelection = false
			ensureWaterfallColumnVisible(column)
			updateHoverState(appGroupIndex: appGroupIndex, windowID: nil, spaceID: nil)
			needsLayout = true
			}
			updateHoverState(appGroupIndex: appGroupIndex, windowID: nil, spaceID: nil)
			needsLayout = true
			}

			private enum AppShelfMouseClickProbe {
			case iconCenter
			case nearCloseOutsideHit
			}

			private func clickAppShelfItemViaMouse(appGroupIndex: Int, probe: AppShelfMouseClickProbe) {
			guard let windowLocation = appShelfSyntheticMouseDownLocation(for: appGroupIndex, probe: probe) else {
			DevelopmentDiagnostics.log("quickSwitch.view.clickAppShelfViaMouse.missingLocation", [
			"appGroupIndex": appGroupIndex
			])
			return
			}
			_ = handleMouseDown(at: windowLocation, clickCount: 1, allowBackgroundClick: false)
			}

			private func appShelfSyntheticMouseDownLocation(
			for appGroupIndex: Int,
			probe: AppShelfMouseClickProbe
			) -> CGPoint? {
			layoutSubtreeIfNeeded()
			guard let item = appShelfItems.first(where: { $0.item.appGroupIndex == appGroupIndex }) else {
			return nil
			}

			let iconFrame = item.iconLayer.frame
			let closeFrame = item.closeButton.containerLayer.frame
			let pointInItem: CGPoint
			switch probe {
			case .iconCenter:
			pointInItem = CGPoint(x: iconFrame.midX, y: iconFrame.midY)
			case .nearCloseOutsideHit:
			let fallbackPoint = CGPoint(
			x: iconFrame.maxX - 4,
			y: iconFrame.maxY - 14
			)
			if closeFrame.width > 0, closeFrame.height > 0 {
			let candidate = CGPoint(x: closeFrame.minX - 4, y: closeFrame.midY)
			pointInItem = iconFrame.contains(candidate) ? candidate : fallbackPoint
			} else {
			pointInItem = fallbackPoint
			}
			}

			let pointInView = CGPoint(
			x: glassLayer.frame.minX
			+ shelfLayer.frame.minX
			+ appShelfContentLayer.frame.minX
			+ item.containerLayer.frame.minX
			+ pointInItem.x,
			y: glassLayer.frame.minY
			+ shelfLayer.frame.minY
			+ appShelfContentLayer.frame.minY
			+ item.containerLayer.frame.minY
			+ pointInItem.y
			)
			return convert(pointInView, to: nil)
			}

			private func scrollAppShelf(to targetOffset: CGFloat) {
			@@ -821,12 +2590,45 @@

			private func clickWindowCard(_ card: WaterfallCardLayers) {
			hoverWindowCard(card)
			commitWindowCard(card, trigger: "windowCard")
			}

			private func commitKeyboardWindowCard(_ card: WaterfallCardLayers, trigger: String) {
			let selection = QuickSwitchSelection(
			appGroupIndex: card.item.appGroupIndex,
			windowIndex: card.item.windowIndex,
			windowID: card.item.window.id
			)
			DevelopmentDiagnostics.log("quickSwitch.view.clickWindowCard", [
			DevelopmentDiagnostics.log("quickSwitch.view.commitKeyboardWindow", [
			"trigger": trigger,
			"appGroupIndex": selection.appGroupIndex,
			"windowIndex": selection.windowIndex,
			"windowID": selection.windowID,
			"appName": card.item.window.app.name,
			"appPID": card.item.window.app.processIdentifier,
			"titleHash": DevelopmentDiagnostics.stableFingerprint(card.item.window.title),
			"titleLength": card.item.window.title.count,
			"titleIsEmpty": card.item.window.title.isEmpty,
			"isMinimized": card.item.window.isMinimized,
			"isFullscreen": card.item.window.isFullscreen,
			"identifierSource": String(describing: card.item.window.identifierSource)
			])
			currentSelection = selection
			columnSelectionHistory[selection.appGroupIndex] = selection.windowIndex
			lastCommittedSelection = selection
			lastCommitSource = .keyboard
			ensureCurrentSelectionVisible()
			onCommitSelection?(selection, .keyboard)
			}

			private func commitWindowCard(_ card: WaterfallCardLayers, trigger: String) {
			let selection = QuickSwitchSelection(
			appGroupIndex: card.item.appGroupIndex,
			windowIndex: card.item.windowIndex,
			windowID: card.item.window.id
			)
			DevelopmentDiagnostics.log("quickSwitch.view.commitMouseWindow", [
			"trigger": trigger,
			"appGroupIndex": selection.appGroupIndex,
			"windowIndex": selection.windowIndex,
			"windowID": selection.windowID,
			@@ -852,28 +2654,99 @@
			appGroupIndex: Int?,
			windowID: UInt32?,
			spaceID: UInt64?,
			alignsWaterfallWithAppShelf: Bool = false
			alignsWaterfallWithAppShelf: Bool = false,
			source: HoverTargetSource = .event
			) {
			guard hoveredAppGroupIndex != appGroupIndex
			\|\| hoveredWindowID != windowID
			\|\| hoveredSpaceID != spaceID
			else {
			if alignsWaterfallWithAppShelf, let appGroupIndex {
			alignWaterfallColumnWithAppShelfIcon(appGroupIndex: appGroupIndex, animated: true)
			}
			let target: HoverTarget
			if let appGroupIndex, let windowID {
			target = .window(appGroupIndex: appGroupIndex, windowID: windowID, spaceID: spaceID)
			} else if let appGroupIndex {
			target = .app(appGroupIndex)
			} else {
			target = .none
			}

			setHoverTarget(target, source: source, alignsWaterfallWithAppShelf: alignsWaterfallWithAppShelf)
			}

			private func refreshHoverTarget(at windowLocation: CGPoint) {
			guard debugHoveredAppGroupIndex == nil else { return }
			lastKnownMouseWindowLocation = windowLocation
			let target = resolveHoverTarget(at: windowLocation)
			setHoverTarget(target, alignsWaterfallWithAppShelf: target.shouldAlignWaterfallWithAppShelf)
			}

			private func refreshHoverTargetAfterViewRebuild() {
			guard debugHoveredAppGroupIndex == nil, currentViewModel != nil else { return }

			layoutSubtreeIfNeeded()
			let windowLocation = lastKnownMouseWindowLocation ?? window?.mouseLocationOutsideOfEventStream
			guard let windowLocation else { return }

			let locationInView = convert(windowLocation, from: nil)
			guard bounds.contains(locationInView) else {
			lastKnownMouseWindowLocation = nil
			setHoverTarget(.none)
			return
			}

			hoveredAppGroupIndex = appGroupIndex
			hoveredWindowID = windowID
			hoveredSpaceID = spaceID
			if alignsWaterfallWithAppShelf, let appGroupIndex {
			refreshHoverTarget(at: windowLocation)
			}

			private func resolveHoverTarget(at windowLocation: CGPoint) -> HoverTarget {
			if let segment = spaceLaneSegment(at: windowLocation) {
			return .space(segment.space.id)
			}

			if let card = waterfallCard(at: windowLocation) {
			return .window(
			appGroupIndex: card.item.appGroupIndex,
			windowID: card.item.window.id,
			spaceID: card.item.primarySpaceID
			)
			}

			if let item = appShelfItem(at: windowLocation) {
			return .app(item.item.appGroupIndex)
			}

			return .none
			}

			private func setHoverTarget(
			_ target: HoverTarget,
			source: HoverTargetSource = .event,
			alignsWaterfallWithAppShelf: Bool = false
			) {
			let previousTarget = hoverTarget
			let previousSource = hoverTargetSource
			hoverTarget = target
			hoverTargetSource = source

			hoveredAppGroupIndex = target.appGroupIndex
			hoveredWindowID = target.windowID
			hoveredSpaceID = target.spaceID
			hoveredSpaceLaneID = target.spaceLaneID

			if case .app(let appGroupIndex) = target, isHorizontalMasonryMode {
			keyboardFocusedWindowID = nil
			_ = selectHorizontalMasonryDefaultWindowForApp(appGroupIndex)
			}

			if alignsWaterfallWithAppShelf, let appGroupIndex = target.appGroupIndex {
			alignWaterfallColumnWithAppShelfIcon(appGroupIndex: appGroupIndex, animated: true)
			}

			guard previousTarget != target \|\| previousSource != source else { return }
			needsLayout = true
			}

			private func moveSelection(_ direction: QuickSwitchKeyboardDirection) {
			if isHorizontalMasonryMode {
			moveHorizontalMasonrySelection(direction)
			return
			}

			guard let currentViewModel,
			let snapshot = snapshotForFocus(from: currentViewModel),
			let current = currentSelection ?? currentViewModel.initialSelection,
			@@ -893,8 +2766,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),
			@@ -903,6 +2779,447 @@
			"windowID": next.windowID
			])
			needsLayout = true
			}

			private func moveHorizontalMasonrySelection(_ direction: QuickSwitchKeyboardDirection) {
			layoutSubtreeIfNeeded()

			let nodes = horizontalKeyboardFocusNodes()
			guard !nodes.isEmpty,
			let current = currentHorizontalKeyboardFocusNode(in: nodes),
			let next = nextHorizontalKeyboardFocusNode(from: current, direction: direction, in: nodes)
			else {
			DevelopmentDiagnostics.log("quickSwitch.view.moveHorizontalMasonrySelection.blocked", [
			"direction": String(describing: direction),
			"hasNodes": !nodes.isEmpty,
			"hasSelection": (currentSelection ?? currentViewModel?.initialSelection) != nil
			])
			selectionChangedByLastCommand = false
			return
			}

			focusHorizontalKeyboardNode(next, direction: direction)
			DevelopmentDiagnostics.log("quickSwitch.view.moveHorizontalMasonrySelection", [
			"direction": String(describing: direction),
			"kind": next.kind.rawValue,
			"appGroupIndex": next.appGroupIndex,
			"windowIndex": next.windowIndex ?? -1,
			"windowID": next.windowID ?? 0
			])
			}

			private func moveHorizontalMasonryTabSelection() {
			guard let current = currentSelection ?? currentViewModel?.initialSelection,
			let next = nextHorizontalMasonrySelection(from: current, direction: .right)
			else {
			DevelopmentDiagnostics.log("quickSwitch.view.moveHorizontalMasonryTabSelection.blocked", [
			"hasSelection": (currentSelection ?? currentViewModel?.initialSelection) != nil
			])
			selectionChangedByLastCommand = false
			return
			}

			columnSelectionHistory[current.appGroupIndex] = current.windowIndex
			let previousSelection = effectiveSelection
			currentSelection = next
			keyboardFocusedAppGroupIndex = next.appGroupIndex
			keyboardFocusedWindowID = next.windowID
			columnSelectionHistory[next.appGroupIndex] = next.windowIndex
			selectionChangedByLastCommand = previousSelection != next
			clearKeyboardBoundaryFeedback()
			setHoverTarget(
			.window(appGroupIndex: next.appGroupIndex, windowID: next.windowID, spaceID: nil),
			source: .keyboard
			)
			ensureCurrentSelectionVisible(horizontalIntent: .alignWithAppShelf(animated: true))
			DevelopmentDiagnostics.log("quickSwitch.view.moveHorizontalMasonryTabSelection", [
			"appGroupIndex": next.appGroupIndex,
			"windowIndex": next.windowIndex,
			"windowID": next.windowID
			])
			needsLayout = true
			}

			private func horizontalKeyboardFocusNodes() -> [HorizontalKeyboardFocusNode] {
			var nodes: [HorizontalKeyboardFocusNode] = []
			nodes.reserveCapacity(appShelfItems.count + waterfallColumns.reduce(0) { $0 + $1.cards.count })

			for (index, item) in appShelfItems.enumerated() {
			let frame = item.iconLayer.frame.offsetBy(
			dx: shelfLayer.frame.minX
			+ appShelfContentLayer.frame.minX
			+ item.containerLayer.frame.minX,
			dy: shelfLayer.frame.minY
			+ appShelfContentLayer.frame.minY
			+ item.containerLayer.frame.minY
			)
			nodes.append(HorizontalKeyboardFocusNode(
			kind: .app,
			appGroupIndex: item.item.appGroupIndex,
			windowIndex: nil,
			windowID: nil,
			spaceID: nil,
			frame: frame,
			order: index
			))
			}

			var order = appShelfItems.count
			for column in waterfallColumns.sorted(by: { $0.column.appGroupIndex < $1.column.appGroupIndex }) {
			for card in column.cards.sorted(by: { $0.item.windowIndex < $1.item.windowIndex }) {
			let frame = card.containerLayer.frame.offsetBy(
			dx: waterfallLayer.frame.minX
			+ waterfallContentLayer.frame.minX
			+ column.containerLayer.frame.minX
			+ column.cardsClipLayer.frame.minX,
			dy: waterfallLayer.frame.minY
			+ waterfallContentLayer.frame.minY
			+ column.containerLayer.frame.minY
			+ column.cardsClipLayer.frame.minY
			)
			nodes.append(HorizontalKeyboardFocusNode(
			kind: .window,
			appGroupIndex: card.item.appGroupIndex,
			windowIndex: card.item.windowIndex,
			windowID: card.item.window.id,
			spaceID: card.item.primarySpaceID,
			frame: frame,
			order: order
			))
			order += 1
			}
			}

			return nodes
			}

			private func currentHorizontalKeyboardFocusNode(
			in nodes: [HorizontalKeyboardFocusNode]
			) -> HorizontalKeyboardFocusNode? {
			if case .app(let appGroupIndex) = hoverTarget,
			let node = nodes.first(where: { $0.kind == .app && $0.appGroupIndex == appGroupIndex }) {
			return node
			}

			if let keyboardFocusedWindowID,
			let node = nodes.first(where: { $0.kind == .window && $0.windowID == keyboardFocusedWindowID }) {
			return node
			}

			if case .window(_, let windowID, _) = hoverTarget,
			let node = nodes.first(where: { $0.kind == .window && $0.windowID == windowID }) {
			return node
			}

			if let selection = effectiveSelection,
			let node = nodes.first(where: { $0.kind == .window && $0.windowID == selection.windowID }) {
			return node
			}

			return nodes.min { $0.order < $1.order }
			}

			private func nextHorizontalKeyboardFocusNode(
			from current: HorizontalKeyboardFocusNode,
			direction: QuickSwitchKeyboardDirection,
			in nodes: [HorizontalKeyboardFocusNode]
			) -> HorizontalKeyboardFocusNode? {
			let candidates = nodes.filter { !$0.matches(current) }
			guard !candidates.isEmpty else { return current }

			if current.kind == .app,
			direction == .down,
			let firstWindow = firstHorizontalWindowNode(for: current.appGroupIndex, in: nodes) {
			return firstWindow
			}

			if current.kind == .window,
			direction == .up,
			current.windowID == firstHorizontalMasonryCard(for: current.appGroupIndex)?.item.window.id,
			let appNode = nodes.first(where: { $0.kind == .app && $0.appGroupIndex == current.appGroupIndex }) {
			return appNode
			}

			switch direction {
			case .left, .right:
			let sameKindCandidates = candidates.filter { $0.kind == current.kind }
			return nextHorizontalFocusByX(
			from: current,
			direction: direction,
			candidates: sameKindCandidates.isEmpty ? candidates : sameKindCandidates
			)
			case .up, .down:
			return nextHorizontalFocusByY(from: current, direction: direction, candidates: candidates)
			}
			}

			private func firstHorizontalWindowNode(
			for appGroupIndex: Int,
			in nodes: [HorizontalKeyboardFocusNode]
			) -> HorizontalKeyboardFocusNode? {
			nodes
			.filter { $0.kind == .window && $0.appGroupIndex == appGroupIndex }
			.min { lhs, rhs in
			(lhs.windowIndex ?? .max, lhs.order) < (rhs.windowIndex ?? .max, rhs.order)
			}
			}

			private func nextHorizontalFocusByX(
			from current: HorizontalKeyboardFocusNode,
			direction: QuickSwitchKeyboardDirection,
			candidates: [HorizontalKeyboardFocusNode]
			) -> HorizontalKeyboardFocusNode? {
			let epsilon: CGFloat = 0.5
			let forward = direction == .right
			let directional = candidates.filter { node in
			forward
			? node.center.x > current.center.x + epsilon
			: node.center.x < current.center.x - epsilon
			}
			let sameBand = directional.filter { isHorizontalFocusSameBand($0, current) }
			let pool = sameBand.isEmpty ? directional : sameBand
			if let next = pool.sorted(by: horizontalFocusXSort(from: current, forward: forward)).first {
			return next
			}

			let wrapSameBand = candidates.filter { isHorizontalFocusSameBand($0, current) }
			let wrapPool = wrapSameBand.isEmpty ? candidates : wrapSameBand
			return wrapPool.sorted(by: horizontalFocusXWrapSort(from: current, forward: forward)).first
			}

			private func nextHorizontalFocusByY(
			from current: HorizontalKeyboardFocusNode,
			direction: QuickSwitchKeyboardDirection,
			candidates: [HorizontalKeyboardFocusNode]
			) -> HorizontalKeyboardFocusNode? {
			let epsilon: CGFloat = 0.5
			let upward = direction == .up
			let directional = candidates.filter { node in
			upward
			? node.center.y > current.center.y + epsilon
			: node.center.y < current.center.y - epsilon
			}
			if let next = directional.sorted(by: horizontalFocusYSort(from: current, upward: upward)).first {
			return next
			}
			return candidates.sorted(by: horizontalFocusYWrapSort(from: current, upward: upward)).first
			}

			private func isHorizontalFocusSameBand(
			_ lhs: HorizontalKeyboardFocusNode,
			_ rhs: HorizontalKeyboardFocusNode
			) -> Bool {
			let tolerance = max(lhs.frame.height, rhs.frame.height) * 0.75
			return abs(lhs.center.y - rhs.center.y) <= tolerance
			}

			private func horizontalFocusXSort(
			from current: HorizontalKeyboardFocusNode,
			forward: Bool
			) -> (HorizontalKeyboardFocusNode, HorizontalKeyboardFocusNode) -> Bool {
			{ lhs, rhs in
			let lhsPrimary = abs(lhs.center.x - current.center.x)
			let rhsPrimary = abs(rhs.center.x - current.center.x)
			if abs(lhsPrimary - rhsPrimary) > 0.5 {
			return lhsPrimary < rhsPrimary
			}

			let lhsSecondary = abs(lhs.center.y - current.center.y)
			let rhsSecondary = abs(rhs.center.y - current.center.y)
			if abs(lhsSecondary - rhsSecondary) > 0.5 {
			return lhsSecondary < rhsSecondary
			}

			return forward ? lhs.order < rhs.order : lhs.order > rhs.order
			}
			}

			private func horizontalFocusXWrapSort(
			from current: HorizontalKeyboardFocusNode,
			forward: Bool
			) -> (HorizontalKeyboardFocusNode, HorizontalKeyboardFocusNode) -> Bool {
			{ lhs, rhs in
			if abs(lhs.center.x - rhs.center.x) > 0.5 {
			return forward ? lhs.center.x < rhs.center.x : lhs.center.x > rhs.center.x
			}

			let lhsSecondary = abs(lhs.center.y - current.center.y)
			let rhsSecondary = abs(rhs.center.y - current.center.y)
			if abs(lhsSecondary - rhsSecondary) > 0.5 {
			return lhsSecondary < rhsSecondary
			}

			return forward ? lhs.order < rhs.order : lhs.order > rhs.order
			}
			}

			private func horizontalFocusYSort(
			from current: HorizontalKeyboardFocusNode,
			upward: Bool
			) -> (HorizontalKeyboardFocusNode, HorizontalKeyboardFocusNode) -> Bool {
			{ lhs, rhs in
			let lhsPrimary = abs(lhs.center.y - current.center.y)
			let rhsPrimary = abs(rhs.center.y - current.center.y)
			if abs(lhsPrimary - rhsPrimary) > 0.5 {
			return lhsPrimary < rhsPrimary
			}

			let lhsSecondary = abs(lhs.center.x - current.center.x)
			let rhsSecondary = abs(rhs.center.x - current.center.x)
			if abs(lhsSecondary - rhsSecondary) > 0.5 {
			return lhsSecondary < rhsSecondary
			}

			return upward ? lhs.order < rhs.order : lhs.order > rhs.order
			}
			}

			private func horizontalFocusYWrapSort(
			from current: HorizontalKeyboardFocusNode,
			upward: Bool
			) -> (HorizontalKeyboardFocusNode, HorizontalKeyboardFocusNode) -> Bool {
			{ lhs, rhs in
			if abs(lhs.center.y - rhs.center.y) > 0.5 {
			return upward ? lhs.center.y < rhs.center.y : lhs.center.y > rhs.center.y
			}

			let lhsSecondary = abs(lhs.center.x - current.center.x)
			let rhsSecondary = abs(rhs.center.x - current.center.x)
			if abs(lhsSecondary - rhsSecondary) > 0.5 {
			return lhsSecondary < rhsSecondary
			}

			return upward ? lhs.order < rhs.order : lhs.order > rhs.order
			}
			}

			private func focusHorizontalKeyboardNode(
			_ node: HorizontalKeyboardFocusNode,
			direction _: QuickSwitchKeyboardDirection
			) {
			switch node.kind {
			case .app:
			keyboardFocusedAppGroupIndex = node.appGroupIndex
			keyboardFocusedWindowID = nil
			clearKeyboardBoundaryFeedback()
			ensureAppShelfItemVisible(node.appGroupIndex)
			_ = selectHorizontalMasonryDefaultWindowForApp(
			node.appGroupIndex,
			recordsSelectionChange: true
			)
			hoverAppGroup(node.appGroupIndex, source: .keyboard)
			case .window:
			guard let windowIndex = node.windowIndex,
			let windowID = node.windowID
			else {
			selectionChangedByLastCommand = false
			return
			}

			let previousSelection = effectiveSelection
			let next = QuickSwitchSelection(
			appGroupIndex: node.appGroupIndex,
			windowIndex: windowIndex,
			windowID: windowID
			)
			keyboardFocusedAppGroupIndex = node.appGroupIndex
			keyboardFocusedWindowID = windowID
			currentSelection = next
			columnSelectionHistory[next.appGroupIndex] = next.windowIndex
			selectionChangedByLastCommand = previousSelection != next
			clearKeyboardBoundaryFeedback()
			ensureAppShelfItemVisible(node.appGroupIndex)
			setHoverTarget(
			.window(appGroupIndex: node.appGroupIndex, windowID: windowID, spaceID: node.spaceID),
			source: .keyboard
			)
			ensureCurrentSelectionVisible(horizontalIntent: .alignWithAppShelf(animated: true))
			}

			needsLayout = true
			}

			private func nextHorizontalMasonrySelection(
			from current: QuickSwitchSelection,
			direction: QuickSwitchKeyboardDirection
			) -> QuickSwitchSelection? {
			layoutSubtreeIfNeeded()

			let cards = horizontalMasonryCardsInPlacementOrder()
			guard let currentIndex = cards.firstIndex(where: { $0.item.window.id == current.windowID }) else {
			return cards.first.map(selectionForCard)
			}

			switch direction {
			case .right:
			return selectionForCard(cards[(currentIndex + 1) % cards.count])
			case .left:
			return selectionForCard(cards[(currentIndex - 1 + cards.count) % cards.count])
			case .up:
			return nearestHorizontalMasonrySelection(from: cards[currentIndex], direction: .up)
			?? selectionForCard(cards.first ?? cards[currentIndex])
			case .down:
			return nearestHorizontalMasonrySelection(from: cards[currentIndex], direction: .down)
			?? selectionForCard(cards.last ?? cards[currentIndex])
			}
			}

			private func nearestHorizontalMasonrySelection(
			from currentCard: WaterfallCardLayers,
			direction: QuickSwitchKeyboardDirection
			) -> QuickSwitchSelection? {
			let currentFrame = currentCard.containerLayer.frame
			let candidates = horizontalMasonryCardsInPlacementOrder().filter { card in
			guard card.item.window.id != currentCard.item.window.id else { return false }
			switch direction {
			case .up:
			return card.containerLayer.frame.minY >= currentFrame.maxY - 0.5
			case .down:
			return card.containerLayer.frame.maxY <= currentFrame.minY + 0.5
			case .left, .right:
			return false
			}
			}

			let best = candidates.min { lhs, rhs in
			let lhsFrame = lhs.containerLayer.frame
			let rhsFrame = rhs.containerLayer.frame
			let lhsPrimaryDistance = direction == .up
			? lhsFrame.minY - currentFrame.maxY
			: currentFrame.minY - lhsFrame.maxY
			let rhsPrimaryDistance = direction == .up
			? rhsFrame.minY - currentFrame.maxY
			: currentFrame.minY - rhsFrame.maxY
			if abs(lhsPrimaryDistance - rhsPrimaryDistance) > 0.5 {
			return lhsPrimaryDistance < rhsPrimaryDistance
			}

			let lhsHorizontalDistance = abs(lhsFrame.midX - currentFrame.midX)
			let rhsHorizontalDistance = abs(rhsFrame.midX - currentFrame.midX)
			if abs(lhsHorizontalDistance - rhsHorizontalDistance) > 0.5 {
			return lhsHorizontalDistance < rhsHorizontalDistance
			}

			return lhs.item.globalIndex < rhs.item.globalIndex
			}

			return best.map(selectionForCard)
			}

			private func horizontalMasonryCardsInPlacementOrder() -> [WaterfallCardLayers] {
			waterfallColumns
			.sorted { $0.column.appGroupIndex < $1.column.appGroupIndex }
			.flatMap { column in
			column.cards.sorted { $0.item.windowIndex < $1.item.windowIndex }
			}
			}

			private func selectionForCard(_ card: WaterfallCardLayers) -> QuickSwitchSelection {
			QuickSwitchSelection(
			appGroupIndex: card.item.appGroupIndex,
			windowIndex: card.item.windowIndex,
			windowID: card.item.window.id
			)
			}

			private func commitCurrentSelection() {
			@@ -962,9 +3279,24 @@
			_ selection: QuickSwitchSelection,
			horizontalIntent: WaterfallHorizontalIntent = .reveal
			) {
			if isHorizontalMasonryMode {
			switch horizontalIntent {
			case .reveal:
			ensureHorizontalMasonrySelectionVisible(selection, animated: false)
			case .alignWithAppShelf(let animated):
			ensureHorizontalMasonrySelectionVisible(selection, animated: animated)
			}
			return
			}

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

			if waterfallShouldKeepFilteredColumnsCentered {
			ensureWaterfallCardVisibleVertically(selection)
			return
			}

			@@ -978,11 +3310,16 @@
			}

			private func ensureWaterfallCardVisibleVertically(_ selection: QuickSwitchSelection) {
			guard !isHorizontalMasonryMode else {
			ensureHorizontalMasonrySelectionVisible(selection, animated: false)
			return
			}

			let visibleHeight = max(
			1,
			waterfallLayer.bounds.height
			- WaterfallMetrics.headerHeight
			- WaterfallMetrics.columnPadding * 2
			- WaterfallMetrics.columnVerticalPadding * 2
			)
			let cardStride = WaterfallMetrics.cardHeight + WaterfallMetrics.cardGap
			let cardStart = CGFloat(selection.windowIndex) * cardStride
			@@ -1005,6 +3342,11 @@
			}

			private func alignWaterfallColumnWithAppShelfIcon(appGroupIndex: Int, animated: Bool) {
			if isHorizontalMasonryMode {
			ensureHorizontalMasonryAppVisible(appGroupIndex, animated: animated)
			return
			}

			guard
			let item = appShelfItems.first(where: { $0.item.appGroupIndex == appGroupIndex }),
			let column = waterfallColumns.first(where: { $0.column.appGroupIndex == appGroupIndex })
			@@ -1031,6 +3373,11 @@
			}

			private func ensureWaterfallColumnVisible(_ appGroupIndex: Int) {
			if isHorizontalMasonryMode {
			ensureHorizontalMasonryAppVisible(appGroupIndex, animated: false)
			return
			}

			guard let column = waterfallColumns.first(where: { $0.column.appGroupIndex == appGroupIndex }) else {
			return
			}
			@@ -1039,18 +3386,31 @@
			}

			private func ensureWaterfallColumnVisible(_ column: WaterfallColumnLayers) {
			if isHorizontalMasonryMode {
			ensureHorizontalMasonryAppVisible(column.column.appGroupIndex, animated: false)
			return
			}

			waterfallScrollOffset = clampedWaterfallOffset(
			scrollOffset(
			makingVisible: column.containerLayer.frame,
			currentOffset: waterfallScrollOffset,
			visibleWidth: waterfallLayer.bounds.width,
			maxOffset: waterfallMaxScrollOffset,
			inset: WaterfallMetrics.revealPadding
			inset: WaterfallMetrics.horizontalRevealPadding
			)
			)
			}

			private var waterfallAlignmentScrollRange: ClosedRange<CGFloat> {
			if isHorizontalMasonryMode {
			return 0...0
			}

			if waterfallShouldKeepFilteredColumnsCentered {
			return 0...0
			}

			var minimumOffset: CGFloat = 0
			var maximumOffset = waterfallMaxScrollOffset

			@@ -1075,6 +3435,10 @@
			private func clampedWaterfallAlignmentOffset(_ offset: CGFloat) -> CGFloat {
			let range = waterfallAlignmentScrollRange
			return min(max(range.lowerBound, offset), range.upperBound)
			}

			private var waterfallShouldKeepFilteredColumnsCentered: Bool {
			currentViewModel?.lockedSpaceID != nil && waterfallMaxScrollOffset <= 0.5
			}

			private func setWaterfallScrollOffset(_ offset: CGFloat, animated: Bool) {
			@@ -1109,6 +3473,80 @@
			animation.timingFunction = CAMediaTimingFunction(name: WaterfallAlignmentMetrics.animationTimingName)
			animation.isRemovedOnCompletion = true
			waterfallContentLayer.add(animation, forKey: "waterfallColumnAlignment")
			}

			private func ensureHorizontalMasonrySelectionVisible(
			_ selection: QuickSwitchSelection,
			animated: Bool
			) {
			guard let card = waterfallCard(
			appGroupIndex: selection.appGroupIndex,
			windowIndex: selection.windowIndex
			) else {
			return
			}

			let visibleFrame = card.containerLayer.frame.offsetBy(
			dx: 0,
			dy: waterfallContentLayer.frame.minY
			)
			let visibleHeight = waterfallLayer.bounds.height
			let padding = WaterfallMetrics.revealPadding
			var nextOffset = horizontalMasonryScrollOffset

			if visibleFrame.maxY > visibleHeight - padding {
			nextOffset -= visibleFrame.maxY - (visibleHeight - padding)
			} else if visibleFrame.minY < padding {
			nextOffset += padding - visibleFrame.minY
			}

			setHorizontalMasonryScrollOffset(nextOffset, animated: animated)
			}

			private func ensureHorizontalMasonryAppVisible(_ appGroupIndex: Int, animated: Bool) {
			guard let firstCard = waterfallColumns
			.first(where: { $0.column.appGroupIndex == appGroupIndex })?
			.cards
			.sorted(by: { $0.item.windowIndex < $1.item.windowIndex })
			.first
			else {
			return
			}

			let cardTopDistance = horizontalMasonryContentHeight - firstCard.containerLayer.frame.maxY
			setHorizontalMasonryScrollOffset(
			cardTopDistance - WaterfallMetrics.revealPadding,
			animated: animated
			)
			}

			private func setHorizontalMasonryScrollOffset(_ offset: CGFloat, animated: Bool) {
			let nextOffset = clampedHorizontalMasonryOffset(offset)
			let previousPositionY = waterfallContentLayer.presentation()?.position.y
			?? waterfallContentLayer.position.y

			horizontalMasonryScrollOffset = nextOffset
			CATransaction.begin()
			CATransaction.setDisableActions(true)
			waterfallContentLayer.frame = horizontalMasonryContentFrame()
			CATransaction.commit()

			let nextPositionY = waterfallContentLayer.position.y
			guard animated,
			!NSWorkspace.shared.accessibilityDisplayShouldReduceMotion,
			abs(previousPositionY - nextPositionY) > 0.5
			else {
			waterfallContentLayer.removeAnimation(forKey: "horizontalMasonryAlignment")
			return
			}

			let animation = CABasicAnimation(keyPath: "position.y")
			animation.fromValue = previousPositionY
			animation.toValue = nextPositionY
			animation.duration = WaterfallAlignmentMetrics.animationDuration
			animation.timingFunction = CAMediaTimingFunction(name: WaterfallAlignmentMetrics.animationTimingName)
			animation.isRemovedOnCompletion = true
			waterfallContentLayer.add(animation, forKey: "horizontalMasonryAlignment")
			}

			private func scrollOffset(
			@@ -1185,7 +3623,7 @@
			}

			private func setupBackdropBlurView() {
			backdropBlurView.material = .fullScreenUI
			backdropBlurView.material = resolvedTheme == .dark ? .hudWindow : .fullScreenUI
			backdropBlurView.blendingMode = .behindWindow
			backdropBlurView.state = .active
			backdropBlurView.isEmphasized = false
			@@ -1203,19 +3641,91 @@
			addSubview(layerHostView, positioned: .above, relativeTo: backdropBlurView)
			}

			private func applyThemeToBackdrop() {
			let palette = themePalette
			backdropBlurView.material = resolvedTheme == .dark ? .hudWindow : .fullScreenUI
			backgroundLayer.colors = palette.backgroundGradientColors.map(\.cgColor)
			backgroundLayer.locations = resolvedTheme == .dark
			? [0, 0.44, 0.72, 1].map(NSNumber.init(value:))
			: [0, 1].map(NSNumber.init(value:))
			safeAreaFillLayer.backgroundColor = palette.safeAreaFill.cgColor

			let showsDarkBackdrop = resolvedTheme == .dark
			darkAmbientLeftLayer.isHidden = !showsDarkBackdrop
			darkAmbientCenterLayer.isHidden = !showsDarkBackdrop
			darkAmbientRightLayer.isHidden = !showsDarkBackdrop
			darkVignetteLayer.isHidden = !showsDarkBackdrop
			guard showsDarkBackdrop else { return }

			darkAmbientLeftLayer.colors = [
			NSColor(calibratedRed: 72 / 255, green: 56 / 255, blue: 145 / 255, alpha: 0.34).cgColor,
			NSColor(calibratedRed: 20 / 255, green: 28 / 255, blue: 76 / 255, alpha: 0.17).cgColor,
			NSColor.clear.cgColor
			]
			darkAmbientCenterLayer.colors = [
			NSColor(calibratedRed: 14 / 255, green: 92 / 255, blue: 130 / 255, alpha: 0.26).cgColor,
			NSColor(calibratedRed: 12 / 255, green: 54 / 255, blue: 89 / 255, alpha: 0.16).cgColor,
			NSColor.clear.cgColor
			]
			darkAmbientRightLayer.colors = [
			NSColor(calibratedRed: 4 / 255, green: 92 / 255, blue: 108 / 255, alpha: 0.20).cgColor,
			NSColor(calibratedRed: 0 / 255, green: 44 / 255, blue: 54 / 255, alpha: 0.15).cgColor,
			NSColor.clear.cgColor
			]
			darkVignetteLayer.colors = [
			NSColor.black.withAlphaComponent(0.48).cgColor,
			NSColor.clear.cgColor,
			NSColor.black.withAlphaComponent(0.28).cgColor
			]
			darkVignetteLayer.locations = [0, 0.36, 1].map(NSNumber.init(value:))
			}

			private func layoutBackdropLayers() {
			applyThemeToBackdrop()
			guard resolvedTheme == .dark else { return }

			let width = max(1, bounds.width)
			let height = max(1, bounds.height)
			darkAmbientLeftLayer.frame = CGRect(
			x: -width * 0.18,
			y: -height * 0.10,
			width: width * 0.82,
			height: height * 1.24
			)
			darkAmbientCenterLayer.frame = CGRect(
			x: width * 0.24,
			y: height * 0.10,
			width: width * 0.52,
			height: height * 0.74
			)
			darkAmbientRightLayer.frame = CGRect(
			x: width * 0.50,
			y: -height * 0.12,
			width: width * 0.72,
			height: height * 1.26
			)
			darkVignetteLayer.frame = bounds
			}

			private func setupLayers() {
			guard let rootLayer = layerHostView.layer else { return }

			rootLayer.masksToBounds = true
			backgroundLayer.colors = [
			NSColor.windowBackgroundColor.withAlphaComponent(0.58).cgColor,
			NSColor.controlBackgroundColor.withAlphaComponent(0.48).cgColor
			]
			backgroundLayer.startPoint = CGPoint(x: 0.5, y: 1.0)
			backgroundLayer.endPoint = CGPoint(x: 0.5, y: 0.0)
			rootLayer.addSublayer(backgroundLayer)
			for ambientLayer in darkBackdropAmbientLayers {
			ambientLayer.type = .radial
			ambientLayer.startPoint = CGPoint(x: 0.5, y: 0.5)
			ambientLayer.endPoint = CGPoint(x: 1.0, y: 1.0)
			ambientLayer.isHidden = true
			rootLayer.addSublayer(ambientLayer)
			}
			darkVignetteLayer.startPoint = CGPoint(x: 0.5, y: 1.0)
			darkVignetteLayer.endPoint = CGPoint(x: 0.5, y: 0.0)
			darkVignetteLayer.isHidden = true
			rootLayer.addSublayer(darkVignetteLayer)

			safeAreaFillLayer.backgroundColor = NSColor.black.cgColor
			rootLayer.addSublayer(safeAreaFillLayer)

			glassLayer.cornerRadius = 0
			@@ -1225,13 +3735,13 @@
			glassLayer.shadowOpacity = 0
			rootLayer.addSublayer(glassLayer)

			laneLayer.backgroundColor = NSColor.controlBackgroundColor.withAlphaComponent(0.68).cgColor
			laneLayer.cornerRadius = 16
			laneLayer.backgroundColor = NSColor.clear.cgColor
			laneLayer.cornerRadius = 0
			laneLayer.masksToBounds = true
			glassLayer.addSublayer(laneLayer)
			laneLayer.addSublayer(spaceLaneContentLayer)

			shelfLayer.backgroundColor = NSColor.controlBackgroundColor.withAlphaComponent(0.60).cgColor
			shelfLayer.backgroundColor = NSColor.clear.cgColor
			shelfLayer.cornerRadius = 16
			shelfLayer.masksToBounds = true
			glassLayer.addSublayer(shelfLayer)
			@@ -1241,6 +3751,49 @@
			waterfallLayer.masksToBounds = true
			glassLayer.addSublayer(waterfallLayer)
			waterfallLayer.addSublayer(waterfallContentLayer)

			closeConfirmationLayers.containerLayer.isHidden = true
			glassLayer.addSublayer(closeConfirmationLayers.containerLayer)

			closeFeedbackLayer.isHidden = true
			closeFeedbackLayer.opacity = 0
			closeFeedbackLayer.cornerRadius = 11
			closeFeedbackLayer.borderWidth = 1
			closeFeedbackLayer.masksToBounds = false
			closeFeedbackLayer.shadowColor = NSColor.black.cgColor
			closeFeedbackLayer.shadowOpacity = 0.14
			closeFeedbackLayer.shadowRadius = 16
			closeFeedbackLayer.shadowOffset = CGSize(width: 0, height: -5)
			closeFeedbackLayer.zPosition = 190
			closeFeedbackTextLayer.contentsScale = backingScaleFactor
			closeFeedbackTextLayer.font = NSFont.systemFont(ofSize: 13, weight: .medium)
			closeFeedbackTextLayer.fontSize = 13
			closeFeedbackTextLayer.alignmentMode = .center
			closeFeedbackTextLayer.truncationMode = .end
			closeFeedbackLayer.addSublayer(closeFeedbackTextLayer)
			glassLayer.addSublayer(closeFeedbackLayer)

			viewModeToggleButtonLayer.cornerRadius = 10
			viewModeToggleButtonLayer.masksToBounds = false
			viewModeToggleButtonLayer.borderWidth = 1
			viewModeToggleButtonLayer.shadowColor = NSColor.black.cgColor
			viewModeToggleButtonLayer.shadowOffset = CGSize(width: 0, height: -2)
			viewModeToggleButtonLayer.zPosition = 170
			viewModeToggleIconLayer.contentsScale = backingScaleFactor
			viewModeToggleButtonLayer.addSublayer(viewModeToggleIconLayer)
			glassLayer.addSublayer(viewModeToggleButtonLayer)

			themeToggleButtonLayer.cornerRadius = 10
			themeToggleButtonLayer.masksToBounds = false
			themeToggleButtonLayer.borderWidth = 1
			themeToggleButtonLayer.shadowColor = NSColor.black.cgColor
			themeToggleButtonLayer.shadowOffset = CGSize(width: 0, height: -2)
			themeToggleButtonLayer.zPosition = 170
			themeToggleIconLayer.contentsScale = backingScaleFactor
			themeToggleButtonLayer.addSublayer(themeToggleIconLayer)
			glassLayer.addSublayer(themeToggleButtonLayer)

			applyThemeToBackdrop()
			}

			private func rebuildAppShelfItems() {
			@@ -1248,22 +3801,15 @@
			item.containerLayer.removeFromSuperlayer()
			}

			let selectedAppGroupIndex = effectiveSelection?.appGroupIndex
			appShelfItems = (currentViewModel?.appShelf ?? []).map { item in
			appShelfItems = (currentViewModel?.appShelf ?? []).enumerated().map { ordinal, item in
			let container = CALayer()
			container.name = item.app.name

			let background = CALayer()
			background.cornerRadius = 10
			background.backgroundColor = (item.appGroupIndex == selectedAppGroupIndex
			? NSColor.systemFill.withAlphaComponent(0.16)
			: NSColor.clear
			).cgColor
			background.borderColor = (item.appGroupIndex == selectedAppGroupIndex
			? NSColor.separatorColor.withAlphaComponent(0.36)
			: NSColor.clear
			).cgColor
			background.borderWidth = item.appGroupIndex == selectedAppGroupIndex ? 1 : 0
			background.backgroundColor = NSColor.clear.cgColor
			background.borderColor = NSColor.clear.cgColor
			background.borderWidth = 0

			let icon = CALayer()
			icon.contentsGravity = .resizeAspect
			@@ -1272,11 +3818,23 @@
			icon.cornerRadius = 12
			icon.masksToBounds = false

			let indexLabel = makeTextLayer(
			string: appShelfIndexText(forOrdinal: ordinal),
			fontSize: AppShelfMetrics.indexFontSize,
			weight: .regular,
			color: appShelfIndexColor,
			alignment: .center
			)
			indexLabel.font = appShelfIndexFont(size: AppShelfMetrics.indexFontSize)
			indexLabel.fontSize = AppShelfMetrics.indexFontSize
			indexLabel.truncationMode = .end
			indexLabel.zPosition = 14

			let label = makeTextLayer(
			string: item.app.name,
			fontSize: 11,
			weight: .regular,
			color: .secondaryLabelColor,
			color: themePalette.appShelfLabelText,
			alignment: .center
			)

			@@ -1293,21 +3851,26 @@

			let selectedIndicator = CALayer()
			selectedIndicator.isHidden = true
			let closeButton = makeCloseButtonLayers()

			container.addSublayer(background)
			container.addSublayer(indexLabel)
			container.addSublayer(icon)
			container.addSublayer(label)
			container.addSublayer(badge)
			container.addSublayer(closeButton.containerLayer)
			appShelfContentLayer.addSublayer(container)

			return AppShelfItemLayers(
			item: item,
			containerLayer: container,
			backgroundLayer: background,
			indexLayer: indexLabel,
			iconLayer: icon,
			labelLayer: label,
			badgeLayer: badge,
			selectedIndicatorLayer: selectedIndicator
			selectedIndicatorLayer: selectedIndicator,
			closeButton: closeButton
			)
			}
			}
			@@ -1323,27 +3886,37 @@
			container.name = column.app.name
			container.cornerRadius = 14
			container.masksToBounds = true
			container.backgroundColor = NSColor.controlBackgroundColor.withAlphaComponent(0.56).cgColor
			container.borderColor = NSColor.separatorColor.withAlphaComponent(0.34).cgColor
			container.backgroundColor = themePalette.columnBackground.cgColor
			container.borderColor = themePalette.columnBorder.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.backgroundColor = themePalette.columnHeaderBackground.cgColor
			header.zPosition = 40

			let appName = makeTextLayer(
			string: column.app.name,
			fontSize: 13,
			weight: .semibold,
			color: .labelColor
			color: themePalette.columnText,
			alignment: .center
			)
			let count = makeTextLayer(
			string: "\(column.windows.count)",
			fontSize: 11,
			weight: .medium,
			color: .secondaryLabelColor,
			color: themePalette.columnSecondaryText,
			alignment: .right
			)

			appName.zPosition = 42
			count.zPosition = 42

			container.addSublayer(cardsClip)
			container.addSublayer(header)
			container.addSublayer(appName)
			container.addSublayer(count)
			@@ -1361,18 +3934,22 @@
			thumbnail.contents = skeletonThumbnailProvider
			.withOverlayTitle(window.window.title, for: window.window.app)

			let titleBar = CALayer()
			titleBar.borderWidth = 0

			let title = makeTextLayer(
			string: window.window.title.isEmpty ? "Untitled Window" : window.window.title,
			fontSize: 12,
			weight: .medium,
			color: .labelColor
			color: themePalette.cardText
			)
			title.truncationMode = .middle
			let meta = makeTextLayer(
			string: waterfallMetaText(for: window),
			fontSize: 10,
			weight: .regular,
			color: .secondaryLabelColor
			color: themePalette.cardSecondaryText,
			alignment: .right
			)
			let appIcon = CALayer()
			appIcon.contentsGravity = .resizeAspect
			@@ -1385,36 +3962,41 @@
			string: waterfallStateText(for: window),
			fontSize: 10,
			weight: .medium,
			color: .secondaryLabelColor,
			color: themePalette.cardSecondaryText,
			alignment: .right
			)
			let shine = CAGradientLayer()
			shine.colors = [
			NSColor.white.withAlphaComponent(0.00).cgColor,
			NSColor.white.withAlphaComponent(0.16).cgColor,
			themePalette.shinePeak.cgColor,
			NSColor.white.withAlphaComponent(0.00).cgColor
			]
			shine.startPoint = CGPoint(x: 0, y: 1)
			shine.endPoint = CGPoint(x: 1, y: 0)
			shine.opacity = 0
			let closeButton = makeCloseButtonLayers()

			card.addSublayer(thumbnail)
			card.addSublayer(titleBar)
			card.addSublayer(appIcon)
			card.addSublayer(title)
			card.addSublayer(meta)
			card.addSublayer(state)
			card.addSublayer(shine)
			container.addSublayer(card)
			card.addSublayer(closeButton.containerLayer)
			cardsClip.addSublayer(card)

			return WaterfallCardLayers(
			item: window,
			containerLayer: card,
			titleBarLayer: titleBar,
			titleLayer: title,
			metaLayer: meta,
			thumbnailLayer: thumbnail,
			appIconLayer: appIcon,
			stateLayer: state,
			shineLayer: shine
			shineLayer: shine,
			closeButton: closeButton
			)
			}

			@@ -1423,6 +4005,7 @@
			return WaterfallColumnLayers(
			column: column,
			containerLayer: container,
			cardsClipLayer: cardsClip,
			headerLayer: header,
			appNameLayer: appName,
			countLayer: count,
			@@ -1435,63 +4018,108 @@
			}

			private func rebuildSpaceLaneSegments() {
			for segment in spaceLaneSegments {
			segment.containerLayer.removeFromSuperlayer()
			for group in spaceLaneDisplayGroups {
			group.containerLayer.removeFromSuperlayer()
			}

			let spaces = currentViewModel?.displays.flatMap(\.spaces) ?? []
			spaceLaneSegments = spaces.map { space in
			let container = CALayer()
			container.name = space.label
			container.cornerRadius = 10
			container.borderWidth = 1
			container.borderColor = NSColor.separatorColor.withAlphaComponent(0.34).cgColor
			container.backgroundColor = spaceColor(for: space).cgColor
			container.shadowColor = NSColor.black.cgColor
			var groups: [SpaceLaneDisplayGroupLayers] = []
			var allSegments: [SpaceLaneSegmentLayers] = []

			let labelLayer = makeTextLayer(
			string: space.label,
			fontSize: 15,
			weight: .semibold,
			color: .labelColor
			)
			let countLayer = makeTextLayer(
			string: "\(space.windowCount)",
			fontSize: 12,
			weight: .medium,
			color: .secondaryLabelColor,
			alignment: .center
			)
			let appLayer = makeTextLayer(
			string: appIdentifierText(for: space.appNames),
			fontSize: 12,
			weight: .regular,
			color: .secondaryLabelColor
			)
			let windowBlocks = makeWindowBlocks(count: min(space.windowCount, 5), space: space)
			let fullscreenMarkerLayer = makeFullscreenMarkerLayer(for: space)
			for display in currentViewModel?.displays ?? [] {
			let groupContainer = CALayer()
			groupContainer.name = display.displayLabel
			groupContainer.cornerRadius = 14
			groupContainer.masksToBounds = false
			groupContainer.borderWidth = 0
			groupContainer.borderColor = NSColor.clear.cgColor
			groupContainer.backgroundColor = themePalette.displayGroupBackground.cgColor
			groupContainer.shadowColor = NSColor.black.cgColor
			groupContainer.shadowOpacity = 0
			groupContainer.shadowRadius = 0
			groupContainer.shadowOffset = .zero

			container.addSublayer(labelLayer)
			container.addSublayer(countLayer)
			container.addSublayer(appLayer)
			if let fullscreenMarkerLayer {
			container.addSublayer(fullscreenMarkerLayer)
			let segments = display.spaces.map { space in
			let container = CAGradientLayer()
			container.name = space.label
			container.cornerRadius = 10
			container.borderWidth = 1
			container.borderColor = NSColor.separatorColor.withAlphaComponent(0.34).cgColor
			container.backgroundColor = NSColor.clear.cgColor
			container.startPoint = CGPoint(x: 0.5, y: 1.0)
			container.endPoint = CGPoint(x: 0.5, y: 0.0)
			container.shadowColor = NSColor.black.cgColor

			let labelLayer = makeTextLayer(
			string: space.label,
			fontSize: 15,
			weight: .semibold,
			color: themePalette.spaceLanePrimaryText
			)
			let countLayer = makeTextLayer(
			string: "\(space.windowCount)",
			fontSize: 12,
			weight: .medium,
			color: themePalette.spaceLaneSecondaryText,
			alignment: .center
			)
			let appLayer = makeTextLayer(
			string: appIdentifierText(for: space),
			fontSize: 12,
			weight: space.type == .fullscreen ? .medium : .regular,
			color: space.type == .fullscreen ? themePalette.spaceLanePrimaryText : themePalette.spaceLaneSecondaryText,
			alignment: space.type == .fullscreen ? .center : .left
			)
			let splitAppLayers = splitViewAppNames(for: space).map { name in
			makeTextLayer(
			string: name,
			fontSize: 12,
			weight: .medium,
			color: themePalette.spaceLanePrimaryText,
			alignment: .center
			)
			}
			let windowBlocks = space.type == .fullscreen
			? []
			: makeWindowBlocks(count: min(space.windowCount, 5), space: space)
			let fullscreenMarkerLayer = makeFullscreenMarkerLayer(for: space)

			container.addSublayer(labelLayer)
			container.addSublayer(countLayer)
			container.addSublayer(appLayer)
			if let fullscreenMarkerLayer {
			container.addSublayer(fullscreenMarkerLayer)
			}
			for splitAppLayer in splitAppLayers {
			container.addSublayer(splitAppLayer)
			}
			for block in windowBlocks {
			container.addSublayer(block)
			}
			groupContainer.addSublayer(container)

			return SpaceLaneSegmentLayers(
			space: space,
			containerLayer: container,
			labelLayer: labelLayer,
			countLayer: countLayer,
			appLayer: appLayer,
			splitAppLayers: splitAppLayers,
			windowBlocks: windowBlocks,
			fullscreenMarkerLayer: fullscreenMarkerLayer
			)
			}
			for block in windowBlocks {
			container.addSublayer(block)
			}
			spaceLaneContentLayer.addSublayer(container)

			return SpaceLaneSegmentLayers(
			space: space,
			containerLayer: container,
			labelLayer: labelLayer,
			countLayer: countLayer,
			appLayer: appLayer,
			windowBlocks: windowBlocks,
			fullscreenMarkerLayer: fullscreenMarkerLayer
			)
			spaceLaneContentLayer.addSublayer(groupContainer)
			groups.append(SpaceLaneDisplayGroupLayers(
			display: display,
			containerLayer: groupContainer,
			segments: segments
			))
			allSegments.append(contentsOf: segments)
			}

			spaceLaneDisplayGroups = groups
			spaceLaneSegments = allSegments
			}

			private func layoutLayers() {
			@@ -1499,6 +4127,7 @@
			CATransaction.setDisableActions(true)

			backgroundLayer.frame = bounds
			layoutBackdropLayers()

			let safeAreaTopInset = topSafeAreaInset
			safeAreaFillLayer.frame = CGRect(
			@@ -1539,8 +4168,284 @@
			layoutSpaceLaneSegments()
			layoutAppShelfItems()
			layoutWaterfallColumns()
			layoutCloseConfirmation()
			layoutCloseFeedback()
			layoutViewModeToggleButton()
			layoutThemeToggleButton()

			CATransaction.commit()
			}

			private func layoutViewModeToggleButton() {
			let size = ViewModeToggleMetrics.visualSize
			let topMargin = topSafeAreaInset + RootLayoutMetrics.topContentMargin
			let x = max(
			RootLayoutMetrics.horizontalMargin,
			glassLayer.bounds.width - RootLayoutMetrics.horizontalMargin - size
			)
			let y = max(
			RootLayoutMetrics.bottomMargin,
			glassLayer.bounds.height - topMargin - size
			)
			viewModeToggleButtonLayer.frame = CGRect(x: x, y: y, width: size, height: size)
			viewModeToggleButtonLayer.cornerRadius = ViewModeToggleMetrics.cornerRadius
			let visualState = viewModeToggleVisualState
			let isSelectedState = viewModeToggleVisualStateIsSelected(visualState)
			viewModeToggleButtonLayer.backgroundColor = (isSelectedState
			? viewModeToggleBlueColor
			: toggleIdleBackgroundColor(hovered: isViewModeToggleButtonHovered)
			).cgColor
			viewModeToggleButtonLayer.borderColor = (isSelectedState
			? viewModeToggleBlueColor.withAlphaComponent(0.96)
			: viewModeToggleBlueColor.withAlphaComponent(isViewModeToggleButtonHovered ? 0.72 : 0.34)
			).cgColor
			viewModeToggleButtonLayer.shadowOpacity = isSelectedState ? 0.16 : (isViewModeToggleButtonHovered ? 0.11 : 0.06)
			viewModeToggleButtonLayer.shadowRadius = isSelectedState
			? ViewModeToggleMetrics.selectedShadowRadius
			: ViewModeToggleMetrics.idleShadowRadius
			viewModeToggleIconLayer.contentsScale = backingScaleFactor
			let iconInset = ViewModeToggleMetrics.iconInset
			viewModeToggleIconLayer.frame = viewModeToggleButtonLayer.bounds.insetBy(dx: iconInset, dy: iconInset)
			layoutViewModeToggleIcon()
			}

			private func layoutThemeToggleButton() {
			let size = ViewModeToggleMetrics.visualSize
			let topMargin = topSafeAreaInset + RootLayoutMetrics.topContentMargin
			let viewModeFrame = viewModeToggleButtonLayer.frame
			let fallbackX = max(
			RootLayoutMetrics.horizontalMargin,
			glassLayer.bounds.width - RootLayoutMetrics.horizontalMargin - size * 2 - ThemeToggleMetrics.buttonGap
			)
			let x = max(
			RootLayoutMetrics.horizontalMargin,
			(viewModeFrame.width > 0 ? viewModeFrame.minX : fallbackX + size + ThemeToggleMetrics.buttonGap)
			- ThemeToggleMetrics.buttonGap
			- size
			)
			let y = max(
			RootLayoutMetrics.bottomMargin,
			glassLayer.bounds.height - topMargin - size
			)
			themeToggleButtonLayer.frame = CGRect(x: x, y: y, width: size, height: size)
			themeToggleButtonLayer.cornerRadius = ViewModeToggleMetrics.cornerRadius
			let isSelectedState = resolvedTheme == .dark
			themeToggleButtonLayer.backgroundColor = (isSelectedState
			? viewModeToggleBlueColor
			: themeToggleIdleBackgroundColor
			).cgColor
			themeToggleButtonLayer.borderColor = (isSelectedState
			? viewModeToggleBlueColor.withAlphaComponent(0.96)
			: viewModeToggleBlueColor.withAlphaComponent(isThemeToggleButtonHovered ? 0.72 : 0.34)
			).cgColor
			themeToggleButtonLayer.shadowOpacity = isSelectedState ? 0.18 : (isThemeToggleButtonHovered ? 0.12 : 0.06)
			themeToggleButtonLayer.shadowRadius = isSelectedState
			? ViewModeToggleMetrics.selectedShadowRadius
			: ViewModeToggleMetrics.idleShadowRadius
			themeToggleIconLayer.contentsScale = backingScaleFactor
			let iconInset = ViewModeToggleMetrics.iconInset
			themeToggleIconLayer.frame = themeToggleButtonLayer.bounds.insetBy(dx: iconInset, dy: iconInset)
			layoutThemeToggleIcon()
			}

			private func layoutViewModeToggleIcon() {
			CATransaction.begin()
			CATransaction.setDisableActions(true)
			viewModeToggleIconLayer.sublayers?.forEach { $0.removeFromSuperlayer() }

			let bounds = viewModeToggleIconLayer.bounds
			guard bounds.width > 0, bounds.height > 0 else {
			CATransaction.commit()
			return
			}

			let visualState = viewModeToggleVisualState
			let isSelectedState = viewModeToggleVisualStateIsSelected(visualState)
			let strokeColor = isSelectedState
			? NSColor.white.withAlphaComponent(0.98)
			: viewModeToggleBlueColor.withAlphaComponent(0.96)
			let fillColor = isSelectedState
			? NSColor.white.withAlphaComponent(0.22)
			: viewModeToggleBlueColor.withAlphaComponent(0.06)
			let glyphRect = centeredSquare(in: bounds)

			switch visualState {
			case .verticalAvailable, .verticalSelected:
			addVerticalColumnsToggleGlyph(
			in: glyphRect,
			strokeColor: strokeColor,
			fillColor: fillColor
			)
			case .horizontalAvailable, .horizontalSelected:
			addHorizontalMasonryToggleGlyph(
			in: glyphRect,
			strokeColor: strokeColor,
			fillColor: fillColor
			)
			}

			CATransaction.commit()
			}

			private func layoutThemeToggleIcon() {
			CATransaction.begin()
			CATransaction.setDisableActions(true)
			themeToggleIconLayer.sublayers?.forEach { $0.removeFromSuperlayer() }

			let bounds = themeToggleIconLayer.bounds
			guard bounds.width > 0, bounds.height > 0 else {
			CATransaction.commit()
			return
			}

			let isSelectedState = resolvedTheme == .dark
			let strokeColor = isSelectedState
			? NSColor.white.withAlphaComponent(0.98)
			: viewModeToggleBlueColor.withAlphaComponent(0.96)
			let lightFillColor = isSelectedState
			? NSColor.white.withAlphaComponent(0.22)
			: viewModeToggleBlueColor.withAlphaComponent(0.06)
			let darkFillColor = isSelectedState
			? NSColor.white.withAlphaComponent(0.96)
			: viewModeToggleBlueColor.withAlphaComponent(0.82)
			let glyphRect = centeredSquare(in: bounds).insetBy(dx: 0.75, dy: 0.75)
			addThemeToggleHalfDiskGlyph(
			in: glyphRect,
			strokeColor: strokeColor,
			lightFillColor: lightFillColor,
			darkFillColor: darkFillColor
			)

			CATransaction.commit()
			}

			private func addThemeToggleHalfDiskGlyph(
			in rect: CGRect,
			strokeColor: NSColor,
			lightFillColor: NSColor,
			darkFillColor: NSColor
			) {
			let circlePath = CGPath(
			ellipseIn: rect,
			transform: nil
			)
			let baseLayer = CAShapeLayer()
			baseLayer.contentsScale = backingScaleFactor
			baseLayer.frame = themeToggleIconLayer.bounds
			baseLayer.path = circlePath
			baseLayer.fillColor = lightFillColor.cgColor
			baseLayer.strokeColor = NSColor.clear.cgColor
			themeToggleIconLayer.addSublayer(baseLayer)

			let radius = min(rect.width, rect.height) / 2
			let center = CGPoint(x: rect.midX, y: rect.midY)
			let halfPath = CGMutablePath()
			halfPath.move(to: CGPoint(x: center.x, y: center.y + radius))
			halfPath.addArc(
			center: center,
			radius: radius,
			startAngle: .pi / 2,
			endAngle: .pi * 1.5,
			clockwise: false
			)
			halfPath.closeSubpath()

			let halfLayer = CAShapeLayer()
			halfLayer.contentsScale = backingScaleFactor
			halfLayer.frame = themeToggleIconLayer.bounds
			halfLayer.path = halfPath
			halfLayer.fillColor = darkFillColor.cgColor
			halfLayer.strokeColor = NSColor.clear.cgColor
			themeToggleIconLayer.addSublayer(halfLayer)

			let outlineLayer = CAShapeLayer()
			outlineLayer.contentsScale = backingScaleFactor
			outlineLayer.frame = themeToggleIconLayer.bounds
			outlineLayer.path = circlePath
			outlineLayer.fillColor = NSColor.clear.cgColor
			outlineLayer.strokeColor = strokeColor.cgColor
			outlineLayer.lineWidth = ViewModeToggleMetrics.glyphLineWidth
			outlineLayer.lineJoin = .round
			themeToggleIconLayer.addSublayer(outlineLayer)
			}

			private func addVerticalColumnsToggleGlyph(
			in rect: CGRect,
			strokeColor: NSColor,
			fillColor: NSColor
			) {
			let columnWidth = rect.width * 0.22
			let gap = (rect.width - columnWidth * 3) / 2
			for index in 0..<3 {
			let x = rect.minX + CGFloat(index) * (columnWidth + gap)
			let columnRect = CGRect(x: x, y: rect.minY, width: columnWidth, height: rect.height)
			addViewModeToggleRoundedRect(
			columnRect,
			cornerRadius: ViewModeToggleMetrics.glyphCornerRadius,
			strokeColor: strokeColor,
			fillColor: fillColor,
			lineWidth: ViewModeToggleMetrics.glyphLineWidth
			)
			}
			}

			private func addHorizontalMasonryToggleGlyph(
			in rect: CGRect,
			strokeColor: NSColor,
			fillColor: NSColor
			) {
			let cellSize = rect.width * 0.38
			let gap = rect.width - cellSize * 2
			for row in 0..<2 {
			for column in 0..<2 {
			let cellRect = CGRect(
			x: rect.minX + CGFloat(column) * (cellSize + gap),
			y: rect.minY + CGFloat(row) * (cellSize + gap),
			width: cellSize,
			height: cellSize
			)
			addViewModeToggleRoundedRect(
			cellRect,
			cornerRadius: ViewModeToggleMetrics.glyphCornerRadius,
			strokeColor: strokeColor,
			fillColor: fillColor,
			lineWidth: ViewModeToggleMetrics.glyphLineWidth
			)
			}
			}
			}

			private func addViewModeToggleRoundedRect(
			_ rect: CGRect,
			cornerRadius: CGFloat,
			strokeColor: NSColor,
			fillColor: NSColor,
			lineWidth: CGFloat
			) {
			let layer = CAShapeLayer()
			layer.contentsScale = backingScaleFactor
			layer.frame = viewModeToggleIconLayer.bounds
			layer.path = CGPath(
			roundedRect: rect,
			cornerWidth: cornerRadius,
			cornerHeight: cornerRadius,
			transform: nil
			)
			layer.fillColor = fillColor.cgColor
			layer.strokeColor = strokeColor.cgColor
			layer.lineWidth = lineWidth
			layer.lineJoin = .round
			viewModeToggleIconLayer.addSublayer(layer)
			}

			private func centeredSquare(in rect: CGRect) -> CGRect {
			let side = min(rect.width, rect.height)
			return CGRect(
			x: rect.midX - side / 2,
			y: rect.midY - side / 2,
			width: side,
			height: side
			)
			}

			private var topSafeAreaInset: CGFloat {
			@@ -1622,15 +4527,34 @@
			}

			private func layoutSpaceLaneSegments() {
			guard !spaceLaneSegments.isEmpty else { return }
			guard !spaceLaneDisplayGroups.isEmpty, !spaceLaneSegments.isEmpty else { return }

			let gap: CGFloat = 10
			let segmentHeight = max(1, laneLayer.bounds.height - 20)
			let availableWidth = laneLayer.bounds.width - 24 - CGFloat(spaceLaneSegments.count - 1) * gap
			let segmentWidth = max(96, min(150, availableWidth / CGFloat(spaceLaneSegments.count)))
			let groupOuterVerticalInset: CGFloat = 6
			let groupHeight = max(1, laneLayer.bounds.height - groupOuterVerticalInset * 2)
			let segmentHeight = max(1, groupHeight - SpaceLaneMetrics.groupVerticalPadding * 2)
			let groupGapWidth = CGFloat(max(0, spaceLaneDisplayGroups.count - 1)) * SpaceLaneMetrics.groupGap
			let segmentGapWidth = spaceLaneDisplayGroups.reduce(CGFloat(0)) { total, group in
			total + CGFloat(max(0, group.segments.count - 1)) * SpaceLaneMetrics.segmentGap
			}
			let groupPaddingWidth = CGFloat(spaceLaneDisplayGroups.count) * SpaceLaneMetrics.groupHorizontalPadding * 2
			let availableWidth = laneLayer.bounds.width
			- SpaceLaneMetrics.horizontalPadding * 2
			- groupGapWidth
			- segmentGapWidth
			- groupPaddingWidth
			let segmentWidth = max(
			SpaceLaneMetrics.segmentMinWidth,
			min(SpaceLaneMetrics.segmentMaxWidth, availableWidth / CGFloat(spaceLaneSegments.count))
			)
			let groupWidths = spaceLaneDisplayGroups.map { group in
			SpaceLaneMetrics.groupHorizontalPadding * 2
			+ CGFloat(group.segments.count) * segmentWidth
			+ CGFloat(max(0, group.segments.count - 1)) * SpaceLaneMetrics.segmentGap
			}
			let segmentGroupWidth = groupWidths.reduce(0, +) + groupGapWidth
			spaceLaneContentWidth = max(
			laneLayer.bounds.width,
			24 + CGFloat(spaceLaneSegments.count) * segmentWidth + CGFloat(spaceLaneSegments.count - 1) * gap
			SpaceLaneMetrics.horizontalPadding * 2 + segmentGroupWidth
			)
			spaceLaneScrollOffset = clampedSpaceLaneOffset(spaceLaneScrollOffset)
			spaceLaneContentLayer.frame = CGRect(
			@@ -1640,13 +4564,35 @@
			height: laneLayer.bounds.height
			)

			var x: CGFloat = 12
			var x = max(
			SpaceLaneMetrics.horizontalPadding,
			(spaceLaneContentWidth - segmentGroupWidth) / 2
			)

			for segment in spaceLaneSegments {
			segment.containerLayer.frame = CGRect(x: x, y: 10, width: segmentWidth, height: segmentHeight)
			applySpaceLaneVisualState(segment)
			layoutSpaceLaneSegmentContents(segment)
			x += segmentWidth + gap
			for (index, group) in spaceLaneDisplayGroups.enumerated() {
			let groupWidth = groupWidths[index]
			group.containerLayer.frame = CGRect(
			x: x,
			y: groupOuterVerticalInset,
			width: groupWidth,
			height: groupHeight
			)
			applySpaceLaneDisplayGroupVisualState(group)

			var segmentX = SpaceLaneMetrics.groupHorizontalPadding
			for segment in group.segments {
			segment.containerLayer.frame = CGRect(
			x: segmentX,
			y: SpaceLaneMetrics.groupVerticalPadding,
			width: segmentWidth,
			height: segmentHeight
			)
			applySpaceLaneVisualState(segment)
			layoutSpaceLaneSegmentContents(segment)
			segmentX += segmentWidth + SpaceLaneMetrics.segmentGap
			}

			x += groupWidth + SpaceLaneMetrics.groupGap
			}
			}

			@@ -1658,32 +4604,145 @@
			min(max(0, offset), spaceLaneMaxScrollOffset)
			}

			private func applySpaceLaneVisualState(_ segment: SpaceLaneSegmentLayers) {
			let isHovered = segment.space.id == hoveredSpaceID
			let isFocused = segment.space.id == activeSpaceFocusID
			let isCurrent = segment.space.isCurrent
			let isActive = isHovered \|\| isFocused
			private func applySpaceLaneDisplayGroupVisualState(_ group: SpaceLaneDisplayGroupLayers) {
			let hasActiveSegment = group.segments.contains { segment in
			segment.space.id == activeSpaceFocusID
			\|\| appHoverAssociatedSpaceIDs.contains(segment.space.id)
			\|\| segment.space.id == windowHoverAssociatedSpaceID
			\|\| segment.space.id == currentViewModel?.lockedSpaceID
			}
			let hasCurrentSegment = group.display.spaces.contains { $0.isCurrent }
			group.containerLayer.backgroundColor = themePalette.displayGroupBackground.cgColor
			group.containerLayer.borderColor = NSColor.clear.cgColor
			group.containerLayer.borderWidth = 0
			group.containerLayer.shadowOpacity = 0
			group.containerLayer.shadowRadius = 0
			group.containerLayer.shadowOffset = .zero
			group.containerLayer.zPosition = hasActiveSegment ? 8 : hasCurrentSegment ? 4 : 0
			group.containerLayer.shadowPath = nil
			}

			segment.containerLayer.borderWidth = isCurrent ? 1.5 : 1
			segment.containerLayer.borderColor = (isCurrent
			? NSColor.labelColor.withAlphaComponent(0.34)
			private func applySpaceLaneVisualState(_ segment: SpaceLaneSegmentLayers) {
			let isHovered = segment.space.id == activeSpaceFocusID
			let isFocused = segment.space.id == activeSpaceFocusID
			let isLocked = segment.space.id == currentViewModel?.lockedSpaceID
			let isCurrent = segment.space.isCurrent
			let hasWindows = segment.space.windowCount > 0
			let isAppAssociated = appHoverAssociatedSpaceIDs.contains(segment.space.id)
			let isWindowAssociated = segment.space.id == windowHoverAssociatedSpaceID
			let isActive = isHovered \|\| isFocused \|\| isLocked
			let isAssociated = (isAppAssociated \|\| isWindowAssociated) && !isActive

			segment.containerLayer.borderWidth = (hasWindows \|\| isCurrent \|\| isActive \|\| isAssociated) ? 1.5 : 1
			segment.containerLayer.borderColor = (isLocked
			? NSColor.white.withAlphaComponent(0.86)
			: isActive
			? NSColor.labelColor.withAlphaComponent(0.24)
			: NSColor.separatorColor.withAlphaComponent(0.34)
			? spaceLaneOccupiedColor.withAlphaComponent(isLocked ? 0.92 : 0.62)
			: isAssociated
			? spaceLaneOccupiedColor.withAlphaComponent(0.50)
			: hasWindows
			? spaceLaneOccupiedColor.withAlphaComponent(isCurrent ? 0.54 : 0.44)
			: isCurrent
			? themePalette.spaceLanePrimaryText.withAlphaComponent(0.34)
			: themePalette.columnBorder.withAlphaComponent(resolvedTheme == .dark ? 0.58 : 0.34)
			).cgColor
			segment.containerLayer.backgroundColor = (isActive
			? NSColor.windowBackgroundColor.withAlphaComponent(0.76)
			: spaceColor(for: segment.space)
			).cgColor
			segment.containerLayer.shadowOpacity = isCurrent ? 0.12 : isActive ? 0.08 : 0
			segment.containerLayer.shadowRadius = isCurrent ? 10 : isActive ? 7 : 0
			segment.containerLayer.shadowOffset = CGSize(width: 0, height: isCurrent ? -2 : -1)
			segment.containerLayer.shadowPath = CGPath(
			roundedRect: segment.containerLayer.bounds,
			cornerWidth: segment.containerLayer.cornerRadius,
			cornerHeight: segment.containerLayer.cornerRadius,
			transform: nil
			if isLocked {
			applySpaceLaneSolidFill(
			to: segment.containerLayer,
			color: spaceLaneLockedFillColor
			)
			} else if !hasWindows {
			applySpaceLaneSolidFill(to: segment.containerLayer, color: .clear)
			} else if isActive {
			applySpaceLaneSolidFill(
			to: segment.containerLayer,
			color: accentTintedWindowBackground(fraction: 0.10, alpha: 0.94)
			)
			} else if isAssociated {
			applySpaceLaneSolidFill(
			to: segment.containerLayer,
			color: accentTintedWindowBackground(fraction: 0.07, alpha: 0.90)
			)
			} else if hasWindows {
			applySpaceLaneGradientFill(
			to: segment.containerLayer,
			colors: spaceLaneIdleOccupiedGradientColors()
			)
			}
			segment.containerLayer.shadowColor = isLocked
			? NSColor.white.withAlphaComponent(0.98).cgColor
			: NSColor.black.cgColor
			segment.containerLayer.shadowOpacity = (hasWindows \|\| isLocked)
			? (isLocked ? 0.72 : isActive ? 0.26 : isAssociated ? 0.18 : isCurrent ? 0.14 : 0)
			: 0
			segment.containerLayer.shadowRadius = (hasWindows \|\| isLocked)
			? (isLocked ? 30 : isActive ? 24 : isAssociated ? 18 : isCurrent ? 12 : 0)
			: 0
			segment.containerLayer.shadowOffset = CGSize(
			width: 0,
			height: (hasWindows \|\| isLocked) ? (isLocked ? 0 : isActive ? -6 : isAssociated ? -4 : isCurrent ? -2.5 : 0) : 0
			)
			segment.containerLayer.zPosition = isLocked ? 42 : isActive ? 30 : isAssociated ? 18 : isCurrent ? 10 : 0
			segment.containerLayer.transform = (isActive \|\| isAssociated)
			? CATransform3DMakeScale(isActive ? 1.03 : 1.015, isActive ? 1.03 : 1.015, 1)
			: CATransform3DIdentity
			segment.containerLayer.shadowPath = (hasWindows \|\| isLocked)
			? CGPath(
			roundedRect: segment.containerLayer.bounds,
			cornerWidth: segment.containerLayer.cornerRadius,
			cornerHeight: segment.containerLayer.cornerRadius,
			transform: nil
			)
			: nil

			applySpaceLaneContentVisualState(
			segment,
			isLocked: isLocked,
			usesLightActiveFill: resolvedTheme == .dark && hasWindows && !isLocked && (isActive \|\| isAssociated)
			)
			}

			private func applySpaceLaneContentVisualState(
			_ segment: SpaceLaneSegmentLayers,
			isLocked: Bool,
			usesLightActiveFill: Bool
			) {
			let primaryTextColor: NSColor = isLocked
			? .white
			: usesLightActiveFill
			? NSColor.black.withAlphaComponent(0.82)
			: themePalette.spaceLanePrimaryText
			let secondaryTextColor: NSColor = isLocked
			? .white
			: usesLightActiveFill
			? NSColor.black.withAlphaComponent(0.58)
			: themePalette.spaceLaneSecondaryText
			let markerTextColor: NSColor = isLocked
			? .white
			: usesLightActiveFill
			? NSColor.black.withAlphaComponent(0.62)
			: themePalette.spaceLaneSecondaryText.withAlphaComponent(segment.space.isCurrent ? 0.72 : 0.54)
			let blockColor: NSColor = isLocked
			? .white
			: usesLightActiveFill
			? NSColor.black.withAlphaComponent(0.20)
			: spaceLaneOccupiedColor.withAlphaComponent(segment.space.isCurrent ? 0.72 : 0.58)

			segment.labelLayer.foregroundColor = primaryTextColor.cgColor
			segment.countLayer.foregroundColor = secondaryTextColor.cgColor
			segment.appLayer.foregroundColor = (segment.space.type == .fullscreen
			? primaryTextColor
			: secondaryTextColor
			).cgColor
			for splitAppLayer in segment.splitAppLayers {
			splitAppLayer.foregroundColor = primaryTextColor.cgColor
			}

			for block in segment.windowBlocks {
			block.backgroundColor = blockColor.cgColor
			}

			(segment.fullscreenMarkerLayer as? CAShapeLayer)?.strokeColor = markerTextColor.cgColor
			}

			private func shouldScrollSpaceLane(for event: NSEvent) -> Bool {
			@@ -1724,50 +4783,177 @@

			private func spaceLaneSegment(at windowLocation: CGPoint) -> SpaceLaneSegmentLayers? {
			let locationInView = convert(windowLocation, from: nil)

			// 严格 band 检查：只有鼠标在 lane 的垂直 band 内才考虑是 lane hover。
			// 防止“完全空的地方”（y 不在 lane 高度范围内）误 hit 到 segment frame，
			// 导致 hoveredSpaceLaneID 粘住、activeSpaceFocusID 非 nil、窗口 spaceFocused 高亮。
			let laneMinYInView = glassLayer.frame.minY + laneLayer.frame.minY
			let laneMaxYInView = laneMinYInView + laneLayer.frame.height
			if locationInView.y < laneMinYInView \|\| locationInView.y > laneMaxYInView {
			return nil
			}

			let locationInSpaceLaneContent = CGPoint(
			x: locationInView.x - glassLayer.frame.minX - laneLayer.frame.minX - spaceLaneContentLayer.frame.minX,
			y: locationInView.y - glassLayer.frame.minY - laneLayer.frame.minY - spaceLaneContentLayer.frame.minY
			)

			return spaceLaneSegments.first { segment in
			segment.containerLayer.frame.contains(locationInSpaceLaneContent)
			for group in spaceLaneDisplayGroups where group.containerLayer.frame.contains(locationInSpaceLaneContent) {
			let locationInGroup = CGPoint(
			x: locationInSpaceLaneContent.x - group.containerLayer.frame.minX,
			y: locationInSpaceLaneContent.y - group.containerLayer.frame.minY
			)
			if let segment = group.segments.first(where: { $0.containerLayer.frame.contains(locationInGroup) }) {
			return segment
			}
			}

			return nil
			}

			private func spaceLaneSegment(spaceID: UInt64) -> SpaceLaneSegmentLayers? {
			spaceLaneSegments.first { $0.space.id == spaceID }
			}

			private func appShelfItem(at windowLocation: CGPoint) -> AppShelfItemLayers? {
			private func viewModeToggleButtonContains(windowLocation: CGPoint) -> Bool {
			let locationInView = convert(windowLocation, from: nil)
			let locationInShelfContent = CGPoint(
			x: locationInView.x - glassLayer.frame.minX - shelfLayer.frame.minX - appShelfContentLayer.frame.minX,
			y: locationInView.y - glassLayer.frame.minY - shelfLayer.frame.minY - appShelfContentLayer.frame.minY
			let locationInGlass = CGPoint(
			x: locationInView.x - glassLayer.frame.minX,
			y: locationInView.y - glassLayer.frame.minY
			)
			let hitOutset = (ViewModeToggleMetrics.hitSize - ViewModeToggleMetrics.visualSize) / 2
			return viewModeToggleButtonLayer.frame
			.insetBy(dx: -hitOutset, dy: -hitOutset)
			.contains(locationInGlass)
			}

			private func themeToggleButtonContains(windowLocation: CGPoint) -> Bool {
			let locationInView = convert(windowLocation, from: nil)
			let locationInGlass = CGPoint(
			x: locationInView.x - glassLayer.frame.minX,
			y: locationInView.y - glassLayer.frame.minY
			)
			let hitOutset = (ViewModeToggleMetrics.hitSize - ViewModeToggleMetrics.visualSize) / 2
			return themeToggleButtonLayer.frame
			.insetBy(dx: -hitOutset, dy: -hitOutset)
			.contains(locationInGlass)
			}

			private func clickViewModeToggleButton(source: String) {
			DevelopmentDiagnostics.log("quickSwitch.view.clickWaterfallViewModeToggle", [
			"source": source,
			"currentMode": waterfallViewMode.rawValue,
			"targetMode": nextWaterfallViewMode.rawValue
			])
			lastMouseCommand = "click-view-toggle"
			if !mouseCommandsApplied.contains("click-view-toggle") {
			mouseCommandsApplied.append("click-view-toggle")
			}
			isViewModeToggleButtonHovered = false
			suppressViewModeToggleHoverPreview = true
			onToggleWaterfallViewMode?()
			}

			private func clickThemeToggleButton(source: String) {
			DevelopmentDiagnostics.log("quickSwitch.view.clickThemeToggle", [
			"source": source,
			"currentTheme": resolvedTheme.rawValue,
			"targetTheme": nextThemePreference.rawValue
			])
			lastMouseCommand = "click-theme-toggle"
			if !mouseCommandsApplied.contains("click-theme-toggle") {
			mouseCommandsApplied.append("click-theme-toggle")
			}
			isThemeToggleButtonHovered = false
			suppressThemeToggleHoverPreview = true
			onToggleTheme?()
			}

			private func appShelfItem(at windowLocation: CGPoint) -> AppShelfItemLayers? {
			let locationInShelfContent = appShelfContentLocation(at: windowLocation)

			return appShelfItems.first { item in
			item.containerLayer.frame.contains(locationInShelfContent)
			interactiveFrame(for: item.containerLayer).contains(locationInShelfContent)
			}
			}

			private func appShelfIconItem(at windowLocation: CGPoint) -> AppShelfItemLayers? {
			let locationInAppShelfContent = appShelfContentLocation(at: windowLocation)

			return appShelfItems.first { item in
			let itemFrame = interactiveFrame(for: item.containerLayer)
			let locationInItem = CGPoint(
			x: locationInAppShelfContent.x - itemFrame.minX,
			y: locationInAppShelfContent.y - itemFrame.minY
			)
			return interactiveFrame(for: item.iconLayer).contains(locationInItem)
			}
			}

			private func appShelfContentLocation(at windowLocation: CGPoint) -> CGPoint {
			let locationInView = convert(windowLocation, from: nil)
			let glassFrame = interactiveFrame(for: glassLayer)
			let shelfFrame = interactiveFrame(for: shelfLayer)
			let appShelfContentFrame = interactiveFrame(for: appShelfContentLayer)

			return CGPoint(
			x: locationInView.x - glassFrame.minX - shelfFrame.minX - appShelfContentFrame.minX,
			y: locationInView.y - glassFrame.minY - shelfFrame.minY - appShelfContentFrame.minY
			)
			}

			private func appShelfItemCenterWindowLocation(for appGroupIndex: Int) -> CGPoint? {
			guard let item = appShelfItems.first(where: { $0.item.appGroupIndex == appGroupIndex }) else {
			return nil
			}

			let pointInView = CGPoint(
			x: glassLayer.frame.minX
			+ shelfLayer.frame.minX
			+ appShelfContentLayer.frame.minX
			+ item.containerLayer.frame.midX,
			y: glassLayer.frame.minY
			+ shelfLayer.frame.minY
			+ appShelfContentLayer.frame.minY
			+ item.containerLayer.frame.midY
			)
			return convert(pointInView, to: nil)
			}

			private func waterfallCard(at windowLocation: CGPoint) -> WaterfallCardLayers? {
			let locationInView = convert(windowLocation, from: nil)
			let glassFrame = interactiveFrame(for: glassLayer)
			let waterfallFrame = interactiveFrame(for: waterfallLayer)
			let waterfallContentFrame = interactiveFrame(for: waterfallContentLayer)
			let locationInWaterfallContent = CGPoint(
			x: locationInView.x - glassLayer.frame.minX - waterfallLayer.frame.minX - waterfallContentLayer.frame.minX,
			y: locationInView.y - glassLayer.frame.minY - waterfallLayer.frame.minY - waterfallContentLayer.frame.minY
			x: locationInView.x - glassFrame.minX - waterfallFrame.minX - waterfallContentFrame.minX,
			y: locationInView.y - glassFrame.minY - waterfallFrame.minY - waterfallContentFrame.minY
			)

			for column in waterfallColumns where column.containerLayer.frame.contains(locationInWaterfallContent) {
			for column in waterfallColumns where interactiveFrame(for: column.containerLayer).contains(locationInWaterfallContent) {
			let columnFrame = interactiveFrame(for: column.containerLayer)
			let cardsClipFrame = interactiveFrame(for: column.cardsClipLayer)
			let locationInColumn = CGPoint(
			x: locationInWaterfallContent.x - column.containerLayer.frame.minX,
			y: locationInWaterfallContent.y - column.containerLayer.frame.minY
			x: locationInWaterfallContent.x - columnFrame.minX,
			y: locationInWaterfallContent.y - columnFrame.minY
			)
			if let card = column.cards.first(where: { $0.containerLayer.frame.contains(locationInColumn) }) {
			guard cardsClipFrame.contains(locationInColumn) else {
			continue
			}
			let locationInCardsClip = CGPoint(
			x: locationInColumn.x - cardsClipFrame.minX,
			y: locationInColumn.y - cardsClipFrame.minY
			)
			if let card = column.cards.first(where: { interactiveFrame(for: $0.containerLayer).contains(locationInCardsClip) }) {
			return card
			}
			}

			return nil
			}

			private func interactiveFrame(for layer: CALayer) -> CGRect {
			layer.presentation()?.frame ?? layer.frame
			}

			private func waterfallCard(appGroupIndex: Int, windowIndex: Int) -> WaterfallCardLayers? {
			@@ -1777,12 +4963,71 @@
			.first(where: { $0.item.windowIndex == windowIndex })
			}

			private func waterfallCard(appGroupIndex: Int, windowIndexSymbol: String) -> WaterfallCardLayers? {
			guard let ordinal = Self.appShelfIndexSymbols.firstIndex(of: windowIndexSymbol),
			ordinal < Self.appShelfIndexSymbols.count
			else {
			return nil
			}
			return waterfallCard(appGroupIndex: appGroupIndex, windowIndex: ordinal)
			}

			private func waterfallCard(windowID: UInt32) -> WaterfallCardLayers? {
			waterfallColumns
			.lazy
			.flatMap(\.cards)
			.first(where: { $0.item.window.id == windowID })
			}

			private func layoutSpaceLaneSegmentContents(_ segment: SpaceLaneSegmentLayers) {
			let bounds = segment.containerLayer.bounds
			let splitAppNames = splitViewAppNames(for: segment.space)
			let isSplitView = splitAppNames.count >= 2
			segment.labelLayer.frame = CGRect(x: 10, y: bounds.height - 29, width: max(1, bounds.width - 48), height: 20)
			segment.countLayer.frame = CGRect(x: bounds.width - 34, y: bounds.height - 29, width: 24, height: 20)
			segment.appLayer.frame = CGRect(x: 10, y: 9, width: max(1, bounds.width - 20), height: 17)
			segment.fullscreenMarkerLayer?.frame = CGRect(x: 10, y: bounds.height - 7, width: max(1, bounds.width - 20), height: 3)
			segment.countLayer.string = isSplitView ? "" : "\(segment.space.windowCount)"
			segment.countLayer.isHidden = isSplitView
			if segment.space.type == .fullscreen {
			let markerFrame = fullscreenMarkerFrame(in: bounds)
			segment.appLayer.isHidden = isSplitView
			if isSplitView {
			let labelY = markerFrame.midY - 8.5
			let halfWidth = markerFrame.width / 2
			for (index, splitAppLayer) in segment.splitAppLayers.enumerated() {
			let x = markerFrame.minX + CGFloat(index) * halfWidth
			splitAppLayer.isHidden = false
			splitAppLayer.frame = CGRect(
			x: x + 4,
			y: labelY,
			width: max(1, halfWidth - 8),
			height: 17
			)
			}
			} else {
			segment.appLayer.frame = CGRect(
			x: 8,
			y: markerFrame.midY - 8.5,
			width: max(1, bounds.width - 16),
			height: 17
			)
			for splitAppLayer in segment.splitAppLayers {
			splitAppLayer.isHidden = true
			}
			}
			} else {
			segment.appLayer.isHidden = false
			segment.appLayer.frame = CGRect(x: 10, y: 9, width: max(1, bounds.width - 20), height: 17)
			for splitAppLayer in segment.splitAppLayers {
			splitAppLayer.isHidden = true
			}
			}
			if let fullscreenMarkerLayer = segment.fullscreenMarkerLayer {
			layoutFullscreenMarkerLayer(
			fullscreenMarkerLayer,
			in: bounds,
			isSplitView: isSplitView
			)
			}

			let blockGap: CGFloat = 5
			let blockWidth = max(12, min(22, (bounds.width - 20 - CGFloat(max(0, segment.windowBlocks.count - 1)) * blockGap) / CGFloat(max(1, segment.windowBlocks.count))))
			@@ -1843,39 +5088,88 @@
			let bounds = item.containerLayer.bounds
			let isSelected = item.item.appGroupIndex == effectiveSelection?.appGroupIndex
			let isHovered = item.item.appGroupIndex == effectiveHoveredAppGroupIndex
			let showsSelectedVisual = shouldShowSelectedVisual(isSelected: isSelected, isHovered: isHovered)
			let isSpaceFocused = spaceFocusWindowCount(for: item.item.appGroupIndex) > 0
			let visualIconSize = appShelfVisualIconSize(forBaseIconSize: iconSize, selected: isSelected, hovered: isHovered)
			let backgroundPadding: CGFloat = (isSelected \|\| isHovered) ? 4 : 2
			let magneticState = appShelfMagneticState(for: item)
			let visualIconSize = appShelfVisualIconSize(
			forBaseIconSize: iconSize,
			selected: showsSelectedVisual,
			hovered: isHovered,
			spaceFocused: isSpaceFocused,
			magneticState: magneticState
			)
			let backgroundPadding: CGFloat = isSpaceFocused ? 6 : 2
			let iconX = (bounds.width - visualIconSize) / 2
			let iconY = bounds.height - visualIconSize - 2
			let iconY = bounds.height - visualIconSize - 2 + magneticState.lift
			let badgeText = appShelfBadgeText(for: item)
			let badgeWidth = max(18, CGFloat(badgeText.count) * 7 + 8)

			item.containerLayer.zPosition = appShelfZPosition(selected: isSelected, hovered: isHovered)
			item.backgroundLayer.backgroundColor = appShelfBackgroundColor(
			selected: isSelected,
			let previousBackgroundFrame = item.backgroundLayer.presentation()?.frame ?? item.backgroundLayer.frame
			let previousIconFrame = item.iconLayer.presentation()?.frame ?? item.iconLayer.frame
			let previousIndexFrame = item.indexLayer.presentation()?.frame ?? item.indexLayer.frame
			let previousBadgeFrame = item.badgeLayer.presentation()?.frame ?? item.badgeLayer.frame
			let previousCloseFrame = item.closeButton.containerLayer.presentation()?.frame
			?? item.closeButton.containerLayer.frame

			item.containerLayer.zPosition = appShelfZPosition(
			selected: showsSelectedVisual,
			hovered: isHovered,
			spaceFocused: isSpaceFocused
			spaceFocused: isSpaceFocused,
			magneticState: magneticState
			)
			item.backgroundLayer.backgroundColor = appShelfBackgroundColor(
			selected: showsSelectedVisual,
			hovered: isHovered,
			spaceFocused: isSpaceFocused,
			magneticState: magneticState
			).cgColor
			item.backgroundLayer.borderColor = (isSelected
			? NSColor.separatorColor.withAlphaComponent(0.38)
			: isHovered
			? NSColor.separatorColor.withAlphaComponent(0.28)
			: NSColor.clear
			).cgColor
			item.backgroundLayer.borderWidth = (isSelected \|\| isHovered) ? 1 : 0
			item.backgroundLayer.borderColor = NSColor.clear.cgColor
			item.backgroundLayer.borderWidth = 0
			item.containerLayer.borderColor = NSColor.clear.cgColor
			item.containerLayer.borderWidth = 0
			item.iconLayer.borderColor = NSColor.clear.cgColor
			item.iconLayer.borderWidth = 0
			item.backgroundLayer.shadowColor = NSColor.black.cgColor
			item.backgroundLayer.shadowOpacity = isSelected ? 0.11 : isHovered ? 0.06 : 0
			item.backgroundLayer.shadowRadius = isSelected ? 10 : isHovered ? 7 : 0
			item.backgroundLayer.shadowOffset = CGSize(width: 0, height: -2)
			item.backgroundLayer.shadowOpacity = appShelfShadowOpacity(
			selected: showsSelectedVisual,
			hovered: isHovered,
			spaceFocused: isSpaceFocused,
			magneticState: magneticState
			)
			item.backgroundLayer.shadowRadius = appShelfShadowRadius(
			selected: showsSelectedVisual,
			hovered: isHovered,
			spaceFocused: isSpaceFocused,
			magneticState: magneticState
			)
			item.backgroundLayer.shadowOffset = CGSize(
			width: 0,
			height: isSpaceFocused ? -4 : magneticState.isNeighbor ? -1 : -2
			)
			item.backgroundLayer.frame = CGRect(
			x: iconX - backgroundPadding,
			y: iconY - backgroundPadding,
			width: visualIconSize + backgroundPadding * 2,
			height: visualIconSize + backgroundPadding * 2
			)
			item.backgroundLayer.shadowPath = isSpaceFocused
			? CGPath(
			roundedRect: item.backgroundLayer.bounds,
			cornerWidth: item.backgroundLayer.cornerRadius,
			cornerHeight: item.backgroundLayer.cornerRadius,
			transform: nil
			)
			: nil
			item.iconLayer.frame = CGRect(x: iconX, y: iconY, width: visualIconSize, height: visualIconSize)
			layoutAppShelfIndexLayer(
			item.indexLayer,
			iconFrame: item.iconLayer.frame,
			iconSize: visualIconSize,
			itemBounds: bounds,
			highlighted: showsSelectedVisual \|\| isHovered
			)
			item.labelLayer.contentsScale = backingScaleFactor
			item.labelLayer.foregroundColor = themePalette.appShelfLabelText.cgColor
			item.labelLayer.frame = CGRect(x: 0, y: 0, width: bounds.width, height: 14)
			item.badgeLayer.string = badgeText
			item.badgeLayer.isHidden = badgeText.isEmpty
			@@ -1889,8 +5183,83 @@
			width: badgeWidth,
			height: 16
			)
			layoutCloseButton(
			item.closeButton,
			target: .app(appGroupIndex: item.item.appGroupIndex),
			visible: isHovered && canClose(app: item.item.app),
			anchorTopRight: CGPoint(
			x: min(iconX + visualIconSize - 6, bounds.width - 12),
			y: min(iconY + visualIconSize - 6, bounds.height - 12)
			)
			)
			item.selectedIndicatorLayer.frame = .zero
			item.selectedIndicatorLayer.backgroundColor = NSColor.clear.cgColor

			animateAppShelfLayerFrame(item.backgroundLayer, from: previousBackgroundFrame)
			animateAppShelfLayerFrame(item.iconLayer, from: previousIconFrame)
			animateAppShelfLayerFrame(item.indexLayer, from: previousIndexFrame)
			animateAppShelfLayerFrame(item.badgeLayer, from: previousBadgeFrame)
			animateAppShelfLayerFrame(item.closeButton.containerLayer, from: previousCloseFrame)
			}

			private var appShelfIndexColor: NSColor {
			themePalette.appShelfIndexText
			}

			private var appShelfIndexHighlightedColor: NSColor {
			themePalette.appShelfIndexHighlightedText
			}

			private func appShelfIndexFont(size: CGFloat) -> NSFont {
			for fontName in ["Bradley Hand ITC", "Noteworthy-Light", "Marker Felt", "Snell Roundhand"] {
			if let font = NSFont(name: fontName, size: size) {
			return font
			}
			}

			return NSFont.monospacedSystemFont(ofSize: size, weight: .regular)
			}

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

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

			private func layoutAppShelfIndexLayer(
			_ layer: CATextLayer,
			iconFrame: CGRect,
			iconSize: CGFloat,
			itemBounds: CGRect,
			highlighted: Bool
			) {
			let fontSize = iconSize <= AppShelfMetrics.minIconSize + 1
			? AppShelfMetrics.compressedIndexFontSize
			: AppShelfMetrics.indexFontSize
			layer.contentsScale = backingScaleFactor
			layer.font = appShelfIndexFont(size: fontSize)
			layer.fontSize = fontSize
			layer.foregroundColor = (highlighted ? appShelfIndexHighlightedColor : appShelfIndexColor).cgColor
			layer.opacity = 1

			let indexWidth = AppShelfMetrics.indexWidth
			let indexHeight = AppShelfMetrics.indexHeight
			let preferredX = iconFrame.minX - indexWidth - 2
			let clampedX = max(-7, min(itemBounds.width - indexWidth, preferredX))
			let preferredY = iconFrame.maxY - indexHeight + 6
			let clampedY = max(0, min(itemBounds.height - indexHeight, preferredY))
			layer.frame = CGRect(
			x: clampedX,
			y: clampedY,
			width: indexWidth,
			height: indexHeight
			)
			}

			private func appShelfRows() -> [[AppShelfItemLayers]] {
			@@ -1915,8 +5284,130 @@
			debugHoveredAppGroupIndex ?? hoveredAppGroupIndex
			}

			private var appShelfMagneticHoverEnabled: Bool {
			!NSWorkspace.shared.accessibilityDisplayShouldReduceMotion
			}

			private func appShelfMagneticState(for item: AppShelfItemLayers) -> AppShelfMagneticState {
			guard appShelfMagneticHoverEnabled,
			let hoveredAppGroupIndex = effectiveHoveredAppGroupIndex,
			item.item.appGroupIndex == hoveredAppGroupIndex
			else {
			return AppShelfMagneticState(influence: 0, lift: 0)
			}

			return AppShelfMagneticState(
			influence: 1,
			lift: AppShelfMetrics.magneticHoverLift
			)
			}

			private func animateAppShelfLayerFrame(_ layer: CALayer, from previousFrame: CGRect) {
			guard appShelfMagneticHoverEnabled,
			previousFrame.width > 0,
			previousFrame.height > 0,
			appShelfFrameIsFinite(previousFrame),
			appShelfFrameIsFinite(layer.frame)
			else {
			layer.removeAnimation(forKey: "appShelfMagneticPosition")
			layer.removeAnimation(forKey: "appShelfMagneticBounds")
			return
			}

			let previousPosition = CGPoint(x: previousFrame.midX, y: previousFrame.midY)
			let previousBounds = CGRect(origin: .zero, size: previousFrame.size)
			let nextPosition = layer.position
			let nextBounds = layer.bounds
			let moved = abs(previousPosition.x - nextPosition.x) > 0.25
			\|\| abs(previousPosition.y - nextPosition.y) > 0.25
			let resized = abs(previousBounds.width - nextBounds.width) > 0.25
			\|\| abs(previousBounds.height - nextBounds.height) > 0.25

			guard moved \|\| resized else { return }

			let timing = CAMediaTimingFunction(name: AppShelfMetrics.magneticAnimationTimingName)
			if moved {
			let animation = CABasicAnimation(keyPath: "position")
			animation.fromValue = previousPosition
			animation.toValue = nextPosition
			animation.duration = AppShelfMetrics.magneticAnimationDuration
			animation.timingFunction = timing
			animation.isRemovedOnCompletion = true
			layer.add(animation, forKey: "appShelfMagneticPosition")
			}
			if resized {
			let animation = CABasicAnimation(keyPath: "bounds")
			animation.fromValue = previousBounds
			animation.toValue = nextBounds
			animation.duration = AppShelfMetrics.magneticAnimationDuration
			animation.timingFunction = timing
			animation.isRemovedOnCompletion = true
			layer.add(animation, forKey: "appShelfMagneticBounds")
			}
			}

			private func appShelfFrameIsFinite(_ frame: CGRect) -> Bool {
			frame.origin.x.isFinite
			&& frame.origin.y.isFinite
			&& frame.size.width.isFinite
			&& frame.size.height.isFinite
			}

			private var activeSpaceFocusID: UInt64? {
			focusedSpaceID ?? hoveredSpaceLaneID
			guard case .space(let spaceID) = hoverTarget else { return nil }

			if hoverTargetSource == .debug {
			return spaceID
			}

			guard let window else { return nil }
			let currentMouseLocation = window.mouseLocationOutsideOfEventStream
			guard let segment = spaceLaneSegment(at: currentMouseLocation),
			segment.space.id == spaceID
			else {
			return nil
			}
			return spaceID
			}

			private var appHoverAssociatedSpaceIDs: Set<UInt64> {
			guard case .app(let appGroupIndex) = hoverTarget else { return [] }
			return Set(
			waterfallColumns
			.first { $0.column.appGroupIndex == appGroupIndex }?
			.cards
			.compactMap(\.item.primarySpaceID) ?? []
			)
			}

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

			private var appHoverAssociatedSpaceLabels: [String] {
			guard !appHoverAssociatedSpaceIDs.isEmpty else { return [] }
			return currentViewModel?.displays
			.flatMap(\.spaces)
			.filter { appHoverAssociatedSpaceIDs.contains($0.id) }
			.map(\.label)
			.sorted() ?? []
			}

			private var windowHoverAssociatedSpaceID: UInt64? {
			guard case .window(_, _, let spaceID) = hoverTarget else { return nil }
			return spaceID
			}

			private var isSpaceAssociationActive: Bool {
			activeSpaceFocusID != nil
			}

			private func shouldShowSelectedVisual(isSelected: Bool, isHovered: Bool) -> Bool {
			isSelected && isHovered && !isSpaceAssociationActive
			}

			private func spaceFocusedAppGroupIndexes() -> [Int] {
			@@ -1932,6 +5423,18 @@
			}
			.map(\.column.appGroupIndex)
			.sorted()
			}

			private func firstWaterfallCard(inSpaceID spaceID: UInt64) -> WaterfallCardLayers? {
			for column in waterfallColumns.sorted(by: { $0.column.appGroupIndex < $1.column.appGroupIndex }) {
			if let card = column.cards
			.sorted(by: { $0.item.windowIndex < $1.item.windowIndex })
			.first(where: { $0.item.primarySpaceID == spaceID }) {
			return card
			}
			}

			return nil
			}

			private func spaceFocusWindowCount(for appGroupIndex: Int) -> Int {
			@@ -1951,6 +5454,10 @@
			return "none"
			}

			guard !isHorizontalMasonryMode else {
			return "visible"
			}

			let visibleMinX = waterfallScrollOffset
			let visibleMaxX = waterfallScrollOffset + waterfallLayer.bounds.width
			if column.containerLayer.frame.maxX < visibleMinX + WaterfallMetrics.gap {
			@@ -1962,35 +5469,80 @@
			return "visible"
			}

			private func appShelfVisualIconSize(forBaseIconSize iconSize: CGFloat, selected: Bool, hovered: Bool) -> CGFloat {
			guard selected \|\| hovered else { return iconSize }
			return AppShelfMetrics.selectedIconSize
			}

			private func appShelfZPosition(selected: Bool, hovered: Bool) -> CGFloat {
			switch (selected, hovered) {
			case (true, true):
			return 30
			case (true, false):
			return 20
			case (false, true):
			return 10
			case (false, false):
			return 0
			}
			}

			private func appShelfBackgroundColor(selected: Bool, hovered: Bool, spaceFocused: Bool) -> NSColor {
			if selected {
			return NSColor.controlAccentColor.withAlphaComponent(0.12)
			}
			if hovered {
			return NSColor.systemFill.withAlphaComponent(0.12)
			private func appShelfVisualIconSize(
			forBaseIconSize iconSize: CGFloat,
			selected: Bool,
			hovered: Bool,
			spaceFocused: Bool,
			magneticState: AppShelfMagneticState
			) -> CGFloat {
			if selected \|\| hovered {
			return AppShelfMetrics.selectedIconSize
			}
			if spaceFocused {
			return NSColor.keyboardFocusIndicatorColor.withAlphaComponent(0.10)
			return min(AppShelfMetrics.selectedIconSize, iconSize + 8)
			}
			guard magneticState.isNeighbor else {
			return iconSize
			}
			let growth = AppShelfMetrics.hoverIconSize - iconSize
			return iconSize + growth * magneticState.influence
			}

			private func appShelfZPosition(
			selected: Bool,
			hovered: Bool,
			spaceFocused: Bool,
			magneticState: AppShelfMagneticState
			) -> CGFloat {
			switch (selected, hovered, spaceFocused) {
			case (true, true, _):
			return 30
			case (true, false, _):
			return 24
			case (false, true, _):
			return 18
			case (false, false, true):
			return 12
			case (false, false, false):
			return magneticState.isNeighbor ? 6 + magneticState.influence : 0
			}
			}

			private func appShelfBackgroundColor(
			selected: Bool,
			hovered: Bool,
			spaceFocused: Bool,
			magneticState: AppShelfMagneticState
			) -> NSColor {
			if spaceFocused {
			return themePalette.appShelfBackgroundSpaceFocused
			}
			return .clear
			}

			private func appShelfShadowOpacity(
			selected: Bool,
			hovered: Bool,
			spaceFocused: Bool,
			magneticState: AppShelfMagneticState
			) -> Float {
			if spaceFocused {
			return 0.18
			}
			return 0
			}

			private func appShelfShadowRadius(
			selected: Bool,
			hovered: Bool,
			spaceFocused: Bool,
			magneticState: AppShelfMagneticState
			) -> CGFloat {
			if spaceFocused {
			return 18
			}
			return 0
			}

			private func appShelfBadgeText(for item: AppShelfItemLayers) -> String {
			@@ -2012,6 +5564,10 @@
			return item.item.windowCount > 1 ? "\(item.item.windowCount)" : ""
			}

			private var waterfallAppHoverHeaderFillColor: NSColor {
			themePalette.columnHeaderHoverBackground
			}

			private var appShelfMaxScrollOffset: CGFloat {
			max(0, appShelfContentWidth - shelfLayer.bounds.width)
			}
			@@ -2021,17 +5577,24 @@
			}

			private func layoutWaterfallColumns() {
			if isHorizontalMasonryMode {
			layoutHorizontalMasonryWaterfall()
			return
			}

			guard !waterfallColumns.isEmpty else {
			waterfallContentWidth = waterfallLayer.bounds.width
			waterfallScrollOffset = 0
			horizontalMasonryContentHeight = waterfallLayer.bounds.height
			horizontalMasonryScrollOffset = 0
			waterfallContentLayer.frame = waterfallLayer.bounds
			return
			}

			let columnWidth = waterfallColumnWidth()
			let totalWidth = WaterfallMetrics.columnPadding * 2
			+ CGFloat(waterfallColumns.count) * columnWidth
			let columnsWidth = CGFloat(waterfallColumns.count) * columnWidth
			+ CGFloat(max(0, waterfallColumns.count - 1)) * WaterfallMetrics.gap
			let totalWidth = WaterfallMetrics.contentHorizontalPadding * 2 + columnsWidth
			waterfallContentWidth = max(waterfallLayer.bounds.width, totalWidth)
			waterfallScrollOffset = clampedWaterfallAlignmentOffset(waterfallScrollOffset)
			waterfallContentLayer.frame = CGRect(
			@@ -2041,7 +5604,7 @@
			height: waterfallLayer.bounds.height
			)

			var x = WaterfallMetrics.columnPadding
			var x = waterfallColumnStartX(columnsWidth: columnsWidth)
			for column in waterfallColumns {
			column.containerLayer.frame = CGRect(
			x: x,
			@@ -2054,12 +5617,191 @@
			}
			}

			private func layoutHorizontalMasonryWaterfall() {
			guard !waterfallColumns.isEmpty else {
			waterfallContentWidth = waterfallLayer.bounds.width
			waterfallScrollOffset = 0
			horizontalMasonryContentHeight = waterfallLayer.bounds.height
			horizontalMasonryScrollOffset = 0
			waterfallContentLayer.frame = waterfallLayer.bounds
			return
			}

			let layout = horizontalMasonryLayout()
			waterfallContentWidth = waterfallLayer.bounds.width
			waterfallScrollOffset = 0
			horizontalMasonryContentHeight = layout.contentHeight
			horizontalMasonryScrollOffset = clampedHorizontalMasonryOffset(horizontalMasonryScrollOffset)
			waterfallContentLayer.frame = horizontalMasonryContentFrame()

			for column in waterfallColumns {
			column.containerLayer.frame = CGRect(
			x: 0,
			y: 0,
			width: waterfallContentWidth,
			height: horizontalMasonryContentHeight
			)
			column.containerLayer.masksToBounds = false
			column.containerLayer.backgroundColor = NSColor.clear.cgColor
			column.containerLayer.borderColor = NSColor.clear.cgColor
			column.containerLayer.borderWidth = 0
			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

			for card in column.cards {
			card.containerLayer.transform = CATransform3DIdentity
			if let frame = layout.cardFramesByWindowID[card.item.window.id] {
			card.containerLayer.frame = frame
			} else {
			card.containerLayer.frame = .zero
			}
			layoutWaterfallCard(card)
			}
			}
			}

			private struct HorizontalMasonryLayout {
			let contentHeight: CGFloat
			let cardFramesByWindowID: [UInt32: CGRect]
			}

			private func horizontalMasonryLayout() -> HorizontalMasonryLayout {
			let cards = horizontalMasonryCardsInPlacementOrder()
			guard !cards.isEmpty else {
			return HorizontalMasonryLayout(
			contentHeight: waterfallLayer.bounds.height,
			cardFramesByWindowID: [:]
			)
			}

			let viewportWidth = max(1, waterfallLayer.bounds.width)
			let availableWidth = max(
			HorizontalMasonryMetrics.cardMinWidth,
			viewportWidth - HorizontalMasonryMetrics.horizontalPadding * 2
			)
			let maximumLaneCount = max(
			1,
			Int(
			floor(
			(availableWidth + HorizontalMasonryMetrics.horizontalGap)
			/ (HorizontalMasonryMetrics.cardMinWidth + HorizontalMasonryMetrics.horizontalGap)
			)
			)
			)
			let laneCount = min(maximumLaneCount, max(1, cards.count))
			let fittingWidth = (
			availableWidth - CGFloat(max(0, laneCount - 1)) * HorizontalMasonryMetrics.horizontalGap
			) / CGFloat(laneCount)
			let cardWidth = floor(
			min(
			HorizontalMasonryMetrics.cardMaxWidth,
			max(HorizontalMasonryMetrics.cardMinWidth, fittingWidth)
			)
			)
			let usedWidth = CGFloat(laneCount) * cardWidth
			+ CGFloat(max(0, laneCount - 1)) * HorizontalMasonryMetrics.horizontalGap
			let startX = max(
			HorizontalMasonryMetrics.horizontalPadding,
			(viewportWidth - usedWidth) / 2
			)

			var laneHeights = Array(repeating: CGFloat(0), count: laneCount)
			var plannedFrames: [(windowID: UInt32, x: CGFloat, top: CGFloat, width: CGFloat, height: CGFloat)] = []

			for card in cards {
			let laneIndex = laneHeights.enumerated().min { lhs, rhs in
			if abs(lhs.element - rhs.element) > 0.5 {
			return lhs.element < rhs.element
			}
			return lhs.offset < rhs.offset
			}?.offset ?? 0
			let cardHeight = HorizontalMasonryMetrics.cardHeight
			let x = startX + CGFloat(laneIndex) * (cardWidth + HorizontalMasonryMetrics.horizontalGap)
			let top = HorizontalMasonryMetrics.verticalPadding + laneHeights[laneIndex]
			plannedFrames.append((
			windowID: card.item.window.id,
			x: x,
			top: top,
			width: cardWidth,
			height: cardHeight
			))
			laneHeights[laneIndex] += cardHeight + HorizontalMasonryMetrics.verticalGap
			}

			let tallestLane = laneHeights.max().map {
			max(0, $0 - HorizontalMasonryMetrics.verticalGap)
			} ?? 0
			let contentHeight = max(
			waterfallLayer.bounds.height,
			HorizontalMasonryMetrics.verticalPadding * 2 + tallestLane
			)
			let frames = Dictionary(
			uniqueKeysWithValues: plannedFrames.map { planned in
			(
			planned.windowID,
			CGRect(
			x: planned.x,
			y: contentHeight - planned.top - planned.height,
			width: planned.width,
			height: planned.height
			)
			)
			}
			)

			return HorizontalMasonryLayout(contentHeight: contentHeight, cardFramesByWindowID: frames)
			}

			private func horizontalMasonryContentFrame() -> CGRect {
			let contentHeight = max(waterfallLayer.bounds.height, horizontalMasonryContentHeight)
			return CGRect(
			x: 0,
			y: waterfallLayer.bounds.height - contentHeight + horizontalMasonryScrollOffset,
			width: waterfallLayer.bounds.width,
			height: contentHeight
			)
			}

			private func waterfallColumnStartX(columnsWidth: CGFloat) -> CGFloat {
			guard currentViewModel?.lockedSpaceID != nil else {
			return WaterfallMetrics.contentHorizontalPadding
			}

			let centeredStart = (waterfallContentWidth - columnsWidth) / 2
			return max(WaterfallMetrics.contentHorizontalPadding, centeredStart)
			}

			private func layoutWaterfallColumn(_ column: WaterfallColumnLayers) {
			column.containerLayer.cornerRadius = 14
			column.containerLayer.masksToBounds = true
			column.containerLayer.backgroundColor = themePalette.columnBackground.cgColor
			column.containerLayer.shadowOpacity = 0
			column.containerLayer.shadowRadius = 0
			column.containerLayer.shadowOffset = .zero
			column.headerLayer.isHidden = false
			column.appNameLayer.isHidden = false
			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
			? NSColor.separatorColor.withAlphaComponent(0.38)
			: NSColor.separatorColor.withAlphaComponent(0.24)
			? themePalette.columnBorder.withAlphaComponent(resolvedTheme == .dark ? 0.34 : 0.38)
			: themePalette.columnBorder
			).cgColor
			column.containerLayer.borderWidth = 1
			column.headerLayer.frame = CGRect(
			@@ -2068,22 +5810,26 @@
			width: bounds.width,
			height: WaterfallMetrics.headerHeight
			)
			column.headerLayer.backgroundColor = (isSpaceFocused
			? NSColor.systemFill.withAlphaComponent(0.10)
			: NSColor.controlBackgroundColor.withAlphaComponent(0.52)
			column.headerLayer.backgroundColor = (isHovered
			? waterfallAppHoverHeaderFillColor
			: (isSpaceFocused
			? themePalette.columnHeaderSpaceFocusedBackground
			: themePalette.columnHeaderBackground)
			).cgColor
			column.appNameLayer.frame = CGRect(
			x: WaterfallMetrics.columnPadding,
			x: WaterfallMetrics.columnHeaderTextInset,
			y: bounds.height - 24,
			width: max(1, bounds.width - 64),
			width: max(1, bounds.width - WaterfallMetrics.columnHeaderTextInset * 2),
			height: 16
			)
			column.appNameLayer.foregroundColor = themePalette.columnText.cgColor
			column.countLayer.frame = CGRect(
			x: bounds.width - 48,
			y: bounds.height - 24,
			width: 36,
			height: 16
			)
			column.countLayer.foregroundColor = themePalette.columnSecondaryText.cgColor

			let appGroupIndex = column.column.appGroupIndex
			let verticalOffset = clampedWaterfallColumnOffset(
			@@ -2092,10 +5838,10 @@
			)
			waterfallColumnScrollOffsets[appGroupIndex] = verticalOffset

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

			for card in column.cards {
			@@ -2103,8 +5849,9 @@
			let y = firstCardTop
			- WaterfallMetrics.cardHeight
			- CGFloat(cardIndex) * (WaterfallMetrics.cardHeight + WaterfallMetrics.cardGap)
			card.containerLayer.transform = CATransform3DIdentity
			card.containerLayer.frame = CGRect(
			x: WaterfallMetrics.columnPadding,
			x: WaterfallMetrics.columnHorizontalPadding,
			y: y,
			width: cardWidth,
			height: WaterfallMetrics.cardHeight
			@@ -2117,33 +5864,74 @@
			let bounds = card.containerLayer.bounds
			let isSelected = card.item.window.id == effectiveSelection?.windowID
			let isHovered = card.item.window.id == hoveredWindowID
			applyWaterfallCardVisualState(card, selected: isSelected, hovered: isHovered)

			let thumbnailWidth = max(90, min(116, bounds.width * 0.44))
			card.thumbnailLayer.frame = CGRect(
			x: 10,
			y: 12,
			width: thumbnailWidth,
			height: bounds.height - 24
			let isKeyboardFocused = card.item.window.id == keyboardFocusedWindowID
			let isHorizontalAppDefaultFocused = isHorizontalAppDefaultCard(card)
			let isAppLinked = isWaterfallCardAppLinked(card)
			let shortcutFilterState = windowShortcutFilterState(for: card)
			applyWaterfallCardVisualState(
			card,
			selected: shouldShowSelectedVisual(isSelected: isSelected, isHovered: isHovered)
			\|\| isKeyboardFocused
			\|\| isHorizontalAppDefaultFocused,
			hovered: isHovered,
			appLinked: isAppLinked,
			shortcutFilterState: shortcutFilterState
			)
			card.appIconLayer.frame = CGRect(x: 18, y: bounds.height - 38, width: 22, height: 22)

			let outerInset: CGFloat = 0
			let titleBarHeight: CGFloat = 26
			let titleGap: CGFloat = 6
			let titleBarFrame = CGRect(
			x: outerInset,
			y: bounds.height - outerInset - titleBarHeight,
			width: max(1, bounds.width - outerInset * 2),
			height: titleBarHeight
			)
			let thumbnailFrame = CGRect(
			x: outerInset,
			y: outerInset,
			width: max(1, bounds.width - outerInset * 2),
			height: max(1, titleBarFrame.minY - outerInset - titleGap)
			)

			card.thumbnailLayer.frame = CGRect(
			x: thumbnailFrame.minX,
			y: thumbnailFrame.minY,
			width: thumbnailFrame.width,
			height: thumbnailFrame.height
			)
			card.titleBarLayer.frame = titleBarFrame
			card.appIconLayer.frame = CGRect(x: titleBarFrame.minX + 7, y: titleBarFrame.minY + 5, width: 16, height: 16)
			card.titleLayer.frame = CGRect(
			x: thumbnailWidth + 22,
			y: bounds.height - 31,
			width: max(1, bounds.width - thumbnailWidth - 34),
			x: titleBarFrame.minX + 29,
			y: titleBarFrame.minY + 6,
			width: max(1, titleBarFrame.width - 68),
			height: 16
			)
			card.titleLayer.foregroundColor = themePalette.cardText.cgColor
			card.metaLayer.frame = CGRect(
			x: thumbnailWidth + 22,
			y: bounds.height - 51,
			width: max(1, bounds.width - thumbnailWidth - 34),
			x: titleBarFrame.maxX - 38,
			y: titleBarFrame.minY + 6,
			width: 30,
			height: 14
			)
			card.metaLayer.foregroundColor = themePalette.cardSecondaryText.cgColor
			card.stateLayer.frame = CGRect(
			x: thumbnailWidth + 22,
			y: 12,
			width: max(1, bounds.width - thumbnailWidth - 34),
			x: thumbnailFrame.maxX - 86,
			y: thumbnailFrame.minY + 6,
			width: 78,
			height: 14
			)
			card.stateLayer.foregroundColor = themePalette.cardSecondaryText.cgColor
			layoutCloseButton(
			card.closeButton,
			target: .window(
			appGroupIndex: card.item.appGroupIndex,
			windowIndex: card.item.windowIndex,
			windowID: card.item.window.id
			),
			visible: isHovered && shortcutFilterState != .dimmed,
			anchorTopRight: CGPoint(x: bounds.maxX - 12, y: bounds.maxY - 12)
			)
			card.shineLayer.frame = CGRect(
			x: -bounds.width * 0.18,
			@@ -2151,37 +5939,675 @@
			width: max(36, min(96, bounds.width * 0.24)),
			height: bounds.height
			)
			card.shineLayer.colors = [
			NSColor.white.withAlphaComponent(0.00).cgColor,
			themePalette.shinePeak.cgColor,
			NSColor.white.withAlphaComponent(0.00).cgColor
			]
			}

			private func applyWaterfallCardVisualState(_ card: WaterfallCardLayers, selected: Bool, hovered: Bool) {
			let isSpaceFocused = card.item.primarySpaceID == activeSpaceFocusID
			private func applyWaterfallCardVisualState(
			_ card: WaterfallCardLayers,
			selected: Bool,
			hovered: Bool,
			appLinked: Bool,
			shortcutFilterState: WindowShortcutFilterState
			) {
			let isSpaceFocused = isWaterfallCardSpaceFocused(card)
			let isShortcutDimmed = shortcutFilterState == .dimmed
			card.containerLayer.backgroundColor = (selected
			? NSColor.windowBackgroundColor.withAlphaComponent(0.94)
			? themePalette.cardSelectedBackground
			: hovered
			? NSColor.systemFill.withAlphaComponent(0.13)
			? accentTintedWindowBackground(fraction: 0.09, alpha: 0.95)
			: appLinked
			? accentTintedWindowBackground(fraction: 0.08, alpha: 0.93)
			: isSpaceFocused
			? NSColor.windowBackgroundColor.withAlphaComponent(0.88)
			: NSColor.windowBackgroundColor.withAlphaComponent(0.82)
			? accentTintedWindowBackground(fraction: 0.10, alpha: 0.94)
			: themePalette.cardBackground
			).cgColor
			card.containerLayer.opacity = isShortcutDimmed ? windowShortcutFilterDimOpacity : 1
			card.containerLayer.borderColor = (selected
			? NSColor.controlAccentColor.withAlphaComponent(0.52)
			: hovered
			? NSColor.separatorColor.withAlphaComponent(0.46)
			? NSColor.controlAccentColor.withAlphaComponent(0.44)
			: appLinked
			? NSColor.controlAccentColor.withAlphaComponent(0.38)
			: isSpaceFocused
			? NSColor.separatorColor.withAlphaComponent(0.38)
			? NSColor.controlAccentColor.withAlphaComponent(0.42)
			: NSColor.separatorColor.withAlphaComponent(0.28)
			).cgColor
			card.containerLayer.borderWidth = selected ? 1.5 : 1
			card.containerLayer.borderWidth = (selected \|\| hovered \|\| appLinked \|\| isSpaceFocused) ? 1.5 : 1
			card.containerLayer.shadowColor = NSColor.black.cgColor
			card.containerLayer.shadowOpacity = selected ? 0.20 : hovered ? 0.08 : 0
			card.containerLayer.shadowRadius = selected ? 18 : hovered ? 10 : 0
			card.containerLayer.shadowOffset = selected
			? CGSize(width: 0, height: -5)
			let darkShadowBoost: Float = resolvedTheme == .dark ? 0.08 : 0
			let baseShadowOpacity: Float = selected
			? 0.24 + darkShadowBoost
			: hovered
			? CGSize(width: 0, height: -2)
			: .zero
			card.containerLayer.zPosition = selected ? 20 : hovered ? 10 : 0
			card.shineLayer.opacity = selected ? 1 : 0
			? 0.14 + darkShadowBoost
			: appLinked
			? 0.16 + darkShadowBoost
			: isSpaceFocused
			? 0.20 + darkShadowBoost
			: 0
			card.containerLayer.shadowOpacity = isShortcutDimmed ? min(baseShadowOpacity, 0.03) : baseShadowOpacity
			card.containerLayer.shadowRadius = selected ? 22 : hovered ? 17 : appLinked ? 18 : isSpaceFocused ? 24 : 0
			card.containerLayer.shadowOffset = selected
			? CGSize(width: 0, height: -6)
			: hovered
			? CGSize(width: 0, height: -2.5)
			: appLinked
			? CGSize(width: 0, height: -3)
			: isSpaceFocused
			? CGSize(width: 0, height: -5)
			: .zero
			card.containerLayer.zPosition = selected ? 20 : hovered ? 12 : appLinked ? 10 : isSpaceFocused ? 8 : 0
			let focusedScale: CGFloat = selected ? WaterfallMetrics.selectedCardScale : isSpaceFocused ? 1.012 : 1.008
			card.containerLayer.transform = (!isShortcutDimmed && (selected \|\| hovered \|\| isSpaceFocused))
			? CATransform3DMakeScale(focusedScale, focusedScale, 1)
			: CATransform3DIdentity
			card.containerLayer.shadowPath = (!isShortcutDimmed && (selected \|\| hovered \|\| appLinked \|\| isSpaceFocused))
			? CGPath(
			roundedRect: card.containerLayer.bounds,
			cornerWidth: card.containerLayer.cornerRadius,
			cornerHeight: card.containerLayer.cornerRadius,
			transform: nil
			)
			: nil
			card.titleBarLayer.backgroundColor = (selected
			? spaceLaneOccupiedColor.withAlphaComponent(0.22)
			: appLinked
			? spaceLaneOccupiedColor.withAlphaComponent(0.18)
			: NSColor.clear
			).cgColor
			card.titleBarLayer.borderColor = NSColor.clear.cgColor
			card.titleBarLayer.borderWidth = 0
			card.shineLayer.opacity = (!isShortcutDimmed && selected) ? 1 : 0
			}

			private func layoutCloseButton(
			_ button: CloseButtonLayers,
			target: CloseTarget,
			visible: Bool,
			anchorTopRight: CGPoint
			) {
			let isButtonHovered = hoveredCloseTarget == target
			let size: CGFloat = isButtonHovered ? 24 : 18
			let buttonFill = isButtonHovered
			? NSColor.systemRed.withAlphaComponent(0.94)
			: NSColor.white.withAlphaComponent(0.34)
			let buttonStroke = isButtonHovered
			? NSColor.white.withAlphaComponent(0.76)
			: NSColor.white.withAlphaComponent(0.46)
			let glyphStroke = isButtonHovered
			? NSColor.white
			: NSColor.white.withAlphaComponent(0.88)

			button.containerLayer.frame = CGRect(
			x: anchorTopRight.x - size / 2,
			y: anchorTopRight.y - size / 2,
			width: size,
			height: size
			)
			button.containerLayer.cornerRadius = size / 2
			button.containerLayer.backgroundColor = buttonFill.cgColor
			button.containerLayer.borderColor = buttonStroke.cgColor
			button.containerLayer.opacity = visible ? 1 : 0
			button.containerLayer.zPosition = isButtonHovered ? 80 : 60
			button.containerLayer.shadowOpacity = visible ? (isButtonHovered ? 0.22 : 0.04) : 0
			button.containerLayer.shadowRadius = isButtonHovered ? 9 : 5
			button.glyphLayer.frame = CGRect(x: 0, y: 0, width: size, height: size)
			button.glyphLayer.lineWidth = isButtonHovered ? 2.1 : 1.45
			button.glyphLayer.strokeColor = glyphStroke.cgColor
			button.glyphLayer.path = closeGlyphPath(size: size, hovered: isButtonHovered)
			}

			private func closeGlyphPath(size: CGFloat, hovered: Bool) -> CGPath {
			let inset: CGFloat = hovered ? 7.2 : 5.6
			let path = CGMutablePath()
			path.move(to: CGPoint(x: inset, y: inset))
			path.addLine(to: CGPoint(x: size - inset, y: size - inset))
			path.move(to: CGPoint(x: size - inset, y: inset))
			path.addLine(to: CGPoint(x: inset, y: size - inset))
			return path
			}

			private func canClose(app: AlignerApp) -> Bool {
			guard let processIdentifier = app.processIdentifier else { return false }
			return processIdentifier != getpid()
			}

			private func layoutCloseConfirmation() {
			guard let pendingCloseTarget,
			let request = closeRequest(for: pendingCloseTarget),
			let anchor = closeConfirmationAnchor(for: pendingCloseTarget)
			else {
			closeConfirmationLayers.containerLayer.isHidden = true
			closeConfirmationArrowEdge = nil
			return
			}

			let contentWidth: CGFloat = 374
			let height: CGFloat = 184
			let arrowWidth: CGFloat = 14
			let edgeMargin: CGFloat = 16
			let anchorGap: CGFloat = 12
			let width = contentWidth + arrowWidth
			let availableRight = glassLayer.bounds.maxX - anchor.x - edgeMargin
			let availableLeft = anchor.x - glassLayer.bounds.minX - edgeMargin
			let arrowEdge: CloseConfirmationArrowEdge = availableRight >= width \|\| availableRight >= availableLeft
			? .left
			: .right
			let preferredX = arrowEdge == .left
			? anchor.x + anchorGap
			: anchor.x - width - anchorGap
			let x = min(
			max(edgeMargin, preferredX),
			max(edgeMargin, glassLayer.bounds.width - width - edgeMargin)
			)
			let y = min(
			max(edgeMargin, anchor.y - height + 64),
			max(edgeMargin, glassLayer.bounds.height - height - edgeMargin)
			)
			let localArrowY = min(max(anchor.y - y, 38), height - 38)
			closeConfirmationArrowEdge = arrowEdge

			let layers = closeConfirmationLayers
			layers.containerLayer.isHidden = false
			layers.containerLayer.frame = CGRect(x: x, y: y, width: width, height: height)
			let contentX = arrowEdge == .left ? arrowWidth : 0
			let contentFrame = CGRect(x: contentX, y: 0, width: contentWidth, height: height)
			let bubblePath = closeConfirmationBubblePath(
			bounds: layers.containerLayer.bounds,
			contentFrame: contentFrame,
			arrowEdge: arrowEdge,
			arrowY: localArrowY
			)
			layers.backgroundLayer.frame = layers.containerLayer.bounds
			layers.backgroundLayer.path = bubblePath
			layers.backgroundLayer.fillColor = themePalette.closeFeedbackBackground.withAlphaComponent(resolvedTheme == .dark ? 0.98 : 0.985).cgColor
			layers.backgroundLayer.strokeColor = themePalette.closeFeedbackBorder.withAlphaComponent(resolvedTheme == .dark ? 0.78 : 1).cgColor
			layers.containerLayer.shadowPath = bubblePath
			layers.titleLayer.string = confirmationTitle(for: request)
			layers.messageLayer.string = confirmationMessage(for: request)
			layers.titleLayer.foregroundColor = (resolvedTheme == .dark
			? NSColor.white.withAlphaComponent(0.92)
			: NSColor.labelColor
			).cgColor
			layers.messageLayer.foregroundColor = themePalette.closeFeedbackText.cgColor
			layers.titleLayer.frame = CGRect(x: contentFrame.minX + 22, y: height - 48, width: contentFrame.width - 44, height: 22)
			layers.messageLayer.frame = CGRect(x: contentFrame.minX + 22, y: height - 78, width: contentFrame.width - 44, height: 21)

			layers.checkboxLayer.frame = CGRect(x: contentFrame.minX + 22, y: 80, width: 18, height: 18)
			layers.checkboxLayer.backgroundColor = (pendingCloseOptOut
			? NSColor.controlAccentColor.withAlphaComponent(0.92)
			: NSColor.clear
			).cgColor
			layers.checkboxLayer.borderColor = (pendingCloseOptOut
			? NSColor.controlAccentColor.withAlphaComponent(0.95)
			: themePalette.closeFeedbackBorder.withAlphaComponent(resolvedTheme == .dark ? 0.80 : 0.48)
			).cgColor
			layers.checkboxMarkLayer.string = pendingCloseOptOut ? "✓" : ""
			layers.checkboxMarkLayer.frame = CGRect(x: 0, y: 1, width: 18, height: 16)
			layers.checkboxLabelLayer.foregroundColor = themePalette.closeFeedbackText.cgColor
			layers.checkboxLabelLayer.frame = CGRect(x: contentFrame.minX + 48, y: 80, width: contentFrame.width - 70, height: 19)

			layers.cancelButtonLayer.backgroundColor = (resolvedTheme == .dark
			? NSColor.white.withAlphaComponent(0.10)
			: NSColor.systemFill.withAlphaComponent(0.16)
			).cgColor
			layers.cancelButtonLayer.borderColor = themePalette.closeFeedbackBorder.withAlphaComponent(resolvedTheme == .dark ? 0.70 : 0.22).cgColor
			layers.cancelButtonTextLayer.foregroundColor = (resolvedTheme == .dark
			? NSColor.white.withAlphaComponent(0.86)
			: NSColor.labelColor
			).cgColor
			layers.cancelButtonLayer.frame = CGRect(x: contentFrame.maxX - 164, y: 22, width: 74, height: 32)
			layers.cancelButtonTextLayer.frame = layers.cancelButtonLayer.bounds.insetBy(dx: 0, dy: 7)
			layers.confirmButtonLayer.frame = CGRect(x: contentFrame.maxX - 78, y: 22, width: 56, height: 32)
			layers.confirmButtonTextLayer.frame = layers.confirmButtonLayer.bounds.insetBy(dx: 0, dy: 7)
			}

			private func setCloseFeedback(_ feedback: CloseFeedback, autoHideAfter delay: TimeInterval?) {
			closeFeedbackHideTask?.cancel()
			closeFeedback = feedback
			closeFeedbackLayer.isHidden = false
			closeFeedbackLayer.opacity = 1
			closeFeedbackTextLayer.string = feedback.message
			switch feedback.kind {
			case .progress:
			closeFeedbackLayer.backgroundColor = themePalette.closeFeedbackBackground.cgColor
			closeFeedbackLayer.borderColor = themePalette.closeFeedbackBorder.cgColor
			closeFeedbackTextLayer.foregroundColor = themePalette.closeFeedbackText.cgColor
			case .failure:
			closeFeedbackLayer.backgroundColor = NSColor.systemRed.withAlphaComponent(0.10).cgColor
			closeFeedbackLayer.borderColor = NSColor.systemRed.withAlphaComponent(0.32).cgColor
			closeFeedbackTextLayer.foregroundColor = NSColor.systemRed.withAlphaComponent(0.95).cgColor
			}
			needsLayout = true

			guard let delay else {
			closeFeedbackHideTask = nil
			return
			}

			closeFeedbackHideTask = Task { @MainActor [weak self] in
			try? await Task.sleep(nanoseconds: UInt64(delay * 1_000_000_000))
			guard !Task.isCancelled,
			let self,
			self.closeFeedback == feedback
			else {
			return
			}
			self.clearCloseFeedback()
			}
			}

			private func layoutCloseFeedback() {
			guard let feedback = closeFeedback else {
			closeFeedbackLayer.isHidden = true
			closeFeedbackLayer.opacity = 0
			return
			}

			closeFeedbackLayer.isHidden = false
			closeFeedbackLayer.opacity = 1
			let font = NSFont.systemFont(
			ofSize: 13,
			weight: feedback.kind == .failure ? .medium : .regular
			)
			closeFeedbackTextLayer.font = font
			closeFeedbackTextLayer.fontSize = 13
			let textWidth = (feedback.message as NSString).size(
			withAttributes: [.font: font]
			).width
			let maxWidth = max(180, glassLayer.bounds.width - 48)
			let width = min(max(180, textWidth + 34), min(460, maxWidth))
			let height: CGFloat = 34
			let x = max(24, (glassLayer.bounds.width - width) / 2)
			let preferredY = waterfallLayer.frame.maxY - height - 14
			let y = min(
			max(16, preferredY),
			max(16, glassLayer.bounds.height - height - 16)
			)

			closeFeedbackLayer.frame = CGRect(x: x, y: y, width: width, height: height)
			closeFeedbackLayer.cornerRadius = height / 2
			closeFeedbackLayer.shadowPath = CGPath(
			roundedRect: closeFeedbackLayer.bounds,
			cornerWidth: closeFeedbackLayer.cornerRadius,
			cornerHeight: closeFeedbackLayer.cornerRadius,
			transform: nil
			)
			closeFeedbackTextLayer.frame = closeFeedbackLayer.bounds.insetBy(dx: 17, dy: 8)
			}

			private func closeConfirmationBubblePath(
			bounds: CGRect,
			contentFrame: CGRect,
			arrowEdge: CloseConfirmationArrowEdge,
			arrowY: CGFloat
			) -> CGPath {
			let cornerRadius: CGFloat = 18
			let arrowHalfHeight: CGFloat = 10
			let path = CGMutablePath()
			let minX = contentFrame.minX
			let maxX = contentFrame.maxX
			let minY = contentFrame.minY
			let maxY = contentFrame.maxY
			let arrowY = min(max(arrowY, minY + cornerRadius + arrowHalfHeight + 4), maxY - cornerRadius - arrowHalfHeight - 4)

			path.move(to: CGPoint(x: minX + cornerRadius, y: minY))
			path.addLine(to: CGPoint(x: maxX - cornerRadius, y: minY))
			path.addQuadCurve(to: CGPoint(x: maxX, y: minY + cornerRadius), control: CGPoint(x: maxX, y: minY))

			if arrowEdge == .right {
			path.addLine(to: CGPoint(x: maxX, y: arrowY - arrowHalfHeight))
			path.addLine(to: CGPoint(x: bounds.maxX, y: arrowY))
			path.addLine(to: CGPoint(x: maxX, y: arrowY + arrowHalfHeight))
			}

			path.addLine(to: CGPoint(x: maxX, y: maxY - cornerRadius))
			path.addQuadCurve(to: CGPoint(x: maxX - cornerRadius, y: maxY), control: CGPoint(x: maxX, y: maxY))
			path.addLine(to: CGPoint(x: minX + cornerRadius, y: maxY))
			path.addQuadCurve(to: CGPoint(x: minX, y: maxY - cornerRadius), control: CGPoint(x: minX, y: maxY))

			if arrowEdge == .left {
			path.addLine(to: CGPoint(x: minX, y: arrowY + arrowHalfHeight))
			path.addLine(to: CGPoint(x: bounds.minX, y: arrowY))
			path.addLine(to: CGPoint(x: minX, y: arrowY - arrowHalfHeight))
			}

			path.addLine(to: CGPoint(x: minX, y: minY + cornerRadius))
			path.addQuadCurve(to: CGPoint(x: minX + cornerRadius, y: minY), control: CGPoint(x: minX, y: minY))
			path.closeSubpath()
			return path
			}

			private func confirmationTitle(for request: QuickSwitchCloseRequest) -> String {
			switch request {
			case .app:
			return "关闭 \(request.appName)？"
			case .window:
			return "关闭这个窗口？"
			}
			}

			private func confirmationMessage(for request: QuickSwitchCloseRequest) -> String {
			switch request {
			case .app:
			return "将退出该应用，并一次性关闭它的所有窗口。"
			case .window:
			return "将关闭此窗口，未保存内容可能需要应用确认。"
			}
			}

			private func closeRequest(for target: CloseTarget) -> QuickSwitchCloseRequest? {
			switch target {
			case .app(let appGroupIndex):
			return appShelfItems
			.first { $0.item.appGroupIndex == appGroupIndex }
			.map { .app($0.item) }
			case .window(let appGroupIndex, let windowIndex, let windowID):
			guard let card = waterfallCard(appGroupIndex: appGroupIndex, windowIndex: windowIndex),
			card.item.window.id == windowID
			else {
			return nil
			}
			return .window(card.item)
			}
			}

			private func requestClose(for target: CloseTarget) {
			guard let request = closeRequest(for: target) else {
			DevelopmentDiagnostics.log("quickSwitch.view.closeRequest.missingTarget", [
			"targetKind": target.kindDescription
			])
			return
			}

			pendingCloseTarget = nil
			pendingCloseRequest = nil
			pendingCloseOptOut = false
			closeConfirmationLayers.containerLayer.isHidden = true
			closeConfirmationArrowEdge = nil
			onRequestClose?(request)
			}

			private func beginCloseConfirmation(for target: CloseTarget) {
			if closeConfirmationRequired {
			guard let request = closeRequest(for: target) else {
			DevelopmentDiagnostics.log("quickSwitch.view.closeConfirmation.missingRequest", [
			"targetKind": target.kindDescription
			])
			return
			}
			pendingCloseTarget = target
			pendingCloseRequest = request
			pendingCloseOptOut = false
			DevelopmentDiagnostics.log("quickSwitch.view.closeConfirmation.show", [
			"targetKind": target.kindDescription
			])
			needsLayout = true
			return
			}

			requestClose(for: target)
			}

			private func confirmPendingClose() {
			guard let target = pendingCloseTarget,
			let request = pendingCloseRequest
			else { return }
			let shouldDisableConfirmation = pendingCloseOptOut
			pendingCloseTarget = nil
			pendingCloseRequest = nil
			pendingCloseOptOut = false
			closeConfirmationLayers.containerLayer.isHidden = true
			closeConfirmationArrowEdge = nil
			if shouldDisableConfirmation && closeConfirmationRequired {
			closeConfirmationRequired = false
			onCloseConfirmationDisabled?()
			}
			DevelopmentDiagnostics.log("quickSwitch.view.closeConfirmation.confirm", [
			"targetKind": target.kindDescription,
			"disableFutureConfirmation": shouldDisableConfirmation
			])
			onRequestClose?(request)
			}

			private func cancelPendingClose() {
			DevelopmentDiagnostics.log("quickSwitch.view.closeConfirmation.cancel")
			pendingCloseTarget = nil
			pendingCloseRequest = nil
			pendingCloseOptOut = false
			closeConfirmationLayers.containerLayer.isHidden = true
			closeConfirmationArrowEdge = nil
			needsLayout = true
			}

			private func toggleCloseConfirmationOptOut() {
			if pendingCloseOptOut && !closeConfirmationRequired {
			return
			}
			pendingCloseOptOut.toggle()
			if pendingCloseOptOut {
			closeConfirmationRequired = false
			onCloseConfirmationDisabled?()
			DevelopmentDiagnostics.log("quickSwitch.view.closeConfirmation.optOutPersisted")
			}
			needsLayout = true
			}

			private enum CloseConfirmationHit {
			case confirm
			case cancel
			case checkbox
			case background
			case outside
			}

			private func closeConfirmationHit(at windowLocation: NSPoint) -> CloseConfirmationHit {
			let location = convert(windowLocation, from: nil)
			let locationInGlass = CGPoint(
			x: location.x - glassLayer.frame.minX,
			y: location.y - glassLayer.frame.minY
			)
			let layers = closeConfirmationLayers
			guard !layers.containerLayer.isHidden else { return .outside }
			guard layers.containerLayer.frame.contains(locationInGlass) else { return .outside }

			let local = CGPoint(
			x: locationInGlass.x - layers.containerLayer.frame.minX,
			y: locationInGlass.y - layers.containerLayer.frame.minY
			)
			if layers.confirmButtonLayer.frame.contains(local) {
			return .confirm
			}
			if layers.cancelButtonLayer.frame.contains(local) {
			return .cancel
			}
			let checkboxHitFrame = layers.checkboxLayer.frame.union(layers.checkboxLabelLayer.frame).insetBy(dx: -6, dy: -4)
			if checkboxHitFrame.contains(local) {
			return .checkbox
			}
			return .background
			}

			private func handleCloseConfirmationMouseDown(at windowLocation: NSPoint) -> Bool {
			switch closeConfirmationHit(at: windowLocation) {
			case .confirm:
			confirmPendingClose()
			return true
			case .cancel:
			cancelPendingClose()
			return true
			case .checkbox:
			toggleCloseConfirmationOptOut()
			return true
			case .background:
			return true
			case .outside:
			if pendingCloseTarget != nil {
			cancelPendingClose()
			return true
			}
			return false
			}
			}

			private func closeButtonTarget(at windowLocation: NSPoint) -> CloseTarget? {
			if let target = appShelfCloseButtonTarget(at: windowLocation) {
			return target
			}
			return waterfallCloseButtonTarget(at: windowLocation)
			}

			private func appShelfCloseButtonTarget(at windowLocation: NSPoint) -> CloseTarget? {
			let locationInAppShelfContent = appShelfContentLocation(at: windowLocation)

			for item in appShelfItems {
			let target = CloseTarget.app(appGroupIndex: item.item.appGroupIndex)
			guard item.closeButton.containerLayer.opacity > 0,
			canClose(app: item.item.app)
			else { continue }

			let itemFrame = interactiveFrame(for: item.containerLayer)
			let closeFrame = interactiveFrame(for: item.closeButton.containerLayer)
			let locationInItem = CGPoint(
			x: locationInAppShelfContent.x - itemFrame.minX,
			y: locationInAppShelfContent.y - itemFrame.minY
			)
			if appShelfCloseHitFrame(for: closeFrame).contains(locationInItem) {
			return target
			}
			}
			return nil
			}

			private func appShelfCloseHitFrame(for closeFrame: CGRect) -> CGRect {
			closeFrame.insetBy(
			dx: -AppShelfMetrics.closeButtonHitOutset,
			dy: -AppShelfMetrics.closeButtonHitOutset
			)
			}

			private func waterfallCloseButtonTarget(at windowLocation: NSPoint) -> CloseTarget? {
			let locationInView = convert(windowLocation, from: nil)
			let glassFrame = interactiveFrame(for: glassLayer)
			let waterfallFrame = interactiveFrame(for: waterfallLayer)
			let waterfallContentFrame = interactiveFrame(for: waterfallContentLayer)
			let locationInWaterfallContent = CGPoint(
			x: locationInView.x - glassFrame.minX - waterfallFrame.minX - waterfallContentFrame.minX,
			y: locationInView.y - glassFrame.minY - waterfallFrame.minY - waterfallContentFrame.minY
			)

			for column in waterfallColumns where interactiveFrame(for: column.containerLayer).contains(locationInWaterfallContent) {
			let columnFrame = interactiveFrame(for: column.containerLayer)
			let cardsClipFrame = interactiveFrame(for: column.cardsClipLayer)
			let locationInColumn = CGPoint(
			x: locationInWaterfallContent.x - columnFrame.minX,
			y: locationInWaterfallContent.y - columnFrame.minY
			)
			guard cardsClipFrame.contains(locationInColumn) else {
			continue
			}
			let locationInCardsClip = CGPoint(
			x: locationInColumn.x - cardsClipFrame.minX,
			y: locationInColumn.y - cardsClipFrame.minY
			)
			for card in column.cards where interactiveFrame(for: card.containerLayer).contains(locationInCardsClip) {
			guard card.closeButton.containerLayer.opacity > 0 else { continue }
			let cardFrame = interactiveFrame(for: card.containerLayer)
			let closeFrame = interactiveFrame(for: card.closeButton.containerLayer)
			let locationInCard = CGPoint(
			x: locationInCardsClip.x - cardFrame.minX,
			y: locationInCardsClip.y - cardFrame.minY
			)
			if closeFrame.insetBy(dx: -8, dy: -8).contains(locationInCard) {
			return .window(
			appGroupIndex: card.item.appGroupIndex,
			windowIndex: card.item.windowIndex,
			windowID: card.item.window.id
			)
			}
			}
			}
			return nil
			}

			private func closeConfirmationAnchor(for target: CloseTarget) -> CGPoint? {
			switch target {
			case .app(let appGroupIndex):
			guard let item = appShelfItems.first(where: { $0.item.appGroupIndex == appGroupIndex }) else {
			return nil
			}
			return CGPoint(
			x: shelfLayer.frame.minX
			+ appShelfContentLayer.frame.minX
			+ item.containerLayer.frame.minX
			+ item.closeButton.containerLayer.frame.midX,
			y: shelfLayer.frame.minY
			+ appShelfContentLayer.frame.minY
			+ item.containerLayer.frame.minY
			+ item.closeButton.containerLayer.frame.midY
			)
			case .window(let appGroupIndex, let windowIndex, let windowID):
			guard let column = waterfallColumns.first(where: { $0.column.appGroupIndex == appGroupIndex }),
			let card = column.cards.first(where: {
			$0.item.windowIndex == windowIndex && $0.item.window.id == windowID
			})
			else {
			return nil
			}
			return CGPoint(
			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
			)
			}
			}

			private func accentTintedWindowBackground(fraction: CGFloat, alpha: CGFloat) -> NSColor {
			let baseColor = resolvedTheme == .dark ? themePalette.cardBackground : NSColor.windowBackgroundColor
			let color = baseColor.blended(withFraction: fraction, of: NSColor.controlAccentColor)
			?? baseColor
			return color.withAlphaComponent(alpha)
			}

			private func isWaterfallCardSpaceFocused(_ card: WaterfallCardLayers) -> Bool {
			guard let activeSpaceFocusID else { return false }
			return card.item.primarySpaceID == activeSpaceFocusID
			}

			private func isWaterfallCardAppLinked(_ card: WaterfallCardLayers) -> Bool {
			guard card.item.appGroupIndex == appIconHoverLinkedAppGroupIndex else { return false }

			if isHorizontalMasonryMode {
			return true
			}

			if keyboardFocusedWindowID != nil {
			return false
			}

			return waterfallColumns
			.first(where: { $0.column.appGroupIndex == card.item.appGroupIndex })?
			.cards
			.sorted { lhs, rhs in
			if lhs.item.windowIndex != rhs.item.windowIndex {
			return lhs.item.windowIndex < rhs.item.windowIndex
			}
			return lhs.item.window.id < rhs.item.window.id
			}
			.first?
			.item.window.id == card.item.window.id
			}

			private func waterfallColumnWidth() -> CGFloat {
			@@ -2190,7 +6616,7 @@
			let visibleColumns = min(4, max(1, waterfallColumns.count))
			let fittingWidth = (
			waterfallLayer.bounds.width
			- WaterfallMetrics.columnPadding * 2
			- WaterfallMetrics.contentHorizontalPadding * 2
			- CGFloat(max(0, visibleColumns - 1)) * WaterfallMetrics.gap
			) / CGFloat(visibleColumns)
			return max(
			@@ -2199,15 +6625,109 @@
			)
			}

			private var isHorizontalMasonryMode: Bool {
			waterfallViewMode == .horizontalMasonry
			}

			private var resolvedTheme: QuickSwitchResolvedTheme {
			themePreference == .dark ? .dark : .light
			}

			private var themePalette: QuickSwitchThemePalette {
			QuickSwitchThemePalette.palette(for: resolvedTheme)
			}

			private var darkBackdropAmbientLayers: [CAGradientLayer] {
			[darkAmbientLeftLayer, darkAmbientCenterLayer, darkAmbientRightLayer]
			}

			private static func normalizedQuickSwitchTheme(_ theme: ThemePreference) -> ThemePreference {
			theme == .dark ? .dark : .light
			}

			private var nextThemePreference: ThemePreference {
			resolvedTheme == .dark ? .light : .dark
			}

			private var nextWaterfallViewMode: QuickSwitchWaterfallViewMode {
			isHorizontalMasonryMode ? .verticalColumns : .horizontalMasonry
			}

			private var viewModeToggleBlueColor: NSColor {
			NSColor(deviceRed: 135.0 / 255.0, green: 200.0 / 255.0, blue: 1, alpha: 1)
			}

			private var themeToggleIdleBackgroundColor: NSColor {
			toggleIdleBackgroundColor(hovered: isThemeToggleButtonHovered)
			}

			private func toggleIdleBackgroundColor(hovered: Bool) -> NSColor {
			switch resolvedTheme {
			case .light:
			return NSColor.windowBackgroundColor.withAlphaComponent(hovered ? 0.76 : 0.58)
			case .dark:
			return NSColor(calibratedRed: 24 / 255, green: 34 / 255, blue: 54 / 255, alpha: hovered ? 0.76 : 0.58)
			}
			}

			private var viewModeToggleVisualState: ViewModeToggleVisualState {
			if isHorizontalMasonryMode {
			return isViewModeToggleButtonHovered ? .verticalAvailable : .horizontalSelected
			}
			return isViewModeToggleButtonHovered ? .horizontalAvailable : .verticalSelected
			}

			private func viewModeToggleVisualStateIsSelected(_ state: ViewModeToggleVisualState) -> Bool {
			switch state {
			case .horizontalSelected, .verticalSelected:
			return true
			case .horizontalAvailable, .verticalAvailable:
			return false
			}
			}

			private var viewModeToggleIconKind: String {
			viewModeToggleVisualState.rawValue
			}

			private var viewModeToggleAccessibilityLabel: String {
			switch nextWaterfallViewMode {
			case .verticalColumns:
			return "切换到纵栏瀑布"
			case .horizontalMasonry:
			return "切换到横栏瀑布"
			}
			}

			private var themeToggleAccessibilityLabel: String {
			switch nextThemePreference {
			case .dark:
			return "切换到深色皮肤"
			case .light, .system:
			return "切换到浅色皮肤"
			}
			}

			private var waterfallMaxScrollOffset: CGFloat {
			max(0, waterfallContentWidth - waterfallLayer.bounds.width)
			guard !isHorizontalMasonryMode else { return 0 }
			return max(0, waterfallContentWidth - waterfallLayer.bounds.width)
			}

			private func clampedWaterfallOffset(_ offset: CGFloat) -> CGFloat {
			min(max(0, offset), waterfallMaxScrollOffset)
			}

			private var horizontalMasonryMaxScrollOffset: CGFloat {
			max(0, horizontalMasonryContentHeight - waterfallLayer.bounds.height)
			}

			private func clampedHorizontalMasonryOffset(_ offset: CGFloat) -> CGFloat {
			min(max(0, offset), horizontalMasonryMaxScrollOffset)
			}

			private func waterfallMaxVerticalScrollOffset(for appGroupIndex: Int) -> CGFloat {
			guard !isHorizontalMasonryMode else { return 0 }

			guard
			let column = waterfallColumns.first(where: { $0.column.appGroupIndex == appGroupIndex })
			else {
			@@ -2218,11 +6738,11 @@
			1,
			waterfallLayer.bounds.height
			- WaterfallMetrics.headerHeight
			- WaterfallMetrics.columnPadding * 2
			- WaterfallMetrics.columnVerticalPadding * 2
			)
			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 {
			@@ -2230,7 +6750,130 @@
			}

			private func waterfallMetaText(for card: QuickSwitchWindowCardViewModel) -> String {
			card.primarySpaceLabel ?? "No Space"
			windowShortcutCode(for: card) ?? ""
			}

			private func windowShortcutCode(for card: QuickSwitchWindowCardViewModel) -> String? {
			guard let appOrdinal = appShelfItems.firstIndex(where: { $0.item.appGroupIndex == card.appGroupIndex }),
			let appSymbol = singleIndexSymbol(forOrdinal: appOrdinal),
			let windowSymbol = singleIndexSymbol(forOrdinal: card.windowIndex)
			else {
			return nil
			}
			return "\(appSymbol)\(windowSymbol)"
			}

			private func singleIndexSymbol(forOrdinal ordinal: Int) -> String? {
			guard ordinal >= 0,
			ordinal < Self.appShelfIndexSymbols.count
			else {
			return nil
			}
			return Self.appShelfIndexSymbols[ordinal]
			}

			private var visibleWaterfallCards: [WaterfallCardLayers] {
			waterfallColumns.flatMap(\.cards)
			}

			private func singleVisibleWaterfallCard(appGroupIndex: Int) -> WaterfallCardLayers? {
			let cards = visibleWaterfallCards.filter { $0.item.appGroupIndex == appGroupIndex }
			return cards.count == 1 ? cards[0] : nil
			}

			private var windowShortcutFilterDimOpacity: Float {
			resolvedTheme == .dark ? 0.44 : 0.38
			}

			private func windowShortcutFilterState(for card: WaterfallCardLayers) -> WindowShortcutFilterState {
			switch windowShortcutFilterPhase {
			case .appPending:
			guard let pending = windowIndexKeyPending else { return .none }
			return card.item.appGroupIndex == pending.appGroupIndex ? .matched : .dimmed
			case .targetPreCommit:
			guard let snapshot = lastWindowShortcutPreCommitFilterSnapshot else { return .none }
			if card.item.window.id == snapshot.targetWindowID {
			return .target
			}
			if snapshot.dimmedWindowIDs.contains(card.item.window.id) {
			return .dimmed
			}
			if snapshot.matchedWindowIDs.contains(card.item.window.id) {
			return .matched
			}
			return .none
			case .none, .invalid, .expired:
			return .none
			}
			}

			private func makeWindowShortcutPreCommitFilterSnapshot(
			target card: WaterfallCardLayers,
			code: String
			) -> WindowShortcutPreCommitFilterSnapshot {
			let targetWindowID = card.item.window.id
			let allWindowIDs = visibleWaterfallCards.map { $0.item.window.id }
			return WindowShortcutPreCommitFilterSnapshot(
			targetCode: code,
			targetWindowID: targetWindowID,
			matchedWindowIDs: [targetWindowID],
			dimmedWindowIDs: allWindowIDs.filter { $0 != targetWindowID }.sorted()
			)
			}

			private func makeWindowShortcutFilterReport() -> WindowShortcutFilterReport {
			switch windowShortcutFilterPhase {
			case .appPending:
			guard let pending = windowIndexKeyPending else {
			return emptyWindowShortcutFilterReport(phase: .none)
			}
			let cards = visibleWaterfallCards
			let matched = cards
			.filter { $0.item.appGroupIndex == pending.appGroupIndex }
			.map { $0.item.window.id }
			.sorted()
			let dimmed = cards
			.filter { $0.item.appGroupIndex != pending.appGroupIndex }
			.map { $0.item.window.id }
			.sorted()
			return WindowShortcutFilterReport(
			active: true,
			phase: .appPending,
			pendingAppGroupIndex: pending.appGroupIndex,
			prefix: pending.appSymbol,
			matchedWindowIDs: matched,
			dimmedWindowIDs: dimmed
			)
			case .targetPreCommit:
			guard let snapshot = lastWindowShortcutPreCommitFilterSnapshot else {
			return emptyWindowShortcutFilterReport(phase: .none)
			}
			return WindowShortcutFilterReport(
			active: true,
			phase: .targetPreCommit,
			pendingAppGroupIndex: nil,
			prefix: snapshot.targetCode,
			matchedWindowIDs: snapshot.matchedWindowIDs,
			dimmedWindowIDs: snapshot.dimmedWindowIDs
			)
			case .invalid, .expired:
			return emptyWindowShortcutFilterReport(phase: windowShortcutFilterPhase)
			case .none:
			return emptyWindowShortcutFilterReport(phase: .none)
			}
			}

			private func emptyWindowShortcutFilterReport(
			phase: WindowShortcutFilterPhase
			) -> WindowShortcutFilterReport {
			WindowShortcutFilterReport(
			active: false,
			phase: phase,
			pendingAppGroupIndex: nil,
			prefix: nil,
			matchedWindowIDs: [],
			dimmedWindowIDs: []
			)
			}

			private func waterfallStateText(for card: QuickSwitchWindowCardViewModel) -> String {
			@@ -2248,24 +6891,63 @@
			return states.joined(separator: " / ")
			}

			private func spaceColor(for space: QuickSwitchSpaceViewModel) -> NSColor {
			if space.isCurrent {
			return NSColor.windowBackgroundColor.withAlphaComponent(0.76)
			}
			if space.windowCount > 0 {
			return NSColor.controlBackgroundColor.withAlphaComponent(0.56)
			private var spaceLaneOccupiedColor: NSColor {
			if resolvedTheme == .dark {
			return NSColor(calibratedRed: 10 / 255, green: 132 / 255, blue: 1, alpha: 1)
			}

			return NSColor.controlBackgroundColor.withAlphaComponent(0.26)
			return NSColor(calibratedRed: 0, green: 122 / 255, blue: 1, alpha: 1)
			}

			private var spaceLaneLockedFillColor: NSColor {
			if resolvedTheme == .dark {
			return NSColor(calibratedRed: 58 / 255, green: 148 / 255, blue: 1, alpha: 0.86)
			}

			return NSColor(calibratedRed: 90 / 255, green: 171 / 255, blue: 1, alpha: 0.82)
			}

			private func spaceLaneIdleOccupiedGradientColors() -> [NSColor] {
			if resolvedTheme == .dark {
			let blue = NSColor(calibratedRed: 18 / 255, green: 42 / 255, blue: 70 / 255, alpha: 0.92)
			let surface = NSColor(calibratedRed: 22 / 255, green: 34 / 255, blue: 50 / 255, alpha: 0.78)
			return [blue, surface]
			}

			return [
			NSColor(calibratedRed: 232 / 255, green: 246 / 255, blue: 1, alpha: 1),
			NSColor.white
			]
			}

			private func applySpaceLaneGradientFill(to layer: CALayer, colors: [NSColor]) {
			if let gradientLayer = layer as? CAGradientLayer {
			gradientLayer.colors = colors.map(\.cgColor)
			gradientLayer.locations = [0, 1].map(NSNumber.init(value:))
			gradientLayer.startPoint = CGPoint(x: 0.5, y: 1.0)
			gradientLayer.endPoint = CGPoint(x: 0.5, y: 0.0)
			}
			layer.backgroundColor = NSColor.clear.cgColor
			}

			private func applySpaceLaneSolidFill(to layer: CALayer, color: NSColor) {
			if let gradientLayer = layer as? CAGradientLayer {
			gradientLayer.colors = nil
			gradientLayer.locations = nil
			}
			layer.backgroundColor = color.cgColor
			}

			private func makeFullscreenMarkerLayer(for space: QuickSwitchSpaceViewModel) -> CALayer? {
			guard space.type == .fullscreen else { return nil }

			let layer = CALayer()
			layer.cornerRadius = 1.5
			layer.backgroundColor = NSColor.secondaryLabelColor.withAlphaComponent(space.isCurrent ? 0.46 : 0.32).cgColor
			return layer
			let shapeLayer = CAShapeLayer()
			shapeLayer.fillColor = NSColor.clear.cgColor
			shapeLayer.strokeColor = NSColor.secondaryLabelColor.withAlphaComponent(space.isCurrent ? 0.42 : 0.28).cgColor
			shapeLayer.lineWidth = 1.2
			shapeLayer.lineCap = .round
			shapeLayer.lineJoin = .round
			return shapeLayer
			}

			private func makeTextLayer(
			@@ -2286,31 +6968,234 @@
			return textLayer
			}

			private func makeCloseButtonLayers() -> CloseButtonLayers {
			let container = CALayer()
			container.cornerRadius = 8
			container.masksToBounds = false
			container.backgroundColor = NSColor.systemRed.withAlphaComponent(0.92).cgColor
			container.borderColor = NSColor.white.withAlphaComponent(0.72).cgColor
			container.borderWidth = 0.8
			container.shadowColor = NSColor.black.cgColor
			container.shadowOpacity = 0.14
			container.shadowRadius = 5
			container.shadowOffset = CGSize(width: 0, height: -1)
			container.opacity = 0

			let glyph = CAShapeLayer()
			glyph.contentsScale = backingScaleFactor
			glyph.strokeColor = NSColor.white.cgColor
			glyph.fillColor = NSColor.clear.cgColor
			glyph.lineCap = .round
			glyph.lineJoin = .round
			container.addSublayer(glyph)

			return CloseButtonLayers(containerLayer: container, glyphLayer: glyph)
			}

			private func makeCloseConfirmationLayers() -> CloseConfirmationLayers {
			let container = CALayer()
			container.masksToBounds = false
			container.backgroundColor = NSColor.clear.cgColor
			container.shadowColor = NSColor.black.cgColor
			container.shadowOpacity = 0.20
			container.shadowRadius = 20
			container.shadowOffset = CGSize(width: 0, height: -8)
			container.zPosition = 200

			let background = CAShapeLayer()
			background.contentsScale = backingScaleFactor
			background.fillColor = NSColor.windowBackgroundColor.withAlphaComponent(0.985).cgColor
			background.strokeColor = NSColor.separatorColor.withAlphaComponent(0.36).cgColor
			background.lineWidth = 1

			let title = makeTextLayer(
			string: "",
			fontSize: 15,
			weight: .semibold,
			color: .labelColor
			)
			let message = makeTextLayer(
			string: "",
			fontSize: 13,
			weight: .regular,
			color: .secondaryLabelColor
			)
			message.truncationMode = .end

			let checkbox = CALayer()
			checkbox.cornerRadius = 4
			checkbox.borderWidth = 1
			checkbox.borderColor = NSColor.separatorColor.withAlphaComponent(0.48).cgColor
			checkbox.backgroundColor = NSColor.clear.cgColor

			let checkmark = makeTextLayer(
			string: "",
			fontSize: 11,
			weight: .bold,
			color: .white,
			alignment: .center
			)

			let checkboxLabel = makeTextLayer(
			string: "以后不再提醒",
			fontSize: 13,
			weight: .regular,
			color: .secondaryLabelColor
			)

			let confirmButton = CALayer()
			confirmButton.cornerRadius = 7
			confirmButton.backgroundColor = NSColor.systemRed.withAlphaComponent(0.94).cgColor

			let confirmText = makeTextLayer(
			string: "关闭",
			fontSize: 13,
			weight: .semibold,
			color: .white,
			alignment: .center
			)

			let cancelButton = CALayer()
			cancelButton.cornerRadius = 7
			cancelButton.backgroundColor = NSColor.systemFill.withAlphaComponent(0.16).cgColor
			cancelButton.borderColor = NSColor.separatorColor.withAlphaComponent(0.22).cgColor
			cancelButton.borderWidth = 1

			let cancelText = makeTextLayer(
			string: "取消",
			fontSize: 13,
			weight: .medium,
			color: .labelColor,
			alignment: .center
			)

			container.addSublayer(background)
			container.addSublayer(title)
			container.addSublayer(message)
			container.addSublayer(checkbox)
			checkbox.addSublayer(checkmark)
			container.addSublayer(checkboxLabel)
			container.addSublayer(confirmButton)
			confirmButton.addSublayer(confirmText)
			container.addSublayer(cancelButton)
			cancelButton.addSublayer(cancelText)

			return CloseConfirmationLayers(
			containerLayer: container,
			backgroundLayer: background,
			titleLayer: title,
			messageLayer: message,
			checkboxLayer: checkbox,
			checkboxMarkLayer: checkmark,
			checkboxLabelLayer: checkboxLabel,
			confirmButtonLayer: confirmButton,
			confirmButtonTextLayer: confirmText,
			cancelButtonLayer: cancelButton,
			cancelButtonTextLayer: cancelText
			)
			}

			private func makeWindowBlocks(count: Int, space: QuickSwitchSpaceViewModel) -> [CALayer] {
			guard count > 0 else { return [] }

			return (0..<count).map { _ in
			let layer = CALayer()
			layer.cornerRadius = 3
			layer.backgroundColor = (space.type == .fullscreen
			? NSColor.labelColor.withAlphaComponent(0.20)
			: NSColor.labelColor.withAlphaComponent(0.18)
			).cgColor
			layer.backgroundColor = spaceLaneOccupiedColor
			.withAlphaComponent(space.isCurrent ? 0.72 : 0.58)
			.cgColor
			return layer
			}
			}

			private func appIdentifierText(for appNames: [String]) -> String {
			var identifiers = appNames.prefix(3).compactMap { name -> String? in
			private func appIdentifierText(for space: QuickSwitchSpaceViewModel) -> String {
			if space.type == .fullscreen,
			let appName = space.appNames.first?.trimmingCharacters(in: .whitespacesAndNewlines),
			!appName.isEmpty {
			return appName
			}

			var identifiers = space.appNames.prefix(3).compactMap { name -> String? in
			let trimmed = name.trimmingCharacters(in: .whitespacesAndNewlines)
			return trimmed.first.map { String($0) }
			}

			if appNames.count > 3 {
			identifiers.append("+\(appNames.count - 3)")
			if space.appNames.count > 3 {
			identifiers.append("+\(space.appNames.count - 3)")
			}

			return identifiers.joined(separator: " ")
			}

			private func splitViewAppNames(for space: QuickSwitchSpaceViewModel) -> [String] {
			guard space.type == .fullscreen else { return [] }

			let names = space.splitViewAppNames
			.prefix(2)
			.map { $0.trimmingCharacters(in: .whitespacesAndNewlines) }
			.filter { !$0.isEmpty }

			guard names.count >= 2 else { return [] }
			return names
			}

			private func layoutFullscreenMarkerLayer(
			_ layer: CALayer,
			in segmentBounds: CGRect,
			isSplitView: Bool = false
			) {
			let markerFrame = fullscreenMarkerFrame(in: segmentBounds)
			layer.frame = markerFrame

			guard let shapeLayer = layer as? CAShapeLayer else { return }

			let bounds = shapeLayer.bounds
			if isSplitView {
			let path = CGMutablePath()
			path.move(to: CGPoint(x: bounds.midX, y: bounds.minY))
			path.addLine(to: CGPoint(x: bounds.midX, y: bounds.maxY))
			shapeLayer.path = path
			shapeLayer.lineCap = .butt
			return
			}

			let cornerLength = min(12, max(7, min(bounds.width, bounds.height) * 0.28))
			let path = CGMutablePath()

			path.move(to: CGPoint(x: 0, y: cornerLength))
			path.addLine(to: CGPoint(x: 0, y: 0))
			path.addLine(to: CGPoint(x: cornerLength, y: 0))

			path.move(to: CGPoint(x: bounds.maxX - cornerLength, y: 0))
			path.addLine(to: CGPoint(x: bounds.maxX, y: 0))
			path.addLine(to: CGPoint(x: bounds.maxX, y: cornerLength))

			path.move(to: CGPoint(x: bounds.maxX, y: bounds.maxY - cornerLength))
			path.addLine(to: CGPoint(x: bounds.maxX, y: bounds.maxY))
			path.addLine(to: CGPoint(x: bounds.maxX - cornerLength, y: bounds.maxY))

			path.move(to: CGPoint(x: cornerLength, y: bounds.maxY))
			path.addLine(to: CGPoint(x: 0, y: bounds.maxY))
			path.addLine(to: CGPoint(x: 0, y: bounds.maxY - cornerLength))

			shapeLayer.path = path
			shapeLayer.lineCap = .round
			}

			private func fullscreenMarkerFrame(in segmentBounds: CGRect) -> CGRect {
			let topReserved: CGFloat = 32
			let bottomReserved: CGFloat = 16
			let availableHeight = max(20, segmentBounds.height - topReserved - bottomReserved)
			let markerHeight = min(30, max(20, availableHeight))
			let markerCenterY = bottomReserved + availableHeight * 0.5
			let markerY = max(8, min(segmentBounds.height - topReserved - markerHeight, markerCenterY - markerHeight * 0.5))

			return CGRect(
			x: 10,
			y: markerY,
			width: max(1, segmentBounds.width - 20),
			height: markerHeight
			)
			}

			private func columnSelectionHistoryReports() -> [[String: Int]] {
			@@ -2327,6 +7212,7 @@
			private func appShelfItemReports() -> [[String: Any]] {
			appShelfItems.enumerated().map { index, item in
			let visibleFrame = item.containerLayer.frame.offsetBy(dx: appShelfContentLayer.frame.minX, dy: 0)
			let magneticState = appShelfMagneticState(for: item)
			return [
			"index": index,
			"name": item.item.app.name,
			@@ -2337,28 +7223,61 @@
			"isSelected": item.item.appGroupIndex == effectiveSelection?.appGroupIndex,
			"isHovered": item.item.appGroupIndex == effectiveHoveredAppGroupIndex,
			"isSpaceFocused": spaceFocusWindowCount(for: item.item.appGroupIndex) > 0,
			"isMagneticNeighbor": magneticState.isNeighbor,
			"magneticInfluence": Double(magneticState.influence),
			"magneticLift": Double(magneticState.lift),
			"visualStates": appShelfVisualStates(for: item),
			"zPosition": Double(item.containerLayer.zPosition),
			"hasMinimizedWindows": item.item.hasMinimizedWindows,
			"hasFullscreenWindows": item.item.hasFullscreenWindows,
			"frame": dictionary(from: item.containerLayer.frame),
			"visibleFrame": dictionary(from: visibleFrame),
			"containerBorderWidth": Double(item.containerLayer.borderWidth),
			"containerBorderColor": colorDictionary(from: item.containerLayer.borderColor),
			"iconFrame": dictionary(from: item.iconLayer.frame),
			"iconBorderWidth": Double(item.iconLayer.borderWidth),
			"iconBorderColor": colorDictionary(from: item.iconLayer.borderColor),
			"backgroundFrame": dictionary(from: item.backgroundLayer.frame),
			"backgroundColor": colorDictionary(from: item.backgroundLayer.backgroundColor),
			"backgroundBorderWidth": Double(item.backgroundLayer.borderWidth),
			"backgroundShadowOpacity": Double(item.backgroundLayer.shadowOpacity),
			"backgroundShadowRadius": Double(item.backgroundLayer.shadowRadius),
			"indexText": item.indexLayer.string ?? "",
			"indexFrame": dictionary(from: item.indexLayer.frame),
			"indexVisible": !item.indexLayer.isHidden && item.indexLayer.opacity > 0,
			"indexFontSize": Double(item.indexLayer.fontSize),
			"indexOpacity": Double(item.indexLayer.opacity),
			"indexColor": colorDictionary(from: item.indexLayer.foregroundColor),
			"labelFrame": dictionary(from: item.labelLayer.frame),
			"labelTruncationMode": "middle",
			"badgeVisible": !item.badgeLayer.isHidden,
			"badgeText": item.badgeLayer.string ?? ""
			"badgeText": item.badgeLayer.string ?? "",
			"closeButtonVisible": item.closeButton.containerLayer.opacity > 0,
			"closeButtonFrame": dictionary(from: item.closeButton.containerLayer.frame),
			"closeButtonHitFrame": dictionary(from: appShelfCloseHitFrame(for: item.closeButton.containerLayer.frame)),
			"closeButtonSize": Double(item.closeButton.containerLayer.bounds.width),
			"closeButtonFillColor": colorDictionary(from: item.closeButton.containerLayer.backgroundColor),
			"closeButtonGlyphColor": colorDictionary(from: item.closeButton.glyphLayer.strokeColor),
			"closeButtonGlyphLineWidth": Double(item.closeButton.glyphLayer.lineWidth)
			] as [String: Any]
			}
			}

			private func appShelfVisualStates(for item: AppShelfItemLayers) -> [String] {
			var states: [String] = []
			if item.item.appGroupIndex == effectiveSelection?.appGroupIndex {
			let isSelected = item.item.appGroupIndex == effectiveSelection?.appGroupIndex
			let isHovered = item.item.appGroupIndex == effectiveHoveredAppGroupIndex
			let magneticState = appShelfMagneticState(for: item)
			if shouldShowSelectedVisual(isSelected: isSelected, isHovered: isHovered) {
			states.append("selected")
			} else if isSelected {
			states.append("selectedVisualSuppressed")
			}
			if item.item.appGroupIndex == effectiveHoveredAppGroupIndex {
			if isHovered {
			states.append("hover")
			}
			if magneticState.isNeighbor {
			states.append("magneticNeighbor")
			}
			if spaceFocusWindowCount(for: item.item.appGroupIndex) > 0 {
			states.append("spaceFocused")
			@@ -2370,21 +7289,56 @@
			return states
			}

			private func waterfallColumnVisualStates(for column: WaterfallColumnLayers) -> [String] {
			var states: [String] = []
			if column.column.appGroupIndex == effectiveHoveredAppGroupIndex {
			states.append("hover")
			}
			if spaceFocusWindowCount(for: column.column.appGroupIndex) > 0 {
			states.append("spaceFocused")
			}
			return states
			}

			private func waterfallColumnReports() -> [[String: Any]] {
			waterfallColumns.map { column in
			let visibleFrame = column.containerLayer.frame.offsetBy(dx: waterfallContentLayer.frame.minX, dy: 0)
			let appGroupIndex = column.column.appGroupIndex
			let isHovered = appGroupIndex == effectiveHoveredAppGroupIndex
			let firstCardFrame = column.cards.first?.containerLayer.frame
			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 = visibleFirstCardFrame.map {
			column.containerLayer.bounds.height - $0.maxY
			}

			return [
			"appGroupIndex": appGroupIndex,
			"appName": column.column.app.name,
			"bundleIdentifier": column.column.app.bundleIdentifier,
			"windowCount": column.column.windows.count,
			"isHovered": isHovered,
			"visualStates": waterfallColumnVisualStates(for: column),
			"spaceFocusWindowCount": spaceFocusWindowCount(for: appGroupIndex),
			"isSpaceFocused": spaceFocusWindowCount(for: appGroupIndex) > 0,
			"spaceFocusDirection": spaceFocusDirection(for: appGroupIndex),
			"frame": dictionary(from: column.containerLayer.frame),
			"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),
			"appNameAlignment": column.appNameLayer.alignmentMode.rawValue,
			"appNameColor": colorDictionary(from: column.appNameLayer.foregroundColor),
			"countFrame": dictionary(from: column.countLayer.frame),
			"countColor": colorDictionary(from: column.countLayer.foregroundColor),
			"verticalScrollOffset": Double(waterfallColumnScrollOffsets[appGroupIndex] ?? 0),
			"maxVerticalScrollOffset": Double(waterfallMaxVerticalScrollOffset(for: appGroupIndex)),
			"cards": waterfallCardReports(for: column)
			@@ -2442,10 +7396,14 @@
			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]
			let shortcutFilterState = windowShortcutFilterState(for: card)
			let shortcutFilterOpacity = shortcutFilterState == .dimmed
			? windowShortcutFilterDimOpacity
			: Float(1)

			var report = [
			"appGroupIndex": card.item.appGroupIndex,
			@@ -2457,19 +7415,40 @@
			"titleIsEmpty": card.item.window.title.isEmpty,
			"primarySpaceID": card.item.primarySpaceID ?? NSNull(),
			"primarySpaceLabel": card.item.primarySpaceLabel ?? NSNull(),
			"windowShortcutCode": waterfallMetaText(for: card.item),
			"isMinimized": card.item.window.isMinimized,
			"isFullscreen": card.item.window.isFullscreen,
			"identifierSource": "\(card.item.window.identifierSource)",
			"isSelected": card.item.window.id == effectiveSelection?.windowID,
			"isKeyboardFocused": card.item.window.id == keyboardFocusedWindowID,
			"isHorizontalAppDefault": isHorizontalAppDefaultCard(card),
			"windowShortcutFilterState": shortcutFilterState.rawValue,
			"windowShortcutFilterOpacity": Double(shortcutFilterOpacity),
			"visualStates": waterfallCardVisualStates(for: card),
			"thumbnailStrategy": thumbnailStrategyString(for: card.item.window),
			"screenshotSource": screenshotSourceString(screenshotSource, for: card.item.window),
			"screenshotFallbackReason": screenshotFallbackReasonString(screenshotSource),
			"screenshotNotRequestedReason": screenshotSkippedReasonsByWindowID[card.item.window.id] ?? NSNull(),
			"backgroundColor": colorDictionary(from: card.containerLayer.backgroundColor),
			"shadowOpacity": Double(card.containerLayer.shadowOpacity),
			"shadowRadius": Double(card.containerLayer.shadowRadius),
			"thumbnailFrame": dictionary(from: card.thumbnailLayer.frame),
			"titleBarFrame": dictionary(from: card.titleBarLayer.frame),
			"titleBarBackgroundColor": colorDictionary(from: card.titleBarLayer.backgroundColor),
			"titleBarBorderWidth": Double(card.titleBarLayer.borderWidth),
			"titleFrame": dictionary(from: card.titleLayer.frame),
			"metaFrame": dictionary(from: card.metaLayer.frame),
			"appIconFrame": dictionary(from: card.appIconLayer.frame),
			"stateFrame": dictionary(from: card.stateLayer.frame),
			"closeButtonVisible": card.closeButton.containerLayer.opacity > 0,
			"closeButtonFrame": dictionary(from: card.closeButton.containerLayer.frame),
			"closeButtonSize": Double(card.closeButton.containerLayer.bounds.width),
			"closeButtonFillColor": colorDictionary(from: card.closeButton.containerLayer.backgroundColor),
			"closeButtonGlyphColor": colorDictionary(from: card.closeButton.glyphLayer.strokeColor),
			"closeButtonGlyphLineWidth": Double(card.closeButton.glyphLayer.lineWidth),
			"shineVisible": card.shineLayer.opacity > 0,
			"zPosition": Double(card.containerLayer.zPosition),
			"bounds": dictionary(from: card.containerLayer.bounds),
			"frame": dictionary(from: card.containerLayer.frame),
			"visibleFrame": dictionary(from: visibleFrame),
			"titleTruncationMode": "middle"
			@@ -2562,14 +7541,42 @@

			private func waterfallCardVisualStates(for card: WaterfallCardLayers) -> [String] {
			var states: [String] = []
			if card.item.window.id == effectiveSelection?.windowID {
			let isSelected = card.item.window.id == effectiveSelection?.windowID
			let isHovered = card.item.window.id == hoveredWindowID
			let isKeyboardFocused = card.item.window.id == keyboardFocusedWindowID
			let isHorizontalAppDefaultFocused = isHorizontalAppDefaultCard(card)
			let isAppLinked = isWaterfallCardAppLinked(card)
			if shouldShowSelectedVisual(isSelected: isSelected, isHovered: isHovered)
			\|\| isKeyboardFocused
			\|\| isHorizontalAppDefaultFocused {
			states.append("selected")
			} else if isSelected {
			states.append("selectedVisualSuppressed")
			}
			if card.item.window.id == hoveredWindowID {
			if isKeyboardFocused {
			states.append("keyboardFocused")
			}
			if isHorizontalAppDefaultFocused {
			states.append("appDefault")
			}
			if isHovered {
			states.append("hover")
			}
			if card.item.primarySpaceID == activeSpaceFocusID {
			if isAppLinked {
			states.append("appLinked")
			}
			if isWaterfallCardSpaceFocused(card) {
			states.append("spaceFocused")
			}
			switch windowShortcutFilterState(for: card) {
			case .matched:
			states.append("shortcutMatched")
			case .dimmed:
			states.append("shortcutDimmed")
			case .target:
			states.append("shortcutTarget")
			case .none:
			break
			}
			if card.item.window.isMinimized {
			states.append("minimized")
			@@ -2584,25 +7591,111 @@
			window?.backingScaleFactor ?? NSScreen.main?.backingScaleFactor ?? 2
			}

			private func spaceLaneDisplayGroupReports() -> [[String: Any]] {
			spaceLaneDisplayGroups.map { group in
			let visibleFrame = group.containerLayer.frame.offsetBy(dx: spaceLaneContentLayer.frame.minX, dy: 0)
			return [
			"displayUUID": group.display.displayUUID,
			"displayIndex": group.display.displayIndex,
			"displayLabel": group.display.displayLabel,
			"physical": group.display.physical,
			"spaceCount": group.segments.count,
			"spaceIDs": group.segments.map(\.space.id),
			"spaceLabels": group.segments.map(\.space.label),
			"frame": dictionary(from: group.containerLayer.frame),
			"visibleFrame": dictionary(from: visibleFrame),
			"backgroundColor": colorDictionary(from: group.containerLayer.backgroundColor),
			"borderColor": colorDictionary(from: group.containerLayer.borderColor),
			"borderWidth": Double(group.containerLayer.borderWidth),
			"shadowOpacity": Double(group.containerLayer.shadowOpacity),
			"shadowRadius": Double(group.containerLayer.shadowRadius),
			"groupGap": Double(SpaceLaneMetrics.groupGap),
			"groupHorizontalPadding": Double(SpaceLaneMetrics.groupHorizontalPadding),
			"groupVerticalPadding": Double(SpaceLaneMetrics.groupVerticalPadding),
			"segmentGap": Double(SpaceLaneMetrics.segmentGap)
			] as [String: Any]
			}
			}

			private func spaceLaneSegmentReports() -> [[String: Any]] {
			currentViewModel?.displays.flatMap { display in
			display.spaces.compactMap { space in
			guard let segment = spaceLaneSegments.first(where: { $0.space.id == space.id }) else {
			return nil
			}
			let visibleFrame = segment.containerLayer.frame.offsetBy(dx: spaceLaneContentLayer.frame.minX, dy: 0)
			let isAppAssociated = appHoverAssociatedSpaceIDs.contains(space.id)
			let isWindowAssociated = space.id == windowHoverAssociatedSpaceID
			let isLocked = space.id == currentViewModel?.lockedSpaceID
			let isActive = space.id == activeSpaceFocusID \|\| isLocked
			let isAssociated = (isAppAssociated \|\| isWindowAssociated) && !isActive
			let usesLightActiveFill = resolvedTheme == .dark && space.windowCount > 0 && !isLocked && (isActive \|\| isAssociated)
			let group = spaceLaneDisplayGroup(containingSpaceID: space.id)
			let visibleFrame = segment.containerLayer.frame.offsetBy(
			dx: (group?.containerLayer.frame.minX ?? 0) + spaceLaneContentLayer.frame.minX,
			dy: group?.containerLayer.frame.minY ?? 0
			)
			let fullscreenMarkerFrame = segment.fullscreenMarkerLayer?.frame
			let fullscreenMarkerCenterRatio = fullscreenMarkerFrame.map {
			Double($0.midY / max(1, segment.containerLayer.bounds.height))
			}
			let splitAppNames = splitViewAppNames(for: space)
			let splitAppLabelFrames = segment.splitAppLayers.map { dictionary(from: $0.frame) }
			return [
			"displayUUID": display.displayUUID,
			"displayLabel": display.displayLabel,
			"spaceID": space.id,
			"label": space.label,
			"type": spaceTypeName(space.type),
			"visualStates": visualStates(for: space),
			"usesLightActiveFill": usesLightActiveFill,
			"foregroundContrastStyle": usesLightActiveFill ? "darkOnLight" : "themeDefault",
			"fullscreenMarkerVisible": segment.fullscreenMarkerLayer != nil,
			"fullscreenMarkerKind": fullscreenMarkerKind(
			markerLayer: segment.fullscreenMarkerLayer,
			splitAppNames: splitAppNames
			),
			"fullscreenMarkerPathStyle": fullscreenMarkerPathStyle(
			markerLayer: segment.fullscreenMarkerLayer,
			splitAppNames: splitAppNames
			),
			"fullscreenMarkerFrame": fullscreenMarkerFrame.map { dictionary(from: $0) } ?? NSNull(),
			"fullscreenMarkerCenterRatio": fullscreenMarkerCenterRatio ?? NSNull(),
			"splitViewAppNames": splitAppNames,
			"splitViewLabelFrames": splitAppLabelFrames,
			"splitViewLabelColors": segment.splitAppLayers.map {
			colorDictionary(from: $0.foregroundColor)
			},
			"windowBlockCount": segment.windowBlocks.count,
			"windowBlockColors": segment.windowBlocks.map { colorDictionary(from: $0.backgroundColor) },
			"windowBlockFrames": segment.windowBlocks.map { dictionary(from: $0.frame) },
			"labelColor": colorDictionary(from: segment.labelLayer.foregroundColor),
			"countText": string(from: segment.countLayer.string),
			"countVisible": !segment.countLayer.isHidden && segment.countLayer.opacity > 0,
			"countColor": colorDictionary(from: segment.countLayer.foregroundColor),
			"appColor": colorDictionary(from: segment.appLayer.foregroundColor),
			"fullscreenMarkerStrokeColor": colorDictionary(
			from: (segment.fullscreenMarkerLayer as? CAShapeLayer)?.strokeColor
			),
			"backgroundKind": spaceLaneFillKind(for: segment.containerLayer),
			"backgroundColor": colorDictionary(from: segment.containerLayer.backgroundColor),
			"gradientColors": gradientColorDictionaries(from: segment.containerLayer),
			"borderColor": colorDictionary(from: segment.containerLayer.borderColor),
			"borderWidth": Double(segment.containerLayer.borderWidth),
			"shadowColor": colorDictionary(from: segment.containerLayer.shadowColor),
			"shadowOpacity": Double(segment.containerLayer.shadowOpacity),
			"shadowRadius": Double(segment.containerLayer.shadowRadius),
			"shadowOffset": [
			"width": Double(segment.containerLayer.shadowOffset.width),
			"height": Double(segment.containerLayer.shadowOffset.height)
			],
			"appFrame": dictionary(from: segment.appLayer.frame),
			"frame": dictionary(from: segment.containerLayer.frame),
			"visibleFrame": dictionary(from: visibleFrame),
			"isCurrent": space.isCurrent,
			"isHovered": space.id == hoveredSpaceID,
			"isHovered": space.id == activeSpaceFocusID,
			"isFocused": space.id == activeSpaceFocusID,
			"isAppAssociated": isAppAssociated,
			"isWindowAssociated": isWindowAssociated,
			"windowCount": space.windowCount,
			"appCount": space.appCount,
			"appNames": space.appNames
			@@ -2611,19 +7704,47 @@
			} ?? []
			}

			private func spaceLaneDisplayGroup(containingSpaceID spaceID: UInt64) -> SpaceLaneDisplayGroupLayers? {
			spaceLaneDisplayGroups.first { group in
			group.segments.contains { $0.space.id == spaceID }
			}
			}

			private func fullscreenMarkerKind(markerLayer: CALayer?, splitAppNames: [String]) -> String {
			guard markerLayer != nil else { return "none" }
			return splitAppNames.count >= 2 ? "splitViewPair" : "cornerBracket"
			}

			private func fullscreenMarkerPathStyle(markerLayer: CALayer?, splitAppNames: [String]) -> String {
			guard markerLayer != nil else { return "none" }
			return splitAppNames.count >= 2 ? "centerDividerOnly" : "cornerBracket"
			}

			private func visualStates(for space: QuickSwitchSpaceViewModel) -> [String] {
			var states: [String] = []
			if space.isCurrent {
			states.append("current")
			}
			if space.id == hoveredSpaceID {
			if appHoverAssociatedSpaceIDs.contains(space.id) {
			states.append("appAssociated")
			}
			if space.id == windowHoverAssociatedSpaceID {
			states.append("windowAssociated")
			}
			if space.id == activeSpaceFocusID {
			states.append("hover")
			}
			if space.id == activeSpaceFocusID {
			states.append("focused")
			}
			if space.id == currentViewModel?.lockedSpaceID {
			states.append("locked")
			}
			if space.type == .fullscreen {
			states.append("fullscreen")
			}
			if splitViewAppNames(for: space).count >= 2 {
			states.append("splitView")
			}
			return states
			}
			@@ -2649,4 +7770,67 @@
			"height": Double(rect.height)
			]
			}

			private func string(from textLayerValue: Any?) -> String {
			if let string = textLayerValue as? String {
			return string
			}
			if let attributedString = textLayerValue as? NSAttributedString {
			return attributedString.string
			}
			return ""
			}

			private func colorDictionary(from color: CGColor?) -> [String: Double] {
			guard let color,
			let nsColor = NSColor(cgColor: color)?.usingColorSpace(.deviceRGB)
			else {
			return [
			"red": 0,
			"green": 0,
			"blue": 0,
			"alpha": 0
			]
			}

			return [
			"red": Double(nsColor.redComponent),
			"green": Double(nsColor.greenComponent),
			"blue": Double(nsColor.blueComponent),
			"alpha": Double(nsColor.alphaComponent)
			]
			}

			private func gradientColorDictionaries(from layer: CALayer) -> [[String: Double]] {
			guard let gradientLayer = layer as? CAGradientLayer else { return [] }
			return (gradientLayer.colors ?? []).map { color in
			let cgColor = color as! CGColor
			return colorDictionary(from: cgColor)
			}
			}

			private var darkBackdropLayerCount: Int {
			darkBackdropAmbientLayers.count + 1
			}

			private var darkBackdropLayersVisible: Bool {
			resolvedTheme == .dark
			&& darkBackdropAmbientLayers.allSatisfy { !$0.isHidden }
			&& !darkVignetteLayer.isHidden
			}

			private func backgroundGradientColorReports() -> [[String: Double]] {
			gradientColorDictionaries(from: backgroundLayer)
			}

			private func spaceLaneFillKind(for layer: CALayer) -> String {
			if !gradientColorDictionaries(from: layer).isEmpty {
			return "gradient"
			}
			let background = colorDictionary(from: layer.backgroundColor)
			if background["alpha", default: 0] <= 0.01 {
			return "clear"
			}
			return "solid"
			}
			}