fix: built-in downloader prefers separate streams over 360p muxed (v1.0.0.16)

When YouTube offered a muxed stream, it was always taken, but muxed streams
are 360p only. Use muxed only when the separate video+audio streams are
missing or not better.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Jellyfin.Plugin.CinemaTrailers4Jellyfins/Configuration/config.html

@@ -45,7 +45,9 @@
                     <fieldset class="verticalSection verticalSection-extrabottompadding">
                         <legend><h3 class="sectionTitle">Trailer Languages</h3></legend>
                         <p class="fieldDescription">
-                            Only download trailers in the selected languages.
+                            Only download trailers in the selected languages. Both the trailer and the
+                            movie/show itself (its original language) must be in one of them, so a
+                            subtitled foreign trailer is skipped.
                             Leave everything unchecked to allow all languages.
                         </p>
                         <div style="display:grid;grid-template-columns:1fr 1fr;gap:0 2em;">

Jellyfin.Plugin.CinemaTrailers4Jellyfins/Jellyfin.Plugin.CinemaTrailers4Jellyfins.csproj

@@ -3,8 +3,8 @@
   <PropertyGroup>
     <TargetFramework>net9.0</TargetFramework>
     <RootNamespace>Jellyfin.Plugin.CinemaTrailers4Jellyfins</RootNamespace>
-    <AssemblyVersion>1.0.0.11</AssemblyVersion>
-    <FileVersion>1.0.0.11</FileVersion>
+    <AssemblyVersion>1.0.0.16</AssemblyVersion>
+    <FileVersion>1.0.0.16</FileVersion>
     <Nullable>enable</Nullable>
     <GenerateDocumentationFile>false</GenerateDocumentationFile>
     <TreatWarningsAsErrors>false</TreatWarningsAsErrors>

Jellyfin.Plugin.CinemaTrailers4Jellyfins/ScheduledTasks/DownloadTrailersTask.cs

@@ -177,6 +177,14 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.ScheduledTasks
                     continue;
                 }
 
+                // A trailer's own language tag is often "en" just because it has English
+                // subtitles, so also require the title itself to be in an allowed language.
+                if (allowedLanguages != null && !allowedLanguages.Contains(movie.OriginalLanguage))
+                {
+                    _logger.LogDebug("|CinemaTrailers4Jellyfins| Skipping '{Title}': original language '{Lang}' is not allowed", movie.Title, movie.OriginalLanguage);
+                    continue;
+                }
+
                 var trailers = await _tmdbService.GetTrailersAsync(
                     "movie", movie.Id.ToString(), config.TmdbApiKey, allowedLanguages, cancellationToken).ConfigureAwait(false);
 
@@ -217,7 +225,8 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.ScheduledTasks
                 var metadata = await _tmdbService.GetMediaMetadataAsync(
                     "movie", movie.Id.ToString(), config.TmdbApiKey, cancellationToken).ConfigureAwait(false);
 
-                _fakeMovieService.WriteNfo(paths.NfoPath, movie.Title, movie.Year, metadata.Genres, metadata.Certification);
+                _fakeMovieService.WriteNfo(paths.NfoPath, movie.Title, movie.Year, metadata.Genres, metadata.Certification,
+                    metadata.IsAnime ? new[] { TrailerTags.Anime } : null);
 
                 downloaded++;
                 _logger.LogInformation(
@@ -283,6 +292,14 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.ScheduledTasks
                     continue;
                 }
 
+                // A trailer's own language tag is often "en" just because it has English
+                // subtitles, so also require the title itself to be in an allowed language.
+                if (allowedLanguages != null && !allowedLanguages.Contains(show.OriginalLanguage))
+                {
+                    _logger.LogDebug("|CinemaTrailers4Jellyfins| Skipping '{Title}': original language '{Lang}' is not allowed", show.Title, show.OriginalLanguage);
+                    continue;
+                }
+
                 var trailers = await _tmdbService.GetTrailersAsync(
                     "tv", show.Id.ToString(), config.TmdbApiKey, allowedLanguages, cancellationToken).ConfigureAwait(false);
 
@@ -323,7 +340,8 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.ScheduledTasks
                 var metadata = await _tmdbService.GetMediaMetadataAsync(
                     "tv", show.Id.ToString(), config.TmdbApiKey, cancellationToken).ConfigureAwait(false);
 
-                _fakeMovieService.WriteNfo(paths.NfoPath, show.Title, show.Year, metadata.Genres, metadata.Certification, new[] { TrailerTags.TvShow });
+                _fakeMovieService.WriteNfo(paths.NfoPath, show.Title, show.Year, metadata.Genres, metadata.Certification,
+                    metadata.IsAnime ? new[] { TrailerTags.TvShow, TrailerTags.Anime } : new[] { TrailerTags.TvShow });
 
                 downloaded++;
                 _logger.LogInformation(

Jellyfin.Plugin.CinemaTrailers4Jellyfins/Services/TmdbService.cs

@@ -14,12 +14,12 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
 {
     public record TmdbVideo(string Key, string Name, string Language, bool Official, int Size);
 
-    public record TmdbMediaResult(int Id, string Title, string ReleaseDate)
+    public record TmdbMediaResult(int Id, string Title, string ReleaseDate, string OriginalLanguage)
     {
         public int? Year => DateTime.TryParse(ReleaseDate, out var d) ? d.Year : (int?)null;
     }
 
-    public record TmdbMediaMetadata(IReadOnlyList<string> Genres, string? Certification);
+    public record TmdbMediaMetadata(IReadOnlyList<string> Genres, string? Certification, bool IsAnime);
 
     public class TmdbService : IDisposable
     {
@@ -170,6 +170,7 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
                         var releaseDate = entry.TryGetProperty(dateField, out var rd) ? rd.GetString() ?? string.Empty : string.Empty;
                         var title = entry.TryGetProperty(titleField, out var t) ? t.GetString() ?? string.Empty : string.Empty;
                         var id = entry.GetProperty("id").GetInt32();
+                        var originalLanguage = entry.TryGetProperty("original_language", out var ol) ? ol.GetString() ?? string.Empty : string.Empty;
 
                         if (releasedAfter.HasValue && DateTime.TryParse(releaseDate, out var parsed))
                         {
@@ -177,7 +178,7 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
                         }
 
                         anyInRange = true;
-                        results.Add(new TmdbMediaResult(id, title, releaseDate));
+                        results.Add(new TmdbMediaResult(id, title, releaseDate, originalLanguage));
                     }
 
                     if (page >= totalPages || (releasedAfter.HasValue && !anyInRange))
@@ -236,7 +237,7 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
             try
             {
                 var appendField = mediaType == "movie" ? "release_dates" : "content_ratings";
-                var url = $"{BaseUrl}/{mediaType}/{tmdbId}?append_to_response={appendField}&language=en-US";
+                var url = $"{BaseUrl}/{mediaType}/{tmdbId}?append_to_response={appendField},keywords&language=en-US";
                 using var request = new HttpRequestMessage(HttpMethod.Get, url);
                 ApplyAuth(request, apiKey);
                 using var response = await _httpClient.SendAsync(request, ct).ConfigureAwait(false);
@@ -262,16 +263,40 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
                     ? GetMovieCertification(doc)
                     : GetTvCertification(doc);
 
-                return new TmdbMediaMetadata(genres.AsReadOnly(), certification);
+                return new TmdbMediaMetadata(genres.AsReadOnly(), certification, IsAnime(doc, mediaType, genres));
             }
             catch (OperationCanceledException) { throw; }
             catch (Exception ex)
             {
                 _logger.LogError(ex, "|CinemaTrailers4Jellyfins| GetMediaMetadata failed for {MediaType} TMDB ID {Id}", mediaType, tmdbId);
-                return new TmdbMediaMetadata(Array.Empty<string>(), null);
+                return new TmdbMediaMetadata(Array.Empty<string>(), null, false);
             }
         }
 
+        private static readonly string[] AnimeKeywords = { "anime", "based on manga" };
+        private static readonly string[] AnimeLanguages = { "ja", "zh", "ko" };
+
+        // Anime vs. Western animation: both carry TMDB's "Animation" genre, so use the "anime" /
+        // "based on manga" keywords, or Animation made in Japanese, Chinese or Korean.
+        private static bool IsAnime(JsonDocument doc, string mediaType, List<string> genres)
+        {
+            // Movie keywords live under keywords.keywords, TV keywords under keywords.results.
+            var listName = mediaType == "movie" ? "keywords" : "results";
+            if (doc.RootElement.TryGetProperty("keywords", out var kw)
+                && kw.TryGetProperty(listName, out var list)
+                && list.ValueKind == JsonValueKind.Array
+                && list.EnumerateArray().Any(k =>
+                    k.TryGetProperty("name", out var n)
+                    && AnimeKeywords.Contains(n.GetString(), StringComparer.OrdinalIgnoreCase)))
+            {
+                return true;
+            }
+
+            return genres.Contains("Animation", StringComparer.OrdinalIgnoreCase)
+                && doc.RootElement.TryGetProperty("original_language", out var lang)
+                && AnimeLanguages.Contains(lang.GetString(), StringComparer.OrdinalIgnoreCase);
+        }
+
         // Finds the US theatrical certification (G, PG, PG-13, R, NC-17) from release_dates.
         private static string? GetMovieCertification(JsonDocument doc)
         {

Jellyfin.Plugin.CinemaTrailers4Jellyfins/Services/TrailerDownloadService.cs

@@ -63,8 +63,10 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
 
             if (!string.IsNullOrWhiteSpace(ytDlpPath) && File.Exists(ytDlpPath))
             {
-                return await DownloadWithYtDlpAsync(youtubeKey, outputPath, preferredHeight, ytDlpPath, ct)
-                    .ConfigureAwait(false);
+                if (await DownloadWithYtDlpAsync(youtubeKey, outputPath, preferredHeight, ytDlpPath, ct).ConfigureAwait(false))
+                    return true;
+
+                _logger.LogWarning("|CinemaTrailers4Jellyfins| yt-dlp failed for {Key}; falling back to the built-in downloader.", youtubeKey);
             }
 
             return await DownloadWithYoutubeExplodeAsync(youtubeKey, outputPath, preferredHeight, ct)
@@ -88,31 +90,37 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
                     .GetManifestAsync($"https://www.youtube.com/watch?v={key}", ct)
                     .ConfigureAwait(false);
 
-                // Muxed streams include audio+video in one file. YouTube rarely serves them
-                // anymore, but use one when it exists since it needs no merge.
+                // Best video-only stream at or below the height limit. MP4 (H.264) is preferred for
+                // client compatibility; any container is the fallback.
+                var videoStreams = manifest.GetVideoOnlyStreams().ToList();
+                var audioStreams = manifest.GetAudioOnlyStreams().ToList();
+                var mp4Video = videoStreams.Where(s => s.Container == Container.Mp4).ToList();
+                var video = videoStreams.Count > 0
+                    ? PickByHeight(mp4Video.Count > 0 ? mp4Video : videoStreams, preferredHeight)
+                    : null;
+
+                // Muxed streams (audio+video in one file) need no merge, but YouTube only serves
+                // them at 360p. Use one only when the separate streams can't do better.
                 var muxedStreams = manifest.GetMuxedStreams().ToList();
                 if (muxedStreams.Count > 0)
                 {
                     var muxed = PickByHeight(muxedStreams, preferredHeight);
-                    _logger.LogInformation(
-                        "|CinemaTrailers4Jellyfins| Downloading {Key} at {Quality} (muxed) to {Path}",
-                        key, muxed.VideoQuality.Label, outputPath);
-                    await youtube.Videos.Streams.DownloadAsync(muxed, outputPath, cancellationToken: ct).ConfigureAwait(false);
-                    return true;
+                    if (video == null || audioStreams.Count == 0
+                        || muxed.VideoQuality.MaxHeight >= video.VideoQuality.MaxHeight)
+                    {
+                        _logger.LogInformation(
+                            "|CinemaTrailers4Jellyfins| Downloading {Key} at {Quality} (muxed) to {Path}",
+                            key, muxed.VideoQuality.Label, outputPath);
+                        await youtube.Videos.Streams.DownloadAsync(muxed, outputPath, cancellationToken: ct).ConfigureAwait(false);
+                        return true;
+                    }
                 }
 
-                // Otherwise download the best video-only and audio-only streams and merge them.
-                // MP4 (H.264/AAC) is preferred for client compatibility; any container is the fallback.
-                var videoStreams = manifest.GetVideoOnlyStreams().ToList();
-                var audioStreams = manifest.GetAudioOnlyStreams().ToList();
-                if (videoStreams.Count == 0 || audioStreams.Count == 0)
+                if (video == null || audioStreams.Count == 0)
                 {
                     _logger.LogWarning("|CinemaTrailers4Jellyfins| No usable video/audio streams for {Key}.", key);
                     return false;
                 }
-
-                var mp4Video = videoStreams.Where(s => s.Container == Container.Mp4).ToList();
-                var video = PickByHeight(mp4Video.Count > 0 ? mp4Video : videoStreams, preferredHeight);
                 var mp4Audio = audioStreams.Where(s => s.Container == Container.Mp4).ToList();
                 var audio = (mp4Audio.Count > 0 ? mp4Audio : audioStreams).GetWithHighestBitrate();
 
@@ -224,13 +232,16 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
         {
             try
             {
-                // Format selects the best video at or below preferredHeight merged with the best audio.
-                // --merge-output-format mp4 ensures the output is always an mp4.
+                // Format selects the best video at or below preferredHeight merged with the best audio,
+                // preferring H.264 + AAC (plays or hardware-transcodes on every client; VP9/AV1 often
+                // need a CPU transcode). --merge-output-format mp4 ensures the output is always an mp4.
                 var args = string.Join(" ",
-                    $"-f \"bestvideo[height<={preferredHeight}]+bestaudio/best[height<={preferredHeight}]\"",
+                    $"-f \"bestvideo[height<={preferredHeight}][vcodec^=avc1]+bestaudio[ext=m4a]/bestvideo[height<={preferredHeight}]+bestaudio/best[height<={preferredHeight}]\"",
                     "--merge-output-format mp4",
                     "--no-playlist",
                     "--no-warnings",
+                    "--no-progress",
+                    $"--ffmpeg-location \"{FfmpegLocator.Path}\"",
                     $"-o \"{outputPath}\"",
                     $"\"https://www.youtube.com/watch?v={key}\"");
 
@@ -252,11 +263,15 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
                 };
 
                 process.Start();
+                // Drain both pipes while yt-dlp runs so a full buffer can never block it.
+                var stdoutTask = process.StandardOutput.ReadToEndAsync(ct);
+                var stderrTask = process.StandardError.ReadToEndAsync(ct);
                 await process.WaitForExitAsync(ct).ConfigureAwait(false);
+                await stdoutTask.ConfigureAwait(false);
+                var stderr = await stderrTask.ConfigureAwait(false);
 
                 if (process.ExitCode != 0)
                 {
-                    var stderr = await process.StandardError.ReadToEndAsync(ct).ConfigureAwait(false);
                     _logger.LogError("|CinemaTrailers4Jellyfins| yt-dlp exited with code {Code} for {Key}: {Error}",
                         process.ExitCode, key, stderr);
                     return false;
@@ -273,6 +288,32 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
                 _logger.LogError(ex, "|CinemaTrailers4Jellyfins| yt-dlp download failed for {Key}", key);
                 return false;
             }
+            finally
+            {
+                DeleteYtDlpLeftovers(outputPath);
+            }
+        }
+
+        // yt-dlp names its separate/partial downloads "<output name>.f137.mp4.part", ".f140.m4a",
+        // ".ytdl", ... It removes them after a successful merge, but not when it fails. Everything
+        // sharing the output's "<name>." prefix (other than the output itself) is one of those.
+        private void DeleteYtDlpLeftovers(string outputPath)
+        {
+            var folder = Path.GetDirectoryName(outputPath);
+            if (folder == null || !Directory.Exists(folder))
+                return;
+
+            var outputName = Path.GetFileName(outputPath);
+            var prefix = Path.GetFileNameWithoutExtension(outputPath) + ".";
+            foreach (var file in Directory.EnumerateFiles(folder))
+            {
+                var name = Path.GetFileName(file);
+                if (name.StartsWith(prefix, StringComparison.Ordinal)
+                    && !string.Equals(name, outputName, StringComparison.Ordinal))
+                {
+                    TryDeleteFile(file);
+                }
+            }
         }
     }
 }

Jellyfin.Plugin.CinemaTrailers4Jellyfins/Services/TrailerIntroProvider.cs

@@ -147,12 +147,12 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
                 }
                 else
                 {
-                    // Animation is a style, not a topic: animated trailers (anime included) only play
-                    // before animated content. Applied before the fallback below, so a live-action
-                    // feature never gets one — it gets no trailer instead.
-                    var eligible = IsAnimated(feature)
+                    // Anime trailers only play before anime. Applied before the fallback below, so
+                    // non-anime content never gets one — it gets no trailer instead. Western animation
+                    // is not affected and follows the normal filters.
+                    var eligible = IsAnimeFeature(feature)
                         ? pairs
-                        : pairs.Where(p => !IsAnimated(p.Movie)).ToList();
+                        : pairs.Where(p => !IsAnimeTrailer(p.Movie)).ToList();
 
                     // Apply enabled filters. If nothing survives, fall back to the eligible pool.
                     var filtered = ApplyFilters(eligible, feature, config);
@@ -236,11 +236,19 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
             return new IntroInfo { ItemId = movie.Id, Path = movie.Path };
         }
 
-        // TMDB tags anime as "Animation"; anime metadata providers (e.g. AniDB) use "Anime".
-        private static readonly string[] AnimatedGenres = { "Animation", "Anime" };
+        // Library items: anime providers (e.g. AniDB) set the "Anime" genre; TMDB-scraped items
+        // carry TMDB keywords as tags ("anime", "based on manga"). "Animation" alone is not enough —
+        // it also covers Western animation.
+        private static readonly string[] AnimeFeatureTags = { "anime", "based on manga" };
 
-        private static bool IsAnimated(BaseItem item)
-            => item.Genres.Any(g => AnimatedGenres.Contains(g, StringComparer.OrdinalIgnoreCase));
+        private static bool IsAnimeFeature(BaseItem item)
+            => item.Genres.Contains("Anime", StringComparer.OrdinalIgnoreCase)
+               || item.Tags.Any(t => AnimeFeatureTags.Contains(t, StringComparer.OrdinalIgnoreCase));
+
+        // Trailers are tagged at download time from TMDB data (see TmdbService.IsAnime).
+        private static bool IsAnimeTrailer(BaseItem item)
+            => item.Tags.Contains(TrailerTags.Anime, StringComparer.OrdinalIgnoreCase)
+               || item.Genres.Contains("Anime", StringComparer.OrdinalIgnoreCase);
 
         private static List<(Movie Movie, BaseItem Trailer)> ApplyFilters(
             List<(Movie Movie, BaseItem Trailer)> pairs,

Jellyfin.Plugin.CinemaTrailers4Jellyfins/Services/TrailerTags.cs

@@ -2,11 +2,14 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
 {
     /// <summary>
     /// Tags written into each downloaded trailer's NFO so <see cref="TrailerIntroProvider"/>
-    /// can tell movie trailers and TV show trailers apart within the shared output folder.
+    /// can tell movie trailers, TV show trailers and anime trailers apart within the shared output folder.
     /// </summary>
     public static class TrailerTags
     {
         /// <summary>Marks a fake-movie folder as containing a TV show trailer.</summary>
         public const string TvShow = "ct4j-tvshow";
+
+        /// <summary>Marks a trailer as anime, so it only plays before anime content.</summary>
+        public const string Anime = "ct4j-anime";
     }
 }

build.yaml

@@ -1,5 +1,5 @@
 ---
-version: 1.0.0.11
+version: 1.0.0.16
 name: CinemaTrailers4Jellyfins
 guid: b581493e-1046-40ed-b6dc-cb8027624984
 description: >
@@ -12,11 +12,9 @@ category: General
 owner: 514mart
 targetAbi: 10.11.0.0
 changelog:
-  - Animated trailers (anime included) now only play before animated
-    content. Before, an anime trailer could play before a live-action
-    movie or show when they shared a genre like Drama or Action, or when
-    no trailer matched the genre filter. A live-action feature now gets no
-    trailer rather than an animated one
+  - The built-in downloader no longer picks YouTube's 360p combined file
+    when separate video and audio streams give a better picture. This
+    mostly showed up when yt-dlp failed and the built-in downloader took over
 
 dotnetProjects:
   - name: Jellyfin.Plugin.CinemaTrailers4Jellyfins

manifest.json

@@ -8,6 +8,46 @@
         "owner": "514mart",
         "imageUrl": "https://www.git.quarantinedstudio.com/mvezina/CinemaTrailers4Jellyfins/raw/branch/main/Jellyfin.Plugin.CinemaTrailers4Jellyfins/Images/logo.svg",
         "versions": [
+            {
+                "checksum": "211f58d992857f9e91263293306fbd0d",
+                "changelog": "- Trailer Languages now also checks the original language of the movie or show. Before, only the trailer's own language tag was checked, and TMDB often tags subtitled foreign trailers as English, so Korean, Chinese or Japanese trailers got through\n",
+                "targetAbi": "10.11.0.0",
+                "sourceUrl": "https://www.git.quarantinedstudio.com/mvezina/CinemaTrailers4Jellyfins/releases/download/v1.0.0.15/cinematrailers4jellyfins_1.0.0.15.zip",
+                "timestamp": "2026-10-05T22:28:03Z",
+                "version": "1.0.0.15"
+            },
+            {
+                "checksum": "10ecbc35b84e98bade61576bbfc41864",
+                "changelog": "- When yt-dlp fails part-way, its partial download files (.part, .ytdl, separate video/audio) are now deleted instead of being left in the trailer folder\n",
+                "targetAbi": "10.11.0.0",
+                "sourceUrl": "https://www.git.quarantinedstudio.com/mvezina/CinemaTrailers4Jellyfins/releases/download/v1.0.0.14/cinematrailers4jellyfins_1.0.0.14.zip",
+                "timestamp": "2026-10-05T22:19:38Z",
+                "version": "1.0.0.14"
+            },
+            {
+                "checksum": "f1fe201e7b0238fa432ae7fb5dbb1844",
+                "changelog": "- yt-dlp now prefers H.264 + AAC (plays or hardware-transcodes on every client; VP9/AV1 often needed a CPU transcode) and uses Jellyfin's own ffmpeg for the merge\n- If yt-dlp fails, the built-in downloader is tried instead\n- Fix a possible hang. yt-dlp's output is now read while it runs, so a full output buffer can no longer block it\n",
+                "targetAbi": "10.11.0.0",
+                "sourceUrl": "https://www.git.quarantinedstudio.com/mvezina/CinemaTrailers4Jellyfins/releases/download/v1.0.0.13/cinematrailers4jellyfins_1.0.0.13.zip",
+                "timestamp": "2026-10-05T22:11:03Z",
+                "version": "1.0.0.13"
+            },
+            {
+                "checksum": "d7a565b0e4d47effb9db40fb44847920",
+                "changelog": "- Anime trailers now only play before anime. Western animation (Pixar, Disney, ...) is no longer blocked and follows the normal genre filter again. A trailer counts as anime when TMDB tags it \"anime\" or \"based on manga\", or it is animation in Japanese, Chinese or Korean; it is marked with a ct4j-anime tag in its NFO at download time. Your anime is recognised by the \"Anime\" genre or the same TMDB keywords\n",
+                "targetAbi": "10.11.0.0",
+                "sourceUrl": "https://www.git.quarantinedstudio.com/mvezina/CinemaTrailers4Jellyfins/releases/download/v1.0.0.12/cinematrailers4jellyfins_1.0.0.12.zip",
+                "timestamp": "2026-10-05T21:57:24Z",
+                "version": "1.0.0.12"
+            },
+            {
+                "checksum": "ccb45ef4bda23b245e47f6226e3c06fc",
+                "changelog": "- Animated trailers (anime included) now only play before animated content. Before, an anime trailer could play before a live-action movie or show when they shared a genre like Drama or Action, or when no trailer matched the genre filter. A live-action feature now gets no trailer rather than an animated one\n",
+                "targetAbi": "10.11.0.0",
+                "sourceUrl": "https://www.git.quarantinedstudio.com/mvezina/CinemaTrailers4Jellyfins/releases/download/v1.0.0.11/cinematrailers4jellyfins_1.0.0.11.zip",
+                "timestamp": "2026-10-05T21:52:47Z",
+                "version": "1.0.0.11"
+            },
             {
                 "checksum": "13e6467ce568b1abe987ef5a8a0ee95d",
                 "changelog": "- Fix trailer downloads, broken by a YouTube change. YouTube no longer serves combined video+audio files, so the built-in downloader now fetches the video and audio separately, merges them with ffmpeg (no re-encode) and deletes the separate files afterwards\n- A failed download no longer leaves an empty trailer folder behind. Empty folders counted toward \"Max trailers to keep\" (pushing out real trailers) and were never retried\n",