@serifpersia/dango 3.3.9 → 3.4.1

package/server/dist/lib/anilist.js

@@ -764,7 +764,7 @@ export async function findPosterByTitle(title, expected) {
         }
     }
     catch {
-        // ignore, try Kitsu next
+        // ignore
     }
     try {
         const kitsu = await kitsuSearchAnime({ query: clean, page: 1, perPage: 5 });
@@ -1030,7 +1030,7 @@ export async function batchGetShowStatuses(ids) {
             }
         }
         catch {
-            // Kitsu fallback failed
+            // ignore
         }
     }
     return result;
@@ -1324,7 +1324,7 @@ export async function getSchedule(date, format, adult = false) {
                     shows.push(withScheduleFields(meta, entry.episode, entry.airingAt));
                 }
                 catch {
-                    // keep going without this show
+                    // ignore
                 }
             }
         }

package/server/dist/lib/insights.js

@@ -0,0 +1,185 @@
+import logger from '../logger.js';
+import { InsightsRepository } from '../repositories/insights.repository.js';
+export async function getWatchInsights(db) {
+    const [core, activityGrid, hourlyDist, seasonality, allWatches, watchedShows, droppedWarning, velocities,] = (await Promise.all([
+        InsightsRepository.getCoreStats(db),
+        InsightsRepository.getActivityGrid(db),
+        InsightsRepository.getHourlyDist(db),
+        InsightsRepository.getSeasonality(db),
+        InsightsRepository.getAllWatches(db),
+        InsightsRepository.getWatchedShowsMeta(db),
+        InsightsRepository.getDroppedShows(db),
+        InsightsRepository.getCompletionVelocities(db),
+    ]));
+    const bingeFactor = activityGrid.length > 0 ? Math.max(...activityGrid.map((a) => a.count)) : 0;
+    const sessions = [];
+    if (allWatches.length > 0) {
+        let currentSessionSeconds = allWatches[0].effectiveSeconds ?? allWatches[0].currentTime;
+        for (let i = 1; i < allWatches.length; i++) {
+            const prev = new Date(allWatches[i - 1].watchedAt).getTime();
+            const curr = new Date(allWatches[i].watchedAt).getTime();
+            const gap = curr - prev;
+            if (Number.isFinite(gap) && gap > 0 && gap < 3600000) {
+                currentSessionSeconds += allWatches[i].effectiveSeconds ?? allWatches[i].currentTime;
+            }
+            else {
+                sessions.push(currentSessionSeconds);
+                currentSessionSeconds = allWatches[i].effectiveSeconds ?? allWatches[i].currentTime;
+            }
+        }
+        sessions.push(currentSessionSeconds);
+    }
+    const avgSessionMinutes = sessions.length > 0 ? Math.round(sessions.reduce((a, b) => a + b, 0) / sessions.length / 60) : 0;
+    const genreCounts = {};
+    let totalPopScore = 0;
+    let popCount = 0;
+    for (const show of watchedShows) {
+        let genres = [];
+        if (show.genres) {
+            try {
+                if (show.genres.startsWith('[')) {
+                    genres = JSON.parse(show.genres);
+                }
+                else {
+                    genres = show.genres.split(',').map((g) => g.trim());
+                }
+            }
+            catch (e) {
+                logger.warn({ err: e, showId: show.id }, 'Failed to parse genres for insights');
+            }
+        }
+        for (const g of genres) {
+            genreCounts[g] = (genreCounts[g] || 0) + 1;
+        }
+        if (show.popularityScore) {
+            let score = show.popularityScore;
+            if (score > 10)
+                score = score / 10;
+            totalPopScore += score;
+            popCount++;
+        }
+    }
+    const topGenre = Object.entries(genreCounts).sort((a, b) => b[1] - a[1])[0]?.[0];
+    const personaMap = {
+        Action: 'Shonen Warrior',
+        Romance: 'Hopeless Romantic',
+        Comedy: 'Chaos Enjoyer',
+        'Slice of Life': 'Vibe Seeker',
+        Horror: 'Fearless Watcher',
+        Fantasy: 'Isekai Traveller',
+        'Sci-Fi': 'Future Scientist',
+        Drama: 'Feels Collector',
+    };
+    const persona = personaMap[topGenre || ''] || 'Anime Enthusiast';
+    const avgCompletionDays = velocities.length > 0
+        ? Math.round(velocities.reduce((a, b) => a + b.daysToFinish, 0) / velocities.length)
+        : 0;
+    return {
+        totalHours: Math.round((core?.totalSeconds || 0) / 3600),
+        totalEpisodes: core?.totalEpisodes || 0,
+        totalAnime: core?.totalAnime || 0,
+        completedAnime: core?.completedCount || 0,
+        completionRate: core?.totalWatchlist > 0 ? Math.round((core.completedCount / core.totalWatchlist) * 100) : 0,
+        persona,
+        bingeFactor,
+        avgSessionMinutes,
+        avgCompletionDays,
+        popularityScore: popCount > 0 ? Math.round(totalPopScore / popCount) : 0,
+        genreSplit: Object.entries(genreCounts)
+            .map(([name, count]) => ({ name, count }))
+            .sort((a, b) => b.count - a.count)
+            .slice(0, 8) || [],
+        activityGrid: activityGrid || [],
+        hourlyDist: Array.from({ length: 24 }, (_, i) => {
+            const hour = i.toString().padStart(2, '0');
+            return { hour, count: hourlyDist?.find((d) => d.hour === hour)?.count || 0 };
+        }) || [],
+        seasonality: Array.from({ length: 12 }, (_, i) => {
+            const month = (i + 1).toString().padStart(2, '0');
+            return {
+                month,
+                seconds: seasonality?.find((s) => s.month === month)?.seconds || 0,
+            };
+        }) || [],
+        droppedShows: (droppedWarning || []).slice(0, 5),
+    };
+}
+export async function getGenreCards(db) {
+    const rows = await InsightsRepository.getWatchedEpisodesWithMeta(db);
+    const genreData = {};
+    for (const row of rows) {
+        let genres = [];
+        if (row.genres) {
+            try {
+                if (row.genres.startsWith('[')) {
+                    genres = JSON.parse(row.genres);
+                }
+                else {
+                    genres = row.genres.split(',').map((g) => g.trim());
+                }
+            }
+            catch (e) {
+                logger.warn({ err: e, showId: row.showId }, 'Failed to parse genres for genre cards');
+            }
+        }
+        const timeWatched = (row.effectiveSeconds ?? row.currentTime) || 0;
+        let score = row.popularityScore || 0;
+        if (score > 10)
+            score = score / 10;
+        for (const genre of genres) {
+            if (!genreData[genre]) {
+                genreData[genre] = { count: 0, totalTime: 0, scores: [], showWatches: {}, showMeta: {} };
+            }
+            genreData[genre].count++;
+            genreData[genre].totalTime += timeWatched;
+            if (score > 0)
+                genreData[genre].scores.push(score);
+            genreData[genre].showWatches[row.showId] = (genreData[genre].showWatches[row.showId] || 0) + 1;
+            if (row.name || row.thumbnail) {
+                genreData[genre].showMeta[row.showId] = {
+                    name: row.name,
+                    nativeName: row.nativeName,
+                    englishName: row.englishName,
+                    thumbnail: row.thumbnail,
+                };
+            }
+        }
+    }
+    const genreCards = Object.entries(genreData).map(([name, data]) => {
+        const topShows = Object.entries(data.showWatches)
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 4)
+            .map(([showId]) => ({
+            id: showId,
+            name: data.showMeta[showId]?.name || '',
+            nativeName: data.showMeta[showId]?.nativeName,
+            englishName: data.showMeta[showId]?.englishName,
+            thumbnail: data.showMeta[showId]?.thumbnail || '',
+        }));
+        return {
+            rank: 0,
+            name,
+            count: data.count,
+            meanScore: data.scores.length > 0 ? data.scores.reduce((a, b) => a + b, 0) / data.scores.length : 0,
+            timeWatched: formatTime(data.totalTime),
+            topShows,
+        };
+    });
+    genreCards.sort((a, b) => b.count - a.count);
+    genreCards.forEach((card, i) => {
+        card.rank = i + 1;
+    });
+    return genreCards;
+}
+function formatTime(seconds) {
+    const days = Math.floor(seconds / 86400);
+    const hours = Math.floor((seconds % 86400) / 3600);
+    const minutes = Math.floor((seconds % 3600) / 60);
+    if (days > 0) {
+        return `${days} days ${hours > 0 ? `${hours} hours` : ''}`;
+    }
+    if (hours > 0) {
+        return `${hours} hours${minutes > 0 ? ` ${minutes} mins` : ''}`;
+    }
+    return `${minutes} mins`;
+}

package/server/dist/lib/ipc.js

@@ -6,8 +6,7 @@ function sendToParent(message) {
         }
     }
     catch {
-        // No IPC channel (dev under npm, or parent already gone).
-        // The stdout tag below remains the fallback signal.
+        // ignore
     }
 }
 export function notifySyncStart(message) {

package/server/dist/lib/kitsu.js

@@ -44,7 +44,6 @@ function asArray(data) {
         return [];
     return Array.isArray(data) ? data : [data];
 }
-/** Builds a map of kitsu relationship id -> included resource for a given type. */
 function includedMap(entry, included, type) {
     if (!included || !entry.relationships)
         return [];
@@ -57,7 +56,6 @@ function includedMap(entry, included, type) {
     }
     return included.filter((i) => i.type === type && ids.has(i.id));
 }
-/** Kitsu status/subtype/season values are lowercase; map to AniList-style values. */
 const STATUS_MAP = {
     current: 'RELEASING',
     finished: 'FINISHED',
@@ -125,7 +123,6 @@ function anilistSortToKitsu(sort) {
             return '-userCount';
     }
 }
-/** Translates an AniList-style status filter to a Kitsu filter value. */
 function statusToKitsuFilter(status) {
     if (!status)
         return undefined;
@@ -143,7 +140,6 @@ function seasonToKitsu(season) {
         return undefined;
     return season.toLowerCase();
 }
-/** Kitsu genre-ish taxonomy: `categories`. */
 const CATEGORY_ALIASES = {
     'Sci-Fi': 'Science Fiction',
     'Sci Fi': 'Science Fiction',
@@ -154,9 +150,6 @@ function normalizeCategory(cat) {
     const alias = Object.entries(CATEGORY_ALIASES).find(([k]) => k.toLowerCase() === c.toLowerCase());
     return alias ? alias[1] : c;
 }
-/**
- * Resolves the included anime resource linked by a mapping entry's `item` relationship.
- */
 function mappingItem(entry, included) {
     const rel = entry.relationships?.item?.data;
     if (!rel)
@@ -165,10 +158,6 @@ function mappingItem(entry, included) {
         return undefined;
     return included.find((i) => i.type === rel.type && i.id === rel.id);
 }
-/**
- * Fetches a list of anime from Kitsu and normalizes entries to AnilistMedia.
- * `include=mappings,categories` gives AniList/MAL ids + genres in one request.
- */
 export async function kitsuSearchAnime(options = {}) {
     const { query, page = 1, perPage = 14, format, status, season, seasonYear, genre, genre_in, genre_not_in, averageScore_greater, episodes_greater, isAdult, sort, } = options;
     const filters = [];
@@ -223,7 +212,6 @@ export async function kitsuSearchAnime(options = {}) {
     }
     return results;
 }
-/** Deduplicates by the resolved AniList/MAL id (keeps the first occurrence). */
 export function dedupeKitsuMedia(list) {
     const seen = new Set();
     const out = [];
@@ -236,7 +224,6 @@ export function dedupeKitsuMedia(list) {
     }
     return out;
 }
-/** Converts a Kitsu entry + included resources into AnilistMedia (id = AniList or MAL id). */
 function normalizeKitsuEntry(entry, included, knownIds) {
     const a = entry.attributes;
     const mappings = includedMap(entry, included, 'mappings');
@@ -298,9 +285,6 @@ function normalizeKitsuEntry(entry, included, knownIds) {
             : null,
     };
 }
-/**
- * Finds the Kitsu entry id for a given AniList id via the mappings endpoint.
- */
 async function kitsuIdByAnilistId(anilistId) {
     const json = await kitsuFetch(`/mappings?filter[externalSite]=anilist%2Fanime&filter[externalId]=${anilistId}&include=item`);
     const entries = asArray(json?.data);
@@ -340,12 +324,11 @@ export async function kitsuBatchGetStatuses(anilistIds) {
                 result.set(id, status);
         }
         catch {
-            // skip failed lookups
+            // ignore
         }
     }
     return result;
 }
-/** Fetches full detail (genres + studios) for a Kitsu anime id. */
 async function kitsuDetail(kitsuId, knownIds) {
     const [animeJson, studiosJson] = await Promise.all([
         kitsuFetch(`/anime/${kitsuId}?include=categories,mappings`),
@@ -384,7 +367,6 @@ export async function kitsuMetaByMalId(malId) {
         return null;
     return kitsuDetail(item.id, { malId });
 }
-/** Batch-resolves English/Japanese titles for MAL ids via the mappings endpoint. */
 export async function kitsuTitlesByMalIds(malIds) {
     const result = new Map();
     const unique = [...new Set(malIds.filter((n) => Number.isFinite(n) && n > 0))];
@@ -424,7 +406,6 @@ export async function kitsuTitlesByMalIds(malIds) {
     }));
     return result;
 }
-/** Episode numbers for a show, via the episodes relationship. */
 export async function kitsuEpisodes(anilistId, idMal) {
     let kitsuId = null;
     if (anilistId > 0)
@@ -462,7 +443,6 @@ export async function kitsuEpisodes(anilistId, idMal) {
     const max = Math.max(...all);
     return Array.from({ length: max }, (_, i) => (i + 1).toString());
 }
-/** Trending proxy: currently-airing shows sorted by popularity (user count). */
 export async function kitsuTrending(page = 1, perPage = 20, status) {
     const statusFilter = statusToKitsuFilter(status);
     const filters = statusFilter ? `filter[status]=${statusFilter}` : '';
@@ -474,7 +454,6 @@ export async function kitsuTrending(page = 1, perPage = 20, status) {
         .map((e) => normalizeKitsuEntry(e, json.included ?? []))
         .filter((m) => m !== null));
 }
-/** Spotlight: top popular shows with native Kitsu banners (3360x800). */
 export async function kitsuSpotlight(page = 1, perPage = 20) {
     const offset = (page - 1) * perPage;
     const json = await kitsuFetch(`/anime?sort=-userCount&page[limit]=${perPage}&page[offset]=${offset}&include=mappings,categories`);
@@ -485,11 +464,6 @@ export async function kitsuSpotlight(page = 1, perPage = 20) {
         .filter((m) => m !== null)
         .filter((m) => !!m.bannerImage));
 }
-/**
- * Latest releases: currently-airing shows. Kitsu has no reliable episode airdates,
- * so we sort current shows by start date (newest first) and bump shows with a known
- * next episode date to the front (soonest first).
- */
 export async function kitsuLatestReleases(format = 'TV', page = 1, size = 12) {
     const needed = page * size;
     const formatFilter = format && format !== 'ALL' ? `filter[subtype]=${format.toLowerCase()}` : '';
@@ -528,7 +502,6 @@ export async function kitsuLatestReleases(format = 'TV', page = 1, size = 12) {
 function fallbackStartRank(m) {
     return ((m.startDate?.year ?? 0) * 10000 + (m.startDate?.month ?? 0) * 100 + (m.startDate?.day ?? 0));
 }
-/** Seasonal list for a given season/year, matching AniList's POPULARITY_DESC order. */
 export async function kitsuSeasonal(season, year, format, page = 1, size = 14) {
     const filters = [`filter[season]=${seasonToKitsu(season)}`, `filter[seasonYear]=${year}`];
     if (format && format !== 'ALL' && format !== 'ADULT') {

package/server/dist/lib/mal-import.js

@@ -0,0 +1,291 @@
+import { XMLParser } from 'fast-xml-parser';
+import { searchAnilistByTitle, isAnilistRateLimited, getShowMetaById } from './anilist.js';
+import { kitsuSearchAnime } from './kitsu.js';
+import { offlineDb } from './offline-db.js';
+import { SettingsRepository } from '../repositories/settings.repository.js';
+import { ShowsMetaRepository } from '../repositories/shows-meta.repository.js';
+import { performWriteTransactionAsync } from '../sync.js';
+import logger from '../logger.js';
+let activeImportStatus = {
+    running: false,
+    current: 0,
+    total: 0,
+    phase: 'done',
+    source: null,
+};
+let activeImportCancelled = false;
+export function getMalImportStatus() {
+    return activeImportStatus;
+}
+export function requestMalImportCancel() {
+    if (!activeImportStatus.running) {
+        return { success: true, message: 'No import running' };
+    }
+    activeImportCancelled = true;
+    return { success: true, message: 'Import cancellation requested' };
+}
+export function prepareMalImport(fileBuffer, flags) {
+    if (activeImportStatus.running) {
+        return { ok: false, status: 409, body: { error: 'An import is already in progress' } };
+    }
+    if (!fileBuffer)
+        return { ok: false, status: 400, body: { error: 'No file' } };
+    const { erase, useOfflineDb, skipFallback } = flags;
+    const offlineEnabled = useOfflineDb !== 'false' && useOfflineDb !== false && useOfflineDb !== '0';
+    const shouldSkipFallback = skipFallback === 'true' || skipFallback === true || skipFallback === '1';
+    let result;
+    try {
+        result = malXmlParser.parse(fileBuffer.toString());
+    }
+    catch {
+        return { ok: false, status: 400, body: { error: 'Invalid XML' } };
+    }
+    const animeList = result?.myanimelist?.anime || [];
+    if (animeList.length === 0) {
+        return { ok: false, status: 400, body: { error: 'No anime found in XML' } };
+    }
+    activeImportCancelled = false;
+    activeImportStatus = {
+        running: true,
+        current: 0,
+        total: animeList.length,
+        phase: 'offline',
+        source: 'offline',
+    };
+    return { ok: true, import: { animeList, erase, offlineEnabled, shouldSkipFallback } };
+}
+export async function executeMalImport(db, prepared, sendEvent) {
+    const { animeList, erase, offlineEnabled, shouldSkipFallback } = prepared;
+    const total = animeList.length;
+    let skippedCount = 0;
+    const offlineShows = [];
+    const offlineMeta = [];
+    const fallbackQueue = [];
+    for (const item of animeList) {
+        const malTitle = xmlText(item.series_title);
+        const status = mapMalStatus(xmlText(item.my_status));
+        let matched = false;
+        if (offlineEnabled) {
+            const malId = parseInt(xmlText(item.series_animedb_id), 10);
+            if (malId && !Number.isNaN(malId)) {
+                const entry = offlineDb.getByMalId(malId);
+                if (entry) {
+                    matched = true;
+                    const showId = String(entry.anilistId);
+                    const title = entry.title || malTitle;
+                    offlineShows.push({ id: showId, name: title, thumbnail: entry.thumbnail, status });
+                    if (entry.thumbnail || entry.type || entry.genres) {
+                        offlineMeta.push({
+                            id: showId,
+                            thumbnail: entry.thumbnail,
+                            type: entry.type,
+                            genres: entry.genres,
+                        });
+                    }
+                    activeImportStatus = {
+                        running: true,
+                        current: offlineShows.length,
+                        total,
+                        phase: 'offline',
+                        source: 'offline',
+                        title: malTitle,
+                        matchedTitle: title,
+                        status,
+                        found: true,
+                        imported: offlineShows.length,
+                    };
+                    sendEvent('progress', {
+                        current: offlineShows.length,
+                        total,
+                        title: malTitle,
+                        matchedTitle: title,
+                        status,
+                        source: 'offline',
+                        found: true,
+                    });
+                }
+            }
+        }
+        if (!matched)
+            fallbackQueue.push(item);
+    }
+    if (offlineShows.length > 0 || erase) {
+        try {
+            await performWriteTransactionAsync(db, async (tx) => {
+                if (erase)
+                    await SettingsRepository.clearWatchlist(tx);
+                await SettingsRepository.upsertWatchlistBatch(tx, offlineShows);
+                for (const meta of offlineMeta) {
+                    if (meta.thumbnail || meta.type || meta.genres) {
+                        await ShowsMetaRepository.upsert(tx, {
+                            id: meta.id,
+                            thumbnail: meta.thumbnail,
+                            type: meta.type,
+                            genres: meta.genres,
+                        });
+                    }
+                }
+            });
+        }
+        catch (dbErr) {
+            logger.error({ err: dbErr }, 'Failed to commit offline import matches');
+        }
+    }
+    let fallbackImported = 0;
+    if (shouldSkipFallback || activeImportCancelled) {
+        skippedCount += fallbackQueue.length;
+    }
+    else if (fallbackQueue.length > 0) {
+        activeImportStatus = { ...activeImportStatus, phase: 'fallback', source: null };
+        const BATCH_SIZE = 5;
+        for (let i = 0; i < fallbackQueue.length; i += BATCH_SIZE) {
+            if (activeImportCancelled) {
+                skippedCount += fallbackQueue.length - i;
+                break;
+            }
+            const batch = fallbackQueue.slice(i, i + BATCH_SIZE);
+            const batchResults = await Promise.allSettled(batch.map((item) => searchByTitleForMal(xmlText(item.series_title))));
+            const batchShows = [];
+            const batchMeta = [];
+            const metaPromises = [];
+            batchResults.forEach((r, idx) => {
+                const malTitle = xmlText(batch[idx].series_title);
+                const status = mapMalStatus(xmlText(batch[idx].my_status));
+                const current = offlineShows.length + fallbackImported + idx + 1;
+                if (r.status === 'fulfilled' && r.value) {
+                    const show = r.value;
+                    const title = show.title?.english || show.title?.romaji || malTitle;
+                    batchShows.push({ id: String(show.id), name: title, status });
+                    activeImportStatus = {
+                        running: true,
+                        current,
+                        total,
+                        phase: 'fallback',
+                        source: show.source,
+                        title: malTitle,
+                        matchedTitle: title,
+                        status,
+                        found: true,
+                        imported: offlineShows.length + fallbackImported + 1,
+                    };
+                    sendEvent('progress', {
+                        current,
+                        total,
+                        title: malTitle,
+                        matchedTitle: title,
+                        status,
+                        source: show.source,
+                        found: true,
+                    });
+                    metaPromises.push(getShowMetaById(String(show.id))
+                        .then((meta) => {
+                        if (meta) {
+                            batchMeta.push({
+                                id: String(show.id),
+                                thumbnail: meta.thumbnail || undefined,
+                                type: meta.type || undefined,
+                            });
+                        }
+                    })
+                        .catch(() => { }));
+                }
+                else {
+                    skippedCount++;
+                    activeImportStatus = {
+                        running: true,
+                        current,
+                        total,
+                        phase: 'fallback',
+                        source: null,
+                        title: malTitle,
+                        matchedTitle: null,
+                        status,
+                        found: false,
+                        imported: offlineShows.length + fallbackImported,
+                    };
+                    sendEvent('progress', {
+                        current,
+                        total,
+                        title: malTitle,
+                        matchedTitle: null,
+                        status,
+                        source: null,
+                        found: false,
+                    });
+                }
+            });
+            await Promise.allSettled(metaPromises);
+            if (batchShows.length > 0) {
+                try {
+                    await performWriteTransactionAsync(db, async (tx) => {
+                        await SettingsRepository.upsertWatchlistBatch(tx, batchShows);
+                        for (const meta of batchMeta) {
+                            if (meta.thumbnail) {
+                                await ShowsMetaRepository.upsert(tx, {
+                                    id: meta.id,
+                                    thumbnail: meta.thumbnail,
+                                    type: meta.type,
+                                });
+                            }
+                        }
+                    });
+                    fallbackImported += batchShows.length;
+                }
+                catch (dbErr) {
+                    logger.error({ err: dbErr }, 'Failed to commit fallback import batch');
+                    skippedCount += batchShows.length;
+                }
+            }
+        }
+    }
+    const imported = offlineShows.length + fallbackImported;
+    activeImportStatus = {
+        running: false,
+        current: total,
+        total,
+        phase: 'done',
+        source: null,
+        imported,
+        skipped: skippedCount,
+    };
+    sendEvent('complete', { imported, skipped: skippedCount });
+}
+function xmlText(value) {
+    if (Array.isArray(value))
+        return String(value[0] ?? '');
+    return String(value ?? '');
+}
+function mapMalStatus(malStatus) {
+    switch (malStatus) {
+        case 'Plan to Watch':
+            return 'Planned';
+        case 'On Hold':
+            return 'On-Hold';
+        default:
+            return malStatus;
+    }
+}
+const malXmlParser = new XMLParser({
+    isArray: (name) => name === 'anime',
+    parseTagValue: false,
+    trimValues: true,
+});
+async function searchByTitleForMal(title) {
+    const result = await searchAnilistByTitle(title);
+    if (result)
+        return { ...result, source: 'anilist' };
+    if (isAnilistRateLimited()) {
+        logger.debug({ title }, 'AniList rate limited, trying Kitsu fallback for MAL import');
+        const fb = await kitsuSearchAnime({ query: title, page: 1, perPage: 5 });
+        if (fb.length > 0) {
+            const lowerTitle = title.toLowerCase();
+            const exactMatch = fb.find((m) => m.title?.romaji?.toLowerCase() === lowerTitle ||
+                m.title?.english?.toLowerCase() === lowerTitle);
+            const best = exactMatch || fb[0];
+            if (best.id > 0) {
+                return { id: best.id, title: best.title ?? {}, source: 'kitsu' };
+            }
+        }
+    }
+    return null;
+}