port: pose a settled screen at ONE instant -- title 1.81% -> 0.26%, splashes to 0.01%

The Decoder's finding, applied. `rest()` returns each element's last hold
keyframe chosen independently of every other element: right for anything that
ends the screen settled, exactly wrong for a transient. The title's
ptlogo_back2eff1 is a two-frame flash (0 until t52, 255 at t54-56, 0 by t58), so
its last hold IS the flash peak and rest() left it burning -- five of them, drawn
at once.

The settled instant is the longest interval containing no keyframe time, over a
bundle's TOP-LEVEL elements. Reproduced here before adopting: title [160, 236],
midpoint 198, the Decoder's number to the unit. The top-level restriction is what
makes it match -- including the ptloop leaves gives [269, 540].

AGAINST THE ORACLE:

  title            20.92 RMSE  1.81%  ->  14.61 RMSE  0.26%
  publisher_logo    9.05       0.75%  ->   2.17       0.01%
  developer_logos   8.86       0.33%  ->   3.05       0.01%
  main_menu                    0.08%  ->              0.08%   window too narrow
  extras                       0.19%  ->              0.19%   window too narrow

Seven times fewer differing pixels on the title, seventy-five times fewer on the
publisher splash, whose differing region is now a 13x18 box. The largest
correctness gain this port has had, and none of it is mine -- it is a decode
computed from the keyframe table with no reference to any capture.

APPLIED ONLY WHERE THE WINDOW IS WIDE, and the bar is not invented. This export's
widths split with nothing in between: 214, 190, 145, 76, then 12, 12, 8, 4. The
bar is 30 units -- the Decoder's disc-wide census puts the knee there (30% of
bundles >= 30, 42% under 10, the latter mostly loop* fragments meant to be in
motion) and this export's screens sit 4x either side with nothing between 12 and
46. Two independent populations agreeing on where to cut.

Checked unbroken: boot pacing unmoved, scripted walk runs end to end with focus
restored.

Also recorded: my "34 focus-record elements, only 2 varying" is right for
GP_TITLE and reads as a fact about the format -- disc-wide it is 210 varying, 202
with rest() at the peak, concentrated in the paks a wider port reaches next. And
their sharper framing, which I have adopted: a pulsing element has no resting
pose at all, so rest() is MALFORMED rather than mis-answered on one.

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

@@ -254,6 +254,35 @@ pub struct Screen {
     /// **Geometric, not a decoded neighbour graph** — right for a vertical menu
     /// and not to be trusted for anything else.
     pub buttons: Vec<String>,
+
+    /// The instant every element of this screen is settled at, and the width of
+    /// the interval it was taken from — `[start, end, midpoint]` in keyframe
+    /// units, absent when the screen has fewer than two keyframe times.
+    ///
+    /// 🔴 **A SETTLED SCREEN IS ONE INSTANT, AND THE DISC SAYS WHICH.** Posing
+    /// each element at its own `rest()` is right for anything that ends the
+    /// screen settled and **exactly wrong for a transient**: the title's
+    /// `ptlogo_back2eff1` is a two-frame flash — 0 until t52, 255 at t54–56, 0
+    /// again by t58 — so its last *hold* is the flash peak and `rest()` leaves
+    /// it burning forever. There are five of these, and `rest()` draws all five
+    /// at once, saturating the light arc.
+    ///
+    /// The window is the **longest interval containing no keyframe time**, over
+    /// this bundle's TOP-LEVEL elements only. Nested leaves are excluded, and
+    /// that exclusion is what reproduces the Decoder's independently computed
+    /// `[160, 236]` for the title: including the `ptloop` leaves gives
+    /// `[269, 540]` instead.
+    ///
+    /// ⚠️ **Emitted for every screen; USABLE only where it is wide.** Across this
+    /// export the widths split with nothing in between — `press_start` 214,
+    /// `publisher_logo` 190, `developer_logos` 145, `title` 76, then
+    /// `main_menu` 12, `extras` 12, the loading screens 8 and 4. A 12-unit
+    /// "settle" on a menu that builds in until t=70 is not a settled pose, it is
+    /// a gap between staggered ramps. The Decoder's disc-wide census agrees on
+    /// the shape: only 30 % of bundles have a window ≥ 30 units and 42 % have
+    /// one under 10, the latter mostly `loop*` fragments meant to be in motion.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub settle_window: Option<[i64; 3]>,
     /// What this file does not answer. A consumer needing one of these must get
     /// it from `authored/`.
     pub unresolved: Vec<&'static str>,
@@ -553,6 +582,7 @@ pub fn export_build(
         .collect();
     buttons.sort_by(|a, b| a.0.cmp(&b.0).then_with(|| a.1.cmp(&b.1)));
 
+    let window = settle_window(&elements);
     let screen = Screen {
         format: "sylpheed.screen/3",
         exporter: exporter.to_string(),
@@ -569,6 +599,7 @@ pub fn export_build(
         elements,
         paint_order: ui_layout::derived_paint_order(&b, bundle),
         buttons: buttons.into_iter().map(|(_, n)| n).collect(),
+        settle_window: window,
         unresolved: vec![
             // The time unit is measured off the running game, not on the disc.
             "keyframe_time_unit",
@@ -599,3 +630,25 @@ pub fn export_build(
         missing,
     })
 }
+
+
+/// The longest interval containing no keyframe time, over TOP-LEVEL elements.
+///
+/// See [`Screen::settle_window`] for why this is the settled instant and why
+/// nested leaves are excluded. Returns `[start, end, midpoint]`.
+fn settle_window(elements: &[Element]) -> Option<[i64; 3]> {
+    let mut times: Vec<i64> = elements
+        .iter()
+        .flat_map(|e| e.keyframes.iter().filter_map(|k| k.t.map(i64::from)))
+        .collect();
+    times.sort_unstable();
+    times.dedup();
+    if times.len() < 2 {
+        return None;
+    }
+    let (a, b) = times
+        .windows(2)
+        .map(|w| (w[0], w[1]))
+        .max_by_key(|(a, b)| b - a)?;
+    Some([a, b, (a + b) / 2])
+}