feat: TMDB Discover source + retry yt-dlp once before fallback (v1.0.0.17)

The fixed TV lists are mostly long-running shows whose first_air_date is outside ReleaseDateRangeMonths, and paging stops at the first page with no in-range title, so only ~7 TV candidates were found (5 then dropped by language). Add a "discover" source per media type that asks /discover for recent titles in AllowedLanguages, sorted by popularity (1600+ TV results for en|fr today). TV Discover defaults on, movie Discover off. yt-dlp failures were mostly passing HTTP 403s from back-to-back requests; the built-in fallback is sometimes only offered 360p. Retry yt-dlp once after 15s before falling back. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
chore: update manifest.json for v1.0.0.16
2026-10-06 00:00:32 -04:00 · 2026-10-06 01:40:16 +00:00 · 2026-10-05 21:39:49 -04:00 · 2026-10-05 22:28:03 +00:00 · 2026-10-05 18:27:50 -04:00 · 2026-10-05 22:19:38 +00:00
13 changed files with 1236 additions and 208 deletions
--- a/Jellyfin.Plugin.CinemaTrailers4Jellyfins/Configuration/PluginConfiguration.cs
+++ b/Jellyfin.Plugin.CinemaTrailers4Jellyfins/Configuration/PluginConfiguration.cs
@@ -8,12 +8,24 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Configuration

        public string TmdbApiKey { get; set; } = string.Empty;

-        // ── Sources ───────────────────────────────────────────────────────────
+        // ── Sources (Movies) ─────────────────────────────────────────────────

        public bool SourceNowPlaying { get; set; } = true;
        public bool SourceUpcoming { get; set; } = true;
        public bool SourcePopular { get; set; } = false;
        public bool SourceTopRated { get; set; } = false;
+        // TMDB Discover: newest titles in the allowed languages, most popular first.
+        public bool SourceDiscover { get; set; } = false;
+
+        // ── Sources (TV Shows) ───────────────────────────────────────────────
+
+        public bool SourceTvAiringToday { get; set; } = true;
+        public bool SourceTvOnTheAir { get; set; } = true;
+        public bool SourceTvPopular { get; set; } = false;
+        public bool SourceTvTopRated { get; set; } = false;
+        // TMDB Discover: newest shows in the allowed languages, most popular first. On by default:
+        // the TV lists above are mostly long-running shows the date range filters out.
+        public bool SourceTvDiscover { get; set; } = true;

        // ── Date Range ────────────────────────────────────────────────────────

@@ -22,7 +34,13 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Configuration
        // ── Download Settings ─────────────────────────────────────────────────

        public string DownloadFolder { get; set; } = string.Empty;
+
+        /// <summary>Maximum movie trailers to download per run. 0 = don't download movie trailers.</summary>
        public int MaxTrailersToDownload { get; set; } = 20;
+
+        /// <summary>Maximum TV show trailers to download per run. 0 = don't download TV show trailers.</summary>
+        public int MaxTvTrailersToDownload { get; set; } = 0;
+
        public int MaxPagesPerSource { get; set; } = 3;
        public int PreferredVideoHeight { get; set; } = 720;
        public bool SkipAlreadyDownloaded { get; set; } = true;
@@ -52,5 +70,18 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Configuration

        /// <summary>Cycle through all trailers before repeating any.</summary>
        public bool AvoidRepeats { get; set; } = true;
+
+        /// <summary>Also inject trailers before TV episodes, but only before the first episode a user watches each day.</summary>
+        public bool TrailersForEpisodes { get; set; } = false;
+
+        // ── Pre-Roll Bumpers ─────────────────────────────────────────────────
+
+        /// <summary>Jellyfin movie library (VirtualFolder ItemId) to pick a random "Trailer Pre-Roll"
+        /// bumper from, played before the trailer block. Empty = disabled.</summary>
+        public string TrailerPreRollLibraryId { get; set; } = string.Empty;
+
+        /// <summary>Jellyfin movie library (VirtualFolder ItemId) to pick a random "Feature Pre-Roll"
+        /// bumper from, played after the trailer block, right before the feature. Empty = disabled.</summary>
+        public string FeaturePreRollLibraryId { get; set; } = string.Empty;
    }
 }
--- a/Jellyfin.Plugin.CinemaTrailers4Jellyfins/Configuration/config.html
+++ b/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;">
@@ -72,11 +74,11 @@
                        </div>
                    </fieldset>

-                    <!-- Sources -->
+                    <!-- Movie Sources -->
                    <fieldset class="verticalSection verticalSection-extrabottompadding">
-                        <legend><h3 class="sectionTitle">Trailer Sources</h3></legend>
+                        <legend><h3 class="sectionTitle">Movie Trailer Sources</h3></legend>
                        <p class="fieldDescription">
-                            Choose which TMDB lists to pull trailers from. Enable multiple for more variety.
+                            Choose which TMDB lists to pull movie trailers from. Enable multiple for more variety.
                        </p>

                        <div class="checkboxContainer checkboxContainer-withDescription">
@@ -118,13 +120,82 @@
                                Highest rated movies on TMDB, filtered by the date range below.
                            </div>
                        </div>
+
+                        <div class="checkboxContainer checkboxContainer-withDescription">
+                            <label>
+                                <input is="emby-checkbox" type="checkbox" id="source-discover" />
+                                <span>Discover</span>
+                            </label>
+                            <div class="fieldDescription checkboxFieldDescription">
+                                Newest movies in your selected languages, most popular first.
+                            </div>
+                        </div>
+                    </fieldset>
+
+                    <!-- TV Show Sources -->
+                    <fieldset class="verticalSection verticalSection-extrabottompadding">
+                        <legend><h3 class="sectionTitle">TV Show Trailer Sources</h3></legend>
+                        <p class="fieldDescription">
+                            Choose which TMDB lists to pull TV show trailers from. Enable multiple for more variety.
+                            Has no effect if "Max TV show trailers per run" below is set to 0.
+                        </p>
+
+                        <div class="checkboxContainer checkboxContainer-withDescription">
+                            <label>
+                                <input is="emby-checkbox" type="checkbox" id="source-tv-airing-today" />
+                                <span>Airing Today</span>
+                            </label>
+                            <div class="fieldDescription checkboxFieldDescription">
+                                TV shows airing today.
+                            </div>
+                        </div>
+
+                        <div class="checkboxContainer checkboxContainer-withDescription">
+                            <label>
+                                <input is="emby-checkbox" type="checkbox" id="source-tv-on-the-air" />
+                                <span>On The Air</span>
+                            </label>
+                            <div class="fieldDescription checkboxFieldDescription">
+                                TV shows airing in the next 7 days.
+                            </div>
+                        </div>
+
+                        <div class="checkboxContainer checkboxContainer-withDescription">
+                            <label>
+                                <input is="emby-checkbox" type="checkbox" id="source-tv-popular" />
+                                <span>Popular</span>
+                            </label>
+                            <div class="fieldDescription checkboxFieldDescription">
+                                Most popular TV shows on TMDB right now, filtered by the date range below.
+                            </div>
+                        </div>
+
+                        <div class="checkboxContainer checkboxContainer-withDescription">
+                            <label>
+                                <input is="emby-checkbox" type="checkbox" id="source-tv-top-rated" />
+                                <span>Top Rated</span>
+                            </label>
+                            <div class="fieldDescription checkboxFieldDescription">
+                                Highest rated TV shows on TMDB, filtered by the date range below.
+                            </div>
+                        </div>
+
+                        <div class="checkboxContainer checkboxContainer-withDescription">
+                            <label>
+                                <input is="emby-checkbox" type="checkbox" id="source-tv-discover" />
+                                <span>Discover (recommended)</span>
+                            </label>
+                            <div class="fieldDescription checkboxFieldDescription">
+                                Newest TV shows in your selected languages, most popular first. The lists above are mostly long-running shows that the date range drops.
+                            </div>
+                        </div>
                    </fieldset>

                    <!-- Date Range -->
                    <fieldset class="verticalSection verticalSection-extrabottompadding">
                        <legend><h3 class="sectionTitle">Date Range</h3></legend>
                        <div class="selectContainer">
-                            <label class="selectLabel" for="date-range">Only include movies released within</label>
+                            <label class="selectLabel" for="date-range">Only include titles released within</label>
                            <select is="emby-select" id="date-range" class="emby-select-withcolor emby-select">
                                <option value="3">Last 3 months</option>
                                <option value="6">Last 6 months</option>
@@ -133,8 +204,9 @@
                                <option value="0">All time (no limit)</option>
                            </select>
                            <div class="fieldDescription">
-                                Applies to all sources. "Now Playing" and "Upcoming" already have tight date windows
-                                set by TMDB, but this provides an additional filter.
+                                Applies to all sources (movie release date / TV show first-air date). "Now Playing",
+                                "Upcoming", "Airing Today" and "On The Air" already have tight date windows set by
+                                TMDB, but this provides an additional filter.
                            </div>
                        </div>
                    </fieldset>
@@ -153,10 +225,20 @@
                        </div>

                        <div class="inputContainer">
-                            <label class="inputLabel inputLabelUnfocused" for="max-trailers">Max trailers per run</label>
-                            <input type="number" id="max-trailers" is="emby-input" min="1" max="200" />
+                            <label class="inputLabel inputLabelUnfocused" for="max-trailers">Max movie trailers per run</label>
+                            <input type="number" id="max-trailers" is="emby-input" min="0" max="200" />
                            <div class="fieldDescription">
-                                Maximum number of trailers to download each time the task runs. Default: 20.
+                                Maximum number of movie trailers to download each time the task runs.
+                                Set to 0 to not download any movie trailers. Default: 20.
+                            </div>
+                        </div>
+
+                        <div class="inputContainer">
+                            <label class="inputLabel inputLabelUnfocused" for="max-tv-trailers">Max TV show trailers per run</label>
+                            <input type="number" id="max-tv-trailers" is="emby-input" min="0" max="200" />
+                            <div class="fieldDescription">
+                                Maximum number of TV show trailers to download each time the task runs.
+                                Set to 0 to not download any TV show trailers. Default: 0.
                            </div>
                        </div>

@@ -164,7 +246,7 @@
                            <label class="inputLabel inputLabelUnfocused" for="max-pages">Pages per source</label>
                            <input type="number" id="max-pages" is="emby-input" min="1" max="10" />
                            <div class="fieldDescription">
-                                How many pages to fetch from each TMDB source (20 movies per page). Default: 3.
+                                How many pages to fetch from each TMDB source (20 results per page). Default: 3.
                            </div>
                        </div>

@@ -180,10 +262,10 @@
                        <div class="checkboxContainer checkboxContainer-withDescription">
                            <label>
                                <input is="emby-checkbox" type="checkbox" id="skip-library" />
-                                <span>Skip movies already in my Jellyfin library</span>
+                                <span>Skip movies/shows already in my Jellyfin library</span>
                            </label>
                            <div class="fieldDescription checkboxFieldDescription">
-                                Trailers for movies you already own won't be downloaded.
+                                Trailers for movies and TV shows you already own won't be downloaded.
                            </div>
                        </div>

@@ -193,7 +275,7 @@
                                <span>Skip trailers already downloaded</span>
                            </label>
                            <div class="fieldDescription checkboxFieldDescription">
-                                If a folder already exists for a movie, don't re-download it.
+                                If a folder already exists for a movie or TV show, don't re-download it.
                            </div>
                        </div>
                    </fieldset>
@@ -268,6 +350,49 @@
                                Resets automatically once every trailer has been shown. Default: on.
                            </div>
                        </div>
+
+                        <div class="checkboxContainer checkboxContainer-withDescription">
+                            <label>
+                                <input is="emby-checkbox" type="checkbox" id="trailers-for-episodes" />
+                                <span>Also play trailers before TV episodes</span>
+                            </label>
+                            <div class="fieldDescription checkboxFieldDescription">
+                                Only plays before the first episode a user watches each day —
+                                if you watch several episodes back-to-back, only the first gets trailers.
+                            </div>
+                        </div>
+                    </fieldset>
+
+                    <!-- Pre-Roll Bumpers -->
+                    <fieldset class="verticalSection verticalSection-extrabottompadding">
+                        <legend><h3 class="sectionTitle">Pre-Roll Bumpers</h3></legend>
+                        <p class="fieldDescription">
+                            Optional: pick existing Jellyfin Movie libraries to pull random bumper
+                            videos from, bookending the trailer block above. Each is independent —
+                            leave either set to "None" to disable it.
+                        </p>
+
+                        <div class="selectContainer">
+                            <label class="selectLabel" for="trailer-preroll-library">Trailer Pre-Roll library</label>
+                            <select is="emby-select" id="trailer-preroll-library" class="emby-select-withcolor emby-select">
+                                <option value="">— None (disabled) —</option>
+                            </select>
+                            <div class="fieldDescription">
+                                A Movie library to pick a random "Now Playing" style bumper from,
+                                played before the trailer block.
+                            </div>
+                        </div>
+
+                        <div class="selectContainer">
+                            <label class="selectLabel" for="feature-preroll-library">Feature Pre-Roll library</label>
+                            <select is="emby-select" id="feature-preroll-library" class="emby-select-withcolor emby-select">
+                                <option value="">— None (disabled) —</option>
+                            </select>
+                            <div class="fieldDescription">
+                                A Movie library to pick a random "Feature Presentation" style bumper
+                                from, played right before the movie/episode (after trailers).
+                            </div>
+                        </div>
                    </fieldset>

                    <!-- Advanced -->
@@ -295,17 +420,48 @@
        <script type="text/javascript">
            var pluginId = "b581493e-1046-40ed-b6dc-cb8027624984";

+            // parseInt(...) || fallback treats 0 as falsy, which breaks fields where
+            // 0 is a meaningful value (e.g. "don't download any").
+            function parseIntOrDefault(value, fallback) {
+                var n = parseInt(value, 10);
+                return isNaN(n) ? fallback : n;
+            }
+
            $('.cinemaTrailers4JellyfinsConfigPage').on('pageshow', function () {
                Dashboard.showLoadingMsg();
-                ApiClient.getPluginConfiguration(pluginId).then(function (config) {
+                Promise.all([
+                    ApiClient.getPluginConfiguration(pluginId),
+                    ApiClient.getJSON(ApiClient.getUrl('Library/VirtualFolders'))
+                ]).then(function (results) {
+                    var config = results[0];
+                    var movieFolders = results[1].filter(function (f) { return f.CollectionType === 'movies'; });
+                    [['trailer-preroll-library', config.TrailerPreRollLibraryId],
+                     ['feature-preroll-library', config.FeaturePreRollLibraryId]]
+                        .forEach(function (entry) {
+                            var select = document.getElementById(entry[0]);
+                            movieFolders.forEach(function (f) {
+                                var opt = document.createElement('option');
+                                opt.value = f.ItemId;
+                                opt.text = f.Name;
+                                select.appendChild(opt);
+                            });
+                            select.value = entry[1] || '';
+                        });
                    document.getElementById('tmdb-api-key').value           = config.TmdbApiKey || '';
                    document.getElementById('source-now-playing').checked   = config.SourceNowPlaying !== false;
                    document.getElementById('source-upcoming').checked      = config.SourceUpcoming !== false;
                    document.getElementById('source-popular').checked       = !!config.SourcePopular;
                    document.getElementById('source-top-rated').checked     = !!config.SourceTopRated;
+                    document.getElementById('source-discover').checked      = !!config.SourceDiscover;
+                    document.getElementById('source-tv-airing-today').checked = config.SourceTvAiringToday !== false;
+                    document.getElementById('source-tv-on-the-air').checked   = config.SourceTvOnTheAir !== false;
+                    document.getElementById('source-tv-popular').checked      = !!config.SourceTvPopular;
+                    document.getElementById('source-tv-top-rated').checked    = !!config.SourceTvTopRated;
+                    document.getElementById('source-tv-discover').checked     = config.SourceTvDiscover !== false;
                    document.getElementById('date-range').value             = String(config.ReleaseDateRangeMonths ?? 6);
                    document.getElementById('download-folder').value        = config.DownloadFolder || '';
                    document.getElementById('max-trailers').value           = config.MaxTrailersToDownload ?? 20;
+                    document.getElementById('max-tv-trailers').value        = config.MaxTvTrailersToDownload ?? 0;
                    document.getElementById('max-pages').value              = config.MaxPagesPerSource ?? 3;
                    document.getElementById('video-quality').value          = String(config.PreferredVideoHeight ?? 720);
                    document.getElementById('skip-library').checked         = config.SkipMoviesInLibrary !== false;
@@ -321,6 +477,7 @@
                    document.getElementById('filter-genre').checked         = !!config.FilterByGenre;
                    document.getElementById('filter-rating').checked        = !!config.FilterByRating;
                    document.getElementById('avoid-repeats').checked        = config.AvoidRepeats !== false;
+                    document.getElementById('trailers-for-episodes').checked = !!config.TrailersForEpisodes;
                    Dashboard.hideLoadingMsg();
                });
            });
@@ -333,9 +490,16 @@
                    config.SourceUpcoming         = document.getElementById('source-upcoming').checked;
                    config.SourcePopular          = document.getElementById('source-popular').checked;
                    config.SourceTopRated         = document.getElementById('source-top-rated').checked;
+                    config.SourceDiscover         = document.getElementById('source-discover').checked;
+                    config.SourceTvAiringToday    = document.getElementById('source-tv-airing-today').checked;
+                    config.SourceTvOnTheAir       = document.getElementById('source-tv-on-the-air').checked;
+                    config.SourceTvPopular        = document.getElementById('source-tv-popular').checked;
+                    config.SourceTvTopRated       = document.getElementById('source-tv-top-rated').checked;
+                    config.SourceTvDiscover       = document.getElementById('source-tv-discover').checked;
                    config.ReleaseDateRangeMonths = parseInt(document.getElementById('date-range').value, 10);
                    config.DownloadFolder         = document.getElementById('download-folder').value;
-                    config.MaxTrailersToDownload  = parseInt(document.getElementById('max-trailers').value, 10) || 20;
+                    config.MaxTrailersToDownload  = parseIntOrDefault(document.getElementById('max-trailers').value, 20);
+                    config.MaxTvTrailersToDownload = parseIntOrDefault(document.getElementById('max-tv-trailers').value, 0);
                    config.MaxPagesPerSource      = parseInt(document.getElementById('max-pages').value, 10) || 3;
                    config.PreferredVideoHeight   = parseInt(document.getElementById('video-quality').value, 10) || 720;
                    config.SkipMoviesInLibrary    = document.getElementById('skip-library').checked;
@@ -347,11 +511,14 @@
                    });
                    // If all are checked treat it as "no preference" (empty string)
                    config.AllowedLanguages       = checkedLangs.length === allLangCodes.length ? '' : checkedLangs.join(',');
-                    config.MaxTotalTrailers       = parseInt(document.getElementById('max-total-trailers').value, 10) || 50;
+                    config.MaxTotalTrailers       = parseIntOrDefault(document.getElementById('max-total-trailers').value, 50);
                    config.TrailersPerMovie       = parseInt(document.getElementById('trailers-per-movie').value, 10) || 0;
                    config.FilterByGenre         = document.getElementById('filter-genre').checked;
                    config.FilterByRating        = document.getElementById('filter-rating').checked;
                    config.AvoidRepeats          = document.getElementById('avoid-repeats').checked;
+                    config.TrailersForEpisodes   = document.getElementById('trailers-for-episodes').checked;
+                    config.TrailerPreRollLibraryId = document.getElementById('trailer-preroll-library').value;
+                    config.FeaturePreRollLibraryId = document.getElementById('feature-preroll-library').value;
                    ApiClient.updatePluginConfiguration(pluginId, config)
                        .then(Dashboard.processPluginConfigurationUpdateResult);
                });
--- a/Jellyfin.Plugin.CinemaTrailers4Jellyfins/Jellyfin.Plugin.CinemaTrailers4Jellyfins.csproj
+++ b/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.3</AssemblyVersion>
-    <FileVersion>1.0.0.3</FileVersion>
+    <AssemblyVersion>1.0.0.17</AssemblyVersion>
+    <FileVersion>1.0.0.17</FileVersion>
    <Nullable>enable</Nullable>
    <GenerateDocumentationFile>false</GenerateDocumentationFile>
    <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
@@ -13,7 +13,7 @@
  <ItemGroup>
    <PackageReference Include="Jellyfin.Controller" Version="10.11.0" />
    <PackageReference Include="Jellyfin.Model" Version="10.11.0" />
-    <PackageReference Include="YoutubeExplode" Version="6.*" />
+    <PackageReference Include="YoutubeExplode" Version="6.6.2" />
  </ItemGroup>

  <ItemGroup>
--- a/Jellyfin.Plugin.CinemaTrailers4Jellyfins/ScheduledTasks/DownloadTrailersTask.cs
+++ b/Jellyfin.Plugin.CinemaTrailers4Jellyfins/ScheduledTasks/DownloadTrailersTask.cs
@@ -8,6 +8,7 @@ using Jellyfin.Data.Enums;
 using Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Entities.Movies;
+using MediaBrowser.Controller.Entities.TV;
 using MediaBrowser.Controller.Library;
 using MediaBrowser.Model.Entities;
 using MediaBrowser.Model.Tasks;
@@ -25,7 +26,7 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.ScheduledTasks

        public string Name => "Download TMDB Trailers";
        public string Key => "CinemaTrailers4JellyfinsDownload";
-        public string Description => "Downloads trailers from TMDB for upcoming and recently released movies not in your library, packaged as fake-movie folders for use with a Cinema Mode / trailer pre-roll plugin.";
+        public string Description => "Downloads trailers from TMDB for upcoming and recently released movies and TV shows not in your library, packaged as fake-movie folders for use with a Cinema Mode / trailer pre-roll plugin.";
        public string Category => "CinemaTrailers4Jellyfins";

        public DownloadTrailersTask(
@@ -67,9 +68,12 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.ScheduledTasks
                return;
            }

-            if (!config.SourceNowPlaying && !config.SourceUpcoming && !config.SourcePopular && !config.SourceTopRated)
+            var downloadMovies = config.MaxTrailersToDownload > 0;
+            var downloadTvShows = config.MaxTvTrailersToDownload > 0;
+
+            if (!downloadMovies && !downloadTvShows)
            {
-                _logger.LogWarning("|CinemaTrailers4Jellyfins| No TMDB sources selected. Enable at least one source. Skipping task.");
+                _logger.LogWarning("|CinemaTrailers4Jellyfins| Both 'Max movie trailers' and 'Max TV show trailers' are 0. Skipping task.");
                return;
            }

@@ -79,26 +83,64 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.ScheduledTasks

            progress.Report(5);

-            var libraryTmdbIds = config.SkipMoviesInLibrary
-                ? GetLibraryTmdbIds()
-                : new HashSet<string>(StringComparer.OrdinalIgnoreCase);
-
-            _logger.LogInformation("|CinemaTrailers4Jellyfins| Library contains {Count} movies with TMDB IDs (will skip these)", libraryTmdbIds.Count);
-
-            progress.Report(10);
-
            var allowedLanguages = string.IsNullOrWhiteSpace(config.AllowedLanguages)
                ? null
                : new HashSet<string>(
                    config.AllowedLanguages.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries),
                    StringComparer.OrdinalIgnoreCase) as IReadOnlySet<string>;

-            _logger.LogInformation("|CinemaTrailers4Jellyfins| Fetching candidates from TMDB...");
+            int totalDownloaded = 0;
+
+            if (downloadMovies)
+            {
+                if (!config.SourceNowPlaying && !config.SourceUpcoming && !config.SourcePopular && !config.SourceTopRated)
+                {
+                    _logger.LogWarning("|CinemaTrailers4Jellyfins| No movie TMDB sources selected. Skipping movie trailers.");
+                }
+                else
+                {
+                    var progressEnd = downloadTvShows ? 50 : 95;
+                    totalDownloaded += await DownloadMoviesAsync(config, allowedLanguages, progress, 5, progressEnd, cancellationToken)
+                        .ConfigureAwait(false);
+                }
+            }
+
+            if (downloadTvShows)
+            {
+                if (!config.SourceTvAiringToday && !config.SourceTvOnTheAir && !config.SourceTvPopular && !config.SourceTvTopRated)
+                {
+                    _logger.LogWarning("|CinemaTrailers4Jellyfins| No TV show TMDB sources selected. Skipping TV show trailers.");
+                }
+                else
+                {
+                    var progressStart = downloadMovies ? 50 : 5;
+                    totalDownloaded += await DownloadTvShowsAsync(config, allowedLanguages, progress, progressStart, 95, cancellationToken)
+                        .ConfigureAwait(false);
+                }
+            }
+
+            _logger.LogInformation("|CinemaTrailers4Jellyfins| Task complete. Downloaded {Count} trailer(s).", totalDownloaded);
+            progress.Report(100);
+        }
+
+        private async Task<int> DownloadMoviesAsync(
+            Configuration.PluginConfiguration config,
+            IReadOnlySet<string>? allowedLanguages,
+            IProgress<double> progress,
+            double progressStart,
+            double progressEnd,
+            CancellationToken cancellationToken)
+        {
+            var libraryTmdbIds = config.SkipMoviesInLibrary
+                ? GetLibraryMovieTmdbIds()
+                : new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
+            _logger.LogInformation("|CinemaTrailers4Jellyfins| Library contains {Count} movies with TMDB IDs (will skip these)", libraryTmdbIds.Count);
+
+            _logger.LogInformation("|CinemaTrailers4Jellyfins| Fetching movie candidates from TMDB...");
            var candidates = await _tmdbService.GetCandidateMoviesAsync(config, cancellationToken).ConfigureAwait(false);
            _logger.LogInformation("|CinemaTrailers4Jellyfins| Found {Count} candidate movies across all sources", candidates.Count);

-            progress.Report(20);
-
            if (config.SkipMoviesInLibrary)
            {
                candidates = candidates
@@ -109,9 +151,8 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.ScheduledTasks

            if (candidates.Count == 0)
            {
-                _logger.LogInformation("|CinemaTrailers4Jellyfins| No new candidates to download. All done.");
-                progress.Report(100);
-                return;
+                _logger.LogInformation("|CinemaTrailers4Jellyfins| No new movie candidates to download.");
+                return 0;
            }

            int downloaded = 0;
@@ -124,20 +165,28 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.ScheduledTasks
                if (downloaded >= config.MaxTrailersToDownload)
                    break;

-                double taskProgress = 20 + (80.0 * processed / candidates.Count);
+                double taskProgress = progressStart + (progressEnd - progressStart) * processed / candidates.Count;
                progress.Report(taskProgress);
                processed++;

-                var paths = BuildMoviePaths(movie.Title, movie.Year, config);
+                var paths = BuildMediaPaths(movie.Title, movie.Year, config);

-                if (config.SkipAlreadyDownloaded && Directory.Exists(paths.MovieFolder))
+                if (config.SkipAlreadyDownloaded && File.Exists(paths.TrailerPath))
                {
-                    _logger.LogDebug("|CinemaTrailers4Jellyfins| Already downloaded: {Path}", paths.MovieFolder);
+                    _logger.LogDebug("|CinemaTrailers4Jellyfins| Already downloaded: {Path}", paths.MediaFolder);
+                    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.Id.ToString(), config.TmdbApiKey, allowedLanguages, cancellationToken).ConfigureAwait(false);
+                    "movie", movie.Id.ToString(), config.TmdbApiKey, allowedLanguages, cancellationToken).ConfigureAwait(false);

                if (trailers.Count == 0)
                {
@@ -156,34 +205,155 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.ScheduledTasks
                    cancellationToken).ConfigureAwait(false);

                if (!success)
+                {
+                    // Don't leave an empty folder behind: it would count toward MaxTotalTrailers
+                    // (pushing out real trailers) and would never be retried.
+                    TryDeleteFolder(paths.MediaFolder);
                    continue;
+                }

                var fakeMovieReady = await _fakeMovieService.CopyFakeMovieAsync(paths.FakeMoviePath, cancellationToken).ConfigureAwait(false);
                if (!fakeMovieReady)
                {
                    _logger.LogError(
                        "|CinemaTrailers4Jellyfins| Could not create the fake movie file for '{Movie}'. Removing incomplete folder {Folder}.",
-                        movie.Title, paths.MovieFolder);
-                    TryDeleteFolder(paths.MovieFolder);
+                        movie.Title, paths.MediaFolder);
+                    TryDeleteFolder(paths.MediaFolder);
                    continue;
                }

-                var metadata = await _tmdbService.GetMovieMetadataAsync(
-                    movie.Id.ToString(), config.TmdbApiKey, cancellationToken).ConfigureAwait(false);
+                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(
                    "|CinemaTrailers4Jellyfins| [{Done}/{Max}] Saved trailer for '{Movie}' → {Path}",
-                    downloaded, config.MaxTrailersToDownload, movie.Title, paths.MovieFolder);
+                    downloaded, config.MaxTrailersToDownload, movie.Title, paths.MediaFolder);
            }

-            _logger.LogInformation("|CinemaTrailers4Jellyfins| Task complete. Downloaded {Count} trailer(s).", downloaded);
-            progress.Report(100);
+            _logger.LogInformation("|CinemaTrailers4Jellyfins| Movie trailers complete. Downloaded {Count}.", downloaded);
+            return downloaded;
        }

-        private HashSet<string> GetLibraryTmdbIds()
+        private async Task<int> DownloadTvShowsAsync(
+            Configuration.PluginConfiguration config,
+            IReadOnlySet<string>? allowedLanguages,
+            IProgress<double> progress,
+            double progressStart,
+            double progressEnd,
+            CancellationToken cancellationToken)
+        {
+            var librarySeriesTmdbIds = config.SkipMoviesInLibrary
+                ? GetLibrarySeriesTmdbIds()
+                : new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
+            _logger.LogInformation("|CinemaTrailers4Jellyfins| Library contains {Count} TV shows with TMDB IDs (will skip these)", librarySeriesTmdbIds.Count);
+
+            _logger.LogInformation("|CinemaTrailers4Jellyfins| Fetching TV show candidates from TMDB...");
+            var candidates = await _tmdbService.GetCandidateTvShowsAsync(config, cancellationToken).ConfigureAwait(false);
+            _logger.LogInformation("|CinemaTrailers4Jellyfins| Found {Count} candidate TV shows across all sources", candidates.Count);
+
+            if (config.SkipMoviesInLibrary)
+            {
+                candidates = candidates
+                    .Where(s => !librarySeriesTmdbIds.Contains(s.Id.ToString()))
+                    .ToList();
+                _logger.LogInformation("|CinemaTrailers4Jellyfins| {Count} candidates remain after filtering library TV shows", candidates.Count);
+            }
+
+            if (candidates.Count == 0)
+            {
+                _logger.LogInformation("|CinemaTrailers4Jellyfins| No new TV show candidates to download.");
+                return 0;
+            }
+
+            int downloaded = 0;
+            int processed = 0;
+
+            foreach (var show in candidates)
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+
+                if (downloaded >= config.MaxTvTrailersToDownload)
+                    break;
+
+                double taskProgress = progressStart + (progressEnd - progressStart) * processed / candidates.Count;
+                progress.Report(taskProgress);
+                processed++;
+
+                var paths = BuildMediaPaths(show.Title, show.Year, config);
+
+                if (config.SkipAlreadyDownloaded && File.Exists(paths.TrailerPath))
+                {
+                    _logger.LogDebug("|CinemaTrailers4Jellyfins| Already downloaded: {Path}", paths.MediaFolder);
+                    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);
+
+                if (trailers.Count == 0)
+                {
+                    _logger.LogDebug("|CinemaTrailers4Jellyfins| No YouTube trailers on TMDB for '{Title}'", show.Title);
+                    continue;
+                }
+
+                var trailer = trailers[0];
+                _logger.LogInformation("|CinemaTrailers4Jellyfins| Downloading '{Trailer}' for '{Show}'", trailer.Name, show.Title);
+
+                var success = await _downloadService.DownloadAsync(
+                    trailer.Key,
+                    paths.TrailerPath,
+                    config.PreferredVideoHeight,
+                    config.YtDlpPath,
+                    cancellationToken).ConfigureAwait(false);
+
+                if (!success)
+                {
+                    // Don't leave an empty folder behind: it would count toward MaxTotalTrailers
+                    // (pushing out real trailers) and would never be retried.
+                    TryDeleteFolder(paths.MediaFolder);
+                    continue;
+                }
+
+                var fakeMovieReady = await _fakeMovieService.CopyFakeMovieAsync(paths.FakeMoviePath, cancellationToken).ConfigureAwait(false);
+                if (!fakeMovieReady)
+                {
+                    _logger.LogError(
+                        "|CinemaTrailers4Jellyfins| Could not create the fake movie file for '{Show}'. Removing incomplete folder {Folder}.",
+                        show.Title, paths.MediaFolder);
+                    TryDeleteFolder(paths.MediaFolder);
+                    continue;
+                }
+
+                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,
+                    metadata.IsAnime ? new[] { TrailerTags.TvShow, TrailerTags.Anime } : new[] { TrailerTags.TvShow });
+
+                downloaded++;
+                _logger.LogInformation(
+                    "|CinemaTrailers4Jellyfins| [{Done}/{Max}] Saved trailer for '{Show}' → {Path}",
+                    downloaded, config.MaxTvTrailersToDownload, show.Title, paths.MediaFolder);
+            }
+
+            _logger.LogInformation("|CinemaTrailers4Jellyfins| TV show trailers complete. Downloaded {Count}.", downloaded);
+            return downloaded;
+        }
+
+        private HashSet<string> GetLibraryMovieTmdbIds()
        {
            var ids = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

@@ -201,7 +371,25 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.ScheduledTasks
            return ids;
        }

-        // Each trailer lives in its own "{Movie Title} ({Year})" folder alongside a fake
+        private HashSet<string> GetLibrarySeriesTmdbIds()
+        {
+            var ids = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
+            var series = _libraryManager
+                .GetItemList(new InternalItemsQuery { IncludeItemTypes = new[] { BaseItemKind.Series }, Recursive = true })
+                .OfType<Series>();
+
+            foreach (var s in series)
+            {
+                var tmdbId = s.GetProviderId(MetadataProvider.Tmdb);
+                if (!string.IsNullOrEmpty(tmdbId))
+                    ids.Add(tmdbId);
+            }
+
+            return ids;
+        }
+
+        // Each trailer lives in its own "{Title} ({Year})" folder alongside a fake
        // movie file and NFO. Removing a trailer always means removing that whole folder.
        private void CleanupOldTrailers(Configuration.PluginConfiguration config)
        {
@@ -238,20 +426,20 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.ScheduledTasks
            }
        }

-        private readonly record struct MoviePaths(string MovieFolder, string FakeMoviePath, string TrailerPath, string NfoPath);
+        private readonly record struct MediaPaths(string MediaFolder, string FakeMoviePath, string TrailerPath, string NfoPath);

-        private static MoviePaths BuildMoviePaths(string title, int? year, Configuration.PluginConfiguration config)
+        private static MediaPaths BuildMediaPaths(string title, int? year, Configuration.PluginConfiguration config)
        {
            var safeTitle = string.Concat(title.Split(Path.GetInvalidFileNameChars())).Trim();
            var folderName = year.HasValue ? $"{safeTitle} ({year.Value})" : safeTitle;

-            var movieFolder = Path.Combine(config.DownloadFolder, folderName);
+            var mediaFolder = Path.Combine(config.DownloadFolder, folderName);

-            return new MoviePaths(
-                MovieFolder: movieFolder,
-                FakeMoviePath: Path.Combine(movieFolder, $"{folderName}.mp4"),
-                TrailerPath: Path.Combine(movieFolder, $"{folderName}-trailer.mp4"),
-                NfoPath: Path.Combine(movieFolder, $"{folderName}.nfo"));
+            return new MediaPaths(
+                MediaFolder: mediaFolder,
+                FakeMoviePath: Path.Combine(mediaFolder, $"{folderName}.mp4"),
+                TrailerPath: Path.Combine(mediaFolder, $"{folderName}-trailer.mp4"),
+                NfoPath: Path.Combine(mediaFolder, $"{folderName}.nfo"));
        }
    }
 }
--- a/Jellyfin.Plugin.CinemaTrailers4Jellyfins/Services/FakeMovieService.cs
+++ b/Jellyfin.Plugin.CinemaTrailers4Jellyfins/Services/FakeMovieService.cs
@@ -56,7 +56,7 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
        /// Writes a minimal Jellyfin/Kodi-compatible movie NFO with &lt;lockdata&gt;true&lt;/lockdata&gt;
        /// so Jellyfin never tries to refresh metadata for the fake entry from TMDB.
        /// </summary>
-        public void WriteNfo(string nfoPath, string title, int? year, IReadOnlyList<string>? genres = null, string? mpaa = null)
+        public void WriteNfo(string nfoPath, string title, int? year, IReadOnlyList<string>? genres = null, string? mpaa = null, IReadOnlyList<string>? tags = null)
        {
            var settings = new XmlWriterSettings { Indent = true };
            using var writer = XmlWriter.Create(nfoPath, settings);
@@ -70,6 +70,9 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
                    writer.WriteElementString("genre", genre);
            if (!string.IsNullOrWhiteSpace(mpaa))
                writer.WriteElementString("mpaa", mpaa);
+            if (tags != null)
+                foreach (var tag in tags)
+                    writer.WriteElementString("tag", tag);
            writer.WriteElementString("lockdata", "true");
            writer.WriteEndElement();
            writer.WriteEndDocument();
@@ -106,16 +109,11 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
                    "-f mp4",
                    $"\"{tempPath}\"");

-                // Prefer Jellyfin's bundled ffmpeg; fall back to whatever is on PATH.
-                var ffmpegPath = File.Exists("/usr/lib/jellyfin-ffmpeg/ffmpeg")
-                    ? "/usr/lib/jellyfin-ffmpeg/ffmpeg"
-                    : "ffmpeg";
-
                using var process = new Process
                {
                    StartInfo = new ProcessStartInfo
                    {
-                        FileName = ffmpegPath,
+                        FileName = FfmpegLocator.Path,
                        Arguments = args,
                        RedirectStandardOutput = true,
                        RedirectStandardError = true,
--- a/Jellyfin.Plugin.CinemaTrailers4Jellyfins/Services/FfmpegLocator.cs
+++ b/Jellyfin.Plugin.CinemaTrailers4Jellyfins/Services/FfmpegLocator.cs
@@ -0,0 +1,12 @@
+using System.IO;
+
+namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
+{
+    internal static class FfmpegLocator
+    {
+        private const string JellyfinFfmpeg = "/usr/lib/jellyfin-ffmpeg/ffmpeg";
+
+        // Prefer Jellyfin's bundled ffmpeg; fall back to whatever is on PATH.
+        public static string Path => File.Exists(JellyfinFfmpeg) ? JellyfinFfmpeg : "ffmpeg";
+    }
+}
--- a/Jellyfin.Plugin.CinemaTrailers4Jellyfins/Services/TmdbService.cs
+++ b/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 TmdbMovieResult(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 TmdbMovieMetadata(IReadOnlyList<string> Genres, string? Certification);
+    public record TmdbMediaMetadata(IReadOnlyList<string> Genres, string? Certification, bool IsAnime);

    public class TmdbService : IDisposable
    {
@@ -75,7 +75,41 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
        /// Fetches candidate movies from the configured TMDB sources, optionally filtered
        /// by a minimum release date. Deduplicates across sources by TMDB ID.
        /// </summary>
-        public async Task<List<TmdbMovieResult>> GetCandidateMoviesAsync(
+        public Task<List<TmdbMediaResult>> GetCandidateMoviesAsync(
+            Configuration.PluginConfiguration config,
+            CancellationToken ct)
+        {
+            var sources = new List<string>();
+            if (config.SourceNowPlaying) sources.Add("now_playing");
+            if (config.SourceUpcoming)   sources.Add("upcoming");
+            if (config.SourcePopular)    sources.Add("popular");
+            if (config.SourceTopRated)   sources.Add("top_rated");
+            if (config.SourceDiscover)   sources.Add(DiscoverSource);
+
+            return GetCandidatesAsync("movie", sources, config, ct);
+        }
+
+        /// <summary>
+        /// Fetches candidate TV shows from the configured TMDB sources, optionally filtered
+        /// by a minimum first-air date. Deduplicates across sources by TMDB ID.
+        /// </summary>
+        public Task<List<TmdbMediaResult>> GetCandidateTvShowsAsync(
+            Configuration.PluginConfiguration config,
+            CancellationToken ct)
+        {
+            var sources = new List<string>();
+            if (config.SourceTvAiringToday) sources.Add("airing_today");
+            if (config.SourceTvOnTheAir)    sources.Add("on_the_air");
+            if (config.SourceTvPopular)     sources.Add("popular");
+            if (config.SourceTvTopRated)    sources.Add("top_rated");
+            if (config.SourceTvDiscover)    sources.Add(DiscoverSource);
+
+            return GetCandidatesAsync("tv", sources, config, ct);
+        }
+
+        private async Task<List<TmdbMediaResult>> GetCandidatesAsync(
+            string mediaType,
+            List<string> sourceEndpoints,
            Configuration.PluginConfiguration config,
            CancellationToken ct)
        {
@@ -84,36 +118,61 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
                : null;

            var seen = new HashSet<int>();
-            var results = new List<TmdbMovieResult>();
+            var results = new List<TmdbMediaResult>();

-            async Task FetchSource(string endpoint)
+            foreach (var endpoint in sourceEndpoints)
            {
-                var movies = await FetchSourcePagesAsync(endpoint, config.TmdbApiKey, releasedAfter, config.MaxPagesPerSource, ct)
+                var path = endpoint == DiscoverSource
+                    ? DiscoverPath(mediaType, releasedAfter, config.AllowedLanguages)
+                    : $"{mediaType}/{endpoint}";
+                var items = await FetchSourcePagesAsync(mediaType, path, config.TmdbApiKey, releasedAfter, config.MaxPagesPerSource, ct)
                    .ConfigureAwait(false);

-                foreach (var m in movies)
+                foreach (var item in items)
                {
-                    if (seen.Add(m.Id))
-                        results.Add(m);
+                    if (seen.Add(item.Id))
+                        results.Add(item);
                }
            }

-            if (config.SourceNowPlaying) await FetchSource("now_playing");
-            if (config.SourceUpcoming)   await FetchSource("upcoming");
-            if (config.SourcePopular)    await FetchSource("popular");
-            if (config.SourceTopRated)   await FetchSource("top_rated");
-
            return results;
        }

-        private async Task<List<TmdbMovieResult>> FetchSourcePagesAsync(
-            string endpoint,
+        private const string DiscoverSource = "discover";
+
+        // /discover asks TMDB directly for recent titles in the allowed languages, sorted by
+        // popularity, unlike the fixed lists, which are mostly older titles the date range drops.
+        private static string DiscoverPath(string mediaType, DateTime? releasedAfter, string allowedLanguages)
+        {
+            var query = new List<string> { "sort_by=popularity.desc" };
+            if (releasedAfter.HasValue)
+            {
+                var dateParam = mediaType == "movie" ? "primary_release_date.gte" : "first_air_date.gte";
+                query.Add($"{dateParam}={releasedAfter.Value:yyyy-MM-dd}");
+            }
+
+            var languages = (allowedLanguages ?? string.Empty)
+                .Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+            if (languages.Length > 0)
+                query.Add("with_original_language=" + Uri.EscapeDataString(string.Join("|", languages)));
+
+            return $"discover/{mediaType}?" + string.Join("&", query);
+        }
+
+        // path is relative to the API root, e.g. "tv/popular" or "discover/tv?sort_by=...".
+        private async Task<List<TmdbMediaResult>> FetchSourcePagesAsync(
+            string mediaType,
+            string path,
            string apiKey,
            DateTime? releasedAfter,
            int maxPages,
            CancellationToken ct)
        {
-            var results = new List<TmdbMovieResult>();
+            var results = new List<TmdbMediaResult>();
+
+            // Movies use "title"/"release_date"; TV shows use "name"/"first_air_date".
+            var titleField = mediaType == "movie" ? "title" : "name";
+            var dateField = mediaType == "movie" ? "release_date" : "first_air_date";

            for (int page = 1; page <= maxPages; page++)
            {
@@ -121,7 +180,7 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services

                try
                {
-                    var url = $"{BaseUrl}/movie/{endpoint}?language=en-US&page={page}";
+                    var url = $"{BaseUrl}/{path}{(path.Contains('?') ? '&' : '?')}language=en-US&page={page}";
                    using var request = new HttpRequestMessage(HttpMethod.Get, url);
                    ApplyAuth(request, apiKey);
                    using var response = await _httpClient.SendAsync(request, ct).ConfigureAwait(false);
@@ -133,11 +192,12 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
                    int totalPages = doc.RootElement.GetProperty("total_pages").GetInt32();
                    bool anyInRange = false;

-                    foreach (var movie in pageResults.EnumerateArray())
+                    foreach (var entry in pageResults.EnumerateArray())
                    {
-                        var releaseDate = movie.TryGetProperty("release_date", out var rd) ? rd.GetString() ?? string.Empty : string.Empty;
-                        var title = movie.TryGetProperty("title", out var t) ? t.GetString() ?? string.Empty : string.Empty;
-                        var id = movie.GetProperty("id").GetInt32();
+                        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))
                        {
@@ -145,7 +205,7 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
                        }

                        anyInRange = true;
-                        results.Add(new TmdbMovieResult(id, title, releaseDate));
+                        results.Add(new TmdbMediaResult(id, title, releaseDate, originalLanguage));
                    }

                    if (page >= totalPages || (releasedAfter.HasValue && !anyInRange))
@@ -157,7 +217,7 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
                }
                catch (Exception ex)
                {
-                    _logger.LogError(ex, "|CinemaTrailers4Jellyfins| Failed to fetch TMDB source '{Endpoint}' page {Page}", endpoint, page);
+                    _logger.LogError(ex, "|CinemaTrailers4Jellyfins| Failed to fetch TMDB source '{Path}' page {Page}", path, page);
                    break;
                }
            }
@@ -190,17 +250,21 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
        }

        /// <summary>
-        /// Returns the genre names and US theatrical certification (G, PG, PG-13, R, NC-17)
-        /// for a movie. Uses a single /movie/{id}?append_to_response=release_dates call.
+        /// Returns the genre names and US certification for a movie or TV show
+        /// (e.g. PG-13 for movies, TV-14 for TV shows). Movies use a single
+        /// /movie/{id}?append_to_response=release_dates call; TV shows use
+        /// /tv/{id}?append_to_response=content_ratings.
        /// </summary>
-        public async Task<TmdbMovieMetadata> GetMovieMetadataAsync(
+        public async Task<TmdbMediaMetadata> GetMediaMetadataAsync(
+            string mediaType,
            string tmdbId,
            string apiKey,
            CancellationToken ct)
        {
            try
            {
-                var url = $"{BaseUrl}/movie/{tmdbId}?append_to_response=release_dates&language=en-US";
+                var appendField = mediaType == "movie" ? "release_dates" : "content_ratings";
+                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);
@@ -222,45 +286,100 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
                    }
                }

-                string? certification = null;
-                if (doc.RootElement.TryGetProperty("release_dates", out var releaseDates)
-                    && releaseDates.TryGetProperty("results", out var rdResults))
-                {
-                    foreach (var country in rdResults.EnumerateArray())
-                    {
-                        if (!country.TryGetProperty("iso_3166_1", out var iso)
-                            || !string.Equals(iso.GetString(), "US", StringComparison.OrdinalIgnoreCase))
-                            continue;
+                string? certification = mediaType == "movie"
+                    ? GetMovieCertification(doc)
+                    : GetTvCertification(doc);

-                        if (!country.TryGetProperty("release_dates", out var dates))
-                            break;
-
-                        foreach (var date in dates.EnumerateArray())
-                        {
-                            if (!date.TryGetProperty("certification", out var cert))
-                                continue;
-                            var certStr = cert.GetString();
-                            if (!string.IsNullOrWhiteSpace(certStr))
-                            {
-                                certification = certStr;
-                                break;
-                            }
-                        }
-                        break;
-                    }
-                }
-
-                return new TmdbMovieMetadata(genres.AsReadOnly(), certification);
+                return new TmdbMediaMetadata(genres.AsReadOnly(), certification, IsAnime(doc, mediaType, genres));
            }
            catch (OperationCanceledException) { throw; }
            catch (Exception ex)
            {
-                _logger.LogError(ex, "|CinemaTrailers4Jellyfins| GetMovieMetadata failed for TMDB ID {Id}", tmdbId);
-                return new TmdbMovieMetadata(Array.Empty<string>(), null);
+                _logger.LogError(ex, "|CinemaTrailers4Jellyfins| GetMediaMetadata failed for {MediaType} TMDB ID {Id}", mediaType, tmdbId);
+                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)
+        {
+            if (!doc.RootElement.TryGetProperty("release_dates", out var releaseDates)
+                || !releaseDates.TryGetProperty("results", out var rdResults))
+                return null;
+
+            foreach (var country in rdResults.EnumerateArray())
+            {
+                if (!country.TryGetProperty("iso_3166_1", out var iso)
+                    || !string.Equals(iso.GetString(), "US", StringComparison.OrdinalIgnoreCase))
+                    continue;
+
+                if (!country.TryGetProperty("release_dates", out var dates))
+                    return null;
+
+                foreach (var date in dates.EnumerateArray())
+                {
+                    if (!date.TryGetProperty("certification", out var cert))
+                        continue;
+                    var certStr = cert.GetString();
+                    if (!string.IsNullOrWhiteSpace(certStr))
+                        return certStr;
+                }
+
+                return null;
+            }
+
+            return null;
+        }
+
+        // Finds the US TV content rating (TV-Y, TV-PG, TV-14, TV-MA, etc.) from content_ratings.
+        private static string? GetTvCertification(JsonDocument doc)
+        {
+            if (!doc.RootElement.TryGetProperty("content_ratings", out var contentRatings)
+                || !contentRatings.TryGetProperty("results", out var crResults))
+                return null;
+
+            foreach (var country in crResults.EnumerateArray())
+            {
+                if (!country.TryGetProperty("iso_3166_1", out var iso)
+                    || !string.Equals(iso.GetString(), "US", StringComparison.OrdinalIgnoreCase))
+                    continue;
+
+                if (!country.TryGetProperty("rating", out var rating))
+                    return null;
+
+                var ratingStr = rating.GetString();
+                return string.IsNullOrWhiteSpace(ratingStr) ? null : ratingStr;
+            }
+
+            return null;
+        }
+
        public async Task<List<TmdbVideo>> GetTrailersAsync(
+            string mediaType,
            string tmdbId,
            string apiKey,
            IReadOnlySet<string>? allowedLanguages,
@@ -270,7 +389,7 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
            {
                // No language filter on the URL — we want all available trailers so we can
                // filter by iso_639_1 ourselves based on the user's language preference.
-                var url = $"{BaseUrl}/movie/{tmdbId}/videos";
+                var url = $"{BaseUrl}/{mediaType}/{tmdbId}/videos";
                using var request = new HttpRequestMessage(HttpMethod.Get, url);
                ApplyAuth(request, apiKey);
                using var response = await _httpClient.SendAsync(request, ct).ConfigureAwait(false);
@@ -311,7 +430,7 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
            catch (OperationCanceledException) { throw; }
            catch (Exception ex)
            {
-                _logger.LogError(ex, "|CinemaTrailers4Jellyfins| GetTrailers failed for TMDB ID {Id}", tmdbId);
+                _logger.LogError(ex, "|CinemaTrailers4Jellyfins| GetTrailers failed for {MediaType} TMDB ID {Id}", mediaType, tmdbId);
                return new List<TmdbVideo>();
            }
        }
--- a/Jellyfin.Plugin.CinemaTrailers4Jellyfins/Services/TrailerDownloadService.cs
+++ b/Jellyfin.Plugin.CinemaTrailers4Jellyfins/Services/TrailerDownloadService.cs
@@ -45,6 +45,8 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
            _httpClient = new HttpClient(handler) { Timeout = TimeSpan.FromMinutes(10) };
        }

+        private static readonly TimeSpan YtDlpRetryDelay = TimeSpan.FromSeconds(15);
+
        public void Dispose() => _httpClient.Dispose();

        /// <summary>
@@ -63,8 +65,18 @@ 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;
+
+                // YouTube answers back-to-back downloads with occasional HTTP 403s that clear on
+                // their own. One more try after a pause usually gets full quality, where the
+                // built-in fallback may only be offered a 360p stream.
+                _logger.LogWarning("|CinemaTrailers4Jellyfins| yt-dlp failed for {Key}; retrying in {Seconds}s.", youtubeKey, YtDlpRetryDelay.TotalSeconds);
+                await Task.Delay(YtDlpRetryDelay, 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)
@@ -77,6 +89,10 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
            int preferredHeight,
            CancellationToken ct)
        {
+            // Separate video/audio downloads land next to the output and are always removed,
+            // whether the merge succeeds or not.
+            var videoTemp = outputPath + ".video.tmp";
+            var audioTemp = outputPath + ".audio.tmp";
            try
            {
                var youtube = new YoutubeClient(_httpClient);
@@ -84,30 +100,48 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
                    .GetManifestAsync($"https://www.youtube.com/watch?v={key}", ct)
                    .ConfigureAwait(false);

-                // Muxed streams include audio+video in one file. Quality is capped at 720p by YouTube.
+                // 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)
+                if (muxedStreams.Count > 0)
                {
-                    _logger.LogWarning("|CinemaTrailers4Jellyfins| No muxed streams available for {Key}. Consider configuring yt-dlp for 1080p support.", key);
-                    return false;
+                    var muxed = PickByHeight(muxedStreams, preferredHeight);
+                    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;
+                    }
                }

-                // Prefer the highest quality at or below the configured height limit.
-                var stream = muxedStreams
-                    .Where(s => s.VideoQuality.MaxHeight <= preferredHeight)
-                    .OrderByDescending(s => s.VideoQuality.MaxHeight)
-                    .FirstOrDefault()
-                    ?? muxedStreams.OrderByDescending(s => s.VideoQuality.MaxHeight).First();
+                if (video == null || audioStreams.Count == 0)
+                {
+                    _logger.LogWarning("|CinemaTrailers4Jellyfins| No usable video/audio streams for {Key}.", key);
+                    return false;
+                }
+                var mp4Audio = audioStreams.Where(s => s.Container == Container.Mp4).ToList();
+                var audio = (mp4Audio.Count > 0 ? mp4Audio : audioStreams).GetWithHighestBitrate();

                _logger.LogInformation(
-                    "|CinemaTrailers4Jellyfins| Downloading {Key} at {Quality} to {Path}",
-                    key, stream.VideoQuality.Label, outputPath);
+                    "|CinemaTrailers4Jellyfins| Downloading {Key} at {Quality} (video + audio, merged with ffmpeg) to {Path}",
+                    key, video.VideoQuality.Label, outputPath);

-                await youtube.Videos.Streams
-                    .DownloadAsync(stream, outputPath, cancellationToken: ct)
-                    .ConfigureAwait(false);
+                await youtube.Videos.Streams.DownloadAsync(video, videoTemp, cancellationToken: ct).ConfigureAwait(false);
+                await youtube.Videos.Streams.DownloadAsync(audio, audioTemp, cancellationToken: ct).ConfigureAwait(false);

-                return true;
+                return await MergeAsync(key, videoTemp, audioTemp, outputPath, ct).ConfigureAwait(false);
            }
            catch (OperationCanceledException)
            {
@@ -118,6 +152,85 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
                _logger.LogError(ex, "|CinemaTrailers4Jellyfins| YoutubeExplode download failed for {Key}", key);
                return false;
            }
+            finally
+            {
+                TryDeleteFile(videoTemp);
+                TryDeleteFile(audioTemp);
+            }
+        }
+
+        // Highest quality at or below the configured height limit, else the lowest available.
+        private static T PickByHeight<T>(System.Collections.Generic.IReadOnlyList<T> streams, int preferredHeight)
+            where T : IVideoStreamInfo
+            => streams
+                .Where(s => s.VideoQuality.MaxHeight <= preferredHeight)
+                .OrderByDescending(s => s.VideoQuality.MaxHeight)
+                .FirstOrDefault()
+               ?? streams.OrderBy(s => s.VideoQuality.MaxHeight).First();
+
+        // Stream-copies (no re-encode) the video and audio tracks into one MP4.
+        // Writes to a temp file first so a failed merge never leaves a broken trailer.
+        private async Task<bool> MergeAsync(string key, string videoPath, string audioPath, string outputPath, CancellationToken ct)
+        {
+            var mergeTemp = outputPath + ".merge.tmp";
+            try
+            {
+                var args = string.Join(" ",
+                    "-y -loglevel error",
+                    $"-i \"{videoPath}\"",
+                    $"-i \"{audioPath}\"",
+                    "-map 0:v:0 -map 1:a:0 -c copy -movflags +faststart",
+                    "-f mp4",
+                    $"\"{mergeTemp}\"");
+
+                using var process = new Process
+                {
+                    StartInfo = new ProcessStartInfo
+                    {
+                        FileName = FfmpegLocator.Path,
+                        Arguments = args,
+                        RedirectStandardOutput = true,
+                        RedirectStandardError = true,
+                        UseShellExecute = false,
+                        CreateNoWindow = true,
+                    }
+                };
+
+                process.Start();
+                // Drain both pipes while ffmpeg 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 || !File.Exists(mergeTemp))
+                {
+                    _logger.LogError("|CinemaTrailers4Jellyfins| ffmpeg merge failed for {Key} (exit code {Code}): {Error}",
+                        key, process.ExitCode, stderr);
+                    return false;
+                }
+
+                File.Move(mergeTemp, outputPath, overwrite: true);
+                return true;
+            }
+            finally
+            {
+                TryDeleteFile(mergeTemp);
+            }
+        }
+
+        private void TryDeleteFile(string path)
+        {
+            try
+            {
+                if (File.Exists(path))
+                    File.Delete(path);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogWarning(ex, "|CinemaTrailers4Jellyfins| Could not delete temporary file {Path}", path);
+            }
        }

        private async Task<bool> DownloadWithYtDlpAsync(
@@ -129,13 +242,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}\"");

@@ -157,11 +273,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;
@@ -178,6 +298,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);
+                }
+            }
        }
    }
 }
--- a/Jellyfin.Plugin.CinemaTrailers4Jellyfins/Services/TrailerIntroProvider.cs
+++ b/Jellyfin.Plugin.CinemaTrailers4Jellyfins/Services/TrailerIntroProvider.cs
@@ -8,6 +8,7 @@ using Jellyfin.Data.Enums;
 using Jellyfin.Database.Implementations.Entities;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Entities.Movies;
+using MediaBrowser.Controller.Entities.TV;
 using MediaBrowser.Controller.Library;
 using Microsoft.Extensions.Logging;

@@ -22,6 +23,10 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
        private static readonly ConcurrentDictionary<Guid, HashSet<Guid>> _seenByUser = new();
        private static readonly object _seenLock = new();

+        // Per-user date of the last episode that received trailers, so only the
+        // first episode a user watches each day gets them.
+        private static readonly ConcurrentDictionary<Guid, DateTime> _lastEpisodeTrailerDateByUser = new();
+
        private readonly ILibraryManager _libraryManager;
        private readonly ILogger<TrailerIntroProvider> _logger;

@@ -36,64 +41,215 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
        public Task<IEnumerable<IntroInfo>> GetIntros(BaseItem item, User user)
        {
            var config = Plugin.Instance?.Configuration;
-            if (config == null || config.TrailersPerMovie <= 0)
+            if (config == null)
                return Task.FromResult(Enumerable.Empty<IntroInfo>());

-            if (item is not Movie)
+            var trailersEnabled = config.TrailersPerMovie > 0;
+            var preRollEnabled = !string.IsNullOrEmpty(config.TrailerPreRollLibraryId);
+            var featurePreRollEnabled = !string.IsNullOrEmpty(config.FeaturePreRollLibraryId);
+
+            _logger.LogInformation(
+                "|CinemaTrailers4Jellyfins| GetIntros called for {Type} '{Name}' (Path={Path}). "
+                + "trailersEnabled={Trailers} preRollEnabled={PreRoll} featurePreRollEnabled={FeaturePreRoll}",
+                item.GetType().Name,
+                item.Name,
+                item.Path,
+                trailersEnabled,
+                preRollEnabled,
+                featurePreRollEnabled);
+
+            if (!trailersEnabled && !preRollEnabled && !featurePreRollEnabled)
                return Task.FromResult(Enumerable.Empty<IntroInfo>());

+            // The item used for genre/rating filtering. For episodes this is the
+            // parent series, since episodes rarely carry their own genre metadata.
+            BaseItem feature;
+            bool isEpisode;
+
+            switch (item)
+            {
+                case Movie:
+                    feature = item;
+                    isEpisode = false;
+                    break;
+
+                case Episode episode:
+                    if (!config.TrailersForEpisodes)
+                    {
+                        _logger.LogInformation("|CinemaTrailers4Jellyfins| Skipping: TrailersForEpisodes is disabled.");
+                        return Task.FromResult(Enumerable.Empty<IntroInfo>());
+                    }
+
+                    if (!IsFirstEpisodeOfDay(user.Id))
+                    {
+                        _logger.LogInformation("|CinemaTrailers4Jellyfins| Skipping: not the first episode of the day for this user.");
+                        return Task.FromResult(Enumerable.Empty<IntroInfo>());
+                    }
+
+                    feature = episode.Series ?? (BaseItem)episode;
+                    isEpisode = true;
+                    break;
+
+                default:
+                    _logger.LogInformation("|CinemaTrailers4Jellyfins| Skipping: item type {Type} is not a Movie or Episode.", item.GetType().Name);
+                    return Task.FromResult(Enumerable.Empty<IntroInfo>());
+            }
+
            var outputFolder = config.DownloadFolder?.TrimEnd(
                Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
-            if (string.IsNullOrEmpty(outputFolder))
-                return Task.FromResult(Enumerable.Empty<IntroInfo>());

            // Break recursion: don't inject intros before items from our own output folder
            // (covers both the fake-movie files and their trailer extras).
-            if (item.Path?.StartsWith(outputFolder, StringComparison.OrdinalIgnoreCase) == true)
-                return Task.FromResult(Enumerable.Empty<IntroInfo>());
-
-            // Server-scoped query so hidden libraries don't block trailer discovery.
-            var pairs = _libraryManager
-                .GetItemList(new InternalItemsQuery
-                {
-                    IncludeItemTypes = new[] { BaseItemKind.Movie },
-                    Recursive = true,
-                })
-                .OfType<Movie>()
-                .Where(m =>
-                    m.Path?.StartsWith(outputFolder, StringComparison.OrdinalIgnoreCase) == true
-                    && m.LocalTrailers.Count > 0)
-                .SelectMany(m => m.LocalTrailers.Select(t => (Movie: m, Trailer: t)))
-                .ToList();
-
-            if (pairs.Count == 0)
+            if (!string.IsNullOrEmpty(outputFolder)
+                && item.Path?.StartsWith(outputFolder, StringComparison.OrdinalIgnoreCase) == true)
            {
-                _logger.LogDebug(
-                    "|CinemaTrailers4Jellyfins| No indexed trailers in {Folder}. "
-                    + "Ensure the output folder is added as a Jellyfin Movies library and scanned.",
-                    outputFolder);
+                _logger.LogInformation("|CinemaTrailers4Jellyfins| Skipping: item path is inside the output folder ({Folder}).", outputFolder);
                return Task.FromResult(Enumerable.Empty<IntroInfo>());
            }

-            // Apply enabled filters. If nothing survives, fall back to the full pool.
-            var filtered = ApplyFilters(pairs, item, config);
-            var pool = filtered.Count > 0 ? filtered : pairs;
+            var intros = new List<IntroInfo>();

-            // Prefer unseen trailers within the pool; reset the cycle when all have been shown.
-            pool = ApplyAvoidRepeats(pool, user.Id, config.AvoidRepeats);
+            if (preRollEnabled)
+            {
+                var preRoll = GetRandomLibraryMovieIntro("Trailer Pre-Roll", config.TrailerPreRollLibraryId, item.Id, user);
+                if (preRoll != null)
+                    intros.Add(preRoll);
+            }

-            var selected = pool
-                .OrderBy(_ => _rng.Next())
-                .Take(config.TrailersPerMovie)
+            if (trailersEnabled && !string.IsNullOrEmpty(outputFolder))
+            {
+                // Server-scoped query so hidden libraries don't block trailer discovery.
+                var pairs = _libraryManager
+                    .GetItemList(new InternalItemsQuery
+                    {
+                        IncludeItemTypes = new[] { BaseItemKind.Movie },
+                        Recursive = true,
+                    })
+                    .OfType<Movie>()
+                    .Where(m =>
+                        m.Path?.StartsWith(outputFolder, StringComparison.OrdinalIgnoreCase) == true
+                        && m.LocalTrailers.Count > 0
+                        // Skip items the user can't actually play (e.g. library not in their access list) —
+                        // some clients hang indefinitely trying to play an inaccessible item.
+                        && m.IsVisibleStandalone(user)
+                        // Keep TV show trailers for episodes and movie trailers for movies separate.
+                        && m.Tags.Contains(TrailerTags.TvShow, StringComparer.OrdinalIgnoreCase) == isEpisode)
+                    .SelectMany(m => m.LocalTrailers.Select(t => (Movie: m, Trailer: t)))
+                    .ToList();
+
+                if (pairs.Count == 0)
+                {
+                    _logger.LogDebug(
+                        "|CinemaTrailers4Jellyfins| No indexed {Kind} trailers in {Folder}. "
+                        + "Ensure the output folder is added as a Jellyfin Movies library and scanned.",
+                        isEpisode ? "TV show" : "movie",
+                        outputFolder);
+                }
+                else
+                {
+                    // 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 => !IsAnimeTrailer(p.Movie)).ToList();
+
+                    // Apply enabled filters. If nothing survives, fall back to the eligible pool.
+                    var filtered = ApplyFilters(eligible, feature, config);
+                    var pool = filtered.Count > 0 ? filtered : eligible;
+
+                    // Prefer unseen trailers within the pool; reset the cycle when all have been shown.
+                    pool = ApplyAvoidRepeats(pool, user.Id, config.AvoidRepeats);
+
+                    var selected = pool
+                        .OrderBy(_ => _rng.Next())
+                        .Take(config.TrailersPerMovie)
+                        .ToList();
+
+                    if (config.AvoidRepeats)
+                        MarkSeen(user.Id, selected.Select(p => p.Trailer.Id));
+
+                    intros.AddRange(selected.Select(p => new IntroInfo { ItemId = p.Trailer.Id, Path = p.Trailer.Path }));
+                }
+            }
+
+            if (featurePreRollEnabled)
+            {
+                var featureRoll = GetRandomLibraryMovieIntro("Feature Pre-Roll", config.FeaturePreRollLibraryId, item.Id, user);
+                if (featureRoll != null)
+                    intros.Add(featureRoll);
+            }
+
+            _logger.LogInformation(
+                "|CinemaTrailers4Jellyfins| Returning {Count} intro(s): {Paths}",
+                intros.Count,
+                string.Join(", ", intros.Select(i => i.Path)));
+
+            return Task.FromResult<IEnumerable<IntroInfo>>(intros);
+        }
+
+        /// <summary>
+        /// Picks a random Movie from the given Jellyfin library (VirtualFolder ItemId) to use as a
+        /// pre-roll/post-roll bumper, excluding the item currently being played.
+        /// </summary>
+        private IntroInfo? GetRandomLibraryMovieIntro(string label, string libraryId, Guid excludeId, User user)
+        {
+            if (!Guid.TryParse(libraryId, out var parsedId))
+            {
+                _logger.LogWarning(
+                    "|CinemaTrailers4Jellyfins| {Label} library ID '{LibraryId}' is not a valid GUID — check the plugin settings.",
+                    label,
+                    libraryId);
+                return null;
+            }
+
+            if (_libraryManager.GetItemById(parsedId) is not Folder folder)
+            {
+                _logger.LogWarning(
+                    "|CinemaTrailers4Jellyfins| {Label} library {LibraryId} could not be found.",
+                    label,
+                    parsedId);
+                return null;
+            }
+
+            var movies = folder.GetRecursiveChildren()
+                .OfType<Movie>()
+                .Where(m => m.Id != excludeId && m.IsVisibleStandalone(user))
                .ToList();

-            if (config.AvoidRepeats)
-                MarkSeen(user.Id, selected.Select(p => p.Trailer.Id));
+            if (movies.Count == 0)
+            {
+                _logger.LogInformation(
+                    "|CinemaTrailers4Jellyfins| {Label} library {LibraryId} has no eligible Movie items visible to this user. "
+                    + "Ensure the library has been scanned, contains at least one other Movie, and is in this user's library access list.",
+                    label,
+                    parsedId);
+                return null;
+            }

-            var intros = selected.Select(p => new IntroInfo { ItemId = p.Trailer.Id, Path = p.Trailer.Path });
-            return Task.FromResult<IEnumerable<IntroInfo>>(intros.ToList());
+            var movie = movies[_rng.Next(movies.Count)];
+            _logger.LogInformation(
+                "|CinemaTrailers4Jellyfins| {Label}: picked '{Title}' ({Path}).",
+                label,
+                movie.Name,
+                movie.Path);
+            return new IntroInfo { ItemId = movie.Id, Path = movie.Path };
        }

+        // 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 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,
            BaseItem feature,
@@ -149,6 +305,36 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
            }
        }

+        /// <summary>
+        /// Returns true (and records today's date) only the first time this is called
+        /// for a given user on a given day.
+        /// </summary>
+        private static bool IsFirstEpisodeOfDay(Guid userId)
+        {
+            var today = DateTime.Now.Date;
+            var isFirst = false;
+
+            _lastEpisodeTrailerDateByUser.AddOrUpdate(
+                userId,
+                _ =>
+                {
+                    isFirst = true;
+                    return today;
+                },
+                (_, lastDate) =>
+                {
+                    if (lastDate < today)
+                    {
+                        isFirst = true;
+                        return today;
+                    }
+
+                    return lastDate;
+                });
+
+            return isFirst;
+        }
+
        private static void MarkSeen(Guid userId, IEnumerable<Guid> trailerIds)
        {
            lock (_seenLock)
--- a/Jellyfin.Plugin.CinemaTrailers4Jellyfins/Services/TrailerTags.cs
+++ b/Jellyfin.Plugin.CinemaTrailers4Jellyfins/Services/TrailerTags.cs
@@ -0,0 +1,15 @@
+namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
+{
+    /// <summary>
+    /// Tags written into each downloaded trailer's NFO so <see cref="TrailerIntroProvider"/>
+    /// 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";
+    }
+}
--- a/README.md
+++ b/README.md
@@ -1,30 +1,70 @@
 # CinemaTrailers4Jellyfins

-A Jellyfin plugin that automatically downloads movie trailers from TMDB/YouTube and packages
-each one as a self-contained "fake movie" folder, ready to be picked up by a Cinema Mode /
-trailer pre-roll plugin.
+A Jellyfin plugin that automatically downloads movie and TV show trailers from TMDB/YouTube and
+packages each one as a self-contained "fake movie" folder, ready to be picked up by a Cinema
+Mode / trailer pre-roll plugin. It can also act as a Cinema Mode pre-roll source itself, via
+Jellyfin's `IIntroProvider` interface (compatible with Wholphin and similar clients).

 ## How it works

-1. A daily scheduled task fetches candidate movies from TMDB (Now Playing, Upcoming, Popular,
-   Top Rated — configurable), optionally skipping movies already in your library.
+### Downloading trailers
+
+1. A daily scheduled task fetches candidate movies and/or TV shows from TMDB (Now Playing,
+   Upcoming, Popular, Top Rated for movies; Airing Today, On The Air, Popular, Top Rated for TV
+   shows — all configurable), optionally skipping titles already in your library.
 2. For each candidate, it fetches the official trailer(s) from TMDB, which point to YouTube.
 3. It downloads the trailer video and builds a folder for it:
   ```
   {OutputFolder}/
-     {Movie Title} ({Year})/
-       {Movie Title} ({Year}).mp4          ← placeholder "fake movie" (copy of a master file)
-       {Movie Title} ({Year})-trailer.mp4  ← the actual downloaded trailer
-       {Movie Title} ({Year}).nfo          ← minimal NFO (title, year, locked metadata)
+     {Title} ({Year})/
+       {Title} ({Year}).mp4          ← placeholder "fake movie" (copy of a master file)
+       {Title} ({Year})-trailer.mp4  ← the actual downloaded trailer
+       {Title} ({Year}).nfo          ← minimal NFO (title, year, genres, rating, locked metadata)
   ```
+   TV show trailers are tagged (`<tag>ct4j-tvshow</tag>`) in their NFO so they can be told apart
+   from movie trailers.
 4. Jellyfin scans the placeholder file as a normal movie (its metadata locked via the NFO so
-   it never queries TMDB for it) and picks up the adjacent `-trailer.mp4` as that movie's
+   it never queries TMDB for it) and picks up the adjacent `-trailer.mp4` as that item's
   local trailer — which a Cinema Mode / trailer pre-roll plugin can then play.

 The placeholder "fake movie" is a few seconds of black video with silent audio — just enough
 for Jellyfin to treat the file as a valid video. It's generated once via `ffmpeg` and reused
 by copying, not regenerated for every trailer.

+Movie and TV show downloads each have their own TMDB sources and their own "max trailers per
+run" setting — set either to 0 to skip that category entirely.
+
+### Playing trailers (Cinema Mode integration)
+
+The plugin also registers as an `IIntroProvider`, so Jellyfin clients with cinema mode support
+(and clients like Wholphin) can play the downloaded trailers as pre-rolls directly, without a
+separate trailer plugin:
+
+- Before a **movie**, it injects movie trailers from the output folder.
+- Before a **TV episode** (if enabled), it injects TV show trailers — but only before the first
+  episode a user watches each day. If you binge several episodes in one sitting, only the first
+  one gets trailers; the next day it resets.
+- Movie and TV trailers are kept in separate pools, so movies only ever get movie trailers and
+  episodes only ever get TV show trailers.
+- Optional filters can restrict trailers to those matching the genre and/or age rating of the
+  movie/show you're about to watch (falling back to the full pool if nothing matches), and an
+  "avoid repeats" mode cycles through all trailers before repeating any.
+
+The output folder still needs to be added as a Jellyfin **Movies** library and scanned for any
+of this to work, since that's how Jellyfin discovers the trailer files in the first place.
+
+#### Pre-roll bumpers
+
+Optionally, you can also bookend the trailer block with bumper videos picked at random from
+your own existing Jellyfin **Movies** libraries:
+
+- **Trailer Pre-Roll**: plays *before* the trailer block (e.g. a "Now Playing" bumper).
+- **Feature Pre-Roll**: plays *after* the trailer block, right before the movie/episode itself
+  (e.g. a "Feature Presentation" bumper).
+
+Each is independent, disabled by default, and picks a plain random `Movie` item from the
+configured library every time (no genre/rating filtering or repeat-avoidance).
+
 ## Requirements

 - Jellyfin 10.11+
@@ -58,15 +98,24 @@ Go to **Admin → Plugins → CinemaTrailers4Jellyfins**.
 |---|---|
 | **TMDB API Key** | Your TMDB Read Access Token (JWT) or v3 API key |
 | **Trailer Languages** | Restrict downloads to specific trailer languages |
-| **Trailer Sources** | Which TMDB lists to pull candidates from (Now Playing, Upcoming, Popular, Top Rated) |
-| **Date Range** | Only consider movies released within the last N months |
+| **Movie Trailer Sources** | Which TMDB lists to pull movie candidates from (Now Playing, Upcoming, Popular, Top Rated) |
+| **TV Show Trailer Sources** | Which TMDB lists to pull TV show candidates from (Airing Today, On The Air, Popular, Top Rated) |
+| **Date Range** | Only consider titles released (or first-aired) within the last N months |
 | **Output Folder** | Where the fake-movie folders are created |
-| **Max trailers per run** | How many trailers to download per task run |
+| **Max movie trailers per run** | How many movie trailers to download per task run. 0 = don't download movie trailers |
+| **Max TV show trailers per run** | How many TV show trailers to download per task run. 0 = don't download TV show trailers |
 | **Pages per source** | How many TMDB pages to fetch per source |
 | **Video quality** | 720p / 480p (built-in) or 1080p (requires yt-dlp) |
-| **Skip movies already in my Jellyfin library** | Don't download trailers for movies you already own |
+| **Skip movies/shows already in my Jellyfin library** | Don't download trailers for movies/shows you already own |
 | **Skip trailers already downloaded** | Don't re-download a trailer if its folder already exists |
 | **Max trailers to keep** | Oldest trailer folders are deleted first once this cap is exceeded |
+| **Trailers per movie** | How many trailers to play before each item via Cinema Mode (`IIntroProvider`). 0 = disabled |
+| **Match genre to the movie being played** | Only pick trailers whose genre overlaps with what you're about to watch |
+| **Limit to same age rating or lower** | Never play a trailer rated higher than what you're about to watch |
+| **Avoid repeating trailers** | Cycle through all available trailers before repeating any |
+| **Also play trailers before TV episodes** | Plays before only the first episode a user watches each day |
+| **Trailer Pre-Roll library** | Movie library to pick a random "Now Playing" style bumper from, played before the trailer block. None = disabled |
+| **Feature Pre-Roll library** | Movie library to pick a random "Feature Presentation" style bumper from, played after the trailer block. None = disabled |
 | **yt-dlp path** | Optional path to `yt-dlp` for 1080p+ downloads |

 ## Running the task
@@ -75,7 +124,8 @@ After configuring, go to **Admin → Scheduled Tasks → CinemaTrailers4Jellyfin
 to do an immediate download pass. The task then runs automatically once per day.

 After the task completes, add the output folder as a Jellyfin **Movies** library (and run a
-library scan) so your Cinema Mode / trailer pre-roll plugin can use the trailers.
+library scan) so your Cinema Mode / trailer pre-roll plugin (or this plugin's own
+`IIntroProvider`) can use the trailers.

 ## Building from source

--- a/build.yaml
+++ b/build.yaml
@@ -1,5 +1,5 @@
 ---
-version: 1.0.0.3
+version: 1.0.0.17
 name: CinemaTrailers4Jellyfins
 guid: b581493e-1046-40ed-b6dc-cb8027624984
 description: >
@@ -12,10 +12,14 @@ category: General
 owner: 514mart
 targetAbi: 10.11.0.0
 changelog:
-  - Add trailer selection filters — genre match, age rating ceiling, and avoid-repeats
-    cycle; genre and rating are written to each fake-movie NFO at download time from
-    TMDB so Jellyfin can use them for filtering; filters fall back to random when no
-    match is found
+  - New "Discover" source for TV shows (on by default) and movies (off by
+    default). It asks TMDB for the newest titles in your selected
+    languages, most popular first. The TV lists (Popular, Top Rated, On The
+    Air, Airing Today) are mostly long-running shows that the date range
+    drops, so very few TV trailers were found before
+  - When yt-dlp fails (often a passing HTTP 403 from YouTube), it is tried
+    once more after 15 seconds before the built-in downloader takes over,
+    which YouTube sometimes only offers 360p

 dotnetProjects:
  - name: Jellyfin.Plugin.CinemaTrailers4Jellyfins
--- a/manifest.json
+++ b/manifest.json
@@ -8,6 +8,118 @@
        "owner": "514mart",
        "imageUrl": "https://www.git.quarantinedstudio.com/mvezina/CinemaTrailers4Jellyfins/raw/branch/main/Jellyfin.Plugin.CinemaTrailers4Jellyfins/Images/logo.svg",
        "versions": [
+            {
+                "checksum": "5329a3a0daf9f82849b441ca2784f622",
+                "changelog": "- 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\n",
+                "targetAbi": "10.11.0.0",
+                "sourceUrl": "https://www.git.quarantinedstudio.com/mvezina/CinemaTrailers4Jellyfins/releases/download/v1.0.0.16/cinematrailers4jellyfins_1.0.0.16.zip",
+                "timestamp": "2026-10-06T01:40:16Z",
+                "version": "1.0.0.16"
+            },
+            {
+                "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",
+                "targetAbi": "10.11.0.0",
+                "sourceUrl": "https://www.git.quarantinedstudio.com/mvezina/CinemaTrailers4Jellyfins/releases/download/v1.0.0.10/cinematrailers4jellyfins_1.0.0.10.zip",
+                "timestamp": "2026-10-05T21:42:55Z",
+                "version": "1.0.0.10"
+            },
+            {
+                "checksum": "9594d14a5fed94ee5eea55d72c71728c",
+                "changelog": "- Skip trailers and pre-roll/feature pre-roll bumpers the current user can't actually access (e.g. a library not in their library access list) \u2014 some Cinema Mode clients hang indefinitely trying to play an inaccessible item, so these are now filtered out per-user instead\n",
+                "targetAbi": "10.11.0.0",
+                "sourceUrl": "https://www.git.quarantinedstudio.com/mvezina/CinemaTrailers4Jellyfins/releases/download/v1.0.0.9/cinematrailers4jellyfins_1.0.0.9.zip",
+                "timestamp": "2026-06-10T17:07:24Z",
+                "version": "1.0.0.9"
+            },
+            {
+                "checksum": "89c66caa789da56ead7d60e01d3207a5",
+                "changelog": "- Fix Trailer Pre-Roll / Feature Pre-Roll bumpers not being found \u2014 the library lookup now walks the configured library folder's children directly instead of relying on TopParentIds matching, which could fail to match movies even when they appear correctly in the library\n",
+                "targetAbi": "10.11.0.0",
+                "sourceUrl": "https://www.git.quarantinedstudio.com/mvezina/CinemaTrailers4Jellyfins/releases/download/v1.0.0.8/cinematrailers4jellyfins_1.0.0.8.zip",
+                "timestamp": "2026-06-10T15:28:02Z",
+                "version": "1.0.0.8"
+            },
+            {
+                "checksum": "a52f1354c9737cf9ec92f588bb4e750e",
+                "changelog": "- Add Information-level diagnostic logging to IIntroProvider.GetIntros \u2014 logs every call (item, path, and which features are enabled), why an item is skipped, and the outcome of Trailer/Feature Pre-Roll lookups, to help troubleshoot why a pre-roll bumper isn't playing\n",
+                "targetAbi": "10.11.0.0",
+                "sourceUrl": "https://www.git.quarantinedstudio.com/mvezina/CinemaTrailers4Jellyfins/releases/download/v1.0.0.7/cinematrailers4jellyfins_1.0.0.7.zip",
+                "timestamp": "2026-06-10T15:10:56Z",
+                "version": "1.0.0.7"
+            },
+            {
+                "checksum": "96e0624e5173e5e6bf829d47118e1b40",
+                "changelog": "- Add diagnostic logging for Trailer Pre-Roll and Feature Pre-Roll bumpers \u2014 logs a warning if the configured library ID is invalid, and a debug message when no eligible movie is found or which movie was picked, to help troubleshoot why a bumper isn't playing\n",
+                "targetAbi": "10.11.0.0",
+                "sourceUrl": "https://www.git.quarantinedstudio.com/mvezina/CinemaTrailers4Jellyfins/releases/download/v1.0.0.6/cinematrailers4jellyfins_1.0.0.6.zip",
+                "timestamp": "2026-06-10T14:35:52Z",
+                "version": "1.0.0.6"
+            },
+            {
+                "checksum": "6c88aaeb38023b327e9b042181dc0708",
+                "changelog": "- Add Trailer Pre-Roll and Feature Pre-Roll bumpers via IIntroProvider \u2014 pick existing Jellyfin Movie libraries in settings and a random movie from each is played before the trailer block (\"Now Playing\") and/or right before the feature (\"Feature Presentation\"); both are independent and disabled by default\n",
+                "targetAbi": "10.11.0.0",
+                "sourceUrl": "https://www.git.quarantinedstudio.com/mvezina/CinemaTrailers4Jellyfins/releases/download/v1.0.0.5/cinematrailers4jellyfins_1.0.0.5.zip",
+                "timestamp": "2026-06-10T05:14:23Z",
+                "version": "1.0.0.5"
+            },
+            {
+                "checksum": "af6051b002939e4e5cd6ef4baf5c85d4",
+                "changelog": "- Add TV show trailer downloads \u2014 separate TMDB sources (Airing Today, On The Air, Popular, Top Rated) and a \"Max TV show trailers per run\" cap independent from movies; set either cap to 0 to skip that category entirely\n- Add trailers before TV episodes via IIntroProvider \u2014 only the first episode a user watches each day gets trailers, picked using the show's genre/rating for filtering\n- Movie and TV trailers are now kept separate \u2014 movies only ever get movie trailers and episodes only ever get TV show trailers, via a tag written to each trailer's NFO at download time\n",
+                "targetAbi": "10.11.0.0",
+                "sourceUrl": "https://www.git.quarantinedstudio.com/mvezina/CinemaTrailers4Jellyfins/releases/download/v1.0.0.4/cinematrailers4jellyfins_1.0.0.4.zip",
+                "timestamp": "2026-06-10T04:42:17Z",
+                "version": "1.0.0.4"
+            },
+            {
+                "checksum": "d43b8d007051d04984d9395d29bc306f",
+                "changelog": "- Add trailer selection filters \u2014 genre match, age rating ceiling, and avoid-repeats cycle; genre and rating are written to each fake-movie NFO at download time from TMDB so Jellyfin can use them for filtering; filters fall back to random when no match is found\n",
+                "targetAbi": "10.11.0.0",
+                "sourceUrl": "https://www.git.quarantinedstudio.com/mvezina/CinemaTrailers4Jellyfins/releases/download/v1.0.0.3/cinematrailers4jellyfins_1.0.0.3.zip",
+                "timestamp": "2026-06-09T21:16:16Z",
+                "version": "1.0.0.3"
+            },
            {
                "checksum": "0259ff74b5e12089c45b8823d6ff6a19",
                "changelog": "- Add IIntroProvider support \u2014 downloaded trailers now play as pre-rolls before movies in Jellyfin clients with cinema mode (Wholphin, etc.); configurable trailers-per-movie count; recursion-safe so the intro items themselves never trigger a second round of intro injection\n",
Author	SHA1	Message	Date
Martin	1de082b96e	feat: TMDB Discover source + retry yt-dlp once before fallback (v1.0.0.17) All checks were successful Publish Release / release (push) Successful in 14s Details The fixed TV lists are mostly long-running shows whose first_air_date is outside ReleaseDateRangeMonths, and paging stops at the first page with no in-range title, so only ~7 TV candidates were found (5 then dropped by language). Add a "discover" source per media type that asks /discover for recent titles in AllowedLanguages, sorted by popularity (1600+ TV results for en\|fr today). TV Discover defaults on, movie Discover off. yt-dlp failures were mostly passing HTTP 403s from back-to-back requests; the built-in fallback is sometimes only offered 360p. Retry yt-dlp once after 15s before falling back. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-06 00:00:32 -04:00
gitea-actions	45405c815d	chore: update manifest.json for v1.0.0.16	2026-10-06 01:40:16 +00:00
Martin	d6280f3ce8	fix: built-in downloader prefers separate streams over 360p muxed (v1.0.0.16) All checks were successful Publish Release / release (push) Successful in 24s Details 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>	2026-10-05 21:39:49 -04:00
gitea-actions	43e002fcdd	chore: update manifest.json for v1.0.0.15	2026-10-05 22:28:03 +00:00
Martin	fb75fa5a07	fix: language filter also checks the title's original language (v1.0.0.15) All checks were successful Publish Release / release (push) Successful in 9s Details AllowedLanguages only filtered on each video's iso_639_1 tag, and TMDB often tags subtitled foreign trailers as "en". With en,fr selected, 6 of 27 downloaded trailers were Korean, Chinese or Zulu titles. Candidates now also need an allowed original_language (from the list results, so no extra API calls). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-05 18:27:50 -04:00
gitea-actions	2664ab4d5a	chore: update manifest.json for v1.0.0.14	2026-10-05 22:19:38 +00:00
Martin	86d8e2a05b	fix: delete yt-dlp partial files when it fails (v1.0.0.14) All checks were successful Publish Release / release (push) Successful in 11s Details yt-dlp removes its separate video/audio files after a successful merge, but a failed run (e.g. HTTP 403 mid-download) left "<name>.f137.mp4.part" etc. in the trailer folder, even when the built-in fallback then succeeded. Always remove files sharing the output's "<name>." prefix after yt-dlp runs. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-05 18:19:24 -04:00
gitea-actions	c013416473	chore: update manifest.json for v1.0.0.13	2026-10-05 22:11:03 +00:00
Martin	e43e3f7245	fix(build): quote-safe changelog line for v1.0.0.13 All checks were successful Publish Release / release (push) Successful in 11s Details "Fix a possible hang: ..." has ": " inside a plain YAML scalar, which PyYAML reads as a mapping key, so update_manifest.py failed in CI. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-05 18:10:49 -04:00
Martin	4145e1f1dd	feat: yt-dlp prefers H.264, falls back to built-in, no pipe hang (v1.0.0.13) Some checks failed Publish Release / release (push) Failing after 8s Details - Format string prefers avc1 video + m4a audio, then any codec. The RTX 2070 host can hardware-transcode H.264 but not AV1. - Pass Jellyfin's ffmpeg via --ffmpeg-location instead of relying on PATH. - If yt-dlp fails, retry with the built-in YoutubeExplode downloader. - Read stdout/stderr while yt-dlp runs (and add --no-progress); before, stdout was never read, so a full pipe buffer could block yt-dlp forever. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-05 18:01:33 -04:00
gitea-actions	6002ce7b46	chore: update manifest.json for v1.0.0.12	2026-10-05 21:57:24 +00:00
Martin	d850e12964	feat: restrict anime trailers, not all animation (v1.0.0.12) All checks were successful Publish Release / release (push) Successful in 9s Details v1.0.0.11 kept every animated trailer away from non-animated content, which also blocked Western animation (Pixar, Disney...). Only anime should be restricted. At download, a trailer is tagged ct4j-anime when TMDB has the "anime" or "based on manga" keyword, or it is Animation in ja/zh/ko (keywords are now appended to the details request). At playback, anime trailers are dropped unless the feature is anime (genre "Anime", or those keywords as tags). Western animation follows the normal genre/rating filters again. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-05 17:57:12 -04:00
gitea-actions	205d64dc6f	chore: update manifest.json for v1.0.0.11	2026-10-05 21:52:47 +00:00
Martin	322d6cc65d	feat: only play animated trailers before animated content (v1.0.0.11) All checks were successful Publish Release / release (push) Successful in 10s Details An anime trailer could play before live-action content: the genre filter accepts any single shared genre (anime is tagged Animation + Drama/Action/...), and when nothing matched it fell back to the whole pool. Trailers tagged Animation or Anime are now dropped for non-animated features before the filters and the fallback run, so a live-action feature gets no trailer rather than an animated one. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-05 17:52:33 -04:00
gitea-actions	c208a81b75	chore: update manifest.json for v1.0.0.10	2026-10-05 21:42:55 +00:00
Martin	5176582391	fix: download trailers as separate video+audio and merge with ffmpeg (v1.0.0.10) All checks were successful Publish Release / release (push) Successful in 26s Details YouTube stopped serving muxed streams and YoutubeExplode 6.6.0 failed on every video ("Video is not available"), so no trailer downloaded. Bump YoutubeExplode to 6.6.2, download the best video-only + audio-only streams and stream-copy them into one MP4 with ffmpeg. The separate files are always deleted afterwards, merge or not. Also delete the trailer folder when a download fails. Empty folders were treated as "already downloaded" (never retried) and counted toward MaxTotalTrailers, so over time they pushed out every real trailer. The skip check now requires the trailer file itself. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-05 17:42:28 -04:00
gitea-actions	e518b79c36	chore: update manifest.json for v1.0.0.9	2026-06-10 17:07:24 +00:00
Martin	6bb23dc9c4	feat: skip trailers/pre-rolls inaccessible to the current user (v1.0.0.9) All checks were successful Publish Release / release (push) Successful in 12s Details Filters trailer pool items and pre-roll/feature pre-roll bumpers using BaseItem.IsVisibleStandalone(user), so users without access to the relevant library are never handed an item they can't actually play — some Cinema Mode clients hang indefinitely in that case.	2026-06-10 13:07:11 -04:00
gitea-actions	5f7a76feb5	chore: update manifest.json for v1.0.0.8	2026-06-10 15:28:02 +00:00
Martin	adfa570569	fix: pre-roll/feature pre-roll bumpers not found in library (v1.0.0.8) All checks were successful Publish Release / release (push) Successful in 8s Details TopParentIds-based queries could fail to match Movie items in the configured pre-roll library even when they appear correctly in the Jellyfin UI. Look up the library Folder by ID and walk its recursive children directly instead, matching the path-based approach already used for the trailer pool.	2026-06-10 11:27:52 -04:00
gitea-actions	99798b5174	chore: update manifest.json for v1.0.0.7	2026-06-10 15:10:56 +00:00
Martin	c76ddbc352	chore: trace GetIntros calls and outcomes at Information level (v1.0.0.7) All checks were successful Publish Release / release (push) Successful in 10s Details Logs every GetIntros call (item, path, enabled features), why an item is skipped, and pre-roll/post-roll lookup outcomes, without depending on a Debug logging.json override.	2026-06-10 11:09:48 -04:00
gitea-actions	e9d9543941	chore: update manifest.json for v1.0.0.6	2026-06-10 14:35:52 +00:00
Martin	ba56926dc2	chore: add diagnostic logging for pre-roll bumpers (v1.0.0.6) All checks were successful Publish Release / release (push) Successful in 13s Details Helps diagnose why a Trailer Pre-Roll/Feature Pre-Roll bumper isn't playing by logging invalid library IDs, empty library results, and the movie picked.	2026-06-10 10:35:33 -04:00
gitea-actions	2ef39853eb	chore: update manifest.json for v1.0.0.5	2026-06-10 05:14:23 +00:00
Martin	a0bddac48d	feat: add Trailer Pre-Roll and Feature Pre-Roll bumpers All checks were successful Publish Release / release (push) Successful in 14s Details Adds two optional IIntroProvider bumper slots, mirroring CherryFloors' cinema mode plugin: a "Trailer Pre-Roll" played before the trailer block and a "Feature Pre-Roll" played right before the movie/episode. Each is configured by picking an existing Jellyfin Movie library, from which a random Movie is injected as the bumper. Bump version to 1.0.0.5. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-06-10 01:13:52 -04:00
gitea-actions	18c3c49a26	chore: update manifest.json for v1.0.0.4	2026-06-10 04:42:17 +00:00
Martin	f49c32f181	feat: add TV show trailer downloads, episode trailers, and movie/TV trailer separation All checks were successful Publish Release / release (push) Successful in 23s Details - Download trailers for TV shows from TMDB with separate sources and an independent max-count cap (0 disables a category) - Play trailers before TV episodes via IIntroProvider, limited to the first episode a user watches each day - Tag TV show trailers in their NFO so movies only get movie trailers and episodes only get TV show trailers Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-06-10 00:41:37 -04:00
gitea-actions	f769e33b8d	chore: update manifest.json for v1.0.0.3	2026-06-09 21:16:16 +00:00