ehbrowser 1.0.0

package/dist/services/local-library.js

@@ -0,0 +1,471 @@
+/*
+ * 本地库：下载落盘的画廊目录、目录内的 .ehbrowser 元数据、按页取图。
+ *
+ * 落盘形状为 <下载根>/<分辨率>@<画廊名>/，图片按页序重命名为 0001.jpg 这样的文件名。
+ * 元数据只记条数与读到第几页，避免把上千个文件名写进一个小文件。
+ *
+ * 目录本身是唯一事实来源，手动修改目录内容或删除目录内文件都能如实反映出来。
+ */
+import { readdir, readFile, rm, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { writeFileAtomic } from "../config/atomic.js";
+import { extractEntry, isDirectory, readZipEntries } from "./zip.js";
+/** 元数据文件名，与规格中的命名一致 */
+export const META_FILENAME = ".ehbrowser";
+const META_SCHEMA_VERSION = 1;
+/** 可识别的图片后缀。解压时只取这些后缀，取图时按同样规则匹配 */
+const IMAGE_EXTENSIONS = new Set(["jpg", "jpeg", "png", "gif", "webp", "bmp", "avif"]);
+/** 页序文件名：0001.jpg */
+const PAGE_FILE = /^(\d{1,6})\.([A-Za-z0-9]+)$/;
+/**
+ * 下载中的标记。写在画廊目录里，记录当前下载的是哪一版。
+ * 逐页下载被打断后重来时用它判断目录里的页文件是否属于同一本：是则续下，否则清空。
+ */
+export const DOWNLOAD_STATE_FILENAME = ".ehbrowser.downloading";
+/** 元数据中会进入接口的字段。schemaVersion 与详情快照不出接口 */
+export function toLocalGallery(meta) {
+    return {
+        gid: meta.gid,
+        token: meta.token,
+        title: meta.title,
+        resolution: meta.resolution,
+        folder: meta.folder,
+        path: meta.path,
+        pageCount: meta.pageCount,
+        files: meta.files,
+        sizeBytes: meta.sizeBytes,
+        downloadedAt: meta.downloadedAt,
+        lastReadPage: meta.lastReadPage,
+        lastReadAt: meta.lastReadAt,
+        archive: meta.archive,
+        summary: meta.summary,
+    };
+}
+/**
+ * 画廊名清洗：各平台非法字符取并集，并去掉控制字符与首尾的空格和点号。
+ * Windows 不允许名称以点或空格结尾，这里统一处理；长度截断到 100 字，避免路径过长。
+ */
+export function safeGalleryName(title) {
+    const cleaned = title
+        .replace(/[\u0000-\u001f<>:"/\\|?*]/g, " ")
+        .replace(/\s+/g, " ")
+        .trim()
+        .replace(/[. ]+$/, "");
+    const capped = cleaned.slice(0, 100).trim();
+    return capped === "" ? "untitled" : capped;
+}
+/** 画廊文件夹名：<分辨率>@<清洗后的画廊名> */
+export function libraryFolderName(resolution, title) {
+    return `${safeGalleryName(resolution)}@${safeGalleryName(title)}`;
+}
+function isSummary(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const item = value;
+    return typeof item.gid === "number" && typeof item.title === "string";
+}
+/** 详情快照比列表项多了标签分组，缺少该字段即不是一份可用的详情 */
+function isDetail(value) {
+    return isSummary(value) && Array.isArray(value.tagGroups);
+}
+/**
+ * 从详情快照里取出列表项需要的字段。
+ * 只有详情、没有列表项快照时用它兜底，避免把整份详情放进列表响应。
+ */
+export function summaryOfDetail(detail) {
+    return {
+        gid: detail.gid,
+        token: detail.token,
+        title: detail.title,
+        titleJpn: detail.titleJpn,
+        category: detail.category,
+        thumbUrl: detail.thumbUrl,
+        uploader: detail.uploader,
+        postedAt: detail.postedAt,
+        pageCount: detail.pageCount,
+        sizeBytes: detail.sizeBytes,
+        rating: detail.rating,
+        torrentCount: detail.torrentCount,
+        expunged: detail.expunged,
+        tags: detail.tags,
+        language: detail.language,
+        favorite: detail.favorite,
+    };
+}
+/** 读入的元数据按陌生数据校验，文件损坏时仅将该目录视为不是本地画廊 */
+function parseMeta(text, folder) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    if (typeof parsed !== "object" || parsed === null) {
+        return null;
+    }
+    const raw = parsed;
+    const gid = Number(raw["gid"]);
+    const resolution = typeof raw["resolution"] === "string" ? raw["resolution"] : "";
+    if (!Number.isFinite(gid) || resolution === "") {
+        return null;
+    }
+    const number = (key) => {
+        const value = Number(raw[key]);
+        return Number.isFinite(value) ? value : 0;
+    };
+    const detail = isDetail(raw["detail"]) ? raw["detail"] : null;
+    return {
+        schemaVersion: number("schemaVersion") || META_SCHEMA_VERSION,
+        gid,
+        token: typeof raw["token"] === "string" ? raw["token"] : "",
+        title: typeof raw["title"] === "string" ? raw["title"] : folder,
+        resolution,
+        pageCount: number("pageCount"),
+        files: number("files"),
+        sizeBytes: number("sizeBytes"),
+        downloadedAt: number("downloadedAt"),
+        lastReadPage: number("lastReadPage"),
+        lastReadAt: raw["lastReadAt"] === null ? null : number("lastReadAt"),
+        archive: typeof raw["archive"] === "string" ? raw["archive"] : null,
+        summary: isSummary(raw["summary"])
+            ? raw["summary"]
+            : detail === null
+                ? null
+                : summaryOfDetail(detail),
+        detail,
+        folder,
+        path: "",
+    };
+}
+export function createLocalLibrary(ctx, options) {
+    /** 页序索引：文件夹到「页号 -> 文件名」的映射。取图每页都要用到，因此缓存 */
+    const pageIndex = new Map();
+    /** 目录扫描结果，避免一次页面渲染中反复读盘 */
+    let scannedAt = 0;
+    let scanned = null;
+    const SCAN_TTL_MS = 2000;
+    function root() {
+        const configured = ctx.user.get().download.directory;
+        return configured === "" ? options.fallbackDirectory(ctx) : configured;
+    }
+    async function readMeta(folder) {
+        const path = join(root(), folder);
+        let text;
+        try {
+            text = await readFile(join(path, META_FILENAME), "utf8");
+        }
+        catch {
+            // 没有元数据的目录不是本地画廊：可能正在下载，也可能是用户自行放入的内容
+            return null;
+        }
+        const meta = parseMeta(text, folder);
+        if (meta === null) {
+            return null;
+        }
+        return { ...meta, path };
+    }
+    async function scan() {
+        if (scanned !== null && Date.now() - scannedAt < SCAN_TTL_MS) {
+            return scanned;
+        }
+        const directory = root();
+        let entries;
+        try {
+            entries = await readdir(directory, { withFileTypes: true });
+        }
+        catch {
+            // 目录尚不存在，本地库为空
+            scanned = [];
+            scannedAt = Date.now();
+            return scanned;
+        }
+        const found = [];
+        for (const entry of entries) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            const meta = await readMeta(entry.name);
+            if (meta !== null) {
+                found.push(meta);
+            }
+        }
+        found.sort((a, b) => b.downloadedAt - a.downloadedAt);
+        scanned = found;
+        scannedAt = Date.now();
+        return found;
+    }
+    /**
+     * 页号到文件名的映射。文件名即解压时按页序写下的 0001.jpg。
+     * 按页号取值而不是按排序后的下标：中间缺少某个页号时返回 null，
+     * 不会把后一页当成前一页。
+     */
+    async function pagesOf(folder) {
+        const path = join(root(), folder);
+        const cached = pageIndex.get(path);
+        if (cached !== undefined) {
+            return cached;
+        }
+        let names;
+        try {
+            names = await readdir(path);
+        }
+        catch {
+            const empty = new Map();
+            pageIndex.set(path, empty);
+            return empty;
+        }
+        const result = new Map();
+        for (const name of names) {
+            const matched = PAGE_FILE.exec(name);
+            if (matched === null) {
+                continue;
+            }
+            if (!IMAGE_EXTENSIONS.has(matched[2].toLowerCase())) {
+                continue;
+            }
+            const page = Number(matched[1]);
+            if (!result.has(page)) {
+                result.set(page, name);
+            }
+        }
+        pageIndex.set(path, result);
+        return result;
+    }
+    /**
+     * 目录里已有的页，按页号排序（页号与字节数）。
+     * 不经过 pagesOf 的页索引缓存：下载进行中目录持续变化，缓存中的结果可能是刚建目录时的空快照，
+     * 用它判断续传会把已经下载完成的页当成不存在，从而重复下载。
+     */
+    async function existingPages(folder) {
+        const path = join(root(), folder);
+        let names;
+        try {
+            names = await readdir(path);
+        }
+        catch {
+            return [];
+        }
+        const result = [];
+        for (const name of names) {
+            const matched = PAGE_FILE.exec(name);
+            if (matched === null || !IMAGE_EXTENSIONS.has(matched[2].toLowerCase())) {
+                continue;
+            }
+            let bytes = 0;
+            try {
+                bytes = (await stat(join(path, name))).size;
+            }
+            catch {
+                // 文件在此期间被删除等情况，按不存在处理
+                continue;
+            }
+            if (bytes > 0) {
+                result.push({ page: Number(matched[1]), bytes });
+            }
+        }
+        result.sort((a, b) => a.page - b.page);
+        return result;
+    }
+    async function downloadState(folder) {
+        let text;
+        try {
+            text = await readFile(join(root(), folder, DOWNLOAD_STATE_FILENAME), "utf8");
+        }
+        catch {
+            return null;
+        }
+        try {
+            const raw = JSON.parse(text);
+            const gid = Number(raw["gid"]);
+            const resolution = typeof raw["resolution"] === "string" ? raw["resolution"] : "";
+            if (!Number.isFinite(gid) || resolution === "") {
+                return null;
+            }
+            return {
+                gid,
+                token: typeof raw["token"] === "string" ? raw["token"] : "",
+                resolution,
+                pageCount: Number(raw["pageCount"]) || 0,
+                startedAt: Number(raw["startedAt"]) || 0,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    async function beginDownload(folder, state) {
+        const path = join(root(), folder);
+        await writeFileAtomic(join(path, DOWNLOAD_STATE_FILENAME), `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
+    }
+    async function endDownload(folder) {
+        await rm(join(root(), folder, DOWNLOAD_STATE_FILENAME), { force: true });
+    }
+    /** 内部使用：包含快照在内的整份元数据。写回时用它保留 detail 这类不经过接口的字段 */
+    async function findStored(gid, resolution) {
+        const all = await scan();
+        return all.find((item) => item.gid === gid && item.resolution === resolution) ?? null;
+    }
+    async function find(gid, resolution) {
+        const stored = await findStored(gid, resolution);
+        return stored === null ? null : toLocalGallery(stored);
+    }
+    /**
+     * 落盘的详情快照。scan 已按下载时间从新到旧排序，取第一条命中的即为最近那一份。
+     * token 只在两边都非空时比对：手动改过目录的元数据不应因此被当成另一本。
+     */
+    async function storedDetail(gid, token) {
+        const all = await scan();
+        const hit = all.find((item) => item.gid === gid &&
+            item.detail !== null &&
+            (token === "" || item.token === "" || item.token === token));
+        return hit?.detail ?? null;
+    }
+    async function saveDetail(gid, detail) {
+        const targets = (await scan()).filter((item) => item.gid === gid);
+        let written = 0;
+        for (const target of targets) {
+            // 先读盘上现状再写：下载进行中可能刚改过进度，不能用扫描缓存中的那份覆盖回盘
+            const current = await readMeta(target.folder);
+            if (current === null) {
+                continue;
+            }
+            await write({
+                ...current,
+                detail,
+                summary: current.summary ?? summaryOfDetail(detail),
+            }, target.folder);
+            written += 1;
+        }
+        return written;
+    }
+    function invalidate() {
+        pageIndex.clear();
+        scanned = null;
+        scannedAt = 0;
+    }
+    async function write(meta, folder) {
+        const path = join(root(), folder);
+        await writeFileAtomic(join(path, META_FILENAME), `${JSON.stringify(meta, null, 2)}\n`, {
+            mode: 0o600,
+        });
+        // 只写元数据不改变目录成员，页索引丢弃即可
+        pageIndex.delete(path);
+        /*
+         * 扫描缓存中的那份是写入之前的，就地替换为新的。
+         * 不这么做的话，写入后 2 秒内再读（例如刚写完阅读进度、紧接着又执行一次）拿到的仍是旧值，
+         * 元数据会被旧值覆盖回去。
+         */
+        if (scanned !== null) {
+            const entry = { ...meta, folder, path };
+            const at = scanned.findIndex((item) => item.folder === folder);
+            scanned =
+                at === -1
+                    ? [...scanned, entry]
+                    : scanned.map((item, index) => (index === at ? entry : item));
+            scannedAt = Date.now();
+        }
+    }
+    /** 清除目录里的页文件（只删按页序命名的文件，元数据与归档均保留） */
+    async function clearPages(folder) {
+        const target = join(root(), folder);
+        for (const name of await readdir(target).catch(() => [])) {
+            if (PAGE_FILE.test(name)) {
+                await rm(join(target, name), { force: true });
+            }
+        }
+        pageIndex.delete(target);
+    }
+    /**
+     * 解压归档。只取图片，按归档中的顺序重命名为 0001.jpg 这样的页序文件名。
+     * 顺序即页序：上游打包时即为该次序，重命名后取第几页就是取第几个文件。
+     */
+    async function extractArchive(archivePath, folder) {
+        const entries = await readZipEntries(archivePath);
+        const target = join(root(), folder);
+        // 重新下载同一个画廊时先清除旧的页文件，避免上一版多出的页留在目录里
+        for (const name of await readdir(target).catch(() => [])) {
+            if (PAGE_FILE.test(name)) {
+                await rm(join(target, name), { force: true });
+            }
+        }
+        let page = 0;
+        for (const entry of entries) {
+            if (isDirectory(entry)) {
+                continue;
+            }
+            const name = entry.name;
+            // 资源叉与隐藏文件不属于内容
+            if (name.startsWith("__MACOSX/") ||
+                name.split("/").some((part) => part.startsWith("."))) {
+                continue;
+            }
+            const dot = name.lastIndexOf(".");
+            if (dot === -1) {
+                continue;
+            }
+            const extension = name.slice(dot + 1).toLowerCase();
+            if (!IMAGE_EXTENSIONS.has(extension)) {
+                continue;
+            }
+            page += 1;
+            const file = join(target, `${String(page).padStart(4, "0")}.${extension}`);
+            await extractEntry(archivePath, entry, file);
+        }
+        if (page === 0) {
+            throw new Error("归档里没有可用的图片");
+        }
+        invalidate();
+        return page;
+    }
+    return {
+        root,
+        async list() {
+            return (await scan()).map(toLocalGallery);
+        },
+        find,
+        storedDetail,
+        saveDetail,
+        async imagePath(gid, resolution, page) {
+            const gallery = await findStored(gid, resolution);
+            if (gallery === null || page < 1) {
+                return null;
+            }
+            const pages = await pagesOf(gallery.folder);
+            const name = pages.get(page);
+            return name === undefined ? null : join(gallery.path, name);
+        },
+        async saveProgress(gid, resolution, page) {
+            const gallery = await findStored(gid, resolution);
+            if (gallery === null) {
+                return null;
+            }
+            // 整份元数据一并写回：详情快照这类不经过接口的字段不能因为写进度而丢失
+            const next = {
+                ...gallery,
+                lastReadPage: Math.max(0, Math.floor(page)),
+                lastReadAt: Math.floor(Date.now() / 1000),
+            };
+            await write(next, gallery.folder);
+            return toLocalGallery({ ...next, folder: gallery.folder, path: gallery.path });
+        },
+        write,
+        existingPages,
+        downloadState,
+        beginDownload,
+        endDownload,
+        clearPages,
+        extractArchive,
+        async remove(gid, resolution) {
+            const gallery = await findStored(gid, resolution);
+            if (gallery === null) {
+                return false;
+            }
+            await rm(gallery.path, { recursive: true, force: true });
+            invalidate();
+            return true;
+        },
+        invalidate,
+    };
+}

package/dist/services/log-service.js

@@ -0,0 +1,139 @@
+/*
+ * 日志
+ * 各服务通过这里输出：既按原来的格式打到控制台，也按天追加到日志目录下的文件，
+ * 还会经 SSE 的 log.appended 推给界面，服务页能直接看到。
+ * 目录默认 ~/ehbrowser/logs（便携模式落在 <数据目录>/logs），可在设置 > 日志里改；
+ * 每次写入都重新解析目录，因此改完立即生效，不必重启。
+ * 写文件是排队异步做的，失败不影响调用方；落盘格式为
+ * 「2026-09-21 00:35:12 [info] [download] 消息」，一行一条，同一天共用一个文件。
+ */
+import { appendFile, mkdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { isAbsolute, join, normalize } from "node:path";
+/** 内存里保留的条数。界面初次打开时先铺一份，够用即可 */
+const RECENT_LIMIT = 500;
+const FILE_PREFIX = "ehbrowser";
+const FILE_SUFFIX = ".log";
+/** 默认日志目录：便携模式跟着数据目录走，否则就是 ~/ehbrowser/logs */
+export function defaultLogDirectory(ctx) {
+    if (ctx.paths.sources.dataDir === "portable-home") {
+        return join(ctx.paths.dataDir, "logs");
+    }
+    return join(homedir(), "ehbrowser", "logs");
+}
+/** 展开 ~ 与 ~/…，相对路径按当前工作目录补全 */
+function absolute(input) {
+    const trimmed = input.trim();
+    const expanded = trimmed === "~"
+        ? homedir()
+        : trimmed.startsWith("~/") || trimmed.startsWith("~\\")
+            ? join(homedir(), trimmed.slice(2))
+            : trimmed;
+    return normalize(isAbsolute(expanded) ? expanded : join(process.cwd(), expanded));
+}
+function pad(value) {
+    return String(value).padStart(2, "0");
+}
+/** 本地时间的 YYYY-MM-DD，用作文件名 */
+function dayOf(at) {
+    const value = new Date(at * 1000);
+    return `${value.getFullYear()}-${pad(value.getMonth() + 1)}-${pad(value.getDate())}`;
+}
+/** 本地时间的 YYYY-MM-DD HH:mm:ss，用作行首时间戳 */
+function stampOf(at) {
+    const value = new Date(at * 1000);
+    return `${dayOf(at)} ${pad(value.getHours())}:${pad(value.getMinutes())}:${pad(value.getSeconds())}`;
+}
+function lineOf(entry) {
+    const tag = entry.tag === "" ? "" : ` [${entry.tag}]`;
+    return `${stampOf(entry.at)} [${entry.level}]${tag} ${entry.message}\n`;
+}
+/** 控制台输出的格式：与文件里的区别是省去日期，来源前缀与原来的写法一致 */
+function consoleOf(entry, keepLevel) {
+    const tag = entry.tag === "" ? "" : `[${entry.tag}] `;
+    return keepLevel ? `${tag}${entry.level}: ${entry.message}` : entry.message;
+}
+export function createLogService(ctx, options) {
+    const listeners = new Set();
+    /** 环形缓冲，新的在后 */
+    const recent = [];
+    /** 写文件的串行队列：不 await，但保证顺序，退出时 flush 等它 */
+    let queue = Promise.resolve();
+    /** 目录创建失败等只报一次，避免日志重复输出 */
+    let reported = false;
+    function defaultDirectory() {
+        return options.fallbackDirectory(ctx);
+    }
+    function directoryOf() {
+        const configured = ctx.user.get().log.directory;
+        return configured.trim() === "" ? defaultDirectory() : absolute(configured);
+    }
+    function fileOf(at) {
+        return join(directoryOf(), `${FILE_PREFIX}-${dayOf(at)}${FILE_SUFFIX}`);
+    }
+    /** 落盘。失败只报一次，日志写入失败不影响服务运行 */
+    function write(entry) {
+        if (!ctx.user.get().log.enabled) {
+            return;
+        }
+        const path = fileOf(entry.at);
+        const text = lineOf(entry);
+        queue = queue
+            .then(async () => {
+            await mkdir(directoryOf(), { recursive: true });
+            await appendFile(path, text, "utf8");
+        })
+            .catch((error) => {
+            if (!reported) {
+                reported = true;
+                console.error(`[log] error: 日志写入失败（${directoryOf()}）：${error instanceof Error ? error.message : String(error)}`);
+            }
+        });
+    }
+    /** 记一条 */
+    function append(level, message, tag = "") {
+        const entry = { level, tag, message, at: Math.floor(Date.now() / 1000) };
+        recent.push(entry);
+        if (recent.length > RECENT_LIMIT) {
+            recent.splice(0, recent.length - RECENT_LIMIT);
+        }
+        // tag 为空的是入口自己的消息（启动横幅之类），控制台上保持原样不加级别前缀
+        console.log(consoleOf(entry, tag !== ""));
+        write(entry);
+        for (const listener of listeners) {
+            try {
+                listener(entry);
+            }
+            catch {
+                // 单个订阅者异常不影响其余订阅者
+            }
+        }
+    }
+    return {
+        logger(tag) {
+            return (level, message) => {
+                append(level, message, tag);
+            };
+        },
+        append,
+        state(limit) {
+            const count = limit === undefined || limit <= 0 ? 100 : Math.min(limit, RECENT_LIMIT);
+            return {
+                enabled: ctx.user.get().log.enabled,
+                directory: directoryOf(),
+                file: `${FILE_PREFIX}-${dayOf(Math.floor(Date.now() / 1000))}${FILE_SUFFIX}`,
+                defaultDirectory: defaultDirectory(),
+                entries: recent.slice(-count),
+            };
+        },
+        onChange(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        async flush() {
+            await queue;
+        },
+    };
+}

package/dist/services/playlist-service.js

@@ -0,0 +1,85 @@
+/*
+ * 用户播放列表：加入、排序、进度与当前项，全部落在 SQLite 里，重启不丢。
+ * 这一份与「画廊播放列表」不同：它装的是画廊，手动加入，可以跨画廊连续播。
+ */
+import { playlistKeyOf } from "../api/index.js";
+/** meta 表里记当前播放项用哪把键 */
+const CURRENT_KEY_META = "playlist.current";
+function toItem(row) {
+    return {
+        key: row.key,
+        gid: row.gid,
+        token: row.token,
+        title: row.title,
+        thumbUrl: row.thumb_url,
+        pageCount: row.page_count,
+        resolution: row.resolution === null || row.resolution === "" ? null : row.resolution,
+        page: row.page,
+        bytesPerPage: row.bytes_per_page,
+        addedAt: row.added_at,
+    };
+}
+export function createPlaylistService(ctx) {
+    const db = ctx.db.raw;
+    function rows() {
+        return db
+            .prepare("select * from playlist_items order by position asc")
+            .all();
+    }
+    function snapshot() {
+        return {
+            items: rows().map(toItem),
+            currentKey: ctx.db.getMeta(CURRENT_KEY_META),
+        };
+    }
+    function touch(key) {
+        db.prepare("update playlist_items set updated_at = ? where key = ?").run(Math.floor(Date.now() / 1000), key);
+    }
+    return {
+        snapshot,
+        add(input) {
+            const key = playlistKeyOf(input.gid, input.resolution);
+            const now = Math.floor(Date.now() / 1000);
+            const existing = db.prepare("select key from playlist_items where key = ?").get(key);
+            if (existing === undefined) {
+                const next = db
+                    .prepare("select coalesce(max(position), 0) + 1 as position from playlist_items")
+                    .get();
+                db.prepare(`insert into playlist_items
+                     (key, position, gid, token, title, thumb_url, page_count, resolution, page,
+                      bytes_per_page, added_at, updated_at)
+                     values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(key, next.position, input.gid, input.token, input.title, input.thumbUrl, input.pageCount, input.resolution ?? null, Math.max(1, input.page ?? 1), Math.max(0, input.bytesPerPage ?? 0), now, now);
+            }
+            else {
+                // 已在列表里：只更新快照字段，保留既有进度与顺序
+                db.prepare(`update playlist_items set title = ?, thumb_url = ?, page_count = ?,
+                     resolution = ?, token = ?, updated_at = ? where key = ?`).run(input.title, input.thumbUrl, input.pageCount, input.resolution ?? null, input.token, now, key);
+            }
+            return snapshot();
+        },
+        play(key) {
+            const found = db.prepare("select key from playlist_items where key = ?").get(key);
+            if (found !== undefined) {
+                ctx.db.setMeta(CURRENT_KEY_META, key);
+                touch(key);
+            }
+            return snapshot();
+        },
+        progress(key, page) {
+            db.prepare("update playlist_items set page = ?, updated_at = ? where key = ?").run(Math.max(1, Math.floor(page)), Math.floor(Date.now() / 1000), key);
+            return snapshot();
+        },
+        remove(key) {
+            db.prepare("delete from playlist_items where key = ?").run(key);
+            if (ctx.db.getMeta(CURRENT_KEY_META) === key) {
+                ctx.db.deleteMeta(CURRENT_KEY_META);
+            }
+            return snapshot();
+        },
+        clear() {
+            db.prepare("delete from playlist_items").run();
+            ctx.db.deleteMeta(CURRENT_KEY_META);
+            return snapshot();
+        },
+    };
+}