Durchsatz je Programm und öffentliche IP

Beides läuft nur, solange jemand hinsieht. Die Prozessliste startet je Messung
einen Fremdprozess — das im Sekundentakt zu tun kostete mehr als der gesamte
übrige Monitor. Sie wird deshalb an das offene Popover gekoppelt, nicht an die
Messschleife.

Für den Durchsatz je Programm gibt es keine Bibliotheksschnittstelle: die
zugrundeliegende NetworkStatistics-API ist privat und verlangt eine
Entitlement, die Apple nicht vergibt. nettop ist Apples eigenes Werkzeug dafür,
liegt im System und läuft — nachgemessen — ohne root für die Prozesse des
eigenen Nutzers. Die Rate entsteht wie bei den Interface-Zählern aus der
Differenz zweier Messungen.

Die öffentliche IP bleibt standardmäßig aus, und der Schalter dafür steht im
Popover statt versteckt in den Einstellungen: wer einen Systemmonitor benutzt,
rechnet nicht damit, dass der nach draußen telefoniert. Ist sie an, steht der
befragte Dienst sichtbar darunter — man soll nachlesen können, wem die Adresse
bekannt wird. Höchstens alle 15 Minuten, weil sie sich selten ändert.

Frequenzen sind der dritte Wunsch und der aufwendigste. Der Weg ist verifiziert:
IOReport ist vollständig verfügbar, die Gruppe "CPU Stats" liefert unter
"CPU Core Performance States" die Kanäle MCPU00 bis MCPU14 mit den
P-Zustands-Residenzen, und die Frequenztabellen stehen als voltage-states* im
IODeviceTree. Das kommt als Nächstes.

145 Tests grün.

Packages/OnyxKit/Sources/NetworkProvider/NetworkWidget.swift

@@ -14,11 +14,60 @@ public final class NetworkModel {
 
     public static let historyLength = 60
 
+    /// Durchsatz je Programm — nur gefüllt, solange ein Popover offen ist.
+    public private(set) var processes: [ProcessTraffic] = []
+    /// Die öffentliche Adresse, wenn eingeschaltet.
+    public let publicAddress = PublicAddressLookup()
+
+    /// Ob die öffentliche Adresse überhaupt abgefragt werden darf.
+    public var showsPublicAddress: Bool {
+        didSet {
+            guard showsPublicAddress != oldValue else { return }
+            defaults.set(showsPublicAddress, forKey: Self.publicAddressKey)
+            showsPublicAddress ? publicAddress.refresh() : publicAddress.clear()
+        }
+    }
+
+    private static let publicAddressKey = "onyx.network.showsPublicAddress"
+
+    private let defaults: UserDefaults
     private let source = NetworkMetrics()
+    private let processSampler = ProcessTrafficSampler()
     private var timer: Timer?
     private var demands: [UUID: TimeInterval] = [:]
+    /// Zählt die offenen Popovers. Die Prozessliste kostet einen Fremdprozess
+    /// je Messung — sie läuft nur, während wirklich jemand hinsieht.
+    private var detailConsumers = 0
 
-    public init() {}
+    public init(defaults: UserDefaults = .standard) {
+        self.defaults = defaults
+        self.showsPublicAddress = defaults.bool(forKey: Self.publicAddressKey)
+    }
+
+    /// Meldet ein offenes Popover an. Erst dann werden Prozesse abgefragt.
+    public func addDetailConsumer() {
+        detailConsumers += 1
+        if showsPublicAddress { publicAddress.refresh() }
+        sampleProcesses()
+    }
+
+    public func removeDetailConsumer() {
+        detailConsumers = max(detailConsumers - 1, 0)
+        if detailConsumers == 0 { processes = [] }
+    }
+
+    private func sampleProcesses() {
+        guard detailConsumers > 0 else { return }
+        // `nettop` blockiert kurz — nicht auf dem Hauptthread.
+        let sampler = processSampler
+        Task.detached(priority: .utility) {
+            let result = sampler.sample()
+            await MainActor.run { [weak self] in
+                guard let self, detailConsumers > 0 else { return }
+                processes = result
+            }
+        }
+    }
 
     @discardableResult
     public func addConsumer(interval: TimeInterval = 2) -> UUID {
@@ -51,6 +100,7 @@ public final class NetworkModel {
     private func sample() {
         let value = source.sample()
         snapshot = value
+        sampleProcesses()
         history.append(value)
         if history.count > Self.historyLength {
             history.removeFirst(history.count - Self.historyLength)