@serifpersia/dango 3.6.7 → 3.6.9

package/server/dist/lib/tracker/manga-sync.service.js

@@ -1,773 +0,0 @@
-import { AniListTracker } from './anilist-tracker.js';
-import { MangaLibraryRepository, MangaProgressRepository, } from '../../repositories/manga.repository.js';
-import { SettingsRepository } from '../../repositories/settings.repository.js';
-import { performMangaWriteTransactionAsync, performWriteTransactionAsync } from '../../sync.js';
-import logger from '../../logger.js';
-import { searchAnilistMangaByTitle, getMangaMetaById, getMangaMetaByMalId } from '../anilist.js';
-import { fetchMalMangaList, mapMalMangaStatusCode } from '../mal.js';
-import { readTrackerSyncState, resolveStatus, } from './sync-state.js';
-const TOKEN_KEY = 'tracker_anilist_token';
-const MANGA_SYNC_STATE_KEY = 'tracker_anilist_manga_sync_state';
-const MANGA_PROVIDER = 'anilist';
-const MAX_TITLE_LOOKUPS_PER_SYNC = 25;
-function parseChapterProgress(value) {
-    if (value == null)
-        return 0;
-    const matches = String(value).match(/(\d+(?:\.\d+)?)/g);
-    if (!matches)
-        return 0;
-    let best = 0;
-    for (const m of matches) {
-        const n = Number(m);
-        if (Number.isFinite(n))
-            best = Math.max(best, Math.floor(n));
-    }
-    return best;
-}
-async function getLocalChapterProgress(mangaDb, libraryId, lastChapterNumber) {
-    let best = parseChapterProgress(lastChapterNumber);
-    try {
-        const rows = await MangaProgressRepository.getByManga(mangaDb, libraryId);
-        for (const row of rows ?? []) {
-            best = Math.max(best, parseChapterProgress(row.chapterNumber));
-        }
-    }
-    catch {
-        // ignore
-    }
-    return best;
-}
-function buildAnilistMangaId(mediaId) {
-    return `${MANGA_PROVIDER}:${mediaId}`;
-}
-function buildSyntheticChapterId(progress) {
-    return `${MANGA_PROVIDER}:ch:${progress}`;
-}
-function parseAnilistMangaId(id) {
-    const match = /^anilist:(\d+)$/i.exec(id.trim());
-    if (!match)
-        return null;
-    const n = Number.parseInt(match[1], 10);
-    return Number.isFinite(n) ? n : null;
-}
-function mangaStatusOrFallback(status) {
-    const known = ['Reading', 'Completed', 'On-Hold', 'Dropped', 'Planned'];
-    return known.includes(status) ? status : undefined;
-}
-function normalizeTitle(value) {
-    return String(value ?? '')
-        .normalize('NFD')
-        .replace(/[\u0300-\u036f]/g, '')
-        .toLowerCase()
-        .replace(/[^\p{L}\p{N}]+/gu, ' ')
-        .replace(/\s+/g, ' ')
-        .trim();
-}
-function titlesEqual(a, b) {
-    const na = normalizeTitle(a);
-    return na.length > 0 && na === normalizeTitle(b);
-}
-function stripEditionSuffix(value) {
-    let s = String(value ?? '').trim();
-    let prev = '';
-    while (prev !== s) {
-        prev = s;
-        s = s.replace(/\s*\([^()]*\)$/, '').trim();
-    }
-    return s;
-}
-function matchesStrippedBaseTitle(item, match) {
-    const candidates = [item.title, item.altTitle]
-        .filter((c) => !!c)
-        .map(stripEditionSuffix)
-        .filter((c) => c.length > 0);
-    const remotes = [match.romaji, match.english, match.native]
-        .filter((r) => !!r)
-        .map(stripEditionSuffix)
-        .filter((r) => r.length > 0);
-    return candidates.some((c) => remotes.some((r) => titlesEqual(c, r)));
-}
-function isExactTitleMatch(item, match) {
-    const candidates = [item.title, item.altTitle];
-    const remotes = [match.romaji, match.english, match.native];
-    return candidates.some((c) => !!c && remotes.some((r) => !!r && titlesEqual(c, r)));
-}
-export async function syncAniListManga(db, mangaDb, opts = {}) {
-    const direction = opts.direction === 'pull-only' ? 'pull-only' : 'two-way';
-    const pullOnly = direction === 'pull-only';
-    const tokenRow = await SettingsRepository.getByKey(db, TOKEN_KEY);
-    const token = tokenRow?.value;
-    if (!token)
-        throw new Error('AniList is not connected. Please log in first.');
-    const tracker = new AniListTracker(token);
-    const viewer = await tracker.getViewer();
-    const remoteEntries = await tracker.fetchUserMangaList(viewer.id);
-    const localItems = await MangaLibraryRepository.getAll(mangaDb);
-    const syncState = await readTrackerSyncState(db, MANGA_SYNC_STATE_KEY);
-    const remoteByMediaId = new Map();
-    for (const entry of remoteEntries)
-        remoteByMediaId.set(entry.mediaId, entry);
-    const localByMediaId = new Map();
-    const newLinks = [];
-    const searchedMediaIds = new Set();
-    const preexistingLinks = new Map();
-    let titleLookups = 0;
-    let unresolved = 0;
-    const details = [];
-    const record = (detail) => {
-        details.push(detail);
-    };
-    const pendingWarnings = [];
-    for (const item of localItems) {
-        let anilistId = typeof item.anilistId === 'number' ? item.anilistId : null;
-        const fromColumn = anilistId != null;
-        const columnSource = fromColumn ? (item.anilistIdSource ?? null) : null;
-        let preexisting = fromColumn;
-        if (anilistId == null) {
-            anilistId = parseAnilistMangaId(item.id);
-            preexisting = anilistId != null;
-        }
-        if (anilistId == null && item.provider && item.mangaId) {
-            const fromParts = String(item.provider).toLowerCase() === MANGA_PROVIDER &&
-                /^\d+$/.test(String(item.mangaId).trim())
-                ? Number.parseInt(String(item.mangaId).trim(), 10)
-                : null;
-            if (fromParts != null) {
-                anilistId = fromParts;
-                preexisting = true;
-            }
-        }
-        if (anilistId == null) {
-            if (titleLookups >= MAX_TITLE_LOOKUPS_PER_SYNC || !item.title) {
-                unresolved++;
-                record({
-                    title: item.title || item.id,
-                    action: 'unresolved',
-                    note: 'No AniList link yet — skipped so nothing is written to the wrong series.',
-                });
-                continue;
-            }
-            titleLookups++;
-            try {
-                const match = await searchAnilistMangaByTitle(item.title);
-                if (match && isExactTitleMatch(item, match.title)) {
-                    anilistId = match.id;
-                    preexisting = false;
-                    newLinks.push({ id: item.id, anilistId: match.id });
-                    searchedMediaIds.add(match.id);
-                }
-                else {
-                    unresolved++;
-                    record({
-                        title: item.title,
-                        action: 'unresolved',
-                        note: match
-                            ? `Closest AniList match ("${match.title.english || match.title.romaji || match.title.native}") is not an exact title match — skipped so nothing is written to the wrong series.`
-                            : 'No AniList match found — skipped.',
-                    });
-                    continue;
-                }
-            }
-            catch (err) {
-                logger.warn({ err, mangaId: item.id }, '[AniList Manga Sync] Title lookup failed');
-                unresolved++;
-                record({
-                    title: item.title || item.id,
-                    action: 'unresolved',
-                    note: 'Title lookup failed — skipped.',
-                });
-                continue;
-            }
-        }
-        if (!localByMediaId.has(anilistId)) {
-            localByMediaId.set(anilistId, item);
-            if (preexisting && fromColumn && !searchedMediaIds.has(anilistId)) {
-                preexistingLinks.set(anilistId, {
-                    title: item.title,
-                    altTitle: item.altTitle,
-                    source: columnSource,
-                });
-            }
-        }
-    }
-    const suspectMediaIds = new Set();
-    for (const [mediaId, link] of preexistingLinks) {
-        const remote = remoteByMediaId.get(mediaId);
-        if (!remote)
-            continue;
-        if (link.source === 'manual' || link.source === 'anilist' || link.source === 'search')
-            continue;
-        if (isExactTitleMatch(link, remote.title))
-            continue;
-        if (matchesStrippedBaseTitle(link, remote.title))
-            continue;
-        suspectMediaIds.add(mediaId);
-        const remoteLabel = remote.title.english || remote.title.romaji || remote.title.native || `Manga #${mediaId}`;
-        pendingWarnings.push(`"${link.title}" is linked to AniList #${mediaId} ("${remoteLabel}") by an older automatic match and the titles do not match — skipped in both directions to protect your AniList list.`);
-        record({
-            mediaId,
-            title: link.title,
-            action: 'suspicious',
-            remoteStatus: remote.status,
-            remoteProgress: remote.progress,
-            note: `Linked AniList title is "${remoteLabel}".`,
-        });
-    }
-    const allMediaIds = new Set([
-        ...localByMediaId.keys(),
-        ...remoteByMediaId.keys(),
-        ...Object.keys(syncState)
-            .map((k) => Number.parseInt(k, 10))
-            .filter((n) => Number.isFinite(n)),
-    ]);
-    const summary = {
-        pushed: 0,
-        pulled: 0,
-        merged: 0,
-        unchanged: 0,
-        skipped: 0,
-        errors: [],
-        warnings: pendingWarnings,
-    };
-    const libraryUpserts = [];
-    const progressPointers = [];
-    const progressRows = [];
-    const libraryDeletes = [];
-    const stateUpdates = {};
-    const pushUpdates = [];
-    const remoteDeleteEntryIds = [];
-    const now = Math.floor(Date.now() / 1000);
-    for (const mediaId of allMediaIds) {
-        if (suspectMediaIds.has(mediaId))
-            continue;
-        const local = localByMediaId.get(mediaId);
-        const remote = remoteByMediaId.get(mediaId);
-        const stateKey = String(mediaId);
-        const localId = local?.id ?? buildAnilistMangaId(mediaId);
-        try {
-            if (local && !remote) {
-                if (syncState[stateKey] && remoteEntries.length > 0) {
-                    if (pullOnly) {
-                        summary.skipped++;
-                        record({
-                            mediaId,
-                            title: local.title,
-                            action: 'skipped',
-                            localStatus: local.status,
-                            note: 'Pull-only mode — local entry kept, nothing deleted.',
-                        });
-                        continue;
-                    }
-                    libraryDeletes.push(local.id);
-                    stateUpdates[stateKey] = undefined;
-                    summary.pulled++;
-                    record({ mediaId, title: local.title, action: 'delete-local', localStatus: local.status });
-                    continue;
-                }
-                const chapters = await getLocalChapterProgress(mangaDb, local.id, local.lastChapterNumber);
-                if (pullOnly) {
-                    summary.skipped++;
-                    record({
-                        mediaId,
-                        title: local.title,
-                        action: 'skipped',
-                        localStatus: local.status,
-                        localChapters: chapters,
-                        note: 'Pull-only mode — not pushed to AniList.',
-                    });
-                    continue;
-                }
-                const status = mangaStatusOrFallback(local.status);
-                if (!status || (status === 'Planned' && chapters === 0)) {
-                    summary.skipped++;
-                    record({
-                        mediaId,
-                        title: local.title,
-                        action: 'skipped',
-                        localStatus: local.status,
-                        localChapters: chapters,
-                        note: 'Bookmark with no chapters read — not pushed to AniList.',
-                    });
-                    continue;
-                }
-                pushUpdates.push({
-                    mediaId,
-                    status,
-                    progress: chapters,
-                });
-                stateUpdates[stateKey] = { lastSyncedAt: now, remoteUpdatedAt: now };
-                summary.pushed++;
-                record({
-                    mediaId,
-                    title: local.title,
-                    action: 'push',
-                    localStatus: local.status,
-                    localChapters: chapters,
-                });
-                continue;
-            }
-            if (!local && remote) {
-                if (syncState[stateKey] && !pullOnly) {
-                    if (remote.entryId) {
-                        remoteDeleteEntryIds.push({ showId: stateKey, entryId: remote.entryId });
-                        stateUpdates[stateKey] = undefined;
-                        summary.pushed++;
-                        record({
-                            mediaId,
-                            title: remote.title.english || remote.title.romaji || `Manga #${mediaId}`,
-                            action: 'delete-remote',
-                            remoteStatus: remote.status,
-                            remoteProgress: remote.progress,
-                            note: 'Removed locally after a previous sync — delete propagated to AniList.',
-                        });
-                        continue;
-                    }
-                    stateUpdates[stateKey] = undefined;
-                    summary.pushed++;
-                    record({ mediaId, title: `Manga #${mediaId}`, action: 'delete-remote' });
-                    continue;
-                }
-                logger.debug({ mediaId, remoteStatus: remote.status }, '[AniList Manga Sync] Remote only -> pulling to local');
-                const title = remote.title.english || remote.title.romaji || `Manga #${mediaId}`;
-                libraryUpserts.push({
-                    id: buildAnilistMangaId(mediaId),
-                    provider: MANGA_PROVIDER,
-                    mangaId: String(mediaId),
-                    title,
-                    cover: remote.coverImage ?? '',
-                    status: remote.status,
-                    anilistId: mediaId,
-                    anilistIdSource: 'anilist',
-                });
-                if (remote.progress > 0) {
-                    progressPointers.push({
-                        id: buildAnilistMangaId(mediaId),
-                        chapterNumber: String(remote.progress),
-                    });
-                    progressRows.push({
-                        mangaId: buildAnilistMangaId(mediaId),
-                        chapterId: buildSyntheticChapterId(remote.progress),
-                        chapterNumber: String(remote.progress),
-                        title,
-                        cover: remote.coverImage ?? '',
-                        provider: MANGA_PROVIDER,
-                    });
-                }
-                stateUpdates[stateKey] = { lastSyncedAt: now, remoteUpdatedAt: remote.updatedAt };
-                summary.pulled++;
-                record({
-                    mediaId,
-                    title,
-                    action: 'pull',
-                    remoteStatus: remote.status,
-                    remoteProgress: remote.progress,
-                });
-                continue;
-            }
-            if (!local && !remote && syncState[stateKey]) {
-                stateUpdates[stateKey] = undefined;
-                continue;
-            }
-            if (local && remote) {
-                const localChapters = await getLocalChapterProgress(mangaDb, local.id, local.lastChapterNumber);
-                const localLastSync = syncState[stateKey]?.lastSyncedAt ?? 0;
-                const remoteUpdated = remote.updatedAt || 0;
-                const targetProgress = Math.max(localChapters, remote.progress);
-                const shouldPushProgress = localChapters > remote.progress;
-                const shouldPullProgress = remote.progress > localChapters;
-                const { status: targetStatus, pull: pullStatus } = resolveStatus(local.status, remote.status, remoteUpdated, localLastSync);
-                const statusDiffers = remote.status !== local.status;
-                if (pullOnly) {
-                    if (pullStatus || shouldPullProgress) {
-                        if (pullStatus && targetStatus !== local.status) {
-                            libraryUpserts.push({
-                                id: local.id,
-                                provider: local.provider,
-                                mangaId: local.mangaId,
-                                title: local.title,
-                                cover: local.cover ?? '',
-                                status: targetStatus,
-                                anilistId: mediaId,
-                            });
-                        }
-                        if (shouldPullProgress) {
-                            progressPointers.push({ id: localId, chapterNumber: String(targetProgress) });
-                            progressRows.push({
-                                mangaId: localId,
-                                chapterId: buildSyntheticChapterId(targetProgress),
-                                chapterNumber: String(targetProgress),
-                                title: local.title,
-                                cover: local.cover ?? '',
-                                provider: local.provider,
-                            });
-                        }
-                        stateUpdates[stateKey] = { lastSyncedAt: now, remoteUpdatedAt: remoteUpdated };
-                        summary.merged++;
-                        record({
-                            mediaId,
-                            title: local.title,
-                            action: 'merge-pull',
-                            localStatus: local.status,
-                            remoteStatus: targetStatus,
-                            localChapters: localChapters,
-                            remoteProgress: targetProgress,
-                        });
-                    }
-                    else if (shouldPushProgress || statusDiffers) {
-                        summary.skipped++;
-                        record({
-                            mediaId,
-                            title: local.title,
-                            action: 'skipped',
-                            localStatus: local.status,
-                            remoteStatus: remote.status,
-                            localChapters: localChapters,
-                            remoteProgress: remote.progress,
-                            note: 'Local is ahead — not pushed in pull-only mode.',
-                        });
-                    }
-                    else {
-                        summary.unchanged++;
-                    }
-                }
-                else if (shouldPushProgress || (!pullStatus && statusDiffers)) {
-                    pushUpdates.push({
-                        mediaId,
-                        status: targetStatus,
-                        progress: targetProgress,
-                    });
-                    if (targetStatus !== local.status) {
-                        libraryUpserts.push({
-                            id: local.id,
-                            provider: local.provider,
-                            mangaId: local.mangaId,
-                            title: local.title,
-                            cover: local.cover ?? '',
-                            status: targetStatus,
-                            anilistId: mediaId,
-                        });
-                    }
-                    stateUpdates[stateKey] = { lastSyncedAt: now, remoteUpdatedAt: now };
-                    summary.merged++;
-                    record({
-                        mediaId,
-                        title: local.title,
-                        action: 'merge-push',
-                        localStatus: targetStatus,
-                        remoteStatus: remote.status,
-                        localChapters: targetProgress,
-                        remoteProgress: remote.progress,
-                    });
-                }
-                else if (pullStatus || shouldPullProgress) {
-                    if (targetStatus !== local.status) {
-                        libraryUpserts.push({
-                            id: local.id,
-                            provider: local.provider,
-                            mangaId: local.mangaId,
-                            title: local.title,
-                            cover: local.cover ?? '',
-                            status: targetStatus,
-                            anilistId: mediaId,
-                        });
-                    }
-                    if (shouldPullProgress) {
-                        progressPointers.push({ id: localId, chapterNumber: String(targetProgress) });
-                        progressRows.push({
-                            mangaId: localId,
-                            chapterId: buildSyntheticChapterId(targetProgress),
-                            chapterNumber: String(targetProgress),
-                            title: local.title,
-                            cover: local.cover ?? '',
-                            provider: local.provider,
-                        });
-                    }
-                    stateUpdates[stateKey] = { lastSyncedAt: now, remoteUpdatedAt: remoteUpdated };
-                    summary.merged++;
-                    record({
-                        mediaId,
-                        title: local.title,
-                        action: 'merge-pull',
-                        localStatus: local.status,
-                        remoteStatus: targetStatus,
-                        localChapters: localChapters,
-                        remoteProgress: targetProgress,
-                    });
-                }
-                else {
-                    summary.unchanged++;
-                }
-            }
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            logger.warn({ err, mediaId }, '[AniList Manga Sync] Entry failed');
-            summary.errors.push(`${local?.title ?? `Manga ${mediaId}`}: ${message}`);
-            record({
-                mediaId,
-                title: local?.title ?? `Manga #${mediaId}`,
-                action: 'error',
-                note: message,
-            });
-        }
-    }
-    if (pushUpdates.length > 0 || remoteDeleteEntryIds.length > 0 || libraryDeletes.length > 0) {
-        const deleteCap = Math.max(5, Math.ceil(localItems.length * 0.1));
-        const totalDeletes = libraryDeletes.length + remoteDeleteEntryIds.length;
-        if (totalDeletes > deleteCap) {
-            throw new Error(`AniList manga sync would delete ${totalDeletes} titles but only ${remoteEntries.length} were fetched. Aborting to protect your library — if you really removed that many manga on AniList, delete them locally first and sync again.`);
-        }
-    }
-    if (pushUpdates.length > 0) {
-        const batchSize = 10;
-        for (let i = 0; i < pushUpdates.length; i += batchSize) {
-            const batch = pushUpdates.slice(i, i + batchSize);
-            await tracker.batchUpdateMediaEntries(batch);
-        }
-    }
-    if (remoteDeleteEntryIds.length > 0) {
-        const deleteBatch = remoteDeleteEntryIds.map((r) => r.entryId);
-        const batchSize = 10;
-        for (let i = 0; i < deleteBatch.length; i += batchSize) {
-            const batch = deleteBatch.slice(i, i + batchSize);
-            await tracker.batchDeleteMediaEntries(batch);
-        }
-    }
-    if (libraryUpserts.length > 0 ||
-        progressPointers.length > 0 ||
-        progressRows.length > 0 ||
-        libraryDeletes.length > 0 ||
-        newLinks.length > 0) {
-        await performMangaWriteTransactionAsync(mangaDb, async (tx) => {
-            for (const item of libraryUpserts) {
-                await MangaLibraryRepository.upsert(tx, item);
-            }
-            for (const link of newLinks) {
-                await MangaLibraryRepository.setAnilistId(tx, link.id, link.anilistId, 'search');
-            }
-            for (const p of progressPointers) {
-                await MangaLibraryRepository.setProgressPointer(tx, p.id, p.chapterNumber);
-            }
-            for (const p of progressRows) {
-                await MangaProgressRepository.deleteSyntheticChapters(tx, p.mangaId, p.chapterId);
-                await MangaProgressRepository.upsert(tx, {
-                    mangaId: p.mangaId,
-                    chapterId: p.chapterId,
-                    chapterNumber: p.chapterNumber,
-                    page: 0,
-                    pageCount: 0,
-                    title: p.title,
-                    cover: p.cover,
-                    provider: p.provider,
-                });
-            }
-            for (const id of libraryDeletes) {
-                await MangaLibraryRepository.delete(tx, id);
-                await MangaProgressRepository.deleteByManga(tx, id);
-            }
-        });
-    }
-    if (Object.keys(stateUpdates).length > 0) {
-        try {
-            const mergedState = { ...syncState };
-            for (const [k, v] of Object.entries(stateUpdates)) {
-                if (v === undefined)
-                    delete mergedState[k];
-                else
-                    mergedState[k] = v;
-            }
-            const snapshot = JSON.stringify(mergedState);
-            await performWriteTransactionAsync(db, async (tx) => {
-                await SettingsRepository.upsert(tx, MANGA_SYNC_STATE_KEY, snapshot);
-            });
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            logger.warn({ err }, '[AniList Manga Sync] Failed to persist sync state');
-            summary.errors.push(`Sync state was not saved, next sync will re-compare: ${message}`);
-        }
-    }
-    if (unresolved > 0) {
-        summary.errors.push(`${unresolved} local title${unresolved === 1 ? ' was' : 's were'} not matched to AniList (no link yet) — they were skipped and will be retried on the next sync.`);
-    }
-    return { summary, details };
-}
-function mangaImportStatusOrDefault(status) {
-    return mangaStatusOrFallback(status) ?? 'Planned';
-}
-export async function insertMangaImportEntries(db, mangaDb, items, eraseAnilistRows) {
-    if (items.length === 0)
-        return 0;
-    const now = Math.floor(Date.now() / 1000);
-    const syncState = await readTrackerSyncState(db, MANGA_SYNC_STATE_KEY);
-    await performMangaWriteTransactionAsync(mangaDb, async (tx) => {
-        if (eraseAnilistRows) {
-            for (const row of await MangaLibraryRepository.getAll(tx)) {
-                if (String(row.provider).toLowerCase() === MANGA_PROVIDER) {
-                    await MangaLibraryRepository.delete(tx, row.id);
-                    await MangaProgressRepository.deleteByManga(tx, row.id);
-                }
-            }
-        }
-        for (const item of items) {
-            const id = buildAnilistMangaId(item.mediaId);
-            const status = mangaImportStatusOrDefault(item.status);
-            await MangaLibraryRepository.upsert(tx, {
-                id,
-                provider: MANGA_PROVIDER,
-                mangaId: String(item.mediaId),
-                title: item.title,
-                cover: item.cover ?? '',
-                status,
-                anilistId: item.mediaId,
-                anilistIdSource: 'anilist',
-            });
-            if (item.progress > 0) {
-                await MangaLibraryRepository.setProgressPointer(tx, id, String(item.progress));
-                const chapterId = buildSyntheticChapterId(item.progress);
-                await MangaProgressRepository.deleteSyntheticChapters(tx, id, chapterId);
-                await MangaProgressRepository.upsert(tx, {
-                    mangaId: id,
-                    chapterId,
-                    chapterNumber: String(item.progress),
-                    page: 0,
-                    pageCount: 0,
-                    title: item.title,
-                    cover: item.cover ?? '',
-                    provider: MANGA_PROVIDER,
-                });
-            }
-            syncState[String(item.mediaId)] = {
-                lastSyncedAt: now,
-                remoteUpdatedAt: item.remoteUpdatedAt ?? now,
-            };
-        }
-    });
-    try {
-        const snapshot = JSON.stringify(syncState);
-        await performWriteTransactionAsync(db, async (tx) => {
-            await SettingsRepository.upsert(tx, MANGA_SYNC_STATE_KEY, snapshot);
-        });
-    }
-    catch (err) {
-        logger.warn({ err }, '[AniList Manga Sync] Failed to persist sync state after import');
-    }
-    return items.length;
-}
-export async function importFromUsernameManga(db, mangaDb, username, erase = false) {
-    const tokenRow = await SettingsRepository.getByKey(db, TOKEN_KEY);
-    const token = tokenRow?.value;
-    const tracker = new AniListTracker(token);
-    let entries;
-    if (token) {
-        const viewer = await tracker.getViewer();
-        entries = await tracker.fetchUserMangaList(viewer.id);
-    }
-    else {
-        entries = await tracker.fetchUserMangaList(username);
-    }
-    if (entries.length === 0)
-        return 0;
-    return insertMangaImportEntries(db, mangaDb, entries.map((remote) => ({
-        mediaId: remote.mediaId,
-        title: remote.title.english || remote.title.romaji || `Manga #${remote.mediaId}`,
-        cover: remote.coverImage,
-        status: remote.status,
-        progress: remote.progress,
-        remoteUpdatedAt: remote.updatedAt,
-    })), erase);
-}
-async function resolveMalMangaToAnilist(malId, title, titleEnglish) {
-    if (malId) {
-        try {
-            const byMal = await getMangaMetaByMalId(malId);
-            if (byMal) {
-                return {
-                    id: byMal.id,
-                    title: byMal.title.english || byMal.title.romaji || title,
-                    cover: byMal.cover,
-                };
-            }
-        }
-        catch {
-            // ignore
-        }
-    }
-    const query = titleEnglish || title;
-    if (!query)
-        return null;
-    try {
-        const found = await searchAnilistMangaByTitle(query);
-        if (!found)
-            return null;
-        const meta = await getMangaMetaById(found.id);
-        return {
-            id: found.id,
-            title: meta?.title.english ||
-                meta?.title.romaji ||
-                found.title.english ||
-                found.title.romaji ||
-                query,
-            cover: meta?.cover,
-        };
-    }
-    catch {
-        return null;
-    }
-}
-export async function importMangaFromMalUsername(db, mangaDb, username, erase = false) {
-    const entries = await fetchMalMangaList(username);
-    if (entries.length === 0)
-        return { imported: 0, skipped: 0 };
-    const items = [];
-    let skipped = 0;
-    const BATCH_SIZE = 5;
-    for (let i = 0; i < entries.length; i += BATCH_SIZE) {
-        const batch = entries.slice(i, i + BATCH_SIZE);
-        const results = await Promise.allSettled(batch.map((e) => resolveMalMangaToAnilist(e.malId, e.title, e.titleEnglish)));
-        results.forEach((r, idx) => {
-            const entry = batch[idx];
-            const status = mapMalMangaStatusCode(entry.status);
-            if (r.status !== 'fulfilled' || !r.value || !status) {
-                skipped++;
-                return;
-            }
-            items.push({
-                mediaId: r.value.id,
-                title: r.value.title,
-                cover: r.value.cover,
-                status,
-                progress: Math.max(entry.chaptersRead, 0),
-            });
-        });
-    }
-    const imported = await insertMangaImportEntries(db, mangaDb, items, erase);
-    return { imported, skipped };
-}
-export async function importMangaFromMalXmlItems(db, mangaDb, list, erase = false) {
-    if (list.length === 0)
-        return { imported: 0, skipped: 0 };
-    const items = [];
-    let skipped = 0;
-    const BATCH_SIZE = 5;
-    for (let i = 0; i < list.length; i += BATCH_SIZE) {
-        const batch = list.slice(i, i + BATCH_SIZE);
-        const results = await Promise.allSettled(batch.map((e) => resolveMalMangaToAnilist(e.malId, e.title, null)));
-        results.forEach((r, idx) => {
-            const entry = batch[idx];
-            if (r.status !== 'fulfilled' || !r.value) {
-                skipped++;
-                return;
-            }
-            items.push({
-                mediaId: r.value.id,
-                title: r.value.title,
-                cover: r.value.cover,
-                status: entry.status,
-                progress: Math.max(entry.chapters, 0),
-            });
-        });
-    }
-    const imported = await insertMangaImportEntries(db, mangaDb, items, erase);
-    return { imported, skipped };
-}