koishi-plugin-anime-schedule 1.1.1 → 1.1.2

package/lib/config.js

@@ -117,7 +117,7 @@ exports.Config = koishi_1.Schema.intersect([
                 .default('localized'),
             scoreTtlHours: koishi_1.Schema.number()
                 .min(1).step(1)
-                .description('评分缓存小时数')
+                .description('评分多久后台补取一次（小时），到期不阻塞构建')
                 .default(constants_1.DEFAULT_SCORE_TTL_HOURS),
             cacheTtlDays: koishi_1.Schema.number()
                 .min(1).step(1)

package/lib/constants.d.ts

@@ -36,8 +36,13 @@ export declare const BANGUMI_DATA_FALLBACK_URLS: string[];
 export declare const BANGUMI_DATA_FILE = "bangumi-data.json";
 /** bangumi-data 回退缓存的目录（相对于 ctx.baseDir），与本地化缓存放在一起 */
 export declare const DATA_DIR: string[];
-/** 插件版本与主页，请求 Bangumi 时用于自报身份 */
-export declare const PLUGIN_VERSION = "1.0.0";
+/**
+ * 插件版本与主页，请求 Bangumi 时用于自报身份。
+ *
+ * 版本号从 `package.json` 读：单独维护一份字面量必然会在发版时漏更新（它曾停在 1.0.0），
+ * 而 `package.json` 一定随包发布，读它不会失效。
+ */
+export declare const PLUGIN_VERSION: string;
 export declare const PLUGIN_HOMEPAGE = "https://github.com/YuzuharaYuka/koishi-plugin-anime-schedule";
 /**
  * 请求 Bangumi 时使用的 User-Agent。
@@ -75,6 +80,9 @@ export declare const LOCALIZE_CACHE_FILE = "localize-cache.json";
  *
  * 比标题封面的 cacheTtlDays 短得多：新番开播头几周评分天天在变，样本量从个位数
  * 涨到几百，用 30 天缓存会一直显示「只有十几个人投票」时的噪声值。
+ *
+ * 到期只触发后台补取（`Localizer.kickScoreRefresh()`），不阻塞构建：评分是一张表的
+ * 附属信息，为它把整张表推迟十几秒不划算。
  */
 export declare const DEFAULT_SCORE_TTL_HOURS = 24;
 /**
@@ -151,6 +159,16 @@ export declare const MAX_SUPERSAMPLE = 5;
  */
 export declare const DAILY_OFFSET_MIN = -7;
 export declare const DAILY_OFFSET_MAX = 7;
+/**
+ * 构建结果的复用窗口（毫秒）。
+ *
+ * 推送遍历频道时每个群都调一次构建，指令层也常被连着问同一张表。这些调用的差别只有
+ * 「已订阅」标记，其余部分（场次推算、AniList 状态、Bangumi 详情、封面地址）完全相同，
+ * 因此一份结果在窗口内可以重复用，订阅标记事后再按频道注入。
+ */
+export declare const BUILD_CACHE_TTL_MS: number;
+/** 构建结果同时留存几份（日/深夜/周/季 × 少量偏移），超出丢最早的一份 */
+export declare const BUILD_CACHE_MAX_ENTRIES = 16;
 /** 注册到 canvas 的字体族名，与 config.render.fontFamily 的默认值保持一致 */
 export declare const DEFAULT_FONT_FAMILY = "Anime Schedule Sans";
 /**

package/lib/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LOG_MESSAGES = exports.RESPONSES = exports.MESSAGES = exports.IMAGE_THEME = exports.IMAGE_LAYOUT = exports.DEFAULT_FONT_FAMILY = exports.DAILY_OFFSET_MAX = exports.DAILY_OFFSET_MIN = exports.MAX_SUPERSAMPLE = exports.DEFAULT_SUPERSAMPLE = exports.DEFAULT_JPEG_QUALITY = exports.BOLD_FONT_CANDIDATES = exports.FONT_CANDIDATES = exports.COVER_MEMORY_MAX_BYTES = exports.COVER_CACHE_MAX_FILES = exports.COVER_CACHE_TTL_MS = exports.COVER_CACHE_DIR = exports.COVER_MAX_BYTES = exports.COVER_TIMEOUT_MS = exports.COVER_CONCURRENCY = exports.LOCALIZE_TIMEOUT_SECONDS = exports.LOCALIZE_CONCURRENCY = exports.EPISODE_QUERY_LIMIT = exports.LOCALIZE_CACHE_MAX_ENTRIES = exports.LOCALIZE_CACHE_VERSION = exports.MIN_SCORE_VOTES = exports.DEFAULT_SCORE_TTL_HOURS = exports.LOCALIZE_CACHE_FILE = exports.LATE_NIGHT_END_HOUR = exports.IMAGE_LIST_TWO_COLUMN_AT = exports.IMAGE_MAX_CARDS = exports.DIGEST_LABELS = exports.PLUGIN_HOMEPAGE = exports.PLUGIN_VERSION = exports.DATA_DIR = exports.BANGUMI_DATA_FILE = exports.BANGUMI_DATA_FALLBACK_URLS = exports.ANILIST_COOLDOWN_MS = exports.ANILIST_MIN_INTERVAL_MS = exports.ANILIST_BATCH_SIZE = exports.ANILIST_API_URL = exports.BANGUMI_API_HOST = exports.PLUGIN_NAME = void 0;
+exports.LOG_MESSAGES = exports.RESPONSES = exports.MESSAGES = exports.IMAGE_THEME = exports.IMAGE_LAYOUT = exports.DEFAULT_FONT_FAMILY = exports.BUILD_CACHE_MAX_ENTRIES = exports.BUILD_CACHE_TTL_MS = exports.DAILY_OFFSET_MAX = exports.DAILY_OFFSET_MIN = exports.MAX_SUPERSAMPLE = exports.DEFAULT_SUPERSAMPLE = exports.DEFAULT_JPEG_QUALITY = exports.BOLD_FONT_CANDIDATES = exports.FONT_CANDIDATES = exports.COVER_MEMORY_MAX_BYTES = exports.COVER_CACHE_MAX_FILES = exports.COVER_CACHE_TTL_MS = exports.COVER_CACHE_DIR = exports.COVER_MAX_BYTES = exports.COVER_TIMEOUT_MS = exports.COVER_CONCURRENCY = exports.LOCALIZE_TIMEOUT_SECONDS = exports.LOCALIZE_CONCURRENCY = exports.EPISODE_QUERY_LIMIT = exports.LOCALIZE_CACHE_MAX_ENTRIES = exports.LOCALIZE_CACHE_VERSION = exports.MIN_SCORE_VOTES = exports.DEFAULT_SCORE_TTL_HOURS = exports.LOCALIZE_CACHE_FILE = exports.LATE_NIGHT_END_HOUR = exports.IMAGE_LIST_TWO_COLUMN_AT = exports.IMAGE_MAX_CARDS = exports.DIGEST_LABELS = exports.PLUGIN_HOMEPAGE = exports.PLUGIN_VERSION = exports.DATA_DIR = exports.BANGUMI_DATA_FILE = exports.BANGUMI_DATA_FALLBACK_URLS = exports.ANILIST_COOLDOWN_MS = exports.ANILIST_MIN_INTERVAL_MS = exports.ANILIST_BATCH_SIZE = exports.ANILIST_API_URL = exports.BANGUMI_API_HOST = exports.PLUGIN_NAME = void 0;
 exports.buildUserAgent = buildUserAgent;
 exports.getMessages = getMessages;
 /** 插件名，同时作为日志前缀与 User-Agent 主体 */
@@ -44,8 +44,21 @@ exports.BANGUMI_DATA_FALLBACK_URLS = [
 exports.BANGUMI_DATA_FILE = 'bangumi-data.json';
 /** bangumi-data 回退缓存的目录（相对于 ctx.baseDir），与本地化缓存放在一起 */
 exports.DATA_DIR = ['data', 'anime-schedule'];
-/** 插件版本与主页，请求 Bangumi 时用于自报身份 */
-exports.PLUGIN_VERSION = '1.0.0';
+/**
+ * 插件版本与主页，请求 Bangumi 时用于自报身份。
+ *
+ * 版本号从 `package.json` 读：单独维护一份字面量必然会在发版时漏更新（它曾停在 1.0.0），
+ * 而 `package.json` 一定随包发布，读它不会失效。
+ */
+exports.PLUGIN_VERSION = (() => {
+    try {
+        const pkg = require('../package.json');
+        return pkg.version ?? '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+})();
 exports.PLUGIN_HOMEPAGE = 'https://github.com/YuzuharaYuka/koishi-plugin-anime-schedule';
 /**
  * 请求 Bangumi 时使用的 User-Agent。
@@ -91,6 +104,9 @@ exports.LOCALIZE_CACHE_FILE = 'localize-cache.json';
  *
  * 比标题封面的 cacheTtlDays 短得多：新番开播头几周评分天天在变，样本量从个位数
  * 涨到几百，用 30 天缓存会一直显示「只有十几个人投票」时的噪声值。
+ *
+ * 到期只触发后台补取（`Localizer.kickScoreRefresh()`），不阻塞构建：评分是一张表的
+ * 附属信息，为它把整张表推迟十几秒不划算。
  */
 exports.DEFAULT_SCORE_TTL_HOURS = 24;
 /**
@@ -188,6 +204,16 @@ exports.MAX_SUPERSAMPLE = 5;
  */
 exports.DAILY_OFFSET_MIN = -7;
 exports.DAILY_OFFSET_MAX = 7;
+/**
+ * 构建结果的复用窗口（毫秒）。
+ *
+ * 推送遍历频道时每个群都调一次构建，指令层也常被连着问同一张表。这些调用的差别只有
+ * 「已订阅」标记，其余部分（场次推算、AniList 状态、Bangumi 详情、封面地址）完全相同，
+ * 因此一份结果在窗口内可以重复用，订阅标记事后再按频道注入。
+ */
+exports.BUILD_CACHE_TTL_MS = 5 * 60 * 1000;
+/** 构建结果同时留存几份（日/深夜/周/季 × 少量偏移），超出丢最早的一份 */
+exports.BUILD_CACHE_MAX_ENTRIES = 16;
 /** 注册到 canvas 的字体族名，与 config.render.fontFamily 的默认值保持一致 */
 exports.DEFAULT_FONT_FAMILY = 'Anime Schedule Sans';
 /**

package/lib/handlers.js

@@ -92,6 +92,8 @@ function platformOf(session) {
 /** 构建一次推送内容并回复当前会话 */
 async function replyDigest(deps, session, digest) {
     const { config, renderer, logger } = deps;
+    // 内容已经拿到手，评分过期的条目趁出图这段时间在后台补，不占用这次指令的等待
+    deps.digest.localizer.kickScoreRefresh();
     if (!digest.groups.length) {
         await session.send([digest.header, digest.summary].filter(Boolean).join('\n'));
         return;

package/lib/render/image.js

@@ -80,7 +80,7 @@ class Renderer {
         const started = Date.now();
         const canvas = await this.draw(payload);
         const encoded = await canvas.encode('jpeg', this.config.render.jpegQuality);
-        this.logger.debug('[render] %s 出图完成 (%dms)，尺寸 %dx%d (超采样 %dx)，%d bytes (jpeg q=%d)', payload.kind, Date.now() - started, canvas.width, canvas.height, encoded.length, this.config.render.jpegQuality);
+        this.logger.debug('[render] %s 出图完成（%dms），尺寸 %dx%d（超采样 %dx），%d bytes（jpeg q=%d）', payload.kind, Date.now() - started, canvas.width, canvas.height, this.scale, encoded.length, this.config.render.jpegQuality);
         releaseSurface(canvas);
         return encoded;
     }

package/lib/services/digest.d.ts

@@ -16,6 +16,10 @@ export declare class DigestService {
     /** AniList 播出状态查询；未注入时退化为「按 Bangumi 逐集档期判断」 */
     private airing?;
     readonly localizer: Localizer;
+    /** 已构建结果的短缓存，见 `shared()` */
+    private readonly recentBuilds;
+    /** 同一份内容正被构建时，后来的调用直接等它，不重复构建 */
+    private readonly pendingBuilds;
     constructor(ctx: Context, config: Config, logger: Logger, index: BangumiDataIndex, http: HttpClient, 
     /** AniList 播出状态查询；未注入时退化为「按 Bangumi 逐集档期判断」 */
     airing?: AiringStatusService | undefined);
@@ -172,6 +176,14 @@ export declare class DigestService {
     /** 每种表的分组方式 */
     private groupOf;
     private emptyTextOf;
+    /**
+     * 取共享构建结果，再把本频道的订阅标记补上。
+     *
+     * @param key 只由「内容口径」决定：表种、偏移、以及 `now` 落在哪一天/哪一季。同一个键在
+     *   `BUILD_CACHE_TTL_MS` 内只构建一次。
+     */
+    private shared;
+    private rememberBuild;
     /**
      * 每日更新表，`offset` 为相对今天的日期偏移（-1 表示前一天）。
      *
@@ -205,7 +217,12 @@ export declare class DigestService {
      * 主动指定的），但已播完的必须滤掉：周期规则无限重复，旧季番照样能推算出「第 287 集」。
      */
     upcomingAirings(tids: string[], days: number, now?: number): Promise<DigestItem[]>;
-    /** 按类型构建，供调度器与指令共用；订阅标记按目标频道计算 */
+    /**
+     * 按类型构建，供调度器与指令共用。
+     *
+     * 除订阅排期外都走 `shared()`：同一份内容在窗口内只构建一次，逐群推送与重复指令只多付
+     * 一次注入「已订阅」标记的工夫。
+     */
     build(kind: DigestKind, platform: string, channelId: string, now?: number): Promise<Digest>;
     /**
      * 收尾：套上上限、算统计行、拼出最终 `Digest`。`now` 必须由调用方传入而**不能取

package/lib/services/digest.js

@@ -66,6 +66,21 @@ const EMPTY_SETS = new Set();
 function defaultTidOf(entry) {
     return entry.bangumiId === null ? null : `bgm:${entry.bangumiId}`;
 }
+/**
+ * 把共享构建结果里的「已订阅」标记换成调用方频道的集合。
+ *
+ * 共享结果按空集合构建，因此条目上的标记全是 `false`，这里只需给命中的条目翻一个布尔值，
+ * 不必重排、重算摘要——那些都只跟条目内容有关。
+ */
+function withSubscribed(digest, subscribed) {
+    if (!subscribed.size || !digest.groups.length)
+        return digest;
+    const groups = digest.groups.map((group) => ({
+        ...group,
+        items: group.items.map((item) => (subscribed.has(item.tid) ? { ...item, subscribed: true } : item)),
+    }));
+    return { ...digest, groups };
+}
 /**
  * 推送内容构建服务。
  * 播出时刻与集数全部由 bangumi-data 的周期规则推算，构建过程不产生番组表请求。
@@ -76,6 +91,10 @@ class DigestService {
     index;
     airing;
     localizer;
+    /** 已构建结果的短缓存，见 `shared()` */
+    recentBuilds = new Map();
+    /** 同一份内容正被构建时，后来的调用直接等它，不重复构建 */
+    pendingBuilds = new Map();
     constructor(ctx, config, logger, index, http, 
     /** AniList 播出状态查询；未注入时退化为「按 Bangumi 逐集档期判断」 */
     airing) {
@@ -844,6 +863,38 @@ class DigestService {
             return this.messages.emptyWeekly;
         return this.messages.emptyDaily;
     }
+    /**
+     * 取共享构建结果，再把本频道的订阅标记补上。
+     *
+     * @param key 只由「内容口径」决定：表种、偏移、以及 `now` 落在哪一天/哪一季。同一个键在
+     *   `BUILD_CACHE_TTL_MS` 内只构建一次。
+     */
+    async shared(key, create, subscribed) {
+        const hit = this.recentBuilds.get(key);
+        if (hit && Date.now() - hit.at < constants_1.BUILD_CACHE_TTL_MS)
+            return withSubscribed(hit.digest, subscribed);
+        let pending = this.pendingBuilds.get(key);
+        if (!pending) {
+            pending = create()
+                .then((digest) => {
+                this.rememberBuild(key, digest);
+                return digest;
+            })
+                .finally(() => this.pendingBuilds.delete(key));
+            this.pendingBuilds.set(key, pending);
+        }
+        return withSubscribed(await pending, subscribed);
+    }
+    rememberBuild(key, digest) {
+        // 先删后加：同一个键再构建一次时把它挪到队尾，淘汰的永远是最久没用过的那份
+        this.recentBuilds.delete(key);
+        this.recentBuilds.set(key, { at: Date.now(), digest });
+        for (const oldest of this.recentBuilds.keys()) {
+            if (this.recentBuilds.size <= constants_1.BUILD_CACHE_MAX_ENTRIES)
+                break;
+            this.recentBuilds.delete(oldest);
+        }
+    }
     /**
      * 每日更新表，`offset` 为相对今天的日期偏移（-1 表示前一天）。
      *
@@ -852,17 +903,20 @@ class DigestService {
     async buildDaily(offset = this.config.push.dailyOffsetDays, subscribed = EMPTY_SETS, now = Date.now()) {
         // 与配置项 `.min()/.max()` 共用同一对边界，避免「配置页能填、这里又被夹一次」
         const days = (0, utils_1.clamp)(offset, constants_1.DAILY_OFFSET_MIN, constants_1.DAILY_OFFSET_MAX);
-        return this.buildAirings('daily', subscribed, now, (at) => {
+        const key = `daily|${days}|${(0, time_1.today)(this.timeZone, now)}`;
+        const create = () => this.buildAirings('daily', EMPTY_SETS, now, (at) => {
             const startMs = (0, time_1.getDayStartMs)((0, time_1.addDays)((0, time_1.today)(this.timeZone, at), days, this.timeZone), this.timeZone);
             return { fromMs: startMs, toMs: startMs + 86400000 - 1, now: startMs };
         });
+        return this.shared(key, create, subscribed);
     }
     /**
      * 深夜档更新表：覆盖「今晚 21:00 之后」与「次日 6:00 之前」两段。凌晨场次按实际播出时刻
      * 展示，因此熬夜追更时一眼就能看到现在之后还有什么可看。
      */
     async buildNight(subscribed = EMPTY_SETS, now = Date.now()) {
-        return this.buildAirings('night', subscribed, now, (at) => {
+        const key = `night|${(0, time_1.today)(this.timeZone, now)}`;
+        const create = () => this.buildAirings('night', EMPTY_SETS, now, (at) => {
             const date = (0, time_1.today)(this.timeZone, at);
             const eveningStartMs = (0, time_1.getDayStartMs)(date, this.timeZone) + EVENING_START_HOUR * 3600000;
             const tomorrowStartMs = (0, time_1.getDayStartMs)((0, time_1.addDays)(date, 1, this.timeZone), this.timeZone);
@@ -873,16 +927,19 @@ class DigestService {
                 now: eveningStartMs,
             };
         });
+        return this.shared(key, create, subscribed);
     }
     /** 本周更新表，覆盖今天起七天，每部作品只占一条 */
     async buildWeekly(subscribed = EMPTY_SETS, now = Date.now()) {
-        return this.buildAirings('weekly', subscribed, now, (at) => {
+        const key = `weekly|${(0, time_1.today)(this.timeZone, now)}`;
+        const create = () => this.buildAirings('weekly', EMPTY_SETS, now, (at) => {
             const start = (0, time_1.today)(this.timeZone, at);
             const startMs = (0, time_1.getDayStartMs)(start, this.timeZone);
             // 七天整：到「第 8 天 0 点」为止
             const endMs = (0, time_1.getDayStartMs)((0, time_1.addDays)(start, 7, this.timeZone), this.timeZone);
             return { fromMs: startMs, toMs: endMs - 1, onePerTitle: true, now: startMs };
         });
+        return this.shared(key, create, subscribed);
     }
     /**
      * 本季（或指定季度）的新番概览：收录该季首播的全部 TV / WEB 动画，不剔除已播完的作品，
@@ -893,7 +950,9 @@ class DigestService {
     async buildSeason(seasonOffset = 0, subscribed = EMPTY_SETS, now = Date.now()) {
         await this.prepare();
         const { year, startMonth } = this.resolveSeason(seasonOffset, now);
-        return this.buildSeasonOf(year, startMonth, subscribed, now);
+        // 同一季的内容与「今天」无关，键里不必带日期
+        const key = `season|${year}|${startMonth}`;
+        return this.shared(key, () => this.buildSeasonOf(year, startMonth, EMPTY_SETS, now), subscribed);
     }
     /** 由「相对当前季度的偏移」算出目标季度 */
     resolveSeason(offset, now) {
@@ -1016,7 +1075,12 @@ class DigestService {
         (0, utils_1.debugLog)('[digest] 订阅排期: %d 条订阅 → 未来 %d 天内 %d 场', tids.length, days, items.length);
         return items.sort((a, b) => a.atMs - b.atMs);
     }
-    /** 按类型构建，供调度器与指令共用；订阅标记按目标频道计算 */
+    /**
+     * 按类型构建，供调度器与指令共用。
+     *
+     * 除订阅排期外都走 `shared()`：同一份内容在窗口内只构建一次，逐群推送与重复指令只多付
+     * 一次注入「已订阅」标记的工夫。
+     */
     async build(kind, platform, channelId, now = Date.now()) {
         const subscribed = await this.subscribedKeys(platform, channelId);
         if (kind === 'daily')
@@ -1024,7 +1088,7 @@ class DigestService {
         if (kind === 'night')
             return this.buildNight(subscribed, now);
         if (kind === 'weekly')
-            return this.buildWeekly(subscribed);
+            return this.buildWeekly(subscribed, now);
         if (kind === 'season')
             return this.buildSeason(0, subscribed, now);
         return this.buildSubscription(platform, channelId, now);

package/lib/services/localizer.d.ts

@@ -45,6 +45,9 @@ export declare class Localizer {
     private loadPromise;
     private dirty;
     private flushTimer;
+    /** 本次构建里评分过期、等出图之后在后台补取的条目 */
+    private readonly pendingScores;
+    private refreshingScores;
     constructor(ctx: Context, config: Config, logger: Logger, http: HttpClient);
     /** 是否使用中文名与评分展示（详情本身始终获取，用于判断是否已播完） */
     get enabled(): boolean;
@@ -58,12 +61,15 @@ export declare class Localizer {
     /** 主动落盘，插件卸载与调度结束后调用 */
     save(): Promise<void>;
     /**
-     * 这一条缓存是否还够用。标题封面与评分分开计保质期：前者几乎不变（`cacheTtlDays`），后者在
-     * 新番开播头几周天天在变（`scoreTtlHours`）。
+     * 标题、封面与首末集日期是否还能用。这几项基本不变，只受 `cacheTtlDays` 管。
      *
-     * @param wantEpisodeTimes 需要逐集档期时，缺档期的条目即使标题还新鲜也得重取一次。
+     * 评分不在其中：它只在开播头几周天天变，而重取一次评分要走整条
+     * `GET /v0/subjects/{id}` 请求。让评分过期去卡构建，等于为了一个数字把整张表推迟十几秒，
+     * 因此过期评分先照旧展示，构建结束后再由 `kickScoreRefresh()` 在后台补。
      */
-    private isFresh;
+    private isDisplayFresh;
+    /** 评分是否该重取；「条目不存在」的占位记录没有评分，不参与 */
+    private needsScoreRefresh;
     /**
      * 批量取回条目详情，返回「条目 ID → 详情」。未命中的条目不会出现在结果里，调用方按
      * 「取不到就退化为日文原名」处理。
@@ -73,6 +79,15 @@ export declare class Localizer {
      *   `hasEpisodeTimes: false`，日后真有需要时会自动补取。
      */
     localizeByIds(ids: number[], wantEpisodeTimes?: boolean): Promise<Map<number, LocalizeCacheEntry>>;
+    /**
+     * 把这次用到的、评分过期的条目在后台重取一遍。出图之后再调，让用户先看到内容。
+     *
+     * 不写在 `localizeByIds` 里自动跑，是因为快照与预览脚本要的结果必须只取决于本地缓存：
+     * 后台刷新会让同一份缓存在不同时刻构建出不同的评分。
+     */
+    kickScoreRefresh(): void;
+    /** 只补评分相关字段；逐集档期是另一笔请求，不在这里重取 */
+    private refreshScores;
     /** 按条目 ID 取单个条目详情；条目不存在（404）或请求失败时返回 null */
     private fetchSubject;
     /**

package/lib/services/localizer.js

@@ -60,6 +60,9 @@ class Localizer {
     loadPromise = null;
     dirty = false;
     flushTimer = null;
+    /** 本次构建里评分过期、等出图之后在后台补取的条目 */
+    pendingScores = new Set();
+    refreshingScores = false;
     constructor(ctx, config, logger, http) {
         this.ctx = ctx;
         this.config = config;
@@ -156,25 +159,21 @@ class Localizer {
         await this.flush();
     }
     /**
-     * 这一条缓存是否还够用。标题封面与评分分开计保质期：前者几乎不变（`cacheTtlDays`），后者在
-     * 新番开播头几周天天在变（`scoreTtlHours`）。
+     * 标题、封面与首末集日期是否还能用。这几项基本不变，只受 `cacheTtlDays` 管。
      *
-     * @param wantEpisodeTimes 需要逐集档期时，缺档期的条目即使标题还新鲜也得重取一次。
+     * 评分不在其中：它只在开播头几周天天变，而重取一次评分要走整条
+     * `GET /v0/subjects/{id}` 请求。让评分过期去卡构建，等于为了一个数字把整张表推迟十几秒，
+     * 因此过期评分先照旧展示，构建结束后再由 `kickScoreRefresh()` 在后台补。
      */
-    isFresh(entry, wantEpisodeTimes) {
-        if (entry.missing) {
-            // 「不存在」也是有效结果：同一季内不必反复去问一个不会出现的条目
-            return Date.now() - entry.cachedAt < this.config.localize.cacheTtlDays * 24 * 60 * 60 * 1000;
-        }
-        // 取过条目详情、却没取逐集档期，而这次需要档期 → 必须重取。旧版缓存没有 hasEpisodeTimes 字段，按「取过」处理。
-        if (wantEpisodeTimes && entry.hasEpisodeTimes === false)
-            return false;
-        // 评分单独算保质期：到期就重取详情，重取时仍按调用方的需要决定要不要连档期一起取
-        const scoreAt = entry.scoreCachedAt ?? entry.cachedAt;
-        if (Date.now() - scoreAt >= this.config.localize.scoreTtlHours * 60 * 60 * 1000)
-            return false;
+    isDisplayFresh(entry) {
         return Date.now() - entry.cachedAt < this.config.localize.cacheTtlDays * 24 * 60 * 60 * 1000;
     }
+    /** 评分是否该重取；「条目不存在」的占位记录没有评分，不参与 */
+    needsScoreRefresh(entry) {
+        if (entry.missing)
+            return false;
+        return Date.now() - (entry.scoreCachedAt ?? entry.cachedAt) >= this.config.localize.scoreTtlHours * 60 * 60 * 1000;
+    }
     /**
      * 批量取回条目详情，返回「条目 ID → 详情」。未命中的条目不会出现在结果里，调用方按
      * 「取不到就退化为日文原名」处理。
@@ -203,7 +202,10 @@ class Localizer {
             }
             // 过期条目也先返回，避免一次请求失败就让整张表掉封面
             result.set(id, cached);
-            if (!this.isFresh(cached, wantEpisodeTimes)) {
+            if (this.needsScoreRefresh(cached))
+                this.pendingScores.add(id);
+            // 只有展示数据过期、或这次要档期而缓存里没有档期时才阻塞构建
+            if (!this.isDisplayFresh(cached) || (wantEpisodeTimes && cached.hasEpisodeTimes === false)) {
                 wanted.push(id);
                 previous.set(id, cached);
             }
@@ -261,6 +263,53 @@ class Localizer {
         }
         return result;
     }
+    /**
+     * 把这次用到的、评分过期的条目在后台重取一遍。出图之后再调，让用户先看到内容。
+     *
+     * 不写在 `localizeByIds` 里自动跑，是因为快照与预览脚本要的结果必须只取决于本地缓存：
+     * 后台刷新会让同一份缓存在不同时刻构建出不同的评分。
+     */
+    kickScoreRefresh() {
+        if (this.refreshingScores || !this.pendingScores.size)
+            return;
+        const ids = [...this.pendingScores];
+        this.pendingScores.clear();
+        this.refreshingScores = true;
+        void this.refreshScores(ids).finally(() => {
+            this.refreshingScores = false;
+        });
+    }
+    /** 只补评分相关字段；逐集档期是另一笔请求，不在这里重取 */
+    async refreshScores(ids) {
+        const started = Date.now();
+        let ok = 0;
+        await (0, utils_1.mapLimit)(ids, constants_1.LOCALIZE_CONCURRENCY, async (id) => {
+            const stale = this.memory.get(id);
+            // 排队期间可能已被别的构建刷新过
+            if (!stale || !this.needsScoreRefresh(stale))
+                return;
+            const subject = await this.fetchSubject(id);
+            if (!subject)
+                return;
+            ok++;
+            this.memory.set(id, {
+                ...stale,
+                title: subject.name_cn?.trim() || subject.name,
+                coverUrl: subject.images?.large ?? subject.images?.common ?? '',
+                score: computeScore(subject.rating),
+                ratingTotal: typeof subject.rating?.total === 'number' ? subject.rating.total : null,
+                totalEpisodes: resolveEpisodeTotal(subject),
+                hasEpisodeTimes: stale.hasEpisodeTimes,
+                firstAirMs: stale.firstAirMs,
+                lastAirMs: stale.lastAirMs,
+                cachedAt: Date.now(),
+                scoreCachedAt: Date.now(),
+            });
+            this.scheduleFlush();
+        });
+        if (ok)
+            (0, utils_1.debugLog)('[localize] 后台补评分: %d 部（%dms）', ok, Date.now() - started);
+    }
     /** 按条目 ID 取单个条目详情；条目不存在（404）或请求失败时返回 null */
     async fetchSubject(id) {
         const url = `${constants_1.BANGUMI_API_HOST}/v0/subjects/${id}`;

package/lib/services/scheduler.js

@@ -163,8 +163,9 @@ class Scheduler {
         const key = (0, dispatch_1.digestKey)(kind, date);
         for (const channel of channels) {
             try {
-                // 必须逐群构建：订阅集合按 `platform:channelId` 算，「已订阅」气泡不能跨群复用，
-                // 否则除第一个群以外都会显示第一个群的订阅标记
+                // 逐群构建，但除订阅标记外的部分由 `DigestService.shared()` 复用：订阅集合按
+                // `platform:channelId` 算，「已订阅」气泡不能跨群复用，否则除第一个群以外都会
+                // 显示第一个群的订阅标记
                 const current = await this.digest.build(kind, channel.platform, channel.channelId, now);
                 if (!current.groups.length) {
                     result.skipped++;
@@ -185,6 +186,8 @@ class Scheduler {
                 this.logger.warn('[push] 向 %s:%s 发送 %s 失败:', channel.platform, channel.channelId, constants_1.DIGEST_LABELS[kind], error);
             }
         }
+        // 推送内容已经发完，评分过期的条目在后台补，不拖慢这一轮推送
+        this.digest.localizer.kickScoreRefresh();
         if (result.sent === 0 && result.failed === 0) {
             this.logger.info('[push] %s: 本次没有符合条件的作品，未发送任何消息', constants_1.DIGEST_LABELS[kind]);
             return result;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-anime-schedule",
   "description": "番剧时间表与订阅提醒：提供日 / 周 / 季三表，支持定时推送、指定订阅、搜索和详情展示",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [

package/readme.md

@@ -60,7 +60,7 @@ npm i koishi-plugin-anime-schedule
 | `output.infoKeywordLimit` | `20` | `anime.info` 按关键词最多出几部，`0` 不限制 |
 | `output.showScore` | `true` | 显示评分，评价不足 10 人时隐藏 |
 | `localize.titleStyle` | `localized` | `localized` 仅中文 / `both` 中文（日文原名）/ `original` 仅日文原名 |
-| `localize.scoreTtlHours` | `24` | 评分与评价人数的缓存小时数 |
+| `localize.scoreTtlHours` | `24` | 评分与评价人数的后台刷新间隔，到期不阻塞出图 |
 | `render.jpegQuality` | `100` | 图片编码质量，调低可减小体积 |
 | `render.supersample` | `3` | 超采样倍数，提升小字与封面清晰度；`1` 最省体积 |
 | `advanced.debug` | `false` | 输出调试日志 |