// ==UserScript==
// @name         Steam 游戏库展示
// @namespace    steam-game-library-viewer
// @author       Github: SmallRob，SteamID: Healer007
// @version      2.11.44
// @description  在 Steam 商店/社区页面增加中央游戏库模态面板（橱窗/个人展柜/时长/洞察/家庭组/系列分类/绝版/愿望单/PS会免/Epic赠送/年度大作/锁区/DLC收藏，支持卡片/横版封面/列表三种视图）和右侧个人信息面板侧滑栏（概览/洞察/社交/勋章/设置）。
// v2.11.44 修复(部分游戏小图标无法获取,如 app 4292950):Steam 社区小图标 CDN 路径已迁移——新游戏(含未发售)的社区图标不再发布到旧路径 cdn.{cloudflare,akamai}.steamstatic.com/steamcommunity/public/images/apps/{appid}/{hash}.jpg(实测 404),仅存在于新路径 shared.{fastly,akamai}.steamstatic.com/community_assets/images/apps/{appid}/{hash}.jpg;且此类新游戏常无任何商店封面资产(capsule_sm_120/header 全 404),社区图标是唯一可用图,旧代码"旧路径+capsule_sm_120 单级兜底"全链路失败。实测新路径对老游戏同样可用(TF2/440 新旧均 200)=超集。修复:①getGameIconUrl 有 hash 时主用 shared.fastly community_assets 新路径,并接入 icon:appid 成功缓存(getPosterGood kind='icon');②新增 communityIconChainUrls 统一图标回退链(新路径 fastly/akamai → 旧路径 cloudflare/akamai → capsule_sm_120 四 CDN 含 store_item_assets);③新增 _sglvIconFallback 页面级回退函数(对齐封面 _sglvPosterFallback 三段式:成功缓存→链式回退→header.jpg 兜底→隐藏),onload 记录成功 URL 避免重复试错;④_applyGameIcon 改走统一链;⑤替换 6 处硬编码内联 onerror(展柜近期游玩/SGIS 近期时间线/SGIS 入库时间线/愿望单列表/时长 Top20/全局搜索缩略图)为 _sglvIconFallback,消除散落的旧路径三元式与单级 capsule_sm_120 兜底,iconUrl 构造统一收敛到 getGameIconUrl;⑥hotfix(SGIS 概览页"用户档案获取失败: getGameIconUrl is not defined"→次日再报"getGameIconUrl is not a function"):getGameIconUrl 定义于主面板渲染子闭包,SGIS 为兄弟闭包不可直接引用(与 v2.11.38 xpPercent 同类作用域事故,ReferenceError 被 renderProfile 外层 catch 误报为档案获取失败)——SGIS 顶部 v2.4.1 别名块补 const getGameIconUrl = SGLV_API.getGameIconUrl 桥接;首版桥接遗漏关键一步:SGLV_API 此前从未导出过 getGameIconUrl(8830 行含 getGameIconUrl 的对象字面量实为收藏库桥 CollectionHost,非 SGLV_API——所有 SGLV_API 成员均为 17079+ 的逐条直接赋值),别名把 undefined 固化进 const → 渲染时报 not a function;本版补 SGLV_API.getGameIconUrl = getGameIconUrl 导出(17089 导出块,先于 SGIS 求值),并新增"导出存在+先于 SGIS 段+别名存在+调用后置"四重哨兵防回归;全局搜索 buildSearchItem 的 typeof getGameIconUrl 守卫因作用域恒假(缩略图 capsule 兜底从未接通)同步改 SGLV_API 真接通。
// v2.11.43 修复(参考 steam-family-game-analysis v2.10 购买动态的购买者归属):GetSharedLibraryApps 的 owner_steamids 按入库顺序排列——末位=最新入库者(购买者),首位=最早购入者(该启发式经 family-analysis v1.56+ 生产验证)。家人后买一款自己已拥有的游戏时,共拥游戏 owners=[我,家人],rt_time_acquired 是家人的购买时间——2.11.42 的许可页校准依赖许可页可达,若许可页抓取失败/超 50 页上限/未命中该 app,家人购买仍会以"当天 07:59"出现在个人入库动态。本版引入 owners 末位归属,不依赖许可页即可正确归属:①新增 isMyAcquisitionEvent 纯函数(owners 末位===我 → rt_time_acquired 是我的购买事件;独占拥有恒真;非我的游戏恒假;无 owners 回退路径视为自己);②个人入库动态:非我的购买事件且无许可页校准日期 → 直接不展示("不是我的购买不出现在个人入库动态中"),有校准日期则展示在我的真实购买日期;③buildCalibratedAcquiredMap 同规则清理:非我的购买事件且无校准日期的游戏从入库时间映射移除(热力图/频率分析/趋势时间线/排序补齐不再按家人的购买日期计数);④fetchAllGames 主库路径:同类游戏 acquiredTime 清零(趋势图年度柱/"今年入库"KPI 回退到 lastPlayed 估算口径,不再错误计入家人购买日);⑤家庭组入库动态新增购买者显示——条目名称下方显示"成员名 购入"(steamIdtoName[owners 末位],名称映射缺失时经 getAccessToken+fetchFamilyInfo 拉取并持久化,失败仅显示时间),对齐 family-analysis 购买动态表的购买者列;⑥家庭组入库 footer 注明"购买者=最新入库成员";⑦测试新增 F 组 isMyAcquisitionEvent 6 场景 + 购买者接线哨兵 G 组 6 项 + H 组执行级回归 2 项(真实执行 buildFamilyTimeline/buildPersonalTimeline 全链路,stub 注入依赖,专门拦截"源码哨兵查不出的运行时 ReferenceError")——sglv-license-time.test.js 共 39 组断言;⑧hotfix:buildFamilyTimeline 的 purchaserName 首版引用了未声明的 owners 局部变量(该函数循环内原本无此声明),家庭组入库动态加载即抛 "owners is not defined"——已补声明并注入式验证 H1 能复现拦截该错误。
// v2.11.42 修复(参考 steam-friend-manager crossVerifyLicenses):家庭组共拥游戏入库时间被家人的新入库刷新——GetSharedLibraryApps 的 rt_time_acquired 是每个 app 的单一时间戳,家庭成员新入库一款自己已拥有的游戏时该时间被刷成家人的入库时间,个人入库动态/入库趋势/热力图等"我的入库"语境把旧游戏统计到家人的入库日期上(当天展示并未购买的共拥游戏)。修复:①新增个人许可页抓取模块(parseLicenseDate/parseLicenseRows/fetchPersonalLicenseMap:store.steampowered.com/account/licenses 首屏+AjaxLoadMoreLicenses 分页,24h 会话级缓存,未登录/失败静默降级保留家庭组时间;许可页仅列本人许可,appid 命中即为"我的游戏" ground truth,日级精度);②新增 licenseCorrectionsFor 纯函数——许可页日期与 rt_time_acquired 不同日才覆盖为许可页日期(秒),同日保留家庭组时间(保留真实时刻);③新增 buildCalibratedAcquiredMap 统一出口,接入 5 个"我的入库"消费点:个人入库动态(buildPersonalTimeline,条目加 licenseCorrected 标记)/入库趋势时间线/入库频率分析/入库排序补齐/入库热力图;④fetchAllGames 主库路径(趋势图年度柱/今年入库 KPI/SGIS 面板数据源)合并家庭组数据后同样校准 acquiredTime;⑤家庭组入库动态(buildFamilyTimeline)保持原始 rt_time_acquired 不校准——家庭组入库页含个人已拥有的共拥游戏为既定正确行为,仅修正其 footer 与状态注释中过时的"排除个人已拥有"虚假声明;⑥个人入库动态渲染:校准条目仅日级精度不再显示伪 HH:MM 时刻,footer 附加"N 款已按个人许可页校准";⑦新增 test/sglv-license-time.test.js 25 组断言(日期解析 3 格式/DOM 行解析契约 shim/校准规则 6 场景/消费点接线哨兵 7 项/许可页网络模块 stub 4 场景:缓存生效+分页合并+网络失败不写负缓存+并发去重)。
// v2.11.40 主题层抽象:①CSS_SGIS_OVERRIDE(无条件紫色覆盖层)重构为典雅紫主题层 CSS_THEME_PURPLE(内容零改动,默认主题零视觉回归),从 CSS_INLINE 移除;②新增经典蓝主题层 CSS_THEME_BLUE(scripts/gen-sglv-theme-blue.js 生成:紫层镜像色值映射 #a78bfa→#66c0f4 等 + 主脚本 CSS 常量/共享库原生紫色规则蓝色瘦身覆盖,Part B 120 条 + Part C 163 条,紫色残留自检 0);③SGLV_THEMES 注册表 + applySglvTheme 动态注入(<style id=sglv-theme-style> + documentElement data-sglv-theme 属性 + sglv-theme-changed 事件),storage.getUiTheme(默认 purple);④设置新增外观主题卡(典雅紫/经典蓝,渐变色板预览),保存即时热切换(主面板 renderBody/SGIS renderTab 监听事件重渲染);⑤SGLVCharts.accent/accentDeep/accentGradient/seriesColors 图表色随主题(趋势图/价格历史/热力图峰值/雷达完成度渐变/默认系列色),内联紫色改 var(--sglv-accent*);⑥语义色(金/绿/红/稀有度/勋章渐变/15色标签循环)两主题保持一致;⑦新增 test/sglv-theme.test.js 8 组(T7 零回归哨兵:紫层与 2.11.38 全文一致);⑧SGIS 侧边栏标题栏设置按钮左侧新增调色板快速切换按钮(典雅紫⇄经典蓝一键互切,toast 反馈+偏好持久化);⑨经典蓝侧边栏精调:Part D 手工段——靛蓝暗基底(--sgis-bg 族)→Steam 深蓝 + 标题栏渐变柔化(镜像色 #1a9fff@0.22 亮度过高发白修正) + FAB 紫色光晕 rgba(102,51,238) 补映射 + 收藏库加载渐变保深度;⑩收藏浮窗主题联动:applySglvTheme 每次应用重挂 head 末尾(收藏库 <style> 首开面板才懒注入,物理位置晚于主题层) + 主题层新增 Part E(html[data-sglv-theme="blue"] 前缀高特异性覆盖收藏库 SGC_PANEL_CSS 紫色 8 条,顺序无关) + collection lib 升 1.9.46(JS 模板 6 处内联紫改 var(--sglv-accent 及派生) 带紫色 fallback;发布顺序:先发 lib 1.9.46 再更主脚本 @require 版本号,当前仍 pin 1.9.45=1909158);⑪成就页/展柜页经典蓝统一(Part D 新段):页面底 GitHub 暗色(#0d1117 族,第三种风格)→Steam 深蓝(#141c28 族);成就页痛点收敛——绿色稀有度左条降饱和至 0.45(角标圆点保留全色,稀有度信息不丢)、彩虹进度条→蓝系渐变(已解锁 #1a9fff→#66c0f4/未解锁灰蓝)、NEW 标签绿→蓝、Steam 徽章横幅金青混杂→蓝系、环形完成度数值炫彩→蓝渐变、已解锁名称/计数徽章/点数文字换柔和浅蓝(#d9e8f7/#a9d4f5 系)修正扎眼文字对比;⑫渐变文字渲染修复(侧边栏标题文字被色块吞掉的根因):.sgis-title-text 等用 background 渐变+background-clip:text+-webkit-text-fill-color:transparent 的渐变文字技术,生成层用 background 简写覆盖时隐式重置 background-clip→border-box,文字透明+渐变画满元素=文字消失;生成器系统性修复(extractPurpleOverrides 检测基础规则含 clip:text 时自动附加 -webkit-background-clip/background-clip: text !important),受影响 4 条全修(侧边栏标题/成就环形数值/Steam 徽章数值×2),T8 加防回归断言,浏览器实测 computed style 确认 clip:text+透明填充生效。
// v2.11.38 修复:SGIS 概览页"用户档案获取失败: xpPercent is not defined"——v2.11.28 段渲染器拆分时 _renderProfileXp 残留 7 处裸变量引用(xpPercent/currentIntoLevel/xpDelta/xpToNext/playerLevel/totalXpDisplay),ReferenceError 被 renderProfile 外层 .catch 捕获误报为档案获取失败;统一改为 data.* 前缀(_prepareProfileData 返回对象本就含全部字段)。
// v2.11.29 FEAT-014 TASK-005 评测 Tab 迁移:renderReviewItem 段拆分(header/meta/text/actions/votes)+ _prepareReviewData 数据准备 + onChange 适配层接 buildListToolbar。
// v2.11.30 FEAT-014 TASK-006 社交+洞察迁移:renderSocialContent 段拆分 + renderUserAchievementsContent 段拆分(KPI 接 kpiCards)+ renderMarketInsightSection 条形接 hbarRow。
// v2.11.31 FEAT-014 TASK-007 价格 Tab + 徽章检测段迁移:renderPricesContent 段化(表格段/历史图段/汇总段) + 6 类检测徽章接统一 renderDetectBadge 段渲染器(配置表驱动 DRM/中文语音/资料状态/破解状态/AAA/保护机制)。
// v2.11.32 FEAT-014 TASK-008 morelike 模块迁移:renderSimilarGamesSection 卡片接 renderGameView(第 5 类消费方) + 工具栏接 buildListToolbar(第 7 处消费方) + renderTagRecsSection 加载/空态接 createLoadingHtml/emptyHtml + 模块互斥(PAGE_CTX.morelike)行为不变。
// v2.11.37 FEAT-015 TASK-004 裸调用迁移批次 B:锁区/价格/gamestatus/卡牌 DB 域 9 处 GM_xmlhttpRequest 迁移至 sglvGmFetchRetry/sglvGmFetchTextRetry,loadCardDatabase 失败补 notifyNetFail。
// v2.11.36 FEAT-015 TASK-003 裸调用迁移批次 A:AI/搜索/详情/token 域 13 处 GM_xmlhttpRequest 迁移至 sglvGmFetchRetry/sglvGmFetchTextRetry(core 升 1.0.6:gmFetchText headers 透传 + gmFetchJson onHttpError),静默失败点补 notifyNetFail(资料徽章检测/拥有游戏列表)。
// v2.11.35 FEAT-015 TASK-002 渲染内拉数外提:SGLV 面板侧 owned/showcase/cloudsave 三 Tab 内嵌数据抓取外提为 TAB_RENDERERS.prepare 数据准备步骤(对齐 FEAT-014 SGIS prepareTabData 模式),renderBody 渲染后追加 prepare,渲染函数只消费数据。
// v2.11.34 FEAT-014 TASK-004/006 回归补拆:renderActivityContent 段化(官方动态 4 分区 + personal/family 共用分页时间线段 + 事件绑定段) + renderUserAchievementsContent 段化(KPI/画像/维度/AI/口味/成就 6 段渲染器)——SGIS 11 Tab 入口全部 ≤150 行。
// @license      MIT
// @match        https://store.steampowered.com/*
// @match        https://steamcommunity.com/id/*/home/
// @match        https://steamcommunity.com/id/*/home
// @match        https://steamcommunity.com/profiles/*/home/
// @match        https://steamcommunity.com/profiles/*/home
// @connect      api.steampowered.com
// @connect      store.steampowered.com
// @connect      steamcommunity.com
// @connect      cdn.akamai.steamstatic.com
// @connect      cdn.cloudflare.steamstatic.com
// @connect      shared.akamai.steamstatic.com
// @connect      shared.fastly.steamstatic.com
// @connect      fastly.jsdelivr.net
// @connect      jsdelivr.net
// @connect      cdn.jsdelivr.net
// @connect      leanisssharedstorage.blob.core.windows.net
// @connect      api.augmentedsteam.com
// @connect      open.er-api.com
// @connect      flagcdn.com
// @connect      api.isthereanydeal.com
// @connect      api.cheapshark.com
// @connect      steamcardexchange.net
// @connect      api.deepseek.com
// @connect      api.openai.com
// @connect      open.bigmodel.cn
// @connect      dashscope.aliyuncs.com
// @connect      api.moonshot.cn
// @connect      api.minimaxi.com
// @connect      ark.cn-beijing.volces.com
// @connect      playstation.com
// @connect      store.playstation.com
// @connect      bartervg.com
// @connect      raw.githubusercontent.com
// @connect      gamestatus.info
// @connect      steam-tracker.com
// @resource     gameDb https://fastly.jsdelivr.net/gh/SmallRob/steam-namespace@main/data/game-db-v1.2.json
// @resource     delistedData https://fastly.jsdelivr.net/gh/SmallRob/steam-namespace@main/data/steam_delisted_apps.json
// @resource     psplusData https://fastly.jsdelivr.net/gh/oXnMe/psplus-steam-overlay@main/data/psplus-games.json

// scriptcat https://scriptcat.org/scripts/code/7432/SGLV%20Core%20Library.user.js?version=1.0.6
// v2.11.36: 依赖 sglv-core.lib.js v1.0.6（v1.0.5 语义不变 + gmFetchText headers 透传 + gmFetchJson onHttpError；发布顺序:先发布 core 1.0.6）

// @require      https://update.greasyfork.org/scripts/589437/1909161/SGLV%20Core%20Library%20%28SGLV-Suite%29.js
// @require      https://update.greasyfork.org/scripts/588483/1902911/SGLV%20%E5%85%B1%E4%BA%AB%E6%A0%B7%E5%BC%8F%20%28Library%29.js

// @require      https://update.greasyfork.org/scripts/589870/1896461/SGLV%20%E4%BA%91%E5%AD%98%E6%A1%A3%E6%A8%A1%E5%9D%97%20%28Library%29.js
// @require      https://update.greasyfork.org/scripts/589926/1909126/SGLV%20%E5%B0%81%E9%9D%A2%E4%B8%89%E7%BA%A7%E9%99%8D%E7%BA%A7%20%28Library%29.js
// (v2.11.44-hotfix) 以下原 [at]require 588484/1912157 sglv-game-collection 1.9.47 已改为内嵌,见下方 inline 块;ScriptCat/Tampermonkey 解析器不会把含 [at] 的注释行当作 @require,故这里用普通注释行(原 @require URL 仅作存档): 1912157 / SGLV 游戏收藏模块 (Library)

// @require      https://update.greasyfork.org/scripts/590084/1909121/SGLV%20App%20Detail%20Library.js
// @require      https://update.greasyfork.org/scripts/591126/1901189/SGLV%20Currency%20Library%20%28SGLV-Suite%29.js

// @require      https://update.greasyfork.org/scripts/590086/1895071/SGLV%20%E6%8B%BC%E9%9F%B3%E5%AD%97%E5%BA%93%20%28Library%29.js
// @require      https://update.greasyfork.org/scripts/590371/1896551/SGLV%20Badge%20Library.js
// @require      https://update.greasyfork.org/scripts/590418/1896925/SGLV%20ITAD%20Library.js

// @grant        GM_xmlhttpRequest
// @grant        GM_getValue
// @grant        GM_setValue
// @grant        GM_addStyle
// @grant        GM_getResourceText
// @grant        GM_listValues
// @grant        GM_notification
// @grant        unsafeWindow
// @run-at       document-idle
// @tag          Steam
// @tag          games
// @icon         data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 64 64'%3E%3Cdefs%3E%3ClinearGradient id='g' x1='0' y1='0' x2='1' y2='1'%3E%3Cstop offset='0' stop-color='%238b5cf6'/%3E%3Cstop offset='0.5' stop-color='%233b82f6'/%3E%3Cstop offset='1' stop-color='%2306b6d4'/%3E%3C/linearGradient%3E%3C/defs%3E%3Crect width='64' height='64' rx='14' fill='url(%23g)'/%3E%3Cg fill='%23fff'%3E%3Crect x='13' y='13' width='17' height='17' rx='3.5' opacity='.96'/%3E%3Crect x='34' y='13' width='17' height='17' rx='3.5' opacity='.78'/%3E%3Crect x='13' y='34' width='17' height='17' rx='3.5' opacity='.78'/%3E%3Crect x='34' y='34' width='17' height='17' rx='3.5' opacity='.96'/%3E%3C/g%3E%3Cpath d='M38 39 L47 44.5 L38 50 Z' fill='url(%23g)'/%3E%3C/svg%3E
// ==/UserScript==

// ============================================================================
// v2.11.44-hotfix: 内嵌 sglv-game-collection 1.9.47(原 @require 改为内联)
// ============================================================================
// 原因: 在受限网络环境下(CDN 受限/离线/GFW),ScriptCat 等脚本管理器的外部
// require 静默失败,导致 window.SGLVCollection 缺失,主脚本打印
// [SGLV] 收藏模块库未加载 警告后,收藏功能(供应商/绝版/PS会免/Epic 赠送/
// 锁区/年度大作/DLC 收藏/捆绑包)完全不可用。
// 修复: 将收藏模块库 1.9.47 直接内嵌到主脚本,window.SGLVCollection 在脚本
// 启动时即可用,init(ctx) 握手正常完成,不再依赖外部 require URL。
// 副作用: 主脚本体积增加约 446KB(1.7MB → ~2.1MB),换取完全自包含,无网络
// 依赖。如未来需切回外部 require 模式,删除本块并恢复上方 @require 行即可。
// ============================================================================
window.SGLVCollection = (function () {
    'use strict';

    // ---- 桥接宿主（由 init(ctx) 注入） ----
    let Host = null;
    const apiVersion = 1;

    // ---- SGLVCore 依赖（sglv-core.lib.js 提供的零业务基础设施；缺失时所有调用走 noop 兜底） ----
    // v1.9.1: DLC 渐进式加载复用 makeThrottledProgress / concurrentPool，避免每批数据都触发主线程渲染风暴
    const _C = (typeof unsafeWindow !== 'undefined' && unsafeWindow.SGLVCore) || window.SGLVCore || null;
    const _throttled = _C && typeof _C.makeThrottledProgress === 'function' ? _C.makeThrottledProgress : null;
    const _StageProgress = _C && _C.StageProgress ? _C.StageProgress : null;

    // ---- v1.9.41: 封面链语言变体增强（sglv-cover-fallback.lib.js v1.2.0 可选依赖）----
    // ---- v1.9.42: 竖版 2x 默认 + 横版 hero 高清 2x 增强 ----
    // 惰性解析：cover-fallback 与本库的加载顺序不作假设，每次调用时取
    function _coverFb() {
        try {
            return (typeof unsafeWindow !== 'undefined' && unsafeWindow.SGLVCoverFallback)
                || window.SGLVCoverFallback || null;
        } catch (e) { return null; }
    }
    // 中文界面请求语言变体封面（library_600x900_schinese 等），其余界面用默认资产
    function coverLang() {
        return (Host && Host.isZh) ? 'schinese' : null;
    }
    // v1.9.42: 4 CDN 前缀（顺序与 sglv-cover-fallback.lib.js 一致：shared.akamai → shared.fastly → cdn.akamai → cloudflare）
    const _COVER_CDNS = [
        'https://shared.akamai.steamstatic.com/store_item_assets/steam/apps/',
        'https://shared.fastly.steamstatic.com/store_item_assets/steam/apps/',
        'https://cdn.akamai.steamstatic.com/steam/apps/',
        'https://cdn.cloudflare.steamstatic.com/steam/apps/',
    ];
    // v1.9.42: 横版 hero 高清 2x 增强链（library_hero_2x 3840x1240 → library_hero 1920x620）
    // cover-fallback 可用 → 复用其 hero 链（中文语言变体 library_hero_schinese_2x 置顶 + 2x 先于非 2x + 4CDN + header 兜底）；
    // 不可用 → 手工构建同序链，保证可选依赖缺失时横版增强不降级
    function heroEnhancedChain(appid) {
        try {
            const fb = _coverFb();
            if (fb && typeof fb.buildFullChain === 'function'
                && Array.isArray(fb.KINDS) && fb.KINDS.indexOf('hero') >= 0) {
                const chain = fb.buildFullChain(appid, 'hero', coverLang());
                if (Array.isArray(chain) && chain.length) return chain;
            }
        } catch (e) { /* fallthrough */ }
        const lang = coverLang();
        const files = [];
        if (lang) files.push('library_hero_' + lang + '_2x.jpg', 'library_hero_' + lang + '.jpg');
        files.push('library_hero_2x.jpg', 'library_hero.jpg');
        const out = [];
        for (const f of files) for (const cdn of _COVER_CDNS) out.push(cdn + appid + '/' + f);
        return out;
    }
    // v1.9.42: 链去重（保留首次出现顺序）
    function _dedupeChain(chain) {
        const seen = new Set();
        const out = [];
        for (const u of chain) if (!seen.has(u)) { seen.add(u); out.push(u); }
        return out;
    }
    // v1.9.42: hero 前缀链去除尾部 header 兜底（header 统一留在整链末尾，
    // 保证 capsule_467x181 等横版资产的优先级高于 header）
    function _heroPrefixChain(appid) {
        return heroEnhancedChain(appid).filter(u => u.slice(-11) !== '/header.jpg');
    }
    // 封面完整回退链：cover-fallback 链（steamui 精确 URL 语境 + 语言变体置顶 + 4CDN）
    //  → 降级 Host.coverChainUrls（v1.9.40 原行为）
    // v1.9.42: ① poster 竖版链保持 2x 置顶（library_600x900_2x 高清竖版为默认：
    //             cover-fallback 链 / Host 链均保证 2x 先于 1x，数据源 poster 字段同为 2x URL）
    //          ② capsule 横版链增强：头部插入 hero 高清 2x 增强链（library_hero_2x 为默认横版封面），
    //             原 capsule_467x181 链降级为 hero 缺失时的回退
    function coverChainLang(appid, kind) {
        try {
            const fb = _coverFb();
            if (fb && typeof fb.buildFullChain === 'function'
                && Array.isArray(fb.KINDS) && fb.KINDS.indexOf(kind) >= 0) {
                let chain = fb.buildFullChain(appid, kind, coverLang());
                if (kind === 'capsule') chain = _heroPrefixChain(appid).concat(chain);
                if (Array.isArray(chain) && chain.length) return _dedupeChain(chain);
            }
        } catch (e) { /* fallthrough */ }
        const host = Host.coverChainUrls(appid, kind);
        return kind === 'capsule' ? _dedupeChain(_heroPrefixChain(appid).concat(host)) : host;
    }
    // good 缓存：v1.9.42 起 capsule 横版优先 steamui hero 精确 hash URL（image2x 优先，即 hero 高清 2x），
    // 其次宿主会话级缓存，最后 cover-fallback 的本 kind steamui 精确 hash URL（同步缓存命中）
    // v1.9.44: 交叉缓存方向门控——所有读取均校验 URL 方向与 kind 匹配（poster=竖版，其余=横版），
    //   方向不匹配的缓存条目（poster 缓存被横版兜底写入、capsule 缓存混入竖版）不再直接返回，
    //   防止竖版视图直用横版缓存地址导致裁切错位（或反向）；横版替代走 coverHorizontalFallbackUrl
    function _sgcvUrlMatchesKind(u, kind) {
        if (typeof u !== 'string' || !u) return false;
        const v = _sgcvIsVerticalUrl(u);
        return (kind === 'poster') ? v : !v;
    }
    function coverGoodUrl(appid, kind) {
        if (kind === 'capsule') {
            try {
                const fb = _coverFb();
                if (fb && typeof fb.getSteamuiGoodUrl === 'function') {
                    const heroUrl = fb.getSteamuiGoodUrl(appid, 'hero', coverLang());
                    if (heroUrl && _sgcvUrlMatchesKind(heroUrl, kind)) return heroUrl;
                }
            } catch (e) { /* fallthrough */ }
        }
        const good = Host.getPosterGood(appid, kind);
        if (good && _sgcvUrlMatchesKind(good, kind)) return good;
        try {
            const fb = _coverFb();
            if (fb && typeof fb.getSteamuiGoodUrl === 'function') {
                const u = fb.getSteamuiGoodUrl(appid, kind, coverLang()) || '';
                if (u && _sgcvUrlMatchesKind(u, kind)) return u;
            }
        } catch (e) { /* fallthrough */ }
        return '';
    }
    // v1.9.44: 竖版缺失判定——poster 缓存存在横版条目 = 此前 poster 链已耗尽至横版兜底
    //   （poster 链竖版优先，poster 上下文加载出横版 ⇒ 竖版资产确认缺失的会话级标记）
    function coverVerticalMissing(appid) {
        try {
            const p = Host.getPosterGood(appid, 'poster');
            return !!(p && !_sgcvIsVerticalUrl(p));
        } catch (e) { return false; }
    }
    // v1.9.44: 横版替代交叉缓存——仅竖版确认缺失（poster 缓存横版标记条目）时返回该标记条目
    //   （链尾 header 兜底，2.14:1 最贴竖版容器 letterbox），未确认缺失时一律为空：
    //   capsule/header 缓存存在 ≠ 竖版资产缺失（横竖是各自独立文件），未确认即交叉读取
    //   会令竖版视图跳过竖版链探测、直接加载错位横图
    function coverHorizontalFallbackUrl(appid) {
        try {
            const p = Host.getPosterGood(appid, 'poster');
            return (p && !_sgcvIsVerticalUrl(p)) ? p : '';
        } catch (e) { return ''; }
    }

    // ---- v1.9.43: 封面方向门控 + API 兜底竞速 ----
    // 竖版资产判定：library_600x900 族（含语言/2x 变体）；header/capsule/hero/page_bg 均为横版。
    // 数据源 poster 字段实测全为横版 header URL，v1.9.30-1.9.42 将其当作竖版初始 src
    // 导致 2:3 竖版卡片显示横图裁切变形
    function _sgcvIsVerticalUrl(u) {
        return typeof u === 'string' && u.indexOf('library_600x900') >= 0;
    }
    // API 兜底竞速：首个 onerror 即后台拉起 appdetails（Host.fetchCoverApiUrl 三级缓存 +
    // 并发去重），CDN 链继续串行走；API 先返回且图片尚未加载成功时直接劫持 src。
    // 新游戏（资产仅存在于 hash 路径、无 hash 链全 404）从 ~36 次串行 404（约 22s）
    // 缩短到 ~2-3 次请求；老游戏链首即命中，竞速不触发任何请求
    function _sgcvCoverRaceImpl(img, appid, kind) {
        if (!img || img._sgcvRace) return;
        img._sgcvRace = 1;
        try {
            if (!Host || typeof Host.fetchCoverApiUrl !== 'function') return;
            Host.fetchCoverApiUrl(appid, kind).then(function (url) {
                if (!url || !img.isConnected || img.src === url) return;
                // v1.9.44: 方向门控——API URL 与 kind 方向不匹配时不劫持。
                // poster kind 的 API 兜底（filters=basic）恒为横版 header_image：劫持会压制
                // 链上更深处仍可能命中的竖版资产，并把横版写入 poster 缓存造成
                // "有竖版资产的游戏显示横版"的会话级污染；横版兜底由链尾 header + _sglvPosterFallback 承担
                if (!_sgcvUrlMatchesKind(url, kind)) return;
                // CDN 链已加载成功（onload 已加 sglv-img-loaded 类）则不干预
                if (img.classList.contains('sglv-img-loaded') || (img.complete && img.naturalWidth > 0)) return;
                // API URL 失败 → 占位（先替换 onerror，防止链式 handler 死循环）
                img.onerror = function () { img.onerror = null; _sgcvToPlaceholder(img); };
                img.src = url;
            }).catch(function () { /* API 失败：CDN 链继续走，不干预 */ });
        } catch (e) { /* Host 契约缺失：降级为纯链行走 */ }
    }
    // 竞速 URL 加载失败的占位（与宿主 _posterImgToPlaceholder 同款，仅替换 img 节点保留徽章浮层）
    function _sgcvToPlaceholder(img) {
        if (!img || !img.parentElement) return;
        const holder = document.createElement('div');
        holder.className = img.className;
        holder.style.cssText = 'display:flex;align-items:center;justify-content:center;color:#5a6a7a;font-size:11px';
        holder.textContent = (Host && Host.isZh) ? '无图片' : 'No Image';
        img.parentElement.replaceChild(holder, img);
    }
    // 挂载到页面上下文（内联 onerror 属性在页面上下文执行，与宿主 _sglvPosterFallback 同机制）
    try {
        const _sgcvPageWin = (typeof unsafeWindow !== 'undefined') ? unsafeWindow : window;
        _sgcvPageWin._sgcvCoverRace = _sgcvCoverRaceImpl;
    } catch (e) { /* ignore */ }
    // v1.9.44: poster kind 通用 onload 属性——宽图检测（横版兜底/替代 letterbox 显示）+ good 记录
    function _sgcvPosterOnloadAttr(appid) {
        return 'this.classList.add(\'sglv-img-loaded\');'
            + 'if(this.naturalWidth>this.naturalHeight)this.classList.add(\'sglv-img-wide\');'
            + '_sglvRecordPosterGood(\'' + appid + '\',this.src,\'poster\');';
    }
    // v1.9.44: 竖版缺失标记快速路径 HTML——竖版确认缺失后横版替代直用（交叉缓存），
    //   免去每次渲染重爬整条竖版链（8 个 CDN 404 + header 兜底）
    function _sgcvHorizontalFallbackImgHtml(appid, name, cls, fbFn) {
        const url = coverHorizontalFallbackUrl(appid);
        if (!url) return '';
        return '<img class="' + cls + '" src="' + url + '" alt="' + name +
            '" loading="lazy" decoding="async" onerror="' + fbFn + '(this,\'' + appid + '\',\'poster\');" onload="' +
            _sgcvPosterOnloadAttr(appid) + '">';
    }

    // v2.9.22: sgc-panel 紧凑 CSS（仿主面板 v2.9.22 页头风格 + 品牌图标 + 拖动 + 骨架占位）
    const SGC_PANEL_CSS = `
/* === 紧凑 header：去除"游戏收藏"标题，保留左侧 Steam 图标 + 中间 tab-bar + 右侧关闭 === */
.sgc-panel > .sglv-header {
    padding: 8px 14px !important;
    gap: 12px;
    cursor: move;             /* header 作为拖动手柄 */
    user-select: none;
    background: linear-gradient(135deg, rgba(27, 40, 56, 0.95) 0%, rgba(42, 71, 94, 0.95) 100%) !important;
    border-bottom: 1px solid rgba(102, 192, 244, 0.18) !important;
}
.sgc-panel > .sglv-header h2 { display: none !important; }
.sgc-panel > .sglv-header > .sglv-tab-bar {
    display: flex;
    align-items: center;
    gap: 2px;
    flex: 1;
    min-width: 0;
    overflow-x: auto;
    scrollbar-width: none;
}
.sgc-panel > .sglv-header > .sglv-tab-bar::-webkit-scrollbar { display: none; }

/* === 保留最左侧 Steam 图标作为品牌标识 === */
.sglv-header-brand {
    width: 24px;
    height: 24px;
    border-radius: 6px;
    flex-shrink: 0;
    display: inline-flex;
    align-items: center;
    justify-content: center;
    background: linear-gradient(135deg, rgba(102, 192, 244, 0.18), rgba(139, 92, 246, 0.18));
    border: 1px solid rgba(102, 192, 244, 0.25);
    color: #66c0f4;
    box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.06);
    transition: transform 0.2s, box-shadow 0.2s;
}
.sglv-header-brand:hover { transform: rotate(-8deg) scale(1.05); box-shadow: 0 2px 8px rgba(102, 192, 244, 0.35), inset 0 1px 0 rgba(255, 255, 255, 0.1); }
.sglv-header-brand img { width: 14px; height: 14px; display: block; border-radius: 2px; }

/* === tab 按钮紧凑化（覆盖 shared css 的 flex:1 + 大 padding） === */
.sgc-panel .sglv-tab {
    flex: 0 0 auto !important;
    padding: 5px 12px !important;
    font-size: 12.5px !important;
    font-weight: 600 !important;
    border-radius: 8px !important;
    border: 1px solid transparent !important;
    background: transparent !important;
    color: #94a3b8 !important;
    white-space: nowrap !important;
    gap: 5px !important;
    transition: background 0.15s, color 0.15s, border-color 0.15s, transform 0.15s !important;
}
.sgc-panel .sglv-tab:hover { color: #e2e8f0 !important; background: rgba(255, 255, 255, 0.06) !important; }
.sgc-panel .sglv-tab.active {
    color: #fff !important;
    background: rgba(102, 192, 244, 0.22) !important;
    border-color: rgba(102, 192, 244, 0.4) !important;
    box-shadow: 0 0 0 1px rgba(102, 192, 244, 0.15) inset, 0 1px 4px rgba(102, 192, 244, 0.18) !important;
}
.sgc-panel .sglv-tab svg { width: 14px; height: 14px; flex-shrink: 0; }

/* === 隐藏原 .sglv-tabs 单独行（兼容老代码，防止双重显示） === */
.sgc-panel .sglv-tabs { display: none !important; }

/* === 关闭按钮位置 === */
.sgc-panel > .sglv-header > .sglv-header-actions {
    gap: 6px;
    flex-shrink: 0;
    margin-left: auto;
}

/* === v2.9.22: Epic免费标签 → 封面右下角（card + cover 两种视图） === */
.sglv-card-img-wrap > .sglv-epic-free-badge,
.sglv-wl-cover-img-wrap > .sglv-epic-free-badge {
    position: absolute !important;
    bottom: 6px !important;
    right: 6px !important;
    top: auto !important;
    left: auto !important;
    margin-top: 0 !important;
    background: #ff69b4 !important;
    color: #fff !important;
    padding: 2px 6px !important;
    border-radius: 3px !important;
    font-size: 10px !important;
    font-weight: 700 !important;
    z-index: 2 !important;
    box-shadow: 0 1px 4px rgba(0, 0, 0, 0.35) !important;
    backdrop-filter: blur(4px) !important;
    -webkit-backdrop-filter: blur(4px) !important;
}

/* === v2.9.22: GotY"年度大作"标签 → 封面右下角（card + cover）== 风格与 Epic免费一致 === */
.sglv-card-img-wrap > .sglv-goty-goty-badge,
.sglv-wl-cover-img-wrap > .sglv-goty-goty-badge {
    position: absolute !important;
    bottom: 6px !important;
    right: 6px !important;
    top: auto !important;
    left: auto !important;
    margin-top: 0 !important;
    background: linear-gradient(135deg, #f59e0b, #ef4444) !important;
    color: #fff !important;
    padding: 2px 6px !important;
    border-radius: 3px !important;
    font-size: 10px !important;
    font-weight: 700 !important;
    z-index: 2 !important;
    box-shadow: 0 1px 4px rgba(0, 0, 0, 0.35) !important;
    backdrop-filter: blur(4px) !important;
    -webkit-backdrop-filter: blur(4px) !important;
}

/* === v2.9.22: cover 视图下方信息行统一间距（Epic / Delisted / GotY 一致） === */
.sglv-wl-cover-body .sglv-epic-owned-row,
.sglv-wl-cover-body .sglv-blocked-owned-row,
.sglv-wl-cover-body .sglv-goty-owned-row {
    margin-top: 2px;
    gap: 4px;
}

/* === v2.9.22: 供应商列表视图封面列 === */
.sglv-pub-list-col.cover { padding-right: 8px; }
.sglv-pub-list-cover {
    width: 80px;
    height: 36px;
    object-fit: cover;
    border-radius: 4px;
    display: block;
    background: rgba(255, 255, 255, 0.05);
}

/* === v1.9.16: 供应商/系列游戏 genres 类型标签（可选字段，无 genres 时不渲染） === */
.sglv-pub-genre-tags {
    display: inline-flex;
    gap: 3px;
    margin-left: 6px;
    vertical-align: 1px;
    flex-wrap: wrap;
}
.sglv-pub-genre-tag {
    font-size: 10px;
    line-height: 1;
    padding: 2px 5px;
    border-radius: 3px;
    background: rgba(102, 192, 244, 0.12);
    color: #9ecfea;
    white-space: nowrap;
}
.sglv-card-genre-row {
    display: flex;
    gap: 3px;
    flex-wrap: wrap;
    margin-top: 3px;
}

/* === v2.9.22: GotY 状态行紧凑布局（owned badge + 🕐 发售日期同行） === */
.sglv-goty-status-row {
    display: flex !important;
    align-items: center !important;
    gap: 6px !important;
    flex-wrap: wrap !important;
    margin-top: 4px !important;
    min-height: 18px !important;
}
.sglv-goty-status-row .sglv-card-badge {
    display: inline-flex !important;
    align-items: center !important;
    font-size: 10px !important;
    padding: 2px 7px !important;
    margin-top: 0 !important;
    flex-shrink: 0 !important;
}
.sglv-goty-date {
    display: inline-flex !important;
    align-items: center !important;
    gap: 3px !important;
    font-size: 10px !important;
    color: var(--sglv-text-secondary, #94a3b8) !important;
    font-variant-numeric: tabular-nums !important;
    margin-left: auto !important;
    white-space: nowrap !important;
}
.sglv-goty-date .sglv-goty-clock {
    width: 11px !important;
    height: 11px !important;
    display: inline-flex !important;
    align-items: center !important;
    justify-content: center !important;
    opacity: 0.6 !important;
    flex-shrink: 0 !important;
}
.sglv-goty-date .sglv-goty-clock svg {
    width: 11px !important;
    height: 11px !important;
}
/* list 视图中的 goty-date 样式（不要 right-push，跟其他 meta 元素 inline） */
.sglv-list-meta .sglv-goty-date {
    margin-left: 0 !important;
    gap: 3px !important;
}

/* === v2.9.22: PS会免封面视图 — tier-badge 绝对定位到 cover 视图封面右上角 === */
/* shared CSS 的 .sglv-card-img-wrap .sglv-ps-tier-badge 定位只对 card 视图生效；
   cover 视图用 .sglv-wl-cover-img-wrap，需要独立覆盖。 */
.sglv-wl-cover-img-wrap > .sglv-ps-tier-badge {
    position: absolute !important;
    top: 6px !important;
    right: 6px !important;
    z-index: 2 !important;
    backdrop-filter: blur(4px) !important;
    -webkit-backdrop-filter: blur(4px) !important;
    box-shadow: 0 1px 4px rgba(0, 0, 0, 0.35) !important;
}

/* === v2.9.22: PS会免 cover 视图 — 信息行紧凑到 3 行内 === */
/* 状态徽章 + 在库徽章合并到同一行（左右排列），月份/版本单独一行 */
.sglv-wl-cover-body .sglv-ps-status-row {
    display: flex !important;
    align-items: center !important;
    gap: 5px !important;
    flex-wrap: wrap !important;
    margin-top: 2px !important;
}
.sglv-wl-cover-body .sglv-ps-status-row .sglv-card-badge {
    display: inline-flex !important;
    align-items: center !important;
    font-size: 10px !important;
    padding: 2px 7px !important;
    margin-top: 0 !important;
}
/* 月份 + 版本 meta 行紧凑 */
.sglv-wl-cover-body .sglv-ps-meta-row {
    display: flex !important;
    align-items: center !important;
    gap: 6px !important;
    flex-wrap: wrap !important;
    font-size: 10px !important;
    color: var(--sglv-text-secondary) !important;
}
.sglv-wl-cover-body .sglv-ps-meta-row .sglv-ps-month-item {
    display: inline-flex !important;
    align-items: center !important;
    gap: 3px !important;
}
.sglv-wl-cover-body .sglv-ps-meta-row .sglv-ps-month-item .sglv-ps-clock {
    width: 11px !important;
    height: 11px !important;
    display: inline-flex !important;
    align-items: center !important;
    opacity: 0.65 !important;
}
.sglv-wl-cover-body .sglv-ps-meta-row .sglv-ps-month-item .sglv-ps-clock svg {
    width: 11px !important;
    height: 11px !important;
}
.sglv-wl-cover-body .sglv-ps-meta-row .sglv-ps-versions {
    display: inline-flex !important;
    gap: 3px !important;
}
.sglv-wl-cover-body .sglv-ps-meta-row .sglv-ps-versions span {
    font-size: 9px !important;
    padding: 1px 4px !important;
    border-radius: 3px !important;
    background: rgba(255, 255, 255, 0.08) !important;
    border: 1px solid rgba(255, 255, 255, 0.15) !important;
}

/* === v2.9.22: 年度大作 chip 强化 — 默认全部展开，active 更明显 === */
.sgc-panel .sglv-goty-year-bar {
    padding: 8px 12px !important;
    gap: 6px !important;
    background: linear-gradient(180deg, rgba(139, 92, 246, 0.08), transparent) !important;
    border-bottom: 1px solid rgba(139, 92, 246, 0.18) !important;
}
.sgc-panel .sglv-goty-year-chip {
    padding: 4px 12px !important;
    font-size: 12px !important;
}
.sgc-panel .sglv-goty-year-chip.active {
    background: linear-gradient(135deg, rgba(139, 92, 246, 0.4), rgba(59, 130, 246, 0.25)) !important;
    color: #fff !important;
    border-color: rgba(139, 92, 246, 0.6) !important;
    box-shadow: 0 0 12px rgba(139, 92, 246, 0.35) !important;
}

/* === v2.9.22: PS / Epic 占位封面 logo 尺寸（适配新版 viewBox 122.88x95.18 和 100x100） === */
.sglv-ps-cover-placeholder .sglv-ps-logo {
    width: 96px !important;
    height: 74px !important;
    opacity: 0.9 !important;
    color: #fff !important;
    flex-shrink: 0 !important;
    filter: drop-shadow(0 2px 6px rgba(0, 0, 0, 0.35));
}
.sglv-ps-cover-placeholder .sglv-ps-logo svg { width: 100% !important; height: 100% !important; display: block; }

/* Epic 占位容器：覆盖 PS 的蓝色渐变，改为深色盾形风格 */
.sglv-epic-cover-placeholder {
    background: linear-gradient(135deg, #0d0d0d 0%, #1f1f1f 55%, #2a2a2a 100%) !important;
    box-shadow: inset 0 0 30px rgba(0, 0, 0, 0.5) !important;
}
.sglv-epic-cover-placeholder .sglv-epic-logo {
    width: 96px !important;
    height: 96px !important;
    opacity: 1 !important;
    flex-shrink: 0 !important;
    filter: drop-shadow(0 4px 12px rgba(0, 0, 0, 0.6));
}
.sglv-epic-cover-placeholder .sglv-epic-logo svg { width: 100% !important; height: 100% !important; display: block; }

/* === 加载中骨架：body 为空或仅含简单文字时显示 spinner === */
@keyframes sgc-spin { from { transform: rotate(0deg); } to { transform: rotate(360deg); } }
.sgc-body-loading {
    display: flex;
    flex-direction: column;
    align-items: center;
    justify-content: center;
    height: 100%;
    min-height: 320px;
    padding: 40px 20px;
    gap: 14px;
    color: #94a3b8;
    font-size: 13px;
    text-align: center;
}
.sgc-body-loading .sgc-bl-spinner {
    width: 36px;
    height: 36px;
    border: 3px solid rgba(102, 192, 244, 0.15);
    border-top-color: #66c0f4;
    border-radius: 50%;
    animation: sgc-spin 0.9s linear infinite;
}
.sgc-body-loading .sgc-bl-title {
    font-size: 15px;
    font-weight: 600;
    color: #cbd5e1;
}
.sgc-body-loading .sgc-bl-tip {
    font-size: 12px;
    color: #64748b;
    line-height: 1.6;
    max-width: 380px;
}
/* body 完全为空时（首次打开/切 tab 瞬间）显示 fallback 提示 */
.sgc-panel .sglv-body:empty::before {
    content: "加载中…";
    display: flex;
    align-items: center;
    justify-content: center;
    height: 200px;
    color: #94a3b8;
    font-size: 13px;
}

/* === v1.9.1: DLC 收藏标签页骨架（KPI shimmer + 卡片占位 + 阶段进度条） === */
@keyframes sglv-skel-shimmer {
    0% { background-position: 200% 0; }
    100% { background-position: -200% 0; }
}
.sglv-skel-line {
    background: linear-gradient(90deg,
        rgba(102,192,244,0.06) 0%,
        rgba(102,192,244,0.20) 50%,
        rgba(102,192,244,0.06) 100%);
    background-size: 200% 100%;
    animation: sglv-skel-shimmer 1.4s ease-in-out infinite;
    border-radius: 4px;
    height: 14px;
    margin: 6px 0;
}
.sglv-skel-line.lg { height: 22px; width: 55%; }
.sglv-skel-line.md { height: 14px; width: 40%; }
.sglv-skel-line.sm { height: 10px; width: 28%; }
.sglv-trend-kpi-card.skeleton { pointer-events: none; opacity: 0.55; }
.sglv-trend-kpi-card.skeleton .sglv-skel-line { margin: 8px 0; }
.sglv-skel-card {
    background: rgba(255,255,255,0.04) !important;
    border: 1px solid rgba(255,255,255,0.06) !important;
    position: relative;
    overflow: hidden;
}
.sglv-skel-card::after {
    content: "";
    position: absolute;
    inset: 0;
    background: linear-gradient(90deg,
        transparent 0%,
        rgba(102,192,244,0.10) 50%,
        transparent 100%);
    background-size: 200% 100%;
    animation: sglv-skel-shimmer 1.4s ease-in-out infinite;
    pointer-events: none;
}
.sglv-skel-card .sglv-card-img-wrap,
.sglv-skel-card .sglv-card-body { visibility: hidden; }
.sglv-skel-stage {
    margin: 14px 18px;
    display: flex;
    flex-direction: column;
    gap: 8px;
}
.sglv-skel-stage-bar {
    height: 4px;
    background: rgba(102,192,244,0.12);
    border-radius: 2px;
    overflow: hidden;
}
.sglv-skel-stage-fill {
    height: 100%;
    background: linear-gradient(90deg, #66c0f4, #a78bfa);
    border-radius: 2px;
    transition: width 0.4s ease;
}
.sglv-skel-stage-text {
    font-size: 12px;
    color: #94a3b8;
    display: flex;
    align-items: center;
    gap: 8px;
}
.sglv-skel-stage-text::before {
    content: "";
    width: 12px;
    height: 12px;
    border: 2px solid rgba(102,192,244,0.25);
    border-top-color: #66c0f4;
    border-radius: 50%;
    animation: sgc-spin 0.9s linear infinite;
    flex-shrink: 0;
}
.sglv-skel-grid { padding: 0 12px 12px; }

/* === v1.9.4: DLC 加载等待动画（参考 steam-friend-manager spinner 风格） === */
.sglv-dlc-loading { display:flex; flex-direction:column; align-items:center; justify-content:center; padding:48px 20px; gap:14px; color:#94a3b8; min-height:280px; }
.sglv-dlc-loading .sglv-dlc-spin { width:32px; height:32px; animation:sgc-spin 1s linear infinite; color:#a78bfa; }
.sglv-dlc-loading-text { font-size:13px; font-weight:600; color:#cbd5e1; }
.sglv-dlc-loading-sub { font-size:11px; color:#64748b; }
.sglv-dlc-loading-bar { width:220px; height:3px; background:rgba(102,192,244,0.12); border-radius:2px; overflow:hidden; }
.sglv-dlc-loading-bar-fill { height:100%; background:linear-gradient(90deg,#66c0f4,#a78bfa); border-radius:2px; transition:width 0.4s ease; }

/* === v1.9.4: DLC 工具栏分隔符 + 已拥有筛选 === */
.sglv-toolbar-sep { width:1px; height:24px; background:rgba(148,163,184,0.2); flex-shrink:0; margin:0 2px; }
.sglv-dlc-own-filter { display:flex; gap:2px; flex-shrink:0; }
.sglv-dlc-own-filter .sglv-btn { padding:4px 10px; font-size:11.5px; }

/* === v1.9.35: 系列详情工具栏——flex-wrap 防溢出 + 拥有状态切换标签 === */
.sglv-pub-detail-toolbar {
    display: flex;
    align-items: center;
    flex-wrap: wrap;
    gap: 8px 12px;
    margin-bottom: 8px;
    font-size: 13px;
    color: #8a9ba8;
}
.sglv-pub-completion { flex-shrink: 0; }
.sglv-pub-own-filter { display: flex; gap: 2px; flex-shrink: 0; }
.sglv-pub-own-filter .sglv-btn { padding: 3px 10px; font-size: 11.5px; }
.sglv-pub-sort-group { display: flex; align-items: center; gap: 4px; flex-shrink: 0; }
.sglv-pub-detail-toolbar .sglv-view-toggle { margin-left: auto; gap: 4px !important; }

/* === v1.9.1: DLC 收藏标签页 KPI 紧凑布局（5 列一行, 缩 padding/font, 避免换行） === */
/* shared-css 默认 .sglv-trend-kpi-row 是 4 列,5 个 KPI 必然换行 → 用 id 选择器精准覆盖 */
#sglv-dlc-kpi .sglv-trend-kpi-row {
    grid-template-columns: repeat(5, 1fr);
    gap: 6px;
    margin-bottom: 8px;
}
#sglv-dlc-kpi .sglv-trend-kpi-card {
    padding: 5px 8px 4px;
    min-width: 0;
}
#sglv-dlc-kpi .sglv-trend-kpi-header {
    gap: 3px;
    margin-bottom: 1px;
}
#sglv-dlc-kpi .sglv-trend-kpi-icon {
    width: 16px;
    height: 16px;
    border-radius: 4px;
}
#sglv-dlc-kpi .sglv-trend-kpi-icon svg {
    width: 10px;
    height: 10px;
}
#sglv-dlc-kpi .sglv-trend-kpi-label {
    font-size: 10px;
    line-height: 1.2;
    white-space: nowrap;
    overflow: hidden;
    text-overflow: ellipsis;
}
#sglv-dlc-kpi .sglv-trend-kpi-value {
    font-size: 17px;
    line-height: 1.15;
    white-space: nowrap;
}
#sglv-dlc-kpi .sglv-trend-kpi-sub {
    font-size: 9px;
    line-height: 1.3;
    white-space: nowrap;
    overflow: hidden;
    text-overflow: ellipsis;
}

/* === v1.9.1: DLC groupMode=true 时,视图切换按钮置灰不可点 === */
/* 分组视图天然是 card 布局,viewMode 概念对它无意义 → 视觉禁用 + pointer-events none */
.sgc-panel .sglv-view-toggle.sglv-view-disabled {
    opacity: 0.35;
    pointer-events: none;
    filter: grayscale(0.6);
}
.sgc-panel .sglv-view-toggle.sglv-view-disabled .sglv-btn.active {
    /* 即使 active 也不应被强调,保持整体灰态 */
    box-shadow: none;
}

/* === v1.8.2: 供应商/系列模式切换条（系列分类标签页侧边栏顶部） === */
.sgc-panel .sglv-pub-mode-switch {
    display: flex;
    gap: 4px;
    padding: 8px 10px;
    border-bottom: 1px solid rgba(255,255,255,0.06);
    position: sticky;
    top: 0;
    background: rgba(20,30,42,0.96);
    backdrop-filter: blur(4px);
    z-index: 2;
}
.sgc-panel .sglv-pub-mode-btn {
    flex: 1;
    padding: 5px 10px;
    font-size: 12px;
    font-weight: 600;
    border-radius: 6px;
    border: 1px solid rgba(255,255,255,0.08);
    background: rgba(255,255,255,0.03);
    color: #94a3b8;
    cursor: pointer;
    transition: background 0.15s, color 0.15s, border-color 0.15s;
}
.sgc-panel .sglv-pub-mode-btn:hover { color: #e2e8f0; background: rgba(255,255,255,0.07); }
.sgc-panel .sglv-pub-mode-btn.active {
    color: #fff;
    background: rgba(102,192,244,0.22);
    border-color: rgba(102,192,244,0.4);
    box-shadow: 0 0 0 1px rgba(102,192,244,0.15) inset;
}
/* v2.9.90: 系列刷新按钮——不占 flex:1，固定宽度 */
.sgc-panel .sglv-pub-mode-btn.sglv-pub-series-refresh {
    flex: 0 0 auto;
    padding: 5px 8px;
    color: #94a3b8;
}
.sgc-panel .sglv-pub-mode-btn.sglv-pub-series-refresh:hover { color: #66c0f4; }
.sgc-panel .sglv-pub-mode-btn.sglv-pub-series-refresh svg { width: 14px; height: 14px; }
.sgc-panel .sglv-pub-mode-btn.sglv-pub-series-refresh.sglv-spin svg {
    animation: sgc-spin 0.8s linear infinite;
}
/* v1.9.47-fix: 绝版游戏刷新按钮 spinner 动画 */
#sglv-delisted-refresh.sglv-spin svg {
    animation: sgc-spin 0.8s linear infinite;
}
/* v1.9.40: 刷新结果悬浮提示——绝对定位不参与工具栏 flex 布局，任何内容都不会压缩切换按钮 */
.sgc-panel .sglv-pub-refresh-toast {
    position: absolute;
    top: calc(100% + 4px);
    right: 10px;
    z-index: 3;
    display: inline-flex;
    align-items: center;
    gap: 8px;
    padding: 4px 10px;
    font-size: 11px;
    color: #cbd5e1;
    background: rgba(15,23,35,0.96);
    border: 1px solid rgba(255,255,255,0.1);
    border-radius: 6px;
    box-shadow: 0 4px 12px rgba(0,0,0,0.35);
    pointer-events: none;
    white-space: nowrap;
}
.sglv-pub-status-ok { color: #4caf50; font-weight: 600; }
.sglv-pub-status-dim { color: #8f9bb3; }
.sglv-pub-status-err { color: #ef5350; font-weight: 600; }
/* v2.9.90: 锁区游戏刷新按钮 spinner 动画 */
#sglv-blocked-refresh.sglv-spin svg {
    animation: sgc-spin 0.8s linear infinite;
}
.sglv-ps-status {
    font-size: 11px;
    color: #8f9bb3;
    white-space: nowrap;
    margin-left: 4px;
    display: inline-flex;
    align-items: center;
    gap: 6px;
}
/* v2.9.91: 锁区游戏工具栏状态文本（更新时间 / 加载进度） */
.sglv-blocked-status {
    font-size: 11px;
    color: #8f9bb3;
    white-space: nowrap;
    margin-left: 4px;
    display: inline-flex;
    align-items: center;
}
.sglv-blocked-status.loading {
    color: #66c0f4;
}

/* === v1.8.2: 系列模式扁平列表项（无二级分类） === */
.sgc-panel .sglv-series-flat-item {
    display: flex;
    align-items: center;
    justify-content: space-between;
    gap: 8px;
    padding: 7px 12px;
    font-size: 12.5px;
    color: #cbd5e1;
    cursor: pointer;
    border-left: 2px solid transparent;
    transition: background 0.15s, border-color 0.15s;
}
.sgc-panel .sglv-series-flat-item:hover { background: rgba(255,255,255,0.05); }
.sgc-panel .sglv-series-flat-item.active {
    background: rgba(102,192,244,0.12);
    border-left-color: #66c0f4;
    color: #fff;
}
.sgc-panel .sglv-series-flat-item .sglv-series-name {
    flex: 1;
    min-width: 0;
    overflow: hidden;
    text-overflow: ellipsis;
    white-space: nowrap;
}
.sgc-panel .sglv-series-empty-hint {
    padding: 20px 12px;
    font-size: 12px;
    color: #8a9ba8;
    text-align: center;
}

/* === v1.9.0: DLC 收藏标签页样式 === */
.sglv-dlc-group {
    border: 1px solid rgba(102, 192, 244, 0.12);
    border-radius: 8px;
    margin-bottom: 8px;
    overflow: hidden;
    background: rgba(255, 255, 255, 0.02);
}
.sglv-dlc-group.collapsed .sglv-dlc-card-row { display: none; }
.sglv-dlc-group-head {
    display: flex !important;
    align-items: center !important;
    gap: 8px !important;
    padding: 8px 12px !important;
    cursor: pointer !important;
    background: rgba(102, 192, 244, 0.06) !important;
    transition: background 0.15s !important;
}
.sglv-dlc-group-head:hover { background: rgba(102, 192, 244, 0.12) !important; }
.sglv-dlc-arrow { font-size: 12px; color: #94a3b8; transition: transform 0.15s; flex-shrink: 0; }
.sglv-dlc-pname { font-weight: 600; font-size: 13px; color: #e2e8f0; flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
.sglv-dlc-meta { font-size: 11px; color: #94a3b8; flex-shrink: 0; }
.sglv-dlc-pct { font-weight: 700; font-size: 13px; color: #66c0f4; font-variant-numeric: tabular-nums; flex-shrink: 0; }
/* === v1.9.3: DLC 父游戏 group 展开后,DLC 卡片用横版 4 列 grid（替代原 8 列竖图） === */
.sglv-dlc-card-row { display: grid; grid-template-columns: repeat(4, 1fr); gap: 8px; padding: 8px 12px 12px; }
.sglv-dlc-card-row .sglv-dlc-group-cover { width: 100% !important; }
@media (max-width: 1280px) { .sglv-dlc-card-row { grid-template-columns: repeat(3, 1fr) !important; } }
@media (max-width: 900px)  { .sglv-dlc-card-row { grid-template-columns: repeat(2, 1fr) !important; } }
@media (max-width: 600px)  { .sglv-dlc-card-row { grid-template-columns: 1fr !important; } }
.sglv-dlc-type-badge-music { background: rgba(34, 165, 247, 0.15); color: #22a5f7; border: 1px solid rgba(34, 165, 247, 0.25); padding: 1px 5px; border-radius: 3px; font-size: 9px; font-weight: 700; }
.sglv-dlc-type-badge-dlc { background: rgba(139, 92, 246, 0.15); color: #a78bfa; border: 1px solid rgba(139, 92, 246, 0.25); padding: 1px 5px; border-radius: 3px; font-size: 9px; font-weight: 700; }
.sglv-dlc-group-toggle { display: flex; gap: 2px; background: rgba(255, 255, 255, 0.06); border-radius: 8px; padding: 2px; }
.sglv-dlc-group-toggle .sglv-btn { padding: 4px 10px; font-size: 12px; font-weight: 600; border-radius: 6px; }

/* === v1.9.14: 捆绑包标签页专用样式 === */
.sglv-bundle-card { cursor: pointer; }
.sglv-bundle-dlc-list { margin-top: 6px; display: flex; flex-direction: column; gap: 3px; }
.sglv-bundle-dlc-item { display: flex; align-items: center; gap: 6px; padding: 3px 6px; border-radius: 4px; background: rgba(255,255,255,0.04); transition: background 0.15s; cursor: pointer; }
.sglv-bundle-dlc-item:hover { background: rgba(102,192,244,0.12); }
.sglv-bundle-dlc-name { flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; font-size: 11px; color: #94a3b8; }
.sglv-bundle-dlc-more { font-size: 10px; color: #64748b; padding: 2px 6px; font-style: italic; }

/* === v1.9.24: 锁区游戏 SVG 锁图案封面占位符 === */
.sglv-blocked-cover-placeholder {
    width: 100%; height: 100%;
    display: flex; flex-direction: column;
    align-items: center; justify-content: center;
    background: linear-gradient(135deg, #1a1a2e 0%, #16213e 40%, #0f3460 100%);
    position: relative; overflow: hidden;
}
.sglv-blocked-cover-placeholder::before {
    content: ''; position: absolute; inset: 0;
    background: radial-gradient(ellipse at 50% 35%, rgba(239,68,68,0.12) 0%, transparent 60%);
}
.sglv-blocked-cover-placeholder::after {
    content: ''; position: absolute; inset: 0;
    background: repeating-linear-gradient(45deg, transparent 0, transparent 12px, rgba(239,68,68,0.03) 12px, rgba(239,68,68,0.03) 24px);
    pointer-events: none;
}
.sglv-blocked-cover-placeholder .sglv-blocked-lock-svg {
    width: 48px; height: 48px;
    filter: drop-shadow(0 2px 8px rgba(239,68,68,0.4));
    z-index: 1; flex-shrink: 0;
}
.sglv-blocked-cover-placeholder .sglv-blocked-cover-name {
    margin-top: 8px; padding: 0 8px;
    font-size: 11px; font-weight: 600;
    color: rgba(248,113,113,0.8);
    text-align: center; line-height: 1.3;
    max-width: 90%; overflow: hidden;
    text-overflow: ellipsis; display: -webkit-box;
    -webkit-line-clamp: 2; -webkit-box-orient: vertical;
    z-index: 1;
}
/* 横版封面视图(cover)适配 */
.sglv-wl-cover-img-wrap .sglv-blocked-cover-placeholder {
    background: linear-gradient(135deg, #1a1a2e 0%, #16213e 50%, #0f3460 100%);
}
.sglv-wl-cover-img-wrap .sglv-blocked-cover-placeholder .sglv-blocked-lock-svg {
    width: 40px; height: 40px;
}
.sglv-wl-cover-img-wrap .sglv-blocked-cover-placeholder .sglv-blocked-cover-name {
    font-size: 10px;
}
/* 列表视图小图标 */
.sglv-list-icon.sglv-blocked-list-icon {
    width: 45px; height: 21px;
    display: flex; align-items: center; justify-content: center;
    background: linear-gradient(135deg, #1a1a2e, #0f3460);
    border: 1px solid rgba(239,68,68,0.2);
    border-radius: 3px;
}
.sglv-blocked-list-icon svg { width: 14px !important; height: 14px !important; }

/* === v1.9.24: KPI 卡片炫彩增强 === */
.sgc-panel .sglv-trend-kpi-card {
    background: linear-gradient(135deg, rgba(255,255,255,0.04) 0%, rgba(255,255,255,0.01) 100%) !important;
    border-width: 1px !important;
    position: relative; overflow: hidden;
    transition: transform 0.25s, box-shadow 0.25s, border-color 0.25s !important;
}
.sgc-panel .sglv-trend-kpi-card::after {
    content: ''; position: absolute; top: 0; left: -100%;
    width: 100%; height: 100%;
    background: linear-gradient(90deg, transparent, rgba(255,255,255,0.06), transparent);
    transition: left 0.6s; pointer-events: none;
}
.sgc-panel .sglv-trend-kpi-card:hover::after { left: 100%; }
.sgc-panel .sglv-trend-kpi-card:hover {
    transform: translateY(-2px) !important;
    box-shadow: 0 4px 20px rgba(0,0,0,0.3) !important;
}
.sgc-panel .sglv-trend-kpi-card.active {
    box-shadow: 0 0 0 1px var(--sglv-accent) inset, 0 4px 16px rgba(102,192,244,0.2) !important;
}
/* 锁区 KPI 红色卡片增强 */
.sgc-panel .sglv-trend-kpi-card[style*="ef4444"] {
    background: linear-gradient(135deg, rgba(239,68,68,0.08) 0%, rgba(239,68,68,0.02) 100%) !important;
}
.sgc-panel .sglv-trend-kpi-card[style*="ef4444"]:hover {
    box-shadow: 0 4px 20px rgba(239,68,68,0.25) !important;
    border-color: rgba(239,68,68,0.5) !important;
}
/* 橙色卡片增强 */
.sgc-panel .sglv-trend-kpi-card[style*="ff9800"] {
    background: linear-gradient(135deg, rgba(255,152,0,0.08) 0%, rgba(255,152,0,0.02) 100%) !important;
}
.sgc-panel .sglv-trend-kpi-card[style*="ff9800"]:hover {
    box-shadow: 0 4px 20px rgba(255,152,0,0.25) !important;
    border-color: rgba(255,152,0,0.5) !important;
}
/* 绿色(mine)卡片增强 */
.sgc-panel .sglv-trend-kpi-card.mine {
    background: linear-gradient(135deg, rgba(34,197,94,0.08) 0%, rgba(34,197,94,0.02) 100%) !important;
}
.sgc-panel .sglv-trend-kpi-card.mine:hover {
    box-shadow: 0 4px 20px rgba(34,197,94,0.25) !important;
    border-color: rgba(34,197,94,0.5) !important;
}
/* KPI 数值炫彩文字 */
.sgc-panel .sglv-trend-kpi-card .sglv-trend-kpi-value {
    text-shadow: 0 0 12px currentColor;
    filter: brightness(1.1);
}

/* === v1.9.24: 收集进度条炫彩 + 减细 === */
/* 系列分类筛选进度条减细（原 12px → 7px） */
.sgc-panel .sglv-progress-filter {
    height: 7px !important;
    border-radius: 4px !important;
}
.sgc-panel .sglv-progress-filter .sglv-progress-fill {
    background: linear-gradient(90deg, #4caf50, #22d3ee, #66c0f4) !important;
    box-shadow: 0 0 6px rgba(34,211,238,0.3) !important;
}
.sgc-panel .sglv-progress-filter .sglv-progress-fill.active {
    background: linear-gradient(90deg, #22c55e, #34d399, #22d3ee) !important;
    box-shadow: 0 0 8px rgba(34,211,238,0.5) !important;
}
/* 供应商/系列概览进度条也减细并炫彩 */
.sgc-panel .sglv-pub-card .sglv-progress,
.sgc-panel .sglv-series-card .sglv-progress {
    height: 4px !important;
    margin: 4px 0 2px !important;
}
.sgc-panel .sglv-pub-card .sglv-progress-fill,
.sgc-panel .sglv-series-card .sglv-progress-fill {
    background: linear-gradient(90deg, #4caf50, #22d3ee) !important;
}
/* 概览大进度条炫彩 */
.sgc-panel .sglv-stat-row + .sglv-progress {
    height: 8px !important;
    border-radius: 4px !important;
}
.sgc-panel .sglv-stat-row + .sglv-progress .sglv-progress-fill {
    background: linear-gradient(90deg, #4caf50, #22d3ee, #66c0f4, #a78bfa) !important;
    box-shadow: 0 0 8px rgba(102,192,244,0.3) !important;
}

/* === v1.9.33: 图片加载占位背景 + 焦点可见性 === */
/* 图片容器加载背景——封面图加载前显示柔和渐变占位 */
.sgc-panel .sglv-card-img-wrap,
.sgc-panel .sglv-wl-cover-img-wrap {
    background: linear-gradient(135deg, rgba(255,255,255,0.03) 0%, rgba(255,255,255,0.06) 50%, rgba(255,255,255,0.02) 100%);
}
/* 图片加载完成淡入动画 */
.sgc-panel .sglv-card-img,
.sgc-panel .sglv-wl-cover-img {
    opacity: 0; transition: opacity 0.3s ease;
}
.sgc-panel .sglv-card-img.sglv-img-loaded,
.sgc-panel .sglv-wl-cover-img.sglv-img-loaded {
    opacity: 1;
}
/* v1.9.43: 竖版容器内横图 letterbox——无竖版资产的游戏（API 兜底返回横版 header）
   onload 检测 naturalWidth>naturalHeight 后追加 sglv-img-wide 类，object-fit:contain
   完整显示 + 渐变底，替代 object-fit:cover 的居中裁切变形 */
.sgc-panel .sglv-card-img.sglv-img-wide {
    object-fit: contain !important;
    background: linear-gradient(160deg, rgba(22, 32, 45, 0.88) 0%, rgba(27, 40, 56, 0.88) 100%);
}
/* 焦点可见性——所有交互元素 focus-visible */
.sgc-panel .sglv-btn:focus-visible,
.sgc-panel .sglv-view-btn:focus-visible,
.sgc-panel .sglv-sort-select:focus-visible,
.sgc-panel .sglv-search:focus-visible,
.sgc-panel .sglv-delisted-type-btn:focus-visible,
.sgc-panel .sglv-delisted-sub-btn:focus-visible {
    outline: 2px solid var(--sglv-accent, #66c0f4);
    outline-offset: 2px;
}
/* select 暗色模式原生样式修复 */
.sgc-panel .sglv-sort-select {
    background-color: rgba(62, 68, 84, 0.8);
    color: #c7d5e0;
    border: 1px solid rgba(255,255,255,0.1);
}

/* === v1.9.34: 系列横版封面视图增强效果 === */
/* 封面卡片 hover 光晕 + 缩放 */
.sgc-panel .sglv-pub-cover-card {
    transition: transform 0.28s ease, box-shadow 0.28s ease, border-color 0.28s ease !important;
}
.sgc-panel .sglv-pub-cover-card:hover {
    transform: translateY(-3px) !important;
    box-shadow: 0 6px 24px rgba(0,0,0,0.4), 0 0 0 1px rgba(102,192,244,0.15) !important;
    border-color: rgba(102,192,244,0.35) !important;
}
/* 已拥有游戏封面卡片——绿色边框微光 */
.sgc-panel .sglv-pub-cover-card.sglv-pub-cover-owned {
    border-color: rgba(76,175,80,0.2) !important;
}
.sgc-panel .sglv-pub-cover-card.sglv-pub-cover-owned:hover {
    border-color: rgba(76,175,80,0.5) !important;
    box-shadow: 0 6px 24px rgba(0,0,0,0.4), 0 0 12px rgba(76,175,80,0.15) !important;
}
/* 封面图片 hover 缩放 */
.sgc-panel .sglv-pub-cover-card .sglv-wl-cover-img {
    transition: opacity 0.3s ease, transform 0.35s ease !important;
}
.sgc-panel .sglv-pub-cover-card:hover .sglv-wl-cover-img {
    transform: scale(1.04) !important;
}
/* 封面底部渐变遮罩——提升文字可读性 */
.sgc-panel .sglv-pub-cover-overlay {
    position: absolute !important;
    bottom: 0 !important; left: 0 !important; right: 0 !important;
    height: 50% !important;
    background: linear-gradient(to top, rgba(0,0,0,0.55) 0%, transparent 100%) !important;
    pointer-events: none !important;
    z-index: 1 !important;
}
/* 拥有状态徽章——封面右上角毛玻璃 */
.sgc-panel .sglv-pub-cover-badge {
    position: absolute !important;
    top: 6px !important; right: 6px !important;
    z-index: 2 !important;
    margin-top: 0 !important;
    backdrop-filter: blur(6px) !important;
    -webkit-backdrop-filter: blur(6px) !important;
    box-shadow: 0 1px 4px rgba(0,0,0,0.35) !important;
}

/* === v1.9.33: prefers-reduced-motion 无障碍降级 === */
@media (prefers-reduced-motion: reduce) {
    .sgc-panel *,
    .sgc-panel *::before,
    .sgc-panel *::after {
        animation-duration: 0.01ms !important;
        animation-iteration-count: 1 !important;
        transition-duration: 0.01ms !important;
        scroll-behavior: auto !important;
    }
    .sgc-panel .sglv-card-img,
    .sgc-panel .sglv-wl-cover-img {
        opacity: 1 !important;
        transition: none !important;
    }
}
`;

    // v1.9.24: 锁区游戏 SVG 锁图案——用于标签页图标和 KPI 卡片图标
    // 全新样式：渐变锁体 + 弧形锁扣 + 钥匙孔，带红色警示色调
    const BLOCKED_LOCK_ICON_SVG = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">'
        + '<rect x="5" y="11" width="14" height="10" rx="2" fill="currentColor" fill-opacity="0.15"/>'
        + '<path d="M8 11V7a4 4 0 0 1 8 0v4"/>'
        + '<circle cx="12" cy="15.5" r="1.5" fill="currentColor" stroke="none"/>'
        + '<line x1="12" y1="17" x2="12" y2="19"/>'
        + '</svg>';

    // v1.9.24: 锁区游戏 SVG 锁图案——最终兜底占位符
    // 使用递增序号生成唯一 gradient ID 避免多实例冲突
    let _blockedCoverSeq = 0;
    function blockedCoverSvg() {
        const sid = '_blk' + (_blockedCoverSeq++);
        return '<svg class="sglv-blocked-lock-svg" viewBox="0 0 120 120" xmlns="http://www.w3.org/2000/svg">'
            + '<defs>'
            + '<linearGradient id="' + sid + '-body" x1="0%" y1="0%" x2="100%" y2="100%">'
            + '<stop offset="0%" stop-color="#f87171"/><stop offset="100%" stop-color="#dc2626"/>'
            + '</linearGradient>'
            + '<linearGradient id="' + sid + '-shackle" x1="0%" y1="0%" x2="0%" y2="100%">'
            + '<stop offset="0%" stop-color="#fca5a5"/><stop offset="100%" stop-color="#ef4444"/>'
            + '</linearGradient>'
            + '<radialGradient id="' + sid + '-glow" cx="50%" cy="50%" r="50%">'
            + '<stop offset="0%" stop-color="#fbbf24" stop-opacity="0.6"/><stop offset="100%" stop-color="#fbbf24" stop-opacity="0"/>'
            + '</radialGradient>'
            + '</defs>'
            + '<circle cx="60" cy="60" r="30" fill="url(#' + sid + '-glow)"/>'
            + '<path d="M40 55 V42 a20 20 0 0 1 40 0 V55" fill="none" stroke="url(#' + sid + '-shackle)" stroke-width="7" stroke-linecap="round"/>'
            + '<rect x="30" y="55" width="60" height="45" rx="8" fill="url(#' + sid + '-body)" stroke="#dc2626" stroke-width="1.5"/>'
            + '<circle cx="60" cy="72" r="6" fill="#1a1a2e"/>'
            + '<rect x="57.5" y="76" width="5" height="10" rx="2.5" fill="#1a1a2e"/>'
            + '<circle cx="60" cy="72" r="2.5" fill="#fbbf24" opacity="0.8"/>'
            + '</svg>';
    }

    // v1.9.24: 锁区游戏封面兜底 DOM（CDN + API 全部失败时展示）
    function blockedPlaceholderDom(name) {
        const holder = document.createElement('div');
        holder.className = 'sglv-blocked-cover-placeholder';
        holder.innerHTML = blockedCoverSvg() + '<div class="sglv-blocked-cover-name">' + Host.wlEscape(name || '') + '</div>';
        return holder;
    }

    // v1.9.24: 锁区游戏封面全局回退——Steam CDN 全部失败时先用 Store API 取真实封面 URL，
    // API URL 仍加载失败时替换为 SVG 锁占位符（参照 _sglvPsCoverFallback 逻辑）
    // v1.9.29: 传递 kind 参数，使 API 兜底按图片类型选择最佳 URL
    unsafeWindow._sglvBlockedCoverFallback = function(img, appid, kind) {
        if (!img || !img.parentElement) return;
        Host.fetchCoverApiUrl(appid, kind).then(url => {
            if (url) {
                img.onerror = function() { img.onerror = null; img.parentElement.replaceChild(blockedPlaceholderDom(img.alt), img); };
                img.src = url;
                return;
            }
            img.parentElement.replaceChild(blockedPlaceholderDom(img.alt), img);
        });
    };

    // v1.9.24: 锁区游戏列表视图图标回退——CDN 图标失败时替换为锁图标占位 div
    unsafeWindow._sglvBlockedListIconFallback = function(img) {
        if (!img || !img.parentElement) return;
        const holder = document.createElement('div');
        holder.className = 'sglv-list-icon sglv-blocked-list-icon';
        holder.innerHTML = '<svg viewBox="0 0 24 24" fill="none" stroke="#f87171" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="5" y="11" width="14" height="10" rx="2" fill="rgba(239,68,68,0.2)"/><path d="M8 11V7a4 4 0 0 1 8 0v4"/></svg>';
        img.parentElement.replaceChild(holder, img);
    };

    // v1.9.24: 锁区游戏竖版封面——Steam 多 CDN 回退链 + Store API + SVG 锁兜底
    // 参照 psplusPosterImg 逻辑：先查 good 缓存 → CDN 回退链 → API → 锁占位
    // v1.9.29: ① 传递 kind 给 _sglvBlockedCoverFallback ② onerror 链跳过 chain[0]（与初始 src 相同）
    // v1.9.41: good/链走 coverGoodUrl/coverChainLang（steamui 精确 URL + 语言变体链，见模块头注释）
    function blockedPosterImg(appid, name) {
        const good = coverGoodUrl(appid, 'poster');
        if (good) {
            return '<img class="sglv-card-img" src="' + good + '" alt="' + Host.wlEscape(name) + '" loading="lazy" decoding="async" onerror="_sglvBlockedCoverFallback(this,\'' + appid + '\',\'poster\');" onload="' + _sgcvPosterOnloadAttr(appid) + '">';
        }
        // v1.9.44: 竖版确认缺失 → 横版替代直用（交叉缓存）
        const horizHtml = _sgcvHorizontalFallbackImgHtml(appid, Host.wlEscape(name), 'sglv-card-img', '_sglvBlockedCoverFallback');
        if (horizHtml) return horizHtml;
        const chain = coverChainLang(appid, 'poster');
        let handler = '_sglvBlockedCoverFallback(this, \'' + appid + '\', \'poster\');';
        for (let i = chain.length - 1; i >= 1; i--) {
            handler = 'this.src=\'' + chain[i] + '\';this.onerror=function(){' + handler + '}';
        }
        handler = '_sgcvCoverRace(this, \'' + appid + '\', \'poster\');' + handler;
        return '<img class="sglv-card-img" src="' + chain[0] + '" alt="' + Host.wlEscape(name) + '" loading="lazy" decoding="async" onerror="' + handler + '" onload="' + _sgcvPosterOnloadAttr(appid) + '">';
    }

    // v1.9.24: 锁区游戏横版封面（capsule 大横幅）——同上逻辑，kind=capsule
    // v1.9.29: ① 传递 kind 给 _sglvBlockedCoverFallback ② onerror 链跳过 chain[0]
    // v1.9.41: good/链走 coverGoodUrl/coverChainLang
    function blockedCapsuleImg(appid, name) {
        const good = coverGoodUrl(appid, 'capsule');
        if (good) {
            return '<img class="sglv-wl-cover-img" src="' + good + '" alt="' + Host.wlEscape(name) + '" loading="lazy" decoding="async" onerror="_sglvBlockedCoverFallback(this,\'' + appid + '\',\'capsule\');" onload="this.classList.add(\'sglv-img-loaded\');_sglvRecordPosterGood(\'' + appid + '\',this.src,\'capsule\');">';
        }
        const chain = coverChainLang(appid, 'capsule');
        let handler = '_sglvBlockedCoverFallback(this, \'' + appid + '\', \'capsule\');';
        for (let i = chain.length - 1; i >= 1; i--) {
            handler = 'this.src=\'' + chain[i] + '\';this.onerror=function(){' + handler + '}';
        }
        handler = '_sgcvCoverRace(this, \'' + appid + '\', \'capsule\');' + handler;
        return '<img class="sglv-wl-cover-img" src="' + chain[0] + '" alt="' + Host.wlEscape(name) + '" loading="lazy" decoding="async" onerror="' + handler + '" onload="this.classList.add(\'sglv-img-loaded\');_sglvRecordPosterGood(\'' + appid + '\',this.src,\'capsule\');">';
    }

    // v2.9.22: sgc-panel 拖动（参考 steam-friend-manager 1.2.5 makeDraggable）
    // 用 !important 覆盖 shared CSS 中 sglv-panel 的 top/left/transform 定位
    function makeSgcDraggable(el, handle) {
        if (!el || !handle) return;
        let isDragging = false, startX = 0, startY = 0, startLeft = 0, startTop = 0;
        const onDown = (e) => {
            const t = e.target;
            if (t.closest('button, input, select, textarea, label, a')) return;
            isDragging = true;
            startX = e.clientX; startY = e.clientY;
            const rect = el.getBoundingClientRect();
            startLeft = rect.left; startTop = rect.top;
            el.style.cursor = 'grabbing';
            e.preventDefault();
        };
        const onMove = (e) => {
            if (!isDragging) return;
            el.style.setProperty('left', (startLeft + e.clientX - startX) + 'px', 'important');
            el.style.setProperty('top', (startTop + e.clientY - startY) + 'px', 'important');
            el.style.setProperty('right', 'auto', 'important');
            el.style.setProperty('bottom', 'auto', 'important');
            el.style.setProperty('transform', 'none', 'important');
        };
        const onUp = () => {
            if (!isDragging) return;
            isDragging = false;
            el.style.cursor = '';
        };
        handle.addEventListener('mousedown', onDown);
        document.addEventListener('mousemove', onMove);
        document.addEventListener('mouseup', onUp);
    }

    function init(ctx) {
        if (!ctx || typeof ctx !== 'object') {
            console.warn('[SGLVCollection] init: invalid ctx');
            return false;
        }
        if (ctx.apiVersion !== apiVersion) {
            console.warn('[SGLVCollection] Host apiVersion mismatch: expected', apiVersion, 'got', ctx.apiVersion);
            // 尝试用宿主的 showToast 提示（可能不可用）
            try {
                if (ctx.showToast) {
                    const zh = ctx.isZh;
                    ctx.showToast(zh
                        ? '收藏模块版本不兼容，请更新主脚本或收藏模块'
                        : 'Collection module version mismatch, please update host script or collection module');
                }
            } catch (e) { /* ignore */ }
            return false;
        }
        Host = ctx;
        // v1.9.47-fix: 同步预热绝版游戏远程源 TTL 缓存(避免开 tab 才发起请求,首屏秒开)
        try { _warmDelistedRemoteCache(); } catch (e) { /* 忽略 */ }
        return true;
    }

    // ==================== 游戏收藏模块 ====================
        // v1.9.5: 永久缓存层——绕过宿主 TTL 缓存
        // v1.9.6: 从 GM_getValue/GM_setValue 迁移到 SGLVCore.IDB
        //   原因:GM_setValue 在多数环境有 5MB 限制,大收藏数据(数千条 + 元数据)可能撑爆
        //        IDB 容量无限制,且与主脚本 PCC 持久化层同源,统一管理
        //   旧 key 'sglv_perm_xxx' 兼容:首次读取时尝试从旧 GM key 迁移,迁移后清旧 key
        const PERM_CACHE_PREFIX = 'sglv_idb_perm_';
        const PERM_CACHE_GM_PREFIX = 'sglv_perm_';   // v1.9.5 旧 key,用于一次性迁移
        const _C_IDB = _C && _C.IDB;
        function _permCacheGet(key) {
            // 1) 优先从 IDB 读
            if (_C_IDB) {
                try {
                    const v = _C_IDB.get(PERM_CACHE_PREFIX + key, null);
                    if (v != null) return v;
                } catch (e) { /* IDB 读失败,降级到旧 GM */ }
            }
            // 2) 旧 GM 兜底(一次性迁移)— 读旧 key 并迁移到 IDB
            try {
                const raw = GM_getValue(PERM_CACHE_GM_PREFIX + key, '');
                if (!raw) return null;
                const parsed = JSON.parse(raw);
                // 立即迁移到 IDB
                if (_C_IDB && parsed != null) {
                    try { _C_IDB.set(PERM_CACHE_PREFIX + key, parsed); } catch (e) { /* ignore */ }
                    // 迁移成功后清旧 key(可选,这里保留以防 IDB 写入失败)
                    // 不主动清,让 IDB 读优先 + 下次读时也会再次尝试迁移
                }
                return parsed;
            } catch { return null; }
        }
        function _permCacheSet(key, data) {
            if (_C_IDB) {
                try { _C_IDB.set(PERM_CACHE_PREFIX + key, data); return; } catch (e) { /* IDB 失败,降级 */ }
            }
            // 降级到旧 GM
            try { GM_setValue(PERM_CACHE_GM_PREFIX + key, JSON.stringify(data)); } catch (e) { /* ignore quota */ }
        }
        // v1.9.5: 按 appid 增量合并——新数据覆盖同 appid 条目，旧数据中独有的条目保留
        function _mergeByAppid(oldItems, newItems) {
            if (!Array.isArray(oldItems) || oldItems.length === 0) return newItems || [];
            if (!Array.isArray(newItems) || newItems.length === 0) return oldItems;
            const map = new Map();
            oldItems.forEach(g => { if (g && g.appid) map.set(g.appid, g); });
            newItems.forEach(g => { if (g && g.appid) map.set(g.appid, g); });
            return Array.from(map.values());
        }
        // v1.9.5: appid 数组增量合并（去重）
        function _mergeAppidArray(oldIds, newIds) {
            const set = new Set(oldIds || []);
            (newIds || []).forEach(id => set.add(id));
            return Array.from(set);
        }
        // v1.9.5: 后台刷新节流检查——intervalMs 内已刷新过则跳过
        function _shouldThrottle(lastTs, intervalMs) {
            return lastTs > 0 && (Date.now() - lastTs) < intervalMs;
        }

        // v1.9.5: debounce 工具函数——避免搜索框每次按键触发完整重渲染
        function _debounce(fn, delay = 200) {
            let timer = null;
            const debounced = function(...args) {
                if (timer) clearTimeout(timer);
                timer = setTimeout(() => { fn.apply(this, args); timer = null; }, delay);
            };
            return debounced;
        }
        // v1.9.5: 缓存 Intl.Collator 实例，避免每次过滤都重新构造
        const _nameCollator = new Intl.Collator(undefined, { numeric: true, sensitivity: 'base' });

        let _collectionActiveTab = 'delisted';   // v2.9.22: 默认标签改为"绝版游戏"（与新 tab 顺序一致）
        let _collectionBodyInitialized = false;   // v2.9.22: 跟踪 body 是否已首次渲染——避免首次打开闪一帧骨架
        let collectionOverlayEl = null;
        let collectionPanelEl = null;

        // ---------- 模块本地状态（v2.6.4 起不再挂主 state，库化后天然隔离） ----------
        // v1.8.2: mode = 'publisher' | 'series' — 供应商/系列双模式切换（系列数据独立展示不合并）
        // v2.9.92: 新增 supplierResult/seriesResult 跟踪各自刷新结果（updated/nochange/error）
        // v1.9.40: 移除 supplierFetchedAt/seriesFetchedAt——更新时间文本不再常驻工具栏（曾压缩切换按钮致变形），
        //          刷新结果改为悬浮提示（不参与 flex 布局）
        const pubState = { mode: 'publisher', expandedPublishers: new Set(), selectedPublisher: null, selectedSeries: null, viewMode: 'card', filter: 'all',
            dataLoading: false, refreshStage: '',
            supplierResult: '', seriesResult: '', showResultUntil: 0,
            // v1.9.31: 系列详情排序——sortField: order|date|name|appid，sortDir: asc|desc
            sortField: 'order', sortDir: 'asc' };
        // v1.9.19: 系列详情分页状态（供应商/系列详情共用）——pageSize 与其他 tab 保持一致(48)
        // pageCache: { key: 页码 } 记忆每个系列的浏览页码，切换回已浏览分类时恢复进度
        const pubDetailState = { page: 1, pageSize: 48, cacheKey: null, pageCache: new Map() };
        const delistedState = { search: '', typeFilter: 'all', subFilter: 'all', page: 1, pageSize: 48, viewMode: 'card',
            // v1.9.32: 绝版游戏排序——appidDesc|appidAsc|dateDesc|dateAsc
            // v1.9.47-fix: pageSize 50→48——与其他 tab(psplus/epic/blocked/goty/dlc/bundle)保持一致
            sort: 'appidDesc' };
        const psplusState = { games: [], loaded: false, loading: false, search: '', tierFilter: 'all', statusFilter: 'all', sort: 'dateDesc', page: 1, pageSize: 48, viewMode: 'card', updatedAt: '', loadError: null };
        // v2.7.9: Epic 赠送模块状态（数据仅为 Steam appid 数组，名称异步加载）
        const epicState = { appids: [], loaded: false, loading: false, search: '', ownFilter: 'all', sort: 'appidDesc', page: 1, pageSize: 48, viewMode: 'card', updatedAt: '', loadError: null, source: '' };
        // v2.9.7: 年度大作模块状态（数据含 name/date/appid，名称无需异步加载）
        // v1.7.0: 加 year 字段——按年拉取数据 (GitHub 2024/2025/2026.json), 默认 null = 自动选最新有数据的年份
        const gotyState = { games: [], loaded: false, loading: false, year: null, availableYears: [], search: '', ownFilter: 'all', sort: 'dateDesc', page: 1, pageSize: 48, viewMode: 'card', updatedAt: '', loadError: null, source: '', lastFetchAt: 0 };
        // v1.9.0: DLC 收藏模块状态——三级渐进加载（Barter.vg DLC DB → Steam 全库存 type → DLC 子类型）
        // v1.9.1: 加 stage / level*Done 字段——支持 L1∥L2 并行 + 中间阶段增量 rebuild（不阻塞 UI 进程）
        // v1.9.2: 加 dlcTypeCache 字段——本地 IDB 永久缓存 DLC 子类型映射（只增不减）,实现真正增量
        const dlcState = {
            dlcs: [], parentTotalMap: {},
            loaded: false, loading: false, loadError: null,
            search: '', typeFilter: 'all', sort: 'parentAsc', page: 1, pageSize: 48,
            viewMode: 'card', groupMode: true, expandedParents: new Set(),
            ownFilter: 'all',  // v1.9.4: 全部/已拥有 筛选
            stage: 0,           // 0=未开始 1=Barter.vg 2=appType 3=DLC 子类型
            level1Done: false,  // Barter.vg DLC DB 完成
            level2Done: false,  // Steam 全库存 appType 完成
            rebuildQueued: false, // 防抖：同一帧多次 scheduleRebuild 合并
            // v1.9.2: 本地 IDB 永久缓存,key=appId,value=type('dlc'/'music'/'video'...)
            // 加载时用此缓存立即填充 buildDlcList,只 enrich 缓存里没有的 DLC（真正的"只增不减"增量）
            dlcTypeCache: {},
            dlcTypeCacheLoaded: false,  // IDB 异步加载完成后置 true
            idbLoadPromise: null,        // 第一次 IDB.loadAll 的 promise（避免重复）
            // v1.9.3: 后台静默刷新节流（避免短时间内重复 enrich）
            lastBgRefreshAt: 0,
            // v1.9.8: 后台 DLC 子类型增量获取中（不阻塞 UI 渲染）
            dlcTypeEnriching: false,
            // v1.9.8: 缓存 filteredDlc 结果（filters/search/sort 未变时跳过重算）
            _filteredCache: null,
            _filteredCacheKey: null,
        };
        // v1.9.2: IDB 缓存 schema 版本号（用于 cache invalidation 升级）
        // v1.9.3: 版本号稳定为 1——业务 key（dlc_subtype_map）+ 内容 schema 都没变,lib 升级不应清缓存
        const _DLC_CACHE_VERSION = { dlc_subtype: 1 };

        // v1.9.14: 捆绑包标签页状态——复用 DLC 进包数据(Host.getBundleCount + Host.getDlcsByParentMap)
        const bundleState = {
            data: [],           // [{appid,name,isOwned,totalBundle,dlcCount,dlcs:[{appid,name,bundleCount,isOwned,playtime}]}]
            loaded: false,
            search: '',
            sort: 'bundleDesc',
            page: 1,
            pageSize: 48,
        };
        const _DLC_TYPE_CACHE_IDB_KEY = 'dlc_subtype_map';
        // v1.9.3: 后台静默刷新节流——6h（与 cloud-save 同步,避免短时间内重复跑 L1+L2+L3）
        const _DLC_BG_REFRESH_INTERVAL = 6 * 3600 * 1000;
        // v1.9.1: DLC 三级加载阶段文案（loading 骨架中央显示当前阶段）
        const DLC_STAGES = [
            null, // 0 占位
            { pct: 15, zh: '加载 Barter.vg DLC 数据库…',       en: 'Loading Barter.vg DLC DB…' },
            { pct: 55, zh: '补全 Steam 全库存应用类型…',      en: 'Enriching Steam app types…' },
            { pct: 85, zh: '获取 DLC 子类型（音乐/视频…）…',  en: 'Fetching DLC subtypes…' },
        ];

        // ==================== 供应商分类标签页 ====================
        // v1.9.19: 统计缓存——数据安装期注入后低频更新，按 GAME_DB 引用缓存计算结果；
        // @resource 更新后 getGameDb() 返回新引用 → Map key 变化自动失效（Map 最多保留 2 代引用，防内存泄漏）
        const _pubStatsCache = new Map();   // dbRef → { sig, inner: Map(pubName → { total, owned }) }
        const _seriesStatsCache = new Map(); // dbRef → { sig, inner: Map(pubName + '\u0000' + seriesName → { total, owned }) }
        function _getStatsCacheForDb(map) {
            const db = Host.getGameDb();
            if (!db) return null;
            // v1.9.19-fix: sig = 拥有集合规模 + 家庭共享开关——面板打开期间重新同步家庭库
            // （sglv:games-updated）时 db 引用不变但拥有集合变化，需整代失效；
            // sig 随每代缓存独立存放（不共用全局表），避免两个缓存重建时序互相干扰
            const sig = (Host.getOwnedGames ? Host.getOwnedGames().length : -1) + '|' + !!Host.getShowFamilyShared();
            let entry = map.get(db);
            if (entry && entry.sig !== sig) entry = null; // sig 变化 → 整代失效
            if (!entry) {
                entry = { sig, inner: new Map() };
                map.set(db, entry);
                if (map.size > 2) map.delete(map.keys().next().value);
            }
            return entry.inner;
        }

        function computePublisherStats(pubName) {
            const db = Host.getGameDb();
            const pub = db?.[pubName];
            if (!pub) return { total: 0, owned: 0 };
            const inner = _getStatsCacheForDb(_pubStatsCache);
            if (inner) {
                const hit = inner.get(pubName);
                if (hit) return hit;
            }
            let total = 0, owned = 0;
            const activeOwnedIds = Host.getActiveOwnedAppIds();
            for (const series of Object.values(pub)) {
                total += series.length;
                for (const g of series) if (activeOwnedIds.has(g.id)) owned++;
            }
            const res = { total, owned };
            if (inner) inner.set(pubName, res);
            return res;
        }

        function computeSeriesStats(pubName, seriesName) {
            const db = Host.getGameDb();
            const series = db?.[pubName]?.[seriesName];
            if (!series) return { total: 0, owned: 0 };
            const inner = _getStatsCacheForDb(_seriesStatsCache);
            const key = pubName + '\u0000' + seriesName;
            if (inner) {
                const hit = inner.get(key);
                if (hit) return hit;
            }
            let owned = 0;
            const activeOwnedIds = Host.getActiveOwnedAppIds();
            for (const g of series) if (activeOwnedIds.has(g.id)) owned++;
            const res = { total: series.length, owned };
            if (inner) inner.set(key, res);
            return res;
        }

        // v1.9.16: genres 类型标签 HTML（game-db-v1.2.json 可选字段；旧数据无 genres 时返回空串，安全降级）
        function genreTagsHtml(g, max = 3) {
            if (!Array.isArray(g.genres) || !g.genres.length) return '';
            const tags = g.genres.slice(0, max).map(t => `<span class="sglv-pub-genre-tag">${Host.wlEscape(t)}</span>`).join('');
            const more = g.genres.length > max ? `<span class="sglv-pub-genre-tag" title="${Host.wlEscape(g.genres.join(' / '))}">+${g.genres.length - max}</span>` : '';
            return tags + more;
        }

        // 统一计算游戏拥有状态徽章信息（供供应商分类列表/卡片视图复用）
        function getGameBadgeInfo(g, ownedAppIds) {
            const isOwned = ownedAppIds.has(g.id);
            if (!isOwned) return { isOwned: false, badgeClass: 'missing', badgeText: Host.T.missing, tooltip: '' };
            const gameObj = Host.getOwnedGames().find(og => og.appid === g.id);
            if (gameObj && !Host.isGameOwnedByMe(gameObj)) {
                return { isOwned: true, badgeClass: 'shared', badgeText: Host.isZh ? '共享' : 'Shared', tooltip: `title="共享自: ${Host.getGameOwnerNames(gameObj)}"` };
            }
            return { isOwned: true, badgeClass: 'owned', badgeText: '✓ ' + Host.T.owned, tooltip: '' };
        }

        function renderPublisherTab(parent) {
            const body = document.createElement('div');
            body.className = 'sglv-pub-layout';

            // 左侧边栏（v1.8.2: 顶部含供应商/系列模式切换）
            const sidebar = document.createElement('div');
            sidebar.className = 'sglv-pub-sidebar';
            sidebar.id = 'sglv-pub-sidebar';
            body.appendChild(sidebar);

            // 右侧内容
            const main = document.createElement('div');
            main.className = 'sglv-pub-main';
            main.id = 'sglv-pub-main';
            body.appendChild(main);

            parent.appendChild(body);

            renderPubSidebar();
            if (pubState.mode === 'series') {
                // v1.8.2: 系列模式——默认展开第一个系列
                ensureSeriesSelected();
                if (pubState.selectedSeries) renderSeriesModeDetail(pubState.selectedSeries);
                else renderSeriesModeEmpty();
            } else {
                // v1.9.19: 供应商模式——默认展开首个供应商并选中其首个系列，按需渲染（不再默认停留 Overview）
                ensurePublisherSelected();
                if (pubState.selectedSeries) {
                    renderPubSeriesDetail(pubState.selectedPublisher, pubState.selectedSeries);
                } else if (pubState.selectedPublisher) {
                    renderPubPublisherDetail(pubState.selectedPublisher);
                } else {
                    renderPubOverview(); // GAME_DB 为空时保持总览（空态）
                }
            }
        }

        /** v1.9.19: 确保供应商模式下有选中项：未选中/选中项已不存在时默认展开第一个供应商并选中其第一个系列（参照 ensureSeriesSelected） */
        function ensurePublisherSelected() {
            const db = Host.getGameDb() || {};
            const pubNames = Object.keys(db);
            if (!pubNames.length) { pubState.selectedPublisher = null; pubState.selectedSeries = null; return; }
            if (!pubState.selectedPublisher || !db[pubState.selectedPublisher]) {
                pubState.selectedPublisher = pubNames[0];
                pubState.selectedSeries = null;
            }
            pubState.expandedPublishers.add(pubState.selectedPublisher);
            if (!pubState.selectedSeries || !db[pubState.selectedPublisher][pubState.selectedSeries]) {
                const seriesNames = Object.keys(db[pubState.selectedPublisher]);
                pubState.selectedSeries = seriesNames.length ? seriesNames[0] : null;
            }
        }

        // ---- v1.8.2: 系列数据访问（宿主未提供 getSeriesDb 时安全降级） ----
        function getSeriesDb() {
            return (typeof Host.getSeriesDb === 'function' && Host.getSeriesDb()) || {};
        }

        function computeSeriesModeStats(seriesName) {
            const games = getSeriesDb()[seriesName] || [];
            let owned = 0;
            const activeOwnedIds = Host.getActiveOwnedAppIds();
            for (const g of games) if (activeOwnedIds.has(g.id)) owned++;
            return { total: games.length, owned };
        }

        /** 确保系列模式下有选中项：未选中/选中项已不存在时默认展开第一个系列 */
        function ensureSeriesSelected() {
            const db = getSeriesDb();
            const names = Object.keys(db);
            if (!names.length) { pubState.selectedSeries = null; return; }
            if (!pubState.selectedSeries || !db[pubState.selectedSeries]) {
                pubState.selectedSeries = names[0];
            }
        }

        /** v1.8.2: 供应商/系列模式切换条 */
        function renderPubModeSwitch() {
            const wrap = document.createElement('div');
            wrap.className = 'sglv-pub-mode-switch';
            const modes = [
                { key: 'publisher', label: Host.isZh ? '供应商' : 'Publisher' },
                { key: 'series', label: Host.isZh ? '系列' : 'Series' },
            ];
            for (const m of modes) {
                const btn = document.createElement('button');
                btn.className = 'sglv-pub-mode-btn' + (pubState.mode === m.key ? ' active' : '');
                btn.textContent = m.label;
                btn.addEventListener('click', () => {
                    if (pubState.mode === m.key) return;
                    pubState.mode = m.key;
                    pubState.filter = 'all';
                    renderPubSidebar();
                    if (m.key === 'series') {
                        ensureSeriesSelected();
                        if (pubState.selectedSeries) renderSeriesModeDetail(pubState.selectedSeries);
                        else renderSeriesModeEmpty();
                    } else {
                        // v1.9.19: 切回供应商模式——同样默认进入首个供应商的首个系列（选中项有效则保留）
                        ensurePublisherSelected();
                        if (pubState.selectedSeries) {
                            renderPubSeriesDetail(pubState.selectedPublisher, pubState.selectedSeries);
                        } else if (pubState.selectedPublisher) {
                            renderPubPublisherDetail(pubState.selectedPublisher);
                        } else {
                            renderPubOverview();
                        }
                    }
                });
                wrap.appendChild(btn);
            }
            // v2.9.91: 两种模式均显示刷新按钮——同时刷新供应商+系列数据
            const hasRefresh = typeof Host.loadSeriesData === 'function' || typeof Host.loadSupplierData === 'function';
            if (hasRefresh) {
                const refreshBtn = document.createElement('button');
                refreshBtn.className = 'sglv-pub-mode-btn sglv-pub-series-refresh';
                refreshBtn.id = 'sglv-pub-refresh';
                refreshBtn.title = Host.isZh ? '刷新供应商和系列数据' : 'Refresh supplier & series data';
                refreshBtn.innerHTML = Host.ICONS.refresh;
                refreshBtn.addEventListener('click', () => loadAllCollectionData(true));
                wrap.appendChild(refreshBtn);
                // v1.9.40: 不再常驻状态文本（更新时间曾压缩切换按钮致变形）——刷新结果由悬浮提示显示
            }
            return wrap;
        }

        /**
         * v1.9.37: 刷新供应商/系列标签页内容（侧边栏+详情区域），不闪骨架屏
         * 供 loadAllCollectionData 完成回调和 sglv:series/supplier-data-loaded 事件复用
         */
        function refreshPublisherTabContent() {
            if (_collectionActiveTab !== 'publisher' || !collectionPanelEl || !collectionPanelEl.classList.contains('sglv-show')) return;
            renderPubSidebar();
            if (pubState.mode === 'series') {
                ensureSeriesSelected();
                if (pubState.selectedSeries) renderSeriesModeDetail(pubState.selectedSeries);
                else renderSeriesModeEmpty();
            } else {
                ensurePublisherSelected();
                if (pubState.selectedSeries) {
                    renderPubSeriesDetail(pubState.selectedPublisher, pubState.selectedSeries);
                } else if (pubState.selectedPublisher) {
                    renderPubPublisherDetail(pubState.selectedPublisher);
                } else {
                    renderPubOverview();
                }
            }
        }

        /**
         * v2.9.91: 同时加载供应商和系列数据（并行）
         * v1.9.37: 移除 refreshStage 加载进度文本，仅保留刷新按钮 spinner 动画
         * v2.9.92: 收集各自结果状态，刷新完成后显示汇总（已更新/已是最新/失败）
         * v1.9.40: 结果汇总改为悬浮提示，不参与工具栏 flex 布局
         * @param {boolean} force - 强制刷新
         */
        function loadAllCollectionData(force) {
            if (pubState.dataLoading) return;
            pubState.dataLoading = true;
            pubState.supplierResult = '';
            pubState.seriesResult = '';
            const refreshBtn = document.getElementById('sglv-pub-refresh');
            if (refreshBtn) refreshBtn.classList.add('sglv-spin');

            const tasks = [];
            // 供应商数据（v1.9.37: 不再传 onProgress 回调，避免加载文本导致界面变形）
            if (typeof Host.loadSupplierData === 'function') {
                tasks.push(Host.loadSupplierData(force).then(result => {
                    pubState.supplierResult = (result && result.status) || 'error';
                }).catch(() => {
                    pubState.supplierResult = 'error';
                }));
            }
            // 系列数据
            if (typeof Host.loadSeriesData === 'function') {
                tasks.push(Host.loadSeriesData(force).then(result => {
                    pubState.seriesResult = (result && result.status) || 'error';
                }).catch(() => {
                    pubState.seriesResult = 'error';
                }));
            }

            Promise.all(tasks).finally(() => {
                pubState.dataLoading = false;
                if (refreshBtn) refreshBtn.classList.remove('sglv-spin');
                // v2.9.92: 显示刷新结果摘要（3秒后消失）
                pubState.showResultUntil = Date.now() + 3000;
                renderPubRefreshToast();
                setTimeout(() => {
                    if (pubState.showResultUntil && Date.now() >= pubState.showResultUntil) {
                        pubState.showResultUntil = 0;
                        renderPubRefreshToast();
                    }
                }, 3100);
                // v1.9.37: 使用统一的刷新函数，不再内联渲染逻辑
                refreshPublisherTabContent();
            });
        }

        /** v1.9.40: 刷新结果悬浮提示（3秒后自动消失）
         *  取代 v2.9.92 的常驻状态文本——更新时间文本曾压缩供应商/系列切换按钮导致变形；
         *  提示为绝对定位悬浮元素，不参与工具栏 flex 布局，任何内容都不会影响按钮宽度 */
        function renderPubRefreshToast() {
            const wrap = document.querySelector('.sgc-panel .sglv-pub-mode-switch');
            if (!wrap) return;
            let el = wrap.querySelector('.sglv-pub-refresh-toast');
            // 刷新结果摘要（刷新完成后3秒内显示）
            if (pubState.showResultUntil && Date.now() < pubState.showResultUntil) {
                const parts = [];
                const zh = Host.isZh;
                // 供应商结果
                if (pubState.supplierResult === 'updated') {
                    parts.push(`<span class="sglv-pub-status-ok">${zh ? '供应商✓' : 'Pub✓'}</span>`);
                } else if (pubState.supplierResult === 'nochange') {
                    parts.push(`<span class="sglv-pub-status-dim">${zh ? '供应商=' : 'Pub='}</span>`);
                } else if (pubState.supplierResult === 'error') {
                    parts.push(`<span class="sglv-pub-status-err">${zh ? '供应商✗' : 'Pub✗'}</span>`);
                }
                // 系列结果
                if (pubState.seriesResult === 'updated') {
                    parts.push(`<span class="sglv-pub-status-ok">${zh ? '系列✓' : 'Ser✓'}</span>`);
                } else if (pubState.seriesResult === 'nochange') {
                    parts.push(`<span class="sglv-pub-status-dim">${zh ? '系列=' : 'Ser='}</span>`);
                } else if (pubState.seriesResult === 'error') {
                    parts.push(`<span class="sglv-pub-status-err">${zh ? '系列✗' : 'Ser✗'}</span>`);
                }
                if (!parts.length) return;
                if (!el) {
                    el = document.createElement('span');
                    el.className = 'sglv-pub-refresh-toast';
                    wrap.appendChild(el);
                }
                el.innerHTML = parts.join(' ');
                return;
            }
            pubState.showResultUntil = 0;
            if (el) el.remove();
        }

        /** v1.8.2: 系列模式侧边栏——扁平系列列表（不做二级分类） */
        function renderSeriesSidebarList(sidebar) {
            const db = getSeriesDb();
            const names = Object.keys(db);
            // v1.9.37: 移除"系列数据加载中…"提示，数据未就绪时直接返回（避免界面变形）
            if (!names.length) return;
            for (const seriesName of names) {
                const sStats = computeSeriesModeStats(seriesName);
                const completionPct = sStats.total > 0 ? Math.round(sStats.owned / sStats.total * 100) : 0;
                const item = document.createElement('div');
                item.className = 'sglv-series-flat-item' + (pubState.selectedSeries === seriesName ? ' active' : '');
                item.innerHTML = `
                    <span class="sglv-series-name">${seriesName}</span>
                    <span class="sglv-series-stats" style="color:${completionPct === 100 ? '#4caf50' : completionPct > 0 ? '#66c0f4' : '#8f98a0'}">${sStats.owned}/${sStats.total}</span>
                `;
                item.addEventListener('click', () => {
                    pubState.selectedSeries = seriesName;
                    renderPubSidebar();
                    renderSeriesModeDetail(seriesName);
                });
                sidebar.appendChild(item);
            }
        }

        function renderPubSidebar() {
            const sidebar = document.getElementById('sglv-pub-sidebar');
            if (!sidebar) return;
            sidebar.innerHTML = '';

            // v1.8.2: 顶部模式切换（供应商 / 系列）
            sidebar.appendChild(renderPubModeSwitch());

            // v1.8.2: 系列模式——扁平系列列表，无二级分类
            if (pubState.mode === 'series') {
                renderSeriesSidebarList(sidebar);
                return;
            }

            for (const [pubName, pubData] of Object.entries(Host.getGameDb())) {
                const pStats = computePublisherStats(pubName);
                const isExpanded = pubState.expandedPublishers.has(pubName);

                const pubEl = document.createElement('div');
                pubEl.className = 'sglv-pub-item';

                const header = document.createElement('div');
                header.className = `sglv-pub-header${pubState.selectedPublisher === pubName && !pubState.selectedSeries ? ' active' : ''}`;
                header.innerHTML = `
                    <svg class="sglv-pub-arrow${isExpanded ? ' expanded' : ''}" viewBox="0 0 24 24"><path d="M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"/></svg>
                    <span class="sglv-pub-name">${pubName}</span>
                    <span class="sglv-pub-stats">${pStats.owned}/${pStats.total}</span>
                `;
                header.addEventListener('click', () => {
                    if (pubState.expandedPublishers.has(pubName)) pubState.expandedPublishers.delete(pubName);
                    else pubState.expandedPublishers.add(pubName);
                    pubState.selectedPublisher = pubName;
                    pubState.selectedSeries = null;
                    renderPubSidebar();
                    renderPubPublisherDetail(pubName);
                });
                pubEl.appendChild(header);

                const seriesList = document.createElement('div');
                seriesList.className = `sglv-series-list${isExpanded ? ' expanded' : ''}`;
                for (const [seriesName, games] of Object.entries(pubData)) {
                    const sStats = computeSeriesStats(pubName, seriesName);
                    const completionPct = sStats.total > 0 ? Math.round(sStats.owned / sStats.total * 100) : 0;
                    const isSelected = pubState.selectedPublisher === pubName && pubState.selectedSeries === seriesName;

                    const seriesHeader = document.createElement('div');
                    seriesHeader.className = `sglv-series-header${isSelected ? ' active' : ''}`;
                    seriesHeader.innerHTML = `
                        <span class="sglv-series-name">${seriesName}</span>
                        <span class="sglv-series-stats" style="color:${completionPct === 100 ? '#4caf50' : completionPct > 0 ? '#66c0f4' : '#8f98a0'}">${sStats.owned}/${sStats.total}</span>
                    `;
                    seriesHeader.addEventListener('click', e => {
                        e.stopPropagation();
                        pubState.selectedPublisher = pubName;
                        pubState.selectedSeries = seriesName;
                        renderPubSidebar();
                        renderPubSeriesDetail(pubName, seriesName);
                    });
                    seriesList.appendChild(seriesHeader);
                }
                pubEl.appendChild(seriesList);
                sidebar.appendChild(pubEl);
            }
        }

        function renderPubOverview() {
            const main = document.getElementById('sglv-pub-main');
            if (!main) return;

            let totalAll = 0, ownedAll = 0;
            for (const pubName of Object.keys(Host.getGameDb())) {
                const s = computePublisherStats(pubName);
                totalAll += s.total;
                ownedAll += s.owned;
            }
            const pctAll = totalAll > 0 ? Math.round(ownedAll / totalAll * 100) : 0;

            const showFamilyShared = Host.getShowFamilyShared();
            const activeTotalGames = showFamilyShared ? Host.getOwnedGames().length : Host.getOwnedGames().filter(g => Host.isGameOwnedByMe(g)).length;

            let html = `
                <div class="sglv-stat-row">
                    <div class="sglv-stat-card blue"><div class="sglv-stat-header"><span class="sglv-stat-icon">${Host.ICONS.library}</span><span class="sglv-stat-label">${Host.T.totalGames}</span></div><div class="sglv-stat-val blue">${activeTotalGames}</div><div class="sglv-stat-dash-sub">${Host.T.kpiOfTotal}</div></div>
                    <div class="sglv-stat-card green"><div class="sglv-stat-header"><span class="sglv-stat-icon">${Host.ICONS.heart}</span><span class="sglv-stat-label">${Host.T.ownedInDb}</span></div><div class="sglv-stat-val green">${ownedAll}</div><div class="sglv-stat-dash-sub">${Host.T.kpiRate} ${pctAll}%</div></div>
                    <div class="sglv-stat-card red"><div class="sglv-stat-header"><span class="sglv-stat-icon">${Host.ICONS.shield}</span><span class="sglv-stat-label">${Host.T.missingInDb}</span></div><div class="sglv-stat-val red">${totalAll - ownedAll}</div><div class="sglv-stat-dash-sub">${Host.T.kpiRate} ${100 - pctAll}%</div></div>
                    <div class="sglv-stat-card purple"><div class="sglv-stat-header"><span class="sglv-stat-icon">${Host.ICONS.barChart}</span><span class="sglv-stat-label">${Host.T.ownership}</span></div><div class="sglv-stat-val">${pctAll}%</div><div class="sglv-stat-dash-sub">${Host.T.kpiCollectionProgress}</div></div>
                </div>
                <div class="sglv-progress"><div class="sglv-progress-fill" style="width:${pctAll}%"></div></div>
            `;

            for (const [pubName] of Object.entries(Host.getGameDb())) {
                const pStats = computePublisherStats(pubName);
                const pct = pStats.total > 0 ? Math.round(pStats.owned / pStats.total * 100) : 0;
                html += `
                    <div class="sglv-pub-card" data-pub="${pubName}">
                        <div class="sglv-card-row gap6">
                            <span class="sglv-pub-card-name">${pubName}</span>
                            <span class="sglv-card-stats${pct === 100 ? ' complete' : ''}">${pStats.owned}/${pStats.total} (${pct}%)</span>
                        </div>
                        <div class="sglv-progress"><div class="sglv-progress-fill" style="width:${pct}%"></div></div>
                    </div>
                `;
            }

            main.innerHTML = html;
            main.querySelectorAll('.sglv-pub-card').forEach(card => {
                card.addEventListener('click', () => {
                    const pubName = card.dataset.pub;
                    pubState.expandedPublishers.add(pubName);
                    pubState.selectedPublisher = pubName;
                    pubState.selectedSeries = null;
                    renderPubSidebar();
                    renderPubPublisherDetail(pubName);
                });
            });
        }

        function renderPubPublisherDetail(pubName) {
            const main = document.getElementById('sglv-pub-main');
            if (!main) return;

            const pStats = computePublisherStats(pubName);
            const pct = pStats.total > 0 ? Math.round(pStats.owned / pStats.total * 100) : 0;

            let html = `
                <div style="margin-bottom:16px"><span style="display:inline-block;padding:3px 10px;border-radius:4px;font-size:13px;font-weight:600;background:rgba(102,192,244,0.15);color:#66c0f4">${pubName}</span></div>
                <div class="sglv-stat-row">
                    <div class="sglv-stat-card blue"><div class="sglv-stat-header"><span class="sglv-stat-icon">${Host.ICONS.library}</span><span class="sglv-stat-label">${Host.isZh ? '游戏总数' : 'Total'}</span></div><div class="sglv-stat-val blue">${pStats.total}</div></div>
                    <div class="sglv-stat-card green"><div class="sglv-stat-header"><span class="sglv-stat-icon">${Host.ICONS.heart}</span><span class="sglv-stat-label">${Host.T.owned}</span></div><div class="sglv-stat-val green">${pStats.owned}</div></div>
                    <div class="sglv-stat-card red"><div class="sglv-stat-header"><span class="sglv-stat-icon">${Host.ICONS.shield}</span><span class="sglv-stat-label">${Host.T.missing}</span></div><div class="sglv-stat-val red">${pStats.total - pStats.owned}</div></div>
                    <div class="sglv-stat-card purple"><div class="sglv-stat-header"><span class="sglv-stat-icon">${Host.ICONS.barChart}</span><span class="sglv-stat-label">${Host.T.ownership}</span></div><div class="sglv-stat-val">${pct}%</div></div>
                </div>
                <div class="sglv-progress" style="margin-bottom:20px"><div class="sglv-progress-fill" style="width:${pct}%"></div></div>
            `;

            for (const [seriesName] of Object.entries(Host.getGameDb()[pubName] || {})) {
                const sStats = computeSeriesStats(pubName, seriesName);
                const sPct = sStats.total > 0 ? Math.round(sStats.owned / sStats.total * 100) : 0;
                html += `
                    <div class="sglv-series-card" data-pub="${pubName}" data-series="${seriesName}">
                        <div class="sglv-card-row gap4">
                            <span class="sglv-series-card-name">${seriesName}</span>
                            <span class="sglv-card-stats${sPct === 100 ? ' complete' : ''}">${sStats.owned}/${sStats.total} (${sPct}%)</span>
                        </div>
                        <div class="sglv-progress"><div class="sglv-progress-fill" style="width:${sPct}%"></div></div>
                    </div>
                `;
            }

            main.innerHTML = html;
            main.querySelectorAll('.sglv-series-card').forEach(card => {
                card.addEventListener('click', () => {
                    const p = card.dataset.pub, s = card.dataset.series;
                    pubState.selectedPublisher = p;
                    pubState.selectedSeries = s;
                    pubState.expandedPublishers.add(p);
                    renderPubSidebar();
                    renderPubSeriesDetail(p, s);
                });
            });
        }

        function renderPubSeriesDetail(pubName, seriesName) {
            const games = Host.getGameDb()[pubName]?.[seriesName] || [];
            const breadcrumbHtml = `
                <div style="margin-bottom:16px;display:flex;align-items:center;gap:8px;flex-wrap:wrap">
                    <span style="display:inline-block;padding:3px 10px;border-radius:4px;font-size:12px;font-weight:600;background:rgba(102,192,244,0.15);color:#66c0f4">${pubName}</span>
                    <span style="color:#8a9ba8">›</span>
                    <span style="font-size:15px;font-weight:600;color:#fff">${seriesName}</span>
                </div>
            `;
            renderSeriesDetailCommon(breadcrumbHtml, games, () => renderPubSeriesDetail(pubName, seriesName), 'pub:' + pubName + '\u0000' + seriesName);
        }

        // v1.8.2: 系列模式详情——直接展示系列游戏列表（无供应商面包屑）
        function renderSeriesModeDetail(seriesName) {
            const games = getSeriesDb()[seriesName] || [];
            const breadcrumbHtml = `
                <div style="margin-bottom:16px;display:flex;align-items:center;gap:8px;flex-wrap:wrap">
                    <span style="display:inline-block;padding:3px 10px;border-radius:4px;font-size:12px;font-weight:600;background:var(--sglv-accent-bg, rgba(139,92,246,0.15));color:var(--sglv-accent, #a78bfa)">${Host.isZh ? '系列' : 'Series'}</span>
                    <span style="font-size:15px;font-weight:600;color:#fff">${seriesName}</span>
                </div>
            `;
            renderSeriesDetailCommon(breadcrumbHtml, games, () => renderSeriesModeDetail(seriesName), 'series:' + seriesName);
        }

        // v1.8.2: 系列数据未加载时的右侧空态
        // v1.9.37: 移除"系列数据加载中，请稍候…"提示，清空主区域即可（避免界面变形）
        function renderSeriesModeEmpty() {
            const main = document.getElementById('sglv-pub-main');
            if (!main) return;
            main.innerHTML = '';
        }

        /**
         * v1.9.31: 系列游戏排序辅助——日期解析为可排序字符串
         * 支持所有数据源日期格式（兼容 game_series.json 中文格式 + vediogame_filtered.json ISO 格式）：
         *   "YYYY年M月D日" / "YYYY年M月" / "YYYY年"（中文格式，game_series.json）
         *   "YYYY-MM-DD" / "YYYY-MM-__" / "YYYY-MM" / "YYYY"（ISO 格式，vediogame_filtered.json）
         *   "Q[1-4] YYYY"（季度格式）
         *   "待定" / "TBD" / "" → 返回空串（排序时排到末尾）
         * @param {string} dateStr - 日期字符串
         * @returns {string} 可排序字符串（如 "20260901"），无效/未知日期返回 ''
         */
        function seriesDateToSortable(dateStr) {
            if (!dateStr) return '';
            var s = String(dateStr).trim();
            if (!s || s === '待定' || s === 'TBD' || s === 'tbd') return '';
            // 中文完整日期: "2026年01月30日" / "2026 年7月8日"
            var m = s.match(/(\d{4})\s*年\s*(\d{1,2})\s*月\s*(\d{1,2})\s*日/);
            if (m) return m[1] + m[2].padStart(2, '0') + m[3].padStart(2, '0');
            // 中文年月: "2028年3月"
            var m2 = s.match(/(\d{4})\s*年\s*(\d{1,2})\s*月/);
            if (m2) return m2[1] + m2[2].padStart(2, '0') + '99';
            // 中文年份: "2026年"
            var m3 = s.match(/^(\d{4})\s*年/);
            if (m3) return m3[1] + '1299';
            // ISO 完整日期: "2026-09-01"
            var m4 = /^(\d{4})-(\d{1,2})-(\d{1,2})$/.exec(s);
            if (m4) return m4[1] + m4[2].padStart(2, '0') + m4[3].padStart(2, '0');
            // ISO 部分日期（日未知）: "2026-01-__"
            var m5 = /^(\d{4})-(\d{1,2})-__$/.exec(s);
            if (m5) return m5[1] + m5[2].padStart(2, '0') + '99';
            // ISO 年月: "2026-08"
            var m6 = /^(\d{4})-(\d{1,2})$/.exec(s);
            if (m6) return m6[1] + m6[2].padStart(2, '0') + '99';
            // 纯年份: "2026"
            var m7 = /^(\d{4})$/.exec(s);
            if (m7) return m7[1] + '1299';
            // 季度格式: "Q4 2026" → 该季度末月
            var m8 = /^Q([1-4])\s+(\d{4})$/i.exec(s);
            if (m8) { var qMon = String(parseInt(m8[1]) * 3).padStart(2, '0'); return m8[2] + qMon + '99'; }
            return '';
        }

        /**
         * v1.9.31: 系列游戏排序——按 sortField + sortDir 排序，未知/空日期始终排到末尾
         * @param {Array} games - 游戏列表 [{id, name, date, order, poster?}]
         * @param {string} sortField - 'order'|'date'|'name'|'appid'
         * @param {string} sortDir - 'asc'|'desc'
         * @returns {Array} 排序后的新数组（不修改原数组）
         */
        function sortSeriesGames(games, sortField, sortDir) {
            var sorted = games.slice();
            var desc = sortDir === 'desc';
            try {
                sorted.sort(function (a, b) {
                    var r;
                    switch (sortField) {
                        case 'name':
                            r = _nameCollator.compare(a.name || '~', b.name || '~');
                            return desc ? -r : r;
                        case 'appid':
                            r = (a.id || 0) - (b.id || 0);
                            return desc ? -r : r;
                        case 'date':
                            // 未知/空日期始终排到末尾，与 sortDir 无关
                            var sa = seriesDateToSortable(a.date);
                            var sb = seriesDateToSortable(b.date);
                            if (!sa && !sb) return 0;
                            if (!sa) return 1;   // a 未知 → 排后面
                            if (!sb) return -1;  // b 未知 → 排后面
                            return desc ? sb.localeCompare(sa) : sa.localeCompare(sb);
                        case 'order':
                        default:
                            r = (a.order || 0) - (b.order || 0);
                            return desc ? -r : r;
                    }
                });
            } catch (e) {
                console.warn('[SGLV-Series] sortSeriesGames 排序失败，降级为原始顺序:', e);
            }
            return sorted;
        }

        /**
         * v1.9.30: 系列封面图生成——优先使用数据源 poster 字段（预验证URL，避免CDN试错），
         * 失败后走三级 CDN 降级链 + API 兜底。向后兼容：poster 为空时走原 Host 逻辑。
         * @param {Object} g - 游戏条目 {id, name, poster?}
         * @param {string} kind - 图片类型 'poster'|'header'
         * @param {string} cls - img class
         * @returns {string} img 标签 HTML
         */
        function seriesCoverImg(g, kind, cls) {
            var appid = g.id;
            var name = Host.wlEscape(g.name || '');
            // v1.9.43: onload 属性——竖版 kind 追加宽图检测（横图 letterbox，避免 2:3 容器裁切变形）
            var onloadAttr = 'this.classList.add(\'sglv-img-loaded\');'
                + (kind === 'poster' ? 'if(this.naturalWidth>this.naturalHeight)this.classList.add(\'sglv-img-wide\');' : '')
                + '_sglvRecordPosterGood(\'' + appid + '\',this.src,\'' + kind + '\');';
            // v1.9.43: poster 字段方向门控——数据源 poster 实为横版 header URL（预验证可用），
            // 竖版 kind 仅接受竖版资产（library_600x900 族），横版 kind 仅接受横版 URL
            var posterOk = false;
            if (g.poster) posterOk = (kind === 'poster') ? _sgcvIsVerticalUrl(g.poster) : !_sgcvIsVerticalUrl(g.poster);
            // v1.9.43: 首个 onerror 即竞速 API 兜底（CDN 链继续走，API 先返回则劫持 src）
            var race = '_sgcvCoverRace(this,\'' + appid + '\',\'' + kind + '\');';
            // 1. 优先使用 good 缓存（跨会话已验证 URL，最快）v1.9.41: 叠加 steamui 精确 URL
            //    v1.9.44: coverGoodUrl 已方向严格——poster kind 仅返回竖版条目
            var good = coverGoodUrl(appid, kind);
            if (good) {
                return '<img class="' + cls + '" src="' + good + '" alt="' + name +
                    '" loading="lazy" decoding="async" onerror="_sglvPosterFallback(this,\'' + appid + '\',\'' + kind + '\');" onload="' + onloadAttr + '">';
            }
            // v1.9.44: 竖版确认缺失（poster 缓存横版标记）→ 横版替代直用（交叉缓存），免整链重爬
            if (kind === 'poster' && coverVerticalMissing(appid)) {
                var horizHtml = _sgcvHorizontalFallbackImgHtml(appid, name, cls, '_sglvPosterFallback');
                if (horizHtml) return horizHtml;
            }
            // 2. 有可用 poster 字段（方向门控后）：用作初始 src（预验证URL，避免CDN试错），
            //    onerror 走完整 CDN 链（含 chain[0]，初始 src 为 g.poster）+ 竞速 API 兜底
            if (posterOk) {
                var chain = coverChainLang(appid, kind);
                var handler = '_sglvPosterFallback(this,\'' + appid + '\',\'' + kind + '\');';
                for (var i = chain.length - 1; i >= 0; i--) {
                    handler = 'this.src=\'' + chain[i] + '\';this.onerror=function(){' + handler + '};';
                }
                return '<img class="' + cls + '" src="' + g.poster + '" alt="' + name +
                    '" loading="lazy" decoding="async" onerror="' + race + handler +
                    '" onload="' + onloadAttr + '">';
            }
            // 3. 无可用 poster（含横版 poster 被 poster kind 门控拒绝）：链首起步 + 竞速。
            //    v1.9.43: 竖版 kind 不再回退 Host.posterImg，统一走本库语言变体链（2x 置顶）
            var hChain = coverChainLang(appid, kind);
            var hHandler = "_sglvPosterFallback(this,'" + appid + "','" + kind + "');";
            for (var j = hChain.length - 1; j >= 1; j--) {
                hHandler = "this.src='" + hChain[j] + "';this.onerror=function(){" + hHandler + '};';
            }
            return '<img class="' + cls + '" src="' + hChain[0] + '" alt="' + name + '" loading="lazy" decoding="async" onload="' + onloadAttr + '" onerror="' + race + hHandler + '">';
        }

        // v1.9.34: 系列横版封面图（capsule kind）——用于封面视图
        // v1.9.41: good/链走 coverGoodUrl/coverChainLang（steamui 精确 URL + 语言变体链）
        // v1.9.43: ① 横版 poster 字段复用——数据源 poster 实为预验证横版 header URL，
        //             hero 链首未命中（新游戏无 hero 资产）后第 2 跳即命中，替代 ~36 次全 404 链爬取
        //             （460x215 与封面视图容器 aspect-ratio 完全一致）；竖版 poster 仍拒绝
        //          ② 首个 onerror 即竞速 API 兜底
        function seriesCapsuleImg(g) {
            var appid = g.id;
            var name = Host.wlEscape(g.name || '');
            var cls = 'sglv-wl-cover-img';
            // 1. 优先使用 good 缓存
            var good = coverGoodUrl(appid, 'capsule');
            if (good) {
                return '<img class="' + cls + '" src="' + good + '" alt="' + name +
                    '" loading="lazy" decoding="async" onerror="_sglvPosterFallback(this,\'' + appid + '\',\'capsule\');" onload="this.classList.add(\'sglv-img-loaded\');_sglvRecordPosterGood(\'' + appid + '\',this.src,\'capsule\');">';
            }
            // 2. hero 链首起步；横版 poster 插入为第 2 跳；其余 CDN 链跟随 + API 兜底
            var chain = coverChainLang(appid, 'capsule');
            var seq = chain.slice(1);
            if (g.poster && !_sgcvIsVerticalUrl(g.poster) && seq.indexOf(g.poster) < 0) {
                seq = [g.poster].concat(seq);
            }
            var handler = '_sglvPosterFallback(this,\'' + appid + '\',\'capsule\');';
            for (var i = seq.length - 1; i >= 0; i--) {
                handler = 'this.src=\'' + seq[i] + '\';this.onerror=function(){' + handler + '};';
            }
            return '<img class="' + cls + '" src="' + chain[0] + '" alt="' + name + '" loading="lazy" decoding="async" onerror="' +
                '_sgcvCoverRace(this,\'' + appid + '\',\'capsule\');' + handler +
                '" onload="this.classList.add(\'sglv-img-loaded\');_sglvRecordPosterGood(\'' + appid + '\',this.src,\'capsule\');">';
        }

        /**
         * 系列/供应商游戏列表公共渲染（KPI + 进度筛选 + 卡片/列表视图）
         * @param {string} breadcrumbHtml - 顶部面包屑 HTML
         * @param {Array} games - [{id, name, date}]
         * @param {function} rerender - 重渲染回调
         * @param {string} cacheKey - v1.9.19: 分类标识（含 filter），用于分页进度记忆/恢复
         */
        function renderSeriesDetailCommon(breadcrumbHtml, games, rerender, cacheKey) {
            const main = document.getElementById('sglv-pub-main');
            if (!main) return;

            cacheKey = cacheKey ? cacheKey + '\u0000' + pubState.filter + '\u0000' + pubState.sortField + '\u0000' + pubState.sortDir : null;
            // v1.9.19: 切换分类时保存旧页码、恢复新分类页码（filter/viewMode 变化仍走 rerender，页码由 cacheKey 区分）
            if (pubDetailState.cacheKey !== cacheKey) {
                if (pubDetailState.cacheKey) pubDetailState.pageCache.set(pubDetailState.cacheKey, pubDetailState.page);
                pubDetailState.page = (cacheKey && pubDetailState.pageCache.get(cacheKey)) || 1;
                pubDetailState.cacheKey = cacheKey;
            }

            const ownedAppIds = Host.getActiveOwnedAppIds();
            let ownedCount = 0;
            for (const g of games) if (ownedAppIds.has(g.id)) ownedCount++;
            const sStats = { total: games.length, owned: ownedCount };
            const pct = sStats.total > 0 ? Math.round(sStats.owned / sStats.total * 100) : 0;
            const viewMode = pubState.viewMode; // v1.9.34: 'card' | 'cover' | 'list'

            let html = breadcrumbHtml + `
                <div class="sglv-pub-detail-toolbar">
                    <span class="sglv-pub-completion">
                        ${Host.isZh ? '收集完成度' : 'Completion'}: <strong style="color:${pct === 100 ? '#4caf50' : '#66c0f4'};font-size:16px">${pct}%</strong>
                        <span style="margin-left:8px">(${sStats.owned}/${sStats.total})</span>
                    </span>
                    <div class="sglv-pub-own-filter" role="group" aria-label="${Host.isZh ? '拥有状态筛选' : 'Ownership filter'}">
                        <button class="sglv-btn sglv-btn-secondary${pubState.filter === 'owned' ? ' active' : ''}" id="sglv-pub-own-owned" title="${Host.isZh ? '仅显示已拥有（再次点击取消）' : 'Show owned only (click again to clear)'}">${Host.isZh ? '已拥有' : 'Owned'}</button>
                        <button class="sglv-btn sglv-btn-secondary${pubState.filter === 'unowned' ? ' active' : ''}" id="sglv-pub-own-unowned" title="${Host.isZh ? '仅显示未拥有（再次点击取消）' : 'Show not owned only (click again to clear)'}">${Host.isZh ? '未拥有' : 'Not Owned'}</button>
                    </div>
                    <div class="sglv-pub-sort-group">
                        <select class="sglv-sort-select" aria-label="${Host.isZh ? '排序方式' : 'Sort by'}" id="sglv-pub-sort-field" style="max-width:100px;font-size:11px;padding:3px 6px" title="${Host.isZh ? '排序方式' : 'Sort by'}">
                            <option value="order"${pubState.sortField === 'order' ? ' selected' : ''}>${Host.isZh ? '序号' : 'Order'}</option>
                            <option value="date"${pubState.sortField === 'date' ? ' selected' : ''}>${Host.isZh ? '发布时间' : 'Date'}</option>
                            <option value="name"${pubState.sortField === 'name' ? ' selected' : ''}>${Host.isZh ? '名称' : 'Name'}</option>
                            <option value="appid"${pubState.sortField === 'appid' ? ' selected' : ''}>AppID</option>
                        </select>
                        <button class="sglv-view-btn" id="sglv-pub-sort-dir" title="${pubState.sortDir === 'asc' ? (Host.isZh ? '升序' : 'Ascending') : (Host.isZh ? '降序' : 'Descending')}" style="font-size:14px;font-weight:bold">${pubState.sortDir === 'asc' ? '↑' : '↓'}</button>
                    </div>
                    <span class="sglv-view-toggle">
                        <button class="sglv-view-btn${viewMode === 'card' ? ' active' : ''}" data-view="card" title="${Host.isZh ? '卡片视图' : 'Card view'}">${Host.ICONS.grid}</button>
                        <button class="sglv-view-btn${viewMode === 'cover' ? ' active' : ''}" data-view="cover" title="${Host.T.coverView}">${Host.ICONS.cover}</button>
                        <button class="sglv-view-btn${viewMode === 'list' ? ' active' : ''}" data-view="list" title="${Host.isZh ? '列表视图' : 'List view'}">${Host.ICONS.list}</button>
                    </span>
                </div>
                <div class="sglv-progress sglv-progress-filter" style="margin-bottom:12px" title="${Host.isZh ? '已拥有 ' + sStats.owned + ' / ' + sStats.total : 'Owned ' + sStats.owned + ' / ' + sStats.total}">
                    <div class="sglv-progress-fill" style="width:${pct}%"></div>
                </div>
                ${viewMode === 'list' ? '<div class="sglv-pub-list">' : viewMode === 'cover' ? '<div class="sglv-wl-cover-grid sglv-pub-cover-grid">' : '<div class="sglv-card-grid">'}
            `;

            // 按拥有状态筛选游戏
            let displayGames = games;
            if (pubState.filter === 'owned') {
                displayGames = games.filter(g => ownedAppIds.has(g.id));
            } else if (pubState.filter === 'unowned') {
                displayGames = games.filter(g => !ownedAppIds.has(g.id));
            }

            // v1.9.31: 排序——按 sortField + sortDir 排序，未知/空日期排末尾
            displayGames = sortSeriesGames(displayGames, pubState.sortField, pubState.sortDir);

            // v1.9.19: 分页——只渲染当前页的游戏卡片/封面（页大小与其他 tab 一致）
            const { pageItems, totalPages, page: _clampedPage } = Host.paginate(displayGames, pubDetailState.page, pubDetailState.pageSize);
            pubDetailState.page = _clampedPage;

            if (displayGames.length === 0) {
                html += `<div style="color:var(--sglv-text-secondary);font-size:13px;text-align:center;padding:30px 16px">
                    ${pubState.filter === 'owned' ? (Host.isZh ? '该系列没有已拥有的游戏' : 'No owned games in this series') : pubState.filter === 'unowned' ? (Host.isZh ? '该系列没有未拥有的游戏' : 'All games in this series are owned') : (Host.isZh ? '该分类暂无游戏' : 'No games in this category')}
                </div>`;
            } else if (viewMode === 'list') {
                // 列表视图：表头（含封面列）
                html += `
                    <div class="sglv-pub-list-header">
                        <span class="sglv-pub-list-col cover" style="width:80px">${Host.isZh ? '封面' : 'Cover'}</span>
                        <span class="sglv-pub-list-col status" style="width:60px">${Host.isZh ? '状态' : 'Status'}</span>
                        <span class="sglv-pub-list-col name">${Host.isZh ? '游戏名称' : 'Game Name'}</span>
                        <span class="sglv-pub-list-col appid" style="width:90px">AppID</span>
                    </div>
                `;
                for (const g of pageItems) {
                    const { badgeClass, badgeText, tooltip } = getGameBadgeInfo(g, ownedAppIds);
                    // v1.9.30: 封面优先使用数据源 poster 字段（预验证URL），失败走 CDN 降级链 + API 兜底
                    const coverImg = seriesCoverImg(g, 'header', 'sglv-pub-list-cover');
                    html += `
                        <a class="sglv-pub-list-row" href="https://store.steampowered.com/app/${g.id}" target="_blank" rel="noopener">
                            <span class="sglv-pub-list-col cover" style="width:80px">
                                ${coverImg}
                            </span>
                            <span class="sglv-pub-list-col status" style="width:60px">
                                <span class="sglv-card-badge ${badgeClass}" ${tooltip}>${badgeText}</span>
                            </span>
                            <span class="sglv-pub-list-col name" title="${g.name}"><span data-sglv-appid="${g.id}">${g.name}</span>${(() => { const tags = genreTagsHtml(g); return tags ? `<span class="sglv-pub-genre-tags">${tags}</span>` : ''; })()}</span>
                            <span class="sglv-pub-list-col appid" style="width:90px">${g.id}</span>
                        </a>
                    `;
                }
            } else if (viewMode === 'cover') {
                // v1.9.34: 横版封面视图（capsule 大图）
                for (const g of pageItems) {
                    const { isOwned, badgeClass, badgeText, tooltip } = getGameBadgeInfo(g, ownedAppIds);
                    html += `
                        <div class="sglv-wl-cover-card sglv-pub-cover-card${isOwned ? ' sglv-pub-cover-owned' : ''}" onclick="window.open('https://store.steampowered.com/app/${g.id}','_blank')">
                            <div class="sglv-wl-cover-img-wrap">
                                ${seriesCapsuleImg(g)}
                                <div class="sglv-pub-cover-overlay"></div>
                                <span class="sglv-card-badge ${badgeClass} sglv-pub-cover-badge" ${tooltip}>${badgeText}</span>
                            </div>
                            <div class="sglv-wl-cover-body">
                                <div class="sglv-card-name" title="${g.name}"><span data-sglv-appid="${g.id}">${g.name}</span><span class="sglv-card-id-inline">${g.id}</span></div>
                                ${(() => { const tags = genreTagsHtml(g); return tags ? `<div class="sglv-card-genre-row">${tags}</div>` : ''; })()}
                            </div>
                        </div>
                    `;
                }
            } else {
                // 卡片视图
                for (const g of pageItems) {
                    const { isOwned, badgeClass, badgeText, tooltip } = getGameBadgeInfo(g, ownedAppIds);

                    html += `
                        <div class="sglv-game-card" onclick="window.open('https://store.steampowered.com/app/${g.id}','_blank')">
                            <div class="sglv-card-img-wrap">
                                ${seriesCoverImg(g, 'poster', 'sglv-card-img')}
                            </div>
                            <div class="sglv-card-body">
                                <div class="sglv-card-name" title="${g.name}"><span data-sglv-appid="${g.id}">${g.name}</span></div>
                                <div class="sglv-card-id">AppID: ${g.id}</div>
                                ${(() => { const tags = genreTagsHtml(g); return tags ? `<div class="sglv-card-genre-row">${tags}</div>` : ''; })()}
                                <span class="sglv-card-badge ${badgeClass}" ${tooltip}>${badgeText}</span>
                            </div>
                        </div>
                    `;
                }
            }

            html += '</div>';
            // v1.9.19: 分页导航（与其他 tab 同一套 Host.renderPagination）
            html += `<div class="sglv-pagination" id="sglv-pub-series-pagination" style="margin-top:14px"></div>`;
            main.innerHTML = html;

            // v2.3.33：异步加载游戏中文名
            main.querySelectorAll('[data-sglv-appid]').forEach(el => {
                Host.loadGameZhName(el, el.getAttribute('data-sglv-appid'), el.textContent);
            });

            // 统一事件绑定
            // v1.9.35: 已拥有/未拥有 切换标签——点击已激活的标签则取消（回到全部）
            const ownOwnedBtn = main.querySelector('#sglv-pub-own-owned');
            const ownUnownedBtn = main.querySelector('#sglv-pub-own-unowned');
            if (ownOwnedBtn) ownOwnedBtn.addEventListener('click', () => {
                pubState.filter = pubState.filter === 'owned' ? 'all' : 'owned';
                pubDetailState.page = 1;
                rerender();
            });
            if (ownUnownedBtn) ownUnownedBtn.addEventListener('click', () => {
                pubState.filter = pubState.filter === 'unowned' ? 'all' : 'unowned';
                pubDetailState.page = 1;
                rerender();
            });
            // v1.9.31: 排序事件——字段切换 + 方向切换
            const sortFieldSelect = main.querySelector('#sglv-pub-sort-field');
            if (sortFieldSelect) sortFieldSelect.addEventListener('change', (e) => {
                pubState.sortField = e.target.value;
                pubDetailState.page = 1;
                rerender();
            });
            const sortDirBtn = main.querySelector('#sglv-pub-sort-dir');
            if (sortDirBtn) sortDirBtn.addEventListener('click', (e) => {
                e.stopPropagation();
                pubState.sortDir = pubState.sortDir === 'asc' ? 'desc' : 'asc';
                pubDetailState.page = 1;
                rerender();
            });
            // v1.9.31: data-view 属性区分视图按钮与排序方向按钮
            main.querySelectorAll('.sglv-view-btn[data-view]').forEach(btn => {
                btn.addEventListener('click', (e) => {
                    e.stopPropagation();
                    pubState.viewMode = btn.dataset.view;
                    rerender();
                });
            });
            // v1.9.19: 分页事件（onJump 驱动首/上/下/末页与跳页输入）
            Host.renderPagination(document.getElementById('sglv-pub-series-pagination'), 'sglv-pub-series', pubDetailState.page, totalPages, displayGames.length,
                () => { pubDetailState.page--; rerender(); },
                () => { pubDetailState.page++; rerender(); },
                (p) => { pubDetailState.page = p; rerender(); });
        }

        // ==================== 绝版游戏标签页 ====================
        // v1.9.47-fix: 绝版游戏数据兜底链——
        //   ① Host.getDelistedDb() 同步取（来自主脚本 @resource delistedData；3.5MB 大文件，Tampermonkey
        //       偶发静默加载失败 + 解析慢导致"暂无绝版游戏数据"），
        //   ② 若 ① 为空 → 异步拉远程源三级回退（fastly.jsdelivr → cdn.jsdelivr → raw.githubusercontent），
        //   ③ 写回 Host.cacheSet('delistedDbRemote', ...) 供后续会话秒开（6h 节流后台刷新）。
        // 选 _refreshDelistedFromRemote 而非替换 Host.getDelistedDb（闭包不可改），改为缓存到
        // _delistedRemoteCache，并让 getDelistedApps() 优先取它，保留 @resource 作为快速通道。
        const _DELISTED_REMOTE_SOURCES = [
            'https://fastly.jsdelivr.net/gh/SmallRob/steam-namespace@main/data/steam_delisted_apps.json',
            'https://cdn.jsdelivr.net/gh/SmallRob/steam-namespace@main/data/steam_delisted_apps.json',
            'https://raw.githubusercontent.com/SmallRob/steam-namespace/main/data/steam_delisted_apps.json'
        ];
        let _delistedRemoteCache = null;          // 远程源完整 JSON {version, source, fetchedAt, totalCount, data}
        let _delistedRemoteLoading = false;       // 防止并发请求
        let _delistedRemoteLoaded = false;        // 远程已成功加载过(避免每次开 tab 重新拉)
        const _DELISTED_REMOTE_BG_INTERVAL = 6 * 3600 * 1000; // 6h 后台节流
        let _delistedLastBgRefreshAt = 0;
        let _delistedForceRemote = false;         // 工具栏刷新按钮触发(force 走全链路)

        function _normalizeDelistedRaw(raw) {
            if (!raw || typeof raw !== 'object') return [];
            let rawApps = [];
            if (Array.isArray(raw.data)) rawApps = raw.data;
            else if (raw.delisted && Array.isArray(raw.delisted.apps)) rawApps = raw.delisted.apps;
            return rawApps.map(app => ({
                appid: app.appId || app.appid,
                name: app.name,
                type: app.delistType || app.type || 'Delisted',
                changed: app.delistedAt || app.changed,
                owners: app.ownerPercentage != null ? app.ownerPercentage + '%' : (app.owners || '-'),
                achievements: app.achievementCount || app.achievements,
                keyshopPrice: app.keyshopPrice,
                source: app.source
            }));
        }

        // 解析远程响应文本，校验为合法绝版 JSON（data 数组 / totalCount > 0）
        function _parseDelistedResponseText(txt) {
            try {
                const obj = JSON.parse(txt);
                if (!obj || typeof obj !== 'object') return null;
                const okData = Array.isArray(obj.data) && obj.data.length > 0;
                const okLegacy = obj.delisted && Array.isArray(obj.delisted.apps) && obj.delisted.apps.length > 0;
                if (!okData && !okLegacy) return null;
                return obj;
            } catch (e) { return null; }
        }

        function _refreshDelistedFromRemote(force) {
            if (typeof GM_xmlhttpRequest !== 'function') return;
            if (_delistedRemoteLoading) return;
            _delistedRemoteLoading = true;
            function _tryNext(idx) {
                if (idx >= _DELISTED_REMOTE_SOURCES.length) {
                    _delistedRemoteLoading = false;
                    return;
                }
                GM_xmlhttpRequest({
                    method: 'GET',
                    url: _DELISTED_REMOTE_SOURCES[idx],
                    timeout: 20000,
                    onload(r) {
                        try {
                            const txt = _safeRespText(r);
                            const obj = _parseDelistedResponseText(txt);
                            if (obj) {
                                _delistedRemoteCache = obj;
                                _delistedRemoteLoaded = true;
                                _delistedLastBgRefreshAt = Date.now();
                                // 写 TTL 缓存(24h),后续会话秒开
                                try { Host.cacheSet('delistedDbRemote', obj, 24 * 3600 * 1000); } catch (e) { /* 忽略 */ }
                                _delistedRemoteLoading = false;
                                // 触发 UI 重渲染(若当前已开 delisted tab)
                                // v1.9.47-fix: 数据到达时,若 wrap 还是"加载骨架占位"状态(无 toolbar/KPI),
                                //   清空 body 重建 tab 一次性同步 KPI/分类汇总/工具栏(否则仅刷新列表内容)。
                                if (_collectionActiveTab === 'delisted' && collectionPanelEl && collectionPanelEl.classList.contains('sglv-show')) {
                                    const body = collectionPanelEl.querySelector('#sgc-body');
                                    if (body) {
                                        const wrap = body.querySelector('.sglv-delisted-wrap');
                                        const hasFullUi = wrap && wrap.querySelector('#sglv-delisted-pagination');
                                        if (hasFullUi) {
                                            renderDelistedGamesList();
                                        } else {
                                            // 清空 body 重建,避免旧 wrap 与新 wrap 重复
                                            body.innerHTML = '';
                                            renderDelistedTab(body);
                                        }
                                    }
                                }
                                return;
                            }
                        } catch (e) { /* fallthrough */ }
                        _tryNext(idx + 1);
                    },
                    onerror() { _tryNext(idx + 1); },
                    ontimeout() { _tryNext(idx + 1); }
                });
            }
            _tryNext(0);
        }

        // 启动时尝试从 TTL 缓存预热远程源(避免开 tab 才发起请求)
        function _warmDelistedRemoteCache() {
            try {
                const cached = Host.cacheGet('delistedDbRemote');
                if (cached && typeof cached === 'object') {
                    if ((Array.isArray(cached.data) && cached.data.length > 0) ||
                        (cached.delisted && Array.isArray(cached.delisted.apps) && cached.delisted.apps.length > 0)) {
                        _delistedRemoteCache = cached;
                        _delistedRemoteLoaded = true;
                    }
                }
            } catch (e) { /* 忽略 */ }
        }

        function getDelistedApps() {
            // ① 优先 _delistedRemoteCache(已通过远程源/TTL 缓存预热),正常情况 @resource 加载也走这条分支
            if (_delistedRemoteCache) return _normalizeDelistedRaw(_delistedRemoteCache);
            // ② @resource 数据(主脚本 GM_getResourceText('delistedData') 同步返回)
            const DELISTED_DB = Host.getDelistedDb();
            if (DELISTED_DB && ((Array.isArray(DELISTED_DB.data) && DELISTED_DB.data.length > 0) ||
                (DELISTED_DB.delisted && Array.isArray(DELISTED_DB.delisted.apps) && DELISTED_DB.delisted.apps.length > 0))) {
                return _normalizeDelistedRaw(DELISTED_DB);
            }
            // ③ 远程源未触发过 → 触发(force 模式跳过 @resource 兜底走全链路)
            if (!_delistedRemoteLoaded && !_delistedRemoteLoading) {
                _refreshDelistedFromRemote(_delistedForceRemote);
            }
            return [];
        }

        // 工具栏"刷新"按钮触发的强制刷新入口
        function forceRefreshDelistedFromRemote() {
            _delistedForceRemote = true;
            _delistedRemoteLoaded = false;       // 强制重走源
            _delistedRemoteCache = null;
            _delistedRemoteLoading = false;
            _refreshDelistedFromRemote(true);
        }

        function getTypeKey(type) {
            if (!type) return 'delisted';
            // 已经是小写下划线格式，直接返回
            if (type.includes('_')) return type;
            // 大写格式 -> 小写下划线格式
            const map = {
                'Delisted': 'delisted',
                'Purchase disabled': 'purchase_disabled',
                'F2P (unavailable)': 'f2p_unavailable',
                'Retail only': 'retail_only',
                'Test app': 'test_app',
            };
            return map[type] || 'delisted';
        }

        function getTypeLabel(type) {
            if (!type) return Host.T.typeDelisted;
            const map = {
                'Delisted': Host.T.typeDelisted,
                'delisted': Host.T.typeDelisted,
                'Purchase disabled': Host.T.typePurchaseDisabled,
                'purchase_disabled': Host.T.typePurchaseDisabled,
                'F2P (unavailable)': Host.T.typeF2P,
                'f2p_unavailable': Host.T.typeF2P,
                'Retail only': Host.T.typeRetailOnly,
                'retail_only': Host.T.typeRetailOnly,
                'Test app': Host.T.typeTestApp,
                'test_app': Host.T.typeTestApp,
            };
            return map[type] || type;
        }

        function getFilteredDelistedApps() {
            const allApps = getDelistedApps();
            // v2.3.14: 使用 getActiveOwnedAppIds() 替代 ownedAppIds，
            // 以尊重"显示家庭共享"开关：关闭时仅匹配自己拥有的游戏，不匹配家庭组共享游戏
            const ownedIds = Host.getActiveOwnedAppIds();
            // v1.9.47-fix: 缓存键加入 ownedIds 集合指纹——
            //   此前仅用 ownedIds.size(拥有游戏数量)做粗粒度失效,同数量但不同游戏的 owned 集合变化会导致
            //   subFilter=owned/missing 筛选结果过时(新购买的不展示,已退款的仍展示)。
            //   用前 8 个 appid 的 djb2 哈希 + 数量作指纹,既能精确失效又避免 ownedIds 全量入键(缓存键爆炸)。
            let _ownedSig = 0;
            if (ownedIds && ownedIds.size) {
                const sample = Array.from(ownedIds).slice(0, 8);
                let h = ownedIds.size * 2654435761;
                for (const n of sample) {
                    h = ((h << 5) + h + Number(n) | 0) >>> 0;
                }
                _ownedSig = h.toString(36);
            }
            const cacheK = Host.cacheKey('delisted-filter', allApps.length, delistedState.subFilter, delistedState.typeFilter, delistedState.search, delistedState.sort, ownedIds.size, _ownedSig);
            return Host.getCached(cacheK, () => {
                let apps = allApps;

                // 子分类筛选：全部 / 已拥有 / 未拥有
                if (delistedState.subFilter === 'owned') {
                    apps = apps.filter(a => ownedIds.has(Number(appidFix(a.appid))) || ownedIds.has(String(a.appid)));
                } else if (delistedState.subFilter === 'missing') {
                    apps = apps.filter(a => !ownedIds.has(Number(appidFix(a.appid))) && !ownedIds.has(String(a.appid)));
                }

                // Type filter
                if (delistedState.typeFilter !== 'all') {
                    apps = apps.filter(a => getTypeKey(a.type) === delistedState.typeFilter);
                }

                // Search filter
                if (delistedState.search) {
                    const q = delistedState.search.toLowerCase();
                    apps = apps.filter(a =>
                        (a.name || '').toLowerCase().includes(q) ||
                        String(a.appid).includes(q)
                    );
                }

                // v1.9.32: 排序——按 appid 或下架时间（delistedAt/changed），空日期排末尾
                apps = apps.slice().sort((a, b) => {
                    let r = 0;
                    switch (delistedState.sort) {
                        case 'appidAsc': r = (a.appid || 0) - (b.appid || 0); break;
                        case 'dateDesc': {
                            const sa = seriesDateToSortable(a.changed), sb = seriesDateToSortable(b.changed);
                            if (!sa && !sb) { r = 0; break; }
                            if (!sa) return 1;
                            if (!sb) return -1;
                            r = sb.localeCompare(sa); break;
                        }
                        case 'dateAsc': {
                            const sa = seriesDateToSortable(a.changed), sb = seriesDateToSortable(b.changed);
                            if (!sa && !sb) { r = 0; break; }
                            if (!sa) return 1;
                            if (!sb) return -1;
                            r = sa.localeCompare(sb); break;
                        }
                        case 'appidDesc':
                        default: r = (b.appid || 0) - (a.appid || 0);
                    }
                    return r || ((a.appid || 0) - (b.appid || 0));
                });

                return apps;
            });
        }

        function appidFix(v) {
            const n = Number(v);
            return isNaN(n) ? v : n;
        }

        function getOwnedGameInfo(appid) {
            // v2.3.14: 关闭"显示家庭共享"时，仅在自己拥有的游戏中查找，避免命中家庭组共享游戏
            const showFamilyShared = Host.getShowFamilyShared();
            const pool = showFamilyShared ? Host.getOwnedGames() : Host.getOwnedGames().filter(g => Host.isGameOwnedByMe(g));
            return pool.find(g => g.appid === appidFix(appid)) || null;
        }

        function renderDelistedGamesList() {
            const content = document.getElementById('sglv-delisted-content');
            if (!content) return;

            const apps = getFilteredDelistedApps();
            // v2.4.0: 复用 paginate 纯函数统一分页计算
            const { pageItems: pageApps, totalPages, page: _clampedPage } = Host.paginate(apps, delistedState.page, delistedState.pageSize);
            delistedState.page = _clampedPage;

            // v2.3.14: 使用 getActiveOwnedAppIds() 尊重"显示家庭共享"开关
            const ownedIds = Host.getActiveOwnedAppIds();

            if (delistedState.viewMode === 'card') {
                content.innerHTML = `<div class="sglv-card-grid">${pageApps.map(app => {
                    const appid = appidFix(app.appid);
                    const isOwned = ownedIds.has(Number(appid)) || ownedIds.has(String(appid));
                    const typeKey = getTypeKey(app.type);
                    const badgeClass = isOwned ? 'owned' : 'missing';
                    const badgeText = isOwned ? ('✓ ' + Host.T.owned) : Host.T.missing;
                    const ownedInfo = isOwned ? getOwnedGameInfo(appid) : null;
                    const playtimeH = ownedInfo && ownedInfo.playtime > 0 ? `${(ownedInfo.playtime / 60).toFixed(1)}h` : '';
                    const lastPlayed = ownedInfo && ownedInfo.lastPlayed ? Host.formatLastPlayedShort(ownedInfo.lastPlayed) : '';

                    return `
                        <div class="sglv-game-card" onclick="window.open('https://store.steampowered.com/app/${appid}','_blank')">
                            <div class="sglv-card-img-wrap">
                                ${Host.posterImg(appid, app.name)}
                                ${playtimeH ? `<span class="sglv-card-playtime-overlay"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><path d="M12 6v6l4 2"/></svg>${playtimeH}</span>` : ''}
                            </div>
                            <div class="sglv-card-body">
                                <div class="sglv-card-name" title="${app.name}"><span data-sglv-appid="${appid}">${app.name}</span><span class="sglv-card-id-inline">${appid}</span></div>
                                <div class="sglv-badge-row">
                                    <span class="sglv-delisted-badge type-${typeKey}">${getTypeLabel(app.type)}</span>
                                    <span class="sglv-card-badge ${badgeClass}">${badgeText}</span>
                                </div>
                                <div class="sglv-info-row">
                                    <span class="sglv-delisted-owners sglv-meta-item"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M17 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2"/><circle cx="9" cy="7" r="4"/><path d="M23 21v-2a4 4 0 0 0-3-3.87"/><path d="M16 3.13a4 4 0 0 1 0 7.75"/></svg>${app.owners || '-'}</span>
                                    ${app.changed ? `<span class="sglv-delisted-date sglv-meta-item"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="3" y="4" width="18" height="18" rx="2"/><line x1="16" y1="2" x2="16" y2="6"/><line x1="8" y1="2" x2="8" y2="6"/><line x1="3" y1="10" x2="21" y2="10"/></svg>${app.changed}</span>` : ''}
                                    ${lastPlayed ? `<span class="sglv-delisted-date sglv-meta-item"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><path d="M12 6v6l4 2"/></svg>${lastPlayed}</span>` : ''}
                                    ${app.achievements ? `<span class="sglv-delisted-achievements sglv-meta-item">🏆 ${app.achievements}</span>` : ''}
                                </div>
                            </div>
                        </div>
                    `;
                }).join('')}</div>`;
            } else {
                content.innerHTML = `<div class="sglv-list-view">${pageApps.map(app => {
                    const appid = appidFix(app.appid);
                    const isOwned = ownedIds.has(Number(appid)) || ownedIds.has(String(appid));
                    const typeKey = getTypeKey(app.type);
                    const badgeClass = isOwned ? 'owned' : 'missing';
                    const badgeText = isOwned ? ('✓ ' + Host.T.owned) : Host.T.missing;
                    const iconUrl = Host.getGameIconUrl(appid, '');
                    const ownedInfo = isOwned ? getOwnedGameInfo(appid) : null;
                    const playtimeH = ownedInfo && ownedInfo.playtime > 0 ? `${(ownedInfo.playtime / 60).toFixed(1)}h` : '';
                    const lastPlayed = ownedInfo && ownedInfo.lastPlayed ? Host.formatLastPlayedShort(ownedInfo.lastPlayed) : '';

                    return `
                        <div class="sglv-list-item" onclick="window.open('https://store.steampowered.com/app/${appid}','_blank')">
                            <img class="sglv-list-icon" src="${iconUrl}" alt="${app.name}" loading="lazy" decoding="async" onerror="this.style.display='none'">
                            <div class="sglv-list-info">
                                <div class="sglv-list-name"><span data-sglv-appid="${appid}">${app.name}</span><span class="sglv-list-id-inline">${appid}</span></div>
                                <div class="sglv-list-meta">
                                    <span class="sglv-delisted-badge type-${typeKey}">${getTypeLabel(app.type)}</span>
                                    <span class="sglv-delisted-owners sglv-meta-item"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M17 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2"/><circle cx="9" cy="7" r="4"/><path d="M23 21v-2a4 4 0 0 0-3-3.87"/><path d="M16 3.13a4 4 0 0 1 0 7.75"/></svg>${app.owners || '-'}</span>
                                    ${app.changed ? `<span class="sglv-delisted-date sglv-meta-item"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="3" y="4" width="18" height="18" rx="2"/><line x1="16" y1="2" x2="16" y2="6"/><line x1="8" y1="2" x2="8" y2="6"/><line x1="3" y1="10" x2="21" y2="10"/></svg>${app.changed}</span>` : ''}
                                    ${app.achievements ? `<span class="sglv-delisted-achievements sglv-meta-item">🏆 ${app.achievements}</span>` : ''}
                                    ${lastPlayed ? `<span class="sglv-delisted-date sglv-meta-item"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><path d="M12 6v6l4 2"/></svg>${lastPlayed}</span>` : ''}
                                </div>
                            </div>
                            <div style="display:flex;align-items:center;gap:6px;flex-shrink:0">
                                ${playtimeH ? `<span class="sglv-list-badge owned">${playtimeH}</span>` : ''}
                                <span class="sglv-list-badge ${badgeClass}">${badgeText}</span>
                            </div>
                        </div>
                    `;
                }).join('')}</div>`;
            }

            // v2.3.33：异步加载游戏中文名
            content.querySelectorAll('[data-sglv-appid]').forEach(el => {
                Host.loadGameZhName(el, el.getAttribute('data-sglv-appid'), el.textContent);
            });

            // v1.9.47-fix: 主脚本 renderPagination 所有按钮(首页/上页/下页/末页/跳页)统一走 onJump,
            // 缺失第 8 参数 → 翻页按钮全部失效("只能加载第一页")。补传 onJump。
            Host.renderPagination(document.getElementById('sglv-delisted-pagination'), 'sglv-delisted', delistedState.page, totalPages, apps.length,
                () => { delistedState.page--; renderDelistedGamesList(); },
                () => { delistedState.page++; renderDelistedGamesList(); },
                (p) => { delistedState.page = p; renderDelistedGamesList(); });
        }

        // v1.9.47-fix: 加载骨架占位——构建完整工具栏 + 工具栏事件绑定(刷新按钮)，
        //   内容区域只放加载骨架条。数据到达时由 _refreshDelistedFromRemote 回调触发
        //   renderDelistedGamesList() 仅更新 #sglv-delisted-content,工具栏/状态保留。
        // 这样既保证用户看到工具栏(可点刷新),又不会因数据未到而无法操作。
        function _renderDelistedLoadingScaffold(wrap) {
            // 工具栏(只放搜索框 + 视图按钮 + 刷新按钮,无数据时类型/排序/子筛选无意义,留空避免误操作)
            const toolbar = document.createElement('div');
            toolbar.className = 'sglv-toolbar sglv-delisted-toolbar';
            toolbar.innerHTML = `
                <input class="sglv-search" aria-label="搜索" id="sglv-delisted-search" placeholder="${Host.T.delistedSearch}" value="" disabled title="${Host.isZh ? '数据加载中' : 'Loading data'}">
                <button class="sglv-btn sglv-btn-secondary sglv-btn-icon" id="sglv-delisted-refresh" title="${Host.isZh ? '从远程源重新加载' : 'Reload from remote source'}">${Host.ICONS.refresh}</button>
            `;
            wrap.appendChild(toolbar);

            // 内容区(加载骨架)
            const content = document.createElement('div');
            content.className = 'sglv-content';
            content.id = 'sglv-delisted-content';
            const loadingText = _delistedRemoteLoading
                ? (Host.isZh ? '正在加载绝版游戏数据…' : 'Loading delisted game data…')
                : (Host.isZh ? '暂无绝版游戏数据' : 'No delisted game data available');
            content.innerHTML = '<div class="sglv-progress" style="margin:16px 0"><div class="sglv-progress-fill" style="width:45%"></div></div><div class="sglv-empty">' + loadingText + '</div>';
            wrap.appendChild(content);

            // 刷新按钮事件(复用正常路径的事件签名,只是数据为空时点击依然可走 force 全链路)
            const refreshBtn = toolbar.querySelector('#sglv-delisted-refresh');
            if (refreshBtn) {
                refreshBtn.addEventListener('click', () => {
                    if (refreshBtn.classList.contains('sglv-spin')) return;
                    refreshBtn.classList.add('sglv-spin');
                    const restore = () => refreshBtn.classList.remove('sglv-spin');
                    forceRefreshDelistedFromRemote();
                    setTimeout(restore, 30000);
                    const poll = setInterval(() => {
                        if (!_delistedRemoteLoading) { clearInterval(poll); restore(); }
                    }, 200);
                });
            }
        }

        function renderDelistedTab(parent) {
            const wrap = document.createElement('div');
            wrap.className = 'sglv-delisted-wrap';

            // v1.9.47-fix: 首次进入触发远程源兜底预热(@resource 加载失败/同步阻塞时仍能加载)
            if (!_delistedRemoteLoaded && !_delistedRemoteLoading) {
                _warmDelistedRemoteCache();      // 先尝试 TTL 缓存(秒开)
                if (!_delistedRemoteCache) _refreshDelistedFromRemote(false);  // 无缓存 → 远程源
            }
            // v1.9.47-fix: 后台静默刷新节流(6h)
            else if (_delistedRemoteLoaded && !_delistedRemoteLoading &&
                     (Date.now() - _delistedLastBgRefreshAt) > _DELISTED_REMOTE_BG_INTERVAL) {
                _refreshDelistedFromRemote(false);
            }

            const apps = getDelistedApps();
            if (apps.length === 0) {
                // v1.9.47-fix: 构建完整工具栏(可点刷新) + 加载骨架占位。
                //   数据到达时 _refreshDelistedFromRemote 回调 → renderDelistedGamesList()
                //   仅更新 #sglv-delisted-content,工具栏/状态保留(避免重新打开 tab 闪烁)。
                parent.appendChild(wrap);
                _renderDelistedLoadingScaffold(wrap);
                return;
            }

            // v2.3.14: 使用 getActiveOwnedAppIds() 尊重"显示家庭共享"开关，
            // 关闭家庭共享时 KPI 与分类统计均仅计自己拥有的绝版游戏
            const ownedIds = Host.getActiveOwnedAppIds();
            const totalDelisted = apps.length;
            let ownedDelisted = 0;
            apps.forEach(app => {
                if (ownedIds.has(Number(app.appid)) || ownedIds.has(String(app.appid))) ownedDelisted++;
            });
            const missingDelisted = totalDelisted - ownedDelisted;
            const delistedPct = totalDelisted > 0 ? Math.round(ownedDelisted / totalDelisted * 100) : 0;

            // KPI cards (v2.3.22: 增强样式——图标+数值+标签+子文本+彩色光晕)
            const kpiSection = document.createElement('div');
            kpiSection.className = 'sglv-trend-kpi-row';
            kpiSection.innerHTML = `
                <div class="sglv-trend-kpi-card red">
                    <div class="sglv-trend-kpi-header"><span class="sglv-trend-kpi-icon">${Host.ICONS.shield}</span><span class="sglv-trend-kpi-label">${Host.T.delistedTotal}</span></div>
                    <div class="sglv-trend-kpi-value">${totalDelisted.toLocaleString()}</div>
                    <div class="sglv-trend-kpi-sub">${Host.T.kpiDelisted}</div>
                </div>
                <div class="sglv-trend-kpi-card mine">
                    <div class="sglv-trend-kpi-header"><span class="sglv-trend-kpi-icon">${Host.ICONS.heart}</span><span class="sglv-trend-kpi-label">${Host.T.delistedOwned}</span></div>
                    <div class="sglv-trend-kpi-value">${ownedDelisted.toLocaleString()}</div>
                    <div class="sglv-trend-kpi-sub">${Host.T.kpiCollected}</div>
                </div>
                <div class="sglv-trend-kpi-card orange">
                    <div class="sglv-trend-kpi-header"><span class="sglv-trend-kpi-icon">${Host.ICONS.shield}</span><span class="sglv-trend-kpi-label">${Host.T.delistedMissing}</span></div>
                    <div class="sglv-trend-kpi-value">${missingDelisted.toLocaleString()}</div>
                    <div class="sglv-trend-kpi-sub">${Host.T.kpiToCollect}</div>
                </div>
                <div class="sglv-trend-kpi-card total">
                    <div class="sglv-trend-kpi-header"><span class="sglv-trend-kpi-icon">${Host.ICONS.barChart}</span><span class="sglv-trend-kpi-label">${Host.T.delistedOwnership}</span></div>
                    <div class="sglv-trend-kpi-value">${delistedPct}%</div>
                    <div class="sglv-trend-kpi-sub">${Host.T.kpiCollectionProgress}</div>
                </div>
            `;
            wrap.appendChild(kpiSection);

            // v2.3.22: 紧凑分类汇总（分页操作栏）—— 可点击徽章 + 分页
            const typeCounts = {};
            apps.forEach(app => {
                const key = getTypeKey(app.type);
                typeCounts[key] = (typeCounts[key] || 0) + 1;
            });
            const typeOwned = {};
            apps.forEach(app => {
                if (ownedIds.has(Number(app.appid)) || ownedIds.has(String(app.appid))) {
                    const key = getTypeKey(app.type);
                    typeOwned[key] = (typeOwned[key] || 0) + 1;
                }
            });
            const typeColors = { delisted: '#f44336', purchase_disabled: '#ff9800', f2p_unavailable: '#ce93d8', retail_only: '#64b5f6', test_app: '#9e9e9e' };

            const summaryBar = document.createElement('div');
            summaryBar.className = 'sglv-delisted-summary-bar';
            const badgesDiv = document.createElement('div');
            badgesDiv.className = 'sglv-delisted-summary-badges';
            const typeEntries = Object.entries(typeCounts).sort((a, b) => b[1] - a[1]);
            typeEntries.forEach(([key, count]) => {
                const o = typeOwned[key] || 0;
                const color = typeColors[key] || '#8f98a0';
                const label = key === 'delisted' ? Host.T.typeDelisted
                    : key === 'purchase_disabled' ? Host.T.typePurchaseDisabled
                    : key === 'f2p_unavailable' ? Host.T.typeF2P
                    : key === 'retail_only' ? Host.T.typeRetailOnly
                    : Host.T.typeTestApp;
                const badge = document.createElement('span');
                badge.className = 'sglv-delisted-summary-badge';
                badge.style.cssText = `background:${color}22;color:${color};border:1px solid ${color}44`;
                badge.dataset.type = key;
                badge.title = `${label}: ${o}/${count}`;
                badge.innerHTML = `${label} <span class="sglv-dsb-owned">${o}</span><span class="sglv-dsb-sep">/</span><span class="sglv-dsb-total">${count}</span>`;
                badgesDiv.appendChild(badge);
            });
            summaryBar.appendChild(badgesDiv);
            // 分页放到分类汇总行右侧
            const summaryPagination = document.createElement('div');
            summaryPagination.className = 'sglv-pagination sglv-delisted-pagination';
            summaryPagination.id = 'sglv-delisted-pagination';
            summaryBar.appendChild(summaryPagination);
            wrap.appendChild(summaryBar);

            // v2.3.22: 收藏进度条（置于分页操作栏下方，紧凑布局）
            const progressCompact = document.createElement('div');
            progressCompact.className = 'sglv-delisted-progress-compact';
            progressCompact.innerHTML = `
                <span class="sglv-dpc-label">${Host.T.kpiCollectionProgress}</span>
                <div class="sglv-dpc-track"><div class="sglv-dpc-fill" style="width:${delistedPct}%"></div></div>
                <span class="sglv-dpc-pct">${delistedPct}%</span>
            `;
            wrap.appendChild(progressCompact);

            // Toolbar（类型筛选 + 拥有状态筛选合并到同一行）
            const toolbar = document.createElement('div');
            toolbar.className = 'sglv-toolbar sglv-delisted-toolbar';
            const typeButtons = [
                { key: 'all', label: Host.T.all },
                { key: 'delisted', label: Host.T.typeDelisted },
                { key: 'purchase_disabled', label: Host.T.typePurchaseDisabled },
                { key: 'f2p_unavailable', label: Host.T.typeF2P },
                { key: 'retail_only', label: Host.T.typeRetailOnly },
                { key: 'test_app', label: Host.T.typeTestApp },
            ];
            const subItems = [
                { key: 'all', label: Host.T.delistedSubAll },
                { key: 'owned', label: Host.T.delistedSubOwned },
                { key: 'missing', label: Host.T.delistedSubMissing },
            ];
            toolbar.innerHTML = `
                <input class="sglv-search" aria-label="搜索" id="sglv-delisted-search" placeholder="${Host.T.delistedSearch}" value="${delistedState.search}">
                <div class="sglv-delisted-filter-group">
                    ${typeButtons.map(tb => `<button class="sglv-btn sglv-btn-secondary sglv-delisted-type-btn${delistedState.typeFilter === tb.key ? ' active' : ''}" data-type="${tb.key}">${tb.label}</button>`).join('')}
                </div>
                <div class="sglv-delisted-sub-group">
                    ${subItems.map(si => `<button class="sglv-btn sglv-btn-secondary sglv-delisted-sub-btn${delistedState.subFilter === si.key ? ' active' : ''}" data-sub="${si.key}">${si.label}</button>`).join('')}
                </div>
                <select class="sglv-sort-select" aria-label="排序方式" id="sglv-delisted-sort" title="${Host.isZh ? '排序方式' : 'Sort by'}">
                    <option value="appidDesc"${delistedState.sort === 'appidDesc' ? ' selected' : ''}>${Host.isZh ? 'AppID ↓' : 'AppID ↓'}</option>
                    <option value="appidAsc"${delistedState.sort === 'appidAsc' ? ' selected' : ''}>${Host.isZh ? 'AppID ↑' : 'AppID ↑'}</option>
                    <option value="dateDesc"${delistedState.sort === 'dateDesc' ? ' selected' : ''}>${Host.isZh ? '下架时间 新→旧' : 'Delisted New→Old'}</option>
                    <option value="dateAsc"${delistedState.sort === 'dateAsc' ? ' selected' : ''}>${Host.isZh ? '下架时间 旧→新' : 'Delisted Old→New'}</option>
                </select>
                <button class="sglv-btn sglv-btn-secondary sglv-btn-icon${delistedState.viewMode === 'card' ? ' active' : ''}" id="sglv-delisted-card" title="${Host.T.cardView}">${Host.ICONS.grid}</button>
                <button class="sglv-btn sglv-btn-secondary sglv-btn-icon${delistedState.viewMode === 'list' ? ' active' : ''}" id="sglv-delisted-list" title="${Host.T.listView}">${Host.ICONS.list}</button>
                <button class="sglv-btn sglv-btn-secondary sglv-btn-icon" id="sglv-delisted-refresh" title="${Host.isZh ? '从远程源重新加载' : 'Reload from remote source'}">${Host.ICONS.refresh}</button>
            `;
            wrap.appendChild(toolbar);

            // Content area
            const content = document.createElement('div');
            content.className = 'sglv-content';
            content.id = 'sglv-delisted-content';
            wrap.appendChild(content);

            parent.appendChild(wrap);

            // Event bindings
            // v2.3.22: 分类汇总徽章点击——快速筛选对应类型，并与工具栏按钮同步
            badgesDiv.querySelectorAll('.sglv-delisted-summary-badge').forEach(badge => {
                badge.addEventListener('click', () => {
                    delistedState.typeFilter = badge.dataset.type;
                    delistedState.page = 1;
                    toolbar.querySelectorAll('.sglv-delisted-type-btn').forEach(b => {
                        b.classList.toggle('active', b.dataset.type === badge.dataset.type);
                    });
                    badgesDiv.querySelectorAll('.sglv-delisted-summary-badge').forEach(b => b.style.outline = '');
                    badge.style.outline = `2px solid ${badge.style.color || '#66c0f4'}`;
                    renderDelistedGamesList();
                });
            });
            toolbar.querySelectorAll('.sglv-delisted-sub-btn').forEach(btn => {
                btn.addEventListener('click', () => {
                    delistedState.subFilter = btn.dataset.sub;
                    delistedState.page = 1;
                    toolbar.querySelectorAll('.sglv-delisted-sub-btn').forEach(b => b.classList.remove('active'));
                    btn.classList.add('active');
                    renderDelistedGamesList();
                });
            });
            toolbar.querySelector('#sglv-delisted-search').addEventListener('input', _debounce((e) => {
                delistedState.search = e.target.value;
                delistedState.page = 1;
                renderDelistedGamesList();
            }, 200));
            // v1.9.32: 排序下拉事件
            toolbar.querySelector('#sglv-delisted-sort').addEventListener('change', (e) => {
                delistedState.sort = e.target.value;
                delistedState.page = 1;
                renderDelistedGamesList();
            });
            toolbar.querySelectorAll('.sglv-delisted-type-btn').forEach(btn => {
                btn.addEventListener('click', () => {
                    delistedState.typeFilter = btn.dataset.type;
                    delistedState.page = 1;
                    toolbar.querySelectorAll('.sglv-delisted-type-btn').forEach(b => b.classList.remove('active'));
                    btn.classList.add('active');
                    // v2.3.22: 同步分类汇总徽章高亮
                    badgesDiv.querySelectorAll('.sglv-delisted-summary-badge').forEach(b => {
                        b.style.outline = b.dataset.type === btn.dataset.type ? `2px solid ${b.style.color || '#66c0f4'}` : '';
                    });
                    renderDelistedGamesList();
                });
            });
            toolbar.querySelector('#sglv-delisted-card').addEventListener('click', () => {
                delistedState.viewMode = 'card';
                toolbar.querySelector('#sglv-delisted-card').classList.add('active');
                toolbar.querySelector('#sglv-delisted-list').classList.remove('active');
                renderDelistedGamesList();
            });
            toolbar.querySelector('#sglv-delisted-list').addEventListener('click', () => {
                delistedState.viewMode = 'list';
                toolbar.querySelector('#sglv-delisted-list').classList.add('active');
                toolbar.querySelector('#sglv-delisted-card').classList.remove('active');
                renderDelistedGamesList();
            });
            // v1.9.47-fix: 远程源手动刷新(@resource 加载失败时可点此走三级回退)
            const refreshBtn = toolbar.querySelector('#sglv-delisted-refresh');
            if (refreshBtn) {
                refreshBtn.addEventListener('click', () => {
                    if (refreshBtn.classList.contains('sglv-spin')) return;
                    refreshBtn.classList.add('sglv-spin');
                    const restore = () => refreshBtn.classList.remove('sglv-spin');
                    const prevLoading = _delistedRemoteLoading;
                    forceRefreshDelistedFromRemote();
                    // 监听 30s 后兜底还原(防止失败场景按钮卡在 spinning 状态)
                    setTimeout(restore, 30000);
                    // 轮询直到 loading=false 再还原
                    const poll = setInterval(() => {
                        if (!_delistedRemoteLoading) { clearInterval(poll); restore(); }
                    }, 200);
                });
            }

            renderDelistedGamesList();
        }

        // v1.9.27: 安全读取 GM_xmlhttpRequest 响应文本
        // 浏览器扩展(如 inspector.js) hook XMLHttpRequest.prototype.send 并修改 responseType 为 arraybuffer，
        // 导致 r.responseText 抛 InvalidStateError。此函数先尝试 responseText，失败后尝试 response(ArrayBuffer→TextDecoder)
        function _safeRespText(r) {
            try {
                if (r.responseText) return r.responseText;
            } catch (e) { /* responseType 被外部修改为 arraybuffer */ }
            try {
                if (typeof r.response === 'string') return r.response;
                if (r.response instanceof ArrayBuffer) return new TextDecoder().decode(new Uint8Array(r.response));
            } catch (e2) { /* ignore */ }
            return '';
        }

        // ==================== PS 会免标签页 (v2.6.0) ====================
        // 远程数据源：psplus-games.json（由 oXnMe/psplus-steam-overlay 维护）
        // 数据结构：{ updatedAt, count, games: [{ recordId, steamAppId, tier, month, monthSort, statusName, statusDisplay, statusDate, versions, psstore, color }] }
        // tier: 1=Essential(必备) 2=Extra(升级) 3=Premium(高级)
        // statusName: 在库/领取中/截止领取/已出库/即将出库

        const PSPLUS_DATA_URL = 'https://fastly.jsdelivr.net/gh/oXnMe/psplus-steam-overlay@main/data/psplus-games.json';
        // v1.9.37: 降级数据源——由 js_script/psplus-data-sync.js 每日同步镜像到 SmallRob/steam-namespace 仓库
        // 主源（oXnMe）不可用时依次尝试三级 CDN 回退链（参照 EPIC_GITHUB_URLS 写法）
        const PSPLUS_BACKUP_URLS = [
            'https://fastly.jsdelivr.net/gh/SmallRob/steam-namespace@main/data/psplus-games.json',
            'https://cdn.jsdelivr.net/gh/SmallRob/steam-namespace@main/data/psplus-games.json',
            'https://raw.githubusercontent.com/SmallRob/steam-namespace/main/data/psplus-games.json'
        ];

        // PS Logo SVG（白色，用于占位封面）
        // v2.9.22: 真实 PlayStation 标识（官方蓝紫色 P + S 经典组合，参考 PS 官方 logo SVG）
        const PS_LOGO_SVG = '<svg viewBox="0 0 122.88 95.18" xmlns="http://www.w3.org/2000/svg" fill="#0070D1"><path d="M2.49,69.39c-4.61,3.07-3.07,8.9,6.75,11.67c10.13,3.38,21.18,4.3,31.93,2.46c0.61,0,1.23-0.31,1.54-0.31V72.76l-10.44,3.38c-3.99,1.23-7.98,1.54-11.97,0.61c-3.07-0.92-2.46-2.76,1.23-4.3l21.18-7.37V53.73L13.23,63.86C9.55,65.09,5.86,66.93,2.49,69.39L2.49,69.39z M73.71,23.33v29.78c12.59,6.14,22.41,0,22.41-15.96c0-16.27-5.83-23.64-22.72-29.47C64.5,4.6,55.29,1.84,46.08,0v88.73l21.49,6.45V20.57c0-3.38,0-5.83,2.46-4.91C73.41,16.58,73.71,19.96,73.71,23.33L73.71,23.33z M113.63,62.32c-8.9-3.07-18.42-4.3-27.63-3.38c-4.91,0.31-9.52,1.54-13.82,3.07l-0.92,0.31V74.3l19.96-7.37c3.99-1.23,7.98-1.54,11.97-0.61c3.07,0.92,2.46,2.76-1.23,4.3l-30.7,11.36v11.67l42.37-15.66c3.07-1.23,5.83-2.76,8.29-5.22C124.07,69.69,123.15,65.39,113.63,62.32L113.63,62.32z"/></svg>';

        // 从 PS Store URL 提取游戏名称（slug → Title Case）——v2.6.2 增强支持 playstation.com games slug 与 store.playstation.com product ID
        function psExtractName(psstore) {
            if (!psstore) return '';
            // 1. playstation.com /games/{slug} 形式
            const m = psstore.match(/\/games\/([^\/\?]+)/);
            if (m) {
                return m[1].split('-').filter(Boolean).map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
            }
            // 2. store.playstation.com /product/{id}_{name} 形式——name 在 ID 之后可能含字母+数字
            //    例如 UP1642-CUSA04798_00-SLUS211960000001  →  SLUS211960000001
            //        JP0106-PPSA34548_00-GITAROOMAN000000    →  GITAROOMAN000000
            const p = psstore.match(/\/product\/[A-Z0-9\-]+_00-([A-Za-z0-9]+)/);
            if (p) {
                // ID 经常是大写字母+数字混合，去掉前 1-2 字母前缀尝试拆分：SLUS21196 → SLUS-21196；GITAROOMAN → GITAROO MAN
                const raw = p[1];
                // 尝试按"大写+小写"分词（AstroBot → Astro Bot）
                const spaced = raw.replace(/([a-z])([A-Z])/g, '$1 $2');
                // 尝试按"数字+字母"分词（SLUS21196 → SLUS 21196）
                const spaced2 = spaced.replace(/([A-Z]+)(\d)/g, '$1 $2').replace(/(\d)([A-Z])/g, '$1 $2');
                // 尝试按纯连续大写字母拆：GITAROOMAN → GITAROO MAN (按 4+ 字母)
                let result = spaced2.replace(/([A-Z]{4,})/g, m => m.replace(/([A-Z]{2})([A-Z]+)/, '$1 $2').trim());
                // 收尾：把数字与字母之间加空格
                result = result.replace(/([A-Za-z])(\d)/g, '$1 $2').replace(/(\d)([A-Za-z])/g, '$1 $2');
                return result.split(/\s+/).filter(Boolean).map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
            }
            return '';
        }

        // v2.6.2: PS 独占异步抓取 psstore 页面获取中文名（基于 product ID 解析 <title>）
        // 输入 psstore URL；输出 Promise<string>，空字符串表示获取失败
        const _psStoreNamePending = new Map();
        const _PS_STORE_NAME_TTL = 6 * 3600 * 1000; // 6h，与 PS 会免数据 TTL 对齐
        const _PS_STORE_NAME_NEG_TTL = 30 * 60 * 1000; // 失败 30 分钟内不再请求
        const SGLV_PS_NAME_KEY = 'sglvPsStoreNameCache_v1';
        function sglvPsStoreNameCacheLoad() {
            try { return JSON.parse(GM_getValue(SGLV_PS_NAME_KEY, '{}') || '{}'); } catch (e) { return {}; }
        }
        function sglvPsStoreNameCacheSave(map) {
            try { GM_setValue(SGLV_PS_NAME_KEY, JSON.stringify(map || {})); } catch (e) { /* 忽略失败，不影响主流程 */ }
        }
        function fetchPsStoreName(psstoreUrl) {
            if (!Host.isZh) return Promise.resolve('');
            if (!psstoreUrl) return Promise.resolve('');
            // 缓存键：URL → 名字
            const cache = sglvPsStoreNameCacheLoad();
            const cached = cache[psstoreUrl];
            if (cached) {
                if (cached.name && Date.now() - (cached.ts || 0) < _PS_STORE_NAME_TTL) return Promise.resolve(cached.name);
                if (!cached.name && Date.now() - (cached.ts || 0) < _PS_STORE_NAME_NEG_TTL) return Promise.resolve('');
            }
            if (_psStoreNamePending.has(psstoreUrl)) return _psStoreNamePending.get(psstoreUrl);
            const p = new Promise(resolve => {
                const settle = (name) => {
                    cache[psstoreUrl] = { name, ts: Date.now() };
                    try { sglvPsStoreNameCacheSave(cache); } catch (e) { /* 忽略失败，不影响主流程 */ }
                    _psStoreNamePending.delete(psstoreUrl);
                    resolve(name);
                };
                // 只抓 zh-hans-hk 区域页面（数据源中 psstore 大多是该区域），避免美区不同步
                const targetUrl = psstoreUrl.includes('playstation.com') && !psstoreUrl.includes('zh-hans-hk')
                    ? psstoreUrl.replace(/(playstation\.com)\/([a-z\-]+\/)/, '$1/zh-hans-hk/')
                    : psstoreUrl;
                GM_xmlhttpRequest({
                    method: 'GET',
                    url: targetUrl,
                    timeout: 10000,
                    onload(resp) {
                        let name = '';
                        try {
                            const html = _safeRespText(resp);
                            // 1. 尝试 <meta property="og:title" content="...">
                            let m = html.match(/<meta\s+(?:[^>]*?)property=["']og:title["']\s+(?:[^>]*?)content=["']([^"']+)/i);
                            if (!m) {
                                // 2. 尝试 <title>...</title>
                                m = html.match(/<title[^>]*>([^<]+)<\/title>/i);
                            }
                            if (!m) {
                                // 3. 尝试 <meta name="twitter:title" content="...">
                                m = html.match(/<meta\s+(?:[^>]*?)name=["']twitter:title["']\s+(?:[^>]*?)content=["']([^"']+)/i);
                            }
                            if (m) {
                                // 清理：去掉 " | PlayStation Store" 之类后缀，HTML 实体反转义
                                name = m[1]
                                    .replace(/\s*\|\s*PlayStation.*$/i, '')
                                    .replace(/\s*-\s*PlayStation.*$/i, '')
                                    .replace(/\s*·\s*PlayStation.*$/i, '')
                                    .replace(/&amp;/g, '&').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&quot;/g, '"').replace(/&#39;/g, "'")
                                    .trim();
                            }
                        } catch (e) { /* 忽略失败，不影响主流程 */ }
                        settle(name);
                    },
                    onerror() { settle(''); },
                    ontimeout() { settle(''); }
                });
            });
            _psStoreNamePending.set(psstoreUrl, p);
            return p;
        }


        // PS 会免占位封面 DOM（蓝色渐变 + 真实 PS 标识 + 名称），供运行时回退统一调用
        function psPlaceholderDom(name) {
            const holder = document.createElement('div');
            holder.className = 'sglv-ps-cover-placeholder';
            holder.innerHTML = '<div class="sglv-ps-logo">' + PS_LOGO_SVG + '</div><div class="sglv-ps-cover-name">' + Host.wlEscape(name || 'PS Exclusive') + '</div>';
            return holder;
        }
        // PS 会免封面图全局回退：Steam CDN 全部失败时先用 Store API 取真实封面 URL，
        // API URL 仍加载失败时替换为蓝色 PS 占位（v1.1.1：修复 API URL 二次失败无兜底导致破图）
        // v1.9.29: 传递 kind 参数，使 API 兜底按图片类型选择最佳 URL
        unsafeWindow._sglvPsCoverFallback = function(img, appid, kind) {
            if (!img || !img.parentElement) return;
            Host.fetchCoverApiUrl(appid, kind).then(url => {
                if (url) {
                    img.onerror = function() { img.onerror = null; img.parentElement.replaceChild(psPlaceholderDom(img.alt), img); };
                    img.src = url;
                    return;
                }
                img.parentElement.replaceChild(psPlaceholderDom(img.alt), img);
            });
        };
        // PS 会免列表视图图标回退：CDN 图标失败时替换为 PS 蓝色占位 div
        // （保持 92x43 尺寸，避免旧版 this.style.display='none' 导致整行左对齐错位）
        unsafeWindow._sglvPsListIconFallback = function(img) {
            if (!img || !img.parentElement) return;
            const holder = document.createElement('div');
            holder.className = 'sglv-list-icon';
            holder.style.cssText = 'display:flex;align-items:center;justify-content:center;background:linear-gradient(135deg,#003791,#0070D1);color:#fff;border-radius:4px;padding:4px';
            holder.innerHTML = Host.ICONS.playstation;
            img.parentElement.replaceChild(holder, img);
        };

        // PS 会免竖版封面：有 steamAppId → Steam 多 CDN 回退链 + PS 蓝色兜底；无 → 直接蓝色占位
        // v1.9.29: ① 传递 kind 给 _sglvPsCoverFallback ② onerror 链跳过 chain[0]
        // v1.9.41: good/链走 coverGoodUrl/coverChainLang
        function psplusPosterImg(appid, name) {
            if (!appid) {
                return '<div class="sglv-ps-cover-placeholder"><div class="sglv-ps-logo">' + PS_LOGO_SVG + '</div><div class="sglv-ps-cover-name">' + Host.wlEscape(name || 'PS Exclusive') + '</div></div>';
            }
            const good = coverGoodUrl(appid, 'poster');
            if (good) {
                return '<img class="sglv-card-img" src="' + good + '" alt="' + Host.wlEscape(name) + '" loading="lazy" decoding="async" onerror="_sglvPsCoverFallback(this,\'' + appid + '\',\'poster\');" onload="' + _sgcvPosterOnloadAttr(appid) + '">';
            }
            // v1.9.44: 竖版确认缺失 → 横版替代直用（交叉缓存）
            const horizHtml = _sgcvHorizontalFallbackImgHtml(appid, Host.wlEscape(name), 'sglv-card-img', '_sglvPsCoverFallback');
            if (horizHtml) return horizHtml;
            const chain = coverChainLang(appid, 'poster');
            let handler = '_sglvPsCoverFallback(this, \'' + appid + '\', \'poster\');';
            for (let i = chain.length - 1; i >= 1; i--) {
                handler = 'this.src=\'' + chain[i] + '\';this.onerror=function(){' + handler + '}';
            }
            handler = '_sgcvCoverRace(this, \'' + appid + '\', \'poster\');' + handler;
            return '<img class="sglv-card-img" src="' + chain[0] + '" alt="' + Host.wlEscape(name) + '" loading="lazy" decoding="async" onerror="' + handler + '" onload="' + _sgcvPosterOnloadAttr(appid) + '">';
        }

        // PS 会免横版封面（capsule 大横幅）
        // v1.9.29: ① 传递 kind 给 _sglvPsCoverFallback ② onerror 链跳过 chain[0]
        // v1.9.41: good/链走 coverGoodUrl/coverChainLang
        function psplusCapsuleImg(appid, name) {
            if (!appid) {
                return '<div class="sglv-ps-cover-placeholder"><div class="sglv-ps-logo">' + PS_LOGO_SVG + '</div><div class="sglv-ps-cover-name">' + Host.wlEscape(name || 'PS Exclusive') + '</div></div>';
            }
            const good = coverGoodUrl(appid, 'capsule');
            if (good) {
                return '<img class="sglv-wl-cover-img" src="' + good + '" alt="' + Host.wlEscape(name) + '" loading="lazy" decoding="async" onerror="_sglvPsCoverFallback(this,\'' + appid + '\',\'capsule\');" onload="_sglvRecordPosterGood(\'' + appid + '\',this.src,\'capsule\');">';
            }
            const chain = coverChainLang(appid, 'capsule');
            let handler = '_sglvPsCoverFallback(this, \'' + appid + '\', \'capsule\');';
            for (let i = chain.length - 1; i >= 1; i--) {
                handler = 'this.src=\'' + chain[i] + '\';this.onerror=function(){' + handler + '}';
            }
            handler = '_sgcvCoverRace(this, \'' + appid + '\', \'capsule\');' + handler;
            return '<img class="sglv-wl-cover-img" src="' + chain[0] + '" alt="' + Host.wlEscape(name) + '" loading="lazy" decoding="async" onerror="' + handler + '" onload="_sglvRecordPosterGood(\'' + appid + '\',this.src,\'capsule\');">';
        }

        // 档位标签
        function psTierLabel(tier) {
            if (tier === 1) return Host.T.psTierEssential;
            if (tier === 2) return Host.T.psTierExtra;
            if (tier === 3) return Host.T.psTierPremium;
            return '?';
        }
        function psTierClass(tier) {
            if (tier === 1) return 'tier-essential';
            if (tier === 2) return 'tier-extra';
            if (tier === 3) return 'tier-premium';
            return '';
        }

        // 状态颜色映射
        function psStatusColor(statusName) {
            if (statusName === '在库') return '#4caf50';
            if (statusName === '领取中') return '#2196f3';
            if (statusName === '截止领取' || statusName === '已出库') return '#ff9800';
            if (statusName === '即将出库') return '#ff5722';
            return '#888';
        }

        // 获取游戏显示名称——v2.6.2 优先用 psstore 提取的英文名作为初始显示，中文名异步替换
        // 有 steamAppId：先用 psExtractName 提取英文名（如果有 psstore），再异步 fetchGameZhName 替换为中文名
        // 无 steamAppId (PS 独占)：用 psExtractName 提取英文名，再异步 fetchPsStoreName 抓页面拿中文名
        function psGameName(g) {
            const fromPs = psExtractName(g.psstore);
            if (fromPs) return fromPs;
            if (g.steamAppId) return Host.isZh ? `App ${g.steamAppId}` : `App ${g.steamAppId}`;
            return Host.isZh ? 'PS 独占' : 'PS Exclusive';
        }

        // 数据加载（@resource 兜底 + 远程 JSON 异步更新 + 永久缓存）
        // v1.9.5: 缓存永不过期——优先读永久缓存秒开，后台静默全量刷新（6h 节流）
        // v2.7.1: @require 库中 GM_xmlhttpRequest 可能因 Tampermonkey 沙箱隔离而静默挂起，
        //         改为优先用 @resource（GM_getResourceText）同步兜底，后台异步更新缓存。
        const _PSPLUS_BG_INTERVAL = 6 * 3600 * 1000; // v1.9.5: 后台刷新 6h 节流
        let _psplusLastBgRefreshAt = 0;
        // v1.9.24: 简单字符串哈希（djb2 变体），用于检测远程数据是否变化
        function _psplusDataHash(str) {
            let hash = 5381;
            const len = str.length;
            // 采样哈希：前500字符 + 后500字符 + 长度，避免对超大 JSON 全量遍历
            const sample = str.slice(0, 500) + str.slice(Math.max(0, len - 500)) + len;
            for (let i = 0; i < sample.length; i++) {
                hash = ((hash << 5) + hash) + sample.charCodeAt(i);
                hash = hash & hash;
            }
            return String(hash);
        }
        async function loadPsplusGames() {
            // v1.9.38: 移除 force 刷新路径（刷新按钮已移除），保留缓存/资源秒开 + 后台静默刷新
            if (psplusState.loading) return;

            // v1.9.5: 优先读永久缓存（永不过期）
            const cached = _permCacheGet('psplusGames');
            if (cached && Array.isArray(cached.games) && cached.games.length > 0) {
                psplusState.games = cached.games;
                psplusState.updatedAt = cached.updatedAt || '';
                psplusState.loaded = true;
                renderPsplusSections();
                // 后台静默刷新（6h 节流）
                if (_shouldThrottle(_psplusLastBgRefreshAt, _PSPLUS_BG_INTERVAL)) return;
                _refreshPsplusFromRemote(false);
                return;
            }

            // 2) 永久缓存无 → 用 @resource 同步兜底（GM_getResourceText，零网络依赖）
            let resourceData = null;
            try {
                const raw = Host.getResourceText ? Host.getResourceText('psplusData') : null;
                if (raw) {
                    const parsed = JSON.parse(raw);
                    if (parsed && Array.isArray(parsed.games) && parsed.games.length > 0) {
                        resourceData = parsed;
                    }
                }
            } catch (e) { /* resource 解析失败，忽略 */ }

            if (resourceData) {
                psplusState.games = resourceData.games;
                psplusState.updatedAt = resourceData.updatedAt || '';
                psplusState.loaded = true;
                psplusState.loading = false;
                // v1.9.26: 写入永久缓存（含 dataHash）
                _permCacheSet('psplusGames', { games: resourceData.games, updatedAt: resourceData.updatedAt, dataHash: _psplusDataHash(JSON.stringify(resourceData)) });
                renderPsplusSections();
                // 后台异步更新（获取最新全量快照）
                _refreshPsplusFromRemote(false);
                return;
            }

            // 3) @resource 也不可用 → 回退到 GM_xmlhttpRequest 异步加载
            _refreshPsplusFromRemote(true);
        }

        // 内部：后台异步从远程 JSON 更新 PS会免数据
        // v1.9.5: 远程数据到达后全量替换（上游为每日全量快照）
        // v1.9.26: 增加 _psplusDataHash 哈希对比——远程数据未变化则跳过更新/缓存写入
        // v1.9.38: 移除 force 刷新（刷新按钮/spinner/状态文本已删除）
        // showLoading=true 时显示 loading 状态（用于无缓存的首次加载）
        function _refreshPsplusFromRemote(showLoading) {
            if (typeof GM_xmlhttpRequest !== 'function') return; // 沙箱中不可用则跳过
            // v1.9.38: 无手动刷新入口，loading 中直接返回避免并发请求
            if (psplusState.loading) return;

            // v1.9.26: 获取缓存中的数据哈希，用于远程数据变化检测
            const cached = _permCacheGet('psplusGames');
            const cachedHash = (cached && cached.dataHash) || '';

            if (showLoading) {
                psplusState.loading = true;
                psplusState.loadError = null;
                renderPsplusGamesList();
            }

            // v1.9.27: loading 安全超时——30s 后强制清除 loading（防止浏览器扩展阻断回调导致永久卡死）
            let _psplusLoadingTimer = null;
            if (showLoading) {
                _psplusLoadingTimer = setTimeout(() => {
                    if (psplusState.loading) {
                        psplusState.loading = false;
                        // 尝试从永久缓存恢复数据
                        const cacheFallback = _permCacheGet('psplusGames');
                        if (cacheFallback && Array.isArray(cacheFallback.games) && cacheFallback.games.length > 0) {
                            psplusState.games = cacheFallback.games;
                            psplusState.updatedAt = cacheFallback.updatedAt || '';
                            psplusState.loaded = true;
                            psplusState.loadError = null;
                        } else {
                            psplusState.loadError = 'Timeout (loading safety)';
                        }
                        renderPsplusGamesList();
                    }
                }, 30000);
            }

            // v1.9.27: 统一清理 loading 超时定时器
            const _clearLoadingTimer = () => { if (_psplusLoadingTimer) { clearTimeout(_psplusLoadingTimer); _psplusLoadingTimer = null; } };

            // v1.9.27: 错误时尝试从永久缓存恢复数据（避免刷新失败导致数据全部丢失）
            const _restoreCacheOnError = () => {
                if (psplusState.games.length === 0) {
                    const cacheFallback = _permCacheGet('psplusGames');
                    if (cacheFallback && Array.isArray(cacheFallback.games) && cacheFallback.games.length > 0) {
                        psplusState.games = cacheFallback.games;
                        psplusState.updatedAt = cacheFallback.updatedAt || '';
                        psplusState.loaded = true;
                        psplusState.loadError = null;
                        return true;
                    }
                }
                return false;
            };

            // v1.9.37: 主源 + 降级数据源多级回退——主源（oXnMe）失败时依次尝试 SmallRob/steam-namespace 镜像
            const _psplusAllUrls = [PSPLUS_DATA_URL].concat(PSPLUS_BACKUP_URLS);
            function _tryNextUrl(idx) {
                if (idx >= _psplusAllUrls.length) {
                    // 所有源均失败 → 尝试从缓存恢复数据
                    _clearLoadingTimer();
                    if (showLoading) {
                        psplusState.loading = false;
                        if (_restoreCacheOnError()) {
                            renderPsplusSections();
                        } else {
                            psplusState.loadError = 'All sources failed';
                            renderPsplusGamesList();
                        }
                    }
                    return;
                }
                GM_xmlhttpRequest({
                    method: 'GET',
                    url: _psplusAllUrls[idx],
                    timeout: 20000,
                    onload(r) {
                        try {
                            // v1.9.27: 使用 _safeRespText 防止浏览器扩展 hook XHR 导致 responseText 抛 InvalidStateError
                            const rawText = _safeRespText(r);
                            // v1.9.37: 非 2xx 响应 → 尝试下一个源
                            if (r.status < 200 || r.status >= 300 || !rawText) { _tryNextUrl(idx + 1); return; }
                            // v1.9.26: 计算远程数据哈希，与缓存哈希对比
                            const remoteHash = _psplusDataHash(rawText);

                            // v1.9.26: 哈希对比——远程数据未变化则跳过更新，保留现有缓存和状态
                            if (cachedHash && remoteHash === cachedHash) {
                                _clearLoadingTimer();
                                psplusState.loading = false;
                                _psplusLastBgRefreshAt = Date.now();
                                return;
                            }

                            const parsed = JSON.parse(rawText);
                            if (parsed && Array.isArray(parsed.games) && parsed.games.length > 0) {
                                _clearLoadingTimer();
                                // v1.9.38: 上游为全量快照，直接整体替换 state（修复 _mergeByAppid 按 appid
                                //          合并、但 PS会免条目无 appid 字段导致非空状态合并后数据被清空的根因）
                                psplusState.games = parsed.games;
                                psplusState.updatedAt = parsed.updatedAt || '';
                                psplusState.loaded = true;
                                psplusState.loading = false;
                                _psplusLastBgRefreshAt = Date.now();
                                // v1.9.26: 写入永久缓存（含 dataHash）
                                _permCacheSet('psplusGames', { games: psplusState.games, updatedAt: psplusState.updatedAt, dataHash: remoteHash });
                                renderPsplusSections();
                                return;
                            }
                            // 格式无效 → 尝试下一个源
                            _tryNextUrl(idx + 1);
                        } catch (e) {
                            // 解析异常 → 尝试下一个源
                            _tryNextUrl(idx + 1);
                        }
                    },
                    onerror() { _tryNextUrl(idx + 1); },
                    ontimeout() { _tryNextUrl(idx + 1); },
                });
            }
            _tryNextUrl(0);
        }

        // 筛选 + 排序
        function getFilteredPsplus() {
            const q = psplusState.search.toLowerCase().trim();
            const ownedIds = Host.getActiveOwnedAppIds();
            const isPsOwned = g => g.steamAppId && (ownedIds.has(Number(g.steamAppId)) || ownedIds.has(String(g.steamAppId)));
            let games = psplusState.games.filter(g => {
                if (q) {
                    const name = psExtractName(g.psstore).toLowerCase();
                    const appid = String(g.steamAppId || '');
                    if (!name.includes(q) && !appid.includes(q) && !(g.month || '').includes(q)) return false;
                }
                if (psplusState.tierFilter !== 'all') {
                    // v1.6.0: catalog 档位匹配 tier 2(升级) + 3(高级)
                    if (psplusState.tierFilter === 'catalog') {
                        if (g.tier !== 2 && g.tier !== 3) return false;
                    } else if (String(g.tier) !== psplusState.tierFilter) return false;
                }
                if (psplusState.statusFilter !== 'all') {
                    if (psplusState.statusFilter === 'expired') {
                        if (g.statusName !== '截止领取' && g.statusName !== '已出库') return false;
                    } else if (psplusState.statusFilter === 'steamOwned') {
                        // v2.7.9: 直接筛选 Steam 家庭共享库已有的匹配游戏
                        if (!isPsOwned(g)) return false;
                    } else if (g.statusName !== psplusState.statusFilter) return false;
                }
                return true;
            });
            const tierOrder = { 1: 1, 2: 2, 3: 3 };
            games.sort((a, b) => {
                switch (psplusState.sort) {
                    case 'dateAsc': return (a.monthSort || '').localeCompare(b.monthSort || '');
                    case 'tierAsc': return (tierOrder[a.tier] || 9) - (tierOrder[b.tier] || 9) || (b.monthSort || '').localeCompare(a.monthSort || '');
                    case 'tierDesc': return (tierOrder[b.tier] || 9) - (tierOrder[a.tier] || 9) || (b.monthSort || '').localeCompare(a.monthSort || '');
                    case 'nameAsc': return _nameCollator.compare(psExtractName(a.psstore) || '~', psExtractName(b.psstore) || '~');
                    case 'dateDesc':
                    default: return (b.monthSort || '').localeCompare(a.monthSort || '');
                }
            });
            return games;
        }

        // ----- 渲染 -----
        function renderPsplusTab(parent) {
            const wrap = document.createElement('div');
            wrap.className = 'sglv-psplus-wrap';

            // KPI 区域
            const kpi = document.createElement('div');
            kpi.id = 'sglv-psplus-kpi';
            wrap.appendChild(kpi);

            // 工具栏（v2.6.1：紧凑两行——第1行 搜索+排序+视图；第2行 筛选按钮+分页）
            const toolbar = document.createElement('div');
            toolbar.className = 'sglv-toolbar';
            const sortOptions = [
                { key: 'dateDesc', label: Host.T.psSortDateDesc },
                { key: 'dateAsc', label: Host.T.psSortDateAsc },
                { key: 'tierAsc', label: Host.T.psSortTierAsc },
                { key: 'tierDesc', label: Host.T.psSortTierDesc },
                { key: 'nameAsc', label: Host.T.psSortNameAsc },
            ];
            toolbar.innerHTML = `
                <input class="sglv-search" aria-label="搜索" id="sglv-psplus-search" placeholder="${Host.T.psSearch}" value="${Host.wlEscape(psplusState.search)}">
                <select class="sglv-sort-select" aria-label="排序方式" id="sglv-psplus-sort">
                    ${sortOptions.map(o => `<option value="${o.key}"${psplusState.sort === o.key ? ' selected' : ''}>${o.label}</option>`).join('')}
                </select>
                <div class="sglv-view-toggle">
                    <button class="sglv-btn sglv-btn-secondary sglv-btn-icon${psplusState.viewMode === 'card' ? ' active' : ''}" id="sglv-ps-card" title="${Host.T.cardView}">${Host.ICONS.grid}</button>
                    <button class="sglv-btn sglv-btn-secondary sglv-btn-icon${psplusState.viewMode === 'cover' ? ' active' : ''}" id="sglv-ps-cover" title="${Host.T.coverView}">${Host.ICONS.cover}</button>
                    <button class="sglv-btn sglv-btn-secondary sglv-btn-icon${psplusState.viewMode === 'list' ? ' active' : ''}" id="sglv-ps-list" title="${Host.T.listView}">${Host.ICONS.list}</button>
                </div>
                <span class="sglv-ps-status" id="sglv-ps-status"></span>
            `;
            wrap.appendChild(toolbar);

            // 筛选栏（档位 + 状态）——分页也放这一行（v2.6.1 紧凑操作栏）
            const filterBar = document.createElement('div');
            filterBar.className = 'sglv-filter-bar';
            const tierBtns = [
                { key: 'all', label: Host.T.all },
                { key: '1', label: Host.T.psTierEssential },
                { key: '2', label: Host.T.psTierExtra },
                { key: '3', label: Host.T.psTierPremium },
            ];
            const statusBtns = [
                { key: 'all', label: Host.T.psStatusAll },
                { key: '在库', label: Host.T.psStatusIn },
                { key: '领取中', label: Host.T.psStatusActive },
                { key: 'expired', label: Host.T.psStatusExpired },
                { key: '即将出库', label: Host.T.psStatusLeaving },
                { key: 'steamOwned', label: Host.T.steamInLib },
            ];
            filterBar.innerHTML = `
                <div class="sglv-filter-bar-group">
                    ${tierBtns.map(b => `<button class="sglv-btn sglv-btn-secondary sglv-ps-tier-btn${psplusState.tierFilter === b.key ? ' active' : ''}" data-tier="${b.key}">${b.label}</button>`).join('')}
                </div>
                <span class="sglv-filter-sep"></span>
                <div class="sglv-filter-bar-group">
                    ${statusBtns.map(b => `<button class="sglv-btn sglv-btn-secondary sglv-ps-status-btn${psplusState.statusFilter === b.key ? ' active' : ''}" data-status="${b.key}">${b.label}</button>`).join('')}
                </div>
                <div class="sglv-pagination sglv-pagination-inline" id="sglv-psplus-pagination"></div>
            `;
            wrap.appendChild(filterBar);

            // 游戏列表容器
            const content = document.createElement('div');
            content.className = 'sglv-content';
            content.id = 'sglv-psplus-content';
            wrap.appendChild(content);

            parent.appendChild(wrap);

            // 事件绑定
            toolbar.querySelector('#sglv-psplus-search').addEventListener('input', _debounce((e) => {
                psplusState.search = e.target.value;
                psplusState.page = 1;
                renderPsplusGamesList();
            }, 200));
            toolbar.querySelector('#sglv-psplus-sort').addEventListener('change', (e) => {
                psplusState.sort = e.target.value;
                psplusState.page = 1;
                renderPsplusGamesList();
            });
            const setPsViewMode = (mode) => {
                psplusState.viewMode = mode;
                ['card', 'cover', 'list'].forEach(m => {
                    toolbar.querySelector('#sglv-ps-' + m)?.classList.toggle('active', m === mode);
                });
                renderPsplusGamesList();
            };
            toolbar.querySelector('#sglv-ps-card').addEventListener('click', () => setPsViewMode('card'));
            toolbar.querySelector('#sglv-ps-cover').addEventListener('click', () => setPsViewMode('cover'));
            toolbar.querySelector('#sglv-ps-list').addEventListener('click', () => setPsViewMode('list'));

            filterBar.querySelectorAll('.sglv-ps-tier-btn').forEach(btn => {
                btn.addEventListener('click', () => {
                    psplusState.tierFilter = btn.dataset.tier;
                    psplusState.page = 1;
                    filterBar.querySelectorAll('.sglv-ps-tier-btn').forEach(b => b.classList.remove('active'));
                    btn.classList.add('active');
                    renderPsplusKpi();      // v1.6.0: 同步 KPI active 高亮
                    renderPsplusGamesList();
                });
            });
            filterBar.querySelectorAll('.sglv-ps-status-btn').forEach(btn => {
                btn.addEventListener('click', () => {
                    psplusState.statusFilter = btn.dataset.status;
                    psplusState.page = 1;
                    filterBar.querySelectorAll('.sglv-ps-status-btn').forEach(b => b.classList.remove('active'));
                    btn.classList.add('active');
                    renderPsplusKpi();      // v1.6.0: 同步 KPI active 高亮
                    renderPsplusGamesList();
                });
            });

            // v1.6.0: 筛选改为点击 KPI 卡片切换（再次点击同一卡片回到「全部」），与年度大作/Epic赠送标签页一致
            kpi.addEventListener('click', e => {
                const card = e.target.closest('[data-psplus-filter]');
                if (!card) return;
                const f = card.dataset.psplusFilter;
                const activeKpi = getPsplusActiveKpi();
                if (activeKpi === f) {
                    // 再次点击同一卡片 → 回到「全部」
                    psplusState.tierFilter = 'all';
                    psplusState.statusFilter = 'all';
                } else {
                    switch (f) {
                        case 'all':        psplusState.tierFilter = 'all';     psplusState.statusFilter = 'all';        break;
                        case 'essential':  psplusState.tierFilter = '1';       psplusState.statusFilter = 'all';        break;
                        case 'catalog':    psplusState.tierFilter = 'catalog'; psplusState.statusFilter = 'all';        break;
                        case 'steamOwned': psplusState.tierFilter = 'all';     psplusState.statusFilter = 'steamOwned'; break;
                    }
                }
                psplusState.page = 1;
                syncPsplusFilterBtns(filterBar);   // 同步筛选栏按钮 active 状态
                renderPsplusKpi();                  // 刷新 KPI active 高亮
                renderPsplusGamesList();
            });

            if (!psplusState.loaded && !psplusState.loading) {
                loadPsplusGames();
            } else {
                renderPsplusSections();
            }
        }

        function renderPsplusSections() {
            if (_collectionActiveTab !== 'psplus' || !document.getElementById('sglv-psplus-content')) return;
            renderPsplusKpi();
            renderPsplusGamesList();
            renderPsplusRefreshStatus();
        }

        /** v1.9.38: 渲染 PS会免工具栏状态文本（仅显示更新时间，手动刷新已移除） */
        function renderPsplusRefreshStatus() {
            const el = document.getElementById('sglv-ps-status');
            if (!el) return;
            const zh = Host.isZh;
            const date = psplusState.updatedAt ? psplusState.updatedAt.slice(0, 10) : '';
            el.textContent = date ? (zh ? '更新: ' : 'Updated: ') + date : '';
            el.className = 'sglv-ps-status';
        }

        // v1.6.0: 根据 tierFilter + statusFilter 推断当前激活的 KPI 卡片
        function getPsplusActiveKpi() {
            if (psplusState.tierFilter === 'all' && psplusState.statusFilter === 'all') return 'all';
            if (psplusState.tierFilter === '1' && psplusState.statusFilter === 'all') return 'essential';
            if (psplusState.tierFilter === 'catalog' && psplusState.statusFilter === 'all') return 'catalog';
            if (psplusState.tierFilter === 'all' && psplusState.statusFilter === 'steamOwned') return 'steamOwned';
            return ''; // 自定义组合，无 KPI 高亮
        }

        // v1.6.0: KPI 点击后同步筛选栏按钮 active 状态
        function syncPsplusFilterBtns(filterBar) {
            filterBar.querySelectorAll('.sglv-ps-tier-btn').forEach(b => {
                b.classList.toggle('active', b.dataset.tier === psplusState.tierFilter);
            });
            filterBar.querySelectorAll('.sglv-ps-status-btn').forEach(b => {
                b.classList.toggle('active', b.dataset.status === psplusState.statusFilter);
            });
        }

        function renderPsplusKpi() {
            const el = document.getElementById('sglv-psplus-kpi');
            if (!el) return;
            if (!psplusState.loaded) { el.innerHTML = ''; return; }

            const games = psplusState.games;
            const total = games.length;
            const essential = games.filter(g => g.tier === 1).length;
            const catalog = games.filter(g => g.tier === 2 || g.tier === 3).length;
            const steamLinked = games.filter(g => g.steamAppId).length;
            const ownedIds = Host.getActiveOwnedAppIds();
            const steamOwned = games.filter(g => g.steamAppId && (ownedIds.has(Number(g.steamAppId)) || ownedIds.has(String(g.steamAppId)))).length;
            const updatedStr = psplusState.updatedAt ? (Host.isZh ? '更新于 ' : 'Updated ') + psplusState.updatedAt.slice(0, 10) : '';
            const activeKpi = getPsplusActiveKpi();
            const tipAll = Host.isZh ? '点击筛选：全部' : 'Click to filter: All';
            const tipEssential = Host.isZh ? '点击筛选：必备档' : 'Click to filter: Essential';
            const tipCatalog = Host.isZh ? '点击筛选：升级/高级档' : 'Click to filter: Extra/Premium';
            const tipSteam = Host.isZh ? '点击筛选：Steam 已拥有' : 'Click to filter: Owned on Steam';

            el.innerHTML = `
                <div class="sglv-trend-kpi-row">
                    <div class="sglv-trend-kpi-card blue clickable${activeKpi === 'all' ? ' active' : ''}" data-psplus-filter="all" title="${tipAll}">
                        <div class="sglv-trend-kpi-header"><span class="sglv-trend-kpi-icon">${Host.ICONS.playstation}</span><span class="sglv-trend-kpi-label">${Host.T.psKpiTotal}</span></div>
                        <div class="sglv-trend-kpi-value">${total.toLocaleString()}</div>
                        <div class="sglv-trend-kpi-sub">${updatedStr}</div>
                    </div>
                    <div class="sglv-trend-kpi-card clickable${activeKpi === 'essential' ? ' active' : ''}" style="border-left:3px solid #FFCD3C" data-psplus-filter="essential" title="${tipEssential}">
                        <div class="sglv-trend-kpi-header"><span class="sglv-trend-kpi-icon" style="color:#FFCD3C">${Host.ICONS.gift}</span><span class="sglv-trend-kpi-label">${Host.T.psKpiMonthly}</span></div>
                        <div class="sglv-trend-kpi-value">${essential.toLocaleString()}</div>
                        <div class="sglv-trend-kpi-sub">${Host.T.psTierEssential}</div>
                    </div>
                    <div class="sglv-trend-kpi-card clickable${activeKpi === 'catalog' ? ' active' : ''}" style="border-left:3px solid #2196f3" data-psplus-filter="catalog" title="${tipCatalog}">
                        <div class="sglv-trend-kpi-header"><span class="sglv-trend-kpi-icon" style="color:#2196f3">${Host.ICONS.library}</span><span class="sglv-trend-kpi-label">${Host.T.psKpiCatalog}</span></div>
                        <div class="sglv-trend-kpi-value">${catalog.toLocaleString()}</div>
                        <div class="sglv-trend-kpi-sub">${Host.T.psTierExtra} / ${Host.T.psTierPremium}</div>
                    </div>
                    <div class="sglv-trend-kpi-card mine clickable${activeKpi === 'steamOwned' ? ' active' : ''}" data-psplus-filter="steamOwned" title="${tipSteam}">
                        <div class="sglv-trend-kpi-header"><span class="sglv-trend-kpi-icon">${Host.ICONS.heart}</span><span class="sglv-trend-kpi-label">${Host.T.psKpiSteamOwned}</span></div>
                        <div class="sglv-trend-kpi-value">${steamOwned.toLocaleString()}</div>
                        <div class="sglv-trend-kpi-sub">${Host.T.psKpiSteamTotal.replace('{n}', steamLinked)}</div>
                    </div>
                </div>
            `;
        }

        function renderPsplusGamesList() {
            const content = document.getElementById('sglv-psplus-content');
            if (!content) return;
            const clearPagination = () => { const p = document.getElementById('sglv-psplus-pagination'); if (p) p.innerHTML = ''; };

            if (psplusState.loading) {
                content.innerHTML = '<div class="sglv-progress" style="margin:16px 0"><div class="sglv-progress-fill" style="width:45%"></div></div><div class="sglv-empty">' + Host.T.psLoading + '</div>';
                clearPagination();
                return;
            }
            if (psplusState.loadError) {
                content.innerHTML = '<div class="sglv-empty">' + Host.T.psLoadError + '</div>';
                clearPagination();
                return;
            }
            if (!psplusState.loaded || psplusState.games.length === 0) {
                content.innerHTML = '<div class="sglv-empty">' + Host.T.psLoading + '</div>';
                clearPagination();
                return;
            }

            const games = getFilteredPsplus();
            if (games.length === 0) {
                content.innerHTML = '<div class="sglv-empty">' + (Host.isZh ? '无匹配结果' : 'No matching results') + '</div>';
                clearPagination();
                return;
            }

            const { pageItems, totalPages, page: _clampedPage } = Host.paginate(games, psplusState.page, psplusState.pageSize);
            psplusState.page = _clampedPage;

            const ownedIds = Host.getActiveOwnedAppIds();
            const isOwned = g => g.steamAppId && (ownedIds.has(Number(g.steamAppId)) || ownedIds.has(String(g.steamAppId)));

            const tierBadgeHtml = g => '<span class="sglv-ps-tier-badge ' + psTierClass(g.tier) + '">' + psTierLabel(g.tier) + '</span>';
            const statusBadgeHtml = g => '<span class="sglv-card-badge" style="background:' + psStatusColor(g.statusName) + ';color:#fff;font-size:10px;margin-top:0;padding:2px 6px;border-radius:3px">' + Host.wlEscape(g.statusDisplay || g.statusName) + '</span>';
            const versionsHtml = g => (g.versions || []).map(v => '<span style="font-size:10px;padding:1px 4px;border-radius:2px;background:rgba(255,255,255,0.1);border:1px solid rgba(255,255,255,0.2)">' + v + '</span>').join(' ');
            const ownershipBadgeHtml = g => isOwned(g) ? '<span class="sglv-card-badge owned" style="margin-top:0">✓ ' + Host.T.steamInLib + '</span>' : '';

            // 卡片视图
            if (psplusState.viewMode === 'card') {
                content.innerHTML = '<div class="sglv-card-grid">' + pageItems.map(g => {
                    const appid = Number(g.steamAppId) || 0;
                    const name = psGameName(g);
                    const clickUrl = appid ? 'https://store.steampowered.com/app/' + appid : (g.psstore || '#');
                    // v2.6.2: 名称 span 加 data-sglv-psstore 以便异步替换 PS 独占中文名
                    const nameSpan = appid
                        ? '<span data-sglv-appid="' + appid + '" data-sglv-psstore="' + Host.wlEscape(g.psstore || '') + '">' + Host.wlEscape(name) + '</span><span class="sglv-card-id-inline">' + appid + '</span>'
                        : '<span data-sglv-psstore="' + Host.wlEscape(g.psstore || '') + '">' + Host.wlEscape(name) + '</span>';
                    return '<div class="sglv-game-card" data-appid="' + (appid || g.recordId) + '" onclick="window.open(\'' + clickUrl + '\',\'_blank\')">' +
                        '<div class="sglv-card-img-wrap">' + tierBadgeHtml(g) + psplusPosterImg(appid, name) + '</div>' +
                        '<div class="sglv-card-body">' +
                            '<div class="sglv-card-name" title="' + Host.wlEscape(name) + '">' + nameSpan + '</div>' +
                            '<div class="sglv-info-row sglv-wl-price-row">' + statusBadgeHtml(g) + ownershipBadgeHtml(g) + '</div>' +
                            '<div class="sglv-info-row sglv-ps-meta-row"><span class="sglv-meta-item sglv-ps-month-item"><span class="sglv-ps-clock">' + Host.ICONS.clock + '</span><span>' + Host.wlEscape(g.month || '') + '</span></span><span class="sglv-ps-versions">' + versionsHtml(g) + '</span></div>' +
                        '</div>' +
                    '</div>';
                }).join('') + '</div>';
            } else if (psplusState.viewMode === 'cover') {
                // 封面视图（横板大图）
                // v2.9.22: 信息行紧凑到 3 行：标题 / [状态+在库] / [月份+版本]
                content.innerHTML = '<div class="sglv-wl-cover-grid">' + pageItems.map(g => {
                    const appid = Number(g.steamAppId) || 0;
                    const name = psGameName(g);
                    const clickUrl = appid ? 'https://store.steampowered.com/app/' + appid : (g.psstore || '#');
                    const nameSpan = appid
                        ? '<span data-sglv-appid="' + appid + '" data-sglv-psstore="' + Host.wlEscape(g.psstore || '') + '">' + Host.wlEscape(name) + '</span><span class="sglv-card-id-inline">' + appid + '</span>'
                        : '<span data-sglv-psstore="' + Host.wlEscape(g.psstore || '') + '">' + Host.wlEscape(name) + '</span>';
                    return '<div class="sglv-wl-cover-card" data-appid="' + (appid || g.recordId) + '" onclick="window.open(\'' + clickUrl + '\',\'_blank\')">' +
                        '<div class="sglv-wl-cover-img-wrap">' + tierBadgeHtml(g) + psplusCapsuleImg(appid, name) + '</div>' +
                        '<div class="sglv-wl-cover-body">' +
                            '<div class="sglv-card-name" title="' + Host.wlEscape(name) + '">' + nameSpan + '</div>' +
                            '<div class="sglv-info-row sglv-wl-price-row sglv-ps-status-row">' + statusBadgeHtml(g) + ownershipBadgeHtml(g) + '</div>' +
                            '<div class="sglv-info-row sglv-ps-meta-row"><span class="sglv-meta-item sglv-ps-month-item"><span class="sglv-ps-clock">' + Host.ICONS.clock + '</span><span>' + Host.wlEscape(g.month || '') + '</span></span><span class="sglv-ps-versions">' + versionsHtml(g) + '</span></div>' +
                        '</div>' +
                    '</div>';
                }).join('') + '</div>';
            } else {
                // 列表视图
                content.innerHTML = '<div class="sglv-list-view">' + pageItems.map(g => {
                    const appid = Number(g.steamAppId) || 0;
                    const name = psGameName(g);
                    const clickUrl = appid ? 'https://store.steampowered.com/app/' + appid : (g.psstore || '#');
                    const iconHtml = appid
                        ? '<img class="sglv-list-icon" src="' + Host.getGameIconUrl(appid, '') + '" alt="' + Host.wlEscape(name) + '" loading="lazy" decoding="async" onerror="_sglvPsListIconFallback(this)">'
                        : '<div class="sglv-list-icon" style="display:flex;align-items:center;justify-content:center;background:linear-gradient(135deg,#003791,#0070D1);color:#fff;border-radius:4px;padding:4px">' + Host.ICONS.playstation + '</div>';
                    const nameSpan = appid
                        ? '<span data-sglv-appid="' + appid + '" data-sglv-psstore="' + Host.wlEscape(g.psstore || '') + '">' + Host.wlEscape(name) + '</span><span class="sglv-card-id-inline">' + appid + '</span>'
                        : '<span data-sglv-psstore="' + Host.wlEscape(g.psstore || '') + '">' + Host.wlEscape(name) + '</span>';
                    return '<div class="sglv-list-item" data-appid="' + (appid || g.recordId) + '" onclick="window.open(\'' + clickUrl + '\',\'_blank\')">' +
                        iconHtml +
                        '<div class="sglv-list-info">' +
                            '<div class="sglv-list-name">' + nameSpan + '</div>' +
                            '<div class="sglv-list-meta">' + tierBadgeHtml(g) + statusBadgeHtml(g) + ownershipBadgeHtml(g) + '<span style="font-size:11px;color:var(--sglv-text-secondary)">' + Host.wlEscape(g.month || '') + '</span><span style="display:flex;gap:2px">' + versionsHtml(g) + '</span></div>' +
                        '</div>' +
                    '</div>';
                }).join('') + '</div>';
            }

            // v1.9.47-fix: 补 onJump——PS会免翻页 5 个按钮全部走 onJump(参见主脚本 renderPagination)
            const pagination = document.getElementById('sglv-psplus-pagination');
            if (pagination) {
                Host.renderPagination(pagination, 'sglv-psplus', psplusState.page, totalPages, games.length,
                    () => { psplusState.page--; renderPsplusGamesList(); },
                    () => { psplusState.page++; renderPsplusGamesList(); },
                    (p) => { psplusState.page = p; renderPsplusGamesList(); });
            }

            // v2.6.2: 异步加载中文名——同时支持 steam appid 路径与 PS 独占 psstore 路径
            content.querySelectorAll('[data-sglv-appid]').forEach(el => {
                Host.loadGameZhName(el, el.getAttribute('data-sglv-appid'), el.textContent);
            });
            // v2.6.2: PS 独占（无 steamAppId）——异步抓 psstore 页面替换为中文名
            content.querySelectorAll('[data-sglv-psstore]').forEach(el => {
                const psUrl = el.getAttribute('data-sglv-psstore');
                if (!psUrl) return;
                // 已经有 appid 的由 loadGameZhName 处理，这里跳过
                if (el.hasAttribute('data-sglv-appid')) return;
                const original = el.textContent;
                fetchPsStoreName(psUrl).then(zhName => {
                    if (zhName && zhName !== original) {
                        el.textContent = zhName;
                        el.title = `${zhName} (${original})`;
                    }
                });
            });
        }

        // ==================== Epic 赠送标签页 (v1.1.0) ====================
        // 数据来源：GitHub 自建数据源 epic_freebies.json（epic-freebies-weekly-sync.js 周同步生产，jsdelivr 三级回退）。
        // v1.9.19: 已移除 keylol 抓取兜底（帖子需登录阅读权限，无法获取）。
        // 与 "E宝的爱标识助手" 脚本共享 GM 存储 key 'epic_freebie_ids'，可互相补充。
        // 数据仅为 Steam appid 集合（无名称/日期/档位），名称经 Steam 中文名异步加载。
        // 多级兜底：① IDB 永久缓存 → ② GM 存储 epic_freebie_ids + 内置名单 → ③ 远程抓取（GitHub 数据源三级回退）→ ④ 手动 JSON 导入。
        // 拥有判定：getActiveOwnedAppIds()（尊重家庭组开关），匹配当前 Steam 用户家庭共享游戏库。

        // v1.9.17: GitHub 自建数据源三级回退链（参照年度大作 GOTY_DATA_SOURCES 写法）——
        //          优先 jsdelivr（国内稳定），raw.githubusercontent 兜底；v1.9.19 起全部失败即视为刷新失败。
        const EPIC_GITHUB_URLS = [
            'https://fastly.jsdelivr.net/gh/SmallRob/steam-namespace@main/data/epic_freebies.json',   // ① fastly 节点（优先）
            'https://cdn.jsdelivr.net/gh/SmallRob/steam-namespace@main/data/epic_freebies.json',      // ② jsdelivr 主节点
            'https://raw.githubusercontent.com/SmallRob/steam-namespace/main/data/epic_freebies.json' // ③ raw 兜底
        ];
        const EPIC_GM_KEY = 'epic_freebie_ids'; // 与 E宝的爱标识助手 共享
        // 内置兜底名单（取自 E宝的爱标识助手 MANUAL_FREEBIE_IDS）
        const EPIC_MANUAL_IDS = ['690640','1564220','822094','750920','391220','203160','362960','346940','234650','300550','49520','261640'];
        // v2.9.22: Epic Games 盾形标识（深色盾形 + 白色 EPIC/GAMES 文字，参考 Epic 官方 logo）
        const EPIC_LOGO_SVG = '<svg viewBox="0 0 100 100" xmlns="http://www.w3.org/2000/svg"><path d="M8 18 L8 52 C8 70 26 86 50 94 C74 86 92 70 92 52 L92 18 Z" fill="#1a1a1a" stroke="#3a3a3a" stroke-width="1.2"/><text x="50" y="47" text-anchor="middle" font-family="Arial Black, Helvetica, sans-serif" font-size="20" font-weight="900" fill="#fff" letter-spacing="0.5">EPIC</text><text x="50" y="65" text-anchor="middle" font-family="Arial, Helvetica, sans-serif" font-size="11" font-weight="700" fill="#fff" letter-spacing="1.2">GAMES</text></svg>';

        // 名称缓存（会话级，供搜索/排序使用；中文复用宿主持久化缓存）
        const _epicNameCache = new Map();
        const _epicNamePending = new Map();
        // v1.1.1: 通过 appdetails 获取英文名（filters=basic 含 name 字段；参考 Steam_Show_English_Name.js）
        //         旧版 filters=name 是无效过滤值，appdetails 返回 data:[]，英文名始终为空。
        function _epicFetchEnName(id) {
            return new Promise(resolve => {
                if (typeof GM_xmlhttpRequest !== 'function') { resolve(''); return; }
                GM_xmlhttpRequest({
                    method: 'GET',
                    url: 'https://store.steampowered.com/api/appdetails?appids=' + id + '&filters=basic&l=english',
                    timeout: 10000,
                    onload(r) {
                        let name = '';
                        try { const j = JSON.parse(_safeRespText(r)); const d = j && j[id]; if (d && d.success && d.data && d.data.name) name = d.data.name; } catch (e) { /* 忽略失败，不影响主流程 */ }
                        resolve(name);
                    },
                    onerror() { resolve(''); },
                    ontimeout() { resolve(''); }
                });
            });
        }
        function epicLoadName(appid) {
            const id = Number(appid);
            if (!id) return Promise.resolve('');
            if (_epicNameCache.has(id)) return Promise.resolve(_epicNameCache.get(id));
            if (_epicNamePending.has(id)) return _epicNamePending.get(id);
            // 默认中文名：中文环境优先复用宿主持久化中文名缓存（含 30 天 TTL + 负缓存）；
            // 中文名获取失败（游戏无中文名 / 请求失败）→ 回退英文名，确保至少展示一种语言名称。
            const p = (async () => {
                if (Host.isZh && typeof Host.fetchGameZhName === 'function') {
                    const zh = await Host.fetchGameZhName(id);
                    if (zh) { _epicNameCache.set(id, zh); _epicNamePending.delete(id); return zh; }
                }
                const en = await _epicFetchEnName(id);
                _epicNameCache.set(id, en || '');
                _epicNamePending.delete(id);
                return en || '';
            })();
            _epicNamePending.set(id, p);
            return p;
        }

        function epicDisplayName(appid) {
            const cached = _epicNameCache.get(Number(appid));
            if (cached) return cached;
            return 'App ' + appid;
        }

        function epicSourceLabel(source) {
            if (source === 'github') return Host.T.epicSourceGithub || (Host.isZh ? 'GitHub 数据源' : 'GitHub');
            if (source === 'keylol') return Host.T.epicSourceKeylol;
            if (source === 'local') return Host.T.epicSourceLocal;
            if (source === 'import') return Host.T.epicSourceImport;
            return Host.T.epicSourceManual;
        }

        // Epic 占位封面（HTML 字符串，用于无 appid 时初始渲染）——深色盾形 + EPIC 标识 + 名称
        function epicPlaceholder(name) {
            return '<div class="sglv-ps-cover-placeholder sglv-epic-cover-placeholder" style="background:linear-gradient(135deg,#0d0d0d,#1f1f1f)"><div class="sglv-epic-logo">' + EPIC_LOGO_SVG + '</div><div class="sglv-ps-cover-name">' + Host.wlEscape(name || 'Epic') + '</div></div>';
        }

        // Epic 占位封面 DOM（深色渐变 + 真实 Epic 盾形标识 + 名称），供运行时回退统一调用
        function epicPlaceholderDom(name) {
            const holder = document.createElement('div');
            holder.className = 'sglv-ps-cover-placeholder sglv-epic-cover-placeholder';
            holder.style.background = 'linear-gradient(135deg,#0d0d0d,#1f1f1f)';
            holder.innerHTML = '<div class="sglv-epic-logo">' + EPIC_LOGO_SVG + '</div><div class="sglv-ps-cover-name">' + Host.wlEscape(name || 'Epic') + '</div>';
            return holder;
        }

        // Epic 封面全局回退：Steam CDN 全部失败时先用 Store API 取真实封面 URL，
        // API URL 仍加载失败时替换为深色 Epic 占位（v1.1.1：修复 API URL 二次失败无兜底导致破图）
        // v1.9.29: 传递 kind 参数，使 API 兜底按图片类型选择最佳 URL
        unsafeWindow._sglvEpicCoverFallback = function(img, appid, kind) {
            if (!img || !img.parentElement) return;
            Host.fetchCoverApiUrl(appid, kind).then(url => {
                if (url) {
                    img.onerror = function() { img.onerror = null; img.parentElement.replaceChild(epicPlaceholderDom(img.alt), img); };
                    img.src = url;
                    return;
                }
                img.parentElement.replaceChild(epicPlaceholderDom(img.alt), img);
            });
        };

        // 竖版封面（卡片视图）
        // v1.9.29: ① 传递 kind 给 _sglvEpicCoverFallback ② onerror 链跳过 chain[0]
        // v1.9.41: good/链走 coverGoodUrl/coverChainLang
        function epicPosterImg(appid, name) {
            if (!appid) return epicPlaceholder(name);
            const good = coverGoodUrl(appid, 'poster');
            if (good) {
                return '<img class="sglv-card-img" src="' + good + '" alt="' + Host.wlEscape(name) + '" loading="lazy" decoding="async" onerror="_sglvEpicCoverFallback(this,\'' + appid + '\',\'poster\');" onload="' + _sgcvPosterOnloadAttr(appid) + '">';
            }
            // v1.9.44: 竖版确认缺失 → 横版替代直用（交叉缓存）
            const horizHtml = _sgcvHorizontalFallbackImgHtml(appid, Host.wlEscape(name), 'sglv-card-img', '_sglvEpicCoverFallback');
            if (horizHtml) return horizHtml;
            const chain = coverChainLang(appid, 'poster');
            let handler = '_sglvEpicCoverFallback(this, \'' + appid + '\', \'poster\');';
            for (let i = chain.length - 1; i >= 1; i--) {
                handler = 'this.src=\'' + chain[i] + '\';this.onerror=function(){' + handler + '}';
            }
            handler = '_sgcvCoverRace(this, \'' + appid + '\', \'poster\');' + handler;
            return '<img class="sglv-card-img" src="' + chain[0] + '" alt="' + Host.wlEscape(name) + '" loading="lazy" decoding="async" onerror="' + handler + '" onload="' + _sgcvPosterOnloadAttr(appid) + '">';
        }

        // 横版封面（封面视图大横幅）
        // v1.9.29: ① 传递 kind 给 _sglvEpicCoverFallback ② onerror 链跳过 chain[0]
        // v1.9.41: good/链走 coverGoodUrl/coverChainLang
        function epicCapsuleImg(appid, name) {
            if (!appid) return epicPlaceholder(name);
            const good = coverGoodUrl(appid, 'capsule');
            if (good) {
                return '<img class="sglv-wl-cover-img" src="' + good + '" alt="' + Host.wlEscape(name) + '" loading="lazy" decoding="async" onerror="_sglvEpicCoverFallback(this,\'' + appid + '\',\'capsule\');" onload="_sglvRecordPosterGood(\'' + appid + '\',this.src,\'capsule\');">';
            }
            const chain = coverChainLang(appid, 'capsule');
            let handler = '_sglvEpicCoverFallback(this, \'' + appid + '\', \'capsule\');';
            for (let i = chain.length - 1; i >= 1; i--) {
                handler = 'this.src=\'' + chain[i] + '\';this.onerror=function(){' + handler + '}';
            }
            handler = '_sgcvCoverRace(this, \'' + appid + '\', \'capsule\');' + handler;
            return '<img class="sglv-wl-cover-img" src="' + chain[0] + '" alt="' + Host.wlEscape(name) + '" loading="lazy" decoding="async" onerror="' + handler + '" onload="_sglvRecordPosterGood(\'' + appid + '\',this.src,\'capsule\');">';
        }

        // 徽章
        function epicFreeBadgeHtml() {
            return '<span class="sglv-card-badge sglv-epic-free-badge">' + Host.T.epicBadgeFree + '</span>';
        }
        function epicOwnedBadgeHtml(owned) {
            return owned
                ? '<span class="sglv-card-badge owned" style="margin-top:0">✓ ' + Host.T.steamInLib + '</span>'
                : '<span class="sglv-card-badge" style="background:rgba(255,255,255,0.12);color:#8f98a0;margin-top:0;padding:2px 6px;border-radius:3px;font-size:10px">' + Host.T.epicBadgeNotOwned + '</span>';
        }

        // 合并多个来源 → 去重数字数组
        function mergeEpicIds(...sources) {
            const set = new Set();
            for (const src of sources) {
                if (!Array.isArray(src)) continue;
                for (const id of src) {
                    const n = Number(id);
                    if (n > 0) set.add(n);
                }
            }
            return Array.from(set);
        }

        // 加载 Epic 赠送数据（多级兜底）
        // v1.9.5: 缓存永不过期——优先读永久缓存秒开，后台增量合并刷新（6h 节流）
        const _EPIC_BG_INTERVAL = 6 * 3600 * 1000;
        let _epicLastBgRefreshAt = 0;
        function loadEpicGames(force = false) {
            // v1.9.27: force 时重置可能卡死的 loading 标志
            if (epicState.loading) {
                if (!force) return;
                epicState.loading = false;
            }
            // v1.9.5: 优先读永久缓存（永不过期）
            if (!force) {
                const cached = _permCacheGet('epicFreeGames');
                if (cached && Array.isArray(cached.appids) && cached.appids.length > 0) {
                    epicState.appids = cached.appids;
                    epicState.updatedAt = cached.updatedAt || '';
                    epicState.source = cached.source || '';
                    epicState.loaded = true;
                    renderEpicSections();
                    // 后台增量刷新（6h 节流）
                    if (_shouldThrottle(_epicLastBgRefreshAt, _EPIC_BG_INTERVAL)) return;
                    _refreshEpicFromRemote(false, false);
                    return;
                }
            }
            // 2) GM 存储 + 内置名单（即时兜底）
            let gmIds = [];
            try { gmIds = GM_getValue(EPIC_GM_KEY, []) || []; } catch (e) { gmIds = []; }
            const merged = mergeEpicIds(gmIds, EPIC_MANUAL_IDS);
            if (merged.length > 0) {
                epicState.appids = merged;
                epicState.updatedAt = '';
                epicState.source = gmIds.length > 0 ? 'local' : 'manual';
                epicState.loaded = true;
                // v1.9.5: 写入永久缓存
                _permCacheSet('epicFreeGames', { appids: merged, updatedAt: '', source: epicState.source });
                if (!force) renderEpicSections();
            }
            // 3) 远程抓取（GitHub 数据源三级回退；force 时显示 loading，失败回退到本地数据）
            _refreshEpicFromRemote(force, force);
        }

        // 远程抓取失败时的统一处理（有本地数据则保留并提示，无数据则显示错误）
        function _epicFailLoading(msg) {
            epicState.loading = false;
            if (epicState.appids.length === 0) {
                epicState.loadError = msg;
            } else {
                epicState.loadError = null;
                Host.showToast(Host.isZh ? '更新失败，已使用本地数据' : 'Update failed, using local data');
            }
            renderEpicGamesList();
        }

        // 内部：远程刷新 Epic 数据（v1.9.17 改造，v1.9.19 移除 keylol 兜底）——
        //         仅走 GitHub 数据源三级回退链（fastly.jsdelivr → cdn.jsdelivr → raw.githubusercontent，
        //         参照年度大作 _refreshGotyFromRemote）。每个请求均带 timeout，
        //         onerror/ontimeout 一律降级到下一个 URL，绝不挂起
        //         （参照 v2.7.1 沙箱挂起历史教训：任何分支都必须走到 settle）。
        function _refreshEpicFromRemote(force, showLoading) {
            if (typeof GM_xmlhttpRequest !== 'function') {
                if (showLoading) _epicFailLoading('noXhr');
                return;
            }
            // v1.9.27: force 时重置可能卡死的 loading 标志
            if (epicState.loading) {
                if (!force) return;
                epicState.loading = false;
            }
            if (showLoading) { epicState.loading = true; epicState.loadError = null; renderEpicGamesList(); }

            // 兼容两种 JSON 格式：数组 appid 列表 / 对象 { _meta?, updatedAt?, appids: number[], games?: [...] }
            function _extractEpicAppids(data) {
                if (Array.isArray(data)) return data;
                if (data && typeof data === 'object') {
                    if (Array.isArray(data.appids)) return data.appids;
                    if (Array.isArray(data.games)) return data.games.map(g => (g && g.appid)).filter(Boolean);
                }
                return null;
            }

            // 成功响应公共逻辑：提取 appid → mergeEpicIds 增量合并（只增不减）→ 写缓存 → 渲染
            function _processEpicJson(data) {
                const incoming = mergeEpicIds(_extractEpicAppids(data));
                if (incoming.length === 0) return false;
                let gmIds = [];
                try { gmIds = GM_getValue(EPIC_GM_KEY, []) || []; } catch (e) { /* 忽略失败，不影响主流程 */ }
                // v1.9.18: 并入当前缓存历史（只增不减），远程数据变小也不丢本地历史 appid
                const merged = mergeEpicIds(incoming, epicState.appids, gmIds, EPIC_MANUAL_IDS);
                epicState.appids = merged;
                epicState.updatedAt = (data && typeof data === 'object' && data.updatedAt) ? String(data.updatedAt).slice(0, 10) : new Date().toISOString().slice(0, 10);
                epicState.source = 'github';
                epicState.loaded = true;
                epicState.loading = false;
                epicState.loadError = null;
                _epicLastBgRefreshAt = Date.now(); // v1.9.5: 记录后台刷新时间戳
                try { GM_setValue(EPIC_GM_KEY, incoming); } catch (e) { /* 忽略失败，不影响主流程 */ }
                // v1.9.5: 写入永久缓存（永不过期）+ TTL 缓存（兼容）
                _permCacheSet('epicFreeGames', { appids: merged, updatedAt: epicState.updatedAt, source: 'github' });
                try { Host.cacheSet('epicFreeGames', { appids: merged, updatedAt: epicState.updatedAt, source: 'github' }, Host.cacheTTL.epic); } catch (e) { /* 忽略失败 */ }
                renderEpicSections();
                return true;
            }

            // 依次尝试 EPIC_GITHUB_URLS，任一成功即停止；全部失败 → 视为刷新失败（保留本地缓存数据）
            function _tryNextGithubSource(idx) {
                if (idx >= EPIC_GITHUB_URLS.length) {
                    // v1.9.19: keylol 兜底已移除（帖子需登录阅读权限）——force 刷新提示失败并用本地数据，后台刷新静默
                    if (showLoading) _epicFailLoading('network');
                    return;
                }
                GM_xmlhttpRequest({
                    method: 'GET',
                    url: EPIC_GITHUB_URLS[idx],
                    timeout: 15000,
                    onload(r) {
                        try {
                            if (r.status !== 404 && _safeRespText(r)) {
                                if (_processEpicJson(JSON.parse(_safeRespText(r)))) return; // 成功，停止
                            }
                        } catch (e) { /* 解析异常，交给下一个源 */ }
                        _tryNextGithubSource(idx + 1); // 失败，尝试下一个源
                    },
                    onerror() { _tryNextGithubSource(idx + 1); },
                    ontimeout() { _tryNextGithubSource(idx + 1); },
                });
            }

            _tryNextGithubSource(0);
        }

        // 手动 JSON 导入（兜底：远程抓取失败时）
        function importEpicJson() {
            const raw = prompt(Host.T.epicImportPrompt, '');
            if (!raw || !raw.trim()) return;
            try {
                const data = JSON.parse(raw);
                let ids = [];
                if (Array.isArray(data)) ids = data;
                else if (Array.isArray(data.appids)) ids = data.appids;
                else if (Array.isArray(data.games)) ids = data.games.map(g => g.appid || g.steamAppId || g.id).filter(Boolean);
                const incoming = mergeEpicIds(ids);
                if (incoming.length === 0) { Host.showToast(Host.T.epicImportNoData); return; }
                let gmIds = [];
                try { gmIds = GM_getValue(EPIC_GM_KEY, []) || []; } catch (e) { /* 忽略失败，不影响主流程 */ }
                const merged = mergeEpicIds(incoming, gmIds, EPIC_MANUAL_IDS);
                try { GM_setValue(EPIC_GM_KEY, incoming); } catch (e) { /* 忽略失败，不影响主流程 */ }
                try { Host.cacheSet('epicFreeGames', { appids: merged, updatedAt: new Date().toISOString().slice(0, 10), source: 'import' }, Host.cacheTTL.epic); } catch (e) { /* 忽略失败，不影响主流程 */ }
                epicState.appids = merged;
                epicState.updatedAt = new Date().toISOString().slice(0, 10);
                epicState.source = 'import';
                epicState.loaded = true;
                epicState.loading = false;
                epicState.loadError = null;
                epicState.page = 1;
                Host.showToast(Host.T.epicImportOk.replace('{n}', merged.length));
                renderEpicSections();
            } catch (e) {
                Host.showToast(Host.T.epicImportFail + e.message);
            }
        }

        // v1.9.18: 一键导出全量 JSON（含缓存历史）——epic_freebies.json 兼容格式，
        // 可经 js_script/epic-freebies-weekly-sync.js --import 回流 GitHub 数据源维护全量名单
        function exportEpicJson() {
            const ids = mergeEpicIds(epicState.appids).sort((a, b) => a - b);
            if (ids.length === 0) {
                Host.showToast(Host.T.epicExportEmpty || (Host.isZh ? '没有可导出的 Epic 赠送数据' : 'No Epic data to export'));
                return;
            }
            const payload = {
                _meta: { source: 'sglv-epic-export', version: 1 },
                updatedAt: new Date().toISOString(),
                appids: ids
            };
            const text = JSON.stringify(payload, null, 2);
            const filename = 'epic_freebies_export_' + new Date().toISOString().slice(0, 10) + '.json';
            try {
                const blob = new Blob([text], { type: 'application/json' });
                const url = URL.createObjectURL(blob);
                const a = document.createElement('a');
                a.href = url;
                a.download = filename;
                document.body.appendChild(a);
                a.click();
                a.remove();
                setTimeout(() => URL.revokeObjectURL(url), 5000);
                Host.showToast((Host.T.epicExportOk || (Host.isZh ? '已导出 {n} 款 Epic 赠送游戏' : 'Exported {n} Epic free games')).replace('{n}', String(ids.length)));
            } catch (e) {
                // 兜底：Blob 下载不可用时弹窗展示 JSON 供手工复制保存
                prompt(Host.T.epicExportFail || (Host.isZh ? '自动下载失败，请手工复制以下 JSON：' : 'Auto download failed. Copy JSON below:'), text);
            }
        }

        // 筛选 + 排序
        function getFilteredEpic() {
            const q = epicState.search.toLowerCase().trim();
            const ownedIds = Host.getActiveOwnedAppIds();
            const isOwned = n => ownedIds.has(n) || ownedIds.has(String(n));
            let list = epicState.appids.map(Number).filter(n => n > 0);
            if (q) {
                list = list.filter(n => {
                    if (String(n).includes(q)) return true;
                    const name = (_epicNameCache.get(n) || '').toLowerCase();
                    return name.includes(q);
                });
            }
            if (epicState.ownFilter === 'owned') list = list.filter(isOwned);
            else if (epicState.ownFilter === 'notOwned') list = list.filter(n => !isOwned(n));
            list.sort((a, b) => {
                switch (epicState.sort) {
                    case 'appidAsc': return a - b;
                    case 'nameAsc': return _nameCollator.compare(_epicNameCache.get(a) || '~', _epicNameCache.get(b) || '~') || (a - b);
                    case 'appidDesc':
                    default: return b - a;
                }
            });
            return list;
        }

        // ----- 渲染 -----
        function renderEpicTab(parent) {
            const wrap = document.createElement('div');
            wrap.className = 'sglv-psplus-wrap';

            // KPI 区域
            const kpi = document.createElement('div');
            kpi.id = 'sglv-epic-kpi';
            wrap.appendChild(kpi);

            // 工具栏：搜索 + 排序 + 视图 + 导入 + 刷新
            const toolbar = document.createElement('div');
            toolbar.className = 'sglv-toolbar';
            const sortOptions = [
                { key: 'appidDesc', label: Host.T.epicSortAppidDesc },
                { key: 'appidAsc', label: Host.T.epicSortAppidAsc },
                { key: 'nameAsc', label: Host.T.epicSortNameAsc },
            ];
            toolbar.innerHTML = `
                <input class="sglv-search" aria-label="搜索" id="sglv-epic-search" placeholder="${Host.T.epicSearch}" value="${Host.wlEscape(epicState.search)}">
                <select class="sglv-sort-select" aria-label="排序方式" id="sglv-epic-sort">
                    ${sortOptions.map(o => `<option value="${o.key}"${epicState.sort === o.key ? ' selected' : ''}>${o.label}</option>`).join('')}
                </select>
                <div class="sglv-view-toggle">
                    <button class="sglv-btn sglv-btn-secondary sglv-btn-icon${epicState.viewMode === 'card' ? ' active' : ''}" id="sglv-epic-card" title="${Host.T.cardView}">${Host.ICONS.grid}</button>
                    <button class="sglv-btn sglv-btn-secondary sglv-btn-icon${epicState.viewMode === 'cover' ? ' active' : ''}" id="sglv-epic-cover" title="${Host.T.coverView}">${Host.ICONS.cover}</button>
                    <button class="sglv-btn sglv-btn-secondary sglv-btn-icon${epicState.viewMode === 'list' ? ' active' : ''}" id="sglv-epic-list" title="${Host.T.listView}">${Host.ICONS.list}</button>
                </div>
                <button class="sglv-btn sglv-btn-secondary sglv-btn-icon" id="sglv-epic-import" title="${Host.T.epicImportTip}">${Host.ICONS.tag}</button>
                <button class="sglv-btn sglv-btn-secondary sglv-btn-icon" id="sglv-epic-export" title="${Host.T.epicExportTip || (Host.isZh ? '一键导出 Epic 赠送数据 JSON（含本地缓存历史全量）' : 'Export Epic free games JSON (incl. local history)')}">${Host.ICONS.download || '<svg viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"/><polyline points="7 10 12 15 17 10"/><line x1="12" y1="15" x2="12" y2="3"/></svg>'}</button>
                <button class="sglv-btn sglv-btn-secondary sglv-btn-icon" id="sglv-epic-refresh" title="${Host.T.epicRefreshTip}">${Host.ICONS.refresh}</button>
                <div class="sglv-pagination" id="sglv-epic-pagination"></div>
            `;
            wrap.appendChild(toolbar);

            // 游戏列表容器
            const content = document.createElement('div');
            content.className = 'sglv-content';
            content.id = 'sglv-epic-content';
            wrap.appendChild(content);

            parent.appendChild(wrap);

            // 事件绑定
            toolbar.querySelector('#sglv-epic-search').addEventListener('input', _debounce((e) => {
                epicState.search = e.target.value;
                epicState.page = 1;
                renderEpicGamesList();
            }, 200));
            toolbar.querySelector('#sglv-epic-sort').addEventListener('change', (e) => {
                epicState.sort = e.target.value;
                epicState.page = 1;
                renderEpicGamesList();
            });
            const setEpicViewMode = (mode) => {
                epicState.viewMode = mode;
                ['card', 'cover', 'list'].forEach(m => {
                    toolbar.querySelector('#sglv-epic-' + m)?.classList.toggle('active', m === mode);
                });
                renderEpicGamesList();
            };
            toolbar.querySelector('#sglv-epic-card').addEventListener('click', () => setEpicViewMode('card'));
            toolbar.querySelector('#sglv-epic-cover').addEventListener('click', () => setEpicViewMode('cover'));
            toolbar.querySelector('#sglv-epic-list').addEventListener('click', () => setEpicViewMode('list'));
            toolbar.querySelector('#sglv-epic-import').addEventListener('click', () => importEpicJson());
            toolbar.querySelector('#sglv-epic-export').addEventListener('click', () => exportEpicJson());
            toolbar.querySelector('#sglv-epic-refresh').addEventListener('click', () => loadEpicGames(true));
            // v1.5.0: 筛选改为点击 KPI 卡片切换（再次点击同一卡片回到「全部」），与年度大作标签页一致
            kpi.addEventListener('click', e => {
                const card = e.target.closest('[data-epic-filter]');
                if (!card) return;
                const f = card.dataset.epicFilter;
                epicState.ownFilter = epicState.ownFilter === f ? 'all' : f;
                epicState.page = 1;
                renderEpicKpi();      // 刷新 KPI active 高亮
                renderEpicGamesList();
            });

            if (!epicState.loaded && !epicState.loading) {
                loadEpicGames();
            } else {
                renderEpicSections();
            }
        }

        function renderEpicSections() {
            if (_collectionActiveTab !== 'epic' || !document.getElementById('sglv-epic-content')) return;
            renderEpicKpi();
            renderEpicGamesList();
        }

        function renderEpicKpi() {
            const el = document.getElementById('sglv-epic-kpi');
            if (!el) return;
            if (!epicState.loaded) { el.innerHTML = ''; return; }
            const total = epicState.appids.length;
            const ownedIds = Host.getActiveOwnedAppIds();
            const isOwned = n => ownedIds.has(n) || ownedIds.has(String(n));
            const owned = epicState.appids.filter(n => isOwned(Number(n))).length;
            const notOwned = total - owned;
            const srcLabel = epicSourceLabel(epicState.source);
            const updatedStr = epicState.updatedAt
                ? (Host.isZh ? '更新于 ' : 'Updated ') + epicState.updatedAt + ' · ' + srcLabel
                : (Host.isZh ? '来源：' : 'Source: ') + srcLabel;
            el.innerHTML = `
                <div class="sglv-trend-kpi-row">
                    <div class="sglv-trend-kpi-card blue clickable${epicState.ownFilter === 'all' ? ' active' : ''}" data-epic-filter="all" title="${Host.isZh ? '点击筛选：全部' : 'Click to filter: All'}">
                        <div class="sglv-trend-kpi-header"><span class="sglv-trend-kpi-icon">${Host.ICONS.epic}</span><span class="sglv-trend-kpi-label">${Host.T.epicKpiTotal}</span></div>
                        <div class="sglv-trend-kpi-value">${total.toLocaleString()}</div>
                        <div class="sglv-trend-kpi-sub">${updatedStr}</div>
                    </div>
                    <div class="sglv-trend-kpi-card mine clickable${epicState.ownFilter === 'owned' ? ' active' : ''}" data-epic-filter="owned" title="${Host.isZh ? '点击筛选：steam在库' : 'Click to filter: In Library'}">
                        <div class="sglv-trend-kpi-header"><span class="sglv-trend-kpi-icon">${Host.ICONS.heart}</span><span class="sglv-trend-kpi-label">${Host.T.epicKpiOwned}</span></div>
                        <div class="sglv-trend-kpi-value">${owned.toLocaleString()}</div>
                        <div class="sglv-trend-kpi-sub">${Host.T.epicKpiOwnedSub}</div>
                    </div>
                    <div class="sglv-trend-kpi-card clickable${epicState.ownFilter === 'notOwned' ? ' active' : ''}" style="border-left:3px solid #ff9800" data-epic-filter="notOwned" title="${Host.isZh ? '点击筛选：未拥有' : 'Click to filter: Not Owned'}">
                        <div class="sglv-trend-kpi-header"><span class="sglv-trend-kpi-icon" style="color:#ff9800">${Host.ICONS.tag}</span><span class="sglv-trend-kpi-label">${Host.T.epicKpiNotOwned}</span></div>
                        <div class="sglv-trend-kpi-value">${notOwned.toLocaleString()}</div>
                        <div class="sglv-trend-kpi-sub">${Host.isZh ? '可在 Epic 领取' : 'Claimable on Epic'}</div>
                    </div>
                </div>
            `;
        }

        function renderEpicGamesList() {
            const content = document.getElementById('sglv-epic-content');
            if (!content) return;
            const clearPagination = () => { const p = document.getElementById('sglv-epic-pagination'); if (p) p.innerHTML = ''; };

            if (epicState.loading) {
                content.innerHTML = '<div class="sglv-progress" style="margin:16px 0"><div class="sglv-progress-fill" style="width:45%"></div></div><div class="sglv-empty">' + Host.T.epicLoading + '</div>';
                clearPagination();
                return;
            }
            if (epicState.loadError) {
                content.innerHTML = '<div class="sglv-empty">' + Host.T.epicLoadError + '</div>';
                clearPagination();
                return;
            }
            if (!epicState.loaded || epicState.appids.length === 0) {
                content.innerHTML = '<div class="sglv-empty">' + Host.T.epicNoData + '</div>';
                clearPagination();
                return;
            }

            const list = getFilteredEpic();
            if (list.length === 0) {
                content.innerHTML = '<div class="sglv-empty">' + (Host.isZh ? '无匹配结果' : 'No matching results') + '</div>';
                clearPagination();
                return;
            }

            const { pageItems, totalPages, page: _clampedPage } = Host.paginate(list, epicState.page, epicState.pageSize);
            epicState.page = _clampedPage;

            const ownedIds = Host.getActiveOwnedAppIds();
            const isOwned = n => ownedIds.has(n) || ownedIds.has(String(n));
            const freeBadge = epicFreeBadgeHtml();

            // 卡片视图
            if (epicState.viewMode === 'card') {
                content.innerHTML = '<div class="sglv-card-grid">' + pageItems.map(appid => {
                    const name = epicDisplayName(appid);
                    const clickUrl = 'https://store.steampowered.com/app/' + appid;
                    const nameSpan = '<span data-sglv-epic-appid="' + appid + '">' + Host.wlEscape(name) + '</span><span class="sglv-card-id-inline">' + appid + '</span>';
                    return '<div class="sglv-game-card" data-appid="' + appid + '" onclick="window.open(\'' + clickUrl + '\',\'_blank\')">' +
                        '<div class="sglv-card-img-wrap">' + freeBadge + epicPosterImg(appid, name) + '</div>' +
                        '<div class="sglv-card-body">' +
                            '<div class="sglv-card-name" title="' + Host.wlEscape(name) + '">' + nameSpan + '</div>' +
                            '<div class="sglv-info-row sglv-wl-price-row">' + epicOwnedBadgeHtml(isOwned(appid)) + '</div>' +
                        '</div>' +
                    '</div>';
                }).join('') + '</div>';
            } else if (epicState.viewMode === 'cover') {
                // 封面视图（横板大图）
                // v2.9.22: 标签统一规则——封面上不放任何徽章（freeBadge 在右下角，owned badge 在标题下方）
                content.innerHTML = '<div class="sglv-wl-cover-grid">' + pageItems.map(appid => {
                    const name = epicDisplayName(appid);
                    const clickUrl = 'https://store.steampowered.com/app/' + appid;
                    const nameSpan = '<span data-sglv-epic-appid="' + appid + '">' + Host.wlEscape(name) + '</span><span class="sglv-card-id-inline">' + appid + '</span>';
                    return '<div class="sglv-wl-cover-card" data-appid="' + appid + '" onclick="window.open(\'' + clickUrl + '\',\'_blank\')">' +
                        '<div class="sglv-wl-cover-img-wrap">' + freeBadge + epicCapsuleImg(appid, name) + '</div>' +
                        '<div class="sglv-wl-cover-body">' +
                            '<div class="sglv-card-name" title="' + Host.wlEscape(name) + '">' + nameSpan + '</div>' +
                            '<div class="sglv-info-row sglv-wl-price-row sglv-epic-owned-row">' + epicOwnedBadgeHtml(isOwned(appid)) + '</div>' +
                        '</div>' +
                    '</div>';
                }).join('') + '</div>';
            } else {
                // 列表视图
                content.innerHTML = '<div class="sglv-list-view">' + pageItems.map(appid => {
                    const name = epicDisplayName(appid);
                    const clickUrl = 'https://store.steampowered.com/app/' + appid;
                    const iconHtml = '<img class="sglv-list-icon" src="' + Host.getGameIconUrl(appid, '') + '" alt="' + Host.wlEscape(name) + '" loading="lazy" decoding="async" onerror="this.style.display=\'none\'">';
                    const nameSpan = '<span data-sglv-epic-appid="' + appid + '">' + Host.wlEscape(name) + '</span><span class="sglv-card-id-inline">' + appid + '</span>';
                    return '<div class="sglv-list-item" data-appid="' + appid + '" onclick="window.open(\'' + clickUrl + '\',\'_blank\')">' +
                        iconHtml +
                        '<div class="sglv-list-info">' +
                            '<div class="sglv-list-name">' + nameSpan + '</div>' +
                            '<div class="sglv-list-meta">' + freeBadge + epicOwnedBadgeHtml(isOwned(appid)) + '</div>' +
                        '</div>' +
                    '</div>';
                }).join('') + '</div>';
            }

            // 分页
            // v1.9.47-fix: 补 onJump——Epic 翻页 5 个按钮全部走 onJump(参见主脚本 renderPagination)
            const pagination = document.getElementById('sglv-epic-pagination');
            if (pagination) {
                Host.renderPagination(pagination, 'sglv-epic', epicState.page, totalPages, list.length,
                    () => { epicState.page--; renderEpicGamesList(); },
                    () => { epicState.page++; renderEpicGamesList(); },
                    (p) => { epicState.page = p; renderEpicGamesList(); });
            }

            // 异步加载中文名 + 写入本地缓存供搜索/排序
            content.querySelectorAll('[data-sglv-epic-appid]').forEach(el => {
                const appid = el.getAttribute('data-sglv-epic-appid');
                const original = el.textContent;
                epicLoadName(appid).then(name => {
                    if (name && name !== original) {
                        el.textContent = name;
                        el.title = name + ' (' + original + ')';
                        // v2.7.9: 清除占位符内联样式，允许 CSS class 生效（项目约定）
                        el.style.color = '';
                        el.style.fontStyle = '';
                        el.style.fontWeight = '';
                    }
                });
            });
        }

        // ==================== 锁区游戏标签页 (v2.9.12) ====================
        // 数据源: GitHub 静态源优先（fastly.jsdelivr.net/gh/SmallRob/steam-namespace steam_blocked_apps.json）
        //         → steam-tracker.com API (Banned + Purchase disabled) → HTML (Regional variant) + 手动导入
        // 宿主桥接: Host.loadBlockedApps(force), Host.getBlockedApps(), Host.isBlockedLoaded(),
        //           Host.parseManualBlockedJson(text), Host.getBlockedSource()

        const blockedState = {
            apps: [], loaded: false, loading: false,
            search: '', ownFilter: 'all', catFilter: 'all', sort: 'appidDesc',
            page: 1, pageSize: 48, viewMode: 'card',
            source: '', loadError: null,
            fetchedAt: '',  // v2.9.90: 远程数据集更新时间
            pendingForce: false,  // v2.9.90: loading中时排队的force刷新请求
            // v2.9.91: 好评500分类单独加载（独立于主锁区数据，确保 categoryId=500 条目始终可用）
            topRatedApps: [], topRatedLoaded: false, topRatedLoading: false,
            topRatedFetchedAt: '',
            refreshStage: '',  // v2.9.91: 刷新进度文本
        };

        function blockedCatBadgeHtml(catId) {
            if (catId === 20) return '<span class="sglv-badge" style="background:rgba(239,68,68,0.15);color:#f87171;border:1px solid rgba(239,68,68,0.25)">' + Host.T.blockedBadgeBanned + '</span>';
            if (catId === 3) return '<span class="sglv-badge" style="background:rgba(245,158,11,0.15);color:#fbbf24;border:1px solid rgba(245,158,11,0.25)">' + Host.T.blockedBadgePurchase + '</span>';
            if (catId === 10) return '<span class="sglv-badge" style="background:rgba(59,130,246,0.15);color:#60a5fa;border:1px solid rgba(59,130,246,0.25)">' + Host.T.blockedBadgeRegional + '</span>';
            if (catId === 0) return '<span class="sglv-badge" style="background:var(--sglv-accent-bg, rgba(168,85,247,0.15));color:var(--sglv-accent-light, #c084fc);border:1px solid var(--sglv-accent-border, rgba(168,85,247,0.25))">' + Host.T.blockedBadgeManual + '</span>';
            // v1.9.15: 好评500 分类（人工整理锁区游戏，categoryId=500）
            if (catId === 500) return '<span class="sglv-badge" style="background:rgba(16,185,129,0.15);color:#34d399;border:1px solid rgba(16,185,129,0.25)">' + (Host.isZh ? '好评500' : 'Positive 500+') + '</span>';
            return '';
        }

        function blockedOwnedBadgeHtml(owned) {
            if (owned) return '<span class="sglv-badge" style="background:rgba(75,181,79,0.15);color:#4bb54f;border:1px solid rgba(75,181,79,0.25)">' + Host.T.blockedBadgeOwned + '</span>';
            return '';
        }

        // v2.9.91: 好评500分类数据远程URL（与主脚本 BLOCKED_STATIC_URL 同源，独立加载确保 categoryId=500 条目可用）
        const BLOCKED_TOP_RATED_URL = 'https://fastly.jsdelivr.net/gh/SmallRob/steam-namespace@main/data/steam_blocked_apps.json';
        const BLOCKED_TOP_RATED_FALLBACK_URL = 'https://raw.githubusercontent.com/SmallRob/steam-namespace/refs/heads/main/data/steam_blocked_apps.json';

        /**
         * v2.9.91: 单独加载好评500分类数据
         * 直接从远程 JSON 筛选 categoryId=500 条目，独立于主锁区数据缓存
         * @param {boolean} force - 强制刷新（忽略永久缓存）
         * @returns {Promise<Array>} 好评500条目数组
         */
        function _fetchTopRatedFromRemote() {
            return new Promise((resolve, reject) => {
                if (typeof GM_xmlhttpRequest !== 'function') { reject(new Error('GM_xmlhttpRequest unavailable')); return; }
                const tryFetch = (url, isFallback) => {
                    GM_xmlhttpRequest({
                        method: 'GET',
                        url,
                        headers: { 'Accept': 'application/json' },
                        timeout: 15000,
                        onload(r) {
                            if (r.status < 200 || r.status >= 300) {
                                if (!isFallback) { tryFetch(BLOCKED_TOP_RATED_FALLBACK_URL, true); return; }
                                reject(new Error(`HTTP ${r.status}`)); return;
                            }
                            try {
                                const data = JSON.parse(_safeRespText(r));
                                const apps = Array.isArray(data) ? data : (Array.isArray(data.data) ? data.data : []);
                                const topRated = apps
                                    .filter(a => a.categoryId === 500 || a.category_id === 500)
                                    .map(a => ({
                                        appid: Number(a.appid) || 0,
                                        name: (a.name || '').trim(),
                                        category: a.category || '好评500',
                                        categoryId: 500,
                                        type: a.type || 'game',
                                        source: 'static',
                                        changedAt: a.changedAt || a.changed_at || '',
                                        positiveRating: a.positiveRating || 0,
                                        reviews: a.reviews || 0,
                                        cheapestRegion: a.cheapestRegion || '',
                                    }));
                                const fetchedAt = (!Array.isArray(data) && data.fetchedAt) ? data.fetchedAt : '';
                                resolve({ apps: topRated, fetchedAt });
                            } catch (e) {
                                if (!isFallback) { tryFetch(BLOCKED_TOP_RATED_FALLBACK_URL, true); return; }
                                reject(new Error('JSON parse fail'));
                            }
                        },
                        onerror: () => {
                            if (!isFallback) { tryFetch(BLOCKED_TOP_RATED_FALLBACK_URL, true); return; }
                            reject(new Error('Network error'));
                        },
                        ontimeout: () => {
                            if (!isFallback) { tryFetch(BLOCKED_TOP_RATED_FALLBACK_URL, true); return; }
                            reject(new Error('Timeout'));
                        },
                    });
                };
                tryFetch(BLOCKED_TOP_RATED_URL, false);
            });
        }

        /**
         * v2.9.91: 加载好评500分类数据（含永久缓存 + 后台静默刷新）
         * @param {boolean} force - 强制刷新
         */
        function loadTopRatedApps(force) {
            if (blockedState.topRatedLoading) return Promise.resolve();
            // 非强制时优先从永久缓存秒开
            if (!force) {
                const permCached = _permCacheGet('blockedTopRated');
                if (permCached && Array.isArray(permCached.apps) && permCached.apps.length > 0) {
                    blockedState.topRatedApps = permCached.apps;
                    blockedState.topRatedFetchedAt = permCached.fetchedAt || '';
                    blockedState.topRatedLoaded = true;
                    // 后台静默刷新
                    _fetchTopRatedFromRemote().then(result => {
                        if (result.fetchedAt && result.fetchedAt !== blockedState.topRatedFetchedAt) {
                            blockedState.topRatedApps = result.apps;
                            blockedState.topRatedFetchedAt = result.fetchedAt;
                            _permCacheSet('blockedTopRated', { apps: result.apps, fetchedAt: result.fetchedAt });
                            if (_collectionActiveTab === 'blocked') renderBlockedSections();
                        }
                    }).catch(() => {});
                    return Promise.resolve();
                }
            }
            blockedState.topRatedLoading = true;
            return _fetchTopRatedFromRemote().then(result => {
                blockedState.topRatedApps = result.apps || [];
                blockedState.topRatedFetchedAt = result.fetchedAt || '';
                blockedState.topRatedLoaded = true;
                blockedState.topRatedLoading = false;
                _permCacheSet('blockedTopRated', { apps: blockedState.topRatedApps, fetchedAt: blockedState.topRatedFetchedAt });
            }).catch(() => {
                blockedState.topRatedLoading = false;
            });
        }

        /**
         * v2.9.91: 将好评500条目合并到主锁区列表（按 appid 去重，已有条目不覆盖）
         * @returns {Array} 合并后的完整锁区列表
         */
        function getMergedBlockedApps() {
            if (!blockedState.topRatedApps || blockedState.topRatedApps.length === 0) {
                return blockedState.apps;
            }
            const existing = new Set(blockedState.apps.map(a => a.appid));
            const additions = blockedState.topRatedApps.filter(a => !existing.has(a.appid));
            return blockedState.apps.concat(additions);
        }

        function loadBlockedGames(force) {
            // v2.9.90: loading中时，force请求排队（pendingForce），避免静默丢弃用户刷新操作
            // v1.9.27: force 时直接重置可能卡死的 loading 标志（浏览器扩展阻断回调时 loading 可能永久卡 true）
            if (blockedState.loading) {
                if (force) {
                    blockedState.loading = false;
                    blockedState.pendingForce = false;
                } else {
                    return;
                }
            }
            blockedState.loading = true;
            blockedState.loadError = null;
            blockedState.refreshStage = Host.isZh ? '正在加载锁区数据…' : 'Loading blocked data…';
            // v2.9.90: 刷新按钮 spinner 反馈
            const refreshBtn = document.getElementById('sglv-blocked-refresh');
            if (refreshBtn) refreshBtn.classList.add('sglv-spin');
            renderBlockedSections();
            renderBlockedToolbarStatus();
            if (typeof Host.loadBlockedApps !== 'function') {
                blockedState.loading = false;
                blockedState.loadError = 'Host loadBlockedApps unavailable';
                blockedState.refreshStage = '';
                if (refreshBtn) refreshBtn.classList.remove('sglv-spin');
                renderBlockedSections();
                renderBlockedToolbarStatus();
                return;
            }
            // v2.9.91: 同时加载好评500分类数据（force 时同步强制刷新）
            loadTopRatedApps(force);
            Host.loadBlockedApps(force, (stage, text) => {
                // v2.9.91: 进度回调更新工具栏状态
                blockedState.refreshStage = text || '';
                renderBlockedToolbarStatus();
            }).then(result => {
                blockedState.apps = result.apps || [];
                blockedState.source = result.source || 'api';
                // v2.9.90: 存储 fetchedAt 用于显示数据更新时间
                blockedState.fetchedAt = result.fetchedAt || '';
                blockedState.loaded = true;
                blockedState.loading = false;
                blockedState.page = 1;
                blockedState.refreshStage = '';
                // v1.9.5: 写入永久缓存（永不过期）+ v2.9.90: 含 fetchedAt
                _permCacheSet('blockedApps', { apps: blockedState.apps, source: blockedState.source, fetchedAt: blockedState.fetchedAt });
                if (refreshBtn) refreshBtn.classList.remove('sglv-spin');
                renderBlockedSections();
                renderBlockedToolbarStatus();
                // v2.9.90: 若有排队的 force 请求，立即执行
                if (blockedState.pendingForce) {
                    blockedState.pendingForce = false;
                    loadBlockedGames(true);
                }
            }).catch(e => {
                blockedState.loading = false;
                blockedState.loadError = e.message || 'Load failed';
                blockedState.refreshStage = '';
                if (refreshBtn) refreshBtn.classList.remove('sglv-spin');
                renderBlockedSections();
                renderBlockedToolbarStatus();
                // v2.9.90: 若有排队的 force 请求，立即执行
                if (blockedState.pendingForce) {
                    blockedState.pendingForce = false;
                    loadBlockedGames(true);
                }
            });
        }

        function importBlockedJson() {
            const text = prompt(Host.T.blockedImportPrompt);
            if (!text || !text.trim()) return;
            try {
                const apps = Host.parseManualBlockedJson(text);
                if (!apps.length) { Host.showToast(Host.T.blockedImportNoData); return; }
                // 合并到现有数据（手动导入的不覆盖已有条目）
                const existing = new Map(blockedState.apps.map(a => [a.appid, a]));
                apps.forEach(a => { if (!existing.has(a.appid)) existing.set(a.appid, a); });
                blockedState.apps = Array.from(existing.values());
                blockedState.loaded = true;
                blockedState.source = 'import';
                blockedState.page = 1;
                // v1.9.5: 写入永久缓存（永不过期）+ TTL 缓存（兼容主脚本加载路径）
                // v2.9.90: 含 fetchedAt（手动导入无远程时间戳，置空）
                _permCacheSet('blockedApps', { apps: blockedState.apps, source: 'import', fetchedAt: '' });
                try { Host.cacheSet('blockedApps', { apps: blockedState.apps, source: 'import', fetchedAt: '' }, Host.cacheTTL.blockedApps); } catch (e) { /* 忽略失败 */ }
                Host.showToast(Host.T.blockedImportOk.replace('{n}', apps.length));
                renderBlockedSections();
            } catch (e) {
                Host.showToast(Host.T.blockedImportFail + e.message);
            }
        }

        function getFilteredBlocked() {
            const q = blockedState.search.toLowerCase().trim();
            const ownedIds = Host.getActiveOwnedAppIds();
            const isOwned = n => ownedIds.has(n) || ownedIds.has(String(n));
            // v2.9.91: 使用合并后的锁区列表（含好评500单独加载的条目）
            let list = getMergedBlockedApps().filter(a => a.appid > 0);
            if (q) {
                list = list.filter(a => {
                    if (String(a.appid).includes(q)) return true;
                    return (a.name || '').toLowerCase().includes(q);
                });
            }
            if (blockedState.ownFilter === 'owned') list = list.filter(a => isOwned(a.appid));
            else if (blockedState.ownFilter === 'notOwned') list = list.filter(a => !isOwned(a.appid));
            if (blockedState.catFilter !== 'all') {
                const catMap = { banned: 20, purchase: 3, regional: 10, manual: 0, topRated: 500 };
                const targetId = catMap[blockedState.catFilter];
                list = list.filter(a => a.categoryId === targetId);
            }
            // v1.9.5: 使用缓存的 _nameCollator，避免每次渲染重新构造
            list.sort((a, b) => {
                let r = 0;
                switch (blockedState.sort) {
                    case 'appidAsc': r = a.appid - b.appid; break;
                    case 'nameAsc': r = _nameCollator.compare(a.name || '~', b.name || '~') || (a.appid - b.appid); break;
                    case 'dateDesc': r = (b.changedAt || '').localeCompare(a.changedAt || ''); break;
                    case 'dateAsc': r = (a.changedAt || '').localeCompare(b.changedAt || ''); break;
                    case 'appidDesc':
                    default: r = b.appid - a.appid;
                }
                return r || (a.appid - b.appid);
            });
            return list;
        }

        function renderBlockedTab(parent) {
            const wrap = document.createElement('div');
            wrap.className = 'sglv-psplus-wrap';

            const kpi = document.createElement('div');
            kpi.id = 'sglv-blocked-kpi';
            wrap.appendChild(kpi);

            const toolbar = document.createElement('div');
            toolbar.className = 'sglv-toolbar';
            const sortOptions = [
                { key: 'appidDesc', label: Host.T.blockedSortAppidDesc },
                { key: 'appidAsc', label: Host.T.blockedSortAppidAsc },
                { key: 'nameAsc', label: Host.T.blockedSortNameAsc },
                { key: 'dateDesc', label: Host.T.blockedSortDateDesc },
                { key: 'dateAsc', label: Host.T.blockedSortDateAsc },
            ];
            toolbar.innerHTML = `
                <input class="sglv-search" aria-label="搜索" id="sglv-blocked-search" placeholder="${Host.T.blockedSearch}" value="${Host.wlEscape(blockedState.search)}">
                <select class="sglv-sort-select" aria-label="排序方式" id="sglv-blocked-sort">
                    ${sortOptions.map(o => `<option value="${o.key}"${blockedState.sort === o.key ? ' selected' : ''}>${o.label}</option>`).join('')}
                </select>
                <div class="sglv-view-toggle">
                    <button class="sglv-btn sglv-btn-secondary sglv-btn-icon${blockedState.viewMode === 'card' ? ' active' : ''}" id="sglv-blocked-card" title="${Host.T.cardView}">${Host.ICONS.grid}</button>
                    <button class="sglv-btn sglv-btn-secondary sglv-btn-icon${blockedState.viewMode === 'cover' ? ' active' : ''}" id="sglv-blocked-cover" title="${Host.T.coverView}">${Host.ICONS.cover}</button>
                    <button class="sglv-btn sglv-btn-secondary sglv-btn-icon${blockedState.viewMode === 'list' ? ' active' : ''}" id="sglv-blocked-list" title="${Host.T.listView}">${Host.ICONS.list}</button>
                </div>
                <button class="sglv-btn sglv-btn-secondary sglv-btn-icon" id="sglv-blocked-import" title="${Host.T.blockedImportTip}">${Host.ICONS.tag}</button>
                <button class="sglv-btn sglv-btn-secondary sglv-btn-icon" id="sglv-blocked-refresh" title="${Host.T.blockedRefreshTip}">${Host.ICONS.refresh}</button>
                <span class="sglv-blocked-status" id="sglv-blocked-status"></span>
            `;
            wrap.appendChild(toolbar);

            const filterBar = document.createElement('div');
            filterBar.className = 'sglv-filter-bar';
            const ownBtns = [
                { key: 'all', label: Host.T.blockedFilterAll },
                { key: 'owned', label: Host.T.blockedFilterOwned },
                { key: 'notOwned', label: Host.T.blockedFilterNotOwned },
            ];
            const catBtns = [
                { key: 'all', label: Host.T.blockedFilterAll },
                { key: 'banned', label: Host.T.blockedBadgeBanned },
                { key: 'purchase', label: Host.T.blockedBadgePurchase },
                { key: 'regional', label: Host.T.blockedBadgeRegional },
                { key: 'manual', label: Host.T.blockedBadgeManual },
                { key: 'topRated', label: Host.isZh ? '好评500' : 'Positive 500+' },
            ];
            filterBar.innerHTML = `
                <div class="sglv-filter-bar-group">
                    ${ownBtns.map(b => `<button class="sglv-btn sglv-btn-secondary sglv-blocked-own-btn${blockedState.ownFilter === b.key ? ' active' : ''}" data-own="${b.key}">${b.label}</button>`).join('')}
                </div>
                <div class="sglv-filter-bar-group">
                    ${catBtns.map(b => `<button class="sglv-btn sglv-btn-secondary sglv-blocked-cat-btn${blockedState.catFilter === b.key ? ' active' : ''}" data-cat="${b.key}">${b.label}</button>`).join('')}
                </div>
                <div class="sglv-pagination sglv-pagination-inline" id="sglv-blocked-pagination"></div>
            `;
            wrap.appendChild(filterBar);

            const content = document.createElement('div');
            content.className = 'sglv-content';
            content.id = 'sglv-blocked-content';
            wrap.appendChild(content);

            parent.appendChild(wrap);

            toolbar.querySelector('#sglv-blocked-search').addEventListener('input', _debounce((e) => {
                blockedState.search = e.target.value; blockedState.page = 1; renderBlockedGamesList();
            }, 200));
            toolbar.querySelector('#sglv-blocked-sort').addEventListener('change', (e) => {
                blockedState.sort = e.target.value; blockedState.page = 1; renderBlockedGamesList();
            });
            const setBlockedViewMode = (mode) => {
                blockedState.viewMode = mode;
                ['card', 'cover', 'list'].forEach(m => { toolbar.querySelector('#sglv-blocked-' + m)?.classList.toggle('active', m === mode); });
                renderBlockedGamesList();
            };
            toolbar.querySelector('#sglv-blocked-card').addEventListener('click', () => setBlockedViewMode('card'));
            toolbar.querySelector('#sglv-blocked-cover').addEventListener('click', () => setBlockedViewMode('cover'));
            toolbar.querySelector('#sglv-blocked-list').addEventListener('click', () => setBlockedViewMode('list'));
            toolbar.querySelector('#sglv-blocked-import').addEventListener('click', () => importBlockedJson());
            toolbar.querySelector('#sglv-blocked-refresh').addEventListener('click', () => loadBlockedGames(true));
            filterBar.querySelectorAll('.sglv-blocked-own-btn').forEach(btn => {
                btn.addEventListener('click', () => {
                    blockedState.ownFilter = btn.dataset.own; blockedState.page = 1;
                    filterBar.querySelectorAll('.sglv-blocked-own-btn').forEach(b => b.classList.remove('active'));
                    btn.classList.add('active');
                    renderBlockedKpi();      // v1.6.0: 同步 KPI active 高亮
                    renderBlockedGamesList();
                });
            });
            filterBar.querySelectorAll('.sglv-blocked-cat-btn').forEach(btn => {
                btn.addEventListener('click', () => {
                    blockedState.catFilter = btn.dataset.cat; blockedState.page = 1;
                    filterBar.querySelectorAll('.sglv-blocked-cat-btn').forEach(b => b.classList.remove('active'));
                    btn.classList.add('active');
                    renderBlockedGamesList();
                });
            });

            // v1.6.0: 筛选改为点击 KPI 卡片切换（再次点击同一卡片回到「全部」），与年度大作/Epic赠送标签页一致
            kpi.addEventListener('click', e => {
                const card = e.target.closest('[data-blocked-filter]');
                if (!card) return;
                const f = card.dataset.blockedFilter;
                blockedState.ownFilter = blockedState.ownFilter === f ? 'all' : f;
                blockedState.page = 1;
                syncBlockedFilterBtns(filterBar);   // 同步筛选栏按钮 active 状态
                renderBlockedKpi();                  // 刷新 KPI active 高亮
                renderBlockedGamesList();
            });

            if (!blockedState.loaded && !blockedState.loading) {
                // 优先从宿主缓存读取
                if (Host.isBlockedLoaded && Host.isBlockedLoaded() && Host.getBlockedApps) {
                    blockedState.apps = Host.getBlockedApps();
                    blockedState.source = Host.getBlockedSource ? Host.getBlockedSource() : 'api';
                    // v2.9.90: 读取宿主的 fetchedAt
                    if (Host.getBlockedFetchedAt) blockedState.fetchedAt = Host.getBlockedFetchedAt();
                    blockedState.loaded = true;
                    renderBlockedSections();
                } else {
                    // v1.9.5: 宿主缓存无数据 → 尝试永久缓存秒开，后台静默刷新
                    const permCached = _permCacheGet('blockedApps');
                    if (permCached && Array.isArray(permCached.apps) && permCached.apps.length > 0) {
                        blockedState.apps = permCached.apps;
                        blockedState.source = permCached.source || 'api';
                        // v2.9.90: 读取 permCache 中的 fetchedAt
                        blockedState.fetchedAt = permCached.fetchedAt || '';
                        blockedState.loaded = true;
                        renderBlockedSections();
                        loadBlockedGames(false); // 后台静默刷新
                    } else {
                        loadBlockedGames(false);
                    }
                }
            } else {
                renderBlockedSections();
            }

            // v2.9.91: 单独加载好评500分类数据（独立于主锁区数据缓存，确保 categoryId=500 条目始终可用）
            if (!blockedState.topRatedLoaded && !blockedState.topRatedLoading) {
                loadTopRatedApps(false).then(() => {
                    if (_collectionActiveTab === 'blocked') renderBlockedSections();
                });
            }
        }

        function renderBlockedSections() {
            if (_collectionActiveTab !== 'blocked' || !document.getElementById('sglv-blocked-content')) return;
            renderBlockedKpi();
            renderBlockedToolbarStatus();
            renderBlockedGamesList();
        }

        // v2.9.91: 渲染工具栏刷新按钮右侧的状态文本（更新时间 / 加载进度）
        function renderBlockedToolbarStatus() {
            const el = document.getElementById('sglv-blocked-status');
            if (!el) return;
            if (blockedState.refreshStage) {
                // 加载中：显示进度文本 + spinner
                el.innerHTML = `<svg style="width:11px;height:11px;animation:sgc-spin 0.8s linear infinite;vertical-align:middle;margin-right:4px" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M21 12a9 9 0 1 1-6.219-8.56"/></svg>${Host.wlEscape(blockedState.refreshStage)}`;
                el.className = 'sglv-blocked-status loading';
            } else if (blockedState.fetchedAt) {
                // 空闲：显示数据更新时间
                const date = blockedState.fetchedAt.slice(0, 10);
                el.textContent = (Host.isZh ? '更新: ' : 'Updated: ') + date;
                el.className = 'sglv-blocked-status';
            } else {
                el.textContent = '';
                el.className = 'sglv-blocked-status';
            }
        }

        // v1.6.0: KPI 点击后同步筛选栏 ownFilter 按钮 active 状态
        function syncBlockedFilterBtns(filterBar) {
            filterBar.querySelectorAll('.sglv-blocked-own-btn').forEach(b => {
                b.classList.toggle('active', b.dataset.own === blockedState.ownFilter);
            });
        }

        function renderBlockedKpi() {
            const el = document.getElementById('sglv-blocked-kpi');
            if (!el) return;
            if (!blockedState.loaded) { el.innerHTML = ''; return; }
            // v2.9.91: 使用合并后的锁区列表（含好评500单独加载的条目）
            const mergedApps = getMergedBlockedApps();
            const total = mergedApps.length;
            const ownedIds = Host.getActiveOwnedAppIds();
            const isOwned = n => ownedIds.has(n) || ownedIds.has(String(n));
            const owned = mergedApps.filter(a => isOwned(a.appid)).length;
            const notOwned = total - owned;
            const banned = mergedApps.filter(a => a.categoryId === 20).length;
            const purchase = mergedApps.filter(a => a.categoryId === 3).length;
            const regional = mergedApps.filter(a => a.categoryId === 10).length;
            // v1.9.15: 好评500 分类计数（非零时追加到副标题）
            const topRated = mergedApps.filter(a => a.categoryId === 500).length;
            const subText = Host.T.blockedKpiSubBanned.replace('N', banned).replace('M', purchase).replace('K', regional) +
                (topRated > 0 ? ' · ' + (Host.isZh ? '好评500 ' : 'Positive500 ') + topRated : '');
            const tipAll = Host.isZh ? '点击筛选：全部' : 'Click to filter: All';
            const tipOwned = Host.isZh ? '点击筛选：steam在库' : 'Click to filter: In Library';
            const tipNotOwned = Host.isZh ? '点击筛选：未拥有' : 'Click to filter: Not Owned';
            el.innerHTML = `
                <div class="sglv-trend-kpi-row">
                    <div class="sglv-trend-kpi-card clickable${blockedState.ownFilter === 'all' ? ' active' : ''}" style="border-left:3px solid #ef4444" data-blocked-filter="all" title="${tipAll}">
                        <div class="sglv-trend-kpi-header"><span class="sglv-trend-kpi-icon" style="color:#ef4444">${BLOCKED_LOCK_ICON_SVG}</span><span class="sglv-trend-kpi-label">${Host.T.blockedKpiTotal}</span></div>
                        <div class="sglv-trend-kpi-value">${total.toLocaleString()}</div>
                        <div class="sglv-trend-kpi-sub">${subText}</div>
                    </div>
                    <div class="sglv-trend-kpi-card mine clickable${blockedState.ownFilter === 'owned' ? ' active' : ''}" data-blocked-filter="owned" title="${tipOwned}">
                        <div class="sglv-trend-kpi-header"><span class="sglv-trend-kpi-icon">${Host.ICONS.heart}</span><span class="sglv-trend-kpi-label">${Host.T.blockedKpiOwned}</span></div>
                        <div class="sglv-trend-kpi-value">${owned.toLocaleString()}</div>
                        <div class="sglv-trend-kpi-sub">${Host.isZh ? '已在 Steam 库' : 'In Steam library'}</div>
                    </div>
                    <div class="sglv-trend-kpi-card clickable${blockedState.ownFilter === 'notOwned' ? ' active' : ''}" style="border-left:3px solid #ff9800" data-blocked-filter="notOwned" title="${tipNotOwned}">
                        <div class="sglv-trend-kpi-header"><span class="sglv-trend-kpi-icon" style="color:#ff9800">${Host.ICONS.tag}</span><span class="sglv-trend-kpi-label">${Host.T.blockedKpiNotOwned}</span></div>
                        <div class="sglv-trend-kpi-value">${notOwned.toLocaleString()}</div>
                        <div class="sglv-trend-kpi-sub">${Host.isZh ? '待探索' : 'To explore'}</div>
                    </div>

                </div>
            `;
        }

        function renderBlockedGamesList() {
            const content = document.getElementById('sglv-blocked-content');
            if (!content) return;
            const clearPagination = () => { const p = document.getElementById('sglv-blocked-pagination'); if (p) p.innerHTML = ''; };

            if (blockedState.loading) {
                // v2.9.91: 显示刷新进度文本（若有）
                const stageText = blockedState.refreshStage || Host.T.blockedLoading;
                content.innerHTML = '<div class="sglv-progress" style="margin:16px 0"><div class="sglv-progress-fill" style="width:45%"></div></div><div class="sglv-empty">' + Host.wlEscape(stageText) + '</div>';
                clearPagination(); return;
            }
            if (blockedState.loadError) {
                content.innerHTML = '<div class="sglv-empty">' + Host.T.blockedLoadError + '</div>';
                clearPagination(); return;
            }
            if (!blockedState.loaded || blockedState.apps.length === 0) {
                content.innerHTML = '<div class="sglv-empty">' + Host.T.blockedNoData + '</div>';
                clearPagination(); return;
            }

            const list = getFilteredBlocked();
            if (list.length === 0) {
                content.innerHTML = '<div class="sglv-empty">' + (Host.isZh ? '无匹配结果' : 'No matching results') + '</div>';
                clearPagination(); return;
            }

            const { pageItems, totalPages, page: _clampedPage } = Host.paginate(list, blockedState.page, blockedState.pageSize);
            blockedState.page = _clampedPage;

            const ownedIds = Host.getActiveOwnedAppIds();
            const isOwned = n => ownedIds.has(n) || ownedIds.has(String(n));

            if (blockedState.viewMode === 'card') {
                content.innerHTML = '<div class="sglv-card-grid">' + pageItems.map(a => {
                    const name = a.name || ('App ' + a.appid);
                    const clickUrl = 'https://store.steampowered.com/app/' + a.appid;
                    const owned = isOwned(a.appid);
                    const nameSpan = '<span>' + Host.wlEscape(name) + '</span><span class="sglv-card-id-inline">' + a.appid + '</span>';
                    const catBadge = blockedCatBadgeHtml(a.categoryId);
                    const ownedBadge = blockedOwnedBadgeHtml(owned);
                    const dateStr = a.changedAt ? '<span class="sglv-card-id-inline">' + Host.T.blockedChangedAt + ': ' + Host.wlEscape(a.changedAt) + '</span>' : '';
                    return '<div class="sglv-game-card" data-appid="' + a.appid + '" onclick="window.open(\'' + clickUrl + '\',\'_blank\')">' +
                        '<div class="sglv-card-img-wrap">' + blockedPosterImg(a.appid, name) + '</div>' +
                        '<div class="sglv-card-body">' +
                            '<div class="sglv-card-name" title="' + Host.wlEscape(name) + '">' + nameSpan + ' ' + dateStr + '</div>' +
                            '<div class="sglv-info-row sglv-wl-price-row">' + catBadge + ownedBadge + '</div>' +
                        '</div>' +
                    '</div>';
                }).join('') + '</div>';
            } else if (blockedState.viewMode === 'cover') {
                // v2.9.22: 标签统一规则——封面上不放任何徽章（cat/owned 全部移到标题下方）
                content.innerHTML = '<div class="sglv-wl-cover-grid">' + pageItems.map(a => {
                    const name = a.name || ('App ' + a.appid);
                    const clickUrl = 'https://store.steampowered.com/app/' + a.appid;
                    const owned = isOwned(a.appid);
                    const catBadge = blockedCatBadgeHtml(a.categoryId);
                    const ownedBadge = blockedOwnedBadgeHtml(owned);
                    return '<div class="sglv-wl-cover-card" data-appid="' + a.appid + '" onclick="window.open(\'' + clickUrl + '\',\'_blank\')">' +
                        '<div class="sglv-wl-cover-img-wrap">' + blockedCapsuleImg(a.appid, name) + '</div>' +
                        '<div class="sglv-wl-cover-body">' +
                            '<div class="sglv-card-name" title="' + Host.wlEscape(name) + '">' + Host.wlEscape(name) + ' <span class="sglv-card-id-inline">' + a.appid + '</span></div>' +
                            '<div class="sglv-info-row sglv-wl-price-row sglv-blocked-owned-row">' + catBadge + ownedBadge + '</div>' +
                        '</div>' +
                    '</div>';
                }).join('') + '</div>';
            } else {
                content.innerHTML = '<div class="sglv-list-view">' + pageItems.map(a => {
                    const name = a.name || ('App ' + a.appid);
                    const clickUrl = 'https://store.steampowered.com/app/' + a.appid;
                    const owned = isOwned(a.appid);
                    const iconHtml = '<img class="sglv-list-icon" src="' + Host.getGameIconUrl(a.appid, '') + '" alt="' + Host.wlEscape(name) + '" loading="lazy" decoding="async" onerror="_sglvBlockedListIconFallback(this)">';
                    const catBadge = blockedCatBadgeHtml(a.categoryId);
                    const ownedBadge = blockedOwnedBadgeHtml(owned);
                    const dateStr = a.changedAt ? '<span style="color:#8f98a0">' + Host.T.blockedChangedAt + ': ' + Host.wlEscape(a.changedAt) + '</span>' : '';
                    return '<div class="sglv-list-item" data-appid="' + a.appid + '" onclick="window.open(\'' + clickUrl + '\',\'_blank\')">' +
                        iconHtml +
                        '<div class="sglv-list-info">' +
                            '<div class="sglv-list-name">' + Host.wlEscape(name) + ' <span class="sglv-card-id-inline">' + a.appid + '</span></div>' +
                            '<div class="sglv-list-meta">' + catBadge + ownedBadge + ' ' + dateStr + '</div>' +
                        '</div>' +
                    '</div>';
                }).join('') + '</div>';
            }

            const pagination = document.getElementById('sglv-blocked-pagination');
            if (pagination) {
                // v1.9.47-fix: 补 onJump——锁区翻页 5 个按钮全部走 onJump(参见主脚本 renderPagination)
                Host.renderPagination(pagination, 'sglv-blocked', blockedState.page, totalPages, list.length,
                    () => { blockedState.page--; renderBlockedGamesList(); },
                    () => { blockedState.page++; renderBlockedGamesList(); },
                    (p) => { blockedState.page = p; renderBlockedGamesList(); });
            }
        }

        // ==================== 年度大作标签页 (v2.9.7, v1.7.x 按年数据源) ====================
        // v1.8.1: 数据源改用 jsdelivr CDN 优先（国内稳定），raw.githubusercontent 兜底。
        //         raw.githubusercontent.com 在国内经常连接超时/被墙，导致年度大作加载失败。
        //         jsdelivr CDN 对 GitHub 仓库有镜像缓存，国内访问稳定且速度快。
        //         采用三级回退链：fastly.jsdelivr → cdn.jsdelivr → raw.githubusercontent
        //         缓存延长至 6 天，刷新节流延长至 24h（数据基本不变，偶尔新增待发售游戏）。
        // v1.7.1: GitHub repo 实际只存了一个 2026.json 全量文件(含 2020-2026 所有年度),
        //         按年探测 2024/2025.json 都会 404 导致大量数据被静默丢弃。
        //         改为"单文件全量拉 2026.json + 从 date 字段动态提取 availableYears"。
        //   JSON 格式：[{ name: "游戏名", date: "2026年01月30日", appid: 2362060 }, ...]
        // v1.7.0: 增加按年度筛选——availableYears 从数据里动态提取(去重 + 倒序)
        //         默认展示全部年度 + 按时间降序(dateDesc)
        const GOTY_YEAR_MIN = 2020;                                  // 数据里允许的最小年份(用于过滤异常数据)
        const GOTY_DATA_FILE = '2026.json';                          // 全量文件名(repo 实际只这一个)
        // v1.8.1: CDN 回退链——优先 jsdelivr（国内稳定），raw.githubusercontent 兜底
        const GOTY_DATA_SOURCES = [
            'https://fastly.jsdelivr.net/gh/SmallRob/steam-namespace@main/data/' + GOTY_DATA_FILE,   // ① fastly 节点（优先）
            'https://cdn.jsdelivr.net/gh/SmallRob/steam-namespace@main/data/' + GOTY_DATA_FILE,      // ② jsdelivr 主节点
            'https://raw.githubusercontent.com/SmallRob/steam-namespace/refs/heads/main/data/' + GOTY_DATA_FILE, // ③ raw 兜底
        ];
        function _gotyCurrentYear() { return new Date().getFullYear(); }

        // "2026年01月30日" / "2026 年7月8日" → "20260130"（可排序字符串）
        function gotyDateToSortable(dateStr) {
            if (!dateStr) return '99999999';
            const m = String(dateStr).match(/(\d{4})\s*年\s*(\d{1,2})\s*月\s*(\d{1,2})\s*日/);
            if (!m) return '99999999';
            return m[1] + m[2].padStart(2, '0') + m[3].padStart(2, '0');
        }
        // 从可排序字符串中提取年份("20260130" → 2026)
        function gotyDateYear(sortable) {
            if (!sortable || sortable === '99999999') return null;
            return parseInt(sortable.slice(0, 4), 10);
        }
        // v2.9.22: "2026年01月30日" → "2026-01-30"（完整年月日，紧凑显示用）
        function gotyDateFull(dateStr) {
            const s = gotyDateToSortable(dateStr);
            if (s === '99999999') return dateStr || '';
            return s.slice(0, 4) + '-' + s.slice(4, 6) + '-' + s.slice(6, 8);
        }

        // ==================== v1.4.0: 年度大作封面获取优化 ====================
        // 参考 Steam-Wishlist-Sidebar v1.2.0（SWE）的「持久化 good URL 缓存 + 多 CDN 回退 +
        // appdetails API 兜底」模式。年度大作多为新发售/未发售的 2026 游戏，部分胶囊图在单一
        // CDN 上尚未就绪，需多 CDN 回退 + API 兜底才能稳定获取；首次会话解析成功的 URL 持久化
        // 到 GM 存储（跨会话 LRU），后续会话直接命中最终 URL，跳过整条回退链，减少封面请求与闪烁。
        const GOTY_COVER_CACHE_KEY = 'sglv_goty_cover_good_v1';
        const GOTY_COVER_MAX = 600;                   // LRU 容量上限
        const GOTY_COVER_TTL = 30 * 24 * 3600 * 1000; // 30 天
        const _gotyCoverGood = new Map();        // `${kind}:${appid}` → 已验证可用 URL（内存）
        const _gotyCoverNext = new WeakMap();    // img → 下一个待尝试的 chain 索引
        const _gotyCoverApiTried = new WeakMap();// img → 是否已尝试 API 兜底
        let _gotyCoverPersisted = null;          // null=未加载, {key:{url,ts}}
        let _gotyCoverWriteTimer = null;
        let _gotyCoverDirty = false;
        const _GOTY_PLACEHOLDER = "data:image/svg+xml;utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 200 300'%3E%3Crect fill='%231a1f3a' width='200' height='300'/%3E%3Ctext x='50%25' y='50%25' text-anchor='middle' dy='.3em' fill='%2364748b' font-family='system-ui' font-size='16'%3E🎮%3C/text%3E%3C/svg%3E";

        function _gotyCoverLoadPersisted() {
            if (_gotyCoverPersisted !== null) return;
            _gotyCoverPersisted = {};
            try {
                const raw = Host.cacheGet(GOTY_COVER_CACHE_KEY);
                if (raw && typeof raw === 'object') _gotyCoverPersisted = raw;
            } catch (e) { /* ignore */ }
            // 同步预热内存缓存
            for (const k in _gotyCoverPersisted) {
                const ent = _gotyCoverPersisted[k];
                if (ent && ent.url) _gotyCoverGood.set(k, ent.url);
            }
        }

        function _gotyCoverRecordGood(appid, url, kind) {
            if (!appid || !url) return;
            const key = `${kind || 'poster'}:${appid}`;
            if (_gotyCoverGood.get(key) === url) return; // 已记录，跳过
            _gotyCoverGood.set(key, url);
            _gotyCoverLoadPersisted();
            _gotyCoverPersisted[key] = { url, ts: Date.now() };
            // LRU 淘汰
            const keys = Object.keys(_gotyCoverPersisted);
            if (keys.length > GOTY_COVER_MAX) {
                keys.sort((a, b) => (_gotyCoverPersisted[a].ts || 0) - (_gotyCoverPersisted[b].ts || 0));
                while (keys.length > GOTY_COVER_MAX) delete _gotyCoverPersisted[keys.shift()];
            }
            _gotyCoverDirty = true;
            // 节流落盘（80ms），避免高频 load 事件触发 GM 写入风暴
            if (_gotyCoverWriteTimer) return;
            _gotyCoverWriteTimer = setTimeout(() => {
                _gotyCoverWriteTimer = null;
                if (!_gotyCoverDirty) return;
                _gotyCoverDirty = false;
                try { Host.cacheSet(GOTY_COVER_CACHE_KEY, _gotyCoverPersisted, GOTY_COVER_TTL); } catch (e) { /* ignore */ }
            }, 80);
        }

        function _gotyCoverGetGood(appid, kind) {
            _gotyCoverLoadPersisted();
            return _gotyCoverGood.get(`${kind || 'poster'}:${appid}`) || '';
        }

        // 生成年度大作封面 <img>（无内联 onerror，回退由 _bindGotyCoverDelegation 委托处理）
        // kind: 'poster'(竖版卡片) | 'capsule'(横版封面) | 'header'(列表图标)
        // v1.9.41: 链走 coverChainLang（语言变体链；good 缓存仍用 GOTY 专用持久缓存）
        function gotyCoverImgTag(appid, name, kind, cls) {
            const good = _gotyCoverGetGood(appid, kind) || coverGoodUrl(appid, kind);
            const chain = coverChainLang(appid, kind);
            const firstUrl = good || chain[0];
            return `<img class="${cls}" data-goty-img="${kind}" data-appid="${appid}" src="${firstUrl}" alt="${Host.wlEscape(name)}" loading="lazy" decoding="async" referrerpolicy="no-referrer">`;
        }

        function _gotyCoverPlaceholder(img) {
            img.removeAttribute('data-goty-img'); // 占位图不再触发回退
            img.src = _GOTY_PLACEHOLDER;
        }

        // 在年度大作内容容器上绑定图片回退委托（img 的 error/load 不冒泡，用捕获阶段）
        function _bindGotyCoverDelegation(contentEl) {
            if (!contentEl || contentEl.dataset.gotyCoverBound === '1') return;
            contentEl.dataset.gotyCoverBound = '1';
            contentEl.addEventListener('error', (e) => {
                const img = e.target;
                if (!img || img.tagName !== 'IMG' || !img.dataset.gotyImg) return;
                const appid = img.dataset.appid;
                const kind = img.dataset.gotyImg;
                const chain = coverChainLang(appid, kind);
                let next = _gotyCoverNext.get(img);
                if (next === undefined) next = 0;
                // 跳过与当前已失败 src 相同的 chain 条目，避免重复请求
                const curSrc = img.getAttribute('src');
                while (next < chain.length && chain[next] === curSrc) next++;
                if (next < chain.length) {
                    _gotyCoverNext.set(img, next + 1);
                    img.src = chain[next];
                    return;
                }
                // 回退链耗尽 → appdetails API 兜底（仅尝试一次），成功会触发 load → 记录 good URL
                // v1.9.29: 传递 kind 参数，使 API 兜底按图片类型选择最佳 URL
                if (!_gotyCoverApiTried.get(img)) {
                    _gotyCoverApiTried.set(img, true);
                    Host.fetchCoverApiUrl(appid, kind).then(url => {
                        if (url) img.src = url;
                        else _gotyCoverPlaceholder(img);
                    }).catch(() => _gotyCoverPlaceholder(img));
                } else {
                    _gotyCoverPlaceholder(img);
                }
            }, true);
            contentEl.addEventListener('load', (e) => {
                const img = e.target;
                if (!img || img.tagName !== 'IMG' || !img.dataset.gotyImg) return;
                if (img.naturalWidth && img.naturalWidth > 1) {
                    _gotyCoverRecordGood(img.dataset.appid, img.getAttribute('src'), img.dataset.gotyImg);
                }
            }, true);
        }

        // v1.9.5: 缓存永不过期——优先读永久缓存秒开，后台增量合并刷新（24h 节流）
        const _GOTY_BG_INTERVAL = 24 * 3600 * 1000; // 年度大作数据变化慢，24h 节流足够
        let _gotyLastBgRefreshAt = 0;
        function loadGotyGames(force) {
            // v1.9.27: force 时重置可能卡死的 loading 标志
            if (gotyState.loading) {
                if (!force) return;
                gotyState.loading = false;
            }
            if (!force) {
                // v1.9.5: 优先读永久缓存（永不过期）
                const cached = _permCacheGet('gotyGames_v2');
                if (cached && Array.isArray(cached.games) && cached.games.length > 0) {
                    gotyState.games = cached.games;
                    gotyState.updatedAt = cached.updatedAt || '';
                    gotyState.source = cached.source || Host.T.gotySourceCache;
                    gotyState.availableYears = Array.isArray(cached.availableYears) ? cached.availableYears : [];
                    gotyState.lastFetchAt = cached.lastFetchAt || 0;
                    gotyState.loaded = true;
                    renderGotySections();
                    // v1.9.5: 后台增量刷新（24h 节流）
                    if (_shouldThrottle(_gotyLastBgRefreshAt, _GOTY_BG_INTERVAL)) return;
                    _refreshGotyFromRemote(false, false);
                    return;
                }
            }
            // v1.9.47-fix: 无缓存首次进入 → showLoading=true 展示 loading 骨架,避免
            //   "打开 GOTY tab → 远程源未返回时看到"暂无数据" → 数据到达后突然刷出" 的闪烁/误判。
            _refreshGotyFromRemote(force, true);
        }

        function _gotyFailLoading(msg) {
            gotyState.loading = false;
            if (gotyState.games.length === 0) {
                gotyState.loadError = msg;
            } else {
                gotyState.loadError = null;
                Host.showToast(Host.isZh ? '更新失败，已使用本地数据' : 'Update failed, using local data');
            }
            renderGotyGamesList();
        }

        // v1.8.1: 远程获取——CDN 三级回退链（fastly.jsdelivr → cdn.jsdelivr → raw.githubusercontent）
        //         依次尝试每个数据源，任一成功即停止；全部失败才报错。
        //         raw.githubusercontent.com 在国内经常超时/被墙，jsdelivr CDN 更稳定。
        // v1.7.1: 单文件全量拉取 2026.json(包含 2020-currentYear 所有年度)
        //         从每个 game 的 date 字段动态提取 availableYears(去重 + 倒序)
        function _refreshGotyFromRemote(force, showLoading) {
            if (typeof GM_xmlhttpRequest !== 'function') {
                if (showLoading) _gotyFailLoading('noXhr');
                return;
            }
            // v1.9.27: force 时重置可能卡死的 loading 标志
            if (gotyState.loading) {
                if (!force) return;
                gotyState.loading = false;
            }
            if (showLoading) { gotyState.loading = true; gotyState.loadError = null; renderGotyGamesList(); }

            const targetYear = gotyState.year;       // 用户已选年度(null = 全部)

            // v1.8.1: 处理成功响应的公共逻辑（解析 + 过滤 + 去重 + 缓存 + 渲染）
            function _processGotyResponse(r) {
                const _gotyTxt = _safeRespText(r);
                if (r.status === 404 || !_gotyTxt) return false; // 交给下一个源
                const data = JSON.parse(_gotyTxt);
                if (!Array.isArray(data) || data.length === 0) return false;
                // 解析 + 过滤无效数据
                const games = data
                    .filter(g => g && g.appid && Number(g.appid) > 0)
                    .map(g => {
                        const sortable = gotyDateToSortable(g.date || '');
                        return { appid: Number(g.appid), name: g.name || ('App ' + g.appid), date: g.date || '', year: gotyDateYear(sortable) };
                    })
                    .filter(g => g.year && g.year >= GOTY_YEAR_MIN && g.year <= _gotyCurrentYear() + 2);
                if (games.length === 0) return false;
                // v1.9.5: 增量合并去重（按 appid）——使用统一工具函数
                gotyState.games = _mergeByAppid(gotyState.games, games);
                // 从所有 games 的 date 字段动态提取 availableYears(去重 + 倒序)
                const yearSet = new Set();
                gotyState.games.forEach(g => { if (g.year) yearSet.add(g.year); });
                gotyState.availableYears = Array.from(yearSet).sort((a, b) => b - a);
                // v1.9.24: 默认展开全部年度供用户筛选（null = 全部），仅在用户已选年度不在列表时回退到全部
                if (targetYear && !gotyState.availableYears.includes(targetYear)) {
                    gotyState.year = null;
                }
                gotyState.updatedAt = new Date().toISOString().slice(0, 10);
                gotyState.source = Host.T.gotySourceGithub;
                gotyState.loaded = true;
                gotyState.loadError = null;
                gotyState.loading = false;
                gotyState.lastFetchAt = Date.now();
                _gotyLastBgRefreshAt = Date.now(); // v1.9.5: 记录后台刷新时间戳
                // v1.9.5: 写入永久缓存（永不过期）
                _permCacheSet('gotyGames_v2', { games: gotyState.games, year: gotyState.year, availableYears: gotyState.availableYears, updatedAt: gotyState.updatedAt, source: gotyState.source, lastFetchAt: gotyState.lastFetchAt });
                renderGotySections();
                return true;
            }

            // v1.8.1: 依次尝试 GOTY_DATA_SOURCES 中的每个数据源
            function _tryNextSource(idx) {
                if (idx >= GOTY_DATA_SOURCES.length) {
                    // 所有数据源都失败
                    gotyState.loading = false;
                    if (gotyState.games.length === 0) _gotyFailLoading('networkError');
                    return;
                }
                GM_xmlhttpRequest({
                    method: 'GET',
                    url: GOTY_DATA_SOURCES[idx],
                    timeout: 15000,
                    onload(r) {
                        try {
                            if (_processGotyResponse(r)) return; // 成功，停止
                        } catch (e) { /* 解析异常，交给下一个源 */ }
                        _tryNextSource(idx + 1); // 失败，尝试下一个源
                    },
                    onerror() { _tryNextSource(idx + 1); },
                    ontimeout() { _tryNextSource(idx + 1); },
                });
            }

            _tryNextSource(0);
        }

        function getFilteredGoty() {
            const q = gotyState.search.toLowerCase().trim();
            const ownedIds = Host.getActiveOwnedAppIds();
            const isOwned = n => ownedIds.has(n) || ownedIds.has(String(n));
            let list = gotyState.games.filter(g => g.appid > 0);
            if (q) {
                list = list.filter(g => String(g.appid).includes(q) || (g.name || '').toLowerCase().includes(q));
            }
            // v1.7.1: 按年度筛选(默认 null = 全部年度);games 已在 _refreshGotyFromRemote 中预解析 year
            if (gotyState.year) {
                list = list.filter(g => g.year === gotyState.year);
            }
            if (gotyState.ownFilter === 'owned') list = list.filter(g => isOwned(g.appid));
            else if (gotyState.ownFilter === 'notOwned') list = list.filter(g => !isOwned(g.appid));
            // v1.7.0: 默认 sort='dateDesc'——按时间降序(最新在前)
            list.sort((a, b) => {
                const da = gotyDateToSortable(a.date);
                const db = gotyDateToSortable(b.date);
                switch (gotyState.sort) {
                    case 'dateDesc': return db.localeCompare(da) || (b.appid - a.appid);
                    case 'dateAsc': return da.localeCompare(db) || (a.appid - b.appid);
                    case 'nameAsc': return _nameCollator.compare(a.name || '~', b.name || '~') || da.localeCompare(db);
                    case 'appidAsc': return a.appid - b.appid;
                    default: return da.localeCompare(db) || (a.appid - b.appid);
                }
            });
            return list;
        }

        function gotyBadgeHtml() {
            return '<span class="sglv-card-badge sglv-goty-goty-badge">' + Host.T.gotyBadgeGoty + '</span>';
        }
        function gotyOwnedBadgeHtml(owned) {
            return owned
                ? '<span class="sglv-card-badge owned" style="margin-top:0">✓ ' + Host.T.steamInLib + '</span>'
                : '<span class="sglv-card-badge" style="background:rgba(255,255,255,0.12);color:#8f98a0;margin-top:0;padding:2px 6px;border-radius:3px;font-size:10px">' + Host.T.gotyBadgeNotOwned + '</span>';
        }

        function renderGotyTab(parent) {
            const wrap = document.createElement('div');
            wrap.className = 'sglv-psplus-wrap';

            const kpi = document.createElement('div');
            kpi.id = 'sglv-goty-kpi';
            wrap.appendChild(kpi);

            // v1.7.0: 年度筛选 chip bar——在 toolbar 上方一行,默认"全部"active
            const yearBar = document.createElement('div');
            yearBar.className = 'sglv-goty-year-bar';
            const renderYearBar = () => {
                const yearAllLabel = (Host.T && Host.T.gotyFilterAllYears) || (Host.isZh ? '全部年度' : 'All Years');
                const yearChips = [`<button class="sglv-goty-year-chip${gotyState.year === null ? ' active' : ''}" data-year="">${yearAllLabel}</button>`];
                (gotyState.availableYears || []).slice().sort((a, b) => b - a).forEach(y => {
                    yearChips.push(`<button class="sglv-goty-year-chip${gotyState.year === y ? ' active' : ''}" data-year="${y}">${y}</button>`);
                });
                yearBar.innerHTML = yearChips.join('');
            };
            renderYearBar();
            wrap.appendChild(yearBar);

            const toolbar = document.createElement('div');
            toolbar.className = 'sglv-toolbar';
            const sortOptions = [
                { key: 'dateDesc', label: Host.T.gotySortDateDesc },   // v1.7.0: 默认时间降序(最新在前)
                { key: 'dateAsc', label: Host.T.gotySortDateAsc },
                { key: 'nameAsc', label: Host.T.gotySortNameAsc },
                { key: 'appidAsc', label: Host.T.gotySortAppidAsc },
            ];
            toolbar.innerHTML = `
                <input class="sglv-search" aria-label="搜索" id="sglv-goty-search" placeholder="${Host.T.gotySearch}" value="${Host.wlEscape(gotyState.search)}">
                <select class="sglv-sort-select" aria-label="排序方式" id="sglv-goty-sort">
                    ${sortOptions.map(o => `<option value="${o.key}"${gotyState.sort === o.key ? ' selected' : ''}>${o.label}</option>`).join('')}
                </select>
                <div class="sglv-view-toggle">
                    <button class="sglv-btn sglv-btn-secondary sglv-btn-icon${gotyState.viewMode === 'card' ? ' active' : ''}" id="sglv-goty-card" title="${Host.T.cardView}">${Host.ICONS.grid}</button>
                    <button class="sglv-btn sglv-btn-secondary sglv-btn-icon${gotyState.viewMode === 'cover' ? ' active' : ''}" id="sglv-goty-cover" title="${Host.T.coverView}">${Host.ICONS.cover}</button>
                    <button class="sglv-btn sglv-btn-secondary sglv-btn-icon${gotyState.viewMode === 'list' ? ' active' : ''}" id="sglv-goty-list" title="${Host.T.listView}">${Host.ICONS.list}</button>
                </div>
                <button class="sglv-btn sglv-btn-secondary sglv-btn-icon" id="sglv-goty-refresh" title="${Host.T.gotyRefreshTip}">${Host.ICONS.refresh}</button>
                <div class="sglv-pagination" id="sglv-goty-pagination"></div>
            `;
            wrap.appendChild(toolbar);

            const content = document.createElement('div');
            content.className = 'sglv-content';
            content.id = 'sglv-goty-content';
            wrap.appendChild(content);

            parent.appendChild(wrap);

            toolbar.querySelector('#sglv-goty-search').addEventListener('input', _debounce((e) => {
                gotyState.search = e.target.value;
                gotyState.page = 1;
                renderGotyGamesList();
            }, 200));
            toolbar.querySelector('#sglv-goty-sort').addEventListener('change', (e) => {
                gotyState.sort = e.target.value;
                gotyState.page = 1;
                renderGotyGamesList();
            });
            // v1.7.0: 年度筛选事件——切换 / 拉取新数据
            yearBar.addEventListener('click', (e) => {
                const chip = e.target.closest('.sglv-goty-year-chip');
                if (!chip) return;
                const y = chip.dataset.year;
                const newYear = y ? parseInt(y, 10) : null;
                if (newYear === gotyState.year) return;
                gotyState.year = newYear;
                gotyState.page = 1;
                // 切换"全部"时不需要重新拉;切换到具体年份时,如已有缓存就无需重拉
                renderYearBar();
                if (newYear !== null && !gotyState.availableYears.includes(newYear)) {
                    // 该年还没拉过,触发拉取
                    _refreshGotyFromRemote(false, true);
                } else {
                    renderGotySections();
                }
            });
            const setGotyViewMode = (mode) => {
                gotyState.viewMode = mode;
                ['card', 'cover', 'list'].forEach(m => {
                    toolbar.querySelector('#sglv-goty-' + m)?.classList.toggle('active', m === mode);
                });
                renderGotyGamesList();
            };
            toolbar.querySelector('#sglv-goty-card').addEventListener('click', () => setGotyViewMode('card'));
            toolbar.querySelector('#sglv-goty-cover').addEventListener('click', () => setGotyViewMode('cover'));
            toolbar.querySelector('#sglv-goty-list').addEventListener('click', () => setGotyViewMode('list'));
            toolbar.querySelector('#sglv-goty-refresh').addEventListener('click', () => loadGotyGames(true));
            // v1.4.0: 筛选改为点击 KPI 卡片切换（再次点击同一卡片回到「全部」），与库存标签页一致
            kpi.addEventListener('click', e => {
                const card = e.target.closest('[data-goty-filter]');
                if (!card) return;
                const f = card.dataset.gotyFilter;
                gotyState.ownFilter = gotyState.ownFilter === f ? 'all' : f;
                gotyState.page = 1;
                renderGotyKpi();      // 刷新 KPI active 高亮
                renderGotyGamesList();
            });

            if (!gotyState.loaded && !gotyState.loading) {
                loadGotyGames();
            } else {
                renderGotySections();
            }
        }

        function renderGotySections() {
            if (_collectionActiveTab !== 'goty' || !document.getElementById('sglv-goty-content')) return;
            renderGotyKpi();
            renderGotyGamesList();
        }

        function renderGotyKpi() {
            const el = document.getElementById('sglv-goty-kpi');
            if (!el) return;
            if (!gotyState.loaded) { el.innerHTML = ''; return; }
            const total = gotyState.games.length;
            const ownedIds = Host.getActiveOwnedAppIds();
            const isOwned = n => ownedIds.has(n) || ownedIds.has(String(n));
            const owned = gotyState.games.filter(g => isOwned(g.appid)).length;
            const notOwned = total - owned;
            const srcLabel = gotyState.source || Host.T.gotySourceGithub;
            const updatedStr = gotyState.updatedAt
                ? (Host.isZh ? '更新于 ' : 'Updated ') + gotyState.updatedAt + ' · ' + srcLabel
                : (Host.isZh ? '来源：' : 'Source: ') + srcLabel;
            el.innerHTML = `
                <div class="sglv-trend-kpi-row">
                    <div class="sglv-trend-kpi-card blue clickable${gotyState.ownFilter === 'all' ? ' active' : ''}" data-goty-filter="all" title="${Host.isZh ? '点击筛选：全部' : 'Click to filter: All'}">
                        <div class="sglv-trend-kpi-header"><span class="sglv-trend-kpi-icon">${Host.ICONS.trophy}</span><span class="sglv-trend-kpi-label">${Host.T.gotyKpiTotal}</span></div>
                        <div class="sglv-trend-kpi-value">${total.toLocaleString()}</div>
                        <div class="sglv-trend-kpi-sub">${updatedStr}</div>
                    </div>
                    <div class="sglv-trend-kpi-card mine clickable${gotyState.ownFilter === 'owned' ? ' active' : ''}" data-goty-filter="owned" title="${Host.isZh ? '点击筛选：steam在库' : 'Click to filter: In Library'}">
                        <div class="sglv-trend-kpi-header"><span class="sglv-trend-kpi-icon">${Host.ICONS.heart}</span><span class="sglv-trend-kpi-label">${Host.T.gotyKpiOwned}</span></div>
                        <div class="sglv-trend-kpi-value">${owned.toLocaleString()}</div>
                        <div class="sglv-trend-kpi-sub">${Host.T.gotyKpiOwnedSub}</div>
                    </div>
                    <div class="sglv-trend-kpi-card clickable${gotyState.ownFilter === 'notOwned' ? ' active' : ''}" style="border-left:3px solid #ff9800" data-goty-filter="notOwned" title="${Host.isZh ? '点击筛选：未拥有' : 'Click to filter: Not Owned'}">
                        <div class="sglv-trend-kpi-header"><span class="sglv-trend-kpi-icon" style="color:#ff9800">${Host.ICONS.tag}</span><span class="sglv-trend-kpi-label">${Host.T.gotyKpiNotOwned}</span></div>
                        <div class="sglv-trend-kpi-value">${notOwned.toLocaleString()}</div>
                        <div class="sglv-trend-kpi-sub">${Host.isZh ? '可在 Steam 购买' : 'Available on Steam'}</div>
                    </div>
                </div>
            `;
        }

        function renderGotyGamesList() {
            const content = document.getElementById('sglv-goty-content');
            if (!content) return;
            _bindGotyCoverDelegation(content); // v1.4.0: 年度大作封面回退委托（捕获阶段，仅绑定一次）
            const clearPagination = () => { const p = document.getElementById('sglv-goty-pagination'); if (p) p.innerHTML = ''; };

            if (gotyState.loading) {
                content.innerHTML = '<div class="sglv-progress" style="margin:16px 0"><div class="sglv-progress-fill" style="width:45%"></div></div><div class="sglv-empty">' + Host.T.gotyLoading + '</div>';
                clearPagination();
                return;
            }
            if (gotyState.loadError) {
                content.innerHTML = '<div class="sglv-empty">' + Host.T.gotyLoadError + '</div>';
                clearPagination();
                return;
            }
            if (!gotyState.loaded || gotyState.games.length === 0) {
                content.innerHTML = '<div class="sglv-empty">' + Host.T.gotyNoData + '</div>';
                clearPagination();
                return;
            }

            const list = getFilteredGoty();
            if (list.length === 0) {
                content.innerHTML = '<div class="sglv-empty">' + (Host.isZh ? '无匹配结果' : 'No matching results') + '</div>';
                clearPagination();
                return;
            }

            const { pageItems, totalPages, page: _clampedPage } = Host.paginate(list, gotyState.page, gotyState.pageSize);
            gotyState.page = _clampedPage;

            const ownedIds = Host.getActiveOwnedAppIds();
            const isOwned = n => ownedIds.has(n) || ownedIds.has(String(n));
            const gotyBadge = gotyBadgeHtml();
            const dateLabel = Host.T.gotyReleaseDate;

            // v2.9.22: 发售日期组件——时间图标 + 完整年月日(YYYY-MM-DD)，与 owned badge 同行右侧
            //         注意：g 是 pageItems.map 回调内的形参，外层不能直接引用，所以用工厂函数
            const gotyDateHtml = g => g.date ? '<span class="sglv-goty-date"><span class="sglv-goty-clock">' + Host.ICONS.clock + '</span>' + Host.wlEscape(gotyDateFull(g.date)) + '</span>' : '';

            if (gotyState.viewMode === 'card') {
                content.innerHTML = '<div class="sglv-card-grid">' + pageItems.map(g => {
                    const clickUrl = 'https://store.steampowered.com/app/' + g.appid;
                    return '<div class="sglv-game-card" data-appid="' + g.appid + '" onclick="window.open(\'' + clickUrl + '\',\'_blank\')">' +
                        '<div class="sglv-card-img-wrap">' + gotyBadge + gotyCoverImgTag(g.appid, g.name, 'poster', 'sglv-card-img') + '</div>' +
                        '<div class="sglv-card-body">' +
                            '<div class="sglv-card-name" title="' + Host.wlEscape(g.name) + '">' + Host.wlEscape(g.name) + '</div>' +
                            // 行 2: [是否拥有] [🕐 发售年月日] 紧凑同行
                            '<div class="sglv-info-row sglv-wl-price-row sglv-goty-status-row">' + gotyOwnedBadgeHtml(isOwned(g.appid)) + gotyDateHtml(g) + '</div>' +
                        '</div>' +
                    '</div>';
                }).join('') + '</div>';
            } else if (gotyState.viewMode === 'cover') {
                // v2.9.22: 标签统一规则——封面上不放任何徽章（gotyBadge 在右下角，owned badge + 日期在标题下方同行）
                content.innerHTML = '<div class="sglv-wl-cover-grid">' + pageItems.map(g => {
                    const clickUrl = 'https://store.steampowered.com/app/' + g.appid;
                    return '<div class="sglv-wl-cover-card" data-appid="' + g.appid + '" onclick="window.open(\'' + clickUrl + '\',\'_blank\')">' +
                        '<div class="sglv-wl-cover-img-wrap">' + gotyBadge + gotyCoverImgTag(g.appid, g.name, 'capsule', 'sglv-wl-cover-img') + '</div>' +
                        '<div class="sglv-wl-cover-body">' +
                            '<div class="sglv-card-name" title="' + Host.wlEscape(g.name) + '">' + Host.wlEscape(g.name) + '</div>' +
                            // 紧凑：状态 + 日期同行
                            '<div class="sglv-info-row sglv-wl-price-row sglv-goty-status-row">' + gotyOwnedBadgeHtml(isOwned(g.appid)) + gotyDateHtml(g) + '</div>' +
                        '</div>' +
                    '</div>';
                }).join('') + '</div>';
            } else {
                content.innerHTML = '<div class="sglv-list-view">' + pageItems.map(g => {
                    const clickUrl = 'https://store.steampowered.com/app/' + g.appid;
                    const iconHtml = gotyCoverImgTag(g.appid, g.name, 'header', 'sglv-list-icon');
                    return '<div class="sglv-list-item" data-appid="' + g.appid + '" onclick="window.open(\'' + clickUrl + '\',\'_blank\')">' +
                        iconHtml +
                        '<div class="sglv-list-info">' +
                            '<div class="sglv-list-name">' + Host.wlEscape(g.name) + ' <span class="sglv-card-id-inline">' + g.appid + '</span></div>' +
                            '<div class="sglv-list-meta">' + gotyBadge + gotyOwnedBadgeHtml(isOwned(g.appid)) + ' ' + gotyDateHtml(g) + '</div>' +
                        '</div>' +
                    '</div>';
                }).join('') + '</div>';
            }

            const pagination = document.getElementById('sglv-goty-pagination');
            if (pagination) {
                // v1.9.47-fix: 补 onJump——年度大作翻页 5 个按钮全部走 onJump(参见主脚本 renderPagination)
                Host.renderPagination(pagination, 'sglv-goty', gotyState.page, totalPages, list.length,
                    () => { gotyState.page--; renderGotyGamesList(); },
                    () => { gotyState.page++; renderGotyGamesList(); },
                    (p) => { gotyState.page = p; renderGotyGamesList(); });
            }
        }

        // ==================== DLC 收藏标签页 (v1.9.0) ====================
        // 数据源: Host.isDlc (双源: Barter.vg DLC DB + Steam type=1/6)
        //         Host.getDlcParent (DLC→父游戏 appID, 仅 Barter.vg 提供)
        //         Host.getDlcType (DLC 子类型: music/dlc/video, 需 enrichDlcTypes)
        //         Host.getBundleCount (进包次数)
        // 加载时序: loadDlcDatabase → enrichOwnedAppTypes → enrichDlcTypes (三级渐进)
        // 宿主桥接: Host.isDlc, Host.isDlcDbReady, Host.loadDlcDatabase,
        //           Host.enrichOwnedAppTypes, Host.enrichDlcTypes, Host.getDlcType,
        //           Host.getBundleCount, Host.getDlcParent, Host.getParentDlcTotalMap

        function dlcTypeBadgeHtml(type) {
            if (type === 'music') return '<span class="sglv-dlc-type-badge-music">' + Host.T.dlcBadgeMusic + '</span>';
            return '<span class="sglv-dlc-type-badge-dlc">DLC</span>';
        }

        function dlcBundleBadgeHtml(count) {
            if (!count || count <= 0) return '';
            return '<span class="sglv-badge" style="background:rgba(245,158,11,0.15);color:#fbbf24;border:1px solid rgba(245,158,11,0.25);font-size:9px;padding:1px 5px;border-radius:3px;font-weight:700">📦' + count + '</span>';
        }

        function dlcPlayedBadgeHtml(playtime) {
            if (!playtime || playtime <= 0) return '';
            return '<span class="sglv-badge" style="background:rgba(75,181,79,0.15);color:#4bb54f;border:1px solid rgba(75,181,79,0.25);font-size:9px;padding:1px 5px;border-radius:3px;font-weight:700">' + Math.round(playtime / 60) + 'h</span>';
        }
        // v1.9.4: 已拥有/未拥有 徽章
        function dlcOwnedBadgeHtml(isOwned) {
            if (isOwned) return '<span class="sglv-badge" style="background:rgba(102,192,244,0.15);color:#66c0f4;border:1px solid rgba(102,192,244,0.25);font-size:9px;padding:1px 5px;border-radius:3px;font-weight:700">' + (Host.isZh ? '已拥有' : 'Owned') + '</span>';
            return '<span class="sglv-badge" style="background:rgba(148,163,184,0.1);color:#64748b;border:1px solid rgba(148,163,184,0.15);font-size:9px;padding:1px 5px;border-radius:3px;font-weight:600">' + (Host.isZh ? '未拥有' : 'Not Owned') + '</span>';
        }

        function dlcPosterImg(appid, name) {
            return Host.posterImg(appid, name);
        }

        function dlcCapsuleImg(appid, name) {
            if (typeof Host.capsuleImg === 'function') return Host.capsuleImg(appid, name);
            return Host.posterImg(appid, name);
        }

        function dlcLookupParentName(parentApp) {
            if (!parentApp) return null;
            const found = Host.getOwnedGames().find(g => g.appid === parentApp || String(g.appid) === String(parentApp));
            return found ? found.name : null;
        }

        // ==================== v1.9.2: DLC 子类型 IDB 永久缓存（只增不减） ====================
        // 首次 enrichDlcTypes 后,所有已 enrich 的 DLC 写入 IDB。
        // 下次加载:从 IDB 同步预热 dlcTypeCache,只 enrich 缓存里没有的 DLC（"只增不减"增量）。
        // 即使主脚本 GM 缓存丢失（用户清理脚本存储），本缓存仍能秒返已知子类型。
        async function _ensureDlcTypeCacheLoaded() {
            if (dlcState.dlcTypeCacheLoaded) return dlcState.dlcTypeCache;
            if (dlcState.idbLoadPromise) return dlcState.idbLoadPromise;
            dlcState.idbLoadPromise = (async () => {
                if (!_C || !_C.IDB || typeof _C.IDB.loadAll !== 'function') {
                    console.log('[SGLV-DLC] SGLVCore.IDB 不可用,跳过 IDB 缓存（fallback to in-memory only）');
                    dlcState.dlcTypeCacheLoaded = true;
                    return dlcState.dlcTypeCache;
                }
                try {
                    await _C.IDB.loadAll();
                    // 缓存版本号管理：ensureCacheVersions 升级时自动失效旧版本
                    if (typeof _C.ensureCacheVersions === 'function') {
                        _C.ensureCacheVersions(_DLC_CACHE_VERSION);
                    }
                    const raw = _C.IDB.get(_DLC_TYPE_CACHE_IDB_KEY, null);
                    if (raw && typeof raw === 'object' && !Array.isArray(raw)) {
                        dlcState.dlcTypeCache = raw;
                        console.log(`[SGLV-DLC] IDB dlcTypeCache 命中: ${Object.keys(raw).length} 个 DLC 子类型已缓存`);
                    } else {
                        console.log('[SGLV-DLC] IDB dlcTypeCache 空,首次使用');
                    }
                } catch (e) {
                    console.warn('[SGLV-DLC] IDB 加载失败,使用空缓存:', e);
                }
                dlcState.dlcTypeCacheLoaded = true;
                return dlcState.dlcTypeCache;
            })();
            return dlcState.idbLoadPromise;
        }
        // 持久化到 IDB（异步写,内存立即可见）
        function _persistDlcTypeCache() {
            if (!_C || !_C.IDB) return;
            try { _C.IDB.set(_DLC_TYPE_CACHE_IDB_KEY, dlcState.dlcTypeCache); } catch (e) { /* quota */ }
        }

        // 构建已拥有 DLC 列表（v1.9.4: 全量加载所有已知 DLC，匹配 isOwned）
        // v1.9.2: 同步版本保留,供"快速终态 rebuild"用;大库存场景请用 buildDlcListAsync
        function buildDlcList() {
            const t0 = performance.now();
            const showFamilyShared = Host.getShowFamilyShared();
            const pool = showFamilyShared
                ? Host.getOwnedGames()
                : Host.getOwnedGames().filter(g => Host.isGameOwnedByMe(g));
            const ownedMap = {};
            pool.forEach(g => { ownedMap[String(g.appid)] = g; });
            // v1.9.11: 预构建 parentAppId → name 映射(O(1)查找),替代 dlcLookupParentName 的 O(n) 线性扫描
            const parentNameMap = {};
            Host.getOwnedGames().forEach(g => { if (g && g.appid) parentNameMap[String(g.appid)] = g.name; });
            const dlcsByParent = (typeof Host.getDlcsByParentMap === 'function') ? Host.getDlcsByParentMap() : {};
            const allDlcAppIds = new Set();
            for (const dlcIds of Object.values(dlcsByParent)) {
                for (const id of dlcIds) allDlcAppIds.add(id);
            }
            for (const g of pool) {
                if (Host.isDlc(g.appid)) allDlcAppIds.add(g.appid);
            }
            console.log(`[SGLV-DLC] buildDlcList — 库存池 ${pool.length} 款 (familyShared=${showFamilyShared}), 全量 DLC ${allDlcAppIds.size} 个, isDlcDbReady=${Host.isDlcDbReady()}`);
            dlcState.dlcs = Array.from(allDlcAppIds).map(appid => {
                const owned = ownedMap[String(appid)];
                const parentApp = Host.getDlcParent(appid);
                const type = (dlcState.dlcTypeCache && dlcState.dlcTypeCache[appid]) || Host.getDlcType(appid) || 'dlc';
                return {
                    appid,
                    name: owned ? owned.name : ('DLC ' + appid),
                    playtime: owned ? (owned.playtime || 0) : 0,
                    parentApp: parentApp,
                    parentName: parentApp ? (parentNameMap[String(parentApp)] || null) : null,
                    type: type,
                    bundleCount: Host.getBundleCount(appid),
                    isOwned: !!owned,
                };
            });
            const withParent = dlcState.dlcs.filter(d => d.parentApp).length;
            const withType = dlcState.dlcs.filter(d => d.type !== 'dlc').length;
            const withBundle = dlcState.dlcs.filter(d => d.bundleCount > 0).length;
            console.log(`[SGLV-DLC] buildDlcList — 完成: ${dlcState.dlcs.length} 个 DLC, 父游戏=${withParent}, 子类型=${withType}, 进包=${withBundle}, 耗时 ${Math.round(performance.now() - t0)}ms`);
        }

        // v1.9.2: buildDlcList 的 async 分片版本——每 300 个 yield 一次(setTimeout 0 让出主线程)
        // 大库存(2k+)场景避免单次同步 200-500ms 卡顿;每个 chunk 后用 setTimeout 让浏览器处理用户输入
        // v1.9.4: 全量加载——遍历所有已拥有父游戏的全部 DLC（含未拥有），匹配 isOwned
        async function buildDlcListAsync() {
            const t0 = performance.now();
            const showFamilyShared = Host.getShowFamilyShared();
            const allOwned = Host.getOwnedGames();
            const pool = showFamilyShared ? allOwned : allOwned.filter(g => Host.isGameOwnedByMe(g));

            // v1.9.4: 构建 appid → ownedGame 映射，用于匹配已拥有 DLC 和父游戏名称
            const ownedMap = {};
            pool.forEach(g => { ownedMap[String(g.appid)] = g; });
            // v1.9.11: 预构建 parentAppId → name 映射(O(1)查找),替代 dlcLookupParentName 的 O(n) 线性扫描
            // 71371 DLC × 10891 games 线性扫描 = ~7.8亿次比较,导致 buildDlcListAsync 永远无法完成
            const parentNameMap = {};
            allOwned.forEach(g => { if (g && g.appid) parentNameMap[String(g.appid)] = g.name; });

            // v1.9.4: 获取父游戏→DLC列表 反向映射（Host.getDlcsByParentMap）
            const dlcsByParent = (typeof Host.getDlcsByParentMap === 'function') ? Host.getDlcsByParentMap() : {};
            const parentKeys = Object.keys(dlcsByParent);

            // 收集所有需要处理的 DLC appid（全量 = 所有已知 DLC）
            const allDlcAppIds = new Set();
            // 从父游戏反向映射收集
            for (const dlcIds of Object.values(dlcsByParent)) {
                for (const id of dlcIds) allDlcAppIds.add(id);
            }
            // 同时保留原有逻辑：已拥有且 isDlc 的也加入（可能有些 DLC 不在 Barter.vg 数据库）
            for (const g of pool) {
                if (Host.isDlc(g.appid)) allDlcAppIds.add(g.appid);
            }

            const dlcCandidates = Array.from(allDlcAppIds);
            console.log(`[SGLV-DLC] buildDlcListAsync — 库存池 ${pool.length} 款, 父游戏 ${parentKeys.length} 个, 全量 DLC ${dlcCandidates.length} 个 (含未拥有)`);

            const out = [];
            const CHUNK = 300;
            for (let i = 0; i < dlcCandidates.length; i += CHUNK) {
                const slice = dlcCandidates.slice(i, i + CHUNK);
                slice.forEach(appid => {
                    const owned = ownedMap[String(appid)];
                    const parentApp = Host.getDlcParent(appid);
                    let type = (dlcState.dlcTypeCache && dlcState.dlcTypeCache[appid]) || Host.getDlcType(appid) || 'dlc';
                    out.push({
                        appid,
                        name: owned ? owned.name : ('DLC ' + appid),
                        playtime: owned ? (owned.playtime || 0) : 0,
                        parentApp,
                        parentName: parentApp ? (parentNameMap[String(parentApp)] || null) : null,
                        type,
                        bundleCount: Host.getBundleCount(appid),
                        isOwned: !!owned,
                    });
                });
                // 每片后让出主线程——浏览器可处理 UI 事件（点击、滚动等）
                if (i + CHUNK < dlcCandidates.length) {
                    await new Promise(r => setTimeout(r, 0));
                }
            }
            dlcState.dlcs = out;
            // v1.9.8: 清除过滤缓存(dlcs 内容已变,需重算 filtered/sorted 结果)
            dlcState._filteredCache = null;
            dlcState._filteredCacheKey = null;
            const withParent = out.filter(d => d.parentApp).length;
            const withType = out.filter(d => d.type !== 'dlc').length;
            const withBundle = out.filter(d => d.bundleCount > 0).length;
            console.log(`[SGLV-DLC] buildDlcListAsync — 完成: ${out.length} 个 DLC, 父游戏=${withParent}, 子类型=${withType}, 进包=${withBundle}, 耗时 ${Math.round(performance.now() - t0)}ms`);
        }

        // 三级渐进加载: Barter.vg DLC DB → Steam 全库存 type → DLC 子类型
        // v1.9.1: L1 + L2 并行启动，任一完成立即 schedule buildDlcList + render（不阻塞 UI 进程）
        // v1.9.2: 四阶段加载——阶段 0 同步预热(IDB + 主脚本闭包),秒出;无缓存才走阶段 1+2+3 冷启
        //         L3 真正"只增不减"增量:只 enrich dlcTypeCache 里没有的 DLC
        // v1.9.8: 渐进式渲染——L1+L2 完成后立即 loaded=true 渲染数据,L3 后台异步获取子类型
        //         DLC 数据只增不减,缓存永久有效,支持增量更新;修复加载完成但一直显示加载中的问题
        async function loadDlcData(force) {
            if (dlcState.loading) {
                // v1.9.27: force 时重置可能卡死的 loading 标志
                if (!force) {
                    console.log('[SGLV-DLC] loadDlcData — 已在加载中, 跳过');
                    return;
                }
                console.log('[SGLV-DLC] loadDlcData — force 重置卡死的 loading 标志');
                dlcState.loading = false;
            }
            if (dlcState.loaded && !force) {
                console.log('[SGLV-DLC] loadDlcData — 已加载且非强制, 直接渲染');
                renderDlcSections();
                return;
            }
            const t0 = performance.now();
            console.log(`[SGLV-DLC] loadDlcData — 开始加载 (force=${!!force}, dlcState.loaded=${dlcState.loaded})`);
            dlcState.loading = true;
            dlcState.loadError = null;
            dlcState.stage = 0;
            dlcState.level1Done = false;
            dlcState.level2Done = false;
            dlcState.rebuildQueued = false;

            // ==================== 阶段 0: 同步预热(关键!) ====================
            // 1) IDB 永久缓存 → 立即填 dlcTypeCache(只增不减,即使主脚本 GM 缓存丢失也能秒返)
            // 2) Host.loadDlcDatabaseFromCacheSync → 同步填主脚本 dlcDbData / appTypeMap 闭包
            // 3) buildDlcListAsync → 立即 build(分片,非阻塞)
            // 4) 如果拿到数据(dlcState.dlcs.length > 0),直接 loaded=true → 秒出 UI
            // 5) 后台异步跑 L1+L2(刷新可能新增的 DLC)+ L3 增量 enrich
            try {
                await _ensureDlcTypeCacheLoaded();
                if (typeof Host.loadDlcDatabaseFromCacheSync === 'function') {
                    try { Host.loadDlcDatabaseFromCacheSync(); } catch (e) { /* noop */ }
                }
                await buildDlcListAsync();
                if (dlcState.dlcs.length > 0) {
                    dlcState.loaded = true;
                    dlcState.loading = false;
                    dlcState.stage = 0;
                    try { dlcState.parentTotalMap = Host.getParentDlcTotalMap() || {}; } catch (e) { dlcState.parentTotalMap = {}; }
                    renderDlcSections();
                    console.log(`[SGLV-DLC] 阶段 0 缓存命中,立即出 ${dlcState.dlcs.length} 个 DLC,耗时 ${Math.round(performance.now() - t0)}ms`);
                    // 后台异步刷新（不阻塞,fire-and-forget）
                    _backgroundDlcRefresh();
                    return;
                }
                console.log('[SGLV-DLC] 阶段 0 无缓存(dlcs=0),降级到阶段 1+2+3 冷启');
            } catch (e) {
                console.warn('[SGLV-DLC] 阶段 0 预热失败,降级到冷启:', e);
            }

            // ==================== 阶段 1+2: 冷启(无缓存场景) ====================
            dlcState.stage = 1;
            renderDlcSections();
            if (_StageProgress && typeof _StageProgress.ensure === 'function') {
                try { _StageProgress.ensure(); _StageProgress.setStage(1, 3, 'DLC'); } catch (e) { /* noop */ }
            }

            // ---- 工具:scheduleRebuild ----
            const scheduleRebuild = (reason) => {
                if (dlcState.rebuildQueued) return;
                dlcState.rebuildQueued = true;
                setTimeout(() => {
                    dlcState.rebuildQueued = false;
                    if (_collectionActiveTab !== 'dlc') return;
                    (async () => {
                        try {
                            const t = performance.now();
                            await buildDlcListAsync();
                            renderDlcSections();
                            console.log(`[SGLV-DLC] scheduleRebuild(${reason}) — dlcs=${dlcState.dlcs.length}, 渲染耗时 ${Math.round(performance.now() - t)}ms`);
                        } catch (e) {
                            console.warn('[SGLV-DLC] scheduleRebuild failed:', e);
                        }
                    })();
                }, 0);
            };

            try {
                // ==================== Level 1 ∥ Level 2 并行 ====================
                const p1 = (async () => {
                    const t1 = performance.now();
                    try {
                        await Host.loadDlcDatabase();
                        dlcState.level1Done = true;
                        console.log(`[SGLV-DLC] [Level 1/3] Barter.vg 就绪, 耗时 ${Math.round(performance.now() - t1)}ms`);
                        scheduleRebuild('L1-done');
                    } catch (e) {
                        console.warn('[SGLV-DLC] [Level 1/3] 失败:', e);
                    }
                })();
                const p2 = (async () => {
                    const t2 = performance.now();
                    try {
                        await Host.enrichOwnedAppTypes();
                        dlcState.level2Done = true;
                        dlcState.stage = 2;
                        if (_StageProgress) try { _StageProgress.setStage(2, 3, 'appType'); } catch (e) {}
                        console.log(`[SGLV-DLC] [Level 2/3] appType 就绪, 耗时 ${Math.round(performance.now() - t2)}ms`);
                        scheduleRebuild('L2-done');
                    } catch (e) {
                        console.warn('[SGLV-DLC] [Level 2/3] 失败:', e);
                    }
                })();
                await Promise.all([p1, p2]);

                // v1.9.8: L1+L2 完成后立即 build + 渐进式渲染(loaded=true),L3 后台异步
                dlcState.stage = 2;
                await buildDlcListAsync();
                try { dlcState.parentTotalMap = Host.getParentDlcTotalMap() || {}; } catch (e) { dlcState.parentTotalMap = {}; }

                // v1.9.8: 关键改变 — L1+L2 完成后立即标记 loaded=true,用户可以看到 DLC 列表
                // L3 (DLC 子类型) 在后台异步获取,不阻塞 UI
                dlcState.loaded = true;
                dlcState.loading = false;
                dlcState.page = 1;
                dlcState.stage = 0;
                if (_StageProgress) try { _StageProgress.hide(); } catch (e) {}
                renderDlcSections();
                console.log(`[SGLV-DLC] L1+L2 完成, 渐进式渲染 ${dlcState.dlcs.length} 个 DLC, 耗时 ${Math.round(performance.now() - t0)}ms`);

                // v1.9.8: L3 后台异步获取 DLC 子类型(fire-and-forget,不阻塞 UI)
                _backgroundDlcTypeEnrich();

            } catch (e) {
                dlcState.loadError = e.message || 'Load failed';
                console.warn(`[SGLV-DLC] loadDlcData — 加载失败: ${e.message}, 已耗时 ${Math.round(performance.now() - t0)}ms`, e);
                dlcState.loading = false;
                if (_StageProgress) try { _StageProgress.hide(); } catch (e) {}
                renderDlcSections();
            }
        }

        // v1.9.8: 后台 DLC 子类型增量获取 — L1+L2 完成后 fire-and-forget
        // 从 dlcTypeCache 中筛选未获取类型的 DLC,调用 Host.enrichDlcTypes 增量获取
        // 获取完成后 rebuild + re-render,更新 KPI 和卡片类型显示
        // DLC 数据只增不减,dlcTypeCache 永久缓存(IDB),支持增量更新
        async function _backgroundDlcTypeEnrich() {
            if (dlcState.dlcTypeEnriching) {
                console.log('[SGLV-DLC] [bg L3] 已在获取中, 跳过');
                return;
            }
            const dlcIds = dlcState.dlcs.map(d => d.appid);
            if (dlcIds.length === 0) return;

            // 增量:只获取 dlcTypeCache 中没有的 DLC
            const dlcIdsToEnrich = dlcIds.filter(id => !dlcState.dlcTypeCache[id]);
            if (dlcIdsToEnrich.length === 0) {
                console.log(`[SGLV-DLC] [bg L3] 跳过: 全部 ${dlcIds.length} 个 DLC 已在本地 IDB 缓存中`);
                return;
            }

            dlcState.dlcTypeEnriching = true;
            const t3 = performance.now();
            console.log(`[SGLV-DLC] [bg L3] 增量 enrich ${dlcIdsToEnrich.length}/${dlcIds.length} 个 DLC（命中 ${dlcIds.length - dlcIdsToEnrich.length}）`);
            try {
                // v2.9.68: 使用 onProgress 回调实现渐进式 re-render
                let renderTimer = null;
                await Host.enrichDlcTypes(dlcIdsToEnrich, {
                    onProgress: (done, total) => {
                        // 节流渲染:每 1.5s 最多刷新一次 UI
                        if (!renderTimer) {
                            renderTimer = setTimeout(() => {
                                renderTimer = null;
                                if (_collectionActiveTab !== 'dlc') return;
                                (async () => {
                                    try {
                                        // 从主脚本拉取已获取的类型,合并到 dlcTypeCache
                                        let newCount = 0;
                                        for (const id of dlcIdsToEnrich) {
                                            const t = Host.getDlcType(id);
                                            if (t && !dlcState.dlcTypeCache[id]) {
                                                dlcState.dlcTypeCache[id] = t;
                                                newCount++;
                                            }
                                        }
                                        if (newCount > 0) {
                                            _persistDlcTypeCache();
                                            // 清除过滤缓存,让新类型生效
                                            dlcState._filteredCache = null;
                                            dlcState._filteredCacheKey = null;
                                            await buildDlcListAsync();
                                            renderDlcSections();
                                        }
                                    } catch (e) { /* noop */ }
                                })();
                            }, 1500);
                        }
                    }
                });

                // 最终:拉取所有类型,rebuild + re-render
                let newCount = 0;
                for (const id of dlcIdsToEnrich) {
                    const t = Host.getDlcType(id);
                    if (t && !dlcState.dlcTypeCache[id]) {
                        dlcState.dlcTypeCache[id] = t;
                        newCount++;
                    }
                }
                if (newCount > 0) {
                    _persistDlcTypeCache();
                    dlcState._filteredCache = null;
                    dlcState._filteredCacheKey = null;
                    await buildDlcListAsync();
                }
                try { dlcState.parentTotalMap = Host.getParentDlcTotalMap() || {}; } catch (e) {}
                if (_collectionActiveTab === 'dlc') renderDlcSections();
                console.log(`[SGLV-DLC] [bg L3] 增量完成: 新增 ${newCount} 个 type, 累计 ${Object.keys(dlcState.dlcTypeCache).length} 个, 耗时 ${Math.round(performance.now() - t3)}ms`);
            } catch (e) {
                console.warn('[SGLV-DLC] [bg L3] 失败:', e);
            } finally {
                dlcState.dlcTypeEnriching = false;
            }
        }

        // v1.9.2: 后台异步刷新——阶段 0 缓存命中后,fire-and-forget 跑 L1+L2 + L3 增量
        // v1.9.3: 节流（6h）——避免短时间内重复刷新
        // 目标:在不阻塞 UI 的前提下,让 dlcTypeCache 持续累计(只增不减,后续秒返)
        async function _backgroundDlcRefresh() {
            // v1.9.3: 节流——6h 内已刷过则跳过（多次打开 DLC tab 不会重复跑）
            if (Date.now() - (dlcState.lastBgRefreshAt || 0) < _DLC_BG_REFRESH_INTERVAL) {
                console.log(`[SGLV-DLC] 后台刷新跳过(节流): 上次 ${new Date(dlcState.lastBgRefreshAt).toLocaleString()}`);
                return;
            }
            dlcState.lastBgRefreshAt = Date.now();
            const tb = performance.now();
            try {
                // L1 ∥ L2 并行(主脚本缓存命中时秒返,否则走网络)
                const p1 = Host.loadDlcDatabase()
                    .then(() => { dlcState.level1Done = true; })
                    .catch(e => console.warn('[SGLV-DLC] [bg L1] 失败:', e));
                const p2 = Host.enrichOwnedAppTypes()
                    .then(() => { dlcState.level2Done = true; })
                    .catch(e => console.warn('[SGLV-DLC] [bg L2] 失败:', e));
                await Promise.all([p1, p2]);
                console.log(`[SGLV-DLC] [bg] L1+L2 完成, 耗时 ${Math.round(performance.now() - tb)}ms`);

                // 重建(可能新增 DLC)
                await buildDlcListAsync();
                dlcState._filteredCache = null;
                dlcState._filteredCacheKey = null;
                if (_collectionActiveTab === 'dlc') renderDlcSections();

                // v1.9.8: L3 增量 enrich 委托给 _backgroundDlcTypeEnrich(复用渐进式渲染逻辑)
                await _backgroundDlcTypeEnrich();

                console.log(`[SGLV-DLC] 后台刷新完成, 总耗时 ${Math.round(performance.now() - tb)}ms`);
            } catch (e) {
                console.warn('[SGLV-DLC] 后台刷新失败:', e);
            }
        }

        // 筛选 + 排序后的扁平 DLC 列表
        // v1.9.8: 缓存结果——当 dlcs/search/typeFilter/ownFilter/sort 未变时跳过重算,减少点击卡顿
        function getFilteredDlc() {
            const cacheKey = `${dlcState.dlcs.length}|${dlcState.search}|${dlcState.typeFilter}|${dlcState.ownFilter}|${dlcState.sort}`;
            if (dlcState._filteredCacheKey === cacheKey && dlcState._filteredCache) {
                return dlcState._filteredCache;
            }
            const q = dlcState.search.toLowerCase().trim();
            let list = dlcState.dlcs.slice();
            if (q) {
                list = list.filter(d => {
                    if (String(d.appid).includes(q)) return true;
                    if ((d.name || '').toLowerCase().includes(q)) return true;
                    if (d.parentName && d.parentName.toLowerCase().includes(q)) return true;
                    return false;
                });
            }
            if (dlcState.typeFilter === 'dlc') list = list.filter(d => d.type === 'dlc');
            else if (dlcState.typeFilter === 'music') list = list.filter(d => d.type === 'music');
            else if (dlcState.typeFilter === 'bundled') list = list.filter(d => d.bundleCount > 0);
            else if (dlcState.typeFilter === 'played') list = list.filter(d => d.playtime > 0);
            // v1.9.4: 已拥有筛选
            if (dlcState.ownFilter === 'owned') list = list.filter(d => d.isOwned);

            // v1.9.5: 使用缓存的 _nameCollator，避免每次渲染重新构造
            // v1.9.13: 激进防御——sort 出错时降级为 appid 排序,绝不抛异常中断渲染
            try {
                list.sort((a, b) => {
                    let r = 0;
                    switch (dlcState.sort) {
                        case 'appidAsc': r = a.appid - b.appid; break;
                        case 'appidDesc': r = b.appid - a.appid; break;
                        case 'nameAsc': r = _nameCollator.compare(a.name || '~', b.name || '~') || (a.appid - b.appid); break;
                        case 'typeAsc': r = (a.type || 'z').localeCompare(b.type || 'z') || (a.appid - b.appid); break;
                        case 'parentAsc':
                        default:
                            r = _nameCollator.compare(a.parentName || a.parentApp || '~', b.parentName || b.parentApp || '~') || (a.appid - b.appid);
                    }
                    return r || (a.appid - b.appid);
                });
            } catch (sortErr) {
                console.warn('[SGLV-DLC] getFilteredDlc sort 失败,降级 appid 排序:', sortErr);
                list.sort((a, b) => a.appid - b.appid);
            }
            // v1.9.8: 缓存结果
            dlcState._filteredCache = list;
            dlcState._filteredCacheKey = cacheKey;
            return list;
        }

        // 按父游戏分组（用于分组视图）
        function getGroupedDlc(filtered) {
            const groups = {};
            const noParent = [];
            filtered.forEach(d => {
                if (d.parentApp) {
                    const key = String(d.parentApp);
                    if (!groups[key]) groups[key] = { parentApp: d.parentApp, parentName: d.parentName, dlcs: [] };
                    groups[key].dlcs.push(d);
                } else {
                    noParent.push(d);
                }
            });
            let groupList = Object.values(groups);
            // v1.9.5: 使用缓存的 _nameCollator
            // v1.9.13: 激进防御——sort 出错时降级为不排序
            try {
                groupList.sort((a, b) => _nameCollator.compare(a.parentName || String(a.parentApp), b.parentName || String(b.parentApp)));
            } catch (sortErr) {
                console.warn('[SGLV-DLC] getGroupedDlc sort 失败,跳过排序:', sortErr);
            }
            if (noParent.length > 0) {
                groupList.push({ parentApp: null, parentName: Host.T.dlcUnknownParent, dlcs: noParent });
            }
            // 计算完成度（v1.9.4: ownedDlc 只统计已拥有，totalDlc 为全部已知 DLC）
            groupList.forEach(g => {
                g.totalDlc = g.dlcs.length;
                g.ownedDlc = g.dlcs.filter(d => d.isOwned).length;
                g.pct = g.totalDlc > 0 ? Math.round(g.ownedDlc / g.totalDlc * 100) : 100;
            });
            return groupList;
        }

        function renderDlcTab(parent) {
            const wrap = document.createElement('div');
            wrap.className = 'sglv-psplus-wrap';

            const kpi = document.createElement('div');
            kpi.id = 'sglv-dlc-kpi';
            wrap.appendChild(kpi);

            const toolbar = document.createElement('div');
            toolbar.className = 'sglv-toolbar';
            const sortOptions = [
                { key: 'parentAsc', label: Host.T.dlcSortParent },
                { key: 'appidDesc', label: Host.T.dlcSortAppidDesc },
                { key: 'appidAsc', label: Host.T.dlcSortAppidAsc },
                { key: 'nameAsc', label: Host.T.dlcSortNameAsc },
                { key: 'typeAsc', label: Host.T.dlcSortType },
            ];
            // v1.9.1: groupMode=true 时视图按钮置灰（分组视图天然是 card 布局,viewMode 概念对它无意义）
            const viewToggleDisabledCls = dlcState.groupMode ? ' sglv-view-disabled' : '';
            toolbar.innerHTML = `
                <input class="sglv-search" aria-label="搜索" id="sglv-dlc-search" placeholder="${Host.T.dlcSearch}" value="${Host.wlEscape(dlcState.search)}">
                <select class="sglv-sort-select" aria-label="排序方式" id="sglv-dlc-sort">
                    ${sortOptions.map(o => `<option value="${o.key}"${dlcState.sort === o.key ? ' selected' : ''}>${o.label}</option>`).join('')}
                </select>
                <div class="sglv-view-toggle${viewToggleDisabledCls}">
                    <button class="sglv-btn sglv-btn-secondary sglv-btn-icon${dlcState.viewMode === 'card' ? ' active' : ''}" id="sglv-dlc-card" title="${Host.T.cardView}">${Host.ICONS.grid}</button>
                    <button class="sglv-btn sglv-btn-secondary sglv-btn-icon${dlcState.viewMode === 'cover' ? ' active' : ''}" id="sglv-dlc-cover" title="${Host.T.coverView}">${Host.ICONS.cover}</button>
                    <button class="sglv-btn sglv-btn-secondary sglv-btn-icon${dlcState.viewMode === 'list' ? ' active' : ''}" id="sglv-dlc-list" title="${Host.T.listView}">${Host.ICONS.list}</button>
                </div>
                <div class="sglv-toolbar-sep"></div>
                <div class="sglv-dlc-own-filter">
                    <button class="sglv-btn sglv-btn-secondary${dlcState.ownFilter === 'all' ? ' active' : ''}" id="sglv-dlc-own-all">${Host.isZh ? '全部' : 'All'}</button>
                    <button class="sglv-btn sglv-btn-secondary${dlcState.ownFilter === 'owned' ? ' active' : ''}" id="sglv-dlc-own-owned">${Host.isZh ? '已拥有' : 'Owned'}</button>
                </div>
                <div class="sglv-dlc-group-toggle">
                    <button class="sglv-btn sglv-btn-secondary${dlcState.groupMode ? ' active' : ''}" id="sglv-dlc-grouped">${Host.T.dlcGroupByParent}</button>
                    <button class="sglv-btn sglv-btn-secondary${!dlcState.groupMode ? ' active' : ''}" id="sglv-dlc-flat">${Host.T.dlcFlatList}</button>
                </div>
                <div class="sglv-pagination" id="sglv-dlc-pagination"></div>
            `;
            wrap.appendChild(toolbar);

            const content = document.createElement('div');
            content.className = 'sglv-content';
            content.id = 'sglv-dlc-content';
            wrap.appendChild(content);

            parent.appendChild(wrap);

            // 事件绑定
            toolbar.querySelector('#sglv-dlc-search').addEventListener('input', _debounce((e) => {
                dlcState.search = e.target.value;
                dlcState.page = 1;
                renderDlcGamesList();
            }, 200));
            toolbar.querySelector('#sglv-dlc-sort').addEventListener('change', (e) => {
                dlcState.sort = e.target.value;
                dlcState.page = 1;
                renderDlcGamesList();
            });
            const setDlcViewMode = (mode) => {
                // v1.9.1: groupMode=true 时视图按钮被禁用,直接返回（双保险,防止 pointer-events bypass）
                if (dlcState.groupMode) return;
                dlcState.viewMode = mode;
                ['card', 'cover', 'list'].forEach(m => {
                    toolbar.querySelector('#sglv-dlc-' + m)?.classList.toggle('active', m === mode);
                });
                renderDlcGamesList();
            };
            toolbar.querySelector('#sglv-dlc-card').addEventListener('click', () => setDlcViewMode('card'));
            toolbar.querySelector('#sglv-dlc-cover').addEventListener('click', () => setDlcViewMode('cover'));
            toolbar.querySelector('#sglv-dlc-list').addEventListener('click', () => setDlcViewMode('list'));
            // v1.9.4: 已拥有筛选切换
            const setDlcOwnFilter = (filter) => {
                dlcState.ownFilter = filter;
                dlcState.page = 1;
                toolbar.querySelector('#sglv-dlc-own-all')?.classList.toggle('active', filter === 'all');
                toolbar.querySelector('#sglv-dlc-own-owned')?.classList.toggle('active', filter === 'owned');
                renderDlcGamesList();
            };
            toolbar.querySelector('#sglv-dlc-own-all').addEventListener('click', () => setDlcOwnFilter('all'));
            toolbar.querySelector('#sglv-dlc-own-owned').addEventListener('click', () => setDlcOwnFilter('owned'));
            // v1.9.1: 统一 grouped/flat 切换逻辑,同步视图按钮置灰状态
            const applyDlcGroupMode = (grouped) => {
                dlcState.groupMode = grouped;
                dlcState.page = 1;
                toolbar.querySelector('#sglv-dlc-grouped').classList.toggle('active', grouped);
                toolbar.querySelector('#sglv-dlc-flat').classList.toggle('active', !grouped);
                toolbar.querySelector('.sglv-view-toggle')?.classList.toggle('sglv-view-disabled', grouped);
                renderDlcGamesList();
            };
            toolbar.querySelector('#sglv-dlc-grouped').addEventListener('click', () => applyDlcGroupMode(true));
            toolbar.querySelector('#sglv-dlc-flat').addEventListener('click', () => applyDlcGroupMode(false));
            // KPI 卡片点击筛选
            kpi.addEventListener('click', e => {
                const card = e.target.closest('[data-dlc-filter]');
                if (!card) return;
                const f = card.dataset.dlcFilter;
                dlcState.typeFilter = dlcState.typeFilter === f ? 'all' : f;
                dlcState.page = 1;
                renderDlcKpi();
                renderDlcGamesList();
            });

            // v1.9.3: 用户点击 tab 立即进入——先无条件渲染骨架（KPI + content 都是 skeleton）
            // 后台 loadDlcData 完成后再 renderDlcSections() 替换为真实数据
            // 这样无论冷启/热数据都能"秒进"
            renderDlcSections();
            if (!dlcState.loaded && !dlcState.loading) {
                // fire-and-forget：后台加载，不阻塞 UI
                loadDlcData();
            }
        }

        function renderDlcSections() {
            if (_collectionActiveTab !== 'dlc' || !document.getElementById('sglv-dlc-content')) return;
            // v1.9.13: 激进防御——任何渲染异常都不应中断 loadDlcData 流程
            try {
                renderDlcKpi();
                renderDlcGamesList();
            } catch (e) {
                console.warn('[SGLV-DLC] renderDlcSections 渲染异常(已降级):', e);
                const content = document.getElementById('sglv-dlc-content');
                if (content && !content.innerHTML.trim()) {
                    content.innerHTML = '<div class="sglv-empty">' + (Host.isZh ? 'DLC 渲染异常,数据已加载,请尝试切换排序或刷新页面' : 'DLC render error, data loaded. Try switching sort or refresh') + '</div>';
                }
            }
        }

        // v1.9.1: 阶段进度条 + DLC 卡片骨架 HTML 工厂
        // 用于 loading 状态：KPI 区 5 个 shimmer 卡 + content 区阶段条 + 12 个 card 占位
        // 数据稳定（loaded=true）前不展示真实 KPI 数字，避免数字跳变
        // v1.9.4: spinner 加载等待动画（参考 steam-friend-manager 的 spinner 风格）
        // v2.9.67: 修复 wlEscape 三元表达式 bug（两分支都调用了 Host.wlEscape）
        function renderDlcLoadingHtml() {
            const stage = DLC_STAGES[dlcState.stage] || { pct: 30, zh: '加载中…', en: 'Loading…' };
            const pct = stage.pct;
            const text = Host && Host.isZh ? stage.zh : stage.en;
            const safeText = Host && Host.wlEscape ? Host.wlEscape(text) : text;
            const spinSvg = '<svg class="sglv-dlc-spin" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M21 12a9 9 0 1 1-6.219-8.56"/></svg>';
            return `<div class="sglv-dlc-loading">
                ${spinSvg}
                <div class="sglv-dlc-loading-text">${safeText}</div>
                <div class="sglv-dlc-loading-bar"><div class="sglv-dlc-loading-bar-fill" style="width:${pct}%"></div></div>
                <div class="sglv-dlc-loading-sub">${Host && Host.isZh ? '正在加载所有已知 DLC 数据…' : 'Loading all known DLC data…'}</div>
            </div>`;
        }
        function renderDlcKpiSkeletonHtml() {
            const skel = '<div class="sglv-skel-line lg"></div><div class="sglv-skel-line md"></div><div class="sglv-skel-line sm"></div>';
            const cards = Array.from({ length: 5 }, () => `<div class="sglv-trend-kpi-card skeleton">${skel}</div>`).join('');
            return `<div class="sglv-trend-kpi-row">${cards}</div>`;
        }

        function renderDlcKpi() {
            const el = document.getElementById('sglv-dlc-kpi');
            if (!el) return;
            // v1.9.1: 加载中 / 未加载完成统一显示骨架（数字会跳变，体验差）
            if (dlcState.loading || !dlcState.loaded) {
                el.innerHTML = renderDlcKpiSkeletonHtml();
                return;
            }
            const total = dlcState.dlcs.length;
            const owned = dlcState.dlcs.filter(d => d.isOwned).length;
            const regular = dlcState.dlcs.filter(d => d.type === 'dlc').length;
            const music = dlcState.dlcs.filter(d => d.type === 'music').length;
            const bundled = dlcState.dlcs.filter(d => d.bundleCount > 0).length;
            const played = dlcState.dlcs.filter(d => d.playtime > 0).length;
            const parentCount = new Set(dlcState.dlcs.filter(d => d.parentApp).map(d => String(d.parentApp))).size;
            const noParent = dlcState.dlcs.filter(d => !d.parentApp).length;
            // v1.9.8: 后台子类型获取中时,在 KPI 区底部显示进度提示
            const enrichHint = dlcState.dlcTypeEnriching
                ? `<div style="text-align:center;padding:4px 0 2px;font-size:11px;color:var(--sglv-accent, #a78bfa);display:flex;align-items:center;justify-content:center;gap:6px">
                    <svg style="width:12px;height:12px;animation:sgc-spin 1s linear infinite" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M21 12a9 9 0 1 1-6.219-8.56"/></svg>
                    ${Host.isZh ? '后台获取 DLC 子类型中…' : 'Fetching DLC subtypes in background…'}
                  </div>`
                : '';
            const ownPct = total > 0 ? Math.round(owned / total * 100) : 0;
            const subText = Host.T.dlcKpiSub.replace('{n}', parentCount) + (noParent > 0 ? ' · ' + Host.T.dlcKpiNoParent + ' ' + noParent : '');
            el.innerHTML = `
                <div class="sglv-trend-kpi-row">
                    <div class="sglv-trend-kpi-card blue clickable${dlcState.typeFilter === 'all' ? ' active' : ''}" data-dlc-filter="all" title="${Host.isZh ? '点击筛选：全部' : 'Click to filter: All'}">
                        <div class="sglv-trend-kpi-header"><span class="sglv-trend-kpi-icon">${Host.ICONS.puzzle}</span><span class="sglv-trend-kpi-label">${Host.T.dlcKpiTotal}</span></div>
                        <div class="sglv-trend-kpi-value">${total.toLocaleString()}</div>
                        <div class="sglv-trend-kpi-sub">${subText}</div>
                        <div class="sglv-trend-kpi-sub" style="color:#4bb54f;font-weight:600">${Host.isZh ? '已拥有 ' + owned.toLocaleString() + ' (' + ownPct + '%)' : 'Owned ' + owned.toLocaleString() + ' (' + ownPct + '%)'}</div>
                    </div>
                    <div class="sglv-trend-kpi-card clickable${dlcState.typeFilter === 'dlc' ? ' active' : ''}" style="border-left:3px solid var(--sglv-accent-deep, #8b5cf6)" data-dlc-filter="dlc" title="${Host.isZh ? '点击筛选：常规 DLC' : 'Click to filter: Regular DLC'}">
                        <div class="sglv-trend-kpi-header"><span class="sglv-trend-kpi-icon" style="color:var(--sglv-accent, #a78bfa)">${Host.ICONS.package}</span><span class="sglv-trend-kpi-label">${Host.T.dlcKpiRegular}</span></div>
                        <div class="sglv-trend-kpi-value">${regular.toLocaleString()}</div>
                        <div class="sglv-trend-kpi-sub">type=1</div>
                    </div>
                    <div class="sglv-trend-kpi-card clickable${dlcState.typeFilter === 'music' ? ' active' : ''}" style="border-left:3px solid #22a5f7" data-dlc-filter="music" title="${Host.isZh ? '点击筛选：音乐包' : 'Click to filter: Music'}">
                        <div class="sglv-trend-kpi-header"><span class="sglv-trend-kpi-icon" style="color:#22a5f7">${Host.ICONS.tag}</span><span class="sglv-trend-kpi-label">${Host.T.dlcKpiMusic}</span></div>
                        <div class="sglv-trend-kpi-value">${music.toLocaleString()}</div>
                        <div class="sglv-trend-kpi-sub">type=6</div>
                    </div>
                    <div class="sglv-trend-kpi-card clickable${dlcState.typeFilter === 'bundled' ? ' active' : ''}" style="border-left:3px solid #f59e0b" data-dlc-filter="bundled" title="${Host.isZh ? '点击筛选：进包 DLC' : 'Click to filter: Bundled'}">
                        <div class="sglv-trend-kpi-header"><span class="sglv-trend-kpi-icon" style="color:#f59e0b">${Host.ICONS.package}</span><span class="sglv-trend-kpi-label">${Host.T.dlcKpiBundled}</span></div>
                        <div class="sglv-trend-kpi-value">${bundled.toLocaleString()}</div>
                        <div class="sglv-trend-kpi-sub">${Host.isZh ? '含 Bundle' : 'In Bundles'}</div>
                    </div>
                    <div class="sglv-trend-kpi-card clickable${dlcState.typeFilter === 'played' ? ' active' : ''}" style="border-left:3px solid #4bb54f" data-dlc-filter="played" title="${Host.isZh ? '点击筛选：已游玩' : 'Click to filter: Played'}">
                        <div class="sglv-trend-kpi-header"><span class="sglv-trend-kpi-icon" style="color:#4bb54f">${Host.ICONS.trend}</span><span class="sglv-trend-kpi-label">${Host.T.dlcKpiPlayed}</span></div>
                        <div class="sglv-trend-kpi-value">${played.toLocaleString()}</div>
                        <div class="sglv-trend-kpi-sub">playtime&gt;0</div>
                    </div>
                </div>
                ${enrichHint}
            `;
        }

        // v1.9.1: 大网格 rAF 分片 append，避免一次性 innerHTML 写入上千卡片卡顿
        // 用 DocumentFragment 多次 append，rAF 让出浏览器绘制
        const _DLC_RENDER_CHUNK = 24;   // 每片卡片数
        const _DLC_RENDER_RAF_THRESHOLD = 30;  // 超过此数才走分片（少量直接 innerHTML 更快）
        function appendDlcCardsChunked(grid, htmls, done) {
            if (!grid || !htmls || htmls.length === 0) { if (done) done(); return; }
            if (htmls.length <= _DLC_RENDER_RAF_THRESHOLD || typeof requestAnimationFrame !== 'function') {
                grid.innerHTML = htmls.join('');
                if (done) done();
                return;
            }
            let i = 0;
            const total = htmls.length;
            const step = () => {
                const frag = document.createDocumentFragment();
                const t0 = performance.now();
                const end = Math.min(i + _DLC_RENDER_CHUNK, total);
                for (; i < end; i++) {
                    const tpl = document.createElement('template');
                    tpl.innerHTML = htmls[i].trim();
                    const node = tpl.content.firstChild;
                    if (node) frag.appendChild(node);
                }
                grid.appendChild(frag);
                if (i < total) {
                    // 切片之间让出主线程：rAF 等同 16ms，若耗时 > 12ms 也强制让出
                    if (performance.now() - t0 > 12) {
                        setTimeout(step, 0);
                    } else {
                        requestAnimationFrame(step);
                    }
                } else {
                    if (done) done();
                }
            };
            step();
        }

        function renderDlcGamesList() {
            const content = document.getElementById('sglv-dlc-content');
            if (!content) return;
            const clearPagination = () => { const p = document.getElementById('sglv-dlc-pagination'); if (p) p.innerHTML = ''; };

            // v1.9.4: loading 阶段显示 spinner 加载动画（参考 steam-friend-manager 风格）
            // v2.9.67: 尚未加载(!loaded && !loading)时也显示加载动画,避免首次进入空白
            if (dlcState.loading || (!dlcState.loaded && !dlcState.loadError)) {
                content.innerHTML = renderDlcLoadingHtml();
                clearPagination();
                return;
            }
            if (dlcState.loadError) {
                content.innerHTML = '<div class="sglv-empty">' + Host.T.dlcLoadError + '</div>';
                clearPagination();
                return;
            }
            if (!dlcState.loaded || dlcState.dlcs.length === 0) {
                content.innerHTML = '<div class="sglv-empty">' + Host.T.dlcNoData + '</div>';
                clearPagination();
                return;
            }

            // v1.9.13: 激进防御——getFilteredDlc 出错时降级为未排序原始列表,绝不白屏
            let list;
            try {
                list = getFilteredDlc();
            } catch (e) {
                console.warn('[SGLV-DLC] getFilteredDlc 异常,降级未排序列表:', e);
                list = dlcState.dlcs.slice();
            }
            if (list.length === 0) {
                content.innerHTML = '<div class="sglv-empty">' + (Host.isZh ? '无匹配结果' : 'No matching results') + '</div>';
                clearPagination();
                return;
            }

            // 分组视图
            if (dlcState.groupMode) {
                let groups;
                try {
                    groups = getGroupedDlc(list);
                } catch (e) {
                    console.warn('[SGLV-DLC] getGroupedDlc 异常,降级扁平视图:', e);
                    dlcState.groupMode = false;
                    groups = null;
                }
                if (groups) {
                    const { pageItems, totalPages, page: _clampedPage } = Host.paginate(groups, dlcState.page, dlcState.pageSize);
                    dlcState.page = _clampedPage;
                    renderDlcGrouped(content, pageItems);
                    const pagination = document.getElementById('sglv-dlc-pagination');
                    if (pagination) {
                        // v1.9.47-fix: 补 onJump——DLC 翻页 5 个按钮全部走 onJump
                        Host.renderPagination(pagination, 'sglv-dlc', dlcState.page, totalPages, groups.length,
                            () => { dlcState.page--; renderDlcGamesList(); },
                            () => { dlcState.page++; renderDlcGamesList(); },
                            (p) => { dlcState.page = p; renderDlcGamesList(); });
                    }
                    return;
                }
            }

            // 扁平视图
            const { pageItems, totalPages, page: _clampedPage } = Host.paginate(list, dlcState.page, dlcState.pageSize);
            dlcState.page = _clampedPage;

            // v1.9.1: 先建空 grid 容器，再 rAF 分片 append（避免上千卡片 innerHTML 解析卡顿）
            let gridClass = 'sglv-card-grid';
            let cardHtmls;
            if (dlcState.viewMode === 'card') {
                gridClass = 'sglv-card-grid';
                cardHtmls = pageItems.map(d => {
                    const clickUrl = 'https://store.steampowered.com/app/' + d.appid;
                    const badges = dlcOwnedBadgeHtml(d.isOwned) + dlcTypeBadgeHtml(d.type) + dlcBundleBadgeHtml(d.bundleCount) + dlcPlayedBadgeHtml(d.playtime);
                    const dimCls = d.isOwned ? '' : ' sglv-dlc-not-owned';
                    return '<div class="sglv-game-card' + dimCls + '" data-appid="' + d.appid + '" onclick="window.open(\'' + clickUrl + '\',\'_blank\')">' +
                        '<div class="sglv-card-img-wrap">' + dlcPosterImg(d.appid, d.name) + '</div>' +
                        '<div class="sglv-card-body">' +
                            '<div class="sglv-card-name" title="' + Host.wlEscape(d.name) + '">' + Host.wlEscape(d.name) + '</div>' +
                            '<div class="sglv-card-id">AppID: ' + d.appid + '</div>' +
                            '<div class="sglv-badge-row">' + badges + '</div>' +
                            (d.parentName ? '<div class="sglv-card-id" style="margin-top:2px">' + Host.wlEscape(d.parentName) + '</div>' : '') +
                        '</div>' +
                    '</div>';
                });
            } else if (dlcState.viewMode === 'cover') {
                gridClass = 'sglv-wl-cover-grid';
                cardHtmls = pageItems.map(d => {
                    const clickUrl = 'https://store.steampowered.com/app/' + d.appid;
                    const badges = dlcOwnedBadgeHtml(d.isOwned) + dlcTypeBadgeHtml(d.type) + dlcBundleBadgeHtml(d.bundleCount) + dlcPlayedBadgeHtml(d.playtime);
                    const dimCls = d.isOwned ? '' : ' sglv-dlc-not-owned';
                    return '<div class="sglv-wl-cover-card' + dimCls + '" data-appid="' + d.appid + '" onclick="window.open(\'' + clickUrl + '\',\'_blank\')">' +
                        '<div class="sglv-wl-cover-img-wrap">' + dlcCapsuleImg(d.appid, d.name) + '</div>' +
                        '<div class="sglv-wl-cover-body">' +
                            '<div class="sglv-card-name" title="' + Host.wlEscape(d.name) + '">' + Host.wlEscape(d.name) + ' <span class="sglv-card-id-inline">' + d.appid + '</span></div>' +
                            '<div class="sglv-info-row sglv-wl-price-row">' + badges + '</div>' +
                        '</div>' +
                    '</div>';
                });
            } else {
                gridClass = 'sglv-list-view';
                cardHtmls = pageItems.map(d => {
                    const clickUrl = 'https://store.steampowered.com/app/' + d.appid;
                    const iconHtml = '<img class="sglv-list-icon" src="' + Host.getGameIconUrl(d.appid, '') + '" alt="' + Host.wlEscape(d.name) + '" loading="lazy" decoding="async" onerror="this.style.display=\'none\'">';
                    const badges = dlcOwnedBadgeHtml(d.isOwned) + dlcTypeBadgeHtml(d.type) + dlcBundleBadgeHtml(d.bundleCount) + dlcPlayedBadgeHtml(d.playtime);
                    const dimCls = d.isOwned ? '' : ' sglv-dlc-not-owned';
                    return '<div class="sglv-list-item' + dimCls + '" data-appid="' + d.appid + '" onclick="window.open(\'' + clickUrl + '\',\'_blank\')">' +
                        iconHtml +
                        '<div class="sglv-list-info">' +
                            '<div class="sglv-list-name">' + Host.wlEscape(d.name) + ' <span class="sglv-card-id-inline">' + d.appid + '</span></div>' +
                            '<div class="sglv-list-meta">' + badges + (d.parentName ? ' · ' + Host.wlEscape(d.parentName) : '') + '</div>' +
                        '</div>' +
                    '</div>';
                });
            }
            content.innerHTML = `<div class="${gridClass}" id="sglv-dlc-grid"></div>`;
            const grid = document.getElementById('sglv-dlc-grid');
            appendDlcCardsChunked(grid, cardHtmls);

            const pagination = document.getElementById('sglv-dlc-pagination');
            if (pagination) {
                // v1.9.47-fix: 补 onJump——DLC 翻页 5 个按钮全部走 onJump
                Host.renderPagination(pagination, 'sglv-dlc', dlcState.page, totalPages, list.length,
                    () => { dlcState.page--; renderDlcGamesList(); },
                    () => { dlcState.page++; renderDlcGamesList(); },
                    (p) => { dlcState.page = p; renderDlcGamesList(); });
            }
        }

        // 分组视图渲染：父游戏折叠头 + DLC 卡片子网格
        // v1.9.1: group 头一次性 innerHTML 写入（数量小），展开的 group 内卡片用 rAF 分片 append
        // 解决"几百个父游戏全展开 → 几千卡片 innerHTML 解析"卡死
        function renderDlcGrouped(content, groups) {
            // 1. 先构造所有 group 的外层骨架（头 + 空 card-row 占位），用 data-group-idx 关联
            const groupHtmls = groups.map((g, gi) => {
                const expanded = dlcState.expandedParents.has(String(g.parentApp));
                const arrow = expanded ? '▼' : '▶';
                return '<div class="sglv-dlc-group' + (expanded ? '' : ' collapsed') + '" data-group-idx="' + gi + '">' +
                    '<div class="sglv-dlc-group-head" data-parent="' + (g.parentApp || 'null') + '">' +
                        '<span class="sglv-dlc-arrow">' + arrow + '</span>' +
                        '<span class="sglv-dlc-pname" title="' + Host.wlEscape(g.parentName || String(g.parentApp)) + '">' + Host.wlEscape(g.parentName || String(g.parentApp)) + '</span>' +
                        '<span class="sglv-dlc-meta">' + g.ownedDlc + '/' + g.totalDlc + ' DLC</span>' +
                        '<span class="sglv-dlc-pct">' + g.pct + '%</span>' +
                    '</div>' +
                    (expanded ? '<div class="sglv-dlc-card-row"></div>' : '') +
                '</div>';
            });
            content.innerHTML = groupHtmls.join('');

            // 2. 绑定折叠/展开
            content.querySelectorAll('.sglv-dlc-group-head').forEach(head => {
                head.addEventListener('click', () => {
                    const p = head.dataset.parent;
                    if (dlcState.expandedParents.has(p)) dlcState.expandedParents.delete(p);
                    else dlcState.expandedParents.add(p);
                    renderDlcGamesList();
                });
            });

            // 3. 展开的 group：把 DLC 卡片 HTML 准备好，分片 append 到对应 card-row
            //    各 group 独立分片，互不阻塞（DOM 解析局部化）
            // v1.9.3: 横版封面布局，每行 4 列（替代原 8 列窄图）
            groups.forEach((g, gi) => {
                if (!dlcState.expandedParents.has(String(g.parentApp))) return;
                if (!g.dlcs || g.dlcs.length === 0) return;
                const cardHtmls = g.dlcs.map(d => {
                    const clickUrl = 'https://store.steampowered.com/app/' + d.appid;
                    const badges = dlcTypeBadgeHtml(d.type) + dlcBundleBadgeHtml(d.bundleCount) + dlcPlayedBadgeHtml(d.playtime);
                    return '<div class="sglv-wl-cover-card sglv-dlc-group-cover" data-appid="' + d.appid + '" onclick="window.open(\'' + clickUrl + '\',\'_blank\')">' +
                        '<div class="sglv-wl-cover-img-wrap">' + dlcCapsuleImg(d.appid, d.name) + '</div>' +
                        '<div class="sglv-wl-cover-body">' +
                            '<div class="sglv-card-name" title="' + Host.wlEscape(d.name) + '">' + Host.wlEscape(d.name) + ' <span class="sglv-card-id-inline">' + d.appid + '</span></div>' +
                            '<div class="sglv-info-row sglv-wl-price-row">' + badges + '</div>' +
                        '</div>' +
                    '</div>';
                });
                const row = content.querySelector('.sglv-dlc-group[data-group-idx="' + gi + '"] .sglv-dlc-card-row');
                if (row) appendDlcCardsChunked(row, cardHtmls);
            });
        }

        // ==================== 捆绑包标签页 (v1.9.14) ====================
        // 数据源: Host.getBundleCount(appid) — DLC 进包次数 (Barter.vg)
        //         Host.getDlcParent(appid) — DLC→父游戏 appID
        //         Host.getDlcsByParentMap() — 父游戏→DLC列表 反向映射
        // 展示: 已拥有游戏中,包含进包 DLC 的父游戏列表,以及直接进包的游戏

        // 构建捆绑包数据: 扫描所有已拥有父游戏的 DLC, 找出进包 DLC, 按父游戏分组
        function buildBundleData() {
            const t0 = performance.now();
            const allOwned = Host.getOwnedGames() || [];
            const showFamilyShared = Host.getShowFamilyShared();
            const pool = showFamilyShared ? allOwned : allOwned.filter(g => Host.isGameOwnedByMe(g));

            // 构建 appid → game 映射 (O(1) 查找游戏名称/拥有状态)
            const gameMap = {};
            pool.forEach(g => { if (g && g.appid) gameMap[String(g.appid)] = g; });
            // 全量 owned 用于查父游戏名称 (即使父游戏不在当前 pool)
            allOwned.forEach(g => { if (g && g.appid && !gameMap[String(g.appid)]) gameMap[String(g.appid)] = g; });

            const hasBundleCount = typeof Host.getBundleCount === 'function';
            const dlcsByParent = (typeof Host.getDlcsByParentMap === 'function') ? Host.getDlcsByParentMap() : {};
            const parentBundleMap = {};   // parentAppid → bundle item

            // 1. 遍历父游戏→DLC列表, 找出进包 DLC
            for (const [parentApp, dlcIds] of Object.entries(dlcsByParent)) {
                if (!Array.isArray(dlcIds)) continue;
                let totalBundle = 0;
                const bundledDlcs = [];
                for (const dlcId of dlcIds) {
                    const bc = hasBundleCount ? Host.getBundleCount(dlcId) : 0;
                    if (bc > 0) {
                        totalBundle += bc;
                        const dlcGame = gameMap[String(dlcId)];
                        bundledDlcs.push({
                            appid: dlcId,
                            name: dlcGame ? dlcGame.name : ('DLC ' + dlcId),
                            bundleCount: bc,
                            isOwned: !!dlcGame,
                            playtime: dlcGame ? (dlcGame.playtime || 0) : 0,
                        });
                    }
                }
                if (totalBundle > 0) {
                    const parentGame = gameMap[String(parentApp)];
                    parentBundleMap[parentApp] = {
                        appid: Number(parentApp),
                        name: parentGame ? parentGame.name : ('App ' + parentApp),
                        isOwned: !!parentGame && pool.some(g => String(g.appid) === String(parentApp)),
                        totalBundle: totalBundle,
                        dlcCount: bundledDlcs.length,
                        dlcs: bundledDlcs,
                    };
                }
            }

            // 2. 检查已拥有游戏本身是否也进包 (getBundleCount 对主游戏可能也有效)
            for (const g of pool) {
                if (!g || !g.appid) continue;
                const bc = hasBundleCount ? Host.getBundleCount(g.appid) : 0;
                if (bc <= 0) continue;
                const key = String(g.appid);
                if (!parentBundleMap[key]) {
                    // 主游戏直接进包, 且没有子 DLC 进包
                    parentBundleMap[key] = {
                        appid: g.appid,
                        name: g.name,
                        isOwned: true,
                        totalBundle: bc,
                        dlcCount: 0,
                        dlcs: [],
                    };
                } else {
                    // 主游戏既自身进包, 子 DLC 也进包——把本体作为第一条 DLC 记录
                    parentBundleMap[key].totalBundle += bc;
                    parentBundleMap[key].dlcs.unshift({
                        appid: g.appid,
                        name: g.name + ' ' + (Host.isZh ? '(本体)' : '(Base)'),
                        bundleCount: bc,
                        isOwned: true,
                        playtime: g.playtime || 0,
                    });
                    parentBundleMap[key].dlcCount++;
                }
            }

            // 按累计进包数降序作为默认排序
            bundleState.data = Object.values(parentBundleMap).sort((a, b) => b.totalBundle - a.totalBundle);
            bundleState.loaded = true;
            console.log(`[SGLV-Bundle] buildBundleData — ${bundleState.data.length} 个含进包游戏, 总进包 DLC ${bundleState.data.reduce((s, g) => s + g.dlcCount, 0)} 个, 耗时 ${Math.round(performance.now() - t0)}ms`);
        }

        // 过滤+排序
        function getFilteredBundle() {
            let list = bundleState.data.slice();
            // 搜索过滤 (游戏名 / appid / DLC名)
            if (bundleState.search) {
                const q = bundleState.search.toLowerCase();
                list = list.filter(item =>
                    String(item.name).toLowerCase().includes(q) ||
                    String(item.appid).includes(q) ||
                    item.dlcs.some(d => String(d.name).toLowerCase().includes(q))
                );
            }
            // 排序
            const sort = bundleState.sort;
            try {
                list.sort((a, b) => {
                    if (sort === 'bundleDesc') return b.totalBundle - a.totalBundle || b.dlcCount - a.dlcCount;
                    if (sort === 'bundleAsc') return a.totalBundle - b.totalBundle || a.dlcCount - b.dlcCount;
                    if (sort === 'nameAsc') return _nameCollator.compare(a.name, b.name);
                    if (sort === 'appidDesc') return b.appid - a.appid;
                    if (sort === 'appidAsc') return a.appid - b.appid;
                    return 0;
                });
            } catch (e) {
                // 降级: 按 appid 排序
                list.sort((a, b) => b.appid - a.appid);
            }
            return list;
        }

        // 渲染 KPI 卡片
        function renderBundleKpi() {
            const el = document.getElementById('sglv-bundle-kpi');
            if (!el) return;
            if (!bundleState.loaded) { el.innerHTML = ''; return; }
            const data = bundleState.data;
            const totalGames = data.length;
            const totalDlcs = data.reduce((s, g) => s + g.dlcCount, 0);
            const totalBundles = data.reduce((s, g) => s + g.totalBundle, 0);
            const ownedGames = data.filter(g => g.isOwned).length;
            const ownPct = totalGames > 0 ? Math.round(ownedGames / totalGames * 100) : 0;

            el.innerHTML = `
                <div class="sglv-trend-kpi-row">
                    <div class="sglv-trend-kpi-card blue">
                        <div class="sglv-trend-kpi-header"><span class="sglv-trend-kpi-icon">${Host.ICONS.package}</span><span class="sglv-trend-kpi-label">${Host.isZh ? '含进包游戏' : 'Games w/ Bundles'}</span></div>
                        <div class="sglv-trend-kpi-value">${totalGames.toLocaleString()}</div>
                        <div class="sglv-trend-kpi-sub" style="color:#4bb54f;font-weight:600">${Host.isZh ? '已拥有 ' + ownedGames.toLocaleString() + ' (' + ownPct + '%)' : 'Owned ' + ownedGames.toLocaleString() + ' (' + ownPct + '%)'}</div>
                    </div>
                    <div class="sglv-trend-kpi-card" style="border-left:3px solid #f59e0b">
                        <div class="sglv-trend-kpi-header"><span class="sglv-trend-kpi-icon" style="color:#f59e0b">${Host.ICONS.package}</span><span class="sglv-trend-kpi-label">${Host.isZh ? '进包 DLC' : 'Bundled DLCs'}</span></div>
                        <div class="sglv-trend-kpi-value">${totalDlcs.toLocaleString()}</div>
                        <div class="sglv-trend-kpi-sub">${Host.isZh ? '含 Bundle 标记' : 'In Bundles'}</div>
                    </div>
                    <div class="sglv-trend-kpi-card" style="border-left:3px solid #4bb54f">
                        <div class="sglv-trend-kpi-header"><span class="sglv-trend-kpi-icon" style="color:#4bb54f">${Host.ICONS.gift}</span><span class="sglv-trend-kpi-label">${Host.isZh ? '累计进包' : 'Total Bundle Entries'}</span></div>
                        <div class="sglv-trend-kpi-value">${totalBundles.toLocaleString()}</div>
                        <div class="sglv-trend-kpi-sub">${Host.isZh ? '所有 DLC 进包次数之和' : 'Sum of all bundle counts'}</div>
                    </div>
                </div>
            `;
        }

        // 渲染游戏列表 (卡片视图)
        function renderBundleList() {
            const content = document.getElementById('sglv-bundle-content');
            if (!content) return;
            const clearPagination = () => { const p = document.getElementById('sglv-bundle-pagination'); if (p) p.innerHTML = ''; };

            // 检查 DLC 数据库是否可用
            if (typeof Host.isDlcDbReady === 'function' && !Host.isDlcDbReady()) {
                content.innerHTML = '<div class="sglv-empty">' +
                    (Host.isZh ? 'DLC 数据库尚未加载，请先打开「DLC」标签页加载数据后返回。' : 'DLC database not loaded. Please open the "DLC" tab first to load data, then come back.') +
                    '</div>';
                clearPagination();
                return;
            }

            if (!bundleState.loaded || bundleState.data.length === 0) {
                content.innerHTML = '<div class="sglv-empty">' + (Host.isZh ? '暂无进包数据' : 'No bundle data available') + '</div>';
                clearPagination();
                return;
            }

            const list = getFilteredBundle();
            if (list.length === 0) {
                content.innerHTML = '<div class="sglv-empty">' + (Host.isZh ? '无匹配结果' : 'No matching results') + '</div>';
                clearPagination();
                return;
            }

            const { pageItems, totalPages, page: _clampedPage } = Host.paginate(list, bundleState.page, bundleState.pageSize);
            bundleState.page = _clampedPage;

            const bundleBadgeStyle = 'background:rgba(245,158,11,0.15);color:#fbbf24;border:1px solid rgba(245,158,11,0.25);font-size:10px;padding:2px 6px;border-radius:3px;font-weight:700';
            const dlcBadgeStyle = 'background:var(--sglv-accent-bg, rgba(167,139,250,0.15));color:var(--sglv-accent, #a78bfa);border:1px solid var(--sglv-accent-border, rgba(167,139,250,0.25));font-size:10px;padding:2px 6px;border-radius:3px;font-weight:700';

            content.innerHTML = '<div class="sglv-card-grid">' + pageItems.map(item => {
                const clickUrl = 'https://store.steampowered.com/app/' + item.appid;
                const bundleBadge = '<span class="sglv-badge" style="' + bundleBadgeStyle + '">📦' + item.totalBundle + '</span>';
                const dlcBadge = item.dlcCount > 0
                    ? '<span class="sglv-badge" style="' + dlcBadgeStyle + '">' + item.dlcCount + ' DLC</span>'
                    : '';
                const posterHtml = Host.posterImg(item.appid, item.name);

                // DLC 详情列表 (最多预览 5 条)
                let dlcListHtml = '';
                if (item.dlcs.length > 0) {
                    const preview = item.dlcs.slice(0, 5);
                    const moreCount = item.dlcs.length - preview.length;
                    dlcListHtml = '<div class="sglv-bundle-dlc-list">' +
                        preview.map(d => {
                            const dlcUrl = 'https://store.steampowered.com/app/' + d.appid;
                            return '<div class="sglv-bundle-dlc-item" onclick="event.stopPropagation();window.open(\'' + dlcUrl + '\',\'_blank\')" title="' + Host.wlEscape(d.name) + '">' +
                                '<span class="sglv-bundle-dlc-name">' + Host.wlEscape(d.name) + '</span>' +
                                '<span class="sglv-badge" style="' + bundleBadgeStyle + ';font-size:9px;padding:1px 5px">📦' + d.bundleCount + '</span>' +
                                '</div>';
                        }).join('') +
                        (moreCount > 0 ? '<div class="sglv-bundle-dlc-more">' + (Host.isZh ? '还有 ' + moreCount + ' 个…' : '+' + moreCount + ' more…') + '</div>' : '') +
                        '</div>';
                }

                return '<div class="sglv-game-card sglv-bundle-card" data-appid="' + item.appid + '" onclick="window.open(\'' + clickUrl + '\',\'_blank\')">' +
                    '<div class="sglv-card-img-wrap">' + posterHtml + '</div>' +
                    '<div class="sglv-card-body">' +
                        '<div class="sglv-card-name" title="' + Host.wlEscape(item.name) + '">' +
                            '<span>' + Host.wlEscape(item.name) + '</span>' +
                            '<span class="sglv-card-id-inline">' + item.appid + '</span>' +
                        '</div>' +
                        '<div class="sglv-info-row">' + bundleBadge + dlcBadge + '</div>' +
                        dlcListHtml +
                    '</div>' +
                '</div>';
            }).join('') + '</div>';

            // 分页
            // v1.9.47-fix: 补 onJump——捆绑包翻页 5 个按钮全部走 onJump(参见主脚本 renderPagination)
            const pagination = document.getElementById('sglv-bundle-pagination');
            if (pagination) {
                Host.renderPagination(pagination, 'sglv-bundle', bundleState.page, totalPages, list.length,
                    () => { bundleState.page--; renderBundleList(); },
                    () => { bundleState.page++; renderBundleList(); },
                    (p) => { bundleState.page = p; renderBundleList(); });
            }
        }

        // 捆绑包标签页主渲染入口
        function renderBundleTab(parent) {
            const wrap = document.createElement('div');
            wrap.className = 'sglv-psplus-wrap';

            // KPI 区域
            const kpi = document.createElement('div');
            kpi.id = 'sglv-bundle-kpi';
            wrap.appendChild(kpi);

            // 工具栏: 搜索 + 排序
            const toolbar = document.createElement('div');
            toolbar.className = 'sglv-toolbar';
            const sortOptions = [
                { key: 'bundleDesc', label: Host.isZh ? '进包数↓' : 'Bundles↓' },
                { key: 'bundleAsc', label: Host.isZh ? '进包数↑' : 'Bundles↑' },
                { key: 'nameAsc', label: Host.isZh ? '名称 A-Z' : 'Name A-Z' },
                { key: 'appidDesc', label: Host.isZh ? 'AppID↓' : 'AppID↓' },
                { key: 'appidAsc', label: Host.isZh ? 'AppID↑' : 'AppID↑' },
            ];
            toolbar.innerHTML = `
                <input class="sglv-search" aria-label="搜索" id="sglv-bundle-search" placeholder="${Host.isZh ? '搜索游戏 / DLC…' : 'Search game / DLC…'}" value="${Host.wlEscape(bundleState.search)}">
                <select class="sglv-sort-select" aria-label="排序方式" id="sglv-bundle-sort">
                    ${sortOptions.map(o => `<option value="${o.key}"${bundleState.sort === o.key ? ' selected' : ''}>${o.label}</option>`).join('')}
                </select>
                <div class="sglv-pagination" id="sglv-bundle-pagination"></div>
            `;
            wrap.appendChild(toolbar);

            // 游戏列表容器
            const content = document.createElement('div');
            content.className = 'sglv-content';
            content.id = 'sglv-bundle-content';
            wrap.appendChild(content);

            parent.appendChild(wrap);

            // 事件绑定
            toolbar.querySelector('#sglv-bundle-search').addEventListener('input', _debounce((e) => {
                bundleState.search = e.target.value;
                bundleState.page = 1;
                renderBundleList();
            }, 200));
            toolbar.querySelector('#sglv-bundle-sort').addEventListener('change', (e) => {
                bundleState.sort = e.target.value;
                bundleState.page = 1;
                renderBundleList();
            });

            // 构建数据并渲染
            buildBundleData();
            renderBundleKpi();
            renderBundleList();
        }

        // ==================== 收藏浮窗管理（v2.7.0） ====================
        function ensureCollectionPanel() {
            if (collectionPanelEl) return;
            collectionOverlayEl = document.createElement('div');
            collectionOverlayEl.className = 'sglv-overlay sgc-overlay';
            collectionOverlayEl.addEventListener('click', closeCollection);
            document.body.appendChild(collectionOverlayEl);

            collectionPanelEl = document.createElement('div');
            collectionPanelEl.className = 'sglv-panel sgc-panel';
            // v2.9.22: 重排页头——保留最左侧 Steam 图标作为品牌标识，6 个 tab 移入 header 内部（仿主面板 v2.9.22 紧凑风格）
            collectionPanelEl.innerHTML = `
                <div class="sglv-header">
                    <div class="sglv-header-brand" title="${Host.isZh ? '游戏收藏' : 'Game Collection'}"><img src="https://steamcommunity.com/favicon.ico" alt="Steam" onerror="this.replaceWith(document.createTextNode('🎮'))"></div>
                    <div class="sglv-tab-bar">
                        <button class="sglv-tab sglv-tab-btn active" data-tab="delisted">${Host.ICONS.shield}<span>${Host.T.tabDelisted}</span></button>
                        <button class="sglv-tab sglv-tab-btn" data-tab="blocked">${BLOCKED_LOCK_ICON_SVG}<span>${Host.T.tabBlocked}</span></button>
                        <button class="sglv-tab sglv-tab-btn" data-tab="goty">${Host.ICONS.trophy}<span>${Host.T.tabGoty}</span></button>
                        <button class="sglv-tab sglv-tab-btn" data-tab="publisher">${Host.ICONS.grid}<span>${Host.T.tabPublisher}</span></button>
                        <button class="sglv-tab sglv-tab-btn" data-tab="psplus">${Host.ICONS.playstation}<span>${Host.T.tabPsplus}</span></button>
                        <button class="sglv-tab sglv-tab-btn" data-tab="epic">${Host.ICONS.epic}<span>${Host.T.tabEpic}</span></button>
                        <button class="sglv-tab sglv-tab-btn" data-tab="dlc">${Host.ICONS.puzzle}<span>${Host.T.tabDlc}</span></button>
                        <button class="sglv-tab sglv-tab-btn" data-tab="bundle">${Host.ICONS.package}<span>${Host.isZh ? '捆绑包' : 'Bundles'}</span></button>
                    </div>
                    <div class="sglv-header-actions">
                        <button class="sglv-header-btn sglv-home-btn" title="${Host.isZh ? '返回游戏库' : 'Back to Library'}">${Host.ICONS.home || '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M3 9l9-7 9 7v11a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z"/><polyline points="9 22 9 12 15 12 15 22"/></svg>'}</button>
                        <button class="sglv-header-btn sglv-close-btn" title="✕">${Host.ICONS.close}</button>
                    </div>
                </div>
                <div class="sglv-body" id="sgc-body"></div>
            `;
            document.body.appendChild(collectionPanelEl);

            collectionPanelEl.querySelector('.sglv-close-btn').addEventListener('click', closeCollection);
            // v1.8.0: home 按钮 → 关闭收藏浮窗并返回游戏库浮窗
            collectionPanelEl.querySelector('.sglv-home-btn').addEventListener('click', () => {
                closeCollection();
                document.dispatchEvent(new CustomEvent('sglv:open-library'));
            });
            collectionPanelEl.querySelectorAll('.sglv-tab').forEach(tab => {
                tab.addEventListener('click', () => {
                    _collectionActiveTab = tab.dataset.tab;
                    collectionPanelEl.querySelectorAll('.sglv-tab').forEach(t => t.classList.remove('active'));
                    tab.classList.add('active');
                    renderCollectionBody();
                });
            });

            // v1.8.0: 系列分类数据异步加载完成后，若当前正在展示系列分类标签页则自动刷新
            // v1.9.40: 移除 seriesFetchedAt 更新（更新时间文本已移除）
            // v1.9.37: 不再调用 renderCollectionBody（会闪骨架），改为直接刷新侧边栏+详情
            document.addEventListener('sglv:series-data-loaded', () => {
                if (_collectionActiveTab === 'publisher' && collectionPanelEl && collectionPanelEl.classList.contains('sglv-show')) {
                    refreshPublisherTabContent();
                }
            });

            // v2.9.91: 供应商数据远程更新事件——运行时检查发现远程版本有更新时自动刷新
            // v1.9.37: 同上，改为直接刷新侧边栏+详情
            document.addEventListener('sglv:supplier-data-loaded', () => {
                if (_collectionActiveTab === 'publisher' && collectionPanelEl && collectionPanelEl.classList.contains('sglv-show')) {
                    refreshPublisherTabContent();
                }
            });

            // v2.9.90: 锁区数据远程更新事件——后台时间戳检查发现新版本或强制刷新后，
            // 自动更新收藏浮窗的 blockedState 并重新渲染（解决主面板刷新后收藏浮窗仍显示旧数据的问题）
            document.addEventListener('sglv:blocked-data-updated', (e) => {
                const detail = e.detail || {};
                if (Array.isArray(detail.apps) && detail.apps.length > 0) {
                    blockedState.apps = detail.apps;
                    blockedState.source = detail.source || 'static';
                    blockedState.fetchedAt = detail.fetchedAt || '';
                    blockedState.loaded = true;
                    // 同步写入永久缓存
                    _permCacheSet('blockedApps', { apps: blockedState.apps, source: blockedState.source, fetchedAt: blockedState.fetchedAt });
                    // v2.9.91: 同时刷新好评500分类数据（确保与主数据同步）
                    loadTopRatedApps(true).finally(() => {
                        if (_collectionActiveTab === 'blocked' && collectionPanelEl && collectionPanelEl.classList.contains('sglv-show')) {
                            renderBlockedSections();
                        }
                    });
                    // 若收藏浮窗打开且当前在锁区标签页，重新渲染
                    if (_collectionActiveTab === 'blocked' && collectionPanelEl && collectionPanelEl.classList.contains('sglv-show')) {
                        renderBlockedSections();
                    }
                }
            });

            // v2.9.22: 注入 sgc-panel 紧凑 CSS（仿主面板 v2.9.22：紧凑 header、tab 按钮圆角化、品牌图标、拖动 cursor、加载骨架）
            if (typeof GM_addStyle === 'function' && !collectionPanelEl._sgcStyled) {
                GM_addStyle(SGC_PANEL_CSS);
                collectionPanelEl._sgcStyled = true;
            }
            // v2.9.22: 绑定拖动（仅一次）
            if (!collectionPanelEl._sgcDraggable) {
                makeSgcDraggable(collectionPanelEl, collectionPanelEl.querySelector('.sglv-header'));
                collectionPanelEl._sgcDraggable = true;
            }

            // v2.7.0: 监听主脚本库存更新事件，收藏浮窗打开时自动刷新
            document.addEventListener('sglv:games-updated', () => {
                if (collectionPanelEl && collectionPanelEl.classList.contains('sglv-show')) {
                    renderCollectionBody();
                }
            });
        }

        function renderCollectionBody() {
            const body = collectionPanelEl?.querySelector('#sgc-body');
            if (!body) return;
            // v1.9.37: 移除切 tab 骨架屏，直接渲染内容（避免界面变形/闪烁）
            body.innerHTML = '';
            if (_collectionActiveTab === 'delisted') renderDelistedTab(body);
            else if (_collectionActiveTab === 'blocked') renderBlockedTab(body);
            else if (_collectionActiveTab === 'goty') renderGotyTab(body);
            else if (_collectionActiveTab === 'publisher') renderPublisherTab(body);
            else if (_collectionActiveTab === 'psplus') renderPsplusTab(body);
            else if (_collectionActiveTab === 'epic') renderEpicTab(body);
            else if (_collectionActiveTab === 'dlc') renderDlcTab(body);
            else if (_collectionActiveTab === 'bundle') renderBundleTab(body);
            _collectionBodyInitialized = true;
        }

        function openCollection() {
            ensureCollectionPanel();
            collectionOverlayEl.classList.add('sglv-show');
            collectionPanelEl.classList.add('sglv-show');
            renderCollectionBody();
        }

        function closeCollection() {
            if (collectionOverlayEl) collectionOverlayEl.classList.remove('sglv-show');
            if (collectionPanelEl) collectionPanelEl.classList.remove('sglv-show');
        }

        function toggleCollection() {
            if (collectionPanelEl && collectionPanelEl.classList.contains('sglv-show')) closeCollection();
            else openCollection();
        }

    return {
        init,
        apiVersion,
        openCollection,
        closeCollection,
        toggleCollection,
        renderPublisherTab,
        renderDelistedTab,
        renderPsplusTab,
        renderEpicTab,
        renderBlockedTab,
        renderGotyTab,
        renderDlcTab,
        renderBundleTab
    };
})();
// ============================================================================
// end of inlined sglv-game-collection 1.9.47
// ============================================================================


(function () {

    'use strict';

    // v2.9.54: 顶层环境守卫 — keylol 等论坛帖子内的 Steam 商店链接卡片以 iframe 形式嵌入
    // store.steampowered.com 页面,@match 会命中 iframe 内脚本上下文,导致侧边栏侧滑按钮(sgis-fab)
    // 检测 window.self !== window.top 时直接退出,跳过所有 UI 初始化。
    if (window.self !== window.top) return;

    const _v = typeof GM_info !== 'undefined' ? GM_info.script.version : 'unknown';
    // v2.11.40: 主题层——启动日志移至 init()（需读 storage.getUiTheme，此处尚在 TDZ 之前）

    // ==================== v2.8.3: Toast 非阻塞通知系统 ====================
    const sglvToast = {
        _el: null,
        _timer: null,
        _show(msg, type) {
            if (!this._el) {
                this._el = document.createElement('div');
                this._el.id = 'sglv-toast';
                document.body.appendChild(this._el);
            }
            this._el.textContent = msg;
            this._el.className = 'sglv-toast' + (type ? ' sglv-toast-' + type : '');
            requestAnimationFrame(() => this._el.classList.add('sglv-toast-show'));
            if (this._timer) clearTimeout(this._timer);
            this._timer = setTimeout(() => this._el.classList.remove('sglv-toast-show'), 2500);
        },
        success(msg) { this._show(msg, 'success'); },
        error(msg) { this._show(msg, 'error'); },
        warning(msg) { this._show(msg, 'warning'); },
        info(msg) { this._show(msg, 'info'); }
    };

    // ==================== v2.9.29: 全局 HTML 转义函数（防 XSS） ====================
    // 统一 HTML 转义工具，所有 innerHTML 拼接外部数据时必须调用
    function escHtml(s) {
        return String(s == null ? '' : s)
            .replace(/&/g, '&amp;')
            .replace(/</g, '&lt;')
            .replace(/>/g, '&gt;')
            .replace(/"/g, '&quot;')
            .replace(/'/g, '&#39;');
    }

    // v2.9.106: 安全读取 GM_xmlhttpRequest 响应文本
    // 部分浏览器扩展(如 inspector.js)会 hook XMLHttpRequest.prototype.send 并修改 responseType，
    // 导致 GM_xmlhttpRequest 回调中 resp.responseText 抛出 InvalidStateError（was 'arraybuffer'）。
    // 此函数先尝试 responseText，失败后尝试 response（可能是 ArrayBuffer），最终兜底空字符串。
    function safeResponseText(resp) {
        try {
            if (resp.responseText) return resp.responseText;
        } catch (e) { /* responseType 被外部修改为 arraybuffer，responseText 不可访问 */ }
        try {
            if (typeof resp.response === 'string') return resp.response;
            if (resp.response instanceof ArrayBuffer) return new TextDecoder().decode(new Uint8Array(resp.response));
        } catch (e2) { /* ignore */ }
        return '';
    }

    // v2.9.85: 货币代码→符号映射（参考 steam-family-game-analysis faCurrencySymbol）
    // SGLVAppDetail.loadDetail 用 cc=cn 请求 appdetails，但 Steam 可能对登录用户忽略 cc= 参数，
    // 返回用户实际所在地区的价格(如 INR)，需根据 d.cnPrice.currency 字段选择正确符号，
    // 而非旧代码硬编码的 ¥。置于主作用域，供搜索详情浮窗(_renderDetailContent)直接调用。
    // v2.9.100: 起优先委托 sglv-currency.lib.js 的 SGLVCurrency.symbolOf，lib 缺失时回退下方内置 map（行为不变）。
    // 注意: 本函数定义早于下方 CUR 探测声明，故在函数内部直接探测全局，不依赖外层变量。
    function sglvCurrencySymbol(code) {
        try {
            const lib = (typeof unsafeWindow !== 'undefined' && unsafeWindow.SGLVCurrency) || window.SGLVCurrency;
            if (lib && lib.apiVersion === 1) return lib.symbolOf(code);
        } catch (e) { console.debug('[SGLV] SGLVCurrency.symbolOf 异常，降级内置 map', e); }
        const map = {
            'CNY': '¥', 'USD': '$', 'EUR': '€', 'GBP': '£', 'JPY': '¥', 'KRW': '₩',
            'INR': '₹', 'RUB': '₽', 'BRL': 'R$', 'TRY': '₺', 'AUD': 'A$', 'CAD': 'C$',
            'HKD': 'HK$', 'TWD': 'NT$', 'SGD': 'S$', 'THB': '฿', 'MYR': 'RM', 'PHP': '₱',
            'IDR': 'Rp', 'VND': '₫', 'MXN': 'Mex$', 'ARS': 'ARS$', 'CLP': 'CLP$', 'COP': 'COL$',
            'PEN': 'S/', 'ZAR': 'R', 'UAH': '₴', 'PLN': 'zł', 'NOK': 'kr', 'CHF': 'CHF ',
            'NZD': 'NZ$', 'SAR': 'SR', 'AED': 'AED ', 'ILS': '₪', 'KZT': '₸', 'QAR': 'QR',
            'KWD': 'KD', 'CRC': '₡', 'UYU': '$U'
        };
        return map[String(code || '').toUpperCase()] || '¥';
    }

    // ==================== v2.11.0 精简: SGLVCore 依赖注入 ====================
    // v2.11.0: 移除 2.10.0 SGLVCore 降级实现（~194 行）— @require 外部库加载失败即终止核心功能,
    // 不再尝试用内置最小化实现(之前 IDB→内存+GM, negCache→内存TTL 等)以减少同步成本。
    // 业务代码继续按原 const/function 名字使用,零改动。IDB / 负缓存 / StageProgress /
    // concurrentPool / gmFetch / notifyNetFail 统一来自 sglv-core.lib.js v1.0.6。
    let C = (typeof unsafeWindow !== 'undefined' && unsafeWindow.SGLVCore) || window.SGLVCore;

    // v2.9.114: 终态失败通知包装——保留兜底以兼容 core 旧版本 < 1.0.5 (远端发布滞后场景),
    // 缺失时回退到 console.warn 静默输出,保证 catch 块内调用永不抛错。
    const sglvNotifyNetFail = (typeof C.notifyNetFail === 'function')
        ? C.notifyNetFail.bind(C)
        : (label, err) => { try { console.warn('[SGLV] 数据获取失败(系统通知未接入):', label, (err && err.message) || err); } catch (e2) {} };

    // v2.9.100: SGLV Currency 货币库软降级探测（增强能力，非基础设施：缺失仅降级不早退）
    const CUR = (typeof unsafeWindow !== 'undefined' && unsafeWindow.SGLVCurrency) || window.SGLVCurrency;
    const hasSglvCurrency = !!(CUR && CUR.apiVersion === 1);
    if (!hasSglvCurrency) console.warn('[SGLV] SGLVCurrency 未加载或版本不匹配，货币增强功能降级为内置实现');

    // ----- 命名空间 -----
    const nsKey = C.nsKey;

    // ----- IDB KV 库 -----
    const sglvIDB = C.IDB;

    // ----- 缓存 schema 版本号(业务特定默认值,本脚本独有) -----
    const CACHE_VERSION = {
        bundle_db: 2,           // 旧版大体积缓存需要 v2 精简
        dlc_db: 1,
        app_types: 1,
        cover_good_url: 1,
        game_name: 1,
        blocked_apps: 1,
    };
    function ensureCacheVersions() { return C.ensureCacheVersions(CACHE_VERSION); }

    // ----- 负缓存(直接转发 core 暴露的 API) -----
    const negCacheGet = C.negCache.get.bind(C.negCache);
    const negCacheSet = C.negCache.set.bind(C.negCache);
    const negCacheClear = C.negCache.clear.bind(C.negCache);

    // ----- 阶段进度 / 节流 / 并发 / 抓取 / 占位 -----
    const StageProgress = C.StageProgress;
    const concurrentPool = C.concurrentPool;

    // ----- GM 网络包装(原 sglvGmFetchRetry / sglvGmFetchTextRetry) -----
    const sglvGmFetchRetry = C.gmFetchJson;
    const sglvGmFetchTextRetry = C.gmFetchText;

    // ==================== v2.8.3: 通用 UI 组件函数 ====================
    // v2.11.3 (FEAT-011 TASK-004): spinner 段生成器——默认形态(#a78bfa/自带自旋动画)与
    // 专属 class 形态(currentColor/圆角端点,尺寸与动画交给配套 CSS,如 .sglv-wl-spin);
    // 供 createLoadingHtml 工厂与详情弹窗加载态共用,消除手写 svg 重复
    function spinSvg(size = 34, cls = '') {
        if (cls) {
            return `<svg class="${cls}" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M21 12a9 9 0 1 1-6.219-8.56"/></svg>`;
        }
        return `<svg viewBox="0 0 24 24" width="${size}" height="${size}" fill="none" stroke="#a78bfa" stroke-width="2" style="animation:sglv-spin 1s linear infinite;"><path d="M21 12a9 9 0 1 1-6.219-8.56"/></svg>`;
    }

    // v2.11.3 (FEAT-011 TASK-004): 阶段条段生成器——自 SGIS renderProgressLoading 收编
    // (class 序列逐字节等价,含非激活态 class 属性的尾随空格;wrapId 供增量更新器按 id 定位)
    function stageBarsHtml(total, active, wrapId = '') {
        const bars = Array.from({ length: total }, (_, i) =>
            `<div class="sgis-load-stage-bar ${i + 1 < active ? 'done' : i + 1 === active ? 'active' : ''}"></div>`
        ).join('');
        return `<div class="sgis-load-stages"${wrapId ? ` id="${wrapId}"` : ''}>${bars}</div>`;
    }

    // v2.11.3 (FEAT-011 TASK-004): 加载态工厂扩展——单一加载态入口,opts 全部可选
    // (无 opts 时输出与 2.11.2 逐字节一致):
    //   cls      外层附加 class(如 'sglv-wl-loading';给定时外层不再输出内联布局样式,布局交给 CSS)
    //   svgCls   spinner 段专属 class(如 'sglv-wl-spin',currentColor 形态,尺寸由 CSS 决定)
    //   spin     'none' 时不渲染 spinner 段
    //   textCls  文案附加 class(给定时文案用 <div class>,否则维持内联 <span style>)
    //   stages   [{key,label}] + activeStage(+可选 stagesId) → 阶段条(数组长度即阶段数,label 预留)
    //   progress {pct} 或 {current,total} → 进度条(total=0 除零保护为 0%;宽度公式与愿望单现状一致)
    //   sub      进度条下副文案
    // 进度条/副文案复用愿望单 .sglv-wl-loading-bar/-fill/-sub 既有 class 体系(CSS 不动)
    function createLoadingHtml(text, size = 34, opts = null) {
        const svg = (!opts || opts.spin !== 'none') ? spinSvg(size, opts ? (opts.svgCls || '') : '') : '';
        const textEl = opts && opts.textCls
            ? `<div class="${opts.textCls}">${text}</div>`
            : `<span style="font-size:13px;">${text}</span>`;
        let inner = svg + textEl;
        if (opts && opts.stages) {
            const active = opts.activeStage != null ? opts.activeStage : opts.stages.length;
            inner += stageBarsHtml(opts.stages.length, active, opts.stagesId || '');
        }
        if (opts && opts.progress) {
            const p = opts.progress;
            const raw = p.pct != null ? p.pct
                : (p.total > 0 ? Math.round(p.current / p.total * 100) : 0);
            const pct = Math.max(0, Math.min(100, raw));
            inner += `<div class="sglv-wl-loading-bar"><div class="sglv-wl-loading-bar-fill" style="width:${pct}%"></div></div>`;
        }
        if (opts && opts.sub != null) inner += `<div class="sglv-wl-loading-sub">${opts.sub}</div>`;
        if (opts && opts.cls) return `<div class="${opts.cls}">${inner}</div>`;
        return `<div style="display:flex;flex-direction:column;align-items:center;justify-content:center;padding:50px 20px;gap:12px;color:#8a9ba8;">${inner}</div>`;
    }

    // ==================== 供应商-系列-游戏数据库 ====================
    // 从远程 @resource 加载，数据源：Azure Blob Storage
    // v2.9.87: 数据升级 game-db-v1.2.json——光荣特库摩重编为 19 个系列分类（数据源小黑盒帖子），
    // 游戏条目新增可选 genres 字段（Steam appdetails 类型标签），由收藏模块 v1.9.16 渲染展示
    const GAME_DB = (function() {
        try {
            const raw = JSON.parse(GM_getResourceText('gameDb') || '{}');
            // 移除 _meta 元数据，避免被解析为供应商分类
            const { _meta, ...db } = raw;
            return db;
        }
        catch(e) { console.warn('[SGLV] GAME_DB 加载失败:', e); return {}; }
    })();

    const DELISTED_DB = (function() {
        try { return JSON.parse(GM_getResourceText('delistedData') || '{}'); }
        catch(e) { console.warn('[SGLV] DELISTED_DB 加载失败:', e); return {}; }
    })();

    // ==================== v2.9.27: 游戏系列数据（game_series.json） ====================
    // 数据源: https://raw.githubusercontent.com/SmallRob/steam-namespace/main/data/game_series.json
    // 经 jsdelivr CDN 加速: https://fastly.jsdelivr.net/gh/SmallRob/steam-namespace@main/data/game_series.json
    // （数据由 py_scripts/import_heybox_series.py 等脚本维护，与锁区数据同仓库）
    // 兼容两种格式: 对象 { 系列名: [{序号, date, appid, name}] }（当前线上格式）
    //              / 扁平数组 [{name, date, appid, 序号, 系列}]（旧格式，按"系列"字段分组）
    const SERIES_DATA_URL = 'https://fastly.jsdelivr.net/gh/SmallRob/steam-namespace@main/data/game_series.json';
    // v2.9.104: 互动影游数据源（steam_vediogame_selected.json，扁平数组 [{序号, date, appid, name}]）
    // 数据源: https://raw.githubusercontent.com/SmallRob/steam-namespace/main/data/steam_vediogame_selected.json
    // 经 jsdelivr CDN 加速（与系列数据同仓库同管线）
    const VEDIO_SERIES_DATA_URL = 'https://fastly.jsdelivr.net/gh/SmallRob/steam-namespace@main/data/steam_vediogame_selected.json';
    // v2.9.113: GitHub 原始源（CDN 失败时回退；force 刷新绕过 jsdelivr 边缘缓存，确保拿到最新分类数据）
    const SERIES_DATA_URL_RAW = 'https://raw.githubusercontent.com/SmallRob/steam-namespace/main/data/game_series.json';
    const VEDIO_SERIES_DATA_URL_RAW = 'https://raw.githubusercontent.com/SmallRob/steam-namespace/main/data/steam_vediogame_selected.json';
    // v2.9.27: 独立系列库 { seriesName: [{id, name, date}] }，与 GAME_DB（供应商）分开展示
    let seriesDb = {};
    // v2.9.104: 最近一次成功拉取/缓存的合并原始数据——某一数据源失败时，
    // 从内存兜底恢复，避免系列侧边栏因单源失败而塌缩/丢系列
    let _lastSeriesRaw = null;
    // v2.9.91: 供应商数据远程覆盖（运行时检查 @resource gameDb 远程版本，有更新时覆盖 GAME_DB）
    const GAME_DB_REMOTE_URL = 'https://fastly.jsdelivr.net/gh/SmallRob/steam-namespace@main/data/game-db-v1.2.json';
    // v2.9.113: 供应商数据 GitHub 原始源（CDN 失败回退）
    const GAME_DB_REMOTE_URL_RAW = 'https://raw.githubusercontent.com/SmallRob/steam-namespace/main/data/game-db-v1.2.json';
    let supplierDbOverride = null;
    let supplierFetchedAt = '';

    /**
     * 将 game_series.json 规范化为独立系列库（不做二级分类，不与供应商合并）
     * 兼容对象格式 { 系列名: [{序号, date, appid, name}] } 与扁平数组 [{name, date, appid, 序号, 系列}]
     * 返回: { seriesName: [{id, name, date, order}, ...] }（系列内按序号升序）
     */
    function groupSeriesData(seriesData) {
        const grouped = {};
        const pushGame = (seriesName, item) => {
            const id = Number(item.appid) || 0;
            if (!id) return;
            if (!grouped[seriesName]) grouped[seriesName] = [];
            // 同系列内按 appid 去重
            if (grouped[seriesName].some(g => g.id === id)) return;
            grouped[seriesName].push({
                id,
                name: item.name || '',
                date: item.date || '',
                order: Number(item['序号'] || item.order) || 0,
                // v2.9.105: 保留数据源 poster 字段（预验证封面URL，为空时走 CDN 降级链）
                poster: item.poster || '',
            });
        };

        if (Array.isArray(seriesData)) {
            // 扁平数组格式：按"系列"字段分组
            for (const item of seriesData) {
                const seriesName = String(item['系列'] || item.series || '').trim() || '未分类';
                pushGame(seriesName, item);
            }
        } else if (seriesData && typeof seriesData === 'object') {
            // 对象格式：键即系列名
            for (const [seriesName, games] of Object.entries(seriesData)) {
                const name = String(seriesName).trim();
                if (!name || !Array.isArray(games)) continue;
                for (const item of games) pushGame(name, item);
            }
        }

        // 系列内按序号升序（无序号的排后，保持稳定排序）
        for (const games of Object.values(grouped)) {
            games.sort((a, b) => (a.order || Infinity) - (b.order || Infinity));
        }
        return grouped;
    }

    /**
     * v2.9.104: 合并系列数据源——互动影游数据（扁平数组）作为独立"互动影游"系列并入 game_series 数据
     * 归一为 groupSeriesData 可直接消费的格式（对象 { 系列名: [...] } / 旧扁平数组打"系列"标记），
     * 使互动影游走与既有系列完全相同的缓存/签名/事件管线（7 天 TTL、签名对比、强制刷新、状态三态）。
     * @param {any} mainData - game_series.json 原始数据（对象或旧扁平数组）
     * @param {any} vedioData - steam_vediogame_selected.json 原始数据（扁平数组）
     * @returns {any} 合并后的原始数据（未归一化）
     */
    function mergeVedioSeriesData(mainData, vedioData) {
        if (!Array.isArray(vedioData) || !vedioData.length) return mainData;
        if (Array.isArray(mainData)) {
            // 旧扁平数组格式：给条目打上"系列"标记后并入（与旧数据兼容）
            return mainData.concat(vedioData.map(item => Object.assign({}, item, { 系列: '互动影游' })));
        }
        if (mainData && typeof mainData === 'object') {
            const out = Object.assign({}, mainData);
            // 影游专用文件为互动影游权威数据源，覆盖主文件同名键（若有）
            out['互动影游'] = vedioData;
            return out;
        }
        // 主数据源为空/异常但影游数据有效：包装成对象格式兜底
        return { '互动影游': vedioData };
    }

    /**
     * v2.9.113: djb2 轻量哈希——将 appid 列表折叠为紧凑签名，避免超长字符串
     */
    function _sigHash(str) {
        let h = 5381;
        for (let i = 0; i < str.length; i++) h = ((h << 5) + h + str.charCodeAt(i)) | 0;
        return (h >>> 0).toString(36);
    }

    /**
     * v2.9.90: 计算系列数据内容签名（用于检测远程数据是否有变化）
     * v2.9.113: 签名从"系列数:游戏总数"粗粒度升级为逐系列 appid 集合哈希——
     *   此前互动影游等分类的条目级变更（游戏新增/移除/跨系列移动而总数恰好不变）无法检测，
     *   导致手动刷新后分类数据"看似成功实则未更新"
     */
    function _computeSeriesSignature(data) {
        if (Array.isArray(data)) {
            const ids = data.map(i => String(i && (i.appid != null ? i.appid : i.name) || '')).sort();
            return `arr:${data.length}:${_sigHash(ids.join(','))}`;
        } else if (data && typeof data === 'object') {
            const keys = Object.keys(data).sort();
            const parts = keys.map(k => {
                const arr = Array.isArray(data[k]) ? data[k] : [];
                const ids = arr.map(i => String(i && (i.appid != null ? i.appid : i.name) || '')).sort();
                return `${k}(${arr.length}):${_sigHash(ids.join(','))}`;
            });
            let totalGames = 0;
            for (const k of keys) if (Array.isArray(data[k])) totalGames += data[k].length;
            return `obj:${keys.length}:${totalGames}:${_sigHash(parts.join('|'))}`;
        }
        return 'empty';
    }

    /**
     * v2.9.113: GM GET JSON（无重试）——raw.githubusercontent 原始源回退用
     * v2.11.36 (FEAT-015 TASK-003): 迁移至 sglvGmFetchRetry（retries:0 保持无重试语义，Accept 头透传）
     */
    function _gmGetJsonRaw(url, timeout = 15000) {
        return sglvGmFetchRetry(url, { timeout, retries: 0, headers: { 'Accept': 'application/json' } });
    }

    /**
     * v2.9.113: 收藏分类数据源抓取——CDN 主源 + GitHub 原始源回退
     * force 时附加时间戳查询参数绕过 jsdelivr 边缘缓存（不同查询串为不同缓存键，
     * 强制回源拉最新数据，解决手动刷新拿到 CDN 旧快照导致互动影游等分类不更新的问题）；
     * 非 force 走普通 URL 复用 CDN 缓存（快、省流量）。
     * @returns {Promise<any>} 解析后的 JSON
     */
    async function _fetchCollectionJson(cdnUrl, rawUrl, force) {
        const bust = force ? `?_sglv=${Date.now()}` : '';
        try {
            return await sglvGmFetchRetry(cdnUrl + bust, { timeout: 15000 });
        } catch (e) {
            return await _gmGetJsonRaw(rawUrl + bust, 15000);
        }
    }

    /**
     * 异步加载游戏系列数据（带缓存，先读缓存同步分组，再后台拉取最新）
     * v2.9.90: 添加 force 参数 + 内容签名比较，避免无变化时重复写缓存/派发事件
     * v2.9.92: force 时先移出过期缓存，返回结果状态 { status: 'updated'|'nochange'|'error', msg }
     * v2.9.113: 缓存策略重写——
     *   ① force 不再先删缓存：拉取失败时旧缓存原样保留（此前先删后拉，失败即丢缓存，
     *      内存兜底 _lastSeriesRaw 页面刷新后即失效）
     *   ② 拉取成功且签名变化时 cacheSet 覆盖写缓存（旧版本缓存被新版本替换）
     *   ③ force 附加时间戳绕 CDN 边缘缓存 + raw.githubusercontent 回退，确保拿到最新分类数据
     * @param {boolean} force - 强制刷新（跳过缓存读取，始终拉取远程数据，绕 CDN 缓存）
     * @param {function} onProgress - v2.9.91 (text) 进度回调
     * @returns {Promise<{status:string, msg:string}>}
     */
    async function loadSeriesData(force = false, onProgress) {
        const report = (text) => { if (typeof onProgress === 'function') onProgress(text); };
        // 1. 非强制刷新时先读缓存，同步分组（确保 UI 首次渲染即有系列数据）
        if (!force) {
            const cached = cacheGet('seriesData');
            if (cached) {
                const cachedDb = groupSeriesData(cached);
                if (Object.keys(cachedDb).length > 0) {
                    seriesDb = cachedDb;
                    _lastSeriesRaw = cached;
                    document.dispatchEvent(new CustomEvent('sglv:series-data-loaded'));
                }
            }
        }

        // 2. 拉取最新远程数据（v2.9.104: game_series.json 与 steam_vediogame_selected.json 并行，
        //    互动影游并入同一 seriesDb，共享缓存/签名/事件管线，更新逻辑与既有系列完全一致；
        //    网络层统一走 SGLVCore gmFetchJson（自动重试 + 状态码校验 + JSON 解析），
        //    v2.9.113: 失败回退 raw.githubusercontent 原始源）
        try {
            report(isZh ? '正在加载系列数据…' : 'Fetching series data…');
            const [mainRes, vedioRes] = await Promise.allSettled([
                _fetchCollectionJson(SERIES_DATA_URL, SERIES_DATA_URL_RAW, force),
                _fetchCollectionJson(VEDIO_SERIES_DATA_URL, VEDIO_SERIES_DATA_URL_RAW, force),
            ]);
            let mainData = mainRes.status === 'fulfilled' ? mainRes.value : null;
            let vedioData = vedioRes.status === 'fulfilled' ? vedioRes.value : null;
            if (!mainData && !vedioData) {
                const err = (mainRes.status === 'rejected' ? mainRes.reason : vedioRes.reason);
                throw (err instanceof Error ? err : new Error('All series sources failed'));
            }
            if (mainRes.status === 'rejected') {
                // 主源失败：优先复用缓存主数据，其次内存兜底
                console.warn('[SGLV] 系列分类主数据源加载失败:', mainRes.reason && mainRes.reason.message);
                const cachedMain = cacheGet('seriesData') || _lastSeriesRaw;
                if (cachedMain) mainData = cachedMain;
                else if (vedioData) mainData = {};
            }
            if (vedioRes.status === 'rejected') {
                console.warn('[SGLV] 互动影游数据加载失败:', vedioRes.reason && vedioRes.reason.message);
                // 影游源失败：复用缓存/内存兜底中的互动影游数据（保留上次成功拉取内容，避免刷新导致该系列消失）
                const cachedRaw = cacheGet('seriesData') || _lastSeriesRaw;
                if (cachedRaw && !Array.isArray(cachedRaw) && Array.isArray(cachedRaw['互动影游'])) {
                    vedioData = cachedRaw['互动影游'];
                }
            }
            const data = mergeVedioSeriesData(mainData, vedioData);
            const freshDb = groupSeriesData(data);
            if (Object.keys(freshDb).length > 0) {
                // v2.9.104: 内存兜底随每次成功拉取更新（后续单源失败时可用）
                _lastSeriesRaw = data;
                // v2.9.90: 内容签名比较——签名相同时仅刷新TTL，不派发事件（避免不必要的UI重渲染）
                // v2.9.113: 签名为逐系列 appid 哈希，条目级变更也能检测；force 与否均按签名判定
                const newSig = _computeSeriesSignature(data);
                const cachedRaw = cacheGet('seriesData');
                const oldSig = cachedRaw ? _computeSeriesSignature(cachedRaw) : '';

                if (newSig !== oldSig) {
                    // 成功获取最新版本：新数据覆盖写缓存（旧版本缓存被替换清除）
                    cacheSet('seriesData', data, CACHE_TTL.seriesData);
                    seriesDb = freshDb;
                    document.dispatchEvent(new CustomEvent('sglv:series-data-loaded'));
                    let totalGames = 0;
                    for (const games of Object.values(freshDb)) totalGames += games.length;
                    console.log(`[SGLV] 系列分类数据${force ? '强制' : ''}加载成功: ${totalGames} 条，共 ${Object.keys(freshDb).length} 个系列 (签名: ${newSig})`);
                    return { status: 'updated', msg: isZh ? `系列: ${Object.keys(freshDb).length} 项已更新` : `Series: ${Object.keys(freshDb).length} items updated` };
                } else {
                    // 签名相同，仅刷新缓存TTL，不派发事件
                    cacheSet('seriesData', data, CACHE_TTL.seriesData);
                    console.log('[SGLV] 系列分类数据远程无变化，跳过更新');
                    return { status: 'nochange', msg: isZh ? '系列: 已是最新' : 'Series: up to date' };
                }
            }
            return { status: 'nochange', msg: isZh ? '系列: 数据为空' : 'Series: empty' };
        } catch (e) {
            // 拉取失败：缓存不动（旧缓存保留，UI 继续用缓存/内存数据）
            console.warn('[SGLV] 系列分类数据加载失败:', e.message);
            sglvNotifyNetFail(isZh ? '收藏分类数据' : 'Collection data', e);   // v2.9.114: 终态失败系统通知(60s 节流)
            return { status: 'error', msg: isZh ? `系列: ${e.message}` : `Series: ${e.message}` };
        }
    }

    /**
     * v2.9.91: 异步加载供应商数据（远程版本检查，有更新时覆盖 @resource GAME_DB）
     * v2.9.92: force 时先移出过期缓存，返回结果状态 { status: 'updated'|'nochange'|'error', msg }
     * v2.9.113: 缓存策略与系列数据同步重写——force 不再先删缓存（失败保留旧缓存）、
     *   附加时间戳绕 CDN 边缘缓存 + raw.githubusercontent 回退
     * @param {boolean} force - 强制刷新（跳过缓存读取，始终拉取远程数据，绕 CDN 缓存）
     * @param {function} onProgress - (text) 进度回调
     * @returns {Promise<{status:string, msg:string}>}
     */
    async function loadSupplierData(force = false, onProgress) {
        const report = (text) => { if (typeof onProgress === 'function') onProgress(text); };
        // 非强制时检查缓存
        if (!force) {
            const cached = cacheGet('supplierData');
            if (cached && cached.db) {
                // 缓存命中：检查是否已有 override 或 GAME_DB 签名一致
                const cachedSig = _computeSupplierSignature(cached.raw || {});
                const currentSig = _computeSupplierSignature(GAME_DB);
                if (cachedSig !== currentSig) {
                    supplierDbOverride = cached.db;
                    supplierFetchedAt = cached.fetchedAt || '';
                    document.dispatchEvent(new CustomEvent('sglv:supplier-data-loaded'));
                }
            }
        }
        // 拉取最新远程数据
        try {
            report(isZh ? '正在加载供应商数据…' : 'Fetching supplier data…');
            const data = await _fetchCollectionJson(GAME_DB_REMOTE_URL, GAME_DB_REMOTE_URL_RAW, force);
            // 移除 _meta 元数据
            const { _meta, ...db } = data;
            const newSig = _computeSupplierSignature(data);
            const oldSig = _computeSupplierSignature(GAME_DB);
            if (force || newSig !== oldSig) {
                supplierDbOverride = db;
                supplierFetchedAt = new Date().toISOString().slice(0, 10);
                cacheSet('supplierData', { db, raw: data, fetchedAt: supplierFetchedAt }, CACHE_TTL.seriesData);
                document.dispatchEvent(new CustomEvent('sglv:supplier-data-loaded'));
                const totalGames = Object.values(db).reduce((s, v) => { try { return s + Object.values(v).reduce((ss, arr) => ss + (Array.isArray(arr) ? arr.length : 0), 0); } catch { return s; } }, 0);
                console.log(`[SGLV] 供应商数据${force ? '强制' : ''}加载成功: ${Object.keys(db).length} 个供应商, ${totalGames} 个游戏 (签名: ${newSig})`);
                return { status: 'updated', msg: isZh ? `供应商: ${Object.keys(db).length} 项已更新` : `Supplier: ${Object.keys(db).length} items updated` };
            } else {
                console.log('[SGLV] 供应商数据远程无变化，跳过更新');
                return { status: 'nochange', msg: isZh ? '供应商: 已是最新' : 'Supplier: up to date' };
            }
        } catch (e) {
            // 拉取失败：缓存与 override 不动
            console.warn('[SGLV] 供应商数据加载失败:', e.message);
            sglvNotifyNetFail(isZh ? '供应商分类数据' : 'Supplier data', e);   // v2.9.114: 终态失败系统通知(60s 节流)
            return { status: 'error', msg: isZh ? `供应商: ${e.message}` : `Supplier: ${e.message}` };
        }
    }

    /** v2.9.91: 计算供应商数据内容签名（供应商数:游戏总数） */
    function _computeSupplierSignature(data) {
        if (!data || typeof data !== 'object') return 'empty';
        const keys = Object.keys(data).filter(k => k !== '_meta');
        let totalGames = 0;
        for (const k of keys) {
            if (typeof data[k] === 'object' && data[k] !== null) {
                for (const sk of Object.keys(data[k])) {
                    if (Array.isArray(data[k][sk])) totalGames += data[k][sk].length;
                }
            }
        }
        return `pub:${keys.length}:${totalGames}`;
    }

    // ==================== SVG 图标 ====================
    const _S = 'viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"';
    const ICONS = {
        game: `<svg ${_S}><rect x="2" y="6" width="20" height="12" rx="2"/><path d="M12 12h.01"/><path d="M17 10h.01"/><path d="M17 14h.01"/><path d="M7 12h4"/><path d="M9 10v4"/></svg>`,
        grid: `<svg ${_S}><rect x="3" y="3" width="7" height="7" rx="1.5"/><rect x="14" y="3" width="7" height="7" rx="1.5"/><rect x="3" y="14" width="7" height="7" rx="1.5"/><rect x="14" y="14" width="7" height="7" rx="1.5"/></svg>`,
        list: `<svg ${_S}><line x1="8" y1="6" x2="21" y2="6"/><line x1="8" y1="12" x2="21" y2="12"/><line x1="8" y1="18" x2="21" y2="18"/><line x1="3" y1="6" x2="3.01" y2="6"/><line x1="3" y1="12" x2="3.01" y2="12"/><line x1="3" y1="18" x2="3.01" y2="18"/></svg>`,
        close: `<svg ${_S}><line x1="18" y1="6" x2="6" y2="18"/><line x1="6" y1="6" x2="18" y2="18"/></svg>`,
        settings: `<svg ${_S}><circle cx="12" cy="12" r="3"/><path d="M19.4 15a1.65 1.65 0 0 0 .33 1.82l.06.06a2 2 0 0 1 0 2.83 2 2 0 0 1-2.83 0l-.06-.06a1.65 1.65 0 0 0-1.82-.33 1.65 1.65 0 0 0-1 1.51V21a2 2 0 0 1-2 2 2 2 0 0 1-2-2v-.09A1.65 1.65 0 0 0 9 19.4a1.65 1.65 0 0 0-1.82.33l-.06.06a2 2 0 0 1-2.83 0 2 2 0 0 1 0-2.83l.06-.06A1.65 1.65 0 0 0 4.68 15a1.65 1.65 0 0 0-1.51-1H3a2 2 0 0 1-2-2 2 2 0 0 1 2-2h.09A1.65 1.65 0 0 0 4.6 9a1.65 1.65 0 0 0-.33-1.82l-.06-.06a2 2 0 0 1 0-2.83 2 2 0 0 1 2.83 0l.06.06A1.65 1.65 0 0 0 9 4.68a1.65 1.65 0 0 0 1-1.51V3a2 2 0 0 1 2-2 2 2 0 0 1 2 2v.09a1.65 1.65 0 0 0 1 1.51 1.65 1.65 0 0 0 1.82-.33l.06-.06a2 2 0 0 1 2.83 0 2 2 0 0 1 0 2.83l-.06.06A1.65 1.65 0 0 0 19.4 9a1.65 1.65 0 0 0 1.51 1H21a2 2 0 0 1 2 2 2 2 0 0 1-2 2h-.09a1.65 1.65 0 0 0-1.51 1z"/></svg>`,
        refresh: `<svg ${_S}><polyline points="23 4 23 10 17 10"/><path d="M20.49 15a9 9 0 1 1-2.12-9.36L23 10"/></svg>`,
        package: `<svg ${_S}><path d="M16.5 9.4L12 12 3.5 7.4"/><path d="M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z"/><path d="M3.27 6.96L12 12.01l8.73-5.05"/><path d="M12 22.08V12"/></svg>`,
        trend: `<svg ${_S}><polyline points="23 6 13.5 15.5 8.5 10.5 1 18"/><polyline points="17 6 23 6 23 12"/></svg>`,
        barChart: `<svg ${_S}><line x1="12" y1="20" x2="12" y2="10"/><line x1="18" y1="20" x2="18" y2="4"/><line x1="6" y1="20" x2="6" y2="16"/></svg>`,
        shield: `<svg ${_S}><path d="M12 22s8-4 8-10V5l-8-3-8 3v7c0 6 8 10 8 10z"/></svg>`,
        clock: `<svg ${_S}><circle cx="12" cy="12" r="10"/><path d="M12 6v6l4 2"/></svg>`,
        share: `<svg ${_S}><circle cx="18" cy="5" r="3"/><circle cx="6" cy="12" r="3"/><circle cx="18" cy="19" r="3"/><line x1="8.59" y1="13.51" x2="15.42" y2="17.49"/><line x1="15.41" y1="6.51" x2="8.59" y2="10.49"/></svg>`,
        // v2.9.67: 家庭共享图标（双人群组,用于愿望单家庭共享标签）
        familyShare: `<svg ${_S}><path d="M17 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2"/><circle cx="9" cy="7" r="4"/><path d="M23 21v-2a4 4 0 0 0-3-3.87"/><path d="M16 3.13a4 4 0 0 1 0 7.75"/></svg>`,
        heart: `<svg ${_S}><path d="M20.84 4.61a5.5 5.5 0 0 0-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 0 0-7.78 7.78l1.06 1.06L12 21.23l7.78-7.78 1.06-1.06a5.5 5.5 0 0 0 0-7.78z"/></svg>`,
        dollar: `<svg ${_S}><line x1="12" y1="1" x2="12" y2="23"/><path d="M17 5H9.5a3.5 3.5 0 0 0 0 7h5a3.5 3.5 0 0 1 0 7H6"/></svg>`,
        tag: `<svg ${_S}><path d="M20.59 13.41l-7.17 7.17a2 2 0 0 1-2.83 0L2 12V2h10l8.59 8.59a2 2 0 0 1 0 2.82z"/><line x1="7" y1="7" x2="7.01" y2="7"/></svg>`,
        gift: `<svg ${_S}><polyline points="20 12 20 22 4 22 4 12"/><rect x="2" y="7" width="20" height="5"/><line x1="12" y1="22" x2="12" y2="7"/><path d="M12 7H7.5a2.5 2.5 0 0 1 0-5C11 2 12 7 12 7z"/><path d="M12 7h4.5a2.5 2.5 0 0 0 0-5C13 2 12 7 12 7z"/></svg>`,
        library: `<svg ${_S}><path d="M16 6V4a2 2 0 0 0-2-2h-4a2 2 0 0 0-2 2v2"/><rect x="2" y="6" width="20" height="12" rx="2"/><path d="M2 10h20"/></svg>`,
        calendar: `<svg ${_S}><rect x="3" y="4" width="18" height="18" rx="2"/><line x1="16" y1="2" x2="16" y2="6"/><line x1="8" y1="2" x2="8" y2="6"/><line x1="3" y1="10" x2="21" y2="10"/></svg>`,
        // v2.7.2: 即将发售 KPI 图标（火箭，区别于日历图标的年份卡片）
        rocket: `<svg ${_S}><path d="M4.5 16.5c-1.5 1.26-2 5-2 5s3.74-.5 5-2c.71-.84.7-2.13-.09-2.91a2.18 2.18 0 0 0-2.91-.09z"/><path d="M12 15l-3-3a22 22 0 0 1 2-3.95A12.88 12.88 0 0 1 22 2c0 2.72-.27 9.65-7 13-1.04.5-2 1-3 1z"/><path d="M9 12H4s.55-3.03 2-4c1.62-1.1 5-.5 5-.5"/><path d="M12 15v5s3.03-.55 4-2c1.1-1.62.5-5 .5-5"/></svg>`,
        // v2.4.3: 横板封面视图图标（宽横幅卡片）
        cover: `<svg ${_S}><rect x="2" y="5" width="20" height="14" rx="2"/><circle cx="7.5" cy="10" r="1.5"/><polyline points="22 15 16 9 6 19"/></svg>`,
        // v2.6.0: PlayStation 四符号图标（三角/圆/叉/方）用于 PS 会免标签页
        // v2.9.22: 真实 PlayStation 标识（官方蓝紫色 P + S 经典组合），替代原 4 符号简笔
        playstation: `<svg viewBox="0 0 122.88 95.18" xmlns="http://www.w3.org/2000/svg" fill="#0070D1"><path d="M2.49,69.39c-4.61,3.07-3.07,8.9,6.75,11.67c10.13,3.38,21.18,4.3,31.93,2.46c0.61,0,1.23-0.31,1.54-0.31V72.76l-10.44,3.38c-3.99,1.23-7.98,1.54-11.97,0.61c-3.07-0.92-2.46-2.76,1.23-4.3l21.18-7.37V53.73L13.23,63.86C9.55,65.09,5.86,66.93,2.49,69.39L2.49,69.39z M73.71,23.33v29.78c12.59,6.14,22.41,0,22.41-15.96c0-16.27-5.83-23.64-22.72-29.47C64.5,4.6,55.29,1.84,46.08,0v88.73l21.49,6.45V20.57c0-3.38,0-5.83,2.46-4.91C73.41,16.58,73.71,19.96,73.71,23.33L73.71,23.33z M113.63,62.32c-8.9-3.07-18.42-4.3-27.63-3.38c-4.91,0.31-9.52,1.54-13.82,3.07l-0.92,0.31V74.3l19.96-7.37c3.99-1.23,7.98-1.54,11.97-0.61c3.07,0.92,2.46,2.76-1.23,4.3l-30.7,11.36v11.67l42.37-15.66c3.07-1.23,5.83-2.76,8.29-5.22C124.07,69.69,123.15,65.39,113.63,62.32L113.63,62.32z"/></svg>`,
        // v2.7.9: Epic 赠送标签页图标（"E" 字形）
        // v2.9.22: Epic Games 盾形标识（深色盾形 + 白色 EPIC/GAMES 文字），替代原"E"字简笔
        epic: `<svg viewBox="0 0 100 100" xmlns="http://www.w3.org/2000/svg"><path d="M8 18 L8 52 C8 70 26 86 50 94 C74 86 92 70 92 52 L92 18 Z" fill="#1a1a1a" stroke="#3a3a3a" stroke-width="1.2"/><text x="50" y="47" text-anchor="middle" font-family="Arial Black, Helvetica, sans-serif" font-size="20" font-weight="900" fill="#fff" letter-spacing="0.5">EPIC</text><text x="50" y="65" text-anchor="middle" font-family="Arial, Helvetica, sans-serif" font-size="11" font-weight="700" fill="#fff" letter-spacing="1.2">GAMES</text></svg>`,
        // v2.9.0: 集换式卡牌图标
        card: `<svg ${_S}><rect x="3" y="6" width="18" height="13" rx="2"/><line x1="3" y1="11" x2="21" y2="11"/></svg>`,
        // v2.9.7: 年度大作标签页图标（奖杯）
        trophy: `<svg ${_S}><path d="M6 9H4.5a2.5 2.5 0 0 1 0-5H6"/><path d="M18 9h1.5a2.5 2.5 0 0 0 0-5H18"/><path d="M4 22h16"/><path d="M10 14.66V17c0 .55-.47.98-.97 1.21C7.85 18.75 7 20.24 7 22"/><path d="M14 14.66V17c0 .55.47.98.97 1.21C16.15 18.75 17 20.24 17 22"/><path d="M18 2H6v7a6 6 0 0 0 12 0V2Z"/></svg>`,
        // v2.9.93: 资料受限图标（用户轮廓 + 警告三角）
        profileLimited: `<svg ${_S}><circle cx="12" cy="8" r="4"/><path d="M4 21v-2a8 8 0 0 1 14-5.3"/><path d="M18 14l3 5.5h-6z" fill="currentColor" fill-opacity="0.3"/><path d="M18 16.5v2" stroke-width="2"/></svg>`,
        // v2.9.33: 我的成就标签页图标（奖杯 + 星芒）
        achievement: `<svg ${_S}><path d="M6 9H4.5a2.5 2.5 0 0 1 0-5H6"/><path d="M18 9h1.5a2.5 2.5 0 0 0 0-5H18"/><path d="M4 22h16"/><path d="M10 14.66V17c0 .55-.47.98-.97 1.21C7.85 18.75 7 20.24 7 22"/><path d="M14 14.66V17c0 .55.47.98.97 1.21C16.15 18.75 17 20.24 17 22"/><path d="M18 2H6v7a6 6 0 0 0 12 0V2Z"/></svg>`,
        // v2.9.34: 云存档标签页图标（云+下载箭头）
        cloud: `<svg ${_S}><path d="M18 10h-1.26A8 8 0 1 0 9 20h9a5 5 0 0 0 0-10z"/><polyline points="12 13 12 21"/><polyline points="8 17 12 21 16 17"/></svg>`,
        // v2.9.32: DLC 收藏标签页图标（拼图块）
        puzzle: `<svg ${_S}><path d="M19.439 7.85c-.049.318.14.547.457.615a1.5 1.5 0 1 1-1.29 2.73c-.317-.117-.6-.005-.74.293a1.5 1.5 0 1 1-2.73-1.29c.117-.317.005-.6-.293-.74a1.5 1.5 0 1 1 1.29-2.73c.318.117.6.005.74-.293a1.5 1.5 0 1 1 2.73 1.29c-.117.317-.005.6.293.74z"/><path d="M2 6a4 4 0 0 1 4-4h12a4 4 0 0 1 4 4v12a4 4 0 0 1-4 4H6a4 4 0 0 1-4-4z" opacity="0.3"/></svg>`,
        // v2.9.51: 全局搜索图标（放大镜）
        search: `<svg ${_S}><circle cx="11" cy="11" r="7"/><line x1="21" y1="21" x2="16.65" y2="16.65"/></svg>`,
        // v2.11.40: 主题层——外观设置卡调色板图标
        palette: `<svg ${_S}><path d="M12 22a10 10 0 1 1 10-10c0 1.66-1.34 3-3 3h-1.6a1.4 1.4 0 0 0-1 2.39c.36.36.6.86.6 1.41A2.2 2.2 0 0 1 12 22z"/><circle cx="7.5" cy="11.5" r="1" fill="#a78bfa"/><circle cx="10.5" cy="7.5" r="1" fill="#22d3ee"/><circle cx="15" cy="7.5" r="1" fill="#f472b6"/><circle cx="17" cy="11.5" r="1" fill="#fbbf24"/></svg>`,
        // v2.9.51: 搜索结果跳转图标（外链箭头）
        external: `<svg ${_S}><path d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6"/><polyline points="15 3 21 3 21 9"/><line x1="10" y1="14" x2="21" y2="3"/></svg>`,
        // v2.9.90: 个人展柜标签页图标（展柜/陈列窗）
        showcase: `<svg ${_S}><path d="M3 9l1-5h16l1 5"/><path d="M4 9v11a1 1 0 0 0 1 1h14a1 1 0 0 0 1-1V9"/><line x1="9" y1="21" x2="9" y2="9"/><line x1="15" y1="21" x2="15" y2="9"/><line x1="3" y1="9" x2="21" y2="9"/></svg>`,
        // v2.9.90: 展柜编辑图标（铅笔）
        edit: `<svg ${_S}><path d="M11 4H4a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7"/><path d="M18.5 2.5a2.121 2.121 0 0 1 3 3L12 15l-4 1 1-4 9.5-9.5z"/></svg>`,
        // v2.9.91: 徽章图标（六角勋章 + 飘带）
        medal: `<svg ${_S}><circle cx="12" cy="9" r="6" fill="currentColor" fill-opacity="0.15"/><circle cx="12" cy="9" r="6"/><circle cx="12" cy="9" r="2" fill="currentColor"/><path d="M8.5 14L7 21l5-2.5L17 21l-1.5-7"/></svg>`,
    };

    // ==================== CSS 样式 ====================
    // v2.7.1: CSS 经 @require 外部库 sglv-shared-css 加载，库未加载时为空字符串（UI 无样式但功能可用）
    const CSS_STYLES = (typeof window.SGLVSharedCSS === 'string' && window.SGLVSharedCSS) || '';
    GM_addStyle(CSS_STYLES);

    // ==================== v2.11.0: 分散 CSS 集中提取 ====================
    // 原 2.10.0 散落在 body 各处的 GM_addStyle(`...`) 块全部提取为命名常量,
    // 一次性合并注入(CSS_INLINE)。与 4.7 精简模式对齐。

    const CSS_ACHIEVEMENT =`    /* ====== 主布局：左右分栏 ====== */
    .sglv-ach-layout { display: flex; height: 100%; min-height: 400px; background: linear-gradient(180deg, #0d1117 0%, #161b22 100%); border-radius: 8px; overflow: hidden; }

    /* ====== 左侧边栏 ====== */
    .sglv-ach-sidebar { width: 240px; flex-shrink: 0; display: flex; flex-direction: column; background: linear-gradient(180deg, rgba(22,27,34,0.95) 0%, rgba(13,17,23,0.95) 100%); border-right: 1px solid rgba(48,54,61,0.6); overflow-y: auto; }
    .sglv-ach-sidebar-header { display: flex; align-items: center; gap: 8px; padding: 16px 16px 12px; border-bottom: 1px solid rgba(48,54,61,0.4); }
    .sglv-ach-sidebar-title { font-size: 15px; font-weight: 700; color: #e6edf3; display: flex; align-items: center; gap: 6px; }
    .sglv-ach-sidebar-title svg { width: 20px; height: 20px; }

    /* v2.9.59: 用户信息区 — 参考设计渐变背景+径向光晕 */
    .sglv-ach-user-card { padding: 20px 16px; display: flex; flex-direction: column; align-items: center; gap: 6px; border-bottom: 1px solid rgba(48,54,61,0.4); background: linear-gradient(160deg, rgba(99,102,241,0.08), rgba(168,85,247,0.04)); position: relative; overflow: hidden; }
    .sglv-ach-user-card::after { content: ''; position: absolute; inset: -50%; background: radial-gradient(circle, rgba(168,85,247,0.12), transparent 60%); pointer-events: none; }
    .sglv-ach-user-avatar { width: 64px; height: 64px; border-radius: 50%; background: linear-gradient(135deg, #fde047, #d97706); display: flex; align-items: center; justify-content: center; flex-shrink: 0; position: relative; box-shadow: 0 8px 24px rgba(251,191,36,0.35); z-index: 1; }
    .sglv-ach-user-avatar svg { width: 32px; height: 32px; }
    .sglv-ach-user-level { position: absolute; bottom: -4px; right: -4px; background: #1c2128; border: 2px solid #fde047; border-radius: 10px; padding: 0 5px; font-size: 10px; font-weight: 700; color: #fde047; line-height: 1.4; }
    .sglv-ach-user-name { font-size: 14px; font-weight: 700; color: #e6edf3; position: relative; z-index: 1; }
    .sglv-ach-user-pts { font-size: 11px; color: #8b949e; position: relative; z-index: 1; }
    .sglv-ach-user-pts strong { color: #fbbf24; font-weight: 700; }

    /* v2.9.59: 分类导航 — 参考设计图标背景+激活渐变 */
    .sglv-ach-nav { padding: 8px 0; flex: 1; }
    .sglv-ach-nav-label { font-size: 10px; font-weight: 700; color: #6e7681; text-transform: uppercase; letter-spacing: 0.05em; padding: 8px 16px 4px; }
    .sglv-ach-nav-item { display: flex; align-items: center; gap: 10px; padding: 8px 12px; margin: 0 8px; cursor: pointer; transition: all 0.15s; border-radius: 10px; }
    .sglv-ach-nav-item:hover { background: rgba(99,102,241,0.08); }
    .sglv-ach-nav-item.active { background: linear-gradient(90deg, rgba(99,102,241,0.2), transparent); color: #fff; }
    .sglv-ach-nav-item-icon { width: 28px; height: 28px; border-radius: 8px; overflow: hidden; flex-shrink: 0; background: rgba(99,102,241,0.12); display: flex; align-items: center; justify-content: center; }
    .sglv-ach-nav-item-icon svg { width: 18px; height: 18px; }
    .sglv-ach-nav-item-name { font-size: 12px; font-weight: 600; color: #c9d1d9; flex: 1; }
    .sglv-ach-nav-item.active .sglv-ach-nav-item-name { color: #fff; font-weight: 700; }
    .sglv-ach-nav-item-badge { font-size: 10px; font-weight: 700; padding: 2px 8px; border-radius: 6px; flex-shrink: 0; background: rgba(99,102,241,0.15); color: #c7d2fe; }
    .sglv-ach-nav-item.active .sglv-ach-nav-item-badge { background: #6366f1; color: #fff; }
    .sglv-ach-nav-item-badge.complete { background: rgba(63,185,80,0.15); color: #3fb950; }
    .sglv-ach-nav-item-badge.partial { background: rgba(56,139,253,0.15); color: #58a6ff; }
    .sglv-ach-nav-item-badge.none { background: rgba(255,255,255,0.06); color: #6e7681; }

    /* v2.9.59: 侧边栏最近解锁 — 参考设计mini-icon渐变 */
    .sglv-ach-sidebar-recent { padding: 8px 0 12px; border-top: 1px solid rgba(48,54,61,0.4); }
    .sglv-ach-sidebar-recent-label { font-size: 10px; font-weight: 700; color: #6e7681; text-transform: uppercase; letter-spacing: 0.05em; padding: 8px 16px 4px; }
    .sglv-ach-sidebar-recent-item { display: flex; align-items: center; gap: 10px; padding: 6px 16px; transition: background 0.15s; cursor: pointer; border-radius: 8px; margin: 0 8px; }
    .sglv-ach-sidebar-recent-item:hover { background: rgba(99,102,241,0.06); }
    .sglv-ach-sidebar-recent-icon { width: 32px; height: 32px; border-radius: 8px; overflow: hidden; flex-shrink: 0; background: linear-gradient(135deg, #6366f1, #a78bfa); display: flex; align-items: center; justify-content: center; }
    .sglv-ach-sidebar-recent-icon svg { width: 20px; height: 20px; }
    .sglv-ach-sidebar-recent-info { flex: 1; min-width: 0; }
    .sglv-ach-sidebar-recent-name { font-size: 11px; font-weight: 600; color: #d2a8ff; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
    .sglv-ach-sidebar-recent-time { font-size: 9px; color: #6e7681; margin-top: 1px; }
    .sglv-ach-sidebar-recent-empty { font-size: 11px; color: #6e7681; padding: 8px 16px; opacity: 0.6; }

    /* ====== 右侧主内容区 ====== */
    .sglv-ach-main { flex: 1; display: flex; flex-direction: column; overflow: hidden; }

    /* v2.9.59: 统计概览区 — 参考设计玻璃态容器 */
    .sglv-ach-header { display: flex; align-items: center; gap: 20px; padding: 20px 24px; background: linear-gradient(135deg, rgba(30,41,59,0.6), rgba(15,23,42,0.6)); backdrop-filter: blur(20px); border-bottom: 1px solid rgba(99,102,241,0.12); flex-shrink: 0; }
    .sglv-ach-ring-wrap { position: relative; width: 88px; height: 88px; flex-shrink: 0; }
    .sglv-ach-ring-svg { width: 100%; height: 100%; transform: rotate(-90deg); }
    .sglv-ach-ring-bg { fill: none; stroke: rgba(99,102,241,0.12); stroke-width: 6; }
    .sglv-ach-ring-fill { fill: none; stroke: url(#ach-ring-grad); stroke-width: 6; stroke-linecap: round; transition: stroke-dashoffset 0.8s cubic-bezier(0.4,0,0.2,1); }
    .sglv-ach-ring-text { position: absolute; inset: 0; display: flex; flex-direction: column; align-items: center; justify-content: center; }
    .sglv-ach-ring-val { font-size: 22px; font-weight: 800; background: linear-gradient(135deg, #22d3ee, #a78bfa, #fbbf24); -webkit-background-clip: text; background-clip: text; -webkit-text-fill-color: transparent; line-height: 1; }
    .sglv-ach-ring-label { font-size: 9px; color: #64748b; margin-top: 2px; }
    /* === v2.9.40: 成就 KPI 卡片复用 sglv-playtime-kpi-card 统一风格 === */
    .sglv-ach-kpi-row { display: grid; grid-template-columns: repeat(4, 1fr); gap: 8px; flex: 1; min-width: 0; }
    .sglv-ach-reset-btn { padding: 8px 16px; border-radius: 10px; border: 1px solid rgba(239,68,68,0.3); background: rgba(239,68,68,0.08); color: #fca5a5; cursor: pointer; font-size: 12px; transition: all 0.2s; flex-shrink: 0; }
    .sglv-ach-reset-btn:hover { background: rgba(239,68,68,0.18); border-color: rgba(239,68,68,0.5); }

    /* v2.9.98: Steam 平台成就/徽章数横幅 */
    .sglv-ach-steam-banner {
        display: flex; align-items: center; gap: 12px;
        padding: 10px 16px; margin-bottom: 10px;
        background: linear-gradient(135deg, rgba(34,211,238,0.08), rgba(251,191,36,0.06), rgba(139,92,246,0.04));
        border: 1px solid rgba(34,211,238,0.15);
        border-radius: 12px;
        position: relative; overflow: hidden;
    }
    .sglv-ach-steam-banner::after {
        content: ''; position: absolute; top: -20px; right: -20px; width: 80px; height: 80px;
        background: radial-gradient(circle, rgba(251,191,36,0.12), transparent 60%);
        pointer-events: none;
    }
    .sglv-ach-steam-banner-icon {
        width: 36px; height: 36px; border-radius: 10px; flex-shrink: 0;
        display: flex; align-items: center; justify-content: center;
        background: linear-gradient(135deg, rgba(251,191,36,0.2), rgba(34,211,238,0.12));
        box-shadow: inset 0 0 0 1px rgba(255,255,255,0.06);
    }
    .sglv-ach-steam-banner-icon svg { width: 18px; height: 18px; color: #fbbf24; }
    .sglv-ach-steam-banner-info { flex: 1; }
    .sglv-ach-steam-banner-label { font-size: 11px; color: #8b949e; font-weight: 600; }
    .sglv-ach-steam-banner-val {
        font-size: 24px; font-weight: 800; line-height: 1.1;
        background: linear-gradient(135deg, #22d3ee, #fbbf24);
        -webkit-background-clip: text; background-clip: text; -webkit-text-fill-color: transparent;
        font-variant-numeric: tabular-nums;
    }
    .sglv-ach-steam-banner-note { font-size: 10px; color: #6e7681; flex-shrink: 0; }

    /* v2.9.59: 成就内容区 — 参考设计容器圆角 */
    .sglv-ach-content { flex: 1; padding: 16px 24px; overflow-y: auto; }
    .sglv-ach-content-header { display: flex; align-items: center; justify-content: space-between; margin-bottom: 14px; }
    .sglv-ach-content-title { font-size: 15px; font-weight: 700; color: #e6edf3; }
    .sglv-ach-content-count { font-size: 11px; color: #22d3ee; background: rgba(34,211,238,0.1); padding: 3px 10px; border-radius: 8px; font-weight: 600; }
    .sglv-ach-grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(320px, 1fr)); gap: 12px; }

    /* v2.9.59: 成就卡片 — 参考设计稀有度左边框+hover提升+图标光泽 */
    .sglv-ach-card { display: flex; align-items: flex-start; gap: 14px; padding: 16px 18px; border-radius: 14px; background: linear-gradient(135deg, rgba(15,23,42,0.6), rgba(30,41,59,0.4)); border: 1px solid rgba(99,102,241,0.1); transition: all 0.25s; position: relative; overflow: hidden; }
    .sglv-ach-card::before { content: ''; position: absolute; left: 0; top: 0; bottom: 0; width: 4px; background: var(--ach-rarity, #6366f1); opacity: 0.8; }
    .sglv-ach-card:hover { transform: translateY(-2px); border-color: rgba(99,102,241,0.3); box-shadow: 0 8px 24px rgba(0,0,0,0.3); }
    .sglv-ach-card.unlocked { --ach-rarity: #22c55e; border-color: rgba(34,197,94,0.15); background: linear-gradient(135deg, rgba(34,197,94,0.05), rgba(13,17,23,0.4)); }
    .sglv-ach-card.unlocked.rare { --ach-rarity: #22d3ee; }
    .sglv-ach-card.unlocked.epic { --ach-rarity: #a78bfa; }
    .sglv-ach-card.unlocked.legendary { --ach-rarity: #fbbf24; }
    .sglv-ach-card.locked { --ach-rarity: #6366f1; opacity: 0.6; }
    .sglv-ach-card.locked.rare { --ach-rarity: #22d3ee; }
    .sglv-ach-card.locked.epic { --ach-rarity: #a78bfa; }
    .sglv-ach-card.locked.legendary { --ach-rarity: #fbbf24; }
    /* v2.9.59: 图标 — 参考设计渐变背景+内阴影+光泽叠加 */
    .sglv-ach-card-icon { width: 52px; height: 52px; border-radius: 14px; display: flex; align-items: center; justify-content: center; flex-shrink: 0; overflow: hidden; position: relative; background: linear-gradient(135deg, rgba(99,102,241,0.15), rgba(139,92,246,0.08)); box-shadow: inset 0 1px 0 rgba(255,255,255,0.1), inset 0 -1px 0 rgba(0,0,0,0.2); }
    .sglv-ach-card-icon::after { content: ''; position: absolute; inset: 0; border-radius: 14px; background: linear-gradient(135deg, rgba(255,255,255,0.12) 0%, transparent 40%); pointer-events: none; }
    .sglv-ach-card-icon svg { width: 100%; height: 100%; display: block; }
    .sglv-ach-card.unlocked .sglv-ach-card-icon { box-shadow: inset 0 1px 0 rgba(255,255,255,0.15), inset 0 -1px 0 rgba(0,0,0,0.2), 0 4px 12px rgba(99,102,241,0.25); }
    .sglv-ach-card.locked .sglv-ach-card-icon { filter: grayscale(70%) brightness(0.5); }
    .sglv-ach-card-rarity { position: absolute; top: -2px; right: -2px; width: 14px; height: 14px; border-radius: 50%; border: 1.5px solid #0d1117; z-index: 2; }
    .sglv-ach-card-rarity.common { background: #8b949e; }
    .sglv-ach-card-rarity.rare { background: #22d3ee; }
    .sglv-ach-card-rarity.epic { background: #a78bfa; }
    .sglv-ach-card-rarity.legendary { background: #fbbf24; }
    .sglv-ach-card-body { flex: 1; min-width: 0; }
    .sglv-ach-card-head { display: flex; align-items: center; justify-content: space-between; gap: 8px; margin-bottom: 4px; }
    .sglv-ach-card-name { font-size: 14px; font-weight: 700; color: #e6edf3; display: flex; align-items: center; gap: 6px; }
    .sglv-ach-card.unlocked .sglv-ach-card-name { color: #4ade80; }
    /* v2.9.59: NEW 标签 */
    .sglv-ach-card-new-tag { font-size: 9px; background: #22c55e; color: #fff; padding: 1px 6px; border-radius: 4px; font-weight: 700; line-height: 1.4; }
    /* v2.9.59: 点数徽章 — 参考设计渐变背景 */
    .sglv-ach-card-pts { font-size: 11px; font-weight: 700; padding: 4px 10px; border-radius: 8px; flex-shrink: 0; white-space: nowrap; background: linear-gradient(135deg, rgba(251,191,36,0.15), rgba(245,158,11,0.1)); border: 1px solid rgba(251,191,36,0.3); color: #fbbf24; }
    .sglv-ach-card.unlocked .sglv-ach-card-pts { background: rgba(34,197,94,0.1); border-color: rgba(34,197,94,0.3); color: #4ade80; }
    .sglv-ach-card-desc { font-size: 11px; color: #94a3b8; line-height: 1.4; margin-bottom: 8px; }
    /* v2.9.59: 进度条 — 参考设计微光动画 */
    .sglv-ach-card-progress-wrap { display: flex; align-items: center; gap: 8px; }
    .sglv-ach-card-progress { flex: 1; height: 6px; background: rgba(34,211,238,0.08); border-radius: 3px; overflow: hidden; position: relative; }
    .sglv-ach-card-progress-fill { height: 100%; border-radius: 3px; transition: width 0.6s cubic-bezier(0.4,0,0.2,1); position: relative; }
    .sglv-ach-card.unlocked .sglv-ach-card-progress-fill { background: linear-gradient(90deg, #22d3ee, #34d399, #fbbf24); box-shadow: 0 0 8px rgba(34,211,238,0.4); }
    .sglv-ach-card.locked .sglv-ach-card-progress-fill { background: linear-gradient(90deg, #38bdf8, #a78bfa, #f59e0b); box-shadow: 0 0 8px rgba(56,189,248,0.25); }
    .sglv-ach-card-progress-fill::after { content: ''; position: absolute; inset: 0; background: linear-gradient(90deg, transparent, rgba(255,255,255,0.3), transparent); animation: sglv-ach-shimmer 2.5s infinite; }
    @keyframes sglv-ach-shimmer { 0% { transform: translateX(-100%); } 100% { transform: translateX(100%); } }
    .sglv-ach-card-progress-val { font-size: 10px; color: #64748b; white-space: nowrap; font-variant-numeric: tabular-nums; }
    .sglv-ach-card.unlocked .sglv-ach-card-progress-val { color: #22d3ee; font-weight: 600; }
    .sglv-ach-card-unlock-time { font-size: 9px; color: #6e7681; margin-top: 4px; }
    .sglv-ach-footer { font-size: 10px; color: #6e7681; text-align: center; padding: 10px 0; margin-top: 8px; border-top: 1px solid rgba(48,54,61,0.3); }`;

    const CSS_SHOWCASE =`    /* ====== 展柜主布局 ====== */
    .sglv-sc-wrap { display: flex; flex-direction: column; height: 100%; min-height: 400px; background: linear-gradient(180deg, #0d1117 0%, #161b22 100%); border-radius: 8px; overflow: hidden; }
    .sglv-sc-scroll { flex: 1; overflow-y: auto; padding: 20px; }

    /* ====== 英雄区（玩家档案横幅 — 紧凑版 v2） ====== */
    .sglv-sc-hero {
        position: relative; display: flex; align-items: center; gap: 12px;
        padding: 10px 14px; border-radius: 10px; margin-bottom: 14px; overflow: hidden;
        background: linear-gradient(135deg, rgba(99,102,241,0.10) 0%, rgba(168,85,247,0.06) 50%, rgba(6,182,212,0.04) 100%);
        border: 1px solid rgba(99,102,241,0.15);
    }
    .sglv-sc-hero::before {
        content: ''; position: absolute; inset: 0;
        background: radial-gradient(ellipse at top right, rgba(168,85,247,0.10), transparent 60%);
        pointer-events: none;
    }
    .sglv-sc-avatar-wrap { position: relative; flex-shrink: 0; z-index: 1; }
    .sglv-sc-avatar {
        width: 44px; height: 44px; border-radius: 50%; object-fit: cover;
        border: 2px solid rgba(255,255,255,0.12);
        box-shadow: 0 1px 8px rgba(0,0,0,0.35), 0 0 0 1px rgba(168,85,247,0.25);
        background: linear-gradient(135deg, #1a1a2e, #16213e);
    }
    .sglv-sc-avatar-placeholder {
        width: 44px; height: 44px; border-radius: 50%;
        display: flex; align-items: center; justify-content: center;
        background: linear-gradient(135deg, #6366f1, #8b5cf6);
        color: #fff; font-size: 18px; font-weight: 700;
        border: 2px solid rgba(255,255,255,0.12);
        box-shadow: 0 1px 8px rgba(0,0,0,0.35);
    }
    .sglv-sc-level-badge {
        display: inline-flex; align-items: center;
        padding: 1px 7px; border-radius: 8px;
        background: linear-gradient(135deg, #f59e0b, #d97706);
        color: #fff; font-size: 10px; font-weight: 800;
        border: 1px solid rgba(245,158,11,0.4);
        box-shadow: 0 1px 4px rgba(245,158,11,0.25);
        font-variant-numeric: tabular-nums; line-height: 1.3;
        white-space: nowrap; flex-shrink: 0;
    }
    .sglv-sc-hero-info { flex: 1; min-width: 0; z-index: 1; }
    .sglv-sc-hero-name-row { display: flex; align-items: center; gap: 6px; flex-wrap: wrap; }
    .sglv-sc-hero-name { font-size: 15px; font-weight: 800; color: #f1f5f9; line-height: 1.2; text-shadow: 0 1px 3px rgba(0,0,0,0.4); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; max-width: 200px; }
    .sglv-sc-hero-country {
        font-size: 10px; color: #94a3b8; display: inline-flex; align-items: center; gap: 3px;
        padding: 1px 6px; border-radius: 8px; background: rgba(148,163,184,0.08);
        border: 1px solid rgba(148,163,184,0.1); white-space: nowrap;
    }
    .sglv-sc-hero-country img { width: 14px; height: 10px; border-radius: 1px; }
    .sglv-sc-hero-stats { display: flex; gap: 0; margin-top: 8px; flex-wrap: wrap; }
    .sglv-sc-hero-stat { display: flex; align-items: center; gap: 6px; padding: 0 14px; border-right: 1px solid rgba(148,163,184,0.10); }
    .sglv-sc-hero-stat:first-child { padding-left: 0; }
    .sglv-sc-hero-stat:last-child { border-right: none; }
    .sglv-sc-hero-stat svg { width: 14px; height: 14px; color: #818cf8; flex-shrink: 0; }
    .sglv-sc-hero-stat-val { font-size: 14px; font-weight: 700; color: #e2e8f0; font-variant-numeric: tabular-nums; line-height: 1; }
    .sglv-sc-hero-stat-label { font-size: 10px; color: #64748b; line-height: 1; margin-top: 2px; }

    /* ====== 双栏布局 ====== */
    .sglv-sc-cols { display: flex; gap: 20px; align-items: flex-start; }
    .sglv-sc-left { flex: 1; min-width: 0; display: flex; flex-direction: column; gap: 20px; }
    .sglv-sc-right { width: 340px; flex-shrink: 0; }

    /* ====== 区块卡片通用 ====== */
    .sglv-sc-card {
        background: rgba(22,27,34,0.6); border: 1px solid rgba(48,54,61,0.5);
        border-radius: 10px; overflow: hidden; backdrop-filter: blur(8px);
    }
    .sglv-sc-card-header {
        display: flex; align-items: center; gap: 8px;
        padding: 14px 16px 10px; border-bottom: 1px solid rgba(48,54,61,0.3);
    }
    .sglv-sc-card-header svg { width: 18px; height: 18px; color: #a78bfa; flex-shrink: 0; }
    .sglv-sc-card-title { font-size: 14px; font-weight: 700; color: #e6edf3; }
    .sglv-sc-card-body { padding: 14px 16px; }

    /* ====== 游戏封面网格（4×2 竖版） ====== */
    .sglv-sc-cover-grid { display: grid; grid-template-columns: repeat(4, 1fr); gap: 10px; }
    .sglv-sc-cover-item {
        position: relative; aspect-ratio: 2/3; border-radius: 8px; overflow: hidden;
        background: #1a1a2e; cursor: pointer;
        border: 1px solid rgba(255,255,255,0.06);
        transition: border-color 0.2s, box-shadow 0.2s;
    }
    .sglv-sc-cover-item:hover { border-color: rgba(168,85,247,0.5); box-shadow: 0 4px 16px rgba(168,85,247,0.2); }
    .sglv-sc-cover-item img { width: 100%; height: 100%; object-fit: cover; display: block; }
    .sglv-sc-cover-overlay {
        position: absolute; inset: 0; display: flex; flex-direction: column;
        justify-content: flex-end; padding: 8px;
        background: linear-gradient(0deg, rgba(0,0,0,0.85) 0%, rgba(0,0,0,0.2) 50%, transparent 100%);
        opacity: 0; transition: opacity 0.2s;
    }
    .sglv-sc-cover-item:hover .sglv-sc-cover-overlay { opacity: 1; }
    .sglv-sc-cover-name { font-size: 11px; font-weight: 600; color: #f1f5f9; line-height: 1.3; overflow: hidden; text-overflow: ellipsis; display: -webkit-box; -webkit-line-clamp: 2; -webkit-box-orient: vertical; }
    .sglv-sc-cover-hours { font-size: 10px; color: #a5b4fc; margin-top: 2px; font-variant-numeric: tabular-nums; }
    .sglv-sc-cover-placeholder {
        display: flex; align-items: center; justify-content: center;
        width: 100%; height: 100%; color: #475569; font-size: 11px;
    }

    /* v2.9.99: 骨架屏样式 — shimmer 动画占位块 */
    .sglv-sc-sk-block {
        background: linear-gradient(90deg, rgba(99,102,241,0.06) 25%, rgba(99,102,241,0.15) 37%, rgba(99,102,241,0.06) 63%);
        background-size: 400% 100%;
        animation: sglv-sc-shimmer 1.4s ease infinite;
    }
    @keyframes sglv-sc-shimmer {
        0% { background-position: 100% 50%; }
        100% { background-position: 0% 50%; }
    }
    .sglv-sc-skeleton-wrap .sglv-sc-playtime-item,
    .sglv-sc-skeleton-wrap .sglv-sc-ach-item {
        background: transparent;
        border-left: none;
    }

    /* ====== 编辑按钮 ====== */
    .sglv-sc-edit-btn {
        display: inline-flex; align-items: center; gap: 5px;
        padding: 5px 12px; border-radius: 6px; font-size: 12px; font-weight: 600;
        background: rgba(99,102,241,0.15); border: 1px solid rgba(99,102,241,0.3);
        color: #a5b4fc; cursor: pointer; transition: background 0.15s, border-color 0.15s;
        margin-left: auto;
    }
    .sglv-sc-edit-btn:hover { background: rgba(99,102,241,0.25); border-color: rgba(99,102,241,0.5); }
    .sglv-sc-edit-btn svg { width: 14px; height: 14px; }

    /* ====== 最近游玩时长列表 ====== */
    .sglv-sc-playtime-list { display: flex; flex-direction: column; gap: 8px; }
    .sglv-sc-playtime-item { display: flex; align-items: center; gap: 10px; padding: 8px 10px; border-radius: 8px; background: rgba(13,17,23,0.5); transition: background 0.15s; }
    .sglv-sc-playtime-item:hover { background: rgba(99,102,241,0.08); }
    .sglv-sc-playtime-icon { width: 32px; height: 32px; border-radius: 6px; object-fit: cover; flex-shrink: 0; background: #1a1a2e; }
    .sglv-sc-playtime-icon-ph { width: 32px; height: 32px; border-radius: 6px; display: flex; align-items: center; justify-content: center; background: #1a1a2e; color: #475569; font-size: 10px; flex-shrink: 0; }
    .sglv-sc-playtime-info { flex: 1; min-width: 0; }
    .sglv-sc-playtime-name { font-size: 12px; font-weight: 600; color: #cbd5e1; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
    .sglv-sc-playtime-meta { font-size: 10px; margin-top: 2px; display: flex; align-items: center; gap: 0; }
    .sglv-sc-playtime-bar { height: 4px; background: rgba(99,102,241,0.1); border-radius: 2px; margin-top: 4px; overflow: hidden; }
    .sglv-sc-playtime-bar-fill { height: 100%; border-radius: 2px; background: linear-gradient(90deg, #6366f1, #a855f7); transition: width 0.6s ease; }
    .sglv-sc-playtime-empty { text-align: center; padding: 24px; color: #64748b; font-size: 12px; }

    /* ====== 最近解锁成就列表 ====== */
    .sglv-sc-ach-list { display: flex; flex-direction: column; gap: 8px; }
    .sglv-sc-ach-item { display: flex; align-items: center; gap: 10px; padding: 10px; border-radius: 8px; background: rgba(13,17,23,0.5); border-left: 3px solid transparent; transition: background 0.15s, border-color 0.15s; }
    .sglv-sc-ach-item:hover { background: rgba(99,102,241,0.08); }
    .sglv-sc-ach-item.rarity-common { border-left-color: #64748b; }
    .sglv-sc-ach-item.rarity-rare { border-left-color: #58a6ff; }
    .sglv-sc-ach-item.rarity-epic { border-left-color: #a855f7; }
    .sglv-sc-ach-item.rarity-legendary { border-left-color: #fbbf24; }
    .sglv-sc-ach-icon { width: 36px; height: 36px; border-radius: 8px; display: flex; align-items: center; justify-content: center; flex-shrink: 0; background: rgba(99,102,241,0.1); }
    .sglv-sc-ach-icon svg { width: 22px; height: 22px; }
    .sglv-sc-ach-info { flex: 1; min-width: 0; }
    .sglv-sc-ach-name { font-size: 12px; font-weight: 600; color: #e2e8f0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
    .sglv-sc-ach-meta { font-size: 10px; color: #64748b; margin-top: 2px; display: flex; align-items: center; gap: 6px; }
    .sglv-sc-ach-pts { font-size: 11px; font-weight: 700; color: #fbbf24; flex-shrink: 0; font-variant-numeric: tabular-nums; }
    .sglv-sc-ach-empty { text-align: center; padding: 24px; color: #64748b; font-size: 12px; }

    /* ====== 玩家画像标签 ====== */
    .sglv-sc-tags { display: flex; flex-wrap: wrap; gap: 8px; padding: 14px 16px; }
    .sglv-sc-tag {
        display: inline-flex; align-items: center; gap: 4px;
        padding: 5px 12px; border-radius: 16px; font-size: 11px; font-weight: 600;
        border: 1px solid rgba(255,255,255,0.08);
    }
    .sglv-sc-tag-collector { background: rgba(139,92,246,0.12); border-color: rgba(139,92,246,0.3); color: #c4b5fd; }
    .sglv-sc-tag-playtime { background: rgba(6,182,212,0.12); border-color: rgba(6,182,212,0.3); color: #67e8f9; }
    .sglv-sc-tag-mastery { background: rgba(16,185,129,0.12); border-color: rgba(16,185,129,0.3); color: #6ee7b7; }
    .sglv-sc-tag-diversity { background: rgba(249,115,22,0.12); border-color: rgba(249,115,22,0.3); color: #fdba74; }
    .sglv-sc-tag-loyalty { background: rgba(244,114,182,0.12); border-color: rgba(244,114,182,0.3); color: #f9a8d4; }
    .sglv-sc-tag-special { background: rgba(251,191,36,0.12); border-color: rgba(251,191,36,0.3); color: #fcd34d; }

    /* ====== 封面选择器弹窗（内嵌于游戏库浮窗内，不遮挡浮窗本身） ====== */
    .sglv-panel .sglv-sc-picker-overlay {
        position: absolute; inset: 0; z-index: 1000002;
        background: rgba(0,0,0,0.65); backdrop-filter: blur(4px);
        display: flex; align-items: center; justify-content: center;
        border-radius: inherit;
        animation: sglv-sc-fade-in 0.2s ease;
    }
    .sglv-sc-picker {
        width: 720px; max-width: calc(100% - 40px); max-height: calc(100% - 40px);
        background: #161b22; border: 1px solid rgba(48,54,61,0.6);
        border-radius: 12px; display: flex; flex-direction: column; overflow: hidden;
        box-shadow: 0 20px 60px rgba(0,0,0,0.6);
    }
    .sglv-sc-picker-header { display: flex; align-items: center; gap: 10px; padding: 16px 20px; border-bottom: 1px solid rgba(48,54,61,0.4); }
    .sglv-sc-picker-title { font-size: 15px; font-weight: 700; color: #e6edf3; flex: 1; }
    .sglv-sc-picker-search { width: 200px; padding: 6px 10px; border-radius: 6px; border: 1px solid rgba(48,54,61,0.6); background: #0d1117; color: #e2e8f0; font-size: 12px; outline: none; }
    .sglv-sc-picker-search:focus { border-color: rgba(99,102,241,0.5); }
    .sglv-sc-picker-close { width: 28px; height: 28px; border-radius: 6px; border: none; background: rgba(255,255,255,0.06); color: #94a3b8; cursor: pointer; display: flex; align-items: center; justify-content: center; font-size: 16px; }
    .sglv-sc-picker-close:hover { background: rgba(255,255,255,0.12); color: #f1f5f9; }
    .sglv-sc-picker-body { flex: 1; overflow-y: auto; padding: 16px 20px; overscroll-behavior: contain; }
    .sglv-sc-picker-grid { display: grid; grid-template-columns: repeat(6, 1fr); gap: 10px; }
    .sglv-sc-picker-item {
        position: relative; aspect-ratio: 2/3; border-radius: 6px; overflow: hidden;
        cursor: pointer; border: 2px solid transparent;
        transition: border-color 0.15s, transform 0.15s;
    }
    .sglv-sc-picker-item:hover { transform: scale(1.03); }
    .sglv-sc-picker-item.selected { border-color: #22c55e; }
    .sglv-sc-picker-item img { width: 100%; height: 100%; object-fit: cover; }
    .sglv-sc-picker-item-name { position: absolute; bottom: 0; left: 0; right: 0; padding: 4px 6px; font-size: 9px; color: #fff; background: linear-gradient(0deg, rgba(0,0,0,0.85), transparent); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
    .sglv-sc-picker-check { position: absolute; top: 4px; right: 4px; width: 20px; height: 20px; border-radius: 50%; background: #22c55e; color: #fff; display: none; align-items: center; justify-content: center; font-size: 12px; font-weight: 700; }
    .sglv-sc-picker-item.selected .sglv-sc-picker-check { display: flex; }
    .sglv-sc-picker-footer { display: flex; align-items: center; gap: 12px; padding: 12px 20px; border-top: 1px solid rgba(48,54,61,0.4); }
    .sglv-sc-picker-count { font-size: 12px; color: #94a3b8; }
    .sglv-sc-picker-count strong { color: #22c55e; }
    .sglv-sc-picker-save { padding: 7px 18px; border-radius: 6px; border: none; background: linear-gradient(135deg, #6366f1, #8b5cf6); color: #fff; font-size: 13px; font-weight: 600; cursor: pointer; margin-left: auto; transition: opacity 0.15s; }
    .sglv-sc-picker-save:hover { opacity: 0.9; }
    .sglv-sc-picker-save:disabled { opacity: 0.4; cursor: not-allowed; }

    /* ====== v2.9.94: 英雄区徽章展示区 ====== */
    .sglv-sc-hero-divider { width: 1px; height: 44px; background: rgba(148,163,184,0.12); flex-shrink: 0; z-index: 1; }
    .sglv-sc-hero-badges { display: flex; gap: 8px; align-items: center; flex-shrink: 0; z-index: 1; }
    .sglv-sc-hero-badge {
        width: 48px; height: 48px; border-radius: 8px;
        background: rgba(255,255,255,0.04); border: 1.5px solid rgba(139,92,246,0.3);
        display: flex; align-items: center; justify-content: center;
        cursor: pointer; transition: border-color 0.16s, transform 0.16s, box-shadow 0.16s;
        position: relative; overflow: visible;
    }
    .sglv-sc-hero-badge:hover { border-color: rgba(139,92,246,0.6); transform: translateY(-2px); box-shadow: 0 4px 12px rgba(139,92,246,0.2); }
    .sglv-sc-hero-badge img { width: 36px; height: 36px; object-fit: contain; border-radius: 4px; }
    .sglv-sc-hero-badge-fallback { display: flex; align-items: center; justify-content: center; width: 100%; height: 100%; color: #818cf8; }
    .sglv-sc-hero-badge-fallback svg { width: 22px; height: 22px; }
    .sglv-sc-hero-badge-lvl {
        position: absolute; bottom: -5px; right: -5px;
        font-size: 9px; font-weight: 700; color: #fff;
        background: linear-gradient(135deg, #8b5cf6, #6366f1);
        border-radius: 4px; padding: 0 4px; line-height: 14px;
        box-shadow: 0 1px 3px rgba(0,0,0,0.3); white-space: nowrap;
    }
    .sglv-sc-hero-badge-foil-tag {
        position: absolute; top: -5px; left: -5px;
        font-size: 8px; font-weight: 700; color: #1a1a2e;
        background: linear-gradient(135deg, #fbbf24, #f59e0b);
        border-radius: 3px; padding: 0 3px; line-height: 12px; white-space: nowrap;
    }
    .sglv-sc-hero-badge-empty {
        width: 48px; height: 48px; border-radius: 8px;
        border: 1.5px dashed rgba(148,163,184,0.2);
        display: flex; align-items: center; justify-content: center;
        color: rgba(148,163,184,0.4); font-size: 20px; cursor: pointer;
        transition: border-color 0.16s, color 0.16s;
    }
    .sglv-sc-hero-badge-empty:hover { border-color: rgba(139,92,246,0.4); color: rgba(139,92,246,0.6); }
    .sglv-sc-hero-badge-edit {
        width: 28px; height: 28px; border-radius: 6px;
        background: rgba(139,92,246,0.15); border: 1px solid rgba(139,92,246,0.25);
        color: #a78bfa; cursor: pointer; flex-shrink: 0;
        display: flex; align-items: center; justify-content: center;
        transition: background 0.16s, border-color 0.16s;
    }
    .sglv-sc-hero-badge-edit:hover { background: rgba(139,92,246,0.25); border-color: rgba(139,92,246,0.5); }
    .sglv-sc-hero-badge-edit svg { width: 14px; height: 14px; }

    /* ====== v2.9.94: 徽章选择器弹窗 ====== */
    .sglv-sc-badge-picker { max-width: 680px; }
    .sglv-sc-badge-tabs { display: flex; gap: 6px; padding: 10px 20px; border-bottom: 1px solid rgba(48,54,61,0.3); flex-wrap: wrap; }
    .sglv-sc-badge-tab {
        padding: 5px 12px; border-radius: 6px; border: 1px solid rgba(48,54,61,0.5);
        background: transparent; color: #94a3b8; font-size: 12px; font-weight: 600;
        cursor: pointer; transition: all 0.16s; white-space: nowrap;
    }
    .sglv-sc-badge-tab:hover { background: rgba(255,255,255,0.04); color: #c4b5fd; }
    .sglv-sc-badge-tab.active { background: rgba(139,92,246,0.15); border-color: rgba(139,92,246,0.4); color: #c4b5fd; }
    .sglv-sc-badge-grid { display: grid; grid-template-columns: repeat(4, 1fr); gap: 10px; }
    .sglv-sc-badge-pick-item {
        position: relative; border-radius: 8px; overflow: hidden;
        background: rgba(22,27,34,0.6); border: 1.5px solid rgba(48,54,61,0.5);
        cursor: pointer; transition: border-color 0.16s, transform 0.16s;
        display: flex; flex-direction: column; gap: 6px; padding: 8px;
    }
    .sglv-sc-badge-pick-item:hover { border-color: rgba(139,92,246,0.4); transform: scale(1.02); }
    .sglv-sc-badge-pick-item.selected { border-color: #22c55e; }
    .sglv-sc-badge-pick-icon {
        width: 100%; height: 64px; display: flex; align-items: center; justify-content: center;
        background: rgba(13,17,23,0.4); border-radius: 6px; overflow: hidden;
    }
    .sglv-sc-badge-pick-icon img { max-width: 56px; max-height: 56px; object-fit: contain; }
    .sglv-sc-badge-pick-icon.no-icon { }
    .sglv-sc-badge-pick-noicon { font-size: 24px; opacity: 0.5; }
    .sglv-sc-badge-pick-info { flex: 1; min-width: 0; }
    .sglv-sc-badge-pick-name { font-size: 11px; font-weight: 600; color: #e2e8f0; line-height: 1.3; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
    .sglv-sc-badge-pick-meta { display: flex; gap: 4px; flex-wrap: wrap; margin-top: 3px; }
    .sglv-sc-badge-pick-meta span { font-size: 9px; padding: 0 4px; border-radius: 3px; line-height: 14px; }
    .sglv-sc-badge-foil { background: rgba(245,158,11,0.15); color: #fbbf24; }
    .sglv-sc-badge-lvl { background: rgba(139,92,246,0.15); color: #c4b5fd; }
    .sglv-sc-badge-pick-xp { background: rgba(34,197,94,0.1); color: #86efac; }
    .sglv-sc-badge-pick-item .sglv-sc-picker-check { top: 4px; right: 4px; }

    @keyframes sglv-sc-fade-in { from { opacity: 0; } to { opacity: 1; } }

    /* ====== 加载/空状态 ====== */
    .sglv-sc-loading { display: flex; flex-direction: column; align-items: center; justify-content: center; height: 100%; gap: 12px; color: #8a9ba8; }
    .sglv-sc-loading svg { animation: sglv-spin 1s linear infinite; }
    @media (prefers-reduced-motion: reduce) {
        .sglv-sc-cover-overlay, .sglv-sc-cover-item, .sglv-sc-playtime-item, .sglv-sc-ach-item, .sglv-sc-picker-item, .sglv-sc-hero-badge, .sglv-sc-hero-badge-empty, .sglv-sc-badge-pick-item { transition: none !important; }
        .sglv-panel .sglv-sc-picker-overlay { animation: none !important; }
        .sglv-sc-loading svg { animation: none !important; }
    }`;

    const CSS_CLOUDSAVE =`    /* ====== 云存档主布局 ====== */
    .sglv-cs-wrap { display: flex; gap: 0; height: 100%; min-height: 400px; }
    .sglv-cs-side { width: 540px; flex-shrink: 0; border-right: 1px solid rgba(255,255,255,0.06); padding: 14px; overflow-y: auto; }
    .sglv-cs-list-wrap { flex: 1; display: flex; flex-direction: column; overflow: hidden; }

    /* ====== 状态视图（加载/错误/空） ====== */
    .sglv-cs-state-box { display: flex; flex-direction: column; align-items: center; justify-content: center; height: 100%; gap: 12px; padding: 40px; text-align: center; width: 100%; }
    .sglv-cs-state-icon { font-size: 36px; }
    .sglv-cs-state-msg { font-size: 14px; color: var(--sglv-text-1, #e2e8f0); max-width: 360px; line-height: 1.5; }
    .sglv-cs-state-tip { font-size: 11px; color: var(--sglv-text-2, #94a3b8); }
    .sglv-cs-action-btn { padding: 8px 20px; border-radius: 8px; border: 1px solid rgba(139,92,246,0.4); background: rgba(139,92,246,0.12); color: #c4b5fd; cursor: pointer; font-size: 13px; transition: all 0.2s; }
    .sglv-cs-action-btn:hover { background: rgba(139,92,246,0.25); border-color: rgba(139,92,246,0.6); }

    /* ====== KPI 卡片（v2.9.36: 炫彩边框 + 色彩变体） ====== */
    /* === v2.9.40: 云存档 KPI 卡片复用 sglv-playtime-kpi-card 统一风格（4 列均分） === */
    .sglv-cs-kpi-row { display: grid; grid-template-columns: repeat(4, 1fr); gap: 10px; margin-bottom: 18px; }
    @media (max-width: 1100px) { .sglv-cs-kpi-row { grid-template-columns: repeat(2, 1fr) !important; } }

    /* ====== 仪表盘区块 ====== */
    .sglv-cs-section { margin-bottom: 16px; }
    .sglv-cs-section-title { font-size: 12px; font-weight: 600; color: var(--sglv-text-1, #e2e8f0); margin-bottom: 8px; }

    /* ====== TOP 10 ====== */
    .sglv-cs-top10 { display: flex; flex-direction: column; gap: 6px; }
    .sglv-cs-top10-item { display: flex; align-items: center; gap: 6px; font-size: 11px; }
    .sglv-cs-top10-rank { width: 16px; text-align: center; font-weight: 700; color: var(--sglv-text-2, #94a3b8); flex-shrink: 0; }
    .sglv-cs-top10-name { flex-shrink: 0; min-width: 0; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; color: var(--sglv-text-1, #e2e8f0); width: 140px; }
    .sglv-cs-top10-bar-track { flex: 1; height: 8px; background: rgba(255,255,255,0.05); border-radius: 4px; overflow: hidden; min-width: 30px; }
    .sglv-cs-top10-bar { height: 100%; background: linear-gradient(90deg, #8b5cf6, #6366f1); border-radius: 4px; transition: width 0.4s ease; }
    .sglv-cs-top10-size { flex-shrink: 0; color: var(--sglv-text-2, #94a3b8); font-size: 10px; min-width: 44px; text-align: right; }

    /* ====== 分布图 ====== */
    /* v2.9.43: 大小分布 + 文件数分布 并排两栏 */
    .sglv-cs-dist-pair { display: grid; grid-template-columns: 1fr 1fr; gap: 12px; margin-bottom: 16px; }
    .sglv-cs-dist-card { background: rgba(255,255,255,0.02); border: 1px solid rgba(255,255,255,0.05); border-radius: 8px; padding: 10px 8px 8px; }
    .sglv-cs-dist-card .sglv-cs-section-title { font-size: 11px; margin-bottom: 6px; text-align: center; }
    .sglv-cs-dist { display: flex; align-items: flex-end; gap: 8px; height: 130px; }
    .sglv-cs-dist-col { flex: 1; display: flex; flex-direction: column; align-items: center; height: 100%; justify-content: flex-end; min-width: 0; }
    .sglv-cs-dist-bar-track { width: 100%; flex: 1; display: flex; align-items: flex-end; justify-content: center; min-height: 2px; }
    .sglv-cs-dist-bar { width: 50%; max-width: 32px; background: linear-gradient(180deg, #8b5cf6, #6366f1); border-radius: 3px 3px 0 0; min-height: 2px; transition: height 0.4s ease; }
    .sglv-cs-dist-bar-2 { background: linear-gradient(180deg, #3b82f6, #06b6d4); }
    .sglv-cs-dist-val { font-size: 10px; font-weight: 600; color: var(--sglv-text-1, #e2e8f0); margin-top: 3px; }
    .sglv-cs-dist-label { font-size: 9px; color: var(--sglv-text-2, #94a3b8); text-align: center; margin-top: 1px; }

    /* ====== Diff 徽章 ====== */
    .sglv-cs-diff-box { display: flex; gap: 6px; flex-wrap: wrap; margin-bottom: 12px; }
    .sglv-cs-diff-badge { font-size: 10px; padding: 3px 8px; border-radius: 6px; font-weight: 600; }
    .sglv-cs-diff-badge.new { background: rgba(34,197,94,0.15); color: #4ade80; border: 1px solid rgba(34,197,94,0.3); }
    .sglv-cs-diff-badge.changed { background: rgba(251,191,36,0.15); color: #fbbf24; border: 1px solid rgba(251,191,36,0.3); }
    .sglv-cs-diff-badge.removed { background: rgba(239,68,68,0.15); color: #f87171; border: 1px solid rgba(239,68,68,0.3); }

    /* ====== 底部 ====== */
    .sglv-cs-footer { display: flex; align-items: center; gap: 8px; margin-top: auto; padding-top: 12px; border-top: 1px solid rgba(255,255,255,0.04); flex-wrap: wrap; }
    .sglv-cs-source-badge { font-size: 10px; padding: 2px 8px; border-radius: 6px; background: rgba(139,92,246,0.12); color: #c4b5fd; border: 1px solid rgba(139,92,246,0.2); }
    .sglv-cs-updated { font-size: 10px; color: var(--sglv-text-2, #94a3b8); }
    .sglv-cs-refresh-btn { margin-left: auto; background: none; border: none; color: var(--sglv-text-2, #94a3b8); cursor: pointer; padding: 4px; border-radius: 6px; display: flex; align-items: center; transition: all 0.2s; }
    .sglv-cs-refresh-btn:hover { color: #c4b5fd; background: rgba(139,92,246,0.12); }
    .sglv-cs-refresh-btn svg { width: 14px; height: 14px; }

    /* ====== 工具栏 ====== */
    .sglv-cs-toolbar { display: flex; gap: 8px; padding: 10px 12px; border-bottom: 1px solid rgba(255,255,255,0.06); flex-shrink: 0; }
    .sglv-cs-search { flex: 1; background: rgba(255,255,255,0.05); border: 1px solid rgba(255,255,255,0.08); border-radius: 8px; padding: 6px 12px; color: var(--sglv-text-1, #e2e8f0); font-size: 12px; outline: none; transition: border-color 0.2s; }
    .sglv-cs-search:focus { border-color: rgba(139,92,246,0.5); }
    .sglv-cs-search::placeholder { color: var(--sglv-text-2, #94a3b8); }
    .sglv-cs-sort { background: rgba(255,255,255,0.05); border: 1px solid rgba(255,255,255,0.08); border-radius: 8px; padding: 6px 8px; color: var(--sglv-text-1, #e2e8f0); font-size: 12px; outline: none; cursor: pointer; }

    /* ====== 列表头 ====== */
    .sglv-cs-list-header { display: flex; align-items: center; justify-content: space-between; padding: 8px 12px; font-size: 12px; font-weight: 600; color: var(--sglv-text-1, #e2e8f0); flex-shrink: 0; }
    .sglv-cs-list-count { font-size: 11px; color: var(--sglv-text-2, #94a3b8); background: rgba(255,255,255,0.05); padding: 2px 8px; border-radius: 6px; }

    /* ====== 游戏列表 ====== */
    .sglv-cs-game-list { flex: 1; overflow-y: auto; padding: 0 12px 12px; }
    .sglv-cs-game-row { display: flex; align-items: center; gap: 10px; padding: 8px 10px; border-radius: 8px; transition: background 0.15s; margin-bottom: 4px; }
    .sglv-cs-game-row:hover { background: rgba(255,255,255,0.04); }
    .sglv-cs-game-cover { width: 46px; height: 22px; border-radius: 4px; object-fit: cover; flex-shrink: 0; background: rgba(255,255,255,0.04); }
    /* v2.9.44: 通用 cover failed 样式（sglv-cover-fallback.lib.js 添加） */
    .sglv-cs-cover-failed, .sglv-cover-failed { object-fit: contain !important; padding: 4px; opacity: 0.6; }
    .sglv-cs-game-cover-fallback { width: 46px; height: 22px; border-radius: 4px; flex-shrink: 0; display: flex; align-items: center; justify-content: center; background: linear-gradient(135deg, rgba(59,130,246,0.12), rgba(139,92,246,0.08)); font-size: 9px; color: var(--sglv-text-2, #94a3b8); }
    .sglv-cs-game-info { display: flex; flex-direction: column; gap: 2px; min-width: 0; flex: 1; }
    .sglv-cs-game-name { font-size: 12px; color: var(--sglv-text-1, #e2e8f0); white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
    .sglv-cs-game-appid { font-size: 10px; color: var(--sglv-text-2, #94a3b8); }
    .sglv-cs-game-stats { display: flex; align-items: center; gap: 8px; flex-shrink: 0; }
    .sglv-cs-game-files { font-size: 11px; color: var(--sglv-text-2, #94a3b8); }
    .sglv-cs-game-size { font-size: 11px; color: var(--sglv-text-1, #e2e8f0); font-weight: 600; min-width: 60px; text-align: right; }
    .sglv-cs-game-dl { font-size: 10px; color: #66c0f4; text-decoration: none; flex-shrink: 0; opacity: 0.7; transition: opacity 0.15s; }
    .sglv-cs-game-dl:hover { opacity: 1; text-decoration: underline; }
    .sglv-cs-status-badge { font-size: 9px; padding: 2px 6px; border-radius: 4px; font-weight: 700; }
    .sglv-cs-status-badge.new { background: rgba(34,197,94,0.15); color: #4ade80; }
    .sglv-cs-status-badge.changed { background: rgba(251,191,36,0.15); color: #fbbf24; }
    .sglv-cs-list-empty { text-align: center; padding: 40px 20px; font-size: 13px; color: var(--sglv-text-2, #94a3b8); }`;

    const CSS_STAGE =`    #sglv-stage-progress {
        padding: 8px 16px;
        background: linear-gradient(180deg, rgba(167,139,250,0.08), transparent);
        border-bottom: 1px solid rgba(167,139,250,0.15);
        display: block;
    }
    #sglv-stage-progress .sglv-stage-progress-row {
        display: flex;
        align-items: center;
        gap: 12px;
    }
    #sglv-stage-progress .sglv-stage-progress-bar {
        flex: 1;
        height: 6px;
        background: rgba(255,255,255,0.06);
        border-radius: 3px;
        overflow: hidden;
        position: relative;
    }
    #sglv-stage-progress .sglv-stage-progress-fill {
        height: 100%;
        background: linear-gradient(90deg, #a78bfa 0%, #38bdf8 100%);
        width: 0%;
        transition: width 0.25s ease-out;
        border-radius: 3px;
    }
    #sglv-stage-progress .sglv-stage-progress-text {
        flex-shrink: 0;
        font-size: 12px;
        color: #94a3b8;
        min-width: 200px;
        text-align: right;
        font-variant-numeric: tabular-nums;
    }`;

    const CSS_HEADER =`    /* === 紧凑页头：删除 h2 标题占用空间，padding 收紧 === */
    .sglv-panel > .sglv-header {
        padding: 8px 14px !important;
        gap: 12px;
        cursor: move;             /* v2.9.22: 整个 header 作为拖动手柄 */
        user-select: none;
    }
    .sglv-panel > .sglv-header h2 { display: none !important; }

    /* === v2.9.22: 保留最左侧 Steam 图标作为品牌标识（去掉"游戏库"文字） === */
    .sglv-header-brand {
        width: 24px;
        height: 24px;
        border-radius: 6px;
        flex-shrink: 0;
        display: inline-flex;
        align-items: center;
        justify-content: center;
        background: linear-gradient(135deg, rgba(102, 192, 244, 0.18), rgba(139, 92, 246, 0.18));
        border: 1px solid rgba(102, 192, 244, 0.25);
        color: #66c0f4;
        box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.06);
        transition: transform 0.2s, box-shadow 0.2s;
    }
    .sglv-header-brand:hover { transform: rotate(-8deg) scale(1.05); box-shadow: 0 2px 8px rgba(102, 192, 244, 0.35), inset 0 1px 0 rgba(255, 255, 255, 0.1); }
    .sglv-header-brand img { width: 14px; height: 14px; display: block; border-radius: 2px; }
    .sglv-header-brand svg { width: 14px; height: 14px; }
    .sglv-panel > .sglv-header > .sglv-tab-bar {
        display: flex;
        align-items: center;
        gap: 2px;
        flex: 1;
        min-width: 0;
        overflow: visible;
        position: relative;
    }

    /* === tab 按钮紧凑化（v2.9.46: 等宽等距布局，flex:1 使各标签宽度一致） === */
    /* v2.9.51: 进一步紧凑——padding 5px 6px → 4px 5px，font-size 12.5px → 11.5px，为右侧全局搜索框腾出空间 */
    .sglv-panel .sglv-tab {
        flex: 1 1 0 !important;
        padding: 4px 5px !important;
        font-size: 11.5px !important;
        font-weight: 600 !important;
        border-radius: 6px !important;
        border: 1px solid transparent !important;
        background: transparent !important;
        color: #94a3b8 !important;
        white-space: nowrap !important;
        justify-content: center !important;
        gap: 4px !important;
        min-width: 0 !important;
        overflow: hidden !important;
        text-overflow: ellipsis !important;
        transition: background 0.15s, color 0.15s, border-color 0.15s, transform 0.15s !important;
        height: 26px !important;
    }
    .sglv-panel .sglv-tab:hover { color: #e2e8f0 !important; background: rgba(255, 255, 255, 0.06) !important; }
    .sglv-panel .sglv-tab.active {
        color: #fff !important;
        background: rgba(102, 192, 244, 0.22) !important;
        border-color: rgba(102, 192, 244, 0.4) !important;
        box-shadow: 0 0 0 1px rgba(102, 192, 244, 0.15) inset, 0 1px 4px rgba(102, 192, 244, 0.18) !important;
    }
    .sglv-panel .sglv-tab svg { width: 12px; height: 12px; flex-shrink: 0; }
    .sglv-panel .sglv-tab span { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; min-width: 0; }

    /* === 头部 action 按钮 hover 反馈 + 状态点 === */
    .sglv-panel > .sglv-header > .sglv-header-actions {
        gap: 6px;
        flex-shrink: 0;
        margin-left: auto;
    }
    .sglv-panel .sglv-header-btn {
        width: 30px !important;
        height: 30px !important;
    }
    .sglv-panel .sglv-header-btn.sglv-export-csv-btn,
    .sglv-panel .sglv-header-btn.sglv-export-json-btn {
        height: 30px !important;
        line-height: 30px !important;
    }

    /* === 头部开关紧凑（家庭组） === */
    .sglv-panel .sglv-switch-container {
        display: inline-flex;
        align-items: center;
        gap: 6px;
        font-size: 11.5px;
        color: #94a3b8;
        user-select: none;
        cursor: pointer;
        height: 30px;
        padding: 0 4px 0 6px;
        border-radius: 6px;
        transition: background 0.15s, color 0.15s;
    }
    .sglv-panel .sglv-switch-container:hover { background: rgba(255, 255, 255, 0.05); color: #e2e8f0; }

    /* === 头部渐变微调，让 tab active 高光更明显 === */
    .sglv-panel > .sglv-header {
        background: linear-gradient(135deg, rgba(27, 40, 56, 0.95) 0%, rgba(42, 71, 94, 0.95) 100%) !important;
        border-bottom: 1px solid rgba(102, 192, 244, 0.18) !important;
    }

    /* === v2.9.51: tab 菜单紧凑化（保留），并接入全局搜索框 + 下拉结果浮层 === */
    /* 全局搜索框：紧贴 wishlist tab 右侧，flex:0 0 auto 不抢占 tab 等宽空间 */
    /* v2.9.51 审查：移除 flex-grow:1（与 flex:0 0 auto 冲突，会抢 tab 空间导致布局错乱） */
    .sglv-panel .sglv-global-search {
        flex: 0 0 200px !important;
        position: relative !important;
        display: flex !important;
        align-items: center !important;
        gap: 4px !important;
        height: 26px !important;
        padding: 0 6px 0 8px !important;
        margin-left: 6px !important;
        background: rgba(255, 255, 255, 0.06) !important;
        border: 1px solid rgba(255, 255, 255, 0.1) !important;
        border-radius: 6px !important;
        color: #c7d5e0 !important;
        transition: border-color 0.15s, background 0.15s, box-shadow 0.15s, width 0.15s !important;
        min-width: 120px !important;
        max-width: 240px !important;
    }
    .sglv-panel .sglv-global-search:hover { background: rgba(255, 255, 255, 0.09) !important; }
    .sglv-panel .sglv-global-search:focus-within {
        border-color: rgba(102, 192, 244, 0.55) !important;
        background: rgba(255, 255, 255, 0.1) !important;
        box-shadow: 0 0 0 1px rgba(102, 192, 244, 0.25) !important;
    }
    .sglv-panel .sglv-global-search-icon {
        display: inline-flex !important;
        align-items: center !important;
        color: #8a9ba8 !important;
        flex-shrink: 0 !important;
    }
    .sglv-panel .sglv-global-search-icon svg { width: 12px !important; height: 12px !important; }
    .sglv-panel .sglv-global-search input {
        flex: 1 1 auto !important;
        min-width: 0 !important;
        border: none !important;
        background: transparent !important;
        color: #fff !important;
        font-size: 11.5px !important;
        line-height: 1 !important;
        outline: none !important;
        padding: 0 !important;
        height: 100% !important;
    }
    .sglv-panel .sglv-global-search input::placeholder { color: #6b7c8c !important; font-size: 11px !important; }
    .sglv-panel .sglv-global-search-clear {
        flex: 0 0 auto !important;
        display: none !important;
        align-items: center !important;
        justify-content: center !important;
        width: 16px !important;
        height: 16px !important;
        padding: 0 !important;
        border: none !important;
        border-radius: 4px !important;
        background: rgba(255, 255, 255, 0.1) !important;
        color: #c7d5e0 !important;
        cursor: pointer !important;
        transition: background 0.15s, color 0.15s !important;
    }
    .sglv-panel .sglv-global-search-clear:hover { background: rgba(255, 255, 255, 0.2) !important; color: #fff !important; }
    .sglv-panel .sglv-global-search-clear svg { width: 9px !important; height: 9px !important; }
    .sglv-panel .sglv-global-search.has-text .sglv-global-search-clear { display: inline-flex !important; }

    /* v2.9.58: 搜索结果浮层 — 右对齐搜索框,动画显隐,动态 max-height 防溢出面板 */
    .sglv-panel .sglv-global-search-pop {
        position: absolute !important;
        top: calc(100% + 6px) !important;
        right: 0 !important;
        left: auto !important;
        min-width: 300px !important;
        max-width: 400px !important;
        max-height: calc(80vh - 80px) !important;
        overflow-y: auto !important;
        background: rgba(15, 23, 42, 0.98) !important;
        border: 1px solid rgba(102, 192, 244, 0.35) !important;
        border-radius: 10px !important;
        box-shadow: 0 12px 32px rgba(0, 0, 0, 0.7), 0 0 0 1px rgba(0, 0, 0, 0.3) !important;
        z-index: 1000001 !important;
        padding: 4px 0 !important;
        backdrop-filter: blur(12px) !important;
        display: block !important;
        opacity: 0;
        transform: translateY(-6px) scale(0.98);
        visibility: hidden;
        transition: opacity 0.16s ease, transform 0.16s ease, visibility 0s linear 0.16s;
        transform-origin: top right;
    }
    .sglv-panel .sglv-global-search-pop::-webkit-scrollbar { width: 6px; }
    .sglv-panel .sglv-global-search-pop::-webkit-scrollbar-thumb { background: rgba(255, 255, 255, 0.15); border-radius: 3px; }
    .sglv-panel .sglv-global-search-pop.show {
        opacity: 1;
        transform: translateY(0) scale(1);
        visibility: visible;
        transition: opacity 0.16s ease, transform 0.16s ease, visibility 0s;
    }
    .sglv-panel .sglv-gs-header {
        padding: 8px 12px 5px !important;
        font-size: 10px !important;
        font-weight: 700 !important;
        color: #6e7681 !important;
        text-transform: uppercase !important;
        letter-spacing: 0.05em !important;
        display: flex !important;
        align-items: center !important;
        justify-content: space-between !important;
        border-bottom: 1px solid rgba(255, 255, 255, 0.04) !important;
    }
    .sglv-panel .sglv-gs-header-count {
        background: rgba(102, 192, 244, 0.12) !important;
        color: #66c0f4 !important;
        font-weight: 700 !important;
        text-transform: none !important;
        letter-spacing: 0 !important;
        padding: 1px 7px !important;
        border-radius: 10px !important;
        font-size: 10px !important;
    }
    .sglv-panel .sglv-gs-item {
        display: flex !important;
        align-items: center !important;
        gap: 10px !important;
        padding: 7px 12px !important;
        cursor: pointer !important;
        color: #c7d5e0 !important;
        font-size: 12px !important;
        transition: background 0.12s, color 0.12s !important;
        border-left: 2px solid transparent !important;
    }
    .sglv-panel .sglv-gs-item:hover,
    .sglv-panel .sglv-gs-item.focus {
        background: rgba(102, 192, 244, 0.12) !important;
        color: #fff !important;
        border-left-color: rgba(102, 192, 244, 0.6) !important;
    }
    .sglv-panel .sglv-gs-item-thumb {
        width: 48px !important;
        height: 18px !important;
        flex-shrink: 0 !important;
        background: rgba(255, 255, 255, 0.04) !important;
        border-radius: 3px !important;
        overflow: hidden !important;
        display: flex !important;
        align-items: center !important;
        justify-content: center !important;
        transition: transform 0.15s ease !important;
    }
    .sglv-panel .sglv-gs-item:hover .sglv-gs-item-thumb,
    .sglv-panel .sglv-gs-item.focus .sglv-gs-item-thumb {
        transform: scale(1.08) !important;
    }
    .sglv-panel .sglv-gs-item-thumb img { width: 100% !important; height: 100% !important; object-fit: cover !important; }
    .sglv-panel .sglv-gs-item-body { flex: 1 1 auto !important; min-width: 0 !important; }
    .sglv-panel .sglv-gs-item-name {
        font-size: 12px !important;
        font-weight: 600 !important;
        color: #e2e8f0 !important;
        white-space: nowrap !important;
        overflow: hidden !important;
        text-overflow: ellipsis !important;
    }
    .sglv-panel .sglv-gs-item.focus .sglv-gs-item-name { color: #fff !important; }
    .sglv-panel .sglv-gs-item-name mark {
        background: rgba(102, 192, 244, 0.35) !important;
        color: #fff !important;
        padding: 0 1px !important;
        border-radius: 2px !important;
    }
    .sglv-panel .sglv-gs-item-sub {
        font-size: 10px !important;
        color: #8a9ba8 !important;
        white-space: nowrap !important;
        overflow: hidden !important;
        text-overflow: ellipsis !important;
        margin-top: 1px !important;
    }
    /* v2.9.58: 右侧徽章+图标容器,统一收紧间距 */
    .sglv-panel .sglv-gs-item-right {
        display: flex !important;
        align-items: center !important;
        gap: 4px !important;
        flex-shrink: 0 !important;
    }
    .sglv-panel .sglv-gs-item-type {
        flex-shrink: 0 !important;
        font-size: 9px !important;
        font-weight: 700 !important;
        padding: 1px 5px !important;
        border-radius: 3px !important;
        text-transform: uppercase !important;
        letter-spacing: 0.04em !important;
    }
    .sglv-panel .sglv-gs-item-type.owned { background: rgba(63, 185, 80, 0.15) !important; color: #3fb950 !important; }
    .sglv-panel .sglv-gs-item-type.wishlist { background: rgba(245, 158, 11, 0.15) !important; color: #f59e0b !important; }
    .sglv-panel .sglv-gs-item-type.store { background: rgba(102, 192, 244, 0.15) !important; color: #66c0f4 !important; }
    /* v2.9.83: 精准匹配(AppID直接命中)行高亮 */
    .sglv-panel .sglv-gs-item-exact { border-left: 3px solid #4ade80 !important; background: rgba(74, 222, 128, 0.04) !important; }
    .sglv-panel .sglv-gs-item-exact:hover, .sglv-panel .sglv-gs-item-exact.focus { background: rgba(74, 222, 128, 0.08) !important; }
    /* v2.9.53: 家庭共享次级徽章(紫色,小尺寸,紧贴主 type 徽章右侧) */
    .sglv-panel .sglv-gs-item-shared {
        display: inline-flex !important; align-items: center !important;
        padding: 1px 6px !important; margin-left: 0 !important;
        font-size: 10px !important; font-weight: 600 !important;
        border-radius: 3px !important;
        background: rgba(139, 92, 246, 0.18) !important;
        color: #c4b5fd !important;
        border: 1px solid rgba(139, 92, 246, 0.35) !important;
        cursor: help !important;
    }
    .sglv-panel .sglv-gs-item-ext { display: inline-flex !important; align-items: center !important; color: #6e7681 !important; }
    .sglv-panel .sglv-gs-item-ext svg { width: 10px !important; height: 10px !important; }
    .sglv-panel .sglv-gs-empty {
        padding: 20px 12px !important;
        text-align: center !important;
        color: #6e7681 !important;
        font-size: 11px !important;
        display: flex !important;
        flex-direction: column !important;
        align-items: center !important;
        gap: 8px !important;
    }
    .sglv-panel .sglv-gs-empty-icon { opacity: 0.4 !important; }
    .sglv-panel .sglv-gs-empty-icon svg { width: 28px !important; height: 28px !important; }
    .sglv-panel .sglv-gs-footer {
        padding: 6px 12px !important;
        border-top: 1px solid rgba(255, 255, 255, 0.05) !important;
        font-size: 10px !important;
        color: #6e7681 !important;
        display: flex !important;
        align-items: center !important;
        gap: 10px !important;
        background: rgba(15, 23, 42, 0.5) !important;
    }
    .sglv-panel .sglv-gs-footer-hint {
        display: flex !important;
        align-items: center !important;
        gap: 3px !important;
    }
    .sglv-panel .sglv-gs-footer kbd {
        background: rgba(255, 255, 255, 0.08) !important;
        border: 1px solid rgba(255, 255, 255, 0.12) !important;
        border-radius: 3px !important;
        padding: 0 4px !important;
        font-size: 9px !important;
        font-family: monospace !important;
        color: #c7d5e0 !important;
    }

    /* === v2.9.63: 游戏详情浮窗（点击搜索结果后弹出） === */
    .sglv-panel .sglv-detail-overlay {
        position: absolute; inset: 0; background: rgba(0,0,0,0.5);
        z-index: 1000002; border-radius: inherit;
        opacity: 0; visibility: hidden;
        transition: opacity 0.16s ease, visibility 0s linear 0.16s;
    }
    .sglv-panel .sglv-detail-overlay.show { opacity: 1; visibility: visible; transition: opacity 0.16s ease, visibility 0s; }
    .sglv-panel .sglv-detail-pop {
        position: absolute; top: 50%; left: 50%; transform: translate(-50%, -48%) scale(0.96);
        width: calc(100% - 48px); max-width: 560px; max-height: calc(85vh - 60px);
        background: linear-gradient(160deg, rgba(23,33,45,0.99), rgba(15,23,42,0.99));
        border: 1px solid rgba(102,192,244,0.25); border-radius: 14px;
        box-shadow: 0 20px 60px rgba(0,0,0,0.6), 0 0 0 1px rgba(0,0,0,0.3);
        z-index: 1000003; overflow: hidden; display: flex; flex-direction: column;
        opacity: 0; visibility: hidden;
        transition: opacity 0.2s ease, transform 0.2s ease, visibility 0s linear 0.2s;
    }
    .sglv-panel .sglv-detail-pop.show {
        opacity: 1; visibility: visible; transform: translate(-50%, -50%) scale(1);
        transition: opacity 0.2s ease, transform 0.2s ease, visibility 0s;
    }
    .sglv-detail-close {
        position: absolute; top: 10px; right: 10px; z-index: 5;
        width: 30px; height: 30px; border-radius: 50%; border: none;
        background: rgba(0,0,0,0.4); color: #c7d5e0; cursor: pointer;
        display: flex; align-items: center; justify-content: center;
        transition: background 0.16s, color 0.16s;
    }
    .sglv-detail-close:hover { background: rgba(244,67,54,0.5); color: #fff; }
    .sglv-detail-close svg { width: 16px; height: 16px; }
    .sglv-detail-scroll { overflow-y: auto; overflow-x: hidden; }
    .sglv-detail-scroll::-webkit-scrollbar { width: 6px; }
    .sglv-detail-scroll::-webkit-scrollbar-thumb { background: rgba(255,255,255,0.15); border-radius: 3px; }
    .sglv-detail-hero { position: relative; width: 100%; aspect-ratio: 231/87; overflow: hidden; background: #1a2332; }
    .sglv-detail-hero img { width: 100%; height: 100%; object-fit: cover; display: block; }
    .sglv-detail-hero::after { content:''; position:absolute; inset:0; background: linear-gradient(180deg, transparent 40%, rgba(15,23,42,0.95)); }
    .sglv-detail-body { padding: 0 18px 18px; }
    .sglv-detail-name { font-size: 18px; font-weight: 700; color: #e2e8f0; margin: -20px 0 4px; position: relative; z-index: 1; text-shadow: 0 2px 8px rgba(0,0,0,0.8); }
    .sglv-detail-desc { font-size: 12px; color: #8b949e; line-height: 1.6; margin: 10px 0; }
    .sglv-detail-meta { display: grid; grid-template-columns: auto 1fr; gap: 4px 12px; font-size: 11px; margin: 10px 0; }
    .sglv-detail-meta dt { color: #6e7681; font-weight: 600; }
    .sglv-detail-meta dd { color: #c7d5e0; margin: 0; }
    .sglv-detail-tags { display: flex; flex-wrap: wrap; gap: 4px; margin: 10px 0; }
    .sglv-detail-tag { font-size: 10px; padding: 2px 8px; border-radius: 4px; background: rgba(102,192,244,0.1); color: #66c0f4; border: 1px solid rgba(102,192,244,0.15); }
    .sglv-detail-price { display: flex; align-items: center; gap: 8px; margin: 10px 0; }
    .sglv-detail-price-val { font-size: 16px; font-weight: 700; color: #4ade80; }
    .sglv-detail-price-discount { font-size: 12px; color: #fbbf24; }
    .sglv-detail-price-free { font-size: 16px; font-weight: 700; color: #4ade80; }
    .sglv-detail-shots { display: flex; gap: 6px; overflow-x: auto; margin: 10px 0; padding-bottom: 4px; }
    .sglv-detail-shots::-webkit-scrollbar { height: 4px; }
    .sglv-detail-shots::-webkit-scrollbar-thumb { background: rgba(255,255,255,0.15); border-radius: 2px; }
    .sglv-detail-shot { flex-shrink: 0; width: 200px; height: 113px; border-radius: 6px; overflow: hidden; background: #1a2332; }
    .sglv-detail-shot img { width: 100%; height: 100%; object-fit: cover; display: block; }
    .sglv-detail-actions { display: flex; gap: 8px; margin-top: 14px; padding-top: 14px; border-top: 1px solid rgba(255,255,255,0.06); }
    .sglv-detail-btn { display: inline-flex; align-items: center; gap: 5px; padding: 8px 16px; border-radius: 8px; font-size: 12px; font-weight: 600; cursor: pointer; border: none; transition: all 0.16s; text-decoration: none; }
    .sglv-detail-btn-primary { background: linear-gradient(135deg, #66c0f4, #1a9fff); color: #fff; }
    .sglv-detail-btn-primary:hover { filter: brightness(1.1); }
    .sglv-detail-btn-secondary { background: rgba(255,255,255,0.08); color: #c7d5e0; }
    .sglv-detail-btn-secondary:hover { background: rgba(255,255,255,0.14); }
    .sglv-detail-btn-ai { background: linear-gradient(135deg, #6366f1, #8b5cf6); color: #fff; }
    .sglv-detail-btn-ai:hover { filter: brightness(1.15); }
    .sglv-detail-btn svg { width: 14px; height: 14px; }
    .sglv-detail-loading { display: flex; flex-direction: column; align-items: center; justify-content: center; min-height: 200px; gap: 12px; color: #6e7681; font-size: 12px; }
    .sglv-detail-error { display: flex; flex-direction: column; align-items: center; justify-content: center; min-height: 200px; gap: 8px; color: #f87171; font-size: 12px; }
    .sglv-detail-metacritic { display: inline-flex; align-items: center; gap: 4px; font-size: 11px; padding: 2px 8px; border-radius: 4px; font-weight: 700; }

    /* === v2.9.22: body 首屏骨架占位（避免空数据时出现完全空白） === */
    .sglv-body-loading {
        display: flex;
        flex-direction: column;
        align-items: center;
        justify-content: center;
        height: 100%;
        min-height: 320px;
        padding: 40px 20px;
        gap: 16px;
        color: #94a3b8;
        font-size: 13px;
        text-align: center;
    }
    .sglv-body-loading .sglv-bl-title {
        font-size: 15px;
        font-weight: 600;
        color: #cbd5e1;
    }
    .sglv-body-loading .sglv-bl-tip {
        font-size: 12px;
        color: #64748b;
        line-height: 1.6;
        max-width: 420px;
    }
    .sglv-body-loading .sglv-bl-spinner {
        width: 36px;
        height: 36px;
        border: 3px solid rgba(102, 192, 244, 0.15);
        border-top-color: #66c0f4;
        border-radius: 50%;
        animation: sglv-spin 0.9s linear infinite;
    }
    .sglv-body-loading .sglv-bl-actions {
        display: flex;
        gap: 8px;
        margin-top: 4px;
    }
    .sglv-body-loading .sglv-bl-btn {
        padding: 6px 14px;
        font-size: 12px;
        font-weight: 600;
        border-radius: 6px;
        border: 1px solid rgba(102, 192, 244, 0.3);
        background: rgba(102, 192, 244, 0.1);
        color: #66c0f4;
        cursor: pointer;
        transition: background 0.15s, border-color 0.15s;
    }
    .sglv-body-loading .sglv-bl-btn:hover {
        background: rgba(102, 192, 244, 0.2);
        border-color: rgba(102, 192, 244, 0.5);
    }
    .sglv-body-loading .sglv-bl-btn.primary {
        background: linear-gradient(135deg, rgba(139, 92, 246, 0.25), rgba(102, 192, 244, 0.2));
        border-color: rgba(139, 92, 246, 0.4);
        color: #c4b5fd;
    }
    .sglv-body-loading .sglv-bl-btn.primary:hover {
        background: linear-gradient(135deg, rgba(139, 92, 246, 0.35), rgba(102, 192, 244, 0.3));
    }

    /* === v2.9.26: 统计仪表布局——热力图行改自适应内容高度（不再撑满 wrap），6月增量SVG加高减少留白 === */
    /* v2.9.27: sglv-body 需 min-height:0 确保 flex 子项正确滚动（移动端关键修复） */
    .sglv-body { min-height: 0 !important; }
    /* wrap: flex:1 填满 sglv-body 可用高度，内部 flex column 纵向排列各区块 */
    .sglv-playtime-wrap {
        display: flex !important;
        flex-direction: column !important;
        flex: 1 1 0 !important;
        min-height: 0 !important;
        gap: 10px !important;
        overflow-y: auto !important;
        padding: 12px !important;
    }
    /* v2.9.55: 图表行(甜甜圈+趋势) 使用内容高度,不再 flex-grow 撑满 wrap 剩余空间。
       低分屏下 flex-grow:1 会吞掉热力图行的可用高度,导致下方热力图/增量图被挤压变形。
       改为 flex:0 0 auto 后,各行按内容自然排列,wrap 的 overflow-y:auto 负责纵向滚动。 */
    .sglv-playtime-row { flex: 0 0 auto !important; min-height: 0 !important; }
    /* v2.9.55: 图表列最小高度,确保甜甜圈/趋势图有足够渲染空间 */
    .sglv-playtime-col { min-height: 220px !important; }
    /* v2.9.26: 热力图行 grid 7:3——改成自适应内容高度 + 最小高度，不再撑满 wrap 剩余高度，避免盖住上方 KPI/图表区 */
    /* v2.9.55: overflow 从 hidden 改为 visible,允许内容自然溢出由 wrap 的 overflow-y:auto 滚动,而非裁剪变形 */
    .sglv-heatmap-acquire-row {
        display: grid !important;
        grid-template-columns: 7fr 3fr !important;
        align-items: stretch !important;
        min-height: 320px !important;
        flex: 0 0 auto !important;
        gap: 10px !important;
        overflow: visible !important;
    }
    .sglv-heatmap-acquire-row .sglv-heatmap-section,
    .sglv-heatmap-acquire-row .sglv-heatmap-mini-section {
        flex: none !important;
        min-width: 0 !important;
        max-width: none !important;
        min-height: 280px !important;
        display: flex !important;
        flex-direction: column !important;
        overflow: visible !important;
    }
    /* v2.9.26: 热力图 block 撑满 section 高度 */
    .sglv-heatmap-acquire-row .sglv-heatmap-block,
    .sglv-heatmap-acquire-row .sglv-heatmap-mini-skeleton,
    .sglv-heatmap-acquire-row .sglv-hm-mini-inner {
        flex: 1 1 0 !important;
        min-height: 0 !important;
    }
    /* v2.9.55: 增量柱图——SVG 用 auto 高度而非 100%,避免容器被压缩时 SVG 跟着变形 */
    .sglv-heatmap-acquire-row .sglv-hm-mini-chart { flex: 1 1 auto !important; min-height: 120px !important; }
    .sglv-heatmap-acquire-row .sglv-hm-mini-chart svg { height: auto !important; max-height: 100% !important; }
    /* v2.9.26: 热力图 SVG 保持原始尺寸，由 scroll 容器水平滚动展示完整内容 */
    .sglv-heatmap-block svg {
        max-width: 100% !important;
        height: auto !important;
    }
    .sglv-heatmap-scroll svg {
        max-width: none !important;
        height: auto !important;
        display: block !important;
    }
    .sglv-heatmap-acquire-row .sglv-heatmap-scroll { overflow-x: auto !important; }
    /* v2.9.26: 热力图 section 紧凑 padding + scroll 容器居中(SVG 内容垂直居中) */
    .sglv-heatmap-acquire-row .sglv-heatmap-section { padding: 10px 12px 8px !important; }
    .sglv-heatmap-acquire-row .sglv-heatmap-mini-section { padding: 10px 12px 8px !important; }
    .sglv-heatmap-section > #sglv-pt-heatmap {
        flex: 1 1 0 !important;
        min-height: 0 !important;
        display: flex !important;
        flex-direction: column !important;
        justify-content: flex-start !important;
    }
    /* v2.9.26: 热力图 scroll 紧凑 padding-bottom */
    .sglv-heatmap-scroll { padding-bottom: 2px !important; }
    /* v2.9.26: heatmap-body 擑满 block 剩余高度，scroll 区域可滚动 + 居中 SVG */
    .sglv-heatmap-acquire-row .sglv-heatmap-body { flex: 1 1 0 !important; min-height: 0 !important; display: flex !important; flex-direction: column !important; }
    .sglv-heatmap-acquire-row .sglv-heatmap-body .sglv-heatmap-scroll { flex: 1 1 0 !important; min-height: 0 !important; display: flex !important; flex-direction: column !important; justify-content: center !important; }
    .sglv-heatmap-acquire-row .sglv-heatmap-body .sglv-heatmap-scroll > svg { flex: 0 0 auto !important; align-self: flex-start !important; }
    /* 趋势图折线等比缩放(meet)后居中 */
    .sglv-pt-trend-chart { align-items: center !important; }
    /* v2.9.23: 增量柱图底部统计栏样式 */
    .sglv-hm-mini-summary { display: flex; flex-wrap: wrap; gap: 8px; padding: 6px 4px 0; flex-shrink: 0; }
    .sglv-hm-mini-stat { font-size: 10px; color: var(--sglv-text-secondary); white-space: nowrap; }
    .sglv-hm-mini-stat b { font-size: 13px; font-weight: 800; color: #e0e0e0; }
    /* 移动端热力图行恢复上下排列 */
    @media (max-width: 900px) {
        .sglv-heatmap-acquire-row { grid-template-columns: 1fr !important; }
    }

    /* === v2.9.27: 移动端统计仪表适配——KPI 卡片防换行 + 热力图高度收缩 === */
    /* KPI 卡片内部文字截断，防止窄屏换行变形 */
    .sglv-playtime-kpi-value { white-space: nowrap !important; overflow: hidden !important; text-overflow: ellipsis !important; }
    .sglv-playtime-kpi-sub { white-space: nowrap !important; overflow: hidden !important; text-overflow: ellipsis !important; }
    .sglv-playtime-kpi-label { white-space: nowrap !important; overflow: hidden !important; text-overflow: ellipsis !important; }

    @media (max-width: 768px) {
        /* KPI 卡片：2 列布局时进一步紧凑化 */
        .sglv-playtime-kpi-row { gap: 5px !important; }
        .sglv-playtime-kpi-row .sglv-playtime-kpi-card { padding: 5px 8px 4px !important; }
        .sglv-playtime-kpi-row .sglv-playtime-kpi-value { font-size: 15px !important; }
        .sglv-playtime-kpi-row .sglv-playtime-kpi-label { font-size: 9px !important; }
        .sglv-playtime-kpi-row .sglv-playtime-kpi-sub { font-size: 8px !important; }
        .sglv-playtime-kpi-row .sglv-playtime-kpi-icon { width: 14px !important; height: 14px !important; }
        .sglv-playtime-kpi-row .sglv-playtime-kpi-icon svg { width: 9px !important; height: 9px !important; }
        .sglv-playtime-kpi-row .sglv-playtime-kpi-unit { font-size: 10px !important; }

        /* v2.9.55: 热力图行降低最小高度,但仍保持足够渲染空间,由 wrap 滚动而非压缩 */
        .sglv-heatmap-acquire-row { min-height: 260px !important; }
        .sglv-heatmap-acquire-row .sglv-heatmap-section,
        .sglv-heatmap-acquire-row .sglv-heatmap-mini-section { padding: 8px 10px 6px !important; min-height: 220px !important; }

        /* 图表行(甜甜圈+趋势) 单列堆叠时限制高度，避免无限增高 */
        .sglv-playtime-row { flex: 0 0 auto !important; }
        .sglv-playtime-col { min-height: 200px !important; max-height: 280px !important; }
        .sglv-playtime-col > #sglv-pt-donut { min-height: 160px !important; }
        .sglv-pt-trend-chart { min-height: 160px !important; }
    }

    @media (max-width: 480px) {
        /* 超窄屏：KPI 保持 2 列但进一步缩小 */
        .sglv-playtime-kpi-row { gap: 4px !important; }
        .sglv-playtime-kpi-row .sglv-playtime-kpi-card { padding: 4px 6px 3px !important; }
        .sglv-playtime-kpi-row .sglv-playtime-kpi-value { font-size: 14px !important; }
        .sglv-playtime-kpi-row .sglv-playtime-kpi-label { font-size: 8px !important; }
        .sglv-playtime-kpi-row .sglv-playtime-kpi-sub { font-size: 7px !important; }

        /* v2.9.55: 热力图行降低高度但保持最小渲染空间 */
        .sglv-heatmap-acquire-row { min-height: 220px !important; }
        .sglv-heatmap-acquire-row .sglv-heatmap-section,
        .sglv-heatmap-acquire-row .sglv-heatmap-mini-section { min-height: 180px !important; }

        /* 图表列限制高度 */
        .sglv-playtime-col { min-height: 180px !important; max-height: 240px !important; }

        /* wrap 内边距收紧 */
        .sglv-playtime-wrap { padding: 8px !important; gap: 8px !important; }
    }

    /* === v2.9.25: 分页导航——简化单行布局，首页|上页|下页|末页 + 跳页输入 === */
    .sglv-tl-pagination,
    .sglv-pagination,
    .sglv-pt-pagination {
        display: flex !important;
        align-items: center !important;
        justify-content: center !important;
        flex-wrap: nowrap !important;
        gap: 4px !important;
        padding: 8px 0 2px !important;
        overflow: hidden !important;
    }
    /* 箭头/文本按钮 */
    .sglv-page-arrow {
        min-width: 24px; height: 24px; padding: 0 2px;
        border: 1px solid rgba(255,255,255,0.1); border-radius: 5px;
        background: rgba(255,255,255,0.04); color: #c7d5e0;
        font-size: 13px; line-height: 1; cursor: pointer;
        transition: var(--sglv-transition); text-align: center; flex-shrink: 0;
    }
    .sglv-page-arrow:hover:not(:disabled) { background: rgba(102,192,244,0.15); border-color: rgba(102,192,244,0.4); color: #fff; }
    .sglv-page-arrow:disabled { opacity: 0.3; cursor: not-allowed; }
    /* 中文文本按钮——加宽适配文字 */
    .sglv-page-text-btn { min-width: auto !important; padding: 0 8px !important; font-size: 11px !important; white-space: nowrap !important; }
    /* 页码按钮组（已废弃，隐藏） */
    .sglv-page-btns { display: none !important; }
    .sglv-page-btn { display: none !important; }
    .sglv-page-ellipsis { display: none !important; }
    /* 跳页输入框——紧凑，回车跳转 */
    .sglv-page-jump-input {
        width: 38px; height: 24px; padding: 0 2px; text-align: center;
        background: rgba(255,255,255,0.08); border: 1px solid rgba(255,255,255,0.1); border-radius: 4px;
        color: #fff; font-size: 11px; outline: none; flex-shrink: 0;
        -moz-appearance: textfield;
    }
    .sglv-page-jump-input::-webkit-inner-spin-button,
    .sglv-page-jump-input::-webkit-outer-spin-button { -webkit-appearance: none; margin: 0; }
    .sglv-page-jump-input:focus { border-color: rgba(102,192,244,0.5); }
    /* 页码信息——极简 */
    .sglv-page-info { font-size: 10px !important; color: var(--sglv-text-secondary) !important; white-space: nowrap !important; flex-shrink: 0 !important; }
    /* 工具栏内嵌分页——更紧凑，隐藏箭头和跳页 */
    .sglv-pagination-inline .sglv-page-arrow { min-width: 20px; height: 20px; font-size: 11px; }
    .sglv-pagination-inline .sglv-page-btn { min-width: 20px; height: 20px; font-size: 10px; }
    .sglv-pagination-inline .sglv-page-jump-input { display: none; }
    .sglv-pagination-inline .sglv-page-info { display: none; }

    /* === v2.9.23: 统计仪表 KPI 卡片 6 列 1 行紧凑布局 + 扁平化（参考设计图） === */
    .sglv-playtime-kpi-row {
        grid-template-columns: repeat(6, 1fr) !important;
        gap: 6px !important;
    }
    @media (max-width: 1280px) { .sglv-playtime-kpi-row { grid-template-columns: repeat(3, 1fr) !important; } }
    @media (max-width: 700px)  { .sglv-playtime-kpi-row { grid-template-columns: repeat(2, 1fr) !important; } }
    /* 6 列 1 行时各元素字号紧凑 */
    .sglv-playtime-kpi-row .sglv-playtime-kpi-value { font-size: 17px !important; }
    .sglv-playtime-kpi-row .sglv-playtime-kpi-label { font-size: 10px !important; }
    .sglv-playtime-kpi-row .sglv-playtime-kpi-sub { font-size: 9px !important; }
    .sglv-playtime-kpi-row .sglv-playtime-kpi-icon { width: 16px !important; height: 16px !important; }
    .sglv-playtime-kpi-row .sglv-playtime-kpi-icon svg { width: 10px !important; height: 10px !important; }
    .sglv-playtime-kpi-row .sglv-playtime-kpi-unit { font-size: 11px !important; }
    /* v2.9.23: KPI 卡片扁平化——弱化边框，靠左侧色条 + 背景色区分，参考设计图 */
    .sglv-playtime-kpi-card { border-width: 1px !important; border-left-width: 3px !important; }

    /* === v2.9.22: 游玩率/完成度 KPI 卡片颜色变体（cyan/rose）+ % 单位字号 === */
    .sglv-playtime-kpi-card.cyan { border-color: rgba(34, 211, 238, 0.35); }
    .sglv-playtime-kpi-card.cyan::before { background: #22d3ee; }
    .sglv-playtime-kpi-card.cyan .sglv-playtime-kpi-value { color: #22d3ee; }
    .sglv-playtime-kpi-card.cyan .sglv-playtime-kpi-icon { background: rgba(34, 211, 238, 0.15); color: #22d3ee; }
    .sglv-playtime-kpi-card.rose { border-color: rgba(244, 63, 94, 0.35); }
    .sglv-playtime-kpi-card.rose::before { background: #f43f5e; }
    .sglv-playtime-kpi-card.rose .sglv-playtime-kpi-value { color: #fb7185; }
    .sglv-playtime-kpi-card.rose .sglv-playtime-kpi-icon { background: rgba(244, 63, 94, 0.15); color: #fb7185; }
    .sglv-playtime-kpi-card.gold { border-color: rgba(251, 191, 36, 0.3); }
    .sglv-playtime-kpi-card.gold::before { background: #fbbf24; }
    .sglv-playtime-kpi-card.gold .sglv-playtime-kpi-value { color: #fbbf24; }
    .sglv-playtime-kpi-card.gold .sglv-playtime-kpi-icon { background: rgba(251, 191, 36, 0.12); color: #fbbf24; }
    .sglv-playtime-kpi-unit { font-size: 13px; font-weight: 700; opacity: 0.85; margin-left: 2px; }

    /* === v2.9.22: 入库趋势页 KPI 紧凑布局（4 卡放左半侧顶部）+ 时间线撑到顶部 === */
    .sglv-trend-kpi-row-compact {
        gap: 6px !important;
        margin-bottom: 8px !important;
    }
    .sglv-trend-kpi-row-compact .sglv-trend-kpi-card { padding: 7px 10px !important; }
    .sglv-trend-kpi-row-compact .sglv-trend-kpi-value { font-size: 17px !important; }
    .sglv-trend-kpi-row-compact .sglv-trend-kpi-label { font-size: 10px !important; }
    .sglv-trend-kpi-row-compact .sglv-trend-kpi-sub { font-size: 9px !important; }
    .sglv-trend-kpi-row-compact .sglv-trend-kpi-icon { width: 16px !important; height: 16px !important; }
    .sglv-trend-kpi-row-compact .sglv-trend-kpi-icon svg { width: 10px !important; height: 10px !important; }
    /* 时间线顶到页面顶部：rightCol 整体高度撑满 */
    .sglv-trend-split-right { align-self: stretch; }

    /* === v2.9.48: KPI 两行布局 + 新色彩变体 === */
    .sglv-trend-kpi-wrap { display: flex; flex-direction: column; gap: 6px; margin-bottom: 8px; flex-shrink: 0; }
    .sglv-trend-kpi-wrap .sglv-trend-kpi-row { margin-bottom: 0 !important; }
    .sglv-trend-kpi-card.green { border-color: rgba(52,211,153,0.3); }
    .sglv-trend-kpi-card.green::before { background: #34d399; }
    .sglv-trend-kpi-card.green .sglv-trend-kpi-value { color: #34d399; }
    .sglv-trend-kpi-card.green .sglv-trend-kpi-icon { background: rgba(52,211,153,0.15); color: #34d399; }
    .sglv-trend-kpi-card.orange { border-color: rgba(245,158,11,0.3); }
    .sglv-trend-kpi-card.orange::before { background: #f59e0b; }
    .sglv-trend-kpi-card.orange .sglv-trend-kpi-value { color: #f59e0b; }
    .sglv-trend-kpi-card.orange .sglv-trend-kpi-icon { background: rgba(245,158,11,0.15); color: #f59e0b; }
    .sglv-trend-kpi-card.cyan { border-color: rgba(6,182,212,0.3); }
    .sglv-trend-kpi-card.cyan::before { background: #06b6d4; }
    .sglv-trend-kpi-card.cyan .sglv-trend-kpi-value { color: #22d3ee; }
    .sglv-trend-kpi-card.cyan .sglv-trend-kpi-icon { background: rgba(6,182,212,0.15); color: #22d3ee; }
    .sglv-trend-kpi-card.purple { border-color: rgba(167,139,250,0.3); }
    .sglv-trend-kpi-card.purple::before { background: #a78bfa; }
    .sglv-trend-kpi-card.purple .sglv-trend-kpi-value { color: #a78bfa; }
    .sglv-trend-kpi-card.purple .sglv-trend-kpi-icon { background: rgba(167,139,250,0.15); color: #a78bfa; }
    .sglv-trend-kpi-unit { font-size: 10px; font-weight: 600; opacity: 0.7; margin-left: 2px; }

    /* === v2.9.48: 右侧标签切换 === */
    .sglv-trend-right-tabs { display: flex; gap: 2px; margin-bottom: 10px; flex-shrink: 0; border-bottom: 1px solid rgba(148,163,184,0.12); }
    .sglv-trend-right-tab { display: inline-flex; align-items: center; gap: 5px; padding: 6px 12px; font-size: 12px; font-weight: 600; color: #8a9ba8; background: transparent; border: none; border-bottom: 2px solid transparent; cursor: pointer; transition: color 0.15s, border-color 0.15s; white-space: nowrap; }
    .sglv-trend-right-tab svg { width: 14px; height: 14px; }
    .sglv-trend-right-tab:hover { color: #cbd5e1; }
    .sglv-trend-right-tab.active { color: var(--sglv-accent, #66c0f4); border-bottom-color: var(--sglv-accent, #66c0f4); }
    .sglv-trend-right-content { flex: 1; display: flex; flex-direction: column; min-height: 0; overflow: hidden; }

    /* === v2.9.48: 频率分析图表 === */
    .sglv-freq-scroll { flex: 1; overflow-y: auto; min-height: 0; padding-right: 2px; }
    .sglv-freq-scroll::-webkit-scrollbar { width: 5px; }
    .sglv-freq-scroll::-webkit-scrollbar-thumb { background: rgba(148,163,184,0.2); border-radius: 3px; }
    .sglv-freq-summary-row { display: grid; grid-template-columns: repeat(4, 1fr); gap: 6px; margin-bottom: 14px; }
    .sglv-freq-summary-card { display: flex; flex-direction: column; align-items: center; gap: 2px; padding: 8px 6px; background: rgba(255,255,255,0.03); border: 1px solid rgba(148,163,184,0.1); border-radius: 8px; text-align: center; }
    .sglv-freq-summary-label { font-size: 9px; color: #64748b; font-weight: 600; }
    .sglv-freq-summary-value { font-size: 16px; font-weight: 700; color: #e2e8f0; }
    .sglv-freq-summary-sub { font-size: 9px; color: #475569; }
    .sglv-freq-chart-section { margin-bottom: 14px; }
    .sglv-freq-chart-title { font-size: 11px; font-weight: 700; color: #94a3b8; margin-bottom: 6px; }
    .sglv-freq-chart svg rect { transition: opacity 0.15s; }
    .sglv-freq-chart svg rect[data-v] { cursor: pointer; }
    .sglv-freq-chart-labels { display: flex; font-size: 9px; color: #475569; margin-top: 3px; }
    .sglv-freq-chart-labels span { flex: 1; text-align: center; }
    .sglv-freq-chart-labels-hr span { font-size: 8px; }

    /* === v2.9.22: 游玩数据页——家庭成员对比紧凑到右半侧底部，Top 20 撑到更高视野 === */
    .sglv-playtime-split-right {
        gap: 0;
    }
    /* 家庭对比放右半侧后紧凑显示：限制高度 + 内部滚动 */
    .sglv-playtime-split-right > .sglv-family-compare-section {
        flex-shrink: 0;
        margin: 10px 0 0;
        padding: 10px 12px;
        max-height: 200px;
        background: rgba(255, 255, 255, 0.02);
        border: 1px solid rgba(255, 255, 255, 0.06);
        border-radius: 8px;
        display: flex;
        flex-direction: column;
        overflow: hidden;
    }
    .sglv-playtime-split-right > .sglv-family-compare-section .sglv-playtime-section-title {
        margin-bottom: 6px;
        font-size: 12px;
    }
    .sglv-playtime-split-right > .sglv-family-compare-section .sglv-family-compare-container {
        margin-top: 0;
        max-height: 140px;
        overflow-y: auto;
    }
    /* v2.9.69: 游戏橱窗 KPI 扁平化——与统计仪表/入库趋势页一致，左侧色条+紧凑 padding */
    .sglv-stats-dashboard .sglv-stat-dash-card { padding: 6px 10px 5px !important; border-left-width: 3px !important; }

    @keyframes sglv-skel-pulse {
        0%, 100% { opacity: 0.55; }
        50% { opacity: 0.9; }
    }
    @keyframes sglv-skel-shimmer-x {
        0% { background-position: -200% 0; }
        100% { background-position: 200% 0; }
    }
    .sglv-heatmap-skeleton svg rect { animation: sglv-skel-pulse 1.6s ease-in-out infinite; }
    .sglv-heatmap-skeleton svg rect:nth-child(odd) { animation-delay: 0.15s; }
    .sglv-heatmap-skeleton svg rect:nth-child(3n) { animation-delay: 0.3s; }
    .sglv-heatmap-mini-skeleton rect { animation: sglv-skel-pulse 1.4s ease-in-out infinite; }
    .sglv-heatmap-mini-skeleton rect:nth-child(odd) { animation-delay: 0.2s; }
    .sglv-family-bar-skel .sglv-family-bar-track { background: rgba(255, 255, 255, 0.04) !important; }
    .sglv-family-bar-skel .sglv-family-bar-name,
    .sglv-family-bar-skel .sglv-family-bar-hours {
        background: linear-gradient(90deg, rgba(255, 255, 255, 0.04) 0%, rgba(255, 255, 255, 0.1) 50%, rgba(255, 255, 255, 0.04) 100%) !important;
        background-size: 200% 100%;
        animation: sglv-skel-shimmer-x 1.6s linear infinite;
    }
    .sglv-family-bar-skel:nth-child(2) .sglv-family-bar-name,
    .sglv-family-bar-skel:nth-child(2) .sglv-family-bar-hours { animation-delay: 0.15s; }
    .sglv-family-bar-skel:nth-child(3) .sglv-family-bar-name,
    .sglv-family-bar-skel:nth-child(3) .sglv-family-bar-hours { animation-delay: 0.3s; }
    .sglv-family-bar-skel:nth-child(4) .sglv-family-bar-name,
    .sglv-family-bar-skel:nth-child(4) .sglv-family-bar-hours { animation-delay: 0.45s; }`;

    const CSS_SGIS_ENHANCE =`    /* === tab 容器：增加底部高光 + tab 之间分隔感 === */
    .sgis-tabs { position: relative; }
    .sgis-tabs::after {
        content: ""; position: absolute; left: 12px; right: 12px; bottom: -1px; height: 1px;
        background: linear-gradient(90deg, transparent, rgba(139, 92, 246, 0.35), transparent);
        pointer-events: none;
    }

    /* === tab 本身：图标上浮 + 文字微微缩放 === */
    .sgis-tab .sgis-svg {
        transition: transform 0.3s cubic-bezier(0.34, 1.56, 0.64, 1);
    }
    .sgis-tab:hover .sgis-svg {
        transform: translateY(-1px) scale(1.08);
    }
    .sgis-tab.active .sgis-svg {
        transform: translateY(-0.5px) scale(1.12);
        filter: drop-shadow(0 1px 4px rgba(139, 92, 246, 0.45));
    }
    .sgis-tab span {
        transition: font-weight 0.2s, letter-spacing 0.2s;
    }
    .sgis-tab.active span {
        font-weight: 700;
        letter-spacing: 0.3px;
    }

    /* === 标题图标：更精致渐变 + 内阴影 === */
    .sgis-title-icon {
        background: linear-gradient(135deg, #8b5cf6 0%, #6366f1 45%, #3b82f6 100%) !important;
        box-shadow:
            0 4px 12px rgba(139, 92, 246, 0.4),
            inset 0 1px 0 rgba(255, 255, 255, 0.25),
            inset 0 -1px 0 rgba(0, 0, 0, 0.2) !important;
    }
    .sgis-title-icon::after {
        background: linear-gradient(180deg, rgba(255, 255, 255, 0.18) 0%, transparent 45%) !important;
    }

    /* === 右上角 action 按钮：加 active 反馈 === */
    .sgis-icon-btn:active {
        transform: translateY(0) scale(0.94) !important;
    }
    .sgis-icon-btn.sgis-spin svg {
        animation: sgis-spin 0.8s linear infinite, sgis-pulse 1.4s ease-in-out infinite;
    }
    @keyframes sgis-pulse {
        0%, 100% { box-shadow: 0 2px 8px rgba(139, 92, 246, 0.25); }
        50% { box-shadow: 0 2px 14px rgba(139, 92, 246, 0.6); }
    }

    /* === SGIS 整体滚动条更精致 === */
    .sgis-body::-webkit-scrollbar-thumb {
        background: linear-gradient(180deg, rgba(139, 92, 246, 0.45), rgba(59, 130, 246, 0.45)) !important;
    }

    /* === SGIS 状态指示器（用于加载/错误/空状态） === */
    .sgis-state-icon {
        width: 48px; height: 48px; border-radius: 14px;
        background: linear-gradient(135deg, rgba(139, 92, 246, 0.15), rgba(59, 130, 246, 0.08));
        border: 1px solid rgba(139, 92, 246, 0.2);
        display: inline-flex; align-items: center; justify-content: center;
        margin-bottom: 10px; color: #a78bfa;
        box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.06);
    }
    .sgis-state-icon svg { width: 22px; height: 22px; }

    /* === 错误状态用红 === */
    .sgis-state.error .sgis-state-icon {
        background: linear-gradient(135deg, rgba(244, 63, 94, 0.15), rgba(244, 63, 94, 0.05));
        border-color: rgba(244, 63, 94, 0.3);
        color: #f87171;
    }

    /* === v2.9.15: 徽章标签页英雄区(顶部总览) === */
    .sgis-badge-hero {
        position: relative;
        background: linear-gradient(135deg, rgba(139, 92, 246, 0.18) 0%, rgba(59, 130, 246, 0.1) 50%, var(--sgis-bg-2) 100%);
        border: 1px solid rgba(139, 92, 246, 0.3);
        border-radius: 12px;
        padding: 14px 14px 12px;
        margin-bottom: 10px;
        overflow: hidden;
        box-shadow: 0 4px 16px rgba(139, 92, 246, 0.08), inset 0 1px 0 rgba(255, 255, 255, 0.05);
    }
    .sgis-badge-hero::before { content: ""; position: absolute; top: -40px; right: -30px; width: 140px; height: 140px; background: radial-gradient(circle, rgba(139, 92, 246, 0.25) 0%, transparent 65%); pointer-events: none; }
    .sgis-badge-hero::after { content: ""; position: absolute; bottom: -30px; left: -20px; width: 100px; height: 100px; background: radial-gradient(circle, rgba(6, 182, 212, 0.15) 0%, transparent 60%); pointer-events: none; }
    .sgis-badge-hero > * { position: relative; z-index: 1; }
    .sgis-badge-hero-stats {
        display: grid; grid-template-columns: repeat(4, 1fr); gap: 6px;
        margin-bottom: 10px;
    }
    .sgis-badge-hero-stat { text-align: center; padding: 6px 4px; background: rgba(255, 255, 255, 0.04); border-radius: 7px; border: 1px solid rgba(255, 255, 255, 0.05); }
    .sgis-badge-hero-stat.highlight { background: linear-gradient(135deg, rgba(16, 185, 129, 0.15), rgba(20, 184, 166, 0.08)); border-color: rgba(16, 185, 129, 0.3); }
    .sgis-badge-hero-stat-val { font-size: 18px; font-weight: 800; color: #fff; line-height: 1.1; font-variant-numeric: tabular-nums; letter-spacing: -0.5px; }
    .sgis-badge-hero-stat.highlight .sgis-badge-hero-stat-val { color: #34d399; }
    .sgis-badge-hero-stat-lbl { font-size: 9px; color: var(--sgis-text-2); margin-top: 2px; font-weight: 600; }
    .sgis-badge-hero-stat.highlight .sgis-badge-hero-stat-lbl { color: #6ee7b7; }
    .sgis-badge-hero-progress { margin-bottom: 12px; }
    .sgis-badge-hero-progress-label { display: flex; justify-content: space-between; font-size: 10px; color: var(--sgis-text-2); margin-bottom: 4px; font-weight: 600; }
    .sgis-badge-hero-progress-label span:last-child { color: #c4b5fd; }
    .sgis-badge-hero-progress-bar { height: 6px; background: rgba(255, 255, 255, 0.06); border-radius: 3px; overflow: hidden; box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.3); }
    .sgis-badge-hero-progress-fill { height: 100%; background: linear-gradient(90deg, #10b981 0%, #34d399 100%); border-radius: 3px; transition: width 0.5s; box-shadow: 0 0 6px rgba(16, 185, 129, 0.4); }
    .sgis-badge-hero-levels { padding-top: 10px; border-top: 1px dashed rgba(255, 255, 255, 0.08); }
    .sgis-badge-hero-levels-label { font-size: 10px; color: var(--sgis-text-2); margin-bottom: 6px; font-weight: 600; }
    .sgis-badge-hero-levels-bars { display: flex; align-items: flex-end; justify-content: space-around; gap: 4px; height: 50px; }
    .sgis-badge-hero-level-cell { flex: 1; display: flex; flex-direction: column; align-items: center; gap: 2px; min-width: 0; }
    .sgis-badge-hero-level-bar {
        width: 100%; min-height: 3px; max-width: 24px;
        background: linear-gradient(180deg, #8b5cf6 0%, #6366f1 100%);
        border-radius: 3px 3px 0 0; flex: 1; align-self: flex-end;
        display: flex; align-items: flex-start; justify-content: center; padding-top: 2px;
        box-shadow: 0 0 6px rgba(139, 92, 246, 0.3);
        transition: height 0.4s;
    }
    .sgis-badge-hero-level-count { font-size: 9px; color: #fff; font-weight: 700; font-variant-numeric: tabular-nums; }
    .sgis-badge-hero-level-num { font-size: 9px; color: var(--sgis-text-2); font-weight: 600; }

    /* === v2.9.15: 章节标题 meta(右侧次要信息) === */
    .sgis-section-title-meta { font-size: 10px; color: var(--sgis-text-2); font-weight: 500; text-transform: none; letter-spacing: 0; margin-left: auto; }

    /* === v2.9.38: 洞察页成就引导入口(替代旧折叠列表) === */
    .sgis-insight-ach-entry {
        display: flex;
        align-items: center;
        gap: 12px;
        padding: 12px 14px;
        background: linear-gradient(135deg, rgba(251, 191, 36, 0.08), rgba(245, 158, 11, 0.04));
        border: 1px solid rgba(251, 191, 36, 0.18);
        border-radius: 10px;
        transition: all 0.25s ease;
        margin-top: 2px;
    }
    .sgis-insight-ach-entry:hover {
        background: linear-gradient(135deg, rgba(251, 191, 36, 0.14), rgba(245, 158, 11, 0.08));
        border-color: rgba(251, 191, 36, 0.35);
        transform: translateY(-1px);
        box-shadow: 0 4px 12px rgba(251, 191, 36, 0.12);
    }
    .sgis-insight-ach-entry > svg {
        width: 36px;
        height: 36px;
        flex-shrink: 0;
        filter: drop-shadow(0 2px 4px rgba(251, 191, 36, 0.25));
    }
    .sgis-insight-ach-entry-info {
        flex: 1;
        min-width: 0;
    }
    .sgis-insight-ach-entry-title {
        font-size: 12px;
        font-weight: 700;
        color: #fef3c7;
        margin-bottom: 2px;
        line-height: 1.3;
    }
    .sgis-insight-ach-entry-sub {
        font-size: 10px;
        color: var(--sgis-text-2);
        line-height: 1.4;
    }
    .sgis-insight-ach-entry-btn {
        flex-shrink: 0;
        padding: 5px 10px;
        background: linear-gradient(135deg, #fbbf24, #f59e0b);
        color: #1c0a01;
        border: none;
        border-radius: 6px;
        font-size: 10px;
        font-weight: 700;
        cursor: pointer;
        transition: all 0.2s ease;
        white-space: nowrap;
    }
    .sgis-insight-ach-entry-btn:hover {
        background: linear-gradient(135deg, #fcd34d, #fbbf24);
        transform: translateY(-1px);
        box-shadow: 0 2px 6px rgba(251, 191, 36, 0.4);
    }
    .sgis-insight-ach-entry-btn:active {
        transform: translateY(0);
    }

    /* === v2.9.15: 徽章 group 头增强(加进度条 + 已合成数) === */
    .sgis-badge-group-head { gap: 10px; padding: 9px 12px; }
    .sgis-badge-group-head:hover { background: linear-gradient(135deg, rgba(139, 92, 246, 0.05), rgba(59, 130, 246, 0.02)); }
    .sgis-badge-group-progress { width: 100%; margin-top: 6px; height: 3px; background: rgba(255, 255, 255, 0.05); border-radius: 2px; overflow: hidden; }
    .sgis-badge-group-progress-fill { height: 100%; background: linear-gradient(90deg, #10b981, #34d399); border-radius: 2px; }
    .sgis-badge-group-stats { flex-direction: column; align-items: flex-end; gap: 3px; }
    .sgis-badge-group-stat-val { font-size: 11px; font-weight: 700; color: #c4b5fd; }
    .sgis-badge-group-stat-lbl { font-size: 9px; color: var(--sgis-text-3); margin-left: 4px; }

    /* === v2.9.15: 徽章 footer 折叠说明 === */
    .sgis-badge-footer-details {
        margin-top: 14px; padding: 8px 10px;
        background: rgba(255, 255, 255, 0.02); border: 1px solid rgba(255, 255, 255, 0.05);
        border-radius: 7px; font-size: 10px; color: var(--sgis-text-2);
    }
    .sgis-badge-footer-details summary {
        cursor: pointer; font-weight: 600; user-select: none;
        list-style: none; display: flex; align-items: center; gap: 5px;
    }
    .sgis-badge-footer-details summary::-webkit-details-marker { display: none; }
    .sgis-badge-footer-details summary::before { content: "▸"; display: inline-block; transition: transform 0.2s; font-size: 9px; color: var(--sgis-text-3); }
    .sgis-badge-footer-details[open] summary::before { transform: rotate(90deg); }
    .sgis-badge-footer-content { padding-top: 8px; line-height: 1.6; }
    .sgis-badge-footer-formula { margin-bottom: 4px; }
    .sgis-badge-footer-formula b { color: #c4b5fd; }
    .sgis-badge-footer-breakdown { font-size: 9px; color: var(--sgis-text-3); }
    .sgis-badge-footer-meta { font-size: 9px; color: var(--sgis-text-3); margin-top: 2px; }

    /* === v2.9.15 → v2.9.18 → v2.9.21: 价值卡片单列布局(共享库默认 flex 单列,在窄侧边栏里 2 列挤压变形) ===
       v2.9.18 尝试 2 列 grid + minmax(0,1fr) + 三层 min-width:0 链式压制,但实际渲染出单卡仍被竖向挤压
       (游戏名截断为 S..、Lv./50/XP 竖排)—— 在 300px 宽的 SGIS 侧边栏里 2 列宽度仍不够放下 56px img + 38px score + 名字 + market。
       v2.9.21 退回单列布局,删掉所有过紧的子项压缩样式,卡片按 flex 自然撑开,信息完整可读。
       历史: 共享库 sglv-shared-css.lib.js:1467 的 .sgis-value-cards { display:flex; flex-direction:column; gap:6px; } 直接可用。
       这里只追加 !important 防止共享库默认被覆盖即可,不再做 2 列。
    */
    .sgis-value-cards {
        display: flex !important;
        flex-direction: column !important;
        gap: 6px !important;
        width: 100% !important;
        max-width: 100% !important;
        box-sizing: border-box;
    }
    /* 单元本身保持原样,不压制 min-width,让 flex 子项(img 56 + score 38 + market 文本)自然撑开 */

    /* === v2.9.17: 愿望单首次加载骨架屏(避免页面紧缩) === */
    @keyframes sglv-skel-shimmer { 0% { background-position: -200% 0; } 100% { background-position: 200% 0; } }
    .sglv-skel-bar {
        background: linear-gradient(90deg, rgba(255, 255, 255, 0.04) 0%, rgba(139, 92, 246, 0.12) 50%, rgba(255, 255, 255, 0.04) 100%);
        background-size: 200% 100%;
        animation: sglv-skel-shimmer 1.6s linear infinite;
        border-radius: 4px;
    }
    .sglv-wl-kpi {
        display: grid;
        grid-template-columns: repeat(2, 1fr);
        gap: 6px;
        margin-bottom: 10px;
    }
    .sglv-wl-kpi-cell {
        background: linear-gradient(135deg, rgba(139, 92, 246, 0.06), rgba(59, 130, 246, 0.03));
        border: 1px solid rgba(139, 92, 246, 0.15);
        border-radius: 8px;
        padding: 10px 8px;
        text-align: center;
        display: flex;
        flex-direction: column;
        align-items: center;
        gap: 6px;
    }
    .sglv-skel-num { width: 50%; height: 18px; }
    .sglv-skel-lbl { width: 70%; height: 9px; }
    .sglv-skel-section-title { width: 40%; height: 12px; margin-bottom: 8px; }
    .sglv-skel-row { width: 100%; height: 10px; margin-bottom: 6px; opacity: 0.85; }
    .sglv-skel-row-short { width: 60%; opacity: 0.6; }
    .sglv-skel-grid {
        display: grid;
        grid-template-columns: repeat(auto-fill, minmax(140px, 1fr));
        gap: 8px;
        padding: 4px 0;
    }
    .sglv-skel-game-card {
        background: rgba(255, 255, 255, 0.025);
        border: 1px solid rgba(255, 255, 255, 0.05);
        border-radius: 8px;
        padding: 8px;
        display: flex;
        flex-direction: column;
        gap: 8px;
    }
    .sglv-skel-cover {
        width: 100%;
        aspect-ratio: 184 / 69;
        background: linear-gradient(90deg, rgba(139, 92, 246, 0.08) 0%, rgba(139, 92, 246, 0.18) 50%, rgba(139, 92, 246, 0.08) 100%);
        background-size: 200% 100%;
        animation: sglv-skel-shimmer 1.6s linear infinite;
        border-radius: 4px;
    }
    .sglv-skel-card-name { width: 80%; height: 11px; }
    .sglv-skel-card-meta { width: 50%; height: 9px; }
    .sglv-wl-skel-tip {
        display: flex;
        align-items: center;
        justify-content: center;
        gap: 8px;
        padding: 18px 12px;
        margin-top: 12px;
        color: var(--sglv-text-secondary, #94a3b8);
        font-size: 12px;
        font-weight: 500;
    }
    .sglv-wl-skel-tip .sglv-spinner { width: 16px; height: 16px; border-width: 2px; }
    /* === v2.9.47: 愿望单加载等待动画（参考 DLC spinner 风格） === */
    .sglv-wl-loading { display:flex; flex-direction:column; align-items:center; justify-content:center; padding:48px 20px; gap:14px; color:#94a3b8; min-height:280px; }
    .sglv-wl-loading .sglv-wl-spin { width:32px; height:32px; animation:sglv-spin 1s linear infinite; color:#a78bfa; }
    .sglv-wl-loading-text { font-size:13px; font-weight:600; color:#cbd5e1; }
    .sglv-wl-loading-sub { font-size:11px; color:#64748b; }
    .sglv-wl-loading-bar { width:220px; height:3px; background:rgba(102,192,244,0.12); border-radius:2px; overflow:hidden; }
    .sglv-wl-loading-bar-fill { height:100%; background:linear-gradient(90deg,#66c0f4,#a78bfa); border-radius:2px; transition:width 0.4s ease; }`;

    const CSS_TOAST =`            @keyframes sglv-spin { from { transform: rotate(0deg); } to { transform: rotate(360deg); } }
            .sglv-toast { position: fixed; bottom: 50px; left: 50%; transform: translateX(-50%) translateY(20px);
                background: rgba(15,23,42,0.95); color: #fff; border: 1px solid rgba(167,139,250,0.5);
                padding: 10px 24px; border-radius: 20px; font-size: 13px; font-weight: 500;
                box-shadow: 0 4px 16px rgba(0,0,0,0.3); z-index: 999999; opacity: 0; pointer-events: none;
                transition: opacity 0.3s, transform 0.3s; }
            .sglv-toast.sglv-toast-show { opacity: 1; transform: translateX(-50%) translateY(0); }
            .sglv-toast.sglv-toast-success { border-color: #2ed573; }
            .sglv-toast.sglv-toast-error { border-color: #ff6b6b; }
            .sglv-toast.sglv-toast-warning { border-color: #f59e0b; }
            .sglv-toast.sglv-toast-info { border-color: #54a0ff; }`;

    const CSS_APIKEY_GUIDE =`            @keyframes sglv-guide-in { from { opacity: 0; transform: translateX(24px); } to { opacity: 1; transform: translateX(0); } }
            .sglv-guide-toast { position: fixed; right: 24px; bottom: 24px; z-index: 999999; width: 320px; box-sizing: border-box;
                background: linear-gradient(145deg, rgba(30,41,59,0.98), rgba(15,23,42,0.98));
                border: 1px solid rgba(167,139,250,0.45); border-radius: 14px; padding: 16px;
                box-shadow: 0 12px 32px rgba(0,0,0,0.45); color: #e2e8f0; font-size: 13px;
                animation: sglv-guide-in 0.3s ease-out; }
            .sglv-guide-toast-head { display: flex; align-items: center; gap: 8px; }
            .sglv-guide-toast-title { flex: 1; display: inline-flex; align-items: center; gap: 6px; font-size: 14px; font-weight: 700; color: #fff; }
            .sglv-guide-toast-title svg { width: 15px; height: 15px; color: #a78bfa; }
            .sglv-guide-toast-close { background: none; border: none; color: #94a3b8; cursor: pointer; padding: 3px; line-height: 0; border-radius: 6px; }
            .sglv-guide-toast-close:hover { color: #fff; background: rgba(148,163,184,0.15); }
            .sglv-guide-toast-close svg { width: 13px; height: 13px; }
            .sglv-guide-toast-desc { margin: 8px 0 12px; color: #94a3b8; font-size: 12px; line-height: 1.7; }
            .sglv-guide-toast-actions { display: flex; gap: 8px; }
            .sglv-guide-toast-btn { flex: 1; padding: 8px 0; border-radius: 8px; font-size: 12px; font-weight: 600; cursor: pointer; border: 1px solid transparent; transition: filter 0.15s; }
            .sglv-guide-toast-btn.primary { background: linear-gradient(90deg, #8b5cf6, #3b82f6); color: #fff; }
            .sglv-guide-toast-btn.ghost { background: transparent; border-color: rgba(148,163,184,0.3); color: #cbd5e1; }
            .sglv-guide-toast-btn:hover { filter: brightness(1.15); }`;

    const CSS_SETTINGS =`            .sglv-panel .sglv-settings-btn.sglv-active { background: rgba(102,192,244,0.2) !important; color: #66c0f4 !important; box-shadow: inset 0 0 0 1px rgba(102,192,244,0.5); border-radius: 6px; }
            .sglv-set-wrap { display: flex; flex-direction: column; height: 100%; min-height: 0; }
            .sglv-set-topbar { display: flex; align-items: center; gap: 12px; padding: 14px 18px 10px; flex: none; border-bottom: 1px solid rgba(148,163,184,0.12); }
            .sglv-set-back { display: inline-flex; align-items: center; gap: 6px; background: rgba(148,163,184,0.1); border: 1px solid rgba(148,163,184,0.2); color: #cbd5e1; font-size: 12px; font-weight: 600; padding: 6px 12px; border-radius: 8px; cursor: pointer; transition: background 0.15s, color 0.15s; }
            .sglv-set-back:hover { background: rgba(148,163,184,0.22); color: #fff; }
            .sglv-set-title { display: flex; align-items: center; gap: 8px; font-size: 15px; font-weight: 700; color: #fff; }
            .sglv-set-title svg { width: 16px; height: 16px; color: #66c0f4; }
            .sglv-set-grid { flex: 1; min-height: 0; overflow-y: auto; display: grid; grid-template-columns: repeat(auto-fit, minmax(340px, 1fr)); gap: 14px; padding: 16px 18px; align-content: start; }
            .sglv-set-card { background: rgba(15,23,42,0.55); border: 1px solid rgba(148,163,184,0.14); border-radius: 12px; padding: 16px; transition: border-color 0.15s; }
            .sglv-set-card:hover { border-color: rgba(102,192,244,0.35); }
            .sglv-set-card.wide { grid-column: 1 / -1; }
            .sglv-set-card-title { display: flex; align-items: center; gap: 8px; font-size: 13px; font-weight: 700; color: #e2e8f0; margin-bottom: 8px; }
            .sglv-set-chip { display: inline-flex; width: 26px; height: 26px; align-items: center; justify-content: center; border-radius: 8px; flex: none; }
            .sglv-set-chip svg { width: 14px; height: 14px; }
            .sglv-set-chip.blue { background: rgba(102,192,244,0.15); color: #66c0f4; }
            .sglv-set-chip.purple { background: rgba(167,139,250,0.15); color: #a78bfa; }
            .sglv-set-chip.amber { background: rgba(245,158,11,0.15); color: #f59e0b; }
            .sglv-set-desc { font-size: 12px; color: #94a3b8; line-height: 1.7; margin-bottom: 12px; }
            .sglv-set-desc a { color: #66c0f4; text-decoration: none; }
            .sglv-set-desc a:hover { text-decoration: underline; }
            .sglv-set-field { margin-bottom: 12px; }
            .sglv-set-field:last-child { margin-bottom: 0; }
            .sglv-set-field > label { display: block; font-size: 12px; font-weight: 600; color: #cbd5e1; margin-bottom: 6px; }
            .sglv-set-input { width: 100%; box-sizing: border-box; background: rgba(2,6,23,0.6); border: 1px solid rgba(148,163,184,0.22); border-radius: 8px; padding: 9px 12px; color: #e2e8f0; font-size: 13px; transition: border-color 0.15s, box-shadow 0.15s; }
            .sglv-set-input::placeholder { color: #475569; }
            .sglv-set-input:focus { outline: none; border-color: #66c0f4; box-shadow: 0 0 0 3px rgba(102,192,244,0.15); }
            .sglv-set-hint { font-size: 11px; color: #64748b; margin-top: 4px; line-height: 1.5; }
            .sglv-set-mode-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(280px, 1fr)); gap: 10px; }
            .sglv-set-mode-item { display: flex; gap: 10px; align-items: flex-start; padding: 10px 12px; border: 1px solid rgba(148,163,184,0.16); border-radius: 10px; cursor: pointer; transition: border-color 0.15s, background 0.15s; }
            .sglv-set-mode-item:hover { border-color: rgba(167,139,250,0.4); background: rgba(167,139,250,0.06); }
            .sglv-set-mode-item input { margin-top: 3px; accent-color: #a78bfa; cursor: pointer; }
            .sglv-set-mode-item input:checked ~ .sglv-set-mode-info .sglv-set-mode-name { color: #a78bfa; }
            .sglv-set-mode-name { font-size: 12.5px; font-weight: 700; color: #e2e8f0; }
            .sglv-set-mode-desc { font-size: 11.5px; color: #94a3b8; margin-top: 2px; line-height: 1.5; }
            /* v2.9.46: 设置页面开关样式 */
            .sglv-set-chip.green { background: rgba(75,181,79,0.15); color: #4bb54f; }
            .sglv-set-toggle-row { display: flex !important; align-items: center; justify-content: space-between; font-size: 12.5px; font-weight: 600; color: #cbd5e1; cursor: pointer; user-select: none; }
            .sglv-set-switch { position: relative; display: inline-block; width: 36px; height: 20px; flex: none; }
            .sglv-set-switch input { opacity: 0; width: 0; height: 0; }
            .sglv-set-slider { position: absolute; cursor: pointer; inset: 0; background-color: rgba(255,255,255,0.1); transition: .2s; border-radius: 20px; border: 1px solid rgba(255,255,255,0.05); }
            .sglv-set-slider:before { position: absolute; content: ""; height: 14px; width: 14px; left: 2px; bottom: 2px; background-color: #8a9ba8; transition: .2s; border-radius: 50%; }
            .sglv-set-switch input:checked + .sglv-set-slider { background-color: rgba(75,181,79,0.2); border-color: rgba(75,181,79,0.4); }
            .sglv-set-switch input:checked + .sglv-set-slider:before { transform: translateX(16px); background-color: #4bb54f; }
            /* v2.11.40: 外观主题选择卡（sglv-set-theme-swatch 为主题预览色板，颜色刻意固定不随主题切换——生成器跳过） */
            .sglv-set-theme-grid { display: grid; grid-template-columns: repeat(2, 1fr); gap: 10px; }
            .sglv-set-theme-opt { position: relative; display: flex; flex-direction: column; gap: 8px; padding: 10px; border: 1px solid rgba(148,163,184,0.16); border-radius: 10px; cursor: pointer; transition: border-color 0.15s, background 0.15s, box-shadow 0.15s; }
            .sglv-set-theme-opt:hover { border-color: rgba(167,139,250,0.4); }
            .sglv-set-theme-opt input { position: absolute; opacity: 0; width: 0; height: 0; }
            .sglv-set-theme-swatch { height: 34px; border-radius: 8px; border: 1px solid rgba(255,255,255,0.08); }
            .sglv-set-theme-swatch.purple { background: linear-gradient(135deg, #171a21 0%, #4c1d95 55%, #a78bfa 100%); }
            .sglv-set-theme-swatch.blue { background: linear-gradient(135deg, #171a21 0%, #2a475e 55%, #66c0f4 100%); }
            .sglv-set-theme-name { display: flex; align-items: center; justify-content: space-between; font-size: 12.5px; font-weight: 700; color: #e2e8f0; }
            .sglv-set-theme-name .sglv-set-theme-check { color: #4bb54f; font-size: 12px; opacity: 0; }
            .sglv-set-theme-opt.selected { border-color: rgba(167,139,250,0.55); background: rgba(167,139,250,0.07); box-shadow: 0 0 0 1px rgba(167,139,250,0.25); }
            .sglv-set-theme-opt.selected .sglv-set-theme-check { opacity: 1; }
            .sglv-set-theme-desc { font-size: 11px; color: #94a3b8; line-height: 1.5; }
            .sglv-set-savebar { display: flex; align-items: center; gap: 12px; padding: 12px 18px; flex: none; border-top: 1px solid rgba(148,163,184,0.12); background: rgba(2,6,23,0.35); }
            .sglv-set-save-btn { display: inline-flex; align-items: center; gap: 6px; background: linear-gradient(90deg, #8b5cf6, #3b82f6); color: #fff; border: none; border-radius: 8px; padding: 9px 22px; font-size: 13px; font-weight: 700; cursor: pointer; transition: filter 0.15s, transform 0.1s; }
            .sglv-set-save-btn:hover { filter: brightness(1.15); }
            .sglv-set-save-btn:active { transform: scale(0.97); }
            .sglv-set-status { font-size: 12px; color: #2ed573; font-weight: 600; }`;

    const CSS_KPI =`            .sglv-stat-dash-card.orange { border-color: rgba(245, 158, 11, 0.3); background: rgba(245, 158, 11, 0.08); }
            .sglv-stat-dash-card.orange .sglv-stat-dash-icon { color: #f59e0b; }
            .sglv-stat-dash-card.orange .sglv-stat-dash-value { color: #f59e0b; }
            .sglv-stat-dash-card.teal { border-color: rgba(20, 184, 166, 0.3); background: rgba(20, 184, 166, 0.08); }
            .sglv-stat-dash-card.teal .sglv-stat-dash-icon { color: #14b8a6; }
            .sglv-stat-dash-card.teal .sglv-stat-dash-value { color: #14b8a6; }
            .sglv-stat-dash-card.pink { border-color: rgba(236, 72, 153, 0.3); background: rgba(236, 72, 153, 0.08); }
            .sglv-stat-dash-card.pink .sglv-stat-dash-icon { color: #ec4899; }
            .sglv-stat-dash-card.pink .sglv-stat-dash-value { color: #ec4899; }
            .sglv-bundle-badge { display: inline-block; margin-left: 4px; padding: 1px 5px; font-size: 10px; font-weight: 600; border-radius: 3px; background: #f59e0b; color: #fff; vertical-align: middle; cursor: help; }
            /* v2.9.69: 游戏橱窗 KPI 改为 grid 7 列扁平布局，与统计仪表/趋势页一致 */
            .sglv-stats-dashboard { display: grid !important; grid-template-columns: repeat(7, 1fr) !important; gap: 6px !important; }
            @media (max-width: 1280px) { .sglv-stats-dashboard { grid-template-columns: repeat(4, 1fr) !important; } }
            @media (max-width: 768px) { .sglv-stats-dashboard { grid-template-columns: repeat(3, 1fr) !important; } }
            @media (max-width: 480px) { .sglv-stats-dashboard { grid-template-columns: repeat(2, 1fr) !important; } }
            .sglv-stats-dashboard .sglv-stat-dash-card { min-width: 0; cursor: pointer; transition: transform 0.15s, box-shadow 0.15s, border-color 0.15s; }
            .sglv-stats-dashboard .sglv-stat-dash-card:hover { transform: translateY(-2px); box-shadow: 0 4px 12px rgba(0,0,0,0.3); }
            .sglv-stats-dashboard .sglv-stat-dash-card.active { box-shadow: 0 0 0 2px rgba(102,192,244,0.4); border-left-width: 4px !important; }
            .sglv-stats-dashboard .sglv-stat-dash-card.amber { cursor: default; }
            .sglv-stats-dashboard .sglv-stat-dash-card.amber:hover { transform: none; box-shadow: none; }`;

    const CSS_SUBSTATUS =`            .sgis-sub-status { display: flex; flex-wrap: wrap; gap: 6px; margin-top: 8px; }
            .sgis-sub-badge { display: inline-flex; align-items: center; gap: 4px; padding: 3px 8px; font-size: 11px; font-weight: 600; border-radius: 4px; }
            /* v2.9.13: 年度大作 KPI 卡片可点击筛选样式 */
            .sglv-trend-kpi-card.clickable { cursor: pointer; transition: transform 0.15s, box-shadow 0.15s, border-color 0.15s; }
            .sglv-trend-kpi-card.clickable:hover { transform: translateY(-2px); box-shadow: 0 4px 12px rgba(0,0,0,0.3); }
            .sglv-trend-kpi-card.active { border-width: 2px; box-shadow: 0 0 0 2px rgba(102,192,244,0.4); }`;

    const CSS_COVER =`            /* ====== 横版封面视图（3列，467/181 胶囊横幅） ====== */
            .sglv-cover-grid { display: grid !important; grid-template-columns: repeat(3, 1fr) !important; gap: 12px !important; }
            @media (max-width: 1100px) { .sglv-cover-grid { grid-template-columns: repeat(2, 1fr) !important; } }
            @media (max-width: 700px) { .sglv-cover-grid { grid-template-columns: 1fr !important; } }
            .sglv-cover-card {
                background: linear-gradient(135deg, rgba(255,255,255,0.06) 0%, rgba(255,255,255,0.02) 100%) !important;
                border: 1px solid rgba(102,192,244,0.1) !important;
                border-radius: 10px !important;
                overflow: hidden !important;
                transition: transform 0.2s, box-shadow 0.2s, border-color 0.2s !important;
                cursor: pointer !important;
                display: flex !important;
                flex-direction: column !important;
            }
            .sglv-cover-card:hover {
                border-color: rgba(102,192,244,0.35) !important;
                transform: translateY(-3px) !important;
                box-shadow: 0 6px 20px rgba(102,192,244,0.12), 0 2px 8px rgba(0,0,0,0.3) !important;
            }
            .sglv-cover-img-wrap {
                position: relative !important;
                width: 100% !important;
                aspect-ratio: 467/181 !important;
                overflow: hidden !important;
                background: rgba(255,255,255,0.05) !important;
                flex-shrink: 0 !important;
            }
            .sglv-cover-img { width: 100% !important; height: 100% !important; object-fit: cover !important; display: block !important; transition: transform 0.3s !important; }
            .sglv-cover-card:hover .sglv-cover-img { transform: scale(1.04) !important; }
            .sglv-cover-gradient {
                position: absolute !important; bottom: 0 !important; left: 0 !important; right: 0 !important;
                height: 45% !important;
                background: linear-gradient(to top, rgba(13,18,35,0.85) 0%, transparent 100%) !important;
                pointer-events: none !important; z-index: 1 !important;
            }
            .sglv-cover-badges { position: absolute !important; top: 6px !important; left: 6px !important; display: flex !important; gap: 4px !important; z-index: 2 !important; }
            .sglv-cover-badge {
                display: inline-flex !important; align-items: center !important; gap: 3px !important;
                font-size: 10px !important; font-weight: 700 !important; padding: 2px 7px !important;
                border-radius: 4px !important; backdrop-filter: blur(6px) !important; -webkit-backdrop-filter: blur(6px) !important;
                background: rgba(0,0,0,0.55) !important; color: #c4b5fd !important; line-height: 1.3 !important;
            }
            .sglv-cover-badge svg { width: 10px !important; height: 10px !important; opacity: 0.85 !important; }
            .sglv-cover-badge.shared { background: rgba(139,92,246,0.55) !important; color: #ddd6fe !important; }
            .sglv-cover-badge.bundle { background: rgba(255,152,0,0.55) !important; color: #ffd591 !important; }
            .sglv-cover-playtime {
                position: absolute !important; bottom: 6px !important; right: 6px !important;
                display: inline-flex !important; align-items: center !important; gap: 3px !important;
                font-size: 11px !important; font-weight: 700 !important; padding: 2px 8px !important;
                border-radius: 4px !important; background: rgba(0,0,0,0.65) !important; color: #66c0f4 !important;
                backdrop-filter: blur(6px) !important; -webkit-backdrop-filter: blur(6px) !important;
                z-index: 2 !important; line-height: 1.3 !important;
            }
            .sglv-cover-playtime svg { width: 10px !important; height: 10px !important; opacity: 0.85 !important; }
            .sglv-cover-body { padding: 8px 10px 9px !important; display: flex !important; flex-direction: column !important; gap: 3px !important; }
            .sglv-cover-name { font-size: 13px !important; font-weight: 600 !important; color: #e0e0e0 !important; overflow: hidden !important; text-overflow: ellipsis !important; white-space: nowrap !important; }
            .sglv-cover-meta { display: flex; align-items: center; gap: 5px; flex-wrap: wrap; }
            .sglv-cover-id { font-size: 10px !important; color: var(--sglv-text-secondary) !important; font-variant-numeric: tabular-nums !important; }
            /* ====== 卡片视图增强 ====== */
            .sglv-game-card { border-radius: 10px !important; }
            .sglv-game-card:hover { box-shadow: 0 6px 20px rgba(102,192,244,0.1), 0 2px 8px rgba(0,0,0,0.3) !important; }
            .sglv-card-img { transition: transform 0.3s !important; }
            .sglv-game-card:hover .sglv-card-img { transform: scale(1.05) !important; }
            /* ====== 工具栏排版优化 ====== */
            .sglv-toolbar { gap: 8px !important; }`;

    const CSS_PRICE =`                /* === 9区完整价格对比表 === */
                .sgis-price-tbl { display:flex; flex-direction:column; gap:1px; }
                .sgis-price-tbl-header {
                    display:grid; grid-template-columns: 1.6fr 0.9fr 1fr 0.6fr 0.9fr;
                    gap:2px; padding:4px 6px; font-size:9px; color:var(--sgis-text-2);
                    text-transform:uppercase; letter-spacing:0.3px; border-bottom:1px solid rgba(255,255,255,0.06);
                }
                .sgis-price-tbl-row {
                    display:grid; grid-template-columns: 1.6fr 0.9fr 1fr 0.6fr 0.9fr;
                    gap:2px; padding:5px 6px; font-size:11px; align-items:center;
                    border-radius:4px; transition:background 0.15s;
                }
                .sgis-price-tbl-row:hover { background:rgba(255,255,255,0.04); }
                .sgis-price-tbl-row-lowest { background:rgba(75,181,79,0.12) !important; border-left:3px solid #4bb54f; }
                .sgis-price-tbl-row-highest { background:rgba(230,57,70,0.10) !important; border-left:3px solid #e63946; }
                .sgis-price-tbl-row.user-region { box-shadow: inset 0 0 0 1px rgba(167,139,250,0.3); }
                .sgis-price-tbl-cell { display:flex; align-items:center; gap:3px; overflow:hidden; }
                .sgis-price-tbl-region { gap:4px; }
                .sgis-price-tbl-initial { color:var(--sgis-text-2); font-size:10px; }
                .sgis-price-tbl-price { font-weight:600; }
                .sgis-price-tbl-cny { font-weight:700; color:#66c0f4; }
                .sgis-price-tbl-badge-low { font-size:8px; background:#4bb54f; color:#fff; padding:1px 4px; border-radius:3px; margin-left:2px; }
                .sgis-price-tbl-badge-high { font-size:8px; background:#e63946; color:#fff; padding:1px 4px; border-radius:3px; margin-left:2px; }

                /* === 评测标签页 === */
                /* === v2.9.15: 评测摘要（Steam 风格大字 + 渐变进度条） === */
                .sgis-review-summary { display:flex; flex-direction:column; gap:10px; padding:10px 12px; background:rgba(255,255,255,0.02); border:1px solid rgba(255,255,255,0.05); border-radius:8px; }
                .sgis-review-summary-head { display:flex; align-items:center; gap:12px; }
                .sgis-review-score { display:flex; align-items:center; gap:12px; flex:1; min-width:0; }
                .sgis-review-score-icon { font-size:30px; line-height:1; flex-shrink:0; filter:drop-shadow(0 1px 2px rgba(0,0,0,0.3)); }
                .sgis-review-score-meta { display:flex; flex-direction:column; gap:2px; min-width:0; flex:1; }
                .sgis-review-score-text { font-size:14px; font-weight:700; line-height:1.2; }
                .sgis-review-score-desc { font-size:10px; color:var(--sgis-text-2); line-height:1.3; }
                .sgis-review-pct-big { font-size:24px; font-weight:800; font-variant-numeric:tabular-nums; line-height:1; flex-shrink:0; letter-spacing:-0.5px; }
                .sgis-review-pct-big.pos { color:#4bb54f; }
                .sgis-review-pct-big.mix { color:#a78bfa; }
                .sgis-review-pct-big.neg { color:#e63946; }
                .sgis-review-bar { display:flex; height:8px; border-radius:4px; overflow:hidden; background:rgba(230,57,70,0.3); box-shadow:inset 0 1px 2px rgba(0,0,0,0.3); }
                .sgis-review-bar-positive { background:linear-gradient(90deg,#4bb54f 0%,#66c0f4 100%); height:100%; transition:width 0.5s cubic-bezier(0.4,0,0.2,1); box-shadow:0 0 6px rgba(75,181,79,0.4); }
                .sgis-review-bar-positive.mix { background:linear-gradient(90deg,#a78bfa 0%,#54a0ff 100%); box-shadow:0 0 6px rgba(167,139,250,0.4); }
                .sgis-review-bar-positive.neg { background:linear-gradient(90deg,#e63946 0%,#ff6b6b 100%); box-shadow:0 0 6px rgba(230,57,70,0.4); }
                .sgis-review-counts { display:flex; justify-content:space-between; font-size:10px; font-weight:600; }
                .sgis-review-counts .pos { color:#4bb54f; }
                .sgis-review-counts .neg { color:#e63946; }
                .sgis-review-trend { display:flex; gap:10px; font-size:10px; flex-wrap:wrap; padding:6px 8px; background:rgba(255,255,255,0.02); border-radius:6px; }
                .sgis-review-trend-item { display:flex; flex-direction:column; gap:2px; flex:1; min-width:80px; }
                .sgis-review-trend-label { color:var(--sgis-text-2); font-size:9px; }
                .sgis-review-trend-val { font-weight:600; font-variant-numeric:tabular-nums; }
                .sgis-review-filters { display:flex; flex-wrap:wrap; gap:4px; padding:6px 0; border-top:1px solid rgba(255,255,255,0.06); border-bottom:1px solid rgba(255,255,255,0.06); }
                .sgis-review-filter-group { display:flex; align-items:center; gap:2px; }
                .sgis-review-filter-label { font-size:9px; color:var(--sgis-text-2); margin-right:2px; }
                .sgis-review-filter-btn {
                    font-size:10px; padding:2px 7px; border-radius:10px; border:1px solid rgba(255,255,255,0.1);
                    background:transparent; color:var(--sgis-text-2); cursor:pointer; transition:all 0.15s;
                }
                .sgis-review-filter-btn:hover { background:rgba(255,255,255,0.06); }
                .sgis-review-filter-btn.active { background:rgba(102,192,244,0.2); color:#66c0f4; border-color:rgba(102,192,244,0.4); }
                .sgis-review-list { display:flex; flex-direction:column; gap:8px; padding:4px 0; }
                /* v2.9.15: 评测项卡片化——左右色条标识好评/差评 */
                .sgis-review-item {
                    position:relative; padding:10px 10px 8px 12px; border-radius:8px;
                    background:rgba(255,255,255,0.025); border:1px solid rgba(255,255,255,0.05);
                    transition:all 0.2s ease; overflow:hidden;
                }
                .sgis-review-item::before {
                    content:""; position:absolute; left:0; top:0; bottom:0; width:3px;
                    background:linear-gradient(180deg,transparent,rgba(75,181,79,0.5),transparent);
                    opacity:0; transition:opacity 0.2s;
                }
                .sgis-review-item.is-positive::before { background:linear-gradient(180deg,transparent,#4bb54f,transparent); opacity:0.7; }
                .sgis-review-item.is-negative::before { background:linear-gradient(180deg,transparent,#e63946,transparent); opacity:0.7; }
                .sgis-review-item:hover { background:rgba(255,255,255,0.045); border-color:rgba(139,92,246,0.15); transform:translateY(-1px); box-shadow:0 2px 8px rgba(0,0,0,0.15); }
                .sgis-review-item.is-positive:hover { border-color:rgba(75,181,79,0.25); }
                .sgis-review-item.is-negative:hover { border-color:rgba(230,57,70,0.25); }
                .sgis-review-item-header { display:flex; align-items:center; gap:8px; margin-bottom:6px; }
                .sgis-review-avatar { width:32px; height:32px; min-width:32px; border-radius:50%; background:rgba(255,255,255,0.08); display:flex; align-items:center; justify-content:center; object-fit:cover; flex-shrink:0; border:1px solid rgba(255,255,255,0.06); }
                .sgis-review-avatar-link { display:inline-flex; line-height:0; flex-shrink:0; border-radius:50%; transition:transform 0.2s; }
                .sgis-review-avatar-link:hover { transform:scale(1.08); }
                .sgis-review-avatar-fallback {
                    background:linear-gradient(135deg,rgba(139,92,246,0.4),rgba(59,130,246,0.3));
                    color:#fff; font-weight:700; font-size:13px; letter-spacing:0.5px;
                    text-transform:uppercase;
                }
                .sgis-review-author-wrap { display:flex; flex-direction:column; gap:1px; min-width:0; flex:1; }
                .sgis-review-author { font-size:12px; font-weight:600; color:#66c0f4; text-decoration:none; overflow:hidden; text-overflow:ellipsis; white-space:nowrap; transition:color 0.15s; }
                a.sgis-review-author:hover { color:#93c5fd; }
                .sgis-review-date { font-size:10px; color:var(--sgis-text-3); font-weight:400; }
                .sgis-review-rec { font-size:10px; padding:2px 7px; border-radius:4px; font-weight:700; flex-shrink:0; }
                .sgis-review-rec-yes { background:rgba(75,181,79,0.18); color:#4bb54f; border:1px solid rgba(75,181,79,0.3); }
                .sgis-review-rec-no { background:rgba(230,57,70,0.18); color:#f87171; border:1px solid rgba(230,57,70,0.3); }
                .sgis-review-meta { font-size:10px; color:var(--sgis-text-2); display:flex; gap:8px; flex-wrap:wrap; margin:6px 0 4px; }
                .sgis-review-meta-item { padding:1px 6px; background:rgba(255,255,255,0.04); border-radius:3px; }
                /* v2.9.15: 计数摘要条——图标 + 数字 + 已筛选徽章 */
                .sgis-review-count-summary {
                    display:flex; align-items:center; gap:6px; margin-top:8px;
                    padding:5px 8px; font-size:10px; color:var(--sgis-text-2);
                    background:rgba(139,92,246,0.06); border:1px solid rgba(139,92,246,0.12);
                    border-radius:5px;
                }
                .sgis-review-count-summary b { color:#c4b5fd; font-weight:700; }
                .sgis-review-count-icon { width:12px; height:12px; color:#a78bfa; flex-shrink:0; }
                .sgis-review-count-icon svg { width:12px; height:12px; }
                .sgis-review-count-filtered {
                    margin-left:auto; font-size:9px; font-weight:700; padding:1px 6px;
                    background:rgba(167,139,250,0.2); color:#a78bfa;
                    border:1px solid rgba(167,139,250,0.3); border-radius:8px;
                }
                .sgis-review-text {
                    font-size:12px; line-height:1.6; color:var(--sgis-text); margin-top:4px;
                    display:-webkit-box; -webkit-line-clamp:3; -webkit-box-orient:vertical; overflow:hidden;
                    cursor:pointer; transition:all 0.15s; padding:4px 0; word-break:break-word;
                }
                .sgis-review-text:hover { color:#f8fafc; }
                .sgis-review-text.expanded { -webkit-line-clamp:unset; overflow:visible; }
                /* v2.9.15: 评测项操作行（展开/复制）——紧凑胶囊按钮 */
                .sgis-review-actions { display:flex; align-items:center; gap:6px; margin-top:6px; }
                .sgis-review-action-btn {
                    display:inline-flex; align-items:center; gap:4px;
                    padding:2px 8px; font-size:10px; font-weight:600;
                    background:rgba(255,255,255,0.04); border:1px solid rgba(255,255,255,0.08);
                    color:var(--sgis-text-2); border-radius:10px;
                    cursor:pointer; transition:all 0.15s;
                }
                .sgis-review-action-btn:hover { background:rgba(139,92,246,0.15); border-color:rgba(139,92,246,0.3); color:#c4b5fd; }
                .sgis-review-action-btn svg { width:11px; height:11px; transition:transform 0.25s; }
                .sgis-review-expand-btn.is-expanded svg { transform:rotate(180deg); }
                .sgis-review-action-btn.copied { background:rgba(75,181,79,0.2); border-color:rgba(75,181,79,0.4); color:#4bb54f; }
                .sgis-review-votes { font-size:10px; color:var(--sgis-text-3); margin-top:6px; display:flex; gap:10px; padding-top:6px; border-top:1px dashed rgba(255,255,255,0.06); }
                /* v2.9.15: 评测空状态——精致状态点 + 文字 */
                .sgis-review-empty {
                    text-align:center; padding:30px 16px; font-size:12px; color:var(--sgis-text-2);
                    display:flex; flex-direction:column; align-items:center; gap:6px;
                }
                .sgis-review-empty-icon {
                    width:42px; height:42px; border-radius:12px;
                    background:linear-gradient(135deg,rgba(139,92,246,0.12),rgba(59,130,246,0.06));
                    border:1px solid rgba(139,92,246,0.18);
                    display:flex; align-items:center; justify-content:center;
                    color:var(--sgis-text-2); margin-bottom:4px;
                }
                .sgis-review-empty-icon svg { width:20px; height:20px; }

                /* === 跨区送礼推荐 === */
                .sgis-gift-card {
                    padding:10px; border-radius:8px; background:linear-gradient(135deg, rgba(167,139,250,0.12), rgba(102,192,244,0.08));
                    border:1px solid rgba(167,139,250,0.2); margin-top:8px;
                }
                .sgis-gift-title { font-size:12px; font-weight:700; margin-bottom:6px; display:flex; align-items:center; gap:4px; }
                .sgis-gift-scheme { font-size:14px; font-weight:700; color:#66c0f4; margin:4px 0; }
                .sgis-gift-save { font-size:20px; font-weight:800; color:#4bb54f; }
                .sgis-gift-pct { font-size:11px; color:#4bb54f; font-weight:600; }
                .sgis-gift-prices { display:flex; gap:12px; margin:6px 0; font-size:10px; }
                .sgis-gift-price-item { display:flex; flex-direction:column; }
                .sgis-gift-price-label { color:var(--sgis-text-2); }
                .sgis-gift-price-val { font-weight:600; }
                .sgis-gift-warn { font-size:9px; color:#e6a839; margin-top:6px; padding:4px 6px; background:rgba(230,168,57,0.08); border-radius:4px; }
                .sgis-gift-rule { font-size:9px; color:var(--sgis-text-2); margin-top:4px; }
                .sgis-gift-alt { font-size:10px; color:var(--sgis-text-2); margin-top:6px; padding-top:6px; border-top:1px dashed rgba(255,255,255,0.06); }

                /* === v2.9.9: SVG 价格走势图 === */
                .sgis-price-chart-wrap { margin-top:8px; border-radius:8px; background:rgba(255,255,255,0.02); padding:8px 6px 4px; border:1px solid rgba(255,255,255,0.05); }
                .sgis-price-chart-header { display:flex; align-items:center; justify-content:space-between; margin-bottom:4px; }
                .sgis-price-chart-title { font-size:10px; color:var(--sgis-text-2); font-weight:500; }
                .sgis-chart-range-group { display:flex; gap:2px; }
                .sgis-chart-range-btn {
                    font-size:9px; padding:1px 6px; border-radius:8px; border:1px solid rgba(255,255,255,0.08);
                    background:transparent; color:var(--sgis-text-2); cursor:pointer; transition:all 0.15s;
                }
                .sgis-chart-range-btn:hover { background:rgba(255,255,255,0.06); }
                .sgis-chart-range-btn.active { background:rgba(102,192,244,0.2); color:#66c0f4; border-color:rgba(102,192,244,0.4); }

                /* === v2.9.9: DRM 警告徽章 === */
                .sgis-drm-badge {
                    display:inline-flex; align-items:center; gap:3px; font-size:10px; font-weight:600;
                    padding:2px 8px; border-radius:4px; background:rgba(239,68,68,0.15);
                    color:#f87171; border:1px solid rgba(239,68,68,0.25);
                }
                .sgis-drm-badge.warn { background:rgba(245,158,11,0.15); color:#fbbf24; border-color:rgba(245,158,11,0.25); }

                /* === v2.9.9: 中文语音标记 === */
                .sgis-audio-badge {
                    display:inline-flex; align-items:center; gap:3px; font-size:10px; font-weight:600;
                    padding:2px 8px; border-radius:4px; background:rgba(75,181,79,0.15);
                    color:#4bb54f; border:1px solid rgba(75,181,79,0.25);
                }

                /* === v2.9.93: 资料受限/Steam正在了解 状态徽章 (参考 steam-restricted-game-realtime-userscript) === */
                .sgis-profile-badge {
                    display:inline-flex; align-items:center; gap:3px; font-size:10px; font-weight:600;
                    padding:2px 8px; border-radius:4px; border:1px solid rgba(255,255,255,0.12);
                    background:rgba(255,255,255,0.06); color:var(--sgis-text);
                }
                .sgis-profile-badge svg { width:12px; height:12px; flex-shrink:0; }
                .sgis-profile-badge.restricted { background:rgba(239,68,68,0.15); color:#f87171; border-color:rgba(239,68,68,0.25); }
                .sgis-profile-badge.learning { background:rgba(245,158,11,0.15); color:#fbbf24; border-color:rgba(245,158,11,0.25); }
                .sgis-profile-badge.normal { background:rgba(34,197,94,0.12); color:#22c55e; border-color:rgba(34,197,94,0.2); }
                .sgis-profile-badge.loading { background:rgba(255,255,255,0.04); color:var(--sgis-text-2); border-color:rgba(255,255,255,0.08); }

                /* === v2.9.11: gamestatus.info 破解状态徽章 === */
                .sgis-crack-badge {
                    display:inline-flex; align-items:center; gap:3px; font-size:10px; font-weight:600;
                    padding:2px 8px; border-radius:4px; border:1px solid rgba(255,255,255,0.12);
                    background:rgba(255,255,255,0.06); color:var(--sgis-text);
                }
                .sgis-crack-badge svg { width:12px; height:12px; flex-shrink:0; }
                .sgis-crack-badge.cracked { background:rgba(34,197,94,0.15); color:#22c55e; border-color:rgba(34,197,94,0.25); }
                .sgis-crack-badge.not-cracked { background:rgba(239,68,68,0.15); color:#f87171; border-color:rgba(239,68,68,0.25); }
                .sgis-crack-badge.bypass { background:rgba(245,158,11,0.15); color:#fbbf24; border-color:rgba(245,158,11,0.25); }
                .sgis-crack-badge.release-today { background:rgba(59,130,246,0.15); color:#60a5fa; border-color:rgba(59,130,246,0.25); }
                .sgis-crack-badge.aaa { background:rgba(168,85,247,0.15); color:#c084fc; border-color:rgba(168,85,247,0.25); }
                .sgis-crack-protection {
                    display:inline-flex; align-items:center; font-size:9px; font-weight:500;
                    padding:1px 6px; border-radius:3px; background:rgba(255,255,255,0.05);
                    color:var(--sgis-text-2); border:1px solid rgba(255,255,255,0.08);
                }
                .sgis-crack-group {
                    display:inline-flex; align-items:center; font-size:9px; font-weight:500;
                    padding:1px 6px; border-radius:3px; background:rgba(20,184,166,0.12);
                    color:#2dd4bf; border:1px solid rgba(20,184,166,0.2);
                }
                .sgis-crack-date { font-size:9px; color:var(--sgis-text-2); }
                .sgis-crack-score {
                    display:inline-flex; align-items:center; gap:2px; font-size:9px; font-weight:600;
                    padding:1px 6px; border-radius:3px; background:rgba(250,204,21,0.12);
                    color:#facc15; border:1px solid rgba(250,204,21,0.2);
                }
                .sgis-crack-score svg { width:10px; height:10px; }
                .sgis-crack-hardware {
                    margin-top:6px; padding:6px 8px; border-radius:6px;
                    background:rgba(255,255,255,0.03); border:1px solid rgba(255,255,255,0.06);
                }
                .sgis-crack-hardware-title { font-size:10px; font-weight:600; color:var(--sgis-text-2); margin-bottom:4px; }
                .sgis-crack-hw-row { display:flex; gap:6px; font-size:10px; line-height:1.5; }
                .sgis-crack-hw-key { color:var(--sgis-text-2); min-width:32px; font-weight:500; }
                .sgis-crack-hw-val { color:var(--sgis-text); flex:1; word-break:break-word; }

                /* === v2.9.15: 评测搜索（flex 布局，按钮不再溢出） === */
                .sgis-review-search-wrap { display:flex; align-items:center; gap:6px; margin-bottom:6px; }
                .sgis-review-search-input {
                    flex:1; min-width:0; width:auto; box-sizing:border-box;
                    font-size:11px; padding:5px 9px; border-radius:6px;
                    border:1px solid rgba(255,255,255,0.1); background:rgba(255,255,255,0.03);
                    color:var(--sgis-text); transition:border-color 0.15s;
                }
                .sgis-review-search-input:focus { outline:none; border-color:rgba(102,192,244,0.4); }
                .sgis-review-search-input::placeholder { color:var(--sgis-text-2); font-size:10px; }
                .sgis-review-regex-toggle {
                    flex-shrink:0; font-size:10px; padding:4px 8px; border-radius:6px;
                    border:1px solid rgba(255,255,255,0.1); background:rgba(255,255,255,0.03);
                    color:var(--sgis-text-2); cursor:pointer; transition:all 0.15s;
                    font-family:monospace; font-weight:600; letter-spacing:0.5px;
                }
                .sgis-review-regex-toggle:hover { background:rgba(167,139,250,0.1); border-color:rgba(167,139,250,0.3); }
                .sgis-review-regex-toggle.active { background:rgba(167,139,250,0.2); color:#a78bfa; border-color:rgba(167,139,250,0.4); box-shadow:0 0 0 1px rgba(167,139,250,0.2); }
                .sgis-review-search-clear {
                    flex-shrink:0; width:22px; height:22px; padding:0; border-radius:50%;
                    border:1px solid rgba(255,255,255,0.1); background:rgba(255,255,255,0.03);
                    color:var(--sgis-text-2); cursor:pointer; transition:all 0.15s;
                    display:flex; align-items:center; justify-content:center; font-size:13px; line-height:1;
                }
                .sgis-review-search-clear:hover { background:rgba(230,57,70,0.15); color:#e63946; border-color:rgba(230,57,70,0.4); }`;

    const CSS_LOAD =`                /* === 加载容器（替代裸 spinner，给用户结构感） === */
                .sgis-load-block { display:flex; flex-direction:column; align-items:stretch; justify-content:flex-start; padding:18px 16px 14px; gap:10px; }
                .sgis-load-head { display:flex; align-items:center; gap:8px; font-size:12px; color:var(--sgis-text); }
                .sgis-load-head .sgis-spinner { width:18px; height:18px; margin:0; flex-shrink:0; }
                .sgis-load-stage { flex:1; font-weight:600; letter-spacing:0.2px; }
                .sgis-load-pct { font-size:11px; color:var(--sgis-text-2); font-variant-numeric:tabular-nums; flex-shrink:0; }

                /* === 主进度条（带渐变 + 流光） === */
                .sgis-load-bar { position:relative; height:6px; background:rgba(255,255,255,0.05); border-radius:3px; overflow:hidden; box-shadow:inset 0 1px 2px rgba(0,0,0,0.3); }
                .sgis-load-bar-fill { position:absolute; left:0; top:0; bottom:0; width:0%; border-radius:3px; background:linear-gradient(90deg,#06b6d4,#3b82f6,#8b5cf6); transition:width 0.35s cubic-bezier(0.4,0,0.2,1); box-shadow:0 0 10px rgba(59,130,246,0.5); }
                .sgis-load-bar-fill::after { content:""; position:absolute; inset:0; background:linear-gradient(90deg,transparent,rgba(255,255,255,0.45),transparent); animation:sgis-load-shimmer 1.4s linear infinite; }
                @keyframes sgis-load-shimmer { 0%{transform:translateX(-100%)} 100%{transform:translateX(100%)} }

                /* === 阶段指示条（4 段小条，阶段切换时高亮） === */
                .sgis-load-stages { display:flex; gap:3px; }
                .sgis-load-stage-bar { flex:1; height:3px; border-radius:2px; background:rgba(255,255,255,0.06); transition:all 0.3s; }
                .sgis-load-stage-bar.active { background:linear-gradient(90deg,#06b6d4,#3b82f6); box-shadow:0 0 6px rgba(59,130,246,0.6); }
                .sgis-load-stage-bar.done { background:rgba(16,185,129,0.55); }

                /* === 骨架屏：与真实游戏行 1:1 布局，避免加载完成后跳变 === */
                .sgis-skel-list { display:flex; flex-direction:column; gap:6px; margin-top:4px; }
                .sgis-skel-row { display:flex; align-items:center; gap:10px; padding:8px 10px; background:rgba(255,255,255,0.02); border:1px solid rgba(255,255,255,0.04); border-radius:8px; }
                .sgis-skel-icon { width:32px; height:32px; border-radius:4px; flex-shrink:0; background:linear-gradient(90deg,rgba(139,92,246,0.08),rgba(139,92,246,0.18),rgba(139,92,246,0.08)); background-size:200% 100%; animation:sgis-skel-shimmer 1.4s linear infinite; }
                .sgis-skel-lines { flex:1; min-width:0; display:flex; flex-direction:column; gap:6px; }
                .sgis-skel-line { height:8px; border-radius:3px; background:linear-gradient(90deg,rgba(255,255,255,0.04),rgba(255,255,255,0.10),rgba(255,255,255,0.04)); background-size:200% 100%; animation:sgis-skel-shimmer 1.4s linear infinite; }
                .sgis-skel-line.l1 { width:55%; }
                .sgis-skel-line.l2 { width:30%; height:7px; opacity:0.6; }
                .sgis-skel-row:nth-child(odd) .sgis-skel-icon, .sgis-skel-row:nth-child(odd) .sgis-skel-line { animation-delay:0s; }
                .sgis-skel-row:nth-child(even) .sgis-skel-icon, .sgis-skel-row:nth-child(even) .sgis-skel-line { animation-delay:0.2s; }
                .sgis-skel-row:nth-child(3n) .sgis-skel-icon, .sgis-skel-row:nth-child(3n) .sgis-skel-line { animation-delay:0.4s; }
                @keyframes sgis-skel-shimmer { 0%{background-position:200% 0} 100%{background-position:-200% 0} }

                /* === 加载中已完成计数（用户能看到 "已处理 X / 约 Y" 真实进度） === */
                .sgis-load-counter { font-size:10px; color:var(--sgis-text-2); text-align:center; font-variant-numeric:tabular-nums; margin-top:2px; }`;

    // v2.11.40: 主题层——原 CSS_SGIS_OVERRIDE（无条件注入的紫色全局覆盖）重构为典雅紫主题层,
    // 由 applySglvTheme() 按用户主题动态注入,不再进入 CSS_INLINE。内容保持不变(默认主题零视觉回归)。
    const CSS_THEME_PURPLE =`    /* ====== 1. 全局 CSS 变量覆盖 → 紫色主调 ====== */
    :root {
        --sglv-accent: #a78bfa !important;
        --sglv-accent-light: #c4b5fd !important;
        --sglv-accent-deep: #8b5cf6 !important;
        --sglv-accent-glow: rgba(139, 92, 246, 0.4) !important;
        --sglv-accent-bg: rgba(139, 92, 246, 0.12) !important;
        --sglv-accent-border: rgba(139, 92, 246, 0.3) !important;
    }

    /* ====== 2. 面板头部 → 紫色调 ====== */
    .sglv-panel > .sglv-header {
        background: linear-gradient(135deg, rgba(27, 40, 56, 0.95) 0%, rgba(42, 71, 94, 0.95) 100%) !important;
        border-bottom: 1px solid rgba(139, 92, 246, 0.2) !important;
    }
    .sglv-header-brand {
        background: linear-gradient(135deg, rgba(139, 92, 246, 0.18), rgba(99, 102, 241, 0.12)) !important;
        border: 1px solid rgba(139, 92, 246, 0.25) !important;
        color: #a78bfa !important;
    }
    .sglv-header-brand:hover {
        box-shadow: 0 2px 8px rgba(139, 92, 246, 0.35), inset 0 1px 0 rgba(255, 255, 255, 0.1) !important;
    }

    /* ====== 3. Tab 激活态 → 紫色 ====== */
    .sglv-panel .sglv-tab.active {
        color: #fff !important;
        background: rgba(139, 92, 246, 0.18) !important;
        border-color: rgba(139, 92, 246, 0.4) !important;
        box-shadow: 0 0 0 1px rgba(139, 92, 246, 0.15) inset, 0 1px 4px rgba(139, 92, 246, 0.2) !important;
    }
    .sglv-panel .sglv-tab:hover {
        background: rgba(139, 92, 246, 0.08) !important;
    }

    /* ====== 4. 全局搜索框聚焦 → 紫色 ====== */
    .sglv-panel .sglv-global-search:focus-within {
        border-color: rgba(139, 92, 246, 0.55) !important;
        box-shadow: 0 0 0 1px rgba(139, 92, 246, 0.25) !important;
    }

    /* ====== 5. KPI 卡片 — 恢复紫色变体 ====== */
    /* amber 变体保持金色（原版设计） */
    .sglv-playtime-kpi-card.amber {
        border-color: rgba(245, 158, 11, 0.35) !important;
    }
    .sglv-playtime-kpi-card.amber::before { background: #f59e0b !important; }
    .sglv-playtime-kpi-card.amber .sglv-playtime-kpi-value { color: #fbbf24 !important; }
    .sglv-playtime-kpi-card.amber .sglv-playtime-kpi-icon {
        background: rgba(245, 158, 11, 0.15) !important;
        color: #fbbf24 !important;
    }
    /* purple 变体 → 恢复紫色 */
    .sglv-playtime-kpi-card.purple {
        border-color: rgba(139, 92, 246, 0.35) !important;
    }
    .sglv-playtime-kpi-card.purple::before { background: #8b5cf6 !important; }
    .sglv-playtime-kpi-card.purple .sglv-playtime-kpi-value { color: #c4b5fd !important; }
    .sglv-playtime-kpi-card.purple .sglv-playtime-kpi-icon {
        background: rgba(139, 92, 246, 0.15) !important;
        color: #c4b5fd !important;
    }
    /* blue/cyan/green/rose 语义色保持不变 */

    /* ====== 6. 统计仪表 — 区块标题 → 紫色 ====== */
    .sglv-playtime-section-title {
        color: #a78bfa !important;
        border-bottom: 1px solid rgba(139, 92, 246, 0.12) !important;
    }
    .sglv-playtime-section-title svg {
        color: #a78bfa !important;
    }

    /* ====== 7. 趋势筛选按钮 → 紫色激活 ====== */
    .sglv-trend-btn.active {
        background: rgba(139, 92, 246, 0.18) !important;
        color: #c4b5fd !important;
        border-color: rgba(139, 92, 246, 0.3) !important;
    }
    .sglv-trend-btn:hover {
        background: rgba(139, 92, 246, 0.1) !important;
    }

    /* ====== 8. 进度条 → 青蓝紫渐变 ====== */
    #sglv-stage-progress .sglv-stage-progress-fill {
        background: linear-gradient(90deg, #06b6d4 0%, #3b82f6 50%, #8b5cf6 100%) !important;
    }
    #sglv-stage-progress {
        background: linear-gradient(180deg, rgba(139, 92, 246, 0.06), transparent) !important;
        border-bottom: 1px solid rgba(139, 92, 246, 0.12) !important;
    }

    /* ====== 9. 仪表盘 — 新增雷达图区块 ====== */
    .sglv-radar-row {
        display: grid;
        grid-template-columns: 280px 1fr;
        gap: 10px;
        flex: 0 0 auto;
        min-height: 0;
    }
    @media (max-width: 900px) {
        .sglv-radar-row { grid-template-columns: 1fr; }
    }
    .sglv-radar-card {
        background: linear-gradient(135deg, rgba(34, 211, 238, 0.05), rgba(139, 92, 246, 0.04), rgba(244, 114, 182, 0.04), rgba(13, 17, 23, 0.4));
        border: 1px solid rgba(139, 92, 246, 0.12);
        border-radius: 10px;
        padding: 12px;
        display: flex;
        flex-direction: column;
        align-items: center;
        gap: 8px;
    }
    .sglv-radar-card-title {
        font-size: 12px;
        font-weight: 700;
        background: linear-gradient(90deg, #22d3ee, #34d399, #a78bfa, #f472b6, #f59e0b);
        -webkit-background-clip: text;
        background-clip: text;
        -webkit-text-fill-color: transparent;
        display: flex;
        align-items: center;
        gap: 6px;
        align-self: flex-start;
    }
    .sglv-radar-card-title svg { width: 14px; height: 14px; color: #a78bfa; }
    .sglv-radar-svg { width: 220px; height: 220px; }
    .sglv-radar-svg .radar-grid { fill: none; stroke: rgba(255, 255, 255, 0.08); stroke-width: 1; }
    .sglv-radar-svg .radar-axis { stroke-width: 1; }
    .sglv-radar-svg .radar-area { stroke-width: 2; stroke-linejoin: round; transition: all 0.6s cubic-bezier(0.4, 0, 0.2, 1); }
    .sglv-radar-svg .radar-point { stroke: #0d1117; stroke-width: 2; transition: all 0.6s cubic-bezier(0.4, 0, 0.2, 1); }
    .sglv-radar-svg .radar-label { font-size: 10px; font-weight: 700; text-anchor: middle; }
    .sglv-radar-svg .radar-value { font-size: 11px; font-weight: 800; text-anchor: middle; }

    /* 雷达图右侧统计面板 */
    .sglv-radar-stats {
        display: flex;
        flex-direction: column;
        gap: 6px;
        padding: 12px;
        background: rgba(13, 17, 23, 0.4);
        border: 1px solid rgba(255, 255, 255, 0.05);
        border-radius: 10px;
    }
    .sglv-radar-stat-item {
        display: flex;
        align-items: center;
        gap: 8px;
        padding: 6px 8px;
        border-radius: 8px;
        background: rgba(255, 255, 255, 0.02);
        border: 1px solid rgba(255, 255, 255, 0.04);
        transition: background 0.15s;
    }
    .sglv-radar-stat-item:hover { background: rgba(255, 255, 255, 0.05); }
    .sglv-radar-stat-icon {
        width: 28px; height: 28px; border-radius: 8px; flex-shrink: 0;
        display: flex; align-items: center; justify-content: center;
    }
    .sglv-radar-stat-icon svg { width: 14px; height: 14px; }
    .sglv-radar-stat-info { flex: 1; min-width: 0; }
    .sglv-radar-stat-label { font-size: 10px; color: #8b949e; font-weight: 600; }
    .sglv-radar-stat-bar {
        height: 4px; background: rgba(255, 255, 255, 0.06); border-radius: 2px;
        overflow: hidden; margin-top: 3px;
    }
    .sglv-radar-stat-bar-fill {
        height: 100%; border-radius: 2px;
        transition: width 0.6s cubic-bezier(0.4, 0, 0.2, 1);
    }
    .sglv-radar-stat-val {
        font-size: 14px; font-weight: 700;
        font-variant-numeric: tabular-nums; flex-shrink: 0;
    }

    /* ====== 10. 仪表盘 KPI 行增强 — hover 微光 ====== */
    .sglv-playtime-kpi-card {
        position: relative;
        transition: transform 0.15s, box-shadow 0.15s, border-color 0.15s;
    }
    .sglv-playtime-kpi-card:hover {
        transform: translateY(-1px);
        box-shadow: 0 3px 10px rgba(0, 0, 0, 0.2);
    }
    .sglv-playtime-kpi-card.amber:hover {
        box-shadow: 0 3px 10px rgba(245, 158, 11, 0.15);
    }

    /* ====== 11. 仪表盘 KPI 行 — 7 列 grid (含雷达图入口) ====== */
    .sglv-stats-dashboard {
        display: grid !important;
        grid-template-columns: repeat(7, 1fr) !important;
        gap: 6px !important;
    }

    /* ====== 12. 甜甜圈图中心文字 → 紫色 ====== */
    .sglv-pt-donut-center-val { fill: #a78bfa !important; }
    .sglv-pt-donut-center-label { fill: #8b949e !important; }

    /* ====== 13. 热力图标题 → 紫色 ====== */
    .sglv-heatmap-section .sglv-playtime-section-title { color: #a78bfa !important; }
    .sglv-hm-mini-title { color: #a78bfa !important; }

    /* ====== 14. 成就页 — 环形进度图背景 → 紫色 ====== */
    .sglv-ach-ring-bg { stroke: rgba(139, 92, 246, 0.1) !important; }
    /* 注意: gradient 定义在 SVG defs 中，需在 JS 中修改 stop colors */

    /* ====== 15. 成就页 — 侧边栏用户卡片紫色调 ====== */
    .sglv-ach-user-card {
        background: linear-gradient(160deg, rgba(139, 92, 246, 0.1), rgba(99, 102, 241, 0.04)) !important;
    }
    .sglv-ach-user-card::after {
        background: radial-gradient(circle, rgba(139, 92, 246, 0.12), transparent 60%) !important;
    }
    .sglv-ach-user-avatar {
        background: linear-gradient(135deg, #8b5cf6, #6366f1) !important;
        box-shadow: 0 8px 24px rgba(139, 92, 246, 0.35) !important;
    }
    .sglv-ach-user-level {
        border: 2px solid #a78bfa !important;
        color: #c4b5fd !important;
    }
    .sglv-ach-user-pts strong { color: #c4b5fd !important; }

    /* ====== 16. 成就页 — 分类导航紫色激活 ====== */
    .sglv-ach-nav-item:hover { background: rgba(139, 92, 246, 0.08) !important; }
    .sglv-ach-nav-item.active {
        background: linear-gradient(90deg, rgba(139, 92, 246, 0.2), transparent) !important;
    }
    .sglv-ach-nav-item-icon { background: rgba(139, 92, 246, 0.12) !important; }
    .sglv-ach-nav-item.active .sglv-ach-nav-item-icon {
        background: rgba(139, 92, 246, 0.2) !important;
    }
    .sglv-ach-nav-item-badge {
        background: rgba(139, 92, 246, 0.15) !important;
        color: #c4b5fd !important;
    }
    .sglv-ach-nav-item.active .sglv-ach-nav-item-badge {
        background: #8b5cf6 !important;
        color: #0d1117 !important;
    }

    /* ====== 17. 成就页 — 侧边栏最近解锁紫色调 ====== */
    .sglv-ach-sidebar-recent-icon {
        background: linear-gradient(135deg, #8b5cf6, #6366f1) !important;
    }
    .sglv-ach-sidebar-recent-item:hover { background: rgba(139, 92, 246, 0.06) !important; }
    .sglv-ach-sidebar-recent-name { color: #e2e8f0 !important; }

    /* ====== 18. 成就页 — 统计概览区紫色调 ====== */
    .sglv-ach-header {
        background: linear-gradient(135deg, rgba(30, 41, 59, 0.6), rgba(15, 23, 42, 0.6)) !important;
        border-bottom: 1px solid rgba(139, 92, 246, 0.12) !important;
        gap: 14px !important;
        padding: 16px 20px !important;
    }
    /* v2.9.99: 环形进度数值使用炫彩渐变，不强制紫色 */

    /* ====== 19. 成就页 — 成就卡片紫色调 ====== */
    .sglv-ach-card {
        background: linear-gradient(135deg, rgba(13, 17, 23, 0.6), rgba(30, 41, 59, 0.4)) !important;
        border: 1px solid rgba(139, 92, 246, 0.08) !important;
    }
    .sglv-ach-card:hover {
        border-color: rgba(139, 92, 246, 0.3) !important;
        box-shadow: 0 8px 24px rgba(0, 0, 0, 0.3) !important;
    }
    .sglv-ach-card.unlocked {
        background: linear-gradient(135deg, rgba(139, 92, 246, 0.05), rgba(13, 17, 23, 0.4)) !important;
        border-color: rgba(139, 92, 246, 0.15) !important;
    }
    .sglv-ach-card.unlocked .sglv-ach-card-name { color: #c4b5fd !important; }
    .sglv-ach-card.unlocked .sglv-ach-card-pts {
        background: linear-gradient(135deg, rgba(139, 92, 246, 0.15), rgba(99, 102, 241, 0.1)) !important;
        border-color: rgba(139, 92, 246, 0.3) !important;
        color: #c4b5fd !important;
    }
    .sglv-ach-card.unlocked .sglv-ach-card-progress-fill {
        background: linear-gradient(90deg, #22d3ee, #34d399, #fbbf24) !important;
        box-shadow: 0 0 8px rgba(34, 211, 238, 0.4) !important;
    }
    .sglv-ach-card.locked .sglv-ach-card-progress-fill {
        background: linear-gradient(90deg, #38bdf8, #a78bfa, #f59e0b) !important;
        box-shadow: 0 0 8px rgba(56, 189, 248, 0.25) !important;
    }
    .sglv-ach-card-icon {
        background: linear-gradient(135deg, rgba(139, 92, 246, 0.15), rgba(99, 102, 241, 0.08)) !important;
    }
    /* 稀有度色保持不变(legendary 已是金色, common/rare/epic 语义色保留) */
    .sglv-ach-card.unlocked .sglv-ach-card-icon {
        box-shadow: inset 0 1px 0 rgba(255,255,255,0.15), inset 0 -1px 0 rgba(0,0,0,0.2), 0 4px 12px rgba(139, 92, 246, 0.2) !important;
    }

    /* ====== 20. 成就页 — 内容标题紫色调 ====== */
    .sglv-ach-content-title { color: #a78bfa !important; }
    .sglv-ach-content-count {
        background: rgba(139, 92, 246, 0.1) !important;
        color: #c4b5fd !important;
    }
    .sglv-ach-reset-btn {
        border: 1px solid rgba(239, 68, 68, 0.3) !important;
        background: rgba(239, 68, 68, 0.08) !important;
    }

    /* ====== 21. 个人展柜 — 英雄区紫青色调（恢复原版色彩平衡） ====== */
    .sglv-sc-hero {
        background: linear-gradient(135deg, rgba(99,102,241,0.10) 0%, rgba(168,85,247,0.06) 50%, rgba(6,182,212,0.04) 100%) !important;
        border: 1px solid rgba(99,102,241,0.15) !important;
    }
    .sglv-sc-hero::before {
        background: radial-gradient(ellipse at top right, rgba(168,85,247,0.10), transparent 60%) !important;
    }
    .sglv-sc-avatar {
        border: 2px solid rgba(255, 255, 255, 0.12) !important;
        box-shadow: 0 1px 8px rgba(0, 0, 0, 0.35), 0 0 0 1px rgba(168, 85, 247, 0.25) !important;
    }
    .sglv-sc-avatar-placeholder {
        background: linear-gradient(135deg, #6366f1, #8b5cf6) !important;
    }
    /* 用户名保持白色，不加金色 */
    .sglv-sc-hero-name { color: #f1f5f9 !important; }
    /* 国家标签保持中性灰 */
    .sglv-sc-hero-country {
        background: rgba(148, 163, 184, 0.08) !important;
        color: #94a3b8 !important;
        border: 1px solid rgba(148, 163, 184, 0.1) !important;
    }
    /* Hero 统计图标 → 恢复靛蓝色 */
    .sglv-sc-hero-stat svg { color: #818cf8 !important; }
    /* Hero 统计数值 → 恢复浅色 */
    .sglv-sc-hero-stat-val { color: #e2e8f0 !important; }

    /* ====== 22. 展柜卡片标题 → 恢复紫色 ====== */
    .sglv-sc-card-header svg { color: #a78bfa !important; }
    .sglv-sc-card-title { color: #e6edf3 !important; }

    /* ====== 23. 展柜封面网格 → 恢复紫色 hover ====== */
    .sglv-sc-cover-item {
        border: 1px solid rgba(255, 255, 255, 0.06) !important;
    }
    .sglv-sc-cover-item:hover {
        border-color: rgba(168, 85, 247, 0.5) !important;
        box-shadow: 0 4px 16px rgba(168, 85, 247, 0.2) !important;
    }

    /* ====== 24. 展柜最近游玩 → 恢复靛蓝紫色 ====== */
    .sglv-sc-playtime-item:hover { background: rgba(99, 102, 241, 0.06) !important; }
    .sglv-sc-playtime-bar { background: rgba(99, 102, 241, 0.1) !important; }
    .sglv-sc-playtime-bar-fill {
        background: linear-gradient(90deg, #6366f1, #a855f7) !important;
    }

    /* ====== 25. 展柜标签徽章 → 移除金色覆盖，恢复原版多彩 ====== */
    /* 原版已有: collector(紫), playtime(青), mastery(绿), diversity(橙), loyalty(粉), special(金) */

    /* ====== 27. Toast 通知 → 紫色 ====== */
    #sglv-toast.sglv-toast-success { border-left-color: #8b5cf6 !important; }
    #sglv-toast.sglv-toast-info { border-left-color: #66c0f4 !important; }

    /* ====== 28. 页码按钮 → 紫色 hover ====== */
    .sglv-page-arrow:hover:not(:disabled) {
        background: rgba(139, 92, 246, 0.15) !important;
        border-color: rgba(139, 92, 246, 0.4) !important;
    }

    /* ====== 29. 仪表盘图表行卡片容器 → 紫色微边 ====== */
    .sglv-playtime-col {
        background: rgba(13, 17, 23, 0.3);
        border: 1px solid rgba(139, 92, 246, 0.06);
        border-radius: 10px;
        padding: 10px;
    }
    .sglv-heatmap-section,
    .sglv-heatmap-mini-section {
        background: rgba(13, 17, 23, 0.3) !important;
        border: 1px solid rgba(139, 92, 246, 0.06) !important;
        border-radius: 10px !important;
    }

    /* ====== 30. SGIS 侧边栏标签 → 恢复紫色激活态 ====== */
    .sgis-tab.active .sgis-svg {
        filter: drop-shadow(0 1px 4px rgba(139, 92, 246, 0.45)) !important;
    }
    .sgis-tab.active {
        border-bottom-color: #8b5cf6 !important;
    }
    .sgis-tabs::after {
        background: linear-gradient(90deg, transparent, rgba(139, 92, 246, 0.35), transparent) !important;
    }

    /* ====== 31. SGIS 标题图标 → 恢复紫蓝渐变 ====== */
    .sgis-title-icon {
        background: linear-gradient(135deg, #8b5cf6 0%, #6366f1 50%, #3b82f6 100%) !important;
        box-shadow:
            0 4px 12px rgba(139, 92, 246, 0.4),
            inset 0 1px 0 rgba(255, 255, 255, 0.25),
            inset 0 -1px 0 rgba(0, 0, 0, 0.2) !important;
    }
    .sgis-fab {
        background: linear-gradient(135deg, #8b5cf6, #6366f1) !important;
        box-shadow: 0 4px 12px rgba(139, 92, 246, 0.4) !important;
    }

    /* ====== 32. 加载进度条 → 恢复青蓝紫渐变 ====== */
    .sgis-load-bar-fill {
        background: linear-gradient(90deg, #06b6d4, #3b82f6, #8b5cf6) !important;
        box-shadow: 0 0 10px rgba(59, 130, 246, 0.5) !important;
    }
    .sgis-load-stage-bar.active {
        background: linear-gradient(90deg, #06b6d4, #3b82f6) !important;
        box-shadow: 0 0 6px rgba(59, 130, 246, 0.6) !important;
    }
    .sgis-skel-icon {
        background: linear-gradient(90deg, rgba(139, 92, 246, 0.08), rgba(139, 92, 246, 0.18), rgba(139, 92, 246, 0.08)) !important;
        background-size: 200% 100% !important;
    }

    /* ====== 34. 云存档 KPI 卡片 → 紫色调 ====== */
    .sglv-cs-source-badge {
        background: rgba(139, 92, 246, 0.12) !important;
        color: #c4b5fd !important;
        border: 1px solid rgba(139, 92, 246, 0.2) !important;
    }
    .sglv-cs-refresh-btn:hover {
        color: #a78bfa !important;
        background: rgba(139, 92, 246, 0.12) !important;
    }
    .sglv-cs-top10-bar {
        background: linear-gradient(90deg, #6366f1, #a855f7) !important;
    }

    /* ====== 35. 集合工具栏刷新按钮 → 紫色 hover ====== */
    .sglv-col-refresh-btn:hover {
        color: #a78bfa !important;
        background: rgba(139, 92, 246, 0.1) !important;
    }

    /* ====== 36. 移动端适配 ====== */
    @media (max-width: 768px) {
        .sglv-radar-row { grid-template-columns: 1fr; }
        .sglv-radar-svg { width: 180px; height: 180px; }
    }
    @media (max-width: 480px) {
        .sglv-radar-svg { width: 160px; height: 160px; }
        .sglv-radar-card { padding: 8px; }
    }

    /* ====== 37. v2.9.97: SGIS Hero — 紫青平衡 + 紧凑布局 + 保留背景图 ====== */
    /* 主卡片：恢复紫色渐变基调，紧凑 padding 保留 */
    .sgis-profile-main-card {
        background: linear-gradient(160deg, #1a1633 0%, #16142b 40%, #0f0d20 100%) !important;
        box-shadow: 0 8px 32px rgba(0, 0, 0, 0.45), 0 0 0 1px rgba(139, 92, 246, 0.15) !important;
        padding: 14px 14px 12px !important;
        border-radius: 16px !important;
    }
    /* 右上角径向光晕 → 紫色 */
    .sgis-profile-main-card::before {
        background: radial-gradient(circle, rgba(139, 92, 246, 0.4) 0%, transparent 60%) !important;
    }
    /* 底部高光线 → 紫色 */
    .sgis-profile-main-card::after {
        background: linear-gradient(90deg, transparent 0%, rgba(139, 92, 246, 0.6) 50%, transparent 100%) !important;
    }
    /* 背景装饰图 → 恢复原始 game-library.png + 紫色滤镜 + mask */
    .sgis-profile-main-card-bg {
        background: url('https://leanisssharedstorage.blob.core.windows.net/copilot/asdm-files/game-library.png') no-repeat center center !important;
        background-size: contain !important;
        opacity: 0.18 !important;
        filter: saturate(1.2) drop-shadow(0 0 20px rgba(139, 92, 246, 0.25)) !important;
        mask-image: linear-gradient(90deg, rgba(0,0,0,0) 0%, rgba(0,0,0,1) 40%, rgba(0,0,0,1) 100%) !important;
        -webkit-mask-image: linear-gradient(90deg, rgba(0,0,0,0) 0%, rgba(0,0,0,1) 40%, rgba(0,0,0,1) 100%) !important;
    }

    /* Hero 头部行 → 紧凑（保留） */
    .sgis-profile-head {
        gap: 12px !important;
        margin-bottom: 12px !important;
    }

    /* 头像 → 64px + 青色边框（原版色调） */
    .sgis-profile-avatar {
        width: 64px !important;
        height: 64px !important;
        border-radius: 18px !important;
        border: 2px solid rgba(102, 192, 244, 0.5) !important;
        box-shadow: 0 6px 20px rgba(0, 0, 0, 0.4), 0 0 0 3px rgba(102, 192, 244, 0.08) !important;
    }

    /* 在线状态徽章 → 恢复紫蓝渐变 */
    .sgis-profile-avatar-badge {
        background: linear-gradient(135deg, #8b5cf6 0%, #6366f1 50%, #3b82f6 100%) !important;
        box-shadow: 0 4px 12px rgba(139, 92, 246, 0.5), 0 0 0 2px #16142b !important;
    }

    /* 等级徽章 → 保持金色（原版即为金色，作为 premium accent） */
    .sgis-profile-level-badge {
        background: linear-gradient(135deg, #f59e0b 0%, #f97316 100%) !important;
        box-shadow: 0 2px 6px rgba(249, 115, 22, 0.4) !important;
    }

    /* 用户名 → 白色，不加金色 text-shadow */
    .sgis-profile-name {
        text-shadow: none !important;
    }

    /* SteamID → 恢复灰蓝色 */
    .sgis-profile-steamid {
        color: rgba(148, 163, 184, 0.9) !important;
    }

    /* 验证徽章 → 恢复紫蓝渐变 */
    .sgis-profile-verified {
        background: linear-gradient(135deg, #8b5cf6, #3b82f6) !important;
        box-shadow: 0 2px 6px rgba(139, 92, 246, 0.4) !important;
    }

    /* 好友数进度环 → 恢复绿色 */
    .sgis-friend-gauge-text b { color: #10b981 !important; }
    .sgis-friend-gauge:hover { background: rgba(255, 255, 255, 0.05) !important; }

    /* ====== 38. SGIS KPI 统计卡片 — 恢复多彩语义色 ====== */
    /* 默认状态：恢复中性背景，移除大面积金色 */
    .sgis-profile-stat {
        background: linear-gradient(160deg, rgba(255, 255, 255, 0.04) 0%, rgba(255, 255, 255, 0.01) 100%) !important;
        border: 1px solid rgba(255, 255, 255, 0.06) !important;
        border-radius: 12px !important;
        transition: all 0.2s ease !important;
    }
    /* 顶部高光线 → 恢复 currentColor 语义色 */
    .sgis-profile-stat::after {
        opacity: 0.35 !important;
    }
    /* hover → 紫色光晕 + 上浮 */
    .sgis-profile-stat:hover {
        border-color: rgba(139, 92, 246, 0.3) !important;
        background: linear-gradient(160deg, rgba(139, 92, 246, 0.08) 0%, rgba(59, 130, 246, 0.03) 100%) !important;
        box-shadow: 0 6px 16px rgba(0, 0, 0, 0.3) !important;
        transform: translateY(-2px) !important;
    }
    /* 默认图标背景 → 恢复紫蓝渐变 */
    .sgis-profile-stat-icon {
        background: linear-gradient(135deg, rgba(139, 92, 246, 0.2), rgba(59, 130, 246, 0.08)) !important;
        box-shadow: inset 0 0 0 1px rgba(255, 255, 255, 0.04) !important;
    }
    .sgis-profile-stat-icon svg { color: #c4b5fd !important; }

    /* t-blue / t-purple / t-cyan / t-green / t-rose → 全部恢复原版语义色 */
    .sgis-profile-stat-icon.t-blue {
        background: linear-gradient(135deg, rgba(59, 130, 246, 0.22), rgba(37, 99, 235, 0.08)) !important;
        box-shadow: inset 0 0 0 1px rgba(255, 255, 255, 0.04) !important;
    }
    .sgis-profile-stat-icon.t-blue svg { color: #93c5fd !important; }
    .sgis-profile-stat-icon.t-purple {
        background: linear-gradient(135deg, rgba(168, 85, 247, 0.22), rgba(139, 92, 246, 0.08)) !important;
        box-shadow: inset 0 0 0 1px rgba(255, 255, 255, 0.04) !important;
    }
    .sgis-profile-stat-icon.t-purple svg { color: #c4b5fd !important; }
    .sgis-profile-stat-val.t-purple { color: #c4b5fd !important; }

    /* KPI 值文字 → 移除金色光泽 */
    .sgis-profile-stat-val { text-shadow: none !important; }

    /* 5列模式 KPI 紧凑（保留布局优化） */
    .sgis-profile-stats.cols-5 { gap: 6px !important; }
    .sgis-profile-stats.cols-5 .sgis-profile-stat {
        padding: 10px 4px 8px !important;
        border-radius: 10px !important;
    }

    /* ====== 39. SGIS 区块标题 — 恢复紫色 ====== */
    .sgis-section-title {
        color: #a78bfa !important;
        border-bottom: 1px solid rgba(139, 92, 246, 0.08) !important;
    }
    .sgis-section-title svg { color: #a78bfa !important; }

    /* ====== 40. SGIS 战绩/游戏人生 双大卡 — 恢复紫蓝色调 ====== */
    .sgis-feature-card {
        background: linear-gradient(160deg, rgba(139, 92, 246, 0.12) 0%, rgba(59, 130, 246, 0.04) 50%, rgba(15, 17, 35, 0.6) 100%) !important;
        border: 1px solid rgba(139, 92, 246, 0.2) !important;
        transition: all 0.25s ease !important;
    }
    .sgis-feature-card::before {
        background: radial-gradient(circle, rgba(139, 92, 246, 0.2) 0%, transparent 60%) !important;
    }
    .sgis-feature-card::after {
        background: linear-gradient(90deg, transparent 0%, rgba(139, 92, 246, 0.5) 50%, transparent 100%) !important;
    }
    .sgis-feature-card:hover {
        border-color: rgba(139, 92, 246, 0.4) !important;
        box-shadow: 0 8px 20px rgba(139, 92, 246, 0.2) !important;
        transform: translateY(-2px) !important;
    }
    /* alt 变体 → 恢复靛蓝色 */
    .sgis-feature-card.alt {
        background: linear-gradient(160deg, rgba(99, 102, 241, 0.12) 0%, rgba(59, 130, 246, 0.04) 50%, rgba(15, 17, 35, 0.6) 100%) !important;
        border-color: rgba(99, 102, 241, 0.2) !important;
    }
    .sgis-feature-card.alt::before {
        background: radial-gradient(circle, rgba(99, 102, 241, 0.2) 0%, transparent 60%) !important;
    }
    .sgis-feature-card.alt::after {
        background: linear-gradient(90deg, transparent 0%, rgba(99, 102, 241, 0.5) 50%, transparent 100%) !important;
    }
    /* 特征卡片图标 → 恢复紫蓝色 */
    .sgis-feature-icon {
        background: linear-gradient(135deg, rgba(139, 92, 246, 0.22), rgba(59, 130, 246, 0.12)) !important;
        box-shadow: inset 0 0 0 1px rgba(255, 255, 255, 0.04), 0 2px 6px rgba(139, 92, 246, 0.15) !important;
    }
    .sgis-feature-icon svg { color: #c4b5fd !important; }
    .sgis-feature-card.alt .sgis-feature-icon {
        background: linear-gradient(135deg, rgba(99, 102, 241, 0.22), rgba(59, 130, 246, 0.12)) !important;
        box-shadow: inset 0 0 0 1px rgba(255, 255, 255, 0.04), 0 2px 6px rgba(99, 102, 241, 0.15) !important;
    }
    .sgis-feature-card.alt .sgis-feature-icon svg { color: #a5b4fc !important; }
    /* hover 箭头 → 紫色 */
    .sgis-feature-card:hover .sgis-feature-arrow { color: #c4b5fd !important; }
    /* 特征卡片数值 → 恢复紫色 */
    .sgis-feature-stat-val.t-purple { color: #c4b5fd !important; }

    /* ====== 40b. SGIS 双大卡紧凑优化 — 3列统计行 + 压缩高度 ====== */
    .sis-feature-grid, .sgis-feature-grid { gap: 8px !important; margin-bottom: 8px !important; }
    .sgis-feature-card { padding: 10px 10px 8px !important; }
    .sgis-feature-head { gap: 8px !important; margin-bottom: 8px !important; }
    .sgis-feature-icon { width: 30px !important; height: 30px !important; border-radius: 8px !important; }
    .sgis-feature-icon svg { width: 15px !important; height: 15px !important; }
    .sgis-feature-title { font-size: 13px !important; }
    .sgis-feature-sub { font-size: 9px !important; margin-top: 1px !important; }
    .sgis-feature-arrow { width: 14px !important; height: 14px !important; }
    /* 3列统计行 — 战绩总览 */
    .sgis-feature-stats-3 { grid-template-columns: repeat(3, 1fr) !important; gap: 4px !important; }
    .sgis-feature-stats-3 .sgis-feature-stat { padding: 5px 4px !important; }
    .sgis-feature-stats-3 .sgis-feature-stat-lbl { font-size: 8px !important; margin-bottom: 1px !important; }
    .sgis-feature-stats-3 .sgis-feature-stat-val { font-size: 13px !important; }
    /* 游戏人生卡片紧凑 */
    .sgis-feature-card.alt .sgis-feature-stats { gap: 4px !important; }
    .sgis-feature-card.alt .sgis-feature-stat { padding: 5px 4px !important; }
    .sgis-feature-card.alt .sgis-feature-stat-lbl { font-size: 8px !important; margin-bottom: 1px !important; }
    .sgis-feature-card.alt .sgis-feature-stat-val { font-size: 13px !important; }
    .sgis-feature-extra { margin-top: 6px !important; padding: 5px 8px !important; font-size: 9px !important; }
    .sgis-feature-extra svg { width: 11px !important; height: 11px !important; }

    /* ====== 41. SGIS XP 卡片 — 保持金色进度条（原版设计），恢复中性背景 ====== */
    .sgis-xp-card {
        border: 1px solid rgba(255, 255, 255, 0.06) !important;
        background: linear-gradient(160deg, rgba(255, 255, 255, 0.035) 0%, rgba(15, 17, 35, 0.5) 100%) !important;
    }
    /* XP 进度条和图标保持原版金色系，不做覆盖 */
    /* XP 等级 next → 恢复紫色 */
    .sgis-xp-levels .next { color: #c4b5fd !important; }
    /* XP 累计数值 → 恢复紫色 */
    .sgis-xp-total b { color: #c4b5fd !important; }

    /* ====== 42. SGIS 社交标题 ====== */
    .sgis-section-title.sgis-social-title {
        border-bottom-color: rgba(139, 92, 246, 0.08) !important;
    }

    /* ====== 43. SGIS copy 按钮 hover ====== */
    .sgis-copy-btn:hover {
        background: rgba(255, 255, 255, 0.1) !important;
        color: #fff !important;
    }`;

    // v2.11.40: 经典蓝主题层——由 scripts/gen-sglv-theme-blue.js 生成（典雅紫层色值镜像映射
    // + 主脚本 CSS 常量/共享库中原生紫色规则的换色覆盖），请勿手改，重新运行生成器即可再生。
    const CSS_THEME_BLUE =`
    /* =====================================================================
     * v2.11.40 经典蓝主题层 —— scripts/gen-sglv-theme-blue.js 自动生成,勿手改(重跑再生)
     * Part A: 典雅紫主题层(CSS_THEME_PURPLE)色值镜像映射 —— 覆盖面板/侧边栏全部可见表面
     * Part B: 主脚本 CSS 常量原生紫色规则 → 蓝色瘦身覆盖(仅换色声明 + !important)
     * Part C: 共享样式库(sglv-shared-css)原生紫色规则 → 蓝色瘦身覆盖
     * Part D: 侧边栏手工精调(靛蓝暗基底→Steam 深蓝/标题栏柔化,自动映射盲区)
     * Part E: 收藏库(sglv-game-collection)面板 CSS 紫色覆盖(html[data-sglv-theme] 前缀,
     *         特异性压过其懒注入且带 220 处 !important 的 <style>,顺序无关)
     * 映射: #a78bfa→#66c0f4 #c4b5fd→#a3d5f7 #8b5cf6→#1a9fff #a855f7→#3b82f6
     *       #6366f1→#2563eb #818cf8→#60a5fa + 深紫背景系;语义色(金/绿/红/玫/青)保持
     * 例外: .sglv-set-theme-swatch 主题预览色板固定不随主题切换
     * ===================================================================== */
    /* ########## Part A: 紫色主题层镜像(共 663 行) ########## */
/* ====== 1. 全局 CSS 变量覆盖 → 紫色主调 ====== */
    :root {
        --sglv-accent: #66c0f4 !important;
        --sglv-accent-light: #a3d5f7 !important;
        --sglv-accent-deep: #1a9fff !important;
        --sglv-accent-glow: rgba(102, 192, 244, 0.4) !important;
        --sglv-accent-bg: rgba(102, 192, 244, 0.12) !important;
        --sglv-accent-border: rgba(102, 192, 244, 0.3) !important;
    }

    /* ====== 2. 面板头部 → 紫色调 ====== */
    .sglv-panel > .sglv-header {
        background: linear-gradient(135deg, rgba(27, 40, 56, 0.95) 0%, rgba(42, 71, 94, 0.95) 100%) !important;
        border-bottom: 1px solid rgba(26,159,255, 0.2) !important;
    }
    .sglv-header-brand {
        background: linear-gradient(135deg, rgba(26,159,255, 0.18), rgba(37,99,235, 0.12)) !important;
        border: 1px solid rgba(26,159,255, 0.25) !important;
        color: #66c0f4 !important;
    }
    .sglv-header-brand:hover {
        box-shadow: 0 2px 8px rgba(26,159,255, 0.35), inset 0 1px 0 rgba(255, 255, 255, 0.1) !important;
    }

    /* ====== 3. Tab 激活态 → 紫色 ====== */
    .sglv-panel .sglv-tab.active {
        color: #fff !important;
        background: rgba(26,159,255, 0.18) !important;
        border-color: rgba(26,159,255, 0.4) !important;
        box-shadow: 0 0 0 1px rgba(26,159,255, 0.15) inset, 0 1px 4px rgba(26,159,255, 0.2) !important;
    }
    .sglv-panel .sglv-tab:hover {
        background: rgba(26,159,255, 0.08) !important;
    }

    /* ====== 4. 全局搜索框聚焦 → 紫色 ====== */
    .sglv-panel .sglv-global-search:focus-within {
        border-color: rgba(26,159,255, 0.55) !important;
        box-shadow: 0 0 0 1px rgba(26,159,255, 0.25) !important;
    }

    /* ====== 5. KPI 卡片 — 恢复紫色变体 ====== */
    /* amber 变体保持金色（原版设计） */
    .sglv-playtime-kpi-card.amber {
        border-color: rgba(245, 158, 11, 0.35) !important;
    }
    .sglv-playtime-kpi-card.amber::before { background: #f59e0b !important; }
    .sglv-playtime-kpi-card.amber .sglv-playtime-kpi-value { color: #fbbf24 !important; }
    .sglv-playtime-kpi-card.amber .sglv-playtime-kpi-icon {
        background: rgba(245, 158, 11, 0.15) !important;
        color: #fbbf24 !important;
    }
    /* purple 变体 → 恢复紫色 */
    .sglv-playtime-kpi-card.purple {
        border-color: rgba(26,159,255, 0.35) !important;
    }
    .sglv-playtime-kpi-card.purple::before { background: #1a9fff !important; }
    .sglv-playtime-kpi-card.purple .sglv-playtime-kpi-value { color: #a3d5f7 !important; }
    .sglv-playtime-kpi-card.purple .sglv-playtime-kpi-icon {
        background: rgba(26,159,255, 0.15) !important;
        color: #a3d5f7 !important;
    }
    /* blue/cyan/green/rose 语义色保持不变 */

    /* ====== 6. 统计仪表 — 区块标题 → 紫色 ====== */
    .sglv-playtime-section-title {
        color: #66c0f4 !important;
        border-bottom: 1px solid rgba(26,159,255, 0.12) !important;
    }
    .sglv-playtime-section-title svg {
        color: #66c0f4 !important;
    }

    /* ====== 7. 趋势筛选按钮 → 紫色激活 ====== */
    .sglv-trend-btn.active {
        background: rgba(26,159,255, 0.18) !important;
        color: #a3d5f7 !important;
        border-color: rgba(26,159,255, 0.3) !important;
    }
    .sglv-trend-btn:hover {
        background: rgba(26,159,255, 0.1) !important;
    }

    /* ====== 8. 进度条 → 青蓝紫渐变 ====== */
    #sglv-stage-progress .sglv-stage-progress-fill {
        background: linear-gradient(90deg, #06b6d4 0%, #3b82f6 50%, #1a9fff 100%) !important;
    }
    #sglv-stage-progress {
        background: linear-gradient(180deg, rgba(26,159,255, 0.06), transparent) !important;
        border-bottom: 1px solid rgba(26,159,255, 0.12) !important;
    }

    /* ====== 9. 仪表盘 — 新增雷达图区块 ====== */
    .sglv-radar-row {
        display: grid;
        grid-template-columns: 280px 1fr;
        gap: 10px;
        flex: 0 0 auto;
        min-height: 0;
    }
    @media (max-width: 900px) {
        .sglv-radar-row { grid-template-columns: 1fr; }
    }
    .sglv-radar-card {
        background: linear-gradient(135deg, rgba(34, 211, 238, 0.05), rgba(26,159,255, 0.04), rgba(244, 114, 182, 0.04), rgba(13, 17, 23, 0.4));
        border: 1px solid rgba(26,159,255, 0.12);
        border-radius: 10px;
        padding: 12px;
        display: flex;
        flex-direction: column;
        align-items: center;
        gap: 8px;
    }
    .sglv-radar-card-title {
        font-size: 12px;
        font-weight: 700;
        background: linear-gradient(90deg, #22d3ee, #34d399, #66c0f4, #f472b6, #f59e0b);
        -webkit-background-clip: text;
        background-clip: text;
        -webkit-text-fill-color: transparent;
        display: flex;
        align-items: center;
        gap: 6px;
        align-self: flex-start;
    }
    .sglv-radar-card-title svg { width: 14px; height: 14px; color: #66c0f4; }
    .sglv-radar-svg { width: 220px; height: 220px; }
    .sglv-radar-svg .radar-grid { fill: none; stroke: rgba(255, 255, 255, 0.08); stroke-width: 1; }
    .sglv-radar-svg .radar-axis { stroke-width: 1; }
    .sglv-radar-svg .radar-area { stroke-width: 2; stroke-linejoin: round; transition: all 0.6s cubic-bezier(0.4, 0, 0.2, 1); }
    .sglv-radar-svg .radar-point { stroke: #0d1117; stroke-width: 2; transition: all 0.6s cubic-bezier(0.4, 0, 0.2, 1); }
    .sglv-radar-svg .radar-label { font-size: 10px; font-weight: 700; text-anchor: middle; }
    .sglv-radar-svg .radar-value { font-size: 11px; font-weight: 800; text-anchor: middle; }

    /* 雷达图右侧统计面板 */
    .sglv-radar-stats {
        display: flex;
        flex-direction: column;
        gap: 6px;
        padding: 12px;
        background: rgba(13, 17, 23, 0.4);
        border: 1px solid rgba(255, 255, 255, 0.05);
        border-radius: 10px;
    }
    .sglv-radar-stat-item {
        display: flex;
        align-items: center;
        gap: 8px;
        padding: 6px 8px;
        border-radius: 8px;
        background: rgba(255, 255, 255, 0.02);
        border: 1px solid rgba(255, 255, 255, 0.04);
        transition: background 0.15s;
    }
    .sglv-radar-stat-item:hover { background: rgba(255, 255, 255, 0.05); }
    .sglv-radar-stat-icon {
        width: 28px; height: 28px; border-radius: 8px; flex-shrink: 0;
        display: flex; align-items: center; justify-content: center;
    }
    .sglv-radar-stat-icon svg { width: 14px; height: 14px; }
    .sglv-radar-stat-info { flex: 1; min-width: 0; }
    .sglv-radar-stat-label { font-size: 10px; color: #8b949e; font-weight: 600; }
    .sglv-radar-stat-bar {
        height: 4px; background: rgba(255, 255, 255, 0.06); border-radius: 2px;
        overflow: hidden; margin-top: 3px;
    }
    .sglv-radar-stat-bar-fill {
        height: 100%; border-radius: 2px;
        transition: width 0.6s cubic-bezier(0.4, 0, 0.2, 1);
    }
    .sglv-radar-stat-val {
        font-size: 14px; font-weight: 700;
        font-variant-numeric: tabular-nums; flex-shrink: 0;
    }

    /* ====== 10. 仪表盘 KPI 行增强 — hover 微光 ====== */
    .sglv-playtime-kpi-card {
        position: relative;
        transition: transform 0.15s, box-shadow 0.15s, border-color 0.15s;
    }
    .sglv-playtime-kpi-card:hover {
        transform: translateY(-1px);
        box-shadow: 0 3px 10px rgba(0, 0, 0, 0.2);
    }
    .sglv-playtime-kpi-card.amber:hover {
        box-shadow: 0 3px 10px rgba(245, 158, 11, 0.15);
    }

    /* ====== 11. 仪表盘 KPI 行 — 7 列 grid (含雷达图入口) ====== */
    .sglv-stats-dashboard {
        display: grid !important;
        grid-template-columns: repeat(7, 1fr) !important;
        gap: 6px !important;
    }

    /* ====== 12. 甜甜圈图中心文字 → 紫色 ====== */
    .sglv-pt-donut-center-val { fill: #66c0f4 !important; }
    .sglv-pt-donut-center-label { fill: #8b949e !important; }

    /* ====== 13. 热力图标题 → 紫色 ====== */
    .sglv-heatmap-section .sglv-playtime-section-title { color: #66c0f4 !important; }
    .sglv-hm-mini-title { color: #66c0f4 !important; }

    /* ====== 14. 成就页 — 环形进度图背景 → 紫色 ====== */
    .sglv-ach-ring-bg { stroke: rgba(26,159,255, 0.1) !important; }
    /* 注意: gradient 定义在 SVG defs 中，需在 JS 中修改 stop colors */

    /* ====== 15. 成就页 — 侧边栏用户卡片紫色调 ====== */
    .sglv-ach-user-card {
        background: linear-gradient(160deg, rgba(26,159,255, 0.1), rgba(37,99,235, 0.04)) !important;
    }
    .sglv-ach-user-card::after {
        background: radial-gradient(circle, rgba(26,159,255, 0.12), transparent 60%) !important;
    }
    .sglv-ach-user-avatar {
        background: linear-gradient(135deg, #1a9fff, #2563eb) !important;
        box-shadow: 0 8px 24px rgba(26,159,255, 0.35) !important;
    }
    .sglv-ach-user-level {
        border: 2px solid #66c0f4 !important;
        color: #a3d5f7 !important;
    }
    .sglv-ach-user-pts strong { color: #a3d5f7 !important; }

    /* ====== 16. 成就页 — 分类导航紫色激活 ====== */
    .sglv-ach-nav-item:hover { background: rgba(26,159,255, 0.08) !important; }
    .sglv-ach-nav-item.active {
        background: linear-gradient(90deg, rgba(26,159,255, 0.2), transparent) !important;
    }
    .sglv-ach-nav-item-icon { background: rgba(26,159,255, 0.12) !important; }
    .sglv-ach-nav-item.active .sglv-ach-nav-item-icon {
        background: rgba(26,159,255, 0.2) !important;
    }
    .sglv-ach-nav-item-badge {
        background: rgba(26,159,255, 0.15) !important;
        color: #a3d5f7 !important;
    }
    .sglv-ach-nav-item.active .sglv-ach-nav-item-badge {
        background: #1a9fff !important;
        color: #0d1117 !important;
    }

    /* ====== 17. 成就页 — 侧边栏最近解锁紫色调 ====== */
    .sglv-ach-sidebar-recent-icon {
        background: linear-gradient(135deg, #1a9fff, #2563eb) !important;
    }
    .sglv-ach-sidebar-recent-item:hover { background: rgba(26,159,255, 0.06) !important; }
    .sglv-ach-sidebar-recent-name { color: #e2e8f0 !important; }

    /* ====== 18. 成就页 — 统计概览区紫色调 ====== */
    .sglv-ach-header {
        background: linear-gradient(135deg, rgba(30, 41, 59, 0.6), rgba(15, 23, 42, 0.6)) !important;
        border-bottom: 1px solid rgba(26,159,255, 0.12) !important;
        gap: 14px !important;
        padding: 16px 20px !important;
    }
    /* v2.9.99: 环形进度数值使用炫彩渐变，不强制紫色 */

    /* ====== 19. 成就页 — 成就卡片紫色调 ====== */
    .sglv-ach-card {
        background: linear-gradient(135deg, rgba(13, 17, 23, 0.6), rgba(30, 41, 59, 0.4)) !important;
        border: 1px solid rgba(26,159,255, 0.08) !important;
    }
    .sglv-ach-card:hover {
        border-color: rgba(26,159,255, 0.3) !important;
        box-shadow: 0 8px 24px rgba(0, 0, 0, 0.3) !important;
    }
    .sglv-ach-card.unlocked {
        background: linear-gradient(135deg, rgba(26,159,255, 0.05), rgba(13, 17, 23, 0.4)) !important;
        border-color: rgba(26,159,255, 0.15) !important;
    }
    .sglv-ach-card.unlocked .sglv-ach-card-name { color: #a3d5f7 !important; }
    .sglv-ach-card.unlocked .sglv-ach-card-pts {
        background: linear-gradient(135deg, rgba(26,159,255, 0.15), rgba(37,99,235, 0.1)) !important;
        border-color: rgba(26,159,255, 0.3) !important;
        color: #a3d5f7 !important;
    }
    .sglv-ach-card.unlocked .sglv-ach-card-progress-fill {
        background: linear-gradient(90deg, #22d3ee, #34d399, #fbbf24) !important;
        box-shadow: 0 0 8px rgba(34, 211, 238, 0.4) !important;
    }
    .sglv-ach-card.locked .sglv-ach-card-progress-fill {
        background: linear-gradient(90deg, #38bdf8, #66c0f4, #f59e0b) !important;
        box-shadow: 0 0 8px rgba(56, 189, 248, 0.25) !important;
    }
    .sglv-ach-card-icon {
        background: linear-gradient(135deg, rgba(26,159,255, 0.15), rgba(37,99,235, 0.08)) !important;
    }
    /* 稀有度色保持不变(legendary 已是金色, common/rare/epic 语义色保留) */
    .sglv-ach-card.unlocked .sglv-ach-card-icon {
        box-shadow: inset 0 1px 0 rgba(255,255,255,0.15), inset 0 -1px 0 rgba(0,0,0,0.2), 0 4px 12px rgba(26,159,255, 0.2) !important;
    }

    /* ====== 20. 成就页 — 内容标题紫色调 ====== */
    .sglv-ach-content-title { color: #66c0f4 !important; }
    .sglv-ach-content-count {
        background: rgba(26,159,255, 0.1) !important;
        color: #a3d5f7 !important;
    }
    .sglv-ach-reset-btn {
        border: 1px solid rgba(239, 68, 68, 0.3) !important;
        background: rgba(239, 68, 68, 0.08) !important;
    }

    /* ====== 21. 个人展柜 — 英雄区紫青色调（恢复原版色彩平衡） ====== */
    .sglv-sc-hero {
        background: linear-gradient(135deg, rgba(37,99,235, 0.10) 0%, rgba(59,130,246, 0.06) 50%, rgba(6,182,212,0.04) 100%) !important;
        border: 1px solid rgba(37,99,235, 0.15) !important;
    }
    .sglv-sc-hero::before {
        background: radial-gradient(ellipse at top right, rgba(59,130,246, 0.10), transparent 60%) !important;
    }
    .sglv-sc-avatar {
        border: 2px solid rgba(255, 255, 255, 0.12) !important;
        box-shadow: 0 1px 8px rgba(0, 0, 0, 0.35), 0 0 0 1px rgba(59,130,246, 0.25) !important;
    }
    .sglv-sc-avatar-placeholder {
        background: linear-gradient(135deg, #2563eb, #1a9fff) !important;
    }
    /* 用户名保持白色，不加金色 */
    .sglv-sc-hero-name { color: #f1f5f9 !important; }
    /* 国家标签保持中性灰 */
    .sglv-sc-hero-country {
        background: rgba(148, 163, 184, 0.08) !important;
        color: #94a3b8 !important;
        border: 1px solid rgba(148, 163, 184, 0.1) !important;
    }
    /* Hero 统计图标 → 恢复靛蓝色 */
    .sglv-sc-hero-stat svg { color: #60a5fa !important; }
    /* Hero 统计数值 → 恢复浅色 */
    .sglv-sc-hero-stat-val { color: #e2e8f0 !important; }

    /* ====== 22. 展柜卡片标题 → 恢复紫色 ====== */
    .sglv-sc-card-header svg { color: #66c0f4 !important; }
    .sglv-sc-card-title { color: #e6edf3 !important; }

    /* ====== 23. 展柜封面网格 → 恢复紫色 hover ====== */
    .sglv-sc-cover-item {
        border: 1px solid rgba(255, 255, 255, 0.06) !important;
    }
    .sglv-sc-cover-item:hover {
        border-color: rgba(59,130,246, 0.5) !important;
        box-shadow: 0 4px 16px rgba(59,130,246, 0.2) !important;
    }

    /* ====== 24. 展柜最近游玩 → 恢复靛蓝紫色 ====== */
    .sglv-sc-playtime-item:hover { background: rgba(37,99,235, 0.06) !important; }
    .sglv-sc-playtime-bar { background: rgba(37,99,235, 0.1) !important; }
    .sglv-sc-playtime-bar-fill {
        background: linear-gradient(90deg, #2563eb, #3b82f6) !important;
    }

    /* ====== 25. 展柜标签徽章 → 移除金色覆盖，恢复原版多彩 ====== */
    /* 原版已有: collector(紫), playtime(青), mastery(绿), diversity(橙), loyalty(粉), special(金) */

    /* ====== 27. Toast 通知 → 紫色 ====== */
    #sglv-toast.sglv-toast-success { border-left-color: #1a9fff !important; }
    #sglv-toast.sglv-toast-info { border-left-color: #66c0f4 !important; }

    /* ====== 28. 页码按钮 → 紫色 hover ====== */
    .sglv-page-arrow:hover:not(:disabled) {
        background: rgba(26,159,255, 0.15) !important;
        border-color: rgba(26,159,255, 0.4) !important;
    }

    /* ====== 29. 仪表盘图表行卡片容器 → 紫色微边 ====== */
    .sglv-playtime-col {
        background: rgba(13, 17, 23, 0.3);
        border: 1px solid rgba(26,159,255, 0.06);
        border-radius: 10px;
        padding: 10px;
    }
    .sglv-heatmap-section,
    .sglv-heatmap-mini-section {
        background: rgba(13, 17, 23, 0.3) !important;
        border: 1px solid rgba(26,159,255, 0.06) !important;
        border-radius: 10px !important;
    }

    /* ====== 30. SGIS 侧边栏标签 → 恢复紫色激活态 ====== */
    .sgis-tab.active .sgis-svg {
        filter: drop-shadow(0 1px 4px rgba(26,159,255, 0.45)) !important;
    }
    .sgis-tab.active {
        border-bottom-color: #1a9fff !important;
    }
    .sgis-tabs::after {
        background: linear-gradient(90deg, transparent, rgba(26,159,255, 0.35), transparent) !important;
    }

    /* ====== 31. SGIS 标题图标 → 恢复紫蓝渐变 ====== */
    .sgis-title-icon {
        background: linear-gradient(135deg, #1a9fff 0%, #2563eb 50%, #3b82f6 100%) !important;
        box-shadow:
            0 4px 12px rgba(26,159,255, 0.4),
            inset 0 1px 0 rgba(255, 255, 255, 0.25),
            inset 0 -1px 0 rgba(0, 0, 0, 0.2) !important;
    }
    .sgis-fab {
        background: linear-gradient(135deg, #1a9fff, #2563eb) !important;
        box-shadow: 0 4px 12px rgba(26,159,255, 0.4) !important;
    }

    /* ====== 32. 加载进度条 → 恢复青蓝紫渐变 ====== */
    .sgis-load-bar-fill {
        background: linear-gradient(90deg, #06b6d4, #3b82f6, #1a9fff) !important;
        box-shadow: 0 0 10px rgba(59, 130, 246, 0.5) !important;
    }
    .sgis-load-stage-bar.active {
        background: linear-gradient(90deg, #06b6d4, #3b82f6) !important;
        box-shadow: 0 0 6px rgba(59, 130, 246, 0.6) !important;
    }
    .sgis-skel-icon {
        background: linear-gradient(90deg, rgba(26,159,255, 0.08), rgba(26,159,255, 0.18), rgba(26,159,255, 0.08)) !important;
        background-size: 200% 100% !important;
    }

    /* ====== 34. 云存档 KPI 卡片 → 紫色调 ====== */
    .sglv-cs-source-badge {
        background: rgba(26,159,255, 0.12) !important;
        color: #a3d5f7 !important;
        border: 1px solid rgba(26,159,255, 0.2) !important;
    }
    .sglv-cs-refresh-btn:hover {
        color: #66c0f4 !important;
        background: rgba(26,159,255, 0.12) !important;
    }
    .sglv-cs-top10-bar {
        background: linear-gradient(90deg, #2563eb, #3b82f6) !important;
    }

    /* ====== 35. 集合工具栏刷新按钮 → 紫色 hover ====== */
    .sglv-col-refresh-btn:hover {
        color: #66c0f4 !important;
        background: rgba(26,159,255, 0.1) !important;
    }

    /* ====== 36. 移动端适配 ====== */
    @media (max-width: 768px) {
        .sglv-radar-row { grid-template-columns: 1fr; }
        .sglv-radar-svg { width: 180px; height: 180px; }
    }
    @media (max-width: 480px) {
        .sglv-radar-svg { width: 160px; height: 160px; }
        .sglv-radar-card { padding: 8px; }
    }

    /* ====== 37. v2.9.97: SGIS Hero — 紫青平衡 + 紧凑布局 + 保留背景图 ====== */
    /* 主卡片：恢复紫色渐变基调，紧凑 padding 保留 */
    .sgis-profile-main-card {
        background: linear-gradient(160deg, #16202d 0%, #121a25 40%, #0d131c 100%) !important;
        box-shadow: 0 8px 32px rgba(0, 0, 0, 0.45), 0 0 0 1px rgba(26,159,255, 0.15) !important;
        padding: 14px 14px 12px !important;
        border-radius: 16px !important;
    }
    /* 右上角径向光晕 → 紫色 */
    .sgis-profile-main-card::before {
        background: radial-gradient(circle, rgba(26,159,255, 0.4) 0%, transparent 60%) !important;
    }
    /* 底部高光线 → 紫色 */
    .sgis-profile-main-card::after {
        background: linear-gradient(90deg, transparent 0%, rgba(26,159,255, 0.6) 50%, transparent 100%) !important;
    }
    /* 背景装饰图 → 恢复原始 game-library.png + 紫色滤镜 + mask */
    .sgis-profile-main-card-bg {
        background: url('https://leanisssharedstorage.blob.core.windows.net/copilot/asdm-files/game-library.png') no-repeat center center !important;
        background-size: contain !important;
        opacity: 0.18 !important;
        filter: saturate(1.2) drop-shadow(0 0 20px rgba(26,159,255, 0.25)) !important;
        mask-image: linear-gradient(90deg, rgba(0,0,0,0) 0%, rgba(0,0,0,1) 40%, rgba(0,0,0,1) 100%) !important;
        -webkit-mask-image: linear-gradient(90deg, rgba(0,0,0,0) 0%, rgba(0,0,0,1) 40%, rgba(0,0,0,1) 100%) !important;
    }

    /* Hero 头部行 → 紧凑（保留） */
    .sgis-profile-head {
        gap: 12px !important;
        margin-bottom: 12px !important;
    }

    /* 头像 → 64px + 青色边框（原版色调） */
    .sgis-profile-avatar {
        width: 64px !important;
        height: 64px !important;
        border-radius: 18px !important;
        border: 2px solid rgba(102, 192, 244, 0.5) !important;
        box-shadow: 0 6px 20px rgba(0, 0, 0, 0.4), 0 0 0 3px rgba(102, 192, 244, 0.08) !important;
    }

    /* 在线状态徽章 → 恢复紫蓝渐变 */
    .sgis-profile-avatar-badge {
        background: linear-gradient(135deg, #1a9fff 0%, #2563eb 50%, #3b82f6 100%) !important;
        box-shadow: 0 4px 12px rgba(26,159,255, 0.5), 0 0 0 2px #121a25 !important;
    }

    /* 等级徽章 → 保持金色（原版即为金色，作为 premium accent） */
    .sgis-profile-level-badge {
        background: linear-gradient(135deg, #f59e0b 0%, #f97316 100%) !important;
        box-shadow: 0 2px 6px rgba(249, 115, 22, 0.4) !important;
    }

    /* 用户名 → 白色，不加金色 text-shadow */
    .sgis-profile-name {
        text-shadow: none !important;
    }

    /* SteamID → 恢复灰蓝色 */
    .sgis-profile-steamid {
        color: rgba(148, 163, 184, 0.9) !important;
    }

    /* 验证徽章 → 恢复紫蓝渐变 */
    .sgis-profile-verified {
        background: linear-gradient(135deg, #1a9fff, #3b82f6) !important;
        box-shadow: 0 2px 6px rgba(26,159,255, 0.4) !important;
    }

    /* 好友数进度环 → 恢复绿色 */
    .sgis-friend-gauge-text b { color: #10b981 !important; }
    .sgis-friend-gauge:hover { background: rgba(255, 255, 255, 0.05) !important; }

    /* ====== 38. SGIS KPI 统计卡片 — 恢复多彩语义色 ====== */
    /* 默认状态：恢复中性背景，移除大面积金色 */
    .sgis-profile-stat {
        background: linear-gradient(160deg, rgba(255, 255, 255, 0.04) 0%, rgba(255, 255, 255, 0.01) 100%) !important;
        border: 1px solid rgba(255, 255, 255, 0.06) !important;
        border-radius: 12px !important;
        transition: all 0.2s ease !important;
    }
    /* 顶部高光线 → 恢复 currentColor 语义色 */
    .sgis-profile-stat::after {
        opacity: 0.35 !important;
    }
    /* hover → 紫色光晕 + 上浮 */
    .sgis-profile-stat:hover {
        border-color: rgba(26,159,255, 0.3) !important;
        background: linear-gradient(160deg, rgba(26,159,255, 0.08) 0%, rgba(59, 130, 246, 0.03) 100%) !important;
        box-shadow: 0 6px 16px rgba(0, 0, 0, 0.3) !important;
        transform: translateY(-2px) !important;
    }
    /* 默认图标背景 → 恢复紫蓝渐变 */
    .sgis-profile-stat-icon {
        background: linear-gradient(135deg, rgba(26,159,255, 0.2), rgba(59, 130, 246, 0.08)) !important;
        box-shadow: inset 0 0 0 1px rgba(255, 255, 255, 0.04) !important;
    }
    .sgis-profile-stat-icon svg { color: #a3d5f7 !important; }

    /* t-blue / t-purple / t-cyan / t-green / t-rose → 全部恢复原版语义色 */
    .sgis-profile-stat-icon.t-blue {
        background: linear-gradient(135deg, rgba(59, 130, 246, 0.22), rgba(37, 99, 235, 0.08)) !important;
        box-shadow: inset 0 0 0 1px rgba(255, 255, 255, 0.04) !important;
    }
    .sgis-profile-stat-icon.t-blue svg { color: #93c5fd !important; }
    .sgis-profile-stat-icon.t-purple {
        background: linear-gradient(135deg, rgba(59,130,246, 0.22), rgba(26,159,255, 0.08)) !important;
        box-shadow: inset 0 0 0 1px rgba(255, 255, 255, 0.04) !important;
    }
    .sgis-profile-stat-icon.t-purple svg { color: #a3d5f7 !important; }
    .sgis-profile-stat-val.t-purple { color: #a3d5f7 !important; }

    /* KPI 值文字 → 移除金色光泽 */
    .sgis-profile-stat-val { text-shadow: none !important; }

    /* 5列模式 KPI 紧凑（保留布局优化） */
    .sgis-profile-stats.cols-5 { gap: 6px !important; }
    .sgis-profile-stats.cols-5 .sgis-profile-stat {
        padding: 10px 4px 8px !important;
        border-radius: 10px !important;
    }

    /* ====== 39. SGIS 区块标题 — 恢复紫色 ====== */
    .sgis-section-title {
        color: #66c0f4 !important;
        border-bottom: 1px solid rgba(26,159,255, 0.08) !important;
    }
    .sgis-section-title svg { color: #66c0f4 !important; }

    /* ====== 40. SGIS 战绩/游戏人生 双大卡 — 恢复紫蓝色调 ====== */
    .sgis-feature-card {
        background: linear-gradient(160deg, rgba(26,159,255, 0.12) 0%, rgba(59, 130, 246, 0.04) 50%, rgba(15, 17, 35, 0.6) 100%) !important;
        border: 1px solid rgba(26,159,255, 0.2) !important;
        transition: all 0.25s ease !important;
    }
    .sgis-feature-card::before {
        background: radial-gradient(circle, rgba(26,159,255, 0.2) 0%, transparent 60%) !important;
    }
    .sgis-feature-card::after {
        background: linear-gradient(90deg, transparent 0%, rgba(26,159,255, 0.5) 50%, transparent 100%) !important;
    }
    .sgis-feature-card:hover {
        border-color: rgba(26,159,255, 0.4) !important;
        box-shadow: 0 8px 20px rgba(26,159,255, 0.2) !important;
        transform: translateY(-2px) !important;
    }
    /* alt 变体 → 恢复靛蓝色 */
    .sgis-feature-card.alt {
        background: linear-gradient(160deg, rgba(37,99,235, 0.12) 0%, rgba(59, 130, 246, 0.04) 50%, rgba(15, 17, 35, 0.6) 100%) !important;
        border-color: rgba(37,99,235, 0.2) !important;
    }
    .sgis-feature-card.alt::before {
        background: radial-gradient(circle, rgba(37,99,235, 0.2) 0%, transparent 60%) !important;
    }
    .sgis-feature-card.alt::after {
        background: linear-gradient(90deg, transparent 0%, rgba(37,99,235, 0.5) 50%, transparent 100%) !important;
    }
    /* 特征卡片图标 → 恢复紫蓝色 */
    .sgis-feature-icon {
        background: linear-gradient(135deg, rgba(26,159,255, 0.22), rgba(59, 130, 246, 0.12)) !important;
        box-shadow: inset 0 0 0 1px rgba(255, 255, 255, 0.04), 0 2px 6px rgba(26,159,255, 0.15) !important;
    }
    .sgis-feature-icon svg { color: #a3d5f7 !important; }
    .sgis-feature-card.alt .sgis-feature-icon {
        background: linear-gradient(135deg, rgba(37,99,235, 0.22), rgba(59, 130, 246, 0.12)) !important;
        box-shadow: inset 0 0 0 1px rgba(255, 255, 255, 0.04), 0 2px 6px rgba(37,99,235, 0.15) !important;
    }
    .sgis-feature-card.alt .sgis-feature-icon svg { color: #93c5fd !important; }
    /* hover 箭头 → 紫色 */
    .sgis-feature-card:hover .sgis-feature-arrow { color: #a3d5f7 !important; }
    /* 特征卡片数值 → 恢复紫色 */
    .sgis-feature-stat-val.t-purple { color: #a3d5f7 !important; }

    /* ====== 40b. SGIS 双大卡紧凑优化 — 3列统计行 + 压缩高度 ====== */
    .sis-feature-grid, .sgis-feature-grid { gap: 8px !important; margin-bottom: 8px !important; }
    .sgis-feature-card { padding: 10px 10px 8px !important; }
    .sgis-feature-head { gap: 8px !important; margin-bottom: 8px !important; }
    .sgis-feature-icon { width: 30px !important; height: 30px !important; border-radius: 8px !important; }
    .sgis-feature-icon svg { width: 15px !important; height: 15px !important; }
    .sgis-feature-title { font-size: 13px !important; }
    .sgis-feature-sub { font-size: 9px !important; margin-top: 1px !important; }
    .sgis-feature-arrow { width: 14px !important; height: 14px !important; }
    /* 3列统计行 — 战绩总览 */
    .sgis-feature-stats-3 { grid-template-columns: repeat(3, 1fr) !important; gap: 4px !important; }
    .sgis-feature-stats-3 .sgis-feature-stat { padding: 5px 4px !important; }
    .sgis-feature-stats-3 .sgis-feature-stat-lbl { font-size: 8px !important; margin-bottom: 1px !important; }
    .sgis-feature-stats-3 .sgis-feature-stat-val { font-size: 13px !important; }
    /* 游戏人生卡片紧凑 */
    .sgis-feature-card.alt .sgis-feature-stats { gap: 4px !important; }
    .sgis-feature-card.alt .sgis-feature-stat { padding: 5px 4px !important; }
    .sgis-feature-card.alt .sgis-feature-stat-lbl { font-size: 8px !important; margin-bottom: 1px !important; }
    .sgis-feature-card.alt .sgis-feature-stat-val { font-size: 13px !important; }
    .sgis-feature-extra { margin-top: 6px !important; padding: 5px 8px !important; font-size: 9px !important; }
    .sgis-feature-extra svg { width: 11px !important; height: 11px !important; }

    /* ====== 41. SGIS XP 卡片 — 保持金色进度条（原版设计），恢复中性背景 ====== */
    .sgis-xp-card {
        border: 1px solid rgba(255, 255, 255, 0.06) !important;
        background: linear-gradient(160deg, rgba(255, 255, 255, 0.035) 0%, rgba(15, 17, 35, 0.5) 100%) !important;
    }
    /* XP 进度条和图标保持原版金色系，不做覆盖 */
    /* XP 等级 next → 恢复紫色 */
    .sgis-xp-levels .next { color: #a3d5f7 !important; }
    /* XP 累计数值 → 恢复紫色 */
    .sgis-xp-total b { color: #a3d5f7 !important; }

    /* ====== 42. SGIS 社交标题 ====== */
    .sgis-section-title.sgis-social-title {
        border-bottom-color: rgba(26,159,255, 0.08) !important;
    }

    /* ====== 43. SGIS copy 按钮 hover ====== */
    .sgis-copy-btn:hover {
        background: rgba(255, 255, 255, 0.1) !important;
        color: #fff !important;
    }

    /* ########## Part B: 主脚本 CSS 常量原生紫色覆盖(120 条) ########## */
    .sglv-ach-user-card { background: linear-gradient(160deg, rgba(37,99,235, 0.08), rgba(59,130,246, 0.04)) !important; }
.sglv-ach-user-card::after { background: radial-gradient(circle, rgba(59,130,246, 0.12), transparent 60%) !important; }
.sglv-ach-nav-item:hover { background: rgba(37,99,235, 0.08) !important; }
.sglv-ach-nav-item.active { background: linear-gradient(90deg, rgba(37,99,235, 0.2), transparent) !important; }
.sglv-ach-nav-item-icon { background: rgba(37,99,235, 0.12) !important; }
.sglv-ach-nav-item-badge { background: rgba(37,99,235, 0.15) !important; color: #dbeafe !important; }
.sglv-ach-nav-item.active .sglv-ach-nav-item-badge { background: #2563eb !important; }
.sglv-ach-sidebar-recent-item:hover { background: rgba(37,99,235, 0.06) !important; }
.sglv-ach-sidebar-recent-icon { background: linear-gradient(135deg, #2563eb, #66c0f4) !important; }
.sglv-ach-header { border-bottom: 1px solid rgba(37,99,235, 0.12) !important; }
.sglv-ach-ring-bg { stroke: rgba(37,99,235, 0.12) !important; }
.sglv-ach-ring-val { background: linear-gradient(135deg, #22d3ee, #66c0f4, #fbbf24) !important; -webkit-background-clip: text !important; background-clip: text !important; }
.sglv-ach-steam-banner { background: linear-gradient(135deg, rgba(34,211,238,0.08), rgba(251,191,36,0.06), rgba(26,159,255, 0.04)) !important; }
.sglv-ach-card { border: 1px solid rgba(37,99,235, 0.1) !important; }
.sglv-ach-card::before { background: var(--ach-rarity, #2563eb) !important; }
.sglv-ach-card:hover { border-color: rgba(37,99,235, 0.3) !important; }
.sglv-ach-card.unlocked.epic { --ach-rarity: #66c0f4 !important; }
.sglv-ach-card.locked { --ach-rarity: #2563eb !important; }
.sglv-ach-card.locked.epic { --ach-rarity: #66c0f4 !important; }
.sglv-ach-card-icon { background: linear-gradient(135deg, rgba(37,99,235, 0.15), rgba(26,159,255, 0.08)) !important; }
.sglv-ach-card.unlocked .sglv-ach-card-icon { box-shadow: inset 0 1px 0 rgba(255,255,255,0.15), inset 0 -1px 0 rgba(0,0,0,0.2), 0 4px 12px rgba(37,99,235, 0.25) !important; }
.sglv-ach-card-rarity.epic { background: #66c0f4 !important; }
.sglv-ach-card.locked .sglv-ach-card-progress-fill { background: linear-gradient(90deg, #38bdf8, #66c0f4, #f59e0b) !important; }
.sglv-sc-hero { background: linear-gradient(135deg, rgba(37,99,235, 0.10) 0%, rgba(59,130,246, 0.06) 50%, rgba(6,182,212,0.04) 100%) !important; border: 1px solid rgba(37,99,235, 0.15) !important; }
.sglv-sc-hero::before { background: radial-gradient(ellipse at top right, rgba(59,130,246, 0.10), transparent 60%) !important; }
.sglv-sc-avatar { box-shadow: 0 1px 8px rgba(0,0,0,0.35), 0 0 0 1px rgba(59,130,246, 0.25) !important; }
.sglv-sc-avatar-placeholder { background: linear-gradient(135deg, #2563eb, #1a9fff) !important; }
.sglv-sc-hero-stat svg { color: #60a5fa !important; }
.sglv-sc-card-header svg { color: #66c0f4 !important; }
.sglv-sc-cover-item:hover { border-color: rgba(59,130,246, 0.5) !important; box-shadow: 0 4px 16px rgba(59,130,246, 0.2) !important; }
.sglv-sc-cover-hours { color: #93c5fd !important; }
.sglv-sc-sk-block { background: linear-gradient(90deg, rgba(37,99,235, 0.06) 25%, rgba(37,99,235, 0.15) 37%, rgba(37,99,235, 0.06) 63%) !important; }
.sglv-sc-edit-btn { background: rgba(37,99,235, 0.15) !important; border: 1px solid rgba(37,99,235, 0.3) !important; color: #93c5fd !important; }
.sglv-sc-edit-btn:hover { background: rgba(37,99,235, 0.25) !important; border-color: rgba(37,99,235, 0.5) !important; }
.sglv-sc-playtime-item:hover { background: rgba(37,99,235, 0.08) !important; }
.sglv-sc-playtime-bar { background: rgba(37,99,235, 0.1) !important; }
.sglv-sc-playtime-bar-fill { background: linear-gradient(90deg, #2563eb, #3b82f6) !important; }
.sglv-sc-ach-item:hover { background: rgba(37,99,235, 0.08) !important; }
.sglv-sc-ach-item.rarity-epic { border-left-color: #3b82f6 !important; }
.sglv-sc-ach-icon { background: rgba(37,99,235, 0.1) !important; }
.sglv-sc-tag-collector { background: rgba(26,159,255, 0.12) !important; border-color: rgba(26,159,255, 0.3) !important; color: #a3d5f7 !important; }
.sglv-sc-picker-search:focus { border-color: rgba(37,99,235, 0.5) !important; }
.sglv-sc-picker-save { background: linear-gradient(135deg, #2563eb, #1a9fff) !important; }
.sglv-sc-hero-badge { border: 1.5px solid rgba(26,159,255, 0.3) !important; }
.sglv-sc-hero-badge:hover { border-color: rgba(26,159,255, 0.6) !important; box-shadow: 0 4px 12px rgba(26,159,255, 0.2) !important; }
.sglv-sc-hero-badge-fallback { color: #60a5fa !important; }
.sglv-sc-hero-badge-lvl { background: linear-gradient(135deg, #1a9fff, #2563eb) !important; }
.sglv-sc-hero-badge-empty:hover { border-color: rgba(26,159,255, 0.4) !important; color: rgba(26,159,255, 0.6) !important; }
.sglv-sc-hero-badge-edit { background: rgba(26,159,255, 0.15) !important; border: 1px solid rgba(26,159,255, 0.25) !important; color: #66c0f4 !important; }
.sglv-sc-hero-badge-edit:hover { background: rgba(26,159,255, 0.25) !important; border-color: rgba(26,159,255, 0.5) !important; }
.sglv-sc-badge-tab:hover { color: #a3d5f7 !important; }
.sglv-sc-badge-tab.active { background: rgba(26,159,255, 0.15) !important; border-color: rgba(26,159,255, 0.4) !important; color: #a3d5f7 !important; }
.sglv-sc-badge-pick-item:hover { border-color: rgba(26,159,255, 0.4) !important; }
.sglv-sc-badge-lvl { background: rgba(26,159,255, 0.15) !important; color: #a3d5f7 !important; }
.sglv-cs-action-btn { border: 1px solid rgba(26,159,255, 0.4) !important; background: rgba(26,159,255, 0.12) !important; color: #a3d5f7 !important; }
.sglv-cs-action-btn:hover { background: rgba(26,159,255, 0.25) !important; border-color: rgba(26,159,255, 0.6) !important; }
.sglv-cs-top10-bar { background: linear-gradient(90deg, #1a9fff, #2563eb) !important; }
.sglv-cs-dist-bar { background: linear-gradient(180deg, #1a9fff, #2563eb) !important; }
.sglv-cs-source-badge { background: rgba(26,159,255, 0.12) !important; color: #a3d5f7 !important; border: 1px solid rgba(26,159,255, 0.2) !important; }
.sglv-cs-refresh-btn:hover { color: #a3d5f7 !important; background: rgba(26,159,255, 0.12) !important; }
.sglv-cs-search:focus { border-color: rgba(26,159,255, 0.5) !important; }
.sglv-cs-game-cover-fallback { background: linear-gradient(135deg, rgba(59,130,246,0.12), rgba(26,159,255, 0.08)) !important; }
#sglv-stage-progress { background: linear-gradient(180deg, rgba(102,192,244, 0.08), transparent) !important; border-bottom: 1px solid rgba(102,192,244, 0.15) !important; }
#sglv-stage-progress .sglv-stage-progress-fill { background: linear-gradient(90deg, #66c0f4 0%, #38bdf8 100%) !important; }
.sglv-header-brand { background: linear-gradient(135deg, rgba(102, 192, 244, 0.18), rgba(26,159,255, 0.18)) !important; }
.sglv-panel .sglv-gs-item-shared { background: rgba(26,159,255, 0.18) !important; color: #a3d5f7 !important; border: 1px solid rgba(26,159,255, 0.35) !important; }
.sglv-detail-btn-ai { background: linear-gradient(135deg, #2563eb, #1a9fff) !important; }
.sglv-body-loading .sglv-bl-btn.primary { background: linear-gradient(135deg, rgba(26,159,255, 0.25), rgba(102, 192, 244, 0.2)) !important; border-color: rgba(26,159,255, 0.4) !important; color: #a3d5f7 !important; }
.sglv-body-loading .sglv-bl-btn.primary:hover { background: linear-gradient(135deg, rgba(26,159,255, 0.35), rgba(102, 192, 244, 0.3)) !important; }
.sglv-trend-kpi-card.purple { border-color: rgba(102,192,244, 0.3) !important; }
.sglv-trend-kpi-card.purple::before { background: #66c0f4 !important; }
.sglv-trend-kpi-card.purple .sglv-trend-kpi-value { color: #66c0f4 !important; }
.sglv-trend-kpi-card.purple .sglv-trend-kpi-icon { background: rgba(102,192,244, 0.15) !important; color: #66c0f4 !important; }
.sgis-tabs::after { background: linear-gradient(90deg, transparent, rgba(26,159,255, 0.35), transparent) !important; }
.sgis-tab.active .sgis-svg { filter: drop-shadow(0 1px 4px rgba(26,159,255, 0.45)) !important; }
.sgis-title-icon { background: linear-gradient(135deg, #1a9fff 0%, #2563eb 45%, #3b82f6 100%) !important; box-shadow: 0 4px 12px rgba(26,159,255, 0.4), inset 0 1px 0 rgba(255, 255, 255, 0.25), inset 0 -1px 0 rgba(0, 0, 0, 0.2) !important; }
.sgis-body::-webkit-scrollbar-thumb { background: linear-gradient(180deg, rgba(26,159,255, 0.45), rgba(59, 130, 246, 0.45)) !important; }
.sgis-state-icon { background: linear-gradient(135deg, rgba(26,159,255, 0.15), rgba(59, 130, 246, 0.08)) !important; border: 1px solid rgba(26,159,255, 0.2) !important; color: #66c0f4 !important; }
.sgis-badge-hero { background: linear-gradient(135deg, rgba(26,159,255, 0.18) 0%, rgba(59, 130, 246, 0.1) 50%, var(--sgis-bg-2) 100%) !important; border: 1px solid rgba(26,159,255, 0.3) !important; box-shadow: 0 4px 16px rgba(26,159,255, 0.08), inset 0 1px 0 rgba(255, 255, 255, 0.05) !important; }
.sgis-badge-hero::before { background: radial-gradient(circle, rgba(26,159,255, 0.25) 0%, transparent 65%) !important; }
.sgis-badge-hero-progress-label span:last-child { color: #a3d5f7 !important; }
.sgis-badge-hero-level-bar { background: linear-gradient(180deg, #1a9fff 0%, #2563eb 100%) !important; box-shadow: 0 0 6px rgba(26,159,255, 0.3) !important; }
.sgis-badge-group-head:hover { background: linear-gradient(135deg, rgba(26,159,255, 0.05), rgba(59, 130, 246, 0.02)) !important; }
.sgis-badge-group-stat-val { color: #a3d5f7 !important; }
.sgis-badge-footer-formula b { color: #a3d5f7 !important; }
.sglv-skel-bar { background: linear-gradient(90deg, rgba(255, 255, 255, 0.04) 0%, rgba(26,159,255, 0.12) 50%, rgba(255, 255, 255, 0.04) 100%) !important; }
.sglv-wl-kpi-cell { background: linear-gradient(135deg, rgba(26,159,255, 0.06), rgba(59, 130, 246, 0.03)) !important; border: 1px solid rgba(26,159,255, 0.15) !important; }
.sglv-skel-cover { background: linear-gradient(90deg, rgba(26,159,255, 0.08) 0%, rgba(26,159,255, 0.18) 50%, rgba(26,159,255, 0.08) 100%) !important; }
.sglv-wl-loading .sglv-wl-spin { color:#66c0f4 !important; }
.sglv-wl-loading-bar-fill { background:linear-gradient(90deg,#66c0f4,#66c0f4) !important; }
.sglv-toast { border: 1px solid rgba(102,192,244, 0.5) !important; }
.sglv-guide-toast { border: 1px solid rgba(102,192,244, 0.45) !important; }
.sglv-guide-toast-title svg { color: #66c0f4 !important; }
.sglv-guide-toast-btn.primary { background: linear-gradient(90deg, #1a9fff, #3b82f6) !important; }
.sglv-set-chip.purple { background: rgba(102,192,244, 0.15) !important; color: #66c0f4 !important; }
.sglv-set-mode-item:hover { border-color: rgba(102,192,244, 0.4) !important; background: rgba(102,192,244, 0.06) !important; }
.sglv-set-mode-item input { accent-color: #66c0f4 !important; }
.sglv-set-mode-item input:checked ~ .sglv-set-mode-info .sglv-set-mode-name { color: #66c0f4 !important; }
.sglv-set-theme-opt:hover { border-color: rgba(102,192,244, 0.4) !important; }
.sglv-set-theme-opt.selected { border-color: rgba(102,192,244, 0.55) !important; background: rgba(102,192,244, 0.07) !important; box-shadow: 0 0 0 1px rgba(102,192,244, 0.25) !important; }
.sglv-set-save-btn { background: linear-gradient(90deg, #1a9fff, #3b82f6) !important; }
.sglv-cover-badge { color: #a3d5f7 !important; }
.sglv-cover-badge.shared { background: rgba(26,159,255, 0.55) !important; color: #d3ecfd !important; }
.sgis-price-tbl-row.user-region { box-shadow: inset 0 0 0 1px rgba(102,192,244, 0.3) !important; }
.sgis-review-pct-big.mix { color:#66c0f4 !important; }
.sgis-review-bar-positive.mix { background:linear-gradient(90deg,#66c0f4 0%,#54a0ff 100%) !important; box-shadow:0 0 6px rgba(102,192,244, 0.4) !important; }
.sgis-review-item:hover { border-color:rgba(26,159,255, 0.15) !important; }
.sgis-review-avatar-fallback { background:linear-gradient(135deg,rgba(26,159,255, 0.4),rgba(59,130,246,0.3)) !important; }
.sgis-review-count-summary { background:rgba(26,159,255, 0.06) !important; border:1px solid rgba(26,159,255, 0.12) !important; }
.sgis-review-count-summary b { color:#a3d5f7 !important; }
.sgis-review-count-icon { color:#66c0f4 !important; }
.sgis-review-count-filtered { background:rgba(102,192,244, 0.2) !important; color:#66c0f4 !important; border:1px solid rgba(102,192,244, 0.3) !important; }
.sgis-review-action-btn:hover { background:rgba(26,159,255, 0.15) !important; border-color:rgba(26,159,255, 0.3) !important; color:#a3d5f7 !important; }
.sgis-review-empty-icon { background:linear-gradient(135deg,rgba(26,159,255, 0.12),rgba(59,130,246,0.06)) !important; border:1px solid rgba(26,159,255, 0.18) !important; }
.sgis-gift-card { background:linear-gradient(135deg, rgba(102,192,244, 0.12), rgba(102,192,244,0.08)) !important; border:1px solid rgba(102,192,244, 0.2) !important; }
.sgis-crack-badge.aaa { background:rgba(59,130,246, 0.15) !important; color:#60a5fa !important; border-color:rgba(59,130,246, 0.25) !important; }
.sgis-review-regex-toggle:hover { background:rgba(102,192,244, 0.1) !important; border-color:rgba(102,192,244, 0.3) !important; }
.sgis-review-regex-toggle.active { background:rgba(102,192,244, 0.2) !important; color:#66c0f4 !important; border-color:rgba(102,192,244, 0.4) !important; box-shadow:0 0 0 1px rgba(102,192,244, 0.2) !important; }
.sgis-load-bar-fill { background:linear-gradient(90deg,#06b6d4,#3b82f6,#1a9fff) !important; }
.sgis-skel-icon { background:linear-gradient(90deg,rgba(26,159,255, 0.08),rgba(26,159,255, 0.18),rgba(26,159,255, 0.08)) !important; }

    /* ########## Part C: 共享样式库原生紫色覆盖(163 条) ########## */
    .sglv-stat-card.purple, .sglv-stat-dash-card.purple, .sglv-playtime-kpi-card.purple { border-color: rgba(26,159,255, 0.35) !important; }
.sglv-stat-card.purple::before, .sglv-stat-dash-card.purple::before, .sglv-playtime-kpi-card.purple::before { background: #66c0f4 !important; }
.sglv-card-badge.shared { background: rgba(26,159,255, 0.2) !important; color: #66c0f4 !important; }
.sglv-ps-tier-badge.tier-premium { background:rgba(102,192,244, 0.95) !important; }
.sglv-ps-card.sglv-ps-exclusive:hover { border-color:rgba(102,192,244, 0.4) !important; }
.sglv-wl-kpi-card.kpi-free::before { background: #2563eb !important; }
.sglv-wl-kpi-card.kpi-year::before { background: #3b82f6 !important; }
.sglv-wl-kpi-card.kpi-free .sglv-wl-kpi-icon { background: rgba(37,99,235, 0.15) !important; color: #2563eb !important; }
.sglv-wl-kpi-card.kpi-year .sglv-wl-kpi-icon { background: rgba(59,130,246, 0.15) !important; color: #3b82f6 !important; }
.sglv-wl-year-bar { background: linear-gradient(180deg, rgba(37,99,235, 0.85), rgba(37,99,235, 0.35)) !important; }
.sglv-list-badge.shared { background: rgba(26,159,255, 0.2) !important; color: #66c0f4 !important; }
.sglv-stat-card.purple .sglv-stat-icon { background: rgba(26,159,255, 0.15) !important; color: #66c0f4 !important; }
.sglv-stat-dash-card.purple .sglv-stat-dash-value { color: #66c0f4 !important; }
.sglv-stat-dash-card.purple .sglv-stat-dash-icon { background: rgba(26,159,255, 0.15) !important; color: #66c0f4 !important; }
.sglv-trend-kpi-card.total { border-color: rgba(96,165,250, 0.35) !important; }
.sglv-trend-kpi-card.total .sglv-trend-kpi-value { color: #60a5fa !important; }
.sglv-trend-kpi-card.total::before { background: #60a5fa !important; }
.sglv-trend-kpi-card.total .sglv-trend-kpi-icon { background: rgba(96,165,250, 0.15) !important; color: #60a5fa !important; }
.sglv-playtime-kpi-card.purple .sglv-playtime-kpi-value { color: #66c0f4 !important; }
.sglv-playtime-kpi-card.purple .sglv-playtime-kpi-icon { background: rgba(26,159,255, 0.15) !important; color: #66c0f4 !important; }
:root { --sgis-border: rgba(26,159,255, 0.18) !important; --sgis-purple: #1a9fff !important; --sgis-purple-2: #66c0f4 !important; --sgis-purple-text: #a3d5f7 !important; --sgis-shadow: 0 16px 60px rgba(0, 0, 0, 0.55), 0 0 0 1px rgba(26,159,255, 0.08) !important; --sgis-glow-purple: 0 0 24px rgba(26,159,255, 0.18) !important; }
#sgis-fab { background: linear-gradient(135deg, #1a9fff 0%, #3b82f6 50%, #06b6d4 100%) !important; box-shadow: -4px 0 18px rgba(26,159,255, 0.4), inset 0 0 0 1px rgba(255, 255, 255, 0.15) !important; }
#sgis-fab:hover { box-shadow: -6px 0 24px rgba(26,159,255, 0.55), inset 0 0 0 1px rgba(255, 255, 255, 0.2) !important; }
#sgis-panel { border-left: 1px solid rgba(26,159,255, 0.22) !important; }
#sgis-panel::before { background: linear-gradient(90deg, transparent 0%, rgba(26,159,255, 0.5) 50%, transparent 100%) !important; }
.sgis-header { background: linear-gradient(135deg, rgba(26,159,255, 0.22) 0%, rgba(59, 130, 246, 0.12) 50%, var(--sgis-bg-2) 100%) !important; border-bottom: 1px solid rgba(26,159,255, 0.2) !important; }
.sgis-header::before { background: radial-gradient(circle, rgba(26,159,255, 0.22) 0%, transparent 65%) !important; }
.sgis-header-decoration { background: linear-gradient(90deg, transparent 0%, rgba(26,159,255, 0.4) 50%, transparent 100%) !important; }
.sgis-title-text { background: linear-gradient(135deg, #fff 0%, #a3d5f7 100%) !important; -webkit-background-clip: text !important; background-clip: text !important; }
.sgis-title-icon { background: linear-gradient(135deg, #1a9fff 0%, #2563eb 50%, #3b82f6 100%) !important; box-shadow: 0 4px 12px rgba(26,159,255, 0.4), inset 0 1px 0 rgba(255, 255, 255, 0.2) !important; }
.sgis-icon-btn:hover { background: rgba(26,159,255, 0.18) !important; border-color: rgba(26,159,255, 0.3) !important; box-shadow: 0 2px 8px rgba(26,159,255, 0.25) !important; }
.sgis-tabs { border-bottom: 1px solid rgba(26,159,255, 0.12) !important; }
.sgis-tab::before { background: linear-gradient(135deg, rgba(26,159,255, 0.3), rgba(59, 130, 246, 0.2)) !important; }
.sgis-tab:hover { color: #a3d5f7 !important; }
.sgis-tab.active { box-shadow: 0 2px 8px rgba(26,159,255, 0.25), inset 0 0 0 1px rgba(26,159,255, 0.5) !important; }
.sgis-body { scrollbar-color: rgba(26,159,255, 0.4) transparent !important; }
.sgis-body::-webkit-scrollbar-thumb { background: linear-gradient(180deg, rgba(26,159,255, 0.4), rgba(59, 130, 246, 0.4)) !important; }
.sgis-body::-webkit-scrollbar-thumb:hover { background: linear-gradient(180deg, rgba(26,159,255, 0.6), rgba(59, 130, 246, 0.6)) !important; }
.sgis-retry-btn { border: 1px solid rgba(26,159,255, 0.4) !important; background: linear-gradient(135deg, rgba(26,159,255, 0.15), rgba(59, 130, 246, 0.1)) !important; color: #a3d5f7 !important; }
.sgis-retry-btn:hover { background: linear-gradient(135deg, rgba(26,159,255, 0.3), rgba(59, 130, 246, 0.2)) !important; box-shadow: 0 4px 12px rgba(26,159,255, 0.25) !important; }
.sgis-spinner { border: 3px solid rgba(26,159,255, 0.15) !important; border-top-color: #1a9fff !important; box-shadow: 0 0 16px rgba(26,159,255, 0.3) !important; }
.sgis-hero { background: linear-gradient(135deg, rgba(102, 192, 244, 0.15) 0%, rgba(26,159,255, 0.1) 50%, var(--sgis-bg-2) 100%) !important; }
.sgis-hero::after { background: radial-gradient(circle, rgba(26,159,255, 0.15) 0%, transparent 60%) !important; }
.sgis-section:hover { border-color: rgba(26,159,255, 0.12) !important; }
.sgis-section-title { color: #66c0f4 !important; border-bottom: 1px solid rgba(26,159,255, 0.08) !important; }
.sgis-section-title svg { color: #66c0f4 !important; }
.sgis-row { border-bottom: 1px dashed rgba(26,159,255, 0.08) !important; }
.sgis-tag { background: linear-gradient(135deg, rgba(26,159,255, 0.12), rgba(59, 130, 246, 0.06)) !important; color: #a3d5f7 !important; border: 1px solid rgba(26,159,255, 0.18) !important; }
.sgis-tag:hover { background: linear-gradient(135deg, rgba(26,159,255, 0.22), rgba(59, 130, 246, 0.12)) !important; border-color: rgba(26,159,255, 0.35) !important; }
.sgis-link { background: linear-gradient(135deg, rgba(26,159,255, 0.1), rgba(59, 130, 246, 0.06)) !important; color: #a3d5f7 !important; border: 1px solid rgba(26,159,255, 0.2) !important; }
.sgis-link:hover { background: linear-gradient(135deg, rgba(26,159,255, 0.2), rgba(59, 130, 246, 0.12)) !important; border-color: rgba(26,159,255, 0.4) !important; }
.sgis-taste-tag.theme { background: rgba(26,159,255, 0.12) !important; color: #a3d5f7 !important; border-color: rgba(26,159,255, 0.22) !important; }
.sgis-owned-hero.shared { background: linear-gradient(135deg, rgba(26,159,255, 0.18) 0%, rgba(37,99,235, 0.08) 50%, var(--sgis-bg-2) 100%) !important; border-color: rgba(26,159,255, 0.35) !important; }
.sgis-owned-hero.shared::after { background: radial-gradient(circle, rgba(26,159,255, 0.2) 0%, transparent 65%) !important; }
.sgis-owned-hero.shared .sgis-owned-icon { background: linear-gradient(135deg, #1a9fff, #2563eb) !important; box-shadow: 0 2px 6px rgba(26,159,255, 0.4) !important; }
.sgis-btn { background: linear-gradient(135deg, rgba(26,159,255, 0.18), rgba(59, 130, 246, 0.1)) !important; border: 1px solid rgba(26,159,255, 0.3) !important; color: #a3d5f7 !important; }
.sgis-btn:hover { background: linear-gradient(135deg, rgba(26,159,255, 0.3), rgba(59, 130, 246, 0.18)) !important; border-color: rgba(26,159,255, 0.45) !important; box-shadow: 0 4px 10px rgba(26,159,255, 0.2) !important; }
.sgis-stat-box:hover { border-color: rgba(26,159,255, 0.3) !important; background: linear-gradient(135deg, rgba(26,159,255, 0.08), rgba(59, 130, 246, 0.04)) !important; }
.sgis-owner-item.sharer { border-color: rgba(26,159,255, 0.35) !important; background: rgba(26,159,255, 0.08) !important; }
.sgis-owner-tag.sharer { background: rgba(26,159,255, 0.25) !important; }
.sgis-card-toggle button.active { background: linear-gradient(135deg, rgba(26,159,255, 0.3), rgba(59, 130, 246, 0.2)) !important; box-shadow: inset 0 0 0 1px rgba(26,159,255, 0.4) !important; }
.sgis-card-item:hover { background: rgba(26,159,255, 0.12) !important; border-color: rgba(26,159,255, 0.3) !important; box-shadow: 0 4px 12px rgba(26,159,255, 0.15) !important; }
.sgis-card-icon-fallback { background: linear-gradient(135deg, rgba(26,159,255, 0.15), rgba(59, 130, 246, 0.08)) !important; }
.sgis-card-badge { background: rgba(26,159,255, 0.2) !important; }
.sgis-family-share-row.sharing { background: rgba(26,159,255, 0.12) !important; border: 1px solid rgba(26,159,255, 0.3) !important; color: #66c0f4 !important; }
.sgis-family-share-row.sharing .sgis-family-share-icon { background: rgba(26,159,255, 0.3) !important; }
.sgis-predict-btn { border: 1px solid rgba(26,159,255, 0.4) !important; background: linear-gradient(135deg, rgba(26,159,255, 0.18), rgba(59, 130, 246, 0.1)) !important; color: #a3d5f7 !important; }
.sgis-predict-btn:hover { background: linear-gradient(135deg, rgba(26,159,255, 0.3), rgba(59, 130, 246, 0.18)) !important; box-shadow: 0 4px 14px rgba(26,159,255, 0.3) !important; }
.sgis-profile-main-card { background: linear-gradient(160deg, #16202d 0%, #121a25 40%, #0d131c 100%) !important; box-shadow: 0 10px 40px rgba(0, 0, 0, 0.45), 0 0 0 1px rgba(26,159,255, 0.15) !important; }
.sgis-profile-main-card::before { background: radial-gradient(circle, rgba(26,159,255, 0.4) 0%, transparent 60%) !important; }
.sgis-profile-main-card::after { background: linear-gradient(90deg, transparent 0%, rgba(26,159,255, 0.6) 50%, transparent 100%) !important; }
.sgis-profile-main-card-bg { filter: saturate(1.2) drop-shadow(0 0 20px rgba(26,159,255, 0.25)) !important; }
.sgis-profile-avatar-badge { background: linear-gradient(135deg, #1a9fff 0%, #2563eb 50%, #3b82f6 100%) !important; box-shadow: 0 4px 12px rgba(26,159,255, 0.5), 0 0 0 3px #121a25 !important; }
.sgis-profile-verified { background: linear-gradient(135deg, #1a9fff, #3b82f6) !important; box-shadow: 0 2px 6px rgba(26,159,255, 0.4) !important; }
.sgis-profile-stat:hover { border-color: rgba(26,159,255, 0.3) !important; background: linear-gradient(160deg, rgba(26,159,255, 0.08) 0%, rgba(59, 130, 246, 0.03) 100%) !important; }
.sgis-profile-stat-icon { background: linear-gradient(135deg, rgba(26,159,255, 0.2), rgba(59, 130, 246, 0.08)) !important; }
.sgis-profile-stat-icon svg { color: #a3d5f7 !important; }
.sgis-profile-stat-icon.t-purple { background: linear-gradient(135deg, rgba(59,130,246, 0.22), rgba(26,159,255, 0.08)) !important; }
.sgis-profile-stat-icon.t-purple svg { color: #a3d5f7 !important; }
.sgis-profile-stat-val.t-purple { color: #a3d5f7 !important; }
.sgis-xp-levels .next { color: #a3d5f7 !important; }
.sgis-xp-total b { color: #a3d5f7 !important; }
.sgis-feature-card { background: linear-gradient(160deg, rgba(26,159,255, 0.12) 0%, rgba(59, 130, 246, 0.04) 50%, rgba(15, 17, 35, 0.6) 100%) !important; border: 1px solid rgba(26,159,255, 0.2) !important; }
.sgis-feature-card::before { background: radial-gradient(circle, rgba(26,159,255, 0.2) 0%, transparent 60%) !important; }
.sgis-feature-card::after { background: linear-gradient(90deg, transparent 0%, rgba(26,159,255, 0.5) 50%, transparent 100%) !important; }
.sgis-feature-card:hover { border-color: rgba(26,159,255, 0.4) !important; box-shadow: 0 8px 20px rgba(26,159,255, 0.2) !important; }
.sgis-feature-card.alt { background: linear-gradient(160deg, rgba(37,99,235, 0.12) 0%, rgba(59, 130, 246, 0.04) 50%, rgba(15, 17, 35, 0.6) 100%) !important; border-color: rgba(37,99,235, 0.2) !important; }
.sgis-feature-card.alt::before { background: radial-gradient(circle, rgba(37,99,235, 0.2) 0%, transparent 60%) !important; }
.sgis-feature-card.alt::after { background: linear-gradient(90deg, transparent 0%, rgba(37,99,235, 0.5) 50%, transparent 100%) !important; }
.sgis-feature-icon { background: linear-gradient(135deg, rgba(26,159,255, 0.22), rgba(37,99,235, 0.12)) !important; box-shadow: inset 0 0 0 1px rgba(255, 255, 255, 0.04), 0 2px 6px rgba(26,159,255, 0.15) !important; }
.sgis-feature-card.alt .sgis-feature-icon { background: linear-gradient(135deg, rgba(37,99,235, 0.22), rgba(59, 130, 246, 0.12)) !important; box-shadow: inset 0 0 0 1px rgba(255, 255, 255, 0.04), 0 2px 6px rgba(37,99,235, 0.15) !important; }
.sgis-feature-icon svg { color: #a3d5f7 !important; }
.sgis-feature-card.alt .sgis-feature-icon svg { color: #93c5fd !important; }
.sgis-feature-card:hover .sgis-feature-arrow { color: #a3d5f7 !important; }
.sgis-feature-stat-val.t-purple { color: #a3d5f7 !important; }
.sgis-activity-type.news { background: rgba(102,192,244, 0.2) !important; }
.sgis-badge-icon { background: linear-gradient(135deg, rgba(26,159,255, 0.12), rgba(59, 130, 246, 0.06)) !important; }
.sgis-badge-card:hover .sgis-badge-icon { background: linear-gradient(135deg, rgba(26,159,255, 0.2), rgba(59, 130, 246, 0.1)) !important; }
.sgis-badge-icon svg { color: #a3d5f7 !important; }
.sgis-user-ach.unlocked .sgis-user-ach-icon { background: linear-gradient(135deg, rgba(26,159,255, 0.12), rgba(59,130,246,0.08)) !important; box-shadow: 0 0 12px rgba(26,159,255, 0.2) !important; }
.sgis-persona-section { background: linear-gradient(135deg, rgba(26,159,255, 0.12) 0%, rgba(59, 130, 246, 0.06) 50%, var(--sgis-bg-2) 100%) !important; border: 1px solid rgba(26,159,255, 0.22) !important; box-shadow: 0 2px 8px rgba(26,159,255, 0.08) !important; }
.sgis-persona-section::before { background: radial-gradient(circle, rgba(26,159,255, 0.2) 0%, transparent 60%) !important; }
.sgis-persona-title { color: #a3d5f7 !important; }
.sgis-persona-title svg { color: #a3d5f7 !important; }
.sgis-persona-type { background: linear-gradient(135deg, rgba(26,159,255, 0.25), rgba(37,99,235, 0.15)) !important; color: #a3d5f7 !important; border: 1px solid rgba(26,159,255, 0.3) !important; }
.sgis-persona-trait { background: linear-gradient(135deg, rgba(26,159,255, 0.18), rgba(37,99,235, 0.08)) !important; color: #a3d5f7 !important; border: 1px solid rgba(26,159,255, 0.2) !important; }
.sgis-insight-kpi.purple { border-color: rgba(26,159,255, 0.3) !important; border-left-color: #1a9fff !important; }
.sgis-insight-kpi.purple::before { background: #1a9fff !important; }
.sgis-insight-kpi.purple:hover { border-color: rgba(26,159,255, 0.5) !important; }
.sgis-insight-persona { border: 1px solid rgba(26,159,255, 0.25) !important; }
.sgis-insight-persona-head { background: linear-gradient(135deg, rgba(26,159,255, 0.35), rgba(59, 130, 246, 0.18)) !important; }
.sgis-insight-persona-rarity { background: linear-gradient(135deg, rgba(26,159,255, 0.4), rgba(37,99,235, 0.25)) !important; color: #d3ecfd !important; border: 1px solid rgba(26,159,255, 0.4) !important; }
.sgis-insight-persona-trait { background: linear-gradient(135deg, rgba(26,159,255, 0.18), rgba(59,130,246,0.08)) !important; color: #a3d5f7 !important; border: 1px solid rgba(26,159,255, 0.22) !important; }
.sgis-insight-persona-trait:hover { background: linear-gradient(135deg, rgba(26,159,255, 0.3), rgba(59,130,246,0.15)) !important; border-color: rgba(26,159,255, 0.4) !important; }
.sgis-insight-metric:hover { border-color: rgba(26,159,255, 0.2) !important; }
.sgis-insight-dim:hover { border-color: rgba(26,159,255, 0.3) !important; }
.sgis-insight-ai { border: 1px solid rgba(26,159,255, 0.22) !important; }
.sgis-insight-ai-head { background: linear-gradient(135deg, rgba(26,159,255, 0.18), rgba(59, 130, 246, 0.08)) !important; border-bottom: 1px solid rgba(26,159,255, 0.15) !important; }
.sgis-insight-ai-icon { background: linear-gradient(135deg, rgba(26,159,255, 0.35), rgba(37,99,235, 0.2)) !important; }
.sgis-insight-ai-icon svg { color: #a3d5f7 !important; }
.sgis-insight-ai-btn { background: linear-gradient(135deg, rgba(26,159,255, 0.45), rgba(59, 130, 246, 0.3)) !important; border: 1px solid rgba(26,159,255, 0.4) !important; }
.sgis-insight-ai-btn:hover { background: linear-gradient(135deg, rgba(26,159,255, 0.6), rgba(59, 130, 246, 0.45)) !important; box-shadow: 0 3px 10px rgba(26,159,255, 0.25) !important; }
.sgis-insight-ai-oneliner { background: linear-gradient(135deg, rgba(26,159,255, 0.15), rgba(59, 130, 246, 0.08)) !important; border: 1px solid rgba(26,159,255, 0.2) !important; }
.sgis-insight-ai-oneliner svg { color: #a3d5f7 !important; }
.sgis-insight-ach-toggle:hover { color: #a3d5f7 !important; }
.sgis-social-friend:hover { border-color: rgba(26,159,255, 0.25) !important; background: linear-gradient(135deg, rgba(26,159,255, 0.06) 0%, rgba(59,130,246,0.03) 100%) !important; }
.sgis-social-friend-days { background: rgba(26,159,255, 0.12) !important; color: #a3d5f7 !important; border: 1px solid rgba(26,159,255, 0.18) !important; }
.sgis-social-group-head { color: #66c0f4 !important; border-bottom: 1px solid rgba(26,159,255, 0.1) !important; }
.sgis-social-group-head .count { background: rgba(26,159,255, 0.15) !important; color: #a3d5f7 !important; }
.sgis-gc-fill { background: linear-gradient(90deg, #38bdf8, #60a5fa) !important; }
.sgis-news-item { background: linear-gradient(135deg, rgba(255, 255, 255, 0.025), rgba(26,159,255, 0.015)) !important; }
.sgis-news-item:hover { background: linear-gradient(135deg, rgba(26,159,255, 0.08), rgba(59, 130, 246, 0.04)) !important; border-color: rgba(26,159,255, 0.25) !important; box-shadow: 0 2px 8px rgba(26,159,255, 0.1) !important; }
.sgis-news-feed { background: linear-gradient(135deg, rgba(26,159,255, 0.18), rgba(59, 130, 246, 0.1)) !important; color: #a3d5f7 !important; border: 1px solid rgba(26,159,255, 0.18) !important; }
.sgis-card-item.sgis-card-with-bg:hover::after { background: linear-gradient(90deg, rgba(15, 17, 35, 0.85) 0%, rgba(26,159,255, 0.3) 50%, rgba(59, 130, 246, 0.2) 100%) !important; }
.sgis-scroll-area { scrollbar-color: rgba(26,159,255, 0.4) transparent !important; }
.sgis-scroll-area::-webkit-scrollbar-thumb { background: linear-gradient(180deg, rgba(26,159,255, 0.4), rgba(59, 130, 246, 0.4)) !important; }
.sgis-badge-group { background: linear-gradient(160deg, rgba(255, 255, 255, 0.025) 0%, rgba(26,159,255, 0.02) 100%) !important; }
.sgis-badge-group:hover { border-color: rgba(26,159,255, 0.18) !important; }
.sgis-badge-group-head::after { background: linear-gradient(90deg, transparent, rgba(26,159,255, 0.15), transparent) !important; }
.sgis-badge-group-icon { background: linear-gradient(135deg, rgba(26,159,255, 0.18), rgba(59, 130, 246, 0.08)) !important; }
.sgis-badge-group-icon svg { color: #a3d5f7 !important; }
.sgis-badge-group-stat { color: #a3d5f7 !important; background: rgba(26,159,255, 0.12) !important; }
.sgis-badge-group-expanded .sgis-badge-group-arrow { color: #a3d5f7 !important; }
.sgis-badge-row:hover { background: rgba(26,159,255, 0.08) !important; border-color: rgba(26,159,255, 0.2) !important; }
.sgis-badge-row-icon { background: linear-gradient(135deg, rgba(26,159,255, 0.15), rgba(59, 130, 246, 0.06)) !important; }
.sgis-badge-row-icon svg { color: #a3d5f7 !important; }
.sgis-badge-row-lv { color: #66c0f4 !important; }
.sgis-badge-row-rar.r3 { background: rgba(26,159,255, 0.2) !important; color: #a3d5f7 !important; }
.sgis-badge-row-link { background: rgba(26,159,255, 0.12) !important; color: #a3d5f7 !important; }
.sgis-badge-row-link:hover { background: rgba(26,159,255, 0.25) !important; }
.sgis-dist-label { color: #a3d5f7 !important; }
.sgis-dist-bar-fill { background: linear-gradient(90deg, #1a9fff, #3b82f6) !important; box-shadow: 0 0 6px rgba(26,159,255, 0.3) !important; }
.sgis-value-card { background: linear-gradient(160deg, rgba(255, 255, 255, 0.04) 0%, rgba(26,159,255, 0.025) 100%) !important; }
.sgis-value-card:hover { background: linear-gradient(160deg, rgba(26,159,255, 0.1) 0%, rgba(59, 130, 246, 0.04) 100%) !important; border-color: rgba(26,159,255, 0.3) !important; }
.sgis-value-card-market { color: #a3d5f7 !important; }
.sgis-badge-row-icon-wrap { background: radial-gradient(circle at 50% 35%, rgba(26,159,255, 0.12), transparent 65%), linear-gradient(135deg, rgba(15, 23, 42, 0.6) 0%, rgba(30, 41, 59, 0.5) 100%) !important; }
.sgis-badge-tip { border: 1px solid rgba(26,159,255, 0.35) !important; box-shadow: 0 8px 24px rgba(0, 0, 0, 0.5), 0 0 0 1px rgba(26,159,255, 0.1) !important; }
.sgis-badge-tip-head { border-bottom: 1px solid rgba(26,159,255, 0.15) !important; }
.sgis-badge-tip-bd-bar > div { background: linear-gradient(90deg, #1a9fff, #3b82f6) !important; }
.sgis-tagrec-tab:hover { background: rgba(26,159,255, 0.1) !important; }
.sgis-tagrec-tab.active { background: rgba(26,159,255, 0.2) !important; color: #a3d5f7 !important; border-color: rgba(26,159,255, 0.4) !important; }
.sglv-goty-year-chip:hover { background: rgba(26,159,255, 0.12) !important; border-color: rgba(26,159,255, 0.3) !important; }
.sglv-goty-year-chip.active { background: linear-gradient(135deg, rgba(26,159,255, 0.25), rgba(59, 130, 246, 0.15)) !important; color: #a3d5f7 !important; border-color: rgba(26,159,255, 0.5) !important; box-shadow: 0 0 8px rgba(26,159,255, 0.2) !important; }

    /* ########## Part E: 收藏库面板 CSS 紫色覆盖(8 条,attr 前缀顺序无关) ########## */
    html[data-sglv-theme="blue"] .sglv-header-brand { background: linear-gradient(135deg, rgba(102, 192, 244, 0.18), rgba(26,159,255, 0.18)) !important; }
html[data-sglv-theme="blue"] .sgc-panel .sglv-goty-year-bar { background: linear-gradient(180deg, rgba(26,159,255, 0.08), transparent) !important; border-bottom: 1px solid rgba(26,159,255, 0.18) !important; }
html[data-sglv-theme="blue"] .sgc-panel .sglv-goty-year-chip.active { background: linear-gradient(135deg, rgba(26,159,255, 0.4), rgba(59, 130, 246, 0.25)) !important; border-color: rgba(26,159,255, 0.6) !important; box-shadow: 0 0 12px rgba(26,159,255, 0.35) !important; }
html[data-sglv-theme="blue"] .sglv-skel-stage-fill { background: linear-gradient(90deg, #66c0f4, #66c0f4) !important; }
html[data-sglv-theme="blue"] .sglv-dlc-loading .sglv-dlc-spin { color:#66c0f4 !important; }
html[data-sglv-theme="blue"] .sglv-dlc-loading-bar-fill { background:linear-gradient(90deg,#66c0f4,#66c0f4) !important; }
html[data-sglv-theme="blue"] .sglv-dlc-type-badge-dlc { background: rgba(26,159,255, 0.15) !important; color: #66c0f4 !important; border: 1px solid rgba(26,159,255, 0.25) !important; }
html[data-sglv-theme="blue"] .sgc-panel .sglv-stat-row + .sglv-progress .sglv-progress-fill { background: linear-gradient(90deg, #4caf50, #22d3ee, #66c0f4, #66c0f4) !important; }

    /* ########## Part D: 手工精调(侧边栏靛蓝暗基底→Steam 深蓝 + 标题栏柔化 + 收藏库渐变保深度) ########## */
:root {
    --sgis-bg: linear-gradient(180deg, rgba(23, 26, 33, 0.98) 0%, rgba(13, 19, 30, 0.99) 100%) !important;
    --sgis-bg-solid: #10151d !important;
    --sgis-bg-2: rgba(19, 25, 36, 0.85) !important;
    --sgis-bg-3: rgba(24, 32, 48, 0.7) !important;
}
.sgis-tabs { background: linear-gradient(180deg, rgba(23, 26, 33, 0.7) 0%, rgba(13, 19, 30, 0.85) 100%) !important; }
.sgis-header { background: linear-gradient(135deg, rgba(102, 192, 244, 0.12) 0%, rgba(59, 130, 246, 0.07) 50%, var(--sgis-bg-2) 100%) !important; border-bottom: 1px solid rgba(102, 192, 244, 0.18) !important; }
.sgis-header::before { background: radial-gradient(circle, rgba(102, 192, 244, 0.12) 0%, transparent 65%) !important; }
.sgis-header-decoration { background: linear-gradient(90deg, transparent 0%, rgba(102, 192, 244, 0.3) 50%, transparent 100%) !important; }
#sgis-panel { border-left: 1px solid rgba(102, 192, 244, 0.2) !important; }
#sgis-panel::before { background: linear-gradient(90deg, transparent 0%, rgba(102, 192, 244, 0.35) 50%, transparent 100%) !important; }
html[data-sglv-theme="blue"] .sglv-skel-stage-fill { background: linear-gradient(90deg, #1a9fff, #66c0f4) !important; }
html[data-sglv-theme="blue"] .sglv-dlc-loading-bar-fill { background: linear-gradient(90deg, #1a9fff, #66c0f4) !important; }
html[data-sglv-theme="blue"] .sgc-panel .sglv-stat-row + .sglv-progress .sglv-progress-fill { background: linear-gradient(90deg, #4caf50, #22d3ee, #1a9fff, #66c0f4) !important; }
/* ---- D5. 成就页 → 经典蓝统一视觉 ----
 * 痛点: 页面原为 GitHub 暗底+多彩语义第三风格,蓝色铬件下绿色稀有度条/彩虹进度条/金青横幅
 * 混杂扎眼。收敛策略: 页面底转 Steam 深蓝;稀有度只保留角标圆点与低饱和左条(信息不丢);
 * 进度/徽章/NEW/横幅/环形数值统一蓝系;已解锁名称与计数文字换柔和浅蓝(降刺眼度)。 */
.sglv-ach-layout, .sglv-sc-wrap { background: linear-gradient(180deg, #141c28 0%, #0e141d 100%) !important; }
.sglv-ach-sidebar { background: linear-gradient(180deg, rgba(18, 25, 36, 0.95) 0%, rgba(12, 17, 25, 0.95) 100%) !important; border-right-color: rgba(102, 192, 244, 0.08) !important; }
.sglv-ach-sidebar-header { border-bottom-color: rgba(102, 192, 244, 0.08) !important; }
.sglv-ach-user-card { border-bottom-color: rgba(102, 192, 244, 0.06) !important; }
.sglv-ach-card { background: linear-gradient(135deg, rgba(16, 24, 36, 0.6), rgba(24, 34, 50, 0.4)) !important; border-color: rgba(102, 192, 244, 0.08) !important; }
.sglv-ach-card:hover { border-color: rgba(102, 192, 244, 0.3) !important; }
.sglv-ach-card::before { opacity: 0.45 !important; }
.sglv-ach-card.unlocked { border-color: rgba(102, 192, 244, 0.18) !important; background: linear-gradient(135deg, rgba(102, 192, 244, 0.05), rgba(13, 17, 23, 0.4)) !important; }
.sglv-ach-card.unlocked .sglv-ach-card-name { color: #d9e8f7 !important; }
.sglv-ach-card.unlocked .sglv-ach-card-pts { background: rgba(102, 192, 244, 0.1) !important; border-color: rgba(102, 192, 244, 0.25) !important; color: #a9d4f5 !important; }
.sglv-ach-card-new-tag { background: #1a9fff !important; }
.sglv-ach-card-progress { background: rgba(102, 192, 244, 0.08) !important; }
.sglv-ach-card.unlocked .sglv-ach-card-progress-fill { background: linear-gradient(90deg, #1a9fff, #66c0f4) !important; box-shadow: 0 0 8px rgba(102, 192, 244, 0.3) !important; }
.sglv-ach-card.locked .sglv-ach-card-progress-fill { background: linear-gradient(90deg, #4c6b87, #66c0f4) !important; box-shadow: none !important; }
.sglv-ach-card.unlocked .sglv-ach-card-progress-val { color: #7fb8e0 !important; }
.sglv-ach-content-count { background: rgba(102, 192, 244, 0.1) !important; color: #a9d4f5 !important; }
.sglv-ach-ring-bg { stroke: rgba(102, 192, 244, 0.1) !important; }
.sglv-ach-ring-val { background: linear-gradient(135deg, #1a9fff, #a3d5f7) !important; -webkit-background-clip: text !important; background-clip: text !important; }
.sglv-ach-steam-banner { background: linear-gradient(135deg, rgba(102, 192, 244, 0.08), rgba(26, 159, 255, 0.04)) !important; border-color: rgba(102, 192, 244, 0.15) !important; }
.sglv-ach-steam-banner::after { background: radial-gradient(circle, rgba(102, 192, 244, 0.1), transparent 60%) !important; }
.sglv-ach-steam-banner-icon { background: linear-gradient(135deg, rgba(102, 192, 244, 0.18), rgba(26, 159, 255, 0.1)) !important; }
.sglv-ach-steam-banner-icon svg { color: #66c0f4 !important; }
.sglv-ach-steam-banner-val { background: linear-gradient(135deg, #66c0f4, #22d3ee) !important; -webkit-background-clip: text !important; background-clip: text !important; }
.sglv-ach-user-pts strong { color: #a9d4f5 !important; }
`;

    const CSS_INLINE = [
        CSS_ACHIEVEMENT,
        CSS_SHOWCASE,
        CSS_CLOUDSAVE,
        CSS_STAGE,
        CSS_HEADER,
        CSS_SGIS_ENHANCE,
        CSS_TOAST,
        CSS_APIKEY_GUIDE,
        CSS_SETTINGS,
        CSS_KPI,
        CSS_SUBSTATUS,
        CSS_COVER,
        CSS_PRICE,
        CSS_LOAD
    ].join('');
    GM_addStyle(CSS_INLINE);

    // ==================== v2.11.40: 主题层运行时（注册表 + 应用函数） ====================
    // 设计: 共享库蓝基底(:root --sglv-*) → CSS_INLINE 模块样式 → 主题覆盖层(本函数注入,
    // <style id="sglv-theme-style"> 挂 head 末尾,层级与原 CSS_SGIS_OVERRIDE 在 CSS_INLINE 末尾等价)。
    // getThemeId 依赖 storage(定义于下方 L~5800),仅在调用时求值——boot 调用位于 storage 定义之后。
    const SGLV_THEMES = {
        purple: { id: 'purple', zh: '典雅紫', en: 'Elegant Purple', css: () => CSS_THEME_PURPLE },
        blue:   { id: 'blue',   zh: '经典蓝', en: 'Classic Blue',   css: () => CSS_THEME_BLUE },
    };
    const DEFAULT_SGLV_THEME = 'purple';

    function getThemeId() {
        try {
            const v = storage.getUiTheme();
            return SGLV_THEMES[v] ? v : DEFAULT_SGLV_THEME;
        } catch (e) { return DEFAULT_SGLV_THEME; }
    }

    function applySglvTheme(id) {
        const theme = SGLV_THEMES[id] || SGLV_THEMES[DEFAULT_SGLV_THEME];
        document.documentElement.setAttribute('data-sglv-theme', theme.id);
        let el = document.getElementById('sglv-theme-style');
        if (!el) {
            el = document.createElement('style');
            el.id = 'sglv-theme-style';
        }
        el.textContent = theme.css();
        // v2.11.40: 每次应用都重挂 head 末尾——收藏库(sglv-game-collection)首次开面板才懒注入
        // 其 <style>(物理位置晚于本元素),appendChild 移动节点保证主题层在层叠顺序上始终最后
        document.head.appendChild(el);
        window.dispatchEvent(new CustomEvent('sglv-theme-changed', { detail: { themeId: theme.id } }));
        return theme.id;
    }


    // v2.9.36: 我的成就标签页 — 左右布局重构（参考设计图3）
    // v2.9.59: 参考成就优化版设计,增强玻璃态/渐变/微光动画/稀有度边框
    // CSS 已提取到顶部: CSS_ACHIEVEMENT

    // v2.9.90: 个人展柜标签页样式
    // CSS 已提取到顶部: CSS_SHOWCASE

    // v2.9.34: 云存档标签页样式
    // CSS 已提取到顶部: CSS_CLOUDSAVE

    // v2.9.15: StageProgress 多阶段进度条样式
    // CSS 已提取到顶部: CSS_STAGE

    // v2.9.22: 紧凑页头 + tabs 移入 header（参考 steam-friend-manager 1.2.5 sfd-tab-bar / sfd-tab-btn 风格）
    // CSS 已提取到顶部: CSS_HEADER

    // v2.9.15: SGIS 侧边栏视觉增强（tab 动画 + 标题图标精致化 + 状态点）
    // CSS 已提取到顶部: CSS_SGIS_ENHANCE

    // v2.8.3: Toast 通知 + spinner 动画样式
    // CSS 已提取到顶部: CSS_TOAST

    // ==================== v2.9.28: 右下角 API Key 引导提示卡片样式 ====================
    // 形态参考 GM_notification 的右下角通知，但 GM_notification 需要系统级通知权限且
    // 点击后无法直接操作页面，故用页面内自绘卡片实现，点击"打开设置"可直接跳转设置视图。
    // CSS 已提取到顶部: CSS_APIKEY_GUIDE

    // ==================== v2.9.28: 设置页（集成在游戏库主面板内）样式 ====================
    // CSS 已提取到顶部: CSS_SETTINGS

    // v2.9.0: 进包/卡牌 KPI 卡片颜色 + badge 样式
    // v2.9.3: 卡片一行不换行 + 可点击筛选 + active 高亮（合并自 2.9.0 思路）
    // CSS 已提取到顶部: CSS_KPI

    // CSS 已提取到顶部: CSS_SUBSTATUS

    // v2.9.31: 游戏橱窗——横版封面视图 + 卡片增强 + 排版优化
    // CSS 已提取到顶部: CSS_COVER

    // ==================== I18N ====================
    const isZh = (navigator.language || '').toLowerCase().startsWith('zh');
    const T = {
        title: isZh ? '游戏库' : 'Game Library',
        tabOwned: isZh ? '游戏橱窗' : 'Game Showcase',
        // v2.9.90: 个人展柜标签页
        tabShowcase: isZh ? '个人展柜' : 'Showcase',
        tabPublisher: isZh ? '系列分类' : 'By Series',
        tabTrend: isZh ? '入库趋势' : 'Acquisition Trends',
        // v2.4.3: 入库趋势动态（趋势图 + 入库时间线）
        trendChartTitle: isZh ? '入库趋势图' : 'Trend Chart',
        trendTimelineTitle: isZh ? '入库时间线' : 'Acquisition Timeline',
        trendTimelineTotal: isZh ? '入库总数' : 'Total',
        // v2.9.48: 入库频率分析
        trendFreqTitle: isZh ? '入库频率分析' : 'Acquisition Frequency',
        trendTabTimeline: isZh ? '入库时间线' : 'Timeline',
        trendTabFrequency: isZh ? '频率分析' : 'Frequency',
        trendKpiThisYear: isZh ? '今年入库' : 'This Year',
        trendKpiAvgYear: isZh ? '年均入库' : 'Avg / Year',
        trendKpiPeakYear: isZh ? '峰值年份' : 'Peak Year',
        trendKpiRecent30: isZh ? '近30天' : 'Last 30 Days',
        trendKpiRecent90: isZh ? '近90天' : 'Last 90 Days',
        trendKpiActiveDays: isZh ? '活跃天数' : 'Active Days',
        trendKpiWeeklyAvg: isZh ? '周均入库' : 'Weekly Avg',
        trendKpiGames: isZh ? '款' : 'games',
        trendFreqByMonth: isZh ? '月度入库频率' : 'Monthly Frequency',
        trendFreqByWeekday: isZh ? '星期分布' : 'Weekday Distribution',
        trendFreqByHour: isZh ? '时段分布' : 'Hourly Distribution',
        trendFreqSummary: isZh ? '频率摘要' : 'Frequency Summary',
        trendFreqPeakMonth: isZh ? '最活跃月份' : 'Peak Month',
        trendFreqPeakWeekday: isZh ? '最活跃星期' : 'Peak Weekday',
        trendFreqPeakHour: isZh ? '最活跃时段' : 'Peak Hour',
        trendFreqStreak: isZh ? '最长连续天数' : 'Longest Streak',
        trendFreqDays: isZh ? '天' : 'days',
        trendFreqWeekdayLong: isZh ? '周日,周一,周二,周三,周四,周五,周六' : 'Sun,Mon,Tue,Wed,Thu,Fri,Sat',
        trendFreqHrLabel: isZh ? '时' : 'h',
        tabSettings: isZh ? '设置' : 'Settings',
        searchPlaceholder: isZh ? '搜索游戏名称...' : 'Search game name...',
        noData: isZh ? '暂无游戏数据，请点击右上角刷新按钮' : 'No game data. Click the refresh button at the top right.',
        noApiKey: isZh ? '请先登录 Steam 商店，或在设置中配置 API Key' : 'Login to Steam Store or configure API Key in Settings.',
        apiKeyLabel: 'Steam Web API Key',
        steamIdLabel: isZh ? 'SteamID64（留空自动检测）' : 'SteamID64 (auto-detect if empty)',
        save: isZh ? '保存设置' : 'Save',
        saved: isZh ? '已保存' : 'Saved',
        totalGames: isZh ? '总游戏数' : 'Total Games',
        ownedInDb: isZh ? '数据库已拥有' : 'Owned in DB',
        missingInDb: isZh ? '数据库未拥有' : 'Missing in DB',
        ownership: isZh ? '拥有率' : 'Ownership',
        page: isZh ? '页' : 'Page',
        prev: isZh ? '上一页' : 'Prev',
        next: isZh ? '下一页' : 'Next',
        first: isZh ? '首页' : 'First',
        last: isZh ? '末页' : 'Last',
        jumpTo: isZh ? '跳至' : 'Go to',
        pageOf: isZh ? '共' : 'of',
        owned: isZh ? '已拥有' : 'Owned',
        missing: isZh ? '未拥有' : 'Missing',
        all: isZh ? '全部' : 'All',
        cardView: isZh ? '卡片' : 'Card',
        coverView: isZh ? '横版封面' : 'Wide Cover',
        listView: isZh ? '列表' : 'List',
        fetchSuccess: isZh ? '获取成功，共 {n} 款游戏' : 'Fetched {n} games',
        fetchFail: isZh ? '获取失败' : 'Fetch failed',
        apiKeyHelp: isZh
            ? '脚本会自动从 Steam 商店页面获取登录凭证（access_token），无需配置 API Key 即可使用。如需获取更多数据（如游戏时长），可配置 <b>API Key</b>：打开 <a href="https://steamcommunity.com/dev/apikey" target="_blank">steamcommunity.com/dev/apikey</a> → 填写域名 → 注册即可。'
            : 'The script auto-detects login credentials from the Steam store page. API Key is optional for extra data (playtime). Get a free <b>API Key</b>: Visit <a href="https://steamcommunity.com/dev/apikey" target="_blank">steamcommunity.com/dev/apikey</a> → Enter domain → Register.',
        tabDelisted: isZh ? '绝版游戏' : 'Delisted Games',
        delistedTotal: isZh ? '绝版总数' : 'Total Delisted',
        delistedOwned: isZh ? '已拥有绝版' : 'Owned Delisted',
        delistedMissing: isZh ? '未拥有绝版' : 'Missing Delisted',
        delistedOwnership: isZh ? '绝版拥有率' : 'Delisted Ownership',
        delistedSearch: isZh ? '搜索绝版游戏...' : 'Search delisted games...',
        typeAll: isZh ? '全部类型' : 'All Types',
        typeDelisted: isZh ? '已下架' : 'Delisted',
        typePurchaseDisabled: isZh ? '购买已禁用' : 'Purchase Disabled',
        typeF2P: isZh ? 'F2P不可用' : 'F2P Unavailable',
        typeRetailOnly: isZh ? '仅零售' : 'Retail Only',
        typeTestApp: isZh ? '测试应用' : 'Test App',
        delistedOwners: isZh ? '拥有占比' : 'Owner %',
        delistedDate: isZh ? '下架时间' : 'Delisted Date',
        delistedAchievements: isZh ? '成就数' : 'Achievements',
        delistedKeyshops: isZh ? 'Keyshop价格' : 'Keyshop Price',
        // 游玩时长标签页
        tabPlaytime: isZh ? '统计仪表' : 'Stats',
        tabPlaydata: isZh ? '游玩数据' : 'Play Data',
        // v2.9.35: 我的成就标签页 — 重构版
        tabAchievements: isZh ? '我的成就' : 'Achievements',
        achCategoryCollector: isZh ? '收藏成就' : 'Collection',
        achCategoryPlaytime: isZh ? '时长成就' : 'Playtime',
        achCategoryMastery: isZh ? '专精成就' : 'Mastery',
        achCategoryDiversity: isZh ? '多元成就' : 'Diversity',
        achCategoryLoyalty: isZh ? '忠诚成就' : 'Loyalty',
        achCategorySpecial: isZh ? '特殊成就' : 'Special',
        achUnlocked: isZh ? '已解锁' : 'Unlocked',
        achLocked: isZh ? '未解锁' : 'Locked',
        achProgress: isZh ? '进度' : 'Progress',
        achNoData: isZh ? '暂无成就数据，请先获取游戏库' : 'No achievement data. Please fetch your library first.',
        achSummary: isZh ? '成就总览' : 'Achievement Summary',
        achSummaryDesc: isZh ? '已解锁' : 'Unlocked',
        achPoints: isZh ? '成就点数' : 'Points',
        achRarityCommon: isZh ? '普通' : 'Common',
        achRarityRare: isZh ? '稀有' : 'Rare',
        achRarityEpic: isZh ? '史诗' : 'Epic',
        achRarityLegendary: isZh ? '传奇' : 'Legendary',
        achRecentUnlocks: isZh ? '最近解锁' : 'Recent Unlocks',
        achTotalPoints: isZh ? '总成就点数' : 'Total Points',
        achCompletionRate: isZh ? '完成率' : 'Completion',
        achUnlockedAt: isZh ? '解锁于' : 'Unlocked at',
        achNoUnlocks: isZh ? '暂无已解锁成就' : 'No achievements unlocked yet',
        achResetConfirm: isZh ? '确定要重置所有成就解锁记录吗？此操作不可撤销。' : 'Reset all achievement unlock records? This cannot be undone.',
        achResetBtn: isZh ? '重置记录' : 'Reset',
        achAllCats: isZh ? '全部' : 'All',
        // v2.9.51: 全局游戏搜索（中文/拼音缩写/英文子串）
        globalSearchPh: isZh ? '搜索游戏（中文/拼音/英文）' : 'Search games (CN/Pinyin/EN)',
        gsHeader: isZh ? '搜索结果' : 'Search Results',
        gsEmpty: isZh ? '未匹配到游戏，试试中文/拼音首字母/英文子串' : 'No matches. Try CN/pinyin/English substring',
        gsMinLen: isZh ? '至少输入 1 个字符' : 'Type at least 1 character',
        gsTypeOwned: isZh ? '已拥有' : 'Owned',
        gsTypeWishlist: isZh ? '愿望单' : 'Wishlist',
        gsTypeStore: isZh ? '商店' : 'Store',
        gsType: isZh ? '类型' : 'Type',
        gsFooterHint: isZh ? '↑↓ 选择 · Enter 跳转 · Esc 关闭' : '↑↓ Navigate · Enter Open · Esc Close',
        gsOpenStore: isZh ? '在 Steam 商店打开' : 'Open in Steam Store',
        gsJumpToOwned: isZh ? '跳转到游戏库' : 'Jump to Library',
        gsJumpToWishlist: isZh ? '跳转到愿望单' : 'Jump to Wishlist',
        // v2.9.63: 游戏详情浮窗
        dpLoading: isZh ? '正在获取游戏详情…' : 'Loading game details…',
        dpError: isZh ? '获取详情失败' : 'Failed to load details',
        dpRetry: isZh ? '重试' : 'Retry',
        dpDeveloper: isZh ? '开发商' : 'Developer',
        dpPublisher: isZh ? '发行商' : 'Publisher',
        dpRelease: isZh ? '发行日期' : 'Release Date',
        dpPlatforms: isZh ? '平台' : 'Platforms',
        dpGenres: isZh ? '类型' : 'Genres',
        dpCategories: isZh ? '特色' : 'Features',
        dpPrice: isZh ? '价格' : 'Price',
        dpFree: isZh ? '免费' : 'Free',
        dpScreenshots: isZh ? '截图' : 'Screenshots',
        dpStorePage: isZh ? '商店页' : 'Store Page',
        dpJumpLib: isZh ? '跳转到游戏库' : 'Jump to Library',
        dpJumpWl: isZh ? '跳转到愿望单' : 'Jump to Wishlist',
        ptTotalHours: isZh ? '总游玩时长' : 'Total Hours',
        ptAvgHours: isZh ? '平均时长' : 'Avg Hours',
        ptPlayedCount: isZh ? '已游玩' : 'Played',
        ptUnplayedCount: isZh ? '从未游玩' : 'Unplayed',
        // v2.9.22: 统计仪表新增 KPI 卡片——游玩率 + 完成度
        ptPlayRate: isZh ? '游玩率' : 'Play Rate',
        ptCompletion: isZh ? '完成度' : 'Completion',
        ptDistTitle: isZh ? '时长分布' : 'Playtime Distribution',
        ptTopTitle: isZh ? '游玩时长 Top 20' : 'Top 20 by Playtime',
        ptAllTitle: isZh ? '全部游戏（按时长排序）' : 'All Games (by Playtime)',
        ptSearchPlaceholder: isZh ? '搜索游戏名称...' : 'Search game name...',
        ptRange0: isZh ? '从未游玩' : 'Never Played',
        ptRange1: isZh ? '0-1 小时' : '0-1 hours',
        ptRange2: isZh ? '1-10 小时' : '1-10 hours',
        ptRange3: isZh ? '10-50 小时' : '10-50 hours',
        ptRange4: isZh ? '50-100 小时' : '50-100 hours',
        ptRange5: isZh ? '100-500 小时' : '100-500 hours',
        ptRange6: isZh ? '500+ 小时' : '500+ hours',
        ptHours: isZh ? '小时' : 'hours',
        ptLastPlayed: isZh ? '最近游玩' : 'Last Played',
        ptNever: isZh ? '从未' : 'Never',
        ptNoData: isZh ? '暂无游玩时长数据，请先获取游戏库' : 'No playtime data. Fetch library first.',
        ptDays: isZh ? '天前' : 'days ago',
        ptFamilyCompare: isZh ? '家庭成员游玩时长对比' : 'Family Playtime Comparison',
        ptFetchingFamily: isZh ? '正在获取家庭成员数据…' : 'Fetching family data…',
        ptNoFamily: isZh ? '未加入家庭组或未配置 API Key' : 'No family group or API Key',
        ptNoApiKey: isZh ? '请先在设置中配置 API Key' : 'Configure API Key in settings first',
        ptNoToken: isZh ? '请先点击面板刷新按钮获取家庭组信息' : 'Click refresh to fetch family info first',
        ptRetryBtn: isZh ? '重试' : 'Retry',
        // v2.3.30: 入库热力图与家庭组占位
        ptLibHeatmap: isZh ? '入库热力图' : 'Library Heatmap',
        ptHeatmapNoData: isZh ? '暂无入库时间数据' : 'No acquisition time data',
        ptHeatmapLoading: isZh ? '加载中…' : 'Loading…',
        ptPending: isZh ? '待加入' : 'Pending',
        ptHeatmapTotal: isZh ? '总' : 'Total',
        ptHeatmapPeak: isZh ? '峰值' : 'Peak',
        ptHeatmapAvg: isZh ? '日均' : 'Avg/day',
        ptHeatmapLess: isZh ? '少' : 'Less',
        ptHeatmapMore: isZh ? '多' : 'More',
        ptHeatmapAcquired: isZh ? '款入库' : 'acquired',
        // v2.4.2: 热力图按年分割
        ptHeatmapAll: isZh ? '全部' : 'All',
        // v2.4.4: 热力图右下角近6月入库增量
        ptHeatmapMini6m: isZh ? '近6月入库增量' : '6-Month Acquisitions',
        // 新增：刷新与分类
        refreshBtnTitle: isZh ? '通过 API Key 刷新游戏库与时长' : 'Refresh library & playtime via API Key',
        refreshSuccess: isZh ? '游戏库与时长已刷新' : 'Library & playtime refreshed',
        categoryAll: isZh ? '全部' : 'All',
        categoryPlayed: isZh ? '已游玩' : 'Played',
        categoryUnplayed: isZh ? '未游玩' : 'Unplayed',
        categoryShared: isZh ? '共享' : 'Shared',
        categoryOwned: isZh ? '仅自己' : 'Owned Only',
        // v2.9.0: 进包/卡牌筛选与 KPI
        categoryBundled: isZh ? '进过包' : 'Bundled',
        categoryCards: isZh ? '有卡牌' : 'Has Cards',
        statsBundled: isZh ? '进包游戏' : 'Bundled Games',
        statsCards: isZh ? '有卡游戏' : 'Card Games',
        kpiInBundles: isZh ? '曾出现在 bundle 中' : 'appeared in bundles',
        kpiHasCards: isZh ? '含集换式卡牌' : 'has trading cards',
        sortBundleDesc: isZh ? '进包次数 多→少' : 'Bundle count ↓',
        bundleBadgeTip: isZh ? '曾出现在' : 'Appeared in',
        bundleBadgeUnit: isZh ? '个 bundle 中' : ' bundles',
        // v2.9.1: DLC 分离统计与仅 DLC 筛选
        categoryDlcOnly: isZh ? '仅 DLC' : 'DLC Only',
        statsDlcTotal: isZh ? 'DLC 总数' : 'DLC Total',
        kpiDlcMusic: isZh ? '音乐' : 'Music',
        kpiDlcBundled: isZh ? '进包' : 'Bundled',
        // v2.4.5: 库存排序
        sortLabel: isZh ? '排序方式' : 'Sort by',
        sortAppidAsc: isZh ? 'AppID 小→大' : 'AppID ↑',
        sortAppidDesc: isZh ? 'AppID 大→小' : 'AppID ↓',
        sortNameAsc: isZh ? '名称 A→Z' : 'Name A–Z',
        sortAcquiredDesc: isZh ? '入库 新→旧' : 'Newest first',
        sortAcquiredAsc: isZh ? '入库 旧→新' : 'Oldest first',
        sortPlaytimeDesc: isZh ? '时长 多→少' : 'Most played',
        sortLastPlayedDesc: isZh ? '最近游玩' : 'Recently played',
        statsTotalGames: isZh ? '总游戏数' : 'Total Games',
        statsTotalHours: isZh ? '总时长 (h)' : 'Total Hours',
        statsPlayed: isZh ? '已游玩' : 'Played',
        statsUnplayed: isZh ? '未游玩' : 'Unplayed',
        statsShared: isZh ? '共享游戏' : 'Shared Games',
        // v2.3.22: KPI 卡片子文本
        kpiAvgHours: isZh ? '均' : 'Avg',
        kpiPerGame: isZh ? '/款' : '/game',
        kpiRate: isZh ? '占比' : 'Rate',
        kpiOfTotal: isZh ? '占总数' : 'of total',
        // v2.9.22: 游玩率/完成度 KPI 副标题
        kpiPlayRateSub: isZh ? '已启动 ÷ 全部' : 'started ÷ total',
        kpiCompletionSub: isZh ? '深度游玩 ≥10h' : 'deep play ≥10h',
        kpiFromFamily: isZh ? '来自家庭组' : 'from family',
        kpiHours: isZh ? '小时' : 'hours',
        kpiMyCollection: isZh ? '我的收藏' : 'My Collection',
        kpiDedupMerge: isZh ? '合并去重' : 'Deduplicated',
        kpiFamilyMembers: isZh ? '位家庭成员' : 'family members',
        kpiYearSpan: isZh ? '年跨度' : 'year span',
        kpiDelisted: isZh ? '款绝版' : 'delisted',
        kpiCollected: isZh ? '已收藏' : 'collected',
        kpiToCollect: isZh ? '待收藏' : 'to collect',
        kpiCollectionProgress: isZh ? '收藏进度' : 'Collection Progress',
        delistedSubAll: isZh ? '全部绝版' : 'All Delisted',
        delistedSubOwned: isZh ? '已拥有' : 'Owned',
        delistedSubMissing: isZh ? '未拥有' : 'Missing',
        ptSourceApi: isZh ? 'API' : 'API',
        ptSourceScrape: isZh ? '页面抓取' : 'Scraped',
        ptTrendTitle: isZh ? '时长趋势' : 'Playtime Trend',
        ptTrendMonth: isZh ? '月' : 'Month',
        ptTrendQuarter: isZh ? '季' : 'Quarter',
        ptTrendYear: isZh ? '年' : 'Year',
        // AI 翻译总结
        aiSettingsTitle: isZh ? 'AI 模型配置' : 'AI Model Settings',
        aiApiUrlLabel: isZh ? 'AI API 地址' : 'AI API URL',
        aiApiKeyLabel: isZh ? 'AI API Key' : 'AI API Key',
        aiModelLabel: isZh ? '模型名称' : 'Model Name',
        aiApiUrlHelp: isZh ? '默认为 DeepSeek 官方 API 地址，也可填入其他兼容 OpenAI 格式的 API 地址' : 'Default is DeepSeek official API URL. Also supports OpenAI-compatible API endpoints.',
        aiModelHelp: isZh ? '默认为 deepseek-v4-pro，可修改为其他模型名称' : 'Default is deepseek-v4-pro. Can be changed to other model names.',
        aiNotConfigured: isZh ? '未配置 AI API Key，请在设置中配置' : 'AI API Key not configured. Set it in Settings.',
        aiTranslating: isZh ? 'AI 翻译总结中…' : 'AI translating & summarizing…',
        aiTranslateFail: isZh ? 'AI 翻译失败' : 'AI translation failed',
        aiToggleOriginal: isZh ? '原文' : 'Original',
        aiToggleSummary: isZh ? 'AI翻译总结' : 'AI Summary',
        // v2.10.0: AI 配置与 Steam AI Agent 插件共享
        aiSharedHint: isZh ? '检测到 Steam AI Agent 插件，AI 配置已自动共享' : 'Steam AI Agent detected, AI config is shared automatically',
        ptNoActivity: isZh ? '近期无游玩活动' : 'No recent activity',
        globalSettings: isZh ? '全局设置' : 'Global Settings',
        // v2.11.40: 外观主题切换（典雅紫/经典蓝，主题名取自 SGLV_THEMES 注册表）
        themeSection: isZh ? '外观主题' : 'Appearance',
        themeDesc: isZh ? '选择界面配色主题，保存后立即生效（无需刷新页面）。' : 'Pick the UI color theme. Applies instantly on save (no reload needed).',
        themePurpleDesc: isZh ? '紫青炫彩主调 · 默认' : 'Violet accent · default',
        themeBlueDesc: isZh ? 'Steam 经典蓝主调' : 'Steam classic blue accent',
        // v2.9.28: 设置集成进主面板——返回按钮与右下角引导提示文案
        settingsBack: isZh ? '返回游戏库' : 'Back to Library',
        apiKeyGuideTitle: isZh ? '尚未配置 Steam API Key' : 'Steam API Key missing',
        apiKeyGuideDesc: isZh
            ? '配置 API Key 可获取游玩时长、家庭组等更完整数据。点击游戏库面板右上角 ⚙ 设置按钮进行配置，也可以直接尝试免 Key 抓取。'
            : 'An API Key unlocks playtime & family data. Click the ⚙ Settings button in the library panel to configure it, or try fetching without a key.',
        apiKeyGuideOpen: isZh ? '打开设置' : 'Open Settings',
        apiKeyGuideLater: isZh ? '稍后再说' : 'Later',
        steamApiSection: isZh ? 'Steam API 配置' : 'Steam API Settings',
        // v2.9.79: ITAD 价格增强配置
        itadSection: isZh ? 'ITAD 价格增强' : 'ITAD Price Enhancement',
        itadApiKeyLabel: 'ITAD API Key',
        itadDesc: isZh
            ? '配置 ITAD (IsThereAnyDeal) API 密钥后，价格页面将增强为<b style="color:#a7d54f">15+ 区域比价</b>、<b style="color:#a7d54f">多商店价格对比</b>（GOG/Fanatical/Humble 等）、<b style="color:#a7d54f">活跃 Bundle</b> 展示及<b style="color:#a7d54f">历史最低价</b>徽章。未配置时自动回退到基础模式。'
            : 'With an ITAD API key, the price tab enhances to <b style="color:#a7d54f">15+ region comparison</b>, <b style="color:#a7d54f">multi-store pricing</b> (GOG/Fanatical/Humble), <b style="color:#a7d54f">active bundles</b>, and <b style="color:#a7d54f">historical low</b> badges. Falls back to basic mode if not configured.',
        itadKeyPlaceholder: '32位十六进制密钥 (如 a9d468...14b725)',
        itadTestConn: isZh ? '测试连接' : 'Test Connection',
        itadTesting: isZh ? '测试中…' : 'Testing…',
        itadConnSuccess: isZh ? '连接成功' : 'Connected',
        itadConnFail: isZh ? '连接失败' : 'Failed',
        itadConnNoKey: isZh ? '未配置' : 'Not configured',
        itadHelpTitle: isZh ? '密钥申请方法' : 'How to get a key',
        itadHelpSteps: isZh
            ? '① 访问 <a href="https://isthereanydeal.com" target="_blank" style="color:#66c0f4">isthereanydeal.com</a> → 注册账号并<b>验证邮箱</b>（影响速率限额）<br>② 进入 <a href="https://isthereanydeal.com/apps" target="_blank" style="color:#66c0f4">isthereanydeal.com/apps</a> → 点击 <b>Register App</b><br>③ 填写应用名称（不可与他人重复）→ <b>Submit</b><br>④ 在 <b>API Keys</b> 区域复制 32 位密钥 → 粘贴到上方输入框<br>⑤ 点击「测试连接」验证 → 保存设置即可生效<br><span style="color:#555">限额：每 5 分钟 1000 次请求 · 可商用但需标注 ITAD 来源</span>'
            : '① Visit <a href="https://isthereanydeal.com" target="_blank" style="color:#66c0f4">isthereanydeal.com</a> → Register & <b>verify email</b> (affects rate limit)<br>② Go to <a href="https://isthereanydeal.com/apps" target="_blank" style="color:#66c0f4">isthereanydeal.com/apps</a> → Click <b>Register App</b><br>③ Enter app name (must be unique) → <b>Submit</b><br>④ Copy the 32-char key from <b>API Keys</b> → Paste above<br>⑤ Click "Test Connection" → Save Settings<br><span style="color:#555">Limit: 1000 requests / 5 min · Commercial use OK with ITAD attribution</span>',
        // AI 价格预测 (v2.3)
        aiPredictSection: isZh ? 'AI 价格预测配置' : 'AI Price Prediction Settings',
        aiPredictModes: isZh ? '预测模式' : 'Prediction Modes',
        aiPredictModesHelp: isZh ? '选择一种或多种预测模式，AI将基于所选模式进行分析' : 'Select one or more prediction modes for AI analysis',
        aiPredictModeSeasonal: isZh ? '季节性折扣预测' : 'Seasonal Discount',
        aiPredictModeSeasonalDesc: isZh ? '基于Steam促销活动节点(夏促/秋促/冬促/春促)预测折扣时机' : 'Predict based on Steam sale events (Summer/Autumn/Winter/Spring)',
        aiPredictModeTrend: isZh ? '价格趋势预测' : 'Price Trend',
        aiPredictModeTrendDesc: isZh ? '基于历史折扣间隔和幅度趋势预测下次折扣' : 'Predict next discount based on historical intervals and depth trends',
        aiPredictModeLowest: isZh ? '史低突破预测' : 'Historical Low',
        aiPredictModeLowestDesc: isZh ? '预测达到或突破历史最低价的可能性与时机' : 'Predict probability and timing of reaching or breaking historical low',
        aiPredictModeReview: isZh ? '评价动量预测' : 'Review Momentum',
        aiPredictModeReviewDesc: isZh ? '结合游戏口碑变化趋势评估折扣力度' : 'Assess discount depth based on review momentum changes',
        aiPredictModeSimilar: isZh ? '相似历史预测' : 'Similar History',
        aiPredictModeSimilarDesc: isZh ? '匹配相似价格历史片段预测折扣模式' : 'Match similar price history patterns to predict discounts',
        aiPredictBtn: isZh ? 'AI预测' : 'AI Predict',
        aiPredicting: isZh ? 'AI预测分析中…' : 'AI predicting…',
        aiPredictFail: isZh ? 'AI预测失败' : 'AI prediction failed',
        aiPredictNoData: isZh ? '需要先获取历史价格数据' : 'Need price history data first',
        aiPredictNoKey: isZh ? '未配置AI API Key，请在设置中配置' : 'AI API Key not configured. Set it in Settings.',
        aiPredictResult: isZh ? 'AI价格预测分析' : 'AI Price Prediction',
        aiPredictConfidence: isZh ? '把握度' : 'Confidence',
        aiPredictDays: isZh ? '天后' : 'days later',
        aiPredictBestTime: isZh ? '最佳入手时机' : 'Best Time to Buy',
        aiPredictSaleEvent: isZh ? '促销节点' : 'Sale Event',
        aiPredictRecommendation: isZh ? '购买建议' : 'Recommendation',
        // ====== 愿望单标签页 (v2.3.19) ======
        tabWishlist: isZh ? '愿望单' : 'Wishlist',
        wlTotal: isZh ? '愿望单总数' : 'Wishlist Total',
        wlTotalValue: isZh ? '愿望单总价值' : 'Total Value',
        wlDiscounted: isZh ? '打折中' : 'On Sale',
        wlInLibrary: isZh ? '已在库' : 'In Library',
        wlAvgDiscount: isZh ? '平均折扣' : 'Avg Discount',
        wlSearch: isZh ? '搜索愿望单游戏...' : 'Search wishlist...',
        wlNoData: isZh ? '暂无愿望单数据' : 'No wishlist data',
        wlFetching: isZh ? '正在获取愿望单数据…' : 'Fetching wishlist…',
        wlFetchFail: isZh ? '愿望单获取失败，请点击右上角刷新按钮重试' : 'Wishlist fetch failed, click refresh to retry',
        wlFetchSuccess: isZh ? '愿望单获取成功，共 {n} 款' : 'Fetched {n} wishlist items',
        wlLoadStage1: isZh ? '正在抓取愿望单页面…' : 'Fetching wishlist page…',
        wlLoadStage2: isZh ? '正在补全商店数据…' : 'Enriching store data…',
        wlLoadStage3: isZh ? '正在补全游戏详情…' : 'Enriching game details…',
        wlLoadSub: isZh ? '正在从 Steam 获取愿望单数据，请稍候' : 'Loading wishlist data from Steam, please wait',
        wlRefreshTip: isZh ? '重新获取愿望单' : 'Refetch wishlist',
        wlFilterDiscount: isZh ? '打折中' : 'On Sale',
        wlFilterInLibrary: isZh ? '已在库' : 'In Library',
        wlFilterFree: isZh ? '免费' : 'Free',
        wlFilterComingSoon: isZh ? '即将发售' : 'Coming Soon',
        wlComingSoon: isZh ? '即将发售' : 'Coming Soon',
        wlKpiComingSoon: isZh ? '即将发售' : 'Coming Soon',
        wlTypeDist: isZh ? '类型分布' : 'Type Distribution',
        wlUpcoming: isZh ? '待上市游戏' : 'Upcoming Games',
        wlUpcoming30d: isZh ? '30天内' : '<30d',
        wlUpcoming90d: isZh ? '90天内' : '<90d',
        wlUpcomingFar: isZh ? '更远' : 'Far',
        wlUpcomingNoDate: isZh ? '未定日期' : 'No Date',
        wlDiscountDist: isZh ? '折扣分布' : 'Discount Distribution',
        wlTopDiscount: isZh ? 'TOP 折扣' : 'TOP Discounts',
        wlFree: isZh ? '免费' : 'Free',
        wlNoPrice: isZh ? '暂无价格' : 'N/A',
        wlTypeGame: isZh ? '游戏' : 'Games',
        wlTypeDlc: 'DLC',
        wlTypeSoftware: isZh ? '软件' : 'Software',
        wlTypeOther: isZh ? '其他' : 'Other',
        wlDiscOff: isZh ? '无折扣' : 'No Discount',
        wlDateAdded: isZh ? '添加于' : 'Added',
        wlTopTags: isZh ? '热门标签 TOP 15' : 'Top 15 Tags',
        wlTimeline: isZh ? '添加时间线' : 'Added Timeline',
        // ====== 愿望单仪表盘增强 (v2.3.21) ======
        wlPriceDist: isZh ? '价格区间分布' : 'Price Range Distribution',
        wlAddedByYear: isZh ? '按年添加趋势' : 'Added by Year',
        wlKpiTotalValue: isZh ? '总价值' : 'Total Value',
        wlKpiOnSale: isZh ? '打折中' : 'On Sale',
        // v2.9.103: 混合币种聚合提示(部分条目缺汇率被排除时在 KPI 副文案提示)
        wlMultiCurHint: isZh ? '部分条目币种无汇率,已按可折算部分统计' : 'Some currencies lack rates; partial total shown',
        wlKpiFree: isZh ? '免费游戏' : 'Free Games',
        wlKpiInLib: isZh ? '已入库' : 'In Library',
        wlEarliest: isZh ? '最早于' : 'Earliest',
        wlAvgPrice: isZh ? '均价' : 'Avg',
        wlMedian: isZh ? '中位' : 'Median',
        wlRate: isZh ? '占比' : 'Rate',
        wlAvgDisc: isZh ? '均折' : 'Avg',
        wlMaxDisc: isZh ? '最高' : 'Max',
        wlPurchaseRate: isZh ? '购入率' : 'Purchase Rate',
        wlPriceFree: isZh ? '免费' : 'Free',
        wlPriceLt50: '<50',
        wlPrice50_100: '50-100',
        wlPrice100_200: '100-200',
        wlPrice200_500: '200-500',
        wlPriceGte500: '500+',
        wlUncatEmpty: isZh ? '无分类 {n} 款' : '{n} uncategorized',
        wlRankTip: isZh ? '愿望单排序位次（可在 Steam 愿望单页面拖拽调整）' : 'Wishlist rank (drag to reorder on your Steam wishlist page)',
        // ====== 愿望单我的类别统计 (v2.8.0) ======
        wlCatStats: isZh ? '我的类别统计' : 'Category Stats',
        wlCatStatsCats: isZh ? '共 {n} 个类别' : '{n} categories',
        wlCatStatsNoCat: isZh ? '未分类' : 'Uncategorized',
        wlCatStatsClick: isZh ? '点击筛选此类别' : 'Click to filter by category',
        wlCatStatsActive: isZh ? '类别: ' : 'Category: ',
        wlFamilyShared: isZh ? '家庭共享' : 'Family Shared',
        wlDisc0: isZh ? '无折扣' : 'None',
        wlDisc1_25: '1-25%',
        wlDisc26_50: '26-50%',
        wlDisc51_75: '51-75%',
        wlDisc76plus: '76%+',
        // ====== PS 会免标签页 (v2.6.0) ======
        tabPsplus: isZh ? 'PS 会免' : 'PS Plus',
        psSearch: isZh ? '搜索游戏名称 / AppID...' : 'Search name / AppID...',
        psSortDateDesc: isZh ? '日期 ↓（新到旧）' : 'Date ↓ (new to old)',
        psSortDateAsc: isZh ? '日期 ↑（旧到新）' : 'Date ↑ (old to new)',
        psSortTierAsc: isZh ? '档位 ↑（必备→高级）' : 'Tier ↑ (Essential→Premium)',
        psSortTierDesc: isZh ? '档位 ↓（高级→必备）' : 'Tier ↓ (Premium→Essential)',
        psSortNameAsc: isZh ? '名称 A→Z' : 'Name A→Z',
        psRefreshTip: isZh ? '重新获取 PS 会免数据' : 'Reload PS Plus data',
        psTierEssential: isZh ? '必备' : 'Essential',
        psTierExtra: isZh ? '升级' : 'Extra',
        psTierPremium: isZh ? '高级' : 'Premium',
        psStatusAll: isZh ? '全部状态' : 'All Status',
        psStatusIn: isZh ? '在库' : 'In Library',
        psStatusActive: isZh ? '领取中' : 'Claimable',
        psStatusExpired: isZh ? '已截止/出库' : 'Expired/Out',
        psStatusLeaving: isZh ? '即将出库' : 'Leaving Soon',
        psKpiTotal: isZh ? '会免总数' : 'Total Titles',
        psKpiMonthly: isZh ? '每月可领' : 'Monthly',
        psKpiCatalog: isZh ? '游戏目录' : 'Catalog',
        psKpiSteamOwned: isZh ? 'Steam 已拥有' : 'Owned on Steam',
        psKpiSteamTotal: isZh ? '共 {n} 款有 Steam 版' : '{n} on Steam',
        psUpdated: isZh ? '更新于' : 'Updated',
        psLoading: isZh ? '正在获取 PS 会免数据...' : 'Loading PS Plus data...',
        psLoadError: isZh ? 'PS 会免数据获取失败，请稍后点击刷新重试' : 'Failed to load PS Plus data. Click refresh to retry.',
        // ====== 通用：Steam 在库标识（v2.7.9，区分 PS 在库状态） ======
        steamInLib: isZh ? 'steam在库' : 'Steam Owned',
        // ====== Epic 赠送标签页 (v2.7.9) ======
        tabEpic: isZh ? 'Epic赠送' : 'Epic Free',
        epicSearch: isZh ? '搜索名称 / AppID...' : 'Search name / AppID...',
        epicSortAppidDesc: isZh ? 'AppID ↓（大→小）' : 'AppID ↓ (high to low)',
        epicSortAppidAsc: isZh ? 'AppID ↑（小→大）' : 'AppID ↑ (low to high)',
        epicSortNameAsc: isZh ? '名称 A→Z' : 'Name A→Z',
        epicRefreshTip: isZh ? '从 GitHub 数据源更新 Epic 赠送名单' : 'Refresh Epic free list from GitHub data source',
        epicImportTip: isZh ? '手动导入 Epic 赠送数据 JSON' : 'Import Epic free games JSON',
        epicExportTip: isZh ? '一键导出 Epic 赠送数据 JSON（含本地缓存历史全量）' : 'Export Epic free games JSON (incl. local history)',
        epicExportOk: isZh ? '已导出 {n} 款 Epic 赠送游戏' : 'Exported {n} Epic free games',
        epicExportEmpty: isZh ? '没有可导出的 Epic 赠送数据' : 'No Epic data to export',
        epicExportFail: isZh ? '自动下载失败，请手工复制以下 JSON：' : 'Auto download failed. Copy JSON below:',
        epicKpiTotal: isZh ? 'Epic赠送总数' : 'Epic Free Titles',
        epicKpiOwned: isZh ? 'steam在库' : 'Steam Owned',
        epicKpiNotOwned: isZh ? '未拥有' : 'Not Owned',
        epicKpiOwnedSub: isZh ? '已在 Steam 家庭共享库' : 'In Steam family library',
        epicLoading: isZh ? '正在获取 Epic 赠送数据...' : 'Loading Epic free data...',
        epicLoadError: isZh ? 'Epic 数据获取失败，可点击导入按钮手动导入 JSON，或用「一键导出/导入」在设备间同步' : 'Failed to load Epic data. Try manual JSON import.',
        epicNoData: isZh ? '暂无 Epic 赠送数据，请点击刷新或导入' : 'No Epic data. Click refresh or import.',
        epicImportPrompt: isZh ? '请粘贴 Epic 赠送数据 JSON：\n支持 [appid,...] / {"appids":[...]} / {"games":[{"appid":...}]}\n（与「E宝的爱标识助手」共享存储，自动合并）' : 'Paste Epic free games JSON:\n[appid,...] / {"appids":[...]} / {"games":[{"appid":...}]}',
        epicImportOk: isZh ? '导入成功，共 {n} 款' : 'Imported {n} games',
        epicImportNoData: isZh ? '未识别到有效 appid' : 'No valid appid found',
        epicImportFail: isZh ? 'JSON 解析失败：' : 'JSON parse failed: ',
        epicBadgeFree: isZh ? 'Epic免费' : 'Epic Free',
        epicBadgeNotOwned: isZh ? '未拥有' : 'Not Owned',
        epicSourceKeylol: isZh ? '其乐论坛' : 'keylol',
        epicSourceLocal: isZh ? '本地缓存' : 'Local',
        epicSourceManual: isZh ? '内置名单' : 'Built-in',
        epicSourceImport: isZh ? '手动导入' : 'Imported',
        // ====== 年度大作标签页 (v2.9.7) ======
        tabGoty: isZh ? '年度大作' : 'GotY',
        gotySearch: isZh ? '搜索游戏名称 / AppID...' : 'Search name / AppID...',
        gotySortDateAsc: isZh ? '发售日 ↑（早→晚）' : 'Date ↑ (early to late)',
        gotySortDateDesc: isZh ? '发售日 ↓（晚→早）' : 'Date ↓ (late to early)',
        gotySortNameAsc: isZh ? '名称 A→Z' : 'Name A→Z',
        gotySortAppidAsc: isZh ? 'AppID ↑（小→大）' : 'AppID ↑ (low to high)',
        gotyRefreshTip: isZh ? '重新获取年度大作数据' : 'Reload GotY data',
        gotyFilterAll: isZh ? '全部' : 'All',
        gotyFilterOwned: isZh ? 'steam在库' : 'Steam Owned',
        gotyFilterNotOwned: isZh ? '未拥有' : 'Not Owned',
        gotyKpiTotal: isZh ? '年度大作总数' : 'GotY Total',
        gotyKpiOwned: isZh ? 'steam在库' : 'Steam Owned',
        gotyKpiNotOwned: isZh ? '未拥有' : 'Not Owned',
        gotyKpiOwnedSub: isZh ? '已在 Steam 家庭共享库' : 'In Steam family library',
        gotyLoading: isZh ? '正在获取年度大作数据...' : 'Loading GotY data...',
        gotyLoadError: isZh ? '年度大作数据获取失败，请点击刷新重试' : 'Failed to load GotY data. Click refresh to retry.',
        gotyNoData: isZh ? '暂无年度大作数据' : 'No GotY data',
        gotyBadgeGoty: isZh ? '年度大作' : 'GotY',
        gotyBadgeNotOwned: isZh ? '未拥有' : 'Not Owned',
        gotyReleaseDate: isZh ? '发售' : 'Release',
        gotySourceGithub: isZh ? 'GitHub' : 'GitHub',
        gotySourceCache: isZh ? '本地缓存' : 'Local',
        gotyFilterAllYears: isZh ? '全部年度' : 'All Years',
        // ====== 锁区游戏标签页 (v2.9.12) ======
        tabBlocked: isZh ? '锁区游戏' : 'Region Blocked',
        blockedSearch: isZh ? '搜索名称 / AppID...' : 'Search name / AppID...',
        blockedSortAppidDesc: isZh ? 'AppID ↓（大→小）' : 'AppID ↓ (high to low)',
        blockedSortAppidAsc: isZh ? 'AppID ↑（小→大）' : 'AppID ↑ (low to high)',
        blockedSortNameAsc: isZh ? '名称 A→Z' : 'Name A→Z',
        blockedSortDateDesc: isZh ? '变更日期 ↓（新→旧）' : 'Changed ↓ (new to old)',
        blockedSortDateAsc: isZh ? '变更日期 ↑（旧→新）' : 'Changed ↑ (old to new)',
        blockedRefreshTip: isZh ? '重新获取锁区游戏数据' : 'Reload blocked data',
        blockedImportTip: isZh ? '手动导入锁区游戏 JSON' : 'Import blocked games JSON',
        blockedFilterAll: isZh ? '全部' : 'All',
        blockedFilterOwned: isZh ? 'steam在库' : 'Steam Owned',
        blockedFilterNotOwned: isZh ? '未拥有' : 'Not Owned',
        blockedKpiTotal: isZh ? '锁区总数' : 'Blocked Total',
        blockedKpiOwned: isZh ? 'steam在库' : 'Steam Owned',
        blockedKpiNotOwned: isZh ? '未拥有' : 'Not Owned',
        blockedKpiSubBanned: isZh ? 'Banned N · Purchase M · Regional K' : 'Banned N · Purchase M · Regional K',
        blockedLoading: isZh ? '正在获取锁区游戏数据...' : 'Loading blocked data...',
        blockedLoadError: isZh ? '锁区数据获取失败，可点击导入按钮手动导入，或稍后点击刷新重试' : 'Failed to load blocked data. Try import or retry later.',
        blockedNoData: isZh ? '暂无锁区游戏数据，请点击刷新或导入' : 'No blocked data. Click refresh or import.',
        blockedImportPrompt: isZh ? '请粘贴锁区游戏数据 JSON：\n支持 [{appid,name,...}] 数组格式\n或 srbb_blocked_apps 格式 {"appid":{"name":"...","at":...}}' : 'Paste blocked games JSON:\n[{appid,name,...}] array\nor srbb format {"appid":{"name":"...","at":...}}',
        blockedImportOk: isZh ? '导入成功，共 {n} 款' : 'Imported {n} games',
        blockedImportNoData: isZh ? '未识别到有效 appid' : 'No valid appid found',
        blockedImportFail: isZh ? 'JSON 解析失败：' : 'JSON parse failed: ',
        blockedBadgeOwned: isZh ? '在库' : 'Owned',
        blockedBadgeBanned: isZh ? '封禁' : 'Banned',
        blockedBadgePurchase: isZh ? '购买禁用' : 'Purchase Disabled',
        blockedBadgeRegional: isZh ? '区域变体' : 'Regional Variant',
        blockedBadgeManual: isZh ? '手动' : 'Manual',
        blockedChangedAt: isZh ? '变更' : 'Changed',
        // ====== 云存档标签页 (v2.9.34) ======
        tabCloudSave: isZh ? '云存档' : 'Cloud Saves',
        csTotalGames: isZh ? '云存档游戏' : 'Cloud Games',
        csTotalSize: isZh ? '总占用' : 'Total Size',
        csTotalFiles: isZh ? '文件总数' : 'Total Files',
        csAvgSize: isZh ? '平均大小' : 'Avg Size',
        csLargestSave: isZh ? '最大存档' : 'Largest Save',
        csTopSizes: isZh ? 'TOP 10 存档大小' : 'TOP 10 Save Sizes',
        csSizeDist: isZh ? '大小分布' : 'Size Distribution',
        csFileDist: isZh ? '文件数分布' : 'File Count Distribution',
        csGameList: isZh ? '游戏列表' : 'Game List',
        csSearch: isZh ? '搜索游戏名称...' : 'Search game name...',
        csSortSizeDesc: isZh ? '大小 ↓（大→小）' : 'Size ↓ (large to small)',
        csSortSizeAsc: isZh ? '大小 ↑（小→大）' : 'Size ↑ (small to large)',
        csSortFilesDesc: isZh ? '文件数 ↓' : 'Files ↓',
        csSortNameAsc: isZh ? '名称 A→Z' : 'Name A→Z',
        csRefreshTip: isZh ? '重新获取云存档数据及文件数' : 'Reload cloud save data & file counts',
        csFetching: isZh ? '正在获取云存档数据…' : 'Fetching cloud saves…',
        csFetchFail: isZh ? '云存档数据获取失败，请点击刷新重试' : 'Cloud save fetch failed. Click refresh to retry.',
        csFetchSuccess: isZh ? '获取成功，共 {n} 款游戏' : 'Fetched {n} games',
        csNoData: isZh ? '暂无云存档数据，请点击刷新获取' : 'No cloud save data. Click refresh to fetch.',
        csBadgeNew: isZh ? '新增' : 'NEW',
        csBadgeChanged: isZh ? '变化' : 'CHANGED',
        csBadgeRemoved: isZh ? '移除' : 'REMOVED',
        csUpdated: isZh ? '存档更新' : 'Saves updated',
        csFileCountUpdated: isZh ? '文件数更新' : 'File count updated',
        csFiles: isZh ? '文件' : 'files',
        csSizeLt1: '<1MB',
        csSize1_10: '1-10MB',
        csSize10_50: '10-50MB',
        csSize50_100: '50-100MB',
        csSize100plus: '100MB+',
        csFilesLt3: '<3',
        csFiles3_5: '3-5',
        csFiles5_10: '5-10',
        csFiles10plus: '10+',
        csLoginRequired: isZh ? '需要 Steam 登录态，请在 store.steampowered.com 登录后重试' : 'Steam login required. Please login on store.steampowered.com.',
        csSourceWeb: isZh ? '网页抓取' : 'Web scrape',
        csSourceCache: isZh ? '本地缓存' : 'Local cache',
        // v2.9.39: 后台静默刷新状态
        csBgRefreshing: isZh ? '后台更新中…' : 'Background updating…',
        csBgRefreshDone: isZh ? '后台更新完成，新增 {n} 款' : 'Background update done, +{n}',
        // ====== DLC 收藏标签页 (v2.9.32) ======
        tabDlc: isZh ? 'DLC收藏' : 'DLC Collection',
        dlcKpiTotal: isZh ? 'DLC 总数' : 'DLC Total',
        dlcKpiRegular: isZh ? '常规 DLC' : 'Regular DLC',
        dlcKpiMusic: isZh ? '音乐包' : 'Music Packs',
        dlcKpiBundled: isZh ? '进包 DLC' : 'Bundled DLC',
        dlcKpiPlayed: isZh ? '已游玩' : 'Played',
        dlcKpiSub: isZh ? '覆盖 {n} 款游戏' : 'Across {n} games',
        dlcKpiNoParent: isZh ? '未关联父游戏' : 'No parent',
        dlcSearch: isZh ? '搜索 DLC 或父游戏...' : 'Search DLC or parent...',
        dlcSortParent: isZh ? '按父游戏' : 'By Parent',
        dlcSortAppidDesc: isZh ? 'AppID ↓（大→小）' : 'AppID ↓ (high to low)',
        dlcSortAppidAsc: isZh ? 'AppID ↑（小→大）' : 'AppID ↑ (low to high)',
        dlcSortNameAsc: isZh ? '名称 A→Z' : 'Name A→Z',
        dlcSortType: isZh ? '按类型' : 'By Type',
        dlcFilterAll: isZh ? '全部' : 'All',
        dlcFilterDlc: isZh ? '常规' : 'Regular',
        dlcFilterMusic: isZh ? '音乐' : 'Music',
        dlcFilterBundled: isZh ? '进包' : 'Bundled',
        dlcFilterPlayed: isZh ? '已游玩' : 'Played',
        dlcGroupByParent: isZh ? '按父游戏' : 'By Parent',
        dlcFlatList: isZh ? '扁平' : 'Flat',
        dlcLoading: isZh ? '正在加载 DLC 数据库...' : 'Loading DLC database...',
        dlcLoadError: isZh ? 'DLC 数据加载失败，请稍后重试' : 'DLC data load failed. Please retry later.',
        dlcNoData: isZh ? '暂无 DLC，请先加载游戏库' : 'No DLC found. Load your library first.',
        dlcBadgeMusic: isZh ? '音乐' : 'Music',
        dlcBadgeBundle: isZh ? '包' : 'Bundle',
        dlcBadgePlayed: isZh ? '已玩' : 'Played',
        dlcComplete: isZh ? '收集完成度' : 'Completion',
        dlcUnknownParent: isZh ? '未知父游戏' : 'Unknown Parent',
    };

    // ==================== 状态管理 ====================
    const state = {
        activeTab: 'owned',
        viewMode: 'card',
        ownedFilter: 'all',
        ownedSort: 'appidAsc',   // v2.4.5: 库存排序方式（默认 AppID 升序）
        ownedGames: [],
        ownedAppIds: new Set(),
        isLoading: false,
        showSettings: false,
        searchQuery: '',
        page: 1,
        pageSize: 48,

        // ====== 愿望单标签页状态 (v2.3.19) ======
        wishlistGames: [],
        wishlistLoaded: false,
        wishlistLoading: false,
        wishlistLoadStage: 0,  // v2.9.47: 加载阶段 0=未开始 1=页面抓取 2=API补全 3=资料富集
        wishlistLoadProgress: 0,  // v2.9.47: 加载进度百分比
        wishlistSearch: '',
        wishlistFilter: 'all',      // 'all' | 'discount' | 'inlibrary' | 'coming' | 'category'
        wishlistPage: 1,
        wishlistPageSize: 48,
        wishlistViewMode: 'card',
        wishlistCategoryNames: {}, // v2.3.23: 用户自定义类别 ID -> 名称映射（我的类别）
        wishlistCategoryFilter: null, // v2.8.0: 当前选中的类别筛选 ID（null=未筛选，'__uncat__'=未分类）

        // ====== 我的成就标签页状态 (v2.9.33) ======
        achSelectedCat: 'all',        // 当前选中的成就分类 ('all'=全部, 'collector'/'playtime'/'mastery'/'special')

        // ====== 锁区游戏标签页状态 (v2.9.12) ======
        blockedApps: [],             // 锁区游戏列表 [{appid, name, category, categoryId, type, source, changedAt}]
        blockedLoaded: false,
        blockedLoading: false,
        blockedError: null,
        blockedSource: null,         // 'api' | 'html' | 'manual' | 'mixed'

        // ====== 云存档标签页状态 (v2.9.34) ======
        cloudSaveGames: [],          // [{appid, name, fileCount, totalSize, sizeBytes, _status}]
        cloudSaveLoaded: false,
        cloudSaveLoading: false,
        cloudSaveError: null,
        cloudSaveSource: null,       // 'web' | 'cache'
        cloudSaveLastUpdate: 0,      // 上次更新时间戳
        cloudSaveSearch: '',
        cloudSaveSort: 'sizeDesc',   // 'sizeDesc' | 'sizeAsc' | 'filesDesc' | 'nameAsc'
        cloudSaveDiff: null,         // {new:[], changed:[], removed:[]} 增量比对结果
        cloudSaveBgRefresh: false,   // v2.9.39: 后台静默增量刷新中（已有缓存数据时使用）
        cloudSaveBgRefreshAt: 0,     // v2.9.39: 上次后台静默刷新尝试时间戳（节流 2 天）
        cloudSaveFileCountEnriching: false,  // v2.9.67: 文件数后台填充中
        cloudSaveFileCountAt: 0,     // v2.9.74: 上次文件数填充时间戳（5天 TTL,从 IDB 缓存恢复）

        // ====== 个人展柜标签页状态 (v2.9.90) ======
        showcaseProfile: null,       // { avatar, name, level, steamId } 玩家档案缓存
        showcaseProfileLoading: false,
        showcaseProfileAt: 0,        // 上次获取时间戳（30 分钟 TTL）
        showcaseConfig: null,        // { selectedAppIds: [appid,...], selectedBadgeIds: [{appid,badgeid,isFoil}] } 用户自定义展柜
        showcaseConfigLoaded: false,
        showcasePickerOpen: false,   // 封面选择器弹窗状态
        // v2.9.94: 徽章图标缓存（从社区徽章页面抓取）
        showcaseBadgeIcons: null,   // { "appid|foil": iconUrl } 徽章图标URL映射
        showcaseBadgeIconsLoading: false,
        showcaseBadgeIconsAt: 0,    // 上次获取时间戳（1 小时 TTL）
        showcaseBadges: null,       // 合并后的徽章数据缓存 [{ appid, badgeid, level, xp, iconUrl, name, badgeType, isFoil }]
        // v2.9.99: 展柜 SWR 缓存状态 — 持久化跨 session 复用，未变化不失效
        // v2.9.103: 移除死字段 showcaseCacheHash/showcaseCacheReady(从未被读取,
        // 缓存有效性实际由每次渲染时 _computeShowcaseCacheHash 现算签名保证)
        showcasePreheating: false,  // 预热进行中
        showcasePreheated: false,   // 预热已完成
        showcaseRenderToken: 0,     // 渲染令牌，防止并发渲染竞态
    };

    // ==================== 通用工具模块（v2.4.0 借鉴 steam-friend-manager） ====================
    // 轻量级 DOM 构建函数 h()：替代 innerHTML 拼接，支持事件绑定/CSS变量/布尔属性，降低 XSS 风险
    const BOOL_ATTRS = new Set(['disabled', 'checked', 'selected', 'readonly', 'required', 'hidden', 'multiple', 'autofocus', 'open']);
    function h(tag, props = {}, children = []) {
        const el = document.createElement(tag);
        for (const [k, v] of Object.entries(props)) {
            if (v == null) continue;
            if (k === 'style' && typeof v === 'object') {
                for (const [sk, sv] of Object.entries(v)) {
                    if (sk.startsWith('--')) el.style.setProperty(sk, sv);
                    else { el.style[sk] = sv; }
                }
            } else if (k === 'dataset') {
                Object.assign(el.dataset, v);
            } else if (k.startsWith('on') && typeof v === 'function') {
                el.addEventListener(k.slice(2).toLowerCase(), v);
            } else if (k === 'text') {
                el.textContent = v;
            } else if (k === 'html') {
                el.innerHTML = v;
            } else if (BOOL_ATTRS.has(k)) {
                v ? el.setAttribute(k, '') : el.removeAttribute(k);
            } else {
                el.setAttribute(k, v);
            }
        }
        for (const c of children) {
            if (c == null || c === false) continue;
            el.appendChild(typeof c === 'string' ? document.createTextNode(c) : c);
        }
        return el;
    }

    // 统一 GM 存储 JSON 读取容错（替代 storage 内多处重复的 try{JSON.parse}catch）
    function parseStored(key, fallback) {
        const str = GM_getValue(key, '');
        if (!str) return fallback;
        try { return JSON.parse(str); } catch (e) { return fallback; }
    }

    // 选择器快捷函数
    function $(selector, parent = document) { return parent.querySelector(selector); }
    function $$(selector, parent = document) { return Array.from(parent.querySelectorAll(selector)); }

    // v2.9.49: 统一 debounce 工具函数——避免搜索框每次按键触发完整重渲染
    function debounce(fn, delay = 200) {
        let timer = null;
        const debounced = function(...args) {
            if (timer) clearTimeout(timer);
            timer = setTimeout(() => { fn.apply(this, args); timer = null; }, delay);
        };
        debounced.cancel = () => { if (timer) { clearTimeout(timer); timer = null; } };
        return debounced;
    }

    // v2.9.49: 缓存 Intl.Collator 实例，避免每次 renderGamesList 重新构造
    const _nameCollator = new Intl.Collator(undefined, { numeric: true, sensitivity: 'base' });

    // v2.11.1 (FEAT-011 TASK-002): KPI 卡工厂——统一 5 套同构 KPI 体系的卡片拼装
    // 结构: header(icon+label) + value(+unit) + sub；wl 体系顺序不同(icon+value+label+sub)；
    //       sgis 体系 icon 带渐变底色(val 类名无 -ue 后缀,sub 可选)。
    // 迁移来源(命名冻结,CSS 不动):
    //   dash     → sglv-stat-dash-card    (owned 统计仪表板 7 卡,含 active/data-filter)
    //   trend    → sglv-trend-kpi-card    (入库趋势 8 卡)
    //   playtime → sglv-playtime-kpi-card (游玩仪表 6 卡/成就 4 卡/云存档 4 卡)
    //   wl       → sglv-wl-kpi-card       (愿望单 6 卡)
    //   sgis     → sgis-insight-kpi       (SGIS 社交 6 卡 + 用户成就 6 卡)
    // 文本字段(label/value/unit/sub)经 escHtml;icon/grad/suffixHtml 为内部受信 HTML 原样输出。
    const KPI_TONE_CLASS = {
        dash: 'sglv-stat-dash',
        trend: 'sglv-trend-kpi',
        playtime: 'sglv-playtime-kpi',
        wl: 'sglv-wl-kpi',
        sgis: 'sgis-insight-kpi',
    };

    function kpiCards(items, opts = {}) {
        const prefix = KPI_TONE_CLASS[opts.tone];
        if (!prefix) throw new TypeError(`kpiCards: 未知 tone "${opts.tone}"(可用: ${Object.keys(KPI_TONE_CLASS).join('/')})`);
        return (items || []).map(it => {
            const icon = it.icon || '';
            const label = escHtml(it.label);
            const value = escHtml(it.value);
            const unit = (it.unit != null && it.unit !== '') ? `<span class="${prefix}-unit">${escHtml(it.unit)}</span>` : '';
            const suffixHtml = it.suffixHtml || '';
            const subHtml = (it.sub != null && it.sub !== '') ? `<div class="${prefix}-sub">${escHtml(it.sub)}${it.subSuffixHtml || ''}</div>` : '';
            const colorCls = it.color || '';
            if (opts.tone === 'wl') {
                return `<div class="${prefix}-card ${colorCls}"><div class="${prefix}-icon">${icon}</div><div class="${prefix}-value">${value}${unit}${suffixHtml}</div><div class="${prefix}-label">${label}</div>${subHtml}</div>`;
            }
            if (opts.tone === 'sgis') {
                return `<div class="${prefix} ${colorCls}"><div class="${prefix}-head"><div class="${prefix}-icon" style="background:${it.grad || ''}">${icon}</div><div class="${prefix}-label">${label}</div></div><div class="${prefix}-val">${value}${unit}${suffixHtml}</div>${subHtml}</div>`;
            }
            if (opts.tone === 'dash') {
                return `<div class="${prefix}-card ${colorCls}${it.active ? ' active' : ''}"${it.dataFilter ? ` data-filter="${it.dataFilter}"` : ''}><div class="${prefix}-header"><span class="${prefix}-icon">${icon}</span><span class="${prefix}-label">${label}</span></div><div class="${prefix}-value">${value}${unit}${suffixHtml}</div>${subHtml}</div>`;
            }
            return `<div class="${prefix}-card ${colorCls}"><div class="${prefix}-header"><span class="${prefix}-icon">${icon}</span><span class="${prefix}-label">${label}</span></div><div class="${prefix}-value">${value}${unit}${suffixHtml}</div>${subHtml}</div>`;
        }).join('');
    }

    // v2.11.2 (FEAT-011 TASK-003): 空态工厂——统一 31 处内联 `<div class="sglv-empty">` 拼接
    // text 经 escHtml;opts.style 透传内联样式(如 padding:8px/font-size:11px);
    // 专属空态外壳(sglv-gs-empty/sglv-cs-list-empty/sgis-state)为独立 class 体系,保持原样不经本工厂
    function emptyHtml(text, opts = {}) {
        const style = opts.style ? ` style="${opts.style}"` : '';
        return `<div class="sglv-empty"${style}>${escHtml(text)}</div>`;
    }

    // ==================== v2.11.3 (FEAT-011 TASK-004): 骨架屏统一工厂 ====================
    // createSkeleton(kind, arg) 唯一骨架入口,6 种 kind 表驱动映射,原 5 个独立构建器实现整体迁入本表:
    //   showcase  展柜骨架(固定形态)              heatmap  入库热力图骨架(SVG 灰格)
    //   monthly   近6月入库增量骨架(SVG)          family   家庭对比骨架行(arg=行数,默认4)
    //   wishlist  愿望单整页骨架(arg=wrap 容器;DOM 副作用型:仅填充空容器,返回 undefined)
    //   sgis      SGIS 侧栏骨架行(arg=行数,默认8,自 renderProgressLoading 收编)
    // 本表位于外层共享区:子闭包 A(SGLV UI)与 B(SGIS)均可访问;表内实现引用 T/isZh/state
    // 均在调用时求值,不受定义顺序影响
    const SKELETONS = {
        showcase: () => {
            const sk = (w, h, r) =>
                `<div class="sglv-sc-sk-block" style="width:${w};height:${h};border-radius:${r || '6px'};"></div>`;
            return `
        <div class="sglv-sc-wrap sglv-sc-skeleton-wrap">
            <div class="sglv-sc-scroll">
                <div class="sglv-sc-hero">
                    <div class="sglv-sc-avatar-wrap">${sk('44px', '44px', '50%')}</div>
                    <div class="sglv-sc-hero-info">
                        <div class="sglv-sc-hero-name-row">${sk('140px', '18px')}</div>
                        <div class="sglv-sc-hero-stats">
                            <div class="sglv-sc-hero-stat">${sk('60px', '32px')}</div>
                            <div class="sglv-sc-hero-stat">${sk('60px', '32px')}</div>
                            <div class="sglv-sc-hero-stat">${sk('60px', '32px')}</div>
                        </div>
                    </div>
                </div>
                <div class="sglv-sc-cols">
                    <div class="sglv-sc-left">
                        <div class="sglv-sc-card">
                            <div class="sglv-sc-card-header">${sk('120px', '16px')}</div>
                            <div class="sglv-sc-card-body"><div class="sglv-sc-cover-grid">
                                ${Array(8).fill(sk('100%', '170px', '8px')).join('')}
                            </div></div>
                        </div>
                        <div class="sglv-sc-card">
                            <div class="sglv-sc-card-header">${sk('120px', '16px')}</div>
                            <div class="sglv-sc-card-body">
                                ${Array(4).fill(`<div class="sglv-sc-playtime-item">${sk('32px', '32px', '50%')}<div class="sglv-sc-playtime-info">${sk('100%', '14px')}${sk('70%', '12px')}</div></div>`).join('')}
                            </div>
                        </div>
                    </div>
                    <div class="sglv-sc-right">
                        <div class="sglv-sc-card" style="margin-bottom:20px;">
                            <div class="sglv-sc-card-header">${sk('120px', '16px')}</div>
                            <div class="sglv-sc-card-body">
                                ${Array(4).fill(`<div class="sglv-sc-ach-item">${sk('32px', '32px', '50%')}<div class="sglv-sc-ach-info">${sk('100%', '14px')}${sk('60%', '12px')}</div></div>`).join('')}
                            </div>
                        </div>
                        <div class="sglv-sc-card">
                            <div class="sglv-sc-card-header">${sk('80px', '16px')}</div>
                            <div class="sglv-sc-tags">${sk('70px', '24px', '12px')}${sk('70px', '24px', '12px')}</div>
                        </div>
                    </div>
                </div>
            </div>
        </div>`;
        },
        heatmap: () => {
            const cellSize = 12, cellGap = 3, cellStep = cellSize + cellGap;
            const labelW = 26, monthH = 16;
            const monthNames = ['1月', '2月', '3月', '4月', '5月', '6月', '7月', '8月', '9月', '10月', '11月', '12月'];
            const dayNames = ['', '一', '', '三', '', '五', ''];
            const totalWeeks = 53;            // 单年最多 53 周
            const baseColor = '#21262d';      // 骨架占位色（GitHub theme-1），比 #161b22 略亮以区分背景
            // v2.9.25: topH 去掉 yearH，与实际单年渲染一致（showYearRow=false），消除加载完成时 14px 垂直跳动
            const topH = monthH;
            const svgW = labelW + totalWeeks * cellStep + 8;
            const svgH = topH + 7 * cellStep + 8;

            // 月份标签：每 4 周一个（避免重叠）
            const monthParts = monthNames.map((n, i) => {
                const w = Math.floor(i * totalWeeks / 12);
                return `<text x="${labelW + w * cellStep}" y="${topH - 5}" fill="#475569" font-size="10">${n}</text>`;
            }).join('');
            // 星期标签
            const dayParts = dayNames.map((n, i) => n ? `<text x="0" y="${topH + i * cellStep + 10}" fill="#475569" font-size="10">${n}</text>` : '').join('');
            // 灰格：7 行 × totalWeeks 列
            const cellParts = [];
            for (let w = 0; w < totalWeeks; w++) {
                for (let d = 0; d < 7; d++) {
                    const x = labelW + w * cellStep, y = topH + d * cellStep;
                    cellParts.push(`<rect x="${x}" y="${y}" width="${cellSize}" height="${cellSize}" rx="2" fill="${baseColor}"/>`);
                }
            }
            // 顶部骨架图例（与真实渲染图例位置一致）
            const legendSwatches = ['#161b22', '#0e4429', '#006832', '#26a641', '#39d353']
                .map(c => `<span class="swatch" style="background:${c};opacity:0.6"></span>`).join('');
            const skeleton = `<svg width="${svgW}" height="${svgH}" viewBox="0 0 ${svgW} ${svgH}" style="display:block;max-width:100%;height:auto;">${monthParts}${dayParts}${cellParts.join('')}</svg>
            <div class="sglv-heatmap-summary" style="opacity:0.5">
                <span class="sglv-heatmap-legend"><span>${T.ptHeatmapLess}</span>${legendSwatches}<span>${T.ptHeatmapMore}</span></span>
                <span>${T.ptHeatmapTotal}: <b>—</b></span>
                <span>${T.ptHeatmapPeak}: <b>—</b></span>
                <span>${T.ptHeatmapAvg}: <b>—</b></span>
                <span>${isZh ? '加载中…' : 'Loading…'}</span>
            </div>`;
            return `<div class="sglv-heatmap-block sglv-heatmap-skeleton">${skeleton}</div>`;
        },
        monthly: () => {
            const now = new Date();
            const months = [];
            for (let i = 5; i >= 0; i--) {
                const d = new Date(now.getFullYear(), now.getMonth() - i, 1);
                months.push({ y: d.getFullYear(), m: d.getMonth(), key: `${String(d.getMonth() + 1).padStart(2, '0')}.${String(d.getFullYear()).slice(-2)}` });
            }
            // v2.9.26: 与 renderMonthlyAcquireChart 完全一致的尺寸（加高 SVG 减少留白）
            const W = 280, H = 200, lw = 32, topPad = 20, botPad = 24;
            const plotW = W - lw - 2, plotH = H - topPad - botPad;
            const step = plotW / 6, barW = Math.min(26, step * 0.6);
            let parts = '';
            // 网格线
            const gridVals = [0, 1];
            for (const v of gridVals) {
                const y = topPad + plotH - (v / 1) * plotH;
                parts += `<line x1="${lw}" y1="${y}" x2="${W - 2}" y2="${y}" stroke="rgba(255,255,255,0.04)" stroke-width="1" stroke-dasharray="3,3"/>`;
                parts += `<text x="${lw - 4}" y="${y + 3}" fill="#475569" font-size="9" text-anchor="end">${v}</text>`;
            }
            months.forEach((mo, i) => {
                const cx = lw + step * i + step / 2;
                const bx = cx - barW / 2, by = topPad + plotH - 2;
                parts += `<rect x="${bx.toFixed(1)}" y="${by.toFixed(1)}" width="${barW}" height="2" rx="3" fill="#334155" opacity="0.25"/>`;
                const lbl = String(mo.y).slice(2) + '.' + String(mo.m + 1).padStart(2, '0');
                parts += `<text x="${cx}" y="${H - 4}" fill="#475569" font-size="9" text-anchor="middle">${lbl}</text>`;
            });
            const svg = `<svg viewBox="0 0 ${W} ${H}" preserveAspectRatio="xMidYMid meet" style="display:block;width:100%;height:100%;">${parts}</svg>`;
            // v2.9.26: 结构与实际渲染一致——inner + title + chart + summary
            const summaryHtml = `<div class="sglv-hm-mini-summary" style="opacity:0.5">
                <span class="sglv-hm-mini-stat"><b>—</b> ${isZh ? '总计' : 'total'}</span>
                <span class="sglv-hm-mini-stat">${isZh ? '加载中…' : 'Loading…'}</span>
            </div>`;
            return `<div class="sglv-hm-mini-inner">
            <div class="sglv-hm-mini-title">${T.ptHeatmapMini6m}</div>
            <div class="sglv-hm-mini-chart">${svg}</div>
            ${summaryHtml}
        </div>`;
        },
        family: (rows = 4) => {
            // 不同宽度的 bar 让骨架看起来更接近真实数据分布（最上面"我"略长，其他成员递减）
            const widths = [72, 55, 38, 22];
            const rowHtml = [];
            for (let i = 0; i < rows; i++) {
                const w = widths[i] || 18;
                rowHtml.push(
                    `<div class="sglv-family-bar-row sglv-family-bar-skel">` +
                        `<span class="sglv-family-bar-name" style="background:linear-gradient(90deg,rgba(255,255,255,0.06),rgba(255,255,255,0.02));border-radius:3px;width:60px;height:12px;display:inline-block"></span>` +
                        `<div class="sglv-family-bar-track"><div class="sglv-family-bar-fill" style="width:${w}%;background:linear-gradient(90deg,rgba(255,255,255,0.12),rgba(255,255,255,0.06))"></div></div>` +
                        `<span class="sglv-family-bar-hours" style="background:linear-gradient(90deg,rgba(255,255,255,0.06),rgba(255,255,255,0.02));border-radius:3px;width:48px;height:12px;display:inline-block"></span>` +
                    `</div>`
                );
            }
            return rowHtml.join('');
        },
        wishlist: (wrap) => {
            // v2.9.15: 愿望单首次加载骨架屏——KPI 数字 + 8 section + 游戏网格,避免页面紧缩(DOM 副作用型)
            // KPI 区:4 个数字骨架
            const kpiEl = wrap.querySelector('#sglv-wishlist-kpi');
            if (kpiEl && !kpiEl.innerHTML) {
                kpiEl.className = 'sglv-wl-kpi';
                kpiEl.innerHTML = Array.from({ length: 4 }, () =>
                    `<div class="sglv-wl-kpi-cell">
                        <div class="sglv-skel-bar sglv-skel-num"></div>
                        <div class="sglv-skel-bar sglv-skel-lbl"></div>
                    </div>`
                ).join('');
            }
            // 8 个 section:每 section 一行骨架
            const sectionIds = ['sglv-wl-upcoming', 'sglv-wl-catstats', 'sglv-wl-tags', 'sglv-wl-year-trend', 'sglv-wl-price-dist', 'sglv-wl-disc-dist', 'sglv-wl-timeline'];
            sectionIds.forEach(id => {
                const el = wrap.querySelector('#' + id);
                if (!el || el.innerHTML) return;
                el.innerHTML = `<div class="sglv-skel-bar sglv-skel-section-title"></div>
                <div class="sglv-skel-bar sglv-skel-row"></div>
                <div class="sglv-skel-bar sglv-skel-row"></div>
                <div class="sglv-skel-bar sglv-skel-row sglv-skel-row-short"></div>`;
            });
            // 右侧 content:12 个卡片网格骨架
            const content = wrap.querySelector('#sglv-wishlist-content');
            if (content && !content.innerHTML) {
                content.innerHTML = `<div class="sglv-skel-grid">${Array.from({ length: 12 }, () =>
                    `<div class="sglv-skel-game-card">
                        <div class="sglv-skel-cover"></div>
                        <div class="sglv-skel-bar sglv-skel-card-name"></div>
                        <div class="sglv-skel-bar sglv-skel-card-meta"></div>
                    </div>`
                ).join('')}</div>
                ${wishlistLoadingHtml()}`;
            }
        },
        sgis: (rows = 8) => Array.from({ length: Math.max(0, rows) }, () =>
            `<div class="sgis-skel-row">
                <div class="sgis-skel-icon"></div>
                <div class="sgis-skel-lines">
                    <div class="sgis-skel-line l1"></div>
                    <div class="sgis-skel-line l2"></div>
                </div>
            </div>`
        ).join(''),
    };
    function createSkeleton(kind, arg) {
        const build = SKELETONS[kind];
        if (!build) throw new TypeError(`createSkeleton: 未知 kind "${kind}"(可用: ${Object.keys(SKELETONS).join('/')})`);
        return build(arg);
    }

    // ==================== v2.11.11 (FEAT-012 TASK-005): 水平条形行工厂 ====================
    // 收编 15 处 name+track+fill(+val) 结构重复(差异矩阵见 README 2.11.11);
    // 前缀表驱动各命名空间现状 class 映射(不改 CSS);row 缺省的命名空间产裸三段(外层行由调用方持有);
    // 宽度归一化/锚定公式与内容转义(wlEscape/escHtml)留在调用方——各处管线现状不一,工厂不二次转义。
    // 豁免清单(非数据条形行): 骨架灰块(family skel)、加载动画条(wl-loading/sgis-load)、
    // 竖向柱(cs-dist height 布局 / wl-vbar val 上 label 下)——竖柱结构与水平行不同构,不强行收编。
    const HBAR_NS = {
        family: { row: 'sglv-family-bar-row', name: 'sglv-family-bar-name', track: 'sglv-family-bar-track', fill: 'sglv-family-bar-fill', val: 'sglv-family-bar-hours' },
        wl:     { row: 'sglv-wl-bar-row', name: 'sglv-wl-bar-name', track: 'sglv-wl-bar-track', fill: 'sglv-wl-bar-fill', val: 'sglv-wl-bar-val' },
        taste:  { row: 'sgis-taste-bar-row', name: 'sgis-taste-bar-label', track: 'sgis-taste-bar-track', fill: 'sgis-taste-bar-fill', val: 'sgis-taste-bar-val' },
        cs10:   { name: 'sglv-cs-top10-name', track: 'sglv-cs-top10-bar-track', fill: 'sglv-cs-top10-bar', val: 'sglv-cs-top10-size' },
        sc:     { track: 'sglv-sc-playtime-bar', fill: 'sglv-sc-playtime-bar-fill' },
        pt:     { track: 'sglv-pt-bar-wrap', fill: 'sglv-pt-bar-fill' },
        ptAll:  { track: 'sglv-pt-all-bar', fill: 'sglv-pt-all-bar-fill' },
        wlBare: { track: 'sglv-wl-bar-track', fill: 'sglv-wl-bar-fill' },
        ach:    { track: 'sgis-ach-bar', fill: 'sgis-ach-bar-fill' },
        xp:     { track: 'sgis-xp-bar', fill: 'sgis-xp-bar-fill' },
        radar:  { track: 'sglv-radar-stat-bar', fill: 'sglv-radar-stat-bar-fill' },
    };
    function hbarRow({ cls, name, nameTitle, pct, color, val, rowClass, nameTag = 'span', valTag = 'span' }) {
        const NS = HBAR_NS[cls];
        if (!NS) return '';
        const nameHtml = name != null
            ? `<${nameTag} class="${NS.name}"${nameTitle != null ? ` title="${nameTitle}"` : ''}>${name}</${nameTag}>`
            : '';
        const valHtml = val != null ? `<${valTag} class="${NS.val}">${val}</${valTag}>` : '';
        const fill = pct != null && pct !== ''
            ? `<div class="${NS.fill}" style="width:${pct}%${color ? `;background:${color}` : ''}"></div>`
            : '';
        const track = `<div class="${NS.track}">${fill}</div>`;
        return NS.row
            ? `<div class="${NS.row}${rowClass ? ' ' + rowClass : ''}">${nameHtml}${track}${valHtml}</div>`
            : nameHtml + track + valHtml;
    }

    // v2.11.14 (FEAT-013 TASK-001): 三视图统一渲染器——card/list 骨架全文唯一份（owned/wishlist 双消费）。
    // 插槽: imgHtml 头图 / bodyHtml 正文(list 为信息列) / trailingHtml 列表尾部徽章串 / itemAttrs 卡片
    // 额外属性(wl: data-appid+onclick) / wrapAttrs 容器属性(wl: data-ids-key)。
    // cover 视图豁免: owned(sglv-cover-* 带 gradient/时长角标) 与 wishlist(sglv-wl-cover-* 带价格浮层)
    // DOM 结构与 CSS 命名空间均不同,参数化合并收益为负,各自保留(等价基线见 TASK-001 验证记录)。
    // 事件绑定遵循「渲染后绑定」现状: 工厂只产 HTML,owned 侧渲染后 querySelectorAll 循环
    // addEventListener(文档序=map 生成序),wl 侧经 itemAttrs 注入内联 onclick。
    // v2.11.17 (FEAT-013 TASK-004) card 分支扩展位(时间线卡第三类消费): gridCls/cardCls/bodyCls
    // 自定义命名空间(默认值与 owned/wishlist 现状逐字节一致)、bareImg 裸头图(不包 img-wrap)、
    // itemPrefixHtml 项前插槽(时间线日期分隔线,divider 为 grid 直接子元素故置于卡片之前)。
    // list 分支不扩(无消费方,避免推测性设计)。
    function renderGameView(items, opts = {}) {
        const {
            viewMode,
            imgHtml,
            bodyHtml,
            trailingHtml = () => '',
            itemAttrs = () => '',
            wrapAttrs = '',
            gridCls = 'sglv-card-grid',
            cardCls = 'sglv-game-card',
            bodyCls = 'sglv-card-body',
            bareImg = false,
            itemPrefixHtml = () => '',
            listItemCls = 'sglv-list-item',
            listInfoCls = 'sglv-list-info',
            rowsOnly = false,
        } = opts;
        if (viewMode === 'card') {
            return `<div class="${gridCls}"${wrapAttrs}>${items.map(g => `
                ${itemPrefixHtml(g)}<div class="${cardCls}"${itemAttrs(g)}>
                    ${bareImg ? imgHtml(g) : `<div class="sglv-card-img-wrap">${imgHtml(g)}</div>`}
                    <div class="${bodyCls}">${bodyHtml(g)}</div>
                </div>`).join('')}</div>`;
        }
        // v2.11.21 (FEAT-013 TASK-008): list 分支参数化(listItemCls/listInfoCls,云存档行消费)+
        // rowsOnly 挂载模式——调用方持有容器时只产出行序列(云存档 .sglv-cs-game-list 为 listWrap
        // 直接 flex 子元素承担 flex:1 滚动区,工厂包裹层会成为额外孙节点破坏该布局)
        const rows = items.map(g => `
            <div class="${listItemCls}"${itemAttrs(g)}>
                ${imgHtml(g)}
                <div class="${listInfoCls}">${bodyHtml(g)}</div>
                ${trailingHtml(g)}
            </div>`).join('');
        return rowsOnly ? rows : `<div class="sglv-list-view"${wrapAttrs}>${rows}</div>`;
    }

    // v2.11.15 (FEAT-013 TASK-002): 列表工具栏工厂——搜索/排序/视图切换/尾部插槽按配置注入,
    // 事件经 onChange({type:'input'|'sort'|'view', value}) 分发(input 走共享 debounce 200ms,与各处现状一致)。
    // listToolbarHtml 纯字符串构建器(A13 快照断言直接消费);buildListToolbar 负责 createElement+渲染后绑定
    // (SGLV 工具栏均为面板构建期一次性 DOM,非每次渲染重建);当前值由调用方 state 提供。
    // 签名扩展位(供 FEAT-014 SGIS 侧消费): filters 按钮组等后续按需增配。
    // 现状差异保留: owned sort 选中值走「渲染后 .value=」路径(不传 sort.value 则 option 无 selected 属性,
    // 与 2.11.14 逐字节一致);云存档传 sort.value 走内联 selected(与其现状一致)。
    // views.idPrefix(wl 形态: id=前缀+mode)与 views.useDataView(owned 形态: data-view 属性)二选一。
    function listToolbarHtml(cfg = {}) {
        const {
            search = null,      // {id, cls, placeholder, value, style}
            sort = null,        // {id, cls, title, options:[{value,label}], value}
            views = null,       // {modes:[{mode,title,icon}], value, idPrefix, useDataView}
            extraHtml = '',
        } = cfg;
        let html = '';
        if (search) {
            html += `<input type="text" class="${search.cls || 'sglv-search'}"${search.id ? ` id="${search.id}"` : ''} placeholder="${search.placeholder}"${search.value != null ? ` value="${search.value}"` : ''}${search.style ? ` style="${search.style}"` : ''}>`;
        }
        if (sort) {
            html += `<select class="${sort.cls || 'sglv-sort-select'}"${sort.id ? ` id="${sort.id}"` : ''}${sort.title ? ` title="${sort.title}"` : ''}>${sort.options.map(o => `<option value="${o.value}"${sort.value === o.value ? ' selected' : ''}>${o.label}</option>`).join('')}</select>`;
        }
        if (views) {
            html += `<div class="sglv-view-toggle">${views.modes.map(m =>
                `<button class="sglv-btn sglv-btn-secondary sglv-btn-icon${views.value === m.mode ? ' active' : ''}"${views.idPrefix ? ` id="${views.idPrefix}${m.mode}"` : ''}${views.useDataView ? ` data-view="${m.mode}"` : ''} title="${m.title}">${m.icon}</button>`
            ).join('')}</div>`;
        }
        return html + extraHtml;
    }

    function buildListToolbar(cfg = {}) {
        const { cls = 'sglv-toolbar', search = null, sort = null, views = null, onChange = null } = cfg;
        const el = document.createElement('div');
        el.className = cls;
        el.innerHTML = listToolbarHtml(cfg);
        if (onChange) {
            if (search) {
                const input = search.id ? el.querySelector(`#${search.id}`) : el.querySelector(`input.${search.cls || 'sglv-search'}`);
                if (input) input.addEventListener('input', debounce(e => onChange({ type: 'input', value: e.target.value }), 200));
            }
            if (sort) {
                const sel = sort.id ? el.querySelector(`#${sort.id}`) : el.querySelector(`select.${sort.cls || 'sglv-sort-select'}`);
                if (sel) sel.addEventListener('change', e => onChange({ type: 'sort', value: e.target.value }));
            }
            if (views) {
                const btns = views.idPrefix
                    ? views.modes.map(m => el.querySelector(`#${views.idPrefix}${m.mode}`)).filter(Boolean)
                    : [...el.querySelectorAll('[data-view]')];
                btns.forEach(btn => {
                    btn.addEventListener('click', () => {
                        const mode = views.idPrefix ? btn.id.slice(views.idPrefix.length) : btn.dataset.view;
                        btns.forEach(b => b.classList.toggle('active', b === btn));
                        onChange({ type: 'view', value: mode });
                    });
                });
            }
        }
        return el;
    }

    // v2.11.16 (FEAT-013 TASK-003): 通用选择器弹窗工厂——封面/徽章选择器两份骨架重复实现收敛为单实现。
    // pickerModalHtml 纯字符串构建器(A14 快照断言直接消费);openPickerModal 负责 DOM 挂载与事件绑定。
    // 骨架契约(与原两实现逐字一致): overlay 点击关闭/搜索 debounce 200ms/已选计数 <strong>N</strong> / max/
    // 保存/关闭按钮/ESC 关闭/打开 100ms 后自动聚焦搜索框;ESC/关闭/保存统一走 close() 集中解绑(修复原保存后
    // keydown 监听悬挂)。差异经插槽注入: getItems(过滤+分页在调用方)/renderItem(条目模板)/itemKey+keyFromItem
    // (选中键: 封面 appid / 徽章 appid|badgeid|foil 复合键)/onGridRendered(渲染后钩子: 封面链/徽章分页条)/
    // bindExtra(自定义区块事件: 徽章分类 tabs)/canSave/buildResult(保存载荷映射)。
    function pickerModalHtml(cfg = {}) {
        const {
            modalCls = 'sglv-sc-picker',
            idBase,                 // 内部元素 id 前缀: sglv-sc-picker | sglv-sc-badge
            title,
            searchPlaceholder,
            searchAria = '',
            extraHtml = '',         // header 与 body 之间插槽(徽章分类 tabs)
            gridCls,
            afterGridHtml = '',     // body 内 grid 之后插槽(徽章分页条)
            countInit,
            maxSelect,
            saveText,
        } = cfg;
        return `
            <div class="${modalCls}">
                <div class="sglv-sc-picker-header">
                    <span class="sglv-sc-picker-title">${title}</span>
                    <input type="text" class="sglv-sc-picker-search" id="${idBase}-search" placeholder="${searchPlaceholder}" autocomplete="off" spellcheck="false"${searchAria ? ` aria-label="${searchAria}"` : ''}>
                    <button class="sglv-sc-picker-close" id="${idBase}-close" aria-label="${isZh ? '关闭' : 'Close'}">✕</button>
                </div>
                ${extraHtml}
                <div class="sglv-sc-picker-body">
                    <div class="${gridCls}" id="${idBase}-grid"></div>
                    ${afterGridHtml}
                </div>
                <div class="sglv-sc-picker-footer">
                    <span class="sglv-sc-picker-count" id="${idBase}-count"><strong>${countInit}</strong> / ${maxSelect}</span>
                    <button class="sglv-sc-picker-save" id="${idBase}-save">${saveText}</button>
                </div>
            </div>
        `;
    }

    function openPickerModal(cfg = {}) {
        const {
            overlayId,
            idBase,
            maxSelect,
            currentSelected = [],
            getItems,               // (searchValue) => 条目数组(过滤/分页由调用方负责)
            itemKey,                // (item) => 选中集合键
            renderItem,             // (item, isSelected) => 条目 HTML(外层 class 自带 selected 注入位)
            itemSelector,           // '.sglv-sc-picker-item' | '.sglv-sc-badge-pick-item'
            keyFromItem,            // (el) => DOM 取键(封面 parseInt(dataset.appid) / 徽章 dataset.key)
            onGridRendered = null,  // (grid, rerender) => 渲染后钩子(封面 _applyCoverChain / 徽章分页条)
            bindExtra = null,       // (overlay, rerender) => 自定义区块事件(徽章 tabs)
            canSave = size => size > 0,
            buildResult,            // (selectedSet) => onSave 载荷
            maxWarningText,
            savedToastText,
            onSave,
        } = cfg;
        const existing = document.getElementById(overlayId);
        if (existing) existing.remove();

        const mountTarget = (SGLV_API.getPanelEl && SGLV_API.getPanelEl()) || document.body;
        const selected = new Set(currentSelected);

        const overlay = document.createElement('div');
        overlay.className = 'sglv-sc-picker-overlay';
        overlay.id = overlayId;
        overlay.innerHTML = pickerModalHtml(cfg);
        mountTarget.appendChild(overlay);

        const grid = overlay.querySelector(`#${idBase}-grid`);
        const searchInput = overlay.querySelector(`#${idBase}-search`);
        const countEl = overlay.querySelector(`#${idBase}-count`);
        const saveBtn = overlay.querySelector(`#${idBase}-save`);

        function updateCount() {
            countEl.innerHTML = `<strong>${selected.size}</strong> / ${maxSelect}`;
            saveBtn.disabled = !canSave(selected.size);
        }

        function renderGrid() {
            const items = getItems(searchInput.value);
            grid.innerHTML = items.map(it => renderItem(it, selected.has(itemKey(it)))).join('');
            grid.querySelectorAll(itemSelector).forEach(item => {
                item.addEventListener('click', () => {
                    const key = keyFromItem(item);
                    if (selected.has(key)) {
                        selected.delete(key);
                        item.classList.remove('selected');
                    } else {
                        if (selected.size >= maxSelect) {
                            sglvToast.warning(maxWarningText);
                            return;
                        }
                        selected.add(key);
                        item.classList.add('selected');
                    }
                    updateCount();
                });
            });
            if (onGridRendered) onGridRendered(grid, renderGrid);
        }

        renderGrid();
        updateCount();

        // 搜索(debounce 200ms,与原两实现一致)
        const debouncedSearch = debounce(() => renderGrid(), 200);
        searchInput.addEventListener('input', (e) => debouncedSearch(e.target.value));

        if (bindExtra) bindExtra(overlay, renderGrid);

        // 关闭路径集中: 按钮/overlay 点击/ESC/保存后均经 close() 解绑 keydown,避免监听泄漏
        function close() {
            overlay.remove();
            document.removeEventListener('keydown', escHandler);
        }
        overlay.querySelector(`#${idBase}-close`).addEventListener('click', close);
        overlay.addEventListener('click', (e) => { if (e.target === overlay) close(); });

        saveBtn.addEventListener('click', () => {
            const result = buildResult(selected);
            close();
            if (onSave) onSave(result);
            sglvToast.success(savedToastText);
        });

        const escHandler = (e) => {
            if (e.key === 'Escape') close();
        };
        document.addEventListener('keydown', escHandler);

        setTimeout(() => searchInput.focus(), 100);
    }

    // v2.11.3 (FEAT-011 TASK-004): 愿望单加载阶段计算——消除 renderWishlistLoadingHtml
    // 与 renderWishlistGamesList 增量更新两处重复的阶段表;progress>0 时优先用实际进度
    function getWishlistLoadStage() {
        const stages = [
            { pct: 15, text: T.wlLoadStage1 },
            { pct: 45, text: T.wlLoadStage2 },
            { pct: 75, text: T.wlLoadStage3 },
        ];
        const stage = stages[state.wishlistLoadStage - 1] || { pct: 10, text: T.wlFetching };
        const pct = state.wishlistLoadProgress > 0 ? state.wishlistLoadProgress : stage.pct;
        return { text: stage.text, pct };
    }
    // v2.11.3: 愿望单加载块——改经 createLoadingHtml 工厂(cls/svgCls/textCls/progress/sub 全量透传)
    function wishlistLoadingHtml() {
        const s = getWishlistLoadStage();
        return createLoadingHtml(s.text, 32, {
            cls: 'sglv-wl-loading',
            svgCls: 'sglv-wl-spin',
            textCls: 'sglv-wl-loading-text',
            progress: { pct: s.pct },
            sub: T.wlLoadSub,
        });
    }

    // v2.9.56: 统一 Tab 切换函数——消除 5 处重复的 "设置 activeTab + 更新 DOM active 类 + renderBody" 逻辑
    // 调用方：_gsJumpToGame(owned/wishlist 跳转)、tab click handler、_onOpenModal 事件
    // v2.9.61: 本函数位于子闭包之外，panelEl/renderBody 处于子闭包内，故经 SGLV_API 桥接访问
    function switchToTab(tabName) {
        if (!tabName) return;
        state.activeTab = tabName;
        state.showSettings = false;
        const _panel = SGLV_API.getPanelEl && SGLV_API.getPanelEl();
        if (_panel) {
            _panel.querySelectorAll('.sglv-tab').forEach(t => t.classList.remove('active'));
            const tabBtn = _panel.querySelector(`.sglv-tab[data-tab="${tabName}"]`);
            if (tabBtn) tabBtn.classList.add('active');
        }
        if (SGLV_API.renderBody) SGLV_API.renderBody();
    }

    // ==================== v2.9.51: 全局游戏搜索（中文/拼音缩写/英文子串匹配） ====================
    // 参考 https://github.com/sys1em/Steam_Buff 的搜索联想思路，结合中文名 + 拼音首字母 + 英文子串，
    // 本实现完全本地运行，索引从已加载的 state.ownedGames + state.wishlistGames + gameDb 离线数据库 + 持久化自定义别名构建。
    // 设计要点：
    //   1) 启动时一次性构建 _searchIndex（每条 {appid, name, nameLower, nameNoSpace, pinyinAbbr, pinyinAbbrNoSpace, type, sources}）
    //   2) 搜索时按子串+拼音子串 双向匹配，排序时优先 substring 完全匹配 > 拼音完全匹配 > 短名称
    //   3) 命中渲染在浮层中，每条带"类型徽章"（已拥有/愿望单/商店），点击按来源跳转到对应 tab + 滚动定位
    //   4) 中文/英文字符串小写化 + 去空格预存，搜索时同样预处理；空格和特殊字符被忽略

    // 常用汉字→拼音首字母查表已抽到独立脚本 sglv-pinyin.lib.js（v1.0.0，@require 引入）。
    // 主脚本通过 _getPinyinLib() 委托 searchByPinyin,不再需要本地 toPinyinAbbr 包装。
    //   - 查表来源：SGLVPinyin._TABLE（~3857 常用汉字，ASCII 数字/英文直通）
    //   - 行为契约：空格/标点保留、英文小写、CJK 查表、未收录字符保留原字符（允许 substring 兜底匹配）
    // v2.9.64: 从一次性求值的 const 改为实时求值函数 _getPinyinLib(),
    //   解决 @require 脚本因网络延迟晚于主脚本执行时拼音库永久不可用的问题
    function _getPinyinLib() {
        return (typeof window !== 'undefined' && window.SGLVPinyin)
            || (typeof unsafeWindow !== 'undefined' && unsafeWindow.SGLVPinyin)
            || null;
    }
    // v2.9.56: 移除 toPinyinAbbr 包装函数——buildSearchIndex 不再预计算 pinyinAbbr 字段,
    // searchByPinyin 内部通过 getName(it) 实时调用 _getPinyinLib().toPinyinAbbr,包装层已无调用方

    // 搜索索引项: {appid, name, type: 'owned'|'wishlist'|'store', owned, wishlist, store, _scoreBias}
    const _searchIndex = [];           // 所有游戏条目(去重,优先级 owned > wishlist > store)
    const _searchIndexByAppid = new Map(); // appid -> index entry(用于去重)
    let _searchIndexBuilt = false;

    // v2.9.56: 统一标点/空格剥离正则——与 sglv-pinyin.lib.js 的 _PUNCT_STRIP_RE 保持一致
    // 消除 buildSearchIndex 和 highlightMatch 中 5 处重复的内联正则字面量
    const _PUNCT_STRIP_RE = /[\s\-_:：·、，,.\/\\()（）\[\]【】''""]/g;
    // 非 global 版本供 .test() 使用——避免 g 标志在循环中 lastIndex 状态泄漏
    const _PUNCT_TEST_RE = /[\s\-_:：·、，,.\/\\()（）\[\]【】''""]/;

    // 提取已加载 game-db 数据库的所有游戏项(供"商店"维度匹配)
    // game-db 格式: { "publisher": { "series": [{id, name}, ...] } }
    function _extractGameDbEntries() {
        // 优先从 _gameDbCache 拿(如果已加载),否则解析当前 game-db
        try {
            let db = null;
            try {
                const txt = GM_getResourceText('gameDb');
                if (txt) db = JSON.parse(txt);
            } catch (e) { /* ignore */ }
            if (!db) return [];
            const entries = [];
            for (const publisher of Object.keys(db)) {
                if (publisher === '_meta') continue;
                const seriesMap = db[publisher];
                if (!seriesMap || typeof seriesMap !== 'object') continue;
                for (const series of Object.keys(seriesMap)) {
                    const items = seriesMap[series];
                    if (!Array.isArray(items)) continue;
                    for (const it of items) {
                        if (it && it.id && it.name) {
                            entries.push({ appid: Number(it.id), name: it.name });
                        }
                    }
                }
            }
            return entries;
        } catch (e) {
            return [];
        }
    }

    // 构建/重建搜索索引
    function buildSearchIndex() {
        _searchIndex.length = 0;
        _searchIndexByAppid.clear();
        const ownedSet = new Set();
        // 1) 已拥有(优先级最高)
        // v2.9.53: 保留 _gameObj 引用,渲染时通过 isGameOwnedByMe(_gameObj) 区分"自己拥有"与"家庭共享"
        if (Array.isArray(state.ownedGames)) {
            for (const g of state.ownedGames) {
                if (!g || !g.appid) continue;
                const appid = Number(g.appid);
                if (ownedSet.has(appid)) continue;
                ownedSet.add(appid);
                _searchIndexByAppid.set(appid, {
                    appid, name: g.name || '', type: 'owned',
                    owned: true, wishlist: false, store: false,
                    _gameObj: g,  // v2.9.53: 供徽章渲染时区分 mine/shared
                });
            }
        }
        // 2) 愿望单
        if (Array.isArray(state.wishlistGames)) {
            for (const g of state.wishlistGames) {
                if (!g || !g.appid) continue;
                const appid = Number(g.appid);
                if (ownedSet.has(appid)) {
                    const ex = _searchIndexByAppid.get(appid);
                    if (ex) { ex.wishlist = true; ex.type = 'owned'; /* 优先 owned */ }
                    continue;
                }
                if (_searchIndexByAppid.has(appid)) continue;
                _searchIndexByAppid.set(appid, {
                    appid, name: g.name || '', type: 'wishlist',
                    owned: false, wishlist: true, store: false,
                });
            }
        }
        // 3) game-db 数据库(商店维度)
        const dbEntries = _extractGameDbEntries();
        for (const e of dbEntries) {
            if (_searchIndexByAppid.has(e.appid)) {
                _searchIndexByAppid.get(e.appid).store = true;
                continue;
            }
            _searchIndexByAppid.set(e.appid, {
                appid: e.appid, name: e.name, type: 'store',
                owned: false, wishlist: false, store: true,
            });
        }
        // 4) 转数组,仅预计算来源权重 _scoreBias
        //    v2.9.56: 移除 nameLower/nameNoSpace/pinyinAbbr/pinyinAbbrNoSpace 预计算——
        //    searchByPinyin 内部通过 getName(it) 实时重算这些字段,预存值从未被读取(死代码)
        for (const entry of _searchIndexByAppid.values()) {
            entry._scoreBias = entry.owned ? 30 : entry.wishlist ? 20 : 0;
            _searchIndex.push(entry);
        }
        _searchIndexBuilt = true;
        console.log(`[Steam 游戏库展示] 全局搜索索引已构建: ${_searchIndex.length} 条 (owned=${ownedSet.size}, wishlist=${(state.wishlistGames||[]).length}, store=${dbEntries.length})`);
    }

    // 搜索:返回匹配项数组(按优先级排序),最多 30 条
    // v2.9.53 优化:4 级匹配逻辑(100/95/80/75)+ 来源权重(_scoreBias)+ 名称长度排序
    // 全部委托给 sglv-pinyin.lib.js 的 searchByPinyin(),sglv-pinyin.lib.test.js 已覆盖 10 个 case。
    // 降级路径:拼音库未加载时(理论不会发生,@require 强制)返回空数组并 console.warn。
    function searchGames(query, limit = 30) {
        if (!_searchIndexBuilt) buildSearchIndex();
        injectSGLVAppDetailHost();  // v2.9.64: 惰性注入 host API,确保 getOwnershipBadge 可用
        const lib = _getPinyinLib();
        if (!lib) {
            console.warn('[Steam 游戏库展示] 拼音库未加载,搜索不可用');
            return [];
        }
        return lib.searchByPinyin(query, _searchIndex, {
            limit,
            getName: e => e.name,
        });
    }

    // 高亮匹配片段:用 <mark> 包裹
    // v2.9.64: 增加拼音首字母匹配高亮——用户输入"wzry"匹配"王者荣耀"时高亮对应字符
    function highlightMatch(name, query) {
        if (!name || !query) return escHtml(name || '');
        const escaped = escHtml(name);
        const q = String(query).trim();
        if (!q) return escaped;
        // 优先匹配原文字符串(忽略大小写),再尝试拼音首字母
        const lowerName = name.toLowerCase();
        const lowerQ = q.toLowerCase();
        const idx = lowerName.indexOf(lowerQ);
        if (idx >= 0) {
            const before = escHtml(name.slice(0, idx));
            const hit = escHtml(name.slice(idx, idx + q.length));
            const after = escHtml(name.slice(idx + q.length));
            return before + '<mark>' + hit + '</mark>' + after;
        }
        // 去空格匹配
        const nameNoSpace = lowerName.replace(_PUNCT_STRIP_RE, '');
        const qNoSpace = lowerQ.replace(_PUNCT_STRIP_RE, '');
        const idx2 = nameNoSpace.indexOf(qNoSpace);
        if (idx2 >= 0) {
            // 反推原始字符串中的大致位置
            let count = 0, startOrig = -1, endOrig = -1;
            for (let i = 0; i < name.length; i++) {
                const c = name[i].toLowerCase();
                if (!_PUNCT_TEST_RE.test(c)) {
                    if (count === idx2) startOrig = i;
                    if (count === idx2 + qNoSpace.length - 1) { endOrig = i + 1; break; }
                    count++;
                }
            }
            if (startOrig >= 0 && endOrig > startOrig) {
                return escHtml(name.slice(0, startOrig))
                    + '<mark>' + escHtml(name.slice(startOrig, endOrig)) + '</mark>'
                    + escHtml(name.slice(endOrig));
            }
        }
        // v2.9.64: 拼音首字母匹配高亮——toPinyinAbbr 与原名字符 1:1 对应,可直接映射位置
        const lib = _getPinyinLib();
        if (lib && typeof lib.toPinyinAbbr === 'function') {
            const pinyinAbbr = lib.toPinyinAbbr(name).toLowerCase();
            // 先尝试直接子串匹配(含空格)
            const idx3 = pinyinAbbr.indexOf(lowerQ);
            if (idx3 >= 0) {
                return escHtml(name.slice(0, idx3))
                    + '<mark>' + escHtml(name.slice(idx3, idx3 + q.length)) + '</mark>'
                    + escHtml(name.slice(idx3 + q.length));
            }
            // 再尝试去空格后的拼音缩写匹配
            const abbrNoSpace = pinyinAbbr.replace(_PUNCT_STRIP_RE, '');
            const idx4 = abbrNoSpace.indexOf(qNoSpace);
            if (idx4 >= 0) {
                let count2 = 0, startOrig2 = -1, endOrig2 = -1;
                for (let i = 0; i < pinyinAbbr.length; i++) {
                    const c = pinyinAbbr[i];
                    if (!_PUNCT_TEST_RE.test(c)) {
                        if (count2 === idx4) startOrig2 = i;
                        if (count2 === idx4 + qNoSpace.length - 1) { endOrig2 = i + 1; break; }
                        count2++;
                    }
                }
                if (startOrig2 >= 0 && endOrig2 > startOrig2) {
                    return escHtml(name.slice(0, startOrig2))
                        + '<mark>' + escHtml(name.slice(startOrig2, endOrig2)) + '</mark>'
                        + escHtml(name.slice(endOrig2));
                }
            }
        }
        return escaped;
    }

    // ==================== v2.9.51: 全局游戏搜索 - 事件绑定/下拉渲染/键盘导航/游戏跳转 ====================
    // 设计：搜索框绑定防抖输入/键盘/外部点击事件；下拉浮层渲染前 30 条匹配项，
    //      支持 ↑↓ 选择、Enter 跳转、Esc 关闭；游戏条目带 owned/wishlist/store 徽标。
    //      跳转策略：owned → 切到 owned tab 并滚动定位；wishlist → 切到 wishlist tab 并定位；
    //                store-only → 直接打开 Steam 商店页。
    let _gsFocusIdx = -1;            // 当前键盘聚焦的项索引
    let _gsLastResults = [];         // 最近一次搜索结果
    let _gsLastQuery = '';           // 最近一次搜索关键词
    let _gsInputEl = null;           // 搜索输入框
    let _gsPopEl = null;             // 下拉浮层
    let _gsSearchWrap = null;        // 整个搜索容器
    let _gsClearBtn = null;          // 清除按钮

    // 标记搜索索引需重建（数据变化时调用）
    function markSearchIndexDirty() {
        _searchIndexBuilt = false;
    }

    // 切换搜索下拉浮层显隐
    // v2.9.56: 用 classList.toggle 简化 if/else
    function _gsShowPop(show) {
        if (!_gsPopEl) return;
        _gsPopEl.classList.toggle('show', show);
    }

    // 关闭搜索下拉（清空聚焦索引）
    function closeSearchPop() {
        _gsShowPop(false);
        _gsFocusIdx = -1;
    }

    // v2.9.83: Steam 商店搜索建议 (异步合并到本地搜索结果)
    let _gsStoreSearchToken = 0;  // 竞态保护: 每次新查询递增, 旧请求返回时丢弃
    async function searchSteamStore(query) {
        const token = ++_gsStoreSearchToken;
        try {
            const url = `https://store.steampowered.com/api/storesearch/?term=${encodeURIComponent(query)}&l=schinese&cc=cn&max_results=15`;
            const data = await sglvGmFetchRetry(url, { timeout: 5000, retries: 0 });
            if (token !== _gsStoreSearchToken) return [];  // 旧请求, 丢弃
            if (!data || !Array.isArray(data.items)) return [];
            return data.items.map(item => ({
                appid: Number(item.id),
                name: item.name || '',
                type: 'store',
                owned: false,
                wishlist: false,
                store: true,
                _storeResult: true,
                _storeImg: item.tiny_image || '',
                _storePrice: item.prices ? {
                    final: (Number(item.prices.final) || 0) / 100,
                    initial: (Number(item.prices.initial) || 0) / 100,
                    discount: Number(item.prices.discount_percentage) || 0,
                    currency: item.prices.currency || '',
                } : null,
                _storeReview: item.review_desc || '',
            }));
        } catch (e) {
            return [];  // 商店搜索失败, 静默降级
        }
    }

    // v2.9.83: 合并本地+商店搜索结果 (去重, 本地优先)
    function mergeSearchResults(localResults, storeResults) {
        if (!storeResults || storeResults.length === 0) return localResults;
        const localAppids = new Set(localResults.map(r => r.appid));
        const merged = [...localResults];
        for (const sr of storeResults) {
            if (!sr.appid || localAppids.has(sr.appid)) continue;
            // 检查是否已在已拥有/愿望单中 (更新标志)
            if (_searchIndexByAppid.has(sr.appid)) {
                const existing = _searchIndexByAppid.get(sr.appid);
                if (existing.owned || existing.wishlist) continue; // 本地已有, 跳过
            }
            merged.push(sr);
            localAppids.add(sr.appid);
            if (merged.length >= 30) break;
        }
        return merged;
    }

    // v2.9.83: 精准匹配检测 (查询为纯数字时匹配 AppID)
    function detectAppidExactMatch(query) {
        const num = Number(query);
        if (!Number.isInteger(num) || num <= 0) return null;
        // 先检查搜索索引
        if (_searchIndexByAppid.has(num)) {
            const entry = _searchIndexByAppid.get(num);
            return { ...entry, _exactMatch: true };
        }
        // 不在索引中, 也返回一个 store-only 精准匹配项
        return { appid: num, name: `App ${num}`, type: 'store', owned: false, wishlist: false, store: true, _exactMatch: true };
    }

    // v2.11.5 (FEAT-011 TASK-006): 搜索结果项单一构建器——renderSearchResults 与
    // renderSearchResults_merged 原各自内联 ~50 行项模板 + 页脚 + 事件绑定逐字重复,
    // 抽取 buildSearchItem/gsFooterHtml/renderGsResults 三件套共用。
    // 差异清单(2026-08-18 通读原 L4872-5086 实测): 两路径的项模板/页脚/事件绑定三段
    // 完全一致,唯一差异在调用侧——主路径多 searchGames/精准匹配置顶/空态/商店异步合并,
    // _merged 路径仅对既有结果列表重渲染(不触发商店搜索,防递归)。
    // 纯字符串拼装零 DOM 查询,不增加 200ms debounce 高频交互开销
    function buildSearchItem(entry, idx, q) {
        const owned = !!entry.owned, wishlist = !!entry.wishlist, store = !!entry.store;
        // 多个来源时主徽标优先: owned > wishlist > store
        let typeKey, typeText;
        if (owned) { typeKey = 'owned'; typeText = T.gsTypeOwned; }
        else if (wishlist) { typeKey = 'wishlist'; typeText = T.gsTypeWishlist; }
        else { typeKey = 'store'; typeText = T.gsTypeStore; }
        // 次要徽标
        const badges = [];
        if (owned && wishlist) badges.push(`<span class="sglv-gs-item-type wishlist" style="opacity:.6">${escHtml(T.gsTypeWishlist)}</span>`);
        if (owned && store) badges.push(`<span class="sglv-gs-item-type store" style="opacity:.6">${escHtml(T.gsTypeStore)}</span>`);
        // v2.9.83: 精准匹配徽章
        if (entry._exactMatch) badges.push(`<span class="sglv-gs-item-type" style="background:rgba(74,222,128,0.15);color:#4ade80;border:1px solid rgba(74,222,128,0.25)">${isZh ? '精准匹配' : 'Exact'}</span>`);
        // v2.9.53: 拥有/共享状态徽章(基于 SGLVAppDetail.getOwnershipBadge)
        // 直接传 entry._gameObj(O(1) 替代库内 Array.find,30 条结果渲染 30x 提速)
        // _gameObj 仅在 owned 条目上存在,wishlist/store-only 跳过即可
        let ownershipBadge = '';
        try {
            if (unsafeWindow.SGLVAppDetail && entry._gameObj) {
                const b = unsafeWindow.SGLVAppDetail.getOwnershipBadge(entry.appid, entry._gameObj);
                if (b && b.kind === 'shared') {
                    // 家庭共享:紫色徽章 + tooltip 显示共享者
                    const tip = b.tip ? escHtml(b.tip) : (isZh ? '家庭库中共享' : 'Family shared');
                    const lbl = isZh ? '共享' : 'Shared';
                    ownershipBadge = `<span class="sglv-gs-item-shared" title="${tip}">${lbl}</span>`;
                }
            }
        } catch (e) { /* ignore */ }
        const subText = owned ? T.gsJumpToOwned : wishlist ? T.gsJumpToWishlist : T.gsOpenStore;
        const htmlName = highlightMatch(entry.name, q);
        // v2.11.44: getGameIconUrl 定义于下方渲染子闭包(7718 行 IIFE)，此处 bare 引用不可见——
        // 旧 typeof 守卫恒为 false，缩略图从未真正接通过 capsule 兜底；改经 SGLV_API 桥接
        // (渲染子闭包求值时已填充，全局搜索渲染时必可用)
        const capSrc = entry._storeImg || (SGLV_API.getGameIconUrl ? SGLV_API.getGameIconUrl(entry.appid, '') : '');
        // v2.9.58: 外链图标仅在 store-only 时显示(owned/wishlist 是面板内跳转)
        const extIcon = (!owned && !wishlist) ? `<span class="sglv-gs-item-ext">${ICONS.external}</span>` : '';
        // v2.9.83: 商店搜索结果附加价格/评测信息
        let storeInfoHtml = '';
        if (entry._storeResult && entry._storePrice && entry._storePrice.final > 0) {
            const sp = entry._storePrice;
            // v2.9.100: ¥ 硬编码替换为 sglvCurrencySymbol，优先走 SGLVCurrency lib（sp.currency 缺失时 fallback '¥'）
            const sym = sglvCurrencySymbol(sp.currency);
            const priceStr = `${sym}${sp.final.toFixed(2)}`;
            const discountStr = sp.discount > 0 ? `<span style="color:#4ade80;font-weight:700">-${sp.discount}%</span>` : '';
            const origStr = sp.discount > 0 && sp.initial > sp.final ? `<span style="text-decoration:line-through;color:var(--sgis-text-2);font-size:9px">${sym}${sp.initial.toFixed(2)}</span>` : '';
            storeInfoHtml = ` · ${discountStr} ${priceStr} ${origStr}`;
        } else if (entry._storeResult && entry._storeReview) {
            storeInfoHtml = ` · ${escHtml(entry._storeReview)}`;
        }
        return `<div class="sglv-gs-item${entry._exactMatch ? ' sglv-gs-item-exact' : ''}" data-idx="${idx}" data-appid="${entry.appid}" data-type="${typeKey}">
            <div class="sglv-gs-item-thumb">${capSrc ? `<img src="${capSrc}" alt="" loading="lazy" onerror="this.onerror=null;_sglvIconFallback(this,'${entry.appid}','')">` : ''}</div>
            <div class="sglv-gs-item-body">
                <div class="sglv-gs-item-name">${htmlName}</div>
                <div class="sglv-gs-item-sub">${escHtml(subText)} · AppID ${entry.appid}${storeInfoHtml}</div>
            </div>
            <div class="sglv-gs-item-right">
                <span class="sglv-gs-item-type ${typeKey}">${escHtml(typeText)}</span>
                ${ownershipBadge}
                ${badges.join('')}
                ${extIcon}
            </div>
        </div>`;
    }

    // v2.11.5: 搜索页脚键盘提示(两路径共用)
    function gsFooterHtml() {
        return isZh
            ? `<div class="sglv-gs-footer">
                <span class="sglv-gs-footer-hint"><kbd>↑</kbd><kbd>↓</kbd> 选择</span>
                <span class="sglv-gs-footer-hint"><kbd>Enter</kbd> 跳转</span>
                <span class="sglv-gs-footer-hint"><kbd>Esc</kbd> 关闭</span>
            </div>`
            : `<div class="sglv-gs-footer">
                <span class="sglv-gs-footer-hint"><kbd>↑</kbd><kbd>↓</kbd> Navigate</span>
                <span class="sglv-gs-footer-hint"><kbd>Enter</kbd> Open</span>
                <span class="sglv-gs-footer-hint"><kbd>Esc</kbd> Close</span>
            </div>`;
    }

    // v2.11.5: 头部+列表+页脚渲染与条目事件绑定(两路径共用;调用方保证 _gsPopEl 与结果数组就绪)
    function renderGsResults(q, results) {
        const header = `<div class="sglv-gs-header"><span>${escHtml(T.gsHeader)}</span><span class="sglv-gs-header-count">${results.length}</span></div>`;
        const items = results.map((entry, idx) => buildSearchItem(entry, idx, q)).join('');
        _gsPopEl.innerHTML = header + items + gsFooterHtml();
        _gsShowPop(true);
        // 绑定每项点击
        _gsPopEl.querySelectorAll('.sglv-gs-item').forEach(itemEl => {
            const idx = Number(itemEl.dataset.idx);
            itemEl.addEventListener('mouseenter', () => {
                _gsFocusIdx = idx;
                _gsUpdateFocusClass();
            });
            itemEl.addEventListener('click', (ev) => {
                ev.preventDefault(); ev.stopPropagation();
                const target = _gsLastResults[idx];
                if (target) _gsJumpToGame(target);
            });
        });
    }

    // 渲染搜索结果下拉
    function renderSearchResults(query) {
        if (!_gsPopEl) return;
        const q = String(query || '').trim();
        if (!q) { _gsShowPop(false); _gsLastResults = []; return; }
        const results = searchGames(q, 30);
        _gsLastQuery = q;
        _gsFocusIdx = -1;
        // v2.9.83: 精准匹配检测
        const exactMatch = detectAppidExactMatch(q);
        if (exactMatch) {
            // 精准匹配项放在第一位 (去重: 如果已在结果中则提升到第一位)
            const idx = results.findIndex(r => r.appid === exactMatch.appid);
            if (idx >= 0) {
                results[idx]._exactMatch = true;
                results.unshift(results.splice(idx, 1)[0]);
            } else {
                results.unshift(exactMatch);
            }
        }
        _gsLastResults = results;
        // 空结果
        if (results.length === 0) {
            _gsPopEl.innerHTML = `<div class="sglv-gs-empty">
                <div class="sglv-gs-empty-icon">${ICONS.search}</div>
                <span>${escHtml(T.gsEmpty)}</span>
            </div>`;
            _gsShowPop(true);
            return;
        }
        // v2.11.5: 头部+列表+页脚渲染与事件绑定经 renderGsResults 共用(原内联段删除)
        renderGsResults(q, results);
        // v2.9.83: 本地结果不足 8 条时,异步合并 Steam 商店搜索建议
        if (results.length < 8 && !exactMatch) {
            searchSteamStore(q).then(storeResults => {
                if (storeResults.length === 0) return;
                if (_gsLastQuery !== q) return;  // 用户已输入新查询, 丢弃旧结果
                const merged = mergeSearchResults(_gsLastResults, storeResults);
                if (merged.length === _gsLastResults.length) return;  // 无新增, 不重渲染
                _gsLastResults = merged;
                _gsFocusIdx = -1;
                // 重新渲染合并后的结果 (递归调用, 但此次 results.length >= 8 不会再次触发商店搜索)
                renderSearchResults_merged(q, merged);
            }).catch(() => {});
        }
    }

    // v2.9.83: 合并后重渲染 (不触发商店搜索, 避免递归)
    function renderSearchResults_merged(query, results) {
        if (!_gsPopEl || results.length === 0) return;
        renderGsResults(query, results);
    }

    // 更新键盘聚焦项高亮
    function _gsUpdateFocusClass() {
        if (!_gsPopEl) return;
        const items = _gsPopEl.querySelectorAll('.sglv-gs-item');
        items.forEach((el, i) => {
            if (i === _gsFocusIdx) el.classList.add('focus');
            else el.classList.remove('focus');
        });
        // 滚动到可视区
        if (_gsFocusIdx >= 0 && items[_gsFocusIdx]) {
            items[_gsFocusIdx].scrollIntoView({ block: 'nearest', behavior: 'smooth' });
        }
    }

    // v2.9.63: 游戏详情浮窗 —— 点击搜索结果后弹出详情卡片
    // 依赖 SGLVAppDetail.loadDetail() 获取 appdetails 数据(内存5min+磁盘24h缓存)
    let _detailEscHandler = null;
    let _detailToken = 0;  // v2.9.64: 异步竞态保护——快速连续点击不同搜索结果时丢弃旧请求结果

    function closeDetailPopup() {
        _detailToken++;  // 使任何在途的详情请求失效
        const overlay = document.getElementById('sglv-detail-overlay');
        const pop = document.getElementById('sglv-detail-pop');
        if (overlay) overlay.classList.remove('show');
        if (pop) { pop.classList.remove('show'); pop.innerHTML = ''; }
        if (_detailEscHandler) {
            document.removeEventListener('keydown', _detailEscHandler);
            _detailEscHandler = null;
        }
    }

    function _bindDetailClose(pop) {
        const overlay = document.getElementById('sglv-detail-overlay');
        const closeBtn = pop.querySelector('#sglv-detail-close-btn');
        if (closeBtn) closeBtn.addEventListener('click', closeDetailPopup);
        if (overlay) overlay.onclick = closeDetailPopup;  // 覆盖式绑定,避免重复
        if (_detailEscHandler) document.removeEventListener('keydown', _detailEscHandler);
        _detailEscHandler = (e) => { if (e.key === 'Escape') closeDetailPopup(); };
        document.addEventListener('keydown', _detailEscHandler);
    }

    function showGameDetailPopup(appid, entry) {
        const overlay = document.getElementById('sglv-detail-overlay');
        const pop = document.getElementById('sglv-detail-pop');
        if (!overlay || !pop) { console.warn('[SGLV] 详情浮窗容器未找到'); return; }
        injectSGLVAppDetailHost();  // v2.9.64: 惰性注入 host API,确保 loadDetail 可用
        const token = ++_detailToken;  // 每次打开递增,旧请求 resolve 后比对发现不一致则丢弃
        // 加载态
        pop.innerHTML = `<button class="sglv-detail-close" id="sglv-detail-close-btn">${ICONS.close}</button>
            <div class="sglv-detail-scroll"><div class="sglv-detail-loading">
                ${spinSvg(34)}
                <span>${escHtml(T.dpLoading)}</span>
            </div></div>`;
        overlay.classList.add('show');
        pop.classList.add('show');
        _bindDetailClose(pop);
        _loadAndRenderDetail(appid, entry, pop, token);
    }

    async function _loadAndRenderDetail(appid, entry, pop, token) {
        const A = (typeof unsafeWindow !== 'undefined' && unsafeWindow.SGLVAppDetail)
            || (typeof window !== 'undefined' && window.SGLVAppDetail);
        if (!A || typeof A.loadDetail !== 'function') {
            if (token !== _detailToken) return;  // 已被新请求取代
            _renderDetailError(pop, appid, entry, 'SGLVAppDetail 库未加载');
            return;
        }
        try {
            const d = await A.loadDetail(appid, { useCache: true });
            if (token !== _detailToken) return;  // 已被新请求取代,丢弃旧结果
            if (!d) { _renderDetailError(pop, appid, entry, 'API 无数据返回'); return; }
            _renderDetailContent(pop, appid, entry, d);
        } catch (e) {
            if (token !== _detailToken) return;  // 已被新请求取代
            _renderDetailError(pop, appid, entry, e.message || String(e));
        }
    }

    function _renderDetailError(pop, appid, entry, msg) {
        pop.innerHTML = `<button class="sglv-detail-close" id="sglv-detail-close-btn">${ICONS.close}</button>
            <div class="sglv-detail-scroll"><div class="sglv-detail-error">
                <span>${escHtml(T.dpError)}</span>
                <span style="font-size:10px;color:#6e7681">${escHtml(msg)}</span>
                <button class="sglv-detail-btn sglv-detail-btn-secondary" id="sglv-detail-retry">${escHtml(T.dpRetry)}</button>
            </div></div>`;
        _bindDetailClose(pop);
        const retry = pop.querySelector('#sglv-detail-retry');
        if (retry) retry.addEventListener('click', () => showGameDetailPopup(appid, entry));
    }

    // v2.9.93: 异步填充资料受限状态徽章到搜索详情浮窗
    // 参考 Nailoooooong/steam-restricted-game-realtime-userscript 的状态检测逻辑:
    // 获取商店页 HTML → 解析 .game_area_details_specs_ctn.learning_about → 判断资料受限/正在了解/正常
    async function _fillProfileStatusBadge(pop, appid, token) {
        const statusEl = pop.querySelector('#sglv-detail-profile-status');
        if (!statusEl) return;
        const _renderBadge = (info) => {
            if (!info || info.status === 'normal') return;
            const title = info.status === 'restricted'
                ? 'Profile Features Limited：该游戏的卡片、成就、游玩时长等资料不会显示在 Steam 个人资料页'
                : 'Steam 正在了解该游戏，部分资料功能可能暂时受限';
            statusEl.innerHTML = `<span class="sgis-profile-badge ${escHtml(info.status)}" title="${escHtml(title)}">${ICONS.profileLimited} ${escHtml(info.label)}</span>`;
        };
        // 1. 先看缓存
        const cached = cacheGet('profileFeatures_' + appid);
        if (cached) { _renderBadge(cached); return; }
        // 2. 异步获取商店页 HTML
        // v2.11.36 (FEAT-015 TASK-003): 迁移至 sglvGmFetchTextRetry（headers 透传依赖 core 1.0.6；
        //   年龄验证 Cookie/Accept-Language 是功能正确性依赖——丢失则返回年龄验证页/本地语言页致误判）
        try {
            const url = `https://store.steampowered.com/app/${appid}/?l=english&cc=us`;
            const html = await sglvGmFetchTextRetry(url, {
                timeout: 15000,
                headers: {
                    'Accept': 'text/html',
                    'Accept-Language': 'en-US,en;q=0.9',
                    'Cookie': 'mature_content=1; birthtime=441734400; lastagecheckage=1-January-1900; Steam_Language=english',
                },
            });
            if (token !== _detailToken) return;  // 已被新请求取代
            const doc = new DOMParser().parseFromString(html, 'text/html');
            const learningEl = doc.querySelector('.game_area_details_specs_ctn.learning_about');
            let result;
            if (!learningEl) {
                result = { status: 'normal', label: '资料正常', source: 'fetch' };
            } else {
                const labelEl = learningEl.querySelector('.label');
                const labelText = (labelEl ? labelEl.textContent : '') || learningEl.textContent || '';
                if (/Profile\s+Features\s+Limited/i.test(labelText)) {
                    result = { status: 'restricted', label: '资料受限', source: 'fetch' };
                } else {
                    result = { status: 'learning', label: 'Steam正在了解', source: 'fetch' };
                }
            }
            cacheSet('profileFeatures_' + appid, result, CACHE_TTL.profileFeatures);
            if (token !== _detailToken) return;
            _renderBadge(result);
        } catch (e) {
            // 静默失败,不影响浮窗正常使用
            // v2.11.36 (FEAT-015 TASK-003): 补终态失败通知(60s 节流,此前完全静默)
            sglvNotifyNetFail('资料受限徽章检测', e);
        }
    }

    function _renderDetailContent(pop, appid, entry, d) {
        const platforms = [];
        if (d.platforms) {
            if (d.platforms.win) platforms.push('Windows');
            if (d.platforms.mac) platforms.push('macOS');
            if (d.platforms.linux) platforms.push('SteamOS+Linux');
        }
        // 价格
        // v2.9.85: 修复货币符号 — 优先使用 entry._gameObj 中的用户地区价格(detectWlPriceSymbol 符号),
        //   其次根据 d.cnPrice.currency 选择正确符号(Steam 可能对登录用户忽略 cc=cn,
        //   返回用户实际所在地区价格如 INR,但旧代码硬编码 ¥ 导致符号与价格不符)
        let priceHtml = '';
        if (d.isFree) {
            priceHtml = `<span class="sglv-detail-price-free">${escHtml(T.dpFree)}</span>`;
        } else {
            const gi = (entry && entry._gameObj) ? entry._gameObj : null;
            if (gi && Number(gi.finalPrice) > 0) {
                const sym = SGLV_API.detectWlPriceSymbol ? SGLV_API.detectWlPriceSymbol() : '¥';
                priceHtml = `<span class="sglv-detail-price-val">${sym}${escHtml(String(gi.finalPrice))}</span>`;
                if (gi.discountPct > 0) priceHtml += `<span class="sglv-detail-price-discount">-${escHtml(String(gi.discountPct))}%</span>`;
            } else if (d.cnPrice) {
                const curSym = sglvCurrencySymbol(d.cnPrice.currency);
                priceHtml = `<span class="sglv-detail-price-val">${curSym}${escHtml(String(d.cnPrice.price))}</span>`;
                if (d.cnPrice.discount > 0) priceHtml += `<span class="sglv-detail-price-discount">-${escHtml(String(d.cnPrice.discount))}%</span>`;
            }
        }
        // Metacritic
        let metaHtml = '';
        if (d.metacritic && d.metacritic.score) {
            const s = d.metacritic.score;
            const c = s >= 75 ? '#4ade80' : s >= 50 ? '#fbbf24' : '#f87171';
            metaHtml = `<a class="sglv-detail-metacritic" href="${escHtml(d.metacritic.url || '#')}" target="_blank" rel="noopener" style="background:${c}22;color:${c};border:1px solid ${c}55">Metacritic ${escHtml(String(s))}</a>`;
        }
        // 评测摘要
        let reviewHtml = '';
        if (d.reviews && d.reviews.summary) {
            reviewHtml = `<div style="font-size:11px;color:#8b949e;margin:6px 0">${escHtml(d.reviews.summary)}${d.reviews.count ? ` (${escHtml(d.reviews.count)})` : ''}</div>`;
        }
        // 类型标签
        const genresHtml = (d.genres && d.genres.length)
            ? `<div class="sglv-detail-tags">${d.genres.map(g => `<span class="sglv-detail-tag">${escHtml(g)}</span>`).join('')}</div>` : '';
        // 截图
        const shotsHtml = (d.screenshots && d.screenshots.length)
            ? `<div class="sglv-detail-shots">${d.screenshots.slice(0, 6).map(s =>
                `<div class="sglv-detail-shot"><img src="${escHtml(s.thumbnail || s.full)}" alt="" loading="lazy" onerror="this.parentElement.style.display='none'"></div>`
              ).join('')}</div>` : '';
        // 操作按钮
        const storeUrl = `https://store.steampowered.com/app/${appid}`;
        let actionsHtml = `<a class="sglv-detail-btn sglv-detail-btn-primary" href="${storeUrl}" target="_blank" rel="noopener">${escHtml(T.dpStorePage)}</a>`;
        if (entry && entry.owned) {
            actionsHtml += `<button class="sglv-detail-btn sglv-detail-btn-secondary" id="sglv-detail-jump-lib">${escHtml(T.dpJumpLib)}</button>`;
        } else if (entry && entry.wishlist) {
            actionsHtml += `<button class="sglv-detail-btn sglv-detail-btn-secondary" id="sglv-detail-jump-wl">${escHtml(T.dpJumpWl)}</button>`;
        }
        // v2.9.110: AI 对话入口（检测到 SteamAgent 插件时显示）
        const _saAgent = (typeof unsafeWindow !== 'undefined' && unsafeWindow.SteamAgent) || window.SteamAgent;
        if (_saAgent && typeof _saAgent.isInstalled === 'function' && _saAgent.isInstalled()) {
            actionsHtml += `<button class="sglv-detail-btn sglv-detail-btn-ai" id="sglv-detail-ask-ai">🤖 问 AI</button>`;
        }

        pop.innerHTML = `<button class="sglv-detail-close" id="sglv-detail-close-btn">${ICONS.close}</button>
            <div class="sglv-detail-scroll">
                ${d.cover ? `<div class="sglv-detail-hero"><img src="${escHtml(d.cover)}" alt="" onerror="this.parentElement.style.display='none'"></div>` : ''}
                <div class="sglv-detail-body">
                    <div class="sglv-detail-name">${escHtml(d.name || (entry && entry.name) || '')}</div>
                    <div style="display:flex;align-items:center;flex-wrap:wrap;gap:6px;margin-top:4px">${metaHtml}<span id="sglv-detail-profile-status"></span></div>
                    ${reviewHtml}
                    ${d.shortDesc ? `<div class="sglv-detail-desc">${escHtml(d.shortDesc)}</div>` : ''}
                    <dl class="sglv-detail-meta">
                        ${d.developers && d.developers.length ? `<dt>${escHtml(T.dpDeveloper)}</dt><dd>${escHtml(d.developers.join(', '))}</dd>` : ''}
                        ${d.publishers && d.publishers.length ? `<dt>${escHtml(T.dpPublisher)}</dt><dd>${escHtml(d.publishers.join(', '))}</dd>` : ''}
                        ${d.releaseDate ? `<dt>${escHtml(T.dpRelease)}</dt><dd>${escHtml(d.releaseDate)}</dd>` : ''}
                        ${platforms.length ? `<dt>${escHtml(T.dpPlatforms)}</dt><dd>${escHtml(platforms.join(', '))}</dd>` : ''}
                        ${priceHtml ? `<dt>${escHtml(T.dpPrice)}</dt><dd>${priceHtml}</dd>` : ''}
                    </dl>
                    ${genresHtml}
                    ${shotsHtml}
                    <div class="sglv-detail-actions">${actionsHtml}</div>
                </div>
            </div>`;
        _bindDetailClose(pop);

        // 跳转到游戏库/愿望单按钮
        const jumpLib = pop.querySelector('#sglv-detail-jump-lib');
        if (jumpLib) jumpLib.addEventListener('click', () => {
            closeDetailPopup();
            if (state.activeTab !== 'owned') switchToTab('owned');
            else if (SGLV_API.renderBody) SGLV_API.renderBody();
            requestAnimationFrame(() => _gsScrollToAppid(entry.appid, '#sglv-body'));
            showToast(`🎮 ${entry.name}`);
        });
        const jumpWl = pop.querySelector('#sglv-detail-jump-wl');
        if (jumpWl) jumpWl.addEventListener('click', () => {
            closeDetailPopup();
            if (state.activeTab !== 'wishlist') switchToTab('wishlist');
            else if (SGLV_API.renderBody) SGLV_API.renderBody();
            requestAnimationFrame(() => _gsScrollToAppid(entry.appid, '#sglv-body'));
            showToast(`💖 ${entry.name}`);
        });

        // v2.9.110: 问 AI 按钮
        const askAi = pop.querySelector('#sglv-detail-ask-ai');
        if (askAi) askAi.addEventListener('click', () => {
            const sa = (typeof unsafeWindow !== 'undefined' && unsafeWindow.SteamAgent) || window.SteamAgent;
            if (!sa || !sa.open) return;
            const gameName = d.name || (entry && entry.name) || '';
            const prompt = `请帮我分析 Steam 游戏「${gameName}」(AppID: ${appid})，包括：\n1. 游戏评价和口碑\n2. 当前价格是否值得入手\n3. 类型和玩法特点\n4. 适合什么样的玩家`;
            closeDetailPopup();
            sa.open({ message: prompt });
        });

        // v2.9.93: 异步获取资料受限状态并填充到浮窗 (参考 steam-restricted-game-realtime-userscript)
        // 搜索详情浮窗不在游戏商店页,需通过 GM_xmlhttpRequest 获取商店页 HTML 检测
        _fillProfileStatusBadge(pop, appid, token);
    }

    // 跳转游戏核心逻辑
    // v2.9.63: 统一弹出游戏详情浮窗(owned/wishlist/store-only 均显示详情)
    // 浮窗内提供"跳转到游戏库/愿望单"按钮实现原有跳转功能
    function _gsJumpToGame(entry) {
        if (!entry) return;
        closeSearchPop();
        // 关闭下拉后清空输入框
        if (_gsInputEl) {
            _gsInputEl.value = '';
            _gsInputEl.dispatchEvent(new Event('input'));
        }
        showGameDetailPopup(entry.appid, entry);
    }

    // 在已渲染的列表中滚动定位 appid
    function _gsScrollToAppid(appid, containerSel = '#sglv-body') {
        try {
            const container = document.querySelector(containerSel);
            if (!container) return false;
            // 尝试多种选择器（cover/card/list 三种视图）
            const selectors = [
                `.sglv-cover-name[data-sglv-appid="${appid}"]`,
                `.sglv-card-name[data-sglv-appid="${appid}"]`,
                `.sglv-list-name[data-sglv-appid="${appid}"]`,
                `.sglv-game-card[data-appid="${appid}"]`,
                `.sglv-wl-cover-card[data-appid="${appid}"]`,
                `.sglv-list-item[data-appid="${appid}"]`,
                `[data-sglv-appid="${appid}"]`,
                `[data-appid="${appid}"]`,
            ];
            for (const sel of selectors) {
                const el = container.querySelector(sel);
                if (el) {
                    el.scrollIntoView({ behavior: 'smooth', block: 'center' });
                    // 视觉高亮
                    const card = el.closest('.sglv-game-card, .sglv-wl-cover-card, .sglv-list-item, .sglv-cover-card, .sglv-cover-item, .sglv-card-grid > div, .sglv-list-view > div') || el;
                    if (card && card.style) {
                        const orig = card.style.boxShadow;
                        card.style.boxShadow = '0 0 0 3px rgba(102, 192, 244, 0.8), 0 0 24px rgba(102, 192, 244, 0.6)';
                        card.style.transition = 'box-shadow 0.3s ease';
                        setTimeout(() => { card.style.boxShadow = orig; }, 2400);
                    }
                    return true;
                }
            }
            // 列表里没找到——可能受分页/搜索过滤影响,提示用户
            showToast(isZh ? '该游戏在当前视图未显示（可能受分页或搜索过滤影响）' : 'Game not visible (pagination/search filter?)');
            return false;
        } catch (e) {
            console.warn('[SGLV] 搜索跳转滚动失败:', e);
            return false;
        }
    }

    // 输入防抖
    const _gsDebouncedRender = debounce((q) => renderSearchResults(q), 150);

    // 绑定全局搜索框全部事件
    function bindGlobalSearchEvents() {
        const _panel = SGLV_API.getPanelEl && SGLV_API.getPanelEl();  // v2.9.61: panelEl 在子闭包内,经 SGLV_API 桥接
        _gsInputEl = _panel?.querySelector('#sglv-global-search-input');
        _gsPopEl = _panel?.querySelector('#sglv-global-search-pop');
        _gsSearchWrap = _panel?.querySelector('#sglv-global-search');
        _gsClearBtn = _panel?.querySelector('#sglv-global-search-clear');
        if (!_gsInputEl || !_gsPopEl) return;
        // 输入事件
        const onInput = () => {
            const v = _gsInputEl.value;
            // 切换清除按钮显隐
            if (v) _gsSearchWrap.classList.add('has-text');
            else _gsSearchWrap.classList.remove('has-text');
            if (!v.trim()) {
                _gsShowPop(false);
                _gsLastResults = [];
                _gsFocusIdx = -1;
                return;
            }
            _gsDebouncedRender(v);
        };
        _gsInputEl.addEventListener('input', onInput);
        addDisposer(() => _gsInputEl.removeEventListener('input', onInput));
        // 焦点聚焦 → 如有内容则打开下拉
        const onFocus = () => {
            if (_gsInputEl.value.trim() && _gsLastResults.length) _gsShowPop(true);
        };
        _gsInputEl.addEventListener('focus', onFocus);
        addDisposer(() => _gsInputEl.removeEventListener('focus', onFocus));
        // 键盘事件
        const onKeydown = (e) => {
            const key = e.key;
            if (key === 'ArrowDown') {
                e.preventDefault();
                if (!_gsLastResults.length) return;
                _gsShowPop(true);
                _gsFocusIdx = (_gsFocusIdx + 1) % _gsLastResults.length;
                _gsUpdateFocusClass();
            } else if (key === 'ArrowUp') {
                e.preventDefault();
                if (!_gsLastResults.length) return;
                _gsShowPop(true);
                _gsFocusIdx = _gsFocusIdx <= 0 ? _gsLastResults.length - 1 : _gsFocusIdx - 1;
                _gsUpdateFocusClass();
            } else if (key === 'Enter') {
                e.preventDefault();
                if (_gsFocusIdx >= 0 && _gsLastResults[_gsFocusIdx]) {
                    _gsJumpToGame(_gsLastResults[_gsFocusIdx]);
                } else if (_gsLastResults.length > 0) {
                    _gsJumpToGame(_gsLastResults[0]);
                }
            } else if (key === 'Escape') {
                e.preventDefault();
                if (_gsPopEl.classList.contains('show')) {
                    closeSearchPop();
                } else {
                    _gsInputEl.value = '';
                    _gsInputEl.dispatchEvent(new Event('input'));
                    _gsInputEl.blur();
                }
            }
        };
        _gsInputEl.addEventListener('keydown', onKeydown);
        addDisposer(() => _gsInputEl.removeEventListener('keydown', onKeydown));
        // 清除按钮
        if (_gsClearBtn) {
            const onClear = (e) => {
                e.preventDefault(); e.stopPropagation();
                _gsInputEl.value = '';
                _gsInputEl.dispatchEvent(new Event('input'));
                _gsInputEl.focus();
            };
            _gsClearBtn.addEventListener('click', onClear);
            addDisposer(() => _gsClearBtn.removeEventListener('click', onClear));
        }
        // 点击外部关闭下拉
        const onDocClick = (e) => {
            if (!_gsSearchWrap) return;
            if (_gsSearchWrap.contains(e.target)) return;
            closeSearchPop();
        };
        // 用 mousedown 比 click 早,避免点击下拉项后被外部关闭抢断
        document.addEventListener('mousedown', onDocClick, true);
        addDisposer(() => document.removeEventListener('mousedown', onDocClick, true));
        // 切换 tab 时关闭下拉
        const onTabClick = (e) => {
            if (e.target.closest('.sglv-tab')) closeSearchPop();
        };
        _panel?.addEventListener('click', onTabClick);
        addDisposer(() => _panel?.removeEventListener('click', onTabClick));
    }

    // 暴露搜索函数到全局,便于其他模块(如侧边栏)调用
    unsafeWindow.SGLVSearch = {
        search: searchGames,
        build: buildSearchIndex,
        dirty: markSearchIndexDirty,
        jump: (appid) => {
            // 由 appid 跳转（兼容调用方）
            if (!_searchIndexBuilt) buildSearchIndex();
            const entry = _searchIndexByAppid.get(Number(appid));
            if (entry) { _gsJumpToGame(entry); return true; }
            return false;
        },
    };

    // v2.9.53: 把主脚本的拥有/共享判定 API 注入到 sglv-app-detail 库,
    // 这样搜索结果下拉和其他上层都能用 SGLVAppDetail.getOwnershipBadge(appid) 拿到统一状态
    // v2.9.64: 从 IIFE 改为惰性注入——@require 脚本可能因网络延迟晚于主脚本执行,
    //   启动时注入会静默失败。改为在 searchGames/showGameDetailPopup 首次调用时尝试注入。
    let _hostApiInjected = false;
    function injectSGLVAppDetailHost() {
        if (_hostApiInjected) return;
        try {
            const A = (typeof unsafeWindow !== 'undefined' && unsafeWindow.SGLVAppDetail)
                || (typeof window !== 'undefined' && window.SGLVAppDetail);
            if (!A || typeof A.setHostApi !== 'function') return;
            A.setHostApi({
                getOwnedGames: () => state.ownedGames,
                isGameOwnedByMe: (g) => isGameOwnedByMe(g),
                getGameOwnerNames: (g) => getGameOwnerNames(g),
                getActiveSteamId: () => getActiveSteamId(),
            });
            _hostApiInjected = true;
        } catch (e) { /* ignore - lib 未加载时静默,下次调用会重试 */ }
    }

    // 分页切片纯函数（统一各标签页分页计算）
    function paginate(items, page, size) {
        const totalPages = Math.max(1, Math.ceil(items.length / size));
        const clampedPage = Math.min(Math.max(1, page), totalPages);
        const start = (clampedPage - 1) * size;
        return { pageItems: items.slice(start, start + size), totalPages, page: clampedPage };
    }

    // 资源清理机制：统一收集事件监听器/MutationObserver/定时器，卸载时清理，避免内存泄漏
    const disposers = [];
    function addDisposer(fn) { if (typeof fn === 'function') disposers.push(fn); }
    function runDisposers() { while (disposers.length) { try { (disposers.pop())(); } catch (e) {} } }

    // 封面图成功 URL 内存缓存：记录已成功加载的封面地址，下次优先使用，减少回退探测请求
    // v2.4.3: 缓存键按图片种类（poster/capsule/header）隔离，避免竖版海报 URL 被横版封面复用导致裁切变形
    const _posterGoodUrl = new Map();
    function recordPosterGood(appid, url, kind) { if (appid && url) _posterGoodUrl.set(`${kind || 'poster'}:${appid}`, url); }
    function getPosterGood(appid, kind) { return _posterGoodUrl.get(`${kind || 'poster'}:${appid}`); }
    // 暴露给内联 onload 使用
    unsafeWindow._sglvRecordPosterGood = function(appid, url, kind) { recordPosterGood(appid, url, kind); };

    // v2.10.0: AI 配置共享 — 优先读取 steam-ai-agent 插件的配置，避免重复配置 apiKey
    function _getSharedAiConfig() {
        try {
            const sa = (typeof unsafeWindow !== 'undefined' && unsafeWindow.SteamAgent) || window.SteamAgent;
            if (sa && typeof sa.getActiveModel === 'function') {
                const m = sa.getActiveModel();
                if (m && m.apiKey) return { apiKey: m.apiKey, apiUrl: m.apiUrl, model: m.model };
            }
        } catch {}
        try {
            const raw = GM_getValue('sa_model_configs', null);
            const models = typeof raw === 'string' ? JSON.parse(raw) : raw;
            if (Array.isArray(models) && models.length > 0) {
                const activeId = GM_getValue('sa_active_model', '');
                const m = models.find(x => x.id === activeId) || models[0];
                if (m && m.apiKey) return { apiKey: m.apiKey, apiUrl: m.apiUrl, model: m.model };
            }
        } catch {}
        try {
            const agentKey = GM_getValue('sa_ai_api_key', '');
            if (agentKey) return {
                apiKey: agentKey,
                apiUrl: GM_getValue('sa_ai_api_url', '') || 'https://api.deepseek.com/v1/chat/completions',
                model: GM_getValue('sa_ai_api_model', '') || 'deepseek-v4-pro',
            };
        } catch {}
        return null;
    }

    const storage = {
        // ---- 小对象：保持 GM_setValue（同步、零延迟、几 KB 级别）----
        getApiKey: () => GM_getValue(nsKey('api_key'), ''),
        setApiKey: v => GM_setValue(nsKey('api_key'), v),
        getSteamId: () => GM_getValue(nsKey('steamid'), ''),
        setSteamId: v => GM_setValue(nsKey('steamid'), v),
        getShowFamilyShared: () => GM_getValue(nsKey('show_family_shared'), true),
        setShowFamilyShared: v => GM_setValue(nsKey('show_family_shared'), v),
        // ---- v2.4.5: 库存排序偏好 ----
        getOwnedSort: () => GM_getValue(nsKey('owned_sort'), 'appidAsc'),
        setOwnedSort: v => GM_setValue(nsKey('owned_sort'), v),
        // ---- v2.11.40: UI 主题偏好（典雅紫 purple / 经典蓝 blue，默认典雅紫） ----
        getUiTheme: () => GM_getValue(nsKey('ui_theme'), 'purple'),
        setUiTheme: v => GM_setValue(nsKey('ui_theme'), v),
        // ---- AI 模型配置 (v2.10.0: 优先共享 Steam AI Agent 插件配置) ----
        getAiApiUrl: () => _getSharedAiConfig()?.apiUrl || GM_getValue(nsKey('ai_api_url'), 'https://api.deepseek.com/v1/chat/completions'),
        setAiApiUrl: v => GM_setValue(nsKey('ai_api_url'), v),
        getAiApiKey: () => _getSharedAiConfig()?.apiKey || GM_getValue(nsKey('ai_api_key'), ''),
        setAiApiKey: v => GM_setValue(nsKey('ai_api_key'), v),
        getAiModel: () => _getSharedAiConfig()?.model || GM_getValue(nsKey('ai_model'), 'deepseek-v4-pro'),
        setAiModel: v => GM_setValue(nsKey('ai_model'), v),
        // ---- v2.9.79: ITAD API Key 配置 (价格增强) ----
        getItadApiKey: () => GM_getValue(nsKey('itad_api_key'), ''),
        setItadApiKey: v => GM_setValue(nsKey('itad_api_key'), v),
        // ---- AI 价格预测模式配置 (v2.3) ----
        getPredictModes: () => {
            const arr = parseStored(nsKey('predict_modes'), ['seasonal', 'trend', 'lowest']);
            return Array.isArray(arr) && arr.length ? arr : ['seasonal', 'trend', 'lowest'];
        },
        setPredictModes: v => GM_setValue(nsKey('predict_modes'), JSON.stringify(v)),
        // ---- v2.9.15: 大对象迁移至 IndexedDB（容量无 5MB 限制）----
        // 旧 GM key 兼容：第一次读取时若 IDB 无值，尝试从 GM_setValue 迁移
        getCachedGames: () => sglvIDB.get(nsKey('cached_games'),
            parseStored(nsKey('cached_games') /* 老 key 兜底 */, parseStored('sglv_cached_games', []))),
        setCachedGames: v => sglvIDB.set(nsKey('cached_games'), v),
        getFamilyInfo: () => sglvIDB.get(nsKey('family_info'),
            parseStored(nsKey('family_info'), parseStored('sglv_family_info', {}))),
        setFamilyInfo: v => sglvIDB.set(nsKey('family_info'), v),
        // ---- v2.9.34: 云存档数据（大对象，IDB 存储）----
        getCloudSaveData: () => sglvIDB.get(nsKey('cloud_save_data'),
            parseStored(nsKey('cloud_save_data'), null)),
        setCloudSaveData: v => sglvIDB.set(nsKey('cloud_save_data'), v),
    };

    // v2.11.40: 主题层 boot——storage 定义后立即同步应用用户主题（早于任何面板渲染）;
    // 异常时兜底注入默认典雅紫，保证布局类规则（雷达图区块/7列 grid 等，现已随主题层下发）不缺失
    try { applySglvTheme(getThemeId()); }
    catch (e) {
        console.warn('[SGLV] 主题应用失败，回退默认主题:', e);
        try { applySglvTheme(DEFAULT_SGLV_THEME); } catch (e2) {}
    }

    // 启动时一次性把老 GM 大对象迁到 IDB，避免下次升级重复走 fallback
    function migrateLegacyGmKeysToIDB() {
        const legacyKeys = [
            ['sglv_cached_games', nsKey('cached_games')],
            ['sglv_family_info',  nsKey('family_info')],
        ];
        for (const [oldKey, newKey] of legacyKeys) {
            try {
                if (sglvIDB.has(newKey)) continue;   // 已迁过
                const raw = GM_getValue(oldKey, null);
                if (raw == null) continue;
                const v = typeof raw === 'string' ? JSON.parse(raw) : raw;
                if (v != null && (Array.isArray(v) ? v.length : Object.keys(v).length)) {
                    sglvIDB.set(newKey, v);
                    console.log(`[SGLV] 迁移 ${oldKey} → IDB:${newKey} (${Array.isArray(v) ? v.length : Object.keys(v).length} 项)`);
                }
            } catch (e) {
                console.warn(`[SGLV] 迁移 ${oldKey} 失败:`, e);
            }
        }
    }

    // ==================== TTL 缓存层 ====================
    // 基于 GM_setValue 的带 TTL 缓存，支持侧边栏各标签页数据缓存
    const CACHE_TTL = {
        overview: 24 * 3600 * 1000,       // 概览：24h（DOM 提取，刷新页面即变）
        prices: 2 * 3600 * 1000,          // 多地区价格：2h
        historyPrices: 6 * 3600 * 1000,   // ITAD 历史价格：6h
        achievements: 1 * 3600 * 1000,    // 成就数据：1h
        globalAchievements: 12 * 3600 * 1000, // 全球成就：12h
        news: 30 * 60 * 1000,             // 新闻动态：30min
        familyShare: 6 * 3600 * 1000,     // 家庭共享支持：6h
        appDetailsExtra: 24 * 3600 * 1000, // v2.3.16: appdetails 增强信息（工坊/截图/分类/捆绑包等）：24h
        friendsList: 6 * 3600 * 1000,     // v2.3.8: 好友完整数据（列表+摘要+VAC）：6h
        friendsVac: 24 * 3600 * 1000,     // v2.3.8: VAC 封禁状态：24h（变化慢）
        friendsLevels: 7 * 24 * 3600 * 1000, // v2.3.8: 好友等级：7天（等级变化慢）
        psplus: 6 * 3600 * 1000,            // v2.6.0: PS 会免数据（远程 json）：6h
        epic: 12 * 3600 * 1000,             // v2.7.9: Epic 赠送名单（其乐抓取）：12h
        goty: 6 * 24 * 3600 * 1000,         // v2.9.27: 年度大作名单（jsdelivr CDN json）：6 天（数据基本不变，偶尔新增待发售游戏，5-7 天缓存足够）
        reviews: 1 * 3600 * 1000,           // v2.8.0: 游戏评测数据：1h
        giftRec: 2 * 3600 * 1000,           // v2.8.0: 跨区送礼推荐：2h（依赖价格数据）
        gameStatus: 6 * 3600 * 1000,         // v2.9.10: gamestatus.info 破解状态：6h
        profileFeatures: 24 * 3600 * 1000,   // v2.9.93: 资料受限状态（Profile Features Limited）：24h
        blockedApps: 24 * 3600 * 1000,       // v2.9.12: steam-tracker.com 锁区数据：24h
        seriesData: 7 * 24 * 3600 * 1000,     // v2.9.27: 游戏系列数据（GitHub json）：7 天
        wishlist: 3 * 24 * 3600 * 1000,        // v2.9.30: 愿望单数据：3 天（价格/折扣等动态字段后台静默刷新，6h 节流）
        cloudSave: 2 * 24 * 3600 * 1000,           // v2.9.39: 云存档数据：2 天（后台静默增量更新，6h 节流；只增不减，保留已有游戏列表）
    };
    // v2.9.39: 云存档后台静默刷新节流（与 wishlist 一致，6h）
    const CLOUDSAVE_BG_REFRESH_INTERVAL = 6 * 3600 * 1000;
    // v2.9.67: 云存档文件数填充节流（v2.9.74: 12h → 5天,云存档相对固定,避免频繁请求单App页面）
    const CLOUDSAVE_FILECOUNT_INTERVAL = 5 * 24 * 3600 * 1000;
    function cacheGet(key) {
        try {
            const raw = GM_getValue('sglv_cache_' + key, '');
            if (!raw) return null;
            const obj = JSON.parse(raw);
            if (obj.expires && Date.now() > obj.expires) {
                GM_setValue('sglv_cache_' + key, '');
                return null;
            }
            return obj.data;
        } catch { return null; }
    }
    function cacheSet(key, data, ttl) {
        try {
            GM_setValue('sglv_cache_' + key, JSON.stringify({ data, expires: Date.now() + ttl }));
        } catch { /* ignore quota errors */ }
    }
    /** v2.9.91: 删除指定缓存项（移出过期缓存） */
    function cacheDelete(key) {
        try { GM_setValue('sglv_cache_' + key, ''); } catch { /* ignore */ }
    }

    function cacheClear(prefix) {
        try {
            const keys = GM_listValues ? GM_listValues() : [];
            for (const k of keys) {
                if (k.startsWith('sglv_cache_' + (prefix || ''))) {
                    GM_setValue(k, '');
                }
            }
        } catch { /* ignore */ }
    }

    // ==================== AI 翻译总结 (v2.2) ====================
    const AI_PROMPT_URL = 'https://cdn.jsdelivr.net/gh/SmallRob/steam-namespace@main/prompts/ai-prompt-template.json';

    // ==================== AI 价格预测 (v2.3) ====================
    const AI_PRICE_PREDICT_PROMPT_URL = 'https://cdn.jsdelivr.net/gh/SmallRob/steam-namespace@main/prompts/ai-price-predict-template.json';

    // ==================== AI 深度分析 (v2.9.85) ====================
    const AI_INSIGHT_PROMPT_URL = 'https://cdn.jsdelivr.net/gh/SmallRob/steam-namespace@main/prompts/ai-insight-template.json';

    // 内置预测提示词模板 (远程加载失败时的 fallback)
    const FALLBACK_PREDICT_PROMPT = `# 角色\n你是一位精通Steam平台价格分析和游戏行业趋势的数据科学家。基于游戏的历史折扣数据和Steam促销活动节点，使用多种预测模型对游戏价格走势进行预测分析。\n\n# 任务\n根据输入的游戏价格历史数据、折扣记录和发行信息，使用用户选定的预测模式进行分析，输出结构化的预测结果。\n\n## 预测模式说明\n用户已启用以下预测模式：\n{PREDICT_MODES}\n\n### seasonal（季节性折扣预测）\n基于Steam官方促销活动日历（夏促6-7月/秋促11月底/冬促12月底/春促3月）预测下一次折扣时机。\n\n### trend（价格趋势预测）\n基于历史折扣的间隔周期和幅度趋势，预测下次折扣的可能百分比和价格。\n\n### lowest（史低突破预测）\n预测游戏达到或突破历史最低价的可能性和时机。\n\n### review（评价动量预测）\n结合游戏口碑变化趋势评估未来折扣力度。\n\n### similar（相似历史预测）\n匹配游戏价格历史中的相似片段预测折扣模式。\n\n# 输出格式\n严格按以下JSON格式输出，不要输出任何其他文字。\n\n{"models":[{"mode":"seasonal","mode_name":"模式名称","prediction":"预测摘要","discount_percent":50,"predicted_price":134.00,"currency":"CNY","days_until":46,"target_date":"2026-08-27","confidence":92,"sale_event":"秋季特卖","detail":"详细分析","indicators":{}}],"best_buy":{"recommendation":"购买建议","best_time":"最佳时间","best_price":134.00,"wait_days":46,"urgency":"medium"}}\n\n# 输入数据\n- 游戏名称：{GAME_NAME}\n- 应用ID：{APP_ID}\n- 发行日期：{RELEASE_DATE}\n- 当前日期：{CURRENT_DATE}\n- 当前价格：{CURRENT_PRICE} {CURRENCY}\n- 原价：{ORIGINAL_PRICE} {CURRENCY}\n\n## 历史折扣记录：\n{DISCOUNT_RECORDS}\n\n## 完整价格历史：\n{PRICE_HISTORY}\n\n# 注意事项\n- 基于数据客观分析，不要编造数据。\n- confidence反映数据支撑程度：样本充足且规律明显时高分，不足时低分。\n- best_buy应综合所有模式给出最优建议。\n- 输出必须是合法JSON。`;

    // 预测模式定义
    const PREDICT_MODES = [
        { key: 'seasonal', name: T.aiPredictModeSeasonal, desc: T.aiPredictModeSeasonalDesc },
        { key: 'trend', name: T.aiPredictModeTrend, desc: T.aiPredictModeTrendDesc },
        { key: 'lowest', name: T.aiPredictModeLowest, desc: T.aiPredictModeLowestDesc },
        { key: 'review', name: T.aiPredictModeReview, desc: T.aiPredictModeReviewDesc },
        { key: 'similar', name: T.aiPredictModeSimilar, desc: T.aiPredictModeSimilarDesc },
    ];

    // ---- 统一提示词模板加载器（带缓存 + 可选 fallback）----
    const _promptCache = new Map();
    // v2.11.36 (FEAT-015 TASK-003): 迁移至 sglvGmFetchRetry（retries:0 保持原无重试快速降级语义——
    //   3 个调用点均带 fallback，网络失败立即兑底；非 2xx 原不检查状态码直接 parse（失败→fallback），
    //   新 404 确定性立即 reject→fallback，语义等价）
    function loadPromptTemplate(url, fallback = null) {
        if (_promptCache.has(url)) return Promise.resolve(_promptCache.get(url));
        return sglvGmFetchRetry(url, { timeout: 15000, retries: 0 }).then(data => {
            if (data.prompt && data.prompt.trim()) {
                _promptCache.set(url, data.prompt.trim());
                return _promptCache.get(url);
            }
            if (fallback) { _promptCache.set(url, fallback); return fallback; }
            throw new Error(isZh ? '提示词模板内容为空' : 'Prompt template is empty');
        }).catch(e => {
            if (fallback) { _promptCache.set(url, fallback); return fallback; }
            throw e;
        });
    }
    // v2.9.81: 翻译模板也增加 fallback, 防止远程加载失败时翻译功能完全不可用
    const FALLBACK_TRANSLATE_PROMPT = `# 角色\n你是一位精通游戏行业的翻译与内容分析专家。对Steam游戏动态新闻进行智能翻译与归纳总结。\n\n# 任务\n对输入的游戏动态新闻列表，逐条执行：\n1. 非中文内容翻译为简体中文，中文保留原文。游戏专有名词保留英文后接括号中文释义。\n2. 提炼核心信息，1-3句话总结，不超过100字。\n3. 严格按JSON格式输出。\n\n# 输出格式\n{"items":[{"title":"标题翻译或原文","summary":"1-3句话总结","is_translated":true}]}\n\n# 输入数据\n- 游戏名称：{GAME_NAME}\n- 应用ID：{APP_ID}\n\n新闻列表：\n{NEWS_DATA}\n\n# 注意事项\n- items数组长度必须与输入新闻条数一致。\n- 输出必须是合法JSON。`;
    const getAiPromptTemplate = () => loadPromptTemplate(AI_PROMPT_URL, FALLBACK_TRANSLATE_PROMPT);
    const getPredictPromptTemplate = () => loadPromptTemplate(AI_PRICE_PREDICT_PROMPT_URL, FALLBACK_PREDICT_PROMPT);

    // v2.9.85: 深度分析提示词模板 (远程加载 + fallback)
    const FALLBACK_INSIGHT_PROMPT = `# 角色\n你是一位游戏行为分析专家和 Steam 库存评论家, 以犀利幽默的风格点评玩家的游戏库。\n\n# 任务\n基于玩家的 Steam 游戏数据和个人口味画像, 从六个维度生成深度分析报告。语言要犀利但不恶意, 数据支撑, 避免空话套话。\n\n# 输入数据\n- 玩家昵称: {PERSONA_NAME}\n- Steam 等级: {STEAM_LEVEL}\n- 游戏总数: {GAME_COUNT}\n- 总时长: {TOTAL_HOURS} 小时\n- 已启动游戏: {PLAYED_COUNT} ({PLAYED_PERCENT}%)\n- 未启动游戏: {UNPLAYED_COUNT} (吃灰率 {DUST_RATE}%)\n- 超 100h 游戏: {OVER_100H_COUNT} 款\n- 超 500h 游戏: {OVER_500H_COUNT} 款\n- 深度游玩(≥10h): {LONG_GAMES_COUNT} 款\n- 平均时长: {AVG_HOURS}h/款\n- 玩家类型: {PERSONA_TYPE} ({PERSONA_RARITY})\n- 玩家特征: {TRAITS}\n- 口味标签: {TASTE_TAGS}\n- 愿望单热门标签: {WISHLIST_TAGS}\n- 维度评分: {DIM_SCORES}\n- 维度详情:\n{DIM_DETAILS}\n- 游玩最多 Top10: {TOP_GAMES}\n- 最近游玩: {RECENT_GAMES}\n- 吃灰游戏示例: {DUST_EXAMPLES}\n\n# 输出格式\n严格按以下 JSON 格式输出, 不要输出任何其他文字。\n{\n  "oneLiner": "一句话犀利总结, 30字以内, 直击要害",\n  "sections": [\n    {"title": "库存概况", "content": "2-4句, 评价游戏数量、规模、收藏习惯"},\n    {"title": "游玩习惯", "content": "2-4句, 分析时长投入、深度游玩、吃灰情况"},\n    {"title": "偏好画像", "content": "2-4句, 从 Top10 游戏和口味标签推断品味偏好、游戏类型倾向"},\n    {"title": "亮点槽点", "content": "2-4句, 先肯定亮点再点出槽点, 犀利但建设性"},\n    {"title": "购买建议", "content": "2-4句, 基于现状给出未来购买/游玩的具体建议"},\n    {"title": "犀利毒舌", "content": "2-3句, 最犀利最毒舌的终极点评, 可使用比喻和讽刺但不人身攻击, 直击玩家最核心的矛盾"}\n  ]\n}`;
    const getInsightPromptTemplate = () => loadPromptTemplate(AI_INSIGHT_PROMPT_URL, FALLBACK_INSIGHT_PROMPT);

    // ---- 统一 AI API POST 调用 ----
    // v2.3.18: 新增 maxTokens (默认 4096, 可按场景提高) 和 returnMeta (返回 {content, finishReason, truncated})
    // v2.11.36 (FEAT-015 TASK-003): 迁移至 sglvGmFetchRetry（POST/headers/data 透传，依赖 core 1.0.6
    //   onHttpError 回调保留 v2.9.82 的非 2xx 服务端错误详情提取；401/400 确定性 4xx 立即失败不重试）
    function callAiApi(prompt, { temperature = 0.3, timeout = 60000, maxTokens = 4096, returnMeta = false } = {}) {
        const apiKey = storage.getAiApiKey();
        if (!apiKey) return Promise.reject(new Error(T.aiNotConfigured));
        const apiUrl = storage.getAiApiUrl();
        return sglvGmFetchRetry(apiUrl, {
            method: 'POST', timeout,
            headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
            data: JSON.stringify({ model: storage.getAiModel(), messages: [{ role: 'user', content: prompt }], temperature, max_tokens: maxTokens }),
            // v2.9.82: 非 2xx 时提取实际错误信息, 避免 "AI 返回为空" 误导（经 core 1.0.6 onHttpError 定制错误消息）
            onHttpError(status, text) {
                let errDetail = '';
                try {
                    const errData = JSON.parse(text || '');
                    errDetail = errData?.error?.message || errData?.message || errData?.error || '';
                } catch { errDetail = (text || '').slice(0, 200); }
                return `AI API HTTP ${status}${errDetail ? ': ' + errDetail : ''}`;
            },
        }).then(respData => {
            const choice = respData?.choices?.[0] || {};
            const content = choice.message?.content || '';
            const finishReason = choice.finish_reason || '';
            if (!content) {
                // v2.9.82: 记录完整响应便于排查空内容问题
                console.error('[SGIS] AI 返回为空, finishReason:', finishReason, '| respData:', JSON.stringify(respData).slice(0, 500));
                throw new Error('AI 返回为空 (finishReason: ' + finishReason + ')');
            }
            if (returnMeta) {
                return { content, finishReason, truncated: finishReason === 'length' };
            }
            return content;
        }).catch(e => {
            console.error('[SGIS] callAiApi error:', e.message, '| url:', apiUrl, '| model:', storage.getAiModel());
            throw e;
        });
    }

    // v2.3.18: 修复被截断的 JSON (AI 响应因 max_tokens 限制被截断, 缺少闭合括号)
    // 策略: 1. 关闭未闭合的字符串 2. 移除尾部不完整的元素 3. 关闭所有未闭合的括号
    function repairTruncatedJson(str) {
        let s = str;
        // 1. 正向扫描: 跟踪字符串状态、括号栈, 记录最后一个"安全边界"位置
        //    安全边界 = 数组内最后一个完整元素 (} 或 ]) 之后的位置, 可在此处安全截断
        let inStr = false, esc = false;
        const stk = [];
        let lastSafeBoundary = -1;
        for (let i = 0; i < s.length; i++) {
            const c = s[i];
            if (esc) { esc = false; continue; }
            if (c === '\\') { esc = true; continue; }
            if (c === '"') { inStr = !inStr; continue; }
            if (inStr) continue;
            if (c === '{' || c === '[') stk.push(c);
            else if (c === '}' || c === ']') {
                if (stk.length) {
                    stk.pop();
                    // 弹出后若栈顶是 '[', 说明刚闭合的是数组内一个完整元素
                    if (stk.length > 0 && stk[stk.length - 1] === '[') {
                        lastSafeBoundary = i + 1;
                    }
                }
            }
        }
        // 2. 关闭未闭合的字符串
        if (inStr) s += '"';
        // 3. 如果截断在元素中间, 裁剪到最后一个安全边界 (移除不完整的尾部元素)
        s = s.replace(/[\s]+$/, '');
        if (s.length > 0) {
            const lastCh = s[s.length - 1];
            if (lastCh !== '}' && lastCh !== ']' && lastCh !== ',') {
                if (lastSafeBoundary >= 0) {
                    s = s.slice(0, lastSafeBoundary);
                }
            }
        }
        // 4. 移除尾部逗号
        s = s.replace(/,\s*$/, '');
        // 5. 关闭所有未闭合的括号 (重新扫描获取当前栈状态)
        inStr = false; esc = false;
        const finalStk = [];
        for (let i = 0; i < s.length; i++) {
            const c = s[i];
            if (esc) { esc = false; continue; }
            if (c === '\\') { esc = true; continue; }
            if (c === '"') { inStr = !inStr; continue; }
            if (inStr) continue;
            if (c === '{' || c === '[') finalStk.push(c);
            else if (c === '}' || c === ']') { if (finalStk.length) finalStk.pop(); }
        }
        while (finalStk.length > 0) {
            const open = finalStk.pop();
            s += (open === '{' ? '}' : ']');
        }
        return s;
    }

    // v2.3.1.1: 鲁棒 JSON 解析 (处理 AI 返回的 markdown/截断/未转义)
    // v2.3.18: 增加 max_tokens 截断修复 (第 3 次尝试: repairTruncatedJson)
    // 流程: 剥离 markdown -> 提取最外层 { ... } -> 清理尾部逗号 -> JSON.parse -> 截断修复
    function safeParseAiJson(content, expectKey) {
        if (!content || typeof content !== 'string') throw new Error('AI 返回内容为空');
        // 1. 去除 <think>...</think> 块
        let cleaned = content.replace(/<think>[\s\S]*?<\/think>/gi, '').trim();
        // 2. 剥离 markdown 代码块 ```json ... ``` 或 ``` ... ```
        cleaned = cleaned.replace(/^```(?:json)?\s*/i, '').replace(/```\s*$/i, '').trim();
        // 3. 提取最外层 JSON: 根据 expectKey 找匹配的 { 或 [
        const openChar = expectKey && expectKey.startsWith('[') ? '[' : '{';
        const closeChar = openChar === '{' ? '}' : ']';
        const firstIdx = cleaned.indexOf(openChar);
        if (firstIdx === -1) throw new Error('AI 返回中找不到 JSON 起始符');
        // v2.3.18: 保存从起始符到字符串末尾的完整内容 (用于截断修复)
        const fullContent = cleaned.slice(firstIdx);
        // 4. 用括号配对法找匹配的闭合位置 (处理字符串/转义)
        let depth = 0, inString = false, escape = false, endIdx = -1;
        for (let i = firstIdx; i < cleaned.length; i++) {
            const ch = cleaned[i];
            if (escape) { escape = false; continue; }
            if (ch === '\\') { escape = true; continue; }
            if (ch === '"') { inString = !inString; continue; }
            if (inString) continue;
            if (ch === openChar) depth++;
            else if (ch === closeChar) { depth--; if (depth === 0) { endIdx = i + 1; break; } }
        }
        if (endIdx === -1) {
            // v2.3.18: 找不到匹配闭合符 — 极可能是 max_tokens 截断
            // 先尝试用 repairTruncatedJson 修复完整内容
            try {
                const repaired = repairTruncatedJson(fullContent);
                const result = JSON.parse(repaired);
                // 标记为截断恢复结果 (括号配对失败 = 确定被截断)
                if (result && typeof result === 'object') {
                    result._truncated = true;
                }
                return result;
            } catch (eRepair) {
                // 修复仍失败, 回退到贪婪匹配
                const m = cleaned.match(/\{[\s\S]*\}/);
                if (m) endIdx = m.index + m[0].length;
                else throw new Error('AI 返回中找不到 JSON 闭合符 (疑似响应被截断)');
            }
        }
        let jsonStr = cleaned.slice(firstIdx, endIdx);
        // 5. 清理 JSON 中常见错误
        // 5.1 移除尾部多余的 }, ] (AI 经常多打)
        jsonStr = jsonStr.replace(/[\s,]+$/, '');
        // 5.2 移除 // 单行注释
        jsonStr = jsonStr.replace(/^\s*\/\/.*$/gm, '');
        // 5.3 移除 /* */ 注释
        jsonStr = jsonStr.replace(/\/\*[\s\S]*?\*\//g, '');
        // 5.4 修复未闭合的字符串(去除末尾未闭合的引号)
        const quoteCount = (jsonStr.match(/"/g) || []).length;
        if (quoteCount % 2 !== 0) {
            jsonStr = jsonStr.replace(/"([^"]*)$/, '$1');
        }
        // 5.5 修复 trailing comma
        jsonStr = jsonStr.replace(/,(\s*[}\]])/g, '$1');
        // 5.6 修复单引号为双引号 (字段名必须是双引号)
        jsonStr = jsonStr.replace(/'([a-zA-Z_]\w*)'(\s*:)/g, '"$1"$2');
        // 6. 解析
        try {
            return JSON.parse(jsonStr);
        } catch (e1) {
            // 7. 二次尝试: 用更激进的清理
            try {
                // 修复模型: 去掉控制字符
                const fixed = jsonStr.replace(/[\u0000-\u001F\u007F]/g, (m) => {
                    if (m === '\n' || m === '\r' || m === '\t') return m;
                    return '';
                });
                return JSON.parse(fixed);
            } catch (e2) {
                // v2.3.18: 三次尝试 — 截断修复 (max_tokens 限制导致响应被截断)
                // 典型症状: "Expected ',' or ']' after array element" 且错误位置 ≈ 字符串末尾
                try {
                    const repaired = repairTruncatedJson(fullContent);
                    const result = JSON.parse(repaired);
                    // 标记为截断恢复结果 (调用方可据此提示用户)
                    if (result && typeof result === 'object') {
                        result._truncated = true;
                    }
                    return result;
                } catch (e3) {
                    throw new Error('AI 返回 JSON 解析失败: ' + e1.message.slice(0, 80) + ' (位置 ' + jsonStr.length + ', 截断修复亦失败)');
                }
            }
        }
    }

    // 调用 AI API 进行翻译总结
    // newsItems: [{ title, contents, ... }], gameName: string, appId: string
    // 返回: [{ title, summary, is_translated, _truncated? }]
    // v2.3.18: max_tokens 提升至 8192 防截断; 限制最多 15 条新闻降低 token 压力;
    //          通过 returnMeta 检测 finish_reason=length; 截断时通过 repairTruncatedJson 恢复部分结果
    async function callAiTranslateSummary(newsItems, gameName, appId) {
        let prompt = await getAiPromptTemplate();
        // v2.3.18: 限制最多 15 条新闻 (原 20 条), 减少 token 消耗防止输出截断
        const cappedNews = newsItems.slice(0, 15);
        const newsData = cappedNews.map((n, i) =>
            `[${i + 1}] 标题: ${n.title || '(无标题)'}\n内容: ${n.contents || '(无内容)'}`
        ).join('\n\n');
        prompt = prompt.replace(/\{GAME_NAME\}/g, gameName || '未知游戏')
                       .replace(/\{APP_ID\}/g, appId || '')
                       .replace(/\{NEWS_DATA\}/g, newsData);
        // v2.3.18: maxTokens 8192 + returnMeta 检测截断
        const { content, finishReason, truncated } = await callAiApi(prompt, {
            temperature: 0.3, timeout: 60000, maxTokens: 8192, returnMeta: true
        });
        const parsed = safeParseAiJson(content, '{');
        const items = parsed.items || [];
        // 截断标记: API 层 (finish_reason=length) 或 JSON 修复层 (_truncated) 任一触发即标记
        const wasTruncated = truncated || parsed._truncated === true || items.length < cappedNews.length;
        if (wasTruncated && items.length > 0) {
            // 部分结果恢复成功 — 在首条 item 上打标记供 UI 提示
            items.forEach(it => { it._truncated = true; });
        }
        return items;
    }

    // 调用 AI API 进行价格预测
    async function callAiPricePredict(historyData, gameName, appId, currentPrice, originalPrice) {
        console.log('[SGIS] AI价格预测开始, gameName:', gameName, 'appId:', appId);
        let prompt = await getPredictPromptTemplate();
        console.log('[SGIS] 提示词模板加载完成, length:', prompt.length);

        // 获取用户选择的预测模式
        const enabledModes = storage.getPredictModes();
        const modesText = enabledModes.map(m => {
            const mode = PREDICT_MODES.find(p => p.key === m);
            return mode ? `- ${mode.key}（${mode.name}）：${mode.desc}` : '';
        }).filter(Boolean).join('\n');

        // 构建折扣记录文本
        // v2.3.7: 安全数值转换, 修复 price?.toFixed is not a function
        const _safeNum = (v) => { const n = Number(v); return isNaN(n) ? 0 : n; };
        const discounts = historyData.discounts || [];
        const discountRecords = discounts.map(d => {
            const dateStr = d.date ? new Date(d.date).toLocaleDateString('zh-CN') : '—';
            const daysStr = d.daysFromRelease != null ? `距发行${d.daysFromRelease}天` : '';
            return `- ${dateStr} | -${d.cut}% | ${d.currency}${_safeNum(d.price).toFixed(2)} | 原价${d.currency}${_safeNum(d.regular).toFixed(2)} | ${daysStr}`;
        }).join('\n') || '无折扣记录';

        // 构建价格历史文本
        const history = historyData.history || [];
        const priceHistory = history.map(h => {
            const dateStr = h.date ? new Date(h.date).toLocaleDateString('zh-CN') : '—';
            return `- ${dateStr} | ${h.cut > 0 ? '-' + h.cut + '%' : '原价'} | ${h.currency}${_safeNum(h.price).toFixed(2)} | 原价${h.currency}${_safeNum(h.regular).toFixed(2)}`;
        }).join('\n') || '无价格历史';

        // 填充提示词模板
        const currentDate = new Date().toISOString().split('T')[0];
        const currency = (history[0] || discounts[0] || {}).currency || 'CNY';
        prompt = prompt.replace(/\{PREDICT_MODES\}/g, modesText)
                       .replace(/\{GAME_NAME\}/g, gameName || historyData.gameTitle || '未知游戏')
                       .replace(/\{APP_ID\}/g, appId || '')
                       .replace(/\{RELEASE_DATE\}/g, historyData.releaseDate || '未知')
                       .replace(/\{CURRENT_DATE\}/g, currentDate)
                       .replace(/\{CURRENT_PRICE\}/g, String(currentPrice || '—'))
                       .replace(/\{ORIGINAL_PRICE\}/g, String(originalPrice || '—'))
                       .replace(/\{CURRENCY\}/g, currency)
                       .replace(/\{DISCOUNT_RECORDS\}/g, discountRecords)
                       .replace(/\{PRICE_HISTORY\}/g, priceHistory);

        // v2.9.81: maxTokens 提升至 8192 防止多模型预测结果被截断 (与翻译函数一致)
        console.log('[SGIS] AI API 调用中, model:', storage.getAiModel(), 'url:', storage.getAiApiUrl());
        const content = await callAiApi(prompt, { temperature: 0.4, timeout: 90000, maxTokens: 8192 });
        console.log('[SGIS] AI API 返回, content length:', content.length);
        // v2.3.1.1: 使用鲁棒 JSON 解析 (处理 markdown/截断/未转义)
        const result = safeParseAiJson(content, '{');
        console.log('[SGIS] AI 价格预测解析完成, models:', (result.models || []).length);
        return result;
    }

    // ==================== 跨产品共享数据访问层（v2.4.1 从 SGLV 区域上移，供 SGLV/SGIS 共用） ====================
    // 事件总线契约：SGLV 通过 document.dispatchEvent(new CustomEvent("sglv:games-updated")) 通知 SGIS 刷新

    // --- 中文名缓存 ---
    // ==================== 游戏中文名获取（参考 steam-friend-manager-1.1.2 fetchGameZhName） ====================
    // 通过 store.steampowered.com/api/appdetails?l=schinese 获取简体中文名称，
    // 带跨会话持久缓存（30天 TTL）和内存级防重复请求（pending Map），
    // 供游戏橱窗列表、游玩仪表、家庭愿望单、绝版游戏等面板异步替换英文名。
    // 仅在中文环境（isZh）下生效，非中文环境直接返回空字符串。
    const SGLV_GAME_NAME_KEY = 'sglv_game_name_cache';
    const SGLV_NAME_CACHE_TTL = 30 * 864e5; // 30天过期
    let _sglvGameNameCache = null;
    const _sglvGameNamePending = new Map();
    function sglvGameNameCacheLoad() {
        if (_sglvGameNameCache !== null) return _sglvGameNameCache;
        _sglvGameNameCache = {};
        try {
            const raw = GM_getValue(SGLV_GAME_NAME_KEY);
            if (raw && typeof raw === 'object') _sglvGameNameCache = raw;
        } catch (e) { console.warn('[SGLV] 游戏名称缓存读取失败:', e); }
        return _sglvGameNameCache;
    }
    function sglvGameNameCacheSave() {
        try { GM_setValue(SGLV_GAME_NAME_KEY, _sglvGameNameCache || {}); } catch (e) { console.warn('[SGLV] 游戏名称缓存写入失败:', e); }
    }
    // v2.4.3: 中文名获取失败负缓存 TTL（30 分钟）——失败结果短期内直接返回，
    // 防止增量渲染（每次资料补全批次都会重渲列表）反复重发单 appid 请求触发 Steam 限流，
    // 这曾是中文名大面积获取失败（停留在英文名）的根因
    const SGLV_NAME_NEG_TTL = 30 * 60 * 1000;
    // 获取游戏中文名（异步，返回 Promise<string>，空字符串表示非中文环境或获取失败）
    function fetchGameZhName(appid) {
        if (!isZh) return Promise.resolve('');
        const id = String(appid);
        const cache = sglvGameNameCacheLoad();
        const cached = cache[id];
        if (cached && cached.name && Date.now() - (cached.ts || 0) < SGLV_NAME_CACHE_TTL) {
            return Promise.resolve(cached.name);
        }
        // 负缓存命中：近期已失败过，不再重发请求
        if (cached && !cached.name && Date.now() - (cached.ts || 0) < SGLV_NAME_NEG_TTL) {
            return Promise.resolve('');
        }
        if (_sglvGameNamePending.has(id)) return _sglvGameNamePending.get(id);
        // v2.8.1: filters=name 是无效过滤值，appdetails 返回 data:[]（空），导致中文名始终获取不到
        //         （库存页因自带英文名未暴露此问题，Epic赠送页仅有 appid 无名称故大面积显示 "App xxxxxx"）。
        //         改用 filters=basic（含 name 字段，响应约 3KB，远小于无过滤的 15KB）。
        const p = new Promise(resolve => {
            const settle = (name) => {
                cache[id] = { name, ts: Date.now() }; // 成功/失败均落缓存（空名=负缓存）
                try { sglvGameNameCacheSave(); } catch (e) { console.warn('[SGLV] 游戏名称缓存保存失败:', id, e); }
                _sglvGameNamePending.delete(id);
                resolve(name);
            };
            // v2.8.3: 使用统一 API 调用层（带重试），失败时走负缓存
            sglvGmFetchRetry(`https://store.steampowered.com/api/appdetails?appids=${id}&filters=basic&l=schinese`, { timeout: 10000, retries: 1 })
                .then(json => {
                    let name = '';
                    try {
                        const d = json && json[id];
                        if (d && d.success && d.data && d.data.name) name = d.data.name;
                    } catch (e) { console.warn('[SGLV] 中文名解析失败:', id, e); }
                    settle(name);
                })
                .catch(() => settle(''));
        });
        _sglvGameNamePending.set(id, p);
        return p;
    }
    // 异步加载中文名并更新 DOM 元素（参考 steam-friend-manager loadGameZhName）
    // el: 显示游戏名的元素；appid: 游戏ID；originalName: 当前显示的名称
    function loadGameZhName(el, appid, originalName) {
        if (!el || !appid) return;
        fetchGameZhName(appid).then(zhName => {
            if (zhName && zhName !== originalName) {
                el.textContent = zhName;
                el.title = `${zhName} (${originalName})`;
            }
        });
    }

    // v2.8.2: 获取游戏英文名（参考 Steam_Show_English_Name.js，filters=basic 含 name 字段）
    const _sglvEnNameCache = new Map();
    const _sglvEnNamePending = new Map();
    function fetchGameEnName(appid) {
        const id = String(appid);
        if (_sglvEnNameCache.has(id)) return Promise.resolve(_sglvEnNameCache.get(id));
        if (_sglvEnNamePending.has(id)) return _sglvEnNamePending.get(id);
        const p = new Promise(resolve => {
            // v2.8.3: 使用统一 API 调用层（带重试）
            sglvGmFetchRetry(`https://store.steampowered.com/api/appdetails?appids=${id}&filters=basic&l=english`, { timeout: 10000, retries: 1 })
                .then(json => {
                    let name = '';
                    try {
                        const d = json && json[id];
                        if (d && d.success && d.data && d.data.name) name = d.data.name;
                    } catch (e) { console.warn('[SGLV] 英文名解析失败:', id, e); }
                    if (name) _sglvEnNameCache.set(id, name);
                    _sglvEnNamePending.delete(id);
                    resolve(name);
                })
                .catch(() => { _sglvEnNamePending.delete(id); resolve(''); });
        });
        _sglvEnNamePending.set(id, p);
        return p;
    }

    // v2.8.2: 异步加载游戏名称——默认显示中文名（如有），原始英文名作为灰色别名追加在后
    // 逻辑：① 主名是 "App xxx" 占位符 → 获取中文名替换主名，英文名作为别名（需额外请求）
    //       ② 主名是英文名 → 获取中文名替换主名，原始英文名作为灰色别名
    //       ③ 中文名与主名相同（主名已是中文）：不追加别名
    //       ④ 无中文名（主名为英文且无中文名）：不追加别名，避免英文名重复/雷同
    //       ⑤ 占位符主名 + 无中文名 → 获取英文名替换主名，不追加别名
    // 参考steam-friend-manager-1.1.6.js：静默失败不显示任何别名
    const _APP_PLACEHOLDER_RE = /^App\s+\d+$/i;
    function loadGameNameAlias(el, appid, originalName) {
        if (!el || !appid || !originalName) return;
        const isPlaceholder = _APP_PLACEHOLDER_RE.test(originalName.trim());
        fetchGameZhName(appid).then(zhName => {
            if (zhName && zhName !== originalName) {
                // 获取到中文名 → 主名替换为中文
                el.textContent = zhName;
                el.title = `${zhName} (${originalName})`;
                // 仅当原始名是真实名称（非 App xxx 占位符）时才作为灰色别名
                if (!isPlaceholder) {
                    _appendGrayAlias(el, originalName);
                }
                return;
            }
            // 中文名为空或与主名相同
            if (!isPlaceholder) return;
            // 主名是 App xxx 占位符且无中文名 → 尝试获取英文名替换占位符
            fetchGameEnName(appid).then(enName => {
                if (enName && enName !== originalName) {
                    el.textContent = enName;
                    el.title = enName;
                    // 不追加别名（已是英文名，无中文名可对照）
                }
            });
        });
    }
    function _appendGrayAlias(el, alias) {
        if (el.querySelector('.sglv-name-alias')) return;
        const span = document.createElement('span');
        span.className = 'sglv-name-alias';
        span.textContent = alias;
        el.appendChild(span);
    }

    // v2.11.4 (FEAT-011 TASK-005): 中文名回填统一入口——收编 9 处重复的
    // 「querySelectorAll('[data-sglv-appid]') → loadGameZhName(el, appid, textContent)」循环
    // 差异矩阵(2026-08-18 grep 实测):
    //   常规 7 处: 趋势时间线/游玩 top/游玩全部/愿望单主列表/愿望单增量(existView)/SGIS 最近游玩/SGIS 动态/SGIS 市场洞察
    //     → 全部走 loadGameZhName(textContent 替换 + title 拼原始名)
    //   橱窗列表 1 处: .sglv-list-name 元素走 loadGameNameAlias(中文名+灰色别名+App 占位符英文回退),其余 loadGameZhName
    //   SGIS 3 处容器为 document: 选择器需 '#sgis-body ' 前缀限定作用域
    // opts.aliasFor: CSS 选择器,匹配元素改走 loadGameNameAlias(橱窗列表视图语义)
    // opts.scope:   作用域选择器前缀(如 '#sgis-body'),配合 container=document 使用
    // 每元素经 data-sglv-alias-done 标记幂等:二次调用(愿望单增量更新场景)零新增请求;
    // 失败负缓存由 fetchGameZhName 层承担(30 分钟 TTL),本工厂不重试
    function applyGameAliases(container, opts = {}) {
        if (!container || typeof container.querySelectorAll !== 'function') return;
        const sel = opts.scope ? `${opts.scope} [data-sglv-appid]` : '[data-sglv-appid]';
        container.querySelectorAll(sel).forEach(el => {
            if (el.getAttribute('data-sglv-alias-done')) return;
            el.setAttribute('data-sglv-alias-done', '1');
            const appid = el.getAttribute('data-sglv-appid');
            if (opts.aliasFor && typeof el.matches === 'function' && el.matches(opts.aliasFor)) {
                loadGameNameAlias(el, appid, el.textContent);
            } else {
                loadGameZhName(el, appid, el.textContent);
            }
        });
    }

    // --- getActiveSteamId ---
    let _activeSteamId = null;
    function getActiveSteamId() {
        if (_activeSteamId) return _activeSteamId;
        _activeSteamId = storage.getSteamId() || detectSteamId();
        return _activeSteamId;
    }

    // --- isGameOwnedByMe ---
    function isGameOwnedByMe(g) {
        const steamId = getActiveSteamId();
        if (!g.owners || g.owners.length === 0) return true;
        if (!steamId) return true;
        return g.owners.includes(steamId);
    }

    // v2.9.2: 获取排除家庭组共享游戏和 DLC 后的游戏列表（用于个人信息面板和洞察页面统计准确性）
    // v2.9.3: 修复 isDlc 跨作用域不可见问题——isDlc 定义在 SGLV 子闭包内，通过 SGLV_API 桥接访问
    // v2.9.50: 加 session 内缓存 + 持久化缓存(签名:dlcReady + ownedGames count)
    //   - session 内:已加载的 isDlc 结果直接复用
    //   - 跨 session:游戏数 + dlcReady 未变时直接命中(避免每次开面板都遍历全库存)
    let _cachedStatFiltered = null;
    let _cachedStatFilteredSig = '';
    function getStatFilteredGames() {
        const allGames = (state.ownedGames && state.ownedGames.length) ? state.ownedGames : storage.getCachedGames();
        const _isDlc = SGLV_API.isDlc;
        const dlcReady = (SGLV_API.isDlcDbReady && SGLV_API.isDlcDbReady()) ? '1' : '0';
        const sig = `${allGames.length}|${dlcReady}`;
        if (_cachedStatFiltered && _cachedStatFilteredSig === sig) return _cachedStatFiltered;
        const result = allGames.filter(g => isGameOwnedByMe(g) && !(_isDlc && _isDlc(g.appid)));
        _cachedStatFiltered = result;
        _cachedStatFilteredSig = sig;
        return result;
    }

    // v2.9.5: DLC 数量缓存（避免个人信息面板每次渲染都重新 filter + isDlc 遍历）
    // 缓存 key 基于 ownedGames 数量 + dlcDbData 是否已加载，任一变化时自动失效
    let _cachedDlcCount = null;
    let _cachedDlcCountKey = '';
    function getOwnedDlcCount() {
        const allGames = (state.ownedGames && state.ownedGames.length) ? state.ownedGames : storage.getCachedGames();
        const _isDlc = SGLV_API.isDlc;
        // 缓存 key 需区分 DLC 数据库加载前后（加载前 isDlc 恒返回 false，DLC 计数为 0）
        const dlcReady = (SGLV_API.isDlcDbReady && SGLV_API.isDlcDbReady()) ? '1' : '0';
        const key = `${allGames.length}|${dlcReady}`;
        if (_cachedDlcCount !== null && _cachedDlcCountKey === key) return _cachedDlcCount;
        if (!_isDlc || dlcReady === '0') { _cachedDlcCount = 0; _cachedDlcCountKey = key; return 0; }
        _cachedDlcCount = allGames.filter(g => isGameOwnedByMe(g) && _isDlc(g.appid)).length;
        _cachedDlcCountKey = key;
        return _cachedDlcCount;
    }

    // --- ownedAppIds缓存变量 ---
    // 缓存 getActiveOwnedAppIds 结果，避免供应商分类标签页重复计算导致卡死
    let _cachedActiveOwnedAppIds = null;
    let _cachedActiveOwnedAppIdsKey = '';

    // --- getActiveOwnedAppIds ---
    function getActiveOwnedAppIds() {
        const showFamilyShared = storage.getShowFamilyShared();
        const cacheKey = `${state.ownedGames.length}|${showFamilyShared}`;
        if (_cachedActiveOwnedAppIds && _cachedActiveOwnedAppIdsKey === cacheKey) {
            return _cachedActiveOwnedAppIds;
        }
        const appIds = new Set();
        state.ownedGames.forEach(g => {
            if (showFamilyShared || isGameOwnedByMe(g)) {
                appIds.add(g.appid);
            }
        });
        _cachedActiveOwnedAppIds = appIds;
        _cachedActiveOwnedAppIdsKey = cacheKey;
        return appIds;
    }

    // --- invalidateActiveOwnedAppIdsCache ---
    // 当 ownedGames 或家庭组开关变化时，使缓存失效
    function invalidateActiveOwnedAppIdsCache() {
        _cachedActiveOwnedAppIds = null;
        _cachedActiveOwnedAppIdsKey = '';
    }

    // --- Token&SteamID检测 ---
    // ==================== Token & SteamID 自动检测 ====================
    let _cachedWebApiToken = null;

    function getAccessTokenSync() {
        try {
            const appConfig = document.getElementById('application_config');
            if (appConfig) {
                const storeConfig = JSON.parse(appConfig.getAttribute('data-store_user_config') || '{}');
                if (storeConfig.webapi_token) return storeConfig.webapi_token;
            }
        } catch (e) { /* ignore */ }
        try {
            const m = document.documentElement.innerHTML.match(/"webapi_token"\s*:\s*"([^"]+)"/);
            if (m && m[1]) return m[1];
        } catch (e) { /* ignore */ }
        return null;
    }

    // v2.11.36 (FEAT-015 TASK-003): 迁移至 sglvGmFetchTextRetry（永不 reject 语义保留——
    //   解析失败/非 2xx/网络错误/超时均 resolve(null)，调用方 getAccessToken 继续下一级兑底）
    function fetchWebApiTokenFromStore() {
        if (_cachedWebApiToken) return Promise.resolve(_cachedWebApiToken);
        return sglvGmFetchTextRetry('https://store.steampowered.com/', { timeout: 10000 }).then(html => {
            try {
                const m1 = html.match(/id="application_config"[^>]*data-store_user_config="([^"]*)"/);
                if (m1 && m1[1]) {
                    const decoded = m1[1].replace(/&amp;/g, '&').replace(/&quot;/g, '"').replace(/&lt;/g, '<').replace(/&gt;/g, '>');
                    const config = JSON.parse(decoded);
                    if (config.webapi_token) { _cachedWebApiToken = config.webapi_token; return config.webapi_token; }
                }
                const m2 = html.match(/"webapi_token"\s*:\s*"([^"]+)"/);
                if (m2 && m2[1]) { _cachedWebApiToken = m2[1]; return m2[1]; }
            } catch (e) { /* ignore */ }
            return null;
        }).catch(() => null);
    }

    async function getAccessToken() {
        const syncToken = getAccessTokenSync();
        if (syncToken) return syncToken;
        const storeToken = await fetchWebApiTokenFromStore();
        if (storeToken) return storeToken;
        return storage.getApiKey() || null;
    }

    function detectSteamId() {
        try { if (unsafeWindow.g_steamID) return unsafeWindow.g_steamID; } catch { /* g_steamID may not exist in all page contexts */ }
        try {
            const appConfig = document.getElementById('application_config');
            if (appConfig) {
                const userInfo = JSON.parse(appConfig.getAttribute('data-userinfo') || '{}');
                if (userInfo.steamid) return String(userInfo.steamid);
            }
        } catch (e) { /* ignore */ }
        const m = document.documentElement.innerHTML.match(/g_steamID\s*=\s*"(\d{17})"/);
        return m ? m[1] : '';
    }

    // --- showToast ---
    // v2.8.3: showToast 升级为委托 sglvToast（保持向后兼容）
    function showToast(msg) {
        sglvToast.info(msg);
    }

    // --- 剪贴板工具 ---
    // v2.3.27: 复制文本到剪贴板（Clipboard API + textarea 兜底）
    function copyTextToClipboard(text) {
        try {
            if (navigator.clipboard && navigator.clipboard.writeText) {
                navigator.clipboard.writeText(text).catch(() => fallbackCopyText(text));
                return;
            }
        } catch { /* ignore */ }
        fallbackCopyText(text);
    }
    function fallbackCopyText(text) {
        try {
            const ta = document.createElement('textarea');
            ta.value = text;
            ta.style.cssText = 'position:fixed;top:-9999px;left:-9999px;opacity:0';
            document.body.appendChild(ta);
            ta.select();
            document.execCommand('copy');
            document.body.removeChild(ta);
        } catch { /* ignore */ }
    }

    // --- fetchDynamicStoreOwnedAppIds ---
    let _dynamicStoreOwnedAppIds = null; // Set<number> | null（模块级缓存）
    // v2.11.36 (FEAT-015 TASK-003): 迁移至 sglvGmFetchRetry（非 2xx/parse 失败统一进 catch，补终态失败通知）
    async function fetchDynamicStoreOwnedAppIds() {
        if (_dynamicStoreOwnedAppIds) return _dynamicStoreOwnedAppIds;
        try {
            const data = await sglvGmFetchRetry('https://store.steampowered.com/dynamicstore/userdata/', { timeout: 15000 });
            const ownedApps = data?.rgOwnedApps;
            if (Array.isArray(ownedApps)) {
                _dynamicStoreOwnedAppIds = new Set(ownedApps.map(Number).filter(n => Number.isFinite(n) && n > 0));
                console.log(`[SGLV] dynamicstore/userdata 获取 ${_dynamicStoreOwnedAppIds.size} 个 owned appids`);
            }
        } catch (e) {
            console.warn('[SGLV] dynamicstore/userdata 获取失败:', e);
            sglvNotifyNetFail('DynamicStore 拥有游戏列表获取', e);   // v2.11.36: 终态失败通知(60s 节流)
        }
        return _dynamicStoreOwnedAppIds;
    }

    // --- getDynamicStoreAppIds ---
    // 参考 SteamPeek标记库存状态-1.9.js：从页面 GDynamicStore 读取愿望单/库存 appid 集合（即时、零请求）
    function getDynamicStoreAppIds(kind) {
        try {
            const win = (typeof unsafeWindow !== 'undefined') ? unsafeWindow : window;
            let raw = null;
            if (kind === 'wishlist') raw = win.GDynamicStore?.s_rgWishlist || win.g_rgWishlist;
            else if (kind === 'owned') raw = win.GDynamicStore?.s_rgOwnedApps;
            if (!raw) return new Set();
            const arr = Array.isArray(raw) ? raw : Object.keys(raw);
            return new Set(arr.map(Number).filter(n => Number.isFinite(n) && n > 0));
        } catch { return new Set(); }
    }

    // ==================== SGLV 子模块（v2.4.1 子闭包封装，仅导出 initUI/autoScan） ====================
    const SGLV_API = {};
    (function () {
    // ==================== SGLV 专属工具函数 ====================
    // ==================== 工具函数 ====================
    function requestSteamAPI(url) {
        // v2.3.15: 增加 timeout（30s）和 ontimeout 处理，避免请求挂起导致 loading 卡住
        // v2.7.9: 检测 HTML 响应（未登录/API Key 失效时 Steam 返回登录页），提前抛出清晰错误
        // v2.11.36 (FEAT-015 TASK-003): 迁移至 sglvGmFetchTextRetry——文本通道保留 HTML 检测与本地 JSON.parse
        //   （core 文本通道 2xx 才返回，非 2xx/网络错误/超时均 reject；HTML 检测文案冻结）
        return sglvGmFetchTextRetry(url, { timeout: 30000 }).then(text => {
            // 检测 HTML 响应（登录页/错误页），避免 JSON.parse 报模糊错误
            if (text.startsWith('<') || text.startsWith('<!DOCTYPE')) {
                throw new Error('Steam API 返回 HTML 而非 JSON（可能未登录或 API Key 失效）');
            }
            return JSON.parse(text);
        });
    }

    // 解析 Steam 游戏库页面中的时长文本（参考 steam-activity-modern-4.3.js）
    function parsePlaytimeTextToMinutes(text) {
        if (!text) return 0;
        const t = text.trim();
        const m1 = t.match(/([\d.]+)\s*hrs?/i);
        if (m1) return Math.round(parseFloat(m1[1]) * 60);
        const m2 = t.match(/([\d.]+)\s*小时/);
        if (m2) {
            const h = parseFloat(m2[1]);
            const minM = t.match(/(\d+)\s*分钟/);
            const min = minM ? parseInt(minM[1], 10) : 0;
            return Math.round(h * 60 + min);
        }
        const m3 = t.match(/(\d+)\s*minutes?/i);
        if (m3) return parseInt(m3[1], 10);
        return 0;
    }

    function parseLastPlayedToTs(text) {
        if (!text) return 0;
        const t = text.trim();
        if (!/last|最后|上次|play|今天|昨天|前天|\d{4}年|days?|hours?/i.test(t)) return 0;
        const now = Math.floor(Date.now() / 1000);
        if (/今天|just now|几分钟前|a few minutes ago/i.test(t)) return now;
        if (/昨天|yesterday/i.test(t)) return now - 86400;
        if (/前天/i.test(t)) return now - 2 * 86400;
        const dayM = t.match(/(\d+)\s*天前|(\d+)\s*days?\s*ago/i);
        if (dayM) return now - parseInt(dayM[1] || dayM[2], 10) * 86400;
        return now;
    }

    // 无 API Key 时抓取 Steam 社区游戏库页面获取时长（参考 steam-activity-modern-4.3.js）
    // v2.11.36 (FEAT-015 TASK-003): 迁移至 sglvGmFetchTextRetry（原非 2xx resolve {ok:false}→空结果，
    //   新非 2xx reject→catch→空结果，语义等价）
    async function fetchGamesPage(steamId, tab = 'all') {
        if (!steamId) return { games: [], total: 0 };
        const url = `https://steamcommunity.com/profiles/${steamId}/games/?tab=${tab}`;
        try {
            const text = await sglvGmFetchTextRetry(url, { timeout: 20000 });
            const doc = new DOMParser().parseFromString(text, 'text/html');
            const rows = doc.querySelectorAll('.gameListRow');
            const games = [];
            rows.forEach(row => {
                const appid = parseInt(row.id?.replace('game_', '') || row.dataset?.appid || '0', 10);
                if (!appid) return;
                const name = row.querySelector('.gameListRowItemName, .gameListRowItem h2, .gameListRowItem .gameListRowItemName')?.textContent?.trim() ||
                             row.querySelector('a[href*="/app/"]')?.textContent?.trim() || '';
                const logoImg = row.querySelector('img.gameListLogo, img[src*="capsule"], img[src*="header"]');
                const logoSrc = logoImg?.getAttribute('src') || '';
                const playtimeEl = row.querySelector('.gameListRowItem .gameListRowItemHours, .hours_played, .gameListRowItem .gameListRowItemTime, .gameListRowItem .gameListRowItemStat');
                const playtimeText = playtimeEl?.textContent?.trim() || '';
                const playtime = parsePlaytimeTextToMinutes(playtimeText);
                const lastPlayedText = row.querySelector('.gameListRowItem .gameListRowItemLastPlayed, .last_played, .gameListRowItem .gameListRowItemTime')?.textContent?.trim() || '';
                const lastPlayed = parseLastPlayedToTs(lastPlayedText);
                games.push({ appid, name: name || `App ${appid}`, playtime_forever: playtime, playtime_2weeks: 0, rtime_last_played: lastPlayed, img_icon_url: '', logoSrc });
            });
            const totalEl = doc.querySelector('.gameListRowItem .gameListRowItemCount, .gameListRow .gameListRowItem .gameListRowItemCount');
            const totalText = totalEl?.textContent || '';
            const totalMatch = totalText.match(/(\d+)/);
            const total = totalMatch ? parseInt(totalMatch[1], 10) : games.length;
            return { games, total };
        } catch (e) {
            console.warn('[SGLV] games 页抓取失败:', e);
            return { games: [], total: 0 };
        }
    }

    function getGameOwnerNames(g) {
        if (!g.owners || g.owners.length === 0) return '';
        const familyInfo = storage.getFamilyInfo();
        const nameMap = familyInfo?.steamIdtoName || {};
        return g.owners.map(sid => nameMap[sid] || 'ID:' + sid.slice(-4)).join(', ');
    }

    // v2.9.50: 通用计算缓存(持久化版)— 内存镜像 + IDB 持久化(通过 SGLVCore.PersistentComputeCache)
    // 旧实现仅 session 内 Map,关闭浏览器/升级脚本即全部失效。
    // 新增 PCC IDB 持久化层,关键计算结果(年度统计 / 家庭组累计 / 成就指标 / wishlist 统计)跨 session 复用。
    //
    // 工作流:
    //   1) getCached(key, computeFn) — 同步读 _computedCache,未命中则 compute 后写内存 + 异步落 PCC
    //   2) hydrateComputedCache() — 启动时从 PCC IDB 同步预填充到 _computedCache
    //   3) clearComputedCache() — 清内存 + 清 PCC
    const _computedCache = new Map();
    const _PCC = (typeof unsafeWindow !== 'undefined' && unsafeWindow.SGLVCore) || window.SGLVCore;
    const _PCC_CACHE = _PCC && _PCC.PersistentComputeCache ? _PCC.PersistentComputeCache : null;
    // v2.9.50: 通用计算缓存 schema 版本(对应 _computedCache 这层,business 单独用自己 schema 升级)
    const _COMPUTE_CACHE_SCHEMA_VER = 1;
    let _pccHydrated = false;

    function cacheKey(...parts) {
        return parts.map(p => JSON.stringify(p)).join('|');
    }

    function getCached(key, computeFn) {
        if (_computedCache.has(key)) return _computedCache.get(key);
        const v = computeFn();
        _computedCache.set(key, v);
        // v2.9.50: 同步写内存 + 异步落 PCC(IDB 持久化,跨 session 复用)
        if (_PCC_CACHE) {
            try { _PCC_CACHE.set(key, _COMPUTE_CACHE_SCHEMA_VER, key, v); } catch (e) { /* quota */ }
        }
        return v;
    }

    // v2.9.50: 启动时从 PCC IDB 同步预填充到 _computedCache(必须在 sglvIDB.loadAll() 完成后调用)
    // 返回:已 hydrate 的 key 数量
    function hydrateComputedCache() {
        if (_pccHydrated) return 0;
        if (!_PCC_CACHE) { _pccHydrated = true; return 0; }
        try {
            const pccMem = _PCC_CACHE._mem || {};
            let count = 0;
            for (const k of Object.keys(pccMem)) {
                if (!_computedCache.has(k)) {
                    const entry = pccMem[k];
                    if (entry && entry.value !== undefined && entry._ver === _COMPUTE_CACHE_SCHEMA_VER) {
                        _computedCache.set(k, entry.value);
                        count++;
                    }
                }
            }
            _pccHydrated = true;
            if (count > 0) console.log(`[SGLV-Compute] PCC IDB 预热 ${count} 条已缓存计算结果到 _computedCache`);
            return count;
        } catch (e) {
            console.warn('[SGLV-Compute] PCC hydrate 失败:', e);
            _pccHydrated = true;
            return 0;
        }
    }

    // v2.9.50: 按"游戏库版本"选择性地失效 PCC 缓存(避免整个 clear 导致其他无关数据丢失)
    //   旧逻辑:_computedCache.clear() 把所有内存缓存清空,下次渲染全部重算
    //   新逻辑:仅失效 sig 与 ownedGames 关联的 key,其他不依赖 ownedGames 的(搜索结果等)保留
    //   当前简单实现:游戏库变化时整体清空(保持安全),但仍通过 PCC 落盘给下次复用
    function clearComputedCache() {
        console.log('[SGLV-Compute] clearComputedCache 被调用 — 失效所有计算缓存');
        _computedCache.clear();
        if (_PCC_CACHE) {
            try { _PCC_CACHE.clear(); } catch (e) { /* ignore */ }
        }
        _pccHydrated = true; // 已清,无需再 hydrate
        _cachedActiveOwnedAppIds = null;
        _cachedActiveOwnedAppIdsKey = '';
        _cachedDlcCount = null;
        _cachedDlcCountKey = '';
        _cachedStatFiltered = null;        // v2.9.50: 同步失效 getStatFilteredGames 缓存
        _cachedStatFilteredSig = '';
        if (SGLV_API.invalidateAppTypeCache) SGLV_API.invalidateAppTypeCache();
        const hadDlcTypeMap = !!dlcTypeMap;
        dlcTypeMap = null;
        _dlcsByParentCache = null;
        console.log(`[SGLV-Compute] clearComputedCache 完成 — dlcTypeMap ${hadDlcTypeMap ? '已失效 (之前有数据)' : '本就为空'}，appTypeCache 已失效，DLC 数量缓存已失效，statFiltered 已失效，dlcsByParent 已失效`);
    }

    // v2.9.50: 业务级持久化计算结果工具(给 computeYearlyStats / computeInsightData 等大数据用)
    //   与 getCached 不同:不依赖 _computedCache 内存层,而是单独命名空间(biz_xxx)便于跨域管理
    //   key: 业务名,如 'biz_yearly_stats'
    //   schemaVer: schema 版本号,升级时强制重算
    //   inputSig: 输入签名(如 "123|456" = 游戏数 + 总acquiredTime)
    //   computeFn: 同步重算函数,返回新值
    //   返回:同步值(命中缓存直接返回,未命中同步重算并落盘)
    function getBizCached(key, schemaVer, inputSig, computeFn) {
        if (!_PCC_CACHE) return computeFn();
        // 1) 同步从 PCC 读 + 元数据
        const meta = _PCC_CACHE.getSyncWithMeta(key);
        if (meta && meta._ver === schemaVer && meta._sig === inputSig) {
            return meta.value;
        }
        // 2) 同步重算 + 落盘
        const v = computeFn();
        try { _PCC_CACHE.set(key, schemaVer, inputSig, v); } catch (e) { /* ignore */ }
        return v;
    }

    function getGameDBMeta(appid) {
        for (const [pubName, pubData] of Object.entries(GAME_DB)) {
            for (const [seriesName, games] of Object.entries(pubData)) {
                if (games.some(g => g.id === appid)) {
                    return { publisher: pubName, series: seriesName };
                }
            }
        }
        return { publisher: '', series: '' };
    }

    // v2.11.44: Steam 社区小图标 CDN 路径迁移适配
    // 新游戏（含未发售，如 app 4292950）的社区图标仅存在于新路径
    //   shared.{fastly,akamai}.steamstatic.com/community_assets/images/apps/{appid}/{hash}.jpg，
    // 旧路径 cdn.{cloudflare,akamai}.steamstatic.com/steamcommunity/public/images/apps/… 对其 404；
    // 实测新路径对老游戏同样可用（TF2/440 新旧均 200）= 超集 → 新路径优先，旧路径留作网络兜底。
    // 另：此类新游戏常无任何商店封面资产（capsule/header 全 404），社区图标是唯一可用图。
    function communityIconChainUrls(appid, iconHash) {
        const cf = 'https://cdn.cloudflare.steamstatic.com';
        const ak = 'https://cdn.akamai.steamstatic.com';
        const shAk = 'https://shared.akamai.steamstatic.com';
        const shF = 'https://shared.fastly.steamstatic.com';
        const urls = [];
        if (iconHash) {
            urls.push(`${shF}/community_assets/images/apps/${appid}/${iconHash}.jpg`); // 新路径（超集，新老通吃）
            urls.push(`${shAk}/community_assets/images/apps/${appid}/${iconHash}.jpg`);
            urls.push(`${cf}/steamcommunity/public/images/apps/${appid}/${iconHash}.jpg`); // 旧路径（老游戏；shared.* 不可达时兜底）
            urls.push(`${ak}/steamcommunity/public/images/apps/${appid}/${iconHash}.jpg`);
        }
        // 无 hash / hash 全 404 → 商店小胶囊（多 CDN）
        urls.push(`${cf}/steam/apps/${appid}/capsule_sm_120.jpg`);
        urls.push(`${ak}/steam/apps/${appid}/capsule_sm_120.jpg`);
        urls.push(`${shAk}/store_item_assets/steam/apps/${appid}/capsule_sm_120.jpg`);
        urls.push(`${shF}/store_item_assets/steam/apps/${appid}/capsule_sm_120.jpg`);
        return urls;
    }
    function getGameIconUrl(appid, iconHash) {
        // v2.11.44: 命中成功缓存直接返回；否则新路径优先（注释见 communityIconChainUrls）
        const good = getPosterGood(appid, 'icon');
        if (good) return good;
        if (iconHash) return `https://shared.fastly.steamstatic.com/community_assets/images/apps/${appid}/${iconHash}.jpg`;
        return `https://cdn.cloudflare.steamstatic.com/steam/apps/${appid}/capsule_sm_120.jpg`;
    }
    // v2.11.44: 小图标统一回退链（对齐封面 _sglvPosterFallback 三段式）
    //   成功缓存 → communityIconChainUrls 链式回退 → header.jpg 兜底 → 隐藏；成功 onload 记录缓存避免重复试错
    function sglvIconFallback(img, appid, iconHash) {
        if (!img || !appid) return;
        const cur = img.getAttribute('src') || '';
        const good = getPosterGood(appid, 'icon');
        if (good && good !== cur) {
            // 缓存 URL 仍失败时重新进入本函数，此时 good===cur 会落入链式回退，无死循环
            img.onerror = function () { img.onerror = null; sglvIconFallback(img, appid, iconHash); };
            img.onload = function () { img.onload = null; };
            img.src = good;
            return;
        }
        const chain = communityIconChainUrls(appid, iconHash);
        // 当前 src 已是链中某个 URL（初始加载失败触发）→ 从其下一个继续，避免重复请求
        let start = chain.indexOf(cur) + 1;
        const tryNext = (i) => {
            if (i >= chain.length) {
                // 最后一搏：header.jpg（几乎所有已发售游戏都有）
                img.onerror = function () { img.onerror = null; img.style.display = 'none'; };
                img.src = `https://cdn.cloudflare.steamstatic.com/steam/apps/${appid}/header.jpg`;
                return;
            }
            img.onerror = function () { img.onerror = null; tryNext(i + 1); };
            img.onload = function () { recordPosterGood(appid, img.src, 'icon'); img.onload = null; };
            img.src = chain[i];
        };
        tryNext(start);
    }
    // 暴露给内联 onerror 使用（页面上下文）
    unsafeWindow._sglvIconFallback = sglvIconFallback;

    // v2.4.3: 多 CDN 封面回退链（参考 steam-family-game-analysis v1.58 faLoadCover 多 CDN fallback）
    // 修复 cdn.cloudflare.steamstatic.com 不可达（部分网络环境被阻断/抽风）时封面大面积获取不到的问题：
    // 依次尝试 cloudflare → cdn.akamai → shared.akamai → shared.fastly(store_item_assets)，全部失败再走 appdetails API
    // v2.9.106: 新增 shared.fastly.steamstatic.com 作为第四 CDN 源（部分新游戏仅 fastly 有图）
    function coverChainUrls(appid, kind) {
        const cf = `https://cdn.cloudflare.steamstatic.com/steam/apps/${appid}`;
        const ak = `https://cdn.akamai.steamstatic.com/steam/apps/${appid}`;
        const sh = `https://shared.akamai.steamstatic.com/store_item_assets/steam/apps/${appid}`;
        const sf = `https://shared.fastly.steamstatic.com/store_item_assets/steam/apps/${appid}`;
        if (kind === 'poster') {
            // v2.9.105: 补充 shared.akamai store_item_assets 路径的 library_600x900（部分新游戏仅在此路径有图）
            // v2.9.106: 追加 shared.fastly store_item_assets 路径
            return [
                `${cf}/library_600x900_2x.jpg`,  // HD 竖版
                `${cf}/library_600x900.jpg`,      // 标准竖版
                `${ak}/library_600x900_2x.jpg`,   // Akamai HD 竖版
                `${ak}/library_600x900.jpg`,      // Akamai 标准竖版
                `${sh}/library_600x900_2x.jpg`,   // shared.akamai HD 竖版
                `${sh}/library_600x900.jpg`,      // shared.akamai 标准竖版
                `${sf}/library_600x900_2x.jpg`,   // v2.9.106: shared.fastly HD 竖版
                `${sf}/library_600x900.jpg`,      // v2.9.106: shared.fastly 标准竖版
                `${cf}/header.jpg`,               // 宽版（几乎所有游戏都有）
                `${ak}/header.jpg`,
                `${sh}/header.jpg`,
                `${sf}/header.jpg`,
            ];
        }
        if (kind === 'capsule') {
            return [
                `${cf}/capsule_467x181.jpg`,      // 大横幅封面（最清晰）
                `${cf}/capsule_231x87.jpg`,       // 中等横幅
                `${cf}/header.jpg`,               // 头图兜底
                `${ak}/capsule_231x87.jpg`,
                `${ak}/header.jpg`,
                `${sh}/capsule_184x69.jpg`,       // shared akamai store_item_assets
                `${sh}/header.jpg`,
                `${sf}/capsule_184x69.jpg`,       // v2.9.106: shared fastly store_item_assets
                `${sf}/header.jpg`,
            ];
        }
        return [`${cf}/header.jpg`, `${ak}/header.jpg`, `${sh}/header.jpg`, `${sf}/header.jpg`]; // header
    }

    // API 图片回退：当所有 CDN 路径都失败时，通过 Steam Store API 获取真实图片 URL（含 hash）
    // v2.4.3 重构：成功/进行中/失败三态分离——旧实现用同一 Map 的 '' 同时表示"请求中"与"失败"，
    // 导致同 appid 并发回退时后者直接占位、且瞬时失败后永不再重试（封面获取不到的另一根因）
    // v2.9.105: 缓存键按 kind 隔离（poster/capsule/header），避免横版 URL 被竖版 poster 复用导致裁切变形
    const _posterApiCache = new Map();   // appid:kind → API 获取成功的图片 URL
    const _posterApiPending = new Map(); // appid:kind → 进行中的 API 请求 Promise（并发共享）
    // v2.4.3: 占位替换仅替换 <img> 节点本身，不再覆盖父容器 innerHTML——
    // 封面视图中父容器还含有徽章浮层（sglv-wl-cover-badges），需保留
    // v2.8.2: 继承原 img 的 className（sglv-list-icon / sglv-card-img），
    //         使占位 div 获得与原图相同的固定尺寸（92x43 / 100%×100%），避免布局塌陷
    function _posterImgToPlaceholder(img) {
        if (!img || !img.parentElement) return;
        const holder = document.createElement('div');
        holder.className = img.className;
        holder.style.cssText = 'display:flex;align-items:center;justify-content:center;color:#5a6a7a;font-size:11px';
        holder.textContent = isZh ? '无图片' : 'No Image';
        img.parentElement.replaceChild(holder, img);
    }
    // v2.9.105: kind 感知——poster 优先 header_image（更宽，适合竖版裁切），
    //           capsule 优先 capsule_image（横幅原生），header 优先 header_image
    // v2.11.36 (FEAT-015 TASK-003): 迁移至 sglvGmFetchRetry（永不 reject 语义保留——
    //   parse 失败/非 2xx/网络错误/超时均 resolve('')；pending map 清理收敛到 .finally）
    function _fetchCoverApiUrl(appid, kind) {
        const cacheKey = `${appid}:${kind || 'poster'}`;
        if (_posterApiCache.has(cacheKey)) return Promise.resolve(_posterApiCache.get(cacheKey));
        if (_posterApiPending.has(cacheKey)) return _posterApiPending.get(cacheKey);
        const p = sglvGmFetchRetry(
            // v2.8.1: filters=capsule_image,header_image 同为无效过滤值（返回 data:[]），
            //         CDN 全部失败时 API 兜底始终拿不到 URL → 直接占位。改用 filters=basic（含 header_image）。
            `https://store.steampowered.com/api/appdetails?appids=${appid}&filters=basic`,
            { timeout: 10000 }
        ).then(d => {
            let url = '';
            try {
                const entry = d && d[appid];
                if (entry?.success && entry?.data) {
                    // v2.9.105: 按 kind 选择最佳图片 URL
                    if (kind === 'capsule') {
                        url = entry.data.capsule_image || entry.data.header_image || '';
                    } else {
                        // poster / header 都优先 header_image（460x215，比 capsule 231x87 更适合竖版裁切）
                        url = entry.data.header_image || entry.data.capsule_image || '';
                    }
                }
            } catch { /* JSON parse or data shape mismatch; return empty url */ }
            if (url) _posterApiCache.set(cacheKey, url); // 仅缓存成功结果；失败不记录，下次渲染可重试
            return url;
        }).catch(() => '').finally(() => { _posterApiPending.delete(cacheKey); });
        _posterApiPending.set(cacheKey, p);
        return p;
    }
    // v2.9.105: 传递 kind 参数，使 API 兜底能按图片类型选择最佳 URL
    unsafeWindow._sglvPosterFallback = function(img, appid, kind) {
        _fetchCoverApiUrl(appid, kind).then(url => {
            if (url) {
                // API URL 加载仍失败 → 占位（先替换 onerror，防止链式 handler 死循环）
                img.onerror = function() {
                    img.onerror = null;
                    _posterImgToPlaceholder(img);
                };
                img.src = url;
            } else {
                _posterImgToPlaceholder(img);
            }
        });
    };

    // 统一封面 <img> 标签生成：成功URL缓存 → 多 CDN 直链回退 → API 获取 → 占位
    // v2.4.0: 增加成功URL内存缓存；v2.4.3: 多 CDN 回退链 + 按 kind 隔离缓存
    // v2.9.105: ① 传递 kind 给 _sglvPosterFallback 使 API 兜底按类型选图
    //           ② onerror 链跳过 chain[0]（与初始 src 相同，避免重复请求）
    function coverImgTag(appid, name, kind, cls) {
        const good = getPosterGood(appid, kind);
        if (good) {
            return `<img class="${cls}" src="${good}" alt="${name}" loading="lazy" onerror="_sglvPosterFallback(this,'${appid}','${kind}');" onload="_sglvRecordPosterGood('${appid}',this.src,'${kind}');">`;
        }
        const chain = coverChainUrls(appid, kind);
        // v2.9.105: onerror 链从 chain[1] 开始（chain[0] 已作为初始 src 尝试）
        let handler = `_sglvPosterFallback(this, '${appid}', '${kind}');`;
        for (let i = chain.length - 1; i >= 1; i--) {
            handler = `this.src='${chain[i]}';this.onerror=function(){${handler}}`;
        }
        return `<img class="${cls}" src="${chain[0]}" alt="${name}" loading="lazy" onerror="${handler}" onload="_sglvRecordPosterGood('${appid}',this.src,'${kind}');">`;
    }
    function posterImg(appid, name) { return coverImgTag(appid, name, 'poster', 'sglv-card-img'); }
    // 横版封面图片（header.jpg），用于游戏橱窗列表
    function headerImg(appid, name) { return coverImgTag(appid, name, 'header', 'sglv-card-img'); }
    // v2.4.3: 横板封面图片（capsule 大横幅），用于愿望单封面视图
    function capsuleImg(appid, name) { return coverImgTag(appid, name, 'capsule', 'sglv-wl-cover-img'); }

    // v2.9.25: 分页导航——仅保留 首页|上页|下页|末页 + 跳页输入，无快捷页码按钮
    function renderPagination(container, prefix, page, totalPages, totalItems, onPrev, onNext, onJump) {
        if (!container) return;
        container.innerHTML = `
            <button class="sglv-page-arrow sglv-page-text-btn" id="${prefix}-first" ${page <= 1 ? 'disabled' : ''}>${T.first}</button>
            <button class="sglv-page-arrow sglv-page-text-btn" id="${prefix}-prev" ${page <= 1 ? 'disabled' : ''}>${T.prev}</button>
            <button class="sglv-page-arrow sglv-page-text-btn" id="${prefix}-next" ${page >= totalPages ? 'disabled' : ''}>${T.next}</button>
            <button class="sglv-page-arrow sglv-page-text-btn" id="${prefix}-last" ${page >= totalPages ? 'disabled' : ''}>${T.last}</button>
            <input type="number" class="sglv-page-jump-input" id="${prefix}-jump" min="1" max="${totalPages}" value="${page}" title="${T.jumpTo}">
            <span class="sglv-page-info">${page}/${totalPages} (${totalItems})</span>
        `;
        const goPage = (p) => {
            const target = Math.min(Math.max(1, p), totalPages);
            if (target === page) return;
            if (onJump) onJump(target);
        };
        container.querySelector(`#${prefix}-first`)?.addEventListener('click', () => goPage(1));
        container.querySelector(`#${prefix}-prev`)?.addEventListener('click', () => goPage(page - 1));
        container.querySelector(`#${prefix}-next`)?.addEventListener('click', () => goPage(page + 1));
        container.querySelector(`#${prefix}-last`)?.addEventListener('click', () => goPage(totalPages));
        const jumpInput = container.querySelector(`#${prefix}-jump`);
        jumpInput?.addEventListener('keydown', e => {
            if (e.key === 'Enter') {
                e.preventDefault();
                const p = parseInt(jumpInput.value);
                if (!isNaN(p)) goPage(p);
            }
        });
        jumpInput?.addEventListener('blur', () => {
            const p = parseInt(jumpInput.value);
            if (!isNaN(p) && p >= 1 && p <= totalPages && p !== page) goPage(p);
            else jumpInput.value = page;
        });
    }

    // ==================== 数据获取 ====================
    // 方式1: 通过 access_token 获取家庭共享库（含自身游戏，include_own=true）
    // v2.8.1: onProgress(stage, percent, text) 进度回调，UI 可选接入避免"界面不动"
    async function fetchFamilyGameList(authToken, onProgress) {
        const report = (stage, percent, text) => { if (typeof onProgress === 'function') onProgress(stage, percent, text); };
        try {
            // 阶段 1：获取家庭组基本信息
            report(1, 25, '正在获取家庭组信息…');
            const familyData = await requestSteamAPI(
                `https://api.steampowered.com/IFamilyGroupsService/GetFamilyGroupForUser/v1/?access_token=${authToken}&include_family_group_response=true`
            );
            if (!familyData?.response?.family_groupid) { report(1, 100, '家庭组信息为空'); return null; }
            const familyGroupId = familyData.response.family_groupid;

            // 阶段 2：拉取共享库（主耗时 API，amount 不可知，给个递进动画）
            report(2, 50, '正在获取家庭组共享游戏库…');
            const gameData = await requestSteamAPI(
                `https://api.steampowered.com/IFamilyGroupsService/GetSharedLibraryApps/v1/?access_token=${authToken}&family_groupid=${familyGroupId}&include_own=true&include_excluded=false&include_non_games=false`
            );
            report(3, 80, '正在整理共享游戏数据…');
            if (gameData?.response?.apps) {
                const apps = gameData.response.apps;
                const games = apps
                    .filter(app => app.exclude_reason === 0)
                    .map(app => ({
                        appid: app.appid,
                        name: app.name || `App ${app.appid}`,
                        playtime: 0,
                        icon: app.img_icon_hash || '',
                        lastPlayed: app.rt_time_acquired || 0,
                        acquiredTime: app.rt_time_acquired || 0,
                        owners: app.owner_steamids || [],
                    }));
                report(4, 100, `已获取 ${games.length} 款家庭组共享游戏`);
                return games;
            }
        } catch (e) {
            console.warn('[SGLV] fetchFamilyGameList error:', e);
        }
        return null;
    }

    // 方式2: 获取拥有游戏（优先 API Key，尝试 access_token，最后 fallback 页面抓取）
    async function fetchOwnedGames(steamId, authToken) {
        const apiKey = storage.getApiKey();

        // 2.1 优先 API Key
        if (apiKey) {
            try {
                const data = await requestSteamAPI(
                    `https://api.steampowered.com/IPlayerService/GetOwnedGames/v0001/?key=${apiKey}&steamid=${steamId}&include_appinfo=1&include_played_free_games=1&format=json`
                );
                if (data?.response?.games) {
                    console.log(`[SGLV] 通过 API Key 获取 ${data.response.games.length} 款游戏（含时长）`);
                    return {
                        games: data.response.games.map(g => ({
                            appid: g.appid,
                            name: g.name || `App ${g.appid}`,
                            playtime: g.playtime_forever || 0,
                            icon: g.img_icon_url || '',
                            lastPlayed: g.rtime_last_played || 0,
                            _source: 'api',
                        })),
                        source: 'api'
                    };
                }
            } catch (e) {
                console.warn('[SGLV] API Key 获取失败:', e);
            }
        }

        // 2.2 尝试用 access_token 调用 IPlayerService（部分账号可用）
        if (authToken && steamId) {
            try {
                const data = await requestSteamAPI(
                    `https://api.steampowered.com/IPlayerService/GetOwnedGames/v0001/?access_token=${authToken}&steamid=${steamId}&include_appinfo=1&include_played_free_games=1&format=json`
                );
                if (data?.response?.games) {
                    console.log(`[SGLV] 通过 access_token 获取 ${data.response.games.length} 款游戏（含时长）`);
                    return {
                        games: data.response.games.map(g => ({
                            appid: g.appid,
                            name: g.name || `App ${g.appid}`,
                            playtime: g.playtime_forever || 0,
                            icon: g.img_icon_url || '',
                            lastPlayed: g.rtime_last_played || 0,
                            _source: 'api',
                        })),
                        source: 'api'
                    };
                }
            } catch (e) {
                console.warn('[SGLV] access_token 获取游戏时长失败:', e);
            }
        }

        // 2.3 fallback：抓取社区游戏库页面（无需 Key，可获取时长）
        if (steamId) {
            try {
                const scraped = await fetchGamesPage(steamId, 'all');
                if (scraped.games.length > 0) {
                    console.log(`[SGLV] 通过页面抓取获取 ${scraped.games.length} 款游戏（含时长）`);
                    return {
                        games: scraped.games.map(g => ({
                            appid: g.appid,
                            name: g.name,
                            playtime: g.playtime_forever,
                            icon: g.img_icon_url || '',
                            lastPlayed: g.rtime_last_played,
                            _source: 'scrape',
                        })),
                        source: 'scrape'
                    };
                }
            } catch (e) {
                console.warn('[SGLV] 页面抓取 fallback 失败:', e);
            }
        }

        return { games: [], source: null };
    }

    async function fetchFamilyInfo(authToken) {
        try {
            const data = await requestSteamAPI(
                `https://api.steampowered.com/IFamilyGroupsService/GetFamilyGroupForUser/v1/?access_token=${authToken}&include_family_group_response=true`
            );
            if (data?.response?.family_group) {
                const fg = data.response.family_group;
                const members = fg.members || [];
                const nameMap = {};
                if (members.length > 0) {
                    const steamids = members.map(m => m.steamid);
                    const batchSize = 100;
                    for (let i = 0; i < steamids.length; i += batchSize) {
                        const batch = steamids.slice(i, i + batchSize);
                        const params = batch.map((sid, idx) => `steamids[${idx}]=${sid}`).join('&');
                        try {
                            const pData = await requestSteamAPI(
                                `https://api.steampowered.com/IPlayerService/GetPlayerLinkDetails/v1/?access_token=${authToken}&${params}`
                            );
                            if (pData?.response?.accounts) {
                                pData.response.accounts.forEach(acc => {
                                    if (acc.public_data) {
                                        const sid = acc.public_data.steamid || acc.steamid;
                                        if (sid && acc.public_data.persona_name) {
                                            nameMap[sid] = acc.public_data.persona_name;
                                        }
                                    }
                                });
                            }
                        } catch (e) { /* ignore */ }
                    }
                }
                return {
                    family_groupid: data.response.family_groupid,
                    family_name: fg.name || 'Steam Family',
                    family_member: members.map(m => ({ steamid: m.steamid, userName: nameMap[m.steamid] || '' })),
                    steamIdtoName: nameMap
                };
            }
        } catch (e) {
            console.warn('[SGLV] fetchFamilyInfo error:', e);
        }
        return null;
    }

    // v2.3.29: 获取 dynamicstore/userdata——Steam 商店动态数据，返回完整 owned appids 列表
    // 该端点比 GetOwnedGames 更可靠：包含 CD key 激活、促销许可、免费领取等所有类型的已入库游戏
    // 参考 Steam-License-Classifier 的思路：license 数据是入库的 ground truth

    // 合并两种数据源
    async function fetchAllGames(onProgress) {
        const gamesMap = new Map();
        // v2.9.15: 进度回调——sub-step 1-3 映射到阶段 1 的 0-100%
        const report = (sub, pct, text) => { if (typeof onProgress === 'function') onProgress(sub, pct, text); };

        report(1, 10, isZh ? '正在准备访问令牌…' : 'Preparing access token…');
        const authToken = await getAccessToken();
        const steamId = getActiveSteamId();

        // 步骤1：优先获取个人拥有游戏（含时长）
        if (steamId) {
            report(1, 20, isZh ? '正在拉取个人游戏…' : 'Fetching owned games…');
            const owned = await fetchOwnedGames(steamId, authToken);
            if (owned.games.length > 0) {
                owned.games.forEach(g => {
                    gamesMap.set(g.appid, {
                        appid: g.appid,
                        name: g.name,
                        playtime: g.playtime || 0,
                        icon: g.icon || '',
                        lastPlayed: g.lastPlayed || 0,
                        owners: [],
                        acquiredTime: 0,
                        _source: g._source || owned.source,
                    });
                });
                console.log(`[SGLV] 个人游戏来源: ${owned.source || 'none'}, 共 ${owned.games.length} 款`);
            }
        }

        // 步骤2：通过 access_token 获取家庭共享库（补充共享游戏和归属信息）
        if (authToken) {
            report(2, 50, isZh ? '正在拉取家庭组…' : 'Fetching family…');
            const familyInfo = await fetchFamilyInfo(authToken);
            if (familyInfo) storage.setFamilyInfo(familyInfo);

            const familyGames = await fetchFamilyGameList(authToken);
            if (familyGames && familyGames.length > 0) {
                familyGames.forEach(g => {
                    const existing = gamesMap.get(g.appid);
                    if (!existing) {
                        gamesMap.set(g.appid, {
                            appid: g.appid,
                            name: g.name,
                            playtime: 0,
                            icon: g.icon || '',
                            lastPlayed: g.lastPlayed || 0,
                            owners: g.owners || [],
                            acquiredTime: g.acquiredTime || 0,
                            _source: 'family',
                        });
                    } else {
                        // 用家庭组数据补充 owners 和 acquiredTime
                        if (g.owners && g.owners.length) existing.owners = g.owners;
                        if (g.acquiredTime) existing.acquiredTime = g.acquiredTime;
                    }
                });
                // v2.11.42: 个人入库时间校准——家人新入库共拥游戏会刷新 rt_time_acquired，
                // 趋势图年度柱/今年入库 KPI/SGIS 面板均消费 ownedGames.acquiredTime，须按个人许可页修正
                try {
                    const all = Array.from(gamesMap.values());
                    if (all.some(g => (g.owners || []).length > 1)) {
                        const licenseMap = await fetchPersonalLicenseMap();
                        const corrections = licenseCorrectionsFor(all, licenseMap || {});
                        let n = 0;
                        gamesMap.forEach(g => {
                            const c = corrections[g.appid];
                            if (c) { g.acquiredTime = c; n++; }
                        });
                        if (n > 0) console.log(`[SGLV] 个人入库时间校准：${n} 款共拥游戏已按个人许可页日期修正`);
                        // v2.11.43: 我拥有但家人后买的共拥游戏（非末位拥有者）且无许可页日期 → 时间戳
                        // 是家人的购买时间，清零回退到 lastPlayed 估算口径，趋势/年度统计不再错误计入
                        // 家人购买日。家人独有的共享游戏不受影响（保留家庭组时间）
                        const sid0 = String(steamId || '').trim();
                        if (sid0) {
                            let zeroed = 0;
                            gamesMap.forEach(g => {
                                const owners = g.owners || [];
                                if (owners.length < 2 || g.acquiredTime <= 0) return;
                                const mine = owners.some(o => String(o).trim() === sid0);
                                const lastIsMe = String(owners[owners.length - 1]).trim() === sid0;
                                if (mine && !lastIsMe && !corrections[g.appid]) {
                                    g.acquiredTime = 0; zeroed++;
                                }
                            });
                            if (zeroed > 0) console.log(`[SGLV] ${zeroed} 款家人购买的共拥游戏入库时间已清零（无本人购买时间，回退估算口径）`);
                        }
                    }
                } catch (e) { console.warn('[SGLV] 入库时间校准失败（保留家庭组时间）:', e); }
                console.log(`[SGLV] 通过 access_token 获取家庭共享 ${familyGames.length} 款游戏`);
            }
        }

        // 步骤3：v2.3.29 通过 dynamicstore/userdata 补充 GetOwnedGames API 遗漏的游戏
        // 某些通过 CD key 激活、促销许可或免费领取的游戏可能不在 GetOwnedGames 返回结果中
        // dynamicstore/userdata 是 Steam 商店客户端使用的真实入库数据，包含所有许可类型
        report(3, 80, isZh ? '正在补充遗漏游戏…' : 'Supplementing missing games…');
        const dsOwnedAppIds = await fetchDynamicStoreOwnedAppIds();
        if (dsOwnedAppIds && dsOwnedAppIds.size > 0) {
            let supplemented = 0;
            dsOwnedAppIds.forEach(appid => {
                if (!gamesMap.has(appid)) {
                    gamesMap.set(appid, {
                        appid,
                        name: `App ${appid}`,
                        playtime: 0,
                        icon: '',
                        lastPlayed: 0,
                        owners: [],
                        acquiredTime: 0,
                        _source: 'dynamicstore',
                    });
                    supplemented++;
                }
            });
            if (supplemented > 0) {
                console.log(`[SGLV] dynamicstore/userdata 补充 ${supplemented} 款 GetOwnedGames 遗漏的游戏（CD key/促销许可等）`);
            }
        }

        report(3, 100, isZh ? '库存拉取完成' : 'Done');
        return Array.from(gamesMap.values());
    }

    // v2.3.24: 动态页专用数据源——始终拉取完整家庭组库（含个人 acquiredTime/owners，10 分钟会话级缓存）。
    // 原因：acquiredTime 仅家庭组 API 提供；state.ownedGames 可能是缺少入库时间的缓存数据，
    // 导致个人入库动态为空。此处与"显示家庭共享"开关无关，保证两个入库动态都能正确加载。
    let _timelineFamilyGamesCache = null; // { games, ts, appidSet }
    // v2.3.31: 入库热力图渲染缓存——避免每次切换游玩仪表标签页都重新计算 SVG
    // v2.4.2: 缓存结构扩展为 { signature, html, ts, views }——views 预存各年份/全部视图 HTML，供年份切换直接复用
    let _heatmapRenderCache = null;
    // ==================== v2.11.42: 个人许可页入库时间校准 ====================
    // GetSharedLibraryApps 的 rt_time_acquired 是每个 app 的单一时间戳：家庭成员新入库一款
    // 自己已拥有的游戏时，该时间会被刷新为家人的入库时间。"个人入库动态/入库趋势/热力图"
    // 等"我的入库"语境若直接采信，会把很早购买的游戏统计到家人的入库日期上（当天展示并未
    // 购买的共拥游戏）。修复参考 steam-friend-manager crossVerifyLicenses：抓取个人许可页
    // （store.steampowered.com/account/licenses，仅精确到日）的真实入库日期做日级覆盖。
    // 家庭组入库动态保持原始 rt_time_acquired 不校准（家人入库事件时间本就是家庭组时间）。
    const LICENSE_MAP_TTL = 24 * 60 * 60 * 1000; // 许可页入库日期基本不变，24h 会话级缓存
    const MAX_LICENSE_PAGES = 50;                // AjaxLoadMoreLicenses 分页上限（与 steam-friend-manager 一致）
    let _licenseMapCache = null;                 // { map, ts }，map: appid -> { ts(ms 本地零点), dateStr }

    // 解析许可页日期字符串为本地零点时间戳（ms）；无法识别返回 0
    function parseLicenseDate(dateStr) {
        if (!dateStr) return 0;
        // 中文格式: "2024年6月13日"（l=schinese）
        let m = dateStr.match(/(\d{4})年(\d{1,2})月(\d{1,2})日/);
        if (m) return new Date(Number(m[1]), Number(m[2]) - 1, Number(m[3])).getTime();
        const months = { Jan:0, Feb:1, Mar:2, Apr:3, May:4, Jun:5, Jul:6, Aug:7, Sep:8, Oct:9, Nov:10, Dec:11 };
        // 英文格式: "13 Jun 2024"
        m = dateStr.match(/(\d{1,2})\s+(\w{3})\s+(\d{4})/);
        if (m && months[m[2]] != null) return new Date(Number(m[3]), months[m[2]], Number(m[1])).getTime();
        // 英文格式: "Jun 13, 2024"
        m = dateStr.match(/(\w{3})\s+(\d{1,2}),?\s+(\d{4})/);
        if (m && months[m[1]] != null) return new Date(Number(m[3]), months[m[1]], Number(m[2])).getTime();
        return 0;
    }

    // 从许可页 HTML 片段解析 .license_row 行到 map（appid -> { ts, dateStr }）
    function parseLicenseRows(html, map) {
        try {
            const doc = new DOMParser().parseFromString(html, 'text/html');
            doc.querySelectorAll('.license_row').forEach(row => {
                const link = row.querySelector('a[href*="/app/"]');
                if (!link) return;
                const appMatch = (link.getAttribute('href') || '').match(/\/app\/(\d+)/);
                if (!appMatch) return;
                const dateEl = row.querySelector('.license_date_col');
                if (!dateEl) return;
                const label = dateEl.querySelector('.license_date_col_label');
                if (label) label.remove();
                const dateText = (dateEl.textContent || '').trim();
                const ts = parseLicenseDate(dateText);
                const appid = Number(appMatch[1]);
                if (appid && ts) map[appid] = { dateStr: dateText, ts };
            });
        } catch (e) { console.warn('[SGLV] 许可页 HTML 解析失败:', e); }
    }

    // 抓取个人许可页全量入库日期（首屏 + AjaxLoadMoreLicenses AJAX 分页）。
    // 未登录（重定向登录页）/网络失败返回空 map，调用方按"无法校准"降级保留家庭组时间。
    let _licenseMapPromise = null; // 并发去重
    function fetchPersonalLicenseMap() {
        if (_licenseMapCache && Date.now() - _licenseMapCache.ts < LICENSE_MAP_TTL) return Promise.resolve(_licenseMapCache.map);
        if (_licenseMapPromise) return _licenseMapPromise;
        _licenseMapPromise = (async () => {
            const map = {};
            let fetchFailed = false;
            try {
                const html = await sglvGmFetchTextRetry('https://store.steampowered.com/account/licenses/?l=schinese', { timeout: 15000, retries: 1 });
                parseLicenseRows(html, map);
                const sidMatch = (html || '').match(/g_sessionID\s*=\s*"([^"]+)"/);
                const sessionid = sidMatch ? sidMatch[1] : null;
                const hasMore = html.includes('load_more_licenses') || html.includes('btn_load_more');
                if (hasMore && sessionid) {
                    let cursor = '';
                    for (let pages = 0; pages < MAX_LICENSE_PAGES; pages++) {
                        const data = await sglvGmFetchRetry('https://store.steampowered.com/account/AjaxLoadMoreLicenses/', {
                            method: 'POST', timeout: 15000, retries: 1,
                            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
                            data: `sessionid=${encodeURIComponent(sessionid)}&cursor=${encodeURIComponent(cursor)}`,
                        });
                        if (data && data.html) parseLicenseRows(data.html, map);
                        if (!(data && data.has_more && data.cursor)) break;
                        cursor = data.cursor;
                    }
                }
            } catch (e) {
                fetchFailed = true;
                console.warn('[SGLV] 个人许可页获取失败（跳过入库时间校准）:', e.message || e);
            } finally {
                _licenseMapPromise = null;
            }
            // 网络异常不缓存，下次调用自动重试；未登录（重定向登录页）属稳定态，空 map 也缓存 24h
            // 避免每次渲染个人入库动态都重打许可页
            if (!fetchFailed) {
                _licenseMapCache = { map, ts: Date.now() };
                if (Object.keys(map).length > 0) console.log(`[SGLV] 个人许可页入库日期已获取：${Object.keys(map).length} 条`);
            }
            return map;
        })();
        return _licenseMapPromise;
    }

    // 校准核心（纯函数，供单测）：许可页日期与 rt_time_acquired 不同日的条目 → 许可页日期（秒）。
    // 许可页仅列本人许可，appid 命中即为"我的游戏"，无需再比对 owners；同日保留家庭组时间（真实时刻）。
    function licenseCorrectionsFor(games, licenseMap) {
        const corrections = {};
        if (!Array.isArray(games) || !licenseMap) return corrections;
        for (const g of games) {
            if (!(g.acquiredTime > 0)) continue;
            const lic = licenseMap[g.appid];
            if (!lic || !lic.ts) continue;
            const d1 = new Date(g.acquiredTime * 1000); d1.setHours(0, 0, 0, 0);
            const d2 = new Date(lic.ts); d2.setHours(0, 0, 0, 0);
            if (d1.getTime() !== d2.getTime()) corrections[g.appid] = Math.floor(lic.ts / 1000);
        }
        return corrections;
    }

    // v2.11.43: 判断 rt_time_acquired 是否为"我的购买事件"。
    // GetSharedLibraryApps 的 owner_steamids 按入库顺序排列：末位=最新入库者（购买者），
    // 首位=最早购入者——参考 steam-family-game-analysis v2.10 购买动态的购买者归属
    // （其购买者筛选即 owners.at(-1)，v1.56 起生产验证）。家人后买一款自己已拥有的游戏时
    // owners=[我,家人]、rt_time_acquired=家人的购买时间，该时间戳不是"我"的购买事件。
    function isMyAcquisitionEvent(g, mySteamId) {
        const owners = (g && g.owners) || [];
        if (!mySteamId || owners.length === 0) return true;  // 无归属信息（回退路径）视为自己
        const sid = String(mySteamId).trim();
        if (!owners.some(o => String(o).trim() === sid)) return false; // 不是我的游戏
        if (owners.length === 1) return true;                // 独占拥有，时间即我的购买时间
        return String(owners[owners.length - 1]).trim() === sid; // 末位=最新购买者
    }

    // "我的入库"语境统一出口：家庭组原始 rt_time_acquired + 个人许可页校准。
    // 返回 { games, map, corrected }——map 含全部游戏的入库时间（秒，我的游戏已校准），
    // corrected 为被校准 appid 集合。消费方：个人入库动态/入库趋势时间线/频率分析/排序补齐/热力图。
    async function buildCalibratedAcquiredMap() {
        const familyGames = await fetchTimelineFamilyGames();
        if (!familyGames || familyGames.length === 0) return { games: null, map: {}, corrected: new Set() };
        const map = {};
        for (const g of familyGames) {
            if (g.acquiredTime > 0) map[g.appid] = g.acquiredTime;
        }
        // 仅当存在共拥游戏（owners > 1）时才可能发生"被家人的新入库刷新"，才需要抓许可页；
        // 无家庭组数据或全为单独拥有时 rt_time_acquired 就是自己的入库时间，零额外请求
        const hasCoOwned = familyGames.some(g => (g.owners || []).length > 1);
        let corrected = new Set();
        if (hasCoOwned) {
            const licenseMap = await fetchPersonalLicenseMap();
            const corrections = licenseCorrectionsFor(familyGames, licenseMap || {});
            for (const appid in corrections) {
                map[appid] = corrections[appid];
                corrected.add(Number(appid));
            }
            if (corrected.size > 0) console.log(`[SGLV] 个人入库时间校准：${corrected.size} 款共拥游戏已按个人许可页日期修正`);
        }
        // v2.11.43: 我拥有但家人后买的共拥游戏（非末位拥有者）且无许可页日期 → rt_time_acquired
        // 是家人的购买时间，从"我的入库"时间映射中移除（热力图/频率/趋势/排序不再按家人的购买日期
        // 计数）。仅影响"本人拥有"的游戏；家人独有的共享游戏保留家庭组时间——热力图/趋势在开启
        // "显示家庭共享"时本就统计它们，不受此清理影响
        const mySid = String(getActiveSteamId() || '').trim();
        if (mySid && hasCoOwned) {
            let dropped = 0;
            for (const g of familyGames) {
                const owners = g.owners || [];
                if (owners.length < 2) continue;
                const mine = owners.some(o => String(o).trim() === mySid);
                const lastIsMe = String(owners[owners.length - 1]).trim() === mySid;
                if (mine && !lastIsMe && !corrected.has(g.appid)) {
                    if (map[g.appid] !== undefined) { delete map[g.appid]; dropped++; }
                }
            }
            if (dropped > 0) console.log(`[SGLV] 个人入库动态：${dropped} 款家人购买的共拥游戏已排除（无本人购买时间）`);
        }
        return { games: familyGames, map, corrected };
    }

    // v2.8.1: onProgress(stage, percent, text) 进度回调，UI 可选接入避免"界面不动"
    // v2.9.48: 增量更新——缓存有效时先返回缓存数据，后台静默拉取最新记录合并（不清空已有数据）
    async function fetchTimelineFamilyGames(onProgress) {
        const report = (stage, percent, text) => { if (typeof onProgress === 'function') onProgress(stage, percent, text); };

        // v2.9.48: 缓存有效期内直接返回，不做增量更新（10 分钟 TTL）
        if (_timelineFamilyGamesCache && Date.now() - _timelineFamilyGamesCache.ts < 10 * 60 * 1000) {
            report(4, 100, `已从缓存载入 ${_timelineFamilyGamesCache.games.length} 款家庭组游戏`);
            return _timelineFamilyGamesCache.games;
        }

        // v2.9.48: 缓存已过期但仍有数据——先返回旧数据（秒开），后台增量拉取最新记录
        const hasStaleCache = _timelineFamilyGamesCache && _timelineFamilyGamesCache.games.length > 0;
        if (hasStaleCache) {
            // 立即返回旧数据，UI 秒开
            report(4, 100, `已从缓存载入 ${_timelineFamilyGamesCache.games.length} 款家庭组游戏`);
            // 后台静默增量更新（不阻塞 UI）
            _refreshTimelineCacheInBackground();
            return _timelineFamilyGamesCache.games;
        }

        // 无缓存——首次加载，走完整流程
        try {
            report(1, 8, '正在准备访问令牌…');
            const authToken = await getAccessToken();
            if (authToken) {
                const games = await fetchFamilyGameList(authToken, (stage, percent, text) => {
                    const mapped = 10 + percent * 0.9;
                    report(Math.min(4, stage + 1), Math.min(99, mapped), text);
                });
                if (games && games.length > 0) {
                    const appidSet = new Set(games.map(g => g.appid));
                    _timelineFamilyGamesCache = { games, ts: Date.now(), appidSet };
                    report(4, 100, `已获取 ${games.length} 款家庭组共享游戏`);
                    return games;
                }
            }
        } catch (e) { console.warn('[SGLV] 动态页家庭组数据获取失败:', e); }
        const fb = (state.ownedGames && state.ownedGames.length > 0) ? state.ownedGames : null;
        report(4, 100, fb ? `已使用本地游戏库（${fb.length} 款）作为回退` : '家庭组数据不可用');
        return fb;
    }

    // v2.9.48: 后台增量刷新——拉取家庭组数据，与缓存合并（只新增不删除），更新时间戳
    async function _refreshTimelineCacheInBackground() {
        try {
            const authToken = await getAccessToken();
            if (!authToken) return;
            const freshGames = await fetchFamilyGameList(authToken);
            if (!freshGames || freshGames.length === 0) return;

            const oldCache = _timelineFamilyGamesCache;
            if (!oldCache) {
                const appidSet = new Set(freshGames.map(g => g.appid));
                _timelineFamilyGamesCache = { games: freshGames, ts: Date.now(), appidSet };
                return;
            }

            // 增量合并：新数据中 appid 不在旧缓存中的才新增（保留已有数据不清空）
            const oldSet = oldCache.appidSet || new Set(oldCache.games.map(g => g.appid));
            const newGames = freshGames.filter(g => !oldSet.has(g.appid));
            if (newGames.length > 0) {
                // 更新旧缓存中已有游戏的数据（acquiredTime 可能更新）
                const freshMap = new Map(freshGames.map(g => [g.appid, g]));
                const mergedGames = oldCache.games.map(g => {
                    const fresh = freshMap.get(g.appid);
                    return fresh ? { ...g, ...fresh } : g;
                });
                // 追加新游戏
                mergedGames.push(...newGames);
                const mergedSet = new Set(mergedGames.map(g => g.appid));
                _timelineFamilyGamesCache = { games: mergedGames, ts: Date.now(), appidSet: mergedSet };
                console.log(`[SGLV] 时间线增量更新：新增 ${newGames.length} 款，总计 ${mergedGames.length} 款`);
            } else {
                // 无新增，仅更新时间戳
                _timelineFamilyGamesCache.ts = Date.now();
            }
        } catch (e) {
            console.warn('[SGLV] 时间线后台增量刷新失败:', e);
            // 失败时仍更新时间戳，避免频繁重试
            if (_timelineFamilyGamesCache) _timelineFamilyGamesCache.ts = Date.now();
        }
    }

    // v2.3.15: 个人入库动态（优先使用已缓存的 state.ownedGames，不判断"显示家庭共享"开关，直接显示所有个人入库动态）
    async function buildPersonalTimeline(steamId) {
        // v2.3.24: 统一走动态页专用数据源（始终含完整家庭组 acquiredTime），与"显示家庭共享"开关无关
        // v2.11.42: 入库时间经个人许可页校准——家人新入库自己已拥有的游戏会刷新 rt_time_acquired，
        // 个人入库动态须用自己的许可页日期，否则旧游戏会被当成家人入库当天的"我的购买"展示
        const { games: familyGames, map: acquiredMap, corrected } = await buildCalibratedAcquiredMap();
        if (!familyGames || familyGames.length === 0) return null;
        const mySteamId = String(steamId || getActiveSteamId() || '').trim();
        const items = [];
        for (const g of familyGames) {
            const acquired = acquiredMap[g.appid] || 0;
            if (!acquired) continue; // v2.3.15: 跳过无入库时间的游戏，避免显示无效条目
            // 个人入库：owners 包含 mySteamId，或 owners 为空（视为个人拥有）
            const owners = g.owners || [];
            if (mySteamId && owners.length > 0 && !owners.some(sid => String(sid).trim() === mySteamId)) continue;
            // v2.11.43: 家人后买的共拥游戏，rt_time_acquired 是家人的购买时间（owner_steamids
            // 末位=购买者）——不是我的购买事件：有个人许可页日期则展示我的真实购买日期
            // （corrected），否则不出现在我的个人入库动态（宁缺毋错）
            if (!isMyAcquisitionEvent(g, mySteamId) && !corrected.has(g.appid)) continue;
            const ts = acquired * 1000;
            const dateStr = new Date(ts).toLocaleDateString('zh-CN', { year: 'numeric', month: '2-digit', day: '2-digit' });
            items.push({
                appid: g.appid,
                name: g.name || `App ${g.appid}`,
                ts,
                dateStr,
                icon: g.icon || '',
                playtime: g.playtime || 0,
                // v2.11.42: 许可页校准的条目仅日级精度（本地零点），渲染时不显示伪 HH:MM 时刻
                licenseCorrected: corrected.has(g.appid),
            });
        }
        items.sort((a, b) => (b.ts || 0) - (a.ts || 0));
        return { items, total: items.length, corrected: corrected.size };
    }

    // v2.3.15: 家庭组入库动态（优先使用已缓存的 state.ownedGames，不判断"显示家庭共享"开关，直接显示所有入库动态）
    // v2.8.1: onProgress(stage, percent, text) 进度回调，UI 可选接入避免"界面不动"
    // 同时把循环拆成异步 yield，避免处理 1k+ 款游戏时阻塞主线程
    async function buildFamilyTimeline(steamId, onProgress) {
        const report = (stage, percent, text) => { if (typeof onProgress === 'function') onProgress(stage, percent, text); };
        // v2.3.24: 统一走动态页专用数据源（始终含完整家庭组 acquiredTime），与"显示家庭共享"开关无关
        // 阶段 1-4：token → 家庭组信息 → 共享库 → 整理（在 fetchTimelineFamilyGames 内部完成）
        const familyGames = await fetchTimelineFamilyGames((stage, percent, text) => {
            report(stage, percent, text);
        });
        if (!familyGames || familyGames.length === 0) return null;

        // v2.11.43: 购买者归属——owner_steamids 末位=最新入库者（参考 steam-family-game-analysis
        // 购买动态表的购买者列）。名称映射优先取已缓存的家庭组信息，缺失时拉取一次并持久化。
        let nameMap = (storage.getFamilyInfo() || {}).steamIdtoName || null;
        if (!nameMap) {
            try {
                const token = await getAccessToken();
                if (token) {
                    const fi = await fetchFamilyInfo(token);
                    if (fi) { storage.setFamilyInfo(fi); nameMap = fi.steamIdtoName || {}; }
                }
            } catch (e) { console.warn('[SGLV] 家庭组成员名称获取失败（购买者显示降级为仅时间）:', e); }
        }
        nameMap = nameMap || {};

        // 阶段 4：分批整理游戏数据，避免长任务阻塞渲染
        const items = [];
        const total = familyGames.length;
        const BATCH = 200;             // 每批 200 条，配合 requestAnimationFrame 让出主线程
        const yieldFrame = () => new Promise(r => requestAnimationFrame(() => r()));
        for (let i = 0; i < total; i++) {
            const g = familyGames[i];
            const acquired = g.acquiredTime || 0;
            if (acquired) {
                const ts = acquired * 1000;
                const dateStr = new Date(ts).toLocaleDateString('zh-CN', { year: 'numeric', month: '2-digit', day: '2-digit' });
                const owners = g.owners || [];
                items.push({
                    appid: g.appid,
                    name: g.name || `App ${g.appid}`,
                    ts,
                    dateStr,
                    icon: g.icon || '',
                    playtime: g.playtime || 0,
                    owners,
                    // v2.11.43: 购买者=owner_steamids 末位（最新入库者），名称缺失时留空仅显示时间
                    purchaserName: owners.length ? String(nameMap[owners[owners.length - 1]] || '').trim() : '',
                });
            }
            // 每批结束让出一次主线程（数据量大时保持 UI 响应）
            if ((i + 1) % BATCH === 0 && i + 1 < total) {
                const pct = 50 + Math.round((i + 1) / total * 45);
                report(4, pct, `已整理 ${i + 1} / ${total} 款游戏…`);
                await yieldFrame();
            }
        }
        items.sort((a, b) => (b.ts || 0) - (a.ts || 0));
        report(4, 100, `整理完成：共 ${items.length} 条入库记录`);
        return { items, total: items.length };
    }

    // ==================== 游戏收藏模块（v2.7.1：@require 外部库） ====================
    // 供应商分类 / 绝版收藏 / PS会免 三个模块已拆分至独立 Greasyfork 库 sglv-game-collection。
    // 主脚本经 CollectionHost 桥提供数据/工具/i18n，库经 init(ctx) 握手后独立运行收藏浮窗。
    // 库未加载时（网络失败/TM缓存损坏），二级菜单项置灰提示，主浮窗功能不受影响。
    // 桥接契约：宿主需 @grant GM_xmlhttpRequest/GM_getValue/GM_setValue，
    //          并 @connect fastly.jsdelivr.net（PS会免数据）与 store.playstation.com（PS独占中文名）。

    const CollectionHost = {
        apiVersion: 1,
        // ---- 库存数据访问（只读，尊重家庭组开关） ----
        getOwnedGames: () => state.ownedGames,
        getActiveOwnedAppIds,
        isGameOwnedByMe,
        getGameOwnerNames,
        getShowFamilyShared: () => storage.getShowFamilyShared(),
        // ---- 收藏数据源（@resource 声明保留在主脚本 metadata） ----
        // v2.9.27: 供应商（GAME_DB）与系列（seriesDb）分离提供，不再合并
        // v2.9.91: getGameDb 优先返回远程覆盖版本（如有）
        getGameDb: () => supplierDbOverride || GAME_DB,
        getSeriesDb: () => seriesDb,
        // v2.9.90: 暴露 loadSeriesData 供收藏浮窗调用强制刷新
        loadSeriesData,
        // v2.9.91: 暴露 loadSupplierData + getSupplierFetchedAt 供收藏浮窗调用
        loadSupplierData,
        getSupplierFetchedAt: () => supplierFetchedAt,
        getDelistedDb: () => DELISTED_DB,
        getResourceText: (name) => { try { return GM_getResourceText(name); } catch (e) { return null; } },
        // ---- 通用工具 ----
        fetchGameZhName,
        loadGameZhName,
        coverChainUrls,
        posterImg,
        capsuleImg,
        getGameIconUrl,
        getPosterGood,
        fetchCoverApiUrl: _fetchCoverApiUrl,
        renderPagination,
        paginate,
        showToast,
        wlEscape,
        escHtml,
        h,
        formatLastPlayedShort,
        cacheKey,
        getCached,
        // ---- TTL 缓存 ----
        cacheGet,
        cacheSet,
        cacheDelete,
        cacheTTL: CACHE_TTL,
        // ---- i18n / 图标 ----
        T,
        ICONS,
        isZh,
        // ---- v2.9.12: 锁区游戏数据访问（供收藏模块调用） ----
        loadBlockedApps,
        isBlockedApp,
        isBlockedLoaded: () => state.blockedLoaded,
        getBlockedApps: () => state.blockedApps,
        getBlockedSource: () => state.blockedSource,
        // v2.9.90: 暴露 fetchedAt 供收藏浮窗显示数据更新时间（延迟查找，因 SGLV_API.getBlockedFetchedAt 在锁区IIFE中赋值）
        getBlockedFetchedAt: () => (typeof SGLV_API.getBlockedFetchedAt === 'function') ? SGLV_API.getBlockedFetchedAt() : '',
        parseManualBlockedJson,
        // ---- v2.9.32: DLC 收集数据访问（供收藏模块调用，闭包直达无需 SGLV_API 中转） ----
        // v1.9.2: loadDlcDatabaseFromCacheSync 暴露给收藏模块——冷启动时同步预热 dlcDbData / appTypeMap 闭包,
        //         避免 collection 库每次 await 异步加载导致"假卡死"
        isDlc,
        isDlcDbReady: () => !!(dlcDbData || appTypeMap),
        loadDlcDatabase,
        loadDlcDatabaseFromCacheSync,  // v1.9.2: 新增,同步读 GM 缓存填充闭包
        enrichOwnedAppTypes,
        enrichDlcTypes,
        getDlcType,
        getBundleCount,
        getDlcParent: (dlcAppId) => {
            const e = dlcDbData && dlcDbData[String(dlcAppId)];
            return e ? e.base_appID : null;
        },
        // v2.9.32: 构建 父游戏 appID → 全部 DLC 数 反向映射（用于 DLC 收集完成度计算）
        getParentDlcTotalMap: () => {
            const map = {};
            if (dlcDbData) {
                for (const info of Object.values(dlcDbData)) {
                    if (info && info.base_appID) {
                        map[info.base_appID] = (map[info.base_appID] || 0) + 1;
                    }
                }
            }
            console.log(`[SGLV-DLC] getParentDlcTotalMap — 构建 ${Object.keys(map).length} 个父游戏的 DLC 总数映射 (dlcDbData=${dlcDbData ? Object.keys(dlcDbData).length + '条' : 'null'})`);
            return map;
        },
        // v2.9.46: 构建 父游戏 appID → [dlcAppId, ...] 反向映射（用于 DLC 收藏全量加载）
        getDlcsByParentMap: () => {
            if (_dlcsByParentCache) return _dlcsByParentCache;
            const map = {};
            if (dlcDbData) {
                for (const [dlcAppId, info] of Object.entries(dlcDbData)) {
                    if (info && info.base_appID) {
                        const key = String(info.base_appID);
                        if (!map[key]) map[key] = [];
                        map[key].push(Number(dlcAppId));
                    }
                }
            }
            _dlcsByParentCache = map;
            console.log(`[SGLV-DLC] getDlcsByParentMap — 构建 ${Object.keys(map).length} 个父游戏的 DLC 列表映射`);
            return map;
        },
    };

    // v2.7.1: 收藏模块经 @require 外部库加载，握手初始化
    let _collectionReady = false;
    if (window.SGLVCollection && typeof window.SGLVCollection.init === 'function') {
        _collectionReady = window.SGLVCollection.init(CollectionHost);
        if (!_collectionReady) {
            console.warn('[SGLV] 收藏模块握手失败 (apiVersion 不匹配)');
        }
    } else {
        console.warn('[SGLV] 收藏模块库未加载 — 收藏功能不可用 (请检查 @require 或 Tampermonkey 外部资源设置)');
    }

    // v2.9.34: 云存档模块经 @require 外部库加载，握手初始化
    let _cloudSaveReady = false;
    if (window.SGLVCloudSave && typeof window.SGLVCloudSave.init === 'function') {
        const CloudSaveHost = {
            apiVersion: 1,
            isZh,
            showToast,
            cacheGet,
            cacheSet,
            cacheDelete,
            cacheTTL: CACHE_TTL,
            storage: {
                getCloudSaveData: storage.getCloudSaveData,
                setCloudSaveData: storage.setCloudSaveData,
            },
        };
        _cloudSaveReady = window.SGLVCloudSave.init(CloudSaveHost);
        if (!_cloudSaveReady) {
            console.warn('[SGLV] 云存档模块握手失败 (apiVersion 不匹配)');
        }
    } else {
        console.warn('[SGLV] 云存档模块库未加载 — 云存档功能不可用 (请检查 @require 或 Tampermonkey 外部资源设置)');
    }

    // v2.9.79: ITAD 价格增强库初始化
    // 硬编码 Key 作为兜底 (用户未配置时使用共享额度)
    const ITAD_API_KEY_FALLBACK = '58eb2271a08c1cf60bd812d701d09d5c694f502e';
    function getEffectiveItadKey() {
        const userKey = storage.getItadApiKey();
        return userKey || ITAD_API_KEY_FALLBACK;
    }
    let _itadReady = false;
    if (window.SGLVITAD && typeof window.SGLVITAD.init === 'function') {
        window.SGLVITAD.init({ apiKey: getEffectiveItadKey() });
        _itadReady = true;
        console.log('[SGLV] ITAD 价格增强库已加载' + (storage.getItadApiKey() ? ' (用户密钥)' : ' (兜底密钥)'));
    } else {
        console.warn('[SGLV] ITAD 库未加载 — 价格增强功能不可用 (请检查 @require)');
    }

    // ==================== UI 构建 ====================
    let overlayEl, panelEl;

    function initUI() {
        // v2.11.40: 主题热切换——CSS 即时生效,已渲染的 SVG 图表/条件色需重渲染取新主题色板;
        // 设置视图打开时跳过（保存流程自身持有 DOM 引用,且设置界面随 CSS 已即时换肤）
        window.addEventListener('sglv-theme-changed', () => {
            if (panelEl && panelEl.isConnected && !state.showSettings) {
                try { renderBody(); } catch (e) { console.warn('[SGLV] 主题切换重渲染失败:', e); }
            }
        });
        // 库存展示按钮 — 插入到全局导航栏"客服"后方
        // v2.7.0: 包装为二级菜单容器，新增"游戏收藏"子菜单项
        const menuWrap = document.createElement('span');
        menuWrap.className = 'sglv-menu-wrap';

        const fab = document.createElement('a');
        fab.className = 'menuitem sglv-fab';
        fab.title = T.title;
        fab.href = 'javascript:void(0)';
        fab.textContent = T.title;
        fab.addEventListener('click', (e) => { e.preventDefault(); togglePanel(); });
        menuWrap.appendChild(fab);

        // 二级菜单：游戏收藏
        const submenu = document.createElement('div');
        submenu.className = 'sglv-submenu';
        const collectionLink = document.createElement('a');
        collectionLink.className = 'menuitem sglv-submenu-item';
        collectionLink.href = 'javascript:void(0)';
        collectionLink.textContent = isZh ? '游戏收藏' : 'Game Collection';
        collectionLink.title = isZh ? '供应商分类 / 绝版收藏 / PS会免 / Epic赠送 / 年度大作' : 'Publisher / Delisted / PS Plus / Epic Free / GotY';
        collectionLink.addEventListener('click', (e) => {
            e.preventDefault();
            // v2.11.44b: 点击链路异常可见化——此前任何运行时错误只进控制台,用户感知为"点击无反应"。
            // 握手失败(库已加载但 apiVersion 不匹配)时 Host 未注入,toggleCollection 渲染面板必然抛
            // TypeError,统一在入口兜住并给出可操作的提示(模块状态+版本号),不再依赖用户开控制台排查。
            try {
                if (!window.SGLVCollection) {
                    sglvToast.warning(isZh ? '收藏模块未加载（请检查 @require 外部库或网络）' : 'Collection module not loaded');
                    console.warn('[SGLV] 游戏收藏不可用: window.SGLVCollection 未定义(收藏库 @require 加载失败?) 主脚本 v' + _v);
                    return;
                }
                if (!_collectionReady) {
                    sglvToast.warning(isZh ? '收藏模块握手失败（版本不兼容，请更新主脚本与收藏库）' : 'Collection module handshake failed');
                    console.warn('[SGLV] 游戏收藏不可用: init 握手失败(apiVersion 不匹配) 主脚本 v' + _v, 'lib apiVersion=', SGLVCollection.apiVersion);
                    return;
                }
                if (typeof SGLVCollection.toggleCollection !== 'function') {
                    sglvToast.warning(isZh ? '收藏模块接口异常' : 'Collection module interface error');
                    console.warn('[SGLV] 游戏收藏不可用: SGLVCollection.toggleCollection 非函数', SGLVCollection);
                    return;
                }
                SGLVCollection.toggleCollection();
            } catch (err) {
                console.error('[SGLV] 游戏收藏菜单点击失败(主脚本 v' + _v + '):', err);
                sglvToast.error(isZh ? '收藏模块异常，详见控制台' : 'Collection error, see console');
            }
        });
        submenu.appendChild(collectionLink);
        menuWrap.appendChild(submenu);

        const supernav = document.querySelector('.supernav_container');
        if (supernav) {
            // 定位"客服"链接（help.steampowered.com），在其后方插入
            const helpLink = supernav.querySelector('a.menuitem[href*="help.steampowered.com"]')
                || Array.from(supernav.querySelectorAll('a.menuitem')).pop();
            if (helpLink) helpLink.after(menuWrap);
            else supernav.appendChild(menuWrap);
        } else {
            // v2.9.109: supernav_container 不存在时(React新布局/社区页)降级为浮动按钮
            menuWrap.style.cssText = 'position:fixed;top:14px;right:160px;z-index:9999;display:flex;align-items:center;gap:4px;';
            document.body.appendChild(menuWrap);
        }

        // 遮罩层
        overlayEl = document.createElement('div');
        overlayEl.className = 'sglv-overlay';
        overlayEl.addEventListener('click', closePanel);
        document.body.appendChild(overlayEl);

        // 主面板
        panelEl = document.createElement('div');
        panelEl.className = 'sglv-panel';
        // v2.9.22: 页头紧凑化——移除"游戏库"标题，保留最左侧 Steam 图标作为品牌标识，tabs 移入 header 内部（参考 steam-friend-manager 1.2.5 sfd-tab-bar 风格）
        // v2.9.51: tab 菜单紧凑化 + 愿望单 tab 右侧加入全局搜索框（中文/拼音缩写/英文子串匹配）
        panelEl.innerHTML = `
            <div class="sglv-header">
                <div class="sglv-header-brand" title="Steam 游戏库"><img src="https://steamcommunity.com/favicon.ico" alt="Steam" onerror="this.replaceWith(document.createTextNode('🎮'))"></div>
                <div class="sglv-tab-bar">
                    <button class="sglv-tab sglv-tab-btn active" data-tab="owned">${ICONS.package}<span>${T.tabOwned}</span></button>
                    <button class="sglv-tab sglv-tab-btn" data-tab="showcase">${ICONS.showcase}<span>${T.tabShowcase}</span></button>
                    <button class="sglv-tab sglv-tab-btn" data-tab="playtime">${ICONS.barChart}<span>${T.tabPlaytime}</span></button>
                    <button class="sglv-tab sglv-tab-btn" data-tab="trend">${ICONS.trend}<span>${T.tabTrend}</span></button>
                    <button class="sglv-tab sglv-tab-btn" data-tab="playdata">${ICONS.list}<span>${T.tabPlaydata}</span></button>
                    <button class="sglv-tab sglv-tab-btn" data-tab="achievements">${ICONS.achievement}<span>${T.tabAchievements}</span></button>
                    <button class="sglv-tab sglv-tab-btn" data-tab="cloudsave">${ICONS.cloud}<span>${T.tabCloudSave}</span></button>
                    <button class="sglv-tab sglv-tab-btn" data-tab="wishlist">${ICONS.heart}<span>${T.tabWishlist}</span></button>
                    <div class="sglv-global-search" id="sglv-global-search">
                        <span class="sglv-global-search-icon">${ICONS.search}</span>
                        <input type="text" id="sglv-global-search-input" placeholder="${T.globalSearchPh}" autocomplete="off" spellcheck="false" maxlength="64">
                        <button class="sglv-global-search-clear" id="sglv-global-search-clear" title="${isZh ? '清除' : 'Clear'}">${ICONS.close}</button>
                        <div class="sglv-global-search-pop" id="sglv-global-search-pop"></div>
                    </div>
                </div>
                <div class="sglv-header-actions">
                    <button class="sglv-header-btn sglv-refresh-btn" id="sglv-refresh-btn" title="${T.refreshBtnTitle}">${ICONS.refresh}</button>
                    <button class="sglv-header-btn sglv-export-csv-btn" title="导出 CSV">CSV</button>
                    <button class="sglv-header-btn sglv-export-json-btn" title="导出 JSON">JSON</button>
                    <button class="sglv-header-btn sglv-collection-btn" title="${isZh ? '游戏收藏' : 'Game Collection'}">${ICONS.heart}</button>
                    <button class="sglv-header-btn sglv-settings-btn" title="${T.tabSettings}">${ICONS.settings}</button>
                    <button class="sglv-header-btn sglv-close-btn" title="✕">${ICONS.close}</button>
                </div>
            </div>
            <div class="sglv-body" id="sglv-body"></div>
            <div class="sglv-detail-overlay" id="sglv-detail-overlay"></div>
            <div class="sglv-detail-pop" id="sglv-detail-pop"></div>
        `;
        document.body.appendChild(panelEl);
        // v2.9.22: header 整行作为拖动手柄（参考 steam-friend-manager 1.2.5 makeDraggable）
        makeDraggable(panelEl, panelEl.querySelector('.sglv-header'));

        // 事件绑定
        panelEl.querySelector('.sglv-close-btn').addEventListener('click', closePanel);
        panelEl.querySelector('.sglv-refresh-btn').addEventListener('click', () => startFetch(true));
        panelEl.querySelector('.sglv-settings-btn').addEventListener('click', () => {
            // v2.9.28: 设置已集成进主面板——再点一次可退出设置视图
            if (state.showSettings) closeGlobalSettings();
            else openGlobalSettings();
        });
        // v2.9.27: 心型按钮 → 打开游戏收藏浮窗
        // v2.11.44b: 同子菜单项——握手/异常可见化(见 collectionLink 点击处注释)
        panelEl.querySelector('.sglv-collection-btn').addEventListener('click', () => {
            try {
                if (!window.SGLVCollection || !_collectionReady || typeof SGLVCollection.openCollection !== 'function') {
                    showToast(isZh ? '收藏模块未加载或版本不兼容' : 'Collection module not loaded or incompatible');
                    console.warn('[SGLV] 游戏收藏不可用(心型按钮): SGLVCollection=', window.SGLVCollection, 'ready=', _collectionReady, '主脚本 v' + _v);
                    return;
                }
                SGLVCollection.openCollection();
            } catch (err) {
                console.error('[SGLV] 游戏收藏打开失败(心型按钮, 主脚本 v' + _v + '):', err);
                showToast(isZh ? '收藏模块异常，详见控制台' : 'Collection error, see console');
            }
        });
        
        panelEl.querySelector('.sglv-export-csv-btn').addEventListener('click', exportCSV);
        panelEl.querySelector('.sglv-export-json-btn').addEventListener('click', exportJSON);

        panelEl.querySelectorAll('.sglv-tab').forEach(tab => {
            tab.addEventListener('click', () => {
                // v2.9.56: 统一使用 switchToTab
                switchToTab(tab.dataset.tab);
            });
        });

        // v2.9.51: 绑定全局游戏搜索框事件（输入防抖/键盘导航/外部点击关闭/清除按钮）
        bindGlobalSearchEvents();
        // v2.9.51: 首次绑定时也构建一次搜索索引（已有缓存的情况下,UI 即可用）
        if (!_searchIndexBuilt) {
            try { buildSearchIndex(); } catch (e) { console.warn('[SGLV] 搜索索引预构建失败:', e); }
        }

        // v2.3.27: 供侧边栏 KPI 卡片跨模块打开游戏库浮窗
        // v2.9.49: 注册到 addDisposer 确保卸载时清理，避免内存泄漏
        const _onOpenLibrary = () => { openPanel(); };
        document.addEventListener('sglv:open-library', _onOpenLibrary);
        addDisposer(() => document.removeEventListener('sglv:open-library', _onOpenLibrary));

        // v2.9.38: 监听 SGIS 侧边栏触发的事件, 支持跳转指定 tab
        const _onOpenModal = (e) => {
            openPanel();
            const targetTab = e?.detail?.tab;
            if (targetTab) {
                // v2.9.56: 统一使用 switchToTab (内含 DOM 存在性检查)
                const tabBtn = panelEl.querySelector(`.sglv-tab[data-tab="${targetTab}"]`);
                if (tabBtn) switchToTab(targetTab);
            }
        };
        document.addEventListener('sglv:open-modal', _onOpenModal);
        addDisposer(() => document.removeEventListener('sglv:open-modal', _onOpenModal));

        // 加载缓存（GM_getValue 同步读取，体积小，不阻塞绘制）
        const cached = storage.getCachedGames();
        if (cached.length) {
            cached.sort((a, b) => a.name.localeCompare(b.name));
            state.ownedGames = cached;
            state.ownedAppIds = new Set(cached.map(g => g.appid));
            markSearchIndexDirty(); // v2.9.51: 缓存恢复,索引需要重建
            // v2.9.50: 同步从 PCC IDB 预热已计算的 KPI 结果到 _computedCache
            // 旧逻辑 clearComputedCache 把所有缓存清空,下次开面板全量重算(每次)
            // 新逻辑 hydrateComputedCache 把已持久化的计算结果(年度统计/家庭组/insight 等)从 IDB 同步填充
            //         启动时 IDB.loadAll 已完成,内存镜像 _mem 可用
            hydrateComputedCache();
        } else {
            // 首次使用/无缓存:确保缓存清空
            clearComputedCache();
        }

        // v2.9.5: 首次使用检测——无 API Key 且无缓存游戏时给出引导
        const _isFirstUse = !storage.getApiKey() && state.ownedGames.length === 0;

        // v2.9.5: DLC 数据库同步预加载延迟到下一事件循环，确保菜单入口优先渲染
        // DLC 缓存体积较大（数万条），同步 JSON.parse 会阻塞浏览器首次绘制
        setTimeout(() => {
            loadDlcDatabaseFromCacheSync();
            loadDlcDatabase();
            // v2.9.27: 异步加载游戏系列数据（game_series.json），合并到系列分类数据库
            // v2.9.104: 同时拉取 steam_vediogame_selected.json，作为"互动影游"系列并入同一管线
            loadSeriesData();
            // v2.9.91: 异步加载供应商数据远程版本检查（覆盖 @resource GAME_DB）
            loadSupplierData();

            // v2.9.28: 首次未配置 API Key 不再自动弹出面板/设置，改为右下角引导提示卡片，
            // 由用户主动点击"打开设置"进入设置视图，避免打断浏览体验
            if (_isFirstUse) {
                showApiKeyGuideToast();
            }
        }, 0);
    }

    function togglePanel() {
        if (panelEl.classList.contains('sglv-show')) closePanel();
        else openPanel();
    }

    function openPanel() {
        panelEl.classList.add('sglv-show');
        overlayEl.classList.add('sglv-show');
        // v2.9.109: renderBody 包裹 try-catch，渲染失败不阻断面板打开
        try { renderBody(); } catch (e) { console.error('[SGLV] 面板渲染失败:', e); }
        // v2.9.99: 展柜预热 — 面板打开时后台预取展柜数据，用户点击展柜标签时即可秒开
        try { _preheatShowcase(); } catch (e) { /* ignore */ }
    }

    // v2.9.99: 展柜预热 — 在后台静默预取展柜数据并写入持久化缓存
    // 不阻塞当前标签页渲染，仅在后台完成数据获取
    function _preheatShowcase() {
        if (state.showcasePreheating || state.showcasePreheated) return;
        if (state.ownedGames.length === 0) return; // 无游戏库数据时不预热
        state.showcasePreheating = true;

        // 异步预取，不阻塞 UI
        (async () => {
            try {
                const configHash = _computeShowcaseCacheHash();
                // 先检查持久化缓存是否仍然有效
                const swr = _swrReadShowcaseCache(configHash);
                if (swr.data && !swr.stale && !swr.configChanged) {
                    // 缓存有效，跳过预取，仅恢复内存缓存
                    if (!state.showcaseProfile && swr.data.profile) {
                        state.showcaseProfile = swr.data.profile;
                        state.showcaseProfileAt = swr.timestamp || 0;
                    }
                    state.showcasePreheating = false;
                    state.showcasePreheated = true;
                    return;
                }
                // v2.9.103: 与标签页渲染共享 in-flight 抓取,避免重复网络请求
                const data = await _fetchShowcaseDataAll();
                _writeShowcaseCache({ ...data, achievements: _showcaseUnlockedOnly(data.achievements) }, configHash);
                state.showcasePreheating = false;
                state.showcasePreheated = true;
            } catch {
                // v2.9.103: 失败仅复位 preheating,允许下次 openPanel 重试预热
                // (旧实现失败后置 preheated=true,本 session 内永久跳过预热)
                state.showcasePreheating = false;
            }
        })();
    }

    // v2.9.103: 展柜数据 in-flight Promise 共享 — 预热与标签页渲染复用同一次抓取
    // (Profile/成就/最近游玩/徽章),并发进入时只发一轮网络请求;结算后清空槽位允许重试
    let _showcaseFetchInflight = null;
    function _fetchShowcaseDataAll() {
        if (_showcaseFetchInflight) return _showcaseFetchInflight;
        const p = (async () => {
            const [profile, achievements, recentGames, allBadges] = await Promise.all([
                _fetchShowcaseProfile(),
                Promise.resolve(computeMyAchievementsCached()),
                _fetchRecentPlayedGames(),
                _getShowcaseBadges().catch(() => []),
            ]);
            const allGames = getStatFilteredGames();
            const gameCount = allGames.length;
            const totalPlaytimeMin = allGames.reduce((s, g) => s + (g.playtime || 0), 0);
            const totalHours = Math.floor(totalPlaytimeMin / 60);
            const unlockedAchs = (achievements || []).filter(a => a.unlocked);
            const stats = {
                gameCount,
                totalHours,
                achCount: unlockedAchs.length,
                totalAchPts: unlockedAchs.reduce((s, a) => s + a.pts, 0),
                steamBadgeCount: (allBadges && allBadges.length) || profile.badgeCount || 0,
            };
            return { profile, recentGames, badges: allBadges, achievements, stats };
        })();
        _showcaseFetchInflight = p.then(
            data => { _showcaseFetchInflight = null; return data; },
            err => { _showcaseFetchInflight = null; throw err; }
        );
        return _showcaseFetchInflight;
    }

    function closePanel() {
        panelEl.classList.remove('sglv-show');
        overlayEl.classList.remove('sglv-show');
        // v2.9.64: 清理搜索/详情浮窗状态,防止面板重开后浮窗残留 + 监听器泄漏 + 防抖 timer 泄漏
        closeDetailPopup();           // 关闭详情浮窗 + 移除 _detailEscHandler + 递增 _detailToken 使在途请求失效
        closeSearchPop();              // 关闭搜索下拉 + 重置聚焦索引
        _gsDebouncedRender.cancel();   // 取消 pending 防抖 timer
        if (_gsInputEl) _gsInputEl.value = '';  // 清空搜索框
        _gsLastResults = [];
    }

    // v2.9.22: 允许拖动面板（参考 steam-friend-manager 1.2.5 makeDraggable）
    // 用 !important 覆盖 shared CSS 中 sglv-panel 的 top/left 定位，
    // 否则拖动后内联 top 会被样式表压制，导致窗口只能左右移动、无法上下移动。
    function makeDraggable(el, handle) {
        if (!el || !handle) return;
        let isDragging = false, startX = 0, startY = 0, startLeft = 0, startTop = 0;
        const onDown = (e) => {
            // 忽略按钮 / 链接 / 输入控件 / label 上的 mousedown，避免与 tab/操作按钮冲突
            const t = e.target;
            if (t.closest('button, input, select, textarea, label, a')) return;
            isDragging = true;
            startX = e.clientX; startY = e.clientY;
            const rect = el.getBoundingClientRect();
            startLeft = rect.left; startTop = rect.top;
            el.style.cursor = 'grabbing';
            e.preventDefault();
        };
        const onMove = (e) => {
            if (!isDragging) return;
            el.style.setProperty('left', (startLeft + e.clientX - startX) + 'px', 'important');
            el.style.setProperty('top', (startTop + e.clientY - startY) + 'px', 'important');
            el.style.setProperty('right', 'auto', 'important');
            el.style.setProperty('bottom', 'auto', 'important');
            el.style.setProperty('transform', 'none', 'important');
        };
        const onUp = () => {
            if (!isDragging) return;
            isDragging = false;
            el.style.cursor = '';
        };
        handle.addEventListener('mousedown', onDown);
        document.addEventListener('mousemove', onMove);
        document.addEventListener('mouseup', onUp);
        addDisposer(() => {
            handle.removeEventListener('mousedown', onDown);
            document.removeEventListener('mousemove', onMove);
            document.removeEventListener('mouseup', onUp);
        });
    }

    // ==================== v2.9.38: 我的成就 — 全新质感炫彩 SVG 图标库 ====================
    // 设计规范：80x80 viewBox · 圆形徽章风格 · 四层结构 (背景环 + 主渐变填充 + 内层高光 + 中央图标)
    // 共享滤镜 ID 命名约定: ach-{key}-shadow / ach-{key}-main / ach-{key}-shine / ach-{key}-rim
    const _ACH_ICONS = {
        // ===== 收藏家 — 紫色宝石盒 (紫蓝渐变) =====
        collector: `<svg viewBox="0 0 80 80" xmlns="http://www.w3.org/2000/svg"><defs><radialGradient id="ach-coll-bg" cx="0.5" cy="0.5" r="0.55"><stop offset="0" stop-color="#1e1b4b" stop-opacity="0"/><stop offset="1" stop-color="#0f0a2e" stop-opacity="0.6"/></radialGradient><linearGradient id="ach-coll-main" x1="0" y1="0" x2="1" y2="1"><stop offset="0" stop-color="#c4b5fd"/><stop offset="0.4" stop-color="#8b5cf6"/><stop offset="0.8" stop-color="#5b21b6"/><stop offset="1" stop-color="#3b0764"/></linearGradient><radialGradient id="ach-coll-shine" cx="0.3" cy="0.25" r="0.5"><stop offset="0" stop-color="#fff" stop-opacity="0.7"/><stop offset="0.5" stop-color="#e9d5ff" stop-opacity="0.2"/><stop offset="1" stop-color="#a78bfa" stop-opacity="0"/></radialGradient><linearGradient id="ach-coll-rim" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#fff" stop-opacity="0.6"/><stop offset="0.5" stop-color="#fff" stop-opacity="0.15"/><stop offset="1" stop-color="#fff" stop-opacity="0.4"/></linearGradient></defs><circle cx="40" cy="40" r="36" fill="url(#ach-coll-bg)"/><circle cx="40" cy="40" r="32" fill="url(#ach-coll-main)"/><circle cx="40" cy="40" r="32" fill="url(#ach-coll-shine)"/><circle cx="40" cy="40" r="32" fill="none" stroke="url(#ach-coll-rim)" stroke-width="1.5"/><g transform="translate(40 40)"><rect x="-18" y="-13" width="36" height="26" rx="3" fill="#fff" opacity="0.95"/><rect x="-18" y="-13" width="36" height="6" fill="#fde047" opacity="0.9"/><line x1="-3" y1="-13" x2="-3" y2="13" stroke="#f59e0b" stroke-width="3" opacity="0.85"/><path d="M-3 -16 Q-3 -21 0 -21 Q3 -21 3 -16" fill="none" stroke="#f59e0b" stroke-width="2.5" stroke-linecap="round"/><circle cx="-10" cy="-2" r="2" fill="#8b5cf6" opacity="0.8"/><circle cx="10" cy="4" r="1.5" fill="#8b5cf6" opacity="0.7"/></g><ellipse cx="40" cy="20" rx="16" ry="5" fill="#fff" opacity="0.18"/></svg>`,

        // ===== 游戏大王 — 黄金王冠 (金黄橙红渐变) =====
        kingCollector: `<svg viewBox="0 0 80 80" xmlns="http://www.w3.org/2000/svg"><defs><radialGradient id="ach-king-bg" cx="0.5" cy="0.5" r="0.55"><stop offset="0" stop-color="#451a03" stop-opacity="0"/><stop offset="1" stop-color="#1c0a01" stop-opacity="0.6"/></radialGradient><linearGradient id="ach-king-main" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#fef3c7"/><stop offset="0.3" stop-color="#fde047"/><stop offset="0.6" stop-color="#f59e0b"/><stop offset="1" stop-color="#92400e"/></linearGradient><radialGradient id="ach-king-shine" cx="0.3" cy="0.2" r="0.5"><stop offset="0" stop-color="#fff" stop-opacity="0.85"/><stop offset="0.5" stop-color="#fef3c7" stop-opacity="0.3"/><stop offset="1" stop-color="#fbbf24" stop-opacity="0"/></radialGradient><linearGradient id="ach-king-rim" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#fff" stop-opacity="0.7"/><stop offset="0.5" stop-color="#fff" stop-opacity="0.2"/><stop offset="1" stop-color="#fff" stop-opacity="0.5"/></linearGradient></defs><circle cx="40" cy="40" r="36" fill="url(#ach-king-bg)"/><circle cx="40" cy="40" r="32" fill="url(#ach-king-main)"/><circle cx="40" cy="40" r="32" fill="url(#ach-king-shine)"/><circle cx="40" cy="40" r="32" fill="none" stroke="url(#ach-king-rim)" stroke-width="1.5"/><g transform="translate(40 42)"><path d="M-22 4 L-16 -18 L-6 0 L0 -22 L6 0 L16 -18 L22 4 Z" fill="#fff" opacity="0.95"/><rect x="-22" y="4" width="44" height="8" rx="1" fill="#fff" opacity="0.95"/><circle cx="-16" cy="-18" r="3.5" fill="#ef4444" stroke="#fbbf24" stroke-width="1.5"/><circle cx="0" cy="-22" r="4" fill="#3b82f6" stroke="#fbbf24" stroke-width="1.5"/><circle cx="16" cy="-18" r="3.5" fill="#10b981" stroke="#fbbf24" stroke-width="1.5"/><rect x="-18" y="6" width="36" height="2" fill="rgba(146,64,14,0.4)"/></g><ellipse cx="40" cy="20" rx="18" ry="5" fill="#fff" opacity="0.2"/></svg>`,

        // ===== 时钟 — 青色钟表 (青蓝渐变) =====
        clock: `<svg viewBox="0 0 80 80" xmlns="http://www.w3.org/2000/svg"><defs><radialGradient id="ach-clk-bg" cx="0.5" cy="0.5" r="0.55"><stop offset="0" stop-color="#0c4a6e" stop-opacity="0"/><stop offset="1" stop-color="#082f49" stop-opacity="0.6"/></radialGradient><linearGradient id="ach-clk-main" x1="0" y1="0" x2="1" y2="1"><stop offset="0" stop-color="#67e8f9"/><stop offset="0.4" stop-color="#06b6d4"/><stop offset="0.8" stop-color="#0e7490"/><stop offset="1" stop-color="#164e63"/></linearGradient><radialGradient id="ach-clk-shine" cx="0.3" cy="0.25" r="0.5"><stop offset="0" stop-color="#fff" stop-opacity="0.7"/><stop offset="0.5" stop-color="#cffafe" stop-opacity="0.2"/><stop offset="1" stop-color="#22d3ee" stop-opacity="0"/></radialGradient><linearGradient id="ach-clk-rim" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#fff" stop-opacity="0.6"/><stop offset="0.5" stop-color="#fff" stop-opacity="0.15"/><stop offset="1" stop-color="#fff" stop-opacity="0.4"/></linearGradient></defs><circle cx="40" cy="40" r="36" fill="url(#ach-clk-bg)"/><circle cx="40" cy="40" r="32" fill="url(#ach-clk-main)"/><circle cx="40" cy="40" r="32" fill="url(#ach-clk-shine)"/><circle cx="40" cy="40" r="32" fill="none" stroke="url(#ach-clk-rim)" stroke-width="1.5"/><g transform="translate(40 44)"><circle r="20" fill="#fff" opacity="0.95"/><circle r="20" fill="none" stroke="#0e7490" stroke-width="2" opacity="0.4"/><g stroke="#0c4a6e" stroke-width="1.5" stroke-linecap="round"><line x1="0" y1="-16" x2="0" y2="-13"/><line x1="16" y1="0" x2="13" y2="0"/><line x1="0" y1="16" x2="0" y2="13"/><line x1="-16" y1="0" x2="-13" y2="0"/></g><line x1="0" y1="0" x2="0" y2="-10" stroke="#0891b2" stroke-width="3" stroke-linecap="round"/><line x1="0" y1="0" x2="7" y2="3" stroke="#0891b2" stroke-width="2.5" stroke-linecap="round"/><circle r="2.5" fill="#0e7490"/><rect x="-4" y="-26" width="8" height="6" rx="1" fill="#fff" opacity="0.9"/><rect x="-2" y="-29" width="4" height="3" fill="#fff" opacity="0.9"/></g><ellipse cx="40" cy="20" rx="14" ry="4" fill="#fff" opacity="0.18"/></svg>`,

        // ===== 沙漏 — 橙红沙漏 (橙红渐变) =====
        hourglass: `<svg viewBox="0 0 80 80" xmlns="http://www.w3.org/2000/svg"><defs><radialGradient id="ach-hg-bg" cx="0.5" cy="0.5" r="0.55"><stop offset="0" stop-color="#7c2d12" stop-opacity="0"/><stop offset="1" stop-color="#431407" stop-opacity="0.6"/></radialGradient><linearGradient id="ach-hg-main" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#fb923c"/><stop offset="0.4" stop-color="#f97316"/><stop offset="0.8" stop-color="#dc2626"/><stop offset="1" stop-color="#7f1d1d"/></linearGradient><radialGradient id="ach-hg-shine" cx="0.3" cy="0.2" r="0.5"><stop offset="0" stop-color="#fff" stop-opacity="0.7"/><stop offset="0.5" stop-color="#fed7aa" stop-opacity="0.2"/><stop offset="1" stop-color="#f97316" stop-opacity="0"/></radialGradient><linearGradient id="ach-hg-rim" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#fff" stop-opacity="0.6"/><stop offset="0.5" stop-color="#fff" stop-opacity="0.15"/><stop offset="1" stop-color="#fff" stop-opacity="0.4"/></linearGradient><linearGradient id="ach-hg-sand" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#fef08a"/><stop offset="0.5" stop-color="#fde047"/><stop offset="1" stop-color="#f59e0b"/></linearGradient></defs><circle cx="40" cy="40" r="36" fill="url(#ach-hg-bg)"/><circle cx="40" cy="40" r="32" fill="url(#ach-hg-main)"/><circle cx="40" cy="40" r="32" fill="url(#ach-hg-shine)"/><circle cx="40" cy="40" r="32" fill="none" stroke="url(#ach-hg-rim)" stroke-width="1.5"/><g transform="translate(40 40)"><rect x="-16" y="-22" width="32" height="6" rx="2" fill="#fff" opacity="0.95"/><rect x="-16" y="16" width="32" height="6" rx="2" fill="#fff" opacity="0.95"/><path d="M-14 -16 L14 -16 L8 0 Q0 6 -8 0 Z" fill="url(#ach-hg-sand)"/><path d="M-14 16 L14 16 L8 0 Q0 -6 -8 0 Z" fill="url(#ach-hg-sand)" opacity="0.85"/><path d="M-2 0 Q0 -2 2 0 Q0 2 -2 0" fill="#fde047"/><line x1="-10" y1="-14" x2="10" y2="-14" stroke="rgba(255,255,255,0.4)" stroke-width="1"/><line x1="-10" y1="14" x2="10" y2="14" stroke="rgba(255,255,255,0.4)" stroke-width="1"/></g><ellipse cx="40" cy="20" rx="14" ry="4" fill="#fff" opacity="0.18"/></svg>`,

        // ===== 完美 — 绿色圆环 (翠绿渐变) =====
        perfection: `<svg viewBox="0 0 80 80" xmlns="http://www.w3.org/2000/svg"><defs><radialGradient id="ach-perf-bg" cx="0.5" cy="0.5" r="0.55"><stop offset="0" stop-color="#064e3b" stop-opacity="0"/><stop offset="1" stop-color="#022c22" stop-opacity="0.6"/></radialGradient><linearGradient id="ach-perf-main" x1="0" y1="0" x2="1" y2="1"><stop offset="0" stop-color="#6ee7b7"/><stop offset="0.4" stop-color="#10b981"/><stop offset="0.8" stop-color="#047857"/><stop offset="1" stop-color="#064e3b"/></linearGradient><radialGradient id="ach-perf-shine" cx="0.3" cy="0.25" r="0.5"><stop offset="0" stop-color="#fff" stop-opacity="0.7"/><stop offset="0.5" stop-color="#a7f3d0" stop-opacity="0.2"/><stop offset="1" stop-color="#34d399" stop-opacity="0"/></radialGradient><linearGradient id="ach-perf-rim" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#fff" stop-opacity="0.6"/><stop offset="0.5" stop-color="#fff" stop-opacity="0.15"/><stop offset="1" stop-color="#fff" stop-opacity="0.4"/></linearGradient></defs><circle cx="40" cy="40" r="36" fill="url(#ach-perf-bg)"/><circle cx="40" cy="40" r="32" fill="url(#ach-perf-main)"/><circle cx="40" cy="40" r="32" fill="url(#ach-perf-shine)"/><circle cx="40" cy="40" r="32" fill="none" stroke="url(#ach-perf-rim)" stroke-width="1.5"/><g transform="translate(40 40)"><circle r="22" fill="none" stroke="#fff" stroke-width="1.5" stroke-dasharray="3 2.5" opacity="0.5"/><path d="M-14 0 L-4 10 L14 -8" fill="none" stroke="#fff" stroke-width="4.5" stroke-linecap="round" stroke-linejoin="round"/><circle r="3" fill="#fff" opacity="0.9"/></g><ellipse cx="40" cy="20" rx="14" ry="4" fill="#fff" opacity="0.18"/></svg>`,

        // ===== 奖杯 — 黄金奖杯 (金黄渐变) =====
        trophy: `<svg viewBox="0 0 80 80" xmlns="http://www.w3.org/2000/svg"><defs><radialGradient id="ach-tro-bg" cx="0.5" cy="0.5" r="0.55"><stop offset="0" stop-color="#451a03" stop-opacity="0"/><stop offset="1" stop-color="#1c0a01" stop-opacity="0.6"/></radialGradient><linearGradient id="ach-tro-main" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#fef9c3"/><stop offset="0.3" stop-color="#fde047"/><stop offset="0.6" stop-color="#f59e0b"/><stop offset="1" stop-color="#92400e"/></linearGradient><radialGradient id="ach-tro-shine" cx="0.3" cy="0.2" r="0.5"><stop offset="0" stop-color="#fff" stop-opacity="0.85"/><stop offset="0.5" stop-color="#fef3c7" stop-opacity="0.3"/><stop offset="1" stop-color="#fbbf24" stop-opacity="0"/></radialGradient><linearGradient id="ach-tro-rim" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#fff" stop-opacity="0.7"/><stop offset="0.5" stop-color="#fff" stop-opacity="0.2"/><stop offset="1" stop-color="#fff" stop-opacity="0.5"/></linearGradient></defs><circle cx="40" cy="40" r="36" fill="url(#ach-tro-bg)"/><circle cx="40" cy="40" r="32" fill="url(#ach-tro-main)"/><circle cx="40" cy="40" r="32" fill="url(#ach-tro-shine)"/><circle cx="40" cy="40" r="32" fill="none" stroke="url(#ach-tro-rim)" stroke-width="1.5"/><g transform="translate(40 40)"><path d="M-12 -20 L12 -20 L12 -4 Q12 8 0 8 Q-12 8 -12 -4 Z" fill="#fff" opacity="0.95"/><path d="M-12 -16 L-20 -16 L-20 -8 Q-20 0 -12 0" fill="none" stroke="#fff" stroke-width="3" stroke-linecap="round"/><path d="M12 -16 L20 -16 L20 -8 Q20 0 12 0" fill="none" stroke="#fff" stroke-width="3" stroke-linecap="round"/><rect x="-4" y="8" width="8" height="10" fill="#fff" opacity="0.95"/><rect x="-14" y="18" width="28" height="6" rx="1.5" fill="#fff" opacity="0.95"/><rect x="-12" y="20" width="24" height="2" fill="rgba(146,64,14,0.4)"/><circle cx="0" cy="-8" r="5" fill="rgba(146,64,14,0.25)"/><path d="M-4 -10 L0 -6 L4 -10" fill="none" stroke="#92400e" stroke-width="1.5" stroke-linecap="round" opacity="0.5"/></g><ellipse cx="40" cy="20" rx="16" ry="5" fill="#fff" opacity="0.2"/></svg>`,

        // ===== 火焰 — 红橙烈焰 (橙红渐变) =====
        fire: `<svg viewBox="0 0 80 80" xmlns="http://www.w3.org/2000/svg"><defs><radialGradient id="ach-fire-bg" cx="0.5" cy="0.5" r="0.55"><stop offset="0" stop-color="#7c2d12" stop-opacity="0"/><stop offset="1" stop-color="#431407" stop-opacity="0.6"/></radialGradient><linearGradient id="ach-fire-main" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#fef08a"/><stop offset="0.3" stop-color="#fbbf24"/><stop offset="0.6" stop-color="#f97316"/><stop offset="1" stop-color="#dc2626"/></linearGradient><radialGradient id="ach-fire-shine" cx="0.3" cy="0.2" r="0.5"><stop offset="0" stop-color="#fff" stop-opacity="0.7"/><stop offset="0.5" stop-color="#fed7aa" stop-opacity="0.25"/><stop offset="1" stop-color="#fb923c" stop-opacity="0"/></radialGradient><linearGradient id="ach-fire-rim" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#fff" stop-opacity="0.6"/><stop offset="0.5" stop-color="#fff" stop-opacity="0.15"/><stop offset="1" stop-color="#fff" stop-opacity="0.4"/></linearGradient></defs><circle cx="40" cy="40" r="36" fill="url(#ach-fire-bg)"/><circle cx="40" cy="40" r="32" fill="url(#ach-fire-main)"/><circle cx="40" cy="40" r="32" fill="url(#ach-fire-shine)"/><circle cx="40" cy="40" r="32" fill="none" stroke="url(#ach-fire-rim)" stroke-width="1.5"/><g transform="translate(40 42)"><path d="M0 -24 C-4 -14 -16 -10 -16 6 C-16 18 -8 26 0 28 C8 26 16 18 16 6 C16 -10 4 -14 0 -24 Z" fill="#fff" opacity="0.95"/><path d="M0 -10 C-2 -4 -8 -2 -8 6 C-8 12 -4 18 0 20 C4 18 8 12 8 6 C8 -2 2 -4 0 -10 Z" fill="#fde047" opacity="0.95"/><path d="M0 0 C-1 4 -3 5 -3 9 C-3 12 -1 15 0 16 C1 15 3 12 3 9 C3 5 1 4 0 0 Z" fill="#fff" opacity="0.8"/></g><ellipse cx="40" cy="20" rx="14" ry="4" fill="#fff" opacity="0.18"/></svg>`,

        // ===== 地球 — 青色地球 (青蓝渐变) =====
        globe: `<svg viewBox="0 0 80 80" xmlns="http://www.w3.org/2000/svg"><defs><radialGradient id="ach-glo-bg" cx="0.5" cy="0.5" r="0.55"><stop offset="0" stop-color="#0c4a6e" stop-opacity="0"/><stop offset="1" stop-color="#082f49" stop-opacity="0.6"/></radialGradient><linearGradient id="ach-glo-main" x1="0" y1="0" x2="1" y2="1"><stop offset="0" stop-color="#67e8f9"/><stop offset="0.4" stop-color="#06b6d4"/><stop offset="0.8" stop-color="#0e7490"/><stop offset="1" stop-color="#164e63"/></linearGradient><radialGradient id="ach-glo-shine" cx="0.3" cy="0.25" r="0.5"><stop offset="0" stop-color="#fff" stop-opacity="0.7"/><stop offset="0.5" stop-color="#cffafe" stop-opacity="0.2"/><stop offset="1" stop-color="#22d3ee" stop-opacity="0"/></radialGradient><linearGradient id="ach-glo-rim" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#fff" stop-opacity="0.6"/><stop offset="0.5" stop-color="#fff" stop-opacity="0.15"/><stop offset="1" stop-color="#fff" stop-opacity="0.4"/></linearGradient></defs><circle cx="40" cy="40" r="36" fill="url(#ach-glo-bg)"/><circle cx="40" cy="40" r="32" fill="url(#ach-glo-main)"/><circle cx="40" cy="40" r="32" fill="url(#ach-glo-shine)"/><circle cx="40" cy="40" r="32" fill="none" stroke="url(#ach-glo-rim)" stroke-width="1.5"/><g transform="translate(40 40)"><circle r="20" fill="#fff" opacity="0.95"/><ellipse rx="20" ry="8" fill="none" stroke="#0e7490" stroke-width="1.2" opacity="0.5"/><ellipse rx="8" ry="20" fill="none" stroke="#0e7490" stroke-width="1.2" opacity="0.5"/><line x1="-20" y1="0" x2="20" y2="0" stroke="#0e7490" stroke-width="1.2" opacity="0.5"/><line x1="0" y1="-20" x2="0" y2="20" stroke="#0e7490" stroke-width="1.2" opacity="0.5"/><path d="M-12 -10 Q-6 -14 2 -8 Q8 -2 14 -6" fill="none" stroke="#10b981" stroke-width="2" stroke-linecap="round" opacity="0.6"/><path d="M-14 4 Q-6 0 0 6 Q8 10 14 4" fill="none" stroke="#10b981" stroke-width="2" stroke-linecap="round" opacity="0.6"/><ellipse cx="-6" cy="-10" rx="3" ry="2" fill="#10b981" opacity="0.45"/><ellipse cx="8" cy="4" rx="4" ry="2.5" fill="#10b981" opacity="0.45"/></g><ellipse cx="40" cy="20" rx="14" ry="4" fill="#fff" opacity="0.18"/></svg>`,

        // ===== 朝阳 — 金黄旭日 (橙黄渐变) =====
        sunrise: `<svg viewBox="0 0 80 80" xmlns="http://www.w3.org/2000/svg"><defs><radialGradient id="ach-sun-bg" cx="0.5" cy="0.5" r="0.55"><stop offset="0" stop-color="#7c2d12" stop-opacity="0"/><stop offset="1" stop-color="#431407" stop-opacity="0.6"/></radialGradient><linearGradient id="ach-sun-main" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#fef08a"/><stop offset="0.3" stop-color="#fbbf24"/><stop offset="0.7" stop-color="#f97316"/><stop offset="1" stop-color="#dc2626"/></linearGradient><radialGradient id="ach-sun-shine" cx="0.3" cy="0.25" r="0.5"><stop offset="0" stop-color="#fff" stop-opacity="0.7"/><stop offset="0.5" stop-color="#fef3c7" stop-opacity="0.3"/><stop offset="1" stop-color="#fbbf24" stop-opacity="0"/></radialGradient><linearGradient id="ach-sun-rim" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#fff" stop-opacity="0.6"/><stop offset="0.5" stop-color="#fff" stop-opacity="0.15"/><stop offset="1" stop-color="#fff" stop-opacity="0.4"/></linearGradient></defs><circle cx="40" cy="40" r="36" fill="url(#ach-sun-bg)"/><circle cx="40" cy="40" r="32" fill="url(#ach-sun-main)"/><circle cx="40" cy="40" r="32" fill="url(#ach-sun-shine)"/><circle cx="40" cy="40" r="32" fill="none" stroke="url(#ach-sun-rim)" stroke-width="1.5"/><g transform="translate(40 40)"><line x1="0" y1="-24" x2="0" y2="-19" stroke="#fff" stroke-width="2.5" stroke-linecap="round"/><line x1="-18" y1="-12" x2="-14" y2="-9" stroke="#fff" stroke-width="2.5" stroke-linecap="round"/><line x1="18" y1="-12" x2="14" y2="-9" stroke="#fff" stroke-width="2.5" stroke-linecap="round"/><line x1="-22" y1="2" x2="-17" y2="2" stroke="#fff" stroke-width="2.5" stroke-linecap="round"/><line x1="22" y1="2" x2="17" y2="2" stroke="#fff" stroke-width="2.5" stroke-linecap="round"/><circle cx="0" cy="6" r="14" fill="#fff" opacity="0.95"/><path d="M-22 16 Q-12 14 0 14 Q12 14 22 16 L22 22 L-22 22 Z" fill="#fff" opacity="0.95"/><path d="M-22 22 L22 22 L22 24 L-22 24 Z" fill="rgba(180,83,9,0.5)"/><circle cx="-6" cy="0" r="2.5" fill="rgba(251,191,36,0.6)"/></g><ellipse cx="40" cy="20" rx="14" ry="4" fill="#fff" opacity="0.18"/></svg>`,

        // ===== 月亮 — 紫蓝夜空 (靛紫渐变) =====
        moon: `<svg viewBox="0 0 80 80" xmlns="http://www.w3.org/2000/svg"><defs><radialGradient id="ach-moon-bg" cx="0.5" cy="0.5" r="0.55"><stop offset="0" stop-color="#1e1b4b" stop-opacity="0"/><stop offset="1" stop-color="#0f0a2e" stop-opacity="0.6"/></radialGradient><linearGradient id="ach-moon-main" x1="0" y1="0" x2="1" y2="1"><stop offset="0" stop-color="#a5b4fc"/><stop offset="0.4" stop-color="#6366f1"/><stop offset="0.8" stop-color="#3730a3"/><stop offset="1" stop-color="#1e1b4b"/></linearGradient><radialGradient id="ach-moon-shine" cx="0.3" cy="0.25" r="0.5"><stop offset="0" stop-color="#fff" stop-opacity="0.5"/><stop offset="0.5" stop-color="#c7d2fe" stop-opacity="0.15"/><stop offset="1" stop-color="#6366f1" stop-opacity="0"/></radialGradient><linearGradient id="ach-moon-rim" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#fff" stop-opacity="0.6"/><stop offset="0.5" stop-color="#fff" stop-opacity="0.15"/><stop offset="1" stop-color="#fff" stop-opacity="0.4"/></linearGradient></defs><circle cx="40" cy="40" r="36" fill="url(#ach-moon-bg)"/><circle cx="40" cy="40" r="32" fill="url(#ach-moon-main)"/><circle cx="40" cy="40" r="32" fill="url(#ach-moon-shine)"/><circle cx="40" cy="40" r="32" fill="none" stroke="url(#ach-moon-rim)" stroke-width="1.5"/><g transform="translate(40 40)"><path d="M8 -16 a18 18 0 1 0 8 28 a14 14 0 0 1 -8 -28 z" fill="#fff" opacity="0.95"/><circle cx="-8" cy="-10" r="2" fill="rgba(99,102,241,0.3)"/><circle cx="0" cy="6" r="1.5" fill="rgba(99,102,241,0.3)"/><circle cx="-14" cy="4" r="1" fill="rgba(99,102,241,0.3)"/><circle cx="14" cy="-4" r="1" fill="rgba(99,102,241,0.3)"/><circle cx="-18" cy="-12" r="1.2" fill="#fff" opacity="0.7"/><circle cx="16" cy="12" r="1" fill="#fff" opacity="0.7"/></g><ellipse cx="40" cy="20" rx="14" ry="4" fill="#fff" opacity="0.18"/></svg>`,

        // ===== 钻石 — 青色钻石 (青蓝渐变) =====
        diamond: `<svg viewBox="0 0 80 80" xmlns="http://www.w3.org/2000/svg"><defs><radialGradient id="ach-dia-bg" cx="0.5" cy="0.5" r="0.55"><stop offset="0" stop-color="#0c4a6e" stop-opacity="0"/><stop offset="1" stop-color="#082f49" stop-opacity="0.6"/></radialGradient><linearGradient id="ach-dia-main" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#cffafe"/><stop offset="0.3" stop-color="#67e8f9"/><stop offset="0.6" stop-color="#06b6d4"/><stop offset="1" stop-color="#0e7490"/></linearGradient><radialGradient id="ach-dia-shine" cx="0.3" cy="0.2" r="0.5"><stop offset="0" stop-color="#fff" stop-opacity="0.85"/><stop offset="0.5" stop-color="#a5f3fc" stop-opacity="0.3"/><stop offset="1" stop-color="#22d3ee" stop-opacity="0"/></radialGradient><linearGradient id="ach-dia-rim" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#fff" stop-opacity="0.7"/><stop offset="0.5" stop-color="#fff" stop-opacity="0.2"/><stop offset="1" stop-color="#fff" stop-opacity="0.5"/></linearGradient></defs><circle cx="40" cy="40" r="36" fill="url(#ach-dia-bg)"/><circle cx="40" cy="40" r="32" fill="url(#ach-dia-main)"/><circle cx="40" cy="40" r="32" fill="url(#ach-dia-shine)"/><circle cx="40" cy="40" r="32" fill="none" stroke="url(#ach-dia-rim)" stroke-width="1.5"/><g transform="translate(40 40)"><path d="M-18 -10 L-10 -20 L10 -20 L18 -10 L0 22 Z" fill="#fff" opacity="0.95"/><path d="M-18 -10 L-10 -20 L0 -10 Z" fill="#a5f3fc" opacity="0.6"/><path d="M-10 -20 L10 -20 L0 -10 Z" fill="#cffafe" opacity="0.5"/><path d="M10 -20 L18 -10 L0 -10 Z" fill="rgba(255,255,255,0.3)"/><path d="M-18 -10 L18 -10 L0 22 Z" fill="none" stroke="#0e7490" stroke-width="1" opacity="0.4"/><line x1="-18" y1="-10" x2="18" y2="-10" stroke="#fff" stroke-width="1.5" opacity="0.8"/><ellipse cx="0" cy="-15" rx="6" ry="1.5" fill="#fff" opacity="0.8"/></g><ellipse cx="40" cy="20" rx="14" ry="4" fill="#fff" opacity="0.2"/></svg>`,

        // ===== 红心 — 粉红心形 (粉红渐变) =====
        heart: `<svg viewBox="0 0 80 80" xmlns="http://www.w3.org/2000/svg"><defs><radialGradient id="ach-hrt-bg" cx="0.5" cy="0.5" r="0.55"><stop offset="0" stop-color="#831843" stop-opacity="0"/><stop offset="1" stop-color="#4c0519" stop-opacity="0.6"/></radialGradient><linearGradient id="ach-hrt-main" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#fbcfe8"/><stop offset="0.3" stop-color="#f472b6"/><stop offset="0.6" stop-color="#ec4899"/><stop offset="1" stop-color="#9d174d"/></linearGradient><radialGradient id="ach-hrt-shine" cx="0.3" cy="0.2" r="0.5"><stop offset="0" stop-color="#fff" stop-opacity="0.85"/><stop offset="0.5" stop-color="#fce7f3" stop-opacity="0.3"/><stop offset="1" stop-color="#ec4899" stop-opacity="0"/></radialGradient><linearGradient id="ach-hrt-rim" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#fff" stop-opacity="0.7"/><stop offset="0.5" stop-color="#fff" stop-opacity="0.2"/><stop offset="1" stop-color="#fff" stop-opacity="0.5"/></linearGradient></defs><circle cx="40" cy="40" r="36" fill="url(#ach-hrt-bg)"/><circle cx="40" cy="40" r="32" fill="url(#ach-hrt-main)"/><circle cx="40" cy="40" r="32" fill="url(#ach-hrt-shine)"/><circle cx="40" cy="40" r="32" fill="none" stroke="url(#ach-hrt-rim)" stroke-width="1.5"/><g transform="translate(40 42)"><path d="M0 18 C0 18 -22 4 -22 -10 C-22 -18 -16 -22 -10 -22 C-4 -22 0 -18 0 -14 C0 -18 4 -22 10 -22 C16 -22 22 -18 22 -10 C22 4 0 18 0 18 Z" fill="#fff" opacity="0.95"/><ellipse cx="-10" cy="-10" rx="4" ry="2.5" fill="#fff" opacity="0.5"/></g><ellipse cx="40" cy="20" rx="14" ry="4" fill="#fff" opacity="0.18"/></svg>`,

        // ===== 星星 — 金色星芒 (金黄渐变) =====
        star: `<svg viewBox="0 0 80 80" xmlns="http://www.w3.org/2000/svg"><defs><radialGradient id="ach-str-bg" cx="0.5" cy="0.5" r="0.55"><stop offset="0" stop-color="#451a03" stop-opacity="0"/><stop offset="1" stop-color="#1c0a01" stop-opacity="0.6"/></radialGradient><linearGradient id="ach-str-main" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#fef9c3"/><stop offset="0.3" stop-color="#fde047"/><stop offset="0.7" stop-color="#f59e0b"/><stop offset="1" stop-color="#92400e"/></linearGradient><radialGradient id="ach-str-shine" cx="0.3" cy="0.2" r="0.5"><stop offset="0" stop-color="#fff" stop-opacity="0.85"/><stop offset="0.5" stop-color="#fef3c7" stop-opacity="0.3"/><stop offset="1" stop-color="#fbbf24" stop-opacity="0"/></radialGradient><linearGradient id="ach-str-rim" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#fff" stop-opacity="0.7"/><stop offset="0.5" stop-color="#fff" stop-opacity="0.2"/><stop offset="1" stop-color="#fff" stop-opacity="0.5"/></linearGradient></defs><circle cx="40" cy="40" r="36" fill="url(#ach-str-bg)"/><circle cx="40" cy="40" r="32" fill="url(#ach-str-main)"/><circle cx="40" cy="40" r="32" fill="url(#ach-str-shine)"/><circle cx="40" cy="40" r="32" fill="none" stroke="url(#ach-str-rim)" stroke-width="1.5"/><g transform="translate(40 40)"><path d="M0 -22 L6 -6 L22 -4 L10 6 L14 22 L0 14 L-14 22 L-10 6 L-22 -4 L-6 -6 Z" fill="#fff" opacity="0.95"/><path d="M0 -22 L6 -6 L22 -4 L10 6 L0 14 Z" fill="rgba(255,255,255,0.4)"/><circle cx="0" cy="0" r="3" fill="rgba(146,64,14,0.3)"/></g><ellipse cx="40" cy="20" rx="16" ry="5" fill="#fff" opacity="0.2"/></svg>`,

        // ===== 盾牌 — 紫蓝盾牌 (靛紫渐变) =====
        shield: `<svg viewBox="0 0 80 80" xmlns="http://www.w3.org/2000/svg"><defs><radialGradient id="ach-shd-bg" cx="0.5" cy="0.5" r="0.55"><stop offset="0" stop-color="#1e1b4b" stop-opacity="0"/><stop offset="1" stop-color="#0f0a2e" stop-opacity="0.6"/></radialGradient><linearGradient id="ach-shd-main" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#c7d2fe"/><stop offset="0.3" stop-color="#818cf8"/><stop offset="0.6" stop-color="#4f46e5"/><stop offset="1" stop-color="#312e81"/></linearGradient><radialGradient id="ach-shd-shine" cx="0.3" cy="0.2" r="0.5"><stop offset="0" stop-color="#fff" stop-opacity="0.75"/><stop offset="0.5" stop-color="#e0e7ff" stop-opacity="0.25"/><stop offset="1" stop-color="#6366f1" stop-opacity="0"/></radialGradient><linearGradient id="ach-shd-rim" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#fff" stop-opacity="0.6"/><stop offset="0.5" stop-color="#fff" stop-opacity="0.15"/><stop offset="1" stop-color="#fff" stop-opacity="0.4"/></linearGradient></defs><circle cx="40" cy="40" r="36" fill="url(#ach-shd-bg)"/><circle cx="40" cy="40" r="32" fill="url(#ach-shd-main)"/><circle cx="40" cy="40" r="32" fill="url(#ach-shd-shine)"/><circle cx="40" cy="40" r="32" fill="none" stroke="url(#ach-shd-rim)" stroke-width="1.5"/><g transform="translate(40 40)"><path d="M0 -22 L18 -14 L18 4 C18 14 10 20 0 24 C-10 20 -18 14 -18 4 L-18 -14 Z" fill="#fff" opacity="0.95"/><path d="M-9 0 L-3 6 L9 -6" fill="none" stroke="#4f46e5" stroke-width="4" stroke-linecap="round" stroke-linejoin="round"/><ellipse cx="-6" cy="-12" rx="3" ry="2" fill="rgba(79,70,229,0.3)"/></g><ellipse cx="40" cy="20" rx="14" ry="4" fill="#fff" opacity="0.18"/></svg>`,

        // ===== 火箭 — 紫粉火箭 (紫粉渐变) =====
        rocket: `<svg viewBox="0 0 80 80" xmlns="http://www.w3.org/2000/svg"><defs><radialGradient id="ach-rkt-bg" cx="0.5" cy="0.5" r="0.55"><stop offset="0" stop-color="#581c87" stop-opacity="0"/><stop offset="1" stop-color="#2e1065" stop-opacity="0.6"/></radialGradient><linearGradient id="ach-rkt-main" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#f5d0fe"/><stop offset="0.3" stop-color="#f472b6"/><stop offset="0.6" stop-color="#a855f7"/><stop offset="1" stop-color="#6b21a8"/></linearGradient><radialGradient id="ach-rkt-shine" cx="0.3" cy="0.2" r="0.5"><stop offset="0" stop-color="#fff" stop-opacity="0.85"/><stop offset="0.5" stop-color="#fae8ff" stop-opacity="0.3"/><stop offset="1" stop-color="#c084fc" stop-opacity="0"/></radialGradient><linearGradient id="ach-rkt-rim" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#fff" stop-opacity="0.7"/><stop offset="0.5" stop-color="#fff" stop-opacity="0.2"/><stop offset="1" stop-color="#fff" stop-opacity="0.5"/></linearGradient></defs><circle cx="40" cy="40" r="36" fill="url(#ach-rkt-bg)"/><circle cx="40" cy="40" r="32" fill="url(#ach-rkt-main)"/><circle cx="40" cy="40" r="32" fill="url(#ach-rkt-shine)"/><circle cx="40" cy="40" r="32" fill="none" stroke="url(#ach-rkt-rim)" stroke-width="1.5"/><g transform="translate(40 40)"><path d="M0 -22 C7 -16 10 -8 10 2 L10 12 L-10 12 L-10 2 C-10 -8 -7 -16 0 -22 Z" fill="#fff" opacity="0.95"/><circle cx="0" cy="-2" r="4" fill="#a855f7" opacity="0.8"/><circle cx="0" cy="-2" r="2" fill="#fff" opacity="0.7"/><path d="M-10 12 L-15 22 L-10 18 Z" fill="#fff" opacity="0.95"/><path d="M10 12 L15 22 L10 18 Z" fill="#fff" opacity="0.95"/><path d="M-5 12 L-6 22 L-2 18 Z" fill="#fbbf24"/><path d="M5 12 L6 22 L2 18 Z" fill="#fbbf24"/><path d="M-1 14 L0 22 L1 14 Z" fill="#fff" opacity="0.7"/></g><ellipse cx="40" cy="20" rx="14" ry="4" fill="#fff" opacity="0.18"/></svg>`,

        // ===== 消费 — 蓝色礼盒 (蓝紫渐变 · 新增) =====
        spending: `<svg viewBox="0 0 80 80" xmlns="http://www.w3.org/2000/svg"><defs><radialGradient id="ach-spend-bg" cx="0.5" cy="0.5" r="0.55"><stop offset="0" stop-color="#1e1b4b" stop-opacity="0"/><stop offset="1" stop-color="#0f0a2e" stop-opacity="0.6"/></radialGradient><linearGradient id="ach-spend-main" x1="0" y1="0" x2="1" y2="1"><stop offset="0" stop-color="#dbeafe"/><stop offset="0.3" stop-color="#93c5fd"/><stop offset="0.6" stop-color="#3b82f6"/><stop offset="1" stop-color="#1e3a8a"/></linearGradient><radialGradient id="ach-spend-shine" cx="0.3" cy="0.25" r="0.5"><stop offset="0" stop-color="#fff" stop-opacity="0.7"/><stop offset="0.5" stop-color="#dbeafe" stop-opacity="0.2"/><stop offset="1" stop-color="#3b82f6" stop-opacity="0"/></radialGradient><linearGradient id="ach-spend-rim" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#fff" stop-opacity="0.6"/><stop offset="0.5" stop-color="#fff" stop-opacity="0.15"/><stop offset="1" stop-color="#fff" stop-opacity="0.4"/></linearGradient></defs><circle cx="40" cy="40" r="36" fill="url(#ach-spend-bg)"/><circle cx="40" cy="40" r="32" fill="url(#ach-spend-main)"/><circle cx="40" cy="40" r="32" fill="url(#ach-spend-shine)"/><circle cx="40" cy="40" r="32" fill="none" stroke="url(#ach-spend-rim)" stroke-width="1.5"/><g transform="translate(40 40)"><rect x="-16" y="-12" width="32" height="24" rx="2" fill="#fff" opacity="0.95"/><rect x="-16" y="-12" width="32" height="6" fill="#fde047"/><rect x="-3" y="-14" width="6" height="28" fill="#f59e0b"/><path d="M-6 -14 Q-6 -19 0 -19 Q6 -19 6 -14" fill="none" stroke="#f59e0b" stroke-width="2.5" stroke-linecap="round"/><path d="M-6 -14 Q-6 -19 -2 -19" fill="none" stroke="#ef4444" stroke-width="2.5" stroke-linecap="round"/><path d="M6 -14 Q6 -19 2 -19" fill="none" stroke="#22c55e" stroke-width="2.5" stroke-linecap="round"/><circle cx="-12" cy="-9" r="1" fill="#fef3c7"/><circle cx="12" cy="-9" r="1" fill="#fef3c7"/></g><ellipse cx="40" cy="20" rx="18" ry="6" fill="#fff" opacity="0.18"/></svg>`,

        // ===== 社交 — 紫粉对话 (粉紫渐变 · 新增) =====
        social: `<svg viewBox="0 0 80 80" xmlns="http://www.w3.org/2000/svg"><defs><radialGradient id="ach-soc-bg" cx="0.5" cy="0.5" r="0.55"><stop offset="0" stop-color="#581c87" stop-opacity="0"/><stop offset="1" stop-color="#2e1065" stop-opacity="0.6"/></radialGradient><linearGradient id="ach-soc-main" x1="0" y1="0" x2="1" y2="1"><stop offset="0" stop-color="#fae8ff"/><stop offset="0.3" stop-color="#f0abfc"/><stop offset="0.6" stop-color="#d946ef"/><stop offset="1" stop-color="#86198f"/></linearGradient><radialGradient id="ach-soc-shine" cx="0.3" cy="0.25" r="0.5"><stop offset="0" stop-color="#fff" stop-opacity="0.7"/><stop offset="0.5" stop-color="#fae8ff" stop-opacity="0.2"/><stop offset="1" stop-color="#d946ef" stop-opacity="0"/></radialGradient><linearGradient id="ach-soc-rim" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#fff" stop-opacity="0.6"/><stop offset="0.5" stop-color="#fff" stop-opacity="0.15"/><stop offset="1" stop-color="#fff" stop-opacity="0.4"/></linearGradient></defs><circle cx="40" cy="40" r="36" fill="url(#ach-soc-bg)"/><circle cx="40" cy="40" r="32" fill="url(#ach-soc-main)"/><circle cx="40" cy="40" r="32" fill="url(#ach-soc-shine)"/><circle cx="40" cy="40" r="32" fill="none" stroke="url(#ach-soc-rim)" stroke-width="1.5"/><g transform="translate(40 40)"><path d="M-18 -8 Q-18 -16 -10 -16 L8 -16 Q16 -16 16 -8 L16 0 Q16 8 8 8 L-4 8 L-10 14 L-10 8 Q-18 8 -18 0 Z" fill="#fff" opacity="0.95"/><circle cx="-8" cy="-4" r="2" fill="#d946ef"/><circle cx="0" cy="-4" r="2" fill="#d946ef"/><circle cx="8" cy="-4" r="2" fill="#d946ef"/><circle cx="14" cy="2" r="6" fill="#fff" opacity="0.9"/><text x="14" y="5" text-anchor="middle" font-family="Arial,sans-serif" font-size="9" font-weight="700" fill="#d946ef">+1</text></g><ellipse cx="40" cy="20" rx="18" ry="6" fill="#fff" opacity="0.18"/></svg>`,

        // ===== 探索 — 翠绿罗盘 (青绿渐变 · 新增) =====
        explore: `<svg viewBox="0 0 80 80" xmlns="http://www.w3.org/2000/svg"><defs><radialGradient id="ach-exp-bg" cx="0.5" cy="0.5" r="0.55"><stop offset="0" stop-color="#064e3b" stop-opacity="0"/><stop offset="1" stop-color="#022c22" stop-opacity="0.6"/></radialGradient><linearGradient id="ach-exp-main" x1="0" y1="0" x2="1" y2="1"><stop offset="0" stop-color="#d1fae5"/><stop offset="0.3" stop-color="#6ee7b7"/><stop offset="0.6" stop-color="#10b981"/><stop offset="1" stop-color="#064e3b"/></linearGradient><radialGradient id="ach-exp-shine" cx="0.3" cy="0.25" r="0.5"><stop offset="0" stop-color="#fff" stop-opacity="0.7"/><stop offset="0.5" stop-color="#a7f3d0" stop-opacity="0.2"/><stop offset="1" stop-color="#10b981" stop-opacity="0"/></radialGradient><linearGradient id="ach-exp-rim" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#fff" stop-opacity="0.6"/><stop offset="0.5" stop-color="#fff" stop-opacity="0.15"/><stop offset="1" stop-color="#fff" stop-opacity="0.4"/></linearGradient></defs><circle cx="40" cy="40" r="36" fill="url(#ach-exp-bg)"/><circle cx="40" cy="40" r="32" fill="url(#ach-exp-main)"/><circle cx="40" cy="40" r="32" fill="url(#ach-exp-shine)"/><circle cx="40" cy="40" r="32" fill="none" stroke="url(#ach-exp-rim)" stroke-width="1.5"/><g transform="translate(40 40)"><circle r="22" fill="#fff" opacity="0.95"/><circle r="18" fill="none" stroke="#065f46" stroke-width="1" opacity="0.3"/><g stroke="#065f46" stroke-width="1.2" opacity="0.5" stroke-linecap="round"><line x1="0" y1="-18" x2="0" y2="-14"/><line x1="0" y1="14" x2="0" y2="18"/><line x1="-18" y1="0" x2="-14" y2="0"/><line x1="14" y1="0" x2="18" y2="0"/></g><text x="0" y="-12" text-anchor="middle" font-family="Arial,sans-serif" font-size="7" font-weight="700" fill="#065f46">N</text><polygon points="0,-8 4,4 0,2 -4,4" fill="#dc2626"/><polygon points="0,8 4,-4 0,-2 -4,-4" fill="#065f46"/><circle r="2" fill="#065f46"/></g><ellipse cx="40" cy="20" rx="14" ry="4" fill="#fff" opacity="0.18"/></svg>`,
    };

    // v2.9.35: 成就稀有度元数据
    const _ACH_RARITY = {
        common:    { label: T.achRarityCommon,    pts: 10,  color: '#94a3b8' },
        rare:      { label: T.achRarityRare,      pts: 25,  color: '#3b82f6' },
        epic:      { label: T.achRarityEpic,      pts: 50,  color: '#a855f7' },
        legendary: { label: T.achRarityLegendary, pts: 100, color: '#f59e0b' },
    };

    // v2.9.35: 成就分类元数据 (6 大分类)
    const _ACH_CATEGORIES = [
        { id: 'collector', icon: _ACH_ICONS.collector, label: T.achCategoryCollector, gradient: 'linear-gradient(135deg, #8b5cf6, #3b82f6)' },
        { id: 'playtime',  icon: _ACH_ICONS.clock,     label: T.achCategoryPlaytime,  gradient: 'linear-gradient(135deg, #06b6d4, #0891b2)' },
        { id: 'mastery',   icon: _ACH_ICONS.trophy,    label: T.achCategoryMastery,   gradient: 'linear-gradient(135deg, #10b981, #059669)' },
        { id: 'diversity', icon: _ACH_ICONS.globe,     label: T.achCategoryDiversity, gradient: 'linear-gradient(135deg, #f97316, #ea580c)' },
        { id: 'loyalty',   icon: _ACH_ICONS.heart,     label: T.achCategoryLoyalty,   gradient: 'linear-gradient(135deg, #f472b6, #db2777)' },
        { id: 'special',   icon: _ACH_ICONS.star,      label: T.achCategorySpecial,   gradient: 'linear-gradient(135deg, #fbbf24, #f59e0b)' },
    ];

    // v2.9.35: 成就定义 — 6 大分类 30+ 成就，含稀有度与成就点数
    // metric 字段统一指向 _computeAchMetrics 返回的 key，简化判定逻辑
    const _ACHIEVEMENT_DEFS = [
        // ===== 收藏成就 (collector) — 游戏数量 =====
        { id: 'collector_10',   icon: _ACH_ICONS.collector,    name: isZh ? '初出茅庐' : 'First Steps',       desc: isZh ? '拥有 10 款游戏' : 'Own 10 games',           threshold: 10,   metric: 'gameCount',  cat: 'collector', rarity: 'common' },
        { id: 'collector_50',   icon: _ACH_ICONS.collector,    name: isZh ? '初级收藏家' : 'Novice Collector',  desc: isZh ? '拥有 50 款游戏' : 'Own 50 games',          threshold: 50,   metric: 'gameCount',  cat: 'collector', rarity: 'common' },
        { id: 'collector_100',  icon: _ACH_ICONS.collector,    name: isZh ? '中级收藏家' : 'Avid Collector',    desc: isZh ? '拥有 100 款游戏' : 'Own 100 games',        threshold: 100,  metric: 'gameCount',  cat: 'collector', rarity: 'rare' },
        { id: 'collector_300',  icon: _ACH_ICONS.collector,    name: isZh ? '高级收藏家' : 'Pro Collector',     desc: isZh ? '拥有 300 款游戏' : 'Own 300 games',        threshold: 300,  metric: 'gameCount',  cat: 'collector', rarity: 'rare' },
        { id: 'collector_500',  icon: _ACH_ICONS.collector,    name: isZh ? '超级收藏家' : 'Mega Collector',    desc: isZh ? '拥有 500 款游戏' : 'Own 500 games',        threshold: 500,  metric: 'gameCount',  cat: 'collector', rarity: 'epic' },
        { id: 'collector_1000', icon: _ACH_ICONS.kingCollector,name: isZh ? '游戏大王' : 'Game Master',         desc: isZh ? '拥有 1000 款游戏' : 'Own 1000 games',      threshold: 1000, metric: 'gameCount',  cat: 'collector', rarity: 'legendary' },
        // ===== 时长成就 (playtime) — 总游戏时长 =====
        { id: 'playtime_500',  icon: _ACH_ICONS.clock,        name: isZh ? '初涉江湖' : 'Getting Started',     desc: isZh ? '总时长达到 500 小时' : 'Reach 500 hours',   threshold: 500,  metric: 'totalHours', cat: 'playtime',  rarity: 'common' },
        { id: 'playtime_1k',   icon: _ACH_ICONS.clock,        name: isZh ? '入门玩家' : 'Beginner',            desc: isZh ? '总时长达到 1000 小时' : 'Reach 1000 hours', threshold: 1000, metric: 'totalHours', cat: 'playtime',  rarity: 'common' },
        { id: 'playtime_3k',   icon: _ACH_ICONS.hourglass,    name: isZh ? '熟练玩家' : 'Skilled',             desc: isZh ? '总时长达到 3000 小时' : 'Reach 3000 hours', threshold: 3000, metric: 'totalHours', cat: 'playtime',  rarity: 'rare' },
        { id: 'playtime_5k',   icon: _ACH_ICONS.hourglass,    name: isZh ? '资深玩家' : 'Veteran',             desc: isZh ? '总时长达到 5000 小时' : 'Reach 5000 hours', threshold: 5000, metric: 'totalHours', cat: 'playtime',  rarity: 'rare' },
        { id: 'playtime_10k',  icon: _ACH_ICONS.hourglass,    name: isZh ? '硬核玩家' : 'Hardcore',            desc: isZh ? '总时长达到 10000 小时' : 'Reach 10000h',   threshold: 10000,metric: 'totalHours', cat: 'playtime',  rarity: 'epic' },
        { id: 'playtime_20k',  icon: _ACH_ICONS.fire,         name: isZh ? '传奇玩家' : 'Legend',              desc: isZh ? '总时长达到 20000 小时' : 'Reach 20000h',   threshold: 20000,metric: 'totalHours', cat: 'playtime',  rarity: 'legendary' },
        // ===== 专精成就 (mastery) — 单游戏深度游玩 =====
        { id: 'mastery_1x100',  icon: _ACH_ICONS.trophy,      name: isZh ? '专精入门' : 'Focused',             desc: isZh ? '1 款游戏游玩超过 100 小时' : '1 game 100h+',  threshold: 1, metric: 'games100h', cat: 'mastery', rarity: 'common' },
        { id: 'mastery_5x100',  icon: _ACH_ICONS.trophy,      name: isZh ? '多线专精' : 'Multi-Focus',         desc: isZh ? '5 款游戏游玩超过 100 小时' : '5 games 100h+', threshold: 5, metric: 'games100h', cat: 'mastery', rarity: 'common' },
        { id: 'mastery_10x100', icon: _ACH_ICONS.trophy,      name: isZh ? '深度专精' : 'Dedicated',           desc: isZh ? '10 款游戏游玩超过 100 小时' : '10 games 100h+',threshold: 10,metric: 'games100h', cat: 'mastery', rarity: 'rare' },
        { id: 'mastery_1x500',  icon: _ACH_ICONS.fire,        name: isZh ? '挚爱之作' : 'Beloved',             desc: isZh ? '1 款游戏游玩超过 500 小时' : '1 game 500h+',  threshold: 1, metric: 'games500h', cat: 'mastery', rarity: 'rare' },
        { id: 'mastery_1x1k',   icon: _ACH_ICONS.fire,        name: isZh ? '一生挚爱' : 'Soulmate',            desc: isZh ? '1 款游戏游玩超过 1000 小时' : '1 game 1000h+',threshold: 1, metric: 'games1kh',  cat: 'mastery', rarity: 'epic' },
        { id: 'mastery_20x100', icon: _ACH_ICONS.perfection,  name: isZh ? '完美主义' : 'Perfectionist',       desc: isZh ? '20 款游戏游玩超过 100 小时' : '20 games 100h+',threshold: 20,metric: 'games100h', cat: 'mastery', rarity: 'legendary' },
        // ===== 多元成就 (diversity) — 游戏覆盖面 =====
        { id: 'div_played50',  icon: isZh ? _ACH_ICONS.globe : _ACH_ICONS.globe, name: isZh ? '广泛涉猎' : 'Explorer',  desc: isZh ? '游玩库中 50% 的游戏' : 'Play 50% of library',   threshold: 50, metric: 'playRate',  cat: 'diversity', rarity: 'common' },
        { id: 'div_played80',  icon: _ACH_ICONS.globe,        name: isZh ? '博览群书' : 'Scholar',             desc: isZh ? '游玩库中 80% 的游戏' : 'Play 80% of library',   threshold: 80, metric: 'playRate',  cat: 'diversity', rarity: 'rare' },
        { id: 'div_unplayed100',icon: _ACH_ICONS.shield,      name: isZh ? '库存积压' : 'Backlog',             desc: isZh ? '拥有 100 款从未游玩的游戏' : '100 unplayed games', threshold: 100, metric: 'unplayedCount', cat: 'diversity', rarity: 'common' },
        { id: 'div_recent7d',  icon: _ACH_ICONS.sunrise,      name: isZh ? '活跃玩家' : 'Active',              desc: isZh ? '7 天内游玩过游戏' : 'Played within 7 days',     threshold: 1,  metric: 'recent7d',  cat: 'diversity', rarity: 'common' },
        { id: 'div_recent24h', icon: _ACH_ICONS.sunrise,      name: isZh ? '今日在线' : 'Today',               desc: isZh ? '24 小时内游玩过游戏' : 'Played within 24h',     threshold: 1,  metric: 'recent24h', cat: 'diversity', rarity: 'rare' },
        { id: 'div_played100', icon: _ACH_ICONS.perfection,   name: isZh ? '全勤玩家' : 'Completionist',       desc: isZh ? '游玩库中 100% 的游戏' : 'Play 100% of library', threshold: 100,metric: 'playRate',  cat: 'diversity', rarity: 'legendary' },
        // ===== 忠诚成就 (loyalty) — 数据完整度与家庭组 =====
        { id: 'loy_data50',    icon: _ACH_ICONS.heart,        name: isZh ? '数据收集者' : 'Data Keeper',       desc: isZh ? '50% 游戏有入库时间' : '50% games have acquire time', threshold: 50, metric: 'dataCompleteness', cat: 'loyalty', rarity: 'common' },
        { id: 'loy_data80',    icon: _ACH_ICONS.heart,        name: isZh ? '数据达人' : 'Data Master',         desc: isZh ? '80% 游戏有入库时间' : '80% games have acquire time', threshold: 80, metric: 'dataCompleteness', cat: 'loyalty', rarity: 'rare' },
        { id: 'loy_family',    icon: _ACH_ICONS.shield,       name: isZh ? '家庭共享' : 'Family Sharing',      desc: isZh ? '启用家庭组共享' : 'Family sharing enabled',     threshold: 1,  metric: 'hasFamily',  cat: 'loyalty', rarity: 'common' },
        { id: 'loy_accurate',  icon: _ACH_ICONS.diamond,      name: isZh ? '精准记录' : 'Precise',             desc: isZh ? '95% 游戏有入库时间' : '95% games have acquire time', threshold: 95, metric: 'dataCompleteness', cat: 'loyalty', rarity: 'epic' },
        // ===== 特殊成就 (special) — 复合里程碑 =====
        { id: 'sp_night_owl',  icon: _ACH_ICONS.moon,         name: isZh ? '夜猫子' : 'Night Owl',             desc: isZh ? '5000h+ 且拥有 200+ 游戏' : '5000h+ & 200+ games', threshold: 1, metric: 'nightOwl',   cat: 'special', rarity: 'epic' },
        { id: 'sp_whale',      icon: _ACH_ICONS.diamond,      name: isZh ? '巨鲸玩家' : 'Whale',               desc: isZh ? '10000h+ 且拥有 500+ 游戏' : '10000h+ & 500+ games', threshold: 1, metric: 'whale',     cat: 'special', rarity: 'legendary' },
        { id: 'sp_pioneer',    icon: _ACH_ICONS.rocket,       name: isZh ? '先锋玩家' : 'Pioneer',             desc: isZh ? '拥有游戏且总时长 1000h+' : 'Has games & 1000h+',  threshold: 1, metric: 'pioneer',   cat: 'special', rarity: 'common' },
        { id: 'sp_liberty',    icon: _ACH_ICONS.star,         name: isZh ? '自由之魂' : 'Free Spirit',         desc: isZh ? '从未游玩的游戏超过 200 款' : '200+ unplayed games', threshold: 200,metric: 'unplayedCount', cat: 'special', rarity: 'rare' },
    ];

    // v2.9.35: 成就解锁缓存 key (GM_setValue 持久化)
    const _ACH_CACHE_KEY = 'sglv_ach_unlocks_v2';

    // v2.9.35: 读取已解锁成就缓存 { achId: unlockTimestamp }
    function _getAchUnlockCache() {
        try {
            const raw = GM_getValue(_ACH_CACHE_KEY, '{}');
            const data = typeof raw === 'string' ? JSON.parse(raw) : raw;
            return (data && typeof data === 'object') ? data : {};
        } catch (e) {
            return {};
        }
    }

    // v2.9.35: 写入已解锁成就缓存 (新增解锁时追加时间戳)
    function _saveAchUnlockCache(cache) {
        try {
            GM_setValue(_ACH_CACHE_KEY, JSON.stringify(cache));
        } catch (e) { /* 静默失败 */ }
    }

    // v2.9.35: 统一计算成就指标 — 一次遍历，所有 metric 集中产出
    function _computeAchMetrics() {
        const allGames = getStatFilteredGames();
        const gameCount = allGames.length;
        const totalPlaytimeMin = allGames.reduce((s, g) => s + (g.playtime || 0), 0);
        const totalHours = Math.floor(totalPlaytimeMin / 60);
        const playedGames = allGames.filter(g => (g.playtime || 0) > 0).length;
        const unplayedCount = gameCount - playedGames;
        const playRate = gameCount > 0 ? Math.round((playedGames / gameCount) * 100) : 0;
        const games100h = allGames.filter(g => (g.playtime || 0) >= 6000).length;   // 100h = 6000min
        const games500h = allGames.filter(g => (g.playtime || 0) >= 30000).length;  // 500h = 30000min
        const games1kh  = allGames.filter(g => (g.playtime || 0) >= 60000).length;  // 1000h = 60000min
        const now = Date.now();
        const recent7d = allGames.filter(g => g.lastPlayed && (now - g.lastPlayed * 1000) <= 7 * 86400000).length > 0 ? 1 : 0;
        const recent24h = allGames.filter(g => g.lastPlayed && (now - g.lastPlayed * 1000) <= 86400000).length > 0 ? 1 : 0;
        const withAcquired = allGames.filter(g => g.acquiredTime && g.acquiredTime > 0).length;
        const dataCompleteness = gameCount > 0 ? Math.round((withAcquired / gameCount) * 100) : 0;
        const hasFamily = (state.familyInfo && state.familyInfo.members && state.familyInfo.members.length > 0) ? 1 : 0;
        const nightOwl = (totalHours >= 5000 && gameCount >= 200) ? 1 : 0;
        const whale = (totalHours >= 10000 && gameCount >= 500) ? 1 : 0;
        const pioneer = (gameCount > 0 && totalHours >= 1000) ? 1 : 0;
        return {
            gameCount, totalHours, playRate, unplayedCount, recent7d, recent24h,
            games100h, games500h, games1kh, dataCompleteness, hasFamily,
            nightOwl, whale, pioneer,
        };
    }

    // v2.9.35: 计算用户成就数据 — 统一 metrics + 缓存解锁时间戳
    function computeMyAchievements() {
        const metrics = _computeAchMetrics();
        const unlockCache = _getAchUnlockCache();
        const now = Date.now();
        let cacheDirty = false;

        const results = _ACHIEVEMENT_DEFS.map(ach => {
            const current = metrics[ach.metric] || 0;
            const unlocked = current >= ach.threshold;
            const progress = ach.threshold > 0 ? Math.min(100, (current / ach.threshold) * 100) : (unlocked ? 100 : 0);
            const pts = _ACH_RARITY[ach.rarity]?.pts || 10;

            // 解锁时间戳：新解锁则记录当前时间
            let unlockedAt = null;
            if (unlocked) {
                if (unlockCache[ach.id]) {
                    unlockedAt = unlockCache[ach.id];
                } else {
                    unlockCache[ach.id] = now;
                    unlockedAt = now;
                    cacheDirty = true;
                }
            }

            return { ...ach, current, unlocked, progress, pts, unlockedAt };
        });

        // 清理已不再解锁的缓存条目（游戏被移除等边界情况）
        Object.keys(unlockCache).forEach(id => {
            const ach = results.find(a => a.id === id);
            if (ach && !ach.unlocked) {
                delete unlockCache[id];
                cacheDirty = true;
            }
        });

        if (cacheDirty) _saveAchUnlockCache(unlockCache);
        return results;
    }

    // v2.9.35: 格式化解锁时间
    function _formatAchTime(ts) {
        if (!ts) return '';
        const d = new Date(ts);
        const yyyy = d.getFullYear();
        const mm = String(d.getMonth() + 1).padStart(2, '0');
        const dd = String(d.getDate()).padStart(2, '0');
        return `${yyyy}-${mm}-${dd}`;
    }

    // v2.9.35: 格式化相对时间 (如 "3天前")
    function _formatRelTime(ts) {
        if (!ts) return '';
        const diff = Date.now() - ts;
        const days = Math.floor(diff / 86400000);
        if (days === 0) return isZh ? '今天' : 'Today';
        if (days === 1) return isZh ? '昨天' : 'Yesterday';
        if (days < 7) return isZh ? `${days}天前` : `${days}d ago`;
        if (days < 30) return isZh ? `${Math.floor(days / 7)}周前` : `${Math.floor(days / 7)}w ago`;
        if (days < 365) return isZh ? `${Math.floor(days / 30)}月前` : `${Math.floor(days / 30)}mo ago`;
        return isZh ? `${Math.floor(days / 365)}年前` : `${Math.floor(days / 365)}y ago`;
    }

    // ==================== v2.9.36: 我的成就标签页 — 左右布局重构 ====================
    // v2.9.50: computeMyAchievementsCached — 走 PCC 持久化,跨 session 复用
    // v2.11.21 (FEAT-013 TASK-008): 降级为组装器——数据组装 + 三段渲染器按文档序消费 + 事件绑定内联
    // (用户卡/分类导航/最近解锁 → 侧边栏段; 环形进度+KPI+重置 → 头部段; 单张成就 → 卡片段)

    // v2.11.21 (FEAT-013 TASK-008): 成就侧边栏段（用户卡 + 分类导航 + 最近解锁,自 renderMyAchievementsTab 拆出,纯搬移）
    function _achSidebarHtml(achievements, unlocked, selectedCat, userName, achLevel, totalPts, maxPts, completionRate) {
        // 最近解锁 (按时间倒序，最多 5 个)
        const recentUnlocks = unlocked
            .filter(a => a.unlockedAt)
            .sort((a, b) => b.unlockedAt - a.unlockedAt)
            .slice(0, 5);

        // 侧边栏最近解锁列表
        const sidebarRecentHtml = recentUnlocks.length > 0
            ? recentUnlocks.map(a => `<div class="sglv-ach-sidebar-recent-item" title="${a.name} · ${_formatAchTime(a.unlockedAt)}">
                <div class="sglv-ach-sidebar-recent-icon">${a.icon}</div>
                <div class="sglv-ach-sidebar-recent-info">
                    <div class="sglv-ach-sidebar-recent-name">${a.name}</div>
                    <div class="sglv-ach-sidebar-recent-time">${_formatRelTime(a.unlockedAt)}</div>
                </div>
              </div>`).join('')
            : `<div class="sglv-ach-sidebar-recent-empty">${T.achNoUnlocks}</div>`;

        // 分类导航（垂直列表）
        const navItems = _ACH_CATEGORIES.map(cat => {
            const catAchs = achievements.filter(a => a.cat === cat.id);
            const catUnlocked = catAchs.filter(a => a.unlocked).length;
            const catTotal = catAchs.length;
            const badgeClass = catUnlocked === catTotal ? 'complete' : catUnlocked > 0 ? 'partial' : 'none';
            return `<div class="sglv-ach-nav-item ${selectedCat === cat.id ? 'active' : ''}" data-cat="${cat.id}">
                <div class="sglv-ach-nav-item-icon">${cat.icon}</div>
                <span class="sglv-ach-nav-item-name">${cat.label}</span>
                <span class="sglv-ach-nav-item-badge ${badgeClass}">${catUnlocked}/${catTotal}</span>
            </div>`;
        }).join('');

        // "全部" 导航项
        const allNavItem = `<div class="sglv-ach-nav-item ${selectedCat === 'all' ? 'active' : ''}" data-cat="all">
            <div class="sglv-ach-nav-item-icon">${_ACH_ICONS.trophy}</div>
            <span class="sglv-ach-nav-item-name">${T.achAllCats}</span>
            <span class="sglv-ach-nav-item-badge ${completionRate === 100 ? 'complete' : completionRate > 0 ? 'partial' : 'none'}">${unlocked.length}/${achievements.length}</span>
        </div>`;

        return `
                <!-- ====== 左侧边栏 ====== -->
                <div class="sglv-ach-sidebar">
                    <div class="sglv-ach-sidebar-header">
                        <div class="sglv-ach-sidebar-title">
                            ${_ACH_ICONS.trophy}
                            <span>${T.tabAchievements}</span>
                        </div>
                    </div>
                    <div class="sglv-ach-user-card">
                        <div class="sglv-ach-user-avatar">
                            ${_ACH_ICONS.trophy}
                            <span class="sglv-ach-user-level">Lv.${achLevel}</span>
                        </div>
                        <div class="sglv-ach-user-name">${userName}</div>
                        <div class="sglv-ach-user-pts">${T.achPoints}: <strong>${totalPts}</strong> / ${maxPts}</div>
                    </div>
                    <div class="sglv-ach-nav">
                        <div class="sglv-ach-nav-label">${isZh ? '成就分类' : 'Categories'}</div>
                        ${allNavItem}
                        ${navItems}
                    </div>
                    <div class="sglv-ach-sidebar-recent">
                        <div class="sglv-ach-sidebar-recent-label">${T.achRecentUnlocks}</div>
                        ${sidebarRecentHtml}
                    </div>
                </div>`;
    }

    // v2.11.21 (FEAT-013 TASK-008): 成就头部段（环形进度 SVG + KPI 行经 kpiCards + 重置按钮,自 renderMyAchievementsTab 拆出,纯搬移）
    function _achHeaderHtml(completionRate, unlockedLen, totalLen, steamBadgeCount, totalPts, maxPts, achLevel) {
        // 环形进度 SVG
        const ringR = 38;
        const ringCirc = 2 * Math.PI * ringR;
        const ringOffset = ringCirc * (1 - completionRate / 100);

        return `
                    <div class="sglv-ach-header">
                        <div class="sglv-ach-ring-wrap">
                            <svg class="sglv-ach-ring-svg" viewBox="0 0 88 88">
                                <defs>
                                    <linearGradient id="ach-ring-grad" x1="0" y1="0" x2="1" y2="1">
                                        <stop offset="0" stop-color="#22d3ee"/>
                                        <stop offset="0.4" stop-color="#38bdf8"/>
                                        <stop offset="0.7" stop-color="#a78bfa"/>
                                        <stop offset="1" stop-color="#fbbf24"/>
                                    </linearGradient>
                                </defs>
                                <circle class="sglv-ach-ring-bg" cx="44" cy="44" r="${ringR}"/>
                                <circle class="sglv-ach-ring-fill" cx="44" cy="44" r="${ringR}"
                                    stroke-dasharray="${ringCirc}" stroke-dashoffset="${ringOffset}"/>
                            </svg>
                            <div class="sglv-ach-ring-text">
                                <div class="sglv-ach-ring-val">${completionRate}%</div>
                                <div class="sglv-ach-ring-label">${isZh ? '自定义完成率' : 'Custom Rate'}</div>
                            </div>
                        </div>
                        <div class="sglv-ach-kpi-row">
                            ${kpiCards([
                                { icon: ICONS.achievement, label: isZh ? '自定义成就' : 'Custom Ach', value: unlockedLen, unit: `/${totalLen}`, sub: `${T.kpiRate} ${completionRate}%`, color: 'purple' },
                                { icon: ICONS.medal || ICONS.trophy, label: isZh ? 'Steam 徽章' : 'Steam Badges', value: steamBadgeCount, sub: isZh ? '平台官方' : 'Official', color: 'gold' },
                                { icon: ICONS.trophy, label: isZh ? '成就点数' : 'Points', value: totalPts, unit: `/${maxPts}pts`, sub: `${T.kpiRate} ${maxPts > 0 ? Math.round(totalPts / maxPts * 100) : 0}%`, color: 'amber' },
                                { icon: ICONS.barChart, label: isZh ? '成就等级' : 'Ach Level', value: `Lv.${achLevel}`, sub: `${totalPts} ${isZh ? '点累计' : 'pts total'}`, color: 'cyan' },
                            ], { tone: 'playtime' })}
                        </div>
                        <button class="sglv-ach-reset-btn" id="sglv-ach-reset">${T.achResetBtn}</button>
                    </div>`;
    }

    // v2.11.21 (FEAT-013 TASK-008): 单张成就卡片段（NEW 标签/稀有度着色/进度条/解锁时间,自 renderMyAchievementsTab 拆出,纯搬移）
    function _achCardHtml(a) {
        const progressVal = a.unlocked ? '100%' : `${a.progress.toFixed(0)}%`;
        const currentText = a.unlocked ? T.achUnlocked : `${a.current}/${a.threshold}`;
        const unlockTimeHtml = a.unlocked && a.unlockedAt
            ? `<div class="sglv-ach-card-unlock-time">${T.achUnlockedAt} ${_formatAchTime(a.unlockedAt)}</div>`
            : '';
        // v2.9.59: NEW 标签 — 24小时内解锁的成就显示 NEW
        const isNew = a.unlocked && a.unlockedAt && (Date.now() - a.unlockedAt < 24 * 3600 * 1000);
        const newTagHtml = isNew ? `<span class="sglv-ach-card-new-tag">NEW</span>` : '';
        // v2.9.59: 稀有度 class 添加到卡片本身(驱动左边框颜色)
        return `<div class="sglv-ach-card ${a.unlocked ? 'unlocked' : 'locked'} ${a.rarity}">
            <div class="sglv-ach-card-icon">
                ${a.icon}
                <div class="sglv-ach-card-rarity ${a.rarity}" title="${_ACH_RARITY[a.rarity]?.label || ''}"></div>
            </div>
            <div class="sglv-ach-card-body">
                <div class="sglv-ach-card-head">
                    <div class="sglv-ach-card-name">${a.name}${newTagHtml}</div>
                    <span class="sglv-ach-card-pts">+${a.pts}pts</span>
                </div>
                <div class="sglv-ach-card-desc">${a.desc}</div>
                <div class="sglv-ach-card-progress-wrap">
                    <div class="sglv-ach-card-progress"><div class="sglv-ach-card-progress-fill" style="width:${a.unlocked ? 100 : a.progress}%"></div></div>
                    <span class="sglv-ach-card-progress-val">${a.unlocked ? progressVal : currentText}</span>
                </div>
                ${unlockTimeHtml}
            </div>
        </div>`;
    }

    function renderMyAchievementsTab(parent) {
        const achievements = computeMyAchievementsCached();
        const unlocked = achievements.filter(a => a.unlocked);
        const totalPts = unlocked.reduce((s, a) => s + a.pts, 0);
        const maxPts = achievements.reduce((s, a) => s + a.pts, 0);
        const completionRate = achievements.length > 0 ? Math.round((unlocked.length / achievements.length) * 100) : 0;
        const selectedCat = state.achSelectedCat || 'all';

        // v2.9.98: 获取 Steam 平台徽章/成就数（区别于自定义成就）
        let steamBadgeCount = 0;
        try {
            const sgisProfile = SGLV_API.getSGISProfile && SGLV_API.getSGISProfile();
            if (sgisProfile && sgisProfile.userBadges && sgisProfile.userBadges.badges) {
                steamBadgeCount = sgisProfile.userBadges.badges.length;
            } else if (SGLV_API.getSGISUserBadges) {
                const ub = SGLV_API.getSGISUserBadges();
                if (ub && ub.badges) steamBadgeCount = ub.badges.length;
            }
        } catch { /* 静默 */ }

        // v2.9.36: 获取用户名（从页面提取）
        let userName = isZh ? 'Steam 玩家' : 'Steam Player';
        try {
            const pulldown = document.querySelector('#account_pulldown');
            if (pulldown && pulldown.textContent.trim()) userName = pulldown.textContent.trim();
        } catch { /* 静默 */ }

        // v2.9.36: 计算成就等级（基于总点数）
        const achLevel = Math.floor(totalPts / 100) + 1;

        // 成就卡片（按选中分类过滤）
        const filteredAchs = selectedCat === 'all' ? achievements : achievements.filter(a => a.cat === selectedCat);
        const catLabel = selectedCat === 'all' ? T.achAllCats : (_ACH_CATEGORIES.find(c => c.id === selectedCat)?.label || '');

        const html = `
            <div class="sglv-ach-layout">
                ${_achSidebarHtml(achievements, unlocked, selectedCat, userName, achLevel, totalPts, maxPts, completionRate)}

                <!-- ====== 右侧主内容区 ====== -->
                <div class="sglv-ach-main">
                    ${_achHeaderHtml(completionRate, unlocked.length, achievements.length, steamBadgeCount, totalPts, maxPts, achLevel)}
                    <div class="sglv-ach-content">
                        <div class="sglv-ach-content-header">
                            <span class="sglv-ach-content-title">${catLabel}</span>
                            <span class="sglv-ach-content-count">${filteredAchs.length}</span>
                        </div>
                        <div class="sglv-ach-grid">
                            ${filteredAchs.map(_achCardHtml).join('')}
                        </div>
                        <div class="sglv-ach-footer">${isZh ? '成就数据基于本地游戏库计算 · 排除家庭组共享和 DLC · v2.9.40' : 'Achievements computed from local library · excludes family shared & DLC · v2.9.40'}</div>
                    </div>
                </div>
            </div>
        `;

        parent.innerHTML = html;

        // 分类切换事件
        parent.querySelectorAll('.sglv-ach-nav-item').forEach(el => {
            el.addEventListener('click', () => {
                state.achSelectedCat = el.dataset.cat;
                renderMyAchievementsTab(parent);
            });
        });

        // 重置按钮事件
        const resetBtn = parent.querySelector('#sglv-ach-reset');
        if (resetBtn) {
            resetBtn.addEventListener('click', () => {
                if (confirm(T.achResetConfirm)) {
                    GM_setValue(_ACH_CACHE_KEY, '{}');
                    renderMyAchievementsTab(parent);
                }
            });
        }
    }

    // ==================== v2.9.90: 个人展柜标签页 ====================
    // 设计目标：展示玩家游玩魅力与口味喜好，支持自定义 8 张竖版游戏封面、
    // 最近游玩时长、最近解锁成就、玩家画像标签等。
    // 布局：顶部英雄区（头像+等级+统计） → 双栏（左：封面网格+时长 / 右：成就+标签）

    // 展柜配置存储 key
    const _SC_CONFIG_KEY = nsKey('showcase_config');

    function _loadShowcaseConfig() {
        if (state.showcaseConfigLoaded) return state.showcaseConfig;
        state.showcaseConfigLoaded = true;
        try {
            const raw = GM_getValue(_SC_CONFIG_KEY, '');
            if (raw) {
                const cfg = JSON.parse(raw);
                if (cfg && Array.isArray(cfg.selectedAppIds)) {
                    // v2.9.94: 兼容 selectedBadgeIds 字段
                    if (!Array.isArray(cfg.selectedBadgeIds)) cfg.selectedBadgeIds = [];
                    state.showcaseConfig = cfg;
                    return cfg;
                }
            }
        } catch (e) { /* 静默 */ }
        state.showcaseConfig = { selectedAppIds: [], selectedBadgeIds: [] };
        return state.showcaseConfig;
    }

    function _saveShowcaseConfig(cfg) {
        state.showcaseConfig = cfg;
        try { GM_setValue(_SC_CONFIG_KEY, JSON.stringify(cfg)); } catch (e) { /* 静默 */ }
        // v2.9.99: 配置变更后展柜缓存失效无需显式重置 — _swrReadShowcaseCache 的
        // configHash 比对(每次渲染现算 _computeShowcaseCacheHash)自然触发刷新
    }

    // ==================== v2.9.99: 展柜持久化缓存层 ====================
    // 设计目标：跨 session 持久化展柜数据，页面刷新后立即可用，
    // 未变化的用户配置（封面/徽章）不失效，配合 SWR 模式后台静默刷新。
    //
    // 缓存结构: { schemaVer, timestamp, steamId, configHash, data: { profile, recentGames, badges, achievements, stats } }
    // configHash = 用户配置签名 + 游戏库规模签名，用于判断缓存是否仍然有效
    // v2.9.103: schemaVer 版本化缓存结构,旧结构缓存直接失效重算;
    //   data.achievements 只存 unlocked 切片(锁定成就不参与展柜渲染,全量写入会撑爆存储配额)

    const _SC_DATA_CACHE_KEY = nsKey('showcase_data_cache');
    const _SC_DATA_SCHEMA = 1;                    // v2.9.103: 缓存结构版本(变更 data 结构时 +1)
    const _SC_DATA_TTL = 30 * 60 * 1000;       // 30 分钟正常 TTL
    const _SC_DATA_STALE_TTL = 6 * 60 * 60 * 1000; // 6 小时过期兜底（超过则不使用）
    let _scCacheWriteWarned = false;            // v2.9.103: 写失败只告警一次,避免刷屏

    // v2.9.103: 缓存只保留已解锁成就 — 全量成就(含锁定)大库用户可达数万条,
    // 展柜渲染仅消费 unlocked 切片(计数/积分/画像标签/最近解锁),只存切片可显著减小 GM_setValue 体积
    function _showcaseUnlockedOnly(achievements) {
        return (achievements || []).filter(a => a && a.unlocked);
    }

    // 计算展柜缓存签名：用户配置 + 游戏库规模
    function _computeShowcaseCacheHash() {
        const cfg = _loadShowcaseConfig();
        const games = getStatFilteredGames();
        const coverPart = (cfg.selectedAppIds || []).join(',');
        const badgePart = (cfg.selectedBadgeIds || []).map(b => b.appid + ':' + b.badgeid + ':' + (b.isFoil ? '1' : '0')).join(',');
        const libPart = games.length + ':' + (games.length > 0 ? Math.floor(games.reduce((s, g) => s + (g.playtime || 0), 0) / 60) : 0);
        return [coverPart, badgePart, libPart].join('|');
    }

    // 从持久化缓存读取展柜数据（不判断 TTL，由调用方决定是否使用）
    function _readShowcaseCache() {
        try {
            const raw = GM_getValue(_SC_DATA_CACHE_KEY, '');
            if (!raw) return null;
            const parsed = JSON.parse(raw);
            if (!parsed || !parsed.data || !parsed.timestamp) return null;
            if (parsed.schemaVer !== _SC_DATA_SCHEMA) return null; // v2.9.103: 结构版本不匹配直接丢弃
            return parsed;
        } catch { return null; }
    }

    // 写入持久化缓存
    function _writeShowcaseCache(data, configHash) {
        try {
            const steamId = getActiveSteamId();
            GM_setValue(_SC_DATA_CACHE_KEY, JSON.stringify({
                schemaVer: _SC_DATA_SCHEMA,
                timestamp: Date.now(),
                steamId,
                configHash,
                data,
            }));
        } catch (e) {
            // v2.9.103: 超配额/序列化失败不再静默 — 告警一次(缓存失败仅影响秒开体验,不影响功能)
            if (!_scCacheWriteWarned) {
                _scCacheWriteWarned = true;
                console.warn('[SGLV] 展柜缓存写入失败(可能超 GM 存储配额),已跳过本次持久化', e);
            }
        }
    }

    // SWR 读取：返回 { data, stale } —— stale=true 表示数据已过 TTL 但仍在兜底窗口内
    function _swrReadShowcaseCache(configHash) {
        const cached = _readShowcaseCache();
        if (!cached) return { data: null, stale: false, timestamp: 0 };
        // steamId 不匹配则不使用（切换了账号）
        const steamId = getActiveSteamId();
        if (cached.steamId && steamId && cached.steamId !== steamId) return { data: null, stale: false, timestamp: 0 };
        const age = Date.now() - cached.timestamp;
        // 超过过期兜底窗口，直接丢弃
        if (age > _SC_DATA_STALE_TTL) return { data: null, stale: false, timestamp: 0 };
        // configHash 不匹配（用户改了封面/徽章/游戏库变化），数据仍可用但需要刷新
        const configChanged = (cached.configHash !== configHash);
        const stale = (age > _SC_DATA_TTL) || configChanged;
        return { data: cached.data, stale, configChanged, timestamp: cached.timestamp };
    }

    // 生成数据签名用于比对是否需要重渲染
    function _showcaseDataSignature(profile, recentGames, badges, stats) {
        const p = profile ? [profile.name, profile.level, profile.badgeCount, profile.country].join(':') : '';
        const r = (recentGames || []).map(g => g.appid + ':' + (g.playtime_forever || 0)).join(',');
        const b = (badges || []).map(b => b.appid + ':' + b.badgeid + ':' + b.level).join(',');
        const s = stats ? [stats.gameCount, stats.totalHours, stats.achCount, stats.totalAchPts].join(':') : '';
        return [p, r, b, s].join('|');
    }

    // 获取默认 8 张封面（游玩时间最长的 8 个游戏）
    function _getDefaultCoverAppIds(allGames) {
        return allGames
            .filter(g => (g.playtime || 0) > 0)
            .sort((a, b) => (b.playtime || 0) - (a.playtime || 0))
            .slice(0, 8)
            .map(g => g.appid);
    }

    // 获取展柜封面 appid 列表（用户自定义优先，否则默认）
    function _getShowcaseCoverAppIds(allGames) {
        const cfg = _loadShowcaseConfig();
        if (cfg.selectedAppIds && cfg.selectedAppIds.length > 0) {
            // 过滤掉不在游戏库中的 appid（可能已移除）
            const validSet = new Set(allGames.map(g => g.appid));
            const valid = cfg.selectedAppIds.filter(id => validSet.has(id));
            if (valid.length > 0) return valid.slice(0, 8);
        }
        return _getDefaultCoverAppIds(allGames);
    }

    // 应用封面三级回退链到 <img> 元素（参考游戏橱窗 coverImgTag 逻辑）
    // Level 1: 成功URL缓存（getPosterGood）—— 避免重复试错
    // Level 2: 多CDN直链回退（coverChainUrls）—— cloudflare → akamai → shared.akamai → shared.fastly
    // Level 3: Steam Store API 兜底（_fetchCoverApiUrl）—— 获取含 hash 的真实图片URL
    // 最终失败: 显示占位符
    function _applyCoverChain(imgEl, appid) {
        if (!imgEl || !appid) return;
        const kind = 'poster';

        // Level 1: 检查成功URL缓存
        const goodUrl = getPosterGood(appid, kind);
        if (goodUrl) {
            imgEl.src = goodUrl;
            imgEl.onerror = function () {
                // 缓存的URL也失败（可能CDN临时不可达），降级到CDN链
                _tryCdnChain(imgEl, appid, kind);
            };
            return;
        }

        _tryCdnChain(imgEl, appid, kind);
    }

    // Level 2: 多CDN直链回退
    function _tryCdnChain(imgEl, appid, kind) {
        const urls = coverChainUrls(appid, kind);
        let idx = 0;
        imgEl.src = urls[0];
        imgEl.onload = function () {
            // 记录成功URL，下次直接使用
            recordPosterGood(appid, imgEl.src, kind);
            imgEl.onload = null;
        };
        imgEl.onerror = function () {
            idx++;
            if (idx < urls.length) {
                imgEl.src = urls[idx];
            } else {
                // 所有CDN直链失败，进入 Level 3: API 兜底
                imgEl.onload = null;
                _tryApiFallback(imgEl, appid, kind);
            }
        };
    }

    // Level 3: Steam Store API 获取真实图片URL
    // v2.9.105: 传递 kind 参数，使 API 兜底按图片类型选择最佳 URL
    function _tryApiFallback(imgEl, appid, kind) {
        _fetchCoverApiUrl(appid, kind).then(url => {
            if (url) {
                // API返回的URL是相对路径或绝对路径，需要处理
                const fullUrl = url.startsWith('http')
                    ? url
                    : `https://cdn.cloudflare.steamstatic.com/steam/apps/${appid}/${url}`;
                imgEl.onerror = function () {
                    // API URL也失败，显示占位
                    imgEl.onerror = null;
                    _showCoverPlaceholder(imgEl);
                };
                imgEl.onload = function () {
                    recordPosterGood(appid, fullUrl, kind);
                    imgEl.onload = null;
                };
                imgEl.src = fullUrl;
            } else {
                _showCoverPlaceholder(imgEl);
            }
        }).catch(() => _showCoverPlaceholder(imgEl));
    }

    // 最终占位符
    function _showCoverPlaceholder(imgEl) {
        if (!imgEl || !imgEl.parentElement) return;
        imgEl.onerror = null;
        imgEl.onload = null;
        imgEl.style.display = 'none';
        const ph = document.createElement('div');
        ph.className = 'sglv-sc-cover-placeholder';
        ph.textContent = isZh ? '无封面' : 'No Cover';
        imgEl.parentElement.appendChild(ph);
    }

    // 应用游戏图标到 <img> 元素（带回退）
    // v2.11.44: 改走统一图标回退链（community_assets 新路径优先 + 多 CDN + header 兜底）
    function _applyGameIcon(imgEl, appid, iconHash) {
        const good = getPosterGood(appid, 'icon');
        imgEl.src = good || communityIconChainUrls(appid, iconHash)[0];
        imgEl.onload = function () { recordPosterGood(appid, imgEl.src, 'icon'); imgEl.onload = null; };
        imgEl.onerror = function () {
            imgEl.onerror = null;
            sglvIconFallback(imgEl, appid, iconHash);
        };
    }

    // 获取玩家档案（头像、昵称、等级、国家等）
    // 参考个人信息面板（SGIS）的数据获取逻辑：
    //   1. 优先复用 SGIS 已获取的 profile（含 GetPlayerSummaries + GetBadges 精确数据）
    //   2. 回退到 Steam Web API（GetPlayerSummaries）+ 社区页面等级抓取
    //   3. 最后回退到当前页面 DOM 提取
    async function _fetchShowcaseProfile() {
        const TTL = 30 * 60 * 1000; // 30 分钟缓存
        if (state.showcaseProfile && (Date.now() - state.showcaseProfileAt) < TTL) {
            return state.showcaseProfile;
        }
        if (state.showcaseProfileLoading) {
            return new Promise(resolve => {
                const check = setInterval(() => {
                    if (!state.showcaseProfileLoading) {
                        clearInterval(check);
                        resolve(state.showcaseProfile);
                    }
                }, 100);
            });
        }
        state.showcaseProfileLoading = true;

        const steamId = getActiveSteamId();
        let avatar = '';
        let name = isZh ? 'Steam 玩家' : 'Steam Player';
        let level = 0;
        let country = '';
        let profileUrl = '';
        let badgeCount = 0;

        // 1. 优先复用 SGIS 个人信息面板已获取的档案数据
        //    SGIS.profile 包含 summary (GetPlayerSummaries)、level、userBadges 等
        const sgisProfile = SGLV_API.getSGISProfile && SGLV_API.getSGISProfile();
        if (sgisProfile && sgisProfile.summary) {
            const s = sgisProfile.summary;
            avatar = s.avatarfull || s.avatarmedium || s.avatar || '';
            name = s.personaname || name;
            country = s.loccountrycode || '';
            profileUrl = s.profileurl || '';
            // 等级：优先用 GetBadges API 返回的精确值，降级用 fetchSteamLevel
            if (sgisProfile.userBadges && sgisProfile.userBadges.playerLevel) {
                level = sgisProfile.userBadges.playerLevel;
                // 徽章数：从 GetBadges API 返回的 badges 数组获取
                if (Array.isArray(sgisProfile.userBadges.badges)) {
                    badgeCount = sgisProfile.userBadges.badges.length;
                }
            } else if (sgisProfile.level && typeof sgisProfile.level === 'number') {
                level = sgisProfile.level;
            }
            // 如果 SGIS 数据完整，直接使用
            if (avatar && level > 0) {
                const profile = { avatar, name, level, country, steamId, profileUrl, badgeCount };
                state.showcaseProfile = profile;
                state.showcaseProfileAt = Date.now();
                state.showcaseProfileLoading = false;
                return profile;
            }
        }

        // 2. 回退到 Steam Web API（GetPlayerSummaries）+ 社区页面等级抓取
        const apiKey = storage.getApiKey();
        if (apiKey && steamId) {
            // 并行获取：GetPlayerSummaries + 社区页面等级
            const [summary, levelFromCommunity] = await Promise.all([
                // GetPlayerSummaries（参考 SGIS fetchPlayerSummaries）
                (async () => {
                    try {
                        const url = `https://api.steampowered.com/ISteamUser/GetPlayerSummaries/v0002/?key=${apiKey}&steamids=${steamId}`;
                        const data = await requestSteamAPI(url);
                        const player = data?.response?.players?.[0];
                        return player || null;
                    } catch { return null; }
                })(),
                // 社区页面等级抓取（参考 SGIS fetchSteamLevel）
                (async () => {
                    if (level > 0) return level; // 已有则跳过
                    try {
                        // v2.11.36 (FEAT-015 TASK-003): 迁移至 sglvGmFetchTextRetry（原 onload 不检查状态码
                        //   resolve 任意文本，非 2xx 时等级匹配失败→0；新非 2xx reject→catch→0，等价）
                        const html = await sglvGmFetchTextRetry(`https://steamcommunity.com/profiles/${steamId}/`, { timeout: 12000 });
                        const m = html.match(/"player_level":(\d+)/) || html.match(/class="friendPlayerLevelNum"[^>]*>(\d+)/);
                        return m ? parseInt(m[1], 10) : 0;
                    } catch { return 0; }
                })(),
            ]);

            if (summary) {
                if (!avatar) avatar = summary.avatarfull || summary.avatarmedium || summary.avatar || '';
                if (name === (isZh ? 'Steam 玩家' : 'Steam Player')) name = summary.personaname || name;
                if (!country) country = summary.loccountrycode || '';
                if (!profileUrl) profileUrl = summary.profileurl || '';
            }
            if (levelFromCommunity > 0) level = levelFromCommunity;
        }

        // 3. 最后回退到当前页面 DOM 提取（快速、无网络开销）
        if (!avatar || !level || !name || name === (isZh ? 'Steam 玩家' : 'Steam Player')) {
            try {
                const pulldown = document.querySelector('#account_pulldown');
                if (pulldown && pulldown.textContent.trim() && (name === (isZh ? 'Steam 玩家' : 'Steam Player'))) {
                    name = pulldown.textContent.trim();
                }
                if (!avatar) {
                    const avatarImg = document.querySelector('#global_actions .user_avatar img, .playerAvatarAutoSizeInner img, .user_avatar img');
                    if (avatarImg && avatarImg.src) avatar = avatarImg.src;
                }
                if (!level) {
                    const levelEl = document.querySelector('.friendPlayerLevelNum');
                    if (levelEl) {
                        const lv = parseInt(levelEl.textContent.trim(), 10);
                        if (!isNaN(lv) && lv > 0) level = lv;
                    }
                }
            } catch { /* 静默 */ }
        }

        // 如果还没有获取到社区页面数据，尝试从社区页面提取昵称和头像
        if ((!avatar || !level) && steamId && !apiKey) {
            try {
                // v2.11.36 (FEAT-015 TASK-003): 迁移至 sglvGmFetchTextRetry（失败 catch 静默保持已有数据）
                const html = await sglvGmFetchTextRetry(`https://steamcommunity.com/profiles/${steamId}/`, { timeout: 10000 });
                if (!avatar) {
                    const avMatch = html.match(/"avatarfull":"([^"]+)"/) || html.match(/class="playerAvatarAutoSizeInner"[^>]*>[\s\S]*?<img[^>]+src="([^"]+)"/);
                    if (avMatch) avatar = avMatch[1];
                }
                if (!level) {
                    const lvMatch = html.match(/"player_level":(\d+)/) || html.match(/class="friendPlayerLevelNum"[^>]*>(\d+)/);
                    if (lvMatch) {
                        const lv = parseInt(lvMatch[1], 10);
                        if (!isNaN(lv) && lv > 0) level = lv;
                    }
                }
                if (name === (isZh ? 'Steam 玩家' : 'Steam Player')) {
                    const nmMatch = html.match(/"personaname":"([^"]+)"/);
                    if (nmMatch) name = nmMatch[1];
                }
            } catch { /* 静默，使用已有数据 */ }
        }

        const profile = { avatar, name, level, country, steamId, profileUrl, badgeCount };
        state.showcaseProfile = profile;
        state.showcaseProfileAt = Date.now();
        state.showcaseProfileLoading = false;
        return profile;
    }

    // 获取最近游玩游戏数据（参考个人信息面板 SGIS 的 fetchRecentlyPlayedGames）
    // 数据源优先级：
    //   1. 复用 SGIS.profile.recentGames（已通过 GetRecentlyPlayedGames API 获取）
    //   2. 直接调用 GetRecentlyPlayedGames/v0001/ API
    //   3. 回退到本地游戏库 lastPlayed 排序
    // 返回统一格式: [{ appid, name, playtime_2weeks, playtime_forever, img_icon_url, iconUrl }]
    async function _fetchRecentPlayedGames() {
        const steamId = getActiveSteamId();
        const gameMap = new Map(getStatFilteredGames().map(g => [g.appid, g]));

        // 1. 优先复用 SGIS 个人信息面板已获取的最近游玩数据
        const sgisProfile = SGLV_API.getSGISProfile && SGLV_API.getSGISProfile();
        if (sgisProfile && Array.isArray(sgisProfile.recentGames) && sgisProfile.recentGames.length > 0) {
            return sgisProfile.recentGames.map(g => {
                const local = gameMap.get(g.appid);
                return {
                    appid: g.appid,
                    name: g.name || (local ? local.name : `App ${g.appid}`),
                    playtime_2weeks: g.playtime_2weeks || 0,
                    playtime_forever: g.playtime_forever || (local ? local.playtime || 0 : 0),
                    img_icon_url: g.img_icon_url || '',
                    // v2.11.44: 统一经 getGameIconUrl（community_assets 新路径 + icon 成功缓存）
                    iconUrl: getGameIconUrl(g.appid, g.img_icon_url),
                };
            });
        }

        // 2. 直接调用 GetRecentlyPlayedGames API
        const apiKey = storage.getApiKey();
        if (apiKey && steamId) {
            try {
                const url = `https://api.steampowered.com/IPlayerService/GetRecentlyPlayedGames/v0001/?key=${apiKey}&steamid=${steamId}&format=json`;
                const data = await requestSteamAPI(url);
                const games = data?.response?.games || [];
                if (games.length > 0) {
                    return games.map(g => {
                        const local = gameMap.get(g.appid);
                        return {
                            appid: g.appid,
                            name: g.name || (local ? local.name : `App ${g.appid}`),
                            playtime_2weeks: g.playtime_2weeks || 0,
                            playtime_forever: g.playtime_forever || (local ? local.playtime || 0 : 0),
                            img_icon_url: g.img_icon_url || '',
                            // v2.11.44: 统一经 getGameIconUrl（community_assets 新路径 + icon 成功缓存）
                            iconUrl: getGameIconUrl(g.appid, g.img_icon_url),
                        };
                    });
                }
            } catch { /* 静默，回退到本地数据 */ }
        }

        // 3. 回退到本地游戏库数据（按 lastPlayed 降序）
        const allGames = getStatFilteredGames();
        return allGames
            .filter(g => g.lastPlayed && g.lastPlayed > 0)
            .sort((a, b) => (b.lastPlayed || 0) - (a.lastPlayed || 0))
            .slice(0, 8)
            .map(g => ({
                appid: g.appid,
                name: g.name,
                playtime_2weeks: 0,
                playtime_forever: g.playtime || 0,
                img_icon_url: g.icon || '',
                // v2.11.44: 统一经 getGameIconUrl（community_assets 新路径 + icon 成功缓存）
                iconUrl: getGameIconUrl(g.appid, g.icon),
            }));
    }

    // ==================== v2.9.94: 徽章自定义展示 ====================
    // 从 Steam 社区徽章页面抓取徽章图标 URL（GetBadges API 不返回图片）
    // 参考 steam-badges-card-view-1.5.5 的 DOM 解析策略:
    //   .badge_info_image img[data-delayed-image] → 已解锁徽章图标
    //   .badge_empty_circle img[data-delayed-image] → 未解锁徽章图标
    //   .badge_progress_card.owned img → 降级: 已拥有的卡牌图
    // 按 "appid|foil" 映射, 1 小时缓存
    const _SC_BADGE_ICONS_KEY = nsKey('showcase_badge_icons');
    const _SC_BADGE_ICONS_TTL = 60 * 60 * 1000; // 1 小时

    async function _fetchBadgeIcons(steamId) {
        if (!steamId) return null;
        // 内存缓存
        if (state.showcaseBadgeIcons && (Date.now() - state.showcaseBadgeIconsAt) < _SC_BADGE_ICONS_TTL) {
            return state.showcaseBadgeIcons;
        }
        if (state.showcaseBadgeIconsLoading) {
            return new Promise(resolve => {
                const check = setInterval(() => {
                    if (!state.showcaseBadgeIconsLoading) {
                        clearInterval(check);
                        resolve(state.showcaseBadgeIcons);
                    }
                }, 100);
            });
        }
        state.showcaseBadgeIconsLoading = true;

        // 持久化缓存
        try {
            const cached = GM_getValue(_SC_BADGE_ICONS_KEY, '');
            if (cached) {
                const parsed = JSON.parse(cached);
                if (parsed && parsed.timestamp && (Date.now() - parsed.timestamp < _SC_BADGE_ICONS_TTL)) {
                    state.showcaseBadgeIcons = parsed.data || {};
                    state.showcaseBadgeIconsAt = parsed.timestamp;
                    state.showcaseBadgeIconsLoading = false;
                    return state.showcaseBadgeIcons;
                }
            }
        } catch { /* 静默 */ }

        const icons = {};
        try {
            // v2.11.36 (FEAT-015 TASK-003): 迁移至 sglvGmFetchTextRetry（失败 catch → 空 icons；
            //   2xx 空文本 core reject→catch→空 icons，与原 resolve('')→length 检查→空 icons 等价）
            const html = await sglvGmFetchTextRetry(`https://steamcommunity.com/profiles/${steamId}/badges`, { timeout: 15000 });

            if (html && html.length > 500) {
                const doc = new DOMParser().parseFromString(html, 'text/html');
                const rows = doc.querySelectorAll('.badge_row');
                rows.forEach(row => {
                    try {
                        // 提取 appid 和 foil 标记
                        const linkEl = row.querySelector('.badge_row_overlay');
                        const url = linkEl ? linkEl.href : '';
                        let appId = '', isFoil = false;
                        if (url) {
                            const foilMatch = url.match(/\/gamecards\/foil\/(\d+)/);
                            if (foilMatch) { appId = foilMatch[1]; isFoil = true; }
                            else { const norm = url.match(/\/gamecards\/(\d+)/); if (norm) appId = norm[1]; }
                        }

                        // 提取徽章图片 (多策略, 参考 steam-badges-card-view)
                        let iconUrl = '';
                        const badgeInfoImg = row.querySelector('.badge_info_image img');
                        if (badgeInfoImg) iconUrl = badgeInfoImg.getAttribute('data-delayed-image') || badgeInfoImg.src || '';
                        if (!iconUrl) {
                            const ownedCard = row.querySelector('.badge_progress_card.owned img');
                            if (ownedCard) iconUrl = ownedCard.getAttribute('data-delayed-image') || ownedCard.src || '';
                        }
                        if (!iconUrl) {
                            const lockedEl = row.querySelector('.badge_empty_circle img');
                            if (lockedEl) iconUrl = lockedEl.getAttribute('data-delayed-image') || lockedEl.src || '';
                        }
                        if (!iconUrl) {
                            const emptyLeftEl = row.querySelector('.badge_empty_left img');
                            if (emptyLeftEl) iconUrl = emptyLeftEl.getAttribute('data-delayed-image') || emptyLeftEl.src || '';
                        }

                        if (appId && iconUrl && /^https?:\/\//.test(iconUrl)) {
                            icons[appId + '|' + (isFoil ? '1' : '0')] = iconUrl;
                        }
                    } catch { /* 跳过单行解析错误 */ }
                });
            }
        } catch { /* 网络失败, 静默 */ }

        state.showcaseBadgeIcons = icons;
        state.showcaseBadgeIconsAt = Date.now();
        state.showcaseBadgeIconsLoading = false;

        // 持久化
        try {
            GM_setValue(_SC_BADGE_ICONS_KEY, JSON.stringify({ timestamp: Date.now(), data: icons }));
        } catch { /* 静默 */ }

        return icons;
    }

    // 合并 GetBadges API 数据 + 社区页面图标数据
    // 参考 SGIS enrichBadgesWithGameNames / detectEventBadge / getBadgeIcon 的逻辑
    function _mergeBadgeData(badgeData, icons) {
        if (!badgeData || !badgeData.badges) return [];
        const owned = (state.ownedGames && state.ownedGames.length) ? state.ownedGames : storage.getCachedGames();
        const ownedMap = {};
        owned.forEach(g => { if (g && g.appid) ownedMap[String(g.appid)] = g.name; });
        // 复用卡牌数据库 (SGLV_API.getCardDbMaxLevel / getCardDbGameName)
        const getCardDbName = SGLV_API.getCardDbGameName || function() { return ''; };
        const getCardDbMaxLv = SGLV_API.getCardDbMaxLevel || function() { return 0; };
        const ACTIVITY_CDN = 'https://cdn.cloudflare.steamstatic.com/steamcommunity/public/images/items/';

        const result = badgeData.badges.map(b => {
            const appId = b.appid || 0;
            // 游戏名
            let gameName = '';
            if (appId > 0) {
                gameName = ownedMap[String(appId)] || getCardDbName(appId) || '';
            }
            // 活动徽章检测
            let eventName = '';
            // 节日活动 appid 映射 (复用 SGIS STEAM_EVENT_APPID_MAP)
            const evtMap = SGLV_API.getSteamEventAppIdMap ? SGLV_API.getSteamEventAppIdMap() : null;
            if (evtMap && evtMap[String(appId)]) {
                eventName = evtMap[String(appId)];
            } else if (appId > 3000000 && !gameName) {
                eventName = 'Steam 活动';
            }
            // 徽章类型
            let badgeType = 'game';
            if (eventName) badgeType = 'event';
            else if (b.communityitemid) badgeType = 'community';

            // isFoil: badgeid 末位为奇数通常代表 foil (Steam 约定)
            const isFoil = !!(b.border_color && b.border_color === 1);

            // 图标 URL: 优先社区页面图标, 降级到 getBadgeIcon 三级回退
            let iconUrl = '';
            if (icons && icons[appId + '|' + (isFoil ? '1' : '0')]) {
                iconUrl = icons[appId + '|' + (isFoil ? '1' : '0')];
            } else if (icons && icons[appId + '|0']) {
                iconUrl = icons[appId + '|0']; // 非foil降级
            }
            // 降级: 活动徽章用 CDN items 路径
            if (!iconUrl && eventName && appId > 0) {
                iconUrl = ACTIVITY_CDN + appId + '/icon_64x64.png';
            }
            // 降级: 游戏徽章用商店胶囊图
            if (!iconUrl && appId > 0 && !eventName) {
                iconUrl = `https://shared.fastly.steamstatic.com/store_item_assets/steam/apps/${appId}/capsule_184x69.jpg`;
            }

            return {
                appid: appId,
                badgeid: b.badgeid,
                level: b.level || 0,
                xp: b.xp || 0,
                scarcity: b.scarcity || 0,
                completionTime: b.completion_time || 0,
                iconUrl,
                gameName,
                eventName,
                name: gameName || eventName || (b.communityitemid ? '社区徽章 #' + b.badgeid : '游戏 #' + appId),
                badgeType,
                isFoil,
                maxLevel: getCardDbMaxLv(appId),
                badgeUrl: appId > 0
                    ? `https://steamcommunity.com/profiles/${getActiveSteamId()}/badges/${appId}`
                    : '',
            };
        });

        // 按等级降序 + XP 降序排序, 便于选择器展示
        result.sort((a, b) => (b.level || 0) - (a.level || 0) || (b.xp || 0) - (a.xp || 0));
        return result;
    }

    // 获取展柜徽章数据 (合并 API + 图标)
    async function _getShowcaseBadges() {
        // 1. 优先复用 SGIS 已获取的徽章数据
        let badgeData = null;
        const sgisProfile = SGLV_API.getSGISProfile && SGLV_API.getSGISProfile();
        if (sgisProfile && sgisProfile.userBadges) {
            badgeData = sgisProfile.userBadges;
        }
        // 也检查 SGIS.userBadges (可能已由勋章标签页加载)
        if (!badgeData && SGLV_API.getSGISUserBadges) {
            badgeData = SGLV_API.getSGISUserBadges();
        }

        // 2. 若无缓存, 直接调用 GetBadges API
        if (!badgeData) {
            const steamId = getActiveSteamId();
            const apiKey = storage.getApiKey();
            if (apiKey && steamId) {
                try {
                    const url = `https://api.steampowered.com/IPlayerService/GetBadges/v1/?key=${apiKey}&steamid=${steamId}`;
                    const data = await requestSteamAPI(url);
                    badgeData = {
                        badges: data?.response?.badges || [],
                        playerLevel: data?.response?.player_level || 0,
                    };
                } catch { /* 静默 */ }
            }
        }

        if (!badgeData || !badgeData.badges || badgeData.badges.length === 0) return [];

        // 3. 获取图标
        const steamId = getActiveSteamId();
        const icons = await _fetchBadgeIcons(steamId);

        // 4. 合并
        return _mergeBadgeData(badgeData, icons);
    }

    // 获取用户选择的徽章 (最多 3 个)
    function _getSelectedShowcaseBadges(allBadges) {
        const cfg = _loadShowcaseConfig();
        if (!cfg.selectedBadgeIds || cfg.selectedBadgeIds.length === 0) return [];
        return cfg.selectedBadgeIds.map(sel => {
            const badge = allBadges.find(b =>
                b.appid === sel.appid && b.badgeid === sel.badgeid &&
                !!b.isFoil === !!sel.isFoil
            );
            return badge || null;
        }).filter(Boolean);
    }

    // 徽章选择器弹窗——v2.11.16 (FEAT-013 TASK-003) 迁移 openPickerModal 工厂,签名不变。
    // 分页方案: 接入 renderPagination,页大小 200——第 1 页与原 slice(0,200) 输出一致,
    // >200 徽章经翻页可见(原实现截断不可达);搜索词变化自动回第 1 页;≤200 时分页条不渲染(零视觉差异)。
    // 虚拟滚动方案否决: 模态内滚动/搜索/分类三态交互边界复杂,收益不成比例(取舍见 TASK-003 PRD 执行记录)。
    function _openBadgePicker(allBadges, currentSelected, onSave) {
        // 分类
        const gameBadges = allBadges.filter(b => b.badgeType === 'game');
        const eventBadges = allBadges.filter(b => b.badgeType === 'event');
        const communityBadges = allBadges.filter(b => b.badgeType === 'community');

        let currentFilter = 'all';
        let page = 1;
        let lastQuery = '';
        let lastTotal = 0;
        let lastTotalPages = 1;
        const PAGE_SIZE = 200;

        function filteredList(searchVal) {
            let list = allBadges;
            if (currentFilter === 'game') list = gameBadges;
            else if (currentFilter === 'event') list = eventBadges;
            else if (currentFilter === 'community') list = communityBadges;
            const filterLower = (searchVal || '').toLowerCase().trim();
            if (filterLower) {
                list = list.filter(b =>
                    (b.name || '').toLowerCase().includes(filterLower) ||
                    String(b.appid).includes(filterLower)
                );
            }
            return list;
        }

        openPickerModal({
            overlayId: 'sglv-sc-badge-picker-overlay',
            idBase: 'sglv-sc-badge',
            modalCls: 'sglv-sc-picker sglv-sc-badge-picker',
            title: isZh ? '选择展柜徽章（最多 3 个）' : 'Select Showcase Badges (max 3)',
            searchPlaceholder: isZh ? '搜索徽章…' : 'Search badges…',
            extraHtml: `
                <div class="sglv-sc-badge-tabs">
                    <button class="sglv-sc-badge-tab active" data-filter="all">${isZh ? '全部' : 'All'} (${allBadges.length})</button>
                    <button class="sglv-sc-badge-tab" data-filter="game">${isZh ? '游戏' : 'Game'} (${gameBadges.length})</button>
                    <button class="sglv-sc-badge-tab" data-filter="event">${isZh ? '活动' : 'Event'} (${eventBadges.length})</button>
                    <button class="sglv-sc-badge-tab" data-filter="community">${isZh ? '社区' : 'Community'} (${communityBadges.length})</button>
                </div>`,
            gridCls: 'sglv-sc-badge-grid',
            afterGridHtml: `<div class="sglv-pagination" id="sglv-sc-badge-pager"></div>`,
            countInit: currentSelected.length,
            maxSelect: 3,
            saveText: isZh ? '保存' : 'Save',
            currentSelected: currentSelected.map(b => b.appid + '|' + b.badgeid + '|' + (b.isFoil ? '1' : '0')),
            // 原语义: 清空选择后若初始有选中则仍可保存(保存空数组=清除);封面侧为 disabled
            canSave: size => size > 0 || currentSelected.length > 0,
            getItems: (searchVal) => {
                if ((searchVal || '') !== lastQuery) { page = 1; lastQuery = searchVal || ''; }
                const list = filteredList(searchVal);
                lastTotal = list.length;
                const { pageItems, totalPages, page: clamped } = paginate(list, page, PAGE_SIZE);
                page = clamped;
                lastTotalPages = totalPages;
                return pageItems;
            },
            itemKey: b => b.appid + '|' + b.badgeid + '|' + (b.isFoil ? '1' : '0'),
            renderItem: (b, isSelected) => {
                const key = b.appid + '|' + b.badgeid + '|' + (b.isFoil ? '1' : '0');
                const foilTag = b.isFoil ? '<span class="sglv-sc-badge-foil">Foil</span>' : '';
                const lvlTag = b.level > 0 ? `<span class="sglv-sc-badge-lvl">Lv.${b.level}${b.maxLevel > 0 ? '/' + b.maxLevel : ''}</span>` : '';
                return `<div class="sglv-sc-badge-pick-item ${isSelected ? 'selected' : ''}" data-key="${escHtml(key)}" title="${escHtml(b.name)}">
                    <div class="sglv-sc-badge-pick-icon">
                        ${b.iconUrl ? `<img src="${escHtml(b.iconUrl)}" alt="" loading="lazy" onerror="this.style.display='none';this.parentElement.classList.add('no-icon')">` : '<div class="sglv-sc-badge-pick-noicon">' + (b.badgeType === 'event' ? '🎉' : b.badgeType === 'community' ? '★' : '🎮') + '</div>'}
                    </div>
                    <div class="sglv-sc-badge-pick-info">
                        <div class="sglv-sc-badge-pick-name">${escHtml(b.name)}</div>
                        <div class="sglv-sc-badge-pick-meta">${foilTag}${lvlTag}<span class="sglv-sc-badge-pick-xp">${b.xp || 0} XP</span></div>
                    </div>
                    <div class="sglv-sc-picker-check">✓</div>
                </div>`;
            },
            itemSelector: '.sglv-sc-badge-pick-item',
            keyFromItem: el => el.dataset.key,
            onGridRendered: (grid, rerender) => {
                const pager = grid.parentElement.querySelector('#sglv-sc-badge-pager');
                if (!pager) return;
                if (lastTotalPages > 1) {
                    renderPagination(pager, 'sglv-scb', page, lastTotalPages, lastTotal,
                        () => { page -= 1; rerender(); },
                        () => { page += 1; rerender(); },
                        (p) => { page = p; rerender(); });
                } else {
                    pager.innerHTML = '';
                }
            },
            bindExtra: (overlay, rerender) => {
                overlay.querySelectorAll('.sglv-sc-badge-tab').forEach(tab => {
                    tab.addEventListener('click', () => {
                        overlay.querySelectorAll('.sglv-sc-badge-tab').forEach(t => t.classList.remove('active'));
                        tab.classList.add('active');
                        currentFilter = tab.dataset.filter;
                        page = 1;
                        rerender();
                    });
                });
            },
            buildResult: (selected) => {
                // 从 allBadges 中找到选中的徽章(输出结构与原实现一致:{appid,badgeid,isFoil})
                const selectedBadges = [];
                selected.forEach(key => {
                    const [appid, badgeid, foil] = key.split('|');
                    const badge = allBadges.find(b =>
                        String(b.appid) === appid && String(b.badgeid) === badgeid &&
                        !!b.isFoil === (foil === '1')
                    );
                    if (badge) selectedBadges.push({
                        appid: badge.appid, badgeid: badge.badgeid, isFoil: badge.isFoil,
                    });
                });
                return selectedBadges;
            },
            maxWarningText: isZh ? '最多选择 3 个徽章' : 'Max 3 badges',
            savedToastText: isZh ? '展柜徽章已更新' : 'Showcase badges updated',
            onSave,
        });
    }

    // v2.9.99: 渲染展柜标签页 — SWR 模式
    // 流程: 骨架屏 → 持久化缓存快渲染 → 后台静默刷新 → 签名比对（未变化不重渲染）
    // v2.11.35 (FEAT-015 TASK-002): 拆分渲染/数据准备——本函数只消费缓存(骨架/缓存直渲染),
    // 后台刷新(网络拉取+签名比对+重渲染)外提至 prepareShowcaseTabData,由 TAB_RENDERERS.prepare 调用
    function renderShowcaseTab(parent) {
        ++state.showcaseRenderToken;
        const allGames = getStatFilteredGames();
        const configHash = _computeShowcaseCacheHash();

        // Step 1: 立即渲染骨架屏（用户可以先看到页面结构）
        parent.innerHTML = createSkeleton('showcase');

        // Step 2: SWR 读取持久化缓存 — 跨 session 复用，页面刷新后立即可用
        const swr = _swrReadShowcaseCache(configHash);
        if (swr.data && swr.data.profile) {
            // 有缓存，立即渲染完整内容（用户先看到上次数据，无白屏）
            _renderShowcaseContent(parent, swr.data, allGames);
            // 从持久化缓存恢复内存缓存，避免后台刷新时重复网络请求
            if (!state.showcaseProfile && swr.data.profile) {
                state.showcaseProfile = swr.data.profile;
                state.showcaseProfileAt = swr.timestamp || 0;
            }
            // 缓存未过期且配置未变化 → 无需后台刷新，直接返回
            if (!swr.stale && !swr.configChanged) {
                state.showcasePreheated = true;
            }
        }
    }

    // v2.11.35 (FEAT-015 TASK-002): 展柜数据准备(自 renderShowcaseTab 外提的后台刷新步骤 Step 3-5)
    // - 缓存未过期且配置未变化时直接返回(不发起网络请求)
    // - 与预热共享 in-flight 抓取(重复进入只发一轮请求)
    // - 渲染竞态保护沿用 state.showcaseRenderToken(每次 renderShowcaseTab 递增)
    async function prepareShowcaseTabData(parent) {
        const myToken = state.showcaseRenderToken;
        const allGames = getStatFilteredGames();
        const configHash = _computeShowcaseCacheHash();
        const swr = _swrReadShowcaseCache(configHash);
        if (swr.data && swr.data.profile && !swr.stale && !swr.configChanged) {
            state.showcasePreheated = true;
            return;
        }

        // Step 3: 后台静默刷新（缓存过期/配置变更/无缓存时获取最新数据）
        // v2.9.103: 与预热共享 in-flight 抓取(重复进入只发一轮请求)
        const data = await _fetchShowcaseDataAll();

        // 防止并发渲染竞态：刷新期间用户切换标签页则放弃本次渲染
        if (myToken !== state.showcaseRenderToken) return;

        // 统计数据
        const { profile, recentGames, badges: allBadges, stats } = data;
        // v2.9.103: 缓存只持久化 unlocked 成就切片(全量成就体积大且渲染不消费锁定条目)
        const newData = { profile, recentGames, badges: allBadges, achievements: _showcaseUnlockedOnly(data.achievements), stats };

        // Step 4: 签名比对 — 数据未变化则保留当前视图（避免闪烁）
        const cachedSig = swr.data
            ? _showcaseDataSignature(swr.data.profile, swr.data.recentGames, swr.data.badges, swr.data.stats)
            : '';
        const newSig = _showcaseDataSignature(profile, recentGames, allBadges, stats);
        if (cachedSig === newSig) {
            _writeShowcaseCache(newData, configHash);
            state.showcasePreheated = true;
            return;
        }

        // Step 5: 数据有变化，重新渲染 + 持久化缓存
        _renderShowcaseContent(parent, newData, allGames);
        _writeShowcaseCache(newData, configHash);
        state.showcasePreheated = true;
    }

    // v2.11.35 (FEAT-015 TASK-002): 展柜完整刷新入口(渲染+数据准备),封面/徽章编辑回调复用
    // (原回调直接调 renderShowcaseTab 走完整流程,拆分后由本入口保持"配置变更后重拉"行为)
    function refreshShowcaseTab(parent) {
        renderShowcaseTab(parent);
        prepareShowcaseTabData(parent);
    }

    // v2.11.20 (FEAT-013 TASK-007): 展柜英雄区段渲染器（头像/等级/国旗 + 徽章槽 + 统计行,自 _renderShowcaseContent 拆出,纯搬移）
    // 注: 统计行为 sglv-sc-hero-stat 命名空间（裸 icon 兄弟节点 + 未命名包装 div + val 先于 label）,
    // 与 kpiCards 五种 tone 形态均不匹配且为单一消费方,经 PRD 差异核销豁免接入（DOM class 红线）
    function _showcaseHeroHtml(profile, gameCount, totalHours, steamBadgeCount, totalAchPts, allBadges, selectedBadges) {
        // === 英雄区 HTML ===
        const avatarHtml = profile.avatar
            ? `<img class="sglv-sc-avatar" src="${escHtml(profile.avatar)}" alt="${escHtml(profile.name)}" width="44" height="44" loading="lazy"
                   onerror="this.onerror=null;this.outerHTML='<div class=&quot;sglv-sc-avatar-placeholder&quot;>${escHtml(profile.name.charAt(0).toUpperCase())}</div>'">`
            : `<div class="sglv-sc-avatar-placeholder">${escHtml(profile.name.charAt(0).toUpperCase())}</div>`;
        const levelBadgeHtml = profile.level > 0
            ? `<div class="sglv-sc-level-badge" title="${isZh ? 'Steam 等级' : 'Steam Level'}">Lv.${profile.level}</div>`
            : '';
        // 国家/地区标签（使用 Steam 社区国旗 CDN）
        const countryHtml = profile.country
            ? `<span class="sglv-sc-hero-country" title="${escHtml(profile.country)}">
                 <img src="https://community.cloudflare.steamstatic.com/public/images/countryflags/${escHtml(profile.country.toLowerCase())}.gif"
                      alt="${escHtml(profile.country)}" loading="lazy"
                      onerror="this.style.display='none'">
                 ${escHtml(profile.country)}
               </span>`
            : '';

        // v2.9.94: === 徽章展示区 HTML ===
        const badgeSlotsHtml = [];
        for (let i = 0; i < 3; i++) {
            const badge = selectedBadges[i];
            if (badge) {
                const lvlText = badge.level > 0
                    ? `<span class="sglv-sc-hero-badge-lvl">Lv.${badge.level}${badge.maxLevel > 0 ? '/' + badge.maxLevel : ''}</span>`
                    : '';
                const foilTag = badge.isFoil ? '<span class="sglv-sc-hero-badge-foil-tag">Foil</span>' : '';
                badgeSlotsHtml.push(`<div class="sglv-sc-hero-badge" data-badge-appid="${badge.appid}" data-badge-url="${escHtml(badge.badgeUrl)}" title="${escHtml(badge.name)}">
                    ${badge.iconUrl
                        ? `<img src="${escHtml(badge.iconUrl)}" alt="${escHtml(badge.name)}" loading="lazy" onerror="this.style.display='none';this.nextElementSibling.style.display='flex'">
                           <div class="sglv-sc-hero-badge-fallback" style="display:none">${ICONS.medal}</div>`
                        : `<div class="sglv-sc-hero-badge-fallback">${ICONS.medal}</div>`
                    }
                    ${lvlText}
                    ${foilTag}
                </div>`);
            } else {
                badgeSlotsHtml.push(`<div class="sglv-sc-hero-badge-empty" data-slot="${i}" title="${isZh ? '点击添加徽章' : 'Click to add badge'}">+</div>`);
            }
        }
        const badgeAreaHtml = allBadges.length > 0 ? `
            <div class="sglv-sc-hero-divider"></div>
            <div class="sglv-sc-hero-badges">
                ${badgeSlotsHtml.join('')}
                <button class="sglv-sc-hero-badge-edit" id="sglv-sc-edit-badges" title="${isZh ? '编辑徽章' : 'Edit badges'}" aria-label="${isZh ? '编辑徽章' : 'Edit badges'}">${ICONS.edit}</button>
            </div>` : '';

        return `
                <!-- 英雄区 -->
                <div class="sglv-sc-hero">
                    <div class="sglv-sc-avatar-wrap">
                        ${avatarHtml}
                    </div>
                    <div class="sglv-sc-hero-info">
                        <div class="sglv-sc-hero-name-row">
                            <span class="sglv-sc-hero-name">${escHtml(profile.name)}</span>
                            ${levelBadgeHtml}
                            ${countryHtml}
                        </div>
                        <div class="sglv-sc-hero-stats">
                            <div class="sglv-sc-hero-stat">
                                ${ICONS.library}
                                <div>
                                    <div class="sglv-sc-hero-stat-val">${gameCount.toLocaleString()}</div>
                                    <div class="sglv-sc-hero-stat-label">${isZh ? '游戏' : 'Games'}</div>
                                </div>
                            </div>
                            <div class="sglv-sc-hero-stat">
                                ${ICONS.clock || ICONS.barChart}
                                <div>
                                    <div class="sglv-sc-hero-stat-val">${totalHours.toLocaleString()}h</div>
                                    <div class="sglv-sc-hero-stat-label">${isZh ? '总时长' : 'Hours'}</div>
                                </div>
                            </div>
                            ${steamBadgeCount > 0 ? `<div class="sglv-sc-hero-stat">
                                ${ICONS.achievement}
                                <div>
                                    <div class="sglv-sc-hero-stat-val">${steamBadgeCount}</div>
                                    <div class="sglv-sc-hero-stat-label">${isZh ? '成就' : 'Ach'}</div>
                                </div>
                            </div>` : ''}
                            <div class="sglv-sc-hero-stat">
                                ${ICONS.trophy}
                                <div>
                                    <div class="sglv-sc-hero-stat-val">${totalAchPts.toLocaleString()}</div>
                                    <div class="sglv-sc-hero-stat-label">${isZh ? '点数' : 'Pts'}</div>
                                </div>
                            </div>
                        </div>
                    </div>
                    ${badgeAreaHtml}
                </div>`;
    }

    // v2.11.20 (FEAT-013 TASK-007): 封面网格卡片段（含编辑入口,自 _renderShowcaseContent 拆出,纯搬移）
    function _showcaseCoverCardHtml(coverAppIds, gameMap) {
        // === 封面网格 HTML ===
        const coverItemsHtml = [];
        for (let i = 0; i < 8; i++) {
            const appid = coverAppIds[i];
            if (appid) {
                const g = gameMap.get(appid);
                const hours = g ? Math.floor((g.playtime || 0) / 60) : 0;
                coverItemsHtml.push(`<div class="sglv-sc-cover-item" data-appid="${appid}" title="${escHtml(g ? g.name : '')}">
                    <img data-cover-appid="${appid}" alt="${escHtml(g ? g.name : '')}" loading="lazy" width="150" height="225">
                    <div class="sglv-sc-cover-overlay">
                        <div class="sglv-sc-cover-name">${escHtml(g ? g.name : '')}</div>
                        ${hours > 0 ? `<div class="sglv-sc-cover-hours">${hours}h</div>` : ''}
                    </div>
                </div>`);
            } else {
                coverItemsHtml.push(`<div class="sglv-sc-cover-item"><div class="sglv-sc-cover-placeholder">${isZh ? '空位' : 'Empty'}</div></div>`);
            }
        }
        return `
                        <!-- 封面网格 -->
                        <div class="sglv-sc-card">
                            <div class="sglv-sc-card-header">
                                ${ICONS.showcase}
                                <span class="sglv-sc-card-title">${isZh ? '我的游戏封面' : 'My Game Covers'}</span>
                                <button class="sglv-sc-edit-btn" id="sglv-sc-edit-covers">${ICONS.edit}<span>${isZh ? '编辑' : 'Edit'}</span></button>
                            </div>
                            <div class="sglv-sc-card-body">
                                <div class="sglv-sc-cover-grid">
                                    ${coverItemsHtml.join('')}
                                </div>
                            </div>
                        </div>`;
    }

    // v2.11.20 (FEAT-013 TASK-007): 最近游玩时长卡片段（条形行经 hbarRow 工厂 cls:'sc',自 _renderShowcaseContent 拆出,纯搬移）
    function _showcasePlaytimeCardHtml(recentGamesDisplay, maxRecentPlaytime) {
        // === 最近游玩时长 HTML ===
        const playtimeListHtml = recentGamesDisplay.length > 0
            ? recentGamesDisplay.map(g => {
                const totalHours = Math.floor((g.playtime_forever || 0) / 60);
                const recentHours = Math.floor((g.playtime_2weeks || 0) / 60);
                const pct = maxRecentPlaytime > 0 ? Math.min(100, ((g.playtime_forever || 0) / maxRecentPlaytime) * 100) : 0;
                const recentLabel = g.playtime_2weeks > 0
                    ? `<span style="color:#06b6d4">${isZh ? '近2周' : '2w'}: ${recentHours}h</span>`
                    : '';
                const totalLabel = `<span style="color:#94a3b8">${isZh ? '总计' : 'Total'}: ${totalHours}h</span>`;
                return `<div class="sglv-sc-playtime-item">
                    <img class="sglv-sc-playtime-icon" src="${escHtml(g.iconUrl)}" alt="" loading="lazy" width="32" height="32"
                         onerror="this.onerror=null;_sglvIconFallback(this,'${g.appid}','${escHtml(g.img_icon_url || '')}')">
                    <div class="sglv-sc-playtime-info">
                        <div class="sglv-sc-playtime-name">${escHtml(g.name)}</div>
                        <div class="sglv-sc-playtime-meta">${recentLabel}${recentLabel && totalLabel ? '<span style="margin:0 5px;color:#475569">·</span>' : ''}${totalLabel}</div>
                        ${hbarRow({ cls: 'sc', pct })}
                    </div>
                </div>`;
            }).join('')
            : `<div class="sglv-sc-playtime-empty">${isZh ? '暂无最近游玩记录' : 'No recent playtime'}</div>`;
        return `
                        <!-- 最近游玩时长 -->
                        <div class="sglv-sc-card">
                            <div class="sglv-sc-card-header">
                                ${ICONS.clock || ICONS.barChart}
                                <span class="sglv-sc-card-title">${isZh ? '最近游玩时长' : 'Recent Playtime'}</span>
                            </div>
                            <div class="sglv-sc-card-body">
                                <div class="sglv-sc-playtime-list">
                                    ${playtimeListHtml}
                                </div>
                            </div>
                        </div>`;
    }

    // v2.11.20 (FEAT-013 TASK-007): 最近解锁成就卡片段（自 _renderShowcaseContent 拆出,纯搬移）
    function _showcaseAchCardHtml(recentAchs) {
        // === 最近解锁成就 HTML ===
        const achListHtml = recentAchs.length > 0
            ? recentAchs.map(a => `<div class="sglv-sc-ach-item rarity-${a.rarity}">
                <div class="sglv-sc-ach-icon">${a.icon}</div>
                <div class="sglv-sc-ach-info">
                    <div class="sglv-sc-ach-name">${escHtml(a.name)}</div>
                    <div class="sglv-sc-ach-meta">${escHtml(_formatRelTime(a.unlockedAt))}</div>
                </div>
                <div class="sglv-sc-ach-pts">+${a.pts}</div>
            </div>`).join('')
            : `<div class="sglv-sc-ach-empty">${isZh ? '暂无解锁的成就' : 'No unlocked achievements'}</div>`;
        return `
                        <!-- 最近解锁成就 -->
                        <div class="sglv-sc-card" style="margin-bottom:20px;">
                            <div class="sglv-sc-card-header">
                                ${ICONS.achievement}
                                <span class="sglv-sc-card-title">${isZh ? '最近解锁成就' : 'Recent Achievements'}</span>
                            </div>
                            <div class="sglv-sc-card-body">
                                <div class="sglv-sc-ach-list">
                                    ${achListHtml}
                                </div>
                            </div>
                        </div>`;
    }

    // v2.11.20 (FEAT-013 TASK-007): 玩家画像标签卡片段（含标签文案表,自 _renderShowcaseContent 拆出,纯搬移）
    function _showcaseTagCardHtml(unlockedCats) {
        // 玩家画像标签（基于已解锁的成就分类）
        const tagLabels = {
            collector: isZh ? '收藏家' : 'Collector',
            playtime: isZh ? '深度玩家' : 'Dedicated',
            mastery: isZh ? '完美主义' : 'Perfectionist',
            diversity: isZh ? '多元品味' : 'Diverse',
            loyalty: isZh ? '忠实粉丝' : 'Loyal',
            special: isZh ? '特殊成就' : 'Special',
        };
        // === 玩家画像标签 HTML ===
        const tagsHtml = unlockedCats.size > 0
            ? Array.from(unlockedCats).map(cat => `<span class="sglv-sc-tag sglv-sc-tag-${cat}">${tagLabels[cat] || cat}</span>`).join('')
            : `<span style="font-size:12px;color:#64748b;">${isZh ? '继续游玩解锁更多标签' : 'Play more to unlock tags'}</span>`;
        return `
                        <!-- 玩家画像标签 -->
                        <div class="sglv-sc-card">
                            <div class="sglv-sc-card-header">
                                ${ICONS.star || ICONS.achievement}
                                <span class="sglv-sc-card-title">${isZh ? '玩家画像' : 'Player Profile'}</span>
                            </div>
                            <div class="sglv-sc-tags">
                                ${tagsHtml}
                            </div>
                        </div>`;
    }

    // v2.11.20 (FEAT-013 TASK-007): 展柜后处理与事件绑定段（封面/图标 CDN 回退链 + 编辑/徽章/封面交互,自 _renderShowcaseContent 拆出,纯搬移）
    function _bindShowcaseEvents(parent, allGames, allBadges, coverAppIds, selectedBadges) {
        // === 后处理：设置封面图片 CDN 回退链 ===
        parent.querySelectorAll('img[data-cover-appid]').forEach(img => {
            const appid = parseInt(img.dataset.coverAppid, 10);
            if (appid) _applyCoverChain(img, appid);
        });

        // === 后处理：设置游戏图标 ===
        parent.querySelectorAll('img[data-icon-appid]').forEach(img => {
            const appid = parseInt(img.dataset.iconAppid, 10);
            const hash = img.dataset.iconHash || '';
            if (appid) _applyGameIcon(img, appid, hash);
        });

        // === 编辑封面按钮事件 ===
        const editBtn = parent.querySelector('#sglv-sc-edit-covers');
        if (editBtn) {
            editBtn.addEventListener('click', () => {
                _openCoverPicker(allGames, coverAppIds, (newAppIds) => {
                    const cfg = _loadShowcaseConfig();
                    _saveShowcaseConfig({ selectedAppIds: newAppIds, selectedBadgeIds: cfg.selectedBadgeIds || [] });
                    renderShowcaseTab(parent);
                    prepareShowcaseTabData(parent);
                });
            });
        }

        // v2.9.94: === 编辑徽章按钮事件 ===
        const editBadgeBtn = parent.querySelector('#sglv-sc-edit-badges');
        if (editBadgeBtn) {
            editBadgeBtn.addEventListener('click', () => {
                _openBadgePicker(allBadges, selectedBadges, (newBadgeIds) => {
                    const cfg = _loadShowcaseConfig();
                    _saveShowcaseConfig({ selectedAppIds: cfg.selectedAppIds || [], selectedBadgeIds: newBadgeIds });
                    renderShowcaseTab(parent);
                    prepareShowcaseTabData(parent);
                });
            });
        }

        // v2.9.94: === 徽章点击跳转 / 空位点击打开选择器 ===
        parent.querySelectorAll('.sglv-sc-hero-badge[data-badge-url]').forEach(item => {
            item.addEventListener('click', () => {
                const url = item.dataset.badgeUrl;
                if (url) window.open(url, '_blank');
            });
        });
        parent.querySelectorAll('.sglv-sc-hero-badge-empty').forEach(item => {
            item.addEventListener('click', () => {
                _openBadgePicker(allBadges, selectedBadges, (newBadgeIds) => {
                    const cfg = _loadShowcaseConfig();
                    _saveShowcaseConfig({ selectedAppIds: cfg.selectedAppIds || [], selectedBadgeIds: newBadgeIds });
                    renderShowcaseTab(parent);
                    prepareShowcaseTabData(parent);
                });
            });
        });

        // === 封面点击跳转 ===
        parent.querySelectorAll('.sglv-sc-cover-item[data-appid]').forEach(item => {
            item.addEventListener('click', () => {
                const appid = parseInt(item.dataset.appid, 10);
                if (appid) window.open(`https://store.steampowered.com/app/${appid}`, '_blank');
            });
        });
    }

    // v2.9.99: 展柜内容渲染（从预获取数据构建 HTML + 绑定事件）
    // v2.11.20 (FEAT-013 TASK-007): 降级为组装器——数据组装 + 五段渲染按文档序消费 + 事件绑定委托
    function _renderShowcaseContent(parent, data, allGames) {
        const { profile, recentGames, badges: allBadges, achievements, stats } = data;
        const gameCount = stats ? stats.gameCount : allGames.length;
        const totalHours = stats ? stats.totalHours : Math.floor(allGames.reduce((s, g) => s + (g.playtime || 0), 0) / 60);
        const achs = achievements || computeMyAchievementsCached();
        const unlockedAchs = achs.filter(a => a.unlocked);
        const achCount = unlockedAchs.length;
        const totalAchPts = unlockedAchs.reduce((s, a) => s + a.pts, 0);
        const steamBadgeCount = (stats && stats.steamBadgeCount) || (allBadges && allBadges.length) || profile.badgeCount || 0;

        // 封面 appid 列表
        const coverAppIds = _getShowcaseCoverAppIds(allGames);
        const gameMap = new Map(allGames.map(g => [g.appid, g]));

        // 最近游玩游戏（API 已按最近游玩时间排序，取前 6 个）
        const recentGamesDisplay = (recentGames || []).slice(0, 6);
        const maxRecentPlaytime = recentGamesDisplay.length > 0
            ? Math.max(...recentGamesDisplay.map(g => g.playtime_forever || 0)) : 0;

        // 最近解锁成就（按 unlockedAt 降序，最多 6 个）
        const recentAchs = unlockedAchs
            .filter(a => a.unlockedAt)
            .sort((a, b) => b.unlockedAt - a.unlockedAt)
            .slice(0, 6);

        // 玩家画像标签（基于已解锁的成就分类）
        const unlockedCats = new Set(unlockedAchs.map(a => a.cat));

        // v2.9.94: 选中徽章组装层一次计算（英雄区段与事件绑定共享）
        const selectedBadges = _getSelectedShowcaseBadges(allBadges);

        // === 组装完整 HTML（五段按文档序） ===
        const html = `
        <div class="sglv-sc-wrap">
            <div class="sglv-sc-scroll">
                ${_showcaseHeroHtml(profile, gameCount, totalHours, steamBadgeCount, totalAchPts, allBadges, selectedBadges)}

                <!-- 双栏布局 -->
                <div class="sglv-sc-cols">
                    <!-- 左栏：封面网格 + 最近游玩 -->
                    <div class="sglv-sc-left">
                        ${_showcaseCoverCardHtml(coverAppIds, gameMap)}
                        ${_showcasePlaytimeCardHtml(recentGamesDisplay, maxRecentPlaytime)}
                    </div>

                    <!-- 右栏：最近成就 + 画像标签 -->
                    <div class="sglv-sc-right">
                        ${_showcaseAchCardHtml(recentAchs)}
                        ${_showcaseTagCardHtml(unlockedCats)}
                    </div>
                </div>
            </div>
        </div>`;

        parent.innerHTML = html;
        _bindShowcaseEvents(parent, allGames, allBadges, coverAppIds, selectedBadges);
    }

    // 封面选择器弹窗（内嵌于游戏库浮窗内，不隐藏浮窗本身）
    // v2.11.16 (FEAT-013 TASK-003): 迁移 openPickerModal 工厂,签名不变(无分页,候选 120 上限保持)
    function _openCoverPicker(allGames, currentSelected, onSave) {
        // 候选游戏列表（按游玩时间降序，最多展示前 120 个）
        const candidates = allGames
            .filter(g => (g.playtime || 0) > 0)
            .sort((a, b) => (b.playtime || 0) - (a.playtime || 0))
            .slice(0, 120);

        openPickerModal({
            overlayId: 'sglv-sc-picker-overlay',
            idBase: 'sglv-sc-picker',
            title: isZh ? '选择展柜封面（最多 8 张）' : 'Select Showcase Covers (max 8)',
            searchPlaceholder: isZh ? '搜索游戏…' : 'Search games…',
            searchAria: isZh ? '搜索游戏' : 'Search games',
            gridCls: 'sglv-sc-picker-grid',
            countInit: currentSelected.length,
            maxSelect: 8,
            saveText: isZh ? '保存' : 'Save',
            currentSelected,
            getItems: (searchVal) => {
                const filterLower = (searchVal || '').toLowerCase().trim();
                return filterLower
                    ? candidates.filter(g => (g.name || '').toLowerCase().includes(filterLower) || String(g.appid).includes(filterLower))
                    : candidates;
            },
            itemKey: g => g.appid,
            renderItem: (g, isSelected) => {
                const hours = Math.floor((g.playtime || 0) / 60);
                return `<div class="sglv-sc-picker-item ${isSelected ? 'selected' : ''}" data-appid="${g.appid}" title="${escHtml(g.name)}">
                    <img data-cover-appid="${g.appid}" alt="${escHtml(g.name)}" loading="lazy" width="100" height="150">
                    <div class="sglv-sc-picker-check">✓</div>
                    <div class="sglv-sc-picker-item-name">${escHtml(g.name)} (${hours}h)</div>
                </div>`;
            },
            itemSelector: '.sglv-sc-picker-item',
            keyFromItem: el => parseInt(el.dataset.appid, 10),
            // 渲染后设置封面图片(三级降级链)
            onGridRendered: (grid) => {
                grid.querySelectorAll('img[data-cover-appid]').forEach(img => {
                    const appid = parseInt(img.dataset.coverAppid, 10);
                    if (appid) _applyCoverChain(img, appid);
                });
            },
            buildResult: selected => Array.from(selected),
            maxWarningText: isZh ? '最多选择 8 张封面' : 'Max 8 covers',
            savedToastText: isZh ? '展柜封面已更新' : 'Showcase covers updated',
            onSave,
        });
    }

    // ==================== 渲染主体 ====================
    // v2.11.22 (FEAT-013 TASK-009): Tab 渲染分发表——8 Tab 入口集中注册,
    // renderBody 由 if-else 链改表查找;needsOwned 标记依赖 ownedGames 的 Tab
    // (原 _ownedDepTabs 数组语义内联,新 Tab 一处注册全生效);
    // v2.11.35 (FEAT-015 TASK-002): 新增 prepare 数据准备项(对齐 SGIS renderTab 模式),
    // 渲染函数只消费数据,带副作用 fetch 的 Tab 单独注册 prepare
    // 未注册 Tab 空渲染 + 警告(与原 if-else 链末端无匹配行为一致)
    const TAB_RENDERERS = {
        owned: { render: renderOwnedTab, needsOwned: true, prepare: prepareOwnedTabData },
        showcase: { render: renderShowcaseTab, needsOwned: true, prepare: prepareShowcaseTabData },
        playtime: { render: renderPlaytimeTab, needsOwned: true },
        trend: { render: renderTrendTab, needsOwned: true },
        playdata: { render: renderPlaydataTab, needsOwned: true },
        achievements: { render: renderMyAchievementsTab, needsOwned: true },
        cloudsave: { render: renderCloudSaveTab, prepare: prepareCloudSaveTabData },
        wishlist: { render: renderWishlistTab },
    };

    function renderBody() {
        const body = panelEl.querySelector('#sglv-body');
        if (!body) { console.warn('[SGLV] #sglv-body 未找到，跳过渲染'); return; }
        body.innerHTML = '';

        try {
        // v2.9.28: 同步设置按钮高亮态（设置视图覆盖展示时点亮 ⚙）
        const _setBtn = panelEl.querySelector('.sglv-settings-btn');
        if (_setBtn) _setBtn.classList.toggle('sglv-active', !!state.showSettings);

        if (state.showSettings) {
            // v2.9.28: 设置内容直接覆盖渲染在游戏库浮窗内（不再弹出独立浮层）
            renderSettingsView(body);
            return;
        }

        // v2.9.22: 依赖 ownedGames 的标签页（TAB_RENDERERS.needsOwned）在无数据时
        // 显示友好的占位骨架而非纯空白——
        //  - 若正在获取：spinner + 阶段进度提示
        //  - 若无缓存且未在获取：空状态 + "立即获取 / 打开设置" 引导按钮
        // wishlist 标签页自带 loading 骨架，不在此拦截
        const spec = TAB_RENDERERS[state.activeTab];
        if (spec && spec.needsOwned && state.ownedGames.length === 0) {
            body.appendChild(_buildOwnedEmptyPlaceholder());
            return;
        }

        // v2.11.22 (FEAT-013 TASK-009): 表查找分发,未注册 Tab 空渲染 + 警告
        if (spec) {
            spec.render(body);
            // v2.11.35 (FEAT-015 TASK-002): 渲染后追加数据准备步骤(fetch 外提),
            // 对齐 SGIS renderTab 的 prepare 模式;无 prepare 项的 Tab 不变
            if (spec.prepare) spec.prepare(body);
        } else {
            console.warn('[SGLV] 未知标签页，跳过渲染:', state.activeTab);
        }
        } catch (e) {
            // v2.9.109: 渲染失败时显示错误提示，不留空白面板
            console.error('[SGLV] renderBody 渲染失败:', e);
            body.innerHTML = `<div style="padding:40px 20px;text-align:center;color:#94a3b8;">`
                + `<p style="font-size:14px;margin-bottom:8px;">${isZh ? '渲染失败' : 'Render failed'}</p>`
                + `<p style="font-size:12px;color:#64748b;">${(e.message || String(e)).replace(/</g, '&lt;')}</p>`
                + `<p style="font-size:11px;margin-top:8px;color:#475569;">${isZh ? '请尝试切换其他标签页或刷新页面' : 'Try switching tabs or refresh the page'}</p>`
                + `</div>`;
        }
    }

    // v2.9.22: ownedGames 空数据占位骨架
    function _buildOwnedEmptyPlaceholder() {
        const wrap = document.createElement('div');
        wrap.className = 'sglv-body-loading';
        const hasKey = !!storage.getApiKey();
        const fetching = !!state.isLoading;
        if (fetching) {
            wrap.innerHTML = `
                <div class="sglv-bl-spinner"></div>
                <div class="sglv-bl-title">${isZh ? '正在获取你的游戏库…' : 'Fetching your library…'}</div>
                <div class="sglv-bl-tip">${isZh ? '首次访问需要从 Steam 拉取库存与时长，请稍候片刻。' : 'First-time load: fetching library and playtime from Steam. Please wait.'}</div>
            `;
        } else {
            wrap.innerHTML = `
                <div style="font-size:38px;line-height:1;opacity:0.7">🎮</div>
                <div class="sglv-bl-title">${isZh ? '游戏库尚未获取' : 'Library not loaded yet'}</div>
                <div class="sglv-bl-tip">${isZh
                    ? '点击下方按钮从 Steam 拉取你的库存与游戏时长（' + (hasKey ? '已配置 API Key' : '未配置 API Key，将自动尝试无 Key 抓取') + '）。'
                    : 'Click below to fetch your library & playtime from Steam (' + (hasKey ? 'API Key configured' : 'no API Key, fallback scraping') + ').'}</div>
                <div class="sglv-bl-actions">
                    <button class="sglv-bl-btn primary" data-act="fetch">${isZh ? '立即获取' : 'Fetch now'}</button>
                    <button class="sglv-bl-btn" data-act="settings">${isZh ? '打开设置' : 'Open settings'}</button>
                </div>
            `;
            wrap.querySelector('[data-act="fetch"]').addEventListener('click', () => {
                wrap.innerHTML = `
                    <div class="sglv-bl-spinner"></div>
                    <div class="sglv-bl-title">${isZh ? '正在获取你的游戏库…' : 'Fetching your library…'}</div>
                    <div class="sglv-bl-tip">${isZh ? '请稍候片刻。' : 'Please wait a moment.'}</div>
                `;
                startFetch(true);
            });
            wrap.querySelector('[data-act="settings"]').addEventListener('click', () => {
                openGlobalSettings();
            });
        }
        return wrap;
    }

    // ==================== 趋势标签页 ====================
    // v2.11.23 (FEAT-013 TASK-010 回归收口): KPI 段渲染器——8 卡值计算 + 双行 kpiCards 组装,
    // 自 renderTrendTab 拆出(Feature Success Criterion 4: 8 Tab 入口均 ≤150 行,纯搬移)
    function _trendKpiCardsHtml(yearlyStats, personalTotal, totalGames, allGames) {
        const now = new Date();
        const thisYear = now.getFullYear();
        const yearCount = yearlyStats.years.length;
        const thisYearIdx = yearlyStats.years.indexOf(thisYear);
        const thisYearCount = thisYearIdx >= 0 ? yearlyStats.counts[thisYearIdx] : 0;
        const avgPerYear = yearCount > 0 ? Math.round(yearlyStats.total / yearCount) : 0;
        const peakYearIdx = yearlyStats.counts.indexOf(Math.max(...yearlyStats.counts));
        const peakYear = yearlyStats.years[peakYearIdx] || '-';
        const peakYearCount = yearlyStats.counts[peakYearIdx] || 0;

        // 近30天/近90天入库数
        const nowTs = Math.floor(now.getTime() / 1000);
        const days30 = nowTs - 30 * 86400;
        const days90 = nowTs - 90 * 86400;
        let recent30 = 0, recent90 = 0;
        allGames.forEach(g => {
            const t = g.acquiredTime || 0;
            if (t <= 0) return;
            if (t >= days30) recent30++;
            if (t >= days90) recent90++;
        });

        // 周均入库
        // v2.9.48: 活跃天数（有入库记录的独立天数）
        const activeDateSet = new Set();
        allGames.forEach(g => {
            const t = g.acquiredTime || 0;
            if (t <= 0) return;
            const d = new Date(t * 1000);
            activeDateSet.add(d.getFullYear() + '-' + d.getMonth() + '-' + d.getDate());
        });
        const activeDays = activeDateSet.size;

        const firstYear = yearlyStats.years[0] || '-';
        const lastYear = yearlyStats.years[yearlyStats.years.length - 1] || '-';

        // v2.9.48: 第一行 4 卡 —— 基础统计；v2.11.1 改经 kpiCards 工厂(tone:trend)
        const kpiRow1 = kpiCards([
            { icon: ICONS.library, label: isZh ? '我的游戏' : 'My Games', value: personalTotal.toLocaleString(), sub: T.kpiMyCollection, color: 'mine' },
            { icon: ICONS.share, label: isZh ? '家庭组合并' : 'Family Total', value: totalGames.toLocaleString(), sub: T.kpiDedupMerge, color: 'total' },
            { icon: ICONS.calendar, label: T.trendKpiThisYear, value: thisYearCount, unit: T.trendKpiGames, sub: thisYear, color: 'blue' },
            { icon: ICONS.calendar, label: isZh ? '年份范围' : 'Year Range', value: `${firstYear} ~ ${lastYear}`, sub: `${lastYear - firstYear + 1} ${T.kpiYearSpan}`, color: 'gray' },
        ], { tone: 'trend' });

        // v2.9.48: 第二行 4 卡 —— 频率维度；v2.11.1 改经 kpiCards 工厂(tone:trend)
        const kpiRow2 = kpiCards([
            { icon: ICONS.trend, label: T.trendKpiAvgYear, value: avgPerYear, unit: T.trendKpiGames, sub: isZh ? '年均入库量' : 'per year', color: 'green' },
            { icon: ICONS.trend, label: T.trendKpiPeakYear, value: peakYear, sub: `${peakYearCount} ${T.trendKpiGames}`, color: 'orange' },
            { icon: ICONS.clock, label: T.trendKpiRecent30, value: recent30, unit: T.trendKpiGames, sub: `${recent90} ${isZh ? '近90天' : '/ 90d'}`, color: 'cyan' },
            { icon: ICONS.clock, label: T.trendKpiActiveDays, value: activeDays, unit: isZh ? '天' : 'days', sub: isZh ? `日均 ${activeDays > 0 ? (totalGames / activeDays).toFixed(1) : '0'} 款` : `${activeDays > 0 ? (totalGames / activeDays).toFixed(1) : '0'} / day`, color: 'purple' },
        ], { tone: 'trend' });

        return `<div class="sglv-trend-kpi-row sglv-trend-kpi-row-compact">${kpiRow1}</div><div class="sglv-trend-kpi-row sglv-trend-kpi-row-compact">${kpiRow2}</div>`;
    }

    function renderTrendTab(parent) {
        const wrap = document.createElement('div');
        wrap.className = 'sglv-trend-wrap';

        if (state.ownedGames.length === 0) {
            wrap.innerHTML = emptyHtml(T.noData);
            parent.appendChild(wrap);
            return;
        }

        const hasAcquiredTime = state.ownedGames.some(g => g.acquiredTime > 0);
        const isEstimated = !hasAcquiredTime;

        // ====== 基础数据统计（始终计算）======
        const allGames = state.ownedGames;
        const totalGames = allGames.length; // 家庭组合并总数

        // 获取当前用户 Steam ID
        const steamId = getActiveSteamId();

        // 筛选仅个人拥有的游戏（基于 owners 字段）
        let personalGames = [];
        if (steamId) {
            personalGames = allGames.filter(g => {
                const owners = g.owners || [];
                return owners.length === 0 || owners.includes(steamId);
            });
        } else {
            personalGames = allGames; // 无 steamId 时视为全部是自己的
        }
        const personalTotal = personalGames.length;

        // 检测是否有家庭组 owners 数据（用于决定是否显示双曲线）
        const hasOwnerData = steamId && allGames.some(g => g.owners && g.owners.length > 0);

        // 家庭组其他成员（排除自己，避免主柱与"我的"成员柱视觉重叠）
        const otherMembers = [];
        if (storage.getShowFamilyShared() && hasOwnerData && steamId) {
            const familyInfo = storage.getFamilyInfo();
            const nameMap = familyInfo?.steamIdtoName || {};
            otherMembers.push(...Object.entries(nameMap)
                .filter(([sid]) => sid !== steamId)
                .map(([sid, name]) => ({ steamid: sid, name })));
        }

        // v2.9.50: 一次性计算所有年度统计并走 PCC 持久化缓存(跨 session 复用,避免每次开面板都重算)
        // 旧实现:分别调用 computeYearlyStats / computePersonalYearlyStats / computeFamilyMemberCumulativeStats / computeFamilyYearlyStats
        //         共 4 次遍历 allGames,大库存(数千款)时 ~10-30ms × 4 ≈ 几十 ms,且每次开面板都重算
        // 新实现:一次遍历 + 签名匹配直接走缓存
        const _yearlyAll = computeYearlyStatsAllCached(allGames, steamId, otherMembers);
        const yearlyStats = _yearlyAll.yearly;
        const personalYearlyStats = _yearlyAll.personal;
        const familyCumStats = _yearlyAll.familyCum;
        const familyYearlyStats = _yearlyAll.familyYearly;

        // ====== v2.9.48: 8 个 KPI 卡片分两行显示，增加入库频率维度 ======
        // v2.11.23 (FEAT-013 TASK-010 回归收口): KPI 值计算与双行组装拆至 _trendKpiCardsHtml
        const kpiSection = document.createElement('div');
        kpiSection.className = 'sglv-trend-kpi-wrap';
        kpiSection.innerHTML = _trendKpiCardsHtml(yearlyStats, personalTotal, totalGames, allGames);

        // ====== v2.4.3: 入库趋势动态——左侧入库趋势图（不变）+ 右侧入库时间线 ======
        // v2.9.22: KPI 紧凑放到左半侧顶部，时间线在右半侧从页面顶部开始撑满整个高度
        const splitRow = document.createElement('div');
        splitRow.className = 'sglv-trend-split';

        // 左：KPI（紧凑 4 列）+ 入库趋势图（年度新增柱 + 家庭成员明细柱 + 累计折线）
        const leftCol = document.createElement('div');
        leftCol.className = 'sglv-trend-split-left';
        leftCol.appendChild(kpiSection);
        leftCol.insertAdjacentHTML('beforeend', `
            <div class="sglv-trend-section sglv-trend-section-main">
                <div class="sglv-playtime-section-title">${ICONS.trend} ${T.trendChartTitle}</div>
                <div class="sglv-trend-chart" id="sglv-trend-chart-main"></div>
            </div>
        `);
        splitRow.appendChild(leftCol);

        // 右：v2.9.48 标签切换（入库时间线 / 入库频率分析）
        const rightCol = document.createElement('div');
        rightCol.className = 'sglv-trend-split-right';
        rightCol.innerHTML = `
            <div class="sglv-tl-section">
                <div class="sglv-trend-right-tabs" id="sglv-trend-right-tabs">
                    <button class="sglv-trend-right-tab active" data-tab="timeline">${ICONS.package} ${T.trendTabTimeline}</button>
                    <button class="sglv-trend-right-tab" data-tab="frequency">${ICONS.trend} ${T.trendTabFrequency}</button>
                </div>
                <div class="sglv-trend-right-content" id="sglv-trend-right-timeline">
                    <div class="sglv-tl-toolbar">
                        <div class="sglv-tl-count"><span class="sglv-tl-count-num" id="sglv-tl-count">-</span><span class="sglv-tl-count-label">${T.trendTimelineTotal}</span></div>
                        <input class="sglv-tl-search" id="sglv-tl-search" type="text" placeholder="${T.searchPlaceholder}">
                    </div>
                    <div class="sglv-tl-scroll" id="sglv-tl-scroll">${emptyHtml(T.ptHeatmapLoading)}</div>
                    <div class="sglv-tl-pagination" id="sglv-tl-pagination"></div>
                </div>
                <div class="sglv-trend-right-content" id="sglv-trend-right-frequency" style="display:none">
                    <div class="sglv-trend-freq-loading" id="sglv-trend-freq-loading">${createLoadingHtml(T.trendFreqTitle, 28)}</div>
                    <div class="sglv-trend-freq-content" id="sglv-trend-freq-content" style="display:none"></div>
                </div>
            </div>
        `;
        splitRow.appendChild(rightCol);
        wrap.appendChild(splitRow);

        // v2.9.49: 使用 requestAnimationFrame 替代 setTimeout，对齐浏览器渲染周期减少卡顿
        requestAnimationFrame(() => renderTrendChart(yearlyStats, leftCol.querySelector('#sglv-trend-chart-main'), { isEstimated, familyCumStats, personalYearlyStats, familyYearlyStats, hasOwnerData }));
        renderAcquiredTimeline(rightCol, allGames);

        // v2.9.48: 右侧标签切换
        const freqLoaded = { done: false };
        rightCol.querySelectorAll('.sglv-trend-right-tab').forEach(tab => {
            tab.addEventListener('click', () => {
                rightCol.querySelectorAll('.sglv-trend-right-tab').forEach(t => t.classList.remove('active'));
                tab.classList.add('active');
                const target = tab.dataset.tab;
                rightCol.querySelector('#sglv-trend-right-timeline').style.display = target === 'timeline' ? '' : 'none';
                rightCol.querySelector('#sglv-trend-right-frequency').style.display = target === 'frequency' ? '' : 'none';
                // 懒加载频率分析
                if (target === 'frequency' && !freqLoaded.done) {
                    freqLoaded.done = true;
                    renderFrequencyAnalysis(rightCol.querySelector('#sglv-trend-freq-content'), rightCol.querySelector('#sglv-trend-freq-loading'), allGames);
                }
            });
        });

        if (isEstimated) {
            const note = document.createElement('div');
            note.className = 'sglv-trend-note';
            note.innerHTML = `${isZh ? '提示：当前数据缺少精确入库时间，趋势图基于“最近游玩时间”估算。登录 Steam 商店或获取家庭组数据后可获得更精确结果。' : 'Note: Precise acquisition time is unavailable; trend is estimated from last-played time.'}`;
            wrap.appendChild(note);
        }

        parent.appendChild(wrap);
    }

    // ====== v2.9.48: 入库频率分析——带缓存的统计计算 + 图表渲染 ======
    // v2.11.17 (FEAT-013 TASK-004) 豁免留痕: 频次图为 SVG 柱状图(rect,月12/周7/时24柱+峰值高亮+hover tooltip),
    // 与 hbarRow 水平 track/fill 条形结构不同源(HBAR_NS 无 freq 命名空间),强行接入需改 DOM class
    // 违反「趋势 Tab DOM class 不变」约束,保持原实现。
    let _freqStatsCache = null; // { sig, stats, ts }

    function computeFreqStats(games) {
        const sig = games.length + '|' + (games[0]?.appid || 0);
        if (_freqStatsCache && _freqStatsCache.sig === sig) return _freqStatsCache.stats;

        const monthData = new Array(12).fill(0);       // 0-11 月度
        const weekdayData = new Array(7).fill(0);      // 0-6 周日~周六
        const hourData = new Array(24).fill(0);         // 0-23 时段
        const dateMap = {};                              // 'YYYY-MM-DD' → count
        let total = 0;

        for (const g of games) {
            const t = g.acquiredTime || 0;
            if (t <= 0) continue;
            const d = new Date(t * 1000);
            monthData[d.getMonth()]++;
            weekdayData[d.getDay()]++;
            hourData[d.getHours()]++;
            const dk = d.getFullYear() + '-' + String(d.getMonth() + 1).padStart(2, '0') + '-' + String(d.getDate()).padStart(2, '0');
            dateMap[dk] = (dateMap[dk] || 0) + 1;
            total++;
        }

        // 最长连续入库天数
        const sortedDates = Object.keys(dateMap).sort();
        let maxStreak = 0, curStreak = 0;
        let prevDate = null;
        for (const ds of sortedDates) {
            if (prevDate) {
                const diff = (new Date(ds) - new Date(prevDate)) / 86400000;
                curStreak = diff === 1 ? curStreak + 1 : 1;
            } else {
                curStreak = 1;
            }
            if (curStreak > maxStreak) maxStreak = curStreak;
            prevDate = ds;
        }

        // 峰值月份/星期/时段
        const monthNames = isZh
            ? ['1月','2月','3月','4月','5月','6月','7月','8月','9月','10月','11月','12月']
            : ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'];
        const weekdayNames = T.trendFreqWeekdayLong.split(',');
        const peakMonth = monthNames[monthData.indexOf(Math.max(...monthData))] || '-';
        const peakWeekday = weekdayNames[weekdayData.indexOf(Math.max(...weekdayData))] || '-';
        const peakHour = hourData.indexOf(Math.max(...hourData));
        const peakHourLabel = peakHour >= 0 ? String(peakHour).padStart(2, '0') + ':00 ~ ' + String((peakHour + 1) % 24).padStart(2, '0') + ':00' : '-';

        const stats = {
            monthData, weekdayData, hourData,
            total, maxStreak,
            peakMonth, peakWeekday, peakHourLabel,
            peakMonthCount: Math.max(...monthData),
            peakWeekdayCount: Math.max(...weekdayData),
            peakHourCount: Math.max(...hourData),
            monthNames, weekdayNames,
            uniqueDays: sortedDates.length,
        };

        _freqStatsCache = { sig, stats, ts: Date.now() };
        return stats;
    }

    function renderFrequencyAnalysis(contentEl, loadingEl, games) {
        // 异步获取入库时间数据（增量更新，复用缓存）
        (async () => {
            try {
                // v2.11.42: 个人拥有的游戏按个人许可页日期校准（家人新入库共拥游戏不改变我的入库日期）
                const { map: acquiredMap } = await buildCalibratedAcquiredMap();
                // 合并 acquiredTime 到 games
                const enriched = games.map(g => ({
                    ...g,
                    acquiredTime: acquiredMap[g.appid] || g.acquiredTime || 0,
                }));

                const stats = computeFreqStats(enriched);
                const wdNames = stats.weekdayNames;

                // 月度柱状图 SVG
                const monthMax = Math.max(...stats.monthData, 1);
                const monthBars = stats.monthData.map((v, i) => {
                    const h = v > 0 ? Math.max(2, (v / monthMax) * 100) : 0;
                    const x = i * (100 / 12) + 1;
                    const isPeak = v === stats.peakMonthCount && v > 0;
                    return `<rect x="${x}%" y="${100 - h}" width="${100 / 12 - 2}%" height="${h}" rx="2" fill="${isPeak ? SGLVCharts.accent() : 'rgba(102,192,244,0.6)'}" data-v="${v}" data-l="${stats.monthNames[i]}"/>`;
                }).join('');

                // 星期柱状图
                const wdMax = Math.max(...stats.weekdayData, 1);
                const wdBars = stats.weekdayData.map((v, i) => {
                    const h = v > 0 ? Math.max(2, (v / wdMax) * 100) : 0;
                    const x = i * (100 / 7) + 1;
                    const isPeak = v === stats.peakWeekdayCount && v > 0;
                    return `<rect x="${x}%" y="${100 - h}" width="${100 / 7 - 2}%" height="${h}" rx="3" fill="${isPeak ? '#f59e0b' : 'rgba(52,211,153,0.6)'}" data-v="${v}" data-l="${wdNames[i]}"/>`;
                }).join('');

                // 时段柱状图
                const hrMax = Math.max(...stats.hourData, 1);
                const hrBars = stats.hourData.map((v, i) => {
                    const h = v > 0 ? Math.max(2, (v / hrMax) * 100) : 0;
                    const x = i * (100 / 24) + 0.3;
                    const isPeak = v === stats.peakHourCount && v > 0;
                    return `<rect x="${x}%" y="${100 - h}" width="${100 / 24 - 0.6}%" height="${h}" rx="1" fill="${isPeak ? '#ec4899' : 'rgba(167,139,250,0.5)'}" data-v="${v}" data-l="${String(i).padStart(2,'0')}${T.trendFreqHrLabel}"/>`;
                }).join('');

                contentEl.innerHTML = `
                    <div class="sglv-freq-scroll">
                        <!-- 频率摘要 -->
                        <div class="sglv-freq-summary-row">
                            <div class="sglv-freq-summary-card"><span class="sglv-freq-summary-label">${T.trendFreqPeakMonth}</span><span class="sglv-freq-summary-value">${stats.peakMonth}</span><span class="sglv-freq-summary-sub">${stats.peakMonthCount} ${T.trendKpiGames}</span></div>
                            <div class="sglv-freq-summary-card"><span class="sglv-freq-summary-label">${T.trendFreqPeakWeekday}</span><span class="sglv-freq-summary-value">${stats.peakWeekday}</span><span class="sglv-freq-summary-sub">${stats.peakWeekdayCount} ${T.trendKpiGames}</span></div>
                            <div class="sglv-freq-summary-card"><span class="sglv-freq-summary-label">${T.trendFreqPeakHour}</span><span class="sglv-freq-summary-value" style="font-size:13px">${stats.peakHourLabel}</span><span class="sglv-freq-summary-sub">${stats.peakHourCount} ${T.trendKpiGames}</span></div>
                            <div class="sglv-freq-summary-card"><span class="sglv-freq-summary-label">${T.trendFreqStreak}</span><span class="sglv-freq-summary-value">${stats.maxStreak}</span><span class="sglv-freq-summary-sub">${T.trendFreqDays}</span></div>
                        </div>

                        <!-- 月度入库频率 -->
                        <div class="sglv-freq-chart-section">
                            <div class="sglv-freq-chart-title">${T.trendFreqByMonth}</div>
                            <div class="sglv-freq-chart" id="sglv-freq-month-chart">
                                <svg viewBox="0 0 100 110" preserveAspectRatio="none" style="width:100%;height:120px">
                                    <line x1="0" y1="100" x2="100" y2="100" stroke="rgba(148,163,184,0.15)" stroke-width="0.3"/>
                                    ${monthBars}
                                </svg>
                                <div class="sglv-freq-chart-labels">${stats.monthNames.map(m => `<span>${m}</span>`).join('')}</div>
                            </div>
                        </div>

                        <!-- 星期分布 -->
                        <div class="sglv-freq-chart-section">
                            <div class="sglv-freq-chart-title">${T.trendFreqByWeekday}</div>
                            <div class="sglv-freq-chart">
                                <svg viewBox="0 0 100 110" preserveAspectRatio="none" style="width:100%;height:90px">
                                    <line x1="0" y1="100" x2="100" y2="100" stroke="rgba(148,163,184,0.15)" stroke-width="0.3"/>
                                    ${wdBars}
                                </svg>
                                <div class="sglv-freq-chart-labels">${wdNames.map(w => `<span>${w}</span>`).join('')}</div>
                            </div>
                        </div>

                        <!-- 时段分布 -->
                        <div class="sglv-freq-chart-section">
                            <div class="sglv-freq-chart-title">${T.trendFreqByHour}</div>
                            <div class="sglv-freq-chart">
                                <svg viewBox="0 0 100 110" preserveAspectRatio="none" style="width:100%;height:90px">
                                    <line x1="0" y1="100" x2="100" y2="100" stroke="rgba(148,163,184,0.15)" stroke-width="0.3"/>
                                    ${hrBars}
                                </svg>
                                <div class="sglv-freq-chart-labels sglv-freq-chart-labels-hr">${[0,3,6,9,12,15,18,21].map(h => `<span>${String(h).padStart(2,'0')}</span>`).join('')}</div>
                            </div>
                        </div>
                    </div>
                `;

                // 显示内容，隐藏 loading
                loadingEl.style.display = 'none';
                contentEl.style.display = '';

                // v2.9.49: 优化 bar hover tooltip——复用单一 DOM 元素，避免每次 hover 创建/销毁
                const freqTooltip = document.createElement('div');
                freqTooltip.className = 'sglv-freq-tooltip';
                freqTooltip.style.cssText = 'position:fixed;background:rgba(15,23,42,0.96);border:1px solid rgba(102,192,244,0.3);border-radius:6px;padding:4px 10px;font-size:11px;color:#fff;pointer-events:none;z-index:999;display:none;transform:translateX(-50%);';
                document.body.appendChild(freqTooltip);
                addDisposer(() => freqTooltip.remove());

                contentEl.querySelectorAll('.sglv-freq-chart svg rect[data-v]').forEach(rect => {
                    rect.addEventListener('mouseenter', function() {
                        const v = this.getAttribute('data-v');
                        const l = this.getAttribute('data-l');
                        this.setAttribute('opacity', '0.7');
                        freqTooltip.textContent = `${l}: ${v} ${T.trendKpiGames}`;
                        const r = this.getBoundingClientRect();
                        freqTooltip.style.left = (r.left + r.width / 2) + 'px';
                        freqTooltip.style.top = (r.top - 28) + 'px';
                        freqTooltip.style.display = '';
                    });
                    rect.addEventListener('mouseleave', function() {
                        this.setAttribute('opacity', '1');
                        freqTooltip.style.display = 'none';
                    });
                });
            } catch (e) {
                console.warn('[SGLV] 频率分析加载失败:', e);
                loadingEl.innerHTML = emptyHtml(T.ptHeatmapNoData);
            }
        })();
    }

    function renderAcquiredTimeline(container, games) {
        const scrollEl = container.querySelector('#sglv-tl-scroll');
        const countEl = container.querySelector('#sglv-tl-count');
        const searchEl = container.querySelector('#sglv-tl-search');
        const pagiEl = container.querySelector('#sglv-tl-pagination');
        if (!scrollEl || !countEl || !searchEl || !pagiEl) return;

        const PAGE_SIZE = 20; // 两列 × 10 行
        let allItems = null;   // null = 加载中
        let page = 1;
        let query = '';

        const fmtDateKey = (ts) => {
            const d = new Date(ts * 1000);
            return d.getFullYear() + '-' + String(d.getMonth() + 1).padStart(2, '0') + '-' + String(d.getDate()).padStart(2, '0');
        };
        const timeOfDay = (ts) => {
            const d = new Date(ts * 1000);
            return String(d.getHours()).padStart(2, '0') + ':' + String(d.getMinutes()).padStart(2, '0') + ':' + String(d.getSeconds()).padStart(2, '0');
        };

        function renderList() {
            if (!allItems) { scrollEl.innerHTML = createLoadingHtml(T.ptHeatmapLoading, 28); return; }
            const items = query ? allItems.filter(it => it.name.toLowerCase().includes(query)) : allItems;
            countEl.textContent = items.length;
            if (items.length === 0) {
                scrollEl.innerHTML = emptyHtml(T.ptHeatmapNoData);
                pagiEl.innerHTML = '';
                return;
            }
            // v2.11.17 (FEAT-013 TASK-004): 手写 Math.ceil/clamp/slice 分页收敛 paginate()(逻辑逐行同构)
            const pg = paginate(items, page, PAGE_SIZE);
            page = pg.page;
            // v2.11.17 (FEAT-013 TASK-004): 时间线卡迁移 renderGameView(card 模式+自定义命名空间),
            // itemPrefixHtml 注入日期分隔线(divider 为 grid 直接子元素,置于卡片之前)
            let curDate = null;
            scrollEl.innerHTML = renderGameView(pg.pageItems, {
                viewMode: 'card',
                gridCls: 'sglv-tl-grid',
                cardCls: 'sglv-tl-card',
                bodyCls: 'sglv-tl-card-info',
                bareImg: true,
                itemAttrs: (it) => ` onclick="window.open('https://store.steampowered.com/app/${it.appid}','_blank')"`,
                itemPrefixHtml: (it) => {
                    if (it.dateKey === curDate) return '';
                    curDate = it.dateKey;
                    return `<div class="sglv-tl-divider"><div class="sglv-tl-divider-line"></div><span class="sglv-tl-date">${curDate}</span><div class="sglv-tl-divider-line"></div></div>`;
                },
                imgHtml: (it) => headerImg(it.appid, it.name),
                bodyHtml: (it) => `<div class="sglv-tl-card-name" data-sglv-appid="${it.appid}" title="${it.name}">${it.name}</div><div class="sglv-tl-card-meta"><span class="sglv-tl-card-time">${timeOfDay(it.ts)}</span><span class="sglv-tl-card-check">✓</span></div>`,
            });
            // v2.3.33: 异步加载游戏中文名
            applyGameAliases(scrollEl);
            renderPagination(pagiEl, 'sglv-tl', page, pg.totalPages, items.length,
                () => { page--; renderList(); },
                () => { page++; renderList(); },
                (p) => { page = p; renderList(); });
        }

        // v2.9.49: debounce 搜索输入，避免时间线列表每次按键触发完整重渲染
        searchEl.addEventListener('input', debounce(() => {
            query = searchEl.value.trim().toLowerCase();
            page = 1;
            renderList();
        }, 200));

        renderList(); // 加载占位
        (async () => {
            try {
                // v2.11.42: 个人拥有的游戏按个人许可页日期校准（家人新入库共拥游戏不改变我的入库日期）
                const { games: familyGames, map: acquiredMap } = await buildCalibratedAcquiredMap();
                if (!familyGames || familyGames.length === 0) { allItems = []; renderList(); return; }
                allItems = games
                    .filter(g => acquiredMap[g.appid])
                    .map(g => ({ appid: g.appid, name: g.name || `App ${g.appid}`, ts: acquiredMap[g.appid], dateKey: fmtDateKey(acquiredMap[g.appid]) }))
                    .sort((a, b) => b.ts - a.ts);
            } catch (e) {
                console.warn('[SGLV] 入库时间线加载失败:', e);
                allItems = [];
            }
            renderList();
        })();
    }

    function computeYearlyStats(games) {
        const map = new Map();
        let total = 0;
        let maxCount = 0;
        games.forEach(g => {
            const t = g.acquiredTime || g.lastPlayed || 0;
            if (t <= 0) return;
            const year = new Date(t * 1000).getFullYear();
            const c = (map.get(year) || 0) + 1;
            map.set(year, c);
            total++;
            if (c > maxCount) maxCount = c;
        });
        if (map.size === 0) return { years: [], counts: [], cumulative: [], total: 0, maxCount: 0, maxCumulative: 0 };
        const minYear = Math.min(...map.keys());
        const maxYear = Math.max(...map.keys());
        const years = [];
        const counts = [];
        const cumulative = [];
        let cum = 0;
        for (let y = minYear; y <= maxYear; y++) {
            const c = map.get(y) || 0;
            cum += c;
            years.push(y);
            counts.push(c);
            cumulative.push(cum);
        }
        return { years, counts, cumulative, total, maxCount, maxCumulative: cum };
    }

    // 计算仅个人拥有的游戏年度统计（用于区分"我的"和"家庭组合并"）
    // refYears: 参考年份范围，确保输出与此对齐
    function computePersonalYearlyStats(games, steamId, refYears) {
        const map = new Map();
        let total = 0;
        let maxCount = 0;
        games.forEach(g => {
            const owners = g.owners || [];
            if (owners.length > 0 && !owners.includes(steamId)) return;
            const t = g.acquiredTime || g.lastPlayed || 0;
            if (t <= 0) return;
            const year = new Date(t * 1000).getFullYear();
            const c = (map.get(year) || 0) + 1;
            map.set(year, c);
            total++;
            if (c > maxCount) maxCount = c;
        });
        if (map.size === 0) return { years: [], counts: [], cumulative: [], total: 0, maxCount: 0, maxCumulative: 0 };

        // 使用 refYears 作为基准年份范围（与汇总统计对齐），缺失年份补 0
        const years = refYears ? [...refYears] : Array.from(map.keys()).sort((a, b) => a - b);
        const counts = [];
        const cumulative = [];
        let cum = 0;
        for (const y of years) {
            const c = map.get(y) || 0;
            cum += c;
            counts.push(c);
            cumulative.push(cum);
        }
        return { years, counts, cumulative, total, maxCount, maxCumulative: cum };
    }

    function computeFamilyMemberCumulativeStats(games, members, years) {
        if (!years || years.length === 0 || members.length === 0) return null;
        const yearlyMemberCounts = new Map();
        const memberIds = new Set(members.map(m => m.steamid));
        years.forEach(y => { yearlyMemberCounts.set(y, {}); });
        games.forEach(g => {
            const t = g.acquiredTime || g.lastPlayed || 0;
            if (t <= 0) return;
            const owners = g.owners || [];
            if (owners.length === 0) return;
            const year = new Date(t * 1000).getFullYear();
            const entry = yearlyMemberCounts.get(year);
            if (!entry) return;
            owners.forEach(sid => {
                if (memberIds.has(sid)) {
                    entry[sid] = (entry[sid] || 0) + 1;
                }
            });
        });

        // 为每个成员构建年度累计数组
        const resultMembers = members.map(m => {
            let cum = 0;
            const cumulative = years.map(y => {
                const entry = yearlyMemberCounts.get(y);
                cum += (entry ? (entry[m.steamid] || 0) : 0);
                return cum;
            });
            return { steamid: m.steamid, name: m.name, cumulative };
        });

        const maxCumulative = Math.max(...resultMembers.map(m => m.cumulative[m.cumulative.length - 1]), 1);

        return { years, members: resultMembers, maxCumulative };
    }

    function computeFamilyYearlyStats(games, members) {
        const yearsSet = new Set();
        const memberMap = new Map();
        members.forEach(m => memberMap.set(m.steamid, { name: m.name, counts: new Map() }));

        games.forEach(g => {
            const t = g.acquiredTime || g.lastPlayed || 0;
            if (t <= 0) return;
            const year = new Date(t * 1000).getFullYear();
            const owners = g.owners || [];
            members.forEach(m => {
                if (owners.includes(m.steamid)) {
                    yearsSet.add(year);
                    const counts = memberMap.get(m.steamid).counts;
                    counts.set(year, (counts.get(year) || 0) + 1);
                }
            });
        });

        const years = Array.from(yearsSet).sort((a, b) => a - b);
        if (years.length === 0) return { years: [], members: [] };

        const colors = ['#06cfbe', '#54a0ff', '#ff9f43', '#2ed573', '#ff6b6b', '#a29bfe', '#ffcd56'];
        const result = [];
        members.forEach((m, i) => {
            const data = memberMap.get(m.steamid);
            const counts = [];
            years.forEach(y => counts.push(data.counts.get(y) || 0));
            result.push({ steamid: m.steamid, name: m.name, counts, color: colors[i % colors.length] });
        });
        return { years, members: result };
    }

    // ==================== v2.9.50: 持久化版本(基于 PCC) ====================
    // 给大数据计算函数加缓存包装,通过输入签名 + schema 版本自动判断是否重算
    // 输入签名:游戏数 + acquiredTime 累计 + lastPlayed 累计(避免简单 length 不够,例如库存没变但补全了 acquiredTime)
    // schema 版本号:业务逻辑变更时手动 +1 强制全量重算
    const _BIZ_SCHEMA_YEARLY = 1;
    const _BIZ_SCHEMA_INSIGHT = 1;
    const _BIZ_SCHEMA_ACHIEVEMENTS = 1;

    // v2.9.50: 生成大数据计算输入签名(基于 ownedGames + familyInfo 关键字段)
    function _bizInputSig(games, extra) {
        let accSum = 0, lpSum = 0, ptSum = 0;
        const n = games ? games.length : 0;
        for (let i = 0; i < n; i++) {
            const g = games[i];
            accSum += (g && g.acquiredTime) || 0;
            lpSum += (g && g.lastPlayed) || 0;
            ptSum += (g && g.playtime) || 0;
        }
        return `${n}|${accSum}|${lpSum}|${ptSum}|${extra || ''}`;
    }

    // v2.9.50: 持久化年度统计(整体 + 个人 + 家庭组)
    // 返回 { yearly, personal, familyCum, familyYearly } 一次性计算所有
    function computeYearlyStatsAllCached(games, steamId, otherMembers) {
        const sig = _bizInputSig(games, `${steamId || ''}|${otherMembers ? otherMembers.length : 0}`);
        return getBizCached('biz_yearly_stats_all', _BIZ_SCHEMA_YEARLY, sig, () => {
            const yearly = computeYearlyStats(games);
            const personal = steamId ? computePersonalYearlyStats(games, steamId, yearly.years) : null;
            let familyCum = null;
            let familyYearly = null;
            if (otherMembers && otherMembers.length > 0 && yearly.years.length > 0) {
                familyCum = computeFamilyMemberCumulativeStats(games, otherMembers, yearly.years);
                familyYearly = computeFamilyYearlyStats(games, otherMembers);
            }
            return { yearly, personal, familyCum, familyYearly };
        });
    }

    // v2.9.50: 持久化我的成就标签页(computeMyAchievements)
    // 输入:state.ownedGames + familyInfo 关键字段 + DLC 状态(影响 gameCount)
    // 注意:我的成就结果依赖 unlockCache(解锁时间),但缓存内只存当前快照
    //      真正的解锁时间仍由 _getAchUnlockCache/_saveAchUnlockCache 管理(IDB 持久化)
    //      业务结果(每个成就的 current/unlocked/progress/pts)可缓存
    function computeMyAchievementsCached() {
        const allGames = getStatFilteredGames();
        const dlcReady = (SGLV_API.isDlcDbReady && SGLV_API.isDlcDbReady()) ? '1' : '0';
        const sig = _bizInputSig(allGames, `myAch|${dlcReady}`);
        return getBizCached('biz_my_achievements', _BIZ_SCHEMA_ACHIEVEMENTS, sig, () => {
            return computeMyAchievements();
        });
    }

    // v2.9.50: 完整版洞察数据(从 SGIS 子闭包抽出,主闭包可走 PCC 持久化)
    // 包含 5 维度评分 + 玩家画像,逻辑与原 SGIS.computeInsightData 同步
    function _computeInsightDataFull() {
        const allGames = getStatFilteredGames();
        const gameCount = allGames.length;
        const totalPlaytimeMin = allGames.reduce((s, g) => s + (g.playtime || 0), 0);
        const totalHours = Math.floor(totalPlaytimeMin / 60);
        const playedGames = allGames.filter(g => (g.playtime || 0) > 0);
        const playedCount = playedGames.length;
        const unplayedCount = Math.max(0, gameCount - playedCount);
        const avgHours = playedCount > 0 ? Math.round(totalHours / playedCount) : 0;
        const over100hCount = allGames.filter(g => (g.playtime || 0) >= 6000).length;
        const over500hCount = allGames.filter(g => (g.playtime || 0) >= 30000).length;
        const dustRate = gameCount > 0 ? unplayedCount / gameCount : 0;
        const longGamesCount = allGames.filter(g => (g.playtime || 0) >= 600).length;
        const completionRate = playedCount > 0 ? Math.round((longGamesCount / playedCount) * 100) : 0;

        const topGames = allGames.filter(g => (g.playtime || 0) > 0)
            .sort((a, b) => (b.playtime || 0) - (a.playtime || 0))
            .slice(0, 10)
            .map(g => ({ name: g.name, hours: Math.floor((g.playtime || 0) / 60) }));

        const recentGames = allGames.filter(g => g.lastPlayed && g.lastPlayed > 0)
            .sort((a, b) => (b.lastPlayed || 0) - (a.lastPlayed || 0))
            .slice(0, 5)
            .map(g => ({ name: g.name, hours: Math.floor((g.playtime || 0) / 60), lastPlayed: g.lastPlayed }));

        const dustCollectors = allGames.filter(g => !g.playtime || g.playtime === 0)
            .slice(0, 5)
            .map(g => g.name);

        // ── 五维度评分 (0-100) ──
        const breadthScore = Math.min(100, Math.round((gameCount / 300) * 100));
        const depthScore = Math.min(100, Math.round((totalHours / 5000) * 100));
        const completionScore = completionRate;
        let diversityScore = 0;
        if (playedCount > 0 && totalPlaytimeMin > 0) {
            const shares = playedGames.map(g => (g.playtime || 0) / totalPlaytimeMin);
            const hhi = shares.reduce((s, x) => s + x * x, 0);
            diversityScore = Math.round((1 - hhi) * 100 * Math.min(1, playedCount / 10));
            diversityScore = Math.max(0, Math.min(100, diversityScore));
        }
        const activityScore = Math.round((1 - dustRate) * 100);

        const dimensions = [
            { label: '收藏广度', score: breadthScore, tag: breadthScore >= 80 ? '收藏大家' : breadthScore >= 60 ? '中量收藏' : breadthScore >= 40 ? '稳步积累' : '初入Steam', gradient: 'linear-gradient(135deg, #3b82f6, #06cfbe)', desc: `${gameCount} 款游戏 · ${over100hCount} 款超 100h · ${over500hCount} 款超 500h` },
            { label: '沉浸深度', score: depthScore, tag: depthScore >= 80 ? '硬核玩家' : depthScore >= 60 ? '资深玩家' : depthScore >= 40 ? '入门玩家' : '体验为主', gradient: 'linear-gradient(135deg, #06cfbe, #22d3ee)', desc: `总时长 ${totalHours}h · 平均 ${avgHours}h/款 · 最长 ${topGames[0]?.hours || 0}h (${topGames[0]?.name || '—'})` },
            { label: '完成度', score: completionScore, tag: completionScore >= 80 ? '深度游玩' : completionScore >= 60 ? '认真体验' : completionScore >= 40 ? '浅尝辄止' : '走马观花', gradient: SGLVCharts.accentGradient(), desc: `${playedCount}/${gameCount} 已启动 · ${longGamesCount} 款深度游玩(≥10h) · 完成率 ${completionRate}%` },
            { label: '偏好多样性', score: diversityScore, tag: diversityScore >= 80 ? '涉猎广泛' : diversityScore >= 60 ? '多元尝试' : diversityScore >= 40 ? '有所偏好' : '专一玩家', gradient: 'linear-gradient(135deg, #f43f5e, #fb7185)', desc: `时长分布集中度 ${diversityScore}% 分散 · Top1 占比 ${topGames[0] && totalHours > 0 ? Math.round((topGames[0].hours / totalHours) * 100) : 0}%` },
            { label: '活跃度', score: activityScore, tag: activityScore >= 80 ? '活跃高玩' : activityScore >= 60 ? '稳定玩家' : activityScore >= 40 ? '间歇游玩' : '吃灰严重', gradient: 'linear-gradient(135deg, #f59e0b, #fbbf24)', desc: `吃灰率 ${(dustRate * 100).toFixed(1)}% · ${unplayedCount} 款未启动 · ${dustCollectors.length ? '如: ' + dustCollectors.slice(0, 2).join('、') : '无'}` },
        ];

        // ── 玩家画像 (本地规则推断) ──
        let personaType = '均衡型玩家';
        let personaRarity = '常见';
        let personaTagline = '游戏风格均衡, 各维度发展稳定';
        let personaTraits = [];

        const maxDim = dimensions.reduce((a, b) => a.score >= b.score ? a : b);
        if (breadthScore >= 75 && depthScore < 50) {
            personaType = '收藏型玩家'; personaRarity = '稀有';
            personaTagline = '热衷扩充库藏, 拥有海量游戏但未必全部深入';
            personaTraits = ['数字收藏家', '促销猎手', 'FOMO 型消费', '广度优先'];
        } else if (depthScore >= 75 && breadthScore < 60) {
            personaType = '硬核型玩家'; personaRarity = '史诗';
            personaTagline = '少量游戏投入海量时长, 追求深度体验与精通';
            personaTraits = ['深度沉浸', '反复游玩', '成就猎人', '精通导向'];
        } else if (activityScore < 40 && breadthScore >= 60) {
            personaType = '吃灰型玩家'; personaRarity = '常见';
            personaTagline = '库藏丰富但启动率低, 大量游戏长期未触碰';
            personaTraits = ['仓鼠症', '冲动消费', '收藏 > 游玩', '潜力待发掘'];
        } else if (diversityScore >= 70 && completionScore >= 60) {
            personaType = '探索型玩家'; personaRarity = '稀有';
            personaTagline = '涉猎广泛且认真体验, 各类游戏均有深度游玩';
            personaTraits = ['多元品味', '开放尝试', '均衡发展', '好奇心强'];
        } else if (completionScore >= 75) {
            personaType = '完成型玩家'; personaRarity = '史诗';
            personaTagline = '注重游戏完成度, 倾向深度通关而非广度收集';
            personaTraits = ['完美主义', '通关导向', '深度体验', '宁缺毋滥'];
        } else if (breadthScore >= 60 && depthScore >= 60) {
            personaType = '全能型玩家'; personaRarity = '传说';
            personaTagline = '收藏与深度兼备, 游戏库既广且深';
            personaTraits = ['收藏 + 深度', '资深 Steam 用户', '多元 + 专注', '高活跃'];
        }

        return {
            kpi: { gameCount, totalHours, playedCount, unplayedCount, avgHours, over100hCount, over500hCount, dustRate, longGamesCount, completionRate },
            topGames, recentGames, dustCollectors,
            dimensions,
            persona: { type: personaType, rarity: personaRarity, tagline: personaTagline, traits: personaTraits, dominantDim: maxDim.label },
        };
    }

    // v2.9.50: SGIS 子闭包洞察数据走 PCC 持久化(跨 session 复用)
    // SGIS 子闭包内的 computeInsightData 直接调用此函数
    function computeInsightDataCachedSgis() {
        const allGames = getStatFilteredGames();
        const dlcReady = (SGLV_API.isDlcDbReady && SGLV_API.isDlcDbReady()) ? '1' : '0';
        const sig = _bizInputSig(allGames, `sgis_insight|${dlcReady}`);
        return getBizCached('biz_sgis_insight_data', _BIZ_SCHEMA_INSIGHT, sig, () => _computeInsightDataFull());
    }

    function createTrendTooltip(chartEl) {
        let tooltip = chartEl.querySelector('.sglv-trend-tooltip');
        if (!tooltip) {
            tooltip = document.createElement('div');
            tooltip.className = 'sglv-trend-tooltip';
            chartEl.appendChild(tooltip);
        }
        return tooltip;
    }

    // v2.11.12 (FEAT-012 TASK-006): 主柱 hover tooltip 装配自 renderTrendChart 抽出——
    // 数据源全为柱上 data-* 属性(几何无关),依赖经 cfg 传入,行为与 2.11.11 内联实现一致
    function bindTrendBarTooltip(container, cfg) {
        const { hasMemberBars, hasFamilyLines, hasPersonalLine, hasPersonalBar, familyYearlyStats, familyCumStats, memberColors } = cfg;
        const tooltip = createTrendTooltip(container);
        container.querySelectorAll('.sglv-trend-bar').forEach(bar => {
            bar.addEventListener('mouseenter', () => {
                const year = bar.dataset.year;
                const count = bar.dataset.count;
                const cum = bar.dataset.cum;
                const membersStr = bar.dataset.members || '';
                const memberBarsStr = bar.dataset.memberBars || '';
                const rect = bar.getBoundingClientRect();
                const chartRect = container.getBoundingClientRect();

                // 成员柱明细(当年新增)
                let memberBarRows = '';
                if (memberBarsStr && hasMemberBars) {
                    memberBarsStr.split('|').forEach(pair => {
                        const [name, val] = pair.split(':');
                        if (!name) return;
                        const m = familyYearlyStats.members.find(mm => mm.name === name);
                        const color = m ? m.color : '#888';
                        const num = parseInt(val, 10) || 0;
                        memberBarRows += `<div class="sglv-trend-tooltip-row"><span class="sglv-trend-tooltip-label"><span class="sglv-trend-tooltip-dot" style="background:${color}"></span>${name}</span><span class="sglv-trend-tooltip-value">${num}</span></div>`;
                    });
                }
                // 成员累计行
                let memberRows = '';
                if (membersStr && hasFamilyLines) {
                    membersStr.split('|').forEach(pair => {
                        const [name, val] = pair.split(':');
                        if (!name || !val) return;
                        const idx = familyCumStats.members.findIndex(m => m.name === name);
                        const color = memberColors[idx % memberColors.length];
                        memberRows += `<div class="sglv-trend-tooltip-row"><span class="sglv-trend-tooltip-label"><span class="sglv-trend-tooltip-dot" style="background:${color}"></span>${name} (${isZh ? '累计' : 'cum.'})</span><span class="sglv-trend-tooltip-value">${val}</span></div>`;
                    });
                }
                // 构建累计行
                let cumRows = '';
                if (hasPersonalLine) {
                    const personalCumVal = bar.dataset.personalCum || '';
                    cumRows += `<div class="sglv-trend-tooltip-row"><span class="sglv-trend-tooltip-label"><span class="sglv-trend-tooltip-dot" style="background:#22c55e"></span>${isZh ? '我的累计' : 'My cum.'}</span><span class="sglv-trend-tooltip-value">${personalCumVal}</span></div>`;
                    cumRows += `<div class="sglv-trend-tooltip-row"><span class="sglv-trend-tooltip-label"><span class="sglv-trend-tooltip-dot" style="background:#818cf8"></span>${isZh ? '家庭组合并' : 'Family total'}</span><span class="sglv-trend-tooltip-value">${cum}</span></div>`;
                } else {
                    cumRows += `<div class="sglv-trend-tooltip-row"><span class="sglv-trend-tooltip-label"><span class="sglv-trend-tooltip-dot" style="background:#22c55e"></span>${isZh ? '累计' : 'Cumulative'}</span><span class="sglv-trend-tooltip-value">${cum}</span></div>`;
                }
                tooltip.innerHTML = `
                    <div style="font-weight:700;margin-bottom:6px">${year}</div>
                    <div class="sglv-trend-tooltip-row"><span class="sglv-trend-tooltip-label"><span class="sglv-trend-tooltip-dot" style="background:#3b82f6"></span>${isZh ? (hasPersonalBar ? '我的新增' : '年度新增') : (hasPersonalBar ? 'My new' : 'New')}</span><span class="sglv-trend-tooltip-value">${count}</span></div>
                    ${memberBarRows ? `<div style="font-size:11px;color:#64748b;margin:6px 0 2px;border-top:1px dashed rgba(255,255,255,.1);padding-top:4px">${isZh ? '各成员新增' : 'Per member'}</div>${memberBarRows}` : ''}
                    ${cumRows}
                    ${memberRows ? `<div style="font-size:11px;color:#64748b;margin:6px 0 2px;border-top:1px dashed rgba(255,255,255,.1);padding-top:4px">${isZh ? '各成员累计' : 'Member cumulative'}</div>${memberRows}` : ''}
                `;
                tooltip.style.opacity = '1';
                const left = rect.left - chartRect.left + rect.width / 2 - tooltip.offsetWidth / 2;
                const top = rect.top - chartRect.top - tooltip.offsetHeight - 8;
                tooltip.style.left = `${Math.max(0, left)}px`;
                tooltip.style.top = `${Math.max(0, top)}px`;
            });
            bar.addEventListener('mouseleave', () => { tooltip.style.opacity = '0'; });
        });
    }

    // ==================== v2.9.15: SVG 图表基础库(共享命名空间) ====================
    // 设计目标:提供最小可用 SVG 工具集,统一风格(深色背景 + 渐变 + 暖色),
    //         现有图表(renderTrendChart/Daily/Donut 等)继续工作,新图表/外部模块可基于此扩展。
    // 借鉴 steam-friend-manager 1.2.2 大量 SVG 图表代码经验
    const SGLVCharts = {
        // 通用颜色板(与现有 SGLV 视觉一致;purple/blue 等为命名色,供语义使用,不随主题切换)
        PALETTE: {
            purple: '#a78bfa', blue: '#3b82f6', cyan: '#06b6d4', teal: '#14b8a6',
            green: '#22c55e', amber: '#f59e0b', red: '#ef4444', pink: '#ec4899',
            gray: '#94a3b8', text: '#cbd5e1', textMuted: '#64748b',
            bgGrid: 'rgba(255,255,255,0.06)', bgCard: 'rgba(255,255,255,0.03)'
        },
        // v2.11.40: 主题层图表色——渲染时读当前主题(每次调用求值,主题热切换后下一次渲染即生效)
        accent() {
            return getThemeId() === 'blue' ? '#66c0f4' : '#a78bfa';
        },
        accentDeep() {
            return getThemeId() === 'blue' ? '#1a9fff' : '#8b5cf6';
        },
        accentGradient() {
            return getThemeId() === 'blue'
                ? 'linear-gradient(135deg, #1a9fff, #66c0f4)'
                : 'linear-gradient(135deg, #8b5cf6, #a78bfa)';
        },
        // 默认系列色:主题强调色优先,另一主题色作次色,语义绿/金/粉不变
        seriesColors() {
            return getThemeId() === 'blue'
                ? ['#66c0f4', '#8b5cf6', '#22c55e', '#f59e0b', '#ec4899']
                : ['#a78bfa', '#38bdf8', '#22c55e', '#f59e0b', '#ec4899'];
        },
        // v2.11.7: 实例自增序列——渐变/clipPath id 防同页多图冲突
        _seq: 0,
        _uid(type) {
            SGLVCharts._seq += 1;
            return `sglv-chart-${type}-${SGLVCharts._seq}`;
        },
        // 通用 SVG 容器生成
        svg(w, h, attrs = '') {
            return `<svg width="100%" viewBox="0 0 ${w} ${h}" preserveAspectRatio="xMidYMid meet" ${attrs}>`;
        },
        // 网格线(横向); fmt 可选(v2.11.7): 刻度值→标签字符串, 默认原样数字(向后兼容)
        // v2.11.9: minVal 域下限可选(价格历史图 y 域迁移引入); fmt 改收未取整刻度值(默认通道取整不变)
        // v2.11.12: opts 可选(combo 引入): {labelFill 刻度文本色覆写, rightMax/rightFmt/rightLabelFill 右轴刻度}
        gridLinesY(pL, pR, pT, cH, maxVal, gridCount = 5, fmt, minVal = 0, opts = null) {
            const o = opts || {};
            const labelFill = o.labelFill || SGLVCharts.PALETTE.textMuted;
            const rightFill = o.rightLabelFill || labelFill;
            const lines = [];
            const hasMin = Number.isFinite(minVal) && minVal !== 0;
            for (let i = 0; i <= gridCount; i++) {
                const raw = hasMin ? minVal + (maxVal - minVal) * i / gridCount : maxVal / gridCount * i;
                const y = pT + cH - (cH * i / gridCount);
                const label = typeof fmt === 'function' ? fmt(raw) : Math.round(raw);
                lines.push(`<line x1="${pL}" y1="${y}" x2="${pR}" y2="${y}" stroke="${SGLVCharts.PALETTE.bgGrid}" />`);
                lines.push(`<text x="${pL - 8}" y="${y + 4}" text-anchor="end" fill="${labelFill}" font-size="11">${label}</text>`);
                if (o.rightMax != null) {
                    const raw2 = o.rightMax / gridCount * i;
                    const label2 = typeof o.rightFmt === 'function' ? o.rightFmt(raw2) : Math.round(raw2);
                    lines.push(`<text x="${pR + 8}" y="${y + 4}" text-anchor="start" fill="${rightFill}" font-size="11">${label2}</text>`);
                }
            }
            return lines.join('');
        },
        // 通用转义
        esc(s) { return String(s || '').replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;'); },
        // 16 进制 → rgba
        hexToRgba(hex, a) {
            const r = parseInt(hex.slice(1, 3), 16), g = parseInt(hex.slice(3, 5), 16), b = parseInt(hex.slice(5, 7), 16);
            return `rgba(${r},${g},${b},${a})`;
        },
        // 多档热力色阶(0..1 → 5 档)
        heatColor(r, hex = '#38bdf8') {
            if (r <= 0) return 'rgba(255,255,255,0.03)';
            if (r < 0.2) return SGLVCharts.hexToRgba(hex, 0.18);
            if (r < 0.4) return SGLVCharts.hexToRgba(hex, 0.35);
            if (r < 0.6) return SGLVCharts.hexToRgba(hex, 0.55);
            if (r < 0.8) return SGLVCharts.hexToRgba(hex, 0.78);
            return hex;
        },
        // 折线图(单/多序列)
        // v2.11.7 扩展(FEAT-012 TASK-001): area(渐变面积)/dots(数据点)/rangeButtons(区间按钮组)/
        // title+yFormatter(轴与头部); 不传新 options 时输出与 2.11.6 逐字节一致(回归保护由单测固化)。
        // 手法来源: area 渐变↔renderPlaytimeTrend(sglvTrendGradient 0.4→0.02), dots/rangeButtons↔
        // renderPriceHistoryChart(sgis-chart-range-btn), 库保持无状态——按钮 data-range 由调用方绑事件。
        // v2.11.8 补充(FEAT-012 TASK-002 迁移所需能力,默认值保持 2.11.7 输出):
        //   svgAttrs(svg 根属性透传)/gridCount(刻度数)/xLabelEvery+xLabelLast(末位标签)/
        //   dots.stroke+strokeWidth(描边)/annotations(refLine 参考线 + point 数据点标注)
        // v2.11.9 补充(FEAT-012 TASK-003 双价格图迁移所需,默认值保持 2.11.8 输出):
        //   xValues+xMinSpan(值域比例 x 轴,承接时间戳横轴与 86400000 跨度护栏)/yMin+yMax(y 域覆写)/
        //   strokeWidth+strokeRound(折线描边)/xLabelAt(指定索引标签)/dots.fill+dots.itemStyle(逐点样式)/
        //   wrapId(区间按钮容器 id)
        lineChart(series, options = {}) {
            const {
                width = 600, height = 240, pL = 40, pR = 16, pT = 16, pB = 28, smooth = true,
                colors = SGLVCharts.seriesColors(),
                area, dots, rangeButtons, activeRange, title, yFormatter,
                svgAttrs, gridCount = 5, xLabelEvery = 8, xLabelLast = false,
            } = options;
            if (!series || !series.length) return '';
            // 双系列长度不一致: 以最短为准截断(warnOnMismatch:false 静默)
            const dataLens = series.map(s => (s && Array.isArray(s.data)) ? s.data.length : 0);
            const n = Math.min(...dataLens);
            if (new Set(dataLens).size > 1 && options.warnOnMismatch !== false) {
                console.warn('SGLVCharts.lineChart: series 数据长度不一致,已按最短截断', dataLens);
            }
            const norm = series.map(s => ({ ...s, data: (s && Array.isArray(s.data) ? s.data : []).slice(0, n) }));
            const allY = norm.flatMap(s => s.data.map(v => Number(v) || 0));
            const maxV = Math.max(1, ...allY);
            const cW = width - pL - pR, cH = height - pT - pB;
            // v2.11.9: y 域覆写(价格历史图 ±15% padding 域迁移引入); 默认 0..maxV 与 2.11.8 一致
            const yMin = Number.isFinite(options.yMin) ? options.yMin : 0;
            const yMax = Number.isFinite(options.yMax) ? options.yMax : maxV;
            const ySpan = Math.max(yMax - yMin, 1e-12);
            // n=1 且 centerSinglePoint:true 时数据点水平居中(对齐 renderPlaytimeTrend 原语义);默认靠左不变
            const centered = n === 1 && options.centerSinglePoint === true;
            // v2.11.9: xValues 提供时按值域比例映射 x(时间比例横轴, 长度不足 n 回退索引等距);
            // xMinSpan 最小跨度护栏(承接 86400000 单日语义); 默认索引等距与 2.11.8 一致
            const xvSrc = Array.isArray(options.xValues) ? options.xValues : null;
            const xv = xvSrc && xvSrc.length >= n ? xvSrc.slice(0, n).map(Number) : null;
            let xOf;
            if (xv) {
                const x0 = xv[0], x1 = xv[xv.length - 1];
                const xSpan = Math.max(x1 - x0, Number(options.xMinSpan) > 0 ? Number(options.xMinSpan) : 0, 1e-12);
                xOf = i => pL + ((xv[i] - x0) / xSpan) * cW;
            } else {
                const stepX = n > 1 ? cW / (n - 1) : 0;
                xOf = i => (centered ? pL + cW / 2 : pL + i * stepX);
            }
            const baseY = pT + cH;
            const uid = SGLVCharts._uid('line');
            // area: true → 系列色默认渐变(op 0.4→0.02); {fill, opacity} 可覆写; 非法类型宽容忽略
            const areaOn = area === true || (area !== null && typeof area === 'object');
            const areaCfg = areaOn && area !== true ? area : {};
            const topOp = areaCfg.opacity != null ? Number(areaCfg.opacity) : 0.4;
            // dots: 默认画 r=3 无 title(与 2.11.6 一致); false 关闭; {r, title(v,i,sIdx), stroke, strokeWidth} 定制
            // v2.11.9 增补: fill(统一填充覆写)/itemStyle(v,i,sIdx)→{r?,fill?}(逐点样式, 最低价高亮迁移引入)
            const dotsOn = dots !== false;
            const dotsCfg = (dots && typeof dots === 'object') ? dots : {};
            const dotR = dotsCfg.r != null ? dotsCfg.r : 3;
            const dotFill = typeof dotsCfg.fill === 'string' ? dotsCfg.fill : null;
            const dotStyle = typeof dotsCfg.itemStyle === 'function' ? dotsCfg.itemStyle : null;
            const dotTitle = typeof dotsCfg.title === 'function' ? dotsCfg.title : null;
            const dotStroke = dotsCfg.stroke
                ? ` stroke="${dotsCfg.stroke}" stroke-width="${dotsCfg.strokeWidth != null ? dotsCfg.strokeWidth : 1}"`
                : '';
            // 渐变 stop: 系列色为 #rrggbb 时 hexToRgba 融合透明度,否则(rgba()/命名色)用 stop-opacity
            const stopOf = (col, a) => /^#[0-9a-f]{6}$/i.test(col)
                ? `stop-color="${SGLVCharts.hexToRgba(col, a)}"`
                : `stop-color="${col}" stop-opacity="${a}"`;
            const parts = [];
            const defs = [];
            const allPts = [];
            norm.forEach((s, idx) => {
                const col = s.color || colors[idx % colors.length];
                const pts = s.data.map((v, i) => {
                    const x = xOf(i);
                    const y = pT + cH - ((Math.max(yMin, Number(v) || 0) - yMin) / ySpan) * cH;
                    return [x, y];
                });
                allPts[idx] = pts;
                const d = pts.map((p, i) => (i === 0 ? 'M' : (smooth ? 'C' : 'L')) + p.join(' ')).join(' ');
                if (areaOn && pts.length) {
                    const gid = `${uid}-g${idx}`;
                    const fill = areaCfg.fill || col;
                    defs.push(`<linearGradient id="${gid}" x1="0" y1="0" x2="0" y2="1">` +
                        `<stop offset="0%" ${stopOf(fill, topOp)}/>` +
                        `<stop offset="100%" ${stopOf(fill, 0.02)}/></linearGradient>`);
                    const areaD = d + ` L ${pts[pts.length - 1][0]} ${baseY} L ${pts[0][0]} ${baseY} Z`;
                    parts.push(`<path d="${areaD}" fill="url(#${gid})" stroke="none"/>`);
                }
                // v2.11.9: strokeWidth/strokeRound 可配(双价格图 1.8px 圆角承接); 默认 2px 与 2.11.8 一致
                const strokeW = Number.isFinite(options.strokeWidth) ? options.strokeWidth : 2;
                const roundCap = options.strokeRound === true ? ' stroke-linejoin="round" stroke-linecap="round"' : '';
                parts.push(`<path d="${d}" fill="none" stroke="${col}" stroke-width="${strokeW}"${roundCap} />`);
                // 端点圆
                if (dotsOn) {
                    pts.forEach(([x, y], i) => {
                        const st = dotStyle ? (dotStyle(s.data[i], i, idx) || {}) : {};
                        const r = st.r != null ? st.r : dotR;
                        const fill = st.fill || dotFill || col;
                        const t = dotTitle ? dotTitle(s.data[i], i, idx) : null;
                        parts.push(t
                            ? `<circle cx="${x}" cy="${y}" r="${r}" fill="${fill}"${dotStroke}><title>${SGLVCharts.esc(t)}</title></circle>`
                            : `<circle cx="${x}" cy="${y}" r="${r}" fill="${fill}"${dotStroke} />`);
                    });
                }
            });
            // annotations: refLine 画在数据下层(参考线), point 画在数据上层(标注),文本均转义
            const refLines = [];
            const pointAnns = [];
            if (Array.isArray(options.annotations)) {
                options.annotations.forEach(a => {
                    if (!a || typeof a !== 'object') return;
                    if (a.type === 'refLine') {
                        const y = pT + cH - ((Math.max(yMin, Number(a.value) || 0) - yMin) / ySpan) * cH;
                        refLines.push(`<line x1="${pL}" y1="${y}" x2="${width - pR}" y2="${y}" stroke="${a.color || SGLVCharts.PALETTE.gray}" stroke-width="${a.width || 1}"${a.dash ? ` stroke-dasharray="${SGLVCharts.esc(a.dash)}"` : ''}/>`);
                        if (a.label) {
                            refLines.push(`<text x="${width - pR + 2}" y="${y + 3}" fill="${a.labelColor || a.color || SGLVCharts.PALETTE.text}" font-size="${a.fontSize || 9}"${a.fontWeight ? ` font-weight="${a.fontWeight}"` : ''}>${SGLVCharts.esc(a.label)}</text>`);
                        }
                    } else if (a.type === 'point') {
                        const pts = allPts[a.sIdx || 0] || [];
                        const idx = Math.min(Math.max(0, a.idx | 0), pts.length - 1);
                        const p = pts[idx];
                        if (!p) return;
                        pointAnns.push(`<text x="${p[0]}" y="${p[1] + (a.dy != null ? a.dy : -7)}" text-anchor="middle" fill="${a.color || SGLVCharts.PALETTE.amber}" font-size="${a.fontSize || 9}"${a.fontWeight ? ` font-weight="${a.fontWeight}"` : ''}>${SGLVCharts.esc(a.text || '')}</text>`);
                    }
                });
            }
            const defsHtml = defs.length ? `<defs>${defs.join('')}</defs>` : '';
            let svg = SGLVCharts.svg(width, height, svgAttrs) + defsHtml
                + SGLVCharts.gridLinesY(pL, width - pR, pT, cH, yMax, gridCount, yFormatter, yMin)
                + refLines.join('') + parts.join('');
            // X 轴标签(labelStep 除数与末位标签可配; 默认与 2.11.7 一致)
            // v2.11.9: xLabelAt 指定索引渲染(价格历史图智能取位迁移引入); 位置一律走 xOf(时间比例轴兼容)
            const xLabels = options.xLabels || norm[0].data.map((_, i) => String(i));
            const xl = [];
            const pushLbl = i => {
                if (!Number.isInteger(i) || i < 0 || i >= xLabels.length) return;
                xl.push(`<text x="${xOf(i)}" y="${height - 8}" text-anchor="middle" fill="${SGLVCharts.PALETTE.textMuted}" font-size="10">${SGLVCharts.esc(xLabels[i])}</text>`);
            };
            if (Array.isArray(options.xLabelAt) && options.xLabelAt.length) {
                options.xLabelAt.forEach(i => pushLbl(Math.round(Number(i))));
            } else {
                const labelStep = Math.max(1, Math.floor(xLabels.length / Math.max(1, xLabelEvery)));
                xLabels.forEach((lbl, i) => {
                    if (i % labelStep !== 0 && !(xLabelLast && i === xLabels.length - 1)) return;
                    pushLbl(i);
                });
            }
            svg += xl.join('') + pointAnns.join('') + '</svg>';
            // rangeButtons: 仅产出按钮 DOM(data-range),点击行为由调用方绑定(库无状态)
            if (Array.isArray(rangeButtons) && rangeButtons.length) {
                const btns = rangeButtons.map(r =>
                    `<button class="sgis-chart-range-btn ${activeRange === r.key ? 'active' : ''}" data-range="${SGLVCharts.esc(r.key)}">${SGLVCharts.esc(r.label)}</button>`
                ).join('');
                const titleHtml = title ? `<span class="sgis-price-chart-title">${SGLVCharts.esc(title)}</span>` : '';
                const wrapAttr = options.wrapId ? ` id="${SGLVCharts.esc(options.wrapId)}"` : '';
                return `<div class="sgis-price-chart-wrap"${wrapAttr}><div class="sgis-price-chart-header">${titleHtml}<div class="sgis-chart-range-group">${btns}</div></div>${svg}</div>`;
            }
            return svg;
        },
        // 堆叠条形图
        stackedBar(categories, series, options = {}) {
            const { width = 600, height = 240, pL = 40, pR = 16, pT = 20, pB = 40, colors = SGLVCharts.seriesColors() } = options;
            if (!categories.length) return '';
            const totals = categories.map((_, i) => series.reduce((s, ser) => s + (Number(ser.data[i]) || 0), 0));
            const maxV = Math.max(1, ...totals);
            const cW = width - pL - pR, cH = height - pT - pB;
            const gap = cW / categories.length;
            const barW = Math.min(Math.max(gap * 0.6, 16), 40);
            let svg = SGLVCharts.svg(width, height) + SGLVCharts.gridLinesY(pL, width - pR, pT, cH, maxV);
            categories.forEach((cat, i) => {
                const cx = pL + gap * i + gap / 2;
                let yAcc = pT + cH;
                series.forEach((ser, sIdx) => {
                    const v = Number(ser.data[i]) || 0;
                    if (v <= 0) return;
                    const h = (v / maxV) * cH;
                    yAcc -= h;
                    const col = ser.color || colors[sIdx % colors.length];
                    svg += `<rect x="${cx - barW / 2}" y="${yAcc}" width="${barW}" height="${h}" fill="${col}" opacity="0.85" rx="2" />`;
                });
                svg += `<text x="${cx}" y="${pT + cH + 16}" text-anchor="middle" fill="${SGLVCharts.PALETTE.textMuted}" font-size="10">${SGLVCharts.esc(cat)}</text>`;
            });
            return svg + '</svg>';
        },
        // 圆环/饼图
        // v2.11.10: 补齐手写 renderPlaytimeDonut 迁移缺口(全可选,默认形态不变):
        //   bg=false 关背景环 / title(sl,i) 每段 <title>(esc 转义) / segStyle 段 circle style 透传 /
        //   center {text,sub,fontSize,weight,fill,y,subFontSize,subFill,subY} 双行中心文本 /
        //   legend {value(sl)} 图例行 / wrap=true 产出 sglv-donut-wrap 布局
        donutChart(slices, options = {}) {
            const {
                size = 160, thickness = 22, centerText = '',
                bg = true, title = null, segStyle = '', center = null, legend = null, wrap = false,
            } = options;
            const total = slices.reduce((s, sl) => s + (sl.value || 0), 0);
            if (total <= 0) return '';
            const r = size / 2 - thickness / 2;
            const cx = size / 2, cy = size / 2;
            const C = 2 * Math.PI * r;
            let acc = 0;
            let svg = SGLVCharts.svg(size, size);
            // 背景环
            if (bg) svg += `<circle cx="${cx}" cy="${cy}" r="${r}" fill="none" stroke="${SGLVCharts.PALETTE.bgCard}" stroke-width="${thickness}" />`;
            slices.forEach((sl, i) => {
                if (!sl.value) return;
                const len = (sl.value / total) * C;
                const offset = -acc;
                const t = title ? title(sl, i) : null;
                const attrs = `cx="${cx}" cy="${cy}" r="${r}" fill="none" stroke="${sl.color}" stroke-width="${thickness}" stroke-dasharray="${len} ${C - len}" stroke-dashoffset="${offset}" transform="rotate(-90 ${cx} ${cy})"${segStyle ? ` style="${segStyle}"` : ''}`;
                if (t) svg += `<circle ${attrs}><title>${SGLVCharts.esc(t)}</title></circle>`;
                else svg += `<circle ${attrs} />`;
                acc += len;
            });
            if (center) {
                const {
                    text = '', sub = '',
                    fontSize = 13, weight = 600, fill = SGLVCharts.PALETTE.text, y = cy + 4,
                    subFontSize = 11, subFill = SGLVCharts.PALETTE.textMuted, subY = y + 14,
                } = center;
                if (text) svg += `<text x="${cx}" y="${y}" text-anchor="middle" fill="${fill}" font-size="${fontSize}" font-weight="${weight}">${SGLVCharts.esc(text)}</text>`;
                if (sub) svg += `<text x="${cx}" y="${subY}" text-anchor="middle" fill="${subFill}" font-size="${subFontSize}">${SGLVCharts.esc(sub)}</text>`;
            } else if (centerText) {
                svg += `<text x="${cx}" y="${cy + 4}" text-anchor="middle" fill="${SGLVCharts.PALETTE.text}" font-size="13" font-weight="600">${SGLVCharts.esc(centerText)}</text>`;
            }
            svg += '</svg>';
            let legendHtml = '';
            if (legend) {
                legendHtml = `<div class="${legend.className || 'sglv-donut-legend'}">` + slices.filter(sl => sl.value > 0).map(sl =>
                    `<div class="sglv-donut-legend-item"><span class="sglv-donut-legend-dot" style="background:${sl.color}"></span><span class="sglv-donut-legend-label">${SGLVCharts.esc(sl.label || '')}</span><span class="sglv-donut-legend-value">${legend.value ? legend.value(sl) : SGLVCharts.esc(sl.value)}</span></div>`
                ).join('') + '</div>';
            }
            if (wrap) {
                return `<div class="sglv-donut-wrap"><div class="sglv-donut-chart">${svg}</div>${legendHtml}</div>`;
            }
            return svg + legendHtml;
        },
        // 热力图(行 × 列)——「矩阵热力图」: 数值矩阵 + 连续单色色阶(heatColor 插值) + 静态轴标签。
        // v2.11.13 (FEAT-012 TASK-007) 分工边界: 与 renderAcquiredHeatmap(GitHub 风格「日历热力图」:
        // 日期驱动周网格/离散5级绿阶+未来占位色/月边界动态标注+年份分隔线)为两种不同图表形态,
        // 五维能力矩阵核查判定非重复实现,互不收编——勿再以"图表重复"为由合并(矩阵记录见 TASK-007 PRD)。
        heatmap(matrix, options = {}) {
            const { cellSize = 18, gap = 3, xLabels = [], yLabels = [], color = '#38bdf8' } = options;
            const rows = matrix.length, cols = matrix[0]?.length || 0;
            if (!rows || !cols) return '';
            const w = (xLabels.length ? 30 : 0) + cols * (cellSize + gap) - gap + 6;
            const h = (yLabels.length ? 16 : 0) + rows * (cellSize + gap) - gap + 4;
            let maxV = 0;
            matrix.forEach(r => r.forEach(v => { if (v > maxV) maxV = v; }));
            let svg = SGLVCharts.svg(w, h);
            matrix.forEach((row, ri) => {
                row.forEach((v, ci) => {
                    const x = (xLabels.length ? 30 : 0) + ci * (cellSize + gap);
                    const y = (yLabels.length ? 16 : 0) + ri * (cellSize + gap);
                    const r = maxV > 0 ? v / maxV : 0;
                    svg += `<rect x="${x}" y="${y}" width="${cellSize}" height="${cellSize}" rx="3" fill="${SGLVCharts.heatColor(r, color)}"><title>${SGLVCharts.esc(v)}</title></rect>`;
                });
            });
            if (xLabels.length) {
                const step = Math.max(1, Math.floor(xLabels.length / 12));
                xLabels.forEach((lbl, i) => {
                    if (i % step !== 0) return;
                    const x = 30 + i * (cellSize + gap) + cellSize / 2;
                    svg += `<text x="${x}" y="12" text-anchor="middle" fill="${SGLVCharts.PALETTE.textMuted}" font-size="9">${SGLVCharts.esc(lbl)}</text>`;
                });
            }
            if (yLabels.length) {
                yLabels.forEach((lbl, ri) => {
                    const y = 16 + ri * (cellSize + gap) + cellSize / 2 + 3;
                    svg += `<text x="26" y="${y}" text-anchor="end" fill="${SGLVCharts.PALETTE.textMuted}" font-size="9">${SGLVCharts.esc(lbl)}</text>`;
                });
            }
            return svg + '</svg>';
        },
        // v2.11.12 (FEAT-012 TASK-006): 柱+折线组合图——趋势 Tab 年度组合图(renderTrendChart)收编。
        // 双 y 轴(左轴=柱、右轴=线共用同一组网格线); 柱几何(v→高度)由库按 leftMax 计算,
        // x 偏移/宽度属业务布局规则留在调用方 bars 回调; 系列按 rightAxis 缩放。
        comboChart(cfg = {}) {
            const {
                width = 800, height = 440, pL = 52, pR = 62, pT = 20, pB = 50,
                n = 0, leftMax = 1, rightMax = null, gridCount = 5, labelFill = '#8a9ba8',
                bars = null,      // (i, cx, gap) => [{ v, x, w, fill, rx=3, cls, opacity, attrs }] — v 按左轴
                series = [],      // [{ data, stroke, strokeWidth=2.5, polyAttrs, dots:{r=3, fill=stroke, attrs} }] — 按右轴
                xLabel = null,    // (i, cx) => 文本|null
                baseStroke = 'rgba(255,255,255,.13)',
                svgAttrs = '',
            } = cfg;
            const cW = width - pL - pR, cH = height - pT - pB;
            const gap = n > 0 ? cW / n : 0;
            const cxOf = i => pL + gap * i + gap / 2;
            let out = SGLVCharts.gridLinesY(pL, width - pR, pT, cH, leftMax, gridCount, undefined, 0,
                { labelFill, rightMax, rightLabelFill: labelFill });
            if (typeof bars === 'function') {
                for (let i = 0; i < n; i++) {
                    (bars(i, cxOf(i), gap) || []).forEach(b => {
                        if (!b) return;
                        const h = leftMax ? (b.v / leftMax) * cH : 0;
                        const y = pT + cH - h;
                        out += `<rect${b.cls ? ` class="${b.cls}"` : ''} x="${b.x}" y="${y}" width="${b.w}" height="${h}" fill="${b.fill}" rx="${b.rx != null ? b.rx : 3}"${b.attrs ? ' ' + b.attrs : ''}${b.opacity != null ? ` opacity="${b.opacity}"` : ''} />`;
                    });
                }
            }
            series.forEach(s => {
                const data = s.data || [];
                if (!data.length) return;
                const sw = s.strokeWidth != null ? s.strokeWidth : 2.5;
                const pts = data.map((v, i) => `${cxOf(i)},${pT + cH - (rightMax ? (v / rightMax) * cH : 0)}`).join(' ');
                out += `<polyline points="${pts}" fill="none" stroke="${s.stroke}" stroke-width="${sw}" stroke-linecap="round" stroke-linejoin="round"${s.polyAttrs ? ' ' + s.polyAttrs : ''} />`;
                const dots = s.dots;
                if (dots) {
                    const r = dots.r != null ? dots.r : 3;
                    const fill = dots.fill || s.stroke;
                    const a = dots.attrs;
                    data.forEach((v, i) => {
                        // 闭合符随有无 attrs 切换: 字节兼容 2.11.11 手写图(成员点 opacity=".8"/> 无空格)
                        out += `<circle cx="${cxOf(i)}" cy="${pT + cH - (rightMax ? (v / rightMax) * cH : 0)}" r="${r}" fill="${fill}"${a ? ` ${a}/>` : ' />'}`;
                    });
                }
            });
            if (typeof xLabel === 'function') {
                for (let i = 0; i < n; i++) {
                    const t = xLabel(i, cxOf(i));
                    if (t != null && t !== '') out += `<text x="${cxOf(i)}" y="${pT + cH + 18}" text-anchor="middle" fill="${labelFill}" font-size="11">${t}</text>`;
                }
            }
            out += `<line x1="${pL}" y1="${pT + cH}" x2="${width - pR}" y2="${pT + cH}" stroke="${baseStroke}" />`;
            return `<svg width="100%" height="100%" viewBox="0 0 ${width} ${height}" preserveAspectRatio="none"${svgAttrs ? ' ' + svgAttrs : ''}>${out}</svg>`;
        }
    };
    // v2.9.15: 暴露给 SGIS / Collection 库复用
    unsafeWindow.SGLVCharts = SGLVCharts;

    function renderTrendChart(stats, container, options = {}) {
        if (!stats.years.length) {
            container.innerHTML = emptyHtml(isZh ? '无时间数据' : 'No time data');
            return;
        }
        const { isEstimated = false, familyCumStats = null, personalYearlyStats = null, familyYearlyStats = null, hasOwnerData = false } = options;

        // 主柱数据：家庭组开启时显示"我的年度新增"，否则显示总年度新增
        const hasPersonalBar = hasOwnerData && personalYearlyStats && personalYearlyStats.years.length > 0
            && personalYearlyStats.cumulative.length === stats.years.length;
        const mainCounts = hasPersonalBar ? personalYearlyStats.counts : stats.counts;

        // SVG 布局参数（v2.11.12 起画布/内边距默认值在 SGLVCharts.comboChart 内,此处仅保留分组布局计算）
        const n = stats.years.length;
        const gap = (800 - 52 - 62) / n;

        // 成员颜色（参考 steam-family-game-analysis）
        const memberColors = ['#06cfbe', '#54a0ff', '#ff9f43', '#2ed573', '#ff6b6b', '#a29bfe'];

        // 判断是否有家庭成员柱状图数据
        const hasMemberBars = familyYearlyStats && familyYearlyStats.years.length > 0
            && familyYearlyStats.members.length > 0;

        // 分组柱状图尺寸：每组最多 1 根主柱(年度总新增) + N 根成员细柱
        const memberCount = hasMemberBars ? familyYearlyStats.members.length : 0;
        const groupCount = hasMemberBars ? (1 + memberCount) : 1;
        const groupGap = Math.max(2, gap * 0.12); // 组内柱间隙
        // 组内总宽度占年份间距的 0.78；主柱稍宽，成员细柱窄
        const groupTotalW = Math.min(gap * 0.78, groupCount * 14 + (groupCount - 1) * groupGap);
        const mainBarW = hasMemberBars ? Math.max(10, groupTotalW * 0.32) : Math.min(gap * 0.55, 38);
        const memberBarW = hasMemberBars ? Math.max(3, (groupTotalW - mainBarW - groupGap) / memberCount) : 0;
        const allBarsTotalW = hasMemberBars ? (mainBarW + groupGap + memberBarW * memberCount) : mainBarW;

        // Y 轴范围：需要考虑柱状最大值(主柱 + 成员最大柱)和折线最大值
        // 主柱最大值
        let mainMax = Math.max(...mainCounts, 1);
        // 成员柱最大值（取所有成员各年新增的最大值）
        let memberMax = 0;
        if (hasMemberBars) {
            familyYearlyStats.members.forEach(m => {
                m.counts.forEach(c => { if (c > memberMax) memberMax = c; });
            });
        }
        const maxCount = Math.max(mainMax, memberMax, 1);

        const myMaxCumulative = stats.maxCumulative || 1;
        const familyMaxCum = familyCumStats?.maxCumulative || 0;
        const personalMaxCum = (personalYearlyStats && personalYearlyStats.years.length > 0) ? personalYearlyStats.maxCumulative : 0;
        const maxCumulative = Math.max(myMaxCumulative, familyMaxCum, personalMaxCum) || 1;

        const hasPersonalLine = personalYearlyStats && personalYearlyStats.years.length > 0
            && personalYearlyStats.cumulative.length === n;
        const hasFamilyLines = familyCumStats && familyCumStats.members.length > 0
            && familyCumStats.members.every(m => m.cumulative.length === n);

        // v2.11.12 (FEAT-012 TASK-006): 网格/双轴刻度/柱/折线/x 轴标签/基线收敛至 SGLVCharts.comboChart
        // （柱 x 偏移与组内宽度属业务布局规则留在 bars 回调；tooltip 依赖的 data-* 属性原样保留）
        const seriesDefs = [];
        if (hasPersonalLine) {
            // 家庭组开启时：个人累计（绿实线）+ 家庭组合并累计（蓝紫虚线）双曲线
            seriesDefs.push({ data: personalYearlyStats.cumulative, stroke: '#22c55e', dots: {} });
            seriesDefs.push({ data: stats.cumulative, stroke: '#818cf8', polyAttrs: 'stroke-dasharray="6,4"', dots: { fill: '#818cf8' } });
        } else {
            // 非家庭组模式：单累计曲线
            seriesDefs.push({ data: stats.cumulative, stroke: '#22c55e', dots: {} });
        }
        // 家庭组成员累计曲线（彩色半透明，参考 steam-family-game-analysis）
        if (hasFamilyLines) {
            familyCumStats.members.forEach((m, mi) => {
                const color = memberColors[mi % memberColors.length];
                seriesDefs.push({ data: m.cumulative, stroke: color, strokeWidth: 2, polyAttrs: 'opacity=".75"', dots: { r: 2.5, fill: color, attrs: 'opacity=".8"' } });
            });
        }
        const svg = SGLVCharts.comboChart({
            n,
            leftMax: maxCount,
            rightMax: maxCumulative,
            // 每年绘制主柱(我的年度新增 或 总年度新增) + 各家庭成员细柱
            bars: (i, cx) => {
                const year = stats.years[i];
                const groupStartX = cx - allBarsTotalW / 2;
                const mainCount = mainCounts[i] || 0;
                // 收集各成员当年累计值、累计、成员柱数据用于 tooltip
                const memberData = hasFamilyLines ? familyCumStats.members.map(m => `${m.name}:${m.cumulative[i]}`).join('|') : '';
                const personalCumVal = hasPersonalLine ? personalYearlyStats.cumulative[i] : '';
                const familyTotalCumVal = stats.cumulative[i];
                // 收集各成员当年新增(用于 tooltip)
                const memberBarPairs = hasMemberBars
                    ? familyYearlyStats.members.map(m => `${m.name}:${(familyYearlyStats.years.includes(year) ? (m.counts[familyYearlyStats.years.indexOf(year)] || 0) : 0)}`).join('|')
                    : '';
                const list = [{
                    v: mainCount, x: groupStartX, w: mainBarW, fill: '#3b82f6', cls: 'sglv-trend-bar',
                    attrs: `data-year="${year}" data-count="${mainCount}" data-cum="${familyTotalCumVal}" data-members="${memberData}" data-personal-cum="${personalCumVal}" data-member-bars="${memberBarPairs}"`,
                }];
                if (hasMemberBars) {
                    const memberStartX = groupStartX + mainBarW + groupGap;
                    familyYearlyStats.members.forEach((m, mi) => {
                        if (!familyYearlyStats.years.includes(year)) return;
                        const yearIdx = familyYearlyStats.years.indexOf(year);
                        const c = m.counts[yearIdx] || 0;
                        list.push({
                            v: c, x: memberStartX + mi * memberBarW, w: memberBarW - 0.5, fill: m.color, rx: 1.5,
                            cls: 'sglv-trend-bar-member', opacity: '0.85',
                            attrs: `data-year="${year}" data-count="${c}" data-member="${m.name}"`,
                        });
                    });
                }
                return list;
            },
            series: seriesDefs,
            xLabel: i => stats.years[i],
        });

        // 图例
        let legendItems = `
            <div class="sglv-trend-legend-item"><span class="sglv-trend-legend-dot" style="background:#3b82f6"></span>${isZh ? (hasPersonalBar ? '我的年度新增' : '年度新增') : (hasPersonalBar ? 'My new this year' : 'New this year')}</div>
        `;
        if (hasMemberBars) {
            familyYearlyStats.members.forEach((m, mi) => {
                // v2.8.3: 图例项变为可交互——hover 高亮对应成员柱，其余变暗
                legendItems += `<div class="sglv-trend-legend-item sglv-trend-legend-interactive" data-mi="${mi}" style="cursor:pointer;transition:opacity .2s"><span class="sglv-trend-legend-dot" style="background:${m.color}"></span>${m.name}</div>`;
            });
        }
        if (hasPersonalLine) {
            // 家庭组开启时：显示个人累计 + 家庭组合并累计
            legendItems += `<div class="sglv-trend-legend-item"><span class="sglv-trend-legend-line" style="background:#22c55e"></span>${isZh ? '我的累计' : 'My cumulative'}</div>`;
            legendItems += `<div class="sglv-trend-legend-item"><span class="sglv-trend-legend-line" style="background:#818cf8"></span>${isZh ? '家庭组合并' : 'Family total'}</div>`;
        } else {
            // 非家庭组模式
            legendItems += `<div class="sglv-trend-legend-item"><span class="sglv-trend-legend-line" style="background:#22c55e"></span>${isZh ? '我的累计' : 'My cumulative'}</div>`;
        }
        const legend = `<div class="sglv-trend-legend">${legendItems}</div>`;

        const summary = `
            <div class="sglv-trend-summary">
                <span>${isZh ? '总计' : 'Total'}: ${stats.total}</span>
                <span>${isZh ? '年份' : 'Years'}: ${stats.years.length}</span>
                <span>${isZh ? '最早' : 'First'}: ${stats.years[0]}</span>
                <span>${isZh ? '最新' : 'Latest'}: ${stats.years[stats.years.length - 1]}</span>
            </div>
        `;

        // v2.8.3: 成员对比摘要 — 贡献最多 / 最少 / 平均
        let compareSummary = '';
        if (hasMemberBars && familyYearlyStats.members.length > 0) {
            const memberTotals = familyYearlyStats.members.map(m => ({
                name: m.name, count: m.counts.reduce((s, c) => s + c, 0)
            })).sort((a, b) => b.count - a.count);
            const topM = memberTotals[0] || { name: '-', count: 0 };
            const lowM = memberTotals[memberTotals.length - 1] || { name: '-', count: 0 };
            const avgCnt = memberTotals.length > 0 ? Math.round(memberTotals.reduce((s, x) => s + x.count, 0) / memberTotals.length) : 0;
            compareSummary = `<div style="display:flex;justify-content:center;gap:16px;margin-top:6px;font-size:10px;color:#64748b">`
                + `<span>${isZh ? '贡献最多' : 'Top'}: <b style="color:#06cfbe">${topM.name}</b> (${topM.count})</span>`
                + `<span>${isZh ? '平均' : 'Avg'}: <b style="color:#94a3b8">${avgCnt}</b></span>`
                + `<span>${isZh ? '贡献最少' : 'Low'}: <b style="color:#ff9f43">${lowM.name}</b> (${lowM.count})</span>`
                + `</div>`;
        }

        container.innerHTML = svg + legend + compareSummary + summary;

        // v2.8.3: 图例交互 — hover 高亮对应成员柱，其余变暗
        // v2.9.49: 缓存 memberBars 引用，避免每次 hover 都 querySelectorAll 扫描 DOM
        if (hasMemberBars) {
            const memberBars = container.querySelectorAll('.sglv-trend-bar-member');
            container.querySelectorAll('.sglv-trend-legend-interactive').forEach(el => {
                el.addEventListener('mouseenter', function() {
                    const mi = this.dataset.mi;
                    memberBars.forEach(bar => {
                        bar.style.opacity = bar.dataset.member === familyYearlyStats.members[mi].name ? '1' : '.1';
                    });
                });
                el.addEventListener('mouseleave', function() {
                    memberBars.forEach(bar => { bar.style.opacity = '0.85'; });
                });
            });
        }

        // Hover tooltip（主柱触发）— v2.11.12 抽出至 bindTrendBarTooltip,数据源为柱上 data-* 属性
        bindTrendBarTooltip(container, { hasMemberBars, hasFamilyLines, hasPersonalLine, hasPersonalBar, familyYearlyStats, familyCumStats, memberColors });
    }

    // ==================== 设置面板 ====================
    // ==================== v2.9.28: 设置集成进游戏库主面板（移除独立浮层） ====================
    // 点击 header 的 ⚙ 设置按钮 → 设置视图在 #sglv-body 内覆盖展示（完整嵌入浮窗），
    // 再次点击 ⚙、点击"返回游戏库"或切换任意标签页即可退出设置。

    function openGlobalSettings() {
        if (!panelEl) return;
        // 保留原函数名兼容既有调用点：先确保主面板可见，再在面板内展示设置
        openPanel();
        state.showSettings = true;
        renderBody();
    }

    function closeGlobalSettings() {
        if (!state.showSettings) return;
        state.showSettings = false;
        renderBody();
    }

    // v2.9.28: 未配置 API Key 引导提示——右下角卡片。
    // 形态参考 GM_notification 的右下角弹窗通知（见 GM_Docs/油猴脚本常见API权限.md），
    // 但 GM_notification 需系统通知授权且点击后无法直接操作页面，故用页面内自绘卡片实现，
    // 点击"打开设置"可直接唤起面板内设置视图；不自动弹出面板/设置，由用户主动进入。
    function showApiKeyGuideToast() {
        if (document.getElementById('sglv-guide-toast')) return;
        const el = document.createElement('div');
        el.id = 'sglv-guide-toast';
        el.className = 'sglv-guide-toast';
        el.innerHTML = `
            <div class="sglv-guide-toast-head">
                <span class="sglv-guide-toast-title">${ICONS.shield} ${T.apiKeyGuideTitle}</span>
                <button class="sglv-guide-toast-close" title="✕">${ICONS.close}</button>
            </div>
            <div class="sglv-guide-toast-desc">${T.apiKeyGuideDesc}</div>
            <div class="sglv-guide-toast-actions">
                <button class="sglv-guide-toast-btn primary">${T.apiKeyGuideOpen}</button>
                <button class="sglv-guide-toast-btn ghost">${T.apiKeyGuideLater}</button>
            </div>
        `;
        document.body.appendChild(el);
        let _timer = setTimeout(dismiss, 12000);
        function dismiss() {
            clearTimeout(_timer);
            el.style.transition = 'opacity 0.25s, transform 0.25s';
            el.style.opacity = '0';
            el.style.transform = 'translateX(24px)';
            setTimeout(() => { try { el.remove(); } catch (e) {} }, 260);
        }
        el.querySelector('.sglv-guide-toast-close').addEventListener('click', dismiss);
        el.querySelector('.sglv-guide-toast-btn.ghost').addEventListener('click', dismiss);
        el.querySelector('.sglv-guide-toast-btn.primary').addEventListener('click', () => {
            dismiss();
            openGlobalSettings();
        });
    }

    // v2.9.28: 设置视图渲染——卡片式分区布局，完整嵌入游戏库浮窗 #sglv-body
    function renderSettingsView(body) {
        const wrap = document.createElement('div');
        wrap.className = 'sglv-set-wrap';
        wrap.innerHTML = `
            <div class="sglv-set-topbar">
                <button class="sglv-set-back">← ${T.settingsBack}</button>
                <div class="sglv-set-title">${ICONS.settings} ${T.globalSettings}</div>
            </div>
            <div class="sglv-set-grid">
                <section class="sglv-set-card">
                    <div class="sglv-set-card-title"><span class="sglv-set-chip blue">${ICONS.shield}</span>${T.steamApiSection}</div>
                    <div class="sglv-set-desc">${T.apiKeyHelp}</div>
                    <div class="sglv-set-field">
                        <label>${T.apiKeyLabel}</label>
                        <input type="password" class="sglv-set-input" id="sglv-gs-apikey" value="${storage.getApiKey()}" placeholder="Steam Web API Key">
                    </div>
                    <div class="sglv-set-field">
                        <label>${T.steamIdLabel}</label>
                        <input type="text" class="sglv-set-input" id="sglv-gs-steamid" value="${getActiveSteamId()}" placeholder="76561198xxxxxxxxx">
                    </div>
                </section>
                <section class="sglv-set-card">
                    <div class="sglv-set-card-title"><span class="sglv-set-chip purple">${ICONS.trend}</span>${T.aiSettingsTitle}</div>
                    <div class="sglv-set-desc">${T.aiApiUrlHelp}</div>
                    ${_getSharedAiConfig() ? `<div class="sglv-set-hint" style="background:var(--sglv-accent-bg);border-radius:5px;padding:8px 10px;border-left:3px solid var(--sglv-accent-deep);margin-bottom:8px;">🔗 ${T.aiSharedHint}</div>` : ''}
                    <div class="sglv-set-field">
                        <label>${T.aiApiUrlLabel}</label>
                        <input type="text" class="sglv-set-input" id="sglv-gs-ai-url" value="${storage.getAiApiUrl()}" placeholder="https://api.deepseek.com/v1/chat/completions">
                    </div>
                    <div class="sglv-set-field">
                        <label>${T.aiApiKeyLabel}</label>
                        <input type="password" class="sglv-set-input" id="sglv-gs-ai-key" value="${storage.getAiApiKey()}" placeholder="sk-xxxxxxxxxxxxxxxx">
                    </div>
                    <div class="sglv-set-field">
                        <label>${T.aiModelLabel}</label>
                        <input type="text" class="sglv-set-input" id="sglv-gs-ai-model" value="${storage.getAiModel()}" placeholder="deepseek-v4-pro">
                        <div class="sglv-set-hint">${T.aiModelHelp}</div>
                    </div>
                </section>
                <section class="sglv-set-card wide">
                    <div class="sglv-set-card-title"><span class="sglv-set-chip amber">${ICONS.dollar}</span>${T.aiPredictSection}</div>
                    <div class="sglv-set-desc">${T.aiPredictModesHelp}</div>
                    <div class="sglv-set-mode-grid" id="sglv-gs-predict-modes">
                        ${PREDICT_MODES.map(m => {
                            const checked = storage.getPredictModes().includes(m.key);
                            return `<label class="sglv-set-mode-item">
                                <input type="checkbox" value="${m.key}" ${checked ? 'checked' : ''}>
                                <div class="sglv-set-mode-info">
                                    <div class="sglv-set-mode-name">${m.name}</div>
                                    <div class="sglv-set-mode-desc">${m.desc}</div>
                                </div>
                            </label>`;
                        }).join('')}
                    </div>
                </section>
                <section class="sglv-set-card wide">
                    <div class="sglv-set-card-title">
                        <span class="sglv-set-chip" style="background:rgba(167,213,79,0.2);color:#a7d54f">${ICONS.dollar}</span>${T.itadSection}
                        <span style="margin-left:auto;font-size:9px;padding:2px 8px;border-radius:10px;font-weight:600;${storage.getItadApiKey() ? 'background:rgba(167,213,79,0.15);color:#a7d54f' : 'background:rgba(255,255,255,0.05);color:#8f98a0'}" id="sglv-gs-itad-badge">${storage.getItadApiKey() ? '● ' + (isZh ? '已配置' : 'Configured') : '○ ' + T.itadConnNoKey}</span>
                    </div>
                    <div class="sglv-set-desc">${T.itadDesc}</div>
                    <div class="sglv-set-field">
                        <label>${T.itadApiKeyLabel}</label>
                        <div style="display:flex;gap:6px;align-items:center;">
                            <input type="password" class="sglv-set-input" id="sglv-gs-itad-key" value="${storage.getItadApiKey()}" placeholder="${T.itadKeyPlaceholder}" style="flex:1;font-family:monospace;">
                            <button class="sglv-set-test-btn" id="sglv-gs-itad-test" style="background:rgba(167,213,79,0.12);border:1px solid rgba(167,213,79,0.4);color:#a7d54f;border-radius:5px;padding:5px 12px;font-size:10px;cursor:pointer;white-space:nowrap;font-weight:600;">${T.itadTestConn}</button>
                        </div>
                    </div>
                    <div class="sglv-set-hint" style="background:rgba(0,0,0,0.2);border-radius:5px;padding:8px 10px;border-left:3px solid #66c0f4;margin-top:6px;">
                        <div style="font-size:10px;font-weight:600;color:#66c0f4;margin-bottom:4px;">📖 ${T.itadHelpTitle}</div>
                        <div style="font-size:9px;color:#8f98a0;line-height:1.6;">${T.itadHelpSteps}</div>
                    </div>
                    <div id="sglv-gs-itad-test-result" style="font-size:9px;margin-top:4px;"></div>
                </section>
                <section class="sglv-set-card">
                    <div class="sglv-set-card-title"><span class="sglv-set-chip purple">${ICONS.palette}</span>${T.themeSection}</div>
                    <div class="sglv-set-desc">${T.themeDesc}</div>
                    <div class="sglv-set-theme-grid" id="sglv-gs-theme-grid">
                        <label class="sglv-set-theme-opt${getThemeId() === 'purple' ? ' selected' : ''}">
                            <input type="radio" name="sglv-gs-theme" value="purple" ${getThemeId() === 'purple' ? 'checked' : ''}>
                            <span class="sglv-set-theme-swatch purple"></span>
                            <span class="sglv-set-theme-name">${SGLV_THEMES.purple[isZh ? 'zh' : 'en']}<span class="sglv-set-theme-check">✓</span></span>
                            <span class="sglv-set-theme-desc">${T.themePurpleDesc}</span>
                        </label>
                        <label class="sglv-set-theme-opt${getThemeId() === 'blue' ? ' selected' : ''}">
                            <input type="radio" name="sglv-gs-theme" value="blue" ${getThemeId() === 'blue' ? 'checked' : ''}>
                            <span class="sglv-set-theme-swatch blue"></span>
                            <span class="sglv-set-theme-name">${SGLV_THEMES.blue[isZh ? 'zh' : 'en']}<span class="sglv-set-theme-check">✓</span></span>
                            <span class="sglv-set-theme-desc">${T.themeBlueDesc}</span>
                        </label>
                    </div>
                </section>
                <section class="sglv-set-card">
                    <div class="sglv-set-card-title"><span class="sglv-set-chip green">${ICONS.shield}</span>${isZh ? '显示偏好' : 'Display Preferences'}</div>
                    <div class="sglv-set-desc">${isZh ? '控制游戏库浮窗中是否显示家庭组共享的游戏。' : 'Toggle whether family-shared games are shown in the library panel.'}</div>
                    <div class="sglv-set-field">
                        <label class="sglv-set-toggle-row">
                            <span>${isZh ? '显示家庭组共享游戏' : 'Show family-shared games'}</span>
                            <div class="sglv-set-switch">
                                <input type="checkbox" id="sglv-gs-family-toggle" ${storage.getShowFamilyShared() ? 'checked' : ''}>
                                <span class="sglv-set-slider"></span>
                            </div>
                        </label>
                    </div>
                </section>
            </div>
            <div class="sglv-set-savebar">
                <button class="sglv-set-save-btn" id="sglv-gs-save">💾 ${T.save}</button>
                <span class="sglv-set-status" id="sglv-gs-status"></span>
            </div>
        `;

        wrap.querySelector('.sglv-set-back').addEventListener('click', closeGlobalSettings);

        // v2.11.40: 主题选项选中态联动（label.selected 高亮跟随 radio，提交仍走保存按钮）
        wrap.querySelectorAll('input[name="sglv-gs-theme"]').forEach(radio => {
            radio.addEventListener('change', () => {
                wrap.querySelectorAll('.sglv-set-theme-opt').forEach(opt => {
                    opt.classList.toggle('selected', !!opt.querySelector('input') && opt.querySelector('input').checked);
                });
            });
        });

        wrap.querySelector('#sglv-gs-save').addEventListener('click', () => {
            storage.setApiKey(wrap.querySelector('#sglv-gs-apikey').value.trim());
            storage.setSteamId(wrap.querySelector('#sglv-gs-steamid').value.trim());
            storage.setAiApiUrl(wrap.querySelector('#sglv-gs-ai-url').value.trim() || 'https://api.deepseek.com/v1/chat/completions');
            storage.setAiApiKey(wrap.querySelector('#sglv-gs-ai-key').value.trim());
            storage.setAiModel(wrap.querySelector('#sglv-gs-ai-model').value.trim() || 'deepseek-v4-pro');
            // 保存预测模式
            const checkedModes = Array.from(wrap.querySelectorAll('#sglv-gs-predict-modes input[type="checkbox"]:checked')).map(cb => cb.value);
            storage.setPredictModes(checkedModes.length ? checkedModes : ['seasonal', 'trend', 'lowest']);
            // v2.9.46: 保存家庭组共享开关
            storage.setShowFamilyShared(wrap.querySelector('#sglv-gs-family-toggle').checked);
            // v2.11.40: 保存 UI 主题并即时热切换（CSS 覆盖层换内容 + data-sglv-theme 属性 + sglv-theme-changed 事件触发已渲染视图刷新）
            const themeRadio = wrap.querySelector('input[name="sglv-gs-theme"]:checked');
            const newThemeId = SGLV_THEMES[themeRadio && themeRadio.value] ? themeRadio.value : DEFAULT_SGLV_THEME;
            const themeChanged = newThemeId !== getThemeId();
            storage.setUiTheme(newThemeId);
            if (themeChanged) applySglvTheme(newThemeId);
            // v2.9.79: 保存 ITAD API Key 并同步到库
            const itadKey = wrap.querySelector('#sglv-gs-itad-key').value.trim();
            storage.setItadApiKey(itadKey);
            if (window.SGLVITAD) window.SGLVITAD.setApiKey(itadKey || ITAD_API_KEY_FALLBACK);
            _activeSteamId = null; // Invalidate cache!
            clearComputedCache();
            const status = wrap.querySelector('#sglv-gs-status');
            status.textContent = '✅ ' + T.saved;
            setTimeout(() => { status.textContent = ''; closeGlobalSettings(); }, 800);
        });

        // v2.9.79: ITAD 测试连接按钮
        const itadTestBtn = wrap.querySelector('#sglv-gs-itad-test');
        if (itadTestBtn) {
            itadTestBtn.addEventListener('click', async () => {
                const keyInput = wrap.querySelector('#sglv-gs-itad-key');
                const resultEl = wrap.querySelector('#sglv-gs-itad-test-result');
                const testKey = keyInput.value.trim();
                if (!testKey) {
                    resultEl.innerHTML = '<span style="color:#e63946">⚠ ' + T.itadConnFail + ': Key 为空</span>';
                    return;
                }
                itadTestBtn.disabled = true;
                itadTestBtn.textContent = T.itadTesting;
                resultEl.innerHTML = '<span style="color:#8f98a0">' + T.itadTesting + '</span>';
                try {
                    const result = await window.SGLVITAD.testConnection(testKey);
                    if (result.success) {
                        resultEl.innerHTML = '<span style="color:#a7d54f">✅ ' + T.itadConnSuccess + ' · ' + (isZh ? '商店数' : 'Shops') + ': ' + result.shopCount + '</span>';
                    } else {
                        resultEl.innerHTML = '<span style="color:#e63946">❌ ' + T.itadConnFail + ': ' + result.error + '</span>';
                    }
                } catch (e) {
                    resultEl.innerHTML = '<span style="color:#e63946">❌ ' + T.itadConnFail + ': ' + e.message + '</span>';
                } finally {
                    itadTestBtn.disabled = false;
                    itadTestBtn.textContent = T.itadTestConn;
                }
            });
        }

        body.appendChild(wrap);
    }

    // ==================== v2.9.4: Barter.vg Bundle 数据库 (进包历史·离线程动态加载) ====================
    // 数据源: https://bartervg.com/browse/bundles/json/
    // 返回格式: {"18500":{"bundles":5,"bundles_packages":3},"232810":{"bundles":1},...}
    // Key 是 appID 字符串, value.bundles = 进过的包数量
    // v2.9.4: 原始 JSON 达数 MB，主线程 JSON.parse / GM_setValue 大对象会卡顿 UI。
    //   改为：① 获取原始文本（不解析）→ ② Web Worker 离线程解析并按库存 appId 裁剪
    //   → ③ 仅缓存精简映射 {appId: 进包次数}（体积小，GM_setValue 毫秒级）。
    //   Worker 不可用（CSP 等）时回退主线程分片扫描（每片 ≤12ms，让出主线程）。
    const BUNDLE_DB_API_URL = 'https://bartervg.com/browse/bundles/json/';
    // v2.9.15: 使用缓存版本号系统自动管理 schema 升级
    const BUNDLE_DB_CACHE_KEY = 'sglv_bundle_db_cache';        // 旧版大体积缓存（废弃，加载成功后清空）
    const BUNDLE_DB_CACHE_KEY_V2 = nsKey('bundle_db_cache_v2');  // { data, appIds, all, timestamp }
    const BUNDLE_DB_NEG_KEY = nsKey('bundle_db_neg');             // 负缓存 key
    const BUNDLE_DB_NEG_TTL = 30 * 60 * 1000;                    // 负缓存 30 分钟
    const BUNDLE_DB_CACHE_TTL = 48 * 60 * 60 * 1000; // 48小时

    let bundleDbData = null;   // { "appId": 进包次数 }（仅覆盖库存内 appId）
    let bundleDbLoading = false;

    function getBundleCount(appId) {
        if (!bundleDbData || !appId) return 0;
        const entry = bundleDbData[String(appId)];
        if (!entry) return 0;
        return typeof entry === 'number' ? entry : (entry.bundles || 0);
    }

    // Web Worker 源码（ES5）：解析大 JSON 并按 wanted 裁剪，仅回传精简计数映射
    const BUNDLE_PARSE_WORKER_SRC =
        'self.onmessage = function(e) {\n' +
        '    var text = e.data.text;\n' +
        '    var wanted = (e.data.wanted && e.data.wanted.length) ? new Set(e.data.wanted) : null;\n' +
        '    try {\n' +
        '        var json = JSON.parse(text);\n' +
        '        var keys = Object.keys(json);\n' +
        '        var out = {};\n' +
        '        for (var i = 0; i < keys.length; i++) {\n' +
        '            var k = keys[i];\n' +
        '            if (wanted && !wanted.has(k)) continue;\n' +
        '            var entry = json[k];\n' +
        '            var n = (entry && entry.bundles) ? entry.bundles : 0;\n' +
        '            if (n > 0) out[k] = n;\n' +
        '        }\n' +
        '        self.postMessage({ ok: true, total: keys.length, data: out });\n' +
        '    } catch (err) {\n' +
        '        self.postMessage({ ok: false, error: String(err) });\n' +
        '    }\n' +
        '};';

    function parseBundleJsonInWorker(text, wantedAppIds, timeoutMs = 15000) {
        return new Promise((resolve, reject) => {
            let worker = null;
            try {
                const blob = new Blob([BUNDLE_PARSE_WORKER_SRC], { type: 'application/javascript' });
                worker = new Worker(URL.createObjectURL(blob));
            } catch (e) { reject(e); return; }
            const timer = setTimeout(() => {
                try { worker.terminate(); } catch (e) {}
                reject(new Error('worker timeout'));
            }, timeoutMs);
            worker.onmessage = (e) => {
                clearTimeout(timer);
                try { worker.terminate(); } catch (err) {}
                const msg = e.data || {};
                if (msg.ok) resolve(msg); else reject(new Error(msg.error || 'worker parse failed'));
            };
            worker.onerror = () => {
                clearTimeout(timer);
                try { worker.terminate(); } catch (err) {}
                reject(new Error('worker error'));
            };
            worker.postMessage({ text: text, wanted: wantedAppIds });
        });
    }

    // 兜底：主线程分片正则扫描（每片 ≤12ms 后让出主线程，UI 保持响应）
    function parseBundleJsonChunked(text, wantedAppIds) {
        return new Promise((resolve, reject) => {
            const wanted = (wantedAppIds && wantedAppIds.length) ? new Set(wantedAppIds) : null;
            const re = /"(\d+)":\s*\{\s*"bundles":(\d+)/g;
            const out = {};
            let total = 0;
            function step() {
                const sliceStart = performance.now();
                let m;
                while ((m = re.exec(text)) !== null) {
                    total++;
                    if (!wanted || wanted.has(m[1])) {
                        const n = parseInt(m[2], 10);
                        if (n > 0) out[m[1]] = n;
                    }
                    if ((total & 1023) === 0 && performance.now() - sliceStart > 12) {
                        setTimeout(step, 0);
                        return;
                    }
                }
                // v2.9.5: 0 匹配时警告 JSON 结构可能已变更
                if (total === 0) console.warn('[SGLV] Bundle 分片解析 0 匹配——Barter.vg JSON 结构可能已变更');
                resolve({ total: total, data: out });
            }
            try { step(); } catch (e) { reject(e); }
        });
    }

    async function loadBundleDatabase() {
        if (bundleDbData || bundleDbLoading) return bundleDbData;
        bundleDbLoading = true;
        try {
            // v2.9.15: 负缓存——30 分钟内失败不重试
            if (negCacheGet(BUNDLE_DB_NEG_KEY, BUNDLE_DB_NEG_TTL)) {
                console.log('[SGLV] Bundle 数据库命中负缓存，跳过重试');
                return null;
            }
            // 库存 appId 集合：按需裁剪，降低内存占用与缓存写入体积
            const wantedAppIds = (state.ownedGames || []).map(g => String(g.appid));
            // v2.9.4: v2 精简缓存命中条件——未过期且覆盖当前全部库存 appId
            const cached = GM_getValue(BUNDLE_DB_CACHE_KEY_V2, null);
            if (cached && cached.timestamp && (Date.now() - cached.timestamp < BUNDLE_DB_CACHE_TTL) && cached.data) {
                const covered = new Set(cached.appIds || []);
                const fullyCovered = wantedAppIds.length === 0 ? !!cached.all : wantedAppIds.every(id => covered.has(id));
                if (fullyCovered) {
                    bundleDbData = cached.data;
                    console.log(`[SGLV] Bundle 数据库缓存命中: ${Object.keys(bundleDbData).length} 条记录（精简版）`);
                    return bundleDbData;
                }
            }
            console.log('[SGLV] 正在从 Barter.vg 获取 Bundle 数据库（离线程解析）...');
            const text = await sglvGmFetchTextRetry(BUNDLE_DB_API_URL, { timeout: 30000, retries: 2 });
            let parsed = null;
            try {
                parsed = await parseBundleJsonInWorker(text, wantedAppIds);
            } catch (we) {
                console.warn('[SGLV] Worker 解析不可用，回退主线程分片解析:', we);
                parsed = await parseBundleJsonChunked(text, wantedAppIds);
            }
            if (!parsed || parsed.total < 7000) {
                throw new Error('Barter.vg bundles data sanity check failed');
            }
            bundleDbData = parsed.data;
            GM_setValue(BUNDLE_DB_CACHE_KEY_V2, { data: parsed.data, appIds: wantedAppIds, all: wantedAppIds.length === 0, timestamp: Date.now() });
            // 清理旧版大体积缓存，释放存储
            try { GM_setValue(BUNDLE_DB_CACHE_KEY, null); } catch (e) {}
            // 成功后清掉负缓存
            negCacheClear(BUNDLE_DB_NEG_KEY);
            console.log(`[SGLV] Bundle 数据库加载完成: 全库 ${parsed.total} 条，库存命中 ${Object.keys(parsed.data).length} 条（未阻塞 UI 主线程）`);
            return bundleDbData;
        } catch(e) {
            console.warn('[SGLV] Bundle 数据库加载失败:', e);
            // v2.9.15: 失败入负缓存
            negCacheSet(BUNDLE_DB_NEG_KEY, e.message || String(e));
            sglvNotifyNetFail('Bundle 数据库 (Barter.vg)', e);   // v2.9.114: 终态失败系统通知(60s 节流)
            return null;
        } finally {
            bundleDbLoading = false;
        }
    }

    // ==================== v2.9.1: Barter.vg DLC 数据库 (识别 DLC 及其父游戏) ====================
    // 数据源: https://bartervg.com/browse/dlc/json/
    // 返回格式: {"239550":{"base_appID":221380,"base_item_id":125},...}
    // Key 是 DLC 的 appID, base_appID 是父游戏 appID
    const DLC_DB_API_URL = 'https://bartervg.com/browse/dlc/json/';
    const DLC_DB_CACHE_KEY = 'sglv_dlc_db_cache';
    // v1.9.2: 48h → 72h（3 天）—DLC 数据只增不减,延长 TTL 减少网络请求
    const DLC_DB_CACHE_TTL = 72 * 60 * 60 * 1000; // 72小时（3天）

    let dlcDbData = null;   // { "dlcAppId": { base_appID: 123, base_item_id: 45 } }
    let dlcDbPromise = null;  // v2.9.5: 存储 in-flight Promise，避免并发调用返回 null
    let appTypeMap = null;  // v2.9.6: 全库存应用的 Steam type 映射（补充 Barter.vg 未覆盖的 DLC）
    let appTypePromise = null;  // v2.9.6: in-flight Promise，避免并发调用
    let _dlcsByParentCache = null;  // v2.9.46: 父游戏→DLC列表 反向映射缓存

    function isDlc(appId) {
        if (!appId) return false;
        const id = String(appId);
        // v2.9.6: 双源检测——Barter.vg DLC 数据库 OR Steam Store API type=1(dlc)/type=6(music)
        if (dlcDbData && dlcDbData[id]) return true;
        if (appTypeMap) {
            const t = appTypeMap[id];
            if (t === 'dlc' || t === 'music') return true;
        }
        return false;
    }

    // v2.9.5: 同步从缓存加载 DLC 数据库（GM_getValue 同步读取）
    // 在 renderGamesList() 首次渲染前调用，确保 isDlc() 可用
    // 避免总游戏数在 DLC 数据库异步加载前错误包含 DLC 数量
    // v2.9.6: 同时从缓存加载 appTypeMap（全库存应用类型），补充 Barter.vg 未覆盖的 DLC
    function loadDlcDatabaseFromCacheSync() {
        if (!dlcDbData) {
            try {
                const cached = GM_getValue(DLC_DB_CACHE_KEY, null);
                if (cached && cached.timestamp && (Date.now() - cached.timestamp < DLC_DB_CACHE_TTL)) {
                    dlcDbData = cached.data;
                    console.log(`[SGLV] DLC 数据库缓存命中 (sync): ${Object.keys(dlcDbData).length} 条记录`);
                }
            } catch(e) {
                console.warn('[SGLV] DLC 数据库缓存读取失败:', e);
            }
        }
        // v2.9.6: 同步加载全库存应用类型缓存
        if (!appTypeMap) {
            try {
                const cached = GM_getValue(APP_TYPES_CACHE_KEY, null);
                if (cached && cached.timestamp && (Date.now() - cached.timestamp < APP_TYPES_CACHE_TTL)) {
                    appTypeMap = cached.data;
                    console.log(`[SGLV] 全库存应用类型缓存命中 (sync): ${Object.keys(appTypeMap).length} 条`);
                }
            } catch(e) {
                console.warn('[SGLV] 全库存应用类型缓存读取失败:', e);
            }
        }
    }

    async function loadDlcDatabase() {
        if (dlcDbData) return dlcDbData;
        if (dlcDbPromise) return dlcDbPromise;  // v2.9.5: 返回 in-flight Promise，避免并发调用返回 null
        dlcDbPromise = (async () => {
            try {
                const cached = GM_getValue(DLC_DB_CACHE_KEY, null);
                if (cached && cached.timestamp && (Date.now() - cached.timestamp < DLC_DB_CACHE_TTL)) {
                    dlcDbData = cached.data;
                    console.log(`[SGLV] DLC 数据库缓存命中: ${Object.keys(dlcDbData).length} 条记录`);
                    return dlcDbData;
                }
                console.log('[SGLV] 正在从 Barter.vg 获取 DLC 数据库...');
                const json = await sglvGmFetchRetry(DLC_DB_API_URL, { timeout: 30000, retries: 2 });
                if (!json || Object.keys(json).length < 7000) {
                    throw new Error('Barter.vg DLC data sanity check failed');
                }
                dlcDbData = json;
                GM_setValue(DLC_DB_CACHE_KEY, { data: json, timestamp: Date.now() });
                console.log(`[SGLV] DLC 数据库加载完成: ${Object.keys(json).length} 条记录`);
                return dlcDbData;
            } catch(e) {
                console.warn('[SGLV] DLC 数据库加载失败:', e);
                sglvNotifyNetFail('DLC 数据库 (Barter.vg)', e);   // v2.9.114: 终态失败系统通知(60s 节流)
                return null;
            } finally {
                dlcDbPromise = null;
            }
        })();
        return dlcDbPromise;
    }

    // ==================== v2.9.1: DLC 类型子分类 (音乐/视频/常规DLC等) ====================
    // 通过 Steam IStoreBrowseService/GetItems 批量获取 type 字段
    // Steam GetItems type: 0=game, 1=dlc, 2=software, 3=video, 4=series, 6=music, 7=tool, 8=video_series
    let dlcTypeMap = null;  // { appId: 'music' | 'dlc' | 'video' | ... }
    let dlcTypeLoading = false;

    function getDlcType(appId) {
        if (!dlcTypeMap || !appId) return null;
        return dlcTypeMap[String(appId)] || null;
    }

    // v2.9.68: 增量式 DLC 类型获取 — 只获取 dlcTypeMap 中不存在的类型,合并而非替换
    // 支持 onProgress 回调供渐进式渲染,支持 options 参数扩展
    async function enrichDlcTypes(dlcAppIds, options = {}) {
        if (!dlcAppIds || dlcAppIds.length === 0) return;
        const { onProgress } = options;

        // v2.9.68: 如果正在加载,等待完成后再检查增量(避免并发请求)
        if (dlcTypeLoading) {
            console.log('[SGLV] enrichDlcTypes — 等待已有加载完成...');
            let waitCount = 0;
            while (dlcTypeLoading && waitCount < 60) {
                await new Promise(r => setTimeout(r, 500));
                waitCount++;
            }
        }

        // v2.9.68: 先尝试从 GM 缓存加载(如果 dlcTypeMap 尚未初始化)
        // DLC 类型不变,缓存永久有效(移除 72h TTL 限制)
        if (!dlcTypeMap) {
            const cached = GM_getValue('sglv_dlc_types_cache', null);
            if (cached && cached.data) {
                dlcTypeMap = cached.data;
                console.log(`[SGLV] DLC 类型 GM 缓存命中: ${Object.keys(dlcTypeMap).length} 条`);
            }
        }

        // v2.9.68: 增量模式 — 只获取 dlcTypeMap 中不存在的 DLC 类型
        const needEnrich = dlcAppIds.filter(id => !dlcTypeMap || !dlcTypeMap[String(id)]);
        if (needEnrich.length === 0) {
            console.log(`[SGLV] enrichDlcTypes — 全部 ${dlcAppIds.length} 个 DLC 类型已存在,跳过`);
            return;
        }

        dlcTypeLoading = true;
        try {
            console.log(`[SGLV] 正在获取 ${needEnrich.length}/${dlcAppIds.length} 个 DLC 的类型信息...`);
            const CHUNK = 100, CONCURRENCY = 3;
            const chunks = [];
            for (let i = 0; i < needEnrich.length; i += CHUNK) chunks.push(needEnrich.slice(i, i + CHUNK));
            const typeMap = {};
            let qIdx = 0;
            let doneCount = 0;
            const worker = async () => {
                while (qIdx < chunks.length) {
                    const chunk = chunks[qIdx++];
                    try {
                        const input = {
                            ids: chunk.map(id => ({ appid: id })),
                            context: { language: 'schinese', country_code: 'CN', steam_realm: 1 },
                            data_request: { include_release: false }
                        };
                        const url = 'https://api.steampowered.com/IStoreBrowseService/GetItems/v1?input_json=' + encodeURIComponent(JSON.stringify(input));
                        const resp = await requestSteamAPI(url);
                        const storeItems = resp?.response?.store_items || [];
                        storeItems.forEach(si => {
                            if (si && si.appid) {
                                let typeStr = 'dlc';
                                if (typeof si.type === 'number') {
                                    typeStr = ({ 0: 'game', 1: 'dlc', 2: 'software', 3: 'video', 4: 'series', 6: 'music', 7: 'tool', 8: 'video_series' })[si.type] || 'other';
                                } else if (si.type) {
                                    typeStr = String(si.type).toLowerCase();
                                }
                                typeMap[String(si.appid)] = typeStr;
                                // 同时补充 DLC 名称
                                if (si.name) {
                                    const nc = sglvGameNameCacheLoad();
                                    nc[String(si.appid)] = { name: si.name, ts: Date.now() };
                                }
                            }
                        });
                    } catch (e) { console.warn('[SGLV] DLC type batch failed:', e); }
                    doneCount += chunk.length;
                    if (onProgress) try { onProgress(doneCount, needEnrich.length); } catch (e) {}
                    await new Promise(r => setTimeout(r, 200));
                }
            };
            const workers = [];
            for (let i = 0; i < CONCURRENCY; i++) workers.push(worker());
            await Promise.all(workers);

            // v2.9.68: 合并新类型到 dlcTypeMap(而非替换),实现"只增不减"永久缓存
            if (!dlcTypeMap) dlcTypeMap = {};
            let newCount = 0;
            for (const [k, v] of Object.entries(typeMap)) {
                if (!dlcTypeMap[k]) { dlcTypeMap[k] = v; newCount++; }
            }
            GM_setValue('sglv_dlc_types_cache', { data: dlcTypeMap, timestamp: Date.now() });
            if (isZh) { try { sglvGameNameCacheSave(); } catch (e) {} }
            console.log(`[SGLV] DLC 类型获取完成: 新增 ${newCount} 条, 累计 ${Object.keys(dlcTypeMap).length} 条`);
        } catch(e) {
            console.warn('[SGLV] DLC 类型获取失败:', e);
        } finally {
            dlcTypeLoading = false;
        }
    }

    // ==================== v2.9.6: 全库存应用类型获取（补充 Barter.vg DLC 数据库未覆盖的 DLC） ====================
    // 通过 Steam IStoreBrowseService/GetItems 批量获取所有库存应用的 type 字段
    // Barter.vg DLC 数据库覆盖不全（部分新 DLC 或冷门 DLC 未收录），
    // 此函数用 Steam 官方 API 补充识别 type=1(dlc) 和 type=6(music) 的应用
    const APP_TYPES_CACHE_KEY = 'sglv_app_types_cache';
    // v1.9.2: 48h → 72h（3 天）—库存应用类型变化极慢
    const APP_TYPES_CACHE_TTL = 72 * 60 * 60 * 1000; // 72小时（3天）

    async function enrichOwnedAppTypes(onProgress) {
        if (appTypeMap || appTypePromise) return appTypePromise;
        const allItems = (storage.getShowFamilyShared() ? state.ownedGames : state.ownedGames.filter(g => isGameOwnedByMe(g)));
        const appIds = allItems.map(g => g.appid);
        if (appIds.length === 0) return null;
        const report = (pct, text) => { if (typeof onProgress === 'function') onProgress(pct, text); };

        appTypePromise = (async () => {
            try {
                // v2.9.15: 负缓存——全失败时短期不再重试,保护 Steam API
                if (negCacheGet(nsKey('app_types_neg'), 30 * 60 * 1000)) {
                    console.log('[SGLV] app types 命中负缓存,跳过重试');
                    return null;
                }
                // 检查缓存
                const cached = GM_getValue(APP_TYPES_CACHE_KEY, null);
                if (cached && cached.timestamp && (Date.now() - cached.timestamp < APP_TYPES_CACHE_TTL)) {
                    appTypeMap = cached.data;
                    console.log(`[SGLV] 全库存应用类型缓存命中: ${Object.keys(appTypeMap).length} 条`);
                    report(100, isZh ? 'appdetails 缓存命中' : 'appdetails cached');
                    return appTypeMap;
                }
                report(0, isZh ? `正在补全 ${appIds.length} 款游戏详情…` : `Enriching ${appIds.length} games…`);
                console.log(`[SGLV] 正在获取 ${appIds.length} 个库存应用的类型信息...`);
                const CHUNK = 200, CONCURRENCY = 3;
                const chunks = [];
                for (let i = 0; i < appIds.length; i += CHUNK) chunks.push(appIds.slice(i, i + CHUNK));
                const typeMap = {};
                let doneCount = 0;
                let qIdx = 0;
                const total = chunks.length;
                const worker = async () => {
                    while (qIdx < chunks.length) {
                        const chunk = chunks[qIdx++];
                        try {
                            const input = {
                                ids: chunk.map(id => ({ appid: id })),
                                context: { language: 'schinese', country_code: 'CN', steam_realm: 1 },
                                data_request: { include_release: false }
                            };
                            const url = 'https://api.steampowered.com/IStoreBrowseService/GetItems/v1?input_json=' + encodeURIComponent(JSON.stringify(input));
                            const resp = await requestSteamAPI(url);
                            const storeItems = resp?.response?.store_items || [];
                            storeItems.forEach(si => {
                                if (si && si.appid) {
                                    let typeStr = 'game';
                                    if (typeof si.type === 'number') {
                                        typeStr = ({ 0: 'game', 1: 'dlc', 2: 'software', 3: 'video', 4: 'series', 6: 'music', 7: 'tool', 8: 'video_series' })[si.type] || 'other';
                                    } else if (si.type) {
                                        typeStr = String(si.type).toLowerCase();
                                    }
                                    typeMap[String(si.appid)] = typeStr;
                                }
                            });
                        } catch (e) { console.warn('[SGLV] App type batch failed:', e); }
                        doneCount++;
                        // v2.9.15: 进度回调（throttle 用 setTimeout 简单实现，避免每批次都更新）
                        if (total > 0) report(Math.round(doneCount / total * 100), isZh ? `已补全 ${doneCount}/${total} 批…` : `${doneCount}/${total} batches…`);
                        await new Promise(r => setTimeout(r, 200));
                    }
                };
                const workers = [];
                for (let i = 0; i < CONCURRENCY; i++) workers.push(worker());
                await Promise.all(workers);
                appTypeMap = typeMap;
                GM_setValue(APP_TYPES_CACHE_KEY, { data: typeMap, timestamp: Date.now() });
                // v2.9.6: appTypeMap 加载后失效 DLC 数量缓存，使下次统计使用双源检测
                _cachedDlcCount = null;
                _cachedDlcCountKey = '';
                // 成功清负缓存
                negCacheClear(nsKey('app_types_neg'));
                report(100, isZh ? '详情补全完成' : 'Enrichment done');
                console.log(`[SGLV] 全库存应用类型获取完成: ${Object.keys(typeMap).length} 条`);
                return appTypeMap;
            } catch(e) {
                console.warn('[SGLV] 全库存应用类型获取失败:', e);
                // v2.9.15: 失败入负缓存
                negCacheSet(nsKey('app_types_neg'), e.message || String(e));
                return null;
            } finally {
                appTypePromise = null;
            }
        })();
        return appTypePromise;
    }

    // ==================== 游戏橱窗标签页 ====================
    function renderOwnedTab(parent) {
        // v2.4.5: 恢复持久化的排序偏好
        state.ownedSort = storage.getOwnedSort();
        // 顶部统计仪表板
        const dashboard = document.createElement('div');
        dashboard.className = 'sglv-stats-dashboard';
        dashboard.id = 'sglv-owned-dashboard';
        parent.appendChild(dashboard);

        // 工具栏（获取按钮已合并到面板头部刷新按钮）
        // v2.9.3: 紧凑布局——第1行搜索+排序+视图切换+分页；筛选改为点击上方 KPI 卡片（合并自 2.9.0 思路）
        // v2.11.15 (FEAT-013 TASK-002): 工具栏经 buildListToolbar 工厂;排序选中值保持「渲染后 .value=」路径
        const toolbar = buildListToolbar({
            search: { id: 'sglv-search', placeholder: T.searchPlaceholder, value: state.searchQuery },
            sort: {
                id: 'sglv-sort', title: T.sortLabel,
                options: [
                    { value: 'appidAsc', label: T.sortAppidAsc },
                    { value: 'appidDesc', label: T.sortAppidDesc },
                    { value: 'nameAsc', label: T.sortNameAsc },
                    { value: 'acquiredDesc', label: T.sortAcquiredDesc },
                    { value: 'acquiredAsc', label: T.sortAcquiredAsc },
                    { value: 'playtimeDesc', label: T.sortPlaytimeDesc },
                    { value: 'lastPlayedDesc', label: T.sortLastPlayedDesc },
                    { value: 'bundleDesc', label: T.sortBundleDesc },
                ],
            },
            views: {
                modes: [
                    { mode: 'card', title: T.cardView, icon: ICONS.grid },
                    { mode: 'cover', title: T.coverView, icon: ICONS.cover },
                    { mode: 'list', title: T.listView, icon: ICONS.list },
                ],
                value: state.viewMode, useDataView: true,
            },
            extraHtml: `<div class="sglv-pagination sglv-pagination-inline" id="sglv-pagination"></div>`,
            onChange: ({ type, value }) => {
                // v2.9.49: debounce 搜索输入（工厂内统一 200ms），避免大库场景每次按键触发完整重渲染
                if (type === 'input') { state.searchQuery = value; state.page = 1; renderGamesList(); }
                // v2.4.5: 排序下拉——切换后持久化并重置到第一页；按入库时间排序时后台补齐缺失的入库时间
                else if (type === 'sort') {
                    state.ownedSort = value;
                    storage.setOwnedSort(value);
                    state.page = 1;
                    renderGamesList();
                    if (value.startsWith('acquired')) enrichAcquiredTimesForSort();
                } else if (type === 'view') { state.viewMode = value; renderGamesList(); }
            },
        });
        toolbar.querySelector('#sglv-sort').value = state.ownedSort;
        parent.appendChild(toolbar);

        // v2.9.3: KPI 卡片点击筛选——点击统计卡片切换筛选状态（合并自 2.9.0 思路）
        dashboard.addEventListener('click', e => {
            const card = e.target.closest('[data-filter]');
            if (!card) return;
            const filter = card.dataset.filter;
            state.ownedFilter = state.ownedFilter === filter ? 'all' : filter;
            state.page = 1;
            renderGamesList();
        });

        // 游戏列表容器
        const content = document.createElement('div');
        content.className = 'sglv-content';
        content.id = 'sglv-games-content';
        parent.appendChild(content);

        // v2.9.5: 在首次渲染前同步从缓存加载 DLC 数据库（GM_getValue 同步读取）
        // 确保 dlcDbData 已从缓存载入，使首次 renderGamesList() 的 isDlc() 即可正确工作
        // 避免总游戏数在 DLC 数据库加载前错误包含 DLC 数量
        loadDlcDatabaseFromCacheSync();

        renderGamesList();
    }

    // v2.11.35 (FEAT-015 TASK-002): 库存 Tab 数据准备(自 renderOwnedTab 外提)
    // Bundle/卡牌/DLC 数据库异步加载与全库存类型补全——加载完成后刷新仪表板
    // (各数据库函数自带 in-flight/缓存保护,重复进入不产生额外网络请求)
    function prepareOwnedTabData() {
        // v2.9.4: 异步加载 Bundle 数据库（Worker 离线程解析，不阻塞 UI）和卡牌数据库，加载完成后刷新仪表板
        loadBundleDatabase().then(() => {
            if (document.getElementById('sglv-owned-dashboard')) {
                renderGamesList();
            }
        }).catch(e => console.warn('[SGLV] Bundle DB load failed:', e));
        if (SGLV_API.loadCardDatabase) {
            SGLV_API.loadCardDatabase().then(() => {
                if (document.getElementById('sglv-owned-dashboard')) {
                    renderGamesList();
                }
            }).catch(e => console.warn('[SGLV] Card DB load failed:', e));
        }
        // v2.9.1: DLC 数据库已在前方调用 loadDlcDatabase() 启动加载；
        // v2.9.6: DLC 数据库加载后，启动全库存应用类型获取（补充 Barter.vg 未覆盖的 DLC）
        loadDlcDatabase().then(() => {
            if (document.getElementById('sglv-owned-dashboard')) {
                renderGamesList();
            }
            // v2.9.6: 用 Steam 官方 API 批量获取所有库存应用的 type，补充识别 Barter.vg 未收录的 DLC
            enrichOwnedAppTypes().then(() => {
                if (document.getElementById('sglv-owned-dashboard')) {
                    renderGamesList();
                }
                // 全库存 type 获取完成后，对已识别的 DLC 获取子分类（音乐/视频/常规DLC等）
                const allItems = (storage.getShowFamilyShared() ? state.ownedGames : state.ownedGames.filter(g => isGameOwnedByMe(g)));
                const dlcIds = allItems.filter(g => isDlc(g.appid)).map(g => g.appid);
                if (dlcIds.length > 0) {
                    enrichDlcTypes(dlcIds).then(() => {
                        if (document.getElementById('sglv-owned-dashboard')) renderGamesList();
                    });
                }
            }).catch(e => console.warn('[SGLV] App types enrichment failed:', e));
        }).catch(e => console.warn('[SGLV] DLC DB load failed:', e));
    }

    // v2.11.14 (FEAT-013 TASK-001): KPI 仪表板——自 renderGamesList 拆出（纯展示段搬移，逻辑未动）
    function renderOwnedKpiSummary(dashboard, showFamilyShared) {
        // v2.9.1: 游戏与 DLC 分离统计
        const allItems = showFamilyShared ? state.ownedGames : state.ownedGames.filter(g => isGameOwnedByMe(g));
        const realGames = allItems.filter(g => !isDlc(g.appid));
        const dlcGames = allItems.filter(g => isDlc(g.appid));
        const totalGames = realGames.length;
        // v2.9.22: 修复库存标签页与统计仪表总时长不一致——
        // 历史实现仅累加 realGames（不含 DLC），但统计仪表 playtime 标签页累加全量（含 DLC），
        // 导致两个 KPI 数字差异（如 4021.5h vs 4210.3h）。
        // 统一取 max(含DLC, 不含DLC)，确保两处显示一致，且以较大值为准。
        const realGamesMinutes = realGames.reduce((s, g) => s + (g.playtime || 0), 0);
        const allItemsMinutes = allItems.reduce((s, g) => s + (g.playtime || 0), 0);
        const totalMinutes = Math.max(realGamesMinutes, allItemsMinutes);
        const playedCount = realGames.filter(g => (g.playtime || 0) > 0).length;
        const unplayedCount = totalGames - playedCount;
        const sharedCount = state.ownedGames.filter(g => g.owners && g.owners.length > 0 && !isGameOwnedByMe(g) && !isDlc(g.appid)).length;
        const avgHoursPerGame = totalGames > 0 ? (totalMinutes / 60 / totalGames).toFixed(1) : '0';
        const playedPct = totalGames > 0 ? Math.round(playedCount / totalGames * 100) : 0;
        const unplayedPct = totalGames > 0 ? Math.round(unplayedCount / totalGames * 100) : 0;
        // v2.9.0: 进包/卡牌游戏统计（仅游戏，不含DLC）
        const bundledCount = realGames.filter(g => getBundleCount(g.appid) > 0).length;
        const cardCount = realGames.filter(g => SGLV_API.getCardDbMaxLevel && SGLV_API.getCardDbMaxLevel(g.appid) > 0).length;
        // v2.9.1: DLC 独立统计
        const dlcTotal = dlcGames.length;
        const dlcBundled = dlcGames.filter(g => getBundleCount(g.appid) > 0).length;
        const dlcMusic = dlcGames.filter(g => getDlcType(g.appid) === 'music').length;
        const dlcSubText = dlcTotal > 0 ? `${T.kpiDlcMusic} ${dlcMusic} · ${T.kpiDlcBundled} ${dlcBundled}` : (isZh ? '加载中...' : 'Loading...');
        // v2.11.1: 改经 kpiCards 工厂(tone:dash)，data-filter/active 语义不变
        dashboard.innerHTML = kpiCards([
            { icon: ICONS.library, label: T.statsTotalGames, value: totalGames.toLocaleString(), sub: `${T.kpiAvgHours} ${avgHoursPerGame}${T.kpiPerGame}`, color: 'blue', active: state.ownedFilter === 'all', dataFilter: 'all' },
            { icon: ICONS.trend, label: T.statsPlayed, value: playedCount.toLocaleString(), sub: `${T.kpiRate} ${playedPct}%`, color: 'green', active: state.ownedFilter === 'played', dataFilter: 'played' },
            { icon: ICONS.clock, label: T.statsUnplayed, value: unplayedCount.toLocaleString(), sub: `${T.kpiRate} ${unplayedPct}%`, color: 'red', active: state.ownedFilter === 'unplayed', dataFilter: 'unplayed' },
            { icon: ICONS.share, label: T.statsShared, value: sharedCount.toLocaleString(), sub: T.kpiFromFamily, color: 'purple', active: state.ownedFilter === 'shared', dataFilter: 'shared' },
            { icon: ICONS.package, label: T.statsBundled, value: bundledCount.toLocaleString(), sub: T.kpiInBundles, color: 'orange', active: state.ownedFilter === 'bundled', dataFilter: 'bundled' },
            { icon: ICONS.card, label: T.statsCards, value: cardCount.toLocaleString(), sub: T.kpiHasCards, color: 'teal', active: state.ownedFilter === 'cards', dataFilter: 'cards' },
            { icon: ICONS.package, label: T.statsDlcTotal, value: dlcTotal.toLocaleString(), sub: dlcSubText, color: 'pink', active: state.ownedFilter === 'dlconly', dataFilter: 'dlconly' },
        ], { tone: 'dash' });
    }

    function renderGamesList() {
        const content = document.getElementById('sglv-games-content');
        const pagination = document.getElementById('sglv-pagination');
        const dashboard = document.getElementById('sglv-owned-dashboard');
        if (!content) return;

        let games = [...state.ownedGames];
        const showFamilyShared = storage.getShowFamilyShared();
        if (!showFamilyShared) {
            games = games.filter(g => isGameOwnedByMe(g));
        }

        // v2.9.1: 所有筛选排除 DLC（dlconly 除外）
        if (state.ownedFilter !== 'dlconly') {
            games = games.filter(g => !isDlc(g.appid));
        }
        // 分类筛选
        if (state.ownedFilter === 'played') {
            games = games.filter(g => (g.playtime || 0) > 0);
        } else if (state.ownedFilter === 'unplayed') {
            games = games.filter(g => (g.playtime || 0) === 0);
        } else if (state.ownedFilter === 'shared') {
            games = games.filter(g => g.owners && g.owners.length > 0 && !isGameOwnedByMe(g));
        } else if (state.ownedFilter === 'owned') {
            games = games.filter(g => isGameOwnedByMe(g));
        } else if (state.ownedFilter === 'bundled') {
            games = games.filter(g => getBundleCount(g.appid) > 0);
        } else if (state.ownedFilter === 'cards') {
            games = games.filter(g => SGLV_API.getCardDbMaxLevel && SGLV_API.getCardDbMaxLevel(g.appid) > 0);
        } else if (state.ownedFilter === 'dlconly') {
            games = games.filter(g => isDlc(g.appid));
        }

        // 搜索过滤
        if (state.searchQuery) {
            const q = state.searchQuery.toLowerCase();
            games = games.filter(g => g.name.toLowerCase().includes(q));
        }

        // v2.4.5: 排序——默认 AppID 升序，修复原列表顺序不明的问题；次级键 AppID 保证顺序稳定确定
        // v2.9.49: 缓存 nameCollator 到模块级，避免每次 renderGamesList 都重新构造
        const sortKey = state.ownedSort || 'appidAsc';
        const acqTime = g => g.acquiredTime || 0;
        games.sort((a, b) => {
            let r = 0;
            switch (sortKey) {
                case 'appidDesc': r = b.appid - a.appid; break;
                case 'nameAsc': r = _nameCollator.compare(a.name || '', b.name || ''); break;
                case 'acquiredDesc': r = acqTime(b) - acqTime(a); break;
                case 'acquiredAsc': {
                    // 无入库时间的条目始终沉底，不随方向浮动
                    const x = acqTime(a), y = acqTime(b);
                    r = (!x && !y) ? 0 : !x ? 1 : !y ? -1 : x - y;
                    break;
                }
                case 'playtimeDesc': r = (b.playtime || 0) - (a.playtime || 0); break;
                case 'lastPlayedDesc': r = (b.lastPlayed || 0) - (a.lastPlayed || 0); break;
                case 'bundleDesc': r = getBundleCount(b.appid) - getBundleCount(a.appid); break;
                default: r = a.appid - b.appid; // appidAsc
            }
            return r || (a.appid - b.appid);
        });

        // 更新统计仪表板（依据“是否显示家庭共享”当前设置）
        // v2.11.14 (FEAT-013 TASK-001): KPI 仪表板段拆出为 renderOwnedKpiSummary（纯展示搬移）
        if (dashboard) renderOwnedKpiSummary(dashboard, showFamilyShared);

        // 分页
        // v2.4.0: 复用 paginate 纯函数统一分页计算
        // v2.9.31: 封面视图每页 24 项（横版卡片占位更大），卡片/列表保持 48
        const _effectivePageSize = state.viewMode === 'cover' ? 24 : state.pageSize;
        const { pageItems: pageGames, totalPages, page: _clampedPage } = paginate(games, state.page, _effectivePageSize);
        state.page = _clampedPage;

        if (games.length === 0) {
            content.innerHTML = emptyHtml(state.ownedGames.length === 0 ? T.noData : (isZh ? '无匹配游戏' : 'No matching games'));
            if (pagination) pagination.innerHTML = '';
            return;
        }

        // v2.9.31: 横版封面视图——3 列网格，胶囊横幅 + 徽章浮层 + 时长角标
        if (state.viewMode === 'cover') {
            const grid = document.createElement('div');
            grid.className = 'sglv-cover-grid';
            pageGames.forEach(g => {
                const card = document.createElement('div');
                card.className = 'sglv-cover-card';
                const isOwned = isGameOwnedByMe(g);
                const ownerNames = getGameOwnerNames(g);
                const hours = Math.round(g.playtime / 60);
                card.innerHTML = `
                    <div class="sglv-cover-img-wrap">
                        ${coverImgTag(g.appid, g.name, 'capsule', 'sglv-cover-img')}
                        <div class="sglv-cover-gradient"></div>
                        <div class="sglv-cover-badges">
                            ${!isOwned ? `<span class="sglv-cover-badge shared" title="${isZh ? '共享自' : 'Shared from'}: ${ownerNames}">${isZh ? '共享' : 'Shared'}</span>` : ''}
                            ${getBundleCount(g.appid) > 0 ? `<span class="sglv-cover-badge bundle" title="${T.bundleBadgeTip} ${getBundleCount(g.appid)} ${T.bundleBadgeUnit}">${ICONS.package}${getBundleCount(g.appid)}</span>` : ''}
                        </div>
                        ${hours > 0 ? `<div class="sglv-cover-playtime">${ICONS.clock}${hours}h</div>` : ''}
                    </div>
                    <div class="sglv-cover-body">
                        <div class="sglv-cover-name" data-sglv-appid="${g.appid}" title="${g.name}">${g.name}</div>
                        <div class="sglv-cover-meta">
                            <span class="sglv-cover-id">AppID: ${g.appid}</span>
                        </div>
                    </div>
                `;
                card.addEventListener('click', () => window.open(`https://store.steampowered.com/app/${g.appid}`, '_blank'));
                grid.appendChild(card);
            });
            content.innerHTML = '';
            content.appendChild(grid);
        } else if (state.viewMode === 'card') {
            // v2.11.14 (FEAT-013 TASK-001): card 骨架经 renderGameView 工厂（badge 语义留在插槽）
            content.innerHTML = renderGameView(pageGames, {
                viewMode: 'card',
                imgHtml: g => posterImg(g.appid, g.name),
                bodyHtml: g => {
                    const isOwned = isGameOwnedByMe(g);
                    const ownerNames = getGameOwnerNames(g);
                    return `
                        <div class="sglv-card-name" data-sglv-appid="${g.appid}" title="${g.name}">${g.name}</div>
                        <div class="sglv-card-id">AppID: ${g.appid}</div>
                        <div class="sglv-badge-row">
                            ${g.playtime > 0 ? `<div class="sglv-card-badge owned">${Math.round(g.playtime / 60)}h</div>` : ''}
                            ${!isOwned ? `<div class="sglv-card-badge shared" title="共享自: ${ownerNames}">共享</div>` : ''}
                            ${getBundleCount(g.appid) > 0 ? `<span class="sglv-bundle-badge" title="${T.bundleBadgeTip} ${getBundleCount(g.appid)} ${T.bundleBadgeUnit}">${getBundleCount(g.appid)}</span>` : ''}
                        </div>
                    `;
                },
            });
            // 渲染后绑定（保持现状模式，非事件代理；文档序 = map 生成序）
            content.querySelectorAll('.sglv-game-card').forEach((el, i) => {
                el.addEventListener('click', () => window.open(`https://store.steampowered.com/app/${pageGames[i].appid}`, '_blank'));
            });
        } else {
            // v2.11.14 (FEAT-013 TASK-001): list 骨架经 renderGameView 工厂（尾部徽章串经 trailingHtml）
            content.innerHTML = renderGameView(pageGames, {
                viewMode: 'list',
                imgHtml: g => headerImg(g.appid, g.name).replace('sglv-card-img', 'sglv-list-icon'),
                bodyHtml: g => {
                    const isOwned = isGameOwnedByMe(g);
                    const ownerNames = getGameOwnerNames(g);
                    return `
                        <div class="sglv-list-name" data-sglv-appid="${g.appid}">${g.name}</div>
                        <div class="sglv-list-meta">
                            <span>AppID: ${g.appid}</span>
                            ${!isOwned ? `<span style="color:var(--sglv-accent)">👥 共享自: ${ownerNames}</span>` : ''}
                        </div>
                    `;
                },
                trailingHtml: g => {
                    const hours = Math.round(g.playtime / 60);
                    const isOwned = isGameOwnedByMe(g);
                    return `
                        ${hours > 0 ? `<span class="sglv-list-badge owned">${hours}h</span>` : ''}
                        ${!isOwned ? `<span class="sglv-list-badge shared">共享</span>` : ''}
                        ${getBundleCount(g.appid) > 0 ? `<span class="sglv-bundle-badge" title="${T.bundleBadgeTip} ${getBundleCount(g.appid)} ${T.bundleBadgeUnit}">${getBundleCount(g.appid)}</span>` : ''}
                    `;
                },
            });
            content.querySelectorAll('.sglv-list-item').forEach((el, i) => {
                el.addEventListener('click', () => window.open(`https://store.steampowered.com/app/${pageGames[i].appid}`, '_blank'));
            });
        }

        // 分页导航
        renderPagination(pagination, 'sglv', state.page, totalPages, games.length,
            () => { state.page--; renderGamesList(); },
            () => { state.page++; renderGamesList(); },
            (p) => { state.page = p; renderGamesList(); });

        // v2.3.33：异步加载游戏中文名（参考 steam-friend-manager loadGameZhName）
        // v2.8.2：列表视图改用 loadGameNameAlias 追加灰色别名（中英文互补），卡片视图保持原替换逻辑
        // v2.11.4：改经 applyGameAliases 统一回填入口（aliasFor=列表视图灰色别名语义）
        applyGameAliases(content, { aliasFor: '.sglv-list-name' });
    }

    // v2.4.5: 按入库时间排序时，若当前库数据缺少 acquiredTime（如缓存/抓取来源），
    // 后台拉取家庭组数据补齐后重渲染，避免排序看似无效
    let _acquiredEnrichPending = false;
    function enrichAcquiredTimesForSort() {
        if (_acquiredEnrichPending) return;
        if (!state.ownedGames.length || state.ownedGames.some(g => g.acquiredTime > 0)) return;
        _acquiredEnrichPending = true;
        // v2.11.42: 个人拥有的游戏按个人许可页日期校准后再补齐（家人新入库共拥游戏不改变我的入库日期）
        buildCalibratedAcquiredMap().then(({ games: fg, map }) => {
            if (fg && fg.length) {
                let changed = 0;
                state.ownedGames.forEach(g => {
                    if (!g.acquiredTime && map[g.appid]) { g.acquiredTime = map[g.appid]; changed++; }
                });
                // 仅在仍按入库时间排序且列表仍展示时重渲染
                if (changed > 0 && (state.ownedSort || '').startsWith('acquired') && document.getElementById('sglv-games-content')) {
                    renderGamesList();
                }
            }
        }).catch(e => console.warn('[SGLV] 入库时间补齐失败:', e))
            .finally(() => { _acquiredEnrichPending = false; });
    }

    // ==================== 游玩时长标签页 ====================
    // v2.9.24: calcPlaytimeDist 支持 mode 参数——'count'(游戏数，默认) 或 'hours'(总时长)
    function calcPlaytimeDist(games, mode = 'count') {
        const cacheK = cacheKey('dist', mode, games.length, games.reduce((s, g) => s + (g.playtime || 0), 0));
        return getCached(cacheK, () => {
            const ranges = [
                { label: T.ptRange1, min: 0.01, max: 1, color: '#94a3b8' },
                { label: T.ptRange2, min: 1, max: 10, color: '#60a5fa' },
                { label: T.ptRange3, min: 10, max: 50, color: '#34d399' },
                { label: T.ptRange4, min: 50, max: 100, color: '#fbbf24' },
                { label: T.ptRange5, min: 100, max: 500, color: '#f97316' },
                { label: T.ptRange6, min: 500, max: Infinity, color: '#ef4444' }
            ];
            if (mode === 'hours') {
                // 时长维度：统计每个区间的总时长（小时），0 时长不计入
                return ranges.map(r => ({
                    label: r.label,
                    count: Math.round(games.filter(g => {
                        const h = (g.playtime || 0) / 60;
                        return h >= r.min && h < r.max;
                    }).reduce((s, g) => s + (g.playtime || 0) / 60, 0)),
                    color: r.color
                }));
            }
            // 游戏数维度（默认）
            const zeroCount = games.filter(g => (g.playtime || 0) === 0).length;
            return [
                { label: T.ptRange0, count: zeroCount, color: '#64748b' },
                ...ranges.map(r => ({
                    label: r.label,
                    count: games.filter(g => {
                        const h = (g.playtime || 0) / 60;
                        return h >= r.min && h < r.max;
                    }).length,
                    color: r.color
                }))
            ];
        });
    }

    function getPeriodKey(date, mode) {
        const y = date.getFullYear();
        const m = date.getMonth();
        if (mode === 'year') return `${y}`;
        if (mode === 'quarter') return `${y}-Q${Math.floor(m / 3) + 1}`;
        return `${y}-${String(m + 1).padStart(2, '0')}`;
    }

    function renderPlaytimeTrend(games, mode) {
        const cacheK = cacheKey('trend', mode, games.length, games.reduce((s, g) => s + (g.lastPlayed || 0), 0));
        return getCached(cacheK, () => {
            const played = games.filter(g => g.lastPlayed > 0);
            if (!played.length) return emptyHtml(isZh ? '暂无趋势数据' : 'No trend data', { style: 'font-size:11px' });
            const buckets = {};
            played.forEach(g => {
                const d = new Date(g.lastPlayed * 1000);
                const key = getPeriodKey(d, mode);
                buckets[key] = (buckets[key] || 0) + ((g.playtime || 0) / 60);
            });
            const dates = played.map(g => new Date(g.lastPlayed * 1000));
            const minDate = new Date(Math.min(...dates));
            const maxDate = new Date(Math.max(...dates));
            const periods = [];
            let cursor = new Date(minDate);
            while (cursor <= maxDate) {
                periods.push(getPeriodKey(cursor, mode));
                if (mode === 'year') cursor.setFullYear(cursor.getFullYear() + 1);
                else if (mode === 'quarter') cursor.setMonth(cursor.getMonth() + 3);
                else cursor.setMonth(cursor.getMonth() + 1);
            }
            const MAX_POINTS = mode === 'month' ? 12 : mode === 'quarter' ? 12 : 10;
            const displayPeriods = periods.slice(-MAX_POINTS);
            const displayValues = displayPeriods.map(p => buckets[p] || 0);
            if (displayValues.every(v => v === 0)) return emptyHtml(isZh ? '暂无趋势数据' : 'No trend data', { style: 'font-size:11px' });

            // v2.11.8 (FEAT-012 TASK-002): 手写 SVG 绘制段(~45 行)迁移 SGLVCharts.lineChart(area 形态)。
            // 数据整形(分桶/区间补零/截尾)与缓存 key 不变;原视觉语义全量注入:
            // 渐变 0.4→0.02/单点居中/均值虚线(均 Xh)/峰值标注/圆点描边/逐点 tooltip。
            // 几何坐标与 2.11.7 冻结基线一致(sglv-charts.test.js C7 断言)。
            const maxV = Math.max(...displayValues) || 1;
            const n = displayValues.length;
            const avgV = displayValues.reduce((s, v) => s + v, 0) / n;
            const maxIdx = displayValues.indexOf(maxV);
            return SGLVCharts.lineChart([{ data: displayValues }], {
                width: 400, height: 200, pL: 30, pR: 30, pT: 30, pB: 30,
                smooth: false, colors: [SGLVCharts.accent()], svgAttrs: 'class="sglv-trend-svg"',
                centerSinglePoint: true,
                area: { fill: SGLVCharts.accent(), opacity: 0.4 },
                gridCount: 4, yFormatter: v => v.toFixed(0) + 'h',
                xLabels: displayPeriods.map(p => mode === 'year' ? p : p.replace(/^\d{4}-/, '')),
                xLabelEvery: 6, xLabelLast: true,
                dots: { r: 3, stroke: '#0f172a', strokeWidth: 1, title: (v, i) => `${displayPeriods[i]}: ${v.toFixed(1)}h` },
                annotations: [
                    { type: 'refLine', value: avgV, color: 'rgba(251,191,36,0.5)', dash: '4,3', label: `${isZh ? '均' : 'avg'} ${avgV.toFixed(0)}h`, labelColor: '#fbbf24', fontSize: 8, fontWeight: 600 },
                    { type: 'point', idx: maxIdx, text: `${isZh ? '峰' : 'peak'} ${maxV.toFixed(0)}h`, color: '#fbbf24', fontSize: 9, fontWeight: 700, dy: -7 },
                ],
            });
        });
    }

    // v2.9.25: renderPlaytimeDonut 数值千分位格式化 + 中心文字自适应字号
    // v2.11.10: 环形绘制迁移 SGLVCharts.donutChart（dasharray/offset/rotate 算法库内唯一定义）；
    //           千分位格式化、中心字号自适应、图例值/百分比格式留在调用方（业务格式）；
    //           中心文本 y=46%/62% 换算为 240×0.46=110.4 / 240×0.62=148.8（数值坐标等价）
    function renderPlaytimeDonut(distData, total, unit = '') {
        if (total === 0) return emptyHtml(T.ptNoData);
        // v2.9.25: 数值格式化——千分位分隔，避免大数字溢出甜甜圈中心
        const fmt = (n) => n.toLocaleString();
        const pct = (n) => (n / total * 100).toFixed(1);
        // v2.9.25: 中心文字自适应字号——根据格式化后字符串长度动态缩放，避免溢出
        const totalStr = fmt(total) + unit;
        let centerFontSize;
        if (totalStr.length <= 5) centerFontSize = 28;
        else if (totalStr.length <= 7) centerFontSize = 24;
        else if (totalStr.length <= 9) centerFontSize = 20;
        else centerFontSize = 16;
        return SGLVCharts.donutChart(
            distData.map(d => ({ value: d.count, color: d.color, label: d.label })),
            {
                size: 240, thickness: 44, bg: false,
                title: sl => `${sl.label}: ${fmt(sl.value)}${unit} (${pct(sl.value)}%)`,
                segStyle: 'transition:all .3s ease',
                center: {
                    text: totalStr, fontSize: centerFontSize, weight: 'bold', fill: '#f8fafc', y: 110.4,
                    sub: isZh ? '总计' : 'Total', subFontSize: 11, subFill: '#8a9ba8', subY: 148.8,
                },
                legend: {
                    value: sl => `${fmt(sl.value)}${unit} <span class="sglv-donut-legend-pct">(${pct(sl.value)}%)</span>`,
                },
                wrap: true,
            }
        );
    }

    // v2.3.30: 入库热力图——参考 steam-family-game-analysis v1.41 的 buildHeatmapBlock 设计
    // 输入: games 数组（需含 acquiredTime 秒级时间戳）；输出 GitHub 式贡献热力图 SVG
    // v2.3.31: 新增缓存层——签名一致且 10 分钟内直接返回缓存的 HTML，跳过 SVG 重新计算
    // v2.4.2: 按年分割（参考 v1.58）——新增年份选择器，默认展示最新年份；
    //         "全部"视图保留跨年连续网格，并增加年份分隔线与年份标签
    // v2.9.22: 入库热力图骨架占位（GitHub 风格年份框架 + 灰格，无数据时也不会出现大片空白）
    // v2.11.3: 构建实现迁入共享区 SKELETONS.heatmap/monthly（createSkeleton 统一入口）
    // v2.11.13 (FEAT-012 TASK-007) 复用核查豁免结论: 本函数为「日历热力图」(日期驱动周网格+周对齐/
    // 离散5级GitHub绿阶+futureColor三态/月边界动态标注+年份分隔虚线/按年视图字典+10min渲染缓存),
    // 与 SGLVCharts.heatmap(「矩阵热力图」: 数值矩阵+连续色阶+静态轴标签)五维能力均不重叠;
    // 外链 collection lib 6848 行 grep 核查零消费 heatmap/SGLVCharts,无外链兼容负担,判定不迁移。
    function renderAcquiredHeatmap(heatGames) {
        const valid = heatGames.filter(g => g.acquiredTime && g.acquiredTime > 0);
        if (valid.length === 0) return emptyHtml(T.ptHeatmapNoData);

        // v2.3.31: 构建缓存签名——游戏数量 + 首尾 appid + 首尾入库时间，足够区分不同数据集
        const sig = valid.length + '_' + valid[0].appid + '_' + valid[valid.length - 1].appid
            + '_' + valid[0].acquiredTime + '_' + valid[valid.length - 1].acquiredTime;
        if (_heatmapRenderCache && _heatmapRenderCache.signature === sig
            && Date.now() - _heatmapRenderCache.ts < 10 * 60 * 1000) {
            return _heatmapRenderCache.html;
        }

        // 单次遍历构建日入库计数：全局 dayMap + 按年 dayMap，同时收集有效时间戳
        const dayMap = {};
        const yearDayMaps = {};
        const tsList = [];
        for (const g of valid) {
            const t = g.acquiredTime;
            const d = new Date(t * 1000);
            const y = d.getFullYear();
            const key = y + '-' + String(d.getMonth() + 1).padStart(2, '0') + '-' + String(d.getDate()).padStart(2, '0');
            dayMap[key] = (dayMap[key] || 0) + 1;
            const ym = yearDayMaps[y] || (yearDayMaps[y] = {});
            ym[key] = (ym[key] || 0) + 1;
            tsList.push(t);
        }
        tsList.sort((a, b) => a - b);
        const firstTs = tsList[0], lastTs = tsList[tsList.length - 1];
        const years = Object.keys(yearDayMaps).map(Number).sort((a, b) => a - b);

        const cellSize = 12, cellGap = 3, cellStep = cellSize + cellGap;
        const labelW = 26, yearH = 14, monthH = 16;
        const monthNames = ['1月', '2月', '3月', '4月', '5月', '6月', '7月', '8月', '9月', '10月', '11月', '12月'];
        const dayNames = ['', '一', '', '三', '', '五', ''];
        // GitHub 风格绿色 5 级色阶（暗→亮）
        const colors = ['#161b22', '#0e4429', '#006832', '#26a641', '#39d353'];
        // v2.9.22: 未来月份占位色（today 之后）—— 比 0 级 #161b22 略亮，让"未到时间"格子清晰可见且不与 0 级混淆
        const futureColor = '#30363d';
        function heatColor(count) {
            if (count === 0) return colors[0];
            if (count <= 1) return colors[1];
            if (count <= 2) return colors[2];
            if (count <= 4) return colors[3];
            return colors[4];
        }
        const fmtD = (d) => d.getFullYear() + '-' + String(d.getMonth() + 1).padStart(2, '0') + '-' + String(d.getDate()).padStart(2, '0');

        // 构建单个视图（某一年 / 全部）的完整 HTML：SVG + 图例 + 统计
        // showYearRow: 是否在顶部渲染年份标签与分隔线（仅"全部"跨年视图需要）
        function buildView(viewDayMap, rangeStartDate, rangeEndDate, avgSpanDays, showYearRow) {
            const globalStart = new Date(rangeStartDate);
            globalStart.setHours(0, 0, 0, 0);
            const endDate = new Date(rangeEndDate);
            endDate.setHours(0, 0, 0, 0);
            const gridStart = new Date(globalStart);
            gridStart.setDate(gridStart.getDate() - globalStart.getDay());
            const totalDays = Math.floor((endDate - gridStart) / 86400000) + 1;
            const totalWeeks = Math.ceil(totalDays / 7);
            const topH = (showYearRow ? yearH : 0) + monthH;
            const svgW = labelW + totalWeeks * cellStep + 8;
            const svgH = topH + 7 * cellStep + 8;

            let maxDaily = 0, total = 0;
            for (const k in viewDayMap) { if (viewDayMap[k] > maxDaily) maxDaily = viewDayMap[k]; total += viewDayMap[k]; }
            const avgDaily = (total / Math.max(1, avgSpanDays)).toFixed(2);

            const cellParts = [], monthLabelPositions = [], yearBoundaries = [];
            let lastMonth = -1, lastYear = -1;
            const startMs = globalStart.getTime(), endMs = endDate.getTime();
            for (let w = 0; w < totalWeeks; w++) {
                for (let d = 0; d < 7; d++) {
                    const cellTs = gridStart.getTime() + (w * 7 + d) * 86400000;
                    if (cellTs < startMs || cellTs > endMs) continue;
                    const cellDate = new Date(cellTs);
                    const key = cellDate.getFullYear() + '-' + String(cellDate.getMonth() + 1).padStart(2, '0') + '-' + String(cellDate.getDate()).padStart(2, '0');
                    const cnt = viewDayMap[key] || 0;
                    const x = labelW + w * cellStep, y = topH + d * cellStep;
                    if (cnt > 0) {
                        cellParts.push(`<rect x="${x}" y="${y}" width="${cellSize}" height="${cellSize}" rx="2" fill="${heatColor(cnt)}"><title>${key} · ${cnt} ${T.ptHeatmapAcquired}</title></rect>`);
                    } else {
                        // v2.9.22: 区分"已过但无数据"(colors[0]=#161b22) 与"未来"(futureColor=#30363d)——
                        // 当年视图 8-12 月位置用 futureColor 填充，一眼能看出"时间还没到"
                        const isFuture = cellDate.getTime() > today.getTime();
                        cellParts.push(`<rect x="${x}" y="${y}" width="${cellSize}" height="${cellSize}" rx="2" fill="${isFuture ? futureColor : colors[0]}"/>`);
                    }
                    if (d === 0) {
                        if (cellDate.getMonth() !== lastMonth) {
                            lastMonth = cellDate.getMonth();
                            monthLabelPositions.push({ w, month: cellDate.getMonth() });
                        }
                        if (showYearRow && cellDate.getFullYear() !== lastYear) {
                            lastYear = cellDate.getFullYear();
                            yearBoundaries.push({ w, year: cellDate.getFullYear() });
                        }
                    }
                }
            }
            // v2.4.2: 年份分隔线 + 年份标签（参考 v1.58），仅跨年视图渲染；首个边界不画线避免与坐标轴重叠
            const yearParts = [];
            for (const yb of yearBoundaries) {
                if (yb.w > 0) {
                    const lineX = labelW + yb.w * cellStep - cellGap / 2;
                    yearParts.push(`<line x1="${lineX}" y1="${yearH}" x2="${lineX}" y2="${topH + 7 * cellStep}" stroke="rgba(255,255,255,0.12)" stroke-width="1" stroke-dasharray="2,2"/>`);
                }
                yearParts.push(`<text x="${labelW + yb.w * cellStep}" y="${yearH - 3}" fill="#c6d4df" font-size="10" font-weight="600">${yb.year}</text>`);
            }
            const monthParts = monthLabelPositions.map(ml =>
                `<text x="${labelW + ml.w * cellStep}" y="${topH - 5}" fill="#8a9ba8" font-size="10">${monthNames[ml.month]}</text>`
            ).join('');
            const dayParts = [];
            for (let di = 0; di < 7; di++) {
                if (dayNames[di]) dayParts.push(`<text x="0" y="${topH + di * cellStep + 10}" fill="#64748b" font-size="10">${dayNames[di]}</text>`);
            }
            const svgStr = `<svg width="${svgW}" height="${svgH}" viewBox="0 0 ${svgW} ${svgH}" style="display:block;">${yearParts.join('')}${monthParts}${dayParts.join('')}${cellParts.join('')}</svg>`;

            // v2.4.9: 图例与统计摘要合并为同一行——图例在左，统计在右，避免图例溢出容器右下角
            const summary = `<div class="sglv-heatmap-summary">
                <span class="sglv-heatmap-legend"><span>${T.ptHeatmapLess}</span>${colors.map(c => `<span class="swatch" style="background:${c}"></span>`).join('')}<span>${T.ptHeatmapMore}</span></span>
                <span>${T.ptHeatmapTotal}: <b>${total}</b></span>
                <span>${T.ptHeatmapPeak}: <b style="color:#fbbf24">${maxDaily}</b></span>
                <span>${T.ptHeatmapAvg}: <b>${avgDaily}</b></span>
                <span>${fmtD(globalStart)} ~ ${fmtD(endDate)}</span>
            </div>`;
            return `<div class="sglv-heatmap-scroll">${svgStr}</div>${summary}`;
        }

        // 预计算各视图：每年一个单年视图 + 跨年"全部"视图
        const today = new Date();
        today.setHours(0, 0, 0, 0);
        const views = {};
        for (const y of years) {
            const yStart = new Date(y, 0, 1);
            // v2.9.22: 当年也画完整 1-12 月（不再截断到 today）—— 8-12 月位置用 futureColor 灰格填满，
            //          让"未到时间"以视觉可见的占位块显示，与真实数据区分清楚
            const yEnd = new Date(y, 11, 31);
            const avgSpan = Math.floor((yEnd - yStart) / 86400000) + 1;
            views[String(y)] = buildView(yearDayMaps[y], yStart, yEnd, avgSpan, false);
        }
        const allAvgSpan = Math.max(1, Math.ceil((lastTs - firstTs) / 86400) + 1);
        views.all = buildView(dayMap, new Date(firstTs * 1000), today, allAvgSpan, true);

        // 年份选择器（最新在前，末尾追加"全部"），默认展示最新年份；仅一年数据时无需选择器
        let filterHtml = '', defaultView = 'all';
        if (years.length > 1) {
            const latestYear = String(years[years.length - 1]);
            const btns = [...years].reverse().map(y =>
                `<button class="sglv-trend-btn sglv-hm-year-btn${String(y) === latestYear ? ' active' : ''}" data-year="${y}">${y}</button>`
            ).join('');
            filterHtml = `<div class="sglv-trend-filter sglv-hm-year-filter">${btns}<button class="sglv-trend-btn sglv-hm-year-btn" data-year="all">${T.ptHeatmapAll}</button></div>`;
            defaultView = latestYear;
        }

        // v2.6.1: 入库热力图与近6月入库增量分成两个独立容器——主热力图占满容器宽度，增量柱图作为独立 section 在 wrap 下方展示（不在热力图节点内）
        const html = `<div class="sglv-heatmap-block">
            ${filterHtml}
            <div class="sglv-heatmap-body">${views[defaultView]}</div>
        </div>`;
        // v2.3.31: 写入渲染缓存（v2.4.2 起含各年份视图，供年份切换直接复用）
        _heatmapRenderCache = { signature: sig, html, ts: Date.now(), views };
        return html;
    }

    // v2.4.4: 近6月入库增量迷你柱状图——展示于入库热力图右下角
    // 输入与热力图相同（含 acquiredTime 的游戏数组）；输出带标题的紧凑 SVG（6 根彩色柱 + 数值标签 + 网格线）
    function renderMonthlyAcquireChart(heatGames) {
        const now = new Date();
        const months = [];
        for (let i = 5; i >= 0; i--) {
            const d = new Date(now.getFullYear(), now.getMonth() - i, 1);
            months.push({ y: d.getFullYear(), m: d.getMonth(), count: 0 });
        }
        const startTs = new Date(months[0].y, months[0].m, 1).getTime() / 1000;
        for (const g of heatGames) {
            const t = g.acquiredTime;
            if (!t || t < startTs) continue;
            const d = new Date(t * 1000);
            const idx = (d.getFullYear() - months[0].y) * 12 + (d.getMonth() - months[0].m);
            if (idx >= 0 && idx < 6) months[idx].count++;
        }
        const max = Math.max(...months.map(o => o.count));
        const BAR_COLORS = ['#14b8a6', '#3b82f6', '#f59e0b', '#22c55e', '#ef4444', '#8b5cf6'];
        // v2.4.7: 侧栏紧凑尺寸（适配 260px 宽右栏，独立布局）
        // v2.9.26: 加高 SVG (H 128→200) 让柱图更方正，在高瘦右栏里减少上下留白
        const W = 280, H = 200, lw = 32, topPad = 20, botPad = 24;
        const plotW = W - lw - 2, plotH = H - topPad - botPad;
        const step = plotW / 6, barW = Math.min(26, step * 0.6);
        const yMax = max > 0 ? max : 1;
        const yOf = v => topPad + plotH - (v / yMax) * plotH;
        let parts = '';
        // 水平网格线 + Y 轴标签（0 / 半值 / 峰值，去重）
        const gridVals = max > 0 ? [...new Set([0, Math.ceil(max / 2), max])] : [0, 1];
        for (const v of gridVals) {
            const y = yOf(v);
            parts += `<line x1="${lw}" y1="${y}" x2="${W - 2}" y2="${y}" stroke="rgba(255,255,255,0.08)" stroke-width="1" stroke-dasharray="3,3"/>`;
            parts += `<text x="${lw - 4}" y="${y + 3}" fill="#64748b" font-size="9" text-anchor="end">${v}</text>`;
        }
        months.forEach((o, i) => {
            const cx = lw + step * i + step / 2;
            const bh = max > 0 ? (o.count / yMax) * plotH : 0;
            const bx = cx - barW / 2, by = topPad + plotH - bh;
            const color = BAR_COLORS[i % BAR_COLORS.length];
            // v2.9.24: count=0 的柱子显示极小高度 + 半透明，避免"标签无柱"困惑
            const isZero = o.count === 0;
            const renderBh = isZero ? 2 : Math.max(bh, 0);
            const renderBy = isZero ? topPad + plotH - 2 : by;
            const fillOpacity = isZero ? '0.25' : '1';
            parts += `<rect x="${bx.toFixed(1)}" y="${renderBy.toFixed(1)}" width="${barW}" height="${renderBh.toFixed(1)}" rx="3" fill="${color}" opacity="${fillOpacity}"><title>${o.y}-${String(o.m + 1).padStart(2, '0')} · ${o.count}${isZero ? (isZh ? ' (进行中)' : ' (in progress)') : ''}</title></rect>`;
            if (o.count > 0) {
                parts += `<text x="${cx}" y="${by - 3}" fill="${color}" font-size="9.5" font-weight="600" text-anchor="middle">${o.count}</text>`;
            }
            const lbl = String(o.y).slice(2) + '.' + String(o.m + 1).padStart(2, '0');
            parts += `<text x="${cx}" y="${H - 4}" fill="#8a9ba8" font-size="9" text-anchor="middle">${lbl}</text>`;
        });
        // v2.9.23: 增加标题栏统计（总数 + 峰值/低谷标注），参考设计图
        const totalAcq = months.reduce((s, o) => s + o.count, 0);
        const maxIdx = months.indexOf(months.reduce((mx, o) => o.count > mx.count ? o : mx, months[0]));
        const minIdx = months.indexOf(months.reduce((mn, o) => o.count < mn.count ? o : mn, months[0]));
        const maxMo = String(months[maxIdx].y).slice(2) + '.' + String(months[maxIdx].m + 1).padStart(2, '0');
        const minMo = String(months[minIdx].y).slice(2) + '.' + String(months[minIdx].m + 1).padStart(2, '0');
        const summaryHtml = `<div class="sglv-hm-mini-summary">
            <span class="sglv-hm-mini-stat"><b>${totalAcq}</b> ${isZh ? '总计' : 'total'}</span>
            <span class="sglv-hm-mini-stat" style="color:#22c55e">${isZh ? '峰值' : 'peak'} ${max} · ${maxMo}</span>
            <span class="sglv-hm-mini-stat" style="color:#ef4444">${isZh ? '低谷' : 'low'} ${months[minIdx].count} · ${minMo}</span>
        </div>`;
        return `<div class="sglv-hm-mini-inner">
            <div class="sglv-hm-mini-title">${T.ptHeatmapMini6m} · ${totalAcq}</div>
            <div class="sglv-hm-mini-chart">
                <svg viewBox="0 0 ${W} ${H}" preserveAspectRatio="xMidYMid meet" style="display:block;width:100%;height:100%;">${parts}</svg>
            </div>
            ${summaryHtml}
        </div>`;
    }

    // v2.3.28: 提取家庭组对比为独立函数——供游玩仪表和游玩数据标签页共用
    // v2.3.30: 新增 maxMembers 参数（默认6），不足时补齐"待加入"占位行
    // v2.3.31: visibleRows=4 控制默认可见行数，超出部分纵向滚动；pending 只补齐到 visibleRows
    // v2.9.22: 默认渲染 4 行灰色骨架行（与最终 bar row 样式一致），避免加载中底部大片空白
    function createFamilyCompareSection(totalMinutes, maxMembers = 6, visibleRows = 4) {
        const familySection = document.createElement('div');
        familySection.className = 'sglv-family-compare-section';
        familySection.innerHTML = `<div class="sglv-playtime-section-title">${ICONS.share} ${T.ptFamilyCompare}</div>`;

        const familyContainer = document.createElement('div');
        familyContainer.className = 'sglv-family-compare-container';
        familyContainer.innerHTML = createSkeleton('family', visibleRows);
        familySection.appendChild(familyContainer);

        const apiKey = storage.getApiKey();
        const mySteamId = getActiveSteamId();

        async function renderFamilyCompare() {
            const authToken = await getAccessToken().catch(() => null);
            const hasApiKey = !!apiKey;
            const hasToken = !!authToken;

            let familyInfo = storage.getFamilyInfo() || {};
            let nameMap = familyInfo.steamIdtoName || {};
            let members = familyInfo.family_member || [];
            let familyName = familyInfo.family_name || '';

            if (Object.keys(nameMap).length === 0 || members.length === 0) {
                // 保留骨架，仅在 familyContainer 顶部覆盖一行小提示
                if (authToken) {
                    try {
                        const freshInfo = await fetchFamilyInfo(authToken);
                        if (freshInfo) {
                            storage.setFamilyInfo(freshInfo);
                            nameMap = freshInfo.steamIdtoName || {};
                            members = freshInfo.family_member || [];
                            familyName = freshInfo.family_name || '';
                        }
                    } catch { /* ignore */ }
                }
            }

            const titleEl = familySection.querySelector('.sglv-playtime-section-title');
            if (titleEl) {
                const namePart = familyName ? `${familyName} · ` : '';
                titleEl.innerHTML = `${ICONS.share} ${namePart}${T.ptFamilyCompare}`;
            }

            if (!mySteamId || Object.keys(nameMap).length === 0) {
                let reason = '';
                if (!hasApiKey && !hasToken) reason = T.ptNoApiKey;
                else if (hasToken && Object.keys(nameMap).length === 0) reason = T.ptNoFamily;
                else reason = T.ptNoToken;
                familyContainer.innerHTML = `
                    <div style="text-align:center;padding:12px 8px">
                        ${emptyHtml(reason, { style: 'margin-bottom:10px' })}
                        <button class="sglv-btn sglv-btn-secondary" id="sglv-family-retry">${T.ptRetryBtn}</button>
                    </div>`;
                familyContainer.querySelector('#sglv-family-retry')?.addEventListener('click', () => {
                    storage.setFamilyInfo({});
                    renderFamilyCompare();
                });
                return;
            }

            const myName = nameMap[mySteamId] || (isZh ? '我' : 'Me');
            const list = [
                { steamId: String(mySteamId), name: myName, isMe: true },
                ...Object.entries(nameMap)
                    .filter(([sid]) => sid !== String(mySteamId))
                    .map(([sid, name]) => ({ steamId: sid, name: name || ('ID:' + String(sid).slice(-4)), isMe: false })),
            ];

            if (members.length > 0) {
                list.forEach(m => {
                    const fm = members.find(x => x.steamid === m.steamid);
                    if (fm?.userName) m.name = fm.userName;
                });
            }

            // 保留骨架直到 API 数据返回（避免家庭信息已就绪但成员时长仍在请求时出现空白）

            Promise.all(list.map(async m => {
                if (m.isMe) {
                    return { ...m, totalMinutes: totalMinutes };
                }
                try {
                    let data;
                    if (hasApiKey) {
                        data = await requestSteamAPI(
                            `https://api.steampowered.com/IPlayerService/GetOwnedGames/v0001/?key=${apiKey}&steamid=${m.steamId}&include_played_free_games=1&format=json`
                        );
                    } else if (authToken) {
                        data = await requestSteamAPI(
                            `https://api.steampowered.com/IPlayerService/GetOwnedGames/v1/?access_token=${authToken}&steamid=${m.steamId}&include_played_free_games=1`
                        );
                    } else {
                        return { ...m, totalMinutes: -1 };
                    }
                    const gList = data?.response?.games || [];
                    return { ...m, totalMinutes: gList.reduce((s, g) => s + (g.playtime_forever || 0), 0) };
                } catch {
                    return { ...m, totalMinutes: -1 };
                }
            })).then(results => {
                const valid = results.filter(r => r.totalMinutes >= 0);
                if (valid.length === 0) {
                    familyContainer.innerHTML = emptyHtml(isZh ? '获取失败，成员资料可能为私密' : 'Failed - profiles may be private');
                    return;
                }
                const maxMin = Math.max(1, ...valid.map(r => r.totalMinutes));
                // v2.3.30: 最多展示 maxMembers 条，按游玩时长降序取前 N；不足则补齐"待加入"占位行
                const sorted = valid.sort((a, b) => b.totalMinutes - a.totalMinutes);
                const displayList = sorted.slice(0, maxMembers);
                const pendingCount = Math.max(0, visibleRows - displayList.length);
                const memberRows = displayList.map(m => {
                    const hours = (m.totalMinutes / 60).toFixed(1);
                    const pct = (m.totalMinutes / maxMin * 100).toFixed(1);
                    return hbarRow({ cls: 'family', name: m.name, nameTitle: `${m.name} (${m.steamId})`, pct, val: `${hours}h`, rowClass: m.isMe ? 'is-me' : '' });
                }).join('');
                const pendingRows = pendingCount > 0 ? Array.from({ length: pendingCount }, () =>
                    hbarRow({ cls: 'family', name: T.ptPending, val: '—', rowClass: 'sglv-family-bar-pending' })
                ).join('') : '';
                familyContainer.innerHTML = memberRows + pendingRows;
            }).catch(() => {
                familyContainer.innerHTML = emptyHtml(isZh ? '获取失败' : 'Failed to fetch');
            });
        }

        renderFamilyCompare();
        return familySection;
    }

    function formatLastPlayedShort(ts) {
        if (!ts || ts <= 0) return T.ptNever;
        const diff = Date.now() / 1000 - ts;
        const days = Math.floor(diff / 86400);
        if (days <= 0) return isZh ? '今天' : 'Today';
        if (days === 1) return isZh ? '昨天' : 'Yesterday';
        if (days < 30) return `${days} ${T.ptDays}`;
        if (days < 365) return isZh ? `${Math.floor(days / 30)} 个月前` : `${Math.floor(days / 30)} months ago`;
        return isZh ? `${Math.floor(days / 365)} 年前` : `${Math.floor(days / 365)} years ago`;
    }

    // ==================== v2.9.95: 六维雷达图组件 ====================
    // 参考体育竞技管理游戏 UI 风格，将玩家游戏数据可视化为六维能力雷达图
    // 维度：库存规模、游玩时长、游玩率、深度完成、平均时长、铁杆指数
    // v2.9.97: 每个维度采用不同炫彩颜色，避免全紫色单调
    function renderPlaytimeRadar(games, stats) {
        const cx = 110, cy = 110, R = 80;
        // 六维炫彩配色 — 每个维度独立颜色，区分不同雷达趋势
        const dimColors = ['#22d3ee', '#f59e0b', '#34d399', '#f472b6', '#38bdf8', '#fb7185'];
        const dims = [
            { label: isZh ? '库存规模' : 'Library', value: Math.min(100, (stats.totalGames / 500) * 100), display: stats.totalGames.toString(), color: dimColors[0] },
            { label: isZh ? '游玩时长' : 'Hours', value: Math.min(100, (stats.totalHours / 5000) * 100), display: stats.totalHours.toFixed(0) + 'h', color: dimColors[1] },
            { label: isZh ? '游玩率' : 'Play Rate', value: stats.playRate, display: stats.playRate + '%', color: dimColors[2] },
            { label: isZh ? '深度完成' : 'Completion', value: stats.completionRate, display: stats.completionRate + '%', color: dimColors[3] },
            { label: isZh ? '平均时长' : 'Avg Hours', value: Math.min(100, (stats.avgHours / 50) * 100), display: stats.avgHours.toFixed(1) + 'h', color: dimColors[4] },
            { label: isZh ? '铁杆指数' : 'Hardcore', value: Math.min(100, (stats.hardcoreRate || 0)), display: (stats.hardcoreRate || 0) + '%', color: dimColors[5] },
        ];
        const n = dims.length;
        const angleStep = (Math.PI * 2) / n;
        const startAngle = -Math.PI / 2;

        // 渐变定义 — 多彩渐变用于雷达区域填充
        let defsSvg = `<defs>
            <linearGradient id="radarAreaGrad" x1="0%" y1="0%" x2="100%" y2="100%">
                <stop offset="0%" stop-color="#22d3ee" stop-opacity="0.25"/>
                <stop offset="33%" stop-color="#a78bfa" stop-opacity="0.20"/>
                <stop offset="66%" stop-color="#f472b6" stop-opacity="0.20"/>
                <stop offset="100%" stop-color="#f59e0b" stop-opacity="0.25"/>
            </linearGradient>
            <linearGradient id="radarStrokeGrad" x1="0%" y1="0%" x2="100%" y2="100%">
                <stop offset="0%" stop-color="#22d3ee"/>
                <stop offset="25%" stop-color="#34d399"/>
                <stop offset="50%" stop-color="#a78bfa"/>
                <stop offset="75%" stop-color="#f472b6"/>
                <stop offset="100%" stop-color="#f59e0b"/>
            </linearGradient>
        </defs>`;

        // 网格圈（4层）
        let gridSvg = '';
        for (let layer = 1; layer <= 4; layer++) {
            const r = (R / 4) * layer;
            let pts = '';
            for (let i = 0; i < n; i++) {
                const a = startAngle + i * angleStep;
                pts += `${cx + r * Math.cos(a)},${cy + r * Math.sin(a)} `;
            }
            gridSvg += `<polygon class="radar-grid" points="${pts.trim()}"/>`;
        }

        // 轴线 + 标签（每个维度使用独立颜色）
        let axisSvg = '';
        let labelSvg = '';
        for (let i = 0; i < n; i++) {
            const a = startAngle + i * angleStep;
            const x2 = cx + R * Math.cos(a);
            const y2 = cy + R * Math.sin(a);
            axisSvg += `<line class="radar-axis" x1="${cx}" y1="${cy}" x2="${x2}" y2="${y2}" stroke="${dims[i].color}" stroke-opacity="0.15"/>`;
            // 标签位置（轴外侧）
            const lr = R + 18;
            const lx = cx + lr * Math.cos(a);
            const ly = cy + lr * Math.sin(a);
            const dim = dims[i];
            labelSvg += `<text class="radar-label" x="${lx}" y="${ly - 4}" fill="${dim.color}">${dim.label}</text>`;
            labelSvg += `<text class="radar-value" x="${lx}" y="${ly + 8}" fill="${dim.color}">${dim.display}</text>`;
        }

        // 数据区域 + 数据点（每个点使用对应维度颜色）
        let dataPts = '';
        let pointSvg = '';
        for (let i = 0; i < n; i++) {
            const a = startAngle + i * angleStep;
            const r = R * (dims[i].value / 100);
            const x = cx + r * Math.cos(a);
            const y = cy + r * Math.sin(a);
            dataPts += `${x},${y} `;
            pointSvg += `<circle class="radar-point" cx="${x}" cy="${y}" r="3.5" fill="${dims[i].color}" stroke="#0d1117" stroke-width="2"/>`;
        }

        return `<svg class="sglv-radar-svg" viewBox="0 0 220 220">
            ${defsSvg}
            ${gridSvg}
            ${axisSvg}
            <polygon class="radar-area" points="${dataPts.trim()}" fill="url(#radarAreaGrad)" stroke="url(#radarStrokeGrad)"/>
            ${pointSvg}
            ${labelSvg}
        </svg>`;
    }

    // v2.9.95: 雷达图右侧统计面板
    // v2.9.97: 每个维度使用匹配的炫彩颜色
    function renderRadarStatsPanel(games, stats) {
        const statColors = ['#22d3ee', '#f59e0b', '#34d399', '#f472b6', '#38bdf8', '#fb7185'];
        const items = [
            { icon: ICONS.library, label: isZh ? '游戏总数' : 'Total Games', val: stats.totalGames.toLocaleString(), pct: Math.min(100, (stats.totalGames / 500) * 100), color: statColors[0] },
            { icon: ICONS.clock, label: isZh ? '总时长' : 'Total Hours', val: stats.totalHours.toFixed(1) + 'h', pct: Math.min(100, (stats.totalHours / 5000) * 100), color: statColors[1] },
            { icon: ICONS.game, label: isZh ? '已启动' : 'Played', val: stats.playedCount.toLocaleString(), pct: stats.playRate, color: statColors[2] },
            { icon: ICONS.trophy, label: isZh ? '深度游玩' : 'Deep Play', val: stats.longGames + (isZh ? '款' : ' games'), pct: stats.completionRate, color: statColors[3] },
            { icon: ICONS.trend, label: isZh ? '平均时长' : 'Avg Hours', val: stats.avgHours.toFixed(1) + 'h', pct: Math.min(100, (stats.avgHours / 50) * 100), color: statColors[4] },
            { icon: ICONS.barChart, label: isZh ? '铁杆指数' : 'Hardcore', val: (stats.hardcoreRate || 0) + '%', pct: stats.hardcoreRate || 0, color: statColors[5] },
        ];
        return items.map(it => `
            <div class="sglv-radar-stat-item">
                <div class="sglv-radar-stat-icon" style="background:${it.color}1a;color:${it.color}">${it.icon}</div>
                <div class="sglv-radar-stat-info">
                    <div class="sglv-radar-stat-label">${it.label}</div>
                    ${hbarRow({ cls: 'radar', pct: it.pct, color: `linear-gradient(90deg,${it.color}88,${it.color})` })}
                </div>
                <div class="sglv-radar-stat-val" style="color:${it.color}">${it.val}</div>
            </div>
        `).join('');
    }

    // v2.11.18 (FEAT-013 TASK-005): 游玩仪表拆分——组装器 + 四段渲染器 + 统计纯计算函数。
    // 段序(=文档序): KPI 卡片 → 雷达图行 → 分布+趋势两栏 → 热力图+近6月增量。
    // 副作用标注: ①games 经 getCached('pt-games') 组装层计算一次,四段共享;
    // ②统计变量打包 stats 对象(KPI/雷达两段共享,hardcore* 仅雷达段消费);
    // ③_distMode 闭包封装在图表段内;④热力图异步 IIFE 闭包捕获本段容器与 games;
    // ⑤_heatmapRenderCache 全局(年份筛选读)由 renderAcquiredHeatmap 写入,段内只读。
    // 各段接入工厂现状(先前系列完成): KPI→kpiCards(v2.11.1)/雷达统计→hbarRow(v2.11.1)
    // /月度趋势→SGLVCharts.lineChart(v2.11.8)/热力图豁免(FEAT-012 TASK-007 核查)。
    function computePlaytimeStats(games) {
        const totalGames = games.length;
        // v2.9.22: 与游戏橱窗标签页口径统一——取 max(含DLC, 不含DLC) 作为总时长，
        // 避免库存 KPI 4021.5h / 统计仪表 KPI 4210.3h 这种不一致。
        const realGamesForTotal = games.filter(g => !isDlc(g.appid));
        const realGamesMinutes = realGamesForTotal.reduce((s, g) => s + (g.playtime || 0), 0);
        const allGamesMinutes = games.reduce((s, g) => s + (g.playtime || 0), 0);
        const totalMinutes = Math.max(realGamesMinutes, allGamesMinutes);
        const totalHours = totalMinutes / 60;
        const playedGames = games.filter(g => (g.playtime || 0) > 0);
        const playedCount = playedGames.length;
        const unplayedCount = totalGames - playedCount;
        const avgHours = playedCount > 0 ? totalHours / playedCount : 0;
        // v2.9.22: 游玩率(已启动/总数) + 完成度(深度游玩 ≥10h / 已启动)
        const longGames = playedGames.filter(g => (g.playtime || 0) >= 600).length; // 600 min = 10h
        const playRate = totalGames > 0 ? Math.round(playedCount / totalGames * 100) : 0;
        const completionRate = playedCount > 0 ? Math.round(longGames / playedCount * 100) : 0;
        const ptPlayedPct = playRate;
        const ptUnplayedPct = totalGames > 0 ? Math.round(unplayedCount / totalGames * 100) : 0;
        // v2.9.95: 硬核玩家维度(雷达段消费)
        const hardcoreGames = playedGames.filter(g => (g.playtime || 0) >= 6000).length; // 6000 min = 100h
        const hardcoreRate = playedCount > 0 ? Math.round(hardcoreGames / playedCount * 100) : 0;
        return { totalGames, totalHours, playedCount, unplayedCount, avgHours, longGames, playRate, completionRate, ptPlayedPct, ptUnplayedPct, hardcoreGames, hardcoreRate };
    }

    // v2.11.18 (FEAT-013 TASK-005): KPI 数据卡片段(自 renderPlaytimeTab 拆出,纯展示搬移)
    function renderPlaytimeKpi(wrap, stats) {
        const kpiSection = document.createElement('div');
        kpiSection.className = 'sglv-playtime-kpi-row';
        // v2.11.1: 改经 kpiCards 工厂(tone:playtime)
        kpiSection.innerHTML = kpiCards([
            { icon: ICONS.clock, label: T.ptTotalHours, value: stats.totalHours.toFixed(1), sub: `${T.kpiHours} · ${T.kpiAvgHours} ${stats.avgHours.toFixed(1)}${T.kpiPerGame}`, color: 'amber' },
            { icon: ICONS.trend, label: T.ptAvgHours, value: stats.avgHours.toFixed(1), sub: `${T.kpiHours}${T.kpiPerGame}`, color: 'blue' },
            { icon: ICONS.game, label: T.ptPlayedCount, value: stats.playedCount.toLocaleString(), sub: `${T.kpiRate} ${stats.ptPlayedPct}%`, color: 'green' },
            { icon: ICONS.library, label: T.ptUnplayedCount, value: stats.unplayedCount.toLocaleString(), sub: `${T.kpiRate} ${stats.ptUnplayedPct}%`, color: 'purple' },
            { icon: ICONS.game, label: T.ptPlayRate, value: stats.playRate, unit: '%', sub: T.kpiPlayRateSub, color: 'cyan' },
            { icon: ICONS.trophy, label: T.ptCompletion, value: stats.completionRate, unit: '%', sub: `${stats.longGames} ${T.kpiCompletionSub}`, color: 'rose' },
        ], { tone: 'playtime' });
        wrap.appendChild(kpiSection);
    }

    // v2.11.18 (FEAT-013 TASK-005): 六维雷达图 + 统计面板段(自 renderPlaytimeTab 拆出,纯展示搬移)
    function renderPlaytimeRadarRow(wrap, games, stats) {
        // v2.9.95: 六维雷达图 + 统计面板
        const radarStats = { totalGames: stats.totalGames, totalHours: stats.totalHours, playedCount: stats.playedCount, longGames: stats.longGames, avgHours: stats.avgHours, playRate: stats.playRate, completionRate: stats.completionRate, hardcoreRate: stats.hardcoreRate };
        const radarRow = document.createElement('div');
        radarRow.className = 'sglv-radar-row';
        radarRow.innerHTML = `
            <div class="sglv-radar-card">
                <div class="sglv-radar-card-title">${ICONS.barChart || ''} ${isZh ? '玩家画像雷达' : 'Player Radar'}</div>
                ${renderPlaytimeRadar(games, radarStats)}
            </div>
            <div class="sglv-radar-stats">
                ${renderRadarStatsPanel(games, radarStats)}
            </div>
        `;
        wrap.appendChild(radarRow);
    }

    function renderPlaytimeTab(parent) {
        const wrap = document.createElement('div');
        wrap.className = 'sglv-playtime-wrap';

        if (state.ownedGames.length === 0) {
            wrap.innerHTML = emptyHtml(T.ptNoData);
            parent.appendChild(wrap);
            return;
        }

        // 获取游戏列表（考虑家庭组共享开关）
        const showFamilyShared = storage.getShowFamilyShared();
        const cacheK = cacheKey('pt-games', showFamilyShared, state.ownedGames.length, state.ownedGames.reduce((s, g) => s + (g.playtime || 0), 0));
        const games = getCached(cacheK, () => showFamilyShared ? [...state.ownedGames] : state.ownedGames.filter(g => isGameOwnedByMe(g)));

        // v2.11.18 (FEAT-013 TASK-005): 组装器——统计计算一次,四段按文档序消费
        const stats = computePlaytimeStats(games);
        renderPlaytimeKpi(wrap, stats);
        renderPlaytimeRadarRow(wrap, games, stats);
        renderPlaytimeChartRow(wrap, games);
        renderPlaytimeHeatmapRow(wrap, games);

        parent.appendChild(wrap);
    }

    // v2.11.18 (FEAT-013 TASK-005): 分布图 + 趋势图左右两栏段(自 renderPlaytimeTab 拆出,纯搬移)
    // _distMode 闭包状态封装在本段(distCol 局部);donut count 模式的 totalGames = games.length
    function renderPlaytimeChartRow(wrap, games) {
        const totalGames = games.length;
        const chartRow = document.createElement('div');
        chartRow.className = 'sglv-playtime-row';

        // 左侧：时长分布甜甜圈（v2.9.25: 默认总时长维度，toggle 切换游戏数|总时长）
        const distCol = document.createElement('div');
        distCol.className = 'sglv-playtime-col';
        distCol.innerHTML = `
            <div class="sglv-playtime-section-title" style="justify-content:space-between">
                <span>${ICONS.barChart} ${T.ptDistTitle}</span>
                <div class="sglv-trend-filter">
                    <button class="sglv-trend-btn" data-dist="count">${isZh ? '游戏数' : 'Count'}</button>
                    <button class="sglv-trend-btn active" data-dist="hours">${isZh ? '总时长' : 'Hours'}</button>
                </div>
            </div>
            <div id="sglv-pt-donut"></div>
        `;
        chartRow.appendChild(distCol);
        // v2.9.25: 默认渲染总时长维度（与"时长分布"标题语义一致）
        let _distMode = 'hours';
        const renderDonutByMode = (mode) => {
            const dd = calcPlaytimeDist(games, mode);
            if (mode === 'hours') {
                const totalH = dd.reduce((s, d) => s + d.count, 0);
                distCol.querySelector('#sglv-pt-donut').innerHTML = renderPlaytimeDonut(dd, totalH, 'h');
            } else {
                distCol.querySelector('#sglv-pt-donut').innerHTML = renderPlaytimeDonut(dd, totalGames, '');
            }
        };
        renderDonutByMode(_distMode);
        // toggle 绑定
        distCol.querySelector('.sglv-trend-filter').addEventListener('click', e => {
            const btn = e.target.closest('[data-dist]');
            if (!btn) return;
            distCol.querySelectorAll('[data-dist]').forEach(b => b.classList.remove('active'));
            btn.classList.add('active');
            _distMode = btn.dataset.dist;
            renderDonutByMode(_distMode);
        });

        // 右侧：时长趋势折线
        const trendCol = document.createElement('div');
        trendCol.className = 'sglv-playtime-col';
        trendCol.innerHTML = `
            <div class="sglv-playtime-section-title" style="justify-content:space-between">
                <span>${ICONS.trend} ${T.ptTrendTitle}</span>
                <div class="sglv-trend-filter">
                    <button class="sglv-trend-btn active" data-mode="month">${T.ptTrendMonth}</button>
                    <button class="sglv-trend-btn" data-mode="quarter">${T.ptTrendQuarter}</button>
                    <button class="sglv-trend-btn" data-mode="year">${T.ptTrendYear}</button>
                </div>
            </div>
            <div class="sglv-pt-trend-chart" id="sglv-pt-trend">${renderPlaytimeTrend(games, 'month')}</div>
        `;
        chartRow.appendChild(trendCol);
        wrap.appendChild(chartRow);

        // 绑定趋势筛选
        trendCol.querySelector('.sglv-trend-filter').addEventListener('click', e => {
            const btn = e.target.closest('.sglv-trend-btn');
            if (!btn) return;
            trendCol.querySelectorAll('.sglv-trend-btn').forEach(b => b.classList.remove('active'));
            btn.classList.add('active');
            trendCol.querySelector('#sglv-pt-trend').innerHTML = renderPlaytimeTrend(games, btn.dataset.mode);
        });
    }

    // v2.11.18 (FEAT-013 TASK-005): 入库热力图 + 近6月增量段(自 renderPlaytimeTab 拆出,纯搬移)
    // 异步 IIFE 闭包捕获本段容器与组装层 games;_heatmapRenderCache 全局由 renderAcquiredHeatmap 写入
    function renderPlaytimeHeatmapRow(wrap, games) {
        // v2.3.30: 入库热力图（替换原家庭组对比——该对比已在"游玩数据"标签页展示，避免重复）
        // v2.6.3: 左右分栏——热力图 + 近6月入库增量 并排展示
        // v2.9.22: 默认渲染空白骨架占位（年份框架 + 灰格），避免加载中底部大片空白
        const heatmapRow = document.createElement('div');
        heatmapRow.className = 'sglv-heatmap-acquire-row';
        wrap.appendChild(heatmapRow);

        const heatmapSection = document.createElement('div');
        heatmapSection.className = 'sglv-heatmap-section';
        heatmapSection.innerHTML = `
            <div class="sglv-playtime-section-title">${ICONS.grid} ${T.ptLibHeatmap}</div>
            <div id="sglv-pt-heatmap">${createSkeleton('heatmap')}</div>
        `;
        heatmapRow.appendChild(heatmapSection);

        // v2.6.3: 近6月入库增量作为右栏容器——与入库热力图左右并排
        // v2.9.22: 默认渲染 6 根灰条骨架，异步数据回来后替换
        const acquireSection = document.createElement('div');
        acquireSection.className = 'sglv-heatmap-mini-section';
        acquireSection.id = 'sglv-pt-acquire-mini';
        acquireSection.innerHTML = createSkeleton('monthly');
        heatmapRow.appendChild(acquireSection);

        // 异步加载含 acquiredTime 的家庭组库数据，按当前 games 列表（已遵循"显示家庭共享"开关）匹配入库时间
        (async () => {
            const heatmapEl = heatmapSection.querySelector('#sglv-pt-heatmap');
            try {
                // v2.11.42: 个人拥有的游戏按个人许可页日期校准（家人新入库共拥游戏不改变我的入库日期）
                const { games: familyGames, map: acquiredMap } = await buildCalibratedAcquiredMap();
                if (!familyGames || familyGames.length === 0) {
                    heatmapEl.innerHTML = emptyHtml(T.ptHeatmapNoData);
                    acquireSection.innerHTML = emptyHtml(T.ptHeatmapNoData, { style: 'padding:24px' });
                    return;
                }
                const heatGames = games
                    .filter(g => acquiredMap[g.appid])
                    .map(g => ({ appid: g.appid, acquiredTime: acquiredMap[g.appid] }));
                heatmapEl.innerHTML = renderAcquiredHeatmap(heatGames);
                // v2.6.1: 近6月入库增量——渲染到独立的 acquireSection 容器，与热力图平级，避免布局错位
                acquireSection.innerHTML = renderMonthlyAcquireChart(heatGames);
                // v2.4.2: 渲染后默认滚动到最右侧，直接展示最新数据（参考 v1.58）
                const scrollHmRight = () => requestAnimationFrame(() => {
                    const s = heatmapEl.querySelector('.sglv-heatmap-scroll');
                    if (s) s.scrollLeft = s.scrollWidth;
                });
                // v2.4.2: 绑定年份选择器——点击切换单年/全部视图（各视图 HTML 已在渲染缓存中预计算）
                const hmFilter = heatmapEl.querySelector('.sglv-hm-year-filter');
                const hmBody = heatmapEl.querySelector('.sglv-heatmap-body');
                if (hmFilter && hmBody) {
                    hmFilter.addEventListener('click', e => {
                        const btn = e.target.closest('.sglv-hm-year-btn');
                        if (!btn || !_heatmapRenderCache || !_heatmapRenderCache.views) return;
                        const view = _heatmapRenderCache.views[btn.dataset.year];
                        if (!view) return;
                        hmFilter.querySelectorAll('.sglv-hm-year-btn').forEach(b => b.classList.remove('active'));
                        btn.classList.add('active');
                        hmBody.innerHTML = view;
                        scrollHmRight();
                    });
                }
                scrollHmRight();
            } catch (e) {
                console.warn('[SGLV] 入库热力图加载失败:', e);
                heatmapEl.innerHTML = emptyHtml(T.ptHeatmapNoData);
                acquireSection.innerHTML = emptyHtml(T.ptHeatmapNoData, { style: 'padding:24px' });
            }
        })();
    }

    // ====== 游玩数据标签页 (Top 20 + 全部游戏) ======
    // v2.11.19 (FEAT-013 TASK-006): 游玩数据 Top20 段渲染器（自 renderPlaydataTab 拆出,纯搬移;条形行经 hbarRow 工厂）
    function renderPlaydataTopSection(splitRow, sortedGames) {
        const top20 = sortedGames.slice(0, 20);
        const maxPlaytime = top20.length > 0 ? (top20[0].playtime || 0) : 1;

        // ====== 左侧：Top 20 ======
        const topSection = document.createElement('div');
        topSection.className = 'sglv-playtime-split-left';
        topSection.innerHTML = `
            <div class="sglv-playtime-section-title">${ICONS.trend} ${T.ptTopTitle}</div>
            <div id="sglv-pt-top-list"></div>
        `;
        splitRow.appendChild(topSection);

        const topListEl = topSection.querySelector('#sglv-pt-top-list');
        if (top20.length === 0 || maxPlaytime === 0) {
            topListEl.innerHTML = emptyHtml(T.ptNoData);
        } else {
            const frag = document.createDocumentFragment();
            top20.forEach((game, i) => {
                const playtimeMin = game.playtime || 0;
                const pct = maxPlaytime > 0 ? (playtimeMin / maxPlaytime * 100).toFixed(1) : '0';
                const playtimeH = playtimeMin > 0 ? (playtimeMin / 60).toFixed(1) + 'h' : T.ptRange0;
                const rankClass = i === 0 ? 'rank-1' : i === 1 ? 'rank-2' : i === 2 ? 'rank-3' : '';
                const rankBadgeClass = i === 0 ? 'r1' : i === 1 ? 'r2' : i === 2 ? 'r3' : '';
                const iconUrl = getGameIconUrl(game.appid, game.icon);
                const lastPlayedText = game.lastPlayed > 0 ? formatLastPlayedShort(game.lastPlayed) : T.ptNever;

                const item = document.createElement('div');
                item.className = `sglv-pt-top-item ${rankClass}`;
                item.innerHTML = `
                    <div class="sglv-pt-rank ${rankBadgeClass}">${i + 1}</div>
                    <img class="sglv-pt-icon" src="${iconUrl}" alt="" loading="lazy" onerror="this.onerror=null;_sglvIconFallback(this,'${game.appid}','${escHtml(game.icon || '')}')">
                    <div class="sglv-pt-info">
                        <div class="sglv-pt-name" data-sglv-appid="${game.appid}" title="${game.name}">${game.name}</div>
                        <div class="sglv-pt-meta">${T.ptLastPlayed}: ${lastPlayedText}</div>
                    </div>
                    ${hbarRow({ cls: 'pt', pct })}
                    <span class="sglv-pt-hours">${playtimeH}</span>
                `;
                item.addEventListener('click', () => window.open(`https://store.steampowered.com/app/${game.appid}`, '_blank'));
                frag.appendChild(item);
            });
            topListEl.appendChild(frag);
            // v2.3.33：异步加载游戏中文名
            applyGameAliases(topListEl);
        }
    }

    // v2.11.19 (FEAT-013 TASK-006): 全部游戏段渲染器（搜索/分页/条形行,自 renderPlaydataTab 拆出,纯搬移;返回 allSection 供组装器追加家庭对比）
    function renderPlaydataAllSection(splitRow, sortedGames) {
        // ====== 右侧：全部游戏（分页） ======
        const PT_ALL_PAGE_SIZE = 50;
        let ptAllPage = 1;
        let ptAllQuery = '';

        const allSection = document.createElement('div');
        allSection.className = 'sglv-playtime-split-right';
        allSection.innerHTML = `
            <div class="sglv-playtime-section-title">${ICONS.list} ${T.ptAllTitle}</div>
            <div class="sglv-pt-all-list" id="sglv-pt-all-list"></div>
            <div class="sglv-pagination" id="sglv-pt-pagination"></div>
        `;
        // v2.11.15 (FEAT-013 TASK-002): 全库工具栏经 buildListToolbar 工厂（仅 search 形态），
        // insertBefore 保持 title→toolbar→list→pagination 原文档序
        const ptToolbar = buildListToolbar({
            cls: 'sglv-pt-all-toolbar',
            search: { id: 'sglv-pt-search', placeholder: T.ptSearchPlaceholder, style: 'flex:1;min-width:120px' },
            extraHtml: `<span class="sglv-page-info" id="sglv-pt-count"></span>`,
            onChange: ({ value }) => renderAllPlaytimeList(value, 1),
        });
        allSection.insertBefore(ptToolbar, allSection.querySelector('#sglv-pt-all-list'));
        splitRow.appendChild(allSection);

        const allListEl = allSection.querySelector('#sglv-pt-all-list');
        const countEl = allSection.querySelector('#sglv-pt-count');
        const ptPagination = allSection.querySelector('#sglv-pt-pagination');

        function renderAllPlaytimeList(filterQuery, page = 1) {
            ptAllQuery = filterQuery;
            ptAllPage = page;
            let displayGames = sortedGames;
            if (filterQuery) {
                const q = filterQuery.toLowerCase();
                displayGames = sortedGames.filter(g => g.name.toLowerCase().includes(q));
            }
            // v2.4.0: 复用 paginate 纯函数统一分页计算
            const { pageItems: pageGames, totalPages, page: _clampedPage } = paginate(displayGames, ptAllPage, PT_ALL_PAGE_SIZE);
            ptAllPage = _clampedPage;
            const ptAllStart = (ptAllPage - 1) * PT_ALL_PAGE_SIZE; // v2.4.1: 修复 globalRank 计算缺失 start 变量

            countEl.textContent = `${displayGames.length} ${isZh ? '款' : 'items'}`;
            allListEl.innerHTML = '';
            if (displayGames.length === 0) {
                allListEl.innerHTML = emptyHtml(isZh ? '无匹配游戏' : 'No matching games');
                ptPagination.innerHTML = '';
                return;
            }

            const allMaxPlaytime = pageGames.length > 0 ? Math.max(...pageGames.map(g => g.playtime || 0)) : 1;
            const frag = document.createDocumentFragment();
            pageGames.forEach((game, i) => {
                const playtimeMin = game.playtime || 0;
                const pct = allMaxPlaytime > 0 ? (playtimeMin / allMaxPlaytime * 100).toFixed(1) : '0';
                const playtimeH = playtimeMin > 0 ? (playtimeMin / 60).toFixed(1) + 'h' : T.ptRange0;
                const globalRank = ptAllStart + i + 1;

                const item = document.createElement('div');
                item.className = 'sglv-pt-all-item';
                item.innerHTML = `
                    <span class="sglv-pt-all-rank">${globalRank}</span>
                    <span class="sglv-pt-all-name" data-sglv-appid="${game.appid}" title="${game.name}">${game.name}</span>
                    ${hbarRow({ cls: 'ptAll', pct })}
                    <span class="sglv-pt-all-hours">${playtimeH}</span>
                `;
                item.addEventListener('click', () => window.open(`https://store.steampowered.com/app/${game.appid}`, '_blank'));
                frag.appendChild(item);
            });
            allListEl.appendChild(frag);
            // v2.3.33：异步加载游戏中文名；v2.11.4 改经 applyGameAliases 统一入口
            applyGameAliases(allListEl);

            // v2.9.25: 统一使用 renderPagination，支持快捷翻页
            const _ptTotal = displayGames.length;
            renderPagination(ptPagination, 'sglv-pt', ptAllPage, totalPages, _ptTotal,
                () => renderAllPlaytimeList(ptAllQuery, ptAllPage - 1),
                () => renderAllPlaytimeList(ptAllQuery, ptAllPage + 1),
                (p) => renderAllPlaytimeList(ptAllQuery, p));
        }

        renderAllPlaytimeList('');

        return allSection;
    }

    // v2.11.19 (FEAT-013 TASK-006): 游玩数据 Tab 组装器——Top20/全部游戏两段按文档序消费
    function renderPlaydataTab(parent) {
        const wrap = document.createElement('div');
        wrap.className = 'sglv-playtime-wrap';
        wrap.style.flexDirection = 'column';

        if (state.ownedGames.length === 0) {
            wrap.innerHTML = emptyHtml(T.ptNoData);
            parent.appendChild(wrap);
            return;
        }

        const showFamilyShared = storage.getShowFamilyShared();
        const cacheK = cacheKey('pt-games', showFamilyShared, state.ownedGames.length, state.ownedGames.reduce((s, g) => s + (g.playtime || 0), 0));
        const games = getCached(cacheK, () => showFamilyShared ? [...state.ownedGames] : state.ownedGames.filter(g => isGameOwnedByMe(g)));
        const sortedGames = [...games].sort((a, b) => (b.playtime || 0) - (a.playtime || 0));

        // ====== Top 20 + 全部游戏 左右分栏 ======
        const splitRow = document.createElement('div');
        splitRow.className = 'sglv-playtime-split-row';
        wrap.appendChild(splitRow);
        renderPlaydataTopSection(splitRow, sortedGames);
        const allSection = renderPlaydataAllSection(splitRow, sortedGames);

        // v2.4.4: 移除左下角重复的时长分布图（"统计仪表"标签页已有），家庭组时长对比独占整行
        // v2.7.8: 恢复整行设计，不再与左侧对齐；Top20 列表撑满 splitRow 高度
        // v2.9.22: 家庭成员对比紧凑放到右半侧（allSection 底部），Top 20 撑到页面底部获得更大视野
        const totalMinutes = games.reduce((s, g) => s + (g.playtime || 0), 0);
        allSection.appendChild(createFamilyCompareSection(totalMinutes));

        parent.appendChild(wrap);
    }

    // ==================== 愿望单标签页 (v2.3.19 新增) ====================

    // v2.9.29: wlEscape 委托至全局 escHtml，统一 HTML 转义实现（DRY）
    function wlEscape(s) {
        return escHtml(s);
    }

    let _wlPriceSym = '';
    // v2.9.101: 模块级币种代码记录（formatted 价格文本推断，供 wlCurrencyOf 兜底链使用；不改动 detectWlPriceSymbol 本身）
    let _wlPriceCode = '';
    function detectWlPriceSymbol(sampleText) {
        if (_wlPriceSym) return _wlPriceSym;
        const text = String(sampleText || document.querySelector('#header_wallet_balance')?.textContent || '');
        const m = text.match(/(HK\$|NT\$|A\$|CDN\$|Mex\$|S\$|R\$|₩|€|£|¥|\$|₽|₹|฿|₫|RM)/);
        _wlPriceSym = m ? m[1] : '¥';
        return _wlPriceSym;
    }

    // 已在库判定集合：优先使用面板当前生效的库存集合（尊重"显示家庭共享"开关），
    // 未加载库存时回退 GDynamicStore.s_rgOwnedApps（SteamPeek 方式）
    function getWishlistOwnedIds() {
        try {
            const ids = getActiveOwnedAppIds();
            if (ids && ids.size > 0) return ids;
        } catch { /* ignore */ }
        return getDynamicStoreAppIds('owned');
    }

    // v2.7.2: 即将发售多源判定（参考 Steam-Wishlist-Sidebar-1.0.9）
    // 优先级：is_coming_soon 字段 > release.is_coming_soon > 未来时间戳 > release_string 措辞
    // 支持 true→false 回退（游戏已发售时纠正旧缓存）
    const WL_COMING_SOON_RE = /即将推出|即将宣布|coming soon|to be announced|\btba\b|\btbd\b|\bq[1-4]\b|summer|winter|spring|fall|autumn|^\s*\d{4}\s*$|年第[一二三四1-4]季度|[春夏秋冬]季/i;
    function wlResolveComingSoon(opts) {
        const rdTs = Number(opts.releaseTs) || 0;
        let soon = opts.soonFlag === true || opts.releaseSoon === true;
        if (!soon && rdTs > 0 && rdTs * 1000 > Date.now()) soon = true;
        if (!soon && opts.releaseStr && WL_COMING_SOON_RE.test(opts.releaseStr)) soon = true;
        const known = opts.soonFlag != null || opts.releaseSoon != null || !!opts.hasReleaseObj || rdTs > 0 || soon;
        return { soon, known, date: rdTs > 0 ? new Date(rdTs * 1000).toISOString().slice(0, 10) : '' };
    }

    // 条目规整：兼容 wishlistdata 新旧两种结构，价格单位统一为元，防止 Infinity/NaN
    function normalizeWishlistEntry(info) {
        const appid = Number(info.appid) || 0;
        let finalPrice = 0, originalPrice = 0, discountPct = 0;
        let hasPriceInfo = false;
        const sub = Array.isArray(info.subs) && info.subs.length > 0 ? info.subs[0] : null;
        if (sub) {
            hasPriceInfo = true;
            finalPrice = (Number(sub.price) || 0) / 100;
            discountPct = Number(sub.discount_pct) || 0;
            originalPrice = (discountPct > 0 && discountPct < 100) ? finalPrice / (1 - discountPct / 100) : finalPrice;
        }
        if (info.best_purchase_option) {
            hasPriceInfo = true;
            const bpo = info.best_purchase_option;
            finalPrice = (Number(bpo.final_price_in_cents) || 0) / 100;
            originalPrice = (Number(bpo.original_price_in_cents) || 0) / 100;
            if (originalPrice === 0) originalPrice = finalPrice;
            discountPct = Number(bpo.discount_pct || 0);
            if (bpo.formatted_final_price) detectWlPriceSymbol(bpo.formatted_final_price);
            // v2.9.101: 旁路推断币种代码（软降级：lib 缺失/异常不影响原流程）
            try { if (hasSglvCurrency && bpo.formatted_final_price) { const c = CUR.detectFromText(bpo.formatted_final_price); if (c) _wlPriceCode = c; } } catch {}
        }
        if (!Number.isFinite(finalPrice) || finalPrice < 0) finalPrice = 0;
        if (!Number.isFinite(originalPrice) || originalPrice < 0) originalPrice = finalPrice;
        if (!Number.isFinite(discountPct) || discountPct < 0 || discountPct > 100) discountPct = 0;
        const name = (info.name && String(info.name).trim()) || '';
        // v2.7.2: 即将发售多源判定（wishlistdata 的 is_coming_soon / release_date 时间戳 / release_string 措辞）
        const cs = wlResolveComingSoon({
            soonFlag: info.is_coming_soon,
            releaseTs: info.release_date,
            releaseStr: info.release_string,
        });
        return {
            appid,
            name: name || `App ${appid}`,
            priority: Number(info.priority) || 0,
            added: Number(info.added || info.date_added) || 0,
            finalPrice, originalPrice, discountPct,
            isFree: !!info.is_free || (hasPriceInfo && finalPrice === 0 && discountPct === 0),
            isComingSoon: cs.soon,
            releaseDate: cs.date,
            _releaseKnown: cs.known,
            type: String(info.type || 'game').toLowerCase(),
            tags: normalizeWishlistTags(info.tags),
            // v2.3.23: 用户自定义类别 ID 列表（新版愿望单"我的类别"，统一为字符串避免 uint64 精度问题）
            categoryIds: Array.isArray(info.category_ids) ? info.category_ids.map(id => String(id)).filter(s => s && s !== '0') : [],
            _priced: hasPriceInfo,
        };
    }

    // 标签规整：兼容字符串数组与 {name}/{tagid,name} 对象数组
    function normalizeWishlistTags(raw) {
        if (!Array.isArray(raw)) return [];
        return raw.map(t => typeof t === 'string' ? t : (t && (t.name || t.description)) || '').filter(Boolean).slice(0, 20);
    }

    // 来源2：store wishlistdata 分页（含名称/价格/折扣，信息最全）
    async function fetchWishlistFromStore(steamId) {
        const out = [];
        if (!steamId) return out;
        const isProfileId = /^\d{17}$/.test(String(steamId));
        const base = isProfileId
            ? `https://store.steampowered.com/wishlist/profiles/${steamId}/wishlistdata/`
            : `https://store.steampowered.com/wishlist/id/${steamId}/wishlistdata/`;
        for (let p = 0; p < 60; p++) {
            let data = null;
            try {
                data = await requestSteamAPI(`${base}?p=${p}`);
            } catch { break; }
            if (!data) break;
            const entries = Array.isArray(data) ? data : Object.entries(data).map(([k, v]) => ({ appid: Number(k), ...(v || {}) }));
            if (entries.length === 0) break;
            entries.forEach(e => { if (e && e.appid) out.push(e); });
            await new Promise(r => setTimeout(r, 200));
        }
        return out;
    }

    // 来源2：IPlayerService/GetWishlist API（仅 appid/排序/添加时间）
    async function fetchWishlistFromApi(steamId) {
        const out = [];
        const apiKey = storage.getApiKey();
        let authToken = null;
        if (!apiKey) { try { authToken = await getAccessToken(); } catch { /* ignore */ } }
        let url = null;
        if (apiKey) url = `https://api.steampowered.com/IPlayerService/GetWishlist/v1/?key=${apiKey}&steamid=${steamId}&format=json`;
        else if (authToken) url = `https://api.steampowered.com/IPlayerService/GetWishlist/v1/?access_token=${authToken}&steamid=${steamId}&format=json`;
        if (!url) return out;
        try {
            const data = await requestSteamAPI(url);
            const arr = data?.response?.items || [];
            arr.forEach(it => { if (it && it.appid) out.push({ appid: Number(it.appid), priority: it.priority, added: it.date_added }); });
        } catch (e) { console.warn('[SGLV] GetWishlist API 失败:', e); }
        return out;
    }

    // v2.3.23: 解析 GetWishlistCategories 响应（返回结构未文档化，防御性兼容多种形态）
    function parseWishlistCategoriesResponse(data) {
        const out = {};
        const resp = (data && typeof data === 'object') ? (data.response || data) : {};
        const list = resp.categories || resp.wishlist_categories || (Array.isArray(resp) ? resp : null);
        if (Array.isArray(list)) {
            list.forEach(c => {
                if (!c || typeof c !== 'object') return;
                const id = c.categoryid ?? c.category_id ?? c.id;
                const name = c.category_name ?? c.name ?? c.label;
                if (id != null && name) out[String(id)] = String(name);
            });
        } else if (resp && typeof resp === 'object') {
            // 兼容 { id: name } 或 { id: {category_name} } 映射
            Object.entries(resp).forEach(([k, v]) => {
                if (typeof v === 'string' && v) out[k] = v;
                else if (v && typeof v === 'object') {
                    const name = v.category_name ?? v.name;
                    if (name) out[k] = String(name);
                }
            });
        }
        return out;
    }

    // v2.3.23: 获取用户自定义愿望单类别（我的类别）ID -> 名称映射，需 access_token（API Key 兜底）
    async function fetchWishlistCategoryNames() {
        const tryUrls = [];
        try {
            const token = await getAccessToken();
            if (token) tryUrls.push(`https://api.steampowered.com/IWishlistService/GetWishlistCategories/v1/?access_token=${token}`);
        } catch { /* ignore */ }
        const apiKey = storage.getApiKey();
        if (apiKey) tryUrls.push(`https://api.steampowered.com/IWishlistService/GetWishlistCategories/v1/?key=${apiKey}`);
        for (const url of tryUrls) {
            try {
                const data = await requestSteamAPI(url);
                const map = parseWishlistCategoriesResponse(data);
                if (Object.keys(map).length > 0) return map;
            } catch (e) {
                // v2.7.9: 静默忽略 HTML 响应（未登录/API Key 失效时 Steam 返回登录页 HTML），不打印警告避免干扰
                if (!String(e.message || e).includes('返回 HTML')) {
                    console.warn('[SGLV] GetWishlistCategories 失败:', e);
                }
            }
        }
        return {};
    }

    // v2.3.23: 后台静默刷新类别名映射，完成后仅局部刷新左侧仪表盘（不重建封面，避免闪烁）
    function refreshWishlistCategoryNames() {
        fetchWishlistCategoryNames().then(map => {
            if (Object.keys(map).length === 0) return;
            state.wishlistCategoryNames = map;
            cacheSet('wishlistCatNames', map, 7 * 24 * 3600 * 1000); // 缓存 7 天
            if (state.activeTab === 'wishlist' && state.wishlistLoaded) renderWishlistSide();
        }).catch(() => {});
    }

    // v2.7.2: IStoreBrowseService/GetItems 批量补全（参考 Steam-Wishlist-Sidebar-1.0.9）
    // 实测匿名可用，单批 100 个 appid、3 路并发，几秒完成数百条，替代绝大多数 appdetails 单条请求
    async function enrichWishlistFromStoreBrowse(items, cc, lang, onBatchDone) {
        const CHUNK = 100, CONCURRENCY = 3;
        const chunks = [];
        for (let i = 0; i < items.length; i += CHUNK) chunks.push(items.slice(i, i + CHUNK));
        let qIdx = 0, processed = 0;
        const applyStoreBrowse = (item, si) => {
            if (!si || (si.success !== 1 && si.success !== true)) return;
            if (si.name && (item.name.startsWith('App ') || isZh)) item.name = String(si.name);
            if (typeof si.type === 'number') {
                item.type = ({ 0: 'game', 1: 'dlc', 2: 'software', 3: 'video', 4: 'series', 6: 'music', 7: 'tool', 8: 'video_series' })[si.type] || 'other';
            } else if (si.type) {
                item.type = String(si.type).toLowerCase();
            }
            if (si.is_free === true) item.isFree = true;
            const bpo = si.best_purchase_option;
            if (bpo) {
                const final = Number(bpo.final_price_in_cents) || 0;
                const original = Number(bpo.original_price_in_cents) || 0;
                item.finalPrice = final / 100;
                item.originalPrice = (original > 0 ? original : final) / 100;
                item.discountPct = Number(bpo.discount_pct || bpo.bundle_discount_pct || 0);
                if (item.originalPrice === item.finalPrice && item.discountPct > 0 && item.discountPct < 100) {
                    item.originalPrice = item.finalPrice / (1 - item.discountPct / 100);
                }
                if (bpo.formatted_final_price) detectWlPriceSymbol(bpo.formatted_final_price);
                // v2.9.101: 旁路推断币种代码（软降级：lib 缺失/异常不影响原流程）
                try { if (hasSglvCurrency && bpo.formatted_final_price) { const c = CUR.detectFromText(bpo.formatted_final_price); if (c) _wlPriceCode = c; } } catch {}
                item._priced = true;
                if (final === 0 && item.discountPct === 0) item.isFree = true;
            }
            // 即将发售判定：顶层 is_coming_soon / release.is_coming_soon / release.steam_release_date 未来时间戳
            const rel = si.release || null;
            const cs = wlResolveComingSoon({
                soonFlag: si.is_coming_soon,
                releaseSoon: rel && rel.is_coming_soon,
                releaseTs: rel && rel.steam_release_date,
                hasReleaseObj: !!rel,
            });
            if (cs.known) {
                item.isComingSoon = cs.soon;
                item._releaseKnown = true;
                if (cs.date) item.releaseDate = cs.date;
            }
            item._metaDone = true;
            if (si.name && isZh) {
                const nc = sglvGameNameCacheLoad();
                nc[String(item.appid)] = { name: si.name, ts: Date.now() };
            }
        };
        const worker = async () => {
            while (qIdx < chunks.length) {
                const chunk = chunks[qIdx++];
                try {
                    const input = {
                        ids: chunk.map(g => ({ appid: g.appid })),
                        context: { language: lang, country_code: cc, steam_realm: 1 },
                        data_request: { include_release: true, include_all_purchase_options: true, include_platforms: true }
                    };
                    const url = 'https://api.steampowered.com/IStoreBrowseService/GetItems/v1?input_json=' + encodeURIComponent(JSON.stringify(input));
                    const resp = await requestSteamAPI(url);
                    const storeItems = resp?.response?.store_items || [];
                    const map = new Map();
                    storeItems.forEach(si => { if (si && si.appid) map.set(Number(si.appid), si); });
                    chunk.forEach(g => { const si = map.get(Number(g.appid)); if (si) applyStoreBrowse(g, si); });
                } catch (e) { console.warn('[SGLV] GetItems batch failed:', e); }
                processed += chunk.length;
                if (onBatchDone) onBatchDone(processed, items.length);
                await new Promise(r => setTimeout(r, 200));
            }
        };
        const workers = [];
        for (let i = 0; i < CONCURRENCY; i++) workers.push(worker());
        await Promise.all(workers);
        if (isZh) { try { sglvGameNameCacheSave(); } catch (e2) { console.warn('[SGLV] 中文名缓存写入失败:', e2); } }
    }

    // 资料补全：v2.7.2 三段式（参考 Steam-Wishlist-Sidebar-1.0.9）
    // ① IStoreBrowseService/GetItems 批量补全（100 个/批、3 路并发）—— 名称/类型/价格/折扣/发售状态
    // ② appdetails 兜底残余（缺名称/价格/发售状态的条目），filters 增加 release_date 判定 coming_soon
    async function enrichWishlistMeta(items, onBatchDone) {
        const need = items.filter(i => !i._metaDone);
        if (need.length === 0) { if (onBatchDone) onBatchDone(0, 0); return; }
        let cc = 'CN';
        try {
            const win = (typeof unsafeWindow !== 'undefined') ? unsafeWindow : window;
            cc = win.g_strCountryCode || 'CN';
        } catch { /* ignore */ }
        const lang = isZh ? 'schinese' : 'english';

        // ① GetItems 批量补全（核心速度优化，替代绝大多数 appdetails 单条请求）
        await enrichWishlistFromStoreBrowse(need, cc, lang, onBatchDone);

        // ② appdetails 兜底残余：仍缺名称/价格/发售状态的条目
        const leftovers = items.filter(i => !i._metaDone && (i.name.startsWith('App ') || !i._priced || !i._releaseKnown));
        if (leftovers.length > 0) {
            // v2.4.3: filters 限定返回字段，v2.7.2: 增加 release_date 以判定 coming_soon
            const filters = 'name,type,is_free,genres,price_overview,release_date';
            const enrichBatch = async (batch) => {
                const data = await requestSteamAPI(`https://store.steampowered.com/api/appdetails?appids=${batch.map(g => g.appid).join(',')}&filters=${filters}&cc=${cc}&l=${lang}`);
                batch.forEach(g => {
                    const d = data?.[g.appid];
                    if (!d || !d.success || !d.data) return;
                    const dd = d.data;
                    // v2.3.33: 中文环境下 appdetails 使用 l=schinese 请求，返回的为中文名，
                    // 应始终覆盖 SSR/API 返回的英文名，而非仅覆盖占位符。
                    if (dd.name && (g.name.startsWith('App ') || isZh)) g.name = dd.name;
                    if (dd.type) g.type = String(dd.type).toLowerCase();
                    if (dd.is_free === true) g.isFree = true;
                    if (Array.isArray(dd.genres) && dd.genres.length > 0) {
                        g.tags = dd.genres.map(x => x.description).filter(Boolean);
                    }
                    const po = dd.price_overview;
                    if (po && typeof po.final === 'number') {
                        g.finalPrice = po.final / 100;
                        g.originalPrice = (po.initial || po.final) / 100;
                        g.discountPct = po.discount_percent || 0;
                        // v2.9.101: entry 补 currency 字段（appdetails price_overview 为权威币种码，保证 wlCurrencyOf 不空）
                        g.currency = po.currency || g.currency;
                        g.isFree = false;
                        g._priced = true;
                        if (po.final_formatted) detectWlPriceSymbol(po.final_formatted);
                        // v2.9.101: 旁路推断币种代码（软降级：lib 缺失/异常不影响原流程）
                        try { if (hasSglvCurrency && po.final_formatted) { const c = CUR.detectFromText(po.final_formatted); if (c) _wlPriceCode = c; } } catch {}
                    }
                    // v2.7.2: release_date.coming_soon 为权威判定（可回退 true→false，纠正旧缓存）
                    if (dd.release_date && typeof dd.release_date.coming_soon !== 'undefined') {
                        g.isComingSoon = !!dd.release_date.coming_soon;
                        g._releaseKnown = true;
                        if (dd.release_date.date) g.releaseDate = dd.release_date.date;
                    }
                    g._metaDone = true;
                    // v2.3.33：同步写入中文名缓存，避免 loadGameZhName 对已补全的游戏重复请求 appdetails
                    if (dd.name && isZh) {
                        const nc = sglvGameNameCacheLoad();
                        nc[String(g.appid)] = { name: dd.name, ts: Date.now() };
                    }
                });
                // v2.3.33：批量写入后统一落盘一次，避免 forEach 内每条都调 GM_setValue
                if (isZh) { try { sglvGameNameCacheSave(); } catch (e2) { console.warn('[SGLV] 中文名缓存写入失败:', e2); } }
            };
            let done = 0;
            for (let i = 0; i < leftovers.length; i += 25) {
                const batch = leftovers.slice(i, i + 25);
                try { await enrichBatch(batch); } catch { /* 忽略单批失败 */ }
                done += batch.length;
                if (onBatchDone) onBatchDone(done, leftovers.length);
                await new Promise(r => setTimeout(r, 250));
            }
            // v2.4.3: 对补全失败的条目以更小批次重试一轮——旧实现单批失败后条目永久缺失中文名/价格
            const retry = leftovers.filter(i => !i._metaDone);
            for (let i = 0; i < retry.length; i += 10) {
                const batch = retry.slice(i, i + 10);
                try { await enrichBatch(batch); } catch { /* 重试失败保持原样 */ }
                await new Promise(r => setTimeout(r, 300));
            }
        }
        if (onBatchDone) onBatchDone(need.length, need.length);
    }

    // v2.7.2: 后台静默刷新愿望单动态字段（价格/折扣/即将发售）
    // 仅用 IStoreBrowseService/GetItems 批量请求（快速），比较新旧值后仅更新有变化的条目并局部刷新 UI
    // v2.9.30: 增加 6 小时节流，避免每次进入愿望单标签页都触发 API 请求（缓存已延长至 3 天）
    let _wlDynamicRefreshing = false;
    let _wlDynamicLastRefresh = 0;
    const WL_DYNAMIC_REFRESH_INTERVAL = 6 * 3600 * 1000; // 6 小时节流
    async function refreshWishlistDynamicFields(items) {
        if (_wlDynamicRefreshing || !items || items.length === 0) return;
        // v2.9.30: 6 小时内已刷新过则跳过，避免每次进入标签页都发起 API 请求
        if (Date.now() - _wlDynamicLastRefresh < WL_DYNAMIC_REFRESH_INTERVAL) return;
        _wlDynamicRefreshing = true;
        try {
            let cc = 'CN';
            try {
                const win = (typeof unsafeWindow !== 'undefined') ? unsafeWindow : window;
                cc = win.g_strCountryCode || 'CN';
            } catch { /* ignore */ }
            const lang = isZh ? 'schinese' : 'english';
            // 标记动态字段待刷新：重置 _priced/_releaseKnown 让 enrichWishlistFromStoreBrowse 重新处理
            // 但保留 _metaDone 以跳过 appdetails 兜底（名称/类型/标签等静态数据不变）
            const refreshItems = items.map(g => {
                const copy = Object.assign({}, g);
                copy._priced = false;
                copy._releaseKnown = false;
                copy._metaDone = true; // 跳过 appdetails 兜底
                return copy;
            });
            // 记录刷新前的快照，用于比较变化
            const before = new Map(items.map(g => [g.appid, {
                finalPrice: g.finalPrice, discountPct: g.discountPct, isComingSoon: g.isComingSoon, isFree: g.isFree,
            }]));
            await enrichWishlistFromStoreBrowse(refreshItems, cc, lang);
            // 将刷新结果合并回原数组，仅更新有变化的动态字段
            let changed = false;
            const origMap = new Map(items.map(g => [g.appid, g]));
            refreshItems.forEach(refreshed => {
                const orig = origMap.get(refreshed.appid);
                if (!orig) return;
                const oldSnap = before.get(orig.appid);
                // 仅在字段实际变化时更新并标记 changed
                if (refreshed._priced && refreshed.finalPrice !== oldSnap.finalPrice) {
                    orig.finalPrice = refreshed.finalPrice;
                    orig.originalPrice = refreshed.originalPrice;
                    orig.discountPct = refreshed.discountPct;
                    orig.isFree = refreshed.isFree;
                    orig._priced = true;
                    changed = true;
                }
                if (refreshed._releaseKnown && !!refreshed.isComingSoon !== !!oldSnap.isComingSoon) {
                    orig.isComingSoon = refreshed.isComingSoon;
                    orig._releaseKnown = true;
                    if (refreshed.releaseDate) orig.releaseDate = refreshed.releaseDate;
                    changed = true;
                }
            });
            if (changed) {
                // 更新缓存并局部刷新 UI
                cacheSet('wishlistGames', items, CACHE_TTL.wishlist);
                renderWishlistSections();
            }
        } catch (e) {
            console.warn('[SGLV] 后台刷新动态字段失败:', e);
        } finally {
            _wlDynamicRefreshing = false;
            _wlDynamicLastRefresh = Date.now(); // v2.9.30: 记录本次刷新时间用于节流
        }
    }

    // ==================== 愿望单页面 SSR 数据提取 (v2.3.20 新增) ====================
    // 参考 steam-wishlist-exporter-2.1.3：从愿望单页面 HTML 中解析 React Query SSR 数据，
    // 获取 date_added/priority（全部条目）+ StoreItem 详情（名称/价格/标签，首批条目）+ 标签名映射
    // 这解决了 wishlistdata API 不返回 added/tags 导致时间线和标签为空、名称需逐批 appdetails 补全的问题

    // 从 HTML 文本中提取 React Query 的 queries 数组（扫描 JSON.parse("...") 包含 queryData 的片段）
    function wlExtractQueryDataFromText(text) {
        try {
            let idx = 0;
            while ((idx = text.indexOf('JSON.parse(', idx)) !== -1) {
                const start = text.indexOf('"', idx + 11);
                if (start === -1) { idx++; continue; }
                let i = start + 1, inEsc = false;
                while (i < text.length) {
                    const c = text[i];
                    if (inEsc) inEsc = false;
                    else if (c === '\\') inEsc = true;
                    else if (c === '"') break;
                    i++;
                }
                const escaped = text.substring(start + 1, i).replace(/[\n\r]/g, '');
                let decoded = '';
                try { decoded = JSON.parse('"' + escaped + '"'); }
                catch (_) { idx = i + 1; continue; }
                if (typeof decoded === 'string' && decoded.includes('queryData')) {
                    try {
                        const outer = JSON.parse(decoded);
                        if (outer && typeof outer.queryData === 'string') {
                            const qd = JSON.parse(outer.queryData);
                            if (qd && Array.isArray(qd.queries)) return qd.queries;
                        }
                    } catch (_) { console.warn('[SGLV] SSR queryData 解析失败'); }
                }
                idx = i + 1;
            }
        } catch (e) { console.warn('[SGLV] wlExtractQueryDataFromText failed:', e); }
        return null;
    }

    // 从 queries 数组提取：愿望单条目 / StoreItem 缓存 / 标签名映射
    function wlExtractFromQueries(queries) {
        const entries = [];
        const tagNameMap = {};
        const storeItemCache = new Map();
        for (const query of queries) {
            if (!query || !query.state || !query.state.data) continue;
            const data = query.state.data;
            const qKey = query.queryKey || [];
            // 愿望单条目（含 appid/priority/date_added/category_ids）
            if (qKey[0] === 'WishlistSortedFiltered') {
                const payload = Array.isArray(data) ? { items: data } : data;
                if (payload && Array.isArray(payload.items)) entries.push(...payload.items);
            }
            // 标签名映射（tagid -> name）
            if (qKey[0] === 'LocalizedTagNames' && typeof data === 'object' && !Array.isArray(data)) {
                Object.assign(tagNameMap, data);
            }
            // StoreItem 详情（按 appid 聚合各子查询：default_info/top_tags/include_platforms 等）
            if (qKey.length >= 3 && qKey[0] === 'StoreItem') {
                const appId = parseInt(String(qKey[1]).replace(/^app_/, ''), 10);
                if (!appId || isNaN(appId)) continue;
                if (!storeItemCache.has(appId)) storeItemCache.set(appId, { _appId: appId });
                storeItemCache.get(appId)[qKey[2]] = data;
            }
        }
        // 去重（按 appid）
        const seen = new Set();
        const unique = entries.filter(e => e && e.appid && !seen.has(e.appid) && seen.add(e.appid));
        return { entries: unique, storeItemCache, tagNameMap };
    }

    // 将 StoreItem 缓存数据应用到已规整的愿望单条目（补全名称/价格/标签/类型）
    function applyStoreItemToWlEntry(item, storeData, tagNameMap) {
        if (!item || !storeData) return;
        const di = storeData.default_info;
        if (di) {
            // v2.3.33：中文环境下 SSR 名称可能为英文，仍作为兜底应用（appdetails 会后续覆盖为中文名）
            if (di.name && (item.name.startsWith('App ') || isZh)) item.name = String(di.name);
            // Steam StoreItem.type: 0=game, 1=DLC, 2=software, 3=video, 4=series, 6=music, 7=tool, 8=video_series
            if (typeof di.type === 'number') {
                item.type = ({ 0: 'game', 1: 'dlc', 2: 'software', 3: 'video', 4: 'series', 6: 'music', 7: 'tool', 8: 'video_series' })[di.type] || 'other';
            } else if (di.type) {
                item.type = String(di.type).toLowerCase();
            }
            if (di.is_free === true) item.isFree = true;
            const bpo = di.best_purchase_option;
            if (bpo) {
                const final = Number(bpo.final_price_in_cents) || 0;
                const original = Number(bpo.original_price_in_cents) || 0;
                item.finalPrice = final / 100;
                item.originalPrice = (original > 0 ? original : final) / 100;
                item.discountPct = Number(bpo.discount_pct || bpo.bundle_discount_pct || 0);
                if (bpo.formatted_final_price) detectWlPriceSymbol(bpo.formatted_final_price);
                // v2.9.101: 旁路推断币种代码（软降级：lib 缺失/异常不影响原流程）
                try { if (hasSglvCurrency && bpo.formatted_final_price) { const c = CUR.detectFromText(bpo.formatted_final_price); if (c) _wlPriceCode = c; } } catch {}
                item._priced = true;
                if (final === 0 && item.discountPct === 0) item.isFree = true;
            }
            // v2.7.2: 即将发售判定（SSR default_info.is_coming_soon / release.steam_release_date / release.is_coming_soon）
            const rel = di.release || di.release_date;
            const cs = wlResolveComingSoon({
                soonFlag: di.is_coming_soon,
                releaseSoon: rel && rel.is_coming_soon,
                releaseTs: rel && (rel.steam_release_date || rel.date),
                hasReleaseObj: !!rel,
            });
            if (cs.known) {
                item.isComingSoon = cs.soon;
                item._releaseKnown = true;
                if (cs.date) item.releaseDate = cs.date;
            }
        }
        // top_tags -> 标签名列表（通过 tagNameMap 映射 tagid）
        const tt = storeData.top_tags;
        if (Array.isArray(tt) && tt.length > 0) {
            item.tags = tt.map(t => {
                if (!t) return '';
                if (t.name) return t.name;
                if (t.tagid != null) return tagNameMap[t.tagid] || '';
                return '';
            }).filter(Boolean).slice(0, 20);
        }
        // v2.3.33：中文环境下 SSR StoreItem 的名称随用户账号语言（可能为英文），
        // 不标记 _metaDone，让 enrichWishlistMeta 通过 l=schinese 的 appdetails 覆盖为中文名；
        // 非中文环境保持原有行为（SSR 数据完整即跳过 appdetails）。
        item._metaDone = isZh ? false : true; // StoreItem 数据完整，跳过 appdetails 补全
    }

    // 从愿望单页面 HTML 抓取 SSR 数据（参考 steam-wishlist-exporter-2.1.3 的 SSR 提取）
    // v2.11.36 (FEAT-015 TASK-003): 迁移至 sglvGmFetchTextRetry（原非 2xx resolve {ok:false}→warn→null，
    //   新非 2xx reject→catch warn→null，语义等价；TASK-006 策略链前置）
    async function fetchWishlistFromPage(steamId) {
        if (!steamId) return null;
        const isProfileId = /^\d{17}$/.test(String(steamId));
        const url = isProfileId
            ? `https://store.steampowered.com/wishlist/profiles/${steamId}/`
            : `https://store.steampowered.com/wishlist/id/${steamId}/`;
        try {
            const text = await sglvGmFetchTextRetry(url, { timeout: 30000 });
            const queries = wlExtractQueryDataFromText(text);
            if (!queries) { console.warn('[SGLV] 愿望单页面未找到 SSR queryData'); return null; }
            const data = wlExtractFromQueries(queries);
            console.log(`[SGLV] 愿望单页面 SSR: ${data.entries.length} 条目, ${data.storeItemCache.size} 详情, ${Object.keys(data.tagNameMap).length} 标签`);
            if (data.entries.length === 0) return null;
            return data;
        } catch (e) {
            console.warn('[SGLV] fetchWishlistFromPage 失败:', e);
            return null;
        }
    }

    // 愿望单类型分布：将 type 字段归一化为 game/dlc/software/other
    function wlGetTypeKey(type) {
        const t = String(type || 'game').toLowerCase();
        if (t === 'game' || t === '0') return 'game';
        if (t === 'dlc' || t === '1') return 'dlc';
        if (t === 'software' || t === '2') return 'software';
        return 'other';
    }

    // 主入口：四级来源兜底（愿望单页面SSR → wishlistdata → GetWishlist API → GDynamicStore）
    // v2.7.2: 缓存命中时后台静默刷新动态字段（价格/折扣/即将发售），不阻塞 UI
    // v2.9.30: 缓存 TTL 延长至 3 天，动态字段刷新增加 6h 节流，避免每次进入标签页都触发 API 请求
    async function loadWishlistGames(force = false) {
        if (state.wishlistLoading) return;
        if (!force) {
            const cached = cacheGet('wishlistGames');
            if (cached && Array.isArray(cached) && cached.length > 0) {
                state.wishlistGames = cached;
                state.wishlistLoaded = true;
                markSearchIndexDirty(); // v2.9.51: 缓存恢复,索引需要重建
                state.wishlistCategoryNames = cacheGet('wishlistCatNames') || {}; // v2.3.23: 恢复类别名缓存
                renderWishlistSections();
                refreshWishlistCategoryNames(); // v2.3.23: 后台静默更新类别名
                // v2.7.2: 后台静默刷新动态字段——价格/折扣/即将发售状态变化频繁，缓存内可能已过时
                // v2.9.30: 6h 节流，同一会话内不重复刷新；复用 enrichWishlistFromStoreBrowse 批量补全
                refreshWishlistDynamicFields(cached);
                return;
            }
        }
        state.wishlistLoading = true;
        state.wishlistLoadStage = 1;  // v2.9.47: 阶段1 — 页面抓取
        state.wishlistLoadProgress = 0;
        renderWishlistGamesList();
        try {
            const steamId = getActiveSteamId();

            // 来源1（新增）：愿望单页面 SSR —— 含 date_added/priority（全部条目）+ StoreItem 详情（首批条目）
            // 解决 wishlistdata API 不返回 added 字段导致时间线为空、名称需逐批 appdetails 补全的问题
            let ssrData = null;
            try { ssrData = await fetchWishlistFromPage(steamId); }
            catch (e) { console.warn('[SGLV] 愿望单页面 SSR 抓取失败:', e); }
            let raw = (ssrData && ssrData.entries.length > 0) ? ssrData.entries : [];
            const storeItemCache = ssrData ? ssrData.storeItemCache : new Map();
            const tagNameMap = ssrData ? ssrData.tagNameMap : {};

            // v2.9.47: 阶段2 — API 数据补全
            state.wishlistLoadStage = 2;
            renderWishlistGamesList();

            // 来源2：store wishlistdata 分页（补充名称/价格/标签/类型）
            let apiEntries = [];
            if (steamId) {
                try { apiEntries = await fetchWishlistFromStore(steamId); }
                catch (e) { console.warn('[SGLV] wishlistdata API 失败:', e); }
            }
            if (raw.length === 0) {
                // SSR 失败，直接用 wishlistdata API 数据
                raw = apiEntries;
            } else if (apiEntries.length > 0) {
                // 合并：SSR 提供 date_added/priority（API 通常缺失），API 提供名称/价格/标签（SSR 仅首批有）
                const apiMap = new Map(apiEntries.map(e => [Number(e.appid), e]));
                raw = raw.map(ssrEntry => {
                    const apiEntry = apiMap.get(Number(ssrEntry.appid));
                    if (!apiEntry) return ssrEntry;
                    // API 字段在前，SSR 的 date_added/priority/category_ids 覆盖（SSR 数据更可靠）
                    return Object.assign({}, apiEntry, {
                        date_added: ssrEntry.date_added,
                        priority: ssrEntry.priority,
                        category_ids: ssrEntry.category_ids,
                    });
                });
            }

            // 来源3：IPlayerService/GetWishlist API
            if (raw.length === 0) raw = await fetchWishlistFromApi(steamId);

            // 来源4：GDynamicStore 兜底（仅 appid）
            if (raw.length === 0) {
                raw = [...getDynamicStoreAppIds('wishlist')].map(appid => ({ appid }));
            }

            const items = raw.map(entry => {
                const item = normalizeWishlistEntry(entry);
                // 应用 SSR StoreItem 详情（首批约 60 个条目有完整名称/价格/标签/类型）
                if (storeItemCache.has(item.appid)) {
                    applyStoreItemToWlEntry(item, storeItemCache.get(item.appid), tagNameMap);
                }
                return item;
            }).filter(i => i.appid > 0);
            items.sort((a, b) => {
                const pa = a.priority > 0 ? a.priority : 999999;
                const pb = b.priority > 0 ? b.priority : 999999;
                if (pa !== pb) return pa - pb;
                return a.name.localeCompare(b.name, 'zh-CN');
            });
            state.wishlistGames = items;
            state.wishlistLoaded = true;
            state.wishlistLoading = false;
            state.wishlistLoadStage = 0;  // v2.9.47: 重置加载阶段
            state.wishlistLoadProgress = 0;
            markSearchIndexDirty(); // v2.9.51: 搜索索引依赖 wishlistGames,标记为脏
            state.wishlistCategoryNames = cacheGet('wishlistCatNames') || {}; // v2.3.23: 先用缓存类别名出图
            renderWishlistSections(); // 先出列表，再后台逐批补全名称/标签/价格
            refreshWishlistCategoryNames(); // v2.3.23: 后台获取最新类别名并局部刷新
            // v2.9.47: 阶段3 — 资料富集（后台补全，不阻塞列表展示）
            state.wishlistLoadStage = 3;
            await enrichWishlistMeta(items, (done, total) => {
                updateWishlistProgress(done, total);
                renderWishlistSections();
            });
            cacheSet('wishlistGames', items, CACHE_TTL.wishlist); // v2.9.30: 缓存延长至 3 天（动态字段后台静默刷新，6h 节流）
            updateWishlistProgress(0, 0);
            state.wishlistLoadStage = 0;  // v2.9.47: 富集完成，重置
            state.wishlistLoadProgress = 0;
            renderWishlistSections();
            sglvToast.success(T.wlFetchSuccess.replace('{n}', items.length));
        } catch (e) {
            console.error('[SGLV] 愿望单获取失败:', e);
            sglvToast.error(T.wlFetchFail);
            state.wishlistLoading = false;
            state.wishlistLoadStage = 0;  // v2.9.47: 重置加载阶段
            state.wishlistLoadProgress = 0;
            renderWishlistSections();
        }
    }

    // 后台资料补全进度提示（左侧仪表盘顶部）
    function updateWishlistProgress(done, total) {
        const el = document.getElementById('sglv-wl-progress');
        if (!el) return;
        if (!done || !total || done >= total) { el.textContent = ''; return; }
        el.textContent = (isZh ? '正在补全资料… ' : 'Enriching… ') + done + '/' + total;
    }

    // v2.9.101: 愿望单条目币种解析 helper（本任务只建 helper 与字段，computeWishlistStats 接入留待下一任务）
    // 兜底链：entry.currency（appdetails 权威值）→ 用户国家代码对应币种（REGIONS 表，g_strCountryCode 权威）
    //   → _wlPriceCode（formatted 价格文本推断，时序波动/跨区域残留风险，垫底）→ 'CNY'
    // v2.9.103: _wlPriceCode 优先级下移 — 推断值存在"统计先于渲染执行为空"与"跨区域浏览残留陈旧值"
    // 两类风险,权威值(entry.currency/国家码)优先;非 REGIONS 国家(如 HK)国家码查不到时自然落到 _wlPriceCode。
    function regionCurrencyOfCountry(cc) {
        try {
            if (SGLV_API.getRegionCurrency) return SGLV_API.getRegionCurrency(cc) || '';
        } catch { /* ignore */ }
        return '';
    }
    function wlCurrencyOf(g) {
        try {
            const cc = (typeof unsafeWindow !== 'undefined' && unsafeWindow.g_strCountryCode) || '';
            return (g && g.currency) || regionCurrencyOfCountry(cc) || _wlPriceCode || 'CNY';
        } catch { return _wlPriceCode || 'CNY'; }
    }

    // 统计计算：参考 steam-portal analyzeWishlist，计算 KPI/价格区间/折扣区间/按年趋势/类型分布
    function computeWishlistStats() {
        const games = state.wishlistGames;
        const ownedIds = getWishlistOwnedIds();
        const total = games.length;
        const inLibrary = games.filter(g => ownedIds.has(Number(g.appid)) || ownedIds.has(String(g.appid))).length;
        const isOwned = g => ownedIds.has(Number(g.appid)) || ownedIds.has(String(g.appid));

        // 价格统计（参考 steam-portal：仅付费游戏，价格单位为元）
        const paidItems = games.filter(g => !g.isFree && g.finalPrice > 0);
        const prices = paidItems.map(g => g.finalPrice).sort((a, b) => a - b);
        // v2.9.102: 多币种汇总软降级开关 —— lib 缺失或 USD 枢纽表派生失败(getUsdRates 返回 null)时,
        // 三处金额汇总全部走原裸求和路径(else 分支保留原实现,仅新增分支不覆写)。
        // aggregate 对空 code 静默跳过(致命陷阱),构造项集时用 wlCurrencyOf 兜底保证 code 永不为空。
        const _wlTargetCode = wlCurrencyOf(null); // 本区币种(统计目标币)
        const _wlUsdRates = (hasSglvCurrency && SGLV_API.getUsdRates) ? SGLV_API.getUsdRates() : null;
        const _wlMultiCur = hasSglvCurrency && !!_wlUsdRates;
        const _rawPriceSum = prices.reduce((s, p) => s + p, 0);
        let totalValue = _rawPriceSum;
        let _wlAgg = null;
        // 单条折算(供 priceBuckets/类别/未分类使用;降级路径下恒为 null 不会被调用):
        // 全同币种(code===target)恒等直返 amount,与裸求和逐项相等;仅混合币种才走 USD 枢纽折算。
        let _convPrice = null;
        if (_wlMultiCur) {
            _convPrice = g => {
                const code = g.currency || wlCurrencyOf(g);
                if (code === _wlTargetCode) return g.finalPrice;
                const v = CUR.convert(g.finalPrice, code, _wlTargetCode, _wlUsdRates);
                return Number.isFinite(v) ? v : null; // 缺汇率 → null,分桶时跳过
            };
            const _aggItems = paidItems.map(g => ({ finalPrice: g.finalPrice, currency: g.currency || wlCurrencyOf(g) }));
            _wlAgg = CUR.aggregate(_aggItems, _wlTargetCode, _wlUsdRates, { amountKey: 'finalPrice', codeKey: 'currency' });
            // 全同币种时 aggregate 走 target 直累分支(Math.round(x*100) 整数分),total === 原裸求和
            // (Steam 价格两位小数,*100 精确无损)——验收红线;混合币种时为折算后总额。
            totalValue = _wlAgg.total;
        }
        // avgPrice/medianPrice 维持基于原 finalPrice 计算,不引入折算:中位数跨币种无数学意义,保持现状。
        const avgPrice = paidItems.length > 0 ? _rawPriceSum / paidItems.length : 0;
        const medianPrice = prices.length > 0
            ? (prices.length % 2 === 0
                ? (prices[prices.length / 2 - 1] + prices[prices.length / 2]) / 2
                : prices[Math.floor(prices.length / 2)])
            : 0;

        // 折扣统计
        const discountedItems = games.filter(g => g.discountPct > 0);
        const discounts = discountedItems.map(g => g.discountPct);
        const avgDiscount = discounts.length > 0 ? discounts.reduce((s, d) => s + d, 0) / discounts.length : 0;
        const maxDiscount = discounts.length > 0 ? Math.max(...discounts) : 0;
        const discountedRate = total > 0 ? discountedItems.length / total : 0;

        // 免费游戏
        const freeCount = games.filter(g => g.isFree).length;
        const freeRate = total > 0 ? freeCount / total : 0;

        // v2.7.2: 即将发售
        const comingSoonItems = games.filter(g => g.isComingSoon);
        const comingSoonCount = comingSoonItems.length;
        const comingSoonRate = total > 0 ? comingSoonCount / total : 0;

        // 购入率
        const purchaseRate = total > 0 ? inLibrary / total : 0;

        // 最早添加日期
        const addedDates = games.filter(g => g.added > 0).map(g => g.added);
        const earliestAdded = addedDates.length > 0 ? Math.min(...addedDates) : 0;

        // 热门标签 TOP 15
        const tagMap = new Map();
        games.forEach(g => (g.tags || []).forEach(t => tagMap.set(t, (tagMap.get(t) || 0) + 1)));
        const topTags = [...tagMap.entries()].sort((a, b) => b[1] - a[1]).slice(0, 15);

        // 添加时间线（按月，取最近 12 个月）
        const monthMap = new Map();
        games.forEach(g => {
            if (g.added > 0) {
                const d = new Date(g.added * 1000);
                const key = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}`;
                monthMap.set(key, (monthMap.get(key) || 0) + 1);
            }
        });
        const timeline = [...monthMap.entries()].sort((a, b) => a[0].localeCompare(b[0])).slice(-12);

        // 按年添加趋势（参考 steam-portal addedByYear）
        const yearMap = new Map();
        games.forEach(g => {
            if (g.added > 0) {
                const year = String(new Date(g.added * 1000).getFullYear());
                yearMap.set(year, (yearMap.get(year) || 0) + 1);
            }
        });
        const addedByYear = [...yearMap.entries()].sort((a, b) => a[0].localeCompare(b[0]));

        // 价格区间分布（参考 steam-portal priceBuckets，单位为元）
        // v2.9.102: 聚合路径下改按折算后金额分桶（全同币种时 _convPrice 恒等直返，分桶数与原版一致）；降级路径维持原 finalPrice 分桶
        const _bucketPrices = _wlMultiCur ? paidItems.map(g => _convPrice(g)) : null;
        const priceBuckets = _wlMultiCur ? [
            { label: T.wlPriceFree,    count: games.filter(g => g.isFree).length, color: '#6366f1' },
            { label: T.wlPriceLt50,    count: _bucketPrices.filter(p => p != null && p < 50).length, color: '#10b981' },
            { label: T.wlPrice50_100,  count: _bucketPrices.filter(p => p != null && p >= 50 && p < 100).length, color: '#22c55e' },
            { label: T.wlPrice100_200, count: _bucketPrices.filter(p => p != null && p >= 100 && p < 200).length, color: '#84cc16' },
            { label: T.wlPrice200_500, count: _bucketPrices.filter(p => p != null && p >= 200 && p < 500).length, color: '#f59e0b' },
            { label: T.wlPriceGte500,  count: _bucketPrices.filter(p => p != null && p >= 500).length, color: '#ef4444' },
        ] : [
            { label: T.wlPriceFree,    count: games.filter(g => g.isFree).length, color: '#6366f1' },
            { label: T.wlPriceLt50,    count: paidItems.filter(g => g.finalPrice < 50).length, color: '#10b981' },
            { label: T.wlPrice50_100,  count: paidItems.filter(g => g.finalPrice >= 50 && g.finalPrice < 100).length, color: '#22c55e' },
            { label: T.wlPrice100_200, count: paidItems.filter(g => g.finalPrice >= 100 && g.finalPrice < 200).length, color: '#84cc16' },
            { label: T.wlPrice200_500, count: paidItems.filter(g => g.finalPrice >= 200 && g.finalPrice < 500).length, color: '#f59e0b' },
            { label: T.wlPriceGte500,  count: paidItems.filter(g => g.finalPrice >= 500).length, color: '#ef4444' },
        ];

        // 折扣分布（参考 steam-portal discountBuckets）
        const discountBuckets = [
            { label: T.wlDisc0,      count: games.filter(g => g.discountPct === 0).length, color: '#64748b' },
            { label: T.wlDisc1_25,   count: games.filter(g => g.discountPct > 0 && g.discountPct <= 25).length, color: '#84cc16' },
            { label: T.wlDisc26_50,  count: games.filter(g => g.discountPct > 25 && g.discountPct <= 50).length, color: '#22c55e' },
            { label: T.wlDisc51_75,  count: games.filter(g => g.discountPct > 50 && g.discountPct <= 75).length, color: '#f59e0b' },
            { label: T.wlDisc76plus, count: games.filter(g => g.discountPct > 75).length, color: '#ef4444' },
        ];

        // 类型分布（愿望单游戏分类汇总：游戏/DLC/软件/其他）
        const typeMap = new Map();
        games.forEach(g => {
            const key = wlGetTypeKey(g.type);
            typeMap.set(key, (typeMap.get(key) || 0) + 1);
        });
        const typeDist = [...typeMap.entries()].sort((a, b) => b[1] - a[1]);

        // v2.8.0: 我的类别详细统计（每类别：数量/总值/均价/打折/待上市/已入库/免费 + 占比）
        // v2.9.102: 聚合路径下 totalValue 按条目折算到目标币种后累加（_convPrice 全同币种恒等直返）；降级路径保持原 finalPrice 累加
        const catNames = state.wishlistCategoryNames || {};
        const catStatsMap = new Map();
        games.forEach(g => {
            const ids = Array.isArray(g.categoryIds) ? g.categoryIds : [];
            if (ids.length === 0) return;
            ids.forEach(id => {
                if (!catStatsMap.has(id)) catStatsMap.set(id, {
                    count: 0, totalValue: 0, paidCount: 0,
                    discountCount: 0, comingSoonCount: 0, inLibraryCount: 0, freeCount: 0,
                });
                const cs = catStatsMap.get(id);
                cs.count++;
                if (!g.isFree && g.finalPrice > 0) {
                    if (_wlMultiCur) {
                        const cv = _convPrice(g);
                        if (cv != null) cs.totalValue += cv;
                    } else {
                        cs.totalValue += g.finalPrice;
                    }
                    cs.paidCount++;
                }
                if (g.discountPct > 0) cs.discountCount++;
                if (g.isComingSoon) cs.comingSoonCount++;
                if (isOwned(g)) cs.inLibraryCount++;
                if (g.isFree) cs.freeCount++;
            });
        });
        const categoryStats = [...catStatsMap.entries()]
            .map(([id, cs]) => ({
                id, name: catNames[id] || `#${id}`,
                ...cs,
                avgPrice: cs.paidCount > 0 ? cs.totalValue / cs.paidCount : 0,
                pct: total > 0 ? cs.count / total : 0,
            }))
            .sort((a, b) => b.count - a.count);

        // v2.8.0: 未分类游戏统计（v2.9.102: totalValue 聚合路径下按折算后金额汇总，降级路径维持原裸求和）
        const uncatGames = games.filter(g => {
            const ids = Array.isArray(g.categoryIds) ? g.categoryIds : [];
            return ids.length === 0;
        });
        const uncatPaid = uncatGames.filter(g => !g.isFree && g.finalPrice > 0);
        const uncategorizedStats = {
            count: uncatGames.length,
            totalValue: _wlMultiCur
                ? uncatPaid.reduce((s, g) => { const cv = _convPrice(g); return cv != null ? s + cv : s; }, 0)
                : uncatPaid.reduce((s, g) => s + g.finalPrice, 0),
            discountCount: uncatGames.filter(g => g.discountPct > 0).length,
            comingSoonCount: uncatGames.filter(g => g.isComingSoon).length,
            inLibraryCount: uncatGames.filter(g => isOwned(g)).length,
            freeCount: uncatGames.filter(g => g.isFree).length,
            pct: total > 0 ? uncatGames.length / total : 0,
        };

        return {
            total, inLibrary, purchaseRate,
            totalValue, avgPrice, medianPrice,
            discountedCount: discountedItems.length, discountedRate, avgDiscount, maxDiscount,
            freeCount, freeRate,
            comingSoonCount, comingSoonRate,
            earliestAdded,
            topTags, timeline, addedByYear,
            priceBuckets, discountBuckets, typeDist,
            categoryStats, uncategorizedStats,
            // v2.9.102: aggregate 附加产物透传（无汇率降级分桶/未支持币种列表；降级路径下为空值，新增字段不影响既有消费方）
            byCurrency: _wlAgg ? _wlAgg.byCurrency : {},
            unsupported: _wlAgg ? _wlAgg.unsupported : [],
            targetCode: _wlTargetCode,
        };
    }

    // v2.9.50: 持久化 wishlist 统计(跨 session 复用)
    // 输入签名:wishlist 数量 + 价格字段总和 + 类别字段总和
    // 动态字段(价格/折扣)会由 refreshWishlistDynamicFields 后台刷新(已有)
    // v2.9.102: PCC 防脏缓存 —— schemaVer 1→2 双保险(旧脏缓存版本不匹配直接重算);
    // 签名在既有单次循环中顺带收集货币指纹(curSet,零额外遍历):币种集合 + 小时级汇率快照 + 目标币种,
    // 任一变化 → sig 变化 → PCC 自动重算,避免沿用汇率/币种变更前的脏统计。
    function computeWishlistStatsCached() {
        const games = state.wishlistGames;
        let finalPriceSum = 0, originalPriceSum = 0, discountSum = 0, addedSum = 0;
        const curSet = new Set(); // v2.9.102: 货币指纹(与汇总同口径: g.currency || wlCurrencyOf 兜底)
        const n = games ? games.length : 0;
        for (let i = 0; i < n; i++) {
            const g = games[i];
            finalPriceSum += (g && g.finalPrice) || 0;
            originalPriceSum += (g && g.originalPrice) || 0;
            discountSum += (g && g.discountPct) || 0;
            addedSum += (g && g.added) || 0;
            curSet.add((g && g.currency) || wlCurrencyOf(g));
        }
        const catNames = state.wishlistCategoryNames || {};
        const catKey = Object.keys(catNames).sort().map(k => `${k}:${catNames[k]}`).join(',');
        // 小时级汇率快照(getRatesTs 经 SGLV_API 桥接,拿不到时用 0);targetCode 与 computeWishlistStats 同口径
        let ratesHour = 0;
        try { if (SGLV_API.getRatesTs) ratesHour = Math.floor((SGLV_API.getRatesTs() || 0) / 3600000); } catch { ratesHour = 0; }
        const curFp = [...curSet].sort().join(',') + '|' + ratesHour + '|' + wlCurrencyOf(null);
        const sig = `${n}|${finalPriceSum}|${originalPriceSum}|${discountSum}|${addedSum}|${catKey}|${curFp}`;
        return getBizCached('biz_wishlist_stats', 2, sig, () => computeWishlistStats());
    }

    function getFilteredWishlist() {
        const q = state.wishlistSearch.toLowerCase().trim();
        const ownedIds = getWishlistOwnedIds();
        return state.wishlistGames.filter(g => {
            if (q && !g.name.toLowerCase().includes(q) && !String(g.appid).includes(q)) return false;
            if (state.wishlistFilter === 'discount' && !(g.discountPct > 0)) return false;
            if (state.wishlistFilter === 'inlibrary' && !(ownedIds.has(Number(g.appid)) || ownedIds.has(String(g.appid)))) return false;
            if (state.wishlistFilter === 'coming' && !g.isComingSoon) return false;
            // v2.8.0: 类别筛选（点击"我的类别统计"卡片触发）
            if (state.wishlistFilter === 'category' && state.wishlistCategoryFilter) {
                const ids = Array.isArray(g.categoryIds) ? g.categoryIds : [];
                if (state.wishlistCategoryFilter === '__uncat__') {
                    if (ids.length > 0) return false;
                } else {
                    if (!ids.includes(state.wishlistCategoryFilter)) return false;
                }
            }
            return true;
        });
    }

    // ----- 渲染 -----
    // ==================== 云存档标签页 (v2.9.34) ====================

    function renderCloudSaveTab(parent) {
        const wrap = document.createElement('div');
        wrap.className = 'sglv-cs-wrap';

        // 模块未加载
        if (!window.SGLVCloudSave || !_cloudSaveReady) {
            wrap.innerHTML = `
                <div class="sglv-cs-state-box">
                    <div class="sglv-cs-state-icon">⚠️</div>
                    <div class="sglv-cs-state-msg">${isZh ? '云存档模块未加载' : 'Cloud save module not loaded'}</div>
                    <div class="sglv-cs-state-tip">${isZh ? '请检查 @require 外部库配置' : 'Please check @require external library config'}</div>
                </div>`;
            parent.innerHTML = '';
            parent.appendChild(wrap);
            return;
        }

        // 加载中
        if (state.cloudSaveLoading) {
            wrap.innerHTML = `
                <div class="sglv-cs-state-box">
                    <div class="sglv-spinner"></div>
                    <div class="sglv-cs-state-msg">${T.csFetching}</div>
                </div>`;
            parent.innerHTML = '';
            parent.appendChild(wrap);
            return;
        }

        // 错误态
        if (state.cloudSaveError) {
            const isLogin = state.cloudSaveError === 'LOGIN_REQUIRED';
            wrap.innerHTML = `
                <div class="sglv-cs-state-box">
                    <div class="sglv-cs-state-icon">${isLogin ? '🔐' : '⚠️'}</div>
                    <div class="sglv-cs-state-msg">${isLogin ? T.csLoginRequired : T.csFetchFail}</div>
                    <button class="sglv-cs-action-btn" id="sglv-cs-retry">${isZh ? '点击重试' : 'Click to retry'}</button>
                </div>`;
            parent.innerHTML = '';
            parent.appendChild(wrap);
            wrap.querySelector('#sglv-cs-retry').addEventListener('click', () => loadCloudSaveData(true));
            return;
        }

        // 空数据——v2.9.39: 切换到云存档标签页时，先尝试从 IDB 加载缓存（立即显示）
        if (!state.cloudSaveLoaded || !state.cloudSaveGames || state.cloudSaveGames.length === 0) {
            // 渲染空态占位（含获取按钮）
            wrap.innerHTML = `
                <div class="sglv-cs-state-box">
                    <div class="sglv-cs-state-icon">☁️</div>
                    <div class="sglv-cs-state-msg">${T.csNoData}</div>
                    <button class="sglv-cs-action-btn" id="sglv-cs-fetch">${isZh ? '获取数据' : 'Fetch Data'}</button>
                </div>`;
            parent.innerHTML = '';
            parent.appendChild(wrap);
            wrap.querySelector('#sglv-cs-fetch').addEventListener('click', () => loadCloudSaveData(true));
            return;
        }

        // 仪表盘
        renderCloudSaveDashboard(parent, wrap);
    }

    // v2.11.35 (FEAT-015 TASK-002): 云存档数据准备(自 renderCloudSaveTab 外提)
    // - 空数据态:启动缓存加载流程(_initCloudSaveTab,可能瞬间命中 IDB 缓存并替换占位)
    // - 仪表盘态:6h 节流后台增量刷新 + 文件数渐进填充(原渲染函数尾部的两处静默 kick-off)
    function prepareCloudSaveTabData() {
        if (!window.SGLVCloudSave || !_cloudSaveReady) return;
        if (state.cloudSaveLoading || state.cloudSaveError) return;
        if (!state.cloudSaveLoaded || !state.cloudSaveGames || state.cloudSaveGames.length === 0) {
            _initCloudSaveTab();
            return;
        }
        // v2.9.39: 渲染完成后，若距上次后台刷新超过 6h 节流窗口，触发静默增量更新
        // 仅在切到该标签页时触发（不打扰用户）
        if (Date.now() - (state.cloudSaveBgRefreshAt || 0) >= CLOUDSAVE_BG_REFRESH_INTERVAL) {
            _backgroundRefreshCloudSave();
        }
        // v2.9.67: 后台渐进式填充文件数量（12h 节流,逐个请求单App页面解析文件数）
        _enrichCloudSaveFileCounts();
    }

    async function loadCloudSaveData(force) {
        state.cloudSaveLoading = true;
        state.cloudSaveError = null;
        renderBody();

        try {
            const result = await window.SGLVCloudSave.fetchGlobalCloudSaves(force);
            state.cloudSaveGames = result.games || [];
            state.cloudSaveSource = result.source;
            state.cloudSaveLastUpdate = result.lastUpdate;
            state.cloudSaveDiff = result.diff;
            state.cloudSaveLoaded = true;
            state.cloudSaveError = null;

            showToast(T.csFetchSuccess.replace('{n}', state.cloudSaveGames.length));
            // v2.9.67: 数据加载完成后,后台填充文件数量
            _enrichCloudSaveFileCounts();
        } catch (err) {
            state.cloudSaveError = err.message || 'UNKNOWN_ERROR';
            console.error('[SGLV] 云存档数据获取失败:', err);
        } finally {
            state.cloudSaveLoading = false;
            renderBody();
        }
    }

    // v2.9.39: 启动时尝试从 IDB 加载缓存（非阻塞）—— 即使后端 fetchGlobalCloudSaves 因 _memCache 未初始化而抓取网络
    // 也能保证先看到本地缓存数据
    async function _tryLoadCloudSaveFromIDBCache() {
        if (state.cloudSaveLoaded && state.cloudSaveGames.length > 0) return;   // 已有内存数据
        if (!window.SGLVCloudSave?.getCachedCloudSavesAsync) return;
        try {
            const cached = await window.SGLVCloudSave.getCachedCloudSavesAsync();
            if (cached && cached.games && cached.games.length > 0) {
                // v2.9.39: 清除旧 _status 标记，避免误显示"新增/变化"徽章
                cached.games.forEach(g => { if (g._status) g._status = null; });
                state.cloudSaveGames = cached.games;
                state.cloudSaveSource = 'cache';
                state.cloudSaveLastUpdate = cached.lastUpdate || 0;
                // v2.9.74: 从 IDB 缓存恢复 fileCountAt,避免页面刷新后丢失导致每次都重新获取文件数
                state.cloudSaveFileCountAt = cached.fileCountAt || 0;
                state.cloudSaveDiff = null;
                state.cloudSaveLoaded = true;
                state.cloudSaveError = null;
                console.log(`[SGLV] 云存档 IDB 缓存命中: ${cached.games.length} 款游戏, 更新于 ${new Date(cached.lastUpdate).toLocaleString()}`);
                renderBody();
                return true;
            }
        } catch (e) {
            console.warn('[SGLV] 云存档 IDB 缓存加载失败:', e);
        }
        return false;
    }

    // v2.9.39: 后台静默增量更新（只增不减 + 6h 节流 + 2天 TTL）
    // - 已有缓存时立即显示缓存数据，后台增量抓取并合并
    // - 节流：6h 内不重复后台刷新（避免频繁抓取被 Steam 限流）
    // - TTL：2 天未更新才触发后台刷新（避免无意义抓取）
    // - additive: 旧游戏中未被新抓取覆盖的项保留（不会显示"删除"）
    async function _backgroundRefreshCloudSave() {
        if (state.cloudSaveBgRefresh) return;   // 已有后台刷新进行中
        if (!window.SGLVCloudSave?.fetchGlobalCloudSaves) return;
        if (Date.now() - (state.cloudSaveBgRefreshAt || 0) < CLOUDSAVE_BG_REFRESH_INTERVAL) {
            return;   // 6h 节流
        }
        state.cloudSaveBgRefresh = true;
        state.cloudSaveBgRefreshAt = Date.now();
        const prevCount = state.cloudSaveGames.length;
        try {
            // additive=true 保留旧数据；silent=true 不修改 lastUpdate（避免影响节流）
            // 这里不传 force，因为 lib 内部 TTL 已处理（仅当 lastUpdate 超 2天才抓取）
            const result = await window.SGLVCloudSave.fetchGlobalCloudSaves(false, { additive: true, silent: true });
            if (result && result.games) {
                state.cloudSaveGames = result.games;
                state.cloudSaveSource = result.source;
                state.cloudSaveLastUpdate = result.lastUpdate;
                state.cloudSaveDiff = result.diff;
                state.cloudSaveLoaded = true;
                state.cloudSaveError = null;
                const newCount = result.games.length - prevCount;
                if (newCount > 0) {
                    console.log(`[SGLV] 云存档后台增量更新: 新增 ${newCount} 款, 总计 ${result.games.length} 款`);
                    showToast(T.csBgRefreshDone.replace('{n}', newCount));
                }
                renderBody();
            }
        } catch (err) {
            console.warn('[SGLV] 云存档后台刷新失败:', err);
        } finally {
            state.cloudSaveBgRefresh = false;
        }
    }

    // v2.9.67: 后台渐进式填充云存档文件数量
    // 全局云存档页面不直接展示文件数,需逐一请求单App页面解析 accountTable tbody tr 行数
    // 参考 Steam 云.html 页面结构: appid=7 (Steam Client) 有 2 个文件 = tbody 内 2 个 tr
    // - v2.9.74: 5天 TTL（云存档相对固定）,fileCountAt 从 IDB 缓存恢复,避免每次页面刷新都重新获取
    // - 并发 3,每请求间隔 500ms
    // - 每获取到一个游戏的文件数就刷新 UI（渐进式更新）
    let _csFileCountAbort = null;
    async function _enrichCloudSaveFileCounts() {
        if (state.cloudSaveFileCountEnriching) return;
        if (!window.SGLVCloudSave?.enrichFileCounts) return;
        // v2.9.74: 5天 TTL——fileCountAt 从 IDB 缓存恢复,避免每次页面刷新都重新获取
        if (Date.now() - (state.cloudSaveFileCountAt || 0) < CLOUDSAVE_FILECOUNT_INTERVAL) return;
        // 检查是否有需要填充的游戏（fileCount=0）
        const needEnrich = state.cloudSaveGames.some(g => g.appid && (!g.fileCount || g.fileCount === 0));
        if (!needEnrich) return;

        state.cloudSaveFileCountEnriching = true;
        state.cloudSaveFileCountAt = Date.now();
        _csFileCountAbort = new AbortController();
        let renderTimer = null;
        try {
            console.log(`[SGLV] 云存档文件数填充开始 (${state.cloudSaveGames.filter(g => !g.fileCount || g.fileCount === 0).length} 款待获取)`);
            await window.SGLVCloudSave.enrichFileCounts(state.cloudSaveGames, {
                concurrency: 3,
                delay: 500,
                signal: _csFileCountAbort.signal,
                onProgress: (updatedGame, allGames) => {
                    // 节流渲染：每 800ms 最多刷新一次 UI
                    if (!renderTimer) {
                        renderTimer = setTimeout(() => {
                            renderTimer = null;
                            if (state.activeTab !== 'cloudsave') return;
                            // v2.11.21 (FEAT-013 TASK-008): 文件数渐进回填改局部更新——仅刷新 .sglv-cs-game-files
                            // 文本节点,不整 Tab 重绘(保留已加载封面 <img> 消除闪烁,参考 wishlist v2.3.23 增量模式);
                            // KPI 总文件数与 filesDesc 排序的最终收敛由下方 finally 的 renderBody 兜底
                            document.querySelectorAll('.sglv-cs-game-list .sglv-cs-game-row[data-appid]').forEach(row => {
                                const g = state.cloudSaveGames.find(x => String(x.appid) === row.dataset.appid);
                                if (!g) return;
                                const files = row.querySelector('.sglv-cs-game-files');
                                if (files) files.textContent = `${g.fileCount || 0} ${T.csFiles}`;
                            });
                        }, 800);
                    }
                },
            });
            console.log('[SGLV] 云存档文件数填充完成');
        } catch (err) {
            console.warn('[SGLV] 云存档文件数填充失败:', err);
        } finally {
            state.cloudSaveFileCountEnriching = false;
            _csFileCountAbort = null;
            // 最终刷新一次 UI
            if (state.activeTab === 'cloudsave') renderBody();
        }
    }

    // v2.9.39: 首次进入云存档标签页时调用——先显示缓存，再后台增量更新
    async function _initCloudSaveTab() {
        // 1) 立即从 IDB 加载缓存（同步显示，无需等待）
        const loaded = await _tryLoadCloudSaveFromIDBCache();
        // 2) 缓存为空时走原 fetch 流程（用户首次使用 / 清缓存）
        if (!loaded) {
            await loadCloudSaveData(false);
            return;
        }
        // 3) 已有缓存 → 后台静默增量更新（不阻塞 UI）
        _backgroundRefreshCloudSave();
        // v2.9.67: 后台渐进式填充文件数量（v2.9.74: 5天 TTL）
        _enrichCloudSaveFileCounts();
    }

    function renderCloudSaveDashboard(parent, wrap) {
        const games = state.cloudSaveGames;
        const fmt = window.SGLVCloudSave.formatSize;

        // v2.9.36: 构建 appid → 游戏名称 映射（从已拥有游戏库中查找）
        const _ownedGameMap = {};
        if (state.ownedGames && state.ownedGames.length > 0) {
            state.ownedGames.forEach(g => {
                if (g.appid) _ownedGameMap[String(g.appid)] = g.name || '';
            });
        }
        // 云存档游戏名称解析：优先用游戏库名称，回退到原始 name 字段
        function resolveGameName(csGame) {
            const appid = String(csGame.appid || '');
            if (_ownedGameMap[appid]) return _ownedGameMap[appid];
            // 如果原始 name 不是 "显示文件" 等无意义值，直接使用
            const raw = csGame.name || '';
            if (raw && raw !== '显示文件' && raw !== 'Show Files' && !/^App\s+\d+$/.test(raw)) return raw;
            return `App ${appid}`;
        }
        // v2.9.44: 封面降级逻辑已抽取到 sglv-cover-fallback.lib.js（@require 引用）
        // 这里只做轻量适配：lib 不可用时安全降级（返回空字符串 + onerror 自然触发 placeholder）
        // v2.9.105: 传递 kind 参数给 lib v1.1.0，使 CDN 链和 API 兜底按图片类型选择最佳 URL
        function getCsCoverUrl(appId, kind) {
            if (window.SGLVCoverFallback && window.SGLVCoverFallback.getCoverUrl) {
                return window.SGLVCoverFallback.getCoverUrl(appId, kind || 'capsule');
            }
            // 兜底：直接用 cloudflare capsule（兼容 lib 未加载场景）
            return `https://cdn.cloudflare.steamstatic.com/steam/apps/${appid}/capsule_231x87.jpg`;
        }

        // ---- KPI 计算 ----
        const totalGames = games.length;
        const totalSize = games.reduce((s, g) => s + (g.sizeBytes || 0), 0);
        const totalFiles = games.reduce((s, g) => s + (g.fileCount || 0), 0);
        const avgSize = totalGames > 0 ? Math.round(totalSize / totalGames) : 0;

        // ---- 大小分布 ----
        const sizeBuckets = [0, 0, 0, 0, 0]; // <1MB, 1-10, 10-50, 50-100, 100+
        const sizeLabels = [T.csSizeLt1, T.csSize1_10, T.csSize10_50, T.csSize50_100, T.csSize100plus];
        games.forEach(g => {
            const mb = (g.sizeBytes || 0) / (1024 * 1024);
            if (mb < 1) sizeBuckets[0]++;
            else if (mb < 10) sizeBuckets[1]++;
            else if (mb < 50) sizeBuckets[2]++;
            else if (mb < 100) sizeBuckets[3]++;
            else sizeBuckets[4]++;
        });

        // ---- 文件数分布 ----
        // v2.9.73: 优化分桶——大多数游戏存档数 <10,旧 <5/5-20/20-50/50+ 颗粒度太粗
        const fileBuckets = [0, 0, 0, 0]; // <3, 3-5, 5-10, 10+
        const fileLabels = [T.csFilesLt3, T.csFiles3_5, T.csFiles5_10, T.csFiles10plus];
        games.forEach(g => {
            const f = g.fileCount || 0;
            if (f < 3) fileBuckets[0]++;
            else if (f <= 5) fileBuckets[1]++;
            else if (f <= 10) fileBuckets[2]++;
            else fileBuckets[3]++;
        });

        // ---- TOP 10 按大小 ----
        const top10 = [...games].sort((a, b) => (b.sizeBytes || 0) - (a.sizeBytes || 0)).slice(0, 10);
        const maxTopSize = top10[0]?.sizeBytes || 1;

        // ---- Diff 汇总 ----
        const diff = state.cloudSaveDiff;
        const hasDiff = diff && (diff.new.length || diff.changed.length || diff.removed.length);

        // ---- 来源/时间 ----
        const sourceLabel = state.cloudSaveSource === 'web' ? T.csSourceWeb : T.csSourceCache;
        const updatedTime = state.cloudSaveLastUpdate ? new Date(state.cloudSaveLastUpdate).toLocaleString() : '';
        // v2.9.74: 文件数更新时间独立显示,避免与存档数据更新时间混淆
        const fileCountTime = state.cloudSaveFileCountAt ? new Date(state.cloudSaveFileCountAt).toLocaleString() : '';

        // ============ 左侧仪表盘 ============
        const side = document.createElement('div');
        side.className = 'sglv-cs-side';
        // v2.11.1: 改经 kpiCards 工厂(tone:playtime)；文件数卡 spinner 为受信后缀 HTML 经 suffixHtml 透传
        side.innerHTML = `
            <div class="sglv-cs-kpi-row">
                ${kpiCards([
                    { icon: ICONS.cloud, label: T.csTotalGames, value: totalGames.toLocaleString(), sub: isZh ? '云存档游戏' : 'cloud games', color: 'purple' },
                    { icon: ICONS.package, label: T.csTotalSize, value: fmt(totalSize), sub: isZh ? '全部存档' : 'all saves', color: 'cyan' },
                    { icon: ICONS.card, label: T.csTotalFiles, value: totalFiles.toLocaleString(), suffixHtml: state.cloudSaveFileCountEnriching ? ' <span class="sglv-cs-filecount-spin" style="display:inline-block;width:14px;height:14px;border:2px solid rgba(245,158,11,0.2);border-top-color:#f59e0b;border-radius:50%;animation:sgc-spin 0.8s linear infinite;vertical-align:middle;margin-left:4px"></span>' : '', sub: state.cloudSaveFileCountEnriching ? (isZh ? '正在获取文件数…' : 'Fetching file counts…') : (isZh ? '存档文件' : 'save files'), color: 'amber' },
                    { icon: ICONS.trend, label: T.csAvgSize, value: fmt(avgSize), sub: isZh ? '平均每款' : 'avg per game', color: 'rose' },
                ], { tone: 'playtime' })}
            </div>

            <div class="sglv-cs-section">
                <div class="sglv-cs-section-title">${T.csTopSizes}</div>
                <div class="sglv-cs-top10">
                    ${top10.map((g, i) => {
                        const gName = resolveGameName(g);
                        return `
                        <div class="sglv-cs-top10-item">
                            <span class="sglv-cs-top10-rank">${i + 1}</span>
                            ${hbarRow({ cls: 'cs10', name: gName, nameTitle: gName, pct: ((g.sizeBytes || 0) / maxTopSize * 100).toFixed(1), val: fmt(g.sizeBytes || 0) })}
                        </div>`;
                    }).join('')}
                </div>
            </div>

            <!-- v2.9.43: 大小分布 + 文件数分布 并排两栏 -->
            <div class="sglv-cs-dist-pair">
                <div class="sglv-cs-dist-card">
                    <div class="sglv-cs-section-title">${T.csSizeDist}</div>
                    <div class="sglv-cs-dist">${sizeBuckets.map((v, i) => {
                        const mx = Math.max(...sizeBuckets, 1);
                        return `<div class="sglv-cs-dist-col">
                            <div class="sglv-cs-dist-bar-track">
                                <div class="sglv-cs-dist-bar" style="height:${(v / mx * 100).toFixed(1)}%" title="${v}"></div>
                            </div>
                            <span class="sglv-cs-dist-val">${v}</span>
                            <span class="sglv-cs-dist-label">${sizeLabels[i]}</span>
                        </div>`;
                    }).join('')}</div>
                </div>
                <div class="sglv-cs-dist-card">
                    <div class="sglv-cs-section-title">${T.csFileDist}</div>
                    <div class="sglv-cs-dist">${fileBuckets.map((v, i) => {
                        const mx = Math.max(...fileBuckets, 1);
                        return `<div class="sglv-cs-dist-col">
                            <div class="sglv-cs-dist-bar-track">
                                <div class="sglv-cs-dist-bar sglv-cs-dist-bar-2" style="height:${(v / mx * 100).toFixed(1)}%" title="${v}"></div>
                            </div>
                            <span class="sglv-cs-dist-val">${v}</span>
                            <span class="sglv-cs-dist-label">${fileLabels[i]}</span>
                        </div>`;
                    }).join('')}</div>
                </div>
            </div>

            ${hasDiff ? `<div class="sglv-cs-diff-box">
                ${diff.new.length ? `<span class="sglv-cs-diff-badge new">${T.csBadgeNew} ${diff.new.length}</span>` : ''}
                ${diff.changed.length ? `<span class="sglv-cs-diff-badge changed">${T.csBadgeChanged} ${diff.changed.length}</span>` : ''}
                ${diff.removed.length ? `<span class="sglv-cs-diff-badge removed">${T.csBadgeRemoved} ${diff.removed.length}</span>` : ''}
            </div>` : ''}

            <div class="sglv-cs-footer">
                <span class="sglv-cs-source-badge">${sourceLabel}</span>
                ${state.cloudSaveBgRefresh ? `<span class="sglv-cs-source-badge" style="color:#67e8f9;border-color:rgba(34,211,238,0.3);background:rgba(34,211,238,0.1);">${T.csBgRefreshing}</span>` : ''}
                ${state.cloudSaveFileCountEnriching ? `<span class="sglv-cs-source-badge" style="color:#f59e0b;border-color:rgba(245,158,11,0.3);background:rgba(245,158,11,0.1);">${isZh ? '获取文件数中…' : 'Fetching file counts…'}</span>` : ''}
                ${updatedTime ? `<span class="sglv-cs-updated">${T.csUpdated}: ${updatedTime}</span>` : ''}
                ${fileCountTime ? `<span class="sglv-cs-updated">${T.csFileCountUpdated}: ${fileCountTime}</span>` : ''}
                <button class="sglv-cs-refresh-btn" id="sglv-cs-refresh" title="${T.csRefreshTip}">${ICONS.refresh}</button>
            </div>
        `;

        // ============ 右侧游戏列表 ============
        const listWrap = document.createElement('div');
        listWrap.className = 'sglv-cs-list-wrap';

        // v2.11.15 (FEAT-013 TASK-002): 工具栏经 buildListToolbar 工厂;sort.value → option 内联 selected(与原实现一致),
        // 搜索 debounce 由工厂统一走共享 debounce(200ms,与原手写 clearTimeout/setTimeout 时长一致)
        const toolbar = buildListToolbar({
            cls: 'sglv-cs-toolbar',
            search: { cls: 'sglv-cs-search', placeholder: T.csSearch, value: state.cloudSaveSearch || '' },
            sort: {
                cls: 'sglv-cs-sort', value: state.cloudSaveSort,
                options: [
                    { value: 'sizeDesc', label: T.csSortSizeDesc },
                    { value: 'sizeAsc', label: T.csSortSizeAsc },
                    { value: 'filesDesc', label: T.csSortFilesDesc },
                    { value: 'nameAsc', label: T.csSortNameAsc },
                ],
            },
            onChange: ({ type, value }) => {
                if (type === 'input') state.cloudSaveSearch = value;
                else state.cloudSaveSort = value;
                renderGameList();
            },
        });

        const listHeader = document.createElement('div');
        listHeader.className = 'sglv-cs-list-header';
        listHeader.innerHTML = `<span>${T.csGameList}</span><span class="sglv-cs-list-count">${games.length}</span>`;

        const listEl = document.createElement('div');
        listEl.className = 'sglv-cs-game-list';

        listWrap.appendChild(toolbar);
        listWrap.appendChild(listHeader);
        listWrap.appendChild(listEl);

        // v2.11.21 (FEAT-013 TASK-008): 云存档行三段插槽构建器——自 renderGameList 手拼模板逐字拆出,
        // 供 renderGameView list 分支 imgHtml/bodyHtml/trailingHtml 消费(闭包依赖 resolveGameName/
        // getCsCoverUrl/fmt/T/isZh 保持在本作用域)
        const _csRowCoverHtml = (g, gName) => {
            // v2.9.44: 游戏封面图（三级降级，data 属性触发全局事件委托）
            // marker 从 data-sglv-cs-cover 改为通用的 data-sglv-cover（lib 通用 marker）
            // v2.9.105: 添加 data-kind="capsule" 使 lib v1.1.0 按 kind 选择 CDN 链和 API 兜底
            return g.appid
                ? `<img class="sglv-cs-game-cover" src="${getCsCoverUrl(g.appid, 'capsule')}" alt="${gName}" loading="lazy" data-sglv-cover="1" data-appid="${g.appid}" data-kind="capsule" referrerpolicy="no-referrer"><span class="sglv-cs-game-cover-fallback" style="display:none;">N/A</span>`
                : '';
        };
        const _csRowInfoHtml = (g, gName) => `
                        <span class="sglv-cs-game-name" title="${gName}">${gName}</span>
                        <span class="sglv-cs-game-appid">App ${g.appid}</span>`;
        const _csRowStatsHtml = (g) => {
            const badge = g._status === 'new'
                ? `<span class="sglv-cs-status-badge new">${T.csBadgeNew}</span>`
                : g._status === 'changed'
                ? `<span class="sglv-cs-status-badge changed">${T.csBadgeChanged}</span>`
                : '';
            return `
                    <div class="sglv-cs-game-stats">
                        ${badge}
                        <span class="sglv-cs-game-files">${g.fileCount || 0} ${T.csFiles}</span>
                        <span class="sglv-cs-game-size">${g.totalSize || fmt(g.sizeBytes || 0)}</span>
                        <a class="sglv-cs-game-dl" href="https://store.steampowered.com/account/remotestorageapp?appid=${g.appid}" target="_blank" rel="noopener noreferrer" title="${isZh ? '查看并下载云存档' : 'View & download cloud saves'}">${isZh ? '去下载' : 'Download'}</a>
                    </div>`;
        };

        // ---- 渲染游戏列表（带搜索+排序） ----
        function renderGameList() {
            let list = [...state.cloudSaveGames];
            if (state.cloudSaveSearch) {
                const q = state.cloudSaveSearch.toLowerCase();
                // v2.9.36: 搜索同时匹配解析后的游戏名称
                list = list.filter(g => {
                    const resolved = resolveGameName(g).toLowerCase();
                    return resolved.includes(q) || String(g.appid).includes(q) || (g.name || '').toLowerCase().includes(q);
                });
            }
            switch (state.cloudSaveSort) {
                case 'sizeAsc': list.sort((a, b) => (a.sizeBytes || 0) - (b.sizeBytes || 0)); break;
                case 'filesDesc': list.sort((a, b) => (b.fileCount || 0) - (a.fileCount || 0)); break;
                case 'nameAsc': list.sort((a, b) => resolveGameName(a).localeCompare(resolveGameName(b))); break;
                default: list.sort((a, b) => (b.sizeBytes || 0) - (a.sizeBytes || 0));
            }

            if (list.length === 0) {
                listEl.innerHTML = `<div class="sglv-cs-list-empty">${isZh ? '无匹配结果' : 'No matching results'}</div>`;
                return;
            }

            // v2.11.21 (FEAT-013 TASK-008): 行骨架经 renderGameView(list 分支 rowsOnly + cs 命名空间)——
            // .sglv-cs-game-list 为 listWrap 直接 flex 子元素(flex:1 滚动区),容器由本函数持有,工厂只产出行序列
            listEl.innerHTML = renderGameView(list, {
                viewMode: 'list',
                rowsOnly: true,
                listItemCls: 'sglv-cs-game-row',
                listInfoCls: 'sglv-cs-game-info',
                itemAttrs: g => ` data-appid="${g.appid}"`,
                imgHtml: g => _csRowCoverHtml(g, resolveGameName(g)),
                bodyHtml: g => _csRowInfoHtml(g, resolveGameName(g)),
                trailingHtml: g => _csRowStatsHtml(g),
            });
        }

        // 组装
        wrap.appendChild(side);
        wrap.appendChild(listWrap);
        parent.innerHTML = '';
        parent.appendChild(wrap);

        renderGameList();

        // ---- 事件绑定 ----
        const refreshBtn = wrap.querySelector('#sglv-cs-refresh');
        if (refreshBtn) {
            // v2.9.39: 手动刷新按钮也使用 additive 模式（只增不减），保护已有游戏列表不被误删
            // v2.9.74: 手动刷新同时重置文件数 TTL,让新增游戏的文件数能立即获取
            refreshBtn.addEventListener('click', () => {
                state.cloudSaveFileCountAt = 0;
                loadCloudSaveDataAdditive(true);
            });
        }

        // v2.9.44: 绑定封面降级事件委托（@require sglv-cover-fallback.lib.js）
        // onFailed 回调:所有降级链失败后,显示右侧 N/A fallback 文本
        if (window.SGLVCoverFallback) {
            window.SGLVCoverFallback.bindErrorHandler(wrap, (img) => {
                if (img.nextElementSibling) img.nextElementSibling.style.display = 'flex';
            });
        } else {
            console.warn('[SGLV] SGLVCoverFallback 未加载 — 封面降级不可用 (请检查 @require sglv-cover-fallback.lib.js)');
        }
    }

    // v2.9.39: additive 模式加载（保留旧数据中未在新抓取中出现的项）
    async function loadCloudSaveDataAdditive(force) {
        state.cloudSaveLoading = true;
        state.cloudSaveError = null;
        renderBody();
        try {
            const result = await window.SGLVCloudSave.fetchGlobalCloudSaves(force, { additive: true, silent: !force });
            state.cloudSaveGames = result.games || [];
            state.cloudSaveSource = result.source;
            state.cloudSaveLastUpdate = result.lastUpdate;
            state.cloudSaveDiff = result.diff;
            state.cloudSaveLoaded = true;
            state.cloudSaveError = null;
            showToast(T.csFetchSuccess.replace('{n}', state.cloudSaveGames.length));
            // v2.9.67: 数据加载完成后,后台填充文件数量
            _enrichCloudSaveFileCounts();
        } catch (err) {
            state.cloudSaveError = err.message || 'UNKNOWN_ERROR';
            console.error('[SGLV] 云存档数据获取失败:', err);
        } finally {
            state.cloudSaveLoading = false;
            renderBody();
        }
    }

    function renderWishlistTab(parent) {
        const wrap = document.createElement('div');
        wrap.className = 'sglv-wishlist-wrap';

        // 左侧仪表盘面板顺序（v2.8.0 调整）：
        // KPI → 待上市游戏 → 我的类别统计 → 热门标签TOP15 → 按年趋势 → 价格区间 → 折扣分布 → 添加时间线
        const side = document.createElement('div');
        side.className = 'sglv-wl-side';
        side.innerHTML = `
            <div id="sglv-wishlist-kpi"></div>
            <div class="sglv-wl-section" id="sglv-wl-upcoming"></div>
            <div class="sglv-wl-section" id="sglv-wl-catstats"></div>
            <div class="sglv-wl-section" id="sglv-wl-tags"></div>
            <div class="sglv-wl-section" id="sglv-wl-year-trend"></div>
            <div class="sglv-wl-section" id="sglv-wl-price-dist"></div>
            <div class="sglv-wl-section" id="sglv-wl-disc-dist"></div>
            <div class="sglv-wl-section" id="sglv-wl-timeline"></div>
        `;
        wrap.appendChild(side);

        // 右侧：游戏视图（工具栏 + 列表）
        const main = document.createElement('div');
        main.className = 'sglv-wl-main';

        const filterBtns = [
            { key: 'all', label: T.all },
            { key: 'discount', label: T.wlFilterDiscount },
            { key: 'coming', label: T.wlFilterComingSoon },
            { key: 'inlibrary', label: T.wlFilterInLibrary },
        ];
        // v2.11.15 (FEAT-013 TASK-002): 工具栏经 buildListToolbar 工厂;刷新按钮经 extraHtml 注入(自定义动作单独绑定)
        const toolbar = buildListToolbar({
            search: { id: 'sglv-wishlist-search', placeholder: T.wlSearch, value: wlEscape(state.wishlistSearch) },
            views: {
                modes: [
                    { mode: 'card', title: T.cardView, icon: ICONS.grid },
                    { mode: 'cover', title: T.coverView, icon: ICONS.cover },
                    { mode: 'list', title: T.listView, icon: ICONS.list },
                ],
                value: state.wishlistViewMode, idPrefix: 'sglv-wl-',
            },
            extraHtml: `<button class="sglv-btn sglv-btn-secondary sglv-btn-icon" id="sglv-wl-refresh" title="${T.wlRefreshTip}">${ICONS.refresh}</button>`,
            onChange: ({ type, value }) => {
                // v2.9.49: debounce 搜索输入在工厂内统一（避免愿望单列表每次按键触发完整重渲染）
                if (type === 'input') {
                    state.wishlistSearch = value;
                    state.wishlistPage = 1;
                    renderWishlistGamesList();
                } else {
                    // v2.4.3: 视图切换统一处理（card/cover/list 三模式，active 类由工厂切换）
                    state.wishlistViewMode = value;
                    renderWishlistGamesList();
                }
            },
        });
        main.appendChild(toolbar);

        // v2.6.1: 筛选标签栏 + 分页放同一行，紧凑操作栏
        // v2.7.3: 更新提示信息移至筛选按钮右侧（红框标注位置）
        const filterBar = document.createElement('div');
        filterBar.className = 'sglv-filter-bar';
        filterBar.innerHTML = `
            <div class="sglv-filter-bar-group">
                ${filterBtns.map(fb =>
                    `<button class="sglv-btn sglv-btn-secondary sglv-wl-filter-btn${state.wishlistFilter === fb.key ? ' active' : ''}" data-filter="${fb.key}">${fb.label}</button>`
                ).join('')}
            </div>
            <span id="sglv-wl-progress" style="font-size:11px;color:var(--sglv-text-secondary);min-height:14px;flex-shrink:0"></span>
            <div class="sglv-pagination sglv-pagination-inline" id="sglv-wishlist-pagination"></div>
        `;
        main.appendChild(filterBar);

        // 游戏列表
        const content = document.createElement('div');
        content.className = 'sglv-content';
        content.id = 'sglv-wishlist-content';
        main.appendChild(content);

        wrap.appendChild(main);
        parent.appendChild(wrap);

        // v2.9.15: 首次加载时显示完整骨架屏(KPI + 8 section + 游戏网格),避免页面紧缩
        // v2.9.47: 修复首次加载骨架屏不显示——改为 !wishlistLoaded 即显示（不要求 wishlistLoading）
        if (!state.wishlistLoaded) {
            createSkeleton('wishlist', wrap);
        }

        // 事件绑定
        // v2.5.0: 筛选按钮事件——从 filterBar 查找
        filterBar.querySelectorAll('.sglv-wl-filter-btn').forEach(btn => {
            btn.addEventListener('click', () => {
                state.wishlistFilter = btn.dataset.filter;
                state.wishlistCategoryFilter = null; // v2.8.0: 清除类别筛选
                state.wishlistPage = 1;
                filterBar.querySelectorAll('.sglv-wl-filter-btn').forEach(b => b.classList.remove('active'));
                btn.classList.add('active');
                renderWishlistSide(); // v2.8.0: 刷新类别卡片高亮状态
                renderWishlistGamesList();
            });
        });
        toolbar.querySelector('#sglv-wl-refresh').addEventListener('click', () => {
            sglvToast.info(isZh ? '正在刷新愿望单…' : 'Refreshing wishlist…');
            loadWishlistGames(true);
        });

        if (!state.wishlistLoaded && !state.wishlistLoading) {
            loadWishlistGames();
        } else {
            renderWishlistSections();
        }
    }

    function renderWishlistSections() {
        if (state.activeTab !== 'wishlist' || !document.getElementById('sglv-wishlist-content')) return;
        renderWishlistKpi();
        renderWishlistSide();
        renderWishlistGamesList();
    }

    // KPI：6 卡片仪表盘（参考 steam-portal WishlistKpiRow，含图标+数值+标签+子文本）
    function renderWishlistKpi() {
        const el = document.getElementById('sglv-wishlist-kpi');
        if (!el) return;
        if (!state.wishlistLoaded) { el.innerHTML = ''; return; }
        const s = computeWishlistStatsCached();
        const sym = detectWlPriceSymbol();
        // v2.9.103: 混合币种聚合提示 — aggregate 对缺汇率币种剔除出 totalValue,存在被排除条目时提示用户
        const multiCurHint = (s.unsupported && s.unsupported.length > 0)
            ? ` · <span style="color:#f59e0b" title="${escHtml(s.unsupported.join(', '))}">${escHtml(T.wlMultiCurHint)}</span>`
            : '';
        // 价格格式化：大数用 k，小数保留整数
        const fmtPrice = (v) => {
            if (v >= 10000) return `${sym}${(v / 1000).toFixed(1)}k`;
            if (v >= 1000) return `${sym}${Math.round(v).toLocaleString()}`;
            return `${sym}${v.toFixed(0)}`;
        };
        // 最早添加日期
        const earliestStr = s.earliestAdded > 0
            ? new Date(s.earliestAdded * 1000).toLocaleDateString(isZh ? 'zh-CN' : 'en-US')
            : '-';
        el.className = 'sglv-wl-kpi-row';
        // v2.11.1: 改经 kpiCards 工厂(tone:wl，icon→value→label→sub 顺序)；multiCurHint 为受信后缀 HTML
        el.innerHTML = kpiCards([
            { icon: ICONS.heart, value: s.total.toLocaleString(), label: T.wlTotal, sub: `${T.wlEarliest} ${earliestStr}`, color: 'kpi-total' },
            { icon: ICONS.dollar, value: fmtPrice(s.totalValue), label: T.wlKpiTotalValue, sub: `${T.wlAvgPrice} ${fmtPrice(s.avgPrice)} · ${T.wlMedian} ${fmtPrice(s.medianPrice)}`, subSuffixHtml: multiCurHint, color: 'kpi-value' },
            { icon: ICONS.tag, value: s.discountedCount.toLocaleString(), label: T.wlKpiOnSale, sub: `${T.wlRate} ${(s.discountedRate * 100).toFixed(1)}% · ${T.wlAvgDisc} ${s.avgDiscount.toFixed(0)}% · ${T.wlMaxDisc} ${s.maxDiscount}%`, color: 'kpi-sale' },
            { icon: ICONS.rocket, value: s.comingSoonCount.toLocaleString(), label: T.wlKpiComingSoon, sub: `${T.wlRate} ${(s.comingSoonRate * 100).toFixed(1)}%`, color: 'kpi-coming' },
            { icon: ICONS.library, value: s.inLibrary.toLocaleString(), label: T.wlKpiInLib, sub: `${T.wlPurchaseRate} ${(s.purchaseRate * 100).toFixed(1)}%`, color: 'kpi-lib' },
            { icon: ICONS.calendar, value: s.addedByYear.length, label: isZh ? '添加年份' : 'Years', sub: s.addedByYear.length > 0 ? `${s.addedByYear[0][0]} - ${s.addedByYear[s.addedByYear.length - 1][0]}` : '-', color: 'kpi-year' },
        ], { tone: 'wl' });
    }

    // 左侧仪表盘：热门标签 TOP 15 + 添加时间线（参考愿望单导出器统计面板样式）
    const WL_TAG_COLORS = ['#66c0f4', '#a78bfa', '#34d399', '#f59e0b', '#ef4444', '#ec4899', '#06b6d4', '#f97316', '#84cc16', '#6366f1', '#14b8a6', '#e11d48', '#8b5cf6', '#0ea5e9', '#10b981'];

    function renderWishlistSide() {
        const tagsEl = document.getElementById('sglv-wl-tags');
        const tlEl = document.getElementById('sglv-wl-timeline');
        const upEl = document.getElementById('sglv-wl-upcoming');
        const ytEl = document.getElementById('sglv-wl-year-trend');
        const pdEl = document.getElementById('sglv-wl-price-dist');
        const ddEl = document.getElementById('sglv-wl-disc-dist');
        const csEl = document.getElementById('sglv-wl-catstats');
        if (!tagsEl || !tlEl) return;
        if (!state.wishlistLoaded) {
            [tagsEl, tlEl, upEl, ytEl, pdEl, ddEl, csEl].forEach(e => { if (e) e.innerHTML = ''; });
            return;
        }
        const s = computeWishlistStatsCached();

        // 按年添加趋势（参考 steam-portal AddedTimelineChart，迷你竖向柱状图）
        // v2.3.23: 柱子外套轨道容器确保百分比高度生效；峰值年份高亮突出
        if (ytEl) {
            const maxY = s.addedByYear.length > 0 ? Math.max(...s.addedByYear.map(x => x[1])) : 1;
            ytEl.innerHTML = `
                <div class="sglv-playtime-section-title">${ICONS.calendar} ${T.wlAddedByYear}</div>
                ${s.addedByYear.length === 0 ? emptyHtml(T.wlNoData, { style: 'padding:8px' }) :
                    `<div class="sglv-wl-year-line">${s.addedByYear.map(([year, count]) => `
                        <div class="sglv-wl-year-col">
                            <span class="sglv-wl-year-val">${count}</span>
                            <div class="sglv-wl-year-track">
                                <div class="sglv-wl-year-bar${count === maxY ? ' peak' : ''}" style="height:${(count / maxY * 100).toFixed(1)}%" title="${year}: ${count}"></div>
                            </div>
                            <span class="sglv-wl-year-label">${year}</span>
                        </div>`).join('')}</div>`}
            `;
        }

        // 价格区间分布（参考 steam-portal PriceDistChart，竖向柱状图）
        if (pdEl) {
            const maxP = s.priceBuckets.length > 0 ? Math.max(...s.priceBuckets.map(b => b.count)) : 1;
            const hasP = s.priceBuckets.some(b => b.count > 0);
            pdEl.innerHTML = `
                <div class="sglv-playtime-section-title">${ICONS.dollar} ${T.wlPriceDist}</div>
                ${!hasP ? emptyHtml(T.wlNoData, { style: 'padding:8px' }) :
                    `<div class="sglv-wl-vbar-chart">${s.priceBuckets.map(b => `
                        <div class="sglv-wl-vbar-col">
                            <span class="sglv-wl-vbar-val">${b.count}</span>
                            <div class="sglv-wl-vbar-track">
                                <div class="sglv-wl-vbar-fill" style="height:${(b.count / maxP * 100).toFixed(1)}%;background:${b.color}" title="${b.label}: ${b.count}"></div>
                            </div>
                            <span class="sglv-wl-vbar-label" title="${b.label}">${b.label}</span>
                        </div>`).join('')}</div>`}
            `;
        }

        // 折扣分布（参考 steam-portal DiscountDistChart，竖向柱状图）
        if (ddEl) {
            const maxD = s.discountBuckets.length > 0 ? Math.max(...s.discountBuckets.map(b => b.count)) : 1;
            const hasD = s.discountBuckets.some(b => b.count > 0);
            ddEl.innerHTML = `
                <div class="sglv-playtime-section-title">${ICONS.tag} ${T.wlDiscountDist}</div>
                ${!hasD ? emptyHtml(T.wlNoData, { style: 'padding:8px' }) :
                    `<div class="sglv-wl-vbar-chart">${s.discountBuckets.map(b => `
                        <div class="sglv-wl-vbar-col">
                            <span class="sglv-wl-vbar-val">${b.count}</span>
                            <div class="sglv-wl-vbar-track">
                                <div class="sglv-wl-vbar-fill" style="height:${(b.count / maxD * 100).toFixed(1)}%;background:${b.color}" title="${b.label}: ${b.count}"></div>
                            </div>
                            <span class="sglv-wl-vbar-label" title="${b.label}">${b.label}</span>
                        </div>`).join('')}</div>`}
            `;
        }

        // 热门标签 TOP 15
        const maxTag = s.topTags.length > 0 ? s.topTags[0][1] : 1;
        tagsEl.innerHTML = `
            <div class="sglv-playtime-section-title">${ICONS.barChart} ${T.wlTopTags}</div>
            ${s.topTags.length === 0 ? emptyHtml(T.wlNoData, { style: 'padding:8px' }) :
                s.topTags.map(([name, count], i) => hbarRow({
                    cls: 'wl', name: wlEscape(name), nameTitle: wlEscape(name),
                    pct: (count / maxTag * 100).toFixed(1), color: WL_TAG_COLORS[i % WL_TAG_COLORS.length], val: count,
                })).join('')}
        `;

        // 添加时间线（按月，取最近 12 个月）
        const maxTl = s.timeline.length > 0 ? Math.max(...s.timeline.map(x => x[1])) : 1;
        tlEl.innerHTML = `
            <div class="sglv-playtime-section-title">${ICONS.clock} ${T.wlTimeline}</div>
            ${s.timeline.length === 0 ? emptyHtml(T.wlNoData, { style: 'padding:8px' }) :
                s.timeline.map(([month, count]) => hbarRow({
                    cls: 'wl', name: month,
                    pct: (count / maxTl * 100).toFixed(1), color: '#22d3ee', val: count,
                })).join('')}
        `;

        // v2.7.3: 待上市游戏图表（参考愿望单插件，替换原类型分布）
        // 按发售时间分组：30天内 / 90天内 / 更远 / 未定日期，并高亮最近即将发售的游戏
        if (upEl) {
            const now = Date.now();
            const day30 = 30 * 864e5, day90 = 90 * 864e5;
            const upcoming = state.wishlistGames
                .filter(g => g.isComingSoon)
                .map(g => {
                    let ts = 0;
                    if (g.releaseDate) {
                        const d = new Date(g.releaseDate);
                        if (!isNaN(d.getTime())) ts = d.getTime();
                    }
                    return { appid: g.appid, name: g.name, ts, releaseDate: g.releaseDate || '' };
                });
            const within30 = upcoming.filter(g => g.ts > 0 && g.ts - now <= day30 && g.ts - now >= 0).length;
            const within90 = upcoming.filter(g => g.ts > 0 && g.ts - now > day30 && g.ts - now <= day90).length;
            const far = upcoming.filter(g => g.ts > 0 && g.ts - now > day90).length;
            const noDate = upcoming.filter(g => g.ts === 0).length;
            const maxUp = Math.max(within30, within90, far, noDate, 1);
            // 最近即将发售的游戏（取第一个有日期且未过期的）
            const nextRelease = upcoming.filter(g => g.ts > 0 && g.ts >= now).sort((a, b) => a.ts - b.ts)[0];
            const upBuckets = [
                { label: T.wlUpcoming30d, count: within30, color: '#10b981' },
                { label: T.wlUpcoming90d, count: within90, color: '#06b6d4' },
                { label: T.wlUpcomingFar, count: far, color: '#a78bfa' },
                { label: T.wlUpcomingNoDate, count: noDate, color: '#94a3b8' },
            ];
            upEl.innerHTML = `
                <div class="sglv-playtime-section-title">${ICONS.rocket} ${T.wlUpcoming}
                    <span style="float:right;font-size:13px;font-weight:600;color:var(--sglv-accent)">${upcoming.length}</span>
                </div>
                ${upcoming.length === 0 ? emptyHtml(T.wlNoData, { style: 'padding:8px' }) :
                    `<div class="sglv-wl-bar-list">${upBuckets.map(b => hbarRow({
                        cls: 'wl', name: b.label,
                        pct: (b.count / maxUp * 100).toFixed(1), color: b.color, val: b.count,
                    })).join('')}
                    </div>`}
                ${nextRelease ? `
                    <div style="margin-top:8px;padding:6px 8px;background:rgba(245,158,11,.12);border-radius:6px;display:flex;align-items:center;gap:6px;font-size:11px">
                        <span style="display:inline-flex;width:14px;height:14px;flex-shrink:0;color:#f59e0b">${ICONS.clock}</span>
                        <span style="flex:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;color:var(--sglv-text)" title="${wlEscape(nextRelease.name)}">${wlEscape(nextRelease.name)}</span>
                        <span style="color:#f59e0b;font-weight:600;flex-shrink:0">${nextRelease.releaseDate}</span>
                    </div>` : ''}
            `;
        }

        // v2.8.0: 我的类别统计（每类别详细统计 + 点击筛选游戏列表）
        if (csEl) {
            const catStats = s.categoryStats || [];
            const uncat = s.uncategorizedStats || { count: 0, totalValue: 0, discountCount: 0, comingSoonCount: 0, inLibraryCount: 0, pct: 0 };
            const sym = detectWlPriceSymbol();
            const activeCat = state.wishlistCategoryFilter;
            const catCount = catStats.length;

            const titleHtml = `<div class="sglv-playtime-section-title">${ICONS.barChart} ${T.wlCatStats}
                <span style="float:right;font-size:13px;font-weight:600;color:var(--sglv-accent)">${catCount}</span>
            </div>`;

            if (s.total === 0) {
                csEl.innerHTML = titleHtml + emptyHtml(T.wlNoData, { style: 'padding:8px' });
            } else if (catCount === 0) {
                csEl.innerHTML = titleHtml + emptyHtml(T.wlUncatEmpty.replace('{n}', uncat.count.toLocaleString()), { style: 'padding:8px' });
            } else {
                const maxCount = Math.max(...catStats.map(c => c.count), uncat.count, 1);
                const renderCatCard = (c, color, isUncat) => {
                    const catId = isUncat ? '__uncat__' : c.id;
                    const isActive = activeCat === catId;
                    const nameStyle = isUncat ? 'font-style:italic;color:var(--sglv-text-secondary)' : '';
                    return `
                    <div class="sglv-wl-cat-card${isActive ? ' active' : ''}" data-cat-id="${wlEscape(catId)}" title="${T.wlCatStatsClick}" style="--cat-color:${color}">
                        <div class="sglv-wl-cat-header">
                            <span class="sglv-wl-cat-dot"></span>
                            <span class="sglv-wl-cat-name" style="${nameStyle}" title="${wlEscape(c.name)}">${wlEscape(c.name)}</span>
                            <span class="sglv-wl-cat-count">${c.count}<span class="sglv-wl-cat-pct">${(c.pct * 100).toFixed(0)}%</span></span>
                        </div>
                        <div class="sglv-wl-cat-stats">
                            <span class="sglv-wl-cat-stat" title="${T.wlKpiTotalValue}">${ICONS.dollar}${sym}${c.totalValue.toFixed(0)}</span>
                            <span class="sglv-wl-cat-stat" title="${T.wlKpiOnSale}">${ICONS.tag}${c.discountCount}</span>
                            <span class="sglv-wl-cat-stat" title="${T.wlKpiComingSoon}">${ICONS.rocket}${c.comingSoonCount}</span>
                            <span class="sglv-wl-cat-stat" title="${T.wlKpiInLib}">${ICONS.library}${c.inLibraryCount}</span>
                        </div>
                        ${hbarRow({ cls: 'wlBare', pct: (c.count / maxCount * 100).toFixed(1), color })}
                    </div>`;
                };
                csEl.innerHTML = `${titleHtml}
                    <div class="sglv-wl-catstats-list">
                        ${catStats.map((c, i) => renderCatCard(c, WL_TAG_COLORS[i % WL_TAG_COLORS.length], false)).join('')}
                        ${uncat.count > 0 ? renderCatCard({ ...uncat, name: T.wlCatStatsNoCat }, '#64748b', true) : ''}
                    </div>`;

                // v2.8.0: 点击类别卡片筛选/取消筛选游戏列表
                csEl.querySelectorAll('.sglv-wl-cat-card').forEach(card => {
                    card.addEventListener('click', () => {
                        const catId = card.dataset.catId;
                        if (state.wishlistCategoryFilter === catId) {
                            state.wishlistCategoryFilter = null;
                            state.wishlistFilter = 'all';
                        } else {
                            state.wishlistCategoryFilter = catId;
                            state.wishlistFilter = 'category';
                        }
                        state.wishlistPage = 1;
                        document.querySelectorAll('.sglv-wl-filter-btn').forEach(b =>
                            b.classList.toggle('active', b.dataset.filter === state.wishlistFilter));
                        renderWishlistSide();
                        renderWishlistGamesList();
                    });
                });
            }
        }
    }

    // v2.9.47: 愿望单加载等待动画——v2.11.3 迁至共享区 wishlistLoadingHtml()（经 createLoadingHtml 工厂）

    function renderWishlistGamesList() {
        const content = document.getElementById('sglv-wishlist-content');
        if (!content) return;
        // v2.5.0: 辅助函数——清空工具栏分页
        const clearPagination = () => { const p = document.getElementById('sglv-wishlist-pagination'); if (p) p.innerHTML = ''; };

        if (state.wishlistLoading) {
            // v2.9.49: 优化加载状态更新——已有 loading 容器时仅更新文本和进度条，避免 spinner 动画重启闪烁
            const existing = content.querySelector('.sglv-wl-loading');
            if (existing) {
                // v2.11.3: 阶段表经共享 getWishlistLoadStage()，消除与加载块的两处重复
                const st = getWishlistLoadStage();
                const textEl = existing.querySelector('.sglv-wl-loading-text');
                const barEl = existing.querySelector('.sglv-wl-loading-bar-fill');
                if (textEl) textEl.textContent = st.text;
                if (barEl) barEl.style.width = st.pct + '%';
            } else {
                content.innerHTML = wishlistLoadingHtml();
            }
            clearPagination();
            return;
        }
        if (!state.wishlistLoaded || state.wishlistGames.length === 0) {
            content.innerHTML = emptyHtml(state.wishlistLoaded ? T.wlNoData : T.wlFetching);
            clearPagination();
            return;
        }

        const games = getFilteredWishlist();
        if (games.length === 0) {
            content.innerHTML = emptyHtml(T.wlNoData);
            clearPagination();
            return;
        }

        // v2.4.0: 复用 paginate 纯函数统一分页计算
        const { pageItems: pageGames, totalPages, page: _clampedPage } = paginate(games, state.wishlistPage, state.wishlistPageSize);
        state.wishlistPage = _clampedPage;

        const ownedIds = getWishlistOwnedIds();
        const sym = detectWlPriceSymbol();
        const isOwned = g => ownedIds.has(Number(g.appid)) || ownedIds.has(String(g.appid));
        // v2.3.23: 在库状态判定集合——个人在库优先，其次家庭共享（ownedGames 未加载时退化为旧集合）
        const myOwnedIds = new Set();
        const familySharedIds = new Set();
        state.ownedGames.forEach(og => {
            if (isGameOwnedByMe(og)) myOwnedIds.add(Number(og.appid));
            else familySharedIds.add(Number(og.appid));
        });
        const showFamily = storage.getShowFamilyShared();
        const ownershipBadgeHtml = g => {
            const id = Number(g.appid);
            const ownedByMe = state.ownedGames.length > 0 ? myOwnedIds.has(id) : isOwned(g);
            if (ownedByMe) return `<span class="sglv-card-badge owned" style="margin-top:0;flex-shrink:0">✓ ${T.wlInLibrary}</span>`;
            // v2.9.67: 家庭共享标签改为图标+“共享”汉字,固定在价格列最右侧,避免换行
            if (showFamily && familySharedIds.has(id)) {
                const _fsIcon = ICONS.familyShare.replace('<svg ', '<svg style="width:11px;height:11px;flex-shrink:0" ');
                return `<span class="sglv-card-badge shared sglv-wl-family-badge" style="margin-top:0" title="${T.wlFamilyShared}">${_fsIcon}${isZh ? '共享' : 'Shared'}</span>`;
            }
            return '';
        };
        const priceHtml = g => {
            if (g.isComingSoon) return `<span class="sglv-wl-price" style="color:#f59e0b;font-style:italic">${T.wlComingSoon}</span>`;
            if (g.isFree) return `<span class="sglv-wl-price">${T.wlFree}</span>`;
            if (!g._priced || g.finalPrice <= 0) return `<span style="font-size:12px;color:var(--sglv-text-secondary)">${T.wlNoPrice}</span>`;
            const orig = (g.discountPct > 0 && g.originalPrice > g.finalPrice)
                ? `<span class="sglv-wl-orig">${sym}${g.originalPrice.toFixed(2)}</span>` : '';
            return `<span class="sglv-wl-price">${sym}${g.finalPrice.toFixed(2)}</span>${orig}`;
        };
        const addedText = g => g.added > 0 ? new Date(g.added * 1000).toLocaleDateString(isZh ? 'zh-CN' : 'en-US') : '-';
        // v2.3.23: 愿望单排序位次徽章（priority = 用户愿望单排名，TOP3 金银铜高亮，tooltip 说明含义）
        const rankHtml = g => g.priority > 0
            ? `<span class="sglv-wl-rank${g.priority <= 3 ? ` sglv-rank-top${g.priority}` : ''}" title="${T.wlRankTip}">#${g.priority}</span>`
            : '';

        // v2.3.23: 卡片正文/列表信息 HTML 抽取，供增量更新复用
        // 卡片精简为 3 行：①名称+AppID ②价格+在库状态（同行，移除折扣徽章）③排序位次+时间图标日期
        const cardBodyHtml = g => `
                        <div class="sglv-card-name" title="${wlEscape(g.name)}"><span data-sglv-appid="${g.appid}">${wlEscape(g.name)}</span><span class="sglv-card-id-inline">${g.appid}</span></div>
                        <div class="sglv-info-row sglv-wl-price-row">
                            <span class="sglv-wl-price-group">${priceHtml(g)}</span>
                            ${ownershipBadgeHtml(g)}
                        </div>
                        <div class="sglv-info-row" style="font-size:11px;color:var(--sglv-text-secondary);display:flex;align-items:center;gap:5px">
                            ${rankHtml(g)}
                            <span class="sglv-wl-added">${ICONS.clock}<span>${addedText(g)}</span></span>
                        </div>`;
        const listInfoHtml = g => `
                        <div class="sglv-list-name"><span data-sglv-appid="${g.appid}">${wlEscape(g.name)}</span><span class="sglv-list-id-inline">${g.appid}</span></div>
                        <div class="sglv-list-meta">
                            ${rankHtml(g)}
                            ${ownershipBadgeHtml(g)}
                            <span class="sglv-wl-added">${ICONS.clock}<span>${addedText(g)}</span></span>
                        </div>`;
        // v2.4.3: 横板封面视图正文（参考 steam-family-game-analysis v1.58 fa-wl-cover-card 布局精简）
        // 在库/家庭共享徽章以浮层形式叠在封面上（见渲染分支的 sglv-wl-cover-badges），正文不含
        const coverBodyHtml = g => `
                        <div class="sglv-card-name" title="${wlEscape(g.name)}"><span data-sglv-appid="${g.appid}">${wlEscape(g.name)}</span><span class="sglv-card-id-inline">${g.appid}</span></div>
                        <div class="sglv-info-row sglv-wl-price-row">
                            <span class="sglv-wl-price-group">${priceHtml(g)}</span>
                            ${rankHtml(g)}
                        </div>
                        <div class="sglv-info-row" style="font-size:11px;color:var(--sglv-text-secondary);display:flex;align-items:center;gap:5px">
                            <span class="sglv-wl-added">${ICONS.clock}<span>${addedText(g)}</span></span>
                        </div>`;

        // v2.3.23: 增量更新——视图模式与当前页 appid 集合未变时，仅更新文本节点，
        // 保留已加载的封面 <img> 元素，修复详情补全刷新时封面从空白到出现反复闪烁的问题
        const idsKey = state.wishlistViewMode + ':' + pageGames.map(g => g.appid).join(',');
        const existView = content.querySelector('[data-ids-key]');
        if (existView && existView.dataset.idsKey === idsKey) {
            pageGames.forEach(g => {
                if (state.wishlistViewMode === 'card') {
                    const body = existView.querySelector(`.sglv-game-card[data-appid="${g.appid}"] .sglv-card-body`);
                    if (body) body.innerHTML = cardBodyHtml(g);
                } else if (state.wishlistViewMode === 'cover') {
                    // v2.4.3: 封面视图增量更新——正文 + 封面浮层徽章，保留已加载的封面 <img>
                    const body = existView.querySelector(`.sglv-wl-cover-card[data-appid="${g.appid}"] .sglv-wl-cover-body`);
                    if (body) body.innerHTML = coverBodyHtml(g);
                    const badges = existView.querySelector(`.sglv-wl-cover-card[data-appid="${g.appid}"] .sglv-wl-cover-badges`);
                    if (badges) badges.innerHTML = ownershipBadgeHtml(g);
                } else {
                    const item = existView.querySelector(`.sglv-list-item[data-appid="${g.appid}"]`);
                    if (!item) return;
                    const info = item.querySelector('.sglv-list-info');
                    if (info) info.innerHTML = listInfoHtml(g);
                    const priceBox = item.querySelector('.sglv-list-price');
                    if (priceBox) priceBox.innerHTML = priceHtml(g);
                }
            });
            // v2.3.33：增量更新后也需异步加载中文名；v2.11.4 改经 applyGameAliases 统一入口
            // （容器内已回填元素经 data-sglv-alias-done 幂等跳过，增量场景零重复请求）
            applyGameAliases(existView);
        } else if (state.wishlistViewMode === 'card') {
            // v2.11.14 (FEAT-013 TASK-001): card 骨架经 renderGameView 工厂（data-appid/onclick/data-ids-key 经插槽保留）
            content.innerHTML = renderGameView(pageGames, {
                viewMode: 'card',
                wrapAttrs: ` data-ids-key="${idsKey}"`,
                itemAttrs: g => ` data-appid="${g.appid}" onclick="window.open('https://store.steampowered.com/app/${g.appid}','_blank')"`,
                imgHtml: g => posterImg(g.appid, wlEscape(g.name)),
                bodyHtml: cardBodyHtml,
            });
        } else if (state.wishlistViewMode === 'cover') {
            // v2.4.3: 横板封面视图（每行3个，参考 steam-family-game-analysis v1.58 fa-wl-cover-grid）
            content.innerHTML = `<div class="sglv-wl-cover-grid" data-ids-key="${idsKey}">${pageGames.map(g => `
                <div class="sglv-wl-cover-card" data-appid="${g.appid}" onclick="window.open('https://store.steampowered.com/app/${g.appid}','_blank')">
                    <div class="sglv-wl-cover-img-wrap">
                        ${capsuleImg(g.appid, wlEscape(g.name))}
                        <div class="sglv-wl-cover-badges">${ownershipBadgeHtml(g)}</div>
                    </div>
                    <div class="sglv-wl-cover-body">${coverBodyHtml(g)}</div>
                </div>
            `).join('')}</div>`;
        } else {
            // v2.11.14 (FEAT-013 TASK-001): list 骨架经 renderGameView 工厂（价格列经 trailingHtml 注入）
            content.innerHTML = renderGameView(pageGames, {
                viewMode: 'list',
                wrapAttrs: ` data-ids-key="${idsKey}"`,
                itemAttrs: g => ` data-appid="${g.appid}" onclick="window.open('https://store.steampowered.com/app/${g.appid}','_blank')"`,
                imgHtml: g => `<img class="sglv-list-icon" src="${getGameIconUrl(g.appid, '')}" alt="${wlEscape(g.name)}" onerror="this.onerror=null;_sglvIconFallback(this,'${g.appid}','')">`,
                bodyHtml: listInfoHtml,
                trailingHtml: g => `<div class="sglv-list-price" style="display:flex;align-items:center;gap:6px;flex-shrink:0">${priceHtml(g)}</div>`,
            });
        }

        // v2.5.0: 分页——使用工具栏内嵌的分页元素（始终可见，不随内容滚动）
        const pagination = document.getElementById('sglv-wishlist-pagination');
        if (pagination) {
            renderPagination(pagination, 'sglv-wishlist', state.wishlistPage, totalPages, games.length,
                () => { state.wishlistPage--; renderWishlistGamesList(); },
                () => { state.wishlistPage++; renderWishlistGamesList(); },
                (p) => { state.wishlistPage = p; renderWishlistGamesList(); });
        }

        // v2.3.33：异步加载游戏中文名（覆盖 SSR/API 返回的英文名）；v2.11.4 改经 applyGameAliases 统一入口
        applyGameAliases(content);
    }

    // ==================== 数据导出 ====================
    function downloadFile(content, filename, type) {
        const blob = new Blob([content], { type });
        const url = URL.createObjectURL(blob);
        const a = document.createElement('a');
        a.href = url; a.download = filename; a.click();
        URL.revokeObjectURL(url);
    }

    function getExportData() {
        let list = [...state.ownedGames];
        const showFamilyShared = storage.getShowFamilyShared();
        if (!showFamilyShared) {
            list = list.filter(g => isGameOwnedByMe(g));
        }
        if (state.searchQuery) {
            const q = state.searchQuery.toLowerCase();
            list = list.filter(g => g.name.toLowerCase().includes(q));
        }
        list.sort((a, b) => a.name.localeCompare(b.name));
        return list;
    }

    function exportCSV() {
        const data = getExportData();
        if (!data.length) {
            showToast(isZh ? '没有可导出的数据' : 'No data to export');
            return;
        }
        const headers = ['AppID', 'GameName', 'PlaytimeHours', 'IsOwned', 'Owners', 'OwnerCount', 'AcquiredTime', 'Publisher', 'Series'];
        const rows = data.map(g => {
            const isOwned = isGameOwnedByMe(g);
            const ownerNames = getGameOwnerNames(g);
            const meta = getGameDBMeta(g.appid);
            const playtimeHours = (g.playtime / 60).toFixed(1);
            const acquiredTime = g.lastPlayed ? new Date(g.lastPlayed * 1000).toISOString() : '';
            return [
                g.appid,
                `"${(g.name || '').replace(/"/g, '""')}"`,
                playtimeHours,
                isOwned ? 'Yes' : 'No',
                `"${ownerNames.replace(/"/g, '""')}"`,
                g.owners ? g.owners.length : 1,
                acquiredTime,
                `"${(meta.publisher || '').replace(/"/g, '""')}"`,
                `"${(meta.series || '').replace(/"/g, '""')}"`
            ];
        });
        const csv = '\uFEFF' + [headers.join(','), ...rows.map(r => r.join(','))].join('\n');
        downloadFile(csv, `steam_games_${Date.now()}.csv`, 'text/csv;charset=utf-8');
    }

    function exportJSON() {
        const data = getExportData();
        if (!data.length) {
            showToast(isZh ? '没有可导出的数据' : 'No data to export');
            return;
        }
        const json = JSON.stringify(data.map(g => {
            const isOwned = isGameOwnedByMe(g);
            const ownerNames = getGameOwnerNames(g);
            const meta = getGameDBMeta(g.appid);
            return {
                appid: g.appid,
                name: g.name,
                playtime_hours: Number((g.playtime / 60).toFixed(1)),
                is_owned: isOwned,
                owners: g.owners || [],
                owner_names: ownerNames,
                owner_count: g.owners ? g.owners.length : 1,
                acquired_time: g.lastPlayed ? new Date(g.lastPlayed * 1000).toISOString() : null,
                publisher: meta.publisher || null,
                series: meta.series || null
            };
        }), null, 2);
        downloadFile(json, `steam_games_${Date.now()}.json`, 'application/json');
    }

    // ==================== 数据获取流程 ====================
    async function startFetch(force = false) {
        // v2.9.109: refreshBtn/setLoading 提前定义供 finally 使用；pre-checks 移入 try-catch
        const refreshBtn = document.getElementById('sglv-refresh-btn');
        const setLoading = (loading) => {
            if (refreshBtn) refreshBtn.classList.toggle('sglv-spin', loading);
        };
        try {
        const steamId = getActiveSteamId();
        const apiKey = storage.getApiKey();
        const authToken = await getAccessToken();

        if (!steamId) {
            showToast(isZh ? '未检测到 SteamID，请先在设置中填写' : 'SteamID not detected. Please configure in settings.');
            state.showSettings = true;
            renderBody();
            return;
        }

        // API Key 是获取完整游戏库+时长的首选；无 Key 时尝试 scraping / access_token 兜底
        if (!apiKey) {
            showToast(isZh ? '未设置 API Key，将尝试页面抓取（数据可能不完整）' : 'No API Key set, will try page scraping (data may be incomplete).');
        }

        if (force) {
            // 强制刷新：清空缓存中的游戏数据（保留设置）
            storage.setCachedGames([]);
            state.ownedGames = [];
            state.ownedAppIds = new Set();
            invalidateActiveOwnedAppIdsCache();
            clearComputedCache();
            // v2.1: 同时清除侧边栏 TTL 缓存
            cacheClear('achievements_');
            cacheClear('globalAchievements_');
            cacheClear('news_');
            cacheClear('historyPrices_');
            cacheClear('familyShare_');
        }

        setLoading(true);
        state.isLoading = true;
        // v2.9.15: 多阶段状态机进度条
        StageProgress.show();
            // 阶段1/4: 拉取库存（带 3 子步进度回调:token→owned→family→dynamicstore）
            StageProgress.setStage(1, 4, isZh ? '正在拉取库存…' : 'Fetching owned games…');
            const games = await fetchAllGames((sub, pct, text) => {
                // sub 1-3 都映射到阶段 1 的 0-30% 区间
                const mappedPct = Math.min(30, Math.round(pct * 0.3));
                StageProgress.setProgress(mappedPct, text);
            });
            if (games.length === 0) {
                StageProgress.fail(isZh ? '未获取到游戏数据' : 'No games fetched');
                showToast(isZh ? '未获取到游戏数据，请检查 SteamID、API Key 或登录状态' : 'No games fetched. Check SteamID, API Key or login status.');
                return;
            }
            games.sort((a, b) => a.name.localeCompare(b.name));
            state.ownedGames = games;
            state.ownedAppIds = new Set(games.map(g => g.appid));
            storage.setCachedGames(games);
            _activeSteamId = null; // Invalidate cache!
            invalidateActiveOwnedAppIdsCache();
            markSearchIndexDirty(); // v2.9.51: 搜索索引依赖 ownedGames,标记为脏
            document.dispatchEvent(new CustomEvent('sglv:games-updated', { detail: { count: games.length } }));
            StageProgress.setProgress(30, isZh ? `已获取 ${games.length} 款游戏,补全详情…` : `Got ${games.length} games, enriching…`);

            // 阶段2/4: 补全 appdetails（带进度回调，映射到 30-60% 区间）
            StageProgress.setStage(2, 4, isZh ? '正在补全游戏详情…' : 'Enriching game details…');
            if (typeof enrichOwnedAppTypes === 'function') {
                try {
                    await enrichOwnedAppTypes((pct, text) => {
                        // 阶段 2 区间 30% - 60%
                        const mapped = 30 + Math.round(pct * 0.3);
                        StageProgress.setProgress(mapped, text);
                    });
                } catch (e) {
                    console.warn('[SGLV] 补全 appdetails 失败:', e);
                }
            }
            StageProgress.setProgress(60, isZh ? '正在加载进包 / DLC 数据…' : 'Loading bundles / DLC…');

            // 阶段3/4: 加载进包 / DLC / 锁区(各自有负缓存,失败不阻塞)
            // v2.9.15: 3 个并发任务各自报告进度,合并到 60%-90% 区间
            StageProgress.setStage(3, 4, isZh ? '正在加载进包 / DLC / 锁区…' : 'Loading bundles / DLC / region…');
            const subProgress = { bundle: 0, dlc: 0, blocked: 0 };
            const updateCombined = () => {
                // 3 任务平均 0-100,合并后映射到 60-90%
                const avg = (subProgress.bundle + subProgress.dlc + subProgress.blocked) / 3;
                StageProgress.setProgress(60 + Math.round(avg * 0.3));
            };
            await Promise.allSettled([
                typeof loadBundleDatabase === 'function' ? loadBundleDatabase().catch(() => null) : null,
                typeof loadDlcDatabase === 'function' ? loadDlcDatabase().catch(() => null) : null,
                typeof loadBlockedApps === 'function' ? loadBlockedApps(force, (stage, text) => {
                    // 锁区 3 步(API/HTML/完成),每步占 1/3
                    subProgress.blocked = stage * 33;
                    updateCombined();
                }).catch(() => null) : null,
            ].filter(Boolean));
            // bundle/dlc 是单次拉取,标记完成
            StageProgress.setProgress(90, isZh ? '正在完成渲染准备…' : 'Finalizing…');

            // 阶段4/4: 渲染
            StageProgress.setStage(4, 4, isZh ? '完成' : 'Done');
            sglvToast.success(force ? T.refreshSuccess : T.fetchSuccess.replace('{n}', games.length));
            renderBody();
            StageProgress.finish(isZh ? '完成' : 'Done');

            // v2.9.50: 数据刷新后渐进式更新(不阻塞当前渲染完成)
            // 立即 renderBody 走 PCC 缓存(可能命中旧数据,跨 session 复用)
            // 后台异步:enrichOwnedAppTypes 已完成 + 新增的 patch-on-cache-invalidate
            // 注意:enrichOwnedAppTypes 在阶段 2 已完成,但此时游戏库 inventory 完整;PCC 缓存输入签名
            // 包含 acquiredTime 累计,所以 inventory 更新后签名变化,下次 render 会触发重算
            // 这里的"渐进式"指:用户已看到页面,后台异步重算大数据并 patch 对应区域(不全量重建)
            if (typeof _progressiveUpdateAfterFetch === 'function') {
                _progressiveUpdateAfterFetch(games);
            }
        } catch (e) {
            console.error('[SGLV] Fetch error:', e);
            StageProgress.fail(e.message || String(e));
            sglvToast.error(T.fetchFail + ': ' + (e.message || e));
        } finally {
            state.isLoading = false;
            setLoading(false);
        }
    }

    // v2.9.50: 数据刷新后渐进式更新 — 立即用缓存渲染后,后台异步重算大数据并局部 patch
    //   流程:
    //     1) startFetch 完成 → 立即 renderBody()(走 PCC,可能命中旧数据)
    //     2) 下一个事件循环:setTimeout(0) 触发 _progressiveUpdateAfterFetch
    //     3) 后台异步重算(年度统计 / 家庭组 / insight),不影响主线程
    //     4) 每个任务完成后,若面板还开着且数据有变化,仅 patch 对应 DOM 节点
    //   与 wishlist 模式(reference: refreshWishlistDynamicFields)类似,但作用域更大
    //   收益:
    //     - 首次开面板:0 ms 看到页面(PCC 同步预热)
    //     - 数据刷新后:用户立即看到结果(可能旧数据),后台渐进式 patch
    //     - 多次开/关面板:首次同步重算后落 PCC,后续直接命中
    function _progressiveUpdateAfterFetch(games) {
        setTimeout(() => {
            // 仅在面板还开着且无新加载中时跑(避免用户主动刷新时重复)
            if (!panelEl || !panelEl.classList.contains('sglv-show')) return;
            if (state.isLoading) return;
            try {
                // 触发大数据重算(后台) — 不强制刷新,只是让 PCC 失效后再算
                // 直接调用同步 getBizCached:未命中则同步重算 + 落盘;命中则立即返回
                // 这里不直接调用,而是让用户在切到 trend/playtime/insight 标签时按需触发
                // 我们预热(预跑)一次,这样切标签时已命中缓存
                if (typeof computeYearlyStatsAllCached === 'function' && state.ownedGames.length > 0) {
                    const steamId = getActiveSteamId();
                    const allGames = state.ownedGames;
                    const hasOwnerData = steamId && allGames.some(g => g.owners && g.owners.length > 0);
                    const otherMembers = [];
                    if (storage.getShowFamilyShared() && hasOwnerData && steamId) {
                        const familyInfo = storage.getFamilyInfo();
                        const nameMap = familyInfo?.steamIdtoName || {};
                        otherMembers.push(...Object.entries(nameMap)
                            .filter(([sid]) => sid !== steamId)
                            .map(([sid, name]) => ({ steamid: sid, name })));
                    }
                    // 同步预热(单次遍历,无重复)— 完成后已落 PCC,下次切 trend 标签时 0 ms 命中
                    computeYearlyStatsAllCached(allGames, steamId, otherMembers);
                }
                // 预热 insight(仅依赖已加载的 state.ownedGames,无需网络)
                if (typeof computeInsightDataCachedSgis === 'function' && state.ownedGames.length > 0) {
                    computeInsightDataCachedSgis();
                }
                // 预热我的成就
                if (typeof computeMyAchievementsCached === 'function' && state.ownedGames.length > 0) {
                    computeMyAchievementsCached();
                }
                // 仅在 trend/playtime/insight/achievements 当前显示时 patch DOM
                // patch 模式:不全量重建,只更新关键 KPI 数字
                _patchActiveTabKpis();
                console.log('[SGLV-Compute] 数据刷新后渐进式更新完成 — PCC 已预热');
            } catch (e) {
                console.warn('[SGLV-Compute] 渐进式更新失败:', e);
            }
        }, 0);
    }

    // v2.9.50: 局部 patch 当前打开的标签页 KPI/图表数据(不重建 DOM 避免闪烁)
    // 支持:trend(年度统计/家庭组)/playtime/insight(SGIS 子闭包)
    function _patchActiveTabKpis() {
        const tab = state.activeTab;
        if (!tab) return;
        try {
            if (tab === 'trend') {
                // 强制清空 _computedCache 内的 trend 局部缓存(只重算 trend 用的,不影响其他)
                // 然后只 patch 关键 KPI 区域而不整体 renderBody
                const trendKpi = document.getElementById('sglv-trend-kpi') || document.querySelector('.sglv-trend-kpi-wrap');
                if (trendKpi) {
                    // 简单策略:替换整个 KPI 区域(只 KPI 部分,不动图表)— 用户视觉感知最小
                    const parent = trendKpi.parentNode;
                    if (parent) {
                        // 清空 _computedCache 让 compute* 重新跑(走 PCC 命中)
                        // 这里我们直接用 PCC 拿到的数据局部 patch
                        const allGames = state.ownedGames;
                        if (allGames.length === 0) return;
                        const steamId = getActiveSteamId();
                        const hasOwnerData = steamId && allGames.some(g => g.owners && g.owners.length > 0);
                        const otherMembers = [];
                        if (storage.getShowFamilyShared() && hasOwnerData && steamId) {
                            const familyInfo = storage.getFamilyInfo();
                            const nameMap = familyInfo?.steamIdtoName || {};
                            otherMembers.push(...Object.entries(nameMap)
                                .filter(([sid]) => sid !== steamId)
                                .map(([sid, name]) => ({ steamid: sid, name })));
                        }
                        // PCC 已经在 _progressiveUpdateAfterFetch 里预热
                        // 这里只 patch KPI 数字
                        const _ya = computeYearlyStatsAllCached(allGames, steamId, otherMembers);
                        if (_ya && _ya.yearly) {
                            // 更新主 KPI 卡片的数字(只 textContent,不重建 DOM)
                            const yearlyStats = _ya.yearly;
                            const now = new Date();
                            const thisYear = now.getFullYear();
                            const thisYearIdx = yearlyStats.years.indexOf(thisYear);
                            const thisYearCount = thisYearIdx >= 0 ? yearlyStats.counts[thisYearIdx] : 0;
                            // 找包含"今年"字样的 KPI 卡,只更新其数字
                            const cards = trendKpi.querySelectorAll('.sglv-trend-kpi-card');
                            cards.forEach(card => {
                                const label = card.querySelector('.sglv-trend-kpi-label');
                                if (!label) return;
                                const ltxt = label.textContent || '';
                                const valueEl = card.querySelector('.sglv-trend-kpi-value');
                                if (!valueEl) return;
                                if (ltxt.includes(T.trendKpiThisYear)) {
                                    valueEl.firstChild && (valueEl.firstChild.nodeValue = String(thisYearCount));
                                } else if (ltxt.includes(T.trendKpiAvgYear)) {
                                    const yc = yearlyStats.years.length;
                                    const avg = yc > 0 ? Math.round(yearlyStats.total / yc) : 0;
                                    valueEl.firstChild && (valueEl.firstChild.nodeValue = String(avg));
                                }
                            });
                        }
                    }
                }
            }
        } catch (e) {
            // patch 失败时静默回退到 renderBody 整体重建
            console.warn('[SGLV-Compute] 局部 patch 失败,回退到 renderBody:', e);
            try { renderBody(); } catch (_) { /* ignore */ }
        }
    }

    // ==================== 自动初始化扫描 ====================
    async function autoScan() {
        // v2.9.109: 全部包裹在 try-catch 中，防止 getActiveSteamId/getAccessToken 抛出导致 unhandled rejection
        try {
            // v2.9.5: 无 API Key 且无缓存时跳过自动扫描（首次使用由 initUI 引导用户配置）
            if (!storage.getApiKey() && state.ownedGames.length === 0) return;
            // 有缓存就不扫
            if (state.ownedGames.length > 0) return;

            const steamId = getActiveSteamId();
            const authToken = await getAccessToken();
            if (!steamId && !authToken) return;

            console.log('[SGLV] 自动扫描游戏库...');
            const games = await fetchAllGames();
            if (games.length > 0) {
                games.sort((a, b) => a.name.localeCompare(b.name));
                state.ownedGames = games;
                state.ownedAppIds = new Set(games.map(g => g.appid));
                storage.setCachedGames(games);
                _activeSteamId = null; // Invalidate cache!
                clearComputedCache();
                markSearchIndexDirty(); // v2.9.51: 搜索索引依赖 ownedGames,标记为脏
                // 通知侧边栏数据已更新
                document.dispatchEvent(new CustomEvent('sglv:games-updated', { detail: { count: games.length, source: 'auto' } }));
                console.log(`[SGLV] 自动扫描完成，共 ${games.length} 款游戏`);
            }
        } catch (e) {
            console.warn('[SGLV] 自动扫描失败:', e);
        }
    }

    // 导出 SGLV 公开接口（供 bootstrap + SGIS 调用）
    SGLV_API.initUI = initUI;
    SGLV_API.autoScan = autoScan;
    // v2.11.40: 主题层 API——供测试与外部调试（SGLV_API_KEYS 基线已同步 +3 键）
    SGLV_API.getThemeId = getThemeId;
    SGLV_API.applySglvTheme = applySglvTheme;
    SGLV_API.getThemes = () => SGLV_THEMES;
    // v2.4.1: 以下函数被 SGIS 子闭包引用，需导出
    SGLV_API.buildPersonalTimeline = buildPersonalTimeline;
    SGLV_API.buildFamilyTimeline = buildFamilyTimeline;
    SGLV_API.fetchWishlistFromApi = fetchWishlistFromApi;
    SGLV_API.openGlobalSettings = openGlobalSettings;
    // v2.11.44: 供 SGIS 兄弟闭包经顶部别名桥接（社区图标 community_assets 新路径 + icon 成功缓存）。
    // 注意须在此处(渲染子闭包内,先于 SGIS 求值)导出——SGIS 顶部的 const 别名在求值时即固化绑定。
    SGLV_API.getGameIconUrl = getGameIconUrl;
    // v2.9.3: 桥接 DLC 数据库函数到外层作用域，供 getStatFilteredGames 使用
    SGLV_API.isDlc = isDlc;
    SGLV_API.loadDlcDatabase = loadDlcDatabase;
    SGLV_API.loadDlcDatabaseFromCacheSync = loadDlcDatabaseFromCacheSync;  // v2.9.5
    SGLV_API.enrichOwnedAppTypes = enrichOwnedAppTypes;  // v2.9.6: 供 SGIS 侧边栏调用
    SGLV_API.invalidateAppTypeCache = () => { appTypeMap = null; };  // v2.9.6: 游戏库刷新时失效
    // v2.9.6: DLC 数据库就绪判定——Barter.vg 数据库 OR Steam type map 任一加载即可
    SGLV_API.isDlcDbReady = () => !!(dlcDbData || appTypeMap);
    // v2.9.61: 导出 renderBody 与 panelEl 访问器，供外层作用域（switchToTab/_gsJumpToGame/bindGlobalSearchEvents）桥接调用
    // 背景：v2.9.56 提取 switchToTab 时误置于子闭包之外，导致 panelEl/renderBody 越界 ReferenceError
    SGLV_API.renderBody = renderBody;
    SGLV_API.getPanelEl = () => panelEl;
    // v2.9.68: 桥接 computeInsightDataCachedSgis 供 SGIS 子闭包调用（修复 ReferenceError）
    SGLV_API.computeInsightDataCachedSgis = computeInsightDataCachedSgis;
    // v2.9.85: 桥接 detectWlPriceSymbol 供外层 _renderDetailContent 调用（修复 ReferenceError）
    SGLV_API.detectWlPriceSymbol = detectWlPriceSymbol;
    // v2.9.73: 桥接 PCC hydrate 供 init() 调用（_PCC_CACHE 定义在本子闭包内,init() 在外层作用域无法直接访问）
    SGLV_API.hydratePccCache = function () {
        if (!_PCC_CACHE) return;
        try {
            const r = _PCC_CACHE.hydrate();
            if (r && r.hydrated > 0) console.log(`[SGLV-Compute] PCC IDB hydrate 完成,${r.hydrated} 项已就绪`);
        } catch (e) { /* noop */ }
    };

    // ==================== v2.9.12: 锁区游戏数据加载 ====================
    // 数据源: steam-tracker.com API (Banned + Purchase disabled) + HTML 抓取 (Regional variant) + 手动导入
    // v2.9.27: 新增 GitHub 静态数据源（由 py_scripts/scrape_blocked_games.py 预先生成，存放于 SmallRob/steam-namespace），优先加载
    const STEAM_TRACKER_API = 'https://steam-tracker.com/api?action=GetAppListV3';
    const STEAM_TRACKER_REGIONAL_URL = 'https://steam-tracker.com/user/76561198027066612/apps/10';
    // v2.9.27: 静态数据源（jsdelivr CDN 加速），数据由 scrape_blocked_games.py 生成后存放于 steam-namespace 仓库
    const BLOCKED_STATIC_URL = 'https://fastly.jsdelivr.net/gh/SmallRob/steam-namespace@main/data/steam_blocked_apps.json';
    // 过滤的 category_id: 3=Purchase disabled, 20=Banned
    const BLOCKED_CATEGORY_IDS = new Set([3, 20]);

    /**
     * v2.9.27: 从 GitHub 静态数据源加载锁区游戏数据（jsdelivr CDN 加速）
     * 数据格式: { version, source, fetchedAt, totalCount, data: [{appid, name, category, categoryId, type, source, changedAt}] }
     * v2.9.90: 返回 { apps, fetchedAt } 以支持时间戳缓存比较
     */
    function fetchBlockedFromStatic() {
        return sglvGmFetchRetry(BLOCKED_STATIC_URL, {
            timeout: 15000,
            headers: { 'Accept': 'application/json' },
        }).then(data => {
            const apps = Array.isArray(data) ? data : (Array.isArray(data.data) ? data.data : []);
            if (apps.length === 0) throw new Error('Empty static data');
            const mappedApps = apps.map(a => ({
                appid: Number(a.appid) || 0,
                name: (a.name || '').trim(),
                category: a.category || '',
                categoryId: a.categoryId || a.category_id || 0,
                type: a.type || 'game',
                source: 'static',
                changedAt: a.changedAt || a.changed_at || '',
            }));
            // v2.9.90: 提取远程 fetchedAt 时间戳用于缓存版本比较
            const fetchedAt = (!Array.isArray(data) && data.fetchedAt) ? data.fetchedAt : '';
            return { apps: mappedApps, fetchedAt };
        });
    }

    /**
     * 从 steam-tracker.com API 获取 Banned + Purchase disabled 应用
     */
    function fetchBlockedFromApi() {
        return sglvGmFetchRetry(STEAM_TRACKER_API, {
            timeout: 20000,
            headers: { 'Accept': 'application/json' },
        }).then(data => {
            if (!data || !data.success || !Array.isArray(data.removed_apps)) {
                throw new Error('Invalid API response');
            }
            return data.removed_apps
                .filter(a => BLOCKED_CATEGORY_IDS.has(a.category_id))
                .map(a => ({
                    appid: a.appid,
                    name: (a.name || '').trim(),
                    category: a.category || '',
                    categoryId: a.category_id,
                    type: a.type || 'game',
                    source: 'api',
                    changedAt: a.changed_at || '',
                }));
        });
    }

    /**
     * 从 steam-tracker.com HTML 页面抓取 Regional variant (cat_id=10) 应用
     */
    function fetchRegionalVariants() {
        return sglvGmFetchTextRetry(STEAM_TRACKER_REGIONAL_URL, {
            timeout: 15000,
            headers: { 'Accept': 'text/html', 'Accept-Language': 'en-US,en;q=0.9' },
        }).then(html => {
            const doc = new DOMParser().parseFromString(html, 'text/html');
            const rows = doc.querySelectorAll('table tbody tr');
            const apps = [];
            rows.forEach(row => {
                const cells = row.querySelectorAll('td');
                if (cells.length < 4) return;
                // 列结构: Owners% | AppID(link to steamdb) | Name(link) | Type | Changed | ...
                const appidText = cells[1]?.textContent?.trim() || '';
                const appid = parseInt(appidText);
                if (!appid) return;
                const name = cells[2]?.textContent?.trim() || '';
                const changedAt = cells[4]?.textContent?.trim() || '';
                apps.push({
                    appid, name,
                    category: 'Regional variant',
                    categoryId: 10,
                    type: 'game',
                    source: 'html',
                    changedAt,
                });
            });
            return apps;
        });
    }

    /**
     * 解析手动导入的 JSON (兼容 srbb_blocked_apps 格式 {appid: {name, at}})
     */
    function parseManualBlockedJson(text) {
        const obj = JSON.parse(text);
        const apps = [];
        if (Array.isArray(obj)) {
            // 数组格式 [{appid, name, ...}]
            obj.forEach(a => {
                if (a.appid) apps.push({
                    appid: Number(a.appid),
                    name: String(a.name || '').trim(),
                    category: a.category || 'User imported',
                    categoryId: a.categoryId || 0,
                    type: a.type || 'game',
                    source: 'manual',
                    changedAt: a.changedAt || '',
                });
            });
        } else if (obj && typeof obj === 'object') {
            // srbb_blocked_apps 格式 {appid: {name, at}}
            Object.entries(obj).forEach(([id, info]) => {
                const appid = Number(id);
                if (appid && info && typeof info === 'object') {
                    apps.push({
                        appid,
                        name: String(info.name || '').trim(),
                        category: 'User imported',
                        categoryId: 0,
                        type: 'game',
                        source: 'manual',
                        changedAt: info.at ? new Date(info.at).toISOString().slice(0, 10) : '',
                    });
                }
            });
        }
        return apps;
    }

    /**
     * v2.9.90: 后台静默检查锁区数据远程版本——比较 fetchedAt 时间戳
     * 若远程 fetchedAt 与缓存不同，更新缓存并派发 sglv:blocked-data-updated 事件
     */
    async function _checkBlockedRemoteVersion(cachedFetchedAt) {
        try {
            const result = await fetchBlockedFromStatic();
            if (result.fetchedAt && result.fetchedAt !== cachedFetchedAt) {
                const apps = result.apps;
                state.blockedApps = apps;
                state.blockedSource = 'static';
                state.blockedLoaded = true;
                cacheSet('blockedApps', { apps, source: 'static', fetchedAt: result.fetchedAt }, CACHE_TTL.blockedApps);
                document.dispatchEvent(new CustomEvent('sglv:blocked-data-updated', {
                    detail: { apps, source: 'static', fetchedAt: result.fetchedAt }
                }));
                console.log(`[SGLV] 锁区数据远程已更新: fetchedAt ${cachedFetchedAt || 'N/A'} → ${result.fetchedAt} (${apps.length} 款)`);
            }
        } catch (e) {
            // 静默失败，不影响主流程
        }
    }

    /**
     * 加载锁区游戏数据（v2.9.27: 四级 fallback: 静态源 → API → HTML → 缓存）
     * v2.9.90: 缓存命中时后台静默检查远程 fetchedAt，有更新则自动刷新缓存+派发事件
     * @param {boolean} force - 强制刷新
     * @param {function} onProgress - (stage, text) 进度回调
     */
    async function loadBlockedApps(force = false, onProgress) {
        const report = (stage, text) => { if (typeof onProgress === 'function') onProgress(stage, text); };
        if (!force) {
            const cached = cacheGet('blockedApps');
            if (cached && Array.isArray(cached.apps) && cached.apps.length > 0) {
                state.blockedApps = cached.apps;
                state.blockedSource = cached.source || 'api';
                state.blockedLoaded = true;
                report(3, isZh ? '缓存命中' : 'Cached');
                // v2.9.90: 后台静默检查远程 fetchedAt 是否有新版本
                _checkBlockedRemoteVersion(cached.fetchedAt || '');
                return { apps: state.blockedApps, source: state.blockedSource, fetchedAt: cached.fetchedAt || '' };
            }
            // v2.9.15: 负缓存——失败后短期不再重试,保护 steam-tracker.com
            if (negCacheGet(nsKey('blocked_neg'), 30 * 60 * 1000)) {
                console.log('[SGLV] blocked apps 命中负缓存,跳过重试');
                report(0, isZh ? '负缓存命中,跳过' : 'Negative cache');
                return { apps: [], source: 'none' };
            }
        }

        state.blockedLoading = true;
        state.blockedError = null;

        try {
            const merged = new Map();
            let source = 'static';
            let remoteFetchedAt = '';

            // v2.9.27 Level 0: GitHub 静态数据源（jsdelivr CDN，优先加载，避免在线抓取网络问题）
            report(1, isZh ? '正在加载静态数据源…' : 'Fetching static source…');
            try {
                const staticResult = await fetchBlockedFromStatic();
                staticResult.apps.forEach(a => merged.set(a.appid, a));
                remoteFetchedAt = staticResult.fetchedAt;
                if (merged.size > 0) source = 'static';
            } catch (e) {
                console.warn('[SGLV] 静态数据源失败:', e.message);
            }

            // Level 1: API (Banned + Purchase disabled) — 静态源无数据时回退
            if (merged.size === 0) {
                report(1, isZh ? '正在拉取 steam-tracker API…' : 'Fetching API…');
                try {
                    const apiApps = await fetchBlockedFromApi();
                    apiApps.forEach(a => merged.set(a.appid, a));
                    if (merged.size > 0) source = 'api';
                } catch (e) {
                    console.warn('[SGLV] steam-tracker API 失败:', e.message);
                }
            }

            // Level 2: HTML 抓取 (Regional variant) — 补充静态源/API 缺失的 Regional 数据
            report(2, isZh ? '正在抓取 HTML 兜底…' : 'Fetching HTML fallback…');
            try {
                const htmlApps = await fetchRegionalVariants();
                htmlApps.forEach(a => {
                    if (!merged.has(a.appid)) merged.set(a.appid, a);
                });
                if (merged.size > 0 && source !== 'static') source = 'mixed';
            } catch (e) {
                console.warn('[SGLV] steam-tracker HTML 抓取失败:', e.message);
            }

            if (merged.size === 0) {
                throw new Error('No blocked apps data found');
            }

            const apps = Array.from(merged.values());
            state.blockedApps = apps;
            state.blockedSource = source;
            state.blockedLoaded = true;
            state.blockedLoading = false;

            cacheSet('blockedApps', { apps, source, fetchedAt: remoteFetchedAt }, CACHE_TTL.blockedApps);
            // v2.9.15: 成功后清负缓存
            negCacheClear(nsKey('blocked_neg'));
            report(3, isZh ? `完成 (${apps.length} 款)` : `Done (${apps.length})`);

            // v2.9.90: 数据更新后派发事件，供收藏浮窗监听并自动刷新 UI
            document.dispatchEvent(new CustomEvent('sglv:blocked-data-updated', {
                detail: { apps, source, fetchedAt: remoteFetchedAt }
            }));

            return { apps, source, fetchedAt: remoteFetchedAt };
        } catch (e) {
            state.blockedLoading = false;
            state.blockedError = e.message || 'Unknown error';
            console.warn('[SGLV] 锁区数据加载失败:', e);
            // v2.9.15: 失败入负缓存(仅当 force=false 时记录,避免用户主动刷新被吞)
            if (!force) negCacheSet(nsKey('blocked_neg'), e.message || String(e));
            throw e;
        }
    }

    /** 检查指定 appid 是否在锁区列表中 */
    function isBlockedApp(appid) {
        if (!state.blockedApps || !state.blockedApps.length) return false;
        const id = Number(appid);
        return state.blockedApps.some(a => a.appid === id);
    }

    SGLV_API.loadBlockedApps = loadBlockedApps;
    SGLV_API.isBlockedApp = isBlockedApp;
    SGLV_API.isBlockedLoaded = () => state.blockedLoaded;
    // v2.9.90: 暴露 fetchedAt 供收藏浮窗显示数据更新时间
    SGLV_API.getBlockedFetchedAt = () => {
        const cached = cacheGet('blockedApps');
        return (cached && cached.fetchedAt) ? cached.fetchedAt : '';
    };
    })();

    // ==================== 信息侧边栏 v2.0 (sgis) ====================
    // 与 steam-game-info-sidebar-1.0 同样的能力, 复用本脚本的 state.ownedGames + storage,
    // 实现"导航栏按钮 + 右侧三角触发器 + 共享 API Key / 家庭组数据"

    (function () {
        // v2.4.1: SGLV 子闭包导出的跨模块函数别名（SGLV_API 在外层作用域，SGLV 闭包完成后已填充）
        const buildPersonalTimeline = SGLV_API.buildPersonalTimeline;
        const buildFamilyTimeline = SGLV_API.buildFamilyTimeline;
        const fetchWishlistFromApi = SGLV_API.fetchWishlistFromApi;
        const openGlobalSettings = SGLV_API.openGlobalSettings;
        // v2.11.44 hotfix: getGameIconUrl 定义于上方主面板渲染子闭包（7718 行 IIFE），SGIS 兄弟闭包
        // 不可直接引用——裸引用抛 ReferenceError 被 renderProfile 外层 .catch 捕获，误报为
        // "用户档案获取失败: getGameIconUrl is not defined"（与 v2.11.38 xpPercent 同类作用域事故）。
        // 经 SGLV_API 桥接：主面板渲染子闭包求值时已填充该成员，SGIS 渲染必可用。
        const getGameIconUrl = SGLV_API.getGameIconUrl;

        // v2.3.26: 愿望单页面检测 — 跳过浮动按钮创建，避免与 Wishlist Exporter 侧边栏冲突
        const IS_WISHLIST_PAGE = /\/wishlist(new)?\//i.test(location.pathname);

        // 在所有 Steam 商店页面挂载侧边栏
        // v2.3.19: 统一页面上下文检测，区分 morelike/app/home 三种页面
        // 原正则未锚定开头，/recommended/morelike/app/3767850/ 会被 app 分支误匹配
        const PAGE_CTX = (function () {
            const path = location.pathname;
            // 1. 相似推荐页（本次改造重点）
            const moreLike = path.match(/^\/recommended\/morelike\/app\/(\d+)/);
            if (moreLike) {
                return { type: 'morelike', appId: moreLike[1], hasAppId: true,
                    hasSimilarGrid: !!document.querySelector('.similar_grid_ctn') };
            }
            // 2. 标准应用详情页（保持原行为）
            const app = path.match(/^\/(?:agecheck\/)?app\/(\d+)/);
            if (app) {
                return { type: 'app', appId: app[1], hasAppId: true,
                    hasSimilarGrid: !!document.querySelector('#steampeek, .similar_grid_ctn') };
            }
            // 3. 首页/社区（profile 模式）
            return { type: 'home', appId: '', hasAppId: false, hasSimilarGrid: false };
        })();
        const APP_ID = PAGE_CTX.appId;
        const HAS_APP_ID = PAGE_CTX.hasAppId;
        const IS_MORELIKE = PAGE_CTX.type === 'morelike';

        // v2.8.0: 新增 UI 组件样式（价格对比表 / 评测 / 跨区送礼推荐）
    // CSS 已提取到顶部: CSS_PRICE


        // v2.8.1: 家庭组入库加载体验优化 —— 进度条 + 游戏框架骨架屏（参考 steam-friend-manager 加载体验）
    // CSS 已提取到顶部: CSS_LOAD

    // ==================== v2.9.97: 紫青炫彩主题平衡 ====================
    // 设计目标：恢复原版紫蓝主色调 + 多彩语义 KPI，移除大面积金色造成的平淡感。
    // 金色仅保留用于：等级徽章、XP 进度条（原版设计即为金色）。
    // 紫色/靛蓝/青色作为主品牌色，KPI 卡片保留 t-blue/t-cyan/t-green/t-rose 语义色。
    // SGIS Hero 恢复背景图 + 紫色径向光晕 + 青色头像边框 + 紫蓝在线徽章。
    // CSS 已提取到顶部: CSS_THEME_PURPLE（v2.11.40 由主题层按用户主题动态注入）


        const SGIS = {
            appId: APP_ID,
            open: false,
            tab: HAS_APP_ID ? 'overview' : 'profile',
            overview: null,
            cards: null,
            cardsLoading: false,
            prices: null,
            pricesLoading: false,
            rateReady: false,
            medalTab: 'regular',
            achievements: null,
            achievementsLoading: false,
            globalAchievements: null,
            dynamics: null,
            dynamicsLoading: false,
            dynamicsMode: 'original',  // 'original' | 'ai'
            aiSummary: null,           // AI 翻译总结结果缓存
            aiSummaryLoading: false,
            aiSummaryError: null,        // AI 翻译总结错误信息
            historyPrices: null,
            historyPricesLoading: false,
            prediction: null,          // AI 价格预测结果
            predictionLoading: false,
            predictionError: null,
            familyShareSupported: null,
            // ---- v2.3.16: appdetails API 增强信息 (工坊/截图/分类/捆绑包等) ----
            appDetailsExtra: null,            // 结构化附加信息 { workshopSupported, categories, platforms, packages, screenshots, ... }
            appDetailsExtraLoading: false,
            // ---- v2.3.17: DLC 名称映射 (appid -> name), 异步获取 ----
            dlcNames: null,                   // { [appid]: { name, isFree } } 或 null
            dlcNamesLoading: false,
            ownersPlaytime: {},
            ownersPlaytimeFetching: false,
            // ---- v2.3.19: 相似游戏推荐 + 库存标记 + 类型扩展推荐 (morelike 页专用) ----
            similarGames: null,               // 从 DOM 采集的相似游戏数组 [{ appId, tagIds, href, capsule, nameSlug, priceText, isFree, status }]
            similarFilter: 'all',             // 'all' | 'unowned' | 'owned' | 'wishlist'
            similarSort: 'default',           // 'default' | 'priceAsc' | 'priceDesc' | 'name'
            similarDisplayLimit: 12,          // 默认展示前 12 个，点击"查看全部"展开
            similarExpanded: false,
            dynamicStore: null,               // GDynamicStore 缓存 { owned:Set, wishlist:Set, ignored:Set }
            dynamicStoreChecked: false,       // 是否已尝试读取 GDynamicStore
            // v2.3.29: dynamicstore/userdata API 缓存的 owned appids（GDynamicStore 不可用时的异步回退）
            dynamicStoreOwnedApps: null,      // Set<number> | null
            dynamicStoreFetching: false,      // 是否正在获取 dynamicstore/userdata
            tagRecs: null,                    // 标签扩展推荐 [{ tagId, tagName, appIds:[] }]
            tagRecsLoading: false,
            tagRecsError: null,
            activeTagId: null,                // 当前展开的标签 ID
            tagRecDisplayLimit: 12,           // 每个标签默认展示前 12 个
            // ---- v2.8.0: 评测标签页 ----
            reviews: null,                    // 评测数据 { summary, reviews[], query_summary }
            reviewsLoading: false,
            reviewsFilter: { rec: 'all', playtime: 'all', language: 'all', purchase: 'all', keyword: '', regexMode: false },
            reviewsExpanded: new Set(),       // 展开的评测 ID 集合
            // ---- v2.9.9: 价格图表/DRM 缓存 ----
            priceChartRange: 'all',           // 价格走势图时间范围 ('6m'|'1y'|'all')
            drmInfo: null,                    // DRM 检测结果缓存
            // ---- v2.9.10: gamestatus.info 破解状态 ----
            gameStatusInfo: null,             // 破解状态数据 { status, protections, groups, crackDate, isAAA, ... }
            gameStatusLoading: false,         // 是否正在加载
            profileFeaturesStatus: null,       // v2.9.93: 资料受限状态 { status, label, source }
            profileFeaturesLoading: false,     // v2.9.93: 是否正在异步获取
            // ---- v2.8.0: 跨区送礼推荐 ----
            giftRec: null,                    // 送礼推荐数据 { best, alternatives[], userRegion }
            giftRecLoading: false,
            // ---- 用户档案 (v2.3: 首页浮窗) ----
            profile: null,
            profileLoading: false,
            profileError: null,
            activity: null,
            activityLoading: false,
            // ---- v2.3.13: 动态标签子分类 (官方动态 / 个人入库 / 家庭组入库) ----
            activitySubTab: 'personal',      // v2.3.24: 默认个人入库动态 'personal' | 'family' | 'official'
            personalTimeline: null,          // 个人入库历史（仅本人的购买事件：owners 末位=购买者，家人购买的共拥游戏已排除，v2.11.43）
            personalTimelineLoading: false,
            personalTimelinePage: 1,         // v2.3.24: 个人入库分页页码（每页 100 条，滚动到底自动加载下一页）
            familyTimeline: null,            // 家庭组入库历史（含个人已拥有的共拥游戏，保留原始 rt_time_acquired，v2.11.42 不做许可页校准）
            familyTimelineLoading: false,
            familyTimelinePage: 1,           // v2.3.24: 家庭组入库分页页码（每页 100 条，滚动到底自动加载下一页）
            familyInfo: null,                // 家庭组基本信息缓存
            userBadges: null,
            userBadgesLoading: false,
            userBadgeMarkets: {},     // v2.3.1.1: 徽章市场数据缓存 (appId -> marketSummary)
            userAchievements: null,
            userAchievementsLoading: false,
            aiPersona: null,
            aiPersonaLoading: false,
            aiPersonaError: null,
            // ---- v2.3.8: 洞察标签页 (重构自原 userAchievements) ----
            insightData: null,              // 本地计算的洞察数据 (KPI/画像/维度)
            insightDataLoading: false,
            aiInsight: null,                // AI 深度分析结果 { oneLiner, sections: [{title, content}] }
            aiInsightLoading: false,
            aiInsightError: null,
            aiMarketInsight: null,          // AI 市场洞察结果 { summary, recommendations: [{name, action, reason}], topValue: [...] }
            aiMarketInsightLoading: false,
            aiMarketInsightError: null,
            // ---- v2.3.8: 社交标签页 (好友列表) ----
            friendsList: null,              // 完整好友数据 [{ steamid, personaname, avatar, personastate, gameextrainfo, friend_since, friend_days, vac_banned, ... }]
            friendsListLoading: false,
            friendsListError: null,
            friendsLevels: null,            // 好友等级 Map { steamid: level } (懒加载)
            friendsLevelsLoading: false,
            friendsLevelsProgress: 0,
            friendsLevelsTotal: 0,
            friendsBansLoading: false,        // v2.3.13: 封禁状态同步中
            friendsBansProgress: 0,
            friendsBansTotal: 0,
            friendsGameCounts: null,        // v2.3.24: 好友游戏数量 Map { steamid: { gc, tm, ts, priv? } } (懒加载, 12h 缓存)
            friendsGameCountsLoading: false,
            friendsGameCountsProgress: 0,
            friendsGameCountsTotal: 0,
            friendsFilter: 'all',           // 筛选: all / ingame / online / vac / new (v2.3.24 移除离线筛选)
            friendsSearch: '',              // 搜索关键词
            friendsSort: 'status',          // 排序: status / level / days / name
            // ---- v2.9.83: 概览页在线玩家数 + 评测摘要增强 ----
            currentPlayers: null,           // { count: number } 当前在线玩家数, null=未获取/超时
            currentPlayersLoading: false,
            // v2.9.112: 负缓存——失败/无数据/未上市后置 true，本页面会话内不再重试，
            // 避免概览页每次重渲染（评测/家庭时长/dynamicstore 异步完成都会触发）都重新请求造成 404 重试风暴
            currentPlayersUnavailable: false,
            reviewSummary: null,            // { totalPositive, totalNegative, totalReviews, reviewScore, reviewScoreDesc, recentPositive, recentNegative, recentReviews }
            reviewSummaryLoading: false,
            reviewSummaryUnavailable: false,

        };

        // ---- 共享数据访问层 (基于游戏库已有的 state + storage) ----
        function getCurrentGameInfo() {
            // 优先用实时 state; 没有则用持久化缓存
            const all = (state.ownedGames && state.ownedGames.length) ? state.ownedGames : storage.getCachedGames();
            const g = all.find(x => String(x.appid) === String(APP_ID));
            if (!g) {
                // v2.3.29: GetOwnedGames API 可能遗漏部分通过 CD key 激活的游戏（免费游戏未游玩、促销许可等）
                // 回退1: 页面 GDynamicStore.s_rgOwnedApps（零请求，Steam 商店客户端实时数据，最可靠）
                const ds = getDynamicStoreStatus();
                if (ds && ds.owned && ds.owned.has(Number(APP_ID))) {
                    const pageName = (document.getElementById('appHubAppName') || {}).textContent?.trim() || '';
                    return {
                        found: true,
                        name: pageName || `App ${APP_ID}`,
                        playtime: 0,
                        lastPlayed: 0,
                        acquiredTime: 0,
                        icon: '',
                        _source: 'dynamicstore',
                        isOwnedByMe: true,
                        isSharedOnly: false,
                        isFamilyLib: false,
                        owners: [],
                    };
                }
                // 回退2: dynamicstore/userdata API 缓存的 owned appids（异步获取后缓存）
                if (SGIS.dynamicStoreOwnedApps && SGIS.dynamicStoreOwnedApps.has(Number(APP_ID))) {
                    const pageName = (document.getElementById('appHubAppName') || {}).textContent?.trim() || '';
                    return {
                        found: true,
                        name: pageName || `App ${APP_ID}`,
                        playtime: 0,
                        lastPlayed: 0,
                        acquiredTime: 0,
                        icon: '',
                        _source: 'dynamicstore_api',
                        isOwnedByMe: true,
                        isSharedOnly: false,
                        isFamilyLib: false,
                        owners: [],
                    };
                }
                return { found: false };
            }

            const mySteamId = getActiveSteamId();
            const familyInfo = storage.getFamilyInfo() || {};
            const nameMap = familyInfo.steamIdtoName || {};
            const owners = g.owners || [];
            const isOwnedByMe = !owners.length || (mySteamId && owners.includes(mySteamId));
            const isSharedOnly = owners.length > 0 && !isOwnedByMe;

            return {
                found: true,
                name: g.name,
                playtime: g.playtime || 0,
                lastPlayed: g.lastPlayed || 0,
                acquiredTime: g.acquiredTime || 0,
                icon: g.icon || '',
                _source: g._source || 'cache',
                isOwnedByMe,
                isSharedOnly,
                isFamilyLib: owners.length > 0,
                owners: owners.map(sid => ({
                    steamId: sid,
                    name: nameMap[sid] || ('ID:' + String(sid).slice(-4)),
                    isMe: mySteamId && String(sid) === String(mySteamId),
                    playtime: SGIS.ownersPlaytime[sid] != null ? SGIS.ownersPlaytime[sid] : null,
                })),
            };
        }

        function formatAcquiredTime(ts) {
            if (!ts) return '—';
            try {
                const d = new Date(ts * 1000);
                return d.toLocaleDateString('zh-CN', { year: 'numeric', month: '2-digit', day: '2-digit' });
            } catch { return '—'; }
        }

        // v2.9.15: 相对时间（用于评测项显示）
        function formatRelativeDate(ts) {
            if (!ts) return '—';
            const t = ts * 1000;
            const diff = Date.now() - t;
            if (diff < 0) return new Date(t).toLocaleDateString('zh-CN');
            const min = Math.floor(diff / 60000);
            if (min < 1) return '刚刚';
            if (min < 60) return `${min} 分钟前`;
            const hr = Math.floor(min / 60);
            if (hr < 24) return `${hr} 小时前`;
            const day = Math.floor(hr / 24);
            if (day < 30) return `${day} 天前`;
            const mon = Math.floor(day / 30);
            if (mon < 12) return `${mon} 个月前`;
            const yr = Math.floor(day / 365);
            return `${yr} 年前`;
        }

        // ---- HTTP 工具（v2.9.54 优化：委托 SGLVCore 统一全脚本网络层）----
        // 委托目标(由 sglv-core.lib.js 提供,主脚本顶部 @require 已加载):
        //   sglvGmFetchRetry       = SGLVCore.gmFetchJson  (自动重试 + HTTP 状态码校验 + JSON 解析)
        //   sglvGmFetchTextRetry   = SGLVCore.gmFetchText  (自动重试 + 状态码校验,返回 raw text)
        //   C.concurrentPool       = SGLVCore.concurrentPool (429 降并发 + 指数退避)
        // 保留以下函数供 SGIS 既有调用方使用,内部委托 SGLVCore,行为兼容:
        //   - httpGet(url, opts)    → Promise<{status, responseText}>
        //   - fetchJson(url, opts)  → Promise<parsed>          (直接走 sglvGmFetchRetry,不再二次 parse)
        //   - fetchText(url, opts)  → Promise<string>         (直接走 sglvGmFetchTextRetry)
        //   - mapLimit(items, limit, mapper) → Promise<Array<value | reason>>
        //     契约:成功时 out[idx] = mapper 返回值,失败时 out[idx] = reason 对象(不抛,调用方走降级)
        // 收益:删 ~50 行重复代码;SGLVCore.gmFetchJson/Text 已带 2 次重试 + 状态码校验(v1.0.2 修复过同款 bug)
        function httpGet(url, opts) {
            return sglvGmFetchTextRetry(url, opts).then(text => ({ status: 200, responseText: text }));
        }
        function fetchJson(url, opts) { return sglvGmFetchRetry(url, opts); }
        function fetchText(url, opts) { return sglvGmFetchTextRetry(url, opts); }
        // 委托 SGLVCore.concurrentPool:包装 tasks + 还原"失败塞 reason"契约,调用方不变
        function mapLimit(items, limit, mapper) {
            const tasks = items.map((item, idx) => () => mapper(item, idx));
            return C.concurrentPool(tasks, limit).then(results =>
                results.map(r => r.status === 'fulfilled' ? r.value : r.reason)
            );
        }

        // ---- 汇率语义对照（v2.9.101 文档化：三套汇率表示，数据源单一事实来源） ----
        // 仓库内存在三种汇率表示语义。数据源已是单一事实来源（本脚本 refreshRates 优先委托
        // SGLVAppDetail.getRates 拉取，见下方 v2.9.54 注释），差异仅在表示格式：
        //   ① SGIS 表 C（GM 键 'sgis-rates'，getRates()）：「1 外币 = X CNY」，toCNY = amount * C[code]
        //   ② app-detail 表 B（SGLVAppDetail.getRates）：「1 CNY = X 外币」，toCNY = amount / B[code]
        //   ③ lib USD 枢纽表 U（SGLVCurrency.convert/aggregate 消费）：「1 USD = X 币种」，键为小写 apiCode
        // 互转公式：
        //   C→U: U[code] = C['USD'] / C[code]  （下方 getUsdRates 实现，lib 亦提供 CUR.sgisRatesToUsdRates）
        //   B→U: U[code] = B[code] / B['USD']  （lib CUR.cnyBaseRatesToUsdRates）
        //   C→B: B[code] = 1 / C[code]          （_convertToSgisRatesFormat 为其反向 B→C）
        // ---- 汇率 ----
        function getRates() { try { return GM_getValue('sgis-rates', null); } catch { return null; } }
        function getRatesTs() { try { return GM_getValue('sgis-rates-ts', 0); } catch { return 0; } }
        function setRates(r) {
            try { GM_setValue('sgis-rates', r); GM_setValue('sgis-rates-ts', Date.now()); } catch { /* ignore */ }
        }
        // v2.9.54 优化: refreshRates 优先委托 sglv-app-detail.getRates() (双源降级 + 1h 内存缓存)
        // 库未加载时降级到本地 AugmentedSteam / open.er-api 双源拉取
        // rates 表语义: SGIS 内部保持"1 外币 = X CNY"倒数形式 (与 toCNY 算法匹配),
        // 库返回的是"1 CNY = X 外币"原值形式, 故此转换
        function _convertToSgisRatesFormat(rates) {
            const out = { CNY: 1 };
            for (const [code, val] of Object.entries(rates || {})) {
                if (typeof val === 'number' && val > 0) out[code] = 1 / val;
            }
            return out;
        }
        async function refreshRates() {
            if (Date.now() - getRatesTs() < 3600000 && getRates()) { SGIS.rateReady = true; return; }
            // 优先委托 sglv-app-detail 拉取 (双源降级 + 自动重试 + 状态码校验)
            try {
                const A = unsafeWindow.SGLVAppDetail;
                if (A && typeof A.getRates === 'function') {
                    const info = await A.getRates();
                    if (info && info.ready && info.rates) {
                        setRates(_convertToSgisRatesFormat(info.rates));
                        SGIS.rateReady = true;
                        return;
                    }
                }
            } catch (e) { /* ignore - fallback below */ }
            // 降级路径 1: AugmentedSteam 直拉
            try {
                const r = await httpGet('https://api.augmentedsteam.com/rates/v1', { timeout: 10000 });
                const data = JSON.parse(safeResponseText(r));
                if (data?.data?.CNY) {
                    const cny = data.data.CNY;
                    const rates = {};
                    for (const [code, val] of Object.entries(data.data)) {
                        if (typeof val === 'number' && val > 0) rates[code] = cny / val;
                    }
                    setRates(rates); SGIS.rateReady = true; return;
                }
            } catch (e) { /* ignore */ }
            // 降级路径 2: open.er-api 兜底
            try {
                const r = await httpGet('https://open.er-api.com/v6/latest/CNY', { timeout: 10000 });
                const data = JSON.parse(safeResponseText(r));
                if (data?.rates) {
                    const rates = { CNY: 1 };
                    for (const [code, val] of Object.entries(data.rates)) {
                        if (typeof val === 'number' && val > 0) rates[code] = 1 / val;
                    }
                    setRates(rates); SGIS.rateReady = true;
                }
            } catch (e) { /* ignore */ }
        }
        function toCNY(amount, currency) {
            if (currency === 'CNY' || currency === 'RMB') return amount;
            const rates = getRates();
            if (!rates || !rates[currency]) return null;
            return amount * rates[currency];
        }

        // v2.9.101: 汇率桥接层 —— 统一折算管道（三套汇率语义收敛第一步）
        // SGIS 表('sgis-rates')为事实来源,语义「1 外币 = X CNY」;
        // USD 枢纽表 U[code] = C['USD'] / C[code](键转小写 apiCode),供 CUR.convert 消费。
        let _usdRatesMemo = null, _usdRatesMemoTs = -1;
        function getUsdRates() {
            // v2.9.103: rateReady 门控 — 汇率过期(>1h)/刷新失败时不派生枢纽表,避免愿望单
            // 聚合路径用陈旧汇率折算(原实现只依赖 getRates 存在性,rateReady=false 时仍会折算)。
            // 门控必须放在 memo 之前,防止 rateReady=false 期间把 null 缓存进 memo 后无法恢复。
            if (!SGIS.rateReady) return null;
            // 与 getRatesTs() 同 ts 直接返回 memo（汇率表按 ts 版本失效）
            const ts = getRatesTs();
            if (_usdRatesMemoTs === ts) return _usdRatesMemo;
            _usdRatesMemoTs = ts;
            // v2.9.103: 派生逻辑委托 lib CUR.sgisRatesToUsdRates,消除主脚本与 lib 的双份实现漂移
            // (语义与旧手写循环完全一致:U[code]=C['USD']/C[code],键转小写,缺 USD/非正数 → null)
            _usdRatesMemo = hasSglvCurrency ? CUR.sgisRatesToUsdRates(getRates()) : null;
            return _usdRatesMemo;
        }
        function convertToCNY(amount, code) {
            if (code === 'CNY' || code === 'RMB') return amount;
            if (!SGIS.rateReady) return null;
            if (hasSglvCurrency) {
                const usdRates = getUsdRates();
                if (usdRates) {
                    const v = CUR.convert(amount, code, 'CNY', usdRates);
                    if (Number.isFinite(v)) return v;
                    // convert 缺项返回 NaN → 落入下方 toCNY 降级（缺汇率返回 null,与原语义一致）
                }
            }
            // 软降级:lib 未加载/派生失败时沿用旧直乘管道（toCNY 保留不删）
            return toCNY(amount, code);
        }

        // ---- 卡牌价格(整合 card-prices 核心) ----
        const MARKET_SEARCH_API = 'https://steamcommunity.com/market/search/render/';
        const MARKET_LISTING_PAGE = 'https://steamcommunity.com/market/listings/753/';
        const BUY_ORDER_CONCURRENCY = 3;

        // v2.9.32: 可变发行商费率手续费计算 (与 steam-badges-card-view 保持一致)
        // 替代 v2.9.31 的固定费率 calcfee, 从市场 API 读取每张卡的实际发行商费率
        const STEAM_TX_FEE_PERCENT = 0.05;        // Steam 交易手续费 5%
        const DEFAULT_PUBLISHER_FEE_PERCENT = 0.10; // 默认发行商手续费 10%

        // 从市场搜索结果读取发行商手续费比例
        // Steam 市场 API 的 asset_description.owner_actions 中包含 publisherFeePercentDbl 参数
        function _readPublisherFeeFromItem(item) {
            const desc = item && item.asset_description ? item.asset_description : {};
            const ownerActions = desc.owner_actions || [];
            for (let i = 0; i < ownerActions.length; i++) {
                const link = ownerActions[i].link || '';
                const m = link.match(/publisherFeePercentDbl=([0-9.]+)/);
                if (m) { const v = Number(m[1]); if (Number.isFinite(v) && v >= 0) return v / 100; }
            }
            return DEFAULT_PUBLISHER_FEE_PERCENT;
        }

        // 计算单笔费用 (Steam 5% + 发行商 fee, 每项最低 1 分)
        function _calcFees(receivedAmount, publisherFee, steamFeePercent) {
            const steamFee = Math.max(Math.floor(receivedAmount * steamFeePercent), 1);
            const publisherFeeAmount = publisherFee > 0 ? Math.max(Math.floor(receivedAmount * publisherFee), 1) : 0;
            return {
                steamFee, publisherFee: publisherFeeAmount,
                fees: steamFee + publisherFeeAmount,
                amount: receivedAmount + steamFee + publisherFeeAmount,
            };
        }

        // 计算卖家到手价 (扣除 Steam 交易手续费 + 发行商手续费)
        // 迭代逼近法与 Steam 官方算法一致, 支持可变发行商费率
        function _calculateSellerReceives(buyerPaysCents, publisherFeePercent) {
            const amount = Math.round(Number(buyerPaysCents));
            if (!Number.isFinite(amount) || amount <= 0) return null;
            publisherFeePercent = publisherFeePercent == null ? DEFAULT_PUBLISHER_FEE_PERCENT : publisherFeePercent;

            const steamFeePercent = STEAM_TX_FEE_PERCENT;
            let estimatedReceived = parseInt(amount / (steamFeePercent + publisherFeePercent + 1), 10);
            if (!Number.isFinite(estimatedReceived)) estimatedReceived = amount;
            estimatedReceived = Math.max(1, estimatedReceived);

            let iterations = 0, everUndershot = false;
            let fees = _calcFees(estimatedReceived, publisherFeePercent, steamFeePercent);
            while (fees.amount !== amount && iterations < 100) {
                if (fees.amount > amount) {
                    if (everUndershot) {
                        fees = _calcFees(estimatedReceived - 1, publisherFeePercent, steamFeePercent);
                        fees.steamFee += amount - fees.amount;
                        fees.fees += amount - fees.amount;
                        fees.amount = amount;
                        break;
                    }
                    estimatedReceived--;
                } else {
                    everUndershot = true;
                    estimatedReceived++;
                }
                estimatedReceived = Math.max(1, estimatedReceived);
                fees = _calcFees(estimatedReceived, publisherFeePercent, steamFeePercent);
                iterations++;
            }
            return amount > fees.fees ? amount - fees.fees : 1;
        }

        async function fetchCardGroup(appId, foil) {
            const cards = [];
            let total = Infinity, start = 0, count = 100;
            while (start < total && cards.length < 200) {
                const params = new URLSearchParams();
                params.set('query', ''); params.set('start', String(start)); params.set('count', String(count));
                params.set('search_descriptions', '0'); params.set('sort_column', 'name'); params.set('sort_dir', 'asc');
                params.set('appid', '753'); params.set('norender', '1');
                params.append('category_753_Game[]', 'tag_app_' + appId);
                params.append('category_753_item_class[]', 'tag_item_class_2');
                params.append('category_753_cardborder[]', foil ? 'tag_cardborder_1' : 'tag_cardborder_0');
                const data = await fetchJson(MARKET_SEARCH_API + '?' + params.toString(), { timeout: 12000 });
                if (data?.success === false) throw new Error('Steam 市场返回失败');
                const results = Array.isArray(data?.results) ? data.results : [];
                total = Number.isFinite(Number(data?.total_count)) ? Number(data.total_count) : results.length;
                for (const item of results) {
                    const desc = item.asset_description || {};
                    const hashName = String(item.hash_name || desc.market_hash_name || '').trim();
                    if (!hashName) continue;
                    // sell_price 单位是 用户的币种最小单位 (分/cent), 已经是 sell_price_text 的数值形式
                    // 例如 CNY: sell_price=6 表示 6 分 = ¥0.06, sell_price_text="¥0.06"
                    // 保留原始数值, 由显示层决定如何格式化
                    const sellPrice = Number.isFinite(Number(item.sell_price)) ? Number(item.sell_price) : null;
                    // v2.9.32: 可变发行商费率 — 从市场 API 读取每张卡的实际发行商费率
                    // 不同游戏的发行商费率可能不同 (默认 10%, 部分游戏为 5% 或其他)
                    const publisherFeePercent = _readPublisherFeeFromItem(item);
                    // v2.9.32: netPrice 用可变费率精确计算 (_calculateSellerReceives 迭代逼近法)
                    // 相比旧公式 sellPrice * 0.95 * 0.9, 低价卡牌 (如 3 分) 误差可从 1+ 分降至 0
                    const netPrice = sellPrice != null ? _calculateSellerReceives(sellPrice, publisherFeePercent) : null;
                    // 卡牌图片 URL (与 steam-store-card-prices 保持一致)
                    const iconPath = desc.icon_url_large || desc.icon_url || '';
                    const iconUrl = iconPath ? `https://community.fastly.steamstatic.com/economy/image/${iconPath}/64fx64f` : '';
                    cards.push({
                        foil,
                        name: String(item.name || desc.market_name || hashName).trim(),
                        hashName,
                        classId: String(desc.classid || '').trim(),
                        type: String(desc.type || '').trim(),
                        listings: parseInt(item.sell_listings, 10) || 0,
                        sellPrice, netPrice,
                        publisherFeePercent,
                        sellPriceText: String(item.sell_price_text || '').trim(),
                        salePriceText: String(item.sale_price_text || '').trim(),
                        iconUrl,
                        marketUrl: MARKET_LISTING_PAGE + encodeURIComponent(hashName),
                    });
                }
                if (results.length < count) break;
                start += count;
            }
            return cards;
        }
        async function enrichBuyOrder(card) {
            try {
                const html = await fetchText(card.marketUrl, { timeout: 8000 });
                // 求购价单位也是最小单位 (分)
                const m1 = html.match(/"amtMaxBuyOrder"\s*:\s*(\d+)/);
                const m2 = html.match(/"cBuyOrders"\s*:\s*(\d+)/);
                return Object.assign({}, card, {
                    buyPrice: m1 ? parseInt(m1[1], 10) : null,
                    buyOrderCount: m2 ? parseInt(m2[1], 10) : 0,
                });
            } catch (e) {
                return Object.assign({}, card, { buyPrice: null, buyOrderCount: 0, buyError: e.message });
            }
        }
        // 最小单位 -> 主单位 (分 -> 元)
        function toMajorUnit(minor) {
            return Number.isFinite(minor) ? minor / 100 : null;
        }
        async function fetchCardPrices(appId) {
            const result = { regular: [], foil: [], regularQueried: false, foilQueried: false };
            await Promise.all([
                fetchCardGroup(appId, false).then(c => { result.regular = c; result.regularQueried = true; }).catch(e => { result.regularError = e.message; }),
                fetchCardGroup(appId, true).then(c => { result.foil = c; result.foilQueried = true; }).catch(e => { result.foilError = e.message; }),
            ]);
            const tasks = [];
            if (result.regular.length) tasks.push(mapLimit(result.regular, BUY_ORDER_CONCURRENCY, c => enrichBuyOrder(c)));
            if (result.foil.length) tasks.push(mapLimit(result.foil, BUY_ORDER_CONCURRENCY, c => enrichBuyOrder(c)));
            await Promise.all(tasks);
            return result;
        }

        // ---- v2.3.1.1: 徽章市场数据轻量抓取 (用于价值分析仪表板) ----
        // 只抓 1 页(最多 100 张), 不查 buy orders, 适合批量调用
        async function fetchCardMarketLight(appId) {
            const cacheKey = 'sgis_badge_market_' + appId;
            const cached = cacheGet(cacheKey);
            if (cached) return cached;
            const params = new URLSearchParams();
            params.set('query', ''); params.set('start', '0'); params.set('count', '100');
            params.set('search_descriptions', '0'); params.set('sort_column', 'name'); params.set('sort_dir', 'asc');
            params.set('appid', '753'); params.set('norender', '1');
            params.append('category_753_Game[]', 'tag_app_' + appId);
            params.append('category_753_item_class[]', 'tag_item_class_2');
            params.append('category_753_cardborder[]', 'tag_cardborder_0'); // 只要普通卡
            const url = MARKET_SEARCH_API + '?' + params.toString();
            const data = await fetchJson(url, { timeout: 10000 });
            const results = Array.isArray(data?.results) ? data.results : [];
            let totalCost = 0, priceCount = 0;
            const seenHash = new Set();
            const cards = [];
            for (const item of results) {
                const desc = item.asset_description || {};
                const hashName = String(item.hash_name || desc.market_hash_name || '').trim();
                if (!hashName || seenHash.has(hashName)) continue;
                seenHash.add(hashName);
                const sellPrice = Number.isFinite(Number(item.sell_price)) ? Number(item.sell_price) : null;
                if (sellPrice != null) { totalCost += sellPrice; priceCount++; }
                // v2.9.32: 读取可变发行商费率 (与 fetchCardGroup 保持一致)
                const publisherFeePercent = _readPublisherFeeFromItem(item);
                const iconPath = desc.icon_url_large || desc.icon_url || '';
                const iconUrl = iconPath ? `https://community.fastly.steamstatic.com/economy/image/${iconPath}/64fx64f` : '';
                cards.push({
                    name: String(item.name || desc.market_name || hashName).replace(/\s*\(Foil\)\s*$/i, '').trim(),
                    hashName, iconUrl, sellPrice, publisherFeePercent,
                    sellPriceText: String(item.sell_price_text || '').trim(),
                    listings: parseInt(item.sell_listings, 10) || 0,
                    marketUrl: MARKET_LISTING_PAGE + encodeURIComponent(hashName),
                });
            }
            const summary = {
                appId,
                cards,
                cardCount: cards.length,
                totalCost,        // 单位: 分 (cent)
                priceCount,
                avgPrice: priceCount > 0 ? Math.round(totalCost / priceCount) : 0,
                // v2.9.31: 增加中位数和忽略最高价统计 (借鉴 Steam Get Trading Card Info 脚本)
                medianPrice: 0,    // 中位数价格 (分), 抗极端高价干扰
                avgNoMax: 0,       // 忽略最高价后的均价 (分)
                netIncome: 0,      // 预计税后总收入 (分), 使用 _calculateSellerReceives 可变费率计算
                updatedAt: Date.now(),
            };
            // v2.9.31: 计算中位数和忽略最高价均价
            if (priceCount > 0) {
                const prices = cards.filter(c => c.sellPrice != null).map(c => c.sellPrice).sort((a, b) => a - b);
                if (prices.length > 0) {
                    // 中位数: 偶数个取中间两个的平均值
                    const mid = Math.floor(prices.length / 2);
                    summary.medianPrice = prices.length % 2 !== 0
                        ? prices[mid]
                        : Math.round((prices[mid - 1] + prices[mid]) / 2);
                    // 忽略最高价均价 (至少 2 张卡才有意义)
                    if (prices.length > 1) {
                        const sumNoMax = prices.slice(0, -1).reduce((s, p) => s + p, 0);
                        summary.avgNoMax = Math.round(sumNoMax / (prices.length - 1));
                    } else {
                        summary.avgNoMax = summary.avgPrice;
                    }
                    // v2.9.32: 预计税后总收入: 均价 * ceil(卡牌数/2) * 可变费率系数
                    // Steam 每套卡牌掉落 ceil(卡牌数/2) 张, 合成徽章需集齐全套
                    // 汇总层面使用默认发行商费率 (与 steam-badges-card-view 保持一致)
                    const dropCount = Math.ceil(cards.length / 2);
                    const grossIncome = summary.avgPrice * dropCount;
                    summary.netIncome = _calculateSellerReceives(grossIncome, DEFAULT_PUBLISHER_FEE_PERCENT) || 0;
                }
            }
            cacheSet(cacheKey, summary, 10 * 60 * 1000); // 10 分钟缓存
            return summary;
        }

        // 格式化分(cent) -> 本地化货币字符串
        function formatMarketPrice(cents) {
            if (cents == null) return '—';
            try {
                // 尝试从页面抓取钱包货币
                const m = document.cookie.match(/steamCountry=(\w{2})/) || [];
                const cc = (m[1] || 'CN').toLowerCase();
                const symbols = { cn: '¥', us: '$', eu: '€', uk: '£', jp: '¥', kr: '₩', ru: '₽' };
                const symbol = symbols[cc] || '¥';
                return symbol + (cents / 100).toFixed(2);
            } catch (e) { return '¥' + (cents / 100).toFixed(2); }
        }

        // ---- v2.3.1.1: 价值分析引擎 (参考 SBC Pro) ----
        const BADGE_VALUE_WEIGHTS = {
            xp: 0.25,
            level: 0.20,
            cardPrice: 0.30,
            completionBonus: 0.15,
            dropBonus: 0.10,
        };

        // 计算徽章价值评分
        // badges: enriched badges (with _gameName), markets: { appId: marketSummary }
        function computeBadgeValueScores(badges, markets) {
            const scores = {};
            const gameBadges = badges.filter(b => b.appid > 0);
            if (gameBadges.length === 0) return scores;
            const maxXp = Math.max(...gameBadges.map(b => b.xp || 0), 1);
            gameBadges.forEach(badge => {
                const appId = String(badge.appid);
                const xpScore = (badge.xp || 0) / maxXp;
                // v2.3.6: 用 SteamCardExchange API 的真实 maxLevel 计算等级进度
                const realMaxLevel = badge._maxLevel || getCardDbMaxLevel(badge.appid) || 5;
                const levelScore = realMaxLevel > 1 ? ((badge.level || 1) - 1) / (realMaxLevel - 1) : 0;
                // 卡价评分: 平均卡价越低, 评分越高 (说明这套卡便宜)
                const marketData = markets[appId];
                let cardPriceScore = 0;
                if (marketData && marketData.avgPrice > 0) {
                    cardPriceScore = Math.max(0, 1 - (marketData.avgPrice / 50000)); // 5 元 = 50000 分为中等
                }
                // 完成度: 1 表示已合成, 0 表示未开始
                const completionBonus = badge.completion_time ? 1 : 0;
                // v2.3.6: 用真实 maxLevel 替代硬编码 5
                const dropBonus = Math.min(1, (badge.level || 1) / realMaxLevel);
                const w = BADGE_VALUE_WEIGHTS;
                const score = Math.round(
                    (w.xp * xpScore + w.level * levelScore +
                    w.cardPrice * cardPriceScore + w.completionBonus * completionBonus +
                    w.dropBonus * dropBonus) * 100
                );
                scores[appId] = {
                    score, appId,
                    gameName: badge._gameName || '',
                    level: badge.level || 1,
                    maxLevel: realMaxLevel, // v2.3.6: 游戏最高可达等级
                    xp: badge.xp || 0,
                    completed: !!badge.completion_time,
                    marketData,
                    breakdown: {
                        xp: Math.round(xpScore * 100),
                        level: Math.round(levelScore * 100),
                        cardPrice: Math.round(cardPriceScore * 100),
                        completion: Math.round(completionBonus * 100),
                        level_max: Math.round(dropBonus * 100),
                    },
                };
            });
            return scores;
        }

        // 获取高价值徽章 (Top N)
        function getTopValueBadges(scores, n) {
            n = n || 6;
            return Object.values(scores).sort((a, b) => b.score - a.score).slice(0, n);
        }

        // 等级分布
        function getBadgeLevelDistribution(badges) {
            const dist = { 1: 0, 2: 0, 3: 0, 4: 0, 5: 0 };
            badges.filter(b => b.appid > 0).forEach(b => {
                const lv = Math.min(5, Math.max(1, b.level || 1));
                dist[lv] = (dist[lv] || 0) + 1;
            });
            return dist;
        }

        // 抓取徽章市场数据 (异步, 限制并发)
        async function fetchBadgeMarkets(appIds, opts) {
            opts = opts || {};
            const concurrency = opts.concurrency || 3;
            const maxApps = opts.maxApps || 20;
            const targets = appIds.slice(0, maxApps);
            const results = {};
            for (let i = 0; i < targets.length; i += concurrency) {
                const batch = targets.slice(i, i + concurrency);
                await Promise.all(batch.map(async (appId) => {
                    try {
                        results[String(appId)] = await fetchCardMarketLight(appId);
                    } catch (e) {
                        results[String(appId)] = { appId, cardCount: 0, totalCost: 0, avgPrice: 0, cards: [], error: e.message };
                    }
                }));
                if (i + concurrency < targets.length) {
                    await new Promise(r => setTimeout(r, 500));
                }
            }
            return results;
        }

        // ---- 多地区价格(整合 game-prices-tools 核心) ----
        // 旗帜图用 flagcdn.com (无 key, PNG 24x18), 欧元区用 eu.png
        function flagUrl(code) {
            const cc = String(code || '').toLowerCase();
            if (cc === 'eu') return 'https://flagcdn.com/w40/eu.png';
            return `https://flagcdn.com/w40/${cc}.png`;
        }
        const REGIONS = [
            { code: 'CN', name: '中国', currency: 'CNY' },
            { code: 'US', name: '美国', currency: 'USD' },
            { code: 'AR', name: '阿根廷', currency: 'ARS' },
            { code: 'TR', name: '土耳其', currency: 'TRY' },
            { code: 'KZ', name: '哈萨克斯坦', currency: 'KZT' },
            { code: 'UA', name: '乌克兰', currency: 'UAH' },
            { code: 'IN', name: '印度', currency: 'INR' },
            { code: 'BR', name: '巴西', currency: 'BRL' },
            { code: 'CL', name: '智利', currency: 'CLP' },
            { code: 'CO', name: '哥伦比亚', currency: 'COP' },
            { code: 'PL', name: '波兰', currency: 'PLN' },
            { code: 'MX', name: '墨西哥', currency: 'MXN' },
            { code: 'RU', name: '俄罗斯', currency: 'RUB' },
            { code: 'JP', name: '日本', currency: 'JPY' },
            { code: 'KR', name: '韩国', currency: 'KRW' },
            { code: 'GB', name: '英国', currency: 'GBP' },
            { code: 'EU', name: '欧元区', currency: 'EUR' },
        ];
        const PRIORITY_REGIONS = ['CN', 'US', 'TR', 'AR', 'RU', 'IN', 'BR', 'UA', 'KZ'];
        // v2.9.79: ITAD 增强模式扩展区域 (15+ 区域)
        // v2.9.82: 移除 'EU' (非有效 ISO 3166-1 alpha-2 国家代码, 导致 ITAD API HTTP 400)
        const EXTENDED_REGIONS = ['CN', 'US', 'TR', 'AR', 'RU', 'IN', 'BR', 'UA', 'KZ', 'CL', 'CO', 'PL', 'MX', 'JP', 'KR', 'GB'];

        // Steam 官方 API (在已登录 session 下可能忽略 cc= 参数, 用作兜底)
        async function fetchSteamRegionPrice(appId, countryCode) {
            try {
                // 加 cache-buster 减少 Steam 缓存干扰
                const url = `https://store.steampowered.com/api/appdetails?appids=${appId}&cc=${countryCode}&l=english&_=${Date.now()}`;
                const data = await fetchJson(url, { timeout: 12000 });
                if (data[appId] && data[appId].success) {
                    const g = data[appId].data;
                    if (g.is_free) return { success: true, data: { region: countryCode, price: 0, currency: 'FREE', discount: 0, initial: 0, source: 'steam' } };
                    if (g.price_overview) {
                        const actualCurrency = g.price_overview.currency;
                        // v2.3.7: 检测币种不匹配 — Steam API 对登录用户可能忽略 cc= 参数,
                        // 返回用户实际所在地区的价格(如请求 CN 但返回 INR), 这种数据是错误的, 应标记为失败
                        const expectedRegion = REGIONS.find(r => r.code === countryCode);
                        if (expectedRegion && expectedRegion.currency && expectedRegion.currency !== actualCurrency) {
                            return { success: false, error: `币种不匹配(期望${expectedRegion.currency}, 实际${actualCurrency}, 疑似Steam返回用户本区数据)` };
                        }
                        return { success: true, data: {
                            region: countryCode,
                            price: g.price_overview.final / 100,
                            currency: actualCurrency,
                            discount: g.price_overview.discount_percent || 0,
                            initial: g.price_overview.initial / 100,
                            source: 'steam',
                        }};
                    }
                }
                return { success: false, error: '无价格数据' };
            } catch (e) { return { success: false, error: e.message }; }
        }

        // AugmentedSteam API (按 country 返回该地区价格, 不受用户登录影响, 首选)
        async function fetchAugRegionPrice(appId, countryCode) {
            try {
                const data = await sglvGmFetchRetry('https://api.augmentedsteam.com/prices/v2', {
                    method: 'POST', timeout: 12000,
                    headers: { 'Content-Type': 'application/json' },
                    data: JSON.stringify({
                        country: countryCode,
                        apps: [parseInt(appId, 10)],
                        subs: [],
                        bundles: [],
                        voucher: true,
                        shops: [],
                    }),
                });
                const key = `app/${appId}`;
                const aug = data?.prices?.[key];
                if (!aug?.current?.price) return { success: false, error: 'Aug 无数据' };
                const cur = aug.current;
                const cur2 = cur.price;
                // v2.9.102: 期望币种防脏检查 —— Aug 返回币种与 REGIONS 期望币种不匹配时视为脏数据(该次抓取失败),
                // 对齐函数既有失败返回形态;FREE/未知地区不受影响
                const _expCur = (REGIONS.find(r => r.code === countryCode) || {}).currency;
                if (_expCur && cur2.currency && cur2.currency !== _expCur) {
                    // v2.9.103: 记录被拒绝的脏数据,便于观察 Aug 上游币种口径变化(如某地区切换官方币种)
                    console.debug(`[SGLV] Aug 币种不匹配 ${countryCode}: 期望 ${_expCur}, 实际 ${cur2.currency}, 降级 Steam 兜底`);
                    return { success: false, error: `Aug 币种不匹配(期望${_expCur}, 实际${cur2.currency})` };
                }
                const regular = cur.regular || cur2;
                const discount = (regular.amount > cur2.amount)
                    ? Math.round((1 - cur2.amount / regular.amount) * 100)
                    : 0;
                return { success: true, data: {
                    region: countryCode,
                    price: cur2.amount,
                    currency: cur2.currency,
                    discount,
                    initial: regular.amount,
                    source: 'aug',
                }};
            } catch (e) { return { success: false, error: 'Aug: ' + e.message }; }
        }

        // 单个地区价格 (Aug 优先 -> Steam 兜底)
        async function fetchOneRegionPrice(appId, countryCode) {
            const aug = await fetchAugRegionPrice(appId, countryCode);
            if (aug.success) return aug;
            return await fetchSteamRegionPrice(appId, countryCode);
        }

        // v2.8.0: Steam API 限速器（"预留位"模式）
        // 在 sleep 前更新 lastRequestTime，防止并发 worker 竞态导致请求间距不足
        let _steamApiLastReq = 0;
        const STEAM_API_MIN_INTERVAL = 1000; // 请求间隔 1 秒
        async function steamApiRateLimit() {
            const now = Date.now();
            const wait = STEAM_API_MIN_INTERVAL - (now - _steamApiLastReq);
            // 预留位：先更新时间戳再 sleep，后续并发的 worker 看到的是已预留的时间
            _steamApiLastReq = now + Math.max(0, wait);
            if (wait > 0) await new Promise(r => setTimeout(r, wait));
        }

        // v2.8.0: 带限速的单地区价格获取（用于 9 区并发对比，3 worker + 1s 间隔）
        async function fetchOneRegionPriceRateLimited(appId, countryCode) {
            await steamApiRateLimit();
            return await fetchOneRegionPrice(appId, countryCode);
        }

        // 多地区价格: 并发获取, 去重 (Steam 官方 API 对登录用户会返回相同的国家价格)
        // v2.8.0: 改用 3 个并发 worker + 1s 请求间隔（预留位限速模式）
        async function fetchMultiRegionPrices(appId) {
            const results = await mapLimit(PRIORITY_REGIONS, 3, r => fetchOneRegionPriceRateLimited(appId, r));
            const prices = [];
            const failed = [];
            const seenKey = new Set();
            // 第一次扫描: 收集成功的结果, 按 "币种 + 金额" 去重
            const successList = [];
            results.forEach((r, i) => {
                if (r.success) successList.push({ data: r.data, idx: i });
                else failed.push({ region: PRIORITY_REGIONS[i], error: r.error });
            });
            // 检测是否所有结果都"看起来一样" (币种 + 价格一致), 这种情况说明 API 被缓存, 全部失败
            const allSameCurrency = successList.length > 1
                && successList.every(s => s.data.currency === successList[0].data.currency)
                && successList.every(s => Math.abs(s.data.price - successList[0].data.price) < 0.01);
            if (allSameCurrency && successList.length > 1) {
                // 全部当失败处理
                successList.forEach(s => failed.push({ region: PRIORITY_REGIONS[s.idx], error: '区域数据相同(疑似被缓存)' }));
            } else {
                successList.forEach(s => {
                    const k = `${s.data.currency}:${Number(s.data.price).toFixed(2)}`;
                    if (!seenKey.has(k)) {
                        seenKey.add(k);
                        prices.push(s.data);
                    } else {
                        // 重复价格 -> 视为失败
                        failed.push({ region: PRIORITY_REGIONS[s.idx], error: '与已有地区价格重复' });
                    }
                });
            }
            return { prices, failed };
        }

        // ---- 图标 v2.9.15: 重新设计精致 SVG 库 ----
        // 设计规范：统一 stroke-width 1.8 / currentColor / 圆角连接 / 0.1-0.18 透明填充做"水彩"层次
        // viewBox 固定 0 0 24 24，14px 渲染下细节清晰
        const _S = 'viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"';
        const SGIS_ICONS = {
            // ===== 导航 tab 图标（重新设计，6 款核心）=====
            // 概览 - 4 块仪表板 + 中心装饰点
            overview: `<svg class="sgis-svg" ${_S}>
                <rect x="3" y="3" width="8" height="8" rx="2" fill="currentColor" fill-opacity="0.12"/>
                <rect x="13" y="3" width="8" height="5" rx="2" fill="currentColor" fill-opacity="0.08"/>
                <rect x="13" y="10" width="8" height="11" rx="2" fill="currentColor" fill-opacity="0.08"/>
                <rect x="3" y="13" width="8" height="8" rx="2" fill="currentColor" fill-opacity="0.12"/>
            </svg>`,
            // 勋章 - 六角星 + 双飘带
            medal: `<svg class="sgis-svg" ${_S}>
                <path d="M7 3h10" opacity="0.6"/>
                <path d="M9 3l3 6 3-6" fill="currentColor" fill-opacity="0.18"/>
                <circle cx="12" cy="15" r="6" fill="currentColor" fill-opacity="0.15"/>
                <circle cx="12" cy="15" r="6"/>
                <circle cx="12" cy="15" r="2.2" fill="currentColor"/>
                <path d="M8.5 19L7 22l4-2"/>
                <path d="M15.5 19L17 22l-4-2"/>
            </svg>`,
            // 价格 - 价签 + $ 标志
            price: `<svg class="sgis-svg" ${_S}>
                <path d="M20.59 13.41l-7.17 7.17a2 2 0 0 1-2.83 0L2 12V2h10l8.59 8.59a2 2 0 0 1 0 2.82z" fill="currentColor" fill-opacity="0.12"/>
                <circle cx="7.5" cy="7.5" r="1.2" fill="currentColor"/>
            </svg>`,
            // 评测 - 聊天气泡 + 引号
            review: `<svg class="sgis-svg" ${_S}>
                <path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z" fill="currentColor" fill-opacity="0.12"/>
                <path d="M7.5 8.5c0-.8.7-1.5 1.5-1.5"/>
                <path d="M7.5 8.5v2c0 .8.7 1.5 1.5 1.5h.5"/>
                <path d="M13 8.5c0-.8.7-1.5 1.5-1.5"/>
                <path d="M13 8.5v2c0 .8.7 1.5 1.5 1.5h.5"/>
            </svg>`,
            // 成就 - 奖杯 + 双手 + 底座
            trophy: `<svg class="sgis-svg" ${_S}>
                <path d="M7 4h10v6a5 5 0 0 1-10 0z" fill="currentColor" fill-opacity="0.18"/>
                <path d="M7 6H4.5a2.5 2.5 0 0 0 0 5H7"/>
                <path d="M17 6h2.5a2.5 2.5 0 0 1 0 5H17"/>
                <path d="M10 15.5V17c0 .6-.5 1-1 1.2-1.2.5-2 2-2 3.8"/>
                <path d="M14 15.5V17c0 .6.5 1 1 1.2 1.2.5 2 2 2 3.8"/>
                <line x1="8" y1="22" x2="16" y2="22"/>
                <path d="M12 4.5l-.8-1.5M12 4.5l.8-1.5" stroke-width="1.2"/>
            </svg>`,
            // 动态 - 喇叭 + 声波
            activity: `<svg class="sgis-svg" ${_S}>
                <path d="M3.5 10.5l17-4.5v12L3.5 13.5z" fill="currentColor" fill-opacity="0.18"/>
                <path d="M11 16.5a2.5 2.5 0 1 1-5-1"/>
                <path d="M19 9.5v5" opacity="0.5"/>
                <path d="M21 8v8" opacity="0.3"/>
            </svg>`,
            // ===== 用户档案 / 社交 tab 图标 =====
            // 用户 - 头部 + 肩部（更精致）
            user: `<svg class="sgis-svg" ${_S}>
                <circle cx="12" cy="8" r="3.5" fill="currentColor" fill-opacity="0.18"/>
                <circle cx="12" cy="8" r="3.5"/>
                <path d="M5.5 20c.6-3.2 3.4-5 6.5-5s5.9 1.8 6.5 5" fill="currentColor" fill-opacity="0.12"/>
            </svg>`,
            // 社交 - 双人组合 + 闪光背景
            social: `<svg class="sgis-svg" ${_S}>
                <circle cx="9" cy="8" r="3.2" fill="currentColor" fill-opacity="0.18"/>
                <circle cx="9" cy="8" r="3.2"/>
                <path d="M3.5 19c.5-2.8 2.8-4.5 5.5-4.5s5 1.7 5.5 4.5" fill="currentColor" fill-opacity="0.12"/>
                <circle cx="16" cy="9.5" r="2.5"/>
                <path d="M13 18.5c.4-2.2 1.6-3.5 3-3.5s2.6 1.3 3 3.5"/>
            </svg>`,
            // 洞察 - 雷达扫描（眼+十字线）
            insight: `<svg class="sgis-svg" ${_S}>
                <circle cx="12" cy="12" r="9" fill="currentColor" fill-opacity="0.1"/>
                <circle cx="12" cy="12" r="9"/>
                <circle cx="12" cy="12" r="5.5" opacity="0.4"/>
                <line x1="12" y1="3" x2="12" y2="7" stroke-width="1.4"/>
                <line x1="12" y1="17" x2="12" y2="21" stroke-width="1.4"/>
                <line x1="3" y1="12" x2="7" y2="12" stroke-width="1.4"/>
                <line x1="17" y1="12" x2="21" y2="12" stroke-width="1.4"/>
                <circle cx="12" cy="12" r="2" fill="currentColor"/>
            </svg>`,
            // ===== 通用工具图标 =====
            close: `<svg class="sgis-svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round"><line x1="18" y1="6" x2="6" y2="18"/><line x1="6" y1="6" x2="18" y2="18"/></svg>`,
            refresh: `<svg class="sgis-svg" ${_S}><path d="M20.5 8a8.5 8.5 0 1 0 1.5 7" /><polyline points="20 3 20.5 8 15.5 8.5"/></svg>`,
            settings: `<svg class="sgis-svg" ${_S}><circle cx="12" cy="12" r="3" fill="currentColor" fill-opacity="0.18"/><circle cx="12" cy="12" r="3"/><path d="M19.4 15a1.65 1.65 0 0 0 .33 1.82l.06.06a2 2 0 0 1-2.83 2.83l-.06-.06a1.65 1.65 0 0 0-1.82-.33 1.65 1.65 0 0 0-1 1.51V21a2 2 0 0 1-4 0v-.09A1.65 1.65 0 0 0 9 19.4a1.65 1.65 0 0 0-1.82.33l-.06.06a2 2 0 0 1-2.83-2.83l.06-.06A1.65 1.65 0 0 0 4.68 15a1.65 1.65 0 0 0-1.51-1H3a2 2 0 0 1 0-4h.09A1.65 1.65 0 0 0 4.6 9a1.65 1.65 0 0 0-.33-1.82l-.06-.06a2 2 0 0 1 2.83-2.83l.06.06A1.65 1.65 0 0 0 9 4.68a1.65 1.65 0 0 0 1-1.51V3a2 2 0 0 1 4 0v.09a1.65 1.65 0 0 0 1 1.51 1.65 1.65 0 0 0 1.82-.33l.06-.06a2 2 0 0 1 2.83 2.83l-.06.06A1.65 1.65 0 0 0 19.4 9a1.65 1.65 0 0 0 1.51 1H21a2 2 0 0 1 0 4h-.09a1.65 1.65 0 0 0-1.51 1z"/></svg>`,
            check: `<svg class="sgis-svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="4 12 10 18 20 6"/></svg>`,
            star: `<svg class="sgis-svg" viewBox="0 0 24 24" fill="currentColor"><polygon points="12 2 14.85 8.6 22 9.3 16.5 14.14 18.18 21.02 12 17.27 5.82 21.02 7.5 14.14 2 9.3 9.15 8.6"/></svg>`,
            share: `<svg class="sgis-svg" ${_S}><circle cx="18" cy="5" r="2.8" fill="currentColor" fill-opacity="0.15"/><circle cx="6" cy="12" r="2.8" fill="currentColor" fill-opacity="0.15"/><circle cx="18" cy="19" r="2.8" fill="currentColor" fill-opacity="0.15"/><line x1="8.2" y1="13.5" x2="15.8" y2="17.5"/><line x1="15.8" y1="6.5" x2="8.2" y2="10.5"/></svg>`,
            news: `<svg class="sgis-svg" ${_S}><path d="M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v18z" fill="currentColor" fill-opacity="0.1"/><polyline points="14 2 14 8 20 8"/><line x1="8" y1="13" x2="16" y2="13"/><line x1="8" y1="17" x2="13" y2="17"/></svg>`,
            info: `<svg class="sgis-svg" ${_S}><circle cx="12" cy="12" r="9.5"/><line x1="12" y1="11" x2="12" y2="16.5"/><circle cx="12" cy="7.5" r="0.8" fill="currentColor"/></svg>`,
            // ====== 媒体/工具 ======
            game: `<svg class="sgis-svg" ${_S}><rect x="2" y="6.5" width="20" height="11" rx="3" fill="currentColor" fill-opacity="0.12"/><line x1="2" y1="11" x2="22" y2="11" opacity="0.6"/><circle cx="7" cy="14" r="1" fill="currentColor"/><circle cx="11" cy="14" r="1" fill="currentColor"/><path d="M14 12.5h4"/><path d="M16 10.5v4"/></svg>`,
            card: `<svg class="sgis-svg" ${_S}><rect x="3" y="6" width="18" height="13" rx="2.5" fill="currentColor" fill-opacity="0.1"/><line x1="3" y1="10.5" x2="21" y2="10.5"/><rect x="6" y="14" width="5" height="2" rx="0.5" fill="currentColor"/></svg>`,
            library: `<svg class="sgis-svg" ${_S}><path d="M16.5 9.4L12 12 3.5 7.4" opacity="0.7"/><path d="M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z" fill="currentColor" fill-opacity="0.1"/></svg>`,
            // 通用
            chevronRight: `<svg class="sgis-svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="9 6 15 12 9 18"/></svg>`,
            sparkle: `<svg class="sgis-svg" viewBox="0 0 24 24" fill="currentColor"><path d="M12 2l1.8 6.3L20 10l-6.2 1.7L12 18l-1.8-6.3L4 10l6.2-1.7L12 2z" opacity="0.85"/><circle cx="19" cy="5" r="1.2"/><circle cx="5" cy="19" r="1.2"/><circle cx="19" cy="19" r="0.8" opacity="0.6"/></svg>`,
            brain: `<svg class="sgis-svg" ${_S}><path d="M12 2a4 4 0 0 0-4 4 4 4 0 0 0-4 4 4 4 0 0 0 0 8 4 4 0 0 0 4 4 4 4 0 0 0 4-4z" fill="currentColor" fill-opacity="0.1"/><path d="M12 2a4 4 0 0 1 4 4 4 4 0 0 1 4 4 4 4 0 0 1 0 8 4 4 0 0 1-4 4 4 4 0 0 1-4-4z" fill="currentColor" fill-opacity="0.1"/><line x1="12" y1="2" x2="12" y2="22" stroke-dasharray="2 2" opacity="0.4"/></svg>`,
            clock: `<svg class="sgis-svg" ${_S}><circle cx="12" cy="12" r="9" fill="currentColor" fill-opacity="0.08"/><polyline points="12 7 12 12 15.5 14"/></svg>`,
            users: `<svg class="sgis-svg" ${_S}><circle cx="9" cy="8" r="3.5" fill="currentColor" fill-opacity="0.18"/><circle cx="9" cy="8" r="3.5"/><path d="M3 20c.6-3.2 3-5 6-5s5.4 1.8 6 5" fill="currentColor" fill-opacity="0.12"/><circle cx="17" cy="9" r="2.5"/><path d="M15 19.5c.4-2 1.4-3 2-3s1.6 1 2 3"/></svg>`,
            package: `<svg class="sgis-svg" ${_S}><path d="M16.5 9.4L12 12 3.5 7.4" opacity="0.7"/><path d="M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z" fill="currentColor" fill-opacity="0.1"/></svg>`,
            gift: `<svg class="sgis-svg" ${_S}><rect x="2" y="8" width="20" height="5" rx="1" fill="currentColor" fill-opacity="0.15"/><line x1="2" y1="13" x2="22" y2="13"/><polyline points="4 13 4 22 20 22 20 13"/><line x1="12" y1="22" x2="12" y2="8"/><path d="M12 8H7.5a2.5 2.5 0 0 1 0-5C11 3 12 8 12 8z" fill="currentColor" fill-opacity="0.2"/><path d="M12 8h4.5a2.5 2.5 0 0 0 0-5C13 3 12 8 12 8z" fill="currentColor" fill-opacity="0.2"/></svg>`,
            link: `<svg class="sgis-svg" ${_S}><path d="M10 13a5 5 0 0 0 7.54.54l3-3a5 5 0 0 0-7.07-7.07l-1.72 1.71"/><path d="M14 11a5 5 0 0 0-7.54-.54l-3 3a5 5 0 0 0 7.07 7.07l1.71-1.71"/></svg>`,
            // 工具/统计
            barChart: `<svg class="sgis-svg" ${_S}><line x1="12" y1="20" x2="12" y2="11"/><line x1="18" y1="20" x2="18" y2="4"/><line x1="6" y1="20" x2="6" y2="15"/><circle cx="12" cy="9" r="1" fill="currentColor"/><circle cx="18" cy="3" r="1" fill="currentColor"/><circle cx="6" cy="13" r="1" fill="currentColor"/></svg>`,
            trend: `<svg class="sgis-svg" ${_S}><polyline points="22 7 13.5 15.5 8.5 10.5 2 17"/><polyline points="16 7 22 7 22 13"/></svg>`,
            // 维度评分图标
            target: `<svg class="sgis-svg" ${_S}><circle cx="12" cy="12" r="9.5" fill="currentColor" fill-opacity="0.08"/><circle cx="12" cy="12" r="5.5"/><circle cx="12" cy="12" r="2" fill="currentColor"/></svg>`,
            // 市场洞察
            market: `<svg class="sgis-svg" ${_S}><path d="M6 2L3 6v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2V6l-3-4z" fill="currentColor" fill-opacity="0.12"/><line x1="3" y1="6" x2="21" y2="6"/><path d="M16 10a4 4 0 0 1-8 0"/></svg>`,
            // 闪电
            zap: `<svg class="sgis-svg" viewBox="0 0 24 24" fill="currentColor"><path d="M13 2L3 14h7l-1 8 11-12h-7l0-8z"/></svg>`,
            // 盾牌（VAC / 年龄限制共用，v2.3.8 重复定义已合并）
            shield: `<svg class="sgis-svg" ${_S}><path d="M12 2.5L4 5.5v6c0 5 3.5 9 8 10.5 4.5-1.5 8-5.5 8-10.5v-6z" fill="currentColor" fill-opacity="0.12"/><path d="M9 12l2 2 4-4"/></svg>`,
            // 外链
            external: `<svg class="sgis-svg" ${_S}><path d="M14 4h6v6" /><line x1="20" y1="4" x2="11" y2="13"/><path d="M19 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V7a2 2 0 0 1 2-2h6"/></svg>`,
            // 心愿
            heart: `<svg class="sgis-svg" viewBox="0 0 24 24" fill="currentColor"><path d="M20.84 4.61a5.5 5.5 0 0 0-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 0 0-7.78 7.78l1.06 1.06L12 21.23l7.78-7.78 1.06-1.06a5.5 5.5 0 0 0 0-7.78z" opacity="0.9"/></svg>`,
            // 复制
            copy: `<svg class="sgis-svg" ${_S}><rect x="9" y="9" width="13" height="13" rx="2" fill="currentColor" fill-opacity="0.1"/><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"/></svg>`,
            // 创意工坊
            workshop: `<svg class="sgis-svg" ${_S}><path d="M14.7 6.3a1 1 0 0 0 0 1.4l1.6 1.6a1 1 0 0 0 1.4 0l3.77-3.77a6 6 0 0 1-7.94 7.94l-6.91 6.91a2.12 2.12 0 0 1-3-3l6.91-6.91a6 6 0 0 1 7.94-7.94l-3.76 3.76z" fill="currentColor" fill-opacity="0.12"/></svg>`,
            // 截图
            image: `<svg class="sgis-svg" ${_S}><rect x="3" y="3" width="18" height="18" rx="2" fill="currentColor" fill-opacity="0.08"/><circle cx="8.5" cy="8.5" r="1.5"/><polyline points="21 15 16 10 5 21"/></svg>`,
            // 标签
            tag: `<svg class="sgis-svg" ${_S}><path d="M20.59 13.41l-7.17 7.17a2 2 0 0 1-2.83 0L2 12V2h10l8.59 8.59a2 2 0 0 1 0 2.82z" fill="currentColor" fill-opacity="0.12"/><circle cx="7.5" cy="7.5" r="1.3" fill="currentColor"/></svg>`,
            // 视频
            video: `<svg class="sgis-svg" ${_S}><rect x="2" y="5" width="14" height="14" rx="2" fill="currentColor" fill-opacity="0.1"/><polygon points="22 7 16 12 22 17 22 7" fill="currentColor" fill-opacity="0.6"/></svg>`,
            // 地球
            globe: `<svg class="sgis-svg" ${_S}><circle cx="12" cy="12" r="9.5" fill="currentColor" fill-opacity="0.08"/><ellipse cx="12" cy="12" rx="4" ry="9.5"/><line x1="2.5" y1="12" x2="21.5" y2="12"/><path d="M4 7h16M4 17h16" opacity="0.5"/></svg>`,
            // 手柄
            gamepad: `<svg class="sgis-svg" ${_S}><path d="M6 8h12a4 4 0 0 1 4 4v3a3 3 0 0 1-5.5 1.7L15 15H9l-1.5 1.7A3 3 0 0 1 2 15v-3a4 4 0 0 1 4-4z" fill="currentColor" fill-opacity="0.12"/><line x1="6" y1="11" x2="9" y2="11"/><line x1="7.5" y1="9.5" x2="7.5" y2="12.5"/><circle cx="15" cy="11.5" r="0.8" fill="currentColor"/><circle cx="17" cy="9.5" r="0.8" fill="currentColor"/></svg>`,
            // 扩展包 (DLC)
            puzzle: `<svg class="sgis-svg" ${_S}><path d="M10 3h4a1 1 0 0 1 1 1v2.5a1.5 1.5 0 0 0 3 0V4a1 1 0 0 1 1-1h2v6a1 1 0 0 1-1 1h-2.5a1.5 1.5 0 0 0 0 3H20a1 1 0 0 1 1 1v4a1 1 0 0 1-1 1h-2.5a1.5 1.5 0 0 1 0-3H20a1 1 0 0 0 1-1V9" opacity="0.3"/><path d="M10 3h4v3.5a1.5 1.5 0 0 0 3 0V4a1 1 0 0 1 1-1h2v6h-3.5a1.5 1.5 0 0 0 0 3H20v4h-3.5a1.5 1.5 0 0 0 0 3H20a1 1 0 0 1-1 1h-2v-3.5a1.5 1.5 0 0 0-3 0V20H8a1 1 0 0 1-1-1v-2.5a1.5 1.5 0 0 0-3 0V20a1 1 0 0 1-1-1v-2a1 1 0 0 1 1-1h2.5a1.5 1.5 0 0 0 0-3H4V9a1 1 0 0 1 1-1h2.5a1.5 1.5 0 0 0 0-3H4V4a1 1 0 0 1 1-1h2v3.5a1.5 1.5 0 0 0 3 0z" fill="currentColor" fill-opacity="0.15"/></svg>`,
            // 火焰（热卖/趋势）
            fire: `<svg class="sgis-svg" ${_S}><path d="M12 2.5c-1 3-4 4.5-4 8a4 4 0 0 0 1.5 3.1 3 3 0 0 1 2.5-3.6 2.5 2.5 0 0 0 1 2.5c0-2 1-3 2-4.5 1 1.5 3 3.5 3 6.5a6 6 0 0 1-12 0c0-2 1-3 1.5-4.5" fill="currentColor" fill-opacity="0.2"/></svg>`,
            // 火箭（速度/即将推出）
            rocket: `<svg class="sgis-svg" ${_S}><path d="M12 2.5c4 2 6 6 6 11l-3 3-3 3-3-3-3-3c0-5 2-9 6-11z" fill="currentColor" fill-opacity="0.18"/><circle cx="12" cy="11" r="2.5" fill="currentColor" fill-opacity="0.4"/><path d="M9 19l-2 3 3-1M15 19l2 3-3-1"/></svg>`,
            // 旗帜（特性/标记）
            flag: `<svg class="sgis-svg" ${_S}><path d="M5 21V4h12l-2 4 2 4H7" fill="currentColor" fill-opacity="0.15"/><line x1="5" y1="3" x2="5" y2="21"/></svg>`,
            // v2.9.93: 资料受限 — 用户轮廓 + 警告三角
            profileLimited: `<svg class="sgis-svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="8" r="4" fill="currentColor" fill-opacity="0.12"/><path d="M4 21v-2a8 8 0 0 1 14-5.3"/><path d="M18 14l3 5.5h-6z" fill="currentColor" fill-opacity="0.3"/><path d="M18 16.5v2" stroke-width="2"/></svg>`,
            // ====== 默认勋章 SVG (加载失败兜底)======
            medalFallback: `<svg class="sgis-svg" viewBox="0 0 80 80" xmlns="http://www.w3.org/2000/svg"><defs><linearGradient id="medal-fb-g1" x1="0" y1="0" x2="1" y2="1"><stop offset="0" stop-color="#8b5cf6"/><stop offset="1" stop-color="#3b82f6"/></linearGradient><linearGradient id="medal-fb-g2" x1="0" y1="0" x2="1" y2="1"><stop offset="0" stop-color="#a78bfa"/><stop offset="1" stop-color="#60a5fa"/></linearGradient><radialGradient id="medal-fb-g3" cx="0.5" cy="0.4"><stop offset="0" stop-color="rgba(255,255,255,0.6)"/><stop offset="1" stop-color="rgba(255,255,255,0)"/></radialGradient></defs><path d="M22 8 L40 30 L58 8 L52 8 L40 22 L28 8 Z" fill="url(#medal-fb-g1)"/><circle cx="40" cy="50" r="24" fill="url(#medal-fb-g1)" stroke="url(#medal-fb-g2)" stroke-width="2"/><circle cx="40" cy="50" r="18" fill="none" stroke="url(#medal-fb-g2)" stroke-width="1.5" stroke-dasharray="2 3"/><path d="M32 50 L38 56 L50 42" fill="none" stroke="#fff" stroke-width="3" stroke-linecap="round" stroke-linejoin="round"/><circle cx="40" cy="50" r="24" fill="url(#medal-fb-g3)"/></svg>`,
        };

        // ---- UI 构建 ----
        function ensureFab() {
            // v2.3.26: 愿望单页面不创建浮动按钮，让 Wishlist Exporter 侧边栏独占
            if (IS_WISHLIST_PAGE) return;
            if (document.getElementById('sgis-fab')) return;
            const btn = document.createElement('button');
            btn.id = 'sgis-fab';
            btn.title = '个人信息面板';
            btn.setAttribute('aria-label', '个人信息面板');
            btn.addEventListener('click', togglePanel);
            document.body.appendChild(btn);
        }
        function ensurePanel() {
            if (document.getElementById('sgis-panel')) return;
            // v2.3.2: 动态标题/图标 - 游戏页(带 appid)显示"游戏信息面板",
            // 其他页面(商店主页等)显示"个人信息面板"
            const titleIcon = HAS_APP_ID ? SGIS_ICONS.game : SGIS_ICONS.user;
            const titleText = HAS_APP_ID ? '游戏信息面板' : '个人信息面板';
            const panel = document.createElement('div');
            panel.id = 'sgis-panel';
            panel.innerHTML = `
                <div class="sgis-header">
                    <div class="sgis-title">
                        <span class="sgis-title-icon">${titleIcon}</span>
                        <span class="sgis-title-text">${titleText}</span>
                    </div>
                    <div class="sgis-title-actions">
                        <button class="sgis-icon-btn" id="sgis-theme-btn" title="">${ICONS.palette}</button>
                        <button class="sgis-icon-btn" id="sgis-settings-btn" title="${T.globalSettings}">${ICONS.settings}</button>
                        <button class="sgis-icon-btn" id="sgis-refresh-btn" title="刷新当前标签">${SGIS_ICONS.refresh}</button>
                        <button class="sgis-icon-btn" id="sgis-close-btn" title="关闭">${SGIS_ICONS.close}</button>
                    </div>
                    <div class="sgis-header-decoration"></div>
                </div>
                <div class="sgis-tabs" id="sgis-tabs">
                    ${HAS_APP_ID ? `
                    <button class="sgis-tab active" data-tab="overview">${SGIS_ICONS.overview}<span>概览</span></button>
                    <button class="sgis-tab" data-tab="medals">${SGIS_ICONS.medal}<span>勋章</span></button>
                    <button class="sgis-tab" data-tab="prices">${SGIS_ICONS.price}<span>价格</span></button>
                    <button class="sgis-tab" data-tab="reviews">${SGIS_ICONS.review}<span>评测</span></button>
                    <button class="sgis-tab" data-tab="achievements">${SGIS_ICONS.trophy}<span>成就</span></button>
                    <button class="sgis-tab" data-tab="dynamics">${SGIS_ICONS.activity}<span>动态</span></button>
                    ` : `
                    <button class="sgis-tab active" data-tab="profile">${SGIS_ICONS.user}<span>概览</span></button>
                    <button class="sgis-tab" data-tab="activity">${SGIS_ICONS.activity}<span>动态</span></button>
                    <button class="sgis-tab" data-tab="userBadges">${SGIS_ICONS.medal}<span>勋章</span></button>
                    <button class="sgis-tab" data-tab="social">${SGIS_ICONS.social}<span>社交</span></button>
                    <button class="sgis-tab" data-tab="userAchievements">${SGIS_ICONS.insight}<span>洞察</span></button>
                    `}
                </div>
                <div class="sgis-body" id="sgis-body"></div>
            `;
            document.body.appendChild(panel);
            panel.querySelector('#sgis-close-btn').addEventListener('click', closePanel);
            panel.querySelector('#sgis-settings-btn').addEventListener('click', () => openGlobalSettings());
            // v2.11.40: 主题快速切换按钮——典雅紫 ⇄ 经典蓝一键互切,保存偏好并即时热切换
            // (CSS 层/内联 var()/收藏浮窗样式随 <style id=sglv-theme-style> 内容替换即时生效,
            //  本面板当前 Tab 由 initSidebar 注册的 sglv-theme-changed 监听重渲染)
            const _themeBtn = panel.querySelector('#sgis-theme-btn');
            const _updateThemeBtnTitle = () => {
                const next = SGLV_THEMES[getThemeId() === 'purple' ? 'blue' : 'purple'];
                _themeBtn.title = isZh ? `切换主题：${next.zh}` : `Switch theme: ${next.en}`;
            };
            _themeBtn.addEventListener('click', () => {
                const nextId = getThemeId() === 'purple' ? 'blue' : 'purple';
                storage.setUiTheme(nextId);
                applySglvTheme(nextId);
                const t = SGLV_THEMES[nextId];
                sglvToast.success(isZh ? `已切换主题：${t.zh}` : `Theme switched: ${t.en}`);
                _updateThemeBtnTitle();
            });
            _updateThemeBtnTitle();
            panel.querySelector('#sgis-refresh-btn').addEventListener('click', () => {
                const refreshBtn = panel.querySelector('#sgis-refresh-btn');
                refreshBtn.classList.add('sgis-spin');
                Promise.resolve(renderTab(SGIS.tab, true)).finally(() => refreshBtn.classList.remove('sgis-spin'));
            });
            panel.querySelectorAll('.sgis-tab').forEach(tabBtn => {
                tabBtn.addEventListener('click', () => {
                    panel.querySelectorAll('.sgis-tab').forEach(b => b.classList.remove('active'));
                    tabBtn.classList.add('active');
                    SGIS.tab = tabBtn.dataset.tab;
                    // v2.9.15: 切换 tab 时滚动条复位到顶部,避免新内容在屏幕外
                    const body = document.getElementById('sgis-body');
                    if (body) body.scrollTop = 0;
                    renderTab(SGIS.tab, false);
                });
            });
            document.addEventListener('keydown', e => {
                if (e.key === 'Escape' && SGIS.open) closePanel();
            });
        }
        function openPanel() {
            const overlay = document.getElementById('sf-wf-overlay');
            if (overlay && overlay.classList.contains('sf-wf-open')) return;
            SGIS.open = true;
            document.body.classList.add('sgis-open');
            document.getElementById('sgis-panel').classList.add('sgis-open');
            const f = document.getElementById('sgis-fab'); if (f) f.classList.add('sgis-open');
            renderTab(SGIS.tab, false);
        }
        function closePanel() {
            SGIS.open = false;
            document.body.classList.remove('sgis-open');
            const p = document.getElementById('sgis-panel'); if (p) p.classList.remove('sgis-open');
            const f = document.getElementById('sgis-fab'); if (f) f.classList.remove('sgis-open');
        }
        function togglePanel() {
            if (SGIS.open) closePanel(); else openPanel();
        }
        function setBody(html) {
            const b = document.getElementById('sgis-body');
            if (b) b.innerHTML = html;
        }
        function renderLoading(text) {
            // v2.9.15: 状态点 + 文字 + spinner 组合,精致化加载态
            setBody(`<div class="sgis-state">
                <div class="sgis-state-icon"><svg class="sgis-svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8"><circle cx="12" cy="12" r="9"/><polyline points="12 7 12 12 15.5 14"/></svg></div>
                <div>${text || '正在加载…'}</div>
            </div>`);
        }

        // v2.8.1: 增强版加载——带阶段进度条 + 游戏骨架占位（参考 steam-friend-manager 加载体验）
        // 调用方：renderProgressLoading({ stage, totalStages, text, skeletonCount }) 初始化，
        //        后续用返回的 update({ percent, stage, text, counter }) 增量更新。
        // 目的：消除"卡死"感，让用户在等待中看到结构与进度。
        function renderProgressLoading(opts) {
            const cfg = Object.assign({
                stage: 1,
                totalStages: 4,
                text: '正在加载…',
                skeletonCount: 8,
            }, opts || {});
            // v2.11.3: 阶段条/骨架行改经共享段生成器与 createSkeleton 工厂(输出逐字节等价)
            const stagesHtml = stageBarsHtml(cfg.totalStages, cfg.stage, 'sgis-load-stages');
            const skelHtml = createSkeleton('sgis', cfg.skeletonCount);
            setBody(`
                <div class="sgis-load-block" id="sgis-load-block">
                    <div class="sgis-load-head">
                        <div class="sgis-spinner"></div>
                        <div class="sgis-load-stage" id="sgis-load-stage-text">${cfg.text}</div>
                        <div class="sgis-load-pct" id="sgis-load-pct">0%</div>
                    </div>
                    ${stagesHtml}
                    <div class="sgis-load-bar"><div class="sgis-load-bar-fill" id="sgis-load-fill"></div></div>
                    <div class="sgis-load-counter" id="sgis-load-counter" style="display:none"></div>
                    <div class="sgis-skel-list" id="sgis-skel-list">${skelHtml}</div>
                </div>
            `);
            // 返回更新器
            return {
                update(u) {
                    if (!u) return;
                    const fill = document.getElementById('sgis-load-fill');
                    const pct = document.getElementById('sgis-load-pct');
                    const text = document.getElementById('sgis-load-stage-text');
                    const counter = document.getElementById('sgis-load-counter');
                    const stagesWrap = document.getElementById('sgis-load-stages');
                    if (u.percent != null) {
                        const p = Math.max(0, Math.min(100, Math.round(u.percent)));
                        if (fill) fill.style.width = p + '%';
                        if (pct) pct.textContent = p + '%';
                    }
                    if (u.text != null && text) text.textContent = u.text;
                    if (u.counter != null) {
                        if (counter) { counter.textContent = u.counter; counter.style.display = ''; }
                    }
                    if (u.stage != null && stagesWrap) {
                        const bars = stagesWrap.querySelectorAll('.sgis-load-stage-bar');
                        bars.forEach((b, i) => {
                            b.classList.remove('active', 'done');
                            if (i + 1 < u.stage) b.classList.add('done');
                            else if (i + 1 === u.stage) b.classList.add('active');
                        });
                    }
                },
                remove() {
                    const blk = document.getElementById('sgis-load-block');
                    if (blk) blk.remove();
                },
            };
        }
        function renderError(text) {
            // v2.9.15: 错误状态点 + 大字提示 + 重试按钮
            setBody(`<div class="sgis-state sgis-error">
                <div class="sgis-state-icon"><svg class="sgis-svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="9"/><line x1="12" y1="8" x2="12" y2="12"/><circle cx="12" cy="16" r="0.6" fill="currentColor"/></svg></div>
                <div style="font-weight:600;margin-bottom:4px">${text || '加载失败'}</div>
                <div style="font-size:11px;color:var(--sgis-text-3)">请检查网络连接或 Steam 登录状态后重试</div>
                <div style="margin-top:14px">
                    <button class="sgis-retry-btn" onclick="void(0)">重新加载</button>
                </div>
            </div>`);
            const retryBtn = document.querySelector('#sgis-body .sgis-retry-btn');
            if (retryBtn) {
                retryBtn.addEventListener('click', () => {
                    // 清除当前标签页缓存后重新渲染
                    resetTabCache(SGIS.tab, 'retry');
                    renderTab(SGIS.tab, true);
                });
            }
        }

        // ---- 概览标签 (整合 DOM 信息 + 共享游戏库数据) ----
        function extractOverviewFromDOM() {
            const data = {
                appId: APP_ID,
                name: '', cover: '',
                developer: '', publisher: '', releaseDate: '',
                platforms: [], tags: [], genres: [],
                priceCurrent: '', priceOriginal: '', discountPercent: 0,
                isFree: false,
                reviews: { recent: { label: '', summary: '', count: '', pos: 0 }, all: { label: '', summary: '', count: '', pos: 0 } },
                shortDesc: '',
            };
            const nameEl = document.getElementById('appHubAppName');
            if (nameEl) data.name = nameEl.textContent.trim();
            if (!data.name) {
                const og = document.querySelector('meta[property="og:title"]');
                if (og) data.name = og.content.replace(/\s+on Steam$/i, '').trim();
            }
            const ogImg = document.querySelector('meta[property="og:image"]');
            if (ogImg) data.cover = ogImg.content;
            const devLink = document.querySelector('#developers_list a, .glance_details a[href*="/developer/"], .game_details a.dev_link');
            if (devLink) data.developer = devLink.textContent.trim();
            const pubLink = document.querySelector('.glance_details a[href*="/publisher/"]');
            if (pubLink) data.publisher = pubLink.textContent.trim();
            const releaseEl = document.querySelector('.release_date .date');
            if (releaseEl) data.releaseDate = releaseEl.textContent.trim();
            // 用 Set 去重平台 (页面中可能有多组 .game_area_purchase_game 对应游戏+DLCs)
            const platformsSet = new Set();
            // 兼容多种 selector: 优先 buy 区, 备用 game details
            const platformNodes = document.querySelectorAll(
                '.game_area_purchase_game .platform_img, .game_details .platform_img, .game_purchase_platform .platform_img'
            );
            platformNodes.forEach(img => {
                const cls = (img.className || '').toLowerCase();
                if (cls.includes('win')) platformsSet.add('Windows');
                else if (cls.includes('mac')) platformsSet.add('macOS');
                else if (cls.includes('linux') || cls.includes('steamos')) platformsSet.add('SteamOS + Linux');
            });
            data.platforms = Array.from(platformsSet);
            // 兜底: 如果没找到, 从 game details 文本提取
            if (data.platforms.length === 0) {
                const detailsText = (document.querySelector('#game_details, .game_details')?.textContent || '').toLowerCase();
                if (/win/i.test(detailsText)) platformsSet.add('Windows');
                if (/mac/i.test(detailsText)) platformsSet.add('macOS');
                if (/linux/i.test(detailsText)) platformsSet.add('SteamOS + Linux');
                data.platforms = Array.from(platformsSet);
            }
            document.querySelectorAll('.glance_tags .app_tag, .popular_tags .app_tag').forEach(t => {
                const txt = t.textContent.trim();
                if (txt) data.tags.push(txt);
            });
            data.tags = [...new Set(data.tags)].slice(0, 12);
            document.querySelectorAll('.glance_details a[href*="/genre/"]').forEach(a => {
                const g = a.textContent.trim();
                if (g) data.genres.push(g);
            });
            // v2.9.84: 从第一个购买区域(基础游戏)提取价格,避免抓取捆绑包价格
            // Steam 页面中 .game_area_purchase_game 按 基础游戏→捆绑包→DLC 顺序排列
            // 旧代码使用全局 querySelector 会命中捆绑包的折扣价格
            const basePurchase = document.querySelector('.game_area_purchase_game');
            const qs = sel => (basePurchase || document).querySelector(sel);
            const freeText = basePurchase
                ? Array.from(basePurchase.querySelectorAll('.game_purchase_price')).find(p => /free/i.test(p.textContent))
                : Array.from(document.querySelectorAll('.game_purchase_price')).find(p => /free/i.test(p.textContent));
            const finalPrice = qs('.discount_final_price');
            const originalPrice = qs('.discount_original_price');
            const discountPct = qs('.discount_pct');
            if (freeText) { data.isFree = true; data.priceCurrent = '免费'; }
            else if (finalPrice) {
                data.priceCurrent = finalPrice.textContent.trim();
                if (originalPrice) data.priceOriginal = originalPrice.textContent.trim();
                if (discountPct) { const m = discountPct.textContent.match(/(\d+)/); if (m) data.discountPercent = parseInt(m[1], 10); }
            } else {
                const pn = qs('.game_purchase_price');
                if (pn) data.priceCurrent = pn.textContent.trim();
            }
            document.querySelectorAll('.user_reviews_summary_row').forEach(row => {
                const subtitle = row.querySelector('.subtitle')?.textContent?.trim() || '';
                const summary = row.querySelector('.game_review_summary')?.textContent?.trim() || '';
                const countText = row.querySelector('.responsive_reviewdesc_summary, .review_summary_with_link')?.textContent?.trim() || '';
                const countMatch = countText.match(/(\d+(?:[,.]\d+)*)\s*user reviews/);
                const count = countMatch ? countMatch[1] : '';
                const pctMatch = countText.match(/\((\d+)%\)/);
                const pos = pctMatch ? parseInt(pctMatch[1], 10) : 0;
                const target = subtitle.includes('All') ? 'all' : 'recent';
                data.reviews[target] = { label: subtitle, summary, count, pos };
            });
            const shortDesc = document.querySelector('.game_description_snippet');
            if (shortDesc) data.shortDesc = shortDesc.textContent.trim();
            return data;
        }

        // ==================== v2.3.19: morelike 页面专用模块 ====================

        // ---- 概览提取：morelike 页适配 ----
        // morelike 页 DOM 与 /app/ 页不同：源游戏信息在 .recommendation_highlight，
        // 而非 #appHubAppName / .game_area_purchase_game 等。其余字段留给 appdetails API 补全。
        function extractMoreLikeOverview() {
            const headerImg = document.querySelector('.recommendation_highlight .header_image');
            const tagIdsAttr = headerImg?.getAttribute('data-ds-tagids');
            const priceEl = document.querySelector('.highlight_description .regular_price, .highlight_description .discount_final_price');
            const priceText = priceEl?.textContent.trim() || '';
            const isFree = /免费|free/i.test(priceText);
            const data = {
                appId: APP_ID,
                name: document.querySelector('h2.pageheader')?.textContent.trim() || '',
                cover: headerImg?.querySelector('img')?.src || '',
                developer: '', publisher: '', releaseDate: '',
                platforms: [], tags: [], genres: [],
                priceCurrent: priceText,
                priceOriginal: '', discountPercent: 0,
                isFree,
                reviews: { recent: { label: '', summary: '', count: '', pos: 0 }, all: { label: '', summary: '', count: '', pos: 0 } },
                shortDesc: '',
                // morelike 专用：源游戏标签 ID，驱动类型扩展推荐
                sourceTagIds: tagIdsAttr ? (() => { try { return JSON.parse(tagIdsAttr); } catch { return []; } })() : [],
                pageType: 'morelike',
            };
            return data;
        }

        // ---- 相似游戏采集：从 DOM 读取 .similar_grid_capsule ----
        function extractSimilarGames() {
            const items = Array.from(document.querySelectorAll('.similar_grid_capsule')).map(a => {
                const item = a.closest('.similar_grid_item');
                const href = a.getAttribute('href') || '';
                const nameSlug = (href.match(/\/app\/\d+\/([^/?]+)/) || [])[1] || '';
                const priceEl = item?.querySelector('.similar_grid_price .regular_price, .similar_grid_price .discount_final_price, .similar_grid_price .discount_original_price');
                const priceText = priceEl?.textContent.trim() || '';
                const tagIdsAttr = a.getAttribute('data-ds-tagids');
                return {
                    appId: Number(a.getAttribute('data-ds-appid')),
                    tagIds: tagIdsAttr ? (() => { try { return JSON.parse(tagIdsAttr); } catch { return []; } })() : [],
                    href: href.split('?snr=')[0],
                    capsule: a.querySelector('img')?.getAttribute('src') || '',
                    nameSlug: decodeURIComponent(nameSlug).replace(/_/g, ' ').trim() || ('App ' + a.getAttribute('data-ds-appid')),
                    priceText,
                    isFree: /免费|free/i.test(priceText),
                    status: null,  // 'owned' | 'wishlist' | 'ignored' | null，由 annotateSimilarStatus 填充
                };
            }).filter(g => g.appId && g.appId !== Number(APP_ID));  // 排除源游戏自身
            return items;
        }

        // ---- 库存状态获取：移植自 SteamPeek 1.9 getSteamData() ----
        // 读取 unsafeWindow.GDynamicStore 三集合，兼容数组/对象两种格式
        function getDynamicStoreStatus() {
            if (SGIS.dynamicStoreChecked) return SGIS.dynamicStore;
            SGIS.dynamicStoreChecked = true;
            const win = (typeof unsafeWindow !== 'undefined') ? unsafeWindow : window;
            const store = win.GDynamicStore;
            if (!store) { SGIS.dynamicStore = null; return null; }
            const toSet = (raw) => {
                if (!raw) return new Set();
                const arr = Array.isArray(raw) ? raw : Object.keys(raw);
                return new Set(arr.map(Number));
            };
            const result = {
                owned: toSet(store.s_rgOwnedApps),
                wishlist: toSet(store.s_rgWishlist || win.g_rgWishlist),
                ignored: toSet(store.s_rgIgnoredApps || win.g_rgIgnoredApps),
            };
            SGIS.dynamicStore = result;
            return result;
        }

        // v2.3.29: 异步获取 dynamicstore/userdata API——GDynamicStore 不可用时的回退
        // 该端点返回完整的 owned apps 列表（含 CD key 激活、促销许可等），比 GetOwnedGames 更可靠
        // 参考 Steam-License-Classifier 的 license 数据获取思路，确保 key 激活的游戏能被正确识别
        // 委托给外层 fetchDynamicStoreOwnedAppIds()，避免重复请求和代码重复
        async function fetchDynamicStoreUserData() {
            if (SGIS.dynamicStoreOwnedApps || SGIS.dynamicStoreFetching) return SGIS.dynamicStoreOwnedApps;
            SGIS.dynamicStoreFetching = true;
            try {
                const ownedApps = await fetchDynamicStoreOwnedAppIds();
                SGIS.dynamicStoreOwnedApps = ownedApps;
            } catch (e) {
                console.warn('[SGLV] 侧边栏 dynamicstore/userdata 获取失败:', e);
            } finally {
                SGIS.dynamicStoreFetching = false;
            }
            return SGIS.dynamicStoreOwnedApps;
        }

        // ---- 将库存状态回填到相似游戏数据 ----
        // 优先级：owned > wishlist > ignored（与 SteamPeek 1.9 一致）
        // 未登录兜底：GDynamicStore 三集合为空时，回退 state.ownedAppIds 判定 owned
        function annotateSimilarStatus() {
            if (!SGIS.similarGames) return;
            const ds = getDynamicStoreStatus();
            const hasDs = ds && (ds.owned.size > 0 || ds.wishlist.size > 0 || ds.ignored.size > 0);
            // 未登录兜底：用本地扫描的游戏库
            const localOwned = (!hasDs || ds.owned.size === 0) ? state.ownedAppIds : null;
            for (const g of SGIS.similarGames) {
                if (ds) {
                    if (ds.owned.has(g.appId)) { g.status = 'owned'; continue; }
                    if (ds.wishlist.has(g.appId)) { g.status = 'wishlist'; continue; }
                    if (ds.ignored.has(g.appId)) { g.status = 'ignored'; continue; }
                }
                if (localOwned && localOwned.has(g.appId)) { g.status = 'owned'; continue; }
                g.status = null;
            }
        }

        // ---- 渲染相似游戏区块 HTML ----
        function renderSimilarGamesSection() {
            if (!IS_MORELIKE) return '';
            if (!SGIS.similarGames) return '';
            const games = SGIS.similarGames;
            if (!games.length) return '';
            annotateSimilarStatus();

            // 筛选
            let filtered = games.slice();
            if (SGIS.similarFilter === 'owned') filtered = filtered.filter(g => g.status === 'owned');
            else if (SGIS.similarFilter === 'unowned') filtered = filtered.filter(g => g.status !== 'owned');
            else if (SGIS.similarFilter === 'wishlist') filtered = filtered.filter(g => g.status === 'wishlist');

            // 排序
            const parsePrice = (text) => {
                if (!text || /免费|free/i.test(text)) return 0;
                const m = text.match(/([\d,.]+)/);
                return m ? parseFloat(m[1].replace(/,/g, '')) : 0;
            };
            if (SGIS.similarSort === 'priceAsc') filtered.sort((a, b) => parsePrice(a.priceText) - parsePrice(b.priceText));
            else if (SGIS.similarSort === 'priceDesc') filtered.sort((a, b) => parsePrice(b.priceText) - parsePrice(a.priceText));
            else if (SGIS.similarSort === 'name') filtered.sort((a, b) => a.nameSlug.localeCompare(b.nameSlug));

            // 展示数量
            const limit = SGIS.similarExpanded ? filtered.length : SGIS.similarDisplayLimit;
            const shown = filtered.slice(0, limit);

            // 统计
            const ownedCount = games.filter(g => g.status === 'owned').length;
            const wishlistCount = games.filter(g => g.status === 'wishlist').length;
            const unownedCount = games.length - ownedCount;

            // 登录提示
            const ds = SGIS.dynamicStore;
            const noDsData = !ds || (ds.owned.size === 0 && ds.wishlist.size === 0 && ds.ignored.size === 0);
            const loginHint = noDsData
                ? `<div class="sgis-sim-login-hint">⚠ 未检测到 Steam 登录态的愿望单/忽略数据，仅显示本地游戏库标记。登录 Steam 商店后刷新页面可获取完整库存标记。</div>`
                : '';

            // 工具栏 - FEAT-014 TASK-008: filter 按钮组 + 排序按钮
            const sortLabels = { default: '默认', priceAsc: '价格↑', priceDesc: '价格↓', name: '名称' };
            const filterButtons = [
                { id: 'all', label: '全部', count: games.length, color: null },
                { id: 'unowned', label: '未拥有', count: unownedCount, color: null },
                { id: 'owned', label: '在库中', count: ownedCount, color: ownedCount ? '#67c1f5' : null },
            ];
            if (wishlistCount) filterButtons.push({ id: 'wishlist', label: '愿望单', count: wishlistCount, color: null });
            const filterHtml = `<div class="sgis-sim-toolbar">${filterButtons.map(f =>
                `<button class="sgis-sim-tbtn ${SGIS.similarFilter === f.id ? 'active' : ''}" data-sim-filter="${f.id}"${f.color ? ` style="color:${f.color}"` : ''}>${f.label}<span class="cnt">${f.count}</span></button>`
            ).join('')}<button class="sgis-sim-tbtn" data-sim-sort style="margin-left:auto">⇅ 排序<span class="cnt">${sortLabels[SGIS.similarSort] || '默认'}</span></button></div>`;

            // 卡片网格 - FEAT-014 TASK-008: 经 renderGameView 工厂(第 5 类消费方)渲染
            const cardItems = shown.map(g => {
                const tagHtml = g.status === 'owned'
                    ? '<span class="sgis-sim-tag sgis-sim-tag-owned">在库中</span>'
                    : g.status === 'wishlist'
                        ? '<span class="sgis-sim-tag sgis-sim-tag-wishlist">愿望单</span>'
                        : g.status === 'ignored'
                            ? '<span class="sgis-sim-tag sgis-sim-tag-ignored">已忽略</span>'
                            : '';
                const priceClass = g.isFree ? 'free' : (g.priceText ? '' : 'unknown');
                const priceDisplay = g.priceText || '价格未知';
                return { g, tagHtml, priceClass, priceDisplay };
            });
            const cardsHtml = (typeof renderGameView === 'function') ? renderGameView(cardItems, {
                viewMode: 'card',
                gridCls: 'sgis-sim-grid',
                cardCls: 'sgis-sim-card',
                bodyCls: 'sgis-sim-card-body',
                bareImg: true,
                imgHtml: (item) => item.g.capsule
                    ? `<img src="${item.g.capsule}" alt="${item.g.nameSlug}" loading="lazy" onerror="this.style.display='none'">`
                    : '<div style="height:62px;background:rgba(0,0,0,0.3)"></div>',
                bodyHtml: (item) => `${item.tagHtml}<div class="sgis-sim-card-name">${item.g.nameSlug}</div><div class="sgis-sim-card-price ${item.priceClass}">${item.priceDisplay}</div>`,
                itemAttrs: (item) => ` href="${item.g.href}" target="_blank" rel="noopener" title="${item.g.nameSlug} (AppID: ${item.g.appId})"`,
            }) : cardItems.map(item => `<a class="sgis-sim-card" href="${item.g.href}" target="_blank" rel="noopener" title="${item.g.nameSlug} (AppID: ${item.g.appId})">${item.tagHtml}${item.g.capsule ? `<img src="${item.g.capsule}" alt="${item.g.nameSlug}" loading="lazy" onerror="this.style.display='none'">` : '<div style="height:62px;background:rgba(0,0,0,0.3)"></div>'}<div class="sgis-sim-card-body"><div class="sgis-sim-card-name">${item.g.nameSlug}</div><div class="sgis-sim-card-price ${item.priceClass}">${item.priceDisplay}</div></div></a>`).join('');

            const moreHtml = filtered.length > limit
                ? `<div class="sgis-sim-more">显示 ${shown.length}/${filtered.length} · <a href="#" data-sim-expand>查看全部 →</a></div>`
                : filtered.length > SGIS.similarDisplayLimit && SGIS.similarExpanded
                    ? `<div class="sgis-sim-more"><a href="#" data-sim-collapse>收起 ↑</a></div>`
                    : '';

            return `<div class="sgis-section">
                <div class="sgis-section-title">${SGIS_ICONS.game} 相似游戏推荐 <span style="font-size:11px;color:var(--sgis-text-2);font-weight:400">(来自本页 · ${games.length})</span></div>
                ${loginHint}
                ${filterHtml}
                ${cardsHtml}
                ${moreHtml}
            </div>`;
        }

        // ---- 绑定相似游戏区块事件 ----
        function bindSimilarGamesEvents() {
            if (!IS_MORELIKE || !SGIS.similarGames) return;
            const body = document.getElementById('sgis-body');
            if (!body) return;
            // 筛选按钮
            body.querySelectorAll('[data-sim-filter]').forEach(btn => {
                btn.addEventListener('click', (e) => {
                    e.preventDefault();
                    SGIS.similarFilter = btn.getAttribute('data-sim-filter');
                    renderOverview();
                });
            });
            // 排序按钮（循环切换）
            const sortBtn = body.querySelector('[data-sim-sort]');
            if (sortBtn) {
                sortBtn.addEventListener('click', (e) => {
                    e.preventDefault();
                    const order = ['default', 'priceAsc', 'priceDesc', 'name'];
                    const idx = order.indexOf(SGIS.similarSort);
                    SGIS.similarSort = order[(idx + 1) % order.length];
                    renderOverview();
                });
            }
            // 展开/收起
            const expandBtn = body.querySelector('[data-sim-expand]');
            if (expandBtn) {
                expandBtn.addEventListener('click', (e) => {
                    e.preventDefault();
                    SGIS.similarExpanded = true;
                    renderOverview();
                });
            }
            const collapseBtn = body.querySelector('[data-sim-collapse]');
            if (collapseBtn) {
                collapseBtn.addEventListener('click', (e) => {
                    e.preventDefault();
                    SGIS.similarExpanded = false;
                    renderOverview();
                });
            }
        }

        // ---- 标签名反查：tagid → name ----
        // 策略：① 从 appdetails 的 categories/tags 匹配 ② 从源游戏相似游戏的 tagids 交叉 ③ 本地高频映射表
        const TAG_ID_NAME_MAP = {
            19: '动作', 21: '冒险', 122: 'RPG', 128: '单人', 1695: '开放世界',
            1754: '大型多人在线', 3859: '免费开玩', 3870: '俯视角', 3964: '像素图形',
            4135: '重玩价值', 4168: '视觉小说', 4231: '角色扮演', 4345: '生存',
            4747: '多人', 492: '独立', 493: '早期访问', 599: '策略',
            597: '休闲', 5350: '类魂', 4625: '派对', 4444: '叙事',
            1719: '奇幻', 1720: '科幻', 1742: '射击', 1775: '军事',
            1665: '生存', 1646: 'Roguelike', 1684: '合作', 3843: '农场模拟',
            4106: '时间管理', 4172: '2D', 4182: '3D', 4663: '卡牌',
            4684: '在线对战', 6730: '蒸汽工作室', 723991: '收纳',
        };
        function resolveTagName(tagId) {
            if (TAG_ID_NAME_MAP[tagId]) return TAG_ID_NAME_MAP[tagId];
            // 从 appdetails categories 中查找
            const extra = SGIS.appDetailsExtra;
            if (extra) {
                const cat = extra.categories.find(c => c.id === tagId);
                if (cat) return cat.description;
                // v2.9.57: genres 从 genreObjs 查找(库返回的 genres 是字符串数组,无 id)
                const genre = (extra.genreObjs || []).find(g => g.id === tagId);
                if (genre) return genre.description;
            }
            return '标签 ' + tagId;
        }

        // ---- 类型扩展推荐：调用 Steam 标签 API ----
        async function fetchTagRecommendations(tagIds) {
            if (!tagIds || !tagIds.length) return [];
            const cacheKey = 'tagRecs_' + tagIds.join(',');
            const cached = cacheGet(cacheKey);
            if (cached) return cached;

            SGIS.tagRecsLoading = true;
            SGIS.tagRecsError = null;
            try {
                const results = await mapLimit(tagIds, 4, async (tagId) => {
                    try {
                        const url = `https://steamcommunity.com/actions/QueryAppsWithTag/${tagId}`;
                        const data = await fetchJson(url, { timeout: 10000 });
                        const appIds = (data.appids || data || []).slice(0, 50).map(Number);
                        return {
                            tagId,
                            tagName: resolveTagName(tagId),
                            appIds,
                        };
                    } catch (e) {
                        return { tagId, tagName: resolveTagName(tagId), appIds: [], error: e.message };
                    }
                });

                const merged = results.filter(r => r.appIds.length);
                // 排除已在相似游戏列表中的 appid，避免重复
                const similarSet = new Set((SGIS.similarGames || []).map(g => g.appId));
                for (const r of merged) {
                    r.appIds = r.appIds.filter(id => !similarSet.has(id) && id !== Number(APP_ID));
                }
                // 过滤掉去重后为空的标签
                const final = merged.filter(r => r.appIds.length);
                cacheSet(cacheKey, final, 6 * 3600 * 1000);  // 6h 缓存
                return final;
            } catch (e) {
                SGIS.tagRecsError = e.message || '标签推荐获取失败';
                return [];
            } finally {
                SGIS.tagRecsLoading = false;
            }
        }

        // ---- 渲染类型扩展推荐区块 HTML ----
        function renderTagRecsSection() {
            if (!IS_MORELIKE) return '';
            const o = SGIS.overview;
            if (!o || !o.sourceTagIds || !o.sourceTagIds.length) return '';

            // 加载中 - FEAT-014 TASK-008: 经 createLoadingHtml 工厂构建
            if (SGIS.tagRecsLoading && !SGIS.tagRecs) {
                return `<div class="sgis-section">
                    <div class="sgis-section-title">${SGIS_ICONS.tag} 同类型游戏 <span style="font-size:11px;color:var(--sgis-text-2);font-weight:400">(按标签扩展)</span></div>
                    <div class="sgis-tagrec-loading">${(typeof createLoadingHtml === 'function') ? createLoadingHtml('正在从 Steam 标签 API 拉取同类型游戏…', 24) : '正在从 Steam 标签 API 拉取同类型游戏…'}</div>
                </div>`;
            }
            // 加载失败 - FEAT-014 TASK-008: 经 emptyHtml 工厂构建
            if (SGIS.tagRecsError && !SGIS.tagRecs) {
                return `<div class="sgis-section">
                    <div class="sgis-section-title">${SGIS_ICONS.tag} 同类型游戏</div>
                    <div class="sgis-sim-empty">${(typeof emptyHtml === 'function') ? emptyHtml('⚠ ' + SGIS.tagRecsError, { icon: '⚠' }) : '⚠ ' + SGIS.tagRecsError}</div>
                </div>`;
            }
            const recs = SGIS.tagRecs;
            if (!recs || !recs.length) return '';

            // 标签切换栏
            const activeTag = SGIS.activeTagId || recs[0].tagId;
            SGIS.activeTagId = activeTag;
            const tabsHtml = recs.map(r => {
                const active = r.tagId === activeTag;
                return `<button class="sgis-tagrec-tab ${active ? 'active' : ''}" data-tagrec-tab="${r.tagId}">${r.tagName}<span class="cnt">(${r.appIds.length})</span></button>`;
            }).join('');

            // 当前标签下的游戏（需要 appid → 卡片，但只有 appid，无封面/价格）
            // FEAT-014 TASK-008: 经 renderGameView 工厂渲染
            const activeRec = recs.find(r => r.tagId === activeTag);
            if (!activeRec) return '';
            const limit = SGIS.tagRecDisplayLimit;
            const shownIds = activeRec.appIds.slice(0, limit);
            const total = activeRec.appIds.length;

            const ds = SGIS.dynamicStore;
            const cardItems = shownIds.map(appId => {
                const status = ds && ds.owned.has(appId) ? 'owned'
                    : ds && ds.wishlist.has(appId) ? 'wishlist'
                        : ds && ds.ignored.has(appId) ? 'ignored'
                            : null;
                const tagHtml = status === 'owned'
                    ? '<span class="sgis-sim-tag sgis-sim-tag-owned">在库中</span>'
                    : status === 'wishlist'
                        ? '<span class="sgis-sim-tag sgis-sim-tag-wishlist">愿望单</span>'
                        : status === 'ignored'
                            ? '<span class="sgis-sim-tag sgis-sim-tag-ignored">已忽略</span>'
                            : '';
                return { appId, tagHtml };
            });
            const cardsHtml = (typeof renderGameView === 'function') ? renderGameView(cardItems, {
                viewMode: 'card',
                gridCls: 'sgis-sim-grid',
                cardCls: 'sgis-sim-card',
                bodyCls: 'sgis-sim-card-body',
                bareImg: true,
                imgHtml: (item) => `<div style="height:62px;background:linear-gradient(135deg,rgba(139,92,246,0.1),rgba(59,130,246,0.05));display:flex;align-items:center;justify-content:center"><span style="font-size:10px;color:var(--sgis-text-2);font-family:monospace">App ${item.appId}</span></div>`,
                bodyHtml: (item) => `${item.tagHtml}<div class="sgis-sim-card-name">AppID ${item.appId}</div><div class="sgis-sim-card-price unknown">点击查看</div>`,
                itemAttrs: (item) => ` href="https://store.steampowered.com/app/${item.appId}/" target="_blank" rel="noopener" title="AppID: ${item.appId}"`,
            }) : cardItems.map(item => `<a class="sgis-sim-card" href="https://store.steampowered.com/app/${item.appId}/" target="_blank" rel="noopener" title="AppID: ${item.appId}">${item.tagHtml}<div style="height:62px;background:linear-gradient(135deg,rgba(139,92,246,0.1),rgba(59,130,246,0.05));display:flex;align-items:center;justify-content:center"><span style="font-size:10px;color:var(--sgis-text-2);font-family:monospace">App ${item.appId}</span></div><div class="sgis-sim-card-body"><div class="sgis-sim-card-name">AppID ${item.appId}</div><div class="sgis-sim-card-price unknown">点击查看</div></div></a>`).join('');

            const moreHtml = total > limit
                ? `<div class="sgis-sim-more">该标签下 ${total} 款 · 仅展示评分较高 ${limit} 款 · <a href="https://store.steampowered.com/search/?tags=${activeTag}" target="_blank" rel="noopener">查看全部 →</a></div>`
                : `<div class="sgis-sim-more"><a href="https://store.steampowered.com/search/?tags=${activeTag}" target="_blank" rel="noopener">在 Steam 搜索该标签 →</a></div>`;

            return `<div class="sgis-section">
                <div class="sgis-section-title">${SGIS_ICONS.tag} 同类型游戏 <span style="font-size:11px;color:var(--sgis-text-2);font-weight:400">(按标签扩展)</span></div>
                <div class="sgis-tagrec-tabs">${tabsHtml}</div>
                ${cardsHtml}
                ${moreHtml}
            </div>`;
        }

        // ---- 绑定类型推荐区块事件 ----
        function bindTagRecsEvents() {
            if (!IS_MORELIKE || !SGIS.tagRecs) return;
            const body = document.getElementById('sgis-body');
            if (!body) return;
            body.querySelectorAll('[data-tagrec-tab]').forEach(btn => {
                btn.addEventListener('click', (e) => {
                    e.preventDefault();
                    SGIS.activeTagId = Number(btn.getAttribute('data-tagrec-tab'));
                    renderOverview();
                });
            });
        }

        function reviewBar(posPercent) {
            const color = posPercent >= 80 ? 'var(--sgis-green)' : posPercent >= 50 ? 'var(--sgis-amber)' : 'var(--sgis-rose)';
            return `<div style="height:5px;background:rgba(255,255,255,0.05);border-radius:3px;overflow:hidden;margin:3px 0 6px"><div style="width:${posPercent}%;height:100%;background:${color};border-radius:3px"></div></div>`;
        }

        // 共享数据 -> 渲染个人游戏状态卡片
        function renderMyGameStatus() {
            const info = getCurrentGameInfo();
            if (!info.found) {
                // v2.3.29: 显示正在检查动态数据的提示
                const checkingHint = (!SGIS.dynamicStoreOwnedApps && !SGIS.dynamicStoreFetching)
                    ? '<div style="margin-top:4px;font-size:11px;color:var(--sgis-amber)">正在检查 Steam 商店动态数据（CD Key 激活的游戏可能需要此检测）…</div>'
                    : '';
                return `<div class="sgis-section">
                    <div class="sgis-section-title">${SGIS_ICONS.library} 我的游戏库</div>
                    <div style="font-size:12px;color:var(--sgis-text-2);line-height:1.6;padding:6px 0">
                        <div>未在你的游戏库中找到此游戏。</div>
                        <div style="margin-top:4px;font-size:11px">打开导航栏【游戏库】面板,点击「刷新」按钮,即可获取完整的个人游戏库 + 家庭组共享数据。</div>
                        ${checkingHint}
                    </div>
                </div>`;
            }

            const playtimeHours = info.playtime > 0 ? (info.playtime / 60).toFixed(1) : '0';
            const acquiredTime = formatAcquiredTime(info.acquiredTime);

            // 顶部 hero (状态/分类)
            let heroClass = '', heroIcon = SGIS_ICONS.check, heroMain = '已拥有', heroSub = '';
            if (info.isOwnedByMe) {
                heroClass = '';
                heroMain = '你已拥有';
                // v2.3.29: 新增 dynamicstore / dynamicstore_api 数据源说明
                const sourceLabels = {
                    'api': 'Web API',
                    'family': '家庭组',
                    'scrape': '页面抓取',
                    'dynamicstore': '商店动态数据',
                    'dynamicstore_api': '商店动态API',
                };
                heroSub = `来源: ${sourceLabels[info._source] || '缓存'} · ${playtimeHours}h · 入库 ${acquiredTime}`;
            } else if (info.isSharedOnly) {
                heroClass = 'shared';
                heroIcon = SGIS_ICONS.share;
                heroMain = '家庭组共享';
                const sharer = info.owners.find(o => !o.isMe);
                heroSub = sharer ? `${sharer.name} 已拥有 · 共享给你 · 入库 ${acquiredTime}` : '由家庭组成员购买';
            }

            // 所有者列表 (家庭组共享 / 多成员拥有)
            let ownerListHtml = '';
            if (info.owners.length > 0) {
                ownerListHtml = `<div class="sgis-section">
                    <div class="sgis-section-title">${SGIS_ICONS.share} 家庭组购买情况</div>
                    <div class="sgis-owner-list">
                        ${info.owners.map(o => {
                            const tag = o.isMe ? '<span class="sgis-owner-tag me">你</span>'
                                              : (info.isOwnedByMe ? '' : '<span class="sgis-owner-tag sharer">共享人</span>');
                            const cls = o.isMe ? 'me' : (info.isOwnedByMe ? '' : 'sharer');
                            const avatarText = (o.name || '?').slice(0, 1).toUpperCase();
                            return `<div class="sgis-owner-item ${cls}">
                                <div class="sgis-owner-avatar">${avatarText}</div>
                                <div class="sgis-owner-info">
                                    <div class="sgis-owner-name">${o.name} ${tag}</div>
                                    ${info.acquiredTime ? `<div class="sgis-owner-time">入库 ${acquiredTime}</div>` : ''}
                                    ${o.playtime != null ? `<div class="sgis-owner-playtime">${o.playtime > 0 ? `已游玩 ${(o.playtime / 60).toFixed(1)} 小时` : '未游玩'}</div>` : ''}
                                </div>
                            </div>`;
                        }).join('')}
                    </div>
                    ${info.owners.filter(o => !o.isMe).length > 0 ? `<div style="font-size:10px;color:var(--sgis-text-2);margin-top:6px;text-align:center">
                        共 ${info.owners.length} 位家庭组成员拥有${(!SGIS.familyShareSupported || SGIS.familyShareSupported.supported !== false) ? `,${info.owners.filter(o => !o.isMe).length} 位可共享` : ''}
                    </div>` : ''}
                </div>`;
            }

            return `
                <div class="sgis-owned-hero ${heroClass}">
                    <div class="sgis-owned-icon">${heroIcon}</div>
                    <div class="sgis-owned-text-main">${heroMain}<span class="sgis-owned-text-sub">${heroSub}</span></div>
                    <a class="sgis-btn" href="https://store.steampowered.com/app/${APP_ID}/" target="_blank" rel="noopener">商店页</a>
                </div>
                ${renderFamilyShareIndicator(info)}
                ${ownerListHtml}
            `;
        }

        // ---- 获取家庭成员游玩时长 ----
        async function fetchOwnersPlaytime() {
            const apiKey = storage.getApiKey();
            if (!apiKey) return;
            if (SGIS.ownersPlaytimeFetching) return;
            const info = getCurrentGameInfo();
            if (!info.found || !info.owners.length) return;
            const ownersToFetch = info.owners.filter(o => !o.isMe && SGIS.ownersPlaytime[o.steamId] == null);
            if (!ownersToFetch.length) return;
            SGIS.ownersPlaytimeFetching = true;
            try {
                const results = {};
                await Promise.all(ownersToFetch.map(async o => {
                    try {
                        const data = await fetchJson(`https://api.steampowered.com/IPlayerService/GetOwnedGames/v0001/?key=${apiKey}&steamid=${o.steamId}&include_played_free_games=1&format=json`, { timeout: 12000 });
                        const games = data?.response?.games || [];
                        const target = games.find(g => String(g.appid) === String(APP_ID));
                        results[o.steamId] = target ? (target.playtime_forever || 0) : 0;
                    } catch {
                        results[o.steamId] = 0;
                    }
                }));
                Object.assign(SGIS.ownersPlaytime, results);
                if (SGIS.tab === 'overview') renderOverview();
            } finally {
                SGIS.ownersPlaytimeFetching = false;
            }
        }

        // ==================== v2.9.83: 在线玩家数 + 评测摘要增强 ====================
        // v2.9.112: 未上市游戏判定——未发售游戏无在线玩家/评测数据，ISteamUserStats 与
        // appreviews 接口均返回 404。提前跳过可避免无效请求与控制台重试风暴。
        // 判定依据：① 商店页原生"即将推出"区块 ② 发行日期文案含 coming soon/即将推出/TBA
        // ③ 发行日期可解析且在未来（如 2026年10月29日）
        function sgisIsComingSoon() {
            try {
                if (document.querySelector('[class*="game_area_coming_soon"]')) return true;
                const o = SGIS.overview;
                const str = String((o && o.releaseDate) || '').trim()
                    || String((document.querySelector('.release_date .date') || {}).textContent || '').trim();
                if (!str) return false;
                if (/coming soon|即将推出|即将宣布|即将发售|to be announced|\btba\b/i.test(str)) return true;
                // 中文日期 "2026 年 10 月 29 日" → "2026-10-29"；英文 "29 Oct, 2026" 由 Date.parse 直接解析
                const norm = str.replace(/(\d{4})\s*年\s*(\d{1,2})\s*月\s*(\d{1,2})\s*日?/, '$1-$2-$3').replace(/,/g, ' ');
                const ts = Date.parse(norm);
                return Number.isFinite(ts) && ts > Date.now();
            } catch { return false; }
        }
        // 获取当前在线玩家数 (ISteamUserStats/GetNumberOfCurrentPlayers/v1)
        // 5秒超时,失败/超时不显示在线玩家区块
        async function fetchCurrentPlayers() {
            // v2.9.112: 已有数据/加载中/已判定不可用（含未上市）则直接跳过
            if (SGIS.currentPlayers !== null || SGIS.currentPlayersLoading || SGIS.currentPlayersUnavailable) return;
            if (sgisIsComingSoon()) {
                SGIS.currentPlayersUnavailable = true;
                return;
            }
            SGIS.currentPlayersLoading = true;
            try {
                const url = `https://api.steampowered.com/ISteamUserStats/GetNumberOfCurrentPlayers/v1/?appid=${APP_ID}`;
                const data = await sglvGmFetchRetry(url, { timeout: 5000, retries: 0 });
                if (data && data.response && data.response.result === 1 && data.response.player_count != null) {
                    SGIS.currentPlayers = { count: data.response.player_count };
                } else {
                    SGIS.currentPlayers = null; // 无数据,隐藏区块
                    SGIS.currentPlayersUnavailable = true; // v2.9.112: 无数据负缓存,不再随重渲染重试
                }
            } catch (e) {
                console.warn('[SGIS] fetchCurrentPlayers failed:', e.message);
                SGIS.currentPlayers = null; // 超时/错误,隐藏区块
                SGIS.currentPlayersUnavailable = true; // v2.9.112: 404/超时负缓存,本会话不再重试
            } finally {
                SGIS.currentPlayersLoading = false;
                if (SGIS.tab === 'overview') renderOverview();
            }
        }

        // 获取评测摘要 (store.steampowered.com/appreviews/{appid})
        // 返回总体+近期好评率、评测数、评测描述
        async function fetchReviewSummary() {
            // v2.9.112: 未上市游戏无评测数据(appreviews 404)，与在线玩家数同步跳过；失败负缓存
            if (SGIS.reviewSummary !== null || SGIS.reviewSummaryLoading || SGIS.reviewSummaryUnavailable) return;
            if (sgisIsComingSoon()) {
                SGIS.reviewSummaryUnavailable = true;
                return;
            }
            SGIS.reviewSummaryLoading = true;
            try {
                const baseUrl = `https://store.steampowered.com/appreviews/${APP_ID}?json=1&purchase_type=all&num_per_page=0`;
                // 并发获取总体和近期评测
                const [allData, recentData] = await Promise.all([
                    sglvGmFetchRetry(baseUrl + '&language=all', { timeout: 8000, retries: 0 }),
                    sglvGmFetchRetry(baseUrl + '&language=all&filter=recent', { timeout: 8000, retries: 0 }),
                ]);
                const summary = {};
                if (allData && allData.query_summary) {
                    const qs = allData.query_summary;
                    summary.totalPositive = qs.total_positive || 0;
                    summary.totalNegative = qs.total_negative || 0;
                    summary.totalReviews = qs.total_reviews || 0;
                    summary.reviewScore = qs.review_score || 0;
                    summary.reviewScoreDesc = qs.review_score_desc || '';
                }
                if (recentData && recentData.query_summary) {
                    const rqs = recentData.query_summary;
                    summary.recentPositive = rqs.total_positive || 0;
                    summary.recentNegative = rqs.total_negative || 0;
                    summary.recentReviews = rqs.total_reviews || 0;
                    summary.recentScoreDesc = rqs.review_score_desc || '';
                }
                if (summary.totalReviews > 0) {
                    SGIS.reviewSummary = summary;
                } else {
                    SGIS.reviewSummary = null;
                    SGIS.reviewSummaryUnavailable = true; // v2.9.112: 无评测负缓存(未上市/冷启动无评测)
                }
            } catch (e) {
                console.warn('[SGIS] fetchReviewSummary failed:', e.message);
                SGIS.reviewSummary = null;
                SGIS.reviewSummaryUnavailable = true; // v2.9.112: 404/超时负缓存,本会话不再重试
            } finally {
                SGIS.reviewSummaryLoading = false;
                if (SGIS.tab === 'overview') renderOverview();
            }
        }

        // FEAT-014 TASK-002: renderOverview 拆分为数据准备 + 13 个段渲染器 + 主组装器
        // 数据准备:从 SGIS.overview / SGIS.appDetailsExtra 融合出组装所需的字段
        function prepareOverviewData() {
            if (!SGIS.overview) SGIS.overview = IS_MORELIKE ? extractMoreLikeOverview() : extractOverviewFromDOM();
            if (IS_MORELIKE && !SGIS.similarGames) {
                SGIS.similarGames = extractSimilarGames();
                annotateSimilarStatus();
            }
            const o = SGIS.overview;
            const extra = SGIS.appDetailsExtra;
            return {
                o,
                extra,
                devName: o.developer || (extra && extra.developers.length ? extra.developers.join(', ') : ''),
                pubName: o.publisher || (extra && extra.publishers.length ? extra.publishers.join(', ') : ''),
                releaseDate: o.releaseDate || (extra && extra.releaseDate) || '',
                coverUrl: o.cover || (extra && extra.headerImage) || '',
                genres: o.genres.length ? o.genres : (extra && extra.genres) || [],
                platforms: o.platforms.length ? o.platforms : (extra && extra.platforms) || [],
            };
        }

        // 段:单条评测行 (近期/全部)
        function _renderOverviewReviewRow(rev) {
            if (!rev.count) return '';
            const cls = rev.pos >= 80 ? 'pos' : rev.pos >= 50 ? 'mix' : 'neg';
            const thumb = rev.pos >= 70 ? 'up' : 'down';
            return `<div class="sgis-review-line">
                <span class="sgis-review-label">${rev.label || '评测'}</span>
                <span class="sgis-thumb ${thumb}"></span>
                <span class="sgis-review-val ${cls}">${rev.summary || ''}</span>
                <span style="color:var(--sgis-text-2);font-size:10px">${rev.count}</span>
            </div>${reviewBar(rev.pos)}`;
        }

        // 段:标签云
        function _renderOverviewTagList(tags) {
            if (!tags.length) return '<div style="color:var(--sgis-text-2);font-size:11px">无标签</div>';
            return `<div class="sgis-tag-list">${tags.map(t => `<span class="sgis-tag">${t}</span>`).join('')}</div>`;
        }

        // 段:价格行 (免费/折扣/原价三态)
        function _renderOverviewPriceRow(o) {
            const priceLabel = isZh ? '基础价格' : 'Base Price';
            if (o.isFree) {
                return `<div class="sgis-row"><span class="sgis-row-key">${priceLabel}</span><span class="sgis-row-val discount">免费</span></div>`;
            }
            if (o.discountPercent > 0) {
                return `<div class="sgis-row"><span class="sgis-row-key">${priceLabel}</span><span class="sgis-row-val discount">${o.priceCurrent} <span class="sgis-price-discount">-${o.discountPercent}%</span><div class="sgis-row-key" style="text-decoration:line-through;margin-top:2px">${o.priceOriginal}</div></span></div>`;
            }
            if (o.priceCurrent) {
                return `<div class="sgis-row"><span class="sgis-row-key">${priceLabel}</span><span class="sgis-row-val">${o.priceCurrent}</span></div>`;
            }
            return '';
        }

        // 段:快捷链接 (Steam/SteamDB/Card Exch./卡牌市场)
        function _renderOverviewLinksRow() {
            return `<div class="sgis-links">
                <a class="sgis-link" href="https://store.steampowered.com/app/${APP_ID}/" target="_blank" rel="noopener">Steam</a>
                <a class="sgis-link" href="https://steamdb.info/app/${APP_ID}/" target="_blank" rel="noopener">SteamDB</a>
                <a class="sgis-link" href="https://www.steamcardexchange.net/index.php?gamepage-appid-${APP_ID}" target="_blank" rel="noopener">Card Exch.</a>
                <a class="sgis-link" href="https://steamcommunity.com/market/search?appid=753&category_753_Game%5B%5D=tag_app_${APP_ID}" target="_blank" rel="noopener">卡牌市场</a>
            </div>`;
        }

        // 段:附加芯片 (Metacritic/评测数/成就/DLC/控制器/官网)
        function _renderOverviewMetaChips(extra) {
            if (!extra) return '';
            const chips = [];
            if (extra.metacritic && extra.metacritic.score) {
                const cls = extra.metacritic.score >= 75 ? 'pos' : extra.metacritic.score >= 50 ? 'warn' : 'neg';
                const url = extra.metacritic.url || '';
                const inner = `${SGIS_ICONS.star} Metacritic ${extra.metacritic.score}`;
                chips.push(url
                    ? `<a class="sgis-meta-chip ${cls}" href="${url}" target="_blank" rel="noopener" style="text-decoration:none">${inner}</a>`
                    : `<span class="sgis-meta-chip ${cls}">${inner}</span>`);
            }
            if (extra.recommendations > 0) {
                chips.push(`<span class="sgis-meta-chip">${SGIS_ICONS.barChart} ${formatBigNumber(extra.recommendations)} 评测</span>`);
            }
            if (extra.achievementsTotal > 0) {
                chips.push(`<span class="sgis-meta-chip">${SGIS_ICONS.trophy} ${extra.achievementsTotal} 成就</span>`);
            }
            if (extra.dlc.length > 0) {
                const dlcUrl = `https://store.steampowered.com/dlc/${APP_ID}/`;
                chips.push(`<a class="sgis-meta-chip" href="${dlcUrl}" target="_blank" rel="noopener" style="text-decoration:none">${SGIS_ICONS.puzzle} ${extra.dlc.length} 个 DLC</a>`);
            }
            if (extra.controllerSupport === 'full') {
                chips.push(`<span class="sgis-meta-chip pos">${SGIS_ICONS.gamepad} 完全支持控制器</span>`);
            } else if (extra.controllerSupport === 'partial') {
                chips.push(`<span class="sgis-meta-chip">${SGIS_ICONS.gamepad} 部分支持控制器</span>`);
            }
            if (extra.website) {
                chips.push(`<a class="sgis-meta-chip" href="${extra.website}" target="_blank" rel="noopener" style="text-decoration:none">${SGIS_ICONS.external} 官网</a>`);
            }
            return chips.length ? `<div style="display:flex;flex-wrap:wrap;gap:5px;margin-top:8px">${chips.join('')}</div>` : '';
        }

        // 段:年龄徽章 + 免费标识
        function _renderOverviewAgeBadge(extra) {
            if (!extra) return '';
            const info = ageBadgeInfo(extra.requiredAge);
            let html = `<span class="sgis-age-badge ${info.cls}">${info.icon} ${info.text}</span>`;
            if (extra.isFree) {
                html += `<span class="sgis-free-badge">免费游戏</span>`;
            }
            return html;
        }

        // 段:内容描述符警告
        function _renderOverviewContentNote(extra) {
            return (extra && extra.contentDescriptors && extra.contentDescriptors.notes)
                ? `<div class="sgis-content-note">${SGIS_ICONS.shield} ${extra.contentDescriptors.notes}</div>`
                : '';
        }

        // 段:跨平台订阅状态 (PS会免/Epic赠送)
        function _renderOverviewSubStatus() {
            const badges = [];
            const appIdNum = Number(APP_ID);
            try {
                const psplusCache = cacheGet('psplus');
                if (psplusCache && Array.isArray(psplusCache) && psplusCache.includes(appIdNum)) {
                    badges.push(`<span class="sgis-sub-badge" style="background:rgba(59,130,246,0.15);color:#3b82f6;border:1px solid rgba(59,130,246,0.25)">${ICONS.playstation} ${isZh ? 'PS会免' : 'PS Plus'}</span>`);
                }
            } catch (e) { /* ignore */ }
            try {
                const epicCache = cacheGet('epic');
                if (epicCache && Array.isArray(epicCache) && epicCache.includes(appIdNum)) {
                    badges.push(`<span class="sgis-sub-badge" style="background:var(--sglv-accent-bg);color:var(--sglv-accent);border:1px solid var(--sglv-accent-border)">${ICONS.epic} ${isZh ? 'Epic赠送' : 'Epic Free'}</span>`);
                }
            } catch (e) { /* ignore */ }
            return badges.length ? `<div class="sgis-sub-status">${badges.join('')}</div>` : '';
        }

        // 段:DLC 列表
        function _renderOverviewDlcList(extra) {
            if (!extra || !extra.dlc.length) return '';
            const dlcNames = SGIS.dlcNames || {};
            const items = extra.dlc.map(dlcId => {
                const info = dlcNames[dlcId];
                const nameClass = info && info.name ? '' : 'loading';
                const nameText = info && info.name ? info.name : '加载中…';
                const url = `https://store.steampowered.com/app/${dlcId}/`;
                return `<a class="sgis-dlc-item" href="${url}" target="_blank" rel="noopener" title="DLC AppID: ${dlcId}">
                    <span class="sgis-dlc-id">${dlcId}</span>
                    <span class="sgis-dlc-name ${nameClass}">${nameText}</span>
                    ${info && info.isFree ? '<span class="sgis-package-flag free">免费</span>' : ''}
                    <span class="sgis-dlc-arrow">→</span>
                </a>`;
            }).join('');
            const dlcAllUrl = `https://store.steampowered.com/dlc/${APP_ID}/`;
            return `<div class="sgis-section">
                <div class="sgis-section-title">${SGIS_ICONS.puzzle} DLC 列表 (${extra.dlc.length})</div>
                <div class="sgis-dlc-list">${items}</div>
                <a class="sgis-link" href="${dlcAllUrl}" target="_blank" rel="noopener" style="margin-top:6px;display:inline-block;font-size:11px">查看全部 DLC →</a>
            </div>`;
        }

        // 段:支持语言
        function _renderOverviewLanguages(extra) {
            if (!extra || !extra.supportedLanguages || !extra.supportedLanguages.list.length) return '';
            const langs = extra.supportedLanguages.list;
            const shown = langs.slice(0, 12).map(l =>
                `<span class="sgis-lang-pill ${l.audio ? 'audio' : ''}" title="${l.audio ? '具有完全音频支持' : '仅界面文字'}">${l.name}${l.audio ? ' ♪' : ''}</span>`
            ).join('');
            const more = langs.length > 12 ? `<span class="sgis-lang-more">+${langs.length - 12}</span>` : '';
            const noteHtml = extra.supportedLanguages.note
                ? `<div style="margin-top:5px;font-size:10px;color:var(--sgis-text-2);line-height:1.4">♪ ${extra.supportedLanguages.note}</div>`
                : '';
            return `<div class="sgis-section">
                <div class="sgis-section-title">${SGIS_ICONS.globe} 支持语言 (${langs.length})</div>
                <div class="sgis-lang-list">${shown}${more}</div>
                ${noteHtml}
            </div>`;
        }

        // 段:预告片
        function _renderOverviewMovies(extra) {
            if (!extra || !extra.movies.length) return '';
            const storeUrl = `https://store.steampowered.com/app/${APP_ID}/`;
            const items = extra.movies.map(m => {
                const playIcon = `<svg viewBox="0 0 24 24" fill="currentColor"><polygon points="5 3 19 12 5 21 5 3"/></svg>`;
                const streamUrl = m.hls_h264 || m.dash_h264 || m.dash_av1 || '';
                const titleParts = [m.name];
                if (streamUrl) titleParts.push(`\n流媒体: ${streamUrl}\n(需 VLC/mpv 等播放器打开)`);
                return `<a class="sgis-movie-item" href="${storeUrl}" target="_blank" rel="noopener" title="${titleParts.join('\n').replace(/"/g, '&quot;')}">
                    <img data-src="${m.thumbnail}" alt="${m.name}" loading="lazy" onerror="this.style.display='none'">
                    <div class="sgis-movie-play">${playIcon}</div>
                    <div class="sgis-movie-name">${m.name}</div>
                </a>`;
            }).join('');
            return `<div class="sgis-section">
                <div class="sgis-section-title">${SGIS_ICONS.video} 预告片 (${extra.movies.length})</div>
                <div class="sgis-movie-grid">${items}</div>
                <div style="margin-top:5px;font-size:10px;color:var(--sgis-text-2);line-height:1.4">点击缩略图在 Steam 商店页观看 · 悬停可查看流媒体清单 URL</div>
            </div>`;
        }

        // 段:游戏特性 (分类标签, 工坊高亮)
        function _renderOverviewCategories(extra) {
            if (!extra || !extra.categories.length) return '';
            const pills = extra.categories.map(c => {
                const isWorkshop = c.id === 30 || /创意工坊|steam\s*workshop/i.test(c.description);
                return `<span class="sgis-category-pill ${isWorkshop ? 'highlight' : ''}" title="分类 ID: ${c.id}">${c.description}</span>`;
            }).join('');
            return `<div class="sgis-section">
                <div class="sgis-section-title">${SGIS_ICONS.tag} 游戏特性</div>
                <div class="sgis-category-list">${pills}</div>
            </div>`;
        }

        // 段:购买选项 (捆绑包)
        function _renderOverviewPackages(extra) {
            if (!extra || !extra.packages.length) return '';
            if (extra.packages.length === 1 && !extra.packages[0].discount) return '';
            const items = extra.packages.map(p => {
                const flagHtml = p.isFree
                    ? '<span class="sgis-package-flag free">免费</span>'
                    : (p.discount > 0 ? `<span class="sgis-package-flag discount">-${p.discount}%</span>` : '');
                const priceHtml = p.isFree
                    ? '<span class="sgis-package-price free">免费</span>'
                    : (p.priceText ? `<span class="sgis-package-price">${p.priceText}</span>` : '');
                return `<div class="sgis-package-item">
                    ${flagHtml}
                    <span class="sgis-package-name">${p.name}</span>
                    ${priceHtml}
                </div>`;
            }).join('');
            return `<div class="sgis-section">
                <div class="sgis-section-title">${SGIS_ICONS.package} 购买选项</div>
                <div class="sgis-package-list">${items}</div>
            </div>`;
        }

        // 段:游戏截图 (3 列网格, 最多 9 张)
        function _renderOverviewScreenshots(extra) {
            if (!extra || !extra.screenshots.length) return '';
            const items = extra.screenshots.map(s => `
                <a class="sgis-screenshot-item" href="${s.full}" target="_blank" rel="noopener">
                    <img data-src="${s.thumbnail}" alt="截图" loading="lazy"
                         onload="this.classList.add('loaded')"
                         onerror="this.parentNode.style.display='none'">
                </a>`).join('');
            return `<div class="sgis-section">
                <div class="sgis-section-title">${SGIS_ICONS.image} 游戏截图</div>
                <div class="sgis-screenshot-grid">${items}</div>
            </div>`;
        }

        // 段:在线玩家数 (仅在数据可用时显示)
        function _renderOverviewCurrentPlayers() {
            const cp = SGIS.currentPlayers;
            if (!cp || cp.count == null) return '';
            const countStr = cp.count >= 1000 ? (cp.count / 1000).toFixed(1) + 'k' : String(cp.count);
            return `<div class="sgis-section" style="display:flex;align-items:center;gap:10px;padding:8px 12px">
                <span style="font-size:16px">${SGIS_ICONS.users || '👥'}</span>
                <div style="flex:1">
                    <div style="font-size:13px;font-weight:600;color:#4ade80">${countStr} ${isZh ? '人正在游玩' : 'in-game now'}</div>
                    <div style="font-size:10px;color:var(--sgis-text-2)">${isZh ? '当前在线玩家数' : 'Current players'}</div>
                </div>
                <span style="width:8px;height:8px;border-radius:50%;background:#4ade80;box-shadow:0 0 6px #4ade80;animation:sgis-pulse 2s infinite"></span>
            </div>`;
        }

        // 段:评测摘要增强 (DOM + API 合并)
        function _renderOverviewReviewSummary(o) {
            const rs = SGIS.reviewSummary;
            const hasDomReviews = o.reviews.recent.count || o.reviews.all.count;
            if (!hasDomReviews && !rs) return '';
            // API 评测摘要
            let apiReviewHtml = '';
            if (rs && rs.totalReviews > 0) {
                const posRate = rs.totalReviews > 0 ? Math.round(rs.totalPositive / rs.totalReviews * 100) : 0;
                const cls = posRate >= 80 ? 'pos' : posRate >= 50 ? 'mix' : 'neg';
                const thumb = posRate >= 70 ? 'up' : 'down';
                let recentHtml = '';
                if (rs.recentReviews > 0) {
                    const rPosRate = Math.round(rs.recentPositive / rs.recentReviews * 100);
                    const rCls = rPosRate >= 80 ? 'pos' : rPosRate >= 50 ? 'mix' : 'neg';
                    const rThumb = rPosRate >= 70 ? 'up' : 'down';
                    recentHtml = `<div class="sgis-review-line">
                        <span class="sgis-review-label">${isZh ? '近期' : 'Recent'}</span>
                        <span class="sgis-thumb ${rThumb}"></span>
                        <span class="sgis-review-val ${rCls}">${rs.recentScoreDesc || ''}</span>
                        <span style="color:var(--sgis-text-2);font-size:10px">${rs.recentReviews.toLocaleString()}</span>
                    </div>${reviewBar(rPosRate)}`;
                }
                apiReviewHtml = `<div class="sgis-review-line">
                    <span class="sgis-review-label">${isZh ? '全部' : 'All'}</span>
                    <span class="sgis-thumb ${thumb}"></span>
                    <span class="sgis-review-val ${cls}">${rs.reviewScoreDesc || ''}</span>
                    <span style="color:var(--sgis-text-2);font-size:10px">${rs.totalReviews.toLocaleString()} ${isZh ? '篇评测' : 'reviews'}</span>
                </div>${reviewBar(posRate)}${recentHtml}`;
            }
            // DOM 评测 (API 未加载时)
            const domReviewHtml = apiReviewHtml ? '' : (_renderOverviewReviewRow(o.reviews.recent) + _renderOverviewReviewRow(o.reviews.all));
            return `<div class="sgis-section">
                <div class="sgis-section-title">${SGIS_ICONS.star} 评测摘要</div>
                ${apiReviewHtml || domReviewHtml}
            </div>`;
        }

        function renderOverview() {
            const d = prepareOverviewData();
            const { o, extra, devName, pubName, releaseDate, coverUrl, genres, platforms } = d;
            // 段:DRM/年龄/语音/免费等紧凑徽章
            const compactBadges = [renderDRMBadge(), renderChineseAudioBadge(), _renderOverviewAgeBadge(extra), renderProfileStatusBadge()].filter(Boolean).join('');
            const compactBadgesHtml = compactBadges
                ? `<div style="display:flex;align-items:center;flex-wrap:wrap;gap:6px;margin-top:6px">${compactBadges}</div>`
                : '';

            setBody(`
                <div class="sgis-hero">
                    ${coverUrl ? `<img class="sgis-hero-img" src="${coverUrl}" alt="" onerror="this.style.display='none'">` : ''}
                    <div class="sgis-hero-info">
                        <div class="sgis-hero-name">${o.name || ('游戏 ' + APP_ID)}</div>
                        <div class="sgis-hero-meta">
                            ${devName ? `<span class="sgis-hero-meta-pill" style="background:var(--sglv-accent-bg);border-color:var(--sglv-accent-border);color:var(--sglv-accent-light)">${SGIS_ICONS.package} 开发商 ${devName}</span>` : ''}
                            ${pubName && pubName !== devName ? `<span class="sgis-hero-meta-pill" style="background:rgba(59,130,246,0.12);border-color:rgba(59,130,246,0.22);color:#93c5fd">${SGIS_ICONS.share} 发行 ${pubName}</span>` : ''}
                            ${releaseDate ? `<span>${releaseDate}</span>` : ''}
                        </div>
                    </div>
                </div>
                ${renderMyGameStatus()}
                ${_renderOverviewSubStatus()}
                ${compactBadgesHtml}
                ${_renderOverviewContentNote(extra)}
                ${renderCrackStatusBadge()}
                ${renderWorkshopIndicator()}
                <div class="sgis-section">
                    <div class="sgis-section-title">${SGIS_ICONS.info} 基本信息</div>
                    ${_renderOverviewPriceRow(o)}
                    ${genres.length ? `<div class="sgis-row"><span class="sgis-row-key">类型</span><span class="sgis-row-val">${genres.join(' / ')}</span></div>` : ''}
                    ${(extra && extra.appType) ? `<div class="sgis-row"><span class="sgis-row-key">应用类型</span><span class="sgis-row-val">${localizeAppType(extra.appType)}</span></div>` : ''}
                    ${platforms.length ? `<div class="sgis-row"><span class="sgis-row-key">平台</span><span class="sgis-row-val">${platforms.join(' / ')}</span></div>` : ''}
                    <div class="sgis-row"><span class="sgis-row-key">AppID</span><span class="sgis-row-val">${APP_ID}</span></div>
                    ${_renderOverviewMetaChips(extra)}
                </div>
                ${_renderOverviewCategories(extra)}
                ${_renderOverviewLanguages(extra)}
                ${o.tags.length ? `<div class="sgis-section">
                    <div class="sgis-section-title">${SGIS_ICONS.info} 热门标签</div>
                    ${_renderOverviewTagList(o.tags)}
                </div>` : ''}
                ${_renderOverviewPackages(extra)}
                ${_renderOverviewDlcList(extra)}
                ${_renderOverviewMovies(extra)}
                ${_renderOverviewScreenshots(extra)}
                ${o.shortDesc ? `<div class="sgis-section"><div class="sgis-section-title">${SGIS_ICONS.info} 简介</div><div style="font-size:12px;color:var(--sgis-text);line-height:1.5">${o.shortDesc}</div></div>` : ''}
                ${_renderOverviewCurrentPlayers()}
                ${_renderOverviewReviewSummary(o)}
                ${renderSimilarGamesSection()}
                ${renderTagRecsSection()}
                <div class="sgis-section">
                    <div class="sgis-section-title">${SGIS_ICONS.info} 快捷链接</div>
                    ${_renderOverviewLinksRow()}
                </div>
            `);
            // 副作用:截图/预告片懒加载 + 事件绑定
            document.querySelectorAll('#sgis-body .sgis-screenshot-item img[data-src]').forEach(img => {
                img.src = img.dataset.src;
            });
            document.querySelectorAll('#sgis-body .sgis-movie-item img[data-src]').forEach(img => {
                img.src = img.dataset.src;
            });
            bindSimilarGamesEvents();
            bindTagRecsEvents();
            // 副作用:morelike 类型扩展推荐 (不阻塞首屏)
            if (IS_MORELIKE && o.sourceTagIds && o.sourceTagIds.length && !SGIS.tagRecs && !SGIS.tagRecsLoading) {
                fetchTagRecommendations(o.sourceTagIds).then(recs => {
                    SGIS.tagRecs = recs;
                    if (SGIS.tab === 'overview') renderOverview();
                }).catch(() => {});
            }
            // 副作用:家庭成员游玩时长 (不阻塞)
            fetchOwnersPlaytime().catch(() => {});
            // 副作用:在线玩家数 + 评测摘要 (超时/失败则隐藏)
            if (HAS_APP_ID) {
                fetchCurrentPlayers().catch(() => {});
                fetchReviewSummary().catch(() => {});
            }
            // 副作用:dynamicstore/userdata API 回退
            if (HAS_APP_ID && !SGIS.dynamicStoreOwnedApps && !SGIS.dynamicStoreFetching) {
                const info = getCurrentGameInfo();
                if (!info.found) {
                    fetchDynamicStoreUserData().then(ownedApps => {
                        if (ownedApps && ownedApps.has(Number(APP_ID)) && SGIS.tab === 'overview') {
                            renderOverview();
                        }
                    }).catch(() => {});
                }
            }
        }

        // ---- 勋章标签 ----
        // v2.9.77: 重写卡牌获取流程 — 移除有缺陷的社区登录前置检测,
        // 改为直接请求市场数据 + SGLVBadge 多重降级检测卡牌支持状态。
        // 旧版 checkCommunityLogin 误判 (网络超时/页面结构变更/Cloudflare) 会导致
        // "Steam 社区未登录" 错误提示, 但 Steam 账户已登录即社区已登录, 不存在此问题。

        // v2.9.77: 获取 SGLVBadge 库实例 (sglv-badge.lib.js)
        function _getBadgeLib() {
            return (typeof unsafeWindow !== 'undefined' && unsafeWindow.SGLVBadge)
                || (typeof window !== 'undefined' && window.SGLVBadge);
        }

        // v2.9.77: 将主脚本已加载的 SteamCardExchange 卡牌数据库注入 SGLVBadge,
        // 使 L2 检测免额外网络请求 (复用 loadCardDatabase 的 24h 缓存)
        function _injectCardDbToBadgeLib() {
            const B = _getBadgeLib();
            if (B && typeof B.setCardDb === 'function' && cardDbData) {
                B.setCardDb(cardDbData);
            }
        }

        function renderMedals() {
            if (SGIS.cardsLoading) return;
            if (SGIS.cards) { renderMedalsContent(); return; }
            SGIS.cardsLoading = true;
            renderLoading('正在获取集换式卡牌价格…');

            // v2.9.77: 注入卡牌数据库, 直接请求市场数据 (无登录前置阻断)
            _injectCardDbToBadgeLib();

            fetchCardPrices(APP_ID).then(data => {
                const allCards = [...(data.regular || []), ...(data.foil || [])];
                if (allCards.length === 0) {
                    // 市场返回 0 张卡牌 — 检查游戏是否实际支持卡牌 (可能是市场 API 问题)
                    _handleEmptyMarketCards();
                } else {
                    SGIS.cards = data;
                    SGIS.cardsLoading = false;
                    renderMedalsContent();
                }
            }).catch(e => {
                // 市场请求失败 — 检查游戏是否支持卡牌, 区分网络错误 vs 无卡牌
                _handleCardFetchError(e);
            });
        }

        // v2.9.77: 市场返回 0 卡牌 — 多重降级检测卡牌支持状态
        async function _handleEmptyMarketCards() {
            const B = _getBadgeLib();
            if (!B || typeof B.checkCardSupport !== 'function') {
                // 库未加载 — 显示"无卡牌"消息 (保守处理)
                SGIS.cards = { regular: [], foil: [], _source: 'market-empty' };
                SGIS.cardsLoading = false;
                renderMedalsContent();
                return;
            }
            renderLoading('正在检测卡牌支持状态…');
            try {
                const categories = (SGIS.appDetailsExtra && SGIS.appDetailsExtra.categories) || [];
                const support = await B.checkCardSupport(APP_ID, { categories });
                if (support.supported) {
                    // 游戏有卡牌但市场未返回 — 使用 SCE 降级数据
                    _renderSCEFallback(support, 'empty');
                } else {
                    // 游戏不支持卡牌
                    SGIS.cards = { regular: [], foil: [], _source: 'no-cards' };
                    SGIS.cardsLoading = false;
                    renderMedalsContent();
                }
            } catch (e) {
                SGIS.cards = { regular: [], foil: [], _source: 'market-empty' };
                SGIS.cardsLoading = false;
                renderMedalsContent();
            }
        }

        // v2.9.77: 市场请求失败 — 多重降级检测卡牌支持状态
        async function _handleCardFetchError(error) {
            const B = _getBadgeLib();
            if (!B || typeof B.checkCardSupport !== 'function') {
                // 库未加载 — 显示网络错误 (不再误判为"社区未登录")
                SGIS.cardsLoading = false;
                renderError('卡牌价格获取失败: ' + error.message);
                return;
            }
            renderLoading('正在检测卡牌支持状态…');
            try {
                const categories = (SGIS.appDetailsExtra && SGIS.appDetailsExtra.categories) || [];
                const support = await B.checkCardSupport(APP_ID, { categories });
                if (support.supported) {
                    // 游戏有卡牌但市场请求失败 — 使用 SCE 降级数据
                    _renderSCEFallback(support, 'error', error.message);
                } else if (support.source === 'none') {
                    // 无法确定是否支持卡牌 — 显示网络错误
                    SGIS.cardsLoading = false;
                    setBody(`<div class="sgis-state">
                        <div style="font-size:36px;margin-bottom:8px">⚠️</div>
                        <div>网络错误,无法获取卡牌数据</div>
                        <div style="font-size:11px;color:var(--sgis-text-2);margin-top:4px">${error.message}</div>
                        <div style="font-size:11px;color:var(--sgis-text-2);margin-top:4px">请检查网络连接后重试</div>
                    </div>`);
                } else {
                    // 游戏不支持卡牌
                    SGIS.cards = { regular: [], foil: [], _source: 'no-cards' };
                    SGIS.cardsLoading = false;
                    renderMedalsContent();
                }
            } catch (e) {
                SGIS.cardsLoading = false;
                renderError('卡牌价格获取失败: ' + error.message);
            }
        }

        // v2.9.77: 使用 SteamCardExchange 降级数据渲染卡牌信息 (无价格数据)
        async function _renderSCEFallback(support, reason, errorMsg) {
            const B = _getBadgeLib();
            let sceData = null;

            // 如果 checkCardSupport 已返回页面数据 (L3), 直接使用
            if (support.cards && support.cards.regular) {
                sceData = support.cards;
            } else {
                // 否则单独获取 SCE 页面数据
                try {
                    const pageData = await B.fetchCardExchangePage(APP_ID);
                    if (pageData && pageData.supported) {
                        sceData = { regular: pageData.regular, foil: pageData.foil };
                    }
                } catch (e) {
                    // SCE 页面也获取失败
                    SGIS.cardsLoading = false;
                    if (reason === 'error') {
                        renderError('卡牌价格获取失败: ' + (errorMsg || ''));
                    } else {
                        SGIS.cards = { regular: [], foil: [], _source: 'market-empty' };
                        renderMedalsContent();
                    }
                    return;
                }
            }

            if (!sceData || (!sceData.regular.length && !sceData.foil.length)) {
                SGIS.cards = { regular: [], foil: [], _source: 'no-cards' };
                SGIS.cardsLoading = false;
                renderMedalsContent();
                return;
            }

            // 构造兼容 renderMedalsContent 的数据结构
            SGIS.cards = {
                regular: sceData.regular || [],
                foil: sceData.foil || [],
                regularQueried: false,
                foilQueried: false,
                _source: 'steamcardexchange',
                _reason: reason,         // 'empty' 或 'error'
                _errorMsg: errorMsg || '',
                _supportSource: support.source,
            };
            SGIS.cardsLoading = false;
            renderMedalsContent();
        }
        function renderMedalsContent() {
            const data = SGIS.cards;
            // v2.9.77: SCE 降级数据 — 有卡牌名称但无价格, 走专用渲染
            if (data._source === 'steamcardexchange') {
                renderMedalsSCEContent(data);
                return;
            }
            const allCards = [...(data.regular || []), ...(data.foil || [])];
            if (allCards.length === 0) {
                // v2.9.77: 区分"确认无卡牌"和"市场返回空(未检测)"
                const isConfirmedNoCards = data._source === 'no-cards';
                setBody(`<div class="sgis-state">
                    <div style="font-size:36px;margin-bottom:8px">🎴</div>
                    <div>${isConfirmedNoCards ? '该游戏没有可交易的集换式卡牌' : '未获取到卡牌数据'}</div>
                    <div style="font-size:11px;color:var(--sgis-text-2);margin-top:4px">${isConfirmedNoCards ? '可能不支持 Steam 集换式卡牌' : '可能是网络问题或该游戏不支持卡牌,请重试'}</div>
                </div>`);
                return;
            }
            // 从卡牌价格文本中提取用户钱包货币符号 (如 ¥ ₹ $ 等)，避免硬编码 CNY
            const samplePriceText = allCards.find(c => c.sellPriceText)?.sellPriceText || '';
            const curSymbol = (samplePriceText.match(/^([^\d.,\s]+)/) || [])[1] || '¥';
            // sellPrice/buyPrice 都是最小单位 (分), 显示时 /100 换算到主单位
            const sellTotal = (data.regular || []).reduce((s, c) => s + (c.sellPrice || 0), 0) / 100;
            const foilSellTotal = (data.foil || []).reduce((s, c) => s + (c.sellPrice || 0), 0) / 100;
            const buyTotal = (data.regular || []).reduce((s, c) => s + (c.buyPrice || 0), 0) / 100;
            const netTotal = (data.regular || []).reduce((s, c) => s + (c.netPrice || 0), 0) / 100;
            // v2.9.31: 计算中位数和忽略最高价均价 (借鉴 Trading Card Info 脚本统计模式)
            const regPrices = (data.regular || []).filter(c => c.sellPrice != null).map(c => c.sellPrice).sort((a, b) => a - b);
            let medianPrice = 0, avgNoMax = 0;
            if (regPrices.length > 0) {
                const mid = Math.floor(regPrices.length / 2);
                medianPrice = regPrices.length % 2 !== 0 ? regPrices[mid] : Math.round((regPrices[mid - 1] + regPrices[mid]) / 2);
                if (regPrices.length > 1) {
                    avgNoMax = Math.round(regPrices.slice(0, -1).reduce((s, p) => s + p, 0) / (regPrices.length - 1));
                } else {
                    avgNoMax = regPrices[0];
                }
            }
            const medianDisplay = medianPrice > 0 ? `${curSymbol}${(medianPrice / 100).toFixed(2)}` : '—';
            const avgNoMaxDisplay = avgNoMax > 0 ? `${curSymbol}${(avgNoMax / 100).toFixed(2)}` : '—';
            const showing = SGIS.medalTab;
            const cards = showing === 'foil' ? (data.foil || []) : (data.regular || []);
            const cardItemHtml = (c) => {
                const sellMajor = toMajorUnit(c.sellPrice);
                const buyMajor = toMajorUnit(c.buyPrice);
                // 显示价格: 优先用 Steam 给的本地化文本, 其次用数值 (转主单位)
                const sellDisplay = c.sellPriceText || (sellMajor != null ? curSymbol + sellMajor.toFixed(2) : '');
                const buyDisplay = c.buyPrice != null ? curSymbol + buyMajor.toFixed(2) : (c.buyError ? '—' : '');
                // v2.3.1: 卡牌图作为背景 (勋章页面), 缩略图同时保留; 失败时用精美 SVG 兜底
                // 由于 CSS background-image 加载失败无事件, 用一个隐藏的 img 预加载检测, 成功后才启用背景
                const iconHtml = c.iconUrl
                    ? `<img class="sgis-card-icon" src="${c.iconUrl}" alt="" loading="lazy" data-bg-url="${c.iconUrl}" onerror="this.classList.add('sgis-icon-failed');this.outerHTML='<div class=&quot;sgis-card-icon sgis-card-icon-fallback&quot;>${SGIS_ICONS.medalFallback}</div>'">`
                    : `<div class="sgis-card-icon sgis-card-icon-fallback">${SGIS_ICONS.medalFallback}</div>`;
                // 卡牌图作为背景: 仅当有 iconUrl 时启用, 加载失败时移除 sgis-card-with-bg
                const hasBg = !!c.iconUrl;
                return `<a class="sgis-card-item ${hasBg ? 'sgis-card-pending-bg' : ''}" href="${c.marketUrl}" target="_blank" rel="noopener" data-bg-url="${c.iconUrl || ''}">
                    ${iconHtml}
                    <div class="sgis-card-info">
                        <div class="sgis-card-name">${c.name.replace(/\(Foil\)$/i, '').trim()}${c.foil ? '<span class="sgis-card-badge foil">闪</span>' : ''}</div>
                        <div class="sgis-card-prices">
                            ${sellDisplay ? `<span class="sell">出售 ${sellDisplay}</span>` : ''}
                            ${buyDisplay ? `<span class="buy">求购 ${buyDisplay}</span>` : ''}
                        </div>
                    </div>
                    ${c.listings ? `<span style="font-size:10px;color:var(--sgis-text-2);white-space:nowrap;margin-left:4px">${c.listings}件</span>` : ''}
                </a>`;
            };
            setBody(`
                <div class="sgis-card-summary">
                    <div class="sgis-card-stat sell">
                        <div class="sgis-card-stat-val">${curSymbol}${sellTotal.toFixed(2)}</div>
                        <div class="sgis-card-stat-lbl">普通出售合计</div>
                    </div>
                    <div class="sgis-card-stat net">
                        <div class="sgis-card-stat-val">${curSymbol}${netTotal.toFixed(2)}</div>
                        <div class="sgis-card-stat-lbl">到手价合计</div>
                    </div>
                    <div class="sgis-card-stat buy">
                        <div class="sgis-card-stat-val">${curSymbol}${buyTotal.toFixed(2)}</div>
                        <div class="sgis-card-stat-lbl">求购合计</div>
                    </div>
                </div>
                <div class="sgis-section">
                    <div class="sgis-row"><span class="sgis-row-key">中位价 (抗极端高价)</span><span class="sgis-row-val">${medianDisplay}</span></div>
                    <div class="sgis-row"><span class="sgis-row-key">均价 (忽略最高价)</span><span class="sgis-row-val">${avgNoMaxDisplay}</span></div>
                </div>
                <div class="sgis-card-toggle">
                    <button data-group="regular" class="${showing === 'regular' ? 'active' : ''}">普通卡 (${(data.regular || []).length})</button>
                    <button data-group="foil" class="${showing === 'foil' ? 'active' : ''}">闪卡 (${(data.foil || []).length})</button>
                </div>
                <div class="sgis-section">
                    <div class="sgis-section-title">${SGIS_ICONS.card} ${showing === 'foil' ? '闪卡' : '普通卡'} 列表</div>
                    ${cards.length ? cards.map(cardItemHtml).join('') : '<div style="color:var(--sgis-text-2);font-size:11px;text-align:center;padding:10px">无此类卡牌</div>'}
                </div>
                ${(data.foil || []).length ? `<div class="sgis-section"><div class="sgis-section-title">${SGIS_ICONS.info} 闪卡市场</div>
                    <div class="sgis-row"><span class="sgis-row-key">闪卡出售合计</span><span class="sgis-row-val">${curSymbol}${foilSellTotal.toFixed(2)}</span></div>
                    <div class="sgis-row"><span class="sgis-row-key">闪卡数量</span><span class="sgis-row-val">${data.foil.length}</span></div>
                </div>` : ''}
                <div style="font-size:10px;color:var(--sgis-text-2);text-align:center;margin-top:8px">
                    出价数据来自 Steam 社区市场 · ${data.regularQueried ? '已查询' : '查询中'} · v2.9.32 到手价采用可变发行商费率精确计算
                </div>
            `);
            const body = document.getElementById('sgis-body');
            if (body) {
                body.querySelectorAll('.sgis-card-toggle button').forEach(btn => {
                    btn.addEventListener('click', () => {
                        SGIS.medalTab = btn.dataset.group;
                        renderMedalsContent();
                    });
                });
                // v2.3.1: 异步预加载卡牌图, 成功则启用背景图, 失败则保持默认(不显示背景, 用 SVG 兜底已生效)
                body.querySelectorAll('.sgis-card-pending-bg[data-bg-url]').forEach(card => {
                    const url = card.dataset.bgUrl;
                    if (!url) return;
                    const probe = new Image();
                    probe.onload = () => {
                        // 加载成功, 启用背景图 + 切换 class
                        card.style.setProperty('--sgis-card-bg', `url('${url}')`);
                        card.classList.remove('sgis-card-pending-bg');
                        card.classList.add('sgis-card-with-bg');
                    };
                    probe.onerror = () => {
                        // 加载失败, 移除待定状态, 保持纯缩略图 (fallback SVG)
                        card.classList.remove('sgis-card-pending-bg');
                    };
                    probe.src = url;
                });
            }
        }

        // v2.9.77: SteamCardExchange 降级渲染 — 有卡牌名称但无价格数据
        // 当市场 API 失败或返回空, 但 SGLVBadge 确认游戏有卡牌时使用
        function renderMedalsSCEContent(data) {
            const showing = SGIS.medalTab;
            const cards = showing === 'foil' ? (data.foil || []) : (data.regular || []);
            const regCount = (data.regular || []).length;
            const foilCount = (data.foil || []).length;
            const reasonText = data._reason === 'error'
                ? `市场数据获取失败(${data._errorMsg || '网络错误'})`
                : '市场未返回卡牌数据';
            const sourceText = data._supportSource === 'appdetails' ? 'Steam 应用详情'
                : data._supportSource === 'steamcardexchange-api' ? 'SteamCardExchange API'
                : data._supportSource === 'steamcardexchange-page' ? 'SteamCardExchange 页面'
                : '卡牌数据库';

            const cardItemHtml = (c) => {
                const iconHtml = `<div class="sgis-card-icon sgis-card-icon-fallback">${SGIS_ICONS.medalFallback}</div>`;
                return `<a class="sgis-card-item" href="${c.marketUrl}" target="_blank" rel="noopener">
                    ${iconHtml}
                    <div class="sgis-card-info">
                        <div class="sgis-card-name">${c.name.replace(/\(Foil\)$/i, '').trim()}${c.foil ? '<span class="sgis-card-badge foil">闪</span>' : ''}</div>
                        <div class="sgis-card-prices">
                            <span style="font-size:10px;color:var(--sgis-text-3)">价格数据不可用</span>
                        </div>
                    </div>
                </a>`;
            };

            setBody(`
                <div class="sgis-section" style="background:rgba(251,191,36,0.08);border:1px solid rgba(251,191,36,0.2);border-radius:8px;padding:10px 12px;margin-bottom:10px">
                    <div style="font-size:12px;color:#fbbf24;font-weight:600;margin-bottom:4px">⚠️ ${reasonText}</div>
                    <div style="font-size:11px;color:var(--sgis-text-2)">卡牌列表来自 ${sourceText} · 市场价格需访问 Steam 社区市场获取</div>
                </div>
                <div class="sgis-card-summary">
                    <div class="sgis-card-stat sell">
                        <div class="sgis-card-stat-val">${regCount}</div>
                        <div class="sgis-card-stat-lbl">普通卡</div>
                    </div>
                    <div class="sgis-card-stat buy">
                        <div class="sgis-card-stat-val">${foilCount}</div>
                        <div class="sgis-card-stat-lbl">闪卡</div>
                    </div>
                    <div class="sgis-card-stat net">
                        <div class="sgis-card-stat-val">${regCount + foilCount}</div>
                        <div class="sgis-card-stat-lbl">总计</div>
                    </div>
                </div>
                <div class="sgis-card-toggle">
                    <button data-group="regular" class="${showing === 'regular' ? 'active' : ''}">普通卡 (${regCount})</button>
                    <button data-group="foil" class="${showing === 'foil' ? 'active' : ''}">闪卡 (${foilCount})</button>
                </div>
                <div class="sgis-section">
                    <div class="sgis-section-title">${SGIS_ICONS.card} ${showing === 'foil' ? '闪卡' : '普通卡'} 列表</div>
                    ${cards.length ? cards.map(cardItemHtml).join('') : '<div style="color:var(--sgis-text-2);font-size:11px;text-align:center;padding:10px">无此类卡牌</div>'}
                </div>
                <div style="font-size:10px;color:var(--sgis-text-2);text-align:center;margin-top:8px">
                    <a class="sgis-link" href="https://www.steamcardexchange.net/index.php?gamepage-appid-${APP_ID}" target="_blank" rel="noopener">查看 SteamCardExchange 详情</a>
                    · <a class="sgis-link" href="https://steamcommunity.com/market/search?appid=753&category_Game=app_${APP_ID}" target="_blank" rel="noopener">Steam 市场</a>
                </div>
            `);
            const body = document.getElementById('sgis-body');
            if (body) {
                body.querySelectorAll('.sgis-card-toggle button').forEach(btn => {
                    btn.addEventListener('click', () => {
                        SGIS.medalTab = btn.dataset.group;
                        renderMedalsContent();
                    });
                });
            }
        }

        // ---- 价格标签 (多地区价格 + ITAD 历史价格 + AI预测) ----
        function appendHistoryPricesToBody(historyData) {
            const bodyEl = document.getElementById('sgis-body');
            if (!bodyEl || SGIS.tab !== 'prices') return;
            // v2.9.82: 历史价格数据为空/加载失败时仍渲染 AI 预测按钮 (置灰状态)
            const hasData = !!(historyData && (historyData.history?.length || historyData.lowest || historyData.discounts?.length));
            if (hasData) {
                const temp = document.createElement('div');
                temp.innerHTML = renderHistoryPricesSection(historyData);
                while (temp.firstChild) bodyEl.appendChild(temp.firstChild);
                // v2.9.9: 绑定价格图表时间范围按钮事件
                bindPriceChartRangeEvents(historyData);
            }
            // 追加 AI 预测按钮 (有数据=可点击, 无数据=置灰)
            appendPredictButton(bodyEl, hasData);
            // 追加已有预测结果
            if (SGIS.prediction) appendPredictionResult(bodyEl);
        }
        function appendPredictButton(bodyEl, hasHistoryData) {
            const enabledModes = storage.getPredictModes();
            const modesLabel = enabledModes.map(m => {
                const mode = PREDICT_MODES.find(p => p.key === m);
                return mode ? mode.name : '';
            }).filter(Boolean).join(' / ');
            // v2.9.82: 无历史价格数据时按钮置灰 + 提示文案
            const disabled = !hasHistoryData;
            const disabledText = isZh ? '暂无历史价格数据,无法AI预测' : 'No price history, AI prediction unavailable';
            const btnHtml = `<div class="sgis-section" style="margin-top:8px">
                <button class="sgis-predict-btn" id="sgis-predict-trigger"${disabled ? ' disabled' : ''} style="${disabled ? 'opacity:0.45;cursor:not-allowed' : ''}">
                    <svg ${_S}><path d="M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z"/><path d="M12 22V12"/><path d="M3.27 6.96L12 12.01l8.73-5.05"/></svg>
                    ${disabled ? disabledText : `${T.aiPredictBtn}${modesLabel ? `（${modesLabel}）` : ''}`}
                </button>
                ${SGIS.predictionLoading ? `<div class="sgis-state" id="sgis-predict-loading" style="padding:12px"><div class="sgis-spinner" style="width:20px;height:20px"></div>${T.aiPredicting}</div>` : ''}
                ${SGIS.predictionError ? `<div class="sgis-state sgis-error" style="padding:8px">⚠️ ${T.aiPredictFail}: ${SGIS.predictionError}</div>` : ''}
            </div>`;
            const temp = document.createElement('div');
            temp.innerHTML = btnHtml;
            while (temp.firstChild) bodyEl.appendChild(temp.firstChild);
            const btn = document.getElementById('sgis-predict-trigger');
            if (btn && !disabled) {
                btn.addEventListener('click', () => triggerPrediction());
            }
        }
        function triggerPrediction() {
            // v2.9.82: 防重复点击 + 完整日志 + 超时保护 + 按钮等待状态
            if (SGIS.predictionLoading) {
                console.log('[SGIS] AI预测已在进行中, 忽略重复点击');
                return;
            }
            if (!SGIS.historyPrices || (!SGIS.historyPrices.discounts?.length && !SGIS.historyPrices.history?.length)) {
                console.log('[SGIS] AI预测取消: 无历史价格数据');
                showToast(T.aiPredictNoData);
                return;
            }
            const apiKey = storage.getAiApiKey();
            if (!apiKey) {
                console.log('[SGIS] AI预测取消: 未配置 API Key');
                showToast(T.aiPredictNoKey);
                return;
            }

            console.log('[SGIS] AI预测按钮点击, 开始流程');
            SGIS.predictionLoading = true;
            SGIS.predictionError = null;
            SGIS.prediction = null;

            // 按钮置于等待状态
            const btn = document.getElementById('sgis-predict-trigger');
            if (btn) {
                btn.disabled = true;
                btn.style.opacity = '0.5';
                btn.style.cursor = 'wait';
                btn.innerHTML = `<div class="sgis-spinner" style="width:14px;height:14px;display:inline-block;vertical-align:middle;margin-right:6px"></div>${T.aiPredicting}`;
            }

            // 插入loading区域
            let loadingEl = document.getElementById('sgis-predict-loading');
            if (!loadingEl) {
                const bodyEl = document.getElementById('sgis-body');
                if (bodyEl) {
                    loadingEl = document.createElement('div');
                    loadingEl.id = 'sgis-predict-loading';
                    loadingEl.className = 'sgis-state';
                    loadingEl.style.cssText = 'padding:12px';
                    loadingEl.innerHTML = `<div class="sgis-spinner" style="width:20px;height:20px"></div>${T.aiPredicting}`;
                    bodyEl.appendChild(loadingEl);
                }
            }

            // 获取当前价格信息
            const overview = SGIS.overview || {};
            const currentPrice = overview.priceCurrent ? parseFloat(overview.priceCurrent.replace(/[^0-9.]/g, '')) : null;
            const originalPrice = overview.priceOriginal ? parseFloat(overview.priceOriginal.replace(/[^0-9.]/g, '')) : null;
            const gameName = overview.name || '';

            // v2.9.82: 超时保护 (120s, 比 callAiApi 的 90s 稍长, 覆盖提示词加载时间)
            let timeoutReached = false;
            const timeoutId = setTimeout(() => {
                if (SGIS.predictionLoading) {
                    timeoutReached = true;
                    console.warn('[SGIS] AI预测超时 (120s无响应)');
                    SGIS.predictionLoading = false;
                    const ld = document.getElementById('sgis-predict-loading');
                    if (ld) ld.remove();
                    if (btn) {
                        btn.disabled = false;
                        btn.style.opacity = '';
                        btn.style.cursor = '';
                        btn.innerHTML = `<svg ${_S}><path d="M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z"/><path d="M12 22V12"/><path d="M3.27 6.96L12 12.01l8.73-5.05"/></svg> ${T.aiPredictBtn}`;
                    }
                    const bodyEl = document.getElementById('sgis-body');
                    if (bodyEl) {
                        const errDiv = document.createElement('div');
                        errDiv.className = 'sgis-state sgis-error';
                        errDiv.style.cssText = 'padding:8px';
                        errDiv.textContent = `⚠️ ${T.aiPredictFail}: ${isZh ? '请求超时(120s无响应), 请检查网络或API配置' : 'Request timeout (120s), check network or API config'}`;
                        bodyEl.appendChild(errDiv);
                    }
                }
            }, 120000);

            callAiPricePredict(SGIS.historyPrices, gameName, APP_ID, currentPrice, originalPrice)
                .then(result => {
                    clearTimeout(timeoutId);
                    if (timeoutReached) return; // 超时已处理, 丢弃结果
                    console.log('[SGIS] AI预测成功, result:', result);
                    SGIS.prediction = result;
                    SGIS.predictionLoading = false;
                    // 移除loading
                    const ld = document.getElementById('sgis-predict-loading');
                    if (ld) ld.remove();
                    if (btn) {
                        btn.disabled = false;
                        btn.style.opacity = '';
                        btn.style.cursor = '';
                        btn.innerHTML = `<svg ${_S}><path d="M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z"/><path d="M12 22V12"/><path d="M3.27 6.96L12 12.01l8.73-5.05"/></svg> ${T.aiPredictBtn}`;
                    }
                    // 追加结果
                    const bodyEl = document.getElementById('sgis-body');
                    if (bodyEl) appendPredictionResult(bodyEl);
                })
                .catch(e => {
                    clearTimeout(timeoutId);
                    if (timeoutReached) return; // 超时已处理, 丢弃错误
                    console.error('[SGIS] AI预测失败:', e);
                    SGIS.predictionError = e.message;
                    SGIS.predictionLoading = false;
                    const ld = document.getElementById('sgis-predict-loading');
                    if (ld) ld.remove();
                    if (btn) {
                        btn.disabled = false;
                        btn.style.opacity = '';
                        btn.style.cursor = '';
                        btn.innerHTML = `<svg ${_S}><path d="M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z"/><path d="M12 22V12"/><path d="M3.27 6.96L12 12.01l8.73-5.05"/></svg> ${T.aiPredictBtn}`;
                    }
                    const bodyEl = document.getElementById('sgis-body');
                    if (bodyEl) {
                        const errDiv = document.createElement('div');
                        errDiv.className = 'sgis-state sgis-error';
                        errDiv.style.cssText = 'padding:8px';
                        errDiv.textContent = `⚠️ ${T.aiPredictFail}: ${e.message}`;
                        bodyEl.appendChild(errDiv);
                    }
                });
        }
        function appendPredictionResult(bodyEl) {
            if (!SGIS.prediction) return;
            const temp = document.createElement('div');
            temp.innerHTML = renderPredictionSection(SGIS.prediction);
            while (temp.firstChild) bodyEl.appendChild(temp.firstChild);
        }
        function renderPredictionSection(prediction) {
            const models = prediction.models || [];
            const bestBuy = prediction.best_buy || {};
            const enabledModes = storage.getPredictModes();
            const modesLabel = enabledModes.map(m => {
                const mode = PREDICT_MODES.find(p => p.key === m);
                return mode ? mode.name : '';
            }).filter(Boolean).join(' / ');

            const modelsHtml = models.map(m => {
                const confClass = m.confidence >= 70 ? 'high' : (m.confidence >= 45 ? 'mid' : 'low');
                const dateStr = m.target_date ? new Date(m.target_date).toLocaleDateString('zh-CN') : '—';
                const saleBadge = m.sale_event ? `<span class="sgis-predict-sale seasonal">${m.sale_event}</span>` : '';
                const indicatorsHtml = m.indicators ? Object.entries(m.indicators).map(([k, v]) => `<div>${k}: <b>${v}</b></div>`).join('') : '';
                return `<div class="sgis-predict-model">
                    <div class="sgis-predict-model-title">
                        <span>${m.mode_name || m.mode}</span>
                        <span class="sgis-predict-model-conf ${confClass}">${T.aiPredictConfidence} ${m.confidence}%</span>
                    </div>
                    <div class="sgis-predict-detail">
                        <div>${m.prediction || ''}</div>
                        <div style="margin-top:4px">
                            预测折扣: <span class="sgis-predict-price">-${m.discount_percent || 0}%</span>
                            · 到手: <span class="sgis-predict-price">${m.currency || ''}${m.predicted_price != null ? Number(m.predicted_price).toFixed(2) : '—'}</span>
                            · 时间: <span class="sgis-predict-date">${m.days_until != null ? m.days_until + T.aiPredictDays : '—'}${dateStr !== '—' ? ` (${dateStr})` : ''}</span>
                            ${saleBadge}
                        </div>
                        ${m.detail ? `<div style="margin-top:4px;color:var(--sgis-text-2)">${m.detail}</div>` : ''}
                        ${indicatorsHtml ? `<div style="margin-top:4px;font-size:10px;color:var(--sgis-text-2)">${indicatorsHtml}</div>` : ''}
                    </div>
                </div>`;
            }).join('');

            const urgencyLabel = bestBuy.urgency === 'high' ? '🔴 尽快入手' : (bestBuy.urgency === 'medium' ? '🟡 可以等待' : '🟢 不急');
            const bestBuyHtml = bestBuy.recommendation ? `<div class="sgis-predict-rec">
                <div style="font-weight:700;margin-bottom:4px">${T.aiPredictRecommendation} · ${urgencyLabel}</div>
                <div>${bestBuy.recommendation}</div>
                ${bestBuy.best_time ? `<div style="margin-top:4px">${T.aiPredictBestTime}: <b>${bestBuy.best_time}</b></div>` : ''}
                ${bestBuy.best_price ? `<div>预测最佳价格: <b>${Number(bestBuy.best_price).toFixed(2)}</b></div>` : ''}
                ${bestBuy.wait_days != null ? `<div>建议等待: <b>${bestBuy.wait_days}天</b></div>` : ''}
            </div>` : '';

            return `<div class="sgis-predict-section">
                <div class="sgis-section-title">${SGIS_ICONS.trend || '🔮'} ${T.aiPredictResult}</div>
                ${modelsHtml}
                ${bestBuyHtml}
                <div class="sgis-predict-modes-label">分析模式: ${modesLabel}</div>
            </div>`;
        }
        // v2.9.79: ITAD 增强模式 — 将 ITAD 区域价格归一化为现有格式
        function normalizeItadRegionPrices(regionPrices) {
            const prices = [];
            const failed = [];
            const seenKey = new Set();
            for (const [country, data] of Object.entries(regionPrices)) {
                if (!data || !data.deals || !data.deals.length) {
                    failed.push({ region: country, error: 'ITAD 无数据' });
                    continue;
                }
                const deal = data.deals[0]; // 取最优价格
                const priceObj = deal.price || {};
                const regularObj = deal.regular || {};
                // v2.9.102: 期望币种防脏检查 —— ITAD 返回币种与 REGIONS 期望币种不匹配时计入 failed(复用既有跳过语义)
                const expCur = (REGIONS.find(r => r.code === country) || {}).currency;
                if (expCur && priceObj.currency && priceObj.currency !== expCur) {
                    // v2.9.103: 记录被跳过的脏数据,便于观察 ITAD 币种口径变化(如 AR 官方币种切换)
                    console.debug(`[SGLV] ITAD 币种不匹配 ${country}: 期望 ${expCur}, 实际 ${priceObj.currency}, 跳过该区域`);
                    failed.push({ region: country, error: `币种不匹配(期望${expCur}, 实际${priceObj.currency})` });
                    continue;
                }
                const k = `${priceObj.currency}:${Number(priceObj.amount || 0).toFixed(2)}`;
                if (seenKey.has(k)) { failed.push({ region: country, error: '与已有地区价格重复' }); continue; }
                seenKey.add(k);
                prices.push({
                    region: country,
                    price: priceObj.amount || 0,
                    currency: priceObj.currency || '',
                    discount: deal.cut || 0,
                    initial: regularObj.amount || 0,
                    source: 'itad',
                });
            }
            return { prices, failed };
        }

        // v2.9.79: ITAD 增强模式 — 多商店比价 + 活跃 Bundle 展示
        function appendItadOverviewToBody() {
            const overview = SGIS.itadOverview;
            if (!overview || !overview.prices.length) return;
            const num = (v) => { const n = Number(v); return isNaN(n) ? 0 : n; };
            const fmt = (v) => num(v).toFixed(2);
            const item = overview.prices[0]; // 单游戏
            // 多商店比价表 (from overview.current)
            let storeCompareHtml = '';
            if (item.current) {
                const cur = item.current;
                const curPrice = cur.price || {};
                const curRegular = cur.regular || {};
                const curCut = cur.cut || 0;
                const isLowest = item.lowest && curPrice.amount <= (item.lowest.price || {}).amount;
                const cny = convertToCNY(num(curPrice.amount), curPrice.currency); // v2.9.101: 桥接层统一折算（原 CNY 直返/rateReady 判空语义不变）
                storeCompareHtml = `<div class="sgis-section">
                    <div class="sgis-section-title">${SGIS_ICONS.price} ${isZh ? '最优商店价格' : 'Best Store Price'} ${isLowest ? '<span class="sgis-price-tbl-badge-low">史低</span>' : ''}</div>
                    <div class="sgis-row"><span class="sgis-row-key">${isZh ? '商店' : 'Store'}</span><span class="sgis-row-val">${(cur.shop || {}).name || '—'}</span></div>
                    <div class="sgis-row"><span class="sgis-row-key">${isZh ? '当前价' : 'Current'}</span><span class="sgis-row-val discount">${fmt(curPrice.amount)} ${curPrice.currency || ''} ${curCut > 0 ? '<span class="sgis-price-discount">-' + curCut + '%</span>' : ''}</span></div>
                    ${curCut > 0 ? `<div class="sgis-row"><span class="sgis-row-key">${isZh ? '原价' : 'Regular'}</span><span class="sgis-row-val" style="text-decoration:line-through;color:var(--sgis-text-2)">${fmt(curRegular.amount)} ${curRegular.currency || ''}</span></div>` : ''}
                    ${cny != null ? `<div class="sgis-row"><span class="sgis-row-key">≈ CNY</span><span class="sgis-row-val" style="color:#66c0f4;font-weight:700">¥${fmt(cny)}</span></div>` : ''}
                </div>`;
            }
            // 历史最低 (from overview.lowest)
            let histLowHtml = '';
            if (item.lowest) {
                const low = item.lowest;
                const lowPrice = low.price || {};
                const lowCny = convertToCNY(num(lowPrice.amount), lowPrice.currency); // v2.9.101: 桥接层统一折算
                const lowDate = low.timestamp ? new Date(low.timestamp).toLocaleDateString(isZh ? 'zh-CN' : 'en-US') : '—';
                histLowHtml = `<div class="sgis-row"><span class="sgis-row-key">${isZh ? '历史最低' : 'Historical Low'}</span><span class="sgis-row-val discount">${fmt(lowPrice.amount)} ${lowPrice.currency || ''} ${low.cut ? '(-' + low.cut + '%)' : ''} · ${(low.shop || {}).name || ''} · ${lowDate}</span></div>`;
                if (lowCny != null) histLowHtml += `<div class="sgis-row"><span class="sgis-row-key">≈ CNY</span><span class="sgis-row-val" style="color:#c0a050;font-weight:600">¥${fmt(lowCny)}</span></div>`;
            }
            // 活跃 Bundle
            let bundleHtml = '';
            if (overview.bundles && overview.bundles.length) {
                const bundleItems = overview.bundles.map(b => {
                    const tier = b.tiers && b.tiers[0];
                    const tierPrice = tier && tier.price ? tier.price : {};
                    const gameCount = b.tiers ? b.tiers.reduce((s, t) => s + (t.games ? t.games.length : 0), 0) : 0;
                    const cny = convertToCNY(num(tierPrice.amount), tierPrice.currency); // v2.9.101: 桥接层统一折算
                    return `<div class="sgis-row"><span class="sgis-row-key">${b.title || 'Bundle'}</span><span class="sgis-row-val">${tierPrice.amount ? fmt(tierPrice.amount) + ' ' + (tierPrice.currency || '') : '—'}${cny != null ? ' · ≈¥' + fmt(cny) : ''}${gameCount ? ' · ' + gameCount + (isZh ? '款' : ' games') : ''}</span></div>`;
                }).join('');
                bundleHtml = `<div class="sgis-section">
                    <div class="sgis-section-title">${SGIS_ICONS.trend} ${isZh ? '活跃 Bundle' : 'Active Bundles'} (${overview.bundles.length})</div>
                    ${bundleItems}
                </div>`;
            }
            // ITAD 增强标识
            const badge = `<div style="font-size:9px;color:#a7d54f;text-align:center;margin-top:4px;padding:3px 8px;background:rgba(167,213,79,0.06);border-radius:4px;">⚡ ${isZh ? 'ITAD 增强模式' : 'ITAD Enhanced'} · ${isZh ? '数据来自 IsThereAnyDeal API' : 'Data from IsThereAnyDeal API'}</div>`;
            const body = document.getElementById('sgis-body');
            if (body) body.insertAdjacentHTML('beforeend', storeCompareHtml + histLowHtml + bundleHtml + badge);
        }

        function renderPrices() {
            if (SGIS.pricesLoading) return;
            if (SGIS.prices) {
                renderPricesContent();
                if (SGIS.itadOverview) appendItadOverviewToBody();
                appendHistoryPricesToBody(SGIS.historyPrices);
                appendGiftRecommendationToBody();
                return;
            }
            SGIS.pricesLoading = true;

            // v2.9.79: ITAD 增强模式 (用户配置了 ITAD Key 时启用)
            const useItadEnhanced = _itad && storage.getItadApiKey() && _itad.hasApiKey();

            if (useItadEnhanced) {
                renderLoading(isZh ? '正在获取 ITAD 增强价格…' : 'Fetching ITAD enhanced prices…');
                refreshRates().catch(() => {});
                (async () => {
                    try {
                        const itadId = await _itad.lookupItadId(APP_ID);
                        if (!itadId) throw new Error('ITAD lookup 失败');
                        // 并行: 价格概览(多商店+史低+Bundle) + 多区域Steam价格(15+区域)
                        const [overview, regionPrices] = await Promise.all([
                            _itad.fetchPriceOverview([itadId], { country: 'US' }),
                            _itad.fetchMultiRegionPrices(itadId, EXTENDED_REGIONS, { shops: [_itad.SHOP_STEAM], concurrency: 3 }),
                        ]);
                        // 归一化区域价格为现有格式
                        const normalized = normalizeItadRegionPrices(regionPrices);
                        SGIS.prices = Object.assign(normalized, { ratesReady: SGIS.rateReady });
                        SGIS.itadOverview = overview;
                        renderPricesContent();
                        appendItadOverviewToBody();
                        SGIS.giftRec = calculateGiftRecommendation(SGIS.prices);
                        appendGiftRecommendationToBody();
                        // 异步获取历史价格
                        fetchHistoryPrices(APP_ID).then(historyData => {
                            SGIS.historyPrices = historyData;
                            appendHistoryPricesToBody(historyData);
                        }).catch(() => {
                            // v2.9.82: 历史价格加载失败时仍渲染 AI 预测按钮 (置灰)
                            appendHistoryPricesToBody(null);
                        });
                    } catch (e) {
                        console.warn('[SGIS] ITAD 增强失败, 回退基础模式:', e.message);
                        // 回退到基础模式 (AugmentedSteam + Steam appdetails)
                        fetchMultiRegionPrices(APP_ID)
                            .then(priceData => {
                                SGIS.prices = Object.assign(priceData, { ratesReady: SGIS.rateReady });
                                renderPricesContent();
                                SGIS.giftRec = calculateGiftRecommendation(SGIS.prices);
                                appendGiftRecommendationToBody();
                                fetchHistoryPrices(APP_ID).then(historyData => {
                                    SGIS.historyPrices = historyData;
                                    appendHistoryPricesToBody(historyData);
                                }).catch(() => {
                                    // v2.9.82: 历史价格加载失败时仍渲染 AI 预测按钮 (置灰)
                                    appendHistoryPricesToBody(null);
                                });
                            })
                            .catch(err => renderError(isZh ? '价格获取失败: ' + err.message : 'Price fetch failed: ' + err.message));
                    } finally {
                        SGIS.pricesLoading = false;
                    }
                })();
            } else {
                // 基础模式 (原有逻辑)
                renderLoading(isZh ? '正在获取多地区价格…' : 'Fetching multi-region prices…');
                refreshRates().catch(() => {});
                fetchMultiRegionPrices(APP_ID)
                    .then(priceData => {
                        SGIS.prices = Object.assign(priceData, { ratesReady: SGIS.rateReady });
                        renderPricesContent();
                        SGIS.giftRec = calculateGiftRecommendation(SGIS.prices);
                        appendGiftRecommendationToBody();
                        fetchHistoryPrices(APP_ID).then(historyData => {
                            SGIS.historyPrices = historyData;
                            appendHistoryPricesToBody(historyData);
                        }).catch(() => {
                            // v2.9.82: 历史价格加载失败时仍渲染 AI 预测按钮 (置灰)
                            appendHistoryPricesToBody(null);
                        });
                    })
                    .catch(e => renderError(isZh ? '价格获取失败: ' + e.message : 'Price fetch failed: ' + e.message))
                    .finally(() => { SGIS.pricesLoading = false; });
            }
        }
        function renderPricesContent() {
            const data = SGIS.prices;
            const userRegion = (document.cookie.match(/steamCountry=(\w{2})/) || [])[1] || 'CN';
            if (!data.prices || !data.prices.length) {
                const failText = data.failed && data.failed.length
                    ? data.failed.map(f => `${f.region}: ${f.error}`).slice(0, 5).join(' / ')
                    : '未知原因';
                setBody(`<div class="sgis-state">
                    <div style="font-size:36px;margin-bottom:8px">💱</div>
                    <div>未获取到任何地区的价格数据</div>
                    <div style="font-size:10px;color:var(--sgis-text-2);margin-top:8px;padding:0 20px;line-height:1.5;text-align:left">失败: ${failText}</div>
                    <div style="font-size:11px;color:var(--sgis-text-2);margin-top:12px">可能是 Steam 限流或网络问题,稍后重试</div>
                </div>`);
                return;
            }
            // v2.3.7: 安全数值转换 (修复 price?.toFixed is not a function, Aug API 可能返回字符串)
            const num = (v) => { const n = Number(v); return isNaN(n) ? 0 : n; };
            const fmt = (v) => num(v).toFixed(2);
            const enriched = data.prices.map(p => {
                const safePrice = num(p.price);
                const cny = convertToCNY(safePrice, p.currency); // v2.9.101: 桥接层统一折算（缺汇率返回 null，下方 filter 自然生效）
                const info = REGIONS.find(r => r.code === p.region) || { name: p.region, code: p.region };
                return Object.assign({}, p, {
                    price: safePrice,
                    initial: num(p.initial),
                    discount: num(p.discount),
                    cny: cny != null ? num(cny) : null,
                    regionName: info,
                });
            }).filter(p => p.cny != null && p.currency !== 'FREE' && p.price > 0);
            if (!enriched.length) {
                setBody(`<div class="sgis-state">
                    <div style="font-size:36px;margin-bottom:8px">💱</div>
                    <div>未获取到有效的价格数据 (${data.prices.length} 个地区失败)</div>
                </div>`);
                return;
            }
            enriched.sort((a, b) => a.cny - b.cny);
            const lowest = enriched[0];
            const highest = enriched[enriched.length - 1];
            // 旗帜图: 用 flagcdn.com, 加载失败 fallback 到文本代码
            const flagHtml = (p) => {
                const url = flagUrl(p.region);
                return `<img class="sgis-price-flag" src="${url}" alt="${p.region}" title="${p.regionName.name} (${p.region})" loading="lazy" onerror="this.replaceWith((function(el){const s=document.createElement('span');s.className='sgis-price-code';s.textContent='${p.region}';return s;})())">`;
            };
            // 顶部 featured card (最低价特别展示)
            const lowestDiscount = lowest.discount > 0
                ? `<span class="sgis-price-featured-discount">-${lowest.discount}%</span>`
                : '';
            const lowestOriginal = lowest.discount > 0
                ? `<span class="sgis-price-featured-original">${fmt(lowest.initial)}</span>`
                : '';
            const featuredHtml = `
                <div class="sgis-price-featured">
                    <img class="sgis-price-featured-img" src="${flagUrl(lowest.region)}" alt="${lowest.region}" loading="lazy" onerror="this.style.visibility='hidden'">
                    <div class="sgis-price-featured-info">
                        <div class="sgis-price-featured-region">
                            ${lowest.regionName.name} <span class="sgis-price-code" style="font-size:10px;color:#a4d007">${lowest.region}</span>
                        </div>
                        <div style="margin-top:2px;font-size:11px;color:var(--sgis-text-2)">
                            ${lowestOriginal}${fmt(lowest.price)} ${lowest.currency}${lowestDiscount}
                            <span class="sgis-price-featured-cny">≈ ¥${fmt(lowest.cny)}</span>
                        </div>
                    </div>
                </div>
            `;
            // v2.8.0: 完整对比表格（区域名称 | 原价 | 折后价 | 折扣率 | 换算后CNY价格）
            // 按换算后CNY价格升序，最低价高亮绿色，最高价标记红色
            const priceTableRowHtml = (p) => {
                const isUser = p.region === userRegion;
                const isLowest = p.region === lowest.region;
                const isHighest = p.region === highest.region && enriched.length > 1;
                const rowCls = isLowest ? 'sgis-price-tbl-row-lowest' : (isHighest ? 'sgis-price-tbl-row-highest' : '');
                const userTag = isUser ? '<span class="sgis-user-tag">本区</span>' : '';
                const badge = isLowest ? '<span class="sgis-price-tbl-badge-low">最低</span>' : (isHighest ? '<span class="sgis-price-tbl-badge-high">最高</span>' : '');
                const discountCell = p.discount > 0
                    ? `<span class="sgis-price-discount">-${p.discount}%</span>`
                    : '<span style="color:var(--sgis-text-2)">—</span>';
                const initialCell = p.discount > 0
                    ? `<span class="sgis-price-original">${fmt(p.initial)}</span>`
                    : `<span style="color:var(--sgis-text-2)">—</span>`;
                return `<div class="sgis-price-tbl-row ${rowCls} ${isUser ? 'user-region' : ''}">
                    <div class="sgis-price-tbl-cell sgis-price-tbl-region">
                        ${flagHtml(p)}
                        <span class="sgis-price-region">${p.regionName.name} ${userTag}${badge}</span>
                    </div>
                    <div class="sgis-price-tbl-cell sgis-price-tbl-initial">${initialCell}</div>
                    <div class="sgis-price-tbl-cell sgis-price-tbl-price">${fmt(p.price)} <span style="font-size:9px;color:var(--sgis-text-2)">${p.currency}</span></div>
                    <div class="sgis-price-tbl-cell sgis-price-tbl-discount">${discountCell}</div>
                    <div class="sgis-price-tbl-cell sgis-price-tbl-cny">¥${fmt(p.cny)}</div>
                </div>`;
            };
            // v2.8.0: 当前区域价格 vs 历史最低价对比
            const userPrice = enriched.find(p => p.region === userRegion);
            let historyCompareHtml = '';
            if (SGIS.historyPrices && SGIS.historyPrices.lowest && userPrice) {
                const histLow = SGIS.historyPrices.lowest;
                const histCny = convertToCNY(num(histLow.price), histLow.currency); // v2.9.101: 桥接层统一折算
                if (histCny != null) {
                    const diff = userPrice.cny - num(histCny);
                    const diffPct = (diff / userPrice.cny) * 100;
                    const isHigher = diff > 0;
                    historyCompareHtml = `<div class="sgis-section">
                        <div class="sgis-section-title">${SGIS_ICONS.trend} 当前价格 vs 历史最低</div>
                        <div class="sgis-row"><span class="sgis-row-key">本区当前</span><span class="sgis-row-val">¥${fmt(userPrice.cny)}</span></div>
                        <div class="sgis-row"><span class="sgis-row-key">历史最低</span><span class="sgis-row-val discount">¥${fmt(histCny)}${histLow.cut ? ` (-${histLow.cut}%)` : ''}</span></div>
                        <div class="sgis-row"><span class="sgis-row-key">价差</span><span class="sgis-row-val ${isHigher ? '' : 'discount'}">${isHigher ? '↑' : '↓'} ¥${fmt(Math.abs(diff))} (${Math.abs(diffPct).toFixed(1)}%)</span></div>
                    </div>`;
                }
            }
            const sources = [...new Set(enriched.map(p => p.source))];
            const sourceText = sources.map(s => s === 'aug' ? 'AugmentedSteam' : s === 'steam' ? 'Steam 官方' : s).join(' + ');
            setBody(`
                <div class="sgis-section">
                    <div class="sgis-section-title">${SGIS_ICONS.price} 多地区低价排行</div>
                    ${featuredHtml}
                </div>
                <div class="sgis-section">
                    <div class="sgis-section-title">${SGIS_ICONS.barChart} 9区完整价格对比</div>
                    <div class="sgis-price-tbl">
                        <div class="sgis-price-tbl-header">
                            <div class="sgis-price-tbl-cell sgis-price-tbl-region">区域</div>
                            <div class="sgis-price-tbl-cell sgis-price-tbl-initial">原价</div>
                            <div class="sgis-price-tbl-cell sgis-price-tbl-price">折后价</div>
                            <div class="sgis-price-tbl-cell sgis-price-tbl-discount">折扣</div>
                            <div class="sgis-price-tbl-cell sgis-price-tbl-cny">CNY</div>
                        </div>
                        ${enriched.map(priceTableRowHtml).join('')}
                    </div>
                </div>
                ${historyCompareHtml}
                <div class="sgis-section">
                    <div class="sgis-section-title">${SGIS_ICONS.info} 比价概览</div>
                    <div class="sgis-row"><span class="sgis-row-key">最低价</span><span class="sgis-row-val discount">¥${fmt(lowest.cny)} (${lowest.regionName.name})</span></div>
                    <div class="sgis-row"><span class="sgis-row-key">最高价</span><span class="sgis-row-val">¥${fmt(highest.cny)} (${highest.regionName.name})</span></div>
                    <div class="sgis-row"><span class="sgis-row-key">价差幅度</span><span class="sgis-row-val">¥${fmt(highest.cny - lowest.cny)} (${((highest.cny - lowest.cny) / lowest.cny * 100).toFixed(1)}%)</span></div>
                    <div class="sgis-row"><span class="sgis-row-key">本地区</span><span class="sgis-row-val">${userRegion}${userPrice ? ` · ¥${fmt(userPrice.cny)}` : ''}</span></div>
                    <div class="sgis-row"><span class="sgis-row-key">有效价格</span><span class="sgis-row-val">${enriched.length} / ${PRIORITY_REGIONS.length} 区</span></div>
                    <div class="sgis-row"><span class="sgis-row-key">失败/重复</span><span class="sgis-row-val">${(data.failed || []).length}</span></div>
                    <div class="sgis-row"><span class="sgis-row-key">数据源</span><span class="sgis-row-val">${sourceText}</span></div>
                </div>
                <div style="font-size:10px;color:var(--sgis-text-2);text-align:center;margin-top:8px">
                    旗帜来自 flagcdn.com · 价格仅供参考 · 3并发+1s限速
                </div>
            `);
        }

        // ---- v2.9.9: DRM 警告检测 (参考 Steam_Buff drm-warning.js) ----
        // 检测 Denuvo 等第三方 DRM, 从 DOM 和 appdetails 描述中扫描
        function detectDRM() {
            if (SGIS.drmInfo) return SGIS.drmInfo;
            const results = [];
            // 1. DOM 扫描: 购买区域和游戏描述区域
            const purchaseSections = document.querySelectorAll('.game_area_purchase_game, .game_area_description, .game_details');
            const drmPatterns = [
                { regex: /denuvo/i, label: 'Denuvo Anti-Tamper', severity: 'warn' },
                { regex: /securom/i, label: 'SecuROM', severity: 'warn' },
                { regex: /games for windows live|GFWL/i, label: 'Games for Windows Live', severity: 'warn' },
                { regex: /uplay/i, label: 'Ubisoft Connect (Uplay)', severity: 'info' },
                { regex: /rockstar.*launcher|RGL/i, label: 'Rockstar Launcher', severity: 'info' },
                { regex: /ea.*app|origin.*client/i, label: 'EA App', severity: 'info' },
                { regex: /bethesda.*launcher/i, label: 'Bethesda Launcher', severity: 'info' },
                { regex: /3rd.party.drm|third.party.drm/i, label: '第三方 DRM', severity: 'warn' },
            ];
            const found = new Set();
            purchaseSections.forEach(sec => {
                const text = sec.textContent || '';
                drmPatterns.forEach(p => {
                    if (p.regex.test(text) && !found.has(p.label)) {
                        found.add(p.label);
                        results.push({ label: p.label, severity: p.severity });
                    }
                });
            });
            // 2. appdetails 缓存补充检测
            const extra = SGIS.appDetailsExtra;
            if (extra && extra.contentDescriptors && extra.contentDescriptors.notes) {
                const notes = extra.contentDescriptors.notes;
                if (/denuvo/i.test(notes) && !found.has('Denuvo Anti-Tamper')) {
                    results.push({ label: 'Denuvo Anti-Tamper', severity: 'warn' });
                }
            }
            SGIS.drmInfo = { list: results, hasDRM: results.length > 0 };
            return SGIS.drmInfo;
        }

        // ---- v2.11.31: 统一徽章检测段渲染器 (FEAT-014 TASK-007) ----
        // 6 类检测徽章共用 1 个段渲染器,类型配置注入图标/文案/状态
        // 支持三类状态: true (有) / false (无) / unknown (未知)
        // 6 类配置:drm / audio / profile / crack / aaa / protection
        const _DETECT_BADGE_DEFS = {
            drm: {
                iconKey: 'shield',
                cls: 'sgis-drm-badge',
                label: 'DRM',
                detect: () => {
                    const drm = (typeof detectDRM === 'function') ? detectDRM() : null;
                    if (!drm) return { state: 'unknown' };
                    if (drm.hasDRM) return { state: 'true', items: drm.list.map(x => x.label) };
                    return { state: 'false' };
                },
                render: (info) => {
                    if (info.state !== 'true' || !info.items || !info.items.length) return '';
                    return info.items.map(label => `<span class="sgis-drm-badge">${SGIS_ICONS.shield} ${label}</span>`).join('');
                },
            },
            audio: {
                iconKey: 'globe',
                cls: 'sgis-audio-badge',
                label: '中文语音',
                detect: () => {
                    const extra = (typeof SGIS !== 'undefined') ? SGIS.appDetailsExtra : null;
                    if (!extra || !extra.supportedLanguages || !extra.supportedLanguages.list.length) return { state: 'unknown' };
                    const langs = extra.supportedLanguages.list;
                    const chineseAudio = langs.find(l => /chinese|中文/i.test(l.name) && l.audio);
                    if (!chineseAudio) return { state: 'false' };
                    return { state: 'true', name: chineseAudio.name };
                },
                render: (info) => {
                    if (info.state !== 'true') return '';
                    return `<span class="sgis-audio-badge">${SGIS_ICONS.globe} ${info.name} 语音支持</span>`;
                },
            },
            profile: {
                iconKey: 'profileLimited',
                cls: 'sgis-profile-badge',
                label: '资料状态',
                detect: () => {
                    const info = (typeof detectProfileFeaturesStatus === 'function') ? detectProfileFeaturesStatus() : null;
                    if (!info) return { state: 'unknown' };
                    if (info.status === 'normal') return { state: 'false' };
                    return { state: 'true', subStatus: info.status, label: info.label };
                },
                render: (info) => {
                    if (info.state !== 'true') return '';
                    const title = info.subStatus === 'restricted'
                        ? 'Profile Features Limited：该游戏的卡片、成就、游玩时长等资料不会显示在 Steam 个人资料页'
                        : 'Steam 正在了解该游戏，部分资料功能可能暂时受限';
                    return `<span class="sgis-profile-badge ${escHtml(info.subStatus || '')}" title="${escHtml(title)}">${SGIS_ICONS.profileLimited} ${escHtml(info.label)}</span>`;
                },
            },
            crack: {
                iconKey: 'shield',
                cls: 'sgis-crack-badge',
                label: '破解状态',
                detect: () => {
                    const info = (typeof SGIS !== 'undefined') ? SGIS.gameStatusInfo : null;
                    if (!info) return { state: 'unknown' };
                    if (info.notFound) return { state: 'unknown' };
                    const status = String(info.status || '').toLowerCase();
                    let cls = '';
                    if (/cracked|взлом/.test(status)) cls = 'cracked';
                    else if (/bypass|обход|hypervisor/.test(status) || /bypass|обход/.test(String(info.hackedGroups || '').toLowerCase())) cls = 'bypass';
                    else if (/not cracked|не взлом|unbroken|unreleased/.test(status)) cls = 'not-cracked';
                    else if (/release today|релиз сегодня|выходит сегодня/.test(status)) cls = 'release-today';
                    return { state: 'true', cls, label: info.status || '未知' };
                },
                render: (info) => {
                    if (info.state !== 'true') return '';
                    return `<span class="sgis-crack-badge ${escHtml(info.cls || '')}">${SGIS_ICONS.shield} ${escHtml(info.label)}</span>`;
                },
            },
            aaa: {
                iconKey: 'shield',
                cls: 'sgis-crack-badge aaa',
                label: 'AAA',
                detect: () => {
                    const info = (typeof SGIS !== 'undefined') ? SGIS.gameStatusInfo : null;
                    if (!info || info.notFound) return { state: 'unknown' };
                    return info.isAAA ? { state: 'true' } : { state: 'false' };
                },
                render: (info) => {
                    if (info.state !== 'true') return '';
                    return '<span class="sgis-crack-badge aaa">AAA</span>';
                },
            },
            protection: {
                iconKey: 'shield',
                cls: 'sgis-crack-protection',
                label: '保护机制',
                detect: () => {
                    const info = (typeof SGIS !== 'undefined') ? SGIS.gameStatusInfo : null;
                    if (!info || info.notFound || !info.protections) return { state: 'unknown' };
                    const items = String(info.protections).split(/[,;/|]+/).map(s => s.trim()).filter(Boolean);
                    if (!items.length) return { state: 'false' };
                    return { state: 'true', items };
                },
                render: (info) => {
                    if (info.state !== 'true' || !info.items) return '';
                    return info.items.map(p => `<span class="sgis-crack-protection">${escHtml(p)}</span>`).join('');
                },
            },
        };

        // 统一段渲染器入口: type → 调用 detect + render
        // 等价性保证: 与原 renderDRMBadge/renderChineseAudioBadge/renderProfileStatusBadge/renderCrackStatusBadge 行为一致
        function renderDetectBadge(type) {
            const def = _DETECT_BADGE_DEFS[type];
            if (!def) return '';
            const info = def.detect();
            return def.render(info);
        }

        function renderDRMBadge() {
            const drm = detectDRM();
            if (!drm.hasDRM) return '';
            return drm.list.map(d => {
                const cls = d.severity === 'warn' ? 'warn' : '';
                return `<span class="sgis-drm-badge ${cls}">${SGIS_ICONS.shield} ${d.label}</span>`;
            }).join('');
        }

        // ---- v2.9.9: 中文语音支持醒目标记 (参考 Steam_Buff audio-check.js) ----
        function renderChineseAudioBadge() {
            const extra = SGIS.appDetailsExtra;
            if (!extra || !extra.supportedLanguages || !extra.supportedLanguages.list.length) return '';
            const langs = extra.supportedLanguages.list;
            // 匹配简体中文/繁体中文/Simplified Chinese/Traditional Chinese
            const chineseAudio = langs.find(l =>
                /chinese|中文/i.test(l.name) && l.audio
            );
            if (!chineseAudio) return '';
            return `<span class="sgis-audio-badge">${SGIS_ICONS.globe} ${chineseAudio.name} 语音支持</span>`;
        }

        // ---- v2.9.93: 资料受限状态检测 (参考 Nailoooooong/steam-restricted-game-realtime-userscript) ----
        // Steam 商店页通过 .game_area_details_specs_ctn.learning_about 标记资料受限状态:
        //   - .label 含 "Profile Features Limited" → 资料受限 (卡片/成就/时长不显示在个人资料页)
        //   - 存在 learning_about 但不是 Profile Features Limited → Steam 正在了解
        //   - 不存在 learning_about → 非受限
        // /app/* 页面直接从 DOM 检测 (零网络开销); 非游戏页通过 fetchProfileFeaturesStatus 异步获取

        function detectProfileFeaturesStatus() {
            if (SGIS.profileFeaturesStatus) return SGIS.profileFeaturesStatus;
            // /app/* 页面直接从 DOM 检测
            const learningEl = document.querySelector('.game_area_details_specs_ctn.learning_about');
            let result;
            if (!learningEl) {
                result = { status: 'normal', label: '资料正常', source: 'dom' };
            } else {
                const labelEl = learningEl.querySelector('.label');
                const labelText = (labelEl ? labelEl.textContent : '') || learningEl.textContent || '';
                if (/Profile\s+Features\s+Limited/i.test(labelText)) {
                    result = { status: 'restricted', label: '资料受限', source: 'dom' };
                } else {
                    result = { status: 'learning', label: 'Steam正在了解', source: 'dom' };
                }
            }
            SGIS.profileFeaturesStatus = result;
            return result;
        }

        // 异步获取资料受限状态 (用于搜索详情浮窗等非 /app/* 页面场景)
        // 通过 GM_xmlhttpRequest 获取商店页 HTML,解析 learning_about 元素
        async function fetchProfileFeaturesStatus(appId) {
            if (!appId) return null;
            // 1. 先看内存缓存
            if (SGIS.profileFeaturesStatus && SGIS.profileFeaturesStatus._appId === String(appId)) {
                return SGIS.profileFeaturesStatus;
            }
            // 2. 再看 GM 持久化缓存
            const cached = cacheGet('profileFeatures_' + appId);
            if (cached) {
                SGIS.profileFeaturesStatus = { ...cached, _appId: String(appId) };
                return SGIS.profileFeaturesStatus;
            }
            // 3. 获取商店页 HTML（依赖 core 1.0.6 headers 透传）
            const url = `https://store.steampowered.com/app/${appId}/?l=english&cc=us`;
            try {
                const html = await sglvGmFetchTextRetry(url, {
                    timeout: 15000,
                    headers: {
                        'Accept': 'text/html',
                        'Accept-Language': 'en-US,en;q=0.9',
                        'Cookie': 'mature_content=1; birthtime=441734400; lastagecheckage=1-January-1900; Steam_Language=english',
                    },
                });
                // 解析 HTML
                const doc = new DOMParser().parseFromString(html, 'text/html');
                const learningEl = doc.querySelector('.game_area_details_specs_ctn.learning_about');
                let result;
                if (!learningEl) {
                    result = { status: 'normal', label: '资料正常', source: 'fetch' };
                } else {
                    const labelEl = learningEl.querySelector('.label');
                    const labelText = (labelEl ? labelEl.textContent : '') || learningEl.textContent || '';
                    if (/Profile\s+Features\s+Limited/i.test(labelText)) {
                        result = { status: 'restricted', label: '资料受限', source: 'fetch' };
                    } else {
                        result = { status: 'learning', label: 'Steam正在了解', source: 'fetch' };
                    }
                }
                result._appId = String(appId);
                SGIS.profileFeaturesStatus = result;
                cacheSet('profileFeatures_' + appId, result, CACHE_TTL.profileFeatures);
                return result;
            } catch (e) {
                console.warn('[SGIS] 资料受限状态获取失败:', appId, e.message);
                return null;
            }
        }

        function renderProfileStatusBadge() {
            const info = detectProfileFeaturesStatus();
            // 仅在受限/正在了解时显示徽章,正常状态不显示 (避免视觉噪声)
            if (!info || info.status === 'normal') return '';
            const cls = info.status || 'normal';
            const title = info.status === 'restricted'
                ? 'Profile Features Limited：该游戏的卡片、成就、游玩时长等资料不会显示在 Steam 个人资料页'
                : 'Steam 正在了解该游戏，部分资料功能可能暂时受限';
            return `<span class="sgis-profile-badge ${cls}" title="${escHtml(title)}">${SGIS_ICONS.profileLimited} ${escHtml(info.label)}</span>`;
        }

        // ---- v2.9.10: gamestatus.info 破解状态集成 (参考 steam-game-status.js) ----
        // 数据源: https://gamestatus.info/back/api/gameinfo/game/{slug}/
        // slug 解析: URL 路径提取 → 游戏标题 slugify → steam_prod_id 验证
        const GAMESTATUS_API = 'https://gamestatus.info/back/api/gameinfo/game';
        const GAMESTATUS_MAX_SLUGS = 2;

        function slugifyGameStatus(text) {
            return String(text || '')
                .toLowerCase()
                .normalize('NFKD')
                .replace(/[\u0300-\u036f]/g, '')
                .replace(/[™®©'':"]/g, '')
                .replace(/[^a-z0-9]+/g, '-')
                .replace(/^-+|-+$/g, '')
                .replace(/-+/g, '-');
        }

        function buildGameStatusSlugs(appId, gameName) {
            const candidates = [];
            const add = (slug) => {
                if (slug && slug.length > 1 && !candidates.includes(slug)) candidates.push(slug);
            };
            // 1. 从 URL 路径提取 slug (如 /app/1245620/ELDEN_RING/)
            const pathMatch = location.pathname.match(/\/app\/\d+\/([^/?#]+)/i);
            if (pathMatch) add(slugifyGameStatus(pathMatch[1].replace(/_/g, '-')));
            // 2. 从游戏标题生成 slug
            const name = String(gameName || '').replace(/\s+/g, ' ').trim();
            if (name) {
                add(slugifyGameStatus(name));
                add(slugifyGameStatus(name.replace(/\s*[-–—:|].*$/, '')));
            }
            return candidates.slice(0, GAMESTATUS_MAX_SLUGS);
        }

        async function fetchGameStatus(appId, gameName) {
            // 1. 先看 SGIS 内存缓存
            if (SGIS.gameStatusInfo) return SGIS.gameStatusInfo;
            // 2. 再看 GM 持久化缓存
            const cached = cacheGet('gameStatus_' + appId);
            if (cached) { SGIS.gameStatusInfo = cached; return cached; }
            // 3. 构建 slug 候选并逐个尝试 API
            const slugs = buildGameStatusSlugs(appId, gameName);
            if (!slugs.length) return null;
            for (const slug of slugs) {
                try {
                    const url = `${GAMESTATUS_API}/${encodeURIComponent(slug)}/`;
                    const data = await sglvGmFetchRetry(url, {
                        timeout: 10000,
                        headers: { 'Accept': 'application/json', 'Accept-Language': 'zh-CN' },
                    });
                    // 404 由 core 立即 reject→catch→try next slug(等价于原 onload resolve(null))
                    // 验证 steam_prod_id 匹配 (防误匹配)
                    if (data && (!data.steam_prod_id || String(data.steam_prod_id) === String(appId))) {
                        // v2.9.11: 增强数据捕获 — 硬件需求 + Metacritic 评分 + 发售日
                        const hw = [
                            data.cpu_info && { k: 'CPU', v: data.cpu_info },
                            data.ram_info && { k: 'RAM', v: data.ram_info },
                            data.gpu_info && { k: 'GPU', v: data.gpu_info },
                            data.os_info && { k: 'OS', v: data.os_info },
                        ].filter(Boolean);
                        const result = {
                            status: data.readable_status || '',
                            protections: data.protections || '',
                            hackedGroups: data.hacked_groups_en || data.hacked_groups || '',
                            crackDate: data.crack_date || '',
                            isAAA: !!data.is_AAA,
                            userScore: data.user_score || null,
                            metacriticScore: data.mata_score || null,   // API 字段名为 mata_score
                            releaseDate: data.release_date || '',
                            hardware: hw.length ? hw : null,
                            slug: data.slug || slug,
                        };
                        SGIS.gameStatusInfo = result;
                        cacheSet('gameStatus_' + appId, result, CACHE_TTL.gameStatus);
                        return result;
                    }
                } catch { /* try next slug */ }
            }
            // 4. 全部 slug 未命中, 缓存 null 避免反复请求
            SGIS.gameStatusInfo = { notFound: true };
            cacheSet('gameStatus_' + appId, { notFound: true }, CACHE_TTL.gameStatus);
            return SGIS.gameStatusInfo;
        }

        function renderCrackStatusBadge() {
            const info = SGIS.gameStatusInfo;
            if (!info || info.notFound) return '';
            // 状态分类 → 颜色/图标
            const status = String(info.status || '').toLowerCase();
            let cls = '', label = info.status || '未知';
            if (/cracked|взлом/.test(status)) { cls = 'cracked'; label = info.status; }
            else if (/bypass|обход|hypervisor/.test(status) || /bypass|обход/.test(String(info.hackedGroups).toLowerCase())) { cls = 'bypass'; }
            else if (/not cracked|не взлом|unbroken|unreleased/.test(status)) { cls = 'not-cracked'; }
            else if (/release today|релиз сегодня|выходит сегодня/.test(status)) { cls = 'release-today'; }

            // 保护机制 chips
            const protections = String(info.protections || '').split(/[,;/|]+/).map(s => s.trim()).filter(Boolean);
            const protChips = protections.map(p => `<span class="sgis-crack-protection">${p}</span>`).join('');
            // 破解组织
            const groups = String(info.hackedGroups || '').split(/[,;/|]+/).map(s => s.trim()).filter(Boolean);
            const groupChips = groups.map(g => `<span class="sgis-crack-group">${g}</span>`).join('');
            // 破解日期
            const crackDateStr = info.crackDate
                ? new Date(info.crackDate).toLocaleDateString('zh-CN')
                : '';

            // v2.9.11: 用户评分 + Metacritic 评分 chips
            const scoreChips = [
                info.userScore ? `<span class="sgis-crack-score">${SGIS_ICONS.star} ${info.userScore}</span>` : '',
                info.metacriticScore ? `<span class="sgis-crack-score" style="background:rgba(96,165,250,0.12);color:#60a5fa;border-color:rgba(96,165,250,0.2)">Meta ${info.metacriticScore}</span>` : '',
            ].filter(Boolean).join('');

            const chips = [
                `<span class="sgis-crack-badge ${cls}">${SGIS_ICONS.shield} ${label}</span>`,
                info.isAAA ? '<span class="sgis-crack-badge aaa">AAA</span>' : '',
                protChips,
                groupChips,
                crackDateStr ? `<span class="sgis-crack-date">破解于 ${crackDateStr}</span>` : '',
                scoreChips,
            ].filter(Boolean).join('');
            if (!chips && !info.hardware) return '';

            // v2.9.11: 硬件需求区块
            const escHw = (s) => String(s || '').replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;');
            const hwHtml = info.hardware && info.hardware.length
                ? `<div class="sgis-crack-hardware">
                    <div class="sgis-crack-hardware-title">${SGIS_ICONS.info} 硬件需求 (gamestatus.info)</div>
                    ${info.hardware.map(h => `<div class="sgis-crack-hw-row"><span class="sgis-crack-hw-key">${h.k}</span><span class="sgis-crack-hw-val">${escHw(h.v)}</span></div>`).join('')}
                   </div>`
                : '';

            return `<div style="margin-top:6px">
                ${chips ? `<div style="display:flex;align-items:center;flex-wrap:wrap;gap:6px">${chips}</div>` : ''}
                ${hwHtml}
            </div>`;
        }

        // ---- 家庭组共享支持检测 ----
        function detectFamilyShareSupport() {
            // 从 DOM 检测 Steam 原生家庭共享提示
            // Steam 在 /app/* 页面会显示 .game_area_purchase_game 内的共享信息
            const shareEl = document.querySelector('.game_area_purchase_game .game_area_purchase_family_share, .family_sharing_notice');
            if (shareEl) return { supported: true, source: 'dom' };
            // 检测页面中是否有 "Steam Family Sharing" 相关文本
            const purchaseSection = document.querySelector('.game_area_purchase_game, #purchaseOptions');
            if (purchaseSection) {
                const text = purchaseSection.textContent || '';
                if (/family sharing|家庭共享|Steam Family/i.test(text)) return { supported: true, source: 'dom-text' };
                if (/not eligible for family sharing|不支持家庭共享/i.test(text)) return { supported: false, source: 'dom-text' };
            }
            // 从 appdetails API 缓存检测
            const cached = cacheGet('familyShare_' + APP_ID);
            if (cached !== null) return cached;
            return null;
        }
        async function fetchFamilyShareSupport() {
            // 先看 DOM
            const domResult = detectFamilyShareSupport();
            if (domResult) return domResult;
            // 从本地缓存检测
            const cached = cacheGet('familyShare_' + APP_ID);
            if (cached !== null) return cached;
            // v2.9.57: 委托 SGLVAppDetail.loadDetail 共享缓存(与 fetchAppDetailsExtra 复用同一请求)
            // category 41 = 家庭共享
            try {
                const A = (typeof unsafeWindow !== 'undefined' && unsafeWindow.SGLVAppDetail)
                    || (typeof window !== 'undefined' && window.SGLVAppDetail);
                if (A && typeof A.loadDetail === 'function') {
                    const detail = await A.loadDetail(APP_ID, { useCache: true });
                    if (detail && detail.categoryObjs) {
                        const hasFamilyShare = detail.categoryObjs.some(c =>
                            c.id === 41 || /family sharing/i.test(c.description || ''));
                        const result = { supported: !!hasFamilyShare, source: 'api' };
                        cacheSet('familyShare_' + APP_ID, result, CACHE_TTL.familyShare);
                        return result;
                    }
                }
            } catch { /* ignore */ }
            const fallback = { supported: null, source: 'unknown' };
            return fallback;
        }
        function renderFamilyShareIndicator(info) {
            // v2.9.62: 若该游戏已通过家庭组共享给当前用户(isSharedOnly),实际共享状态优先于
            // 能力检测,避免出现"共享给你"与"不支持家庭组共享"自相矛盾的描述
            if (info && info.isSharedOnly) {
                return `<div class="sgis-family-share-row sharing">
                    <span class="sgis-family-share-icon">✓</span>
                    <span>家庭组共享中</span>
                </div>`;
            }
            if (!SGIS.familyShareSupported) return '';
            const s = SGIS.familyShareSupported;
            if (s.supported === true) {
                return `<div class="sgis-family-share-row supported">
                    <span class="sgis-family-share-icon">✓</span>
                    <span>支持家庭组共享</span>
                    <span class="sgis-family-share-source">${s.source}</span>
                </div>`;
            } else if (s.supported === false) {
                return `<div class="sgis-family-share-row unsupported">
                    <span class="sgis-family-share-icon">✕</span>
                    <span>不支持家庭组共享</span>
                </div>`;
            }
            return '';
        }

        // ---- v2.3.16: appdetails API 增强信息 (创意工坊/截图/分类/捆绑包等) ----
        // 数据源：https://store.steampowered.com/api/appdetails?appids={APP_ID}&l=schinese
        // 工坊识别：categories 中 id=30 或描述包含 "创意工坊"/"Steam Workshop"
        // 附加信息：screenshots / categories / platforms / packages / genres / metacritic / recommendations 等
        // v2.9.57: 委托 SGLVAppDetail.loadDetail() 获取 appdetails 数据,
        // 消除与 sglv-app-detail.lib.js 的重复 API 调用+解析+缓存逻辑(净减约 120 行)
        // 库提供 3 级缓存(内存 5min + 磁盘 24h + 失败黑名单)+ 中文→英文→DOM 三级降级 + 429 退避
        async function fetchAppDetailsExtra() {
            const A = (typeof unsafeWindow !== 'undefined' && unsafeWindow.SGLVAppDetail)
                || (typeof window !== 'undefined' && window.SGLVAppDetail);
            if (!A || typeof A.loadDetail !== 'function') {
                console.warn('[SGIS] SGLVAppDetail 库未加载,概览增强信息不可用');
                return null;
            }
            try {
                const detail = await A.loadDetail(APP_ID, { useCache: true });
                if (!detail) return null;
                // 映射库返回结构到 SGIS 概览期望的结构
                const platforms = [];
                if (detail.platforms) {
                    if (detail.platforms.win) platforms.push('Windows');
                    if (detail.platforms.mac) platforms.push('macOS');
                    if (detail.platforms.linux) platforms.push('SteamOS + Linux');
                }
                return {
                    workshopSupported: (detail.categoryObjs || []).some(c =>
                        c.id === 30 || /steam\s*workshop|steam\s*创意工坊|创意工坊/i.test(c.description || '')
                    ),
                    workshopUrl: `https://steamcommunity.com/workshop/browse/?appid=${APP_ID}`,
                    categories: detail.categoryObjs || [],
                    platforms,
                    packages: detail.packages || [],
                    screenshots: detail.screenshots || [],
                    movies: detail.movies || [],
                    supportedLanguages: detail.supportedLanguages || { list: [], note: '' },
                    controllerSupport: detail.controllerSupport || null,
                    requiredAge: detail.requiredAge || 0,
                    contentDescriptors: detail.contentDescriptors || null,
                    appType: detail.type || '',
                    background: detail.background || '',
                    genres: detail.genres || [],
                    genreObjs: detail.genreObjs || [],
                    developers: detail.developers || [],
                    publishers: detail.publishers || [],
                    releaseDate: detail.releaseDate || '',
                    recommendations: detail.recommendations || 0,
                    metacritic: detail.metacritic || null,
                    achievementsTotal: detail.achievementsTotal || 0,
                    dlc: detail.dlc || [],
                    isFree: detail.isFree || false,
                    website: detail.website || '',
                    headerImage: detail.cover || '',
                    shortDesc: detail.shortDesc || '',
                    source: detail.source || 'api',
                    fetchedAt: Date.now(),
                };
            } catch (e) {
                console.warn('[SGIS] appdetails 增强信息获取失败:', e.message);
                return null;
            }
        }
        // v2.9.114: 商店页 DLC 列表 DOM 兜底提取——appdetails API 失败/未返回 dlc 时，
        // 从当前商店页 .game_area_dlc_row 提取 DLC AppID（选择器链：data-ds-appid 属性优先 →
        // 行内 /app/\d+ 链接正则兜底 → Set 去重，排除本体 AppID）。
        // 仅商店域有该结构；SGIS 面板本身也只在商店 app 页激活，此 guard 是防御性的。
        function extractDlcIdsFromDom() {
            try {
                if (!/^(store\.steampowered\.com)$/.test(location.hostname)) return [];
                const ids = new Set();
                document.querySelectorAll('.game_area_dlc_row[data-ds-appid]').forEach(el => {
                    const v = el.getAttribute('data-ds-appid');
                    if (v && /^\d+$/.test(v.trim())) ids.add(v.trim());
                });
                // 兜底: 旧行结构无 data-ds-appid 属性时从行内链接解析
                document.querySelectorAll('.game_area_dlc_row a[href]').forEach(a => {
                    const m = (a.getAttribute('href') || '').match(/\/app\/(\d+)/);
                    if (m) ids.add(m[1]);
                });
                ids.delete(String(APP_ID));
                return Array.from(ids).map(Number).filter(n => n > 0);
            } catch (e) { return []; }
        }
        // v2.9.114: DOM 提取结果并入 extra——
        //   extra 为 null(SGLVAppDetail 库缺失/API 失败) → 生成仅含 dlc 的完整骨架(其余字段空值,
        //     保证概览各区块 if (!extra || !xxx.length) 判断全部安全跳过),source 标记 'dom';
        //   extra 存在但 dlc 为空(API 未返回) → 合并去重补入,不覆盖已有;
        //   extra.dlc 已有数据 → 合并 DOM 新增项(去重)
        function mergeDlcFromDom(extra) {
            try {
                const domIds = extractDlcIdsFromDom();
                if (!domIds.length) return extra;
                if (!extra) {
                    return {
                        workshopSupported: undefined,
                        workshopUrl: '',
                        categories: [], platforms: [], packages: [], screenshots: [], movies: [],
                        supportedLanguages: { list: [], note: '' },
                        controllerSupport: null, requiredAge: 0, contentDescriptors: null,
                        appType: 'dlc-list-only', background: '', genres: [], genreObjs: [],
                        developers: [], publishers: [], releaseDate: '', recommendations: 0,
                        metacritic: null, achievementsTotal: 0, dlc: domIds, isFree: false,
                        website: '', headerImage: '', shortDesc: '',
                        source: 'dom', fetchedAt: Date.now(),
                    };
                }
                const cur = new Set((extra.dlc || []).map(String));
                const merged = Array.isArray(extra.dlc) ? extra.dlc.slice() : [];
                let added = false;
                domIds.forEach(id => { if (!cur.has(String(id))) { merged.push(id); added = true; } });
                if (added) extra.dlc = merged;
                return extra;
            } catch (e) { return extra; }
        }
        // 工坊标记渲染 (类似家庭共享指示器)
        function renderWorkshopIndicator() {
            const extra = SGIS.appDetailsExtra;
            if (!extra || extra.workshopSupported === undefined || extra.workshopSupported === null) return '';
            if (extra.workshopSupported) {
                return `<div class="sgis-workshop-row supported">
                    <span class="sgis-workshop-icon">${SGIS_ICONS.workshop}</span>
                    <span>支持 Steam 创意工坊</span>
                    <a class="sgis-workshop-link" href="${extra.workshopUrl}" target="_blank" rel="noopener">浏览工坊 →</a>
                </div>`;
            }
            return `<div class="sgis-workshop-row unsupported">
                <span class="sgis-workshop-icon">${SGIS_ICONS.workshop}</span>
                <span>不支持 Steam 创意工坊</span>
            </div>`;
        }
        // 工具函数: 大数字简写 (如 5178439 -> 517.8万)
        function formatBigNumber(n) {
            if (!n || n <= 0) return '';
            if (n < 10000) return String(n);
            if (n < 100000000) return (n / 10000).toFixed(1) + '万';
            return (n / 100000000).toFixed(1) + '亿';
        }
        // v2.3.17: 应用类型本地化映射
        function localizeAppType(t) {
            const map = {
                game: '游戏', dlc: 'DLC', music: '音乐', series: '系列',
                mod: '模组', demo: '试玩版', advertising: '宣传',
                series_episode: '系列剧集', tool: '工具', video: '视频',
                hardware: '硬件', episode: '剧集',
            };
            return map[t] || t || '';
        }
        // v2.3.17: 年龄限制等级文案
        function ageBadgeInfo(age) {
            if (!age || age <= 0) return { cls: 'unrestricted', text: '全年龄', icon: SGIS_ICONS.shield };
            if (age >= 18) return { cls: 'restricted', text: age + '+ 限制级', icon: SGIS_ICONS.shield };
            if (age >= 16) return { cls: 'mature', text: age + '+ 成熟内容', icon: SGIS_ICONS.shield };
            if (age >= 13) return { cls: 'mature', text: age + '+ 青少年', icon: SGIS_ICONS.shield };
            return { cls: 'unrestricted', text: age + '+', icon: SGIS_ICONS.shield };
        }
        // v2.3.17: 异步获取 DLC 名称映射
        // 调用 appdetails?appids={dlcId}&filters=basic 获取每个 DLC 的名称
        // 使用并发限制 (mapLimit 模式), 缓存 24h
        async function fetchDlcNames(dlcIds) {
            if (!dlcIds || !dlcIds.length) return {};
            // 先看缓存
            const cacheKey = 'dlcNames_' + dlcIds.join(',');
            const cached = cacheGet(cacheKey);
            if (cached) return cached;
            const result = {};
            const concurrency = 4;  // 并发 4 个
            const queue = dlcIds.slice();
            const workers = [];
            const fetchOne = async (dlcId) => {
                try {
                    const url = `https://store.steampowered.com/api/appdetails?appids=${dlcId}&filters=basic&l=schinese&_=${Date.now()}`;
                    const data = await fetchJson(url, { timeout: 8000 });
                    const d = data?.[dlcId]?.data;
                    if (d) {
                        result[dlcId] = {
                            name: d.name || ('DLC ' + dlcId),
                            isFree: !!d.is_free,
                            headerImage: d.header_image || '',
                            shortDesc: d.short_description || '',
                        };
                    }
                } catch (e) {
                    // 单个 DLC 失败不阻塞其他
                }
            };
            // 简单的并发池
            while (queue.length > 0) {
                const batch = queue.splice(0, concurrency);
                await Promise.all(batch.map(fetchOne));
            }
            cacheSet(cacheKey, result, CACHE_TTL.appDetailsExtra);
            return result;
        }

        // ---- ITAD 历史价格 (v2.9.79: 改用 SGLVITAD 独立库) ----
        // 原 lookupItadId / fetchItadGameInfo / fetchItadPriceHistory 已迁移至 sglv-itad.lib.js
        // 硬编码 Key 作为兜底, 用户配置的 Key 优先 (通过 SGLVITAD.setApiKey 动态切换)
        const _itad = window.SGLVITAD;

        async function fetchHistoryPrices(appId) {
            const cacheKey = 'historyPrices_' + appId;
            const cached = cacheGet(cacheKey);
            if (cached) return cached;

            // 使用 SGLVITAD 库 (用户 Key 优先, 兜底 Key 兜底)
            if (_itad && _itad.hasApiKey()) {
                // 步骤1: Steam AppID → ITAD GameID
                const itadId = await _itad.lookupItadId(appId);
                if (!itadId) {
                    return await fetchHistoryPricesCheapShark(appId, 'ITAD lookup 失败');
                }

                // 步骤2: 并行获取游戏信息和价格历史 (库内部已处理归一化和缓存)
                const [gameInfo, historyData] = await Promise.all([
                    _itad.fetchGameInfo(itadId),
                    _itad.fetchPriceHistory(itadId, { country: 'CN', shops: [_itad.SHOP_STEAM] }),
                ]);

                if (!historyData || !historyData.discounts.length) {
                    return await fetchHistoryPricesCheapShark(appId, 'ITAD 无价格历史');
                }

                // 步骤3: 补充 daysFromRelease (业务逻辑, 不在库中)
                const releaseDate = gameInfo?.releaseDate || null;
                if (releaseDate) {
                    for (const d of historyData.discounts) {
                        if (d.date) {
                            try {
                                d.daysFromRelease = Math.floor((new Date(d.date) - new Date(releaseDate)) / 86400000);
                            } catch { /* ignore */ }
                        }
                    }
                }

                const result = {
                    history: historyData.history,
                    discounts: historyData.discounts,
                    lowest: historyData.lowest,
                    releaseDate: releaseDate,
                    gameTitle: gameInfo?.title || '',
                    source: 'itad',
                };
                cacheSet(cacheKey, result, CACHE_TTL.historyPrices);
                return result;
            }

            // 库未加载或无 Key: 回退到 CheapShark → AugmentedSteam
            return await fetchHistoryPricesCheapShark(appId, 'ITAD 库未加载');
        }

        // Fallback: 使用 AugmentedSteam API 获取历史价格（原 v2.2 逻辑）
        async function fetchHistoryPricesFallback(appId, reason) {
            try {
                const data = await sglvGmFetchRetry('https://api.augmentedsteam.com/prices/v2', {
                    method: 'POST', timeout: 12000,
                    headers: { 'Content-Type': 'application/json' },
                    data: JSON.stringify({
                        country: 'US',
                        apps: [parseInt(appId, 10)],
                        subs: [],
                        bundles: [],
                        voucher: false,
                        shops: [],
                    }),
                });
                const key = `app/${appId}`;
                const aug = data?.prices?.[key];
                if (!aug) return { history: [], discounts: [], lowest: null, source: 'aug', error: reason };
                const lowest = aug.lowest || (aug.historic?.[0] ? { price: aug.historic[0].price, currency: aug.historic[0].currency, store: aug.historic[0].store, date: aug.historic[0].date } : null);
                const history = (aug.historic || []).map(h => ({
                    price: h.price, currency: h.currency, cut: 0, store: h.store || '', date: h.date || '',
                })).sort((a, b) => new Date(b.date) - new Date(a.date)).slice(0, 20);
                const result = { history, discounts: [], lowest, releaseDate: null, source: 'aug', error: reason };
                cacheSet('historyPrices_' + appId, result, CACHE_TTL.historyPrices);
                return result;
            } catch (e) {
                return { history: [], discounts: [], lowest: null, source: 'error', error: reason + ' / ' + e.message };
            }
        }

        // 折扣趋势曲线图: 折扣记录 > 2 个时绘制, 无数据或 <= 2 个时隐藏
        // v2.11.9 (FEAT-012 TASK-003): 手写 SVG 绘制段(~45 行)迁移 SGLVCharts.lineChart(area 形态)。
        // 数据整形(cut>0 过滤/时间升序)与 <=2 隐藏守卫不变; 原视觉语义全量注入:
        // 时间比例 x 轴(xValues, 86400000 单日护栏)/y 域 0..max(cut,10)/#a4d007 渐变 0.28→0.02/
        // 逐点 -cut% 标注(annotations point)/圆点描边 #0e141b 1.5/逐点 tooltip(完整日期 · -cut%)。
        // 几何坐标与 2.11.8 冻结基线一致(sglv-charts.test.js C9 断言)。
        function renderDiscountTrendChart(discounts) {
            const pts = (discounts || [])
                .filter(d => d && d.date && d.cut > 0)
                .map(d => ({ t: new Date(d.date).getTime(), cut: Number(d.cut) || 0, date: d.date }))
                .filter(p => !isNaN(p.t))
                .sort((a, b) => a.t - b.t);
            if (pts.length <= 2) return '';
            const W = 340, H = 120, PL = 22, PR = 10, PT = 14, PB = 16;
            const maxCut = Math.max(...pts.map(p => p.cut), 10);
            const svg = SGLVCharts.lineChart([{ data: pts.map(p => p.cut) }], {
                width: W, height: H, pL: PL, pR: PR, pT: PT, pB: PB,
                smooth: false, colors: ['#a4d007'],
                xValues: pts.map(p => p.t), xMinSpan: 86400000,
                yMin: 0, yMax: maxCut, gridCount: 4,
                yFormatter: v => Math.round(v) + '%',
                area: { fill: '#a4d007', opacity: 0.28 },
                strokeWidth: 1.8, strokeRound: true,
                dots: {
                    r: 3, fill: '#a4d007', stroke: '#0e141b', strokeWidth: 1.5,
                    title: (v, i) => `${new Date(pts[i].t).toLocaleDateString('zh-CN')} · -${pts[i].cut}%`,
                },
                xLabels: pts.map(p => new Date(p.t).toLocaleDateString('zh-CN', { year: '2-digit', month: '2-digit' })),
                xLabelAt: pts.map((_, i) => i),
                annotations: pts.map((p, i) => ({ type: 'point', idx: i, text: `-${p.cut}%`, dy: -6, color: '#c8d6e5', fontSize: 8 })),
                svgAttrs: 'style="width:100%;height:auto;display:block" role="img" aria-label="折扣趋势图"',
            });
            return `<div class="sgis-discount-trend" style="margin-top:8px">
                <div style="font-size:10px;color:var(--sgis-text-2);margin-bottom:4px;text-align:center">折扣趋势 (按首次到达日期)</div>
                ${svg}
            </div>`;
        }

        // v2.9.9: SVG 价格历史走势图 (零依赖, 支持时间范围筛选, 参考 Steam_Buff charts.js)
        // v2.11.9: 绘制段迁移 SGLVCharts.lineChart(详见函数内注释), 数据整形/区间过滤/y 域计算保留
        function renderPriceHistoryChart(historyData) {
            const allPoints = (historyData?.history || [])
                .filter(h => h && h.date && h.price > 0)
                .map(h => ({
                    t: new Date(h.date).getTime(),
                    price: Number(h.price) || 0,
                    cut: Number(h.cut) || 0,
                    currency: h.currency || '',
                    store: h.store || '',
                    date: h.date,
                }))
                .filter(p => !isNaN(p.t))
                .sort((a, b) => a.t - b.t);
            if (allPoints.length < 2) return '';

            const now = Date.now();
            const ranges = [
                { key: '6m', label: '6月', ms: 180 * 86400000 },
                { key: '1y', label: '12月', ms: 365 * 86400000 },
                { key: 'all', label: '全部', ms: Infinity },
            ];
            const activeRange = SGIS.priceChartRange || 'all';
            const filterByRange = (rangeKey) => {
                if (rangeKey === 'all') return allPoints;
                const r = ranges.find(x => x.key === rangeKey);
                if (!r) return allPoints;
                const filtered = allPoints.filter(p => p.t >= now - r.ms);
                return filtered.length >= 2 ? filtered : allPoints;
            };
            const points = filterByRange(activeRange);

            const W = 340, H = 140, PL = 34, PR = 10, PT = 14, PB = 20;
            const prices = points.map(p => p.price);
            const minP = Math.min(...prices);
            const maxP = Math.max(...prices);
            const padP = (maxP - minP) * 0.15 || maxP * 0.1 || 1;
            const yMin = Math.max(0, minP - padP);
            const yMax = maxP + padP;
            const lowestIdx = prices.indexOf(minP);
            const labelCount = Math.min(5, points.length);
            const xLabelAt = Array.from({ length: labelCount }, (_, i) =>
                Math.floor(i * (points.length - 1) / (labelCount - 1)));
            const currency = points[0]?.currency || '';

            // v2.11.9 (FEAT-012 TASK-003): 手写 SVG 绘制段(~70 行)迁移 SGLVCharts.lineChart(area+dots+rangeButtons 形态)。
            // y 域(±15% padding/下限钳 0)与区间过滤(<2 点回退全量)保留函数内; 区间按钮组由库产出
            // (sgis-chart-range-btn, data-range), 点击重绘仍走 bindPriceChartRangeEvents; 最低价大圆点+价格标注
            // 经 dots.itemStyle + annotations 注入; 逐点 tooltip(日期 · 价格 (-cut%) @ 商店)不变。
            // 几何坐标与 2.11.8 冻结基线一致(含 6m/1y/all 三态, sglv-charts.test.js C9 断言)。
            return SGLVCharts.lineChart([{ data: prices }], {
                width: W, height: H, pL: PL, pR: PR, pT: PT, pB: PB,
                smooth: false, colors: [SGLVCharts.accent()],
                xValues: points.map(p => p.t), xMinSpan: 86400000,
                yMin, yMax, gridCount: 4,
                yFormatter: v => (v >= 100 ? Math.round(v).toString() : v.toFixed(1)),
                area: { fill: SGLVCharts.accent(), opacity: 0.25 },
                strokeWidth: 1.8, strokeRound: true,
                dots: {
                    stroke: '#0e141b', strokeWidth: 1.5,
                    itemStyle: (v, i) => (i === lowestIdx ? { r: 4, fill: '#a4d007' } : { r: 2.5, fill: SGLVCharts.accent() }),
                    title: (v, i) => {
                        const p = points[i];
                        return `${new Date(p.t).toLocaleDateString('zh-CN')} · ${p.currency}${p.price.toFixed(2)}${p.cut > 0 ? ` (-${p.cut}%)` : ''}${p.store ? ' @ ' + p.store : ''}`;
                    },
                },
                xLabels: points.map(p => new Date(p.t).toLocaleDateString('zh-CN', { year: '2-digit', month: '2-digit' })),
                xLabelAt,
                annotations: [{ type: 'point', idx: lowestIdx, text: `${points[lowestIdx].currency}${points[lowestIdx].price.toFixed(2)}`, dy: -8, color: '#a4d007', fontSize: 8.5, fontWeight: 600 }],
                rangeButtons: ranges, activeRange,
                title: `价格走势 (${currency})`,
                wrapId: 'sgis-price-chart-wrap',
                svgAttrs: 'style="width:100%;height:auto;display:block" role="img" aria-label="价格历史走势图"',
            });
        }

        // v2.9.9: 绑定价格图表时间范围按钮事件
        function bindPriceChartRangeEvents(historyData) {
            const wrap = document.getElementById('sgis-price-chart-wrap');
            if (!wrap) return;
            wrap.querySelectorAll('.sgis-chart-range-btn').forEach(btn => {
                btn.addEventListener('click', () => {
                    SGIS.priceChartRange = btn.dataset.range;
                    const newChartHtml = renderPriceHistoryChart(historyData);
                    if (newChartHtml) {
                        const temp = document.createElement('div');
                        temp.innerHTML = newChartHtml;
                        const newWrap = temp.firstChild;
                        wrap.replaceWith(newWrap);
                        bindPriceChartRangeEvents(historyData);
                    }
                });
            });
        }

        function renderHistoryPricesSection(historyData) {
            if (!historyData || (!historyData.history?.length && !historyData.lowest && !historyData.discounts?.length)) {
                return `<div class="sgis-section">
                    <div class="sgis-section-title">${SGIS_ICONS.price} 历史价格</div>
                    <div style="font-size:11px;color:var(--sgis-text-2);text-align:center;padding:10px">
                        暂无历史价格数据${historyData?.error ? '（' + historyData.error + '）' : ''}
                    </div>
                </div>`;
            }
            const lowest = historyData.lowest;
            const discounts = historyData.discounts || [];
            const releaseDate = historyData.releaseDate;

            // 史低价格卡片
            // v2.3.7: 安全数值转换, 修复 price?.toFixed is not a function
            const _f = (v) => { const n = Number(v); return isNaN(n) ? '—' : n.toFixed(2); };
            const lowestHtml = lowest ? `<div class="sgis-history-lowest">
                <div class="sgis-history-lowest-label">史低价格 ${lowest.cut ? `(-${lowest.cut}%)` : ''}</div>
                <div class="sgis-history-lowest-val">${lowest.currency || '$'}${_f(lowest.price)}</div>
                ${lowest.store ? `<div class="sgis-history-lowest-store">@ ${lowest.store}</div>` : ''}
                ${lowest.date ? `<div class="sgis-history-lowest-date">${new Date(lowest.date).toLocaleDateString('zh-CN')}</div>` : ''}
            </div>` : '';

            // 折扣记录摘要（每个折扣百分比第一次到达的天数，参考 Python seen_cuts 逻辑）
            const discountSummaryHtml = discounts.length ? `<div class="sgis-discount-summary">
                ${discounts.map(d => {
                    const daysStr = d.daysFromRelease != null ? `<span class="sgis-discount-badge-days">第${d.daysFromRelease}天</span>` : '';
                    return `<span class="sgis-discount-badge">-${d.cut}%${daysStr}</span>`;
                }).join('')}
            </div>` : '';

            // 完整价格历史列表（显示折扣百分比）
            const historyRows = (historyData.history || []).slice(0, 10).map(h => {
                const dateStr = h.date ? new Date(h.date).toLocaleDateString('zh-CN', { year: '2-digit', month: '2-digit', day: '2-digit' }) : '—';
                const cutBadge = h.cut > 0 ? `<span class="sgis-history-cut">-${h.cut}%</span>` : '';
                // 计算距发行天数
                let daysStr = '';
                if (releaseDate && h.date) {
                    try {
                        const days = Math.floor((new Date(h.date) - new Date(releaseDate)) / 86400000);
                        if (days >= 0) daysStr = `<span class="sgis-history-days">+${days}天</span>`;
                    } catch { /* ignore */ }
                }
                return `<div class="sgis-history-row">
                    <span class="sgis-history-date">${dateStr}</span>
                    ${cutBadge}
                    <span class="sgis-history-price">${h.cut > 0 && h.regular > 0 ? `<span style="text-decoration:line-through;color:var(--sgis-text-2);font-weight:400;font-size:10px;margin-right:3px">${h.currency || '$'}${_f(h.regular)}</span>` : ''}${h.currency || '$'}${_f(h.price)}</span>
                    <span class="sgis-history-store">${h.store || ''}</span>
                    ${daysStr}
                </div>`;
            }).join('');

            const sourceLabel = historyData.source === 'itad' ? 'ITAD' : historyData.source === 'aug' ? 'AugmentedSteam' : historyData.source;
            return `<div class="sgis-section">
                <div class="sgis-section-title">${SGIS_ICONS.price} 历史价格走势</div>
                ${lowestHtml}
                ${discountSummaryHtml}
                ${renderPriceHistoryChart(historyData)}
                ${historyRows ? `<div class="sgis-history-list">${historyRows}</div>` : ''}
                ${renderDiscountTrendChart(discounts)}
                ${releaseDate ? `<div style="font-size:10px;color:var(--sgis-text-2);margin-top:4px">发行日期: ${new Date(releaseDate).toLocaleDateString('zh-CN')}</div>` : ''}
                <div style="font-size:10px;color:var(--sgis-text-2);text-align:center;margin-top:6px">
                    数据源: ${sourceLabel}${discounts.length ? ` · ${discounts.length} 个折扣记录` : ''}
                </div>
            </div>`;
        }

        // ---- 成就标签 ----
        async function fetchPlayerAchievements(appId) {
            const apiKey = storage.getApiKey();
            const steamId = getActiveSteamId();
            if (!apiKey || !steamId) return { error: 'NO_KEY', achievements: [], total: 0, unlocked: 0 };
            const cacheKey = 'achievements_' + appId;
            const cached = cacheGet(cacheKey);
            if (cached) return cached;
            const url = `https://api.steampowered.com/ISteamUserStats/GetPlayerAchievements/v0001/?appid=${appId}&key=${apiKey}&steamid=${steamId}&l=schinese`;
            const data = await fetchJson(url, { timeout: 15000 });
            if (!data?.playerstats?.success) return { error: 'API_FAIL', achievements: [], total: 0, unlocked: 0 };
            const ach = data.playerstats.achievements || [];
            const result = {
                achievements: ach.map(a => ({
                    name: a.name || '',
                    apiname: a.apiname || '',
                    achieved: a.achieved === 1,
                    unlocktime: a.unlocktime || 0,
                })),
                total: ach.length,
                unlocked: ach.filter(a => a.achieved === 1).length,
                gameName: data.playerstats.gameName || '',
            };
            cacheSet(cacheKey, result, CACHE_TTL.achievements);
            return result;
        }
        async function fetchGlobalAchievements(appId) {
            const cacheKey = 'globalAchievements_' + appId;
            const cached = cacheGet(cacheKey);
            if (cached) return cached;
            const url = `https://api.steampowered.com/ISteamUserStats/GetGlobalAchievementPercentagesForApp/v0002/?gameid=${appId}&l=schinese`;
            const data = await fetchJson(url, { timeout: 15000 });
            const ach = data?.achievementpercentages?.achievements || [];
            const result = ach.map(a => ({
                name: a.name || '',
                percent: a.percent || 0,
            })).sort((a, b) => b.percent - a.percent);
            cacheSet(cacheKey, result, CACHE_TTL.globalAchievements);
            return result;
        }
        function renderAchievements() {
            if (SGIS.achievementsLoading) return;
            if (SGIS.achievements && SGIS.globalAchievements) { renderAchievementsContent(); return; }
            SGIS.achievementsLoading = true;
            renderLoading('正在获取成就数据…');
            Promise.all([
                fetchPlayerAchievements(APP_ID).catch(e => ({ error: e.message, achievements: [], total: 0, unlocked: 0 })),
                fetchGlobalAchievements(APP_ID).catch(e => []),
            ]).then(([playerData, globalData]) => {
                SGIS.achievements = playerData;
                SGIS.globalAchievements = globalData;
                renderAchievementsContent();
            }).catch(e => {
                renderError('成就获取失败: ' + e.message);
            }).finally(() => { SGIS.achievementsLoading = false; });
        }
        // ---- FEAT-014 TASK-009: renderAchievementsContent 段化 ----
        // 数据准备 + 4 段渲染器,主函数降级为组装器
        function _prepareAchievementsData() {
            const player = SGIS.achievements;
            const global = SGIS.globalAchievements || [];
            if (player?.error === 'NO_KEY') return { state: 'no_key' };
            if (player?.error && player.error !== 'API_FAIL') return { state: 'error', error: player.error };
            if (!player || player.total === 0) {
                if (global.length === 0) return { state: 'empty' };
                return { state: 'global_only', global };
            }
            const unlocked = player.unlocked;
            const total = player.total;
            const pct = total > 0 ? (unlocked / total * 100) : 0;
            const globalMap = {};
            global.forEach(g => { globalMap[g.name] = g.percent; });
            const merged = player.achievements.map(a => ({
                name: a.name,
                achieved: a.achieved,
                unlocktime: a.unlocktime,
                globalPct: globalMap[a.name] || null,
            }));
            const unlockedList = merged.filter(a => a.achieved).sort((a, b) => (b.unlocktime || 0) - (a.unlocktime || 0));
            const lockedList = merged.filter(a => !a.achieved).sort((a, b) => (b.globalPct || 0) - (a.globalPct || 0));
            return { state: 'normal', player, global, unlocked, total, pct, merged, unlockedList, lockedList };
        }

        function _renderAchievementsNoKey() {
            return `<div class="sgis-state">
                <div style="font-size:36px;margin-bottom:8px">🏆</div>
                <div>需要 API Key 才能查看成就</div>
                <div style="font-size:11px;color:var(--sgis-text-2);margin-top:8px;padding:0 16px;line-height:1.5">
                    请在设置中配置 Steam Web API Key。<br>
                    打开 <a href="https://steamcommunity.com/dev/apikey" target="_blank" style="color:var(--sgis-blue)">steamcommunity.com/dev/apikey</a> 获取免费 Key。
                </div>
            </div>`;
        }

        function _renderAchievementsError(d) {
            return `<div class="sgis-state"><div style="font-size:36px;margin-bottom:8px">🏆</div><div>成就数据获取失败: ${d.error}</div></div>`;
        }

        function _renderAchievementsEmpty() {
            return `<div class="sgis-state">
                <div style="font-size:36px;margin-bottom:8px">🏆</div>
                <div>该游戏暂无成就数据</div>
            </div>`;
        }

        function _renderAchievementsGlobalOnly(d) {
            const globalList = d.global.slice(0, 20).map(a => {
                const barColor = a.percent >= 50 ? 'var(--sgis-green)' : a.percent >= 20 ? 'var(--sgis-amber)' : 'var(--sgis-rose)';
                return `<div class="sgis-ach-item">
                    <div class="sgis-ach-info">
                        <div class="sgis-ach-name">${a.name}</div>
                        ${hbarRow({ cls: 'ach', pct: a.percent, color: barColor })}
                    </div>
                    <div class="sgis-ach-pct">${a.percent.toFixed(1)}%</div>
                </div>`;
            }).join('');
            return `<div class="sgis-section">
                <div class="sgis-section-title">${SGIS_ICONS.star} 全球成就达成率</div>
                <div style="font-size:11px;color:var(--sgis-text-2);margin-bottom:8px">该游戏不在你的库中,仅展示全球数据</div>
                ${globalList}
            </div>`;
        }

        function _renderAchievementsNormal(d) {
            const formatUnlockTime = (ts) => {
                if (!ts) return '';
                try { return new Date(ts * 1000).toLocaleDateString('zh-CN', { year: '2-digit', month: '2-digit', day: '2-digit' }); } catch { return ''; }
            };
            const unlockedHtml = d.unlockedList.slice(0, 15).map(a => `<div class="sgis-ach-item unlocked">
                <div class="sgis-ach-check">✓</div>
                <div class="sgis-ach-info">
                    <div class="sgis-ach-name">${a.name || '(隐藏成就)'}</div>
                    <div class="sgis-ach-meta">
                        ${a.unlocktime ? `<span class="sgis-ach-time">${formatUnlockTime(a.unlocktime)}</span>` : ''}
                        ${a.globalPct != null ? `<span class="sgis-ach-global">全球 ${a.globalPct.toFixed(1)}%</span>` : ''}
                    </div>
                </div>
            </div>`).join('');
            const lockedHtml = d.lockedList.slice(0, 15).map(a => {
                const barColor = (a.globalPct || 0) >= 50 ? 'var(--sgis-green)' : (a.globalPct || 0) >= 20 ? 'var(--sgis-amber)' : 'var(--sgis-rose)';
                return `<div class="sgis-ach-item locked">
                    <div class="sgis-ach-check locked">○</div>
                    <div class="sgis-ach-info">
                        <div class="sgis-ach-name">${a.name || '(隐藏成就)'}</div>
                        ${hbarRow({ cls: 'ach', pct: a.globalPct || 0, color: barColor })}
                        ${a.globalPct != null ? `<div class="sgis-ach-global">全球 ${a.globalPct.toFixed(1)}%</div>` : ''}
                    </div>
                </div>`;
            }).join('');
            const donutR = 52, donutSw = 10, donutCx = 60, donutCy = 60;
            const donutC = 2 * Math.PI * donutR;
            const donutDash = (d.pct / 100) * donutC;
            const rainbowIntensity = Math.max(0.3, Math.min(1.0, 0.25 + d.pct / 100 * 0.85));
            const rainbowId = `sgis-rainbow-${APP_ID || 'p'}`;
            const rainbowGlowId = `${rainbowId}-glow`;
            const rainbowStops = [
                [0.00, '#ff0080'], [0.17, '#ff4500'], [0.34, '#ffb300'], [0.50, '#00ff7f'],
                [0.67, '#00bfff'], [0.84, '#7b2cff'], [1.00, '#ff00d4'],
            ].map(([off, c]) => `<stop offset="${off * 100}%" stop-color="${c}"/>`).join('');
            return `
                <div class="sgis-ach-summary">
                    <div class="sgis-ach-donut" style="--rainbow-intensity: ${rainbowIntensity.toFixed(3)}">
                        <svg width="120" height="120" viewBox="0 0 120 120">
                            <defs>
                                <linearGradient id="${rainbowId}" x1="0" y1="0" x2="1" y2="1">
                                    ${rainbowStops}
                                </linearGradient>
                                <filter id="${rainbowGlowId}" x="-50%" y="-50%" width="200%" height="200%">
                                    <feGaussianBlur stdDeviation="${(2 + rainbowIntensity * 3).toFixed(1)}" result="blur"/>
                                    <feMerge><feMergeNode in="blur"/><feMergeNode in="SourceGraphic"/></feMerge>
                                </filter>
                            </defs>
                            <circle cx="${donutCx}" cy="${donutCy}" r="${donutR}" fill="none" stroke="rgba(255,255,255,0.06)" stroke-width="${donutSw}"/>
                            <circle class="sgis-rainbow-ring" cx="${donutCx}" cy="${donutCy}" r="${donutR}" fill="none" stroke="url(#${rainbowId})" stroke-width="${donutSw}"
                                stroke-dasharray="${donutDash} ${donutC - donutDash}" stroke-dashoffset="${-donutC/4}" transform="rotate(-90 ${donutCx} ${donutCy})"
                                filter="url(#${rainbowGlowId})" style="transition:stroke-dasharray .6s ease"/>
                            <text x="${donutCx}" y="${donutCy - 4}" text-anchor="middle" class="sgis-donut-pct" font-size="22" font-weight="bold">${d.pct.toFixed(0)}%</text>
                            <text x="${donutCx}" y="${donutCy + 16}" text-anchor="middle" fill="#8a9ba8" font-size="11">${d.unlocked}/${d.total}</text>
                        </svg>
                    </div>
                    <div class="sgis-ach-stats">
                        <div class="sgis-ach-stat"><span class="sgis-ach-stat-val">${d.unlocked}</span><span class="sgis-ach-stat-lbl">已解锁</span></div>
                        <div class="sgis-ach-stat"><span class="sgis-ach-stat-val">${d.total - d.unlocked}</span><span class="sgis-ach-stat-lbl">未解锁</span></div>
                        <div class="sgis-ach-stat"><span class="sgis-ach-stat-val">${d.total}</span><span class="sgis-ach-stat-lbl">总成就</span></div>
                    </div>
                </div>
                ${unlockedHtml ? `<div class="sgis-section">
                    <div class="sgis-section-title">${SGIS_ICONS.check} 已解锁 (${d.unlockedList.length})</div>
                    ${unlockedHtml}
                </div>` : ''}
                ${lockedHtml ? `<div class="sgis-section">
                    <div class="sgis-section-title">${SGIS_ICONS.star} 未解锁 (${d.lockedList.length})</div>
                    ${lockedHtml}
                </div>` : ''}
                <div style="font-size:10px;color:var(--sgis-text-2);text-align:center;margin-top:8px">
                    玩家成就来自 Steam Web API · 全球数据每12小时更新
                </div>
            `;
        }

        function renderAchievementsContent() {
            const d = _prepareAchievementsData();
            let html;
            if (d.state === 'no_key') html = _renderAchievementsNoKey();
            else if (d.state === 'error') html = _renderAchievementsError(d);
            else if (d.state === 'empty') html = _renderAchievementsEmpty();
            else if (d.state === 'global_only') html = _renderAchievementsGlobalOnly(d);
            else html = _renderAchievementsNormal(d);
            setBody(html);
        }

        // ---- 动态标签 (游戏新闻/更新) ----
        // v2.9.111: 新闻正文清洗——原 /\\[a-zA-Z]/ 正则双重转义失效（实际匹配"反斜杠+字母"），
        // BBCode 标签([url]/[img]/[list]等)与 {STEAM_CLAN_LOC_IMAGE}/gid/hash.png 图片占位符原样泄漏到
        // 面板原文模式与 AI 翻译总结输入。现剥离全部 BBCode/占位符并丢弃超长裸链。
        function sglvCleanNewsText(text) {
            return String(text || '')
                .replace(/\{STEAM_CLAN(?:_LOC)?_(?:IMAGE|VIDEO)\}\S*/gi, '')
                .replace(/\[img\][\s\S]*?\[\/img\]/gi, '')
                .replace(/\[url=[^\]]*\]([\s\S]*?)\[\/url\]/gi, '$1')
                .replace(/\[\/?[a-z0-9_=#.\s:%{}|\/\\-]*\]/gi, '')
                .replace(/https?:\/\/\S+/g, m => (m.length > 80 ? '' : m))
                .replace(/[ \t]{2,}/g, ' ')
                .replace(/\n{3,}/g, '\n\n')
                .trim();
        }
        async function fetchGameNews(appId) {
            const cacheKey = 'news_' + appId;
            const cached = cacheGet(cacheKey);
            if (cached) return cached;
            // v2.9.111: 官方公告源优先，为空时回退全源——部分游戏仅经 steam_news/patch_notes
            // 等其它 feed 发布动态，限定 feeds 过滤会导致面板误显示"暂无游戏动态"
            let newsItems = [];
            try {
                const officialUrl = `https://api.steampowered.com/ISteamNews/GetNewsForApp/v0002/?appid=${appId}&count=20&maxlength=500&l=schinese&feeds=steam_community_announcements`;
                const officialData = await fetchJson(officialUrl, { timeout: 15000 });
                newsItems = officialData?.appnews?.newsitems || [];
            } catch { newsItems = []; }
            if (!newsItems.length) {
                const allUrl = `https://api.steampowered.com/ISteamNews/GetNewsForApp/v0002/?appid=${appId}&count=20&maxlength=500&l=schinese`;
                const allData = await fetchJson(allUrl, { timeout: 15000 });
                newsItems = allData?.appnews?.newsitems || [];
            }
            const result = newsItems.map(n => ({
                title: n.title || '',
                url: n.url || '',
                contents: sglvCleanNewsText(n.contents).slice(0, 300),
                date: n.date || 0,
                feedname: n.feedname || '',
                author: n.author || '',
            }));
            cacheSet(cacheKey, result, CACHE_TTL.news);
            return result;
        }

        function renderDynamics() {
            if (SGIS.dynamicsLoading) return;
            if (SGIS.dynamics) { renderDynamicsContent(); return; }
            SGIS.dynamicsLoading = true;
            renderLoading('正在获取游戏动态…');
            fetchGameNews(APP_ID).then(news => {
                SGIS.dynamics = news;
                renderDynamicsContent();
            }).catch(e => {
                renderError('动态获取失败: ' + e.message);
            }).finally(() => { SGIS.dynamicsLoading = false; });
        }
        // ---- FEAT-014 TASK-009: renderDynamicsContent 段化 ----
        // 数据准备 + 4 段渲染器(空态/原文/AI/AI 触发),主函数降级为组装器
        function _formatNewsDate(ts) {
            if (!ts) return '';
            try {
                const d = new Date(ts * 1000);
                const now = new Date();
                const diff = (now - d) / 1000;
                if (diff < 3600) return Math.floor(diff / 60) + ' 分钟前';
                if (diff < 86400) return Math.floor(diff / 3600) + ' 小时前';
                if (diff < 30 * 86400) return Math.floor(diff / 86400) + ' 天前';
                return d.toLocaleDateString('zh-CN', { year: 'numeric', month: '2-digit', day: '2-digit' });
            } catch { return ''; }
        }

        const _FEED_LABELS = {
            steam_community_announcements: '社区公告',
            steam_blog: '官方博客',
            patch_notes: '更新日志',
            product_updates: '产品更新',
        };
        function _feedLabel(name) { return _FEED_LABELS[name] || name || '动态'; }

        function _prepareDynamicsData() {
            const news = SGIS.dynamics || [];
            const isAiMode = SGIS.dynamicsMode === 'ai';
            const hasTruncationFlag = SGIS.aiSummary && SGIS.aiSummary.some(it => it._truncated);
            return { news, isAiMode, hasTruncationFlag };
        }

        function _renderDynamicsEmpty() {
            return `<div class="sgis-state">
                <div style="font-size:36px;margin-bottom:8px">📢</div>
                <div>暂无游戏动态</div>
                <div style="font-size:11px;color:var(--sgis-text-2);margin-top:6px">该游戏近期没有发布新闻或更新公告</div>
            </div>`;
        }

        function _renderDynamicsOriginal(d) {
            return d.news.map(n => {
                const feedLabel = _feedLabel(n.feedname);
                const desc = n.contents ? n.contents.slice(0, 200) + (n.contents.length > 200 ? '...' : '') : '';
                return `<a class="sgis-news-item" ${n.url ? `href="${n.url}" target="_blank" rel="noopener"` : ''}>
                    <div class="sgis-news-header">
                        <span class="sgis-news-feed">${feedLabel}</span>
                        <span class="sgis-news-date">${_formatNewsDate(n.date)}</span>
                    </div>
                    <div class="sgis-news-title">${n.title}</div>
                    ${desc ? `<div class="sgis-news-desc">${desc}</div>` : ''}
                    ${n.author ? `<div class="sgis-news-author">— ${n.author}</div>` : ''}
                </a>`;
            }).join('');
        }

        function _renderDynamicsAiSummary(d) {
            // v2.3.18: 截断部分恢复提示横幅
            const truncationBanner = d.hasTruncationFlag
                ? `<div style="margin-bottom:10px;padding:7px 10px;background:rgba(255,152,0,0.08);border:1px solid rgba(255,152,0,0.25);border-left:3px solid rgba(255,152,0,0.6);border-radius:4px;font-size:11px;color:var(--sgis-amber-text,#fbbf24);line-height:1.5">
                    ⚠️ AI 响应因长度限制被截断, 已通过修复算法恢复 ${SGIS.aiSummary.length} 条结果。切换到"原文"可查看完整新闻。
                </div>`
                : '';
            return truncationBanner + SGIS.aiSummary.map((item, i) => {
                const origNews = d.news[i] || {};
                const feedLabel = _feedLabel(origNews.feedname);
                const badge = item.is_translated ? `<span class="sgis-ai-summary-badge">已翻译</span>` : '';
                return `<a class="sgis-ai-summary-item" ${origNews.url ? `href="${origNews.url}" target="_blank" rel="noopener"` : ''}>
                    <div class="sgis-news-header">
                        <span class="sgis-news-feed">${feedLabel}</span>
                        <span class="sgis-news-date">${_formatNewsDate(origNews.date)}</span>
                    </div>
                    <div class="sgis-ai-summary-title">${item.title || origNews.title || ''}${badge}</div>
                    <div class="sgis-ai-summary-text">${item.summary || ''}</div>
                </a>`;
            }).join('');
        }

        function _renderDynamicsAiLoading() {
            return `<div class="sgis-state"><div class="sgis-spinner"></div>${T.aiTranslating}</div>`;
        }

        function _renderDynamicsAiError() {
            return `<div class="sgis-state sgis-error">⚠️ ${T.aiTranslateFail}: ${SGIS.aiSummaryError}
                <div style="margin-top:12px"><button class="sgis-retry-btn" id="sgis-ai-retry">重试</button></div>
            </div>`;
        }

        function _renderDynamicsToggleBar(d) {
            const aiStatusText = d.isAiMode
                ? (SGIS.aiSummary
                    ? (d.hasTruncationFlag
                        ? `⚠️ 已恢复 ${SGIS.aiSummary.length} 条 (部分结果因长度限制被截断)`
                        : `✅ ${SGIS.aiSummary.length} 条已总结`)
                    : T.aiTranslating)
                : '';
            return `<div class="sgis-ai-toggle-bar">
                <div class="sgis-ai-toggle">
                    <button class="sgis-ai-toggle-btn ${!d.isAiMode ? 'active' : ''}" data-mode="original">${T.aiToggleOriginal}</button>
                    <button class="sgis-ai-toggle-btn ${d.isAiMode ? 'active' : ''}" data-mode="ai">${T.aiToggleSummary}</button>
                </div>
                <span class="sgis-ai-status" id="sgis-ai-status">${aiStatusText}</span>
            </div>`;
        }

        function _bindDynamicsEvents() {
            const body = document.getElementById('sgis-body');
            if (!body) return;
            body.querySelectorAll('.sgis-ai-toggle-btn').forEach(btn => {
                btn.addEventListener('click', () => {
                    const mode = btn.dataset.mode;
                    if (SGIS.dynamicsMode === mode) return;
                    SGIS.dynamicsMode = mode;
                    if (mode === 'original') SGIS.aiSummaryError = null;
                    renderDynamicsContent();
                });
            });
            const aiRetryBtn = body.querySelector('#sgis-ai-retry');
            if (aiRetryBtn) {
                aiRetryBtn.addEventListener('click', () => {
                    SGIS.aiSummaryError = null;
                    SGIS.aiSummary = null;
                    renderDynamicsContent();
                });
            }
        }

        function _renderDynamicsAiTrigger(d) {
            // 触发 AI 翻译
            SGIS.aiSummaryLoading = true;
            const gameName = (document.getElementById('appHubAppName') || {}).textContent || '';
            callAiTranslateSummary(d.news, gameName, APP_ID).then(result => {
                SGIS.aiSummary = result;
                SGIS.aiSummaryLoading = false;
                if (SGIS.tab === 'dynamics') renderDynamicsContent();
            }).catch(e => {
                SGIS.aiSummaryLoading = false;
                SGIS.aiSummaryError = e.message;
                if (SGIS.tab === 'dynamics' && SGIS.dynamicsMode === 'ai') {
                    renderDynamicsContent();
                }
            });
            return _renderDynamicsAiLoading();
        }

        function renderDynamicsContent() {
            const d = _prepareDynamicsData();
            if (d.news.length === 0) {
                setBody(_renderDynamicsEmpty());
                return;
            }
            let contentHtml;
            if (d.isAiMode) {
                if (SGIS.aiSummaryLoading) contentHtml = _renderDynamicsAiLoading();
                else if (SGIS.aiSummaryError) contentHtml = _renderDynamicsAiError();
                else if (SGIS.aiSummary) contentHtml = _renderDynamicsAiSummary(d);
                else contentHtml = _renderDynamicsAiTrigger(d);
            } else {
                contentHtml = _renderDynamicsOriginal(d);
            }
            setBody(`
                <div class="sgis-section">
                    <div class="sgis-section-title">${SGIS_ICONS.news} 游戏动态与新闻</div>
                    <div style="font-size:11px;color:var(--sgis-text-2);margin-bottom:8px">
                        共 ${d.news.length} 条动态 · 来自 Steam 官方公告/新闻源
                    </div>
                    ${_renderDynamicsToggleBar(d)}
                    ${contentHtml}
                </div>
                <div style="font-size:10px;color:var(--sgis-text-2);text-align:center;margin-top:8px">
                    数据来自 Steam News API · 每30分钟刷新缓存${d.isAiMode ? ' · AI翻译总结由用户配置的模型提供' : ''}
                </div>
            `);
            _bindDynamicsEvents();
        }

        // ==================== 用户档案浮窗 (v2.3) ====================

        // ---- 获取用户摘要 (GetPlayerSummaries) ----
        async function fetchPlayerSummaries(steamId) {
            const apiKey = storage.getApiKey();
            if (!apiKey || !steamId) return null;
            const cacheKey = 'playerSummary_' + steamId;
            const cached = cacheGet(cacheKey);
            if (cached) return cached;
            try {
                const url = `https://api.steampowered.com/ISteamUser/GetPlayerSummaries/v0002/?key=${apiKey}&steamids=${steamId}`;
                const data = await fetchJson(url, { timeout: 12000 });
                const player = data?.response?.players?.[0];
                if (player) {
                    cacheSet(cacheKey, player, 30 * 60 * 1000);
                    return player;
                }
                return null;
            } catch { return null; }
        }

        // v2.3.13: 获取最近游玩（参考 steam-friend-manager 个人库浮窗）
        async function fetchRecentlyPlayedGames(steamId) {
            const apiKey = storage.getApiKey();
            if (!apiKey || !steamId) return [];
            try {
                const url = `https://api.steampowered.com/IPlayerService/GetRecentlyPlayedGames/v0001/?key=${apiKey}&steamid=${steamId}&format=json`;
                const data = await fetchJson(url, { timeout: 12000 });
                return (data?.response?.games || []).map(g => ({
                    appid: g.appid,
                    name: g.name || `App ${g.appid}`,
                    playtime_2weeks: g.playtime_2weeks || 0,
                    playtime_forever: g.playtime_forever || 0,
                    img_icon_url: g.img_icon_url || '',
                }));
            } catch { return []; }
        }

        // 格式化游玩时长（分钟→小时）
        function formatPlaytimeShort(minutes) {
            if (!minutes || minutes === 0) return '0h';
            return Math.floor(minutes / 60) + 'h';
        }

        // ---- 获取 Steam 等级 (从社区页面抓取) ----
        async function fetchSteamLevel(steamId) {
            if (!steamId) return null;
            const cacheKey = 'steamLevel_' + steamId;
            const cached = cacheGet(cacheKey);
            if (cached) return cached;
            try {
                const html = await sglvGmFetchTextRetry(`https://steamcommunity.com/profiles/${steamId}/`, {
                    timeout: 12000,
                });
                const m = html.match(/"player_level":(\d+)/) || html.match(/class="friendPlayerLevelNum"[^>]*>(\d+)/);
                const level = m ? parseInt(m[1], 10) : null;
                if (level != null) cacheSet(cacheKey, level, 60 * 60 * 1000);
                return level;
            } catch { return null; }
        }

        // ---- 获取好友数量 ----
        async function fetchFriendCount(steamId) {
            if (!steamId) return null;
            const cacheKey = 'friendCount_' + steamId;
            const cached = cacheGet(cacheKey);
            if (cached != null) return cached;
            try {
                const auth = await sgisAuthParams(); // v2.3.24: API Key 缺省时回退 access_token
                if (!auth) return null;
                const url = `https://api.steampowered.com/ISteamUser/GetFriendList/v0001/?${auth}&steamid=${steamId}&relationship=friend`;
                const data = await fetchJson(url, { timeout: 12000 });
                const count = data?.friendslist?.friends?.length || 0;
                cacheSet(cacheKey, count, 60 * 60 * 1000);
                return count;
            } catch { return null; }
        }

        // v2.3.27: 轻量愿望单计数（参考 Steam-Wishlist-Exporter 的获取链路，仅供概览 KPI 卡片展示）
        // 优先级: 会话已加载 → GDynamicStore(零请求) → 6h缓存 → GetWishlist API(单请求)
        async function fetchWishlistCount(steamId) {
            // 1. 中央面板本次会话已加载的愿望单列表
            if (Array.isArray(state.wishlistGames) && state.wishlistGames.length > 0) {
                return state.wishlistGames.length;
            }
            // 2. GDynamicStore 即时读取（商店页面，零请求且数据最新）
            try {
                const dsIds = getDynamicStoreAppIds('wishlist');
                if (dsIds.size > 0) return dsIds.size;
            } catch { /* ignore */ }
            // 3. 与愿望单标签页共享的 6h 全量缓存
            const cachedList = cacheGet('wishlistGames');
            if (Array.isArray(cachedList) && cachedList.length > 0) return cachedList.length;
            // 4. 计数缓存（避免重复 API 请求）
            const cacheKey = 'wishlistCount_' + steamId;
            const cachedCount = cacheGet(cacheKey);
            if (cachedCount != null) return cachedCount;
            // 5. GetWishlist API 单请求兜底
            if (steamId) {
                try {
                    const entries = await fetchWishlistFromApi(steamId);
                    if (entries.length > 0) {
                        cacheSet(cacheKey, entries.length, 6 * 3600 * 1000);
                        return entries.length;
                    }
                } catch { /* ignore */ }
            }
            return null;
        }

        // ==================== v2.3.8: 社交标签页 - 好友列表完整数据 ====================
        // 参考 steam-friend-manager-1.0.16.js 的批量获取+缓存策略
        // 流程: GetFriendList → GetPlayerSummaries(批量100) → GetPlayerBans(批量100)
        // 缓存: 完整数据 6h, VAC 独立 24h, 等级独立 7天
        const SUMMARY_BATCH = 100;  // GetPlayerSummaries 单次上限
        const VAC_BATCH = 100;      // GetPlayerBans 单次上限

        // ==================== SVG 国旗 (移植自 steam-friend-manager-1.0.16) ====================
        // 内联 SVG 国旗, 不依赖外部 CDN (flagcdn.com), 加载更快/不跨域/失败时降级为文本代码徽章
        const SGIS_FLAGS = {
            CN:'<svg viewBox="0 0 64 48"><path fill="#de2910" d="M0 0h64v48H0z"/><polygon fill="#ffde00" points="10.67,4.80 12.28,9.78 17.51,9.78 13.28,12.85 14.90,17.82 10.67,14.75 6.43,17.82 8.05,12.85 3.82,9.78 9.05,9.78"/><polygon fill="#ffde00" points="20.34,6.14 21.42,4.77 20.44,3.32 22.08,3.92 23.15,2.54 23.09,4.29 24.73,4.88 23.06,5.36 23.00,7.11 22.02,5.66"/><polygon fill="#ffde00" points="24.23,9.98 25.78,9.19 25.51,7.46 26.74,8.69 28.29,7.90 27.51,9.45 28.74,10.68 27.02,10.42 26.23,11.97 25.95,10.25"/><polygon fill="#ffde00" points="24.32,16.07 26.06,16.06 26.59,14.40 27.14,16.06 28.88,16.05 27.47,17.08 28.02,18.74 26.60,17.72 25.20,18.75 25.73,17.09"/><polygon fill="#ffde00" points="20.55,19.99 22.14,20.70 23.31,19.41 23.13,21.14 24.72,21.85 23.01,22.21 22.83,23.95 21.96,22.44 20.26,22.80 21.42,21.50"/></svg>',
            US:'<svg viewBox="0 0 64 48"><path fill="#b22234" d="M0 0h64v48H0z"/><path stroke="#fff" stroke-width="4" d="M0 8h64M0 16h64M0 24h64M0 32h64M0 40h64"/><path fill="#3c3b6e" d="M0 0h28v20H0z"/></svg>',
            JP:'<svg viewBox="0 0 64 48"><path fill="#fff" d="M0 0h64v48H0z"/><circle cx="32" cy="24" r="10" fill="#bc002d"/></svg>',
            KR:'<svg viewBox="0 0 64 48"><path fill="#fff" d="M0 0h64v48H0z"/><circle cx="32" cy="24" r="10" fill="#cd2e3a"/></svg>',
            TW:'<svg viewBox="0 0 64 48"><path fill="#fe0000" d="M0 0h64v48H0z"/><path fill="#000095" d="M0 0h28v20H0z"/><circle cx="14" cy="10" r="5" fill="#fff"/></svg>',
            HK:'<svg viewBox="0 0 64 48"><path fill="#de2910" d="M0 0h64v48H0z"/><path fill="#fff" d="M32 10l3 6 6 1-4 5 1 6-6-3-6 3 1-6-4-5 6-1z"/></svg>',
            MO:'<svg viewBox="0 0 64 48"><path fill="#007944" d="M0 0h64v48H0z"/><path fill="#fff" d="M32 8l3 6 6 1-4 5 1 6-6-3-6 3 1-6-4-5 6-1z"/></svg>',
            GB:'<svg viewBox="0 0 64 48"><path fill="#012169" d="M0 0h64v48H0z"/><path stroke="#fff" stroke-width="10" d="M0 0l64 48M64 0L0 48"/><path stroke="#c8102e" stroke-width="5" d="M0 0l64 48M64 0L0 48"/><path stroke="#fff" stroke-width="14" d="M32 0v48M0 24h64"/><path stroke="#c8102e" stroke-width="8" d="M32 0v48M0 24h64"/></svg>',
            DE:'<svg viewBox="0 0 64 48"><path fill="#000" d="M0 0h64v16H0z"/><path fill="#d00" d="M0 16h64v16H0z"/><path fill="#ffce00" d="M0 32h64v16H0z"/></svg>',
            FR:'<svg viewBox="0 0 64 48"><path fill="#002395" d="M0 0h21v48H0z"/><path fill="#fff" d="M21 0h22v48H21z"/><path fill="#ed2939" d="M43 0h21v48H43z"/></svg>',
            RU:'<svg viewBox="0 0 64 48"><path fill="#fff" d="M0 0h64v16H0z"/><path fill="#0039a6" d="M0 16h64v12H0z"/><path fill="#d52b1e" d="M0 32h64v16H0z"/></svg>',
            AU:'<svg viewBox="0 0 64 48"><path fill="#012169" d="M0 0h64v48H0z"/><path stroke="#fff" stroke-width="6" d="M0 0l28 20M28 0L0 20"/><path stroke="#c8102e" stroke-width="3" d="M0 0l28 20M28 0L0 20"/><circle cx="48" cy="24" r="4" fill="#fff"/></svg>',
            CA:'<svg viewBox="0 0 64 48"><path fill="#ff0000" d="M0 0h16v48H0zm48 0h16v48H48z"/><path fill="#fff" d="M16 0h32v48H16z"/><path fill="#ff0000" d="M32 10l4 10h8l-6 5 2 9-8-5-8 5 2-9-6-5h8z"/></svg>',
            BR:'<svg viewBox="0 0 64 48"><path fill="#009b3a" d="M0 0h64v48H0z"/><path fill="#ffdf00" d="M32 8l20 16-20 16L12 24z"/><circle cx="32" cy="24" r="8" fill="#002776"/></svg>',
            IN:'<svg viewBox="0 0 64 48"><path fill="#ff9933" d="M0 0h64v16H0z"/><path fill="#fff" d="M0 16h64v16H0z"/><path fill="#138808" d="M0 32h64v16H0z"/><circle cx="32" cy="24" r="4" fill="none" stroke="#000080" stroke-width="2"/></svg>',
            SG:'<svg viewBox="0 0 64 48"><path fill="#ef3340" d="M0 0h64v24H0z"/><path fill="#fff" d="M0 24h64v24H0z"/><circle cx="16" cy="12" r="6" fill="#fff"/><circle cx="18" cy="12" r="5" fill="#ef3340"/></svg>',
            MY:'<svg viewBox="0 0 64 48"><path fill="#cc0001" d="M0 0h64v48H0z"/><path stroke="#fff" stroke-width="3" d="M0 6h64M0 12h64M0 18h64M0 24h64M0 30h64M0 36h64M0 42h64"/><path fill="#010066" d="M0 0h28v24H0z"/><circle cx="12" cy="12" r="6" fill="#fc0"/></svg>',
            TH:'<svg viewBox="0 0 64 48"><path fill="#a51931" d="M0 0h64v8H0zm0 40h64v8H0z"/><path fill="#fff" d="M0 8h64v8H0zm0 32h64v8H0z"/><path fill="#2d2a4a" d="M0 16h64v16H0z"/></svg>',
            VN:'<svg viewBox="0 0 64 48"><path fill="#da251d" d="M0 0h64v48H0z"/><path fill="#ff0" d="M32 12l4 12h12l-10 7 4 11-10-7-10 7 4-11-10-7h12z"/></svg>',
            ID:'<svg viewBox="0 0 64 48"><path fill="#ce1126" d="M0 0h64v24H0z"/><path fill="#fff" d="M0 24h64v24H0z"/></svg>',
            PH:'<svg viewBox="0 0 64 48"><path fill="#0038a8" d="M16 0h48v24H16z"/><path fill="#ce1126" d="M16 24h48v24H16z"/><path fill="#fff" d="M0 0l24 24L0 48z"/></svg>',
            NZ:'<svg viewBox="0 0 64 48"><path fill="#012169" d="M0 0h64v48H0z"/><circle cx="46" cy="24" r="4" fill="#c8102e" stroke="#fff" stroke-width="2"/></svg>',
            SE:'<svg viewBox="0 0 64 48"><path fill="#006aa7" d="M0 0h64v48H0z"/><path stroke="#fecc02" stroke-width="6" d="M20 0v48M0 24h64"/></svg>',
            NO:'<svg viewBox="0 0 64 48"><path fill="#ba0c2f" d="M0 0h64v48H0z"/><path stroke="#fff" stroke-width="10" d="M20 0v48M0 24h64"/><path stroke="#00205b" stroke-width="6" d="M20 0v48M0 24h64"/></svg>',
            FI:'<svg viewBox="0 0 64 48"><path fill="#fff" d="M0 0h64v48H0z"/><path stroke="#003580" stroke-width="10" d="M20 0v48M0 24h64"/></svg>',
            DK:'<svg viewBox="0 0 64 48"><path fill="#c8102e" d="M0 0h64v48H0z"/><path stroke="#fff" stroke-width="10" d="M20 0v48M0 24h64"/></svg>',
            NL:'<svg viewBox="0 0 64 48"><path fill="#ae1c28" d="M0 0h64v16H0z"/><path fill="#fff" d="M0 16h64v16H0z"/><path fill="#21468b" d="M0 32h64v16H0z"/></svg>',
            IT:'<svg viewBox="0 0 64 48"><path fill="#009246" d="M0 0h21v48H0z"/><path fill="#fff" d="M21 0h22v48H21z"/><path fill="#ce2b37" d="M43 0h21v48H43z"/></svg>',
            ES:'<svg viewBox="0 0 64 48"><path fill="#aa151b" d="M0 0h64v12H0zm0 36h64v12H0z"/><path fill="#f1bf00" d="M0 12h64v24H0z"/></svg>',
            PL:'<svg viewBox="0 0 64 48"><path fill="#fff" d="M0 0h64v24H0z"/><path fill="#dc143c" d="M0 24h64v24H0z"/></svg>',
            UA:'<svg viewBox="0 0 64 48"><path fill="#0057b7" d="M0 0h64v24H0z"/><path fill="#ffd700" d="M0 24h64v24H0z"/></svg>',
            TR:'<svg viewBox="0 0 64 48"><path fill="#e30a17" d="M0 0h64v48H0z"/><circle cx="26" cy="24" r="10" fill="#fff"/><circle cx="30" cy="24" r="8" fill="#e30a17"/><circle cx="40" cy="24" r="4" fill="#fff"/></svg>',
            SA:'<svg viewBox="0 0 64 48"><path fill="#006c35" d="M0 0h64v48H0z"/><path stroke="#fff" stroke-width="3" d="M16 34h32"/></svg>',
            AE:'<svg viewBox="0 0 64 48"><path fill="#ff0000" d="M0 0h16v48H0z"/><path fill="#00732f" d="M16 0h48v16H16z"/><path fill="#fff" d="M16 16h48v16H16z"/><path fill="#000" d="M16 32h48v16H16z"/></svg>',
            EG:'<svg viewBox="0 0 64 48"><path fill="#ce1126" d="M0 0h64v16H0z"/><path fill="#fff" d="M0 16h64v16H0z"/><path fill="#000" d="M0 32h64v16H0z"/><circle cx="32" cy="24" r="5" fill="#c09300"/></svg>',
            ZA:'<svg viewBox="0 0 64 48"><path fill="#007749" d="M0 0h64v48H0z"/><path fill="#ffb612" d="M0 12h64v24H0z"/><path fill="#fff" d="M0 16h64v16H0z"/><path fill="#de3831" d="M0 20h64v8H0z"/></svg>',
            IL:'<svg viewBox="0 0 64 48"><path fill="#fff" d="M0 0h64v48H0z"/><path stroke="#0038b8" stroke-width="4" d="M0 8h64M0 40h64"/><path fill="none" stroke="#0038b8" stroke-width="2" d="M32 16l8 14H24zM32 32l-8-14h16z"/></svg>',
            MX:'<svg viewBox="0 0 64 48"><path fill="#006847" d="M0 0h21v48H0z"/><path fill="#fff" d="M21 0h22v48H21z"/><path fill="#ce1126" d="M43 0h21v48H43z"/></svg>',
            AR:'<svg viewBox="0 0 64 48"><path fill="#74acdf" d="M0 0h64v16H0zm0 32h64v16H0z"/><path fill="#fff" d="M0 16h64v16H0z"/><circle cx="32" cy="24" r="4" fill="#f6b40e"/></svg>',
            CL:'<svg viewBox="0 0 64 48"><path fill="#fff" d="M0 0h64v24H0z"/><path fill="#d52b1e" d="M0 24h64v24H0z"/><path fill="#0039a6" d="M0 0h20v24H0z"/><circle cx="10" cy="12" r="4" fill="#fff"/></svg>',
            AT:'<svg viewBox="0 0 64 48"><path fill="#ed2939" d="M0 0h64v16H0zm0 32h64v16H0z"/><path fill="#fff" d="M0 16h64v16H0z"/></svg>',
            BE:'<svg viewBox="0 0 64 48"><path fill="#000" d="M0 0h21v48H0z"/><path fill="#fae042" d="M21 0h22v48H21z"/><path fill="#ed2939" d="M43 0h21v48H43z"/></svg>',
            CH:'<svg viewBox="0 0 48 48"><path fill="#d52b1e" d="M0 0h48v48H0z"/><path fill="#fff" d="M20 10h8v28h-8z"/><path fill="#fff" d="M10 20h28v8H10z"/></svg>',
            PT:'<svg viewBox="0 0 64 48"><path fill="#006600" d="M0 0h24v48H0z"/><path fill="#ff0000" d="M24 0h40v48H24z"/></svg>',
            GR:'<svg viewBox="0 0 64 48"><path fill="#0d5eaf" d="M0 0h64v48H0z"/><path stroke="#fff" stroke-width="4" d="M0 8h64M0 16h64M0 24h64M0 32h64M0 40h64"/><path fill="#fff" d="M0 0h28v20H0z"/><path stroke="#0d5eaf" stroke-width="4" d="M0 10h28M14 0v20"/></svg>',
            CZ:'<svg viewBox="0 0 64 48"><path fill="#fff" d="M0 0h64v24H0z"/><path fill="#d7141a" d="M0 24h64v24H0z"/><path fill="#11457e" d="M0 0l32 24L0 48z"/></svg>',
            HU:'<svg viewBox="0 0 64 48"><path fill="#ce2939" d="M0 0h64v16H0z"/><path fill="#fff" d="M0 16h64v16H0z"/><path fill="#477050" d="M0 32h64v16H0z"/></svg>',
            RO:'<svg viewBox="0 0 64 48"><path fill="#002b7f" d="M0 0h21v48H0z"/><path fill="#fcd116" d="M21 0h22v48H21z"/><path fill="#ce1126" d="M43 0h21v48H43z"/></svg>',
            IE:'<svg viewBox="0 0 64 48"><path fill="#009a49" d="M0 0h21v48H0z"/><path fill="#fff" d="M21 0h22v48H21z"/><path fill="#ff8200" d="M43 0h21v48H43z"/></svg>',
            EU:'<svg viewBox="0 0 64 48"><path fill="#003399" d="M0 0h64v48H0z"/><g fill="#ffcc00"><circle cx="32" cy="10" r="1.5"/><circle cx="42" cy="14" r="1.5"/><circle cx="48" cy="22" r="1.5"/><circle cx="48" cy="30" r="1.5"/><circle cx="42" cy="38" r="1.5"/><circle cx="32" cy="42" r="1.5"/><circle cx="22" cy="38" r="1.5"/><circle cx="16" cy="30" r="1.5"/><circle cx="16" cy="22" r="1.5"/><circle cx="22" cy="14" r="1.5"/></g></svg>'
        };

        // ==================== 国家/地区名称映射 (zh-CN) ====================
        const SGIS_COUNTRY_MAP = {
            CN:'中国',US:'美国',JP:'日本',KR:'韩国',TW:'中国台湾',HK:'中国香港',MO:'中国澳门',
            SG:'新加坡',MY:'马来西亚',TH:'泰国',VN:'越南',ID:'印度尼西亚',PH:'菲律宾',
            IN:'印度',AU:'澳大利亚',NZ:'新西兰',GB:'英国',DE:'德国',FR:'法国',IT:'意大利',
            ES:'西班牙',RU:'俄罗斯',BR:'巴西',CA:'加拿大',MX:'墨西哥',AR:'阿根廷',CL:'智利',
            SE:'瑞典',NO:'挪威',FI:'芬兰',DK:'丹麦',NL:'荷兰',BE:'比利时',AT:'奥地利',
            CH:'瑞士',PL:'波兰',CZ:'捷克',PT:'葡萄牙',GR:'希腊',TR:'土耳其',
            SA:'沙特阿拉伯',AE:'阿联酋',EG:'埃及',ZA:'南非',IL:'以色列',UA:'乌克兰',
            RO:'罗马尼亚',HU:'匈牙利',SK:'斯洛伐克',BG:'保加利亚',HR:'克罗地亚',
            SI:'斯洛文尼亚',LT:'立陶宛',LV:'拉脱维亚',EE:'爱沙尼亚',IE:'爱尔兰',
            IS:'冰岛',LU:'卢森堡',MT:'马耳他',CY:'塞浦路斯',EU:'欧盟'
        };

        // 生成 inline SVG 国旗 (默认 18x13), 失败回退文本代码徽章
        function flagSvg(cc, w, h) {
            if (!cc || cc.length < 2) return '';
            const uc = cc.toUpperCase();
            const svg = SGIS_FLAGS[uc];
            const ww = w || 18, hh = h || 13;
            const style = `display:inline-block;width:${ww}px;height:${hh}px;vertical-align:middle;flex-shrink:0;border-radius:1px;box-shadow:0 0 0 1px rgba(255,255,255,0.08)`;
            if (svg) return svg.replace('<svg ', `<svg style="${style}" `);
            return `<svg viewBox="0 0 20 15" style="${style}"><rect width="20" height="15" rx="2" fill="#4a5568"/><text x="10" y="11" text-anchor="middle" font-size="8" font-weight="700" fill="#e2e8f0" font-family="system-ui,sans-serif">${uc}</text></svg>`;
        }

        // 获取国家信息 { name, flag }
        function getCountryInfo(code) {
            if (!code) return null;
            const uc = code.toUpperCase();
            return { code: uc, name: SGIS_COUNTRY_MAP[uc] || uc, flag: flagSvg(uc) };
        }

        // 计算好友天数 (friend_since 是 unix 秒)
        function calcFriendDays(friendSince) {
            if (!friendSince) return { days: 0, text: '未知', cls: 'd-old' };
            const days = Math.floor((Date.now() / 1000 - friendSince) / 86400);
            let text, cls;
            if (days < 30) { text = `${days}天`; cls = 'd-new'; }
            else if (days < 365) { text = `${Math.floor(days / 30)}个月`; cls = 'd-mid'; }
            else { text = `${(days / 365).toFixed(1)}年`; cls = 'd-old'; }
            return { days, text, cls };
        }

        // 获取在线状态文字
        function getPersonaStateText(state) {
            const map = ['离线', '在线', '忙碌', '离开', '休眠', '交易中', '游戏中'];
            return map[state] || '离线';
        }

        // v2.3.24: 统一鉴权参数——优先 API Key，缺省时回退页面 access_token（免配置也可获取好友数据）
        async function sgisAuthParams() {
            const apiKey = storage.getApiKey();
            if (apiKey) return `key=${apiKey}`;
            try {
                const token = await getAccessToken();
                if (token) return `access_token=${token}`;
            } catch { /* ignore */ }
            return '';
        }

        // 获取好友完整数据 (列表+摘要+VAC), 带缓存与增量更新
        async function fetchFriendsList(steamId, opts = {}) {
            // v2.3.24: 鉴权优化——API Key 或 access_token 任一可用即可
            const auth = await sgisAuthParams();
            if (!auth || !steamId) return { error: 'NO_KEY', friends: [] };
            const { force = false } = opts;

            // 1. 检查完整缓存 (6h TTL)
            const listCacheKey = 'friendsList_' + steamId;
            if (!force) {
                const cached = cacheGet(listCacheKey);
                if (cached && cached.friends && cached.friends.length > 0) {
                    return cached;
                }
            }

            // 2. 获取好友列表 (含 friend_since)
            const listUrl = `https://api.steampowered.com/ISteamUser/GetFriendList/v0001/?${auth}&steamid=${steamId}&relationship=friend&format=json`;
            const listData = await fetchJson(listUrl, { timeout: 15000 });
            const rawFriends = listData?.friendslist?.friends || [];
            if (rawFriends.length === 0) {
                return { error: 'EMPTY', friends: [], steamId };
            }
            const steamIds = rawFriends.map(f => f.steamid);

            // 3. 批量获取摘要 (每批 100)
            const summaries = [];
            for (let i = 0; i < steamIds.length; i += SUMMARY_BATCH) {
                const batch = steamIds.slice(i, i + SUMMARY_BATCH);
                try {
                    const sumUrl = `https://api.steampowered.com/ISteamUser/GetPlayerSummaries/v2/?${auth}&steamids=${batch.join(',')}`;
                    const sumData = await fetchJson(sumUrl, { timeout: 15000 });
                    if (sumData?.response?.players) summaries.push(...sumData.response.players);
                } catch (e) { console.warn('[SGIS] GetPlayerSummaries batch failed:', e); }
            }
            const sumMap = new Map(summaries.map(s => [s.steamid, s]));

            // 4. 批量获取 VAC 封禁 (每批 100), 优先用独立缓存
            const vacCacheKey = 'friendsVac_' + steamId;
            const vacCached = cacheGet(vacCacheKey) || {};
            const vacMap = { ...vacCached };
            const needVacIds = steamIds.filter(sid => !vacMap[sid]);
            for (let i = 0; i < needVacIds.length; i += VAC_BATCH) {
                const batch = needVacIds.slice(i, i + VAC_BATCH);
                try {
                    const banUrl = `https://api.steampowered.com/ISteamUser/GetPlayerBans/v1/?${auth}&steamids=${batch.join(',')}`;
                    const banData = await fetchJson(banUrl, { timeout: 15000 });
                    if (banData?.players) {
                        for (const p of banData.players) {
                            vacMap[p.SteamId] = {
                                VACBanned: !!p.VACBanned,
                                DaysSinceLastBan: p.DaysSinceLastBan || 0,
                                NumberOfVACBans: p.NumberOfVACBans || 0,
                                NumberOfGameBans: p.NumberOfGameBans || 0,
                            };
                        }
                    }
                } catch (e) { console.warn('[SGIS] GetPlayerBans batch failed:', e); }
            }
            // VAC 独立缓存 24h
            cacheSet(vacCacheKey, vacMap, CACHE_TTL.friendsVac);

            // 5. 合并数据 (参考 friend-manager fetchAllData 的 enriched 逻辑)
            const friends = rawFriends.map(f => {
                const s = sumMap.get(f.steamid) || {};
                const daysInfo = calcFriendDays(f.friend_since);
                const vacInfo = vacMap[f.steamid] || {};
                const countryInfo = getCountryInfo(s.loccountrycode);
                return {
                    steamid: f.steamid,
                    friend_since: f.friend_since || 0,
                    friend_days: daysInfo.days,
                    friend_days_text: daysInfo.text,
                    friend_days_class: daysInfo.cls,
                    personaname: s.personaname || '匿名玩家',
                    avatar: s.avatar || '',
                    avatarmedium: s.avatarmedium || s.avatar || '',
                    avatarfull: s.avatarfull || s.avatar || '',
                    personastate: s.personastate !== undefined ? s.personastate : 0,
                    lastlogoff: s.lastlogoff || 0,
                    gameextrainfo: s.gameextrainfo || '',
                    gameid: s.gameid || '',
                    loccountrycode: s.loccountrycode || '',
                    // v2.3.8 修复: 预填国家名+SVG国旗, 渲染时直接用, 不再依赖外部 CDN
                    country_name: countryInfo ? countryInfo.name : '',
                    country_flag: countryInfo ? countryInfo.flag : '',
                    profileurl: s.profileurl || `https://steamcommunity.com/profiles/${f.steamid}/`,
                    // VAC 信息
                    vac_banned: !!vacInfo.VACBanned,
                    vac_days_since_last_ban: vacInfo.DaysSinceLastBan || 0,
                    vac_ban_count: vacInfo.NumberOfVACBans || 0,
                    game_ban_count: vacInfo.NumberOfGameBans || 0,
                    // 等级 (从独立缓存读取, fetchFriendsLevels 填充)
                    level: null,
                };
            });

            // 6. 读取等级缓存 (独立 7天 TTL, 可能不完整)
            const levelCacheKey = 'friendsLevels_' + steamId;
            const levelCached = cacheGet(levelCacheKey) || {};
            for (const f of friends) {
                if (levelCached[f.steamid] != null) f.level = levelCached[f.steamid];
            }

            const result = { friends, steamId, total: friends.length, _ts: Date.now() };
            // 完整数据缓存 6h
            cacheSet(listCacheKey, result, CACHE_TTL.friendsList);
            // 同步更新好友数量缓存
            cacheSet('friendCount_' + steamId, friends.length, 60 * 60 * 1000);
            return result;
        }

        // 懒加载好友等级 (GetSteamLevel 单次只接受一个 steamid, 使用 mapLimit 并发)
        // 参考 friend-manager 的并发池思想：v2.3.12 改为 100 并发，点击一次即可自动同步全部未知等级
        async function fetchFriendsLevels(steamId, opts = {}) {
            const auth = await sgisAuthParams(); // v2.3.24: API Key 缺省时回退 access_token
            if (!auth || !steamId) return null;
            const { force = false, maxCount = Infinity } = opts;

            const levelCacheKey = 'friendsLevels_' + steamId;
            const levelCached = force ? {} : (cacheGet(levelCacheKey) || {});
            let changed = false;

            const friends = (SGIS.friendsList && SGIS.friendsList.friends) || [];
            let toFetch = friends.filter(f => f.level == null).map(f => f.steamid);
            if (maxCount !== Infinity && maxCount > 0) {
                toFetch = toFetch.slice(0, maxCount);
            }

            if (toFetch.length === 0) {
                SGIS.friendsLevels = levelCached;
                return levelCached;
            }

            const LEVEL_CONCURRENCY = 100;
            const RENDER_INTERVAL = 800;
            let lastRenderTime = 0;

            // 仅在用户主动触发（按钮点击）时显示实时进度；后台预加载不干扰按钮状态
            if (SGIS.friendsLevelsLoading) {
                SGIS.friendsLevelsTotal = toFetch.length;
                SGIS.friendsLevelsProgress = 0;
            }

            async function fetchOne(sid, attempt = 0) {
                const url = `https://api.steampowered.com/IPlayerService/GetSteamLevel/v1/?${auth}&steamid=${sid}`;
                try {
                    const data = await fetchJson(url, { timeout: 8000 });
                    return data?.response?.player_level ?? 0;
                } catch (e) {
                    if (attempt < 2) {
                        await new Promise(r => setTimeout(r, (attempt + 1) * 800));
                        return fetchOne(sid, attempt + 1);
                    }
                    return undefined;
                }
            }

            await mapLimit(toFetch, LEVEL_CONCURRENCY, async (sid) => {
                const level = await fetchOne(sid);
                if (level !== undefined) {
                    levelCached[sid] = level;
                    const f = friends.find(x => x.steamid === sid);
                    if (f) f.level = level;
                    changed = true;
                }
                if (SGIS.friendsLevelsLoading) {
                    SGIS.friendsLevelsProgress++;
                    const now = Date.now();
                    if (now - lastRenderTime >= RENDER_INTERVAL) {
                        lastRenderTime = now;
                        if (SGIS.tab === 'social') renderSocialContent();
                    }
                }
            });

            if (changed) {
                cacheSet(levelCacheKey, levelCached, CACHE_TTL.friendsLevels);
                for (const f of friends) {
                    if (levelCached[f.steamid] != null) f.level = levelCached[f.steamid];
                }
            }
        }

        // v2.3.13: 手动同步全部好友 VAC/游戏封禁状态 (GetPlayerBans 支持批量 100)
        async function fetchFriendsBans(steamId, opts = {}) {
            const auth = await sgisAuthParams(); // v2.3.24: API Key 缺省时回退 access_token
            if (!auth || !steamId) return null;
            const { force = false } = opts;

            const friends = (SGIS.friendsList && SGIS.friendsList.friends) || [];
            const steamIds = friends.map(f => f.steamid);
            if (steamIds.length === 0) return null;

            const vacCacheKey = 'friendsVac_' + steamId;
            const vacCached = cacheGet(vacCacheKey) || {};
            const vacMap = { ...vacCached };
            let toFetch = steamIds;
            if (!force) {
                toFetch = steamIds.filter(sid => !vacMap[sid]);
            }
            if (toFetch.length === 0) return vacMap;

            const BAN_BATCH = 100;
            const RENDER_INTERVAL = 800;
            let lastRenderTime = 0;
            if (SGIS.friendsBansLoading) {
                SGIS.friendsBansTotal = toFetch.length;
                SGIS.friendsBansProgress = 0;
            }

            for (let i = 0; i < toFetch.length; i += BAN_BATCH) {
                const batch = toFetch.slice(i, i + BAN_BATCH);
                let retry = 0;
                while (retry < 3) {
                    try {
                        const banUrl = `https://api.steampowered.com/ISteamUser/GetPlayerBans/v1/?${auth}&steamids=${batch.join(',')}`;
                        const banData = await fetchJson(banUrl, { timeout: 15000 });
                        if (banData?.players) {
                            for (const p of banData.players) {
                                vacMap[p.SteamId] = {
                                    VACBanned: !!p.VACBanned,
                                    DaysSinceLastBan: p.DaysSinceLastBan || 0,
                                    NumberOfVACBans: p.NumberOfVACBans || 0,
                                    NumberOfGameBans: p.NumberOfGameBans || 0,
                                };
                            }
                        }
                        break;
                    } catch (e) {
                        retry++;
                        console.warn(`[SGIS] GetPlayerBans batch retry ${retry}:`, e);
                        if (retry < 3) await new Promise(r => setTimeout(r, retry * 600));
                    }
                }
                for (const sid of batch) {
                    const info = vacMap[sid];
                    const f = friends.find(x => x.steamid === sid);
                    if (f && info) {
                        f.vac_banned = info.VACBanned;
                        f.vac_days_since_last_ban = info.DaysSinceLastBan || 0;
                        f.vac_ban_count = info.NumberOfVACBans || 0;
                        f.game_ban_count = info.NumberOfGameBans || 0;
                    }
                }
                if (SGIS.friendsBansLoading) {
                    SGIS.friendsBansProgress += batch.length;
                    const now = Date.now();
                    if (now - lastRenderTime >= RENDER_INTERVAL) {
                        lastRenderTime = now;
                        if (SGIS.tab === 'social') renderSocialContent();
                    }
                }
            }

            cacheSet(vacCacheKey, vacMap, CACHE_TTL.friendsVac);
            SGIS.friendsVac = vacMap;
            if (SGIS.friendsBansLoading) SGIS.friendsBansProgress = toFetch.length;
            return vacMap;
        }

        // v2.3.24: 好友游戏数量懒加载（参考 steam-friend-manager 社交仪表盘"游戏总数排行"）
        // GetOwnedGames include_appinfo=0 轻量请求（不拉游戏名，响应更小）；mapLimit 6 并发；12h 缓存；私密资料跳过
        async function fetchFriendsGameCounts(steamId, opts = {}) {
            const auth = await sgisAuthParams();
            if (!auth || !steamId) return null;
            const { force = false } = opts;
            const GC_TTL = 12 * 3600 * 1000;
            const cacheKey = 'friendsGameCounts_' + steamId;
            const gcMap = force ? {} : (cacheGet(cacheKey) || {});
            const friends = (SGIS.friendsList && SGIS.friendsList.friends) || [];
            if (friends.length === 0) return gcMap;
            const now = Date.now();
            const toFetch = friends.map(f => f.steamid).filter(sid => !(gcMap[sid] && now - gcMap[sid].ts < GC_TTL));
            if (toFetch.length === 0) { SGIS.friendsGameCounts = gcMap; return gcMap; }

            if (SGIS.friendsGameCountsLoading) {
                SGIS.friendsGameCountsTotal = toFetch.length;
                SGIS.friendsGameCountsProgress = 0;
            }
            let done = 0;
            await mapLimit(toFetch, 6, async (sid) => {
                try {
                    const data = await fetchJson(`https://api.steampowered.com/IPlayerService/GetOwnedGames/v0001/?${auth}&steamid=${sid}&include_appinfo=0&include_played_free_games=1&format=json`, { timeout: 15000 });
                    const resp = data && data.response;
                    if (resp && typeof resp.game_count === 'number' && resp.game_count > 0) {
                        let tm = 0;
                        (resp.games || []).forEach(g => { tm += g.playtime_forever || 0; });
                        gcMap[sid] = { gc: resp.game_count, tm, ts: now };
                    } else {
                        // 私密资料或无游戏
                        gcMap[sid] = { gc: 0, tm: 0, ts: now, priv: true };
                    }
                } catch { /* 单个失败跳过，下轮再补 */ }
                done++;
                if (SGIS.friendsGameCountsLoading) {
                    SGIS.friendsGameCountsProgress = done;
                    // 直接更新按钮文案，避免整页重绘导致搜索框失焦
                    const btn = document.getElementById('sgis-social-load-gc');
                    if (btn) btn.textContent = `${isZh ? '加载中' : 'Loading'} ${done}/${toFetch.length}`;
                }
            });
            cacheSet(cacheKey, gcMap, GC_TTL);
            SGIS.friendsGameCounts = gcMap;
            return gcMap;
        }

        // ---- 获取 Steam 官方新闻 (促销/更新/活动) ----

        // v2.3.25: 重写官方动态数据获取——接入 featuredcategories API 获取结构化特惠/促销数据
        // 数据源：
        //   1. store.steampowered.com/api/featuredcategories — 当前特惠/每日优惠/聚光灯（含促销活动页URL）
        //   2. api.steampowered.com/ISteamNews/GetNewsForApp — Steam 官方新闻公告
        // 返回结构: { specials:[], dailyDeals:[], spotlights:[], news:[], totalCount:N, fetchedAt:ts }
        async function fetchSteamOfficialNews() {
            const cacheKey = 'steamOfficialNews';
            const cached = cacheGet(cacheKey);
            // v2.3.25: 兼容旧版缓存（旧版返回数组，新版返回对象）
            if (cached && !Array.isArray(cached) && cached.totalCount !== undefined) return cached;

            const result = { specials: [], dailyDeals: [], spotlights: [], news: [], totalCount: 0, fetchedAt: Date.now() };

            // ---- 1. featuredcategories API：获取当前特惠/每日优惠/聚光灯 ----
            try {
                const fcUrl = 'https://store.steampowered.com/api/featuredcategories?cc=us&l=schinese';
                const fcData = await fetchJson(fcUrl, { timeout: 15000 });

                // 1a. 特惠游戏 (specials)
                if (fcData.specials && Array.isArray(fcData.specials.items)) {
                    result.specials = fcData.specials.items
                        .filter(it => it && it.discounted && Number(it.discount_percent) > 0)
                        .slice(0, 20)
                        .map(it => {
                            const discount = Number(it.discount_percent) || 0;
                            const original = Number(it.original_price) || 0;
                            const final = Number(it.final_price) || 0;
                            const exp = Number(it.discount_expiration) || 0;
                            return {
                                appid: it.id,
                                name: it.name || '',
                                discount,
                                originalPrice: original,   // 分
                                finalPrice: final,          // 分
                                currency: it.currency || 'USD',
                                expiration: exp,            // Unix 时间戳
                                headerImage: it.header_image || it.large_capsule_image || '',
                                url: `https://store.steampowered.com/app/${it.id}`,
                            };
                        });
                }

                // 1b. 每日优惠 (cat_dailydeal) — key 不固定，可能是 cat_dailydeal 或数字索引
                const dailyDealKey = Object.keys(fcData).find(k => {
                    const v = fcData[k];
                    return v && v.id === 'cat_dailydeal' && Array.isArray(v.items);
                });
                if (dailyDealKey) {
                    result.dailyDeals = fcData[dailyDealKey].items
                        .filter(it => it && it.discounted)
                        .slice(0, 5)
                        .map(it => {
                            const discount = Number(it.discount_percent) || 0;
                            const original = Number(it.original_price) || 0;
                            const final = Number(it.final_price) || 0;
                            return {
                                appid: it.id,
                                name: it.name || '',
                                discount,
                                originalPrice: original,
                                finalPrice: final,
                                currency: it.currency || 'USD',
                                headerImage: it.header_image || '',
                                url: `https://store.steampowered.com/app/${it.id}`,
                            };
                        });
                }

                // 1c. 聚光灯/促销活动 (cat_spotlight) — 含促销活动页 URL
                const spotlightKeys = Object.keys(fcData).filter(k => {
                    const v = fcData[k];
                    return v && v.id === 'cat_spotlight' && Array.isArray(v.items);
                });
                for (const sk of spotlightKeys) {
                    for (const sp of fcData[sk].items) {
                        if (sp && sp.url && sp.url.includes('/sale/')) {
                            // 从 URL 提取活动名称，如 /sale/Games-Composed-in-Germany
                            const saleNameMatch = sp.url.match(/\/sale\/([^\/\?]+)/);
                            const saleId = saleNameMatch ? saleNameMatch[1] : '';
                            // 去重：同一 saleId 只保留一条
                            if (saleId && result.spotlights.some(s => s.saleId === saleId)) continue;
                            result.spotlights.push({
                                name: sp.name || '促销活动',
                                url: sp.url,
                                saleId,
                                headerImage: sp.header_image || sp.large_capsule_image || '',
                                body: sp.body || '',
                                // v2.9.70: 捕获 discount_expiration 时间戳（部分 spotlight 有此字段）
                                discountExpiration: Number(sp.discount_expiration) || 0,
                            });
                        }
                    }
                }
            } catch (e) {
                console.warn('[SGIS] featuredcategories 获取失败:', e);
            }

            // ---- 2. Steam 官方新闻公告 ----
            // v2.9.111: 原 ISteamNews appid=593050 实为 Dead Rising 4 的 DLC appid，
            // 恒返回空导致"官方新闻"分区始终为 0 条。改用 Steam 官方新闻 RSS（RDF 格式，
            // 无需 key），RSS 失败时回退旧源保持兼容。
            try {
                const raw = await fetchText('https://store.steampowered.com/feeds/news.xml', { timeout: 12000 });
                const blocks = String(raw).match(/<item[\s>][\s\S]*?<\/item>/g) || [];
                const decodeXml = s => String(s || '')
                    .replace(/<!\[CDATA\[|\]\]>/g, '')
                    .replace(/&amp;/g, '&').replace(/&lt;/g, '<').replace(/&gt;/g, '>')
                    .replace(/&quot;/g, '"').replace(/&#39;|&apos;/g, "'")
                    .trim();
                const pickTag = (block, tag) => decodeXml((block.match(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)</${tag}>`)) || [])[1]);
                const items = blocks.slice(0, 15).map(b => {
                    const dateStr = (b.match(/<dc:date[^>]*>([\s\S]*?)<\/dc:date>/) || [])[1] || '';
                    const ts = dateStr ? Math.floor(new Date(decodeXml(dateStr)).getTime() / 1000) : 0;
                    return {
                        title: pickTag(b, 'title'),
                        url: pickTag(b, 'link'),
                        date: ts || 0,
                        contents: sglvCleanNewsText(pickTag(b, 'description').replace(/<[^>]+>/g, '')).slice(0, 300),
                        feedname: 'steam_blog',
                        author: 'Steam',
                    };
                }).filter(n => n.title);
                if (!items.length) throw new Error('RSS 无条目');
                result.news = items;
            } catch (e) {
                console.warn('[SGIS] 官方新闻 RSS 获取失败，回退 ISteamNews:', e.message);
                try {
                    const newsAppIds = [593050]; // 旧源（恒空，仅兜底）
                    const allNews = [];
                    for (const aid of newsAppIds) {
                        try {
                            const newsUrl = 'https://api.steampowered.com/ISteamNews/GetNewsForApp/v2/?appid=' + aid + '&count=20&maxlength=500&format=json';
                            const data = await fetchJson(newsUrl, { timeout: 12000 });
                            const items = (data && data.appnews && data.appnews.newsitems) || [];
                            allNews.push(...items.map(n => ({
                                title: n.title || '',
                                url: n.url || '',
                                date: n.date || 0,
                                contents: sglvCleanNewsText(n.contents).slice(0, 300),
                                feedname: n.feedname || 'steam',
                                author: n.author || '',
                            })));
                        } catch { /* ignore individual appid failures */ }
                    }
                    allNews.sort((a, b) => b.date - a.date);
                    result.news = allNews.slice(0, 15);
                } catch (e2) {
                    console.warn('[SGIS] ISteamNews 获取失败:', e2);
                }
            }

            result.totalCount = result.specials.length + result.dailyDeals.length + result.spotlights.length + result.news.length;
            cacheSet(cacheKey, result, 30 * 60 * 1000);
            return result;
        }

        // ---- v2.3.6: SteamCardExchange 卡牌数据库 (全部有交易卡牌的游戏) ----
        // 数据源: https://www.steamcardexchange.net/api/request.php?GetInventory
        // 返回格式: { data: [ [[appid, name], ..., [size]], ... ] }
        // 解析为: { appId: { name, maxLevel } }  (maxLevel = size, 即徽章最高可达等级)
        const CARD_DB_API_URL = 'https://www.steamcardexchange.net/api/request.php?GetInventory';
        const CARD_DB_CACHE_KEY = 'sgis_card_db_cache';
        const CARD_DB_CACHE_TTL = 24 * 60 * 60 * 1000; // 24小时

        let cardDbData = null;   // { appId: { name, maxLevel } }
        let cardDbLoading = false;

        function getCardDbMaxLevel(appId) {
            if (!cardDbData || !appId) return 0;
            const info = cardDbData[String(appId)];
            return info ? info.maxLevel : 0;
        }

        function getCardDbGameName(appId) {
            if (!cardDbData || !appId) return '';
            const info = cardDbData[String(appId)];
            return info ? info.name : '';
        }

        async function loadCardDatabase() {
            if (cardDbData || cardDbLoading) return cardDbData;
            cardDbLoading = true;
            try {
                // 检查本地缓存
                const cached = GM_getValue(CARD_DB_CACHE_KEY, null);
                if (cached && cached.timestamp && (Date.now() - cached.timestamp < CARD_DB_CACHE_TTL)) {
                    cardDbData = cached.data;
                    console.log(`[SGIS] 卡牌数据库缓存命中: ${Object.keys(cardDbData).length} 款游戏`);
                    return cardDbData;
                }
                console.log('[SGIS] 正在从 SteamCardExchange 获取卡牌数据库...');
                const text = await sglvGmFetchTextRetry(CARD_DB_API_URL, { timeout: 30000 });
                const json = JSON.parse(text);
                if (!json || !json.data || !Array.isArray(json.data)) {
                    throw new Error('API 返回数据格式异常');
                }
                const db = {};
                let count = 0;
                // data[i] = [[appid, name], ..., [size]]
                json.data.forEach((current) => {
                    if (!current || !current[0] || !current[3]) return;
                    const appId = String(current[0][0]);
                    const name = current[0][1] || '';
                    const size = current[3][0] || 0;
                    if (appId && size) {
                        db[appId] = { name, maxLevel: size };
                        count++;
                    }
                });
                cardDbData = db;
                GM_setValue(CARD_DB_CACHE_KEY, { timestamp: Date.now(), data: db });
                console.log(`[SGIS] 卡牌数据库加载完成: ${count} 款游戏`);
                // v2.9.77: 注入到 SGLVBadge 库, 供勋章页卡牌支持检测复用 (免额外 API 请求)
                const _badgeLib = (typeof unsafeWindow !== 'undefined' && unsafeWindow.SGLVBadge)
                    || (typeof window !== 'undefined' && window.SGLVBadge);
                if (_badgeLib && typeof _badgeLib.setCardDb === 'function') {
                    _badgeLib.setCardDb(db);
                }
                return cardDbData;
            } catch (e) {
                console.warn('[SGIS] 卡牌数据库加载失败(不影响基本功能):', e.message);
                sglvNotifyNetFail('卡牌数据库 (SteamCardExchange)', e);
                return null;
            } finally {
                cardDbLoading = false;
            }
        }

        // v2.9.0: 桥接卡牌数据库函数到 SGLV_API，供外层 renderGamesList 使用
        SGLV_API.getCardDbMaxLevel = getCardDbMaxLevel;
        SGLV_API.getCardDbGameName = getCardDbGameName;
        SGLV_API.loadCardDatabase = loadCardDatabase;
        // v2.9.90: 桥接 SGIS 玩家档案数据到 SGLV_API，供个人展柜标签页复用
        SGLV_API.getSGISProfile = () => SGIS.profile || null;
        SGLV_API.fetchSGISProfile = () => { renderProfile({ force: false }); };
        // v2.9.94: 桥接 SGIS 徽章数据和活动 appid 映射, 供展柜徽章展示复用
        SGLV_API.getSGISUserBadges = () => SGIS.userBadges || null;
        SGLV_API.getSteamEventAppIdMap = () => typeof STEAM_EVENT_APPID_MAP !== 'undefined' ? STEAM_EVENT_APPID_MAP : null;
        // v2.9.101: 桥接 REGIONS 国家码→币种查询，供主作用域 wlCurrencyOf 兜底链使用（REGIONS 在子闭包内，外层不可见）
        SGLV_API.getRegionCurrency = (cc) => {
            const r = REGIONS.find(x => x.code === String(cc || '').toUpperCase());
            return r ? r.currency : '';
        };
        // v2.9.102: 桥接汇率桥接层供主作用域使用 —— computeWishlistStats 经 aggregate 折算(getUsdRates),
        // computeWishlistStatsCached 货币指纹小时级快照(getRatesTs);拿不到时调用方降级(传 0/null)
        SGLV_API.getUsdRates = () => getUsdRates();
        SGLV_API.getRatesTs = () => getRatesTs();

        // ---- 获取用户勋章/徽章 ----
        // v2.3.7: 增加浏览器持久缓存与数据合理性校验, 避免 API 异常时覆盖已有正确缓存
        const PROFILE_CACHE_KEY = 'sgis_profile_cache_v1';
        const USER_BADGES_CACHE_KEY = 'sgis_user_badges_cache_v1';
        const PROFILE_CACHE_TTL = 7 * 24 * 3600 * 1000; // 7 天 (实际过期由失效条件控制)

        function readPersistentProfileCache(steamId) {
            try {
                const raw = GM_getValue(PROFILE_CACHE_KEY, null);
                if (!raw) return null;
                const obj = JSON.parse(raw);
                if (!obj || obj.steamId !== steamId) return null;
                if (obj.expires && Date.now() > obj.expires) {
                    GM_setValue(PROFILE_CACHE_KEY, '');
                    return null;
                }
                return obj.data || null;
            } catch { return null; }
        }
        function writePersistentProfileCache(steamId, data) {
            try {
                GM_setValue(PROFILE_CACHE_KEY, JSON.stringify({ steamId, data, expires: Date.now() + PROFILE_CACHE_TTL }));
            } catch { /* ignore quota errors */ }
        }
        function readPersistentUserBadgesCache(steamId) {
            try {
                const raw = GM_getValue(USER_BADGES_CACHE_KEY, null);
                if (!raw) return null;
                const obj = JSON.parse(raw);
                if (!obj || obj.steamId !== steamId) return null;
                if (obj.expires && Date.now() > obj.expires) {
                    GM_setValue(USER_BADGES_CACHE_KEY, '');
                    return null;
                }
                return obj.data || null;
            } catch { return null; }
        }
        function writePersistentUserBadgesCache(steamId, data) {
            try {
                GM_setValue(USER_BADGES_CACHE_KEY, JSON.stringify({ steamId, data, expires: Date.now() + PROFILE_CACHE_TTL }));
            } catch { /* ignore quota errors */ }
        }

        // v2.3.7: 校验 GetBadges 数据是否比缓存更"合理"
        // 核心规则: 等级进度 (playerXp - curLevelXp) 不应低于缓存值 (经验只增不减)
        function isBadgeDataBetterThanCache(newData, cachedData) {
            if (!cachedData) return true;
            if (!newData) return false;
            // 等级不能降低
            if ((newData.playerLevel || 0) < (cachedData.playerLevel || 0)) return false;
            // 总经验不能降低
            if ((newData.playerXp || 0) < (cachedData.playerXp || 0)) return false;
            // 计算当前等级进度 (使用公式得出 curLevelXp, 因为 API 阈值可能异常)
            function curLevelThreshold(d) {
                const L = d.playerLevel || 0;
                if (L <= 0) return 0;
                let xp = 0;
                let bracketStart = 1;
                let perLevel = 100;
                while (bracketStart < L) {
                    const bracketEnd = Math.min(bracketStart + 10, L);
                    xp += (bracketEnd - bracketStart) * perLevel;
                    bracketStart += 10;
                    perLevel += 100;
                }
                return xp;
            }
            const newProgress = Math.max(0, (newData.playerXp || 0) - curLevelThreshold(newData));
            const cachedProgress = Math.max(0, (cachedData.playerXp || 0) - curLevelThreshold(cachedData));
            // 如果新进度明显低于缓存进度, 认为 API 数据异常, 不更新缓存
            if (newProgress < cachedProgress - 100) return false;
            return true;
        }

        async function fetchUserBadges(steamId, opts = {}) {
            const apiKey = storage.getApiKey();
            if (!apiKey || !steamId) return null;
            const { force = false } = opts;
            const cacheKey = 'userBadges_' + steamId;
            const ttlCache = cacheGet(cacheKey);
            const persistentCache = readPersistentUserBadgesCache(steamId);
            const cached = force ? null : (ttlCache || persistentCache);
            if (cached && !force) {
                return enrichBadgesWithGameNames(cached);
            }
            try {
                const url = `https://api.steampowered.com/IPlayerService/GetBadges/v1/?key=${apiKey}&steamid=${steamId}`;
                const data = await fetchJson(url, { timeout: 12000 });
                const badges = data?.response?.badges || [];
                const playerLevel = data?.response?.player_level || 0;
                const playerXp = data?.response?.player_xp || 0;
                // v2.3.7: 获取 API 提供的等级 XP 阈值 (权威值, 避免公式计算误差)
                const playerXpNeededCurrentLevel = data?.response?.player_xp_needed_current_level || 0;
                const playerXpNeededToLevelUp = data?.response?.player_xp_needed_to_level_up || 0;
                const result = { badges, playerLevel, playerXp, playerXpNeededCurrentLevel, playerXpNeededToLevelUp, _ts: Date.now() };
                // v2.3.7: 数据合理性校验, 如果新数据比缓存差则保留旧缓存
                const keepOld = cached && !isBadgeDataBetterThanCache(result, cached);
                if (keepOld) {
                    console.log('[SGIS] GetBadges API 数据异常(进度低于缓存), 保留旧缓存');
                    return enrichBadgesWithGameNames(cached);
                }
                cacheSet(cacheKey, result, 6 * 3600 * 1000);
                writePersistentUserBadgesCache(steamId, result);
                return enrichBadgesWithGameNames(result);
            } catch {
                // 网络失败时回退到持久缓存
                if (persistentCache) return enrichBadgesWithGameNames(persistentCache);
                return null;
            }
        }

        // ---- 用本地游戏库补全 badge.gameName (v2.3.1.1 修复) ----
        // GetBadges API 不返回 badge 名称, 用 state.ownedGames 反查
        // v2.3.6: 增加用 SteamCardExchange API 数据补全名称 (覆盖未拥有但有徽章的游戏)
        function enrichBadgesWithGameNames(badgeData) {
            if (!badgeData || !badgeData.badges) return badgeData;
            const owned = (state.ownedGames && state.ownedGames.length) ? state.ownedGames : storage.getCachedGames();
            const ownedMap = {};
            owned.forEach(g => { if (g && g.appid) ownedMap[String(g.appid)] = g.name; });
            badgeData.badges.forEach(b => {
                if (b.appid > 0) {
                    // v2.3.6: 优先用本地游戏库名称, 回退到卡牌数据库API名称
                    b._gameName = ownedMap[String(b.appid)] || getCardDbGameName(b.appid) || '';
                    b._hasGameName = !!b._gameName;
                    // v2.3.6: 补充最大等级信息
                    b._maxLevel = getCardDbMaxLevel(b.appid);
                }
                // 节日徽章 / 社区徽章: 用 communityitemid / type / completion_time 推断
                if (b.communityitemid) {
                    b._isCommunityBadge = true;
                }
            });
            return badgeData;
        }

        // ---- 节日 / 活动徽章名称映射 (v2.3.5 扩展) ----
        // Steam 节日活动 appid 常见列表 (从社区维护)
        // v2.3.5: 增加 Steam Awards(Steam 大奖)投票活动 appid + 历年活动
        const STEAM_EVENT_APPID_MAP = {
            // 2026
            4761370: '2026 年夏日特卖',
            // 2025
            4113600: '2025 年冬日特卖',
            4098760: '2025 年夏日特卖',
            3902760: '2025 年春季特卖',
            // 2024
            3567630: '2024 年冬日特卖',
            3443010: '2024 年夏日特卖',
            3220140: '2024 年春季特卖',
            // 2023
            3091960: '2023 年冬日特卖',
            2881690: '2023 年夏日特卖',
            2700500: '2023 年春季特卖',
            // 2022
            2682730: '2022 年冬日特卖',
            2489650: '2022 年夏日特卖',
            2320430: '2022 年秋季特卖',
            // 2021
            2285690: '2021 年冬日特卖',
            2111170: '2021 年夏日特卖',
            1977630: '2021 年秋季特卖',
            // 2020
            1919510: '2020 年冬日特卖',
            1708140: '2020 年夏日特卖',
            1624910: '2020 年秋季特卖',
            // 2019
            1531430: '2019 年冬日特卖',
            1411040: '2019 年夏日特卖',
            1283310: '2019 年秋季特卖',
            // 2018
            1254900: '2018 年冬日特卖',
            1111370: '2018 年夏日特卖',
            977950: '2018 年秋季特卖',
            // 2017
            991980: '2017 年冬日特卖',
            866930: '2017 年夏日特卖',
            748210: '2017 年冬日特卖',
            // 2016
            630870: '2016 年夏日特卖',
            516940: '2016 年冬日特卖',
            // 2015
            408590: '2015 年夏日特卖',
            302200: '2015 年冬日特卖',
            // 2014
            224260: '2014 年夏日特卖',
            161330: '2014 年冬日特卖',
            // 2013
            104700: '2013 年夏日特卖',
            57430: '2013 年冬日特卖',
            // 2012
            207250: '2012 年假日特卖',

            // ===== Steam Awards (Steam 大奖) 投票活动 =====
            // Steam Awards 每年秋季特卖期间举办, 有专门的投票 appid
            4770200: '2025 Steam 大奖投票',
            4149180: '2024 Steam 大奖投票',
            3934100: '2023 Steam 大奖投票',
            3711000: '2022 Steam 大奖投票',
            3510200: '2021 Steam 大奖投票',
            3326500: '2020 Steam 大奖投票',
            3125400: '2019 Steam 大奖投票',
            2944230: '2018 Steam 大奖投票',

            // ===== 其他特殊活动 =====
            1510: 'Steam 大奖 (2016)',
            660: 'Steam 大奖 (2015)',
            531: 'Steam 大奖 (2014)',

            // ===== Steam 游戏庆祝/周年活动 =====
            2519800: 'Steam 20 周年纪念',
            1978740: 'Steam 18 周年纪念',
        };
        // v2.3.7: 活动徽章图标 CDN 基础 URL (借鉴 steam-badges-card-view 脚本)
        // Steam 节日活动徽章图标存储在 steamcommunity/public/images/items/{appid}/ 路径下
        const ACTIVITY_ICON_CDN = 'https://cdn.cloudflare.steamstatic.com/steamcommunity/public/images/items/';
        // v2.3.7: 构建活动徽章图标 URL (icon_64x64.png)
        function getActivityIconUrl(appid) {
            if (!appid) return '';
            return ACTIVITY_ICON_CDN + appid + '/icon_64x64.png';
        }

        // v2.3.5: 推断 badge 是否属于 Steam 节日活动
        // 1) 优先查已知 appid 表
        // 2) 辅助检测: appid > 3000000 且不在用户游戏库中的, 很可能是节日活动
        function detectEventBadge(b) {
            if (!b.appid) return null;
            const eventName = STEAM_EVENT_APPID_MAP[String(b.appid)];
            if (eventName) return { name: eventName, appid: b.appid };
            // v2.3.5: 辅助检测 - appid > 3000000 且没有对应游戏名(不在游戏库中)
            // Steam 节日活动 appid 通常很大(300万+), 且用户不会"拥有"这些"游戏"
            if (b.appid > 3000000 && !b._hasGameName) {
                return { name: 'Steam 活动 #' + b.appid, appid: b.appid };
            }
            return null;
        }

        // ==================== 概览标签 (用户 Hero) ====================
        // v2.3.7: 读取持久化 profile 缓存, 并检查游戏库数量变化标记
        function shouldInvalidateProfileCache(steamId) {
            try {
                const cached = readPersistentProfileCache(steamId);
                if (!cached) return true;
                // v2.9.2: 使用排除家庭组共享和 DLC 后的游戏数量，确保统计一致性
                const currentGameCount = getStatFilteredGames().length;
                // 如果游戏库数量变化, 视为缓存失效 (游戏数量可能影响统计展示)
                if ((cached.gameCount || 0) !== currentGameCount) return true;
                return false;
            } catch { return true; }
        }

        function renderProfile(opts = {}) {
            const { force = false } = opts;
            const steamId = getActiveSteamId();
            // v2.9.3: 异步触发 DLC 数据库加载（首次打开侧栏时），加载完成后刷新统计
            // v2.9.6: 同时触发全库存应用类型获取，补充 Barter.vg 未覆盖的 DLC
            if (SGLV_API.loadDlcDatabase) {
                SGLV_API.loadDlcDatabase().then(() => {
                    if (SGIS.profile && !SGIS.profileLoading) renderProfileContent();
                    // v2.9.6: DLC 数据库加载后，启动全库存 type 获取，完成后再次刷新 DLC 数量
                    if (SGLV_API.enrichOwnedAppTypes) {
                        SGLV_API.enrichOwnedAppTypes().then(() => {
                            if (SGIS.profile && !SGIS.profileLoading) renderProfileContent();
                        }).catch(() => {});
                    }
                }).catch(() => {});
            }
            // v2.3.7: 非强制刷新时, 先尝试使用内存与持久缓存
            if (!force && SGIS.profile) { renderProfileContent(); return; }
            if (SGIS.profileLoading) return;
            SGIS.profileLoading = true;
            renderLoading('正在获取用户档案…');
            if (!steamId) {
                SGIS.profileLoading = false;
                setBody(`<div class="sgis-state">
                    <div style="font-size:36px;margin-bottom:8px">${SGIS_ICONS.user}</div>
                    <div>未检测到 SteamID</div>
                    <div style="font-size:11px;color:var(--sgis-text-2);margin-top:8px;padding:0 16px;line-height:1.5">
                        请在设置中配置 SteamID64，或访问你的 Steam 个人主页后重试。
                    </div>
                </div>`);
                return;
            }
            // v2.3.7: 检查是否需要强制失效缓存
            const cacheInvalid = force || shouldInvalidateProfileCache(steamId);
            const cachedProfile = !cacheInvalid ? readPersistentProfileCache(steamId) : null;
            if (cachedProfile && cachedProfile.summary) {
                SGIS.profile = cachedProfile;
                SGIS.profileLoading = false;
                renderProfileContent();
                return;
            }
            // 同时获取 userBadges 用于 XP 计算 (force 时强制刷新)
            Promise.all([
                fetchPlayerSummaries(steamId),
                fetchSteamLevel(steamId),
                fetchFriendCount(steamId),
                fetchUserBadges(steamId, { force }).catch(() => null),
                fetchRecentlyPlayedGames(steamId).catch(() => []),
                fetchWishlistCount(steamId).catch(() => null), // v2.3.27: 愿望单计数（KPI 卡片）
            ]).then(([summary, level, friendCount, userBadges, recentGames, wishlistCount]) => {
                // v2.9.2: 使用排除家庭组共享和 DLC 后的游戏数量
                const gameCount = getStatFilteredGames().length;
                const profileData = { summary, level, friendCount, userBadges, steamId, gameCount, recentGames, wishlistCount };
                SGIS.profile = profileData;
                SGIS.profileLoading = false;
                writePersistentProfileCache(steamId, profileData);
                renderProfileContent();
            }).catch(e => {
                SGIS.profileLoading = false;
                renderError('用户档案获取失败: ' + e.message);
            });
        }

function xpRequiredToReachLevel(L) {
            if (L <= 1) return 0;
            let xp = 0;
            let bracketStart = 1;
            let perLevel = 100;
            while (bracketStart < L) {
                const bracketEnd = Math.min(bracketStart + 10, L);
                const levelsInBracket = bracketEnd - bracketStart;
                xp += levelsInBracket * perLevel;
                bracketStart += 10;
                perLevel += 100;
            }
            return xp;
        }

        // v2.11.28 (FEAT-014 TASK-004): 段渲染器 — header
        function _renderProfileHeader(data) {
            return `<!-- 主面板卡片 (大圆角头像 + 等级徽章 + STEAM ID) -->
            <div class="sgis-profile-main-card">
                <div class="sgis-profile-main-card-bg" aria-hidden="true"></div>
                <div class="sgis-profile-head">
                    <div class="sgis-profile-avatar-wrap">
                        <img class="sgis-profile-avatar" src="${data.avatarUrl}" alt="" onerror="this.src='data:image/svg+xml;utf8,<svg xmlns=%22http://www.w3.org/2000/svg%22 viewBox=%220 0 80 80%22><rect width=%2280%22 height=%2280%22 fill=%22%231b2838%22/><text x=%2240%22 y=%2248%22 text-anchor=%22middle%22 font-size=%2230%22 fill=%22%2366c0f4%22>${(data.personaName || '?').slice(0, 1).toUpperCase()}</text></svg>'">
                    </div>
                    <div class="sgis-profile-info">
                        <div class="sgis-profile-name-row">
                            <div class="sgis-profile-name">${data.personaName}</div>
                            <div class="sgis-profile-level-badge" title="Steam 等级 Lv.${data.playerLevel}">Lv.${data.playerLevel}</div>
                        </div>
                        <div class="sgis-profile-steamid-row">
                            <div class="sgis-profile-steamid">${data.steamIdShort || '?'}</div>
                            ${data.steamIdShort ? `<button class="sgis-copy-btn" id="sgis-copy-steamid" title="复制 SteamID">${data.SGIS_ICONS.copy}</button>` : ''}
                        </div>
                    </div>
                    <!-- v2.3.27: 好友数量进度环（参考 steam-friend-manager，点击进入社交标签） -->
                    <div class="sgis-friend-gauge" id="sgis-friend-gauge" title="好友 ${data.friendCount} / ${data.friendLimit}（上限随等级增长）· 点击查看社交">
                        <div><svg viewBox="0 0 120 64" width="104" height="56"><path d="M 12,58 A 48,48 0 0 1 108,58" fill="none" stroke="rgba(255,255,255,0.08)" stroke-width="10" stroke-linecap="round"/><path d="M 12,58 A 48,48 0 0 1 108,58" fill="none" stroke="#10b981" stroke-width="10" stroke-linecap="round" stroke-dasharray="${data.ringDash} ${data.ringCirc}"/></svg></div>
                        <div class="sgis-friend-gauge-text"><b>${data.friendCount}</b><span>/ ${data.friendLimit}</span></div>
                        <div class="sgis-friend-gauge-lbl">好友数</div>
                    </div>
                </div>

                <!-- 5 列统计卡 (v2.9.5: 新增 DLC 数量卡片, 游戏与 DLC 分别展示; 卡片可点击跳转) -->
                <div class="sgis-profile-stats cols-5">
                    <div class="sgis-profile-stat clickable" id="sgis-stat-games" style="color:#3b82f6" title="打开游戏库浮窗">
                        <div class="sgis-profile-stat-icon t-blue">${data.SGIS_ICONS.barChart}</div>
                        <div class="sgis-profile-stat-val t-blue">${data.gameCount.toLocaleString()}</div>
                        <div class="sgis-profile-stat-label">Games</div>
                    </div>
                    <div class="sgis-profile-stat clickable" id="sgis-stat-dlc" style="color:#ec4899" title="打开游戏库浮窗·仅 DLC 筛选">
                        <div class="sgis-profile-stat-icon" style="color:#ec4899">${data.SGIS_ICONS.package}</div>
                        <div class="sgis-profile-stat-val" style="color:#ec4899">${data.dlcDisplay}</div>
                        <div class="sgis-profile-stat-label">DLC</div>
                    </div>
                    <div class="sgis-profile-stat clickable" id="sgis-stat-badges" style="color:var(--sglv-accent-deep)" title="查看 Steam 勋章页面">
                        <div class="sgis-profile-stat-icon t-purple">${data.SGIS_ICONS.medal}</div>
                        <div class="sgis-profile-stat-val t-purple">${data.badgeCount.toLocaleString()}</div>
                        <div class="sgis-profile-stat-label">Badges</div>
                    </div>
                    <div class="sgis-profile-stat clickable" id="sgis-stat-wishlist" style="color:#f43f5e" title="查看 Steam 愿望单页面">
                        <div class="sgis-profile-stat-icon t-rose">${data.SGIS_ICONS.heart}</div>
                        <div class="sgis-profile-stat-val t-rose" id="sgis-stat-wishlist-val">${data.wishlistDisplay}</div>
                        <div class="sgis-profile-stat-label">Wishlist</div>
                    </div>
                    <div class="sgis-profile-stat" style="color:#10b981">
                        <div class="sgis-profile-stat-icon t-green">${data.SGIS_ICONS.clock}</div>
                        <div class="sgis-profile-stat-val t-green">${data.totalHours >= 1000 ? (data.totalHours / 1000).toFixed(1) + 'k' : data.totalHours}h</div>
                        <div class="sgis-profile-stat-label">Playtime</div>
                    </div>
                </div>
            </div>

            `;
        }

        // v2.11.28 (FEAT-014 TASK-004): 段渲染器 — xp
        function _renderProfileXp(data) {
            return `<!-- 经验值进度条卡片 (v2.3.4: 修正公式, 完整展示) -->
            <div class="sgis-xp-card">
                <div class="sgis-xp-head">
                    <div class="sgis-xp-title">
                        <div class="sgis-xp-title-icon">
                            <svg viewBox="0 0 24 24" fill="currentColor"><polygon points="13 2 3 14 12 14 11 22 21 10 12 10 13 2"/></svg>
                        </div>
                        经验值 · 等级进度
                    </div>
                    <div class="sgis-xp-levels">
                        <span class="cur">Lv.${data.playerLevel}</span>
                        <span class="arrow">→</span>
                        ${data.isMaxLevel
                            ? `<span class="next" style="color:#fbbf24">MAX</span>`
                            : `<span class="next">Lv.${data.playerLevel + 1}</span>`}
                    </div>
                </div>
                <div class="sgis-xp-bar">
                    ${data.hbarRow({ cls: 'xp', pct: data.xpPercent.toFixed(1) })}
                </div>
                <div class="sgis-xp-meta">
                    ${data.isMaxLevel
                        ? `<div class="sgis-xp-current"><b>已达成</b> · 满级</div>
                           <div class="sgis-xp-percent" style="color:#fbbf24">100%</div>`
                        : `<div class="sgis-xp-current"><b>${data.currentIntoLevel.toLocaleString()}</b> / ${data.xpDelta.toLocaleString()} XP · 还差 <b>${data.xpToNext.toLocaleString()}</b> XP</div>
                           <div class="sgis-xp-percent">${data.xpPercent.toFixed(0)}%</div>`}
                </div>
                <div class="sgis-xp-footer">
                    <div>累计经验${data.totalXp === 0 && data.playerLevel > 0 ? ' <span style="opacity:0.5">(估算)</span>' : ''}</div>
                    <div class="sgis-xp-total"><b>${data.totalXpDisplay.toLocaleString()}</b> XP ${data.totalXpDisplay >= 1000 ? `(${(data.totalXpDisplay / 1000).toFixed(1)}k)` : ''}</div>
                </div>
            </div>

            `;
        }

        // v2.11.28 (FEAT-014 TASK-004): 段渲染器 — features
        function _renderProfileFeatures(data) {
            return `<!-- 战绩总览 / 游戏人生 双大卡 -->
            <div class="sgis-feature-grid">
                <div class="sgis-feature-card" id="sgis-feature-stats" title="查看详细统计">
                    <div class="sgis-feature-head">
                        <div class="sgis-feature-icon">${data.SGIS_ICONS.trophy}</div>
                        <div class="sgis-feature-titles">
                            <div class="sgis-feature-title">战绩总览</div>
                            <div class="sgis-feature-sub">Battle Stats</div>
                        </div>
                        <svg class="sgis-feature-arrow" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="9 18 15 12 9 6"/></svg>
                    </div>
                    <div class="sgis-feature-stats sgis-feature-stats-3">
                        <div class="sgis-feature-stat">
                            <div class="sgis-feature-stat-lbl">已游玩</div>
                            <div class="sgis-feature-stat-val t-blue">${data.playedGames}</div>
                        </div>
                        <div class="sgis-feature-stat">
                            <div class="sgis-feature-stat-lbl">完成度</div>
                            <div class="sgis-feature-stat-val t-green">${data.completeRate}%</div>
                        </div>
                        <div class="sgis-feature-stat">
                            <div class="sgis-feature-stat-lbl">平均时长</div>
                            <div class="sgis-feature-stat-val t-amber">${data.avgHours}h</div>
                        </div>
                    </div>
                </div>
                <div class="sgis-feature-card alt" id="sgis-feature-achievements" title="查看成就">
                    <div class="sgis-feature-head">
                        <div class="sgis-feature-icon">${data.SGIS_ICONS.sparkle}</div>
                        <div class="sgis-feature-titles">
                            <div class="sgis-feature-title">游戏人生</div>
                            <div class="sgis-feature-sub">Gamer Profile</div>
                        </div>
                        <svg class="sgis-feature-arrow" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="9 18 15 12 9 6"/></svg>
                    </div>
                    <div class="sgis-feature-stats">
                        <div class="sgis-feature-stat">
                            <div class="sgis-feature-stat-lbl">总时长</div>
                            <div class="sgis-feature-stat-val t-purple">${data.totalHours >= 1000 ? (data.totalHours / 1000).toFixed(1) + 'k' : data.totalHours}h</div>
                        </div>
                        <div class="sgis-feature-stat">
                            <div class="sgis-feature-stat-lbl">成就数</div>
                            <div class="sgis-feature-stat-val t-blue">${data.badgeCount}</div>
                        </div>
                    </div>
                </div>
            </div>

            `;
        }

        // v2.11.28 (FEAT-014 TASK-004): 段渲染器 — sections
        function _renderProfileSections(data) {
            return `<!-- 最近游玩 (v2.3.27: 移至游戏人生卡片下方) -->
            <div class="sgis-section">
                <div class="sgis-section-title">${data.SGIS_ICONS.game} 最近游玩</div>
                ${data.recentGames.length === 0 ? '<div class="sgis-state" style="padding:12px">最近 2 周未游玩任何游戏</div>' : data.recentGamesHtml}
            </div>

            ${data.wishlistSaleHtml}

            <!-- 快捷链接 -->
            <div class="sgis-section">
                <div class="sgis-section-title">${data.SGIS_ICONS.link} 快捷链接</div>
                <div class="sgis-links">
                    <a class="sgis-link" href="${data.profileUrl}" target="_blank" rel="noopener">个人主页</a>
                    <a class="sgis-link" href="${data.profileUrl}inventory/" target="_blank" rel="noopener">库存</a>
                    <a class="sgis-link" href="${data.profileUrl}badges/" target="_blank" rel="noopener">勋章</a>
                    <a class="sgis-link" href="${data.profileUrl}games/" target="_blank" rel="noopener">游戏库</a>
                    <a class="sgis-link" href="${data.profileUrl}friends/" target="_blank" rel="noopener">好友</a>
                    <a class="sgis-link" href="https://steamcommunity.com/my/recommended/" target="_blank" rel="noopener">评测</a>
                </div>
            </div>
            <div style="font-size:10px;color:var(--sgis-text-2);text-align:center;margin-top:8px">
                数据来自 Steam Web API · 缓存30分钟
            </div>
`;
        }

                // v2.11.28 (FEAT-014 TASK-004): 准备 Profile 渲染所需数据 (从 SGIS.profile 派生所有 KPI 字段)
        function _prepareProfileData(p, s) {
            // 游戏库统计 (v2.9.2: 排除家庭组共享游戏和 DLC,确保统计准确)
            if (SGLV_API.loadDlcDatabaseFromCacheSync) SGLV_API.loadDlcDatabaseFromCacheSync();
            const allGames = getStatFilteredGames();
            const gameCount = allGames.length;
            const dlcCount = getOwnedDlcCount();
            const dlcReady = !!(SGLV_API.isDlcDbReady && SGLV_API.isDlcDbReady());
            const dlcDisplay = dlcReady ? dlcCount.toLocaleString() : '—';
            const totalPlaytime = allGames.reduce((sum, g) => sum + (g.playtime || 0), 0);
            const totalHours = Math.floor(totalPlaytime / 60);
            const friendCount = p.friendCount != null ? p.friendCount : '?';
            const badgeCount = (p.userBadges && p.userBadges.badges) ? p.userBadges.badges.length : 0;
            const totalXp = (p.userBadges && p.userBadges.playerXp) ? p.userBadges.playerXp : 0;
            const level = p.level || '?';
            const playerLevel = (p.userBadges && p.userBadges.playerLevel) ? p.userBadges.playerLevel : (typeof level === 'number' ? level : 0);
            const friendLimit = 300 + playerLevel * 5;
            const fcNum = (typeof friendCount === 'number' && isFinite(friendCount)) ? friendCount : 0;
            const friendRatio = Math.min(1, fcNum / Math.max(1, friendLimit));
            const ringCirc = (Math.PI * 48).toFixed(1);
            const ringDash = (friendRatio * Math.PI * 48).toFixed(1);
            const wishlistCount = p.wishlistCount;
            const wishlistDisplay = (wishlistCount != null) ? Number(wishlistCount).toLocaleString() : '?';

            // XP 计算
            const apiCurLevelXp = (p.userBadges && p.userBadges.playerXpNeededCurrentLevel) ? p.userBadges.playerXpNeededCurrentLevel : 0;
            const apiLevelUpXp = (p.userBadges && p.userBadges.playerXpNeededToLevelUp) ? p.userBadges.playerXpNeededToLevelUp : 0;
            let useApiXp = apiCurLevelXp > 0 && apiLevelUpXp > 0;
            if (useApiXp && totalXp > 0 && totalXp < apiCurLevelXp - 1000) useApiXp = false;
            const curLevelXp = useApiXp ? apiCurLevelXp : xpRequiredToReachLevel(playerLevel);
            const xpDelta = useApiXp ? apiLevelUpXp : (xpRequiredToReachLevel(playerLevel + 1) - curLevelXp);
            const effectiveXp = totalXp > 0 ? totalXp : (playerLevel > 0 ? curLevelXp : 0);
            let currentIntoLevel = Math.max(0, effectiveXp - curLevelXp);
            let safeCurrentIntoLevel = currentIntoLevel;
            let safeXpDelta = Math.max(1, xpDelta);
            if (safeCurrentIntoLevel > safeXpDelta) {
                safeCurrentIntoLevel = Math.max(0, effectiveXp - xpRequiredToReachLevel(playerLevel));
                safeXpDelta = Math.max(1, xpRequiredToReachLevel(playerLevel + 1) - xpRequiredToReachLevel(playerLevel));
                if (safeCurrentIntoLevel > safeXpDelta) safeCurrentIntoLevel = safeXpDelta;
            }
            const xpPercent = Math.max(0, Math.min(100, (safeCurrentIntoLevel / safeXpDelta) * 100));
            const xpToNext = Math.max(0, safeXpDelta - safeCurrentIntoLevel);
            const isMaxLevel = playerLevel <= 0;
            const totalXpDisplay = effectiveXp;

            // 战绩统计
            const playedGames = allGames.filter(g => (g.playtime || 0) > 0).length;
            const unplayedGames = Math.max(0, gameCount - playedGames);
            const avgHours = playedGames > 0 ? Math.round(totalHours / playedGames) : 0;
            const longGames = allGames.filter(g => (g.playtime || 0) >= 600).length;
            const completeRate = playedGames > 0 ? Math.round((longGames / playedGames) * 100) : 0;

            const profileUrl = s.profileurl || `https://steamcommunity.com/profiles/${p.steamId}/`;
            const recentGames = p.recentGames || [];
            const recentGamesHtml = recentGames.slice(0, 8).map(game => {
                const recentH = formatPlaytimeShort(game.playtime_2weeks);
                const totalH = formatPlaytimeShort(game.playtime_forever);
                // v2.11.44: 统一经 getGameIconUrl（community_assets 新路径 + icon 成功缓存）
                const iconUrl = getGameIconUrl(game.appid, game.img_icon_url);
                return `<div class="sgis-timeline-game" style="border-left-color:#06b6d4;" onclick="window.open('https://store.steampowered.com/app/${game.appid}','_blank')">
                    <img class="sgis-timeline-game-icon" src="${iconUrl}" loading="lazy" onerror="this.onerror=null;_sglvIconFallback(this,'${game.appid}','${escHtml(game.img_icon_url || '')}')">
                    <div class="sgis-timeline-game-info">
                        <a class="sgis-timeline-game-name" data-sglv-appid="${game.appid}" href="https://store.steampowered.com/app/${game.appid}" target="_blank" rel="noopener">${game.name}</a>
                        <div style="font-size:10px;color:var(--sgis-text-2);margin-top:2px;">
                            <span style="color:#06b6d4">近2周: ${recentH}</span>
                            <span style="margin:0 6px">·</span>
                            <span>总计: ${totalH}</span>
                        </div>
                    </div>
                </div>`;
            }).join('');
            const wishlistOnSale = (Array.isArray(state.wishlistGames) ? state.wishlistGames : []).filter(g => g && g.discountPct > 0 && !g.isFree).sort((a, b) => (b.discountPct || 0) - (a.discountPct || 0)).slice(0, 8);
            const wishlistSaleHtml = wishlistOnSale.length === 0 ? '' : (() => {
                const items = wishlistOnSale.map(g => {
                    const finalStr = g.finalPrice > 0 ? `¥${g.finalPrice.toFixed(2)}` : (isZh ? '免费' : 'Free');
                    const origStr = g.originalPrice > g.finalPrice ? `¥${g.originalPrice.toFixed(2)}` : '';
                    return `<a class="sgis-wl-sale-item" href="https://store.steampowered.com/app/${g.appid}/" target="_blank" rel="noopener" title="${escHtml(g.name)}">
                        <div class="sgis-wl-sale-name" data-sglv-appid="${g.appid}">${escHtml(g.name)}</div>
                        <div class="sgis-wl-sale-price">
                            <span class="sgis-wl-sale-discount">-${g.discountPct}%</span>
                            <span class="sgis-wl-sale-final">${finalStr}</span>
                            ${origStr ? `<span class="sgis-wl-sale-orig">${origStr}</span>` : ''}
                        </div>
                    </a>`;
                }).join('');
                return `<div class="sgis-section">
                    <div class="sgis-section-title">${SGIS_ICONS.heart || '💝'} ${isZh ? '愿望单促销' : 'Wishlist on Sale'} <span style="font-size:10px;color:var(--sgis-text-2);font-weight:400">${wishlistOnSale.length} ${isZh ? '款打折中' : 'on sale'}</span></div>
                    <div class="sgis-wl-sale-list">${items}</div>
                </div>`;
            })();

            return {
                p, s,
                avatarUrl: s.avatarfull || s.avatarmedium || s.avatar || '',
                personaName: s.personaname || '未知玩家',
                level, realName: s.realname || '', country: s.loccountrycode || '',
                profileUrl, steamIdShort: p.steamId ? String(p.steamId) : '',
                allGames, gameCount, dlcCount, dlcReady, dlcDisplay,
                totalPlaytime, totalHours, friendCount, badgeCount, totalXp, playerLevel,
                friendLimit, fcNum, friendRatio, ringCirc, ringDash,
                wishlistCount, wishlistDisplay,
                apiCurLevelXp, apiLevelUpXp, useApiXp, curLevelXp, xpDelta, effectiveXp,
                currentIntoLevel, safeCurrentIntoLevel, safeXpDelta, xpPercent, xpToNext, isMaxLevel, totalXpDisplay,
                playedGames, unplayedGames, avgHours, longGames, completeRate,
                recentGames, recentGamesHtml, wishlistOnSale, wishlistSaleHtml,
                SGIS_ICONS, hbarRow, escHtml,
            };
        }

        function renderProfileContent() {
            const p = SGIS.profile;
            if (!p || !p.summary) {
                setBody(`<div class="sgis-state">
                    <div style="font-size:36px;margin-bottom:8px">${SGIS_ICONS.user}</div>
                    <div>无法获取用户档案</div>
                    <div style="font-size:11px;color:var(--sgis-text-2);margin-top:8px">
                        请确保 API Key 和 SteamID 配置正确
                    </div>
                </div>`);
                return;
            }
            const s = p.summary;
            const data = _prepareProfileData(p, s);

            setBody(_renderProfileHeader(data) + _renderProfileXp(data) + _renderProfileFeatures(data) + _renderProfileSections(data));

            // v2.3.33：异步加载最近游玩游戏中文名；v2.11.4 改经 applyGameAliases（scope 限定 SGIS 作用域）
            applyGameAliases(document, { scope: '#sgis-body' });

            const featureStats = document.getElementById('sgis-feature-stats');
            if (featureStats) {
                featureStats.addEventListener('click', () => {
                    // 跳转到动态标签(展示详细统计)
                    if (typeof SGIS !== 'undefined') {
                        const panel = document.getElementById('sgis-panel');
                        if (panel) {
                            const tab = panel.querySelector('.sgis-tab[data-tab="userAchievements"]');
                            if (tab) tab.click();
                        }
                    }
                });
            }
            const featureAch = document.getElementById('sgis-feature-achievements');
            if (featureAch) {
                featureAch.addEventListener('click', () => {
                    if (typeof SGIS !== 'undefined') {
                        const panel = document.getElementById('sgis-panel');
                        if (panel) {
                            const tab = panel.querySelector('.sgis-tab[data-tab="userAchievements"]');
                            if (tab) tab.click();
                        }
                    }
                });
            }

            // ==================== v2.3.27: KPI 卡片 + 进度环点击交互 ====================
            // 游戏数量 → 弹出中央游戏库浮窗（先收起侧边栏避免遮挡）
            const statGames = document.getElementById('sgis-stat-games');
            if (statGames) {
                statGames.addEventListener('click', () => {
                    closePanel();
                    document.dispatchEvent(new CustomEvent('sglv:open-library'));
                });
            }
            // v2.9.5: DLC 数量 → 弹出中央游戏库浮窗并切换到仅 DLC 筛选
            const statDlc = document.getElementById('sgis-stat-dlc');
            if (statDlc) {
                statDlc.addEventListener('click', () => {
                    closePanel();
                    document.dispatchEvent(new CustomEvent('sglv:open-library'));
                    // 延迟触发仅 DLC 筛选，等待浮窗渲染完成
                    setTimeout(() => {
                        const dashCard = document.querySelector('.sglv-stat-dash-card[data-filter="dlconly"]');
                        if (dashCard) dashCard.click();
                    }, 300);
                });
            }
            // 徽章数量 → 跳转 Steam 勋章页面
            const statBadges = document.getElementById('sgis-stat-badges');
            if (statBadges) {
                statBadges.addEventListener('click', () => {
                    window.open(`${profileUrl}badges/`, '_blank');
                });
            }
            // 愿望单数量 → 跳转 Steam 愿望单页面
            const statWishlist = document.getElementById('sgis-stat-wishlist');
            if (statWishlist) {
                statWishlist.addEventListener('click', () => {
                    const sid = p.steamId || getActiveSteamId();
                    window.open(sid ? `https://store.steampowered.com/wishlist/profiles/${sid}/` : 'https://store.steampowered.com/wishlist/', '_blank');
                });
            }
            // 好友进度环 → 切换到社交标签页
            const friendGauge = document.getElementById('sgis-friend-gauge');
            if (friendGauge) {
                friendGauge.addEventListener('click', () => {
                    const panel = document.getElementById('sgis-panel');
                    const tab = panel ? panel.querySelector('.sgis-tab[data-tab="social"]') : null;
                    if (tab) tab.click();
                });
            }
            // SteamID 复制按钮
            const copySidBtn = document.getElementById('sgis-copy-steamid');
            if (copySidBtn) {
                copySidBtn.addEventListener('click', (e) => {
                    e.preventDefault();
                    e.stopPropagation();
                    copyTextToClipboard(data.steamIdShort);
                    sglvToast.success(isZh ? 'SteamID 已复制' : 'SteamID copied');
                });
            }
            // v2.3.27: 旧缓存档案无愿望单计数时，后台补取并局部更新卡片
            if (p.wishlistCount == null) {
                fetchWishlistCount(p.steamId || getActiveSteamId()).then(n => {
                    if (n == null) return;
                    p.wishlistCount = n;
                    const el = document.getElementById('sgis-stat-wishlist-val');
                    if (el) el.textContent = Number(n).toLocaleString();
                }).catch(() => { /* ignore */ });
            }
        }

        // ==================== 动态标签 (Steam 官方新闻 + 个人/家庭组入库) ====================
        function renderActivity() {
            const sub = SGIS.activitySubTab || 'personal'; // v2.3.24: 默认个人入库动态
            if (sub === 'official') {
                if (SGIS.activity) { renderActivityContent(); return; }
                if (SGIS.activityLoading) return;
                SGIS.activityLoading = true;
                renderLoading('正在获取 Steam 官方动态…');
                fetchSteamOfficialNews().then(news => {
                    SGIS.activity = news;
                    SGIS.activityLoading = false;
                    renderActivityContent();
                }).catch(e => {
                    SGIS.activityLoading = false;
                    renderError('动态获取失败: ' + e.message);
                });
            } else if (sub === 'personal') {
                if (SGIS.personalTimeline) { renderActivityContent(); return; }
                if (SGIS.personalTimelineLoading) return;
                SGIS.personalTimelineLoading = true;
                renderLoading('正在加载个人入库历史…');
                const steamId = getActiveSteamId();
                buildPersonalTimeline(steamId).then(data => {
                    SGIS.personalTimeline = data;
                    SGIS.personalTimelineLoading = false;
                    renderActivityContent();
                }).catch(e => {
                    SGIS.personalTimelineLoading = false;
                    console.warn('[SGIS] 个人入库历史加载失败:', e);
                    sglvToast.error(isZh ? '个人入库历史加载失败' : 'Personal timeline load failed');
                    renderError('个人入库历史加载失败: ' + (e.message || '网络错误'));
                });
            } else if (sub === 'family') {
                if (SGIS.familyTimeline) { renderActivityContent(); return; }
                // v2.8.1: 已发起加载但用户切走又切回（如先看 personal 再回 family），
                // DOM 可能已被其他 tab 覆盖；此时仍应重新渲染进度条，避免用户看到残留旧内容
                if (SGIS.familyTimelineLoading) {
                    if (!document.getElementById('sgis-load-block')) {
                        renderProgressLoading({ stage: 3, totalStages: 4, text: '正在加载家庭组入库历史…', skeletonCount: 8 });
                    }
                    return;
                }
                SGIS.familyTimelineLoading = true;
                // v2.8.1: 进度条 + 游戏骨架屏（参考 steam-friend-manager 加载体验），让用户在等待中看到结构
                const prog = renderProgressLoading({ stage: 1, totalStages: 4, text: '正在准备家庭组数据…', skeletonCount: 8 });
                const steamId = getActiveSteamId();
                buildFamilyTimeline(steamId, (stage, percent, text) => {
                    // 防止切走/刷新后旧回调更新到不存在的 DOM
                    if (!SGIS.familyTimelineLoading) return;
                    prog.update({ stage, percent, text });
                }).then(data => {
                    SGIS.familyTimeline = data;
                    SGIS.familyTimelineLoading = false;
                    renderActivityContent();
                }).catch(e => {
                    SGIS.familyTimelineLoading = false;
                    console.warn('[SGIS] 家庭组入库历史加载失败:', e);
                    sglvToast.error(isZh ? '家庭组入库历史加载失败' : 'Family timeline load failed');
                    renderError('家庭组入库历史加载失败: ' + (e.message || '网络错误'));
                });
            }
        }

        function renderActivityLibraryHistory(data) {
            if (!data || !data.items || data.items.length === 0) return '<div class="sgis-state">暂无入库记录</div>';
            const items = data.items;
            let html = '';
            let curDate = '';
            items.forEach(it => {
                const dateKey = it.dateStr || '';
                if (dateKey && dateKey !== curDate) {
                    curDate = dateKey;
                    html += `<div class="sgis-timeline-divider"><div class="sgis-timeline-line"></div><span class="sgis-timeline-date">${dateKey}</span><div class="sgis-timeline-line"></div></div>`;
                }
                // v2.11.44: 统一经 getGameIconUrl（community_assets 新路径 + icon 成功缓存）
                const iconUrl = getGameIconUrl(it.appid, it.icon);
                // v2.11.42: 许可页校准的条目仅日级精度（本地零点），不显示伪造的 HH:MM 时刻
                const timeText = it.ts && !it.licenseCorrected
                    ? new Date(it.ts).toLocaleTimeString('zh-CN', { hour: '2-digit', minute: '2-digit' })
                    : '';
                // v2.11.43: 家庭组入库条目显示购买者（owner_steamids 末位成员，persona 名需转义）
                const metaParts = [];
                if (it.purchaserName) metaParts.push(`${escHtml(it.purchaserName)} 购入`);
                if (timeText) metaParts.push(timeText);
                html += `<div class="sgis-timeline-game" onclick="window.open('https://store.steampowered.com/app/${it.appid}','_blank')">
                    <img class="sgis-timeline-game-icon" src="${iconUrl}" loading="lazy" onerror="this.onerror=null;_sglvIconFallback(this,'${it.appid}','${escHtml(it.icon || '')}')">
                    <div class="sgis-timeline-game-info">
                        <a class="sgis-timeline-game-name" data-sglv-appid="${it.appid}" href="https://store.steampowered.com/app/${it.appid}" target="_blank" rel="noopener">${it.name}</a>
                        ${metaParts.length ? `<div style="font-size:10px;color:var(--sgis-text-2);margin-top:2px;">${metaParts.join(' · ')}</div>` : ''}
                    </div>
                </div>`;
            });
            return html;
        }

        // ---- FEAT-014 TASK-004 回归补拆: renderActivityContent 段化 ----
        // 官方动态 4 分区 + personal/family 共用分页时间线段 + 事件绑定段,主函数降级为组装器
        const _ACTIVITY_SUB_TABS = [
            { key: 'personal', icon: SGIS_ICONS.package, label: '个人入库' },
            { key: 'family', icon: SGIS_ICONS.users, label: '家庭组入库' },
            { key: 'official', icon: SGIS_ICONS.news, label: '官方动态' },
        ];

        function _actFormatPrice(cents, currency) {
            const v = Number(cents);
            if (isNaN(v) || v === 0) return '免费';
            const symbol = (currency === 'USD') ? '$' : '';
            return symbol + (v / 100).toFixed(2);
        }

        function _actFormatExpiration(expTs) {
            const exp = Number(expTs);
            if (!exp || isNaN(exp)) return '';
            const now = Math.floor(Date.now() / 1000);
            const diff = exp - now;
            if (diff <= 0) return '已结束';
            const days = Math.floor(diff / 86400);
            const hours = Math.floor((diff % 86400) / 3600);
            if (days > 0) return `剩余${days}天${hours}小时`;
            if (hours > 0) return `剩余${hours}小时`;
            return `剩余${Math.floor(diff / 60)}分钟`;
        }

        function _actFormatNewsDate(ts) {
            if (!ts) return '';
            const d = new Date(ts * 1000);
            return `${d.getMonth() + 1}月${d.getDate()}日`;
        }

        // v2.9.70: 处理 body 中的 %1$s 占位符——Steam API 返回的本地化模板未格式化
        function _actSpotlightBody(sp) {
            if (!sp.body) return '';
            let body = sp.body;
            // 检测是否包含 %1$s 或类似占位符
            if (!body.match(/%\d\$s/)) return body;
            // 尝试用实际截止时间替换
            let timeStr = '';
            if (sp.discountExpiration && sp.discountExpiration > 0) {
                timeStr = _actFormatExpiration(sp.discountExpiration);
            }
            if (!timeStr) {
                // 预估截止时间：周末特惠2天(截止明天)，其他促销2-3天
                const name = (sp.name || '').toLowerCase();
                if (name.includes('周末') || name.includes('weekend')) {
                    timeStr = isZh ? '预计明天截止' : 'Est. ends tomorrow';
                } else {
                    timeStr = isZh ? '预计2-3天后截止' : 'Est. ends in 2-3 days';
                }
            }
            // 替换所有 %N$s 占位符
            body = body.replace(/%\d\$s/g, timeStr);
            return body;
        }

        // v2.3.25: 结构化官方动态——促销活动/每日优惠/当前特惠/官方新闻
        function _renderActivityOfficial() {
            const data = SGIS.activity || { specials: [], dailyDeals: [], spotlights: [], news: [], totalCount: 0 };
            const totalCount = Number(data.totalCount) || 0;
            if (totalCount === 0) {
                return `<div class="sgis-state"><div style="font-size:36px;margin-bottom:8px">📢</div><div>暂无官方动态</div></div>`;
            }
            let html = '';

            // 分区1: 促销活动 (Spotlights — 含活动页URL)
            if (Array.isArray(data.spotlights) && data.spotlights.length > 0) {
                html += `<div class="sgis-official-section">`;
                html += `<div class="sgis-official-section-title">🎯 促销活动<span class="sgis-section-count">${data.spotlights.length} 个活动</span></div>`;
                html += data.spotlights.map(sp => {
                    const processedBody = _actSpotlightBody(sp);
                    return `
                    <a class="sgis-spotlight-card" href="${sp.url}" target="_blank" rel="noopener">
                        ${sp.headerImage ? `<img class="sgis-spotlight-banner" src="${sp.headerImage}" loading="lazy" onerror="this.style.display='none'">` : ''}
                        <div class="sgis-spotlight-body">
                            <div class="sgis-spotlight-name">${sp.name}</div>
                            ${processedBody ? `<div class="sgis-spotlight-desc">${processedBody}</div>` : ''}
                        </div>
                    </a>`;
                }).join('');
                html += `</div>`;
            }

            // 分区2: 每日优惠 (Daily Deals)
            if (Array.isArray(data.dailyDeals) && data.dailyDeals.length > 0) {
                html += `<div class="sgis-official-section">`;
                html += `<div class="sgis-official-section-title">⚡ 每日优惠<span class="sgis-section-count">${data.dailyDeals.length} 款</span></div>`;
                html += `<div class="sgis-special-grid">`;
                html += data.dailyDeals.map(it => `
                    <a class="sgis-special-card" href="${it.url}" target="_blank" rel="noopener">
                        ${it.headerImage ? `<img class="sgis-special-img" src="${it.headerImage}" loading="lazy" onerror="this.style.display='none'">` : ''}
                        <div class="sgis-special-info">
                            <div class="sgis-special-name">${it.name}</div>
                        </div>
                        <div class="sgis-special-price">
                            <span class="sgis-special-discount">-${it.discount}%</span>
                            <span class="sgis-special-final">${_actFormatPrice(it.finalPrice, it.currency)}</span>
                        </div>
                    </a>`).join('');
                html += `</div></div>`;
            }

            // 分区3: 当前特惠 (Current Specials — 含折扣到期倒计时)
            if (Array.isArray(data.specials) && data.specials.length > 0) {
                html += `<div class="sgis-official-section">`;
                html += `<div class="sgis-official-section-title">🏷️ 当前特惠<span class="sgis-section-count">${data.specials.length} 款</span></div>`;
                html += `<div class="sgis-special-grid">`;
                html += data.specials.map(it => `
                    <a class="sgis-special-card" href="${it.url}" target="_blank" rel="noopener">
                        ${it.headerImage ? `<img class="sgis-special-img" src="${it.headerImage}" loading="lazy" onerror="this.style.display='none'">` : ''}
                        <div class="sgis-special-info">
                            <div class="sgis-special-name">${it.name}</div>
                            ${it.expiration ? `<div class="sgis-special-meta">${_actFormatExpiration(it.expiration)}</div>` : ''}
                        </div>
                        <div class="sgis-special-price">
                            <span class="sgis-special-discount">-${it.discount}%</span>
                            <span class="sgis-special-final">${_actFormatPrice(it.finalPrice, it.currency)}</span>
                            ${it.originalPrice > 0 ? `<span class="sgis-special-original">${_actFormatPrice(it.originalPrice, it.currency)}</span>` : ''}
                        </div>
                    </a>`).join('');
                html += `</div></div>`;
            }

            // 分区4: 官方新闻 (ISteamNews)
            if (Array.isArray(data.news) && data.news.length > 0) {
                html += `<div class="sgis-official-section">`;
                html += `<div class="sgis-official-section-title">📰 官方新闻<span class="sgis-section-count">${data.news.length} 条</span></div>`;
                html += data.news.map(n => {
                    const desc = n.contents ? n.contents.slice(0, 150) + (n.contents.length > 150 ? '...' : '') : '';
                    return `<a class="sgis-activity-item" ${n.url ? `href="${n.url}" target="_blank" rel="noopener"` : ''}>
                        <span class="sgis-activity-type news">新闻</span>
                        <div style="font-size:10px;color:var(--sgis-text-2);margin-bottom:2px">${_actFormatNewsDate(n.date)}</div>
                        <div style="font-size:12px;font-weight:600;color:#fff;margin-bottom:4px">${n.title}</div>
                        ${desc ? `<div style="font-size:10px;color:var(--sgis-text-2);line-height:1.5">${desc}</div>` : ''}
                    </a>`;
                }).join('');
                html += `</div>`;
            }

            return html;
        }

        // personal/family 共用分页时间线段——每页 100 条，默认仅第一页，滚动到底自动追加下一页
        function _renderActivityTimelineSection({ loading, timeline, page, loadMoreId }) {
            if (loading) return `<div class="sgis-state"><div class="sgis-spinner"></div>正在加载…</div>`;
            if (!timeline) return `<div class="sgis-state">暂无数据</div>`;
            const allItems = timeline.items || [];
            const PAGE_SIZE = 100;
            const curPage = Math.max(1, page || 1);
            const visibleItems = allItems.slice(0, curPage * PAGE_SIZE);
            const hasMore = visibleItems.length < allItems.length;
            let html = renderActivityLibraryHistory({ items: visibleItems });
            if (hasMore) {
                html += `<div id="${loadMoreId}" class="sgis-state" style="padding:14px 8px;font-size:11px">
                    <div class="sgis-spinner" style="width:16px;height:16px;margin:0 auto 6px"></div>
                    向下滚动加载更多（已显示 ${visibleItems.length}/${allItems.length}）
                </div>`;
            } else if (allItems.length > 0) {
                html += `<div style="text-align:center;font-size:10px;color:var(--sgis-text-2);padding:10px 0">已加载全部 ${allItems.length} 条</div>`;
            }
            return html;
        }

        function _bindActivityEvents(sub) {
            // 绑定子标签切换
            const body = document.getElementById('sgis-body');
            if (body) {
                body.querySelectorAll('.sgis-sub-tab').forEach(btn => {
                    btn.addEventListener('click', () => {
                        const newSub = btn.dataset.sub;
                        if (SGIS.activitySubTab === newSub) return;
                        SGIS.activitySubTab = newSub;
                        // v2.3.24: 切换子标签时重置入库分页
                        SGIS.familyTimelinePage = 1;
                        SGIS.personalTimelinePage = 1;
                        renderActivity();
                    });
                });
            }

            // v2.3.24: 入库动态分页——哨兵进入视口自动加载下一页（每页 100 条），个人/家庭组通用
            const bindTimelineLoadMore = (elId, getPage, setPage, getTotal) => {
                const el = document.getElementById(elId);
                if (!el) return;
                const io = new IntersectionObserver(entries => {
                    if (!entries[0].isIntersecting) return;
                    io.disconnect();
                    const nextPage = getPage() + 1;
                    if (nextPage * 100 - 100 < getTotal()) {
                        setPage(nextPage);
                        renderActivityContent();
                    }
                }, { root: document.getElementById('sgis-body'), rootMargin: '300px' });
                io.observe(el);
            };
            if (sub === 'family') {
                bindTimelineLoadMore('sgis-family-load-more',
                    () => SGIS.familyTimelinePage || 1,
                    p => { SGIS.familyTimelinePage = p; },
                    () => (SGIS.familyTimeline && SGIS.familyTimeline.items ? SGIS.familyTimeline.items.length : 0));
            }
            if (sub === 'personal') {
                bindTimelineLoadMore('sgis-personal-load-more',
                    () => SGIS.personalTimelinePage || 1,
                    p => { SGIS.personalTimelinePage = p; },
                    () => (SGIS.personalTimeline && SGIS.personalTimeline.items ? SGIS.personalTimeline.items.length : 0));
            }
        }

        function renderActivityContent() {
            const sub = SGIS.activitySubTab || 'personal';
            // v2.3.24: 默认个人入库动态，官方动态移至最后
            const subTabHtml = `<div class="sgis-sub-tabs">${_ACTIVITY_SUB_TABS.map(t => `<button class="sgis-sub-tab ${sub === t.key ? 'active' : ''}" data-sub="${t.key}">${t.icon}<span>${t.label}</span></button>`).join('')}</div>`;

            let contentHtml = '';
            let footerText = '';
            if (sub === 'official') {
                contentHtml = _renderActivityOfficial();
                footerText = '数据来自 Steam Storefront API + Steam News API · 缓存30分钟';
            } else if (sub === 'personal') {
                contentHtml = _renderActivityTimelineSection({
                    loading: SGIS.personalTimelineLoading,
                    timeline: SGIS.personalTimeline,
                    page: SGIS.personalTimelinePage,
                    loadMoreId: 'sgis-personal-load-more',
                });
                const pTotal = (SGIS.personalTimeline && SGIS.personalTimeline.items) ? SGIS.personalTimeline.items.length : 0;
                const pShown = Math.min(pTotal, Math.max(1, SGIS.personalTimelinePage || 1) * 100);
                // v2.11.42: 共拥游戏被个人许可页校准时在 footer 说明（家人新入库不再改变我的入库日期）
                const pCorrected = (SGIS.personalTimeline && SGIS.personalTimeline.corrected) || 0;
                footerText = `基于家庭组共享库入库时间（rt_time_acquired）· 按入库时间排序${pTotal > 0 ? ` · 已显示 ${pShown}/${pTotal}` : ''}${pCorrected > 0 ? ` · ${pCorrected} 款已按个人许可页校准` : ''}`;
            } else if (sub === 'family') {
                contentHtml = _renderActivityTimelineSection({
                    loading: SGIS.familyTimelineLoading,
                    timeline: SGIS.familyTimeline,
                    page: SGIS.familyTimelinePage,
                    loadMoreId: 'sgis-family-load-more',
                });
                const totalItems = (SGIS.familyTimeline && SGIS.familyTimeline.items) ? SGIS.familyTimeline.items.length : 0;
                const shownItems = Math.min(totalItems, Math.max(1, SGIS.familyTimelinePage || 1) * 100);
                // v2.11.42: 家庭组入库页含个人已拥有的共拥游戏为既定正确行为，修正过时的"排除个人已拥有"虚假声明
                // v2.11.43: 注明购买者归属语义（对齐 family-analysis 购买动态）
                footerText = `基于家庭组共享库入库时间（rt_time_acquired）· 按入库时间排序 · 购买者=最新入库成员${totalItems > 0 ? ` · 已显示 ${shownItems}/${totalItems}` : ''}`;
            }

            setBody(`
                <div class="sgis-section">
                    <div class="sgis-section-title">${SGIS_ICONS.news} Steam 动态</div>
                    ${subTabHtml}
                    <div class="sgis-activity-content">
                        ${contentHtml}
                    </div>
                </div>
                <div style="font-size:10px;color:var(--sgis-text-2);text-align:center;margin-top:8px">${footerText}</div>
            `);

            // v2.3.33：异步加载入库动态游戏中文名；v2.11.4 改经 applyGameAliases（scope 限定 SGIS 作用域）
            applyGameAliases(document, { scope: '#sgis-body' });

            _bindActivityEvents(sub);
        }

        // ==================== 勋章标签 (Steam 官方勋章) ====================
        function renderUserBadges() {
            if (SGIS.userBadges) { renderUserBadgesContent(); return; }
            if (SGIS.userBadgesLoading) return;
            SGIS.userBadgesLoading = true;
            renderLoading('正在获取勋章数据…');
            const steamId = getActiveSteamId();
            if (!steamId) {
                SGIS.userBadgesLoading = false;
                setBody(`<div class="sgis-state">
                    <div style="font-size:36px;margin-bottom:8px">🎖️</div>
                    <div>未检测到 SteamID</div>
                </div>`);
                return;
            }
            fetchUserBadges(steamId).then(data => {
                SGIS.userBadges = data;
                SGIS.userBadgesLoading = false;
                renderUserBadgesContent();
                // v2.3.6: 异步加载卡牌数据库, 加载完成后重新 enrich + 渲染以显示 maxLevel
                if (!cardDbData && !cardDbLoading) {
                    loadCardDatabase().then(() => {
                        if (cardDbData && SGIS.userBadges) {
                            SGIS.userBadges = enrichBadgesWithGameNames(SGIS.userBadges);
                            if (SGIS.tab === 'userBadges') renderUserBadgesContent();
                        }
                    }).catch(() => { /* 静默失败, 不影响基本功能 */ });
                }
            }).catch(e => {
                SGIS.userBadgesLoading = false;
                renderError('勋章获取失败: ' + e.message);
            });
        }

        // v2.3.1.1: 完整重写 - 加入价值分析仪表板 + 智能分析浮窗 + 徽章图标加载

        // FEAT-014 TASK-003: 社区页勋章段渲染器提为顶层 (共享区)
        // 工具函数:时间戳格式化
        function _userBadgeFormatTime(ts) {
            if (!ts) return '';
            try { return new Date(ts * 1000).toLocaleDateString('zh-CN', { year: '2-digit', month: '2-digit', day: '2-digit' }); }
            catch { return ''; }
        }
        // 工具函数:稀有度文案 (5 档)
        function _userBadgeRarityLabel(s) {
            if (!s) return null;
            if (s >= 5) return { label: '史诗', cls: 'r5' };
            if (s >= 4) return { label: '极稀有', cls: 'r4' };
            if (s >= 3) return { label: '稀有', cls: 'r3' };
            if (s >= 2) return { label: '少见', cls: 'r2' };
            return { label: '普通', cls: 'r1' };
        }
        // 工具函数:价值分档色 (高/中/低)
        function _userBadgeScoreColor(s) { return s >= 70 ? 'high' : s >= 40 ? 'mid' : 'low'; }

        // 工具函数:获取徽章图标 URL (1)卡牌封面 → 2)Steam 活动 CDN → 3)游戏胶囊图)
        function _getUserBadgeIcon(b, markets) {
            const market = markets[String(b.appid)];
            if (market && market.cards && market.cards.length > 0) {
                const cardWithIcon = market.cards.find(c => c.iconUrl);
                if (cardWithIcon) return cardWithIcon.iconUrl;
            }
            if (b._eventName && b.appid > 0) {
                return getActivityIconUrl(b.appid);
            }
            if (b.appid > 0) {
                return `https://shared.fastly.steamstatic.com/store_item_assets/steam/apps/${b.appid}/capsule_184x69.jpg`;
            }
            return '';
        }

        // 段:单条徽章行 (含智能分析 tooltip)
        // ctx = { markets, valueScores }
        function _renderUserBadgeRow(b, ctx) {
            const gname = b._gameName || (b._eventName ? b._eventName + ' 徽章' : (b.communityitemid ? `社区徽章 #${b.badgeid}` : `游戏 #${b.appid}`));
            const eventBadge = b._eventName;
            const rar = _userBadgeRarityLabel(b.scarcity);
            const icon = eventBadge ? SGIS_ICONS.gift : (b._gameName ? SGIS_ICONS.game : SGIS_ICONS.sparkle);
            const valueData = ctx.valueScores[String(b.appid)];
            const hasValue = !!valueData;
            const scoreCls = hasValue ? _userBadgeScoreColor(valueData.score) : '';
            const market = ctx.markets[String(b.appid)];
            const hasCardIcon = !!(market && market.cards && market.cards.find(c => c.iconUrl));
            const tooltip = hasValue ? `
                    <div class="sgis-badge-tip">
                        <div class="sgis-badge-tip-head">
                            <div class="sgis-badge-tip-name">${gname}</div>
                            <div class="sgis-badge-tip-score ${scoreCls}">价值 ${valueData.score}</div>
                        </div>
                        ${valueData.marketData ? `<div class="sgis-badge-tip-row">
                            <span>市场卡价</span>
                            <span>${valueData.marketData.cardCount} 张 · 均 ${formatMarketPrice(valueData.marketData.avgPrice)}</span>
                        </div>
                        <div class="sgis-badge-tip-row">
                            <span>中位/税后</span>
                            <span>${formatMarketPrice(valueData.marketData.medianPrice)} / ${formatMarketPrice(valueData.marketData.netIncome)}</span>
                        </div>` : '<div class="sgis-badge-tip-row"><span>市场数据</span><span style="opacity:0.6">加载中...</span></div>'}
                        <div class="sgis-badge-tip-row"><span>Lv.${b.level || 1}${b._maxLevel > 0 ? '/' + b._maxLevel : ''}</span><span>${b.xp || 0} XP</span></div>
                        <div class="sgis-badge-tip-bd">
                            <div class="sgis-badge-tip-bd-row"><span>XP</span><div class="sgis-badge-tip-bd-bar"><div style="width:${valueData.breakdown.xp}%"></div></div></div>
                            <div class="sgis-badge-tip-bd-row"><span>等级</span><div class="sgis-badge-tip-bd-bar"><div style="width:${valueData.breakdown.level}%"></div></div></div>
                            <div class="sgis-badge-tip-bd-row"><span>卡价</span><div class="sgis-badge-tip-bd-bar"><div style="width:${valueData.breakdown.cardPrice}%"></div></div></div>
                            <div class="sgis-badge-tip-bd-row"><span>完成</span><div class="sgis-badge-tip-bd-bar"><div style="width:${valueData.breakdown.completion}%"></div></div></div>
                        </div>
                    </div>` : '';
            return `<div class="sgis-badge-row ${hasValue ? 'has-tip' : ''}" data-appid="${b.appid || ''}" data-has-card-icon="${hasCardIcon ? '1' : '0'}">
                    <div class="sgis-badge-row-icon-wrap">
                        ${b.appid > 0 ? `<img class="sgis-badge-row-img" src="${_getUserBadgeIcon(b, ctx.markets)}" alt="" loading="lazy" onerror="this.style.display='none';this.nextElementSibling.style.display='flex'"><div class="sgis-badge-row-icon" style="display:none">${icon}</div>` : `<div class="sgis-badge-row-icon">${icon}</div>`}
                    </div>
                    <div class="sgis-badge-row-info">
                        <div class="sgis-badge-row-name" title="${gname}">${gname}</div>
                        <div class="sgis-badge-row-meta">
                            <span class="sgis-badge-row-lv">Lv.${b.level || 1}${b._maxLevel > 0 ? '/' + b._maxLevel : ''}</span>
                            <span class="sgis-badge-row-xp">${(b.xp || 0).toLocaleString()} XP</span>
                            ${rar ? `<span class="sgis-badge-row-rar ${rar.cls}">${rar.label}</span>` : ''}
                            ${b.completion_time ? `<span class="sgis-badge-row-time">${_userBadgeFormatTime(b.completion_time)}</span>` : ''}
                            ${hasValue ? `<span class="sgis-badge-row-score ${scoreCls}">${valueData.score}分</span>` : ''}
                        </div>
                    </div>
                    ${b.appid > 0 ? `<a class="sgis-badge-row-link" href="https://steamcommunity.com/my/gamecards/${b.appid}" target="_blank" rel="noopener" title="查看卡牌">${SGIS_ICONS.chevronRight}</a>` : ''}
                    ${tooltip}
                </div>`;
        }

        // 段:折叠 group (头部 + 进度条 + body)
        function _renderUserBadgeGroup(id, icon, title, sub, badges, defaultExpanded, ctx) {
            const expClass = defaultExpanded ? ' sgis-badge-group-expanded' : '';
            const totalXp = badges.reduce((s, b) => s + (b.xp || 0), 0);
            const maxLevel = badges.reduce((m, b) => Math.max(m, b.level || 1), 1);
            const realMaxLevel = badges.reduce((m, b) => Math.max(m, b._maxLevel || 0), 0);
            const completedN = badges.filter(b => (b.completion_time || 0) > 0).length;
            const completedPct = badges.length ? Math.round(completedN / badges.length * 100) : 0;
            return `<div class="sgis-badge-group${expClass}" data-group="${id}">
                    <div class="sgis-badge-group-head" data-toggle="${id}">
                        <div class="sgis-badge-group-icon">${icon}</div>
                        <div class="sgis-badge-group-titles">
                            <div class="sgis-badge-group-title">${title}</div>
                            <div class="sgis-badge-group-sub">${sub}</div>
                        </div>
                        <div class="sgis-badge-group-stats">
                            <span><span class="sgis-badge-group-stat-val">${badges.length}</span><span class="sgis-badge-group-stat-lbl">枚</span></span>
                            <span><span class="sgis-badge-group-stat-val">Lv.${maxLevel}</span>${realMaxLevel > 0 ? `<span class="sgis-badge-group-stat-lbl">/ ${realMaxLevel}</span>` : ''}</span>
                        </div>
                        <div class="sgis-badge-group-arrow">${SGIS_ICONS.chevronRight}</div>
                    </div>
                    <div class="sgis-badge-group-progress"><div class="sgis-badge-group-progress-fill" style="width:${completedPct}%"></div></div>
                    <div class="sgis-badge-group-body" id="${id}">
                        <div class="sgis-badge-group-rows">${badges.map(b => _renderUserBadgeRow(b, ctx)).join('')}</div>
                        <div class="sgis-badge-group-foot">
                            <span>${completedN}/${badges.length} 已合成 · ${totalXp.toLocaleString()} XP</span>
                        </div>
                    </div>
                </div>`;
        }

        // 段:价值 Top 6 卡片
        function _renderUserValueBadgeCard(vd) {
            if (!vd) return '';
            const market = vd.marketData;
            const avgPrice = market ? formatMarketPrice(market.avgPrice) : '—';
            const medianPrice = market && market.medianPrice ? formatMarketPrice(market.medianPrice) : '—';
            const netIncome = market && market.netIncome ? formatMarketPrice(market.netIncome) : '—';
            const cardCount = market ? `${market.cardCount} 张` : '加载中';
            let imgSrc = `https://shared.fastly.steamstatic.com/store_item_assets/steam/apps/${vd.appId}/capsule_184x69.jpg`;
            if (market && market.cards && market.cards.length > 0) {
                const cardWithIcon = market.cards.find(c => c.iconUrl);
                if (cardWithIcon) imgSrc = cardWithIcon.iconUrl;
            }
            return `<div class="sgis-value-card" data-appid="${vd.appId}">
                    <div class="sgis-value-card-img" ${vd.gameName ? `title="${vd.gameName}"` : ''}>
                        <img src="${imgSrc}" alt="" loading="lazy" onerror="this.onerror=null;this.src='https://shared.fastly.steamstatic.com/store_item_assets/steam/apps/${vd.appId}/capsule_184x69.jpg';this.style.opacity=0.2">
                    </div>
                    <div class="sgis-value-card-info">
                        <div class="sgis-value-card-name">${vd.gameName || '游戏 #' + vd.appId}</div>
                        <div class="sgis-value-card-meta">Lv.${vd.level}${vd.maxLevel > 0 ? '/' + vd.maxLevel : ''} · ${vd.xp} XP</div>
                    </div>
                    <div class="sgis-value-card-score ${_userBadgeScoreColor(vd.score)}">
                        <div class="sgis-value-card-score-num">${vd.score}</div>
                        <div class="sgis-value-card-score-lbl">价值</div>
                    </div>
                    <div class="sgis-value-card-market">
                        <span>${cardCount} · 均 ${avgPrice}</span>
                        <span style="font-size:9px;color:var(--sgis-text-3);display:block">中位 ${medianPrice} · 税后 ${netIncome}</span>
                    </div>
                </div>`;
        }

        // 段:英雄区 (4 KPI + 进度条 + 等级分布迷你条)
        function _renderUserBadgeHero(totalBadges, completedCount, avgValueScore, totalXpFromBadges, levelDist, maxLvCount) {
            return `
                <div class="sgis-badge-hero">
                    <div class="sgis-badge-hero-stats">
                        <div class="sgis-badge-hero-stat">
                            <div class="sgis-badge-hero-stat-val">${totalBadges}</div>
                            <div class="sgis-badge-hero-stat-lbl">勋章总数</div>
                        </div>
                        <div class="sgis-badge-hero-stat highlight">
                            <div class="sgis-badge-hero-stat-val">${completedCount}</div>
                            <div class="sgis-badge-hero-stat-lbl">已合成</div>
                        </div>
                        <div class="sgis-badge-hero-stat">
                            <div class="sgis-badge-hero-stat-val">${avgValueScore}</div>
                            <div class="sgis-badge-hero-stat-lbl">均价值</div>
                        </div>
                        <div class="sgis-badge-hero-stat">
                            <div class="sgis-badge-hero-stat-val">${(totalXpFromBadges / 1000).toFixed(1)}k</div>
                            <div class="sgis-badge-hero-stat-lbl">总 XP</div>
                        </div>
                    </div>
                    <div class="sgis-badge-hero-progress">
                        <div class="sgis-badge-hero-progress-label">
                            <span>完成进度</span>
                            <span>${completedCount}/${totalBadges} (${totalBadges ? Math.round(completedCount / totalBadges * 100) : 0}%)</span>
                        </div>
                        <div class="sgis-badge-hero-progress-bar">
                            <div class="sgis-badge-hero-progress-fill" style="width:${totalBadges ? (completedCount / totalBadges * 100) : 0}%"></div>
                        </div>
                    </div>
                    <div class="sgis-badge-hero-levels">
                        <div class="sgis-badge-hero-levels-label">等级分布</div>
                        <div class="sgis-badge-hero-levels-bars">
                            ${[1, 2, 3, 4, 5].map(lv => {
                                const count = levelDist[lv] || 0;
                                const pct = Math.max(3, (count / maxLvCount) * 100);
                                return `<div class="sgis-badge-hero-level-cell">
                                    <div class="sgis-badge-hero-level-bar" style="height:${pct}%" title="Lv.${lv}: ${count} 枚">
                                        <span class="sgis-badge-hero-level-count">${count}</span>
                                    </div>
                                    <div class="sgis-badge-hero-level-num">Lv.${lv}</div>
                                </div>`;
                            }).join('')}
                        </div>
                    </div>
                </div>
            `;
        }

        // 段:评分说明 footer
        function _renderUserBadgeFooter(eventBadgeCount, gameBadgeCount, communityBadgeCount) {
            return `
                <details class="sgis-badge-footer-details">
                    <summary>评分说明与统计</summary>
                    <div class="sgis-badge-footer-content">
                        <div class="sgis-badge-footer-formula">
                            <b>价值评分公式</b>: XP(25%) + 等级(20%) + 卡价(30%) + 完成(15%) + 等级上限(10%)
                        </div>
                        <div class="sgis-badge-footer-breakdown">
                            ${eventBadgeCount} 节日 · ${gameBadgeCount} 游戏 · ${communityBadgeCount} 社区
                        </div>
                        ${cardDbData ? `<div class="sgis-badge-footer-meta">卡牌数据库已加载: ${Object.keys(cardDbData).length} 款游戏 (SteamCardExchange API)</div>` : ''}
                    </div>
                </details>
            `;
        }

        // 段:数据驱动的徽章行图标刷新 (市场数据回填后)
        function _refreshUserBadgeIconsToCardCover(newMarkets) {
            const bodyEl = document.getElementById('sgis-body');
            if (!bodyEl) return;
            bodyEl.querySelectorAll('.sgis-badge-row[data-appid]').forEach(row => {
                if (row.dataset.hasCardIcon === '1') return;
                const appid = row.dataset.appid;
                if (!appid) return;
                const market = newMarkets[appid];
                if (!market || !market.cards || !market.cards.length) return;
                const cardWithIcon = market.cards.find(c => c.iconUrl);
                if (!cardWithIcon) return;
                const imgEl = row.querySelector('.sgis-badge-row-img');
                if (!imgEl) return;
                row.dataset.hasCardIcon = '1';
                imgEl.dataset.originalSrc = imgEl.src;
                imgEl.src = cardWithIcon.iconUrl;
                imgEl.addEventListener('error', function onError() {
                    imgEl.removeEventListener('error', onError);
                    if (imgEl.dataset.originalSrc) {
                        imgEl.src = imgEl.dataset.originalSrc;
                        delete imgEl.dataset.originalSrc;
                    }
                }, { once: true });
            });
        }

        // 组装器:数据准备 + 段渲染器串联 + 副作用
        function renderUserBadgesContent() {
            const data = SGIS.userBadges;
            if (!data || !data.badges) {
                setBody(`<div class="sgis-state">
                    <div style="font-size:36px;margin-bottom:8px">${SGIS_ICONS.medal}</div>
                    <div>无法获取勋章数据</div>
                    <div style="font-size:11px;color:var(--sgis-text-2);margin-top:8px">
                        请确保 API Key 和 SteamID 配置正确
                    </div>
                </div>`);
                return;
            }
            const badges = data.badges || [];
            // 分类:节日/游戏/社区
            const eventBadges = [];
            const gameBadges = [];
            const communityBadges = [];
            badges.forEach(b => {
                if (b.appid > 0) {
                    const evt = detectEventBadge(b);
                    if (evt) { b._eventName = evt.name; eventBadges.push(b); }
                    else { gameBadges.push(b); }
                } else {
                    communityBadges.push(b);
                }
            });
            // 分组
            const eventGroups = {};
            eventBadges.forEach(b => {
                if (!eventGroups[b._eventName]) eventGroups[b._eventName] = [];
                eventGroups[b._eventName].push(b);
            });
            const gameGroups = {};
            gameBadges.forEach(b => {
                const gname = b._gameName || `游戏 #${b.appid}`;
                if (!gameGroups[gname]) gameGroups[gname] = { name: gname, appid: b.appid, badges: [] };
                gameGroups[gname].badges.push(b);
            });
            // 排序
            const eventNames = Object.keys(eventGroups).sort((a, b) => b.localeCompare(a, 'zh-CN'));
            const gameNames = Object.keys(gameGroups).sort((a, b) => gameGroups[b].badges.length - gameGroups[a].badges.length);
            // 统计
            const totalBadges = badges.length;
            const completedCount = badges.filter(b => (b.completion_time || 0) > 0).length;
            const gameBadgeCount = gameBadges.length;
            const eventBadgeCount = eventBadges.length;
            const totalXpFromBadges = badges.reduce((s, b) => s + (b.xp || 0), 0);
            // 等级分布
            const levelDist = getBadgeLevelDistribution(badges);
            const maxLvCount = Math.max(...Object.values(levelDist), 1);
            // 价值分析
            const markets = SGIS.userBadgeMarkets || {};
            const needFetchAppIds = gameBadges
                .filter(b => !markets[String(b.appid)])
                .map(b => b.appid)
                .filter((v, i, a) => a.indexOf(v) === i)
                .slice(0, 15);
            const valueScores = computeBadgeValueScores(badges, markets);
            const topValueBadges = getTopValueBadges(valueScores, 6);
            // 段渲染器上下文 (闭包共享 markets/valueScores)
            const ctx = { markets, valueScores };
            // 折叠状态
            const collapseStateKey = 'sgis_badge_group_collapse';
            const getCollapseState = () => {
                try { return JSON.parse(GM_getValue(collapseStateKey, '{}')); } catch { return {}; }
            };
            const setCollapseState = (state) => {
                try { GM_setValue(collapseStateKey, JSON.stringify(state)); } catch { /* ignore */ }
            };
            const collapseState = getCollapseState();
            const groupId = (k) => 'sgis-bg-' + String(k).replace(/[^\w]/g, '_').slice(0, 60);
            const valueSectionHtml = _renderUserBadgeValueSection(topValueBadges);
            // 英雄区
            const totalValueScore = badges.reduce((s, b) => {
                const v = valueScores[String(b.appid)];
                return s + (v ? v.score : 0);
            }, 0);
            const avgValueScore = totalBadges ? Math.round(totalValueScore / totalBadges) : 0;
            const heroHtml = _renderUserBadgeHero(totalBadges, completedCount, avgValueScore, totalXpFromBadges, levelDist, maxLvCount);
            const TOP_EXPAND = 5;
            const eventSectionHtml = _renderUserBadgeEventSection(eventNames, eventGroups, eventBadgeCount, collapseState, groupId, ctx);
            const gameSectionHtml = _renderUserBadgeGameSection(gameNames, gameGroups, gameBadgeCount, collapseState, groupId, TOP_EXPAND, ctx);
            const communitySectionHtml = _renderUserBadgeCommunitySection(communityBadges, collapseState, ctx);
            const footerHtml = _renderUserBadgeFooter(eventBadgeCount, gameBadgeCount, communityBadges.length);
            // 组装
            const html = heroHtml + valueSectionHtml + eventSectionHtml + gameSectionHtml + communitySectionHtml + footerHtml;
            setBody(html);
            // 副作用:异步拉市场 + 刷新徽章行图标
            if (needFetchAppIds.length > 0) {
                fetchBadgeMarkets(needFetchAppIds, { concurrency: 3, maxApps: 15 }).then(newMarkets => {
                    SGIS.userBadgeMarkets = Object.assign({}, markets, newMarkets);
                    _refreshUserBadgeIconsToCardCover(newMarkets);
                }).catch(e => console.warn('[SGLV] 徽章市场数据获取失败:', e));
            }
            // 绑定折叠事件
            const body = document.getElementById('sgis-body');
            if (body) {
                body.querySelectorAll('[data-toggle]').forEach(head => {
                    head.addEventListener('click', () => {
                        const group = head.closest('.sgis-badge-group');
                        if (group) {
                            const isExp = group.classList.toggle('sgis-badge-group-expanded');
                            const gid = head.getAttribute('data-toggle');
                            collapseState[gid] = isExp;
                            setCollapseState(collapseState);
                        }
                    });
                });
            }
        }

        // v2.11.27 (FEAT-014 TASK-003 收尾): 价值 Top 6 section
        function _renderUserBadgeValueSection(topValueBadges) {
            const valueCardsHtml = topValueBadges.length
                ? `<div class="sgis-value-cards">${topValueBadges.map(_renderUserValueBadgeCard).join('')}</div>`
                : `<div class="sgis-badge-group-empty">暂无可分析的游戏勋章 (需要先获取游戏库数据)</div>`;
            return `
                <div class="sgis-section">
                    <div class="sgis-section-title">${SGIS_ICONS.star} 价值 Top ${topValueBadges.length} ${topValueBadges.length > 0 ? `<span class="sgis-section-title-meta">综合价值评分</span>` : ''}</div>
                    ${valueCardsHtml}
                </div>
            `;
        }

        // v2.11.27 (FEAT-014 TASK-003 收尾): 节日活动 section 段渲染器
        function _renderUserBadgeEventSection(eventNames, eventGroups, eventBadgeCount, collapseState, groupId, ctx) {
            return `
                <div class="sgis-section">
                    <div class="sgis-section-title">${SGIS_ICONS.gift} 节日活动 <span class="sgis-section-title-meta">${eventBadgeCount} 枚 / ${eventNames.length} 个活动</span></div>
                    <div class="sgis-badge-group-stack">
                        ${eventNames.length === 0
                            ? `<div class="sgis-badge-group-empty">暂无节日活动徽章</div>`
                            : eventNames.map(name => {
                                const list = eventGroups[name];
                                const id = groupId('event_' + name);
                                const expanded = collapseState[id] === true;
                                return _renderUserBadgeGroup(id, SGIS_ICONS.gift, name, 'Steam 限定徽章', list, expanded, ctx);
                            }).join('')}
                    </div>
                </div>
            `;
        }

        // v2.11.27 (FEAT-014 TASK-003 收尾): 游戏勋章 section 段渲染器
        function _renderUserBadgeGameSection(gameNames, gameGroups, gameBadgeCount, collapseState, groupId, TOP_EXPAND, ctx) {
            return `
                <div class="sgis-section">
                    <div class="sgis-section-title">${SGIS_ICONS.game} 游戏勋章 <span class="sgis-section-title-meta">${gameBadgeCount} 枚 / ${gameNames.length} 个游戏</span></div>
                    <div class="sgis-badge-group-stack">
                        ${gameNames.length === 0
                            ? `<div class="sgis-badge-group-empty">暂无游戏勋章 (需要先获取游戏库数据)</div>`
                            : gameNames.slice(0, 30).map((name, idx) => {
                                const g = gameGroups[name];
                                const id = groupId('game_' + g.appid);
                                const userSetExpanded = collapseState[id] === true;
                                const userSetCollapsed = collapseState[id] === false;
                                const expanded = userSetExpanded || (!userSetCollapsed && idx < TOP_EXPAND);
                                return _renderUserBadgeGroup(id, SGIS_ICONS.game, g.name, `AppID: ${g.appid}`, g.badges, expanded, ctx);
                            }).join('')}
                        ${gameNames.length > 30 ? `<div class="sgis-badge-group-empty">还有 ${gameNames.length - 30} 个游戏的勋章未显示</div>` : ''}
                    </div>
                </div>
            `;
        }

        // v2.11.27 (FEAT-014 TASK-003 收尾): 社区勋章 section 段渲染器(单 group, 复用 _renderUserBadgeRow)
        function _renderUserBadgeCommunitySection(communityBadges, collapseState, ctx) {
            if (communityBadges.length === 0) return '';
            const showComm = communityBadges.slice(0, 12);
            const id = 'sgis-bg-community';
            const expanded = collapseState[id] === true;
            return `
                <div class="sgis-section">
                    <div class="sgis-section-title">${SGIS_ICONS.sparkle} 社区勋章 <span class="sgis-section-title-meta">${communityBadges.length} 枚</span></div>
                    <div class="sgis-badge-group-stack">
                        <div class="sgis-badge-group ${expanded ? 'sgis-badge-group-expanded' : ''}" data-group="community">
                            <div class="sgis-badge-group-head" data-toggle="${id}">
                                <div class="sgis-badge-group-icon">${SGIS_ICONS.sparkle}</div>
                                <div class="sgis-badge-group-titles">
                                    <div class="sgis-badge-group-title">社区勋章</div>
                                    <div class="sgis-badge-group-sub">Steam 社区授予的成就</div>
                                </div>
                                <div class="sgis-badge-group-stats">
                                    <span class="sgis-badge-group-stat">${communityBadges.length} 枚</span>
                                </div>
                                <div class="sgis-badge-group-arrow">${SGIS_ICONS.chevronRight}</div>
                            </div>
                            <div class="sgis-badge-group-body" id="${id}">
                                <div class="sgis-badge-group-rows">${showComm.map(b => _renderUserBadgeRow(b, ctx)).join('')}</div>
                            </div>
                        </div>
                    </div>
                </div>
            `;
        }

        // ==================== 成就标签 (自制成就系统 + AI 人格分析) ====================

        // 炫彩 SVG 成就图标库 (v2.3.1) - 每个成就独立的渐变配色
        const ACHIEVEMENT_SVG_ICONS = {
            // 收藏家 - 礼物盒 (蓝紫渐变)
            collector: `<svg viewBox="0 0 64 64" xmlns="http://www.w3.org/2000/svg"><defs><linearGradient id="ac-coll" x1="0" y1="0" x2="1" y2="1"><stop offset="0" stop-color="#8b5cf6"/><stop offset="1" stop-color="#3b82f6"/></linearGradient></defs><rect x="6" y="22" width="52" height="36" rx="4" fill="url(#ac-coll)"/><rect x="6" y="22" width="52" height="10" fill="rgba(255,255,255,0.15)"/><rect x="26" y="22" width="12" height="36" fill="rgba(255,255,255,0.2)"/><path d="M32 8 L24 16 L20 22 L24 22 L28 18 L28 22 L36 22 L36 18 L40 22 L44 22 L40 16 Z" fill="url(#ac-coll)"/><circle cx="32" cy="14" r="3" fill="#fbbf24" stroke="#fff" stroke-width="1.5"/></svg>`,
            // 收藏家皇冠 (金黄渐变)
            kingCollector: `<svg viewBox="0 0 64 64" xmlns="http://www.w3.org/2000/svg"><defs><linearGradient id="ac-king" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#fde047"/><stop offset="0.5" stop-color="#f59e0b"/><stop offset="1" stop-color="#d97706"/></linearGradient></defs><path d="M6 44 L12 18 L22 32 L32 12 L42 32 L52 18 L58 44 Z" fill="url(#ac-king)"/><rect x="6" y="44" width="52" height="10" fill="url(#ac-king)"/><circle cx="12" cy="14" r="4" fill="#ef4444" stroke="#fff" stroke-width="1.5"/><circle cx="32" cy="8" r="4" fill="#3b82f6" stroke="#fff" stroke-width="1.5"/><circle cx="52" cy="14" r="4" fill="#10b981" stroke="#fff" stroke-width="1.5"/><rect x="14" y="48" width="36" height="3" fill="rgba(255,255,255,0.4)"/></svg>`,
            // 时钟入门 (青蓝渐变)
            clock: `<svg viewBox="0 0 64 64" xmlns="http://www.w3.org/2000/svg"><defs><linearGradient id="ac-clk" x1="0" y1="0" x2="1" y2="1"><stop offset="0" stop-color="#06b6d4"/><stop offset="1" stop-color="#0891b2"/></linearGradient></defs><circle cx="32" cy="34" r="24" fill="url(#ac-clk)"/><circle cx="32" cy="34" r="20" fill="none" stroke="rgba(255,255,255,0.3)" stroke-width="1.5"/><circle cx="32" cy="34" r="3" fill="#fff"/><line x1="32" y1="34" x2="32" y2="22" stroke="#fff" stroke-width="3" stroke-linecap="round"/><line x1="32" y1="34" x2="42" y2="38" stroke="#fff" stroke-width="2.5" stroke-linecap="round"/><rect x="28" y="6" width="8" height="6" rx="1" fill="url(#ac-clk)"/></svg>`,
            // 时钟沙漏 (橙红渐变)
            hourglass: `<svg viewBox="0 0 64 64" xmlns="http://www.w3.org/2000/svg"><defs><linearGradient id="ac-hg" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#f97316"/><stop offset="1" stop-color="#dc2626"/></linearGradient><linearGradient id="ac-hg-sand" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#fbbf24"/><stop offset="1" stop-color="#f59e0b"/></linearGradient></defs><rect x="14" y="6" width="36" height="6" rx="2" fill="url(#ac-hg)"/><rect x="14" y="52" width="36" height="6" rx="2" fill="url(#ac-hg)"/><path d="M18 12 L46 12 L40 30 Q32 36 24 30 Z" fill="url(#ac-hg-sand)"/><path d="M18 52 L46 52 L40 34 Q32 28 24 34 Z" fill="url(#ac-hg-sand)"/><line x1="20" y1="14" x2="44" y2="14" stroke="rgba(255,255,255,0.4)" stroke-width="1"/><line x1="20" y1="50" x2="44" y2="50" stroke="rgba(255,255,255,0.4)" stroke-width="1"/></svg>`,
            // 完美主义 (绿对勾)
            perfection: `<svg viewBox="0 0 64 64" xmlns="http://www.w3.org/2000/svg"><defs><linearGradient id="ac-perf" x1="0" y1="0" x2="1" y2="1"><stop offset="0" stop-color="#10b981"/><stop offset="1" stop-color="#059669"/></linearGradient></defs><circle cx="32" cy="32" r="26" fill="url(#ac-perf)"/><circle cx="32" cy="32" r="22" fill="none" stroke="rgba(255,255,255,0.2)" stroke-width="1.5" stroke-dasharray="3 2"/><path d="M18 32 L28 42 L46 22" fill="none" stroke="#fff" stroke-width="4" stroke-linecap="round" stroke-linejoin="round"/><circle cx="32" cy="32" r="26" fill="none" stroke="rgba(255,255,255,0.3)" stroke-width="2"/></svg>`,
            // 骰子 - 涉猎广泛 (多彩)
            dice: `<svg viewBox="0 0 64 64" xmlns="http://www.w3.org/2000/svg"><defs><linearGradient id="ac-die" x1="0" y1="0" x2="1" y2="1"><stop offset="0" stop-color="#ec4899"/><stop offset="1" stop-color="#8b5cf6"/></linearGradient></defs><rect x="8" y="8" width="48" height="48" rx="10" fill="url(#ac-die)" transform="rotate(8 32 32)"/><circle cx="20" cy="20" r="3" fill="#fff"/><circle cx="44" cy="20" r="3" fill="#fff"/><circle cx="32" cy="32" r="3" fill="#fff"/><circle cx="20" cy="44" r="3" fill="#fff"/><circle cx="44" cy="44" r="3" fill="#fff"/></svg>`,
            // 早鸟 (太阳/日出)
            sunrise: `<svg viewBox="0 0 64 64" xmlns="http://www.w3.org/2000/svg"><defs><linearGradient id="ac-sun" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#fbbf24"/><stop offset="0.5" stop-color="#f97316"/><stop offset="1" stop-color="#dc2626"/></linearGradient></defs><circle cx="32" cy="40" r="18" fill="url(#ac-sun)"/><line x1="32" y1="6" x2="32" y2="14" stroke="#fbbf24" stroke-width="2.5" stroke-linecap="round"/><line x1="14" y1="20" x2="18" y2="24" stroke="#fbbf24" stroke-width="2.5" stroke-linecap="round"/><line x1="50" y1="20" x2="46" y2="24" stroke="#fbbf24" stroke-width="2.5" stroke-linecap="round"/><line x1="6" y1="40" x2="14" y2="40" stroke="#fbbf24" stroke-width="2.5" stroke-linecap="round"/><line x1="50" y1="40" x2="58" y2="40" stroke="#fbbf24" stroke-width="2.5" stroke-linecap="round"/><line x1="32" y1="60" x2="6" y2="60" stroke="#f97316" stroke-width="2.5" stroke-linecap="round"/><line x1="32" y1="60" x2="58" y2="60" stroke="#f97316" stroke-width="2.5" stroke-linecap="round"/></svg>`,
            // 夜猫子 (月亮+星星)
            moon: `<svg viewBox="0 0 64 64" xmlns="http://www.w3.org/2000/svg"><defs><linearGradient id="ac-moon" x1="0" y1="0" x2="1" y2="1"><stop offset="0" stop-color="#6366f1"/><stop offset="1" stop-color="#312e81"/></linearGradient></defs><circle cx="32" cy="32" r="26" fill="url(#ac-moon)"/><path d="M44 18 a18 18 0 1 0 12 24 a14 14 0 0 1 -12 -24 z" fill="#fbbf24"/><circle cx="16" cy="16" r="1.5" fill="#fff"/><circle cx="50" cy="44" r="1" fill="#fff"/><circle cx="12" cy="44" r="1.5" fill="#fff"/><circle cx="50" cy="14" r="1" fill="#fff"/></svg>`,
            // 老用户 (钻石)
            diamond: `<svg viewBox="0 0 64 64" xmlns="http://www.w3.org/2000/svg"><defs><linearGradient id="ac-dia" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#a5f3fc"/><stop offset="0.5" stop-color="#06b6d4"/><stop offset="1" stop-color="#0e7490"/></linearGradient></defs><path d="M14 24 L24 8 L40 8 L50 24 L32 56 Z" fill="url(#ac-dia)"/><path d="M14 24 L24 8 L32 24 Z" fill="rgba(255,255,255,0.3)"/><path d="M24 8 L40 8 L32 24 Z" fill="rgba(255,255,255,0.1)"/><path d="M50 24 L40 8 L32 24 Z" fill="rgba(0,0,0,0.1)"/><path d="M14 24 L50 24 L32 56 Z" fill="url(#ac-dia)" opacity="0.9"/><line x1="14" y1="24" x2="50" y2="24" stroke="#fff" stroke-width="1.5" opacity="0.5"/></svg>`,
        };

        // 自制成就定义 (v2.3.1: 炫彩 SVG 图标)
        const USER_ACHIEVEMENTS = [
            { id: 'collector_50', icon: ACHIEVEMENT_SVG_ICONS.collector, name: '初级收藏家', desc: '拥有 50 款游戏', threshold: 50, metric: 'gameCount' },
            { id: 'collector_100', icon: ACHIEVEMENT_SVG_ICONS.collector, name: '中级收藏家', desc: '拥有 100 款游戏', threshold: 100, metric: 'gameCount' },
            { id: 'collector_500', icon: ACHIEVEMENT_SVG_ICONS.collector, name: '高级收藏家', desc: '拥有 500 款游戏', threshold: 500, metric: 'gameCount' },
            { id: 'collector_1000', icon: ACHIEVEMENT_SVG_ICONS.kingCollector, name: '游戏大王', desc: '拥有 1000 款游戏', threshold: 1000, metric: 'gameCount' },
            { id: 'playtime_1k', icon: ACHIEVEMENT_SVG_ICONS.clock, name: '入门玩家', desc: '总游戏时长达到 1000 小时', threshold: 1000, metric: 'totalHours' },
            { id: 'playtime_5k', icon: ACHIEVEMENT_SVG_ICONS.hourglass, name: '资深玩家', desc: '总游戏时长达到 5000 小时', threshold: 5000, metric: 'totalHours' },
            { id: 'playtime_10k', icon: ACHIEVEMENT_SVG_ICONS.hourglass, name: '硬核玩家', desc: '总游戏时长达到 10000 小时', threshold: 10000, metric: 'totalHours' },
            { id: 'completionist', icon: ACHIEVEMENT_SVG_ICONS.perfection, name: '完美主义者', desc: '有 10 款游戏达成 100% 成就', threshold: 10, metric: 'perfectGames' },
            { id: 'diverse_10', icon: ACHIEVEMENT_SVG_ICONS.dice, name: '涉猎广泛', desc: '游玩 10 种不同类型的游戏', threshold: 10, metric: 'genres' },
            { id: 'early_bird', icon: ACHIEVEMENT_SVG_ICONS.sunrise, name: '早鸟玩家', desc: '在游戏发行 7 天内入库 5 款游戏', threshold: 5, metric: 'earlyAccess' },
            { id: 'night_owl', icon: ACHIEVEMENT_SVG_ICONS.moon, name: '夜猫子', desc: '总游戏时长超过 5000 小时且拥有 200+ 游戏', threshold: 1, metric: 'nightOwl' },
            { id: 'patron', icon: ACHIEVEMENT_SVG_ICONS.diamond, name: 'Steam 老用户', desc: 'Steam 账号超过 10 年', threshold: 1, metric: 'veteran' },
        ];

        function computeUserAchievements() {
            // v2.9.2: 排除家庭组共享游戏和 DLC，确保成就统计准确
            const allGames = getStatFilteredGames();
            const gameCount = allGames.length;
            const totalPlaytimeMin = allGames.reduce((s, g) => s + (g.playtime || 0), 0);
            const totalHours = Math.floor(totalPlaytimeMin / 60);
            // 完美游戏 (有成就且全部解锁 - 这里用 playtime > 60h 作为近似)
            const perfectGames = allGames.filter(g => g.playtime && g.playtime > 3600).length;
            // 游戏类型多样性 (从游戏名推断不了，用 0 占位)
            const genres = 0;
            // 早鸟 (acquiredTime 在发行 7 天内)
            const earlyAccess = allGames.filter(g => {
                if (!g.acquiredTime || !g.releaseDate) return false;
                const diff = g.acquiredTime - g.releaseDate;
                return diff >= 0 && diff <= 7 * 86400000;
            }).length;
            // 夜猫子 (游戏时长 > 5000h 且游戏数 > 200)
            const nightOwl = (totalHours > 5000 && gameCount > 200) ? 1 : 0;
            // 老用户 (从 SteamID 创建时间估算 - 用 account creation time)
            const veteran = 0; // 需要额外 API

            const metrics = { gameCount, totalHours, perfectGames, genres, earlyAccess, nightOwl, veteran };
            return USER_ACHIEVEMENTS.map(ach => {
                const current = metrics[ach.metric] || 0;
                const unlocked = current >= ach.threshold;
                const progress = Math.min(100, (current / ach.threshold) * 100);
                return { ...ach, current, unlocked, progress };
            });
        }

        // ==================== v2.3.8: 社交标签页渲染 (参考 friend-manager) ====================
        function renderSocial() {
            if (SGIS.friendsList) { renderSocialContent(); return; }
            if (SGIS.friendsListLoading) return;
            const steamId = getActiveSteamId();
            if (!steamId) {
                setBody(`<div class="sgis-state">
                    <div style="font-size:32px;margin-bottom:8px;opacity:0.5">${SGIS_ICONS.social}</div>
                    <div>无法获取好友列表</div>
                    <div style="font-size:11px;color:var(--sgis-text-2);margin-top:6px">请先配置 SteamID 或登录 Steam 商店</div>
                </div>`);
                return;
            }
            SGIS.friendsListLoading = true;
            renderLoading('正在获取好友列表…');
            fetchFriendsList(steamId).then(result => {
                SGIS.friendsList = result;
                SGIS.friendsListLoading = false;
                SGIS.friendsListError = result.error || null;
                renderSocialContent();

            }).catch(e => {
                SGIS.friendsListLoading = false;
                SGIS.friendsListError = e.message || '获取好友列表失败';
                renderSocialContent();
            });
        }

        // v2.11.1 (FEAT-011 TASK-002): KPI 渐变色表 + renderKpi 单一定义——原 renderSocialContent/
        // renderUserAchievementsContent 两处逐字重复定义,现提升到 SGIS 闭包共享层,
        // 内部经共享工厂 kpiCards(tone:'sgis') 拼装,两个消费方调用语句不变
        const KPI_GRADIENTS = {
            blue: 'linear-gradient(135deg, #3b82f6, #06b6d4)',
            cyan: 'linear-gradient(135deg, #06b6d4, #22d3ee)',
            purple: 'linear-gradient(135deg, #8b5cf6, #a78bfa)',
            amber: 'linear-gradient(135deg, #f59e0b, #fbbf24)',
            rose: 'linear-gradient(135deg, #f43f5e, #fb7185)',
            green: 'linear-gradient(135deg, #10b981, #34d399)',
        };
        const renderKpi = (icon, label, val, sub, grad, color) => kpiCards(
            [{ icon, label, value: val, sub, grad, color }], { tone: 'sgis' });

        function _prepareSocialData() {
            const data = SGIS.friendsList || { friends: [], total: 0 };
            const friends = data.friends || [];
            const totalCount = friends.length;
            const ingameFriends = friends.filter(f => f.gameextrainfo || f.personastate === 6);
            const onlineFriends = friends.filter(f => f.personastate > 0 && !f.gameextrainfo);
            const vacBanned = friends.filter(f => f.vac_banned);
            const newFriends = friends.filter(f => f.friend_days != null && f.friend_days < 30);
            const knownLevels = friends.filter(f => f.level != null);
            const maxLevel = knownLevels.length > 0 ? Math.max(...knownLevels.map(f => f.level)) : null;
            const filter = SGIS.friendsFilter || 'all';
            const sort = SGIS.friendsSort || 'status';
            const search = SGIS.friendsSearch || '';
            return {
                data, friends, totalCount, ingameFriends, onlineFriends,
                vacBanned, newFriends, knownLevels, maxLevel,
                filter, sort, search,
            };
        }

        function _renderSocialKPI(d) {
            return `<div class="sgis-insight-kpi-grid">
                ${renderKpi(SGIS_ICONS.social, '好友总数', d.totalCount, `在线 ${d.onlineFriends.length + d.ingameFriends.length}`, KPI_GRADIENTS.blue, 'blue')}
                ${renderKpi(SGIS_ICONS.sparkle, '游戏中', d.ingameFriends.length, '正在玩游戏', KPI_GRADIENTS.cyan, 'cyan')}
                ${renderKpi(SGIS_ICONS.check, '在线', d.onlineFriends.length, '未在游戏中', KPI_GRADIENTS.green, 'green')}
                ${renderKpi(SGIS_ICONS.shield, 'VAC 封禁', d.vacBanned.length, d.vacBanned.length > 0 ? `最近 ${d.vacBanned[0].vac_days_since_last_ban}天` : '安全', d.vacBanned.length > 0 ? KPI_GRADIENTS.rose : KPI_GRADIENTS.green, d.vacBanned.length > 0 ? 'rose' : 'green')}
                ${renderKpi(SGIS_ICONS.clock, '新好友(30天)', d.newFriends.length, '最近添加', KPI_GRADIENTS.amber, 'amber')}
                ${renderKpi(SGIS_ICONS.trophy, '最高等级', d.maxLevel != null ? 'Lv.' + d.maxLevel : '—', d.knownLevels.length > 0 ? `${knownFriends(d.friends)} 人已加载` : '点击下方加载', KPI_GRADIENTS.purple, 'purple')}
            </div>`;
        }

        function _renderSocialToolbar(d) {
            const filterBtns = [
                { id: 'all', label: '全部', count: d.totalCount },
                { id: 'ingame', label: '游戏中', count: d.ingameFriends.length },
                { id: 'online', label: '在线', count: d.onlineFriends.length },
                { id: 'vac', label: 'VAC', count: d.vacBanned.length },
                { id: 'new', label: '新好友', count: d.newFriends.length },
            ];
            const sortOptions = [
                { id: 'status', label: '按状态' },
                { id: 'days', label: '按好友天数' },
                { id: 'level', label: '按等级' },
                { id: 'name', label: '按昵称' },
            ];
            return `<div class="sgis-social-toolbar">
                <input type="text" class="sgis-social-search" id="sgis-social-search" placeholder="搜索昵称或 SteamID…" value="${d.search.replace(/"/g, '&quot;')}">
                <select class="sgis-social-sort" id="sgis-social-sort">
                    ${sortOptions.map(s => `<option value="${s.id}" ${d.sort === s.id ? 'selected' : ''}>${s.label}</option>`).join('')}
                </select>
            </div>
            <div class="sgis-social-filter-row">
                ${filterBtns.map(f => `<button class="sgis-social-filter ${d.filter === f.id ? 'active' : ''}" data-filter="${f.id}">${f.label}<span class="count">${f.count}</span></button>`).join('')}
            </div>`;
        }

        function _filterSortFriends(d) {
            let filtered = [...d.friends];
            if (d.filter === 'ingame') filtered = filtered.filter(f => f.gameextrainfo || f.personastate === 6);
            else if (d.filter === 'online') filtered = filtered.filter(f => f.personastate > 0 && !f.gameextrainfo);
            else if (d.filter === 'offline') filtered = filtered.filter(f => f.personastate === 0);
            else if (d.filter === 'vac') filtered = filtered.filter(f => f.vac_banned);
            else if (d.filter === 'new') filtered = filtered.filter(f => f.friend_days != null && f.friend_days < 30);
            if (d.search) {
                const q = d.search.toLowerCase();
                filtered = filtered.filter(f =>
                    (f.personaname || '').toLowerCase().includes(q) ||
                    String(f.steamid).includes(q)
                );
            }
            if (d.sort === 'days') filtered.sort((a, b) => (b.friend_days || 0) - (a.friend_days || 0));
            else if (d.sort === 'level') filtered.sort((a, b) => (b.level || 0) - (a.level || 0));
            else if (d.sort === 'name') filtered.sort((a, b) => (a.personaname || '').localeCompare(b.personaname || ''));
            else {
                const rank = f => f.gameextrainfo ? 0 : (f.personastate > 0 ? 1 : 2);
                filtered.sort((a, b) => rank(a) - rank(b));
            }
            return filtered;
        }

        function _renderSocialList(d, filtered) {
            if (d.sort === 'status' && d.filter === 'all') {
                const groups = [
                    { id: 'ingame', label: '游戏中', icon: SGIS_ICONS.sparkle, friends: filtered.filter(f => f.gameextrainfo || f.personastate === 6) },
                    { id: 'online', label: '在线', icon: SGIS_ICONS.check, friends: filtered.filter(f => f.personastate > 0 && !f.gameextrainfo) },
                    { id: 'offline', label: '离线', icon: SGIS_ICONS.clock, friends: filtered.filter(f => f.personastate === 0) },
                ];
                return groups.map(g => g.friends.length > 0 ? `<div class="sgis-social-group">
                    <div class="sgis-social-group-head">${g.icon}<span>${g.label}</span><span class="count">${g.friends.length}</span></div>
                    ${g.friends.slice(0, 50).map(renderFriendCard).join('')}
                    ${g.friends.length > 50 ? `<div style="font-size:10px;color:var(--sgis-text-2);text-align:center;padding:6px">还有 ${g.friends.length - 50} 位好友未显示, 请使用筛选或搜索查看</div>` : ''}
                </div>` : '').join('');
            } else {
                let html = filtered.slice(0, 100).map(renderFriendCard).join('');
                if (filtered.length > 100) {
                    html += `<div style="font-size:10px;color:var(--sgis-text-2);text-align:center;padding:6px">显示前 100 位, 共 ${filtered.length} 位匹配好友</div>`;
                }
                return html;
            }
        }

        function _renderSocialGameCountTop(d) {
            const gcMap = SGIS.friendsGameCounts || cacheGet('friendsGameCounts_' + getActiveSteamId()) || {};
            const gcRows = d.friends
                .map(f => ({ f, gc: gcMap[f.steamid] }))
                .filter(x => x.gc && x.gc.gc > 0)
                .sort((a, b) => b.gc.gc - a.gc.gc)
                .slice(0, 10);
            const gcLoadedCount = Object.keys(gcMap).length;
            const gcBtn = `<button class="sgis-social-load-levels" id="sgis-social-load-gc" ${SGIS.friendsGameCountsLoading ? 'disabled' : ''}
                title="${isZh ? '逐好友获取游戏库数量（GetOwnedGames，6 并发，12h 缓存；私密资料自动跳过）' : 'Fetch per-friend game counts (12h cache, private profiles skipped)'}">
                ${SGIS.friendsGameCountsLoading
                    ? `${isZh ? '加载中' : 'Loading'} ${SGIS.friendsGameCountsProgress || 0}/${SGIS.friendsGameCountsTotal || '?'}`
                    : (gcRows.length > 0 ? `${SGIS_ICONS.refresh}` : `${SGIS_ICONS.library} ${isZh ? '加载游戏数' : 'Load'}`)}
            </button>`;
            return `<div class="sgis-section">
                <div class="sgis-section-title sgis-social-title">
                    <span class="sgis-social-title-text">${SGIS_ICONS.library} ${isZh ? '好友游戏数量 TOP 10' : 'Friend Game Count Top 10'}</span>
                    <div class="sgis-social-title-actions">${gcBtn}</div>
                </div>
                ${gcRows.length > 0 ? gcRows.map((x, i) => {
                    const pct = Math.max(3, Math.round(x.gc.gc / gcRows[0].gc.gc * 100));
                    const hours = Math.round((x.gc.tm || 0) / 60);
                    return `<div class="sgis-gc-row" data-profile="${x.f.profileurl}" title="${(x.f.personaname || '').replace(/"/g, '&quot;')} · ${x.gc.gc}${isZh ? '款' : ''} · ${isZh ? '总时长' : 'Total'} ${hours}h">
                        <span class="sgis-gc-no${i < 3 ? ' r' + (i + 1) : ''}">${i + 1}</span>
                        <img class="sgis-gc-avatar" src="${x.f.avatarmedium || x.f.avatar || ''}" loading="lazy" onerror="this.style.visibility='hidden'">
                        <span class="sgis-gc-name">${x.f.personaname || ''}</span>
                        <div class="sgis-gc-bar"><div class="sgis-gc-fill" style="width:${pct}%"></div></div>
                        <span class="sgis-gc-val">${x.gc.gc}${isZh ? '款' : ''}<small>${hours}h</small></span>
                    </div>`;
                }).join('') : `<div class="sgis-gc-hint">${isZh
                    ? (gcLoadedCount > 0 ? '已加载的好友均无公开游戏库（资料私密）' : '暂无数据——点击右上角"加载游戏数"逐好友获取游戏库统计<br>（私密资料自动跳过，数据缓存 12 小时）')
                    : (gcLoadedCount > 0 ? 'No public libraries among loaded friends' : 'No data — click "Load" to fetch per-friend library stats (cached 12h)')}</div>`}
            </div>`;
        }

        function _renderSocialHeaderActions(d) {
            const unknownLevelCount = d.friends.filter(f => f.level == null).length;
            const knownLevelCount = d.friends.length - unknownLevelCount;
            const loadLevelsBtn = `<button class="sgis-social-load-levels" id="sgis-social-load-levels" ${SGIS.friendsLevelsLoading ? 'disabled' : ''} title="${unknownLevelCount > 0 ? `点击同步全部好友等级 (100 并发)` : '所有好友等级均已加载'}${knownLevelCount > 0 ? `, 已加载 ${knownLevelCount} 位` : ''}">
                ${SGIS.friendsLevelsLoading
                    ? `<svg class="sgis-insight-spin" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M21 12a9 9 0 1 1-6.219-8.56"/></svg>`
                    : (unknownLevelCount > 0 ? SGIS_ICONS.trophy : '✓')}
                ${SGIS.friendsLevelsLoading
                    ? (SGIS.friendsLevelsTotal > 0 ? `同步中… ${SGIS.friendsLevelsProgress || 0}/${SGIS.friendsLevelsTotal}` : '同步中…')
                    : (unknownLevelCount > 0
                        ? `同步等级 (${unknownLevelCount})`
                        : `等级已加载`)}
            </button>`;
            const banSyncBtn = `<button class="sgis-social-ban-sync" id="sgis-social-ban-sync" ${SGIS.friendsBansLoading ? 'disabled' : ''} title="同步全部好友 VAC/游戏封禁状态 (100 并发)">
                ${SGIS.friendsBansLoading
                    ? `<svg class="sgis-insight-spin" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M21 12a9 9 0 1 1-6.219-8.56"/></svg>`
                    : SGIS_ICONS.shield}
                ${SGIS.friendsBansLoading
                    ? (SGIS.friendsBansTotal > 0 ? `同步封禁… ${SGIS.friendsBansProgress || 0}/${SGIS.friendsBansTotal}` : '同步封禁中…')
                    : '同步封禁'}
            </button>`;
            return `<div class="sgis-section-title sgis-social-title">
                <span class="sgis-social-title-text">${SGIS_ICONS.social} 好友概览</span>
                <div class="sgis-social-title-actions">
                    ${banSyncBtn}
                    ${loadLevelsBtn}
                </div>
            </div>`;
        }

        function _renderSocialErrorState() {
            return `<div class="sgis-state">
                <div style="font-size:32px;margin-bottom:8px;opacity:0.5">${SGIS_ICONS.social}</div>
                <div>获取好友列表失败</div>
                <div style="font-size:11px;color:var(--sgis-text-2);margin-top:6px">${SGIS.friendsListError}</div>
                <div style="margin-top:10px"><button class="sgis-retry-btn" id="sgis-social-retry">重试</button></div>
            </div>`;
        }

        function renderSocialContent() {
            if (SGIS.friendsListError && (!SGIS.friendsList || !SGIS.friendsList.friends || SGIS.friendsList.friends.length === 0)) {
                setBody(_renderSocialErrorState());
                const retry = document.getElementById('sgis-social-retry');
                if (retry) retry.addEventListener('click', () => {
                    SGIS.friendsList = null; SGIS.friendsListError = null;
                    renderSocial();
                });
                return;
            }
            const d = _prepareSocialData();
            const filtered = _filterSortFriends(d);
            setBody(`
                <div class="sgis-section">
                    ${_renderSocialHeaderActions(d)}
                    ${_renderSocialKPI(d)}
                </div>
                ${_renderSocialGameCountTop(d)}
                <div class="sgis-section">
                    <div class="sgis-section-title">${SGIS_ICONS.users} 好友列表 (${filtered.length}/${d.totalCount})</div>
                    ${_renderSocialToolbar(d)}
                    ${_renderSocialList(d, filtered) || '<div style="font-size:11px;color:var(--sgis-text-2);text-align:center;padding:16px">无匹配好友</div>'}
                </div>
                <div style="font-size:10px;color:var(--sgis-text-2);text-align:center;margin-top:8px">
                    好友数据缓存 6h · VAC 状态缓存 24h · 等级缓存 7天 · 数据源 Steam Web API
                </div>
            `);
            _bindSocialEvents(getActiveSteamId());
        }

        function knownFriends(friends) {
            return friends.filter(f => f.level != null).length;
        }

        // 渲染单个好友卡片
        function renderFriendCard(f) {
            const hasGame = !!f.gameextrainfo;
            const isIngame = hasGame || f.personastate === 6;
            const isOnline = f.personastate > 0 && !hasGame;
            const stateCls = isIngame ? 'ingame' : isOnline ? 'online' : 'offline';
            const statusText = hasGame ? `🎮 ${f.gameextrainfo}` : getPersonaStateText(f.personastate);
            const statusCls = isIngame ? 'ingame' : isOnline ? 'online' : 'offline';

            const avatarUrl = f.avatarmedium || f.avatar || '';
            const avatarFallback = `data:image/svg+xml;utf8,<svg xmlns=%22http://www.w3.org/2000/svg%22 viewBox=%220 0 40 40%22><rect width=%2240%22 height=%2240%22 fill=%22%231b2838%22/><text x=%2220%22 y=%2225%22 text-anchor=%22middle%22 font-size=%2216%22 fill=%22%2366c0f4%22>${(f.personaname || '?').slice(0, 1).toUpperCase()}</text></svg>`;

            const levelBadge = f.level != null ? `<span class="sgis-social-level-badge" title="Steam 等级">Lv.${f.level}</span>` : '';
            const vacShield = f.vac_banned ? `<span class="sgis-social-vac-shield" title="VAC 封禁 · 距上次封禁 ${f.vac_days_since_last_ban}天 · VAC封禁 ${f.vac_ban_count}次 · 游戏封禁 ${f.game_ban_count}次">${SGIS_ICONS.shield}VAC</span>` : '';

            // v2.3.8 修复: 用内联 SVG 国旗 + 国家名, 不再依赖外部 CDN, 加载更稳定
            const countryBadge = f.country_flag ? `<span class="sgis-social-country" title="${f.country_name || f.loccountrycode}">${f.country_flag}<span class="sgis-social-country-name">${f.country_name || f.loccountrycode}</span></span>` : '';

            return `<div class="sgis-social-friend">
                <div class="sgis-social-avatar-wrap">
                    <img class="sgis-social-avatar" src="${avatarUrl}" alt="" onerror="this.src='${avatarFallback}'">
                    <span class="sgis-social-status-dot ${stateCls}"></span>
                </div>
                <div class="sgis-social-friend-info">
                    <div class="sgis-social-friend-name-row">
                        <span class="sgis-social-friend-name" title="${f.personaname}">${f.personaname}</span>
                        ${levelBadge}
                        ${vacShield}
                    </div>
                    <div class="sgis-social-friend-meta">
                        <span class="sgis-social-friend-status ${statusCls}">${statusText}</span>
                        ${f.friend_days_text ? `<span class="sgis-social-friend-days ${f.friend_days_class || ''}" title="好友添加于 ${new Date((f.friend_since || 0) * 1000).toLocaleDateString('zh-CN')}">🤝 ${f.friend_days_text}</span>` : ''}
                        ${countryBadge}
                    </div>
                </div>
                <div class="sgis-social-friend-actions">
                    <a class="sgis-social-link-btn" href="${f.profileurl}" target="_blank" rel="noopener" title="查看 Steam 主页">${SGIS_ICONS.external}</a>
                </div>
            </div>`;
        }

        // 绑定社交页事件
        function _bindSocialEvents(steamId) {
            // 搜索
            const searchInput = document.getElementById('sgis-social-search');
            if (searchInput) {
                let timer;
                searchInput.addEventListener('input', e => {
                    clearTimeout(timer);
                    timer = setTimeout(() => {
                        SGIS.friendsSearch = e.target.value;
                        renderSocialContent();
                    }, 250);
                });
            }
            // 筛选
            document.querySelectorAll('.sgis-social-filter').forEach(btn => {
                btn.addEventListener('click', () => {
                    SGIS.friendsFilter = btn.dataset.filter;
                    renderSocialContent();
                });
            });
            // 排序
            const sortSelect = document.getElementById('sgis-social-sort');
            if (sortSelect) {
                sortSelect.addEventListener('change', e => {
                    SGIS.friendsSort = e.target.value;
                    renderSocialContent();
                });
            }
            // 同步全部等级
            const loadLevelsBtn = document.getElementById('sgis-social-load-levels');
            if (loadLevelsBtn) {
                loadLevelsBtn.addEventListener('click', async () => {
                    if (SGIS.friendsLevelsLoading) return;
                    const friends = (SGIS.friendsList && SGIS.friendsList.friends) || [];
                    const unknown = friends.filter(f => f.level == null).length;
                    if (unknown === 0) {
                        showToast(isZh ? '所有好友等级已加载' : 'All friend levels already loaded');
                        return;
                    }
                    SGIS.friendsLevelsLoading = true;
                    SGIS.friendsLevelsProgress = 0;
                    SGIS.friendsLevelsTotal = unknown;
                    renderSocialContent();
                    try {
                        const totalUnknown = unknown;
                        // v2.3.12: 100 并发，点击一次自动同步全部未知等级
                        await fetchFriendsLevels(steamId, { maxCount: Infinity });
                        const remaining = (SGIS.friendsList.friends || []).filter(f => f.level == null).length;
                        if (remaining > 0) {
                            showToast(isZh ? `已同步 ${totalUnknown - remaining}/${totalUnknown} 个等级，${remaining} 位获取失败` : `Synced ${totalUnknown - remaining}/${totalUnknown}, ${remaining} failed`);
                        } else {
                            showToast(isZh ? '所有好友等级同步完成' : 'All friend levels synced');
                        }
                    } catch (e) {
                        console.warn('[SGIS] 加载好友等级失败:', e);
                        showToast(isZh ? `同步失败: ${e.message || '网络错误'}` : `Sync failed: ${e.message || 'network error'}`);
                    } finally {
                        SGIS.friendsLevelsLoading = false;
                        renderSocialContent();
                    }
                });
            }
            // v2.3.13: 同步封禁状态按钮
            const banSyncBtn = document.getElementById('sgis-social-ban-sync');
            if (banSyncBtn) {
                banSyncBtn.addEventListener('click', async () => {
                    if (SGIS.friendsBansLoading) return;
                    const friends = (SGIS.friendsList && SGIS.friendsList.friends) || [];
                    if (friends.length === 0) {
                        showToast(isZh ? '暂无好友数据' : 'No friend data');
                        return;
                    }
                    SGIS.friendsBansLoading = true;
                    SGIS.friendsBansProgress = 0;
                    SGIS.friendsBansTotal = friends.length;
                    renderSocialContent();
                    try {
                        await fetchFriendsBans(steamId, { force: true });
                        const vacCount = (SGIS.friendsList.friends || []).filter(f => f.vac_banned).length;
                        showToast(isZh ? `封禁状态同步完成，发现 ${vacCount} 位封禁好友` : `Ban sync complete, ${vacCount} banned friends found`);
                    } catch (e) {
                        console.warn('[SGIS] 同步封禁状态失败:', e);
                        showToast(isZh ? `同步失败: ${e.message || '网络错误'}` : `Sync failed: ${e.message || 'network error'}`);
                    } finally {
                        SGIS.friendsBansLoading = false;
                        renderSocialContent();
                    }
                });
            }
            // v2.3.24: 加载好友游戏数量按钮
            const gcBtn = document.getElementById('sgis-social-load-gc');
            if (gcBtn) {
                gcBtn.addEventListener('click', async () => {
                    if (SGIS.friendsGameCountsLoading) return;
                    const friends = (SGIS.friendsList && SGIS.friendsList.friends) || [];
                    if (friends.length === 0) {
                        showToast(isZh ? '暂无好友数据' : 'No friend data');
                        return;
                    }
                    SGIS.friendsGameCountsLoading = true;
                    SGIS.friendsGameCountsProgress = 0;
                    SGIS.friendsGameCountsTotal = 0;
                    gcBtn.disabled = true;
                    gcBtn.textContent = isZh ? '加载中…' : 'Loading…';
                    try {
                        await fetchFriendsGameCounts(steamId);
                        const loaded = Object.keys(SGIS.friendsGameCounts || {}).length;
                        showToast(isZh ? `好友游戏数量加载完成（${loaded} 位，私密资料已跳过）` : `Game counts loaded (${loaded} friends)`);
                    } catch (e) {
                        console.warn('[SGIS] 加载好友游戏数量失败:', e);
                        showToast(isZh ? `加载失败: ${e.message || '网络错误'}` : `Load failed: ${e.message || 'network error'}`);
                    } finally {
                        SGIS.friendsGameCountsLoading = false;
                        renderSocialContent();
                    }
                });
            }
            // v2.3.24: 游戏数量排行行点击跳转主页
            document.querySelectorAll('.sgis-gc-row').forEach(row => {
                row.addEventListener('click', () => {
                    if (row.dataset.profile) window.open(row.dataset.profile, '_blank');
                });
            });
        }

        function renderUserAchievements() {
            if (SGIS.userAchievements && SGIS.insightData) { renderUserAchievementsContent(); return; }
            if (SGIS.userAchievementsLoading) return;
            SGIS.userAchievementsLoading = true;
            renderLoading('正在分析游戏数据…');
            setTimeout(() => {
                SGIS.userAchievements = computeUserAchievements();
                SGIS.insightData = computeInsightData();
                SGIS.userAchievementsLoading = false;
                renderUserAchievementsContent();
            }, 200);
        }

        // ==================== v2.3.8: 洞察数据本地计算 (参考 AIPage analyzeLibrary) ====================
        // v2.9.50: 改为调用主闭包缓存版本(PCC 持久化)— 跨 session 复用,避免每次开洞察标签页都全量重算
        // v2.9.68: 修复 ReferenceError — computeInsightDataCachedSgis 在 SGLV 子闭包内,通过 SGLV_API 桥接调用
        function computeInsightData() {
            if (typeof SGLV_API.computeInsightDataCachedSgis === 'function') {
                return SGLV_API.computeInsightDataCachedSgis();
            }
            console.warn('[SGIS] computeInsightData: SGLV_API桥接不可用,返回 null');
            return null;
        }

        // ---- FEAT-014 TASK-006 回归补拆: renderUserAchievementsContent(洞察 Tab) 段化 ----
        // KPI/画像/维度/AI/口味/成就 6 段渲染器 + 事件绑定段,主函数降级为组装器
        function _renderInsightEmpty() {
            return `<div class="sgis-state">
                <div style="font-size:32px;margin-bottom:8px;opacity:0.5">${SGIS_ICONS.insight}</div>
                <div>暂无洞察数据</div>
                <div style="font-size:11px;color:var(--sgis-text-2);margin-top:6px">请先获取游戏库数据</div>
            </div>`;
        }

        // ── KPI 卡片 (参考 AIPage LocalKpiCard) ──
        // v2.11.1: KPI_GRADIENTS/renderKpi 已提升至 SGIS 闭包共享层(见 renderSocialContent 定义之前)
        function _renderInsightKpi(k) {
            return `
                <div class="sgis-insight-kpi-grid">
                    ${renderKpi(SGIS_ICONS.barChart, '游戏库', k.gameCount, `${k.over100hCount} 款超 100h`, KPI_GRADIENTS.blue, 'blue')}
                    ${renderKpi(SGIS_ICONS.clock, '总时长', k.totalHours + ' h', `平均 ${k.avgHours}h/款`, KPI_GRADIENTS.cyan, 'cyan')}
                    ${renderKpi(SGIS_ICONS.check, '已启动', k.playedCount, `占比 ${k.gameCount > 0 ? Math.round(k.playedCount / k.gameCount * 100) : 0}%`, KPI_GRADIENTS.purple, 'purple')}
                    ${renderKpi(SGIS_ICONS.sparkle, '未启动', k.unplayedCount, `吃灰率 ${(k.dustRate * 100).toFixed(1)}%`, KPI_GRADIENTS.amber, 'amber')}
                    ${renderKpi(SGIS_ICONS.trophy, '深度游玩', k.longGamesCount, '≥10h 的游戏数', KPI_GRADIENTS.rose, 'rose')}
                    ${renderKpi(SGIS_ICONS.target, '完成度', k.completionRate + '%', '深度游玩/已启动', KPI_GRADIENTS.purple, 'purple')}
                </div>
            `;
        }

        // ── 玩家画像区 (参考 AIPage persona 卡片) ──
        function _renderInsightPersona(k, p) {
            return `
                <div class="sgis-insight-persona">
                    <div class="sgis-insight-persona-head">
                        <div class="sgis-insight-persona-icon">${SGIS_ICONS.insight}</div>
                        <div style="flex:1;min-width:0">
                            <div class="sgis-insight-persona-title">${p.type}<span class="sgis-insight-persona-rarity">${p.rarity}</span></div>
                            <div class="sgis-insight-persona-tagline">${p.tagline}</div>
                        </div>
                    </div>
                    <div class="sgis-insight-persona-body">
                        <div class="sgis-insight-persona-traits">
                            ${p.traits.map(t => `<span class="sgis-insight-persona-trait">${t}</span>`).join('')}
                        </div>
                        <div class="sgis-insight-metrics">
                            <div class="sgis-insight-metric">
                                <div class="sgis-insight-metric-icon" style="background:${KPI_GRADIENTS.blue}">${SGIS_ICONS.barChart}</div>
                                <div><div class="sgis-insight-metric-label">总游戏</div><div class="sgis-insight-metric-val">${k.gameCount}</div></div>
                            </div>
                            <div class="sgis-insight-metric">
                                <div class="sgis-insight-metric-icon" style="background:${KPI_GRADIENTS.cyan}">${SGIS_ICONS.clock}</div>
                                <div><div class="sgis-insight-metric-label">总时长</div><div class="sgis-insight-metric-val">${k.totalHours}h</div></div>
                            </div>
                            <div class="sgis-insight-metric">
                                <div class="sgis-insight-metric-icon" style="background:${KPI_GRADIENTS.amber}">${SGIS_ICONS.trend}</div>
                                <div><div class="sgis-insight-metric-label">超100h</div><div class="sgis-insight-metric-val">${k.over100hCount}</div></div>
                            </div>
                            <div class="sgis-insight-metric">
                                <div class="sgis-insight-metric-icon" style="background:${KPI_GRADIENTS.rose}">${SGIS_ICONS.sparkle}</div>
                                <div><div class="sgis-insight-metric-label">吃灰率</div><div class="sgis-insight-metric-val">${(k.dustRate * 100).toFixed(1)}%</div></div>
                            </div>
                            <div class="sgis-insight-metric">
                                <div class="sgis-insight-metric-icon" style="background:${KPI_GRADIENTS.purple}">${SGIS_ICONS.target}</div>
                                <div><div class="sgis-insight-metric-label">主导维度</div><div class="sgis-insight-metric-val">${p.dominantDim}</div></div>
                            </div>
                        </div>
                    </div>
                </div>
            `;
        }

        // ── 维度评分卡片 (参考 AIPage LocalDimensionCard) ──
        function _renderInsightDimensions(data) {
            const getDimTagClass = (s) => s >= 80 ? 't-high' : s >= 60 ? 't-mid' : s >= 40 ? 't-low' : 't-bad';
            const getDimProgressColor = (s) => s >= 80 ? '#10b981' : s >= 60 ? '#3b82f6' : s >= 40 ? '#f59e0b' : '#f43f5e';
            return `
                <div class="sgis-insight-dim-grid">
                    ${data.dimensions.map(d => `<div class="sgis-insight-dim">
                        <div class="sgis-insight-dim-bar" style="background:${d.gradient}"></div>
                        <div class="sgis-insight-dim-body">
                            <div class="sgis-insight-dim-head">
                                <div class="sgis-insight-dim-title-row">
                                    <span class="sgis-insight-dim-label">${d.label}</span>
                                    <span class="sgis-insight-dim-tag ${getDimTagClass(d.score)}">${d.tag}</span>
                                </div>
                                <span class="sgis-insight-dim-score">${d.score}</span>
                            </div>
                            <div class="sgis-insight-dim-progress">
                                <div class="sgis-insight-dim-progress-fill" style="width:${d.score}%;background:${getDimProgressColor(d.score)}"></div>
                            </div>
                            <div class="sgis-insight-dim-desc">${d.desc}</div>
                        </div>
                    </div>`).join('')}
                </div>
            `;
        }

        // ── AI 深度分析区 (参考 AIPage "游戏库深度分析",4 状态) ──
        function _renderInsightAi() {
            const aiConfigured = !!storage.getAiApiKey();
            const aiSectionHtml = SGIS.aiInsight ? `
                ${SGIS.aiInsight.oneLiner ? `<div class="sgis-insight-ai-oneliner">
                    ${SGIS_ICONS.target}
                    <div class="sgis-insight-ai-oneliner-text">${SGIS.aiInsight.oneLiner}</div>
                </div>` : ''}
                ${SGIS.aiInsight.sections.map((s, i) => {
                    // v2.9.84: 六维度配色, 新增绿色渐变给"犀利毒舌"
                    const grad = [KPI_GRADIENTS.blue, KPI_GRADIENTS.cyan, KPI_GRADIENTS.purple, KPI_GRADIENTS.rose, KPI_GRADIENTS.amber, KPI_GRADIENTS.green][i % 6];
                    return `<div class="sgis-insight-ai-section">
                        <div class="sgis-insight-ai-section-head" style="background:${grad}">
                            ${SGIS_ICONS.sparkle}<span>${s.title}</span>
                        </div>
                        <div class="sgis-insight-ai-section-body">${s.content}</div>
                    </div>`;
                }).join('')}
            ` : SGIS.aiInsightLoading ? `
                <div class="sgis-insight-ai-empty">
                    <div class="sgis-insight-ai-empty-icon sgis-insight-spin">${SGIS_ICONS.refresh}</div>
                    <div class="sgis-insight-ai-empty-text">AI 正在分析你的游戏库…</div>
                    <div class="sgis-insight-ai-empty-sub">六维度犀利点评生成中, 预计 15-30 秒</div>
                </div>
            ` : SGIS.aiInsightError ? `
                <div class="sgis-insight-ai-empty">
                    <div class="sgis-insight-ai-empty-icon" style="color:#fda4af">⚠️</div>
                    <div class="sgis-insight-ai-empty-text">分析失败: ${SGIS.aiInsightError}</div>
                    <div style="margin-top:8px"><button class="sgis-retry-btn" id="sgis-insight-retry">重试</button></div>
                </div>
            ` : `
                <div class="sgis-insight-ai-empty">
                    <div class="sgis-insight-ai-empty-icon">${SGIS_ICONS.brain}</div>
                    <div class="sgis-insight-ai-empty-text">点击「开始深度分析」</div>
                    <div class="sgis-insight-ai-empty-sub">AI 将从库存概况、游玩习惯、偏好画像、亮点槽点、购买建议、犀利毒舌六个维度犀利点评</div>
                    ${!aiConfigured ? `<div class="sgis-insight-ai-empty-warn">⚠️ 未配置 AI API Key, 请先在设置中配置</div>` : ''}
                </div>
            `;

            return `
                <div class="sgis-insight-ai">
                    <div class="sgis-insight-ai-head">
                        <div class="sgis-insight-ai-title-row">
                            <div class="sgis-insight-ai-icon">${SGIS_ICONS.brain}</div>
                            <div>
                                <div class="sgis-insight-ai-title">AI 深度分析</div>
                                <div class="sgis-insight-ai-subtitle">六维度犀利点评你的 Steam 库存</div>
                            </div>
                        </div>
                        <button class="sgis-insight-ai-btn" id="sgis-insight-trigger" ${SGIS.aiInsightLoading || !aiConfigured ? 'disabled' : ''}>
                            ${SGIS.aiInsightLoading ? `<svg class="sgis-insight-spin" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M21 12a9 9 0 1 1-6.219-8.56"/></svg>` : SGIS_ICONS.zap}
                            ${SGIS.aiInsightLoading ? '分析中…' : SGIS.aiInsight ? '重新分析' : '开始深度分析'}
                        </button>
                    </div>
                    <div class="sgis-insight-ai-body">${aiSectionHtml}</div>
                </div>
            `;
        }

        // ── 底部成就引导 (v2.9.38: 移除重复展示, 改为简洁跳转入口指向中央面板) ──
        function _renderInsightAchEntry() {
            const achievements = SGIS.userAchievements || [];
            const unlocked = achievements.filter(a => a.unlocked);
            return `
                <div class="sgis-insight-ach-entry">
                    ${SGIS_ICONS.trophy}
                    <div class="sgis-insight-ach-entry-info">
                        <div class="sgis-insight-ach-entry-title">${isZh ? '我的成就' : 'My Achievements'}</div>
                        <div class="sgis-insight-ach-entry-sub">${isZh ? `已解锁 ${unlocked.length}/${achievements.length} · 共 ${achievements.reduce((s,a)=>s+(a.pts||0),0)} 成就点` : `Unlocked ${unlocked.length}/${achievements.length} · ${achievements.reduce((s,a)=>s+(a.pts||0),0)} pts`}</div>
                    </div>
                    <button class="sgis-insight-ach-entry-btn" id="sgis-insight-ach-open">${isZh ? '在中央面板查看' : 'Open in Modal'}</button>
                </div>
            `;
        }

        // v2.9.83: 游戏口味标签画像 — 从愿望单标签 + 游玩模式 + 画像特征推断
        function _renderInsightGameTaste(data, k, p) {
            // 1) 收集愿望单标签频率 (用户主动添加的标签反映真实兴趣)
            const tagFreq = {};
            if (Array.isArray(state.wishlistGames)) {
                for (const g of state.wishlistGames) {
                    if (g && Array.isArray(g.tags)) {
                        for (const t of g.tags) {
                            const tag = String(t).trim();
                            if (tag) tagFreq[tag] = (tagFreq[tag] || 0) + 1;
                        }
                    }
                }
            }
            // 取频率最高的标签 (至少出现2次)
            const sortedTags = Object.entries(tagFreq)
                .filter(([, c]) => c >= 2)
                .sort((a, b) => b[1] - a[1])
                .slice(0, 20);

            // 2) 基于游玩模式推断口味标签
            const tasteTags = [];
            if (k.over100hCount >= 5) tasteTags.push({ label: '长篇沉浸', cat: 'style' });
            if (k.gameCount > 0 && k.playedCount / k.gameCount < 0.5) tasteTags.push({ label: '收藏型', cat: 'style' });
            if (k.avgHours >= 50) tasteTags.push({ label: '硬核深度', cat: 'style' });
            if (k.dustRate > 0.5) tasteTags.push({ label: '吃灰大户', cat: 'style' });
            if (k.completionRate >= 60) tasteTags.push({ label: '认真通关', cat: 'feature' });
            if (k.gameCount >= 200) tasteTags.push({ label: '量大管饱', cat: 'feature' });
            if (k.over500hCount >= 1) tasteTags.push({ label: '极致专注', cat: 'feature' });

            // 3) 从 persona traits 提取标签
            if (p.traits && p.traits.length) {
                p.traits.slice(0, 3).forEach(t => tasteTags.push({ label: t, cat: 'theme' }));
            }

            // 4) 将愿望单标签映射为口味标签
            const genreKeywords = { '动作': 'genre', '冒险': 'genre', '策略': 'genre', 'RPG': 'genre', '独立': 'genre', '模拟': 'genre', '休闲': 'genre', '竞速': 'genre', '体育': 'genre', '恐怖': 'genre', '射击': 'genre', '解谜': 'genre', '平台': 'genre', '开放世界': 'genre', '生存': 'genre', '多人': 'feature', '合作': 'feature', '单机': 'feature', 'PvP': 'feature', '沙盒': 'style', 'Roguelike': 'style', '像素': 'style', '剧情': 'theme', '科幻': 'theme', '奇幻': 'theme', '二次元': 'theme' };
            const wlTasteTags = sortedTags.slice(0, 12).map(([tag, count]) => {
                let cat = 'theme';
                for (const [kw, c] of Object.entries(genreKeywords)) {
                    if (tag.includes(kw) || kw.includes(tag)) { cat = c; break; }
                }
                return { label: tag, cat, count };
            });

            // 5) 合并去重
            const allTags = [...tasteTags, ...wlTasteTags];
            const seen = new Set();
            const dedupedTags = allTags.filter(t => {
                if (seen.has(t.label)) return false;
                seen.add(t.label);
                return true;
            }).slice(0, 18);

            // 6) 标签大小分级 (基于频率/权重)
            const maxCount = Math.max(...sortedTags.map(([, c]) => c), 1);
            const tagCloudHtml = dedupedTags.map(t => {
                const weight = t.count ? t.count / maxCount : 0.5;
                const sizeCls = weight > 0.7 ? 't-xl' : weight > 0.5 ? 't-lg' : weight > 0.3 ? 't-md' : 't-sm';
                return `<span class="sgis-taste-tag ${t.cat} ${sizeCls}">${escHtml(t.label)}</span>`;
            }).join('');

            // 7) 游玩时长分布条形图 (按维度分数)
            const bars = data.dimensions.slice(0, 5).map(d => {
                const color = d.score >= 80 ? '#10b981' : d.score >= 60 ? '#3b82f6' : d.score >= 40 ? '#f59e0b' : '#f43f5e';
                return hbarRow({
                    cls: 'taste', name: escHtml(d.label), nameTag: 'div',
                    pct: d.score, color, val: `${d.score} · ${escHtml(d.tag)}`, valTag: 'div',
                });
            }).join('');

            return `<div class="sgis-section">
                <div class="sgis-section-title">${SGIS_ICONS.tag || '🏷️'} ${isZh ? '游戏口味' : 'Game Taste'} <span style="font-size:10px;color:var(--sgis-text-2);font-weight:400">${isZh ? '标签画像' : 'Profile'}</span></div>
                <div class="sgis-taste-section">
                    <div style="font-size:10px;color:var(--sgis-text-2);margin-bottom:6px">${isZh ? '基于愿望单标签与游玩习惯推断' : 'Inferred from wishlist tags & play habits'}</div>
                    <div class="sgis-taste-cloud">${tagCloudHtml}</div>
                </div>
                <div class="sgis-taste-bars">${bars}</div>
            </div>`;
        }

        function _bindInsightEvents() {
            // 绑定 AI 深度分析按钮
            const triggerBtn = document.getElementById('sgis-insight-trigger');
            if (triggerBtn) triggerBtn.addEventListener('click', triggerAiInsight);
            const retryBtn = document.getElementById('sgis-insight-retry');
            if (retryBtn) retryBtn.addEventListener('click', () => { SGIS.aiInsightError = null; triggerAiInsight(); });

            // 绑定市场洞察按钮
            const marketBtn = document.getElementById('sgis-market-trigger');
            if (marketBtn) marketBtn.addEventListener('click', triggerAiMarketInsight);
            const marketRetry = document.getElementById('sgis-market-retry');
            if (marketRetry) marketRetry.addEventListener('click', () => { SGIS.aiMarketInsightError = null; triggerAiMarketInsight(); });

            // v2.9.38: 绑定成就引导按钮 — 关闭 SGIS 侧边栏并打开中央面板的"游戏成就"页签(展示该游戏的具体成就)
            const achOpenBtn = document.getElementById('sgis-insight-ach-open');
            if (achOpenBtn) achOpenBtn.addEventListener('click', () => {
                try {
                    if (typeof closePanel === 'function') closePanel();
                    // 触发中央面板打开 + 切换到游戏成就标签(展示当前游戏的成就数据)
                    document.dispatchEvent(new CustomEvent('sglv:open-modal', { detail: { tab: 'achievements' } }));
                } catch (e) { /* 静默 */ }
            });
        }

        function renderUserAchievementsContent() {
            const data = SGIS.insightData;
            // 数据为空时的兜底
            if (!data || !data.kpi) {
                setBody(_renderInsightEmpty());
                return;
            }

            const k = data.kpi;
            const p = data.persona;
            const kpiHtml = _renderInsightKpi(k);
            const personaHtml = _renderInsightPersona(k, p);
            const dimensionsHtml = _renderInsightDimensions(data);
            const aiHtml = _renderInsightAi();

            // ── 游戏市场洞察区 (基于卡牌/徽章数据) ──
            const marketHtml = renderMarketInsightSection();
            const achievementsHtml = _renderInsightAchEntry();
            const gameTasteHtml = _renderInsightGameTaste(data, k, p);

            setBody(`
                <div class="sgis-section">
                    <div class="sgis-section-title">${SGIS_ICONS.barChart} KPI 概览</div>
                    ${kpiHtml}
                </div>
                ${personaHtml}
                ${gameTasteHtml}
                <div class="sgis-section">
                    <div class="sgis-section-title">${SGIS_ICONS.target} 五维度评分</div>
                    ${dimensionsHtml}
                </div>
                ${aiHtml}
                ${marketHtml}
                <div class="sgis-section">
                    <div class="sgis-section-title">${SGIS_ICONS.trophy} 成就系统</div>
                    ${achievementsHtml}
                </div>
                <div style="font-size:10px;color:var(--sgis-text-2);text-align:center;margin-top:8px">
                    洞察数据基于本地游戏库本地计算 · AI 分析需配置 AI API Key · 参考 steam-game-hub-2.0 AIPage 设计
                </div>
            `);

            // v2.3.33：异步加载市场洞察游戏中文名；v2.11.4 改经 applyGameAliases（scope 限定 SGIS 作用域）
            applyGameAliases(document, { scope: '#sgis-body' });

            _bindInsightEvents();
        }

        // ==================== v2.3.8: 游戏市场洞察渲染 (基于 userBadgeMarkets 数据) ====================
        function renderMarketInsightSection() {
            const markets = SGIS.userBadgeMarkets || {};
            const aiConfigured = !!storage.getAiApiKey();

            // 统计卡牌市场数据
            const gameMarkets = Object.entries(markets)
                .filter(([appId, m]) => m && m.cards && m.cards.length > 0)
                .map(([appId, m]) => {
                    const totalValue = (m.cards || []).reduce((s, c) => s + (c.lowestPrice || 0), 0);
                    const avgValue = totalValue / (m.cards || []).length;
                    const gameName = (m.gameName || state.ownedGames?.find(g => String(g.appid) === String(appId))?.name || `App ${appId}`);
                    return { appId, gameName, cardCount: (m.cards || []).length, totalValue, avgValue };
                })
                .sort((a, b) => b.totalValue - a.totalValue);

            const totalCardValue = gameMarkets.reduce((s, g) => s + g.totalValue, 0);
            const totalCards = gameMarkets.reduce((s, g) => s + g.cardCount, 0);
            const top5 = gameMarkets.slice(0, 5);

            const aiMarketHtml = SGIS.aiMarketInsight ? `
                ${SGIS.aiMarketInsight.summary ? `<div class="sgis-insight-market-summary">${SGIS.aiMarketInsight.summary}</div>` : ''}
                ${SGIS.aiMarketInsight.recommendations && SGIS.aiMarketInsight.recommendations.length > 0 ? SGIS.aiMarketInsight.recommendations.map(r => `
                    <div class="sgis-insight-market-rec">
                        <div class="sgis-insight-market-rec-head">
                            <span class="sgis-insight-market-rec-name">${r.name}</span>
                            <span class="sgis-insight-market-rec-action ${r.action === '买入' || r.action === 'buy' ? 'buy' : r.action === '卖出' || r.action === 'sell' ? 'sell' : 'hold'}">${r.action}</span>
                        </div>
                        <div class="sgis-insight-market-rec-reason">${r.reason}</div>
                    </div>
                `).join('') : ''}
            ` : SGIS.aiMarketInsightLoading ? `
                <div class="sgis-insight-ai-empty">
                    <div class="sgis-insight-ai-empty-icon sgis-insight-spin">${SGIS_ICONS.refresh}</div>
                    <div class="sgis-insight-ai-empty-text">AI 正在分析市场数据…</div>
                    <div class="sgis-insight-ai-empty-sub">生成投资建议中</div>
                </div>
            ` : SGIS.aiMarketInsightError ? `
                <div class="sgis-insight-ai-empty">
                    <div class="sgis-insight-ai-empty-icon" style="color:#fda4af">⚠️</div>
                    <div class="sgis-insight-ai-empty-text">分析失败: ${SGIS.aiMarketInsightError}</div>
                    <div style="margin-top:8px"><button class="sgis-retry-btn" id="sgis-market-retry">重试</button></div>
                </div>
            ` : `
                <div class="sgis-insight-ai-empty">
                    <div class="sgis-insight-ai-empty-icon">${SGIS_ICONS.market}</div>
                    <div class="sgis-insight-ai-empty-text">点击「生成投资建议」</div>
                    <div class="sgis-insight-ai-empty-sub">AI 将基于你的卡牌库分析哪些游戏卡牌值得合成/出售</div>
                    ${!aiConfigured ? `<div class="sgis-insight-ai-empty-warn">⚠️ 未配置 AI API Key</div>` : ''}
                    ${top5.length === 0 ? `<div class="sgis-insight-ai-empty-warn" style="background:var(--sglv-accent-bg);color:var(--sglv-accent-light)">📡 暂无卡牌市场数据, 请先访问「勋章」标签页加载</div>` : ''}
                </div>
            `;

            return `
                <div class="sgis-insight-market">
                    <div class="sgis-insight-market-head">
                        <div class="sgis-insight-market-title-row">
                            <div class="sgis-insight-market-icon">${SGIS_ICONS.market}</div>
                            <div>
                                <div class="sgis-insight-market-title">游戏市场洞察</div>
                                <div class="sgis-insight-market-subtitle">基于你的卡牌库分析市场价值与投资机会</div>
                            </div>
                        </div>
                        <button class="sgis-insight-market-btn" id="sgis-market-trigger" ${SGIS.aiMarketInsightLoading || !aiConfigured || top5.length === 0 ? 'disabled' : ''}>
                            ${SGIS.aiMarketInsightLoading ? `<svg class="sgis-insight-spin" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M21 12a9 9 0 1 1-6.219-8.56"/></svg>` : SGIS_ICONS.zap}
                            ${SGIS.aiMarketInsightLoading ? '分析中…' : SGIS.aiMarketInsight ? '重新分析' : '生成投资建议'}
                        </button>
                    </div>
                    <div class="sgis-insight-market-body">
                        ${top5.length > 0 ? `
                            <div class="sgis-insight-market-stats">
                                <div class="sgis-insight-market-stat">
                                    <div class="sgis-insight-market-stat-val">${gameMarkets.length}</div>
                                    <div class="sgis-insight-market-stat-label">有卡牌游戏</div>
                                </div>
                                <div class="sgis-insight-market-stat">
                                    <div class="sgis-insight-market-stat-val">${totalCards}</div>
                                    <div class="sgis-insight-market-stat-label">卡牌总数</div>
                                </div>
                                <div class="sgis-insight-market-stat">
                                    <div class="sgis-insight-market-stat-val">¥${totalCardValue.toFixed(0)}</div>
                                    <div class="sgis-insight-market-stat-label">总价值</div>
                                </div>
                            </div>
                            <div style="font-size:10px;font-weight:700;color:#6ee7b7;margin-bottom:6px;text-transform:uppercase;letter-spacing:0.5px">价值 Top 5</div>
                            ${top5.map((g, i) => `<div class="sgis-insight-market-row ${i === 0 ? 'top1' : ''}">
                                <div class="sgis-insight-market-rank">${i + 1}</div>
                                <div class="sgis-insight-market-name" data-sglv-appid="${g.appId}">${g.gameName}</div>
                                <div class="sgis-insight-market-val">¥${g.totalValue.toFixed(2)}<span style="font-size:9px;color:var(--sgis-text-2);font-weight:400"> · ${g.cardCount}卡</span></div>
                            </div>`).join('')}
                        ` : `<div style="font-size:11px;color:var(--sgis-text-2);text-align:center;padding:12px">暂无卡牌市场数据<br><span style="font-size:10px">请先访问「勋章」标签页加载卡牌数据</span></div>`}
                        <div style="margin-top:10px">${aiMarketHtml}</div>
                    </div>
                </div>
            `;
        }

        // ==================== v2.3.8: AI 深度分析 (参考 AIPage analyzeLibrary + handleLibraryAnalyze) ====================
        async function triggerAiInsight() {
            if (SGIS.aiInsightLoading) return;
            const apiKey = storage.getAiApiKey();
            if (!apiKey) { showToast('未配置 AI API Key，请在设置中配置'); return; }
            SGIS.aiInsightLoading = true;
            SGIS.aiInsightError = null;
            SGIS.aiInsight = null;
            renderUserAchievementsContent();
            try {
                const data = SGIS.insightData || computeInsightData();
                const k = data.kpi;
                const p = data.persona;
                const profile = SGIS.profile?.summary;
                const personaName = profile?.personaname || '未知';
                const level = SGIS.profile?.level || SGIS.userBadges?.playerLevel || '?';

                // 构造输入数据摘要
                const topGamesStr = data.topGames.map(g => `${g.name}(${g.hours}h)`).join(', ');
                const recentStr = data.recentGames.map(g => `${g.name}(${g.hours}h)`).join(', ');
                const dustStr = data.dustCollectors.join(', ');
                const dimsStr = data.dimensions.map(d => `${d.label}=${d.score}分(${d.tag})`).join(', ');
                const traitsStr = p.traits.join('、');

                // v2.9.84: 构建个人口味标签摘要 (与洞察页面"游戏口味"标签画像同步)
                const tasteTags = [];
                if (k.over100hCount >= 5) tasteTags.push('长篇沉浸');
                if (k.gameCount > 0 && k.playedCount / k.gameCount < 0.5) tasteTags.push('收藏型');
                if (k.avgHours >= 50) tasteTags.push('硬核深度');
                if (k.dustRate > 0.5) tasteTags.push('吃灰大户');
                if (k.completionRate >= 60) tasteTags.push('认真通关');
                if (k.gameCount >= 200) tasteTags.push('量大管饱');
                if (k.over500hCount >= 1) tasteTags.push('极致专注');
                // 愿望单标签频率 (用户主动添加的标签反映真实兴趣)
                const wlTagFreq = {};
                if (Array.isArray(state.wishlistGames)) {
                    for (const g of state.wishlistGames) {
                        if (g && Array.isArray(g.tags)) {
                            for (const t of g.tags) {
                                const tag = String(t).trim();
                                if (tag) wlTagFreq[tag] = (wlTagFreq[tag] || 0) + 1;
                            }
                        }
                    }
                }
                const topWlTags = Object.entries(wlTagFreq)
                    .filter(([, c]) => c >= 2)
                    .sort((a, b) => b[1] - a[1])
                    .slice(0, 10)
                    .map(([t]) => t);
                const tasteTagsStr = [...tasteTags, ...p.traits].join('、');
                const wlTagsStr = topWlTags.join('、');
                const dimsDetailStr = data.dimensions.map(d => `${d.label}=${d.score}分(${d.tag}) - ${d.desc}`).join('\n');

                // v2.9.85: 从远程模板加载提示词, 支持随时修改无需更新脚本
                let prompt = await getInsightPromptTemplate();
                prompt = prompt.replace(/\{PERSONA_NAME\}/g, personaName)
                               .replace(/\{STEAM_LEVEL\}/g, String(level))
                               .replace(/\{GAME_COUNT\}/g, String(k.gameCount))
                               .replace(/\{TOTAL_HOURS\}/g, String(k.totalHours))
                               .replace(/\{PLAYED_COUNT\}/g, String(k.playedCount))
                               .replace(/\{PLAYED_PERCENT\}/g, String(k.gameCount > 0 ? Math.round(k.playedCount / k.gameCount * 100) : 0))
                               .replace(/\{UNPLAYED_COUNT\}/g, String(k.unplayedCount))
                               .replace(/\{DUST_RATE\}/g, (k.dustRate * 100).toFixed(1))
                               .replace(/\{OVER_100H_COUNT\}/g, String(k.over100hCount))
                               .replace(/\{OVER_500H_COUNT\}/g, String(k.over500hCount))
                               .replace(/\{LONG_GAMES_COUNT\}/g, String(k.longGamesCount))
                               .replace(/\{AVG_HOURS\}/g, String(k.avgHours))
                               .replace(/\{PERSONA_TYPE\}/g, p.type)
                               .replace(/\{PERSONA_RARITY\}/g, p.rarity)
                               .replace(/\{TRAITS\}/g, traitsStr || '无')
                               .replace(/\{TASTE_TAGS\}/g, tasteTagsStr || '无')
                               .replace(/\{WISHLIST_TAGS\}/g, wlTagsStr || '无')
                               .replace(/\{DIM_SCORES\}/g, dimsStr)
                               .replace(/\{DIM_DETAILS\}/g, dimsDetailStr)
                               .replace(/\{TOP_GAMES\}/g, topGamesStr || '无数据')
                               .replace(/\{RECENT_GAMES\}/g, recentStr || '无数据')
                               .replace(/\{DUST_EXAMPLES\}/g, dustStr || '无');

                const content = await callAiApi(prompt, { temperature: 0.6, timeout: 90000, maxTokens: 6144 });
                const result = safeParseAiJson(content, '{');
                // 校验结构
                if (!result.oneLiner || !Array.isArray(result.sections)) {
                    throw new Error('AI 返回结构不完整');
                }
                SGIS.aiInsight = result;
            } catch (e) {
                SGIS.aiInsightError = e.message || 'AI 分析失败';
            } finally {
                SGIS.aiInsightLoading = false;
                renderUserAchievementsContent();
            }
        }

        // ==================== v2.3.8: AI 市场洞察 (基于卡牌市场数据) ====================
        async function triggerAiMarketInsight() {
            if (SGIS.aiMarketInsightLoading) return;
            const apiKey = storage.getAiApiKey();
            if (!apiKey) { showToast('未配置 AI API Key，请在设置中配置'); return; }
            const markets = SGIS.userBadgeMarkets || {};
            const gameMarkets = Object.entries(markets)
                .filter(([appId, m]) => m && m.cards && m.cards.length > 0)
                .map(([appId, m]) => {
                    const totalValue = (m.cards || []).reduce((s, c) => s + (c.lowestPrice || 0), 0);
                    const gameName = m.gameName || state.ownedGames?.find(g => String(g.appid) === String(appId))?.name || `App ${appId}`;
                    return { appId, gameName, cardCount: (m.cards || []).length, totalValue, avgValue: totalValue / (m.cards || []).length, cards: m.cards };
                })
                .sort((a, b) => b.totalValue - a.totalValue)
                .slice(0, 10);

            if (gameMarkets.length === 0) {
                showToast('暂无卡牌市场数据, 请先访问「勋章」标签页加载');
                return;
            }

            SGIS.aiMarketInsightLoading = true;
            SGIS.aiMarketInsightError = null;
            SGIS.aiMarketInsight = null;
            renderUserAchievementsContent();
            try {
                const totalValue = gameMarkets.reduce((s, g) => s + g.totalValue, 0);
                const totalCards = gameMarkets.reduce((s, g) => s + g.cardCount, 0);
                const gamesDataStr = gameMarkets.map(g => {
                    const cardDetails = g.cards.slice(0, 5).map(c => `${c.name || '卡'}(¥${(c.lowestPrice || 0).toFixed(2)})`).join(', ');
                    return `- ${g.gameName} (AppID:${g.appId}): ${g.cardCount}张卡牌, 总价值¥${g.totalValue.toFixed(2)}, 均价¥${g.avgValue.toFixed(2)} | 卡牌示例: ${cardDetails}`;
                }).join('\n');

                const prompt = `# 角色\n你是一位 Steam 卡牌市场投资顾问, 精通卡牌合成、徽章升级、市场套利策略。\n\n# 任务\n基于玩家的 Steam 卡牌库数据, 生成市场洞察报告和投资建议。\n\n# 输入数据\n- 有卡牌游戏数: ${gameMarkets.length}\n- 卡牌总数: ${totalCards}\n- 卡牌总价值: ¥${totalValue.toFixed(2)}\n\n## 游戏卡牌详情 (Top ${gameMarkets.length})\n${gamesDataStr}\n\n# 输出格式\n严格按以下 JSON 格式输出, 不要输出任何其他文字。\n{\n  "summary": "2-3句话市场总览, 评价卡牌库整体价值、合成潜力、套利空间",\n  "recommendations": [\n    {"name": "游戏名称", "action": "买入/卖出/持有/合成", "reason": "1-2句话具体建议理由, 包含数据"}\n  ]\n}\n\n# 要求\n- recommendations 数组包含 3-5 条建议, 优先选择价值最高或最有套利空间的游戏\n- action 只能是: 买入(补全卡牌合成徽章)、卖出(出售多余卡牌获利)、持有(暂不操作)、合成(立即合成徽章升级)\n- reason 必须包含具体数据支撑\n- 语言简洁有力, 避免空话`;

                const content = await callAiApi(prompt, { temperature: 0.4, timeout: 90000 });
                const result = safeParseAiJson(content, '{');
                if (!result.summary || !Array.isArray(result.recommendations)) {
                    throw new Error('AI 返回结构不完整');
                }
                SGIS.aiMarketInsight = result;
            } catch (e) {
                SGIS.aiMarketInsightError = e.message || 'AI 市场分析失败';
            } finally {
                SGIS.aiMarketInsightLoading = false;
                renderUserAchievementsContent();
            }
        }

        // v2.11.24 (FEAT-014 TASK-001): SGIS Tab 分发表——11 Tab 入口集中注册,
        // renderTab 由 if-else 链改表查找;overview 副作用 fetch 外提至 prepare 步骤.
        // 表条目: render(渲染入口) + 可选 prepare(数据准备,带副作用 fetch 的 Tab 单独注册);
        // renderError 复用 TAB_CACHE_RESET 清理表(与原 if-else 链共用,未变).
        // 未注册 Tab 空渲染 + 警告(与原 if-else 链末端无匹配行为一致)
        const SGIS_TAB_RENDERERS = {
            overview: {
                render: () => renderOverview(),
                prepare: () => {
                    // 异步检测家庭共享支持
                    if (!SGIS.familyShareSupported) {
                        fetchFamilyShareSupport().then(r => {
                            SGIS.familyShareSupported = r;
                            if (SGIS.tab === 'overview') renderOverview();
                        }).catch(() => {});
                    }
                    // v2.3.16: 异步拉取 appdetails 增强信息 (工坊/截图/分类/捆绑包等)
                    if (!SGIS.appDetailsExtra && !SGIS.appDetailsExtraLoading) {
                        SGIS.appDetailsExtraLoading = true;
                        fetchAppDetailsExtra().then(extra => {
                            // v2.9.114: appdetails 失败/未返回 dlc 时，从商店页 DOM 兜底提取 DLC 列表
                            extra = mergeDlcFromDom(extra);
                            SGIS.appDetailsExtra = extra;
                            SGIS.appDetailsExtraLoading = false;
                            if (SGIS.tab === 'overview') renderOverview();
                            // v2.3.17: appdetails 到手后, 若有 DLC 则异步获取 DLC 名称
                            if (extra && extra.dlc && extra.dlc.length && !SGIS.dlcNames && !SGIS.dlcNamesLoading) {
                                SGIS.dlcNamesLoading = true;
                                fetchDlcNames(extra.dlc).then(names => {
                                    SGIS.dlcNames = names;
                                    SGIS.dlcNamesLoading = false;
                                    if (SGIS.tab === 'overview') renderOverview();
                                }).catch(() => { SGIS.dlcNamesLoading = false; });
                            }
                        }).catch(() => { SGIS.appDetailsExtraLoading = false; });
                    } else if (SGIS.appDetailsExtra && SGIS.appDetailsExtra.dlc && SGIS.appDetailsExtra.dlc.length && !SGIS.dlcNames && !SGIS.dlcNamesLoading) {
                        // v2.3.17: appdetails 已缓存但 DLC 名称未获取
                        SGIS.dlcNamesLoading = true;
                        fetchDlcNames(SGIS.appDetailsExtra.dlc).then(names => {
                            SGIS.dlcNames = names;
                            SGIS.dlcNamesLoading = false;
                            if (SGIS.tab === 'overview') renderOverview();
                        }).catch(() => { SGIS.dlcNamesLoading = false; });
                    }
                    // v2.9.11: 异步获取 gamestatus.info 破解状态（独立于 appDetailsExtra）
                    if (!SGIS.gameStatusInfo && !SGIS.gameStatusLoading) {
                        SGIS.gameStatusLoading = true;
                        const gsName = (SGIS.overview && SGIS.overview.name) || '';
                        fetchGameStatus(APP_ID, gsName).then(() => {
                            SGIS.gameStatusLoading = false;
                            if (SGIS.tab === 'overview') renderOverview();
                        }).catch(() => { SGIS.gameStatusLoading = false; });
                    }
                    // v2.9.93: 资料受限状态检测 (DOM 直接检测,首次渲染时已在 renderProfileStatusBadge 中调用)
                    // 延迟 1.5s 后重检,以防 Steam React SSR 延迟渲染 learning_about 元素
                    if (HAS_APP_ID && !SGIS._profileFeaturesDelayedCheck) {
                        SGIS._profileFeaturesDelayedCheck = true;
                        setTimeout(() => {
                            SGIS._profileFeaturesDelayedCheck = false;
                            // 重新检测 (清除缓存让 detectProfileFeaturesStatus 重新读取 DOM)
                            const prev = SGIS.profileFeaturesStatus;
                            SGIS.profileFeaturesStatus = null;
                            const latest = detectProfileFeaturesStatus();
                            // 仅在状态变化时重渲染 (避免无谓刷新)
                            if (prev && latest && prev.status !== latest.status && SGIS.tab === 'overview') {
                                renderOverview();
                            }
                        }, 1500);
                    }
                },
            },
            medals: { render: () => renderMedals() },
            prices: { render: () => renderPrices() },
            reviews: { render: () => renderReviews() },
            achievements: { render: () => renderAchievements() },
            dynamics: { render: () => renderDynamics() },
            // profile Tab 渲染器签名特殊(renderProfile({ force }))，由 renderTab 内 force 透传分支直接调用
            profile: { render: () => {} },
            activity: { render: () => renderActivity() },
            userBadges: { render: () => renderUserBadges() },
            social: { render: () => renderSocial() },
            userAchievements: { render: () => renderUserAchievements() },
        };

        // v2.11.6 (FEAT-011 TASK-007): Tab 缓存重置单一数据源——原两张平行手工同步表
        // (renderError 重试清理 if-else 链 + renderTab force 清理内联段)合并为 TAB_CACHE_RESET 表驱动。
        // 对照矩阵(2026-08-18 摘录实测,键序=Tab 按钮定义顺序):
        //   both  = 重试与 force 共同重置字段
        //   retry = 仅 renderError 重试路径重置(失败 Tab 局部清理)
        //   force = 仅 renderTab force 路径重置(显式强制刷新完整清理)
        // 差异项: overview(retry 独有 currentPlayers/reviewSummary,force 独有 similarGames/dynamicStoreChecked)
        //         dynamics(force 独有 aiSummaryLoading/aiSummaryError)
        //         social(retry 独有 friendsLevels)
        // 值语义: null/false/'all' 为字面量;Set/对象存工厂函数,每次重置产出全新实例
        // (reviewsFilter/reviewsExpanded 若共享同一引用会跨次泄漏过滤状态,工厂必须保持)
        const TAB_CACHE_RESET = {
            overview: {
                both: { overview: null, familyShareSupported: null, appDetailsExtra: null, dlcNames: null, drmInfo: null, priceChartRange: 'all', gameStatusInfo: null, profileFeaturesStatus: null },
                retry: { currentPlayers: null, reviewSummary: null },
                force: { similarGames: null, dynamicStoreChecked: false },
            },
            medals: { both: { cards: null } },
            prices: { both: { prices: null, historyPrices: null, prediction: null, predictionError: null, giftRec: null, priceChartRange: 'all' } },
            reviews: { both: { reviews: null, reviewsExpanded: () => new Set(), reviewsFilter: () => ({ rec: 'all', playtime: 'all', language: 'all', purchase: 'all', keyword: '', regexMode: false }) } },
            achievements: { both: { achievements: null, globalAchievements: null } },
            dynamics: { both: { dynamics: null, aiSummary: null }, force: { aiSummaryLoading: false, aiSummaryError: null } },
            profile: { both: { profile: null, profileError: null } },
            activity: { both: { activity: null, personalTimeline: null, familyTimeline: null } },
            userBadges: { both: { userBadges: null } },
            social: { both: { friendsList: null, friendsListError: null }, retry: { friendsLevels: null } },
            userAchievements: { both: { userAchievements: null, aiPersona: null, aiPersonaError: null, insightData: null, aiInsight: null, aiInsightError: null, aiMarketInsight: null, aiMarketInsightError: null } },
        };

        function _applyTabReset(map) {
            for (const k in map) {
                const v = map[k];
                SGIS[k] = (typeof v === 'function') ? v() : v;
            }
        }

        // scope='retry': renderError 重试(失败 Tab 局部清理)
        // scope='force': renderTab 强制刷新(完整清理)
        // 未登记 tab 安全跳过(与原 default 分支一致)
        function resetTabCache(tab, scope) {
            const spec = TAB_CACHE_RESET[tab];
            if (!spec) return;
            _applyTabReset(spec.both);
            _applyTabReset(scope === 'force' ? spec.force : spec.retry);
        }

        function renderTab(tab, force) {
            try {
                // v2.11.24 (FEAT-014 TASK-001): 表驱动分发;overview 副作用 fetch 外提至 prepareTabData
                if (force) resetTabCache(tab, 'force');
                const spec = SGIS_TAB_RENDERERS[tab];
                if (!spec) {
                    console.warn('[SGIS] 未知标签页:', tab);
                    return;
                }
                // profile Tab 需透传 force 入参到 renderProfile(opts);其他 Tab 无签名差异
                if (tab === 'profile') {
                    renderProfile({ force: !!force });
                } else {
                    spec.render();
                }
                // 数据准备步骤（fetch 外提），overview 等带 prepare 的 Tab 在渲染后追加准备逻辑
                if (spec.prepare) spec.prepare();
            } catch (e) {
                console.error('[SGIS] renderTab error:', e);
                renderError('渲染失败: ' + e.message);
            }
        }

        // v2.3.11: 监听 Activity 瀑布流浮窗，浮窗打开时关闭并隐藏个人信息面板
        function watchActivityOverlay() {
            const overlay = document.getElementById('sf-wf-overlay');
            if (!overlay) {
                const mo = new MutationObserver((_, obs) => {
                    if (document.getElementById('sf-wf-overlay')) {
                        obs.disconnect();
                        watchActivityOverlay();
                    }
                });
                mo.observe(document.body, { childList: true });
                addDisposer(() => mo.disconnect());
                return;
            }
            const handle = () => {
                if (overlay.classList.contains('sf-wf-open') && SGIS.open) closePanel();
            };
            handle();
            const mo = new MutationObserver(handle);
            mo.observe(overlay, { attributes: true, attributeFilter: ['class'] });
            addDisposer(() => mo.disconnect());
        }

        // ---- 初始化 ----
        function initSidebar() {
            ensureFab();
            ensurePanel();
            // 后台预加载汇率
            refreshRates().catch(() => { /* ignore */ });
            // 监听游戏库数据更新事件, 侧边栏打开时自动重新渲染
            document.addEventListener('sglv:games-updated', () => {
                if (SGIS.open) renderTab(SGIS.tab, true);
            });
            // v2.11.40: 主题热切换——侧边栏打开时重渲染当前 Tab（SVG 图表/内联色随新主题色板再生）
            window.addEventListener('sglv-theme-changed', () => {
                if (SGIS.open) renderTab(SGIS.tab, true);
            });
            watchActivityOverlay();
            console.log('%c[Steam 个人信息面板 v2.8.0] UI 初始化完成 · AppID:', `color:${SGLVCharts.accent()};font-weight:bold`, APP_ID || '(首页模式)');
        }
        // ==================== v2.8.0: 评测标签页 ====================

        // 评测分数描述映射 (review_score → 中文 + 图标 + 渐变色档)
        const REVIEW_SCORE_MAP = {
            9: { desc: '好评如潮', icon: '🎉', cls: 'overwhelmingly-positive' },
            8: { desc: '特别好评', icon: '👍', cls: 'very-positive' },
            7: { desc: '多半好评', icon: '✅', cls: 'mostly-positive' },
            6: { desc: '好评', icon: '🙂', cls: 'positive' },
            5: { desc: '褒贬不一', icon: '⚖️', cls: 'mixed' },
            4: { desc: '差评', icon: '😕', cls: 'negative' },
            3: { desc: '多半差评', icon: '❌', cls: 'mostly-negative' },
            2: { desc: '特别差评', icon: '👎', cls: 'very-negative' },
            1: { desc: '差评如潮', icon: '💢', cls: 'overwhelmingly-negative' },
        };
        // v2.9.15: cls → 渐变档(pos/mix/neg),用于大字 + 进度条配色
        const SCORE_CLS_TO_TIER = {
            'overwhelmingly-positive': 'pos', 'very-positive': 'pos', 'mostly-positive': 'pos', 'positive': 'pos',
            'mixed': 'mix',
            'overwhelmingly-negative': 'neg', 'very-negative': 'neg', 'mostly-negative': 'neg', 'negative': 'neg',
        };

        // 获取评测数据：摘要 + 详细评测
        // API: store.steampowered.com/appreviews/{appid}?json=1&filter=summary&language=schinese&purchase_type=all
        // API: store.steampowered.com/appreviews/{appid}?json=1&filter=all&language=schinese&num_per_page=20
        async function fetchReviews(appId) {
            const cacheKey = 'reviews_' + appId;
            const cached = cacheGet(cacheKey);
            if (cached) return cached;

            // 并行请求摘要和详细评测
            const summaryUrl = `https://store.steampowered.com/appreviews/${appId}?json=1&filter=summary&language=schinese&purchase_type=all&day_range=999999`;
            const detailUrl = `https://store.steampowered.com/appreviews/${appId}?json=1&filter=all&language=schinese&purchase_type=all&num_per_page=20`;

            const [summaryRes, detailRes] = await Promise.all([
                fetchJson(summaryUrl, { timeout: 12000 }).catch(() => null),
                fetchJson(detailUrl, { timeout: 12000 }).catch(() => null),
            ]);

            // 摘要数据 (全部时间)
            const allTimeSummary = summaryRes?.query_summary || {};
            // 详细评测数据 (含最近30天摘要)
            const recentSummary = detailRes?.query_summary || {};
            // v2.9.15: 修复 authorName bug——原代码三目两边都是 'Steam用户' (typo)
            //          优先用 author.personaname (Steam 实际昵称),匿名则降级
            const reviews = (detailRes?.reviews || []).map(r => {
                const a = r.author || {};
                const realName = (a.personaname || '').trim();
                return {
                    id: r.recommendationid || '',
                    steamid: a.steamid || '',
                    authorName: realName || 'Steam 用户',
                    profileUrl: a.profileurl || '',
                    avatar: a.avatar || '',
                    avatarMedium: a.avatar_medium || a.avatar || '',
                    avatarFull: a.avatar_full || a.avatar || '',
                    playtimeForever: a.playtime_forever || 0, // 分钟
                    playtimeAtReview: a.playtime_at_review || 0,
                    numGamesOwned: a.num_games_owned || 0,
                    numReviews: a.num_reviews || 0,
                    language: r.language || '',
                    review: r.review || '',
                    timestampCreated: r.timestamp_created || 0,
                    timestampUpdated: r.timestamp_updated || 0,
                    votedUp: !!r.voted_up,
                    votesUp: r.votes_up || 0,
                    votesFunny: r.votes_funny || 0,
                    weightedVoteScore: r.weighted_vote_score || '0',
                    commentCount: r.comment_count || 0,
                    steamPurchase: !!r.steam_purchase,
                    receivedForFree: !!r.received_for_free,
                    writtenDuringEarlyAccess: !!r.written_during_early_access,
                };
            });

            const result = {
                // 全部时间摘要
                allTime: {
                    totalReviews: allTimeSummary.total_reviews || 0,
                    totalPositive: allTimeSummary.total_positive || 0,
                    totalNegative: allTimeSummary.total_negative || 0,
                    reviewScore: allTimeSummary.review_score || 0,
                    reviewScoreDesc: allTimeSummary.review_score_desc || '无数据',
                },
                // 最近30天摘要 (来自详细评测请求的 query_summary)
                recent: {
                    numReviews: recentSummary.num_reviews || 0,
                    totalPositive: recentSummary.total_positive || 0,
                    totalNegative: recentSummary.total_negative || 0,
                    totalReviews: recentSummary.total_reviews || 0,
                    reviewScore: recentSummary.review_score || 0,
                    reviewScoreDesc: recentSummary.review_score_desc || '',
                },
                reviews: reviews,
                fetchedAt: Date.now(),
            };
            // v2.9.15: 单一缓存入口(之前双写 cacheSet + GM_setValue 是冗余)
            cacheSet(cacheKey, result, CACHE_TTL.reviews);
            return result;
        }

        // 评测标签页渲染入口
        function renderReviews() {
            if (SGIS.reviewsLoading) return;
            if (SGIS.reviews) {
                renderReviewsContent(SGIS.reviews);
                return;
            }
            SGIS.reviewsLoading = true;
            renderLoading('正在获取评测数据…');
            fetchReviews(APP_ID)
                .then(data => {
                    SGIS.reviews = data;
                    renderReviewsContent(data);
                })
                .catch(e => renderError('评测获取失败: ' + e.message))
                .finally(() => { SGIS.reviewsLoading = false; });
        }

        // 渲染评测内容（摘要 + 筛选 + 列表）
        function _prepareReviewData(data, filter) {
            const num = (v) => { const n = Number(v); return isNaN(n) ? 0 : n; };
            const fmt = (v) => num(v).toLocaleString('zh-CN');
            const pct = (a, b) => b > 0 ? ((a / b) * 100).toFixed(1) : '0.0';

            const allTime = data.allTime;
            const recent = data.recent;
            const scoreInfo = REVIEW_SCORE_MAP[allTime.reviewScore] || { desc: allTime.reviewScoreDesc, icon: '❓', cls: 'unknown' };
            const scoreTier = SCORE_CLS_TO_TIER[scoreInfo.cls] || 'mix';
            const positiveRate = pct(allTime.totalPositive, allTime.totalReviews);
            const positiveBarWidth = positiveRate;

            const recentPositiveRate = recent.totalReviews > 0 ? pct(recent.totalPositive, recent.totalReviews) : null;
            let trendHtml = '';
            if (recentPositiveRate != null && allTime.totalReviews > 0) {
                const diff = (Number(recentPositiveRate) - Number(positiveRate)).toFixed(1);
                const trendIcon = Number(diff) > 0 ? '📈' : (Number(diff) < 0 ? '📉' : '➡️');
                const trendColor = Number(diff) > 0 ? '#4bb54f' : (Number(diff) < 0 ? '#e63946' : 'var(--sgis-text-2)');
                trendHtml = `<div class="sgis-review-trend">
                    <div class="sgis-review-trend-item">
                        <span class="sgis-review-trend-label">最近30天</span>
                        <span class="sgis-review-trend-val">${recentPositiveRate}% (${fmt(recent.totalReviews)}条)</span>
                    </div>
                    <div class="sgis-review-trend-item">
                        <span class="sgis-review-trend-label">全部时间</span>
                        <span class="sgis-review-trend-val">${positiveRate}% (${fmt(allTime.totalReviews)}条)</span>
                    </div>
                    <div class="sgis-review-trend-item">
                        <span class="sgis-review-trend-label">趋势</span>
                        <span class="sgis-review-trend-val" style="color:${trendColor}">${trendIcon} ${diff > 0 ? '+' : ''}${diff}%</span>
                    </div>
                </div>`;
            }

            const filterBtn = (group, value, label) => {
                const active = filter[group] === value ? 'active' : '';
                return `<button class="sgis-review-filter-btn ${active}" data-filter-group="${group}" data-filter-value="${value}">${label}</button>`;
            };

            const filteredReviews = applyReviewFilters(data.reviews, filter);
            const reviewsHtml = filteredReviews.length
                ? filteredReviews.map(r => renderReviewItem(r)).join('')
                : '<div class="sgis-review-empty"><div class="sgis-review-empty-icon"><svg class="sgis-svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><circle cx="11" cy="11" r="7"/><line x1="21" y1="21" x2="16.5" y2="16.5"/></svg></div><div style="font-weight:600">无符合条件的评测</div><div style="font-size:10px;color:var(--sgis-text-3)">尝试调整筛选条件或更换关键词</div></div>';

            return {
                num, fmt, pct,
                allTime, recent, scoreInfo, scoreTier,
                positiveRate, positiveBarWidth, trendHtml,
                filterBtn, filteredReviews, reviewsHtml,
            };
        }

        function _renderReviewSummary(d) {
            return `<div class="sgis-section">
                    <div class="sgis-section-title">${SGIS_ICONS.review} 评测摘要</div>
                    <div class="sgis-review-summary">
                        <div class="sgis-review-summary-head">
                            <div class="sgis-review-score">
                                <span class="sgis-review-score-icon">${d.scoreInfo.icon}</span>
                                <div class="sgis-review-score-meta">
                                    <div class="sgis-review-score-text">${d.scoreInfo.desc}</div>
                                    <div class="sgis-review-score-desc">${d.fmt(d.allTime.totalReviews)} 条评测 · 来自 Steam 用户</div>
                                </div>
                            </div>
                            <div class="sgis-review-pct-big ${d.scoreTier}">${d.positiveRate}%</div>
                        </div>
                        <div class="sgis-review-bar">
                            <div class="sgis-review-bar-positive ${d.scoreTier}" style="width:${d.positiveBarWidth}%"></div>
                        </div>
                        <div class="sgis-review-counts">
                            <span class="pos">👍 ${d.fmt(d.allTime.totalPositive)} 好评</span>
                            <span class="neg">👎 ${d.fmt(d.allTime.totalNegative)} 差评</span>
                        </div>
                        ${d.trendHtml}
                    </div>
                </div>`;
        }

        function _renderReviewFilters(d, filter) {
            return `<div class="sgis-section">
                    <div class="sgis-section-title">${SGIS_ICONS.target} 多维筛选</div>
                    <div class="sgis-review-search-wrap">
                        <input type="text" class="sgis-review-search-input" id="sgis-review-search"
                            placeholder="搜索评测内容（支持正则）"
                            value="${(filter.keyword || '').replace(/"/g, '&quot;')}">
                        <button class="sgis-review-regex-toggle ${filter.regexMode ? 'active' : ''}" id="sgis-review-regex-toggle" title="切换正则表达式模式">.*</button>
                        ${filter.keyword ? '<button class="sgis-review-search-clear" id="sgis-review-search-clear" title="清空">×</button>' : ''}
                    </div>
                    <div class="sgis-review-filters">
                        <div class="sgis-review-filter-group">
                            <span class="sgis-review-filter-label">推荐:</span>
                            ${d.filterBtn('rec', 'all', '全部')}
                            ${d.filterBtn('rec', 'yes', '好评')}
                            ${d.filterBtn('rec', 'no', '差评')}
                        </div>
                        <div class="sgis-review-filter-group">
                            <span class="sgis-review-filter-label">时长:</span>
                            ${d.filterBtn('playtime', 'all', '全部')}
                            ${d.filterBtn('playtime', 'lt1', '<1h')}
                            ${d.filterBtn('playtime', '1to10', '1-10h')}
                            ${d.filterBtn('playtime', '10to50', '10-50h')}
                            ${d.filterBtn('playtime', 'gt50', '50h+')}
                        </div>
                        <div class="sgis-review-filter-group">
                            <span class="sgis-review-filter-label">语言:</span>
                            ${d.filterBtn('language', 'all', '全部')}
                            ${d.filterBtn('language', 'schinese', '中文')}
                            ${d.filterBtn('language', 'english', '英文')}
                        </div>
                        <div class="sgis-review-filter-group">
                            <span class="sgis-review-filter-label">获取:</span>
                            ${d.filterBtn('purchase', 'all', '全部')}
                            ${d.filterBtn('purchase', 'steam', '购买')}
                            ${d.filterBtn('purchase', 'free', '免费')}
                            ${d.filterBtn('purchase', 'key', 'Key')}
                        </div>
                    </div>
                    <div class="sgis-review-count-summary" data-count-summary>
                        <span class="sgis-review-count-icon">${SGIS_ICONS.review}</span>
                        <span>显示 <b>${d.filteredReviews.length}</b> / ${d.data ? d.data.reviews.length : 0} 条评测</span>
                        ${d.filteredReviews.length !== (d.data ? d.data.reviews.length : 0) ? '<span class="sgis-review-count-filtered">已筛选</span>' : ''}
                    </div>
                </div>`;
        }

        function _renderReviewList(d) {
            return `<div class="sgis-section">
                    <div class="sgis-section-title">${SGIS_ICONS.review} 评测列表</div>
                    <div class="sgis-review-list" id="sgis-review-list">
                        ${d.reviewsHtml}
                    </div>
                </div>`;
        }

        function _renderReviewEmptyState() {
            return `<div class="sgis-state">
                <div class="sgis-state-icon"><svg class="sgis-svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z"/><path d="M8 9h8M8 13h5"/></svg></div>
                <div style="font-weight:600">暂无评测数据</div>
                <div style="font-size:11px;color:var(--sgis-text-3);margin-top:2px">该游戏可能没有中文评测,或 Steam API 暂未返回</div>
            </div>`;
        }

        function renderReviewsContent(data) {
            if (!data || (!data.allTime.totalReviews && !data.reviews.length)) {
                setBody(_renderReviewEmptyState());
                return;
            }
            const filter = SGIS.reviewsFilter;
            const d = _prepareReviewData(data, filter);
            d.data = data; // 让段渲染器可访问 reviews 总数
            setBody(_renderReviewSummary(d) + _renderReviewFilters(d, filter) + _renderReviewList(d));
            bindReviewFilterEvents(data);
            bindReviewExpandEvents();
        }

        // 渲染单条评测
        function _prepareReviewItemData(r) {
            const num = (v) => { const n = Number(v); return isNaN(n) ? 0 : n; };
            const playtimeHours = r.playtimeForever > 0 ? (r.playtimeForever / 60).toFixed(1) : '0';
            const recCls = r.votedUp ? 'sgis-review-rec-yes' : 'sgis-review-rec-no';
            const recText = r.votedUp ? '推荐' : '不推荐';
            const dateStr = r.timestampCreated > 0 ? formatRelativeDate(r.timestampCreated) : '—';
            const dateAbs = r.timestampCreated > 0 ? new Date(r.timestampCreated * 1000).toLocaleDateString('zh-CN') : '';
            let purchaseType = '';
            if (r.receivedForFree) purchaseType = '免费获取';
            else if (r.steamPurchase) purchaseType = 'Steam 购买';
            else purchaseType = 'Key 激活';
            const langMap = { schinese: '中文', tchinese: '繁中', english: '英文', japanese: '日文' };
            const langText = langMap[r.language] || r.language || '—';
            const avatarSrc = r.avatarMedium || r.avatar || '';
            const initial = (r.authorName || '?').trim().charAt(0).toUpperCase();
            const esc = escHtml;
            const escReview = esc(r.review).replace(/\n/g, '<br>');
            const isExpanded = SGIS.reviewsExpanded.has(r.id);
            const reviewLen = (r.review || '').length;
            const isLong = reviewLen > 200;
            return {
                r, num, playtimeHours, recCls, recText, dateStr, dateAbs,
                purchaseType, langText, avatarSrc, initial, esc, escReview,
                isExpanded, reviewLen, isLong,
            };
        }

        function _renderReviewItemHeader(d) {
            const avatarHtml = d.avatarSrc
                ? `<a class="sgis-review-avatar-link" href="${d.r.profileUrl || '#'}" target="_blank" rel="noopener"><img class="sgis-review-avatar" src="${d.avatarSrc}" width="32" height="32" alt="" loading="lazy" onerror="this.replaceWith(Object.assign(document.createElement('div'),{className:'sgis-review-avatar sgis-review-avatar-fallback',textContent:'${d.initial}'}))"></a>`
                : `<div class="sgis-review-avatar sgis-review-avatar-fallback">${d.initial}</div>`;
            const authorHtml = d.r.profileUrl
                ? `<a class="sgis-review-author" href="${d.r.profileUrl}" target="_blank" rel="noopener" title="查看 Steam 个人主页">${d.r.authorName}</a>`
                : `<span class="sgis-review-author">${d.r.authorName}</span>`;
            return `<div class="sgis-review-item-header">
                    ${avatarHtml}
                    <div class="sgis-review-author-wrap">
                        ${authorHtml}
                        <span class="sgis-review-date" title="${d.esc(d.dateAbs)}">${d.esc(d.dateStr)}</span>
                    </div>
                    <span class="sgis-review-rec ${d.recCls}">${d.recText}</span>
                </div>`;
        }

        function _renderReviewItemMeta(d) {
            return `<div class="sgis-review-meta">
                    <span class="sgis-review-meta-item" title="总游戏时长">⏱ ${d.playtimeHours}h</span>
                    <span class="sgis-review-meta-item" title="购买方式">📦 ${d.purchaseType}</span>
                    <span class="sgis-review-meta-item" title="评测语言">🌐 ${d.esc(d.langText)}</span>
                    ${d.r.numGamesOwned ? `<span class="sgis-review-meta-item" title="已拥有游戏数">🎮 ${d.r.numGamesOwned} 款</span>` : ''}
                </div>`;
        }

        function _renderReviewItemText(d) {
            return `<div class="sgis-review-text ${d.isExpanded ? 'expanded' : ''}" data-review-id="${d.esc(d.r.id)}">${d.escReview}</div>`;
        }

        function _renderReviewItemActions(d) {
            return `<div class="sgis-review-actions">
                    ${d.isLong ? `<button class="sgis-review-action-btn sgis-review-expand-btn ${d.isExpanded ? 'is-expanded' : ''}" data-review-id="${d.esc(d.r.id)}" title="${d.isExpanded ? '收起' : '展开完整评测'}">
                        <svg class="sgis-svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="6 9 12 15 18 9"/></svg>
                        <span>${d.isExpanded ? '收起' : '展开'}</span>
                    </button>` : ''}
                    <button class="sgis-review-action-btn sgis-review-copy-btn" data-review-id="${d.esc(d.r.id)}" title="复制原文到剪贴板">
                        <svg class="sgis-svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><rect x="9" y="9" width="13" height="13" rx="2"/><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"/></svg>
                        <span>复制</span>
                    </button>
                </div>`;
        }

        function _renderReviewItemVotes(d) {
            return `<div class="sgis-review-votes">
                    <span title="觉得这条评测有用的人数">👍 ${d.num(d.r.votesUp)}</span>
                    <span title="觉得这条评测欢乐的人数">😄 ${d.num(d.r.votesFunny)}</span>
                    ${d.r.commentCount > 0 ? `<span title="评论数">💬 ${d.num(d.r.commentCount)}</span>` : ''}
                </div>`;
        }

        function renderReviewItem(r) {
            const d = _prepareReviewItemData(r);
            return `<div class="sgis-review-item ${r.votedUp ? 'is-positive' : 'is-negative'}" data-review-id="${d.esc(r.id)}">
                ${_renderReviewItemHeader(d)}
                ${_renderReviewItemMeta(d)}
                ${_renderReviewItemText(d)}
                ${_renderReviewItemActions(d)}
                ${_renderReviewItemVotes(d)}
            </div>`;
        }

        // 筛选评测列表
        function applyReviewFilters(reviews, filter) {
            // v2.9.9: 预编译正则表达式 (参考 Steam_Buff review-filter-core.js)
            let compiledRegex = null;
            if (filter.keyword && filter.regexMode) {
                try { compiledRegex = new RegExp(filter.keyword, 'i'); }
                catch { compiledRegex = null; }
            }
            return reviews.filter(r => {
                // 推荐状态
                if (filter.rec === 'yes' && !r.votedUp) return false;
                if (filter.rec === 'no' && r.votedUp) return false;
                // 游戏时长（分钟）
                const minutes = r.playtimeForever;
                if (filter.playtime === 'lt1' && minutes >= 60) return false;
                if (filter.playtime === '1to10' && (minutes < 60 || minutes >= 600)) return false;
                if (filter.playtime === '10to50' && (minutes < 600 || minutes >= 3000)) return false;
                if (filter.playtime === 'gt50' && minutes < 3000) return false;
                // 语言
                if (filter.language === 'schinese' && !r.language.startsWith('schinese')) return false;
                if (filter.language === 'english' && !r.language.startsWith('english')) return false;
                // 获取方式
                if (filter.purchase === 'steam' && !r.steamPurchase) return false;
                if (filter.purchase === 'free' && !r.receivedForFree) return false;
                if (filter.purchase === 'key' && (r.steamPurchase || r.receivedForFree)) return false;
                // v2.9.9: 关键词/正则搜索
                if (filter.keyword && filter.keyword.trim()) {
                    const text = r.review || '';
                    if (filter.regexMode) {
                        if (!compiledRegex || !compiledRegex.test(text)) return false;
                    } else {
                        if (!text.toLowerCase().includes(filter.keyword.toLowerCase())) return false;
                    }
                }
                return true;
            });
        }

        // v2.11.29 (FEAT-014 TASK-005): onChange 适配层 — 统一 4 类源(筛选按钮/搜索/正则切换/清空)
        // 走 onChange({type, value}) 回调, 与 buildListToolbar 的事件分发语义对齐。
        // 事件 handler 不再直接 rerender, 而是经 _handleReviewOnChange 适配。
        function _handleReviewOnChange(type, value, btn) {
            if (type === 'filter') {
                SGIS.reviewsFilter[value.group] = value.value;
                document.querySelectorAll(`.sgis-review-filter-btn[data-filter-group="${value.group}"]`).forEach(b => b.classList.remove('active'));
                if (btn) btn.classList.add('active');
            } else if (type === 'search') {
                SGIS.reviewsFilter.keyword = value;
            } else if (type === 'regex') {
                SGIS.reviewsFilter.regexMode = value;
                const toggle = document.getElementById('sgis-review-regex-toggle');
                if (toggle) toggle.classList.toggle('active', value);
            } else if (type === 'clear') {
                const input = document.getElementById('sgis-review-search');
                if (input) input.value = '';
                SGIS.reviewsFilter.keyword = '';
                if (input) input.focus();
            }
        }

        // 绑定筛选按钮事件
        function bindReviewFilterEvents(data) {
            // v2.9.9: 抽取重渲染逻辑, 供筛选按钮和搜索共用
            const rerenderReviews = () => {
                const filteredReviews = applyReviewFilters(data.reviews, SGIS.reviewsFilter);
                const listEl = document.getElementById('sgis-review-list');
                if (listEl) {
                    listEl.innerHTML = filteredReviews.length
                        ? filteredReviews.map(r => renderReviewItem(r)).join('')
                        : '<div class="sgis-review-empty"><div class="sgis-review-empty-icon"><svg class="sgis-svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><circle cx="11" cy="11" r="7"/><line x1="21" y1="21" x2="16.5" y2="16.5"/></svg></div><div style="font-weight:600">无符合条件的评测</div><div style="font-size:10px;color:var(--sgis-text-3)">尝试调整筛选条件或更换关键词</div></div>';
                    bindReviewExpandEvents();
                }
                const countSummary = document.querySelector('[data-count-summary]');
                if (countSummary) {
                    countSummary.innerHTML = `
                        <span class="sgis-review-count-icon">${SGIS_ICONS.review}</span>
                        <span>显示 <b>${filteredReviews.length}</b> / ${data.reviews.length} 条评测</span>
                        ${filteredReviews.length !== data.reviews.length ? '<span class="sgis-review-count-filtered">已筛选</span>' : ''}`;
                }
            };
            // v2.11.29: onChange 适配 — 4 类源统一经 _handleReviewOnChange 触发 rerender
            const onChange = (type, value, btn) => {
                _handleReviewOnChange(type, value, btn);
                rerenderReviews();
            };

            document.querySelectorAll('.sgis-review-filter-btn').forEach(btn => {
                btn.addEventListener('click', () => {
                    onChange('filter', { group: btn.dataset.filterGroup, value: btn.dataset.filterValue }, btn);
                });
            });

            // v2.9.9: 关键词搜索 (防抖 300ms, 参考 Steam_Buff search-suggestions.js)
            const searchInput = document.getElementById('sgis-review-search');
            if (searchInput) {
                let searchTimer = null;
                searchInput.addEventListener('input', () => {
                    clearTimeout(searchTimer);
                    searchTimer = setTimeout(() => onChange('search', searchInput.value), 300);
                });
            }

            // v2.9.9: 正则模式切换
            const regexToggle = document.getElementById('sgis-review-regex-toggle');
            if (regexToggle) {
                regexToggle.addEventListener('click', () => {
                    onChange('regex', !SGIS.reviewsFilter.regexMode);
                });
            }

            // v2.9.15: 清空搜索按钮(只在该按钮存在时绑定)
            const clearBtn = document.getElementById('sgis-review-search-clear');
            if (clearBtn && searchInput) {
                clearBtn.addEventListener('click', () => onChange('clear', null));
            }
        }

        // 绑定评测文本展开/收起事件
        function bindReviewExpandEvents() {
            // v2.9.15: 展开/收起改由按钮触发(避免点击全行歧义),文本点击只切换(保留旧行为兼容)
            document.querySelectorAll('.sgis-review-text').forEach(el => {
                el.addEventListener('click', (e) => {
                    // 点按钮/链接时不展开(让按钮自身处理)
                    if (e.target.closest('.sgis-review-action-btn, a, button')) return;
                    const id = el.dataset.reviewId;
                    toggleReviewExpand(id);
                });
            });
            // 展开/收起按钮
            document.querySelectorAll('.sgis-review-expand-btn').forEach(btn => {
                btn.addEventListener('click', (e) => {
                    e.stopPropagation();
                    toggleReviewExpand(btn.dataset.reviewId);
                    const isExpanded = btn.classList.contains('is-expanded');
                    btn.classList.toggle('is-expanded', !isExpanded);
                    btn.querySelector('span').textContent = !isExpanded ? '收起' : '展开';
                });
            });
            // 复制按钮
            document.querySelectorAll('.sgis-review-copy-btn').forEach(btn => {
                btn.addEventListener('click', async (e) => {
                    e.stopPropagation();
                    const id = btn.dataset.reviewId;
                    const review = (SGIS.reviews?.reviews || []).find(x => String(x.id) === String(id));
                    if (!review || !review.review) return;
                    const ok = await copyTextToClipboard(review.review);
                    btn.classList.add('copied');
                    const label = btn.querySelector('span');
                    const origText = label.textContent;
                    label.textContent = ok ? '已复制' : '失败';
                    setTimeout(() => { btn.classList.remove('copied'); label.textContent = origText; }, 1500);
                });
            });
        }

        function toggleReviewExpand(id) {
            const textEl = document.querySelector(`.sgis-review-text[data-review-id="${id}"]`);
            if (!textEl) return;
            if (SGIS.reviewsExpanded.has(id)) {
                SGIS.reviewsExpanded.delete(id);
                textEl.classList.remove('expanded');
            } else {
                SGIS.reviewsExpanded.add(id);
                textEl.classList.add('expanded');
            }
        }

        // ==================== v2.8.0: 跨区送礼推荐 ====================

        // Steam 跨区送礼限制区域（不能向其他区域送礼的区域）
        // 参考 steam-gift-checker: 俄罗斯/CIS 区域有送礼限制
        const GIFT_RESTRICTED_REGIONS = new Set(['RU']); // 俄罗斯不能向其他区域送礼

        // Steam 跨区送礼价格差异阈值（参考 steam-gift-checker: Math.abs(percentage) <= 15）
        const GIFT_PRICE_DIFF_THRESHOLD = 15;

        // 计算跨区送礼推荐方案
        // 核心逻辑（参考 steam-gift-checker/content.js 的 calculatePriceDifference）:
        //   percentage = (recipientCny - senderCny) / senderCny * 100
        //   canGift = percentage > 0 && percentage <= 15 (送礼区更便宜且差价在15%以内)
        function calculateGiftRecommendation(pricesData) {
            if (!pricesData || !pricesData.prices || !pricesData.prices.length) return null;

            const num = (v) => { const n = Number(v); return isNaN(n) ? 0 : n; };
            const userRegion = (document.cookie.match(/steamCountry=(\w{2})/) || [])[1] || 'CN';

            // 找到收礼区（用户当前区域）的价格
            const recipientData = pricesData.prices.find(p => p.region === userRegion);
            if (!recipientData) {
                // 用户区域价格不在数据中，无法计算
                return { error: 'no-recipient', userRegion, message: '当前区域价格数据缺失，无法计算送礼推荐' };
            }

            // 计算 CNY 价格
            // v2.9.101: 桥接层统一折算（原三元式中 num(toCNY(null))→0 的路径现直接返回 null，下游 == null/<=0 判定等价）
            const recipientCny = convertToCNY(num(recipientData.price), recipientData.currency);
            if (recipientCny == null || recipientCny <= 0) {
                return { error: 'no-rate', userRegion, message: '汇率未就绪，无法换算送礼推荐' };
            }

            // 对每个可送礼区域计算差价
            const candidates = [];
            for (const p of pricesData.prices) {
                // 跳过收礼区自身
                if (p.region === userRegion) continue;
                // 跳过受限区域（不能向其他区域送礼）
                if (GIFT_RESTRICTED_REGIONS.has(p.region)) continue;

                const senderCny = convertToCNY(num(p.price), p.currency); // v2.9.101: 桥接层统一折算
                if (senderCny == null || senderCny <= 0) continue;

                // 只考虑送礼区价格低于收礼区的情况（礼物只能从低价区送往高价区）
                if (senderCny >= recipientCny) continue;

                // 计算差价和百分比（参考 gift-checker: percentage = (recipient - sender) / sender * 100）
                const savings = recipientCny - senderCny;
                const savingsPercent = (savings / senderCny) * 100;
                const withinRule = savingsPercent <= GIFT_PRICE_DIFF_THRESHOLD;

                const regionInfo = REGIONS.find(r => r.code === p.region) || { name: p.region, code: p.region };
                candidates.push({
                    region: p.region,
                    regionName: regionInfo.name,
                    senderCny: num(senderCny),
                    recipientCny: num(recipientCny),
                    savings: num(savings),
                    savingsPercent: num(savingsPercent),
                    withinRule: withinRule,
                    senderPrice: num(p.price),
                    senderCurrency: p.currency,
                    senderDiscount: num(p.discount),
                    canGift: withinRule, // 在15%规则内可以赠送
                });
            }

            if (!candidates.length) {
                return { error: 'no-candidates', userRegion, message: '没有找到可送礼的区域（所有区域价格均不低于本区或为受限区域）' };
            }

            // 排序：优先可赠送的（withinRule=true），然后按节约金额降序
            candidates.sort((a, b) => {
                if (a.withinRule !== b.withinRule) return a.withinRule ? -1 : 1;
                return b.savings - a.savings;
            });

            const best = candidates[0];
            const alternatives = candidates.slice(1, 4); // 备选方案最多3个

            return {
                best: best,
                alternatives: alternatives,
                userRegion: userRegion,
                userRegionName: (REGIONS.find(r => r.code === userRegion) || { name: userRegion }).name,
                recipientCny: num(recipientCny),
                allCandidates: candidates.length,
                timestamp: Date.now(),
            };
        }

        // 渲染送礼推荐卡片 HTML
        function renderGiftRecommendation(giftData) {
            if (!giftData || giftData.error) {
                const msg = giftData?.message || '无法计算跨区送礼推荐';
                return `<div class="sgis-gift-card">
                    <div class="sgis-gift-title">${SGIS_ICONS.gift} 跨区送礼推荐</div>
                    <div style="font-size:11px;color:var(--sgis-text-2);padding:6px 0">${msg}</div>
                </div>`;
            }
            const num = (v) => { const n = Number(v); return isNaN(n) ? 0 : n; };
            const fmt = (v) => num(v).toFixed(2);
            const best = giftData.best;
            const ruleText = best.withinRule
                ? '<span style="color:#4bb54f">✓ 符合Steam送礼规则（价差≤15%）</span>'
                : `<span style="color:#e6a839">⚠ 价差${best.savingsPercent.toFixed(1)}%超过15%限制，可能无法赠送</span>`;
            const altText = giftData.alternatives.length
                ? `<div class="sgis-gift-alt">其他备选: ${giftData.alternatives.map(a =>
                    `${a.regionName} (省¥${fmt(a.savings)}, ${a.withinRule ? '可送' : '超限'})`
                ).join(' · ')}</div>`
                : '';

            return `<div class="sgis-gift-card">
                <div class="sgis-gift-title">${SGIS_ICONS.gift} 跨区送礼推荐</div>
                <div class="sgis-gift-scheme">${best.regionName} → ${giftData.userRegionName} 赠送最划算</div>
                <div style="display:flex;align-items:baseline;gap:8px;margin:4px 0">
                    <span class="sgis-gift-save">¥${fmt(best.savings)}</span>
                    <span class="sgis-gift-pct">节约 ${best.savingsPercent.toFixed(1)}%</span>
                </div>
                <div class="sgis-gift-prices">
                    <div class="sgis-gift-price-item">
                        <span class="sgis-gift-price-label">送礼区(${best.regionName})</span>
                        <span class="sgis-gift-price-val">¥${fmt(best.senderCny)}${best.senderDiscount > 0 ? ` (-${best.senderDiscount}%)` : ''}</span>
                    </div>
                    <div class="sgis-gift-price-item">
                        <span class="sgis-gift-price-label">收礼区(${giftData.userRegionName})</span>
                        <span class="sgis-gift-price-val">¥${fmt(best.recipientCny)}</span>
                    </div>
                </div>
                <div class="sgis-gift-rule">${ruleText}</div>
                <div class="sgis-gift-warn">⚠ 注意事项：Steam跨区送礼政策可能随时调整，请确认当前政策。部分区域有送礼限制（如俄罗斯/CIS区域不能向其他区域送礼）。礼物只能从低价区送往高价区，且价格差异需在15%以内。</div>
                ${altText}
            </div>`;
        }

        // 将送礼推荐追加到价格标签页 body
        function appendGiftRecommendationToBody() {
            if (!SGIS.giftRec && !SGIS.prices) return;
            const bodyEl = document.getElementById('sgis-body');
            if (!bodyEl || SGIS.tab !== 'prices') return;
            // 如果还没计算过，基于已有价格数据计算
            if (!SGIS.giftRec && SGIS.prices) {
                SGIS.giftRec = calculateGiftRecommendation(SGIS.prices);
            }
            if (!SGIS.giftRec) return;
            // 移除旧的推荐卡片
            const oldCard = bodyEl.querySelector('.sgis-gift-card');
            if (oldCard) oldCard.remove();
            // 追加新卡片
            const temp = document.createElement('div');
            temp.innerHTML = renderGiftRecommendation(SGIS.giftRec);
            while (temp.firstChild) bodyEl.appendChild(temp.firstChild);
        }

        // ==================== v2.8.0: CheapShark 历史价格回退 ====================
        // 价格历史数据回退链：ITAD → CheapShark → AugmentedSteam
        async function fetchHistoryPricesCheapShark(appId, reason) {
            try {
                // CheapShark API: 按 steamAppID 查询
                const url = `https://api.cheapshark.com/api/1.0/games?id=${appId}`;
                const data = await fetchJson(url, { timeout: 10000 });
                if (!data || !data.deals || !data.deals.length) {
                    return await fetchHistoryPricesFallback(appId, reason + ' / CheapShark 无数据');
                }
                // 解析 deals 中的历史价格
                const history = data.deals.map(d => ({
                    price: Number(d.price) || 0,
                    regular: Number(d.retailPrice) || 0,
                    currency: 'USD',
                    cut: d.savings ? Math.round(Number(d.savings)) : 0,
                    store: d.storeName || '',
                    date: d.lastChange ? new Date(Number(d.lastChange) * 1000).toISOString() : '',
                })).filter(h => h.price > 0).sort((a, b) => new Date(b.date) - new Date(a.date)).slice(0, 20);

                // 找到史低
                let lowest = null;
                if (history.length) {
                    const minPrice = Math.min(...history.map(h => h.price));
                    lowest = history.find(h => h.price === minPrice);
                    if (lowest) lowest = { price: lowest.price, currency: 'USD', store: lowest.store, date: lowest.date, cut: lowest.cut };
                }

                const result = {
                    history,
                    discounts: history.filter(h => h.cut > 0).sort((a, b) => b.cut - a.cut),
                    lowest,
                    releaseDate: null,
                    source: 'cheapshark',
                    error: reason,
                };
                cacheSet('historyPrices_' + appId, result, CACHE_TTL.historyPrices);
                return result;
            } catch (e) {
                return await fetchHistoryPricesFallback(appId, reason + ' / CheapShark: ' + e.message);
            }
        }

        try { initSidebar(); } catch (e) { console.error('[SGIS] 侧边栏初始化失败，不影响游戏库功能:', e); }
    })();

    // ==================== 启动 ====================
    async function init() {
        // v2.11.40: 主题层——主题已在 storage 定义后同步应用（见 storage 之后的 boot 调用），此处仅输出主题化启动日志
        const _tId = getThemeId();
        const _tName = (SGLV_THEMES[_tId] && SGLV_THEMES[_tId][isZh ? 'zh' : 'en']) || _tId;
        console.log(`%c[Steam 游戏库展示] v${_v} 已启动 · ${_tName} · 设置→外观可切换主题`,
            `color:${_tId === 'blue' ? '#66c0f4' : '#a78bfa'};font-weight:bold;font-size:13px`);
        // v2.9.15: 启动时一次性把 IDB 缓存加载到内存（异步，非阻塞）
        try {
            await sglvIDB.loadAll();
            // 缓存 schema 版本检查：旧版本自动失效
            const upgraded = ensureCacheVersions();
            if (Object.keys(upgraded).length) {
                console.log('[SGLV] 缓存 schema 已升级:', upgraded);
                // 失效对应 cache（举例：bundle_db 升级时清空旧 GM v2 缓存）
                if (upgraded.bundle_db) {
                    try { GM_setValue(BUNDLE_DB_CACHE_KEY_V2, null); } catch (e) {}
                }
            }
            // 从老 GM 大对象一次性迁移到 IDB
            migrateLegacyGmKeysToIDB();
            // v2.9.50: 同步从 IDB hydrate PCC 持久化计算缓存到 _mem,让 getSync 立即可命中
            // v2.9.73: _PCC_CACHE 定义在 SGLV 子闭包内,通过 SGLV_API 桥接调用（修复 ReferenceError）
            if (SGLV_API.hydratePccCache) SGLV_API.hydratePccCache();
        } catch (e) {
            console.warn('[SGLV] IDB 初始化失败,降级使用 GM_setValue:', e);
        }
        // v2.9.109: initUI/autoScan 独立 try-catch，一个失败不影响另一个
        try { SGLV_API.initUI(); } catch (e) { console.error('[SGLV] UI 初始化失败:', e); }
        try { SGLV_API.autoScan(); } catch (e) { console.warn('[SGLV] 自动扫描失败:', e); }
        console.log('[Steam 游戏库展示] UI 初始化完成');
        // v2.4.0: 注册卸载清理，释放事件监听器/MutationObserver，避免内存泄漏
        window.addEventListener('pagehide', runDisposers);
    }

    // v2.9.109: init() 加 .catch 防止 unhandled rejection
    if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', () => init().catch(e => console.error('[SGLV] 启动失败:', e)));
    else init().catch(e => console.error('[SGLV] 启动失败:', e));
})();