@bilibili-notify/dynamic 0.0.1-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Akokko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/lib/index.cjs

@@ -0,0 +1,556 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _bilibili_notify_internal = require("@bilibili-notify/internal");
+let cron = require("cron");
+let luxon = require("luxon");
+//#region src/types.ts
+let DynamicFilterReason = /* @__PURE__ */ function(DynamicFilterReason) {
+	DynamicFilterReason["BlacklistKeyword"] = "blacklist-keyword";
+	DynamicFilterReason["BlacklistForward"] = "blacklist-forward";
+	DynamicFilterReason["BlacklistArticle"] = "blacklist-article";
+	DynamicFilterReason["WhitelistUnmatched"] = "whitelist-unmatched";
+	return DynamicFilterReason;
+}({});
+//#endregion
+//#region src/dynamic-filter.ts
+function collectRichText(dynamic, texts) {
+	const richTextNodes = dynamic.modules?.module_dynamic?.desc?.rich_text_nodes;
+	if (richTextNodes?.length) texts.push(richTextNodes.map((n) => n.text ?? "").join(""));
+	const summaryNodes = dynamic.modules?.module_dynamic?.major?.opus?.summary?.rich_text_nodes;
+	if (summaryNodes?.length) texts.push(summaryNodes.map((n) => n.text ?? "").join(""));
+	const title = dynamic.modules?.module_dynamic?.major?.opus?.title;
+	if (title) texts.push(title);
+	const archiveTitle = dynamic.modules?.module_dynamic?.major?.archive?.title;
+	if (archiveTitle) texts.push(archiveTitle);
+}
+function getDynamicText(dynamic) {
+	const texts = [];
+	collectRichText(dynamic, texts);
+	if (dynamic.orig) collectRichText(dynamic.orig, texts);
+	return texts.join("\n");
+}
+const MAX_REGEX_TEST_TEXT_LEN = 1e4;
+function safeRegexTest(pattern, text, logger) {
+	if (!pattern) return false;
+	const check = (0, _bilibili_notify_internal.checkUserRegex)(pattern);
+	if (!check.ok) {
+		logger?.warn(`[bilibili-notify-dynamic] 拒绝执行正则(${check.reason}):"${pattern.slice(0, 80)}"`);
+		return false;
+	}
+	try {
+		const subject = text.length > MAX_REGEX_TEST_TEXT_LEN ? text.slice(0, MAX_REGEX_TEST_TEXT_LEN) : text;
+		return new RegExp(pattern).test(subject);
+	} catch (e) {
+		logger?.warn(`[bilibili-notify-dynamic] 无效的正则表达式 "${pattern}": ${e.message}`);
+		return false;
+	}
+}
+function testKeywordMatched(text, keywords) {
+	if (!keywords?.length) return false;
+	return keywords.some((kw) => kw && text.includes(kw));
+}
+function filterDynamic(dynamic, config, logger) {
+	const cfg = {
+		enable: false,
+		regex: "",
+		keywords: [],
+		forward: false,
+		article: false,
+		whitelistEnable: false,
+		whitelistRegex: "",
+		whitelistKeywords: [],
+		...config
+	};
+	const text = getDynamicText(dynamic);
+	if (cfg.enable) {
+		if (cfg.forward && dynamic.type === "DYNAMIC_TYPE_FORWARD") return {
+			blocked: true,
+			reason: "blacklist-forward"
+		};
+		if (cfg.article && dynamic.type === "DYNAMIC_TYPE_ARTICLE") return {
+			blocked: true,
+			reason: "blacklist-article"
+		};
+		if (safeRegexTest(cfg.regex, text, logger) || testKeywordMatched(text, cfg.keywords)) return {
+			blocked: true,
+			reason: "blacklist-keyword"
+		};
+	}
+	if (cfg.whitelistEnable) {
+		if ((!!cfg.whitelistRegex || cfg.whitelistKeywords.length > 0) && !safeRegexTest(cfg.whitelistRegex, text, logger) && !testKeywordMatched(text, cfg.whitelistKeywords)) return {
+			blocked: true,
+			reason: "whitelist-unmatched"
+		};
+	}
+	return { blocked: false };
+}
+//#endregion
+//#region src/dynamic-engine.ts
+const LOG_TAG = "bilibili-notify-dynamic";
+/**
+* 风控/瞬时错误停 cron 后的退避重启间隔。原实现:任何非鉴权错误(-509 限流、
+* 瞬时 -403、未知码)都永久 stop cron 且唯一重启路径 `auth-restored` 不会触发
+* → 动态轮询永久静默直到重启进程。退避后自动重探,瞬时错误/`bili cap` 解风控
+* 后即自愈,无需人工重启进程。
+*/
+const DETECTOR_RESTART_BACKOFF_MS = 5 * 6e4;
+/** 从动态数据中提取图片 URL，用于多模态 AI 点评（最多 4 张） */
+function extractDynamicImages(item) {
+	const mod = item.modules.module_dynamic;
+	const urls = [];
+	if (mod.major?.draw?.items) {
+		for (const img of mod.major.draw.items) if (typeof img.src === "string" && img.src) urls.push(img.src);
+	}
+	if (mod.major?.opus?.pics) {
+		for (const pic of mod.major.opus.pics) if (typeof pic.url === "string" && pic.url) urls.push(pic.url);
+	}
+	const archiveCover = mod.major?.archive?.cover;
+	if (typeof archiveCover === "string" && archiveCover) urls.push(archiveCover);
+	return urls.slice(0, 4);
+}
+/** 从动态数据中提取纯文本内容，用于 AI 点评 */
+function extractDynamicText(item) {
+	const mod = item.modules.module_dynamic;
+	const parts = [];
+	if (mod.desc?.text) parts.push(mod.desc.text);
+	if (mod.major?.opus?.summary?.text) {
+		if (mod.major.opus.title) parts.push(`标题：${mod.major.opus.title}`);
+		parts.push(mod.major.opus.summary.text);
+	}
+	if (mod.major?.archive?.title) parts.push(`视频标题：${mod.major.archive.title}`);
+	if (item.orig) {
+		const origMod = item.orig.modules?.module_dynamic;
+		const origAuthor = item.orig.modules?.module_author?.name;
+		const origParts = [];
+		if (origMod?.desc?.text) origParts.push(origMod.desc.text);
+		if (origMod?.major?.opus?.summary?.text) origParts.push(origMod.major.opus.summary.text);
+		if (origMod?.major?.archive?.title) origParts.push(`视频标题：${origMod.major.archive.title}`);
+		if (origParts.length > 0) parts.push(`（转发自 ${origAuthor ?? "未知"}：${origParts.join(" ")}）`);
+	}
+	return parts.join("\n").trim();
+}
+/**
+* 平台中立的动态轮询/过滤/渲染核心。
+*
+* - 不依赖 koishi runtime；adapter 提供 ServiceContext / MessageBus / PushLike。
+* - image / ai 通过 **构造期注入**（不在 detect 循环内做服务查找），缺失时降级。
+* - 时间线、过滤、API 错误处理逻辑与原 koishi 版 BilibiliNotifyDynamic 一致。
+*/
+var DynamicEngine = class {
+	serviceCtx;
+	bus;
+	api;
+	push;
+	image;
+	ai;
+	logger;
+	getSubs;
+	config;
+	dynamicJob;
+	/** 风控/瞬时错误后的一次性退避重启句柄;非 undefined 表示已排程,不叠加。 */
+	detectorRestartTimer;
+	/**
+	* -352 风控态边沿标记。进入风控只 error+DM+engine-error 一次;退避重探仍
+	* 风控 → debug(不重复告警);成功拉取(code 0)→ info 一次并清除。避免在
+	* 退避重试热路径反复刷 error(Q1)。
+	*/
+	riskControlled = false;
+	dynamicSubManager = /* @__PURE__ */ new Map();
+	dynamicTimelineManager = /* @__PURE__ */ new Map();
+	/** 连续图片渲染失败计数，达到阈值时仅通知一次但不停 cron */
+	imageFailureStreak = 0;
+	imageFailureNotified = false;
+	busHandles = [];
+	constructor(opts) {
+		this.serviceCtx = opts.serviceCtx;
+		this.bus = opts.bus;
+		this.api = opts.api;
+		this.push = opts.push;
+		this.image = opts.image;
+		this.ai = opts.ai;
+		this.config = opts.config;
+		this.getSubs = opts.getSubs;
+		this.logger = opts.serviceCtx.logger;
+	}
+	/** 启动钩子。Adapter 在 ServiceContext 就绪、订阅可访问后调用。 */
+	start() {
+		this.dynamicTimelineManager = /* @__PURE__ */ new Map();
+		const initial = this.getSubs();
+		this.logger.info(`[start] 动态引擎启动（${initial ? "订阅已就绪，立即启动检测" : "等待订阅数据"}）`);
+		if (initial) this.startDynamicDetector(initial);
+		else this.logger.debug("[start] 订阅尚未就绪，等待 subscription-changed 事件");
+		this.busHandles.push(this.bus.on("auth-restored", () => {
+			const subs = this.getSubs();
+			if (!subs) return;
+			this.logger.info("[detector] 收到 auth-restored，重启动态检测");
+			this.startDynamicDetector(subs);
+		}));
+		this.serviceCtx.onDispose(() => this.stop());
+	}
+	/** 停止钩子。停止 cron、释放事件订阅。 */
+	stop() {
+		this.riskControlled = false;
+		this.detectorRestartTimer?.dispose();
+		this.detectorRestartTimer = void 0;
+		if (this.dynamicJob) {
+			this.dynamicJob.stop();
+			this.dynamicJob = void 0;
+			this.logger.info("[stop] 动态检测任务已停止");
+		}
+		while (this.busHandles.length > 0) this.busHandles.pop()?.dispose();
+	}
+	/**
+	* 替换运行时配置(adapter 在 koishi config / dashboard 编辑后调用)。
+	* `dynamicCron` 变化时会自动停掉旧 CronJob 并按新表达式重新 schedule —— 否则
+	* 配置已经写进 this.config,但 node-cron 句柄还在跑旧节奏,纯粹的字段更新
+	* 是看不见的 bug。
+	*/
+	updateConfig(config) {
+		const cronChanged = this.config.dynamicCron !== config.dynamicCron;
+		this.config = config;
+		if (cronChanged && this.dynamicJob) {
+			this.logger.info(`[detector] dynamicCron 已更新为 "${config.dynamicCron}",重启检测任务`);
+			this.dynamicJob.stop();
+			this.dynamicJob = void 0;
+			if (this.dynamicSubManager.size > 0) this.startJob();
+		}
+	}
+	/**
+	* 热替换 CommentaryGenerator 实例。adapter 在用户运行时打开 / 关闭 / 更换 AI
+	* 配置后调用,引擎随后的动态点评会立即用新实例 (或回退到纯文字) ,无需重启 server。
+	*/
+	setAi(ai) {
+		this.ai = ai;
+	}
+	get isActive() {
+		return this.dynamicJob?.running ?? false;
+	}
+	/** 用最新订阅快照重启动态检测；保留已有 UID 的时间戳避免重推旧动态。 */
+	startDynamicDetector(subs) {
+		this.detectorRestartTimer?.dispose();
+		this.detectorRestartTimer = void 0;
+		if (this.dynamicJob) {
+			this.logger.info("[detector] 停止旧的动态检测任务");
+			this.dynamicJob.stop();
+			this.dynamicJob = void 0;
+		}
+		const dynamicSubManager = /* @__PURE__ */ new Map();
+		for (const sub of Object.values(subs)) if (sub.dynamic) {
+			if (!this.dynamicTimelineManager.has(sub.uid)) {
+				this.dynamicTimelineManager.set(sub.uid, Math.floor(luxon.DateTime.now().toSeconds()));
+				this.logger.debug(`[detector] 初始化 UID：${sub.uid} 时间戳`);
+			}
+			dynamicSubManager.set(sub.uid, sub);
+		}
+		for (const uid of this.dynamicTimelineManager.keys()) if (!dynamicSubManager.has(uid)) {
+			this.dynamicTimelineManager.delete(uid);
+			this.logger.debug(`[detector] 清理已移除 UID：${uid} 的时间戳`);
+		}
+		if (dynamicSubManager.size === 0) {
+			this.logger.info("[detector] 没有需要动态检测的订阅对象");
+			return;
+		}
+		this.logger.debug(`[detector] 动态检测 UID 列表：${[...dynamicSubManager.keys()].join(", ")}`);
+		this.dynamicSubManager = dynamicSubManager;
+		this.startJob();
+	}
+	startDynamicForUid(uid, sub) {
+		if (!this.dynamicTimelineManager.has(uid)) {
+			this.dynamicTimelineManager.set(uid, Math.floor(luxon.DateTime.now().toSeconds()));
+			this.logger.debug(`[ops] 初始化 UID：${uid} 时间戳`);
+		}
+		this.dynamicSubManager.set(uid, structuredClone(sub));
+		this.logger.debug(`[ops] 开启动态订阅 UID：${uid}`);
+	}
+	stopDynamicForUid(uid) {
+		if (!this.dynamicSubManager.has(uid)) return;
+		this.dynamicSubManager.delete(uid);
+		this.dynamicTimelineManager.delete(uid);
+		this.logger.debug(`[ops] 移除动态订阅 UID：${uid}`);
+	}
+	/**
+	* UID 是否仍订阅。detectDynamics 在 image/AI/broadcast 等多个 await 处挂起,
+	* `applyOps`(由 adapter 在 subscription-changed 时调,**不**在 withLock 内)
+	* 可在挂起期 stopDynamicForUid 删表。每个 dispatch / 时间线回写前用它重校,
+	* 否则会给已退订 UID 推送、并把其时间线“复活”进而长期抑制再订阅后的动态。
+	*/
+	stillSubscribed(uid, expected) {
+		if (!this.dynamicSubManager.has(uid)) return false;
+		return expected === void 0 || this.dynamicSubManager.get(uid) === expected;
+	}
+	/** Incrementally apply subscription ops without restarting the cron job. */
+	applyOps(ops) {
+		let jobNeedsReconcile = false;
+		let opened = 0;
+		let removed = 0;
+		for (const op of ops) switch (op.type) {
+			case "add":
+				if (!op.sub.dynamic) break;
+				this.startDynamicForUid(op.sub.uid, op.sub);
+				opened++;
+				jobNeedsReconcile = true;
+				break;
+			case "delete":
+				if (!this.dynamicSubManager.has(op.uid)) break;
+				this.stopDynamicForUid(op.uid);
+				removed++;
+				jobNeedsReconcile = true;
+				break;
+			case "update":
+				for (const change of op.changes) {
+					if (change.scope !== "dynamic") continue;
+					if (change.dynamic) {
+						const fullSub = this.getSubs()?.[op.uid];
+						if (fullSub) {
+							this.startDynamicForUid(op.uid, fullSub);
+							opened++;
+						}
+						jobNeedsReconcile = true;
+					} else if (change.dynamic === false) {
+						if (!this.dynamicSubManager.has(op.uid)) continue;
+						this.stopDynamicForUid(op.uid);
+						removed++;
+						jobNeedsReconcile = true;
+					}
+				}
+				break;
+		}
+		if (jobNeedsReconcile) {
+			this.logger.info(`[ops] 动态订阅变更已应用：+${opened} 开启 / -${removed} 移除（当前 ${this.dynamicSubManager.size} 个动态订阅）`);
+			this.reconcileJob();
+		}
+	}
+	startJob() {
+		this.dynamicJob = new cron.CronJob(this.config.dynamicCron, (0, _bilibili_notify_internal.withLock)(() => this.detectDynamics(), (err) => this.logger.error(`[detector] 动态检测执行异常：${err instanceof Error ? err.message : String(err)}`)));
+		this.dynamicJob.start();
+		this.logger.info("[detector] 动态检测任务已启动");
+	}
+	reconcileJob() {
+		if (this.dynamicSubManager.size === 0) {
+			if (this.dynamicJob?.running) {
+				this.dynamicJob.stop();
+				this.dynamicJob = void 0;
+				this.logger.info("[detector] 订阅清空，动态检测任务已停止");
+			}
+		} else if (!this.dynamicJob?.running) {
+			this.logger.debug(`[detector] 动态检测 UID 列表：${[...this.dynamicSubManager.keys()].join(", ")}`);
+			this.startJob();
+		}
+	}
+	async detectDynamics() {
+		this.logger.debug("[detector] 开始获取动态信息");
+		let content;
+		try {
+			content = await this.api.getAllDynamic();
+		} catch (e) {
+			this.logger.warn(`[api] 获取动态失败：${e instanceof Error ? e.message : String(e)}`);
+			return;
+		}
+		if (!content) return;
+		if (content.code !== 0) {
+			await this.handleApiError(content.code, content.message);
+			return;
+		}
+		if (this.riskControlled) {
+			this.riskControlled = false;
+			this.logger.info("[api] 风控已解除，动态检测恢复正常");
+		}
+		this.logger.debug("[detector] 成功获取动态信息，开始处理");
+		const okTs = {};
+		const failTs = {};
+		const markOk = (u, ts) => {
+			const arr = okTs[u];
+			if (arr) arr.push(ts);
+			else okTs[u] = [ts];
+		};
+		const markFail = (u, ts) => {
+			const arr = failTs[u];
+			if (arr) arr.push(ts);
+			else failTs[u] = [ts];
+		};
+		for (const item of content.data.items) {
+			if (!item) continue;
+			const postTime = item.modules.module_author.pub_ts;
+			if (typeof postTime !== "number" || !Number.isFinite(postTime)) {
+				this.logger.warn(`[detector] 跳过无效动态：pub_ts 缺失或非数字，ID=${item.id_str ?? "unknown"}`);
+				continue;
+			}
+			const uid = item.modules.module_author.mid.toString();
+			const name = item.modules.module_author.name;
+			const timeline = this.dynamicTimelineManager.get(uid);
+			if (timeline === void 0) continue;
+			this.logger.debug(`[detector] 检查动态 UP=${name} UID=${uid} 发布时间=${luxon.DateTime.fromSeconds(postTime).toFormat("yyyy-MM-dd HH:mm:ss")}`);
+			if (timeline >= postTime) continue;
+			const subAtCapture = this.dynamicSubManager.get(uid);
+			try {
+				const effFilter = this.dynamicSubManager.get(uid)?.filter ?? this.config.filter ?? {};
+				const filterResult = filterDynamic(item, effFilter, this.logger);
+				if (filterResult.blocked) {
+					this.logger.debug(`[filter] 动态 ID=${item.id_str} 被过滤，原因：${filterResult.reason}`);
+					if (effFilter.notify && this.stillSubscribed(uid, subAtCapture)) {
+						const msgs = {
+							["blacklist-keyword"]: `${name}发布了一条含有屏蔽关键字的动态`,
+							["blacklist-forward"]: `${name}转发了一条动态，已屏蔽`,
+							["blacklist-article"]: `${name}投稿了一条专栏，已屏蔽`,
+							["whitelist-unmatched"]: `${name}发布了一条不在白名单范围内的动态，已屏蔽`
+						};
+						try {
+							await this.push.broadcastDynamic(uid, [{
+								type: "text",
+								text: msgs[filterResult.reason]
+							}], "dynamic");
+						} catch (e) {
+							this.logger.warn(`[filter] 屏蔽提示发送失败(忽略,不重试以免重复轰炸): ${e.message}`);
+						}
+					}
+					markOk(uid, postTime);
+					continue;
+				}
+				const sub = this.dynamicSubManager.get(uid);
+				let buffer;
+				try {
+					if (this.image && this.config.imageEnabled !== false) buffer = await this.image.generateDynamicCard(item, sub?.customCardStyle?.enable ? sub.customCardStyle : void 0);
+				} catch (e) {
+					const err = e;
+					if (err.message === "直播开播动态，不做处理") {
+						markOk(uid, postTime);
+						continue;
+					}
+					this.imageFailureStreak++;
+					this.logger.error(`[image] 生成动态图片失败 (连续 ${this.imageFailureStreak} 次): ${err.message}`);
+					if (!this.imageFailureNotified) try {
+						await this.push.sendErrorMsg(`生成动态图片失败：${err.message}，已降级为纯文字推送，请检查图片插件状态`);
+						this.bus.emit("engine-error", LOG_TAG, `生成动态图片失败：${err.message}`);
+						this.imageFailureNotified = true;
+					} catch (notifyErr) {
+						this.logger.warn(`[image] 失败通知发送失败,下轮将重试通知: ${notifyErr.message}`);
+					}
+					buffer = void 0;
+				}
+				if (buffer) {
+					if (this.imageFailureStreak > 0) this.logger.info(`[image] 图片渲染已恢复（之前连续失败 ${this.imageFailureStreak} 次）`);
+					this.imageFailureStreak = 0;
+					this.imageFailureNotified = false;
+				}
+				let dUrl = "";
+				if (this.config.dynamicUrl) if (item.type === "DYNAMIC_TYPE_AV") {
+					const jumpUrl = item.modules.module_dynamic.major?.archive?.jump_url ?? "";
+					if (this.config.dynamicVideoUrlToBV) {
+						const bvMatch = jumpUrl.match(/BV[0-9A-Za-z]+/);
+						dUrl = bvMatch ? bvMatch[0] : "";
+					} else dUrl = `${name}发布了新视频：https:${jumpUrl}`;
+				} else dUrl = `${name}发布了一条动态：https://t.bilibili.com/${item.id_str}`;
+				let aiComment;
+				if (this.ai && this.config.aiEnabled !== false) {
+					const dynamicText = extractDynamicText(item);
+					if (dynamicText) {
+						const imageUrls = extractDynamicImages(item);
+						const subForAi = this.dynamicSubManager.get(uid);
+						this.logger.debug(`[ai] 开始生成动态点评，文本长度=${dynamicText.length}，图片数=${imageUrls.length}${subForAi?.aiOverride ? "，命中 per-UP override" : ""}`);
+						try {
+							aiComment = await this.ai.comment(`${name}发布了一条动态，内容如下：\n${dynamicText}`, "dynamic", imageUrls, subForAi?.aiOverride);
+							this.logger.debug(`[ai] 动态点评生成完毕，长度=${aiComment?.length ?? 0}`);
+						} catch (e) {
+							this.logger.error(`[ai] AI 点评生成失败：${e.message}，回退到普通文字`);
+						}
+					} else this.logger.debug("[ai] 动态无可提取文本，跳过 AI 点评");
+				}
+				if (!this.stillSubscribed(uid, subAtCapture)) {
+					this.logger.debug(`[detector] UID=${uid} 在本轮处理中已退订/被替换，跳过推送`);
+					continue;
+				}
+				const textPart = aiComment ?? (dUrl || void 0);
+				const segments = buffer ? [{
+					type: "image",
+					buffer,
+					mime: "image/jpeg"
+				}, ...textPart ? [{
+					type: "text",
+					text: textPart
+				}] : []] : [{
+					type: "text",
+					text: aiComment ?? `${name}发布了一条动态${dUrl ? `：${dUrl}` : ""}`
+				}];
+				await this.push.broadcastDynamic(uid, segments, "dynamic");
+				if (this.config.pushImgsInDynamic && item.type === "DYNAMIC_TYPE_DRAW") {
+					const major = item.modules?.module_dynamic?.major;
+					const urls = [];
+					for (const it of major?.draw?.items ?? []) if (it.src) urls.push(it.src);
+					for (const pic of major?.opus?.pics ?? []) if (pic.url) urls.push(pic.url);
+					if (urls.length) await this.push.broadcastDynamic(uid, [{
+						type: "image-group",
+						forward: true,
+						urls
+					}], "dynamic-images");
+				}
+				markOk(uid, postTime);
+			} catch (e) {
+				markFail(uid, postTime);
+				this.logger.warn(`[detector] 推送失败 UID=${uid} ID=${item.id_str ?? "?"}：${e.message}`);
+			}
+		}
+		for (const uid of new Set([...Object.keys(okTs), ...Object.keys(failTs)])) {
+			if (!this.stillSubscribed(uid)) {
+				this.logger.debug(`[timeline] UID=${uid} 已退订，跳过时间线回写（不复活）`);
+				continue;
+			}
+			const fails = failTs[uid] ?? [];
+			const minFail = fails.length ? Math.min(...fails) : Number.POSITIVE_INFINITY;
+			const safeOks = (okTs[uid] ?? []).filter((t) => t < minFail);
+			if (safeOks.length === 0) continue;
+			const existing = this.dynamicTimelineManager.get(uid) ?? 0;
+			const next = Math.max(existing, ...safeOks);
+			if (next <= existing) continue;
+			this.dynamicTimelineManager.set(uid, next);
+			this.logger.debug(`[timeline] 更新时间线 UID=${uid} 时间=${luxon.DateTime.fromSeconds(next).toFormat("yyyy-MM-dd HH:mm:ss")}`);
+		}
+		this.logger.debug(`[detector] 本次成功处理 ${Object.keys(okTs).length} 个 UP 的动态`);
+	}
+	async handleApiError(code, message) {
+		this.dynamicJob?.stop();
+		this.dynamicJob = void 0;
+		switch (code) {
+			case -101:
+				this.logger.error("[api] 账号未登录，动态检测已停止（待 auth-restored 重启）");
+				this.bus.emit("engine-error", LOG_TAG, "账号未登录");
+				this.riskControlled = false;
+				break;
+			case -352:
+				if (!this.riskControlled) {
+					this.riskControlled = true;
+					this.logger.error("[api] 账号被风控，动态检测暂停，将退避后自动重试");
+					await this.push.sendPrivateMsg("账号被风控，请使用 `bili cap` 指令解除风控");
+					this.bus.emit("engine-error", LOG_TAG, "账号被风控");
+				} else this.logger.debug("[api] 仍处于风控态，退避后继续重探(不重复告警)");
+				this.scheduleDetectorRestart("风控");
+				break;
+			default:
+				this.logger.warn(`[api] 获取动态信息失败，错误码：${code}，${message}，将退避后自动重试`);
+				await this.push.sendPrivateMsg(`获取动态信息失败，错误码：${code}`);
+				this.bus.emit("engine-error", LOG_TAG, `获取动态失败，错误码：${code}`);
+				this.scheduleDetectorRestart(`错误码 ${code}`);
+		}
+	}
+	/**
+	* 风控/瞬时错误后排一次性退避重启。已有待执行的不叠加(`detectorRestartTimer`
+	* 非空即跳过)。到点取最新订阅快照重启检测;`stop()` / 显式 `startDynamicDetector`
+	* 会作废本计时(避免 dispose 后 / 重启后仍触发陈旧重启)。
+	*/
+	scheduleDetectorRestart(reason) {
+		if (this.detectorRestartTimer) return;
+		this.logger.info(`[detector] ${reason},将在 ${DETECTOR_RESTART_BACKOFF_MS / 1e3}s 后自动重试动态检测`);
+		this.detectorRestartTimer = this.serviceCtx.setTimeout(() => {
+			this.detectorRestartTimer = void 0;
+			const subs = this.getSubs();
+			if (!subs) {
+				this.logger.debug("[detector] 退避重启:订阅快照不可用,跳过本次(等下个触发)");
+				return;
+			}
+			this.logger.info("[detector] 退避计时到,重启动态检测");
+			this.startDynamicDetector(subs);
+		}, DETECTOR_RESTART_BACKOFF_MS);
+	}
+};
+//#endregion
+exports.DynamicEngine = DynamicEngine;
+exports.DynamicFilterReason = DynamicFilterReason;
+exports.filterDynamic = filterDynamic;