gacha-calendar-core 0.10.6 → 0.10.7

package/core.mjs

@@ -4,7 +4,7 @@
 		// 用途：缓存里记录"这份数据是哪版插件产出的"。更新插件后首次启动，据此**强制**刷新一次
 		// （不看自动刷新开关）——因为有些改动（悬停格式、来源地址、样式、解析器）不刷新就看不到效果。
 		// 写入时机见 engine-api.js 的 refresh()；判定见 60-helpers.js 的 autoRefreshPlan()。
-		const PLUGIN_VERSION = "0.10.6";
+		const PLUGIN_VERSION = "0.10.7";
 		//#endregion
 
 		//#region config
@@ -1165,17 +1165,36 @@ export function createEngine(env) {
 
 		// 选当期：优先"起始明确且覆盖 now"的主池；
 		// 其次"起始未知（版本更新后）但结束在未来"的主池（星铁/zzz 上半，此时起始已被 fillMissingStarts 补齐）；
-		// 同期多张主池（如 104期+104-2期）合并角色。返回 null 时调用方回退内置数据。
+		// **当期多个主池的角色全部合并**（见下方合并说明）。返回 null 时调用方回退内置数据。
 		// bannerDates 为补全后用于倒计时的文本；bannerDatesRaw 为源站原文（悬停展示）。
 		function selectCurrent(items, now) {
+			// 先记下**补全前**哪些行的起点是"版本更新后"（startTs 原本为 null）。
+			// 为什么要记：fillMissingStarts 会用"上一组结束时间"去猜这类行的起点，
+			// 而那个猜测**并非总是对的** —— 星铁 4.6 上线时间期有两池：
+			//   「韶艾裁英」4.6版本更新后 ~ 10-21 11:59
+			//   「沧海萃珠」4.6版本更新后 ~ 11-10 15:00
+			// 两者同为"4.6 上线"，只是结束不同；按"上一组结束"补会把后者补成 10-21，
+			// 于是"起点已过"判定失败、它被踢出当期 —— 而它其实覆盖当前时刻
+			// （用户实测：卡片只显示绯英，真珠不见了）。
+			const hadOpenStart = new Set(items.filter((it) => it.startTs == null).map((it) => it));
 			fillMissingStarts(items);
-			const exact = items.filter((it) => it.startTs != null && it.startTs <= now && it.endTs != null && it.endTs >= now);
-			const loose = items.filter((it) => it.startTs == null && it.endTs != null && it.endTs >= now);
-			const pool = (exact.length > 0 ? exact : loose).filter((it) => it.isMain);
+			const inWindow = (it) => it.endTs != null && it.endTs >= now
+				&& (it.startTs == null ? true : it.startTs <= now || hadOpenStart.has(it));
+			// 说明最后一个条件：起点原本为 null（写作"版本更新后"）的行，**一定已经开始**——
+			// 源站表只列**已发布版本**的排期，"X.Y版本更新后"里的 X.Y 必已上线，
+			// 所以它的真实起点在版本更新那天（≤ now），补出来的那个值不可信、不应用来判"未开始"。
+			// 注意这里**不覆盖**补全后的 startTs：显示（bannerDates 等）仍用补出来的窗口，
+			// 悬停也仍显示源站原文"4.6版本更新后 ~ …"，不编造日期。
+			const pool = items.filter(inWindow).filter((it) => it.isMain);
 			if (pool.length === 0) return null;
-			const first = pool[0];
-			const sameRange = pool.filter((it) => it.startTs === first.startTs && it.endTs === first.endTs);
-			const roles = [...new Set(sameRange.map((it) => cleanRoles(it.roles)).filter(Boolean))].join("、");
+			// 外显取哪个池的"名字与时间"：结束最早的（越快结束越该被盯住）。
+			//
+			// ⚠️ 合并条件（用户要求，2026-09-30 改）：
+			//   旧 = 起止**完全相同**才合并 → 星铁同期两池结束不同就只合到自己，
+			//        卡片只显示一个池的角色。
+			//   新 = **当前时刻落在其持续区间内的主池全部合并**（就是这个 `pool`）。
+			const first = pool.slice().sort((a, b) => a.endTs - b.endTs)[0];
+			const roles = [...new Set(pool.map((it) => cleanRoles(it.roles)).filter(Boolean))].join("、");
 			return {
 				banner: first.banner,
 				roles,
@@ -1794,7 +1813,15 @@ export function createEngine(env) {
 				const d = new Date(iso);
 				return `${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")} ${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
 			};
-			// 1) 当期 d：windows 覆盖当前 → 直接用
+			// **统一规则（§49）**：当前时刻落在持续期间内的卡池**全部合并**外显。
+			// 旧实现是"两个分支各自命中第一个就 return" → 只显示一个池，同期的另一个池看不到
+			// （用户实测：终末地外显没合并）。现在先把两类候选都收集起来再合并。
+			//
+			// ⚠️ 这条路径**不走 `selectCurrent`**（canmoe 的 chunk 是压缩 JS，得单独解析），
+			// 所以 §49 改 `selectCurrent` 时漏了这里 —— 教训：改"通用规则"要**枚举所有外显路径**，
+			// 不能只改名字最像的那个函数。
+			const active = [];
+			// 1) 当期 d：windows 覆盖当前 → 收进来
 			const curM = js.match(/\bd=\{(.+?)\},\s*u=\[/);
 			if (curM) {
 				sawStructure = true;
@@ -1803,10 +1830,12 @@ export function createEngine(env) {
 				const roles = featuredM ? featuredM[1].trim() : "";
 				for (const w of inner.matchAll(/windows\s*:\s*\[\s*\{\s*start\s*:\s*"([^"]+)"\s*,\s*end\s*:\s*"([^"]+)"\s*,\s*version\s*:\s*"([^"]+)"\s*,\s*period\s*:\s*(\d+)\s*,\s*isRerun\s*:\s*(!0|!1|true|false)\s*\}\s*\]/g)) {
 					const a = new Date(w[1]).getTime(), b = new Date(w[2]).getTime();
-					if (a <= now && now <= b) return { banner: `\u3010${w[3]}\u3011${roles}`, roles, bannerDates: `${fmt(w[1])} ~ ${fmt(w[2])}` };
+					if (a <= now && now <= b) {
+						active.push({ banner: `\u3010${w[3]}\u3011${roles}`, roles, startTs: a, endTs: b, dates: `${fmt(w[1])} ~ ${fmt(w[2])}`, raw: `${fmt(w[1])} ~ ${fmt(w[2])}` });
+					}
 				}
 			}
-			// 2) p 数组中的"当前进行中"条目（过期当期后以此为兜底）
+			// 2) p 数组中的"当前进行中"条目（过期当期后以此为兜底）—— 同样**全部收**，不是取第一个
 			const arr = extractCanmoePeriods(js);
 			if (arr) {
 				sawStructure = true;
@@ -1815,15 +1844,28 @@ export function createEngine(env) {
 					const pe = (e.match(/periodEnd\s*:\s*"([^"]*)"/) || [])[1];
 					if (!ps || !pe) continue;
 					const a = new Date(ps).getTime(), b = new Date(pe).getTime();
-					if (a <= now && now <= b) {
-						const title = (e.match(/title\s*:\s*"([^"]*)"/) || [])[1] || "";
-						const subtitle = (e.match(/subtitle\s*:\s*"([^"]*)"/) || [])[1] || "";
-						const version = (e.match(/version\s*:\s*"([^"]*)"/) || [])[1] || "";
-						const roles = subtitle || title;
-						return { banner: title || `\u3010${version}\u3011${subtitle}`, roles, bannerDates: `${fmt(ps)} ~ ${fmt(pe)}`, bannerDatesRaw: `${fmt(ps)} ~ ${fmt(pe)}` };
-					}
+					if (!(a <= now && now <= b)) continue;
+					const title = (e.match(/title\s*:\s*"([^"]*)"/) || [])[1] || "";
+					const subtitle = (e.match(/subtitle\s*:\s*"([^"]*)"/) || [])[1] || "";
+					const version = (e.match(/version\s*:\s*"([^"]*)"/) || [])[1] || "";
+					active.push({
+						banner: title || `\u3010${version}\u3011${subtitle}`,
+						roles: subtitle || title,
+						startTs: a, endTs: b,
+						dates: `${fmt(ps)} ~ ${fmt(pe)}`, raw: `${fmt(ps)} ~ ${fmt(pe)}`
+					});
 				}
 			}
+			if (active.length > 0) {
+				// 外显名与窗口取**结束最早**的那个池（越快结束越该被盯住；与 selectCurrent 的 first 同口径）
+				const first = active.slice().sort((x, y) => x.endTs - y.endTs)[0];
+				return {
+					banner: first.banner,
+					roles: [...new Set(active.map((p) => p.roles).filter(Boolean))].join("、"),
+					bannerDates: first.dates,
+					bannerDatesRaw: first.raw
+				};
+			}
 			// 结构在但没覆盖当前时刻 → null（未公布）；连结构都没有 → undefined（页面改版，交上层决定）
 			return sawStructure ? null : void 0;
 		}
@@ -2034,7 +2076,64 @@ export function createEngine(env) {
 			return null;
 		}
 
-		// 解析官网公告正文 → 当期卡池（全新限定S级角色所属限定棋盘）+ 当期活动（限时活动）
+		// 异环公告里的「棋盘」条目解析（角色卡池）。
+		//
+		// 为什么从**「棋盘」**入手（用户建议，2026-09-30）：
+		//   异环的角色卡池在公告里叫「X」**限定棋盘**，条目形如
+		//     ● 全新限定S级角色「黑羽」
+		//     开放时间：9月24日版本更新后-10月15日05:59
+		//     棋盘说明：可通过「预言终幕时」限定棋盘获得S级角色「黑羽」。…
+		//   `棋盘说明` 是**角色卡池独有的锚点** —— 弧盘走 `研募说明`、剧情段没有这个字段。
+		//   用「有棋盘说明」筛，比用"全新限定S级角色"精确：后者漏掉**返场**（`限定S级角色「安魂曲」返场`，
+		//   没有"全新"二字），而那也是一张在开的角色池。
+		//
+		// 旧实现只认 `全新限定S级角色「X」…开放时间：N月N日**维护**更新后-…` 一条正则，
+		// 而现公告写的是 `**版本**更新后` → 一条都匹配不上 → 卡池为空 → `if (!data.banner) return null`
+		// → `fetchNteWanmei` 继续往下试，最终拿 index1 页那篇**已过期**的旧公告冒充当期。
+		function parseNteBoards(text, nowYear) {
+			const lines = text.split("\n").map((l) => l.trim());
+			// 「一、 全新角色&弧盘」这一段的边界（只在这里找，避免匹配到别处的"开放时间"）
+			const start = lines.findIndex((l) => /^一、/.test(l));
+			if (start < 0) return [];
+			let end = lines.findIndex((l, i) => i > start && /^二、/.test(l));
+			if (end < 0) end = lines.length;
+			const pools = [];
+			for (let i = start; i < end; i++) {
+				const m = lines[i].match(/^●\s*(?:全新)?(限定S级角色|S级角色)「([^」]+)」(返场)?/);
+				if (!m) continue;
+				// 往后找该条目的「开放时间」与「棋盘说明」（各限 8 行内）
+				let range = null, board = "";
+				for (let j = i + 1; j < Math.min(end, i + 8); j++) {
+					if (!range) {
+						const t = lines[j].match(/^开放时间：(\d+)月(\d+)日(?:(?:维护|版本)更新后|(\d{1,2}):(\d{2}))\s*[-–—]\s*(\d+)月(\d+)日(\d{1,2}):(\d{2})/);
+						if (t) {
+							range = {
+								sMo: +t[1], sD: +t[2], sH: t[3] ? +t[3] : 11, sMi: t[4] ? +t[4] : 0,
+								eMo: +t[5], eD: +t[6], eH: +t[7], eMi: +t[8]
+							};
+						}
+					}
+					if (!board) {
+						const b = lines[j].match(/棋盘说明：可通过「([^」]+)」限定棋盘获得/);
+						if (b) board = b[1];
+					}
+				}
+				// **有棋盘说明才是角色卡池**（弧盘那条走研募说明，会在这里被排除）
+				if (!range || !board) continue;
+				pools.push({
+					name: board,
+					// 类型：`全新限定S级角色` → 限定棋盘；`限定S级角色…返场` → 返场限定棋盘。
+					// 注意 `限定` 属于**类型的一部分**，不是动词/修饰（与国服"更新限时限定招募"同理）。
+					type: `${m[3] ? "返场" : ""}限定棋盘`,
+					roles: baRoleName(m[2]),
+					startTs: new Date(nowYear, range.sMo - 1, range.sD, range.sH, range.sMi).getTime(),
+					endTs: new Date(nowYear, range.eMo - 1, range.eD, range.eH, range.eMi).getTime()
+				});
+			}
+			return pools;
+		}
+
+		// 解析官网公告正文 → 当期卡池（有「棋盘说明」的角色卡池，按**统一规则**合并）+ 当期活动（限时活动）
 		function parseNteWanmei(html) {
 			const text = String(html || "")
 				.replace(/<script[\s\S]*?<\/script>/gi, " ")
@@ -2044,17 +2143,24 @@ export function createEngine(env) {
 				.replace(/\n\s*\n+/g, "\n").trim();
 			const fmt = (mo, d, h, mi) => `${String(mo).padStart(2, "0")}-${String(d).padStart(2, "0")} ${String(h).padStart(2, "0")}:${String(mi).padStart(2, "0")}`;
 			const data = { banner: "", roles: "", bannerDates: "", bannerDatesRaw: "", event: "", eventDates: "", eventDatesRaw: "" };
-			// 当期卡池：全新限定S级角色「X」→「Y」限定棋盘, 开放时间 M月D日维护更新后-M月D日05:59
-			const newRole = text.match(/全新限定S级角色「([^」]+)」[\s\S]{0,400}?可通过「([^」]+)」限定棋盘获得[\s\S]{0,300}?开放时间：(\d+)月(\d+)日维护更新后-(\d+)月(\d+)日05:59/);
-			if (newRole) {
-				const mo = +newRole[3], d = +newRole[4], emo = +newRole[5], ed = +newRole[6];
-				data.banner = `「${newRole[2]}」限定棋盘`;
-				data.roles = newRole[1];
-				data.bannerDates = `${fmt(mo, d, 11, 0)} ~ ${fmt(emo, ed, 5, 59)}`;
+			// 当期卡池：**按统一规则**——当前时刻落在开放期间内的「棋盘」全部合并外显。
+			// 卡片/悬停都走 banner + roles（与其它游戏一致）：类型进 `banner`，
+			// 悬停由面板兜底显示 `类型：角色` + 日期。**不构造 bannerHover**（同国服，见 §48.3d）。
+			const now = nowMs();
+			const nowYear = new Date(now).getFullYear();
+			const active = parseNteBoards(text, nowYear)
+				.filter((p) => p.endTs >= now && p.startTs <= now)
+				.sort((a, b) => a.endTs - b.endTs);
+			if (active.length > 0) {
+				data.banner = [...new Set(active.map((p) => p.type))].join(" & ");
+				data.roles = [...new Set(active.map((p) => p.roles).filter(Boolean))].join("、");
+				// 窗口取结束最早的那个（与 selectCurrent 的 `first` 同口径）
+				const first = active[0];
+				data.bannerDates = `${fmt(new Date(first.startTs).getMonth() + 1, new Date(first.startTs).getDate(), new Date(first.startTs).getHours(), new Date(first.startTs).getMinutes())} ~ ${fmt(new Date(first.endTs).getMonth() + 1, new Date(first.endTs).getDate(), new Date(first.endTs).getHours(), new Date(first.endTs).getMinutes())}`;
 				data.bannerDatesRaw = data.bannerDates;
 			}
-			// 当期活动：「X」限时活动 活动时间：M月D日(维护更新后|hh:mm)-M月D日hh:mm
-			const ev = text.match(/「([^」]+)」限时活动[\s\S]{0,200}?活动时间：(\d+)月(\d+)日(?:维护更新后|(\d{2}):(\d{2}))-(\d+)月(\d+)日(\d{2}):(\d{2})/);
+			// 当期活动：「X」限时活动 活动时间：M月D日(维护|版本)更新后|hh:mm-M月D日hh:mm
+			const ev = text.match(/「([^」]+)」限时活动[\s\S]{0,200}?活动时间：(\d+)月(\d+)日(?:(?:维护|版本)更新后|(\d{1,2}):(\d{2}))\s*[-–—]\s*(\d+)月(\d+)日(\d{1,2}):(\d{2})/);
 			if (ev) {
 				const sMo = +ev[2], sD = +ev[3], sH = ev[4] ? +ev[4] : 11, sMi = ev[5] ? +ev[5] : 0;
 				const eMo = +ev[6], eD = +ev[7], eH = +ev[8], eMi = +ev[9];
@@ -3034,9 +3140,49 @@ export function createEngine(env) {
 				.replace(/&ldquo;/g, "「").replace(/&rdquo;/g, "」")
 				.replace(/&hellip;/g, "…").replace(/&times;/g, "×").replace(/&bull;/g, "·")
 				.replace(/\n\s*\n+/g, "\n").trim();
-			// 当期卡池名（第一个"更新限时招募【X】"或复刻）
-			const bannerM = text.match(/更新限时招募【([^】]+)】/);
-			const bannerR = text.match(/更新限时复刻招募【([^】]+)】/);
+			return parseBaCnMaintText(text, nowYear);
+		}
+		// 国服公告里「招募」开头的东西**不是一类**。实测（09月24日维护更新说明）：
+		//   更新限时限定招募【秩序隐匿于粼粼波光中】   ← 限定角色卡池（当期主卡池）
+		//   更新限时限定招募【思绪飘散在漫漫夏夜里】   ← 限定角色卡池（同期第二池）
+		//   更新限时招募活动【100次免费招募】          ← 免费招募**活动**（不是卡池）
+		//   更新限时招募活动【3★必得招募】            ← 必得**活动**
+		//   更新限时招募活动【3★限定成员必得招募】    ← 限定必得**活动**
+		//   更新限时招募活动【3★自选招募】            ← 自选**活动**
+		// 关键区分点在**词序**：`…招募【` 后面紧跟 `】` 的是**卡池名**；
+		//   而 `招募活动【` 是"招募"作定语去修饰"活动"，是**活动**。
+		// 曾经的糟糕修法是"把所有 招募 塞进一条正则按出现顺序取第一条" —— 那等于把
+		// 限定卡池与招募活动混成同一类（用户指出）。这里按类型分级取，并显式排除活动类。
+		const BA_CN_CHAR_POOL_RE = /^更新限时(限定复刻|限定|复刻|)招募$/;
+		// 档位：限定角色池 > 普通角色池 > 限定复刻池 > 复刻池（数值越小越优先）
+		const BA_CN_POOL_RANK = { 限定: 0, "": 1, 限定复刻: 2, 复刻: 3 };
+
+		function baCnPoolInfo(line) {
+			const m = line.match(/更新限时([^【]*)【([^】]+)】/);
+			if (!m) return null;
+			const t = BA_CN_CHAR_POOL_RE.exec(`更新限时${m[1]}`);
+			return { isPool: !!t, kind: t ? t[1] : "", name: m[2] };
+		}
+
+		// 国服维护公告正文 → 卡池/活动数据（纯函数：只吃**已清洗的文本**，不碰网络）。
+		// 抽出来是为了能用合成文本精确回归 —— 这个源的坑全在措辞（见上面类型表），
+		// 而措辞能不能认出来只能靠测解析，靠抓线上只能"等它坏了才发现"。
+		// 无角色卡池时返回 null（调用方据此判"未公布"）。
+		function parseBaCnMaintText(text, nowYear) {
+			// 卡池识别分两步：① 挑出**角色卡池**（排除招募活动）；② 按档位选外显那一类。
+			//
+			// WHY 不能只认一种写法：措辞漂移过。旧写法 `更新限时招募【X】` 曾一度**一处都没有**
+			//   （实测 0 处），当前正文用的是 `更新限时限定招募【X】`。老代码只认旧写法 →
+			//   banner 为空 → 末尾 `if (!data.banner) return null` 把整条记录判死，
+			//   表现为卡池与活动**两列同时**「无匹配/未公布」（两列共用本函数）。
+			const bannerPools = [];
+			for (const line of text.split("\n")) {
+				const info = baCnPoolInfo(line);
+				if (info && info.isPool) bannerPools.push({ ...info, line });
+			}
+			// 按（档位, 出现顺序）取最优：稳定排序即可，因为 bannerPools 已按文档顺序收集
+			bannerPools.sort((a, b) => (BA_CN_POOL_RANK[a.kind] ?? 9) - (BA_CN_POOL_RANK[b.kind] ?? 9));
+			const bannerPool = bannerPools[0] || null;
 			// 当期活动名（第一个"更新限时活动【X】"）
 			const eventM = text.match(/更新限时活动【([^】]+)】/);
 			// 维护开始时间 "08月20日 14:00"
@@ -3053,37 +3199,56 @@ export function createEngine(env) {
 				const eEnd = new Date(nowYear, mo - 1, d + 28, 13, 59);
 				eventDates = `${start} ~ ${fmt(eEnd.getMonth() + 1, eEnd.getDate(), eEnd.getHours(), eEnd.getMinutes())}`;
 			}
-			// 公告里同期全部招募池（更新限时招募 / 更新限时限定复刻招募 / 更新限时复刻招募）：
-			// 池名 + 该行成员名，如
+			// 公告里同期**全部角色卡池**（只含卡池，不含招募活动）：池名 + 该行成员名，如
 			// 2、更新限时招募【夏日思绪长…】，…全新3★成员「桔梗（泳装）」、2★成员「莲华（泳装）」登场
-			const recPools = [];
-			for (const m of text.matchAll(/更新限时(?:限定复刻|复刻|)招募【([^】]+)】([^\n]*)/g)) {
-				const members = [...new Set([...m[2].matchAll(/(?:\d★)?(?:限定)?成员\s*[「“"]([^」”"]+)[」”"]/g)].map((x) => baRoleName(x[1].trim())).filter(Boolean))];
-				recPools.push({ name: m[1], members });
-			}
-			// 外显：合并同期各池成员（与其它游戏"同窗口角色合并"一致；此前只取第一个池的成员，导致外显不全）
-			const roleNames = [...new Set(recPools.flatMap((p) => p.members))];
+			const recPools = bannerPools.map((p) => {
+				const members = [...new Set([...p.line.matchAll(/(?:\d★)?(?:限定)?成员\s*[「“"]([^」”"]+)[」”"]/g)].map((x) => baRoleName(x[1].trim())).filter(Boolean))];
+				return { name: p.name, kind: p.kind, members };
+			});
+			// ---- 外显 = **卡池类型**（对齐国际服「特選招募」的呈现方式），不是某个池名 ----
+			//
+			// WHY 改成显示类型（用户要求，2026-09-30）：国服一期公告常同时开**同类多个池**
+			//   （当期两个「限定招募」），只显示第一个池名会漏掉另一个池；而卡池类型才是
+			//   "这一期在开什么"的稳定答案。国际服走结构化日程表，外显本来就是类别（`特選招募`），
+			//   这里对齐它。
+			// 同类型多池的**角色合并**展示（同国际服 roles 的做法）；悬停只列同类型那些池，
+			// 不把其它档位的池混进来（否则"显示限定招募、悬停却列着复刻池"自相矛盾）。
+			//
+			// 类型只放在 `banner` 里（悬停第一行会显示它，与国际服 `特選招募` 的位置一致）。
+			// **不另外加 `bannerKind` 字段**：面板卡片格的规则是"有角色就显示角色"，
+			// 而 core 的 Result JSON 是冻结契约、字段白名单外的会被丢掉（实测过），
+			// 想让卡片显示类型就得改契约。用户 2026-09-30 选择方案 A（类型只进悬停），
+			// 故这里不留没有消费者的字段。
+			const bannerKind = bannerPool ? bannerPool.kind : null;
+			// 类型名 = **限时[限定][复刻]招募** —— 注意**不带 `更新`**。
+			//
+			// 公告原文是 `2、更新限时限定招募【秩序隐匿于粼粼波光中】`，断句是：
+			//   「更新」= 公告的动词（这期更新了什么），「限时限定招募」= 卡池类型。
+			// 我最初写成 `更新限时${kind}招募`（`更新限时限定招募`）是把动词也吞进了类型名——
+			// 卡池不叫"更新限时限定招募"，就叫"限时限定招募"（用户指出）。
+			const bannerTypeName = bannerPool ? `限时${bannerKind}招募` : "";
+			const sameKindPools = bannerPool ? recPools.filter((p) => p.kind === bannerKind) : [];
+			const roleNames = [...new Set(sameKindPools.flatMap((p) => p.members))];
 			const data = {
-				banner: bannerM ? bannerM[1] : (bannerR ? `复刻·${bannerR[1]}` : ""),
+				banner: bannerTypeName,
 				roles: roleNames.join("、"),
 				bannerDates,
 				event: eventM ? eventM[1] : "",
 				eventDates
 			};
-			// 卡池列悬停：每池"池名：成员"一行；公告只给整期维护窗口 → 各池窗口相同，时间按"相同窗口合并"只在末尾写一遍
-			if (maintM) {
-				const mo = Number(maintM[1]), d = Number(maintM[2]);
-				const sTs = new Date(nowYear, mo - 1, d, Number(maintM[3]), Number(maintM[4])).getTime();
-				const eTs = new Date(nowYear, mo - 1, d + 14, 13, 59).getTime();
-				const hover = buildPoolHover(recPools.map((p) => ({
-					name: p.name,
-					label: `${p.name}${p.members.length ? `\uFF1A${p.members.join("、")}` : ""}`,
-					startTs: sTs,
-					endTs: eTs,
-					raw: bannerDates
-				})));
-				if (hover) data.bannerHover = hover;
-			}
+			// 卡池列悬停：**不单独构造 `bannerHover`**（用户要求"悬停显示卡池类型"，2026-09-30）。
+			//
+			// 原因：国服的"类型"已经在 `banner` 里（如 `更新限时限定招募`），而面板的悬停规则是
+			//   `title = withFailNote(g.bannerHover || gachaTitle, …)`
+			//   `gachaTitle = (g.roles ? `${g.banner}：${g.roles}` : g.banner) + 日期`
+			// 所以**不设 bannerHover 时，悬停自然就是**
+			//   `更新限时限定招募：莲见(泳装)、圣娅(泳装)`
+			//   `09-24 14:00 ~ 10-08 13:59`
+			// —— 已含类型，且类型与卡片口径一致。
+			//
+			// 曾试过"每池一行、以类型开头"，但国服一期常开**同类多池**，那样会输出多行**完全一样**
+			// 的文字（只有成员不同）；而按类型归并成一条后，`buildPoolHover` 对 0/1 池返回空串
+			// （全站共用的兜底约定）。结论：这里根本不需要 bannerHover，交给 UI 的兜底更准。
 			if (!data.banner) return null;
 			return data;
 		}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gacha-calendar-core",
-  "version": "0.10.6",
+  "version": "0.10.7",
   "description": "二游活动/卡池排期抓取核心：11 款游戏的来源注册表 + 解析器 + 刷新编排 + 缓存降级。零依赖、零宿主环境依赖，任何 JS 运行时（浏览器扩展 background / Tauri / JavaScriptCore / ArkTS 嵌入式引擎）都能跑。",
   "type": "module",
   "main": "./core.mjs",