@serifpersia/dango 3.3.4

package/server/dist/lib/anilist.js

@@ -0,0 +1,1549 @@
+import logger from '../logger.js';
+import { parseJsonBody } from '../utils/http.utils.js';
+import { findTmdbDefaultBackdrop } from './tmdb.js';
+import { getScheduleFromAniSchedule, getAiredEpisodesFromAniScheduleFeed, withScheduleFields, } from './anischedule.js';
+import { kitsuSearchAnime, kitsuTrending, kitsuSeasonal, kitsuSpotlight, kitsuLatestReleases, kitsuMetaByAnilistId, kitsuMetaByMalId, kitsuEpisodes, } from './kitsu.js';
+import { malSearchMedia, malSeasonal, malTop, malLatestReleases, malSearchAnime, malAnimeDetail, enrichEnglishFromMalDetail, EN_TITLE_CACHE_PREFIX, toAnilistSearchMedia, toAnilistDetailMedia, } from './mal.js';
+import { malCacheStore } from '../repositories/mal-cache.repository.js';
+import { offlineDb } from './offline-db.js';
+const ANILIST_API = 'https://graphql.anilist.co';
+let anilistDownUntil = 0;
+let anilistRateLimited = false;
+let anilistWasDownAtBoot = false;
+const DOWN_COOLDOWN_MS = 10 * 60 * 1000;
+const NETWORK_COOLDOWN_MS = 2 * 60 * 1000;
+const RATE_LIMIT_FALLBACK_THRESHOLD_MS = 30 * 1000;
+export function anilistUnavailable() {
+    if (anilistDownUntil > Date.now())
+        return true;
+    if (anilistRateLimited && anilistCooldownUntil - Date.now() > RATE_LIMIT_FALLBACK_THRESHOLD_MS) {
+        return true;
+    }
+    return false;
+}
+export function anilistIsDown() {
+    return anilistDownUntil > Date.now();
+}
+export function isAnilistRateLimited() {
+    return anilistRateLimited && anilistCooldownUntil > Date.now();
+}
+export function markAnilistDownAtBoot() {
+    anilistWasDownAtBoot = anilistUnavailable();
+}
+export async function checkAnilistStatus() {
+    const available = await performAnilistStatusCheck();
+    if (!available) {
+        anilistWasDownAtBoot = true;
+    }
+    return available;
+}
+async function performAnilistStatusCheck() {
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 5000);
+        const response = await fetch(ANILIST_API, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+            body: JSON.stringify({ query: 'query { __typename }' }),
+            signal: controller.signal,
+        });
+        clearTimeout(timer);
+        const available = response.ok;
+        if (!available) {
+            anilistDownUntil = Date.now() + DOWN_COOLDOWN_MS;
+            anilistRateLimited = false;
+        }
+        else {
+            anilistDownUntil = 0;
+            anilistRateLimited = false;
+        }
+        return available;
+    }
+    catch {
+        anilistDownUntil = Date.now() + DOWN_COOLDOWN_MS;
+        anilistRateLimited = false;
+        return false;
+    }
+}
+export function wasAnilistDownAtBoot() {
+    return anilistWasDownAtBoot;
+}
+const BURST_CAPACITY = 8;
+const DEFAULT_REFILL_INTERVAL_MS = 1500;
+let refillIntervalMs = DEFAULT_REFILL_INTERVAL_MS;
+let tokens = BURST_CAPACITY;
+let lastRefill = Date.now();
+let anilistCooldownUntil = 0;
+function refillTokens() {
+    const now = Date.now();
+    if (now < lastRefill)
+        return;
+    const elapsed = now - lastRefill;
+    const refillAmount = Math.floor(elapsed / refillIntervalMs);
+    if (refillAmount > 0) {
+        tokens = Math.min(BURST_CAPACITY, tokens + refillAmount);
+        lastRefill += refillAmount * refillIntervalMs;
+    }
+}
+export function applyRateLimitHeaders(headers) {
+    const readHeader = (name) => {
+        const raw = headers.get(name);
+        if (raw === null || raw === '')
+            return null;
+        const value = Number.parseInt(raw, 10);
+        return Number.isFinite(value) && value >= 0 ? value : null;
+    };
+    const limit = readHeader('X-RateLimit-Limit');
+    const remaining = readHeader('X-RateLimit-Remaining');
+    if (limit !== null && limit > 0) {
+        const reserve = Math.max(1, Math.round(limit * 0.2));
+        const safeRate = Math.max(1, limit - reserve);
+        refillIntervalMs = Math.max(300, Math.min(60000, Math.round(60000 / safeRate)));
+    }
+    if (remaining !== null && remaining <= 2) {
+        const reset = readHeader('X-RateLimit-Reset');
+        if (reset !== null) {
+            const resetMs = reset * 1000;
+            if (resetMs > Date.now()) {
+                anilistCooldownUntil = Math.max(anilistCooldownUntil, resetMs);
+            }
+        }
+    }
+}
+const anilistMemoryCache = new Map();
+const ANILIST_MEMORY_TTL = 60 * 60 * 1000;
+const airedEpisodesCache = new Map();
+const AIRED_EPISODES_TTL = 60 * 60 * 1000;
+const inFlightAnilistRequests = new Map();
+export function mediaFields() {
+    return `
+    id
+    idMal
+    title { romaji english native }
+    bannerImage
+    coverImage { extraLarge large medium color }
+    description
+    genres
+    averageScore
+    meanScore
+    format
+    status
+    episodes
+    duration
+    season
+    seasonYear
+    startDate { year month day }
+    endDate { year month day }
+    countryOfOrigin
+    isAdult
+    synonyms
+    trending
+    popularity
+    favourites
+    tags { id name rank isMediaSpoiler }
+    studios(isMain: true) { nodes { id name } }
+    nextAiringEpisode { episode timeUntilAiring airingAt }
+    trailer { id site thumbnail }
+    rankings { id rank type format allTime context }
+    siteUrl
+  `;
+}
+export function mediaFieldsLight() {
+    return `
+    id
+    title { romaji english native }
+    coverImage { extraLarge large }
+    status
+    averageScore
+    episodes
+    seasonYear
+    season
+    genres
+    isAdult
+    format
+    nextAiringEpisode { episode }
+  `;
+}
+async function tryFallback(malFn, kitsuFn) {
+    for (const fn of [malFn, kitsuFn]) {
+        try {
+            const result = await fn();
+            if (result && result.length > 0)
+                return result;
+        }
+        catch {
+            // ignore
+        }
+    }
+    return [];
+}
+function mapFallbackResults(fb) {
+    const seen = new Set();
+    const results = [];
+    for (const m of fb) {
+        if (!m.id || seen.has(m.id))
+            continue;
+        seen.add(m.id);
+        results.push(fromAnilistMedia(m));
+    }
+    return results;
+}
+export async function getBatchedHomeData(format) {
+    const now = new Date();
+    const year = now.getFullYear();
+    const month = now.getMonth() + 1;
+    const currentSeason = month <= 3 ? 'WINTER' : month <= 6 ? 'SPRING' : month <= 9 ? 'SUMMER' : 'FALL';
+    const formatVar = format && format !== 'ALL' ? format.toUpperCase() : undefined;
+    const formatFilter = formatVar ? `format: $seasonFormat,` : '';
+    const query = `
+    query ($season: MediaSeason, $seasonYear: Int, $seasonFormat: MediaFormat) {
+      trending: Page(perPage: 20) {
+        media(sort: TRENDING_DESC, type: ANIME, isAdult: false, status: RELEASING) {
+          ${mediaFieldsLight()}
+        }
+      }
+      seasonal: Page(perPage: 14) {
+        media(season: $season, seasonYear: $seasonYear, type: ANIME, isAdult: false, ${formatFilter} sort: [POPULARITY_DESC, SCORE_DESC]) {
+          ${mediaFieldsLight()}
+        }
+      }
+      spotlight: Page(perPage: 20) {
+        media(sort: TRENDING_DESC, type: ANIME, isAdult: false) {
+          ${mediaFields()}
+        }
+      }
+    }
+  `;
+    const result = await anilistRequest(query, { season: currentSeason, seasonYear: year, seasonFormat: formatVar });
+    if (!result?.data) {
+        if (!anilistUnavailable())
+            return { trending: [], seasonal: [], spotlight: [] };
+        try {
+            const [trending, seasonal, spotlight] = await Promise.all([
+                tryFallback(() => malTop(malCacheStore(), 'airing', 1).then((m) => m.map(fromAnilistMedia)), () => kitsuTrending(1, 20).then((m) => m.map(fromAnilistMedia))),
+                tryFallback(() => malSeasonal(malCacheStore(), currentSeason, year, formatVar, 1, 14).then((m) => m.map(fromAnilistMedia)), () => kitsuSeasonal(currentSeason, year, formatVar, 1, 14).then((m) => m.map(fromAnilistMedia))),
+                tryFallback(() => malTop(malCacheStore(), 'airing', 1).then((m) => m.map(fromAnilistMedia)), () => kitsuSpotlight(1, 20).then((m) => m.map(fromAnilistMedia))),
+            ]);
+            return { trending, seasonal, spotlight };
+        }
+        catch {
+            return { trending: [], seasonal: [], spotlight: [] };
+        }
+    }
+    return {
+        trending: (result.data.trending?.media ?? []).map(fromAnilistMedia),
+        seasonal: (result.data.seasonal?.media ?? []).map(fromAnilistMedia),
+        spotlight: (result.data.spotlight?.media ?? []).map(fromAnilistMedia),
+    };
+}
+function getAnilistCacheKey(query, variables) {
+    return `${query}:${JSON.stringify(variables || {})}`;
+}
+function getCachedAnilist(key) {
+    const entry = anilistMemoryCache.get(key);
+    if (entry && Date.now() < entry.expiry)
+        return entry.data;
+    anilistMemoryCache.delete(key);
+    return null;
+}
+export function setCachedAnilist(key, data) {
+    anilistMemoryCache.set(key, { data, expiry: Date.now() + ANILIST_MEMORY_TTL });
+}
+function getCachedAiredEpisodes(key) {
+    const entry = airedEpisodesCache.get(key);
+    if (entry && Date.now() < entry.expiry)
+        return entry.data;
+    airedEpisodesCache.delete(key);
+    return null;
+}
+function setCachedAiredEpisodes(key, data) {
+    airedEpisodesCache.set(key, { data, expiry: Date.now() + AIRED_EPISODES_TTL });
+}
+export async function waitForAnilistSlot() {
+    while (true) {
+        const now = Date.now();
+        if (now < anilistCooldownUntil) {
+            await new Promise((resolve) => setTimeout(resolve, anilistCooldownUntil - now));
+            continue;
+        }
+        refillTokens();
+        if (tokens >= 1) {
+            tokens -= 1;
+            return;
+        }
+        await new Promise((resolve) => setTimeout(resolve, refillIntervalMs));
+    }
+}
+async function performAnilistRequest(query, variables, retryCount = 0) {
+    await waitForAnilistSlot();
+    try {
+        const response = await fetch(ANILIST_API, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+            body: JSON.stringify({ query, variables }),
+        });
+        applyRateLimitHeaders(response.headers);
+        if (response.status === 429) {
+            anilistRateLimited = true;
+            if (retryCount >= 5) {
+                return { data: null, errors: [{ message: 'AniList rate limited' }] };
+            }
+            const retryAfterHeader = Number.parseInt(response.headers.get('Retry-After') || '', 10);
+            const retryAfter = Number.isFinite(retryAfterHeader) && retryAfterHeader >= 0 ? retryAfterHeader : 5;
+            const delay = Math.min(retryAfter * 1000, 60000);
+            anilistCooldownUntil = Math.max(anilistCooldownUntil, Date.now() + delay);
+            refillIntervalMs = Math.min(60000, Math.max(refillIntervalMs, 1500) * 1.15);
+            logger.warn({ retryAfter, retryCount }, 'AniList rate limited, retrying');
+            return performAnilistRequest(query, variables, retryCount + 1);
+        }
+        if (response.status === 403 || response.status >= 500) {
+            anilistDownUntil = Date.now() + DOWN_COOLDOWN_MS;
+            anilistRateLimited = false;
+        }
+        else if (response.status >= 200 && response.status < 300) {
+            anilistDownUntil = 0;
+            anilistRateLimited = false;
+        }
+        const json = (await parseJsonBody(response));
+        if (json.errors && !json.data) {
+            logger.warn({ status: response.status, errors: json.errors }, 'AniList request failed');
+        }
+        return { data: json.data ?? null, errors: json.errors };
+    }
+    catch (err) {
+        anilistDownUntil = Math.max(anilistDownUntil, Date.now() + NETWORK_COOLDOWN_MS);
+        logger.error({ err }, 'AniList request error');
+        return null;
+    }
+}
+export function anilistRequest(query, variables) {
+    if (anilistUnavailable()) {
+        return Promise.resolve({ data: null, errors: [{ message: 'AniList unavailable' }] });
+    }
+    const cacheKey = getAnilistCacheKey(query, variables);
+    const existing = inFlightAnilistRequests.get(cacheKey);
+    if (existing)
+        return existing;
+    const request = performAnilistRequest(query, variables);
+    inFlightAnilistRequests.set(cacheKey, request);
+    request.then(() => inFlightAnilistRequests.delete(cacheKey), () => inFlightAnilistRequests.delete(cacheKey));
+    return request;
+}
+const STATIC_GENRES = [
+    'Action',
+    'Adventure',
+    'Comedy',
+    'Drama',
+    'Fantasy',
+    'Horror',
+    'Mahou Shoujo',
+    'Mecha',
+    'Music',
+    'Mystery',
+    'Psychological',
+    'Romance',
+    'Sci-Fi',
+    'Slice of Life',
+    'Sports',
+    'Supernatural',
+    'Thriller',
+];
+let genreTagCache = null;
+const GENRE_TAG_TTL_MS = 24 * 3600 * 1000;
+export async function getGenreTagLists() {
+    if (genreTagCache && Date.now() - genreTagCache.at < GENRE_TAG_TTL_MS) {
+        return { genres: genreTagCache.genres, tags: genreTagCache.tags };
+    }
+    try {
+        const result = await anilistRequest(`query { GenreCollection MediaTagCollection { name isAdult } }`);
+        const genres = result?.data?.GenreCollection?.filter((g) => typeof g === 'string');
+        const tags = (result?.data?.MediaTagCollection ?? [])
+            .filter((t) => t && !t.isAdult && typeof t.name === 'string')
+            .map((t) => t.name);
+        if (genres && genres.length > 0) {
+            genreTagCache = { genres, tags, at: Date.now() };
+            return { genres, tags };
+        }
+    }
+    catch {
+        // ignore
+    }
+    return { genres: STATIC_GENRES, tags: [] };
+}
+function stripHtml(input) {
+    if (!input)
+        return '';
+    return input
+        .replace(/<br\s*\/?>/gi, '\n')
+        .replace(/<[^>]+>/g, '')
+        .replace(/&amp;/g, '&')
+        .replace(/&quot;/g, '"')
+        .replace(/&#0?39;|&apos;/g, "'")
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .trim();
+}
+export function fromAnilistMedia(m) {
+    const id = m.id < 0 ? `mal-${Math.abs(m.id)}` : m.id.toString();
+    const title = m.title;
+    const name = title?.romaji || title?.english || title?.native || 'Unknown';
+    const nextEpisodeAirDate = m.nextAiringEpisode?.airingAt != null
+        ? new Date(m.nextAiringEpisode.airingAt * 1000).toLocaleDateString('en-US', {
+            month: 'short',
+            day: 'numeric',
+            year: 'numeric',
+            timeZone: 'UTC',
+        })
+        : undefined;
+    return {
+        _id: id,
+        id,
+        anilistId: m.id > 0 ? m.id : undefined,
+        name,
+        englishName: title?.english,
+        nativeName: title?.native,
+        names: {
+            romaji: title?.romaji,
+            english: title?.english,
+            native: title?.native,
+            synonyms: m.synonyms,
+        },
+        thumbnail: m.coverImage?.extraLarge || m.coverImage?.large || '',
+        bannerImage: m.bannerImage || undefined,
+        description: stripHtml(m.description),
+        genres: (m.genres?.slice(0, 6) || []).map((g) => ({ name: g })),
+        score: m.averageScore != null ? Number((m.averageScore / 10).toFixed(1)) : undefined,
+        type: m.format,
+        status: m.status,
+        episodeCount: m.episodes ?? undefined,
+        year: m.seasonYear ?? undefined,
+        season: m.season
+            ? { season: m.season, title: m.season, year: m.seasonYear ?? undefined }
+            : undefined,
+        nextAiring: m.nextAiringEpisode
+            ? {
+                episode: m.nextAiringEpisode.episode,
+                timeUntilAiring: m.nextAiringEpisode.timeUntilAiring,
+            }
+            : undefined,
+        nextEpisodeAirDate,
+        studios: m.studios?.nodes?.map((n) => ({ name: n.name })),
+        isAdult: m.isAdult,
+        tags: m.tags?.map((t) => ({ name: t.name })),
+        averageScore: m.averageScore ?? undefined,
+        country: m.countryOfOrigin ?? undefined,
+        airedStart: m.startDate
+            ? {
+                year: m.startDate.year ?? undefined,
+                month: m.startDate.month ?? undefined,
+                date: m.startDate.day ?? undefined,
+            }
+            : undefined,
+        airedEnd: m.endDate
+            ? {
+                year: m.endDate.year ?? undefined,
+                month: m.endDate.month ?? undefined,
+                date: m.endDate.day ?? undefined,
+            }
+            : undefined,
+    };
+}
+export function showFromOfflineEntry(entry) {
+    const id = String(entry.anilistId);
+    const name = entry.title || 'Unknown';
+    let genres;
+    if (entry.genres) {
+        try {
+            const parsed = JSON.parse(entry.genres);
+            if (Array.isArray(parsed)) {
+                const names = parsed.filter((g) => typeof g === 'string');
+                if (names.length > 0)
+                    genres = names.map((g) => ({ name: g }));
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    return {
+        _id: id,
+        id,
+        anilistId: entry.anilistId,
+        name,
+        names: { romaji: entry.title || undefined },
+        thumbnail: entry.thumbnail || '',
+        genres,
+        type: entry.type,
+    };
+}
+export async function getLatestReleases(format = 'TV', page = 1, size = 12) {
+    if (format === 'ADULT') {
+        return getAdultLatest(page, size);
+    }
+    const now = Math.floor(Date.now() / 1000);
+    const thirtyDaysAgo = now - 30 * 86400;
+    const needed = page * size;
+    const accumulated = [];
+    const seen = new Set();
+    let anilistPage = 1;
+    let apiFailed = false;
+    while (accumulated.length < needed && anilistPage <= 10) {
+        const query = `
+      query ($page: Int, $perPage: Int, $airingAtGt: Int, $airingAtLt: Int) {
+        Page(page: $page, perPage: $perPage) {
+          pageInfo { hasNextPage }
+          airingSchedules(sort: TIME_DESC, airingAt_lesser: $airingAtLt, airingAt_greater: $airingAtGt) {
+            id episode airingAt
+            media {
+              ${mediaFieldsLight()}
+            }
+          }
+        }
+      }
+    `;
+        const result = await anilistRequest(query, { page: anilistPage, perPage: 50, airingAtLt: now, airingAtGt: thirtyDaysAgo });
+        if (!result?.data) {
+            apiFailed = true;
+            break;
+        }
+        const schedules = result?.data?.Page?.airingSchedules;
+        if (!schedules || schedules.length === 0)
+            break;
+        for (const s of schedules) {
+            if (!s.media)
+                continue;
+            if (format !== 'ALL' && s.media.format !== format)
+                continue;
+            if (s.media.isAdult)
+                continue;
+            if (!s.media.id || seen.has(s.media.id))
+                continue;
+            seen.add(s.media.id);
+            accumulated.push(fromAnilistMedia(s.media));
+            if (accumulated.length >= needed)
+                break;
+        }
+        if (!result.data?.Page?.pageInfo?.hasNextPage)
+            break;
+        anilistPage++;
+    }
+    if (apiFailed) {
+        return (await tryFallback(() => malLatestReleases(malCacheStore(), format, page, size), () => kitsuLatestReleases(format, page, size))).map(fromAnilistMedia);
+    }
+    const start = (page - 1) * size;
+    return accumulated.slice(start, start + size);
+}
+async function getAdultLatest(page, size) {
+    const query = `
+    query ($page: Int, $perPage: Int) {
+      Page(page: $page, perPage: $perPage) {
+        pageInfo { total hasNextPage }
+        media(sort: [START_DATE_DESC, ID_DESC], type: ANIME, isAdult: true) {
+          ${mediaFieldsLight()}
+        }
+      }
+    }
+  `;
+    const result = await anilistRequest(query, { page, perPage: size });
+    if (!result?.data) {
+        return [];
+    }
+    const media = result?.data?.Page?.media;
+    if (!media)
+        return [];
+    return media.map(fromAnilistMedia);
+}
+export async function getSeasonal(page = 1, size = 14, format) {
+    if (format === 'ADULT') {
+        return getAdultLatest(page, size);
+    }
+    const now = new Date();
+    const year = now.getFullYear();
+    const month = now.getMonth() + 1;
+    const currentSeason = month <= 3 ? 'WINTER' : month <= 6 ? 'SPRING' : month <= 9 ? 'SUMMER' : 'FALL';
+    const query = `
+    query ($page: Int, $perPage: Int, $season: MediaSeason, $seasonYear: Int, $format: MediaFormat) {
+      Page(page: $page, perPage: $perPage) {
+        pageInfo { hasNextPage total }
+        media(season: $season, seasonYear: $seasonYear, type: ANIME, format: $format, isAdult: false, sort: [POPULARITY_DESC, SCORE_DESC]) {
+          ${mediaFieldsLight()}
+        }
+      }
+    }
+  `;
+    const formatVar = format && format !== 'ALL' ? format.toUpperCase() : undefined;
+    const result = await anilistRequest(query, { page, perPage: size, season: currentSeason, seasonYear: year, format: formatVar });
+    if (!result?.data) {
+        if (anilistUnavailable()) {
+            return (await tryFallback(() => malSeasonal(malCacheStore(), currentSeason, year, format, page, size), () => kitsuSeasonal(currentSeason, year, format, page, size))).map(fromAnilistMedia);
+        }
+        return [];
+    }
+    const media = result?.data?.Page?.media;
+    if (!media)
+        return [];
+    return media.map(fromAnilistMedia);
+}
+export async function getTrending(page = 1, perPage = 20, sort = 'TRENDING_DESC', status) {
+    const media = await fetchAnilistMedia(page, perPage, sort, status);
+    if (media && media.length > 0) {
+        return media.map(fromAnilistMedia);
+    }
+    if (anilistUnavailable()) {
+        return (await tryFallback(async () => {
+            if (status === 'RELEASING')
+                return malTop(malCacheStore(), 'airing', page);
+            switch (sort) {
+                case 'POPULARITY_DESC':
+                case 'FAVOURITES_DESC':
+                    return malTop(malCacheStore(), 'bypopularity', page);
+                case 'SCORE_DESC':
+                    return malTop(malCacheStore(), null, page);
+                default:
+                    return malTop(malCacheStore(), 'airing', page);
+            }
+        }, () => kitsuTrending(page, perPage))).map(fromAnilistMedia);
+    }
+    return [];
+}
+async function fetchAnilistMedia(page = 1, perPage = 20, sort = 'TRENDING_DESC', status) {
+    const statusFilter = status ? `status: ${status},` : '';
+    const query = `
+    query ($page: Int, $perPage: Int) {
+      Page(page: $page, perPage: $perPage) {
+        media(sort: ${sort}, type: ANIME, isAdult: false, ${statusFilter}) {
+          ${mediaFields()}
+        }
+      }
+    }
+  `;
+    const result = await anilistRequest(query, {
+        page,
+        perPage,
+    });
+    if (!result?.data)
+        return null;
+    return result?.data?.Page?.media ?? [];
+}
+export async function getSpotlightBanners(page = 1, perPage = 20) {
+    const media = await fetchAnilistMedia(page, perPage);
+    if (media) {
+        const withBanner = [];
+        const rest = [];
+        for (const m of media) {
+            if (withBanner.length >= 6 && rest.length >= 6)
+                break;
+            const show = fromAnilistMedia(m);
+            if (show.bannerImage) {
+                if (withBanner.length < 6)
+                    withBanner.push(show);
+            }
+            else if (rest.length < 6) {
+                rest.push(show);
+            }
+        }
+        const results = [...withBanner];
+        for (const show of rest) {
+            if (results.length >= 6)
+                break;
+            if (show.thumbnail)
+                results.push({ ...show, bannerImage: show.thumbnail });
+        }
+        return results;
+    }
+    const now = new Date();
+    const year = now.getFullYear();
+    const month = now.getMonth() + 1;
+    const currentSeason = month <= 3 ? 'WINTER' : month <= 6 ? 'SPRING' : month <= 9 ? 'SUMMER' : 'FALL';
+    const source = await tryFallback(() => malTop(malCacheStore(), 'airing', 1), () => kitsuSeasonal(currentSeason, year, 'TV', 1, 20));
+    if (!source || source.length === 0) {
+        return [];
+    }
+    const withTimeout = (p, ms = 4000) => Promise.race([
+        p,
+        new Promise((resolve) => setTimeout(() => resolve(null), ms)),
+    ]);
+    const shuffled = [...source].sort(() => Math.random() - 0.5);
+    const enriched = await Promise.allSettled(shuffled.slice(0, 10).map((m) => withTimeout(findTmdbDefaultBackdrop({
+        english: m.title?.english,
+        romaji: m.title?.romaji,
+        native: m.title?.native,
+    })).then((artwork) => ({ m, artwork }))));
+    const results = [];
+    for (const r of enriched) {
+        if (results.length >= 6)
+            break;
+        if (r.status !== 'fulfilled' || !r.value?.artwork)
+            continue;
+        const show = fromAnilistMedia(r.value.m);
+        results.push({
+            ...show,
+            bannerImage: r.value.artwork.backdrop,
+            description: show.description || r.value.artwork.overview || '',
+        });
+    }
+    if (results.length < 6) {
+        const seen = new Set(results.map((s) => s._id));
+        for (const m of shuffled) {
+            if (results.length >= 6)
+                break;
+            const show = fromAnilistMedia(m);
+            if (seen.has(show._id) || !show.thumbnail)
+                continue;
+            seen.add(show._id);
+            results.push({ ...show, bannerImage: show.thumbnail });
+        }
+    }
+    return results;
+}
+export function parseMalId(id) {
+    if (typeof id === 'number')
+        return id < 0 ? Math.abs(id) : null;
+    const prefixed = /^mal-(\d+)$/i.exec(id.trim());
+    if (prefixed)
+        return parseInt(prefixed[1], 10);
+    if (/^-\d+$/.test(id.trim()))
+        return Math.abs(parseInt(id, 10));
+    return null;
+}
+function hasPoster(show) {
+    return !!show?.thumbnail && show.thumbnail.trim() !== '';
+}
+function posterFromMedia(m) {
+    const url = m?.coverImage?.extraLarge ||
+        m?.coverImage?.large ||
+        m?.coverImage?.medium ||
+        m?.coverImage?.original ||
+        m?.coverImage?.small ||
+        m?.coverImage?.tiny;
+    return url && url.trim() !== '' ? url : null;
+}
+function titleWords(s) {
+    return new Set(s
+        .toLowerCase()
+        .normalize('NFD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .split(/[^a-z0-9]+/)
+        .filter((w) => w.length >= 2));
+}
+function titleSimilarity(a, b) {
+    if (!a.trim() || !b.trim())
+        return 0;
+    const an = a.trim().toLowerCase();
+    const bn = b.trim().toLowerCase();
+    if (an === bn || an.includes(bn) || bn.includes(an))
+        return 1;
+    const wa = titleWords(a);
+    const wb = titleWords(b);
+    if (wa.size === 0 || wb.size === 0)
+        return 0;
+    const overlap = [...wa].filter((w) => wb.has(w)).length;
+    return overlap / Math.min(wa.size, wb.size);
+}
+function titlesMatchAny(candidate, expected) {
+    if (!candidate)
+        return false;
+    return expected.some((t) => titleSimilarity(candidate, t) >= 0.6);
+}
+export async function findPosterByTitle(title, expected) {
+    const clean = title?.trim();
+    if (!clean)
+        return null;
+    const expectedTitles = (expected?.titles ?? []).filter((t) => t.trim() !== '');
+    try {
+        const { entries } = await malSearchAnime(malCacheStore(), clean, 1);
+        for (const e of entries) {
+            if (!e.imageUrl || e.imageUrl.trim() === '')
+                continue;
+            if (expected?.malId && e.idMal === expected.malId)
+                return e.imageUrl;
+            if (expected && titlesMatchAny(e.title, expectedTitles))
+                return e.imageUrl;
+            if (!expected)
+                return e.imageUrl;
+        }
+    }
+    catch {
+        // ignore, try Kitsu next
+    }
+    try {
+        const kitsu = await kitsuSearchAnime({ query: clean, page: 1, perPage: 5 });
+        for (const m of kitsu) {
+            const url = posterFromMedia(m);
+            if (!url)
+                continue;
+            if (expected?.anilistId && m.id === expected.anilistId)
+                return url;
+            if (expected?.malId && m.idMal === expected.malId)
+                return url;
+        }
+    }
+    catch {
+        // ignore
+    }
+    return null;
+}
+async function withPosterBackfill(show, cacheKey, expected) {
+    if (!show)
+        return null;
+    if (hasPoster(show)) {
+        setCachedAnilist(cacheKey, show);
+        return show;
+    }
+    if (expected && (expected.anilistId || expected.malId)) {
+        const entry = (expected.anilistId ? offlineDb.getByAnilistId(expected.anilistId) : null) ??
+            (expected.malId ? offlineDb.getByMalId(expected.malId) : null);
+        const thumb = entry?.thumbnail;
+        if (thumb && thumb.trim() !== '') {
+            show.thumbnail = thumb;
+            setCachedAnilist(cacheKey, show);
+            return show;
+        }
+    }
+    const candidates = [show.names?.english, show.englishName, show.name, show.names?.romaji]
+        .filter((t) => !!t && t.trim().length >= 4)
+        .filter((t, i, a) => a.findIndex((x) => x.toLowerCase() === t.toLowerCase()) === i);
+    const exp = expected ?? { titles: [] };
+    if (exp.titles.length === 0)
+        exp.titles = [...candidates];
+    if (show.names?.native)
+        exp.titles.push(show.names.native);
+    const seen = new Set();
+    for (const title of candidates) {
+        const key = title.toLowerCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        try {
+            const poster = await findPosterByTitle(title, exp);
+            if (poster) {
+                show.thumbnail = poster;
+                setCachedAnilist(cacheKey, show);
+                return show;
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    return show;
+}
+async function backfillKitsuShowFromMal(show, malId) {
+    try {
+        const d = await malAnimeDetail(malCacheStore(), malId);
+        if (d.detail?.imageUrl)
+            show.thumbnail = d.detail.imageUrl;
+        try {
+            malCacheStore().put(`${EN_TITLE_CACHE_PREFIX}${malId}`, (d.detail?.titleEnglish ?? '').trim(), 7 * 24 * 3600);
+        }
+        catch {
+            // ignore
+        }
+        const titleEnglish = d.detail?.titleEnglish?.trim();
+        if (titleEnglish &&
+            (!show.names?.english ||
+                show.names.english.trim() === '' ||
+                show.names.english === show.names?.romaji)) {
+            show.names = { ...show.names, english: titleEnglish };
+            show.englishName = titleEnglish;
+        }
+        const titleJapanese = d.detail?.titleJapanese?.trim();
+        if (titleJapanese && !show.names?.native) {
+            show.names = { ...show.names, native: titleJapanese };
+            show.nativeName = titleJapanese;
+        }
+        if ((!show.name || show.name === 'Unknown') && (show.names?.english || show.names?.native)) {
+            show.name = show.names.english ?? show.names.native ?? show.name;
+        }
+    }
+    catch {
+        // ignore
+    }
+}
+export async function getShowMetaById(id) {
+    const malId = parseMalId(id);
+    if (malId)
+        return getShowMetaByMalId(malId);
+    const numericId = parseInt(id);
+    if (isNaN(numericId))
+        return null;
+    if (numericId < 0)
+        return getShowMetaByMalId(Math.abs(numericId));
+    const fields = mediaFields();
+    const cacheKey = `meta:v2:${id}`;
+    const legacyCached = getCachedAnilist(`meta:${id}`);
+    const cached = getCachedAnilist(cacheKey) ?? legacyCached;
+    if (cached && hasPoster(cached)) {
+        setCachedAnilist(cacheKey, cached);
+        return cached;
+    }
+    const expected = { anilistId: numericId, titles: [] };
+    const query = `query ($id: Int) { Media(id: $id, type: ANIME) { ${fields} } }`;
+    const queryMal = `query ($id: Int) { Media(idMal: $id, type: ANIME) { ${fields} } }`;
+    const byId = await anilistRequest(query, { id: numericId });
+    if (byId?.data?.Media) {
+        const show = fromAnilistMedia(byId.data.Media);
+        return withPosterBackfill(show, cacheKey, expected);
+    }
+    const byMal = await anilistRequest(queryMal, { id: numericId });
+    if (byMal?.data?.Media) {
+        const show = fromAnilistMedia(byMal.data.Media);
+        return withPosterBackfill(show, cacheKey, expected);
+    }
+    const apiFailed = !byId?.data && !byMal?.data;
+    if (apiFailed && anilistUnavailable()) {
+        const offline = offlineDb.getByAnilistId(numericId) ?? offlineDb.getByMalId(numericId);
+        const offlineShow = offline ? showFromOfflineEntry(offline) : null;
+        if (offlineShow && hasPoster(offlineShow)) {
+            setCachedAnilist(cacheKey, offlineShow);
+            return offlineShow;
+        }
+        const fb = (await kitsuMetaByAnilistId(numericId)) ?? (await kitsuMetaByMalId(numericId));
+        if (fb) {
+            const show = fromAnilistMedia(fb);
+            if (hasPoster(show)) {
+                if (fb.idMal) {
+                    await backfillKitsuShowFromMal(show, fb.idMal);
+                }
+                setCachedAnilist(cacheKey, show);
+                return show;
+            }
+            return withPosterBackfill(show, cacheKey, expected);
+        }
+        if (offlineShow) {
+            setCachedAnilist(cacheKey, offlineShow);
+            return offlineShow;
+        }
+    }
+    if (cached && !hasPoster(cached)) {
+        return withPosterBackfill(cached, cacheKey, expected);
+    }
+    return null;
+}
+export async function getShowMetaByMalId(malId) {
+    const absMal = Math.abs(malId);
+    if (!absMal)
+        return null;
+    const cacheKey = `meta:v2:-${absMal}`;
+    const cached = getCachedAnilist(cacheKey) ?? getCachedAnilist(`meta:-${absMal}`);
+    const expected = { malId: absMal, titles: [] };
+    if (cached && cached.anilistId != null && cached.anilistId > 0 && hasPoster(cached)) {
+        setCachedAnilist(cacheKey, cached);
+        return cached;
+    }
+    const anilistUp = !anilistUnavailable();
+    if (cached && !anilistUp && hasPoster(cached)) {
+        setCachedAnilist(cacheKey, cached);
+        return cached;
+    }
+    if (anilistUp) {
+        try {
+            const byMal = await anilistRequest(`query ($id: Int) { Media(idMal: $id, type: ANIME) { ${mediaFields()} } }`, { id: absMal });
+            if (byMal?.data?.Media) {
+                const show = fromAnilistMedia(byMal.data.Media);
+                return withPosterBackfill(show, cacheKey, expected);
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    const offline = anilistUp ? null : offlineDb.getByMalId(absMal);
+    const offlineShow = offline ? showFromOfflineEntry(offline) : null;
+    if (offlineShow && hasPoster(offlineShow)) {
+        setCachedAnilist(cacheKey, offlineShow);
+        return offlineShow;
+    }
+    try {
+        const fb = await kitsuMetaByMalId(absMal);
+        if (fb) {
+            const show = fromAnilistMedia(fb);
+            await backfillKitsuShowFromMal(show, absMal);
+            if (hasPoster(show)) {
+                setCachedAnilist(cacheKey, show);
+                return show;
+            }
+            return withPosterBackfill(show, cacheKey, expected);
+        }
+    }
+    catch {
+        // ignore
+    }
+    try {
+        const d = await malAnimeDetail(malCacheStore(), absMal);
+        if (d.detail) {
+            const show = fromAnilistMedia(toAnilistDetailMedia(d.detail));
+            return withPosterBackfill(show, cacheKey, expected);
+        }
+    }
+    catch {
+        // ignore
+    }
+    if (cached && !hasPoster(cached)) {
+        return withPosterBackfill(cached, cacheKey, expected);
+    }
+    if (offlineShow) {
+        setCachedAnilist(cacheKey, offlineShow);
+        return offlineShow;
+    }
+    logger.warn({ malId: absMal }, 'MAL id unresolvable on all metadata providers');
+    return null;
+}
+export async function batchGetShowStatuses(ids) {
+    const result = new Map();
+    if (ids.length === 0)
+        return result;
+    if (!isAnilistRateLimited()) {
+        const BATCH = 10;
+        for (let i = 0; i < ids.length; i += BATCH) {
+            const batch = ids.slice(i, i + BATCH);
+            const aliases = batch
+                .map((id, idx) => `a${idx}: Media(id: $id${idx}, type: ANIME) { id status }`)
+                .join('\n');
+            const variables = {};
+            batch.forEach((id, idx) => {
+                variables[`id${idx}`] = id;
+            });
+            try {
+                const resp = await anilistRequest(`query (${batch.map((_, idx) => `$id${idx}: Int`).join(', ')}) { ${aliases} }`, variables);
+                for (let j = 0; j < batch.length; j++) {
+                    const alias = `a${j}`;
+                    const media = resp?.data?.[alias];
+                    if (media?.status)
+                        result.set(media.id, media.status);
+                }
+            }
+            catch {
+                break;
+            }
+        }
+        if (result.size === ids.length)
+            return result;
+    }
+    const missing = ids.filter((id) => !result.has(id));
+    if (missing.length > 0) {
+        try {
+            const { kitsuBatchGetStatuses } = await import('./kitsu.js');
+            const kitsuStatuses = await kitsuBatchGetStatuses(missing);
+            for (const [id, status] of kitsuStatuses) {
+                result.set(id, status);
+            }
+        }
+        catch {
+            // Kitsu fallback failed
+        }
+    }
+    return result;
+}
+export async function getAnilistEpisodes(id) {
+    const malId = parseMalId(id);
+    if (malId)
+        return getEpisodesByMalId(malId);
+    const numericId = parseInt(id);
+    if (isNaN(numericId))
+        return [];
+    if (numericId < 0)
+        return getEpisodesByMalId(Math.abs(numericId));
+    const cacheKey = `eps:${id}`;
+    const cached = getCachedAnilist(cacheKey);
+    if (cached)
+        return cached;
+    const subquery = `id episodes status nextAiringEpisode { episode airingAt } airingSchedule(perPage: 100) { nodes { episode airingAt } }`;
+    const query = `query ($id: Int) { Media(id: $id, type: ANIME) { ${subquery} } }`;
+    const queryMal = `query ($id: Int) { Media(idMal: $id, type: ANIME) { ${subquery} } }`;
+    const byId = await anilistRequest(query, { id: numericId });
+    const media = byId?.data?.Media;
+    if (!media) {
+        const byMal = await anilistRequest(queryMal, { id: numericId });
+        if (!byMal?.data) {
+            if (anilistUnavailable()) {
+                const episodes = await kitsuEpisodes(numericId, numericId);
+                if (episodes.length > 0) {
+                    setCachedAnilist(cacheKey, episodes);
+                    return episodes;
+                }
+            }
+            return [];
+        }
+        if (!byMal?.data?.Media)
+            return [];
+        const episodes = extractEpisodes(byMal.data.Media);
+        setCachedAnilist(cacheKey, episodes);
+        return episodes;
+    }
+    const episodes = extractEpisodes(media);
+    setCachedAnilist(cacheKey, episodes);
+    return episodes;
+}
+async function getEpisodesByMalId(malId) {
+    const cacheKey = `eps:-${malId}`;
+    const cached = getCachedAnilist(cacheKey);
+    if (cached)
+        return cached;
+    try {
+        const episodes = await kitsuEpisodes(0, malId);
+        if (episodes.length > 0) {
+            setCachedAnilist(cacheKey, episodes);
+            return episodes;
+        }
+    }
+    catch {
+        // ignore
+    }
+    try {
+        const d = await malAnimeDetail(malCacheStore(), malId);
+        const total = d.detail?.episodes;
+        if (total && total > 0 && total <= 2000) {
+            const episodes = Array.from({ length: total }, (_, i) => (i + 1).toString());
+            setCachedAnilist(cacheKey, episodes);
+            return episodes;
+        }
+    }
+    catch {
+        // ignore
+    }
+    return [];
+}
+function extractEpisodes(result) {
+    const { status, episodes: total, nextAiringEpisode, airingSchedule } = result;
+    if (status === 'FINISHED' && total) {
+        return Array.from({ length: total }, (_, i) => (i + 1).toString());
+    }
+    if (status === 'RELEASING' && nextAiringEpisode?.episode) {
+        const airedCount = nextAiringEpisode.episode - 1;
+        if (airedCount > 0) {
+            return Array.from({ length: airedCount }, (_, i) => (i + 1).toString());
+        }
+    }
+    if (airingSchedule?.nodes) {
+        const now = Date.now() / 1000;
+        const aired = airingSchedule.nodes.filter((n) => n.airingAt < now);
+        if (aired.length > 0) {
+            const max = Math.max(...aired.map((n) => n.episode));
+            return Array.from({ length: max }, (_, i) => (i + 1).toString());
+        }
+    }
+    if (total) {
+        return Array.from({ length: total }, (_, i) => (i + 1).toString());
+    }
+    return [];
+}
+export async function searchAnilistByTitle(title) {
+    const query = `
+    query ($search: String) {
+      Page(page: 1, perPage: 5) {
+        media(search: $search, type: ANIME) {
+          id
+          title { romaji english native }
+        }
+      }
+    }
+  `;
+    const normalizedTitle = title.normalize('NFD').replace(/[\u0300-\u036f]/g, '');
+    const words = normalizedTitle.split(/\s+/).filter((word) => word.length >= 3);
+    const searchTerms = [
+        title,
+        normalizedTitle,
+        normalizedTitle.replace(/:/g, ''),
+        words.slice(0, 5).join(' '),
+        words.slice(0, 4).join(' '),
+        words.slice(0, 3).join(' '),
+        words.slice(0, 2).join(' ').replace(/:/g, ''),
+        normalizedTitle.replace(/\s*\d+(?:st|nd|rd|th)?\s*Season\s*\d*/gi, '').trim(),
+    ].filter((t, i, a) => t && a.indexOf(t) === i);
+    let media;
+    let anyFailed = false;
+    for (const searchTerm of searchTerms) {
+        const result = await anilistRequest(query, { search: searchTerm });
+        if (!result?.data) {
+            anyFailed = true;
+            break;
+        }
+        media = result?.data?.Page?.media;
+        if (media?.length)
+            break;
+    }
+    if (!media || media.length === 0) {
+        if (anyFailed && anilistUnavailable()) {
+            const fb = await kitsuSearchAnime({ query: title, page: 1, perPage: 5 });
+            if (fb.length > 0) {
+                const best = fb[0];
+                return { id: best.id, title: best.title ?? {} };
+            }
+        }
+        return null;
+    }
+    const lowerTitle = title.toLowerCase();
+    const exactMatch = media.find((m) => m.title?.romaji?.toLowerCase() === lowerTitle ||
+        m.title?.english?.toLowerCase() === lowerTitle ||
+        m.title?.native === title);
+    if (exactMatch) {
+        return { id: exactMatch.id, title: exactMatch.title };
+    }
+    const inputWords = new Set(normalizedTitle
+        .toLowerCase()
+        .split(/\s+/)
+        .filter((w) => w.length >= 2));
+    let best = media[0];
+    let bestScore = 0;
+    for (const m of media) {
+        const text = (m.title?.romaji || m.title?.english || '').toLowerCase();
+        const overlap = text.split(/\s+/).filter((w) => inputWords.has(w)).length;
+        if (overlap > bestScore) {
+            bestScore = overlap;
+            best = m;
+        }
+    }
+    return { id: best.id, title: best.title };
+}
+export async function getAiredEpisodesForShows(ids, startDate, endDate) {
+    const dayStart = Math.floor(startDate.getTime() / 1000);
+    const dayEnd = Math.floor(endDate.getTime() / 1000);
+    const cacheKey = `aired:${dayStart}:${dayEnd}:${Array.from(ids)
+        .sort((a, b) => a - b)
+        .join(',')}`;
+    const cached = getCachedAiredEpisodes(cacheKey);
+    if (cached)
+        return cached;
+    try {
+        const results = await getAiredEpisodesFromAniScheduleFeed(ids, dayStart, dayEnd);
+        setCachedAiredEpisodes(cacheKey, results);
+        return results;
+    }
+    catch (e) {
+        logger.warn({ err: e }, 'AniSchedule episode feed failed, falling back to AniList aired episodes');
+    }
+    if (isAnilistRateLimited()) {
+        return [];
+    }
+    const now = Math.floor(Date.now() / 1000);
+    const results = [];
+    const seen = new Set();
+    const BATCH = 5;
+    for (let i = 0; i < ids.length; i += BATCH) {
+        const batch = ids.slice(i, i + BATCH);
+        const aliases = batch
+            .map((id, idx) => `a${idx}: Media(id: $id${idx}, type: ANIME) { id airingSchedule(perPage: 100) { nodes { episode airingAt } } }`)
+            .join('\n');
+        const variables = {};
+        batch.forEach((id, idx) => {
+            variables[`id${idx}`] = id;
+        });
+        const result = await anilistRequest(`query (${batch.map((_, idx) => `$id${idx}: Int`).join(', ')}) { ${aliases} }`, variables);
+        for (let j = 0; j < batch.length; j++) {
+            const alias = `a${j}`;
+            const media = result?.data?.[alias];
+            if (!media?.airingSchedule?.nodes)
+                continue;
+            for (const node of media.airingSchedule.nodes) {
+                if (node.airingAt >= dayStart && node.airingAt <= dayEnd && node.airingAt <= now) {
+                    const key = `${media.id}:${node.episode}`;
+                    if (!seen.has(key)) {
+                        seen.add(key);
+                        results.push({ mediaId: media.id, episode: node.episode, airingAt: node.airingAt });
+                    }
+                }
+            }
+        }
+    }
+    setCachedAiredEpisodes(cacheKey, results);
+    return results;
+}
+export async function getAiredEpisodesForShow(id, startDate, endDate) {
+    const dayStart = Math.floor(startDate.getTime() / 1000);
+    const dayEnd = Math.floor(endDate.getTime() / 1000);
+    const query = `
+    query ($id: Int, $dayStart: Int, $dayEnd: Int) {
+      Media(id: $id, type: ANIME) {
+        id
+        airingSchedule(airingAt_greater: $dayStart, airingAt_lesser: $dayEnd) {
+          episode
+          airingAt
+        }
+      }
+    }
+  `;
+    const result = await anilistRequest(query, { id, dayStart, dayEnd });
+    const schedules = result?.data?.Media?.airingSchedule;
+    if (!schedules || schedules.length === 0)
+        return [];
+    const now = Math.floor(Date.now() / 1000);
+    return schedules.filter((s) => s.airingAt <= now).map((s) => s.episode);
+}
+export async function getSchedule(date, format, adult = false) {
+    if (format === 'ADULT') {
+        adult = true;
+        format = undefined;
+    }
+    try {
+        const result = await getScheduleFromAniSchedule(date, format, adult);
+        const shows = result.entries
+            .filter((e) => e.show)
+            .map((e) => withScheduleFields(e.show, e.episode, e.airingAt));
+        if (result.missingMeta.length > 0) {
+            for (const entry of result.missingMeta) {
+                try {
+                    const meta = await getShowMetaById(String(entry.id));
+                    if (!meta)
+                        continue;
+                    if (adult ? !meta.isAdult : meta.isAdult)
+                        continue;
+                    shows.push(withScheduleFields(meta, entry.episode, entry.airingAt));
+                }
+                catch {
+                    // keep going without this show
+                }
+            }
+        }
+        return shows;
+    }
+    catch (e) {
+        logger.warn({ err: e }, 'AniSchedule schedule failed, falling back to AniList');
+        if (isAnilistRateLimited())
+            return [];
+        return getScheduleFromAnilist(date, format, adult);
+    }
+}
+async function getScheduleFromAnilist(date, format, adult = false) {
+    const dayStart = Math.floor(date.getTime() / 1000);
+    const dayEnd = dayStart + 86400;
+    const query = `
+    query ($dayStart: Int, $dayEnd: Int) {
+      Page(perPage: 50) {
+        airingSchedules(airingAt_greater: $dayStart, airingAt_lesser: $dayEnd) {
+          episode
+          airingAt
+          media {
+            ${mediaFields()}
+          }
+        }
+      }
+    }
+  `;
+    const result = await anilistRequest(query, { dayStart, dayEnd });
+    const schedules = result?.data?.Page?.airingSchedules;
+    if (!schedules || schedules.length === 0)
+        return [];
+    const seen = new Set();
+    const results = [];
+    const now = Math.floor(Date.now() / 1000);
+    for (const entry of schedules) {
+        const media = entry.media;
+        if (!media)
+            continue;
+        if (format && format !== 'ALL' && media.format !== format)
+            continue;
+        const isAdultShow = !!media.isAdult;
+        if (adult ? !isAdultShow : isAdultShow)
+            continue;
+        const key = media.idMal ?? media.id;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        const show = fromAnilistMedia(media);
+        show.episodeNumber = entry.episode;
+        show.aired = entry.airingAt <= now;
+        show.nextAiring = {
+            episode: entry.episode,
+            timeUntilAiring: entry.airingAt - now,
+        };
+        show.nextEpisodeAirDate = new Date(entry.airingAt * 1000).toLocaleDateString('en-US', {
+            month: 'short',
+            day: 'numeric',
+            year: 'numeric',
+            timeZone: 'UTC',
+        });
+        show.airTime = new Date(entry.airingAt * 1000).toLocaleTimeString('en-US', {
+            hour: '2-digit',
+            minute: '2-digit',
+            timeZone: 'UTC',
+        });
+        results.push(show);
+    }
+    return results;
+}
+function splitList(value) {
+    const arr = Array.isArray(value) ? value : typeof value === 'string' ? value.split(',') : [];
+    return [...new Set(arr.map((v) => v.trim()).filter(Boolean))];
+}
+export async function searchAnilist(options = {}) {
+    const { query, page = 1, perPage = 14, format, status, season, seasonYear, countryOfOrigin, genre, genre_in, tag, tag_in, genre_not_in, tag_not_in, averageScore_greater, episodes_greater, isAdult, sort, } = options;
+    const searchVars = {
+        page,
+        perPage,
+    };
+    if (query)
+        searchVars.search = query;
+    if (format && format !== 'ALL') {
+        if (format === 'ADULT') {
+            searchVars.isAdult = true;
+        }
+        else {
+            searchVars.format = format.toUpperCase();
+        }
+    }
+    if (status)
+        searchVars.status = status;
+    if (season && season !== 'ALL')
+        searchVars.season = season.toUpperCase();
+    if (seasonYear)
+        searchVars.seasonYear = seasonYear;
+    if (countryOfOrigin && countryOfOrigin !== 'ALL')
+        searchVars.countryOfOrigin = countryOfOrigin;
+    const genreList = [...splitList(genre), ...(genre_in ?? []).map((g) => g.trim()).filter(Boolean)];
+    const uniqueGenres = [...new Set(genreList)];
+    if (uniqueGenres.length === 1)
+        searchVars.genre = uniqueGenres[0];
+    else if (uniqueGenres.length > 1)
+        searchVars.genre_in = uniqueGenres;
+    const tagList = [...splitList(tag), ...(tag_in ?? []).map((t) => t.trim()).filter(Boolean)];
+    const uniqueTags = [...new Set(tagList)];
+    if (uniqueTags.length === 1)
+        searchVars.tag = uniqueTags[0];
+    else if (uniqueTags.length > 1)
+        searchVars.tag_in = uniqueTags;
+    if (genre_not_in && genre_not_in.length > 0)
+        searchVars.genre_not_in = genre_not_in;
+    if (tag_not_in && tag_not_in.length > 0)
+        searchVars.tag_not_in = tag_not_in;
+    if (averageScore_greater)
+        searchVars.averageScore_greater = averageScore_greater;
+    if (episodes_greater)
+        searchVars.episodes_greater = episodes_greater;
+    if (isAdult !== undefined)
+        searchVars.isAdult = isAdult;
+    if (sort)
+        searchVars.sort = [sort];
+    const queryStr = `
+    query ($page: Int, $perPage: Int, $search: String, $format: MediaFormat, $status: MediaStatus, $season: MediaSeason, $seasonYear: Int, $countryOfOrigin: CountryCode, $genre: String, $genre_in: [String], $tag: String, $tag_in: [String], $genre_not_in: [String], $tag_not_in: [String], $averageScore_greater: Int, $episodes_greater: Int, $isAdult: Boolean, $sort: [MediaSort]) {
+      Page(page: $page, perPage: $perPage) {
+        pageInfo { hasNextPage total }
+        media(
+          search: $search,
+          type: ANIME,
+          format: $format,
+          status: $status,
+          season: $season,
+          seasonYear: $seasonYear,
+          countryOfOrigin: $countryOfOrigin,
+          genre: $genre,
+          genre_in: $genre_in,
+          tag: $tag,
+          tag_in: $tag_in,
+          genre_not_in: $genre_not_in,
+          tag_not_in: $tag_not_in,
+          averageScore_greater: $averageScore_greater,
+          episodes_greater: $episodes_greater,
+          isAdult: $isAdult,
+          sort: $sort
+        ) {
+          ${mediaFieldsLight()}
+        }
+      }
+    }
+  `;
+    const result = await anilistRequest(queryStr, searchVars);
+    if (!result?.data) {
+        if (anilistUnavailable()) {
+            const malSearch = async () => {
+                const store = malCacheStore();
+                let fb = await malSearchMedia(store, {
+                    query,
+                    page,
+                    perPage,
+                    format: format && format !== 'ALL' && format !== 'ADULT' ? format : undefined,
+                    status,
+                    season,
+                    seasonYear,
+                    genre,
+                    genre_in,
+                    genre_not_in,
+                    averageScore_greater,
+                    episodes_greater,
+                    isAdult: format === 'ADULT' ? true : isAdult,
+                    sort,
+                });
+                if (fb.length > 0) {
+                    try {
+                        const hentai = await malSearchMedia(store, {
+                            query,
+                            page,
+                            perPage,
+                            format: format && format !== 'ALL' && format !== 'ADULT' ? format : undefined,
+                            status,
+                            season,
+                            seasonYear,
+                            genre,
+                            genre_in,
+                            averageScore_greater,
+                            episodes_greater,
+                            sort,
+                            isAdult: true,
+                        }, false);
+                        if (hentai.length > 0) {
+                            const hentaiIds = new Set(hentai.map((m) => m.id));
+                            fb = fb.filter((m) => !hentaiIds.has(m.id));
+                        }
+                    }
+                    catch {
+                        // ignore
+                    }
+                }
+                return fb;
+            };
+            const fb = await tryFallback(malSearch, () => kitsuSearchAnime({
+                query,
+                page,
+                perPage,
+                format: format && format !== 'ALL' && format !== 'ADULT' ? format : undefined,
+                status,
+                season,
+                seasonYear,
+                genre,
+                genre_in,
+                genre_not_in,
+                averageScore_greater,
+                episodes_greater,
+                isAdult: format === 'ADULT' ? true : isAdult,
+                sort,
+            }));
+            try {
+                await enrichEnglishFromMalDetail(malCacheStore(), fb);
+            }
+            catch {
+                // ignore
+            }
+            let results = mapFallbackResults(fb);
+            if (results.length === 0 && query?.trim()) {
+                try {
+                    const mal = await malSearchAnime(malCacheStore(), query, page);
+                    const media = mal.entries.map((e) => toAnilistSearchMedia(e));
+                    try {
+                        await enrichEnglishFromMalDetail(malCacheStore(), media);
+                    }
+                    catch {
+                        // ignore
+                    }
+                    results = media.map((m) => fromAnilistMedia(m));
+                }
+                catch {
+                    // ignore
+                }
+            }
+            return results;
+        }
+        return [];
+    }
+    const media = result?.data?.Page?.media;
+    if (!media || media.length === 0)
+        return [];
+    const seen = new Set();
+    const results = [];
+    for (const m of media) {
+        if (!m.id || seen.has(m.id))
+            continue;
+        seen.add(m.id);
+        results.push(fromAnilistMedia(m));
+    }
+    return results;
+}