ehbrowser 1.0.0

package/dist/services/favorite-service.js

@@ -0,0 +1,237 @@
+/*
+ * 收藏服务。
+ * 本地部分（收藏夹与夹内条目）落在 SQLite，离线可用；云端部分（槽位 0～9 的名称、数量、
+ * 夹内画廊）向 favorites.php 取，未登录或上游不可达时只给本地那份，并把原因带回去。
+ * 「标记号」指条目上的 slot：修改该字段即把这条收藏挪到另一个云端分类，登录时同步到上游。
+ */
+import { randomUUID } from "node:crypto";
+import { activeAccount } from "../config/index.js";
+import { fetchFavoriteCategories, fetchFavoriteGalleryPairs, LoginRequiredError, setFavorite, } from "../eh/index.js";
+import { describeError } from "../platform/errors.js";
+/** 默认收藏夹的名字。第一次打开收藏页时自动建一个，保证界面有可选的收藏夹 */
+const DEFAULT_FOLDER_NAME = "本地收藏1";
+function toItem(row) {
+    return {
+        gid: row.gid,
+        token: row.token,
+        title: row.title,
+        thumbUrl: row.thumb_url,
+        pageCount: row.page_count,
+        slot: row.slot,
+        addedAt: row.added_at,
+    };
+}
+export function createFavoriteService(ctx, gallery, options = {}) {
+    const log = options.logger ?? (() => undefined);
+    const db = ctx.db.raw;
+    /** 上游请求参数：登录后用当前账号的 Cookie */
+    function requestOptions(signal) {
+        const account = activeAccount(ctx.auth.get());
+        const site = account?.site ?? ctx.user.get().preferredSite;
+        if (account === null) {
+            return null;
+        }
+        const cookies = {
+            ipb_member_id: account.cookies.ipbMemberId,
+            ipb_pass_hash: account.cookies.ipbPassHash,
+        };
+        if (account.cookies.igneous !== "") {
+            cookies["igneous"] = account.cookies.igneous;
+        }
+        return {
+            site,
+            cookies,
+            ...(signal === undefined ? {} : { signal }),
+        };
+    }
+    function folders() {
+        const rows = db
+            .prepare("select * from favorite_folders order by position asc, created_at asc")
+            .all();
+        return rows.map((row) => ({
+            id: row.id,
+            name: row.name,
+            count: db
+                .prepare("select count(*) as n from favorite_items where folder_id = ?")
+                .get(row.id).n,
+            createdAt: row.created_at,
+        }));
+    }
+    /** 一个夹都没有时建一个默认夹，保证界面始终有可选的收藏夹 */
+    function ensureDefaultFolder() {
+        const row = db.prepare("select count(*) as n from favorite_folders").get();
+        if (row.n > 0) {
+            return;
+        }
+        const now = Math.floor(Date.now() / 1000);
+        db.prepare("insert into favorite_folders (id, name, position, created_at) values (?, ?, ?, ?)").run(randomUUID(), DEFAULT_FOLDER_NAME, 1, now);
+    }
+    function items(folderId) {
+        const rows = db
+            .prepare("select * from favorite_items where folder_id = ? order by added_at desc")
+            .all(folderId);
+        return rows.map(toItem);
+    }
+    async function cloudFolders() {
+        const request = requestOptions();
+        if (request === null) {
+            return { cloud: [], error: "未登录，云端收藏夹不可见" };
+        }
+        try {
+            const list = await fetchFavoriteCategories(request);
+            return { cloud: [...list], error: null };
+        }
+        catch (error) {
+            const reason = error instanceof LoginRequiredError ? "登录已失效" : describeError(error);
+            log("warn", `云端收藏夹读取失败：${reason}`);
+            return { cloud: [], error: reason };
+        }
+    }
+    return {
+        async state() {
+            ensureDefaultFolder();
+            const { cloud, error } = await cloudFolders();
+            return { folders: folders(), cloud, cloudError: error };
+        },
+        async cloudItems(slot) {
+            const request = requestOptions();
+            if (request === null) {
+                return [];
+            }
+            const pairs = await fetchFavoriteGalleryPairs(slot, request);
+            if (pairs.length === 0) {
+                return [];
+            }
+            return gallery.summariesOf(pairs);
+        },
+        createFolder(name) {
+            const now = Math.floor(Date.now() / 1000);
+            const next = db
+                .prepare("select coalesce(max(position), 0) + 1 as position from favorite_folders")
+                .get();
+            db.prepare("insert into favorite_folders (id, name, position, created_at) values (?, ?, ?, ?)").run(randomUUID(), name.trim() === "" ? "新收藏夹" : name.trim(), next.position, now);
+            return { folders: folders(), cloud: [], cloudError: null };
+        },
+        removeFolder(id) {
+            db.prepare("delete from favorite_items where folder_id = ?").run(id);
+            db.prepare("delete from favorite_folders where id = ?").run(id);
+            ensureDefaultFolder();
+            return { folders: folders(), cloud: [], cloudError: null };
+        },
+        items,
+        async add(input) {
+            const now = Math.floor(Date.now() / 1000);
+            db.prepare(`insert into favorite_items
+                 (folder_id, gid, token, title, thumb_url, page_count, slot, added_at)
+                 values (?, ?, ?, ?, ?, ?, ?, ?)
+                 on conflict(folder_id, gid) do update set
+                 title = excluded.title, thumb_url = excluded.thumb_url,
+                 page_count = excluded.page_count, token = excluded.token`).run(input.folderId, input.gid, input.token, input.title, input.thumbUrl, input.pageCount, input.slot ?? -1, now);
+            // 指定了槽位时同步到上游；失败只记日志，本地记录保留
+            if (input.slot !== undefined && input.slot >= 0) {
+                await syncSlot(input.gid, input.token, input.slot);
+            }
+            return items(input.folderId);
+        },
+        removeItem(folderId, gid) {
+            db.prepare("delete from favorite_items where folder_id = ? and gid = ?").run(folderId, gid);
+            return items(folderId);
+        },
+        async setSlot(folderId, gid, slot) {
+            db.prepare("update favorite_items set slot = ? where folder_id = ? and gid = ?").run(slot, folderId, gid);
+            const row = db
+                .prepare("select token from favorite_items where folder_id = ? and gid = ?")
+                .get(folderId, gid);
+            if (row !== undefined) {
+                await syncSlot(gid, row.token, slot);
+            }
+            return items(folderId);
+        },
+        async refresh(folderId, gids) {
+            const all = items(folderId);
+            const wanted = gids === undefined || gids.length === 0
+                ? all
+                : all.filter((item) => gids.includes(item.gid));
+            const results = [];
+            for (const item of wanted) {
+                results.push(await moveToLatest(folderId, item));
+            }
+            return {
+                entries: results,
+                moved: results.filter((entry) => entry.moved).length,
+                items: items(folderId),
+            };
+        },
+    };
+    /**
+     * 把一条收藏挪到它所属画廊的最新版本
+     * 上游的处理是「先取消旧版本的收藏，再把新版本放进同一个槽位」；
+     * 本地则是把这一行连同 added_at 一起改成新版本（新版本若已在夹里，两行合成一行）
+     */
+    async function moveToLatest(folderId, item) {
+        const skip = (reason, latestGid = null) => ({
+            gid: item.gid,
+            latestGid,
+            moved: false,
+            reason,
+        });
+        let latestGid;
+        let latestToken;
+        let latestTitle;
+        let latestThumb;
+        let latestPages;
+        try {
+            // 更新标记号同样需要新数据：current 关系变化时需要迁移
+            const detail = await gallery.detail(item.gid, item.token, { fresh: true });
+            // current 指回来的就是自己时同样视为没有新版本，否则会多一轮无用的上游写入
+            if (detail.current === null || detail.current.gid === item.gid) {
+                return skip("已是最新版本");
+            }
+            latestGid = detail.current.gid;
+            latestToken = detail.current.token;
+            // 新版本的标题与封面一并取回：收藏页显示的内容应与新版本一致
+            const summary = await gallery.summaryOf(latestGid, latestToken);
+            latestTitle = summary.title;
+            latestThumb = summary.thumbUrl;
+            latestPages = summary.pageCount;
+        }
+        catch (error) {
+            return skip(`读取画廊信息失败：${describeError(error)}`);
+        }
+        // 上游侧：仅在条目本就在云端收藏中时才操作，两次调用都成功才算同步成功
+        let reason = null;
+        if (item.slot >= 0) {
+            const removed = await syncSlot(item.gid, item.token, -1);
+            const added = await syncSlot(latestGid, latestToken, item.slot);
+            if (!removed || !added) {
+                reason = "上游标记号同步失败，只改了本地";
+            }
+        }
+        const targetSlot = item.slot >= 0 ? item.slot : -1;
+        db.prepare("delete from favorite_items where folder_id = ? and gid = ?").run(folderId, item.gid);
+        db.prepare(`insert into favorite_items
+             (folder_id, gid, token, title, thumb_url, page_count, slot, added_at)
+             values (?, ?, ?, ?, ?, ?, ?, ?)
+             on conflict(folder_id, gid) do update set
+             title = excluded.title, thumb_url = excluded.thumb_url,
+             page_count = excluded.page_count, token = excluded.token, slot = excluded.slot`).run(folderId, latestGid, latestToken, latestTitle === "" ? item.title : latestTitle, latestThumb === "" ? item.thumbUrl : latestThumb, latestPages, targetSlot, item.addedAt);
+        log("info", `更新标记号：#${item.gid} → #${latestGid}${reason === null ? "" : `（${reason}）`}`);
+        return { gid: item.gid, latestGid, moved: true, reason };
+    }
+    /** 把标记号同步到上游。未登录或上游不可达都只记日志：本地标记号仍然有效 */
+    async function syncSlot(gid, token, slot) {
+        const request = requestOptions();
+        if (request === null) {
+            log("info", `未登录，标记号只改本地：#${gid} → ${slot}`);
+            return false;
+        }
+        try {
+            await setFavorite(gid, token, slot, request);
+            return true;
+        }
+        catch (error) {
+            log("warn", `标记号同步失败：#${gid} ${describeError(error)}`);
+            return false;
+        }
+    }
+}

package/dist/services/gallery-service.js

@@ -0,0 +1,403 @@
+/*
+ * 画廊服务：把上游接口元数据与页面解析结果归一化为线上 DTO
+ * 列表只从搜索页取 (gid, token)，其余字段由 gdata 批量补全；详情与图片页需要解析 HTML
+ * 画廊页解析结果带短时缓存，连续翻页时不会每次重新获取
+ */
+import { GALLERY_CATEGORIES, GALLERY_LANGUAGES, SEARCH_PAGE_LIMIT, } from "../api/index.js";
+import { activeAccount } from "../config/index.js";
+import { callApi, fetchArchiveCatalog, galleryUrl, imagePageUrl, isUsablePage, parseGalleryPage, parseImagePage, parseSearchResults, searchUrl, torrentsUrl, LoginRequiredError, } from "../eh/index.js";
+import { createDetailCache } from "./detail-cache.js";
+import { createSearchCache } from "./search-cache.js";
+const SEARCH_PAGE_SIZE = 25;
+/** 查过且当时没有新版本时，隔多久重查一次（秒） */
+const RECHECK_NEWER_SECONDS = 86_400;
+const THUMBS_PER_PAGE = 20;
+/** 界面读取缓存时等待预热的上限。预热卡住时界面不能一直等下去 */
+const WARMUP_WAIT_MS = 12_000;
+/** 定时器不阻塞事件循环，进程可以正常退出 */
+function delay(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms).unref();
+    });
+}
+export function createGalleryService(ctx, upstream, options = {}) {
+    const cacheSize = options.cacheSize ?? 32;
+    const cacheTtlMs = options.cacheTtlMs ?? 5 * 60 * 1000;
+    /** 详情页缓存：条数上限取自设置，修改后立即生效 */
+    const detailCache = createDetailCache({
+        limit: () => ctx.user.get().ui.cachedGalleries,
+        ...(options.logger === undefined ? {} : { logger: options.logger }),
+    });
+    const pageCache = new Map();
+    const searchCache = createSearchCache(ctx.paths.cacheDir);
+    /** 在途的预热检索。界面在没有缓存时会等它，避免同一份结果被拉取两次 */
+    let warming = null;
+    // 上次运行留下的缓存一律丢弃：重启后的第一份结果由预热检索（或界面自身的检索）决定
+    void searchCache.discard();
+    /** 记录本次检索，界面再次进入搜索页时可以先据此铺出内容 */
+    function rememberSearch(query, result) {
+        searchCache.save({
+            query: { ...query, page: result.page, limit: result.limit },
+            result,
+            savedAt: Math.floor(Date.now() / 1000),
+        });
+    }
+    async function runSearch(query) {
+        const page = query.page ?? 1;
+        const limit = query.limit ?? SEARCH_PAGE_SIZE;
+        const response = await callApi({
+            url: searchUrl(currentSite(), {
+                ...query,
+                page: Math.max(0, page - 1),
+            }),
+            ...pageOptions(),
+        });
+        if (!isUsablePage(response.status)) {
+            throw new Error(`搜索页返回 HTTP ${response.status}`);
+        }
+        const pairs = parseSearchResults(response.text).slice(0, limit);
+        if (pairs.length === 0) {
+            const empty = { items: [], page, limit, hasNext: false };
+            rememberSearch(query, empty);
+            return empty;
+        }
+        const infos = await upstream.gdata(pairs.map((pair) => [pair.gid, pair.token]));
+        const items = infos.filter((info) => info.error === undefined).map(toSummary);
+        const result = {
+            items,
+            page,
+            limit,
+            // 上游不返回总数，取满一页即认为可能还有下一页
+            hasNext: pairs.length >= limit,
+        };
+        rememberSearch(query, result);
+        return result;
+    }
+    function currentSite() {
+        return activeAccount(ctx.auth.get())?.site ?? ctx.user.get().preferredSite;
+    }
+    function pageOptions(extra = {}) {
+        const auth = upstream.callOptions();
+        return { ...(auth ?? {}), site: extra.site ?? auth?.site ?? currentSite() };
+    }
+    async function loadGalleryPage(gid, token, thumbPage = 0, signal) {
+        const key = `${gid}:${token}:${thumbPage}`;
+        const hit = pageCache.get(key);
+        if (hit !== undefined && Date.now() - hit.at < cacheTtlMs) {
+            return hit.page;
+        }
+        const response = await callApi({
+            url: galleryUrl(currentSite(), gid, token, thumbPage),
+            ...pageOptions(),
+            ...(signal === undefined ? {} : { signal }),
+        });
+        if (!isUsablePage(response.status)) {
+            throw new Error(`画廊页返回 HTTP ${response.status}`);
+        }
+        const parsed = parseGalleryPage(response.text, gid);
+        if (parsed.title === "" && parsed.previewPages.length === 0) {
+            throw new Error("画廊页解析为空，页面结构可能已变更");
+        }
+        pageCache.set(key, { at: Date.now(), page: parsed });
+        if (pageCache.size > cacheSize) {
+            const oldest = pageCache.keys().next().value;
+            if (oldest !== undefined) {
+                pageCache.delete(oldest);
+            }
+        }
+        return parsed;
+    }
+    async function infoOf(gid, token) {
+        const infos = await upstream.gdata([[gid, token]]);
+        const info = infos[0];
+        if (info === undefined) {
+            throw new Error("gdata 未返回该画廊");
+        }
+        if (info.error !== undefined) {
+            throw new Error(`gdata 拒绝：${info.error}`);
+        }
+        return info;
+    }
+    /** 解析某一页的图片地址。第 1 页（详情页封面）由详情缓存包住，其余页直接调用 */
+    async function loadImagePage(gid, token, page, pageToken) {
+        let resolved = pageToken;
+        if (resolved === undefined) {
+            const thumbPage = Math.floor((Math.max(1, page) - 1) / THUMBS_PER_PAGE);
+            const parsed = await loadGalleryPage(gid, token, thumbPage);
+            resolved = parsed.pageTokens.get(page);
+        }
+        if (resolved === undefined) {
+            throw new Error(`未找到第 ${page} 页的图片页 token`);
+        }
+        const response = await callApi({
+            url: imagePageUrl(currentSite(), gid, page, resolved),
+            ...pageOptions(),
+        });
+        if (!isUsablePage(response.status)) {
+            throw new Error(`图片页返回 HTTP ${response.status}`);
+        }
+        const parsed = parseImagePage(response.text, gid);
+        if (parsed.showkey === null) {
+            throw new Error("图片页未取到 showkey");
+        }
+        const result = await upstream.showpage({
+            gid,
+            page,
+            imgkey: resolved,
+            showkey: parsed.showkey,
+        });
+        return {
+            page,
+            pageToken: resolved,
+            imageUrl: result.imageUrl,
+            originalImageUrl: result.originalImageUrl,
+            skipHathKey: result.skipHathKey,
+            // 上游不再返回尺寸，保留字段
+            width: null,
+            height: null,
+            nextPageToken: parsed.nextToken,
+        };
+    }
+    return {
+        search: runSearch,
+        async cachedSearch() {
+            const hit = await searchCache.read();
+            if (hit !== null) {
+                return hit;
+            }
+            if (warming === null) {
+                return null;
+            }
+            // 预热正在进行：等待它结束，界面不必自己再发起一次同样的检索。
+            // 但只等待 WARMUP_WAIT_MS，预热卡住（例如上游连不上）时界面不会一直等下去
+            await Promise.race([warming, delay(WARMUP_WAIT_MS)]);
+            return searchCache.read();
+        },
+        async warmSearch() {
+            if (warming !== null) {
+                return warming;
+            }
+            warming = (async () => {
+                try {
+                    await runSearch({ page: 1, limit: SEARCH_PAGE_LIMIT });
+                }
+                catch (error) {
+                    options.logger?.("warn", `启动预热检索失败：${error instanceof Error ? error.message : String(error)}`);
+                }
+            })();
+            return warming;
+        },
+        async summaryOf(gid, token, signal) {
+            const infos = await upstream.gdata([[gid, token]], {
+                ...(signal === undefined ? {} : { signal }),
+            });
+            const info = infos[0];
+            if (info === undefined || info.error !== undefined) {
+                throw new Error(`画廊信息读取失败：#${gid}`);
+            }
+            return toSummary(info);
+        },
+        async summariesOf(pairs, signal) {
+            if (pairs.length === 0) {
+                return [];
+            }
+            const infos = await upstream.gdata(pairs.map(([gid, token]) => [gid, token]), signal === undefined ? {} : { signal });
+            return infos.filter((info) => info.error === undefined).map(toSummary);
+        },
+        detail(gid, token, detailOptions) {
+            return detailCache.detail(gid, token, async () => {
+                // 内存未命中时读取落盘副本，fresh 的调用方不经过这里
+                const stored = options.store === undefined ? null : await options.store.get(gid, token);
+                if (stored !== null) {
+                    return stored.detail;
+                }
+                const [info, parsed] = await Promise.all([
+                    infoOf(gid, token),
+                    loadGalleryPage(gid, token),
+                ]);
+                const detail = toDetail(info, parsed);
+                // 落盘，重启后同一画廊可以立即打开
+                await options.store?.put(gid, token, detail);
+                return detail;
+            }, detailOptions?.fresh === true);
+        },
+        async newer(gid, token) {
+            const store = options.store;
+            const stored = store === undefined ? null : await store.get(gid, token);
+            if (stored !== null && stored.newer !== null) {
+                return { newer: stored.newer, checkedAt: stored.checkedAt };
+            }
+            const checkedAt = stored?.checkedAt ?? null;
+            if (checkedAt !== null && Date.now() / 1000 - checkedAt < RECHECK_NEWER_SECONDS) {
+                return { newer: null, checkedAt };
+            }
+            const info = await infoOf(gid, token);
+            const newer = relationOfNewer(info, gid, token);
+            await store?.saveCheck(gid, token, newer);
+            return { newer, checkedAt: Math.floor(Date.now() / 1000) };
+        },
+        imagePage(gid, token, page, pageToken, pageOptions) {
+            // 第 1 页即详情页封面，因此纳入缓存（有效期 10 分钟）；其余页地址过期风险更大，直接透传
+            if (page !== 1 || pageToken !== undefined) {
+                return loadImagePage(gid, token, page, pageToken);
+            }
+            return detailCache.cover(gid, token, () => loadImagePage(gid, token, page, pageToken), pageOptions?.fresh === true);
+        },
+        async torrents(gid, token) {
+            const info = await infoOf(gid, token);
+            const site = currentSite();
+            return (info.torrents ?? []).map((torrent) => ({
+                hash: torrent.hash,
+                name: torrent.name,
+                // 单条种子的直链需要登录，此处给列表页地址
+                url: torrentsUrl(site, gid, token),
+                addedAt: Number(torrent.added),
+                sizeBytes: Number(torrent.fsize),
+            }));
+        },
+        previews(gid, token, index, signal, previewOptions) {
+            const target = Math.max(0, index);
+            return detailCache.previews(gid, token, target, async () => {
+                const parsed = await loadGalleryPage(gid, token, target, signal);
+                const previews = parsed.previewPages.map((page) => ({
+                    ...page,
+                }));
+                return {
+                    index: target,
+                    previews,
+                    hasMore: previews.length >= THUMBS_PER_PAGE,
+                };
+            }, previewOptions?.fresh === true);
+        },
+        detailCacheStats() {
+            return detailCache.stats();
+        },
+        clearDetailCache() {
+            return detailCache.clear();
+        },
+        async archives(gid, token) {
+            if (!upstream.hasAccount()) {
+                throw new LoginRequiredError("归档列表需要登录后查看");
+            }
+            const parsed = await fetchArchiveCatalog(gid, token, {
+                site: currentSite(),
+                ...(pageOptions().cookies === undefined ? {} : { cookies: pageOptions().cookies }),
+            });
+            const options_ = parsed.options.map((option) => ({
+                resolution: option.resolution,
+                label: option.label,
+                sizeText: option.sizeText,
+                costText: option.costText,
+                viaHath: option.viaHath,
+            }));
+            const catalog = { options: options_, fundsText: parsed.fundsText };
+            return catalog;
+        },
+    };
+}
+const CATEGORY_SET = new Set(GALLERY_CATEGORIES);
+const LANGUAGE_SET = new Set(GALLERY_LANGUAGES);
+/** 上游给的是字符串，取不到或不在枚举内时归入 Misc */
+function toCategory(value) {
+    const raw = (value ?? "").trim();
+    return (CATEGORY_SET.has(raw) ? raw : "Misc");
+}
+function toLanguage(tags) {
+    const found = (tags ?? []).find((tag) => tag.startsWith("language:"));
+    if (found === undefined) {
+        return null;
+    }
+    const value = found.slice("language:".length);
+    return LANGUAGE_SET.has(value) ? value : null;
+}
+/** 上游把数字当字符串返回，这里统一转换 */
+function toNumber(value) {
+    if (typeof value === "number") {
+        return Number.isFinite(value) ? value : 0;
+    }
+    const parsed = Number(value ?? "");
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+function toSummary(info) {
+    return {
+        gid: info.gid,
+        token: info.token ?? "",
+        title: info.title ?? "",
+        titleJpn: info.title_jpn ?? "",
+        category: toCategory(info.category),
+        thumbUrl: info.thumb ?? "",
+        uploader: info.uploader ?? "",
+        postedAt: toNumber(info.posted),
+        pageCount: toNumber(info.filecount),
+        sizeBytes: info.filesize ?? 0,
+        rating: toNumber(info.rating),
+        torrentCount: toNumber(info.torrentcount),
+        expunged: info.expunged === true,
+        tags: info.tags ?? [],
+        language: toLanguage(info.tags),
+        // 收藏状态需要登录后另查
+        favorite: null,
+    };
+}
+/** 标签组优先用页面解析结果（含显示名），缺失时退回 gdata 的带前缀标签 */
+function toTagGroups(info, parsed) {
+    if (parsed.tagGroups.length > 0) {
+        return parsed.tagGroups.map((group) => ({ namespace: group.namespace, tags: group.tags }));
+    }
+    const grouped = new Map();
+    for (const tag of info.tags ?? []) {
+        const separator = tag.indexOf(":");
+        if (separator === -1) {
+            continue;
+        }
+        const namespace = tag.slice(0, separator);
+        const bucket = grouped.get(namespace) ?? [];
+        bucket.push(tag.slice(separator + 1));
+        grouped.set(namespace, bucket);
+    }
+    return [...grouped].map(([namespace, tags]) => ({ namespace, tags }));
+}
+function toRelation(gid, key) {
+    const parsed = Number(gid ?? "");
+    return Number.isInteger(parsed) && parsed > 0 && key !== undefined
+        ? { gid: parsed, token: key }
+        : null;
+}
+/*
+ * gdata 返回的 current_* 与自身不同，表示上游存在更新版本。
+ * 未返回、与自身相同或字段不完整时，按已是最新处理。
+ */
+function relationOfNewer(info, gid, token) {
+    const targetGid = Number(info.current_gid ?? "");
+    const targetToken = info.current_key ?? "";
+    if (!Number.isFinite(targetGid) || targetGid <= 0 || targetToken === "") {
+        return null;
+    }
+    if (targetGid === gid && targetToken === token) {
+        return null;
+    }
+    return { gid: targetGid, token: targetToken };
+}
+function toDetail(info, parsed) {
+    const summary = toSummary(info);
+    return {
+        ...summary,
+        title: parsed.title === "" ? summary.title : parsed.title,
+        titleJpn: parsed.titleJpn === "" ? summary.titleJpn : parsed.titleJpn,
+        category: parsed.category === "" ? summary.category : toCategory(parsed.category),
+        tagGroups: toTagGroups(info, parsed),
+        // 上游页面不直接给可见性文本，以 expunged 推导
+        visibility: info.expunged === true ? "Deleted" : "Visible",
+        sizeText: parsed.sizeText === "" ? `${summary.sizeBytes} B` : parsed.sizeText,
+        rating: parsed.rating ?? summary.rating,
+        ratingCount: parsed.ratingCount,
+        favoriteCount: parsed.favoriteCount,
+        previewPages: parsed.previewPages.map((page) => ({ ...page })),
+        // 评论区结构复杂，暂不解析
+        comments: [],
+        archiveAvailable: parsed.archiveAvailable,
+        parent: toRelation(info.parent_gid, info.parent_key),
+        first: toRelation(info.first_gid, info.first_key),
+        current: toRelation(info.current_gid, info.current_key),
+    };
+}