koishi-plugin-anime-schedule 1.0.9 → 1.1.0

package/lib/config.js

@@ -165,7 +165,7 @@ exports.Config = koishi_1.Schema.intersect([
             requestTimeout: koishi_1.Schema.number()
                 .min(1)
                 .description('单次请求超时（秒）')
-                .default(20),
+                .default(constants_1.LOCALIZE_TIMEOUT_SECONDS),
             retries: koishi_1.Schema.number()
                 .min(0)
                 .description('请求失败重试次数')
@@ -238,7 +238,7 @@ function normalizeConfig(config) {
         },
         advanced: {
             ...config.advanced,
-            requestTimeout: int(config.advanced?.requestTimeout, 20, 1),
+            requestTimeout: int(config.advanced?.requestTimeout, constants_1.LOCALIZE_TIMEOUT_SECONDS, 1),
             retries: int(config.advanced?.retries, 2),
         },
     };

package/lib/constants.d.ts

@@ -19,6 +19,12 @@ export declare const ANILIST_BATCH_SIZE = 50;
  * 相当于最多 50 次/分钟，既不会触发突发限流，也远低于上限。
  */
 export declare const ANILIST_MIN_INTERVAL_MS = 1200;
+/**
+ * 收到 429 / 403 后的冷却时长。
+ *
+ * 429 是超限封禁、403 是 API 被临时停用，两种情况都沿用已有数据一段时间再试。
+ */
+export declare const ANILIST_COOLDOWN_MS: number;
 /**
  * bangumi-data 索引。
  *
@@ -85,10 +91,18 @@ export declare const LOCALIZE_CACHE_MAX_ENTRIES = 5000;
 export declare const EPISODE_QUERY_LIMIT = 100;
 /**
  * 并发检索 Bangumi 的条数上限。
- * Bangumi 没有公开的严格限流，但一次本季表可能有上百部作品，
- * 4 路并发已能把原本串行的等待时间压到 1/4，同时不至于触发风控。
+ *
+ * Bangumi 没有公开的严格限流，但一次本季表可能有上百部作品。取 6 路：实测 4 路时周表
+ * 取详情要 50 秒上下，6 路约省三分之一，仍远低于会让站点限流的密度。
+ */
+export declare const LOCALIZE_CONCURRENCY = 6;
+/**
+ * 单次元数据请求的超时（秒），`advanced.requestTimeout` 的默认值。
+ *
+ * Bangumi 的条目接口是小体积 JSON，正常几百毫秒返回。等满 20 秒基本等价于连接已死，
+ * 而一条超时会把整次构建拖住这么久，所以默认压到 10 秒；嫌紧可以自行调大。
  */
-export declare const LOCALIZE_CONCURRENCY = 4;
+export declare const LOCALIZE_TIMEOUT_SECONDS = 10;
 /** 并发拉取封面时的并发上限 */
 export declare const COVER_CONCURRENCY = 8;
 /** 封面下载超时与体积上限，避免个别大图拖垮整次渲染 */
@@ -101,15 +115,6 @@ export declare const COVER_CACHE_MAX_FILES = 1200;
 /** 图片渲染用的字体候选，按平台常见路径排列，找不到时回退到运行环境默认字体 */
 export declare const FONT_CANDIDATES: string[];
 /** 加粗字体候选，找不到时由绘制层用描边模拟粗体 */
-/**
- * 兜底字体族候选。
- *
- * 与 `FONT_CANDIDATES` 的区别：那些是**主字体**（选一个用），这些是**补充**
- * （全部注册，缺字形时按顺序回退）。`@napi-rs/canvas` 只在"字体族不存在"时回退，
- * 族存在但缺字形就直接画豆腐块，所以补充族必须真的注册进来才有效。
- * 名字要与 `render/fonts.ts` 的 `FALLBACK_FAMILIES` 一致。
- */
-export declare const FALLBACK_FONT_CANDIDATES: string[];
 export declare const BOLD_FONT_CANDIDATES: string[];
 /**
  * JPEG 编码质量。
@@ -308,12 +313,8 @@ export interface Messages {
     footer: string;
     /** 周历表表头的日期区间，例如 `9月21日 - 9月27日`；两端已由 formatDayLabel 本地化 */
     rangeLabel: (start: string, end: string) => string;
-    /** 今天的日期列角标 */
-    todayBadge: string;
     /** 已在订阅列表里的作品，条目上的气泡 */
     subscribedBadge: string;
-    /** 日期列超出上限时的提示 */
-    moreItems: (count: number) => string;
     /** 详情卡页脚的数据更新时间 */
     infoUpdated: (moment: string) => string;
     /** 连载状态 */

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.FALLBACK_FONT_CANDIDATES = exports.FONT_CANDIDATES = 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_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_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.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_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 主体 */
@@ -23,6 +23,12 @@ exports.ANILIST_BATCH_SIZE = 50;
  * 相当于最多 50 次/分钟，既不会触发突发限流，也远低于上限。
  */
 exports.ANILIST_MIN_INTERVAL_MS = 1200;
+/**
+ * 收到 429 / 403 后的冷却时长。
+ *
+ * 429 是超限封禁、403 是 API 被临时停用，两种情况都沿用已有数据一段时间再试。
+ */
+exports.ANILIST_COOLDOWN_MS = 5 * 60 * 1000;
 /**
  * bangumi-data 索引。
  *
@@ -101,10 +107,18 @@ exports.LOCALIZE_CACHE_MAX_ENTRIES = 5000;
 exports.EPISODE_QUERY_LIMIT = 100;
 /**
  * 并发检索 Bangumi 的条数上限。
- * Bangumi 没有公开的严格限流，但一次本季表可能有上百部作品，
- * 4 路并发已能把原本串行的等待时间压到 1/4，同时不至于触发风控。
+ *
+ * Bangumi 没有公开的严格限流，但一次本季表可能有上百部作品。取 6 路：实测 4 路时周表
+ * 取详情要 50 秒上下，6 路约省三分之一，仍远低于会让站点限流的密度。
+ */
+exports.LOCALIZE_CONCURRENCY = 6;
+/**
+ * 单次元数据请求的超时（秒），`advanced.requestTimeout` 的默认值。
+ *
+ * Bangumi 的条目接口是小体积 JSON，正常几百毫秒返回。等满 20 秒基本等价于连接已死，
+ * 而一条超时会把整次构建拖住这么久，所以默认压到 10 秒；嫌紧可以自行调大。
  */
-exports.LOCALIZE_CONCURRENCY = 4;
+exports.LOCALIZE_TIMEOUT_SECONDS = 10;
 /** 并发拉取封面时的并发上限 */
 exports.COVER_CONCURRENCY = 8;
 /** 封面下载超时与体积上限，避免个别大图拖垮整次渲染 */
@@ -131,20 +145,6 @@ exports.FONT_CANDIDATES = [
     '/usr/share/fonts/truetype/arphic/uming.ttc',
 ];
 /** 加粗字体候选，找不到时由绘制层用描边模拟粗体 */
-/**
- * 兜底字体族候选。
- *
- * 与 `FONT_CANDIDATES` 的区别：那些是**主字体**（选一个用），这些是**补充**
- * （全部注册，缺字形时按顺序回退）。`@napi-rs/canvas` 只在"字体族不存在"时回退，
- * 族存在但缺字形就直接画豆腐块，所以补充族必须真的注册进来才有效。
- * 名字要与 `render/fonts.ts` 的 `FALLBACK_FAMILIES` 一致。
- */
-exports.FALLBACK_FONT_CANDIDATES = [
-    'C:/Windows/Fonts/YuGothR.ttc',
-    'C:/Windows/Fonts/msgothic.ttc',
-    'C:/Windows/Fonts/simsun.ttc',
-    'C:/Windows/Fonts/NotoSansSC-VF.ttf',
-];
 exports.BOLD_FONT_CANDIDATES = [
     'C:/Windows/Fonts/msyhbd.ttc',
     'C:/Windows/Fonts/Dengb.ttf',
@@ -342,9 +342,7 @@ const ZH_CN = {
     truncated: (shown, total) => `仅显示前 ${shown} 部，其余 ${total - shown} 部请使用指令按需查询。`,
     footer: '数据来源: bangumi-data / Bangumi',
     rangeLabel: (start, end) => `${start} - ${end}`,
-    todayBadge: '今天',
     subscribedBadge: '已订阅',
-    moreItems: (count) => `还有 ${count} 部`,
     infoUpdated: (moment) => `数据更新于 ${moment}`,
     infoAiring: '连载中',
     infoFinished: '已完结',
@@ -387,9 +385,7 @@ const JA_JP = {
     truncated: (shown, total) => `先頭 ${shown} 作品のみ表示しています (残り ${total - shown} 作品)。`,
     footer: 'データ提供: bangumi-data / Bangumi',
     rangeLabel: (start, end) => `${start} 〜 ${end}`,
-    todayBadge: '今日',
     subscribedBadge: '登録済み',
-    moreItems: (count) => `他 ${count} 作品`,
     infoUpdated: (moment) => `データ更新 ${moment}`,
     infoAiring: '放送中',
     infoFinished: '完結',
@@ -432,9 +428,7 @@ const EN_US = {
     truncated: (shown, total) => `Showing first ${shown} of ${total} titles.`,
     footer: 'Data: bangumi-data / Bangumi',
     rangeLabel: (start, end) => `${start} - ${end}`,
-    todayBadge: 'Today',
     subscribedBadge: 'Subscribed',
-    moreItems: (count) => `+${count} more`,
     infoUpdated: (moment) => `Updated ${moment}`,
     infoAiring: 'Airing',
     infoFinished: 'Finished',

package/lib/data/bangumi-data-loader.d.ts

@@ -1,5 +1,6 @@
 import type { Context, Logger } from 'koishi';
 import type { BangumiDataItem } from './bangumi-data-source';
+import { HttpClient } from '../services/network';
 /** 一次载入的结果 */
 export interface LoadedData {
     items: BangumiDataItem[];
@@ -10,7 +11,7 @@ export declare class BangumiDataLoader {
     private ctx;
     private logger;
     private readonly http;
-    constructor(ctx: Context, logger: Logger);
+    constructor(ctx: Context, logger: Logger, http: HttpClient);
     private get cachePath();
     /** 依次尝试：npm 依赖包 → 磁盘缓存 → CDN 镜像 */
     load(): Promise<LoadedData | null>;

package/lib/data/bangumi-data-loader.js

@@ -10,7 +10,6 @@ const fs_1 = require("fs");
 const path_1 = require("path");
 const constants_1 = require("../constants");
 const utils_1 = require("../utils");
-const network_1 = require("../services/network");
 /** 只在缓存里保留用得到的字段，避免把整个包写一遍 */
 const CACHED_FIELDS = [
     'title', 'titleTranslate', 'type', 'officialSite', 'begin', 'broadcast', 'end', 'sites',
@@ -19,10 +18,10 @@ class BangumiDataLoader {
     ctx;
     logger;
     http;
-    constructor(ctx, logger) {
+    constructor(ctx, logger, http) {
         this.ctx = ctx;
         this.logger = logger;
-        this.http = new network_1.HttpClient(ctx, logger);
+        this.http = http;
     }
     get cachePath() {
         return (0, path_1.resolve)(this.ctx.baseDir, ...constants_1.DATA_DIR, constants_1.BANGUMI_DATA_FILE);

package/lib/data/bangumi-data.d.ts

@@ -4,6 +4,7 @@
  * `bangumi-data-loader.ts`，本文件只负责建立索引并提供查询。
  */
 import type { Context, Logger } from 'koishi';
+import type { HttpClient } from '../services/network';
 import type { BroadcastSource } from './bangumi-data-source';
 /** 索引层对外暴露的一条作品 */
 export interface IndexEntry {
@@ -63,7 +64,7 @@ export declare class BangumiDataIndex {
     private readonly loader;
     /** 补充映射命中的条数，用于日志 */
     private mappedCount;
-    constructor(ctx: Context, logger: Logger);
+    constructor(ctx: Context, logger: Logger, http: HttpClient);
     get ready(): boolean;
     get size(): number;
     /**
@@ -114,4 +115,3 @@ export declare class BangumiDataIndex {
     /** 把原始清单展开成索引条目 */
     private apply;
 }
-export type { BangumiDataItem } from './bangumi-data-source';

package/lib/data/bangumi-data.js

@@ -27,9 +27,9 @@ class BangumiDataIndex {
     loader;
     /** 补充映射命中的条数，用于日志 */
     mappedCount = 0;
-    constructor(ctx, logger) {
+    constructor(ctx, logger, http) {
         this.logger = logger;
-        this.loader = new bangumi_data_loader_1.BangumiDataLoader(ctx, logger);
+        this.loader = new bangumi_data_loader_1.BangumiDataLoader(ctx, logger, http);
     }
     get ready() {
         return this.entries.length > 0;

package/lib/handlers.js

@@ -344,8 +344,6 @@ async function sendInfoDetail(deps, session, bgmId) {
 }
 /** 出图，失败时退回文本；两者都不可用时返回 `null` */
 async function renderInfoNode(deps, detail) {
-    if (!detail)
-        return null;
     if (deps.config.output.format !== 'image')
         return koishi_1.h.text((0, text_1.renderInfoText)(detail, deps.config));
     try {

package/lib/index.js

@@ -97,10 +97,10 @@ function apply(ctx, rawConfig) {
     // 出网客户端：Bangumi 接口与图床在国内无法直连，代理在这里统一生效
     const http = new network_1.HttpClient(ctx, logger, config.advanced.retries);
     // bangumi-data 索引层：作品清单、中文译名、Bangumi 条目 ID 与周期时刻都来自这里
-    const index = new bangumi_data_1.BangumiDataIndex(ctx, logger);
+    const index = new bangumi_data_1.BangumiDataIndex(ctx, logger, http);
     // AniList 播出状态：判断「这部番是否还在播」的权威依据
-    const airing = new airing_1.AiringStatusService(ctx, logger);
-    const digest = new digest_1.DigestService(ctx, config, logger, index, airing);
+    const airing = new airing_1.AiringStatusService(ctx, logger, http);
+    const digest = new digest_1.DigestService(ctx, config, logger, index, http, airing);
     const renderer = new image_1.Renderer(ctx, config, logger, http);
     const guard = new dispatch_1.DispatchGuard(ctx, logger);
     // 单部作品详情：只服务 `anime.info` 的交互查询，不参与推送

package/lib/render/canvas.d.ts

@@ -1,6 +1,4 @@
-import { IMAGE_THEME } from '../constants';
 import type { SKRSContext2D } from '@napi-rs/canvas';
-export type Theme = typeof IMAGE_THEME;
 /** 主题别名，渲染层统一用 `theme.xxx` 取色 */
 export declare const THEME: {
     background: string;
@@ -61,7 +59,4 @@ export declare function drawContainImage(ctx: SKRSContext2D, image: {
     background?: string;
     border?: boolean;
     shadow?: boolean;
-}): {
-    width: number;
-    height: number;
-};
+}): void;

package/lib/render/canvas.js

@@ -130,7 +130,7 @@ function drawContainImage(ctx, image, x, y, width, height, options = {}) {
         fillRoundRect(ctx, x, y, width, height, radius, options.background ?? exports.THEME.badge);
     }
     if (!image.width || !image.height)
-        return { width: 0, height: 0 };
+        return;
     const scale = Math.min(width / image.width, height / image.height);
     const drawWidth = Math.max(1, Math.floor(image.width * scale));
     const drawHeight = Math.max(1, Math.floor(image.height * scale));
@@ -149,5 +149,4 @@ function drawContainImage(ctx, image, x, y, width, height, options = {}) {
     if (options.border !== false) {
         strokeRoundRect(ctx, x + 0.5, y + 0.5, width - 1, height - 1, radius, exports.THEME.cardBorder);
     }
-    return { width: drawWidth, height: drawHeight };
 }

package/lib/render/covers.d.ts

@@ -4,7 +4,6 @@ import type { CoverRequest } from '../types';
 import { HttpClient } from '../services/network';
 /** 封面加载器：内存 → 磁盘 → 网络三级缓存 + 并发下载，同一张封面一次推送只下载一次 */
 export declare class CoverStore {
-    private ctx;
     private logger;
     private concurrency;
     private cacheDays;
@@ -29,6 +28,8 @@ export declare class CoverStore {
     private fetchAndDecode;
     private download;
     private filePath;
+    /** 该封面是否命中磁盘缓存（仅用于统计，不参与加载流程） */
+    private isOnDisk;
     private readDiskCache;
     private writeDiskCache;
     /** 清理过期的封面缓存，插件启动时调用一次即可 */

package/lib/render/covers.js

@@ -9,6 +9,13 @@ const constants_1 = require("../constants");
 const utils_1 = require("../utils");
 /** 等待一张封面解码完成的最长时间 */
 const DECODE_WAIT_MS = 5000;
+/**
+ * 单张封面的总时间预算（含多候选地址）。
+ *
+ * 未命中缓存的封面要按候选地址逐个试，每个都等满 8s 的话，一张图就能拖住整批；
+ * 封面缺失只是退化成占位块，不值得为它耗更多时间。
+ */
+const COVER_TOTAL_BUDGET_MS = 12000;
 /** 同一张封面的备用地址：Bangumi 图床按尺寸分目录（`/pic/cover/l|c|m|s/`），个别条目会缺某个尺寸，需逐个回退 */
 function coverUrlCandidates(url) {
     const matched = /^(https?:\/\/[^/]+\/pic\/cover\/)([a-z]+)(\/.*)$/i.exec(url);
@@ -73,7 +80,6 @@ function waitForLoad(image) {
 }
 /** 封面加载器：内存 → 磁盘 → 网络三级缓存 + 并发下载，同一张封面一次推送只下载一次 */
 class CoverStore {
-    ctx;
     logger;
     concurrency;
     cacheDays;
@@ -86,7 +92,6 @@ class CoverStore {
     constructor(ctx, logger, concurrency, cacheDays, 
     /** 出网客户端（含代理） */
     http) {
-        this.ctx = ctx;
         this.logger = logger;
         this.concurrency = concurrency;
         this.cacheDays = cacheDays;
@@ -119,11 +124,16 @@ class CoverStore {
         const started = Date.now();
         let downloaded = 0;
         let fromDisk = 0;
+        let fromMemory = 0;
         const entries = await (0, utils_1.mapLimit)(urls, this.concurrency, async (url) => {
+            // 内存命中多半来自「取详情时的预热」；磁盘命中说明缓存生效；两者都不是才是真下载。
+            // 三个数分开统计，才能从日志判断预热有没有起作用。
             const hadMemory = this.memory.has(url);
             const canvas = await this.loadOne(url);
             if (canvas) {
                 if (hadMemory)
+                    fromMemory++;
+                else if (await this.isOnDisk(url))
                     fromDisk++;
                 else
                     downloaded++;
@@ -136,7 +146,7 @@ class CoverStore {
         this.logger.debug('[render] 封面就绪 %d/%d 张 (%dms)', ok, urls.length, Date.now() - started);
         // 封面缺失会影响版面，失败比例高时给出 info 提示便于定位
         if (ok < urls.length) {
-            this.logger.info('[render] 封面 %d/%d 张可用（内存或磁盘命中 %d，新下载 %d，失败 %d）', ok, urls.length, fromDisk, downloaded, urls.length - ok);
+            this.logger.info('[render] 封面 %d/%d 张可用（预热命中 %d，磁盘命中 %d，新下载 %d，失败 %d）', ok, urls.length, fromMemory, fromDisk, downloaded, urls.length - ok);
         }
         return result;
     }
@@ -168,9 +178,16 @@ class CoverStore {
             // 磁盘上的文件损坏时删掉，重新下载
             await fs_1.promises.rm(this.filePath(url), { force: true }).catch(() => undefined);
         }
-        // 逐个候选地址尝试：图床偶尔缺某个尺寸的图，只试一个地址整张封面就变成占位块了
+        // 逐个候选地址尝试：图床偶尔缺某个尺寸的图，只试一个地址整张封面就变成占位块了。
+        // 总耗时受 `COVER_TOTAL_BUDGET_MS` 约束，避免多个候选叠加成十几秒。
+        const deadline = Date.now() + COVER_TOTAL_BUDGET_MS;
         for (const candidate of coverUrlCandidates(url)) {
-            const buffer = await this.download(candidate);
+            const remaining = deadline - Date.now();
+            if (remaining <= 0) {
+                this.logger.debug('[render] 封面超出时间预算，使用占位块: %s', url);
+                break;
+            }
+            const buffer = await this.download(candidate, Math.min(constants_1.COVER_TIMEOUT_MS, remaining));
             if (!buffer)
                 continue;
             const canvas = await decodeToCanvas(buffer);
@@ -187,11 +204,13 @@ class CoverStore {
         this.logger.debug('[render] 封面全部候选地址都失败: %s', url);
         return null;
     }
-    async download(url) {
+    async download(url, timeout = constants_1.COVER_TIMEOUT_MS) {
         try {
             const buffer = toBuffer(await this.http.get(url, {
-                timeout: constants_1.COVER_TIMEOUT_MS,
+                timeout,
                 responseType: 'arraybuffer',
+                // 封面已有候选地址回退，重试同一地址只会把单次超时叠成数倍
+                retries: 0,
             }));
             if (!buffer) {
                 this.logger.debug('[render] 封面响应不是二进制数据，使用占位块: %s', url);
@@ -214,6 +233,18 @@ class CoverStore {
         const hash = (0, crypto_1.createHash)('sha1').update(url).digest('hex');
         return (0, path_1.resolve)(this.cacheRoot, hash.slice(0, 2), `${hash}.img`);
     }
+    /** 该封面是否命中磁盘缓存（仅用于统计，不参与加载流程） */
+    async isOnDisk(url) {
+        if (!this.enabled)
+            return false;
+        try {
+            await fs_1.promises.access(this.filePath(url));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
     async readDiskCache(url) {
         if (!this.enabled)
             return null;

package/lib/render/image.js

@@ -153,8 +153,6 @@ class Renderer {
     /** 选画布宽度：各版面在常量里各有固定宽度，保证同一版面每次出图尺寸一致 */
     canvasWidth(payload) {
         const L = constants_1.IMAGE_LAYOUT;
-        if (payload.kind === 'season' && this.config.output.layout !== 'list')
-            return L.seasonWidth;
         if (payload.kind === 'weekly')
             return L.weekWidth;
         if (this.config.output.layout === 'list')
@@ -178,7 +176,6 @@ class Renderer {
         const width = L.timelineWidth;
         // 只有一组时不画日期节点
         const showDayHeader = groups.length > 1;
-        const showNow = payload.kind !== 'weekly';
         const spineX = L.padding + L.timelineLabelWidth;
         const elements = [];
         const dayGap = showDayHeader ? L.timelineDayHeaderHeight : 0;
@@ -192,7 +189,7 @@ class Renderer {
             }
             for (const item of group.items) {
                 // 「现在」插在第一条未播出的条目之前
-                if (showNow && !nowPlaced && item.atMs > payload.now) {
+                if (!nowPlaced && item.atMs > payload.now) {
                     nowPlaced = true;
                     elements.push({ kind: 'now', centre: cursor + NOW_MARKER_HEIGHT / 2 });
                     cursor += NOW_MARKER_HEIGHT + separatorGap;
@@ -202,7 +199,7 @@ class Renderer {
             }
         }
         // 全部已播时「现在」落在末尾，与末条留出间距
-        if (showNow && !nowPlaced) {
+        if (!nowPlaced) {
             cursor += separatorGap;
             elements.push({ kind: 'now', centre: cursor + NOW_MARKER_HEIGHT / 2 });
             cursor += NOW_MARKER_HEIGHT;
@@ -529,10 +526,6 @@ class Renderer {
             cursor += ctx.measureText(item.time).width + 8;
             ctx.font = (0, fonts_1.font)(fonts_1.FONT_SIZE.weekTime);
             ctx.fillText((0, canvas_2.fitText)(ctx, episode, Math.max(20, x + width - 8 - cursor)), cursor, y + 18);
-            cursor += ctx.measureText(episode).width + 7;
-        }
-        else {
-            cursor += ctx.measureText(item.time).width + 7;
         }
         // 第二行起：标题（最多两行）
         ctx.font = (0, fonts_1.font)(fonts_1.FONT_SIZE.weekTitle, true);

package/lib/render/info.js

@@ -40,7 +40,6 @@ const L = {
     summaryGap: 14,
     /** 评分图表：10 柱 × (柱宽 + 间距)，另留 10 个刻度数字的位置 */
     scoreChartWidth: 240,
-    footerGapColumns: 24,
     scoreChartHeight: 60,
     scoreAxisHeight: 18,
     scoreBarWidth: 18,
@@ -87,7 +86,7 @@ function renderInfoCard(card) {
     const progressColumnWidth = L.epPerRow * L.epMinWidth + (L.epPerRow - 1) * L.epGap;
     const footerTop = L.padding + headerHeight + summaryHeight + L.sectionGap;
     const bandTop = footerTop + L.sectionTitleSize + L.sectionTitleGap;
-    const band = bandMetrics(bandTop, info.totalEpisodes, progressColumnWidth, scoreColumnWidth);
+    const band = bandMetrics(bandTop, info.totalEpisodes, progressColumnWidth);
     // 两列顶部对齐、各自决定高度，取较高者作为底块高度
     const footerHeight = Math.max(band.progressHeight, band.scoreHeight);
     const height = bandTop + footerHeight + L.footerGap + L.padding + L.footerHeight;
@@ -166,7 +165,7 @@ function renderInfoCard(card) {
         // 底块：两列独立布局，顶部对齐
         const titleLine = bandTop - L.sectionTitleSize - L.sectionTitleGap;
         drawProgressTile(ctx, info, messages, left, progressColumnWidth, titleLine, bandTop, band.grid);
-        drawScoreTile(ctx, info, messages, scoreColumnX, scoreColumnWidth, titleLine, band.baseline);
+        drawScoreTile(ctx, info, messages, scoreColumnX, titleLine, band.baseline);
         // ── 页脚：左边条目 ID（供 `anime.sub` / `anime.info` 直接抄），右边数据更新时间 ──
         ctx.font = (0, fonts_1.font)(fonts_1.FONT_SIZE.footer);
         ctx.textBaseline = 'top';
@@ -260,8 +259,7 @@ function gridMetrics(total, width, perRow) {
     return { cols, rows, height: rows * L.epHeight + (rows - 1) * L.epGap };
 }
 /** 底部两列的几何：两列顶部对齐、各自决定高度互不拉伸；柱区不超过左列高度，避免柱子顶到上一行胶囊 */
-function bandMetrics(bandTop, total, progressWidth, scoreWidth) {
-    void scoreWidth;
+function bandMetrics(bandTop, total, progressWidth) {
     const grid = total !== null && total > 0 && total <= L.epGridMax
         ? gridMetrics(total, progressWidth, L.epPerRow)
         : null;
@@ -287,7 +285,6 @@ function drawProgressTile(ctx, info, messages, x, columnWidth, lineY, top, grid)
     ctx.textAlign = 'left';
     ctx.textBaseline = 'top';
     ctx.fillText(value, x + titleWidth, lineY + 1);
-    void columnWidth;
     if (!grid) {
         // 长期连载番或话数未知：只给一行说明，不铺胶囊，否则几百话会画出上百行
         ctx.font = (0, fonts_1.font)(L.bodySize);
@@ -331,7 +328,7 @@ function drawProgressTile(ctx, info, messages, x, columnWidth, lineY, top, grid)
  *
  * @param baseline 柱子底边，刻度画在它下面
  */
-function drawScoreTile(ctx, info, messages, x, columnWidth, titleY, baseline) {
+function drawScoreTile(ctx, info, messages, x, titleY, baseline) {
     drawSectionTitle(ctx, messages.infoScoreBoard, x, titleY);
     const count = info.scoreCount;
     if (!count) {

package/lib/services/airing.d.ts

@@ -12,6 +12,7 @@
 import type { Context, Logger } from 'koishi';
 import type { AiringState } from '../types';
 import type { MatchTarget } from '../data/anilist-match';
+import { HttpClient } from './network';
 /**
  * 播出数据查询器。
  * 只负责「按 ID 取数据并缓存」；「据此决定怎么排期」由 `DigestService` 负责。
@@ -19,6 +20,7 @@ import type { MatchTarget } from '../data/anilist-match';
 export declare class AiringStatusService {
     private ctx;
     private logger;
+    private http;
     /** 进程内缓存；按 AniList 条款不落盘 */
     private readonly memory;
     /**
@@ -28,20 +30,17 @@ export declare class AiringStatusService {
     private readonly idByTitle;
     /** 已经用掉的标题搜索次数，见 `TITLE_SEARCH_BUDGET` */
     private titleSearches;
-    private readonly http;
     /** 冷却截止时刻：收到 429 后到这时刻之前不再发请求 */
     private cooldownUntil;
     /** 上一次请求结束的时刻，用于保证最小间隔 */
     private lastRequestAt;
     /** 请求串行化，避免并发触发突发限流 */
     private queue;
-    constructor(ctx: Context, logger: Logger);
+    constructor(ctx: Context, logger: Logger, http: HttpClient);
     /** 当前是否处于限流冷却中 */
     get coolingDown(): boolean;
     /** 无需预热（缓存只在内存里），保留此方法让调用方写法统一 */
     ensure(): Promise<void>;
-    /** 条款要求不落盘，因此没有持久化动作；保留此方法兼容调用方 */
-    save(): Promise<void>;
     private isFresh;
     /**
      * 按标题给缺失 `aniList` ID 的条目补一个 ID：补上就用 AniList 的逐話時刻排期，搜不到返回

package/lib/services/airing.js

@@ -4,7 +4,6 @@ exports.AiringStatusService = void 0;
 const constants_1 = require("../constants");
 const utils_1 = require("../utils");
 const anilist_match_1 = require("../data/anilist-match");
-const network_1 = require("./network");
 const QUERY = `query ($ids: [Int]) {
   Page(page: 1, perPage: 50) {
     media(id_in: $ids, type: ANIME) {
@@ -49,6 +48,7 @@ const TITLE_SEARCH_BUDGET = 24;
 class AiringStatusService {
     ctx;
     logger;
+    http;
     /** 进程内缓存；按 AniList 条款不落盘 */
     memory = new Map();
     /**
@@ -58,17 +58,16 @@ class AiringStatusService {
     idByTitle = new Map();
     /** 已经用掉的标题搜索次数，见 `TITLE_SEARCH_BUDGET` */
     titleSearches = 0;
-    http;
     /** 冷却截止时刻：收到 429 后到这时刻之前不再发请求 */
     cooldownUntil = 0;
     /** 上一次请求结束的时刻，用于保证最小间隔 */
     lastRequestAt = 0;
     /** 请求串行化，避免并发触发突发限流 */
     queue = Promise.resolve();
-    constructor(ctx, logger) {
+    constructor(ctx, logger, http) {
         this.ctx = ctx;
         this.logger = logger;
-        this.http = new network_1.HttpClient(ctx, logger);
+        this.http = http;
     }
     /** 当前是否处于限流冷却中 */
     get coolingDown() {
@@ -78,8 +77,6 @@ class AiringStatusService {
     ensure() {
         return Promise.resolve();
     }
-    /** 条款要求不落盘，因此没有持久化动作；保留此方法兼容调用方 */
-    async save() { }
     isFresh(entry, ttlDays) {
         return Date.now() - entry.cachedAt < ttlDays * 24 * 60 * 60 * 1000;
     }
@@ -246,11 +243,11 @@ class AiringStatusService {
      * 服务被停用）；`false` 表示普通失败，调用方按「取不到就跳过」处理。
      */
     handleRequestError(error) {
-        const status = error?.response?.status;
+        const status = (0, utils_1.errorStatus)(error);
         if (status === 429 || status === 403) {
             // 429：超限封禁 1 分钟；403：API 被临时停用。两种情况都进入冷却
-            this.cooldownUntil = Date.now() + ANILIST_COOLDOWN_MS;
-            this.logger.warn('[airing] AniList 返回 %d（%s），暂停查询 %d 分钟，期间沿用已有数据', status, status === 429 ? '超出速率限制' : 'API 被临时停用', ANILIST_COOLDOWN_MS / 60000);
+            this.cooldownUntil = Date.now() + constants_1.ANILIST_COOLDOWN_MS;
+            this.logger.warn('[airing] AniList 返回 %d（%s），暂停查询 %d 分钟，期间沿用已有数据', status, status === 429 ? '超出速率限制' : 'API 被临时停用', constants_1.ANILIST_COOLDOWN_MS / 60000);
             return true;
         }
         this.logger.debug('[airing] AniList 查询失败（本次不判定完结）: %s', (0, utils_1.errorMessage)(error));
@@ -276,5 +273,3 @@ class AiringStatusService {
     }
 }
 exports.AiringStatusService = AiringStatusService;
-/** 收到 429 / 403 后的冷却时长 */
-const ANILIST_COOLDOWN_MS = 5 * 60 * 1000;