feat: warn on uncertain episode availability

internal/playback/handler/watch_page_test.go

@@ -106,3 +106,32 @@ func TestHandleWatchPagePreservesPartialDataOnPlaybackFailure(t *testing.T) {
 		t.Fatalf("expected partial episode list instead of empty state, got:\n%s", body)
 	}
 }
+
+func TestHandleWatchPageRendersEpisodeAvailabilityWarningModal(t *testing.T) {
+	t.Parallel()
+
+	data := baseWatchPageData()
+	data.EpisodeAvailabilityWarning = "Episode availability may be incomplete or out of date. Continue only if you understand that the episode list and audio availability may be uncertain."
+	router := newWatchPageRouter(t, &PlaybackHandler{
+		svc: &watchPagePlaybackService{data: data},
+	})
+
+	req := httptest.NewRequestWithContext(context.Background(), http.MethodGet, "/anime/123/watch?ep=1", nil)
+	rec := httptest.NewRecorder()
+	router.ServeHTTP(rec, req)
+
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status = %d, want %d", rec.Code, http.StatusOK)
+	}
+	body := rec.Body.String()
+	for _, want := range []string{
+		`data-episode-availability-warning`,
+		`Episode availability is uncertain`,
+		`Continue anyway`,
+		data.EpisodeAvailabilityWarning,
+	} {
+		if !strings.Contains(body, want) {
+			t.Fatalf("watch page missing %q in body:\n%s", want, body)
+		}
+	}
+}

internal/playback/watch_data.go

@@ -6,12 +6,15 @@ import (
 	"sort"
 	"strconv"
 	"strings"
+	"time"
 
 	"mal/integrations/jikan"
 	"mal/internal/domain"
 	"mal/internal/observability"
 )
 
+const episodeAvailabilityUncertainWarning = "Episode availability may be incomplete or out of date. Continue only if you understand that the episode list and audio availability may be uncertain."
+
 func (s *playbackService) BuildWatchData(ctx context.Context, animeID int, titleCandidates []string, episode string, mode string, userID string) (domain.WatchPageData, error) {
 	anime, err := s.jikan.GetAnimeByID(ctx, animeID)
 	if err != nil {
@@ -51,6 +54,7 @@ func (s *playbackService) BuildWatchData(ctx context.Context, animeID int, title
 	}
 	watchData := buildWatchDataPayload(animeData, animeID, episode, startTime, eps.Episodes, modeSources, mode, from, segments)
 	pageData := buildWatchPageData(animeData, eps.Episodes, episode, watchlistStatus, watchlistIDs, seasons, watchData)
+	pageData.EpisodeAvailabilityWarning = episodeAvailabilityWarning(eps, time.Now())
 	if len(modeSources) == 0 {
 		return pageData, fmt.Errorf("no streams found")
 	}
@@ -96,6 +100,23 @@ func buildWatchPageData(anime domain.Anime, episodes []domain.CanonicalEpisode,
 	}
 }
 
+func episodeAvailabilityWarning(episodeList domain.CanonicalEpisodeList, now time.Time) string {
+	if episodeList.FailureCount > 0 {
+		return episodeAvailabilityUncertainWarning
+	}
+	if episodeList.NextRefreshAt == "" {
+		return ""
+	}
+	nextRefresh, err := time.Parse(time.RFC3339, episodeList.NextRefreshAt)
+	if err != nil {
+		return ""
+	}
+	if nextRefresh.After(now) {
+		return ""
+	}
+	return episodeAvailabilityUncertainWarning
+}
+
 func buildSearchTitles(anime domain.Anime, titleCandidates []string) []string {
 	seen := map[string]struct{}{}
 	out := make([]string, 0, 3+len(anime.TitleSynonyms)+len(titleCandidates))

internal/playback/watch_data_test.go

@@ -1,7 +1,9 @@
 package playback
 
 import (
+	"mal/internal/domain"
 	"testing"
+	"time"
 )
 
 func TestFallbackModes(t *testing.T) {
@@ -33,3 +35,57 @@ func TestFallbackModes(t *testing.T) {
 		})
 	}
 }
+
+func TestEpisodeAvailabilityWarning(t *testing.T) {
+	now := time.Date(2026, time.June, 27, 11, 0, 0, 0, time.UTC)
+	tests := []struct {
+		name string
+		list domain.CanonicalEpisodeList
+		want string
+	}{
+		{
+			name: "fresh availability does not warn",
+			list: domain.CanonicalEpisodeList{
+				Episodes:      []domain.CanonicalEpisode{{Number: 1, HasSub: true}},
+				LastSuccessAt: "2026-06-27T10:00:00Z",
+				NextRefreshAt: "2026-06-27T12:00:00Z",
+			},
+		},
+		{
+			name: "stale availability warns",
+			list: domain.CanonicalEpisodeList{
+				Episodes:      []domain.CanonicalEpisode{{Number: 1, HasSub: true}},
+				LastSuccessAt: "2026-06-27T09:00:00Z",
+				NextRefreshAt: "2026-06-27T10:00:00Z",
+			},
+			want: episodeAvailabilityUncertainWarning,
+		},
+		{
+			name: "retrying availability warns",
+			list: domain.CanonicalEpisodeList{
+				Episodes:      []domain.CanonicalEpisode{{Number: 1, HasSub: true}},
+				NextRefreshAt: "2026-06-27T11:05:00Z",
+				RetryUntilAt:  "2026-06-27T11:30:00Z",
+				FailureCount:  1,
+			},
+			want: episodeAvailabilityUncertainWarning,
+		},
+		{
+			name: "failed availability warns",
+			list: domain.CanonicalEpisodeList{
+				Episodes:     []domain.CanonicalEpisode{{Number: 1, HasSub: true}},
+				FailureCount: 3,
+			},
+			want: episodeAvailabilityUncertainWarning,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := episodeAvailabilityWarning(tt.list, now)
+			if got != tt.want {
+				t.Fatalf("episodeAvailabilityWarning() = %q, want %q", got, tt.want)
+			}
+		})
+	}
+}