crazy-macs/aligner.git

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

			enum QuickSwitchCommitSource: String {
			@@ -20,11 +21,15 @@
			private let appShelfContentLayer = CALayer()
			private let waterfallLayer = CALayer()
			private let waterfallContentLayer = CALayer()
			private lazy var closeConfirmationLayers = makeCloseConfirmationLayers()
			private let closeFeedbackLayer = CALayer()
			private let closeFeedbackTextLayer = CATextLayer()
			private let 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
			@@ -36,6 +41,16 @@
			private var hoveredAppGroupIndex: Int?
			private var hoveredWindowID: UInt32?
			private var hoveredSpaceID: UInt64?
			private var hoveredCloseTarget: CloseTarget?
			private var pendingCloseTarget: CloseTarget?
			private var pendingCloseRequest: QuickSwitchCloseRequest?
			private var pendingCloseOptOut = false
			private var closeConfirmationArrowEdge: CloseConfirmationArrowEdge?
			private var closeConfirmationRequired = true
			private var closeFeedback: CloseFeedback?
			private var closeFeedbackHideTask: Task<Void, Never>?
			private var hoverTarget: HoverTarget = .none
			private var hoverTargetSource: HoverTargetSource = .event
			private var hoveredSpaceLaneID: UInt64?
			private var focusedSpaceID: UInt64?
			private var debugHoveredAppGroupIndex: Int?
			@@ -65,6 +80,129 @@
			private var hoverResponseLatencyMilliseconds: [Double] = []
			var onEscape: (() -> Void)?
			var onCommitSelection: ((QuickSwitchSelection, QuickSwitchCommitSource) -> Void)?
			var onRequestClose: ((QuickSwitchCloseRequest) -> Void)?
			var onCloseConfirmationDisabled: (() -> Void)?

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

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

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

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

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

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

			private enum CloseConfirmationArrowEdge: String {
			case left
			case right
			}

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

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

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

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

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

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

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

			private enum HoverTargetSource: String {
			case event
			case debug
			}

			private struct SpaceLaneSegmentLayers {
			let space: QuickSwitchSpaceViewModel
			@@ -76,6 +214,12 @@
			let fullscreenMarkerLayer: CALayer?
			}

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

			private struct AppShelfItemLayers {
			let item: QuickSwitchAppShelfItemViewModel
			let containerLayer: CALayer
			@@ -84,6 +228,7 @@
			let labelLayer: CATextLayer
			let badgeLayer: CATextLayer
			let selectedIndicatorLayer: CALayer
			let closeButton: CloseButtonLayers
			}

			private struct AppShelfLayout {
			@@ -103,12 +248,14 @@
			private struct WaterfallCardLayers {
			let item: QuickSwitchWindowCardViewModel
			let containerLayer: CALayer
			let titleBarLayer: CALayer
			let titleLayer: CATextLayer
			let metaLayer: CATextLayer
			let thumbnailLayer: CALayer
			let appIconLayer: CALayer
			let stateLayer: CATextLayer
			let shineLayer: CAGradientLayer
			let closeButton: CloseButtonLayers
			}

			private enum AppShelfMetrics {
			@@ -134,11 +281,15 @@
			static let columnWidth: CGFloat = 252
			static let columnMinWidth: CGFloat = 220
			static let columnMaxWidth: CGFloat = 292
			static let columnPadding: CGFloat = 12
			static let contentHorizontalPadding: CGFloat = 0
			static let columnHorizontalPadding: CGFloat = 0
			static let columnVerticalPadding: CGFloat = 0
			static let columnHeaderTextInset: CGFloat = 12
			static let headerHeight: CGFloat = 34
			static let cardHeight: CGFloat = 118
			static let cardHeight: CGFloat = 138
			static let cardGap: CGFloat = 12
			static let revealPadding: CGFloat = 24
			static let horizontalRevealPadding: CGFloat = 0
			}

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

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

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

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

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

			let dominantDelta = abs(event.scrollingDeltaX) >= abs(event.scrollingDeltaY)
			? event.scrollingDeltaX
			: event.scrollingDeltaY
			@@ -263,43 +426,30 @@
			override func mouseMoved(with event: NSEvent) {
			guard debugHoveredAppGroupIndex == nil else { return }

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

			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
			updateHoverState(appGroupIndex: nil, windowID: nil, spaceID: nil)
			refreshHoverTarget(at: event.locationInWindow)
			}

			override func mouseExited(with event: NSEvent) {
			guard debugHoveredAppGroupIndex == nil else { return }
			hoveredSpaceLaneID = nil
			updateHoverState(appGroupIndex: nil, windowID: nil, spaceID: nil)
			hoveredCloseTarget = nil
			setHoverTarget(.none)
			}

			override func mouseDown(with event: NSEvent) {
			if handleCloseConfirmationMouseDown(at: event.locationInWindow) {
			return
			}

			if let closeTarget = closeButtonTarget(at: event.locationInWindow) {
			beginCloseConfirmation(for: closeTarget)
			return
			}

			if let card = waterfallCard(at: event.locationInWindow) {
			clickWindowCard(card)
			return
			@@ -325,10 +475,8 @@

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

			@@ -386,6 +534,54 @@
			hoverResponseLatencyMilliseconds = []
			}

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

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

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

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

			func applyScreenshot(_ resolution: ScreenshotResolution, for windowID: UInt32) {
			screenshotSkippedReasonsByWindowID[windowID] = nil
			screenshotSourcesByWindowID[windowID] = resolution.source
			@@ -393,7 +589,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
			}
			@@ -429,15 +627,16 @@
			lastSpaceFocusedAppGroupIndex = nil
			lastSpaceLaneClickSpaceID = nil
			lastAppShelfScrollSyncedAppGroupIndex = nil
			hoveredWindowID = nil
			hoveredSpaceID = nil
			hoveredSpaceLaneID = nil
			focusedSpaceID = nil
			if debugHoveredAppGroupIndex == nil {
			hoveredAppGroupIndex = nil
			} else {
			hoveredAppGroupIndex = debugHoveredAppGroupIndex
			}
			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
			}
			@@ -470,17 +669,26 @@
			"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(),
			"spaceFocusAppGroupIndexes": spaceFocusedAppGroupIndexes(),
			"appHoverAssociatedSpaceIDs": appHoverAssociatedSpaceIDs.sorted(),
			"appHoverAssociatedSpaceLabels": appHoverAssociatedSpaceLabels,
			"windowHoverAssociatedSpaceID": windowHoverAssociatedSpaceID ?? NSNull(),
			"lastSpaceFocusedAppGroupIndex": lastSpaceFocusedAppGroupIndex ?? NSNull(),
			"lastSpaceLaneClickSpaceID": lastSpaceLaneClickSpaceID ?? NSNull(),
			"lastAppShelfScrollSyncedAppGroupIndex": lastAppShelfScrollSyncedAppGroupIndex ?? NSNull(),
			@@ -537,6 +745,20 @@
			"hoveredAppGroupIndex": effectiveHoveredAppGroupIndex ?? NSNull(),
			"hoveredWindowID": hoveredWindowID ?? NSNull(),
			"hoveredSpaceID": hoveredSpaceID ?? NSNull(),
			"hoveredCloseTargetKind": hoveredCloseTarget?.kindDescription ?? NSNull(),
			"pendingCloseTargetKind": pendingCloseTarget?.kindDescription ?? NSNull(),
			"pendingCloseOptOut": pendingCloseOptOut,
			"closeConfirmationRequired": closeConfirmationRequired,
			"closeConfirmationVisible": !closeConfirmationLayers.containerLayer.isHidden,
			"closeConfirmationFrame": dictionary(from: closeConfirmationLayers.containerLayer.frame),
			"closeConfirmationArrowEdge": closeConfirmationArrowEdge?.rawValue ?? NSNull(),
			"closeFeedbackVisible": closeFeedback != nil && !closeFeedbackLayer.isHidden,
			"closeFeedbackKind": closeFeedback?.kind.rawValue ?? NSNull(),
			"closeFeedbackMessage": closeFeedback?.message ?? NSNull(),
			"closeFeedbackTargetKind": closeFeedback?.targetKind ?? NSNull(),
			"closeFeedbackAppGroupIndex": closeFeedback?.appGroupIndex ?? NSNull(),
			"closeFeedbackWindowID": closeFeedback?.windowID ?? NSNull(),
			"closeFeedbackFrame": dictionary(from: closeFeedbackLayer.frame),
			"mouseCommandsApplied": mouseCommandsApplied,
			"lastMouseCommand": lastMouseCommand ?? NSNull(),
			"lastClickedAppGroupIndex": lastClickedAppGroupIndex ?? NSNull(),
			@@ -638,6 +860,20 @@
			}
			recordMouseCommand("click-app:\(appGroupIndex)")
			clickAppShelfItem(appGroupIndex: appGroupIndex)
			case "hover-app-close" where parts.count == 2:
			guard let appGroupIndex = Int(parts[1]) else {
			recordMouseCommand("invalid:\(command)")
			return
			}
			recordMouseCommand("hover-app-close:\(appGroupIndex)")
			hoverAppCloseButton(appGroupIndex)
			case "click-app-close" where parts.count == 2:
			guard let appGroupIndex = Int(parts[1]) else {
			recordMouseCommand("invalid:\(command)")
			return
			}
			recordMouseCommand("click-app-close:\(appGroupIndex)")
			clickAppCloseButton(appGroupIndex)
			case "scroll-app-shelf" where parts.count == 2:
			guard let targetOffset = Double(parts[1]) else {
			recordMouseCommand("invalid:\(command)")
			@@ -652,7 +888,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 {
			@@ -670,7 +906,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 {
			@@ -681,6 +917,29 @@
			if let card = waterfallCard(appGroupIndex: appGroupIndex, windowIndex: windowIndex) {
			clickWindowCard(card)
			}
			case "hover-card-close" where parts.count == 3:
			guard let appGroupIndex = Int(parts[1]), let windowIndex = Int(parts[2]) else {
			recordMouseCommand("invalid:\(command)")
			return
			}
			recordMouseCommand("hover-card-close:\(appGroupIndex):\(windowIndex)")
			hoverCardCloseButton(appGroupIndex: appGroupIndex, windowIndex: windowIndex)
			case "click-card-close" where parts.count == 3:
			guard let appGroupIndex = Int(parts[1]), let windowIndex = Int(parts[2]) else {
			recordMouseCommand("invalid:\(command)")
			return
			}
			recordMouseCommand("click-card-close:\(appGroupIndex):\(windowIndex)")
			clickCardCloseButton(appGroupIndex: appGroupIndex, windowIndex: windowIndex)
			case "toggle-close-optout":
			recordMouseCommand("toggle-close-optout")
			toggleCloseConfirmationOptOut()
			case "confirm-close":
			recordMouseCommand("confirm-close")
			confirmPendingClose()
			case "cancel-close":
			recordMouseCommand("cancel-close")
			cancelPendingClose()
			default:
			recordMouseCommand("unknown:\(command)")
			}
			@@ -699,26 +958,60 @@
			}

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

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

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

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

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

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

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

			private func clickSpaceLaneSegment(_ segment: SpaceLaneSegmentLayers) {
			@@ -739,11 +1032,8 @@
			commitWindowCard(firstCard, trigger: "spaceLane")
			}

			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
			@@ -872,24 +1162,67 @@
			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
			}

			@@ -1002,7 +1335,7 @@
			1,
			waterfallLayer.bounds.height
			- WaterfallMetrics.headerHeight
			- WaterfallMetrics.columnPadding * 2
			- WaterfallMetrics.columnVerticalPadding * 2
			)
			let cardStride = WaterfallMetrics.cardHeight + WaterfallMetrics.cardGap
			let cardStart = CGFloat(selection.windowIndex) * cardStride
			@@ -1065,7 +1398,7 @@
			currentOffset: waterfallScrollOffset,
			visibleWidth: waterfallLayer.bounds.width,
			maxOffset: waterfallMaxScrollOffset,
			inset: WaterfallMetrics.revealPadding
			inset: WaterfallMetrics.horizontalRevealPadding
			)
			)
			}
			@@ -1245,8 +1578,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)
			@@ -1261,6 +1594,27 @@
			waterfallLayer.masksToBounds = true
			glassLayer.addSublayer(waterfallLayer)
			waterfallLayer.addSublayer(waterfallContentLayer)

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

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

			private func rebuildAppShelfItems() {
			@@ -1268,22 +1622,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
			@@ -1313,11 +1660,13 @@

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

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

			return AppShelfItemLayers(
			@@ -1327,7 +1676,8 @@
			iconLayer: icon,
			labelLayer: label,
			badgeLayer: badge,
			selectedIndicatorLayer: selectedIndicator
			selectedIndicatorLayer: selectedIndicator,
			closeButton: closeButton
			)
			}
			}
			@@ -1354,7 +1704,8 @@
			string: column.app.name,
			fontSize: 13,
			weight: .semibold,
			color: .labelColor
			color: .labelColor,
			alignment: .center
			)
			let count = makeTextLayer(
			string: "\(column.windows.count)",
			@@ -1380,6 +1731,9 @@
			thumbnail.masksToBounds = true
			thumbnail.contents = skeletonThumbnailProvider
			.withOverlayTitle(window.window.title, for: window.window.app)

			let titleBar = CALayer()
			titleBar.borderWidth = 0

			let title = makeTextLayer(
			string: window.window.title.isEmpty ? "Untitled Window" : window.window.title,
			@@ -1417,24 +1771,29 @@
			shine.startPoint = CGPoint(x: 0, y: 1)
			shine.endPoint = CGPoint(x: 1, y: 0)
			shine.opacity = 0
			let closeButton = makeCloseButtonLayers()

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

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

			@@ -1455,63 +1814,93 @@
			}

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

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

			let labelLayer = makeTextLayer(
			string: space.label,
			fontSize: 15,
			weight: .semibold,
			color: .labelColor
			)
			let countLayer = makeTextLayer(
			string: "\(space.windowCount)",
			fontSize: 12,
			weight: .medium,
			color: .secondaryLabelColor,
			alignment: .center
			)
			let appLayer = makeTextLayer(
			string: appIdentifierText(for: space.appNames),
			fontSize: 12,
			weight: .regular,
			color: .secondaryLabelColor
			)
			let windowBlocks = makeWindowBlocks(count: min(space.windowCount, 5), space: space)
			let fullscreenMarkerLayer = makeFullscreenMarkerLayer(for: space)
			for display in currentViewModel?.displays ?? [] {
			let groupContainer = CALayer()
			groupContainer.name = display.displayLabel
			groupContainer.cornerRadius = 14
			groupContainer.masksToBounds = false
			groupContainer.borderWidth = 0
			groupContainer.borderColor = NSColor.clear.cgColor
			groupContainer.backgroundColor = 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 = 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

			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)

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

			return SpaceLaneSegmentLayers(
			space: space,
			containerLayer: container,
			labelLayer: labelLayer,
			countLayer: countLayer,
			appLayer: appLayer,
			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() {
			@@ -1559,6 +1948,8 @@
			layoutSpaceLaneSegments()
			layoutAppShelfItems()
			layoutWaterfallColumns()
			layoutCloseConfirmation()
			layoutCloseFeedback()

			CATransaction.commit()
			}
			@@ -1642,15 +2033,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(
			@@ -1660,13 +2070,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
			}
			}

			@@ -1678,26 +2110,60 @@
			min(max(0, offset), spaceLaneMaxScrollOffset)
			}

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

			private func applySpaceLaneVisualState(_ segment: SpaceLaneSegmentLayers) {
			let isHovered = segment.space.id == hoveredSpaceID
			let isHovered = segment.space.id == activeSpaceFocusID
			let isFocused = segment.space.id == activeSpaceFocusID
			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
			let isAssociated = (isAppAssociated \|\| isWindowAssociated) && !isActive

			segment.containerLayer.borderWidth = isCurrent ? 1.5 : 1
			segment.containerLayer.borderColor = (isCurrent
			? NSColor.labelColor.withAlphaComponent(0.34)
			: isActive
			? NSColor.labelColor.withAlphaComponent(0.24)
			segment.containerLayer.borderWidth = (hasWindows \|\| isCurrent \|\| isActive \|\| isAssociated) ? 1.5 : 1
			segment.containerLayer.borderColor = (isActive
			? spaceLaneOccupiedColor.withAlphaComponent(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
			? NSColor.windowBackgroundColor.withAlphaComponent(0.76)
			: spaceColor(for: segment.space)
			? accentTintedWindowBackground(fraction: 0.10, alpha: 0.94)
			: isAssociated
			? accentTintedWindowBackground(fraction: 0.07, alpha: 0.90)
			: spaceColor(for: segment.space)
			).cgColor
			segment.containerLayer.shadowOpacity = isCurrent ? 0.12 : isActive ? 0.08 : 0
			segment.containerLayer.shadowRadius = isCurrent ? 10 : isActive ? 7 : 0
			segment.containerLayer.shadowOffset = CGSize(width: 0, height: isCurrent ? -2 : -1)
			segment.containerLayer.shadowOpacity = isActive ? 0.26 : isAssociated ? 0.18 : isCurrent ? 0.14 : 0
			segment.containerLayer.shadowRadius = isActive ? 24 : isAssociated ? 18 : isCurrent ? 12 : 0
			segment.containerLayer.shadowOffset = CGSize(
			width: 0,
			height: isActive ? -6 : isAssociated ? -4 : isCurrent ? -2.5 : 0
			)
			segment.containerLayer.zPosition = 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 = CGPath(
			roundedRect: segment.containerLayer.bounds,
			cornerWidth: segment.containerLayer.cornerRadius,
			@@ -1744,14 +2210,32 @@

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

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

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

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

			return nil
			}

			private func spaceLaneSegment(spaceID: UInt64) -> SpaceLaneSegmentLayers? {
			@@ -1801,8 +2285,20 @@
			let bounds = segment.containerLayer.bounds
			segment.labelLayer.frame = CGRect(x: 10, y: bounds.height - 29, width: max(1, bounds.width - 48), height: 20)
			segment.countLayer.frame = CGRect(x: bounds.width - 34, y: bounds.height - 29, width: 24, height: 20)
			segment.appLayer.frame = CGRect(x: 10, y: 9, width: max(1, bounds.width - 20), height: 17)
			segment.fullscreenMarkerLayer?.frame = CGRect(x: 10, y: bounds.height - 7, width: max(1, bounds.width - 20), height: 3)
			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
			)
			} else {
			segment.appLayer.frame = CGRect(x: 10, y: 9, width: max(1, bounds.width - 20), height: 17)
			}
			if let fullscreenMarkerLayer = segment.fullscreenMarkerLayer {
			layoutFullscreenMarkerLayer(fullscreenMarkerLayer, in: bounds)
			}

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

			item.containerLayer.zPosition = appShelfZPosition(selected: isSelected, hovered: isHovered)
			item.containerLayer.zPosition = appShelfZPosition(
			selected: showsSelectedVisual,
			hovered: isHovered,
			spaceFocused: isSpaceFocused
			)
			item.backgroundLayer.backgroundColor = appShelfBackgroundColor(
			selected: isSelected,
			selected: showsSelectedVisual,
			hovered: isHovered,
			spaceFocused: isSpaceFocused
			).cgColor
			item.backgroundLayer.borderColor = (isSelected
			? NSColor.separatorColor.withAlphaComponent(0.38)
			item.backgroundLayer.borderColor = (showsSelectedVisual
			? NSColor.controlAccentColor.withAlphaComponent(0.40)
			: isHovered
			? NSColor.separatorColor.withAlphaComponent(0.28)
			? NSColor.controlAccentColor.withAlphaComponent(0.36)
			: NSColor.clear
			).cgColor
			item.backgroundLayer.borderWidth = (isSelected \|\| isHovered) ? 1 : 0
			item.backgroundLayer.borderWidth = (showsSelectedVisual \|\| isHovered) ? 1 : 0
			item.backgroundLayer.shadowColor = NSColor.black.cgColor
			item.backgroundLayer.shadowOpacity = isSelected ? 0.11 : isHovered ? 0.06 : 0
			item.backgroundLayer.shadowRadius = isSelected ? 10 : isHovered ? 7 : 0
			item.backgroundLayer.shadowOffset = CGSize(width: 0, height: -2)
			item.backgroundLayer.shadowOpacity = showsSelectedVisual ? 0.11 : isHovered ? 0.07 : isSpaceFocused ? 0.18 : 0
			item.backgroundLayer.shadowRadius = showsSelectedVisual ? 10 : isHovered ? 8 : isSpaceFocused ? 18 : 0
			item.backgroundLayer.shadowOffset = CGSize(width: 0, height: isSpaceFocused ? -4 : -2)
			item.backgroundLayer.frame = CGRect(
			x: iconX - backgroundPadding,
			y: iconY - backgroundPadding,
			width: visualIconSize + backgroundPadding * 2,
			height: visualIconSize + backgroundPadding * 2
			)
			item.backgroundLayer.shadowPath = (showsSelectedVisual \|\| isHovered \|\| isSpaceFocused)
			? CGPath(
			roundedRect: item.backgroundLayer.bounds,
			cornerWidth: item.backgroundLayer.cornerRadius,
			cornerHeight: item.backgroundLayer.cornerRadius,
			transform: nil
			)
			: nil
			item.iconLayer.frame = CGRect(x: iconX, y: iconY, width: visualIconSize, height: visualIconSize)
			item.labelLayer.contentsScale = backingScaleFactor
			item.labelLayer.frame = CGRect(x: 0, y: 0, width: bounds.width, height: 14)
			@@ -1908,6 +2426,15 @@
			y: iconY - 2,
			width: badgeWidth,
			height: 16
			)
			layoutCloseButton(
			item.closeButton,
			target: .app(appGroupIndex: item.item.appGroupIndex),
			visible: isHovered && canClose(app: item.item.app),
			anchorTopRight: CGPoint(
			x: min(iconX + visualIconSize - 6, bounds.width - 12),
			y: min(iconY + visualIconSize - 6, bounds.height - 12)
			)
			)
			item.selectedIndicatorLayer.frame = .zero
			item.selectedIndicatorLayer.backgroundColor = NSColor.clear.cgColor
			@@ -1936,7 +2463,52 @@
			}

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

			if hoverTargetSource == .debug {
			return spaceID
			}

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

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

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

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

			private var isSpaceAssociationActive: Bool {
			activeSpaceFocusID != nil
			}

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

			private func spaceFocusedAppGroupIndexes() -> [Int] {
			@@ -1994,33 +2566,45 @@
			return "visible"
			}

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

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

			private func appShelfBackgroundColor(selected: Bool, hovered: Bool, spaceFocused: Bool) -> NSColor {
			if selected {
			return NSColor.controlAccentColor.withAlphaComponent(0.12)
			return NSColor.controlAccentColor.withAlphaComponent(0.14)
			}
			if hovered {
			return NSColor.systemFill.withAlphaComponent(0.12)
			return NSColor.controlAccentColor.withAlphaComponent(0.13)
			}
			if spaceFocused {
			return NSColor.keyboardFocusIndicatorColor.withAlphaComponent(0.10)
			return NSColor.controlAccentColor.withAlphaComponent(0.14)
			}
			return .clear
			}
			@@ -2061,7 +2645,7 @@
			}

			let columnWidth = waterfallColumnWidth()
			let totalWidth = WaterfallMetrics.columnPadding * 2
			let totalWidth = WaterfallMetrics.contentHorizontalPadding * 2
			+ CGFloat(waterfallColumns.count) * columnWidth
			+ CGFloat(max(0, waterfallColumns.count - 1)) * WaterfallMetrics.gap
			waterfallContentWidth = max(waterfallLayer.bounds.width, totalWidth)
			@@ -2073,7 +2657,7 @@
			height: waterfallLayer.bounds.height
			)

			var x = WaterfallMetrics.columnPadding
			var x = WaterfallMetrics.contentHorizontalPadding
			for column in waterfallColumns {
			column.containerLayer.frame = CGRect(
			x: x,
			@@ -2089,6 +2673,7 @@
			private func layoutWaterfallColumn(_ column: WaterfallColumnLayers) {
			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)
			@@ -2105,11 +2690,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,
			@@ -2124,10 +2713,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 {
			@@ -2136,7 +2725,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
			@@ -2149,33 +2738,63 @@
			let bounds = card.containerLayer.bounds
			let isSelected = card.item.window.id == effectiveSelection?.windowID
			let isHovered = card.item.window.id == hoveredWindowID
			applyWaterfallCardVisualState(card, selected: isSelected, hovered: isHovered)

			let thumbnailWidth = max(90, min(116, bounds.width * 0.44))
			card.thumbnailLayer.frame = CGRect(
			x: 10,
			y: 12,
			width: thumbnailWidth,
			height: bounds.height - 24
			applyWaterfallCardVisualState(
			card,
			selected: shouldShowSelectedVisual(isSelected: isSelected, isHovered: isHovered),
			hovered: isHovered
			)
			card.appIconLayer.frame = CGRect(x: 18, y: bounds.height - 38, width: 22, height: 22)

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

			card.thumbnailLayer.frame = CGRect(
			x: thumbnailFrame.minX,
			y: thumbnailFrame.minY,
			width: thumbnailFrame.width,
			height: thumbnailFrame.height
			)
			card.titleBarLayer.frame = titleBarFrame
			card.appIconLayer.frame = CGRect(x: titleBarFrame.minX + 7, y: titleBarFrame.minY + 5, width: 16, height: 16)
			card.titleLayer.frame = CGRect(
			x: thumbnailWidth + 22,
			y: bounds.height - 31,
			width: max(1, bounds.width - thumbnailWidth - 34),
			x: titleBarFrame.minX + 29,
			y: titleBarFrame.minY + 6,
			width: max(1, titleBarFrame.width - 68),
			height: 16
			)
			card.metaLayer.frame = CGRect(
			x: thumbnailWidth + 22,
			y: bounds.height - 51,
			width: max(1, bounds.width - thumbnailWidth - 34),
			x: titleBarFrame.maxX - 38,
			y: titleBarFrame.minY + 6,
			width: 30,
			height: 14
			)
			card.stateLayer.frame = CGRect(
			x: thumbnailWidth + 22,
			y: 12,
			width: max(1, bounds.width - thumbnailWidth - 34),
			x: thumbnailFrame.maxX - 86,
			y: thumbnailFrame.minY + 6,
			width: 78,
			height: 14
			)
			layoutCloseButton(
			card.closeButton,
			target: .window(
			appGroupIndex: card.item.appGroupIndex,
			windowIndex: card.item.windowIndex,
			windowID: card.item.window.id
			),
			visible: isHovered,
			anchorTopRight: CGPoint(x: bounds.maxX - 12, y: bounds.maxY - 12)
			)
			card.shineLayer.frame = CGRect(
			x: -bounds.width * 0.18,
			@@ -2186,34 +2805,575 @@
			}

			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
			? NSColor.systemFill.withAlphaComponent(0.13)
			? accentTintedWindowBackground(fraction: 0.09, alpha: 0.95)
			: isSpaceFocused
			? NSColor.windowBackgroundColor.withAlphaComponent(0.88)
			? accentTintedWindowBackground(fraction: 0.10, alpha: 0.94)
			: NSColor.windowBackgroundColor.withAlphaComponent(0.82)
			).cgColor
			card.containerLayer.borderColor = (selected
			? NSColor.controlAccentColor.withAlphaComponent(0.52)
			: hovered
			? NSColor.separatorColor.withAlphaComponent(0.46)
			? NSColor.controlAccentColor.withAlphaComponent(0.44)
			: isSpaceFocused
			? NSColor.separatorColor.withAlphaComponent(0.38)
			? NSColor.controlAccentColor.withAlphaComponent(0.42)
			: NSColor.separatorColor.withAlphaComponent(0.28)
			).cgColor
			card.containerLayer.borderWidth = selected ? 1.5 : 1
			card.containerLayer.borderWidth = (selected \|\| hovered \|\| isSpaceFocused) ? 1.5 : 1
			card.containerLayer.shadowColor = NSColor.black.cgColor
			card.containerLayer.shadowOpacity = selected ? 0.20 : hovered ? 0.08 : 0
			card.containerLayer.shadowRadius = selected ? 18 : hovered ? 10 : 0
			card.containerLayer.shadowOpacity = selected ? 0.24 : hovered ? 0.14 : isSpaceFocused ? 0.20 : 0
			card.containerLayer.shadowRadius = selected ? 22 : hovered ? 17 : isSpaceFocused ? 24 : 0
			card.containerLayer.shadowOffset = selected
			? CGSize(width: 0, height: -5)
			? CGSize(width: 0, height: -6)
			: hovered
			? CGSize(width: 0, height: -2)
			: .zero
			card.containerLayer.zPosition = selected ? 20 : hovered ? 10 : 0
			? CGSize(width: 0, height: -2.5)
			: isSpaceFocused
			? CGSize(width: 0, height: -5)
			: .zero
			card.containerLayer.zPosition = selected ? 20 : hovered ? 10 : isSpaceFocused ? 8 : 0
			let focusedScale: CGFloat = selected ? 1.015 : isSpaceFocused ? 1.012 : 1.008
			card.containerLayer.transform = (selected \|\| hovered \|\| isSpaceFocused)
			? CATransform3DMakeScale(focusedScale, focusedScale, 1)
			: CATransform3DIdentity
			card.containerLayer.shadowPath = (selected \|\| hovered \|\| isSpaceFocused)
			? CGPath(
			roundedRect: card.containerLayer.bounds,
			cornerWidth: card.containerLayer.cornerRadius,
			cornerHeight: card.containerLayer.cornerRadius,
			transform: nil
			)
			: nil
			card.titleBarLayer.backgroundColor = NSColor.clear.cgColor
			card.titleBarLayer.borderColor = NSColor.clear.cgColor
			card.titleBarLayer.borderWidth = 0
			card.shineLayer.opacity = selected ? 1 : 0
			}

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

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

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

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

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

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

			let layers = closeConfirmationLayers
			layers.containerLayer.isHidden = false
			layers.containerLayer.frame = CGRect(x: x, y: y, width: width, height: height)
			let contentX = arrowEdge == .left ? arrowWidth : 0
			let contentFrame = CGRect(x: contentX, y: 0, width: contentWidth, height: height)
			let bubblePath = closeConfirmationBubblePath(
			bounds: layers.containerLayer.bounds,
			contentFrame: contentFrame,
			arrowEdge: arrowEdge,
			arrowY: localArrowY
			)
			layers.backgroundLayer.frame = layers.containerLayer.bounds
			layers.backgroundLayer.path = bubblePath
			layers.containerLayer.shadowPath = bubblePath
			layers.titleLayer.string = confirmationTitle(for: request)
			layers.messageLayer.string = confirmationMessage(for: request)
			layers.titleLayer.frame = CGRect(x: contentFrame.minX + 22, y: height - 48, width: contentFrame.width - 44, height: 22)
			layers.messageLayer.frame = CGRect(x: contentFrame.minX + 22, y: height - 78, width: contentFrame.width - 44, height: 21)

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

			layers.cancelButtonLayer.frame = CGRect(x: contentFrame.maxX - 164, y: 22, width: 74, height: 32)
			layers.cancelButtonTextLayer.frame = layers.cancelButtonLayer.bounds.insetBy(dx: 0, dy: 7)
			layers.confirmButtonLayer.frame = CGRect(x: contentFrame.maxX - 78, y: 22, width: 56, height: 32)
			layers.confirmButtonTextLayer.frame = layers.confirmButtonLayer.bounds.insetBy(dx: 0, dy: 7)
			}

			private func setCloseFeedback(_ feedback: CloseFeedback, autoHideAfter delay: TimeInterval?) {
			closeFeedbackHideTask?.cancel()
			closeFeedback = feedback
			closeFeedbackLayer.isHidden = false
			closeFeedbackLayer.opacity = 1
			closeFeedbackTextLayer.string = feedback.message
			switch feedback.kind {
			case .progress:
			closeFeedbackLayer.backgroundColor = 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,
			arrowEdge: CloseConfirmationArrowEdge,
			arrowY: CGFloat
			) -> CGPath {
			let cornerRadius: CGFloat = 18
			let arrowHalfHeight: CGFloat = 10
			let path = CGMutablePath()
			let minX = contentFrame.minX
			let maxX = contentFrame.maxX
			let minY = contentFrame.minY
			let maxY = contentFrame.maxY
			let arrowY = min(max(arrowY, minY + cornerRadius + arrowHalfHeight + 4), maxY - cornerRadius - arrowHalfHeight - 4)

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

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

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

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

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

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

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

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

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

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

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

			requestClose(for: target)
			}

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

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

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

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

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

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

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

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

			private func appShelfCloseButtonTarget(at windowLocation: NSPoint) -> CloseTarget? {
			let locationInView = convert(windowLocation, from: nil)
			let locationInAppShelfContent = CGPoint(
			x: locationInView.x - glassLayer.frame.minX - shelfLayer.frame.minX - appShelfContentLayer.frame.minX,
			y: locationInView.y - glassLayer.frame.minY - shelfLayer.frame.minY - appShelfContentLayer.frame.minY
			)

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

			let locationInItem = CGPoint(
			x: locationInAppShelfContent.x - item.containerLayer.frame.minX,
			y: locationInAppShelfContent.y - item.containerLayer.frame.minY
			)
			if item.closeButton.containerLayer.frame.insetBy(dx: -8, dy: -8).contains(locationInItem) {
			return target
			}
			}
			return nil
			}

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

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

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

			private func accentTintedWindowBackground(fraction: CGFloat, alpha: CGFloat) -> NSColor {
			let color = NSColor.windowBackgroundColor.blended(withFraction: fraction, of: NSColor.controlAccentColor)
			?? NSColor.windowBackgroundColor
			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 {
			@@ -2222,7 +3382,7 @@
			let visibleColumns = min(4, max(1, waterfallColumns.count))
			let fittingWidth = (
			waterfallLayer.bounds.width
			- WaterfallMetrics.columnPadding * 2
			- WaterfallMetrics.contentHorizontalPadding * 2
			- CGFloat(max(0, visibleColumns - 1)) * WaterfallMetrics.gap
			) / CGFloat(visibleColumns)
			return max(
			@@ -2250,7 +3410,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
			@@ -2281,23 +3441,31 @@
			}

			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)
			return NSColor.controlBackgroundColor.withAlphaComponent(0.36)
			}

			return NSColor.controlBackgroundColor.withAlphaComponent(0.26)
			return NSColor.clear
			}

			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(calibratedRed: 0, green: 122 / 255, blue: 1, alpha: 1)
			}

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

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

			private func makeTextLayer(
			@@ -2318,31 +3486,201 @@
			return textLayer
			}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			return identifiers.joined(separator: " ")
			}

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

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

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

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

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

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

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

			shapeLayer.path = path
			}

			private func fullscreenMarkerFrame(in segmentBounds: CGRect) -> CGRect {
			CGRect(
			x: 10,
			y: 30,
			width: max(1, segmentBounds.width - 20),
			height: max(1, segmentBounds.height - 58)
			)
			}

			private func columnSelectionHistoryReports() -> [[String: Int]] {
			@@ -2379,17 +3717,27 @@
			"labelFrame": dictionary(from: item.labelLayer.frame),
			"labelTruncationMode": "middle",
			"badgeVisible": !item.badgeLayer.isHidden,
			"badgeText": item.badgeLayer.string ?? ""
			"badgeText": item.badgeLayer.string ?? "",
			"closeButtonVisible": item.closeButton.containerLayer.opacity > 0,
			"closeButtonFrame": dictionary(from: item.closeButton.containerLayer.frame),
			"closeButtonSize": Double(item.closeButton.containerLayer.bounds.width),
			"closeButtonFillColor": colorDictionary(from: item.closeButton.containerLayer.backgroundColor),
			"closeButtonGlyphColor": colorDictionary(from: item.closeButton.glyphLayer.strokeColor),
			"closeButtonGlyphLineWidth": Double(item.closeButton.glyphLayer.lineWidth)
			] as [String: Any]
			}
			}

			private func appShelfVisualStates(for item: AppShelfItemLayers) -> [String] {
			var states: [String] = []
			if item.item.appGroupIndex == effectiveSelection?.appGroupIndex {
			let isSelected = item.item.appGroupIndex == effectiveSelection?.appGroupIndex
			let isHovered = item.item.appGroupIndex == effectiveHoveredAppGroupIndex
			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 {
			@@ -2402,21 +3750,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)
			@@ -2498,8 +3874,22 @@
			"screenshotSource": screenshotSourceString(screenshotSource, for: card.item.window),
			"screenshotFallbackReason": screenshotFallbackReasonString(screenshotSource),
			"screenshotNotRequestedReason": screenshotSkippedReasonsByWindowID[card.item.window.id] ?? NSNull(),
			"backgroundColor": colorDictionary(from: card.containerLayer.backgroundColor),
			"shadowOpacity": Double(card.containerLayer.shadowOpacity),
			"shadowRadius": Double(card.containerLayer.shadowRadius),
			"thumbnailFrame": dictionary(from: card.thumbnailLayer.frame),
			"titleBarFrame": dictionary(from: card.titleBarLayer.frame),
			"titleBarBorderWidth": Double(card.titleBarLayer.borderWidth),
			"titleFrame": dictionary(from: card.titleLayer.frame),
			"metaFrame": dictionary(from: card.metaLayer.frame),
			"appIconFrame": dictionary(from: card.appIconLayer.frame),
			"stateFrame": dictionary(from: card.stateLayer.frame),
			"closeButtonVisible": card.closeButton.containerLayer.opacity > 0,
			"closeButtonFrame": dictionary(from: card.closeButton.containerLayer.frame),
			"closeButtonSize": Double(card.closeButton.containerLayer.bounds.width),
			"closeButtonFillColor": colorDictionary(from: card.closeButton.containerLayer.backgroundColor),
			"closeButtonGlyphColor": colorDictionary(from: card.closeButton.glyphLayer.strokeColor),
			"closeButtonGlyphLineWidth": Double(card.closeButton.glyphLayer.lineWidth),
			"shineVisible": card.shineLayer.opacity > 0,
			"zPosition": Double(card.containerLayer.zPosition),
			"frame": dictionary(from: card.containerLayer.frame),
			@@ -2594,13 +3984,17 @@

			private func waterfallCardVisualStates(for card: WaterfallCardLayers) -> [String] {
			var states: [String] = []
			if card.item.window.id == effectiveSelection?.windowID {
			let isSelected = card.item.window.id == effectiveSelection?.windowID
			let isHovered = card.item.window.id == hoveredWindowID
			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 {
			@@ -2616,25 +4010,71 @@
			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
			)
			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(),
			"windowBlockCount": segment.windowBlocks.count,
			"windowBlockColors": segment.windowBlocks.map { colorDictionary(from: $0.backgroundColor) },
			"windowBlockFrames": segment.windowBlocks.map { dictionary(from: $0.frame) },
			"backgroundColor": colorDictionary(from: segment.containerLayer.backgroundColor),
			"borderColor": colorDictionary(from: segment.containerLayer.borderColor),
			"borderWidth": Double(segment.containerLayer.borderWidth),
			"shadowOpacity": Double(segment.containerLayer.shadowOpacity),
			"shadowRadius": Double(segment.containerLayer.shadowRadius),
			"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
			@@ -2643,12 +4083,24 @@
			} ?? []
			}

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

			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 {
			@@ -2681,4 +4133,24 @@
			"height": Double(rect.height)
			]
			}

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

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