Address secondary Deno, remux, and release metadata notes (#537)

* Address secondary Deno, remux, and release metadata notes

* Fix formatting and preserve packaging script modes

* Update live remux argv test for full stream mapping

Author: Linuxuser67

build-aux/check-bundle-contents.py

@@ -56,7 +56,11 @@ def fail(msg: str) -> Mismatch:
 def version_key(version: str) -> tuple:
     # AppStream ordering: '~' sorts before everything, so 5.6.7~beta.3 < 5.6.7.
     # Normalize Cargo's '-' prerelease separator to AppStream's '~'.
-    version = version.replace("-beta.", "~beta.").replace("-alpha.", "~alpha.")
+    version = (
+        version.replace("-beta.", "~beta.")
+        .replace("-alpha.", "~alpha.")
+        .replace("-rc.", "~rc.")
+    )
     if "~" in version:
         core, pre = version.split("~", 1)
         core_tuple = tuple(int(p) if p.isdigit() else 0 for p in core.split("."))

build-aux/check-release-consistency.py

@@ -79,7 +79,11 @@ def metainfo_release_versions() -> list[str]:
 def version_key(version: str):
     # AppStream ordering: '~' sorts before everything, so 5.6.7~beta.3 < 5.6.7.
     # Normalize Cargo's '-' prerelease separator to AppStream's '~'.
-    version = version.replace("-beta.", "~beta.").replace("-alpha.", "~alpha.")
+    version = (
+        version.replace("-beta.", "~beta.")
+        .replace("-alpha.", "~alpha.")
+        .replace("-rc.", "~rc.")
+    )
     if "~" in version:
         core, pre = version.split("~", 1)
         core_tuple = tuple(int(p) if p.isdigit() else 0 for p in core.split("."))

src/application.rs

@@ -30,6 +30,7 @@ fn appstream_release_version(version: &str) -> String {
     version
         .replace("-beta.", "~beta.")
         .replace("-alpha.", "~alpha.")
+        .replace("-rc.", "~rc.")
 }
 
 /// True for an http(s) URL pointing at a .torrent file (case-insensitive).
@@ -1573,6 +1574,7 @@ mod tests {
     fn appstream_release_version_uses_tilde_for_prereleases_only() {
         assert_eq!(appstream_release_version("6.3.0-beta.1"), "6.3.0~beta.1");
         assert_eq!(appstream_release_version("6.3.0-alpha.2"), "6.3.0~alpha.2");
+        assert_eq!(appstream_release_version("6.3.0-rc.3"), "6.3.0~rc.3");
         assert_eq!(appstream_release_version("6.2.2"), "6.2.2");
     }
 

src/gallery_tools.rs

@@ -87,11 +87,11 @@ pub fn managed_gallerydl_sha() -> Option<Option<String>> {
     Some(sha256_file(&path).ok())
 }
 
-/// Whether Grab's own gallery-dl differs from the latest upstream build. It
-/// compares the installed file's SHA-256 with the upstream asset digest, the
-/// same value the installer verifies, so the answer follows the binary on
-/// disk. A binary Grab does not manage, or a missing upstream digest, never
-/// prompts.
+/// Whether Grab's own gallery-dl differs from the latest stable Codeberg build.
+/// The managed channel is intentionally stable even if a prior build installed a
+/// newer nightly: a hash mismatch offers the user an explicit stable-channel
+/// replacement from Preferences. A binary Grab does not manage, or a missing
+/// upstream digest, never prompts.
 pub fn gallerydl_needs_update(managed: Option<Option<&str>>, latest_digest: Option<&str>) -> bool {
     match (managed, latest_digest) {
         (Some(Some(installed)), Some(latest)) => !installed.eq_ignore_ascii_case(latest),
@@ -105,7 +105,9 @@ pub fn gallerydl_needs_update(managed: Option<Option<&str>>, latest_digest: Opti
 /// Any API failure, draft/prerelease, unexpected asset URL, or missing checksum
 /// makes the release unavailable rather than weakening verification.
 fn valid_release_tag(tag: &str) -> bool {
-    !tag.is_empty()
+    tag.as_bytes()
+        .first()
+        .is_some_and(|b| b.is_ascii_alphanumeric())
         && tag.bytes().all(|b| {
             matches!(
                 b,
@@ -357,6 +359,9 @@ mod tests {
             .is_none()
         );
         assert!(codeberg_asset_url("v1.32.17/../../evil", LINUX_ASSET).is_none());
+        assert!(codeberg_asset_url(".", LINUX_ASSET).is_none());
+        assert!(codeberg_asset_url("..", LINUX_ASSET).is_none());
+        assert!(codeberg_asset_url(".hidden", LINUX_ASSET).is_none());
     }
 
     #[test]

src/video_argv.rs

@@ -388,15 +388,18 @@ pub(crate) fn live_remux_argv(
     argv.extend(["-i".to_string(), ts_path.to_string_lossy().into_owned()]);
     if audio_only {
         argv.extend(["-map".to_string(), "0:a?".to_string()]);
-    } else {
-        // A live HLS capture may expose subtitle/data tracks that MP4 cannot
-        // mux. Only carry its actual media streams into the finished file.
+    } else if repair_timestamps {
+        // The repair pass narrows mapping to A/V streams in case subtitle/data
+        // tracks are part of the muxer failure.
         argv.extend([
             "-map".to_string(),
             "0:v?".to_string(),
             "-map".to_string(),
             "0:a?".to_string(),
         ]);
+    } else {
+        // Preserve the normal remux's full-stream behavior, including subtitles.
+        argv.extend(["-map".to_string(), "0".to_string()]);
     }
     argv.extend([
         "-dn".to_string(),
@@ -621,7 +624,7 @@ mod live_remux_argv_tests {
     use std::path::Path;
 
     #[test]
-    fn live_video_remux_maps_only_video_and_audio_streams() {
+    fn normal_live_video_remux_preserves_all_input_streams() {
         let args = live_remux_argv(
             Path::new("capture.mp4"),
             Path::new("finished.mp4.part"),
@@ -630,6 +633,24 @@ mod live_remux_argv_tests {
             false,
             "https://example.com/live",
         );
+        let maps: Vec<&str> = args
+            .windows(2)
+            .filter(|pair| pair[0] == "-map")
+            .map(|pair| pair[1].as_str())
+            .collect();
+        assert_eq!(maps, vec!["0"]);
+    }
+
+    #[test]
+    fn timestamp_repair_remux_narrows_mapping_to_audio_and_video() {
+        let args = live_remux_argv(
+            Path::new("capture.ts"),
+            Path::new("finished.mp4.part"),
+            false,
+            true,
+            true,
+            "https://example.com/live",
+        );
         let maps: Vec<&str> = args
             .windows(2)
             .filter(|pair| pair[0] == "-map")

src/video_runner.rs

@@ -935,6 +935,23 @@ fn needs_live_timestamp_repair(log: &str) -> bool {
     .any(|needle| log.contains(needle))
 }
 
+/// Return the next (AAC bitstream filter, timestamp repair) configuration.
+/// Timestamp repair gets one priority retry; otherwise the AAC filter is
+/// dropped once. Pure logic so retry ordering can be regression-tested.
+fn next_live_remux_attempt(
+    with_bsf: bool,
+    repair_timestamps: bool,
+    log_tail: &str,
+) -> Option<(bool, bool)> {
+    if !repair_timestamps && needs_live_timestamp_repair(log_tail) {
+        Some((true, true))
+    } else if with_bsf {
+        Some((false, repair_timestamps))
+    } else {
+        None
+    }
+}
+
 /// Remux a stopped live capture into place. ffmpeg writes `<dest>.part` and the result is renamed to `dest` only on success: a bare `final.<n>.<ext>` is always worth keeping, a `.part` never is.
 pub(crate) async fn remux_live_capture(
     ffmpeg_bin: &Path,
@@ -1016,29 +1033,28 @@ pub(crate) async fn remux_live_capture(
             };
         }
         let detail = last_log_line(&log_tail, "ffmpeg reported failure");
-        if !repair_timestamps && needs_live_timestamp_repair(&log_tail) {
+        let Some((next_with_bsf, next_repair_timestamps)) =
+            next_live_remux_attempt(with_bsf, repair_timestamps, &log_tail)
+        else {
+            let _ = tokio::fs::remove_file(&partial).await;
+            break Err(VideoError::combine(detail));
+        };
+        if !repair_timestamps && next_repair_timestamps {
             tracing::warn!(
                 error = %detail,
                 "live remux retrying with timestamp recovery"
             );
-            // FFmpeg failed on an input timestamp pattern that can be repaired.
-            // Start with the AAC fixup enabled; if that still fails, the loop
-            // will also test the repaired path without the bitstream filter.
-            let _ = tokio::fs::remove_file(&partial).await;
-            repair_timestamps = true;
-            with_bsf = true;
-            continue;
-        }
-        if with_bsf {
-            tracing::debug!(error = %detail, "live remux without bsf, retrying bare");
-            // The failed attempt may have left a partial output. The retry must
-            // start clean; the partial is ours because this loop reserved its slot.
-            let _ = tokio::fs::remove_file(&partial).await;
-            with_bsf = false;
-            continue;
+            // Keep the AAC fixup for the first repair attempt; the helper drops
+            // it if the repaired attempt also fails.
+        } else {
+            tracing::debug!(error = %detail, "live remux retrying with adjusted flags");
         }
+        // The failed attempt may have left a partial output. The retry must
+        // start clean; the partial is ours because this loop reserved its slot.
         let _ = tokio::fs::remove_file(&partial).await;
-        break Err(VideoError::combine(detail));
+        with_bsf = next_with_bsf;
+        repair_timestamps = next_repair_timestamps;
+        continue;
     }
 }
 

src/video_runner_tests.rs

@@ -6,6 +6,34 @@ use super::*;
 
 use crate::video_argv::VideoJob;
 
+#[test]
+fn live_remux_retry_policy_repairs_timestamps_before_dropping_aac_filter() {
+    assert_eq!(
+        next_live_remux_attempt(true, false, "non-monotonous DTS in output"),
+        Some((true, true))
+    );
+    assert_eq!(
+        next_live_remux_attempt(true, true, "non-monotonous DTS in output"),
+        Some((false, true))
+    );
+    assert_eq!(
+        next_live_remux_attempt(false, true, "generic failure"),
+        None
+    );
+}
+
+#[test]
+fn live_remux_retry_policy_drops_aac_filter_once_for_other_errors() {
+    assert_eq!(
+        next_live_remux_attempt(true, false, "disk I/O error"),
+        Some((false, false))
+    );
+    assert_eq!(
+        next_live_remux_attempt(false, false, "disk I/O error"),
+        None
+    );
+}
+
 /// `Exit::RenameFailed` keeps the user's only copy: nothing re-records, nothing is
 /// swept except `.ytdl` state. Also pins the non-recursive staging sweep, which is
 /// what keeps an earlier attempt's unplaceable remux durable.

src/video_tests.rs

@@ -3798,7 +3798,7 @@ fn live_argv_pins_planner_id_in_mpegts() {
 
 #[test]
 fn live_remux_argv_copies_with_fixup_and_carries_provenance() {
-    // Map media streams only, stream-copy, ADTS fixup, faststart.
+    // Preserve normal input stream mapping, stream-copy, ADTS fixup, faststart.
     // Dests are the `.part` remux targets production passes: ffmpeg can't guess a
     // container from that name, so `-f` must be pinned from the real extension.
     let argv = live_remux_argv(
@@ -3809,8 +3809,9 @@ fn live_remux_argv_copies_with_fixup_and_carries_provenance() {
         false,
         "https://x.com/watch?v=abc123",
     );
-    assert!(argv.windows(2).any(|w| w == ["-map", "0:v?"]));
-    assert!(argv.windows(2).any(|w| w == ["-map", "0:a?"]));
+    assert!(argv.windows(2).any(|w| w == ["-map", "0"]));
+    assert!(!argv.windows(2).any(|w| w == ["-map", "0:v?"]));
+    assert!(!argv.windows(2).any(|w| w == ["-map", "0:a?"]));
     assert!(argv.windows(2).any(|w| w == ["-c", "copy"]));
     assert!(argv.windows(2).any(|w| w == ["-bsf:a", "aac_adtstoasc"]));
     assert!(argv.windows(2).any(|w| w == ["-f", "mp4"]));