port: test backdrop coverage per instant -- scale animates, and the disc proves it

The Decoder found forced_backdrop judged coverage from declared size alone.
pbafc.prm declares 844x600 at alpha ff and draws ~17x18 px at 2%x3% scale --
a rule reading declared size would call it screen-covering.

scale_at interpolates on the same ramp as the fade, and coverage is folded into
the opaque-instant test: an instant counts only where the element is BOTH alpha
255 and covering. The previous code tested the two halves at different times.
The size prefilter deliberately no longer rejects, since an element scaled above
100 could cover from a smaller declared size.

No verdict moves: 6 forced before and after, 16 screens validate, oracle figures
identical to the digit. Nothing in GP_TITLE has a non-100 scale on any keyframe.
It is in because the data that would break it exists, not because it failed.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01N7FiFFFwbvG2uxdcEh8HyF

crates/sylpheed-export/src/screen.rs

@@ -684,6 +684,35 @@ fn alpha_at(e: &Element, t: i64) -> u8 {
     a(timed[timed.len() - 1]) as u8
 }
 
+/// Scale of one element at instant `t`, in percent per axis, under the same
+/// linear ramp as the fade. Interpolated rather than stepped, because a scale
+/// that animates passes through every value between its keyframes.
+fn scale_at(e: &Element, t: i64) -> [f64; 2] {
+    let timed: Vec<&Keyframe> = e.keyframes.iter().filter(|k| k.t.is_some()).collect();
+    if timed.is_empty() {
+        return [100.0, 100.0];
+    }
+    let g = |k: &Keyframe, i: usize| k.scale[i] as f64;
+    if t <= timed[0].t.unwrap() as i64 {
+        return [g(timed[0], 0), g(timed[0], 1)];
+    }
+    for w in timed.windows(2) {
+        let (t0, t1) = (w[0].t.unwrap() as i64, w[1].t.unwrap() as i64);
+        if t < t1 {
+            if t1 <= t0 {
+                return [g(w[0], 0), g(w[0], 1)];
+            }
+            let f = (t - t0) as f64 / (t1 - t0) as f64;
+            return [
+                g(w[0], 0) + (g(w[1], 0) - g(w[0], 0)) * f,
+                g(w[0], 1) + (g(w[1], 1) - g(w[0], 1)) * f,
+            ];
+        }
+    }
+    let l = timed[timed.len() - 1];
+    [g(l, 0), g(l, 1)]
+}
+
 /// Move a full-screen opaque primitive to the FRONT of the paint order when the
 /// file forces it there.
 ///
@@ -754,9 +783,11 @@ fn forced_backdrop_first(order: Vec<usize>, elements: &[Element], design: [u32;
             // full-screen element here is `.prm` and pure black, checked -- so
             // this changes no verdict today and is a guard against a corpus
             // that grows.
-            e.role == "primitive"
-                && e.sprite.is_none()
-                && e.size.is_some_and(|s| s[0] as u32 >= design[0] && s[1] as u32 >= design[1])
+            // Cheap prefilter only -- the binding coverage test is per-instant,
+            // in `covers` below. An element scaled ABOVE 100 could cover the
+            // screen from a smaller declared size, so this deliberately does
+            // not reject on size.
+            e.role == "primitive" && e.sprite.is_none() && e.size.is_some()
         })
         .filter(|(i, e)| {
             let span: Vec<i64> = e
@@ -766,6 +797,24 @@ fn forced_backdrop_first(order: Vec<usize>, elements: &[Element], design: [u32;
                 .map(i64::from)
                 .collect();
             let Some(&lo) = span.first() else { return false };
+            // 🔴 COVERAGE IS TESTED AT EACH INSTANT, NOT ONCE FROM `size`.
+            // Declared size alone is not what the element draws: scale is a
+            // percent per axis and it animates. `pbafc.prm` is the disc's own
+            // counterexample -- declared 844x600, scaled 2 % x 3 %, so it draws
+            // about 17x18 px, a moving glint rather than a wash. A rule that
+            // read its declared size would call it screen-covering.
+            //
+            // Nothing in GP_TITLE needs this: every layerless full-screen
+            // element here is at scale 100 on every keyframe, so no verdict
+            // moves. It is in because the data that would break it exists on
+            // this disc, which is a better reason than a failure would have been.
+            let covers = |t: i64| {
+                let sc = scale_at(e, t);
+                e.size.is_some_and(|s| {
+                    s[0] as f64 * sc[0] / 100.0 >= design[0] as f64
+                        && s[1] as f64 * sc[1] / 100.0 >= design[1] as f64
+                })
+            };
             // An element HOLDS ITS FINAL POSE to the end of the screen -- it does
             // not vanish at its own last keyframe. `palogo_eff0.prm` is the case
             // that shows why: it declares ONE keyframe, opaque black full-screen
@@ -773,7 +822,9 @@ fn forced_backdrop_first(order: Vec<usize>, elements: &[Element], design: [u32;
             // a single-instant event instead of the thing that is on screen for
             // the whole splash. So the span runs to the SCREEN's last keyframe.
             let hi = screen_end.max(*span.last().unwrap());
-            let opaque: Vec<i64> = (lo..=hi).filter(|&t| alpha_at(e, t) == 255).collect();
+            let opaque: Vec<i64> = (lo..=hi)
+                .filter(|&t| alpha_at(e, t) == 255 && covers(t))
+                .collect();
             if opaque.is_empty() {
                 return false;
             }