// ==UserScript==
// @name         Steam 游戏库收藏分析
// @namespace    steam-game-library-viewer
// @author       Github: SmallRob，SteamID: Healer007
// @version      2.46.2
// @description  给 Steam 商店页和个人主页加一个「游戏库分析」面板，一屏看清你的游戏资产。🏆 我的成就：同步你在 Steam 上的真实成就，按完成率、稀有度浏览每一款游戏，看得见哪款已完美通关、哪些是全球稀有成就、还差哪几个。🎮 游戏收藏：绝版游戏、锁区（你所在地区无法购买）、Epic / PS 限时免费、DLC 与捆绑包、年度佳作清单。💰 跨区比价：自动对比美 / 日 / 俄 / 土等多区售价，标出最便宜的国家。📊 统计图表：游玩时长、玩得最久的游戏、最近入库、年度曲库曲线。☁️ 云存档：查询各游戏的云存档状态。💗 愿望单：整理愿望单并识别家庭共享。全部数据只存在你自己的浏览器里，不上传任何服务器。完整更新日志见项目 README。
// @description:en  Adds a "Game Library" panel to Steam's store and profile pages so you can see your whole game collection at a glance. 🏆 Achievements: syncs your real Steam achievements and lets you browse every game by completion rate and rarity — see which ones you've perfected, which contain globally rare achievements, and what's still missing. 🎮 Collection: delisted games, region-locked titles, Epic/PS giveaways, DLC and bundles, and Game of the Year picks. 💰 Price comparison: compares prices across US / JP / RU / TR regions and flags the cheapest country. 📊 Charts: playtime, most-played games, recent purchases, yearly library growth. ☁️ Cloud saves: check cloud-save status per game. 💗 Wishlist: tidy up your wishlist and spot family-shared titles. Everything stays in your own browser — nothing is uploaded. Full changelog in the project README.
// @homepageURL  https://github.com/SmallRob/steam-userscripts/blob/main/steam-game-library-viewer/README.md
// @supportURL   https://github.com/SmallRob/steam-userscripts/issues
// @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      gcore.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
// @connect      api.xiaoheihe.cn
// ============================================================================
// 依赖清单 —— 改任何引用之前，先读这一段
// ============================================================================
// 【规范】四条，改 @require / @resource 前先对照：
//   ① 一条依赖只能有一种加载方式：@require（远程）或内联进本文件，**互斥**。
//      同时存在 = 白下载 + 白解析 + 同名全局被赋值两次（v2.42.2 实测踩过）。
//   ② @require 一律钉具体版本 / 提交号。@main、@latest 会静默漂移 ——
//      上游一提交就换掉你正在跑的代码。@resource 例外（纯数据、无执行风险、需自动更新）。
//   ③ 头部只指向**已发布且存在**的版本。core 缺失会让整个脚本致命早退
//      （见下方「SGLVCore 依赖注入」一节），指向未发布版本 = 整脚本哑火。
//   ④ 本地真源在 libs/，远程是发布产物。改库 → 发布 → 再改本头部，三步缺一即漂移。
//      校验：node test-scripts/verify-remote-deps.js
//           （头部 ↔ 清单 ↔ 本地真源 ↔ 远程实际内容，四方逐行比对）
//      清单：test-scripts/remote-deps.config.json
//
// 【A. 基础层】@require · scriptcat.org · 已发布
//   core   v2.0.6  基础能力：IDB / 负缓存 / StageProgress / 并发池 / gmFetch / 通知
//          本地真源 libs/sglv-libs-core.lib.js
//   theme  v2.1.4  全局 token 与基座样式（幂等：root.SGLVTheme 已存在则不重复注入）
//          本地真源 libs/sglv-libs-theme.lib.js
// @require https://scriptcat.org/lib/7432/2.0.8/SGLV%20Core%20Library.js
// @require https://scriptcat.org/lib/7493/2.1.4/%20SGLV%20Shared%20CSS%20(Library).js
//
// 【B. 浮窗层】@require · scriptcat.org · 已发布
//   ptw-framework v3.0.0  浮窗外壳：Tab 注册表 / 懒挂载 / 生命周期 / 拖拽 / 降级卡 / 诊断卡
//   ptw-tabs      v3.0.0  10 个功能 Tab：总览 / 全部 / 日历 / 家庭组 / 成就 / 价值 / 足迹 / 库 / 玩 / 行情
//          本地真源 libs/sglv-libs-ptw-framework.lib.js · libs/sglv-libs-ptw-tabs.lib.js
//          框架库内嵌了一份 token 层副本 → PTW 自带样式，不依赖上面独立 theme 库也能浮窗
// @require https://scriptcat.org/lib/8427/3.0.0/SGLV%20PTW%20Framework.js
// @require https://scriptcat.org/lib/8430/3.0.0/SGLV%20PTW%20Tab%20All.js
//
// 【C. 共享宿主层】@require · jsdelivr · 钉 commit（坏推送不会连带打挂本插件）
//   plugin-host v0.3.0  插件宿主：别的脚本接入本插件能力的桥（window.__PLUGIN_HOST__）
//          本地真源：steam-namespace 仓 shared/
// ⚠️ v2.45.0：saa-auth / hub-relay（数据回流层）随「数据回流」功能整体下线一并移除 ——
//          本脚本不再把任何数据发往自建数据中心，也不再需要登录态自证 / 出箱链路。
//          保留 plugin-host 是因为它承担的是「别的脚本读本插件版本号」，与回流无关。
// @require https://cdn.jsdelivr.net/gh/SmallRob/steam-namespace@50174b3/libs/sglv-plugin-host.lib.js
//
// 【D. 内联依赖】无远程发布版，直接内联进本文件（见下方对应 INLINE 块）
//   shelf           暂存箱        libs/sglv-libs-shelf.lib.js（版本号未维护）
//   cover-fallback  v2.0.3  封面降级链路  libs/sglv-libs-cover-fallback.lib.js
//                   （曾发布于 scriptcat lib 7495 —— 远程副本已停用，勿恢复）
//   game-collection v2.9.9  收藏模块     libs/sglv-libs-game-collection.lib.js
//                   （曾发布于 scriptcat lib 8411 —— 远程副本已停用，勿恢复）
//
// 【E. 数据资源】@resource · jsdelivr · @main 自动更新（纯数据，无执行风险）
// @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
// @resource     humbleChoiceData https://fastly.jsdelivr.net/gh/SmallFork/json@main/Humble_Choice.json

// @grant        GM_xmlhttpRequest
// @grant        GM_getValue
// @grant        GM_setValue
// @grant        GM_addStyle
// @grant        GM_getResourceText
// @grant        GM_listValues
// @grant        GM_notification
// @grant        unsafeWindow
// @grant        GM_info
// @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==

// ============================================================================
// 游戏收藏模块为独立 GreasyFork 库（sglv-game-collection）
// ============================================================================
// 收藏模块核心实现（供应商分类 / 绝版收藏 / PS会免 / Epic赠送 / 锁区游戏 /
// 年度大作 / DLC收藏 / 捆绑包 / Humble Choice 月包分析 + 收藏浮窗管理）经
// 上方 @require 外部加载；库缺失时走降级链路：菜单项置灰 + 警告日志。
// 主脚本仅保留收藏基本界面：子菜单入口 / 心型按钮 / SGIS 侧边栏按钮 /
// CollectionHost 数据桥 / init 握手（见下方"游戏收藏模块"桥接区）。
// 本地开发库源码: script_libs/sglv-game-collection.lib.js
// （与 GreasyFork 发布版同步维护，apiVersion=1 桥接契约不变）。
// ============================================================================

// 游戏数据浮窗（PTW）三层架构——浮窗框架与 8 个功能 Tab（总览 / 全部游戏 / 日历 /
// 家庭组 / 成就分析 / 价值分析 / 游玩足迹，游玩足迹基于本地每日快照 IDB 滚动 90 天）
// v2.32.0：Tab 栏引入「分组」机制（概览/分析/明细/垂直），Tab 数量增长后仍可扫读；
// 总览瘦身（HERO + Top20），新增「游玩分析」Tab（时长分档 / 5 维雷达 / 最近两周 /
// 时长集中度 / 活跃度分层 / SCI 剧情完成度）；PTW_HOST 补挂 calcPlaytimeDist /
// isDlc / computeInsightData（此前已实现但从未挂到 host，Tab 库够不着）。
// 位于独立库经上方 @require 加载，主脚本退化为薄壳（仅保留 PTW_HOST 桥接与 2 个入口）。
// 框架含设置与诊断卡、Tab 熔断器（连续 3 次 mount 失败自动停用）、无障碍 tablist
// 键盘导航与窄屏适配。如需临时回退内联，运行 node test-scripts/build-ptw-inline.js
// 重新生成（该脚本会同时停用远程 @require 并切到内联模式，不会留下双载）。


// ==== SGLV-SHELF-INLINE-BEGIN (build-shelf-inline.js 自动生成，勿手改) ====
/**
 * 内联内容由 test-scripts/build-shelf-inline.js 生成 —— 请勿手改。
 * 来源：libs/{sglv-libs-shelf.lib.js}
 * 改动请编辑库文件后重跑本脚本；verify-shelf-inline-sync.js 会拦截漏跑。
 */
// ---------- sglv-libs-shelf.lib.js (1971 行) ----------
/* ===================================================================== *
 * SGLV 暂存箱库 (sglv-shelf)
 *
 * 定位：Steam 商店全域可达的「暂存箱」——把暂时不想买/想买但现在不买的
 *       商品、愿望单项、外部链接与备忘统一暂存，随时查看与恢复。
 *
 * 与 Steam-Cart-Enhanced.js（购物车增强）的关系
 * ---------------------------------------------------------------------
 * 共享 localStorage['sce_cart_shelf_v1']，即「购物类」记录（kind =
 * app/bundle/package）双向互通：SCE 暂存的项在 SGLV 浮窗可见，SGLV 从
 * 购物车暂存的项在 SCE 暂存架可见。用户未安装 SCE 时该 key 由本库独享，
 * 行为完全一致，无需任何配置。
 *
 * 为什么 wishlist/note 不写进同一个 items 数组
 * ---------------------------------------------------------------------
 * SCE 的 loadShelf() 过滤条件为
 *     it.id && (it.appid || it.bundleid || it.packageid || appids.length)
 * 且 saveShelf() 用过滤后的 shelf.items **整体重写** items 数组。
 * 若把备忘录/外部链接塞进同一数组，用户一旦在购物车页使用 SCE 暂存，
 * 这些记录会被 SCE 静默丢弃（无 appid/bundleid/packageid）。
 * 故采用双桶：
 *     INTEROP_KEY = 'sce_cart_shelf_v1'   购物类，与 SCE 互通（有损风险 0）
 *     EXTRA_KEY   = 'sglv_shelf_extra_v1' 愿望单/备忘，本库独享
 * 读取时合并为统一视图，写入时按 kind 路由，用户感知不到分桶。
 *
 * 扩展字段安全性
 * ---------------------------------------------------------------------
 * 顶层未知字段（如自定义 meta）会被 SCE 的 saveShelf 丢弃，故所有扩展
 * 一律挂在「记录级」字段上——SCE 只改写它认识的字段，记录级扩展可无损
 * 往返。写入互通桶时保留 days/tab 等 SCE 需要的顶层键（Object.assign 合并）。
 *
 * 能力边界（诚实声明）
 * -------------------------------------------------------------------
 * · 恢复（加购）走 AddItemsToCart/v1，全站可用，但**依赖当前登录账号**：
 *   记录写入时记 steamid，恢复前校验，不匹配直接拒绝（参考脚本无此保护，
 *   跨账号会静默加到错误账号的购物车）。
 * · 暂存（移出购物车）**没有官方 API**，只能点 Steam 自己的「移除」按钮，
 *   因此仅在 /cart 页可用（与 SCE 同一约束）。其他页面按钮置灰并给跳转。
 * · 愿望单不提供移除 API，故 wishlist 记录只做「打开/定位 + 记录管理」。
 * · 折扣到期时间 endTs 仅当记录带有该字段时显示倒计时（由 SCE 写入）；
 *   本库从购物车暂存时不主动拉折扣数据。
 *
 * 桥接契约（宿主注入，见 init(ShelfHost)）
 * ---------------------------------------------------------------------
 *   apiVersion: 1
 *   isZh: boolean
 *   getSteamId(): string            当前账号 steamid64（可为空）
 *   toast: { success, error, warning, info }
 *   resolveName(appid): Promise<string>   名称补全（可选，缺失时降级）
 *   openUrl(url), isCartPage(): boolean  （可选，缺失时降级）
 *
 * 暴露：window.SGLVShelf
 * ===================================================================== */

window.SGLVShelf = (function () {
    'use strict';

    const apiVersion = 1;

    // ==================== 常量 ====================
    const CFG = {
        INTEROP_KEY: 'sce_cart_shelf_v1',      // 与 Steam-Cart-Enhanced.js 共用
        EXTRA_KEY: 'sglv_shelf_extra_v1',     // 本库独享（wishlist / note）
        INTEROP_KINDS: ['app', 'bundle', 'package'],
        RESTORABLE: ['app', 'bundle', 'package'],
        CART_API: 'https://api.steampowered.com/IAccountCartService/GetCart/v1/',
        CART_ADD_API: 'https://api.steampowered.com/IAccountCartService/AddItemsToCart/v1/',
        ITEMS_API: 'https://api.steampowered.com/IStoreBrowseService/GetItems/v1/',
        SHELVE_STEP_MS: 700,
        RESTORE_STEP_MS: 250,
        CANDIDATE_STEP_MS: 200,
        MAX_ITEMS: 300,
        STALE_DAYS: 180,
        TICK_MS: 1000,
    };

    const KIND_META = {
        app: { label: '单品', tag: 'cart' },
        bundle: { label: '捆绑包', tag: 'cart' },
        package: { label: '购买包', tag: 'cart' },
        wishlist: { label: '愿望单', tag: 'wishlist' },
        note: { label: '备忘', tag: 'note' },
    };

    const FILTER_META = [
        { key: 'all', label: '全部' },
        { key: 'cart', label: '购物' },
        { key: 'wishlist', label: '愿望单' },
        { key: 'note', label: '备忘' },
    ];

    // ==================== 宿主 ====================
    let Host = null;
    let _hostReady = false;
    const _changeCbs = [];

    function zh(s, en) { return Host && Host.isZh === false ? en : s; }

    function toast(msg, type) {
        try {
            if (Host && Host.toast && typeof Host.toast[type] === 'function') Host.toast[type](msg);
            else if (typeof console !== 'undefined') console.log('[SGLVShelf]', type || 'info', msg);
        } catch (e) { /* ignore */ }
    }

    function debug() {
        if (typeof console === 'undefined') return;
        console.log.apply(console, ['[SGLVShelf]'].concat([].slice.call(arguments)));
    }

    // ==================== 基础工具 ====================
    const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
    const now = () => Date.now();
    const num = (v) => { const n = Number(v); return isNaN(n) ? 0 : n; };

    function esc(s) {
        return String(s == null ? '' : s).replace(/[&<>"']/g, (c) => (
            { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]
        ));
    }

    function uid(prefix) {
        return (prefix || 'sh') + '_' + now().toString(36) + '_' + Math.random().toString(36).slice(2, 7);
    }

    function clamp(n, lo, hi) { return Math.max(lo, Math.min(hi, n)); }

    function absTime(ts) {
        if (!ts) return '';
        try {
            const d = new Date(ts);
            const p = (x) => String(x).padStart(2, '0');
            return d.getFullYear() + '-' + p(d.getMonth() + 1) + '-' + p(d.getDate()) + ' ' + p(d.getHours()) + ':' + p(d.getMinutes());
        } catch (e) { return ''; }
    }

    /** 剩余时间文案；ts<=0 返回空串 */
    function remainText(ts) {
        const t = num(ts);
        if (t <= 0) return '';
        let s = Math.floor((t - now()) / 1000);
        if (s <= 0) return '已到期';
        const d = Math.floor(s / 86400); s -= d * 86400;
        const h = Math.floor(s / 3600); s -= h * 3600;
        const m = Math.floor(s / 60);
        if (d > 0) return '剩 ' + d + ' 天 ' + h + ' 小时';
        if (h > 0) return '剩 ' + h + ' 小时 ' + m + ' 分';
        return '剩 ' + Math.max(1, m) + ' 分';
    }

    /** 紧迫度：0 已过期/无，1 紧张(<24h)，2 临近(<72h)，3 宽松 */
    function severity(ts) {
        const t = num(ts);
        if (t <= 0) return 0;
        const h = (t - now()) / 3600000;
        if (h <= 0) return 1;
        if (h < 24) return 1;
        if (h < 72) return 2;
        return 3;
    }

    function isVisible(el) {
        if (!el) return false;
        try {
            const cs = getComputedStyle(el);
            if (cs.display === 'none' || cs.visibility === 'hidden') return false;
        } catch (e) { /* ignore */ }
        try {
            if (el.getClientRects && document.body && document.body.getClientRects) {
                if (document.body.getClientRects().length && !el.getClientRects().length) return false;
            }
        } catch (e) { /* ignore */ }
        return true;
    }

    // ==================== 存储层 ====================
    function lsGet(key) {
        try { return window.localStorage.getItem(key); } catch (e) { return null; }
    }
    function lsSet(key, val) {
        try { window.localStorage.setItem(key, val); return true; } catch (e) { return false; }
    }
    function readRaw(key) {
        const s = lsGet(key);
        if (!s) return null;
        try { const v = JSON.parse(s); return (v && typeof v === 'object') ? v : null; } catch (e) { return null; }
    }

    function isInteropKind(kind) { return CFG.INTEROP_KINDS.indexOf(kind) !== -1; }
    function bucketOf(kind) { return isInteropKind(kind) ? 'interop' : 'extra'; }

    /**
     * kind 推断的唯一权威入口（导入 / 归一化共用）。
     * 顺序：显式合法 kind → 购买项 id → 未知 kind 按有无 appid 归一 → 有 url 判备忘 → 默认。
     * 「先看 kind 再看 id」：kind='weird' + appid 应归一为 app，而 kind 缺失但带 bundleid
     * 才按 bundle 处理（与 SCE 的 legacy 推断兼容）。
     */
    function resolveKind(rec) {
        const r = rec || {};
        const k = r.kind;
        if (k && KIND_META[k]) return k;
        if (r.bundleid) return 'bundle';
        if (r.packageid) return 'package';
        const hasApp = !!r.appid || (Array.isArray(r.appids) && r.appids.length);
        if (k) return hasApp ? 'app' : 'note';
        if (r.url) return 'note';
        return hasApp ? 'app' : 'note';
    }

    function currentSteamId() {
        try { return (Host && typeof Host.getSteamId === 'function' && String(Host.getSteamId() || '')) || ''; }
        catch (e) { return ''; }
    }

    /**
     * 记录规范化。
     * - 互通桶强制 kind ∈ app/bundle/package（与 SCE 的理解对齐）
     * - 缺失 kind 时按 bundleid/packageid 推断并打 legacy（与 SCE 2216-2230 同规则）
     * - 补齐 appids/names/displayName/count 等展示字段
     * 不丢弃任何未知字段（往返无损）
     */
    function normalizeRecord(rec, bucket) {
        const r = Object.assign({}, rec || {});
        r.id = r.id || uid('sh');
        if (!Array.isArray(r.appids)) r.appids = r.appids != null ? [r.appids] : [];
        r.appids = r.appids.map(num).filter((n) => n > 0);
        if (!r.names || typeof r.names !== 'object') r.names = {};

        let kind = r.kind;
        if (!kind) {
            r.legacy = true;
            if (r.bundleid) kind = 'bundle';
            else if (r.packageid) kind = 'package';
            else kind = 'app';
            if (r.appid == null && kind === 'app' && r.appids.length === 1) r.appid = r.appids[0];
        }
        if (!KIND_META[kind]) kind = resolveKind(r);
        // 互通桶只允许购物类（SCE 不认其它 kind）
        if (bucket === 'interop' && !isInteropKind(kind)) kind = 'app';
        r.kind = kind;

        // 三 id 字段互斥化（与 SCE 结构一致：冗余三字段，方便按类型直读）
        if (kind === 'bundle') { r.packageid = null; r.appid = null; }
        else if (kind === 'package') { r.bundleid = null; r.appid = null; }
        else { r.bundleid = null; r.packageid = null; }

        if (kind === 'bundle') r.bundleid = num(r.bundleid) || null;
        if (kind === 'package') r.packageid = num(r.packageid) || null;
        if ((kind === 'app' || kind === 'wishlist') && !r.appid && r.appids.length === 1) r.appid = r.appids[0];
        if (kind === 'app' || kind === 'wishlist') r.appid = num(r.appid) || null;
        if (kind === 'note') { r.appid = null; r.bundleid = null; r.packageid = null; r.appids = []; }

        r.endTs = num(r.endTs);
        r.pct = num(r.pct);
        r.count = num(r.count) || r.appids.length || (kind === 'note' ? 1 : 0);
        r.removedAt = num(r.removedAt);
        r.addedAt = num(r.addedAt) || r.removedAt || 0;
        r.tags = Array.isArray(r.tags) ? r.tags.filter((x) => x != null && x !== '').slice(0, 12) : [];
        if (r.url == null) r.url = '';
        if (r.note == null) r.note = '';
        if (r.origin != 'sce') r.origin = 'sglv';
        if (!r.source) r.source = bucket === 'interop' ? 'cart' : 'manual';
        if (r.lastError === undefined) r.lastError = null;
        if (r.displayName == null) r.displayName = '';
        // SCE 记录常只有 targetName 而 displayName 为空 —— 回填一份，
        // 使记录自描述（两个脚本都能直接读 displayName）
        if (!r.displayName && r.targetName) r.displayName = r.targetName;
        return r;
    }

    /** SCE 认可的记录形状（有 id 且至少一个可定位 id） */
    function sceAcceptable(rec) {
        return !!(rec && rec.id && (rec.appid || rec.bundleid || rec.packageid
            || (Array.isArray(rec.appids) && rec.appids.length)));
    }

    function readBucket(bucket) {
        const key = bucket === 'interop' ? CFG.INTEROP_KEY : CFG.EXTRA_KEY;
        const raw = readRaw(key);
        const items = [];
        if (raw && Array.isArray(raw.items)) {
            raw.items.forEach((it) => {
                if (!it || typeof it !== 'object') return;
                if (bucket === 'interop' && !sceAcceptable(it)) return;
                items.push(normalizeRecord(it, bucket));
            });
        }
        return { raw: raw || {}, items: items };
    }

    /**
     * 写桶。互通桶用 Object.assign 合并而非整体覆盖，
     * 保留 SCE 需要的顶层键（days/tab）与任何未来新增键。
     */
    function writeBucket(bucket, items) {
        const key = bucket === 'interop' ? CFG.INTEROP_KEY : CFG.EXTRA_KEY;
        const cur = readRaw(key) || {};
        const payload = Object.assign({}, cur);
        payload.items = items;
        if (bucket === 'extra' && !payload.version) payload.version = 1;
        const ok = lsSet(key, JSON.stringify(payload));
        if (!ok) toast(zh('暂存箱保存失败：浏览器存储不可用或已满', 'Shelf save failed: storage unavailable or full'), 'error');
        return ok;
    }

    /** 统一视图：互通桶 + 独享桶 */
    function allItems() {
        return readBucket('interop').items.concat(readBucket('extra').items);
    }

    function getItem(id) {
        const list = allItems();
        for (let i = 0; i < list.length; i++) if (list[i].id === id) return list[i];
        return null;
    }

    function countAll() { return allItems().length; }

    /**
     * 容量上限：**跨两桶的全局上限**。
     * 淘汰顺序：先独享桶（备忘/愿望单，最不贵）→ 再互通桶（购物类，最贵）。
     * 同桶内按 addedAt 升序（最旧先走）。
     * 返回被淘汰条数。
     */
    function enforceCap() {
        const ex = readBucket('extra').items;
        const it = readBucket('interop').items;
        let over = ex.length + it.length - CFG.MAX_ITEMS;
        if (over <= 0) return 0;
        let dropped = 0;
        const drain = (arr) => {
            const order = arr.slice().sort((a, b) => (num(a.addedAt) || num(a.removedAt)) - (num(b.addedAt) || num(b.removedAt)));
            for (const r of order) {
                if (over <= 0) break;
                const i = arr.indexOf(r);
                if (i >= 0) { arr.splice(i, 1); over--; dropped++; }
            }
        };
        drain(ex);
        if (over > 0) drain(it);
        if (dropped) { writeBucket('extra', ex); writeBucket('interop', it); }
        return dropped;
    }

    /**
     * 写入/更新一条记录（按 kind 路由桶）。
     * opts.silent 内部批处理时静默（不逐条 toast、不逐条广播）
     */
    function putItem(rec, opts) {
        const o = opts || {};
        const inp = Object.assign({}, rec || {});
        // 别名归一：允许调用方直接传 title/name（其他 SGLV 模块的常见用法）
        if (!inp.displayName && !inp.targetName) {
            const t = inp.title || inp.name;
            if (t) { inp.displayName = t; inp.targetName = t; }
        }
        // 时间戳补齐：无任何时间戳的记录（外部模块直接 putItem）盖章 now，
        // 否则 addedAt=0 会让「按加入时间排序」与陈旧清理全部失效
        if (!num(inp.addedAt) && !num(inp.removedAt)) {
            inp.addedAt = now();
            inp.removedAt = inp.addedAt;
        }
        const r = normalizeRecord(inp, bucketOf(inp.kind));
        if (!sceAcceptable(r) && isInteropKind(r.kind)) {
            toast(zh('这条记录缺少可定位的商品 ID，未保存', 'Record lacks a resolvable id, skipped'), 'warning');
            return null;
        }
        const bucket = bucketOf(r.kind);
        const cur = readBucket(bucket).items;
        const idx = cur.findIndex((x) => x.id === r.id);
        if (idx >= 0) cur[idx] = r; else cur.unshift(r);
        writeBucket(bucket, cur);

        const dropped = enforceCap();
        if (dropped && !o.silent) {
            toast(zh('暂存箱已满（上限 ' + CFG.MAX_ITEMS + ' 条），已淘汰最旧的 ' + dropped + ' 条', 'Shelf full (' + CFG.MAX_ITEMS + '), pruned ' + dropped + ' oldest'), 'warning');
        }
        if (!o.silent) emitChange();
        return r;
    }

    function deleteItem(id, opts) {
        const o = opts || {};
        const rec = getItem(id);
        if (!rec) return false;
        const bucket = bucketOf(rec.kind);
        const cur = readBucket(bucket).items.filter((x) => x.id !== id);
        writeBucket(bucket, cur);
        if (!o.silent) emitChange();
        return true;
    }

    /** 清理长期未处理的记录（用户手动触发，绝不自动删） */
    function pruneStale(days) {
        const limit = now() - (num(days) || CFG.STALE_DAYS) * 86400000;
        let n = 0;
        ['interop', 'extra'].forEach((b) => {
            const cur = readBucket(b).items;
            const keep = cur.filter((it) => (num(it.addedAt) || num(it.removedAt)) > limit);
            if (keep.length !== cur.length) { n += cur.length - keep.length; writeBucket(b, keep); }
        });
        if (n) emitChange();
        return n;
    }

    // ---- 偏好（存独享桶，SGLV 私有） ----
    function getPrefs() {
        const raw = readRaw(CFG.EXTRA_KEY) || {};
        const p = raw.prefs && typeof raw.prefs === 'object' ? raw.prefs : {};
        return {
            filter: p.filter || 'all',
            sort: p.sort || 'end',
            compatOnly: !!p.compatOnly,
        };
    }
    function setPrefs(patch) {
        const raw = readRaw(CFG.EXTRA_KEY) || {};
        const next = Object.assign({}, raw.prefs || {}, patch || {});
        const payload = Object.assign({}, raw);
        payload.prefs = next;
        if (!payload.version) payload.version = 1;
        lsSet(CFG.EXTRA_KEY, JSON.stringify(payload));
    }

    // ---- 展示派生 ----
    function displayName(rec) {
        if (!rec) return '';
        if (rec.displayName) return rec.displayName;
        if (rec.targetName) return rec.targetName;
        if (rec.kind === 'note') return rec.url || zh('（未命名备忘）', '(untitled note)');
        const n = rec.names && Object.keys(rec.names)[0];
        if (n) return rec.names[n];
        if (rec.appid) return 'App ' + rec.appid;
        if (rec.bundleid) return 'Bundle ' + rec.bundleid;
        if (rec.packageid) return 'Package ' + rec.packageid;
        return zh('（未命名）', '(untitled)');
    }

    function linkOf(rec) {
        if (!rec) return '';
        if (rec.kind === 'bundle' && rec.bundleid) return 'https://store.steampowered.com/bundle/' + rec.bundleid;
        if (rec.kind === 'package' && rec.packageid) return 'https://store.steampowered.com/sub/' + rec.packageid;
        if (rec.appid) return 'https://store.steampowered.com/app/' + rec.appid;
        if (rec.url) return rec.url;
        return '';
    }

    /** 该记录是否属于其他账号（写入时账号 ≠ 当前账号） */
    function foreignAccount(rec) {
        const mine = currentSteamId();
        if (!mine || !rec || !rec.steamid) return false;
        return String(rec.steamid) !== mine;
    }

    function canRestore(rec) { return !!rec && CFG.RESTORABLE.indexOf(rec.kind) !== -1; }

    // ==================== 变更广播 ====================
    function emitChange() {
        const n = countAll();
        try { setBadge(n); } catch (e) { /* ignore */ }
        // 浮窗开着就同步重绘：删除/清空/导入/恢复都走 emitChange，
        // 否则弹窗确认后列表会停留在旧快照（UI 与数据不一致）
        if (isOpenFlag) { try { renderList(); } catch (e) { console.warn('[SGLVShelf] 重绘失败', e); } }
        _changeCbs.forEach((cb) => { try { cb(n); } catch (e) { console.warn('[SGLVShelf] onChange 回调异常', e); } });
    }
    function onChange(cb) { if (typeof cb === 'function') _changeCbs.push(cb); }

    // ==================== Steam 接口层 ====================
    function appConfigEl() { return document.querySelector('#application_config'); }

    function readJsonAttr(el, name) {
        if (!el) return null;
        try { return JSON.parse(el.getAttribute(name) || 'null'); } catch (e) { return null; }
    }

    function getAccessToken() {
        const uc = readJsonAttr(appConfigEl(), 'data-store_user_config');
        return (uc && uc.webapi_token) || null;
    }

    function isLoggedIn() {
        const ui = readJsonAttr(appConfigEl(), 'data-userinfo');
        return !!(ui && ui.logged_in);
    }

    function getContext() {
        const cfg = readJsonAttr(appConfigEl(), 'data-config') || {};
        const lang = cfg.LANGUAGE || (window.g_Languages && window.g_Languages[0]) || 'schinese';
        let cc = cfg.COUNTRY;
        if (!cc) { try { cc = new URLSearchParams(location.search).get('cc'); } catch (e) { /* ignore */ } }
        return { language: String(lang).toLowerCase(), country_code: String(cc || 'CN').toUpperCase(), steam_realm: 1 };
    }

    function gmJson(url) {
        return new Promise((resolve, reject) => {
            if (typeof GM_xmlhttpRequest !== 'function') {
                fetch(url, { credentials: 'include' }).then((r) => r.json()).then(resolve).catch(reject);
                return;
            }
            GM_xmlhttpRequest({
                method: 'GET', url: url, timeout: 15000,
                onload: (res) => { try { resolve(JSON.parse(res.responseText)); } catch (e) { reject(new Error('JSON 解析失败')); } },
                onerror: () => reject(new Error('网络错误')),
                ontimeout: () => reject(new Error('请求超时')),
            });
        });
    }

    function gmFormPost(url, body) {
        return new Promise((resolve, reject) => {
            const headers = { 'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8' };
            if (typeof GM_xmlhttpRequest !== 'function') {
                fetch(url, { method: 'POST', credentials: 'include', headers: headers, body: body })
                    .then((r) => r.json()).then(resolve).catch(reject);
                return;
            }
            GM_xmlhttpRequest({
                method: 'POST', url: url, headers: headers, data: body, timeout: 20000,
                onload: (res) => { try { resolve(JSON.parse(res.responseText)); } catch (e) { reject(new Error('JSON 解析失败')); } },
                onerror: () => reject(new Error('网络错误')),
                ontimeout: () => reject(new Error('请求超时')),
            });
        });
    }

    async function fetchLineItems(token) {
        const data = await gmJson(CFG.CART_API + '?access_token=' + encodeURIComponent(token));
        const cart = data && data.response && data.response.cart;
        return ((cart && cart.line_items) || []).map((it) => ({
            lineItemId: it.line_item_id != null ? it.line_item_id : null,
            type: it.type != null ? it.type : null,
            packageid: it.packageid ? Number(it.packageid) : null,
            bundleid: it.bundleid ? Number(it.bundleid) : null,
        }));
    }

    async function fetchStoreItems(ids) {
        if (!ids || !ids.length) return [];
        const payload = {
            ids: ids,
            context: getContext(),
            data_request: { include_basic_info: true, include_all_purchase_options: true },
        };
        const data = await gmJson(CFG.ITEMS_API + '?input_json=' + encodeURIComponent(JSON.stringify(payload)));
        return (data && data.response && data.response.store_items) || [];
    }

    function kindQuery(t) { return t.kind === 'bundle' ? { bundleid: t.id } : { packageid: t.id }; }

    function cartNavData(cc) {
        return {
            domain: 'store.steampowered.com', controller: 'default', method: 'default', submethod: '',
            feature: 'store_home', depth: 1, countrycode: cc, webkey: 0, is_client: false,
            curator_data: { clanid: null, listid: null }, is_likely_bot: false, is_utm: false,
        };
    }

    function describeCartError(data) {
        const r = data && data.response;
        if (!r) return zh('接口没有返回内容，可能是网络或登录态问题', 'No response from API');
        const e = r.error;
        if (e) {
            const bits = [];
            if (e.message) bits.push(String(e.message));
            if (e.error_description && e.error_description !== e.message) bits.push(String(e.error_description));
            if (e.eresult != null) bits.push('eresult ' + e.eresult);
            if (!bits.length) bits.push(JSON.stringify(e).slice(0, 200));
            return bits.join(' / ');
        }
        return zh('Steam 没有把它加入购物车', 'Steam refused to add it');
    }

    async function addOneToCart(token, cc, cand) {
        const item = { gift_info: null, flags: { is_gift: false, is_private: false } };
        if (cand.kind === 'bundle') item.bundleid = cand.id; else item.packageid = cand.id;
        const payload = { user_country: cc, items: [item], navdata: cartNavData(cc) };
        const data = await gmFormPost(
            CFG.CART_ADD_API + '?access_token=' + encodeURIComponent(token),
            'input_json=' + encodeURIComponent(JSON.stringify(payload))
        );
        if (data && data.response && data.response.cart) return { ok: true, data: data };
        return { ok: false, data: data, err: describeCartError(data) };
    }

    function verifyRestored(data, cand) {
        const resp = (data && data.response) || {};
        const lis = (resp.cart && resp.cart.line_items) || [];
        const ids = (resp.line_item_ids || []).map(String);
        const mine = ids.length ? lis.filter((li) => ids.indexOf(String(li.line_item_id)) !== -1) : [];
        const field = cand.kind === 'bundle' ? 'bundleid' : 'packageid';
        if (mine.length > 1) return zh('Steam 一次加回了 ' + mine.length + ' 条（预期 1 条）', 'Steam added ' + mine.length + ' lines');
        const pool = mine.length ? mine : lis;
        if (pool.some((li) => String(li[field] || '') === String(cand.id))) return '';
        return zh('加回的购买项对不上（Steam 返回了别的项）', 'Restored item mismatch');
    }

    async function bestOptionOfApp(appid) {
        try {
            const items = await fetchStoreItems([{ appid: Number(appid) }]);
            const si = items[0];
            const opt = (si && si.best_purchase_option) || null;
            if (!opt) return null;
            if (opt.bundleid) return { kind: 'bundle', id: Number(opt.bundleid), name: si.name || '' };
            if (opt.packageid) return { kind: 'package', id: Number(opt.packageid), name: si.name || '' };
        } catch (e) { debug('bestOptionOfApp 失败', appid, e); }
        return null;
    }

    /** 旧记录（无购买项 id）按内容重新识别购买项 */
    async function resolveTargetByContent(appids) {
        const idsWant = (appids || []).map(Number).filter((n) => n > 0);
        if (!idsWant.length) return null;
        try {
            const items = await fetchStoreItems(idsWant.map((a) => ({ appid: a })));
            const cand = [];
            const seen = new Set();
            const push = (kind, id) => {
                if (!kind || !id) return;
                const k = kind + ':' + id;
                if (seen.has(k)) return;
                seen.add(k);
                cand.push({ kind: kind, id: Number(id) });
            };
            items.forEach((si) => {
                (si.purchase_options || []).forEach((o) => {
                    if (o.bundleid) push('bundle', o.bundleid);
                    else if (o.packageid) push('package', o.packageid);
                });
                const b = si.best_purchase_option;
                if (b) { if (b.bundleid) push('bundle', b.bundleid); else if (b.packageid) push('package', b.packageid); }
            });
            if (!cand.length) return null;
            const detail = await fetchStoreItems(cand.map(kindQuery));
            const byId = new Map();
            detail.forEach((si) => { if (si && si.id != null) byId.set(String(si.id), si); });
            let best = null;
            cand.forEach((c) => {
                const si = byId.get(String(c.id));
                if (!si || !Array.isArray(si.included_appids)) return;
                const inc = si.included_appids.map(String);
                if (!idsWant.every((a) => inc.indexOf(String(a)) !== -1)) return;
                if (!best || inc.length < best.incLength) best = { kind: c.kind, id: c.id, name: si.name || '', incLength: inc.length, how: zh('按商品内容重新识别', 'resolved by content') };
            });
            return best;
        } catch (e) { debug('按内容解析购买项失败', e); return null; }
    }

    async function resolveRestorePlan(rec) {
        if (rec.legacy && rec.appids && rec.appids.length) {
            const byContent = await resolveTargetByContent(rec.appids);
            if (byContent) return [byContent];
        }
        if (rec.kind === 'bundle' && rec.bundleid) return [{ kind: 'bundle', id: Number(rec.bundleid) }];
        if (rec.kind === 'package' && rec.packageid) return [{ kind: 'package', id: Number(rec.packageid) }];
        const appid = num(rec.appid || ((rec.appids && rec.appids.length === 1) ? rec.appids[0] : 0));
        if (appid > 0 && rec.kind === 'app') {
            const one = await bestOptionOfApp(appid);
            if (one) return [one];
        }
        return [];
    }

    function candidateLabel(c) {
        return c.kind === 'bundle' ? 'bundle ' + c.id : 'package ' + c.id;
    }

    // ==================== 恢复（加购） ====================
    let busy = false;
    let busyText = '';

    function isBusy() { return busy; }

    async function executeRestore(ids) {
        if (busy) { toast(zh('暂存箱正忙，稍后再试', 'Shelf is busy, try later'), 'warning'); return; }
        const targets = allItems().filter((it) => ids.indexOf(it.id) !== -1 && canRestore(it));
        if (!targets.length) {
            toast(zh('选中的记录里没有可恢复到购物车的项', 'Nothing restorable selected'), 'warning');
            return;
        }
        // 账号归属优先于登录态：「来自其他账号」比「未登录」更具体，
        // 若先判登录态会把它掩盖成一句误导性的登录提示
        const blocked = targets.filter(foreignAccount);
        if (blocked.length === targets.length) {
            toast(zh('这些记录来自其他 Steam 账号，已阻止恢复', 'Records belong to another account — restore blocked'), 'error');
            return;
        }
        if (!isLoggedIn() && !getAccessToken()) {
            toast(zh('未登录 Steam，请先登录后再恢复', 'Not logged in — log in first'), 'warning');
            return;
        }

        const token = getAccessToken();
        const cc = getContext().country_code;
        const added = [];
        const failed = [];
        const warns = [];
        busy = true;
        setBusy(zh('准备恢复 ' + targets.length + ' 项…', 'Preparing ' + targets.length + ' items…'));

        try {
            for (let i = 0; i < targets.length; i++) {
                const rec = targets[i];
                if (foreignAccount(rec)) {
                    failed.push({ name: displayName(rec), why: zh('来自其他 Steam 账号', 'from another account') });
                    continue;
                }
                setBusy(zh('正在恢复 ' + (i + 1) + '/' + targets.length + '：', 'Restoring ') + displayName(rec));
                const plan = await resolveRestorePlan(rec);
                if (!plan.length) {
                    rec.lastError = zh('记录里没有可用的购买项', 'no purchasable option');
                    putItem(rec, { silent: true });
                    failed.push({ name: displayName(rec), why: rec.lastError });
                    continue;
                }
                const errs = [];
                let ok = false;
                for (const cand of plan) {
                    try {
                        const r = await addOneToCart(token, cc, cand);
                        if (r.ok) {
                            const bad = verifyRestored(r.data, cand);
                            rec.kind = cand.kind;
                            rec.bundleid = cand.kind === 'bundle' ? cand.id : null;
                            rec.packageid = cand.kind === 'package' ? cand.id : null;
                            rec.appid = null;
                            if (cand.name) rec.targetName = cand.name;
                            rec.displayName = rec.targetName || displayName(rec);
                            rec.legacy = false;
                            rec.lastError = null;
                            rec.restoredAt = now();
                            putItem(rec, { silent: true });
                            if (bad) warns.push({ name: displayName(rec), why: bad });
                            added.push(rec.id);
                            ok = true;
                            break;
                        }
                        errs.push(candidateLabel(cand) + ' → ' + r.err);
                    } catch (e) {
                        errs.push(candidateLabel(cand) + ' → ' + ((e && e.message) || zh('请求失败', 'request failed')));
                    }
                    await sleep(CFG.CANDIDATE_STEP_MS);
                }
                if (!ok) {
                    rec.lastError = errs.join(zh('；', '; ')) || zh('未知原因', 'unknown');
                    putItem(rec, { silent: true });
                    failed.push({ name: displayName(rec), why: rec.lastError });
                }
                await sleep(CFG.RESTORE_STEP_MS);
            }
        } finally {
            busy = false;
            setBusy('');
            emitChange();
        }

        const parts = [];
        if (added.length) parts.push(zh('已恢复 <b>', 'Restored <b>') + added.length + '</b> ' + zh('项到购物车', 'items to cart'));
        if (failed.length) parts.push(zh('失败 <b>', 'Failed <b>') + failed.length + '</b> ' + zh('项', 'items'));
        if (warns.length) parts.push(zh('有 <b>', '<b>') + warns.length + '</b> ' + zh('项 Steam 返回与预期不符', 'items returned unexpected cart content'));
        toast(parts.join(' · ') || zh('没有可恢复的项目', 'Nothing restored'), failed.length ? 'warning' : 'success');

        if (failed.length || warns.length) {
            const rows = failed.concat(warns).map((f) => '<div class="sgsh-m-line"><b>' + esc(f.name) + '</b><span>' + esc(f.why) + '</span></div>').join('');
            showModal({
                title: zh('恢复结果', 'Restore result'),
                body: '<div class="sgsh-m-lead">' + (parts.join(' · ') || '') + '</div>' + rows,
                buttons: [{ label: zh('知道了', 'OK'), primary: true }, { label: zh('刷新购物车', 'Refresh cart'), act: () => { location.href = 'https://store.steampowered.com/cart/'; } }],
            });
        }
        return { added: added.length, failed: failed.length, warns: warns.length };
    }

    // ==================== 购物车页：行内暂存 ====================
    const CART_REMOVE_RE = /(remove|移除|删除|entfernen|supprimer|eliminar|rimuovi)/i;

    function cartRoot() {
        return document.querySelector('[data-featuretarget="react-root"]')
            || document.querySelector('.responsive_page_template_content')
            || document.body;
    }

    function collectAnchors(root) {
        const out = { apps: [], bundles: [], subs: [], all: [] };
        const seen = new Set();
        (root.querySelectorAll('a[href*="/app/"], a[href*="/bundle/"], a[href*="/sub/"]') || []).forEach((a) => {
            const href = a.getAttribute('href') || '';
            const ma = href.match(/\/app\/(\d+)/);
            const mb = href.match(/\/bundle\/(\d+)/);
            const ms = href.match(/\/sub\/(\d+)/);
            if (ma && out.apps.indexOf(Number(ma[1])) === -1) out.apps.push(Number(ma[1]));
            if (mb && out.bundles.indexOf(Number(mb[1])) === -1) out.bundles.push(Number(mb[1]));
            if (ms && out.subs.indexOf(Number(ms[1])) === -1) out.subs.push(Number(ms[1]));
            const key = href;
            if (!seen.has(key)) { seen.add(key); out.all.push({ href: href, el: a }); }
        });
        return out;
    }

    function nearestRowWith(el, root) {
        let n = el;
        for (let d = 0; n && d < 14; d++) {
            const anchors = collectAnchors(n);
            if (anchors.apps.length || anchors.bundles.length || anchors.subs.length) {
                if (n !== root && n.querySelector && n.querySelector('button, a')) return n;
            }
            n = n.parentElement;
        }
        return null;
    }

    function removeActionEl(rowEl) {
        let found = null;
        (rowEl.querySelectorAll('button, a') || []).forEach((el) => {
            if (found) return;
            const t = ((el.textContent || '') + ' ' + (el.getAttribute('aria-label') || '') + ' ' + (el.title || '')).trim();
            if (t && CART_REMOVE_RE.test(t)) found = el;
        });
        return found;
    }

    function rowKey(row) {
        return [row.appids.join('.'), row.bundleIds.join('.'), row.subIds.join('.')].join('|');
    }

    function scanCartRows() {
        const root = cartRoot();
        if (!root) return [];
        const rows = [];
        const seen = new Set();
        collectAnchors(root).all.forEach((a) => {
            const rowEl = nearestRowWith(a.el, root);
            if (!rowEl) return;
            const key = rowEl.__sgshRowKey || (rowEl.__sgshRowKey = uid('row'));
            if (seen.has(key)) return;
            const an = collectAnchors(rowEl);
            if (!an.apps.length && !an.bundles.length && !an.subs.length) return;
            seen.add(key);
            rows.push({
                rowEl: rowEl,
                key: key,
                appids: an.apps,
                bundleIds: an.bundles,
                subIds: an.subs,
                removeBtn: removeActionEl(rowEl),
            });
        });
        return rows;
    }

    /** 行内注入「暂存」按钮；检测到 SCE 已注入 .sce-shelve-btn 时跳过，避免双按钮 */
    function injectCartButtons() {
        if (!onCartPage()) return 0;
        let n = 0;
        scanCartRows().forEach((row) => {
            if (row.rowEl.querySelector('.sgsh-shelve-btn') || row.rowEl.querySelector('.sce-shelve-btn')) return;
            const btn = document.createElement('button');
            btn.className = 'sgsh-shelve-btn';
            btn.type = 'button';
            btn.textContent = zh('暂存', 'Stash');
            btn.title = zh('加入暂存箱（会从购物车移除）', 'Move to shelf (removes from cart)');
            btn.addEventListener('click', (e) => { e.preventDefault(); e.stopPropagation(); shelveOneRow(row); });
            const act = removeActionEl(row.rowEl);
            if (act && act.parentElement) act.parentElement.insertBefore(btn, act);
            else row.rowEl.appendChild(btn);
            n++;
        });
        return n;
    }

    function onCartPage() {
        try { return /^\/cart\/?(\?|$)/i.test(location.pathname); } catch (e) { return false; }
    }

    async function buildCartIndex() {
        const token = getAccessToken();
        if (!token) return { entries: [], ok: false, error: zh('未登录 Steam，读不到登录令牌', 'Not logged in: no access token') };
        let lineItems;
        try { lineItems = await fetchLineItems(token); }
        catch (e) { return { entries: [], ok: false, error: zh('读取购物车接口失败：', 'GetCart failed: ') + ((e && e.message) || e) }; }

        const targets = lineItems.map((li) => (
            li.bundleid ? { kind: 'bundle', id: Number(li.bundleid) }
                : li.packageid ? { kind: 'package', id: Number(li.packageid) } : null
        )).filter(Boolean);

        let storeItems = [];
        if (targets.length) {
            try { storeItems = await fetchStoreItems(targets.map(kindQuery)); }
            catch (e) { debug('读取购买项内容失败', e); }
        }
        const byKey = new Map();
        storeItems.forEach((si) => {
            if (!si || si.id == null) return;
            const t = targets.find((x) => String(x.id) === String(si.id));
            const kind = (t && t.kind) || (si.item_type === 2 ? 'bundle' : 'package');
            byKey.set(kind + ':' + si.id, si);
        });
        return {
            ok: true, error: '',
            entries: lineItems.map((li, i) => {
                const t = targets[i];
                if (!t) return null;
                const si = byKey.get(t.kind + ':' + t.id) || null;
                return {
                    lineItemId: li.lineItemId, kind: t.kind, id: t.id,
                    name: (si && si.name) || '',
                    included: (si && Array.isArray(si.included_appids)) ? si.included_appids.map(String) : [],
                };
            }).filter(Boolean),
        };
    }

    function classifyRow(row, index) {
        const ents = ((index && index.entries) || []).filter((e) => e && e.kind);
        if (!ents.length) return null;
        const apps = (row.appids || []).map(String);
        if (apps.length) {
            const cover = ents.filter((e) => e.included.length && apps.every((a) => e.included.indexOf(a) !== -1));
            if (cover.length) {
                const exact = cover.filter((e) => e.included.length === apps.length);
                const pool = exact.length ? exact : cover;
                pool.sort((a, b) => a.included.length - b.included.length);
                return {
                    kind: pool[0].kind, id: pool[0].id, name: pool[0].name, lineItemId: pool[0].lineItemId,
                    how: exact.length ? zh('内容与购物车里那一项一致', 'content matches cart line') : zh('内容都属于购物车里那一项', 'content belongs to cart line'),
                };
            }
        }
        const links = [];
        (row.bundleIds || []).forEach((id) => links.push({ kind: 'bundle', id: num(id), how: '/bundle/' }));
        (row.subIds || []).forEach((id) => links.push({ kind: 'package', id: num(id), how: '/sub/' }));
        for (const l of links) {
            const hit = ents.find((e) => e.kind === l.kind && String(e.id) === String(l.id));
            if (hit) return { kind: hit.kind, id: hit.id, name: hit.name, lineItemId: hit.lineItemId, how: l.how };
        }
        return null;
    }

    function buildRecord(row, target) {
        const rec = normalizeRecord({
            id: uid('sh'),
            kind: target.kind,
            bundleid: target.kind === 'bundle' ? target.id : null,
            packageid: target.kind === 'package' ? target.id : null,
            appid: null,
            targetName: target.name || '',
            targetHow: target.how || '',
            lineItemId: target.lineItemId != null ? target.lineItemId : null,
            appids: row.appids.slice(),
            names: {},
            endTsMap: {},
            endTs: 0,
            pct: 0,
            count: row.appids.length,
            removedAt: now(),
            addedAt: now(),
            source: 'cart',
            steamid: currentSteamId(),
        }, 'interop');
        return rec;
    }

    /** 单行暂存（无确认弹窗，与 SCE 行内行为一致） */
    async function shelveOneRow(row) {
        if (busy) { toast(zh('暂存箱正忙，稍后再试', 'Shelf is busy, try later'), 'warning'); return; }
        const index = await buildCartIndex();
        if (!index.ok) { toast(index.error, 'error'); return; }
        let target = classifyRow(row, index);
        if (!target && row.appids.length === 1) {
            target = { kind: 'app', id: num(row.appids[0]), name: '', lineItemId: null, how: zh('单个商品，恢复时按商店当前购买项', 'single app; resolved at restore time') };
        }
        if (!target) {
            showModal({ title: zh('无法暂存这一项', 'Cannot stash this line'), body: '<div class="sgsh-m-lead">' + zh('这一行认不出对应的购买项（bundle/sub）。为避免暂存错东西，已中止。', 'Cannot resolve the purchase option for this line; aborted to avoid a wrong record.') + '</div>', buttons: [{ label: zh('知道了', 'OK'), primary: true }] });
            return;
        }
        const rec = buildRecord(row, target);
        const ok = doShelveRows([{ row: row, rec: rec }]);
        if (ok) toast(zh('已暂存：', 'Stashed: ') + displayName(rec), 'success');
    }

    /** 批量暂存（确认弹窗 → 执行） */
    function shelveAllRows() {
        if (busy) { toast(zh('暂存箱正忙，稍后再试', 'Shelf is busy, try later'), 'warning'); return; }
        const rows = scanCartRows();
        if (!rows.length) { toast(zh('购物车里没有可暂存的行', 'No cart rows found'), 'warning'); return; }
        showModal({
            title: zh('暂存购物车', 'Stash whole cart'),
            body: '<div class="sgsh-m-lead">' + zh('将把购物车里的 <b>', 'Moves <b>') + rows.length + '</b> ' + zh('项移出购物车并存入暂存箱：', 'lines out of the cart into the shelf:') + '</div>'
                + '<ul class="sgsh-m-list">' + rows.map((r) => '<li>' + esc((r.appids[0] ? 'App ' + r.appids[0] : (r.bundleIds[0] ? 'Bundle ' + r.bundleIds[0] : 'Package ' + (r.subIds[0] || '?')))) + '</li>').join('') + '</ul>'
                + '<div class="sgsh-m-warn">' + zh('整包内只要有一项认不出购买项，该行会被跳过。', 'Lines whose purchase option cannot be resolved will be skipped.') + '</div>',
            buttons: [
                { label: zh('取消', 'Cancel') },
                { label: zh('确认暂存 ' + rows.length + ' 项', 'Stash ' + rows.length), primary: true, act: async () => { await doShelveRows(rows.map((r) => ({ row: r, rec: null }))); } },
            ],
        });
    }

    async function doShelveRows(items) {
        if (busy) return false;
        busy = true;
        let done = 0;
        let fail = 0;
        try {
            const index = await buildCartIndex();
            if (!index.ok) { toast(index.error, 'error'); return false; }
            for (let i = 0; i < items.length; i++) {
                const it = items[i];
                let rec = it.rec;
                if (!rec) {
                    const t = classifyRow(it.row, index)
                        || (it.row.appids.length === 1
                            ? { kind: 'app', id: num(it.row.appids[0]), name: '', lineItemId: null, how: zh('单个商品', 'single app') }
                            : null);
                    if (!t) { fail++; continue; }
                    rec = buildRecord(it.row, t);
                }
                setBusy(zh('正在暂存 ' + (done + fail + 1) + '/' + items.length + '：', 'Stashing ') + displayName(rec));
                let btn = it.row.removeBtn;
                if (!btn || !btn.isConnected) btn = removeActionEl(it.row.rowEl);
                if (!btn || !btn.isConnected) {
                    const again = scanCartRows().find((r) => rowKey(r) === rowKey(it.row));
                    btn = again && (again.removeBtn || removeActionEl(again.rowEl));
                }
                if (!btn || !btn.isConnected) { fail++; continue; }
                try { btn.click(); } catch (e) { fail++; continue; }
                putItem(rec, { silent: true });
                done++;
                await sleep(CFG.SHELVE_STEP_MS);
            }
        } finally {
            busy = false;
            setBusy('');
            emitChange();
        }
        if (done) toast(zh('已暂存 <b>', 'Stashed <b>') + done + '</b> ' + zh('项', 'items'), 'success');
        if (fail) toast(zh('有 <b>', '<b>') + fail + '</b> ' + zh('项未暂存（找不到移除按钮或认不出购买项）', 'items not stashed (no remove button / unresolvable)'), 'warning');
        if (done) setTimeout(() => { try { location.reload(); } catch (e) { /* ignore */ } }, 700);
        return done > 0;
    }

    // ==================== 公开：新增记录 ====================
    async function resolveName(appid) {
        if (Host && typeof Host.resolveName === 'function') {
            try { const n = await Host.resolveName(appid); if (n) return n; } catch (e) { /* ignore */ }
        }
        try {
            const items = await fetchStoreItems([{ appid: num(appid) }]);
            if (items[0] && items[0].name) return items[0].name;
        } catch (e) { /* ignore */ }
        return '';
    }

    /** 统一入口：{kind, appid/bundleid/packageid, url, title, note, tags, endTs, pct} */
    async function addItem(input) {
        const inp = Object.assign({}, input || {});
        let kind = inp.kind;
        if (!kind) {
            if (inp.url) kind = 'note';
            else if (inp.bundleid) kind = 'bundle';
            else if (inp.packageid) kind = 'package';
            else kind = inp.appid ? 'app' : 'note';
        }
        const rec = normalizeRecord({
            id: inp.id || uid('sh'),
            kind: kind,
            appid: inp.appid != null ? num(inp.appid) : null,
            bundleid: inp.bundleid != null ? num(inp.bundleid) : null,
            packageid: inp.packageid != null ? num(inp.packageid) : null,
            appids: Array.isArray(inp.appids) ? inp.appids : (inp.appid ? [num(inp.appid)] : []),
            names: inp.names || {},
            targetName: inp.title || inp.name || '',
            displayName: inp.title || inp.name || '',
            note: inp.note || '',
            url: inp.url || '',
            tags: inp.tags || [],
            endTs: num(inp.endTs),
            pct: num(inp.pct),
            price: num(inp.price),
            currency: inp.currency || '',
            source: inp.source || 'manual',
            steamid: currentSteamId(),
            addedAt: now(),
            removedAt: now(),
        }, bucketOf(kind));

        if (isInteropKind(kind) && !rec.appid && !rec.bundleid && !rec.packageid) {
            toast(zh('缺少商品 ID，未保存', 'Missing product id'), 'warning');
            return null;
        }
        // 名称补全（app/wishlist 且未命名）
        if (!rec.displayName && (kind === 'app' || kind === 'wishlist') && rec.appid) {
            rec.displayName = await resolveName(rec.appid);
            if (rec.displayName) rec.targetName = rec.displayName;
        }
        const saved = putItem(rec);
        if (saved) toast(zh('已加入暂存箱：', 'Added to shelf: ') + displayName(saved), 'success');
        return saved;
    }

    function addWishlist(appid, name, note) { return addItem({ kind: 'wishlist', appid: appid, title: name, note: note, source: 'wishlist' }); }
    function addNote(url, title, note, tags) { return addItem({ kind: 'note', url: url, title: title, note: note, tags: tags, source: 'manual' }); }

    // ==================== 导入 / 导出 ====================
    function buildExport(opts) {
        const o = opts || {};
        let items = allItems();
        if (o.compatOnly) items = items.filter((r) => isInteropKind(r.kind));
        const interopRaw = readRaw(CFG.INTEROP_KEY) || {};
        return {
            format: 'sglv-shelf',
            version: 2,
            exportedAt: now(),
            source: 'SGLV 暂存箱',
            compatOnly: !!o.compatOnly,
            counts: {
                cart: items.filter((r) => isInteropKind(r.kind)).length,
                wishlist: items.filter((r) => r.kind === 'wishlist').length,
                note: items.filter((r) => r.kind === 'note').length,
            },
            days: typeof interopRaw.days === 'number' ? interopRaw.days : 3,
            items: items,
        };
    }

    /**
     * 导入：兼容三种形态
     *   a) 本库导出体 {format:'sglv-shelf', items:[...]}
     *   b) SCE 原样体 {items:[...], days, tab}
     *   c) 裸数组 [...]
     * 返回 {added, updated, skipped}
     */
    function parseImport(text) {
        let data = null;
        try { data = JSON.parse(String(text || '').trim()); }
        catch (e) { return { ok: false, error: zh('JSON 解析失败：', 'JSON parse failed: ') + (e.message || e) }; }
        let list = null;
        if (Array.isArray(data)) list = data;
        else if (data && Array.isArray(data.items)) list = data.items;
        if (!list) return { ok: false, error: zh('没有找到 items 数组', 'No items array found') };

        let added = 0;
        let updated = 0;
        let skipped = 0;
        const interopNew = [];
        const extraNew = [];
        list.forEach((raw) => {
            if (!raw || typeof raw !== 'object') { skipped++; return; }
            const kind = resolveKind(raw);
            const bucket = bucketOf(kind);
            // 互通桶必须自带 id：SCE 读取时会丢弃无 id 的记录，
            // 放进去等于「导入成功但下次 SCE 保存时静默消失」
            if (bucket === 'interop' && !raw.id) { skipped++; return; }
            const rec = normalizeRecord(raw, bucket);
            if (bucket === 'interop' && !sceAcceptable(raw)) { skipped++; return; }
            if (bucket === 'interop') interopNew.push(rec); else extraNew.push(rec);
        });
        if (interopNew.length) {
            const cur = readBucket('interop').items;
            interopNew.forEach((rec) => {
                const idx = cur.findIndex((x) => sameTarget(x, rec));
                if (idx >= 0) { cur[idx] = Object.assign({}, cur[idx], rec, { id: cur[idx].id }); updated++; }
                else { cur.unshift(rec); added++; }
            });
            writeBucket('interop', cur);
        }
        if (extraNew.length) {
            const cur = readBucket('extra').items;
            extraNew.forEach((rec) => {
                const idx = cur.findIndex((x) => sameTarget(x, rec));
                if (idx >= 0) { cur[idx] = Object.assign({}, cur[idx], rec, { id: cur[idx].id }); updated++; }
                else { cur.unshift(rec); added++; }
            });
            writeBucket('extra', cur);
        }
        emitChange();
        return { ok: true, added: added, updated: updated, skipped: skipped };
    }

    /** 去重比较：同 kind 同 id 视为同一条（id 不同也不重复入库） */
    function sameTarget(a, b) {
        if (!a || !b) return false;
        if (a.id && b.id && a.id === b.id) return true;
        if (a.kind !== b.kind) return false;
        if (a.kind === 'bundle') return !!a.bundleid && String(a.bundleid) === String(b.bundleid);
        if (a.kind === 'package') return !!a.packageid && String(a.packageid) === String(b.packageid);
        if (a.kind === 'note') return !!a.url && a.url === b.url;
        return !!a.appid && String(a.appid) === String(b.appid);
    }

    // ==================== UI：浮窗 ====================
    let overlayEl = null;
    let panelEl = null;
    let modalEl = null;
    let modalOnClose = null;
    let tickTimer = null;
    let isOpenFlag = false;
    let uiState = { filter: 'all', sort: 'end', q: '', compatOnly: false };

    /* =================================================================
     * CSS —— steam-industrial token 体系
     * 参考 steam-industrial-theme.css（oil-ui 方法论）：
     *   高信息密度 · 小圆角(工业风) · 左侧色条强调 · 斑马纹列表 · 大写小标签
     * 表面/文字用 Steam 原生 #171a21 色阶（dark/purple 主题下均稳定）；
     * 强调色走 var(--sglv-accent)，跟随主脚本主题切换（color-mix 派生阶）。
     * ============================================================== */
    const CSS = `
/* ---------- 0. Design Tokens（作用域：浮窗 / 弹窗 / 购物车行内按钮） ---------- */
.sgsh-panel,.sgsh-modal,.sgsh-shelve-btn{
  /* 表面 */
  --sgsh-bg:#171a21; --sgsh-bg-2:#1b2838; --sgsh-bg-3:#2a3040; --sgsh-bg-4:#333c4e;
  --sgsh-border:#3d4450; --sgsh-border-2:#2a3040;
  /* 文字 */
  --sgsh-text:#c6d4df; --sgsh-text-2:#8f98a0; --sgsh-text-3:#5c6b7a; --sgsh-heading:#e5e9ed;
  /* 强调（跟随主题） */
  --sgsh-accent:var(--sglv-accent,#66c0f4);
  --sgsh-accent-wash:color-mix(in srgb,var(--sgsh-accent) 8%,transparent);
  --sgsh-accent-soft:color-mix(in srgb,var(--sgsh-accent) 16%,transparent);
  --sgsh-accent-line:color-mix(in srgb,var(--sgsh-accent) 42%,transparent);
  /* 语义色 */
  --sgsh-gold:#ffb74c; --sgsh-gold-text:#d4a853;
  --sgsh-red:#d94a4a; --sgsh-red-text:#e07070;
  --sgsh-red-wash:color-mix(in srgb,var(--sgsh-red) 14%,transparent);
  --sgsh-red-line:color-mix(in srgb,var(--sgsh-red) 42%,transparent);
  --sgsh-green:#7ba82a; --sgsh-sky:#7dd3fc;
  /* 刻度 */
  --sgsh-r:3px; --sgsh-ease:150ms ease;
}

/* ---------- 1. 窗体 ---------- */
.sgsh-overlay { background: rgba(8,11,17,0.72) !important; }
.sgsh-panel { width: 920px !important; height: 82vh !important;
  background: var(--sgsh-bg) !important;
  border: 1px solid var(--sgsh-border) !important;
  border-radius: 4px !important;
  box-shadow: 0 18px 60px rgba(0,0,0,.55) !important; }
.sgsh-panel .sglv-header { background: var(--sgsh-bg-2) !important;
  border-bottom: 1px solid var(--sgsh-border); }

/* ---------- 2. 头部 ---------- */
.sgsh-head { display:flex; align-items:center; gap:10px; }
.sgsh-head-icon { width:24px; height:24px; display:flex; align-items:center; justify-content:center;
  background: var(--sgsh-accent-wash); border:1px solid var(--sgsh-accent-line);
  border-radius: var(--sgsh-r); color: var(--sgsh-accent); font-size:13px; }
.sgsh-head-title { font-size:14px; font-weight:600; color:var(--sgsh-heading); letter-spacing:.3px; }
.sgsh-count { min-width:22px; height:18px; padding:0 7px; border-radius:2px; font-size:11px; font-weight:700;
  display:inline-flex; align-items:center; justify-content:center;
  color:var(--sgsh-gold-text); background:rgba(255,183,76,.12); border:1px solid rgba(255,183,76,.35);
  font-variant-numeric:tabular-nums; }

/* ---------- 3. 按钮（扁平 + 描边） ---------- */
.sgsh-btn { border:1px solid var(--sgsh-border-2); border-radius:var(--sgsh-r); padding:5px 11px;
  font-size:11px; font-weight:600; letter-spacing:.3px; cursor:pointer;
  background:var(--sgsh-bg-3); color:var(--sgsh-text); display:inline-flex; align-items:center; gap:5px;
  transition:color var(--sgsh-ease), background var(--sgsh-ease), border-color var(--sgsh-ease); }
.sgsh-btn:hover { background:var(--sgsh-bg-4); color:var(--sgsh-heading); border-color:var(--sgsh-border); }
.sgsh-btn.primary { background:var(--sgsh-accent-soft); border-color:var(--sgsh-accent-line); color:var(--sgsh-accent); }
.sgsh-btn.primary:hover { background:color-mix(in srgb,var(--sgsh-accent) 26%,transparent); border-color:var(--sgsh-accent); }
.sgsh-btn.danger { background:transparent; border-color:var(--sgsh-red-line); color:var(--sgsh-red-text); }
.sgsh-btn.danger:hover { background:var(--sgsh-red-wash); color:#fff; }
.sgsh-btn:disabled { opacity:.4; cursor:not-allowed; }

/* ---------- 4. 工具栏（搜索 / 筛选 / 排序） ---------- */
.sgsh-toolbar { display:flex; align-items:center; gap:10px; padding:10px 14px; flex-shrink:0;
  border-bottom:1px solid var(--sgsh-border-2); background:var(--sgsh-bg); flex-wrap:wrap; }
.sgsh-search { flex:1; min-width:160px; padding:6px 10px; border-radius:var(--sgsh-r); font-size:12px;
  background:var(--sgsh-bg-2); border:1px solid var(--sgsh-border-2); color:var(--sgsh-text); outline:none;
  transition:border-color var(--sgsh-ease), box-shadow var(--sgsh-ease); }
.sgsh-search::placeholder { color:var(--sgsh-text-3); }
.sgsh-search:focus { border-color:var(--sgsh-accent-line); box-shadow:0 0 0 1px var(--sgsh-accent-wash); }
.sgsh-chips { display:flex; gap:4px; }
.sgsh-chip { border:1px solid var(--sgsh-border-2); background:transparent; color:var(--sgsh-text-2);
  border-radius:var(--sgsh-r); padding:4px 11px; font-size:11px; font-weight:600; cursor:pointer;
  transition:color var(--sgsh-ease), background var(--sgsh-ease), border-color var(--sgsh-ease); }
.sgsh-chip:hover { color:var(--sgsh-text); border-color:var(--sgsh-border); }
.sgsh-chip.active { background:var(--sgsh-accent-soft); color:var(--sgsh-accent); border-color:var(--sgsh-accent-line); }
.sgsh-sort { padding:6px 9px; border-radius:var(--sgsh-r); font-size:11px; background:var(--sgsh-bg-2);
  border:1px solid var(--sgsh-border-2); color:var(--sgsh-text); outline:none; cursor:pointer;
  transition:border-color var(--sgsh-ease); }
.sgsh-sort:focus { border-color:var(--sgsh-accent-line); }

/* ---------- 5. 摘要条 ---------- */
.sgsh-summary { padding:7px 14px; font-size:11px; color:var(--sgsh-text-2); border-bottom:1px solid var(--sgsh-border-2);
  display:flex; align-items:center; gap:12px; flex-shrink:0; font-variant-numeric:tabular-nums; }
.sgsh-summary b { color:var(--sgsh-accent); }
.sgsh-busy { color:var(--sgsh-gold-text); font-weight:600; }

/* ---------- 6. 列表（斑马纹 + 左侧色条强调，替代卡片流） ---------- */
.sgsh-body { flex:1; overflow-y:auto; padding:8px 14px 12px; }
.sgsh-body::-webkit-scrollbar { width:6px; }
.sgsh-body::-webkit-scrollbar-track { background:transparent; }
.sgsh-body::-webkit-scrollbar-thumb { background:var(--sgsh-border-2); border-radius:3px; }
.sgsh-body::-webkit-scrollbar-thumb:hover { background:var(--sgsh-border); }
.sgsh-row { display:flex; align-items:flex-start; gap:10px; padding:9px 12px 9px 9px;
  border-left:3px solid transparent; border-bottom:1px solid var(--sgsh-border-2);
  transition:background var(--sgsh-ease), border-color var(--sgsh-ease); }
.sgsh-row:first-child { border-top:1px solid var(--sgsh-border-2); }
.sgsh-row:nth-child(odd) { background:rgba(255,255,255,.02); }
.sgsh-row:hover { background:var(--sgsh-accent-wash); border-left-color:var(--sgsh-accent); }
.sgsh-row.is-foreign { border-left-color:var(--sgsh-red); }
.sgsh-kindtag { flex-shrink:0; font-size:9px; font-weight:700; padding:2px 6px; border-radius:2px;
  letter-spacing:.8px; text-transform:uppercase;
  background:var(--sgsh-accent-wash); color:var(--sgsh-accent); border:1px solid var(--sgsh-accent-line); margin-top:1px; }
.sgsh-kindtag.wishlist { background:rgba(125,211,252,.1); color:var(--sgsh-sky); border-color:rgba(125,211,252,.32); }
.sgsh-kindtag.note { background:rgba(255,183,76,.1); color:var(--sgsh-gold-text); border-color:rgba(255,183,76,.32); }
.sgsh-main { flex:1; min-width:0; }
.sgsh-name { font-size:13px; font-weight:600; color:var(--sgsh-heading);
  overflow:hidden; text-overflow:ellipsis; white-space:nowrap; }
.sgsh-meta { display:flex; flex-wrap:wrap; gap:8px; margin-top:3px; font-size:10.5px; color:var(--sgsh-text-2);
  font-variant-numeric:tabular-nums; }
.sgsh-meta .sev1 { color:var(--sgsh-red-text); font-weight:600; }
.sgsh-meta .sev2 { color:var(--sgsh-gold-text); font-weight:600; }
.sgsh-meta .sev3 { color:var(--sgsh-green); }
.sgsh-meta .sgsh-warn { color:var(--sgsh-gold-text); }
.sgsh-note { margin-top:4px; font-size:11px; color:var(--sgsh-text-2); background:rgba(255,255,255,.03);
  border-left:2px solid var(--sgsh-accent-line); padding:4px 8px;
  border-radius:0 var(--sgsh-r) var(--sgsh-r) 0; word-break:break-all; }
.sgsh-acts { display:flex; gap:4px; flex-shrink:0; }
.sgsh-act { width:26px; height:26px; border-radius:var(--sgsh-r); border:1px solid var(--sgsh-border-2);
  background:transparent; color:var(--sgsh-text-2); cursor:pointer; font-size:12px; line-height:1;
  display:flex; align-items:center; justify-content:center;
  transition:color var(--sgsh-ease), background var(--sgsh-ease), border-color var(--sgsh-ease); }
.sgsh-act:hover { background:var(--sgsh-accent-soft); color:var(--sgsh-accent); border-color:var(--sgsh-accent-line); }
.sgsh-act.del:hover { background:var(--sgsh-red-wash); color:var(--sgsh-red-text); border-color:var(--sgsh-red-line); }
.sgsh-act:disabled { opacity:.35; cursor:not-allowed; }
.sgsh-empty { text-align:center; padding:50px 20px; color:var(--sgsh-text-3); font-size:12px; line-height:1.9; }
.sgsh-foot { display:flex; align-items:center; gap:8px; padding:10px 14px;
  border-top:1px solid var(--sgsh-border); background:var(--sgsh-bg-2); flex-shrink:0; }
.sgsh-foot .sp { flex:1; }

/* ---------- 7. 购物车页行内暂存按钮 ---------- */
.sgsh-shelve-btn { margin:0 6px; padding:2px 9px; font-size:10px; font-weight:700; letter-spacing:.5px;
  cursor:pointer; border-radius:2px; border:1px solid var(--sgsh-accent-line);
  background:var(--sgsh-accent-wash); color:var(--sgsh-accent);
  transition:background var(--sgsh-ease), color var(--sgsh-ease), border-color var(--sgsh-ease); }
.sgsh-shelve-btn:hover { background:var(--sgsh-accent-soft); border-color:var(--sgsh-accent); color:var(--sgsh-accent); }

/* ---------- 8. 弹窗 ---------- */
.sgsh-modal-mask { position:fixed; inset:0; z-index:1000001; background:rgba(8,11,17,.7);
  display:flex; align-items:center; justify-content:center; }
.sgsh-modal { width:520px; max-width:calc(100vw - 40px); max-height:82vh; display:flex; flex-direction:column;
  background:var(--sgsh-bg); border:1px solid var(--sgsh-border);
  border-radius:4px; box-shadow:0 18px 60px rgba(0,0,0,.6); overflow:hidden; }
.sgsh-modal-head { padding:12px 16px; font-size:13px; font-weight:600; color:var(--sgsh-heading);
  background:var(--sgsh-bg-2); border-bottom:1px solid var(--sgsh-border);
  display:flex; align-items:center; letter-spacing:.3px; }
.sgsh-modal-body { padding:14px 16px; overflow-y:auto; font-size:12px; color:var(--sgsh-text); line-height:1.7; }
.sgsh-modal-foot { padding:11px 16px; border-top:1px solid var(--sgsh-border-2);
  display:flex; gap:8px; justify-content:flex-end; }
.sgsh-m-lead { margin-bottom:9px; color:var(--sgsh-text); }
.sgsh-m-lead b { color:var(--sgsh-accent); font-variant-numeric:tabular-nums; }
.sgsh-m-warn { margin-top:9px; padding:7px 10px; border-radius:0 var(--sgsh-r) var(--sgsh-r) 0; font-size:11px;
  background:rgba(255,183,76,.07); border-left:2px solid var(--sgsh-gold);
  color:var(--sgsh-gold-text); line-height:1.5; }
.sgsh-m-list { margin:6px 0 0; padding-left:18px; max-height:220px; overflow-y:auto; }
.sgsh-m-line { display:flex; flex-direction:column; padding:5px 0; border-bottom:1px dashed var(--sgsh-border-2); }
.sgsh-m-line span { color:var(--sgsh-text-2); font-size:11px; word-break:break-all; }

/* ---------- 9. 表单 ---------- */
.sgsh-field { margin-bottom:11px; }
.sgsh-field label { display:block; font-size:10px; color:var(--sgsh-text-2); margin-bottom:5px; font-weight:700;
  text-transform:uppercase; letter-spacing:.6px; }
.sgsh-field input, .sgsh-field textarea, .sgsh-field select { width:100%; box-sizing:border-box; padding:7px 10px;
  border-radius:var(--sgsh-r); font-size:12px; background:var(--sgsh-bg-2);
  border:1px solid var(--sgsh-border-2); color:var(--sgsh-text); outline:none; font-family:inherit;
  transition:border-color var(--sgsh-ease); }
.sgsh-field textarea { min-height:110px; resize:vertical; font-family:ui-monospace,Menlo,Consolas,monospace; font-size:11px; }
.sgsh-field input:focus, .sgsh-field textarea:focus, .sgsh-field select:focus { border-color:var(--sgsh-accent-line); }
.sgsh-field .hint { font-size:10.5px; color:var(--sgsh-text-3); margin-top:4px; }
.sgsh-check { display:flex; align-items:center; gap:7px; font-size:11.5px; color:var(--sgsh-text-2);
  margin-bottom:10px; cursor:pointer; }
.sgsh-check input { width:auto; }

/* ---------- 10. 侧栏角标：红点，不展示条数（--sgsh-red 只定义在浮窗上，这里写死颜色） ---------- */
.sgsh-badge { position:absolute; top:2px; right:2px; width:7px; height:7px; min-width:0; padding:0;
  display:block; border-radius:50%; background:#e23b3b; box-shadow:0 0 0 1.5px rgba(15,18,24,.9);
  pointer-events:none; font-size:0; line-height:0; color:transparent; overflow:hidden; }
`;

    function ensureCss() {
        if (document.getElementById('sgsh-css')) return;
        const st = document.createElement('style');
        st.id = 'sgsh-css';
        st.textContent = CSS;
        (document.head || document.documentElement).appendChild(st);
    }

    function ensureUI() {
        if (panelEl) return;
        ensureCss();
        overlayEl = document.createElement('div');
        overlayEl.className = 'sglv-overlay sgsh-overlay';
        overlayEl.setAttribute('data-sglv-plugin-ui', '1');
        overlayEl.addEventListener('click', closeShelf);
        document.body.appendChild(overlayEl);

        panelEl = document.createElement('div');
        panelEl.className = 'sglv-panel sgsh-panel';
        panelEl.setAttribute('data-sglv-plugin-ui', '1');
        panelEl.innerHTML = `
<div class="sglv-header">
  <div class="sgsh-head">
    <div class="sgsh-head-icon">📦</div>
    <div class="sgsh-head-title">${zh('暂存箱', 'Shelf')}</div>
    <span class="sgsh-count" id="sgsh-count">0</span>
  </div>
  <div class="sglv-header-actions">
    <button class="sgsh-btn primary" data-act="add">＋ ${zh('新建', 'New')}</button>
    <button class="sgsh-btn" data-act="import">${zh('导入', 'Import')}</button>
    <button class="sgsh-btn" data-act="export">${zh('导出', 'Export')}</button>
    <button class="sglv-header-btn" data-act="close" title="${zh('关闭', 'Close')}">✕</button>
  </div>
</div>
<div class="sgsh-toolbar">
  <input class="sgsh-search" id="sgsh-q" placeholder="${zh('搜索名称 / 备注 / 标签 / ID', 'Search name / note / tag / id')}">
  <div class="sgsh-chips" id="sgsh-chips"></div>
  <select class="sgsh-sort" id="sgsh-sort">
    <option value="end">${zh('按到期时间', 'By expiry')}</option>
    <option value="added">${zh('按加入时间', 'By added')}</option>
    <option value="name">${zh('按名称', 'By name')}</option>
  </select>
  <button class="sgsh-btn" data-act="shelve-cart" id="sgsh-shelve-cart" title="${zh('把购物车全部移入暂存箱', 'Move whole cart into shelf')}">${zh('暂存购物车', 'Stash cart')}</button>
</div>
<div class="sgsh-summary" id="sgsh-summary"></div>
<div class="sgsh-body" id="sgsh-body"></div>
<div class="sgsh-foot">
  <button class="sgsh-btn primary" data-act="restore-all">${zh('全部恢复到购物车', 'Restore all to cart')}</button>
  <button class="sgsh-btn" data-act="prune" title="${zh('清理搁置超过 180 天的记录', 'Prune records shelved >180 days')}">${zh('清理陈旧', 'Prune stale')}</button>
  <span class="sp"></span>
  <span style="font-size:10.5px;color:#5c6b7a" id="sgsh-share"></span>
  <button class="sgsh-btn danger" data-act="clear">${zh('清空', 'Clear')}</button>
</div>`;
        document.body.appendChild(panelEl);

        panelEl.addEventListener('click', onPanelClick);
        panelEl.querySelector('#sgsh-q').addEventListener('input', (e) => { uiState.q = e.target.value; renderList(); });
        panelEl.querySelector('#sgsh-sort').addEventListener('change', (e) => { uiState.sort = e.target.value; setPrefs({ sort: uiState.sort }); renderList(); });

        document.addEventListener('keydown', onKeydown);
        window.addEventListener('storage', onStorage);
        renderChips();
    }

    function onKeydown(e) {
        if (e.key === 'Escape') {
            if (modalEl) { closeModal(); return; }
            if (isOpenFlag) closeShelf();
        }
    }

    /** 跨脚本热更新：SCE 改了互通桶 → 同步角标与列表 */
    function onStorage(e) {
        if (!e || (e.key && e.key !== CFG.INTEROP_KEY && e.key !== CFG.EXTRA_KEY)) return;
        emitChange();
        if (isOpenFlag) render();
    }

    /** 有暂存则亮红点，不把条数写进角标 */
    function setBadge(n) {
        try {
            const on = num(n) > 0;
            document.querySelectorAll('[data-sgsh-badge]').forEach((el) => {
                if (el.textContent) el.textContent = '';
                el.style.display = on ? '' : 'none';
            });
        } catch (e) { /* ignore */ }
    }

    function renderChips() {
        const box = panelEl && panelEl.querySelector('#sgsh-chips');
        if (!box) return;
        box.innerHTML = FILTER_META.map((f) => (
            `<button class="sgsh-chip ${uiState.filter === f.key ? 'active' : ''}" data-filter="${f.key}">${esc(f.label)}</button>`
        )).join('');
    }

    function visibleItems() {
        let list = allItems();
        if (uiState.filter !== 'all') {
            list = list.filter((r) => (KIND_META[r.kind] || {}).tag === uiState.filter);
        }
        const q = uiState.q.trim().toLowerCase();
        if (q) {
            list = list.filter((r) => {
                const hay = [displayName(r), r.note, (r.tags || []).join(' '), r.appid, r.bundleid, r.packageid, r.url]
                    .filter(Boolean).join(' ').toLowerCase();
                return hay.indexOf(q) !== -1;
            });
        }
        const sort = uiState.sort;
        list.sort((a, b) => {
            if (sort === 'name') return displayName(a).localeCompare(displayName(b));
            if (sort === 'added') return (num(b.addedAt) || num(b.removedAt)) - (num(a.addedAt) || num(a.removedAt));
            const ae = num(a.endTs) || Infinity;
            const be = num(b.endTs) || Infinity;
            if (ae !== be) return ae - be;
            return (num(a.addedAt) || num(a.removedAt)) - (num(b.addedAt) || num(b.removedAt));
        });
        return list;
    }

    function rowHtml(rec) {
        const name = displayName(rec);
        const km = KIND_META[rec.kind] || { label: rec.kind, tag: 'cart' };
        const meta = [];
        if (rec.count > 1) meta.push(zh('含 ', 'incl. ') + rec.count + ' ' + zh('项', 'items'));
        if (rec.pct) meta.push('-' + rec.pct + '%');
        if (num(rec.endTs)) {
            const s = severity(rec.endTs);
            meta.push('<span class="sev' + s + '" data-end="' + num(rec.endTs) + '">' + esc(absTime(rec.endTs)) + ' · ' + esc(remainText(rec.endTs)) + '</span>');
        }
        if (rec.price) meta.push((rec.currency || '') + ' ' + rec.price);
        meta.push(rec.source === 'cart' ? zh('来自购物车', 'from cart') : rec.source === 'wishlist' ? zh('来自愿望单', 'from wishlist') : zh('手动', 'manual'));
        if (foreignAccount(rec)) meta.push('<span class="sgsh-warn">' + zh('⚠ 其他账号写入', '⚠ other account') + '</span>');
        if (rec.lastError) meta.push('<span class="sgsh-warn">' + esc(rec.lastError) + '</span>');
        if ((rec.tags || []).length) meta.push('#' + rec.tags.map(esc).join(' #'));

        const acts = [];
        if (canRestore(rec)) acts.push('<button class="sgsh-act" data-act="restore" title="' + zh('恢复到购物车', 'Restore to cart') + '">↩</button>');
        const url = linkOf(rec);
        if (url) acts.push('<button class="sgsh-act" data-act="open" title="' + zh('打开链接', 'Open link') + '">↗</button>');
        if (rec.url) acts.push('<button class="sgsh-act" data-act="copy" title="' + zh('复制链接', 'Copy link') + '">⧉</button>');
        acts.push('<button class="sgsh-act" data-act="edit" title="' + zh('编辑', 'Edit') + '">✎</button>');
        acts.push('<button class="sgsh-act del" data-act="del" title="' + zh('删除', 'Delete') + '">×</button>');

        return `<div class="sgsh-row ${foreignAccount(rec) ? 'is-foreign' : ''}" data-id="${esc(rec.id)}">
  <div class="sgsh-kindtag ${km.tag}">${esc(km.label)}</div>
  <div class="sgsh-main">
    <div class="sgsh-name" title="${esc(name)}">${esc(name)}</div>
    <div class="sgsh-meta">${meta.join('<span>·</span>')}</div>
    ${rec.note ? '<div class="sgsh-note">' + esc(rec.note) + '</div>' : ''}
  </div>
  <div class="sgsh-acts">${acts.join('')}</div>
</div>`;
    }

    function renderList() {
        const body = panelEl && panelEl.querySelector('#sgsh-body');
        if (!body) return;
        const list = visibleItems();
        const total = countAll();
        const cnt = panelEl.querySelector('#sgsh-count');
        if (cnt) cnt.textContent = String(total);
        const share = panelEl.querySelector('#sgsh-share');
        if (share) {
            const nInterop = readBucket('interop').items.length;
            share.textContent = zh('与购物车增强互通 ', 'shared with cart script: ') + nInterop + ' · ' + zh('独享 ', 'private: ') + (total - nInterop);
        }
        const restoreable = list.filter(canRestore).length;
        const soonest = list.filter((r) => num(r.endTs)).sort((a, b) => a.endTs - b.endTs)[0];
        const sum = panelEl.querySelector('#sgsh-summary');
        if (sum) {
            sum.innerHTML = `<span>${zh('共 ', 'Total ') + '<b>' + list.length + '</b>' + (list.length !== total ? zh('（全部 ' + total + '）', ' of ' + total) : '')}</span>`
                + `<span>${zh('可恢复 ', 'Restorable ') + '<b>' + restoreable + '</b>'}</span>`
                + (soonest ? `<span>${zh('最近到期 ', 'Next expiry ') + '<b>' + esc(remainText(soonest.endTs)) + '</b></span>'}` : '')
                + (busy ? `<span class="sgsh-busy">${esc(busyText)}</span>` : '');
        }
        const cartBtn = panelEl.querySelector('#sgsh-shelve-cart');
        if (cartBtn) {
            cartBtn.style.display = onCartPage() ? '' : 'none';
            cartBtn.disabled = busy;
        }
        const restoreAllBtn = panelEl.querySelector('[data-act="restore-all"]');
        if (restoreAllBtn) restoreAllBtn.disabled = busy || restoreable === 0;
        if (!list.length) {
            body.innerHTML = `<div class="sgsh-empty">📦<br>${total
                ? zh('没有符合当前筛选的记录', 'No record matches the filter')
                : zh('暂存箱是空的。<br>在购物车页点行内「暂存」、或用右上角「＋ 新建」记录备忘与外部链接。', 'Shelf is empty.<br>Use the row-level “Stash” on /cart, or “＋ New” to save notes and links.')}</div>`;
            return;
        }
        body.innerHTML = list.map(rowHtml).join('');
    }

    function render() { renderList(); }

    function setBusy(text) {
        busyText = text || '';
        if (isOpenFlag) renderList();
    }

    function openShelf() {
        if (!_hostReady) { toast(zh('暂存箱模块未就绪', 'Shelf module not ready'), 'warning'); return; }
        ensureUI();
        const p = getPrefs();
        uiState.filter = p.filter;
        uiState.sort = p.sort;
        uiState.compatOnly = p.compatOnly;
        isOpenFlag = true;
        overlayEl.classList.add('sglv-show');
        panelEl.classList.add('sglv-show');
        const q = panelEl.querySelector('#sgsh-q');
        if (q) q.value = uiState.q;
        const s = panelEl.querySelector('#sgsh-sort');
        if (s) s.value = uiState.sort;
        renderChips();
        renderList();
        startTick();
        injectCartButtons();
    }

    function closeShelf() {
        if (!panelEl) return;
        isOpenFlag = false;
        stopTick();
        closeModal();
        overlayEl.classList.remove('sglv-show');
        panelEl.classList.remove('sglv-show');
    }

    function isOpen() { return isOpenFlag; }

    function toggleShelf() { if (isOpenFlag) closeShelf(); else openShelf(); }

    function startTick() {
        stopTick();
        tickTimer = setInterval(() => {
            if (!isOpenFlag) { stopTick(); return; }
            const nodes = document.querySelectorAll('#sgsh-body [data-end]');
            for (let i = 0; i < nodes.length; i++) {
                const el = nodes[i];
                const ts = num(el.getAttribute('data-end'));
                const cls = 'sev' + severity(ts);
                if (el.className !== cls) el.className = cls;
                const txt = absTime(ts) + ' · ' + remainText(ts);
                if (el.textContent !== txt) el.textContent = txt;
            }
        }, CFG.TICK_MS);
    }
    function stopTick() { if (tickTimer) { clearInterval(tickTimer); tickTimer = null; } }

    // ==================== 弹窗 ====================
    function showModal(opts) {
        const o = opts || {};
        closeModal();
        modalOnClose = o.onClose || null;
        const mask = document.createElement('div');
        mask.className = 'sgsh-modal-mask';
        mask.setAttribute('data-sglv-plugin-ui', '1');
        const buttons = (o.buttons || [{ label: zh('关闭', 'Close'), primary: true }]).map((b, i) => (
            `<button class="sgsh-btn ${b.primary ? 'primary' : ''} ${b.danger ? 'danger' : ''}" data-mi="${i}">${esc(b.label)}</button>`
        )).join('');
        mask.innerHTML = `<div class="sgsh-modal">
  <div class="sgsh-modal-head">${esc(o.title || '')}</div>
  <div class="sgsh-modal-body">${o.body || ''}</div>
  <div class="sgsh-modal-foot">${buttons}</div>
</div>`;
        mask.addEventListener('click', (e) => { if (e.target === mask && o.maskClose !== false) closeModal(); });
        mask.querySelector('.sgsh-modal-foot').addEventListener('click', async (e) => {
            const b = e.target.closest('[data-mi]');
            if (!b) return;
            const def = (o.buttons || [])[Number(b.getAttribute('data-mi'))];
            if (def && typeof def.act === 'function') {
                b.disabled = true;
                try { await def.act(); } catch (err) { console.warn('[SGLVShelf] 弹窗动作失败', err); }
                b.disabled = false;
            }
            if (!def || def.keep !== true) closeModal();
        });
        document.body.appendChild(mask);
        modalEl = mask;
        return mask;
    }

    function closeModal() {
        if (!modalEl) return;
        modalEl.remove();
        modalEl = null;
        const cb = modalOnClose;
        modalOnClose = null;
        if (cb) { try { cb(); } catch (e) { /* ignore */ } }
    }

    function showConfirm(title, lead, okLabel, act) {
        showModal({
            title: title,
            body: '<div class="sgsh-m-lead">' + lead + '</div>',
            buttons: [
                { label: zh('取消', 'Cancel') },
                { label: okLabel, primary: true, act: act },
            ],
        });
    }

    function copyText(txt) {
        try {
            if (navigator.clipboard && navigator.clipboard.writeText) { navigator.clipboard.writeText(txt); return true; }
        } catch (e) { /* ignore */ }
        try {
            const ta = document.createElement('textarea');
            ta.value = txt;
            ta.style.position = 'fixed';
            ta.style.opacity = '0';
            document.body.appendChild(ta);
            ta.select();
            document.execCommand('copy');
            ta.remove();
            return true;
        } catch (e) { return false; }
    }

    // ==================== 交互分发 ====================
    function onPanelClick(e) {
        const chip = e.target.closest('[data-filter]');
        if (chip) {
            uiState.filter = chip.getAttribute('data-filter');
            setPrefs({ filter: uiState.filter });
            renderChips();
            renderList();
            return;
        }
        const actBtn = e.target.closest('[data-act]');
        if (!actBtn) return;
        const act = actBtn.getAttribute('data-act');
        const rowEl = actBtn.closest('.sgsh-row');
        const id = rowEl ? rowEl.getAttribute('data-id') : null;
        const rec = id ? getItem(id) : null;

        switch (act) {
            case 'close': closeShelf(); break;
            case 'add': showEditModal(null); break;
            case 'edit': if (rec) showEditModal(rec); break;
            case 'restore': if (rec) executeRestore([rec.id]); break;
            case 'restore-all': {
                const ids = visibleItems().filter(canRestore).map((r) => r.id);
                if (!ids.length) { toast(zh('没有可恢复的记录', 'Nothing to restore'), 'warning'); break; }
                showConfirm(zh('全部恢复', 'Restore all'), zh('将把 <b>', 'Restores <b>') + ids.length + '</b> ' + zh('项恢复到购物车。', 'items back into the cart.'), zh('确认恢复', 'Restore'), () => executeRestore(ids));
                break;
            }
            case 'open': {
                const u = rec ? linkOf(rec) : '';
                if (!u) break;
                if (Host && typeof Host.openUrl === 'function') { try { Host.openUrl(u); break; } catch (err) { /* fallthrough */ } }
                window.open(u, '_blank', 'noopener');
                break;
            }
            case 'copy':
                if (rec && rec.url) toast(copyText(rec.url) ? zh('链接已复制', 'Link copied') : zh('复制失败', 'Copy failed'), copyText(rec.url) ? 'success' : 'error');
                break;
            case 'del':
                if (rec) showConfirm(zh('删除这条暂存？', 'Delete this record?'), zh('将从暂存箱移除 <b>', 'Removes <b>') + esc(displayName(rec)) + '</b>。', zh('删除', 'Delete'), () => {
                    deleteItem(rec.id);
                    toast(zh('已删除', 'Deleted'), 'success');
                });
                break;
            case 'clear': {
                const n = countAll();
                if (!n) { toast(zh('暂存箱已经是空的', 'Shelf is already empty'), 'warning'); break; }
                showConfirm(zh('清空暂存箱', 'Clear shelf'), zh('将删除全部 <b>', 'Deletes all <b>') + n + '</b> ' + zh('条记录（含与购物车增强互通的）。此操作不可撤销，建议先导出。', 'records (including shared ones). This cannot be undone — export first.'), zh('确认清空', 'Clear all'), () => {
                    writeBucket('interop', []);
                    writeBucket('extra', []);
                    emitChange();
                    toast(zh('暂存箱已清空', 'Shelf cleared'), 'success');
                });
                break;
            }
            case 'prune': {
                const n = pruneStale(CFG.STALE_DAYS);
                toast(n ? zh('已清理 ', 'Pruned ') + n + zh(' 条陈旧记录', ' stale records') : zh('没有超过 ' + CFG.STALE_DAYS + ' 天的记录', 'Nothing older than ' + CFG.STALE_DAYS + ' days'), n ? 'success' : 'info');
                break;
            }
            case 'export': showExportModal(); break;
            case 'import': showImportModal(); break;
            case 'shelve-cart': shelveAllRows(); break;
            default: break;
        }
    }

    // ---- 新建 / 编辑 ----
    function showEditModal(rec) {
        const isNew = !rec;
        const kind = rec ? rec.kind : 'note';
        const kinds = ['note', 'app', 'wishlist', 'bundle', 'package'];
        const opt = (k) => `<option value="${k}" ${k === kind ? 'selected' : ''}>${esc((KIND_META[k] || {}).label || k)}</option>`;
        showModal({
            title: isNew ? zh('新建暂存', 'New shelf entry') : zh('编辑暂存', 'Edit shelf entry'),
            body: `
<div class="sgsh-field"><label>${zh('类型', 'Kind')}</label><select id="f-kind">${kinds.map(opt).join('')}</select>
  <div class="hint">${zh('单品/捆绑包/购买包会写入与「购物车增强」互通的存储；愿望单与备忘由本库独享。', 'app/bundle/package go to the bucket shared with the cart script; wishlist/note are private.')}</div></div>
<div class="sgsh-field"><label>${zh('名称 / 标题', 'Name / title')}</label><input id="f-title" value="${esc(rec ? (rec.displayName || rec.targetName || '') : '')}" placeholder="${zh('例如： summer sale 备忘', 'e.g. summer sale memo')}"></div>
<div class="sgsh-field" id="wrap-app"><label>AppID</label><input id="f-appid" inputmode="numeric" value="${esc(rec && rec.appid ? rec.appid : '')}"></div>
<div class="sgsh-field" id="wrap-bundle"><label>BundleID</label><input id="f-bundleid" inputmode="numeric" value="${esc(rec && rec.bundleid ? rec.bundleid : '')}"></div>
<div class="sgsh-field" id="wrap-package"><label>PackageID (sub)</label><input id="f-packageid" inputmode="numeric" value="${esc(rec && rec.packageid ? rec.packageid : '')}"></div>
<div class="sgsh-field" id="wrap-url"><label>${zh('链接', 'Link')}</label><input id="f-url" value="${esc(rec && rec.url ? rec.url : '')}" placeholder="https://"></div>
<div class="sgsh-field"><label>${zh('备注', 'Note')}</label><textarea id="f-note" placeholder="${zh('为什么暂存、什么时候提醒自己买…', 'Why you stashed it, when to buy…')}">${esc(rec ? rec.note : '')}</textarea></div>
<div class="sgsh-field"><label>${zh('标签（空格分隔）', 'Tags (space separated)')}</label><input id="f-tags" value="${esc(rec && rec.tags ? rec.tags.join(' ') : '')}"></div>
<div class="sgsh-field"><label>${zh('折扣到期时间戳（毫秒，可空）', 'Discount end timestamp (ms, optional)')}</label><input id="f-endts" inputmode="numeric" value="${esc(rec && rec.endTs ? rec.endTs : '')}">
  <div class="hint">${zh('填了就会在列表里倒计时并按到期排序', 'Enables countdown and expiry sorting')}</div></div>`,
            buttons: [
                { label: zh('取消', 'Cancel') },
                {
                    label: isNew ? zh('加入暂存箱', 'Add') : zh('保存', 'Save'), primary: true, keep: true, act: async () => {
                        const g = (id) => { const el = document.getElementById(id); return el ? el.value.trim() : ''; };
                        const k = g('f-kind');
                        const payload = {
                            kind: k,
                            title: g('f-title'),
                            appid: num(g('f-appid')) || null,
                            bundleid: num(g('f-bundleid')) || null,
                            packageid: num(g('f-packageid')) || null,
                            url: g('f-url'),
                            note: g('f-note'),
                            tags: g('f-tags').split(/\s+/).filter(Boolean),
                            endTs: num(g('f-endts')),
                            source: k === 'wishlist' ? 'wishlist' : 'manual',
                        };
                        if (k !== 'note' && !payload.appid && !payload.bundleid && !payload.packageid) {
                            toast(zh('该类型必须填写对应 ID', 'This kind requires its id'), 'warning');
                            return;
                        }
                        if (rec) {
                            const merged = Object.assign({}, rec, payload);
                            putItem(merged);
                            toast(zh('已保存', 'Saved'), 'success');
                        } else {
                            await addItem(payload);
                        }
                    }
                },
            ],
            onClose: () => { if (isOpenFlag) renderList(); },
        });
    }

    // ---- 导出 ----
    function showExportModal() {
        const full = buildExport({ compatOnly: false });
        const compat = buildExport({ compatOnly: true });
        showModal({
            title: zh('导出暂存箱', 'Export shelf'),
            body: `
<label class="sgsh-check"><input type="checkbox" id="f-compat"> ${zh('仅导出购物类（app/bundle/package）——导入到「购物车增强」时勾选', 'Cart items only (app/bundle/package) — tick when importing into the cart script')}</label>
<div class="sgsh-field"><textarea id="f-json" readonly>${esc(JSON.stringify(full, null, 2))}</textarea>
  <div class="hint">${zh('共 ' + full.items.length + ' 条（购物类 ' + compat.items.length + ' 条）。Ctrl/⌘+C 或点复制。', full.items.length + ' records (' + compat.items.length + ' cart). Ctrl/⌘+C or use Copy.')}</div></div>`,
            buttons: [
                { label: zh('取消', 'Cancel') },
                {
                    label: zh('复制', 'Copy'), act: () => {
                        const ta = document.getElementById('f-json');
                        const txt = ta ? ta.value : '';
                        toast(copyText(txt) ? zh('已复制到剪贴板', 'Copied to clipboard') : zh('复制失败，请手动全选', 'Copy failed — select manually'), copyText(txt) ? 'success' : 'warning');
                    }
                },
            ],
        });
        const chk = document.getElementById('f-compat');
        const ta = document.getElementById('f-json');
        if (chk && ta) chk.addEventListener('change', () => { ta.value = JSON.stringify(chk.checked ? compat : full, null, 2); });
    }

    // ---- 导入 ----
    function showImportModal() {
        showModal({
            title: zh('导入暂存箱', 'Import shelf'),
            body: `<div class="sgsh-m-lead">${zh('粘贴 JSON。支持本库导出体、购物车增强的原样导出、以及裸数组。相同商品自动合并，不产生重复。', 'Paste JSON. Accepts this shelf export, the cart script raw export, or a bare array. Identical products merge instead of duplicating.')}</div>
<div class="sgsh-field"><textarea id="f-json" placeholder='{"items":[...]}'></textarea></div>`,
            buttons: [
                { label: zh('取消', 'Cancel') },
                {
                    label: zh('导入', 'Import'), primary: true, act: () => {
                        const ta = document.getElementById('f-json');
                        const r = parseImport(ta ? ta.value : '');
                        if (!r.ok) { toast(r.error, 'error'); return; }
                        toast(zh('导入完成：新增 ', 'Imported: ') + r.added + zh(' · 更新 ', ' · updated ') + r.updated + (r.skipped ? zh(' · 跳过 ', ' · skipped ') + r.skipped : ''), r.added || r.updated ? 'success' : 'info');
                    }
                },
            ],
            onClose: () => { if (isOpenFlag) renderList(); },
        });
    }

    // ==================== 购物车页监听 ====================
    let cartObserver = null;
    let cartDebounce = 0;

    function watchCartPage() {
        if (cartObserver) return;
        const boot = () => {
            if (cartObserver || !onCartPage()) return;
            injectCartButtons();
            cartObserver = new MutationObserver((mutations) => {
                for (let i = 0; i < mutations.length; i++) {
                    const t = mutations[i].target;
                    if (t && typeof t.closest === 'function' && t.closest('#sgis-panel, .sglv-panel, .sglv-overlay, .sglv-menu-wrap, #familyAnalysisPanel, #swe-panel, #swe-fab, .swe-nav-entry, [data-sglv-plugin-ui], [data-fa-plugin-ui], [data-swe-plugin-ui]')) continue;
                    clearTimeout(cartDebounce);
                    cartDebounce = setTimeout(() => { if (onCartPage()) injectCartButtons(); }, 600);
                    return;
                }
            });
            cartObserver.observe(document.body, { childList: true, subtree: true });
        };
        boot();
        // 单页应用路由（/cart 内部不会切页，但保险起见监听一次 popstate）
        window.addEventListener('popstate', () => setTimeout(boot, 300));
    }

    function refreshCartButtons() {
        if (!onCartPage()) return;
        injectCartButtons();
        if (isOpenFlag) renderList();
    }

    // ==================== 对外 ====================
    function init(host) {
        Host = host || null;
        if (!Host || Host.apiVersion !== apiVersion) {
            console.warn('[SGLVShelf] 握手失败：Host.apiVersion 与库版本不匹配');
            _hostReady = false;
            return false;
        }
        _hostReady = true;
        try {
            // 样式必须此刻注入，不能等到 ensureUI()：侧栏角标在浮窗首次打开前
            // 就可能显示（init 的 emitChange 会点亮它），懒加载会让角标裸奔
            ensureCss();
            // 初始化即广播一次，让侧栏按钮拿到初始角标
            emitChange();
            watchCartPage();
        } catch (e) {
            console.warn('[SGLVShelf] 初始化异常（数据层仍可用）', e);
        }
        debug('init ok · interop=%d extra=%d', readBucket('interop').items.length, readBucket('extra').items.length);
        return true;
    }

    return {
        init: init,
        apiVersion: apiVersion,
        // 浮窗
        openShelf: openShelf,
        closeShelf: closeShelf,
        toggleShelf: toggleShelf,
        isOpen: isOpen,
        // 数据
        getCount: countAll,
        allItems: allItems,
        getItem: getItem,
        addItem: addItem,
        addWishlist: addWishlist,
        addNote: addNote,
        deleteItem: deleteItem,
        putItem: putItem,
        executeRestore: executeRestore,
        pruneStale: pruneStale,
        buildExport: buildExport,
        parseImport: parseImport,
        onChange: onChange,
        setBadge: setBadge,
        // 购物车页
        injectCartButtons: refreshCartButtons,
        onCartPage: onCartPage,
        shelveAllRows: shelveAllRows,
        // 测试/诊断用内部接口
        _internals: {
            normalizeRecord: normalizeRecord,
            isInteropKind: isInteropKind,
            bucketOf: bucketOf,
            resolveKind: resolveKind,
            sceAcceptable: sceAcceptable,
            readBucket: readBucket,
            writeBucket: writeBucket,
            getPrefs: getPrefs,
            setPrefs: setPrefs,
            sameTarget: sameTarget,
            resolveRestorePlan: resolveRestorePlan,
            displayName: displayName,
            linkOf: linkOf,
            remainText: remainText,
            severity: severity,
            CFG: CFG,
        },
    };
})();
// ==== SGLV-SHELF-INLINE-END ====

// ==== SGLV-COVER-FALLBACK-INLINE-BEGIN (inline-cover-fallback.js 自动生成，勿手改) ====
/**
 * 内联内容由 inline-cover-fallback.js 生成 —— 请勿手改。
 * 来源：libs/sglv-libs-cover-fallback.lib.js
 * 改动请编辑库文件后重跑本脚本；verify-cover-fallback-inline-sync.js 会拦截漏跑。
 *
 * v2.0.0 重写要点:
 *   - 链首 cdn.cloudflare（老游戏命中率最高，替代 v1.x 的 shared.akamai schinese_2x）
 *   - 链长 7-8 (从 20 砍掉一半多)
 *   - schinese 变体放链尾（避免老游戏先吃 4-5 个 404）
 *   - 拿掉 steamui.com 渠道（被 Cloudflare managed challenge 拦截，永久失效）
 *   - JS 驱动的 chainLoad(img, ...) — 参考 steam-friend-manager 1.5.3 dashChainLoad
 *   - addEventListener('error') 单一 listener，链耗尽异步走 Steam Store API
 *
 * v2.0.1: good URL 跨会话缓存补 6 个月 TTL（COVER_GOOD_TTL）——
 *   验证可用的封面 URL 半年内不再重走整条链；游戏换封面后半年自动重新探测。
 *
 * v2.0.2: 修复封面"越改越坏"根因——
 *   chainLoad 单一状态机（不再 onerror + addEventListener 双推进）；
 *   skipUrl 跳过刚失败的 src；成功后 recordGood 落缓存；锁可复位；
 *   getCoverUrl 先查 lang 键再回落无 lang 键。
 *
 * v2.0.3: 缓存复用 / 渐进式失效——
 *   过期条目不再批量删除（旧 URL 继续当初始 src，命中即刷新 ts，404 才走链）；
 *   LRU 500 → 2000；负缓存真正接上（网络失败 10min / 确认无资产 24h）；
 *   只剪除 data:/blob: 垃圾条目。
 */
// ---------- sglv-libs-cover-fallback.lib.js (610 行) ----------

/*
 * SGLV Cover Fallback Library v2.0.3
 *
 * v2.0.3 缓存策略（渐进式失效 / 增量刷新 / 最大化复用旧缓存）:
 *   - 过期条目不再批量删除：旧 URL 继续作为初始 src 使用，命中即 recordGood 刷新 ts（零成本续期），
 *     404 只让这一条走回退链 —— 杜绝"半年后整库同时过期 → 全量重爬"
 *   - PERSISTED_MAX 500 → 2000：大库不再频繁淘汰仍在使用的 good URL
 *   - 负缓存真正接上（此前 _coverNeg 定义了但无人使用）：API 网络失败 10min 重试、
 *     确认无资产 24h 重试，避免每次渲染都打 appdetails
 *   - loadPersisted 只剪除 data:/blob: 垃圾条目，http(s) 条目一律保留
 *
 * v2.0.2 修复（封面"越改越坏"根因）:
 *   - chainLoad 不再混用 img.onerror + addEventListener('error')(同一次失败双推进,
 *     一次 error 跳过 2 个 URL 直冲 placeholder);改为单一状态机
 *   - 支持 skipUrl:跳过调用方刚失败的 src(旧实现重设同一 URL → 立刻再失败)
 *   - 加载成功一律 recordGood() 写缓存(旧实现要求 onLoaded,宿主全都没传 → 缓存恒空)
 *   - recordGood 只接受 http(s),data:/blob: 占位图绝不入缓存
 *   - 成功/放弃时复位 _sglvChainLoading(旧实现一次性锁永不复位,视图切换后彻底失效)
 *   - getCoverUrl 先查 lang 键再回落无 lang 键(旧实现写入无 lang、读取只有 lang → 中文界面永不命中)
 *
 * v2.0.0 重写（性能与覆盖率重设计）:
 *   - 链首 cdn.cloudflare.steamstatic.com（Steam 老游戏命中率最高，2018 前所有发售游戏都覆盖）
 *   - 链长度从 20 砍到 7-8（去掉冗余的 4 CDN × schinese 变体置顶；实测 schinese 变体在老游戏几乎全 404）
 *   - schinese 变体放链尾部（仅在所有基础 URL 失败后才尝试，节省 4-5 个 404）
 *   - 新增 chainLoad(img, appid, kind, opts) — JS 驱动链式加载（参考 steam-friend-manager 1.5.3 dashChainLoad）
 *     img 创建时无 src（避免浏览器主动加载链首 404），addEventListener('error') 单一 listener，
 *     链耗尽后异步走 Steam Store API（不阻塞当前链）
 *   - 移除 v1.x 的 steamui.com 渠道（被 Cloudflare managed challenge 拦截，受限网络下 _steamuiCfBlockedUntil
 *     永久触发，getSteamuiAssets 永远返回 null，整个 hash URL 直通渠道失效——回退到传统 CDN 链 + API 兜底）
 *   - 保留 good URL 缓存 + GM 持久化（LRU 500）+ 负缓存（双 TTL：确认无资产 24h / 网络抖动快速自愈）
 *   - 兼容 v1.x API：getCoverUrl(appid, kind, lang) / resolveCover(appid, kind, lang) /
 *     bindErrorHandler(rootEl, onFailed) / loadImageWithFallback(img, onFailed)
 *
 * 设计目标：从 sglv-libs-core 抽出"封面降级 + 多 CDN 探测"基础设施，
 *   供所有 SGLV 系列脚本 @require 共享，避免每个脚本都重写一遍：
 *   - cdn.cloudflare 链（老游戏最稳）→ store_item_assets 链（新游戏）→ header.jpg 兜底
 *   - 跨视图/跨会话的 good URL 缓存（按 kind 隔离）
 *   - appdetails API 兜底（kind 感知：capsule 优先 capsule_image, 其余 header_image）
 *   - SVG placeholder
 *
 * 使用方式:
 *   1) 宿主 @require 此 lib
 *   2) img 标签加 data-sglv-cover="1" + data-appid="123" + data-kind="capsule"（kind 默认 capsule）
 *   3) 初始 src 推荐用 SGLVCoverFallback.getCoverUrl(appId, kind) 同步取（命中缓存或链首）
 *   4) 在根容器上调用 SGLVCoverFallback.bindErrorHandler(rootEl)
 *   5) 错误时自动走 chainLoad（JS 接管，加 addEventListener('error') 单一 listener）
 *   6) 成功时自动写缓存（同会话 + 跨会话 GM）
 *   7) 链耗尽后异步走 Steam Store API（不阻塞当前链）
 *
 * 桥接契约(测试/宿主需要注入):
 *   window.__sglvCoverMockGmXhr = function(method, url, opts, cb)  可选,默认走 GM_xmlhttpRequest
 *
 * API:
 *   version: '2.0.0'
 *   apiVersion: 3
 *   SVG_PLACEHOLDER: data:image/svg+xml 兜底图
 *   CHAIN: 默认 CDN fallback 链(横图 7:3,向后兼容)
 *   KINDS: 支持的图片类型列表
 *   LANG_VARIANTS: 各 kind 的语言变体文件名模板(链尾部,老游戏通常 miss)
 *   getCoverUrl(appId, kind?, lang?): 获取初始 URL(good 缓存→链首)
 *   resolveCover(appId, kind?, lang?): Promise 版(同步 good 缓存→链首;异步仅在 Steam API 调用时使用)
 *   chainLoad(img, appid, kind?, opts?): JS 驱动的链式加载(主要入口 — 推荐)
 *   bindErrorHandler(rootEl, onFailed?): 在 rootEl 上绑定 error/load 委托(全局只调一次)
 *   loadImageWithFallback(img, onFailed?): 兼容 v1.x 手动触发单图降级
 *   getSteamuiAssets: (v1.x 兼容, v2.0 返回 null, 避免误调)
 *   getSteamuiGoodUrl: (v1.x 兼容, v2.0 返回 '')
 *
 * 宿主需 @grant GM_xmlhttpRequest, GM_getValue, GM_setValue。
 */

(function (root) {
    'use strict';

    // ==================== 常量 ====================
    const VERSION = '2.0.3';
    const API_VERSION = 3;

    // CDN 前缀（按"老游戏命中率"排序,链首=命中率最高）
    // v2.0.0: cdn.cloudflare 排第一 — Steam 老游戏(2018 前)基本都在这
    //         shared.akamai store_item_assets 排第二 — 新游戏(2018+ / 哈希子目录)
    //         cdn.akamai 排第三 — 部分老 CDN 资源
    //         shared.fastly store_item_assets 排第四 — 备用哈希子目录
    const CDN_CF = 'https://cdn.cloudflare.steamstatic.com/steam/apps/';
    const CDN_SHARED_AK = 'https://shared.akamai.steamstatic.com/store_item_assets/steam/apps/';
    const CDN_AK = 'https://cdn.akamai.steamstatic.com/steam/apps/';
    const CDN_SHARED_FASTLY = 'https://shared.fastly.steamstatic.com/store_item_assets/steam/apps/';

    // kind → 基础文件列表(无语言变体;变体放链尾部,避免老游戏先吃 4-5 个 404)
    const POSTER_FILES = ['library_600x900_2x.jpg', 'library_600x900.jpg'];
    const CAPSULE_FILES = ['capsule_467x181.jpg', 'capsule_231x87.jpg'];
    const HEADER_FILES = ['header.jpg'];
    const HERO_FILES = ['library_hero_2x.jpg', 'library_hero.jpg'];
    const LOGO_FILES = ['logo_2x.png', 'logo.png'];
    const LIB_HEADER_FILES = ['library_header_2x.jpg', 'library_header.jpg'];

    // 语言变体文件名模板(仅在基础链全部失败时追加,避免老游戏先吃 schinese 404)
    // 实测 Steam CDN 路径直接支持语言后缀: capsule_467x181_schinese.jpg / logo_schinese.png 等
    // 但 2018 前发售的老游戏几乎都没这些变体 → 放链尾节省 4-5 个 404
    const LANG_VARIANTS = {
        poster: ['library_600x900_{v}_2x.jpg', 'library_600x900_{v}.jpg'],
        capsule: ['capsule_467x181_{v}.jpg', 'capsule_231x87_{v}.jpg'],
        header: ['header_{v}.jpg'],
        hero: ['library_hero_{v}_2x.jpg', 'library_hero_{v}.jpg'],
        logo: ['logo_{v}_2x.png', 'logo_{v}.png'],
        library_header: ['library_header_{v}_2x.jpg', 'library_header_{v}.jpg'],
    };
    const KINDS = ['poster', 'capsule', 'header', 'hero', 'logo', 'library_header'];

    // SVG placeholder(URL 编码内嵌)
    const SVG_PLACEHOLDER = "data:image/svg+xml;utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 184 69'%3E%3Crect fill='%231a1f3a' width='184' height='69'/%3E%3Ctext x='50%25' y='50%25' text-anchor='middle' dy='.3em' fill='%2364748b' font-family='system-ui' font-size='10'%3ENo Image%3C/text%3E%3C/svg%3E";

    // ==================== 内存缓存(同会话跨视图共享) ====================
    // 缓存键按 kind(+lang) 隔离 → "kind:appid" / "kind:appid@lang"
    const _goodMap = new Map();

    function goodKey(kind, appId, lang) {
        const k = kind || 'capsule';
        return lang ? k + ':' + appId + '@' + lang : k + ':' + appId;
    }

    // ==================== 持久化缓存(跨会话,GM_setValue) ====================
    // 与 v1.x 兼容: 键名 'sglv_cover_url_v2', LRU 2000
    //   v2.0.3: 500 → 2000 —— 大库(1000+ 游戏)下 500 条会频繁淘汰仍在使用的条目,
    //   被淘汰的条目下次渲染要从链首重爬(最坏 10 次 404)。2000 条约 240KB,远低于 GM 配额。
    const PERSISTED_KEY = 'sglv_cover_url_v2';
    const PERSISTED_MAX = 2000;
    // 新鲜期（诊断/迁移用，不再用于批量删除）
    //   v2.0.3: 过期条目**不再删除** —— 渐进式失效:
    //     旧 URL 继续作为初始 src 使用，命中则 recordGood 刷新 ts（零成本续期）；
    //     404 则只让这一条走回退链。避免"半年后整库同时过期 → 全量重爬"。
    //   容量由 PERSISTED_MAX 的 LRU（按最近成功使用时间）控制。
    const COVER_GOOD_TTL = 6 * 30 * 24 * 3600 * 1000; // 180 天（仅 v1 迁移门槛）
    let _persisted = null;

    function loadPersisted() {
        if (_persisted !== null) return _persisted;
        _persisted = {};
        try {
            const raw = GM_getValue(PERSISTED_KEY);
            if (raw && typeof raw === 'object') _persisted = raw;
        } catch (e) { /* ignore */ }
        // 只剪除确定无效的条目（非 http(s) 的 data:/blob: 占位残留）。
        // 过期条目保留：它大概率仍然可用，作为初始 src 再试一次比"重新爬整条链"便宜得多。
        let pruned = false;
        for (const key in _persisted) {
            const ent = _persisted[key];
            if (!ent || !isHttpUrl(ent.url)) {
                delete _persisted[key];
                pruned = true;
                continue;
            }
            _goodMap.set(key, ent.url);
        }
        if (pruned) {
            try { GM_setValue(PERSISTED_KEY, _persisted); } catch (e) { /* ignore */ }
        }
        // v1.x 兼容: 迁移 v1 旧格式 (appid 直接作键)
        try {
            const now = Date.now();
            const oldRaw = GM_getValue('sglv_cover_url_v1');
            if (oldRaw && typeof oldRaw === 'object') {
                for (const id in oldRaw) {
                    const ent = oldRaw[id];
                    if (ent && isHttpUrl(ent.url) && !_persisted['capsule:' + id]
                        && (now - (ent.ts || 0)) <= COVER_GOOD_TTL) {
                        _persisted['capsule:' + id] = { url: ent.url, ts: ent.ts || now };
                        _goodMap.set('capsule:' + id, ent.url);
                    }
                }
            }
        } catch (e) { /* ignore */ }
        return _persisted;
    }

    let _writeTimer = null;
    let _writeDirty = false;
    // 同一 URL 的 ts 刷新落盘节流：ts 只服务 LRU 排序，不需要秒级精度。
    //   每次 load 都整表序列化(2000 条约 220KB)会在滚动时造成明显卡顿。
    const PERSIST_TOUCH_TTL = 60 * 60 * 1000;   // 1h
    function setPersisted(cacheKey, url) {
        if (!cacheKey || !url) return;
        const container = loadPersisted();
        const ent = container[cacheKey];
        const now = Date.now();
        if (ent && ent.url === url && (now - (ent.ts || 0)) < PERSIST_TOUCH_TTL) return;
        container[cacheKey] = { url, ts: now };
        const keys = Object.keys(container);
        if (keys.length > PERSISTED_MAX) {
            // LRU: 删最旧的
            keys.sort((a, b) => (container[a].ts || 0) - (container[b].ts || 0));
            while (keys.length > PERSISTED_MAX) delete container[keys.shift()];
        }
        _writeDirty = true;
        if (_writeTimer) return;
        _writeTimer = setTimeout(() => {
            _writeTimer = null;
            if (!_writeDirty) return;
            _writeDirty = false;
            try { GM_setValue(PERSISTED_KEY, container); } catch (e) { /* 配额/序列化失败静默 */ }
        }, 50);
    }

    function flushPersisted() {
        if (_writeTimer) { clearTimeout(_writeTimer); _writeTimer = null; }
        if (_writeDirty && _persisted) {
            _writeDirty = false;
            try { GM_setValue(PERSISTED_KEY, _persisted); } catch (e) { /* ignore */ }
        }
    }

    function clearPersisted() {
        _persisted = {};
        _goodMap.clear();
        try { GM_setValue(PERSISTED_KEY, {}); } catch (e) { /* ignore */ }
        try { GM_setValue('sglv_cover_url_v1', {}); } catch (e) { /* ignore */ }
    }

    // ==================== 负缓存(API 调用失败避免重试风暴) ====================
    // 双 TTL: 确认无资产(API 成功但 data 空)24h;网络/限频失败 10min 快速自愈
    //   收敛策略：同一 appid+kind 最多每 10min / 24h 打一次 API，
    //   网络抖动很快恢复，确认无资产也不会每次渲染都重试 —— 渐进式刷新。
    const COVER_NEG_TTL = 24 * 60 * 60 * 1000;
    const COVER_NETFAIL_TTL = 10 * 60 * 1000;
    const COVER_NEG_MAX = 800;
    const _coverNeg = new Map();  // 'kind:appid' → { t, n }  (n=1 网络失败,n=0 确认无资产)

    function _negHit(rec) {
        if (!rec) return false;
        const now = Date.now();
        return (now - rec.t) < (rec.n ? COVER_NETFAIL_TTL : COVER_NEG_TTL);
    }
    function _negKey(k, appId) { return k + ':' + appId; }
    function _negMark(k, appId, netFail) {
        const key = _negKey(k, appId);
        _coverNeg.delete(key);
        _coverNeg.set(key, { t: Date.now(), n: netFail ? 1 : 0 });
        if (_coverNeg.size > COVER_NEG_MAX) {
            const it = _coverNeg.keys();
            while (_coverNeg.size > COVER_NEG_MAX) {
                const kk = it.next();
                if (kk.done) break;
                _coverNeg.delete(kk.value);
            }
        }
    }

    // ==================== 链构建 ====================
    // v2.0.0: 链首 cdn.cloudflare（老游戏命中率最高）,基础文件, schinese 变体放链尾
    function buildFiles(kind, lang) {
        const k = (kind && KINDS.indexOf(kind) >= 0) ? kind : 'capsule';
        let base;
        if (k === 'poster') base = POSTER_FILES;
        else if (k === 'capsule') base = CAPSULE_FILES;
        else if (k === 'header') base = HEADER_FILES;
        else if (k === 'hero') base = HERO_FILES;
        else if (k === 'logo') base = LOGO_FILES;
        else base = LIB_HEADER_FILES;
        const files = base.slice();
        // schinese 变体放链尾 — 老游戏(2018 前)基本没这些,放链首是 4-5 个浪费的 404
        if (lang) {
            const tpl = LANG_VARIANTS[k];
            if (tpl) for (const t of tpl) files.push(t.replace('{v}', lang));
        }
        return files;
    }

    // 链构造: cdn.cloudflare(1) → store_item_assets(2,3,4) → header.jpg 兜底
    // 总数 7-8 URL(从 v1.x 的 20 砍掉一半多)
    function buildFullChain(appId, kind, lang) {
        const id = String(appId);
        const files = buildFiles(kind, lang);
        const full = [];
        for (const f of files) {
            // 1. cdn.cloudflare 链首(老游戏最稳)
            full.push(CDN_CF + id + '/' + f);
            // 2. shared.akamai store_item_assets(新游戏哈希子目录)
            full.push(CDN_SHARED_AK + id + '/' + f);
            // 3. cdn.akamai(部分老 CDN 资源)
            full.push(CDN_AK + id + '/' + f);
            // 4. shared.fastly store_item_assets(备用)
            full.push(CDN_SHARED_FASTLY + id + '/' + f);
        }
        // header.jpg 兜底(几乎所有游戏都有,放链尾)
        if (kind !== 'header' && kind !== 'library_header') {
            full.push(CDN_CF + id + '/header.jpg');
            full.push(CDN_SHARED_AK + id + '/header.jpg');
        }
        return full;
    }

    // ==================== 链去重 ====================
    // 同一 URL 不重复探测(steamui hash URL 可能跟基础链重复)
    function _dedupeChain(chain) {
        if (!Array.isArray(chain)) return chain;
        const seen = new Set();
        const out = [];
        for (const u of chain) {
            if (u && !seen.has(u)) { seen.add(u); out.push(u); }
        }
        return out;
    }

    // ==================== good URL 写入(统一入口) ====================
    // v2.0.2: 宿主一直调用 recordGood() 但 v2.0.0 没有导出该 API —
    //   结果 whole 会话内没有任何 URL 被写进 good 缓存,getCoverUrl 永远只返回链首,
    //   每张封面每次渲染都要从链首重新试错(这也是"越改越慢/越改越坏"的根源之一)。
    function isHttpUrl(u) {
        return typeof u === 'string' && /^https?:\/\//i.test(u);
    }

    // 取 img 当前 src(容错: 测试/桩对象可能没有 getAttribute)
    function _imgSrc(img) {
        try {
            if (img && typeof img.getAttribute === 'function') return img.getAttribute('src') || '';
            return (img && img.src) || '';
        } catch (e) { return ''; }
    }

    // 记录"已验证可加载"的 URL:同会话 Map + 跨会话 GM 持久化
    // 只接受 http(s) —— data:/blob: 占位图绝不入缓存
    // 统一写无 lang 键(lang 只是读取顺序偏好,写两份会浪费 LRU 配额;
    //   getCoverUrl 会先查 lang 键再回落无 lang 键)
    function recordGood(appId, url, kind, lang) {
        if (!appId || !isHttpUrl(url)) return false;
        const k = (kind && KINDS.indexOf(kind) >= 0) ? kind : 'capsule';
        const id = String(appId);
        _goodMap.set(goodKey(k, id, ''), url);
        setPersisted(goodKey(k, id, ''), url);
        if (lang) _goodMap.set(goodKey(k, id, lang), url);   // 仅内存别名,不额外占持久化配额
        return true;
    }

    // ==================== getCoverUrl / resolveCover (兼容 v1.x API) ====================
    function getCoverUrl(appId, kind, lang) {
        if (!appId) return '';
        const k = kind || 'capsule';
        loadPersisted();
        // 1) 同步 good 缓存(同会话 + 跨会话)
        // v2.0.2: 先查带 lang 的键,再回落到无 lang 键 —— 写入统一走无 lang 键,
        //   旧实现只查 lang 键导致中文界面下跨会话缓存永远命中不了
        const cached = _goodMap.get(goodKey(k, appId, lang)) || _goodMap.get(goodKey(k, appId, ''));
        if (isHttpUrl(cached)) return cached;
        // 2) 没缓存 → 链首(基础文件,无 schinese 变体 — 优先快速命中老游戏)
        const chain = buildFullChain(appId, k, '');
        return chain[0] || '';
    }

    // v1.x 兼容: Promise 版封面解析
    // v2.0: 同步 good 缓存命中后直接 resolve;未命中走链首(异步 Steam API 仅在显式调用时执行)
    function resolveCover(appId, kind, lang) {
        if (!appId) return Promise.resolve(SVG_PLACEHOLDER);
        const u = getCoverUrl(appId, kind, lang);
        return Promise.resolve(u || SVG_PLACEHOLDER);
    }

    // ==================== Steam Store API 兜底 ====================
    // kind 感知: capsule 优先 capsule_image, poster/header/hero/logo/library_header 优先 header_image
    function fetchFromAPI(appId, kind) {
        return new Promise((resolve) => {
            const k = kind || 'capsule';
            const apiUrl = `https://store.steampowered.com/api/appdetails?appids=${appId}&filters=basic`;
            const gmxhr = root.__sglvCoverMockGmXhr
                || (typeof GM_xmlhttpRequest !== 'undefined' ? GM_xmlhttpRequest : null);
            let settled = false;
            // v2.0.3: 区分「网络失败」(10min 后可重试) 与「确认无资产」(24h) ——
            //   两者都写负缓存，避免每次渲染都重打 API（重试风暴），又不会永久拉黑。
            const finish = (url, netFail) => {
                if (settled) return;
                settled = true;
                if (isHttpUrl(url)) _coverNeg.delete(_negKey(k, appId));
                else _negMark(k, appId, !!netFail);
                resolve(url || '');
            };
            const pick = (d) => (k === 'capsule')
                ? (d.capsule_image || d.header_image || '')
                : (d.header_image || d.capsule_image || '');
            if (gmxhr) {
                gmxhr({
                    method: 'GET', url: apiUrl, timeout: 8000,
                    onload: (r) => {
                        try {
                            const j = JSON.parse(_safeText(r));
                            const d = j[appId];
                            if (d && d.success && d.data) finish(pick(d.data), false);
                            else finish('', false);   // API 正常返回但无该游戏资产 → 24h 内不重试
                        } catch (e) { finish('', true); }
                    },
                    onerror: () => finish('', true),
                    ontimeout: () => finish('', true),
                });
            } else if (typeof fetch !== 'undefined') {
                fetch(apiUrl).then(r => r.json()).then(j => {
                    const d = j[appId];
                    if (d && d.success && d.data) finish(pick(d.data), false);
                    else finish('', false);
                }).catch(() => finish('', true));
            } else {
                finish('', true);
            }
        });
    }

    function _safeText(r) {
        try {
            if (!r) return '';
            if (typeof r.responseText === 'string') return r.responseText;
            if (typeof r.response === 'string') return r.response;
            return '';
        } catch (e) { return ''; }
    }

    // ==================== chainLoad: JS 驱动的链式加载（v2.0.2 重写）====================
    // v2.0.2 修复的关键缺陷:
    //   ① 旧实现同时挂 img.onerror 与 addEventListener('error') —— 同一次失败两套
    //      handler 各推进一次链(tryFinal 被调两次),一次 error 跳过 2 个 URL,
    //      直接从链首冲到 placeholder。现在只用一对 addEventListener,单一状态机。
    //   ② 旧实现忽略调用方当前 src —— bindErrorHandler 明明算了 cur 却没用,
    //      chain[0] 往往就是刚 404 的那个 URL,重设同一 URL 立刻再次失败。
    //      现在支持 opts.skipUrl,并且 step() 内部也跳过 curSrc。
    //   ③ 旧实现只有调用方传 onLoaded 才写 good 缓存,而宿主全部没传 —
    //      缓存永远是空的。现在加载成功即内部 recordGood()。
    //   ④ 旧实现的 _sglvChainLoading 一次性锁从不复位 —— 同一 img 节点再次赋值
    //      src(视图切换复用节点)后 error 全被忽略,永远停在坏图上。现在成功/放弃时复位。
    //   ⑤ 旧实现链耗尽后还会再试一遍 header.jpg 两连(finalChain),而 buildFullChain
    //      已经带了 header 兜底 —— 重复请求。现在去重后统一由 chain 覆盖。
    // - img 创建时可无 src（不触发浏览器主动加载）
    // - 链耗尽后异步走 Steam API（不阻塞当前链）
    // - 失败/超时/API 空: 通知 onGiveUp(宿主替换占位)或设 SVG placeholder
    function chainLoad(img, appid, kind, opts) {
        if (!img || !appid) return;
        const k = (kind && KINDS.indexOf(kind) >= 0) ? kind : 'capsule';
        const o = opts || {};
        const lang = o.lang || root.__sglvCoverLang || '';

        // 1) 同步 good 缓存命中 — 放链首(成功概率最高,避免链首 404)
        //    只接受 http(s)：占位图/脏缓存一律忽略，继续走真实 CDN 链
        loadPersisted();
        const goodRaw = _goodMap.get(goodKey(k, appid, lang)) || _goodMap.get(goodKey(k, appid, ''));
        const good = isHttpUrl(goodRaw) ? goodRaw : '';

        // 2) 完整链(已含 header.jpg 兜底)
        const chain = _dedupeChain((good ? [good] : []).concat(buildFullChain(appid, k, lang)));

        // 3) 从"当前已失败的 src"之后继续,不重复请求同一个 404
        const curSrc = (o.skipUrl != null) ? String(o.skipUrl) : _imgSrc(img);
        let i = 0;
        const pos = chain.indexOf(curSrc);
        if (pos >= 0 && pos + 1 < chain.length) i = pos + 1;

        let done = false;
        let apiStarted = false;

        function detach() {
            img.removeEventListener('error', onError);
            img.removeEventListener('load', onLoad);
            img._sglvChainLoading = 0;   // 释放一次性锁,允许后续重新接管
        }
        function succeed() {
            if (done) return;
            done = true;
            detach();
            const u = img.currentSrc || img.src || '';
            recordGood(appid, u, k, lang);
            if (o.onLoaded) { try { o.onLoaded(u); } catch (e) { /* ignore */ } }
        }
        function fail() {
            if (done) return;
            done = true;
            detach();
            if (o.onGiveUp) { try { o.onGiveUp(); } catch (e) { /* ignore */ } }
            // 宿主已替换节点时不再改 src(onGiveUp 内部 replaceChild)
            if (!o.noPlaceholder && img.isConnected && img.parentElement) img.src = SVG_PLACEHOLDER;
        }
        function step() {
            if (done) return;
            while (i < chain.length) {
                const u = chain[i++];
                if (!u || u === curSrc) continue;   // 刚失败的 URL 不再请求
                img.src = u;
                return;
            }
            // 4) 链耗尽 → Steam API 兜底(仅一次)
            if (!apiStarted) {
                apiStarted = true;
                // v2.0.3: 负缓存命中则跳过 API —— 同一 appid+kind 在 TTL 内最多打一次，
                //   既不会每次渲染都重试（重试风暴），也会在 TTL 后自动恢复（渐进式刷新）
                if (_negHit(_coverNeg.get(_negKey(k, appid)))) { fail(); return; }
                Promise.resolve(fetchFromAPI(appid, k)).then(function (url) {
                    if (done) return;
                    if (isHttpUrl(url) && chain.indexOf(url) < 0) { img.src = url; return; }
                    fail();
                }, fail);
                return;
            }
            fail();
        }
        function onError() { if (!done) step(); }
        function onLoad() {
            if (done) return;
            // naturalWidth <= 1 视为占位/空图,不写缓存也不算成功
            if (!img.naturalWidth || img.naturalWidth < 2) return;
            succeed();
        }

        img.addEventListener('load', onLoad);
        img.addEventListener('error', onError);
        step();
    }

    // ==================== bindErrorHandler (兼容 v1.x API) ====================
    // 在 rootEl 上绑定 error/load 委托 — 任何 data-sglv-cover="1" 的 img 出错时自动走 chainLoad
    // 全局只调一次(bindErrorHandler 内部守卫)
    function bindErrorHandler(rootEl, onFailed) {
        if (!rootEl || rootEl.dataset.sglvCoverHandlerBound) return;
        rootEl.dataset.sglvCoverHandlerBound = '1';
        rootEl.addEventListener('error', (e) => {
            const t = e.target;
            if (!t || t.tagName !== 'IMG') return;
            if (t.dataset && t.dataset.sglvCover !== '1') return;
            if (t._sglvChainLoading) return;
            const appid = t.dataset.appid;
            if (!appid) return;
            t._sglvChainLoading = 1;
            const kind = t.dataset.kind || 'capsule';
            // 记录当前失败 src,从 chain 中跳过(避免对同一个 404 重复发请求)
            const cur = _imgSrc(t);
            chainLoad(t, appid, kind, {
                skipUrl: cur,
                onGiveUp: () => { if (onFailed) try { onFailed(t); } catch (e) {} },
            });
        }, true);  // capture: 捕获内嵌 img 的 error
    }

    // ==================== loadImageWithFallback (兼容 v1.x API) ====================
    function loadImageWithFallback(img, onFailed) {
        if (!img) return;
        const appid = img.dataset && img.dataset.appid;
        if (!appid) return;
        const kind = (img.dataset && img.dataset.kind) || 'capsule';
        if (img._sglvChainLoading) return;
        img._sglvChainLoading = 1;
        chainLoad(img, appid, kind, {
            skipUrl: _imgSrc(img),
            onGiveUp: () => { if (onFailed) try { onFailed(img); } catch (e) {} },
        });
    }

    // ==================== v1.x 兼容: steamui 接口(全部返回空)====================
    // v2.0 移除 steamui.com 渠道(被 CF managed challenge 拦截,失效)
    // 保留接口名(返回 null/'')避免宿主调用炸
    function getSteamuiAssets(appId, opts) { return Promise.resolve(null); }
    function getSteamuiGoodUrl(appId, kind, lang) { return ''; }
    function _resetSteamuiState() { /* no-op */ }

    // ==================== 公开 API ====================
    const api = {
        // 元信息
        version: VERSION,
        apiVersion: API_VERSION,

        // 常量
        SVG_PLACEHOLDER,
        CHAIN: ['capsule_231x87.jpg', 'capsule_184x69.jpg', 'capsule_467x181.jpg', 'header.jpg'],
        KINDS,
        LANG_VARIANTS,

        // 链构建
        buildFiles,
        buildFullChain,
        _dedupeChain,

        // 同步获取 URL
        getCoverUrl,
        resolveCover,

        // JS 驱动链式加载(主要入口)
        chainLoad,

        // 委托绑定
        bindErrorHandler,
        loadImageWithFallback,

        // 缓存管理
        recordGood,      // v2.0.2: 宿主成功回调统一写 good 缓存(仅接受 http(s))
        flushPersisted,
        clearPersisted,

        // v1.x 兼容(steamui 渠道已移除,接口保留)
        getSteamuiAssets,
        getSteamuiGoodUrl,
        _resetSteamuiState,

        // 内部 API(供宿主 monky-patch / 调试)
        _goodMap,
        loadPersisted,
        setPersisted,
        isHttpUrl,
        _safeText,
        fetchFromAPI,
    };

    root.SGLVCoverFallback = api;

    if (typeof unsafeWindow !== 'undefined' && unsafeWindow !== root) {
        try { unsafeWindow.SGLVCoverFallback = api; } catch (e) { /* ignore */ }
    }

    return api;
})(typeof window !== 'undefined' ? window : globalThis);
// ==== SGLV-COVER-FALLBACK-INLINE-END ====

// ==== SGLV-GAME-COLLECTION-INLINE-BEGIN (inline-game-collection.js 自动生成，勿手改) ====
/**
 * 内联内容由 inline-game-collection.js 生成 —— 请勿手改。
 * 来源：libs/sglv-libs-game-collection.lib.js
 * 改动请编辑库文件后重跑本脚本；verify-game-collection-inline-sync.js 会拦截漏跑。
 *
 * v2.1.0 关键改进:
 *   - seriesCoverImg / seriesCapsuleImg 重写为 data-属性 + 单一 onerror 委托
 *     (img 创建时无 src,失败时由 _sglvChainFallback → chainLoad JS 接管)
 *   - 3 级下拉面包菜单 (分类 › 供应商 › 系列) 替代 sidebar 列表选择器
 *   - _bcRenderDetail 统一 4 个 detail 渲染函数
 *   - 30+ 条 CSS 渐变/圆角/hover 动效
 */
// ---------- sglv-libs-game-collection.lib.js (11155 行) ----------

/*
 * SGLV Game Collection Library v2.1.0
 *
 * ── 版本沿革 ──────────────────────────────────────────────
 * v2.9.9（PS 会免：独占占位画居中 + 名称显示优化）:
 *   ① 占位画居中——蓝色 PS 底纹改绝对定位铺满图片盒 + flex 双向居中，PS Logo 收敛到与卡片
 *      协调的尺寸，Logo+名称组稳定落在正中（此前 height:100% 在 aspect-ratio 盒内 + 过大 Logo
 *      让内容观感偏移、不居中）。
 *   ② 名称显示——底纹名称降为居中两行省略的小字说明；并给底纹名称挂 data-sglv-psstore，
 *      让它与卡片正文一样被异步替换成 PS Store 官方名（此前只有正文被替换，底纹残留
 *      URL slug 拆词产生的 garbled 名，两处不一致）。
 *   ③ 泛化名守卫——PS Store 页 og:title 整页就是平台名（区域限售回落首页）时解析出
 *      "PlayStation" 之类泛化词，此前会回填成卡片名；现视为抓取失败保留原名。
 *
 * v2.9.8（年度大作：顶部穿透修复 + TGA 年度游戏殿堂）:
 *   ① 顶部内容穿透修复——年度大作滚动区 padding-top:2px 与 sticky 分组标题栏(top:0)组合，
 *      使吸附后的标题栏停在滚动口顶 +2px，这 2px 缝隙没有栏体遮挡，滚过的彩色封面从中透出。
 *      改为滚动区 padding-top:0 + 首元素 margin-top:2px（margin 随内容一起滚走，
 *      静止时顶部留白不变，吸附时标题栏与滚动口严丝合缝，杜绝穿透）。
 *   ② TGA 年度游戏殿堂（参考 steam-friend-manager 1.6.2）——年份时间轴最左新增金色「年度游戏」
 *      节点，点击进入殿堂：2014–2025 历届 GOTY 冠军竖版海报墙（年份徽标 + 皇冠数=当年获奖次数 +
 *      在库标记，非 Steam 平台独占用平台配色占位画）；点击任一冠军打开「年度游戏 · {year}」提名弹窗
 *      （左获奖者竖版海报 + 右提名横版网格，Steam 卡点击开商店页，ESC/遮罩/关闭按钮退出）。
 *      数据源 SmallFork/json TGA_winners.json（fastly→cdn→raw 三级回退 + IDB 永久缓存 + 24h 后台刷新）。
 *   ③ 年度大作卡片交叉标记——命中 TGA 年度游戏冠军的卡片加金色 👑 年度游戏 chip，点击直接开该年提名弹窗。
 *
 * v2.9.7（收藏模块：非 Steam 游戏补真实封面）:
 *   ① PS 会免 tab 里没有 steamAppId 的 PS 独占条目（实测数据源 1595 条中 293 条）
 *      此前只有一块蓝色 PS Logo 占位画、没有任何封面——本版给它们补上 PS Store 真实主视觉。
 *      做法参考 steam-friend-manager 1.6.2 的非 Steam 卡（sfd-tga-excl-art + sfd-tga-excl-img）：
 *      平台占位画垫底，商店主视觉图绝对定位盖在其上；图加载失败自动移除图，保住占位画。
 *   ② 封面来源：PS Store 页面内嵌的 schema.org JSON-LD（script#mfe-jsonld-tags → Product.image），
 *      实测为 1024×1024 方图，CDN image.api.playstation.com 可直链热链（无需 Referer、无需鉴权）。
 *      主区域（zh-hans-hk）缺图时自动换 en-us 再试一次（部分地区未发行/限售会缺 SSR 数据）。
 *   ③ 抓取层重构：fetchPsStoreName 升级为 fetchPsStoreMeta —— 同一次请求同时产出中文名与封面图
 *      （此前中文名独立抓页，改后二者共用一页，零额外请求）；缓存 key 升到 sglvPsStoreMetaCache_v2
 *      （中文名 + 封面），v1 旧 key 自动迁移，无需清缓存。
 *   ④ 抓取限流：PS Store 单页 300KB+，加并发闸门（4 路）+ 同 URL 请求去重；缓存整表落盘改 3s 节流
 *      （单页 49 张卡原本会放大成 49 次整表序列化写入）。
 *   ⑤ 三个视图统一补封面：卡片（2:3 海报）/ 封面（460×215 横版）/ 列表（92×43 图标）；
 *      方图焦点上移（object-position: center 20%）保住方图上方的游戏 LOGO 区。
 *
 * v2.9.6（年度大作筛选/边距 + KPI 光斑 + Humble 平铺）:
 *   ① 年度大作年份时间轴从"滚动定位"改为"真筛选"——点击年份节点只渲染该年份分块
 *      （gotyState.yearFilter，再点同一年份或「全部」取消）；active 由筛选态决定，
 *      不再被平滑滚动中途漂移；当前筛选下 0 条的年份节点灰显禁用，杜绝"点了没反应"。
 *   ② 年度大作列表边距收紧——工具栏行/时间轴行留白、年份块(14px)+分组(12px)叠加空隙、
 *      分组 header padding 全部压缩；renderGotyScroll 重渲染后回到顶部，消除顶部空白观感。
 *   ③ KPI 卡片光斑弱化——主脚本 CSS_KPI 的 ::before（全卡渐变 hover:opacity 1）与共享 CSS 库
 *      的 ::before（40x40 圆形 blur 8px）层叠成"左上角一团高斯模糊光斑"遮住标签/图标；
 *      sgc-panel 内覆盖为全卡轻渐变(hover 0.5)+数值去发光+选中仅 accent 描边+hover 阴影收敛。
 *   ④ Humble 月包顶部缩略图全量平铺——去掉"最多 5 个 + +N 折叠块"，8 款游戏直接平铺
 *      （44px 缩略 + flex-wrap 自动换行），右侧空白不再浪费、无需展开即可看全。
 *
 * v2.9.5（DLC 封面绑定修复 + 状态斜切带移除）:
 *   ① DLC 分组视图（renderDlcGrouped）从未调用 bindRestrictedCoverLoaders →
 *      wrapper 永远停在 sglv-img-loading（灰色空块）。改为 appendDlcCardsChunked
 *      每批 append 后统一绑定（幂等），扁平/分组/任意调用方都覆盖。
 *   ② 移除受限卡片封面右下角的琥珀/绿色状态斜切带（.sglv-own-flag）——
 *      7 列紧凑卡片里贴着封面底边，看起来就是"一块黄色背景"；拥有态已由徽章表达。
 *
 * v2.9.4（卡片墙竖版化）:
 *   ① 系列分类 / PS 会免 / Epic 赠送的默认卡片视图改为竖版海报（2:3）+ 每行 7 列紧凑网格
 *   ② unifiedCover 新增 preferVertical：poster 走竖版优先链（library_600x900_2x →
 *      library_600x900 → header 兜底），其余 tab 保持原横向链；binder 通过
 *      data-cover-prefer-vertical 选择同一条链，避免初始 src 与回退链错位
 *   ③ 竖版图 object-fit:cover 铺满；横版兜底（markLoaded 打 .sglv-img-wide）走 contain letterbox
 *   ④ 三个视图 pageSize 48 → 49（7×7 整排，不留半排）
 *
 * v2.9.3（缓存复用 / 渐进式失效 / 增量刷新）:
 *   ① 横版封面统一归一到 header 槽位（markLoaded / API 兜底按 URL 形态写，而不是按容器 kind）——
 *      受限/PS/Epic/GOTY/主面板共享同一份横版 good URL，不再各探一次
 *   ② coverGoodUrl 横版类补 header/capsule 交叉读取；restrictedCoverImg 不再把竖版海报塞进横版容器
 *   ③ API 兜底负缓存 10min（成功结果本会话有效）—— 失败不再永久拉黑，也不会每次渲染重打接口
 *   ④ GOTY 持久缓存：先读原始值恢复"已被 180 天容器 TTL 清掉"的旧表，容器 TTL 改 10 年，
 *      条目失效交给"用一次自愈 + LRU 淘汰"，避免整表同时过期后全量重爬
 *   ⑤ markLoaded 同步写宿主共享缓存（Host.recordPosterGood）：收藏视图验证过的封面主面板直接复用
 *
 * v2.1.0（从 sglv-libs-core 剥离 + 收藏模块 UI/封面改造）:
 *   ① 从 sglv-libs-core IIFE 剥离为独立 lib, 与 sglv-libs-cover-fallback 同步
 *   ② seriesCoverImg / seriesCapsuleImg 重写为 data-属性 + 单一 onerror 委托
 *      (img 创建时无 src, 失败时由 _sglvChainFallback → chainLoad JS 接管,
 *       取代 v1.x 的 20 URL inline string 链; 链长 7-8 砍掉一半多)
  *
 * v2.0.0（大版本，配合主脚本 v2.20.0 架构重构）:
 *   ① 恢复独立库形态——v2.11.44-hotfix 起收藏模块被内联进主脚本（受限网络下
 *      外部 @require 静默失败导致功能全不可用），内联期主脚本侧演进了两个补丁
 *      （v2.11.49 捆绑包骨架屏 / v2.11.50 Humble Choice 月包分析 Tab）。
 *      本版将 1.9.47 + 两个补丁合并收编为独立库正式版本，主脚本 2.20.0 起
 *      恢复 @require 外部加载，主脚本仅保留收藏基本界面（菜单/按钮/桥接/降级）。
 *   ② 代码本体与主脚本 2.11.51 内联块逐字节一致（除本头部），行为零回归。
 *   ③ apiVersion 保持 1，CollectionHost 桥接契约不变。
 *
 * ── 历史版本（1.9.x，收编自主脚本内联期/原独立库） ──────────
 *   v1.9.50: Humble Choice 月包分析 Tab（数据源 @resource humbleChoiceData，
 *     KPI + 搜索 + 拥有筛选 + 分页网格；借鉴 steam-friend-manager 1.5.2）
 *   v1.9.49: 捆绑包 Tab 骨架屏（数据异步构建中先出骨架，避免闪"暂无进包数据"空态）
 *   v1.9.47: 全面修复绝版游戏/年度大作/锁区/PS/Epic/DLC/捆绑包翻页失效 + 绝版数据兜底链——
 *     ① 9 处 Host.renderPagination 调用补传第 8 参数 onJump（delisted/psplus/epic/blocked/goty/dlc×2/bundle，
 *        主脚本 renderPagination 内部所有按钮(首页/上页/下页/末页/跳页)统一走 goPage()→onJump 唯一触发路径，
 *        缺失 onJump → 翻页按钮全部静默失效 → 用户看到"只能加载第一页/不能翻页"）；
 *     ② 绝版数据兜底链：@resource 同步预热失败(Tampermonkey 大文件 3.5MB 偶发静默失败)→ 异步拉远程源三级回退
 *        (fastly.jsdelivr → cdn.jsdelivr → raw.githubusercontent) + 24h TTL 缓存跨会话秒开 + 6h 后台节流
 *        静默刷新；首次进入 tab 显示加载骨架(避免误判为"无数据"),远程源回调内触发 renderDelistedGamesList() 重渲染；
 *     ③ 工具栏新增"从远程源重新加载"按钮(force 走全链路,30s 兜底还原 spinner 防止失败场景卡死)；
 *     ④ delistedState.pageSize 50→48 与其他 tab 保持一致；
 *     ⑤ getFilteredDelistedApps 缓存键加入 ownedIds 集合指纹(前 8 个 appid djb2 哈希 + size),
 *        同数量不同游戏的 owned 集合变化时 subFilter=owned/missing 筛选结果精确失效(此前仅按 size 粗粒度失效,
 *        新购买/退款的绝版游戏不展示/错误展示)
 *   v1.9.46: 主题层适配（配合主脚本 v2.11.40 典雅紫/经典蓝双主题）——JS 模板中 6 处内联紫色
 *     （系列徽章/锁区手动徽章/DLC 提示文字/DLC KPI 边与图标/dlcBadgeStyle 常量）改用
 *     var(--sglv-accent 及派生 token) 并带紫色 fallback，主题切换时随主脚本主题层 :root 即时变色；
 *     面板 CSS 类级紫色由主脚本主题层 Part E（html[data-sglv-theme="blue"] 前缀高特异性覆盖）处理，本库 CSS 零改动
 *   v1.9.44: 封面交叉缓存（按页面需求方向取缓存，杜绝样式格式不匹配的缓存地址直用）——
 *     ① coverGoodUrl 方向严格读取：所有缓存层（宿主会话 good 缓存 / steamui 精确 URL）均以
 *        _sgcvUrlMatchesKind 校验方向（poster=竖版 library_600x900 族，capsule/header=横版），
 *        方向不匹配的条目不再直接返回——poster 缓存曾被横版兜底 URL 污染（v1.9.42 起 API 兜底
 *        与链尾 header 加载成功即写入 poster 缓存），竖版视图直用导致裁切错位、参差不齐
 *     ② 竖版缺失标记 + 横版替代交叉缓存：coverVerticalMissing（poster 缓存横版条目 =
 *        此前 poster 链已耗尽至横版兜底的会话级结论）+ coverHorizontalFallbackUrl
 *        （仅返回 poster 标记条目——capsule/header 缓存存在 ≠ 竖版资产缺失，
 *        未确认缺失时交叉读取会跳过竖版链探测直接加载错位横图），
 *        四个 poster 函数（series/blocked/psplus/epic）标记命中时横版替代直用并 letterbox 显示，
 *        免去每次渲染重爬整条竖版链；竖版未确认缺失时绝不使用横版（保证竖版优先语义）
 *     ③ 竞速兜底方向门控：_sgcvCoverRace 对 API URL 方向校验，poster kind 拒绝横版劫持
 *        （API filters=basic 恒返回横版 header_image，劫持会压制链上更深处的竖版资产，
 *        并把横版写入 poster 缓存造成"有竖版资产的游戏显示横版"的会话级污染）
 *     ④ _sgcvPosterOnloadAttr 统一 poster onload（宽图检测 letterbox + good 记录），
 *        blocked/psplus/epic 海报函数补齐 v1.9.43 只加在 seriesCoverImg 的宽图检测
 *   v1.9.43: 系列封面方向门控 + API 兜底竞速（修复"竖屏封面显示横板封面、横板封面长时间无法加载"）——
 *     ① 根因 A（竖版显示横图）：数据源 poster 字段（steam_vediogame_selected.json）实测 340/340
 *        全为横版 header URL（并非 v1.9.30 文档假设的竖版 library_600x900_2x），v1.9.30 起
 *        seriesCoverImg 将其直接作为竖版 kind 初始 src → 2:3 竖版卡片 object-fit:cover 裁切变形，
 *        且压制了已有竖版资产游戏正常显示。修复：poster 字段方向门控（_sgcvIsVerticalUrl 判定
 *        library_600x900 族）——竖版 kind 仅接受竖版 URL，横版 kind 仅接受横版 URL；
 *        竖版 kind 无可用 poster 时走竖版语言变体链（library_600x900_2x 置顶）
 *     ② 根因 B（横版封面黑屏 ~22s）：新游戏（未上市/新上架）商店资产仅存在于
 *        store_item_assets hash 路径，无 hash 传统链（hero 16 + capsule 20 = 36 URL）全部 404，
 *        串行爬取约 22s 后才触发 appdetails API 兜底。修复：_sgcvCoverRace 竞速兜底——
 *        首个 onerror 即后台拉起 Host.fetchCoverApiUrl（宿主三级缓存 + 并发去重），CDN 链
 *        继续走，API 先返回且图片尚未加载成功时直接劫持 src（失败场景 ~22s → ~2s）
 *     ③ seriesCapsuleImg 横版 poster 复用：hero 链首未命中后第 2 跳即命中 poster 预验证
 *        header URL（460x215 与封面视图容器 aspect-ratio 460/215 完全一致）
 *     ④ 竖版无资产 letterbox：poster kind onload 宽图检测（naturalWidth>naturalHeight 追加
 *        sglv-img-wide 类）→ object-fit:contain + 渐变底，API 兜底返回的横版 header 完整显示不裁切
 *     ⑤ 竞速兜底同步接入 blocked/psplus/epic 六个封面函数（老游戏无 library 资产场景同样提速）
 *   v1.9.42: 封面高清增强（竖版 2x 默认 + 横版 hero 高清 2x，参考 sglv-cover-fallback.lib.js v1.2.0）——
 *     ① 横版 capsule 链增强：coverChainLang 对 capsule kind 头部插入 hero 高清增强链
 *        （library_hero_2x 3840x1240 → library_hero 1920x620 → 原 capsule_467x181 链 → header 兜底），
 *        hero 高清 2x 成为默认横版封面；_heroPrefixChain 去除 hero 链尾 header（保持 capsule 资产
 *        优先级高于 header），_dedupeChain 去重；对 8 个封面函数 + GOTY + 系列封面视图全量生效
 *     ② 新增 heroEnhancedChain(appid)：cover-fallback 可用时复用其 hero 链（含中文语言变体
 *        library_hero_schinese_2x 置顶）；不可用时手工构建同序 4CDN 链，可选依赖缺失不降级
 *     ③ coverGoodUrl：capsule kind 优先 steamui hero 精确 hash URL（image2x 优先），
 *        其次宿主 good 缓存，最后本 kind steamui URL
 *     ④ 竖版 poster 链保持 2x 置顶断言（library_600x900_2x 高清竖版为默认：cover-fallback 链 /
 *        Host 链 / 数据源 poster 字段三方一致），新增独立测试 sglv-game-collection.lib.test.js 回归
 *   v1.9.41: 封面链语言变体增强（配合 sglv-cover-fallback.lib.js v1.2.0）——
 *     ① 新增模块级 coverChainLang(appid, kind) / coverGoodUrl(appid, kind) 辅助：
 *        SGLVCoverFallback 可用时走其完整链（steamui 精确 hash URL 优先 +
 *        中文界面下语言变体封面 library_600x900_schinese 等置顶 + 4CDN 交叉回退），
 *        不可用时原样回退 Host.coverChainUrls（向后兼容，行为与 v1.9.40 一致）
 *     ② v2.8.0 起全部封面函数（seriesCoverImg / seriesCapsuleImg / psplusPosterImg /
 *        psplusCapsuleImg / epicPosterImg / epicCapsuleImg / dlcPosterImg / dlcCapsuleImg）
 *        已统一改走 unifiedCover + bindRestrictedCoverLoaders——good 缓存查询改为同步读取，
 *        回退链由 addEventListener 驱动（不再依赖跨上下文 inline onerror），
 *        CDN 链换用语言变体链；内联 onerror 链构建逻辑不变
 *     ③ gotyCoverImgTag / _bindGotyCoverDelegation 同步换链（GOTY good 缓存保持独立）
 *     ④ 可选依赖、零破坏：cover-fallback 未加载或 kind 不受支持时自动降级原 Host 链
 *   v1.9.40: 系列分类工具栏更新时间提示移除——
 *     ① 移除常驻状态文本 #sglv-pub-status（"更新: 日期"），该文本为不换行 flex 项，
 *        会压缩供应商/系列切换按钮（flex:1）导致按钮变形
 *     ② 刷新结果摘要改为悬浮提示 .sglv-pub-refresh-toast：绝对定位于模式切换条下方，
 *        不参与 flex 布局，3 秒后自动消失，保留刷新反馈但零布局影响
 *     ③ 移除 pubState.supplierFetchedAt/seriesFetchedAt 及相关赋值（配合宿主 v2.9.113）
 *   v1.9.39: 系列详情工具栏布局重构——
 *     ① 修复工具栏操作选项超出面板宽度导致横向滚动条的问题：改用 flex-wrap 布局，
 *        控件按逻辑分组（完成度 / 拥有筛选 / 排序 / 视图），窄面板自动换行
 *     ② 拥有状态筛选从下拉菜单改为"已拥有"/"未拥有"两个切换标签按钮，
 *        未选中任何标签表示查询全部；点击已激活按钮可取消筛选回到全部
 *   v1.9.38: PS会免刷新无数据根因修复 + 移除手动刷新按钮——
 *     ① 修复刷新后数据消失：_mergeByAppid 按 appid 合并，但 PS会免条目字段为
 *        recordId/steamAppId（无 appid），非空状态合并时全部条目被丢弃为空数组，
 *        且空数组写回永久缓存导致后续加载也空白。上游为全量快照（psplus-data-sync.js
 *        每日全量镜像），改为远程快照整体替换 state 与缓存，不再增量合并
 *     ② 移除工具栏刷新按钮（数据变更频率低，无需手动更新），保留 6h 后台节流静默刷新
 *     ③ 删除 force 刷新相关代码：loadPsplusGames force 分支、_refreshPsplusFromRemote
 *        force 参数/spinner/状态文本、psplusState.refreshResult/showResultUntil、
 *        #sglv-ps-refresh spinner CSS；renderPsplusRefreshStatus 简化为仅显示更新时间
 *   v1.9.37: PS会免降级数据源——
 *     ① 新增 PSPLUS_BACKUP_URLS 三级 CDN 回退链（SmallRob/steam-namespace 镜像，
 *        由 js_script/psplus-data-sync.js 每日同步自主源 oXnMe/psplus-steam-overlay）
 *     ② _refreshPsplusFromRemote 改为主源 + 降级源多级回退（_tryNextUrl 模式）：
 *        主源失败（网络错误/超时/非2xx/格式无效）时依次尝试 3 个镜像源，
 *        全部失败才报错并尝试缓存恢复（参照 EPIC_GITHUB_URLS _tryNextGithubSource 写法）
 *   v1.9.35: 系列分类筛选与封面视图优化——
 *     ① 移除点击进度条筛选逻辑，改为筛选下拉菜单（全部/已拥有/未拥有，默认全部），
 *        进度条保留为纯视觉收集完成度指示器（不可点击）
 *   v1.9.34: 系列详情工具栏布局重构——工具栏操作选项超出面板宽度导致横向滚动条，
 *     改用 flex-wrap 布局，控件按逻辑分组（完成度 / 拥有筛选 / 排序 / 视图），窄面板自动换行
 *   v1.9.30: 系列封面竖版化（数据源 poster 字段作为竖版 kind 初始 src）
 */
window.SGLVCollection = (function () {
    /**
     * HTML 转义助手（v2.42.2 新增）。
     * 背景：供应商名 / 系列名来自**远程可改写**的 game-db JSON
     *   （@resource steam-namespace@main/data/game-db-v1.2.json），
     *   之前直接拼进 innerHTML —— 远程数据一旦被投毒，即可在 Steam 页面上执行任意脚本。
     *   本库此前**完全没有**转义助手（其它模块各自有 escHtml，这里补齐）。
     */
    function sgcEsc(v) {
        return String(v == null ? '' : v).replace(/[&<>"']/g, (c) => (
            { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]
        ));
    }
    '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;
    }
    // v2.0.0: 4 CDN 前缀(顺序与 sglv-cover-fallback.lib.js v2.0.0 一致:cdn.cloudflare 链首,
    //   老游戏最稳;新游戏哈希子目录走 store_item_assets/akamai/fastly 兜底)
    //   v1.9.42 用 shared.akamai 优先,新游戏走哈希子目录命中,但老游戏 4-5 次 404 浪费
    const _COVER_CDNS = [
        'https://cdn.cloudflare.steamstatic.com/steam/apps/',
        'https://shared.akamai.steamstatic.com/store_item_assets/steam/apps/',
        'https://cdn.akamai.steamstatic.com/steam/apps/',
        'https://shared.fastly.steamstatic.com/store_item_assets/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;
        // v2.9.3: 横版视图共享 header 槽位 —— 受限/PS/Epic/GOTY/主面板验证过的横版 URL
        //   统一归一到 header（markLoaded / API 兜底也是这么写的），这里补上交叉读取，
        //   避免同一张 header.jpg 在每个视图各探一次整链
        if (kind !== 'poster') {
            const alts = (kind === 'header') ? ['capsule'] : ['header', 'capsule'];
            for (const ak of alts) {
                let u = '';
                try { u = Host.getPosterGood(appid, ak) || ''; } catch (e) { /* ignore */ }
                if (u && _sgcvUrlMatchesKind(u, kind)) return u;
            }
        }
        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 */ }
        // v2.0.0: 不再 fb.getCoverUrl 兜底(会污染"已验证好 URL"语义,且对 capsule kind
        //   返回 capsule_467x181.jpg 而非 hero 链首,让 seriesCapsuleImg 错失 hero 增强)
        //   调用方应自己取 coverChainLang(appid, kind)[0] 作为初始 src
        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;
}
/* v1.0.4: 发售倒计时徽章(参考 friend-manager sfd-stress-featured-countdown)
   三态:future(将发售,亮橙)/ today(今日,amber 强调+外发光)/ past(已发售,暗灰) */
.sglv-goty-countdown {
    display: inline-flex !important;
    align-items: center !important;
    gap: 2px !important;
    margin-left: 4px !important;
    padding: 1px 6px !important;
    border-radius: 8px !important;
    font-size: 9.5px !important;
    line-height: 1.2 !important;
    font-variant-numeric: tabular-nums !important;
    transition: all .18s var(--sglv-transition, ease) !important;
}
.sglv-goty-countdown-days {
    font-weight: 800 !important;
    font-size: 11px !important;
    letter-spacing: -.3px !important;
}
.sglv-goty-countdown-lbl {
    opacity: .85 !important;
    font-weight: 500 !important;
}
.sglv-goty-countdown--future {
    background: linear-gradient(135deg, rgba(245, 158, 11, 0.18), rgba(255, 159, 67, 0.10)) !important;
    border: 1px solid rgba(245, 158, 11, 0.4) !important;
    color: #f59e0b !important;
    box-shadow: 0 0 6px rgba(245, 158, 11, 0.18) !important;
}
.sglv-goty-countdown--future .sglv-goty-countdown-days {
    color: #fbbf24 !important;
}
.sglv-goty-countdown--today {
    background: linear-gradient(135deg, rgba(34, 197, 94, 0.22), rgba(74, 222, 128, 0.14)) !important;
    border: 1px solid rgba(34, 197, 94, 0.5) !important;
    color: #22c55e !important;
    box-shadow: 0 0 8px rgba(34, 197, 94, 0.3) !important;
    animation: sglv-goty-today-pulse 1.8s ease-in-out infinite !important;
}
.sglv-goty-countdown--today .sglv-goty-countdown-days {
    color: #4ade80 !important;
}
@keyframes sglv-goty-today-pulse {
    0%, 100% { box-shadow: 0 0 8px rgba(34, 197, 94, 0.3); }
    50% { box-shadow: 0 0 14px rgba(34, 197, 94, 0.55); }
}
.sglv-goty-countdown--past {
    background: rgba(148, 163, 184, 0.08) !important;
    border: 1px solid rgba(148, 163, 184, 0.18) !important;
    color: var(--sglv-text-muted, #64748b) !important;
}
.sglv-goty-countdown--past .sglv-goty-countdown-days {
    color: var(--sglv-text-muted, #64748b) !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.x: GotY 时光机 —— 年份时间轴 + 分组 + 焦点卡 + 网格（参考 steam-friend-manager sfd-stress-*）=== */

/* v2.x: GotY 顶部紧凑 —— KPI 卡片覆盖(只影响 goty,不污染其他 tab 共享的 .sglv-trend-kpi-card) */
#sglv-goty-kpi .sglv-trend-kpi-row { gap: 6px !important; margin: 4px 0 2px !important; }
#sglv-goty-kpi .sglv-trend-kpi-card { padding: 6px 10px !important; min-width: 0 !important; }
#sglv-goty-kpi .sglv-trend-kpi-header { margin-bottom: 2px !important; gap: 4px !important; }
#sglv-goty-kpi .sglv-trend-kpi-value { font-size: 18px !important; line-height: 1.1 !important; }
#sglv-goty-kpi .sglv-trend-kpi-label { font-size: 11px !important; }
#sglv-goty-kpi .sglv-trend-kpi-sub { font-size: 10px !important; margin-top: 1px !important; }
#sglv-goty-kpi .sglv-trend-kpi-icon { font-size: 13px !important; }

/* 年份时间轴：渐变主线 + 发光年份节点，点击切换年份(显示/隐藏对应年份块) */
.sglv-goty-timeline {
    position: relative;
    display: flex;
    align-items: flex-start;
    padding: 6px 20px 2px;
    margin: 0 6px 4px;
    flex: none;
    gap: 0;
    justify-content: flex-start;
    overflow-x: auto;
    overflow-y: hidden;
    scrollbar-width: thin;
}
.sglv-goty-timeline::-webkit-scrollbar { height: 4px; }
.sglv-goty-timeline::-webkit-scrollbar-thumb { background: rgba(102, 192, 244, 0.2); border-radius: 2px; }
.sglv-goty-tl-line {
    position: absolute;
    top: 10px;
    left: 20px;
    right: 20px;
    height: 2px;
    background: linear-gradient(90deg, transparent, #06cfbe 12%, #66c0f4 50%, #a78bfa 88%, transparent);
    opacity: 0.7;
    pointer-events: none;
}
.sglv-goty-tl-node {
    position: relative;
    display: flex;
    flex-direction: column;
    align-items: center;
    gap: 2px;
    background: none;
    border: none;
    cursor: pointer;
    padding: 0 6px;
    font-family: inherit;
    color: inherit;
    flex-shrink: 0;
}
.sglv-goty-tl-node:hover .sglv-goty-tl-dot {
    transform: scale(1.4);
    border-color: #66c0f4;
    box-shadow: 0 0 12px rgba(102, 192, 244, 0.8);
}
.sglv-goty-tl-node.sglv-goty-tl-active .sglv-goty-tl-dot {
    background: #66c0f4;
    border-color: #66c0f4;
    box-shadow: 0 0 14px rgba(102, 192, 244, 0.95), 0 0 4px rgba(255, 255, 255, 0.6);
}
.sglv-goty-tl-dot {
    width: 7px;
    height: 7px;
    border-radius: 50%;
    background: #0f172a;
    border: 2px solid rgba(102, 192, 244, 0.55);
    transition: all 0.2s;
    box-shadow: 0 0 6px rgba(102, 192, 244, 0.35);
}
.sglv-goty-tl-year {
    font-size: 10px;
    font-weight: 700;
    color: #64748b;
    letter-spacing: 0.5px;
    transition: color 0.2s, text-shadow 0.2s;
    white-space: nowrap;
}
.sglv-goty-tl-node:hover .sglv-goty-tl-year { color: #9fd0f5; }
.sglv-goty-tl-node.sglv-goty-tl-active .sglv-goty-tl-year {
    color: #66c0f4;
    text-shadow: 0 0 10px rgba(102, 192, 244, 0.7);
}
.sglv-goty-tl-count {
    font-size: 8px;
    color: #94a3b8;
    font-weight: 600;
    line-height: 1;
}
.sglv-goty-tl-node.sglv-goty-tl-active .sglv-goty-tl-count { color: #66c0f4; }

/* 年份分块容器(可滚动) */
.sglv-goty-scroll {
    flex: 1;
    overflow-y: auto;
    overflow-x: hidden;
    min-height: 0;
    padding-right: 2px;
}
.sglv-goty-year-block {
    margin-bottom: 14px;
}

/* 分组(未发售 / 已发售)sticky header */
.sglv-goty-group {
    margin-bottom: 12px;
}
.sglv-goty-group-header {
    display: flex;
    align-items: center;
    gap: 10px;
    padding: 8px 12px;
    background: #1a2233;
    border-radius: 8px;
    margin-bottom: 8px;
    position: sticky;
    top: 0;
    z-index: 10;
    border: 1px solid rgba(102, 192, 244, 0.12);
    cursor: pointer;
    user-select: none;
    transition: background 0.15s;
}
.sglv-goty-group-header:hover { background: #1e2940; }
.sglv-goty-group-caret {
    width: 0;
    height: 0;
    border-left: 5px solid currentColor;
    border-top: 4px solid transparent;
    border-bottom: 4px solid transparent;
    color: #94a3b8;
    transition: transform 0.2s;
    flex-shrink: 0;
}
.sglv-goty-group-header.sglv-goty-group-collapsed .sglv-goty-group-caret {
    transform: rotate(-90deg);
}
.sglv-goty-group-title {
    font-size: 14px;
    font-weight: 700;
    color: #f8fafc;
    flex-shrink: 0;
}
.sglv-goty-group-count {
    font-size: 12px;
    color: #94a3b8;
    flex-shrink: 0;
}
.sglv-goty-group-bar {
    flex: 1;
    height: 8px;
    background: #0f172a;
    border-radius: 4px;
    overflow: hidden;
    min-width: 60px;
}
.sglv-goty-group-bar-fill {
    height: 100%;
    background: linear-gradient(90deg, #4caf50, #66c0f4);
    transition: width 0.3s ease;
}
.sglv-goty-group-pct {
    font-size: 12px;
    font-weight: 600;
    color: #94a3b8;
    flex-shrink: 0;
    min-width: 40px;
    text-align: right;
}
.sglv-goty-group-body {
    display: block;
}
.sglv-goty-group-header.sglv-goty-group-collapsed + .sglv-goty-group-body {
    display: none;
}

/* 焦点大卡(未发售分组前 1-2 个,宽海报贴边) */
.sglv-goty-featured-wrap {
    display: grid;
    grid-template-columns: 1fr 1fr;
    gap: 10px;
    margin-bottom: 10px;
}
.sglv-goty-featured {
    display: flex;
    align-items: center;
    gap: 0;
    border-radius: 10px;
    overflow: hidden;
    background: linear-gradient(135deg, rgba(245, 158, 11, 0.08), rgba(255, 159, 67, 0.04));
    border: 1px solid rgba(245, 158, 11, 0.3);
    cursor: pointer;
    transition: transform 0.15s, border-color 0.2s, box-shadow 0.2s;
    padding: 0 10px 0 0;
}
.sglv-goty-featured:hover {
    transform: translateY(-2px);
    border-color: rgba(245, 158, 11, 0.55);
    box-shadow: 0 6px 18px rgba(0, 0, 0, 0.35);
}
.sglv-goty-featured.owned {
    border-color: rgba(76, 175, 80, 0.4);
    background: linear-gradient(135deg, rgba(76, 175, 80, 0.08), rgba(102, 187, 106, 0.04));
}
.sglv-goty-featured-poster {
    width: 190px;
    aspect-ratio: 460/215;
    object-fit: cover;
    display: block;
    flex-shrink: 0;
    border-radius: 0;
}
.sglv-goty-featured-info {
    min-width: 0;
    display: flex;
    flex-direction: column;
    gap: 4px;
    padding: 10px 14px 10px 12px;
    flex: 1;
}
.sglv-goty-featured-badge {
    display: inline-block;
    align-self: flex-start;
    font-size: 11px;
    font-weight: 700;
    color: #f59e0b;
    background: rgba(245, 158, 11, 0.15);
    border: 1px solid rgba(245, 158, 11, 0.3);
    padding: 1px 8px;
    border-radius: 4px;
    line-height: 1.4;
}
.sglv-goty-featured.owned .sglv-goty-featured-badge {
    color: #66bb6a;
    background: rgba(102, 187, 106, 0.2);
    border-color: rgba(102, 187, 106, 0.4);
}
.sglv-goty-featured-name {
    font-size: 15px;
    font-weight: 700;
    color: #f8fafc;
    overflow: hidden;
    text-overflow: ellipsis;
    white-space: nowrap;
    line-height: 1.3;
}
.sglv-goty-featured-date {
    font-size: 12px;
    color: #94a3b8;
}
.sglv-goty-featured-countdown {
    display: flex;
    flex-direction: column;
    align-items: center;
    justify-content: center;
    flex-shrink: 0;
    padding: 0 4px;
    min-width: 64px;
}
.sglv-goty-featured-days {
    font-size: 26px;
    font-weight: 800;
    color: #ff9f43;
    line-height: 1;
}
.sglv-goty-featured.owned .sglv-goty-featured-days { color: #66bb6a; }
.sglv-goty-featured-days-lbl {
    font-size: 10px;
    color: #f59e0b;
    margin-top: 3px;
    white-space: nowrap;
    text-transform: uppercase;
    letter-spacing: 0.5px;
}
.sglv-goty-featured.owned .sglv-goty-featured-days-lbl { color: #66bb6a; }

/* 网格 5 列(共用 card / cover / list 三种视图) */
.sglv-goty-grid {
    display: grid;
    grid-template-columns: repeat(6, 1fr);
    gap: 6px;
}
@media (max-width: 1100px) { .sglv-goty-grid { grid-template-columns: repeat(5, 1fr); } }
@media (max-width: 800px) { .sglv-goty-grid { grid-template-columns: repeat(4, 1fr); } }
.sglv-goty-card {
    display: flex;
    flex-direction: column;
    border-radius: 9px;
    background: rgba(15, 23, 42, 0.5);
    border: 1px solid rgba(102, 192, 244, 0.18);
    overflow: hidden;
    cursor: pointer;
    transition: border-color 0.2s, transform 0.15s, opacity 0.2s, box-shadow 0.2s;
}
.sglv-goty-card:hover {
    border-color: rgba(102, 192, 244, 0.55);
    transform: translateY(-2px);
    box-shadow: 0 6px 18px rgba(0, 0, 0, 0.35);
}
.sglv-goty-card-img {
    width: 100%;
    aspect-ratio: 2/3;
    object-fit: cover;
    display: block;
    background: #0f172a;
}
.sglv-goty-card-img-wrap { position: relative; }
.sglv-goty-card-body {
    padding: 4px 6px 5px;
    display: flex;
    flex-direction: column;
    gap: 2px;
}
.sglv-goty-card-name {
    font-size: 11px;
    font-weight: 600;
    color: #f1f5f9;
    overflow: hidden;
    text-overflow: ellipsis;
    white-space: nowrap;
    line-height: 1.25;
}
.sglv-goty-card-meta {
    display: flex;
    align-items: center;
    gap: 4px;
    font-size: 10px;
    color: #94a3b8;
    line-height: 1.2;
}
.sglv-goty-card-owned {
    display: inline-flex;
    align-items: center;
    gap: 2px;
    font-size: 9px;
    font-weight: 700;
    color: #66bb6a;
    background: rgba(102, 187, 106, 0.18);
    border: 1px solid rgba(102, 187, 106, 0.35);
    padding: 1px 5px;
    border-radius: 3px;
    line-height: 1.3;
}
.sglv-goty-card-not-owned {
    display: inline-flex;
    align-items: center;
    font-size: 9px;
    font-weight: 600;
    color: #94a3b8;
    background: rgba(148, 163, 184, 0.1);
    border: 1px solid rgba(148, 163, 184, 0.18);
    padding: 1px 5px;
    border-radius: 3px;
    line-height: 1.3;
}
.sglv-goty-card-countdown {
    font-size: 9.5px;
    font-weight: 700;
    line-height: 1.3;
}
.sglv-goty-card-countdown.future { color: #f59e0b; }
.sglv-goty-card-countdown.today { color: #66c0f4; }
.sglv-goty-card-countdown.past { color: #64748b; }

/* list 视图(行项) */
.sglv-goty-list-view { display: flex; flex-direction: column; gap: 4px; }
.sglv-goty-list-item {
    display: flex;
    align-items: center;
    gap: 10px;
    padding: 6px 8px;
    border-radius: 6px;
    background: rgba(15, 23, 42, 0.4);
    border: 1px solid rgba(102, 192, 244, 0.12);
    cursor: pointer;
    transition: background 0.15s, border-color 0.15s;
}
.sglv-goty-list-item:hover { background: rgba(15, 23, 42, 0.7); border-color: rgba(102, 192, 244, 0.35); }
.sglv-goty-list-icon { width: 60px; height: 30px; object-fit: cover; border-radius: 4px; flex-shrink: 0; }
.sglv-goty-list-info { flex: 1; min-width: 0; display: flex; flex-direction: column; gap: 2px; }
.sglv-goty-list-name {
    font-size: 13px;
    font-weight: 600;
    color: #f1f5f9;
    overflow: hidden;
    text-overflow: ellipsis;
    white-space: nowrap;
}
.sglv-goty-list-meta {
    display: flex;
    align-items: center;
    gap: 6px;
    font-size: 11px;
    color: #94a3b8;
}

/* 工具条 + 顶部 chip 行(回归一行 chip 风格,与 sglv 主色一致) */
.sglv-goty-toolbar-row {
    display: flex;
    align-items: center;
    gap: 6px;
    padding: 4px 8px 6px;
    flex-wrap: wrap;
}
.sglv-goty-toolbar-row .sglv-search { flex: 1; min-width: 120px; }
.sglv-goty-empty {
    text-align: center;
    padding: 40px 16px;
    color: #94a3b8;
    font-size: 13px;
}

/* === 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: 72px !important;
    height: 56px !important;
    opacity: 0.85 !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; }

/* v2.9.9: PS 独占占位画居中 + 名称显示优化 ——
   ① 占位画改绝对定位铺满图片盒（aspect-ratio 盒内 height:100% 的解析差异不再影响它），
      flex 双向居中，PS Logo + 名称组稳定落在正中；z-index:0 让真实封面(z-index:1)仍能盖住它。
   ② 名称降为居中、两行省略的小字说明（不再是挤占视觉中心的三行大字），与正文异步官方名同源。 */
.sgc-panel .sglv-card-img-wrap > .sglv-ps-cover-placeholder,
.sgc-panel .sglv-wl-cover-img-wrap > .sglv-ps-cover-placeholder {
    position: absolute !important;
    inset: 0 !important;
    z-index: 0 !important;
    justify-content: center !important;
    align-items: center !important;
    gap: 6px !important;
    padding: 10px !important;
}
.sgc-panel .sglv-ps-cover-placeholder .sglv-ps-cover-name {
    max-width: 88% !important;
    font-size: 10px !important;
    font-weight: 600 !important;
    line-height: 1.3 !important;
    letter-spacing: 0.2px !important;
    -webkit-line-clamp: 2 !important;
    opacity: 0.92 !important;
}

/* 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; }

/* === v2.9.7: PS 独占（非 Steam 游戏）真实封面层 ===
   参考 steam-friend-manager 1.6.2 的 .sfd-tga-excl-img：平台占位画垫底，
   商店主视觉绝对定位盖在其上；图片加载失败由 JS 直接移除 img，保住占位画。 */
.sglv-ps-excl-cover {
    position: absolute !important;
    inset: 0;
    z-index: 1;
    width: 100% !important;
    height: 100% !important;
    object-fit: cover;
    /* 主视觉为 1024×1024 方图：2:3 海报位裁上下、460/215 横版裁左右，
       焦点上移（center 20%）保住方图上方的游戏 LOGO 区 */
    object-position: center 20%;
    opacity: 0;
    transition: opacity .18s ease;
}
.sglv-ps-excl-cover.sglv-ps-excl-cover-loaded { opacity: 1 !important; }
/* 列表视图图标位：包一层 relative 容器，封面图绝对定位盖住 PS 图标 */
.sglv-ps-excl-iconwrap { position: relative !important; overflow: hidden !important; }

/* === 加载中骨架：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;
}


/* v2.0.0: sidebar 模式提示 */
.sglv-pub-sidebar-hint {
    padding: 12px 14px;
    margin-top: 8px;
    font-size: 11.5px;
    color: #8a9ba8;
    text-align: center;
    background: rgba(102, 192, 244, 0.05);
    border: 1px dashed rgba(102, 192, 244, 0.2);
    border-radius: 6px;
    line-height: 1.5;
}


/* === 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: 捆绑包标签页专用样式 === */

/* === 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-metric-card: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;
    }
}

/* === v2.6.0: 受限游戏板组件样式已迁至下方 v2.6.0 区块（HERO + 卡片重构），
   旧的一排等宽 KPI 小卡样式已随版本收敛一并移除。 === */


/* === v2.8.0: 捆绑包「内容墙」重构 ===
   设计思路反转：捆绑包的价值在于"包里有什么"，主游戏封面是干扰项。
   卡片 = 顶部主游戏标题条（上下文）+ 3 列 DLC 封面墙（主体）。
   每张 DLC 有独立 appid，可直接取真实 header.jpg —— 旧版 24px 社区图标读不出美术细节。 */

.sglv-bundle-wall {
    display: grid !important;
    grid-template-columns: repeat(auto-fill, minmax(232px, 1fr)) !important;
    gap: 12px !important;
}

.sglv-bundle-card {
    position: relative;
    display: flex;
    flex-direction: column;
    border-radius: 10px;
    overflow: hidden;
    border: 1px solid rgba(255, 255, 255, 0.055);
    background: linear-gradient(180deg, rgba(255, 255, 255, 0.035) 0%, rgba(255, 255, 255, 0.015) 100%);
    box-shadow: 0 1px 2px rgba(0, 0, 0, 0.22);
    transition: transform 0.18s cubic-bezier(0.22, 1, 0.36, 1),
                border-color 0.18s ease, box-shadow 0.18s ease;
}
.sglv-bundle-card:hover {
    transform: translateY(-3px);
    border-color: rgba(102, 192, 244, 0.36);
    box-shadow: 0 10px 26px -8px rgba(0, 0, 0, 0.6), 0 0 0 1px rgba(102, 192, 244, 0.1);
}

/* ---- 顶部标题条：主游戏退为上下文 ---- */
.sglv-bundle-head {
    padding: 8px 10px 7px;
    border-bottom: 1px solid rgba(255, 255, 255, 0.045);
    background: rgba(255, 255, 255, 0.018);
    position: relative;
}
.sglv-bundle-title-row {
    display: flex;
    align-items: baseline;
    gap: 6px;
    cursor: pointer;
    min-width: 0;
}
.sglv-bundle-title-row:hover .sglv-bundle-title { color: #eef5fb !important; }
.sglv-bundle-title {
    font-size: 12px;
    font-weight: 700;
    color: #dce8f4;
    line-height: 1.3;
    letter-spacing: 0.01em;
    white-space: nowrap;
    overflow: hidden;
    text-overflow: ellipsis;
    flex: 1 1 auto;
    min-width: 0;
    transition: color 0.15s;
}
.sglv-bundle-appid {
    font-size: 9px;
    color: rgba(148, 163, 184, 0.5);
    font-variant-numeric: tabular-nums;
    flex-shrink: 0;
}
.sglv-bundle-meta {
    display: flex;
    align-items: center;
    gap: 6px;
    margin-top: 3px;
    font-size: 9.5px;
    color: #8296ab;
    font-variant-numeric: tabular-nums;
}
.sglv-bundle-stat { display: inline-flex; align-items: center; gap: 3px; }
.sglv-bundle-stat-ico { font-size: 9px; opacity: 0.8; }
.sglv-bundle-sep { width: 1px; height: 9px; background: rgba(255, 255, 255, 0.12); }
/* 已拥有的主游戏：标题条左侧一条绿色标记 */
.sglv-bundle-head.is-owned::before {
    content: '';
    position: absolute;
    left: 0;
    top: 7px;
    bottom: 7px;
    width: 2.5px;
    border-radius: 0 2px 2px 0;
    background: linear-gradient(180deg, #34d399, #22c55e);
    box-shadow: 0 0 7px rgba(52, 211, 153, 0.5);
}

/* ---- DLC 封面墙：3 列 ---- */
.sglv-bundle-tiles {
    display: grid;
    grid-template-columns: repeat(3, 1fr);
    gap: 3px;
    padding: 6px;
}
.sglv-bundle-tiles-single { grid-template-columns: 1fr; }

.sglv-bundle-tile {
    position: relative;
    aspect-ratio: 16 / 10;
    border-radius: 5px;
    overflow: hidden;
    cursor: pointer;
    background: rgba(255, 255, 255, 0.04);
    border: 1px solid rgba(255, 255, 255, 0.05);
    transition: transform 0.16s cubic-bezier(0.22, 1, 0.36, 1),
                border-color 0.16s ease, box-shadow 0.16s ease, z-index 0s;
}
.sglv-bundle-tile:hover {
    transform: scale(1.07);
    border-color: rgba(102, 192, 244, 0.6);
    box-shadow: 0 6px 16px -4px rgba(0, 0, 0, 0.7), 0 0 0 1px rgba(102, 192, 244, 0.25);
    z-index: 3;
}
/* 搜索命中的 DLC：琥珀色描边 */
.sglv-bundle-tile.is-hit {
    border-color: rgba(251, 191, 36, 0.75);
    box-shadow: 0 0 0 1px rgba(251, 191, 36, 0.3), 0 0 12px -2px rgba(251, 191, 36, 0.35);
}
/* 已拥有 DLC：左上角小绿点 */
.sglv-bundle-tile.is-owned::after {
    content: '';
    position: absolute;
    top: 4px;
    left: 4px;
    width: 6px;
    height: 6px;
    border-radius: 50%;
    background: #34d399;
    box-shadow: 0 0 0 1.5px rgba(10, 18, 28, 0.85), 0 0 7px rgba(52, 211, 153, 0.75);
    z-index: 4;
    pointer-events: none;
}
/* tile 内的封面：填满 + letterbox */
.sglv-bundle-tile .sglv-img-wrapper { position: absolute; inset: 0; }
.sglv-bundle-tile .sglv-img-wrapper > .sglv-card-img { object-fit: cover !important; }
/* 进包次数角标 */
.sglv-bundle-tile-num {
    position: absolute;
    right: 3px;
    bottom: 3px;
    z-index: 4;
    min-width: 15px;
    padding: 0 3px;
    border-radius: 3px;
    background: rgba(8, 14, 22, 0.82);
    border: 1px solid rgba(245, 158, 11, 0.4);
    color: #fbbf24;
    font-size: 8.5px;
    font-weight: 700;
    line-height: 13px;
    text-align: center;
    font-variant-numeric: tabular-nums;
    backdrop-filter: blur(3px);
    -webkit-backdrop-filter: blur(3px);
    pointer-events: none;
}
.sglv-bundle-tile-badge {
    position: absolute;
    left: 4px;
    bottom: 4px;
    z-index: 4;
    padding: 1px 5px;
    border-radius: 3px;
    background: rgba(8, 14, 22, 0.8);
    border: 1px solid rgba(52, 211, 153, 0.4);
    color: #34d399;
    font-size: 8.5px;
    font-weight: 700;
    line-height: 14px;
    backdrop-filter: blur(3px);
    -webkit-backdrop-filter: blur(3px);
    pointer-events: none;
}

/* ---- 展开按钮：ghost 风格，不用白底黑字 ---- */
.sglv-bundle-expand {
    display: flex;
    align-items: center;
    justify-content: center;
    gap: 5px;
    width: calc(100% - 12px);
    margin: 0 6px 6px;
    padding: 4px 0;
    border-radius: 5px;
    background: rgba(102, 192, 244, 0.07);
    border: 1px solid rgba(102, 192, 244, 0.18);
    color: #8fc9e8;
    font-size: 9.5px;
    font-weight: 600;
    cursor: pointer;
    transition: background 0.15s, border-color 0.15s, color 0.15s;
}
.sglv-bundle-expand:hover {
    background: rgba(102, 192, 244, 0.14);
    border-color: rgba(102, 192, 244, 0.38);
    color: #b6e0f5;
}
.sglv-bundle-expand.is-open {
    background: rgba(255, 255, 255, 0.035);
    border-color: rgba(255, 255, 255, 0.1);
    color: #8296ab;
}
.sglv-bundle-expand-caret {
    font-size: 8px;
    opacity: 0.8;
    transition: transform 0.2s ease;
    display: inline-block;
}
.sglv-bundle-expand.is-open .sglv-bundle-expand-caret { transform: rotate(180deg); }

/* 折叠区展开时不额外加间距 */
.sglv-bundle-tiles-rest { padding-top: 0; }

/* === v2.9.0: 年度大片「大海报」视图 ===
   此前 cover 视图复用 card 视图的 .sglv-goty-grid + renderGotyGridCard，
   渲染结果完全一致 → 点击「大海报」按钮后视觉零变化（用户报"切换没效果"）。
   这里给出独立的横向宽海报布局：封面铺满 + 底部渐变 + 标题信息叠加。 */
.sglv-goty-cover-grid {
    display: grid !important;
    grid-template-columns: repeat(auto-fill, minmax(272px, 1fr)) !important;
    gap: 12px !important;
    padding: 10px 0;
}
.sglv-goty-cover-card {
    position: relative;
    border-radius: 10px;
    overflow: hidden;
    cursor: pointer;
    border: 1px solid rgba(255, 255, 255, 0.06);
    box-shadow: 0 1px 3px rgba(0, 0, 0, 0.3);
    transition: transform 0.2s cubic-bezier(0.22, 1, 0.36, 1),
                border-color 0.2s ease, box-shadow 0.2s ease;
}
.sglv-goty-cover-card:hover {
    transform: translateY(-4px) scale(1.008);
    border-color: rgba(102, 192, 244, 0.45);
    box-shadow: 0 14px 32px -10px rgba(0, 0, 0, 0.72), 0 0 0 1px rgba(102, 192, 244, 0.12);
}
.sglv-goty-cover-img-wrap {
    position: relative;
    aspect-ratio: 460 / 215 !important;   /* header.jpg 原生比例 */
    overflow: hidden;
    background: linear-gradient(145deg, rgba(102,192,244,0.06), rgba(139,92,246,0.06));
}
.sglv-goty-cover-img-wrap .sglv-img-wrapper { position: absolute; inset: 0; }
/* 大海报视图：横图铺满，不留黑边 */
.sglv-goty-cover-img-wrap .sglv-img-wrapper > .sglv-goty-cover-img {
    object-fit: cover !important;
    opacity: 0;
    transition: opacity 0.3s ease;
}
.sglv-goty-cover-img-wrap .sglv-img-wrapper.sglv-img-loaded > .sglv-goty-cover-img { opacity: 1; }
/* 大图上不显示转圈 spinner */
.sglv-goty-cover-img-wrap .sglv-img-wrapper.sglv-img-loading::after { display: none !important; }

/* 底部渐变 + 信息叠加 */
.sglv-goty-cover-grad {
    position: absolute;
    left: 0; right: 0; bottom: 0;
    height: 68%;
    background: linear-gradient(to top,
        rgba(8, 13, 20, 0.94) 0%,
        rgba(8, 13, 20, 0.72) 38%,
        rgba(8, 13, 20, 0.22) 72%,
        transparent 100%);
    pointer-events: none;
    z-index: 2;
}
.sglv-goty-cover-overlay {
    position: absolute;
    left: 0; right: 0; bottom: 0;
    padding: 12px 14px 11px;
    z-index: 3;
    display: flex;
    flex-direction: column;
    gap: 3px;
    pointer-events: none;
}
.sglv-goty-cover-title {
    font-size: 14px;
    font-weight: 700;
    color: #f2f7fb;
    line-height: 1.25;
    letter-spacing: 0.01em;
    text-shadow: 0 1px 6px rgba(0, 0, 0, 0.85);
    display: -webkit-box;
    -webkit-line-clamp: 2;
    -webkit-box-orient: vertical;
    overflow: hidden;
}
.sglv-goty-cover-meta {
    display: flex;
    align-items: center;
    gap: 8px;
    font-size: 10px;
    font-weight: 600;
}
.sglv-goty-cover-owned { color: #34d399; text-shadow: 0 1px 4px rgba(0,0,0,0.8); }
.sglv-goty-cover-not-owned { color: #94a3b8; text-shadow: 0 1px 4px rgba(0,0,0,0.8); }
.sglv-goty-cover-countdown {
    padding: 1px 6px;
    border-radius: 3px;
    background: rgba(245, 158, 11, 0.16);
    border: 1px solid rgba(245, 158, 11, 0.32);
    color: #fbbf24;
    font-size: 9px;
    backdrop-filter: blur(3px);
    -webkit-backdrop-filter: blur(3px);
}
.sglv-goty-cover-countdown.today {
    background: rgba(239, 68, 68, 0.18);
    border-color: rgba(239, 68, 68, 0.4);
    color: #fca5a5;
}
.sglv-goty-cover-countdown.past {
    background: rgba(100, 116, 139, 0.18);
    border-color: rgba(100, 116, 139, 0.35);
    color: #94a3b8;
}
/* 已拥有：左上角绿点 + 细绿边 */
.sglv-goty-cover-card.is-owned { border-color: rgba(52, 211, 153, 0.32); }
.sglv-goty-cover-card.is-owned::after {
    content: '';
    position: absolute;
    top: 9px; left: 9px;
    width: 7px; height: 7px;
    border-radius: 50%;
    background: #34d399;
    box-shadow: 0 0 0 2px rgba(8, 13, 20, 0.85), 0 0 9px rgba(52, 211, 153, 0.8);
    z-index: 4;
}

/* === v2.8.0: 工具栏整合筛选 + 分页到一行 === */
/* 分页器移入 toolbar 后，用弹性占位把左侧控件与右侧分页推到两端。
   core 已有 .sglv-toolbar .sglv-pagination { margin-left: auto }，
   这里补 spacer 作为双保险，并让窄浮窗下分页可换行而不撑破工具栏。 */
.sglv-toolbar-spacer {
    flex: 1 1 auto;
    min-width: 8px;
    height: 1px;
}
.sglv-toolbar .sglv-pagination {
    margin-left: auto !important;
    flex-shrink: 0 !important;
}
.sglv-toolbar .sglv-toolbar-spacer + .sglv-pagination {
    margin-left: 0 !important;   /* spacer 已占位，去掉 auto 避免双重间隙 */
}
/* 状态文本（锁区「更新: 2026-08-10」）与分页之间留出间距 */
.sglv-blocked-status { flex-shrink: 0 !important; }

/* === v2.8.0: 大海报视图（Epic / PS会免 / 系列 / GOTY / DLC）封面容器适配 ===
   这五处原本用裸 <img class="sglv-wl-cover-img"> 直接放进 .sglv-wl-cover-img-wrap，
   现在改为 .sglv-img-wrapper 三态结构，需要补容器规则：
   ① wrapper 撑满父容器（绝对定位），避免图片高度塌陷；
   ② letterbox 改为 cover —— 大海报视图就是给横图"放大展示"的，contain 会留大片黑边；
   ③ 骨架/兜底层沿用受限游戏板那套三态样式，无需额外定义。 */
.sglv-wl-cover-img-wrap {
    position: relative;
    overflow: hidden;
    background: rgba(255, 255, 255, 0.04);
}
.sglv-wl-cover-img-wrap .sglv-img-wrapper {
    position: absolute;
    inset: 0;
    width: 100%;
    height: 100%;
}
/* 大海报视图：横图铺满（cover），这是该视图存在的意义 */
.sglv-wl-cover-img-wrap .sglv-img-wrapper > .sglv-wl-cover-img {
    object-fit: cover !important;
    opacity: 0;
    transition: opacity 0.25s ease;
}
.sglv-wl-cover-img-wrap .sglv-img-wrapper.sglv-img-loaded > .sglv-wl-cover-img {
    opacity: 1;
}
/* 该视图中不显示进度 spinner（大图上转圈很扎眼），只保留淡骨架 */
.sglv-wl-cover-img-wrap .sglv-img-wrapper.sglv-img-loading::after { display: none !important; }
.sglv-wl-cover-img-wrap .sglv-img-wrapper.sglv-img-loading::before { opacity: 0.5; }

/* GOTY 网格卡片内的封面同理 */
.sglv-goty-grid .sglv-img-wrapper { position: relative; width: 100%; height: 100%; }
.sglv-goty-grid .sglv-img-wrapper > .sglv-card-img { object-fit: cover !important; }

/* 系列分类的 header 视图 */
.sglv-pub-list-cover { object-fit: cover !important; }

/* === v2.7.0: HERO 质感打磨 === */
.sglv-hero {
    position: relative;
    overflow: hidden;
    background:
        radial-gradient(120% 140% at 8% -20%, rgba(102, 192, 244, 0.13) 0%, transparent 55%),
        linear-gradient(135deg, rgba(28, 42, 60, 0.78) 0%, rgba(18, 28, 42, 0.9) 100%);
    border-color: rgba(102, 192, 244, 0.2);
    box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.06), 0 4px 18px -8px rgba(0, 0, 0, 0.5);
}
/* 右上角极淡网格纹理，呼应 Steam 的"库"隐喻 */
.sglv-hero::after {
    content: '';
    position: absolute;
    top: 0;
    right: 0;
    width: 180px;
    height: 100%;
    background-image:
        linear-gradient(rgba(255, 255, 255, 0.022) 1px, transparent 1px),
        linear-gradient(90deg, rgba(255, 255, 255, 0.022) 1px, transparent 1px);
    background-size: 14px 14px;
    mask-image: linear-gradient(to left, #000, transparent);
    -webkit-mask-image: linear-gradient(to left, #000, transparent);
    pointer-events: none;
}
.sglv-hero-left, .sglv-hero-right { position: relative; z-index: 1; }

.sglv-hero-num {
    font-size: 38px !important;
    font-weight: 800 !important;
    letter-spacing: -0.03em;
    line-height: 1;
    font-variant-numeric: tabular-nums;
    background: linear-gradient(180deg, #ffffff 20%, #a8c8e0 100%);
    -webkit-background-clip: text;
    background-clip: text;
    -webkit-text-fill-color: transparent;
    text-shadow: none;
}
.sglv-hero-progress {
    height: 6px !important;
    border-radius: 4px;
    background: rgba(255, 255, 255, 0.07);
    box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.3);
    overflow: hidden;
}
.sglv-hero-progress-fill {
    height: 100%;
    border-radius: 4px;
    background: linear-gradient(90deg, #22c55e, #4ade80 55%, #66c0f4);
    box-shadow: 0 0 10px rgba(74, 222, 128, 0.4);
}
.sglv-hero-scope {
    padding: 6px 8px;
    border-radius: 7px;
    background: rgba(255, 255, 255, 0.04);
    border: 1px solid rgba(255, 255, 255, 0.065);
    transition: background 0.16s, border-color 0.16s, transform 0.14s;
}
.sglv-hero-scope:hover { background: rgba(255, 255, 255, 0.085); transform: translateY(-1px); }
.sglv-hero-scope.active {
    background: linear-gradient(180deg, rgba(102, 192, 244, 0.22), rgba(102, 192, 244, 0.12));
    border-color: rgba(102, 192, 244, 0.55);
    box-shadow: 0 0 0 1px rgba(102, 192, 244, 0.18), 0 3px 10px -4px rgba(102, 192, 244, 0.4);
}
.sglv-hero-scope-val {
    font-size: 15px !important;
    font-weight: 700;
    font-variant-numeric: tabular-nums;
    letter-spacing: -0.01em;
}
.sglv-hero-type {
    padding: 3.5px 7px;
    border-radius: 5px;
    transition: background 0.15s, transform 0.12s;
}
.sglv-hero-type:hover { background: rgba(255, 255, 255, 0.055); transform: translateX(2px); }
.sglv-hero-type.active {
    background: rgba(102, 192, 244, 0.14);
    box-shadow: inset 2px 0 0 #66c0f4;
}
.sglv-hero-type-track {
    height: 6px !important;
    border-radius: 4px;
    background: rgba(255, 255, 255, 0.055);
    box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.25);
}
.sglv-hero-type-fill {
    height: 100%;
    border-radius: 4px;
    box-shadow: 0 0 8px currentColor;
}
.sglv-hero-type-count { font-size: 11px !important; font-weight: 700; }
.sglv-hero-type-pct { font-size: 9.5px !important; }

/* === v2.9.2: 三态封面 wrapper 基础规则（补齐缺失的 base）===
   此前工程里只有 ::before/::after 的 override，没有基础定义：
   - .sglv-img-fallback-layer 是普通 block → 永远跟在图片下方占位；
   - .sglv-img-broken 无法隐藏图片；
   - loading 骨架/spinner 没有 content/position，override 全部失效。
   这里补齐 loading / loaded / broken 三态的最小闭环。 */
.sglv-img-wrapper {
    position: relative;
    display: block;
    overflow: hidden;
}
.sglv-img-wrapper > img {
    display: block;
    max-width: 100%;
}
/* 卡片容器内：wrapper 撑满固定比例容器，img 由 core 的
   .sglv-card-img（width/height 100% !important）决定尺寸，
   object-fit:contain 负责 letterbox（横图不硬裁主体） */
.sglv-card-img-wrap > .sglv-img-wrapper {
    position: absolute;
    inset: 0;
}
.sglv-card-img-wrap > .sglv-img-wrapper > img {
    width: 100%;
    height: 100%;
}
.sglv-img-fallback-layer {
    position: absolute;
    inset: 0;
    display: none;
    flex-direction: column;
    align-items: center;
    justify-content: center;
    z-index: 2;
    pointer-events: none;
}
.sglv-img-wrapper.sglv-img-broken > img { visibility: hidden; }
.sglv-img-wrapper.sglv-img-broken > .sglv-img-fallback-layer { display: flex; }
.sglv-img-wrapper.sglv-img-loading::before {
    content: '';
    position: absolute;
    inset: 0;
    z-index: 1;
    background: linear-gradient(100deg, rgba(255,255,255,0.015) 0%, rgba(255,255,255,0.06) 45%, rgba(255,255,255,0.015) 100%);
    background-size: 220% 100%;
    animation: sglv-img-shimmer 1.4s ease-in-out infinite;
}
.sglv-img-wrapper.sglv-img-loading::after {
    content: '';
    position: absolute;
    top: 50%;
    left: 50%;
    z-index: 2;
    width: 20px;
    height: 20px;
    margin: -10px 0 0 -10px;
    border-radius: 50%;
    border: 1.5px solid rgba(102, 192, 244, 0.18);
    border-top-color: rgba(102, 192, 244, 0.7);
    animation: sglv-img-spin 0.9s linear infinite;
}
@keyframes sglv-img-shimmer {
    0% { background-position: 120% 0; }
    100% { background-position: -120% 0; }
}
@keyframes sglv-img-spin {
    to { transform: rotate(360deg); }
}

/* === v2.7.0: broken 占位精致化 —— 去掉粗笨大图标，改为细线图标 + 短标签 === */
.sglv-img-fallback-layer {
    gap: 7px !important;
    background:
        repeating-linear-gradient(45deg, rgba(255, 255, 255, 0.012) 0 6px, transparent 6px 12px),
        linear-gradient(160deg, rgba(30, 42, 58, 0.9), rgba(18, 26, 38, 0.95));
}
.sglv-img-broken-icon {
    width: 26px !important;
    height: 26px !important;
    background: rgba(148, 163, 184, 0.1) !important;
    border: 1px solid rgba(148, 163, 184, 0.16) !important;
    color: rgba(148, 163, 184, 0.55) !important;
}
.sglv-img-broken-icon svg { width: 13px !important; height: 13px !important; }
.sglv-img-broken-label {
    font-size: 9px !important;
    letter-spacing: 0.04em;
    opacity: 0.5;
    font-weight: 500;
}
.sglv-img-broken-blocked .sglv-img-broken-icon,
.sglv-img-wrapper.sglv-img-broken.sglv-img-broken-blocked .sglv-img-broken-icon {
    background: rgba(239, 68, 68, 0.1) !important;
    border-color: rgba(239, 68, 68, 0.2) !important;
    color: rgba(239, 68, 68, 0.55) !important;
}
/* 骨架：更细腻的扫描线 */
.sglv-img-wrapper.sglv-img-loading::before {
    background: linear-gradient(100deg, rgba(255,255,255,0.015) 0%, rgba(255,255,255,0.06) 45%, rgba(255,255,255,0.015) 100%);
    background-size: 220% 100%;
}
.sglv-img-wrapper.sglv-img-loading::after {
    width: 20px;
    height: 20px;
    margin: -10px 0 0 -10px;
    border-width: 1.5px;
    border-color: rgba(102, 192, 244, 0.18);
    border-top-color: rgba(102, 192, 244, 0.7);
}

/* === v2.7.0: 质感打磨 —— 层级、材质、微交互 === */

/* 卡片：更克制的边框 + 悬停抬升 + 顶部高光 */
.sglv-card-grid .sglv-game-card {
    border: 1px solid rgba(255, 255, 255, 0.055) !important;
    border-radius: 9px !important;
    background: linear-gradient(180deg, rgba(255, 255, 255, 0.038) 0%, rgba(255, 255, 255, 0.018) 100%) !important;
    box-shadow: 0 1px 2px rgba(0, 0, 0, 0.22);
    transition: transform 0.18s cubic-bezier(0.22, 1, 0.36, 1),
                border-color 0.18s ease,
                box-shadow 0.18s ease,
                background 0.18s ease !important;
}
.sglv-card-grid .sglv-game-card:hover {
    transform: translateY(-3px) !important;
    border-color: rgba(102, 192, 244, 0.38) !important;
    background: linear-gradient(180deg, rgba(102, 192, 244, 0.075) 0%, rgba(255, 255, 255, 0.022) 100%) !important;
    box-shadow: 0 8px 22px -6px rgba(0, 0, 0, 0.55), 0 0 0 1px rgba(102, 192, 244, 0.12);
}
/* 顶部 1px 高光，模拟受光边缘 */
.sglv-card-grid .sglv-game-card::before {
    content: '';
    position: absolute;
    top: 0;
    left: 8px;
    right: 8px;
    height: 1px;
    background: linear-gradient(90deg, transparent, rgba(255, 255, 255, 0.16), transparent);
    pointer-events: none;
    z-index: 7;
    opacity: 0.75;
}
.sglv-card-grid .sglv-game-card { position: relative !important; }

/* 封面区：更深的底 + 底部渐隐，让横图与卡片体衔接自然 */
.sglv-card-grid .sglv-game-card .sglv-card-img-wrap {
    position: relative;
    overflow: hidden;
    border-bottom: 1px solid rgba(255, 255, 255, 0.045);
}
.sglv-card-grid .sglv-game-card .sglv-card-img-wrap::after {
    content: '';
    position: absolute;
    left: 0;
    right: 0;
    bottom: 0;
    height: 26px;
    background: linear-gradient(to top, rgba(18, 26, 38, 0.55), transparent);
    pointer-events: none;
    z-index: 5;
}

/* 游戏名：两行截断（部分长名），hover 显示全名 */
.sglv-card-grid .sglv-game-card .sglv-card-name {
    font-size: 11px !important;
    font-weight: 600 !important;
    line-height: 1.32 !important;
    color: #d5e2ee !important;
    letter-spacing: 0.01em;
    display: -webkit-box !important;
    -webkit-line-clamp: 2;
    -webkit-box-orient: vertical;
    overflow: hidden;
    min-height: 29px;   /* 两行高度，保证同行卡片正文对齐 */
    margin-bottom: 2px;
}
.sglv-card-grid .sglv-game-card:hover .sglv-card-name { color: #eef5fb !important; }
.sglv-card-grid .sglv-game-card .sglv-card-id-inline {
    font-size: 9px !important;
    opacity: 0.5;
    font-variant-numeric: tabular-nums;
}

/* 两栏 meta：细分隔线 + 更克制的排版 */
.sglv-card-meta2 {
    display: flex !important;
    align-items: center;
    justify-content: space-between;
    gap: 6px;
    margin-top: 2px;
    padding-top: 4px;
    border-top: 1px solid rgba(255, 255, 255, 0.04);
    min-width: 0;
}
.sglv-meta-col-left,
.sglv-meta-col-right {
    display: flex;
    align-items: center;
    gap: 4px;
    min-width: 0;
}
.sglv-meta-col-left { flex: 1 1 auto; overflow: hidden; }
.sglv-meta-col-right { flex: 0 0 auto; }

/* 分类徽章：更精致 —— 半透明底 + 左侧色点 */
.sglv-type-badge {
    display: inline-flex !important;
    align-items: center;
    font-size: 9px !important;
    font-weight: 600 !important;
    padding: 1.5px 5px 1.5px 4px !important;
    border-radius: 4px !important;
    border: 1px solid transparent !important;
    line-height: 1.45;
    white-space: nowrap;
    flex-shrink: 0;
    letter-spacing: 0.01em;
}

/* 拥有态文字：纯文字，无背景无边框 */
.sglv-own-text {
    font-size: 9px !important;
    font-weight: 600 !important;
    line-height: 1.45;
    white-space: nowrap;
    flex-shrink: 0;
    letter-spacing: 0.01em;
}
.sglv-own-text.owned { color: #34d399 !important; }
.sglv-own-text.missing { color: #fbbf24 !important; }

/* 右栏数值：小图标 + tabular 对齐 */
.sglv-meta-col-right .sglv-meta-item {
    display: inline-flex !important;
    align-items: center;
    gap: 2.5px;
    font-size: 9px !important;
    color: rgba(148, 163, 184, 0.85) !important;
    white-space: nowrap;
    line-height: 1.45;
    font-variant-numeric: tabular-nums;
}
.sglv-meta-col-right .sglv-meta-item svg {
    width: 9px !important;
    height: 9px !important;
    opacity: 0.55;
    flex-shrink: 0;
}
.sglv-meta-col-right .sglv-m-playtime { color: #66c0f4 !important; font-weight: 700 !important; }

/* 状态斜切带：更利落 */
.sglv-own-flag {
    position: absolute !important;
    bottom: 0;
    right: 0;
    z-index: 8;
    pointer-events: none;
    clip-path: polygon(16px 0, 100% 0, 100% 100%, 0 100%);
    border-top-left-radius: 2px;
    transition: opacity 0.18s ease;
}
.sglv-own-flag.missing {
    width: 54px;
    height: 4px;
    background: linear-gradient(90deg, rgba(245, 158, 11, 0.4), #f59e0b 70%);
}
.sglv-own-flag.owned {
    width: 30px;
    height: 3px;
    clip-path: polygon(12px 0, 100% 0, 100% 100%, 0 100%);
    background: linear-gradient(90deg, rgba(52, 211, 153, 0.4), #34d399 70%);
}
.sglv-card-grid .sglv-game-card:hover .sglv-own-flag { opacity: 0.85; }

/* 网格间距略增，给抬升留呼吸 */
.sglv-card-grid { gap: 12px !important; }

/* === v2.6.0: 受限游戏板 HERO —— 铺满宽度的仪表盘 === */
.sglv-hero {
    display: flex !important;
    align-items: stretch;
    gap: 14px;
    width: 100%;
    padding: 12px 14px 13px;
    margin-bottom: 10px;
    border-radius: 10px;
    border: 1px solid rgba(102, 192, 244, 0.16);
    background: linear-gradient(135deg, rgba(27, 40, 56, 0.72) 0%, rgba(20, 32, 48, 0.86) 100%);
    box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.04);
}
/* 左区：主数字 —— flex: 0 0 auto 保证数字不被压缩，宽度随内容自适应 */
.sglv-hero-left {
    flex: 0 0 auto;
    min-width: 148px;
    display: flex;
    flex-direction: column;
}
.sglv-hero-title {
    font-size: 10px;
    font-weight: 600;
    letter-spacing: 0.08em;
    color: #7e93ab;
    text-transform: uppercase;
}
.sglv-hero-num {
    font-size: 34px;
    font-weight: 800;
    line-height: 1.05;
    letter-spacing: -0.02em;
    color: #e8f1fa;
    margin: 3px 0 7px;
    text-shadow: 0 0 22px rgba(102, 192, 244, 0.28);
}
.sglv-hero-progress {
    width: 100%;
    height: 4px;
    border-radius: 3px;
    background: rgba(255, 255, 255, 0.08);
    overflow: hidden;
}
.sglv-hero-progress-fill {
    height: 100%;
    border-radius: 3px;
    background: linear-gradient(90deg, #34d399, #66c0f4);
    transition: width 0.4s ease;
}
.sglv-hero-progress-cap {
    font-size: 9px;
    color: #6f8399;
    margin-top: 4px;
    letter-spacing: 0.02em;
}
/* scope 卡：紧凑双联，取代原 KPI 行里的"在库/未拥有"两张卡 */
.sglv-hero-scope-row {
    display: flex;
    gap: 6px;
    margin-top: 9px;
}
.sglv-hero-scope {
    flex: 1;
    min-width: 62px;
    padding: 5px 7px;
    border-radius: 6px;
    background: rgba(255, 255, 255, 0.045);
    border: 1px solid rgba(255, 255, 255, 0.07);
    cursor: pointer;
    transition: background 0.15s, border-color 0.15s, transform 0.12s;
}
.sglv-hero-scope:hover {
    background: rgba(255, 255, 255, 0.09);
    transform: translateY(-1px);
}
.sglv-hero-scope.active {
    background: rgba(102, 192, 244, 0.17);
    border-color: rgba(102, 192, 244, 0.5);
}
.sglv-hero-scope-val {
    display: block;
    font-size: 14px;
    font-weight: 700;
    line-height: 1.2;
    color: #dbe7f3;
}
.sglv-hero-scope-label {
    display: block;
    font-size: 9px;
    color: #8296ab;
    margin-top: 1px;
}
/* 右区：类型占比列表 —— flex:1 吃掉全部剩余宽度，这是"铺满浮窗"的关键 */
.sglv-hero-right {
    flex: 1 1 auto;
    min-width: 0;
    display: flex;
    flex-direction: column;
    gap: 3px;
    padding-left: 14px;
    border-left: 1px solid rgba(255, 255, 255, 0.07);
}
.sglv-hero-right-head {
    font-size: 9px;
    font-weight: 600;
    letter-spacing: 0.08em;
    color: #6f8399;
    text-transform: uppercase;
    margin-bottom: 2px;
}
.sglv-hero-type {
    display: flex !important;
    align-items: center;
    gap: 7px;
    padding: 3px 6px;
    border-radius: 5px;
    cursor: pointer;
    transition: background 0.15s;
}
.sglv-hero-type:hover { background: rgba(255, 255, 255, 0.05); }
.sglv-hero-type.active { background: rgba(102, 192, 244, 0.14); }
.sglv-hero-type-dot {
    width: 7px;
    height: 7px;
    border-radius: 2px;
    flex-shrink: 0;
}
.sglv-hero-type-name {
    font-size: 10px;
    color: #b9c9d9;
    width: 56px;
    flex-shrink: 0;
    white-space: nowrap;
    overflow: hidden;
    text-overflow: ellipsis;
}
.sglv-hero-type-track {
    flex: 1 1 auto;
    min-width: 20px;
    height: 5px;
    border-radius: 3px;
    background: rgba(255, 255, 255, 0.06);
    overflow: hidden;
}
.sglv-hero-type-fill {
    display: block;
    height: 100%;
    border-radius: 3px;
    opacity: 0.85;
    transition: width 0.35s ease;
}
.sglv-hero-type-count {
    font-size: 10px;
    font-weight: 700;
    color: #dbe7f3;
    width: 46px;
    text-align: right;
    flex-shrink: 0;
    font-variant-numeric: tabular-nums;
}
.sglv-hero-type-pct {
    font-size: 9px;
    color: #7e93ab;
    width: 30px;
    text-align: right;
    flex-shrink: 0;
    font-variant-numeric: tabular-nums;
}
.sglv-hero-empty {
    font-size: 10px;
    color: #6f8399;
    padding: 8px 0;
}
/* 窄浮窗：右区换行到下方，仍保持铺满 */
@media (max-width: 720px) {
    .sglv-hero { flex-direction: column; gap: 10px; }
    .sglv-hero-left { min-width: 0; }
    .sglv-hero-right { padding-left: 0; padding-top: 10px; border-left: none; border-top: 1px solid rgba(255,255,255,0.07); }
}

/* === v2.6.0: 受限游戏卡片重构 —— letterbox 封面 + 状态斜切带 + 两栏 meta === */

/* 封面容器：横向图 letterbox（居中不裁剪），高度略降给信息区腾空间 */
.sglv-card-grid .sglv-game-card .sglv-card-img-wrap {
    aspect-ratio: 16 / 11 !important;   /* 从 2:3 改为接近 header.jpg 的 460:215 比例 */
    background: linear-gradient(145deg, rgba(102,192,244,0.05), rgba(139,92,246,0.05)) !important;
}
.sglv-img-wrapper > .sglv-card-img {
    object-fit: contain !important;      /* 关键：横向图在容器内完整显示，不再硬裁主体 */
    object-position: center;
}

/* === v2.9.4: 竖版海报卡片墙（系列分类 / PS 会免 / Epic 赠送） ===
   数据源里竖版 library_600x900 覆盖率更高，卡片默认改用 2:3 海报；
   拿不到竖版时链尾回退 header.jpg，img 会被 markLoaded 标上 .sglv-img-wide
   → 下面单独走 contain letterbox，视觉上不裁切、不变形。 */
.sgc-panel .sglv-card-grid.sglv-card-grid-7 {
    grid-template-columns: repeat(7, minmax(0, 1fr)) !important;
    gap: 8px !important;
}
.sgc-panel .sglv-card-grid .sglv-game-card.sglv-poster-card .sglv-card-img-wrap {
    aspect-ratio: 2 / 3 !important;
    background: linear-gradient(160deg, rgba(22, 32, 45, 0.85) 0%, rgba(27, 40, 56, 0.85) 100%) !important;
}
/* 竖版：铺满容器（2:3 容器 + 2:3 图 → 零留白） */
.sgc-panel .sglv-poster-card .sglv-img-wrapper > .sglv-card-img:not(.sglv-img-wide) {
    object-fit: cover !important;
    object-position: center top;
}
/* 横版兜底：完整显示，上下留渐变底（不硬裁主体） */
.sgc-panel .sglv-poster-card .sglv-img-wrapper > .sglv-card-img.sglv-img-wide {
    object-fit: contain !important;
    object-position: center;
}
.sgc-panel .sglv-poster-card .sglv-card-body { padding: 5px 7px 6px !important; }
.sgc-panel .sglv-poster-card .sglv-card-name { min-height: 27px !important; }
.sgc-panel .sglv-poster-card .sglv-card-id-inline,
.sgc-panel .sglv-poster-card .sglv-card-id { font-size: 9px !important; opacity: 0.55; }
/* 7 列下卡片内边距/徽章同步收紧 */
.sgc-panel .sglv-poster-card .sglv-card-badge { font-size: 9px !important; padding: 1px 5px !important; }
.sgc-panel .sglv-poster-card .sglv-info-row { gap: 4px !important; flex-wrap: wrap; }

/* 状态斜切带（signature）—— 封���右下角的一道纯色斜带，无文字。
   取代原先信息区里的实心「未拥有」色块，节省一整行高度。
   未拥有 = 琥珀（醒目，提示"这个你还没有"）；已拥有 = 绿（细一些，次要） */
.sglv-own-flag {
    position: absolute !important;
    bottom: 0;
    right: 0;
    width: 62px;
    height: 5px;
    z-index: 6;
    pointer-events: none;
    clip-path: polygon(18px 0, 100% 0, 100% 100%, 0 100%);
    border-top-left-radius: 3px;
}
.sglv-own-flag.missing {
    background: linear-gradient(90deg, rgba(245,158,11,0.55), #f59e0b);
    box-shadow: 0 0 8px rgba(245,158,11,0.45);
}
.sglv-own-flag.owned {
    width: 34px;
    height: 4px;
    clip-path: polygon(14px 0, 100% 0, 100% 100%, 0 100%);
    background: linear-gradient(90deg, rgba(52,211,153,0.5), #34d399);
}

/* 两栏 meta：左 = 分类徽章 + 拥有态；右 = 数值/日期 */
.sglv-card-meta2 {
    display: flex !important;
    align-items: center;
    justify-content: space-between;
    gap: 6px;
    margin-top: 3px;
    min-width: 0;
}
.sglv-meta-col-left,
.sglv-meta-col-right {
    display: flex;
    align-items: center;
    gap: 5px;
    min-width: 0;
}
.sglv-meta-col-left { flex: 0 1 auto; overflow: hidden; }
.sglv-meta-col-right { flex: 0 0 auto; justify-content: flex-end; }

.sglv-type-badge {
    display: inline-flex !important;
    align-items: center;
    font-size: 9px !important;
    padding: 1px 5px !important;
    border-radius: 3px !important;
    border: 1px solid transparent;
    font-weight: 700;
    line-height: 1.5;
    white-space: nowrap;
    flex-shrink: 0;
}
/* 拥有态文字：与分类徽章同字号同风格，只是无边框 —— 不再是实心色块 */
.sglv-own-text {
    font-size: 9px !important;
    font-weight: 600;
    line-height: 1.5;
    white-space: nowrap;
    flex-shrink: 0;
}
.sglv-own-text.owned { color: #34d399 !important; }
.sglv-own-text.missing { color: #fbbf24 !important; }

/* 右栏 meta 项：图标 + 文本，超长省略 */
.sglv-meta-col-right .sglv-meta-item {
    display: inline-flex !important;
    align-items: center;
    gap: 2px;
    font-size: 9px !important;
    color: var(--sglv-text-secondary) !important;
    white-space: nowrap;
    line-height: 1.5;
}
.sglv-meta-col-right .sglv-meta-item svg {
    width: 9px !important;
    height: 9px !important;
    opacity: 0.65;
    flex-shrink: 0;
}
.sglv-meta-col-right .sglv-m-playtime {
    color: #66c0f4 !important;
    font-weight: 700;
}

/* 卡片正文：两栏后高度收紧 */
.sglv-card-grid .sglv-game-card .sglv-card-body {
    padding: 5px 7px 6px !important;
}
.sglv-card-grid .sglv-game-card .sglv-card-name {
    font-size: 11px !important;
    line-height: 1.35;
    margin-bottom: 1px;
}

/* 列表视图的两栏 meta 同样生效 */
.sglv-list-item .sglv-card-meta2 {
    margin-top: 2px;
}
.sglv-list-item .sglv-meta-col-right .sglv-meta-item {
    font-size: 10px !important;
}

/* 搜索高亮：改为左标记 + 底色，避免整块抢眼 */
.sglv-highlight {
    background: rgba(251, 191, 36, 0.16) !important;
    color: #fbbf24 !important;
    border-radius: 2px;
    padding: 0 2px;
    font-weight: 700;
    box-shadow: inset 2px 0 0 rgba(251, 191, 36, 0.8);
}

/* === Humble 专项 v2.4.0: 月卡 + 缩略 + 展开行 === */
.sglv-humble-month-card {
    padding: 12px 14px;
    background: rgba(255, 255, 255, 0.03);
    border: 1px solid rgba(255, 255, 255, 0.06);
    border-radius: 8px;
    margin-bottom: 10px;
}
.sglv-humble-month-head {
    display: flex;
    align-items: baseline;
    gap: 8px;
    flex-wrap: wrap;
}
.sglv-humble-month-title {
    font-size: 13px;
    font-weight: 700;
    color: #e2e8f0;
}
.sglv-humble-month-count {
    font-size: 11px;
    color: #94a3b8;
}
.sglv-humble-month-owned {
    margin-left: auto;
    font-size: 11px;
    font-weight: 700;
    color: #4caf50;
}
.sglv-humble-month-owned:empty,
.sglv-humble-month-owned[data-zero="1"] {
    color: #8f98a0;
}
/* 月卡顶部 3-5 个游戏缩略 */
.sglv-humble-game-thumbs {
    display: flex;
    gap: 6px;
    margin: 8px 0 0 0;
    flex-wrap: wrap;
}
.sglv-humble-game-thumb {
    position: relative;
    width: 48px;
    height: 48px;
    border-radius: 4px;
    overflow: hidden;
    background: rgba(255, 255, 255, 0.05);
    border: 1px solid rgba(255, 255, 255, 0.08);
    flex-shrink: 0;
}
.sglv-humble-game-thumb img {
    width: 100%;
    height: 100%;
    object-fit: cover;
    display: block;
}
.sglv-humble-game-thumb.no-img {
    background: linear-gradient(135deg, rgba(102, 192, 244, 0.08), rgba(139, 92, 246, 0.08));
}
.sglv-humble-game-thumb.owned {
    border-color: rgba(76, 175, 80, 0.5);
    box-shadow: 0 0 0 1px rgba(76, 175, 80, 0.2);
}
.sglv-humble-game-thumb-mark {
    position: absolute;
    top: 1px;
    right: 1px;
    width: 14px;
    height: 14px;
    background: #4caf50;
    color: #fff;
    font-size: 10px;
    font-weight: 700;
    border-radius: 50%;
    display: flex;
    align-items: center;
    justify-content: center;
    line-height: 1;
}
.sglv-humble-game-thumb-more {
    width: 48px;
    height: 48px;
    border-radius: 4px;
    background: rgba(255, 255, 255, 0.04);
    border: 1px dashed rgba(255, 255, 255, 0.15);
    display: flex;
    align-items: center;
    justify-content: center;
    font-size: 11px;
    font-weight: 600;
    color: #94a3b8;
    flex-shrink: 0;
}
/* 展开行 */
.sglv-humble-month-details {
    margin-top: 8px;
}
.sglv-humble-month-summary {
    cursor: pointer;
    font-size: 11px;
    color: #66c0f4;
    user-select: none;
    padding: 2px 0;
}
.sglv-humble-month-rows {
    margin-top: 6px;
    display: flex;
    flex-direction: column;
    gap: 2px;
}
.sglv-humble-row {
    display: flex;
    align-items: center;
    gap: 8px;
    padding: 4px 6px;
    border-radius: 4px;
    font-size: 12px;
    color: #cbd5e1;
    transition: background 0.15s;
}
.sglv-humble-row:hover {
    background: rgba(102, 192, 244, 0.08);
}
.sglv-humble-row.owned {
    color: #4caf50;
}
.sglv-humble-row-icon {
    width: 24px !important;
    height: 24px !important;
    flex-shrink: 0;
    border-radius: 3px;
    object-fit: cover;
    background: rgba(255, 255, 255, 0.05);
}
.sglv-humble-row-owned,
.sglv-humble-row-missing {
    flex: none;
    width: 16px;
    text-align: center;
    font-weight: 700;
}
.sglv-humble-row-name {
    flex: 1;
    min-width: 0;
    overflow: hidden;
    text-overflow: ellipsis;
    white-space: nowrap;
}
.sglv-humble-row-pub {
    flex: none;
    font-size: 10px;
    color: #8f98a0;
}
.sglv-humble-row-link {
    flex: none;
    font-size: 10px;
    color: #66c0f4;
    text-decoration: none;
}
.sglv-humble-row-link:hover {
    text-decoration: underline;
}

/* ==================== v2.9.6: 年度大作 列表边距收紧 ==================== */
/* 工具栏上下留白过大（搜索框行与内容区之间出现明显空隙），整体收紧 */
.sgc-panel .sglv-goty-toolbar-row { padding: 2px 8px 4px !important; gap: 5px !important; }
/* 滚动区顶部 + 年份块/分组之间的间距收紧（年份块 14px + 分组 12px 叠加出 26px 空隙） */
/* v2.9.8: padding-top 归零——原 2px padding 与 sticky 分组标题栏(top:0)组合，吸附后标题栏停在
   滚动口顶 +2px，该 2px 缝隙无栏体遮挡 → 滚过的封面从中透出（顶部穿透）。静止留白改用首元素
   margin-top（随内容滚走，不影响吸附），吸附时标题栏与滚动口严丝合缝。 */
.sgc-panel .sglv-goty-scroll { padding-top: 0; }
.sgc-panel .sglv-goty-scroll > :first-child { margin-top: 2px; }
.sgc-panel .sglv-goty-year-block { margin-bottom: 8px; }
.sgc-panel .sglv-goty-group { margin-bottom: 6px; }
.sgc-panel .sglv-goty-group-header { margin-bottom: 6px; padding: 6px 10px; }
/* 时间轴行自身留白收紧 */
.sgc-panel .sglv-goty-timeline { padding: 4px 14px 2px; margin: 0 2px 2px; }
/* 空年份节点（disabled）：灰显 + 禁用 hover 发光，消除"点了没反应" */
.sgc-panel .sglv-goty-tl-node[disabled] { cursor: not-allowed; opacity: 0.35; }
.sgc-panel .sglv-goty-tl-node[disabled] .sglv-goty-tl-dot { box-shadow: none; }
.sgc-panel .sglv-goty-tl-node[disabled]:hover .sglv-goty-tl-dot { transform: none; border-color: rgba(102,192,244,0.55); box-shadow: none; }
.sgc-panel .sglv-goty-tl-node[disabled]:hover .sglv-goty-tl-year { color: #64748b; }

/* ==================== v2.9.6: KPI 卡片光斑弱化（修复选中/hover 强光斑遮挡文字） ==================== */
/* 根因：主脚本 CSS_KPI 把 .sglv-trend-kpi-card::before 重定义为"全卡渐变 opacity:0/hover:1"，
   但共享 CSS 库的 ::before 还留着 width:40px/height:40px/border-radius:50%/filter:blur(8px)
   —— 两者层叠后变成"左上角一团 40x40 圆形高斯模糊光斑"，hover/选中时完全遮住标签与图标。 */
.sgc-panel .sglv-trend-kpi-card::before {
    top: -1px !important; right: -1px !important; bottom: -1px !important; left: -1px !important;
    width: auto !important; height: auto !important;
    border-radius: inherit !important;
    filter: none !important;
    background: linear-gradient(135deg, rgba(102,192,244,0.10), transparent 52%) !important;
    opacity: 0;
}
.sgc-panel .sglv-trend-kpi-card:hover::before { opacity: 0.5; }
/* 数值发光（text-shadow 12px currentColor + brightness 滤镜）弱化，避免数字糊成一团 */
.sgc-panel .sglv-trend-kpi-card .sglv-trend-kpi-value { text-shadow: none !important; filter: none !important; }
/* 选中态：只保留 accent 描边（去掉 16px 外发光），选中状态用边框表达更清晰 */
.sgc-panel .sglv-trend-kpi-card.active { box-shadow: 0 0 0 1px rgba(102,192,244,0.55) inset !important; }
/* hover 抬升 + 多重外发光（含 22px 蓝光晕）收敛为轻阴影 */
.sgc-panel .sglv-trend-kpi-card:hover,
.sgc-panel .sglv-trend-kpi-card.clickable:hover { transform: translateY(-1px) !important; box-shadow: 0 3px 10px rgba(0,0,0,0.35) !important; }

/* ==================== v2.9.6: Humble 月包缩略图平铺 ==================== */
/* 缩略图不再截断 5 个 + "+N"，全量平铺（flex-wrap 自动换行），右侧空白不再浪费 */
.sgc-panel .sglv-humble-game-thumbs { gap: 5px; }
.sgc-panel .sglv-humble-game-thumb, .sgc-panel .sglv-humble-game-thumb-more { width: 44px; height: 44px; }

/* ==================== v2.9.8: TGA 年度游戏殿堂 ==================== */
/* 金色「年度游戏」时间轴节点（置于年份节点之前） */
.sgc-panel .sglv-goty-tl-node.sglv-goty-tl-goty { padding-right: 12px; margin-right: 4px; }
.sgc-panel .sglv-goty-tl-node.sglv-goty-tl-goty::after {
    content: ''; position: absolute; top: 2px; bottom: 2px; right: 0; width: 1px;
    background: linear-gradient(180deg, transparent, rgba(245,158,11,0.4), transparent);
}
.sgc-panel .sglv-goty-tl-node.sglv-goty-tl-goty .sglv-goty-tl-dot {
    width: 9px; height: 9px; border-color: rgba(245,158,11,0.7);
    background: radial-gradient(circle, #fde68a 0%, #f59e0b 70%);
    box-shadow: 0 0 8px rgba(245,158,11,0.6);
}
.sgc-panel .sglv-goty-tl-node.sglv-goty-tl-goty .sglv-goty-tl-year { color: #fbbf24; }
.sgc-panel .sglv-goty-tl-node.sglv-goty-tl-goty:hover .sglv-goty-tl-dot {
    transform: scale(1.35); border-color: #fde68a; box-shadow: 0 0 14px rgba(245,158,11,0.9);
}
.sgc-panel .sglv-goty-tl-node.sglv-goty-tl-goty.sglv-goty-tl-active .sglv-goty-tl-dot {
    background: #fde68a; border-color: #fde68a;
    box-shadow: 0 0 16px rgba(245,158,11,1), 0 0 5px rgba(255,255,255,0.7);
}
.sgc-panel .sglv-goty-tl-node.sglv-goty-tl-goty.sglv-goty-tl-active .sglv-goty-tl-year {
    color: #fde68a; text-shadow: 0 0 10px rgba(245,158,11,0.8);
}

/* 殿堂 hero 标题条 */
.sglv-tga-hall { padding: 2px 2px 8px; }
.sglv-tga-hero {
    display: flex; align-items: center; gap: 10px; padding: 10px 14px; margin-bottom: 10px;
    border-radius: 10px; background: linear-gradient(135deg, rgba(245,158,11,0.16), rgba(15,23,42,0.4) 55%);
    border: 1px solid rgba(245,158,11,0.35);
}
.sglv-tga-hero-icon { display: inline-flex; color: #fbbf24; flex-shrink: 0; }
.sglv-tga-hero-icon svg { width: 26px; height: 26px; }
.sglv-tga-hero-txt { min-width: 0; }
.sglv-tga-hero-title { font-size: 16px; font-weight: 800; color: #fde68a; letter-spacing: 0.5px; line-height: 1.2; }
.sglv-tga-hero-sub { font-size: 10px; font-weight: 700; color: rgba(251,191,36,0.7); letter-spacing: 1.5px; }
.sglv-tga-hero-count { margin-left: auto; flex-shrink: 0; font-size: 12px; font-weight: 700; color: #fbbf24; white-space: nowrap; }

/* 殿堂冠军墙 */
.sglv-tga-grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(104px, 1fr)); gap: 8px; }
.sglv-tga-cell {
    position: relative; display: flex; flex-direction: column; border-radius: 9px; overflow: hidden;
    cursor: pointer; background: rgba(15,23,42,0.5); border: 1px solid rgba(245,158,11,0.22);
    transition: transform 0.15s, border-color 0.2s, box-shadow 0.2s;
}
.sglv-tga-cell:hover { transform: translateY(-3px); border-color: rgba(245,158,11,0.75); box-shadow: 0 8px 22px rgba(0,0,0,0.45), 0 0 14px rgba(245,158,11,0.25); }
.sglv-tga-cell.not-owned { opacity: 0.72; }
.sglv-tga-cell.not-owned:hover { opacity: 1; }
.sglv-tga-poster { position: relative; width: 100%; aspect-ratio: 2/3; background: #0f172a; overflow: hidden; }
.sglv-tga-poster-img { width: 100%; height: 100%; object-fit: cover; display: block; }
.sglv-tga-year-badge {
    position: absolute; top: 5px; left: 5px; z-index: 3; padding: 1px 7px; border-radius: 10px;
    font-size: 11px; font-weight: 800; color: #1a1206; letter-spacing: 0.5px;
    background: linear-gradient(135deg, #fde68a, #f59e0b); box-shadow: 0 1px 5px rgba(0,0,0,0.5);
}
.sglv-tga-crown {
    position: absolute; top: 4px; right: 5px; z-index: 3; display: flex; align-items: center; gap: 1px;
    color: #fbbf24; filter: drop-shadow(0 1px 3px rgba(0,0,0,0.7)); font-size: 10px; font-weight: 800;
}
.sglv-tga-crown svg { width: 15px; height: 15px; }
.sglv-tga-crown.multi svg { width: 13px; height: 13px; }
.sglv-tga-cell-info { padding: 5px 7px 6px; display: flex; flex-direction: column; gap: 3px; }
.sglv-tga-cell-name {
    font-size: 11.5px; font-weight: 700; color: #f1f5f9; line-height: 1.25;
    overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
}
.sglv-tga-tag {
    display: inline-flex; align-items: center; gap: 2px; align-self: flex-start;
    font-size: 9px; font-weight: 700; padding: 1px 5px; border-radius: 3px; line-height: 1.4;
    color: #94a3b8; background: rgba(148,163,184,0.12); border: 1px solid rgba(148,163,184,0.2);
}
.sglv-tga-tag.owned { color: #66bb6a; background: rgba(102,187,106,0.18); border-color: rgba(102,187,106,0.35); }
.sglv-tga-excl-type {
    display: inline-flex; align-items: center; align-self: flex-start;
    font-size: 9px; font-weight: 700; padding: 1px 5px; border-radius: 3px; line-height: 1.4;
    border: 1px solid currentColor; background: rgba(255,255,255,0.05); max-width: 100%;
    overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
}

/* 非 Steam 平台占位画（平台主色 SVG + 平台名 + 提示；有商店图则叠加） */
.sglv-tga-excl-art {
    position: absolute; inset: 0; display: flex; flex-direction: column;
    align-items: center; justify-content: center; gap: 4px; padding: 6px; text-align: center;
    background: radial-gradient(circle at 50% 35%, rgba(255,255,255,0.08), rgba(15,23,42,0.85));
}
.sglv-tga-excl-art svg { width: 34px; height: 34px; opacity: 0.9; }
.sglv-tga-excl-name { font-size: 10px; font-weight: 700; color: currentColor; line-height: 1.2; }
.sglv-tga-excl-hint { font-size: 9px; color: rgba(148,163,184,0.75); }
.sglv-tga-excl-img { position: absolute; inset: 0; width: 100%; height: 100%; object-fit: cover; z-index: 2; }

/* 年度大作卡片上的金色 👑 年度游戏 chip */
.sglv-goty-tga-chip {
    display: inline-flex; align-items: center; gap: 2px; cursor: pointer;
    font-size: 9px; font-weight: 800; padding: 1px 5px; border-radius: 3px; line-height: 1.4;
    color: #1a1206; background: linear-gradient(135deg, #fde68a, #f59e0b);
    border: 1px solid rgba(245,158,11,0.6); white-space: nowrap;
}
.sglv-goty-tga-chip:hover { filter: brightness(1.12); box-shadow: 0 0 8px rgba(245,158,11,0.6); }

/* 提名弹窗 */
.sglv-tga-modal {
    position: fixed; inset: 0; z-index: 2147483000; display: flex; align-items: center; justify-content: center;
    background: rgba(4,8,16,0.72); backdrop-filter: blur(3px); -webkit-backdrop-filter: blur(3px); padding: 20px;
}
.sglv-tga-modal-win {
    display: flex; flex-direction: column; width: 100%; max-width: 720px; max-height: 86vh;
    background: #141d2e; border: 1px solid rgba(245,158,11,0.4); border-radius: 12px;
    box-shadow: 0 20px 60px rgba(0,0,0,0.6), 0 0 30px rgba(245,158,11,0.12); overflow: hidden;
}
.sglv-tga-modal-head {
    display: flex; align-items: center; gap: 8px; padding: 12px 16px; flex-shrink: 0;
    background: linear-gradient(135deg, rgba(245,158,11,0.18), rgba(20,29,46,0.2));
    border-bottom: 1px solid rgba(245,158,11,0.25);
}
.sglv-tga-modal-trophy { display: inline-flex; color: #fbbf24; }
.sglv-tga-modal-trophy svg { width: 20px; height: 20px; }
.sglv-tga-modal-title { font-size: 15px; font-weight: 800; color: #fde68a; white-space: nowrap; }
.sglv-tga-modal-sub { font-size: 11px; font-weight: 600; color: rgba(251,191,36,0.8); white-space: nowrap; }
.sglv-tga-modal-close { margin-left: auto; display: inline-flex; cursor: pointer; color: #94a3b8; padding: 2px; border-radius: 4px; transition: color 0.15s, background 0.15s; }
.sglv-tga-modal-close:hover { color: #f8fafc; background: rgba(255,255,255,0.1); }
.sglv-tga-modal-close svg { width: 18px; height: 18px; }
.sglv-tga-modal-body { display: flex; gap: 14px; padding: 14px 16px; overflow-y: auto; }
.sglv-tga-noms-side { flex-shrink: 0; width: 168px; display: flex; flex-direction: column; gap: 6px; }
.sglv-tga-noms-side-top { display: flex; align-items: center; gap: 6px; }
.sglv-tga-side-year { font-size: 13px; font-weight: 800; color: #fde68a; }
.sglv-tga-side-cat { font-size: 10px; font-weight: 700; color: rgba(251,191,36,0.75); }
.sglv-tga-winner-poster {
    position: relative; width: 100%; aspect-ratio: 2/3; border-radius: 8px; overflow: hidden; background: #0f172a;
    border: 2px solid rgba(245,158,11,0.65); box-shadow: 0 4px 16px rgba(0,0,0,0.4); cursor: pointer;
}
.sglv-tga-winner-poster.excl { cursor: default; }
.sglv-tga-winner-img { width: 100%; height: 100%; object-fit: cover; display: block; }
.sglv-tga-noms-side-name { font-size: 13px; font-weight: 700; color: #f1f5f9; line-height: 1.3; }
.sglv-tga-noms-side-own { display: flex; align-items: center; gap: 6px; flex-wrap: wrap; }
.sglv-tga-winner-badge {
    display: inline-flex; align-items: center; font-size: 10px; font-weight: 800; padding: 2px 8px; border-radius: 4px;
    color: #1a1206; background: linear-gradient(135deg, #fde68a, #f59e0b);
}
.sglv-tga-noms-grid { flex: 1; min-width: 0; display: grid; grid-template-columns: 1fr 1fr; gap: 10px; align-content: start; }
.sglv-tga-nom-card {
    display: flex; flex-direction: column; gap: 4px; padding: 6px; border-radius: 8px; cursor: pointer;
    background: rgba(15,23,42,0.5); border: 1px solid rgba(102,192,244,0.18);
    transition: border-color 0.2s, transform 0.15s;
}
.sglv-tga-nom-card:hover { border-color: rgba(102,192,244,0.55); transform: translateY(-2px); }
.sglv-tga-nom-card.excl { cursor: default; }
.sglv-tga-nom-card.excl:hover { transform: none; border-color: rgba(102,192,244,0.18); }
.sglv-tga-nom-img-wrap { position: relative; width: 100%; aspect-ratio: 467/181; border-radius: 5px; overflow: hidden; background: #0f172a; }
.sglv-tga-nom-img { width: 100%; height: 100%; object-fit: cover; display: block; }
.sglv-tga-nom-name { font-size: 11.5px; font-weight: 600; color: #f1f5f9; line-height: 1.25; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
.sglv-tga-noms-empty { flex: 1; display: flex; align-items: center; justify-content: center; color: #64748b; font-size: 13px; min-height: 120px; }
@media (max-width: 620px) {
    .sglv-tga-modal-body { flex-direction: column; }
    .sglv-tga-noms-side { width: 100%; flex-direction: row; align-items: flex-end; gap: 12px; }
    .sglv-tga-winner-poster { width: 120px; }
}
`;

        // ==================== v2.8.0: 统一封面渲染（按 kind） ====================
        // 背景：Epic / PS会免 / 系列分类 / 年度大作 / DLC 五个 tab 的「大海报视图」全部加载失败，
        // 但它们的「网格视图」和「列表视图」正常 —— 说明问题不在数据、不在网络，
        // 而在这几个 tab 特有的渲染路径。
        //
        // 排查出的三个叠加原因：
        // ① 一次性锁不可复位：_sgcvChainFallbackImpl 首次进入时置 img._sglvChainLoading = 1 且永不复位。
        //    同一 appid 在视图间切换（网格→大海报→网格）时，第二次 onerror 直接被锁死，
        //    chainLoad 永不执行 → 永远停在坏 src 上。用户「切到大海报视图」恰好触发这个路径。
        // ② kind 缓存污染：网格视图写入的是竖版 good URL（recordPosterGood(appid, url, 'poster')），
        //    大海报视图按 'capsule' 读缓存时被 _sgcvUrlMatchesKind 判为方向不符而丢弃，
        //    于是既拿不到缓存、又被迫走链首的 library_hero（对非新游戏命中率低）。
        // ③ 跨上下文 inline onerror：这五处都依赖挂在 unsafeWindow 上的
        //    _sglvChainFallback / _sglvRecordPosterGood 才能回退，一旦某次注入失败或被覆盖，
        //    onerror 就是个 undefined 函数，图片静默停在坏 src 上（无任何可见错误）。
        //
        // 统一方案：全部改走 v2.7.0 的 bindRestrictedCoverLoaders（addEventListener + 闭包链索引，
        // 无跨上下文依赖、无一次性锁、每次渲染重新绑定），按 kind 给出不同的 URL 链与容器类。
        // ====================================================================

        /** 按 kind 返回统一封面链（横向优先，命中率高）
         *  - 'poster'  → 卡片视图用，横图 letterbox
         *  - 'capsule' → 大海报视图用，横向大图铺满
         *  - 'hero'    → 系列/供应商视图用，超宽横图
         */
        function unifiedCoverChain(appid, kind, preferVertical) {
            const id = String(appid);
            const cdn = [
                'https://cdn.cloudflare.steamstatic.com/steam/apps/' + id,
                'https://shared.akamai.steamstatic.com/store_item_assets/steam/apps/' + id,
                'https://cdn.akamai.steamstatic.com/steam/apps/' + id,
                'https://shared.fastly.steamstatic.com/store_item_assets/steam/apps/' + id,
            ];
            if (kind === 'poster' && preferVertical) {
                // v2.9.4: 竖版优先链（与主脚本 coverChainUrls('poster') 保持一致）——
                //   library_600x900_2x → library_600x900 → header 兜底
                //   拿不到竖版时自动落到 header.jpg（横版 letterbox），逻辑不变
                const files = ['library_600x900_2x.jpg', 'library_600x900.jpg', 'header.jpg'];
                const out = [];
                for (const f of files) for (let i = 0; i < cdn.length; i++) out.push(cdn[i] + '/' + f);
                return out;
            }
            if (kind === 'hero') {
                // hero：优先 library_hero（系列视图专属，超宽比例）
                return [
                    cdn[0] + '/library_hero.jpg',
                    cdn[1] + '/library_hero.jpg',
                    cdn[2] + '/library_hero.jpg',
                    cdn[3] + '/library_hero.jpg',
                    cdn[0] + '/header.jpg',
                    cdn[1] + '/header.jpg',
                    cdn[2] + '/header.jpg',
                    cdn[3] + '/header.jpg',
                    cdn[0] + '/capsule_467x181.jpg',
                    cdn[1] + '/capsule_467x181.jpg',
                ];
            }
            // poster / capsule：统一横向链（header 命中率最高，capsule_467x181 兜底）
            return [
                cdn[0] + '/header.jpg',
                cdn[1] + '/header.jpg',
                cdn[2] + '/header.jpg',
                cdn[3] + '/header.jpg',
                cdn[0] + '/capsule_467x181.jpg',
                cdn[1] + '/capsule_467x181.jpg',
                cdn[0] + '/capsule_231x87.jpg',
                cdn[1] + '/capsule_231x87.jpg',
            ];
        }

        /**
         * 统一封面组件（替代 epicCapsuleImg / psplusCapsuleImg / seriesCapsuleImg / gotyCoverImg / dlcPosterImg）
         * @param {number|string} appid
         * @param {string} name
         * @param {'poster'|'capsule'|'hero'} kind
         * @param {Object} [opts]
         * @param {string} [opts.imgCls] - img 类名（默认按 kind 推断）
         * @param {boolean} [opts.isBlocked] - 锁区红色锁占位
         * @returns {string} HTML
         */
        function unifiedCover(appid, name, kind, opts) {
            const o = opts || {};
            const k = kind || 'poster';
            if (!appid) {
                // 无 appid（PS 独占游戏）—— 显示占位容器，不生成坏 img
                return '<div class="sglv-img-wrapper sglv-img-broken"><div class="sglv-img-broken-label">' +
                    Host.wlEscape(name || (Host.isZh ? '无封面' : 'No Cover')) + '</div></div>';
            }
            const imgCls = o.imgCls || (k === 'poster' ? 'sglv-card-img' : 'sglv-wl-cover-img');
            const safeName = Host.wlEscape(name || '');
            const brokenCls = 'sglv-img-broken' + (o.isBlocked ? ' sglv-img-broken-blocked' : '');
            // v2.9.4: preferVertical —— 竖版海报卡片墙（系列/PS/Epic）
            const preferVertical = !!o.preferVertical;
            const chain = unifiedCoverChain(appid, k, preferVertical);

            // 已有 good 缓存则优先用（跨视图共享）：
            //   ① v2.9.3: coverGoodUrl —— 方向门控 + 横版 header/capsule 交叉槽位，
            //      同一张图不再由主面板/收藏/PS/Epic 各探一次
            //   ② v2.9.2: cover-fallback 的跨会话缓存
            let first = '';
            try { first = coverGoodUrl(String(appid), k) || ''; } catch (e) { /* ignore */ }
            // 竖版槽位里的横版条目 = 上次已确认该游戏无竖版资产（链耗尽标记）：
            //   直接拿来 letterbox，省掉每次重新吃 8 个 404
            if (!first && k === 'poster') {
                try { first = coverHorizontalFallbackUrl(String(appid)) || ''; } catch (e) { /* ignore */ }
            }
            try {
                const fb = _coverFb();
                if (!first && fb && typeof fb.getCoverUrl === 'function') {
                    first = fb.getCoverUrl(String(appid), k, coverLang()) || '';
                }
            } catch (e) { /* ignore */ }
            first = first || chain[0];

            // v2.9.2: wrapper 必须带 data-cover-appid —— bindRestrictedCoverLoaders 用
            //   `.sglv-img-wrapper[data-cover-appid]` 选择；此前只写 data-appid，
            //   选择器一个都匹配不到 → 从不绑定 → sglv-img-loading 永不摘除
            //   → .sglv-wl-cover-img-wrap 下 opacity:0，大海报视图全是空白。
            return '<div class="sglv-img-wrapper sglv-img-loading" data-cover-appid="' + appid + '" data-appid="' + appid + '"' +
                ' data-cover-kind="' + k + '" data-cover-blocked="' + (o.isBlocked ? '1' : '0') + '"' +
                (preferVertical ? ' data-cover-prefer-vertical="1"' : '') + '>' +
                '<img class="' + imgCls + '" src="' + first + '" alt="' + safeName + '" decoding="async" referrerpolicy="no-referrer">' +
                '<div class="sglv-img-fallback-layer">' + _restrictedBrokenInner(name, o.isBlocked) + '</div>' +
                '</div>';
        }

    // 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 锁兜底
    // v2.0.0: 统一 onerror 委托 _sglvChainFallback(失败时由 chainLoad JS 接管整链 + API 兜底)
    //   锁占位 SVG 由 _sglvChainFallbackImpl → onGiveUp(若 chainLoad 完全失败) → 后续由 blocked 专用回调接管


    // 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 = 'publisher';   // v1.0.4: 默认标签改为"供应商/系列"（与新 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: 页码 } 记忆每个系列的浏览页码，切换回已浏览分类时恢复进度
        // v2.9.4: 系列分类卡片墙改 7 列 → 每页 49（7×7）刚好铺满，不留半排
        const pubDetailState = { page: 1, pageSize: 49, 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: 49, 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: 49, viewMode: 'card', updatedAt: '', loadError: null, source: '' };
        // v2.9.7: 年度大作模块状态（数据含 name/date/appid，名称无需异步加载）
        // v2.x: "GotY 时光机"——年份时间轴 + 分组(未发售/已发售)+ 焦点卡 + 网格 5 列
        //   移除 year 单选字段(改用 expandedYears Set 默认全部展开),移除 page/pageSize(网格 5 列滚动)
        // v2.9.6: 新增 yearFilter —— 年份时间轴节点点击后"真筛选"（null=全部年份）；
        //   旧实现只是 scrollIntoView 滚动定位，平滑滚动中途 active 会漂移到中间年份，
        //   且停在年份块之间的 margin 空隙上，表现为"点击不生效/位置不准/顶部留白"。
        // v2.9.8: 新增 tgaView —— 时间轴金色「年度游戏」节点开启后，滚动区改渲染 TGA 历届 GOTY 殿堂
        //   （与年份筛选互斥：进入殿堂清 yearFilter，选年份则退出殿堂）。
        const gotyState = { games: [], loaded: false, loading: false, availableYears: [], expandedYears: null, search: '', ownFilter: 'all', yearFilter: null, tgaView: false, sort: 'dateDesc', 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,
            loading: false,     // v2.5.0: Bundle 数据库加载中
            loadError: false,   // v2.5.0: Bundle 数据库加载失败
            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…' },
        ];

        // ==================== v2.2.0: 受限游戏板通用组件 ====================
        // 仿 steam-friend-manager buildDelistedBoardData + makeDelistedCardsRow 风格，
        // 抽象出"受限游戏板（绝版/锁区/将来可能的 wishlist 锁区 等）"通用数据层 + UI 组件，
        // 替代每个 tab 各自维护一套内联模板字符串。
        //
        // 用法：
        //   const board = makeRestrictedBoardData(myGames, restrictedList, { typeKey, typeLabelMap });
        //   const heroHtml = makeRestrictedHero({ total, ownedCount, scopeBase, typeKeys, ... });
        //   const cardHtml = makeRestrictedCard({ appid, name, isOwned, typeLabel, ... });
        //   const listHtml = makeRestrictedListItem({ appid, name, isOwned, ... });
        // ============================================================

        /** 构建受限游戏板数据：来源游戏 ∩ 受限数据库
         * @param {Array} sourceEntries - 来源游戏 [{appid, name, ...}]
         * @param {Array} restrictedList - 受限数据库 [{appid, name, type, changed, ...}]
         * @param {Object} [opts]
         * @param {Function} [opts.typeKey] - 标准化 type 字段（默认直接取 a.type）
         * @returns {{owned: Array, missing: Array, allApps: Array, total: number}}
         */
        function makeRestrictedBoardData(sourceEntries, restrictedList, opts) {
            const o = opts || {};
            const typeKeyFn = o.typeKey || ((a) => a.type || 'default');
            const ownedIds = new Set();
            const ownedEntryMap = new Map();
            (sourceEntries || []).forEach(s => {
                if (s && s.appid != null) {
                    const id = Number(s.appid);
                    ownedIds.add(id);
                    ownedEntryMap.set(id, s);
                }
            });

            const owned = [];
            const missing = [];
            const allApps = [];
            (restrictedList || []).forEach(app => {
                if (!app || app.appid == null) return;
                const appid = Number(app.appid);
                if (!appid) return;
                const entry = {
                    appid,
                    name: app.name || ('App ' + appid),
                    type: typeKeyFn(app) || 'default',
                    changed: app.changed || app.delistedAt || '',
                    _meta: app  // 保留原始数据，调用方可读取附加字段（achievements / owners 等）
                };
                allApps.push(entry);
                if (ownedIds.has(appid)) {
                    owned.push(Object.assign({ sourceEntry: ownedEntryMap.get(appid) }, entry));
                } else {
                    missing.push(entry);
                }
            });

            return { owned, missing, allApps, total: restrictedList ? restrictedList.length : 0 };
        }

        /** KPI 卡片行：总数 / 已拥有 / 未拥有 + 类型筛选
         * @param {Object} opts
         * @param {number} opts.total
         * @param {number} opts.ownedCount
         * @param {number} opts.missingCount
         * @param {Array}  opts.scopeBase - 范围筛选基础列表（'all' / 'owned' / 'missing' 切换）
         * @param {string} opts.scope - 'all' | 'owned' | 'missing'
         * @param {string} opts.typeFilter - 'all' | <typeKey>
         * @param {string[]} opts.labels - [总数, 拥有, 未拥有] 三档文案
         * @param {string[]} [opts.typeKeys] - 类型 key 列表（决定渲染几个类型卡）
         * @param {Object}   [opts.typeColors] - { typeKey → 颜色 }
         * @param {Object}   [opts.typeLabels] - { typeKey → 标签 }
         * @param {string}   opts.tabId - 用于事件委托的 data-attr 前缀
         */
        /**
         * 受限游戏板 HERO —— v2.6.0 重设计
         *
         * 旧设计的问题（截图实证）：一行 7 张等宽小卡横排，每个数字都是同一视觉权重，
         * 浮窗再宽也铺不满 → 大片留白；而真正有决策价值的"哪类占多数"完全看不出来。
         *
         * 新设计：左大右小的仪表盘结构，天然铺满任意宽度。
         *   左区  主数字（锁区总数）+ 拥有率细进度条 + 两个 scope 卡（在库/未拥有）
         *   右区  类型占比条形列表，每行 = 分类色块 + 名称 + 占比条 + 数量 + 百分比
         * 交互：scope 卡切换拥有态筛选；类型行点击切换类型筛选（再次点击同一行回到全部）。
         *
         * @param {Object} opts 含 total / ownedCount / scopeBase / scope / typeFilter / typeKeys / typeColors / typeLabels / tabId / title
         */
        function makeRestrictedHero(opts) {
            const o = opts || {};
            const tabId = o.tabId || 'sgr';
            const scope = o.scope || 'all';
            const typeFilter = o.typeFilter || 'all';
            const typeKeys = o.typeKeys || [];
            const typeColors = o.typeColors || {};
            const typeLabels = o.typeLabels || {};
            const total = o.total || 0;
            const ownedCount = o.ownedCount || 0;
            const scopeBase = o.scopeBase || [];
            const title = o.title || (Host.isZh ? '受限总数' : 'Total');

            // 类型计数（基于当前 scope 收窄后的列表）+ 占比
            const typeStats = typeKeys.map(function (key) {
                const count = scopeBase.filter(function (g) { return g.type === key; }).length;
                return { key: key, count: count, color: typeColors[key] || '#94a3b8', label: typeLabels[key] || key };
            }).filter(function (t) { return t.count > 0; });
            const statSum = typeStats.reduce(function (s, t) { return s + t.count; }, 0) || 1;

            const ownedPct = total > 0 ? Math.round(ownedCount / total * 100) : 0;

            // 左区：scope 卡（在库 / 未拥有）—— 主数字已表达"全部"，这里不再重复一个"全部"卡
            const scopeCards =
                '<div class="sglv-hero-scope-row">' +
                    '<div class="sglv-hero-scope' + (scope === 'owned' ? ' active' : '') + '" data-' + tabId + '-scope="owned" title="' + (Host.isZh ? '只看已在 Steam 库' : 'Only in library') + '">' +
                        '<span class="sglv-hero-scope-val">' + ownedCount.toLocaleString() + '</span>' +
                        '<span class="sglv-hero-scope-label">' + (Host.isZh ? '在库' : 'Owned') + '</span>' +
                    '</div>' +
                    '<div class="sglv-hero-scope' + (scope === 'missing' ? ' active' : '') + '" data-' + tabId + '-scope="missing" title="' + (Host.isZh ? '只看未拥有' : 'Only not owned') + '">' +
                        '<span class="sglv-hero-scope-val">' + (total - ownedCount).toLocaleString() + '</span>' +
                        '<span class="sglv-hero-scope-label">' + (Host.isZh ? '未拥有' : 'Missing') + '</span>' +
                    '</div>' +
                '</div>';

            // 右区：类型占比条形列表
            const typeRows = typeStats.map(function (t) {
                const pct = Math.round(t.count / statSum * 100);
                const active = typeFilter === t.key;
                return '<div class="sglv-hero-type' + (active ? ' active' : '') + '" data-' + tabId + '-type="' + Host.wlEscape(t.key) + '" ' +
                    'title="' + Host.wlEscape(t.label) + ' · ' + t.count.toLocaleString() + ' (' + pct + '%)' + '">' +
                    '<span class="sglv-hero-type-dot" style="background:' + t.color + '"></span>' +
                    '<span class="sglv-hero-type-name">' + Host.wlEscape(t.label) + '</span>' +
                    '<span class="sglv-hero-type-track"><span class="sglv-hero-type-fill" style="width:' + pct + '%;background:' + t.color + '"></span></span>' +
                    '<span class="sglv-hero-type-count">' + t.count.toLocaleString() + '</span>' +
                    '<span class="sglv-hero-type-pct">' + pct + '%</span>' +
                '</div>';
            }).join('');

            return '<div class="sglv-hero">' +
                '<div class="sglv-hero-left">' +
                    '<div class="sglv-hero-title">' + Host.wlEscape(title) + '</div>' +
                    '<div class="sglv-hero-num">' + total.toLocaleString() + '</div>' +
                    '<div class="sglv-hero-progress">' +
                        '<div class="sglv-hero-progress-fill" style="width:' + ownedPct + '%"></div>' +
                    '</div>' +
                    '<div class="sglv-hero-progress-cap">' + (Host.isZh ? '已收集' : 'Collected') + ' ' + ownedPct + '%</div>' +
                    scopeCards +
                '</div>' +
                '<div class="sglv-hero-right">' +
                    '<div class="sglv-hero-right-head">' + (Host.isZh ? '分类占比' : 'By category') + '</div>' +
                    (typeRows || '<div class="sglv-hero-empty">' + (Host.isZh ? '无分类数据' : 'No category data') + '</div>') +
                '</div>' +
            '</div>';
        }

        // v2.6.0: 筛选区统一由 makeRestrictedHero 渲染（HERO 仪表盘），
        // 此处不再保留旧的一排等宽 KPI 小卡实现。

        /** 受限游戏卡片（卡片视图）— 封面 + 名称 + 类型徽章 + 拥有徽章 + meta 项
         * @param {Object} opts
         * @param {number} opts.appid
         * @param {string} opts.name
         * @param {boolean} opts.isOwned
         * @param {string} [opts.typeLabel] - 顶部类型徽章文本
         * @param {string} [opts.typeKey] - 用于 class="sglv-type-<key>" 着色
         * @param {string} [opts.typeColor] - 徽章主色（默认 #f44336 红色系）
         * @param {Array<string>} [opts.metaItems] - 附加 meta 项（每个是 HTML 片段）
         * @param {string} [opts.clickUrl] - 自定义跳转 URL
         * @param {string} [opts.coverHtml] - 自定义封面 HTML（默认 restrictedCoverImg）
         * @returns {string} HTML
         */
        // v2.5.0: 徽章配色工具——typeColor 是实色（如 #fb923c），直接拿来做 background 会得到
        // 与文字同色的实心方块（截图里的橙色/紫色块，文字完全不可见）。
        // 这里把实色转成低透明度背景 + 实色文字 + 实色描边，保证文字始终可读。
        function _badgeColors(hex) {
            const c = hex || '#f44336';
            const m = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(c);
            if (!m) return { bg: 'rgba(244,67,54,0.15)', fg: '#f44336', border: 'rgba(244,67,54,0.28)' };
            const r = parseInt(m[1], 16), g = parseInt(m[2], 16), b = parseInt(m[3], 16);
            return {
                bg: 'rgba(' + r + ',' + g + ',' + b + ',0.14)',
                fg: '#' + m[1] + m[2] + m[3],
                border: 'rgba(' + r + ',' + g + ',' + b + ',0.32)'
            };
        }

        // v2.6.0: 状态斜切带（signature element）——取代原先的「未拥有/已拥有」实心标签块。
        // 旧方案的问题：彩色实心底 + 同色文字，视觉上就是一个读不出内容的色块（截图里的紫色方块），
        // 而且每张卡都挂一个色块，卡片信息区被挤成两行。
        // 新方案：把状态做成封���右下角的一道斜切色带（纯色无文字），状态文字移入下方 meta 栏，
        // 卡片因此省下一整行，信息区得以压缩成两栏。
        //   未拥有 → 琥珀色带（#f59e0b），提示"这个你还没有"
        //   已拥有 → 绿色细带（#34d399），细一些表示次要
        function _stateRibbon(isOwned) {
            // v2.9.5: 移除封面右下角的琥珀色/绿色斜切带 ——
            //   7 列紧凑卡片里它贴着封面底边，视觉上就是"一块黄色背景"，
            //   而卡片下方已有「购买已禁用/未拥有/已拥有」徽章表达同一信息。
            //   保留函数 + CSS（.sglv-own-flag）以便随时回滚。
            void isOwned;
            return '';
        }

        /**
         * 受限游戏卡片 —— v2.6.0 重构版式
         *   封面（横向图 letterbox + 右下角状态斜切带）
         *   名称行（游戏名 + appid）
         *   两栏 meta：左 = 分类徽章 + 拥有态文字；右 = 日期 / 数值类信息
         */
        function makeRestrictedCard(opts) {
            const o = opts || {};
            const appid = Number(o.appid);
            const name = o.name || ('App ' + appid);
            const isOwned = !!o.isOwned;
            const clickUrl = o.clickUrl || ('https://store.steampowered.com/app/' + appid);
            const coverHtml = o.coverHtml != null ? o.coverHtml : restrictedCoverImg(appid, name, 'poster', { isBlocked: !!o.isBlocked });

            // 两栏布局：left = 分类徽章 + 拥有态；right = 日期 / 统计
            const metaLeft = [];
            if (o.typeLabel && o.typeKey) {
                const bc = _badgeColors(o.typeColor);
                metaLeft.push('<span class="sglv-type-badge" style="background:' + bc.bg + ';color:' + bc.fg + ';border-color:' + bc.border + '">' + Host.wlEscape(o.typeLabel) + '</span>');
            }
            if (o.showOwnText !== false) {
                metaLeft.push('<span class="sglv-own-text ' + (isOwned ? 'owned' : 'missing') + '">' +
                    (isOwned ? '✓ ' + Host.wlEscape(Host.T.owned || '已拥有') : Host.wlEscape(Host.T.missing || '未拥有')) + '</span>');
            }

            const metaRight = (o.metaItems || []).filter(Boolean);

            const twoCol = '<div class="sglv-card-meta2">' +
                '<div class="sglv-meta-col-left">' + metaLeft.join('') + '</div>' +
                '<div class="sglv-meta-col-right">' + metaRight.join('') + '</div>' +
                '</div>';

            return '<div class="sglv-game-card" data-appid="' + appid + '" onclick="window.open(\'' + clickUrl + '\',\'_blank\')">' +
                '<div class="sglv-card-img-wrap">' + coverHtml + _stateRibbon(isOwned) + '</div>' +
                '<div class="sglv-card-body">' +
                    '<div class="sglv-card-name" title="' + Host.wlEscape(name) + '">' +
                        '<span data-sglv-appid="' + appid + '">' + Host.wlEscape(name) + '</span>' +
                        '<span class="sglv-card-id-inline">' + appid + '</span>' +
                    '</div>' +
                    twoCol +
                '</div>' +
            '</div>';
        }

        function makeRestrictedListItem(opts) {
            const o = opts || {};
            const appid = Number(o.appid);
            const name = o.name || ('App ' + appid);
            const isOwned = !!o.isOwned;
            const clickUrl = o.clickUrl || ('https://store.steampowered.com/app/' + appid);
            const iconUrl = o.iconUrl || (typeof Host.getGameIconUrl === 'function' ? Host.getGameIconUrl(appid, '') : '');

            // v2.6.0: 列表视图同步去掉实心拥有态块 —— 左列 = 分类徽章 + 拥有态文字，右列 = 日期/统计
            const bc = _badgeColors(o.typeColor);
            const left = [];
            if (o.typeLabel && o.typeKey) {
                left.push('<span class="sglv-type-badge" style="background:' + bc.bg + ';color:' + bc.fg + ';border-color:' + bc.border + '">' + Host.wlEscape(o.typeLabel) + '</span>');
            }
            left.push('<span class="sglv-own-text ' + (isOwned ? 'owned' : 'missing') + '">' +
                (isOwned ? '✓ ' + Host.wlEscape(Host.T.owned || '已拥有') : Host.wlEscape(Host.T.missing || '未拥有')) + '</span>');
            const right = (o.metaItems || []).filter(Boolean);

            return '<div class="sglv-list-item" data-appid="' + appid + '" onclick="window.open(\'' + clickUrl + '\',\'_blank\')">' +
                '<img class="sglv-list-icon" src="' + iconUrl + '" alt="' + Host.wlEscape(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 + '">' + Host.wlEscape(name) + '</span>' +
                        '<span class="sglv-list-id-inline">' + appid + '</span>' +
                    '</div>' +
                    '<div class="sglv-card-meta2">' +
                        '<div class="sglv-meta-col-left">' + left.join('') + '</div>' +
                        '<div class="sglv-meta-col-right">' + right.join('') + '</div>' +
                    '</div>' +
                '</div>' +
            '</div>';
        }

        // ==================== v2.4.0: 收藏标签页壳（统一工具栏 + KPI + 网格 + 翻页） ====================
        // 抽象 4 个 tab 共用的"容器 + 工具栏 + KPI + 内容 + 翻页"四段式结构，
        // 各 tab 通过回调定制工具栏内容（搜索/排序/视图切换/刷新按钮）
        // ================================================================

        /**
         * 创建收藏标签页外壳
         * @param {Object} opts
         * @param {HTMLElement} opts.parent - 父元素（body）
         * @param {string} opts.tabId - 唯一 ID 前缀（用于元素 ID）
         * @param {string} [opts.wrapCls] - wrap 容器 class（默认 'sglv-collection-tab'）
         * @param {string} [opts.kpiHtml] - KPI 区域 HTML（可选）
         * @param {string} [opts.toolbarHtml] - 工具栏 HTML（可选）
         * @param {string} [opts.filterBarHtml] - 筛选栏 HTML（可选）
         * @returns {{ wrap: HTMLElement, kpi: HTMLElement|null, toolbar: HTMLElement, content: HTMLElement, pagination: HTMLElement }}
         */
        function createCollectionTabShell(opts) {
            const o = opts || {};
            const parent = o.parent;
            if (!parent) throw new Error('createCollectionTabShell: parent required');
            const tabId = o.tabId || 'sgr';
            const wrapCls = o.wrapCls || 'sglv-collection-tab';

            const wrap = document.createElement('div');
            wrap.className = wrapCls;
            wrap.dataset.tab = tabId;

            let kpi = null;
            if (o.kpiHtml) {
                kpi = document.createElement('div');
                kpi.id = tabId + '-kpi';
                kpi.innerHTML = o.kpiHtml;
                wrap.appendChild(kpi);
            }

            const toolbar = document.createElement('div');
            toolbar.className = 'sglv-toolbar';
            toolbar.innerHTML = o.toolbarHtml || '';
            if (toolbar.children.length > 0) wrap.appendChild(toolbar);

            if (o.filterBarHtml) {
                const filterBar = document.createElement('div');
                filterBar.className = 'sglv-filter-bar';
                filterBar.innerHTML = o.filterBarHtml;
                wrap.appendChild(filterBar);
            }

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

            const pagination = document.createElement('div');
            pagination.className = 'sglv-pagination';
            pagination.id = tabId + '-pagination';
            wrap.appendChild(pagination);

            parent.appendChild(wrap);
            return { wrap: wrap, kpi: kpi, toolbar: toolbar, content: content, pagination: pagination };
        }

        // ==================== v2.4.0: 多源数据加载器（MultiSourceLoader） ====================
        // 抽象"缓存命中 → 后台静默刷新 → 多源回退 → 负缓存"通用组件
        // 锁区/绝版/捆绑包等数据加载均可接入
        // ================================================================

        // ---- MultiSourceLoader 底层工具：统一委托 SGLVCore(_C) ----
        // 修复：本组件初版直接使用裸标识符 nsKey / negCacheGet / negCacheSet /
        //   negCacheClear / gmFetch，但这几个名字在本 lib 内从未定义（预期来自 SGLVCore）。
        //   运行时抛 ReferenceError 的后果：
        //     · gmFetch —— 同步抛出落在 Promise executor 内 → load() 永远 reject，
        //       串行多源回退全部走不通 → 锁区/绝版/捆绑包标签页永远拿不到远程数据；
        //     · negCache* —— 被 try/catch 吞掉 → 负缓存从未生效 → 源挂掉时反复重试风暴。
        const _mslNsKey = (k) => (_C && typeof _C.nsKey === 'function') ? _C.nsKey(k) : ('sglv_' + k);
        const _mslNegGet = (k, ttl) => {
            try { return (_C && _C.negCache) ? _C.negCache.get(k, ttl) : null; } catch (e) { return null; }
        };
        const _mslNegSet = (k, err) => {
            try { if (_C && _C.negCache) _C.negCache.set(k, err); } catch (e) { /* ignore */ }
        };
        const _mslNegClear = (k) => {
            try { if (_C && _C.negCache) _C.negCache.clear(k); } catch (e) { /* ignore */ }
        };
        const _mslFetch = (url) => (_C && typeof _C.gmFetchText === 'function')
            ? _C.gmFetchText(url)
            : fetch(url).then((r) => { if (!r.ok) throw new Error('HTTP ' + r.status); return r.text(); });

        /**
         * 创建多源加载器实例
         * @param {Object} cfg
         * @param {string} cfg.key - 缓存 key（同时作为 nsKey 前缀）
         * @param {string[]} cfg.sources - URL 列表（按顺序回退）
         * @param {Function} cfg.parse - 解析函数 (text) => { apps, source, fetchedAt }
         * @param {number} [cfg.ttl] - TTL 毫秒（默认 6h）
         * @param {number} [cfg.negCacheTtl] - 负缓存 TTL 毫秒（默认 30min）
         * @param {Function} [cfg.onUpdate] - 数据更新回调 (result) => void
         * @returns {Object} loader instance { load(force), getCache(), clearCache() }
         */
        function createMultiSourceLoader(cfg) {
            const c = cfg || {};
            const key = c.key;
            if (!key) throw new Error('createMultiSourceLoader: key required');
            const sources = Array.isArray(c.sources) ? c.sources.slice() : [];
            const parse = c.parse || function (t) { return JSON.parse(t); };
            const ttl = c.ttl || (6 * 3600 * 1000);
            const negTtl = c.negCacheTtl || (30 * 60 * 1000);
            const onUpdate = c.onUpdate || function () {};

            let _memCache = null;
            let _loading = false;
            let _lastBgRefresh = 0;
            let _pendingForce = false;
            const _permKey = 'msl_' + key;

            // 永久缓存读写（基于 SGLVCore.IDB）
            function _permGet() {
                try {
                    if (_C_IDB) return _C_IDB.get(PERM_CACHE_PREFIX + _permKey, null);
                } catch (e) { /* ignore */ }
                return null;
            }
            function _permSet(v) {
                try {
                    if (_C_IDB) _C_IDB.set(PERM_CACHE_PREFIX + _permKey, v);
                } catch (e) { /* ignore */ }
                _memCache = v;
            }

            // 负缓存（防止短时间内重复打挂掉的源）
            function _negGet() {
                return _mslNegGet(_mslNsKey('msl_neg_' + key), negTtl);
            }
            function _negSet(msg) {
                _mslNegSet(_mslNsKey('msl_neg_' + key), msg || '');
            }
            function _negClear() {
                _mslNegClear(_mslNsKey('msl_neg_' + key));
            }

            function _backgroundRefresh(force) {
                if (_loading) {
                    if (force) _pendingForce = true;
                    return;
                }
                _loading = true;
                const restore = () => { _loading = false; if (_pendingForce) { _pendingForce = false; setTimeout(() => load(true), 0); } };

                // 串行回退多源
                const trySources = async (idx) => {
                    if (idx >= sources.length) {
                        _loading = false;
                        if (!force) _negSet('all sources failed');
                        throw new Error('MultiSourceLoader[' + key + ']: all sources failed');
                    }
                    try {
                        const text = await _mslFetch(sources[idx]);
                        const parsed = parse(text);
                        _permSet({ data: parsed, source: 'remote', fetchedAt: Date.now() });
                        _negClear();
                        _lastBgRefresh = Date.now();
                        onUpdate({ data: parsed, source: 'remote', fetchedAt: _lastBgRefresh });
                        _loading = false;
                        return parsed;
                    } catch (e) {
                        console.warn('[MSL ' + key + '] source ' + idx + ' failed:', e.message);
                        return trySources(idx + 1);
                    }
                };
                trySources(0).catch(e => { _loading = false; if (!force) _negSet(e.message); });
            }

            function load(force) {
                if (!force) {
                    if (_memCache) return Promise.resolve({ data: _memCache.data, source: _memCache.source || 'memory', fetchedAt: _memCache.fetchedAt || 0, fromCache: true });
                    const perm = _permGet();
                    if (perm && perm.data) {
                        _memCache = perm;
                        // 后台静默刷新节流
                        if (Date.now() - _lastBgRefresh > ttl) _backgroundRefresh(false);
                        return Promise.resolve({ data: perm.data, source: perm.source || 'permCache', fetchedAt: perm.fetchedAt || 0, fromCache: true });
                    }
                    if (_negGet()) return Promise.resolve({ data: null, source: 'negCache', fetchedAt: 0, fromCache: true });
                }
                return new Promise((resolve, reject) => {
                    if (_loading) { _pendingForce = !!force; return; }
                    _loading = true;
                    const trySources = (idx) => {
                        if (idx >= sources.length) {
                            _loading = false;
                            if (!force) _negSet('all sources failed');
                            return reject(new Error('all sources failed'));
                        }
                        _mslFetch(sources[idx]).then(text => {
                            const parsed = parse(text);
                            _permSet({ data: parsed, source: 'remote', fetchedAt: Date.now() });
                            _negClear();
                            _lastBgRefresh = Date.now();
                            _loading = false;
                            onUpdate({ data: parsed, source: 'remote', fetchedAt: _lastBgRefresh });
                            resolve({ data: parsed, source: 'remote', fetchedAt: _lastBgRefresh, fromCache: false });
                        }).catch(e => {
                            console.warn('[MSL ' + key + '] source ' + idx + ' failed:', e.message);
                            trySources(idx + 1);
                        });
                    };
                    trySources(0);
                });
            }

            return {
                load: load,
                getCache: function () { return _memCache || _permGet(); },
                clearCache: function () { _memCache = null; try { if (_C_IDB) _C_IDB.set(PERM_CACHE_PREFIX + _permKey, null); } catch (e) {} _negClear(); },
                invalidate: function () { _memCache = null; }
            };
        }

        // ==================== v2.6.0: 受限游戏封面加载器（重写） ====================
        // 参考 steam-friend-manager-1.5.3.js 的 dashLoadPosterImg + steam-activity-modern.user.js
        // 的 coverChainUrls / fetchCapsuleFromAPI，重写要点：
        //
        // ① 【关键修复】链首改为横向 header.jpg 而非竖版 library_600x900。
        //    旧链把 library_600x900 放链首且竖版变体有 8 个 URL。绝版 / 锁区收录的绝大多数是
        //    2015 年前的老游戏，Steam 早已不再为其生成竖版 library_600x900 —— 这 8 个 URL 必然
        //    逐个 404，串行等待把首屏拖到数秒后才落到 header.jpg，表现为"封面加载失败"。
        //    header.jpg 是 Steam 对所有已发售游戏的通用横图，命中率接近 100%，应当放链首。
        // ② 链长从 12 收敛到 6（4 CDN × header/capsule 各一），配合 ① 大幅缩短失败路径。
        // ③ 新增 appdetails API 兜底（filters=basic 同时返回 capsule_image 与 header_image），
        //    这是老游戏和非英语区游戏唯一可靠的取图途径（old API 由 steam-activity 验证有效）。
        // ④ 成功 URL 统一写跨会话缓存（recordGood），下次直接链首命中，省掉全部探测请求。
        // ⑤ 容器改为 letterbox：横向图在竖版容器内居中显示（上下留白），
        //    不再用 object-fit:cover 硬裁 —— 旧游戏横图被裁成竖版时主体常被切掉。
        // ================================================================

        // 通用"无封面"占位（Steam 图标）
        const RESTRICTED_BROKEN_ICON_SVG = '<svg viewBox="0 0 24 24" fill="currentColor"><path d="M12 2C6.5 2 2 6.5 2 12s4.5 10 10 10 10-4.5 10-10S17.5 2 12 2zm-1 14H9V8h2v8zm4 0h-2V8h2v8z"/></svg>';
        // 锁区"被锁"占位（红色锁）
        const RESTRICTED_BLOCKED_ICON_SVG = '<svg viewBox="0 0 24 24" fill="currentColor"><path d="M18 8h-1V6c0-2.76-2.24-5-5-5S7 3.24 7 6v2H6c-1.1 0-2 .9-2 2v10c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V10c0-1.1-.9-2-2-2zm-6 9c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2zm3.1-9H8.9V6c0-1.71 1.39-3.1 3.1-3.1 1.71 0 3.1 1.39 3.1 3.1v2z"/></svg>';

        /** 受限游戏封面短链（横向优先）。
         *  chain[0] = cdn.cloudflare header.jpg（命中率最高）
         *  chain[1] = shared.akamai store_item_assets header.jpg
         *  chain[2] = cdn.akamai header.jpg
         *  chain[3] = shared.fastly store_item_assets header.jpg
         *  chain[4] = shared.akamai store_item_assets capsule_467x181.jpg（更新游戏的大横幅）
         *  chain[5] = cdn.cloudflare capsule_467x181.jpg
         *  全部失败 → appdetails API 兜底（见 restrictedCoverImg 的 onerror）
         */
        function restrictedCoverChain(appid) {
            const id = String(appid);
            return [
                `https://cdn.cloudflare.steamstatic.com/steam/apps/${id}/header.jpg`,
                `https://shared.akamai.steamstatic.com/store_item_assets/steam/apps/${id}/header.jpg`,
                `https://cdn.akamai.steamstatic.com/steam/apps/${id}/header.jpg`,
                `https://shared.fastly.steamstatic.com/store_item_assets/steam/apps/${id}/header.jpg`,
                `https://shared.akamai.steamstatic.com/store_item_assets/steam/apps/${id}/capsule_467x181.jpg`,
                `https://cdn.cloudflare.steamstatic.com/steam/apps/${id}/capsule_467x181.jpg`,
            ];
        }

        // appdetails API 兜底结果缓存（同 appid 只发一次请求，多张卡共享）
        // v2.9.3: 成功结果本会话长期有效；失败结果只缓存 10 分钟（渐进式重试），
        //   避免一次网络抖动把该 appid 在整个会话里永久拉黑
        const _coverApiCache = new Map();   // appid → { url, ts }
        const _coverApiPending = new Set();
        const COVER_API_NEG_TTL = 10 * 60 * 1000;
        const COVER_API_CACHE_MAX = 1200;
        function _coverApiCached(id) {
            const e = _coverApiCache.get(id);
            if (!e) return undefined;
            if (!e.url && (Date.now() - e.ts) > COVER_API_NEG_TTL) {
                _coverApiCache.delete(id);
                return undefined;
            }
            return e.url;
        }
        function _coverApiStore(id, url) {
            _coverApiCache.delete(id);
            _coverApiCache.set(id, { url: url || '', ts: Date.now() });
            if (_coverApiCache.size > COVER_API_CACHE_MAX) {
                const it = _coverApiCache.keys();
                while (_coverApiCache.size > COVER_API_CACHE_MAX) {
                    const n = it.next();
                    if (n.done) break;
                    _coverApiCache.delete(n.value);
                }
            }
        }

        /** appdetails?filters=basic 兜底取图 —— 老游戏/非英语区游戏唯一可靠途径。
         *  参考 steam-activity-modern.user.js 的 fetchCapsuleFromAPI（含 in-flight 去重）。 */
        function fetchCoverFromApi(appid) {
            const id = String(appid);
            const cachedNow = _coverApiCached(id);
            if (cachedNow !== undefined) return Promise.resolve(cachedNow);
            if (_coverApiPending.has(id)) return Promise.resolve('');   // 并发中不再重复打接口
            _coverApiPending.add(id);

            const apiUrl = `https://store.steampowered.com/api/appdetails?appids=${id}&filters=basic`;
            const finish = (url) => {
                _coverApiStore(id, url);
                _coverApiPending.delete(id);
                if (url) {
                    // v2.9.3: appdetails 的 capsule_image/header_image 都是横版，归 header 槽位；
                    //   写成 poster 会让"竖版缺失"标记被误触（主线竖版链还没跑过）。
                    //   真正的归槽以 markLoaded 按实际加载 URL 形态写入为准。
                    try {
                        const fb = _coverFb();
                        if (fb && typeof fb.recordGood === 'function') fb.recordGood(id, url, 'header');
                    } catch (e) { /* ignore */ }
                }
                return url || '';
            };

            return new Promise((resolve) => {
                const doReq = (typeof GM_xmlhttpRequest !== 'undefined') ? GM_xmlhttpRequest : null;
                const onFail = () => resolve(finish(''));
                if (doReq) {
                    let settled = false;
                    const timer = setTimeout(onFail, 8000);
                    doReq({
                        method: 'GET', url: apiUrl, timeout: 8000,
                        onload: (resp) => {
                            if (settled) return; settled = true; clearTimeout(timer);
                            let url = '';
                            try {
                                const json = JSON.parse(resp.responseText);
                                const d = json && json[id];
                                if (d && d.success && d.data) url = d.data.capsule_image || d.data.header_image || '';
                            } catch (e) { url = ''; }
                            resolve(finish(url));
                        },
                        onerror: () => { if (!settled) { settled = true; clearTimeout(timer); onFail(); } },
                        ontimeout: () => { if (!settled) { settled = true; clearTimeout(timer); onFail(); } },
                    });
                } else {
                    fetch(apiUrl).then(r => r.json()).then(json => {
                        const d = json && json[id];
                        const url = (d && d.success && d.data) ? (d.data.capsule_image || d.data.header_image || '') : '';
                        resolve(finish(url));
                    }).catch(() => resolve(finish('')));
                }
            });
        }

        /**
         * 三态封面渲染后的同步校正补丁。
         * 背景：受限游戏列表一次性 innerHTML 写入上千张卡，浏览器对命中 HTTP 缓存的图
         * 可能在 DOM 解析阶段就完成解码 —— 此时 inline onload 事件的监听器尚未挂上，
         * 导致 wrapper 永远停在 sglv-img-loading（opacity:0 → 封面全白）。
         */
        // v2.7.0: 已并入 bindRestrictedCoverLoaders（链式回退 + API 兜底 + 缓存命中补状态），
        // 保留同名薄封装，避免 3 个渲染函数里的调用点需要同步改名。
        function syncRestrictedCoverStates(root) {
            bindRestrictedCoverLoaders(root);
        }

        /**
         * 受限游戏三态封面加载器（绝版 / 锁区 / 捆绑包 共用）—— v2.7.0 重写
         *
         * v2.6.0 的实现把回退链塞进 inline onerror，用 `.replace(/\d+/, ci)` 拼下一个 URL。
         * 这是错的：appid 本身含数字，replace 会把 appid 替换成链索引，
         * 实测 chain[5].replace(/\d+/, 1) → `.../apps/1/header.jpg`，
         * 于是整条链全是 404，永远走不到 API 兜底 —— 表现为"所有封面全挂"。
         *
         * v2.7.0 改为「渲染时只输出干净标记 + 渲染后统一绑定事件」：
         *   - HTML 里只有 <img data-cover-appid="..." data-cover-ci="0">，没有任何拼接的 JS；
         *   - bindRestrictedCoverLoaders() 渲染后扫一遍，用 addEventListener 绑定链式回退；
         *     链数组在闭包里，索引直接取自 dataset，不会有字符串替换的坑；
         *   - 链穷尽 → fetchCoverFromApi() 兜底 → 仍失败才 broken。
         */
        function restrictedCoverImg(appid, name, kind, opts) {
            const o = opts || {};
            const isBlocked = !!o.isBlocked;
            const safeName = Host.wlEscape(name || '');
            const brokenCls = 'sglv-img-broken' + (isBlocked ? ' sglv-img-broken-blocked' : '');

            // 1) 跨会话缓存命中 —— 命中即链首，后续全部跳过
            // v2.9.3: 受限封面是横版容器，只读横版槽位：
            //   竖版缺失标记（poster 槽位里的横版 URL）→ header → capsule → 本会话 API 结果
            //   旧实现直接读 poster 槽位，可能把竖版海报塞进 16:9 容器
            let url = '';
            try { url = coverHorizontalFallbackUrl(String(appid)) || ''; } catch (e) { /* ignore */ }
            if (!url) { try { url = coverGoodUrl(String(appid), 'header') || ''; } catch (e) { /* ignore */ } }
            if (!url) { try { url = coverGoodUrl(String(appid), 'capsule') || ''; } catch (e) { /* ignore */ } }
            if (!url) {
                try {
                    const fb = _coverFb();
                    if (fb && typeof fb.getCoverUrl === 'function') {
                        url = fb.getCoverUrl(String(appid), 'header', Host.isZh ? 'schinese' : '') || '';
                    }
                } catch (e) { /* ignore */ }
            }
            if (!url) {
                const cachedApi = _coverApiCached(String(appid));
                if (cachedApi) url = cachedApi;
            }

            const chain = restrictedCoverChain(appid);
            const firstUrl = url || chain[0];

            if (!firstUrl) {
                return '<div class="sglv-img-wrapper ' + brokenCls + '" data-appid="' + appid + '">' + _restrictedBrokenInner(name, isBlocked) + '</div>';
            }

            // 2) 干净的 HTML：只带 data 标记，回退逻辑交给 bindRestrictedCoverLoaders
            // v2.9.2: 必须带 data-cover-appid（见 unifiedCover 同名注释）
            return '<div class="sglv-img-wrapper sglv-img-loading" data-cover-appid="' + appid + '" data-appid="' + appid + '" data-cover-kind="poster"' +
                ' data-cover-blocked="' + (isBlocked ? '1' : '0') + '">' +
                '<img class="sglv-card-img" src="' + firstUrl + '" alt="' + safeName + '" decoding="async" referrerpolicy="no-referrer">' +
                '<div class="sglv-img-fallback-layer">' + _restrictedBrokenInner(name, isBlocked) + '</div>' +
                '</div>';
        }

        /**
         * 渲染后绑定封面回退链（v2.7.0 核心）
         * 每个 wrapper 只绑定一次（用 __bound 标记），内部维护链索引，
         * 链穷尽后走一次 appdetails API 兜底。
         */
        function bindRestrictedCoverLoaders(root) {
            const scope = root || document;
            // v2.9.2: 选择器同时接受 data-cover-appid / data-appid ——
            //   旧选择器只认 wrapper 上的 data-cover-appid，而 unifiedCover / restrictedCoverImg
            //   生成的 wrapper 只有 data-appid，一个都匹配不到 → 从不绑定事件
            //   → sglv-img-loading 永不摘除（大海报视图 opacity:0 全空白）
            //   → 图片 404 后也没有任何回退链。
            scope.querySelectorAll('.sglv-img-wrapper[data-appid]:not([data-bound]), .sglv-img-wrapper[data-cover-appid]:not([data-bound])').forEach(function (wrapper) {
                const img = wrapper.querySelector('img');
                if (!img) return;
                wrapper.setAttribute('data-bound', '1');

                const appid = img.getAttribute('data-cover-appid') || wrapper.getAttribute('data-cover-appid') || wrapper.getAttribute('data-appid');
                if (!appid) return;
                const isBlocked = wrapper.getAttribute('data-cover-blocked') === '1';
                const brokenCls = 'sglv-img-broken' + (isBlocked ? ' sglv-img-broken-blocked' : '');
                const name = img.getAttribute('alt') || '';
                const kind = wrapper.getAttribute('data-cover-kind') || 'poster';
                const preferVertical = wrapper.getAttribute('data-cover-prefer-vertical') === '1';
                // hero（大海报视图）走独立长链；竖版卡片墙走竖版优先链（链尾同样是 header 兜底）；
                // 其余（受限封面/锁区/捆绑包）统一横向链
                let chain;
                if (kind === 'hero') chain = unifiedCoverChain(appid, 'hero');
                else if (kind === 'poster' && preferVertical) chain = unifiedCoverChain(appid, 'poster', true);
                else chain = restrictedCoverChain(appid);

                // 初始 src 可能是跨会话 good 缓存（不在 chain 里）：
                // 命中 chain → 从下一条继续；未命中 → 从链首开始尝试
                let ci = chain.indexOf(img.getAttribute('src') || '');
                let apiTried = false;

                img.setAttribute('data-cover-appid', appid);

                const markLoaded = () => {
                    wrapper.classList.remove('sglv-img-loading');
                    wrapper.classList.add('sglv-img-loaded');
                    // v2.9.2: 图片本身也要挂 sglv-img-loaded ——
                    //   `.sgc-panel .sglv-card-img { opacity: 0 }` 的显示态是
                    //   `.sglv-card-img.sglv-img-loaded`（img 级），旧 inline onload 会加。
                    //   改用事件委托后没人加 → 卡片/列表视图封面全员 opacity:0 不可见。
                    if (img.classList) {
                        img.classList.add('sglv-img-loaded');
                        if (img.naturalWidth > img.naturalHeight) img.classList.add('sglv-img-wide');
                    }
                    // v2.9.3: 按图片实际形态归槽（竖版 → poster，横版 → header），
                    //   而不是按容器 kind —— 受限/大海报容器加载的常是 header.jpg，
                    //   写成 capsule 会污染对应槽位；归一到 header 则各视图共享。
                    //   例外：竖版容器最终加载了横图 = "竖版资产缺失"标记，仍需写 poster 槽位，
                    //   否则 coverVerticalMissing 永远为假，竖版视图每次都要重吃 8 个 404。
                    try {
                        const src = img.src || '';
                        if (src && src.indexOf('data:') !== 0) {
                            const vertical = _sgcvIsVerticalUrl(src);
                            const slots = vertical ? ['poster'] : ['header'];
                            if (!vertical && kind === 'poster') slots.push('poster');   // 缺失标记
                            const fb = _coverFb();
                            for (const slot of slots) {
                                if (fb && typeof fb.recordGood === 'function') fb.recordGood(appid, src, slot);
                                // 同步写入宿主共享缓存（跨面板复用：收藏 → 主面板）
                                if (Host && typeof Host.recordPosterGood === 'function') Host.recordPosterGood(appid, src, slot);
                            }
                        }
                    } catch (e) { /* ignore */ }
                };

                const markBroken = () => {
                    wrapper.classList.remove('sglv-img-loading');
                    wrapper.classList.add(brokenCls);
                    const layer = wrapper.querySelector('.sglv-img-fallback-layer');
                    if (layer) layer.innerHTML = _restrictedBrokenInner(name, isBlocked);
                };

                // 推进到链上第一个"不是当前失败 URL"的候选
                const advance = () => {
                    const cur = img.getAttribute('src') || '';
                    for (ci++; ci < chain.length; ci++) {
                        const u = chain[ci];
                        if (u && u !== cur) { img.src = u; return true; }
                    }
                    return false;
                };

                const onError = () => {
                    if (advance()) return;
                    if (!apiTried) {
                        apiTried = true;
                        fetchCoverFromApi(appid).then(url => {
                            if (url) { img.src = url; return; }
                            markBroken();
                        }).catch(() => markBroken());
                        return;
                    }
                    markBroken();
                };

                img.addEventListener('load', () => {
                    // naturalWidth<=1 视为占位/空图（同步校正时也会走到这里）
                    if (!img.naturalWidth || img.naturalWidth < 2) return;
                    markLoaded();
                });
                img.addEventListener('error', onError);

                // load/error 早于绑定（HTTP 缓存命中 / 首图在 DOM 解析阶段就 404）
                // → 立即补状态，否则 wrapper 会永远停在 sglv-img-loading
                if (img.complete) {
                    if (img.naturalWidth > 1) markLoaded();
                    else if (img.getAttribute('src')) onError();
                }
            });
        }

        // broken 态内容（同时用作 wrapper 内的兜底层，loaded 态下被 CSS 隐藏）
        function _restrictedBrokenInner(name, isBlocked) {
            return '<div class="sglv-img-broken-icon">' + (isBlocked ? RESTRICTED_BLOCKED_ICON_SVG : RESTRICTED_BROKEN_ICON_SVG) + '</div>' +
                '<div class="sglv-img-broken-label">' + Host.wlEscape(isBlocked ? (Host.isZh ? '锁区游戏' : 'Region Locked') : (Host.isZh ? '无封面' : 'No Cover')) +
                (name ? '<br>' + Host.wlEscape(name) : '') + '</div>';
        }

        // ==================== 供应商分类标签页 ====================
        // 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;
                // 修复：原调用 loadAllCollectionData(true)，但该函数在模块 4 抽离后已无定义
                //   （悬空引用 → 点刷新即抛 ReferenceError）。按上方守卫条件直接调用宿主加载器，
                //   数据到位后由 sglv:series-data-loaded / sglv:supplier-data-loaded 事件触发重绘。
                refreshBtn.addEventListener('click', () => {
                    if (typeof Host.loadSeriesData === 'function') Host.loadSeriesData(true);
                    if (typeof Host.loadSupplierData === 'function') Host.loadSupplierData(true);
                });
                wrap.appendChild(refreshBtn);
                // v1.9.40: 不再常驻状态文本（更新时间曾压缩切换按钮致变形）——刷新结果由悬浮提示显示
            }
            return wrap;
        }


        /** 刷新供应商/系列标签页内容（不重建整个面板，避免骨架闪烁）
         *  修复：sglv:series-data-loaded / sglv:supplier-data-loaded 事件回调引用了本函数，
         *        但该函数从未定义 → 事件触发时抛 ReferenceError，远程数据更新后界面不刷新。
         *  逻辑与 renderPubModeSwitch 的模式切换分支保持一致。 */
        function refreshPublisherTabContent() {
            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();
            }
        }

        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="${sgcEsc(pubName)}">
                        <div class="sglv-card-row gap6">
                            <span class="sglv-pub-card-name">${sgcEsc(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);
                });
            });
        }

        // 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">${sgcEsc(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">${sgcEsc(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);
            }
        }



        // v2.0.0: 选 pub 后显示该 pub 下所有系列的合并游戏列表
        //  用户可通过面包菜单二级下拉进一步选具体 series
        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">${sgcEsc(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="${sgcEsc(pubName)}" data-series="${sgcEsc(seriesName)}">
                        <div class="sglv-card-row gap4">
                            <span class="sglv-series-card-name">${sgcEsc(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">${sgcEsc(pubName)}</span>
                    <span style="color:#8a9ba8">›</span>
                    <span style="font-size:15px;font-weight:600;color:#fff">${sgcEsc(seriesName)}</span>
                </div>
            `;
            renderSeriesDetailCommon(breadcrumbHtml, games, () => renderPubSeriesDetail(pubName, seriesName), 'pub:' + pubName + '\u0000' + seriesName);
        }

        // v2.0.0: 系列模式 — 面包菜单 + 完成度 + 网格
        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">${sgcEsc(seriesName)}</span>
                </div>
            `;
            renderSeriesDetailCommon(breadcrumbHtml, games, () => renderSeriesModeDetail(seriesName), 'series:' + seriesName);
        }

        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
         */
        // v2.0.0 (cover-fallback v2.0): 重写为 data-属性 + 单一 onerror 委托
        // 之前: inline 链式 onerror 串 7-20 URL, 浏览器主动加载链首 (常 404), HTML attribute 冗长
        // 现在: img 创建时 src = SGLVCoverFallback.getCoverUrl() (链首 cdn.cloudflare,老游戏命中),
        //      失败时委托 _sglvChainFallback → SGLVCoverFallback.chainLoad (JS 接管, addEventListener 单 listener)
        // 链长度: 7-8 (从 20 砍掉一半多), schinese 变体放链尾 (避免老游戏先吃 4-5 个 404)
        // v2.0.0 (cover-fallback v2.0): 重写为 data-属性 + 单一 onerror 委托
        // 之前: inline 链式 onerror 串 7-20 URL, 浏览器主动加载链首 (常 404), HTML attribute 冗长
        // 现在: img 创建时 src = SGLVCoverFallback.getCoverUrl() (链首 cdn.cloudflare, 老游戏命中),
        //      失败时委托 _sglvChainFallback → SGLVCoverFallback.chainLoad (JS 接管, addEventListener 单 listener)
        // 链长度: 7-8 (从 20 砍掉一半多), schinese 变体放链尾 (避免老游戏先吃 4-5 个 404)
        // v2.8.0: 统一走 unifiedCover（addEventListener 绑定，无跨上下文 inline onerror、无一次性锁）。
        // kind 'header' 归一到 'hero' 链（系列视图专属的超宽横图链）。
        function seriesCoverImg(g, kind, cls, opts) {
            const k = (kind === 'header') ? 'hero' : (kind || 'poster');
            return unifiedCover(g.id, g.name || '', k, Object.assign({ imgCls: cls || 'sglv-card-img' }, opts || {}));
        }

        function seriesCapsuleImg(g) {
            return unifiedCover(g.id, g.name || '', 'capsule', { imgCls: 'sglv-wl-cover-img' });
        }

        function _sgcvChainFallbackImpl(img) {
            if (!img || !img.dataset || !img.dataset.appid) return;
            var appid = img.dataset.appid;
            var kind = img.dataset.kind || 'capsule';
            if (img._sglvChainLoading) return;
            img._sglvChainLoading = 1;
            try {
                var fb = _coverFb();
                if (fb && typeof fb.chainLoad === 'function') {
                    fb.chainLoad(img, String(appid), kind, {
                        onGiveUp: function () {
                            if (img && img.parentElement) {
                                var ph = document.createElement('div');
                                ph.className = (img.className || '') + ' sglv-cover-broken';
                                ph.textContent = (Host && Host.isZh) ? '无封面' : 'No Cover';
                                img.parentElement.replaceChild(ph, img);
                            }
                        },
                    });
                } else {
                    if (img.parentElement) {
                        var ph = document.createElement('div');
                        ph.className = (img.className || '') + ' sglv-cover-broken';
                        ph.textContent = (Host && Host.isZh) ? '无封面' : 'No Cover';
                        img.parentElement.replaceChild(ph, img);
                    }
                }
            } catch (e) { /* 静默降级 */ }
        }
        try {
            var _sgcvPageWin = (typeof unsafeWindow !== 'undefined') ? unsafeWindow : window;
            _sgcvPageWin._sglvChainFallback = _sgcvChainFallbackImpl;
        } catch (e) { /* ignore */ }

                // 挂载到页面上下文（内联 onerror 属性在页面上下文执行）
        try {
            var _sgcvPageWin = (typeof unsafeWindow !== 'undefined') ? unsafeWindow : window;
            _sgcvPageWin._sglvChainFallback = _sgcvChainFallbackImpl;
        } catch (e) { /* ignore */ }

        // v2.0.0: 删掉旧版 seriesCapsuleImg(2838 旧实现)——已统一到 _sglvChainFallback 单委托
        //   旧版 inline 链式 onerror 串 7-20 URL + 竞速兜底,与新 design 重复,会让 2838 旧版覆盖
        //   上面的 2767 新版,导致单委托 _sglvChainFallback 永远不会生效

        /**
         * 系列/供应商游戏列表公共渲染（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 sglv-card-grid-7">'}
            `;

            // 按拥有状态筛选游戏
            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 sglv-poster-card" onclick="window.open('https://store.steampowered.com/app/${g.id}','_blank')">
                            <div class="sglv-card-img-wrap">
                                ${seriesCoverImg(g, 'poster', 'sglv-card-img', { preferVertical: true })}
                            </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.8.0: 统一封面链绑定（系列视图的三种卡片都走 unifiedCover）
            bindRestrictedCoverLoaders(main);

            // 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);
        }

        // v2.2.0: 绝版类型 → 颜色映射（KPI 行 + 卡片徽章共用）
        const DELISTED_TYPE_COLORS = {
            'delisted': '#f44336',           // 已下架
            'purchase_disabled': '#fb923c',  // 购买禁用
            'f2p_unavailable': '#a78bfa',    // F2P 不可用
            'retail_only': '#60a5fa',        // 仅零售
            'test_app': '#94a3b8'            // 测试应用
        };
        const DELISTED_TYPE_KEYS = ['delisted', 'purchase_disabled', 'f2p_unavailable', 'retail_only', 'test_app'];

        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();

            // v2.2.0: 抽出受限游戏板通用组件（绝版 / 锁区 / 将来可能扩展共用一套）
            // 卡片元数据构造：owners / changed / achievements / lastPlayed / playtime
            const ownersSvg = '<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>';
            const dateSvg = '<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>';
            const clockSvg = '<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>';

            if (delistedState.viewMode === 'card') {
                content.innerHTML = '<div class="sglv-card-grid">' + pageApps.map(function (app) {
                    const appid = appidFix(app.appid);
                    const isOwned = ownedIds.has(Number(appid)) || ownedIds.has(String(appid));
                    const typeKey = getTypeKey(app.type);
                    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) : '';

                    // v2.6.0 关键修复：此前这里传的是 coverHtml = Host.posterImg(...)，
                    // 导致绝版 tab 完全绕开了新写的 restrictedCoverImg（横向优先短链 + API 兜底），
                    // 仍在走旧的长链（8 个 library_600x900 竖版 URL）——绝版收录的都是老游戏，
                    // 这 8 个竖版图必然全 404，这就是"绝版封面加载失败"的直接原因。
                    // 现在删掉 coverHtml 覆盖，让 makeRestrictedCard 走默认的 restrictedCoverImg。
                    // 游玩时长从封面 overlay 移入右栏 meta（overlay 会与新的状态斜切带抢右下角位置）。
                    const metaItems = [];
                    if (playtimeH) metaItems.push('<span class="sglv-meta-item sglv-m-playtime" title="' + (Host.isZh ? '游玩时长' : 'Playtime') + '">' + clockSvg + Host.wlEscape(playtimeH) + '</span>');
                    if (app.owners) metaItems.push('<span class="sglv-meta-item sglv-m-owners" title="' + (Host.isZh ? '拥有率' : 'Owners') + '">' + ownersSvg + Host.wlEscape(app.owners) + '</span>');
                    if (app.changed) metaItems.push('<span class="sglv-meta-item sglv-m-date" title="' + (Host.isZh ? '下架时间' : 'Delisted') + '">' + dateSvg + Host.wlEscape(app.changed) + '</span>');

                    return makeRestrictedCard({
                        appid: appid,
                        name: app.name,
                        isOwned: isOwned,
                        typeLabel: getTypeLabel(app.type),
                        typeKey: typeKey,
                        typeColor: DELISTED_TYPE_COLORS[typeKey] || '#f44336',
                        metaItems: metaItems
                    });
                }).join('') + '</div>';
            } else {
                content.innerHTML = '<div class="sglv-list-view">' + pageApps.map(function (app) {
                    const appid = appidFix(app.appid);
                    const isOwned = ownedIds.has(Number(appid)) || ownedIds.has(String(appid));
                    const typeKey = getTypeKey(app.type);
                    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) : '';

                    // v2.6.0: 列表视图右栏保留 3 项（拥有率 / 下架 / 最后游玩），比卡片多一项是因为横向空间充裕
                    const metaItems = [];
                    if (app.owners) metaItems.push('<span class="sglv-meta-item">' + ownersSvg + Host.wlEscape(app.owners) + '</span>');
                    if (app.changed) metaItems.push('<span class="sglv-meta-item">' + dateSvg + Host.wlEscape(app.changed) + '</span>');
                    if (lastPlayed) metaItems.push('<span class="sglv-meta-item">' + clockSvg + Host.wlEscape(lastPlayed) + '</span>');
                    if (playtimeH) metaItems.push('<span class="sglv-meta-item sglv-m-playtime">' + Host.wlEscape(playtimeH) + '</span>');

                    return makeRestrictedListItem({
                        appid: appid,
                        name: app.name,
                        isOwned: isOwned,
                        typeLabel: getTypeLabel(app.type),
                        typeKey: typeKey,
                        typeColor: DELISTED_TYPE_COLORS[typeKey] || '#f44336',
                        metaItems: metaItems
                    });
                }).join('') + '</div>';
            }

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

            // v2.5.0: 补齐缓存命中图的 loaded 态（onload 早于监听器挂载时不会触发）
            syncRestrictedCoverStates(content);

            // 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>
                <div class="sglv-toolbar-spacer"></div>
                <div class="sglv-pagination sglv-delisted-pagination" id="sglv-delisted-pagination"></div>
            `;
            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);
                });
            }
        }

        // v2.5.0: 重渲染绝版 KPI 卡片行——筛选态（scope / type）变化后需要刷新 active 态与各类型可见计数。
        // scope 变化会改变每个类型卡显示的计数（scopeBase 随 scope 收窄），所以必须整体重算而非切 class。
        function renderDelistedTabKpi(kpiEl) {
            if (!kpiEl) return;
            const apps = getDelistedApps();
            if (!apps.length) { kpiEl.innerHTML = ''; return; }
            const ownedIds = Host.getActiveOwnedAppIds();
            const isOwnedId = (id) => ownedIds.has(Number(id)) || ownedIds.has(String(id));

            const totalDelisted = apps.length;
            let ownedDelisted = 0;
            apps.forEach(app => { if (isOwnedId(app.appid)) ownedDelisted++; });

            const scope = (delistedState.subFilter === 'owned') ? 'owned'
                : (delistedState.subFilter === 'missing') ? 'missing' : 'all';
            const scopeBase = (scope === 'owned') ? apps.filter(a => isOwnedId(a.appid))
                : (scope === 'missing') ? apps.filter(a => !isOwnedId(a.appid))
                : apps;

            const typeLabels = {
                'delisted': Host.T.typeDelisted,
                'purchase_disabled': Host.T.typePurchaseDisabled,
                'f2p_unavailable': Host.T.typeF2P,
                'retail_only': Host.T.typeRetailOnly,
                'test_app': Host.T.typeTestApp
            };
            // v2.6.0: KPI 小卡行 → HERO 仪表盘（与锁区同款，铺满浮窗宽度 + 分类占比可视化）
            kpiEl.innerHTML = makeRestrictedHero({
                total: totalDelisted,
                ownedCount: ownedDelisted,
                scopeBase: scopeBase.map(function (a) { return { type: getTypeKey(a.type) }; }),
                scope: scope,
                typeFilter: delistedState.typeFilter,
                title: Host.T.delistedTotal,
                typeKeys: DELISTED_TYPE_KEYS,
                typeColors: DELISTED_TYPE_COLORS,
                typeLabels: typeLabels,
                tabId: 'delisted'
            });
        }

        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;

            // v2.5.0 收敛：原布局有 5 层筛选 UI（KPI 行 / 类型徽章汇总栏 / 独立进度条 /
            //   工具栏类型按钮组 / 工具栏拥有状态按钮组），后三层与前两层表达同一组维度，视觉噪音极大。
            //   改为 2 层：① KPI 卡片行（3 scope + 5 类型，全部可点即筛选）② 工具栏（搜索 / 排序 / 视图 / 刷新）。
            //   拥有率进度条的信息不再单独占一行。
            const kpiSection = document.createElement('div');
            kpiSection.id = 'sglv-delisted-kpi';
            wrap.appendChild(kpiSection);
            renderDelistedTabKpi(kpiSection);

            // Toolbar（v2.5.0: 移除类型/拥有状态按钮组——已由 KPI 卡片承担；此处只留搜索 / 排序 / 视图 / 刷新）
            // v2.8.0: 分页器并入工具栏右侧同一行（此前独立成行，多占一整行垂直空间）
            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="${delistedState.search}">
                <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.5.0: 筛选职责已收敛到 KPI 卡片行 —— 用事件委托替代原先分散在
            //   「分类汇总徽章 / 工具栏类型按钮 / 工具栏拥有状态按钮」三处的监听。
            //   - data-delisted-scope="all|owned|missing" → subFilter
            //   - data-delisted-type="<typeKey>"            → typeFilter（再次点击同一类型回到「全部」）
            const scopeToSub = { all: 'all', owned: 'owned', missing: 'missing' };
            kpiSection.addEventListener('click', e => {
                // v2.6.0: 点击 HERO 左侧主数字区 → 一键清空 type + sub 两个筛选维度
                if (!e.target.closest('[data-delisted-scope],[data-delisted-type]') && e.target.closest('.sglv-hero-left')) {
                    if (delistedState.subFilter !== 'all' || delistedState.typeFilter !== 'all') {
                        delistedState.subFilter = 'all';
                        delistedState.typeFilter = 'all';
                        delistedState.page = 1;
                        renderDelistedTabKpi(kpiSection);
                        renderDelistedGamesList();
                    }
                    return;
                }
                const scopeCard = e.target.closest('[data-delisted-scope]');
                if (scopeCard) {
                    delistedState.subFilter = scopeToSub[scopeCard.dataset.delistedScope] || 'all';
                    delistedState.page = 1;
                    renderDelistedTabKpi(kpiSection);
                    renderDelistedGamesList();
                    return;
                }
                const typeCard = e.target.closest('[data-delisted-type]');
                if (typeCard) {
                    const t = typeCard.dataset.delistedType;
                    delistedState.typeFilter = (delistedState.typeFilter === t) ? 'all' : t;
                    delistedState.page = 1;
                    renderDelistedTabKpi(kpiSection);
                    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.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>）
        // v2.9.7: 升级为「PS Store 元数据」抓取——同一次请求同时解析中文名与真实封面主视觉。
        //   背景：收藏模块里唯一的非 Steam 游戏是「PS 会免」里无 steamAppId 的 PS 独占条目
        //   （实测数据源 1595 条中 293 条无 steamAppId），此前只有一块蓝色 PS Logo 占位画，没有封面。
        //   做法参考 steam-friend-manager 1.6.2 的非 Steam 卡（sfd-tga-excl-art + sfd-tga-excl-img）：
        //   平台占位画垫底，商店主视觉图覆盖其上；图加载失败自动移除图，保住占位画。
        //   主视觉来源：PS Store 页面内嵌的 schema.org JSON-LD（script#mfe-jsonld-tags → Product.image），
        //   实测为 1024×1024 方图，CDN image.api.playstation.com 可直链热链（无需 Referer）。
        // 输入 psstore URL；输出 Promise<{name, cover}>，空字符串表示获取失败
        const _psStoreMetaPending = new Map();
        const _PS_STORE_NAME_TTL = 6 * 3600 * 1000; // 6h，与 PS 会免数据 TTL 对齐
        const _PS_STORE_NAME_NEG_TTL = 30 * 60 * 1000; // 失败 30 分钟内不再请求
        const _PS_STORE_COVER_TTL = 30 * 24 * 3600 * 1000; // 封面主视觉 30 天（静态资源，几乎不变）
        const _PS_STORE_COVER_NEG_TTL = 6 * 3600 * 1000; // 封面抓取失败 6h 后再试
        const SGLV_PS_NAME_KEY = 'sglvPsStoreNameCache_v1';   // v1 旧 key（仅中文名，用于一次性迁移）
        const SGLV_PS_META_KEY = 'sglvPsStoreMetaCache_v2';   // v2 新 key（中文名 + 封面图）
        const _PS_META_MAX_CONCURRENCY = 4;                  // PS Store 页面 300KB+，限并发避免打满带宽
        const _PS_STORE_PRIMARY_LOCALE = 'zh-hans-hk';        // 主区域（数据源多为该区域）
        const _PS_STORE_ALT_LOCALE = 'en-us';                 // 兜底区域（主区域缺图时再试一次）

        // 内存镜像 —— 避免每次读缓存都 GM_getValue + JSON.parse（单页 49 张卡会放大成 49 次解析）
        let _psMetaCacheMap = null;
        let _psMetaFlushTimer = null;
        let _psMetaDirty = false;

        function sglvPsStoreMetaCacheLoad() {
            if (_psMetaCacheMap) return _psMetaCacheMap;
            let map = {};
            try { map = JSON.parse(GM_getValue(SGLV_PS_META_KEY, '{}') || '{}') || {}; } catch (e) { map = {}; }
            if (!map || typeof map !== 'object') map = {};
            // 迁移 v1（仅中文名）——封面字段留空，等首次抓取补齐
            try {
                const old = JSON.parse(GM_getValue(SGLV_PS_NAME_KEY, '{}') || '{}') || {};
                Object.keys(old).forEach(u => {
                    if (map[u]) return;
                    const o = old[u];
                    if (!o) return;
                    map[u] = { name: o.name || '', nameTs: o.ts || 0 };
                });
            } catch (e) { /* 忽略迁移失败 */ }
            _psMetaCacheMap = map;
            return map;
        }
        // 落盘节流——一页 49 张卡会连续写 49 次，整表 JSON 序列化放大成几十 MB 写入
        function sglvPsStoreMetaCacheSave() {
            _psMetaDirty = true;
            if (_psMetaFlushTimer) return;
            _psMetaFlushTimer = setTimeout(() => {
                _psMetaFlushTimer = null;
                if (!_psMetaDirty) return;
                _psMetaDirty = false;
                try { GM_setValue(SGLV_PS_META_KEY, JSON.stringify(_psMetaCacheMap || {})); } catch (e) { /* 忽略失败 */ }
            }, 3000);
        }
        // 旧接口（仅中文名）保留，内部并入元数据抓取
        function sglvPsStoreNameCacheLoad() { return sglvPsStoreMetaCacheLoad(); }
        function sglvPsStoreNameCacheSave() { sglvPsStoreMetaCacheSave(); }

        // 区域化 URL——数据源里 psstore 多数是 zh-hant-hk，统一到主区域再抓
        //   只替换「语言-地区」段（如 zh-hans-hk / en-us），不动 www.playstation.com/games/{slug} 这类无区域段 URL
        function psStoreLocaleUrl(url, locale) {
            if (!url) return '';
            if (!/playstation\.com/.test(url)) return url;
            if (!locale) return url;
            if (url.indexOf('/' + locale + '/') >= 0) return url;
            return url.replace(/(playstation\.com)\/[a-z]{2}(?:-[a-z]{2,4}){0,2}\//, '$1/' + locale + '/');
        }

        // PS Store 页面 → 官方名（og:title → <title> → twitter:title，与 v2.6.2 既有口径一致）
        function parsePsStoreName(html) {
            let name = '';
            try {
                if (!html) return '';
                let m = html.match(/<meta\s+(?:[^>]*?)property=["']og:title["']\s+(?:[^>]*?)content=["']([^"']+)/i);
                if (!m) m = html.match(/<title[^>]*>([^<]+)<\/title>/i);
                if (!m) m = html.match(/<meta\s+(?:[^>]*?)name=["']twitter:title["']\s+(?:[^>]*?)content=["']([^"']+)/i);
                if (m) {
                    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) { /* 忽略失败 */ }
            // v2.9.9: og:title 可能整页就是平台/商店名（区域限售页回落到首页），
            //   此时解析出的"name"是 "PlayStation" 之类泛化词，回填会把卡片名改成平台名 —— 视为抓取失败。
            if (/^(playstation(\s+(store|official\s+site))?|ps\s*store|games?)$/i.test(name)) return '';
            return name;
        }

        // PS Store 页面 → 真实封面主视觉（只认 image.api.playstation.com 主视觉域）
        function isPsCoverUrl(u) {
            return typeof u === 'string' && /^https:\/\/image\.api\.playstation\.com\/vulcan\//.test(u);
        }
        function parsePsStoreCover(html) {
            if (!html) return '';
            try {
                // ① schema.org JSON-LD（PS Store SSR 直出 Product.image）
                const m = html.match(/<script[^>]+id=["']mfe-jsonld-tags["'][^>]*>([\s\S]*?)<\/script>/i);
                if (m) {
                    try {
                        const o = JSON.parse(m[1]);
                        const img = o && typeof o.image === 'string' ? o.image : '';
                        if (isPsCoverUrl(img)) return img;
                    } catch (e) { /* JSON 解析失败走兜底 */ }
                }
                // ② 兜底——页面里第一张非评分图标的主视觉
                const all = html.match(/https:\/\/image\.api\.playstation\.com\/vulcan\/[^"'\\\s]+?\.(?:jpg|jpeg|png)/gi);
                if (all) {
                    for (let i = 0; i < all.length; i++) if (isPsCoverUrl(all[i])) return all[i];
                }
            } catch (e) { /* 忽略失败 */ }
            return '';
        }

        // 页面抓取（GM_xmlhttpRequest 包装）
        function psStoreRequest(url) {
            return new Promise(resolve => {
                if (typeof GM_xmlhttpRequest !== 'function') { resolve(''); return; }
                GM_xmlhttpRequest({
                    method: 'GET',
                    url: url,
                    timeout: 15000,
                    onload(resp) {
                        let html = '';
                        try { html = _safeRespText(resp); } catch (e) { html = ''; }
                        resolve(html || '');
                    },
                    onerror() { resolve(''); },
                    ontimeout() { resolve(''); }
                });
            });
        }

        // 并发闸门——PS Store 页面体积大，限制同时在飞的请求数
        let _psMetaQueue = [];
        let _psMetaActive = 0;
        function psMetaEnqueue(task) {
            return new Promise(resolve => {
                _psMetaQueue.push({ task, resolve });
                psMetaPump();
            });
        }
        function psMetaPump() {
            while (_psMetaActive < _PS_META_MAX_CONCURRENCY && _psMetaQueue.length) {
                const job = _psMetaQueue.shift();
                _psMetaActive++;
                const release = () => { _psMetaActive--; psMetaPump(); };
                Promise.resolve().then(job.task)
                    .then(meta => job.resolve(meta || { name: '', cover: '' }), () => job.resolve({ name: '', cover: '' }))
                    .then(release, release);
            }
        }

        // 读缓存里的封面 URL（同步，供渲染时直接贴 src，避免"先空后闪"）
        function psStoreCoverCacheGet(url) {
            if (!url) return '';
            try {
                const e = sglvPsStoreMetaCacheLoad()[url];
                if (!e || !e.cover || !e.coverTs) return '';
                if (Date.now() - e.coverTs > _PS_STORE_COVER_TTL) return '';
                return e.cover;
            } catch (e) { return ''; }
        }

        // 抓取 + 缓存：一次请求同时产出中文名与封面主视觉
        async function fetchPsStoreMetaNow(psstoreUrl) {
            const cache = sglvPsStoreMetaCacheLoad();
            const entry = cache[psstoreUrl] || {};
            const now = Date.now();
            const nameFresh = !!(entry.name && entry.nameTs && (now - entry.nameTs) < _PS_STORE_NAME_TTL);
            const coverFresh = !!(entry.cover && entry.coverTs && (now - entry.coverTs) < _PS_STORE_COVER_TTL);
            const coverFailed = !!(entry.coverFailTs && (now - entry.coverFailTs) < _PS_STORE_COVER_NEG_TTL);
            // 缓存全命中 → 不发请求
            if ((!Host.isZh || nameFresh) && (coverFresh || coverFailed)) {
                return { name: entry.name || '', cover: entry.cover || '' };
            }

            const primaryUrl = psStoreLocaleUrl(psstoreUrl, _PS_STORE_PRIMARY_LOCALE);
            const html = await psStoreRequest(primaryUrl);
            let name = nameFresh ? (entry.name || '') : parsePsStoreName(html);
            let cover = coverFresh ? (entry.cover || '') : parsePsStoreCover(html);
            // 主区域没 SSR 出主视觉（部分地区未发行/限售）→ 换美区再试一次
            if (!cover && !coverFresh && !coverFailed) {
                const altUrl = psStoreLocaleUrl(psstoreUrl, _PS_STORE_ALT_LOCALE);
                if (altUrl && altUrl !== primaryUrl) {
                    const altHtml = await psStoreRequest(altUrl);
                    if (altHtml) {
                        cover = parsePsStoreCover(altHtml);
                        if (!name && !nameFresh) name = parsePsStoreName(altHtml);
                    }
                }
            }

            const next = Object.assign({}, entry);
            if (name && name !== entry.name) { next.name = name; next.nameTs = now; }
            if (cover) { next.cover = cover; next.coverTs = now; delete next.coverFailTs; }
            else if (!coverFresh) { next.coverFailTs = now; }
            cache[psstoreUrl] = next;
            sglvPsStoreMetaCacheSave();
            return { name: name || '', cover: cover || '' };
        }

        // 对外入口：同 URL 并发去重 + 并发闸门
        function fetchPsStoreMeta(psstoreUrl) {
            if (!psstoreUrl) return Promise.resolve({ name: '', cover: '' });
            if (_psStoreMetaPending.has(psstoreUrl)) return _psStoreMetaPending.get(psstoreUrl);
            const p = psMetaEnqueue(() => fetchPsStoreMetaNow(psstoreUrl)).then(meta => {
                _psStoreMetaPending.delete(psstoreUrl);
                return meta;
            }, () => {
                _psStoreMetaPending.delete(psstoreUrl);
                return { name: '', cover: '' };
            });
            _psStoreMetaPending.set(psstoreUrl, p);
            return p;
        }

        // v2.6.2 旧接口：只取中文名（中文环境才有意义）
        function fetchPsStoreName(psstoreUrl) {
            if (!Host.isZh) return Promise.resolve('');
            if (!psstoreUrl) return Promise.resolve('');
            const cache = sglvPsStoreMetaCacheLoad();
            const cached = cache[psstoreUrl];
            if (cached) {
                if (cached.name && Date.now() - (cached.nameTs || 0) < _PS_STORE_NAME_TTL) return Promise.resolve(cached.name);
                if (!cached.name && Date.now() - (cached.nameTs || 0) < _PS_STORE_NAME_NEG_TTL) return Promise.resolve('');
            }
            return fetchPsStoreMeta(psstoreUrl).then(meta => meta.name || '');
        }


        // 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 会免封面 —— v2.8.0 统一走 unifiedCover。
        // 原实现是本项目最严重的封面反模式：每次渲染都用循环拼出 12 层嵌套的
        //   `this.src='...';this.onerror=function(){...}` 字符串再塞进 inline onerror，
        //   还叠加 _sgcvCoverRace 竞速 + 跨上下文 _sglvPsCoverFallback 兜底。
        // 后果：① HTML 体积暴涨 ② 内联属性里的多层闭包极易被 CSP/扩展拦截
        //      ③ 跨视图切换撞上一次性锁后永久失效（用户反馈的"大海报视图无封面"）。
        // v2.9.7: 无 appid 的 PS 独占游戏不再只有占位画——占位画下垫一层真实封面主视觉
        //   （data-sglv-ps-cover 由 bindPsExclusiveCovers 异步补 src）。
        function psplusPosterImg(appid, name, psstore) {
            if (!appid) return _psExclusivePlaceholder(name, psstore);
            // v2.9.4: 卡片墙默认竖版海报（竖版优先链，拿不到自动回退横版 header）
            return unifiedCover(appid, name, 'poster', { preferVertical: true });
        }

        function psplusCapsuleImg(appid, name, psstore) {
            if (!appid) return _psExclusivePlaceholder(name, psstore);
            return unifiedCover(appid, name, 'capsule', { imgCls: 'sglv-wl-cover-img' });
        }

        // PS 独占占位画 + 真实封面图层
        //   占位画（蓝色 PS Logo + 名称）垫底，封面图绝对定位覆盖其上；
        //   封面抓不到/加载失败 → 图被移除，占位画原样保留（与 friend-manager 非 Steam 卡同构）。
        function _psExclusivePlaceholder(name, psstore) {
            const cover = psstore
                ? '<img class="sglv-ps-excl-cover" data-sglv-ps-cover="' + Host.wlEscape(psstore) + '" alt="" loading="lazy" decoding="async" referrerpolicy="no-referrer">'
                : '';
            return '<div class="sglv-ps-cover-placeholder"><div class="sglv-ps-logo">' + PS_LOGO_SVG +
                '</div><div class="sglv-ps-cover-name"' + (psstore ? ' data-sglv-psstore="' + Host.wlEscape(psstore) + '"' : '') + '>' + Host.wlEscape(name || 'PS Exclusive') + '</div></div>' + cover;
        }

        // PS 独占封面绑定：给占位画上的 img 补真实主视觉
        //   ① 缓存命中 → 同步贴 src（无闪烁）
        //   ② 未命中 → 异步抓 PS Store 页（与中文名共用同一次请求），拿到后补 src
        //   ③ 加载失败/无图 → 直接移除 img，占位画不受影响
        function bindPsExclusiveCovers(root) {
            if (!root || typeof root.querySelectorAll !== 'function') return;
            const imgs = root.querySelectorAll('img[data-sglv-ps-cover]');
            if (!imgs.length) return;
            Array.prototype.forEach.call(imgs, img => {
                const url = img.getAttribute('data-sglv-ps-cover');
                if (!url) { img.remove(); return; }
                if (img.getAttribute('data-sglv-ps-bound') === '1') return;
                img.setAttribute('data-sglv-ps-bound', '1');
                img.addEventListener('load', () => img.classList.add('sglv-ps-excl-cover-loaded'), { once: true });
                img.addEventListener('error', () => img.remove(), { once: true });
                const cached = psStoreCoverCacheGet(url);
                if (cached) { img.src = cached; return; }
                fetchPsStoreMeta(url).then(meta => {
                    if (!meta || !meta.cover) { img.remove(); return; }
                    if (!img.isConnected) return;
                    img.src = meta.cover;
                });
            });
        }

        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 sglv-card-grid-7">' + 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 sglv-poster-card" data-appid="' + (appid || g.recordId) + '" onclick="window.open(\'' + clickUrl + '\',\'_blank\')">' +
                        '<div class="sglv-card-img-wrap">' + tierBadgeHtml(g) + psplusPosterImg(appid, name, g.psstore) + '</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) + (appid ? unifiedCover(appid, name, 'capsule') : psplusCapsuleImg(0, name, g.psstore)) + '</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)">'
                        // v2.9.7: PS 独占——PS 图标垫底 + 真实封面图覆盖其上（失败自动移除图）
                        : '<div class="sglv-list-icon sglv-ps-excl-iconwrap" 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 +
                            (g.psstore ? '<img class="sglv-ps-excl-cover" data-sglv-ps-cover="' + Host.wlEscape(g.psstore) + '" alt="" loading="lazy" decoding="async" referrerpolicy="no-referrer">' : '') +
                          '</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 页面替换为中文名
            // v2.9.7: 改走 fetchPsStoreMeta —— 与封面主视觉共用同一次请求（不再二次抓页）
            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;
                fetchPsStoreMeta(psUrl).then(meta => {
                    // 英文环境沿用既有命名（psExtractName 的 slug 标题化），不做替换
                    if (!Host.isZh) return;
                    const zhName = meta && meta.name;
                    if (zhName && zhName !== original) {
                        el.textContent = zhName;
                        el.title = `${zhName} (${original})`;
                    }
                });
            });
            // v2.8.0: 统一封面链绑定（addEventListener，无跨上下文 inline onerror）
            bindRestrictedCoverLoaders(content);
            // v2.9.7: PS 独占（非 Steam 游戏）真实封面绑定——占位画上叠商店主视觉
            bindPsExclusiveCovers(content);
        }

        // ==================== 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>';

        // 名称缓存（会话级，供搜索/排序使用；中文复用宿主持久化缓存；英文复用宿主 fetchGameEnName
        //         （filters=basic + 会话缓存，与橱窗别名/SGIS 别名路径共享，v2.45.1 收编 _epicFetchEnName）
        const _epicNameCache = new Map();
        const _epicNamePending = new Map();
        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; }
                }
                // 英文名走宿主桥（老宿主无此导出时降级为空名 → 显示 'App xxx' 占位）
                const en = (Host && typeof Host.fetchGameEnName === 'function') ? await Host.fetchGameEnName(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) {
            // v2.8.0: 统一封面（原实现走 coverGoodUrl + inline _sglvChainFallback，
            // 跨视图切换时会撞上 _sglvChainLoading 一次性锁导致永久失效）
            // v2.9.4: 卡片墙默认竖版海报（竖版优先链，拿不到自动回退横版 header）
            return unifiedCover(appid, name, 'poster', { preferVertical: true });
        }
        // 徽章
        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 sglv-card-grid-7">' + 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 sglv-poster-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 + unifiedCover(appid, name, 'capsule') + '</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.8.0: 统一封面链绑定（addEventListener，无跨上下文 inline onerror）
            bindRestrictedCoverLoaders(content);
        }

        // ==================== 锁区游戏标签页 (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' || blockedState.viewMode === 'cover' ? ' 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 === '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>
                <div class="sglv-toolbar-spacer"></div>
                <div class="sglv-pagination sglv-pagination-inline" id="sglv-blocked-pagination"></div>
            `;
            wrap.appendChild(toolbar);

            // v2.5.0: 移除独立筛选栏——own/cat 筛选统一由 KPI 卡片行承担（3 scope + 4 类型），
            // 原筛选栏与 KPI 行表达同一组维度，双排并存造成界面逻辑混乱。
            // v2.8.0: 分页器也并入工具栏右侧，工具栏独占一行即可完成「搜索+排序+视图+分页」全部操作。
            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', 'list'].forEach(m => { toolbar.querySelector('#sglv-blocked-' + m)?.classList.toggle('active', m === mode || (m === 'card' && blockedState.viewMode === 'cover')); });
                renderBlockedGamesList();
            };
            toolbar.querySelector('#sglv-blocked-card').addEventListener('click', () => setBlockedViewMode('card'));
            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));

            // v2.6.0: HERO 承担全部筛选职责（事件委托）
            //   - data-blocked-scope="owned|missing"     → ownFilter（再点同一卡回到「全部」）
            //   - data-blocked-type="banned|purchase_disabled|regional|top_rated" → catFilter（同样 toggle 回「all」）
            //   - 点击 HERO 左侧主数字区 → 一键清空两个维度（替代原先两个「全部」按钮的"重置"语义）
            kpi.addEventListener('click', e => {
                if (!e.target.closest('[data-blocked-scope],[data-blocked-type]') && e.target.closest('.sglv-hero-left')) {
                    if (blockedState.ownFilter !== 'all' || blockedState.catFilter !== 'all') {
                        blockedState.ownFilter = 'all';
                        blockedState.catFilter = 'all';
                        blockedState.page = 1;
                        renderBlockedKpi();
                        renderBlockedGamesList();
                    }
                    return;
                }
                const scopeCard = e.target.closest('[data-blocked-scope]');
                if (scopeCard) {
                    const f = scopeCard.dataset.blockedScope;
                    blockedState.ownFilter = (blockedState.ownFilter === f && f !== 'all') ? 'all' : f;
                    blockedState.page = 1;
                    renderBlockedKpi();
                    renderBlockedGamesList();
                    return;
                }
                const typeCard = e.target.closest('[data-blocked-type]');
                if (typeCard) {
                    const t = typeCard.dataset.blockedType;
                    // typeKey(banned/purchase_disabled/regional/top_rated) → catFilter(banned/purchase/regional/topRated)
                    const toCat = { banned: 'banned', purchase_disabled: 'purchase', regional: 'regional', top_rated: 'topRated' };
                    const cat = toCat[t];
                    if (!cat) return;
                    blockedState.catFilter = (blockedState.catFilter === cat) ? 'all' : cat;
                    blockedState.page = 1;
                    renderBlockedKpi();
                    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';
            }
        }

        // v2.5.0: 锁区筛选栏已移除——筛选职责统一收敛到 KPI 卡片行（3 scope 卡 + 4 类型卡），
        // 避免"顶部 KPI 行 + 下方筛选栏"两处重复表达同一组筛选维度。
        // 保留 syncBlockedFilterBtns 仅为兼容旧调用点（空实现，不再有筛选栏可同步）。
        function syncBlockedFilterBtns() { /* v2.5.0: 筛选栏已移除，KPI 卡片自带 active 态 */ }

        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;
            // v2.2.0: 用通用受限游戏板 KPI 行组件（scope 卡 + 类型卡合并展示）
            const typeColors = { banned: '#ef4444', purchase_disabled: '#fb923c', regional: '#a78bfa', top_rated: '#fbbf24' };
            const typeLabels = {};
            BLOCKED_TYPE_KEYS.forEach(k => {
                const info = Object.values(BLOCKED_TYPE_INFO).find(v => v.key === k);
                typeLabels[k] = Host.isZh ? info.label.zh : info.label.en;
            });

            // v2.5.0: 筛选统一收敛到 KPI 卡片行——scope 由 ownFilter 映射，type 由 catFilter 反向映射。
            // catFilter 的历史值（banned/purchase/regional/manual/topRated）与 typeKey（banned/purchase_disabled/regional/top_rated）命名不一致，
            // 这里做双向映射，保证 KPI 卡 active 态与实际筛选一致。manual 无对应类型卡 → 视为未选中任何类型。
            const scope = blockedState.ownFilter === 'notOwned' ? 'missing' : blockedState.ownFilter;
            const catToType = { banned: 'banned', purchase: 'purchase_disabled', regional: 'regional', topRated: 'top_rated' };
            const typeFilter = catToType[blockedState.catFilter] || 'all';

            const scopeBase = (scope === 'owned') ? mergedApps.filter(a => isOwned(a.appid))
                : (scope === 'missing') ? mergedApps.filter(a => !isOwned(a.appid))
                : mergedApps;

            // v2.6.0: KPI 小卡行 → HERO 仪表盘（大数字 + 类型占比条，铺满浮窗宽度）
            // 顺带解决旧版"两个全部"：主数字即"全部"，scope 卡只有「在库/未拥有」，类型行点击即筛选。
            el.innerHTML = makeRestrictedHero({
                total: total,
                ownedCount: owned,
                scopeBase: scopeBase.map(function (a) { return { type: _blockedTypeKey(a) }; }),
                scope: scope,
                typeFilter: typeFilter,
                title: Host.T.blockedKpiTotal,
                typeKeys: BLOCKED_TYPE_KEYS,
                typeColors: typeColors,
                typeLabels: typeLabels,
                tabId: 'blocked'
            });
        }

        // v2.2.0: 锁区类型标准化——categoryId → typeKey + 颜色映射
        // 真实 categoryId：20=下架 / 3=停售 / 10=锁区 / 500=好评500
        const BLOCKED_TYPE_INFO = {
            20:  { key: 'banned',            color: '#ef4444', label: { zh: '下架', en: 'Banned' } },
            3:   { key: 'purchase_disabled', color: '#fb923c', label: { zh: '停售', en: 'Purchase disabled' } },
            10:  { key: 'regional',          color: '#a78bfa', label: { zh: '锁区', en: 'Regional' } },
            500: { key: 'top_rated',         color: '#fbbf24', label: { zh: '好评500', en: 'Positive 500+' } }
        };
        const BLOCKED_TYPE_KEYS = ['banned', 'purchase_disabled', 'regional', 'top_rated'];
        function _blockedCategoryInfo(app) {
            const cid = Number(app.categoryId || 0);
            return BLOCKED_TYPE_INFO[cid] || { key: 'unknown', color: '#94a3b8', label: { zh: '其他', en: 'Other' } };
        }
        function _blockedTypeLabel(app) {
            const info = _blockedCategoryInfo(app);
            return Host.isZh ? info.label.zh : info.label.en;
        }
        function _blockedTypeKey(app) {
            return _blockedCategoryInfo(app).key;
        }
        function _blockedTypeColor(app) {
            return _blockedCategoryInfo(app).color;
        }

        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));

            // v2.2.0: 移除 cover viewMode，统一为 card / list 两视图（与绝版对齐）
            if (blockedState.viewMode === 'list') {
                content.innerHTML = '<div class="sglv-list-view">' + pageItems.map(function (a) {
                    const name = a.name || ('App ' + a.appid);
                    const owned = isOwned(a.appid);
                    const metaItems = [];
                    if (a.changedAt) metaItems.push('<span style="color:#8f98a0">' + Host.T.blockedChangedAt + ': ' + Host.wlEscape(a.changedAt) + '</span>');
                    return makeRestrictedListItem({
                        appid: a.appid,
                        name: name,
                        isOwned: owned,
                        typeLabel: _blockedTypeLabel(a),
                        typeKey: _blockedTypeKey(a),
                        typeColor: _blockedTypeColor(a),
                        metaItems: metaItems,
                        clickUrl: 'https://store.steampowered.com/app/' + a.appid
                    });
                }).join('') + '</div>';
            } else {
                content.innerHTML = '<div class="sglv-card-grid">' + pageItems.map(function (a) {
                    const name = a.name || ('App ' + a.appid);
                    const owned = isOwned(a.appid);
                    const metaItems = [];
                    if (a.changedAt) metaItems.push('<span class="sglv-meta-item">' + Host.T.blockedChangedAt + ': ' + Host.wlEscape(a.changedAt) + '</span>');
                    return makeRestrictedCard({
                        appid: a.appid,
                        name: name,
                        isOwned: owned,
                        isBlocked: true,
                        typeLabel: _blockedTypeLabel(a),
                        typeKey: _blockedTypeKey(a),
                        typeColor: _blockedTypeColor(a),
                        metaItems: metaItems,
                        clickUrl: 'https://store.steampowered.com/app/' + a.appid
                    });
                }).join('') + '</div>';
            }

            // v2.5.0: 补齐缓存命中图的 loaded 态 + 异步加载中文名
            syncRestrictedCoverStates(content);
            content.querySelectorAll('[data-sglv-appid]').forEach(el => {
                Host.loadGameZhName(el, el.getAttribute('data-sglv-appid'), el.textContent);
            });

            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.0.4: 发售日期 → Date 对象（无效返回 null，区别于空字符串）
        // 参考 friend-manager 精品游戏 sfd-stress-featured-countdown (steam-friend-manager.user.js:11489)
        function gotyDateToDate(dateStr) {
            const s = gotyDateToSortable(dateStr);
            if (s === '99999999') return null;
            const y = +s.slice(0, 4), m = +s.slice(4, 6) - 1, d = +s.slice(6, 8);
            if (!y || m < 0 || d < 1) return null;
            const dt = new Date(y, m, d);
            return isNaN(dt.getTime()) ? null : dt;
        }

        // v1.0.4: 发售倒计时 HTML
        // 状态机:未发售(亮橙)/ 今日发售(amber 强调)/ 已发售(暗灰)/ 发售日期待定(null)
        // 参考 steam-friend-manager sfd-stress-featured-countdown / sfd-stress-featured-days
        function gotyCountdownHtml(dateStr) {
            const releaseDate = gotyDateToDate(dateStr);
            if (!releaseDate) return '';
            const now = new Date();
            // 抹掉当天时分秒,按"自然日"差计算（与 friend-manager parseStressDate 一致）
            const todayStart = new Date(now.getFullYear(), now.getMonth(), now.getDate());
            const relStart = new Date(releaseDate.getFullYear(), releaseDate.getMonth(), releaseDate.getDate());
            const daysLeft = Math.round((relStart - todayStart) / 86400000);
            if (daysLeft > 0) {
                return '<span class="sglv-goty-countdown sglv-goty-countdown--future" title="' + (Host.isZh ? '距离发售还有 ' : 'Releases in ') + daysLeft + (Host.isZh ? ' 天' : ' days') + '">'
                    + '<span class="sglv-goty-countdown-days">' + daysLeft + '</span>'
                    + '<span class="sglv-goty-countdown-lbl">' + (Host.isZh ? '天后发售' : 'days left') + '</span>'
                    + '</span>';
            }
            if (daysLeft === 0) {
                return '<span class="sglv-goty-countdown sglv-goty-countdown--today" title="' + (Host.isZh ? '今日发售' : 'Releases today') + '">'
                    + '<span class="sglv-goty-countdown-days">★</span>'
                    + '<span class="sglv-goty-countdown-lbl">' + (Host.isZh ? '今日发售' : 'today') + '</span>'
                    + '</span>';
            }
            // 已发售:仅显示"X 天前发售"作历史时间感（不强调）
            const ago = -daysLeft;
            return '<span class="sglv-goty-countdown sglv-goty-countdown--past" title="' + (Host.isZh ? '已发售 ' : 'Released ') + ago + (Host.isZh ? ' 天' : ' days ago') + '">'
                + '<span class="sglv-goty-countdown-days">' + ago + '</span>'
                + '<span class="sglv-goty-countdown-lbl">' + (Host.isZh ? '天前发售' : 'days ago') + '</span>'
                + '</span>';
        }

        // ==================== 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 容量上限
        // v2.9.3: 不再按条目 ts 判断是否有效，也不用 180 天容器 TTL（旧实现到期后
        //   cacheGet 会整表丢弃 → 所有 GOTY 封面同时重爬）。
        //   容器 TTL 拉长到 10 年，失效交给"用一次自愈（404 → 回退链）+ LRU 600 淘汰"。
        const GOTY_COVER_CONTAINER_TTL = 10 * 365 * 24 * 3600 * 1000; // 10 年（容器不过期）
        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 = {};
            let data = null;
            // v2.9.3: 直接读原始值（不经 cacheGet 的 expires 检查）——
            //   旧版本写的是 180 天容器 TTL，过期后 cacheGet 会整表清空；
            //   这里把内容完好的旧表恢复出来，并马上用 10 年 TTL 重写。
            try {
                if (typeof GM_getValue === 'function') {
                    const s = GM_getValue('sglv_cache_' + GOTY_COVER_CACHE_KEY, '');
                    if (s) {
                        const obj = JSON.parse(s);
                        if (obj && obj.data && typeof obj.data === 'object') data = obj.data;
                    }
                }
            } catch (e) { /* ignore */ }
            if (!data) {
                try {
                    const raw = Host.cacheGet(GOTY_COVER_CACHE_KEY);
                    if (raw && typeof raw === 'object') data = raw;
                } catch (e) { /* ignore */ }
            }
            if (!data) return;
            let n = 0;
            for (const k in data) {
                const ent = data[k];
                // 只收 http(s)（历史版本可能写入过 data: 占位图）
                if (ent && typeof ent.url === 'string' && /^https?:\/\//i.test(ent.url)) {
                    _gotyCoverPersisted[k] = ent;
                    _gotyCoverGood.set(k, ent.url);
                    n++;
                }
            }
            if (n) {
                // 立刻用长 TTL 重写，避免下一次读取又被整表过期
                try { Host.cacheSet(GOTY_COVER_CACHE_KEY, _gotyCoverPersisted, GOTY_COVER_CONTAINER_TTL); } catch (e) { /* ignore */ }
            }
        }

        function _gotyCoverRecordGood(appid, url, kind) {
            if (!appid || !url) return;
            // v2.9.2: 占位 data URI 绝不入持久缓存（否则下次渲染直接以占位图当封面）
            if (!/^https?:\/\//i.test(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_CONTAINER_TTL); } catch (e) { /* ignore */ }
            }, 80);
        }

        function _gotyCoverGetGood(appid, kind) {
            _gotyCoverLoadPersisted();
            const v = _gotyCoverGood.get(`${kind || 'poster'}:${appid}`) || '';
            // v2.9.2: 历史版本可能把 data: 占位图写进过缓存 —— 读到也当没有
            return /^https?:\/\//i.test(v) ? v : '';
        }

        // 生成年度大作封面 <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 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>';
        }

        // v2.9.8: 命中 TGA 年度游戏冠军的年度大作卡片 → 金色 👑 chip（点击开该年提名弹窗）
        function gotyTgaChipHtml(appid) {
            const info = _tgaState.index && _tgaState.index.byAppid[Number(appid)];
            if (!info) return '';
            return '<span class="sglv-goty-tga-chip" data-tga-chip="' + info.year + '" title="' + (Host.isZh ? 'TGA 年度游戏冠军 · ' + info.year + '（点击查看提名）' : 'TGA Game of the Year ' + info.year + ' (click for nominees)') + '">👑 ' + (Host.isZh ? '年度游戏' : 'GOTY') + '</span>';
        }

        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');
            }
            renderGotySections();
        }

        // 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; renderGotySections(); }

            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, 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);
        }


        // v2.x: "GotY 时光机" — 按游戏发售日期拆为"未发售 / 已发售"两组;
        //   搜索 + 拥有筛选 + 排序在整个游戏集上过滤,年份时间轴按显示/隐藏年份块
        function getGotyByYearAndSearch() {
            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));
            }
            if (gotyState.ownFilter === 'owned') list = list.filter(g => isOwned(g.appid));
            else if (gotyState.ownFilter === 'notOwned') list = list.filter(g => !isOwned(g.appid));
            // 默认 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 db.localeCompare(da) || (b.appid - a.appid);
                }
            });
            // 按 year 分组(已排序,空 year 跳过)
            const byYear = {};
            for (const g of list) {
                if (!g.year) continue;
                if (!byYear[g.year]) byYear[g.year] = [];
                byYear[g.year].push(g);
            }
            return byYear;
        }

        // v2.x: GotY 焦点大卡(未发售分组前 2 个,宽海报贴边 + 倒计时大数字)
        //   参考 steam-friend-manager 1.5.3 sfd-stress-featured-* (steam-friend-manager-1.5.3.js:11448)
        function renderGotyFeaturedCard(g) {
            const appid = g.appid;
            const ownedIds = Host.getActiveOwnedAppIds();
            const isOwned = ownedIds.has(appid) || ownedIds.has(String(appid));
            const releaseDate = gotyDateToDate(g.date);
            const now = new Date();
            let daysLeft = null;
            let state = 'future';
            if (releaseDate) {
                const todayStart = new Date(now.getFullYear(), now.getMonth(), now.getDate());
                const relStart = new Date(releaseDate.getFullYear(), releaseDate.getMonth(), releaseDate.getDate());
                const diff = Math.round((relStart - todayStart) / 86400000);
                if (diff > 0) { daysLeft = diff; state = 'future'; }
                else if (diff === 0) { daysLeft = 0; state = 'today'; }
                else { daysLeft = diff; state = 'past'; }
            }
            const cls = 'sglv-goty-featured' + (isOwned ? ' owned' : '');
            const badgeText = isOwned
                ? (state === 'past' ? (Host.isZh ? '已拥有' : 'Owned') : (Host.isZh ? '已预购' : 'Wishlisted'))
                : (state === 'future' ? (Host.isZh ? '即将发售' : 'Upcoming') : (state === 'today' ? (Host.isZh ? '今日发售' : 'Today') : (Host.isZh ? '未拥有' : 'Not Owned')));
            const daysText = daysLeft == null ? '—' : (state === 'past' ? '−' + Math.abs(daysLeft) : String(daysLeft));
            const daysLbl = daysLeft == null ? (Host.isZh ? '待定' : 'TBD') : (state === 'future' ? (Host.isZh ? '天后' : 'd') : (state === 'today' ? (Host.isZh ? '今天' : 'today') : (Host.isZh ? '天前' : 'd ago')));
            const clickUrl = 'https://store.steampowered.com/app/' + appid;
            const posterHtml = gotyCoverImgTag(appid, g.name, 'capsule', 'sglv-goty-featured-poster');
            return '<div class="' + cls + '" data-appid="' + appid + '" onclick="window.open(\'' + clickUrl + '\',\'_blank\')">' +
                posterHtml +
                '<div class="sglv-goty-featured-info">' +
                    '<span class="sglv-goty-featured-badge">' + badgeText + '</span>' +
                    '<div class="sglv-goty-featured-name" title="' + Host.wlEscape(g.name) + '">' + Host.wlEscape(g.name) + '</div>' +
                    '<div class="sglv-goty-featured-date">' + Host.wlEscape(gotyDateFull(g.date)) + '</div>' +
                '</div>' +
                '<div class="sglv-goty-featured-countdown">' +
                    '<div class="sglv-goty-featured-days">' + daysText + '</div>' +
                    '<div class="sglv-goty-featured-days-lbl">' + daysLbl + '</div>' +
                '</div>' +
            '</div>';
        }

        // v2.x: GotY 网格卡片(card 视图: 竖版海报 + 名称 + 拥有 + 倒计时)
        /** 年度大片「大海报」卡片 —— v2.9.0
         *  此前 cover 视图与 card 视图共用 renderGotyGridCard + .sglv-goty-grid，
         *  渲染结果完全一致 → 用户点「大海报」按钮视觉零变化，表现为"切换没效果"。
         *  这里给 cover 视图独立的渲染路径：横向宽海报（.sglv-goty-cover-card），
         *  封面用 unifiedCover 的 capsule 链铺满，标题与元信息叠在封面下半部分。
         */
        function renderGotyCoverCard(g) {
            const appid = g.appid;
            const ownedIds = Host.getActiveOwnedAppIds();
            const isOwned = ownedIds.has(appid) || ownedIds.has(String(appid));
            const releaseDate = gotyDateToDate(g.date);
            const now = new Date();
            let countdownHtml = '';
            let countdownCls = '';
            if (releaseDate) {
                const todayStart = new Date(now.getFullYear(), now.getMonth(), now.getDate());
                const relStart = new Date(releaseDate.getFullYear(), releaseDate.getMonth(), releaseDate.getDate());
                const diff = Math.round((relStart - todayStart) / 86400000);
                if (diff > 0) { countdownHtml = '<span class="sglv-goty-cover-countdown">' + (Host.isZh ? '还有 ' + diff + ' 天' : diff + 'd') + '</span>'; countdownCls = ' future'; }
                else if (diff === 0) { countdownHtml = '<span class="sglv-goty-cover-countdown">' + (Host.isZh ? '今日发售' : 'Today') + '</span>'; countdownCls = ' today'; }
                else if (diff > -60) { countdownHtml = '<span class="sglv-goty-cover-countdown">' + (Host.isZh ? Math.abs(diff) + ' 天前' : Math.abs(diff) + 'd ago') + '</span>'; countdownCls = ' past'; }
            }
            const clickUrl = 'https://store.steampowered.com/app/' + appid;
            return '<div class="sglv-goty-cover-card' + (isOwned ? ' is-owned' : '') + '" data-appid="' + appid + '"' +
                ' onclick="window.open(\'' + clickUrl + '\',\'_blank\')" title="' + Host.wlEscape(g.name) + '">' +
                '<div class="sglv-goty-cover-img-wrap">' +
                    unifiedCover(appid, g.name, 'capsule', { imgCls: 'sglv-goty-cover-img' }) +
                    '<div class="sglv-goty-cover-grad"></div>' +
                    '<div class="sglv-goty-cover-overlay">' +
                        '<div class="sglv-goty-cover-title">' + Host.wlEscape(g.name) + '</div>' +
                        '<div class="sglv-goty-cover-meta">' +
                            (isOwned
                                ? '<span class="sglv-goty-cover-owned">\u2713 ' + (Host.isZh ? '在库' : 'Owned') + '</span>'
                                : '<span class="sglv-goty-cover-not-owned">' + (Host.isZh ? '未拥有' : 'Not Owned') + '</span>') +
                            countdownHtml +
                            gotyTgaChipHtml(appid) +
                        '</div>' +
                    '</div>' +
                '</div>' +
            '</div>';
        }

        function renderGotyGridCard(g) {
            const appid = g.appid;
            const ownedIds = Host.getActiveOwnedAppIds();
            const isOwned = ownedIds.has(appid) || ownedIds.has(String(appid));
            const releaseDate = gotyDateToDate(g.date);
            const now = new Date();
            let countdownHtml = '';
            if (releaseDate) {
                const todayStart = new Date(now.getFullYear(), now.getMonth(), now.getDate());
                const relStart = new Date(releaseDate.getFullYear(), releaseDate.getMonth(), releaseDate.getDate());
                const diff = Math.round((relStart - todayStart) / 86400000);
                if (diff > 0) countdownHtml = '<span class="sglv-goty-card-countdown future">还有 ' + diff + ' 天</span>';
                else if (diff === 0) countdownHtml = '<span class="sglv-goty-card-countdown today">今日发售</span>';
                else if (diff > -60) countdownHtml = '<span class="sglv-goty-card-countdown past">' + Math.abs(diff) + ' 天前</span>';
            }
            const ownedHtml = isOwned
                ? '<span class="sglv-goty-card-owned">✓ ' + (Host.isZh ? '在库' : 'Owned') + '</span>'
                : '<span class="sglv-goty-card-not-owned">' + (Host.isZh ? '未拥有' : 'Not Owned') + '</span>';
            const clickUrl = 'https://store.steampowered.com/app/' + appid;
            return '<div class="sglv-goty-card" data-appid="' + appid + '" onclick="window.open(\'' + clickUrl + '\',\'_blank\')" title="' + Host.wlEscape(g.name) + '">' +
                '<div class="sglv-goty-card-img-wrap">' + gotyCoverImgTag(appid, g.name, 'poster', 'sglv-goty-card-img') + gotyBadgeHtml() + '</div>' +
                '<div class="sglv-goty-card-body">' +
                    '<div class="sglv-goty-card-name">' + Host.wlEscape(g.name) + '</div>' +
                    '<div class="sglv-goty-card-meta">' + ownedHtml + countdownHtml + gotyTgaChipHtml(appid) + '</div>' +
                '</div>' +
            '</div>';
        }

        // v2.x: GotY 列表行项
        function renderGotyListItem(g) {
            const appid = g.appid;
            const ownedIds = Host.getActiveOwnedAppIds();
            const isOwned = ownedIds.has(appid) || ownedIds.has(String(appid));
            const ownedHtml = gotyOwnedBadgeHtml(isOwned);
            const dateHtml = g.date
                ? '<span class="sglv-goty-date"><span class="sglv-goty-clock">' + Host.ICONS.clock + '</span>' + Host.wlEscape(gotyDateFull(g.date)) + gotyCountdownHtml(g.date) + '</span>'
                : '';
            const clickUrl = 'https://store.steampowered.com/app/' + appid;
            return '<div class="sglv-goty-list-item" data-appid="' + appid + '" onclick="window.open(\'' + clickUrl + '\',\'_blank\')">' +
                gotyCoverImgTag(appid, g.name, 'header', 'sglv-goty-list-icon') +
                '<div class="sglv-goty-list-info">' +
                    '<div class="sglv-goty-list-name">' + Host.wlEscape(g.name) + ' <span class="sglv-card-id-inline">' + appid + '</span></div>' +
                    '<div class="sglv-goty-list-meta">' + gotyBadgeHtml() + ' ' + ownedHtml + ' ' + dateHtml + ' ' + gotyTgaChipHtml(appid) + '</div>' +
                '</div>' +
            '</div>';
        }

        // v2.x: 单个分组(未发售 / 已发售)HTML
        //   sticky header(可点击折叠) + 焦点卡(0-2 个, 仅未发售组有) + 网格 5 列
        function renderGotyGroup(year, title, groupGames, isUnreleased) {
            const ownedIds = Host.getActiveOwnedAppIds();
            const isOwned = n => ownedIds.has(n) || ownedIds.has(String(n));
            const ownedCount = groupGames.filter(g => isOwned(g.appid)).length;
            const total = groupGames.length;
            const pct = total > 0 ? Math.round(ownedCount / total * 100) : 0;
            const groupKey = year + ':' + (isUnreleased ? 'unreleased' : 'released');
            const collapsed = gotyState.expandedYears && gotyState.expandedYears.has('collapsed:' + groupKey);
            const headerCls = 'sglv-goty-group-header' + (collapsed ? ' sglv-goty-group-collapsed' : '');
            const bodyCls = 'sglv-goty-group-body';
            let body = '';
            // 焦点卡: 仅未发售组 + >=1 款时,前 2 个
            if (isUnreleased && groupGames.length >= 1) {
                const featured = groupGames.slice(0, 2);
                const rest = groupGames.slice(2);
                body += '<div class="sglv-goty-featured-wrap">' + featured.map(renderGotyFeaturedCard).join('') + '</div>';
                if (rest.length > 0) {
                    body += (gotyState.viewMode === 'cover')
                        ? '<div class="sglv-goty-cover-grid">' + rest.map(renderGotyCoverCard).join('') + '</div>'
                        : '<div class="sglv-goty-grid">' + rest.map(renderGotyGridCard).join('') + '</div>';
                }
            } else if (gotyState.viewMode === 'cover') {
                // v2.9.0: cover 视图改为独立的横向宽海报卡（此前与 card 视图渲染完全一致，切换无视觉变化）
                body += '<div class="sglv-goty-cover-grid">' + groupGames.map(renderGotyCoverCard).join('') + '</div>';
            } else if (gotyState.viewMode === 'list') {
                body += '<div class="sglv-goty-list-view">' + groupGames.map(renderGotyListItem).join('') + '</div>';
            } else {
                body += '<div class="sglv-goty-grid">' + groupGames.map(renderGotyGridCard).join('') + '</div>';
            }
            const titleHtml = (isUnreleased ? '🕐 ' : '✓ ') + title;
            return '<div class="sglv-goty-group" data-group-key="' + groupKey + '">' +
                '<div class="' + headerCls + '" data-toggle-group="' + groupKey + '">' +
                    '<span class="sglv-goty-group-caret"></span>' +
                    '<span class="sglv-goty-group-title">' + titleHtml + '</span>' +
                    '<span class="sglv-goty-group-count">' + ownedCount + ' / ' + total + (Host.isZh ? ' 已拥有' : ' owned') + '</span>' +
                    '<div class="sglv-goty-group-bar"><div class="sglv-goty-group-bar-fill" style="width:' + pct + '%"></div></div>' +
                    '<span class="sglv-goty-group-pct">' + pct + '%</span>' +
                '</div>' +
                '<div class="' + bodyCls + '">' + body + '</div>' +
            '</div>';
        }

        // v2.x: 单个年份分块(包含"未发售" + "已发售"两个子分组)
        //   按当前日期切分; 时间轴节点 active = 当前 visible 年份
        function renderGotyYearBlock(year, games) {
            const now = new Date();
            const nowYear = now.getFullYear();
            const nowMonth = now.getMonth();
            const nowDay = now.getDate();
            // 按"未发售" / "已发售"切分
            const unreleased = [];
            const released = [];
            games.forEach(g => {
                const d = gotyDateToDate(g.date);
                if (!d) {
                    // 无日期: 视作已发售(展示)
                    released.push(g);
                    return;
                }
                const isFuture = d.getFullYear() > nowYear
                    || (d.getFullYear() === nowYear && (d.getMonth() > nowMonth
                        || (d.getMonth() === nowMonth && d.getDate() > nowDay)));
                if (isFuture) unreleased.push(g);
                else released.push(g);
            });
            // 未发售组: 按日期升序(最近的发售在前)
            unreleased.sort((a, b) => gotyDateToSortable(a.date).localeCompare(gotyDateToSortable(b.date)));
            // 已发售组: 按日期降序
            released.sort((a, b) => gotyDateToSortable(b.date).localeCompare(gotyDateToSortable(a.date)));

            const unreleasedTitle = (Host.isZh ? '即将发售' : 'Upcoming');
            const releasedTitle = (Host.isZh ? '已发售' : 'Released');
            let html = '<div class="sglv-goty-year-block" data-year="' + year + '">';
            if (unreleased.length > 0) html += renderGotyGroup(year, year + ' · ' + unreleasedTitle, unreleased, true);
            if (released.length > 0) html += renderGotyGroup(year, year + ' · ' + releasedTitle, released, false);
            html += '</div>';
            return html;
        }

        // v2.x: GotY 标签页(主入口)
        function renderGotyTab(parent) {
            const wrap = document.createElement('div');
            wrap.className = 'sglv-psplus-wrap sglv-goty-wrap';
            wrap.style.cssText = 'display:flex;flex-direction:column;height:100%;min-height:0;';

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

            // 年份时间轴(横向滚动)
            const timeline = document.createElement('div');
            timeline.id = 'sglv-goty-timeline';
            timeline.className = 'sglv-goty-timeline';
            wrap.appendChild(timeline);

            // 工具条(搜索 + 排序 + 视图 + 刷新)
            const toolbar = document.createElement('div');
            toolbar.className = 'sglv-goty-toolbar-row';
            const sortOptions = [
                { key: 'dateDesc', label: Host.T.gotySortDateDesc },
                { 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>';
            wrap.appendChild(toolbar);

            // 滚动区(年份分块)
            const scroll = document.createElement('div');
            scroll.id = 'sglv-goty-scroll';
            scroll.className = 'sglv-goty-scroll';
            wrap.appendChild(scroll);

            parent.appendChild(wrap);

            // ---- 事件 ----
            toolbar.querySelector('#sglv-goty-search').addEventListener('input', _debounce(e => {
                gotyState.search = e.target.value;
                renderGotySections();
            }, 200));
            toolbar.querySelector('#sglv-goty-sort').addEventListener('change', e => {
                gotyState.sort = e.target.value;
                renderGotySections();
            });
            const setView = m => {
                gotyState.viewMode = m;
                ['card', 'cover', 'list'].forEach(x => toolbar.querySelector('#sglv-goty-' + x)?.classList.toggle('active', x === m));
                renderGotySections();
            };
            toolbar.querySelector('#sglv-goty-card').addEventListener('click', () => setView('card'));
            toolbar.querySelector('#sglv-goty-cover').addEventListener('click', () => setView('cover'));
            toolbar.querySelector('#sglv-goty-list').addEventListener('click', () => setView('list'));
            // v2.9.8: 刷新同时强拉 TGA 冠军数据（殿堂 + 👑 chip）
            toolbar.querySelector('#sglv-goty-refresh').addEventListener('click', () => { loadGotyGames(true); loadTgaWinners(true); });

            // 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;
                renderGotyKpi();
                renderGotySections();
            });

            // v2.9.6: 时间轴节点点击 = 切换年份筛选（真筛选，不再滚动定位）
            //   点击年份 → 只显示该年份分块；再次点击同一年份或点「全部」→ 回到全部。
            //   （disabled 节点为原生 button，不会派发 click，无需额外判断）
            timeline.addEventListener('click', e => {
                const node = e.target.closest('.sglv-goty-tl-node');
                if (!node) return;
                // v2.9.8: 金色「年度游戏」节点 → 切换 TGA 殿堂视图（与年份筛选互斥）
                if (node.dataset.tgaView) {
                    gotyState.tgaView = !gotyState.tgaView;
                    if (gotyState.tgaView) gotyState.yearFilter = null;
                    renderGotySections();
                    return;
                }
                gotyState.tgaView = false;
                const year = node.dataset.year;
                const y = (year === 'all' || year == null) ? null : parseInt(year, 10);
                gotyState.yearFilter = (gotyState.yearFilter === y) ? null : y;
                renderGotySections();
            });

            // 分组折叠切换 + v2.9.8 TGA 殿堂冠军卡点击 → 开该年提名弹窗
            scroll.addEventListener('click', e => {
                const cell = e.target.closest('[data-tga-cell]');
                if (cell) { const yr = parseInt(cell.dataset.tgaCell, 10); if (yr) openTgaNomsModal(yr); return; }
                const header = e.target.closest('[data-toggle-group]');
                if (!header) return;
                const key = header.dataset.toggleGroup;
                const fullKey = 'collapsed:' + key;
                if (!gotyState.expandedYears) gotyState.expandedYears = new Set();
                if (gotyState.expandedYears.has(fullKey)) {
                    gotyState.expandedYears.delete(fullKey);
                } else {
                    gotyState.expandedYears.add(fullKey);
                }
                // 只重渲染该分组
                const groupEl = header.parentElement;
                const year = groupEl.dataset.groupKey.split(':')[0];
                const gamesArr = getGotyByYearAndSearch()[+year] || [];
                const now = new Date();
                const nowY = now.getFullYear(), nowM = now.getMonth(), nowD = now.getDate();
                const isUnr = key.endsWith(':unreleased');
                const filtered = isUnr ? gamesArr.filter(g => {
                    const d = gotyDateToDate(g.date);
                    if (!d) return false;
                    return d.getFullYear() > nowY || (d.getFullYear() === nowY && (d.getMonth() > nowM || (d.getMonth() === nowM && d.getDate() > nowD)));
                }) : gamesArr.filter(g => {
                    const d = gotyDateToDate(g.date);
                    if (!d) return true;
                    return !(d.getFullYear() > nowY || (d.getFullYear() === nowY && (d.getMonth() > nowM || (d.getMonth() === nowM && d.getDate() > nowD))));
                });
                // 简单做法: 整个 scroll 重渲染(分组小,开销可接受)
                renderGotySections();
            });

            // 滚动监听: 时间轴 active 跟随（v2.9.6: 年份筛选锁定时不跟随，active 由筛选态决定）
            scroll.addEventListener('scroll', () => {
                if (gotyState.yearFilter != null || gotyState.tgaView) return;
                const blocks = scroll.querySelectorAll('.sglv-goty-year-block');
                let current = null;
                blocks.forEach(b => {
                    const r = b.getBoundingClientRect();
                    const scrollTop = scroll.getBoundingClientRect().top;
                    if (r.top - scrollTop <= 80) current = b.dataset.year;
                });
                timeline.querySelectorAll('.sglv-goty-tl-node').forEach(n => {
                    n.classList.toggle('sglv-goty-tl-active', n.dataset.year === String(current || 'all'));
                });
            });

            // v2.9.8: 年度大作卡片上的金色 👑 年度游戏 chip —— capture 阶段拦截点击开提名弹窗，
            //   stopPropagation 阻止冒泡到卡片自身的 inline onclick（开商店页）
            scroll.addEventListener('click', e => {
                const chip = e.target.closest('[data-tga-chip]');
                if (!chip) return;
                e.preventDefault();
                e.stopPropagation();
                const yr = parseInt(chip.dataset.tgaChip, 10);
                if (yr) openTgaNomsModal(yr);
            }, true);

            // 首次进入:加载数据 or 已加载则直接渲染
            // v2.9.0: 绑定已移入 renderGotyScroll() —— 年度大片的视图切换/排序/年份筛选
            // 都走 renderGotySections → renderGotyScroll 重渲染内容，
            // 绑定放在 renderGotyTab 里会早于内容生成执行（等于绑定空容器），
            // 导致「切视图后新卡片封面不加载」。
            if (!gotyState.loaded && !gotyState.loading) {
                loadGotyGames();
            } else {
                renderGotySections();
            }
            // v2.9.8: 预载 TGA 冠军索引（缓存命中同步重渲染补 👑 chip；未命中后台拉取，供殿堂视图）
            loadTgaWinners();
        }

        // v2.x: 重建时间轴 + scroll 区
        function renderGotySections() {
            if (_collectionActiveTab !== 'goty' || !document.getElementById('sglv-goty-scroll')) return;
            renderGotyKpi();
            renderGotyTimeline();
            renderGotyScroll();
            // v2.9.0: 内容渲染完成后再绑定封面链（每次重渲染都要重新绑定新生成的 wrapper）
            bindRestrictedCoverLoaders(document.getElementById('sglv-goty-scroll'));
        }

        // v2.x: 顶部 3 KPI(全部 / 已拥有 / 未拥有,clickable 切换 ownFilter)
        function renderGotyKpi() {
            const el = document.getElementById('sglv-goty-kpi');
            if (!el) return;
            if (!gotyState.loaded) { el.innerHTML = ''; return; }
            const ownedIds = Host.getActiveOwnedAppIds();
            const isOwned = n => ownedIds.has(n) || ownedIds.has(String(n));
            const total = gotyState.games.length;
            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-goty-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>';
        }

        // v2.x: 年份时间轴(渐变主线 + 发光年份节点,首节点 "全部")
        function renderGotyTimeline() {
            const el = document.getElementById('sglv-goty-timeline');
            if (!el) return;
            if (!gotyState.loaded) { el.innerHTML = ''; return; }
            // 收集各年游戏数(在当前 search/filter/sort 之后)
            const byYear = getGotyByYearAndSearch();
            const yearStats = (gotyState.availableYears || []).slice().sort((a, b) => b - a).map(y => ({
                year: y,
                count: (byYear[y] || []).length,
            }));
            // 总数(全部)
            const totalCount = Object.values(byYear).reduce((s, arr) => s + arr.length, 0);
            // v2.9.6: active 由 yearFilter 决定（不再依赖滚动位置）——「全部」仅在未筛选时点亮
            // v2.9.8: 殿堂视图(tgaView)开启时「全部」不点亮，改点亮金色「年度游戏」节点
            const isAllActive = !gotyState.tgaView && gotyState.yearFilter == null && !gotyState.search && gotyState.ownFilter === 'all';
            let html = '<div class="sglv-goty-tl-line"></div>' +
                '<button type="button" class="sglv-goty-tl-node sglv-goty-tl-goty' + (gotyState.tgaView ? ' sglv-goty-tl-active' : '') + '" data-tga-view="1" title="' + (Host.isZh ? 'TGA 年度游戏殿堂（历届冠军）' : 'TGA Game of the Year Hall') + '">' +
                    '<span class="sglv-goty-tl-dot"></span>' +
                    '<span class="sglv-goty-tl-year">' + (Host.isZh ? '年度游戏' : 'GOTY') + '</span>' +
                    '<span class="sglv-goty-tl-count">' + (Host.isZh ? '殿堂' : 'Hall') + '</span>' +
                '</button>' +
                '<button type="button" class="sglv-goty-tl-node' + (isAllActive ? ' sglv-goty-tl-active' : '') + '" data-year="all" title="' + (Host.isZh ? '全部年度' : 'All Years') + '">' +
                    '<span class="sglv-goty-tl-dot"></span>' +
                    '<span class="sglv-goty-tl-year">' + (Host.isZh ? '全部' : 'All') + '</span>' +
                    '<span class="sglv-goty-tl-count">' + totalCount + '</span>' +
                '</button>';
            yearStats.forEach(s => {
                // v2.9.6: 当前搜索/筛选下该年 0 条 → 禁用点击（灰显，避免"点了没反应"）
                const empty = s.count === 0;
                const active = gotyState.yearFilter === s.year;
                const title = empty
                    ? (Host.isZh ? '该年度暂无匹配游戏' : 'No matching games in ' + s.year)
                    : (Host.isZh ? (active ? '取消筛选，显示全部年度' : '只看 ' + s.year + ' 年游戏') : (active ? 'Clear year filter' : 'Show only ' + s.year + ' games'));
                html += '<button type="button" class="sglv-goty-tl-node' + (active ? ' sglv-goty-tl-active' : '') + '"' +
                    (empty ? ' disabled' : ' data-year="' + s.year + '"') +
                    ' title="' + title + '">' +
                    '<span class="sglv-goty-tl-dot"></span>' +
                    '<span class="sglv-goty-tl-year">' + s.year + '</span>' +
                    '<span class="sglv-goty-tl-count">' + s.count + '</span>' +
                '</button>';
            });
            el.innerHTML = html;
        }

        // v2.x: scroll 区(所有年份分块)
        function renderGotyScroll() {
            const el = document.getElementById('sglv-goty-scroll');
            if (!el) return;
            // v2.9.8: TGA 年度游戏殿堂视图（时间轴金色节点开启时优先渲染，覆盖常规年份分块）
            if (gotyState.tgaView) { renderTgaHall(el); return; }
            if (gotyState.loading) {
                el.innerHTML = '<div class="sglv-progress" style="margin:16px 0"><div class="sglv-progress-fill" style="width:45%"></div></div><div class="sglv-goty-empty">' + Host.T.gotyLoading + '</div>';
                return;
            }
            if (gotyState.loadError && gotyState.games.length === 0) {
                el.innerHTML = '<div class="sglv-goty-empty">' + Host.T.gotyLoadError + '</div>';
                return;
            }
            if (!gotyState.loaded || gotyState.games.length === 0) {
                el.innerHTML = '<div class="sglv-goty-empty">' + Host.T.gotyNoData + '</div>';
                return;
            }
            const byYear = getGotyByYearAndSearch();
            let yearKeys = Object.keys(byYear).map(Number).filter(y => byYear[y].length > 0).sort((a, b) => b - a);
            // v2.9.6: 年份筛选 —— 时间轴选中某年时只渲染该年份分块
            if (gotyState.yearFilter != null) yearKeys = yearKeys.filter(y => y === gotyState.yearFilter);
            if (yearKeys.length === 0) {
                el.innerHTML = '<div class="sglv-goty-empty">' + (gotyState.yearFilter != null
                    ? (Host.isZh ? '该年度暂无匹配游戏' : 'No matching games in this year')
                    : (Host.isZh ? '无匹配结果' : 'No matching results')) + '</div>';
                return;
            }
            _bindGotyCoverDelegation(el);
            let html = '';
            yearKeys.forEach(y => { html += renderGotyYearBlock(y, byYear[y]); });
            el.innerHTML = html;
            // v2.9.6: 重渲染后回到顶部（避免残留上次滚动位置造成"顶部空白"观感）
            el.scrollTop = 0;
        }

        // ==================== v2.9.8: TGA 年度游戏殿堂（参考 steam-friend-manager 1.6.2）====================
        // 数据源 SmallFork/json TGA_winners.json：
        //   { _meta:{categories:{goty:'年度游戏',…}}, years:[{year, games:[{awards, appid, name, url?, nominees:[{appid,name,url?}]}]}] }
        //   appid=number → Steam 游戏；appid=string → 非 Steam 平台独占（"任天堂独占"/"PlayStation 独占"/…）
        //   awards==='goty' 标记当年年度游戏冠军；同名游戏同年多条获奖记录 → 皇冠数=当年获奖次数
        const TGA_WINNERS_SOURCES = [
            'https://fastly.jsdelivr.net/gh/SmallFork/json@main/TGA_winners.json',   // ① fastly（优先，国内稳定）
            'https://cdn.jsdelivr.net/gh/SmallFork/json@main/TGA_winners.json',      // ② jsdelivr 主节点
            'https://raw.githubusercontent.com/SmallFork/json/main/TGA_winners.json',// ③ raw 兜底
        ];
        const _TGA_BG_INTERVAL = 24 * 3600 * 1000;   // TGA 历史数据几乎不变，24h 后台刷新足够
        let _tgaLastBgRefreshAt = 0;
        const _tgaState = { data: null, index: null, loaded: false, loading: false, loadError: null, updatedAt: '', source: '', lastFetchAt: 0 };

        // 非 Steam 平台占位画配置（appid 字符串即平台名；平台主色 + 内联 SVG 图标，取自 friend-manager）
        const TGA_PLATFORMS = {
            '任天堂独占': { color: '#ff6b6b', icon: '<rect x="2.5" y="3.5" width="8" height="17" rx="4"/><rect x="13.5" y="3.5" width="8" height="17" rx="4"/><circle cx="6.5" cy="8.5" r="1.5"/><circle cx="17.5" cy="16" r="1.5"/>' },
            'PlayStation 独占': { color: '#5b9cf8', icon: '<path d="M7.5 4.8l3.2 5.4H4.3z"/><circle cx="16.5" cy="7.5" r="2.5"/><path d="M5.2 14l4.6 4.6M9.8 14l-4.6 4.6"/><rect x="14.4" y="14.2" width="4.4" height="4.4" rx=".7"/>' },
            'Xbox/微软商店': { color: '#4ade80', icon: '<circle cx="12" cy="12" r="8.2"/><path d="M6.6 6.4c3 2.6 7.8 7.4 10.8 11M17.4 6.4c-3 2.6-7.8 7.4-10.8 11"/>' },
            '暴雪战网': { color: '#38bdf8', icon: '<path d="M12 3.2a8.8 8.8 0 1 0 8.8 8.8"/><path d="M12 6.6a5.4 5.4 0 1 1-5.4 5.4"/><path d="M12 10a2 2 0 1 0 2 2"/>' },
            'Epic 独占': { color: '#cbd5e1', icon: '<path d="M12 3l7.5 2.6v6.2c0 4.6-3.5 7.6-7.5 8.7-4-1.1-7.5-4.1-7.5-8.7V5.6z"/><path d="M9.4 8.6h5.2M9.4 12h4.2M9.4 15.4h5.2"/>' },
            '手机游戏': { color: '#34d399', icon: '<rect x="7" y="2.6" width="10" height="18.8" rx="2.4"/><path d="M10.5 5.6h3"/>' },
            'VR 独占': { color: '#a78bfa', icon: '<path d="M3.2 8.4a2.6 2.6 0 0 1 2.6-2.6h12.4a2.6 2.6 0 0 1 2.6 2.6v4.2a2.6 2.6 0 0 1-2.6 2.6h-2.6L12 18.4l-3.6-3.2H5.8a2.6 2.6 0 0 1-2.6-2.6z"/>' },
        };
        const TGA_PLATFORM_FALLBACK = { color: '#66c0f4', icon: '<rect x="2.4" y="7" width="19.2" height="9.4" rx="2.4"/><path d="M7 9.6v4.2M4.9 11.7h4.2"/><circle cx="16.6" cy="10.6" r="1"/><circle cx="18.6" cy="12.8" r="1"/>' };
        const TGA_CROWN_SVG = '<svg viewBox="0 0 24 24" fill="currentColor"><path d="M2.8 7l4.7 3.4L12 4.5l4.5 5.9L21.2 7l-1.5 9.5a1.6 1.6 0 0 1-1.6 1.4H5.9a1.6 1.6 0 0 1-1.6-1.4z"/><rect x="5.2" y="19.3" width="13.6" height="1.8" rx="0.9"/></svg>';

        // 纯函数：TGA 原始数据 → 冠军索引（无副作用，供单测）
        //   byYear[year] = { year, winner, count(当年获奖次数), nominees[] }；byAppid[steamAppid] = { year, count }
        //   years = 有 GOTY 冠军的年份倒序；cats = 奖项 key→中文名映射
        function tgaBuildWinnerIndex(data) {
            const idx = { byYear: {}, byAppid: {}, years: [], cats: (data && data._meta && data._meta.categories) || {} };
            const years = (data && Array.isArray(data.years)) ? data.years : [];
            years.forEach(y => {
                if (!y || y.year == null || !Array.isArray(y.games)) return;
                const yr = Number(y.year);
                if (!yr) return;
                const winner = y.games.find(g => g && g.awards === 'goty');
                if (!winner) return;
                const count = Math.max(1, y.games.filter(g => g && g.name === winner.name).length);
                idx.byYear[yr] = { year: yr, winner: winner, count: count, nominees: Array.isArray(winner.nominees) ? winner.nominees : [] };
                idx.years.push(yr);
                if (typeof winner.appid === 'number') idx.byAppid[winner.appid] = { year: yr, count: count };
            });
            idx.years.sort((a, b) => b - a);
            return idx;
        }

        function tgaOwned(appid) {
            try {
                const ids = Host.getActiveOwnedAppIds();
                return !!(ids && (ids.has(appid) || ids.has(String(appid))));
            } catch (e) { return false; }
        }
        function tgaPlatform(type) { return TGA_PLATFORMS[String(type)] || TGA_PLATFORM_FALLBACK; }
        function tgaOpenStore(appid) {
            try { window.open('https://store.steampowered.com/app/' + appid, '_blank'); } catch (e) { /* ignore */ }
        }
        function tgaOwnedChipHtml(owned) {
            return owned
                ? '<span class="sglv-tga-tag owned">✓ ' + (Host.isZh ? '在库' : 'Owned') + '</span>'
                : '<span class="sglv-tga-tag">' + (Host.isZh ? '未拥有' : 'Not owned') + '</span>';
        }
        function tgaExclTypeHtml(type) {
            return '<span class="sglv-tga-excl-type" style="color:' + tgaPlatform(type).color + '">' + Host.wlEscape(String(type)) + '</span>';
        }
        // 非 Steam 平台占位画（vertical=true 竖版省略平台名）；有商店图(game.url)则叠加海报层（失败自动移除）
        function tgaExclArtHtml(game, vertical) {
            const type = String(game.appid);
            const p = tgaPlatform(type);
            let html = '<div class="sglv-tga-excl-art" style="color:' + p.color + '">'
                + '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.6" stroke-linecap="round" stroke-linejoin="round">' + p.icon + '</svg>'
                + (vertical ? '' : '<div class="sglv-tga-excl-name">' + Host.wlEscape(type) + '</div>')
                + '<div class="sglv-tga-excl-hint">' + (Host.isZh ? '封面待补充' : 'No cover yet') + '</div>'
                + '</div>';
            if (game.url) html += '<img class="sglv-tga-excl-img" src="' + Host.wlEscape(game.url) + '" loading="lazy" decoding="async" alt="" referrerpolicy="no-referrer">';
            return html;
        }
        function tgaBindExclImgs(root) {
            if (!root || !root.querySelectorAll) return;
            root.querySelectorAll('.sglv-tga-excl-img').forEach(img => img.addEventListener('error', () => img.remove(), { once: true }));
        }
        // 皇冠（数量=当年获奖次数，最多显示 3 顶，超出以 ×N 标注）
        function tgaCrownHtml(count) {
            const n = Math.max(1, count || 1);
            const shown = TGA_CROWN_SVG.repeat(Math.min(3, n));
            return '<div class="sglv-tga-crown' + (n > 1 ? ' multi' : '') + '" title="' + (Host.isZh ? '当年获 ' + n + ' 项奖' : n + ' awards that year') + '">' + shown + (n > 3 ? '<span>×' + n + '</span>' : '') + '</div>';
        }

        // 殿堂单卡：竖版海报 + 金色年份徽标 + 皇冠 + 名称 + 在库/平台标记（点击开该年提名弹窗）
        function tgaHallCellHtml(info) {
            const w = info.winner, year = info.year;
            const isSteam = typeof w.appid === 'number';
            const owned = isSteam ? tgaOwned(w.appid) : false;
            const cls = 'sglv-tga-cell' + (isSteam ? (owned ? ' owned' : ' not-owned') : ' excl');
            const poster = '<div class="sglv-tga-poster">' + (isSteam
                ? gotyCoverImgTag(w.appid, w.name, 'poster', 'sglv-tga-poster-img')
                : tgaExclArtHtml(w, true)) + '</div>';
            const ownChip = isSteam ? tgaOwnedChipHtml(owned) : tgaExclTypeHtml(w.appid);
            return '<div class="' + cls + '" data-tga-cell="' + year + '" title="' + Host.wlEscape(w.name) + ' · ' + year + '">'
                + poster
                + '<div class="sglv-tga-year-badge">' + year + '</div>'
                + tgaCrownHtml(info.count)
                + '<div class="sglv-tga-cell-info"><div class="sglv-tga-cell-name">' + Host.wlEscape(w.name) + '</div>' + ownChip + '</div>'
                + '</div>';
        }

        // 殿堂视图（hero + 历届冠军墙）；数据未就绪时触发加载并显示占位
        function renderTgaHall(el) {
            const loadingHtml = '<div class="sglv-progress" style="margin:16px 0"><div class="sglv-progress-fill" style="width:45%"></div></div><div class="sglv-goty-empty">' + (Host.isZh ? '正在获取 TGA 年度游戏数据…' : 'Loading TGA data…') + '</div>';
            if (_tgaState.loading) { el.innerHTML = loadingHtml; return; }
            if (!_tgaState.loaded || !_tgaState.index || !_tgaState.index.years.length) {
                if (_tgaState.loadError) {
                    el.innerHTML = '<div class="sglv-goty-empty">' + (Host.isZh ? 'TGA 数据获取失败，请点击右上角刷新重试' : 'Failed to load TGA data, click refresh to retry') + '</div>';
                    return;
                }
                el.innerHTML = loadingHtml;
                loadTgaWinners();
                return;
            }
            const idx = _tgaState.index;
            _bindGotyCoverDelegation(el);
            const cells = idx.years.map(y => tgaHallCellHtml(idx.byYear[y])).join('');
            const newest = idx.years[0], oldest = idx.years[idx.years.length - 1];
            el.innerHTML = '<div class="sglv-tga-hall">'
                + '<div class="sglv-tga-hero">'
                    + '<span class="sglv-tga-hero-icon">' + Host.ICONS.trophy + '</span>'
                    + '<div class="sglv-tga-hero-txt"><div class="sglv-tga-hero-title">' + (Host.isZh ? '年度游戏殿堂' : 'Game of the Year Hall') + '</div>'
                    + '<div class="sglv-tga-hero-sub">TGA · GAME OF THE YEAR</div></div>'
                    + '<span class="sglv-tga-hero-count">' + oldest + '–' + newest + ' · ' + idx.years.length + (Host.isZh ? ' 届冠军' : ' champions') + '</span>'
                + '</div>'
                + '<div class="sglv-tga-grid">' + cells + '</div>'
                + '</div>';
            tgaBindExclImgs(el);
            el.scrollTop = 0;
        }

        // ---- 提名弹窗（单例）：左获奖者竖版海报 + 右提名横版网格；ESC/遮罩/关闭按钮退出 ----
        let _tgaNomsModal = null, _tgaNomsEsc = null;
        function closeTgaNomsModal() {
            if (_tgaNomsEsc) { document.removeEventListener('keydown', _tgaNomsEsc, true); _tgaNomsEsc = null; }
            if (_tgaNomsModal) { _tgaNomsModal.remove(); _tgaNomsModal = null; }
        }
        function openTgaNomsModal(year) {
            const idx = _tgaState.index;
            const info = idx && idx.byYear[year];
            if (!info) return;
            closeTgaNomsModal();
            const w = info.winner;
            const catLabel = (idx.cats && idx.cats.goty) || (Host.isZh ? '年度游戏' : 'Game of the Year');
            const noms = info.nominees.filter(n => n && n.name !== w.name);
            const isSteam = typeof w.appid === 'number';
            const owned = isSteam ? tgaOwned(w.appid) : false;
            // 左栏：获奖者竖版海报（Steam 可点开商店；非 Steam 占位画）+ 名称 + 获奖徽章 + 在库/平台标记
            const winPoster = isSteam
                ? '<div class="sglv-tga-winner-poster" data-tga-store="' + w.appid + '">' + gotyCoverImgTag(w.appid, w.name, 'poster', 'sglv-tga-winner-img') + '</div>'
                : '<div class="sglv-tga-winner-poster excl">' + tgaExclArtHtml(w, true) + '</div>';
            const winOwn = isSteam ? tgaOwnedChipHtml(owned) : tgaExclTypeHtml(w.appid);
            // 右栏：提名横版网格（不含获奖者本人）
            let gridHtml = '';
            noms.forEach(n => {
                const nSteam = typeof n.appid === 'number';
                if (nSteam) {
                    const nOwned = tgaOwned(n.appid);
                    gridHtml += '<div class="sglv-tga-nom-card' + (nOwned ? ' owned' : '') + '" data-tga-store="' + n.appid + '" title="' + Host.wlEscape(n.name) + '">'
                        + '<div class="sglv-tga-nom-img-wrap">' + gotyCoverImgTag(n.appid, n.name, 'capsule', 'sglv-tga-nom-img') + '</div>'
                        + '<div class="sglv-tga-nom-name">' + Host.wlEscape(n.name) + '</div>'
                        + (nOwned ? tgaOwnedChipHtml(true) : '')
                        + '</div>';
                } else {
                    gridHtml += '<div class="sglv-tga-nom-card excl" title="' + Host.wlEscape(n.name) + '">'
                        + '<div class="sglv-tga-nom-img-wrap">' + tgaExclArtHtml(n, false) + '</div>'
                        + '<div class="sglv-tga-nom-name">' + Host.wlEscape(n.name) + '</div>'
                        + tgaExclTypeHtml(n.appid)
                        + '</div>';
                }
            });
            const html = '<div class="sglv-tga-modal-win">'
                + '<div class="sglv-tga-modal-head">'
                    + '<span class="sglv-tga-modal-trophy">' + Host.ICONS.trophy + '</span>'
                    + '<span class="sglv-tga-modal-title">' + Host.wlEscape(catLabel) + ' · ' + year + '</span>'
                    + '<span class="sglv-tga-modal-sub">' + (Host.isZh ? '获奖 1 · 提名 ' + noms.length + ' 款' : 'Winner 1 · ' + noms.length + ' nominees') + '</span>'
                    + '<span class="sglv-tga-modal-close" title="' + (Host.isZh ? '关闭' : 'Close') + '">' + Host.ICONS.close + '</span>'
                + '</div>'
                + '<div class="sglv-tga-modal-body">'
                    + '<div class="sglv-tga-noms-side">'
                        + '<div class="sglv-tga-noms-side-top"><span class="sglv-tga-side-year">' + year + '</span><span class="sglv-tga-side-cat">' + Host.wlEscape(catLabel) + '</span></div>'
                        + winPoster
                        + '<div class="sglv-tga-noms-side-name">' + Host.wlEscape(w.name) + '</div>'
                        + '<div class="sglv-tga-noms-side-own"><span class="sglv-tga-winner-badge">' + (Host.isZh ? '获奖' : 'Winner') + '</span>' + winOwn + '</div>'
                    + '</div>'
                    + (gridHtml ? '<div class="sglv-tga-noms-grid">' + gridHtml + '</div>' : '<div class="sglv-tga-noms-empty">' + (Host.isZh ? '暂无提名数据' : 'No nominees') + '</div>')
                + '</div>'
                + '</div>';
            const modal = document.createElement('div');
            modal.className = 'sglv-tga-modal';
            modal.innerHTML = html;
            modal.addEventListener('click', ev => {
                if (ev.target === modal || ev.target.closest('.sglv-tga-modal-close')) { closeTgaNomsModal(); return; }
                const storeEl = ev.target.closest('[data-tga-store]');
                if (storeEl) tgaOpenStore(storeEl.dataset.tgaStore);
            });
            _tgaNomsEsc = ev => { if (ev.key === 'Escape') closeTgaNomsModal(); };
            document.addEventListener('keydown', _tgaNomsEsc, true);
            document.body.appendChild(modal);
            _tgaNomsModal = modal;
            _bindGotyCoverDelegation(modal);
            tgaBindExclImgs(modal);
        }

        // ---- 数据加载：IDB 永久缓存优先秒开 + 24h 后台刷新（镜像 loadGotyGames）----
        function _tgaFailLoading(msg) {
            _tgaState.loading = false;
            if (!_tgaState.loaded) _tgaState.loadError = msg;
            if (gotyState.tgaView) renderGotySections();
        }
        function loadTgaWinners(force) {
            if (_tgaState.loading) { if (!force) return; _tgaState.loading = false; }
            if (!force) {
                const cached = _permCacheGet('tgaWinners_v1');
                if (cached && cached.data && Array.isArray(cached.data.years) && cached.data.years.length) {
                    _tgaState.data = cached.data;
                    _tgaState.index = tgaBuildWinnerIndex(cached.data);
                    _tgaState.updatedAt = cached.updatedAt || '';
                    _tgaState.source = cached.source || (Host.isZh ? '本地缓存' : 'local cache');
                    _tgaState.lastFetchAt = cached.lastFetchAt || 0;
                    _tgaState.loaded = true;
                    _tgaState.loadError = null;
                    // 缓存命中后重渲染：殿堂视图 或 常规视图（补上 👑 年度游戏 chip）
                    if (gotyState.tgaView || gotyState.loaded) renderGotySections();
                    if (_shouldThrottle(_tgaLastBgRefreshAt, _TGA_BG_INTERVAL)) return;
                    _refreshTgaFromRemote(false, false);
                    return;
                }
            }
            _refreshTgaFromRemote(force, true);
        }
        function _refreshTgaFromRemote(force, showLoading) {
            if (typeof GM_xmlhttpRequest !== 'function') { if (showLoading) _tgaFailLoading('noXhr'); return; }
            if (_tgaState.loading) { if (!force) return; _tgaState.loading = false; }
            if (showLoading) { _tgaState.loading = true; _tgaState.loadError = null; if (gotyState.tgaView) renderGotySections(); }
            function _processTga(r) {
                const txt = _safeRespText(r);
                if (r.status === 404 || !txt) return false;
                const data = JSON.parse(txt);
                if (!data || !Array.isArray(data.years) || !data.years.length) return false;
                _tgaState.data = data;
                _tgaState.index = tgaBuildWinnerIndex(data);
                _tgaState.updatedAt = new Date().toISOString().slice(0, 10);
                _tgaState.source = 'TGA · GitHub';
                _tgaState.loaded = true;
                _tgaState.loadError = null;
                _tgaState.loading = false;
                _tgaState.lastFetchAt = Date.now();
                _tgaLastBgRefreshAt = Date.now();
                _permCacheSet('tgaWinners_v1', { data: data, updatedAt: _tgaState.updatedAt, source: _tgaState.source, lastFetchAt: _tgaState.lastFetchAt });
                if (gotyState.tgaView || gotyState.loaded) renderGotySections();
                return true;
            }
            function _tryNextTga(i) {
                if (i >= TGA_WINNERS_SOURCES.length) {
                    _tgaState.loading = false;
                    if (!_tgaState.loaded) _tgaFailLoading('networkError');
                    else if (gotyState.tgaView) renderGotySections();
                    return;
                }
                GM_xmlhttpRequest({
                    method: 'GET', url: TGA_WINNERS_SOURCES[i], timeout: 15000,
                    onload(r) { try { if (_processTga(r)) return; } catch (e) { /* 解析异常，交给下一个源 */ } _tryNextTga(i + 1); },
                    onerror() { _tryNextTga(i + 1); },
                    ontimeout() { _tryNextTga(i + 1); },
                });
            }
            _tryNextTga(0);
        }

        // ==================== 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 unifiedCover(appid, name, 'poster');
        }

        function dlcCapsuleImg(appid, name) {
            // v2.8.0: 统一封面（Host.capsuleImg 走旧 inline onerror 链，跨视图切换时会锁死）
            return unifiedCover(appid, name, 'capsule', { imgCls: 'sglv-wl-cover-img' });
        }

        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('');
                // v2.9.5: DLC 分组视图从不绑定封面回退 → wrapper 永远停在 sglv-img-loading（灰块）
                bindRestrictedCoverLoaders(grid);
                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);
                // v2.9.5: 每批 append 后就绑定新卡片（幂等，只处理未绑定的 wrapper）——
                //   DLC 分组视图（renderDlcGrouped）此前完全没有调用 binder，
                //   封面 404 后无回退链，wrapper 永远停在 loading 灰块。
                bindRestrictedCoverLoaders(grid);
                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(); });
            }
            // v2.8.0: 统一封面链绑定（addEventListener，无跨上下文 inline onerror）
            bindRestrictedCoverLoaders(content);
        }

        // 分组视图渲染：父游戏折叠头 + 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, 按父游戏分组
        // ==================== 捆绑包标签页 ====================
        // v2.5.0 关键修复：捆绑包数据源（Barter.vg bundle 数据库）原先**只能被动消费**——
        //   buildBundleData() 直接调 Host.getBundleCount()，而它在 bundleDbData 为 null 时恒返回 0。
        //   原先只有「我的库存」tab 才会触发 loadBundleDatabase()，于是用户直接点捆绑包 tab
        //   （不先进库存 tab）时：dlcsByParent 空 + bundleCount 全 0 → KPI 全 0 + 「暂无进包数据」。
        //   修复：renderBundleTab 进入时主动 await Host.loadBundleDatabase()，
        //   并区分 loading / loadError / loaded 三态分别给出进度条、失败提示+重试按钮、真实空态。
        const BUNDLE_LOAD_STAGES = {
            zh: { start: '正在加载进包数据…', fail: '进包数据加载失败', retry: '重试', notReady: '进包数据源未就绪，请点击重试' },
            en: { start: 'Loading bundle data…', fail: 'Failed to load bundle data', retry: 'Retry', notReady: 'Bundle data source not ready, click retry' }
        };
        const _bundleLang = () => (Host.isZh ? BUNDLE_LOAD_STAGES.zh : BUNDLE_LOAD_STAGES.en);

        /** 确保 Bundle 数据库就绪——已就绪直接返回 true；否则主动触发宿主加载并等待完成。 */
        function ensureBundleDbReady() {
            // 已就绪
            if (typeof Host.isBundleDbReady === 'function' ? Host.isBundleDbReady() : true) return Promise.resolve(true);
            // 宿主未暴露主动加载能力 → 降级：只能等「我的库存」tab 预热
            if (typeof Host.loadBundleDatabase !== 'function') return Promise.resolve(false);
            bundleState.loading = true;
            bundleState.loadError = false;
            return Promise.resolve()
                .then(() => Host.loadBundleDatabase())
                .then(() => {
                    const ok = (typeof Host.isBundleDbReady === 'function') ? Host.isBundleDbReady() : true;
                    bundleState.loading = false;
                    bundleState.loadError = !ok;
                    return ok;
                })
                .catch(e => {
                    console.warn('[SGLV-Bundle] loadBundleDatabase 失败:', e);
                    bundleState.loading = false;
                    bundleState.loadError = true;
                    return false;
                });
        }

        /** 强制重新加载 Bundle 数据库（重试按钮）——先清缓存再拉，避免负缓存 30min 内直接跳过。 */
        function reloadBundleDb() {
            bundleState.loading = true;
            bundleState.loadError = false;
            bundleState.loaded = false;
            renderBundleKpi();
            renderBundleList();
            if (typeof Host.loadBundleDatabase !== 'function') {
                bundleState.loading = false;
                bundleState.loadError = true;
                renderBundleKpi();
                renderBundleList();
                return;
            }
            Promise.resolve().then(() => Host.loadBundleDatabase()).then(() => {
                bundleState.loading = false;
                const ok = (typeof Host.isBundleDbReady === 'function') ? Host.isBundleDbReady() : true;
                bundleState.loadError = !ok;
                if (ok) buildBundleData();
                renderBundleKpi();
                renderBundleList();
            }).catch(e => {
                console.warn('[SGLV-Bundle] reloadBundleDb 失败:', e);
                bundleState.loading = false;
                bundleState.loadError = true;
                renderBundleKpi();
                renderBundleList();
            });
        }

        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,
                            // v2.8.0: 未在库存里找到名字时不再回退成"DLC <id>"这种占位文案——
                            // 卡片上直接显示 appid + 无封面骨架，比"DLC 347150"更干净。
                            name: dlcGame ? dlcGame.name : '',
                            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;
            // v2.5.0: 加载中 / 失败态不再复用 DLC 的 KPI 骨架（原骨架与捆绑包字段无关，且失败时显示骨架误导用户）
            if (bundleState.loading) { el.innerHTML = ''; return; }
            if (bundleState.loadError) { el.innerHTML = ''; return; }
            if (!bundleState.loaded) { el.innerHTML = renderDlcKpiSkeletonHtml(); 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;

            // v2.8.0: KPI 小卡 → HERO 仪表盘（与锁区/绝版同款，铺满浮窗宽度）
            // 捆绑包没有"分类"维度，右区改放两个规模指标（进包 DLC / 累计进包次数）的占比条。
            const stats = [
                { key: 'dlcs',  label: Host.isZh ? '进包 DLC' : 'Bundled DLCs', count: totalDlcs,   color: '#a78bfa' },
                { key: 'times', label: Host.isZh ? '累计进包' : 'Bundle entries', count: totalBundles, color: '#f59e0b' },
            ].filter(t => t.count > 0);
            const statSum = stats.reduce((s, t) => s + t.count, 0) || 1;

            el.innerHTML = '<div class="sglv-hero">' +
                '<div class="sglv-hero-left">' +
                    '<div class="sglv-hero-title">' + (Host.isZh ? '含进包游戏' : 'Games w/ Bundles') + '</div>' +
                    '<div class="sglv-hero-num">' + totalGames.toLocaleString() + '</div>' +
                    '<div class="sglv-hero-progress"><div class="sglv-hero-progress-fill" style="width:' + ownPct + '%"></div></div>' +
                    '<div class="sglv-hero-progress-cap">' + (Host.isZh ? '已拥有' : 'Owned') + ' ' + ownPct + '%</div>' +
                    '<div class="sglv-hero-scope-row">' +
                        '<div class="sglv-hero-scope' + (ownPct === 100 ? ' active' : '') + '">' +
                            '<span class="sglv-hero-scope-val">' + ownedGames.toLocaleString() + '</span>' +
                            '<span class="sglv-hero-scope-label">' + (Host.isZh ? '已拥有' : 'Owned') + '</span>' +
                        '</div>' +
                        '<div class="sglv-hero-scope' + (ownPct < 100 ? ' active' : '') + '">' +
                            '<span class="sglv-hero-scope-val">' + (totalGames - ownedGames).toLocaleString() + '</span>' +
                            '<span class="sglv-hero-scope-label">' + (Host.isZh ? '家庭共享' : 'Family') + '</span>' +
                        '</div>' +
                    '</div>' +
                '</div>' +
                '<div class="sglv-hero-right">' +
                    '<div class="sglv-hero-right-head">' + (Host.isZh ? '进包规模' : 'Bundle scale') + '</div>' +
                    stats.map(function (t) {
                        const pct = Math.round(t.count / statSum * 100);
                        return '<div class="sglv-hero-type">' +
                            '<span class="sglv-hero-type-dot" style="background:' + t.color + '"></span>' +
                            '<span class="sglv-hero-type-name">' + Host.wlEscape(t.label) + '</span>' +
                            '<span class="sglv-hero-type-track"><span class="sglv-hero-type-fill" style="width:' + pct + '%;background:' + t.color + '"></span></span>' +
                            '<span class="sglv-hero-type-count">' + t.count.toLocaleString() + '</span>' +
                            '<span class="sglv-hero-type-pct">' + pct + '%</span>' +
                            '</div>';
                    }).join('') +
                '</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 = ''; };

            // v2.5.0: 三态判断顺序调整为 加载中 → 失败 → DLC 未就绪 → 构建中骨架 → 空态 → 列表。
            // 原先「DLC 未就绪」在前且没有 loading 态，导致加载中直接闪「暂无进包数据」。
            if (bundleState.loading) {
                content.innerHTML = '<div class="sglv-bundle-state">' +
                    '<div class="sglv-progress" style="margin:0 0 10px"><div class="sglv-progress-fill sglv-progress-indeterminate"></div></div>' +
                    '<div class="sglv-empty">' + Host.wlEscape(_bundleLang().start) + '</div>' +
                    '</div>';
                clearPagination();
                return;
            }
            if (bundleState.loadError) {
                content.innerHTML = '<div class="sglv-bundle-state">' +
                    '<div class="sglv-empty sglv-empty-error">' + Host.wlEscape(_bundleLang().fail) + '</div>' +
                    '<div class="sglv-bundle-state-actions">' +
                        '<button class="sglv-btn sglv-btn-secondary" id="sglv-bundle-retry">' + Host.wlEscape(_bundleLang().retry) + '</button>' +
                    '</div>' +
                    '</div>';
                clearPagination();
                const retry = content.querySelector('#sglv-bundle-retry');
                if (retry) retry.addEventListener('click', () => reloadBundleDb());
                return;
            }
            // 检查 DLC 数据库是否可用（进包数据依赖 Barter.vg DLC 反向映射）
            if (typeof Host.isDlcDbReady === 'function' && !Host.isDlcDbReady()) {
                content.innerHTML = '<div class="sglv-bundle-state">' +
                    '<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></div>';
                clearPagination();
                return;
            }

            if (!bundleState.loaded) {
                // 数据异步构建中——骨架占位（避免闪"暂无进包数据"空态）
                const skelCards = 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('');
                content.innerHTML = '<div class="sglv-skel-grid">' + skelCards + '</div>';
                clearPagination();
                return;
            }
            if (bundleState.data.length === 0) {
                content.innerHTML = '<div class="sglv-bundle-state">' +
                    '<div class="sglv-empty">' + (Host.isZh ? '暂无进包数据' : 'No bundle data available') + '</div>' +
                    '<div class="sglv-bundle-state-actions">' +
                        '<button class="sglv-btn sglv-btn-secondary" id="sglv-bundle-retry">' + Host.wlEscape(_bundleLang().retry) + '</button>' +
                    '</div></div>';
                clearPagination();
                const retry = content.querySelector('#sglv-bundle-retry');
                if (retry) retry.addEventListener('click', () => reloadBundleDb());
                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-bundle-wall">' + pageItems.map(item => {
                const q = (bundleState.search || '').toLowerCase();
                const parentName = item.name || ('App ' + item.appid);
                const parentNameCls = q && parentName.toLowerCase().includes(q) ? ' sglv-highlight' : '';
                const restId = 'sglv-bundle-rest-' + item.appid;

                // ---- 顶部标题条：主游戏退为上下文（左侧色条表示已拥有） ----
                const head =
                    '<div class="sglv-bundle-head' + (item.isOwned ? ' is-owned' : '') + '">' +
                        '<div class="sglv-bundle-title-row" onclick="event.stopPropagation();window.open(\'https://store.steampowered.com/app/' + item.appid + '\',\'_blank\')" title="' + Host.wlEscape(parentName) + '">' +
                            '<span class="sglv-bundle-title' + parentNameCls + '">' + Host.wlEscape(parentName) + '</span>' +
                            '<span class="sglv-bundle-appid">' + item.appid + '</span>' +
                        '</div>' +
                        '<div class="sglv-bundle-meta">' +
                            '<span class="sglv-bundle-stat"><span class="sglv-bundle-stat-ico">📦</span>' + item.totalBundle + (Host.isZh ? ' 进包' : ' bundles') + '</span>' +
                            (item.dlcCount > 0 ? '<span class="sglv-bundle-sep"></span><span class="sglv-bundle-stat">' + item.dlcCount + ' DLC</span>' : '') +
                        '</div>' +
                    '</div>';

                // ---- 主体：DLC 封面墙（3 列） ----
                // 每个 DLC 有独立 appid，可直接走 restrictedCoverImg 拿真实封面；
                // 旧版用 24px 社区图标，DLC 的美术资源基本读不出来。
                const renderTile = (d) => {
                    const dlcUrl = 'https://store.steampowered.com/app/' + d.appid;
                    const label = d.name || ('DLC ' + d.appid);
                    const hitCls = q && d.name && d.name.toLowerCase().includes(q) ? ' is-hit' : '';
                    return '<div class="sglv-bundle-tile' + hitCls + (d.isOwned ? ' is-owned' : '') + '"' +
                        ' onclick="event.stopPropagation();window.open(\'' + dlcUrl + '\',\'_blank\')"' +
                        ' title="' + Host.wlEscape(label) + '\n📦 ' + d.bundleCount + (Host.isZh ? ' 进包' : ' bundles') + ' · ' + d.appid + '">' +
                        restrictedCoverImg(d.appid, d.name, 'poster') +
                        '<span class="sglv-bundle-tile-num">' + d.bundleCount + '</span>' +
                        '</div>';
                };

                let wallHtml = '';
                if (item.dlcs.length > 0) {
                    const PREVIEW = 6;      // 2 行 × 3 列
                    const preview = item.dlcs.slice(0, PREVIEW);
                    const rest = item.dlcs.slice(PREVIEW);
                    wallHtml = '<div class="sglv-bundle-tiles">' + preview.map(renderTile).join('') + '</div>' +
                        (rest.length > 0
                            ? '<div class="sglv-bundle-tiles sglv-bundle-tiles-rest" id="' + restId + '" hidden>' + rest.map(renderTile).join('') + '</div>' +
                              '<button class="sglv-bundle-expand" data-target="' + restId + '" data-count="' + rest.length + '">' +
                                '<span class="sglv-bundle-expand-txt">' + (Host.isZh ? '展开其余 ' + rest.length + ' 个' : 'Show ' + rest.length + ' more') + '</span>' +
                                '<span class="sglv-bundle-expand-caret">▾</span>' +
                              '</button>'
                            : '');
                } else {
                    // 主游戏本体直接进包、无子 DLC —— 用主游戏封面占位，保持卡片视觉完整
                    wallHtml = '<div class="sglv-bundle-tiles sglv-bundle-tiles-single">' +
                        '<div class="sglv-bundle-tile is-owned" onclick="event.stopPropagation();window.open(\'https://store.steampowered.com/app/' + item.appid + '\',\'_blank\')" title="' + Host.wlEscape(parentName) + '">' +
                        restrictedCoverImg(item.appid, parentName, 'poster') +
                        '<span class="sglv-bundle-tile-badge">' + (Host.isZh ? '本体进包' : 'Base') + '</span>' +
                        '</div></div>';
                }

                return '<div class="sglv-bundle-card">' + head + wallHtml + '</div>';
            }).join('') + '</div>';

            // v2.8.0: DLC 墙折叠展开（事件委托，避免上千个监听器）
            content.querySelectorAll('.sglv-bundle-expand').forEach(btn => {
                btn.addEventListener('click', e => {
                    e.stopPropagation();
                    const box = document.getElementById(btn.dataset.target);
                    if (!box) return;
                    const show = box.hasAttribute('hidden');
                    if (show) box.removeAttribute('hidden'); else box.setAttribute('hidden', '');
                    const n = box.querySelectorAll('.sglv-bundle-tile').length;
                    btn.querySelector('.sglv-bundle-expand-txt').textContent = show
                        ? (Host.isZh ? '收起' : 'Show less')
                        : (Host.isZh ? '展开其余 ' + n + ' 个' : 'Show ' + n + ' more');
                    btn.querySelector('.sglv-bundle-expand-caret').textContent = show ? '▴' : '▾';
                    btn.classList.toggle('is-open', show);
                });
            });

            bindRestrictedCoverLoaders(content);

            // 分页
            // 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();
            });

            // v2.5.0: 数据异步加载链路——
            //   ① 先同步渲染 loading 态（进度条），不闪空态；
            //   ② 主动确保 Bundle 数据库就绪（原先只在「我的库存」tab 触发，直接点捆绑包必然空）；
            //   ③ 同步读一次缓存，命中则立即出列表（秒开路径）；
            //   ④ 让出主线程后构建派生数据（buildBundleData 遍历库存×DLC 进包映射，是长任务）。
            //   容器已随 tab 切换被移出文档时跳过本次构建。
            renderBundleKpi();
            renderBundleList();

            ensureBundleDbReady().then(() => {
                // Bundle 数据库就绪后，DLC 反向映射也可能尚未就绪 → 触发一次 DLC 加载再重建
                const dlcPromise = (typeof Host.isDlcDbReady === 'function' && !Host.isDlcDbReady() && typeof Host.loadDlcDatabase === 'function')
                    ? Promise.resolve().then(() => Host.loadDlcDatabase()).catch(() => null)
                    : Promise.resolve();
                return dlcPromise.then(() => {
                    if (!document.getElementById('sglv-bundle-kpi')) return;   // 容器已卸载
                    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="publisher">${Host.ICONS.grid}<span>${Host.T.tabPublisher}</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="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="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>
                        <button class="sglv-tab sglv-tab-btn" data-tab="humble">${Host.ICONS.gift}<span>${Host.T.tabHumble}</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();
                }
            });
        }

        // ==================== v2.11.50: Humble Choice 月包分析（借鉴 steam-friend-manager 1.5.2） ====================
        // 数据源：@resource humbleChoiceData（SmallFork JSON，{months:[{choice,month,year,games:[{name,appid,date,publisher}]}]}）。
        // 性能：月份解析一次缓存；游戏列表放 <details> 内惰性展开（不渲染海报，纯文本行）；
        // 分页 12 月/页；搜索/筛选走内存过滤 + 局部重渲。
        const humbleState = { search: '', filter: 'all', page: 1, pageSize: 12 };
        let _humbleMonthsCache = null;
        const HUMBLE_MON_ZH = { January: 1, February: 2, March: 3, April: 4, May: 5, June: 6, July: 7, August: 8, September: 9, October: 10, November: 11, December: 12 };
        function humbleLoadMonths() {
            if (_humbleMonthsCache !== null) return _humbleMonthsCache;
            const raw = (typeof Host.getResourceText === 'function') ? Host.getResourceText('humbleChoiceData') : null;
            if (!raw) { _humbleMonthsCache = []; return _humbleMonthsCache; }
            try {
                const json = JSON.parse(raw);
                _humbleMonthsCache = Array.isArray(json.months) ? json.months : [];
            } catch (e) { console.warn('[SGLV-Humble] 数据解析失败:', e); _humbleMonthsCache = []; }
            return _humbleMonthsCache;
        }
        function renderHumbleTab(parent) {
            const wrap = document.createElement('div');
            wrap.className = 'sglv-psplus-wrap';
            parent.appendChild(wrap);
            const months = humbleLoadMonths();
            if (!months.length) {
                wrap.innerHTML = `<div class="sglv-empty">${Host.T.humbleNoData}</div>`;
                return;
            }
            const ownedIds = Host.getActiveOwnedAppIds();
            const isOwned = id => ownedIds.has(Number(id)) || ownedIds.has(String(id));
            // 预计算每月统计与展示标签（一次遍历）
            months.forEach(m => {
                const games = Array.isArray(m.games) ? m.games : [];
                m._games = games;
                m._owned = games.filter(g => isOwned(g.appid)).length;
                const zh = HUMBLE_MON_ZH[m.month] || '';
                m._label = Host.isZh ? `#${m.choice} ${m.year}年${zh}月` : `#${m.choice} ${m.month} ${m.year}`;
            });
            wrap.innerHTML = `
                <div id="sglv-humble-kpi"></div>
                <div class="sglv-toolbar">
                    <input class="sglv-search" aria-label="搜索" id="sglv-humble-search" placeholder="${Host.T.humbleSearch}" value="${Host.wlEscape(humbleState.search)}">
                    <div class="sglv-filter-bar" style="margin:0">
                        ${['all', 'owned', 'unowned'].map(f => `<button class="sglv-btn sglv-btn-secondary${humbleState.filter === f ? ' active' : ''}" data-humble-filter="${f}">${Host.T['humbleFilter' + f[0].toUpperCase() + f.slice(1)]}</button>`).join('')}
                    </div>
                    <button class="sglv-btn sglv-btn-secondary" id="sglv-humble-expand-all" title="${Host.isZh ? '全部展开' : 'Expand all'}">${Host.isZh ? '展开' : 'Expand'}</button>
                    <button class="sglv-btn sglv-btn-secondary" id="sglv-humble-collapse-all" title="${Host.isZh ? '全部收起' : 'Collapse all'}">${Host.isZh ? '收起' : 'Collapse'}</button>
                    <div class="sglv-pagination" id="sglv-humble-pagination"></div>
                </div>
                <div class="sglv-content" id="sglv-humble-content"></div>
            `;
            const kpiEl = wrap.querySelector('#sglv-humble-kpi');
            const contentEl = wrap.querySelector('#sglv-humble-content');
            const pagiEl = wrap.querySelector('#sglv-humble-pagination');
            const totalGames = months.reduce((s, m) => s + m._games.length, 0);
            const totalOwned = months.reduce((s, m) => s + m._owned, 0);
            const ownedPct = totalGames > 0 ? Math.round(totalOwned / totalGames * 100) : 0;
            const unowned = totalGames - totalOwned;
            // v2.4.0: 填充 KPI sub 文本（之前 "游戏数" 和 "未拥有" sub 为空）
            kpiEl.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.gift}</span><span class="sglv-trend-kpi-label">${Host.T.humbleKpiMonths}</span></div>
                        <div class="sglv-trend-kpi-value">${months.length}</div>
                        <div class="sglv-trend-kpi-sub">Choice #1 ~ #${months[months.length - 1].choice}</div>
                    </div>
                    <div class="sglv-trend-kpi-card" style="border-left:3px solid #a78bfa">
                        <div class="sglv-trend-kpi-header"><span class="sglv-trend-kpi-icon" style="color:#a78bfa">${Host.ICONS.package}</span><span class="sglv-trend-kpi-label">${Host.T.humbleKpiGames}</span></div>
                        <div class="sglv-trend-kpi-value">${totalGames.toLocaleString()}</div>
                        <div class="sglv-trend-kpi-sub">${Host.isZh ? '历年总数' : 'Total all years'}</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;font-weight:700">✓</span><span class="sglv-trend-kpi-label">${Host.T.humbleKpiOwned}</span></div>
                        <div class="sglv-trend-kpi-value">${totalOwned.toLocaleString()}</div>
                        <div class="sglv-trend-kpi-sub" style="color:#4bb54f;font-weight:600">${ownedPct}%</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.clock}</span><span class="sglv-trend-kpi-label">${Host.T.humbleKpiUnowned}</span></div>
                        <div class="sglv-trend-kpi-value">${unowned.toLocaleString()}</div>
                        <div class="sglv-trend-kpi-sub">${Host.isZh ? '待探索 ' + (totalGames ? Math.round(unowned / totalGames * 100) : 0) + '%' : 'To explore ' + (totalGames ? Math.round(unowned / totalGames * 100) : 0) + '%'}</div>
                    </div>
                </div>`;
            const q = () => (humbleState.search || '').toLowerCase();
            // v2.4.0: 月卡顶部展示 3-5 个游戏缩略 + 搜索高亮 + <details> 行升级（加封面 + 拥有徽章）
            const monthCardHtml = m => {
                const games = m._games;
                const pct = games.length ? Math.round(m._owned / games.length * 100) : 0;
                const titleCls = q() && m._label.toLowerCase().includes(q()) ? ' sglv-highlight' : '';

                // v2.9.6: 顶部游戏缩略 —— 全量平铺（去掉"最多 5 个 + "+N" 截断"，
                //   月包 8 款远没占满卡片宽度，右侧大片空白却让用户多点一次展开才看得全）
                const gameThumbsHtml = games.length > 0
                    ? '<div class="sglv-humble-game-thumbs">' +
                        games.map(g => {
                            const owned = isOwned(g.appid);
                            const thumbCls = owned ? 'sglv-humble-game-thumb owned' : 'sglv-humble-game-thumb';
                            return '<div class="' + thumbCls + '" title="' + Host.wlEscape(g.name || '') + '">' +
                                '<img src="' + Host.getGameIconUrl(g.appid, '') + '" alt="" loading="lazy" onerror="this.parentElement.classList.add(\'no-img\')">' +
                                (owned ? '<span class="sglv-humble-game-thumb-mark">✓</span>' : '') +
                            '</div>';
                        }).join('') +
                    '</div>'
                    : '';

                // 展开行：每行加 24x24 封面 + 拥有徽章 + 搜索高亮
                const rows = games.map(g => {
                    const owned = isOwned(g.appid);
                    const nameCls = q() && (g.name || '').toLowerCase().includes(q()) ? ' sglv-highlight' : '';
                    const icon = '<img class="sglv-humble-row-icon" src="' + Host.getGameIconUrl(g.appid, '') + '" alt="" loading="lazy" onerror="this.style.display=\'none\'">';
                    const ownedMark = owned ? '<span class="sglv-humble-row-owned">✓</span>' : '<span class="sglv-humble-row-missing">·</span>';
                    return '<div class="sglv-humble-row' + (owned ? ' owned' : '') + '">' +
                        icon +
                        ownedMark +
                        '<span class="sglv-humble-row-name' + nameCls + '" title="' + Host.wlEscape(g.name || '') + '">' + Host.wlEscape(g.name || '') + '</span>' +
                        (g.publisher ? '<span class="sglv-humble-row-pub">' + Host.wlEscape(g.publisher) + '</span>' : '') +
                        (g.appid ? '<a class="sglv-humble-row-link" href="https://store.steampowered.com/app/' + g.appid + '" target="_blank" rel="noopener" onclick="event.stopPropagation()">' + g.appid + '</a>' : '') +
                    '</div>';
                }).join('');

                return '<div class="sglv-humble-month-card">' +
                    '<div class="sglv-humble-month-head">' +
                        '<span class="sglv-humble-month-title' + titleCls + '">' + Host.wlEscape(m._label) + '</span>' +
                        '<span class="sglv-humble-month-count">' + games.length + ' games</span>' +
                        '<span class="sglv-humble-month-owned">' + Host.T.humbleOwnedIn + ' ' + m._owned + '/' + games.length + ' (' + pct + '%)</span>' +
                    '</div>' +
                    gameThumbsHtml +
                    '<details class="sglv-humble-month-details">' +
                        '<summary class="sglv-humble-month-summary">' + (Host.isZh ? '展开游戏列表' : 'Show games') + '</summary>' +
                        '<div class="sglv-humble-month-rows">' + rows + '</div>' +
                    '</details>' +
                '</div>';
            };
            const filteredMonths = () => {
                const qStr = q();
                return months.filter(m => {
                    if (humbleState.filter === 'owned' && m._owned === 0) return false;
                    if (humbleState.filter === 'unowned' && m._owned > 0) return false;
                    if (!qStr) return true;
                    if (m._label.toLowerCase().includes(qStr)) return true;
                    return m._games.some(g =>
                        (g.name || '').toLowerCase().includes(qStr) ||
                        (g.publisher || '').toLowerCase().includes(qStr) ||
                        String(g.appid) === qStr);
                });
            };
            const renderList = () => {
                const list = filteredMonths().sort((a, b) => b.choice - a.choice);
                const pg = Host.paginate(list, humbleState.page, humbleState.pageSize);
                humbleState.page = pg.page;
                contentEl.innerHTML = pg.pageItems.map(monthCardHtml).join('');
                if (typeof Host.renderPagination === 'function') {
                    Host.renderPagination(pagiEl, 'sglv-humble', pg.page, pg.totalPages, list.length,
                        () => { humbleState.page--; renderList(); },
                        () => { humbleState.page++; renderList(); },
                        p => { humbleState.page = p; renderList(); });
                }
            };
            renderList();
            // 搜索（防抖 200ms，复用 lib 内 _debounce）
            wrap.querySelector('#sglv-humble-search').addEventListener('input', _debounce(e => {
                humbleState.search = e.target.value;
                humbleState.page = 1;
                renderList();
            }, 200));
            // 拥有状态筛选
            wrap.querySelectorAll('[data-humble-filter]').forEach(btn => {
                btn.addEventListener('click', () => {
                    humbleState.filter = btn.dataset.humbleFilter;
                    humbleState.page = 1;
                    wrap.querySelectorAll('[data-humble-filter]').forEach(b => b.classList.remove('active'));
                    btn.classList.add('active');
                    renderList();
                });
            });
            // v2.4.0: 批量展开/收起
            wrap.querySelector('#sglv-humble-expand-all').addEventListener('click', () => {
                contentEl.querySelectorAll('details.sglv-humble-month-details').forEach(d => { d.open = true; });
            });
            wrap.querySelector('#sglv-humble-collapse-all').addEventListener('click', () => {
                contentEl.querySelectorAll('details.sglv-humble-month-details').forEach(d => { d.open = false; });
            });
        }

        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);
            else if (_collectionActiveTab === 'humble') renderHumbleTab(body);
            _collectionBodyInitialized = true;
        }

        function openCollection() {
            ensureCollectionPanel();
            collectionOverlayEl.classList.add('sglv-show');
            collectionPanelEl.classList.add('sglv-show');
            // v2.11.49: 打开性能优化——先同步显示面板+骨架占位，把当前 tab 的重构建
            // （DOM 批量插入 + 数据遍历）推迟到下一帧，避免长任务阻塞打开动画造成卡顿
            const body = collectionPanelEl && collectionPanelEl.querySelector('#sgc-body');
            if (body && !body.childElementCount) {
                const skelLines = '<div class="sglv-skel-line lg"></div><div class="sglv-skel-line md"></div><div class="sglv-skel-line sm"></div>';
                const kpiCards = Array.from({ length: 5 }, () => `<div class="sglv-trend-kpi-card skeleton">${skelLines}</div>`).join('');
                const cards = Array.from({ length: 8 }, () =>
                    '<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('');
                body.innerHTML = `<div style="padding:16px 18px"><div class="sglv-trend-kpi-row">${kpiCards}</div><div class="sglv-skel-grid">${cards}</div></div>`;
            }
            requestAnimationFrame(() => requestAnimationFrame(renderCollectionBody));
        }

        function closeCollection() {
            closeTgaNomsModal(); // v2.9.8: 关闭收藏面板时清理遗留的 TGA 提名弹窗
            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,
        renderHumbleTab,
        // v2.6.0: 供封面 <img> 的 inline onerror 调用（appdetails API 兜底取图）。
        // 必须在 window 上可见 —— inline handler 运行在页面上下文，只能通过 window.SGLVCollection 访问。
        _fetchCoverFromApi: fetchCoverFromApi,
        restrictedCoverChain: restrictedCoverChain
    };
})();
// ==== SGLV-GAME-COLLECTION-INLINE-END ====







// ============================================================================
// PTW（游戏数据浮窗）加载方式
// ============================================================================
// ★ 当前加载方式：远程 @require —— 见头部【B. 浮窗层】
// v2.42.2：PTW 此前内联在本文件里（框架库 + Tab 集库，8,500+ 行 / 480 KB），
//   同时头部又留着两条 @require → 同一份代码下载两遍、解析两遍、同名全局赋值两次。
//   现状：两库已发布到 scriptcat（8427/3.0.0 框架、8430/3.0.0 Tab 集），且与 libs/ 真源
//   逐行一致（verify-remote-deps.js 实测 sha 相同）→ 改为纯远程加载，内联块整体移除。
//   本文件因此减少约 480 KB（-15%）。
//
//   ⚠️ 应急回退（scriptcat 不可达时）：node test-scripts/build-ptw-inline.js
//      会重新生成内联块**并自动停用远程 @require**（两者必须互斥，不能只做一半）。
//      切回远程：node test-scripts/build-ptw-inline.js --remote
//      两种形态都会由 verify-remote-deps.js 的「加载方式互斥」检查守住。
// ============================================================================



(function () {

    'use strict';

 //顶层环境守卫 — 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.32.0 插件版本清单注册（共享宿主 v0.3.0）—— 让 Steam AI Agent 能读到本插件版本号。

    // ⚠️ 共享宿主缺失时静默跳过，绝不影响本插件主流程。

    try {

        var __PH = (typeof unsafeWindow !== 'undefined' && unsafeWindow.__PLUGIN_HOST__)

              || (typeof window !== 'undefined' && window.__PLUGIN_HOST__);

        if (__PH && typeof __PH.registerPlugin === 'function') {

            __PH.registerPlugin({ id: 'sglv', name: 'Steam 游戏库展示', family: 'core' });

        }

    } catch (e) { /* ignore */ }

 //主题层——启动日志移至 init()（需读 storage.getUiTheme，此处尚在 TDZ 之前）

 // ==================== Toast 非阻塞通知系统 ====================
    const sglvToast = {
        _el: null,
        _timer: null,
        _show(msg, type) {
            if (!this._el) {
                this._el = document.createElement('div');
                this._el.id = 'sglv-toast';
                this._el.setAttribute('data-sglv-plugin-ui', '1');
                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'); }
    };

 // ==================== 全局 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;');
    }

 //货币代码→符号映射（参考 steam-family-game-analysis faCurrencySymbol）
 // SGLVAppDetail.loadDetail 用 cc=cn 请求 appdetails，但 Steam 可能对登录用户忽略 cc= 参数，
 // 返回用户实际所在地区的价格(如 INR)，需根据 d.cnPrice.currency 字段选择正确符号，
 // 而非旧代码硬编码的 ¥。置于主作用域，供搜索详情浮窗(_renderDetailContent)直接调用。
 //起优先委托 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()] || '¥';
    }

 // ==================== SGLVCore 依赖注入 ====================
 // @require 外部库加载失败即终止核心功能（无内置降级实现），
 // 不再尝试用内置最小化实现以减少同步成本。
 // 业务代码继续按原 const/function 名字使用,零改动。IDB / 负缓存 / StageProgress /
 // concurrentPool / gmFetch / notifyNetFail 统一来自 sglv-core.lib.js。
    let C = (typeof unsafeWindow !== 'undefined' && unsafeWindow.SGLVCore) || (typeof window !== 'undefined' ? window.SGLVCore : null) || null;

 //SGLVCore 缺失时优雅早退。用户实测场景:ScriptCat(脚本猫)下 @require 的
 // sglv-core.lib.js 拉取失败/被网络拦截 → C === undefined → 原代码 `C.notifyNetFail`
 // 顶层抛 TypeError("Cannot read properties of undefined (reading 'notifyNetFail')"),
 // 整个主 IIFE 崩溃,导航栏菜单/入库按钮全不加载且报错文案看不出根因。
 // 改为:明确的致命日志 + return 早退(不初始化 UI,不产生错误风暴)。
    if (!C) {
        console.error('[SGLV] 致命: SGLVCore 基础库未加载 (@require sglv-core.lib.js 拉取失败或被网络拦截)。脚本本次不初始化 — 请检查脚本管理器外部依赖/网络(可访问 update.greasyfork.org)后刷新重试。');
        return;
    }

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

 //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;

 // ==================== v2.45.0: API Key 同意门 ====================
 // 为什么要这道门（三条纪律）：
 //   ① 开场不催填 —— 首次使用就弹窗催 API Key 属于打扰，v2.45.0 已移除开场引导卡片；
 //   ② 但 Key 是敏感凭据 —— 用户有权在**知道用途与风险**的前提下，自己决定要不要填；
 //   ③ 所以改成「按需触发」：只有当用户点了需要 Key 的功能（拉库存 / 看成就），
 //      才当场把「为什么需要 · 数据流向 · 有无风险」摊开讲，勾选同意后才允许填 Key。
 // 状态机（GM 键 sglv_apikey_consent_v1）：
 //   ''       未判定
 //   'legacy' 存量用户（升级前就在用）→ 直接放行，一个字都不打扰
 //   'agreed' 用户已勾选同意 → 放行
 //   'pending' 全新用户且尚未同意 → 需要 Key 的操作会被门拦住
    const APIKEY_CONSENT_GM_KEY = nsKey('apikey_consent_v1');
    let _apiKeyConsentState = '';
    let _pendingFetchAfterKey = false;   // 同意后送去设置页 → 填好 Key 保存后自动续跑那次加载

    function _readApiKeyConsent() {
        if (!_apiKeyConsentState) {
            try { _apiKeyConsentState = GM_getValue(APIKEY_CONSENT_GM_KEY, '') || ''; } catch (e) { _apiKeyConsentState = ''; }
        }
        return _apiKeyConsentState;
    }
    function _writeApiKeyConsent(v) {
        _apiKeyConsentState = v;
        try { GM_setValue(APIKEY_CONSENT_GM_KEY, v); } catch (e) { /* ignore */ }
    }
 /**
  * 存量用户识别 —— 升级前就在用的老用户不该被同意门拦住。
  * 判据只有一个：**GM 存储里已经存在任意 sglv_* 键**（配过 Key / 换过主题 / 写过缓存）。
  *   · 老用户几乎必然有键（缓存键前缀 sglv_cache_*，配置键 sglv_api_key …）→ 判为 legacy；
  *   · 全新安装一个键都没有 → 判为 pending，走同意门。
  * ⚠️ 只判定一次并落盘：否则新用户自己产生的缓存键会反过来把门「洗掉」——
  *   判定必须发生在**本脚本任何一次 GM 写入之前**，所以这个函数在模块加载期就跑。
  */
    function _initApiKeyConsent() {
        if (_readApiKeyConsent()) return;
        let legacy = false;
        try {
            if (typeof GM_listValues === 'function') {
                const keys = GM_listValues() || [];
                legacy = keys.some(k => typeof k === 'string' && k.indexOf('sglv') === 0);
            }
        } catch (e) { /* ignore */ }
        _writeApiKeyConsent(legacy ? 'legacy' : 'pending');
        console.log('[SGLV] API Key 同意门初始化:', _apiKeyConsentState);
    }
    _initApiKeyConsent();

 /** 是否已获授权（用户勾过同意，或存量用户直接放行） */
    function _hasApiKeyConsent() {
        const s = _readApiKeyConsent();
        return s === 'agreed' || s === 'legacy';
    }

 /**
  * 同意弹窗 —— 把「为什么需要 / 数据流向 / 有无风险」摊开讲，用户勾选同意才放行。
  * @returns {Promise<boolean>} true=同意，false=不同意
  */
    function _openApiKeyConsent() {
        return new Promise((resolve) => {
            const old = document.getElementById('sglv-apikey-consent');
            if (old) { try { old.remove(); } catch (e) { /* ignore */ } }

            const whyZh = [
                'Steam 官方 Web API 要求每个调用方携带一枚属于自己的 Key。没有 Key 就拿不到完整库存、游玩时长、家庭组归属与成就数据，只能退化到不完整的页面抓取。',
                'Key 由 Steam 官方免费发放：<b>steamcommunity.com/dev/apikey</b> → 填一个域名 → 注册，即刻拿到。'
            ];
            const whyEn = [
                'Steam\'s official Web API requires every caller to carry its own key. Without one you only get incomplete page scraping — no full inventory, playtime, family attribution or achievements.',
                'The key is free from Steam: <b>steamcommunity.com/dev/apikey</b> → enter a domain → register.'
            ];
            const riskZh = [
                'Key 只保存在你本机的浏览器脚本存储里（GM 存储），不上传、不跨设备同步。',
                'Key 只会发往 Steam 官方接口 <b>api.steampowered.com</b>。本插件没有服务端，不做任何数据回流，也不会发往任何第三方。',
                '这枚 Key 的权限是「读取公开资料」（库存 / 时长 / 成就 / 公开档案），拿不到密码、邮箱、付款信息，也动不了你的库存资产。',
                '想撤销随时去 <b>steamcommunity.com/dev/apikey</b> 重置，重置后本插件立即失效。',
                '填 Key 是可选的：不填也能继续用，只是部分数据缺失。'
            ];
            const riskEn = [
                'The key is stored only in your own browser (GM storage) — never uploaded, never synced across devices.',
                'It is sent only to Steam\'s official endpoint <b>api.steampowered.com</b>. This script has no server, performs no data backhaul, and never talks to third parties.',
                'Its scope is reading public profile data (library / playtime / achievements / public profile). It cannot read your password, email or payment details, and cannot touch your inventory.',
                'Revoke it any time at <b>steamcommunity.com/dev/apikey</b> — this script stops working immediately.',
                'Configuring a key is optional: you can keep using the script without it, with some data missing.'
            ];
            const listZh = isZh, listEn = !isZh;
            const why = listZh ? whyZh : whyEn;
            const risk = listZh ? riskZh : riskEn;

            const ov = document.createElement('div');
            ov.id = 'sglv-apikey-consent';
            ov.className = 'sglv-apikey-consent';
            ov.setAttribute('data-sglv-plugin-ui', '1');
            ov.innerHTML = `
                <div class="sglv-apikey-consent-card" role="dialog" aria-modal="true">
                    <div class="sglv-apikey-consent-head">
                        <span class="sglv-apikey-consent-title">🔐 ${isZh ? '配置 Steam API Key 前的说明' : 'Before you configure a Steam API Key'}</span>
                        <button class="sglv-apikey-consent-close" title="✕" type="button">✕</button>
                    </div>
                    <div class="sglv-apikey-consent-body">
                        <div class="sglv-apikey-consent-sec">
                            <div class="sglv-apikey-consent-sec-title">${isZh ? '为什么需要' : 'Why it is needed'}</div>
                            ${why.map(t => `<p class="sglv-apikey-consent-p">${t}</p>`).join('')}
                        </div>
                        <div class="sglv-apikey-consent-sec">
                            <div class="sglv-apikey-consent-sec-title">${isZh ? '风险与边界' : 'Risks & boundaries'}</div>
                            <ul class="sglv-apikey-consent-ul">
                                ${risk.map(t => `<li>${t}</li>`).join('')}
                            </ul>
                        </div>
                        <label class="sglv-apikey-consent-check">
                            <input type="checkbox" id="sglv-apikey-consent-check">
                            <span>${isZh ? '我已阅读并理解上述用途与风险，自行配置 API Key' : 'I have read and understood the above purpose and risks, and I choose to configure the key myself'}</span>
                        </label>
                    </div>
                    <div class="sglv-apikey-consent-actions">
                        <button class="sglv-apikey-consent-btn ghost" id="sglv-apikey-consent-no" type="button">${isZh ? '不同意，不配置' : 'Decline'}</button>
                        <button class="sglv-apikey-consent-btn primary" id="sglv-apikey-consent-yes" type="button" disabled>${isZh ? '同意并前往设置' : 'Agree & open settings'}</button>
                    </div>
                </div>`;
            document.body.appendChild(ov);

            const chk = ov.querySelector('#sglv-apikey-consent-check');
            const yes = ov.querySelector('#sglv-apikey-consent-yes');
            const no = ov.querySelector('#sglv-apikey-consent-no');
            const close = ov.querySelector('.sglv-apikey-consent-close');

            let done = false;
            function finish(ok) {
                if (done) return;
                done = true;
                try { ov.remove(); } catch (e) { /* ignore */ }
                try { document.removeEventListener('keydown', onKey); } catch (e) { /* ignore */ }
                resolve(ok);
            }
            function onKey(e) {
                if (e.key === 'Escape') finish(false);
            }
            document.addEventListener('keydown', onKey);
            chk.addEventListener('change', () => { yes.disabled = !chk.checked; });
            yes.addEventListener('click', () => {
                if (!chk.checked) return;
                _writeApiKeyConsent('agreed');
                finish(true);
            });
            no.addEventListener('click', () => finish(false));
            close.addEventListener('click', () => finish(false));
            ov.addEventListener('click', (e) => { if (e.target === ov) finish(false); });
        });
    }

 /** 跳到设置页并聚焦 Steam API Key 输入框 */
    function _openApiKeySettings() {
        // ⚠️ openGlobalSettings 定义在**嵌套 IIFE**（设置/取数区）内 —— 本模块在外层作用域，
        // 直接调用会是 ReferenceError（verify-main-scope.js 会拦）。走 SGLV_API 桥接，
        // 这也正是本仓处理跨闭包访问的既有约定（见 SGLV_API.openGlobalSettings 导出）。
        const openSettings = SGLV_API.openGlobalSettings;
        if (typeof openSettings === 'function') openSettings();
        else showToast(isZh ? '设置页暂不可用，请刷新页面重试' : 'Settings unavailable — please reload');
        setTimeout(() => {
            const el = document.getElementById('sglv-gs-apikey');
            if (el) { try { el.scrollIntoView({ block: 'center' }); el.focus(); } catch (e) { /* ignore */ } }
        }, 80);
    }

 /**
  * 需要 API Key 的操作统一走这道门。
  * 放行规则（三档，缺一不可）：
  *   ① 已有 Key                → 放行；
  *   ② 'legacy' 存量用户       → 放行，**完全保持旧行为**（免 Key 抓取照旧），升级不改变任何东西；
  *   ③ 'agreed' 已同意未填 Key → 放行（用户已拿到授权，剩下的由他决定填不填；免 Key 降级路径仍在）；
  *   ④ 'pending' 全新未同意    → 弹同意门：同意则送去设置页填 Key（填好保存后自动续跑这次加载），
  *                              不同意则**中止加载**，既不给设置入口也不继续取数。
  * @returns {Promise<boolean>} true=可以继续；false=已被门拦住，调用方必须中止后续动作。
  */
    async function _requireApiKeyConsent(opts) {
        opts = opts || {};
        if (storage.getApiKey()) return true;
        const state = _readApiKeyConsent();
        if (state === 'legacy' || state === 'agreed') return true;
        const ok = await _openApiKeyConsent();
        if (!ok) {
            showToast(isZh ? '未同意配置 API Key，已停止加载数据' : 'Consent declined — data loading stopped');
            return false;
        }
 // 已同意 → 送去设置页填 Key；填好保存后自动续跑这一次加载
        _pendingFetchAfterKey = !!opts.thenFetch;
        _openApiKeySettings();
        return false;
    }

 // ----- 捆绑包数据库 GM 缓存键 -----
 // v2.42.2：从 SGLV 子闭包（21920 IIFE）提升到主闭包顶层。
 //   原先定义在子闭包内，而主闭包的 init() 要用它清理旧版本缓存 → 跨闭包引用
 //   → ReferenceError 被空 catch 吞掉 → CACHE_VERSION.bundle_db 升级到 2 时
 //   旧 GM v2 缓存**不会被失效**（版本号升了但缓存没清）。
    const BUNDLE_DB_CACHE_KEY_V2 = nsKey('bundle_db_cache_v2');  // { data, appIds, all, timestamp }

 // ----- 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;

 // ==================== 通用 UI 组件函数 ====================
 //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>`;
    }

 //阶段条段生成器——自 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>`;
    }

 //加载态工厂扩展——单一加载态入口,opts 全部可选
 // 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
 //数据升级 game-db-v1.2.json——光荣特库摩重编为 19 个系列分类（数据源小黑盒帖子），
 // 游戏条目新增可选 genres 字段（Steam appdetails 类型标签），由收藏模块 渲染展示
    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 {}; }
    })();

    // v2.42.2 性能修复：绝版游戏库改为**惰性解析**。
    //   原先是顶层 IIFE：脚本求值期就 JSON.parse(GM_getResourceText('delistedData'))，
    //   而该 @resource 实测 3.46 MiB —— 解析一次 ≈ 6~21 ms + 约 10 MB 堆，
    //   且这份数据**只有用户打开「绝版游戏」面板时才用得上**（唯一消费点是
    //   Host.getDelistedDb()）。改成惰性 getter：首屏不再背这笔账。
    let _sglvDelistedDbCache = null;
    function _getDelistedDb() {
        if (_sglvDelistedDbCache !== null) return _sglvDelistedDbCache;
        try {
            _sglvDelistedDbCache = JSON.parse(GM_getResourceText('delistedData') || '{}');
        } catch (e) {
            console.warn('[SGLV] DELISTED_DB 加载失败:', e);
            _sglvDelistedDbCache = {};
        }
        return _sglvDelistedDbCache;
    }

 // ==================== 游戏系列数据（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';
 //互动影游数据源（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';
 //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';
 //独立系列库 { seriesName: [{id, name, date}] }，与 GAME_DB（供应商）分开展示
    let seriesDb = {};
 //最近一次成功拉取/缓存的合并原始数据——某一数据源失败时，
 // 从内存兜底恢复，避免系列侧边栏因单源失败而塌缩/丢系列
    let _lastSeriesRaw = null;
 //供应商数据远程覆盖（运行时检查 @resource gameDb 远程版本，有更新时覆盖 GAME_DB）
    const GAME_DB_REMOTE_URL = 'https://fastly.jsdelivr.net/gh/SmallRob/steam-namespace@main/data/game-db-v1.2.json';
 //供应商数据 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,
 //保留数据源 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;
    }

 /**
 *合并系列数据源——互动影游数据（扁平数组）作为独立"互动影游"系列并入 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 };
    }

 /**
 *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);
    }

 /**
 *计算系列数据内容签名（用于检测远程数据是否有变化）
 *签名从"系列数:游戏总数"粗粒度升级为逐系列 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';
    }

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

 /**
 *收藏分类数据源抓取——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);
        }
    }

 /**
 * 异步加载游戏系列数据（带缓存，先读缓存同步分组，再后台拉取最新）
 *添加 force 参数 + 内容签名比较，避免无变化时重复写缓存/派发事件
 *force 时先移出过期缓存，返回结果状态 { status: 'updated'|'nochange'|'error', msg }
 *缓存策略重写——
 * ① force 不再先删缓存：拉取失败时旧缓存原样保留（此前先删后拉，失败即丢缓存，
 * 内存兜底 _lastSeriesRaw 页面刷新后即失效）
 * ② 拉取成功且签名变化时 cacheSet 覆盖写缓存（旧版本缓存被新版本替换）
 * ③ force 附加时间戳绕 CDN 边缘缓存 + raw.githubusercontent 回退，确保拿到最新分类数据
 * @param {boolean} force - 强制刷新（跳过缓存读取，始终拉取远程数据，绕 CDN 缓存）
 * @param {function} onProgress - (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. 拉取最新远程数据（game_series.json 与 steam_vediogame_selected.json 并行，
 // 互动影游并入同一 seriesDb，共享缓存/签名/事件管线，更新逻辑与既有系列完全一致；
 // 网络层统一走 SGLVCore gmFetchJson（自动重试 + 状态码校验 + JSON 解析），
 //失败回退 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) {
 //内存兜底随每次成功拉取更新（后续单源失败时可用）
                _lastSeriesRaw = data;
 //内容签名比较——签名相同时仅刷新TTL，不派发事件（避免不必要的UI重渲染）
 //签名为逐系列 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}` };
        }
    }

 /**
 *异步加载供应商数据（远程版本检查，有更新时覆盖 @resource GAME_DB）
 *force 时先移出过期缓存，返回结果状态 { status: 'updated'|'nochange'|'error', msg }
 *缓存策略与系列数据同步重写——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}` };
        }
    }

 /** 计算供应商数据内容签名（供应商数:游戏总数） */
    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>`,
        download: `<svg ${_S}><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>`,
        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>`,
 //家庭共享图标（双人群组,用于愿望单家庭共享标签）
        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>`,
 //即将发售 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>`,
 //横板封面视图图标（宽横幅卡片）
        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>`,
 //PlayStation 四符号图标（三角/圆/叉/方）用于 PS 会免标签页
 //真实 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>`,
 //Epic 赠送标签页图标（"E" 字形）
 //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>`,
 //集换式卡牌图标
        card: `<svg ${_S}><rect x="3" y="6" width="18" height="13" rx="2"/><line x1="3" y1="11" x2="21" y2="11"/></svg>`,
 //年度大作标签页图标（奖杯）
        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>`,
 //资料受限图标（用户轮廓 + 警告三角）
        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>`,
 //我的成就标签页图标（奖杯 + 星芒）
        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>`,
 //云存档标签页图标（云+下载箭头）
        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>`,
 //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>`,
 //全局搜索图标（放大镜）
        search: `<svg ${_S}><circle cx="11" cy="11" r="7"/><line x1="21" y1="21" x2="16.65" y2="16.65"/></svg>`,
 //主题层——外观设置卡调色板图标
        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>`,
 //搜索结果跳转图标（外链箭头）
        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>`,
 //个人展柜标签页图标（展柜/陈列窗）
        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>`,
 //展柜编辑图标（铅笔）
        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>`,
 //徽章图标（六角勋章 + 飘带）
        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 样式 ====================
 //CSS 经 @require 外部库 sglv-shared-css 加载，库未加载时为空字符串（UI 无样式但功能可用）
    const CSS_STYLES = (typeof window.SGLVSharedCSS === 'string' && window.SGLVSharedCSS) || '';
    GM_addStyle(CSS_STYLES);

 // ==================== 分散 CSS 集中提取 ====================
 // GM_addStyle(`...`) 块统一提取为命名常量,
 // 一次性合并注入(CSS_INLINE)。

    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; }

 /*用户信息区 — 参考设计渐变背景+径向光晕 */
    .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; }

 /*分类导航 — 参考设计图标背景+激活渐变 */
    .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; }

 /*侧边栏最近解锁 — 参考设计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; }

 /*统计概览区 — 参考设计玻璃态容器 */
    .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: 8px; color: #64748b; margin-top: 2px; letter-spacing: 0.02em; white-space: nowrap; }
 /* === 成就 KPI 卡片复用 sglv-playtime-kpi-card 统一风格 === */
    .sglv-ach-kpi-row { display: grid; grid-template-columns: repeat(4, 1fr); gap: 8px; flex: 1; min-width: 0; }
    /* ====== v2.44.0：Hero 总览（真实口径） + 游戏成就矩阵 + 自定义徽章架 ====== */
    .sglv-ach-header-v2 { flex-direction: column; align-items: stretch; gap: 12px; padding: 16px 24px 14px; }
    .sglv-ach-hero-top { display: flex; align-items: center; gap: 20px; }
    .sglv-ach-kpi-row-6 { grid-template-columns: repeat(6, minmax(0, 1fr)); }
    .sglv-ach-hero-strip { display: flex; align-items: center; gap: 22px; flex-wrap: wrap; padding-top: 10px; border-top: 1px solid rgba(48,54,61,0.45); }
    .sglv-ach-hero-item { display: flex; align-items: baseline; gap: 7px; font-size: 11px; min-width: 0; }
    .sglv-ach-hero-item .lbl { color: #6e7681; font-weight: 600; white-space: nowrap; }
    .sglv-ach-hero-item .val { color: #e6edf3; font-weight: 700; font-size: 12px; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; max-width: 280px; }
    .sglv-ach-nav-item-icon { color: #a5b4fc; }
    .sglv-ach-sidebar-recent-dot { width: 8px; height: 8px; border-radius: 50%; flex-shrink: 0; margin: 0 4px; }
    /* 子视图切换（游戏成就 / 聚合分析） */
    .sglv-ach-subview { display: none; }
    .sglv-ach-subview.active { display: block; }
    /* 游戏成就矩阵 —— v2.44.0 新增的主视图 */
    .sglv-ach-matrix { display: flex; flex-direction: column; gap: 6px; }
    /* 空态卡片 —— 空态必须读成「下一步做什么」，不能只给一行淡灰小字 */
    .sglv-ach-empty-card { padding: 24px 20px; border-radius: 14px; background: rgba(13,17,23,0.5); border: 1px dashed rgba(74,85,104,0.7); text-align: center; }
    .sglv-ach-empty-title { font-size: 13.5px; font-weight: 700; color: #c9d1d9; margin-bottom: 6px; }
    .sglv-ach-empty-hint { font-size: 11.5px; color: #8b949e; line-height: 1.7; }
    .sglv-ach-empty-cta { margin-top: 14px; padding: 8px 20px; border-radius: 10px; border: 1px solid rgba(34,211,238,0.42); background: rgba(34,211,238,0.12); color: #67e8f9; font-size: 12px; font-weight: 700; cursor: pointer; transition: all 0.15s; font-family: inherit; }
    .sglv-ach-empty-cta:hover { background: rgba(34,211,238,0.22); border-color: rgba(34,211,238,0.65); }
    .sglv-ach-matrix-row { display: flex; align-items: center; gap: 12px; padding: 9px 12px; border-radius: 10px; background: rgba(13,17,23,0.45); border: 1px solid rgba(48,54,61,0.45); transition: background 0.15s, border-color 0.15s; cursor: pointer; }
    .sglv-ach-matrix-row:hover { background: rgba(34,211,238,0.07); border-color: rgba(34,211,238,0.32); }
    .sglv-ach-matrix-row:focus-visible { outline: 2px solid rgba(34,211,238,0.6); outline-offset: 1px; }
    /* v2.44.2：矩阵工具栏（借鉴游戏收藏模块的「完成度 / 排序 / 视图」工具栏） */
    .sglv-ach-mx { display: flex; flex-direction: column; gap: 10px; }
    .sglv-ach-mx-toolbar { display: flex; align-items: center; gap: 10px; flex-wrap: wrap; }
    .sglv-ach-mx-group { display: flex; align-items: center; gap: 3px; padding: 3px; border-radius: 9px; background: rgba(13,17,23,0.5); border: 1px solid rgba(48,54,61,0.6); }
    .sglv-ach-mx-seg { padding: 5px 11px; border-radius: 7px; border: none; background: transparent; color: #8b949e; font-size: 11.5px; font-weight: 700; cursor: pointer; transition: all 0.15s; font-family: inherit; white-space: nowrap; }
    .sglv-ach-mx-seg:hover { color: #e6edf3; background: rgba(99,102,241,0.12); }
    .sglv-ach-mx-seg.active { color: #fff; background: linear-gradient(135deg, rgba(34,211,238,0.2), rgba(99,102,241,0.18)); box-shadow: inset 0 1px 0 rgba(255,255,255,0.06); }
    .sglv-ach-mx-search { flex: 1; min-width: 130px; max-width: 260px; padding: 6px 12px; border-radius: 9px; border: 1px solid rgba(48,54,61,0.7); background: rgba(13,17,23,0.55); color: #e6edf3; font-size: 12px; outline: none; font-family: inherit; }
    .sglv-ach-mx-search:focus { border-color: rgba(34,211,238,0.5); }
    .sglv-ach-mx-search::placeholder { color: #6e7681; }
    .sglv-ach-mx-meta { font-size: 11px; color: #6e7681; }
    /* 列表行：游戏封面缩略图（capsule 231x87 比例） */
    .sglv-ach-matrix-ico { width: 92px; height: 34px; flex-shrink: 0; border-radius: 6px; overflow: hidden; background: rgba(13,17,23,0.6); }
    .sglv-ach-matrix-ico img { width: 100%; height: 100%; object-fit: cover; display: block; }
    /* 卡片视图 */
    .sglv-ach-mx-cards { display: grid; grid-template-columns: repeat(auto-fill, minmax(150px, 1fr)); gap: 12px; }
    .sglv-ach-mx-card { display: flex; flex-direction: column; gap: 6px; padding: 8px; border-radius: 12px; background: rgba(13,17,23,0.5); border: 1px solid rgba(48,54,61,0.5); cursor: pointer; transition: background 0.15s, border-color 0.15s; }
    .sglv-ach-mx-card:hover { background: rgba(34,211,238,0.06); border-color: rgba(34,211,238,0.3); }
    .sglv-ach-mx-card:focus-visible { outline: 2px solid rgba(34,211,238,0.6); outline-offset: 1px; }
    .sglv-ach-mx-card-cover { width: 100%; aspect-ratio: 2 / 3; border-radius: 8px; overflow: hidden; background: rgba(13,17,23,0.7); }
    .sglv-ach-mx-card-cover img { width: 100%; height: 100%; object-fit: cover; display: block; }
    .sglv-ach-mx-card-name { font-size: 12px; font-weight: 600; color: #e6edf3; line-height: 1.35; max-height: 33px; overflow: hidden; }
    .sglv-ach-mx-card-bar { height: 4px; border-radius: 3px; background: rgba(48,54,61,0.7); overflow: hidden; }
    .sglv-ach-mx-card-bar i { display: block; height: 100%; background: linear-gradient(90deg, #22d3ee, #6366f1); border-radius: 3px; }
    .sglv-ach-mx-card-meta { font-size: 10px; color: #8b949e; }
    .sglv-ach-mx-card .sglv-ach-matrix-tags { justify-content: flex-start; margin-top: 2px; }
    .sglv-ach-matrix-ring { position: relative; width: 38px; height: 38px; flex-shrink: 0; }
    .sglv-ach-matrix-ring svg { width: 100%; height: 100%; transform: rotate(-90deg); }
    .sglv-ach-matrix-ring .bg { fill: none; stroke: rgba(99,102,241,0.15); stroke-width: 3; }
    .sglv-ach-matrix-ring .fill { fill: none; stroke: url(#ach-ring-grad) #22d3ee; stroke-width: 3; stroke-linecap: round; }
    .sglv-ach-matrix-ring-t { position: absolute; inset: 0; display: flex; align-items: center; justify-content: center; font-size: 10px; font-weight: 700; color: #e6edf3; }
    .sglv-ach-matrix-info { flex: 1; min-width: 0; }
    .sglv-ach-matrix-name { font-size: 13px; font-weight: 600; color: #e6edf3; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
    .sglv-ach-matrix-meta { font-size: 11px; color: #8b949e; margin-top: 2px; }
    .sglv-ach-matrix-tags { display: flex; align-items: center; gap: 6px; flex-shrink: 0; flex-wrap: wrap; justify-content: flex-end; }
    .sglv-ach-matrix-tag { font-size: 9px; font-weight: 700; padding: 2px 7px; border-radius: 5px; letter-spacing: 0.04em; white-space: nowrap; }
    .sglv-ach-matrix-tag.perfect { background: rgba(63,185,80,0.16); color: #3fb950; }
    .sglv-ach-matrix-tag.rare { background: rgba(168,85,247,0.16); color: #c084fc; }
    .sglv-ach-matrix-tag.done { background: rgba(251,191,36,0.14); color: #fbbf24; }
    .sglv-ach-matrix-tag.muted { background: rgba(110,118,129,0.18); color: #8b949e; }
    /* 自定义成就徽章架（弱化后的位置：页面底部、可折叠） */
    .sglv-ach-shelf { flex-shrink: 0; border-top: 1px solid rgba(48,54,61,0.5); background: rgba(13,17,23,0.5); }
    .sglv-ach-shelf-head { display: flex; align-items: center; gap: 10px; width: 100%; padding: 10px 24px; background: none; border: none; cursor: pointer; text-align: left; color: #8b949e; font-family: inherit; }
    .sglv-ach-shelf-head:hover { background: rgba(99,102,241,0.06); }
    .sglv-ach-shelf-title { font-size: 12px; font-weight: 700; color: #c9d1d9; }
    .sglv-ach-shelf-summary { font-size: 11px; color: #6e7681; flex: 1; }
    .sglv-ach-shelf-caret { font-size: 11px; color: #8b949e; }
    .sglv-ach-shelf-body { padding: 0 24px 14px; display: none; }
    .sglv-ach-shelf.open .sglv-ach-shelf-body { display: block; }
    .sglv-ach-shelf-grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(104px, 1fr)); gap: 8px; }
    .sglv-ach-badge { display: flex; flex-direction: column; align-items: center; gap: 4px; padding: 8px 6px; border-radius: 10px; background: rgba(13,17,23,0.5); border: 1px solid rgba(48,54,61,0.4); opacity: 0.5; }
    .sglv-ach-badge.on { opacity: 1; border-color: rgba(99,102,241,0.35); }
    .sglv-ach-badge-icon { width: 40px; height: 40px; }
    .sglv-ach-badge-icon svg { width: 100%; height: 100%; }
    .sglv-ach-badge-name { font-size: 10px; color: #c9d1d9; text-align: center; line-height: 1.3; max-height: 26px; overflow: hidden; }
    .sglv-ach-badge-bar { width: 100%; height: 3px; border-radius: 2px; background: rgba(48,54,61,0.7); overflow: hidden; }
    .sglv-ach-badge-bar i { display: block; height: 100%; background: linear-gradient(90deg, #22d3ee, #6366f1); border-radius: 2px; }
    .sglv-ach-shelf-foot { display: flex; align-items: center; gap: 12px; margin-top: 10px; font-size: 10px; color: #6e7681; }
    .sglv-ach-shelf-foot span { flex: 1; }
    @media (max-width: 900px) {
        .sglv-ach-kpi-row-6 { grid-template-columns: repeat(3, minmax(0, 1fr)); }
    }
    @media (max-width: 720px) {
        .sglv-ach-header-v2 { padding: 12px 14px 10px; }
        .sglv-ach-hero-top { flex-direction: column; align-items: stretch; gap: 12px; }
        .sglv-ach-shelf-head, .sglv-ach-shelf-body { padding-left: 14px; padding-right: 14px; }
    }
    .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); }

 /*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; }

 /*成就内容区 — 参考设计容器圆角 */
    .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; }

 /* ====== 主视图切换：Steam 成就 / 自定义成就 ====== */
    .sglv-ach-switch { display: flex; align-items: center; gap: 8px; flex-wrap: wrap; padding: 12px 24px 0; flex-shrink: 0; }
    .sglv-ach-switch-btn { display: inline-flex; align-items: center; gap: 7px; padding: 7px 14px; border-radius: 10px; border: 1px solid rgba(48,54,61,0.8); background: rgba(13,17,23,0.55); color: #8b949e; font-size: 12px; font-weight: 700; cursor: pointer; transition: all 0.16s; }
    .sglv-ach-switch-btn:hover { color: #e6edf3; border-color: rgba(99,102,241,0.4); }
    .sglv-ach-switch-btn.active { color: #e6edf3; background: linear-gradient(135deg, rgba(34,211,238,0.16), rgba(99,102,241,0.14)); border-color: rgba(34,211,238,0.5); box-shadow: inset 0 1px 0 rgba(255,255,255,0.06); }
    .sglv-ach-switch-btn b { font-size: 10px; font-weight: 700; padding: 1px 6px; border-radius: 6px; background: rgba(148,163,184,0.16); color: #94a3b8; }
    .sglv-ach-switch-btn.active b { background: rgba(34,211,238,0.24); color: #a5f3fc; }
 /* 两个视图各自独立滚动：切标签不重建 DOM，也不丢滚动位置 */
    .sglv-ach-tracks { flex: 1; min-height: 0; display: flex; flex-direction: column; }
    .sglv-ach-track { flex: 1; min-height: 0; overflow-y: auto; display: none; }
    .sglv-ach-track.active { display: block; }
    .sglv-ach-track-steam { padding: 14px 24px 16px; }
    .sglv-ach-track-custom > .sglv-ach-content { flex: none; height: auto; overflow: visible; }
    .sglv-ach-track::-webkit-scrollbar { width: 8px; }
    .sglv-ach-track::-webkit-scrollbar-thumb { background: rgba(99,102,241,0.32); border-radius: 4px; }
    @media (max-width: 720px) {
        .sglv-ach-switch { padding: 10px 14px 0; }
        .sglv-ach-track-steam { padding: 12px 14px 14px; }
    }

 /* ===== ACH-DEEP-CSS:BEGIN ===== 真实成就（S1 数据层 + S2/S3/S4/S5 深度面板）
    这段 CSS 会被 test-scripts/build-preview.js 原样抽到本地预览页，改样式只改这里 ===== */
 /*真实成就区块 — 与自定义成就并列的第二轨（S1 数据层）*/
    .sglv-ach-real { margin-bottom: 16px; padding: 14px 18px; border-radius: 14px; background: linear-gradient(135deg, rgba(15,23,42,0.72), rgba(30,41,59,0.42)); border: 1px solid rgba(34,211,238,0.18); }
    .sglv-ach-real-head { display: flex; align-items: center; justify-content: space-between; gap: 12px; margin-bottom: 12px; }
    .sglv-ach-real-title { font-size: 14px; font-weight: 700; color: #e6edf3; display: flex; align-items: center; gap: 8px; }
    .sglv-ach-real-tag { font-size: 9px; font-weight: 700; padding: 2px 6px; border-radius: 5px; background: rgba(34,211,238,0.15); color: #22d3ee; letter-spacing: 0.05em; }
    .sglv-ach-real-sub { font-size: 11px; color: #8b949e; text-align: right; }
    .sglv-ach-real-kpis { display: grid; grid-template-columns: repeat(4, 1fr); gap: 10px; }
    .sglv-ach-real-kpi { padding: 9px 12px; border-radius: 10px; background: rgba(13,17,23,0.55); border: 1px solid rgba(48,54,61,0.5); min-width: 0; }
    .sglv-ach-real-kpi-v { font-size: 19px; font-weight: 700; color: #e6edf3; line-height: 1.2; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
    .sglv-ach-real-kpi-l { font-size: 10px; color: #8b949e; margin-top: 3px; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
    .sglv-ach-real-kpi.gold .sglv-ach-real-kpi-v { color: #fbbf24; }
    .sglv-ach-real-kpi.cyan .sglv-ach-real-kpi-v { color: #22d3ee; }
    .sglv-ach-real-kpi.violet .sglv-ach-real-kpi-v { color: #a78bfa; }
    .sglv-ach-real-bar { height: 6px; border-radius: 4px; background: rgba(48,54,61,0.6); overflow: hidden; margin-top: 12px; }
    .sglv-ach-real-bar > div { height: 100%; background: linear-gradient(90deg, #22d3ee, #6366f1); border-radius: 4px; transition: width 0.3s; }
    .sglv-ach-real-foot { display: flex; align-items: center; justify-content: space-between; gap: 12px; margin-top: 10px; flex-wrap: wrap; }
    .sglv-ach-real-hint { font-size: 10px; color: #6e7681; line-height: 1.5; min-width: 0; }
    .sglv-ach-real-actions { display: flex; align-items: center; gap: 8px; flex-shrink: 0; }
    .sglv-ach-real-btn { padding: 6px 14px; border-radius: 8px; border: 1px solid rgba(34,211,238,0.35); background: rgba(34,211,238,0.12); color: #67e8f9; font-size: 11px; font-weight: 700; cursor: pointer; transition: all 0.15s; flex-shrink: 0; white-space: nowrap; }
    .sglv-ach-real-btn:hover:not(:disabled) { background: rgba(34,211,238,0.22); border-color: rgba(34,211,238,0.55); }
    .sglv-ach-real-btn:disabled { opacity: 0.45; cursor: default; }
    .sglv-ach-real-btn.ghost { border-color: rgba(148,163,184,0.28); background: rgba(148,163,184,0.08); color: #94a3b8; }
    .sglv-ach-real-btn.ghost:hover:not(:disabled) { background: rgba(148,163,184,0.16); border-color: rgba(148,163,184,0.45); color: #cbd5e1; }
    .sglv-ach-real-hint.sglv-ach-real-loading { color: #22d3ee; animation: sglv-ach-pulse 2s ease-in-out infinite; }
    @keyframes sglv-ach-pulse { 0%,100% { opacity:1; } 50% { opacity:0.6; } }


 /*真实成就 · 深度面板（S2 完美墙 / S3 稀有收藏 / S4 缺口）*/
    .sglv-ach-deep { margin-bottom: 16px; padding: 14px 18px 16px; border-radius: 14px; background: linear-gradient(135deg, rgba(15,23,42,0.62), rgba(30,41,59,0.34)); border: 1px solid rgba(99,102,241,0.16); }
    .sglv-ach-deep-head { display: flex; align-items: center; justify-content: space-between; gap: 12px; flex-wrap: wrap; margin-bottom: 12px; }
    .sglv-ach-deep-tabs { display: flex; gap: 6px; flex-wrap: wrap; }
    .sglv-ach-deep-tab { display: inline-flex; align-items: center; gap: 6px; padding: 6px 12px; border-radius: 9px; border: 1px solid rgba(48,54,61,0.8); background: rgba(13,17,23,0.5); color: #8b949e; font-size: 11.5px; font-weight: 600; cursor: pointer; transition: all 0.15s; }
    .sglv-ach-deep-tab:hover { color: #e6edf3; border-color: rgba(99,102,241,0.4); }
    .sglv-ach-deep-tab.active { color: #e6edf3; background: rgba(99,102,241,0.16); border-color: rgba(129,140,248,0.55); box-shadow: inset 0 1px 0 rgba(255,255,255,0.06); }
    .sglv-ach-deep-tab b { font-size: 10px; font-weight: 700; padding: 1px 6px; border-radius: 6px; background: rgba(148,163,184,0.16); color: #94a3b8; }
    .sglv-ach-deep-tab.active b { background: rgba(129,140,248,0.28); color: #c7d2fe; }
    .sglv-ach-deep-hunter { display: flex; align-items: baseline; gap: 8px; padding: 5px 12px; border-radius: 9px; background: linear-gradient(135deg, rgba(251,191,36,0.14), rgba(244,63,94,0.1)); border: 1px solid rgba(251,191,36,0.32); }
    .sglv-ach-deep-hunter-l { font-size: 10px; color: #d6bc8a; letter-spacing: 0.04em; }
    .sglv-ach-deep-hunter-v { font-size: 17px; font-weight: 800; color: #fbbf24; line-height: 1; }
    .sglv-ach-deep-body { min-height: 60px; }
    .sglv-ach-sec { display: flex; align-items: center; gap: 8px; margin: 0 0 8px; font-size: 11px; font-weight: 700; color: #8b949e; letter-spacing: 0.03em; }
    .sglv-ach-sec b { font-size: 10px; padding: 1px 6px; border-radius: 6px; background: rgba(148,163,184,0.14); color: #94a3b8; font-weight: 700; }
    .sglv-ach-sec + .sglv-ach-wall, .sglv-ach-sec + .sglv-ach-list { margin-bottom: 14px; }
    .sglv-ach-empty { padding: 18px 4px; font-size: 11.5px; color: #6e7681; line-height: 1.7; }

 /*完美通关墙 — 卡片网格*/
    .sglv-ach-wall { display: grid; grid-template-columns: repeat(auto-fill, minmax(206px, 1fr)); gap: 9px; }
    .sglv-ach-wall-card { position: relative; text-align: left; padding: 11px 13px 12px; border-radius: 11px; border: 1px solid rgba(48,54,61,0.7); background: linear-gradient(135deg, rgba(13,17,23,0.72), rgba(30,41,59,0.3)); cursor: pointer; transition: all 0.16s; overflow: hidden; font-family: inherit; color: inherit; }
    .sglv-ach-wall-card::before { content: ''; position: absolute; inset: 0 auto 0 0; width: 3px; background: var(--tw, #6366f1); opacity: 0.85; }
    .sglv-ach-wall-card:hover { transform: translateY(-2px); border-color: rgba(129,140,248,0.5); box-shadow: 0 10px 26px rgba(0,0,0,0.36); }
    .sglv-ach-wall-top { display: flex; align-items: center; justify-content: space-between; gap: 8px; margin-bottom: 5px; }
    .sglv-ach-wall-name { flex: 1; min-width: 0; font-size: 12.5px; font-weight: 700; color: #e6edf3; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
    .sglv-ach-game-ico { width: 48px; height: 22px; object-fit: cover; object-position: center; border-radius: 4px; flex-shrink: 0; display: block; background: rgba(255,255,255,0.06); }
    .sglv-ach-wall-card .sglv-ach-game-ico { width: 36px; height: 36px; border-radius: 6px; }
    .sglv-ach-wall-badge { flex-shrink: 0; font-size: 9px; font-weight: 800; padding: 2px 6px; border-radius: 5px; color: var(--tw, #6366f1); background: color-mix(in srgb, var(--tw, #6366f1) 16%, transparent); border: 1px solid color-mix(in srgb, var(--tw, #6366f1) 38%, transparent); letter-spacing: 0.04em; }
    .sglv-ach-wall-sub { font-size: 10px; color: #8b949e; }
    .sglv-ach-wall-ach { margin-top: 5px; font-size: 10.5px; color: #6e7681; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }

 /*稀有度分桶条形*/
    .sglv-ach-buckets { display: grid; gap: 6px; margin-bottom: 14px; }
    .sglv-ach-bucket { display: grid; grid-template-columns: 44px 1fr 74px; align-items: center; gap: 10px; font-size: 10.5px; }
    .sglv-ach-bucket-l { color: var(--bc, #94a3b8); font-weight: 700; }
    .sglv-ach-bucket-bar { height: 8px; border-radius: 5px; background: rgba(48,54,61,0.55); overflow: hidden; position: relative; }
    .sglv-ach-bucket-bar > i { position: absolute; inset: 0 auto 0 0; min-width: 2px; background: color-mix(in srgb, var(--bc, #94a3b8) 70%, transparent); border-radius: 5px; }
    .sglv-ach-bucket-c { color: #8b949e; text-align: right; font-variant-numeric: tabular-nums; }
    .sglv-ach-bucket-c b { color: #e6edf3; }

 /*稀有列表 / 缺口列表 — 通用行*/
    .sglv-ach-list { display: grid; gap: 4px; }
    .sglv-ach-row { display: grid; grid-template-columns: 8px 48px 1fr auto; align-items: center; gap: 10px; width: 100%; padding: 7px 10px; border-radius: 8px; border: 1px solid transparent; background: rgba(13,17,23,0.42); cursor: pointer; text-align: left; font-family: inherit; color: inherit; transition: all 0.13s; }
    .sglv-ach-row:hover { background: rgba(30,41,59,0.66); border-color: rgba(99,102,241,0.32); }
    .sglv-ach-row-dot { width: 8px; height: 8px; border-radius: 50%; background: var(--dc, #94a3b8); box-shadow: 0 0 7px color-mix(in srgb, var(--dc, #94a3b8) 55%, transparent); }
    .sglv-ach-row-main { min-width: 0; }
    /* 这两个是 <span>，必须显式块级化：否则成就名与游戏名会挤在同一行、互相切断 */
    .sglv-ach-row-t { display: block; font-size: 11.5px; color: #d8e0e8; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
    .sglv-ach-row-s { display: block; font-size: 10px; color: #6e7681; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; margin-top: 1px; }
    .sglv-ach-row-p { font-size: 11.5px; font-weight: 700; color: var(--dc, #94a3b8); font-variant-numeric: tabular-nums; white-space: nowrap; }
    .sglv-ach-row-p small { font-size: 9px; font-weight: 600; color: #6e7681; margin-left: 2px; }

 /*成就详情弹窗（S5）*/
    .sglv-ach-modal { position: fixed; inset: 0; z-index: 2147483000; display: flex; align-items: center; justify-content: center; padding: 24px; }
    .sglv-ach-modal-mask { position: absolute; inset: 0; background: rgba(2,6,14,0.74); backdrop-filter: blur(4px); }
    .sglv-ach-modal-panel { position: relative; width: min(680px, 100%); max-height: min(78vh, 720px); display: flex; flex-direction: column; border-radius: 16px; background: linear-gradient(160deg, rgba(17,24,39,0.98), rgba(11,15,25,0.99)); border: 1px solid rgba(99,102,241,0.28); box-shadow: 0 24px 70px rgba(0,0,0,0.6); overflow: hidden; animation: sglv-ach-modal-in 0.16s ease-out; }
    @keyframes sglv-ach-modal-in { from { opacity: 0; transform: translateY(10px) scale(0.985); } to { opacity: 1; transform: none; } }
    .sglv-ach-modal-head { display: flex; align-items: flex-start; justify-content: space-between; gap: 14px; padding: 16px 18px 13px; border-bottom: 1px solid rgba(48,54,61,0.6); }
    .sglv-ach-modal-title { display: flex; align-items: center; gap: 8px; font-size: 15px; font-weight: 800; color: #e6edf3; margin-bottom: 4px; }
    .sglv-ach-modal-title .sglv-ach-game-ico { width: 64px; height: 30px; }
    .sglv-ach-modal-sub { font-size: 11px; color: #8b949e; }
    .sglv-ach-modal-sub b { color: #22d3ee; font-weight: 700; }
    .sglv-ach-modal-close { flex-shrink: 0; width: 26px; height: 26px; border-radius: 8px; border: 1px solid rgba(48,54,61,0.8); background: rgba(13,17,23,0.6); color: #8b949e; font-size: 15px; line-height: 1; cursor: pointer; transition: all 0.14s; }
    .sglv-ach-modal-close:hover { color: #e6edf3; border-color: rgba(239,68,68,0.45); background: rgba(239,68,68,0.12); }
    .sglv-ach-modal-body { padding: 10px 14px 16px; overflow-y: auto; overscroll-behavior: contain; }
    .sglv-ach-modal-body::-webkit-scrollbar { width: 8px; }
    .sglv-ach-modal-body::-webkit-scrollbar-thumb { background: rgba(99,102,241,0.32); border-radius: 4px; }
    .sglv-ach-mrow { display: grid; grid-template-columns: 8px 1fr auto; align-items: center; gap: 10px; padding: 8px 10px; border-radius: 8px; }
    .sglv-ach-mrow:nth-child(odd) { background: rgba(30,41,59,0.3); }
    .sglv-ach-mrow.off .sglv-ach-row-t { color: #6e7681; }
    .sglv-ach-mrow.off .sglv-ach-row-dot { opacity: 0.42; }
    .sglv-ach-mrow-p { font-size: 11px; font-weight: 700; color: var(--dc, #94a3b8); font-variant-numeric: tabular-nums; white-space: nowrap; }
    .sglv-ach-mrow-p small { font-size: 9px; color: #6e7681; font-weight: 600; margin-left: 3px; }
    @media (max-width: 720px) {
        .sglv-ach-real-kpis { grid-template-columns: repeat(2, 1fr); }
        .sglv-ach-deep-head { align-items: flex-start; }
        .sglv-ach-bucket { grid-template-columns: 38px 1fr 64px; }
        .sglv-ach-modal { padding: 12px; }
    }
 /* ===== ACH-DEEP-CSS:END ===== */

 /*成就卡片 — 参考设计稀有度左边框+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; }
 /*图标 — 参考设计渐变背景+内阴影+光泽叠加 */
    .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; }
 /*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; }
 /*点数徽章 — 参考设计渐变背景 */
    .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; }
 /*进度条 — 参考设计微光动画 */
    .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;
    }

 /*骨架屏样式 — 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; }

 /* ====== 英雄区徽章展示区 ====== */
    .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; }

 /* ====== 徽章选择器弹窗 ====== */
    .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 卡片（炫彩边框 + 色彩变体） ====== */
 /* === 云存档 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; }

 /* ====== 分布图 ====== */
 /*大小分布 + 文件数分布 并排两栏 */
    .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); }
 /*通用 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;             /* 整个 header 作为拖动手柄 */
        user-select: none;
    }
    .sglv-panel > .sglv-header h2 { display: none !important; }

 /* === 保留最左侧 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 按钮紧凑化（等宽等距布局，flex:1 使各标签宽度一致） === */
 /*紧凑——padding 4px 5px，font-size 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;
    }
 /* === ★v2.36.0 导出下拉菜单（合并原 CSV/JSON 两个 header 按钮） === */
    .sglv-export-menu { position: fixed; z-index: 1000012; min-width: 176px; padding: 6px; background: var(--sglv-panel-bg, rgba(23,26,33,0.98)); border: 1px solid var(--sglv-border, rgba(255,255,255,0.1)); border-radius: 10px; box-shadow: 0 12px 36px rgba(0,0,0,0.55); display: none; opacity: 0; transform: translateY(-4px); transition: opacity .15s ease, transform .15s ease; }
    .sglv-export-menu.show { display: block; opacity: 1; transform: translateY(0); }
    .sglv-export-menu button { display: flex; align-items: center; gap: 9px; width: 100%; padding: 8px 10px; border: none; background: transparent; color: var(--sglv-text, #c7d5e0); font-size: 12.5px; border-radius: 7px; cursor: pointer; text-align: left; font-family: inherit; }
    .sglv-export-menu button:hover { background: rgba(102,192,244,0.12); color: #fff; }
    .sglv-export-menu .fmt-badge { flex-shrink: 0; min-width: 38px; text-align: center; padding: 2px 6px; border-radius: 6px; font-size: 10px; font-weight: 700; letter-spacing: .04em; }
    .sglv-export-menu .fmt-badge.csv { background: rgba(52,211,153,0.14); color: #34d399; }
    .sglv-export-menu .fmt-badge.json { background: rgba(102,192,244,0.14); color: #66c0f4; }

 /* === 头部开关紧凑（家庭组） === */
    .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;
    }

 /* === tab 菜单紧凑化（保留），并接入全局搜索框 + 下拉结果浮层 === */
 /* 全局搜索框：紧贴 wishlist tab 右侧，flex:0 0 auto 不抢占 tab 等宽空间 */
 /*审查：移除 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; }

 /*搜索结果浮层 — 右对齐搜索框,动画显隐,动态 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;
    }
 /*右侧徽章+图标容器,统一收紧间距 */
    .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; }
 /*精准匹配(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; }
 /*家庭共享次级徽章(紫色,小尺寸,紧贴主 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;
    }

 /* === 游戏详情浮窗（点击搜索结果后弹出） === */
    .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; }

 /* === 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));
    }

 /* === 统计仪表布局——热力图行改自适应内容高度（不再撑满 wrap），6月增量SVG加高减少留白 === */
 /*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;
    }
 /*图表行(甜甜圈+趋势) 使用内容高度,不再 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; }
 /*图表列最小高度,确保甜甜圈/趋势图有足够渲染空间 */
    .sglv-playtime-col { min-height: 220px !important; }
 /*雷达行紧凑:雷达卡内容居中、右侧统计面板均匀分布填满高度,消除底部空白失衡 */
    .sglv-radar-card { justify-content: center; }
    .sglv-radar-stats { justify-content: space-between; }
 /*图表行(甜甜圈+趋势)适度紧凑:限制列高与甜甜圈尺寸,下方热力图/增量区更快进入视野。
       注意只限 svg 高度——覆写宽度会让 CDN 库的 viewBox SVG 宽度塌缩消失 */
    .sglv-playtime-row { max-height: 320px !important; }
    .sglv-playtime-col { max-height: 320px !important; overflow: hidden !important; }
    .sglv-playtime-col > #sglv-pt-donut { flex: 1 1 auto; min-height: 0; overflow: hidden; display: flex; flex-direction: column; justify-content: center; }
    .sglv-playtime-col > #sglv-pt-donut svg { max-height: 190px !important; }
    .sglv-playtime-col > #sglv-pt-donut .sglv-donut-chart { flex-shrink: 1; min-height: 0; }
 /*热力图行 grid 7:3——改成自适应内容高度 + 最小高度，不再撑满 wrap 剩余高度，避免盖住上方 KPI/图表区 */
 /*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;
    }
 /*热力图 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;
    }
 /*增量柱图——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; }
 /*热力图 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; }
 /*热力图 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;
    }
 /*热力图 scroll 紧凑 padding-bottom */
    .sglv-heatmap-scroll { padding-bottom: 2px !important; }
 /*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; }
 /*增量柱图底部统计栏样式 */
    .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; }
    }

 /* === 移动端统计仪表适配——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; }

 /*热力图行降低最小高度,但仍保持足够渲染空间,由 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; }

 /*热力图行降低高度但保持最小渲染空间 */
        .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; }
    }

 /* === 分页导航——简化单行布局，首页|上页|下页|末页 + 跳页输入 === */
    .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; }

 /* === 统计仪表 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; }
 /*KPI 卡片扁平化——弱化边框，靠左侧色条 + 背景色区分，参考设计图 */
    .sglv-playtime-kpi-card { border-width: 1px !important; border-left-width: 3px !important; }

 /* === 游玩率/完成度 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; }

 /* === 入库趋势页 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; }

 /* === 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; }

 /* === 右侧标签切换 === */
    .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; }

 /* === 频率分析图表 === */
    .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; }

 /* === 游玩数据页——家庭成员对比紧凑到右半侧底部，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;
    }
 /*游戏橱窗 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-tabs.is-arming .sgis-tab { cursor: progress; }

 /* === 标题图标：更精致渐变 + 内阴影 === */
    .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-pane { min-width: 0; }
    .sgis-pane.is-active { animation: sgis-pane-in .18s ease; }
    @keyframes sgis-pane-in { from { opacity: 0; transform: translateY(4px); } to { opacity: 1; transform: none; } }
    .sgis-tab-pending { min-height: 160px; }
    .sgis-social-friend { content-visibility: auto; contain-intrinsic-size: auto 64px; }

 /* === 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;
    }

 /* === 徽章标签页英雄区(顶部总览) === */
    .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; }

 /* === 章节标题 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; }

 /* === 洞察页成就引导入口(替代旧折叠列表) === */
    .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);
    }

 /* === 徽章 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; }

 /* === 徽章 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; }

 /* === 价值卡片单列布局(共享库默认 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 文本)自然撑开 */

 /* === 愿望单首次加载骨架屏(避免页面紧缩) === */
    @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 {
        position: relative;
        background:
            linear-gradient(135deg, rgba(139, 92, 246, 0.08), rgba(59, 130, 246, 0.04)),
            var(--sglv-surface-1, rgba(255, 255, 255, 0.025));
        border: 1px solid rgba(139, 92, 246, 0.18);
        border-radius: 8px;
        padding: 10px 8px;
        text-align: center;
        display: flex;
        flex-direction: column;
        align-items: center;
        gap: 6px;
        box-shadow: var(--sglv-shadow-sm, 0 2px 8px rgba(0, 0, 0, 0.35)), inset 0 1px 0 rgba(139, 92, 246, 0.12);
        transition: transform 0.18s var(--sglv-ease, ease), box-shadow 0.18s var(--sglv-ease, ease), border-color 0.18s var(--sglv-ease, ease);
        overflow: hidden;
    }
    .sglv-wl-kpi-cell::before {
        content: '';
        position: absolute;
        inset: -1px;
        border-radius: 8px;
        pointer-events: none;
        background: linear-gradient(135deg, rgba(139, 92, 246, 0.35), transparent 60%);
        opacity: 0;
        transition: opacity 0.18s var(--sglv-ease, ease);
    }
    .sglv-wl-kpi-cell:hover {
        transform: translateY(-2px);
        border-color: rgba(139, 92, 246, 0.4);
        box-shadow: var(--sglv-shadow-md, 0 6px 20px rgba(0, 0, 0, 0.45)), 0 0 0 1px rgba(139, 92, 246, 0.25), 0 0 22px rgba(139, 92, 246, 0.2), inset 0 1px 0 rgba(139, 92, 246, 0.18);
    }
    .sglv-wl-kpi-cell:hover::before { opacity: 1; }
    .sglv-wl-kpi-cell > * { position: relative; z-index: 1; }
    .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; }
 /* === 愿望单加载等待动画（参考 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; }`;

 // ==================== v2.45.0: API Key 同意门弹窗 ====================
    const CSS_APIKEY_CONSENT =`            @keyframes sglv-consent-in { from { opacity: 0; transform: translateY(12px) scale(0.98); } to { opacity: 1; transform: translateY(0) scale(1); } }
            .sglv-apikey-consent { position: fixed; inset: 0; z-index: 10000050;
                background: rgba(2,6,23,0.72); backdrop-filter: blur(3px);
                display: flex; align-items: center; justify-content: center; padding: 20px; box-sizing: border-box; }
            .sglv-apikey-consent-card { width: min(560px, 100%); max-height: 86vh; display: flex; flex-direction: column;
                background: linear-gradient(160deg, rgba(30,41,59,0.99), rgba(15,23,42,0.99));
                border: 1px solid rgba(167,139,250,0.4); border-radius: 14px;
                box-shadow: 0 24px 64px rgba(0,0,0,0.6); color: #e2e8f0;
                font-size: 13px; line-height: 1.7; animation: sglv-consent-in 0.22s ease-out; }
            .sglv-apikey-consent-head { display: flex; align-items: center; gap: 10px;
                padding: 16px 18px 12px; border-bottom: 1px solid rgba(148,163,184,0.16); }
            .sglv-apikey-consent-title { flex: 1; font-size: 15px; font-weight: 700; color: #fff; }
            .sglv-apikey-consent-close { background: none; border: none; color: #94a3b8; cursor: pointer;
                font-size: 15px; line-height: 1; padding: 4px 8px; border-radius: 6px; }
            .sglv-apikey-consent-close:hover { color: #fff; background: rgba(148,163,184,0.15); }
            .sglv-apikey-consent-body { padding: 16px 18px; overflow-y: auto; }
            .sglv-apikey-consent-sec + .sglv-apikey-consent-sec { margin-top: 16px; }
            .sglv-apikey-consent-sec-title { font-size: 12px; font-weight: 700; color: #a78bfa;
                margin-bottom: 8px; letter-spacing: 0.04em; }
            .sglv-apikey-consent-p { margin: 0 0 8px; color: #cbd5e1; font-size: 12.5px; }
            .sglv-apikey-consent-p b, .sglv-apikey-consent-ul b { color: #e9d5ff; }
            .sglv-apikey-consent-ul { margin: 0; padding-left: 18px; color: #cbd5e1; font-size: 12.5px; }
            .sglv-apikey-consent-ul li { margin-bottom: 6px; }
            .sglv-apikey-consent-check { display: flex; align-items: flex-start; gap: 9px; margin-top: 16px;
                padding: 11px 13px; border: 1px solid rgba(167,139,250,0.32); border-radius: 10px;
                background: rgba(167,139,250,0.07); cursor: pointer; font-size: 12.5px; color: #e2e8f0; }
            .sglv-apikey-consent-check:hover { border-color: rgba(167,139,250,0.55); }
            .sglv-apikey-consent-check input { margin-top: 3px; accent-color: #a78bfa; flex: none; cursor: pointer; }
            .sglv-apikey-consent-actions { display: flex; gap: 10px; padding: 14px 18px 18px;
                border-top: 1px solid rgba(148,163,184,0.16); }
            .sglv-apikey-consent-btn { flex: 1; padding: 10px 0; border-radius: 9px; font-size: 13px;
                font-weight: 600; cursor: pointer; border: 1px solid transparent; transition: filter 0.15s, opacity 0.15s; }
            .sglv-apikey-consent-btn.primary { background: linear-gradient(90deg, #8b5cf6, #3b82f6); color: #fff; }
            .sglv-apikey-consent-btn.ghost { background: transparent; border-color: rgba(148,163,184,0.3); color: #cbd5e1; }
            .sglv-apikey-consent-btn:hover:not(:disabled) { filter: brightness(1.15); }
            .sglv-apikey-consent-btn:disabled { opacity: 0.42; cursor: not-allowed; }
            .sglv-set-locked { padding: 12px 14px; border: 1px dashed rgba(167,139,250,0.4); border-radius: 10px;
                background: rgba(167,139,250,0.06); }
            .sglv-set-locked-title { font-size: 13px; font-weight: 700; color: #e9d5ff; margin-bottom: 6px; }
            .sglv-set-locked-desc { font-size: 12px; color: #94a3b8; line-height: 1.65; margin-bottom: 10px; }
            .sglv-set-locked-btn { padding: 7px 16px; border-radius: 8px; font-size: 12px; font-weight: 600; cursor: pointer;
                border: 1px solid transparent; background: linear-gradient(90deg, #8b5cf6, #3b82f6); color: #fff; }
            .sglv-set-locked-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; }
 /*设置页面开关样式 */
            .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; }
 /*外观主题选择卡（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; }
 /*游戏橱窗 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; }
 /* v1.0.3: sglv-stat-dash-card / sglv-trend-kpi-card / sglv-wl-kpi-cell 共享炫彩效果 —
    渐变背景 + shadow-sm 基线 + 抬升 -2px + accent-glow 外发光 */
            .sglv-stat-dash-card, .sglv-trend-kpi-card { position: relative; overflow: hidden; box-shadow: 0 2px 8px rgba(0,0,0,.35), inset 0 1px 0 rgba(255,255,255,.04); }
            .sglv-stat-dash-card::before, .sglv-trend-kpi-card::before { content: ''; position: absolute; inset: -1px; pointer-events: none; background: linear-gradient(135deg, rgba(102,192,244,.32), transparent 60%); opacity: 0; transition: opacity .18s ease; }
            .sglv-stat-dash-card:hover::before, .sglv-trend-kpi-card:hover::before { opacity: 1; }
            .sglv-stat-dash-card:hover, .sglv-trend-kpi-card:hover { box-shadow: 0 6px 20px rgba(0,0,0,.45), 0 0 0 1px rgba(102,192,244,.25), 0 0 22px rgba(102,192,244,.18), inset 0 1px 0 rgba(255,255,255,.06); border-color: rgba(102,192,244,.45) !important; }
            .sglv-stat-dash-value, .sglv-trend-kpi-value { text-shadow: 0 0 14px rgba(102,192,244,.25); }
            .sglv-stat-dash-card > *, .sglv-trend-kpi-card > * { position: relative; z-index: 1; }`;

    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; }
 /*年度大作 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; }
 /* === 国旗完整显示 — flagcdn w40 各国旗帜宽高比不一(US/GB/KZ/CO 为 2:1 宽旗,
                   BR 为 10:7 等),共享库 .sgis-price-flag 固定 30×20(3:2)+cover 会把宽旗左右裁掉约 1/4;
                   此处以更高优先级覆盖为 contain,旗帜图案完整呈现,比例空隙由行背景自然过渡 === */
                .sgis-price-tbl .sgis-price-flag { object-fit: contain; }
                .sgis-price-featured-img { object-fit: contain; }

 /* === 比价目标货币切换（多地区低价排行页头） === */
                .sgis-price-cur-switch { margin-left:auto; display:inline-flex; align-items:center; gap:4px; flex-shrink:0; text-transform:none; letter-spacing:0; }
                .sgis-price-cur-switch-label { font-size:9px; color:var(--sgis-text-2); font-weight:500; }
                .sgis-price-cur-select {
                    font-size:10px; font-weight:600; color:#66c0f4; font-family:inherit;
                    background:rgba(102,192,244,0.08); border:1px solid rgba(102,192,244,0.25);
                    border-radius:6px; padding:2px 4px; cursor:pointer; outline:none;
                    max-width:132px; text-transform:none; letter-spacing:0; transition:border-color 0.15s, background 0.15s;
                }
                .sgis-price-cur-select:hover { border-color:rgba(102,192,244,0.5); background:rgba(102,192,244,0.14); }
                .sgis-price-cur-select:focus { border-color:rgba(102,192,244,0.6); }
                .sgis-price-cur-select option { background:#1b2838; color:#fff; }
                .sgis-price-cur-fallback { font-size:9px; color:#c0a050; margin:-4px 0 6px; line-height:1.4; }

 /* === 评测标签页 === */
 /* === 评测摘要（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; }
 /*评测项卡片化——左右色条标识好评/差评 */
                .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; }
 /*计数摘要条——图标 + 数字 + 已筛选徽章 */
                .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; }
 /*评测项操作行（展开/复制）——紧凑胶囊按钮 */
                .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); }
 /*评测空状态——精致状态点 + 文字 */
                .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); }

 /* === 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); }

 /* === 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); }

 /* === 中文语音标记 === */
                .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);
                }

 /* === 资料受限/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); }

 /* === 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; gap:4px; 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-group .sgis-crack-group-key { opacity:0.65; font-weight:400; }
                .sgis-crack-group .sgis-crack-group-val { font-weight:600; }
                .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; }

 /* === 评测搜索（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; }`;

 //游戏别名 (Steam EN + 小黑盒中文别名) —— 行内样式
    const CSS_ALIAS =`                /* === v2.11.48: 游戏别名行 (Steam EN + 小黑盒中文别名,异步填充) === */
                .sgis-alias-row {
                    display: flex;
                    flex-wrap: wrap;
                    gap: 4px 6px;
                    align-items: center;
                    margin-top: 4px;
                    min-height: 0;
                    line-height: 1;
                }
                .sgis-alias-row:empty { display: none; }
                .sgis-alias-pill {
                    display: inline-flex;
                    align-items: center;
                    gap: 4px;
                    font-size: 10.5px;
                    line-height: 1.4;
                    padding: 2px 7px;
                    border-radius: 4px;
                    background: rgba(255, 255, 255, 0.05);
                    border: 1px solid rgba(255, 255, 255, 0.1);
                    max-width: 100%;
                }
                .sgis-alias-pill .sgis-alias-source {
                    font-size: 9px;
                    font-weight: 500;
                    opacity: 0.6;
                    letter-spacing: 0.2px;
                }
                .sgis-alias-pill .sgis-alias-value {
                    font-weight: 600;
                    white-space: nowrap;
                    overflow: hidden;
                    text-overflow: ellipsis;
                    max-width: 200px;
                }
                .sgis-alias-en { border-color: rgba(147, 197, 253, 0.25); background: rgba(96, 165, 250, 0.08); }`;

 //主题层——原 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);
    }
 /* v1.0.3: playtime-kpi 卡片炫彩升级——叠加 accent 渐变背景 + shadow-sm 基线 + hover 抬升 + 外发光 */
    .sglv-playtime-kpi-card { overflow: hidden; box-shadow: 0 2px 8px rgba(0,0,0,.35), inset 0 1px 0 rgba(255,255,255,.04); }
    .sglv-playtime-kpi-card::before { content: ''; position: absolute; inset: -1px; pointer-events: none; background: linear-gradient(135deg, rgba(102,192,244,.3), transparent 60%); opacity: 0; transition: opacity .18s ease; }
    .sglv-playtime-kpi-card:hover::before { opacity: 1; }
    .sglv-playtime-kpi-card:hover { box-shadow: 0 6px 20px rgba(0,0,0,.45), 0 0 0 1px rgba(102,192,244,.25), 0 0 22px rgba(102,192,244,.18), inset 0 1px 0 rgba(255,255,255,.06); }
    .sglv-playtime-kpi-value { text-shadow: 0 0 14px rgba(102,192,244,.25); }
    .sglv-playtime-kpi-card > * { position: relative; z-index: 1; }

 /* ====== 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;
    }
 /*环形进度数值使用炫彩渐变，不强制紫色 */

 /* ====== 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; }
    }

 /* ====== 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;
    }`;

 //经典蓝主题层——由 scripts/gen-sglv-theme-blue.js 生成（典雅紫层色值镜像映射
 // + 主脚本 CSS 常量/共享库中原生紫色规则的换色覆盖），请勿手改，重新运行生成器即可再生。
    const CSS_THEME_BLUE =`
    /* =====================================================================
 *经典蓝主题层 —— 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);
    }
 /* v1.0.3: playtime-kpi 卡片炫彩升级——叠加 accent 渐变背景 + shadow-sm 基线 + hover 抬升 + 外发光 */
    .sglv-playtime-kpi-card { overflow: hidden; box-shadow: 0 2px 8px rgba(0,0,0,.35), inset 0 1px 0 rgba(255,255,255,.04); }
    .sglv-playtime-kpi-card::before { content: ''; position: absolute; inset: -1px; pointer-events: none; background: linear-gradient(135deg, rgba(102,192,244,.3), transparent 60%); opacity: 0; transition: opacity .18s ease; }
    .sglv-playtime-kpi-card:hover::before { opacity: 1; }
    .sglv-playtime-kpi-card:hover { box-shadow: 0 6px 20px rgba(0,0,0,.45), 0 0 0 1px rgba(102,192,244,.25), 0 0 22px rgba(102,192,244,.18), inset 0 1px 0 rgba(255,255,255,.06); }
    .sglv-playtime-kpi-value { text-shadow: 0 0 14px rgba(102,192,244,.25); }
    .sglv-playtime-kpi-card > * { position: relative; z-index: 1; }

 /* ====== 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;
    }
 /*环形进度数值使用炫彩渐变，不强制紫色 */

 /* ====== 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; }
    }

 /* ====== 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-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; }
`;

 //列表视图固定 2 列等宽修复 —— 共享库 .sglv-list-view 用 repeat(2, 1fr)，
 // 1fr 轨道的自动最小尺寸为 min-content，长游戏名/不可收缩徽章会把轨道撑破，
 // 导致两列宽度不等、整行溢出容器（右列被面板边缘裁切）。
 // minmax(0,1fr) 将轨道下限钉死为 0，配合 .sglv-list-item min-width:0 + overflow:hidden，
 // 列宽恒等且永不超出容器；内部文字经既有的 ellipsis 规则正常截断。
    const CSS_LIST_FIX = `
 /* ====== 列表视图固定 2 列等宽（愿望单等所有 list 视图共用） ====== */
    .sglv-list-view { grid-template-columns: repeat(2, minmax(0, 1fr)) !important; width: 100% !important; max-width: 100% !important; }
    .sglv-list-view > .sglv-list-item { min-width: 0 !important; max-width: 100% !important; overflow: hidden !important; }
    .sglv-list-view .sglv-list-info { min-width: 0 !important; max-width: 100% !important; overflow: hidden !important; }
    .sglv-list-view .sglv-list-meta { min-width: 0 !important; max-width: 100% !important; overflow: hidden !important; }
    /* ====== v2.31.6 长列表渲染治理：游戏库屏外条目降级渲染 ======
       背景：一页 48 项（横版 24 项），每项含封面图 + 标题 + 徽章，
             切视图/筛选/排序/翻页都会整块重建 DOM，屏外条目白白参与布局与绘制。
       实测（Chromium，48 张卡片）：布局 17.5ms → 1.1ms，绝对节省 16.4ms（超过一帧预算）。
       写法要点：
         - 用 auto（不用 hidden）：hidden 会让条目不可被 Ctrl+F 搜到；
         - contain-intrinsic-size 的 auto 前缀让浏览器自己记住上次真实高度，
           因此无需 JS 测高——也就没有"重复测量导致高度越改越小"的老问题，
           面板 resize 导致列宽变化时浏览器也会自动重新学习；
         - 作用域限定 .sglv-content（游戏库主滚动容器），
           不影响愿望单/系列/云存档等共用 renderGameView 工厂的其他页面；
         - 刻意不加 contain：条目内含 position:absolute 的浮层（徽章/时长角标/斜切带），
           加了会被 paint containment 裁剪。 */
    .sglv-content .sglv-game-card { content-visibility: auto; contain-intrinsic-size: auto var(--sglv-h, 200px); }
    .sglv-content .sglv-cover-card { content-visibility: auto; contain-intrinsic-size: auto var(--sglv-h, 190px); }
    .sglv-content .sglv-list-item  { content-visibility: auto; contain-intrinsic-size: auto var(--sglv-h, 62px); }
`;

 //导航栏二级菜单——点击接管 + fixed 停靠（修复"游戏收藏二级菜单无法打开"）
 // 根因: ① 共享库纯 CSS :hover 下拉在触屏/Steam 客户端 CEF 无 hover 事件不可达, fab 也无下拉
 // 箭头零可供性; ② 降级分支(无 .supernav_container 的社区页/React 新布局)曾用
 // style.cssText 写 position:fixed, 被共享库 .sglv-menu-wrap{position:relative!important}
 // 完全覆盖(stylesheet !important 胜 inline 非 important), 菜单被钉在文档流末尾。
 // 方案: 点击 ▾ 开关切换 .sglv-open 类显隐; 停靠态 position:fixed 摆脱祖先 overflow 裁剪;
 // !important 冲突用 CSS 自定义属性绕开(var 供值, !important 留在样式表侧);
 // 开态的 (0,4,0)/(0,3,0) 特异性均不低于 hover 关闭规则, 开+悬停不会闪隐。
    const CSS_MENU = `
 /* ====== 导航栏二级菜单——点击接管 + fixed 停靠 ====== */
 /*子菜单竖排 + 自带底板(不再依赖共享库)。根因: .sglv-submenu-item{display:block}
       只存在于 @require 外部库 sglv-shared-css, 该库加载失败时 CSS_STYLES 为空串(见 v2.7.1 注释),
       两个 <a> 退回 inline 默认值 → 「游戏收藏 / 游戏数据」横排成一行, 且 ▾ 开关因 Steam
       .menuitem{float:left} 换行堆到「游戏库」上方。此处在主脚本内以 !important 兜底:
       ① menuWrap 改 inline-flex + 子元素 float:none —— 游戏库与 ▾ 恒在同一行;
       ② 子菜单项强制 display:block + width:100% —— 恒为竖排, 任何加载顺序都不横排;
       ③ 子菜单自带 min-width/底板/圆角/阴影 —— 共享库缺失时也不会"裸奔"贴到页面上。
       停靠坐标仍由 JS 按 fab.getBoundingClientRect() 写入 --sglv-sub-*(见 dockSubmenu)。 */
    .sglv-menu-wrap { display: inline-flex !important; align-items: center !important; vertical-align: middle !important; }
    .sglv-menu-wrap > .sglv-fab { float: none !important; }
 /*完美复刻 Steam 原生 supernav 下拉(对照 雅俊杰汐→主页/讨论/创意工坊/市场/实况直播)
       面板: rgba(58,79,96,.95) = Steam supernav dropdown token / 无圆角无描边 / 轻投影;
       菜单项: 14px 常规字重 + #c7d5e0 + 行高 30px + 左右 16px 内边距(与 Steam 实测留白一致);
       悬停: rgba(255,255,255,.12) 浅色高亮 = Steam 原生 hover, 不是蓝底也不是白色块;
       父项「游戏库」展开时**不做**激活底色 —— Steam 展开父项不变色, 此前误加的
       rgba(255,255,255,.12) 父项底 + .is-active 纯白块是"看起来不一样"的主因, 均已移除。
       选中态(is-active)改为白字 + 600 字重 + 极浅底, 与 Steam 视觉体系不冲突。 */
    .sglv-submenu { display: none !important; box-sizing: border-box !important; width: max-content !important; min-width: 120px !important; max-width: 260px !important; padding: 4px 0 !important; background: rgba(58, 79, 96, 0.95) !important; border: none !important; border-radius: 0 !important; box-shadow: 0 4px 12px rgba(0, 0, 0, 0.4) !important; overflow: hidden !important; z-index: 9999 !important; }
    .sglv-submenu-item { display: block !important; float: none !important; width: 100% !important; box-sizing: border-box !important; height: 30px !important; line-height: 30px !important; padding: 0 16px !important; font-size: 14px !important; font-weight: 400 !important; color: #c7d5e0 !important; background: transparent !important; white-space: nowrap !important; text-decoration: none !important; }
    .sglv-submenu-item:hover { background: rgba(255, 255, 255, 0.12) !important; color: #ffffff !important; }
    .sglv-submenu-item.is-active { background: rgba(255, 255, 255, 0.06) !important; color: #ffffff !important; font-weight: 600 !important; }
    .sglv-menu-wrap.sglv-open .sglv-submenu { display: block !important; }
    .sglv-menu-wrap.sglv-open:hover .sglv-submenu { display: block !important; }
    .sglv-menu-wrap:hover .sglv-submenu { display: none !important; }
    .sglv-submenu.sglv-submenu-docked { position: fixed !important; top: var(--sglv-sub-top, 100%) !important; left: var(--sglv-sub-left, 0) !important; overflow: visible !important; }
 /* 热区桥：向上盖住按钮与菜单之间的缝。overflow:hidden 会把这段裁掉，停靠态必须改回 visible。 */
    .sglv-submenu.sglv-submenu-docked::before { content: '' !important; position: absolute !important; left: 0 !important; right: 0 !important; top: -10px !important; height: 10px !important; display: block !important; background: transparent !important; }
    .sglv-menu-wrap.sglv-menu-fixed { position: fixed !important; top: 14px !important; right: 160px !important; z-index: 99999 !important; display: inline-flex !important; }
 /* React 商店头（愿望单等页没有 .supernav_container）：入口插在「客服」同一条 flex 行里，
    外观由运行时复制的头部链接 class 决定。这里只取消浮动定位，避免再钉到右上角。 */
    .sglv-menu-wrap.sglv-menu-in-header { position: relative !important; top: auto !important; right: auto !important; margin: 0 !important; flex: 0 0 auto !important; float: none !important; z-index: 2 !important; align-items: stretch !important; align-self: stretch !important; }
    .sglv-menu-wrap.sglv-menu-in-header > .sglv-fab { height: 100% !important; box-sizing: border-box !important; }
`;

 //游玩数据页样式 —— 总览（HERO + Top20）/ 游玩分析（集中度/活跃度/分档/雷达）共用基础面板 /
 // 全部游戏排行全屏浮窗。注意: 浮窗样式必须写在主脚本(共享库 .sglv-overlay 为 display:none,
 // 且库经 GreasyFork @require 加载,本地改库文件不生效)。
    const CSS_PLAYDATA = `
 /* ====== 游玩数据页（排行 + 洞察） ====== */
    .sglv-pt-hero-kpi { display: grid; grid-template-columns: repeat(5, minmax(0, 1fr)); gap: 10px; flex-shrink: 0; }
    /* HERO KPI 卡宽松化:Top20 可内部滚动后不再极限压缩——恢复呼吸感 padding/字号 */
    .sglv-pt-hero-kpi .sglv-playtime-kpi-card { padding: 8px 12px 6px; }
    .sglv-pt-hero-kpi .sglv-playtime-kpi-value { font-size: 20px; }
    .sglv-pt-hero-kpi .sglv-playtime-kpi-label { font-size: 11.5px; }
    .sglv-pt-hero-kpi .sglv-playtime-kpi-sub { font-size: 10px; }
    .sglv-pt-panel { background: var(--sglv-section-bg, rgba(255,255,255,0.02)); border: 1px solid var(--sglv-border, rgba(255,255,255,0.08)); border-radius: var(--sglv-radius, 10px); padding: 14px 16px; min-width: 0; }
    .sglv-pt-panel-body { display: flex; flex-direction: column; gap: 8px; min-width: 0; }
 /* v2.32.0 起总览瘦身为「HERO + Top20」直排结构（.sglv-pt-main-row 双栏已废弃），
       时长集中度/活跃度分层迁入「游玩分析」Tab——旧双栏选择器一并清除 */
    .sglv-pt-conc-summary { display: flex; flex-wrap: wrap; gap: 6px; }
    .sglv-pt-conc-chip { font-size: 11.5px; padding: 3px 10px; border-radius: 999px; background: rgba(102,192,244,0.1); border: 1px solid rgba(102,192,244,0.22); color: #c7d5e0; }
    .sglv-pt-conc-chip b { color: var(--sglv-accent, #66c0f4); font-weight: 700; }
    .sglv-pt-conc-note { font-size: 11.5px; color: var(--sglv-text-secondary, #8a9ba8); line-height: 1.5; }
    .sglv-pt-conc-chart { width: 100%; height: 160px; display: flex; align-items: center; }
    .sglv-pt-conc-chart .sglv-trend-svg { height: auto !important; max-height: 160px; width: 100% !important; }
    .sglv-pt-layer-row { cursor: pointer; border-radius: 4px; padding: 2px 6px; transition: background .15s; }
    .sglv-pt-layer-row:hover { background: rgba(102,192,244,0.08); }
    /* 活跃度分层面板隐藏"点击任一分层查看该层排行"提示行（远端 PTW 库尚未更新，
       主脚本 CSS 兜底，避免面板体溢出容器） */
    #sglv-pt-act-body > .sglv-pt-conc-note { display: none !important; }
    .sglv-pt-dust { margin-top: 8px; padding-top: 10px; border-top: 1px dashed rgba(255,255,255,0.08); display: flex; align-items: center; gap: 8px; flex-wrap: wrap; font-size: 11.5px; color: var(--sglv-text-secondary, #8a9ba8); }
    .sglv-pt-dust b { color: #fbbf24; }
    .sglv-pt-dust-btn { border: 1px solid rgba(251,191,36,0.35); background: rgba(251,191,36,0.1); color: #fbbf24; border-radius: 4px; font-size: 11.5px; padding: 2px 9px; cursor: pointer; }
    .sglv-pt-dust-btn:hover { background: rgba(251,191,36,0.2); }
 /*Top20 单列长列表——列表自身滚动后放开压缩:行高 ~34px,
       icon 28px / padding 6-10px / gap 10px / rank 24×24,呼吸感优先于"一屏看完" */
    .sglv-pt-top-grid { display: grid; grid-template-columns: minmax(0, 1fr); gap: 4px; }
    .sglv-pt-top-grid .sglv-pt-top-item { margin-bottom: 0; min-width: 0; padding: 6px 10px; gap: 10px; }
    .sglv-pt-top-col .sglv-pt-icon { width: 28px; height: 28px; border-radius: 4px; }
    .sglv-pt-top-col .sglv-pt-rank { width: 24px; height: 24px; font-size: 11px; border-radius: 5px; }
    .sglv-pt-top-col .sglv-pt-name { font-size: 13px; line-height: 1.3; }
    .sglv-pt-top-col .sglv-pt-meta { font-size: 11px; line-height: 1.3; margin-top: 2px; }
    .sglv-pt-top-col .sglv-pt-info { display: flex; flex-direction: column; gap: 0; justify-content: center; }
    .sglv-pt-top-col .sglv-pt-hours { min-width: 48px; font-size: 12.5px; }
    .sglv-pt-top-col .sglv-pt-bar-wrap { height: 5px; }
 /* Top20 段标题:14px 字号 + 10px 下间距 */
    .sglv-pt-top-col > .sglv-playtime-section-title { font-size: 14px; margin-bottom: 10px; }
 /* panel 内 section title(集中度/活跃度分层):14px 字号 + 10px 下间距 */
    .sglv-pt-panel > .sglv-playtime-section-title { font-size: 14px; margin-bottom: 10px; }
 /* 活跃度分层行:行距/轨道放宽,与面板留白节奏一致（游玩分析 Tab） */
    .sglv-dist-bar-row { margin-bottom: 6px; gap: 10px; }
    .sglv-dist-bar-track { height: 16px; }
    .sglv-dist-bar-label { width: 72px; font-size: 11.5px; }
    .sglv-dist-bar-value { width: 84px; font-size: 11.5px; }
    .sglv-ptwin-open { display: inline-flex; align-items: center; gap: 4px; padding: 3px 10px; border-radius: 6px; border: 1px solid rgba(102,192,244,0.3); background: rgba(102,192,244,0.1); color: var(--sglv-accent, #66c0f4); font-size: 11px; font-weight: 600; cursor: pointer; transition: var(--sglv-transition); }
    .sglv-ptwin-open:hover { background: rgba(102,192,244,0.2); }
    .sglv-ptwin-open svg { width: 12px; height: 12px; }
 /* 主区布局：HERO 固定 → Top20 卡片占满剩余高度 → 列表自身纵向滚动（sglv-pt-tab 仅游玩数据页，勿波及统计仪表页） */
    .sglv-body > .sglv-pt-tab { overflow: hidden !important; padding: 12px 14px !important; gap: 12px !important; }
    .sglv-body > .sglv-pt-tab > .sglv-playtime-wrap { flex: 1 1 0 !important; min-height: 0 !important; overflow: hidden !important; gap: 12px !important; }
 /* v2.33.1 修复：v2.32.0 重构后总览 DOM 变为 .sglv-pt-overview 直排（HERO + Top20），
       旧 .sglv-pt-main-row 双栏选择器失配 → 面板退化 block、#sglv-pt-top-list 无高度约束，
       溢出被内层 overflow:hidden 裁掉且无滚动条。改为直接锚定 .sglv-pt-overview 新结构：
       面板 flex column 撑满剩余高度，滚动交还列表自身；不锚定 .sglv-body，
       全屏浮窗 overview Tab 同构 DOM 同规则受益 */
    .sglv-pt-overview > .sglv-pt-top-col { flex: 1 1 auto; min-height: 0; display: flex; flex-direction: column; }
    .sglv-pt-top-col > .sglv-playtime-section-title { flex-shrink: 0; }
    .sglv-pt-top-col > #sglv-pt-top-list { flex: 1 1 auto; min-height: 140px; max-height: none; overflow-y: auto; overflow-x: hidden; overscroll-behavior: contain; scrollbar-gutter: stable; scrollbar-width: thin; scrollbar-color: rgba(255,255,255,0.14) transparent; }
    .sglv-pt-top-col > #sglv-pt-top-list::-webkit-scrollbar { width: 6px; }
    .sglv-pt-top-col > #sglv-pt-top-list::-webkit-scrollbar-thumb { background: rgba(255,255,255,0.14); border-radius: 3px; }
    .sglv-pt-top-col > #sglv-pt-top-list::-webkit-scrollbar-thumb:hover { background: rgba(255,255,255,0.24); }
 /* 列表不足一屏（游戏 <20 款）时行块顶部对齐，不随 flex 拉伸出空隙 */
    .sglv-pt-top-grid { align-content: start; }
 /* ≤900px：单列流式，恢复整页滚动 */
    @media (max-width: 900px) {
        .sglv-body > .sglv-pt-tab,
        .sglv-body > .sglv-pt-tab > .sglv-playtime-wrap { overflow-y: auto !important; }
        .sglv-pt-overview > .sglv-pt-top-col { flex: 0 0 auto; }
        .sglv-pt-top-col > #sglv-pt-top-list { overflow-y: visible; min-height: 0; }
    }
 /* ====== 全部游戏排行遗留壳样式 ======
              .sglv-ptwin-overlay/.sglv-ptwin/.sglv-ptwin-head/tabs/body/pane 系列已废弃（排行已改走 SGLVPTW 框架浮窗），
              仍在使用的：.sglv-ptwin-open（Top20 卡片头「全部游戏排行」按钮）、
              .sglv-pt-all-loading / .sglv-pt-all-hint（月历/排行 Tab 加载态）。 */
    .sglv-pt-all-loading { padding: 24px 0; text-align: center; font-size: 12px; color: var(--sglv-text-secondary, #8a9ba8); }
    .sglv-pt-all-hint { margin: 0 0 8px; font-size: 11px; line-height: 1.5; color: #fbbf24; }
 /* ====== 全部游戏排行过滤 chips(隐藏从未游玩/隐藏家庭共享/正倒序切换) ====== */
    .sglv-pt-filter-chip { border: 1px solid rgba(255,255,255,0.12); background: rgba(255,255,255,0.04); color: #8a9ba8; border-radius: 999px; font-size: 11px; padding: 3px 10px; cursor: pointer; white-space: nowrap; }
    .sglv-pt-filter-chip:hover { color: #fff; }
    .sglv-pt-filter-chip.active { color: var(--sglv-accent, #66c0f4); border-color: rgba(102,192,244,0.35); background: rgba(102,192,244,0.1); }
 /* ====== 全部游戏列表行首游戏图标 ====== */
 /* 紧凑 22px(共享库 .sglv-pt-icon 为 Top20 的 40px;本列表行密 padding 6px/字号 12px,
       40px 会把行高从 ~29px 撑到 ~52px,密集排行可读性下降)。固定尺寸 + flex-shrink:0
       保证图标懒加载过程零布局抖动;object-fit:cover 兼容竖版/横版资产裁切一致。 */
    .sglv-pt-all-icon { width: 22px; height: 22px; border-radius: 3px; flex-shrink: 0; object-fit: cover; background: rgba(255,255,255,0.05); }
 /* ====== 家庭成员对比（对比条 + 可展开 Top20） ====== */
    .sglv-fam-list { margin-top: 8px; }
    .sglv-fam-item { background: rgba(255,255,255,0.025); border: 1px solid var(--sglv-border, rgba(255,255,255,0.08)); border-radius: 8px; margin-bottom: 8px; overflow: hidden; }
    .sglv-fam-item.is-me { border-color: rgba(102,192,244,0.28); background: rgba(102,192,244,0.05); }
    .sglv-fam-head { display: flex; align-items: center; gap: 8px; padding: 8px 10px; cursor: pointer; }
    .sglv-fam-head:hover { background: rgba(255,255,255,0.04); }
    .sglv-fam-rank { width: 22px; height: 22px; flex: 0 0 22px; border-radius: 5px; display: flex; align-items: center; justify-content: center; font-size: 11px; font-weight: 700; background: rgba(255,255,255,0.06); color: #94a3b8; }
    .sglv-fam-item.is-me .sglv-fam-rank { background: rgba(102,192,244,0.2); color: #66c0f4; }
    .sglv-fam-name { flex: 1; min-width: 0; font-size: 13px; font-weight: 600; color: #e0e0e0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
    .sglv-fam-item.is-me .sglv-fam-name { color: #66c0f4; }
    .sglv-fam-hours { flex: 0 0 auto; font-size: 13px; font-weight: 700; color: #fbbf24; white-space: nowrap; }
    .sglv-fam-chev { flex: 0 0 auto; font-size: 11px; color: #8a9ba8; transition: transform .2s ease; }
    .sglv-fam-item.open .sglv-fam-chev { transform: rotate(180deg); }
    .sglv-fam-track { height: 5px; margin: 0 10px 8px; background: rgba(255,255,255,0.06); border-radius: 3px; overflow: hidden; }
    .sglv-fam-fill { display: block; height: 100%; border-radius: 3px; background: linear-gradient(90deg, #4caf50, #2e7d32); transition: width .4s ease; min-width: 2px; }
    .sglv-fam-item.is-me .sglv-fam-fill { background: linear-gradient(90deg, #66c0f4, #4a9eda); }
    .sglv-fam-games { display: none; padding: 6px 10px 10px; border-top: 1px dashed rgba(255,255,255,0.08); }
    .sglv-fam-item.open .sglv-fam-games { display: block; }
    .sglv-fam-game { display: flex; align-items: center; gap: 8px; padding: 3px 0; }
    .sglv-fam-game-rank { flex: 0 0 20px; font-size: 10px; color: #64748b; text-align: right; }
 /*家庭对比 Top20 行首游戏图标——16px 紧凑尺寸(行高由 12px 名称行 ~17px 决定,
       16px 图标不撑高行;固定尺寸 + flex-shrink:0 保证懒加载零布局抖动) */
    .sglv-fam-game-icon { width: 16px; height: 16px; border-radius: 3px; flex-shrink: 0; object-fit: cover; background: rgba(255,255,255,0.05); }
    .sglv-fam-game-name { flex: 1; min-width: 0; font-size: 12px; color: #c7d5e0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
    .sglv-fam-game-bar { flex: 0 0 90px; height: 4px; border-radius: 2px; background: rgba(255,255,255,0.06); overflow: hidden; }
    .sglv-fam-game-bar > i { display: block; height: 100%; border-radius: 2px; background: linear-gradient(90deg, #66c0f4, #4caf50); }
    .sglv-fam-game-hours { flex: 0 0 58px; text-align: right; font-size: 11px; font-weight: 600; color: #fbbf24; }
    .sglv-fam-empty { padding: 8px 2px; font-size: 11px; color: var(--sglv-text-secondary, #8a9ba8); }
    .sglv-fam-refresh { flex: 0 0 auto; width: 24px; height: 24px; border-radius: 5px; border: 1px solid rgba(102,192,244,0.3); background: rgba(102,192,244,0.1); color: var(--sglv-accent, #66c0f4); cursor: pointer; display: flex; align-items: center; justify-content: center; padding: 0; }
    .sglv-fam-refresh:hover { background: rgba(102,192,244,0.2); }
    .sglv-fam-refresh svg { width: 12px; height: 12px; }
    @media (max-width: 1100px) { .sglv-pt-hero-kpi { grid-template-columns: repeat(3, minmax(0, 1fr)); } }
    @media (max-width: 600px) { .sglv-pt-hero-kpi { grid-template-columns: repeat(2, minmax(0, 1fr)); } }
 /* ====== 全部游戏浮窗 · 入库月历 Tab ====== */
    /* v2.22.6 布局最终形态：**选择器固定 + 详情自带滚动条**（用户明确要求两条）：
           pane(不滚) = toolbar(固定) + grid(固定·完整 12 月卡) + timeline(唯一滚动区)
           —— 走过的弯路与各自的失效点：
              ① grid 收缩 + timeline min-height → timeline 保底生效后，flex 剩余收缩压力
                 全部转嫁 grid，选择器被压到 ~140px（用户截图：日期行被切半、7-12 月整行消失）；
              ② grid 固定 + timeline{flex:1 1 0} 吃剩余 → 选择器完整，但 800px 视口下
                 timeline 只剩 4px，详情几乎不可见；
              ③ 滚动上移到 pane → 选择器/详情都正常，但**滚动条跑到了整个 Tab 区域的最右缘**
                 （贴着窗口边框），用户反馈「滚动条消失、无法滚动查看」——
                 技术上可滚，但滚动入口视觉上不可见 = 等于没有。
           现方案：滚动条还给详情区（.sglv-ptcal-timeline overflow-y:auto），
           grid 固定不压缩，空间冲突由「矮视口紧凑月历」化解（见下方 @media）。*/
     .sglv-ptcal-pane { flex: 1; min-height: 0; display: flex; flex-direction: column; gap: 10px; overflow-y: auto; overscroll-behavior: contain; }
     .sglv-ptcal-toolbar { display: flex; align-items: center; gap: 10px 8px; flex-wrap: wrap; flex: 0 0 auto; }
     .sglv-ptcal-yearnav { display: flex; align-items: center; gap: 4px; flex-shrink: 0; }
     .sglv-ptcal-yearnav-btn { width: 24px; height: 24px; border: 1px solid rgba(102,192,244,0.3); background: rgba(102,192,244,0.1); color: var(--sglv-accent, #66c0f4); border-radius: 5px; cursor: pointer; font-size: 10px; display: flex; align-items: center; justify-content: center; padding: 0; }
     .sglv-ptcal-yearnav-btn:hover { background: rgba(102,192,244,0.2); }
     .sglv-ptcal-yearnav-btn:disabled { opacity: 0.35; cursor: default; }
     .sglv-ptcal-year-label { min-width: 52px; text-align: center; font-size: 15px; font-weight: 700; color: #fff; }
    /* 年份胶囊：单行横向滚动，但宽度有下限保护。
       v2.22.6修正：原写 min-width:0，flex 收缩时容器被压到 ~145px，
       13 个胶囊（flex:0 0 auto 不可压）反而把内容挤成「一排小点」；
       下限 min(200px,45%) 保证至少放得下 4 个胶囊，多出的年份走横向滚动。
       上限 min(52%,460px) 取代旧硬编码 46%（46% 在 1080px 窗口只有 ~500px，
       叠加右侧 summary 后必然溢出被裁）。*/
     .sglv-ptcal-year-chips { display: flex; gap: 4px; flex-wrap: nowrap; flex: 0 1 auto; min-width: min(200px, 45%); max-width: min(52%, 460px); overflow-x: auto; overscroll-behavior-x: contain; scrollbar-width: thin; padding-bottom: 1px; }
     .sglv-ptcal-year-chip { flex: 0 0 auto; border: 1px solid rgba(255,255,255,0.12); background: rgba(255,255,255,0.04); color: #8a9ba8; border-radius: 999px; font-size: 11px; padding: 2px 10px; cursor: pointer; }
     .sglv-ptcal-year-chip:hover { color: #fff; }
     .sglv-ptcal-year-chip.active { color: var(--sglv-accent, #66c0f4); border-color: rgba(102,192,244,0.35); background: rgba(102,192,244,0.1); }
    /*「今年」胶囊——当前年即使在筛选集内无数据（如吃灰榜入库超 1 年）也固定占位，
       绿点标识自然年"此刻"，与入库数量绿色阶同语义但仅为标记点 */
     .sglv-ptcal-year-chip.now::after { content: ''; display: inline-block; width: 5px; height: 5px; border-radius: 50%; background: #39d353; margin-left: 5px; vertical-align: 1px; }
     .sglv-ptcal-year-chip.now.active::after { box-shadow: 0 0 5px rgba(57,211,83,0.9); }
    /* 统计区：允许整块换行到下一行，不再与年份胶囊抢同一行导致右侧被裁 */
     .sglv-ptcal-summary { display: flex; flex-wrap: wrap; align-items: center; justify-content: flex-end; gap: 6px; margin-left: auto; min-width: 0; }
     .sglv-ptcal-chip { font-size: 11px; padding: 2px 9px; border-radius: 999px; background: rgba(102,192,244,0.08); border: 1px solid rgba(102,192,244,0.2); color: #c7d5e0; white-space: nowrap; }
     .sglv-ptcal-chip b { color: var(--sglv-accent, #66c0f4); font-weight: 700; }
     .sglv-ptcal-chip.peak b { color: #fbbf24; }
    /*「仅个人游戏」过滤 chip(复用 ptcal-chip 底样, active 高亮 accent) */
     .sglv-ptcal-chip.tgl { cursor: pointer; }
     .sglv-ptcal-chip.tgl:hover { color: #fff; }
     .sglv-ptcal-chip.tgl.active { color: var(--sglv-accent, #66c0f4); border-color: rgba(102,192,244,0.45); background: rgba(102,192,244,0.16); }
     .sglv-ptcal-legend { display: inline-flex; align-items: center; gap: 3px; font-size: 10px; color: #8a9ba8; flex-shrink: 0; }
     .sglv-ptcal-legend .swatch { width: 10px; height: 10px; border-radius: 2px; display: inline-block; }
    /*6+6 月历组合(每行 6 个月 × 2 行, 替代原 8+4)——
       卡片宽度封顶 240px 确保宽度适中(全屏下不过度拉伸、日格保持可点尺寸),
       space-between 均匀分配余白; <1200px 退化 4 列, <760px 退化 2 列(小屏卡片可用性优先)
       v2.22.6:flex:0 0 auto —— 12 个月卡**永不收缩、永不内部滚动**，
       月历选择区整体固定在顶部，时间线只能从它下方开始。 */
     .sglv-ptcal-grid { display: grid; grid-template-columns: repeat(6, minmax(0, 240px)); justify-content: space-between; gap: 10px 8px; flex: 0 0 auto; }
    @media (max-width: 1400px) { .sglv-ptcal-grid { grid-template-columns: repeat(6, minmax(0, 1fr)); } }
    /* v2.22.6：4 列断点 1200→1000px。1200px 以下就退 4 列时，12 张月卡排成 3 行(~680px)，
       在「窄而高」的窗口（如 1280×1000）里会把详情压到百来像素；收到 1000px 后
       1100~1200px 的常见宽度保持 6 列 2 行，详情可视区明显更充裕。 */
    @media (max-width: 1000px) { .sglv-ptcal-grid { grid-template-columns: repeat(4, minmax(0, 1fr)); } }
    @media (max-width: 760px) { .sglv-ptcal-grid { grid-template-columns: repeat(2, minmax(0, 1fr)); } }
    .sglv-ptcal-month { background: rgba(255,255,255,0.025); border: 1px solid var(--sglv-border, rgba(255,255,255,0.08)); border-radius: 8px; padding: 8px 8px 6px; min-width: 0; }
    .sglv-ptcal-month-head { display: flex; align-items: baseline; justify-content: space-between; gap: 6px; margin-bottom: 5px; }
    .sglv-ptcal-month-name { font-size: 12px; font-weight: 700; color: #c7d5e0; }
    .sglv-ptcal-month-count { font-size: 10px; color: #8a9ba8; }
    .sglv-ptcal-month-count b { color: var(--sglv-accent, #66c0f4); }
    .sglv-ptcal-week, .sglv-ptcal-days { display: grid; grid-template-columns: repeat(7, minmax(0, 1fr)); gap: 2px; }
    .sglv-ptcal-wd { font-size: 9px; color: #64748b; text-align: center; padding-bottom: 1px; }
    .sglv-ptcal-day { aspect-ratio: 1; border-radius: 3px; display: flex; align-items: center; justify-content: center; font-size: 9px; line-height: 1; color: #8a9ba8; background: rgba(255,255,255,0.03); min-width: 0; }
    .sglv-ptcal-day.empty { background: transparent; }
    .sglv-ptcal-day.future { background: rgba(255,255,255,0.012); color: #3d4a5a; }
    .sglv-ptcal-day.has { cursor: pointer; color: #fff; font-weight: 600; }
    .sglv-ptcal-day.has:hover { outline: 1px solid var(--sglv-accent, #66c0f4); }
    .sglv-ptcal-day.sel { outline: 2px solid var(--sglv-accent, #66c0f4); }
    .sglv-ptcal-day.lv1 { background: #0e4429; }
    .sglv-ptcal-day.lv2 { background: #006832; }
    .sglv-ptcal-day.lv3 { background: #26a641; }
    .sglv-ptcal-day.lv4 { background: #39d353; color: #062b13; }
 /*当月入库时间线（常驻展示，倒序：月末 → 月初）
   —— 选中态背景色与该日在月历中的「入库数量色阶」同色（lv1~lv4），
      --ptcal-c 为该级实色（描边/左侧色条），--ptcal-c-soft 为同色低透明背景。 */
 /*tl-body 不设 max-height——滚动由 .sglv-ptcal-timeline 容器承担
       (v2.20.1 曾由外层 pane 统一滚动, 现日历区固定后时间线独立滚动), 分组不再被截断。 */
    /* 时间线 = **详情区自己的滚动容器**（滚动条就在详情区内，用户可直接看到并悬停滚动）。
       min-height:140px 是「详情绝不被压成几像素」的硬保证：极窄而高的窗口
       （如 1080×1000 命中 max-width:1200px 的 4 列断行，月历变3 行 ~680px）
       也不会把详情挤没 —— 此时由 pane 滚动承载，超出部分仍可达。
       scrollbar-gutter:stable 让滚动条常驻占位，避免内容随滚动条出现/消失抖动。 */
    .sglv-ptcal-timeline { flex: 1 1 auto; min-height: 140px; overflow-y: auto; overscroll-behavior: contain; border-top: 1px dashed var(--sglv-border-subtle, rgba(102,192,244,.13)); padding: 0 2px 4px 0; scrollbar-gutter: stable; }
    /* 矮视口紧凑月历（视口高 ≤900px）：12 张标准月卡(~450px) + 详情可视区无法在
       800px 视口的 ~598px pane 内共存。这里把月卡切紧凑档（卡宽 240→170px、
       内距/日格间距收紧），两行总高降到 ~390px，释放的高度全部给详情区，
       实现「选择器完整 + 详情可滚动」同时成立；日格仍有 ~22px，鼠标点击可用。 */
    @media (max-height: 900px) {
      .sglv-ptcal-grid { grid-template-columns: repeat(6, minmax(0, 170px)); gap: 8px 6px; }
      .sglv-ptcal-month { padding: 6px 6px 4px; }
      .sglv-ptcal-month-head { margin-bottom: 3px; }
      .sglv-ptcal-week, .sglv-ptcal-days { gap: 1px; }
      .sglv-ptcal-day { font-size: 8.5px; border-radius: 2px; }
      .sglv-ptcal-wd { font-size: 8px; padding-bottom: 0; }
      .sglv-ptcal-group-games { grid-template-columns: repeat(auto-fill, minmax(170px, 1fr)); }
    }
 /*分组头吸顶——时间线滚动时「当月入库时间线」标题钉在详情区顶部
       (自带底色遮住滚过的内容, 底部投影提示分层)
       v2.22.6: 底色改走 token(原为硬编码 #16202d，浅色主题下是一块深色补丁) */
     .sglv-ptcal-tl-head { position: sticky; top: 0; z-index: 1; display: flex; align-items: baseline; gap: 8px; flex-wrap: wrap; padding: 6px 0 8px; margin-bottom: 0; background: var(--sglv-surface-deep, #16202d); box-shadow: 0 10px 12px -10px rgba(0,0,0,0.65); }
    .sglv-ptcal-tl-title { font-size: 12px; font-weight: 700; color: #fff; display: inline-flex; align-items: center; gap: 6px; }
    .sglv-ptcal-tl-title svg { width: 13px; height: 13px; color: var(--sglv-accent, #66c0f4); }
    .sglv-ptcal-tl-month { font-variant-numeric: tabular-nums; color: var(--sglv-accent, #66c0f4); }
    .sglv-ptcal-tl-hint { font-size: 11px; color: var(--sglv-text-secondary, #8a9ba8); line-height: 1.5; }
    .sglv-ptcal-tl-body { display: flex; flex-direction: column; gap: 6px; }
    .sglv-ptcal-group { border: 1px solid rgba(255,255,255,0.06); border-left: 3px solid transparent; border-radius: 8px; background: rgba(255,255,255,0.02); padding: 6px 8px; transition: var(--sglv-transition); }
    .sglv-ptcal-group.lv1 { --ptcal-c: #0e4429; --ptcal-c-soft: rgba(14,68,41,0.55); }
    .sglv-ptcal-group.lv2 { --ptcal-c: #006832; --ptcal-c-soft: rgba(0,104,50,0.52); }
    .sglv-ptcal-group.lv3 { --ptcal-c: #26a641; --ptcal-c-soft: rgba(38,166,65,0.34); }
    .sglv-ptcal-group.lv4 { --ptcal-c: #39d353; --ptcal-c-soft: rgba(57,211,83,0.28); }
    .sglv-ptcal-group.sel { background: var(--ptcal-c-soft); border-color: var(--ptcal-c); box-shadow: 0 0 0 1px var(--ptcal-c); }
    .sglv-ptcal-group-head { display: flex; align-items: center; gap: 7px; cursor: pointer; }
    .sglv-ptcal-group-date { font-size: 12px; font-weight: 700; color: var(--ptcal-c, #fff); font-variant-numeric: tabular-nums; }
    .sglv-ptcal-group.lv4 .sglv-ptcal-group-date { color: #6ee87a; }
    .sglv-ptcal-group-wd { font-size: 10px; color: #64748b; }
    .sglv-ptcal-group-count { font-size: 10px; font-weight: 700; color: var(--ptcal-c, #c7d5e0); border: 1px solid var(--ptcal-c, rgba(255,255,255,0.2)); background: var(--ptcal-c-soft, rgba(255,255,255,0.06)); border-radius: 999px; padding: 0 8px; margin-left: auto; }
    .sglv-ptcal-group.lv4 .sglv-ptcal-group-count { color: #eafff0; }
    /*游戏条目轨道 200px→190px：单条可用宽度从 ~150px 提到 ~180px，
      「永远消失的幻想乡 ～The Story of...」这类长名不再被压到只剩三四个字。 */
    .sglv-ptcal-group-games { display: grid; grid-template-columns: repeat(auto-fill, minmax(190px, 1fr)); gap: 2px 10px; margin-top: 5px; }
    .sglv-ptcal-detail-item { display: flex; align-items: center; gap: 7px; padding: 3px 6px; border-radius: 5px; font-size: 12px; color: #c7d5e0; cursor: pointer; min-width: 0; }
    .sglv-ptcal-detail-item:hover { background: rgba(102,192,244,0.14); color: #fff; }
    .sglv-ptcal-detail-item img { width: 16px; height: 16px; border-radius: 3px; flex-shrink: 0; }
    .sglv-ptcal-detail-name { flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
    .sglv-ptcal-detail-hours { flex-shrink: 0; font-size: 10px; font-weight: 600; color: #fbbf24; font-variant-numeric: tabular-nums; }
    .sglv-ptcal-detail-empty { font-size: 11px; color: var(--sglv-text-secondary, #8a9ba8); padding: 4px 0; }
    @media (max-width: 900px) { .sglv-ptcal-summary { margin-left: 0; } }
`;

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

 // ==================== 主题层运行时（注册表 + 应用函数） ====================
 // 设计: token 基座(sglv-libs-theme.lib.js，已内联进 PTW 库 → <style id="sglv-theme-base">)
 //     → 共享库蓝基底(:root --sglv-*) → CSS_INLINE 模块样式
 //     → 主题覆盖层(本函数注入, <style id="sglv-theme-style"> 挂 head 末尾)。
 // ⚠️ v2.22.6 id 分工（曾发生线上样式塌陷）：本函数整体替换 id="sglv-theme-style" 的内容，
 //    因此该 id 归「主题覆盖层」独占；token 基座另用 id="sglv-theme-base"。
 //    二者曾共用一个 id → applySglvTheme() 把基座（:root 全量 token + PTW 基座样式）整体抹掉，
 //    padding/gap/border-radius/font-size/transition/box-shadow 集体失效，浮窗整体塌陷。
 // 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();
 //每次应用都重挂 head 末尾——收藏库(sglv-game-collection)首次开面板才懒注入
 // 其 <style>(物理位置晚于本元素),appendChild 移动节点保证主题层在层叠顺序上始终最后
        document.head.appendChild(el);
        window.dispatchEvent(new CustomEvent('sglv-theme-changed', { detail: { themeId: theme.id } }));
        return theme.id;
    }


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

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

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

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

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

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

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

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

 //进包/卡牌 KPI 卡片颜色 + badge 样式
 //卡片一行不换行 + 可点击筛选 + active 高亮
 // CSS 已提取到顶部: CSS_KPI

 // CSS 已提取到顶部: CSS_SUBSTATUS

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

 // ==================== I18N ====================
    const isZh = (navigator.language || '').toLowerCase().startsWith('zh');
    const T = {
        title: isZh ? '游戏库' : 'Game Library',
        tabOwned: isZh ? '游戏橱窗' : 'Game Showcase',
 //个人展柜标签页
        tabShowcase: isZh ? '个人展柜' : 'Showcase',
        tabPublisher: isZh ? '系列分类' : 'By Series',
        tabTrend: isZh ? '入库趋势' : 'Acquisition Trends',
 //入库趋势动态（趋势图 + 入库时间线）
        trendChartTitle: isZh ? '入库趋势图' : 'Trend Chart',
        trendTimelineTitle: isZh ? '入库时间线' : 'Acquisition Timeline',
        trendTimelineTotal: isZh ? '入库总数' : 'Total',
 //入库频率分析
        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',
 //我的成就标签页 — 重构版
        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',
 //全局游戏搜索（中文/拼音缩写/英文子串）
        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',
 //游戏详情浮窗
        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',
 //统计仪表新增 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...',
 //游玩数据页重构——HERO 摘要 / 时长集中度 / 活跃度分层 / 全屏排行浮窗
        ptHeroRecent: isZh ? '近2周时长' : '2-Week Hours',
        ptHeroRecentSub: isZh ? '需配置 API Key' : 'API key required',
        ptHeroLongest: isZh ? '最长单游' : 'Longest Game',
        ptHeroMedian: isZh ? '中位数' : 'Median',
 //中位数改按已游玩口径(全库中位在未游玩过半的真实库恒为 0),sub 标注样本量
        ptHeroMedianSub: isZh ? '已游玩 {n} 款的中位' : 'median of {n} played',
        ptHeroMedianNone: isZh ? '从未游玩' : 'never played',
        ptConcTitle: isZh ? '时长集中度' : 'Playtime Concentration',
        ptConcTop: isZh ? '前 {n} 款占全部游玩时长的 {p}%' : 'Top {n} games account for {p}% of total playtime',
        ptConcHalf: isZh ? '，前 {n} 款即吃掉一半时长' : ', top {n} reach 50%',
        ptActTitle: isZh ? '活跃度分层（按最近游玩）' : 'Activity Layers (by Last Played)',
        ptActHint: isZh ? '点击任一分层查看该层排行' : 'Click a layer to open its ranking',
        ptDustScanning: isZh ? '正在统计吃灰游戏…' : 'Scanning idle games…',
        ptDustView: isZh ? '查看吃灰榜' : 'View idle list',
        ptDustText: isZh ? '入库超 1 年却从未启动' : 'Owned over a year, never launched',
 //──── v2.32.0 「游玩分析」Tab 文案（PTW 分析层） ────
        ptPlayTabLabel: isZh ? '游玩分析' : 'Play Analysis',
        ptPlayDistTitle: isZh ? '时长分档分布' : 'Playtime Distribution',
        ptPlayDistModeCount: isZh ? '按游戏数' : 'By count',
        ptPlayDistModeHours: isZh ? '按时长' : 'By hours',
        ptPlayInsightTitle: isZh ? '玩家画像（5 维）' : 'Player Profile (5 dims)',
        ptPlayInsightSub: isZh ? '本地规则推断，非 AI 评分' : 'Local rule-based, not AI scoring',
        ptPlayRecentTitle: isZh ? '最近两周游玩' : 'Last 2 Weeks',
        ptPlayRecentEmpty: isZh ? '最近两周没有游玩记录' : 'No play in the last 2 weeks',
        ptPlayRecentNeedKey: isZh ? '需要 Steam Web API Key 才能读取近两周时长' : 'Steam Web API Key required for 2-week playtime',
        ptPlaySciTitle: isZh ? '剧情完成度（SCI）' : 'Story Completion (SCI)',
        ptPlaySciSub: isZh ? '累计时长 ÷ 剧情基准时长，衡量你玩到了主线的多少' : 'Total playtime / story baseline',
        ptPlaySciNoData: isZh ? '暂无剧情时长数据（未接入 HLTB 索引）' : 'No story-length data (HLTB index not loaded)',
        ptPlaySciSample: isZh ? '基于 {n} 款有剧情数据的游戏' : 'Based on {n} games with story data',
        ptPlayRadarEmpty: isZh ? '洞察数据不可用' : 'Insight data unavailable',
        ptPlayTitle: isZh ? '游玩分析' : 'Play Analysis',
 //──── v2.32.0 「库分析」Tab 文案 ────
        ptLibTabLabel: isZh ? '库分析' : 'Library Analysis',
        ptLibEraTitle: isZh ? '发行年代分布' : 'Release Era Distribution',
        ptLibEraScope: isZh ? 'Steam 可用部分' : 'Steam-available subset',
        ptLibEraRef: isZh ? 'HLTB 全量参考' : 'HLTB full population',
        ptLibEraBias: isZh ? '样本偏差 {n}pt —— 主机独占游戏未计入，实际年代更早' : 'Sample bias {n}pt — console-exclusive titles excluded',
        ptLibGenTitle: isZh ? '类型分布' : 'Genre Distribution',
        ptLibSilTitle: isZh ? '沉默库存' : 'Silent Stock',
        ptLibSilDesc: isZh ? '已入库但从未启动 · 按剧情时长从短到长（最容易救回）· 前 10 款' : 'Never launched · shortest story first · top 10',
        ptPotTabLabel: isZh ? '潜力清单' : 'Potentials',
        ptPotFastTitle: isZh ? '最快通关' : 'Fastest to Finish',
        ptPotTasteTitle: isZh ? '口味最对' : 'Best Taste Match',
        ptPotSilentTitle: isZh ? '沉默库存' : 'Silent Stock',
        ptPotEmpty: isZh ? '暂无匹配结果（口味画像或标签数据不足）' : 'No matches (insufficient taste/tag data)',
        ptPotEstHours: isZh ? '预计 {h} 小时' : '~{h}h est.',
        ptAllOpenBtn: isZh ? '全部游戏排行' : 'All Games',
        ptAllOpenTip: isZh ? '打开全部游戏时长排行（全屏浮窗）' : 'Open full playtime ranking (fullscreen)',
        ptWinTabAll: isZh ? '全部游戏' : 'All Games',
        ptWinTabFamily: isZh ? '家庭对比' : 'Family Compare',
 //全部游戏浮窗「入库月历」Tab
        ptWinTabCalendar: isZh ? '入库月历' : 'Entry Calendar',
        ptCalLoading: isZh ? '正在获取入库时间…' : 'Loading acquisition times…',
        ptCalNoData: isZh ? '未获取到入库时间数据' : 'No acquisition data available',
        ptCalNoDataHint: isZh ? '入库月历依赖家庭组共享库/个人许可页的入库时间，请先登录 Steam 后重试' : 'The calendar needs acquisition times from the family library / licenses page. Sign in to Steam and retry.',
        ptCalYearTotal: isZh ? '本年入库' : 'Acquired this year',
        ptCalPeakMonth: isZh ? '最猛月份' : 'Peak month',
        ptCalPeakDay: isZh ? '单日峰值' : 'Peak day',
        ptCalMonthsCovered: isZh ? '覆盖月份' : 'Months covered',
        ptCalUnit: isZh ? '款' : 'games',
 //年份 chips 上「今年」胶囊的 title（当前年即使无数据也固定占位）
        ptCalThisYear: isZh ? '今年' : 'This year',
        ptCalNoDataThisYear: isZh ? '当前筛选集在今年暂无入库记录' : 'No entries this year in the current filter',
 //导航栏二级菜单「游戏数据」入口（直接打开全部游戏浮窗）
        ptMenuGameData: isZh ? '游戏数据' : 'Game Data',
 //取消 ▾ 箭头后, 面板入口迁入下拉首项(默认选中高亮)
        ptMenuOpenPanel: isZh ? '打开游戏库面板' : 'Open Library Panel',
        ptMenuOpenPanelTip: isZh ? '打开中央游戏库面板（橱窗 / 时长 / 洞察 / 愿望单等）' : 'Open the central library panel',
        ptMenuGameDataTip: isZh ? '全部游戏排行 / 家庭对比 / 入库月历（全屏浮窗）' : 'All games ranking / Family compare / Entry calendar (fullscreen)',
        ptMenuDataEmpty: isZh ? '游戏库数据尚未加载，请先打开面板等待数据加载' : 'Library data not loaded yet — open the panel and wait',
 //月历下方常驻「当月入库时间线」——默认展示当月、按日倒序（月末→月初），
 // 点日历色块即高亮对应日期分组（高亮底色 = 该日入库数量色阶）
        ptCalTimeline: isZh ? '当月入库时间线' : 'This Month Timeline',
        ptCalTimelineHint: isZh ? '按时间倒序（月末 → 月初）· 点击日历中的色块日期可高亮当天记录' : 'Reverse-chronological (month-end → month-start) · click a colored day to highlight its records',
        ptCalTimelineEmpty: isZh ? '本月暂无入库记录' : 'No entries this month',
        ptCalTimelineEmptyHint: isZh ? '点击月历中有色块的日期，即可查看并高亮当天记录' : 'Click a colored day in the calendar to view and highlight its records',
        ptCalOpenStore: isZh ? '在 Steam 商店打开' : 'Open in Steam Store',
        ptCalPrevYear: isZh ? '上一年' : 'Previous year',
        ptCalNextYear: isZh ? '下一年' : 'Next year',
        ptCalFuture: isZh ? '未到时间' : 'Not yet',
        ptSortPlaytime: isZh ? '时长降序' : 'Playtime',
        ptSortRecent: isZh ? '最近游玩' : 'Last Played',
        ptSortAcquired: isZh ? '入库时间' : 'Acquired',
        ptSortName: isZh ? '名称' : 'Name',
        ptSortAcquiredLoading: isZh ? '正在获取入库时间…' : 'Loading acquisition times…',
 //全部游戏排行过滤 chips + 排序方向切换
        ptFilterUnplayed: isZh ? '隐藏从未游玩' : 'Hide unplayed',
        ptFilterShared: isZh ? '隐藏家庭共享' : 'Hide family shared',
        ptSortAsc: isZh ? '↑ 正序' : '↑ Asc',
        ptSortDesc: isZh ? '↓ 倒序' : '↓ Desc',
 //入库月历「仅个人游戏」过滤（排除家庭共享入库）
        ptCalPersonalOnly: isZh ? '仅个人游戏' : 'Personal only',
        ptCalPersonalOnlyTip: isZh ? '月历与时间线仅统计本人拥有的游戏（排除家庭共享入库）' : 'Count only games owned by me (exclude family-shared entries)',
        ptCalPersonalEmpty: isZh ? '该筛选集内个人游戏暂无入库记录' : 'No personal-only entries in this filter',
 //全 0 时长列表的排序兜底说明 + 入库时间缺失回退
        ptZeroPtHint: isZh
            ? '该列表内游戏均为 0 时长，时长列无法区分先后——按入库时间/最近游玩倒序兜底排列'
            : 'All games here have 0 playtime; fallback order (acquired / last played) is applied.',
        ptSortAcquiredEmpty: isZh ? '未获取到入库时间，已回退时长排序' : 'No acquisition data — fell back to playtime sorting',
 //持久缓存 / 按周增量 / 家庭成员 Top20
        ptWeeklyUpdated: isZh ? '游玩时长已按周增量更新（{n} 款变化）' : 'Playtime updated weekly ({n} changed)',
        ptFamRefreshTip: isZh ? '刷新家庭成员数据（默认按周缓存）' : 'Refresh family data (weekly cache)',
        ptFamTop20: isZh ? 'Top 20 游玩时长' : 'Top 20 Playtime',
        ptFamNoGames: isZh ? '暂无游玩时长数据' : 'No playtime data',
        ptFamPrivate: isZh ? '获取失败，该成员资料可能为私密' : 'Failed — profile may be private',
        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',
 //入库热力图与家庭组占位
        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',
 //热力图按年分割
        ptHeatmapAll: isZh ? '全部' : 'All',
 //热力图右下角近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',
 //进包/卡牌筛选与 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',
 //DLC 分离统计与仅 DLC 筛选
        categoryDlcOnly: isZh ? '仅 DLC' : 'DLC Only',
        statsDlcTotal: isZh ? 'DLC 总数' : 'DLC Total',
        kpiDlcMusic: isZh ? '音乐' : 'Music',
        kpiDlcBundled: isZh ? '进包' : 'Bundled',
 //库存排序
        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',
 //KPI 卡片子文本
        kpiAvgHours: isZh ? '均' : 'Avg',
        kpiPerGame: isZh ? '/款' : '/game',
        kpiRate: isZh ? '占比' : 'Rate',
        kpiOfTotal: isZh ? '占总数' : 'of total',
 //游玩率/完成度 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',
 //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',
 //外观主题切换（典雅紫/经典蓝，主题名取自 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',
 //设置集成进主面板——返回按钮文案
        settingsBack: isZh ? '返回游戏库' : 'Back to Library',
        steamApiSection: isZh ? 'Steam API 配置' : 'Steam API Settings',
 //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 价格预测
        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',
 // ====== 愿望单标签页 ======
        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',
 // ====== 打折曲线弹窗 + 新史低预测（借鉴 steam-friend-manager） ======
        wlCurveTip: isZh ? '价格历史与史低预测' : 'Price history & low prediction',
        wlCurveTitle: isZh ? '打折曲线' : 'Price Curve',
        wlCurveLoading: isZh ? '正在获取历史价格…' : 'Fetching price history…',
        wlCurveNoData: isZh ? '暂无历史价格数据（可在设置配置 ITAD API Key 获得完整数据）' : 'No price history (configure ITAD API key in settings for full data)',
        wlCurveLowest: isZh ? '史低' : 'Lowest',
        wlCurveNow: isZh ? '现价' : 'Now',
        wlPredictTitle: isZh ? '下次新史低预测' : 'Next Historical Low Prediction',
        wlPredictDue: isZh ? '已到预测窗口，随时可能' : 'Due now',
        wlPredictStalled: isZh ? '节奏停滞或已达底线' : 'Stalled / floor reached',
        wlPredictIn: isZh ? '约' : 'in',
        wlPredictDays: isZh ? '天' : 'd',
        wlPredictLast: isZh ? '上次史低' : 'Last low',
        wlPredictGap: isZh ? '史低间隔' : 'Low interval',
        wlPredictNextCut: isZh ? '预计折扣' : 'Predicted cut',
        wlConfHigh: isZh ? '可信度高' : 'High confidence',
        wlConfMid: isZh ? '可信度中' : 'Medium confidence',
        wlConfLow: isZh ? '可信度低' : 'Low confidence',
        wlCurveSource: isZh ? '数据源' : 'Source',
        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',
 // ====== 愿望单仪表盘增强 ======
        wlPriceDist: isZh ? '价格区间分布' : 'Price Range Distribution',
        wlAddedByYear: isZh ? '按年添加趋势' : 'Added by Year',
        wlKpiTotalValue: isZh ? '总价值' : 'Total Value',
        wlKpiOnSale: isZh ? '打折中' : 'On Sale',
 //混合币种聚合提示(部分条目缺汇率被排除时在 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)',
 // ====== 愿望单我的类别统计 ======
        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 会免标签页 ======
        tabPsplus: isZh ? 'PS 会免' : 'PS Plus',
 // ====== Humble Choice 月包分析（借鉴 steam-friend-manager） ======
        tabHumble: isZh ? 'Humble月包' : 'Humble Choice',
        humbleSearch: isZh ? '搜索游戏 / 发行商…' : 'Search game / publisher…',
        humbleKpiMonths: isZh ? '月包数' : 'Months',
        humbleKpiGames: isZh ? '游戏总数' : 'Total Games',
        humbleKpiOwned: isZh ? '已拥有' : 'Owned',
        humbleKpiUnowned: isZh ? '未拥有' : 'Not Owned',
        humbleMonthLabel: isZh ? '第' : 'Choice #',
        humbleOwnedIn: isZh ? '已收' : 'Owned',
        humbleFilterAll: isZh ? '全部' : 'All',
        humbleFilterOwned: isZh ? '已拥有' : 'Owned',
        humbleFilterUnowned: isZh ? '未拥有' : 'Not Owned',
        humbleNoData: isZh ? '月包数据加载失败（@resource 不可用）' : 'Failed to load bundle data (@resource unavailable)',
        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 在库标识（区分 PS 在库状态） ======
        steamInLib: isZh ? 'steam在库' : 'Steam Owned',
 // ====== Epic 赠送标签页 ======
        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',
 // ====== 年度大作标签页 ======
        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',
 // ====== 锁区游戏标签页 ======
        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',
 // ====== 云存档标签页 ======
        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',
 //后台静默刷新状态
        csBgRefreshing: isZh ? '后台更新中…' : 'Background updating…',
        csBgRefreshDone: isZh ? '后台更新完成，新增 {n} 款' : 'Background update done, +{n}',
 // ====== DLC 收藏标签页 ======
        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,

 // ====== 愿望单标签页状态 ======
        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__'=未分类）

 // ====== 我的成就标签页状态 ======
        achMainTab: '',               // 主视图：'steam'(真实成就) / 'custom'(自定义成就) / ''=自动（v2.44.0 起默认 Steam）
        achSelectedCat: 'all',        // 自定义成就分类（仅底部徽章架内部使用）
        achDeepTab: 'perfect',        // 真实成就深度面板当前标签 ('perfect'/'rare'/'gap')
        achSteamView: 'games',        // v2.44.0：Steam 成就子视图 'games'(游戏成就矩阵) / 'insights'(聚合分析)
        achNavView: 'all',            // v2.44.0：左栏游戏维度导航 'all'/'perfect'/'rare'/'gap'/'private'/'unsynced'
        achShelfOpen: false,          // v2.44.0：自定义成就徽章架是否展开
        achShelfTouched: false,       // v2.44.0：用户是否手动操作过徽章架（手动过就以用户为准）
        // v2.44.2：游戏成就矩阵工具栏（借鉴收藏模块的「完成度 / 排序 / 视图」工具栏）
        achMatrixPage: 1,              // 当前页码
        achMatrixPageSize: 50,         // 每页行数
        achMatrixSort: 'rate',         // 排序键：rate/rare/recent/count/name
        achMatrixView: 'list',         // 视图：list(行) / card(卡片)
        achMatrixQuery: '',            // 矩阵内搜索词

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

 // ====== 云存档标签页状态 ======
        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 缓存恢复）

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

 //统一 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;
    }

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

 //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('');
    }

 //空态工厂——统一 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>`;
    }

 // ==================== 骨架屏统一工厂 ====================
 // 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 略亮以区分背景
 //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)}` });
            }
 //与 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>`;
 //结构与实际渲染一致——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) => {
 //愿望单首次加载骨架屏——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);
    }

 // ==================== 水平条形行工厂 ====================
 // 收编 15 处 name+track+fill(+val) 结构重复;
 // 前缀表驱动各命名空间现状 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;
    }

 //三视图统一渲染器——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。
 // 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>`;
        }
 //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>`;
    }

 //列表工具栏工厂——搜索/排序/视图切换/尾部插槽按配置注入,
 // 事件经 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 属性,
 // owned 形态保持此行为);云存档传 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;
    }

 //通用选择器弹窗工厂——封面/徽章选择器两份骨架重复实现收敛为单实现。
 // 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);
    }

 //愿望单加载阶段计算——消除 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 };
    }
 //愿望单加载块——改经 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,
        });
    }

 //统一 Tab 切换函数——消除 5 处重复的 "设置 activeTab + 更新 DOM active 类 + renderBody" 逻辑
 // 调用方：_gsJumpToGame(owned/wishlist 跳转)、tab click handler、_onOpenModal 事件
 //本函数位于子闭包之外，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();
    }

 // ==================== 全局游戏搜索（中文/拼音缩写/英文子串匹配） ====================
 // 参考 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（@require 引入）。
 // 主脚本通过 _getPinyinLib() 委托 searchByPinyin,不再需要本地 toPinyinAbbr 包装。
 // - 查表来源：SGLVPinyin._TABLE（~3857 常用汉字，ASCII 数字/英文直通）
 // - 行为契约：空格/标点保留、英文小写、CJK 查表、未收录字符保留原字符（允许 substring 兜底匹配）
 //从一次性求值的 const 改为实时求值函数 _getPinyinLib(),
 // 解决 @require 脚本因网络延迟晚于主脚本执行时拼音库永久不可用的问题
    function _getPinyinLib() {
        return (typeof window !== 'undefined' && window.SGLVPinyin)
            || (typeof unsafeWindow !== 'undefined' && unsafeWindow.SGLVPinyin)
            || null;
    }
 //移除 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;

 //统一标点/空格剥离正则——与 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) 已拥有(优先级最高)
 //保留 _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
 //移除 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 条
 //优化: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> 包裹
 //增加拼音首字母匹配高亮——用户输入"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));
            }
        }
 //拼音首字母匹配高亮——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;
    }

 // ==================== 全局游戏搜索 - 事件绑定/下拉渲染/键盘导航/游戏跳转 ====================
 // 设计：搜索框绑定防抖输入/键盘/外部点击事件；下拉浮层渲染前 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;
    }

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

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

 //Steam 商店搜索建议 (异步合并到本地搜索结果)
    let _gsStoreSearchToken = 0;  // 竞态保护: 每次新查询递增, 旧请求返回时丢弃

 // ---- 商店搜索增强（借鉴 GreasyFork #576594「Steam 链接助手」）----
 // ① demo/prologue 排污：非 demo 查询下把 demo/prologue 项降权排尾（借其 selectBest
 //    思路；下拉是列表不是单选，故降权不直接过滤 —— 搜得到，只是不让它挤掉本体）
 // ② cc/l 区域：跟随页面自身商店语言/地区（#application_config data-config），
 //    不再硬编码 l=schinese&cc=cn（非国区账号看到的价格/结果会错）
 // ③ 删词回退：0 结果才放宽，最多 2 级（对齐 mv-search.shrinkQuery）。
 //    只剥掉尾部标点，或删掉最后一个空白分隔的词。响应异常不回退。
 //    中文 / 日文 / 连字符整体算一个词。v2.46.0 用 \w 判断，CJK 每个字都不是 \w，
 //    「艾尔登法环」会被逐字削成「艾」并把不相干的商店结果灌进下拉。
    function _gsIsWordChar(ch) {
        return /[\p{L}\p{N}_]/u.test(ch);
    }
    function _gsShrinkStoreQuery(q) {
        const s = String(q || '').trim();
        if (!s) return '';
        let end = s.length;
        while (end > 0 && !_gsIsWordChar(s[end - 1])) end--;
        const stripped = s.slice(0, end).trimEnd();
        if (stripped !== s) return stripped;
        const m = stripped.match(/^(.*)\s+\S+$/);
        if (!m) return '';
        return m[1].trimEnd();
    }

 // 词边界匹配，避免 Demolition 之类误伤（参考脚本用 includes('demo') 会误伤）
    const _GS_STORE_PROHIBITED_RE = /\bdemo\b|\bprologue\b|试玩|体验版|序章/i;
    function _gsStoreIsProhibited(name) {
        return _GS_STORE_PROHIBITED_RE.test(String(name || ''));
    }

    function _gsDemoteStoreItems(items, query) {
        if (_gsStoreIsProhibited(query)) return items;  // 用户本就在搜 demo, 不动
        const clean = [], demoted = [];
        for (const it of items) (_gsStoreIsProhibited(it.name) ? demoted : clean).push(it);
        return clean.concat(demoted);
    }

    function _gsStoreLocale() {
        let cfg = null;
        try {
            const el = document.querySelector('#application_config');
            cfg = JSON.parse((el && el.getAttribute('data-config')) || 'null');
        } catch (e) { cfg = null; }
        return {
            lang: (cfg && cfg.LANGUAGE) ? String(cfg.LANGUAGE).toLowerCase() : (isZh ? 'schinese' : 'english'),
            cc: (cfg && cfg.COUNTRY) ? String(cfg.COUNTRY).toLowerCase() : 'cn',
        };
    }

    async function searchSteamStore(query) {
        const token = ++_gsStoreSearchToken;
        try {
            const loc = _gsStoreLocale();
            let q = String(query || '').trim();
            let items = [];
            let shrinks = 0;
            while (q) {
                const url = `https://store.steampowered.com/api/storesearch/?term=${encodeURIComponent(q)}&l=${loc.lang}&cc=${loc.cc}&max_results=15`;
                const data = await sglvGmFetchRetry(url, { timeout: 5000, retries: 0 });
                if (token !== _gsStoreSearchToken) return [];  // 旧请求, 丢弃
                if (!data || !Array.isArray(data.items)) return [];  // 响应异常, 不回退
                if (data.items.length) { items = data.items; break; }
                if (shrinks >= 2) break;  // 原查询 + 最多 2 级，对齐 mv-search.shrinkQuery
                const next = _gsShrinkStoreQuery(q);
                if (!next || next === q) break;
                q = next;
                shrinks++;
            }
            return _gsDemoteStoreItems(items, query).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 [];  // 商店搜索失败, 静默降级
        }
    }

 //合并本地+商店搜索结果 (去重, 本地优先)
    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;
    }

 //精准匹配检测 (查询为纯数字时匹配 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 };
    }

 //搜索结果项单一构建器——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>`);
 //精准匹配徽章
        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>`);
 //拥有/共享状态徽章(基于 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);
 //getGameIconUrl 定义于下方渲染子闭包(7718 行 IIFE)，此处 bare 引用不可见——
 // 旧 typeof 守卫恒为 false，缩略图从未真正接通过 capsule 兜底；改经 SGLV_API 桥接
 // (渲染子闭包求值时已填充，全局搜索渲染时必可用)
        const capSrc = entry._storeImg || (SGLV_API.getGameIconUrl ? SGLV_API.getGameIconUrl(entry.appid, '') : '');
 //外链图标仅在 store-only 时显示(owned/wishlist 是面板内跳转)
        const extIcon = (!owned && !wishlist) ? `<span class="sglv-gs-item-ext">${ICONS.external}</span>` : '';
 //商店搜索结果附加价格/评测信息
        let storeInfoHtml = '';
        if (entry._storeResult && entry._storePrice && entry._storePrice.final > 0) {
            const sp = entry._storePrice;
 //¥ 硬编码替换为 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>`;
    }

 //搜索页脚键盘提示(两路径共用)
    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>`;
    }

 //头部+列表+页脚渲染与条目事件绑定(两路径共用;调用方保证 _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) {
            _gsLastQuery = '';  // 清空后，在途的商店响应不得把下拉再弹出来
            _gsShowPop(false);
            _gsLastResults = [];
            return;
        }
        const results = searchGames(q, 30);
        _gsLastQuery = q;
        _gsFocusIdx = -1;
 //精准匹配检测
        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;
 // 空结果先出空态，但不 return：0 条同样要问商店
 // （v2.46.0 及更早在这里 return，库里没有的游戏永远不会发商店请求）
        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);
        } else {
 //头部+列表+页脚渲染与事件绑定经 renderGsResults 共用(原内联段删除)
            renderGsResults(q, results);
        }
 //本地结果不足 8 条时,异步合并 Steam 商店搜索建议（含 0 条）
        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(() => {});
        }
    }

 //合并后重渲染 (不触发商店搜索, 避免递归)
    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' });
        }
    }

 //游戏详情浮窗 —— 点击搜索结果后弹出详情卡片
 // 依赖 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, token);
        } 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));
    }

 //异步填充资料受限状态徽章到搜索详情浮窗
 // 参考 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
 //经 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) {
 // 静默失败,不影响浮窗正常使用
 //补终态失败通知(60s 节流,此前完全静默)
            sglvNotifyNetFail('资料受限徽章检测', e);
        }
    }

    function _renderDetailContent(pop, appid, entry, d, token) {
        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');
        }
 // 价格
 //修复货币符号 — 优先使用 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>`;
        }
 //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}`);
        });

 //问 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 });
        });

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

 // 跳转游戏核心逻辑
 //统一弹出游戏详情浮窗(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;
        },
    };

 //把主脚本的拥有/共享判定 API 注入到 sglv-app-detail 库,
 // 这样搜索结果下拉和其他上层都能用 SGLVAppDetail.getOwnershipBadge(appid) 拿到统一状态
 //从 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 };
    }

 // ==================== 智能并发池（借鉴 steam-friend-manager _concurrentPool） ====================
 // 429 限流自动降速（并发 ×0.7、下限 1）+ 指数退避重试 + in-flight 动态闸门 + 幻影任务复查。
 // tasks: [() => Promise<any>]；resolve 后返回 results 数组（成功位为返回值，最终失败位为 undefined）。
 // 错误对象 message 需含 "429"/"rate" 才会触发降速（requestSteamAPI 的 reject 为 `HTTP 429` 格式，天然兼容）。
    function sglvSmartPool(tasks, concurrency, opts = {}) {
        const MAX_RETRY = opts.maxRetry != null ? opts.maxRetry : 2;
        const cap = Math.max(1, Math.min(concurrency, tasks.length));
        const results = new Array(tasks.length);
        let nextIndex = 0;
        let inFlight = 0;
        let activeConcurrency = cap;
        const isRateLimited = (e) => {
            const m = (e && e.message) ? String(e.message) : String(e || '');
            return m.includes('429') || m.toLowerCase().includes('rate');
        };
        async function runTask(index) {
            for (let retry = 0; retry <= MAX_RETRY; retry++) {
                try {
                    results[index] = await tasks[index]();
                    return;
                } catch (e) {
                    if (retry === MAX_RETRY) return; // 最终失败：结果位保持空，不污染进度
 // 退避重试：首次 1s、二次 2s；429 额外 +1s 并立即降并发
                    const rate = isRateLimited(e);
                    await new Promise(r => setTimeout(r, (retry === 0 ? 1000 : 2000) + (rate ? 1000 : 0)));
                    if (rate) activeConcurrency = Math.max(1, Math.floor(activeConcurrency * 0.7));
                }
            }
        }
        async function worker() {
            while (nextIndex < tasks.length) {
 // 动态闸门：429 降速后在途数须低于当前上限才取新任务
                while (inFlight >= activeConcurrency) await new Promise(r => setTimeout(r, 100));
 // 唤醒后复查：等待期间任务可能已被其他 worker 取完（避免 undefined 幻影任务）
                if (nextIndex >= tasks.length) break;
                const idx = nextIndex++;
                inFlight++;
                try { await runTask(idx); } finally { inFlight--; }
            }
        }
        const workers = [];
        for (let i = 0; i < cap; i++) workers.push(worker());
        return Promise.all(workers).then(() => results);
    }

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

 // 封面图成功 URL 缓存：记录已成功加载的封面地址，下次优先使用，减少回退探测请求
 //缓存键按图片种类（poster/capsule/header）隔离，避免竖版海报 URL 被横版封面复用导致裁切变形
 //三级持久缓存（借鉴 steam-friend-manager）——内存 Map 即时生效 +
 // GM_setValue 整体镜像（防抖 2s 批量写 + beforeunload 冲刷防丢）+ 启动惰性恢复，
 // 刷新页面后无需对 CDN 404 封面重新逐个探测 Store API。
    const _posterGoodUrl = new Map();
    const SGLV_COVER_BK_KEY = 'sglv_bk_cover_map';
    const SGLV_COVER_BK_MAX = 2 * 1024 * 1024;   // GM 配额保护上限（2MB）
    let _coverBkTimer = null;
    let _coverBkLoaded = false;
    function _coverBkRestore() {
        if (_coverBkLoaded) return;
        _coverBkLoaded = true;
        try {
            const s = GM_getValue(SGLV_COVER_BK_KEY, null);
            if (s) {
                const obj = JSON.parse(s);
                let n = 0;
                // v2.31.2: 只跳过 data:/blob: 垃圾条目（历史版本可能写入过占位图），
                //   http(s) 条目一律恢复 —— 旧缓存能用的绝不重新探测
                Object.keys(obj).forEach(k => {
                    const u = obj[k];
                    if (typeof u === 'string' && /^https?:\/\//i.test(u) && !_posterGoodUrl.has(k)) { _posterGoodUrl.set(k, u); n++; }
                });
                if (n) console.log(`[SGLV] 封面 URL 持久缓存已恢复 ${n} 条`);
            }
        } catch (e) { /* 备份损坏时静默重建 */ }
    }
    function _coverBkFlush() {
        if (_coverBkTimer) { clearTimeout(_coverBkTimer); _coverBkTimer = null; }
        try {
            let obj = {};
            _posterGoodUrl.forEach((url, k) => { obj[k] = url; });
            let s = JSON.stringify(obj);
            if (s.length > SGLV_COVER_BK_MAX) {
 // 超限：仅保留最近 8000 条（Map 迭代序≈插入序，老旧条目先淘汰）
                //   v2.31.2: 4000 → 8000 —— 大库(2000+ 游戏 × poster/header/capsule)
                //   4000 条会在 LRU 边缘反复淘汰仍在用的 URL；8000 条约 1MB，仍在 2MB 保护线内
                obj = {};
                const entries = Array.from(_posterGoodUrl.entries());
                entries.slice(-8000).forEach(([k, u]) => { obj[k] = u; });
                s = JSON.stringify(obj);
            }
            if (s.length <= SGLV_COVER_BK_MAX) GM_setValue(SGLV_COVER_BK_KEY, s);
        } catch (e) { /* 配额/序列化失败静默 */ }
    }
    function _coverBkSchedule() {
        if (_coverBkTimer) return;
        _coverBkTimer = setTimeout(() => { _coverBkTimer = null; _coverBkFlush(); }, 2000);
    }
    try { window.addEventListener('beforeunload', _coverBkFlush); } catch (e) { /* 非页面环境忽略 */ }
    function recordPosterGood(appid, url, kind) {
        if (!appid || !url) return;
        // v2.31.1: 只记录 http(s)。占位用的 data:image/svg+xml / blob: 一旦进缓存，
        //   下次渲染就以占位图作为初始 src（永远"加载成功"但永远没有封面）。
        if (!/^https?:\/\//i.test(url)) return;
        _coverBkRestore();
        const key = `${kind || 'poster'}:${appid}`;
        // v2.31.2: URL 未变化则不重复调度整表落盘 —— 每次 onload 都写会放大 GM 写入量
        if (_posterGoodUrl.get(key) === url) return;
        _posterGoodUrl.set(key, url);
        _coverBkSchedule();
    }
    function getPosterGood(appid, kind) {
        _coverBkRestore();
        const u = _posterGoodUrl.get(`${kind || 'poster'}:${appid}`);
        // v2.31.1: 历史版本可能把 data: 占位图写进过持久缓存 —— 读到也当没有，强制重新探测
        return (u && /^https?:\/\//i.test(u)) ? u : '';
    }
 // 暴露给内联 onload 使用
    unsafeWindow._sglvRecordPosterGood = function(appid, url, kind) {
        recordPosterGood(appid, url, kind);
        // v2.31.2: 横版图额外写 header 槽位 —— 收藏/受限/PS/Epic 视图可以直接复用，
        //   同一张 header.jpg 不再在每个面板各探一次链
        try {
            if (url && /^https?:\/\//i.test(url) && url.indexOf('library_600x900') < 0) {
                recordPosterGood(appid, url, 'header');
            }
        } catch (e) { /* ignore */ }
    };

 //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),
 // ---- 数据回流（relay）：v2.45.0 已整体下线，存储开关一并移除 ----
 // ---- API Key 同意门（v2.45.0）----
 // '' = 未判定；'agreed' = 用户已勾选同意；'legacy' = 存量用户（升级前就在用）直接放行。
 // 为什么要有第三种：老用户升级不该被同意门拦住，判定只做一次并落盘（见 _initApiKeyConsent）。
        getApiKeyConsent: () => _readApiKeyConsent(),
        setApiKeyConsent: v => _writeApiKeyConsent(v),
 // ---- 库存排序偏好 ----
        getOwnedSort: () => GM_getValue(nsKey('owned_sort'), 'appidAsc'),
        setOwnedSort: v => GM_setValue(nsKey('owned_sort'), v),
 // ---- UI 主题偏好（典雅紫 purple / 经典蓝 blue，默认典雅紫） ----
        getUiTheme: () => GM_getValue(nsKey('ui_theme'), 'purple'),
        setUiTheme: v => GM_setValue(nsKey('ui_theme'), v),
 // ---- 价格比价目标货币偏好（价格 Tab 多地区低价排行，默认 CNY，记忆最近一次选择） ----
        getPriceTargetCurrency: () => GM_getValue(nsKey('price_target_currency'), 'CNY'),
        setPriceTargetCurrency: v => GM_setValue(nsKey('price_target_currency'), v),
 // ---- AI 模型配置 (优先共享 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),
 // ---- ITAD API Key 配置 (价格增强) ----
        getItadApiKey: () => GM_getValue(nsKey('itad_api_key'), ''),
        setItadApiKey: v => GM_setValue(nsKey('itad_api_key'), v),
 // ---- AI 价格预测模式配置 ----
        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)),
 // ---- 大对象存储于 IndexedDB（容量无 5MB 限制）----
 // 旧 GM key 兼容：第一次读取时若 IDB 无值，尝试从 GM_setValue 迁移
 //
 // ★ v2.42.2 性能修复：改为**惰性兜底**。
 //   原写法 `sglvIDB.get(k, parseStored(k, parseStored(k2, dflt)))` 的实参是**先求值**的：
 //   每次调用都会先跑 2 次 GM_getValue + 对整份旧数据的 JSON.parse，
 //   然后在 IDB 命中时把算好的兜底**整个丢弃** —— 白算。
 //   现在改成「先取、没取到才兜底」，命中 IDB 时零额外开销。
        getCachedGames: () => {
            const k = nsKey('cached_games');
            const v = sglvIDB.get(k, undefined);
            return v !== undefined ? v : parseStored(k, parseStored('sglv_cached_games', []));
        },
        setCachedGames: v => sglvIDB.set(nsKey('cached_games'), v),
        getFamilyInfo: () => {
            const k = nsKey('family_info');
            const v = sglvIDB.get(k, undefined);
            return v !== undefined ? v : parseStored(k, parseStored('sglv_family_info', {}));
        },
        setFamilyInfo: v => sglvIDB.set(nsKey('family_info'), v),
 // ---- 云存档数据（大对象，IDB 存储）----
        getCloudSaveData: () => {
            const k = nsKey('cloud_save_data');
            const v = sglvIDB.get(k, undefined);
            return v !== undefined ? v : parseStored(k, null);
        },
        setCloudSaveData: v => sglvIDB.set(nsKey('cloud_save_data'), v),
    };

 //主题层 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: 6 * 30 * 24 * 3600 * 1000,  // v2.9.27: 游戏系列 + 供应商数据（GitHub json）：6 个月（数据极低频变化，靠供应商视图的刷新按钮手动强刷）
        wishlist: 3 * 24 * 3600 * 1000,        // v2.9.30: 愿望单数据：3 天（价格/折扣等动态字段后台静默刷新，6h 节流）
        cloudSave: 2 * 24 * 3600 * 1000,           // v2.9.39: 云存档数据：2 天（后台静默增量更新，6h 节流；只增不减，保留已有游戏列表）
        gameAlias: 30 * 24 * 3600 * 1000,           // v2.11.48: 游戏别名（Steam EN + 小黑盒中文名）：30 天（极低变化，限流友好）
        gameAliasMiss: 6 * 3600 * 1000,              // v2.11.48: 游戏别名 miss 缓存：6h（限流保护，成功后才走 30 天长缓存）
    };
 //云存档后台静默刷新节流（与 wishlist 一致，6h）
    const CLOUDSAVE_BG_REFRESH_INTERVAL = 6 * 3600 * 1000;
 //云存档文件数填充节流（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 cachePeek(key) {
        try {
            const raw = GM_getValue('sglv_cache_' + key, '');
            if (!raw) return null;
            const obj = JSON.parse(raw);
            if (obj.data == null) return null;
            return { data: obj.data, fresh: !(obj.expires && Date.now() > obj.expires) };
        } 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 */ }
    }
 /** 删除指定缓存项（移出过期缓存） */
    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 翻译总结 ====================
    const AI_PROMPT_URL = 'https://cdn.jsdelivr.net/gh/SmallRob/steam-namespace@main/prompts/ai-prompt-template.json';

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

 // ==================== AI 深度分析 ====================
    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();
 //迁移至 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;
        });
    }
 //翻译模板也增加 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);

 //深度分析提示词模板 (远程加载 + 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 调用 ----
 //新增 maxTokens (默认 4096, 可按场景提高) 和 returnMeta (返回 {content, finishReason, truncated})
 //经 sglvGmFetchRetry 发送（POST/headers/data 透传，依赖 core 1.0.6
 // onHttpError 回调保留非 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 }),
 //非 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) {
 //记录完整响应便于排查空内容问题
                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;
        });
    }

 //修复被截断的 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;
    }

 // 鲁棒 JSON 解析 (处理 AI 返回的 markdown/截断/未转义)
 //增加 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 起始符');
 //保存从起始符到字符串末尾的完整内容 (用于截断修复)
        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) {
 //找不到匹配闭合符 — 极可能是 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 中常见错误
 //移除尾部多余的 }, ] (AI 经常多打)
        jsonStr = jsonStr.replace(/[\s,]+$/, '');
 //移除 // 单行注释
        jsonStr = jsonStr.replace(/^\s*\/\/.*$/gm, '');
 //移除 /* */ 注释
        jsonStr = jsonStr.replace(/\/\*[\s\S]*?\*\//g, '');
 //修复未闭合的字符串(去除末尾未闭合的引号)
        const quoteCount = (jsonStr.match(/"/g) || []).length;
        if (quoteCount % 2 !== 0) {
            jsonStr = jsonStr.replace(/"([^"]*)$/, '$1');
        }
 //修复 trailing comma
        jsonStr = jsonStr.replace(/,(\s*[}\]])/g, '$1');
 //修复单引号为双引号 (字段名必须是双引号)
        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) {
 //三次尝试 — 截断修复 (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? }]
 //max_tokens 提升至 8192 防截断; 限制最多 15 条新闻降低 token 压力;
 // 通过 returnMeta 检测 finish_reason=length; 截断时通过 repairTruncatedJson 恢复部分结果
    async function callAiTranslateSummary(newsItems, gameName, appId) {
        let prompt = await getAiPromptTemplate();
 //限制最多 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);
 //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');

 // 构建折扣记录文本
 //安全数值转换, 修复 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);

 //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);
 // 使用鲁棒 JSON 解析 (处理 markdown/截断/未转义)
        const result = safeParseAiJson(content, '{');
        console.log('[SGIS] AI 价格预测解析完成, models:', (result.models || []).length);
        return result;
    }

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

 // --- 中文名缓存 ---
 // ==================== 游戏中文名获取（参考 steam-friend-manager 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();

    // ==================== v2.31.5 Steam AI Agent 缓存桥（saa-bridge）====================
    // GM 存储按脚本沙箱隔离，别的脚本读不到；但同源 localStorage 是共享的。
    // 这里把「汇率 + 游戏中文名」两个 GM 键镜像到 store 域的 localStorage，
    // 供 Steam AI Agent 的 readPluginCache 工具只读消费（省一次网络请求、不耗 Steam API 配额）。
    //
    // 铁律：桥永远不能影响宿主。
    //  - 全程 try/catch 静默，任何异常都不得冒泡到 SGLV 主流程；
    //  - names 可能 MB 级，写入前先估体积，超阈值或 QuotaExceeded 时降级为 names=null
    //    并标 namesSkipped='quota'，绝不因为桥挤爆 SGLV 自己的 localStorage 配额；
    //  - 2s 防抖合并高频写入（中文名缓存是逐个 appid 增量写的）。
    const SAA_BRIDGE_KEY = '__saa_bridge_sglv__';
    const SAA_BRIDGE_NAMES_MAX_CHARS = 1.2 * 1024 * 1024; // 桥内中文名体积上限，超出只带汇率
    let _saaBridgeTimer = null;

    function scheduleSaaBridge() {
        if (_saaBridgeTimer) return;
        _saaBridgeTimer = setTimeout(() => {
            _saaBridgeTimer = null;
            try { writeSaaBridge(); } catch (e) { /* 桥失败静默，绝不影响宿主 */ }
        }, 2000);
    }

    function writeSaaBridge() {
        try {
            const bridge = { v: 1, updatedAt: Date.now(), rates: null, names: null, namesSkipped: null };

            // 汇率：GM 键 'sgis-rates'（1 外币 = X CNY）+ 时间戳，体量小（~2KB）原样放行
            try {
                const rates = GM_getValue('sgis-rates', null);
                const ts = Number(GM_getValue('sgis-rates-ts', 0)) || 0;
                if (rates && typeof rates === 'object') bridge.rates = { ts, map: rates };
            } catch (e) { /* 汇率读不到就不带，不影响 names */ }

            // 中文名：全量尝试，超体积阈值直接跳过（宁可没有，也不要挤占宿主配额）
            try {
                const raw = GM_getValue(SGLV_GAME_NAME_KEY, null);
                if (raw && typeof raw === 'object') {
                    const names = {};
                    for (const k in raw) { const v = raw[k]; names[k] = (v && typeof v === 'object') ? (v.name || '') : v; }
                    const nKeys = Object.keys(names).length;
                    if (nKeys) {
                        let approx = 0;
                        try { approx = JSON.stringify(names).length; } catch (e) { approx = Infinity; }
                        if (approx <= SAA_BRIDGE_NAMES_MAX_CHARS) bridge.names = names;
                        else bridge.namesSkipped = 'quota';
                    }
                }
            } catch (e) { bridge.namesSkipped = 'quota'; }

            // 写入：先试带 names 的完整包，QuotaExceeded 则退化为仅汇率再试一次
            const full = JSON.stringify(bridge);
            if (sglvLocalSet(SAA_BRIDGE_KEY, full)) return;
            if (bridge.names) {
                bridge.names = null;
                bridge.namesSkipped = 'quota';
                sglvLocalSet(SAA_BRIDGE_KEY, JSON.stringify(bridge));
            }
        } catch (e) { /* 顶层兜底：桥不影响宿主 */ }
    }
    // 启动补调一次：把上次会话未落盘的更新（页面关闭前的最后一批写入）补上
    try { scheduleSaaBridge(); } catch (e) {}

    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.31.5：同步触发 AI Agent 桥（2s 防抖，中文名逐个写入已合并）
        try { scheduleSaaBridge(); } catch (e) {}
    }
 //中文名获取失败负缓存 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);
 //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);
            };
 //使用统一 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})`;
            }
        });
    }

 //获取游戏英文名（参考 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 => {
 //使用统一 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;
    }

 //异步加载游戏名称——默认显示中文名（如有），原始英文名作为灰色别名追加在后
 // 逻辑：① 主名是 "App xxx" 占位符 → 获取中文名替换主名，英文名作为别名（需额外请求）
 // ② 主名是英文名 → 获取中文名替换主名，原始英文名作为灰色别名
 // ③ 中文名与主名相同（主名已是中文）：不追加别名
 // ④ 无中文名（主名为英文且无中文名）：不追加别名，避免英文名重复/雷同
 // ⑤ 占位符主名 + 无中文名 → 获取英文名替换主名，不追加别名
 // 参考steam-friend-manager：静默失败不显示任何别名
    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);
    }

 //中文名回填统一入口——收编 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);
    }

 // --- 家庭组成员名（appid → 拥有者昵称列表）---
 // v2.42.2：从 SGLV 子闭包（21920 IIFE）提升到主闭包顶层。
 //   原先它定义在子闭包内，而 injectSGLVAppDetailHost（主闭包）要把它注入给
 //   外部的 sglv-app-detail 库 → 跨闭包引用 → ReferenceError 被 catch 吞掉，
 //   表现为「归属人名永远不显示」且毫无报错。
 //   它只依赖 storage（主闭包顶层），提升后对子闭包内的调用点同样可见。
    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(', ');
    }

 // --- localStorage 写入助手（主闭包自带）---
 // v2.42.2：原先误用 shelf IIFE 的私有 lsSet → 跨闭包 ReferenceError，
 //   被外层 catch 吞掉后，SAA 数据桥的写盘率恒为 0（桥从未落地过）。
    function sglvLocalSet(key, val) {
        try { window.localStorage.setItem(key, val); return true; } catch (e) { return false; }
    }

 //获取排除家庭组共享游戏和 DLC 后的游戏列表（用于个人信息面板和洞察页面统计准确性）
 //修复 isDlc 跨作用域不可见问题——isDlc 定义在 SGLV 子闭包内，通过 SGLV_API 桥接访问
 //加 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;
    }

 //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;
    }

 //迁移至 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 ---
 //showToast 升级为委托 sglvToast（保持向后兼容）
    function showToast(msg) {
        sglvToast.info(msg);
    }

 // --- 剪贴板工具 ---
 //复制文本到剪贴板（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（模块级缓存）
 //迁移至 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标记库存状态：从页面 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 子模块（子闭包封装，仅导出 initUI/autoScan） ====================
    const SGLV_API = {};
    (function () {
 // ==================== SGLV 专属工具函数 ====================
 // ==================== 工具函数 ====================
    function requestSteamAPI(url) {
 //增加 timeout（30s）和 ontimeout 处理，避免请求挂起导致 loading 卡住
 //检测 HTML 响应（未登录/API Key 失效时 Steam 返回登录页），提前抛出清晰错误
 //迁移至 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.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.js）
 //迁移至 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 };
        }
    }

    // 注：getGameOwnerNames 已提升到主闭包顶层（见主闭包 isGameOwnedByMe 附近）——
    // v2.42.2 修复跨闭包不可见问题。

 //通用计算缓存(持久化版)— 内存镜像 + 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();
 //精简: 复用外层主闭包已探测的 SGLVCore 实例 C,移除重复的全局探测(行为不变)
    const _PCC_CACHE = C.PersistentComputeCache || null;
 //通用计算缓存 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);
 //同步写内存 + 异步落 PCC(IDB 持久化,跨 session 复用)
        if (_PCC_CACHE) {
            try { _PCC_CACHE.set(key, _COMPUTE_CACHE_SCHEMA_VER, key, v); } catch (e) { /* quota */ }
        }
        return v;
    }

 //启动时从 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;
        }
    }

 //按"游戏库版本"选择性地失效 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 已失效`);
    }

 //业务级持久化计算结果工具(给 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: '' };
    }

 //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) {
 //命中成功缓存直接返回；否则新路径优先（注释见 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`;
    }
 //小图标统一回退链（对齐封面 _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;

 //多 CDN 封面回退链（参考 steam-family-game-analysis faLoadCover 多 CDN fallback）
 // 修复 cdn.cloudflare.steamstatic.com 不可达（部分网络环境被阻断/抽风）时封面大面积获取不到的问题：
 // 依次尝试 cloudflare → cdn.akamai → shared.akamai → shared.fastly(store_item_assets)，全部失败再走 appdetails API
 //新增 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') {
 //补充 shared.akamai store_item_assets 路径的 library_600x900（部分新游戏仅在此路径有图）
 //追加 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）
 //重构：成功/进行中/失败三态分离——旧实现用同一 Map 的 '' 同时表示"请求中"与"失败"，
 // 导致同 appid 并发回退时后者直接占位、且瞬时失败后永不再重试（封面获取不到的另一根因）
 //缓存键按 kind 隔离（poster/capsule/header），避免横版 URL 被竖版 poster 复用导致裁切变形
    const _posterApiCache = new Map();   // appid:kind → API 获取成功的图片 URL
    const _posterApiPending = new Map(); // appid:kind → 进行中的 API 请求 Promise（并发共享）
    // v2.31.2: appdetails 失败负缓存 —— 避免同一游戏每次渲染都重打 API（重试风暴）。
    //   10 分钟后再试：瞬时网络抖动很快恢复，也不会永久拉黑一个游戏。
    const _posterApiNeg = new Map();     // appid:kind → 失败时间戳
    const POSTER_API_NEG_TTL = 10 * 60 * 1000;
    const POSTER_API_NEG_MAX = 600;
    function _markPosterApiNeg(cacheKey) {
        _posterApiNeg.delete(cacheKey);
        _posterApiNeg.set(cacheKey, Date.now());
        if (_posterApiNeg.size > POSTER_API_NEG_MAX) {
            const it = _posterApiNeg.keys();
            while (_posterApiNeg.size > POSTER_API_NEG_MAX) {
                const n = it.next();
                if (n.done) break;
                _posterApiNeg.delete(n.value);
            }
        }
    }
    function _posterApiNegHit(cacheKey) {
        const t = _posterApiNeg.get(cacheKey);
        if (!t) return false;
        if ((Date.now() - t) < POSTER_API_NEG_TTL) return true;
        _posterApiNeg.delete(cacheKey);
        return false;
    }
//占位替换仅替换 <img> 节点本身，不再覆盖父容器 innerHTML——
 // 封面视图中父容器还含有徽章浮层（sglv-wl-cover-badges），需保留
 //继承原 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);
    }
 //kind 感知——poster 优先 header_image（更宽，适合竖版裁切），
 // capsule 优先 capsule_image（横幅原生），header 优先 header_image
 //迁移至 sglvGmFetchRetry（永不 reject 语义保留——
 // parse 失败/非 2xx/网络错误/超时均 resolve('')；pending map 清理收敛到 .finally）
//kind 感知——poster 优先 header_image（更宽，适合竖版裁切），
// capsule 优先 capsule_image（横幅原生），header 优先 header_image
//迁移至 sglvGmFetchRetry（永不 reject 语义保留——
// parse 失败/非 2xx/网络错误/超时均 resolve('')；pending map 清理收敛到 .finally）
//
// v2.23.1 重构：原实现引用未声明的 _coverNegCache / _coverBatchEnqueue / COVER_NEG_TTL
// （v2.22.2 引入负缓存/batch 队列时声明被遗漏），API 兜底触发即 ReferenceError，
// 导致所有 CDN 链失败后无法走 Steam appdetails / steamui.com hash 渠道。
// 现统一委托 sglv-cover-fallback.lib.js：resolveCover 已自带负缓存(确认无资产/网络
// 抖动双 TTL)+ 并发去重(pending Map) + steamui hash URL 直通 + 语言变体链，按 kind 选图。
// 参考 steam-friend-manager 1.5.3 dashFetchCapsuleFromStore 同架构（pending 去重 +
// 双 TTL 负缓存 + 三层持久化）。
    function _fetchCoverApiUrl(appid, kind) {
        const k = kind || 'poster';
// 同步 good 缓存命中直接 resolve —— 避免每次重渲染都重复打 appdetails
        const good = getPosterGood(appid, k);
        if (good) return Promise.resolve(good);
// v2.31.1 关键修复：cover-fallback v2.0.x 的 resolveCover 是纯同步实现
//   （good 缓存 → 否则链首），根本不做网络解析。旧实现把它当"API 兜底"，
//   拿回来的 URL 就是刚刚 404 的那个链首 → img.src 被重设成同一个坏 URL →
//   立刻再次 error → 直接进「无图片」占位。这就是"封面全都加载不出来"的直接原因。
//   这里一律走真实的 appdetails 查询（in-flight 去重 + 成功结果缓存）。
        return _legacyFetchCoverApiUrl(appid, k);
    }
//内联 appdetails 直查兜底（保留原 v2.22 语义：永不 reject；不引用任何未声明变量）
// 仅在 SGLVCoverFallback 不可用时启用，正常路径不会进入
    function _legacyFetchCoverApiUrl(appid, kind) {
        const k = kind || 'poster';
        const cacheKey = `${appid}:${k}`;
        if (_posterApiCache.has(cacheKey)) return Promise.resolve(_posterApiCache.get(cacheKey));
        if (_posterApiPending.has(cacheKey)) return _posterApiPending.get(cacheKey);
        // v2.31.2: 负缓存命中 → 直接返回空，不再打 API（10 分钟后自动重试）
        if (_posterApiNegHit(cacheKey)) return Promise.resolve('');
        const url = `https://store.steampowered.com/api/appdetails?appids=${appid}&l=${isZh ? 'schinese' : 'english'}&filters=basic`;
        const p = sglvGmFetchRetry(url, { timeout: 10000, retries: 1 })
            .then(data => {
                const entry = data && data[appid];
                const d = entry && entry.success && entry.data;
                if (!d) { _markPosterApiNeg(cacheKey); return ''; }
                const u = (k === 'capsule' && d.capsule_image) ? d.capsule_image
                    : (d.header_image || d.capsule_image || '');
                const full = u && (u.startsWith('http') ? u : `https://cdn.cloudflare.steamstatic.com/steam/apps/${appid}/${u}`);
                // v2.31.1: 只缓存成功结果。旧实现失败/空也写 '' →
                //   一次瞬时网络抖动就让该 appid 在整个会话内永远拿不到 API 兜底。
                if (full) {
                    _posterApiCache.set(cacheKey, full);
                    _posterApiNeg.delete(cacheKey);
                    // 方向归一：按 URL 本身的形态写槽位（竖版 → poster，横版 → header），
                    //   既不会把 460x215 的 header_image 写进 poster 槽位污染竖版视图，
                    //   又能让受限/PS/Epic/收藏视图共享同一份横版 good URL。
                    const naturalKind = full.indexOf('library_600x900') >= 0 ? 'poster' : 'header';
                    recordPosterGood(appid, full, naturalKind);
                    try {
                        const fb = window.SGLVCoverFallback;
                        if (fb && typeof fb.recordGood === 'function') fb.recordGood(String(appid), full, naturalKind);
                    } catch (e) { /* ignore */ }
                } else {
                    _markPosterApiNeg(cacheKey);
                }
                return full || '';
            })
            .catch(() => { _markPosterApiNeg(cacheKey); return ''; });
        _posterApiPending.set(cacheKey, p);
        p.then(() => {}, () => {}).then(() => { _posterApiPending.delete(cacheKey); });
        return p;
    }
//传递 kind 参数，使 API 兜底能按图片类型选择最佳 URL
//v2.31.1: ① cover-fallback 已接管（data-sglv-cover + bindErrorHandler）时直接返回，
//            否则会用 resolveCover 拿到的同一个坏 URL 抢 src，打断 lib 的链推进；
//          ② API 也给不出新 URL 时直接占位，不再重设同一个 src 形成"error→同 URL→error"死循环。
    unsafeWindow._sglvPosterFallback = function(img, appid, kind) {
        if (!img || !img.isConnected) return;
        const k = kind || 'poster';
        let managed = false;
        try {
            managed = !!img._sglvChainLoading
                || !!(img.closest && img.closest('[data-sglv-cover-handler-bound]'));
        } catch (e) { /* ignore */ }
        if (managed) return;
        const cur = img.getAttribute('src') || '';
        _fetchCoverApiUrl(appid, k).then(url => {
            if (url && url !== cur) {
// API URL 加载仍失败 → 占位（先替换 onerror，防止链式 handler 死循环）
                img.onerror = function() {
                    img.onerror = null;
                    _posterImgToPlaceholder(img);
                };
                img.src = url;
                return;
            }
            _posterImgToPlaceholder(img);
        }, () => _posterImgToPlaceholder(img));
    };

// 统一封面 <img> 标签生成：成功URL缓存 → 多 CDN 直链回退 → API 获取 → 占位
//增加成功URL内存缓存；多 CDN 回退链 + 按 kind 隔离缓存
//① 传递 kind 给 _sglvPosterFallback 使 API 兜底按类型选图
// ② onerror 链跳过 chain[0]（与初始 src 相同，避免重复请求）
//
// v2.23.1: 优先使用 SGLVCoverFallback.getCoverUrl() 作为初始 src——
// 1) 命中 good 缓存同步返回（跨视图跨会话）;2) steamui hash URL 直通免 CDN 探测;
// 3) 语言变体（如 schinese）链前部插入,优先返回中文变体;
// 4) data-sglv-cover 属性 + bindErrorHandler 接管 error 链（替代内联 onerror 字符串,
//    URL 长度不再受 HTML 属性限制,且 lib 内部维护 CDN 全链+steamui+API+placeholder）;
// 5) 双缓存层（_posterGoodUrl 旧会话缓存 + SGLVCoverFallback 跨会话缓存）协同,
//    一次加载成功后两个缓存同时写入,下次访问秒开。
    function coverImgTag(appid, name, kind, cls) {
        const k = kind || 'poster';
        const fb = window.SGLVCoverFallback;
        // lib 可用 = 链式回退由 panelEl 上的 bindErrorHandler 全权接管
        const managed = !!(fb && typeof fb.chainLoad === 'function' && typeof fb.bindErrorHandler === 'function');

// 初始 src：宿主 good 缓存(已验证/跨会话) → lib good 缓存(跨会话) → 宿主 CDN 链首
        //   v2.31.2: 宿主缓存必须放第一位 —— getCoverUrl 无缓存时会返回链首，
        //   若放在前面，sglv_bk_cover_map 里几千条已验证 URL 永远读不到（旧缓存等于白存）
        let first = getPosterGood(appid, k) || '';
        // 横版类共享 header 槽位（收藏/PS/Epic/受限视图写入的横版 URL）
        if (!first && k !== 'poster' && k !== 'header') first = getPosterGood(appid, 'header') || '';
        if (!first && fb && typeof fb.getCoverUrl === 'function') {
            try { first = fb.getCoverUrl(String(appid), k, isZh ? 'schinese' : '') || ''; } catch (e) { /* ignore */ }
        }
        if (!first) first = coverChainUrls(appid, k)[0] || '';

        const base = `class="${cls}" src="${first}" alt="${name}" loading="lazy" decoding="async" referrerpolicy="no-referrer"`
            + ` data-sglv-cover="1" data-appid="${appid}" data-kind="${k}"`
            + ` onload="_sglvRecordPosterGood('${appid}',this.src,'${k}')"`;

// v2.31.1 关键修复：lib 已接管时绝不能同时挂内联 onerror。
//   旧实现两条链路互相抢 src：内联 onerror → _sglvPosterFallback → 拿回同一个坏 URL
//   → 立刻再次 error → 把 img 换成「无图片」div，链上后面本可成功的 URL 全被掐断。
        if (managed) return `<img ${base}>`;

// lib 不可用 → 保留旧的内联 API 兜底（仅此一条链路）
        return `<img ${base} onerror="if(this.dataset.fb){this.style.display='none'}else{this.dataset.fb='1';_sglvPosterFallback(this,'${appid}','${k}')}">`;
    }
    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'); }
//横板封面图片（capsule 大横幅），用于愿望单封面视图
    function capsuleImg(appid, name) { return coverImgTag(appid, name, 'capsule', 'sglv-wl-cover-img'); }

// 注册 SGLVCoverFallback 全局 error 委托——用于主脚本自渲染的封面（CS 模块等）
// 仅注册一次,多次调用幂等（lib 内部维护注册表）
// 委托函数职责：捕获带 data-sglv-cover / data-kind / data-appid 的 img,自动走 CDN 链
// → steamui → appdetails → SVG placeholder 全链路,无需每张图单独写 onerror
    function _ensureCoverFallbackDelegation(root) {
        if (!root || root.__sglvCoverDelegated) return;
        const fb = window.SGLVCoverFallback;
        if (!fb || typeof fb.bindErrorHandler !== 'function') return;
        root.__sglvCoverDelegated = true;
        fb.bindErrorHandler(root, (img) => {
            if (img.nextElementSibling) img.nextElementSibling.style.display = 'flex';
            try {
                const ph = document.createElement('div');
                ph.className = (img.className || '') + ' sglv-cover-broken';
                ph.textContent = isZh ? '无封面' : 'No Cover';
                if (img.parentElement) img.parentElement.replaceChild(ph, img);
            } catch (e) { /* 静默 */ }
        });
    }

 //分页导航——仅保留 首页|上页|下页|末页 + 跳页输入，无快捷页码按钮
    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）
 //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();

 //优先 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);
            }
        }

 //尝试用 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);
            }
        }

 // 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;
    }

 //获取 dynamicstore/userdata——Steam 商店动态数据，返回完整 owned appids 列表
 // 该端点比 GetOwnedGames 更可靠：包含 CD key 激活、促销许可、免费领取等所有类型的已入库游戏
 // 参考 Steam-License-Classifier 的思路：license 数据是入库的 ground truth

 // 合并两种数据源
    async function fetchAllGames(onProgress) {
        const gamesMap = new Map();
 //进度回调——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;
                    }
                });
 //个人入库时间校准——家人新入库共拥游戏会刷新 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} 款共拥游戏已按个人许可页日期修正`);
 //我拥有但家人后买的共拥游戏（非末位拥有者）且无许可页日期 → 时间戳
 // 是家人的购买时间，清零回退到 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：通过 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());
    }

 //动态页专用数据源——始终拉取完整家庭组库（含个人 acquiredTime/owners，10 分钟会话级缓存）。
 // 原因：acquiredTime 仅家庭组 API 提供；state.ownedGames 可能是缺少入库时间的缓存数据，
 // 导致个人入库动态为空。此处与"显示家庭共享"开关无关，保证两个入库动态都能正确加载。
    let _timelineFamilyGamesCache = null; // { games, ts, appidSet }
 //入库热力图渲染缓存——避免每次切换游玩仪表标签页都重新计算 SVG
 //缓存结构扩展为 { signature, html, ts, views }——views 预存各年份/全部视图 HTML，供年份切换直接复用
    let _heatmapRenderCache = null;
 // ==================== 个人许可页入库时间校准 ====================
 // 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;
    }

 //判断 rt_time_acquired 是否为"我的购买事件"。
 // GetSharedLibraryApps 的 owner_steamids 按入库顺序排列：末位=最新入库者（购买者），
 // 首位=最早购入者——参考 steam-family-game-analysis 购买动态的购买者归属
 // （其购买者筛选即 owners.at(-1)）。家人后买一款自己已拥有的游戏时
 // 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} 款共拥游戏已按个人许可页日期修正`);
        }
 //我拥有但家人后买的共拥游戏（非末位拥有者）且无许可页日期 → 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 };
    }

 //onProgress(stage, percent, text) 进度回调，UI 可选接入避免"界面不动"
 //增量更新——缓存有效时先返回缓存数据，后台静默拉取最新记录合并（不清空已有数据）
    async function fetchTimelineFamilyGames(onProgress) {
        const report = (stage, percent, text) => { if (typeof onProgress === 'function') onProgress(stage, percent, text); };

 //缓存有效期内直接返回，不做增量更新（10 分钟 TTL）
        if (_timelineFamilyGamesCache && Date.now() - _timelineFamilyGamesCache.ts < 10 * 60 * 1000) {
            report(4, 100, `已从缓存载入 ${_timelineFamilyGamesCache.games.length} 款家庭组游戏`);
            return _timelineFamilyGamesCache.games;
        }

 //缓存已过期但仍有数据——先返回旧数据（秒开），后台增量拉取最新记录
        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;
    }

 //后台增量刷新——拉取家庭组数据，与缓存合并（只新增不删除），更新时间戳
    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();
        }
    }

 //个人入库动态（优先使用已缓存的 state.ownedGames，不判断"显示家庭共享"开关，直接显示所有个人入库动态）
    async function buildPersonalTimeline(steamId) {
 //统一走动态页专用数据源（始终含完整家庭组 acquiredTime），与"显示家庭共享"开关无关
 //入库时间经个人许可页校准——家人新入库自己已拥有的游戏会刷新 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;
 //家人后买的共拥游戏，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,
 //许可页校准的条目仅日级精度（本地零点），渲染时不显示伪 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 };
    }

 //家庭组入库动态（优先使用已缓存的 state.ownedGames，不判断"显示家庭共享"开关，直接显示所有入库动态）
 //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); };
 //统一走动态页专用数据源（始终含完整家庭组 acquiredTime），与"显示家庭共享"开关无关
 // 阶段 1-4：token → 家庭组信息 → 共享库 → 整理（在 fetchTimelineFamilyGames 内部完成）
        const familyGames = await fetchTimelineFamilyGames((stage, percent, text) => {
            report(stage, percent, text);
        });
        if (!familyGames || familyGames.length === 0) return null;

 //购买者归属——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,
 //购买者=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 };
    }

 // ==================== 游戏收藏模块（@require 外部库 sglv-game-collection） ====================
 //收藏模块核心实现位于独立库，
 // 主脚本仅加载收藏基本界面——本桥接区 + 子菜单/心型/SGIS 三个入口 + 主题层 Part E。
 // 供应商分类 / 绝版收藏 / PS会免 / Epic赠送 / 锁区 / 年度大作 / DLC收藏 / 捆绑包 /
 // Humble Choice 全部实现位于库内，经 CollectionHost 桥访问主脚本数据/工具/i18n。
 // 库未加载时（网络失败/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） ----
 //供应商（GAME_DB）与系列（seriesDb）分离提供，不再合并
 //getGameDb 优先返回远程覆盖版本（如有）
        getGameDb: () => supplierDbOverride || GAME_DB,
        getSeriesDb: () => seriesDb,
 //暴露 loadSeriesData 供收藏浮窗调用强制刷新
        loadSeriesData,
 //暴露 loadSupplierData + getSupplierFetchedAt 供收藏浮窗调用
        loadSupplierData,
        getSupplierFetchedAt: () => supplierFetchedAt,
        getDelistedDb: () => _getDelistedDb(),
        getResourceText: (name) => { try { return GM_getResourceText(name); } catch (e) { return null; } },
 // ---- 通用工具 ----
        fetchGameZhName,
        fetchGameEnName,
        loadGameZhName,
        coverChainUrls,
        posterImg,
        capsuleImg,
        getGameIconUrl,
        getPosterGood,
        // v2.31.2: 收藏模块加载成功的封面也写入共享 good 缓存（跨面板复用，避免各探一遍）
        recordPosterGood,
        fetchCoverApiUrl: _fetchCoverApiUrl,
        renderPagination,
        paginate,
        showToast,
        wlEscape,
        escHtml,
        h,
        formatLastPlayedShort,
        cacheKey,
        getCached,
 // ---- TTL 缓存 ----
        cacheGet,
        cacheSet,
        cacheDelete,
        cacheTTL: CACHE_TTL,
 // ---- i18n / 图标 ----
        T,
        ICONS,
        isZh,
 // ---- 锁区游戏数据访问（供收藏模块调用） ----
        loadBlockedApps,
        isBlockedApp,
        isBlockedLoaded: () => state.blockedLoaded,
        getBlockedApps: () => state.blockedApps,
        getBlockedSource: () => state.blockedSource,
 //暴露 fetchedAt 供收藏浮窗显示数据更新时间（延迟查找，因 SGLV_API.getBlockedFetchedAt 在锁区IIFE中赋值）
        getBlockedFetchedAt: () => (typeof SGLV_API.getBlockedFetchedAt === 'function') ? SGLV_API.getBlockedFetchedAt() : '',
        parseManualBlockedJson,
 // ---- DLC 收集数据访问（供收藏模块调用，闭包直达无需 SGLV_API 中转） ----
 //loadDlcDatabaseFromCacheSync 暴露给收藏模块——冷启动时同步预热 dlcDbData / appTypeMap 闭包,
 // 避免 collection 库每次 await 异步加载导致"假卡死"
        isDlc,
        isDlcDbReady: () => !!(dlcDbData || appTypeMap),
        loadDlcDatabase,
        loadDlcDatabaseFromCacheSync,  // v1.9.2: 新增,同步读 GM 缓存填充闭包
        enrichOwnedAppTypes,
        enrichDlcTypes,
        getDlcType,
        getBundleCount,
        // v2.5.0: 捆绑包数据源就绪态 + 主动加载入口——
        //   原先捆绑包 tab 只能被动消费 getBundleCount()（bundleDbData 为 null 时全返 0），
        //   且没有任何地方暴露 loadBundleDatabase，导致「不先点『我的库存』tab 就打不开捆绑包」。
        //   这里补两个桥接：isBundleDbReady 让收藏模块判断是否需要等待，loadBundleDatabase 让它能主动触发。
        isBundleDbReady: () => !!bundleDbData,
        loadBundleDatabase,
        getDlcParent: (dlcAppId) => {
            const e = dlcDbData && dlcDbData[String(dlcAppId)];
            return e ? e.base_appID : null;
        },
 //构建 父游戏 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;
        },
 //构建 父游戏 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;
        },
    };

 //收藏模块经 @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 外部资源设置)');
    }
 //回写握手结果到库全局对象——侧边栏(SGIS)收藏快捷按钮无法访问主脚本闭包内
 // 的 _collectionReady，经 window.SGLVCollection._hostReady 判定模块可用性
    if (window.SGLVCollection) window.SGLVCollection._hostReady = _collectionReady;

// ==================== 暂存箱模块（sglv-shelf）桥接 ====================
// 暂存箱与「Steam 购物车增强」(Steam-Cart-Enhanced.js) 共用 localStorage['sce_cart_shelf_v1']，
// 购物类记录（app/bundle/package）双向互通；愿望单/备忘等 SGLV 独享类型走独立桶，
// 避免被 SCE 的 saveShelf() 整体重写 items 时静默丢弃（详见库头注释）。
// 库以内联形式随主脚本同步执行（见 SGLV-SHELF-INLINE 区），加载失败则整块降级。
    let _shelfReady = false;
    if (window.SGLVShelf && typeof window.SGLVShelf.init === 'function') {
        const ShelfHost = {
            apiVersion: 1,
            isZh: isZh,
            getSteamId: () => storage.getSteamId(),
            toast: sglvToast,
            // 名称补全：优先走 app-detail 库，失败时库内回退 GetItems
            resolveName: async (appid) => {
                try {
                    const AD = (typeof unsafeWindow !== 'undefined' && unsafeWindow.SGLVAppDetail) || window.SGLVAppDetail;
                    if (AD && typeof AD.loadDetail === 'function') {
                        const d = await AD.loadDetail(appid);
                        return (d && d.name) || '';
                    }
                } catch (e) { /* 回退库内实现 */ }
                return '';
            },
            openUrl: (url) => { try { window.open(url, '_blank', 'noopener'); } catch (e) { location.href = url; } },
        };
        _shelfReady = window.SGLVShelf.init(ShelfHost);
        if (!_shelfReady) console.warn('[SGLV] 暂存箱握手失败 (apiVersion 不匹配)');
    } else {
        console.warn('[SGLV] 暂存箱库未加载 — 暂存箱功能不可用');
    }
//回写握手结果：侧边栏(SGIS)按钮在主闭包之外，需经 window.SGLVShelf._hostReady 判定可用性
    if (window.SGLVShelf) window.SGLVShelf._hostReady = _shelfReady;

 //云存档模块经 @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 外部资源设置)');
    }

 //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)');
    }

 //每日快照历史常量与内存镜像上移（原位于本 IIFE 后段）——
 // PTW_HOST 对象字面量的 maxDays 以及 _inspect() 的成员遍历都会**急切读取** PT_HISTORY_DAYS，
 // 声明必须先于这些消费点，否则命中 TDZ 抛 ReferenceError → 主 IIFE 崩溃、UI 全不加载。
 // 依赖：nsKey 在本 IIFE 前段（命名空间区）定义，先于此处 ✓
    const PT_HISTORY_KEY = nsKey('pt_daily_history');
    const PT_HISTORY_DAYS = 90;
 // v2.46.2 采样密度下限：每日采集前，时长本体（PT_SNAP_KEY）超过此年龄就先刷一次。
 // 理由见 ptHistoryCollect：周刷新 + 逐日快照 = 六天差值恒 0、第七天爆发。
 // 只在「今天还没采过」时才可能触发 → 最多 1 次/天。
    const PT_HISTORY_FRESH_MS = 6 * 3600 * 1000;
    let _ptHistory = null;
    let _ptHistoryInflight = null;

    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)'
        },
 //主题层图表色——渲染时读当前主题(每次调用求值,主题热切换后下一次渲染即生效)
        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'];
        },
 //实例自增序列——渐变/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 可选: 刻度值→标签字符串, 默认原样数字(向后兼容)
 //minVal 域下限可选(价格历史图 y 域迁移引入); fmt 改收未取整刻度值(默认通道取整不变)
 //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;
        },
 // 折线图(单/多序列)
 //扩展: area(渐变面积)/dots(数据点)/rangeButtons(区间按钮组)/
 // title+yFormatter(轴与头部); 不传新 options 时保持默认输出(回归保护由单测固化)。
 // 手法来源: area 渐变↔renderPlaytimeTrend(sglvTrendGradient 0.4→0.02), dots/rangeButtons↔
 // renderPriceHistoryChart(sgis-chart-range-btn), 库保持无状态——按钮 data-range 由调用方绑事件。
 //补充:
 // svgAttrs(svg 根属性透传)/gridCount(刻度数)/xLabelEvery+xLabelLast(末位标签)/
 // dots.stroke+strokeWidth(描边)/annotations(refLine 参考线 + point 数据点标注)
 //补充:
 // 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;
 //y 域覆写(价格历史图 ±15% padding); 默认 0..maxV
            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;
 //xValues 提供时按值域比例映射 x(时间比例横轴, 长度不足 n 回退索引等距);
 // xMinSpan 最小跨度护栏(承接 86400000 单日语义); 默认索引等距
            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; false 关闭; {r, title(v,i,sIdx), stroke, strokeWidth} 定制
 //增补: 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"/>`);
                }
 //strokeWidth/strokeRound 可配; 默认 2px
                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 除数与末位标签可配)
 //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>';
        },
 // 圆环/饼图
 //补齐手写 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,
                // v2.32.0 内环（双环对照）：outer = 主数据，inner = 参照数据
                // 用途：年代分布要同时呈现「Steam 可用部分」与「HLTB 全量参考」，
                //       单环会掩盖样本偏差（实测最大偏 37.7pt）→ 双环让差异肉眼可见。
                inner = null, innerGap = 6,
            } = 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;
            });
            // v2.32.0 内环：半径 = 外环半径 - 外环厚度 - 间隙
            if (inner && Array.isArray(inner.slices) && inner.slices.length) {
                const ir = r - thickness - innerGap;
                if (ir > 12) {
                    const ith = Math.min(inner.thickness || Math.max(8, Math.round(thickness * 0.6)), ir);
                    const ir2 = ir - ith / 2;
                    const iC = 2 * Math.PI * ir2;
                    const iTotal = inner.slices.reduce((s2, sl) => s2 + (sl.value || 0), 0);
                    if (iTotal > 0) {
                        let iacc = 0;
                        if (inner.bg !== false) {
                            svg += `<circle cx="${cx}" cy="${cy}" r="${ir2}" fill="none" stroke="${SGLVCharts.PALETTE.bgCard}" stroke-width="${ith}" />`;
                        }
                        inner.slices.forEach((sl, i) => {
                            if (!sl.value) return;
                            const len = (sl.value / iTotal) * iC;
                            const off = -iacc;
                            const t = inner.title ? inner.title(sl, i) : (title ? title(sl, i) : null);
                            const attrs = `cx="${cx}" cy="${cy}" r="${ir2}" fill="none" stroke="${sl.color}" stroke-width="${ith}" stroke-dasharray="${len} ${iC - len}" stroke-dashoffset="${off}" transform="rotate(-90 ${cx} ${cy})"${segStyle ? ` style="${segStyle}"` : ''}`;
                            if (t) svg += `<circle ${attrs}><title>${SGLVCharts.esc(t)}</title></circle>`;
                            else svg += `<circle ${attrs} />`;
                            iacc += 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 插值) + 静态轴标签。
 //分工边界: 与 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>';
        },
 //柱+折线组合图——趋势 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 切换: (成员点 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>`;
        }
    };
 //暴露给 SGIS / Collection 库复用
    unsafeWindow.SGLVCharts = SGLVCharts;
// SGLVCharts 已整体上移至 PTW_HOST 之前（PTW_HOST 的 SGLVCharts/accent 成员会急切求值，
// 声明留在后段会命中 TDZ → ReferenceError → 主 IIFE 崩溃、UI 全不加载）。

 // ==================== PTW_HOST 游戏数据浮窗桥接对象 ====================
 // PTW = PlayTimeWindow，游戏数据浮窗框架（sglv-ptw-framework.lib.js）的唯一数据入口。
 //
 // 【设计约束 · 勿改】
 // ① 本对象只做「转发」，不含任何业务逻辑 —— 主脚本借 PTW 实现的瘦身。
 // ② SGIS 闭包能力一律经 SGLV_API 中转并用 `?.` + `typeof` 双重防御。
 // 历史事故：getGameIconUrl(:19440) / xpPercent —— 均为裸引用他层闭包导致 ReferenceError。
 // 本处所有 SGIS 来源均为可选调用，SGIS 闭包未就绪时返回 undefined 而非抛错。
 // ③ services 层的取数函数**无内部限流保护**，Tab 库必须用 sglvSmartPool 约束并发 ≤3。
 // ④ apiVersion 与框架库握手校验，不匹配即拒绝 init（框架侧降级提示）。
 // ⑤ 新增 Tab 一律在此挂能力，禁止让 Tab 直连 SGLV_API 或主 IIFE 内部变量。
    // ═══ v2.32.0 HLTB 索引加载器（发行年份 + 剧情时长）═══
    // ⚠️ 刻意放在 PTW_HOST **之外**：PTW_HOST 只引用主 IIFE 内部定义的符号
    //    （框架纪律：桥接层不直接依赖 GM API）。GM_xmlhttpRequest / GM_getValue
    //    在这里用是安全的 —— 主脚本全篇都是这么调的。
    //    PTW_HOST 内只做「hltb: PTW_HLTB」的暴露。
    const PTW_HLTB = (function () {
        const DEFAULT_BASE = 'https://cdn.jsdelivr.net/gh/SmallRob/steam-namespace@main/data';
        // v2.34.2 多源回落链：cdn.jsdelivr.net 在部分网络（如大陆）被阻断（SSL 握手失败），
        // 而同仓镜像 fastly/gcore 通常可达。逐源用 manifest 探测，成功源固定给本次会话。
        // GM 值 'sglv_hltb_base' 仍是最优先（用户显式换源/自建镜像）。
        const FALLBACK_BASES = [
            'https://cdn.jsdelivr.net/gh/SmallRob/steam-namespace@main/data',
            'https://fastly.jsdelivr.net/gh/SmallRob/steam-namespace@main/data',
            'https://gcore.jsdelivr.net/gh/SmallRob/steam-namespace@main/data',
        ];
        const state = {
            ready: false, loading: false, err: '',
            shards: [],        // [{ids:Int32Array, years:Int32Array, story:Float64Array}]
            reference: null,   // 参考分布（人口基准）
            base: '',
            // v2.34.2 部分成功诊断：missingShards=缺失分片序号；lastProbe=各源探测结果
            missingShards: [],
            lastProbe: [],
        };
        const shardCount = 8;

        function base() {
            try { return String(GM_getValue('sglv_hltb_base', '') || DEFAULT_BASE).replace(/\/+$/, ''); }
            catch (e) { return DEFAULT_BASE; }
        }

        function fetchJson(url) {
            return new Promise((resolve, reject) => {
                GM_xmlhttpRequest({
                    method: 'GET', url, timeout: 20000,
                    onload: (r) => {
                        if (r.status < 200 || r.status >= 300) { reject(new Error('HTTP ' + r.status)); return; }
                        try { resolve(JSON.parse(r.responseText)); } catch (e) { reject(e); }
                    },
                    onerror: () => reject(new Error('网络错误')),
                    ontimeout: () => reject(new Error('请求超时')),
                });
            });
        }

        /** 逐源探测 manifest，返回 { base, manifest }；全失败抛出最后一次错误 */
        async function probeBase() {
            const candidates = [];
            const gmBase = base();
            // GM 显式配置排在最前；去重避免重复探测
            for (const b of [gmBase, ...FALLBACK_BASES]) {
                if (!candidates.includes(b)) candidates.push(b);
            }
            state.lastProbe = [];
            let lastErr = new Error('无可用源');
            for (const b of candidates) {
                try {
                    const manifest = await fetchJson(b + '/hltb-index-v1.manifest.json');
                    if (!manifest || !manifest.shards) throw new Error('manifest 格式异常');
                    state.lastProbe.push({ base: b, ok: true });
                    return { base: b, manifest };
                } catch (e) {
                    state.lastProbe.push({ base: b, ok: false, err: e.message || String(e) });
                    lastErr = e;
                }
            }
            throw lastErr;
        }

        async function load() {
            if (state.ready) return true;
            if (state.loading) return false;
            state.loading = true; state.err = '';
            try {
                // ① 探测可用源（v2.34.2：不再写死单一 CDN）
                const { base: okBase, manifest } = await probeBase();
                state.base = okBase;
                // ② 参考分布（失败不阻断主索引）
                try {
                    const ref = await fetchJson(state.base + '/hltb-index-v1.reference.json');
                    state.reference = ref;
                } catch (e) {
                    console.warn('[SGLV-HLTB] 参考分布加载失败（年代图将只显示匹配部分）', e.message);
                }
                // 数据新鲜度提示：manifest.builtAt 是构建时刻，超过 30 天说明索引陈旧
                // ⚠️ jsDelivr 对 @main 分支有最长 12h 的 CDN 缓存；索引更新后可能拉到旧版。
                //    需要立即生效时把 GM 值 'sglv_hltb_base' 指向 commit SHA 或 tag 的固定 URL。
                if (manifest.builtAt) {
                    const ageDays = (Date.now() - Date.parse(manifest.builtAt)) / 86400000;
                    if (ageDays > 30) {
                        console.warn('[SGLV-HLTB] 索引已 ' + ageDays.toFixed(0) + ' 天未更新（builtAt=' + manifest.builtAt + '）');
                    }
                }
                // ③ 并行拉取分片 + 失败片重试一轮（v2.34.2：部分成功不再全盘失败）
                async function fetchShard(i) {
                    const url = state.base + '/hltb-index-v1.' + i + '.json';
                    try { return await fetchJson(url); }
                    catch (e) { return fetchJson(url); }   // 单片重试一次
                }
                const settled = await Promise.allSettled(
                    Array.from({ length: shardCount }, (_, i) => fetchShard(i))
                );
                const shards = [];
                const missing = [];
                settled.forEach((r, i) => {
                    if (r.status === 'fulfilled') {
                        const f = r.value;
                        shards[i] = {
                            // ⚠️ story 必须用 Float64Array，不能用 Float32Array：
                            //    Float32 精度约 7 位有效数字，3.12 会被存成 3.119999885559082。
                            //    实测端到端 16,439/35,272 条与构建产物比对"不一致"（全是精度问题），
                            //    且 SCI 分档边界（如 0.35）会因此错档 → 必须保 float64。
                            //    内存代价：35,272 × 8B = 282KB，相对 141KB 可忽略。
                            ids: Int32Array.from(f.ids || []),
                            years: Int32Array.from(f.years || []),
                            story: Float64Array.from(f.story || []),
                        };
                    } else {
                        shards[i] = null;                    // 缺失片的 appid 查询自然返回 null
                        missing.push(i);
                    }
                });
                if (missing.length === shardCount) throw new Error('全部分片拉取失败（' + (settled[0] && settled[0].reason && settled[0].reason.message || '未知') + '）');
                if (missing.length) {
                    console.warn('[SGLV-HLTB] 分片部分缺失，缺失片内的游戏将查不到剧情时长：', missing.join(','));
                }
                state.shards = shards;
                state.missingShards = missing;
                state.ready = true;
                state.loading = false;
                const entries = shards.reduce((s, sh) => s + (sh ? sh.ids.length : 0), 0);
                console.log('[SGLV-HLTB] 索引就绪（源 ' + state.base.replace(/^https:\/\//, '').split('/')[0] + '）：'
                    + entries + ' 条 / ' + (shardCount - missing.length) + '/' + shardCount + ' 片'
                    + (missing.length ? '（缺 ' + missing.join(',') + '）' : ''));
                return true;
            } catch (e) {
                state.err = e.message || String(e);
                state.loading = false;
                console.warn('[SGLV-HLTB] 索引加载失败（库分析/剧情完成度降级）', state.err,
                    '探测结果:', JSON.stringify(state.lastProbe));
                return false;
            }
        }

        // 分片键与构建脚本一致：shard = (appid >> 1) % 8
        // ⚠️ Steam appid 99.90% 是偶数，用 appid % 8 会让一半分片永远为空。
        function get(appid) {
            if (!state.ready) return null;
            const id = Number(appid);
            if (!Number.isFinite(id)) return null;
            const sh = state.shards[(id >> 1) % shardCount];
            if (!sh || !sh.ids.length) return null;
            let lo = 0, hi = sh.ids.length - 1;
            while (lo <= hi) {
                const mid = (lo + hi) >> 1;
                if (sh.ids[mid] === id) return { y: sh.years[mid], m: sh.story[mid] };
                if (sh.ids[mid] < id) lo = mid + 1; else hi = mid - 1;
            }
            return null;
        }

        return {
            isReady: () => state.ready,
            isLoading: () => state.loading,
            error: () => state.err,
            load,
            get,
            reference: () => state.reference,
            stats: () => ({
                ready: state.ready, loading: state.loading, err: state.err,
                entries: state.shards.reduce((s, sh) => s + (sh ? sh.ids.length : 0), 0),
                hasReference: !!state.reference,
                // v2.34.2 部分成功诊断
                missingShards: state.missingShards.slice(),
                probe: state.lastProbe.slice(),
            }),
        };
    })();

    const PTW_HOST = {
        apiVersion: 1,

 // ==================== 一、数据访问（只读） ====================
 // ---- 主 IIFE 原生能力（直连，零风险）----
 //getOwnedGames 语义修正——原实现返回未过滤的全库，
 // 而 renderPlaydataTab / openGameDataWindow 都要按 show_family_shared
 // 过滤后使用。Tab 库若直连全库，会与迁移前口径不一致（多算家庭共享游戏）。
 // 改为返回「口径正确」的游戏集，并保留 rawOwnedGames 供需要全库的调用方。
        getOwnedGames() {
            const all = state.ownedGames || [];
            const showFamilyShared = storage.getShowFamilyShared();
            return showFamilyShared ? all.slice() : all.filter(g => isGameOwnedByMe(g));
        },
        rawOwnedGames: () => state.ownedGames,
        getActiveSteamId,
        isGameOwnedByMe,
        getShowFamilyShared: () => storage.getShowFamilyShared(),
        getPlaytimeSnapshot: () => ptSnapLoad(),
        applySnapshotToGames: ptSnapApplyToGames,

 // ---- 每日快照历史（数据层职责，留主脚本）----
 // 与 familyCache 同理：Tab 库只调collect/load，不自行持久化，保持格式单点维护。
        playtimeHistory: {
 /** 采集今日快照（跨日才写；并发去重；滚动 90 天） */
            collect: (games) => ptHistoryCollect(games),
 /** 读取原始历史 { v, days: { 'YYYY-MM-DD': { appid: minutes } } } */
            load: () => ptHistoryLoad(),
 /** 采样日键，升序（旧 → 新） */
            days: () => Object.keys(ptHistoryLoad().days).sort(),
            dayKey: (ts) => ptDayKey(ts),
            maxDays: PT_HISTORY_DAYS,
 /** 设置卡「清除历史」入口（同步重置内存镜像 + IDB） */
            clear: () => {
                _ptHistory = { v: 1, days: {} };
                try { sglvIDB.set(PT_HISTORY_KEY, _ptHistory); } catch (e) { /* quota */ }
                return true;
            },
        },
        getAcquiredMap: (force) => ptGetAcquiredMap(force),
        refreshPlaytime: (force) => ptRefreshPlaytime(force),

 // ---- v2.32.0 HLTB 索引（发行年份 + 剧情时长）----
 // ⚠️ 刻意**不用 @resource**：索引文件尚未托管到 jsDelivr 时，@resource 拉取失败会
 //    连带影响整个脚本的元数据解析。改走 GM_xmlhttpRequest 远程加载 + 失败静默降级，
 //    「库分析」Tab 检测不到就整块隐藏。
 //    配置：GM 值 'sglv_hltb_base' 可覆盖 CDN 根路径（便于自建镜像 / 换源）。
        // 加载器实现见 PTW_HLTB（主 IIFE 顶层，PTW_HOST 只做暴露）
        hltb: PTW_HLTB,
        getFamilyInfo: () => fetchFamilyInfo(),
        computePlaytimeStats,
        computeWishlistStats,
 // ---- 总览 Tab 依赖（探测发现，原契约未登记）----
        kpiCards,
        ptPlaytimeMedian,
        fetchRecentPlayedGames: () => _fetchRecentPlayedGames(),

 // ---- v2.32.0「游玩分析」Tab 依赖（原契约未登记，Tab 拿不到）----
 // ① calcPlaytimeDist：时长分档 donut 的数据源（count ⇄ hours 双模）。
 //    早已实现（:28137）但从未挂到 host → Tab 库无法调用，一直是「写了没用」。
        calcPlaytimeDist: (games, mode) => calcPlaytimeDist(games, mode),
 // ② isDlc：库分析/潜力清单算「大型游戏数」必须用它过滤 DLC，
 //    否则与 computePlaytimeStats 的口径不一致（后者内部已过滤）。
 //    挂在 SGLV_API 上（:22700），此前 PTW 侧够不着。
        isDlc: (appid) => (SGLV_API && typeof SGLV_API.isDlc === 'function') ? SGLV_API.isDlc(appid) : false,
 // ③ computeInsightData：5 维画像（收藏广度/沉浸深度/完成度/偏好多样性/活跃度）
 //    + 玩家画像（类型/稀有度/标签）。走 getBizCached 持久缓存，避免每次重算。
        computeInsightData: () => (typeof computeInsightDataCachedSgis === 'function' ? computeInsightDataCachedSgis() : null),

 // ---- 家庭成员缓存（数据层职责，留在主脚本；Tab 库只调 load/save/isStale）----
 // 设计：避免 Tab 库各自实现持久化，保持缓存格式单点维护。
        familyCache: {
            get data() { ptFamLoad(); return _ptFamCache; },
            load() { ptFamLoad(); },
            save() { ptFamSave(_ptFamCache); },
            isStale: (rec) => ptFamIsStale(rec),
        },

 // ---- 家庭组持久化读写 ----
 // ⚠️ 修复的真实缺陷：sglv-ptw-tab-family 的 requires 声明了 'storage'，
 // 但 PTW_HOST 从未挂出 storage → H.storage 为 undefined，
 // Tab 内 `H.storage.getFamilyInfo()` 抛 TypeError。
 // 由于该调用在 async loadFamily 里且被 try/catch 包裹，
 // 冒烟的同步断言抓不到 → 家庭对比 Tab 一直静默空白（家庭组数据永远拉不到）。
 // 这里按最小必要面挂出：Tab 只用到这3 个方法，不整体暴露 storage。
        storage: {
            getApiKey: () => storage.getApiKey(),
            getFamilyInfo: () => storage.getFamilyInfo(),
            setFamilyInfo: (v) => storage.setFamilyInfo(v),
        },
 // 带 access_token 的家庭组实时拉取（fetchFamilyInfo 本身需要 token 实参）
        fetchFamilyInfo: (authToken) => fetchFamilyInfo(authToken),

 // ---- SGIS 闭包能力（经 SGLV_API 中转 + 防御）----
 // 成就
        getPlayerAchievements: (appId) => SGLV_API.fetchPlayerAchievements?.(appId),
        getGlobalAchievements: (appId) => SGLV_API.fetchGlobalAchievements?.(appId),
 // 评测
        getReviews: (appId) => SGLV_API.fetchReviews?.(appId),
        getReviewSummary: (appId) => SGLV_API.fetchReviewSummary?.(appId),
 // 元数据
        getAppDetailsExtra: (appId) => SGLV_API.fetchAppDetailsExtra?.(appId),
        getDlcNames: (appId) => SGLV_API.fetchDlcNames?.(appId),
        getGameNews: (appId) => SGLV_API.fetchGameNews?.(appId),
        getFamilyShareSupport: (appId) => SGLV_API.fetchFamilyShareSupport?.(appId),
        getGameStatus: (appId) => SGLV_API.fetchGameStatus?.(appId),
 // 价格
        getMultiRegionPrices: (appId) => SGLV_API.fetchMultiRegionPrices?.(appId),
        getSteamRegionPrice: (appId) => SGLV_API.fetchSteamRegionPrice?.(appId),
        getAugRegionPrice: (appId) => SGLV_API.fetchAugRegionPrice?.(appId),
        getHistoryPrices: (appId) => SGLV_API.fetchHistoryPrices?.(appId),
        getHistoryPricesCheapShark: (appId) => SGLV_API.fetchHistoryPricesCheapShark?.(appId),
        refreshRates: () => SGLV_API.refreshRates?.(),

 // ---- v2.37.0「库价行情」Tab 依赖：ITAD 批量价格原语（白名单代理）----
 // ⚠️ 刻意**不挂整包 window.SGLVITAD**：
 //   ① 整包暴露会让 Tab 摸到 fetchPriceHistory（逐游戏 GET /games/history/v2）。
 //      对 2000 款库逐个拉历史既慢又必然撞 ITAD 限额（5 分钟 1000 次）——
 //      库价行情的曲线一律靠「每天批量扫一次全库 → 本地日快照」自累积。
 //   ② 这里只代理两个**批量**端点 + 能力自检，Tab 拿不到逐游戏接口。
 // ⚠️ 这几个成员在 ITAD 库未加载时**依然存在**（available() 返回 false / 返回空结果），
 //    所以 Tab 能正常注册并给出「价格服务不可用」的明确说明，而不是整页签凭空消失。
 //    （若挂进 requires 且库缺失 → Tab 按钮不渲染，用户完全无从判断发生了什么。）
        itad: {
            available: () => !!(window.SGLVITAD && typeof window.SGLVITAD.fetchPriceOverview === 'function'),
            maxBatch: () => (window.SGLVITAD && window.SGLVITAD.MAX_BATCH) || 200,
            lookupItadIds: (appIds) => (window.SGLVITAD && typeof window.SGLVITAD.lookupItadIds === 'function')
                ? window.SGLVITAD.lookupItadIds(appIds)
                : Promise.resolve({}),
            fetchPriceOverview: (itadIds, opts) => (window.SGLVITAD && typeof window.SGLVITAD.fetchPriceOverview === 'function')
                ? window.SGLVITAD.fetchPriceOverview(itadIds, opts)
                : Promise.resolve(null),
            fetchPrices: (itadIds, opts) => (window.SGLVITAD && typeof window.SGLVITAD.fetchPrices === 'function')
                ? window.SGLVITAD.fetchPrices(itadIds, opts)
                : Promise.resolve(null),
        },
 // ---- v2.37.0 Steam 区域探测（cookie steamCountry，缺失回落 CN）----
 // 主脚本内已有两处同源的内联 cookie 读取（入库趋势 / 价值统计）；
 // 这里挂成 host 能力，避免 Tab 自己摸 document.cookie（沙箱内不存在）。
        getUserSteamCountry: () => {
            try {
                const m = document.cookie.match(/steamCountry=(\w{2})/);
                return (m && m[1]) ? String(m[1]).toUpperCase() : 'CN';
            } catch (e) { return 'CN'; }
        },
 // 徽章 / 卡牌
 //修复「配置了 API Key 仍提示需要 Key」——fetchUserBadges(steamId) 需要
 // steamId 实参，原桥接无参调用 → !steamId 恒返回 null → 价值 Tab 恒走无 Key 分支
        getUserBadges: (steamId) => SGLV_API.fetchUserBadges?.(steamId || getActiveSteamId()),
        getBadgeValueScores: (badges, markets) => SGLV_API.computeBadgeValueScores?.(badges, markets),
 //契约修正：底层 fetchBadgeMarkets(appIds, opts) 首行即 appIds.slice(0, maxApps)，
 // 只接受数组；原桥接参数名单写 appId，直传单值会抛 TypeError。
 // 这里做双向兼容归一：单值包成数组，数组透传，缺省值返回 {}。
        getBadgeMarkets: (appIds, opts) => {
            const list = Array.isArray(appIds) ? appIds : (appIds == null ? [] : [appIds]);
            if (!list.length) return Promise.resolve({});
            return SGLV_API.fetchBadgeMarkets?.(list, opts) || Promise.resolve({});
        },
        getCardPrices: (appId) => SGLV_API.fetchCardPrices?.(appId),
        loadCardDatabase: () => SGLV_API.loadCardDatabase?.(),
 // 社交 / 玩法数据
        getSteamLevel: (steamid) => SGLV_API.fetchSteamLevel?.(steamid),
        getCurrentPlayers: (appId) => SGLV_API.fetchCurrentPlayers?.(appId),
        getOwnersPlaytime: (appId) => SGLV_API.fetchOwnersPlaytime?.(appId),
        getTagRecommendations: (appId) => SGLV_API.fetchTagRecommendations?.(appId),
        getProfileFeaturesStatus: () => SGLV_API.fetchProfileFeaturesStatus?.(),

 // ==================== 二、services（新增 Tab 自取数据） ====================
 // ⚠️ 全部无内部限流保护 → Tab 库必须 sglvSmartPool 并发 ≤3
 // ⚠️ 各源 TTL 建议见 ptw-host-contract.v1.json services.cache
        services: {
            // v2.42.2：原先用 fetchJson —— 它定义在 PTW_HLTB 子闭包内，
            //   PTW_HOST 所在作用域取不到 → ReferenceError（调用即炸）。
            //   改用主闭包顶层的 sglvGmFetchRetry（= C.gmFetchJson），语义等价。
            getAppDetails: (appId) => sglvGmFetchRetry(
                `https://store.steampowered.com/api/appdetails?appids=${appId}&l=schinese&filters=categories`,
                { timeout: 15000 }
            ),
            getStoreReviews: (appId) => sglvGmFetchRetry(
                `https://store.steampowered.com/appreviews/${appId}?json=1&filter=summary&language=schinese&purchase_type=all&day_range=999999`,
                { timeout: 12000 }
            ),
            getGlobalAchvPercents: (appId) => sglvGmFetchRetry(
                `https://api.steampowered.com/ISteamUserStats/GetGlobalAchievementPercentagesForApp/v0002/?gameid=${appId}`,
                { timeout: 15000 }
            ),
            getAugmentedAppData: (appId) => sglvGmFetchRetry(
                `https://api.augmentedsteam.com/app/${appId}/v2`, { timeout: 12000 }
            ),
            getSimilarGames: (appId) => sglvGmFetchRetry(
                `https://api.augmentedsteam.com/similar/${appId}/v2?count=15`, { timeout: 12000 }
            ),
            getCheapSharkDeals: (appId) => sglvGmFetchRetry(
                `https://www.cheapshark.com/api/1.0/games?steamAppID=${appId}`, { timeout: 12000 }
            ),
        },

 // ==================== 三、工具 ====================
        h, escHtml, T, ICONS, isZh,
        SGLVCharts,
        showToast: sglvToast,
        cacheGet, cacheSet, cacheDelete, cacheTTL: CACHE_TTL,
        getCached, cacheKey, getGameIconUrl, getPosterGood,
        formatLastPlayedShort, renderPagination, paginate,
        buildListToolbar, hbarRow, createSkeleton, emptyHtml,
        sglvSmartPool, applyGameAliases,
        getAccessToken, requestSteamAPI, storage,

 // ---- 拼音搜索 ----
 // 委托既有 sglv-pinyin.lib.js（@require），主脚本不重复实现查表逻辑。
 // 契约：
 // toPinyinAbbr(name) → 'csgo'（中文取首字母；英文/数字直通；空格标点保留）
 // matchQuery(name, q) → 归一化后的「子串 OR 拼音首字母子串」双向匹配结果
 // 库不可用时 matchQuery 退化为纯英文子串匹配（软降级，不阻断搜索）。
        _getPinyinLib: () => _getPinyinLib(),
        toPinyinAbbr: (name) => {
            const lib = _getPinyinLib();
            try { return lib && typeof lib.toPinyinAbbr === 'function' ? lib.toPinyinAbbr(String(name || '')) : String(name || '').toLowerCase(); }
            catch (e) { return String(name || '').toLowerCase(); }
        },
 /** 搜索统一入口：中文名 / 英文名 / 拼音首字母 三路匹配 */
        matchGameName(name, query) {
            const q = String(query == null ? '' : query).trim().toLowerCase();
            if (!q) return true;
            const raw = String(name == null ? '' : name);
            const lower = raw.toLowerCase();
            if (lower.includes(q)) return true;
 // 拼音首字母匹配（如 "cs" 命中 "传送门"）
            const py = this.toPinyinAbbr(raw);
            if (py && py.toLowerCase().includes(q)) return true;
            return false;
        },

 // ==================== 四、主题 ====================
        getThemeId,
        applySglvTheme,
        getThemes: () => SGLV_THEMES,
        accent: SGLVCharts?.accent,

 // ==================== 五、能力自检 ====================
 /**
 * Tab 库注册与用户排障共用。列出 PTW_HOST 全部成员的值类型，
 * 值为 function 的标记 `fn`，SGIS 来源标记 `sgis`（可能为 undefined）。
 */
        _inspect() {
            const out = {};
            const mark = (v) => (typeof v === 'function' ? 'fn' : typeof v);
            const walk = (obj, prefix) => {
                for (const k of Object.keys(obj)) {
                    if (k.startsWith('_') || k === 'apiVersion') continue;
 //读取成员值加防御——任何成员命中 TDZ / 抛错时标记 unavailable，
 // 不允许诊断函数自身炸掉主 IIFE（历史事故：PT_HISTORY_DAYS TDZ）
                    let v;
                    try { v = obj[k]; } catch (e) { out[prefix + k] = 'unavailable'; continue; }
                    if (typeof v === 'function') out[prefix + k] = 'fn';
                    else if (v && typeof v === 'object' && !Array.isArray(v)) walk(v, prefix + k + '.');
                    else out[prefix + k] = mark(v);
                }
            };
            walk(this, '');
            return out;
        },
    };

 // ---- 能力探测（供框架与设置面板诊断）----
    const _ptwInspect = PTW_HOST._inspect();
    const _ptwFnCount = Object.values(_ptwInspect).filter(v => v === 'fn').length;

 // ---- 框架库握手（起 window.SGLVPTW 存在）----
    let _ptwReady = false;
    if (window.SGLVPTW && typeof window.SGLVPTW.init === 'function') {
        _ptwReady = window.SGLVPTW.init(PTW_HOST);
        if (!_ptwReady) {
            console.warn('[PTW] 浮窗框架握手失败 (apiVersion 不匹配)');
        } else {
            console.log(`[PTW] 浮窗框架已就绪 (apiVersion=1, 宿主能力 ${_ptwFnCount} 项)`);
        }
    } else {
        console.warn('[PTW] 浮窗框架库未加载 — 游戏数据浮窗不可用 (请检查 @require 或 Tampermonkey 外部资源设置)');
    }
 // 回写握手结果，供 SGIS / 设置面板判定浮窗可用性（无法访问本闭包 _ptwReady）
    if (window.SGLVPTW) window.SGLVPTW._hostReady = _ptwReady;

 //浮窗隐藏「总览」Tab——内容与主面板「游玩数据」页完全重复
 //（两者共用 SGLVPTW.mountInto('overview') 同一份渲染实现，库仍需 @require 加载）。
 // hideTab 只影响浮窗 Tab 栏与 view 恢复，mountInto 主面板路径不受影响。
    try {
        if (window.SGLVPTW && typeof window.SGLVPTW.hideTab === 'function') {
            window.SGLVPTW.hideTab('overview', true);
        } else {
            console.warn('[PTW] 框架库版本过旧，无 hideTab——浮窗「总览」Tab 未隐藏（不影响功能）');
        }
    } catch (e) { /* 隐藏失败不阻断 */ }

 //PTW 面板标题/状态图标尺寸约束（覆盖层，随主脚本走）——
 // ICONS 系列 SVG 仅有 viewBox 无 width/height，默认 width:100% 撑满整行；
 // 除总览 Tab（复用 .sglv-playtime-section-title，共享 CSS 已约束）外，
 // 其余 Tab 库的面板标题类均无 svg 尺寸规则 → 成就/价格/价值/足迹/日历/家庭图标全部炸开。
    // 此处统一约束；stroke/fill 等外观属性已内联在 ICONS 的 ${_S} 中，无需重复声明。
 // ★v2.42.0 补 .sglv-pt-quote-panel-title：库价行情 Tab（v2.37.0 新增）建好后没被加进这份名单，
 //   结果曲线面板标题的折线图标被撑成 691×691（实测），整块版面变成一条巨大的「M」。
 //   ——新 Tab 上线时，记得把它的面板标题类补进这份名单。
    try {
        GM_addStyle(`
.sglv-ptw-ach-panel-title svg,.sglv-ptw-price-panel-title svg,.sglv-ptw-value-panel-title svg,
.sglv-ptw-strk-panel-title svg,.sglv-ptcal-tl-title svg,.sglv-fam-title>svg,.sglv-fam-refresh svg,
.sglv-pt-quote-panel-title svg,
.sglv-ptwin-open svg{width:14px;height:14px;flex-shrink:0;}
.sglv-ptw-ach-state-icon svg,.sglv-ptw-price-state-icon svg{width:34px;height:34px;flex-shrink:0;}
/* 图表宽度约束——SGLVCharts.svg 输出 width=100%+viewBox（设计宽 640/680），
   超宽窗口下被等比放大近 3 倍（字号/线宽随之爆炸，成就时间线变成全屏巨图）。
   按各图表设计宽封顶并居中，高度随 viewBox 等比，不再随容器拉伸 */
.sglv-ptw-ach-chart{max-width:680px;margin:0 auto;}
.sglv-ptw-ach-chart svg{width:100%;height:auto;}
.sglv-ptw-value-chart{max-width:720px;margin:0 auto;}
.sglv-ptw-value-chart svg{width:100%;height:auto;}
/* 库价行情曲线图同纪律：设计宽 560，面板宽 ~980 时会被等比放大到 1.7 倍
   （轴字号 10px→17px，比 11.5px 的面板标题还大）。按设计宽封顶并居中。 */
.sglv-pt-quote-panel-body>svg{max-width:640px;height:auto;display:block;margin:0 auto;}
/* 全部游戏 Tab——列表吃满 pane 高度（共享库 .sglv-pt-all-list max-height:500px
   只能看 ~13 行），分页钉在 pane 底部；行距紧凑保证 18 行/页完整可视 */
.sglv-ptw-pane.active{display:flex;flex-direction:column;}
.sglv-ptw-pane > .sglv-pt-all-list{flex:1 1 0;min-height:0;max-height:none;}
.sglv-ptw-pane > .sglv-pt-pagination{flex-shrink:0;margin-top:8px;}
.sglv-ptw-pane .sglv-pt-all-item{padding:4px 8px;margin-bottom:2px;}
/* 成就 Tab 网格重排（替代居中窄列）——Hero 通栏；
   「稀有度分布 + 解锁时间线」双栏；「成就明细」通栏 */
.sglv-ptw-ach-body{display:grid;grid-template-columns:minmax(0,2fr) minmax(0,3fr);gap:12px;align-items:start;}
.sglv-ptw-ach-body > div:nth-child(1){grid-column:1/-1;}
.sglv-ptw-ach-body > div:nth-child(2){grid-column:1;grid-row:2;}
.sglv-ptw-ach-body > div:nth-child(3){grid-column:2;grid-row:2;}
.sglv-ptw-ach-body > div:nth-child(4){grid-column:1/-1;grid-row:3;}
/* 足迹 Tab 布局 —— v2.22.6 起**移除**本覆盖层：
   原 grid 重排（grid-row:3 硬指定行号 + auto auto minmax(0,1fr) 行模板）会把
   「采样日历 / 年度游戏」两面板压扁，面板内容溢出网格行后与下方通栏的
   「首次上手 / 里程碑」互相压盖（用户截图：两个标题叠在同一格、note 横穿面板），
   且 pane 是 overflow:hidden 导致整页无法滚动。
   现由 PTW 库统一用 flex-wrap 负责（banner/hero 通栏 + panel 两列平铺 + body 自滚），
   此处保留注释以免后续再被加回来。 */
/* 入库月历微调——月卡间距与内边距收紧（年份胶囊 nowrap / 宽度上限 / 时间线高度下限
   已在 CSS_PLAYDATA 基线统一治理，此处不再重复覆盖：
   原覆盖层的 max-width:46% 是「右侧图例被裁掉」的元凶之一——1080px 窗口下年份胶囊被钉死
   在 ~500px，叠加右侧 summary(5 chip + 图例) 后必然溢出，被 pane 的 overflow 裁切。） */
.sglv-ptcal-grid{gap:10px;}
.sglv-ptcal-month{padding:7px 7px 5px;}
`);
    } catch (e) { /* 样式失败不阻断功能 */ }

 // ---- 降级路径：框架缺失时给用户明确提示，绝不静默白屏 ----
 // 背景：受限网络下 @require 可能静默失败导致功能整体不可用且无任何提示。
 // 此处保证「功能不可用」时用户一定看得到原因与处置方法。
 //
 //拆出 ptwFallbackHtml() 供主面板「游玩数据」Tab 内联复用——
 // showPtwFallback 是模态卡片形态，不适合塞进 Tab 面板。
    const PTW_FALLBACK_REASON = window.SGLVPTW
        ? 'apiVersion 不匹配（脚本与功能库版本不一致）'
        : '外部资源 scriptcat.org 未返回脚本内容';

    function ptwFallbackHtml() {
        const NSS = 'sglv-ptw-fb';
        try {
            if (!document.getElementById(NSS + '-style')) {
                const st = document.createElement('style');
                st.id = NSS + '-style';
                st.textContent = `
.${NSS}-inline{padding:22px 18px;border:1px dashed rgba(232,163,61,.4);border-radius:10px;background:rgba(232,163,61,.06);color:#c7d5e0;font-size:13px;line-height:1.75;}
.${NSS}-inline .${NSS}-t{font-size:14px;font-weight:600;color:#e8a33d;margin-bottom:10px;}
.${NSS}-k{display:inline-block;padding:1px 7px;margin:0 2px;border-radius:5px;background:rgba(102,192,244,.14);color:#66c0f4;font-family:ui-monospace,monospace;font-size:11px;}
.${NSS}{position:fixed;z-index:1000004;inset:0;display:flex;align-items:center;justify-content:center;background:rgba(0,0,0,.5);backdrop-filter:blur(3px);}
.${NSS}-box{max-width:520px;padding:28px 30px;border-radius:14px;background:#1a2733;border:1px solid rgba(232,163,61,.35);box-shadow:0 18px 60px rgba(0,0,0,.55);color:#c7d5e0;font-size:13px;line-height:1.75;}
.${NSS}-t{font-size:15px;font-weight:600;color:#e8a33d;margin-bottom:12px;}
.${NSS}-d{opacity:.85;margin-bottom:8px;}
.${NSS}-k{display:inline-block;padding:1px 7px;margin:0 2px;border-radius:5px;background:rgba(102,192,244,.14);color:#66c0f4;font-family:ui-monospace,monospace;font-size:11px;}
.${NSS}-btn{margin-top:18px;padding:8px 20px;border-radius:8px;border:1px solid rgba(102,192,244,.4);background:rgba(102,192,244,.14);color:#66c0f4;font-size:13px;cursor:pointer;}
.${NSS}-btn:hover{background:rgba(102,192,244,.26);}
`;
                document.head.appendChild(st);
            }
            return `<div class="${NSS}-inline">
<div class="${NSS}-t">游戏数据浮窗功能库未加载</div>
<div>原因：${escHtml(PTW_FALLBACK_REASON)}</div>
<div>常见处置：</div>
<div>1. Tampermonkey → 编辑脚本 → 确认「外部资源设置」允许访问 <span class="${NSS}-k">scriptcat.org</span></div>
<div>2. 检查网络能否访问该域名，必要时切换 CDN</div>
<div>3. 其余功能不受影响，可正常继续使用</div>
</div>`;
        } catch (e) {
            return `<div class="${NSS}-inline">游戏数据浮窗功能库未加载（${escHtml(PTW_FALLBACK_REASON)}）</div>`;
        }
    }

    function showPtwFallback(reason) {
        try {
            if (document.getElementById('sglv-ptw-fallback')) return;
            const NSS = 'sglv-ptw-fb';
            const el = document.createElement('div');
            el.id = 'sglv-ptw-fallback';
            el.className = NSS;
            el.innerHTML = `<div class="${NSS}-box">
<div class="${NSS}-t">游戏数据浮窗功能库未加载</div>
<div class="${NSS}-d">原因：${escHtml(reason)}</div>
<div class="${NSS}-d">常见处置：</div>
<div class="${NSS}-d">1. Tampermonkey → 编辑脚本 → 确认「外部资源设置」允许访问 <span class="${NSS}-k">scriptcat.org</span></div>
<div class="${NSS}-d">2. 检查网络能否访问该域名，必要时切换 CDN</div>
<div class="${NSS}-d">3. 其余功能不受影响，可正常继续使用</div>
<button class="${NSS}-btn" onclick="this.closest('.${NSS}').remove()">知道了</button>
</div>`;
            document.body.appendChild(el);
        } catch (e) { /* 降级再失败则静默，不阻塞主流程 */ }
    }
    if (!_ptwReady) {
 // 延迟到 DOM 就绪后再提示，避免过早插入被后续 DOM 操作覆盖
        if (document.readyState === 'loading') {
            document.addEventListener('DOMContentLoaded', () => showPtwFallback(
                window.SGLVPTW ? 'apiVersion 不匹配（脚本与功能库版本不一致）' : '外部资源 scriptcat.org 未返回脚本内容'
            ), { once: true });
        } else {
            showPtwFallback(
                window.SGLVPTW ? 'apiVersion 不匹配（脚本与功能库版本不一致）' : '外部资源 scriptcat.org 未返回脚本内容'
            );
        }
    }


 //修复 Steam 客户端中"测试 ITAD 连接"报
 // ❌ 连接失败: Cannot read properties of undefined (reading 'match')
 // 根因链: ① Steam 客户端 CEF 环境下 GM_xmlhttpRequest 网络层失败(浏览器正常)；
 // ② SGLVCore.gmFetchJson 的 onerror(err) 在重试耗尽后 reject(err)——err 是 GM 传入的
 // 原始响应/事件对象，没有 .message 属性；
 // ③ SGLVITAD.testConnection 的 catch 里 e.message.match(/HTTP (\d+)/) 对 undefined 调
 // .match 抛 TypeError，其消息被外层 catch 显示为上述报错。
 // 修复两处（均在主脚本内做，覆盖层方式，不改 @require 库文件）：
 // A) 包装 SGLVCore.gmFetchJson：任何非 Error 拒绝值归一化为带 message 的 Error（全局受益）；
 // B) 主脚本侧 _sglvItadTestConnection：GM 网络层失败时用原生 fetch 直连兜底
 // （ITAD API 返回 Access-Control-Allow-Origin: *，页面上下文 fetch 可用）。
    function _sglvNormalizeFetchError(e) {
        if (e instanceof Error && e.message) return e;
        let msg = '';
        if (e && typeof e === 'object') {
            if (typeof e.error === 'string' && e.error) msg = e.error;
            else if (e.status) msg = 'HTTP ' + e.status + (e.statusText ? ' ' + e.statusText : '');
            else try { msg = JSON.stringify(e); } catch (_) { msg = ''; }
        }
        if (!msg) msg = String(e || 'network error');
        if (msg === '{}' || msg === 'undefined' || msg === 'null') msg = 'network error';
        return new Error(msg);
    }
    (function _sglvPatchGmFetchJson() {
        try {
            if (!window.SGLVCore || typeof window.SGLVCore.gmFetchJson !== 'function') return;
            if (window.SGLVCore.gmFetchJson.__sglvErrNormalized) return;
            const orig = window.SGLVCore.gmFetchJson;
            const wrapped = function (url, options) {
                return orig.call(this, url, options).catch(e => { throw _sglvNormalizeFetchError(e); });
            };
            wrapped.__sglvErrNormalized = true;
            window.SGLVCore.gmFetchJson = wrapped;
        } catch (e) { /* 包装失败不影响原链路 */ }
    })();
    async function _sglvItadTestConnection(testKey) {
        try {
            return await window.SGLVITAD.testConnection(testKey);
        } catch (e) {
            const msg = (e && e.message) ? String(e.message) : String(e || 'unknown error');
 // GM 网络层不可用/网络错误 → 原生 fetch 直连 ITAD 兜底（Steam 客户端 CEF 场景）
            if (typeof fetch === 'function' && /network error|timeout|unavailable|Failed to fetch|NetworkError|网络/i.test(msg)) {
                try {
                    const resp = await fetch('https://api.isthereanydeal.com/service/shops/v1?key=' + encodeURIComponent(testKey), { method: 'GET' });
                    if (resp.ok) {
                        const data = await resp.json().catch(() => null);
                        return { success: true, shopCount: Array.isArray(data) ? data.length : 0 };
                    }
                    if (resp.status === 401 || resp.status === 403) {
                        return { success: false, error: 'Invalid API key (HTTP ' + resp.status + ')' };
                    }
                    return { success: false, error: 'HTTP ' + resp.status };
                } catch (e2) {
                    return { success: false, error: '网络请求失败 (GM 与 fetch 均不可达): ' + ((e2 && e2.message) || e2) };
                }
            }
            return { success: false, error: msg };
        }
    }

 // ==================== UI 构建 ====================
    let overlayEl, panelEl;

 //导航栏二级菜单构建器（修复"游戏收藏二级菜单无法打开" + 新增「游戏数据」入口）
 // ——从 initUI 抽出为独立函数, 便于 vm 执行级回归(见单测 H 组)。
 //对齐 Steam 原生下拉——取消 ▾ 箭头开关,「游戏库」悬停展开、点击直接打开主浮窗,
 // 菜单三项竖排(打开面板 / 游戏收藏 / 游戏数据), 首项 is-active 选中高亮, 停靠锚点仍是 fab。
 // 历史坑: ① 纯 CSS :hover 下拉在触屏/Steam 客户端 CEF 无 hover 不可达, fab 无下拉箭头零可供性;
 // ② 降级分支 style.cssText 的 position:fixed 被共享库 .sglv-menu-wrap{position:relative!important}
 // 覆盖(stylesheet !important 胜 inline), 社区页菜单被钉在文档流末尾"打不开";
 // ③ 箭头作为独立 .menuitem 受 Steam float:left 影响换行堆到 fab 上方, 且与菜单割裂。
 // 方案: 有 hover 时「游戏库」点击直接 togglePanel, 悬停才展开菜单(打开有短延迟, 离开有宽限,
 // 避免划过导航栏闪一下、或还没移到选项就收起); 无 hover(触屏/Steam 客户端 CEF)仍点击开合。
 // 展开时子菜单 position:fixed 停靠到 fab 下方(滚动 rAF 节流重定位, resize 关闭);
 // 外点/Esc/移出关闭; 降级分支改走 .sglv-menu-fixed class(class 选择器可与 !important 同权竞争)。
 // 返回 menuWrap, 由调用方插入 supernav 或 body(本函数内已按 .supernav_container 是否存在自分流)。
    function buildSglvMenu() {
        const menuWrap = document.createElement('span');
        menuWrap.className = 'sglv-menu-wrap';
        menuWrap.setAttribute('data-sglv-plugin-ui', '1');

        const fab = document.createElement('a');
        fab.className = 'menuitem sglv-fab';
        fab.href = 'javascript:void(0)';
        fab.textContent = T.title;
        // 不用 title：原生提示会盖在第一项「打开游戏库」上，鼠标追过去时菜单已经收起
        fab.setAttribute('aria-label', T.title);
        menuWrap.appendChild(fab);

 //二级菜单 —— 「打开游戏库面板 / 游戏收藏 / 游戏数据」三项竖排。
 //变更(对齐 Steam 原生下拉):① 取消 ▾ 箭头开关, 「游戏库」悬停开合、点击进主浮窗,
 // 箭头曾因 Steam .menuitem{float:left} 换行堆到「游戏库」上方且与菜单割裂;
 // ② 面板入口从 fab 移入菜单首项(带 is-active 选中高亮), 取消箭头后仍可一键开面板;
 // ③ 停靠锚点仍是 fab(游戏库), 子菜单恒在其正下方。
        const submenu = document.createElement('div');
        submenu.className = 'sglv-submenu';

 // 首项: 打开游戏库面板(原先由 fab 点击承担, 取消箭头后迁入菜单, 默认选中高亮)
        const panelLink = document.createElement('a');
        panelLink.className = 'menuitem sglv-submenu-item is-active';
        panelLink.href = 'javascript:void(0)';
        panelLink.textContent = T.ptMenuOpenPanel;
        panelLink.title = T.ptMenuOpenPanelTip;
        panelLink.addEventListener('click', (e) => {
            e.preventDefault();
            closeSubmenu();
            togglePanel();
        });
        submenu.appendChild(panelLink);

        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();
 //点击接管后 hover 不再自动收起子菜单, 菜单项点击需显式关闭
            closeSubmenu();
 //点击链路异常可见化——此前任何运行时错误只进控制台,用户感知为"点击无反应"。
 // 握手失败(库已加载但 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);

 //「游戏数据」——位于游戏收藏下方, 点击直接打开全部游戏排行全屏浮窗
 // (全部游戏 / 家庭对比 / 入库月历三 Tab), 无需先开面板再切游玩数据 Tab。
        const gameDataLink = document.createElement('a');
        gameDataLink.className = 'menuitem sglv-submenu-item';
        gameDataLink.href = 'javascript:void(0)';
        gameDataLink.textContent = T.ptMenuGameData;
        gameDataLink.title = T.ptMenuGameDataTip;
        gameDataLink.addEventListener('click', (e) => {
            e.preventDefault();
            closeSubmenu();
            openGameDataWindow();
        });
        submenu.appendChild(gameDataLink);

        menuWrap.appendChild(submenu);

 //「游戏库」：有 hover 时点击直接进主浮窗，悬停才出菜单。
 // 子菜单是 position:fixed，和按钮之间有一条缝；指针穿过缝时不算还在 menuWrap 里，
 // 立刻 mouseleave 收起就是「还没点到就消失」。打开稍等一下，离开再留一段宽限，
 // 移进菜单（含 ::before 热区）就取消收起。
        const _hoverUnsupported = (typeof window.matchMedia === 'function')
            ? window.matchMedia('(hover: none)').matches
            : false;
        const SUB_OPEN_DELAY = 140;
        const SUB_CLOSE_DELAY = 380;
        let _subOpenTimer = 0;
        let _subCloseTimer = 0;
        function _clearSubTimer(which) {
            if (which === 'open' && _subOpenTimer) { clearTimeout(_subOpenTimer); _subOpenTimer = 0; }
            if (which === 'close' && _subCloseTimer) { clearTimeout(_subCloseTimer); _subCloseTimer = 0; }
        }
        function _cancelSubTimers() { _clearSubTimer('open'); _clearSubTimer('close'); }
        function _scheduleSubOpen() {
            if (_hoverUnsupported || isSubOpen() || _subOpenTimer) return;
            _clearSubTimer('close');
            _subOpenTimer = setTimeout(() => { _subOpenTimer = 0; openSubmenu(); }, SUB_OPEN_DELAY);
        }
        function _scheduleSubClose() {
            _clearSubTimer('open');
            if (_hoverUnsupported || !isSubOpen()) return;
            _clearSubTimer('close');
            _subCloseTimer = setTimeout(() => { _subCloseTimer = 0; closeSubmenu(); }, SUB_CLOSE_DELAY);
        }
        function _subPointerIn() {
            _clearSubTimer('close');
            if (!isSubOpen()) _scheduleSubOpen();
        }
        function _subPointerOut() { _scheduleSubClose(); }
        fab.addEventListener('click', (e) => {
            e.preventDefault();
            e.stopPropagation();
            _cancelSubTimers();
            // 无 hover 时点击仍负责开合，否则触屏进不了「游戏收藏 / 游戏数据」
            if (_hoverUnsupported) { toggleSubmenu(); return; }
            closeSubmenu();
            togglePanel();
        });
        menuWrap.addEventListener('mouseenter', _subPointerIn);
        menuWrap.addEventListener('mouseleave', _subPointerOut);
        submenu.addEventListener('mouseenter', _subPointerIn);
        submenu.addEventListener('mouseleave', _subPointerOut);

        function isSubOpen() { return menuWrap.classList.contains('sglv-open'); }
        function closeSubmenu() {
            _cancelSubTimers();
            menuWrap.classList.remove('sglv-open');
            submenu.classList.remove('sglv-submenu-docked');
        }
 // 停靠: 子菜单 position:fixed 到 fab 正下方——摆脱 Steam 头部/面板祖先 overflow:hidden
 // 裁剪(共享库 absolute 定位在降级浮浮场景会被裁)。坐标经 CSS 自定义属性传值,
 // 避开共享库 top/left 的 !important(CSS_MENU 内 var 供值 + !important 留样式表侧)。
        function dockSubmenu() {
 // 锚点 = 游戏库(fab)本身, 子菜单因此恒停靠在「游戏库」正下方(而非 ▾ 或菜单容器右缘)。
 // fab 尚未参与布局时(首帧 / 祖先 display:none)矩形全 0, 退回 menuWrap 自身矩形,
 // 避免 --sglv-sub-* 拿到 0 把子菜单钉到视口左上角——即"加载位置有问题"的兜底。
            let r = (typeof fab.getBoundingClientRect === 'function') ? fab.getBoundingClientRect() : null;
            if (!r || !(r.bottom > 0)) {
                r = (typeof menuWrap.getBoundingClientRect === 'function') ? menuWrap.getBoundingClientRect() : null;
            }
            if (r && submenu.style && typeof submenu.style.setProperty === 'function') {
                submenu.style.setProperty('--sglv-sub-top', r.bottom + 'px');
                submenu.style.setProperty('--sglv-sub-left', r.left + 'px');
            }
            submenu.classList.add('sglv-submenu-docked');
        }
        function openSubmenu() {
            menuWrap.classList.add('sglv-open');
            dockSubmenu();
        }
        function toggleSubmenu() { isSubOpen() ? closeSubmenu() : openSubmenu(); }

 // 页面滚动时子菜单跟着 fab 走(rAF 节流; passive 不阻塞滚动)
        let _subScrollRaf = 0;
        window.addEventListener('scroll', () => {
            if (!isSubOpen() || _subScrollRaf) return;
            _subScrollRaf = requestAnimationFrame(() => { _subScrollRaf = 0; if (isSubOpen()) dockSubmenu(); });
        }, { passive: true });
 // 视口变化时停靠几何失效, 直接关闭避免错位
        window.addEventListener('resize', closeSubmenu);
 // 外点 / Esc 关闭（menuWrap.contains 在测试桩上不存在, 可选链兜底）
        document.addEventListener('click', (e) => {
            if (!isSubOpen()) return;
            if (menuWrap.contains && menuWrap.contains(e.target)) return;
            closeSubmenu();
        });
        document.addEventListener('keydown', (e) => { if (e && e.key === 'Escape') closeSubmenu(); });

 // 客服锚点：旧商店头走 .supernav_container；愿望单等 React 头没有这个节点，
 // 顶栏是 nav > ul 里的 help.steampowered.com 链接（页脚「联系客服」和折叠菜单要排除）。
        function findHeaderSupportLink() {
            const supernav = document.querySelector('.supernav_container');
            if (supernav) {
                const classic = supernav.querySelector('a.menuitem[href*="help.steampowered.com"]')
                    || Array.from(supernav.querySelectorAll('a.menuitem')).pop();
                if (classic) return { link: classic, mode: 'classic' };
            }
            const links = document.querySelectorAll ? document.querySelectorAll('a[href*="help.steampowered.com"]') : [];
            for (const a of links) {
                const href = (a.getAttribute && a.getAttribute('href')) || '';
                if (href.indexOf('/faqs/') !== -1) continue;
                if (typeof a.closest === 'function') {
                    if (a.closest('details[name="responsive-menu"]')) continue;
                    if (a.closest('footer')) continue;
                    if (a.closest('[popover]')) continue;
                }
                const text = (a.textContent || '').replace(/\s+/g, ' ').trim();
                if (!text || text.length > 16) continue;
                const parent = a.parentElement;
                if (!parent || (parent.tagName !== 'UL' && parent.tagName !== 'NAV' && parent.tagName !== 'LI')) continue;
                if (typeof a.closest === 'function' && !a.closest('nav')) continue;
                return { link: a, mode: 'react' };
            }
            return null;
        }
        function syncReactHeaderClasses(helpLink) {
            const classes = String(helpLink.className || '').split(/\s+/).filter(Boolean);
            for (const c of classes) {
                if (c && !fab.classList.contains(c)) fab.classList.add(c);
            }
            if (helpLink.style && fab.style && typeof helpLink.style.getPropertyValue === 'function') {
                const cursor = helpLink.style.getPropertyValue('--cursor');
                if (cursor) fab.style.setProperty('--cursor', cursor);
            }
        }
        let _menuObs = [];
        let _seating = false;
        let _seatMoves = [];
        let _seatTimer = 0;
        function _nodeInForeignUi(node) {
            const el = node && node.nodeType === 1 ? node : (node && node.parentElement);
            if (!el || typeof el.closest !== 'function') return false;
            return !!el.closest('#familyAnalysisPanel, #sgis-panel, #fa-wl-sibling, #setting_btn, #fa_dd_item, #swe-panel, #swe-fab, .swe-nav-entry, .swe-settings-overlay, .swe-loading-overlay, .swe-toast, [data-fa-plugin-ui], [data-swe-plugin-ui]');
        }
        function _menuMutationIsOurs(mutation) {
            const t = mutation && mutation.target;
            if (!t) return true;
            if (menuWrap.contains && (t === menuWrap || menuWrap.contains(t))) return true;
            if (_nodeInForeignUi(t)) return true;
            const lists = [mutation.addedNodes, mutation.removedNodes];
            let saw = false;
            for (let li = 0; li < lists.length; li++) {
                const list = lists[li];
                if (!list) continue;
                for (let j = 0; j < list.length; j++) {
                    const n = list[j];
                    if (!n || (n.nodeType !== 1 && n.nodeType !== 3)) continue;
                    saw = true;
                    const inMenu = n !== menuWrap && menuWrap.contains && menuWrap.contains(n);
                    if (!inMenu && !_nodeInForeignUi(n)) return false;
                }
            }
            return saw;
        }
        function watchMenuHost(node, opts) {
            if (!node || typeof MutationObserver !== 'function') return;
            if (_menuObs.some(o => o.target === node)) return;
            const obs = new MutationObserver((mutations) => {
                for (let i = 0; i < mutations.length; i++) {
                    if (_menuMutationIsOurs(mutations[i])) continue;
                    if (_seatTimer) return;
                    _seatTimer = setTimeout(() => { _seatTimer = 0; seatMenu(); }, 200);
                    return;
                }
            });
            obs.target = node;
            obs.observe(node, opts);
            _menuObs.push(obs);
        }
        function seatMenu() {
            if (_seating) return false;
            const now = Date.now();
            _seatMoves = _seatMoves.filter(t => now - t < 10000);
            if (_seatMoves.length >= 6) return !!(menuWrap.isConnected);
            const found = findHeaderSupportLink();
            if (!found) return false;
            _seating = true;
            try {
                const helpLink = found.link;
                const nav = (typeof helpLink.closest === 'function' && helpLink.closest('nav')) || helpLink.parentElement;
                const already = !!(menuWrap.isConnected && nav && typeof nav.contains === 'function' && nav.contains(menuWrap));
                if (!already) {
                    if (found.mode === 'react') {
                        syncReactHeaderClasses(helpLink);
                        menuWrap.classList.add('sglv-menu-in-header');
                    }
                    menuWrap.classList.remove('sglv-menu-fixed');
                    const anchor = (helpLink.parentElement && helpLink.parentElement.tagName === 'LI') ? helpLink.parentElement : helpLink;
                    if (anchor.nextElementSibling !== menuWrap) {
                        _seatMoves.push(Date.now());
                        if (typeof anchor.after === 'function') anchor.after(menuWrap);
                        else if (anchor.parentNode) anchor.parentNode.insertBefore(menuWrap, anchor.nextSibling);
                    }
                }
                if (nav) {
                    watchMenuHost(nav, { childList: true, subtree: true });
                    if (nav.parentElement) watchMenuHost(nav.parentElement, { childList: true });
                }
            } finally {
                _seating = false;
            }
            return !!(menuWrap.isConnected || (menuWrap.parentNode));
        }
        if (!seatMenu()) {
 // 头部还没出来时先挂浮动按钮，避免入口消失；挂上后由 seatMenu 挪到客服后面。
            menuWrap.classList.add('sglv-menu-fixed');
            if (document.body) document.body.appendChild(menuWrap);
            let tries = 0;
            const retry = setInterval(() => {
                tries++;
                if (seatMenu() || tries >= 24) clearInterval(retry);
            }, 250);
        }
        return menuWrap;
    }

    function initUI() {
 //主题热切换——CSS 即时生效,已渲染的 SVG 图表/条件色需重渲染取新主题色板;
 // 设置视图打开时跳过（保存流程自身持有 DOM 引用,且设置界面随 CSS 已即时换肤）
        window.addEventListener('sglv-theme-changed', () => {
            if (panelEl && panelEl.isConnected && !state.showSettings) {
                try { renderBody(); } catch (e) { console.warn('[SGLV] 主题切换重渲染失败:', e); }
            }
        });
 // 库存展示按钮 + 二级菜单（游戏收藏 / 游戏数据）——插入到全局导航栏"客服"后方
        buildSglvMenu();

 // 遮罩层
        overlayEl = document.createElement('div');
        overlayEl.className = 'sglv-overlay';
        overlayEl.addEventListener('click', closePanel);
        document.body.appendChild(overlayEl);

 // 主面板
        panelEl = document.createElement('div');
        panelEl.className = 'sglv-panel';
 //页头紧凑化——移除"游戏库"标题，保留最左侧 Steam 图标作为品牌标识，tabs 移入 header 内部（参考 steam-friend-manager sfd-tab-bar 风格）
 //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-btn" id="sglv-export-btn" title="${isZh ? '导出库数据（CSV / JSON）' : 'Export library (CSV / JSON)'}">${ICONS.download || ICONS.json || '⬇'}</button>
                    <button class="sglv-header-btn sglv-data-analysis-btn" id="sglv-data-analysis-btn" title="${isZh ? '游戏数据分析' : 'Game data analysis'}">${ICONS.barChart}</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.23.1: 注册 SGLVCoverFallback 全局 error 委托——data-sglv-cover 属性的 <img>
 // 出错时由 lib 接管降级链(4 CDN → steamui hash → appdetails API → SVG placeholder),
 // 覆盖所有 tab（owned/showcase/wishlist/cloudsave/...）和未来新增视图
        _ensureCoverFallbackDelegation(panelEl);
 //header 整行作为拖动手柄（参考 steam-friend-manager 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', () => {
 //设置已集成进主面板——再点一次可退出设置视图
            if (state.showSettings) closeGlobalSettings();
            else openGlobalSettings();
        });
 //心型按钮 → 打开游戏收藏浮窗
 //同子菜单项——握手/异常可见化(见 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');
            }
        });
        
        // ★v2.36.0 导出合并为一个下拉菜单（原 CSV/JSON 两个文本按钮）+ 新增数据分析直达入口
        const exportBtn = panelEl.querySelector('#sglv-export-btn');
        let _exportMenu = null;
        const _closeExportMenu = () => {
            if (_exportMenu) { _exportMenu.remove(); _exportMenu = null; }
            document.removeEventListener('mousedown', _onExportOutside, true);
        };
        const _onExportOutside = (e) => {
            if (!_exportMenu) return;
            if (_exportMenu.contains(e.target) || exportBtn.contains(e.target)) return;
            _closeExportMenu();
        };
        exportBtn.addEventListener('click', () => {
            if (_exportMenu) { _closeExportMenu(); return; }
            _exportMenu = document.createElement('div');
            _exportMenu.className = 'sglv-export-menu';
            _exportMenu.innerHTML = `
                <button type="button" data-fmt="csv"><span class="fmt-badge csv">CSV</span>${isZh ? '导出 CSV 文件' : 'Export CSV'}</button>
                <button type="button" data-fmt="json"><span class="fmt-badge json">JSON</span>${isZh ? '导出 JSON 文件' : 'Export JSON'}</button>`;
            document.body.appendChild(_exportMenu);
            const rect = exportBtn.getBoundingClientRect();
            const mw = _exportMenu.offsetWidth || 170;
            _exportMenu.style.left = Math.min(rect.left, (window.innerWidth || document.documentElement.clientWidth) - mw - 8) + 'px';
            _exportMenu.style.top = (rect.bottom + 6) + 'px';
            _exportMenu.classList.add('show');
            _exportMenu.addEventListener('click', (e) => {
                const b = e.target.closest('button');
                if (!b) return;
                _closeExportMenu();
                if (b.dataset.fmt === 'csv') exportCSV();
                else exportJSON();
            });
            setTimeout(() => document.addEventListener('mousedown', _onExportOutside, true), 0);
        });

        // 数据分析按钮——直达「游戏数据分析」全屏浮窗（库未加载时 toast 引导，与导航菜单同口径）
        panelEl.querySelector('#sglv-data-analysis-btn').addEventListener('click', () => {
            try { openGameDataWindow(); }
            catch (e) { console.error('[SGLV] 打开游戏数据分析失败:', e); showToast(isZh ? '打开失败，详见控制台' : 'Failed to open, see console'); }
        });

        panelEl.querySelectorAll('.sglv-tab').forEach(tab => {
            tab.addEventListener('click', () => {
 //统一使用 switchToTab
                switchToTab(tab.dataset.tab);
            });
        });

 //绑定全局游戏搜索框事件（输入防抖/键盘导航/外部点击关闭/清除按钮）
        bindGlobalSearchEvents();
 //首次绑定时也构建一次搜索索引（已有缓存的情况下,UI 即可用）
        if (!_searchIndexBuilt) {
            try { buildSearchIndex(); } catch (e) { console.warn('[SGLV] 搜索索引预构建失败:', e); }
        }

 //供侧边栏 KPI 卡片跨模块打开游戏库浮窗
 //注册到 addDisposer 确保卸载时清理，避免内存泄漏
        const _onOpenLibrary = () => { openPanel(); };
        document.addEventListener('sglv:open-library', _onOpenLibrary);
        addDisposer(() => document.removeEventListener('sglv:open-library', _onOpenLibrary));

 //监听 SGIS 侧边栏触发的事件, 支持跳转指定 tab
        const _onOpenModal = (e) => {
            openPanel();
            const targetTab = e?.detail?.tab;
            if (targetTab) {
 //统一使用 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: 缓存恢复,索引需要重建
 //同步从 PCC IDB 预热已计算的 KPI 结果到 _computedCache
 // 旧逻辑 clearComputedCache 把所有缓存清空,下次开面板全量重算(每次)
 // 新逻辑 hydrateComputedCache 把已持久化的计算结果(年度统计/家庭组/insight 等)从 IDB 同步填充
 // 启动时 IDB.loadAll 已完成,内存镜像 _mem 可用
            hydrateComputedCache();
        } else {
 // 首次使用/无缓存:确保缓存清空
            clearComputedCache();
        }

 //DLC 数据库同步预加载延迟到下一事件循环，确保菜单入口优先渲染
 // DLC 缓存体积较大（数万条），同步 JSON.parse 会阻塞浏览器首次绘制
        setTimeout(() => {
            loadDlcDatabaseFromCacheSync();
            loadDlcDatabase();
 //异步加载游戏系列数据（game_series.json），合并到系列分类数据库
 //同时拉取 steam_vediogame_selected.json，作为"互动影游"系列并入同一管线
            loadSeriesData();
 //异步加载供应商数据远程版本检查（覆盖 @resource GAME_DB）
            loadSupplierData();

// v2.45.0：不再有「首次未配置 API Key」的开场引导卡片 ——
// 配置 Key 必须由用户在「需要它的功能」上主动触发，并先看到用途与风险说明（见 _openApiKeyConsent）。
// 页面加载阶段保持零打扰：不弹窗、不引导、不加载。
        }, 0);
    }

    function togglePanel() {
        if (panelEl.classList.contains('sglv-show')) closePanel();
        else openPanel();
    }

    function openPanel() {
        panelEl.classList.add('sglv-show');
        overlayEl.classList.add('sglv-show');
 //renderBody 包裹 try-catch，渲染失败不阻断面板打开
        try { renderBody(); } catch (e) { console.error('[SGLV] 面板渲染失败:', e); }
 //展柜预热 — 面板打开时后台预取展柜数据，用户点击展柜标签时即可秒开
        try { _preheatShowcase(); } catch (e) { /* ignore */ }
    }

 //展柜预热 — 在后台静默预取展柜数据并写入持久化缓存
 // 不阻塞当前标签页渲染，仅在后台完成数据获取
    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;
                }
 //与标签页渲染共享 in-flight 抓取,避免重复网络请求
                const data = await _fetchShowcaseDataAll();
                _writeShowcaseCache({ ...data, achievements: _showcaseUnlockedOnly(data.achievements) }, configHash);
                state.showcasePreheating = false;
                state.showcasePreheated = true;
            } catch {
 //失败仅复位 preheating,允许下次 openPanel 重试预热
 // (旧实现失败后置 preheated=true,本 session 内永久跳过预热)
                state.showcasePreheating = false;
            }
        })();
    }

 //展柜数据 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');
 //清理搜索/详情浮窗状态,防止面板重开后浮窗残留 + 监听器泄漏 + 防抖 timer 泄漏
        closeDetailPopup();           // 关闭详情浮窗 + 移除 _detailEscHandler + 递增 _detailToken 使在途请求失效
        closeSearchPop();              // 关闭搜索下拉 + 重置聚焦索引
        _gsDebouncedRender.cancel();   // 取消 pending 防抖 timer
        if (_gsInputEl) _gsInputEl.value = '';  // 清空搜索框
        _gsLastResults = [];
 //同步关闭"全部游戏排行"全屏浮窗，避免面板关闭后浮窗残留（含 ESC 监听泄漏）
        const ptWin = document.getElementById('sglv-pt-all-overlay');
        if (ptWin) ptWin.remove();
    }

 //允许拖动面板（参考 steam-friend-manager 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);
        });
    }

 // ==================== 真实成就数据层（S1）====================
 // 通路：GET https://steamcommunity.com/profiles/<steamid>/achievements/<appid>?l=schinese
 //   → <script type="application/json" id="valve-ssr-data">
 //   → renderContext.queryData（多数页面是**字符串**，必须二次 JSON.parse）
 //   → queries[] 三条：schema / user_achievements / globalpercentages
 //
 // 实测口径（2026-10-25，勿凭印象改）：
 //   ① 三条 query **全部**以 internal_key（数字）为键；api_name 只存在于 schema。
 //      必须先建 internal_key → api_name 映射，映射不上的点直接丢弃（绝不拿 internal_key 冒充主键）。
 //   ② user_achievements.achievements 的 value 形如 {internal_key, unlocked, unlock_time}，
 //      字段是 unlocked / unlock_time（秒），不是 achieved / unlocktime；且只列已解锁项。
 //   ③ schema.archived 的成就必须从完成率分母剔除，否则「100% 完成」永远差几个。
 //   ④ user_achievements 整条 query 缺失 = 成就私密（unknown）；存在但为空 = 真的 0 解锁。
 //      unknown 绝不参与任何均值（unknown ≠ 0）。
 //   ⑤ 体积与成就数成正比：Portal 2（51 条）≈517KB，Wallpaper Engine（4096 条）≈2.0MB。
 //      所以必须限速；已落库的条目永久保留（只增不减、永不过期），只补没同步过的游戏。
 //   ⑥ 部分游戏 schema 没有 name / description（如 NEW_ACHIEVEMENT_1_0），回退用 api_name。
 //   ⑦ ★ schema 的 queryKey kind 实测是 "**schema_v2**"（2026-11-06 真实 steamcommunity），
 //      不再是 "schema" —— 定位靠 kindMatches（严格相等会永远 no-schema，整条链路失效）。

 // ==================== ACH-S1-BEGIN ====================
 // 真实成就模块（S1 数据层 + S2 完美墙 / S3 稀有收藏 / S4 缺口 / S5 详情弹窗）
 // 这一段被 test-scripts/build-preview.js 原样抽到本地预览页做视觉验证，保持自包含：
 // 只依赖 esc / isZh / state / showToast / _formatAchTime / nsKey / sglvIDB / C / getActiveSteamId / getStatFilteredGames
 // ⚠️ 这里的 sglvIDB / C 是**主 IIFE** 的绑定（sglvIDB = C.IDB）。
 // 收藏模块 IIFE 里那个 _C 在这里不可见 —— 之前成就层误用 _C，导致数据层整体静默失效。
 const ACH_RARE_PCT = 5;   // 全球完成率低于此值算「稀有成就」
 // 完美墙 / 缺口榜的最低成就数门槛。
 // 不加这道闸，只有 1~2 个成就的小品游戏会把「差 1 个就完美」刷成噪音
 // （实测 400 款里有 0/1、0/2 这种条目），而且它们和「51 个全解锁」混排会严重稀释价值感。
 // 只影响墙和缺口榜，不影响 KPI 的 defs / unlocked / 稀有度分布。
 const ACH_WALL_MIN_ACTIVE = 5;

 // ---- 纯解析层：无外部依赖，可独立单测 ----
 const ACH_PARSE = (function () {
     const SSR_RE = /<script[^>]*id=["']valve-ssr-data["'][^>]*>([\s\S]*?)<\/script>/i;

    // ⚠️ 数字口径纪律：未知 ≠ 0
    // Number(null) === 0 —— 若把「全球完成率未知」读成 0，tierOf(0) 会判成 mythic（<1%），
    // 即「未知」被当成「全球 0% 拿到」的最稀有档。
    // 所有 pct 读取一律走 numOrNull()：非数字 / null / 负数 / >100 → null（unknown）。
    function numOrNull(v) {
        if (v === null || v === undefined || v === '') return null;
        const n = Number(v);
        if (!Number.isFinite(n) || n < 0 || n > 100) return null;
        return n;
    }

    // ⚠️ 时间单位纪律：库内一律【毫秒】
    // Steam SSR 的 user_achievements.unlock_time 是【秒】，而快照导入与内部缓存是【毫秒】。
    // 历史上 parsePage 把秒原样写进 items[3]，UI 五处消费点全按毫秒读 →
    // 实时抓来的成就显示 1970-01-22、相对时间「20736天前」、NEW 标签永不触发；
    // 快照导入后日期正常、重新同步又变 1970（两条路写进同一份 IDB）。
    //
    // 归一用【量级判别】而非来源标记：存量 IDB 里两种单位混存，只有量级能区分。
    // 阈值 1e11 —— 现在约 1.8e9 秒 / 1.8e12 毫秒；< 1e11 的毫秒值落在 1973 年之前（Steam 不可能有），
    // ≥ 1e11 的秒值落在 5138 年（也不可能）。故该判别是安全的。
    const MS_SEC_THRESHOLD = 1e11;
    function toMs(v) {
        const n = Number(v);
        if (!Number.isFinite(n) || n <= 0) return 0;
        return n < MS_SEC_THRESHOLD ? n * 1000 : n;
    }


     // 从整页 HTML 里取 SSR 数据对象；失败返回 null
     function extractSsrJson(html) {
         if (typeof html !== 'string' || !html) return null;
         const m = html.match(SSR_RE);
         if (!m) return null;
         try { return JSON.parse(m[1]); } catch (e) { return null; }
     }

     // renderContext.queryData 可能是对象也可能是字符串（字符串需二次 parse）
     function pickQueries(ssr) {
         if (!ssr || !ssr.renderContext) return [];
         let qd = ssr.renderContext.queryData;
         if (typeof qd === 'string') {
             try { qd = JSON.parse(qd); } catch (e) { return []; }
         }
         return (qd && Array.isArray(qd.queries)) ? qd.queries : [];
     }

     // 兼容 payload 放在 queryData 或 state.data 两种形态
     function queryPayload(q) {
         if (!q || typeof q !== 'object') return null;
         if (q.queryData !== undefined && q.queryData !== null) return q.queryData;
         if (q.state && q.state.data !== undefined && q.state.data !== null) return q.state.data;
         return null;
     }

     // queryKey 的 kind 段匹配
     //
     // ★ Valve 会给 queryKey 加版本后缀 —— 实测（2026-11-06，真实 steamcommunity）：
     //   成就 schema 的 kind 从 "schema" 改成了 "**schema_v2**"。
     //   原来用 `k[2] !== kind` 严格相等 → 每页都判 no-schema
     //   → defs 为空 → no-defs，整条 SSR 成就采集链路失效。
     //
     // 规则：精确匹配优先；只有 schema 家族接受 `schema` / `schema_vN`。
     // 不做「前缀通配」—— user_achievements / globalpercentages 一旦被误配，
     // 会把别的 appid 或别的数据类型当成 schema 写库。
     // 同一套算法（kindMatches）在本仓另一处已跑通的成就采集器里也有，
     // 跨仓出处见 README 的 v2.45.2 条目；此处不复述那个名字 ——
     // 主脚本里不许出现任何指向自建数据中心的字样（test/sglv-apikey-consent.test.js 静态守卫）。
     const SCHEMA_KIND_RE = /^schema(_v\d+)?$/;

     function kindMatches(actual, want) {
         if (actual === want) return true;
         if (want === 'schema') return SCHEMA_KIND_RE.test(String(actual));
         return false;
     }

     // 按 ["achievements", appid, kind] 定位 query
     function findQuery(queries, appid, kind) {
         if (!Array.isArray(queries)) return null;
         const want = Number(appid);
         for (const q of queries) {
             const k = q && q.queryKey;
             if (!Array.isArray(k) || k.length < 3) continue;
             if (String(k[0]) !== 'achievements') continue;
             if (!Number.isFinite(Number(k[1])) || Number(k[1]) !== want) continue;
             if (!kindMatches(String(k[2]), kind)) continue;
             return queryPayload(q);
         }
         return null;
     }

     // 解析一页 → 精简切片。items 每项：[apiName, name, unlocked(0/1), unlockAt, pct(-1=缺), flags]
     // flags: bit0 = hidden, bit1 = archived
     function parsePage(html, appid) {
         const want = Number(appid);
         if (!Number.isFinite(want) || want <= 0) return { ok: false, reason: 'bad-appid' };
         const ssr = extractSsrJson(html);
         if (!ssr) return { ok: false, reason: 'no-ssr' };
         const queries = pickQueries(ssr);
         if (!queries.length) return { ok: false, reason: 'no-query' };

         const schemaData = findQuery(queries, want, 'schema');
         if (!schemaData) return { ok: false, reason: 'no-schema' };

         // schema.groups 实测是数组；user_achievements.groups 是对象，这里只吃数组/对象两种防御
         const rawGroups = Array.isArray(schemaData.groups) ? schemaData.groups
             : (schemaData.groups && typeof schemaData.groups === 'object' ? Object.keys(schemaData.groups).map(k => schemaData.groups[k]) : []);
         const defs = [];
         const keyToApi = Object.create(null);
         let archivedCount = 0;
         let seen = Object.create(null);
         for (const g of rawGroups) {
             const list = (g && Array.isArray(g.achievements)) ? g.achievements : [];
             for (const a of list) {
                 if (!a || typeof a !== 'object') continue;
                 const apiName = String(a.api_name || '').trim();
                 if (!apiName) continue;                 // 主键是 api_name，缺了跳过（绝不拿 internal_key 顶）
                 if (seen[apiName]) continue;            // 去重，防同 apiname 跨组重复
                 seen[apiName] = 1;
                 const archived = a.archived === true;
                 defs.push({
                     apiName,
                     name: String(a.name || apiName),
                     hidden: a.hidden === true,
                     archived,
                 });
                 const ik = Number(a.internal_key);
                 if (Number.isFinite(ik)) keyToApi[ik] = apiName;
                 if (archived) archivedCount++;
             }
         }
         if (!defs.length) return { ok: false, reason: 'no-defs' };

         // 全球完成率：key 是 internal_key，必须经 schema 映射
         const pctMap = Object.create(null);
         const pctData = findQuery(queries, want, 'globalpercentages');
         const pcts = pctData && pctData.percentages;
         if (pcts && typeof pcts === 'object') {
             for (const k of Object.keys(pcts)) {
                 const apiName = keyToApi[Number(k)];
                 if (!apiName) continue;                 // 映射不上就放弃（不猜）
                 const v = Number(pcts[k]);
                 if (Number.isFinite(v)) pctMap[apiName] = v;
             }
         }

         // 用户解锁：query 缺失 = 私密
         const userData = findQuery(queries, want, 'user_achievements');
         let privacy = 'unknown';
         const unlockedMap = Object.create(null);
         if (userData && typeof userData === 'object') {
             privacy = 'public';
             const ua = userData.achievements;
             if (ua && typeof ua === 'object') {
                 for (const k of Object.keys(ua)) {
                     const v = ua[k];
                     if (!v || typeof v !== 'object') continue;
                     if (v.unlocked !== true) continue;
                     const apiName = keyToApi[Number(k)] || keyToApi[Number(v.internal_key)];
                     if (!apiName) continue;             // 映射不上就不认（宁少不错）
                     const t = toMs(v.unlock_time);   // unlock_time 是【秒】→ 统一归一成【毫秒】（v2.44.0：修「实时抓来的成就日期显示 1970」）
                     unlockedMap[apiName] = t;
                 }
             }
         }

         let unlocked = 0;
         const items = defs.map(d => {
             const has = Object.prototype.hasOwnProperty.call(unlockedMap, d.apiName);
             if (has) unlocked++;
             const pct = Number.isFinite(pctMap[d.apiName]) ? pctMap[d.apiName] : -1;
             const flags = (d.hidden ? 1 : 0) | (d.archived ? 2 : 0);
             return [d.apiName, d.name, has ? 1 : 0, has ? unlockedMap[d.apiName] : 0, pct, flags];
         });

         return {
             ok: true,
             appid: want,
             privacy,
             total: defs.length,                                 // 含 archived
             activeTotal: defs.length - archivedCount,           // 完成率分母
             archived: archivedCount,
             unlocked,
             items,
         };
     }

     // 汇总多款游戏 → KPI。unknown 单独计数，不进 unlocked / rate / perfect
    //
    // ⚠️ v2.44.0：分母口径收敛到 computeItemsStats()（与 analyze() 共用同一份真源）。
    //   历史问题：summarize() 与 analyze() 各自实现了一遍「从 items 重算分母、剔 archived」，
    //   两处同源却不同步 —— 改一处忘一处就会原样重现「KPI 说完美 6、完美墙上只有 0」。
    //   现在分母/分子/稀有度/未评级/通关日期全部收敛到一个纯函数，两处共用，不再各算一遍。
    function summarize(rows) {
        const out = { apps: 0, synced: 0, unknown: 0, defs: 0, unlocked: 0, perfect: 0, rare: 0, rareOwned: 0, unrated: 0, rate: 0, perfectApps: [] };
        if (!Array.isArray(rows)) return out;
        for (const r of rows) {
            if (!r || !Number.isFinite(Number(r.appid))) continue;
            out.apps++;
            if (r.privacy === 'unknown') { out.unknown++; continue; }
            out.synced++;
            const items = Array.isArray(r.items) ? r.items : [];
            const st = computeItemsStats(items);
            let active = st.active, unlocked = st.unlocked, allDone = st.allDone;
            if (!items.length) {
                // 老数据没有 items 明细：只能用存储字段兜底
                active = Math.max(0, Number(r.activeTotal) || 0);
                unlocked = Math.max(0, Number(r.unlocked) || 0);
                allDone = active > 0 && unlocked >= active;
            }
            out.defs += active;
            out.unlocked += unlocked;
            out.rare += st.rare;
            out.rareOwned += st.rareOwned;
            out.unrated += st.unrated;
            if (allDone && active > 0 && active >= ACH_WALL_MIN_ACTIVE) {
                out.perfect++;
                out.perfectApps.push({ appid: Number(r.appid), rare: st.rareOwned, hardest: st.rarestPct });
            }
        }
        out.rate = out.defs > 0 ? Math.round((out.unlocked / out.defs) * 100) : 0;
        out.perfectApps.sort((a, b) => (a.hardest - b.hardest) || (b.rare - a.rare));
        return out;
    }

    // ---- 单一分母口径（v2.44.0 新增）：KPI 与派生视图的唯一真源 ----
    // 分母 = 非 archived 的有效成就数；分子 = 其中已解锁数。
    // 绝不直接用 r.activeTotal / r.unlocked —— 那两个字段会把 archived 算进去
    // （老数据 / 快照导入），于是 KPI 说「完美 6」而完美墙上只有 0。
    // items 缺失的老数据由 summarize() / analyze() 各自回退到存储字段。
    function computeItemsStats(items) {
        const st = {
            active: 0, unlocked: 0, missing: 0, allDone: false,
            rare: 0, rareOwned: 0, unrated: 0,
            rarestPct: -1, rarestName: '', rarestUnlockAt: 0,
            completedAt: 0,
            buckets: Object.create(null), weighted: 0, ownedRated: 0,
        };
        for (const t of TIERS) st.buckets[t.key] = { key: t.key, total: 0, owned: 0 };
        if (!Array.isArray(items)) return st;
        for (const it of items) {
            if (!Array.isArray(it)) continue;
            if (((Number(it[5]) || 0) & 2) === 2) continue;   // archived 不进任何统计
            st.active++;
            const isUnlocked = it[2] === 1;
            const pct = numOrNull(it[4]);
            if (isUnlocked) {
                st.unlocked++;
                const at = Number(it[3]) || 0;
                // 通关日期 = 最后一个已解锁成就的解锁时间
                if (at > st.completedAt) st.completedAt = at;
            } else {
                st.missing++;
            }
            if (pct === null) {
                st.unrated++;                        // unknown ≠ 0：单列，不并进 common
                continue;
            }
            const tk = tierOf(pct);
            if (tk) {
                st.buckets[tk].total++;
                if (isUnlocked) st.buckets[tk].owned++;
            }
            if (pct < ACH_RARE_PCT) {
                st.rare++;
                if (isUnlocked) st.rareOwned++;
            }
            if (isUnlocked) {
                if (tk) { st.weighted += TIER_BY_KEY[tk].weight; st.ownedRated++; }
                if (st.rarestPct < 0 || pct < st.rarestPct) {
                    st.rarestPct = pct;
                    st.rarestName = String(it[1] || it[0]);
                    st.rarestUnlockAt = Number(it[3]) || 0;
                }
            }
        }
        st.allDone = st.active > 0 && st.unlocked >= st.active;
        return st;
    }

    // ---- 稀有度分桶（S3）：按全球完成率切五档 ----
    // 阈值语义是「上一档上界」，判定用 pct < max；pct 未知(-1) 返回 null，
    // 绝不并进 common（unknown ≠ 常见，否则稀有度分布会系统性偏高）。
    const TIERS = [
        { key: 'mythic',   max: 1,   weight: 50, label: '神话', labelEn: 'Mythic',   color: '#f43f5e' },
        { key: 'legend',   max: 5,   weight: 20, label: '传说', labelEn: 'Legend',   color: '#f59e0b' },
        { key: 'rare',     max: 20,  weight: 8,  label: '稀有', labelEn: 'Rare',     color: '#a855f7' },
        { key: 'uncommon', max: 50,  weight: 3,  label: '少见', labelEn: 'Uncommon', color: '#3b82f6' },
        { key: 'common',   max: 101, weight: 1,  label: '常见', labelEn: 'Common',   color: '#94a3b8' },
    ];
    const TIER_BY_KEY = TIERS.reduce((m, t) => { m[t.key] = t; return m; }, Object.create(null));

    function tierOf(pct) {
        // ⚠️ 必须走 numOrNull：Number(null) === 0，会把「未知」判成 mythic（<1%），
        //   即「全球完成率未知」被当成「全球 0% 拿到」的最稀有档。
        const v = numOrNull(pct);
        if (v === null) return null;
        for (const t of TIERS) { if (v < t.max) return t.key; }
        return 'common';
    }

    // 深度分析（S2 完美墙 / S3 收藏 / S4 缺口）：一次扫描出全部派生视图
    // nameOf: appid → 游戏名（名册在数据层，解析层不碰）
    function analyze(rows, nameOf) {
        const nameFn = typeof nameOf === 'function' ? nameOf : (id => 'App ' + id);
        const out = {
            games: [], perfect: [], nearPerfect: [], popularMissing: [], rarestOwned: [],
            buckets: Object.create(null), hunter: 0, weighted: 0, owned: 0,
            scanned: 0, unknown: 0,
            // v2.44.0 新增派生字段：未评级数 / 已通关款数 / 最近通关时间
            unrated: 0, completedGames: 0, lastCompletedAt: 0,
            privateGames: [], recentUnlocks: [],
        };
        for (const t of TIERS) out.buckets[t.key] = { key: t.key, total: 0, owned: 0 };
        if (!Array.isArray(rows)) return out;

        const ownedPool = [];      // 所有已解锁且 pct 已知的条目 → 「最稀有收藏」
        const missingPool = [];    // 所有未解锁且 pct ≥ 60 的条目 → 「大家都拿了你没拿」
        const recentPool = [];     // 所有已解锁且有解锁时间的条目 → 「最近解锁」（v2.44.0：真实时间，非合成时间）

        for (const r of rows) {
            if (!r || !Number.isFinite(Number(r.appid))) continue;
            out.scanned++;
            const appid = Number(r.appid);
            const gname = String(nameFn(appid) || ('App ' + appid));
            if (r.privacy === 'unknown') {
                // 私密：整款跳过，不参与任何派生统计，但【要记账】——
                // v2.44.0 左栏新增「成就私密」导航项，用户需要知道有多少款是私密的。
                out.unknown++;
                out.privateGames.push({ appid: appid, name: gname });
                continue;
            }
            const items = Array.isArray(r.items) ? r.items : [];

            // ⚠️ 分母/分子/稀有度/未评级/通关日期 —— 一律走单一口径（与 summarize() 共用）
            //   两处各算一遍是历史上「KPI 说完美 6、完美墙上只有 0」那个 bug 的复发路径。
            const st = computeItemsStats(items);
            if (st.active <= 0) continue;

            // 分桶与猎手权重也从 st 取（避免同一份数据被算两遍、口径漂移）
            for (const t of TIERS) {
                out.buckets[t.key].total += st.buckets[t.key].total;
                out.buckets[t.key].owned += st.buckets[t.key].owned;
            }
            out.weighted += st.weighted;
            out.owned += st.ownedRated;
            out.unrated += st.unrated;

            // 两个池子要逐条明细（稀有收藏 / 缺口榜），仍走一次轻量扫描
            for (const it of items) {
                if (!Array.isArray(it)) continue;
                if (((Number(it[5]) || 0) & 2) === 2) continue;        // archived 不进分母
                const isU = it[2] === 1;
                const pct = numOrNull(it[4]);
                const achName = String(it[1] || it[0]);
                if (isU) {
                    const at = Number(it[3]) || 0;
                    if (at > 0) recentPool.push({ appid: appid, game: gname, ach: achName, at: at, pct: pct === null ? -1 : pct });
                    if (pct !== null && pct < 100) ownedPool.push({ appid, game: gname, ach: achName, pct: pct, at: at });
                } else if (pct !== null && pct >= 60) {
                    missingPool.push({ appid, game: gname, ach: achName, pct: pct });
                }
            }

            const g = {
                appid, name: gname, active: st.active, unlocked: st.unlocked, missing: st.missing,
                rate: Math.round((st.unlocked / st.active) * 100),
                rarest: st.rarestPct, rarestName: st.rarestName, rarestUnlockAt: st.rarestUnlockAt,
                rare: st.rareOwned, unrated: st.unrated,
                completedAt: st.completedAt,          // 通关日期（ms，0 = 未解锁过任何成就）
            };
            if (g.completedAt > 0) {
                out.completedGames++;
                if (g.completedAt > out.lastCompletedAt) out.lastCompletedAt = g.completedAt;
            }
            out.games.push(g);
            const bigEnough = st.active >= ACH_WALL_MIN_ACTIVE;   // 小品游戏不上墙（见 ACH_WALL_MIN_ACTIVE 注释）
            if (bigEnough && st.missing === 0) out.perfect.push(g);
            else if (bigEnough && st.missing <= 2) out.nearPerfect.push(g);
        }

        // 完美墙：最难的那个成就越稀有越值钱。pct 未知(-1) 排最后，
        // 否则 -1 会小于任何真实百分比、被顶到榜首（unknown ≠ 最有价值）。
        const rarityKey = g => (g.rarest < 0 ? 999 : g.rarest);
        out.perfect.sort((a, b) => rarityKey(a) - rarityKey(b) || b.active - a.active);
        out.nearPerfect.sort((a, b) => a.missing - b.missing || rarityKey(a) - rarityKey(b));
        out.rarestOwned = ownedPool.sort((a, b) => a.pct - b.pct || b.at - a.at).slice(0, 40);
        out.recentUnlocks = recentPool.sort((a, b) => b.at - a.at).slice(0, 8);
        out.popularMissing = missingPool.sort((a, b) => b.pct - a.pct).slice(0, 40);
        // 猎手指数：加权解锁分 / 理论满分，开方压到 0~100。
        // 全「常见」≈14，全员「神话」=100 —— 用于横向比自己的收藏质量，不是绝对实力。
        out.hunter = out.owned > 0
            ? Math.min(100, Math.round(Math.sqrt(out.weighted / (out.owned * 50)) * 100))
            : 0;
        return out;
    }

    // 校验离线快照导入包（export-ach-seed.js 产出）。
    // 逐条容错而不是整体拒绝：5 万条里混进几条脏数据不该让整包白导。
    // items[i] = [apiName, name, unlocked(0/1), unlockAt(ms), pct(-1=缺), flags?]
    function validateSeed(payload) {
        if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
            return { ok: false, reason: 'not-object' };
        }
        if (Number(payload.v) !== 1) return { ok: false, reason: 'bad-version' };
        const list = payload.games;
        if (!Array.isArray(list)) return { ok: false, reason: 'no-games' };
        if (!list.length) return { ok: false, reason: 'empty-games' };

        const games = [];
        let droppedGames = 0, droppedItems = 0, totalItems = 0;
        for (const raw of list) {
            const appid = Number(raw && raw.appid);
            if (!Number.isFinite(appid) || appid <= 0) { droppedGames++; continue; }
            const src = raw && raw.items;
            if (!Array.isArray(src) || !src.length) { droppedGames++; continue; }

            const items = [];
            for (const it of src) {
                // 没有 apiName 的条目直接丢：它是成就的唯一稳定主键，
                // 用 internal_key 或名字顶替会在 schema 变更后对错行。
                if (!Array.isArray(it)) { droppedItems++; continue; }
                const apiName = typeof it[0] === 'string' ? it[0].trim() : '';
                if (!apiName) { droppedItems++; continue; }
                const name = typeof it[1] === 'string' && it[1].trim() ? it[1].trim() : apiName;
                const unlocked = Number(it[2]) === 1 ? 1 : 0;
                const unlockAt = toMs(it[3]);
                // pct 缺失必须落 -1（未知），不能落 0（0 是「几乎没人拿到」，语义完全不同）
                const pct = numOrNull(it[4]);
                items.push([apiName, name, unlocked, unlockAt, pct === null ? -1 : pct]);
            }
            if (!items.length) { droppedGames++; continue; }

            const privacy = raw.privacy === 'unknown' || raw.privacy === 'private' ? 'unknown' : 'public';
            games.push({ appid, privacy, items });
            totalItems += items.length;
        }
        if (!games.length) return { ok: false, reason: 'no-valid-game' };
        return { ok: true, games, totalItems, dropped: { games: droppedGames, items: droppedItems } };
    }

    // 存量迁移（v2.44.0）：把历史落库的【秒】值归一成【毫秒】。
    // 只在值落在「秒量级」(< 1e11) 时才乘 1000 —— 已是毫秒的值原样返回，迁移幂等。
    // 迁移脚本必须区分来源，**绝不能「一律乘 1000」**（会把已经正确的毫秒值再乘一次）。
    function normalizeItemsUnits(items) {
        if (!Array.isArray(items)) return { items: [], changed: 0 };
        const out = [];
        let changed = 0;
        for (const it of items) {
            if (!Array.isArray(it)) { out.push(it); continue; }
            const at = Number(it[3]) || 0;
            const ms = toMs(at);
            if (ms !== at) changed++;
            const copy = it.slice();
            copy[3] = ms;
            out.push(copy);
        }
        return { items: out, changed };
    }

    return { extractSsrJson, pickQueries, findQuery, kindMatches, parsePage, summarize, analyze, tierOf, TIERS, TIER_BY_KEY, validateSeed, computeItemsStats, numOrNull, toMs, normalizeItemsUnits };
})();

 // ---- 数据层：IDB 存储 + 候选筛选 + 限速抓取 ----
 const ACH_REAL = (function () {
     const DETAIL_PREFIX = nsKey('idb_achd') + '_';   // 每款一个 key：sglv_idb_achd_<appid>
     const INDEX_KEY = nsKey('idb_achi');             // { [appid]: [ts, activeTotal, unlocked, unknown] }
     const ATTEMPTS_KEY = nsKey('idb_acha');          // { [appid]: { count, ts } } — 失败重试计数（v2.44.0 落盘）
     const MIGRATED_KEY = nsKey('idb_achm');          // 单位迁移标记（v2.44.0）
     const MIN_PLAYTIME = 120;                        // 只抓玩满 2 小时的
     const PACE_MS = 1000;                            // 1 req/s（页面 0.5MB~2MB，不能更密）
     const BATCH_MAX = 120;                           // 每轮上限（约 2 分钟）
     const MAX_WALL_MS = 20 * 60 * 1000;              // 墙钟保护
     const MAX_ATTEMPTS = 3;                          // 单款失败上限，超了 24h 后再试

     let _running = false;
     let _abort = false;
     let _progress = null;
     let _ready = false;                               // IDB 内存镜像是否已 hydrate
     let _sumCache = null;
    let _deepCache = null;
     const _attempts = Object.create(null);           // appid → { count, ts }（内存镜像，v2.44.0 起同步落盘到 IDB）

     function idb() {
         // ⚠️ 必须用 sglvIDB（= C.IDB），不能用 _C。
         // _C 只在 window.SGLVCollection 模块 IIFE 里声明（收藏模块，主脚本 2906 行），
         // 主 IIFE 根本没有这个名字 —— 引用未声明标识符会抛 ReferenceError，
         // 被下面的 catch 吞掉 → idb() 恒为 null → 整个成就数据层静默失效：
         // 界面 KPI 全 0、同步完也不落盘（看起来像"浏览器禁用了 IndexedDB"，其实是作用域写错）。
         try { return sglvIDB || null; } catch (e) { return null; }
     }

    // ====== IndexedDB 可用性探测（真探一次，不看 API 在不在）========
    // 为什么必须探：core lib 即使浏览器禁用了 IndexedDB 也会照样暴露 set/loadAll
    //（内部降级成纯内存镜像），只判断「函数存不存在」→ 判定恒为 true，红字告警等于没有；
    // 反过来按「函数不在」判 → 恒为 false，任何浏览器都会误报「浏览器禁用了 IndexedDB」。
    // 这里开一个临时库做一次真实写→读，再删掉：能走通才算缓存可持久化。
    let _persistState = null;      // null=未知 / true=可持久化 / false=浏览器禁用
    let _persistProbe = null;
    function _idbFactory() {
        try { if (typeof window !== 'undefined' && window && window.indexedDB) return window.indexedDB; } catch (e) { /* ignore */ }
        try { if (typeof indexedDB !== 'undefined' && indexedDB) return indexedDB; } catch (e) { /* ignore */ }
        return null;
    }
    function persistState() { return _persistState; }
    function probePersist() {
        if (_persistProbe) return _persistProbe;
        const DB = '__sglv_idb_probe__';
        _persistProbe = new Promise(resolve => {
            let settled = false;
            const finish = ok => {
                if (settled) return;
                settled = true;
                _persistState = !!ok;
                try { const f = _idbFactory(); if (f) f.deleteDatabase(DB); } catch (e) { /* ignore */ }
                resolve(_persistState);
            };
            try {
                const f = _idbFactory();
                if (!f) { finish(false); return; }
                const req = f.open(DB, 1);
                req.onupgradeneeded = e => { try { e.target.result.createObjectStore('p'); } catch (err) { /* ignore */ } };
                req.onsuccess = e => {
                    let db = null;
                    try {
                        db = e.target.result;
                        const tx = db.transaction('p', 'readwrite');
                        tx.objectStore('p').put(1, 'k');
                        tx.oncomplete = () => { try { db.close(); } catch (err) { } finish(true); };
                        tx.onerror = () => { try { db.close(); } catch (err) { } finish(false); };
                        tx.onabort = () => { try { db.close(); } catch (err) { } finish(false); };
                    } catch (err) { try { if (db) db.close(); } catch (e2) { } finish(false); }
                };
                req.onerror = () => finish(false);
                req.onblocked = () => finish(false);
                setTimeout(() => finish(false), 5000);
            } catch (e) { finish(false); }
        });
        return _persistProbe;
    }

     function readIndex() {
         const db = idb();
         if (!db) return Object.create(null);
         try {
             const v = db.get(INDEX_KEY, null);
             return (v && typeof v === 'object') ? v : Object.create(null);
         } catch (e) { return Object.create(null); }
     }

     function readDetail(appid) {
         const db = idb();
         if (!db) return null;
         try {
             const v = db.get(DETAIL_PREFIX + Number(appid), null);
             if (!v || typeof v !== 'object') return null;
             if (Number(v.appid) !== Number(appid)) return null;
             return v;
         } catch (e) { return null; }
     }

    // 明细 key → appid 列表。以 IDB 里真实存在的明细键为准（而不是索引），
    // 这样即使索引那一条写入被防抖丢掉，已抓到的游戏也照样能被读到、不会再重抓。
     function detailKeyList() {
         const db = idb();
         if (!db) return [];
         const out = [];
         try {
             if (typeof db.keys === 'function') {
                 for (const k of db.keys()) {
                     if (typeof k !== 'string') continue;
                     if (k.indexOf(DETAIL_PREFIX) !== 0) continue;
                     const id = k.slice(DETAIL_PREFIX.length);
                     if (id) out.push(id);
                 }
                 if (out.length) return out;
             }
         } catch (e) { /* 忽略，走索引兜底 */ }
         try { return Object.keys(readIndex()); } catch (e) { return []; }
     }

    // 索引写入是 O(n²)（每款重写一次整表），而且底层 IDB.set 对同一个 key 有
    // 「上一笔事务没结束就丢弃本次写入」的防抖。所以改成：内存里同步更新，
    // 落盘节流合并；即使某次落盘被丢，下一次（或批次结束）也会补上。
     let _idxTimer = null;
     function flushIndex() {
         _idxTimer = null;
         // 未 hydrate 前 readIndex() 是空对象，这时候落盘会把已有索引整个冲掉
         if (!_ready) return;
         const db = idb();
         if (!db) return;
         try { db.set(INDEX_KEY, readIndex()); } catch (e) { /* ignore */ }
     }
     function scheduleIndexFlush() {
         if (_idxTimer) return;
         _idxTimer = setTimeout(flushIndex, 1200);
     }
     function touchIndex(appid, row) {
         if (!_ready) return;
         const db = idb();
         if (!db) return;
         let idx;
         try { idx = db.get(INDEX_KEY, null); } catch (e) { return; }
         if (!idx || typeof idx !== 'object') {
             idx = Object.create(null);
             // 必须先落到内存镜像上，下面才是在同一个对象上追加
             try { db.set(INDEX_KEY, idx); } catch (e) { return; }
         }
         idx[String(appid)] = [
             row.ts || Date.now(),
             row.activeTotal || 0,
             row.unlocked || 0,
             row.privacy === 'unknown' ? 1 : 0,
         ];
         scheduleIndexFlush();
     }

     // ---- 失败重试计数落盘（v2.44.0）----
    // 历史上 _attempts 只在内存里，刷新页面即清 →「连续失败 3 次则 24h 内不再试」
    // 这条规则跨页面完全失效，每次刷新都会把之前失败过的款重打一遍。
    // 现在把计数写进 IDB，页面重开后依然生效。
    let _attemptsTimer = null;
    function flushAttempts() {
        _attemptsTimer = null;
        if (!_ready) return;
        const db = idb();
        if (!db) return;
        try { db.set(ATTEMPTS_KEY, _attempts); } catch (e) { /* ignore */ }
    }
    function scheduleAttemptsFlush() {
        if (_attemptsTimer) return;
        _attemptsTimer = setTimeout(flushAttempts, 1200);
    }
    function hydrateAttempts() {
        const db = idb();
        if (!db) return;
        try {
            const v = db.get(ATTEMPTS_KEY, null);
            if (v && typeof v === 'object') {
                for (const k of Object.keys(v)) {
                    const a = v[k];
                    if (a && Number.isFinite(Number(a.count))) {
                        _attempts[k] = { count: Number(a.count) || 0, ts: Number(a.ts) || 0 };
                    }
                }
            }
        } catch (e) { /* ignore */ }
    }

    // ---- 存量单位迁移（v2.44.0）：把历史落库的【秒】归一成【毫秒】----
    // 背景：parsePage 曾把 Steam 的 unlock_time（秒）原样写进 items[3]，
    // 而快照导入路径写的是毫秒 —— 同一份 IDB 里混存两种单位。
    // UI 一律按毫秒消费 → 实时抓来的成就日期显示 1970-01-22、相对时间「20736天前」。
    // 修法：按【量级】判别（< 1e11 = 秒），已是毫秒的原样保留 —— 迁移幂等，不碰正确数据。
    // ⚠️ 绝不能「一律乘 1000」：那会把已经正确的毫秒值再乘一次。
    function migrateLegacyUnits(force) {
        const db = idb();
        if (!db) return { ok: false, reason: 'no-idb' };
        if (!force) {
            try {
                if (db.get(MIGRATED_KEY, null)) {
                    return { ok: true, skipped: true, scanned: 0, changedGames: 0, changedItems: 0 };
                }
            } catch (e) { /* ignore */ }
        }
        let changedGames = 0, changedItems = 0, scanned = 0;
        for (const key of detailKeyList()) {
            const appid = Number(key);
            if (!Number.isFinite(appid) || appid <= 0) continue;
            const row = readDetail(appid);
            if (!row || !Array.isArray(row.items) || !row.items.length) continue;
            scanned++;
            const res = ACH_PARSE.normalizeItemsUnits(row.items);
            if (!res.changed) continue;
            changedItems += res.changed;
            changedGames++;
            try {
                row.items = res.items;
                db.set(DETAIL_PREFIX + appid, row);
            } catch (e) { /* ignore */ }
        }
        try { db.set(MIGRATED_KEY, { at: Date.now(), changedGames, changedItems }); } catch (e) { /* ignore */ }
        _sumCache = null;
        _deepCache = null;
        return { ok: true, skipped: false, scanned, changedGames, changedItems };
    }

    function writeDetail(row) {
         const db = idb();
         if (!db || !row) return;
         try {
             // 先写明细：明细是唯一数据源，索引只是「别再重抓」的加速表。
             // 逐款立即写，关闭浮窗/中断时已抓到的一条都不会丢。
             db.set(DETAIL_PREFIX + Number(row.appid), row);
             touchIndex(row.appid, row);
            _sumCache = null;
            _deepCache = null;
         } catch (e) { /* IDB 写失败不影响主流程 */ }
     }

    // 页面被关闭 / 切到后台前把索引合并落盘（明细已逐款写过了）
     try {
         if (typeof window !== 'undefined' && window.addEventListener) {
             window.addEventListener('pagehide', flushIndex);
         }
         if (typeof document !== 'undefined' && document.addEventListener) {
             document.addEventListener('visibilitychange', () => {
                 try { if (document.visibilityState === 'hidden') flushIndex(); } catch (e) { /* ignore */ }
             });
         }
     } catch (e) { /* ignore */ }

     function detailRows() {
         const rows = [];
         for (const k of detailKeyList()) {
             const r = readDetail(k);
             if (r) rows.push(r);
         }
         return rows;
     }

    // 汇总（带内存缓存，写库时失效）
    function summary(force) {
        if (_sumCache && !force) return _sumCache;
        _sumCache = ACH_PARSE.summarize(detailRows());
        return _sumCache;
    }

    // 深度分析（完美墙 / 稀有收藏 / 缺口）。同样缓存：一次遍历 800 款约 5 万条，
    // 每次切标签都重算会明显卡顿。缓存与 summary 共用失效点。
    function deep(force) {
        if (_deepCache && !force) return _deepCache;
        const nameMap = Object.create(null);
        try {
            for (const t of targets()) nameMap[t.appid] = t.name;
        } catch (e) { /* 名册取不到就用 App <id> 兜底 */ }
        _deepCache = ACH_PARSE.analyze(detailRows(), id => nameMap[id]);
        return _deepCache;
    }

     // 目标集：玩满 2 小时的游戏（按游玩时长降序，核心游戏优先）
     // getStatFilteredGames 自身有缓存 → 用引用比较做二级缓存，避免每次渲染重排 8000 条
     let _targetsSrc = null;
     let _targetsCache = null;
     function targets() {
         let games = [];
         try { games = (typeof getStatFilteredGames === 'function') ? (getStatFilteredGames() || []) : []; } catch (e) { games = []; }
         if (games === _targetsSrc && _targetsCache) return _targetsCache;
         const out = [];
         for (const g of games) {
             const appid = Number(g && g.appid);
             if (!appid) continue;
             const mins = Number(g.playtime) || 0;
             if (mins < MIN_PLAYTIME) continue;
             out.push({ appid, name: String(g.name || ('App ' + appid)), playtime: mins });
         }
         out.sort((a, b) => b.playtime - a.playtime);
         _targetsSrc = games;
         _targetsCache = out;
         return out;
     }

     // 待抓：只包含从没同步过的游戏。已落库的条目永不过期（缓存只增不减），
     // 这样首屏一律先走缓存，只有补新游戏时才发请求。
     function pending() {
         const now = Date.now();
         const out = [];
         for (const t of targets()) {
             if (readDetail(t.appid)) continue;           // 有缓存就直接用，不再按时间重抓
             const a = _attempts[t.appid];
             if (a && a.count >= MAX_ATTEMPTS && (now - a.ts) < 864e5) continue;
             out.push(t);
         }
         return out;
     }

     function isRunning() { return _running; }
     function progress() { return _progress; }
     function stop() { _abort = true; }

     // 确保 IDB 内存镜像已 hydrate（幂等）。若早于启动时序调用，
     // 读索引会拿到空对象 → 随后的读-改-写会把已有索引覆盖掉，所以写前必须等这一步。
     async function ensureReady() {
         if (_ready) return true;
         const db = idb();
         if (!db || typeof db.loadAll !== 'function') return false;
         try {
            await db.loadAll();
            _ready = true;
            // hydrate 之后**必须**让派生缓存失效：
            // 首屏通常在 loadAll 完成之前就渲染过，那时 summarize()/analyze() 读到的是
            // 「镜像还是空的」的快照，并把它缓存了下来。不失效的话，后续每一次渲染都会
            // 命中这份空快照 —— 表现为「IDB 里明明有数据，面板却一直空白 / KPI 全 0」。
            _sumCache = null;
            _deepCache = null;
            // v2.44.0：hydrate 之后补两件事 ——
            //   ① 恢复失败重试计数（原先只在内存，刷新即清 → 「24h 内不再试」跨页面失效）
            //   ② 一次性把历史落库的【秒】归一成【毫秒】（有标记，只跑一次）
            try { hydrateAttempts(); } catch (e) { /* ignore */ }
            try { migrateLegacyUnits(false); } catch (e) { /* ignore */ }
            return true;
        } catch (e) { return false; }
     }
     function isReady() { return _ready; }

     function sleep(ms) { return new Promise(res => setTimeout(res, ms)); }

     function isCommunityHost() {
         try { return /(^|\.)steamcommunity\.com$/i.test(location.hostname); } catch (e) { return false; }
     }

     function pageUrl(appid, steamid) {
         return 'https://steamcommunity.com/profiles/' + encodeURIComponent(String(steamid)) +
             '/achievements/' + encodeURIComponent(String(appid)) + '?l=schinese';
     }

     // 同源通道：带 cookie、无 CORS，最快
     function fetchSameOrigin(url) {
         const ctrl = (typeof AbortController === 'function') ? new AbortController() : null;
         let timer = null;
         const timeout = new Promise((_, reject) => {
             timer = setTimeout(() => {
                 try { if (ctrl) ctrl.abort(); } catch (e) { /* ignore */ }
                 reject(new Error('timeout'));
             }, 30000);
         });
         const req = fetch(url, { credentials: 'include', signal: ctrl ? ctrl.signal : undefined })
             .then(resp => {
                 if (!resp.ok) {
                     const err = new Error('HTTP ' + resp.status);
                     err.status = resp.status;
                     throw err;
                 }
                 return resp.text();
             });
         return Promise.race([req, timeout]).finally(() => { if (timer) clearTimeout(timer); });
     }

     // 跨域通道（商店域）：走库里的 gmFetchText，已内置 429/5xx 退避
     function fetchCrossOrigin(url) {
         // 同 idb()：跨域抓取走主 IIFE 的 C（SGLVCore），不能用收藏模块里的 _C
         const fn = (C && typeof C.gmFetchText === 'function') ? C.gmFetchText : null;
         if (!fn) return Promise.reject(new Error('no-gm-fetch'));
         return Promise.resolve(fn(url, { timeout: 30000, retries: 1 }));
     }

     function fetchPage(appid, steamid) {
         const url = pageUrl(appid, steamid);
         return isCommunityHost() ? fetchSameOrigin(url) : fetchCrossOrigin(url);
     }

     async function syncOne(appid, steamid) {
         const html = await fetchPage(appid, steamid);
         const parsed = ACH_PARSE.parsePage(html, appid);
         if (!parsed.ok) return parsed;
         const row = {
             appid: parsed.appid,
             ts: Date.now(),
             privacy: parsed.privacy,
             total: parsed.total,
             activeTotal: parsed.activeTotal,
             archived: parsed.archived,
             unlocked: parsed.unlocked,
             items: parsed.items,
         };
         writeDetail(row);
         return { ok: true, row };
     }

     // 主循环：串行 + 限速 + 429 长退避 + 墙钟保护
     async function run(opts) {
         const cfg = opts || {};
         const onProgress = typeof cfg.onProgress === 'function' ? cfg.onProgress : null;
         const limit = Math.max(1, Math.min(BATCH_MAX, Number(cfg.limit) || BATCH_MAX));
         if (_running) return { skipped: true, running: true };
         // 同步占锁必须放在**第一个 await 之前**：否则两个入口（自动 kick + 手动点按钮）
         // 会同时通过上面的检查，各抓一轮，请求直接翻倍。
         _running = true;
         _abort = false;
         try {
             let steamid = '';
             try { steamid = (typeof getActiveSteamId === 'function') ? String(getActiveSteamId() || '') : ''; } catch (e) { steamid = ''; }
             if (!steamid) return { error: 'no-steamid' };

            await ensureReady();   // 写前必须保证索引已从 IDB 载入，否则会覆盖掉已有索引
            _sumCache = null;
            _deepCache = null;
             const list = pending().slice(0, limit);
             if (!list.length) return { done: 0, total: 0, ok: 0, fail: 0, private: 0, empty: true };

             const started = Date.now();
             let ok = 0, fail = 0, priv = 0, done = 0;
             _progress = { done: 0, total: list.length, ok: 0, fail: 0, private: 0 };

             for (const item of list) {
                 if (_abort) break;
                 if (Date.now() - started > MAX_WALL_MS) break;
                 let backoff = 0;
                 try {
                     const r = await syncOne(item.appid, steamid);
                     if (!r || !r.ok) throw new Error((r && r.reason) || 'parse-failed');
                     if (r.row.privacy === 'unknown') priv++; else ok++;
                     delete _attempts[item.appid];
                     scheduleAttemptsFlush();     // v2.44.0：重试计数落盘，刷新后「24h 内不再试」仍生效
                 } catch (e) {
                     fail++;
                     const status = Number(e && e.status);
                     const a = _attempts[item.appid] || { count: 0, ts: 0 };
                     a.count++; a.ts = Date.now();
                     _attempts[item.appid] = a;
                     scheduleAttemptsFlush();     // v2.44.0：重试计数落盘
                     if (status === 429 || status === 403) {
                         // 限流：长退避后继续，且不计入失败配额（这是整站级，不是这一款的问题）
                         fail--;
                         a.count--;
                         backoff = 60000 + Math.floor(Math.random() * 60000);
                     }
                 }
                 done++;
                 _progress = { done, total: list.length, ok, fail, private: priv };
                 if (onProgress) { try { onProgress(_progress, item); } catch (e) { /* 回调异常不影响抓取 */ } }
                 await sleep(PACE_MS + backoff);
             }
                     _sumCache = null;
            _deepCache = null;
            return { done, total: list.length, ok, fail, private: priv, aborted: _abort };
         } finally {
             // 批次结束（正常结束 / 中断 / 异常）都补一次索引落盘，
             // 下一次进来只补没抓过的游戏，不会从 0 重来
             try { flushIndex(); } catch (e) { /* ignore */ }
             _progress = null;
             _running = false;
         }
     }

    // 批量导入快照（跳过冷启动）。与 writeDetail 的区别：索引只写一次。
    // 逐款写索引是 O(n²) —— 851 款 × 每款重写 40KB 索引对象，白扔 30MB 写入。
    async function importSeed(payload, opts) {
        const cfg = opts || {};
        const v = ACH_PARSE.validateSeed(payload);
        if (!v.ok) return { error: v.reason };
        const db = idb();
        if (!db) return { error: 'no-idb' };
        // 写前必须 hydrate：否则 readIndex() 拿到空对象，最后一次性写回会把已有索引整个冲掉
        await ensureReady();
        const now = Date.now();
        const idx = readIndex();
        let imported = 0, fail = 0, unlocked = 0, items = 0;
        for (const g of v.games) {
            let done = 0;
            for (const it of g.items) if (it[2] === 1) done++;
            const row = {
                appid: g.appid,
                ts: now,
                privacy: g.privacy,
                total: g.items.length,
                activeTotal: g.items.length,   // 快照里没有 archived 信息，按全部可完成算
                archived: 0,
                unlocked: done,
                items: g.items,
                seed: cfg.markSeed === false ? undefined : 1,
            };
            try {
                db.set(DETAIL_PREFIX + g.appid, row);
                idx[String(g.appid)] = [now, row.activeTotal, done, g.privacy === 'unknown' ? 1 : 0];
                imported++;
                unlocked += done;
                items += g.items.length;
            } catch (e) { fail++; }
        }
        try { db.set(INDEX_KEY, idx); } catch (e) { return { error: 'index-write' }; }
        _sumCache = null;
        _deepCache = null;
        return { imported, fail, unlocked, items, dropped: v.dropped };
    }

    // 危险操作：清空全部成就缓存（UI 里需二次确认）
    function clearAll() {
         const db = idb();
         if (!db) return 0;
         // 以真实存在的明细键为准，连索引里漏记的孤儿明细一起清掉
         const keys = detailKeyList();
         for (const k of keys) {
             try { db.remove(DETAIL_PREFIX + Number(k)); } catch (e) { /* ignore */ }
         }
         try { db.set(INDEX_KEY, {}); } catch (e) { /* ignore */ }
         scheduleIndexFlush();
         _sumCache = null;
         _deepCache = null;
         return keys.length;
     }

     return {
        summary, deep, targets, pending, run, stop, isRunning, progress, clearAll,
        importSeed, readDetail, isCommunityHost, isReady, ready: ensureReady, MIN_PLAYTIME,
        persistState, probePersist,
        // v2.44.0：存量单位迁移（秒→毫秒，手动可强制重跑）+ 明细导出（备份用）
        migrateLegacyUnits, detailRows,
         get targetCount() { try { return targets().length; } catch (e) { return 0; } },
         get pendingCount() { try { return pending().length; } catch (e) { return 0; } },
     };
 })();

 // ==================== ACH-S1-END ====================

 // ==================== 我的成就 — 全新质感炫彩 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>`,
    };

 //成就稀有度元数据
    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' },
    };

 //成就分类元数据 (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)' },
    ];

 //成就定义 — 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' },
    ];

 //成就解锁缓存 key (GM_setValue 持久化)
    const _ACH_CACHE_KEY = 'sglv_ach_unlocks_v2';

 //读取已解锁成就缓存 { 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 {};
        }
    }

 //写入已解锁成就缓存 (新增解锁时追加时间戳)
    function _saveAchUnlockCache(cache) {
        try {
            GM_setValue(_ACH_CACHE_KEY, JSON.stringify(cache));
        } catch (e) { /* 静默失败 */ }
    }

 //统一计算成就指标 — 一次遍历，所有 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,
        };
    }

 //计算用户成就数据 — 统一 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;
    }

 //格式化解锁时间
    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}`;
    }

 //格式化相对时间 (如 "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`;
    }

 // ==================== 我的成就标签页 — 左右布局重构 ====================
 //computeMyAchievementsCached — 走 PCC 持久化,跨 session 复用
 //降级为组装器——数据组装 + 三段渲染器按文档序消费 + 事件绑定内联
 // (用户卡/分类导航/最近解锁 → 侧边栏段; 环形进度+KPI+重置 → 头部段; 单张成就 → 卡片段)

 //成就侧边栏段（用户卡 + 分类导航 + 最近解锁,自 renderMyAchievementsTab 拆出,纯搬移）
    // 稀有度取色（v2.44.0）：侧栏「最近解锁」圆点、矩阵行徽章共用
    function _achTierColor(pct) {
        const v = ACH_PARSE.numOrNull(pct);
        if (v === null) return '#6e7681';   // unknown ≠ 最稀有
        const t = ACH_PARSE.tierOf(v);
        const tier = t ? ACH_PARSE.TIER_BY_KEY[t] : null;
        return tier ? tier.color : '#6e7681';
    }

    //成就侧边栏（v2.44.0 语义反转）
    // 旧版：整个左栏都是【自定义成就】的产物（用户卡 + Lv + 积分 + 6 分类导航 + 最近解锁），
    //       真实成就一条都进不来 —— 合成指标占据了主角位。
    // 现在：左栏 100% 由 Steam 真实成就派生 —— 游戏维度导航 + 真实最近解锁；
    //       自定义成就降级为底部徽章架，不再占据导航与首屏。
    function _achSidebarHtml(view, counts, recent) {
        const items = [
            { id: 'all',      icon: ICONS.achievement, label: isZh ? '全部已同步' : 'All synced', n: counts.synced },
            { id: 'perfect',  icon: ICONS.trophy,      label: isZh ? '完美通关' : 'Perfect',      n: counts.perfect },
            { id: 'rare',     icon: ICONS.gift,        label: isZh ? '稀有收藏' : 'Rare',         n: counts.rare },
            { id: 'gap',      icon: ICONS.barChart,   label: isZh ? '待补缺口' : 'Gaps',         n: counts.gap },
            { id: 'private',  icon: ICONS.shield,     label: isZh ? '成就私密' : 'Private',      n: counts.private },
            { id: 'unsynced', icon: ICONS.clock,      label: isZh ? '未同步' : 'Not synced',    n: counts.unsynced },
        ];
        const navItems = items.map(it => `<div class="sglv-ach-nav-item ${view === it.id ? 'active' : ''}" data-achnav="${it.id}">
                <div class="sglv-ach-nav-item-icon">${it.icon}</div>
                <span class="sglv-ach-nav-item-name">${it.label}</span>
                <span class="sglv-ach-nav-item-badge ${it.n > 0 ? 'partial' : 'none'}">${it.n}</span>
            </div>`).join('');

        const recentHtml = (recent && recent.length)
            ? recent.slice(0, 6).map(r => `<div class="sglv-ach-sidebar-recent-item" data-achgame="${r.appid}" title="${escHtml(r.game)} · ${escHtml(r.ach)}">
                <span class="sglv-ach-sidebar-recent-dot" style="background:${_achTierColor(r.pct)}"></span>
                <div class="sglv-ach-sidebar-recent-info">
                    <div class="sglv-ach-sidebar-recent-name">${escHtml(r.ach)}</div>
                    <div class="sglv-ach-sidebar-recent-time">${escHtml(r.game)} · ${_formatRelTime(r.at)}</div>
                </div>
            </div>`).join('')
            : `<div class="sglv-ach-sidebar-recent-empty">${isZh ? '还没有解锁记录' : 'No unlocks yet'}</div>`;

        return `
                <!-- ====== 左侧边栏（v2.44.0：游戏维度导航，全部来自 Steam 真实成就） ====== -->
                <div class="sglv-ach-sidebar">
                    <div class="sglv-ach-sidebar-header">
                        <div class="sglv-ach-sidebar-title">
                            ${ICONS.achievement}
                            <span>${T.tabAchievements}</span>
                        </div>
                    </div>
                    <div class="sglv-ach-nav">
                        <div class="sglv-ach-nav-label">${isZh ? '按游戏浏览' : 'Browse by game'}</div>
                        ${navItems}
                    </div>
                    <div class="sglv-ach-sidebar-recent">
                        <div class="sglv-ach-sidebar-recent-label">${isZh ? '最近解锁' : 'Recent unlocks'}</div>
                        ${recentHtml}
                    </div>
                </div>`;
    }

 //成就头部（v2.44.0）：Hero 总览 —— 全部走 Steam 真实口径
    // 旧版是「综合成就指数 = 自定义×60% + Steam×40%」，两侧量纲不可比（自定义稀有是点数完成率、
    // Steam 稀有是猎手指数），加权相加没有物理意义；而且让合成的指标以 3:2 压过真实数据。
    // 现在大环直接显示 Steam 真实完成率，KPI 全部来自 ACH_REAL.summary()，
    // 可与 Steam 官方成就页逐条核对。
    function _achHeaderHtml(p) {
        const x = p || {};
        const n = (v) => Math.max(0, Math.min(100, Math.round(Number(v) || 0)));
        const rate = n(x.steamRate);
        const ringR = 38;
        const ringCirc = 2 * Math.PI * ringR;
        const ringOffset = ringCirc * (1 - rate / 100);
        const tip = isZh
            ? 'Steam 成就完成率 = 已解锁成就数 ÷ 已同步游戏的有效成就总数（已剔除 archived）。可与 Steam 官方成就页逐条核对。'
            : 'Steam completion rate = unlocked / effective achievements across synced games.';
        const card = (color, label, valueHtml, sub, dataKey) => `<div class="sglv-playtime-kpi-card ${color}">
            <div class="sglv-playtime-kpi-header"><span class="sglv-playtime-kpi-label">${escHtml(label)}</span></div>
            <div class="sglv-playtime-kpi-value"${dataKey ? ` data-achkpi="${dataKey}"` : ''}>${valueHtml}</div>
            <div class="sglv-playtime-kpi-sub">${escHtml(sub)}</div>
        </div>`;
        const strip = (label, key, val) => `<div class="sglv-ach-hero-item"><span class="lbl">${escHtml(label)}</span><span class="val" data-achkpi="${key}">${escHtml(val)}</span></div>`;
        const unlockedHtml = `<span data-achkpi="unlocked">${x.unlocked}</span><small>/<span data-achkpi="defs">${x.defs}</span></small>`;
        return `
                    <div class="sglv-ach-header sglv-ach-header-v2">
                        <div class="sglv-ach-hero-top">
                            <div class="sglv-ach-ring-wrap" title="${escHtml(tip)}">
                                <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" data-achidx="ring">${rate}%</div>
                                    <div class="sglv-ach-ring-label">${isZh ? 'Steam 完成率' : 'Steam Rate'}</div>
                                </div>
                            </div>
                            <div class="sglv-ach-kpi-row sglv-ach-kpi-row-6">
                                ${card('cyan', isZh ? '已同步游戏' : 'Synced', String(x.synced), isZh ? '真实成就已入库' : 'cached', 'synced')}
                                ${card('', isZh ? '已解锁成就' : 'Unlocked', unlockedHtml, isZh ? '已剔除 archived' : 'archived excluded')}
                                ${card('gold', isZh ? '完成率' : 'Rate', `${rate}%`, isZh ? 'Steam 真实口径' : 'real rate', 'ratePct')}
                                ${card('green', isZh ? '完美通关' : 'Perfect', String(x.perfectN), isZh ? '全部成就解锁' : 'all unlocked', 'perfect')}
                                ${card('violet', isZh ? '稀有成就' : 'Rare', String(x.rareOwned), isZh ? `全球 <${ACH_RARE_PCT}%` : `global <${ACH_RARE_PCT}%`, 'rare')}
                                ${card('purple', isZh ? '已通关游戏' : 'Completed', String(x.completedGames), isZh ? '有解锁记录' : 'with unlocks', 'completed')}
                            </div>
                        </div>
                        <div class="sglv-ach-hero-strip">
                            ${strip(isZh ? '最近解锁' : 'Latest', 'recent', '—')}
                            ${strip(isZh ? '最近通关' : 'Last cleared', 'lastDone', '—')}
                            ${strip(isZh ? '猎手指数' : 'Hunter', 'hunter', String(x.hunter || 0))}
                            ${strip(isZh ? '未评级成就' : 'Unrated', 'unrated', String(x.unrated || 0))}
                        </div>
                    </div>`;
    }

 // ==================== ACH-S2-BEGIN ====================
 // 真实成就 UI 段（KPI 区块 / 同步按钮 / 深度面板 / 详情弹窗）
 // 同样被 build-preview.js 原样抽取；这一段不依赖 T / ICONS，所以能脱离主脚本独立渲染
 //综合成就指数。自定义 60%、Steam 40%；每一侧里稀有与完美各占一半。
 // 自定义稀有 = 稀有/史诗/传说的点数完成率；自定义完美 = 全解锁分类占比。
 // Steam 稀有 = 猎手指数；Steam 完美 = 完美通关款数 / 已同步款数。
    function _achIndexParts(achievements, steamSummary, steamDeep) {
        const clamp = (v) => Math.max(0, Math.min(100, Math.round(Number(v) || 0)));
        const achs = Array.isArray(achievements) ? achievements : [];
        // ---- 自定义成就（弱化口径）：只喂底部徽章架，不再参与主指数 ----
        const rareRarity = { rare: 1, epic: 1, legendary: 1 };
        const cats = Object.create(null);
        let rarePts = 0, rareMax = 0;
        for (const a of achs) {
            if (!a) continue;
            const cat = a.cat || '_';
            if (!cats[cat]) cats[cat] = { n: 0, u: 0 };
            cats[cat].n++;
            if (a.unlocked) cats[cat].u++;
            if (rareRarity[a.rarity]) {
                const pts = Number(a.pts) || 0;
                rareMax += pts;
                if (a.unlocked) rarePts += pts;
            }
        }
        const catKeys = Object.keys(cats);
        const perfectCats = catKeys.filter(k => cats[k].n > 0 && cats[k].u === cats[k].n).length;
        const cPerfect = catKeys.length ? clamp(perfectCats / catKeys.length * 100) : 0;
        const cRare = rareMax > 0 ? clamp(rarePts / rareMax * 100) : 0;
        const custom = clamp(cPerfect * 0.5 + cRare * 0.5);

        // ---- Steam 真实成就（核心口径）----
        const s = steamSummary || {};
        const synced = Number(s.synced) || 0;
        const perfectN = Number(s.perfect) || 0;
        const sPerfect = synced > 0 ? clamp(perfectN / synced * 100) : 0;
        const sRare = clamp(steamDeep && steamDeep.hunter);
        const steam = clamp(sPerfect * 0.5 + sRare * 0.5);
        // ★ v2.44.0：主指数改为【Steam 真实完成率】
        //   旧口径 composite = 自定义×60% + Steam×40% —— 两侧量纲不可比（自定义稀有是点数完成率，
        //   Steam 稀有是猎手指数），加权相加没有物理意义；而且让合成的指标以 3:2 压过真实数据。
        //   新口径直接显示「已解锁 ÷ 已同步游戏的有效成就总数」，可与 Steam 官方成就页逐条核对。
        const steamRate = clamp(Number(s.rate) || 0);
        return {
            composite: steamRate,
            steamRate,
            custom, steam, cRare, cPerfect, sRare, sPerfect,
            rareBlend: clamp(cRare * 0.6 + sRare * 0.4),
            perfectBlend: clamp(cPerfect * 0.6 + sPerfect * 0.4),
            perfectCats, catCount: catKeys.length, perfectN, synced,
            // ★ 新增：真实口径的全量 KPI（供 Hero 区直接消费）
            unlocked: Number(s.unlocked) || 0,
            defs: Number(s.defs) || 0,
            unknown: Number(s.unknown) || 0,
            unrated: Number(s.unrated) || 0,
            rareOwned: Number(s.rareOwned) || 0,
            completedGames: (steamDeep && Number(steamDeep.completedGames)) || 0,
            lastCompletedAt: (steamDeep && Number(steamDeep.lastCompletedAt)) || 0,
            hunter: sRare,
        };
    }

    function _achPaintComposite(root) {
        if (!root || typeof root.querySelector !== 'function') return;
        let achs = [];
        try { if (typeof computeMyAchievementsCached === 'function') achs = computeMyAchievementsCached() || []; } catch (e) { achs = []; }
        let s = null, d = null;
        try { s = ACH_REAL.summary(); } catch (e) { s = null; }
        try { d = ACH_REAL.deep(); } catch (e) { d = null; }
        const p = _achIndexParts(achs, s, d);
        const put = (key, val) => {
            const el = root.querySelector('[data-achidx="' + key + '"]');
            if (el && el.textContent !== val) el.textContent = val;
        };
        // ★ v2.44.0：大环改显示 Steam 真实完成率（可与 Steam 官方成就页逐条核对）。
        //   旧口径 composite = 自定义×60% + Steam×40% 已下线（两侧量纲不可比）。
        put('ring', p.steamRate + '%');
        const ring = root.querySelector('.sglv-ach-ring-fill');
        if (ring && ring.setAttribute) {
            const circ = 2 * Math.PI * 38;
            ring.setAttribute('stroke-dashoffset', String(circ * (1 - p.steamRate / 100)));
        }
    }

 //真实成就区块（S1）— KPI + 覆盖率进度 + 同步按钮
 // 与「自定义成就」并列展示：前者是仓库指标换皮，后者是 Steam 真实解锁数据
    let _achRealAutoStarted = false;
    // 深面板：按内容指纹判断是否需要换 body（既不用重建 DOM，也不会无谓地动 DOM）。
    // _achDeepLastAt 只用于给「深分析」本身限频（扫全库成就要几千条，不能每秒重算）。
    let _achDeepLastAt = 0;

    // IndexedDB 探测：整个页面只跑一次。探测出「不可用」时刷新一次区块，把红字告警挂出来。
    // （探测前不显示告警 —— 宁可晚挂，也不误报"浏览器禁用了 IndexedDB"）
    let _achPersistProbeStarted = false;
    function _achPersistProbeOnce() {
        if (_achPersistProbeStarted) return;
        _achPersistProbeStarted = true;
        try {
            ACH_REAL.probePersist().then(ok => {
                if (!ok) { try { _achRealRefresh(document); } catch (e) { /* ignore */ } }
            });
        } catch (e) { /* ignore */ }
    }

    function _achRealBlockHtml() {
        _achPersistProbeOnce();
        const s = ACH_REAL.summary();
        const target = ACH_REAL.targetCount;
        const pend = ACH_REAL.pendingCount;
        const running = ACH_REAL.isRunning();
        const prog = ACH_REAL.progress();
        const ready = (typeof ACH_REAL.isReady === 'function') ? ACH_REAL.isReady() : true;
        // IndexedDB 可用性：null=尚未探测（不显示告警）/ true=可持久化 / false=浏览器禁用
        const persistState = (typeof ACH_REAL.persistState === 'function') ? ACH_REAL.persistState() : null;
        const covered = target > 0 ? Math.min(100, Math.round(((s.synced + s.unknown) / target) * 100)) : 0;
        const hours = Math.round(ACH_REAL.MIN_PLAYTIME / 60);
        const empty = s.synced === 0 && s.unknown === 0;
        const sub = target > 0
            ? (isZh ? `覆盖玩满 ${hours} 小时的 ${target} 款` : `${target} games with ${hours}h+ playtime`)
            : (isZh ? '请先获取游戏库' : 'Fetch library first');
        const btnText = running && prog
            ? (isZh ? `同步中 ${prog.done}/${prog.total}` : `${prog.done}/${prog.total}`)
            : (pend > 0
                ? (isZh ? `同步（待抓 ${pend}）` : `Sync (${pend})`)
                : (isZh ? '已是最新' : 'Up to date'));
        // 商店域不再禁用同步：跨域走 GM_xmlhttpRequest（默认携带 Steam 登录 cookie），结果写本域 IDB。
        // 个人主页同步的数据因 IDB 按 origin 隔离本来就读不到，所以两个域各自同步、各自成库。
        const crossOrigin = !ACH_REAL.isCommunityHost();
        const disabled = (target === 0 || running || pend === 0) ? 'disabled' : '';
        // 空态文案分三种：本地缓存还没读完 / 正在同步 / 真的没数据
        let emptyHint = '';
        if (empty) {
            if (running && prog) {
                emptyHint = isZh
                    ? `正在同步 ${prog.done}/${prog.total}：每抓到一款就写入本地缓存，上面的统计会立刻跟着涨。`
                    : `Syncing ${prog.done}/${prog.total}: each game is cached and reflected above immediately.`;
            } else if (!ready) {
                emptyHint = isZh
                    ? '正在读取本地成就缓存，已同步过的数据会直接显示，不需要重新抓取…'
                    : 'Loading local achievement cache — synced data shows up instantly.';
            } else {
                emptyHint = isZh
                    ? `还没有真实成就数据。点右侧按钮开始同步：每轮最多 120 款、约 2 分钟，全部 ${target} 款会在几次访问里陆续铺满。`
                    : 'No real achievement data yet. Click sync — up to 120 games per run, about 2 minutes.';
            }
        }
        return `
            <div class="sglv-ach-real">
                <div class="sglv-ach-real-head">
                    <div class="sglv-ach-real-title">
                        ${isZh ? '同步状态' : 'Sync status'}
                        <span class="sglv-ach-real-tag">STEAM</span>
                    </div>
                    <div class="sglv-ach-real-sub">${sub}</div>
                </div>
                ${empty ? `<div class="sglv-ach-real-hint ${(!ready || running) ? 'sglv-ach-real-loading' : ''}" style="margin:0 0 10px">${emptyHint}</div>` : ''}
                ${persistState === false ? `<div class="sglv-ach-real-hint" style="margin:0 0 10px;color:#fca5a5">${isZh
                    ? '本地缓存不可用（此浏览器禁用了 IndexedDB）：本次同步的数据不会保留，关闭页面后需重新抓取。'
                    : 'Local cache unavailable (IndexedDB blocked): synced data will not be kept.'}</div>` : ''}
                <div class="sglv-ach-real-bar"><div style="width:${covered}%"></div></div>
                <div class="sglv-ach-real-foot">
                    <div class="sglv-ach-real-hint">${`${isZh ? '已覆盖' : 'Covered'} <span data-achkpi="covered">${covered}</span>%${s.unknown > 0
                        ? (isZh ? ` · ${s.unknown} 款成就私密（不计入统计）` : ` · ${s.unknown} private (excluded)`)
                        : ''}`}${crossOrigin
                        ? (isZh ? ' · 跨域抓取社区成就页（需已登录 Steam）；商店页与个人主页的本地缓存各自独立' : ' · cross-origin fetch (Steam login required); store and profile keep separate caches')
                        : ''}</div>
                    <div class="sglv-ach-real-actions">
                        <input type="file" id="sglv-ach-real-seed-input" accept="application/json,.json" style="display:none">
                        <button class="sglv-ach-real-btn ghost" id="sglv-ach-real-seed" title="${isZh
                            ? '导入离线快照（sglv-ach-seed.json）：一次性灌入已有成就数据，免去逐款抓取的冷启动'
                            : 'Import offline seed (sglv-ach-seed.json): load existing achievement data at once'}">${isZh ? '导入快照' : 'Import'}</button>
                        <button class="sglv-ach-real-btn" id="sglv-ach-real-sync" ${disabled}>${btnText}</button>
                    </div>
                </div>
            </div>`;
    }

 //局部刷新真实成就区块（结构级重建：同步结束 / 导入快照后用）
 // 日常刷新一律走 _achRealPaint —— 就地改数字 + 按指纹换深面板 body，
 // 不再整块替换 DOM（整块替换会把滚动位置顶回顶部、并让事件反复重绑）。
    //局部刷新真实成就区块（结构级重建：同步结束 / 导入快照后用）
    // 日常刷新一律走 _achRealPaint —— 就地改数字 + 按指纹换深面板 body，
    // 不再整块替换 DOM（整块替换会把滚动位置顶回顶部、并让事件反复重绑）。
    // v2.44.0：realwrap 只装「同步状态条」；游戏矩阵与聚合分析各自独立刷新。
    function _achRealRefresh(scope) {
        const root = scope || document;
        const host = root.querySelector('#sglv-ach-realwrap') || root.querySelector('.sglv-ach-real');
        if (host) {
            const tpl = document.createElement('div');
            try {
                tpl.innerHTML = `<div class="sglv-ach-realwrap" id="sglv-ach-realwrap">${_achRealBlockHtml()}</div>`;
            } catch (e) {
                // 以前这里是静默 return —— 出错就什么都不更新，用户只看到"内容不加载"。
                // 现在明确打日志，否则线上出问题只能靠猜。
                console.warn('[SGLV] 真实成就区块重建失败', e);
            }
            const next = tpl.firstElementChild;
            if (next) {
                host.replaceWith(next);
                try { _achRealBind(next.parentElement || root); } catch (e) { /* ignore */ }
            }
        }
        // 同步结束后：游戏矩阵 + 聚合分析一起按新数据重算
        try { _achRefreshSubviews(root); } catch (e) { console.warn('[SGLV] 成就子视图刷新失败', e); }
        try { _achRealPaint(root); } catch (e) { console.warn('[SGLV] 真实成就局部刷新失败', e); }
    }

    // 同步结束 / 缓存 hydrate 后：按最新数据重算游戏矩阵、聚合分析与侧栏计数
    function _achRefreshSubviews(root) {
        if (!root || typeof root.querySelector !== 'function') return;
        let d = null, s = null;
        try { d = ACH_REAL.deep(); } catch (e) { d = null; }
        try { s = ACH_REAL.summary(); } catch (e) { s = null; }
        const navView = state.achNavView || 'all';

        const gamesBox = root.querySelector('[data-achsubview="games"]');
        if (gamesBox) {
            try { _achMatrixRefresh(root); }
            catch (e) { console.warn('[SGLV] 游戏成就矩阵刷新失败', e); }
        }
        const insightsBox = root.querySelector('[data-achsubview="insights"]');
        if (insightsBox) {
            try {
                insightsBox.innerHTML = _achDeepHtml();
                _achDeepBind(insightsBox);
            } catch (e) { console.warn('[SGLV] 聚合分析刷新失败', e); }
        }
        // 侧栏计数就地更新（不整块重建，免得滚动位置被顶回顶部）
        try {
            const counts = _achNavCounts(d, s);
            const map = {
                all: counts.synced, perfect: counts.perfect, rare: counts.rare,
                gap: counts.gap, private: counts.private, unsynced: counts.unsynced,
            };
            const sb = root.querySelector('.sglv-ach-sidebar');
            if (sb) {
                sb.querySelectorAll('[data-achnav]').forEach(el => {
                    const n = map[el.dataset.achnav];
                    if (typeof n !== 'number') return;
                    const b = el.querySelector('.sglv-ach-nav-item-badge');
                    if (!b) return;
                    if (b.textContent !== String(n)) b.textContent = String(n);
                    b.className = 'sglv-ach-nav-item-badge ' + (n > 0 ? 'partial' : 'none');
                });
            }
        } catch (e) { /* ignore */ }
    }

    // 深面板指纹：这些派生量全不变 → 内容必然不变 → 不需要碰 DOM
    function _achDeepFingerprint(d) {
        if (!d) return 'null';
        return [d.scanned, d.owned, d.perfect.length, d.nearPerfect.length,
            d.popularMissing.length, d.rarestOwned.length, d.hunter].join('|');
    }

 //渐进式刷新：每抓到一款就地更新 KPI / 覆盖率 / 深面板（不重建结构）
 // 深面板用指纹判断内容是否真的变了：变了只换 body，没变一个字节都不动。
 //渐进式刷新：每抓到一款就地更新 Hero KPI / 覆盖率 / 子视图（不重建结构）
    // 深面板用指纹判断内容是否真的变了：变了只换 body，没变一个字节都不动。
    function _achRealPaint(scope) {
        const root = scope || document;
        if (!root || typeof root.querySelector !== 'function') return;
        try { _achPaintComposite(root); } catch (e) { console.warn('[SGLV] 成就总览刷新失败', e); }
        let s;
        try { s = ACH_REAL.summary(); } catch (e) { console.warn('[SGLV] 真实成就汇总失败', e); return; }
        // ★ v2.44.0：KPI 元素已从「真实成就区块」上提到 Hero 区，
        //   所以这里必须从 root 找，不能再从 .sglv-ach-real 找（否则 Hero 数字永远不更新）。
        const put = (key, val) => {
            const el = root.querySelector(`[data-achkpi="${key}"]`);
            if (el && el.textContent !== val) el.textContent = val;
        };
        const target = ACH_REAL.targetCount;
        const covered = target > 0 ? Math.min(100, Math.round(((s.synced + s.unknown) / target) * 100)) : 0;
        put('synced', String(s.synced));
        put('unlocked', String(s.unlocked));
        put('defs', String(s.defs));
        put('ratePct', s.rate + '%');
        put('perfect', String(s.perfect));
        put('rare', String(s.rareOwned));
        put('covered', String(covered));
        // 新增派生：通关数 / 未评级 / 猎手指数 / 最近解锁 / 最近通关
        let d = null;
        try { d = ACH_REAL.deep(); } catch (e) { d = null; }
        if (d) {
            put('completed', String(d.completedGames || 0));
            put('hunter', String(d.hunter || 0));
            put('unrated', String(d.unrated || 0));
            const rec = (d.recentUnlocks || [])[0];
            put('recent', rec ? `${rec.game} · ${_formatRelTime(rec.at)}` : (isZh ? '暂无' : 'None'));
            put('lastDone', d.lastCompletedAt > 0 ? _formatAchTime(d.lastCompletedAt) : (isZh ? '暂无' : 'None'));
        }
        // 覆盖率条（v2.44.0：这条留在「同步状态条」里）
        const box = root.querySelector('.sglv-ach-real');
        if (box) {
            const bar = box.querySelector('.sglv-ach-real-bar > div');
            if (bar) bar.style.width = covered + '%';
        }
        // 顶部「游戏成就」标签上的计数也一起走，别让用户看到「0」但其实已经同步了几百款
        // （scope 可能已经缩到 track 内，找不到就退回 document）
        const tabCount = (root.querySelector && root.querySelector('[data-achsub="games"] b'))
            || (document.querySelector ? document.querySelector('[data-achsub="games"] b') : null);
        if (tabCount && tabCount.textContent !== String(s.synced)) tabCount.textContent = String(s.synced);

        // ---- 游戏成就矩阵：按指纹换 body（同步过程中边抓边长）----
        const now = Date.now();
        if (now - _achDeepLastAt >= 800) {
            _achDeepLastAt = now;
            try {
                const d2 = ACH_REAL.deep();
                const fp = _achDeepFingerprint(d2);
                const gamesBox = root.querySelector('[data-achsubview="games"]');
                if (gamesBox && gamesBox.dataset.achMatrixFp !== fp) {
                    gamesBox.dataset.achMatrixFp = fp;
                    try {
                        _achMatrixRefresh(root);
                    } catch (e) {
                        console.warn('[SGLV] 游戏成就矩阵刷新失败', e);
                        gamesBox.innerHTML = `<div class="sglv-ach-empty">${isZh
                            ? '矩阵渲染失败，详情见浏览器控制台（SGLV 日志）'
                            : 'Render failed - see console (SGLV log)'}</div>`;
                    }
                }

                const deepBoxes = root.querySelectorAll ? root.querySelectorAll('.sglv-ach-deep') : [];
                if (deepBoxes.length > 1) {
                    console.warn('[SGLV] 页面上出现多个真实成就深面板（' + deepBoxes.length + ' 个），它们的数据可能不同步');
                }
                const deepBox = deepBoxes[0];
                if (deepBox && deepBox.dataset.achDeepFp !== fp) {
                    deepBox.dataset.achDeepFp = fp;
                    const bodyEl = deepBox.querySelector('.sglv-ach-deep-body');
                    if (bodyEl) {
                        try {
                            bodyEl.innerHTML = _achDeepBodyHtml(d2);
                        } catch (e) {
                            console.warn('[SGLV] 真实成就深面板渲染失败', e);
                            bodyEl.innerHTML = `<div class="sglv-ach-empty">${isZh
                                ? '这一栏渲染失败，详情见浏览器控制台（SGLV 日志）'
                                : 'Render failed - see console (SGLV log)'}</div>`;
                        }
                        // body 换了，里面的行要重新绑定
                        _achDeepBind(deepBox);
                    }
                    const badge = (tab, n) => {
                        const b = deepBox.querySelector('[data-achdeep-tab="' + tab + '"] b');
                        if (b && b.textContent !== String(n)) b.textContent = String(n);
                    };
                    badge('perfect', d2.perfect.length);
                    badge('rare', _achRareOwned(d2));
                    badge('gap', d2.nearPerfect.length);
                    const hv = deepBox.querySelector('.sglv-ach-deep-hunter-v');
                    if (hv && hv.textContent !== String(d2.hunter)) hv.textContent = String(d2.hunter);
                }
            } catch (e) {
                console.warn('[SGLV] 真实成就深度分析失败', e);
            }
        }
    }

    function _achRealProgressTick(scope, p) {
        // 只做就地刷新（KPI + 深面板按指纹换 body）。不再每 2 秒整块重建 DOM。
        try { _achRealPaint(scope); } catch (e) { console.warn('[SGLV] 真实成就进度刷新失败', e); }
        // 按钮文案（整块重建后按钮是新节点，这里按需重新定位）
        const btn = (scope || document).querySelector('#sglv-ach-real-sync');
        if (btn && p) {
            const txt = isZh ? `同步中 ${p.done}/${p.total}` : `${p.done}/${p.total}`;
            if (btn.textContent !== txt) btn.textContent = txt;
        }
    }

    // 导入快照失败时的中文提示。错误码来自 ACH_PARSE.validateSeed / ACH_REAL.importSeed，
    // 每个码都要有话说 —— 否则用户只看到「导入失败」无从下手。
    function _achSeedErrText(code) {
        const zh = {
            'not-object': '快照文件格式无法识别',
            'bad-version': '快照版本不匹配（需要 v1）',
            'no-games': '快照里没有 games 数组',
            'empty-games': '快照内容为空',
            'no-valid-game': '快照里没有可用条目（appid 或 apiName 缺失）',
            'no-idb': '本地数据库不可用（隐私模式下 IndexedDB 可能被禁用）',
            'index-write': '索引写入失败，存储空间可能已满',
        };
        const en = {
            'not-object': 'Unrecognized seed format',
            'bad-version': 'Seed version mismatch (v1 required)',
            'no-games': 'Seed has no games array',
            'empty-games': 'Seed is empty',
            'no-valid-game': 'Seed has no usable entries',
            'no-idb': 'IndexedDB unavailable (private mode?)',
            'index-write': 'Index write failed, storage may be full',
        };
        const m = isZh ? zh : en;
        return m[code] || (isZh ? `导入失败（${code}）` : `Import failed (${code})`);
    }

    function _achRealBindSeed(scope) {
        const btn = scope.querySelector('#sglv-ach-real-seed');
        const input = scope.querySelector('#sglv-ach-real-seed-input');
        if (!btn || !input || btn.dataset.bound === '1') return;
        btn.dataset.bound = '1';

        btn.addEventListener('click', () => {
            if (ACH_REAL.isRunning()) {
                showToast(isZh ? '同步进行中，请等这轮结束再导入' : 'Sync in progress, import after it finishes');
                return;
            }
            input.click();
        });

        input.addEventListener('change', async () => {
            const file = input.files && input.files[0];
            // 立刻清空 value：不清的话第二次选同一个文件不会触发 change（浏览器判定「没变化」）
            input.value = '';
            if (!file) return;

            const label = btn.textContent;
            btn.disabled = true;
            btn.textContent = isZh ? '导入中…' : 'Importing…';
            let toast = '';
            try {
                const text = await file.text();
                let payload = null;
                try { payload = JSON.parse(text); } catch (e) {
                    toast = isZh ? '快照文件不是合法 JSON' : 'Seed file is not valid JSON';
                }
                if (payload) {
                    const r = await ACH_REAL.importSeed(payload);
                    if (!r || r.error) {
                        toast = _achSeedErrText((r && r.error) || 'unknown');
                    } else {
                        const dropped = (r.dropped && (r.dropped.games + r.dropped.items)) || 0;
                        toast = isZh
                            ? `导入 ${r.imported} 款 / ${r.unlocked} 条解锁${r.fail ? `（${r.fail} 款写失败）` : ''}${dropped ? `，跳过 ${dropped} 条脏数据` : ''}`
                            : `Imported ${r.imported} games / ${r.unlocked} unlocked${r.fail ? ` (${r.fail} failed)` : ''}${dropped ? `, skipped ${dropped} invalid` : ''}`;
                    }
                }
            } catch (e) {
                toast = isZh ? '导入失败，请重试' : 'Import failed, please retry';
            } finally {
                btn.disabled = false;
                btn.textContent = label;
                // 失败也要刷新：可能部分写入成功（failing 的是索引或个别游戏）
                try { _achRealRefresh(scope); } catch (e) { /* 刷新失败不影响结果提示 */ }
            }
            if (toast) showToast(toast);
        });
    }

    function _achRealBind(scope) {
        if (!scope || typeof scope.querySelector !== 'function') return;
        _achRealBindSeed(scope);
        const btn = scope.querySelector('#sglv-ach-real-sync');
        if (!btn || btn.dataset.bound === '1') return;
        btn.dataset.bound = '1';
        btn.addEventListener('click', async () => {
            if (ACH_REAL.isRunning()) return;
            btn.disabled = true;
            // 先等缓存读完，否则待抓数会把「已同步」也算进去（显示成从 0 开始）
            try { await ACH_REAL.ready(); } catch (e) { /* 无 IDB 时继续走 run 的降级路径 */ }
            const total = ACH_REAL.pendingCount;
            const onProgress = p => {
                try { _achRealProgressTick(scope, p); } catch (e) { /* 忽略 */ }
            };
            onProgress({ done: 0, total });
            try {
                const r = await ACH_REAL.run({ limit: 120, onProgress });
                if (r && r.error === 'no-steamid') {
                    showToast(isZh ? '未获取到 SteamID，请先获取游戏库' : 'SteamID not found');
                } else if (r && !r.skipped && !r.empty) {
                    const crossHint = (!ACH_REAL.isCommunityHost() && r.ok === 0 && r.fail > 0)
                        ? (isZh ? '；商店页跨域抓取失败，请到个人主页（steamcommunity.com）同步' : '; cross-origin sync failed, try your profile page')
                        : '';
                    showToast((isZh
                        ? `真实成就：成功 ${r.ok} 款，私密 ${r.private} 款，失败 ${r.fail} 款`
                        : `Achievements: ${r.ok} ok, ${r.private} private, ${r.fail} failed`) + crossHint);
                }
            } catch (e) {
                showToast(isZh ? '同步失败，请稍后重试' : 'Sync failed, try again later');
            }
            _achRealRefresh(scope);
        });
    }

 //首次进入成就页时静默补一轮：缓存里的数据永远保留，只抓从没同步过的游戏，
 // 每次访问自动往前推进一段（每轮 120 款），让覆盖率逐步铺满而不是一次性落空
    function _achRealAutoKick(scope) {
        if (_achRealAutoStarted) return;
        // 自动轮只在社区域跑：商店域跨域抓取成本高（每轮 120 个请求、约 2 分钟），
        // 且 IDB 按 origin 隔离、两域各存各的，更适合由用户手动点「同步」触发。
        if (!ACH_REAL.isCommunityHost()) { _achRealAutoStarted = true; return; }
        if (ACH_REAL.isRunning()) return;
        _achRealAutoStarted = true;

        let tries = 0;
        const kick = () => {
            if (ACH_REAL.isRunning()) { _achRealAutoStarted = false; return; }
            // 游戏库还没载入时 targets 为空 → 别把这当成「没有待抓」，过几秒再试
            if (ACH_REAL.targetCount === 0) {
                if (++tries <= 4) { try { setTimeout(kick, 3000); } catch (e) { /* 忽略 */ } return; }
                _achRealAutoStarted = false;
                return;
            }
            if (ACH_REAL.pendingCount === 0) { _achRealAutoStarted = false; return; }
            ACH_REAL.run({
                limit: 120,
                onProgress: p => {
                    try { _achRealProgressTick(scope, p); } catch (e) { /* 忽略 */ }
                },
            }).then(r => {
                // 这一轮没干活（无待抓 / 被中断 / 无 steamid）→ 放开标记，下次进入还能再补
                if (!r || r.empty || r.error || r.skipped) _achRealAutoStarted = false;
                try { _achRealRefresh(scope); } catch (e) { /* 静默 */ }
            }).catch(() => { _achRealAutoStarted = false; });
        };

        // 缓存要先读完再判断 pending，否则会把「已同步」误算成全部待抓
        try {
            if (ACH_REAL.isReady()) kick();
            else ACH_REAL.ready().then(ok => { if (ok) kick(); else _achRealAutoStarted = false; });
        } catch (e) { _achRealAutoStarted = false; }
    }

 // ---- 真实成就深度面板：完美墙(S2) / 稀有收藏(S3) / 缺口(S4) / 详情弹窗(S5) ----
    function _achDeepTab() {
        const t = state && state.achDeepTab;
        return (t === 'rare' || t === 'gap') ? t : 'perfect';
    }

    function _achPctText(p) {
        const v = Number(p);
        if (!Number.isFinite(v) || v < 0) return '—';       // pct 未知：显示破折号，不显示 0%
        return (v < 1 ? v.toFixed(2) : v.toFixed(1)) + '%';
    }

    function _achTierMeta(key) {
        return (key && ACH_PARSE.TIER_BY_KEY[key]) || null;
    }

    function _achTierName(key) {
        const t = _achTierMeta(key);
        if (!t) return isZh ? '未知' : 'Unknown';
        return isZh ? t.label : t.labelEn;
    }

    // 稀有度 → CSS 变量（卡片左边框 / 徽标 / 圆点统一走 --tw / --dc）
    function _achTierStyle(pct, varName) {
        const t = _achTierMeta(ACH_PARSE.tierOf(pct));
        return `${varName || '--dc'}:${t ? t.color : '#64748b'}`;
    }

    function _achRareOwned(d) {
        const b = d && d.buckets ? d.buckets : null;
        if (!b) return 0;
        return (b.mythic ? b.mythic.owned : 0) + (b.legend ? b.legend.owned : 0) + (b.rare ? b.rare.owned : 0);
    }

    function _achDeepEmpty(msg) {
        return `<div class="sglv-ach-empty">${msg}</div>`;
    }

    function _achGameIconHtml(appid, alt) {
        const id = Number(appid) || 0;
        if (!id) return '';
        const src = 'https://cdn.cloudflare.steamstatic.com/steam/apps/' + id + '/capsule_231x87.jpg';
        return `<img class="sglv-ach-game-ico" alt="${escHtml(alt || '')}" loading="lazy" decoding="async" referrerpolicy="no-referrer" src="${src}" data-sglv-cover="1" data-appid="${id}" data-kind="capsule">`;
    }

 //完美通关墙：一款一张卡，按「该游戏最稀有成就的全球%」升序（越稀有越靠前）
    function _achDeepPerfectHtml(d) {
        if (!d.perfect.length) {
            const nearest = d.nearPerfect.length
                ? (isZh ? `最接近的还差 ${d.nearPerfect[0].missing} 个 —— 去「待补缺口」看看` : `Closest is ${d.nearPerfect[0].missing} away`)
                : (isZh ? '继续玩吧' : 'Keep playing');
            return _achDeepEmpty(isZh
                ? `已分析 ${d.games.length} 款，还没有完美通关的游戏。${nearest}。`
                : `Analyzed ${d.games.length} games, no perfect ones yet. ${nearest}.`);
        }
        const shown = d.perfect.slice(0, 60);
        const cards = shown.map(g => {
            const tk = ACH_PARSE.tierOf(g.rarest);
            const rareTxt = g.rarest >= 0
                ? (isZh ? `最难 ${_achPctText(g.rarest)}` : `hardest ${_achPctText(g.rarest)}`)
                : (isZh ? '全球完成率未知' : 'pct unknown');
            return `<button class="sglv-ach-wall-card" data-achgame="${g.appid}" style="--tw:${(_achTierMeta(tk) || {}).color || '#6366f1'}">
                <div class="sglv-ach-wall-top">
                    ${_achGameIconHtml(g.appid, g.name)}
                    <span class="sglv-ach-wall-name">${escHtml(g.name)}</span>
                    <span class="sglv-ach-wall-badge">${_achTierName(tk)}</span>
                </div>
                <div class="sglv-ach-wall-sub">${g.active} ${isZh ? '个成就全解锁' : 'achievements done'} · ${rareTxt}</div>
                <div class="sglv-ach-wall-ach">${g.rarestName
                    ? (isZh ? '最难：' : 'Hardest: ') + escHtml(g.rarestName)
                    : (isZh ? '点开看全部成就' : 'Click for details')}</div>
            </button>`;
        }).join('');
        const more = d.perfect.length > shown.length
            ? `<div class="sglv-ach-empty" style="padding:8px 2px 0">${isZh
                ? `还有 ${d.perfect.length - shown.length} 款完美通关未展示（按稀有度排序，这里只显示最值钱的 ${shown.length} 款）`
                : `+${d.perfect.length - shown.length} more perfect games not shown`}</div>`
            : '';
        return `${cards ? `<div class="sglv-ach-wall">${cards}</div>` : ''}${more}`;
    }

 //稀有收藏：五档分布条 + 最稀有的已解锁条目
    function _achDeepRareHtml(d) {
        const totalOwned = d.owned || 0;
        const bars = ACH_PARSE.TIERS.map(t => {
            const b = d.buckets[t.key] || { total: 0, owned: 0 };
            const w = b.total > 0 ? Math.round((b.owned / b.total) * 100) : 0;
            const range = t.max <= 1 ? '<1%' : (t.key === 'legend' ? '1–5%' : (t.key === 'rare' ? '5–20%' : (t.key === 'uncommon' ? '20–50%' : '>50%')));
            const label = isZh ? t.label : t.labelEn;
            return `<div class="sglv-ach-bucket" style="--bc:${t.color}">
                <span class="sglv-ach-bucket-l" title="${range}">${label}</span>
                <span class="sglv-ach-bucket-bar"><i style="width:${w}%"></i></span>
                <span class="sglv-ach-bucket-c"><b>${b.owned}</b>/${b.total}</span>
            </div>`;
        }).join('');

        const head = `<div class="sglv-ach-sec">${isZh ? '稀有度分布（已解锁 / 全部）' : 'Rarity distribution'}<b>${totalOwned}</b></div>
            <div class="sglv-ach-buckets">${bars}</div>`;

        if (!d.rarestOwned.length) {
            return head + _achDeepEmpty(isZh
                ? '还没有带全球完成率的成就数据。完成率来自成就页的 globalpercentages，同步过就会带上。'
                : 'No global percentages yet.');
        }
        const rows = d.rarestOwned.map(a => `<button class="sglv-ach-row" data-achgame="${a.appid}" style="${_achTierStyle(a.pct)}">
            <span class="sglv-ach-row-dot"></span>
            ${_achGameIconHtml(a.appid, a.game)}
            <span class="sglv-ach-row-main">
                <span class="sglv-ach-row-t">${escHtml(a.ach)}</span>
                <span class="sglv-ach-row-s">${escHtml(a.game)}${a.at ? ' · ' + _formatAchTime(a.at) : ''}</span>
            </span>
            <span class="sglv-ach-row-p">${_achPctText(a.pct)}<small>${isZh ? '拥有' : 'own'}</small></span>
        </button>`).join('');
        return `${head}
            <div class="sglv-ach-sec">${isZh ? '最稀有的解锁' : 'Rarest unlocked'}<b>${d.rarestOwned.length} / ${_achRareOwned(d)}</b></div>
            <div class="sglv-ach-list">${rows}</div>`;
    }

    //缺口分析：差 1~2 个就完美 / 全球多数人已拿而你没拿
    function _achDeepGapHtml(d) {
        const NEAR_CAP = 30;
        const nearShown = d.nearPerfect.slice(0, NEAR_CAP);
        const nearMore = d.nearPerfect.length > nearShown.length
            ? `<div class="sglv-ach-empty" style="padding:6px 2px 0">${isZh
                ? `还有 ${d.nearPerfect.length - nearShown.length} 款未展示（按缺口与稀有度排序）`
                : `+${d.nearPerfect.length - nearShown.length} more`}</div>`
            : '';
        const secA = d.nearPerfect.length
            ? `<div class="sglv-ach-sec">${isZh ? '差 1~2 个就完美' : 'Almost perfect'}<b>${d.nearPerfect.length}</b></div>
               <div class="sglv-ach-list">${nearShown.map(g => `<button class="sglv-ach-row" data-achgame="${g.appid}" style="${_achTierStyle(g.rarest)}">
                    <span class="sglv-ach-row-dot"></span>
                    ${_achGameIconHtml(g.appid, g.name)}
                    <span class="sglv-ach-row-main">
                        <span class="sglv-ach-row-t">${escHtml(g.name)}</span>
                        <span class="sglv-ach-row-s">${g.unlocked}/${g.active} · ${g.rate}% ${isZh ? '完成' : 'done'}${g.rarest >= 0 ? ' · ' + (isZh ? '最难已拿 ' : 'hardest ') + _achPctText(g.rarest) : ''}</span>
                    </span>
                    <span class="sglv-ach-row-p">${isZh ? '差' : '-'}${g.missing}</span>
                </button>`).join('')}</div>${nearMore}`
            : `<div class="sglv-ach-sec">${isZh ? '差 1~2 个就完美' : 'Almost perfect'}<b>0</b></div>
               ${_achDeepEmpty(isZh ? '没有卡在最后一两个的成就 —— 要么都完美了，要么离得还远。' : 'Nothing stuck at the last step.')}`;

        // 这里的条数就是 analyze 已截断后的 40 条，别再加 slice，否则标题数与渲染数对不上
        const secB = d.popularMissing.length
            ? `<div class="sglv-ach-sec">${isZh ? '全球多数人已拿，你还没拿' : 'Popular but missing'}<b>${d.popularMissing.length}</b></div>
               <div class="sglv-ach-list">${d.popularMissing.map(a => `<button class="sglv-ach-row" data-achgame="${a.appid}" style="${_achTierStyle(a.pct)}">
                    <span class="sglv-ach-row-dot"></span>
                    ${_achGameIconHtml(a.appid, a.game)}
                    <span class="sglv-ach-row-main">
                        <span class="sglv-ach-row-t">${escHtml(a.ach)}</span>
                        <span class="sglv-ach-row-s">${escHtml(a.game)}</span>
                    </span>
                    <span class="sglv-ach-row-p">${_achPctText(a.pct)}<small>${isZh ? '人有' : 'have'}</small></span>
                </button>`).join('')}</div>`
            : `<div class="sglv-ach-sec">${isZh ? '全球多数人已拿，你还没拿' : 'Popular but missing'}<b>0</b></div>
               ${_achDeepEmpty(isZh ? '没有这种「漏掉的大众成就」—— 常见成就基本都拿到了。' : 'No popular achievements missing.')}`;

        return secA + secB;
    }

    function _achDeepBodyHtml(d) {
        if (!d || d.scanned === 0) {
            return _achDeepEmpty(isZh
                ? '还没有真实成就数据。先点上方「同步」，玩满 2 小时的游戏会按游玩时长顺序排队，每轮 120 款。'
                : 'No real achievement data yet. Click Sync above — 120 games per run.');
        }
        if (!d.games.length) {
            return _achDeepEmpty(isZh
                ? `已同步的 ${d.unknown} 款游戏成就都是私密的，无法参与分析。到 Steam「隐私设置 → 游戏详情」改为公开后再同步。`
                : `${d.unknown} synced games are private. Set game details to public on Steam, then re-sync.`);
        }
        const tab = _achDeepTab();
        if (tab === 'rare') return _achDeepRareHtml(d);
        if (tab === 'gap') return _achDeepGapHtml(d);
        return _achDeepPerfectHtml(d);
    }

    function _achDeepHtml() {
        let d;
        try { d = ACH_REAL.deep(); } catch (e) { return ''; }
        const tab = _achDeepTab();
        const rareN = _achRareOwned(d);
        const gapN = d.nearPerfect.length;
        const hunterTitle = isZh
            ? '按已解锁成就的全球稀有度加权（神话 50 / 传说 20 / 稀有 8 / 少见 3 / 常见 1）后开方归一到 0~100。全是常见成就约 14，全神话才是 100。'
            : 'Weighted by global rarity, sqrt-normalized to 0-100.';
        return `
            <div class="sglv-ach-deep">
                <div class="sglv-ach-deep-head">
                    <div class="sglv-ach-deep-tabs">
                        <button class="sglv-ach-deep-tab ${tab === 'perfect' ? 'active' : ''}" data-achdeep-tab="perfect" title="${isZh ? `全成就解锁、且该游戏至少 ${ACH_WALL_MIN_ACTIVE} 个成就` : ''}">${isZh ? '完美通关墙' : 'Perfect Wall'} <b>${d.perfect.length}</b></button>
                        <button class="sglv-ach-deep-tab ${tab === 'rare' ? 'active' : ''}" data-achdeep-tab="rare" title="${isZh ? '神话(<1%) + 传说(1–5%) + 稀有(5–20%) 三档的已解锁数，与上方 &lt;5% 的 KPI 口径不同' : ''}">${isZh ? '稀有收藏' : 'Rare Collection'} <b>${rareN}</b></button>
                        <button class="sglv-ach-deep-tab ${tab === 'gap' ? 'active' : ''}" data-achdeep-tab="gap" title="${isZh
                            ? `差 1~2 个就完美的游戏数（此数字即此项）；下方另列「全球多数人已拿、你还没拿」的高通过率成就 Top ${d.popularMissing.length}`
                            : 'Games missing only 1-2 achievements'}">${isZh ? '待补缺口' : 'Gaps'} <b>${gapN}</b></button>
                    </div>
                    <div class="sglv-ach-deep-hunter" title="${hunterTitle}">
                        <span class="sglv-ach-deep-hunter-l">${isZh ? '猎手指数' : 'Hunter Index'}</span>
                        <span class="sglv-ach-deep-hunter-v">${d.hunter}</span>
                    </div>
                </div>
                <div class="sglv-ach-deep-body">${_achDeepBodyHtml(d)}</div>
            </div>`;
    }

    function _achDeepBind(scope) {
        if (!scope || typeof scope.querySelector !== 'function') return;
        const tabs = scope.querySelectorAll('[data-achdeep-tab]');
        tabs.forEach(btn => {
            if (btn.dataset.bound === '1') return;
            btn.dataset.bound = '1';
            btn.addEventListener('click', () => {
                const want = btn.dataset.achdeepTab;
                if (_achDeepTab() === want) return;
                state.achDeepTab = want;
                tabs.forEach(b => b.classList.toggle('active', b.dataset.achdeepTab === want));
                // 只换 body：整块重建会把滚动位置顶回顶部
                const body = scope.querySelector('.sglv-ach-deep-body');
                if (!body) return;
                try {
                    body.innerHTML = _achDeepBodyHtml(ACH_REAL.deep());
                } catch (e) {
                    // 以前这里是 body.innerHTML = '' —— 任何一次异常都会把整栏内容
                    // 悄悄抹掉，界面上只剩一片空白，看起来就像"数据加载不出来"。
                    // 现在保留提示并打日志，让故障可见、可查。
                    console.warn('[SGLV] 真实成就深面板切页渲染失败', e);
                    body.innerHTML = `<div class="sglv-ach-empty">${isZh
                        ? '这一栏渲染失败，详情见浏览器控制台（SGLV 日志）'
                        : 'Render failed - see console (SGLV log)'}</div>`;
                }
                _achDeepBind(scope);   // 新 body 里的行需要重新绑定
            });
        });
        scope.querySelectorAll('[data-achgame]').forEach(el => {
            if (el.dataset.bound === '1') return;
            el.dataset.bound = '1';
            el.addEventListener('click', () => _achOpenGame(Number(el.dataset.achgame)));
        });
    }

 //详情弹窗（S5）：单款游戏的全部成就，按全球完成率升序
    function _achModalKeydown(e) {
        if (e.key === 'Escape') { e.stopPropagation(); _achCloseGame(); }
    }

    function _achCloseGame() {
        const el = document.getElementById('sglv-ach-modal');
        if (el) el.remove();
        document.removeEventListener('keydown', _achModalKeydown, true);
        // 恢复滚动：只在确实锁过时才动，避免覆盖别的模块设置的 overflow
        if (document.body && document.body.dataset.achLocked === '1') {
            document.body.style.overflow = document.body.dataset.achPrevOverflow || '';
            delete document.body.dataset.achLocked;
            delete document.body.dataset.achPrevOverflow;
        }
    }

    function _achOpenGame(appid) {
        let row = null;
        try { row = ACH_REAL.readDetail(appid); } catch (e) { row = null; }
        if (!row) {
            showToast(isZh ? '这款游戏还没有成就缓存' : 'No cached achievements for this game');
            return;
        }
        let gname = 'App ' + appid;
        try {
            const g = (ACH_REAL.deep().games || []).find(x => Number(x.appid) === Number(appid));
            if (g) gname = g.name;
        } catch (e) { /* 用兜底名 */ }

        const items = (Array.isArray(row.items) ? row.items : [])
            .filter(it => Array.isArray(it) && ((Number(it[5]) || 0) & 2) !== 2)
            .map(it => ({ ach: String(it[1] || it[0]), on: it[2] === 1, at: Number(it[3]) || 0, pct: Number(it[4]) }))
            // 稀有的排前面；pct 未知(-1) 垫底，不冒充最高稀有度
            .sort((a, b) => (a.pct < 0 ? 999 : a.pct) - (b.pct < 0 ? 999 : b.pct));

        if (!items.length) {
            showToast(isZh ? '这款游戏没有可显示的成就' : 'No achievements to show');
            return;
        }
        const active = items.length;
        const done = items.filter(i => i.on).length;
        const rate = active > 0 ? Math.round((done / active) * 100) : 0;
        const priv = row.privacy === 'unknown';
        const bodyHtml = items.map(i => `<div class="sglv-ach-mrow ${i.on ? '' : 'off'}" style="${_achTierStyle(i.pct)}">
            <span class="sglv-ach-row-dot"></span>
            <span class="sglv-ach-row-main">
                <span class="sglv-ach-row-t">${escHtml(i.ach)}</span>
                <span class="sglv-ach-row-s">${i.on
                    ? (isZh ? '已解锁' : 'Unlocked') + (i.at ? ' · ' + _formatAchTime(i.at) : '')
                    : (isZh ? '未解锁' : 'Locked')}</span>
            </span>
            <span class="sglv-ach-mrow-p">${_achPctText(i.pct)}<small>${isZh ? '人有' : 'have'}</small></span>
        </div>`).join('');

        _achCloseGame();
        const wrap = document.createElement('div');
        wrap.className = 'sglv-ach-modal';
        wrap.id = 'sglv-ach-modal';
        wrap.innerHTML = `
            <div class="sglv-ach-modal-mask"></div>
            <div class="sglv-ach-modal-panel" role="dialog" aria-modal="true">
                <div class="sglv-ach-modal-head">
                    <div>
                        <div class="sglv-ach-modal-title">${_achGameIconHtml(appid, gname)}<span>${escHtml(gname)}</span></div>
                        <div class="sglv-ach-modal-sub">${isZh
                            ? `<b>${done}/${active}</b> · ${rate}% 完成${rate === 100 ? ' · <b>完美通关</b>' : ''}`
                            : `<b>${done}/${active}</b> · ${rate}%${rate === 100 ? ' · <b>Perfect</b>' : ''}`}${row.archived ? (isZh ? ` · ${row.archived} 个已下架成就不计入` : ` · ${row.archived} archived excluded`) : ''}${priv ? (isZh ? ' · 成就私密' : ' · private') : ''}</div>
                    </div>
                    <button class="sglv-ach-modal-close" aria-label="close">×</button>
                </div>
                <div class="sglv-ach-modal-body">${bodyHtml}</div>
            </div>`;
        document.body.appendChild(wrap);
        // 锁背景滚动（弹窗盖满视口，背后还能滚会很怪）
        if (document.body && document.body.dataset.achLocked !== '1') {
            document.body.dataset.achPrevOverflow = document.body.style.overflow || '';
            document.body.dataset.achLocked = '1';
            document.body.style.overflow = 'hidden';
        }
        const mask = wrap.querySelector('.sglv-ach-modal-mask');
        const closeBtn = wrap.querySelector('.sglv-ach-modal-close');
        if (mask) mask.addEventListener('click', _achCloseGame);
        if (closeBtn) closeBtn.addEventListener('click', _achCloseGame);
        document.addEventListener('keydown', _achModalKeydown, true);
    }

 // ==================== ACH-S2-END ====================

 //单张成就卡片段（NEW 标签/稀有度着色/进度条/解锁时间,自 renderMyAchievementsTab 拆出,纯搬移）
    // （v2.44.0：_achCardHtml 已移除 —— 自定义成就的大卡片视图被页面底部的徽章架取代）

    // ====== v2.44.0：游戏维度导航计数（左栏徽章） ======
    function _achNavCounts(d, s) {
        const deep = d || {};
        const sum = s || {};
        const synced = Number(sum.synced) || 0;
        let unsynced = 0;
        try { unsynced = Math.max(0, ACH_REAL.targetCount - synced); } catch (e) { unsynced = 0; }
        return {
            synced: synced,
            perfect: (deep.perfect || []).length,
            rare: (deep.games || []).filter(g => (g.rare || 0) > 0).length,
            gap: (deep.nearPerfect || []).length,
            private: (deep.privateGames || []).length,
            unsynced: unsynced,
        };
    }

    // ====== v2.44.0：游戏成就矩阵（新增主视图） ======
    // 这是最自然的浏览方式，但旧版完全没有：Steam 侧只有「完美墙/稀有收藏/缺口」三个聚合视图，
    // 逐款游戏的成就明细只能从聚合视图点进模态框看。
    function _achMatrixRows(d, view) {
        if (!d) return [];
        const games = d.games || [];
        const byRate = (a, b) => (b.rate - a.rate) || (b.active - a.active);
        if (view === 'perfect') return (d.perfect || []).slice();
        if (view === 'gap') return (d.nearPerfect || []).slice();
        if (view === 'rare') return games.filter(g => (g.rare || 0) > 0).sort((a, b) => (b.rare - a.rare) || byRate(a, b));
        if (view === 'private') return (d.privateGames || []).slice();
        if (view === 'unsynced') {
            const rows = [];
            try {
                for (const t of ACH_REAL.targets()) {
                    if (!t || !t.appid) continue;
                    if (ACH_REAL.readDetail(t.appid)) continue;
                    rows.push({
                        appid: t.appid, name: t.name || ('App ' + t.appid),
                        active: 0, unlocked: 0, missing: 0, rate: 0, unsynced: true,
                    });
                }
            } catch (e) { /* ignore */ }
            return rows;
        }
        return games.slice().sort(byRate);
    }

    // ====== v2.44.2：矩阵工具栏（借鉴游戏收藏模块的「完成度 / 排序 / 视图」工具栏） ======
    // 收藏模块那套工具栏是本仓最成熟的交互范式：分段按钮组 + flex-wrap 防溢出 + 视图切换。
    // 成就矩阵此前只有「一列纯文字行」—— 851 款游戏一次性铺开、看不出是哪个游戏、也没法排序检索。
    const _ACH_MATRIX_SORTS = [
        { id: 'rate',   label: isZh ? '完成率' : 'Rate' },
        { id: 'rare',   label: isZh ? '稀有数' : 'Rare' },
        { id: 'recent', label: isZh ? '最近解锁' : 'Recent' },
        { id: 'count',  label: isZh ? '成就数' : 'Count' },
        { id: 'name',   label: isZh ? '名称' : 'Name' },
    ];

    // 排序 + 搜索过滤（在导航分类过滤之后叠加）
    function _achMatrixApply(rows) {
        const list = (rows || []).slice();
        const sort = state.achMatrixSort || 'rate';
        const byRate = (a, b) => (b.rate - a.rate) || (b.active - a.active);
        if (sort === 'rare') list.sort((a, b) => ((b.rare || 0) - (a.rare || 0)) || byRate(a, b));
        else if (sort === 'recent') list.sort((a, b) => ((b.completedAt || 0) - (a.completedAt || 0)) || byRate(a, b));
        else if (sort === 'count') list.sort((a, b) => (b.active - a.active) || byRate(a, b));
        else if (sort === 'name') list.sort((a, b) => String(a.name || '').localeCompare(String(b.name || '')));
        else list.sort(byRate);
        const q = String(state.achMatrixQuery || '').trim().toLowerCase();
        if (!q) return list;
        return list.filter(g => String(g.name || '').toLowerCase().includes(q));
    }

    function _achMatrixToolbarHtml(total, filtered) {
        const sort = state.achMatrixSort || 'rate';
        const view = state.achMatrixView === 'card' ? 'card' : 'list';
        const q = state.achMatrixQuery || '';
        const sortBtns = _ACH_MATRIX_SORTS.map(s =>
            `<button class="sglv-ach-mx-seg ${sort === s.id ? 'active' : ''}" type="button" data-achsort="${s.id}">${s.label}</button>`).join('');
        return `
            <div class="sglv-ach-mx-toolbar">
                <div class="sglv-ach-mx-group">${sortBtns}</div>
                <input class="sglv-ach-mx-search" type="text" data-achq value="${escHtml(q)}"
                    placeholder="${isZh ? '搜索游戏名' : 'Search games'}" autocomplete="off" spellcheck="false" maxlength="64">
                <div class="sglv-ach-mx-group">
                    <button class="sglv-ach-mx-seg ${view === 'list' ? 'active' : ''}" type="button" data-achview="list">${isZh ? '列表' : 'List'}</button>
                    <button class="sglv-ach-mx-seg ${view === 'card' ? 'active' : ''}" type="button" data-achview="card">${isZh ? '卡片' : 'Cards'}</button>
                </div>
            </div>
            <div class="sglv-ach-mx-meta" data-achmx-meta></div>`;
    }

    function _achMatrixBodyHtml(rows, allCount, filteredCount) {
        if (!rows || !rows.length) {
            // 两种空态要分清：「这个分类本来就没有」vs「筛选条件没命中」
            const noMatch = (allCount || 0) > 0 && (filteredCount || 0) === 0;
            const title = noMatch
                ? (isZh ? '没有匹配的游戏' : 'No matching games')
                : (isZh ? '这一类下暂时没有游戏' : 'No games in this group');
            const hint = noMatch
                ? (isZh ? '换个关键词或排序条件试试。' : 'Try another keyword or sort.')
                : (isZh ? '换个左侧分类看看，或点上方「立即同步」补齐数据。' : 'Try another filter on the left, or sync to fetch more.');
            return `<div class="sglv-ach-empty-card">
                <div class="sglv-ach-empty-title">${escHtml(title)}</div>
                <div class="sglv-ach-empty-hint">${escHtml(hint)}</div>
            </div>`;
        }
        const card = state.achMatrixView === 'card';
        const R = 15, CIRC = 2 * Math.PI * R;
        const list = rows.map(g => {
            const pct = Math.max(0, Math.min(100, Number(g.rate) || 0));
            const off = CIRC * (1 - pct / 100);
            const tags = [];
            if (g.unsynced) {
                tags.push(`<span class="sglv-ach-matrix-tag muted">${isZh ? '待同步' : 'PENDING'}</span>`);
            } else {
                if (g.missing === 0) tags.push(`<span class="sglv-ach-matrix-tag perfect">${isZh ? '完美' : 'PERFECT'}</span>`);
                if ((g.rare || 0) > 0) tags.push(`<span class="sglv-ach-matrix-tag rare">${g.rare} ${isZh ? '稀有' : 'RARE'}</span>`);
                if (g.completedAt > 0) tags.push(`<span class="sglv-ach-matrix-tag done">${isZh ? '通关' : 'CLEARED'} ${_formatAchTime(g.completedAt)}</span>`);
            }
            const meta = g.unsynced
                ? (isZh ? '还没有抓取成就数据' : 'Not fetched yet')
                : `${g.unlocked}/${g.active} ${isZh ? '成就' : 'achievements'}${g.missing > 0 ? ` · ${isZh ? '还差' : 'missing'} ${g.missing}` : ''}`;
            if (card) {
                // 卡片视图：竖版海报（主脚本 coverImgTag → data-sglv-cover 全降级链）
                return `<div class="sglv-ach-mx-card" data-achgame="${g.appid}" role="button" tabindex="0">
                    <div class="sglv-ach-mx-card-cover">${posterImg(g.appid, escHtml(g.name))}</div>
                    <div class="sglv-ach-mx-card-name">${escHtml(g.name)}</div>
                    <div class="sglv-ach-mx-card-bar"><i style="width:${pct}%"></i></div>
                    <div class="sglv-ach-mx-card-meta">${escHtml(meta)}</div>
                    <div class="sglv-ach-matrix-tags">${tags.join('')}</div>
                </div>`;
            }
            // 列表视图：游戏封面 + 进度环 + 名称 + 标签
            return `<div class="sglv-ach-matrix-row" data-achgame="${g.appid}" role="button" tabindex="0">
                <div class="sglv-ach-matrix-ico">${_achGameIconHtml(g.appid, g.name)}</div>
                <div class="sglv-ach-matrix-ring">
                    <svg viewBox="0 0 36 36">
                        <circle class="bg" cx="18" cy="18" r="${R}"></circle>
                        <circle class="fill" cx="18" cy="18" r="${R}" stroke-dasharray="${CIRC.toFixed(2)}" stroke-dashoffset="${off.toFixed(2)}"></circle>
                    </svg>
                    <span class="sglv-ach-matrix-ring-t">${pct}%</span>
                </div>
                <div class="sglv-ach-matrix-info">
                    <div class="sglv-ach-matrix-name">${escHtml(g.name)}</div>
                    <div class="sglv-ach-matrix-meta">${escHtml(meta)}</div>
                </div>
                <div class="sglv-ach-matrix-tags">${tags.join('')}</div>
            </div>`;
        }).join('');
        return card
            ? `<div class="sglv-ach-mx-cards">${list}</div>`
            : `<div class="sglv-ach-matrix">${list}</div>`;
    }

    function _achMatrixHtml(d, view) {
        // 空态（还没有任何真实成就数据）—— 保持 v2.44.1 的可操作空态卡
        if (!d || d.scanned === 0) {
            const running = ACH_REAL.isRunning();
            const prog = ACH_REAL.progress();
            const target = ACH_REAL.targetCount;
            let title, hint, cta = '';
            if (running && prog) {
                title = isZh ? `正在同步 ${prog.done}/${prog.total}` : `Syncing ${prog.done}/${prog.total}`;
                hint = isZh
                    ? '每抓到一款就写入本地缓存，上面的统计与下面这份列表会立刻跟着涨。'
                    : 'Each game is cached as it is fetched; stats and this list update immediately.';
            } else if (target === 0) {
                title = isZh ? '请先获取游戏库' : 'Fetch your library first';
                hint = isZh
                    ? '成就同步只覆盖玩满 2 小时的游戏 —— 先在「我的库存」里拉一次游戏库。'
                    : 'Achievement sync covers games with 2h+ playtime. Fetch your library first.';
            } else {
                title = isZh ? '还没有真实成就数据' : 'No real achievement data yet';
                hint = isZh
                    ? `点「立即同步」开始：每轮最多 120 款、约 2 分钟，剩余 ${target} 款会在几次访问里陆续铺满。`
                    : `Click Sync: up to 120 games per run, about 2 minutes. ${target} games in total.`;
                cta = isZh ? '立即同步' : 'Sync now';
            }
            return `<div class="sglv-ach-empty-card">
                <div class="sglv-ach-empty-title">${escHtml(title)}</div>
                <div class="sglv-ach-empty-hint">${escHtml(hint)}</div>
                ${cta ? `<button class="sglv-ach-empty-cta" type="button" data-achempty="sync">${escHtml(cta)}</button>` : ''}
            </div>`;
        }
        const all = _achMatrixRows(d, view);
        const filtered = _achMatrixApply(all);
        const size = Math.max(10, Number(state.achMatrixPageSize) || 50);
        const pg = paginate(filtered, state.achMatrixPage || 1, size);
        state.achMatrixPage = pg.page;
        return `
            <div class="sglv-ach-mx">
                ${_achMatrixToolbarHtml(all.length, filtered.length)}
                <div class="sglv-ach-mx-body" data-achmx-body>${_achMatrixBodyHtml(pg.pageItems, all.length, filtered.length)}</div>
                <div class="sglv-pagination" id="sglv-ach-matrix-pagination" data-achmx-pager></div>
            </div>`;
    }

    // 矩阵重绘（排序 / 搜索 / 翻页后只换 body 与分页器，不整页重建 → 滚动位置不跳）
    function _achMatrixPaint(root) {
        if (!root || typeof root.querySelector !== 'function') return;
        let d = null;
        try { d = ACH_REAL.deep(); } catch (e) { d = null; }
        const navView = state.achNavView || 'all';
        const all = _achMatrixRows(d, navView);
        const filtered = _achMatrixApply(all);
        const size = Math.max(10, Number(state.achMatrixPageSize) || 50);
        const pg = paginate(filtered, state.achMatrixPage || 1, size);
        state.achMatrixPage = pg.page;

        const bodyBox = root.querySelector('[data-achmx-body]');
        if (bodyBox) {
            try { bodyBox.innerHTML = _achMatrixBodyHtml(pg.pageItems, all.length, filtered.length); }
            catch (e) { console.warn('[SGLV] 矩阵重绘失败', e); }
        }
        const metaBox = root.querySelector('[data-achmx-meta]');
        if (metaBox) {
            const txt = isZh
                ? `共 ${all.length} 款${filtered.length !== all.length ? ` · 筛选出 ${filtered.length} 款` : ''} · 第 ${pg.page}/${pg.totalPages} 页`
                : `${all.length} games${filtered.length !== all.length ? ` · ${filtered.length} shown` : ''} · page ${pg.page}/${pg.totalPages}`;
            if (metaBox.textContent !== txt) metaBox.textContent = txt;
        }
        const pager = root.querySelector('[data-achmx-pager]');
        if (pager) {
            try {
                // ⚠️ onJump 是第 8 个参数，必须传 ——
                //   缺了它，首/上/下/末页 + 跳页这 5 个按钮会**全部静默失效**
                //   （游戏收藏模块 v1.9.47 踩过这个坑：用户只看到「只能加载第一页/不能翻页」）。
                renderPagination(pager, 'sglv-ach-matrix', pg.page, pg.totalPages, filtered.length,
                    () => { state.achMatrixPage = pg.page - 1; _achMatrixPaint(root); },
                    () => { state.achMatrixPage = pg.page + 1; _achMatrixPaint(root); },
                    (p) => { state.achMatrixPage = p; _achMatrixPaint(root); });
            } catch (e) { console.warn('[SGLV] 矩阵分页渲染失败', e); }
        }
        _achMatrixBind(root);
    }

    // 矩阵刷新：结构已在 → 就地重绘（body / 统计 / 分页器）；结构不在 → 整块重建后重绘
    function _achMatrixRefresh(root) {
        if (!root || typeof root.querySelector !== 'function') return;
        try {
            if (!root.querySelector('[data-achmx-body]')) {
                const gamesBox = root.querySelector('[data-achsubview="games"]');
                if (!gamesBox) return;
                let d0 = null;
                try { d0 = ACH_REAL.deep(); } catch (e) { d0 = null; }
                gamesBox.innerHTML = _achMatrixHtml(d0, state.achNavView || 'all');
            }
            _achMatrixPaint(root);
        } catch (e) {
            console.warn('[SGLV] 游戏成就矩阵刷新失败', e);
        }
    }

    // 打开某款游戏的成就明细弹窗（模块级：矩阵行与侧栏最近解锁共用）
    function _achOpenGameDetail(appid) {
        const id = Number(appid);
        if (!Number.isFinite(id) || id <= 0) return;
        try { _achOpenGame(id); } catch (e) { console.warn('[SGLV] 打开成就详情失败', e); }
    }

    // 矩阵内「立即同步」CTA 与工具栏的绑定。
    // ⚠️ 矩阵会被重渲染（_achMatrixPaint / _achRefreshSubviews / _achRealPaint 都整块换 innerHTML），
    //   innerHTML 替换会把节点连同事件监听一起丢掉 → 每次重渲染后都要重绑。
    // ⚠️ 搜索防抖计时器挂在 scope 上而不是模块级变量 —— 模块级 let 会在按函数抽取的测试沙箱里丢失。
    function _achMatrixBind(scope) {
        if (!scope || typeof scope.querySelectorAll !== 'function') return;

        // 工具栏：排序
        scope.querySelectorAll('[data-achsort]').forEach(btn => {
            if (btn.dataset.bound === '1') return;
            btn.dataset.bound = '1';
            btn.addEventListener('click', () => {
                if ((state.achMatrixSort || 'rate') === btn.dataset.achsort) return;
                state.achMatrixSort = btn.dataset.achsort;
                state.achMatrixPage = 1;
                scope.querySelectorAll('[data-achsort]').forEach(b => b.classList.toggle('active', b.dataset.achsort === state.achMatrixSort));
                _achMatrixPaint(scope);
            });
        });

        // 工具栏：视图切换
        scope.querySelectorAll('[data-achview]').forEach(btn => {
            if (btn.dataset.bound === '1') return;
            btn.dataset.bound = '1';
            btn.addEventListener('click', () => {
                const want = btn.dataset.achview === 'card' ? 'card' : 'list';
                if ((state.achMatrixView || 'list') === want) return;
                state.achMatrixView = want;
                state.achMatrixPage = 1;
                scope.querySelectorAll('[data-achview]').forEach(b => b.classList.toggle('active', b.dataset.achview === want));
                _achMatrixPaint(scope);
            });
        });

        // 工具栏：搜索（防抖，避免每敲一个字就重绘）
        scope.querySelectorAll('[data-achq]').forEach(inp => {
            if (inp.dataset.bound === '1') return;
            inp.dataset.bound = '1';
            inp.addEventListener('input', () => {
                if (scope._achMxSearchTimer) clearTimeout(scope._achMxSearchTimer);
                scope._achMxSearchTimer = setTimeout(() => {
                    state.achMatrixQuery = inp.value || '';
                    state.achMatrixPage = 1;
                    _achMatrixPaint(scope);
                }, 250);
            });
        });

        // 空态 CTA
        scope.querySelectorAll('[data-achempty="sync"]').forEach(btn => {
            if (btn.dataset.bound === '1') return;
            btn.dataset.bound = '1';
            btn.addEventListener('click', () => {
                const sync = (scope.querySelector && scope.querySelector('#sglv-ach-real-sync'))
                    || (document.querySelector ? document.querySelector('#sglv-ach-real-sync') : null);
                if (sync && !sync.disabled) { sync.click(); return; }
                showToast(isZh ? '当前没有待同步的游戏' : 'Nothing to sync');
            });
        });

        // 游戏行 / 侧栏最近解锁 → 成就明细弹窗
        scope.querySelectorAll('[data-achgame]').forEach(el => {
            if (el.dataset.bound === '1') return;
            el.dataset.bound = '1';
            el.addEventListener('click', () => _achOpenGameDetail(el.dataset.achgame));
            el.addEventListener('keydown', (e) => {
                if (e.key === 'Enter' || e.key === ' ') { e.preventDefault(); _achOpenGameDetail(el.dataset.achgame); }
            });
        });
    }

    // ====== v2.44.0：自定义成就徽章架（弱化后的位置） ======
    // 自定义成就是「本地游戏库指标换皮」的趣味收藏，不参与主指数、不占导航、不占首屏，
    // 收进页面底部的可折叠徽章架。功能完整保留，只是不再冒充成就页的主角。
    // ⚠️ 展开/收起只切 class，不重建 DOM —— 重建会把主区滚动位置顶回顶部。
    function _achShelfHtml(achievements, unlocked, totalPts, maxPts, achLevel, noReal) {
        const achs = Array.isArray(achievements) ? achievements : [];
        const un = achs.filter(a => a.unlocked);
        // 用户手动操作过就以用户为准；否则在「一条真实成就都没有」时自动展开，
        // 避免整个成就页空荡（过渡期内容），但绝不因此把徽章架摆回首屏。
        const open = state.achShelfTouched ? !!state.achShelfOpen : !!noReal;
        const head = `
            <button class="sglv-ach-shelf-head" type="button" data-achshelf="toggle" aria-expanded="${open ? '1' : '0'}">
                <span class="sglv-ach-shelf-title">${isZh ? '自定义成就徽章架' : 'Custom badge shelf'}</span>
                <span class="sglv-ach-shelf-summary">${un.length}/${achs.length} · Lv.${achLevel} · ${totalPts}/${maxPts} ${isZh ? '分' : 'pts'}</span>
                <span class="sglv-ach-shelf-caret">${open ? '▾' : '▸'}</span>
            </button>`;
        const body = achs.map(a => `<div class="sglv-ach-badge ${a.unlocked ? 'on' : 'off'} ${a.rarity}" title="${escHtml(a.desc)}">
                <div class="sglv-ach-badge-icon">${a.icon}</div>
                <div class="sglv-ach-badge-name">${escHtml(a.name)}</div>
                <div class="sglv-ach-badge-bar"><i style="width:${a.unlocked ? 100 : Math.round(a.progress)}%"></i></div>
            </div>`).join('');
        return `
            <div class="sglv-ach-shelf ${open ? 'open' : ''}" data-achshelf>
                ${head}
                <div class="sglv-ach-shelf-body">
                    <div class="sglv-ach-shelf-grid">${body}</div>
                    <div class="sglv-ach-shelf-foot">
                        <span>${isZh
                            ? '自定义成就由本地游戏库指标计算（游戏数 / 时长 / 专精度），与 Steam 真实成就无关，仅作趣味徽章。'
                            : 'Custom achievements are computed from local library metrics — a novelty badge shelf, unrelated to Steam achievements.'}</span>
                        <button class="sglv-ach-reset-btn" id="sglv-ach-reset">${T.achResetBtn}</button>
                    </div>
                </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), 0);
        const maxPts = achievements.reduce((s, a) => s + (a.pts || 0), 0);
        const achLevel = Math.floor(totalPts / 100) + 1;

        // 当前左栏导航（游戏维度）
        const navView = state.achNavView || 'all';
        // Steam 子视图：游戏成就矩阵 / 聚合分析
        const steamView = (state.achSteamView === 'insights') ? 'insights' : 'games';

        let steamS = null, steamD = null;
        try { steamS = ACH_REAL.summary(); } catch (e) { steamS = null; }
        try { steamD = ACH_REAL.deep(); } catch (e) { steamD = null; }
        const achIndex = _achIndexParts(achievements, steamS, steamD);
        const counts = _achNavCounts(steamD, steamS);
        const recent = (steamD && Array.isArray(steamD.recentUnlocks)) ? steamD.recentUnlocks : [];

        const html = `
            <div class="sglv-ach-layout">
                ${_achSidebarHtml(navView, counts, recent)}

                <!-- ====== 右侧主内容区 ====== -->
                <div class="sglv-ach-main">
                    ${_achHeaderHtml(achIndex)}
                    <div class="sglv-ach-switch">
                        <button class="sglv-ach-switch-btn ${steamView === 'games' ? 'active' : ''}" type="button" data-achsub="games">
                            ${isZh ? '游戏成就' : 'Games'} <b>${counts.synced}</b>
                        </button>
                        <button class="sglv-ach-switch-btn ${steamView === 'insights' ? 'active' : ''}" type="button" data-achsub="insights">
                            ${isZh ? '聚合分析' : 'Insights'} <b>${counts.perfect + counts.rare + counts.gap}</b>
                        </button>
                    </div>
                    <div class="sglv-ach-tracks">
                        <!-- Steam 真实成就（主体）：同步状态条 + 游戏矩阵 / 聚合分析 -->
                        <div class="sglv-ach-track sglv-ach-track-steam active" data-achtrack="steam">
                            ${(() => {
                                try {
                                    return `<div class="sglv-ach-realwrap" id="sglv-ach-realwrap">${_achRealBlockHtml()}</div>`;
                                } catch (e) {
                                    console.warn('[SGLV] 真实成就区渲染失败', e);
                                    return '';
                                }
                            })()}
                            <div class="sglv-ach-subview ${steamView === 'games' ? 'active' : ''}" data-achsubview="games">
                                ${(() => {
                                    try { return _achMatrixHtml(steamD, navView); }
                                    catch (e) { console.warn('[SGLV] 游戏成就矩阵渲染失败', e); return `<div class="sglv-ach-empty">${isZh ? '矩阵渲染失败，详见控制台' : 'Matrix render failed - see console'}</div>`; }
                                })()}
                            </div>
                            <div class="sglv-ach-subview ${steamView === 'insights' ? 'active' : ''}" data-achsubview="insights">
                                ${(() => {
                                    try { return _achDeepHtml(); }
                                    catch (e) { console.warn('[SGLV] 聚合分析渲染失败', e); return ''; }
                                })()}
                            </div>
                        </div>
                    </div>
                    ${_achShelfHtml(achievements, unlocked, totalPts, maxPts, achLevel, !counts.synced && !counts.private)}
                </div>
            </div>
        `;

        parent.innerHTML = html;
        // 矩阵里的「立即同步」CTA 需要绑定（innerHTML 替换会丢事件）
        try { _achMatrixBind(parent); } catch (e) { /* ignore */ }

        // 子视图切换（游戏成就 / 聚合分析）——只切 class，不重建 DOM
        const switchSub = want => {
            state.achSteamView = want;
            parent.querySelectorAll('[data-achsub]').forEach(b => b.classList.toggle('active', b.dataset.achsub === want));
            parent.querySelectorAll('[data-achsubview]').forEach(v => v.classList.toggle('active', v.dataset.achsubview === want));
            if (want === 'insights') { try { _achDeepBind(parent); } catch (e) { /* ignore */ } }
        };
        parent.querySelectorAll('[data-achsub]').forEach(btn => {
            btn.addEventListener('click', () => {
                const want = btn.dataset.achsub === 'insights' ? 'insights' : 'games';
                // ⚠️ 必须比对【实时 state】，不能比对渲染时的快照 steamView ——
                //   快照永远是首次渲染时的那个值：切到「聚合分析」后再点「游戏成就」，
                //   快照仍等于 'games' → 直接 return → 表现为「游戏成就点击无反应」。
                if ((state.achSteamView || 'games') === want) return;
                switchSub(want);
            });
        });

        // 左栏游戏维度导航
        parent.querySelectorAll('[data-achnav]').forEach(el => {
            el.addEventListener('click', () => {
                const want = el.dataset.achnav;
                if ((state.achNavView || 'all') === want) return;
                state.achNavView = want;
                state.achSteamView = 'games';
                renderMyAchievementsTab(parent);
            });
        });

        // 游戏行 / 最近解锁 → 打开该游戏的成就明细弹窗（统一由 _achMatrixBind 绑定，避免重复绑定）

        // 徽章架展开/收起——只切 class，不重建 DOM（重建会把主区滚动位置顶回顶部）
        const shelfToggle = parent.querySelector('[data-achshelf="toggle"]');
        if (shelfToggle) {
            shelfToggle.addEventListener('click', () => {
                const shelf = parent.querySelector('[data-achshelf]');
                if (!shelf) return;
                const isOpen = shelf.classList.toggle('open');
                state.achShelfOpen = isOpen;
                state.achShelfTouched = true;
                shelfToggle.setAttribute('aria-expanded', isOpen ? '1' : '0');
                const caret = shelfToggle.querySelector('.sglv-ach-shelf-caret');
                if (caret) caret.textContent = isOpen ? '▾' : '▸';
            });
        }

        // 重置按钮事件（重置自定义成就的解锁时间缓存）
        const resetBtn = parent.querySelector('#sglv-ach-reset');
        if (resetBtn) {
            resetBtn.addEventListener('click', () => {
                if (confirm(T.achResetConfirm)) {
                    GM_setValue(_ACH_CACHE_KEY, '{}');
                    renderMyAchievementsTab(parent);
                }
            });
        }

        // 真实成就区块：绑定同步按钮 + 首次静默起一轮（任何异常都不能影响成就页主渲染）
        try { _achRealBind(parent); } catch (e) { console.warn('[SGLV] 真实成就区事件绑定失败', e); }
        try { _achDeepBind(parent); } catch (e) { console.warn('[SGLV] 深度面板事件绑定失败', e); }
        try { _achRealAutoKick(parent); } catch (e) { console.warn('[SGLV] 真实成就自动同步启动失败', e); }

        // IDB 缓存尚未 hydrate：先出占位文案，读完立刻局部刷新真实成就区。
        // 不阻塞整页渲染，也不清空已有 DOM，避免「打开后长时间空白」
        try {
            if (!ACH_REAL.isReady()) {
                ACH_REAL.ready().then(ok => {
                    if (!ok) return;
                    try { _achRealRefresh(parent); } catch (e) { console.warn('[SGLV] 缓存读完后刷新真实成就区失败', e); }
                });
            }
        } catch (e) { console.warn('[SGLV] 成就缓存预热失败', e); }
    }

 // ==================== 个人展柜标签页 ====================
 // 设计目标：展示玩家游玩魅力与口味喜好，支持自定义 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)) {
 //兼容 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) { /* 静默 */ }
 //配置变更后展柜缓存失效无需显式重置 — _swrReadShowcaseCache 的
 // configHash 比对(每次渲染现算 _computeShowcaseCacheHash)自然触发刷新
    }

 // ==================== 展柜持久化缓存层 ====================
 // 设计目标：跨 session 持久化展柜数据，页面刷新后立即可用，
 // 未变化的用户配置（封面/徽章）不失效，配合 SWR 模式后台静默刷新。
 //
 // 缓存结构: { schemaVer, timestamp, steamId, configHash, data: { profile, recentGames, badges, achievements, stats } }
 // configHash = 用户配置签名 + 游戏库规模签名，用于判断缓存是否仍然有效
 //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: 写失败只告警一次,避免刷屏

 //缓存只保留已解锁成就 — 全量成就(含锁定)大库用户可达数万条,
 // 展柜渲染仅消费 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) {
 //超配额/序列化失败不再静默 — 告警一次(缓存失败仅影响秒开体验,不影响功能)
            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
 //传递 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> 元素（带回退）
 //改走统一图标回退链（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 {
 //迁移至 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 {
 //迁移至 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 || '',
 //统一经 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 || '',
 //统一经 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 || '',
 //统一经 getGameIconUrl（community_assets 新路径 + icon 成功缓存）
                iconUrl: getGameIconUrl(g.appid, g.icon),
            }));
    }

 // ==================== 徽章自定义展示 ====================
 // 从 Steam 社区徽章页面抓取徽章图标 URL（GetBadges API 不返回图片）
 // 参考 steam-badges-card-view 的 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 {
 //迁移至 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);
    }

 // 徽章选择器弹窗——使用 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,
        });
    }

 //渲染展柜标签页 — SWR 模式
 // 流程: 骨架屏 → 持久化缓存快渲染 → 后台静默刷新 → 签名比对（未变化不重渲染）
 //拆分渲染/数据准备——本函数只消费缓存(骨架/缓存直渲染),
 // 后台刷新(网络拉取+签名比对+重渲染)外提至 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;
            }
        }
    }

 //展柜数据准备(自 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: 后台静默刷新（缓存过期/配置变更/无缓存时获取最新数据）
 //与预热共享 in-flight 抓取(重复进入只发一轮请求)
        const data = await _fetchShowcaseDataAll();

 // 防止并发渲染竞态：刷新期间用户切换标签页则放弃本次渲染
        if (myToken !== state.showcaseRenderToken) return;

 // 统计数据
        const { profile, recentGames, badges: allBadges, stats } = data;
 //缓存只持久化 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;
    }

 //展柜英雄区段渲染器（头像/等级/国旗 + 徽章槽 + 统计行,自 _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>`
            : '';

 //=== 徽章展示区 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>`;
    }

 //封面网格卡片段（含编辑入口,自 _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>`;
    }

 //最近游玩时长卡片段（条形行经 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>`;
    }

 //最近解锁成就卡片段（自 _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>`;
    }

 //玩家画像标签卡片段（含标签文案表,自 _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>`;
    }

 //展柜后处理与事件绑定段（封面/图标 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);
                });
            });
        }

 //=== 编辑徽章按钮事件 ===
        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);
                });
            });
        }

 //=== 徽章点击跳转 / 空位点击打开选择器 ===
        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');
            });
        });
    }

 //展柜内容渲染（从预获取数据构建 HTML + 绑定事件）
 //降级为组装器——数据组装 + 五段渲染按文档序消费 + 事件绑定委托
    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));

 //选中徽章组装层一次计算（英雄区段与事件绑定共享）
        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);
    }

 // 封面选择器弹窗（内嵌于游戏库浮窗内，不隐藏浮窗本身）
 //迁移 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,
        });
    }

 // ==================== 渲染主体 ====================
 //Tab 渲染分发表——8 Tab 入口集中注册,
 // renderBody 由 if-else 链改表查找;needsOwned 标记依赖 ownedGames 的 Tab
 // (原 _ownedDepTabs 数组语义内联,新 Tab 一处注册全生效);
 //新增 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 {
 //同步设置按钮高亮态（设置视图覆盖展示时点亮 ⚙）
        const _setBtn = panelEl.querySelector('.sglv-settings-btn');
        if (_setBtn) _setBtn.classList.toggle('sglv-active', !!state.showSettings);

        if (state.showSettings) {
 //设置内容直接覆盖渲染在游戏库浮窗内（不再弹出独立浮层）
            renderSettingsView(body);
            return;
        }

 //依赖 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;
        }

 //表查找分发,未注册 Tab 空渲染 + 警告
        if (spec) {
            spec.render(body);
 //渲染后追加数据准备步骤(fetch 外提),
 // 对齐 SGIS renderTab 的 prepare 模式;无 prepare 项的 Tab 不变
            if (spec.prepare) spec.prepare(body);
        } else {
            console.warn('[SGLV] 未知标签页，跳过渲染:', state.activeTab);
        }
        } catch (e) {
 //渲染失败时显示错误提示，不留空白面板
            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>`;
        }
    }

 //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;
    }

 // ==================== 趋势标签页 ====================
 //精简: 三处重复的"家庭组其他成员(排除自己)"构造逻辑(趋势页/渐进式更新预热/
 // KPI 局部 patch)收敛为此共享函数; 条件不满足返回空数组,行为与原内联 if 块完全一致。
    function getFamilyOtherMembers(allGames, steamId) {
        const hasOwnerData = steamId && allGames.some(g => g.owners && g.owners.length > 0);
        if (!(storage.getShowFamilyShared() && hasOwnerData && steamId)) return [];
        const nameMap = storage.getFamilyInfo()?.steamIdtoName || {};
        return Object.entries(nameMap)
            .filter(([sid]) => sid !== steamId)
            .map(([sid, name]) => ({ steamid: sid, name }));
    }

 //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++;
        });

 // 周均入库
 //活跃天数（有入库记录的独立天数）
        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] || '-';

 //第一行 4 卡 —— 基础统计；经 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' });

 //第二行 4 卡 —— 频率维度；经 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 = getFamilyOtherMembers(allGames, steamId);

 //一次性计算所有年度统计并走 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;

 // ====== 8 个 KPI 卡片分两行显示，增加入库频率维度 ======
 //KPI 值计算与双行组装拆至 _trendKpiCardsHtml
        const kpiSection = document.createElement('div');
        kpiSection.className = 'sglv-trend-kpi-wrap';
        kpiSection.innerHTML = _trendKpiCardsHtml(yearlyStats, personalTotal, totalGames, allGames);

 // ====== 入库趋势动态——左侧入库趋势图（不变）+ 右侧入库时间线 ======
 //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);

 // 右：标签切换（入库时间线 / 入库频率分析）
        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);

 //使用 requestAnimationFrame 替代 setTimeout，对齐浏览器渲染周期减少卡顿
        requestAnimationFrame(() => renderTrendChart(yearlyStats, leftCol.querySelector('#sglv-trend-chart-main'), { isEstimated, familyCumStats, personalYearlyStats, familyYearlyStats, hasOwnerData }));
        renderAcquiredTimeline(rightCol, allGames);

 //右侧标签切换
        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);
    }

 // ====== 入库频率分析——带缓存的统计计算 + 图表渲染 ======
 //豁免留痕: 频次图为 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 {
 //个人拥有的游戏按个人许可页日期校准（家人新入库共拥游戏不改变我的入库日期）
                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 = '';

 //优化 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;
            }
 //手写 Math.ceil/clamp/slice 分页收敛 paginate()(逻辑逐行同构)
            const pg = paginate(items, page, PAGE_SIZE);
            page = pg.page;
 //时间线卡迁移 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>`,
            });
 //异步加载游戏中文名
            applyGameAliases(scrollEl);
            renderPagination(pagiEl, 'sglv-tl', page, pg.totalPages, items.length,
                () => { page--; renderList(); },
                () => { page++; renderList(); },
                (p) => { page = p; renderList(); });
        }

 //debounce 搜索输入，避免时间线列表每次按键触发完整重渲染
        searchEl.addEventListener('input', debounce(() => {
            query = searchEl.value.trim().toLowerCase();
            page = 1;
            renderList();
        }, 200));

        renderList(); // 加载占位
        (async () => {
            try {
 //个人拥有的游戏按个人许可页日期校准（家人新入库共拥游戏不改变我的入库日期）
                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 };
    }

 // ==================== 持久化版本(基于 PCC) ====================
 // 给大数据计算函数加缓存包装,通过输入签名 + schema 版本自动判断是否重算
 // 输入签名:游戏数 + acquiredTime 累计 + lastPlayed 累计(避免简单 length 不够,例如库存没变但补全了 acquiredTime)
 // schema 版本号:业务逻辑变更时手动 +1 强制全量重算
    const _BIZ_SCHEMA_YEARLY = 1;
    const _BIZ_SCHEMA_INSIGHT = 1;
    const _BIZ_SCHEMA_ACHIEVEMENTS = 1;

 //生成大数据计算输入签名(基于 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 || ''}`;
    }

 //持久化年度统计(整体 + 个人 + 家庭组)
 // 返回 { 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 };
        });
    }

 //持久化我的成就标签页(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();
        });
    }

 //完整版洞察数据(从 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 },
        };
    }

 //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;
    }

 //主柱 hover tooltip 装配自 renderTrendChart 抽出——
 // 数据源全为柱上 data-* 属性(几何无关),依赖经 cfg 传入
    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'; });
        });
    }

 // ==================== SVG 图表基础库(共享命名空间) ====================
 // 设计目标:提供最小可用 SVG 工具集,统一风格(深色背景 + 渐变 + 暖色),
 // 现有图表(renderTrendChart/Daily/Donut 等)继续工作,新图表/外部模块可基于此扩展。
 // 借鉴 steam-friend-manager 大量 SVG 图表代码经验

    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 布局参数（画布/内边距默认值在 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);

 //网格/双轴刻度/柱/折线/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) => {
 //图例项变为可交互——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>
        `;

 //成员对比摘要 — 贡献最多 / 最少 / 平均
        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;

 //图例交互 — hover 高亮对应成员柱，其余变暗
 //缓存 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（主柱触发）— bindTrendBarTooltip,数据源为柱上 data-* 属性
        bindTrendBarTooltip(container, { hasMemberBars, hasFamilyLines, hasPersonalLine, hasPersonalBar, familyYearlyStats, familyCumStats, memberColors });
    }

 // ==================== 设置面板 ====================
 // ==================== 设置集成进游戏库主面板（移除独立浮层） ====================
 // 点击 header 的 ⚙ 设置按钮 → 设置视图在 #sglv-body 内覆盖展示（完整嵌入浮窗），
 // 再次点击 ⚙、点击"返回游戏库"或切换任意标签页即可退出设置。

    function openGlobalSettings() {
        if (!panelEl) return;
 // 保留原函数名兼容既有调用点：先确保主面板可见，再在面板内展示设置
        openPanel();
        state.showSettings = true;
        renderBody();
    }

    function closeGlobalSettings() {
        if (!state.showSettings) return;
        state.showSettings = false;
        renderBody();
    }

 //设置视图渲染——卡片式分区布局，完整嵌入游戏库浮窗 #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>
${_hasApiKeyConsent() ? `
                        <input type="password" class="sglv-set-input" id="sglv-gs-apikey" value="${storage.getApiKey()}" placeholder="Steam Web API Key">
` : `
                        <!-- v2.45.0：未取得同意前不提供填写入口 —— 不能设置 Key，也不能加载数据 -->
                        <div class="sglv-set-locked" id="sglv-apikey-locked">
                            <div class="sglv-set-locked-title">🔒 ${isZh ? '尚未同意配置 API Key' : 'You have not agreed to configure an API key'}</div>
                            <div class="sglv-set-locked-desc">${isZh
                                ? 'API Key 是一枚敏感凭据。点击下方按钮先了解它的用途、数据流向与风险，确认同意后才能填写。'
                                : 'An API key is a sensitive credential. Read how it is used, where the data goes and what the risks are before you can fill it in.'}</div>
                            <button class="sglv-set-locked-btn" id="sglv-apikey-unlock" type="button">${isZh ? '查看用途与风险并解锁' : 'Show risks & unlock'}</button>
                        </div>
`}
                    </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>
                        <!-- v2.42.2 安全：这三个值可能来自 unsafeWindow.SteamAgent（页面上下文可写）
                             → 未经 escHtml 进 value 属性可闭合属性注入任意属性/事件。 -->
                        <input type="text" class="sglv-set-input" id="sglv-gs-ai-url" value="${escHtml(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="${escHtml(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="${escHtml(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);

 //主题选项选中态联动（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);
                });
            });
        });

 //v2.45.0 API Key 同意门：未同意前设置页不提供填写入口 —— 点「解锁」先看用途与风险
        const apikeyUnlockBtn = wrap.querySelector('#sglv-apikey-unlock');
        if (apikeyUnlockBtn) {
            apikeyUnlockBtn.addEventListener('click', async () => {
                apikeyUnlockBtn.disabled = true;
                const agreed = await _openApiKeyConsent();
                apikeyUnlockBtn.disabled = false;
                if (!agreed) {
                    showToast(isZh ? '未同意配置 API Key' : 'Consent declined');
                    return;
                }
                renderBody();   // 重新渲染设置视图 —— 输入框解锁
            });
        }

        wrap.querySelector('#sglv-gs-save').addEventListener('click', () => {
 //v2.45.0：未解锁时输入框不存在 —— 不能凭空把 Key 清空
            const apikeyEl = wrap.querySelector('#sglv-gs-apikey');
            if (apikeyEl) storage.setApiKey(apikeyEl.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']);
 //保存家庭组共享开关
            storage.setShowFamilyShared(wrap.querySelector('#sglv-gs-family-toggle').checked);
 //保存 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);
 //保存 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.45.0：用户是被同意门引导到设置页来的 —— 填好 Key 保存后，自动续跑那次被拦下的加载
            if (_pendingFetchAfterKey) {
                _pendingFetchAfterKey = false;
                if (storage.getApiKey()) {
                    setTimeout(() => { try { startFetch(true); } catch (e) { console.warn('[SGLV] 同意门续跑拉取失败:', e); } }, 900);
                }
            }
        });

 //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 {
 //走带原生 fetch 兜底的测试入口，错误消息归一化（修复 Steam 客户端 undefined.match）
                    const result = await _sglvItadTestConnection(testKey);
                    if (result && result.success) {
                        resultEl.innerHTML = '<span style="color:#a7d54f">✅ ' + T.itadConnSuccess + ' · ' + (isZh ? '商店数' : 'Shops') + ': ' + result.shopCount + '</span>';
                    } else {
                        const errMsg = (result && result.error) ? String(result.error) : 'unknown error';
                        resultEl.innerHTML = '<span style="color:#e63946">❌ ' + T.itadConnFail + ': ' + errMsg + '</span>';
                    }
                } catch (e) {
                    const errMsg = (e && e.message) ? String(e.message) : String(e || 'unknown error');
                    resultEl.innerHTML = '<span style="color:#e63946">❌ ' + T.itadConnFail + ': ' + errMsg + '</span>';
                } finally {
                    itadTestBtn.disabled = false;
                    itadTestBtn.textContent = T.itadTestConn;
                }
            });
        }

        body.appendChild(wrap);
    }

 // ==================== Barter.vg Bundle 数据库 (进包历史·离线程动态加载) ====================
 // 数据源: https://bartervg.com/browse/bundles/json/
 // 返回格式: {"18500":{"bundles":5,"bundles_packages":3},"232810":{"bundles":1},...}
 // Key 是 appID 字符串, value.bundles = 进过的包数量
 //原始 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/';
 //使用缓存版本号系统自动管理 schema 升级
    const BUNDLE_DB_CACHE_KEY = 'sglv_bundle_db_cache';        // 旧版大体积缓存（废弃，加载成功后清空）
    // 注：BUNDLE_DB_CACHE_KEY_V2 已提升到主闭包顶层（见 nsKey 定义处）——
    // v2.42.2 修复跨闭包不可见导致旧缓存不失效的问题。
    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;
                    }
                }
 //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 {
 //负缓存——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 精简缓存命中条件——未过期且覆盖当前全部库存 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);
 //失败入负缓存
            negCacheSet(BUNDLE_DB_NEG_KEY, e.message || String(e));
            sglvNotifyNetFail('Bundle 数据库 (Barter.vg)', e);   // v2.9.114: 终态失败系统通知(60s 节流)
            return null;
        } finally {
            bundleDbLoading = false;
        }
    }

 // ==================== 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';
 //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);
 //双源检测——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;
    }

 //同步从缓存加载 DLC 数据库（GM_getValue 同步读取）
 // 在 renderGamesList() 首次渲染前调用，确保 isDlc() 可用
 // 避免总游戏数在 DLC 数据库异步加载前错误包含 DLC 数量
 //同时从缓存加载 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);
            }
        }
 //同步加载全库存应用类型缓存
        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;
    }

 // ==================== 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;
    }

 //增量式 DLC 类型获取 — 只获取 dlcTypeMap 中不存在的类型,合并而非替换
 // 支持 onProgress 回调供渐进式渲染,支持 options 参数扩展
    async function enrichDlcTypes(dlcAppIds, options = {}) {
        if (!dlcAppIds || dlcAppIds.length === 0) return;
        const { onProgress } = options;

 //如果正在加载,等待完成后再检查增量(避免并发请求)
        if (dlcTypeLoading) {
            console.log('[SGLV] enrichDlcTypes — 等待已有加载完成...');
            let waitCount = 0;
            while (dlcTypeLoading && waitCount < 60) {
                await new Promise(r => setTimeout(r, 500));
                waitCount++;
            }
        }

 //先尝试从 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} 条`);
            }
        }

 //增量模式 — 只获取 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);

 //合并新类型到 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;
        }
    }

 // ==================== 全库存应用类型获取（补充 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';
 //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 {
 //负缓存——全失败时短期不再重试,保护 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++;
 //进度回调（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() });
 //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);
 //失败入负缓存
                negCacheSet(nsKey('app_types_neg'), e.message || String(e));
                return null;
            } finally {
                appTypePromise = null;
            }
        })();
        return appTypePromise;
    }

 // ==================== 游戏橱窗标签页 ====================
    function renderOwnedTab(parent) {
 //恢复持久化的排序偏好
        state.ownedSort = storage.getOwnedSort();
 // 顶部统计仪表板
        const dashboard = document.createElement('div');
        dashboard.className = 'sglv-stats-dashboard';
        dashboard.id = 'sglv-owned-dashboard';
        parent.appendChild(dashboard);

 // 工具栏（获取按钮已合并到面板头部刷新按钮）
 //紧凑布局——第1行搜索+排序+视图切换+分页；筛选改为点击上方 KPI 卡片
 //工具栏经 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 }) => {
 //debounce 搜索输入（工厂内统一 200ms），避免大库场景每次按键触发完整重渲染
                if (type === 'input') { state.searchQuery = value; state.page = 1; renderGamesList(); }
 //排序下拉——切换后持久化并重置到第一页；按入库时间排序时后台补齐缺失的入库时间
                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);

 //KPI 卡片点击筛选——点击统计卡片切换筛选状态
        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);

 //在首次渲染前同步从缓存加载 DLC 数据库（GM_getValue 同步读取）
 // 确保 dlcDbData 已从缓存载入，使首次 renderGamesList() 的 isDlc() 即可正确工作
 // 避免总游戏数在 DLC 数据库加载前错误包含 DLC 数量
        loadDlcDatabaseFromCacheSync();

        renderGamesList();
    }

 //库存 Tab 数据准备(自 renderOwnedTab 外提)
 // Bundle/卡牌/DLC 数据库异步加载与全库存类型补全——加载完成后刷新仪表板
 // (各数据库函数自带 in-flight/缓存保护,重复进入不产生额外网络请求)
    function prepareOwnedTabData() {
 //异步加载 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));
        }
 //DLC 数据库已在前方调用 loadDlcDatabase() 启动加载；
 //DLC 数据库加载后，启动全库存应用类型获取（补充 Barter.vg 未覆盖的 DLC）
        loadDlcDatabase().then(() => {
            if (document.getElementById('sglv-owned-dashboard')) {
                renderGamesList();
            }
 //用 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));
    }

 //KPI 仪表板——自 renderGamesList 拆出（纯展示段搬移，逻辑未动）
    function renderOwnedKpiSummary(dashboard, showFamilyShared) {
 //游戏与 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;
 //修复库存标签页与统计仪表总时长不一致——
 // 历史实现仅累加 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;
 //进包/卡牌游戏统计（仅游戏，不含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;
 //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...');
 //改经 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));
        }

 //所有筛选排除 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));
        }

 //排序——默认 AppID 升序，修复原列表顺序不明的问题；次级键 AppID 保证顺序稳定确定
 //缓存 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);
        });

 // 更新统计仪表板（依据“是否显示家庭共享”当前设置）
 //KPI 仪表板段拆出为 renderOwnedKpiSummary（纯展示搬移）
        if (dashboard) renderOwnedKpiSummary(dashboard, showFamilyShared);

 // 分页
 //复用 paginate 纯函数统一分页计算
 //封面视图每页 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;
        }

 //横版封面视图——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') {
 //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 {
 //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(); });

 //异步加载游戏中文名（参考 steam-friend-manager loadGameZhName）
 //列表视图改用 loadGameNameAlias 追加灰色别名（中英文互补），卡片视图保持原替换逻辑
 //改经 applyGameAliases 统一回填入口（aliasFor=列表视图灰色别名语义）
        applyGameAliases(content, { aliasFor: '.sglv-list-name' });
    }

 //按入库时间排序时，若当前库数据缺少 acquiredTime（如缓存/抓取来源），
 // 后台拉取家庭组数据补齐后重渲染，避免排序看似无效
    let _acquiredEnrichPending = false;
    function enrichAcquiredTimesForSort() {
        if (_acquiredEnrichPending) return;
        if (!state.ownedGames.length || state.ownedGames.some(g => g.acquiredTime > 0)) return;
        _acquiredEnrichPending = true;
 //个人拥有的游戏按个人许可页日期校准后再补齐（家人新入库共拥游戏不改变我的入库日期）
        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; });
    }

 // ==================== 游玩时长标签页 ====================
 //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' });

 //手写 SVG 绘制段(~45 行)迁移 SGLVCharts.lineChart(area 形态)。
 // 数据整形(分桶/区间补零/截尾)与缓存 key 不变;原视觉语义全量注入:
 // 渐变 0.4→0.02/单点居中/均值虚线(均 Xh)/峰值标注/圆点描边/逐点 tooltip。
 // 几何坐标由 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 },
                ],
            });
        });
    }

 //renderPlaytimeDonut 数值千分位格式化 + 中心文字自适应字号
 //环形绘制迁移 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);
 //数值格式化——千分位分隔，避免大数字溢出甜甜圈中心
        const fmt = (n) => n.toLocaleString();
        const pct = (n) => (n / total * 100).toFixed(1);
 //中心文字自适应字号——根据格式化后字符串长度动态缩放，避免溢出
        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,
            }
        );
    }

 //入库热力图——参考 steam-family-game-analysis 的 buildHeatmapBlock 设计
 // 输入: games 数组（需含 acquiredTime 秒级时间戳）；输出 GitHub 式贡献热力图 SVG
 //新增缓存层——签名一致且 10 分钟内直接返回缓存的 HTML，跳过 SVG 重新计算
 //按年分割——新增年份选择器，默认展示最新年份；
 // "全部"视图保留跨年连续网格，并增加年份分隔线与年份标签
 //入库热力图骨架占位（GitHub 风格年份框架 + 灰格，无数据时也不会出现大片空白）
 //构建实现迁入共享区 SKELETONS.heatmap/monthly（createSkeleton 统一入口）
 //复用核查豁免结论: 本函数为「日历热力图」(日期驱动周网格+周对齐/
 // 离散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);

 //构建缓存签名——游戏数量 + 首尾 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'];
 //未来月份占位色（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 {
 //区分"已过但无数据"(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() });
                        }
                    }
                }
            }
 //年份分隔线 + 年份标签，仅跨年视图渲染；首个边界不画线避免与坐标轴重叠
            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>`;

 //图例与统计摘要合并为同一行——图例在左，统计在右，避免图例溢出容器右下角
            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);
 //当年也画完整 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;
        }

 //入库热力图与近6月入库增量分成两个独立容器——主热力图占满容器宽度，增量柱图作为独立 section 在 wrap 下方展示（不在热力图节点内）
        const html = `<div class="sglv-heatmap-block">
            ${filterHtml}
            <div class="sglv-heatmap-body">${views[defaultView]}</div>
        </div>`;
 //写入渲染缓存（含各年份视图，供年份切换直接复用）
        _heatmapRenderCache = { signature: sig, html, ts: Date.now(), views };
        return html;
    }

 //近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'];
 //侧栏紧凑尺寸（适配 260px 宽右栏，独立布局）
 //加高 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];
 //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>`;
        });
 //增加标题栏统计（总数 + 峰值/低谷标注），参考设计图
        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>`;
    }
    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`;
    }

 // ==================== 六维雷达图组件 ====================
 // 参考体育竞技管理游戏 UI 风格，将玩家游戏数据可视化为五维能力雷达图
 // 维度：库存规模、游玩时长、游玩率、深度完成、平均时长（铁杆指数恒为 0% 已移除）
 //每个维度采用不同炫彩颜色，避免全紫色单调
    function renderPlaytimeRadar(games, stats) {
        const cx = 110, cy = 110, R = 80;
 // 五维炫彩配色 — 每个维度独立颜色，区分不同雷达趋势
        const dimColors = ['#22d3ee', '#f59e0b', '#34d399', '#f472b6', '#38bdf8'];
        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] },
        ];
        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>`;
    }

 //雷达图右侧统计面板
 //每个维度使用匹配的炫彩颜色
    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] },
        ];
        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('');
    }

 //游玩仪表拆分——组装器 + 四段渲染器 + 统计纯计算函数。
 // 段序(=文档序): KPI 卡片 → 雷达图行 → 分布+趋势两栏 → 热力图+近6月增量。
 // 副作用标注: ①games 经 getCached('pt-games') 组装层计算一次,四段共享;
 // ②统计变量打包 stats 对象(KPI/雷达两段共享,hardcore* 仅雷达段消费);
 // ③_distMode 闭包封装在图表段内;④热力图异步 IIFE 闭包捕获本段容器与 games;
 // ⑤_heatmapRenderCache 全局(年份筛选读)由 renderAcquiredHeatmap 写入,段内只读。
 // 各段接入工厂现状(先前系列完成): KPI→kpiCards/雷达统计→hbarRow
 // /月度趋势→SGLVCharts.lineChart/热力图豁免。
    function computePlaytimeStats(games) {
        const totalGames = games.length;
 //与游戏橱窗标签页口径统一——取 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;
 //游玩率(已启动/总数) + 完成度(深度游玩 ≥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;
 //硬核玩家维度(雷达段消费)
        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 };
    }

 //KPI 数据卡片段(自 renderPlaytimeTab 拆出,纯展示搬移)
    function renderPlaytimeKpi(wrap, stats) {
        const kpiSection = document.createElement('div');
        kpiSection.className = 'sglv-playtime-kpi-row';
 //改经 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);
    }

 //六维雷达图 + 统计面板段(自 renderPlaytimeTab 拆出,纯展示搬移)
    function renderPlaytimeRadarRow(wrap, games, stats) {
 //六维雷达图 + 统计面板
        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)));

 //组装器——统计计算一次,四段按文档序消费
        const stats = computePlaytimeStats(games);
        renderPlaytimeKpi(wrap, stats);
        renderPlaytimeRadarRow(wrap, games, stats);
        renderPlaytimeChartRow(wrap, games);
        renderPlaytimeHeatmapRow(wrap, games);

        parent.appendChild(wrap);
    }

 //分布图 + 趋势图左右两栏段(自 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';

 // 左侧：时长分布甜甜圈（默认总时长维度，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);
 //默认渲染总时长维度（与"时长分布"标题语义一致）
        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);
        });
    }

 //入库热力图 + 近6月增量段(自 renderPlaytimeTab 拆出,纯搬移)
 // 异步 IIFE 闭包捕获本段容器与组装层 games;_heatmapRenderCache 全局由 renderAcquiredHeatmap 写入
    function renderPlaytimeHeatmapRow(wrap, games) {
 //入库热力图（替换原家庭组对比——该对比已在"游玩数据"标签页展示，避免重复）
 //左右分栏——热力图 + 近6月入库增量 并排展示
 //默认渲染空白骨架占位（年份框架 + 灰格），避免加载中底部大片空白
        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);

 //近6月入库增量作为右栏容器——与入库热力图左右并排
 //默认渲染 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 {
 //个人拥有的游戏按个人许可页日期校准（家人新入库共拥游戏不改变我的入库日期）
                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);
 //近6月入库增量——渲染到独立的 acquireSection 容器，与热力图平级，避免布局错位
                acquireSection.innerHTML = renderMonthlyAcquireChart(heatGames);
 //渲染后默认滚动到最右侧，直接展示最新数据
                const scrollHmRight = () => requestAnimationFrame(() => {
                    const s = heatmapEl.querySelector('.sglv-heatmap-scroll');
                    if (s) s.scrollLeft = s.scrollWidth;
                });
 //绑定年份选择器——点击切换单年/全部视图（各视图 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 + 全部游戏) ======
 // ==================== 游玩时长持久缓存 + 按周增量更新 ====================
 // 目标: ①进入标签页/浮窗零等待（本地快照直接出图，不等网络）
 // ②Steam 仅每 7 天拉一次 GetOwnedGames，且只把"发生变化的条目"写回库存（增量合并）
 // ③入库时间映射 / 家庭成员 Top20 同样持久化，跨 session 复用
 // 存储: 复用 cacheGet/cacheSet（GM 持久化 + TTL 信封）。
    const PT_WEEK_MS = 7 * 24 * 3600 * 1000;        // 游玩时长增量刷新周期：一周
    const PT_RETRY_MS = 6 * 3600 * 1000;             // 刷新失败后的重试间隔：6h（防失败风暴）
    const PT_FAM_TOP_N = 20;                         // 家庭成员展示的游戏数
    const PT_SNAP_KEY = 'ptPlaytimeSnapshot';        // { ts, att, map: { appid: [playtime, lastPlayed] } }
    const PT_ACQ_KEY = 'ptAcquiredMap';              // { ts, map: { appid: acquiredTs } }
    const PT_FAM_KEY = 'ptFamilyMembers';            // { members: { steamid: { t, c, ts, g: [[appid,name,pt,lp]…] } } }
    const PT_PERSIST_TTL = 365 * 24 * 3600 * 1000;   // 信封 TTL：长期保留，新鲜度由内部 ts 判定
    let _ptSnap = null;
    let _ptRefreshInflight = null;
    let _ptAcq = null;
    let _ptAcqInflight = null;

    function ptSnapLoad() {
        if (!_ptSnap) {
            const raw = cacheGet(PT_SNAP_KEY);
            _ptSnap = (raw && raw.map) ? raw : { ts: 0, att: 0, map: {} };
        }
        return _ptSnap;
    }
    function ptSnapSave() { try { cacheSet(PT_SNAP_KEY, _ptSnap, PT_PERSIST_TTL); } catch (e) { /* quota */ } }

 // 首次使用：用当前库存播种快照（ts 保持 0 → 仍会触发一次按周刷新）
    function ptSnapSeed(games) {
        const snap = ptSnapLoad();
        if (Object.keys(snap.map).length > 0 || !games || !games.length) return;
        const map = {};
        for (const g of games) map[g.appid] = [g.playtime || 0, g.lastPlayed || 0];
        snap.map = map;
        ptSnapSave();
    }

 // 把快照写回库存：只改变化的字段值，不重建数组、不动顺序（渲染依赖的顺序保持稳定）
    function ptSnapApplyToGames(games) {
        const snap = ptSnapLoad();
        let touched = 0;
        for (const g of games) {
            const v = snap.map[g.appid];
            if (!v) continue;
            if ((g.playtime || 0) !== v[0]) { g.playtime = v[0]; touched++; }
            if ((g.lastPlayed || 0) !== v[1]) { g.lastPlayed = v[1]; touched++; }
        }
        return touched;
    }

 // 按周增量刷新：快照新鲜 → 零请求；过期 → 拉一次 GetOwnedGames 并只合并变化条目
    function ptRefreshPlaytime(force = false) {
        const snap = ptSnapLoad();
        const now = Date.now();
        if (!force) {
            if (now - (snap.ts || 0) < PT_WEEK_MS) return Promise.resolve({ ok: true, skipped: true, changed: 0 });
            if (now - (snap.att || 0) < PT_RETRY_MS) return Promise.resolve({ ok: false, skipped: true, changed: 0 });
        }
        if (_ptRefreshInflight) return _ptRefreshInflight;
        snap.att = now;
        ptSnapSave();
        _ptRefreshInflight = (async () => {
            const steamId = getActiveSteamId();
            if (!steamId) return { ok: false, changed: 0 };
            const apiKey = storage.getApiKey();
            const token = apiKey ? null : await getAccessToken().catch(() => null);
            const url = apiKey
                ? `https://api.steampowered.com/IPlayerService/GetOwnedGames/v0001/?key=${apiKey}&steamid=${steamId}&include_played_free_games=1&format=json`
                : (token ? `https://api.steampowered.com/IPlayerService/GetOwnedGames/v1/?access_token=${token}&steamid=${steamId}&include_played_free_games=1` : '');
            if (!url) return { ok: false, changed: 0 };
            let list = null;
            try { list = (await requestSteamAPI(url))?.response?.games || []; } catch (e) { return { ok: false, changed: 0 }; }
            if (!list.length) return { ok: false, changed: 0 };
            let changed = 0;
            const next = {};
            for (const g of list) {
                const pt = g.playtime_forever || 0;
                const lp = g.rtime_last_played || 0;
                next[g.appid] = [pt, lp];
                const old = snap.map[g.appid];
                if (!old || old[0] !== pt || old[1] !== lp) changed++;
            }
 // 增量合并：Steam 本次未返回的旧条目保留（下架/家庭共享过期的条目不会丢数据）
            snap.map = Object.assign({}, snap.map, next);
            snap.ts = Date.now();
            ptSnapSave();
            ptSnapApplyToGames(state.ownedGames || []);
            if (state.ownedGames && state.ownedGames.length) {
                try { storage.setCachedGames(state.ownedGames); } catch (e) { /* quota */ }
            }
            return { ok: true, changed, total: list.length };
        })().catch(() => ({ ok: false, changed: 0 })).then(res => { _ptRefreshInflight = null; return res; });
        return _ptRefreshInflight;
    }

 // 入库时间映射持久缓存（家庭组 + 个人许可页校准，按周有效）：吃灰榜 / 入库时间排序共用
    function ptGetAcquiredMap(force = false) {
        const now = Date.now();
        if (!force) {
            if (_ptAcq && now - _ptAcq.ts < PT_WEEK_MS) return Promise.resolve(_ptAcq.map);
            const raw = cacheGet(PT_ACQ_KEY);
            if (raw && raw.map && now - raw.ts < PT_WEEK_MS) { _ptAcq = raw; return Promise.resolve(raw.map); }
        }
        if (_ptAcqInflight) return _ptAcqInflight;
        _ptAcqInflight = buildCalibratedAcquiredMap()
            .then(({ map }) => {
                const m = map || {};
                if (Object.keys(m).length > 0) {
                    _ptAcq = { ts: Date.now(), map: m };
                    try { cacheSet(PT_ACQ_KEY, _ptAcq, PT_PERSIST_TTL); } catch (e) { /* quota */ }
                }
                return m;
            })
            .catch(() => ({}))
            .then(res => { _ptAcqInflight = null; return res; });
        return _ptAcqInflight;
    }

 // ---- 家庭成员持久缓存（按周增量刷新） ----
 //引入内存镜像 _ptFamCache —— 供 PTW_HOST.familyCache 暴露给浮窗 Tab 库使用。
 // 原实现每次 ptFamLoad() 都走 cacheGet，读写分离对 Tab 库不友好（拿不到稳定引用）。
    let _ptFamCache = null;
    function ptFamLoad() {
        if (!_ptFamCache) {
            const raw = cacheGet(PT_FAM_KEY);
            _ptFamCache = (raw && raw.members) ? raw : { members: {} };
        }
        return _ptFamCache;
    }
    function ptFamSave(c) {
        _ptFamCache = c;
        try { cacheSet(PT_FAM_KEY, c, PT_PERSIST_TTL); } catch (e) { /* quota */ }
    }
    function ptFamIsStale(rec) { return !rec || Date.now() - (rec.ts || 0) >= PT_WEEK_MS; }

 // ====== 每日快照采集（IDB 滚动 90 天） ======
 //
 // 为什么需要：Steam 只给**累计**时长（playtime_forever），从不提供逐日历史。
 // 要算「连续游玩天数 / 年度游戏 / 首玩日期」必须有本地逐日采样，
 // 否则这三项只能凭空编造或永久显示为空。
 //
 // 数据模型（key = nsKey('pt_daily_history')，存 IDB 而非 GM）：
 // { v:1, days: { 'YYYY-MM-DD': { [appid]: playtimeMinutes } } }
 // 每天一份「全库累计时长快照」，由相邻两日快照**求差**得到当日各游戏增量。
 //
 // 关键设计（避免自欺）：
 // ① 只在**真实跨日**时写入，同日多次进入不覆盖 —— 否则日内重复采集会污染差值
 // ② 缺采的日子不补零、不插值 —— 历史空洞如实留空，下游 streak 只按实采日算
 // ③ 滚动窗口 90 天（PT_HISTORY_DAYS），超出即裁剪，防止 IDB 无限增长
 // ④ 首次启用时以当前库播种但不标记为有效采样日（ts 缺失），
 // 否则第一天会被误判为「一次性玩了 N 小时」
 // ⑤ v2.46.2 采样密度：写进某天的快照必须是**那天观测到的**累计时长。
 //   时长本体（PT_SNAP_KEY）按周刷新，若采集前不补一次，7 天里有 6 天写进去的是
 //   同一批数字 → 差值恒 0（日历读成「有采样但没玩」），第 7 天一次性爆发。
 //   这正是「拿快照相减当逐日用」—— 只有采样足够密才成立；提不了频就必须如实留空。
 //   刷新失败的样本仍写入（否则无 Key/令牌的用户永远没有历史），但打 meta.stale 标记，
 //   不把「没看准」伪装成「没游玩」。
 //PT_HISTORY_KEY / PT_HISTORY_DAYS / _ptHistory / _ptHistoryInflight 已上移至 PTW_HOST 之前
 // （PTW_HOST 装配与 _inspect() 会急切读取这些值，声明必须先于消费点）。

 /** 本地日期键（YYYY-MM-DD）。刻意用本地时区而非 UTC：streak 是「玩家所在地的自然日」 */
    function ptDayKey(ts) {
        const d = new Date(ts || Date.now());
        const p = (n) => String(n).padStart(2, '0');
        return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`;
    }

    function ptHistoryLoad() {
        if (!_ptHistory) {
            const raw = sglvIDB.get(PT_HISTORY_KEY, null);
            _ptHistory = (raw && raw.days) ? raw : { v: 1, days: {} };
        }
        return _ptHistory;
    }

    function ptHistorySave() {
        ptHistoryPrune();
        try { sglvIDB.set(PT_HISTORY_KEY, _ptHistory); } catch (e) { /* quota */ }
    }

 /** 滚动裁剪：只保留最近 PT_HISTORY_DAYS 个采样日（meta 同步裁，避免残留已删日的标记） */
    function ptHistoryPrune() {
        const h = ptHistoryLoad();
        const keys = Object.keys(h.days).sort();
        if (keys.length <= PT_HISTORY_DAYS) return 0;
        const drop = keys.slice(0, keys.length - PT_HISTORY_DAYS);
        drop.forEach(k => {
            delete h.days[k];
            if (h.meta) delete h.meta[k];
        });
        return drop.length;
    }

 /**
 * 采集今日快照。
 * @param {Array} games 游戏集（缺省用 state.ownedGames）
 * @param {{stale?:boolean, reason?:string}} [opts] stale=本日样本的时长未刷新成功（观测不完整）
 * @returns {{ok:boolean, written:boolean, reason?:string, day?:string, changed?:number, pruned?:number, staleRefresh?:boolean}}
 */
    function ptHistoryRecord(games, opts) {
        const h = ptHistoryLoad();
        const today = ptDayKey();
        const list = Array.isArray(games) ? games : [];

        if (!list.length) return { ok: false, written: false, reason: 'empty' };
 // 同日已采过 → 不覆盖（差值口径依赖「每个自然日恰好一份」）
        if (h.days[today]) return { ok: true, written: false, reason: 'same_day', day: today };

        const prevKeys = Object.keys(h.days).sort();
        const prevDay = prevKeys.length ? prevKeys[prevKeys.length - 1] : '';
        const prev = prevDay ? (h.days[prevDay] || {}) : {};

        const snap = {};
        let changed = 0;
        for (const g of list) {
            const pt = Math.max(0, Math.round(Number(g.playtime) || 0));
            if (pt <= 0) continue;
            snap[String(g.appid)] = pt;
            const before = Number(prev[String(g.appid)]) || 0;
            if (pt > before) changed++;
        }
        if (!Object.keys(snap).length) return { ok: false, written: false, reason: 'no_playtime' };

        h.days[today] = snap;
        // v2.46.2：观测不完整的日子单独留标记（与 days 同一次写入，不做二次落盘 ——
        // IDB 封装对同一 key 有写防抖，连写两次会丢后一次）
        if (opts && opts.stale) {
            if (!h.meta) h.meta = {};
            h.meta[today] = { stale: true, reason: String(opts.reason || 'stale'), ts: Date.now() };
        }
        const pruned = ptHistoryPrune();
        ptHistorySave();
        return { ok: true, written: true, day: today, changed, pruned, prevDay };
    }

 /** 采集入口（并发去重）。供 Tab 库调用，不抛错。 */
    function ptHistoryCollect(games) {
        if (_ptHistoryInflight) return _ptHistoryInflight;
        _ptHistoryInflight = (async () => {
            try {
                const explicit = Array.isArray(games) && games.length > 0;
                const today = ptDayKey();
                // 今天已写过 → 直接交回，不刷新（同日不覆盖，也没必要多打一次接口）
                if (ptHistoryLoad().days[today]) {
                    return { ok: true, written: false, reason: 'same_day', day: today };
                }
                // —— 采样密度自检（v2.46.2）：先让时长变成「今天的观测值」再落快照 ——
                // 显式传 games 的调用方（Tab 库自己挑了数据源）不代它发请求。
                let refresh = null;
                if (!explicit) {
                    const snap = ptSnapLoad();
                    if (Date.now() - (snap.ts || 0) >= PT_HISTORY_FRESH_MS) {
                        ptSnapSeed(state.ownedGames || []);
                        refresh = await ptRefreshPlaytime(true).catch(() => null);
                    }
                }
                const stale = !!(refresh && refresh.ok === false);
                const list = explicit ? games : (state.ownedGames || []);
                const rec = ptHistoryRecord(list, stale ? { stale: true, reason: 'refresh_failed' } : null);
                if (stale && rec && rec.written) {
                    rec.staleRefresh = true;
                    console.warn('[SGLV] 每日快照：采集前刷新时长失败，今日样本标记为「观测不完整」'
                        + '（差值可能跨多天重叠，不当作「今日未游玩」）');
                }
                return rec;
            } catch (e) {
                return { ok: false, written: false, reason: 'error', error: String((e && e.message) || e) };
            }
        })().then(r => { _ptHistoryInflight = null; return r; });
        return _ptHistoryInflight;
    }

 // ====== 游玩数据标签页 ======
 // 定位调整: 统计仪表=总览(你是谁), 游玩数据=排行+洞察(时间花在哪 / 哪些吃灰)。
 // 结构: HERO 摘要条 → Top 20 卡片占满剩余高度（列表自身滚动，v2.33.1 修复滚动链）;
 // 全部游戏排行迁移至独立全屏浮窗(搜索/排序/分页 + 家庭对比 Tab)。
 // 复用: computePlaytimeStats / kpiCards(tone:playtime) / hbarRow / buildListToolbar /
 // paginate+renderPagination / createFamilyCompareSection / SGLVCharts.lineChart。

 //游玩时长中位数纯函数——升序取中位,偶数取中间两值平均
 // (算式提取为纯函数便于单元测试与复用)
    function ptPlaytimeMedian(list) {
        if (!list || list.length === 0) return 0;
        const asc = [...list].sort((a, b) => (a.playtime || 0) - (b.playtime || 0));
        const mid = Math.floor(asc.length / 2);
        return asc.length % 2
            ? (asc[mid].playtime || 0)
            : (((asc[mid - 1].playtime || 0) + (asc[mid].playtime || 0)) / 2);
    }

 //布局调整——总览瘦身为「HERO + Top20」（集中度/活跃度分层已迁至「游玩分析」Tab），
 // Top 20 卡片占满剩余高度，列表自身滚动（v2.33.1 修复滚动链）
 //存量迁移——4 个 renderPlaydata* 函数 + PT_ACTIVITY_LAYERS 已外置至
 // script_libs/sglv-ptw-tab-overview.lib.js，本函数改为委托 SGLVPTW.mountInto 复用同一份实现，
 // 避免「主脚本一份 + Tab 库一份」双份漂移（原双栏 DOM 层级已在 Tab 库内复刻）。
 // 数据口径、快照增量刷新、toast 仍留在主脚本（属数据层职责，不随渲染外置）。
    function renderPlaydataTab(parent) {
        const wrap = document.createElement('div');
        wrap.className = 'sglv-playtime-wrap sglv-pt-tab';
        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)));

 // ---- 渲染：委托 Tab 库（框架缺失时降级为可操作提示，不静默空白）----
        const PTW = window.SGLVPTW;
        if (PTW && typeof PTW.mountInto === 'function') {
            PTW.mountInto('overview', wrap, {
 // 主面板内的钻取 = 打开浮窗并切到「全部游戏」Tab（面板本身没有 Tab 栏）
                goTo(key, patch) {
                    try { PTW.open(Object.assign({ tab: key }, patch || {})); }
                    catch (e) { console.error('[PTW] 主面板钻取打开浮窗失败', e); }
                },
            });
        } else {
            wrap.innerHTML = ptwFallbackHtml();
        }

 // ---- 数据层：快照播种 + 按周增量更新（命中新鲜快照则零请求，本次渲染直接出图）----
        ptSnapSeed(games);
        ptRefreshPlaytime().then(res => {
            if (res && res.changed > 0 && state.activeTab === 'playdata') {
                try { renderBody(); } catch (e) { /* ignore */ }
                sglvToast.info(T.ptWeeklyUpdated.replace('{n}', String(res.changed)));
            }
        }).catch(() => { });

        parent.appendChild(wrap);
    }

 //导航栏「游戏数据」菜单入口——与 renderPlaydataTab 同口径取游戏集
 // (show_family_shared 决定是否混入家庭共享; 库为空时回退 IndexedDB 缓存),
 // 直接打开全部游戏排行全屏浮窗(全部游戏 / 家庭对比 / 入库月历三 Tab)。
 // 库数据尚未加载时 toast 提示先开面板, 不开空浮窗。
 //openPlaytimeAllWindow 已外置，改为 SGLVPTW.open() 走框架浮窗；
 // 游戏集口径由 PTW_HOST.getOwnedGames() 内部保证（Tab 库不再自行过滤）。
    function openGameDataWindow() {
        let games = (state.ownedGames && state.ownedGames.length) ? state.ownedGames : storage.getCachedGames();
        if (!games || games.length === 0) {
            sglvToast.warning(T.ptMenuDataEmpty);
            return;
        }
        const PTW = window.SGLVPTW;
        if (!PTW || typeof PTW.open !== 'function') {
 // 框架缺失 → 与启动时同源的降级提示，绝不静默无响应
            showPtwFallback(PTW_FALLBACK_REASON);
            return;
        }
 // 复用回退缓存时（state.ownedGames 为空）把游戏集交给浮窗，避免 Tab 拿到空库
        const sortedGames = games.slice().sort((a, b) => (b.playtime || 0) - (a.playtime || 0));
        PTW.open({ games: sortedGames, tab: 'all' });
// v1.0.1 修复「无法加载全部游戏数据」——
 // 旧逻辑仅在 openGameDataWindow 调用瞬间快照 games,后续 state.ownedGames
 // 异步加载完成(由 fetchAllGames 派发 'sglv:games-updated' 事件)后,浮窗拿到的
 // 还是打开瞬间的快照,显示数量 = 缓存数 < 实际库存数,用户感知"看不到全部"。
 // 现在:监听 'sglv:games-updated' 事件 → 浮窗已开则用 PTW.refreshGames 用新集合重建当前 Tab。
 // 守卫:用 _ptwGamesUpdatedBound 防重复绑定(同 session 内多次打开浮窗不再叠加监听器)。
        if (PTW && typeof PTW.refreshGames === 'function') {
            if (!window._ptwGamesUpdatedBound) {
                window._ptwGamesUpdatedBound = true;
                document.addEventListener('sglv:games-updated', (ev) => {
                    try {
                        const next = (state.ownedGames && state.ownedGames.length) ? state.ownedGames : null;
                        if (next && next.length > 0) PTW.refreshGames(next);
                    } catch (e) { /* 刷新失败不影响其他功能 */ }
                });
            }
        }
    }

 // ==================== 愿望单标签页 ====================

 //wlEscape 委托至全局 escHtml，统一 HTML 转义实现（DRY）
    function wlEscape(s) {
        return escHtml(s);
    }

    let _wlPriceSym = '';
 //模块级币种代码记录（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');
    }

 //即将发售多源判定（参考 Steam-Wishlist-Sidebar）
 // 优先级：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);
 //旁路推断币种代码（软降级：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()) || '';
 //即将发售多源判定（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),
 //用户自定义类别 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：IWishlistService/GetWishlist API（appid/priority/date_added 全量条目）
 //旧 store wishlistdata 分页接口已被 Steam 下线（2026-07 愿望单改版，
 // 现返回 302→商店首页 HTML），替换为 IWishlistService/GetWishlist/v1——匿名可访问，
 // 单次返回全部条目。仅含 appid/priority/date_added，名称/价格仍靠 SSR StoreItem + 富集补全。
    async function fetchWishlistFromStore(steamId) {
        const out = [];
        if (!steamId) return out;
 // vanity 自定义 URL → steamid64 解析（API 只接受 64 位 ID；从愿望单页 HTML 提取）
        if (!/^\d{17}$/.test(String(steamId))) {
            try {
                const html = await sglvGmFetchTextRetry(`https://store.steampowered.com/wishlist/id/${steamId}/`, { timeout: 30000 });
                const m = html.match(/"steamid"\s*:\s*"(\d{17})"/) || html.match(/g_steamID\s*=\s*"(\d{17})"/);
                if (m) steamId = m[1];
                else { console.warn('[SGLV] 愿望单页未解析到 steamid64:', steamId); return out; }
            } catch (e) { console.warn('[SGLV] vanity 解析失败:', steamId, e); return out; }
        }
        try {
            const data = await requestSteamAPI(`https://api.steampowered.com/IWishlistService/GetWishlist/v1/?steamid=${steamId}`);
            const arr = data?.response?.items || [];
            arr.forEach(it => { if (it && it.appid) out.push({ appid: Number(it.appid), priority: it.priority, date_added: it.date_added }); });
            console.log(`[SGLV] IWishlistService: ${out.length} 条目`);
        } catch (e) { console.warn('[SGLV] IWishlistService 获取失败:', e); }
        return out;
    }

 // 来源3：IWishlistService/GetWishlist API 兜底重试（仅 appid/排序/添加时间）
 //IPlayerService/GetWishlist 已被 Steam 下线（任何鉴权状态均返回 404），
 // 替换为 IWishlistService/GetWishlist/v1（匿名可用）。与来源2 相同端点——仅在 SSR 和
 // 来源2 均失败后才会触达，作为网络抖动重试兜底。
    async function fetchWishlistFromApi(steamId) {
        const out = [];
        if (!steamId || !/^\d{17}$/.test(String(steamId))) return out;
        try {
            const data = await requestSteamAPI(`https://api.steampowered.com/IWishlistService/GetWishlist/v1/?steamid=${steamId}`);
            const arr = data?.response?.items || [];
            arr.forEach(it => { if (it && it.appid) out.push({ appid: Number(it.appid), priority: it.priority, date_added: it.date_added }); });
        } catch (e) { console.warn('[SGLV] IWishlistService 兜底获取失败:', e); }
        return out;
    }

 //解析 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;
    }

 //获取用户自定义愿望单类别（我的类别）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) {
 //静默忽略 HTML 响应（未登录/API Key 失效时 Steam 返回登录页 HTML），不打印警告避免干扰
 //401/403 = access_token 失效或未登录，属预期降级路径（后续有 SSR 页面兜底），同样不刷警告
                const errMsg = String(e.message || e);
                if (!errMsg.includes('返回 HTML') && !/\b(401|403)\b/.test(errMsg)) {
                    console.warn('[SGLV] GetWishlistCategories 失败:', e);
                }
            }
        }
        return {};
    }

 //后台静默刷新类别名映射，完成后仅局部刷新左侧仪表盘（不重建封面，避免闪烁）
 //API（GetWishlistCategories，需 token）为空时回退 SSR 页面提取——2026-07 改版后
 // token 链路不稳，而登录态愿望单页 SSR 的 wishlistcategories 查询必然包含自定义类别。
    function refreshWishlistCategoryNames() {
        fetchWishlistCategoryNames().then(map => {
            if (Object.keys(map).length === 0) {
 // API 无数据 → SSR 页面兜底（带登录 Cookie，看自己愿望单时含私有分类）
                return fetchWishlistFromPage(getActiveSteamId()).then(ssr => {
                    if (ssr && ssr.categoryNames && Object.keys(ssr.categoryNames).length > 0) return ssr.categoryNames;
                    return {};
                }).catch(() => ({}));
            }
            return map;
        }).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(() => {});
    }

 //IStoreBrowseService/GetItems 批量补全（参考 Steam-Wishlist-Sidebar）
 // 实测匿名可用，单批 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 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);
 //旁路推断币种代码（软降级：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() };
            }
        };
 //智能并发池（sglvSmartPool）替代固定 worker 手写池——
 // 429 限流自动降速+退避重试，批量失败率显著下降；批间保持 150ms 节奏
        await sglvSmartPool(chunks.map(chunk => async () => {
            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, 150));
        }), CONCURRENCY);
        if (isZh) { try { sglvGameNameCacheSave(); } catch (e2) { console.warn('[SGLV] 中文名缓存写入失败:', e2); } }
    }

 // 资料补全：三段式（参考 Steam-Wishlist-Sidebar）
 // ① 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) {
 //filters 限定返回字段，增加 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;
 //中文环境下 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;
 //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);
 //旁路推断币种代码（软降级：lib 缺失/异常不影响原流程）
                        try { if (hasSglvCurrency && po.final_formatted) { const c = CUR.detectFromText(po.final_formatted); if (c) _wlPriceCode = c; } } catch {}
                    }
 //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;
 //同步写入中文名缓存，避免 loadGameZhName 对已补全的游戏重复请求 appdetails
                    if (dd.name && isZh) {
                        const nc = sglvGameNameCacheLoad();
                        nc[String(g.appid)] = { name: dd.name, ts: Date.now() };
                    }
                });
 //批量写入后统一落盘一次，避免 forEach 内每条都调 GM_setValue
                if (isZh) { try { sglvGameNameCacheSave(); } catch (e2) { console.warn('[SGLV] 中文名缓存写入失败:', e2); } }
            };
 //智能并发池（并发 2）替代纯串行——appdetails 是限流重灾区，
 // 429 自动退避重试+降速，批间保持 250ms 节奏
            let done = 0;
            const batchTasks = [];
            for (let i = 0; i < leftovers.length; i += 25) {
                const batch = leftovers.slice(i, i + 25);
                batchTasks.push(async () => {
                    try { await enrichBatch(batch); } catch { /* 忽略单批失败 */ }
                    done += batch.length;
                    if (onBatchDone) onBatchDone(done, leftovers.length);
                    await new Promise(r => setTimeout(r, 250));
                });
            }
            await sglvSmartPool(batchTasks, 2);
 //对补全失败的条目以更小批次重试一轮——旧实现单批失败后条目永久缺失中文名/价格
            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);
    }

 //后台静默刷新愿望单动态字段（价格/折扣/即将发售）
 // 仅用 IStoreBrowseService/GetItems 批量请求（快速），比较新旧值后仅更新有变化的条目并局部刷新 UI
 //增加 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;
 //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 数据提取 ====================
 // 参考 steam-wishlist-exporter：从愿望单页面 HTML 中解析 React Query SSR 数据，
 // 获取 date_added/priority（全部条目）+ StoreItem 详情（名称/价格/标签，首批条目）+ 标签名映射
 // 这解决了 wishlistdata API 不返回 added/tags 导致时间线和标签为空、名称需逐批 appdetails 补全的问题

 // 从 HTML 文本中提取 React Query 的 queries 数组（扫描 JSON.parse("...") 包含 queryData 的片段）
    function wlExtractQueryDataFromText(text) {
        try {
 //新版愿望单 SSR（2026-07 愿望单改版）——数据迁移到
 // <script type="application/json" id="valve-ssr-data"> 的 renderContext.queryData
 // （脱水 react-query 缓存，queries 含 WishlistSortedFiltered/StoreItem/LocalizedTagNames）。
 // 旧版内联 JSON.parse("...") 模式已从页面移除，此路径解析不到任何数据。
            const ssrMatch = text.match(/<script[^>]*id="valve-ssr-data"[^>]*>([\s\S]*?)<\/script>/);
            if (ssrMatch) {
                const ssr = JSON.parse(ssrMatch[1]);
 // 首选 renderContext.queryData（实测结构：{mutations:[],queries:[...]}）
                if (ssr && ssr.renderContext && typeof ssr.renderContext.queryData === 'string') {
                    const qd = JSON.parse(ssr.renderContext.queryData);
                    if (qd && Array.isArray(qd.queries)) return qd.queries;
                }
 // 兜底：loaderData（路由级字符串数组）内嵌 queryData 时扫描
                if (Array.isArray(ssr && ssr.loaderData)) {
                    for (const seg of ssr.loaderData) {
                        if (typeof seg !== 'string' || !seg.includes('queryData')) continue;
                        try {
                            const segObj = JSON.parse(seg);
                            const qdStr = segObj && segObj.queryData;
                            if (typeof qdStr === 'string') {
                                const qd = JSON.parse(qdStr);
                                if (qd && Array.isArray(qd.queries)) return qd.queries;
                            }
                        } catch (_) { /* 继续扫下一段 */ }
                    }
                }
                console.warn('[SGLV] valve-ssr-data 已找到但未含 queries（愿望单可能为空或加载失败）');
            }
 // 旧版格式回退：内联 JSON.parse("...") 模式
            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();
        const categoryNames = {};
        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);
            }
 //自定义类别（"我的类别"）id -> 名称映射——私有数据仅登录态可见，
 // 2026-07 改版后 GetWishlistCategories API token 链路不稳，SSR 是可靠来源。
 // 查询形态 wishlistcategories: 数组或 {categories:[...]}，复用既有解析器。
            if (qKey[0] === 'wishlistcategories') {
                const list = Array.isArray(data) ? data : (data && (data.categories || data.wishlist_categories));
                if (Array.isArray(list)) {
                    Object.assign(categoryNames, parseWishlistCategoriesResponse({ categories: list }));
                } else if (data && typeof data === 'object') {
                    Object.assign(categoryNames, parseWishlistCategoriesResponse(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, categoryNames };
    }

 // 将 StoreItem 缓存数据应用到已规整的愿望单条目（补全名称/价格/标签/类型）
    function applyStoreItemToWlEntry(item, storeData, tagNameMap) {
        if (!item || !storeData) return;
        const di = storeData.default_info;
        if (di) {
 //中文环境下 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);
 //旁路推断币种代码（软降级：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;
            }
 //即将发售判定（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);
        }
 //中文环境下 SSR StoreItem 的名称随用户账号语言（可能为英文），
 // 不标记 _metaDone，让 enrichWishlistMeta 通过 l=schinese 的 appdetails 覆盖为中文名；
 // 非中文环境保持原有行为（SSR 数据完整即跳过 appdetails）。
        item._metaDone = isZh ? false : true; // StoreItem 数据完整，跳过 appdetails 补全
    }

 // 从愿望单页面 HTML 抓取 SSR 数据（参考 steam-wishlist-exporter 的 SSR 提取）
 //迁移至 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} 标签, ${Object.keys(data.categoryNames || {}).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';
    }

 // ==================== 富集渲染节流（VAC 式批量 DOM 刷新，借鉴 steam-friend-manager） ====================
 // 数千条愿望单逐批补全时，onBatchDone 每批触发 renderWishlistSections 全量重渲会阻塞主线程。
 // 800ms 尾沿合并：批量期间至多重渲 1 次 + 收尾补偿 1 次，进度文本（textContent）仍即时更新。
    let _wlRenderThrottleTimer = null;
    let _wlRenderPiggyback = false;
    function scheduleWishlistRender() {
        if (_wlRenderThrottleTimer) { _wlRenderPiggyback = true; return; }
        _wlRenderThrottleTimer = setTimeout(() => {
            _wlRenderThrottleTimer = null;
            try { renderWishlistSections(); } catch (e) { console.warn('[SGLV] 节流渲染失败:', e); }
            if (_wlRenderPiggyback) { _wlRenderPiggyback = false; scheduleWishlistRender(); }
        }, 800);
    }

 // ==================== 打折曲线弹窗 + 新史低预测（借鉴 steam-friend-manager） ====================
 // 数据源：SGLVITAD 库（用户 Key 优先）→ AugmentedSteam prices/v2（匿名兜底），会话级缓存 24h。
 // 预测算法：从折扣记录提取"新史低序列"（折扣逐次加深的节点），median 相邻间隔推算下次时间，
 // 样本量决定可信度（≥3 高 / 2 中 / 1 低），下档折扣 ≈ last + median(step) 取 5 的倍数封顶 100。
    async function wlFetchHistoryPrices(appid) {
        const cacheKey = 'wlHistory_' + appid;
        const cached = cacheGet(cacheKey);
        if (cached) return cached;
        const itad = window.SGLVITAD;
        if (itad && typeof itad.hasApiKey === 'function' && itad.hasApiKey()) {
            try {
                const itadId = await itad.lookupItadId(appid);
                if (itadId) {
                    const [gameInfo, historyData] = await Promise.all([
                        itad.fetchGameInfo(itadId),
                        itad.fetchPriceHistory(itadId, { country: 'CN', shops: [itad.SHOP_STEAM] }),
                    ]);
                    if (historyData && (historyData.discounts || []).length) {
                        const result = {
                            history: historyData.history || [],
                            discounts: historyData.discounts || [],
                            lowest: historyData.lowest || null,
                            source: 'itad',
                        };
                        cacheSet(cacheKey, result, 24 * 3600 * 1000);
                        return result;
                    }
                }
            } catch (e) { console.warn('[SGLV] ITAD 历史价格失败:', e); }
        }
 // 兜底：AugmentedSteam prices/v2（匿名可用，含 historic low）
        try {
            const data = await sglvGmFetchRetry('https://api.augmentedsteam.com/prices/v2', {
                method: 'POST', timeout: 12000,
                headers: { 'Content-Type': 'application/json' },
                data: JSON.stringify({ country: 'CN', apps: [parseInt(appid, 10)], subs: [], bundles: [], voucher: false, shops: [] }),
            });
            const aug = data?.prices?.[`app/${appid}`];
            if (aug) {
                const lowest = aug.lowest || (aug.historic && aug.historic[0]) || null;
                const result = { history: [], discounts: [], lowest, source: 'aug' };
                cacheSet(cacheKey, result, 24 * 3600 * 1000);
                return result;
            }
        } catch (e) { console.warn('[SGLV] AugmentedSteam 历史价格失败:', e); }
        return null;
    }

    function wlPredictNextLow(discounts) {
        const DAY = 86400000;
        const pts = (discounts || [])
            .map(d => ({ date: new Date(d.date).getTime(), cut: Number(d.cut) || 0 }))
            .filter(p => p.date > 0 && !isNaN(p.date))
            .sort((a, b) => a.date - b.date || a.cut - b.cut);
        const lows = [];
        let run = 0;
        pts.forEach(p => { if (p.cut > run) { run = p.cut; lows.push(p); } });
        if (lows.length === 0) return null;
        const median = arr => {
            if (!arr.length) return null;
            const s = [...arr].sort((a, b) => a - b);
            const m = s.length >> 1;
            return s.length % 2 ? s[m] : Math.round((s[m - 1] + s[m]) / 2);
        };
        const now = Date.now();
        const gaps = [];
        for (let i = 1; i < lows.length; i++) gaps.push(Math.max(1, Math.round((lows[i].date - lows[i - 1].date) / DAY)));
        let gap, conf;
        if (gaps.length >= 2) { gap = median(gaps); conf = gaps.length >= 3 ? 'high' : 'mid'; }
        else { gap = gaps[0] || 180; conf = 'low'; }
        gap = Math.max(1, gap);
        const last = lows[lows.length - 1];
        const nextTs = last.date + gap * DAY;
        const daysLeft = Math.ceil((nextTs - now) / DAY);
        const sinceLast = Math.ceil((now - last.date) / DAY);
 // upcoming=预测窗口在未来 / due=已超期不足一个周期（随时可能）/ stalled=超期≥一个周期（节奏停滞或已达底线）
        const state = daysLeft >= 0 ? 'upcoming' : ((sinceLast / gap) < 2 ? 'due' : 'stalled');
        const steps = [];
        for (let i = 1; i < lows.length; i++) steps.push(lows[i].cut - lows[i - 1].cut);
        const step = median(steps) || 10;
        const nextCut = Math.min(100, Math.max(last.cut, Math.round((last.cut + step) / 5) * 5));
        return { gapDays: gap, daysLeft, sinceLast, state, conf, lastCut: last.cut, nextCut, nLows: lows.length };
    }

    function wlRenderCurveSvg(history, lowest) {
        const pts = (history || [])
            .map(h => ({ t: new Date(h.date).getTime(), price: Number(h.price) || 0, cut: Number(h.cut) || 0 }))
            .filter(p => p.t > 0 && !isNaN(p.t) && p.price > 0)
            .sort((a, b) => a.t - b.t);
        if (pts.length < 2) return '';
        const W = 680, H = 230, PL = 46, PR = 12, PT = 12, PB = 24;
        const t0 = pts[0].t, t1 = pts[pts.length - 1].t;
        const lowestPrice = lowest && Number(lowest.price) > 0 ? Number(lowest.price) : null;
        let pMin = Math.min(...pts.map(p => p.price), lowestPrice != null ? lowestPrice : Infinity);
        let pMax = Math.max(...pts.map(p => p.price));
        if (pMax <= pMin) pMax = pMin + 1;
        const x = t => PL + (t - t0) / Math.max(1, t1 - t0) * (W - PL - PR);
        const y = p => PT + (1 - (p - pMin) / (pMax - pMin)) * (H - PT - PB);
        const path = pts.map((p, i) => `${i ? 'L' : 'M'}${x(p.t).toFixed(1)},${y(p.price).toFixed(1)}`).join(' ');
        let out = '';
 // y 轴网格（3 档）
        for (let i = 0; i <= 2; i++) {
            const p = pMin + (pMax - pMin) * i / 2;
            const yy = y(p).toFixed(1);
            out += `<line x1="${PL}" y1="${yy}" x2="${W - PR}" y2="${yy}" stroke="rgba(255,255,255,0.06)"/><text x="${PL - 6}" y="${yy}" fill="#8b949e" font-size="10" text-anchor="end">${p.toFixed(0)}</text>`;
        }
 // x 轴时间刻度（5 档）
        const fmtDate = t => { const d = new Date(t); return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}`; };
        for (let i = 0; i <= 4; i++) {
            const t = t0 + (t1 - t0) * i / 4;
            out += `<text x="${x(t).toFixed(1)}" y="${H - 6}" fill="#8b949e" font-size="10" text-anchor="middle">${fmtDate(t)}</text>`;
        }
 // 史低虚线
        if (lowestPrice != null && lowestPrice >= pMin) {
            const ly = y(lowestPrice).toFixed(1);
            out += `<line x1="${PL}" y1="${ly}" x2="${W - PR}" y2="${ly}" stroke="#f59e0b" stroke-dasharray="4 3" opacity="0.6"/><text x="${W - PR}" y="${(y(lowestPrice) - 4).toFixed(1)}" fill="#f59e0b" font-size="10" text-anchor="end">LOW</text>`;
        }
 // 折扣点高亮
        pts.forEach(p => {
            if (p.cut > 0) out += `<circle cx="${x(p.t).toFixed(1)}" cy="${y(p.price).toFixed(1)}" r="2.5" fill="#f59e0b" opacity="0.85"/>`;
        });
        out += `<path d="${path}" fill="none" stroke="#66c0f4" stroke-width="1.8" stroke-linejoin="round"/>`;
        return `<svg viewBox="0 0 ${W} ${H}" style="width:100%;height:auto;display:block;background:rgba(255,255,255,0.02);border:1px solid rgba(255,255,255,0.06);border-radius:8px">${out}</svg>`;
    }

    async function openWlPriceCurve(appid, name, ev) {
        if (ev) { ev.preventDefault(); ev.stopPropagation(); }
        const old = document.getElementById('sglv-wl-curve-overlay');
        if (old) old.remove();
        const overlay = document.createElement('div');
        overlay.id = 'sglv-wl-curve-overlay';
        overlay.className = 'sglv-overlay';
        overlay.innerHTML = `
            <div class="sglv-panel" style="position:relative;max-width:760px;width:92%;max-height:86vh;display:flex;flex-direction:column">
                <div class="sglv-header" style="display:flex;align-items:center;gap:10px;padding:10px 16px">
                    <h2 style="font-size:14px;margin:0;flex:1;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap">${T.wlCurveTitle} · ${wlEscape(name)}</h2>
                    <button class="sglv-close-btn" style="background:none;border:none;color:#cbd5e1;cursor:pointer;font-size:14px">✕</button>
                </div>
                <div class="sglv-body" id="sglv-wl-curve-body" style="padding:16px 18px;overflow-y:auto">
                    <div style="padding:40px 0;text-align:center;color:var(--sglv-text-secondary)">${T.wlCurveLoading}</div>
                </div>
            </div>`;
        document.body.appendChild(overlay);
        overlay.addEventListener('click', e => { if (e.target === overlay) overlay.remove(); });
        overlay.querySelector('.sglv-close-btn').addEventListener('click', () => overlay.remove());
        const body = overlay.querySelector('#sglv-wl-curve-body');
        try {
            const data = await wlFetchHistoryPrices(appid);
            if (!data) { body.innerHTML = `<div style="padding:40px 0;text-align:center;color:var(--sglv-text-secondary)">${T.wlCurveNoData}</div>`; return; }
            const pred = wlPredictNextLow(data.discounts);
            const svg = wlRenderCurveSvg(data.history, data.lowest);
            let html = svg || `<div style="padding:24px 0;text-align:center;color:var(--sglv-text-secondary)">${T.wlCurveNoData}</div>`;
            if (pred) {
                const stateText = pred.state === 'upcoming'
                    ? `${T.wlPredictIn} ${Math.max(0, pred.daysLeft)} ${T.wlPredictDays}`
                    : (pred.state === 'due' ? T.wlPredictDue : T.wlPredictStalled);
                const confText = pred.conf === 'high' ? T.wlConfHigh : (pred.conf === 'mid' ? T.wlConfMid : T.wlConfLow);
                const stateColor = pred.state === 'due' ? '#f59e0b' : (pred.state === 'upcoming' ? '#66c0f4' : '#94a3b8');
                html += `
                    <div style="margin-top:14px;border:1px solid rgba(102,192,244,0.25);border-radius:8px;padding:12px 14px;background:rgba(102,192,244,0.06)">
                        <div style="display:flex;align-items:center;gap:10px;flex-wrap:wrap">
                            <span style="font-size:13px;font-weight:700;color:#66c0f4">📈 ${T.wlPredictTitle}</span>
                            <span style="font-size:14px;font-weight:800;color:${stateColor}">${stateText}</span>
                            <span style="font-size:10px;padding:1px 6px;border-radius:4px;border:1px solid rgba(102,192,244,0.3);color:#94a3b8">${confText}</span>
                        </div>
                        <div style="display:flex;gap:18px;flex-wrap:wrap;margin-top:8px;font-size:11px;color:var(--sglv-text-secondary)">
                            <span>${T.wlPredictLast}: -${pred.lastCut}%</span>
                            <span>${T.wlPredictGap}: ~${pred.gapDays} ${T.wlPredictDays}</span>
                            <span>${T.wlPredictNextCut}: -${pred.nextCut}%</span>
                            <span>${T.wlCurveSource}: ${data.source}</span>
                        </div>
                    </div>`;
            }
            body.innerHTML = html;
        } catch (e) {
            body.innerHTML = `<div style="padding:40px 0;text-align:center;color:#f87171">${wlEscape(String(e.message || e))}</div>`;
        }
    }
 // 暴露给卡片内联 onclick（避免跨视图事件委托接线）
    unsafeWindow._sglvOpenWlCurve = function(ev, appid, name) { openWlPriceCurve(appid, name, ev); };

 // 曲线按钮（card/cover/list 三视图共用；内联样式避免新增 CSS 块）
    function wlCurveBtnHtml(g) {
        const safeName = wlEscape(g.name || '').replace(/'/g, '&#39;').replace(/"/g, '&quot;');
        return `<button class="sglv-wl-curve-btn" title="${T.wlCurveTip}" style="border:1px solid rgba(102,192,244,0.3);background:rgba(102,192,244,0.08);color:#66c0f4;border-radius:4px;font-size:11px;padding:1px 5px;cursor:pointer;flex-shrink:0;line-height:1.5" onclick="window._sglvOpenWlCurve(event,'${g.appid}','${safeName}')">📈</button>`;
    }

 // 主入口：四级来源兜底（愿望单页面SSR → IWishlistService → IWishlistService 重试 → GDynamicStore）

 // 主入口：四级来源兜底（愿望单页面SSR → IWishlistService → IWishlistService 重试 → GDynamicStore）
 //2026-07 Steam 愿望单改版——旧 wishlistdata 分页(302→首页)与 IPlayerService/GetWishlist
 // (恒 404)均已下线；SSR 数据迁移至 valve-ssr-data 脚本节点，愿望单数据改用 IWishlistService 获取。
 //缓存命中时后台静默刷新动态字段（价格/折扣/即将发售），不阻塞 UI
 //缓存 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: 后台静默更新类别名
 //后台静默刷新动态字段——价格/折扣/即将发售状态变化频繁，缓存内可能已过时
 //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 : {};

 //阶段2 — API 数据补全
            state.wishlistLoadStage = 2;
            renderWishlistGamesList();

 // 来源2：IWishlistService 全量条目（appid/priority/date_added，补 SSR 缺失项）
            let apiEntries = [];
            if (steamId) {
                try { apiEntries = await fetchWishlistFromStore(steamId); }
                catch (e) { console.warn('[SGLV] IWishlistService 获取失败:', e); }
            }
            if (raw.length === 0) {
 // SSR 失败，直接用 API 数据
                raw = apiEntries;
            } else if (apiEntries.length > 0) {
 // 合并：SSR 提供 date_added/priority/category_ids + StoreItem 首批详情，API 提供全量条目清单
                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,
                    });
                });
 //补入仅 API 有、SSR 缺失的条目（已下架/不可见 app 频繁缺失，
 // 实测 1402 条愿望单 SSR 仅含 1369 条）——否则这部分游戏永远丢失
                const rawIds = new Set(raw.map(e => Number(e.appid)));
                for (const [apid, e] of apiMap) {
                    if (!rawIds.has(apid)) raw.push(e);
                }
            }

 // 来源3：IWishlistService 重试兜底
            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,标记为脏
 //类别名三级来源——SSR（登录态 wishlistcategories 查询，最可靠）优先，
 // 其次本地缓存，最后 API（refreshWishlistCategoryNames，token 失效时 401 静默）。
 // 2026-07 改版后 API token 链路不稳，SSR 命中时直接回写缓存。
            const _ssrCatNames = (ssrData && ssrData.categoryNames) || {};
            if (Object.keys(_ssrCatNames).length > 0) {
                state.wishlistCategoryNames = Object.assign({}, cacheGet('wishlistCatNames') || {}, _ssrCatNames);
                cacheSet('wishlistCatNames', state.wishlistCategoryNames, 7 * 24 * 3600 * 1000);
            } else {
                state.wishlistCategoryNames = cacheGet('wishlistCatNames') || {}; // v2.3.23: 先用缓存类别名出图
            }
            renderWishlistSections(); // 先出列表，再后台逐批补全名称/标签/价格
            refreshWishlistCategoryNames(); // v2.3.23: 后台获取最新类别名并局部刷新
 //阶段3 — 资料富集（后台补全，不阻塞列表展示）
            state.wishlistLoadStage = 3;
            await enrichWishlistMeta(items, (done, total) => {
                updateWishlistProgress(done, total);
                scheduleWishlistRender(); // v2.11.50: 800ms 合并重渲，替代每批全量刷新
            });
            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;
    }

 //愿望单条目币种解析 helper（本任务只建 helper 与字段，computeWishlistStats 接入留待下一任务）
 // 兜底链：entry.currency（appdetails 权威值）→ 用户国家代码对应币种（REGIONS 表，g_strCountryCode 权威）
 // → _wlPriceCode（formatted 价格文本推断，时序波动/跨区域残留风险，垫底）→ 'CNY'
 //_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);
 //多币种汇总软降级开关 —— 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;

 //即将发售
        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，单位为元）
 //聚合路径下改按折算后金额分桶（全同币种时 _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]);

 //我的类别详细统计（每类别：数量/总值/均价/打折/待上市/已入库/免费 + 占比）
 //聚合路径下 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);

 //未分类游戏统计（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,
 //aggregate 附加产物透传（无汇率降级分桶/未支持币种列表；降级路径下为空值，新增字段不影响既有消费方）
            byCurrency: _wlAgg ? _wlAgg.byCurrency : {},
            unsupported: _wlAgg ? _wlAgg.unsupported : [],
            targetCode: _wlTargetCode,
        };
    }

 //持久化 wishlist 统计(跨 session 复用)
 // 输入签名:wishlist 数量 + 价格字段总和 + 类别字段总和
 // 动态字段(价格/折扣)会由 refreshWishlistDynamicFields 后台刷新(已有)
 //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;
 //类别筛选（点击"我的类别统计"卡片触发）
            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;
        });
    }

 // ----- 渲染 -----
 // ==================== 云存档标签页 ====================

    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;
        }

 // 空数据——切换到云存档标签页时，先尝试从 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);
    }

 //云存档数据准备(自 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;
        }
 //渲染完成后，若距上次后台刷新超过 6h 节流窗口，触发静默增量更新
 // 仅在切到该标签页时触发（不打扰用户）
        if (Date.now() - (state.cloudSaveBgRefreshAt || 0) >= CLOUDSAVE_BG_REFRESH_INTERVAL) {
            _backgroundRefreshCloudSave();
        }
 //后台渐进式填充文件数量（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));
 //数据加载完成后,后台填充文件数量
            _enrichCloudSaveFileCounts();
        } catch (err) {
            state.cloudSaveError = err.message || 'UNKNOWN_ERROR';
            console.error('[SGLV] 云存档数据获取失败:', err);
        } finally {
            state.cloudSaveLoading = false;
            renderBody();
        }
    }

 //启动时尝试从 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) {
 //清除旧 _status 标记，避免误显示"新增/变化"徽章
                cached.games.forEach(g => { if (g._status) g._status = null; });
                state.cloudSaveGames = cached.games;
                state.cloudSaveSource = 'cache';
                state.cloudSaveLastUpdate = cached.lastUpdate || 0;
 //从 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;
    }

 //后台静默增量更新（只增不减 + 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;
        }
    }

 //后台渐进式填充云存档文件数量
 // 全局云存档页面不直接展示文件数,需逐一请求单App页面解析 accountTable tbody tr 行数
 // 参考 Steam 云.html 页面结构: appid=7 (Steam Client) 有 2 个文件 = tbody 内 2 个 tr
 // - 5天 TTL（云存档相对固定）,fileCountAt 从 IDB 缓存恢复,避免每次页面刷新都重新获取
 // - 并发 3,每请求间隔 500ms
 // - 每获取到一个游戏的文件数就刷新 UI（渐进式更新）
    let _csFileCountAbort = null;
    async function _enrichCloudSaveFileCounts() {
        if (state.cloudSaveFileCountEnriching) return;
        if (!window.SGLVCloudSave?.enrichFileCounts) return;
 //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;
 //文件数渐进回填改局部更新——仅刷新 .sglv-cs-game-files
 // 文本节点,不整 Tab 重绘(保留已加载封面 <img> 消除闪烁,参考 wishlist 增量模式);
 // 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();
        }
    }

 //首次进入云存档标签页时调用——先显示缓存，再后台增量更新
    async function _initCloudSaveTab() {
 // 1) 立即从 IDB 加载缓存（同步显示，无需等待）
        const loaded = await _tryLoadCloudSaveFromIDBCache();
 // 2) 缓存为空时走原 fetch 流程（用户首次使用 / 清缓存）
        if (!loaded) {
            await loadCloudSaveData(false);
            return;
        }
 // 3) 已有缓存 → 后台静默增量更新（不阻塞 UI）
        _backgroundRefreshCloudSave();
 //后台渐进式填充文件数量（5天 TTL）
        _enrichCloudSaveFileCounts();
    }

    function renderCloudSaveDashboard(parent, wrap) {
        const games = state.cloudSaveGames;
        const fmt = window.SGLVCloudSave.formatSize;

 //构建 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}`;
        }
 //封面降级逻辑已抽取到 sglv-cover-fallback.lib.js（@require 引用）
 // 这里只做轻量适配：lib 不可用时安全降级（返回空字符串 + onerror 自然触发 placeholder）
 //传递 kind 参数给封面加载库，使 CDN 链和 API 兜底按图片类型选择最佳 URL
        function getCsCoverUrl(appId, kind) {
            if (window.SGLVCoverFallback && window.SGLVCoverFallback.getCoverUrl) {
                return window.SGLVCoverFallback.getCoverUrl(appId, kind || 'capsule');
            }
 // 兜底：直接用 cloudflare capsule（兼容 lib 未加载场景）
 // v2.42.2 修复：形参是 appId，模板串却用了 appid（另一个闭包的变量）→ ReferenceError
            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]++;
        });

 // ---- 文件数分布 ----
 //优化分桶——大多数游戏存档数 <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() : '';
 //文件数更新时间独立显示,避免与存档数据更新时间混淆
        const fileCountTime = state.cloudSaveFileCountAt ? new Date(state.cloudSaveFileCountAt).toLocaleString() : '';

 // ============ 左侧仪表盘 ============
        const side = document.createElement('div');
        side.className = 'sglv-cs-side';
 //改经 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';

 //工具栏经 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);

 //云存档行三段插槽构建器——自 renderGameList 手拼模板逐字拆出,
 // 供 renderGameView list 分支 imgHtml/bodyHtml/trailingHtml 消费(闭包依赖 resolveGameName/
 // getCsCoverUrl/fmt/T/isZh 保持在本作用域)
        const _csRowCoverHtml = (g, gName) => {
 //游戏封面图（三级降级，data 属性触发全局事件委托）
 // marker 从 data-sglv-cs-cover 改为通用的 data-sglv-cover（lib 通用 marker）
 //添加 data-kind="capsule" 使封面库按 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();
 //搜索同时匹配解析后的游戏名称
                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;
            }

 //行骨架经 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) {
 //手动刷新按钮也使用 additive 模式（只增不减），保护已有游戏列表不被误删
 //手动刷新同时重置文件数 TTL,让新增游戏的文件数能立即获取
            refreshBtn.addEventListener('click', () => {
                state.cloudSaveFileCountAt = 0;
                loadCloudSaveDataAdditive(true);
            });
        }

 //绑定封面降级事件委托（@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)');
        }
    }

 //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));
 //数据加载完成后,后台填充文件数量
            _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';

 // 左侧仪表盘面板顺序：
 // 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 },
        ];
 //工具栏经 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 }) => {
 //debounce 搜索输入在工厂内统一（避免愿望单列表每次按键触发完整重渲染）
                if (type === 'input') {
                    state.wishlistSearch = value;
                    state.wishlistPage = 1;
                    renderWishlistGamesList();
                } else {
 //视图切换统一处理（card/cover/list 三模式，active 类由工厂切换）
                    state.wishlistViewMode = value;
                    renderWishlistGamesList();
                }
            },
        });
        main.appendChild(toolbar);

 //筛选标签栏 + 分页放同一行，紧凑操作栏
 //更新提示信息移至筛选按钮右侧（红框标注位置）
        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);

 //首次加载时显示完整骨架屏(KPI + 8 section + 游戏网格),避免页面紧缩
 //修复首次加载骨架屏不显示——改为 !wishlistLoaded 即显示（不要求 wishlistLoading）
        if (!state.wishlistLoaded) {
            createSkeleton('wishlist', wrap);
        }

 // 事件绑定
 //筛选按钮事件——从 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();
 //混合币种聚合提示 — 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';
 //改经 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，迷你竖向柱状图）
 //柱子外套轨道容器确保百分比高度生效；峰值年份高亮突出
        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('')}
        `;

 //待上市游戏图表（参考愿望单插件，替换原类型分布）
 // 按发售时间分组：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>` : ''}
            `;
        }

 //我的类别统计（每类别详细统计 + 点击筛选游戏列表）
        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>`;

 //点击类别卡片筛选/取消筛选游戏列表
                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();
                    });
                });
            }
        }
    }

 //愿望单加载等待动画——使用共享区 wishlistLoadingHtml()（经 createLoadingHtml 工厂）

    function renderWishlistGamesList() {
        const content = document.getElementById('sglv-wishlist-content');
        if (!content) return;
 //辅助函数——清空工具栏分页
        const clearPagination = () => { const p = document.getElementById('sglv-wishlist-pagination'); if (p) p.innerHTML = ''; };

        if (state.wishlistLoading) {
 //优化加载状态更新——已有 loading 容器时仅更新文本和进度条，避免 spinner 动画重启闪烁
            const existing = content.querySelector('.sglv-wl-loading');
            if (existing) {
 //阶段表经共享 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;
        }

 //复用 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));
 //在库状态判定集合——个人在库优先，其次家庭共享（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>`;
 //家庭共享标签改为图标+“共享”汉字,固定在价格列最右侧,避免换行
            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') : '-';
 //愿望单排序位次徽章（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>`
            : '';

 //卡片正文/列表信息 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>
                            ${wlCurveBtnHtml(g)}
                            ${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>`;
 //横板封面视图正文（参考 steam-family-game-analysis 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>
                            ${wlCurveBtnHtml(g)}
                            ${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>`;

 //增量更新——视图模式与当前页 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') {
 //封面视图增量更新——正文 + 封面浮层徽章，保留已加载的封面 <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);
                }
            });
 //增量更新后也需异步加载中文名；经 applyGameAliases 统一入口
 // （容器内已回填元素经 data-sglv-alias-done 幂等跳过，增量场景零重复请求）
            applyGameAliases(existView);
        } else if (state.wishlistViewMode === 'card') {
 //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') {
 //横板封面视图（每行3个，参考 steam-family-game-analysis 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 {
 //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)}${wlCurveBtnHtml(g)}</div>`,
            });
        }

 //分页——使用工具栏内嵌的分页元素（始终可见，不随内容滚动）
        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(); });
        }

 //异步加载游戏中文名（覆盖 SSR/API 返回的英文名）；经 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) {
 //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 {
 //v2.45.0 API Key 同意门：全新用户第一次用「拉库存」这类需要 Key 的功能时，
 // 先把用途与风险摊开讲，勾选同意才允许填 Key；不同意则直接中止本次加载。
        if (!storage.getApiKey()) {
            const allowed = await _requireApiKeyConsent({ thenFetch: true });
            if (!allowed) return;
        }
        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) {
 // v2.46.2 强制刷新只清派生缓存，**不再先清库存本体**。
 //   旧写法先 setCachedGames([]) + state.ownedGames = []，万一随后拉取失败（限流 / 令牌过期 /
 //   断网），用户整库连同 IDB 缓存一起消失，只剩一句「未获取到游戏数据」。
 //   等价于「写新数据前先把旧址拆了」—— 新数据到手再换（写 .tmp 再 rename 的同一条纪律）。
 //   库存本体由下面拉取成功后的 setCachedGames(games) 整体替换，这里清不清对结果无影响。
 //   `state.ownedAppIds` 也一并保留：它与 ownedGames 是一对，只清一半会让商店页的
 //   「已拥有」角标在拉取的几十秒里集体误判成「未拥有」。
            invalidateActiveOwnedAppIdsCache();
            clearComputedCache();
 //同时清除侧边栏 TTL 缓存
            cacheClear('achievements_');
            cacheClear('globalAchievements_');
            cacheClear('news_');
            cacheClear('historyPrices_');
            cacheClear('familyShare_');
        }

        setLoading(true);
        state.isLoading = true;
 //多阶段状态机进度条
        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. (Previous library kept.)');
                return;
            }
            games.sort((a, b) => a.name.localeCompare(b.name));
            // v2.46.2 缩容诊断：替换缓存前先看一眼旧量。「只出现在其中一份清单里的条目会被
            // 悄悄丢掉」是这个数据层的典型事故 —— 家庭组成员离开 / 退款会让库正常变小，
            // 但令牌权限收窄、接口只回一部分也长这样；缓存一换就再也对不出来，所以留一条日志。
            const _prevCached = storage.getCachedGames();
            const _prevCount = Array.isArray(_prevCached) ? _prevCached.length : 0;
            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,标记为脏
            if (_prevCount > 0 && games.length < Math.ceil(_prevCount * 0.8)) {
                console.warn(`[SGLV] 本次拉取比缓存少 ${_prevCount - games.length} 款（${_prevCount} → ${games.length}）`
                    + '：家庭组成员离开 / 退款属正常；若量级明显不对，检查 API Key 是否被降权、令牌是否过期');
            }
            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 / 锁区(各自有负缓存,失败不阻塞)
 //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');

 //数据刷新后渐进式更新(不阻塞当前渲染完成)
 // 立即 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);
        }
    }

 //数据刷新后渐进式更新 — 立即用缓存渲染后,后台异步重算大数据并局部 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 otherMembers = getFamilyOtherMembers(allGames, steamId);
 // 同步预热(单次遍历,无重复)— 完成后已落 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);
    }

 //局部 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 otherMembers = getFamilyOtherMembers(allGames, steamId);
 // 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() {
 //全部包裹在 try-catch 中，防止 getActiveSteamId/getAccessToken 抛出导致 unhandled rejection
        try {
 //无 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;
 //主题层 API——供测试与外部调试（SGLV_API_KEYS 基线已同步 +3 键）
    SGLV_API.getThemeId = getThemeId;
    SGLV_API.applySglvTheme = applySglvTheme;
    SGLV_API.getThemes = () => SGLV_THEMES;
 //以下函数被 SGIS 子闭包引用，需导出
    SGLV_API.buildPersonalTimeline = buildPersonalTimeline;
    SGLV_API.buildFamilyTimeline = buildFamilyTimeline;
    SGLV_API.fetchWishlistFromApi = fetchWishlistFromApi;
    SGLV_API.openGlobalSettings = openGlobalSettings;
 //供 SGIS 兄弟闭包经顶部别名桥接（社区图标 community_assets 新路径 + icon 成功缓存）。
 // 注意须在此处(渲染子闭包内,先于 SGIS 求值)导出——SGIS 顶部的 const 别名在求值时即固化绑定。
    SGLV_API.getGameIconUrl = getGameIconUrl;
 //桥接 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: 游戏库刷新时失效
 //DLC 数据库就绪判定——Barter.vg 数据库 OR Steam type map 任一加载即可
    SGLV_API.isDlcDbReady = () => !!(dlcDbData || appTypeMap);
 //导出 renderBody 与 panelEl 访问器，供外层作用域（switchToTab/_gsJumpToGame/bindGlobalSearchEvents）桥接调用
 // 背景：switchToTab 若误置于子闭包之外，会导致 panelEl/renderBody 越界 ReferenceError
    SGLV_API.renderBody = renderBody;
    SGLV_API.getPanelEl = () => panelEl;
 //桥接 computeInsightDataCachedSgis 供 SGIS 子闭包调用（修复 ReferenceError）
    SGLV_API.computeInsightDataCachedSgis = computeInsightDataCachedSgis;
 //桥接 detectWlPriceSymbol 供外层 _renderDetailContent 调用（修复 ReferenceError）
    SGLV_API.detectWlPriceSymbol = detectWlPriceSymbol;
 //桥接 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 */ }
    };

 // ==================== 锁区游戏数据加载 ====================
 // 数据源: steam-tracker.com API (Banned + Purchase disabled) + HTML 抓取 (Regional variant) + 手动导入
 //新增 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';
 //静态数据源（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]);

 /**
 *从 GitHub 静态数据源加载锁区游戏数据（jsdelivr CDN 加速）
 * 数据格式: { version, source, fetchedAt, totalCount, data: [{appid, name, category, categoryId, type, source, changedAt}] }
 *返回 { 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 || '',
            }));
 //提取远程 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;
    }

 /**
 *后台静默检查锁区数据远程版本——比较 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) {
 // 静默失败，不影响主流程
        }
    }

 /**
 * 加载锁区游戏数据（四级 fallback: 静态源 → API → HTML → 缓存）
 *缓存命中时后台静默检查远程 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');
 //后台静默检查远程 fetchedAt 是否有新版本
                _checkBlockedRemoteVersion(cached.fetchedAt || '');
                return { apps: state.blockedApps, source: state.blockedSource, fetchedAt: cached.fetchedAt || '' };
            }
 //负缓存——失败后短期不再重试,保护 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 = '';

 // 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);
 //成功后清负缓存
            negCacheClear(nsKey('blocked_neg'));
            report(3, isZh ? `完成 (${apps.length} 款)` : `Done (${apps.length})`);

 //数据更新后派发事件，供收藏浮窗监听并自动刷新 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);
 //失败入负缓存(仅当 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;
 //暴露 fetchedAt 供收藏浮窗显示数据更新时间
    SGLV_API.getBlockedFetchedAt = () => {
        const cached = cacheGet('blockedApps');
        return (cached && cached.fetchedAt) ? cached.fetchedAt : '';
    };
 // SGIS 是兄弟闭包，看不到本闭包里的 _ensureCoverFallbackDelegation。
 // 不导出的话侧栏 ensurePanel 会 ReferenceError，整段 initSidebar 中断。
    SGLV_API.ensureCoverFallbackDelegation = _ensureCoverFallbackDelegation;
    })();

 // ==================== 信息侧边栏 (sgis) ====================
 // 与 steam-game-info-sidebar 同样的能力, 复用本脚本的 state.ownedGames + storage,
 // 实现"导航栏按钮 + 右侧三角触发器 + 共享 API Key / 家庭组数据"

    (function () {
 //SGLV 子闭包导出的跨模块函数别名（SGLV_API 在外层作用域，SGLV 闭包完成后已填充）
        const buildPersonalTimeline = SGLV_API.buildPersonalTimeline;
        const buildFamilyTimeline = SGLV_API.buildFamilyTimeline;
        const fetchWishlistFromApi = SGLV_API.fetchWishlistFromApi;
        const openGlobalSettings = SGLV_API.openGlobalSettings;
 // getGameIconUrl 定义于上方主面板渲染子闭包（7718 行 IIFE），SGIS 兄弟闭包
 // 不可直接引用——裸引用抛 ReferenceError 被 renderProfile 外层 .catch 捕获，误报为
 // "用户档案获取失败: getGameIconUrl is not defined"（作用域事故）。
 // 经 SGLV_API 桥接：主面板渲染子闭包求值时已填充该成员，SGIS 渲染必可用。
        const getGameIconUrl = SGLV_API.getGameIconUrl;

 //愿望单页面检测 — 跳过浮动按钮创建，避免与 Wishlist Exporter 侧边栏冲突
        const IS_WISHLIST_PAGE = /\/wishlist(new)?\//i.test(location.pathname);

 // 在所有 Steam 商店页面挂载侧边栏
 //统一页面上下文检测，区分 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';

 //精简: SGIS 闭包共享安全数值转换助手 (修复 price?.toFixed is not a function,
 // Aug API 可能返回字符串)——原价格/送礼/评测等 6 处函数内重复定义,收敛于此。
        const num = (v) => { const n = Number(v); return isNaN(n) ? 0 : n; };

 //新增 UI 组件样式（价格对比表 / 评测 / 跨区送礼推荐）
 // CSS 已提取到顶部: CSS_PRICE


 //家庭组入库加载体验优化 —— 进度条 + 游戏框架骨架屏（参考 steam-friend-manager 加载体验）
 // CSS 已提取到顶部: CSS_LOAD

 // ==================== 紫青炫彩主题平衡 ====================
 // 设计目标：恢复原版紫蓝主色调 + 多彩语义 KPI，移除大面积金色造成的平淡感。
 // 金色仅保留用于：等级徽章、XP 进度条（原版设计即为金色）。
 // 紫色/靛蓝/青色作为主品牌色，KPI 卡片保留 t-blue/t-cyan/t-green/t-rose 语义色。
 // SGIS Hero 恢复背景图 + 紫色径向光晕 + 青色头像边框 + 紫蓝在线徽章。
 // CSS 已提取到顶部: CSS_THEME_PURPLE（由主题层按用户主题动态注入）


        const SGIS = {
            appId: APP_ID,
            open: false,
            tab: HAS_APP_ID ? 'overview' : 'profile',
            overview: null,
            cards: null,
            cardsLoading: false,
            prices: null,
            pricesLoading: false,
            pricesFetchedAt: 0,
            itadOverview: null,
            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,
            historyFetchedAt: 0,
            prediction: null,          // AI 价格预测结果
            predictionLoading: false,
            predictionError: null,
            familyShareSupported: null,
 // ---- appdetails API 增强信息 (工坊/截图/分类/捆绑包等) ----
            appDetailsExtra: null,            // 结构化附加信息 { workshopSupported, categories, platforms, packages, screenshots, ... }
            appDetailsExtraLoading: false,
 // ---- DLC 名称映射 (appid -> name), 异步获取 ----
            dlcNames: null,                   // { [appid]: { name, isFree } } 或 null
            dlcNamesLoading: false,
            ownersPlaytime: {},
            ownersPlaytimeFetching: false,
 // ---- 相似游戏推荐 + 库存标记 + 类型扩展推荐 (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
 //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 个
 // ---- 评测标签页 ----
            reviews: null,                    // 评测数据 { summary, reviews[], query_summary }
            reviewsLoading: false,
            reviewsFilter: { rec: 'all', playtime: 'all', language: 'all', purchase: 'all', keyword: '', regexMode: false },
            reviewsExpanded: new Set(),       // 展开的评测 ID 集合
 // ---- 价格图表/DRM 缓存 ----
            priceChartRange: 'all',           // 价格走势图时间范围 ('6m'|'1y'|'all')
            drmInfo: null,                    // DRM 检测结果缓存
 // ---- gamestatus.info 破解状态 ----
            gameStatusInfo: null,             // 破解状态数据 { status, protections, groups, crackDate, isAAA, ... }
            gameStatusLoading: false,         // 是否正在加载
            profileFeaturesStatus: null,       // v2.9.93: 资料受限状态 { status, label, source }
            profileFeaturesLoading: false,     // v2.9.93: 是否正在异步获取
 // ---- 跨区送礼推荐 ----
            giftRec: null,                    // 送礼推荐数据 { best, alternatives[], userRegion }
            giftRecLoading: false,
 // ---- 用户档案 (首页浮窗) ----
            profile: null,
            profileLoading: false,
            profileError: null,
            activity: null,
            activityLoading: false,
 // ---- 动态标签子分类 (官方动态 / 个人入库 / 家庭组入库) ----
            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,
 // ---- 洞察标签页 ----
            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,
 // ---- 社交标签页 (好友列表) ----
            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
 // ---- 概览页在线玩家数 + 评测摘要增强 ----
            currentPlayers: null,           // { count: number } 当前在线玩家数, null=未获取/超时
            currentPlayersLoading: false,
 //负缓存——失败/无数据/未上市后置 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) {
 //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 '—'; }
        }

 //相对时间（用于评测项显示）
        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 工具（委托 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 对象(不抛,调用方走降级)
 // SGLVCore.gmFetchJson/Text 已带 2 次重试 + 状态码校验
        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)
            );
        }

 // ---- 汇率语义对照（三套汇率表示，数据源单一事实来源） ----
 // 仓库内存在三种汇率表示语义。数据源已是单一事实来源（本脚本 refreshRates 优先委托
 // SGLVAppDetail.getRates 拉取，见下方注释），差异仅在表示格式：
 // ① 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.31.5：同步触发 AI Agent 桥（汇率是 AI 回答中文名/跨区比价的高频依赖）
            try { scheduleSaaBridge(); } catch { /* ignore */ }
        }
 //优化: 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 });
 //精简: httpGet 底层走 SGLVCore.gmFetchText,已含安全解码(等价旧 safeResponseText)
                const data = JSON.parse(r.responseText);
                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(r.responseText);
                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];
        }

 //汇率桥接层 —— 统一折算管道（三套汇率语义收敛第一步）
 // SGIS 表('sgis-rates')为事实来源,语义「1 外币 = X CNY」;
 // USD 枢纽表 U[code] = C['USD'] / C[code](键转小写 apiCode),供 CUR.convert 消费。
        let _usdRatesMemo = null, _usdRatesMemoTs = -1;
        function getUsdRates() {
 //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;
 //派生逻辑委托 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);
        }

 // ---- 比价目标货币切换（价格 Tab 多地区低价排行） ----
 // 热门低价结算货币置前（用户比价高频目标），CNY 默认居首；HKD 无对应比价区域但属热门
 // 结算货币一并纳入；其余覆盖 REGIONS 全部区域币种，保证任一区域原生价格可作比价基准。
        const PRICE_TARGET_CURRENCIES = [
            { code: 'CNY', symbol: '¥',    name: '人民币' },
            { code: 'INR', symbol: '₹',    name: '印度卢比' },
            { code: 'UAH', symbol: '₴',    name: '乌克兰格里夫纳' },
            { code: 'HKD', symbol: 'HK$',  name: '港币' },
            { code: 'TRY', symbol: '₺',    name: '土耳其里拉' },
            { code: 'ARS', symbol: 'AR$',  name: '阿根廷比索' },
            { code: 'KZT', symbol: '₸',    name: '哈萨克斯坦坚戈' },
            { code: 'RUB', symbol: '₽',    name: '俄罗斯卢布' },
            { code: 'USD', symbol: '$',    name: '美元' },
            { code: 'EUR', symbol: '€',    name: '欧元' },
            { code: 'GBP', symbol: '£',    name: '英镑' },
            { code: 'JPY', symbol: '¥',    name: '日元' },
            { code: 'KRW', symbol: '₩',    name: '韩元' },
            { code: 'BRL', symbol: 'R$',   name: '巴西雷亚尔' },
            { code: 'MXN', symbol: 'MX$',  name: '墨西哥比索' },
            { code: 'CLP', symbol: 'CLP$', name: '智利比索' },
            { code: 'COP', symbol: 'COL$', name: '哥伦比亚比索' },
            { code: 'PLN', symbol: 'zł',   name: '波兰兹罗提' },
        ];
        function priceTargetCurInfo(code) {
            return PRICE_TARGET_CURRENCIES.find(c => c.code === code) || { code: String(code || 'CNY'), symbol: String(code || 'CNY'), name: String(code || 'CNY') };
        }
 // 任意币种 → 目标币种折算。汇率表 C 语义「1 外币 = X CNY」，交叉汇率 = amount × C[from] / C[target]；
 // 目标为 CNY 时与既有 convertToCNY 管道完全等价（含 lib 桥接/软降级/rateReady 门控），
 // 非目标侧仅多一步 ÷C[target]，缺目标汇率 → null（与 convertToCNY 缺率语义一致，消费方 filter 自然生效）。
        function convertToCurrency(amount, fromCode, toCode) {
            const cny = convertToCNY(amount, fromCode);
            if (cny == null) return null;
            if (!toCode || toCode === 'CNY' || toCode === 'RMB') return cny;
            const rates = getRates();
            if (!rates || typeof rates[toCode] !== 'number' || !(rates[toCode] > 0)) return null;
            return cny / rates[toCode];
        }
 // 生效目标货币：存储偏好缺汇率/非法时回落 CNY（避免整表折算失败空态），fallback 标记供 UI 提示。
 // 返回 { code, fallback, wanted }；rateReady=false 期间 getRates() 可能有旧表——按表内有无该币种判定即可，
 // 汇率整体未就绪时 convertToCNY 本身返回 null，走既有"未获取到有效价格"空态。
        function getEffectivePriceTarget(stored) {
            const t = stored != null ? stored : storage.getPriceTargetCurrency();
            if (!t || t === 'CNY') return { code: 'CNY', fallback: false };
            const rates = getRates();
            if (rates && typeof rates[t] === 'number' && rates[t] > 0) return { code: t, fallback: false };
            return { code: 'CNY', fallback: true, wanted: t };
        }

 // ---- 卡牌价格(整合 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;

 //可变发行商费率手续费计算 (与 steam-badges-card-view 保持一致)
 // 不用固定费率 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;
 //可变发行商费率 — 从市场 API 读取每张卡的实际发行商费率
 // 不同游戏的发行商费率可能不同 (默认 10%, 部分游戏为 5% 或其他)
                    const publisherFeePercent = _readPublisherFeeFromItem(item);
 //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;
        }

 // ---- 徽章市场数据轻量抓取 (用于价值分析仪表板) ----
 // 只抓 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++; }
 //读取可变发行商费率 (与 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,
 //增加中位数和忽略最高价统计 (借鉴 Steam Get Trading Card Info 脚本)
                medianPrice: 0,    // 中位数价格 (分), 抗极端高价干扰
                avgNoMax: 0,       // 忽略最高价后的均价 (分)
                netIncome: 0,      // 预计税后总收入 (分), 使用 _calculateSellerReceives 可变费率计算
                updatedAt: Date.now(),
            };
 //计算中位数和忽略最高价均价
            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;
                    }
 //预计税后总收入: 均价 * 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); }
        }

 // ---- 价值分析引擎 (参考 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;
 //用 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;
 //用真实 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`;
        }
 // 区域表 —— 每个区的「当前结算币种」以 Steam 实测为准（2026-10-29 实测 appdetails）。
 // TR / AR 已改用美元结算（返回 currency=USD，价与美区同源），旧表写 TRY/ARS 会出两类问题：
 //   ① AugmentedSteam 镜像里 TR 仍是旧的 TRY 价 → 按旧期望校验会放行 → 显示 Steam 已不收的旧价；
 //   ② Steam 官方返回 USD → 按旧期望判「币种不符」→ 好的区被误丢。
 // curAlt = 该区可能残留的历史本币，只有 Steam 官方源可信、镜像源（Aug/ITAD）必须严格按当前币种校验。
        const REGIONS = [
            { code: 'CN', name: '中国', currency: 'CNY' },
            { code: 'US', name: '美国', currency: 'USD' },
            { code: 'AR', name: '阿根廷', currency: 'USD', curAlt: ['ARS'], usd: true },
            { code: 'TR', name: '土耳其', currency: 'USD', curAlt: ['TRY'], usd: true },
            { 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' },
        ];
 // 默认比价区：实测都有本币报价的低价区（不含 TR/AR —— 已按美元结算，与美区同价、无比差价意义）
        const PRIORITY_REGIONS = ['CN', 'US', 'RU', 'IN', 'BR', 'UA', 'KZ', 'CL', 'CO'];
 //ITAD 增强模式扩展区域 (15+ 区域)
 //移除 'EU' (非有效 ISO 3166-1 alpha-2 国家代码, 导致 ITAD API HTTP 400)
 //移除 'TR' / 'AR' (已按美元结算, 与美区同价; ITAD 镜像里仍可能是旧本币, 容易出旧价)
        const EXTENDED_REGIONS = ['CN', 'US', 'RU', 'IN', 'BR', 'UA', 'KZ', 'CL', 'CO', 'PL', 'MX', 'JP', 'KR', 'GB', 'VN', 'ID'];
 // 该区当前期望币种（Steam 官方口径）
        function regionExpectedCurrency(code) {
            const r = REGIONS.find(x => x.code === code);
            return r ? r.currency : '';
        }
 // 该区可接受的历史本币（仅 Steam 官方源可信）
        function regionAltCurrencies(code) {
            const r = REGIONS.find(x => x.code === code);
            return (r && Array.isArray(r.curAlt)) ? r.curAlt : [];
        }
        function regionAcceptsCurrency(code, cur) {
            if (!cur) return true;
            if (cur === regionExpectedCurrency(code)) return true;
            return regionAltCurrencies(code).indexOf(cur) >= 0;
        }

 // 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;
 //检测币种不匹配 — Steam API 对登录用户可能忽略 cc= 参数,
 // 返回用户实际所在地区的价格(如请求 CN 但返回 INR), 这种数据是错误的, 应标记为失败
                        const expectedRegion = REGIONS.find(r => r.code === countryCode);
 // Steam 官方是权威源：允许该区残留的历史本币（如 TR 早期的 TRY），只拒绝「完全不相干的币种」
                        if (expectedRegion && expectedRegion.currency && !regionAcceptsCurrency(countryCode, 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;
 //期望币种防脏检查 —— Aug 返回币种与 REGIONS 期望币种不匹配时视为脏数据(该次抓取失败),
 // 对齐函数既有失败返回形态;FREE/未知地区不受影响
 // Aug 是镜像源：只认该区「当前」结算币种。TR/AR 的历史本币(TRY/ARS)在 Aug 里仍停在旧价格上，
 // 放行就会显示 Steam 已不收的旧价 —— 一律判为过时数据，降级 Steam 官方兜底拿当前价。
                const _expCur = regionExpectedCurrency(countryCode);
                if (_expCur && cur2.currency && cur2.currency !== _expCur) {
 //记录被拒绝的脏数据,便于观察 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);
        }

 //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));
        }

 //带限速的单地区价格获取（用于 9 区并发对比，3 worker + 1s 间隔）
        async function fetchOneRegionPriceRateLimited(appId, countryCode) {
            await steamApiRateLimit();
            return await fetchOneRegionPrice(appId, countryCode);
        }

 // 多地区价格: 并发获取, 去重 (Steam 官方 API 对登录用户会返回相同的国家价格)
 //改用 3 个并发 worker + 1s 请求间隔（预留位限速模式）
        async function fetchMultiRegionPrices(appId) {
 // 请求区集 = 默认比价区 + 用户所在区。默认集里通常没有用户本区，
 // 不带上它，面板「本地区」那行就永远只有区名没有价。
            const userCc = (document.cookie.match(/steamCountry=(\w{2})/) || [])[1] || '';
            const regions = (userCc && PRIORITY_REGIONS.indexOf(userCc) < 0 && REGIONS.find(r => r.code === userCc))
                ? [userCc].concat(PRIORITY_REGIONS)
                : PRIORITY_REGIONS.slice();
            const results = await mapLimit(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: regions[i], error: r.error });
            });
 // 检测是否所有结果都"看起来一样" (币种 + 价格一致), 这种情况说明 API 被缓存, 全部失败
 // 但前提是各区期望币种互不相同 —— 否则 TR/AR 与美区同为 USD 时价格一样是事实，
 // 不能把整组区都判成「疑似缓存」。
            const expCurSet = new Set(regions.map(cc => regionExpectedCurrency(cc)));
            const curSharedInSet = expCurSet.size < regions.length;
            const allSameCurrency = !curSharedInSet
                && 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: regions[s.idx], error: '区域数据相同(疑似被缓存)' }));
            } else {
                successList.forEach(s => {
                    const cc = regions[s.idx];
                    const k = `${s.data.currency}:${Number(s.data.price).toFixed(2)}`;
 // 去重只针对「串区脏数据」：Steam 忽略 cc= 时会拿别区的价，币种与本区期望对不上。
 // 但当多个区期望同一币种（TR/AR 已按美元结算，与美区同源）时，同价是事实而非脏数据，
 // 两个区都要留 —— 否则总有一个区被误判成「重复」失败。
                    const expCur = regionExpectedCurrency(cc);
                    const curShared = regions.filter(x => regionExpectedCurrency(x) === expCur).length > 1;
                    const dupKey = curShared ? null : k;
                    if (dupKey === null || !seenKey.has(dupKey)) {
                        if (dupKey !== null) seenKey.add(dupKey);
                        prices.push(s.data);
                    } else {
 // 重复价格 -> 视为失败
                        failed.push({ region: cc, error: '与已有地区价格重复' });
                    }
                });
            }
            return { prices, failed };
        }

 // ---- 精致 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>`,
 //收藏快捷按钮图标（心形，与主面板收藏按钮同语义）
            heart: `<svg class="sgis-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" fill="currentColor" fill-opacity="0.12"/></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 / 年龄限制共用）
            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>`,
 //资料受限 — 用户轮廓 + 警告三角
            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() {
 //愿望单页面不创建浮动按钮，让 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;
 //动态标题/图标 - 游戏页(带 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.setAttribute('data-sglv-plugin-ui', '1');
            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-collection-btn" title="${isZh ? '游戏收藏' : 'Game Collection'}">${SGIS_ICONS.heart}</button>
                        <button class="sgis-icon-btn" id="sgis-shelf-btn" title="${isZh ? '暂存箱（与购物车增强互通）' : 'Shelf'}"><span style="display:flex;align-items:center;justify-content:center">${SGIS_ICONS.package}</span><span class="sgsh-badge" data-sgsh-badge style="display:none"></span></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);
// v2.23.1: SGIS 侧栏（收藏浮窗入口 / 暂存箱入口等）封面走 SGLVCoverFallback 降级
// 函数定义在 SGLV 子闭包内，经 SGLV_API 导出；失败只跳过封面降级，不能挡住侧栏初始化
            try {
                if (typeof SGLV_API.ensureCoverFallbackDelegation === 'function') {
                    SGLV_API.ensureCoverFallbackDelegation(panel);
                }
            } catch (e) { console.warn('[SGIS] 封面降级委托注册失败', e); }
            panel.querySelector('#sgis-close-btn').addEventListener('click', closePanel);
            panel.querySelector('#sgis-settings-btn').addEventListener('click', () => openGlobalSettings());
 //主题快速切换按钮——典雅紫 ⇄ 经典蓝一键互切,保存偏好并即时热切换
 // (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();
 //收藏快捷按钮——直接打开游戏收藏浮窗（与主面板心型按钮/子菜单同一入口）
 // 就绪判定走 window.SGLVCollection._hostReady（主脚本 init 握手后回写），未就绪可见化提示
            panel.querySelector('#sgis-collection-btn').addEventListener('click', () => {
                const col = window.SGLVCollection;
                if (!col || !col._hostReady || typeof col.openCollection !== 'function') {
                    if (typeof sglvToast !== 'undefined' && sglvToast) {
                        sglvToast.warning(isZh ? '收藏模块未加载或版本不兼容' : 'Collection module not loaded or incompatible');
                    }
                    console.warn('[SGIS] 游戏收藏不可用: SGLVCollection=', col, 'ready=', col && col._hostReady);
                    return;
                }
                try {
                    col.openCollection();
                } catch (err) {
                    console.error('[SGIS] 收藏浮窗打开失败:', err);
                    if (typeof sglvToast !== 'undefined' && sglvToast) {
                        sglvToast.warning(isZh ? '收藏模块异常，详见控制台' : 'Collection error, see console');
                    }
                }
            });
//暂存箱快捷按钮——打开暂存箱浮窗（与「Steam 购物车增强」共用 sce_cart_shelf_v1 互通）
// 判定走 window.SGLVShelf._hostReady（主脚本 init 握手后回写），与收藏按钮同一范式。
// 浮窗与侧滑栏可共存：.sglv-overlay z-index 999999 < #sgis-panel 1000002。
            const _shelfBtn = panel.querySelector('#sgis-shelf-btn');
            if (_shelfBtn) {
                const _shelf = window.SGLVShelf;
                const _shelfUsable = () => !!(window.SGLVShelf && window.SGLVShelf._hostReady && typeof window.SGLVShelf.openShelf === 'function');
                if (!_shelfUsable()) {
                    _shelfBtn.title = isZh ? '暂存箱模块未加载或版本不兼容' : 'Shelf module unavailable';
                    _shelfBtn.style.opacity = '0.45';
                    _shelfBtn.addEventListener('click', () => {
                        sglvToast.warning(isZh ? '暂存箱模块未加载，请检查脚本依赖' : 'Shelf module not loaded');
                        console.warn('[SGIS] 暂存箱不可用: SGLVShelf=', _shelf, 'ready=', _shelf && _shelf._hostReady);
                    });
                } else {
                    _shelfBtn.addEventListener('click', () => {
                        try {
                            window.SGLVShelf.openShelf();
                        } catch (err) {
                            console.error('[SGIS] 暂存箱打开失败:', err);
                            sglvToast.warning(isZh ? '暂存箱异常，详见控制台' : 'Shelf error, see console');
                        }
                    });
                    // 角标：面板此刻才刚建好，需主动补一次。之后由库 emitChange → setBadge
                    // 点亮红点（不写条数；不要在 onChange 里再填 textContent，会把红点盖回数字）
                    try {
                        window.SGLVShelf.setBadge(window.SGLVShelf.getCount());
                    } catch (e) { console.warn('[SGIS] 暂存箱角标初始化失败', e); }
                }
            }
            panel.querySelector('#sgis-refresh-btn').addEventListener('click', () => {
                const refreshBtn = panel.querySelector('#sgis-refresh-btn');
                refreshBtn.classList.add('sgis-spin');
                const cached = _tabPanes.get(SGIS.tab);
                if (cached) cached.dataset.ready = '';
                _activateSgisTab(SGIS.tab, { force: true });
                requestAnimationFrame(() => requestAnimationFrame(() => refreshBtn.classList.remove('sgis-spin')));
            });
            panel.querySelectorAll('.sgis-tab').forEach(tabBtn => {
                tabBtn.addEventListener('click', () => {
                    _activateSgisTab(tabBtn.dataset.tab, { force: false });
                });
            });
            document.addEventListener('keydown', e => {
                if (e.key !== 'Escape' || !SGIS.open) return;
//暂存箱浮窗打开时，ESC 归浮窗（先关浮窗内的弹窗，再关浮窗本身），
// 否则一次 ESC 会把浮窗和侧滑栏一起关掉，用户体感为「点了没反应然后全没了」
                const sh = window.SGLVShelf;
                if (sh && typeof sh.isOpen === 'function' && sh.isOpen()) return;
                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');
            _activateSgisTab(SGIS.tab, { force: 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();
        }
 // 每个 Tab 一份 DOM。切走时摘下节点（监听还在），切回已渲染的页只做挂载。
 // #sgis-body 只留当前页。价格历史如果挂在 body 上，切走后会留在别的栏目顶部，刷新再追加一份。
        const _tabPanes = new Map();
        const _tabScroll = new Map();
        let _sgisSwitchGen = 0;
        let _paintTab = null;
        let _sgisSwitchTimer = 0;
        let _pricesGen = 0;
        let _historyGen = 0;
        const SGIS_TAB_SWITCH_MS = 250;

        function _ensureSgisPane(tab) {
            let pane = _tabPanes.get(tab);
            if (!pane) {
                pane = document.createElement('div');
                pane.className = 'sgis-pane';
                pane.dataset.sgisPane = tab;
                _tabPanes.set(tab, pane);
            }
            return pane;
        }
        function _armSgisTabs(on) {
            const tabs = document.getElementById('sgis-tabs');
            if (!tabs) return;
            tabs.classList.toggle('is-arming', !!on);
            if (on) tabs.setAttribute('aria-busy', 'true');
            else tabs.removeAttribute('aria-busy');
        }
        function _sgisPaneReady(pane) {
            if (!pane || pane.dataset.ready !== '1') return false;
            for (const ch of pane.children) {
                if (ch.classList.contains('sgis-tab-pending') || ch.classList.contains('sgis-load-block')) return false;
            }
            return true;
        }
        function _showSgisPane(tab) {
            const body = document.getElementById('sgis-body');
            if (!body) return;
            const pane = _ensureSgisPane(tab);
            const already = pane.parentNode === body;
            Array.from(body.children).forEach(ch => {
                if (ch === pane) return;
                if (ch.classList && ch.classList.contains('is-active')) ch.classList.remove('is-active');
                ch.remove();
            });
            if (pane.parentNode !== body) body.appendChild(pane);
            if (!pane.classList.contains('is-active')) pane.classList.add('is-active');
            if (!already) body.scrollTop = _tabScroll.get(tab) || 0;
        }
        function _showSgisPending(tab) {
            const pane = _ensureSgisPane(tab);
            pane.dataset.ready = '';
            pane.innerHTML = '<div class="sgis-state sgis-tab-pending"><div class="sgis-spinner"></div></div>';
            _showSgisPane(tab);
            const body = document.getElementById('sgis-body');
            if (body) body.scrollTop = 0;
        }
        function _invalidateSgisPanes() {
            _tabPanes.forEach(p => { p.dataset.ready = ''; });
        }
        function _activateSgisTab(next, opts) {
            const force = !!(opts && opts.force);
            const fromOther = SGIS.tab !== next;
            const body = document.getElementById('sgis-body');
            if (body && SGIS.tab && SGIS.tab !== next) _tabScroll.set(SGIS.tab, body.scrollTop);
            const root = document.getElementById('sgis-panel');
            if (root) root.querySelectorAll('.sgis-tab').forEach(b => b.classList.toggle('active', b.dataset.tab === next));
            const pane = _tabPanes.get(next);
            const ready = _sgisPaneReady(pane);
            if (!force && next === SGIS.tab && ready) return;
            // 连点还在等、价格请求没回来、或这一页正在加载：不要把内容清掉。
            // 只剩切换占位、定时器却没了，说明上次渲染被取消，再点一次要能重新画。
            if (!force && next === SGIS.tab && pane && !ready) {
                if (_sgisSwitchTimer || (next === 'prices' && SGIS.pricesLoading)) return;
                if (pane.querySelector('.sgis-load-block')) return;
                if (!pane.querySelector('.sgis-tab-pending') && pane.querySelector('.sgis-state')) return;
            }
            SGIS.tab = next;
            if (_sgisSwitchTimer) { clearTimeout(_sgisSwitchTimer); _sgisSwitchTimer = 0; }
            if (!force && ready) {
                _armSgisTabs(false);
                _showSgisPane(next);
                return;
            }
            const gen = ++_sgisSwitchGen;
            _showSgisPending(next);
            const run = () => {
                _sgisSwitchTimer = 0;
                _armSgisTabs(false);
                if (gen !== _sgisSwitchGen || SGIS.tab !== next) return;
                _paintTab = next;
                renderTab(next, force);
            };
            // 刷新、以及打开面板时的当前页，立刻画。从别的标签点过来才等连点停下来，避免每个标签都打一轮请求。
            if (force || !fromOther) {
                if (typeof requestAnimationFrame === 'function') requestAnimationFrame(run);
                else setTimeout(run, 0);
                return;
            }
            _armSgisTabs(true);
            _sgisSwitchTimer = setTimeout(run, SGIS_TAB_SWITCH_MS);
        }
        function setBody(html, tab) {
            const key = tab || _paintTab || SGIS.tab;
            const pane = _ensureSgisPane(key);
            pane.innerHTML = html;
            pane.dataset.ready = '1';
            if (key === SGIS.tab) _showSgisPane(key);
        }
        function renderLoading(text, tab) {
 //状态点 + 文字 + 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>`, tab);
            // 整页加载不算画完。切走再切回来要能重新挂上，而不是把这句提示当成成品。
            if (tab) {
                const pane = _tabPanes.get(tab);
                if (pane) pane.dataset.ready = '';
            }
        }

 //增强版加载——带阶段进度条 + 游戏骨架占位（参考 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 || {});
 //阶段条/骨架行改经共享段生成器与 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, tab) {
 //错误状态点 + 大字提示 + 重试按钮
            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>`, tab);
            const errTab = tab || _paintTab || SGIS.tab;
            const retryBtn = (_tabPanes.get(errTab) || document).querySelector('.sgis-retry-btn');
            if (retryBtn) {
                retryBtn.addEventListener('click', () => {
 // 清除当前标签页缓存后重新渲染
                    resetTabCache(errTab, 'retry');
                    const cached = _tabPanes.get(errTab);
                    if (cached) cached.dataset.ready = '';
                    if (SGIS.tab === errTab) _activateSgisTab(errTab, { force: 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);
            });
 //从第一个购买区域(基础游戏)提取价格,避免抓取捆绑包价格
 // 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;
        }

 // ==================== 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 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;
        }

 //异步获取 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 一致）
 // 未登录兜底：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>`
                : '';

 // 工具栏 - : 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>`;

 // 卡片网格 - : 经 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;
 //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 '';

 // 加载中 - : 经 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>`;
            }
 // 加载失败 - : 经 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，无封面/价格）
 // : 经 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) {
 //显示正在检查动态数据的提示
                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 = '你已拥有';
 //新增 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;
            }
        }

 // ==================== 在线玩家数 + 评测摘要增强 ====================
 //未上市游戏判定——未发售游戏无在线玩家/评测数据，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() {
 //已有数据/加载中/已判定不可用（含未上市）则直接跳过
            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() {
 //未上市游戏无评测数据(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();
            }
        }

 // : 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 _renderOverviewXhhInfoRow() {
            return `<div data-sgis-xhh-info-appid="${APP_ID}" aria-live="polite"></div>`;
        }

        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() {
            _paintTab = 'overview';
            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>
                        ${_renderOverviewAliasRow()}
                        <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>` : ''}
                    ${_renderOverviewXhhInfoRow()}
                    ${(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(() => {});
            }
 //游戏别名 (Steam EN + 小黑盒中文别名) —— 主名替换(方案 A) + EN 药丸,异步按需获取 + 长缓存,失败短路 6h
            if (HAS_APP_ID) {
                fetchGameAlias(APP_ID).then(() => {
                    if (SGIS.tab === 'overview') _applyAliasToDom(APP_ID);
                }).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(() => {});
                }
            }
        }

 // ---- 勋章标签 ----
 //重写卡牌获取流程 — 移除有缺陷的社区登录前置检测,
 // 改为直接请求市场数据 + SGLVBadge 多重降级检测卡牌支持状态。
 // 旧版 checkCommunityLogin 误判 (网络超时/页面结构变更/Cloudflare) 会导致
 // "Steam 社区未登录" 错误提示, 但 Steam 账户已登录即社区已登录, 不存在此问题。

 //获取 SGLVBadge 库实例 (sglv-badge.lib.js)
        function _getBadgeLib() {
            return (typeof unsafeWindow !== 'undefined' && unsafeWindow.SGLVBadge)
                || (typeof window !== 'undefined' && window.SGLVBadge);
        }

 //将主脚本已加载的 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('正在获取集换式卡牌价格…');

 //注入卡牌数据库, 直接请求市场数据 (无登录前置阻断)
            _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);
            });
        }

 //市场返回 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();
            }
        }

 //市场请求失败 — 多重降级检测卡牌支持状态
        async function _handleCardFetchError(error) {
            _paintTab = 'medals';
            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);
            }
        }

 //使用 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() {
            _paintTab = 'medals';
            const data = SGIS.cards;
 //SCE 降级数据 — 有卡牌名称但无价格, 走专用渲染
            if (data._source === 'steamcardexchange') {
                renderMedalsSCEContent(data);
                return;
            }
            const allCards = [...(data.regular || []), ...(data.foil || [])];
            if (allCards.length === 0) {
 //区分"确认无卡牌"和"市场返回空(未检测)"
                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;
 //计算中位数和忽略最高价均价 (借鉴 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 ? '—' : '');
 //卡牌图作为背景 (勋章页面), 缩略图同时保留; 失败时用精美 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();
                    });
                });
 //异步预加载卡牌图, 成功则启用背景图, 失败则保持默认(不显示背景, 用 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;
                });
            }
        }

 //SteamCardExchange 降级渲染 — 有卡牌名称但无价格数据
 // 当市场 API 失败或返回空, 但 SGLVBadge 确认游戏有卡牌时使用
        function renderMedalsSCEContent(data) {
            _paintTab = 'medals';
            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预测) ----
 // 追加块只进价格 pane。挂到 #sgis-body 上会在切换后留在别的栏目里，刷新再叠一份。
        function _pricesPane() {
            return _tabPanes.get('prices') || null;
        }
        function _predictHost() {
            const pane = _pricesPane();
            if (!pane) return null;
            return pane.querySelector('[data-sgis-price-block="history"]') || pane;
        }
        function _fillPriceBlock(name, html) {
            const pane = _pricesPane();
            if (!pane) return null;
            let el = pane.querySelector('[data-sgis-price-block="' + name + '"]');
            if (!html) {
                if (el) el.remove();
                return null;
            }
            if (!el) {
                el = document.createElement('div');
                el.dataset.sgisPriceBlock = name;
                pane.appendChild(el);
            }
            el.innerHTML = html;
            return el;
        }
        function _ensurePriceBlock(name) {
            const pane = _pricesPane();
            if (!pane) return null;
            let el = pane.querySelector('[data-sgis-price-block="' + name + '"]');
            if (!el) {
                el = document.createElement('div');
                el.dataset.sgisPriceBlock = name;
                pane.appendChild(el);
            }
            return el;
        }
        function _mountHistoryPlaceholder() {
            _fillPriceBlock('history', `<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:12px">正在读取历史价格…</div>
            </div>`);
        }
        function appendHistoryPricesToBody(historyData) {
            const pane = _pricesPane();
            if (!pane) return;
            const hasData = !!(historyData && (historyData.history?.length || historyData.lowest || historyData.discounts?.length));
            const block = _ensurePriceBlock('history');
            if (!block) return;
            block.innerHTML = hasData ? renderHistoryPricesSection(historyData) : '';
            if (hasData) bindPriceChartRangeEvents(historyData);
            appendPredictButton(block, hasData);
            if (SGIS.prediction) appendPredictionResult(block);
        }
        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(' / ');
 //无历史价格数据时按钮置灰 + 提示文案
            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 = bodyEl.querySelector('#sgis-predict-trigger');
            if (btn && !disabled) {
                btn.addEventListener('click', () => triggerPrediction());
            }
        }
        function triggerPrediction() {
 //防重复点击 + 完整日志 + 超时保护 + 按钮等待状态
            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;

 // 按钮和结果都落在价格 pane 里。用户中途切走时，完成结果写回这个 pane，不会贴到当前栏目。
            const liveBtn = () => {
                const host = _predictHost();
                return host && host.querySelector('#sgis-predict-trigger');
            };
            const restoreBtn = () => {
                const b = liveBtn();
                if (!b) return;
                b.disabled = false;
                b.style.opacity = '';
                b.style.cursor = '';
                b.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 showPredictError = (message) => {
                const host = _predictHost();
                if (!host) return;
                host.querySelectorAll('.sgis-predict-error').forEach(n => n.remove());
                const errDiv = document.createElement('div');
                errDiv.className = 'sgis-state sgis-error sgis-predict-error';
                errDiv.style.cssText = 'padding:8px';
                errDiv.textContent = message;
                host.appendChild(errDiv);
            };
            const btn = liveBtn();
            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}`;
            }

            const host = _predictHost();
            let loadingEl = host && host.querySelector('#sgis-predict-loading');
            if (!loadingEl && host) {
                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}`;
                host.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 || '';

 //超时保护 (120s, 比 callAiApi 的 90s 稍长, 覆盖提示词加载时间)
            let timeoutReached = false;
            const timeoutId = setTimeout(() => {
                if (SGIS.predictionLoading) {
                    timeoutReached = true;
                    console.warn('[SGIS] AI预测超时 (120s无响应)');
                    SGIS.predictionLoading = false;
                    const timeoutHost = _predictHost();
                    const ld = timeoutHost && timeoutHost.querySelector('#sgis-predict-loading');
                    if (ld) ld.remove();
                    restoreBtn();
                    showPredictError(`⚠️ ${T.aiPredictFail}: ${isZh ? '请求超时(120s无响应), 请检查网络或API配置' : 'Request timeout (120s), check network or API config'}`);
                }
            }, 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;
                    const doneHost = _predictHost();
                    const ld = doneHost && doneHost.querySelector('#sgis-predict-loading');
                    if (ld) ld.remove();
                    restoreBtn();
                    if (doneHost) appendPredictionResult(doneHost);
                })
                .catch(e => {
                    clearTimeout(timeoutId);
                    if (timeoutReached) return; // 超时已处理, 丢弃错误
                    console.error('[SGIS] AI预测失败:', e);
                    SGIS.predictionError = e.message;
                    SGIS.predictionLoading = false;
                    const failHost = _predictHost();
                    const ld = failHost && failHost.querySelector('#sgis-predict-loading');
                    if (ld) ld.remove();
                    restoreBtn();
                    showPredictError(`⚠️ ${T.aiPredictFail}: ${e.message}`);
                });
        }
        function appendPredictionResult(bodyEl) {
            if (!SGIS.prediction || !bodyEl) return;
            bodyEl.querySelectorAll('.sgis-predict-section').forEach(n => n.remove());
            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>`;
        }
 //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 || {};
 //期望币种防脏检查 —— ITAD 返回币种与 REGIONS 期望币种不匹配时计入 failed(复用既有跳过语义)
                const expCur = (REGIONS.find(r => r.code === country) || {}).currency;
                if (expCur && priceObj.currency && priceObj.currency !== expCur) {
 //记录被跳过的脏数据,便于观察 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)}`;
 // 同上：期望币种被多个区共用时（TR/AR 与美区同为 USD），同价是事实不是脏数据，不去重
                const curShared = Object.keys(regionPrices).filter(x => regionExpectedCurrency(x) === expCur).length > 1;
                const dupKey = curShared ? null : k;
                if (dupKey !== null && seenKey.has(dupKey)) { failed.push({ region: country, error: '与已有地区价格重复' }); continue; }
                if (dupKey !== null) seenKey.add(dupKey);
                prices.push({
                    region: country,
                    price: priceObj.amount || 0,
                    currency: priceObj.currency || '',
                    discount: deal.cut || 0,
                    initial: regularObj.amount || 0,
                    source: 'itad',
                });
            }
            return { prices, failed };
        }

 //ITAD 增强模式 — 多商店比价 + 活跃 Bundle 展示
        function appendItadOverviewToBody() {
            const overview = SGIS.itadOverview;
            if (!overview || !overview.prices || !overview.prices.length) return;
            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>`;
            _fillPriceBlock('itad', storeCompareHtml + histLowHtml + bundleHtml + badge);
        }

 // 价格请求代数。切走标签不取消（结果写回价格 pane），新的一次价格渲染会让旧响应作废。
 // 缓存键带区域集签名：区域集一改，旧缓存（2h TTL）里的旧区集不该继续命中并显示旧区。
        const PRICE_REGIONS_SIG = PRIORITY_REGIONS.join('') + '|' + EXTENDED_REGIONS.join('');
        function _pricesCacheKey() { return 'prices_' + APP_ID + '_' + PRICE_REGIONS_SIG; }
        function _itadCacheKey() { return 'itadOverview_' + APP_ID; }
        function _historyCacheKey() { return 'historyPrices_' + APP_ID; }
        function _pricesAreFresh() {
            if (SGIS.pricesFetchedAt && Date.now() - SGIS.pricesFetchedAt < CACHE_TTL.prices) return true;
            if (!APP_ID) return false;
            const peek = cachePeek(_pricesCacheKey());
            return !!(peek && peek.fresh);
        }
        function _historyIsFresh() {
            if (!SGIS.historyPrices) return false;
            if (SGIS.historyFetchedAt && Date.now() - SGIS.historyFetchedAt < CACHE_TTL.historyPrices) return true;
            if (!APP_ID) return false;
            const peek = cachePeek(_historyCacheKey());
            return !!(peek && peek.fresh);
        }
        function _hydratePricesCache() {
            if (!APP_ID) return;
            if (!SGIS.prices) {
                const peeked = cachePeek(_pricesCacheKey());
                if (peeked && peeked.data && peeked.data.prices) {
                    SGIS.prices = Object.assign({}, peeked.data, { ratesReady: SGIS.rateReady });
                    if (peeked.fresh) SGIS.pricesFetchedAt = Date.now();
                }
            }
            if (!SGIS.historyPrices) {
                const peeked = cachePeek(_historyCacheKey());
                if (peeked && peeked.data) {
                    SGIS.historyPrices = peeked.data;
                    if (peeked.fresh) SGIS.historyFetchedAt = Date.now();
                }
            }
            if (!SGIS.itadOverview) {
                const peeked = cachePeek(_itadCacheKey());
                if (peeked && peeked.data) SGIS.itadOverview = peeked.data;
            }
        }
        function _clearPricesCache() {
            SGIS.prices = null;
            SGIS.historyPrices = null;
            SGIS.itadOverview = null;
            SGIS.giftRec = null;
            SGIS.prediction = null;
            SGIS.predictionError = null;
            SGIS.pricesFetchedAt = 0;
            SGIS.historyFetchedAt = 0;
            if (!APP_ID) return;
            cacheDelete(_pricesCacheKey());
            cacheDelete(_historyCacheKey());
            cacheDelete(_itadCacheKey());
        }
        function _rememberPrices(priceData, opts) {
            const stored = {
                prices: (priceData && priceData.prices) || [],
                failed: (priceData && priceData.failed) || [],
            };
            SGIS.prices = Object.assign({}, stored, { ratesReady: SGIS.rateReady });
            if (stored.prices.length) {
                SGIS.pricesFetchedAt = Date.now();
                if (APP_ID) cacheSet(_pricesCacheKey(), stored, CACHE_TTL.prices);
            } else {
                SGIS.pricesFetchedAt = 0;
            }
            if (!(opts && opts.itad)) {
                SGIS.itadOverview = null;
                if (APP_ID) cacheDelete(_itadCacheKey());
            }
        }
        function _paintPricesFromState() {
            const body = document.getElementById('sgis-body');
            const keepScroll = (SGIS.tab === 'prices' && body) ? body.scrollTop : 0;
            renderPricesContent();
            if (SGIS.itadOverview) appendItadOverviewToBody();
            if (SGIS.historyPrices) appendHistoryPricesToBody(SGIS.historyPrices);
            appendGiftRecommendationToBody();
            if (SGIS.tab === 'prices' && body) body.scrollTop = keepScroll;
        }
        function _applyPricesResult(priceData, gen, opts) {
            if (gen !== _pricesGen) return;
            _rememberPrices(priceData, opts);
            SGIS.giftRec = calculateGiftRecommendation(SGIS.prices);
            _paintPricesFromState();
            _ensureHistory(gen);
        }
        function _ensureHistory(gen) {
            if (_historyIsFresh() || SGIS.historyPricesLoading) return;
            _loadHistoryPricesAppend(gen);
        }
        function _loadHistoryPricesAppend(gen) {
            const token = ++_historyGen;
            if (!SGIS.historyPrices) _mountHistoryPlaceholder();
            SGIS.historyPricesLoading = true;
            fetchHistoryPrices(APP_ID).then(historyData => {
                if (gen !== _pricesGen || token !== _historyGen) return;
                const prevLow = SGIS.historyPrices && SGIS.historyPrices.lowest;
                const nextLow = historyData && historyData.lowest;
                const lowChanged = JSON.stringify(prevLow || null) !== JSON.stringify(nextLow || null);
                SGIS.historyPrices = historyData;
                SGIS.historyFetchedAt = Date.now();
                // 史低变了要重画「当前价 vs 史低」，那一段在主表里，不在历史块里
                if (lowChanged) _paintPricesFromState();
                else appendHistoryPricesToBody(historyData);
            }).catch(() => {
                if (gen !== _pricesGen || token !== _historyGen) return;
                if (!SGIS.historyPrices) appendHistoryPricesToBody(null);
            }).finally(() => {
                if (token === _historyGen) SGIS.historyPricesLoading = false;
            });
        }
        function _startPricesFetch(opts) {
            const gen = ++_pricesGen;
            const silent = !!(opts && opts.silent);
            SGIS.pricesLoading = true;
            const useItadEnhanced = _itad && storage.getItadApiKey() && _itad.hasApiKey();
            if (!silent) {
                renderLoading(useItadEnhanced
                    ? (isZh ? '正在获取 ITAD 增强价格…' : 'Fetching ITAD enhanced prices…')
                    : (isZh ? '正在获取多地区价格…' : 'Fetching multi-region prices…'), 'prices');
            }
            refreshRates().catch(() => {});
            const fail = (err) => {
                if (gen !== _pricesGen) return;
                const message = (err && err.message) || '';
                console.warn('[SGIS] 价格获取失败:', message);
                if (!silent || !SGIS.prices) {
                    renderError(isZh ? '价格获取失败: ' + message : 'Price fetch failed: ' + message, 'prices');
                }
            };
            const done = () => { if (gen === _pricesGen) SGIS.pricesLoading = false; };
            if (useItadEnhanced) {
                (async () => {
                    try {
                        const itadId = await _itad.lookupItadId(APP_ID);
                        if (!itadId) throw new Error('ITAD lookup 失败');
                        const [overview, regionPrices] = await Promise.all([
                            _itad.fetchPriceOverview([itadId], { country: 'US' }),
                            _itad.fetchMultiRegionPrices(itadId, EXTENDED_REGIONS, { shops: [_itad.SHOP_STEAM], concurrency: 3 }),
                        ]);
                        if (gen !== _pricesGen) return;
                        const normalized = normalizeItadRegionPrices(regionPrices);
                        SGIS.itadOverview = overview;
                        if (APP_ID) cacheSet(_itadCacheKey(), overview, CACHE_TTL.prices);
                        _applyPricesResult(normalized, gen, { itad: true });
                    } catch (e) {
                        console.warn('[SGIS] ITAD 增强失败, 回退基础模式:', e.message);
                        try {
                            const priceData = await fetchMultiRegionPrices(APP_ID);
                            if (gen !== _pricesGen) return;
                            _applyPricesResult(priceData, gen);
                        } catch (err) {
                            fail(err);
                        }
                    } finally {
                        done();
                    }
                })();
                return;
            }
            fetchMultiRegionPrices(APP_ID)
                .then(priceData => { if (gen === _pricesGen) _applyPricesResult(priceData, gen); })
                .catch(fail)
                .finally(done);
        }
        function renderPrices(force) {
            force = force === true;
            if (force) _clearPricesCache();
            else if (!SGIS.prices) _hydratePricesCache();
            if (!force && SGIS.prices) {
                _paintPricesFromState();
                if (_pricesAreFresh() || SGIS.pricesLoading) {
                    _ensureHistory(_pricesGen);
                    return;
                }
                _startPricesFetch({ silent: true });
                return;
            }
            if (!force && SGIS.pricesLoading) return;
            _startPricesFetch({ silent: false });
        }
        function renderPricesContent() {
            // 不改 _paintTab。异步回来时用户可能已在别的标签，必须写明 prices。
            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>`, 'prices');
                return;
            }
            const fmt = (v) => num(v).toFixed(2);
 //比价目标货币——记忆最近一次用户选择（storage GM 持久化），
 // 存储值缺汇率时 getEffectivePriceTarget 回落 CNY（fallback 提示见下方页头）。
            const storedTarget = storage.getPriceTargetCurrency();
            const targetInfo = getEffectivePriceTarget(storedTarget);
            const targetCur = targetInfo.code;
            const curSym = priceTargetCurInfo(targetCur).symbol;
            const enriched = data.prices.map(p => {
                const safePrice = num(p.price);
                const conv = convertToCurrency(safePrice, p.currency, targetCur); // v2.11.47: 目标货币折算（目标为 CNY 时与旧 convertToCNY 管道等价；缺汇率返回 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),
                    conv: conv != null ? num(conv) : null,
                    regionName: info,
                });
            }).filter(p => p.conv != 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>`, 'prices');
                return;
            }
 //排序改按目标货币折算值（交叉汇率恒正,排序结果与 CNY 排序等价,语义直读）
            enriched.sort((a, b) => a.conv - b.conv);
            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">≈ ${curSym}${fmt(lowest.conv)}</span>
                        </div>
                    </div>
                </div>
            `;
 //完整对比表格（区域名称 | 原价 | 折后价 | 折扣率 | 换算后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">${curSym}${fmt(p.conv)}</div>
                </div>`;
            };
 //当前区域价格 vs 历史最低价对比
            const userPrice = enriched.find(p => p.region === userRegion);
            let historyCompareHtml = '';
            if (SGIS.historyPrices && SGIS.historyPrices.lowest && userPrice) {
                const histLow = SGIS.historyPrices.lowest;
                const histConv = convertToCurrency(num(histLow.price), histLow.currency, targetCur); // v2.11.47: 桥接层折算至目标货币
                if (histConv != null) {
                    const diff = userPrice.conv - num(histConv);
                    const diffPct = (diff / userPrice.conv) * 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">${curSym}${fmt(userPrice.conv)}</span></div>
                        <div class="sgis-row"><span class="sgis-row-key">历史最低</span><span class="sgis-row-val discount">${curSym}${fmt(histConv)}${histLow.cut ? ` (-${histLow.cut}%)` : ''}</span></div>
                        <div class="sgis-row"><span class="sgis-row-key">价差</span><span class="sgis-row-val ${isHigher ? '' : 'discount'}">${isHigher ? '↑' : '↓'} ${curSym}${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(' + ');
 // 本轮实际比价的区数 = 取到价的 + 失败的（每个请求的区只会落进其中一边）。
 // ITAD 增强模式是 16 区、基础模式是 9 区，写死 PRIORITY_REGIONS.length 会显示成「16 / 9 区」。
            const attemptedRegions = data.prices.length + (data.failed || []).length;
 // 已改美元结算的区（与美区同源，比不出差价，默认不比价）—— 文案由区域表的 usd 标记生成
            const usdRegionsNote = (() => {
                const names = REGIONS.filter(r => r.usd).map(r => r.name);
                return names.length ? `${names.join('、')}已按美元结算（与美区同源），默认不比价` : '';
            })();
 // 失败明细：点名是哪些区、什么原因（只给一个数字等于让用户自己猜）
            const failedList = data.failed || [];
            const failedDetailHtml = failedList.length
                ? `<div class="sgis-section">
                    <div class="sgis-section-title">${SGIS_ICONS.info} 未取到报价的区</div>
                    <div style="font-size:10px;color:var(--sgis-text-2);line-height:1.6">${failedList.map(f => {
                        const ri = REGIONS.find(x => x.code === f.region);
                        return `${escHtml(ri ? ri.name : f.region)}：${escHtml(f.error || '未知原因')}`;
                    }).join('<br>')}</div>
                </div>`
                : '';
 //页头比价目标货币切换器——select 显示用户存储选择（缺汇率回落时不篡改选中项，
 // 仅以金色提示行告知当前按 CNY 折算），切换即写偏好并整段重渲染（数据已缓存,零网络）。
            const curOptions = PRICE_TARGET_CURRENCIES.map(c =>
                `<option value="${c.code}"${c.code === storedTarget ? ' selected' : ''}>${c.symbol} ${c.code} ${c.name}</option>`).join('');
            const curFallbackHint = targetInfo.fallback
                ? `<div class="sgis-price-cur-fallback">⚠ ${targetInfo.wanted} 汇率未就绪，暂按 ¥ CNY 折算（刷新汇率后生效）</div>`
                : '';
            setBody(`
                <div class="sgis-section">
                    <div class="sgis-section-title">${SGIS_ICONS.price} 多地区低价排行
                        <span class="sgis-price-cur-switch">
                            <span class="sgis-price-cur-switch-label">比价</span>
                            <select id="sgis-price-target-cur" class="sgis-price-cur-select" title="切换比价目标货币（记忆最近一次选择）">${curOptions}</select>
                        </span>
                    </div>
                    ${curFallbackHint}
                    ${featuredHtml}
                </div>
                <div class="sgis-section">
                    <div class="sgis-section-title">${SGIS_ICONS.barChart} ${attemptedRegions}区完整价格对比</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">${targetCur}</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">${curSym}${fmt(lowest.conv)} (${lowest.regionName.name})</span></div>
                    <div class="sgis-row"><span class="sgis-row-key">最高价</span><span class="sgis-row-val">${curSym}${fmt(highest.conv)} (${highest.regionName.name})</span></div>
                    <div class="sgis-row"><span class="sgis-row-key">价差幅度</span><span class="sgis-row-val">${curSym}${fmt(highest.conv - lowest.conv)} (${((highest.conv - lowest.conv) / lowest.conv * 100).toFixed(1)}%)</span></div>
                    <div class="sgis-row"><span class="sgis-row-key">本地区</span><span class="sgis-row-val">${userRegion}${userPrice ? ` · ${curSym}${fmt(userPrice.conv)}` : ''}</span></div>
                    <div class="sgis-row"><span class="sgis-row-key">有效价格</span><span class="sgis-row-val">${enriched.length} / ${attemptedRegions} 区</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>
                ${failedDetailHtml}
                ${usdRegionsNote ? `<div class="sgis-price-cur-fallback">${usdRegionsNote}</div>` : ''}
                <div style="font-size:10px;color:var(--sgis-text-2);text-align:center;margin-top:8px">
                    旗帜来自 flagcdn.com · 价格仅供参考 · 3并发+1s限速
                </div>
            `, 'prices');
 //切换目标货币——写偏好(记忆) + 整段重画价格 pane（数据已在内存，不再往 body 上追加）
            const curSelect = (_pricesPane() || document).querySelector('#sgis-price-target-cur');
            if (curSelect) {
                curSelect.addEventListener('change', () => {
                    storage.setPriceTargetCurrency(curSelect.value);
                    _paintPricesFromState();
                });
            }
        }

 // ---- 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;
        }

 // ---- 统一徽章检测段渲染器 ----
 // 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('');
                },
            },
        };

        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('');
        }

 // ---- 中文语音支持醒目标记 (参考 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>`;
        }

 // ---- 资料受限状态检测 (参考 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>`;
        }

 // ---- 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))) {
 //增强数据捕获 — 硬件需求 + 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;
        }

 // ---- 游戏别名 (Steam EN + 小黑盒中文别名) ----
 // 异步按需获取,不阻塞首屏。成功缓存 30 天,miss 缓存 6h 限流友好。
 // 数据源 1: Steam store API ?l=english → 英文原名 (参考 Steam_Show_English_Name.js 思路)
 // 数据源 2: 小黑盒 get_game_detail → result.name 是小黑盒认为的中文名 (常与 Steam 中文名不同,作为别名)
 // 例: Steam "毛线先生 (CHUCHEL)" / 小黑盒 "脸黑先生"
 // API: https://api.xiaoheihe.cn/game/web/get_game_detail/?_time=xxx&appid=xxx
 // 已知限制: 部分游戏不带 hkey 可能无价格,基础信息仍返回;无需 hkey 即可获得 name/developers/score 等
        const XIAOHEIHE_GAME_API = 'https://api.xiaoheihe.cn/game/web/get_game_detail/';
        const _gameAliasInflight = new Map();   // appId → Promise<result>  (请求去重)

        // --- sgis-alias-pure:start ---
        // 脏词黑名单（对齐 GameVault PLAN-settings-alias.md §3.7：别名来源无人工复核，需客户端过滤）
        const SGIS_ALIAS_BLOCK = ['你妈', '妈的', '傻逼', '草泥马'];
        // 过滤管线（纯函数）：非 CJK / 长度>30 / 脏词 一律丢弃，返回 '' 表示不可用
        function sgisFilterAlias(s) {
            if (!s || typeof s !== 'string') return '';
            const t = s.trim();
            if (!t || t.length > 30) return '';
            if (!/[\u3400-\u4dbf\u4e00-\u9fff]/.test(t)) return '';
            for (const w of SGIS_ALIAS_BLOCK) {
                if (t.indexOf(w) >= 0) return '';
            }
            return t;
        }
        // 显示名决策（纯函数，对齐 GameVault 方案 A + §3.1 互斥判据）：
        // - zh: 过滤后的小黑盒中文名（'' = 不可用，主名保持原名）
        // - replaced: 主名是否替换为 zh（zh 有效且 ≠ 原名；原名空 = App 占位符场景，有中文名即替换）
        // - showEnPill: EN 药丸是否值得显示（en 不含于原名也不含于中文显示名 —— 已可见则不重复）
        function sgisResolveDisplayName(currentName, info) {
            const cur = String(currentName || '').trim();
            const zh = sgisFilterAlias(info && info.xhhName);
            const en = String((info && info.enName) || '').trim();
            const replaced = !!(zh && zh !== cur);
            const contains = (hay, sub) => !!hay && !!sub && hay.toLowerCase().indexOf(sub.toLowerCase()) >= 0;
            const showEnPill = !!(en && !contains(cur, en) && !contains(zh, en));
            return { zh, en, replaced, showEnPill };
        }
        // --- sgis-alias-pure:end ---

        function fetchGameAlias(appId) {
            if (!appId) return Promise.resolve(null);
            const key = String(appId);
 // 1. 内存缓存命中
            if (SGIS.gameAlias && SGIS.gameAlias._appId === key) {
                return Promise.resolve(SGIS.gameAlias);
            }
 // 2. 请求去重 (并发渲染只发一次)
            if (_gameAliasInflight.has(key)) return _gameAliasInflight.get(key);
 // 3. 持久化缓存命中
            const cached = cacheGet('gameAlias_' + key);
            if (cached) {
                SGIS.gameAlias = cached;
                return Promise.resolve(cached);
            }
 // 4. 拉取 Steam EN + 小黑盒 (并行,任一失败不影响另一个)
 // Steam EN 复用主闭包 fetchGameEnName(filters=basic 响应约 3KB + 会话级缓存,与橱窗别名路径共享)
            const p = Promise.all([
                fetchGameEnName(appId).catch(() => null),
                fetchXiaoheiheGameName(appId).catch(() => null),
            ]).then(([enRes, xhhRes]) => {
                const result = {
                    _appId: key,
                    enName: enRes,                                  // 英文名 (Steam ?l=english)
                    xhhName: xhhRes && xhhRes.name || '',           // 小黑盒中文名
                    xhhScore: xhhRes && xhhRes.score || '',         // 小黑盒评分
                    xhhGenres: xhhRes && xhhRes.genres || [],       // 小黑盒分类 (辅助参考)
                    _fetchedAt: Date.now(),
                };
                const hasAny = !!(result.enName || result.xhhName);
                SGIS.gameAlias = hasAny ? result : { _appId: key, notFound: true, _fetchedAt: Date.now() };
 // 成功存长缓存(30 天),miss 存短缓存(6h,限流保护,允许恢复)
                cacheSet('gameAlias_' + key, SGIS.gameAlias, hasAny ? CACHE_TTL.gameAlias : CACHE_TTL.gameAliasMiss);
                _gameAliasInflight.delete(key);
                return SGIS.gameAlias;
            }).catch((e) => {
                console.warn('[SGIS] 游戏别名获取失败:', appId, e && e.message);
                _gameAliasInflight.delete(key);
                SGIS.gameAlias = { _appId: key, notFound: true, _fetchedAt: Date.now() };
                cacheSet('gameAlias_' + key, SGIS.gameAlias, CACHE_TTL.gameAliasMiss);
                return SGIS.gameAlias;
            });
            _gameAliasInflight.set(key, p);
            return p;
        }

 // 小黑盒 API 中文别名 (返回 {name, score, genres, ...})
        async function fetchXiaoheiheGameName(appId) {
            const url = `${XIAOHEIHE_GAME_API}?_time=${Math.floor(Date.now() / 1000)}&appid=${encodeURIComponent(appId)}`;
            try {
                const text = await sglvGmFetchTextRetry(url, {
                    timeout: 12000,
                    headers: { 'Accept': 'application/json', 'Accept-Language': 'zh-CN,zh;q=0.9' },
                });
                if (!text || /<html/i.test(text) || text[0] !== '{') return null;
                const json = JSON.parse(text);
                if (!json || json.status !== 'ok' || !json.result) return null;
                const r = json.result;
                return {
                    name: String(r.name || '').trim(),
                    score: String(r.score || '').trim(),
                    genres: Array.isArray(r.genres) ? r.genres.slice(0, 5) : [],
                };
            } catch { return null; }
        }

 // 段:游戏别名 (英文名 + 小黑盒中文别名),初次渲染为空,异步填充
        function _renderOverviewAliasRow() {
            return `<div class="sgis-alias-row" data-sgis-alias-appid="${APP_ID}" aria-live="polite"></div>`;
        }

 // 异步别名 DOM 填充:主名替换 + EN 药丸 + 小黑盒评分/分类 (避免整体重渲染导致滚动丢失)
        function _applyAliasToDom(appId) {
            const info = SGIS.gameAlias;
 // 0. 键校验:防止 SPA 切页竞态下把上一款游戏的别名灌进当前面板
            if (!info || info._appId !== String(appId)) return;
            const curName = String((SGIS.overview && SGIS.overview.name) || '').trim();
            const alias = sgisResolveDisplayName(curName, info);
 // 1. 主名替换 (方案 A:中文名顶替主名,原名进 tooltip;SGIS.overview.name 数据层不动)
            const heroNameEl = document.querySelector('#sgis-body .sgis-hero-name');
            if (heroNameEl && alias.replaced) {
                heroNameEl.textContent = alias.zh;
                heroNameEl.title = `${alias.zh} (${curName})`;
            }
 // 2. EN 药丸 (hero 块下) —— 只在原名和中文显示名都看不到英文名时才显示,避免三处重复
            const slot = document.querySelector(`#sgis-body [data-sgis-alias-appid="${appId}"]`);
            if (slot) {
                slot.innerHTML = (!info.notFound && alias.en && alias.showEnPill)
                    ? `<span class="sgis-alias-pill sgis-alias-en" title="Steam EN · 别名" style="color:#93c5fd">
                            <span class="sgis-alias-source">Steam EN</span>
                            <span class="sgis-alias-value">${escHtml(alias.en)}</span>
                        </span>`
                    : '';
            }
 // 3. 小黑盒额外信息 (评分 + 分类) —— "基本信息" section,显示来源
            const xhhSlot = document.querySelector(`#sgis-body [data-sgis-xhh-info-appid="${appId}"]`);
            if (xhhSlot) {
                if (!info || info.notFound || (!info.xhhScore && (!info.xhhGenres || !info.xhhGenres.length))) {
                    xhhSlot.innerHTML = '';
                } else {
                    const rows = [];
                    if (info.xhhScore) {
 // 标题前显式标 "小黑盒",确保来源一目了然 (避免与 Steam 评测混淆)
                        rows.push(`<div class="sgis-row"><span class="sgis-row-key">小黑盒评分</span><span class="sgis-row-val" style="color:#fbbf24;font-weight:600">${escHtml(info.xhhScore)}</span></div>`);
                    }
                    if (info.xhhGenres && info.xhhGenres.length) {
                        rows.push(`<div class="sgis-row"><span class="sgis-row-key">小黑盒分类</span><span class="sgis-row-val">${info.xhhGenres.map(escHtml).join(' / ')}</span></div>`);
                    }
                    xhhSlot.innerHTML = rows.join('');
                }
            }
        }

        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'; }

 //简化破解信息展示 —— 状态徽章 + 破解日期 + 破解组 (带字段标签)
 // - 保留: 状态 (破解时间相对描述) + 破解日期 (具体日期) + 破解组 (带 "破解组" 字段标签,避免裸 DINOByTES 看不懂)
 // - 移除: AAA (游戏分级标记,非破解时间) + protections (DRM 列表,已有独立徽章) + 评分 chips (游戏评分,非破解时间)
            const crackDateStr = info.crackDate
                ? new Date(info.crackDate).toLocaleDateString('zh-CN')
                : '';
 // 破解组 —— 必须带字段标签,避免用户看到裸 "DINOByTES" 看不懂
            const groups = String(info.hackedGroups || '').split(/[,;/|]+/).map(s => s.trim()).filter(Boolean);
            const groupChips = groups.map(g =>
                `<span class="sgis-crack-group"><span class="sgis-crack-group-key">破解组</span><span class="sgis-crack-group-val">${escHtml(g)}</span></span>`
            ).join('');

            const chips = [
                `<span class="sgis-crack-badge ${cls}">${SGIS_ICONS.shield} ${label}</span>`,
                crackDateStr ? `<span class="sgis-crack-date">破解于 ${crackDateStr}</span>` : '',
                groupChips,
            ].filter(Boolean).join('');
            if (!chips && !info.hardware) return '';

 //硬件需求区块
            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;
 //委托 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) {
 //若该游戏已通过家庭组共享给当前用户(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 '';
        }

 // ---- 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 等
 //委托 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;
            }
        }
 //商店页 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 []; }
        }
 //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) + '亿';
        }
 //应用类型本地化映射
        function localizeAppType(t) {
            const map = {
                game: '游戏', dlc: 'DLC', music: '音乐', series: '系列',
                mod: '模组', demo: '试玩版', advertising: '宣传',
                series_episode: '系列剧集', tool: '工具', video: '视频',
                hardware: '硬件', episode: '剧集',
            };
            return map[t] || t || '';
        }
 //年龄限制等级文案
        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 };
        }
 //异步获取 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 历史价格 (改用 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 peeked = cachePeek(cacheKey);
            // 未过期直接用。过期的先留着，请求成功后再覆盖，失败时下次还能先画出来。
            if (peeked && peeked.fresh) return peeked.data;

 // 使用 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 获取历史价格
        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 个时隐藏
 //手写 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%)。
 // 几何坐标由 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>`;
        }

 //SVG 价格历史走势图 (零依赖, 支持时间范围筛选, 参考 Steam_Buff charts.js)
 //绘制段迁移 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 || '';

 //手写 SVG 绘制段(~70 行)迁移 SGLVCharts.lineChart(area+dots+rangeButtons 形态)。
 // y 域(±15% padding/下限钳 0)与区间过滤(<2 点回退全量)保留函数内; 区间按钮组由库产出
 // (sgis-chart-range-btn, data-range), 点击重绘仍走 bindPriceChartRangeEvents; 最低价大圆点+价格标注
 // 经 dots.itemStyle + annotations 注入; 逐点 tooltip(日期 · 价格 (-cut%) @ 商店)不变。
 // 几何坐标由 sglv-charts.test.js C9 断言固化(含 6m/1y/all 三态)。
            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="价格历史走势图"',
            });
        }

 //绑定价格图表时间范围按钮事件
        function bindPriceChartRangeEvents(historyData) {
            const root = _pricesPane() || document;
            const wrap = root.querySelector('#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;

 // 史低价格卡片
 //安全数值转换, 修复 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`;
 //v2.34.1 借 SGLVCore v1.0.6 onHttpError 读 400 响应体：Steam 对无成就体系的游戏返回
 // HTTP 400 + {"playerstats":{"success":false}}，翻译成语义哨兵 NO_ACHIEVEMENTS，
 // 渲染层据此显示「该游戏暂无成就」而非裸「HTTP 400」（用户误以为程序故障）。
 // 无成就是游戏固有属性 → 30min 负缓存，避免每次切 Tab 反复打 400。
            let data;
            try {
                data = await fetchJson(url, {
                    timeout: 15000,
                    onHttpError(status, body) {
                        if (status === 400 && /"success"\s*:\s*false/.test(String(body || ''))) return 'NO_ACHIEVEMENTS';
                        return '';
                    },
                });
            } catch (e) {
                if (e && e.message === 'NO_ACHIEVEMENTS') {
                    const result = { error: 'NO_ACHIEVEMENTS', achievements: [], total: 0, unlocked: 0 };
                    cacheSet(cacheKey, result, 30 * 60 * 1000);
                    return result;
                }
                throw e;
            }
            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; });
        }
 // ---- : renderAchievementsContent 段化 ----
 // 数据准备 + 4 段渲染器,主函数降级为组装器
        function _prepareAchievementsData() {
            const player = SGIS.achievements;
            const global = SGIS.globalAchievements || [];
            if (player?.error === 'NO_KEY') return { state: 'no_key' };
 //v2.34.1 无成就哨兵（HTTP 400 + success:false）→ 与空数据同一友好态，不算故障
            if (player?.error === 'NO_ACHIEVEMENTS') return { state: 'empty' };
            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>
                <button class="sgis-btn" id="sgis-ach-apikey-btn" type="button"
                    style="margin-top:14px;padding:6px 22px;border-radius:8px;font-size:12px;cursor:pointer;">${isZh ? '了解用途与风险并配置' : 'Why & risks, then configure'}</button>
            </div>`;
        }

        function _renderAchievementsError(d) {
 //v2.34.1 错误分类话术——裸「HTTP 403/503」会让用户以为程序故障；
 // 按状态码给出可行动的提示（隐私设置 / API Key / Steam 服务 / 网络）+ 重试按钮
            const msg = String(d.error || '');
            let reason;
            if (/HTTP 403/.test(msg)) {
                reason = '成就详情无法访问（HTTP 403）。常见原因：<br>① Steam 隐私设置中「游戏详情」未公开；<br>② API Key 无效或无该资料权限';
            } else if (/HTTP 401/.test(msg)) {
                reason = 'API Key 无效或已过期（HTTP 401），请在设置中更新后重试';
            } else if (/HTTP 5\d\d/.test(msg)) {
                reason = `Steam 服务暂时不可用（${(msg.match(/HTTP 5\d\d/) || ['服务端错误'])[0]}），请稍后重试`;
            } else if (/^HTTP \d+/.test(msg)) {
                reason = `Steam 接口返回错误（${(msg.match(/^HTTP \d+/) || [''])[0]}），请稍后重试`;
            } else {
                reason = '网络异常，请检查网络连接后重试';
            }
            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:8px;padding:0 16px;line-height:1.6">${reason}</div>
                <button class="sgis-btn" id="sgis-ach-retry-btn" type="button"
                    style="margin-top:14px;padding:6px 22px;border-radius:8px;font-size:12px;cursor:pointer;">重试</button>
            </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() {
            _paintTab = 'achievements';
            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);
            if (d.state === 'no_key') {
 //v2.45.0：需要 Key 的功能才触发同意门 —— 先讲用途与风险，同意后送去设置页填 Key
                const pane = _ensureSgisPane('achievements');
                const keyBtn = pane.querySelector('#sgis-ach-apikey-btn');
                if (keyBtn) {
                    keyBtn.addEventListener('click', async () => {
                        keyBtn.disabled = true;
                        const allowed = await _requireApiKeyConsent({ thenFetch: false });
                        keyBtn.disabled = false;
                        if (!allowed) return;
                        //已放行（已同意 / 存量用户）→ 送去设置页
                        _openApiKeySettings();
                    });
                }
            }
            if (d.state === 'error') {
 //v2.34.1 重试：错误结果不落缓存，清内存态后走正常加载（loading 中重复点击被 achievementsLoading 挡掉）
                const pane = _ensureSgisPane('achievements');
                const retryBtn = pane.querySelector('#sgis-ach-retry-btn');
                if (retryBtn) retryBtn.addEventListener('click', () => {
                    SGIS.achievements = null;
                    SGIS.globalAchievements = null;
                    renderAchievements();
                });
            }
        }

 // ---- 动态标签 (游戏新闻/更新) ----
 //新闻正文清洗——原 /\\[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;
 //官方公告源优先，为空时回退全源——部分游戏仅经 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; });
        }
 // ---- : 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) {
 //截断部分恢复提示横幅
            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() {
            _paintTab = 'dynamics';
            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();
        }

 // ==================== 用户档案浮窗 ====================

 // ---- 获取用户摘要 (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; }
        }

 //获取最近游玩（参考 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; }
        }

 //轻量愿望单计数（参考 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;
        }

 // ==================== 社交标签页 - 好友列表完整数据 ====================
 // 参考 steam-friend-manager 的批量获取+缓存策略
 // 流程: GetFriendList → GetPlayerSummaries(批量100) → GetPlayerBans(批量100)
 // 缓存: 完整数据 6h, VAC 独立 24h, 等级独立 7天
        const SUMMARY_BATCH = 100;  // GetPlayerSummaries 单次上限
        const VAC_BATCH = 100;      // GetPlayerBans 单次上限

 // ==================== SVG 国旗 (移植自 steam-friend-manager) ====================
 // 内联 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] || '离线';
        }

 //统一鉴权参数——优先 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 = {}) {
 //鉴权优化——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 || '',
 //修复: 预填国家名+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 的并发池思想：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];
                }
            }
        }

 //手动同步全部好友 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;
        }

 //好友游戏数量懒加载（参考 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 官方新闻 (促销/更新/活动) ----

 //重写官方动态数据获取——接入 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);
 //兼容旧版缓存（旧版返回数组，新版返回对象）
            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 || '',
 //捕获 discount_expiration 时间戳（部分 spotlight 有此字段）
                                discountExpiration: Number(sp.discount_expiration) || 0,
                            });
                        }
                    }
                }
            } catch (e) {
                console.warn('[SGIS] featuredcategories 获取失败:', e);
            }

 // ---- 2. Steam 官方新闻公告 ----
 //原 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;
        }

 // ---- 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} 款游戏`);
 //注入到 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;
            }
        }

 //桥接卡牌数据库函数到 SGLV_API，供外层 renderGamesList 使用
        SGLV_API.getCardDbMaxLevel = getCardDbMaxLevel;
        SGLV_API.getCardDbGameName = getCardDbGameName;
        SGLV_API.loadCardDatabase = loadCardDatabase;
 //桥接 SGIS 玩家档案数据到 SGLV_API，供个人展柜标签页复用
        SGLV_API.getSGISProfile = () => SGIS.profile || null;
        SGLV_API.fetchSGISProfile = () => { renderProfile({ force: false }); };
 //桥接 SGIS 徽章数据和活动 appid 映射, 供展柜徽章展示复用
        SGLV_API.getSGISUserBadges = () => SGIS.userBadges || null;
        SGLV_API.getSteamEventAppIdMap = () => typeof STEAM_EVENT_APPID_MAP !== 'undefined' ? STEAM_EVENT_APPID_MAP : null;
 //桥接 REGIONS 国家码→币种查询，供主作用域 wlCurrencyOf 兜底链使用（REGIONS 在子闭包内，外层不可见）
        SGLV_API.getRegionCurrency = (cc) => {
            const r = REGIONS.find(x => x.code === String(cc || '').toUpperCase());
            return r ? r.currency : '';
        };
 //桥接汇率桥接层供主作用域使用 —— computeWishlistStats 经 aggregate 折算(getUsdRates),
 // computeWishlistStatsCached 货币指纹小时级快照(getRatesTs);拿不到时调用方降级(传 0/null)
        SGLV_API.getUsdRates = () => getUsdRates();
        SGLV_API.getRatesTs = () => getRatesTs();

 // ---- 获取用户勋章/徽章 ----
 //增加浏览器持久缓存与数据合理性校验, 避免 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 */ }
        }

 //校验 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;
 //获取 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() };
 //数据合理性校验, 如果新数据比缓存差则保留旧缓存
                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 ----
 // GetBadges API 不返回 badge 名称, 用 state.ownedGames 反查
 //增加用 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) {
 //优先用本地游戏库名称, 回退到卡牌数据库API名称
                    b._gameName = ownedMap[String(b.appid)] || getCardDbGameName(b.appid) || '';
                    b._hasGameName = !!b._gameName;
 //补充最大等级信息
                    b._maxLevel = getCardDbMaxLevel(b.appid);
                }
 // 节日徽章 / 社区徽章: 用 communityitemid / type / completion_time 推断
                if (b.communityitemid) {
                    b._isCommunityBadge = true;
                }
            });
            return badgeData;
        }

 // ---- 节日 / 活动徽章名称映射 ----
 // Steam 节日活动 appid 常见列表 (从社区维护)
 //增加 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 周年纪念',
        };
 //活动徽章图标 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/';
 //构建活动徽章图标 URL (icon_64x64.png)
        function getActivityIconUrl(appid) {
            if (!appid) return '';
            return ACTIVITY_ICON_CDN + appid + '/icon_64x64.png';
        }

 //推断 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 };
 //辅助检测 - appid > 3000000 且没有对应游戏名(不在游戏库中)
 // Steam 节日活动 appid 通常很大(300万+), 且用户不会"拥有"这些"游戏"
            if (b.appid > 3000000 && !b._hasGameName) {
                return { name: 'Steam 活动 #' + b.appid, appid: b.appid };
            }
            return null;
        }

 // ==================== 概览标签 (用户 Hero) ====================
 //读取持久化 profile 缓存, 并检查游戏库数量变化标记
        function shouldInvalidateProfileCache(steamId) {
            try {
                const cached = readPersistentProfileCache(steamId);
                if (!cached) return true;
 //使用排除家庭组共享和 DLC 后的游戏数量，确保统计一致性
                const currentGameCount = getStatFilteredGames().length;
 // 如果游戏库数量变化, 视为缓存失效 (游戏数量可能影响统计展示)
                if ((cached.gameCount || 0) !== currentGameCount) return true;
                return false;
            } catch { return true; }
        }

        function renderProfile(opts = {}) {
            _paintTab = 'profile';
            const { force = false } = opts;
            const steamId = getActiveSteamId();
 //异步触发 DLC 数据库加载（首次打开侧栏时），加载完成后刷新统计
 //同时触发全库存应用类型获取，补充 Barter.vg 未覆盖的 DLC
            if (SGLV_API.loadDlcDatabase) {
                SGLV_API.loadDlcDatabase().then(() => {
                    if (SGIS.profile && !SGIS.profileLoading) renderProfileContent();
 //DLC 数据库加载后，启动全库存 type 获取，完成后再次刷新 DLC 数量
                    if (SGLV_API.enrichOwnedAppTypes) {
                        SGLV_API.enrichOwnedAppTypes().then(() => {
                            if (SGIS.profile && !SGIS.profileLoading) renderProfileContent();
                        }).catch(() => {});
                    }
                }).catch(() => {});
            }
 //非强制刷新时, 先尝试使用内存与持久缓存
            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;
            }
 //检查是否需要强制失效缓存
            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]) => {
 //使用排除家庭组共享和 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;
        }

 //段渲染器 — 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>

            `;
        }

 //段渲染器 — 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>

            `;
        }

 //段渲染器 — 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>

            `;
        }

 //段渲染器 — 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>
`;
        }

 //准备 Profile 渲染所需数据 (从 SGIS.profile 派生所有 KPI 字段)
        function _prepareProfileData(p, s) {
 // 游戏库统计 (排除家庭组共享游戏和 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);
 //统一经 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() {
            _paintTab = 'profile';
            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));

 //异步加载最近游玩游戏中文名；经 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();
                        }
                    }
                });
            }

 // ==================== KPI 卡片 + 进度环点击交互 ====================
 // 游戏数量 → 弹出中央游戏库浮窗（先收起侧边栏避免遮挡）
            const statGames = document.getElementById('sgis-stat-games');
            if (statGames) {
                statGames.addEventListener('click', () => {
                    closePanel();
                    document.dispatchEvent(new CustomEvent('sglv:open-library'));
                });
            }
 //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(`${data.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');
                });
            }
 //旧缓存档案无愿望单计数时，后台补取并局部更新卡片
            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; }
 //已发起加载但用户切走又切回（如先看 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;
 //进度条 + 游戏骨架屏（参考 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>`;
                }
 //统一经 getGameIconUrl（community_assets 新路径 + icon 成功缓存）
                const iconUrl = getGameIconUrl(it.appid, it.icon);
 //许可页校准的条目仅日级精度（本地零点），不显示伪造的 HH:MM 时刻
                const timeText = it.ts && !it.licenseCorrected
                    ? new Date(it.ts).toLocaleTimeString('zh-CN', { hour: '2-digit', minute: '2-digit' })
                    : '';
 //家庭组入库条目显示购买者（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;
        }

 // ---- 回归补拆: 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()}日`;
        }

 //处理 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;
        }

 //结构化官方动态——促销活动/每日优惠/当前特惠/官方新闻
        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;
 //切换子标签时重置入库分页
                        SGIS.familyTimelinePage = 1;
                        SGIS.personalTimelinePage = 1;
                        renderActivity();
                    });
                });
            }

 //入库动态分页——哨兵进入视口自动加载下一页（每页 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() {
            _paintTab = 'activity';
            const sub = SGIS.activitySubTab || 'personal';
 //默认个人入库动态，官方动态移至最后
            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);
 //共拥游戏被个人许可页校准时在 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);
 //家庭组入库页含个人已拥有的共拥游戏为既定正确行为，修正过时的"排除个人已拥有"虚假声明
 //注明购买者归属语义（对齐 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>
            `);

 //异步加载入库动态游戏中文名；经 applyGameAliases（scope 限定 SGIS 作用域）
            applyGameAliases(document, { scope: '#sgis-body' });

            _bindActivityEvents(sub);
        }

 // ==================== 勋章标签 (Steam 官方勋章) ====================
        function renderUserBadges() {
            _paintTab = 'userBadges';
            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();
 //异步加载卡牌数据库, 加载完成后重新 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);
            });
        }

 // 价值分析仪表板 + 智能分析浮窗 + 徽章图标加载

 // : 社区页勋章段渲染器提为顶层 (共享区)
 // 工具函数:时间戳格式化
        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} 张` : '加载中';
            const appIdNum = Number(vd.appId) || 0;
            const capsule = `https://shared.fastly.steamstatic.com/store_item_assets/steam/apps/${appIdNum}/capsule_184x69.jpg`;
            let imgSrc = capsule;
            if (market && market.cards && market.cards.length > 0) {
                const cardWithIcon = market.cards.find(c => c.iconUrl);
                if (cardWithIcon && /^https:\/\/[^\s"'<>\\]+$/i.test(String(cardWithIcon.iconUrl))) imgSrc = String(cardWithIcon.iconUrl);
            }
            const esc = (s) => String(s == null ? '' : s).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]));
            const safeName = esc(vd.gameName || '');
            if (!window.__sglvValueCardImgBound) {
                window.__sglvValueCardImgBound = true;
                document.addEventListener('error', (ev) => {
                    const img = ev.target;
                    if (!img || !img.getAttribute || img.getAttribute('data-sglv-vcard') !== '1' || img.dataset.fbDone) return;
                    img.dataset.fbDone = '1';
                    const fb = img.getAttribute('data-fallback');
                    if (fb && img.getAttribute('src') !== fb) {
                        img.src = fb;
                        img.style.opacity = '0.2';
                    }
                }, true);
            }
            return `<div class="sgis-value-card" data-appid="${appIdNum}">
                    <div class="sgis-value-card-img" ${safeName ? `title="${safeName}"` : ''}>
                        <img src="${esc(imgSrc)}" alt="" loading="lazy" data-sglv-vcard="1" data-fallback="${esc(capsule)}">
                    </div>
                    <div class="sgis-value-card-info">
                        <div class="sgis-value-card-name">${safeName || ('游戏 #' + appIdNum)}</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() {
            _paintTab = 'userBadges';
            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);
                        }
                    });
                });
            }
        }

 //价值 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>
            `;
        }

 //节日活动 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>
            `;
        }

 //游戏勋章 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>
            `;
        }

 //社区勋章 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 成就图标库 - 每个成就独立的渐变配色
        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>`,
        };

 // 自制成就定义 (炫彩 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() {
 //排除家庭组共享游戏和 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 };
            });
        }

 // ==================== 社交标签页渲染 (参考 friend-manager) ====================
        function renderSocial() {
            _paintTab = 'social';
            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>`, 'social');
                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();
            });
        }

 //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 _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(), 'social');
                const retry = (_tabPanes.get('social') || document).querySelector('#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>
                <div class="sgis-section">
                    <div class="sgis-section-title" id="sgis-social-list-count">${SGIS_ICONS.users} 好友列表 (${filtered.length}/${d.totalCount})</div>
                    ${_renderSocialToolbar(d)}
                    <div id="sgis-social-list">
                        ${_renderSocialList(d, filtered) || '<div style="font-size:11px;color:var(--sgis-text-2);text-align:center;padding:16px">无匹配好友</div>'}
                    </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>
            `, 'social');
            _bindSocialEvents(getActiveSteamId());
        }

        function _paintSocialList() {
            const list = document.getElementById('sgis-social-list');
            if (!list) { renderSocialContent(); return; }
            const d = _prepareSocialData();
            const filtered = _filterSortFriends(d);
            const count = document.getElementById('sgis-social-list-count');
            if (count) count.innerHTML = `${SGIS_ICONS.users} 好友列表 (${filtered.length}/${d.totalCount})`;
            list.innerHTML = _renderSocialList(d, filtered) || '<div style="font-size:11px;color:var(--sgis-text-2);text-align:center;padding:16px">无匹配好友</div>';
            document.querySelectorAll('#sgis-body .sgis-social-filter').forEach(btn => {
                btn.classList.toggle('active', btn.dataset.filter === SGIS.friendsFilter);
            });
        }

        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>` : '';

 //修复: 用内联 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 root = _tabPanes.get('social') || document;
 // 搜索
            const searchInput = root.querySelector('#sgis-social-search');
            if (searchInput) {
                let timer;
                searchInput.addEventListener('input', e => {
                    clearTimeout(timer);
                    timer = setTimeout(() => {
                        SGIS.friendsSearch = e.target.value;
                        _paintSocialList();
                    }, 250);
                });
            }
 // 筛选
            root.querySelectorAll('.sgis-social-filter').forEach(btn => {
                btn.addEventListener('click', () => {
                    SGIS.friendsFilter = btn.dataset.filter;
                    _paintSocialList();
                });
            });
 // 排序
            const sortSelect = root.querySelector('#sgis-social-sort');
            if (sortSelect) {
                sortSelect.addEventListener('change', e => {
                    SGIS.friendsSort = e.target.value;
                    _paintSocialList();
                });
            }
 // 同步全部等级
            const loadLevelsBtn = root.querySelector('#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;
 //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();
                    }
                });
            }
 //同步封禁状态按钮
            const banSyncBtn = root.querySelector('#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();
                    }
                });
            }
        }

        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);
        }

 // ==================== 洞察数据本地计算 (参考 AIPage analyzeLibrary) ====================
 //改为调用主闭包缓存版本(PCC 持久化)— 跨 session 复用,避免每次开洞察标签页都全量重算
 //修复 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;
        }

 // ---- 回归补拆: 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) ──
 //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) => {
 //六维度配色, 新增绿色渐变给"犀利毒舌"
                    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>
            `;
        }

 // ── 底部成就引导 (移除重复展示, 改为简洁跳转入口指向中央面板) ──
        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>
            `;
        }

 //游戏口味标签画像 — 从愿望单标签 + 游玩模式 + 画像特征推断
        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(); });

 //绑定成就引导按钮 — 关闭 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() {
            _paintTab = 'userAchievements';
            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>
            `);

 //异步加载市场洞察游戏中文名；经 applyGameAliases（scope 限定 SGIS 作用域）
            applyGameAliases(document, { scope: '#sgis-body' });

            _bindInsightEvents();
        }

 // ==================== 游戏市场洞察渲染 (基于 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>
            `;
        }

 // ==================== 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('、');

 //构建个人口味标签摘要 (与洞察页面"游戏口味"标签画像同步)
                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');

 //从远程模板加载提示词, 支持随时修改无需更新脚本
                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();
            }
        }

 // ==================== 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();
            }
        }

 //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(() => {});
                    }
 //异步拉取 appdetails 增强信息 (工坊/截图/分类/捆绑包等)
                    if (!SGIS.appDetailsExtra && !SGIS.appDetailsExtraLoading) {
                        SGIS.appDetailsExtraLoading = true;
                        fetchAppDetailsExtra().then(extra => {
 //appdetails 失败/未返回 dlc 时，从商店页 DOM 兜底提取 DLC 列表
                            extra = mergeDlcFromDom(extra);
                            SGIS.appDetailsExtra = extra;
                            SGIS.appDetailsExtraLoading = false;
                            if (SGIS.tab === 'overview') renderOverview();
 //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) {
 //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; });
                    }
 //异步获取 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; });
                    }
 //资料受限状态检测 (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: (force) => renderPrices(!!force) },
            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() },
        };

 //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', itadOverview: null, pricesFetchedAt: 0, historyFetchedAt: 0 } },
            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) {
            _paintTab = tab;
            try {
 //表驱动分发;overview 副作用 fetch 外提至 prepareTabData
                if (force) resetTabCache(tab, 'force');
                const spec = SGIS_TAB_RENDERERS[tab];
                if (!spec) {
                    console.warn('[SGIS] 未知标签页:', tab);
                    return;
                }
 // profile 透传 force；价格页用同一个参数决定要不要绕过缓存
                if (tab === 'profile') {
                    renderProfile({ force: !!force });
                } else {
                    spec.render(!!force);
                }
 // 数据准备步骤（fetch 外提），overview 等带 prepare 的 Tab 在渲染后追加准备逻辑
                if (spec.prepare) spec.prepare();
            } catch (e) {
                console.error('[SGIS] renderTab error:', e);
                renderError('渲染失败: ' + e.message);
            }
        }

 //监听 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', () => {
                _invalidateSgisPanes();
                if (SGIS.open) _activateSgisTab(SGIS.tab, { force: true });
            });
 //主题热切换——侧边栏打开时重渲染当前 Tab（SVG 图表/内联色随新主题色板再生）
            window.addEventListener('sglv-theme-changed', () => {
                _invalidateSgisPanes();
                if (SGIS.open) _activateSgisTab(SGIS.tab, { force: true });
            });
            watchActivityOverlay();
            console.log('%c[Steam 个人信息面板 v2.8.0] UI 初始化完成 · AppID:', `color:${SGLVCharts.accent()};font-weight:bold`, APP_ID || '(首页模式)');
        }
 // ==================== 评测标签页 ====================

 // 评测分数描述映射 (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' },
        };
 //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 || {};
 //修复 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(),
            };
 //单一缓存入口(之前双写 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 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) {
            _paintTab = 'reviews';
            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 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) {
 //预编译正则表达式 (参考 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;
 //关键词/正则搜索
                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;
            });
        }

 //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) {
 //抽取重渲染逻辑, 供筛选按钮和搜索共用
            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>' : ''}`;
                }
            };
 //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);
                });
            });

 //关键词搜索 (防抖 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);
                });
            }

 //正则模式切换
            const regexToggle = document.getElementById('sgis-review-regex-toggle');
            if (regexToggle) {
                regexToggle.addEventListener('click', () => {
                    onChange('regex', !SGIS.reviewsFilter.regexMode);
                });
            }

 //清空搜索按钮(只在该按钮存在时绑定)
            const clearBtn = document.getElementById('sgis-review-search-clear');
            if (clearBtn && searchInput) {
                clearBtn.addEventListener('click', () => onChange('clear', null));
            }
        }

 // 绑定评测文本展开/收起事件
        function bindReviewExpandEvents() {
 //展开/收起改由按钮触发(避免点击全行歧义),文本点击只切换(保留旧行为兼容)
            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');
            }
        }

 // ==================== 跨区送礼推荐 ====================

 // Steam 跨区送礼限制区域（不能向其他区域送礼的区域）
 // 参考 steam-gift-checker: 俄罗斯/CIS 区域有送礼限制
        const GIFT_RESTRICTED_REGIONS = new Set(['RU']); // 俄罗斯不能向其他区域送礼

 // Steam 跨区赠礼价格规则: 低价区(送礼区)价格 × 1.15 > 目标区(收礼区)价格 才可赠送
 // (等价于价差 (recipient-sender)/sender < 15%;超出该规则的区域直接不进入推荐)
        const GIFT_MARKUP_FACTOR = 1.15;

 // 计算跨区送礼推荐方案（仅收录可赠送区域,无可赠送方案返回 null,卡片整体不渲染）
        function calculateGiftRecommendation(pricesData) {
            if (!pricesData || !pricesData.prices || !pricesData.prices.length) return null;

            const userRegion = (document.cookie.match(/steamCountry=(\w{2})/) || [])[1] || 'CN';

 // 找到收礼区（用户当前区域）的价格
            const recipientData = pricesData.prices.find(p => p.region === userRegion);
            if (!recipientData) return null;

 // 计算 CNY 价格
 //桥接层统一折算（原三元式中 num(toCNY(null))→0 的路径现直接返回 null，下游 == null/<=0 判定等价）
            const recipientCny = convertToCNY(num(recipientData.price), recipientData.currency);
            if (recipientCny == null || recipientCny <= 0) return null;

 //仅收录可赠送区域——不满足 低价区×1.15>目标区 规则的直接跳过
 // (用户需求:不显示无法赠送的建议,只显示可以赠送的最优方式)
            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;
 // 赠礼规则: 送礼区(低价区) × 1.15 > 收礼区(目标区) 价格
                if (!(senderCny * GIFT_MARKUP_FACTOR > recipientCny)) continue;

                const savings = recipientCny - senderCny;
                const savingsPercent = (savings / senderCny) * 100;
                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),
                    senderPrice: num(p.price),
                    senderCurrency: p.currency,
                    senderDiscount: num(p.discount),
                });
            }

 // 无任何可赠送方案 → 返回 null,送礼卡片整体不渲染(不出现任何"无法赠送"提示)
            if (!candidates.length) return null;

 // 候选已全部通过赠礼规则,直接按节约金额降序取最优
            candidates.sort((a, b) => 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.best) return '';
            const fmt = (v) => num(v).toFixed(2);
            const best = giftData.best;
            const altText = giftData.alternatives.length
                ? `<div class="sgis-gift-alt">其他可赠送: ${giftData.alternatives.map(a =>
                    `${a.regionName} (省¥${fmt(a.savings)})`
                ).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"><span style="color:#4bb54f">✓ 可赠送（符合低价区×1.15＞收礼区规则）</span></div>
                <div class="sgis-gift-warn">⚠ 注意事项：Steam跨区送礼政策可能随时调整，请确认当前政策。部分区域有送礼限制（如俄罗斯不能向其他区域送礼）。</div>
                ${altText}
            </div>`;
        }

 // 将送礼推荐画进价格 pane（无可赠送方案时不留空卡片）
        function appendGiftRecommendationToBody() {
            if (!SGIS.prices) return;
            if (!_pricesPane()) return;
            if (!SGIS.giftRec) SGIS.giftRec = calculateGiftRecommendation(SGIS.prices);
            if (!SGIS.giftRec) {
                _fillPriceBlock('gift', '');
                return;
            }
            _fillPriceBlock('gift', renderGiftRecommendation(SGIS.giftRec));
        }

 // ==================== 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); }

 // ==================== SGIS 能力导出 (PTW 桥接前置) ====================
 // 供游戏数据浮窗(PTW)经 SGLV_API 消费。集中挂出，便于审查与回滚。
 //
 // 设计说明（勿改）：
 // ① 本闭包的取数函数自带闭包环境，内部引用主 IIFE 的 cacheGet/cacheSet/CACHE_TTL/
 // sglvGmFetchRetry/apiKey 等能力是安全的；挂出仅是「让函数对象可见」，不跨作用域求值。
 // ② 历史两次 ReferenceError 事故(getGameIconUrl :19440 / xpPercent)均发生在
 // 「主面板反向引用 SGIS」的场景；本方向(SGIS → 主 IIFE)是安全方向。
 // ③ 消费方必须用 `?.` + `typeof === 'function'` 双重防御（见 PTW_HOST 装配处）。
 // ④ 以下函数无内部限流保护(fetchReviews / fetchAppDetailsExtra 等)，
 // 批量调用方必须用 sglvSmartPool 约束并发 ≤3。
        if (typeof SGLV_API !== 'undefined') {
 // ---- 成就 ----
            SGLV_API.fetchPlayerAchievements = fetchPlayerAchievements;
            SGLV_API.fetchGlobalAchievements = fetchGlobalAchievements;
 // ---- 评测 ----
            SGLV_API.fetchReviews = fetchReviews;
            SGLV_API.fetchReviewSummary = fetchReviewSummary;
 // ---- 元数据 ----
            SGLV_API.fetchAppDetailsExtra = fetchAppDetailsExtra;
            SGLV_API.fetchDlcNames = fetchDlcNames;
            SGLV_API.fetchGameNews = fetchGameNews;
            SGLV_API.fetchFamilyShareSupport = fetchFamilyShareSupport;
            SGLV_API.fetchGameStatus = fetchGameStatus;
 // ---- 价格 ----
            SGLV_API.fetchMultiRegionPrices = fetchMultiRegionPrices;
            SGLV_API.fetchSteamRegionPrice = fetchSteamRegionPrice;
            SGLV_API.fetchAugRegionPrice = fetchAugRegionPrice;
            SGLV_API.fetchHistoryPrices = fetchHistoryPrices;
            SGLV_API.fetchHistoryPricesCheapShark = fetchHistoryPricesCheapShark;
            SGLV_API.refreshRates = refreshRates;
 // ---- 徽章 / 卡牌 ----
            SGLV_API.computeBadgeValueScores = computeBadgeValueScores;
            SGLV_API.fetchBadgeMarkets = fetchBadgeMarkets;
            SGLV_API.fetchCardPrices = fetchCardPrices;
            SGLV_API.fetchUserBadges = fetchUserBadges;
 // ---- 社交 / 玩法 ----
            SGLV_API.fetchSteamLevel = fetchSteamLevel;
            SGLV_API.fetchCurrentPlayers = fetchCurrentPlayers;
            SGLV_API.fetchOwnersPlaytime = fetchOwnersPlaytime;
            SGLV_API.fetchTagRecommendations = fetchTagRecommendations;
            SGLV_API.fetchProfileFeaturesStatus = fetchProfileFeaturesStatus;
        }
    })();

 // ==================== 启动 ====================
    async function init() {
 //主题层——主题已在 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`);
 //启动时一次性把 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();
 //同步从 IDB hydrate PCC 持久化计算缓存到 _mem,让 getSync 立即可命中
 //_PCC_CACHE 定义在 SGLV 子闭包内,通过 SGLV_API 桥接调用（修复 ReferenceError）
            if (SGLV_API.hydratePccCache) SGLV_API.hydratePccCache();
        } catch (e) {
            console.warn('[SGLV] IDB 初始化失败,降级使用 GM_setValue:', e);
        }
 //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 初始化完成');
 //注册卸载清理，释放事件监听器/MutationObserver，避免内存泄漏
        window.addEventListener('pagehide', runDisposers);
    }

 //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));
})();