@serifpersia/dango 3.6.7 → 3.6.9

package/server/dist/providers/remote-types.js

@@ -1,159 +0,0 @@
-const ID_RE = /^[a-z0-9][a-z0-9-]*$/i;
-const SHA_RE = /^[0-9a-f]{64}$/i;
-export function parseRegistry(raw) {
-    if (!raw || typeof raw !== 'object')
-        throw new Error('registry: not an object');
-    const r = raw;
-    if (typeof r.version !== 'number')
-        throw new Error('registry.version must be a number');
-    if (!Array.isArray(r.providers))
-        throw new Error('registry.providers must be an array');
-    const providers = r.providers.map((p, i) => parseEntry(p, i));
-    const seen = new Set();
-    for (const p of providers) {
-        const key = p.id.toLowerCase();
-        if (seen.has(key))
-            throw new Error(`registry: duplicate provider id "${p.id}"`);
-        seen.add(key);
-    }
-    return {
-        version: r.version,
-        updatedAt: typeof r.updatedAt === 'string' ? r.updatedAt : undefined,
-        providers,
-    };
-}
-function parseEntry(raw, index) {
-    if (!raw || typeof raw !== 'object')
-        throw new Error(`registry.providers[${index}]: not an object`);
-    const p = raw;
-    const id = p.id;
-    const entry = p.entry;
-    const label = p.label;
-    const version = p.version;
-    if (typeof id !== 'string' || !ID_RE.test(id.trim())) {
-        throw new Error(`registry.providers[${index}].id must match ${ID_RE}`);
-    }
-    if (typeof label !== 'string' || !label.trim()) {
-        throw new Error(`registry.providers[${index}].label must be a non-empty string`);
-    }
-    if (typeof version !== 'string' || !version.trim()) {
-        throw new Error(`registry.providers[${index}].version must be a non-empty string`);
-    }
-    const embedBase = p.embedBase;
-    if (embedBase !== undefined) {
-        if (typeof embedBase !== 'string' || !/^https:\/\/[^/]+/i.test(embedBase.trim())) {
-            throw new Error(`registry.providers[${index}].embedBase must be an https URL`);
-        }
-    }
-    if ((typeof entry !== 'string' || !entry.trim()) && embedBase === undefined) {
-        throw new Error(`registry.providers[${index}].entry must be a non-empty string`);
-    }
-    if (p.sha256 !== undefined && (typeof p.sha256 !== 'string' || !SHA_RE.test(p.sha256.trim()))) {
-        throw new Error(`registry.providers[${index}].sha256 must be 64 hex chars`);
-    }
-    if (p.mature !== undefined && typeof p.mature !== 'boolean') {
-        throw new Error(`registry.providers[${index}].mature must be boolean`);
-    }
-    if (p.kind !== undefined &&
-        p.kind !== 'anime' &&
-        p.kind !== 'asmr' &&
-        p.kind !== 'manga' &&
-        p.kind !== 'tv') {
-        throw new Error(`registry.providers[${index}].kind must be anime|asmr|manga|tv`);
-    }
-    if (p.sub !== undefined && p.sub !== 'soft' && p.sub !== 'hard' && p.sub !== 'mixed') {
-        throw new Error(`registry.providers[${index}].sub must be soft|hard|mixed`);
-    }
-    if (p.tier !== undefined && p.tier !== 'direct' && p.tier !== 'embed' && p.tier !== 'cookie') {
-        throw new Error(`registry.providers[${index}].tier must be direct|embed|cookie`);
-    }
-    let modes;
-    if (p.modes !== undefined) {
-        if (!Array.isArray(p.modes))
-            throw new Error(`registry.providers[${index}].modes must be an array`);
-        modes = [];
-        for (const m of p.modes) {
-            if (m !== 'sub' && m !== 'dub') {
-                throw new Error(`registry.providers[${index}].modes must contain only sub|dub`);
-            }
-            if (!modes.includes(m))
-                modes.push(m);
-        }
-    }
-    return {
-        id: id.trim(),
-        label: label.trim(),
-        version: version.trim(),
-        entry: typeof entry === 'string' ? entry.trim() : undefined,
-        embedBase: typeof embedBase === 'string' ? embedBase.trim().replace(/\/+$/, '') : undefined,
-        sha256: typeof p.sha256 === 'string' ? p.sha256.trim().toLowerCase() : undefined,
-        minDango: typeof p.minDango === 'string' ? p.minDango : undefined,
-        mature: typeof p.mature === 'boolean' ? p.mature : false,
-        kind: p.kind === 'asmr' || p.kind === 'manga' || p.kind === 'tv' ? p.kind : 'anime',
-        sub: p.sub,
-        tier: p.tier,
-        modes,
-        browse: parseBrowseCaps(p.browse, index),
-        proxy: parseProxyRule(p.proxy, index),
-        auth: p.auth === 'cookie' ? 'cookie' : undefined,
-        enabledByDefault: p.enabledByDefault === false ? false : true,
-    };
-}
-function parseProxyRule(raw, index) {
-    if (raw === undefined)
-        return undefined;
-    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
-        throw new Error(`registry.providers[${index}].proxy must be an object`);
-    }
-    const p = raw;
-    const rule = {};
-    for (const key of ['hosts', 'suffixes', 'mirrors']) {
-        if (p[key] === undefined)
-            continue;
-        if (!Array.isArray(p[key]) || !p[key].every((v) => typeof v === 'string' && v)) {
-            throw new Error(`registry.providers[${index}].proxy.${key} must be a non-empty string array`);
-        }
-        rule[key] = p[key].map((v) => v.trim().toLowerCase());
-    }
-    for (const key of ['referer', 'origin']) {
-        if (p[key] === undefined)
-            continue;
-        if (typeof p[key] !== 'string' || !/^https:\/\//i.test(p[key].trim())) {
-            throw new Error(`registry.providers[${index}].proxy.${key} must be an https URL`);
-        }
-        rule[key] = p[key].trim();
-    }
-    for (const key of ['originFromReferer', 'scrape', 'cfCookie', 'embedPatch']) {
-        if (p[key] === undefined)
-            continue;
-        if (typeof p[key] !== 'boolean') {
-            throw new Error(`registry.providers[${index}].proxy.${key} must be boolean`);
-        }
-        rule[key] = p[key];
-    }
-    return rule;
-}
-function parseBrowseCaps(raw, index) {
-    if (raw === undefined)
-        return undefined;
-    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
-        throw new Error(`registry.providers[${index}].browse must be an object`);
-    }
-    const b = raw;
-    const caps = {};
-    for (const key of ['genre', 'order', 'studio', 'sort']) {
-        if (b[key] === undefined)
-            continue;
-        if (typeof b[key] !== 'boolean') {
-            throw new Error(`registry.providers[${index}].browse.${key} must be boolean`);
-        }
-        caps[key] = b[key];
-    }
-    if (b.pageSize !== undefined) {
-        if (typeof b.pageSize !== 'number' || !Number.isInteger(b.pageSize) || b.pageSize < 1) {
-            throw new Error(`registry.providers[${index}].browse.pageSize must be a positive integer`);
-        }
-        caps.pageSize = b.pageSize;
-    }
-    return caps;
-}

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

@@ -1,226 +0,0 @@
-function normalizeCompact(s) {
-    return s.toLowerCase().replace(/[^a-z0-9]/g, '');
-}
-function tokenize(s) {
-    return s
-        .toLowerCase()
-        .replace(/[^\p{L}\p{N}\s]/gu, ' ')
-        .split(/\s+/)
-        .filter((w) => w.length >= 2);
-}
-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]]);
-    const trailingNum = t.match(/\b(\d+)\s*(season)?\s*$/);
-    if (trailingNum)
-        return trailingNum[1];
-    return '';
-}
-function distinctiveTokens(s) {
-    return [...new Set(tokenize(s).filter((w) => !STOPWORDS.has(w)))];
-}
-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);
-    if (/^re\s*zero$/i.test(title.trim()))
-        push('Re Zero');
-    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

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

package/server/dist/rclone.js

@@ -1,120 +0,0 @@
-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

@@ -1,77 +0,0 @@
-import { eq, inArray, sql } from 'drizzle-orm';
-import { getDrizzle } from '../db/drizzle.js';
-import { asmrProgress } from '../db/schema-asmr.js';
-import { makeLibraryRepo } from './library.repository.js';
-export const ASMR_STATUSES = ['Listening', 'Completed', 'On-Hold', 'Dropped', 'Planned'];
-export function buildAsmrId(rjCode) {
-    return String(rjCode).trim().toUpperCase();
-}
-export const AsmrLibraryRepository = {
-    ...makeLibraryRepo('asmr_library'),
-    upsert: (db, data) => getDrizzle(db).run(sql `
-      INSERT INTO asmr_library (id, rjCode, title, thumbnail, status, isAdult, updatedAt)
-      VALUES (${data.id}, ${data.rjCode}, ${data.title}, ${data.thumbnail}, ${data.status}, ${data.isAdult ? 1 : 0}, 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')`),
-    touchProgress: (db, id, progress) => getDrizzle(db).run(sql `
-      UPDATE asmr_library SET lastTrackIndex = ${progress.trackIndex}, lastTrackLabel = ${progress.trackLabel}, lastPosition = ${progress.position}, updatedAt = strftime('%s', 'now') WHERE id = ${id}`),
-};
-export const AsmrProgressRepository = {
-    getByWork: (db, workId) => getDrizzle(db).all(sql `
-      SELECT workId, trackIndex, trackLabel, currentTime, duration, updatedAt FROM asmr_progress WHERE workId = ${workId} ORDER BY updatedAt DESC`),
-    getTrack: async (db, workId, trackIndex) => {
-        const rows = await getDrizzle(db).all(sql `
-      SELECT workId, trackIndex, trackLabel, currentTime, duration, updatedAt FROM asmr_progress WHERE workId = ${workId} AND trackIndex = ${trackIndex}`);
-        return rows[0];
-    },
-    getLatest: async (db, workId) => {
-        const rows = await getDrizzle(db).all(sql `
-      SELECT workId, trackIndex, trackLabel, currentTime, duration, updatedAt FROM asmr_progress WHERE workId = ${workId} ORDER BY updatedAt DESC LIMIT 1`);
-        return rows[0];
-    },
-    upsert: (db, data) => getDrizzle(db).run(sql `
-      INSERT INTO asmr_progress (workId, trackIndex, trackLabel, currentTime, duration, title, thumbnail, rjCode, isAdult, updatedAt)
-      VALUES (${data.workId}, ${data.trackIndex}, ${data.trackLabel}, ${data.currentTime}, ${data.duration}, ${data.title ?? null}, ${data.thumbnail ?? null}, ${data.rjCode ?? null}, ${data.isAdult ?? null}, 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')`),
-    deleteByWork: (db, workId) => getDrizzle(db).delete(asmrProgress).where(eq(asmrProgress.workId, workId)),
-    deleteMany: (db, ids) => {
-        if (ids.length === 0)
-            return Promise.resolve();
-        return getDrizzle(db).delete(asmrProgress).where(inArray(asmrProgress.workId, ids));
-    },
-    deleteTrack: (db, workId, trackIndex) => getDrizzle(db).run(sql `
-      DELETE FROM asmr_progress WHERE workId = ${workId} AND trackIndex = ${trackIndex}`),
-    getContinueListening: (db, limit) => {
-        const limitClause = typeof limit === 'number' ? `LIMIT ${limit}` : '';
-        return getDrizzle(db).all(sql `
-      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
-      ${sql.raw(limitClause)}`);
-    },
-};

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

@@ -1,106 +0,0 @@
-import { sql } from 'drizzle-orm';
-import { getDrizzle } from '../db/drizzle.js';
-export const InsightsRepository = {
-    getCoreStats: async (db) => (await getDrizzle(db).all(sql `
-      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`))[0],
-    getActivityGrid: (db) => getDrizzle(db).all(sql `
-      SELECT date(watchedAt) as day, COUNT(*) as count FROM watched_episodes WHERE NOT (currentTime = 0 AND duration = 0) GROUP BY day`),
-    getHourlyDist: (db) => getDrizzle(db).all(sql `
-      SELECT strftime('%H', watchedAt) as hour, COUNT(*) as count FROM watched_episodes WHERE NOT (currentTime = 0 AND duration = 0) GROUP BY hour`),
-    getSeasonality: (db) => getDrizzle(db).all(sql `
-      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) => getDrizzle(db).all(sql `
-      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) => getDrizzle(db).all(sql `
-      SELECT DISTINCT sm.id, sm.genres, sm.popularityScore
-      FROM shows_meta sm
-      JOIN watched_episodes we ON sm.id = we.showId`),
-    getDroppedShows: (db) => getDrizzle(db).all(sql `
-      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) => getDrizzle(db).all(sql `
-      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) => getDrizzle(db).all(sql `
-      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`),
-    getLibraryShowsWithGenres: (db) => getDrizzle(db).all(sql `
-      SELECT
-        w.id,
-        w.status,
-        COALESCE(NULLIF(sm.englishName, ''), sm.name, w.name) as title,
-        sm.genres,
-        (SELECT COUNT(*) FROM watched_episodes we WHERE we.showId = w.id) as episodesWatched,
-        COALESCE(sm.popularityScore, 0) as popularityScore
-      FROM watchlist w
-      LEFT JOIN shows_meta sm ON sm.id = w.id`),
-    getAllAnilistIds: (db) => getDrizzle(db).all(sql `SELECT anilistId FROM shows_meta WHERE anilistId IS NOT NULL`),
-};