@serifpersia/dango 3.3.6 → 3.3.8

package/server/dist/controllers/insights.controller.js

@@ -1,6 +1,6 @@
 import logger from '../logger.js';
 import { InsightsRepository } from '../repositories/insights.repository.js';
-import { computeDiscordSyncStats } from '../lib/discord-roles-sync.service.js';
+import { computeDiscordSyncStats, getCachedRecommendations, } from '../lib/discord-roles-sync.service.js';
 export class InsightsController {
     getWatchInsights = async (req, res) => {
         const db = req.db;
@@ -21,7 +21,8 @@ export class InsightsController {
             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();
-                if (curr - prev < 3600000) {
+                const gap = curr - prev;
+                if (Number.isFinite(gap) && gap > 0 && gap < 3600000) {
                     currentSessionSeconds += allWatches[i].effectiveSeconds ?? allWatches[i].currentTime;
                 }
                 else {
@@ -155,7 +156,7 @@ export class InsightsController {
                     genreData[genre].scores.push(score);
                 genreData[genre].showWatches[row.showId] =
                     (genreData[genre].showWatches[row.showId] || 0) + 1;
-                if (row.name && row.thumbnail) {
+                if (row.name || row.thumbnail) {
                     genreData[genre].showMeta[row.showId] = {
                         name: row.name,
                         nativeName: row.nativeName,
@@ -195,4 +196,8 @@ export class InsightsController {
         const db = req.db;
         res.json(await computeDiscordSyncStats(db));
     };
+    getRecommendations = async (req, res) => {
+        const db = req.db;
+        res.json({ candidates: await getCachedRecommendations(db) });
+    };
 }

package/server/dist/controllers/manga-library.controller.js

@@ -42,6 +42,60 @@ export class MangaLibraryController {
             res.json({ inLibrary: false, status: null });
         }
     };
+    getEntry = async (req, res) => {
+        try {
+            const item = MangaLibraryRepository.getById(mangaDb(req), req.params.id);
+            if (!item)
+                return res.status(404).json({ error: 'Not in library' });
+            res.json({ item });
+        }
+        catch {
+            res.status(500).json({ error: 'Failed to load entry' });
+        }
+    };
+    linkAnilist = async (req, res) => {
+        const { id, anilistId } = req.body ?? {};
+        const targetId = typeof id === 'string' ? id : '';
+        const mediaId = Number(anilistId);
+        if (!targetId || !Number.isInteger(mediaId) || mediaId <= 0) {
+            return res.status(400).json({ error: 'id and a numeric anilistId are required' });
+        }
+        try {
+            const db = mangaDb(req);
+            const row = MangaLibraryRepository.getById(db, targetId);
+            if (!row)
+                return res.status(404).json({ error: 'Library entry not found' });
+            if (String(row.provider).toLowerCase() === 'anilist') {
+                return res
+                    .status(400)
+                    .json({ error: 'Link a provider bookmark to the AniList entry, not the reverse' });
+            }
+            let progressMigrated = false;
+            await performMangaWriteTransaction(db, (tx) => {
+                MangaLibraryRepository.setAnilistId(tx, targetId, mediaId, 'manual');
+                const orphanId = `anilist:${mediaId}`;
+                if (orphanId !== targetId) {
+                    const orphan = MangaLibraryRepository.getById(tx, orphanId);
+                    const target = MangaLibraryRepository.getById(tx, targetId);
+                    const targetProgress = MangaProgressRepository.getByManga(tx, targetId);
+                    if (orphan?.lastChapterNumber &&
+                        !target?.lastChapterNumber &&
+                        targetProgress.length === 0) {
+                        MangaLibraryRepository.setProgressPointer(tx, targetId, orphan.lastChapterNumber);
+                        MangaProgressRepository.moveSyntheticChapters(tx, orphanId, targetId);
+                        progressMigrated = true;
+                    }
+                    MangaLibraryRepository.delete(tx, orphanId);
+                    MangaProgressRepository.deleteByManga(tx, orphanId);
+                }
+            });
+            res.json({ success: true, id: targetId, progressMigrated });
+        }
+        catch (err) {
+            logger.error({ err }, 'Failed to link manga to AniList');
+            res.status(500).json({ error: 'Failed to link entry' });
+        }
+    };
     getLibraryIds = async (req, res) => {
         try {
             res.json({ ids: MangaLibraryRepository.getIds(mangaDb(req)) });

package/server/dist/controllers/proxy.controller.js

@@ -128,6 +128,40 @@ export class ProxyController {
         'vibeplayer.site',
         'aniwatchtv.site',
     ];
+    static NEXABLOOM_FAMILY_SUFFIXES = [
+        '.quavex.top',
+        '.nexabloom.top',
+        '.hiddenvertex.top',
+        '.ironhorizon.top',
+        '.solarhaven.top',
+    ];
+    static NEXABLOOM_FALLBACK_HOSTS = ['fetch.nexabloom.top'];
+    static nexabloomFallbackUrls(urlStr) {
+        let host = '';
+        try {
+            host = new URL(urlStr).hostname.toLowerCase();
+        }
+        catch {
+            return [urlStr];
+        }
+        if (!ProxyController.NEXABLOOM_FAMILY_SUFFIXES.some((s) => host.endsWith(s))) {
+            return [urlStr];
+        }
+        const urls = [urlStr];
+        for (const fallback of ProxyController.NEXABLOOM_FALLBACK_HOSTS) {
+            if (fallback === host)
+                continue;
+            try {
+                const candidate = new URL(urlStr);
+                candidate.hostname = fallback;
+                urls.push(candidate.href);
+            }
+            catch {
+                // ignore
+            }
+        }
+        return urls;
+    }
     static isGotScrapingHost(urlStr) {
         try {
             const host = new URL(urlStr).hostname.toLowerCase();
@@ -259,17 +293,26 @@ export class ProxyController {
                         .set('Access-Control-Allow-Origin', '*')
                         .send(cached);
                 }
-                const resp = await gotScraping({
-                    url: isNexabloomMasterUrl(urlStr) ? signNexabloomMasterUrl(urlStr) : urlStr,
-                    method: 'GET',
-                    headers,
-                    responseType: 'text',
-                    timeout: { request: 30000 },
-                    followRedirect: true,
-                    throwHttpErrors: false,
-                });
-                if (resp.statusCode !== 200 && resp.statusCode !== 206) {
-                    return res.status(resp.statusCode ?? 502).send('Upstream error');
+                const resp = await (async () => {
+                    let last = null;
+                    for (const candidate of ProxyController.nexabloomFallbackUrls(urlStr)) {
+                        const attempt = await gotScraping({
+                            url: isNexabloomMasterUrl(candidate) ? signNexabloomMasterUrl(candidate) : candidate,
+                            method: 'GET',
+                            headers,
+                            responseType: 'text',
+                            timeout: { request: 30000 },
+                            followRedirect: true,
+                            throwHttpErrors: false,
+                        });
+                        last = attempt;
+                        if (attempt.statusCode === 200 || attempt.statusCode === 206)
+                            return attempt;
+                    }
+                    return last;
+                })();
+                if (!resp || (resp.statusCode !== 200 && resp.statusCode !== 206)) {
+                    return res.status(resp?.statusCode ?? 502).send('Upstream error');
                 }
                 const finalUrl = resp.url || urlStr;
                 const baseUrl = new URL(finalUrl);
@@ -314,17 +357,23 @@ export class ProxyController {
                 if (ProxyController.isGotScrapingHost(urlStr)) {
                     if (req.headers.range)
                         headers['Range'] = req.headers.range;
-                    const resp = await gotScraping({
-                        url: urlStr,
-                        method: 'GET',
-                        headers,
-                        responseType: 'buffer',
-                        timeout: { request: 30000 },
-                        followRedirect: true,
-                        throwHttpErrors: false,
-                    });
-                    if (resp.statusCode !== 200 && resp.statusCode !== 206) {
-                        return res.status(resp.statusCode ?? 502).send('Upstream error');
+                    let resp = null;
+                    for (const candidate of ProxyController.nexabloomFallbackUrls(urlStr)) {
+                        const attempt = await gotScraping({
+                            url: candidate,
+                            method: 'GET',
+                            headers,
+                            responseType: 'buffer',
+                            timeout: { request: 30000 },
+                            followRedirect: true,
+                            throwHttpErrors: false,
+                        });
+                        resp = attempt;
+                        if (attempt.statusCode === 200 || attempt.statusCode === 206)
+                            break;
+                    }
+                    if (!resp || (resp.statusCode !== 200 && resp.statusCode !== 206)) {
+                        return res.status(resp?.statusCode ?? 502).send('Upstream error');
                     }
                     const ct = resp.headers['content-type'];
                     const isVtt = urlStr.endsWith('.vtt') || urlStr.includes('.vtt?');
@@ -342,7 +391,29 @@ export class ProxyController {
                     res.send(resp.body);
                 }
                 else {
-                    const upstream = await fetchWithRetry(urlStr, { method: 'GET', headers }, { retries: 3, timeoutMs: 30000, signal: abortController.signal });
+                    let upstream = null;
+                    for (const candidate of ProxyController.nexabloomFallbackUrls(urlStr)) {
+                        if (abortController.signal.aborted)
+                            break;
+                        try {
+                            const attempt = await fetchWithRetry(candidate, { method: 'GET', headers }, { retries: 3, timeoutMs: 30000, signal: abortController.signal });
+                            upstream = attempt;
+                            if (attempt.status === 200 || attempt.status === 206)
+                                break;
+                            try {
+                                await attempt.body?.cancel();
+                            }
+                            catch {
+                                // ignore
+                            }
+                        }
+                        catch {
+                            // ignore
+                        }
+                    }
+                    if (!upstream) {
+                        return res.status(502).send('Upstream error');
+                    }
                     const status = upstream.status;
                     if (status !== 200 && status !== 206) {
                         try {

package/server/dist/controllers/watchlist.controller.js

@@ -11,6 +11,7 @@ import { dbAll, dbGet } from '../utils/db-utils.js';
 import { searchAnilist, searchAnilistByTitle, getAiredEpisodesForShows, getAnilistEpisodes, getShowMetaById, isAnilistRateLimited, batchGetShowStatuses, } from '../lib/anilist.js';
 import { kitsuSearchAnime } from '../lib/kitsu.js';
 import { getMigratedId } from '../lib/migration.js';
+import { offlineDb } from '../lib/offline-db.js';
 const BACKGROUND_DISCOVERY_INTERVAL_MS = 5 * 60 * 1000;
 const NUDGE_THROTTLE_MS = 120 * 1000;
 const SLOW_MAX_RUN_MS = 5 * 60 * 1000;
@@ -449,7 +450,11 @@ export class WatchlistController {
                 if (dual._id !== undefined)
                     dual._id = row.id;
                 try {
-                    ShowsMetaRepository.upsert(db, { id: row.id, thumbnail: poster });
+                    ShowsMetaRepository.upsert(db, {
+                        id: row.id,
+                        thumbnail: poster,
+                        popularityScore: meta?.score ?? (meta?.averageScore != null ? meta.averageScore / 10 : undefined),
+                    });
                 }
                 catch {
                     // ignore
@@ -466,6 +471,55 @@ export class WatchlistController {
             }
         }));
         db.scheduleSave();
+        await this.sweepOfflinePosters(db);
+    }
+    async sweepOfflinePosters(db) {
+        try {
+            db.run(`UPDATE shows_meta SET name = (SELECT w.name FROM watchlist w WHERE w.id = shows_meta.id)
+         WHERE (name IS NULL OR TRIM(name) = '')
+         AND EXISTS (SELECT 1 FROM watchlist w WHERE w.id = shows_meta.id AND w.name IS NOT NULL AND TRIM(w.name) != '')`);
+        }
+        catch {
+            // ignore
+        }
+        const [wlMissing, metaMissing] = await Promise.all([
+            WatchlistRepository.getMissingThumbnails(db),
+            ShowsMetaRepository.getShowIdsMissingMeta(db),
+        ]);
+        const ids = [
+            ...new Set([...wlMissing.map((r) => r.id), ...metaMissing.map((r) => r.id)]),
+        ].slice(0, 500);
+        if (ids.length === 0)
+            return;
+        for (const id of ids) {
+            const poster = this.resolveOfflinePoster(id);
+            if (poster)
+                await this.applyPoster(db, id, poster);
+        }
+        db.scheduleSave();
+    }
+    resolveOfflinePoster(id) {
+        if (/^\d+$/.test(id)) {
+            return offlineDb.getByAnilistId(Number(id))?.thumbnail?.trim() || null;
+        }
+        const mal = /^mal-(\d+)$/i.exec(id)?.[1];
+        if (mal)
+            return offlineDb.getByMalId(Number(mal))?.thumbnail?.trim() || null;
+        return null;
+    }
+    async applyPoster(db, id, poster) {
+        try {
+            ShowsMetaRepository.upsert(db, { id, thumbnail: poster });
+        }
+        catch {
+            // ignore
+        }
+        try {
+            await WatchlistRepository.updateThumbnail(db, id, poster);
+        }
+        catch {
+            // ignore
+        }
     }
     async getContinueWatchingData(req, limit) {
         const rows = await WatchedEpisodesRepository.getContinueWatching(req.db, limit);

package/server/dist/lib/anilist.js

@@ -1128,11 +1128,11 @@ function extractEpisodes(result) {
     }
     return [];
 }
-export async function searchAnilistByTitle(title) {
+export async function searchAnilistByTitle(title, type = 'ANIME') {
     const query = `
     query ($search: String) {
       Page(page: 1, perPage: 5) {
-        media(search: $search, type: ANIME) {
+        media(search: $search, type: ${type}) {
           id
           title { romaji english native }
         }
@@ -1164,7 +1164,7 @@ export async function searchAnilistByTitle(title) {
             break;
     }
     if (!media || media.length === 0) {
-        if (anyFailed && anilistUnavailable()) {
+        if (anyFailed && type === 'ANIME' && anilistUnavailable()) {
             const fb = await kitsuSearchAnime({ query: title, page: 1, perPage: 5 });
             if (fb.length > 0) {
                 const best = fb[0];
@@ -1196,6 +1196,39 @@ export async function searchAnilistByTitle(title) {
     }
     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);

package/server/dist/lib/discord-roles-sync.service.js

@@ -3,10 +3,225 @@ import { CONFIG } from '../config.js';
 import { SettingsRepository } from '../repositories/settings.repository.js';
 import { InsightsRepository } from '../repositories/insights.repository.js';
 import { parseJsonBody } from '../utils/http.utils.js';
+import { anilistRequest } from '../lib/anilist.js';
+function parseGenres(raw) {
+    if (!raw)
+        return [];
+    try {
+        if (raw.startsWith('[')) {
+            const arr = JSON.parse(raw);
+            return Array.isArray(arr) ? arr.map(String) : [];
+        }
+        return raw
+            .split(',')
+            .map((g) => g.trim())
+            .filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+export async function computeTasteProfile(db) {
+    const [rows, anilistRows, epRows] = (await Promise.all([
+        InsightsRepository.getLibraryShowsWithGenres(db),
+        InsightsRepository.getAllAnilistIds(db),
+        InsightsRepository.getWatchedEpisodesWithMeta(db),
+    ]));
+    const genreComp = {};
+    const genreDrop = {};
+    for (const row of rows) {
+        const genres = parseGenres(row.genres);
+        if (row.status === 'Completed') {
+            for (const g of genres)
+                genreComp[g] = (genreComp[g] || 0) + 1;
+        }
+        else if (row.status === 'Dropped') {
+            for (const g of genres)
+                genreDrop[g] = (genreDrop[g] || 0) + 1;
+        }
+    }
+    const watchesByGenre = {};
+    for (const ep of epRows) {
+        const title = ep.englishName || ep.name || ep.showId;
+        for (const g of parseGenres(ep.genres)) {
+            if (!watchesByGenre[g])
+                watchesByGenre[g] = new Map();
+            const entry = watchesByGenre[g].get(ep.showId) || { title, count: 0 };
+            entry.count += 1;
+            watchesByGenre[g].set(ep.showId, entry);
+        }
+    }
+    const exemplars = {};
+    const topGenres = Object.entries(genreComp)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 6);
+    for (const [genre] of topGenres) {
+        exemplars[genre] = [...(watchesByGenre[genre]?.values() || [])]
+            .sort((a, b) => b.count - a.count)
+            .slice(0, 2)
+            .map((e) => e.title);
+    }
+    const knownIds = new Set();
+    for (const row of rows) {
+        if (/^\d+$/.test(row.id))
+            knownIds.add(Number(row.id));
+    }
+    for (const r of anilistRows) {
+        if (r.anilistId)
+            knownIds.add(r.anilistId);
+    }
+    return { genreComp, genreDrop, exemplars, knownIds: [...knownIds] };
+}
+const REC_FIELDS = `id title { romaji english } coverImage { large } averageScore popularity episodes seasonYear format genres isAdult status`;
+function tasteWeights(genreComp, genreDrop) {
+    const max = Math.max(1, ...Object.values(genreComp));
+    const W = {};
+    for (const [g, c] of Object.entries(genreComp)) {
+        const d = genreDrop[g] || 0;
+        W[g] = (c / max) * (c / (c + d));
+    }
+    return W;
+}
+function recCombos(W) {
+    const top = Object.entries(W)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 4)
+        .map(([g]) => g);
+    while (top.length < 2)
+        top.push('Fantasy');
+    const pairs = [
+        [top[0], top[1]],
+        [top[0], top[2] || top[1]],
+        [top[1], top[2] || top[0]],
+        [top[0], top[3] || top[1]],
+    ];
+    const seen = new Set();
+    return pairs.filter((p) => {
+        const key = [...p].sort().join('|');
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function exemplarsForCandidate(exemplars, candidateGenres, n = 2) {
+    const votes = new Map();
+    for (const g of candidateGenres) {
+        for (const t of exemplars[g] || [])
+            votes.set(t, (votes.get(t) || 0) + 1);
+    }
+    return [...votes.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, n)
+        .map(([t]) => t);
+}
+export async function computeRecCandidates(taste) {
+    const knownIds = new Set(taste.knownIds || []);
+    if (knownIds.size === 0)
+        return [];
+    const W = tasteWeights(taste.genreComp, taste.genreDrop);
+    const DEFAULT_W = 0.15;
+    const wsum = Object.values(W).reduce((a, b) => a + b, 0) || 1;
+    const seen = new Map();
+    for (const combo of recCombos(W)) {
+        try {
+            const res = await anilistRequest(`query ($g: [String]) { Page(page: 1, perPage: 20) { media(genre_in: $g, type: ANIME, status: FINISHED, isAdult: false, averageScore_greater: 68, sort: SCORE_DESC) { ${REC_FIELDS} } } }`, { g: combo });
+            for (const m of res?.data?.Page?.media || []) {
+                if (!seen.has(m.id))
+                    seen.set(m.id, m);
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    if (seen.size === 0)
+        return [];
+    const scored = [];
+    for (const m of seen.values()) {
+        if (knownIds.has(m.id) || m.isAdult)
+            continue;
+        if (m.format === 'MUSIC' || m.format === 'SPECIAL')
+            continue;
+        const gs = m.genres || [];
+        const fit = gs.reduce((a, g) => a + (W[g] ?? DEFAULT_W), 0) / wsum;
+        const score = 0.65 * fit +
+            0.25 * ((m.averageScore || 70) / 100) +
+            0.1 * Math.min(1, (m.popularity || 0) / 200000);
+        scored.push({ m, score, overlap: gs.filter((g) => (W[g] ?? 0) > 0.3) });
+    }
+    scored.sort((a, b) => b.score - a.score);
+    const top = scored.slice(0, 15);
+    const relMap = new Map();
+    try {
+        const res = await anilistRequest(`query ($ids: [Int]) { Page(page: 1, perPage: 50) { media(id_in: $ids, type: ANIME) { id relations { edges { relationType node { id title { romaji english } type } } } } } }`, { ids: top.map((t) => t.m.id) });
+        for (const m of res?.data?.Page?.media || [])
+            relMap.set(m.id, m);
+    }
+    catch {
+        // ignore
+    }
+    return top.map((t) => {
+        const rel = relMap.get(t.m.id);
+        const pre = rel?.relations?.edges?.find((e) => e.relationType === 'PREQUEL' && e.node?.type === 'ANIME')?.node;
+        let adj = t.score;
+        let kind = 'entry';
+        let prequelTitle = null;
+        if (pre && pre.id && !knownIds.has(pre.id)) {
+            kind = 'sequel';
+            prequelTitle = pre.title?.english || pre.title?.romaji || null;
+            adj -= 0.3;
+        }
+        else if (pre) {
+            kind = 'continue';
+            adj += 0.05;
+        }
+        const gs = t.m.genres || [];
+        const title = t.m.title?.english || t.m.title?.romaji || 'Unknown';
+        return {
+            id: t.m.id,
+            title,
+            url: `https://anilist.co/anime/${t.m.id}`,
+            cover: t.m.coverImage?.large || null,
+            year: t.m.seasonYear ?? null,
+            format: t.m.format || 'TV',
+            episodes: t.m.episodes ?? null,
+            averageScore: t.m.averageScore ?? null,
+            genres: gs,
+            matchPct: Math.round(adj * 100),
+            sharedGenres: t.overlap,
+            exemplars: exemplarsForCandidate(taste.exemplars, gs),
+            kind,
+            prequelTitle,
+        };
+    });
+}
 const SETTING_KEY = 'discordLinkedUser';
 const SYNC_INTERVAL_MS = 10 * 60 * 1000;
 let syncTimer = null;
 let lastSyncedSeconds = null;
+let lastSyncedTasteHash = null;
+let recCache = null;
+function tasteHashOf(taste) {
+    return JSON.stringify([taste.genreComp, taste.genreDrop, taste.knownIds.length]);
+}
+async function refreshCandidatesIfNeeded(taste, hash) {
+    if (!recCache || recCache.hash !== hash) {
+        try {
+            const fresh = await computeRecCandidates(taste);
+            if (fresh.length > 0)
+                recCache = { hash, candidates: fresh };
+        }
+        catch (err) {
+            logger.warn({ err: err?.message }, 'Recommendation candidates failed, reusing previous');
+        }
+    }
+    return recCache?.candidates || [];
+}
+export async function getCachedRecommendations(db) {
+    const taste = await computeTasteProfile(db);
+    return refreshCandidatesIfNeeded(taste, tasteHashOf(taste));
+}
 export async function getLinkedDiscordUser(db) {
     const row = await SettingsRepository.getByKey(db, SETTING_KEY);
     if (!row?.value)
@@ -22,6 +237,8 @@ export async function setLinkedDiscordUser(db, user) {
     if (!user) {
         await SettingsRepository.deleteByKey(db, SETTING_KEY);
         lastSyncedSeconds = null;
+        lastSyncedTasteHash = null;
+        recCache = null;
     }
     else {
         await SettingsRepository.upsert(db, SETTING_KEY, JSON.stringify(user));
@@ -54,10 +271,16 @@ export async function computeDiscordSyncStats(db) {
         .sort((a, b) => b[1] - a[1])
         .slice(0, 3)
         .map(([name]) => name);
+    const completedCount = core?.completedCount || 0;
+    const totalWatchlist = core?.totalWatchlist || 0;
     return {
         totalSeconds: core?.totalSeconds || 0,
         topGenre,
         genres,
+        totalEpisodes: core?.totalEpisodes || 0,
+        totalAnime: core?.totalAnime || 0,
+        completedCount,
+        completionRate: totalWatchlist > 0 ? Math.round((completedCount / totalWatchlist) * 100) : 0,
     };
 }
 export async function syncDiscordRoles(db, force = false) {
@@ -69,10 +292,16 @@ export async function syncDiscordRoles(db, force = false) {
     if (!user) {
         return { success: false, message: 'No Discord user linked in database' };
     }
-    const { totalSeconds, topGenre, genres } = await computeDiscordSyncStats(db);
-    if (!force && lastSyncedSeconds !== null && totalSeconds === lastSyncedSeconds) {
+    const { totalSeconds, topGenre, genres, totalEpisodes, totalAnime, completedCount, completionRate, } = await computeDiscordSyncStats(db);
+    const taste = await computeTasteProfile(db);
+    const tasteHash = tasteHashOf(taste);
+    if (!force &&
+        lastSyncedSeconds !== null &&
+        totalSeconds === lastSyncedSeconds &&
+        lastSyncedTasteHash === tasteHash) {
         return { success: true, message: 'Watch time unchanged, skipped sync', skipped: true };
     }
+    taste.candidates = await refreshCandidatesIfNeeded(taste, tasteHash);
     try {
         const res = await fetch(`${workerUrl}/api/sync`, {
             method: 'POST',
@@ -83,6 +312,11 @@ export async function syncDiscordRoles(db, force = false) {
                 totalSeconds,
                 topGenre,
                 genres,
+                totalEpisodes,
+                totalAnime,
+                completedCount,
+                completionRate,
+                taste,
                 force,
             }),
         });
@@ -97,6 +331,7 @@ export async function syncDiscordRoles(db, force = false) {
             };
         }
         lastSyncedSeconds = totalSeconds;
+        lastSyncedTasteHash = tasteHash;
         logger.info({
             user: user.username,
             rank: data.rank,