@serifpersia/dango 3.3.9 → 3.4.0

package/server/dist/trpc/routers/discord.js

@@ -0,0 +1,288 @@
+import { TRPCError } from '@trpc/server';
+import { protectedProcedure, router } from '../index.js';
+import { defineSchema, optStr, reqObj } from '../validation.js';
+import { discordRPCService } from '../../discord-rpc.js';
+import { discordGatewayService } from '../../discord-gateway.js';
+import { getDlsitePoster, getMangadexCover } from '../../hono/watchlist.js';
+import { updateEnvFile } from '../../utils/env.utils.js';
+import { CONFIG } from '../../config.js';
+import logger from '../../logger.js';
+function failed(message) {
+    return new TRPCError({ code: 'INTERNAL_SERVER_ERROR', message });
+}
+function badRequest(message) {
+    return new TRPCError({ code: 'BAD_REQUEST', message });
+}
+function maskToken(t) {
+    if (!t)
+        return 'none';
+    return t.slice(0, 8) + '...' + t.slice(-4);
+}
+const gatewayLog = logger.child({ module: 'DiscordGatewayRoutes' });
+function optUnknown(obj, name) {
+    return obj[name];
+}
+function cleanProxyThumb(value) {
+    let thumb = String(value || '');
+    if (thumb.includes('/api/proxy') || thumb.includes('/api/image-proxy')) {
+        const match = thumb.match(/url=([^&]+)/);
+        if (match) {
+            try {
+                thumb = decodeURIComponent(match[1]);
+            }
+            catch {
+                return '';
+            }
+        }
+    }
+    if (!thumb.startsWith('https://'))
+        return '';
+    if (thumb.includes('localhost') || thumb.includes('127.0.0.1'))
+        return '';
+    return thumb;
+}
+const presenceInput = () => defineSchema((value) => {
+    if (value === undefined || value === null)
+        return {};
+    return { ...reqObj(value) };
+});
+export const discordRouter = router({
+    pageStatus: protectedProcedure.input(presenceInput()).mutation(async ({ input }) => {
+        const page = optUnknown(input, 'page');
+        if (typeof page !== 'string' || !discordRPCService.isServiceEnabled) {
+            return { success: true };
+        }
+        discordRPCService.setIdleStatus(page);
+        return { success: true };
+    }),
+    heartbeat: protectedProcedure.input(presenceInput()).mutation(async ({ input }) => {
+        const sessionId = optUnknown(input, 'sessionId');
+        const bye = optUnknown(input, 'bye');
+        if (typeof sessionId !== 'string' || !discordRPCService.isServiceEnabled) {
+            return { success: true };
+        }
+        if (bye) {
+            discordRPCService.removeHeartbeat(sessionId);
+        }
+        else {
+            discordRPCService.heartbeat(sessionId);
+        }
+        return { success: true };
+    }),
+    asmrPresence: protectedProcedure.input(presenceInput()).mutation(async ({ input }) => {
+        if (!discordRPCService.isServiceEnabled)
+            return { success: true };
+        const sessionId = optUnknown(input, 'sessionId');
+        if (typeof sessionId === 'string')
+            discordRPCService.heartbeat(sessionId);
+        const thumbnail = optUnknown(input, 'thumbnail');
+        const thumbnails = optUnknown(input, 'thumbnails');
+        const rjCode = optUnknown(input, 'rjCode');
+        let thumb = String(thumbnail || '');
+        const thumbs = Array.isArray(thumbnails) ? thumbnails.map(String).filter(Boolean) : undefined;
+        const needsDlsite = !thumb || thumb.includes('weeabo0.xyz') || thumb.includes('japaneseasmr.com');
+        if (needsDlsite && rjCode) {
+            const dlsiteThumb = await getDlsitePoster(String(rjCode));
+            if (dlsiteThumb)
+                thumb = dlsiteThumb;
+        }
+        if (thumb.includes('/api/image-proxy') || thumb.includes('weeabo0.xyz'))
+            thumb = '';
+        discordRPCService.updatePresence({
+            title: String(optUnknown(input, 'title') || 'ASMR').slice(0, 128),
+            episode: String(optUnknown(input, 'trackLabel') || '').slice(0, 64),
+            totalEpisodes: '',
+            currentTime: Number(optUnknown(input, 'currentTime')) || 0,
+            duration: Number(optUnknown(input, 'duration')) || 0,
+            thumbnail: thumb,
+            thumbnails: thumbs,
+            isPlaying: !!optUnknown(input, 'isPlaying'),
+            providerName: 'ASMR',
+            sessionId: typeof sessionId === 'string' ? sessionId : undefined,
+            isAdult: !!optUnknown(input, 'isAdult'),
+        });
+        return { success: true };
+    }),
+    radioPresence: protectedProcedure.input(presenceInput()).mutation(async ({ input }) => {
+        if (!discordRPCService.isServiceEnabled)
+            return { success: true };
+        const sessionId = optUnknown(input, 'sessionId');
+        if (typeof sessionId === 'string')
+            discordRPCService.heartbeat(sessionId);
+        let thumb = String(optUnknown(input, 'thumbnail') || '');
+        if (thumb.includes('/api/image-proxy')) {
+            const match = thumb.match(/url=([^&]+)/);
+            if (match)
+                thumb = decodeURIComponent(match[1]);
+        }
+        if (thumb && !thumb.startsWith('https://'))
+            thumb = '';
+        if (thumb.includes('localhost') || thumb.includes('127.0.0.1'))
+            thumb = '';
+        const stationLabel = String(optUnknown(input, 'stationLabel') || '');
+        discordRPCService.updatePresence({
+            title: String(optUnknown(input, 'title') || 'Radio').slice(0, 128),
+            episode: stationLabel.slice(0, 64),
+            totalEpisodes: '',
+            stateLine: (stationLabel || 'Radio').slice(0, 64),
+            currentTime: Number(optUnknown(input, 'currentTime')) || 0,
+            duration: 0,
+            thumbnail: thumb,
+            isPlaying: !!optUnknown(input, 'isPlaying'),
+            providerName: 'Radio',
+            sessionId: typeof sessionId === 'string' ? sessionId : undefined,
+            isAdult: false,
+        });
+        return { success: true };
+    }),
+    musicPresence: protectedProcedure.input(presenceInput()).mutation(async ({ input }) => {
+        if (!discordRPCService.isServiceEnabled)
+            return { success: true };
+        const sessionId = optUnknown(input, 'sessionId');
+        if (typeof sessionId === 'string')
+            discordRPCService.heartbeat(sessionId);
+        let thumb = String(optUnknown(input, 'thumbnail') || '');
+        if (thumb.includes('/api/image-proxy')) {
+            const match = thumb.match(/url=([^&]+)/);
+            if (match)
+                thumb = decodeURIComponent(match[1]);
+        }
+        if (thumb && !thumb.startsWith('https://'))
+            thumb = '';
+        if (thumb.includes('localhost') || thumb.includes('127.0.0.1'))
+            thumb = '';
+        const artistLabel = String(optUnknown(input, 'artistLabel') || '');
+        discordRPCService.updatePresence({
+            title: String(optUnknown(input, 'title') || 'Music').slice(0, 128),
+            episode: artistLabel.slice(0, 64),
+            totalEpisodes: '',
+            stateLine: (artistLabel || 'Music').slice(0, 64),
+            currentTime: Number(optUnknown(input, 'currentTime')) || 0,
+            duration: Number(optUnknown(input, 'duration')) || 0,
+            thumbnail: thumb,
+            isPlaying: !!optUnknown(input, 'isPlaying'),
+            providerName: 'Music',
+            sessionId: typeof sessionId === 'string' ? sessionId : undefined,
+            isAdult: false,
+        });
+        return { success: true };
+    }),
+    mangaPresence: protectedProcedure.input(presenceInput()).mutation(async ({ input }) => {
+        if (!discordRPCService.isServiceEnabled)
+            return { success: true };
+        const sessionId = optUnknown(input, 'sessionId');
+        if (typeof sessionId === 'string')
+            discordRPCService.heartbeat(sessionId);
+        const thumbnails = optUnknown(input, 'thumbnails');
+        const title = optUnknown(input, 'title');
+        let thumb = cleanProxyThumb(optUnknown(input, 'thumbnail'));
+        let thumbs = Array.isArray(thumbnails)
+            ? thumbnails.map(cleanProxyThumb).filter(Boolean)
+            : undefined;
+        if (!thumb && title) {
+            const fallback = await getMangadexCover(String(title));
+            if (fallback) {
+                thumb = fallback;
+                thumbs = [fallback, ...(thumbs || [])];
+            }
+        }
+        const chapterLabel = String(optUnknown(input, 'chapterLabel') || '');
+        discordRPCService.updatePresence({
+            title: String(title || 'Manga').slice(0, 128),
+            episode: chapterLabel.slice(0, 64),
+            totalEpisodes: '',
+            stateLine: (chapterLabel ? `Reading ${chapterLabel}` : 'Reading').slice(0, 64),
+            currentTime: 0,
+            duration: 0,
+            thumbnail: thumb,
+            thumbnails: thumbs,
+            isPlaying: optUnknown(input, 'isPlaying') !== false,
+            providerName: 'Manga',
+            sessionId: typeof sessionId === 'string' ? sessionId : undefined,
+            isAdult: optUnknown(input, 'isAdult') === true,
+        });
+        return { success: true };
+    }),
+    tvPresence: protectedProcedure.input(presenceInput()).mutation(async ({ input }) => {
+        if (!discordRPCService.isServiceEnabled)
+            return { success: true };
+        const sessionId = optUnknown(input, 'sessionId');
+        if (typeof sessionId === 'string')
+            discordRPCService.heartbeat(sessionId);
+        const thumbnail = optUnknown(input, 'thumbnail');
+        let thumb = String(thumbnail || '');
+        if (thumb.includes('/api/image-proxy')) {
+            const match = thumb.match(/url=([^&]+)/);
+            if (match)
+                thumb = decodeURIComponent(match[1]);
+        }
+        if (thumb.includes('localhost') || thumb.includes('127.0.0.1'))
+            thumb = '';
+        const episodeLabel = String(optUnknown(input, 'episodeLabel') || '');
+        discordRPCService.updatePresence({
+            title: String(optUnknown(input, 'title') || 'TV').slice(0, 128),
+            episode: episodeLabel.slice(0, 64),
+            totalEpisodes: '',
+            stateLine: (episodeLabel || 'Movie').slice(0, 64),
+            currentTime: Number(optUnknown(input, 'currentTime')) || 0,
+            duration: Number(optUnknown(input, 'duration')) || 0,
+            thumbnail: thumb,
+            isPlaying: !!optUnknown(input, 'isPlaying'),
+            providerName: 'TV',
+            sessionId: typeof sessionId === 'string' ? sessionId : undefined,
+            isAdult: optUnknown(input, 'isAdult') === true,
+        });
+        return { success: true };
+    }),
+    gatewayStatus: protectedProcedure.query(() => {
+        const hasToken = discordGatewayService.hasToken();
+        return {
+            hasToken,
+            masked: hasToken ? maskToken(process.env.DISCORD_GATEWAY_TOKEN) : null,
+            enabled: discordGatewayService.serviceEnabled,
+        };
+    }),
+    gatewaySave: protectedProcedure
+        .input(defineSchema((value) => {
+        if (value === undefined || value === null)
+            return {};
+        const obj = reqObj(value);
+        const out = {};
+        const token = optStr(obj, 'token');
+        if (token !== undefined)
+            out.token = token;
+        return out;
+    }))
+        .mutation(async ({ input }) => {
+        let token = (input.token || '').trim();
+        if (token.startsWith('"') && token.endsWith('"'))
+            token = token.slice(1, -1);
+        if (token.length < 30)
+            throw badRequest('Token too short');
+        try {
+            await updateEnvFile({ DISCORD_GATEWAY_TOKEN: token });
+            discordGatewayService.reloadToken();
+            gatewayLog.info(`Discord Gateway token saved ${maskToken(token)} (not logged)`);
+            return { ok: true, masked: maskToken(token) };
+        }
+        catch (e) {
+            gatewayLog.error({ err: e }, 'Failed to save Discord Gateway token');
+            throw failed('Failed to save token');
+        }
+    }),
+    gatewayRemove: protectedProcedure.mutation(async () => {
+        try {
+            await updateEnvFile({ DISCORD_GATEWAY_TOKEN: '' });
+            discordGatewayService.reloadToken();
+            gatewayLog.info('Discord Gateway token removed');
+            return { ok: true };
+        }
+        catch (e) {
+            gatewayLog.error({ err: e }, 'Failed to remove Discord Gateway token');
+            throw failed('Failed to remove token');
+        }
+    }),
+    rolesConfig: protectedProcedure.query(() => {
+        return { workerUrl: CONFIG.DISCORD_ROLES_WORKER_URL || null };
+    }),
+});

package/server/dist/trpc/routers/discovery.js

@@ -0,0 +1,15 @@
+import { protectedProcedure, router } from '../index.js';
+import { getWatchlistDiscoveryStatus, triggerWatchlistDiscovery } from '../../hono/watchlist.js';
+export const discoveryRouter = router({
+    status: protectedProcedure.query(() => {
+        return getWatchlistDiscoveryStatus();
+    }),
+    nudge: protectedProcedure.mutation(() => {
+        const started = triggerWatchlistDiscovery(false);
+        return { success: true, started, ...getWatchlistDiscoveryStatus() };
+    }),
+    refresh: protectedProcedure.mutation(() => {
+        const started = triggerWatchlistDiscovery(true);
+        return { success: true, started, ...getWatchlistDiscoveryStatus() };
+    }),
+});

package/server/dist/trpc/routers/insights.js

@@ -0,0 +1,45 @@
+import { TRPCError } from '@trpc/server';
+import { protectedProcedure, router } from '../index.js';
+import { getWatchInsights, getGenreCards } from '../../lib/insights.js';
+import { computeDiscordSyncStats, getCachedRecommendations, getLinkedDiscordUser, setLinkedDiscordUser, syncDiscordRoles, } from '../../lib/discord-roles-sync.service.js';
+import { defineSchema, reqObj } from '../validation.js';
+const discordUserInput = () => defineSchema((value) => {
+    if (value === undefined || value === null)
+        return {};
+    return { user: reqObj(value).user };
+});
+export const insightsRouter = router({
+    summary: protectedProcedure.query(async ({ ctx }) => {
+        return getWatchInsights(ctx.db);
+    }),
+    genreCards: protectedProcedure.query(async ({ ctx }) => {
+        return getGenreCards(ctx.db);
+    }),
+    recommendations: protectedProcedure.query(async ({ ctx }) => {
+        return { candidates: await getCachedRecommendations(ctx.db) };
+    }),
+    discordSyncStats: protectedProcedure.query(async ({ ctx }) => {
+        return computeDiscordSyncStats(ctx.db);
+    }),
+    discordUser: protectedProcedure.query(async ({ ctx }) => {
+        return { user: await getLinkedDiscordUser(ctx.db) };
+    }),
+    setDiscordUser: protectedProcedure.input(discordUserInput()).mutation(async ({ ctx, input }) => {
+        const { user } = input;
+        if (user !== null &&
+            user !== undefined &&
+            (typeof user !== 'object' ||
+                typeof user.id !== 'string' ||
+                !user.id)) {
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: 'Invalid user payload: expected { id, ... } or null',
+            });
+        }
+        await setLinkedDiscordUser(ctx.db, user || null);
+        return { success: true, user: user || null };
+    }),
+    discordSyncNow: protectedProcedure.mutation(async ({ ctx }) => {
+        return syncDiscordRoles(ctx.db, true);
+    }),
+});

package/server/dist/trpc/routers/manga-library.js

@@ -0,0 +1,280 @@
+import { TRPCError } from '@trpc/server';
+import { protectedProcedure, router } from '../index.js';
+import { performMangaWriteTransactionAsync } from '../../sync.js';
+import { buildMangaId, MANGA_STATUSES, MangaLibraryRepository, MangaProgressRepository, } from '../../repositories/manga.repository.js';
+import { defineSchema, optStr, reqObj } from '../validation.js';
+function mangaDb(ctx) {
+    const db = ctx.mangaDb;
+    if (!db || db.isClosedCheck())
+        throw new Error('Manga database is not ready');
+    return db;
+}
+function normalizeId(provider, mangaId, idRaw) {
+    if (idRaw && idRaw.includes(':'))
+        return idRaw;
+    return buildMangaId(provider, mangaId || idRaw || '');
+}
+function badRequest(message) {
+    return new TRPCError({ code: 'BAD_REQUEST', message });
+}
+function failed(message) {
+    return new TRPCError({ code: 'INTERNAL_SERVER_ERROR', message });
+}
+function readCount(obj, name, fallback) {
+    const raw = obj[name];
+    if (raw === undefined || raw === null || raw === '')
+        return fallback;
+    const n = Math.floor(Number(raw));
+    return Number.isFinite(n) ? n : fallback;
+}
+const mangaLibraryListInput = () => defineSchema((value) => {
+    const obj = reqObj(value);
+    const status = optStr(obj, 'status');
+    const page = Math.max(readCount(obj, 'page', 1), 1);
+    const limit = Math.min(Math.max(readCount(obj, 'limit', 24), 1), 100);
+    return { status, page, limit };
+});
+const mangaLibraryIdInput = () => defineSchema((value) => {
+    const obj = reqObj(value);
+    const id = obj.id;
+    if (typeof id !== 'string')
+        throw new Error('id must be a string');
+    return { id };
+});
+const mangaLibraryAddInput = () => defineSchema((value) => {
+    const obj = reqObj(value);
+    const out = {
+        provider: optStr(obj, 'provider'),
+        mangaId: optStr(obj, 'mangaId'),
+        id: optStr(obj, 'id'),
+        title: optStr(obj, 'title'),
+        cover: optStr(obj, 'cover'),
+        status: optStr(obj, 'status'),
+        author: optStr(obj, 'author'),
+        altTitle: optStr(obj, 'altTitle'),
+        contentRating: optStr(obj, 'contentRating'),
+    };
+    if (typeof obj.silent === 'boolean')
+        out.silent = obj.silent;
+    return out;
+});
+const mangaLibraryRemoveInput = () => defineSchema((value) => {
+    if (typeof value !== 'string')
+        throw new Error('id must be a string');
+    return value;
+});
+const mangaLibraryStatusInput = () => defineSchema((value) => {
+    const obj = reqObj(value);
+    return { id: optStr(obj, 'id'), status: optStr(obj, 'status') };
+});
+const mangaLibraryLinkInput = () => defineSchema((value) => {
+    const obj = reqObj(value);
+    return { id: optStr(obj, 'id'), anilistId: obj.anilistId };
+});
+const mangaLibraryBatchStatusInput = () => defineSchema((value) => {
+    const obj = reqObj(value);
+    const idsRaw = obj.ids;
+    const ids = Array.isArray(idsRaw) ? idsRaw.map((id) => String(id)) : [];
+    return { ids, status: optStr(obj, 'status') };
+});
+const mangaLibraryRemoveManyInput = () => defineSchema((value) => {
+    if (!Array.isArray(value))
+        throw new Error('ids must be a non-empty array');
+    return value.map((id) => String(id));
+});
+export const mangaLibraryRouter = router({
+    list: protectedProcedure.input(mangaLibraryListInput()).query(async ({ ctx, input }) => {
+        try {
+            const offset = (input.page - 1) * input.limit;
+            const db = mangaDb(ctx);
+            const rows = await MangaLibraryRepository.getAll(db, input.status, input.limit, offset);
+            const total = await MangaLibraryRepository.getCount(db, input.status);
+            return { data: rows, total, page: input.page, limit: input.limit };
+        }
+        catch (err) {
+            if (err instanceof TRPCError)
+                throw err;
+            throw failed('Failed to load manga library');
+        }
+    }),
+    ids: protectedProcedure.query(async ({ ctx }) => {
+        try {
+            return { ids: await MangaLibraryRepository.getIds(mangaDb(ctx)) };
+        }
+        catch {
+            return { ids: [] };
+        }
+    }),
+    check: protectedProcedure.input(mangaLibraryIdInput()).query(async ({ ctx, input }) => {
+        try {
+            const item = await MangaLibraryRepository.getById(mangaDb(ctx), input.id);
+            return { inLibrary: !!item, status: item?.status ?? null };
+        }
+        catch {
+            return { inLibrary: false, status: null };
+        }
+    }),
+    entry: protectedProcedure.input(mangaLibraryIdInput()).query(async ({ ctx, input }) => {
+        try {
+            const item = await MangaLibraryRepository.getById(mangaDb(ctx), input.id);
+            if (!item)
+                throw new TRPCError({ code: 'NOT_FOUND', message: 'Not in library' });
+            return { item };
+        }
+        catch (err) {
+            if (err instanceof TRPCError)
+                throw err;
+            throw failed('Failed to load entry');
+        }
+    }),
+    add: protectedProcedure.input(mangaLibraryAddInput()).mutation(async ({ ctx, input }) => {
+        const provider = input.provider || '';
+        const mangaId = input.mangaId || '';
+        const idRaw = input.id || '';
+        if (!provider || (!mangaId && !idRaw)) {
+            throw badRequest('provider and mangaId are required');
+        }
+        const id = normalizeId(String(provider), String(mangaId || ''), idRaw ? String(idRaw) : undefined);
+        const cleanStatus = typeof input.status === 'string' && MANGA_STATUSES.includes(input.status)
+            ? input.status
+            : 'Reading';
+        try {
+            await performMangaWriteTransactionAsync(mangaDb(ctx), async (tx) => {
+                await MangaLibraryRepository.upsert(tx, {
+                    id,
+                    provider: String(provider).toLowerCase(),
+                    mangaId: String(mangaId || idRaw || ''),
+                    title: String(input.title || ''),
+                    cover: String(input.cover || ''),
+                    status: cleanStatus,
+                    author: input.author ? String(input.author) : undefined,
+                    altTitle: input.altTitle ? String(input.altTitle) : undefined,
+                    contentRating: input.contentRating ? String(input.contentRating) : undefined,
+                });
+            });
+            return { success: true, id };
+        }
+        catch (err) {
+            if (err instanceof TRPCError)
+                throw err;
+            throw failed('Failed to bookmark manga');
+        }
+    }),
+    remove: protectedProcedure.input(mangaLibraryRemoveInput()).mutation(async ({ ctx, input }) => {
+        if (!input)
+            throw badRequest('id is required');
+        try {
+            await performMangaWriteTransactionAsync(mangaDb(ctx), async (tx) => {
+                await MangaLibraryRepository.delete(tx, String(input));
+                await MangaProgressRepository.deleteByManga(tx, String(input));
+            });
+            return { success: true };
+        }
+        catch (err) {
+            if (err instanceof TRPCError)
+                throw err;
+            throw failed('Failed to remove bookmark');
+        }
+    }),
+    setStatus: protectedProcedure
+        .input(mangaLibraryStatusInput())
+        .mutation(async ({ ctx, input }) => {
+        if (!input.id || !MANGA_STATUSES.includes(input.status)) {
+            throw badRequest('id and a valid status are required');
+        }
+        try {
+            await performMangaWriteTransactionAsync(mangaDb(ctx), async (tx) => {
+                await MangaLibraryRepository.updateStatus(tx, String(input.id), String(input.status));
+            });
+            return { success: true };
+        }
+        catch (err) {
+            if (err instanceof TRPCError)
+                throw err;
+            throw failed('Failed to update status');
+        }
+    }),
+    link: protectedProcedure.input(mangaLibraryLinkInput()).mutation(async ({ ctx, input }) => {
+        const targetId = typeof input.id === 'string' ? input.id : '';
+        const mediaId = Number(input.anilistId);
+        if (!targetId || !Number.isInteger(mediaId) || mediaId <= 0) {
+            throw badRequest('id and a numeric anilistId are required');
+        }
+        try {
+            const db = mangaDb(ctx);
+            const row = await MangaLibraryRepository.getById(db, targetId);
+            if (!row)
+                throw new TRPCError({ code: 'NOT_FOUND', message: 'Library entry not found' });
+            if (String(row.provider).toLowerCase() === 'anilist') {
+                throw badRequest('Link a provider bookmark to the AniList entry, not the reverse');
+            }
+            let progressMigrated = false;
+            await performMangaWriteTransactionAsync(db, async (tx) => {
+                await MangaLibraryRepository.setAnilistId(tx, targetId, mediaId, 'manual');
+                const orphanId = `anilist:${mediaId}`;
+                if (orphanId !== targetId) {
+                    const orphan = await MangaLibraryRepository.getById(tx, orphanId);
+                    const target = await MangaLibraryRepository.getById(tx, targetId);
+                    const targetProgress = await MangaProgressRepository.getByManga(tx, targetId);
+                    if (orphan?.lastChapterNumber &&
+                        !target?.lastChapterNumber &&
+                        targetProgress.length === 0) {
+                        await MangaLibraryRepository.setProgressPointer(tx, targetId, orphan.lastChapterNumber);
+                        await MangaProgressRepository.moveSyntheticChapters(tx, orphanId, targetId);
+                        progressMigrated = true;
+                    }
+                    await MangaLibraryRepository.delete(tx, orphanId);
+                    await MangaProgressRepository.deleteByManga(tx, orphanId);
+                }
+            });
+            return { success: true, id: targetId, progressMigrated };
+        }
+        catch (err) {
+            if (err instanceof TRPCError)
+                throw err;
+            throw failed('Failed to link entry');
+        }
+    }),
+    batchStatus: protectedProcedure
+        .input(mangaLibraryBatchStatusInput())
+        .mutation(async ({ ctx, input }) => {
+        if (!Array.isArray(input.ids) || input.ids.length === 0) {
+            throw badRequest('ids must be a non-empty array');
+        }
+        if (!input.status || !MANGA_STATUSES.includes(input.status)) {
+            throw badRequest('a valid status is required');
+        }
+        const ids = input.ids.map((id) => String(id));
+        try {
+            await performMangaWriteTransactionAsync(mangaDb(ctx), async (tx) => {
+                await MangaLibraryRepository.updateStatusMany(tx, ids, String(input.status));
+            });
+            return { success: true, updated: ids.length };
+        }
+        catch (err) {
+            if (err instanceof TRPCError)
+                throw err;
+            throw failed('Failed to update statuses');
+        }
+    }),
+    removeMany: protectedProcedure
+        .input(mangaLibraryRemoveManyInput())
+        .mutation(async ({ ctx, input }) => {
+        if (!Array.isArray(input) || input.length === 0) {
+            throw badRequest('ids must be a non-empty array');
+        }
+        const ids = input.map((id) => String(id));
+        try {
+            await performMangaWriteTransactionAsync(mangaDb(ctx), async (tx) => {
+                await MangaLibraryRepository.deleteMany(tx, ids);
+                await MangaProgressRepository.deleteMany(tx, ids);
+            });
+            return { success: true, removed: ids.length };
+        }
+        catch (err) {
+            if (err instanceof TRPCError)
+                throw err;
+            throw failed('Failed to remove bookmarks');
+        }
+    }),
+});