crazy-macs/aligner.git

			@@ -22,11 +22,17 @@
			private let waterfallLayer = CALayer()
			private let waterfallContentLayer = CALayer()
			private lazy var closeConfirmationLayers = makeCloseConfirmationLayers()
			private let closeFeedbackLayer = CALayer()
			private let closeFeedbackTextLayer = CATextLayer()
			private let settingsButtonLayer = CALayer()
			private let settingsButtonIconLayer = CALayer()
			private let settingsButtonFallbackTextLayer = CATextLayer()
			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
			@@ -40,16 +46,25 @@
			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 isSettingsButtonHovered = 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 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 keyboardCommandsApplied: [String] = []
			@@ -70,8 +85,17 @@
			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 onOpenSettings: (() -> Void)?
			var onRequestClose: ((QuickSwitchCloseRequest) -> Void)?
			var onCloseConfirmationDisabled: (() -> Void)?

			@@ -108,9 +132,92 @@
			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
			}

			private struct SpaceLaneSegmentLayers {
			@@ -119,8 +226,15 @@
			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 {
			@@ -161,6 +275,22 @@
			let closeButton: CloseButtonLayers
			}

			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 {
			static let normalIconSize: CGFloat = 56
			static let hoverIconSize: CGFloat = 68
			@@ -184,11 +314,25 @@
			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 = 138
			static let cardGap: CGFloat = 12
			static let revealPadding: CGFloat = 24
			static let horizontalRevealPadding: CGFloat = 0
			}

			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 {
			@@ -200,6 +344,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) {
			@@ -231,7 +385,7 @@

			let trackingArea = NSTrackingArea(
			rect: bounds,
			options: [.activeInKeyWindow, .mouseMoved, .mouseEnteredAndExited, .inVisibleRect],
			options: [.activeAlways, .mouseMoved, .mouseEnteredAndExited, .inVisibleRect],
			owner: self,
			userInfo: nil
			)
			@@ -247,6 +401,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?()
			@@ -268,6 +429,8 @@
			}

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

			let dominantDelta = abs(event.scrollingDeltaX) >= abs(event.scrollingDeltaY)
			? event.scrollingDeltaX
			: event.scrollingDeltaY
			@@ -287,6 +450,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
			@@ -313,52 +485,48 @@
			override func mouseMoved(with event: NSEvent) {
			guard debugHoveredAppGroupIndex == nil else { return }

			let settingsHovered = settingsButtonContains(windowLocation: event.locationInWindow)
			if isSettingsButtonHovered != settingsHovered {
			isSettingsButtonHovered = settingsHovered
			needsLayout = true
			}
			if settingsHovered {
			hoveredCloseTarget = nil
			setHoverTarget(.none)
			return
			}

			let closeTarget = closeButtonTarget(at: event.locationInWindow)
			if hoveredCloseTarget != closeTarget {
			hoveredCloseTarget = closeTarget
			needsLayout = true
			}

			if let segment = spaceLaneSegment(at: event.locationInWindow) {
			hoverSpaceLaneSegment(segment)
			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
			}

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

			hoveredSpaceLaneID = nil
			hoveredCloseTarget = 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
			isSettingsButtonHovered = false
			hoveredCloseTarget = nil
			updateHoverState(appGroupIndex: nil, windowID: nil, spaceID: nil)
			setHoverTarget(.none)
			}

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

			if handleCloseConfirmationMouseDown(at: event.locationInWindow) {
			return
			}

			if settingsButtonContains(windowLocation: event.locationInWindow) {
			clickSettingsButton(source: "mouse")
			return
			}

			@@ -373,7 +541,7 @@
			}

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

			@@ -387,15 +555,16 @@
			"y": event.locationInWindow.y,
			"bounds": NSStringFromRect(bounds)
			])
			if !suppressEventBackgroundClicks, onBackgroundClick?() == true {
			return
			}
			super.mouseDown(with: event)
			}

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

			@@ -432,6 +601,15 @@
			}
			}

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

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

			func beginPerformanceFirstFrameMeasurement() {
			firstFrameMeasurementStart = CACurrentMediaTime()
			}
			@@ -457,10 +635,58 @@
			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 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
			}

			@@ -471,7 +697,9 @@
			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
			card.shineLayer.opacity = shouldShowSelectedVisual(isSelected: isSelected, isHovered: isHovered) ? 1 : 0
			}
			needsLayout = true
			}
			@@ -488,39 +716,77 @@
			}
			}

			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)
			}

			private func apply(
			viewModel: QuickSwitchViewModel?,
			preservingInteractionState: Bool,
			animatedProjection: Bool
			) {
			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
			hoveredCloseTarget = nil
			pendingCloseTarget = nil
			pendingCloseOptOut = false
			closeConfirmationLayers.containerLayer.isHidden = true
			closeConfirmationArrowEdge = 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 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 = [:]
			keyboardCommandsApplied = []
			lastKeyboardCommand = 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
			}
			@@ -530,6 +796,250 @@
			needsLayout = true
			ensureCurrentSelectionVisible(horizontalIntent: .alignWithAppShelf(animated: false))
			needsLayout = true
			if animatedProjection, let transitionSnapshot {
			layoutSubtreeIfNeeded()
			applyProjectionTransitionAnimations(from: transitionSnapshot)
			}
			}

			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] {
			@@ -553,17 +1063,31 @@
			"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,
			"settingsButtonVisible": !settingsButtonLayer.isHidden,
			"settingsButtonHovered": isSettingsButtonHovered,
			"settingsButtonFrame": dictionary(from: settingsButtonLayer.frame),
			"spaceFocusAppGroupIndexes": spaceFocusedAppGroupIndexes(),
			"appHoverAssociatedSpaceIDs": appHoverAssociatedSpaceIDs.sorted(),
			"appHoverAssociatedSpaceLabels": appHoverAssociatedSpaceLabels,
			"windowHoverAssociatedSpaceID": windowHoverAssociatedSpaceID ?? NSNull(),
			"lastSpaceFocusedAppGroupIndex": lastSpaceFocusedAppGroupIndex ?? NSNull(),
			"lastSpaceLaneClickSpaceID": lastSpaceLaneClickSpaceID ?? NSNull(),
			"lastAppShelfScrollSyncedAppGroupIndex": lastAppShelfScrollSyncedAppGroupIndex ?? NSNull(),
			@@ -591,13 +1115,19 @@
			"appShelfMinIconSize": Double(AppShelfMetrics.minIconSize),
			"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,
			@@ -606,6 +1136,10 @@
			"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(),
			@@ -627,6 +1161,13 @@
			"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(),
			@@ -694,8 +1235,13 @@
			recordKeyboardCommand("enter")
			commitCurrentSelection()
			case "tab":
			tabIgnoredCount += 1
			recordKeyboardCommand("tabIgnored")
			if isHorizontalMasonryMode {
			recordKeyboardCommand("tab")
			moveSelection(.right)
			} else {
			tabIgnoredCount += 1
			recordKeyboardCommand("tabIgnored")
			}
			default:
			recordKeyboardCommand("unknown:\(command)")
			}
			@@ -756,7 +1302,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 {
			@@ -765,8 +1311,24 @@
			}
			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 "click-settings":
			recordMouseCommand("click-settings")
			clickSettingsButton(source: "debug")
			case "hover-card" where parts.count == 3:
			guard let appGroupIndex = Int(parts[1]), let windowIndex = Int(parts[2]) else {
			recordMouseCommand("invalid:\(command)")
			@@ -774,7 +1336,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 {
			@@ -826,13 +1388,12 @@
			}

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

			@@ -847,19 +1408,18 @@
			beginCloseConfirmation(for: .app(appGroupIndex: appGroupIndex))
			}

			private func hoverWindowCard(_ card: WaterfallCardLayers) {
			hoveredSpaceLaneID = nil
			hoveredCloseTarget = nil
			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 hoverCardCloseButton(appGroupIndex: Int, windowIndex: Int) {
			guard let card = waterfallCard(appGroupIndex: appGroupIndex, windowIndex: windowIndex) else { return }
			hoverWindowCard(card)
			hoverWindowCard(card, source: .debug)
			hoveredCloseTarget = .window(
			appGroupIndex: appGroupIndex,
			windowIndex: windowIndex,
			@@ -880,33 +1440,23 @@
			)
			}

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

			private func clickSpaceLaneSegment(_ segment: SpaceLaneSegmentLayers) {
			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
			])
			lastSpaceLaneClickSpaceID = segment.space.id

			guard let firstCard = firstWaterfallCard(inSpaceID: segment.space.id) else {
			DevelopmentDiagnostics.log("quickSwitch.view.clickSpaceLane.emptySpaceUnsupported", [
			"spaceID": segment.space.id,
			"label": segment.space.label
			])
			return
			}

			commitWindowCard(firstCard, trigger: "spaceLane")
			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
			@@ -1035,28 +1585,76 @@
			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)
			}
			return
			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
			}

			hoveredAppGroupIndex = appGroupIndex
			hoveredWindowID = windowID
			hoveredSpaceID = spaceID
			if alignsWaterfallWithAppShelf, let appGroupIndex {
			setHoverTarget(target, source: source, alignsWaterfallWithAppShelf: alignsWaterfallWithAppShelf)
			}

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

			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 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,
			@@ -1086,6 +1684,113 @@
			"windowID": next.windowID
			])
			needsLayout = true
			}

			private func moveHorizontalMasonrySelection(_ direction: QuickSwitchKeyboardDirection) {
			guard let current = currentSelection ?? currentViewModel?.initialSelection,
			let next = nextHorizontalMasonrySelection(from: current, direction: direction)
			else {
			DevelopmentDiagnostics.log("quickSwitch.view.moveHorizontalMasonrySelection.blocked", [
			"direction": String(describing: direction),
			"hasSelection": (currentSelection ?? currentViewModel?.initialSelection) != nil
			])
			return
			}

			columnSelectionHistory[current.appGroupIndex] = current.windowIndex
			currentSelection = next
			columnSelectionHistory[next.appGroupIndex] = next.windowIndex
			ensureCurrentSelectionVisible(horizontalIntent: .alignWithAppShelf(animated: true))
			DevelopmentDiagnostics.log("quickSwitch.view.moveHorizontalMasonrySelection", [
			"direction": String(describing: direction),
			"appGroupIndex": next.appGroupIndex,
			"windowIndex": next.windowIndex,
			"windowID": next.windowID
			])
			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() {
			@@ -1145,9 +1850,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
			}

			@@ -1161,11 +1881,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
			@@ -1188,6 +1913,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 })
			@@ -1214,6 +1944,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
			}
			@@ -1222,18 +1957,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

			@@ -1258,6 +2006,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) {
			@@ -1292,6 +2044,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(
			@@ -1408,8 +2234,8 @@
			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)
			@@ -1427,6 +2253,44 @@

			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)

			settingsButtonLayer.cornerRadius = 10
			settingsButtonLayer.masksToBounds = false
			settingsButtonLayer.borderWidth = 1
			settingsButtonLayer.shadowColor = NSColor.black.cgColor
			settingsButtonLayer.shadowOffset = CGSize(width: 0, height: -2)
			settingsButtonLayer.zPosition = 170
			settingsButtonIconLayer.contentsGravity = .resizeAspect
			settingsButtonIconLayer.contentsScale = backingScaleFactor
			settingsButtonIconLayer.contents = settingsIconImage()
			settingsButtonFallbackTextLayer.contentsScale = backingScaleFactor
			settingsButtonFallbackTextLayer.string = "⚙"
			settingsButtonFallbackTextLayer.font = NSFont.systemFont(ofSize: 18, weight: .regular)
			settingsButtonFallbackTextLayer.fontSize = 18
			settingsButtonFallbackTextLayer.alignmentMode = .center
			settingsButtonFallbackTextLayer.foregroundColor = NSColor.secondaryLabelColor.cgColor
			settingsButtonFallbackTextLayer.isHidden = settingsButtonIconLayer.contents != nil
			settingsButtonLayer.addSublayer(settingsButtonIconLayer)
			settingsButtonLayer.addSublayer(settingsButtonFallbackTextLayer)
			glassLayer.addSublayer(settingsButtonLayer)
			}

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

			let selectedAppGroupIndex = effectiveSelection?.appGroupIndex
			appShelfItems = (currentViewModel?.appShelf ?? []).map { 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
			@@ -1523,7 +2380,8 @@
			string: column.app.name,
			fontSize: 13,
			weight: .semibold,
			color: .labelColor
			color: .labelColor,
			alignment: .center
			)
			let count = makeTextLayer(
			string: "\(column.windows.count)",
			@@ -1632,66 +2490,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),
			fontSize: 12,
			weight: space.type == .fullscreen ? .medium : .regular,
			color: space.type == .fullscreen ? .labelColor : .secondaryLabelColor,
			alignment: space.type == .fullscreen ? .center : .left
			)
			let windowBlocks = space.type == .fullscreen
			? []
			: 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 = NSColor.windowBackgroundColor.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: .labelColor
			)
			let countLayer = makeTextLayer(
			string: "\(space.windowCount)",
			fontSize: 12,
			weight: .medium,
			color: .secondaryLabelColor,
			alignment: .center
			)
			let appLayer = makeTextLayer(
			string: appIdentifierText(for: space),
			fontSize: 12,
			weight: space.type == .fullscreen ? .medium : .regular,
			color: space.type == .fullscreen ? .labelColor : .secondaryLabelColor,
			alignment: space.type == .fullscreen ? .center : .left
			)
			let splitAppLayers = splitViewAppNames(for: space).map { name in
			makeTextLayer(
			string: name,
			fontSize: 12,
			weight: .medium,
			color: .labelColor,
			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() {
			@@ -1740,8 +2640,41 @@
			layoutAppShelfItems()
			layoutWaterfallColumns()
			layoutCloseConfirmation()
			layoutCloseFeedback()
			layoutSettingsButton()

			CATransaction.commit()
			}

			private func layoutSettingsButton() {
			let size: CGFloat = 34
			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
			)
			settingsButtonLayer.frame = CGRect(x: x, y: y, width: size, height: size)
			settingsButtonLayer.backgroundColor = NSColor.windowBackgroundColor
			.withAlphaComponent(isSettingsButtonHovered ? 0.78 : 0.54)
			.cgColor
			settingsButtonLayer.borderColor = NSColor.separatorColor
			.withAlphaComponent(isSettingsButtonHovered ? 0.42 : 0.26)
			.cgColor
			settingsButtonLayer.shadowOpacity = isSettingsButtonHovered ? 0.14 : 0.08
			settingsButtonLayer.shadowRadius = isSettingsButtonHovered ? 9 : 6
			settingsButtonIconLayer.contentsScale = backingScaleFactor
			settingsButtonFallbackTextLayer.contentsScale = backingScaleFactor
			let iconInset: CGFloat = 8
			settingsButtonIconLayer.frame = settingsButtonLayer.bounds.insetBy(dx: iconInset, dy: iconInset)
			settingsButtonFallbackTextLayer.frame = settingsButtonLayer.bounds.insetBy(dx: 0, dy: 6)
			settingsButtonFallbackTextLayer.foregroundColor = (isSettingsButtonHovered
			? NSColor.labelColor
			: NSColor.secondaryLabelColor
			).cgColor
			}

			private var topSafeAreaInset: CGFloat {
			@@ -1823,15 +2756,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(
			@@ -1841,13 +2793,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
			}
			}

			@@ -1859,36 +2833,127 @@
			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 = NSColor.windowBackgroundColor.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 \|\| isActive) ? 1.5 : 1
			segment.containerLayer.borderColor = (isActive
			? NSColor.controlAccentColor.withAlphaComponent(0.54)
			: 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
			? spaceLaneOccupiedColor.withAlphaComponent(isLocked ? 0.92 : 0.62)
			: isAssociated
			? spaceLaneOccupiedColor.withAlphaComponent(0.50)
			: hasWindows
			? spaceLaneOccupiedColor.withAlphaComponent(isCurrent ? 0.54 : 0.44)
			: isCurrent
			? NSColor.labelColor.withAlphaComponent(0.34)
			: NSColor.separatorColor.withAlphaComponent(0.34)
			).cgColor
			segment.containerLayer.backgroundColor = (isActive
			? accentTintedWindowBackground(fraction: 0.10, alpha: 0.94)
			: spaceColor(for: segment.space)
			).cgColor
			segment.containerLayer.shadowOpacity = isActive ? 0.26 : isCurrent ? 0.14 : 0
			segment.containerLayer.shadowRadius = isActive ? 24 : isCurrent ? 12 : 0
			segment.containerLayer.shadowOffset = CGSize(width: 0, height: isActive ? -6 : isCurrent ? -2.5 : 0)
			segment.containerLayer.zPosition = isActive ? 30 : isCurrent ? 10 : 0
			segment.containerLayer.transform = isActive
			? CATransform3DMakeScale(1.03, 1.03, 1)
			: CATransform3DIdentity
			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)
			}

			private func applySpaceLaneContentVisualState(_ segment: SpaceLaneSegmentLayers, isLocked: Bool) {
			let primaryTextColor: NSColor = isLocked ? .white : .labelColor
			let secondaryTextColor: NSColor = isLocked
			? .white
			: .secondaryLabelColor

			segment.labelLayer.foregroundColor = primaryTextColor.cgColor
			segment.countLayer.foregroundColor = (isLocked ? NSColor.white : .secondaryLabelColor).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 = (isLocked
			? NSColor.white
			: spaceLaneOccupiedColor.withAlphaComponent(segment.space.isCurrent ? 0.72 : 0.58)
			).cgColor
			}

			(segment.fullscreenMarkerLayer as? CAShapeLayer)?.strokeColor = (isLocked
			? NSColor.white
			: NSColor.secondaryLabelColor.withAlphaComponent(segment.space.isCurrent ? 0.42 : 0.28)
			).cgColor
			}

			private func shouldScrollSpaceLane(for event: NSEvent) -> Bool {
			@@ -1944,13 +3009,41 @@
			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 settingsButtonContains(windowLocation: CGPoint) -> Bool {
			let locationInView = convert(windowLocation, from: nil)
			let locationInGlass = CGPoint(
			x: locationInView.x - glassLayer.frame.minX,
			y: locationInView.y - glassLayer.frame.minY
			)
			return settingsButtonLayer.frame.contains(locationInGlass)
			}

			private func clickSettingsButton(source: String) {
			DevelopmentDiagnostics.log("quickSwitch.view.clickSettings", [
			"source": source
			])
			lastMouseCommand = "click-settings"
			if !mouseCommandsApplied.contains("click-settings") {
			mouseCommandsApplied.append("click-settings")
			}
			onOpenSettings?()
			}

			private func appShelfItem(at windowLocation: CGPoint) -> AppShelfItemLayers? {
			@@ -1998,17 +3091,45 @@
			segment.countLayer.frame = CGRect(x: bounds.width - 34, y: bounds.height - 29, width: 24, height: 20)
			if segment.space.type == .fullscreen {
			let markerFrame = fullscreenMarkerFrame(in: bounds)
			segment.appLayer.frame = CGRect(
			x: 8,
			y: markerFrame.midY - 8.5,
			width: max(1, bounds.width - 16),
			height: 17
			)
			let splitAppNames = splitViewAppNames(for: segment.space)
			segment.appLayer.isHidden = splitAppNames.count >= 2
			if splitAppNames.count >= 2 {
			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)
			layoutFullscreenMarkerLayer(
			fullscreenMarkerLayer,
			in: bounds,
			isSplitView: splitViewAppNames(for: segment.space).count >= 2
			)
			}

			let blockGap: CGFloat = 5
			@@ -2069,8 +3190,8 @@
			private func layoutAppShelfItemContents(_ item: AppShelfItemLayers, iconSize: CGFloat) {
			let bounds = item.containerLayer.bounds
			let isSelected = item.item.appGroupIndex == effectiveSelection?.appGroupIndex
			let showsSelectedVisual = shouldShowSelectedVisual(isSelected)
			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,
			@@ -2174,15 +3295,52 @@
			}

			private var activeSpaceFocusID: UInt64? {
			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 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) -> Bool {
			isSelected && !isSpaceAssociationActive
			private func shouldShowSelectedVisual(isSelected: Bool, isHovered: Bool) -> Bool {
			isSelected && isHovered && !isSpaceAssociationActive
			}

			private func spaceFocusedAppGroupIndexes() -> [Int] {
			@@ -2227,6 +3385,10 @@
			let column = waterfallColumns.first(where: { $0.column.appGroupIndex == appGroupIndex })
			else {
			return "none"
			}

			guard !isHorizontalMasonryMode else {
			return "visible"
			}

			let visibleMinX = waterfallScrollOffset
			@@ -2311,17 +3473,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(
			@@ -2331,7 +3500,7 @@
			height: waterfallLayer.bounds.height
			)

			var x = WaterfallMetrics.columnPadding
			var x = waterfallColumnStartX(columnsWidth: columnsWidth)
			for column in waterfallColumns {
			column.containerLayer.frame = CGRect(
			x: x,
			@@ -2344,9 +3513,177 @@
			}
			}

			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.headerLayer.isHidden = true
			column.appNameLayer.isHidden = true
			column.countLayer.isHidden = true

			for card in column.cards {
			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 = NSColor.controlBackgroundColor.withAlphaComponent(0.56).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 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)
			@@ -2363,11 +3700,15 @@
			: NSColor.controlBackgroundColor.withAlphaComponent(0.52)
			).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 = (isHovered
			? spaceLaneOccupiedColor
			: NSColor.labelColor
			).cgColor
			column.countLayer.frame = CGRect(
			x: bounds.width - 48,
			y: bounds.height - 24,
			@@ -2382,10 +3723,10 @@
			)
			waterfallColumnScrollOffsets[appGroupIndex] = verticalOffset

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

			for card in column.cards {
			@@ -2394,7 +3735,7 @@
			- WaterfallMetrics.cardHeight
			- CGFloat(cardIndex) * (WaterfallMetrics.cardHeight + WaterfallMetrics.cardGap)
			card.containerLayer.frame = CGRect(
			x: WaterfallMetrics.columnPadding,
			x: WaterfallMetrics.columnHorizontalPadding,
			y: y,
			width: cardWidth,
			height: WaterfallMetrics.cardHeight
			@@ -2407,9 +3748,13 @@
			let bounds = card.containerLayer.bounds
			let isSelected = card.item.window.id == effectiveSelection?.windowID
			let isHovered = card.item.window.id == hoveredWindowID
			applyWaterfallCardVisualState(card, selected: shouldShowSelectedVisual(isSelected), hovered: isHovered)
			applyWaterfallCardVisualState(
			card,
			selected: shouldShowSelectedVisual(isSelected: isSelected, isHovered: isHovered),
			hovered: isHovered
			)

			let outerInset: CGFloat = 8
			let outerInset: CGFloat = 0
			let titleBarHeight: CGFloat = 26
			let titleGap: CGFloat = 6
			let titleBarFrame = CGRect(
			@@ -2470,7 +3815,7 @@
			}

			private func applyWaterfallCardVisualState(_ card: WaterfallCardLayers, selected: Bool, hovered: Bool) {
			let isSpaceFocused = card.item.primarySpaceID == activeSpaceFocusID
			let isSpaceFocused = isWaterfallCardSpaceFocused(card)
			card.containerLayer.backgroundColor = (selected
			? NSColor.windowBackgroundColor.withAlphaComponent(0.94)
			: hovered
			@@ -2527,13 +3872,14 @@
			let size: CGFloat = isButtonHovered ? 24 : 18
			let buttonFill = isButtonHovered
			? NSColor.systemRed.withAlphaComponent(0.94)
			: NSColor.labelColor.withAlphaComponent(0.24)
			: NSColor.white.withAlphaComponent(0.34)
			let buttonStroke = isButtonHovered
			? NSColor.white.withAlphaComponent(0.76)
			: NSColor.white.withAlphaComponent(0.52)
			: NSColor.white.withAlphaComponent(0.46)
			let glyphStroke = isButtonHovered
			? NSColor.white
			: NSColor.secondaryLabelColor.withAlphaComponent(0.92)
			: NSColor.white.withAlphaComponent(0.88)

			button.containerLayer.frame = CGRect(
			x: anchorTopRight.x - size / 2,
			y: anchorTopRight.y - size / 2,
			@@ -2545,10 +3891,10 @@
			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.07) : 0
			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.7
			button.glyphLayer.lineWidth = isButtonHovered ? 2.1 : 1.45
			button.glyphLayer.strokeColor = glyphStroke.cgColor
			button.glyphLayer.path = closeGlyphPath(size: size, hovered: isButtonHovered)
			}
			@@ -2641,6 +3987,80 @@
			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 = NSColor.windowBackgroundColor.withAlphaComponent(0.94).cgColor
			closeFeedbackLayer.borderColor = NSColor.separatorColor.withAlphaComponent(0.28).cgColor
			closeFeedbackTextLayer.foregroundColor = NSColor.secondaryLabelColor.withAlphaComponent(0.96).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,
			@@ -2726,18 +4146,23 @@
			}

			pendingCloseTarget = nil
			pendingCloseRequest = nil
			pendingCloseOptOut = false
			closeConfirmationLayers.containerLayer.isHidden = true
			closeConfirmationArrowEdge = nil
			if pendingCloseOptOut {
			onCloseConfirmationDisabled?()
			}
			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
			@@ -2750,23 +4175,30 @@
			}

			private func confirmPendingClose() {
			guard let target = pendingCloseTarget else { return }
			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 {
			if shouldDisableConfirmation && closeConfirmationRequired {
			closeConfirmationRequired = false
			onCloseConfirmationDisabled?()
			}
			if let request = closeRequest(for: target) {
			onRequestClose?(request)
			}
			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
			@@ -2774,7 +4206,15 @@
			}

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

			@@ -2941,13 +4381,18 @@
			return color.withAlphaComponent(alpha)
			}

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

			private func waterfallColumnWidth() -> CGFloat {
			guard waterfallColumns.count > 0 else { return WaterfallMetrics.columnWidth }

			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(
			@@ -2956,15 +4401,30 @@
			)
			}

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

			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 {
			@@ -2975,7 +4435,7 @@
			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
			@@ -3005,15 +4465,51 @@
			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 effectiveAppearance.bestMatch(from: [.darkAqua, .aqua]) == .darkAqua {
			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 effectiveAppearance.bestMatch(from: [.darkAqua, .aqua]) == .darkAqua {
			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 effectiveAppearance.bestMatch(from: [.darkAqua, .aqua]) == .darkAqua {
			let blue = NSColor(calibratedRed: 36 / 255, green: 54 / 255, blue: 72 / 255, alpha: 1)
			let surface = NSColor.windowBackgroundColor.withAlphaComponent(1)
			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]
			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? {
			@@ -3026,6 +4522,21 @@
			shapeLayer.lineCap = .round
			shapeLayer.lineJoin = .round
			return shapeLayer
			}

			private func settingsIconImage() -> CGImage? {
			let names = [
			NSImage.Name("NSPreferencesGeneral"),
			NSImage.Name("NSAdvanced")
			]
			for name in names {
			guard let image = NSImage(named: name) else { continue }
			var rect = CGRect(origin: .zero, size: image.size)
			if let cgImage = image.cgImage(forProposedRect: &rect, context: nil, hints: nil) {
			return cgImage
			}
			}
			return nil
			}

			private func makeTextLayer(
			@@ -3179,10 +4690,9 @@
			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
			}
			}
			@@ -3206,13 +4716,44 @@
			return identifiers.joined(separator: " ")
			}

			private func layoutFullscreenMarkerLayer(_ layer: CALayer, in segmentBounds: CGRect) {
			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 insetBounds = bounds.insetBy(dx: 0.6, dy: 0.6)
			let radius = min(7, max(5, insetBounds.height * 0.22))
			let path = CGMutablePath()
			path.addRoundedRect(
			in: insetBounds,
			cornerWidth: radius,
			cornerHeight: radius
			)
			path.move(to: CGPoint(x: bounds.midX, y: insetBounds.minY + 1.5))
			path.addLine(to: CGPoint(x: bounds.midX, y: insetBounds.maxY - 1.5))
			shapeLayer.path = path
			return
			}

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

			@@ -3236,11 +4777,18 @@
			}

			private func fullscreenMarkerFrame(in segmentBounds: CGRect) -> 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: 30,
			y: markerY,
			width: max(1, segmentBounds.width - 20),
			height: max(1, segmentBounds.height - 58)
			height: markerHeight
			)
			}

			@@ -3282,7 +4830,9 @@
			"closeButtonVisible": item.closeButton.containerLayer.opacity > 0,
			"closeButtonFrame": dictionary(from: item.closeButton.containerLayer.frame),
			"closeButtonSize": Double(item.closeButton.containerLayer.bounds.width),
			"closeButtonFillColor": colorDictionary(from: item.closeButton.containerLayer.backgroundColor)
			"closeButtonFillColor": colorDictionary(from: item.closeButton.containerLayer.backgroundColor),
			"closeButtonGlyphColor": colorDictionary(from: item.closeButton.glyphLayer.strokeColor),
			"closeButtonGlyphLineWidth": Double(item.closeButton.glyphLayer.lineWidth)
			] as [String: Any]
			}
			}
			@@ -3290,12 +4840,13 @@
			private func appShelfVisualStates(for item: AppShelfItemLayers) -> [String] {
			var states: [String] = []
			let isSelected = item.item.appGroupIndex == effectiveSelection?.appGroupIndex
			if shouldShowSelectedVisual(isSelected) {
			let isHovered = item.item.appGroupIndex == effectiveHoveredAppGroupIndex
			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 spaceFocusWindowCount(for: item.item.appGroupIndex) > 0 {
			@@ -3308,21 +4859,49 @@
			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 headerToFirstCardGap = firstCardFrame.map {
			column.headerLayer.frame.minY - $0.maxY
			}
			let topToFirstCardGap = firstCardFrame.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),
			"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),
			"verticalScrollOffset": Double(waterfallColumnScrollOffsets[appGroupIndex] ?? 0),
			"maxVerticalScrollOffset": Double(waterfallMaxVerticalScrollOffset(for: appGroupIndex)),
			"cards": waterfallCardReports(for: column)
			@@ -3418,6 +4997,8 @@
			"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),
			"frame": dictionary(from: card.containerLayer.frame),
			@@ -3513,15 +5094,16 @@
			private func waterfallCardVisualStates(for card: WaterfallCardLayers) -> [String] {
			var states: [String] = []
			let isSelected = card.item.window.id == effectiveSelection?.windowID
			if shouldShowSelectedVisual(isSelected) {
			let isHovered = card.item.window.id == hoveredWindowID
			if shouldShowSelectedVisual(isSelected: isSelected, isHovered: isHovered) {
			states.append("selected")
			} else if isSelected {
			states.append("selectedVisualSuppressed")
			}
			if card.item.window.id == hoveredWindowID {
			if isHovered {
			states.append("hover")
			}
			if card.item.primarySpaceID == activeSpaceFocusID {
			if isWaterfallCardSpaceFocused(card) {
			states.append("spaceFocused")
			}
			if card.item.window.isMinimized {
			@@ -3537,32 +5119,99 @@
			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 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),
			"fullscreenMarkerVisible": segment.fullscreenMarkerLayer != nil,
			"fullscreenMarkerKind": segment.fullscreenMarkerLayer == nil ? "none" : "cornerBracket",
			"fullscreenMarkerFrame": segment.fullscreenMarkerLayer.map { dictionary(from: $0.frame) } ?? NSNull(),
			"fullscreenMarkerKind": fullscreenMarkerKind(
			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),
			"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
			@@ -3571,19 +5220,42 @@
			} ?? []
			}

			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 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
			}
			@@ -3629,4 +5301,23 @@
			"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 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"
			}
			}