rename: lumen → punktfunk, everywhere

Full project rename, decided 2026-06-10:
- Crates/binaries: punktfunk-core / punktfunk-host / punktfunk-client-rs.
- C ABI: punktfunk_* symbols, Punktfunk* types, include/punktfunk_core.h,
  PUNKTFUNK_FEATURE_QUIC guard (header regenerated; cbindgen renames updated, incl.
  PUNKTFUNK_BTN_*/PUNKTFUNK_AXIS_* wire constants).
- Protocol: punktfunk/1 — control-plane magic LMN1 → PKF1, nonce salt lmn1 → pkf1.
  WIRE BREAK: clients must be rebuilt from this revision.
- Env knobs: PUNKTFUNK_VIDEO_SOURCE / PUNKTFUNK_COMPOSITOR / PUNKTFUNK_ZEROCOPY / ….
- Host config dir: ~/.config/punktfunk (the box's dir was migrated in place — the
  persistent identity is unchanged, pinned fingerprints stay valid).
- Swift package: PunktfunkKit + PunktfunkCore.xcframework + PunktfunkConnection
  (Sources/PunktfunkClient app + tests renamed with it); build-xcframework.sh updated.
- scripts/: 60-punktfunk.rules, punktfunk-host.service; OpenAPI doc regenerated.

Also: scripts/headless/run-headless-kde.sh — full headless Plasma bringup. Root cause of
"desktop but no apps/settings" over the stream: plasmashell launched without
XDG_MENU_PREFIX=plasma-, so the launcher resolved a nonexistent applications.menu and
rendered an empty menu. The script sets the complete KDE session env (menu prefix,
KDE_FULL_SESSION, session version) and rebuilds ksycoca before starting plasmashell.

Gate: 97/97 tests, clippy -D warnings (both feature sets), fmt, C-ABI harness PASS,
zero lumen references left outside .git.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

clients/apple/Sources/PunktfunkClient/ContentView.swift

@@ -0,0 +1,122 @@
+// Connect form ⇄ live stream. Stage-1 UX: pick host + mode, see frames, type/aim.
+
+import AppKit
+import PunktfunkKit
+import SwiftUI
+
+struct ContentView: View {
+    @StateObject private var model = SessionModel()
+    @AppStorage("punktfunk.host") private var host = "192.168.1.70"
+    @AppStorage("punktfunk.port") private var port = 9777
+    @AppStorage("punktfunk.width") private var width = 1920
+    @AppStorage("punktfunk.height") private var height = 1080
+    @AppStorage("punktfunk.hz") private var hz = 60
+
+    var body: some View {
+        Group {
+            if let conn = model.connection {
+                stream(conn)
+            } else {
+                connectForm
+            }
+        }
+        .onAppear { autoConnectIfAsked() }
+        .onDisappear { model.disconnect() } // window closed mid-session (Cmd+N spawns more)
+    }
+
+    /// Development hook: PUNKTFUNK_AUTOCONNECT=host[:port] connects immediately at the saved
+    /// (or PUNKTFUNK_MODE=WxHxHz) mode — lets scripts drive first-light runs. (IPv4/hostname
+    /// only; an IPv6 literal would need bracket parsing.)
+    private func autoConnectIfAsked() {
+        guard let target = ProcessInfo.processInfo.environment["PUNKTFUNK_AUTOCONNECT"],
+              !target.isEmpty, model.connection == nil, !model.connecting
+        else { return }
+        let parts = target.split(separator: ":")
+        host = String(parts[0])
+        if parts.count == 2, let p = Int(parts[1]) { port = p }
+        if let mode = ProcessInfo.processInfo.environment["PUNKTFUNK_MODE"] {
+            let dims = mode.split(separator: "x").compactMap { Int($0) }
+            if dims.count == 3 {
+                width = dims[0]
+                height = dims[1]
+                hz = dims[2]
+            }
+        }
+        model.connect(
+            host: host, port: UInt16(clamping: port),
+            width: UInt32(clamping: width), height: UInt32(clamping: height),
+            hz: UInt32(clamping: hz))
+    }
+
+    private func stream(_ conn: PunktfunkConnection) -> some View {
+        StreamView(
+            connection: conn,
+            onFrame: { [meter = model.meter] au in meter.note(byteCount: au.data.count) },
+            onSessionEnd: { [weak model] in
+                Task { @MainActor in model?.sessionEnded() }
+            }
+        )
+        .overlay(alignment: .topTrailing) { hud(conn) }
+        .frame(minWidth: 640, minHeight: 360)
+        .background(Color.black)
+    }
+
+    private func hud(_ conn: PunktfunkConnection) -> some View {
+        VStack(alignment: .trailing, spacing: 4) {
+            Text("\(conn.width)×\(conn.height)@\(conn.refreshHz)  \(model.fps) fps  \(model.mbps, specifier: "%.1f") Mb/s")
+                .font(.system(.caption, design: .monospaced))
+            Button("Disconnect") { model.disconnect() }
+                .font(.caption)
+        }
+        .padding(8)
+        .background(.black.opacity(0.5), in: RoundedRectangle(cornerRadius: 6))
+        .foregroundStyle(.white)
+        .padding(10)
+    }
+
+    private var connectForm: some View {
+        VStack(spacing: 14) {
+            Text("punktfunk").font(.largeTitle.weight(.semibold))
+            Form {
+                TextField("Host", text: $host)
+                TextField("Port", value: $port, format: .number.grouping(.never))
+                HStack {
+                    TextField("Width", value: $width, format: .number.grouping(.never))
+                    Text("×")
+                    TextField("Height", value: $height, format: .number.grouping(.never))
+                    Text("@")
+                    TextField("Hz", value: $hz, format: .number.grouping(.never))
+                }
+                Button("Use this display's mode") { fillFromMainScreen() }
+                    .buttonStyle(.link)
+            }
+            .frame(width: 340)
+
+            if let error = model.errorMessage {
+                Text(error)
+                    .font(.caption)
+                    .foregroundStyle(.red)
+                    .frame(width: 340)
+            }
+
+            Button(model.connecting ? "Connecting…" : "Connect") {
+                model.connect(
+                    host: host, port: UInt16(clamping: port),
+                    width: UInt32(clamping: width), height: UInt32(clamping: height),
+                    hz: UInt32(clamping: hz))
+            }
+            .keyboardShortcut(.defaultAction)
+            .disabled(model.connecting || host.isEmpty)
+        }
+        .padding(28)
+        .frame(minWidth: 420, minHeight: 320)
+    }
+
+    private func fillFromMainScreen() {
+        guard let screen = NSScreen.main else { return }
+        let scale = screen.backingScaleFactor
+        width = Int(screen.frame.width * scale)
+        height = Int(screen.frame.height * scale)
+        hz = screen.maximumFramesPerSecond
+    }
+}

clients/apple/Sources/PunktfunkClient/PunktfunkClientApp.swift

@@ -0,0 +1,29 @@
+// PunktfunkClient — development app shell around PunktfunkKit (swift run PunktfunkClient).
+// Connect form → StreamView (AVSampleBufferDisplayLayer HEVC) + InputCapture.
+
+import AppKit
+import SwiftUI
+
+@main
+struct PunktfunkClientApp: App {
+    @NSApplicationDelegateAdaptor(AppDelegate.self) private var appDelegate
+
+    var body: some Scene {
+        WindowGroup("punktfunk") {
+            ContentView()
+        }
+    }
+}
+
+final class AppDelegate: NSObject, NSApplicationDelegate {
+    func applicationDidFinishLaunching(_ notification: Notification) {
+        // `swift run` launches an unbundled binary; promote it to a regular app so the
+        // window fronts and receives keyboard/mouse focus (GameController needs focus).
+        NSApp.setActivationPolicy(.regular)
+        NSApp.activate(ignoringOtherApps: true)
+    }
+
+    func applicationShouldTerminateAfterLastWindowClosed(_ sender: NSApplication) -> Bool {
+        true
+    }
+}

clients/apple/Sources/PunktfunkClient/SessionModel.swift

@@ -0,0 +1,115 @@
+// Session state for the app shell: owns the connection, the input capture, and the
+// pump-thread → main-actor stats relay.
+
+import Foundation
+import PunktfunkKit
+import SwiftUI
+
+/// Pump-thread-side frame counters; a 1 Hz main-actor timer drains them into @Published
+/// values. NSLock instead of an actor — the writer is the (non-async) pump thread.
+final class FrameMeter: @unchecked Sendable {
+    private let lock = NSLock()
+    private var frames = 0
+    private var bytes = 0
+    private var totalFrames = 0
+
+    func note(byteCount: Int) {
+        lock.lock()
+        frames += 1
+        bytes += byteCount
+        totalFrames += 1
+        lock.unlock()
+    }
+
+    /// Returns and resets the per-interval counters (the running total stays).
+    func drain() -> (frames: Int, bytes: Int, total: Int) {
+        lock.lock()
+        defer {
+            frames = 0
+            bytes = 0
+            lock.unlock()
+        }
+        return (frames, bytes, totalFrames)
+    }
+}
+
+@MainActor
+final class SessionModel: ObservableObject {
+    @Published var connection: PunktfunkConnection?
+    @Published var connecting = false
+    @Published var errorMessage: String?
+    @Published var fps = 0
+    @Published var mbps = 0.0
+    @Published var totalFrames = 0
+
+    let meter = FrameMeter()
+    private var inputCapture: InputCapture?
+    private var statsTimer: Timer?
+
+    func connect(host: String, port: UInt16, width: UInt32, height: UInt32, hz: UInt32) {
+        guard !connecting else { return }
+        connecting = true
+        errorMessage = nil
+        Task.detached(priority: .userInitiated) {
+            // PunktfunkConnection.init blocks on the QUIC handshake — keep it off the main actor.
+            let result = Result { try PunktfunkConnection(
+                host: host, port: port, width: width, height: height, refreshHz: hz) }
+            await MainActor.run { [weak self] in
+                guard let self else { return }
+                self.connecting = false
+                switch result {
+                case .success(let conn):
+                    self.connection = conn
+                    self.startInput(conn)
+                    self.startStatsTimer()
+                case .failure:
+                    self.errorMessage = "Connection failed — is the host running? " +
+                        "(punktfunk-host m3-host on \(host):\(port))"
+                }
+            }
+        }
+    }
+
+    func disconnect() {
+        inputCapture?.stop()
+        inputCapture = nil
+        statsTimer?.invalidate()
+        statsTimer = nil
+        if let conn = connection {
+            // close() waits out an in-flight poll (≤100 ms) and joins the Rust worker
+            // threads — keep that off the main actor.
+            Task.detached { conn.close() }
+        }
+        connection = nil
+        fps = 0
+        mbps = 0
+    }
+
+    /// Called (via the main actor) when the pump hits end-of-session.
+    func sessionEnded() {
+        guard connection != nil else { return }
+        disconnect()
+        errorMessage = "Session ended by host."
+    }
+
+    private func startInput(_ conn: PunktfunkConnection) {
+        let capture = InputCapture(connection: conn)
+        capture.start()
+        inputCapture = capture
+    }
+
+    private func startStatsTimer() {
+        let timer = Timer(timeInterval: 1.0, repeats: true) { [weak self] _ in
+            guard let self else { return }
+            Task { @MainActor in
+                let (frames, bytes, total) = self.meter.drain()
+                self.fps = frames
+                self.mbps = Double(bytes) * 8 / 1_000_000
+                self.totalFrames = total
+            }
+        }
+        // .common so the HUD keeps updating during window drags / menu tracking.
+        RunLoop.main.add(timer, forMode: .common)
+        statsTimer = timer
+    }
+}