@serifpersia/dango 3.6.7 → 3.6.9

package/server/dist/lib/anilist.js

@@ -1,1583 +0,0 @@
-import { buildQueryVariants, pickBestMatch } from '../providers/title-matching.js';
-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 isAnilistRateLimited() {
-    return anilistRateLimited && anilistCooldownUntil > Date.now();
-}
-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 {
-        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 {
-            // ignore
-        }
-    }
-    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, type = 'ANIME') {
-    const query = `
-    query ($search: String) {
-      Page(page: 1, perPage: 5) {
-        media(search: $search, type: ${type}) {
-          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 && type === 'ANIME' && 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 searchAnilistMangaByTitle(title) {
-    return searchAnilistByTitle(title, 'MANGA');
-}
-const MANGA_META_FRAGMENT = `id title { romaji english native } coverImage { large }`;
-export async function getMangaMetaById(id) {
-    if (!id)
-        return null;
-    try {
-        const result = await anilistRequest(`query ($id: Int) { Media(id: $id, type: MANGA) { ${MANGA_META_FRAGMENT} } }`, { id });
-        const m = result?.data?.Media;
-        if (!m)
-            return null;
-        return { id: m.id, title: m.title ?? {}, cover: m.coverImage?.large };
-    }
-    catch {
-        return null;
-    }
-}
-export async function getMangaMetaByMalId(malId) {
-    const absMal = Math.abs(malId);
-    if (!absMal)
-        return null;
-    try {
-        const result = await anilistRequest(`query ($id: Int) { Media(idMal: $id, type: MANGA) { ${MANGA_META_FRAGMENT} } }`, { id: absMal });
-        const m = result?.data?.Media;
-        if (!m)
-            return null;
-        return { id: m.id, title: m.title ?? {}, cover: m.coverImage?.large };
-    }
-    catch {
-        return null;
-    }
-}
-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 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 {
-                    // ignore
-                }
-            }
-        }
-        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 compactQuery = query?.toLowerCase().replace(/[^a-z0-9]/g, '');
-    const searchQueries = query?.trim()
-        ? buildQueryVariants(query).filter((term) => term.toLowerCase().replace(/[^a-z0-9]/g, '') === compactQuery)
-        : [''];
-    const mediaById = new Map();
-    let result = null;
-    let searchedVariant = false;
-    for (const [index, searchQuery] of searchQueries.entries()) {
-        result = await anilistRequest(queryStr, { ...searchVars, ...(searchQuery ? { search: searchQuery } : {}) });
-        if (!result?.data)
-            break;
-        for (const item of result.data.Page.media ?? []) {
-            if (item.id)
-                mediaById.set(item.id, item);
-        }
-        if (index > 0)
-            searchedVariant = true;
-        if ((result.data.Page.media?.length ?? 0) >= perPage)
-            break;
-    }
-    if (!result?.data && mediaById.size === 0) {
-        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 = [...mediaById.values()];
-    if (!media || media.length === 0)
-        return [];
-    if (searchedVariant) {
-        media.sort((a, b) => {
-            const score = (item) => Math.max(0, ...[item.title?.romaji, item.title?.english, item.title?.native]
-                .filter((title) => !!title)
-                .map((title) => pickBestMatch([{ title }], [query ?? ''])?.score ?? 0));
-            return score(b) - score(a);
-        });
-    }
-    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.slice(0, perPage);
-}