fix: cap the Video settings summary to the device ceiling (follow-up to #17) (#29)

The 1080p60 unlock (#28) gated the Quality and Frame Rate pickers by
StreamCapability but left the collapsed Video launcher summary
interpolating the raw persisted videoQuality/frameRate. On a device
whose ceiling is below a stored value — e.g. a settings blob restored via
iCloud/backup from a more capable phone — the row rendered "1080p · … ·
60 fps" while the pickers and the actual encoded stream were correctly
capped, reintroducing the exact over-promise #17 set out to remove. Show
the effective (min'd) values so the summary matches what streams.

Also pins two StreamCore contracts an adversarial review flagged as
untested: the StreamCapability core-count boundary at exactly 6 (5 cores
+ ample RAM -> 30 fps) and the zero-dimension encodeSize fallback at a
1080 ceiling and under clamping.

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

Author: joeblau

Stream/SettingsView.swift

@@ -325,7 +325,13 @@ struct SettingsView: View {
                 ? "\(settings.selectedProtocol.displayName) · \(settings.isSecure ? "Secure" : "Unencrypted")"
                 : "\(settings.selectedProtocol.displayName) · Not configured"
         case .video:
-            return "\(settings.videoQuality)p · \(bitrateLabel(settings.videoBitrate)) · \(settings.frameRate) fps"
+            // Show the EFFECTIVE (device-capped) values, matching the Quality and
+            // Frame Rate pickers — so the collapsed row never over-promises a
+            // resolution/fps the device won't actually stream (e.g. a settings blob
+            // restored from a more capable phone).
+            let quality = min(settings.videoQuality, capability.maxShortEdge)
+            let fps = min(settings.frameRate, capability.maxFrameRate)
+            return "\(quality)p · \(bitrateLabel(settings.videoBitrate)) · \(fps) fps"
         case .backup:
             return "Off"
         case .audio:

StreamCoreTests/StreamSettingsTests.swift

@@ -75,6 +75,22 @@ import StreamCore
         #expect(size.height == 1280)
     }
 
+    @Test("Zero-dimension fallback honors a 1080 ceiling (true 1080×1920 canvas)")
+    func zeroFallbackAt1080Ceiling() {
+        let size = settings(videoQuality: 1080).encodeSize(forOrientedWidth: 0, height: 0, maxShortEdge: 1080)
+        #expect(size.width == 1080)
+        #expect(size.height == 1920)
+    }
+
+    @Test("Zero-dimension fallback still clamps to the device ceiling")
+    func zeroFallbackClampsToCeiling() {
+        // A 1080p pick on a 720-ceiling device must fall back to 720×1280, proving
+        // the ceiling clamps the fallback branch too (not just the scaled path).
+        let size = settings(videoQuality: 1080).encodeSize(forOrientedWidth: 0, height: 0, maxShortEdge: 720)
+        #expect(size.width == 720)
+        #expect(size.height == 1280)
+    }
+
     @Test("Aspect ratio is preserved within a pixel of rounding")
     func preservesAspectRatio() {
         let size = settings().encodeSize(forOrientedWidth: 1170, height: 2532, maxShortEdge: 1080)
@@ -153,6 +169,14 @@ import StreamCore
         #expect(cap.maxFrameRate == 30)
     }
 
+    @Test("The core-count boundary sits exactly at 6 (5 cores + ample RAM → 30 fps)")
+    func coreCountBoundaryPinnedAtSix() {
+        // Pins the >= 6 gate to the exact edge so a regression to >= 5 is caught.
+        let cap = StreamCapability.device(processorCount: 5, physicalMemory: 8_000_000_000)
+        #expect(cap.maxShortEdge == 1080)
+        #expect(cap.maxFrameRate == 30)
+    }
+
     @Test("Memory-tier boundaries map to the intended profile")
     func memoryBoundaries() {
         // Exactly at the high floor → 1080p60.