Die Notch wird zur Insel, wo es keine Hardware gibt

Die Silhouette bestand aus zwei überlappenden Teilpfaden. Gefüllt stimmte die
Vereinigung, aber die Kontur zeichnete jeden Teilpfad vollständig nach — auch
dort, wo er innen lag. Dazu kippte die Form ab einer Breite in einen anderen
Zweig, und die beiden Zweige waren nicht dieselbe Geometrie. Zusammen war das
das Flackern an den Rundungen. Jetzt ein durchgehender Umriss, dessen Zweige
ineinander übergehen statt zu springen.

Neu ist die Wahl zwischen verschmolzen und schwebend. Eine echte Notch **muss**
an der Kante kleben und oben eckig sein, sonst klafft ein Spalt zum Gehäuse;
eine Insel **muss** Abstand halten und rundum gerundet sein, sonst sieht sie aus
wie ein abgeschnittenes Rechteck. Beides zu mischen geht nicht, deshalb eine
Wahl und keine zwei Schalter.

Ihre Höhe rät Onyx nicht mehr, sondern misst die Menüleiste: 24 Punkte minus
Luft oben und unten. Vorher hing ein festes Maß unten heraus.

Dazu „nur der Hauptbildschirm" als dritte Anzeigewahl — gemeint ist der mit der
Menüleiste, nicht `NSScreen.main`, das mit dem aktiven Fenster mitwandert.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Packages/OnyxKit/Sources/OnyxNotch/NotchStateMachine.swift

@@ -31,6 +31,12 @@ public enum NotchInput: Equatable, Sendable {
     case closeTimerFired
     /// Vollbildvideo, „Nicht stören" oder ein anderer Grund, das Panel wegzuhalten.
     case suppressed(Bool)
+    /// Ob gerade eine Live Activity zu zeigen ist.
+    ///
+    /// Sie hält das Panel **eingeklappt sichtbar**: Fenster auf dem Schirm,
+    /// Fläche in Notchgröße, Band daneben belegt. Ausgefahren wird davon
+    /// nichts — das bleibt dem Zeiger vorbehalten.
+    case ambient(Bool)
 }
 
 /// Was der Aufrufer nach einem Übergang zu tun hat. Die Maschine selbst
@@ -42,6 +48,10 @@ public enum NotchEffect: Equatable, Sendable {
     case cancelCloseTimer
     case show
     case hide
+    /// Fenster einblenden, ohne auszufahren.
+    case showAmbient
+    /// Den eingeklappten Inhalt wieder wegnehmen.
+    case hideAmbient
 }
 
 /// Das Öffnungs- und Schließverhalten des Notch-Panels, frei von AppKit.
@@ -75,16 +85,29 @@ public struct NotchStateMachine: Equatable, Sendable {
     /// Kommt er zurück, wird ohne weiteres Warten geöffnet.
     private var debounceElapsed = false
 
+    /// Ob eine Live Activity anliegt.
+    public private(set) var hasAmbient = false
+
     public init() {}
 
-    /// Sichtbar, egal aus welchem Grund.
-    public var isVisible: Bool {
+    /// Ausgefahren — die Fläche zeigt Kacheln.
+    public var isExpanded: Bool {
         switch phase {
         case .open, .pinned, .closing: true
         case .idle, .arming: false
         }
     }
 
+    /// Auf dem Bildschirm, aus welchem Grund auch immer.
+    ///
+    /// **Getrennt von `isExpanded`, und das ist der ganze Punkt dieser
+    /// Erweiterung.** Bis hierher hieß „nicht ausgefahren" auch „nicht da":
+    /// `idle` war unsichtbar. Eine Live Activity ist aber eingeklappt *und*
+    /// sichtbar — sonst gäbe es keinen Ort, an dem sie stehen könnte.
+    public var isOnScreen: Bool {
+        !isSuppressed && (isExpanded || hasAmbient)
+    }
+
     @discardableResult
     public mutating func handle(_ input: NotchInput) -> [NotchEffect] {
         // Unterdrückung schlägt jeden anderen Zustand, auch die Fixierung.
@@ -94,12 +117,28 @@ public struct NotchStateMachine: Equatable, Sendable {
             guard active != isSuppressed else { return [] }
             isSuppressed = active
 
-            guard active else { return [] }
-            let wasVisible = isVisible
+            guard active else {
+                // Unterdrückung vorbei: was eingeklappt anliegt, darf zurück.
+                return hasAmbient ? [.showAmbient] : []
+            }
+            let wasExpanded = isExpanded
             phase = .idle
-            return wasVisible
-                ? [.cancelArmTimer, .cancelCloseTimer, .hide]
-                : [.cancelArmTimer, .cancelCloseTimer]
+            var effects: [NotchEffect] = [.cancelArmTimer, .cancelCloseTimer]
+            if wasExpanded { effects.append(.hide) }
+            if hasAmbient { effects.append(.hideAmbient) }
+            return effects
+        }
+
+        // Live Activities kommen und gehen unabhängig vom Zeiger. Sie ändern
+        // die Phase **nicht**: ein eingeblendeter Titel darf nicht dazu führen,
+        // dass ein Klick plötzlich fixiert oder eine Frist läuft.
+        if case .ambient(let present) = input {
+            guard present != hasAmbient else { return [] }
+            hasAmbient = present
+            // Ausgefahren ist ohnehin alles zu sehen, und unterdrückt gar
+            // nichts. In beiden Fällen bleibt es beim Merken.
+            guard !isSuppressed, !isExpanded else { return [] }
+            return present ? [.showAmbient] : [.hideAmbient]
         }
 
         guard !isSuppressed else { return [] }