fix(cli): repaint the progress line through stalled reads (#366)

* fix(cli): repaint the progress line through stalled reads

The styled progress line was driven only by scan events, so a read that
did not return froze it: a 40 s stall showed the pre-scan text and the
first redraw after it already read `Elapsed: 00:00:40`. A ticker thread
now repaints the retained event about once a second while the scan
thread is blocked, and five seconds of silence swaps the lead-in to
`Still reading`, the wording the desktop shell uses for the same state.
The plain (piped stderr) path is unchanged.

The short-stream notice sentence moves to `ShortStreamFile::notice`, the
one home the CLI, the desktop shell and the browser mirror now delegate
to; the wording is pinned there, and each surface asserts only that it
delegates.

* test(cli): keep the notice out of the assert message

* perf(cli): end the stall ticker on demand and skip it on a plain line

* refactor(cli): make the stall ticker a type instead of a generic wrapper

* test(cli): pin the tick interval, the ticker's stop, and drop a redundant guard

Author: agentjp

crates/bdinfo-rs-core/src/bdrom/shortfall.rs

@@ -84,6 +84,26 @@ impl ShortStreamFile {
     pub const fn missing_seconds(&self) -> f64 {
         self.declared_seconds - self.measured_seconds
     }
+
+    /// The one-line notice a surface raises for this file, beside the report:
+    /// `00011.M2TS is shorter than declared: measured 500.0 s of 1640.0 s
+    /// (1140.0 s missing)`.
+    ///
+    /// The single home of that sentence — the CLI prints it on stderr, the
+    /// desktop shell banners it and the browser mirror crosses it as a wire
+    /// string, all through this method, so the three surfaces cannot word it
+    /// differently. Seconds to one decimal, like every other span the surfaces
+    /// show a human.
+    #[must_use]
+    pub fn notice(&self) -> String {
+        format!(
+            "{} is shorter than declared: measured {:.1} s of {:.1} s ({:.1} s missing)",
+            self.file(),
+            self.measured_seconds(),
+            self.declared_seconds(),
+            self.missing_seconds()
+        )
+    }
 }
 
 /// Every stream file in `playlists` whose demuxed span fell materially short of
@@ -277,6 +297,21 @@ mod tests {
         assert_eq!(names, vec!["00011.M2TS".to_owned(), "00033.M2TS".to_owned()]);
     }
 
+    #[test]
+    fn the_notice_spells_the_sentence_every_surface_raises() {
+        // The authoritative byte pin of the shared wording: the CLI, the
+        // desktop shell and the browser mirror all render this string through
+        // `ShortStreamFile::notice`, and each asserts only that it delegates
+        // here — this test is where the bytes are decided.
+        let short: Vec<ShortStreamFile> =
+            short_stream_files(&disc_of(vec![measured_clip("00011.M2TS", 1640.0, 500.0)]));
+        let first = short.first().expect("the short file is reported");
+        assert_eq!(
+            first.notice(),
+            "00011.M2TS is shorter than declared: measured 500.0 s of 1640.0 s (1140.0 s missing)"
+        );
+    }
+
     #[test]
     fn the_missing_span_is_the_difference_of_the_two() {
         let short: Vec<ShortStreamFile> =

crates/bdinfo-rs-gui/src/flow.rs

@@ -348,24 +348,6 @@ pub fn scan_notice(errors: usize) -> String {
     }
 }
 
-/// The notice for one stream file the demux measured shorter than the disc
-/// declares — raised beside the report, because the locked report format has no
-/// line for it ([`bdinfo_rs_core::bdrom::shortfall`]).
-///
-/// The wording is shared with the other surfaces' copies of this format
-/// (the `bdinfo-rs` CLI's `short_stream_notice`, `bdinfo-rs-wasm`'s
-/// `mirror::short_stream_notice`); each copy is pinned by an identical test, so
-/// a change here reworks all three together or fails a sibling gate.
-fn short_stream_notice(short: &ShortStreamFile) -> String {
-    format!(
-        "{} is shorter than declared: measured {:.1} s of {:.1} s ({:.1} s missing)",
-        short.file(),
-        short.measured_seconds(),
-        short.declared_seconds(),
-        short.missing_seconds()
-    )
-}
-
 /// What a measured scan needs, read from the [`Flow`] before spawning the worker.
 ///
 /// The input to re-open, the selected playlist names (the report order), and the
@@ -929,11 +911,12 @@ impl Flow {
     ///
     /// Derived from the retained disc on every call rather than stored, so a
     /// later scan that replaces the measured playlists can never leave a stale
-    /// notice behind.
+    /// notice behind. The sentences come from [`ShortStreamFile::notice`], the
+    /// one home of that wording.
     #[must_use]
     pub fn short_stream_notices(&self) -> Vec<String> {
         self.any_listing().map_or_else(Vec::new, |listing| {
-            listing.bdrom.short_stream_files().iter().map(short_stream_notice).collect()
+            listing.bdrom.short_stream_files().iter().map(ShortStreamFile::notice).collect()
         })
     }
 
@@ -1198,7 +1181,7 @@ mod tests {
     use bdinfo_rs_core::primitives::Pid;
     use bdinfo_rs_core::stream::TsStreamType;
 
-    use super::{Flow, Stage};
+    use super::{Flow, ShortStreamFile, Stage};
     use crate::live::{LivePlaylist, LiveStream};
     use crate::model::{Sort, SortColumn, ViewSettings};
     use crate::scan::{Input, Structural};
@@ -2278,7 +2261,7 @@ mod tests {
     }
 
     #[test]
-    fn a_measured_short_stream_file_surfaces_the_notice_with_the_shared_wording() {
+    fn a_measured_short_stream_file_surfaces_cores_notice_sentence() {
         use bdinfo_rs_core::bdrom::disc::ClipStreamTally;
 
         // No disc, and an unmeasured (structural) disc: silent.
@@ -2301,12 +2284,22 @@ mod tests {
             packet_count: 8,
         }];
         let flow = flow.finished(1, "R".to_owned(), Arc::new(Vec::new()), measured);
-        // The exact sentence, pinned: the CLI and wasm crates carry the same
-        // format and pin the same bytes, which is what keeps the three
-        // surfaces' wording identical.
-        assert_eq!(
-            flow.short_stream_notices(),
-            ["A.M2TS is shorter than declared: measured 500.0 s of 1640.0 s (1140.0 s missing)"]
+        // Delegation, not a second pin: the shell shows exactly what
+        // `ShortStreamFile::notice` says — the bytes themselves are pinned in
+        // core, once, so this sentence cannot fork per surface.
+        let notices = flow.short_stream_notices();
+        let from_core: Vec<String> = flow
+            .any_listing()
+            .expect("the measured listing")
+            .bdrom
+            .short_stream_files()
+            .iter()
+            .map(ShortStreamFile::notice)
+            .collect();
+        assert_eq!(notices, from_core);
+        assert!(
+            notices.first().is_some_and(|notice| notice.starts_with("A.M2TS is shorter")),
+            "the notice names the truncated file: {notices:?}"
         );
     }
 

crates/bdinfo-rs-wasm/src/mirror.rs

@@ -775,29 +775,15 @@ impl Disc {
     }
 }
 
-/// The notice for one stream file the demux measured shorter than the disc
-/// declares — raised beside the report, because the locked report format has no
-/// line for it ([`bdinfo_rs_core::bdrom::shortfall`]).
-///
-/// The wording is shared with the other surfaces' copies of this format
-/// (the `bdinfo-rs` CLI's `short_stream_notice`, `bdinfo-rs-gui`'s
-/// `flow::short_stream_notice`); each copy is pinned by an identical test, so
-/// a change here reworks all three together or fails a sibling gate.
-fn short_stream_notice(short: &ShortStreamFile) -> String {
-    format!(
-        "{} is shorter than declared: measured {:.1} s of {:.1} s ({:.1} s missing)",
-        short.file(),
-        short.measured_seconds(),
-        short.declared_seconds(),
-        short.missing_seconds()
-    )
-}
-
 /// [`Disc::short_stream_notices`] for a scanned disc: the notice sentences, or
 /// `None` when no stream file is short — the field's "nothing to say" spelling,
 /// so a healthy disc's wire form carries no empty list.
+///
+/// The sentences come from [`ShortStreamFile::notice`], the one home of that
+/// wording; the mirror only decides whether there are any.
 fn short_stream_notices(bdrom: &BdRom) -> Option<Vec<String>> {
-    let notices: Vec<String> = bdrom.short_stream_files().iter().map(short_stream_notice).collect();
+    let notices: Vec<String> =
+        bdrom.short_stream_files().iter().map(ShortStreamFile::notice).collect();
     (!notices.is_empty()).then_some(notices)
 }
 
@@ -1264,8 +1250,8 @@ mod tests {
 
     use super::{
         Chapter, Clip, ClipStream, Disc, HiddenRule, MeasuredSnapshot, Playlist, ScanError,
-        ScanErrorReason, ScanOptions, ScanStage, Stream, borrowed_codec_alt_name, core_measured,
-        order,
+        ScanErrorReason, ScanOptions, ScanStage, ShortStreamFile, Stream, borrowed_codec_alt_name,
+        core_measured, order,
     };
 
     // One fixture value and one hand-written wire form per mirror type, composed
@@ -1619,7 +1605,7 @@ mod tests {
     }
 
     #[test]
-    fn a_short_stream_file_crosses_as_the_shared_notice_wording() {
+    fn a_short_stream_file_crosses_as_cores_notice_sentence() {
         // A clip demuxed to 500 of its declared 1640 seconds, carrying the
         // per-stream tally that marks its file as measured.
         let clip = ClipSummary {
@@ -1632,28 +1618,21 @@ mod tests {
             ..a_core_bdrom()
         };
         let disc = Disc::from_scan(&bdrom, &[], true, &PlaylistFilter::default(), None);
-        // The exact sentence, pinned: the CLI and GUI crates carry the same
-        // format and pin the same bytes, which is what keeps the three
-        // surfaces' wording identical.
-        assert_eq!(
-            disc.short_stream_notices.as_deref(),
-            Some(
-                &["00011.M2TS is shorter than declared: measured 500.0 s of 1640.0 s (1140.0 s \
-                   missing)"
-                    .to_owned()][..]
-            )
+        // Delegation, not a second pin: the mirror carries exactly what
+        // `ShortStreamFile::notice` says — the bytes themselves are pinned in
+        // core, once, so this sentence cannot fork per surface.
+        let from_core: Vec<String> =
+            bdrom.short_stream_files().iter().map(ShortStreamFile::notice).collect();
+        assert_eq!(disc.short_stream_notices.as_deref(), Some(&from_core[..]));
+        assert!(
+            from_core.first().is_some_and(|notice| notice.starts_with("00011.M2TS is shorter")),
+            "the notice names the truncated file: {from_core:?}"
         );
 
         // The wire carries the sentences as a plain array, and they survive
         // the round trip.
         let wire = serde_json::to_value(&disc).expect("serialize the mirror");
-        assert_eq!(
-            wire.get("shortStreamNotices"),
-            Some(&json!([
-                "00011.M2TS is shorter than declared: measured 500.0 s of 1640.0 s (1140.0 s \
-                 missing)"
-            ]))
-        );
+        assert_eq!(wire.get("shortStreamNotices"), Some(&json!(from_core)));
         let back: Disc = serde_json::from_value(wire).expect("deserialize the mirror");
         assert_eq!(back, disc);