Phase 1: Notch-Shell, Design-System, Menüleisten-Infrastruktur

Zustandsmaschine und Geometrie sind testgetrieben entstanden und tragen 40
Tests — sie sind frei von AppKit, damit jeder Übergang ohne Fenster und ohne
Warten prüfbar ist. Zeit kommt nur als Ereignis herein.

Zwei Entscheidungen, die im Code begründet sind:

Der Zeiger wird über einen globalen Ereignismonitor verfolgt, nicht über ein
unsichtbares Fenster auf der Notch. Ein solches Fenster müsste Mausereignisse
annehmen, um sie zu bemerken, und würde damit Menüleiste und Fensterknöpfe
darunter unbenutzbar machen.

"Nur internes Display" fällt auf ein externes zurück, wenn kein eingebautes da
ist. Am Dock mit geschlossenem Deckel hieße die Einstellung wörtlich genommen,
dass Onyx unerreichbar wird.

Design: NSVisualEffectView mit eigenem Tint statt Liquid Glass — Onyx ist Stein,
kein Glas. Alle Farben und Maße liegen als Tokens in OnyxDesign.

Menüleiste: jedes Modul bekommt ein eigenes NSStatusItem. Elemente, denen macOS
mangels Platz keine Breite gibt, werden erkannt und gemeldet, statt still zu
verschwinden.

App-Target über XcodeGen, damit die Projektdefinition im Diff lesbar bleibt.
Nicht sandboxed, mit App-Group-Entitlement — baut, startet, signiert mit
PP34X97WS3.

Packages/OnyxKit/Sources/OnyxNotch/NotchScreenController.swift

@@ -0,0 +1,106 @@
+import AppKit
+
+/// Führt für genau einen Bildschirm Geometrie, Zustandsmaschine und Fenster zusammen.
+///
+/// Die Entscheidungen trifft `NotchStateMachine`; diese Klasse übersetzt sie nur
+/// in Timer und Fensteraufrufe. Deshalb steht hier auch kein `if phase == …`.
+@MainActor
+public final class NotchScreenController {
+
+    public private(set) var geometry: NotchGeometry
+    public let displayID: CGDirectDisplayID
+
+    private var machine = NotchStateMachine()
+    private let panel: NotchPanel
+    private var armTimer: DispatchWorkItem?
+    private var closeTimer: DispatchWorkItem?
+
+    /// Größe des ausgefahrenen Panels. Ab Phase 2 liefert das die Layout-Engine.
+    public var expandedSize = CGSize(width: 640, height: 320) {
+        didSet { if machine.isVisible { layoutPanel() } }
+    }
+
+    public init(metrics: ScreenMetrics, virtualSize: CGSize, content: NSView) {
+        self.displayID = metrics.displayID
+        self.geometry = NotchGeometry.resolve(metrics, virtualSize: virtualSize)
+        self.panel = NotchPanel(contentRect: .zero)
+        panel.contentView = content
+        layoutPanel()
+    }
+
+    public var phase: NotchPhase { machine.phase }
+    public var isVisible: Bool { machine.isVisible }
+
+    // MARK: - Eingaben
+
+    /// Zeigerposition in globalen Bildschirmkoordinaten.
+    public func pointerMoved(to point: CGPoint) {
+        let inside = geometry.triggerRect.contains(point)
+            || (machine.isVisible && panel.frame.contains(point))
+        apply(machine.handle(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))) }
+
+    /// Nach einem Wechsel von Auflösung, Anordnung oder Skalierung.
+    public func update(metrics: ScreenMetrics, virtualSize: CGSize) {
+        geometry = NotchGeometry.resolve(metrics, virtualSize: virtualSize)
+        layoutPanel()
+    }
+
+    public func tearDown() {
+        armTimer?.cancel()
+        closeTimer?.cancel()
+        panel.orderOut(nil)
+    }
+
+    // MARK: - Wirkungen
+
+    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))
+                }
+
+            case .cancelArmTimer:
+                armTimer?.cancel()
+                armTimer = nil
+
+            case .startCloseTimer(let delay):
+                closeTimer?.cancel()
+                closeTimer = schedule(after: delay) { [weak self] in
+                    guard let self else { return }
+                    apply(machine.handle(.closeTimerFired))
+                }
+
+            case .cancelCloseTimer:
+                closeTimer?.cancel()
+                closeTimer = nil
+
+            case .show:
+                layoutPanel()
+                panel.orderFrontRegardless()
+
+            case .hide:
+                panel.orderOut(nil)
+            }
+        }
+    }
+
+    private func schedule(after delay: TimeInterval, _ body: @escaping @MainActor () -> Void)
+    -> DispatchWorkItem {
+        let item = DispatchWorkItem { MainActor.assumeIsolated { body() } }
+        DispatchQueue.main.asyncAfter(deadline: .now() + delay, execute: item)
+        return item
+    }
+
+    private func layoutPanel() {
+        panel.setFrame(geometry.panelRect(for: expandedSize), display: machine.isVisible)
+    }
+}