Schließen entruckeln: Material fest, Maske animiert, Zeiger abgefragt

Drei Ursachen, davon zwei echte Fehler.

Die NSVisualEffectView steckte in einem Rahmen, dessen Größe animiert wurde.
Ein Weichzeichner muss dann in jedem Einzelbild neu in anderer Größe gerechnet
werden — am teuersten genau beim Schließen, wo die Fläche am schnellsten
schrumpft. Das Material behält jetzt feste Größe, animiert wird nur die Maske
davor. Tint, Bänderung und Kante sind reine SwiftUI-Formen und dürfen weiter in
der Größe animieren. Auch die Schattendeckkraft ist jetzt konstant statt
animiert; sie aufzublenden kostete pro Bild eine neue Weichzeichnung.

Onyx bekam Mausbewegungen über dem eigenen Panel praktisch nicht mit. Der
globale Monitor feuert nur für Ereignisse an fremde Programme, der lokale nur
wenn Onyx aktiv ist — was es als .accessory-App nie ist. Ausgerechnet beim
Verlassen des Panels kam das Ereignis also verspätet oder gar nicht. Solange
ein Panel offen ist, wird die Zeigerposition jetzt mit 60 Hz abgefragt; der
Timer läuft ausschließlich in dieser Zeit.

Öffnen und Schließen benutzten dieselbe Kurve. Schließen ist jetzt kürzer und
ohne Nachschwingen: beim Öffnen sieht man zu, beim Schließen ist man schon
woanders.

Nebenbefund beim Prüfen: es liefen zwei Onyx-Instanzen aus verschiedenen Builds
gleichzeitig, jede mit eigener Zustandsmaschine auf derselben Notch. Das dürfte
einen guten Teil der Hakeligkeit erklärt haben.

Packages/OnyxKit/Sources/OnyxNotch/NotchScreenController.swift

@@ -56,6 +56,10 @@ public final class NotchScreenController {
     public var phase: NotchPhase { machine.phase }
     public var isVisible: Bool { machine.isVisible }
 
+    /// Meldet, wenn das Panel sichtbar wird oder verschwindet. Der Koordinator
+    /// schaltet daran die Zeigerabfrage an und aus.
+    public var onVisibilityChanged: ((Bool) -> Void)?
+
     // MARK: - Eingaben
 
     /// Zeigerposition in globalen Bildschirmkoordinaten.
@@ -66,12 +70,12 @@ public final class NotchScreenController {
         // Fläche das Panel offen.
         let inside = geometry.triggerRect.contains(point)
             || (presentation.isExpanded && panel.frame.contains(point))
-        apply(machine.handle(inside ? .pointerEntered : .pointerExited))
+        send(inside ? .pointerEntered : .pointerExited)
     }
 
-    public func click() { apply(machine.handle(.click)) }
-    public func escape() { apply(machine.handle(.escape)) }
-    public func setSuppressed(_ suppressed: Bool) { apply(machine.handle(.suppressed(suppressed))) }
+    public func click() { send(.click) }
+    public func escape() { send(.escape) }
+    public func setSuppressed(_ suppressed: Bool) { send(.suppressed(suppressed)) }
 
     /// Nach einem Wechsel von Auflösung, Anordnung oder Skalierung.
     public func update(metrics: ScreenMetrics, virtualSize: CGSize) {
@@ -93,14 +97,23 @@ public final class NotchScreenController {
 
     // MARK: - Wirkungen
 
+    /// Der einzige Weg, die Maschine zu bewegen.
+    ///
+    /// Sichtbarkeit wird hier verglichen und nicht in `apply`: `handle` hat den
+    /// Zustand dort bereits geändert, ein Vergleich käme also immer negativ zurück.
+    private func send(_ input: NotchInput) {
+        let wasVisible = machine.isVisible
+        apply(machine.handle(input))
+        if machine.isVisible != wasVisible { onVisibilityChanged?(machine.isVisible) }
+    }
+
     private func apply(_ effects: [NotchEffect]) {
         for effect in effects {
             switch effect {
             case .startArmTimer(let delay):
                 armTimer?.cancel()
                 armTimer = schedule(after: delay) { [weak self] in
-                    guard let self else { return }
-                    apply(machine.handle(.armTimerFired))
+                    self?.send(.armTimerFired)
                 }
 
             case .cancelArmTimer:
@@ -110,8 +123,7 @@ public final class NotchScreenController {
             case .startCloseTimer(let delay):
                 closeTimer?.cancel()
                 closeTimer = schedule(after: delay) { [weak self] in
-                    guard let self else { return }
-                    apply(machine.handle(.closeTimerFired))
+                    self?.send(.closeTimerFired)
                 }
 
             case .cancelCloseTimer: