@serifpersia/dango 3.3.4

package/server/dist/providers/title-matching.js

@@ -0,0 +1,225 @@
+export function normalizeCompact(s) {
+    return s.toLowerCase().replace(/[^a-z0-9]/g, '');
+}
+export function tokenize(s) {
+    return s
+        .toLowerCase()
+        .replace(/[^\p{L}\p{N}\s]/gu, ' ')
+        .split(/\s+/)
+        .filter((w) => w.length >= 2);
+}
+export function bigramDice(a, b) {
+    if (a.length < 2 || b.length < 2)
+        return a === b ? 1 : 0;
+    const grams = (s) => {
+        const map = new Map();
+        for (let i = 0; i < s.length - 1; i++) {
+            const g = s.slice(i, i + 2);
+            map.set(g, (map.get(g) || 0) + 1);
+        }
+        return map;
+    };
+    const A = grams(a);
+    const B = grams(b);
+    let totalA = 0;
+    let totalB = 0;
+    let shared = 0;
+    A.forEach((c) => (totalA += c));
+    B.forEach((c) => (totalB += c));
+    A.forEach((c, g) => {
+        const other = B.get(g);
+        if (other)
+            shared += Math.min(c, other);
+    });
+    return (2 * shared) / (totalA + totalB);
+}
+const STOPWORDS = new Set([
+    'the',
+    'animation',
+    'no',
+    'wa',
+    'ga',
+    'wo',
+    'ni',
+    'de',
+    'to',
+    'e',
+    'o',
+    'x',
+    'ii',
+    'yo',
+    'ova',
+    'oad',
+    'hd',
+    'ep',
+    'episode',
+    'season',
+    'part',
+    'hen',
+    'a',
+]);
+const SEASON_TOKENS = new Set([
+    'season',
+    '2nd',
+    '3rd',
+    '4th',
+    '5th',
+    'ii',
+    'iii',
+    'iv',
+    'v',
+    'vi',
+    'vii',
+    'viii',
+    'ix',
+    'x',
+    'two',
+    'three',
+    'four',
+    'five',
+    'six',
+    'seven',
+    'eight',
+    'nine',
+    'ten',
+]);
+function distinctiveTokensExcludingSeason(s) {
+    return [...new Set(tokenize(s).filter((w) => !STOPWORDS.has(w) && !SEASON_TOKENS.has(w)))];
+}
+const ROMAN_TO_NUM = {
+    ii: 2,
+    iii: 3,
+    iv: 4,
+    v: 5,
+    vi: 6,
+    vii: 7,
+    viii: 8,
+    ix: 9,
+    x: 10,
+};
+const WORD_TO_NUM = {
+    two: 2,
+    three: 3,
+    four: 4,
+    five: 5,
+    six: 6,
+    seven: 7,
+    eight: 8,
+    nine: 9,
+    ten: 10,
+};
+function detectSeasonMarker(s) {
+    const t = s.toLowerCase();
+    // "season 2", "season ii", "season 2nd", "season three"
+    const seasonNum = t.match(/\bseason\s*(\d+|ii|iii|iv|v|vi|vii|viii|ix|x|two|three|four|five|six|seven|eight|nine|ten)\b/);
+    if (seasonNum) {
+        const token = seasonNum[1];
+        const n = ROMAN_TO_NUM[token];
+        const w = WORD_TO_NUM[token];
+        return String(n ?? w ?? token);
+    }
+    const ord = t.match(/\b(\d+)(st|nd|rd|th)\b/);
+    if (ord)
+        return ord[1];
+    const trailing = t.match(/\b(ii|iii|iv|v|vi|vii|viii|ix|x)\b(?!\s*(st|nd|rd|th|season))/);
+    if (trailing)
+        return String(ROMAN_TO_NUM[trailing[1]]);
+    // bare trailing number, e.g. "...Another World 2"
+    const trailingNum = t.match(/\b(\d+)\s*(season)?\s*$/);
+    if (trailingNum)
+        return trailingNum[1];
+    return '';
+}
+export function distinctiveTokens(s) {
+    return [...new Set(tokenize(s).filter((w) => !STOPWORDS.has(w)))];
+}
+export function titleSimilarity(query, candidate) {
+    const q = normalizeCompact(query);
+    const c = normalizeCompact(candidate);
+    if (!q || !c)
+        return 0;
+    if (q === c)
+        return 1;
+    let score = bigramDice(q, c);
+    if (q.startsWith(c) || c.startsWith(q)) {
+        const prefixScore = 0.5 + 0.5 * (Math.min(q.length, c.length) / Math.max(q.length, c.length));
+        if (prefixScore > score)
+            score = prefixScore;
+    }
+    const qD = distinctiveTokensExcludingSeason(query);
+    const cD = distinctiveTokensExcludingSeason(candidate);
+    if (qD.length > 0 && cD.length >= 2) {
+        const cSet = new Set(cD);
+        let hits = 0;
+        for (const t of qD) {
+            if (cSet.has(t))
+                hits++;
+        }
+        const coverage = hits / Math.min(qD.length, cD.length);
+        if (coverage > score)
+            score = coverage;
+    }
+    const qMarker = detectSeasonMarker(query);
+    if (qMarker) {
+        const cMarker = detectSeasonMarker(candidate);
+        if (cMarker === qMarker) {
+            score += 0.25;
+        }
+        else if (!cMarker && score >= 0.5) {
+            score -= 0.25;
+        }
+    }
+    return score >= 1 ? 0.99 : score;
+}
+export function pickBestMatch(candidates, targets, minScore = 0.6) {
+    if (!candidates.length)
+        return null;
+    const cleanTargets = targets.filter((t) => !!t && t.trim().length > 0);
+    if (!cleanTargets.length)
+        return null;
+    let best = null;
+    for (const item of candidates) {
+        if (!item.title)
+            continue;
+        let score = 0;
+        for (const target of cleanTargets) {
+            const s = titleSimilarity(target, item.title);
+            if (s > score)
+                score = s;
+        }
+        if (!best || score > best.score)
+            best = { item, score };
+    }
+    return best && best.score >= minScore ? best : null;
+}
+export function buildQueryVariants(title, romaji) {
+    const seen = new Set();
+    const out = [];
+    const push = (q) => {
+        const v = q.replace(/\s+/g, ' ').trim();
+        if (v && !seen.has(v.toLowerCase())) {
+            seen.add(v.toLowerCase());
+            out.push(v);
+        }
+    };
+    if (romaji && romaji.trim())
+        push(romaji);
+    push(title);
+    const stripped = (s) => s.replace(/[^\p{L}\p{N}\s]/gu, ' ');
+    push(stripped(title));
+    if (romaji)
+        push(stripped(romaji));
+    const words = stripped(title).split(/\s+/).filter(Boolean);
+    if (words.length > 3)
+        push(words.slice(0, 3).join(' '));
+    if (words.length > 4)
+        push(words.slice(0, 4).join(' '));
+    const tokens = distinctiveTokens(title)
+        .concat(romaji ? distinctiveTokens(romaji) : [])
+        .filter((w) => w.length >= 4);
+    const unique = [...new Set(tokens)];
+    unique.sort((a, b) => b.length - a.length);
+    for (const t of unique.slice(0, 4))
+        push(t);
+    return out;
+}

package/server/dist/providers/tv.types.js

@@ -0,0 +1 @@
+export {};

package/server/dist/rclone.js

@@ -0,0 +1,120 @@
+import { spawn, execFile } from 'child_process';
+import logger from './logger.js';
+import { CONFIG } from './config.js';
+class RcloneService {
+    activeRemote = null;
+    executeCommand(args) {
+        return new Promise((resolve, reject) => {
+            execFile('rclone', args, (err, stdout, stderr) => {
+                if (err) {
+                    if (stderr)
+                        logger.warn({ stderr }, 'Rclone command warning');
+                    return reject(new Error(stderr || err.message));
+                }
+                resolve(stdout.trim());
+            });
+        });
+    }
+    executeRcloneArgs(args) {
+        return new Promise((resolve, reject) => {
+            const process = spawn('rclone', args, { stdio: 'ignore' });
+            process.on('close', (code) => {
+                if (code === 0)
+                    resolve();
+                else
+                    reject(new Error(`Rclone exited with code ${code}`));
+            });
+            process.on('error', (err) => reject(err));
+        });
+    }
+    async listRemotes() {
+        try {
+            const remotesStr = await this.executeCommand(['listremotes']);
+            return remotesStr
+                .split('\n')
+                .map((r) => r.trim())
+                .filter((r) => r !== '')
+                .map((r) => r.replace(/:$/, ''));
+        }
+        catch {
+            return [];
+        }
+    }
+    async init() {
+        try {
+            await this.executeCommand(['version']);
+            const remotes = await this.listRemotes();
+            if (CONFIG.RCLONE_REMOTE) {
+                const found = remotes.find((r) => r.toLowerCase() === CONFIG.RCLONE_REMOTE?.toLowerCase());
+                if (found) {
+                    this.activeRemote = found;
+                    logger.info(`Rclone initialized with manual remote: ${this.activeRemote}`);
+                    return true;
+                }
+                else {
+                    logger.warn(`Configured RCLONE_REMOTE '${CONFIG.RCLONE_REMOTE}' not found in rclone listremotes.`);
+                }
+            }
+            if (remotes.length > 0 && !CONFIG.RCLONE_REMOTE) {
+                logger.info({ remotes }, 'Rclone available but no manual remote is configured in settings.');
+                return false;
+            }
+            return false;
+        }
+        catch (error) {
+            logger.warn({ err: error }, 'Rclone initialization failed');
+            return false;
+        }
+    }
+    isActive() {
+        return this.activeRemote !== null;
+    }
+    getRemoteName() {
+        return this.activeRemote || 'unknown';
+    }
+    async downloadFile(remoteFolder, fileName, localPath) {
+        if (!this.activeRemote)
+            throw new Error('Rclone not active');
+        const remotePath = `${this.activeRemote}:${remoteFolder}/${fileName}`;
+        await this.executeRcloneArgs(['copyto', remotePath, localPath]);
+    }
+    async uploadFile(localPath, remoteFolder, fileName) {
+        if (!this.activeRemote)
+            throw new Error('Rclone not active');
+        const remotePath = `${this.activeRemote}:${remoteFolder}/${fileName}`;
+        await this.executeRcloneArgs(['copyto', localPath, remotePath]);
+    }
+    executeRcloneArgsWithOutput(args) {
+        return new Promise((resolve, reject) => {
+            const process = spawn('rclone', args, { stdio: 'pipe' });
+            let stdout = '';
+            let stderr = '';
+            process.stdout?.on('data', (data) => (stdout += data));
+            process.stderr?.on('data', (data) => (stderr += data));
+            process.on('close', (code) => {
+                if (code === 0)
+                    resolve(stdout.trim());
+                else {
+                    if (stderr)
+                        logger.warn({ stderr }, 'Rclone command warning');
+                    reject(new Error(stderr || `Rclone exited with code ${code}`));
+                }
+            });
+            process.on('error', (err) => reject(err));
+        });
+    }
+    async fileExists(remoteFolder, fileName) {
+        if (!this.activeRemote)
+            return false;
+        try {
+            const remotePath = `${this.activeRemote}:${remoteFolder}/${fileName}`;
+            const output = await this.executeRcloneArgsWithOutput(['lsjson', remotePath]);
+            const json = JSON.parse(output);
+            return json && json.length > 0;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+export const rcloneService = new RcloneService();

package/server/dist/repositories/asmr.repository.js

@@ -0,0 +1,123 @@
+import { dbAll, dbGet, dbRun } from '../utils/db-utils.js';
+export const ASMR_STATUSES = [
+    'Listening',
+    'Completed',
+    'On-Hold',
+    'Dropped',
+    'Planned',
+];
+export function buildAsmrId(rjCode) {
+    return String(rjCode).trim().toUpperCase();
+}
+export const AsmrLibraryRepository = {
+    getById: (db, id) => dbGet(db, 'SELECT * FROM asmr_library WHERE id = ?', [id]),
+    exists: (db, id) => {
+        const row = dbGet(db, 'SELECT EXISTS(SELECT 1 FROM asmr_library WHERE id = ?) as inLibrary', [id]);
+        return !!(row && row.inLibrary);
+    },
+    getAll: (db, status, limit, offset) => {
+        let query = 'SELECT * FROM asmr_library';
+        const params = [];
+        if (status && status !== 'All') {
+            query += ' WHERE status = ?';
+            params.push(status);
+        }
+        query += ' ORDER BY updatedAt DESC';
+        if (limit !== undefined && offset !== undefined) {
+            query += ' LIMIT ? OFFSET ?';
+            params.push(limit, offset);
+        }
+        return dbAll(db, query, params);
+    },
+    getCount: (db, status) => {
+        let query = 'SELECT COUNT(*) as total FROM asmr_library';
+        const params = [];
+        if (status && status !== 'All') {
+            query += ' WHERE status = ?';
+            params.push(status);
+        }
+        const row = dbGet(db, query, params);
+        return row?.total || 0;
+    },
+    getIds: (db) => dbAll(db, 'SELECT id FROM asmr_library').map((r) => r.id),
+    upsert: (db, data) => dbRun(db, `INSERT INTO asmr_library (id, rjCode, title, thumbnail, status, isAdult, updatedAt)
+       VALUES (?, ?, ?, ?, ?, ?, strftime('%s', 'now'))
+       ON CONFLICT(id) DO UPDATE SET
+          rjCode = COALESCE(NULLIF(EXCLUDED.rjCode, ''), asmr_library.rjCode),
+          title = COALESCE(NULLIF(EXCLUDED.title, ''), asmr_library.title),
+          thumbnail = COALESCE(NULLIF(EXCLUDED.thumbnail, ''), asmr_library.thumbnail),
+          status = COALESCE(NULLIF(EXCLUDED.status, ''), asmr_library.status),
+          isAdult = COALESCE(EXCLUDED.isAdult, asmr_library.isAdult),
+          updatedAt = strftime('%s', 'now')`, [data.id, data.rjCode, data.title, data.thumbnail, data.status, data.isAdult ? 1 : 0]),
+    updateStatus: (db, id, status) => dbRun(db, "UPDATE asmr_library SET status = ?, updatedAt = strftime('%s', 'now') WHERE id = ?", [status, id]),
+    updateStatusMany: (db, ids, status) => {
+        if (ids.length === 0)
+            return;
+        const placeholders = ids.map(() => '?').join(', ');
+        dbRun(db, `UPDATE asmr_library SET status = ?, updatedAt = strftime('%s', 'now') WHERE id IN (${placeholders})`, [status, ...ids]);
+    },
+    touchProgress: (db, id, progress) => dbRun(db, `UPDATE asmr_library SET lastTrackIndex = ?, lastTrackLabel = ?, lastPosition = ?, updatedAt = strftime('%s', 'now') WHERE id = ?`, [progress.trackIndex, progress.trackLabel, progress.position, id]),
+    delete: (db, id) => dbRun(db, 'DELETE FROM asmr_library WHERE id = ?', [id]),
+    deleteMany: (db, ids) => {
+        if (ids.length === 0)
+            return;
+        const placeholders = ids.map(() => '?').join(', ');
+        dbRun(db, `DELETE FROM asmr_library WHERE id IN (${placeholders})`, ids);
+    },
+};
+export const AsmrProgressRepository = {
+    getByWork: (db, workId) => dbAll(db, 'SELECT workId, trackIndex, trackLabel, currentTime, duration, updatedAt FROM asmr_progress WHERE workId = ? ORDER BY updatedAt DESC', [workId]),
+    getTrack: (db, workId, trackIndex) => dbGet(db, 'SELECT workId, trackIndex, trackLabel, currentTime, duration, updatedAt FROM asmr_progress WHERE workId = ? AND trackIndex = ?', [workId, trackIndex]),
+    getLatest: (db, workId) => dbGet(db, 'SELECT workId, trackIndex, trackLabel, currentTime, duration, updatedAt FROM asmr_progress WHERE workId = ? ORDER BY updatedAt DESC LIMIT 1', [workId]),
+    upsert: (db, data) => dbRun(db, `INSERT INTO asmr_progress (workId, trackIndex, trackLabel, currentTime, duration, title, thumbnail, rjCode, isAdult, updatedAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, strftime('%s', 'now'))
+       ON CONFLICT(workId, trackIndex) DO UPDATE SET
+          trackLabel = COALESCE(NULLIF(EXCLUDED.trackLabel, ''), asmr_progress.trackLabel),
+          currentTime = EXCLUDED.currentTime,
+          duration = EXCLUDED.duration,
+          title = COALESCE(EXCLUDED.title, asmr_progress.title),
+          thumbnail = COALESCE(EXCLUDED.thumbnail, asmr_progress.thumbnail),
+          rjCode = COALESCE(EXCLUDED.rjCode, asmr_progress.rjCode),
+          isAdult = COALESCE(EXCLUDED.isAdult, asmr_progress.isAdult),
+          updatedAt = strftime('%s', 'now')`, [
+        data.workId,
+        data.trackIndex,
+        data.trackLabel,
+        data.currentTime,
+        data.duration,
+        data.title ?? null,
+        data.thumbnail ?? null,
+        data.rjCode ?? null,
+        data.isAdult ?? null,
+    ]),
+    deleteByWork: (db, workId) => dbRun(db, 'DELETE FROM asmr_progress WHERE workId = ?', [workId]),
+    deleteMany: (db, ids) => {
+        if (ids.length === 0)
+            return;
+        const placeholders = ids.map(() => '?').join(', ');
+        dbRun(db, `DELETE FROM asmr_progress WHERE workId IN (${placeholders})`, ids);
+    },
+    deleteTrack: (db, workId, trackIndex) => dbRun(db, 'DELETE FROM asmr_progress WHERE workId = ? AND trackIndex = ?', [
+        workId,
+        trackIndex,
+    ]),
+    getContinueListening: (db, limit) => {
+        const limitClause = typeof limit === 'number' ? `LIMIT ${limit}` : '';
+        return dbAll(db, `SELECT p.workId as id,
+              COALESCE(l.rjCode, p.rjCode, p.workId) as rjCode,
+              COALESCE(l.title, p.title) as title,
+              COALESCE(l.thumbnail, p.thumbnail) as thumbnail,
+              COALESCE(l.isAdult, p.isAdult) as isAdult,
+              l.status as watchlistStatus,
+              p.trackIndex, p.trackLabel, p.currentTime, p.duration, p.updatedAt as progressAt
+       FROM (
+         SELECT *, ROW_NUMBER() OVER (PARTITION BY workId ORDER BY updatedAt DESC) as rn
+         FROM asmr_progress
+       ) p
+       LEFT JOIN asmr_library l ON p.workId = l.id
+       WHERE p.rn = 1
+         AND (l.status IS NULL OR l.status = 'Listening')
+       ORDER BY p.updatedAt DESC
+       ${limitClause}`);
+    },
+};

package/server/dist/repositories/insights.repository.js

@@ -0,0 +1,85 @@
+import { dbAll, dbGet } from '../utils/db-utils.js';
+export const InsightsRepository = {
+    getCoreStats: (db) => dbGet(db, `SELECT
+        (SELECT SUM(
+          CASE WHEN we.currentTime > 0 THEN we.currentTime
+               WHEN we.currentTime = 0 AND we.duration = 0 THEN
+                 COALESCE(sm.episodeDuration * 60,
+                   CASE UPPER(COALESCE(sm.type, ''))
+                     WHEN 'MOVIE' THEN 6000
+                     WHEN 'TV_SHORT' THEN 720
+                     WHEN 'MUSIC' THEN 300
+                     ELSE 1440 END)
+               ELSE 0 END)
+         FROM watched_episodes we
+         LEFT JOIN shows_meta sm ON sm.id = we.showId) as totalSeconds,
+        (SELECT COUNT(*) FROM watched_episodes) as totalEpisodes,
+        (SELECT COUNT(DISTINCT showId) FROM watched_episodes) as totalAnime,
+        (SELECT COUNT(*) FROM watchlist WHERE status = 'Completed') as completedCount,
+        (SELECT COUNT(*) FROM watchlist) as totalWatchlist`),
+    getActivityGrid: (db) => dbAll(db, `SELECT date(watchedAt) as day, COUNT(*) as count FROM watched_episodes WHERE NOT (currentTime = 0 AND duration = 0) GROUP BY day`),
+    getHourlyDist: (db) => dbAll(db, `SELECT strftime('%H', watchedAt) as hour, COUNT(*) as count FROM watched_episodes WHERE NOT (currentTime = 0 AND duration = 0) GROUP BY hour`),
+    getSeasonality: (db) => dbAll(db, `SELECT strftime('%m', we.watchedAt) as month, SUM(
+        CASE WHEN we.currentTime > 0 THEN we.currentTime
+             WHEN we.currentTime = 0 AND we.duration = 0 THEN
+               COALESCE(sm.episodeDuration * 60,
+                 CASE UPPER(COALESCE(sm.type, ''))
+                   WHEN 'MOVIE' THEN 6000
+                   WHEN 'TV_SHORT' THEN 720
+                   WHEN 'MUSIC' THEN 300
+                   ELSE 1440 END)
+             ELSE 0 END) as seconds
+       FROM watched_episodes we
+       LEFT JOIN shows_meta sm ON sm.id = we.showId
+       GROUP BY month`),
+    getAllWatches: (db) => dbAll(db, `SELECT we.watchedAt, we.currentTime,
+        CASE WHEN we.currentTime > 0 THEN we.currentTime
+             WHEN we.currentTime = 0 AND we.duration = 0 THEN
+               COALESCE(sm.episodeDuration * 60,
+                 CASE UPPER(COALESCE(sm.type, ''))
+                   WHEN 'MOVIE' THEN 6000
+                   WHEN 'TV_SHORT' THEN 720
+                   WHEN 'MUSIC' THEN 300
+                   ELSE 1440 END)
+             ELSE 0 END as effectiveSeconds
+       FROM watched_episodes we
+       LEFT JOIN shows_meta sm ON sm.id = we.showId
+       ORDER BY we.watchedAt ASC`),
+    getWatchedShowsMeta: (db) => dbAll(db, `SELECT DISTINCT sm.id, sm.genres, sm.popularityScore
+      FROM shows_meta sm
+      JOIN watched_episodes we ON sm.id = we.showId`),
+    getDroppedShows: (db) => dbAll(db, `SELECT w.id, w.name, MAX(we.watchedAt) as lastActivity
+        FROM watchlist w
+        JOIN watched_episodes we ON w.id = we.showId
+        WHERE w.status = 'Watching' AND NOT (we.currentTime = 0 AND we.duration = 0)
+        GROUP BY w.id
+        HAVING lastActivity < date('now', '-90 days')`),
+    getCompletionVelocities: (db) => dbAll(db, `SELECT
+        (julianday(MAX(we.watchedAt)) - julianday(MIN(we.watchedAt))) as daysToFinish
+        FROM watchlist w
+        JOIN watched_episodes we ON w.id = we.showId
+        WHERE w.status = 'Completed'
+        GROUP BY w.id
+        HAVING SUM(we.currentTime) > 0`),
+    getWatchedEpisodesWithMeta: (db) => dbAll(db, `SELECT 
+        we.showId,
+        we.currentTime,
+        we.duration,
+        CASE WHEN we.currentTime > 0 THEN we.currentTime
+             WHEN we.currentTime = 0 AND we.duration = 0 THEN
+               COALESCE(sm.episodeDuration * 60,
+                 CASE UPPER(COALESCE(sm.type, ''))
+                   WHEN 'MOVIE' THEN 6000
+                   WHEN 'TV_SHORT' THEN 720
+                   WHEN 'MUSIC' THEN 300
+                   ELSE 1440 END)
+             ELSE 0 END as effectiveSeconds,
+        sm.genres,
+        sm.popularityScore,
+        sm.name,
+        sm.nativeName,
+        sm.englishName,
+        sm.thumbnail
+      FROM watched_episodes we
+      JOIN shows_meta sm ON we.showId = sm.id`),
+};

package/server/dist/repositories/library.repository.js

@@ -0,0 +1,108 @@
+import { dbGet, dbRun } from '../utils/db-utils.js';
+const LIBRARY_TABLES = [
+    'watchlist',
+    'watched_episodes',
+    'queue',
+    'shows_meta',
+    'dismissed_notifications',
+    'discovered_notifications',
+    'legacy_id_mapping',
+    'temp_show_ids',
+];
+const MANGA_LIBRARY_TABLES = ['manga_library', 'manga_progress'];
+const TV_LIBRARY_TABLES = ['tv_library', 'tv_progress'];
+const ASMR_LIBRARY_TABLES = ['asmr_library', 'asmr_progress'];
+export const LibraryRepository = {
+    countAll: (db) => {
+        const counts = {};
+        for (const table of LIBRARY_TABLES) {
+            try {
+                counts[table] =
+                    dbGet(db, `SELECT COUNT(*) AS rows FROM "${table}"`)?.rows ?? 0;
+            }
+            catch {
+                counts[table] = 0;
+            }
+        }
+        return counts;
+    },
+    clearAll: (db) => {
+        for (const table of LIBRARY_TABLES) {
+            try {
+                dbRun(db, `DELETE FROM "${table}"`);
+            }
+            catch {
+                // ignore
+            }
+        }
+    },
+    countManga: (db) => {
+        const counts = {};
+        for (const table of MANGA_LIBRARY_TABLES) {
+            try {
+                counts[table] =
+                    dbGet(db, `SELECT COUNT(*) AS rows FROM "${table}"`)?.rows ?? 0;
+            }
+            catch {
+                counts[table] = 0;
+            }
+        }
+        return counts;
+    },
+    clearManga: (db) => {
+        for (const table of MANGA_LIBRARY_TABLES) {
+            try {
+                dbRun(db, `DELETE FROM "${table}"`);
+            }
+            catch {
+                // ignore
+            }
+        }
+    },
+    countTv: (db) => {
+        const counts = {};
+        for (const table of TV_LIBRARY_TABLES) {
+            try {
+                counts[table] =
+                    dbGet(db, `SELECT COUNT(*) AS rows FROM "${table}"`)?.rows ?? 0;
+            }
+            catch {
+                counts[table] = 0;
+            }
+        }
+        return counts;
+    },
+    clearTv: (db) => {
+        for (const table of TV_LIBRARY_TABLES) {
+            try {
+                dbRun(db, `DELETE FROM "${table}"`);
+            }
+            catch {
+                // ignore
+            }
+        }
+    },
+    countAsmr: (db) => {
+        const counts = {};
+        for (const table of ASMR_LIBRARY_TABLES) {
+            try {
+                counts[table] =
+                    dbGet(db, `SELECT COUNT(*) AS rows FROM "${table}"`)?.rows ?? 0;
+            }
+            catch {
+                counts[table] = 0;
+            }
+        }
+        return counts;
+    },
+    clearAsmr: (db) => {
+        for (const table of ASMR_LIBRARY_TABLES) {
+            try {
+                dbRun(db, `DELETE FROM "${table}"`);
+            }
+            catch {
+                // ignore
+            }
+        }
+    },
+};