// ==UserScript==
// @name         Steam 社区市场增强
// @name:en      Steam Community Market Enhancer
// @namespace    steam-market-enhancer
// @version      2.2.5
// @description  Steam 社区市场交易助手：上架汇总、超价/低价检测、一键改价重挂、批量下架与我的挂单市场排名；买卖盘全量档位订单深度（各变体最低价 + 税后到手价）、价格历史趋势、跨平台挂刀比价；库存价格标签、快速出售、批量自主定价与交易冷却角标；成交记录分析与导出（CSV/TSV/JSON/Markdown）、全库存浮盈浮亏、我的池子行情盘、补充包制作利润计算、汇率报价参考；交易报价价值摘要与价格提醒。适合每天改价挂单的卖家、批量清库存的玩家、盯价格趋势与盈亏的收藏者，以及在 Steam 充值或转售前想先看清真实到手价的人——挂单、定价、看盘、清货、复盘，一套脚本走完。
// @description:en  Steam Community Market trading assistant: listing summary, overpriced/underpriced detection, one-click relist, batch delisting and market rank of my listings; full-depth order book (per-variant lowest price and net-after-fees), price history, cross-platform price comparison; inventory price labels, quick sell, bulk custom pricing and trade-cooldown badges; transaction history analysis and export (CSV/TSV/JSON/Markdown), portfolio profit and loss, my-pool market dashboard, booster pack profit calculator, FX quote reference; trade offer value summary and price alerts. Built for sellers who relist daily, players clearing inventory in bulk, collectors tracking trends and P&L, and anyone who wants the real take-home figure before topping up or selling elsewhere - list, price, watch, clear and review, all in one script.
// @author       SmallRob
// @match        https://steamcommunity.com/market
// @match        https://steamcommunity.com/market/*
// @match        https://steamcommunity.com/id/*/inventory*
// @match        https://steamcommunity.com/profiles/*/inventory*
// @match        https://steamcommunity.com/tradeoffer/*
// @match        https://steamcommunity.com/tradingcards/boostercreator*
// @grant        GM_addStyle
// @grant        GM_getValue
// @grant        GM_setValue
// @grant        GM_xmlhttpRequest
// @grant        unsafeWindow
// @grant        GM_info
// @connect      store.steampowered.com
// @connect      cdn.jsdelivr.net
// @connect      latest.currency-api.pages.dev
// @connect      buff.163.com
// @connect      api.youpin898.com
// @connect      api.augmentedsteam.com
// @connect      api.frankfurter.app
// @connect      api.frankfurter.dev
// @connect      open.er-api.com
// @require      https://cdn.jsdelivr.net/gh/SmallRob/steam-namespace@main/libs/sglv-plugin-host.lib.js
// @run-at       document-start
// run-at 说明：document-start 是 v1.5.0"显示更多价格"的硬性要求——需在页面 react-dom
// 初始化之前向 window 注入假的 __REACT_DEVTOOLS_GLOBAL_HOOK__ 完成绑定；脚本主体逻辑
// 仍会等待 DOM ready + URL 稳定后再初始化（见文件末尾启动段），不受提前执行影响。
// @license      MIT
// @tag          Steam
// @tag          market
// @icon         data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><defs><linearGradient id='bg' x1='0' y1='0' x2='0' y2='1'><stop offset='0' stop-color='%231b2838'/><stop offset='1' stop-color='%230d0f15'/></linearGradient><linearGradient id='ring' x1='0' y1='0' x2='1' y2='1'><stop offset='0' stop-color='%2366c0f4'/><stop offset='1' stop-color='%232e6d8e'/></linearGradient><linearGradient id='arrow' x1='0' y1='1' x2='1' y2='0'><stop offset='0' stop-color='%232e6d8e'/><stop offset='0.55' stop-color='%2366c0f4'/><stop offset='1' stop-color='%238ad8ff'/></linearGradient></defs><rect width='100' height='100' rx='22' fill='url(%23bg)'/><circle cx='50' cy='50' r='39' fill='none' stroke='url(%23ring)' stroke-width='2.5' opacity='0.6'/><circle cx='50' cy='50' r='39' fill='none' stroke='%2366c0f4' stroke-width='0.5' opacity='0.2' stroke-dasharray='2 4'/><path d='M18 76 L36 56 L48 60 L70 26' fill='none' stroke='url(%23arrow)' stroke-width='5' stroke-linecap='round' stroke-linejoin='round'/><path d='M62 18 L72 18 L72 28' fill='none' stroke='%238ad8ff' stroke-width='5' stroke-linecap='round' stroke-linejoin='round'/><path d='M78 10 L80.5 5 L83 10 L88 12.5 L83 15 L80.5 20 L78 15 L73 12.5 Z' fill='%2366c0f4' opacity='0.85'/></svg>
// ==/UserScript==

(function () {
    // v2.2.1：'use strict' 必须是函数体的**第一条**语句才是指令序言。
    // 原实现把它放在 registerPlugin 的 try 块之后 → 只是个无副作用的字符串表达式，
    // 1.8 万行主体实际一直跑在**非严格模式**（内联的 3 个 lib 自带 'use strict'，不受影响）。
    // 挪到开头后可能暴露隐式全局变量 / 给只读属性赋值等问题 → 已配静态守卫
    // （test/test-strict-mode-static.js）盯住这两类。
    'use strict';

    // v2.2.3 插件版本清单注册（共享宿主 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: 'sme', name: 'Steam 社区市场增强', family: 'market' });
        }
    } catch (e) { /* ignore */ }

    const VERSION = '2.2.5';
    const PREFIX = 'sme';
    console.log(`%c[Steam 社区市场增强] v${VERSION} 已启动`, 'color:#66c0f4;font-weight:bold;font-size:13px');

    /* ===== INLINE-BEGIN: shared/fx-core.lib.js ===== */
/*
 * fx-core.lib.js —— 双锚点汇率引擎（Steam 充值报价参考的取数地基）
 * ===========================================================================
 *  canonical 位置：shared/fx-core.lib.js（本仓库）
 *  消费方式：① Node/测试：require('./fx-core.lib.js')
 *           ② 油猴脚本：原样内联（见 steam-price-converter 的 inline 标记块）
 *
 * 为什么不是「一个接口一张表」：
 *   充值报价评估需要两个口径分开的锚点 ——
 *     steam：Steam 参考结算价（AugmentedSteam 交叉表，跟随 Steam 建议汇率）
 *     spot ：即期市场中间价（Frankfurter=ECB → jsDelivr currency-api → er-api）
 *   两个锚点各自独立取数、独立缓存、独立标注来源与日期；一个挂了不污染另一个。
 *
 * 血的教训（2026-11-05 实测）：
 *   open.er-api.com 免费档会返回 result:"success" + HTTP 200，但 time_last_update
 *   停在 2022-05-09。只看「有没有 rates 字段」就会把 4 年前的牌价当实时汇率。
 *   → 所有源必须做 payload 级新鲜度校验，陈旧即弃并记录 stale 来源。
 *
 * 表的形状（冻结语义，方向不许含糊）：
 *   USD 枢纽表 rates：rates[CODE] = 「1 USD 能换多少 CODE」，rates.USD === 1。
 *   CODE→CNY 的单价 = rates.CNY / rates.CODE（convert 内部走 USD 枢纽）。
 *
 * 缓存键：
 *   fxcore_spot_v1 / fxcore_steam_v1  带 1h TTL 的锚点缓存
 *   fxcore_snap_v1                    无 TTL 快照 {spot,steam,ts}，接口全挂时兜底
 *   只读救援键（不写）：swe_fx_cache / swe_fx_snap_v1 / spc_fx_snap_v1 / spc_fx_v1
 *   —— 与愿望单侧边栏、个人日历两个插件的既有 FX 链互救，快照时间如实保留。
 *
 * 宽表模式（2026-11-06 新增，opt-in，默认关）：
 *   create({ wideTable: true }) → spot 锚把多个源按优先级**逐币种合并**，
 *   而不是「取第一个成功的源」。原因：ECB(frankfurter) 只有 ~30 个币种，
 *   **RUB/TRY/UAH/VND/PHP/NOK/SEK/PLN 全都没有**（ECB 2022 年后不公布卢布），
 *   只取第一个成功的源 → 这些币种一个都拿不到。
 *   合并后 rateDate 取各源里最旧的那个（保守），source 标记 merged:<源列表>。
 *   默认关 → 其余三个插件（个人日历 / 价格换算 / 市场增强的老调用方）行为完全不变。
 * ===========================================================================
 */
(function () {
    'use strict';

    var BASE = 'USD';
    var TTL_MS = 60 * 60 * 1000;          // 锚点缓存 1 小时
    var REQ_TIMEOUT = 6000;               // 单请求超时
    var ANCHOR_BUDGET = 7000;             // 单锚点所有源合计预算
    var SPOT_MAX_AGE_MS = 5 * 24 * 3600 * 1000; // 即期牌价最多容忍 5 天（ECB 周末/长假不更新）
    var ERAPI_MAX_AGE_MS = 72 * 3600 * 1000;

    var K_SPOT = 'fxcore_spot_v1';
    var K_STEAM = 'fxcore_steam_v1';
    var K_SNAP = 'fxcore_snap_v1';
    // 他脚本的缓存/快照：只读，用于接口全挂时的最后一层救援
    var RESCUE_KEYS = ['swe_fx_cache', 'swe_fx_snap_v1', 'spc_fx_snap_v1', 'spc_fx_v1'];

    function isValidTable(rates) {
        return !!rates && typeof rates === 'object' && Number(rates[BASE]) > 0;
    }

    /**
     * 交叉表 {USD:{CNY:6.67}, INR:{CNY:0.070}, ...}（语义：1 单位 X = ? CNY）
     * 折成 USD 枢纽表。真实返回里没有查询币种自己，必须补 rates[quote]。
     * 缺 USD 基准 → null（不硬凑一张比例错的表）。
     */
    function ratesFromCross(data, quoteId) {
        if (!data || typeof data !== 'object') return null;
        var quote = quoteId || 'CNY';
        var baseRow = data[BASE];
        var usdToQuote = baseRow ? Number(baseRow[quote]) : 0;
        if (!usdToQuote || usdToQuote <= 0) return null;
        var out = {};
        Object.keys(data).forEach(function (id) {
            var row = data[id];
            var perQuote = row ? Number(row[quote]) : 0;
            if (!perQuote || perQuote <= 0) return;
            out[id] = usdToQuote / perQuote;
        });
        if (!out[quote]) out[quote] = usdToQuote;
        return Object.keys(out).length ? out : null;
    }

    /** 'YYYY-MM-DD'（UTC）→ ms；非法返回 0 */
    function dateOnlyToMs(s) {
        if (typeof s !== 'string') return 0;
        var m = s.match(/^(\d{4})-(\d{2})-(\d{2})$/);
        if (!m) return 0;
        return Date.UTC(+m[1], +m[2] - 1, +m[3]);
    }

    function ageOk(dateMs, maxAgeMs, now) {
        return dateMs > 0 && (now - dateMs) <= maxAgeMs && dateMs <= now + 24 * 3600 * 1000;
    }

    /** 小写键表 → 大写键表（currency-api 的 usd 对象键是小写） */
    function lowerTableToUpper(lower) {
        var out = {};
        Object.keys(lower).forEach(function (k) {
            var v = Number(lower[k]);
            if (Number.isFinite(v) && v > 0) out[k.toUpperCase()] = v;
        });
        out[BASE] = 1;
        return out;
    }

    // ---- 源定义：parse(data, ctx) 返回 {rates, dateMs} | {stale:true, dateMs} | null ----
    var STEAM_SOURCES = [
        {
            id: 'augmented',
            label: 'api.augmentedsteam.com',
            url: 'https://api.augmentedsteam.com/rates/v1?to=CNY',
            parse: function (data) {
                var rates = ratesFromCross(data, 'CNY');
                if (!rates) return null;
                // AS 交叉表不带日期，dateMs 留空（UI 上显示「接口未提供日期」）
                return { rates: rates, dateMs: 0 };
            },
        },
    ];

    var SPOT_SOURCES = [
        {
            id: 'frankfurter',
            label: 'frankfurter.dev (ECB)',
            // 2026-11-06 实测：api.frankfurter.app 已 301 迁移到 api.frankfurter.dev/v1/latest
            // （路径也多了一层 /v1）。直接用新域名，不再靠重定向活着。
            url: 'https://api.frankfurter.dev/v1/latest?from=USD',
            parse: function (data, ctx) {
                var r = data && data.rates;
                if (!r) return null;
                var rates = Object.assign({}, r);
                rates[BASE] = 1;
                if (!isValidTable(rates)) return null;
                var d = dateOnlyToMs(data.date);
                if (!ageOk(d, SPOT_MAX_AGE_MS, ctx.now)) {
                    return d > 0 ? { stale: true, dateMs: d } : null;
                }
                return { rates: rates, dateMs: d };
            },
        },
        {
            id: 'frankfurter-legacy',
            label: 'frankfurter.app (ECB, 旧域名)',
            url: 'https://api.frankfurter.app/latest?from=USD',
            parse: function (data, ctx) {
                var r = data && data.rates;
                if (!r) return null;
                var rates = Object.assign({}, r);
                rates[BASE] = 1;
                if (!isValidTable(rates)) return null;
                var d = dateOnlyToMs(data.date);
                if (!ageOk(d, SPOT_MAX_AGE_MS, ctx.now)) {
                    return d > 0 ? { stale: true, dateMs: d } : null;
                }
                return { rates: rates, dateMs: d };
            },
        },
        {
            id: 'jsdelivr',
            label: 'cdn.jsdelivr.net currency-api',
            url: 'https://cdn.jsdelivr.net/npm/@fawazahmed0/currency-api@latest/v1/currencies/usd.json',
            parse: function (data, ctx) {
                var u = data && data.usd;
                if (!u) return null;
                var d = dateOnlyToMs(data.date);
                if (!ageOk(d, SPOT_MAX_AGE_MS, ctx.now)) {
                    return d > 0 ? { stale: true, dateMs: d } : null;
                }
                var rates = lowerTableToUpper(u);
                return isValidTable(rates) ? { rates: rates, dateMs: d } : null;
            },
        },
        {
            id: 'erapi',
            label: 'open.er-api.com',
            url: 'https://open.er-api.com/v6/latest/USD',
            parse: function (data, ctx) {
                var rates = data && data.rates;
                if (!rates) return null;
                var d = Number(data.time_last_update_unix) * 1000;
                // 免费档实测会返回 2022 年的陈旧数据却自称 success —— 这里是专门的闸门
                if (!ageOk(d, ERAPI_MAX_AGE_MS, ctx.now)) {
                    return d > 0 ? { stale: true, dateMs: d } : null;
                }
                return isValidTable(rates) ? { rates: rates, dateMs: d } : null;
            },
        },
    ];

    function defaultDeps() {
        return {
            now: function () { return Date.now(); },
            gmGet: function (k, d) {
                try { return (typeof GM_getValue === 'function') ? GM_getValue(k, d) : d; }
                catch (e) { return d; }
            },
            gmSet: function (k, v) {
                try { if (typeof GM_setValue === 'function') GM_setValue(k, v); } catch (e) { /* ignore */ }
            },
            fetchJson: function (url, opts) {
                return new Promise(function (resolve, reject) {
                    if (typeof GM_xmlhttpRequest !== 'function') { reject(new Error('no GM_xmlhttpRequest')); return; }
                    GM_xmlhttpRequest({
                        method: 'GET', url: url, timeout: (opts && opts.timeout) || REQ_TIMEOUT,
                        onload: function (res) {
                            if (res.status >= 200 && res.status < 300) {
                                try { resolve(JSON.parse(res.responseText)); }
                                catch (e) { reject(new Error('bad json: ' + url)); }
                            } else reject(new Error('http ' + res.status));
                        },
                        onerror: function () { reject(new Error('network error: ' + url)); },
                        ontimeout: function () { reject(new Error('timeout: ' + url)); },
                    });
                });
            },
            log: function () {},
            // 宽表模式（默认关）：spot 锚把多个源按优先级逐币种合并，
            // 用来补上 ECB 不公布的币种（RUB/TRY/UAH/VND/PHP/NOK/SEK/PLN…）。
            // 开了它一次刷新会打多个源，且 rateDate 取各源里最旧的那个。
            wideTable: false,
        };
    }

    // ---- 无状态纯函数（实例与顶层 API 共用，方向语义冻结，见文件头） ----

    /** amount 单位 fromCur → toCur，USD 枢纽：from→USD→to；缺项返回 null */
    function convert(amount, fromCur, toCur, rates) {
        var v = Number(amount);
        if (!Number.isFinite(v)) return null;
        if (!fromCur || !toCur || fromCur === toCur) return v;
        if (!isValidTable(rates)) return null;
        var fr = Number(rates[fromCur]);
        var tr = Number(rates[toCur]);
        if (!(fr > 0) || !(tr > 0)) return null;
        return (v / fr) * tr;
    }

    /**
     * 手动汇率覆盖（购汇成本锚点用），不修改原表。
     * per='usd'：value = 「1 USD = value 个 currency」
     * per='cur'：value = 「1 currency = value USD」
     * 非法值 → {ok:false}，调用方必须回退，绝不拿错的数去算报价。
     */
    function applyManualRate(rates, manual) {
        if (!isValidTable(rates)) return { ok: false, reason: 'noTable' };
        if (!manual) return { ok: false, reason: 'noManual' };
        var currency = manual.currency;
        var value = Number(manual.value);
        if (!currency || !Number.isFinite(value) || value <= 0) return { ok: false, reason: 'badValue' };
        var next = Object.assign({}, rates);
        next[currency] = manual.per === 'cur' ? 1 / value : value;
        return { ok: true, rates: next };
    }

    /** 1 单位 code 合多少 CNY（方向冻结：CNY per unit）；CNY/RMB→1；缺项 null */
    function cnyPerUnit(code, rates) {
        if (!code) return null;
        code = String(code).toUpperCase();
        if (code === 'CNY' || code === 'RMB') return 1;
        if (!isValidTable(rates)) return null;
        var cny = Number(rates.CNY);
        var v = Number(rates[code]);
        if (!(cny > 0) || !(v > 0)) return null;
        return cny / v;
    }

    function create(injected) {
        var deps = Object.assign(defaultDeps(), injected || {});
        var wideTable = !!deps.wideTable;
        // mem：{ spot:entry|null, steam:entry|null, ts, warnings:[] }
        // entry = { rates, source, label, rateDate, ts, stale? }
        var mem = { spot: null, steam: null, ts: 0, warnings: [] };
        var inflight = null;   // 单飞的 in-flight Promise

        function readCache(key) {
            try {
                var c = deps.gmGet(key, null);
                if (c && isValidTable(c.rates) && c.ts && (deps.now() - c.ts) < TTL_MS) return c;
            } catch (e) { /* ignore */ }
            return null;
        }

        function writeCache(key, entry) {
            try { deps.gmSet(key, { rates: entry.rates, ts: entry.ts, source: entry.source, rateDate: entry.rateDate || 0 }); }
            catch (e) { /* ignore */ }
        }

        function readSnapshotBuckets() {
            var out = { spot: null, steam: null };
            try {
                var snap = deps.gmGet(K_SNAP, null);
                if (snap) {
                    if (snap.spot && isValidTable(snap.spot.rates)) out.spot = snap.spot;
                    if (snap.steam && isValidTable(snap.steam.rates)) out.steam = snap.steam;
                }
            } catch (e) { /* ignore */ }
            return out;
        }

        function writeSnapshot(spotEntry, steamEntry) {
            var cur = { spot: null, steam: null, ts: deps.now() };
            try {
                var old = deps.gmGet(K_SNAP, null);
                if (old) cur = old;
            } catch (e) { /* ignore */ }
            if (spotEntry) cur.spot = spotEntry;
            if (steamEntry) cur.steam = steamEntry;
            cur.ts = deps.now();
            try { deps.gmSet(K_SNAP, cur); } catch (e) { /* ignore */ }
        }

        /** 救援：他脚本的通用 USD 表快照（来源无法区分锚点，标记 snapshot） */
        function genericRescue(anchorId) {
            for (var i = 0; i < RESCUE_KEYS.length; i++) {
                try {
                    var c = deps.gmGet(RESCUE_KEYS[i], null);
                    if (c && isValidTable(c.rates)) {
                        return {
                            rates: c.rates, source: 'snapshot:' + RESCUE_KEYS[i],
                            label: RESCUE_KEYS[i], rateDate: c.rateDate || 0, ts: c.ts || deps.now(),
                            rescued: true, anchor: anchorId,
                        };
                    }
                } catch (e) { /* next */ }
            }
            return null;
        }

        function fetchAnchor(anchorId, sources) {
            var warnings = [];
            var deadline = deps.now() + ANCHOR_BUDGET;
            function next(i) {
                if (i >= sources.length) return Promise.resolve(null);
                var src = sources[i];
                var left = deadline - deps.now();
                if (left <= 0) return Promise.resolve(null);
                return deps.fetchJson(src.url, { timeout: Math.min(REQ_TIMEOUT, left) })
                    .then(function (data) {
                        var parsed;
                        try { parsed = src.parse(data, { now: deps.now() }); }
                        catch (e) { parsed = null; }
                        if (parsed && parsed.stale) {
                            warnings.push({ anchor: anchorId, source: src.id, reason: 'stale', dateMs: parsed.dateMs });
                            return next(i + 1);
                        }
                        if (parsed && parsed.rates) {
                            return {
                                rates: parsed.rates, source: src.id, label: src.label,
                                rateDate: parsed.dateMs || 0, ts: deps.now(),
                            };
                        }
                        return next(i + 1);
                    })
                    .catch(function () { return next(i + 1); });
            }
            return next(0).then(function (entry) {
                return { entry: entry, warnings: warnings };
            });
        }

        /**
         * 宽表模式（opt-in，默认关）：不取「第一个成功的源」，而是把**所有**源按优先级
         * 逐币种合并 —— 先到的源优先，后来���源只补前面缺的币种。
         *
         * 为什么需要：ECB(frankfurter) 只有 ~30 个币种，**RUB/TRY/UAH/VND/PHP/NOK/SEK/PLN
         * 全都没有**（ECB 2022 年后不公布卢布）；而 currency-api 有 339 个、er-api 有 166 个。
         * 只取第一个成功的源 → 这些币种全部拿不到汇率。
         *
         * 语义变化（只影响开了 wideTable 的调用方）：
         *   · 一次刷新会打多个源（受 ANCHOR_BUDGET 约束，打不完就只用已到的那些）
         *   · rateDate 取各源里**最旧**的那个（保守：合并表里最不鲜的那个币种决定新鲜度）
         *   · source 标记为 merged:<源1>+<源2>，UI 上要如实显示是宽表
         */
        function fetchAnchorMerged(anchorId, sources) {
            var warnings = [];
            var deadline = deps.now() + ANCHOR_BUDGET;
            var merged = null;
            var primary = null;
            var usedSources = [];
            var oldestDate = 0;
            var seenDate = false;

            function step(i) {
                if (i >= sources.length) return Promise.resolve(null);
                var src = sources[i];
                var left = deadline - deps.now();
                if (left <= 0) return Promise.resolve(null);
                return deps.fetchJson(src.url, { timeout: Math.min(REQ_TIMEOUT, left) })
                    .then(function (data) {
                        var parsed;
                        try { parsed = src.parse(data, { now: deps.now() }); }
                        catch (e) { parsed = null; }
                        if (parsed && parsed.stale) {
                            warnings.push({ anchor: anchorId, source: src.id, reason: 'stale', dateMs: parsed.dateMs });
                            return step(i + 1);
                        }
                        if (parsed && parsed.rates) {
                            if (!merged) { merged = {}; primary = src; }
                            var codes = Object.keys(parsed.rates);
                            for (var k = 0; k < codes.length; k++) {
                                if (merged[codes[k]] === undefined) merged[codes[k]] = parsed.rates[codes[k]];
                            }
                            usedSources.push(src.id);
                            var d = parsed.dateMs || 0;
                            if (!seenDate || d < oldestDate) { oldestDate = d; seenDate = true; }
                        }
                        return step(i + 1);
                    })
                    .catch(function () { return step(i + 1); });
            }

            return step(0).then(function () {
                if (!merged || !Object.keys(merged).length) return { entry: null, warnings: warnings };
                return {
                    entry: {
                        rates: merged,
                        source: 'merged:' + usedSources.join('+'),
                        label: (primary ? primary.label : 'merged') + ' + 宽表',
                        rateDate: oldestDate,
                        ts: deps.now(),
                        merged: true,
                        mergedSources: usedSources.slice(),
                    },
                    warnings: warnings,
                };
            });
        }

        /**
         * 取双锚点汇率。force=true 无视 TTL 强刷（F3）。
         * 返回 { spot, steam, ts, warnings }；任一锚点可能为 null（unknown≠0，绝不伪造）。
         */
        function load(force) {
            var now = deps.now();
            if (!force && mem.ts && (now - mem.ts) < TTL_MS && (mem.spot || mem.steam)) {
                return Promise.resolve(mem);
            }
            // 单飞：并发调用共享同一次刷新（多个页面同时要汇率时不会打出一串重复请求）
            if (!inflight) {
                inflight = doLoad(force).then(function (r) { inflight = null; return r; },
                    function (e) { inflight = null; throw e; });
            }
            return inflight;
        }

        function doLoad(force) {
            var now = deps.now();
            var warnings = [];
            var startSpot = null;
            var startSteam = null;
            if (!force) {
                var cs = readCache(K_SPOT);
                var ce = readCache(K_STEAM);
                if (cs) startSpot = cacheToEntry(cs, K_SPOT);
                if (ce) startSteam = cacheToEntry(ce, K_STEAM);
            }
            if (!force && startSpot && startSteam) {
                mem = { spot: startSpot, steam: startSteam, ts: now, warnings: [] };
                return Promise.resolve(mem);
            }

            return Promise.all([
                startSpot ? Promise.resolve({ entry: startSpot, warnings: [] })
                    : (wideTable ? fetchAnchorMerged('spot', SPOT_SOURCES) : fetchAnchor('spot', SPOT_SOURCES)),
                startSteam ? Promise.resolve({ entry: startSteam, warnings: [] }) : fetchAnchor('steam', STEAM_SOURCES),
            ]).then(function (results) {
                var spot = results[0].entry;
                var steam = results[1].entry;
                warnings = warnings.concat(results[0].warnings, results[1].warnings);

                // 网络成功 → 写锚点缓存 + 合并写快照
                if (spot) writeCache(K_SPOT, spot);
                if (steam) writeCache(K_STEAM, steam);
                if (spot || steam) writeSnapshot(spot, steam);

                // 网络全挂的锚点：先找自己的无 TTL 快照，再找他脚本快照救援
                var buckets = readSnapshotBuckets();
                if (!spot) spot = buckets.spot || genericRescue('spot');
                if (!steam) steam = buckets.steam || genericRescue('steam');

                if (spot && spot.rescued) warnings.push({ anchor: 'spot', source: spot.source, reason: 'rescue' });
                if (steam && steam.rescued) warnings.push({ anchor: 'steam', source: steam.source, reason: 'rescue' });
                if (!spot) warnings.push({ anchor: 'spot', reason: 'unavailable' });
                if (!steam) warnings.push({ anchor: 'steam', reason: 'unavailable' });

                mem = { spot: spot, steam: steam, ts: now, warnings: warnings };
                return mem;
            });
        }

        function cacheToEntry(c, key) {
            return {
                rates: c.rates, source: c.source || 'cache', label: c.source || key,
                rateDate: c.rateDate || 0, ts: c.ts, cached: true,
            };
        }

        return {
            BASE: BASE,
            load: load,
            convert: convert,
            applyManualRate: applyManualRate,
            cnyPerUnit: cnyPerUnit,
            ratesFromCross: ratesFromCross,
            isValidTable: isValidTable,
            wideTable: wideTable,
            getMem: function () { return mem; },
            /** 同步取汇率（只读内存里的 spot 锚，不发请求）；取不到返回 null（unknown≠0） */
            getRate: function (fromCur, toCur) {
                var m = mem.spot;
                if (!m || !m.rates) return null;
                var v = convert(1, fromCur, toCur, m.rates);
                return (v === null || !Number.isFinite(v)) ? null : v;
            },
            // 暴露给测试
            _internals: { dateOnlyToMs: dateOnlyToMs, ageOk: ageOk, lowerTableToUpper: lowerTableToUpper, TTL_MS: TTL_MS },
        };
    }

    var api = {
        BASE: BASE,
        create: create,
        ratesFromCross: ratesFromCross,
        isValidTable: isValidTable,
        convert: convert,
        applyManualRate: applyManualRate,
        cnyPerUnit: cnyPerUnit,
    };

    // UMD-lite：Node 测试走 require；油猴内联时挂 window 并由 var 声明直接可见
    if (typeof module === 'object' && module.exports) module.exports = api;
    if (typeof window !== 'undefined') window.FxCore = api;
    if (typeof self !== 'undefined' && !self.FxCore) self.FxCore = api;
})();
    /* ===== INLINE-END: shared/fx-core.lib.js ===== */

    /* ===== INLINE-BEGIN: shared/topup-quote.lib.js ===== */
/*
 * topup-quote.lib.js —— Steam 充值报价归一化 / 公平性分层 / 风险计算 / 群报价文本解析
 * ===========================================================================
 *  canonical 位置：shared/topup-quote.lib.js（本仓库）
 *  纯函数、零依赖（不 require fx-core，汇率方向语义在本库内自洽：
 *  USD 枢纽表 rates[CODE]=「1 USD = ? CODE」，1 单位外币的 CNY 单价 = rates.CNY/rates.CODE）。
 *
 * 报价口径（行规）：「每 100 美金钱包余额收多少人民币」，不是实时汇率。
 *   r_impl      = payCny / face           —— 隐含的 CNY/单位钱包币
 *   ratio_anchor = r_impl / anchorRate    —— 相对某锚点的比例（1=公平，<1=让利，>1=溢价）
 *   到账率风险（受限区）：
 *     eff(%)  = payCny / (face × p)       —— 按到账率 p 调整后的实际成本（CNY/单位）
 *     p*      = payCny / (face × anchorRate) —— 盈亏平衡到账率（实际到账低于它就比牌价贵）
 *
 * 风险色带（2026-11-05 校准，可在 evaluate 覆盖）：
 *   ratio ≥ 0.93  绿  正常让利（批量/代理 5~7% 折让可解释）
 *   0.85–0.93     黄  挂刀/折扣带（89 折挂刀=0.89 落在带内；Steam 市场手续费后成本线 ~0.85）
 *   < 0.85        红  异常低价（低于挂刀成本线，只可能是低价区套利或黑卡，红信封号来源）
 *   ≥ 1.00        灰  溢价
 *   无汇率数据    灰蓝 unknown —— unknown≠0，缺锚点绝不硬算色带
 * ===========================================================================
 */
(function () {
    'use strict';

    var DEFAULT_BANDS = { green: 0.93, yellow: 0.85 };

    var BAND_INFO = {
        gray: { id: 'gray', text: '溢价', cls: 'tq-band-gray', hint: '报价不低于参考汇率，没有价格优势' },
        green: { id: 'green', text: '正常让利', cls: 'tq-band-green', hint: '5~7% 内的折让，批量/代理渠道可解释' },
        yellow: { id: 'yellow', text: '挂刀/折扣带', cls: 'tq-band-yellow', hint: '与市场余额(挂刀)成本线接近，注意渠道资质' },
        red: { id: 'red', text: '异常低价·警惕黑卡', cls: 'tq-band-red', hint: '低于挂刀成本线，可能是黑卡扣款/钱包清零/红信封号' },
        unknown: { id: 'unknown', text: '缺汇率', cls: 'tq-band-unknown', hint: '缺少该币种的汇率锚点，无法评估' },
    };

    function num(v) {
        var n = Number(v);
        return Number.isFinite(n) ? n : NaN;
    }

    /** 归一化报价；非法返回 null（调用方不许拿 null 继续算） */
    function normalize(input) {
        if (!input || typeof input !== 'object') return null;
        var pay = num(input.pay);
        if (!(pay > 0)) return null;

        if (input.kind === 'factor') {
            var f = num(input.factor);
            if (!(f > 0) || f > 1) return null;
            return { kind: 'factor', ccy: 'CNY', face: 1, payCny: f,
                arriveExp: in01(input.arriveExp), arriveLo: in01(input.arriveLo), arriveHi: in01(input.arriveHi),
                label: input.label || '', raw: input.raw || '', confidence: input.confidence || 'hi' };
        }
        if (input.kind === 'same') {
            var faceS = num(input.face);
            if (!(faceS > 0)) return null;
            return { kind: 'same', ccy: 'CNY', face: faceS, payCny: pay,
                arriveExp: in01(input.arriveExp), arriveLo: in01(input.arriveLo), arriveHi: in01(input.arriveHi),
                label: input.label || '', raw: input.raw || '', confidence: input.confidence || 'hi' };
        }
        // 默认 per：每 face 单位外币收 pay 人民币
        var faceP = num(input.face);
        if (!(faceP > 0)) faceP = 100;
        var ccy = String(input.ccy || 'USD').toUpperCase();
        return { kind: 'per', ccy: ccy, face: faceP, payCny: pay,
            arriveExp: in01(input.arriveExp), arriveLo: in01(input.arriveLo), arriveHi: in01(input.arriveHi),
            label: input.label || '', raw: input.raw || '', confidence: input.confidence || 'hi',
            altCcy: input.altCcy ? String(input.altCcy).toUpperCase() : null };
    }

    function in01(v) {
        if (v === undefined || v === null || v === '') return null;
        var n = Number(v);
        if (!Number.isFinite(n)) return null;
        if (n > 1) n = n / 100; // 容忍百分数输入 85 → 0.85
        return (n > 0 && n <= 1) ? n : null;
    }

    /** USD 枢纽表 → 1 单位 code 的 CNY 单价（方向冻结，缺项 null） */
    function cnyPerUnit(code, rates) {
        if (!rates || typeof rates !== 'object') return null;
        code = String(code || '').toUpperCase();
        if (code === 'CNY' || code === 'RMB') return 1;
        var base = Number(rates.USD);
        if (!(base > 0)) return null;
        var cny = Number(rates.CNY);
        var v = Number(rates[code]);
        if (!(cny > 0) || !(v > 0)) return null;
        return cny / v;
    }

    function rateSet(anchor) {
        if (!anchor) return null;
        return anchor.rates || anchor;
    }

    function compareAnchor(q, rate) {
        if (!(rate > 0)) return null;
        var ratio = q.rImpl / rate;
        return {
            rate: rate,
            ratio: ratio,
            fair: q.face * rate,          // 按锚点本该付的人民币
            diff: q.payCny - q.face * rate,
            diffPct: ratio - 1,
        };
    }

    var EPS = 1e-9; // 边界浮点容差（666.92×0.85 这类构造值可能落在 0.8499999…）
    function bandOf(ratio, bands) {
        if (!(Number(ratio) > 0)) return { id: 'unknown', basis: null };
        var b = bands || DEFAULT_BANDS;
        if (ratio >= 1 - EPS) return { id: 'gray', basis: true };
        if (ratio >= b.green - EPS) return { id: 'green', basis: true };
        if (ratio >= b.yellow - EPS) return { id: 'yellow', basis: true };
        return { id: 'red', basis: true };
    }

    function arrivalEval(q, cmp) {
        var hasRange = q.arriveLo !== null && q.arriveHi !== null;
        var pExp = q.arriveExp !== null ? q.arriveExp : (hasRange ? (q.arriveLo + q.arriveHi) / 2 : null);
        if (pExp === null) return null;

        function effAt(p) { return q.payCny / (q.face * p); }
        function effCmp(rate) {
            if (!(rate > 0)) return null;
            return {
                exp: effAt(pExp) / rate,          // 期望到账时实际成本相对锚点
                lo: hasRange ? effAt(q.arriveHi) / rate : null,  // 到账最多→成本最低
                hi: hasRange ? effAt(q.arriveLo) / rate : null,  // 到账最少→成本最高
            };
        }
        var breakEven = function (rate) {
            return rate > 0 ? q.payCny / (q.face * rate) : null;
        };
        var beSteam = cmp.steam ? breakEven(cmp.steam.rate) : null;
        var beSpot = cmp.spot ? breakEven(cmp.spot.rate) : null;
        // 风险以更严格的平衡到账率为准（哪个锚点低，哪个先触发亏损）
        var beMax = [beSteam, beSpot].filter(function (x) { return x !== null; }).sort(function (a, b) { return b - a; })[0];
        var risk = 'low';
        if (beMax !== null) {
            if (beMax >= 0.95) risk = 'high';
            else if (beMax >= 0.85) risk = 'mid';
        }
        return {
            pExp: pExp,
            lo: hasRange ? q.arriveLo : null,
            hi: hasRange ? q.arriveHi : null,
            effRateExp: effAt(pExp),
            effRateLo: hasRange ? effAt(q.arriveHi) : null,
            effRateHi: hasRange ? effAt(q.arriveLo) : null,
            effSteam: effCmp(cmp.steam ? cmp.steam.rate : 0),
            effSpot: effCmp(cmp.spot ? cmp.spot.rate : 0),
            breakEvenSteam: beSteam,
            breakEvenSpot: beSpot,
            risk: risk,
        };
    }

    /**
     * 评估一条报价。
     * @param q  normalize() 的产物，或可直接 normalize 的输入
     * @param tables {spot:{rates}|rates, steam:{rates}|rates, cost:{rates}|rates}
     * @param opts {bands:{green,yellow}, costRate?}
     */
    function evaluate(q, tables, opts) {
        var quote = (q && q.payCny !== undefined && q.face !== undefined) ? q : normalize(q);
        if (!quote) return null;
        quote.rImpl = quote.payCny / quote.face;
        tables = tables || {};
        opts = opts || {};

        var spotRates = rateSet(tables.spot);
        var steamRates = rateSet(tables.steam);
        var costRates = rateSet(tables.cost);

        var spotRate = cnyPerUnit(quote.ccy, spotRates);
        var steamRate = cnyPerUnit(quote.ccy, steamRates);
        var costRate = cnyPerUnit(quote.ccy, costRates);

        var cmp = {
            spot: compareAnchor(quote, spotRate),
            steam: compareAnchor(quote, steamRate),
            cost: compareAnchor(quote, costRate),
        };

        // 色带以 Steam 参考为优先基准，缺失时退即期牌价；都没有 → unknown
        var basisRate = steamRate || spotRate;
        var band = bandOf(basisRate ? quote.rImpl / basisRate : 0, opts.bands);
        if (!basisRate) band = { id: 'unknown', basis: null };
        else band.basis = steamRate ? 'steam' : 'spot';

        var arrival = arrivalEval(quote, cmp);

        return {
            quote: quote,
            rImpl: quote.rImpl,
            spot: cmp.spot,
            steam: cmp.steam,
            cost: cmp.cost,
            band: {
                id: band.id, basis: band.basis,
                text: BAND_INFO[band.id].text, hint: BAND_INFO[band.id].hint, cls: BAND_INFO[band.id].cls,
            },
            arrival: arrival,
        };
    }

    /** 反算：充 amount 单位 ccy，按某 CNY/单位 汇率应付多少人民币 */
    function payable(amount, ccy, rates) {
        var a = num(amount);
        if (!(a > 0)) return null;
        var rate = cnyPerUnit(ccy, rates);
        if (rate === null) return null;
        return { amount: a, ccy: String(ccy).toUpperCase(), rate: rate, cny: a * rate };
    }

    // ==================== 群报价文本解析 ====================

    var TITLE_RE = /【([^】]+)】|\[([^\]]+)\]/;
    var SAME_RE = /(\d+(?:\.\d+)?)\s*R\s*[=＝]\s*(\d+(?:\.\d+)?)/i;
    var FACTOR_RE = /(\d+(?:\.\d+)?)\s*折/;
    var ARRIVE_RANGE_RE = /(\d+(?:\.\d+)?)\s*[~～\-—至]\s*(\d+(?:\.\d+)?)/;
    var ARRIVE_CTX_RE = /到|账|只能|未到/;
    var CTX_KW = /充|折|刀|美金|美元|欧元|乌克|印度|俄区|巴区|区\b|余额|R\s*[=＝]/;
    var BARE_LINE_RE = /^\s*(\d+(?:\.\d+)?)\s*$/;
    var UNIT_AFTER = /^\s*(?:美金|美刀|美元|欧元|欧|刀|R|以上)/;

    function titleOf(line) {
        var m = line.match(TITLE_RE);
        return m ? (m[1] || m[2]) : '';
    }

    /** 行尾候选报价数字：排除「300美金」「100刀」这类面值数字 */
    function trailingQuoteNumber(line) {
        var re = /\d+(?:\.\d+)?/g;
        var m;
        var candidates = [];
        while ((m = re.exec(line)) !== null) {
            var after = line.slice(m.index + m[0].length);
            if (UNIT_AFTER.test(after)) continue;
            candidates.push({ value: parseFloat(m[0]), index: m.index });
        }
        return candidates.length ? candidates[candidates.length - 1].value : null;
    }

    function inferCcy(line) {
        var euro = /欧元|€/.test(line);
        var usd = /美金|美刀|美元|纯美|\d\s*刀/.test(line);
        var mixed = /混充|多币?种/.test(line);
        var region = /乌克|印度|UAH|INR/.test(line);
        if (euro && mixed) return { ccy: 'USD', confidence: 'lo', altCcy: 'EUR' };
        if (euro && !usd) return { ccy: 'EUR', confidence: 'hi' };
        if (usd) return { ccy: 'USD', confidence: 'hi' };
        if (region) return { ccy: 'USD', confidence: 'lo', region: true };
        return { ccy: 'USD', confidence: 'lo' };
    }

    function parseArrival(line) {
        var m = line.match(ARRIVE_RANGE_RE);
        if (!m) return null;
        var lo = parseFloat(m[1]);
        var hi = parseFloat(m[2]);
        if (!(lo > 0 && hi > 0 && lo <= 100 && hi <= 100 && lo <= hi)) return null;
        // 区间前后 10 字内要有到账语境（防止把普通数字范围当成到账率）
        var before = line.slice(Math.max(0, m.index - 10), m.index);
        var after = line.slice(m.index + m[0].length, m.index + m[0].length + 10);
        if (!ARRIVE_CTX_RE.test(before) && !ARRIVE_CTX_RE.test(after)) return null;
        return { lo: lo / 100, hi: hi / 100, index: m.index, len: m[0].length };
    }

    /**
     * 解析群发报价文本 → quote 数组（normalize 输入形状，evaluate 可直接消费）。
     * 不认识的行不产出（unknown≠0）；低置信度行（混充/区域口径）打 confidence:'lo'。
     */
    function parseQuoteText(text) {
        if (!text || typeof text !== 'string') return [];
        var lines = text.split(/\r?\n/);
        var quotes = [];
        var ctx = null;   // {label, ccy, confidence, altCcy, age}

        function emit(q) {
            var lastIdx = quotes.length - 1;
            if (q.arriveLo === undefined) {
                q.arriveLo = null;
                q.arriveHi = null;
            }
            quotes.push(q);
            return quotes[quotes.length - 1];
        }

        for (var i = 0; i < lines.length; i++) {
            var raw = lines[i];
            var line = raw.trim();
            if (!line) continue;
            if (ctx) ctx.age++;

            var title = titleOf(line);
            if (title && (!ctx || ctx.title !== title)) {
                ctx = { title: title, label: title, age: 0 };
            }

            // 1) 国区同币「500R=472」
            var same = line.match(SAME_RE);
            if (same) {
                var qs = normalize({
                    kind: 'same', face: parseFloat(same[1]), pay: parseFloat(same[2]),
                    label: title || ctxLabel(ctx) || ('国区 ' + same[0]),
                    raw: line, confidence: 'hi',
                });
                if (qs) { emit(qs); ctx = ctx || { age: 0 }; continue; }
            }

            // 2) 折扣「89折」（89折/8.9折/0.89折 都归 0.89）
            var fac = line.match(FACTOR_RE);
            if (fac && !/R\s*[=＝]/.test(line)) {
                var n = parseFloat(fac[1]);
                var factor = n >= 10 ? n / 100 : (n >= 1 ? n / 10 : n);
                var qf = normalize({
                    kind: 'factor', pay: factor, factor: factor,
                    label: title || ctxLabel(ctx) || (factor * 10 + '折'),
                    raw: line, confidence: 'hi',
                });
                if (qf) { emit(qf); continue; }
            }

            // 3) 到账区间提示（70~100）：先把区间片段从行里剜掉，
            //    避免「下单100刀只能到70~100之间」里的数字被误当报价
            var arr = parseArrival(line);
            var stripped = arr
                ? line.slice(0, arr.index) + line.slice(arr.index + arr.len)
                : line;
            var looksChannel = /充|折|刀|美金|美元|欧元|乌克|印度|余额/.test(stripped);
            if (arr && trailingQuoteNumber(stripped) === null) {
                var last = quotes[quotes.length - 1];
                if (last) {
                    last.arriveLo = arr.lo;
                    last.arriveHi = arr.hi;
                    if (last.arriveExp === null || last.arriveExp === undefined) {
                        last.arriveExp = (arr.lo + arr.hi) / 2;
                    }
                }
                continue;
            }

            // 4) 行尾自带报价数字（610 / 600 / 590 与描述同行；区间数字已剜除）
            var n2 = trailingQuoteNumber(stripped);
            if (n2 !== null && looksChannel) {
                var inf = inferCcy(line);
                var qp = normalize({
                    kind: 'per', pay: n2, face: 100, ccy: inf.ccy,
                    label: title || ctxLabel(ctx) || line.slice(0, 12),
                    raw: line, confidence: inf.confidence,
                    altCcy: inf.altCcy || null,
                });
                if (qp) {
                    if (arr) { qp.arriveLo = arr.lo; qp.arriveHi = arr.hi; qp.arriveExp = (arr.lo + arr.hi) / 2; }
                    emit(qp);
                    if (ctx) ctx.age = 0;
                    continue;
                }
            }

            // 5) 独立数字行（「大额300美金以上起充」换行后的 590）
            var bare = line.match(BARE_LINE_RE);
            if (bare && ctx && ctx.age <= 2) {
                var inf2 = { ccy: ctx.ccy || 'USD', confidence: ctx.confidence || 'lo', altCcy: ctx.altCcy || null };
                var qb = normalize({
                    kind: 'per', pay: parseFloat(bare[1]), face: 100, ccy: inf2.ccy,
                    label: ctx.label || line, raw: line,
                    confidence: inf2.confidence, altCcy: inf2.altCcy,
                });
                if (qb) { emit(qb); ctx.age = 0; continue; }
            }

            // 6) 更新上下文（含关键词的描述行）
            if (looksChannel) {
                var inf3 = inferCcy(line);
                ctx = {
                    title: title || (ctx && ctx.title) || '',
                    label: title || (ctx && ctx.label) || line.slice(0, 12),
                    ccy: inf3.ccy, confidence: inf3.confidence, altCcy: inf3.altCcy || null,
                    age: 0,
                };
            }
        }
        return quotes;
    }

    function ctxLabel(ctx) {
        return ctx && ctx.label ? ctx.label : '';
    }

    var api = {
        DEFAULT_BANDS: DEFAULT_BANDS,
        BAND_INFO: BAND_INFO,
        normalize: normalize,
        evaluate: evaluate,
        parseQuoteText: parseQuoteText,
        payable: payable,
        cnyPerUnit: cnyPerUnit,
        bandOf: bandOf,
        _internals: { trailingQuoteNumber: trailingQuoteNumber, inferCcy: inferCcy, parseArrival: parseArrival },
    };

    if (typeof module === 'object' && module.exports) module.exports = api;
    if (typeof window !== 'undefined') window.TopupQuote = api;
    if (typeof self !== 'undefined' && !self.TopupQuote) self.TopupQuote = api;
})();
    /* ===== INLINE-END: shared/topup-quote.lib.js ===== */

    /* ===== INLINE-BEGIN: shared/case-fx.lib.js ===== */
/*
 * case-fx.lib.js —— CS2 武器箱隐含汇率（纯计算，不发请求）
 * ===========================================================================
 *  canonical 位置：shared/case-fx.lib.js（本仓库）
 *  消费方式：① Node/测试：require('./case-fx.lib.js')
 *           ② 油猴脚本：原样内联（见 steam-market-enhancer 的 INLINE 标记块）
 *
 * 这个库回答的数：花 1 美元 Steam 钱包买箱子，按 BUFF 在售价卖掉能换回多少人民币。
 *   毛汇率 = BUFF在售最低价(CNY) / Steam美元区买家价(USD)
 *   净汇率 = 毛汇率 × (1 - buffFee)
 *   价差   = 净汇率 - 卡价          正数 = 箱子套现比卡价多出的人民币/美元
 *
 * 美元区买家价是美金卡入账之后真正付出的钱包美元（标价已含 Steam 购买侧费用）。
 * buffFee 只扣 BUFF 卖出手续费。不要再乘挂刀比价用的 0.85：那是另一条路径
 * （Steam 卖出到手 vs 第三方），乘进来会把价差算没。
 *
 * 标题汇率是有效箱子净汇率的中位数。偏离中位数超过 outlierPct、或 24h 成交量
 * 低于 minVolume 的不计入。有效只数 < minCount 时 median 为 null（unknown≠0）。
 *
 * 2026-11-06 改造（v2.2.0，依据见 fxq.lib.js 库头「血的教训」）：
 *   ① **离群阈值从 8% 收紧到 3%**，但阈值不是死数：
 *      实际判定用 `dev > max(outlierPct, 本行误差 + 中位数误差)`。
 *      理由：箱子单价只有 $0.12~$1.12，两位小数量化误差就有 ±0.4%~4.2%，
 *      固定 8% 抓不到量化噪声（实测 Kilowatt lowest 口径偏 5%），
 *      而固定 3% 又会把纯噪声当离群剔掉 → 必须让阈值跟着本行的精度走。
 *   ② **价格口径由调用方决定**（本库不猜）：调用方可用 steamPrice/buffPrice
 *      传入稳健统计量（Steam median / BUFF 前三档均价），
 *      缺省时仍用 steamUsd/buffCny（向后兼容，老调用方不受影响）。
 *   ③ 每行带 errPct（该行价格的量化误差上界），返回值带 uncertainty
 *      （有效样本里的最大误差，保守取 max）→ 调用方必须把它显示出来，
 *      精度不够的数字不能显示得像精确值。
 * ===========================================================================
 */
(function () {
    'use strict';

    var DEFAULTS = {
        buffFee: 0.025,
        minVolume: 50,
        outlierPct: 0.03,
        minCount: 3,
    };

    /** 两位小数取整的量化步长（本库口径固定 USD/CNY，都是两位小数） */
    var PRICE_STEP = 0.005;

    function num(v) {
        var n = Number(v);
        return Number.isFinite(n) ? n : NaN;
    }

    /** 价格量化误差上界（百分比）。价格缺失 → null */
    function priceErrPct(price) {
        var p = num(price);
        if (!(p > 0)) return null;
        return (PRICE_STEP / p) * 100;
    }

    function medianOf(sorted) {
        var n = sorted.length;
        if (!n) return null;
        var mid = Math.floor(n / 2);
        if (n % 2) return sorted[mid];
        return (sorted[mid - 1] + sorted[mid]) / 2;
    }

    /** BUFF 人民币在售价 / Steam 美元买家价。缺腿返回 null。 */
    function impliedRate(buffCny, steamUsd) {
        var b = num(buffCny);
        var s = num(steamUsd);
        if (!(b > 0) || !(s > 0)) return null;
        return b / s;
    }

    /**
     * 扣掉 BUFF 卖出手续费后的汇率。
     * buffFee 为 0~1 的比例；缺省、非法视为 0（净汇率 = 毛汇率），不拿错的扣减去算。
     */
    function netRate(buffCny, steamUsd, buffFee) {
        var gross = impliedRate(buffCny, steamUsd);
        if (gross === null) return null;
        var fee = num(buffFee);
        if (!Number.isFinite(fee) || fee < 0 || fee >= 1) fee = 0;
        return gross * (1 - fee);
    }

    /** 正数：箱子净汇率高于卡价（每 1 美元多出的人民币）。缺任一端返回 null。 */
    function spread(caseNet, cardRate) {
        var c = num(caseNet);
        var k = num(cardRate);
        if (!(c > 0) || !(k > 0)) return null;
        var perUsd = c - k;
        return { perUsd: perUsd, per100: perUsd * 100 };
    }

    function feeOf(opts) {
        var fee = opts && opts.buffFee != null ? num(opts.buffFee) : DEFAULTS.buffFee;
        if (!Number.isFinite(fee) || fee < 0 || fee >= 1) return 0;
        return fee;
    }

    /**
     * @param items [{name, buffCny, steamUsd, volume, note?}]
     *        可选：steamPrice / buffPrice（调用方已选好的稳健口径）、
     *              errPct（调用方算好的误差上界，覆盖本库估算）
     * @param opts  {buffFee, minVolume, outlierPct, minCount} 缺省用 DEFAULTS
     * @returns {rows, median, min, max, used, total, unknown, uncertainty, rejected}
     *   row.status: used | outlier | thin | missing
     */
    function evaluateBasket(items, opts) {
        opts = opts || {};
        var fee = feeOf(opts);
        var minVolume = opts.minVolume != null ? opts.minVolume : DEFAULTS.minVolume;
        var outlierPct = opts.outlierPct != null ? opts.outlierPct : DEFAULTS.outlierPct;
        var minCount = opts.minCount != null ? opts.minCount : DEFAULTS.minCount;
        var list = Array.isArray(items) ? items : [];

        var rows = list.map(function (it) {
            it = it || {};
            var name = it.name ? String(it.name) : '';
            var vol = num(it.volume);
            if (!Number.isFinite(vol) || vol < 0) vol = 0;
            // 价格口径：调用方给了稳健口径就用稳健口径，否则回落到老字段
            var steamPrice = it.steamPrice != null ? num(it.steamPrice) : num(it.steamUsd);
            var buffPrice = it.buffPrice != null ? num(it.buffPrice) : num(it.buffCny);
            if (!(steamPrice > 0)) steamPrice = 0;
            if (!(buffPrice > 0)) buffPrice = 0;
            var gross = impliedRate(buffPrice, steamPrice);
            var net = gross === null ? null : gross * (1 - fee);
            var errPct = it.errPct != null ? num(it.errPct) : null;
            if (!Number.isFinite(errPct) || errPct < 0) {
                var e1 = priceErrPct(steamPrice);
                var e2 = priceErrPct(buffPrice);
                errPct = e1 === null ? e2 : (e2 === null ? e1 : Math.max(e1, e2));
            }
            var row = {
                name: name,
                buffCny: buffPrice,
                steamUsd: steamPrice,
                volume: vol,
                gross: gross,
                net: net,
                errPct: errPct,
                status: 'candidate',
                reason: '',
            };
            if (gross === null) {
                row.status = 'missing';
                row.reason = it.note ? String(it.note) : '无报价';
                return row;
            }
            if (vol < minVolume) {
                row.status = 'thin';
                row.reason = '24小时成交 ' + vol + '，低于 ' + minVolume;
                return row;
            }
            return row;
        });

        var candidates = rows.filter(function (r) { return r.status === 'candidate'; });
        var candNets = candidates.map(function (r) { return r.net; }).sort(function (a, b) { return a - b; });
        var pivot = medianOf(candNets);
        // 中位数自身的误差：候选行误差的中位数（保守）
        var pivotErr = medianOf(candidates.map(function (r) { return r.errPct || 0; }).sort(function (a, b) { return a - b; })) || 0;
        if (pivot > 0) {
            candidates.forEach(function (r) {
                var dev = Math.abs(r.net - pivot) / pivot;
                // 阈值跟着精度走：量化误差能解释的偏离不算离群
                // （errPct / pivotErr 是百分数，先折成小数再和 outlierPct 同量纲比）
                var tol = Math.max(outlierPct, ((r.errPct || 0) + pivotErr) / 100);
                if (dev > tol) {
                    r.status = 'outlier';
                    r.reason = '偏离中位数 ' + (dev * 100).toFixed(1) + '%';
                } else {
                    r.status = 'used';
                }
            });
        }

        var used = rows.filter(function (r) { return r.status === 'used'; });
        var usedNets = used.map(function (r) { return r.net; }).sort(function (a, b) { return a - b; });
        var median = used.length >= minCount ? medianOf(usedNets) : null;
        // 不确定度：有效样本里的最大误差（保守取 max，不假设误差独立）
        var uncertainty = null;
        used.forEach(function (r) {
            var e = r.errPct || 0;
            if (uncertainty === null || e > uncertainty) uncertainty = e;
        });
        return {
            rows: rows,
            median: median,
            min: median === null ? null : usedNets[0],
            max: median === null ? null : usedNets[usedNets.length - 1],
            used: used.length,
            total: rows.length,
            rejected: rows.filter(function (r) { return r.status === 'outlier' || r.status === 'thin'; }).length,
            uncertainty: uncertainty,
            unknown: median === null,
        };
    }

    var api = {
        DEFAULTS: DEFAULTS,
        impliedRate: impliedRate,
        netRate: netRate,
        spread: spread,
        evaluateBasket: evaluateBasket,
        priceErrPct: priceErrPct,
        _internals: { medianOf: medianOf },
    };

    if (typeof module === 'object' && module.exports) module.exports = api;
    if (typeof window !== 'undefined') window.CaseFx = api;
    if (typeof self !== 'undefined' && !self.CaseFx) self.CaseFx = api;
})();
    /* ===== INLINE-END: shared/case-fx.lib.js ===== */

    /* ===== INLINE-BEGIN: shared/vol-metrics.lib.js ===== */
/*
 * vol-metrics.lib.js —— 价格序列波动率度量（CV 变异系数 + 下标线性回归趋势拟合）
 * ===========================================================================
 *  canonical 位置：shared/vol-metrics.lib.js（本仓库）
 *  消费方式：① Node/测试：require('./vol-metrics.lib.js')
 *           ② 油猴脚本：原样内联（见 steam-market-enhancer 的 INLINE 标记块）
 *
 * 为什么要有这个库（借鉴 AetherSwap 的 CV + R² 选品思想）：
 *   「史低 / 降价提醒」只有在低波动序列上才可信 ——
 *   CV 0.4 的物品今天史低，明天可能再跌 20%，跌破阈值是家常便饭而非机会；
 *   而持续阴跌（slope<0 且拟合度高）的「降价」是趋势而非买点。
 *   用两个正交维度给序列定性：
 *     CV（变异系数 = 样本标准差 / 均值）  —— 震荡幅度，量纲无关，可跨价格量级比较
 *     R² + slope（对下标的最小二乘回归） —— 趋势方向与置信度
 *
 * 分级语义（classifyVol，阈值冻结）：
 *   stable    cv ≤ 0.05            波动小，提醒可信度高
 *   normal    0.05 < cv ≤ 0.15     一般
 *   volatile  cv > 0.15            价格剧烈震荡，阈值提醒参考价值低
 *   declining slope<0 且 r2 ≥ 0.6  趋势性下跌（覆盖上面的分级，最优先判定）
 *
 * 输入约定：prices 为数值数组；空 / 单元素 / 均值≤0 / 含非有限数一律返回 null
 * —— unknown≠0，算不出就如实说算不出，绝不拿脏数据硬算。
 * ===========================================================================
 */
(function () {
    'use strict';

    var STABLE_CV_MAX = 0.05;   // stable 上界（含）
    var NORMAL_CV_MAX = 0.15;   // normal 上界（含）
    var DECLINE_R2_MIN = 0.6;   // declining 判定要求的拟合度下界（含）

    /** 数组 → 有限数值数组；非数组 / 含非有限数返回 null */
    function toNums(prices) {
        if (!Array.isArray(prices)) return null;
        var out = [];
        for (var i = 0; i < prices.length; i++) {
            var v = Number(prices[i]);
            if (!Number.isFinite(v)) return null;
            out.push(v);
        }
        return out;
    }

    /**
     * CV 变异系数 = 样本标准差（n-1 分母）/ 均值。
     * 空 / 单元素 / 均值≤0 → null（均值≤0 时 CV 无意义，负价序列本就是脏数据）。
     */
    function cvOf(prices) {
        var arr = toNums(prices);
        if (!arr || arr.length < 2) return null;
        var n = arr.length;
        var sum = 0;
        for (var i = 0; i < n; i++) sum += arr[i];
        var mean = sum / n;
        if (!(mean > 0)) return null;
        var ss = 0;
        for (var j = 0; j < n; j++) {
            var d = arr[j] - mean;
            ss += d * d;
        }
        return Math.sqrt(ss / (n - 1)) / mean;
    }

    /**
     * 对下标 0..n-1 做最小二乘线性回归，返回 {slope, r2}。
     * r2 = 1 - SSE/SST；SST=0（常数序列）时 r2=1（完美平稳）。
     * 空 / 单元素 / 含非有限数 → null（两点才成线）。
     */
    function linregOf(prices) {
        var arr = toNums(prices);
        if (!arr || arr.length < 2) return null;
        var n = arr.length;
        var sumX = 0, sumY = 0, sumXY = 0, sumXX = 0;
        for (var i = 0; i < n; i++) {
            sumX += i;
            sumY += arr[i];
            sumXY += i * arr[i];
            sumXX += i * i;
        }
        var slope = (n * sumXY - sumX * sumY) / (n * sumXX - sumX * sumX);
        var intercept = (sumY - slope * sumX) / n;
        var meanY = sumY / n;
        var sse = 0, sst = 0;
        for (var j = 0; j < n; j++) {
            var fit = intercept + slope * j;
            var e = arr[j] - fit;
            sse += e * e;
            var d = arr[j] - meanY;
            sst += d * d;
        }
        var r2 = sst === 0 ? 1 : 1 - sse / sst;
        if (r2 < 0) r2 = 0; // 浮点误差兜底（带截距的最小二乘数学上 SSE≤SST）
        if (r2 > 1) r2 = 1;
        return { slope: slope, r2: r2 };
    }

    /**
     * 分级（阈值见文件头；declining 覆盖一切）。任一参数非有限数 → null。
     * 返回 {level, cv, r2, slope}。
     */
    function classifyVol(cv, r2, slope) {
        // null/undefined 显式拒绝（Number(null)===0，不拦会把缺参当 0 混进分级）
        if (cv == null || r2 == null || slope == null) return null;
        var c = Number(cv), r = Number(r2), s = Number(slope);
        if (!Number.isFinite(c) || !Number.isFinite(r) || !Number.isFinite(s)) return null;
        var level;
        if (s < 0 && r >= DECLINE_R2_MIN) level = 'declining';
        else if (c <= STABLE_CV_MAX) level = 'stable';
        else if (c <= NORMAL_CV_MAX) level = 'normal';
        else level = 'volatile';
        return { level: level, cv: c, r2: r, slope: s };
    }

    /** 一步到位：cvOf + linregOf + classifyVol；输入非法 → null */
    function metricsOf(prices) {
        var cv = cvOf(prices);
        if (cv === null) return null;
        var lr = linregOf(prices);
        if (!lr) return null;
        return classifyVol(cv, lr.r2, lr.slope);
    }

    var api = {
        cvOf: cvOf,
        linregOf: linregOf,
        classifyVol: classifyVol,
        metricsOf: metricsOf,
    };

    // UMD-lite：Node 测试走 require；油猴内联时挂 window（主脚本经 window.VolMetrics 取用）
    if (typeof module === 'object' && module.exports) module.exports = api;
    if (typeof window !== 'undefined') window.VolMetrics = api;
    if (typeof self !== 'undefined' && !self.VolMetrics) self.VolMetrics = api;
})();
    /* ===== INLINE-END: shared/vol-metrics.lib.js ===== */

    /* ===== INLINE-BEGIN: shared/fxq.lib.js ===== */
/*
 * fxq.lib.js —— 汇率报价面板的纯计算层（精度 / 稳健统计量 / Steam 实测反推 / 锚点分歧度）
 * ===========================================================================
 *  canonical 位置：shared/fxq.lib.js（本仓库）
 *  消费方式：① Node/测试：require('./fxq.lib.js')
 *           ② 油猴脚本：原样内联（见 steam-market-enhancer 的 INLINE 标记块）
 *
 * 这个库只回答「算得准不准」，不发一个请求：
 *   ① 一次价格读数有多准？        → quantErrPct / synthUncertainty
 *   ② 该用最低价还是中位价？      → pickSteamPrice / pickBuffPrice
 *   ③ Steam 到底按什么汇率定价？  → buildLiveRate（双币种反推 + 双读自洽）
 *   ④ 两个锚点差多少、算不算异常？→ divergence / explainDivergence
 *   ⑤ 价差是真的还是在噪声里？    → signalOf
 *
 * 血的教训（2026-11-06 一线实测，steam-market-enhancer 汇率报价面板 v2.1.0 现役缺陷）：
 *   ① **第三方汇率表 ≠ Steam 实际执行价**。AS 的 `rates/v1?to=CNY` 给 6.67098，
 *      而 Steam 把 $76.01 标成 ¥510.83 → 真实汇率 6.72056，**差 0.78%**。
 *      同物品多币种对比 ECB：EUR +0.10% / JPY +0.08% / GBP −0.06% / KRW +0.15%，
 *      而 **CNY +0.78%** → 这层摩擦是人民币钱包专属，不是全局手续费。
 *      → 「Steam 参考价」必须实测反推，不能引用第三方表。
 *   ② **价格量化误差 = ±0.005/price**（两位小数取整）。$76 档 ±0.01%，$0.12 档 ±4.2%。
 *      用 lowest_price 算「汇率」会把单个错价挂单放大成 5% 偏差
 *      （实测 Kilowatt lowest 隐含 6.3333 vs median 隐含 6.6667），
 *      而 8% 的离群阈值**根本抓不到** → 必须用稳健统计量 + 显式标注不确定度。
 *   ③ **价格串是本地化的**：EUR 是 "67,79€"、JPY 是 "¥ 12,054"、CNY 是 "¥ 510.83"。
 *      用 `/[\d.,]+/` 一把梭会把 "1,234.56" 解析成 1.234（**1000× 错**）
 *      → 必须按币种小数位解析（parseMoney）。
 *
 * 口径纪律（沿用本仓既有哲学）：
 *   unknown≠0 —— 缺任何一腿都返回 null，绝不拿 0 或另一个口径的数充数；
 *   不猜 —— 精度不够时把不确定度显式标出来，而不是把数字显示得像精确值。
 * ===========================================================================
 */
(function () {
    'use strict';

    var DEFAULTS = {
        minAnchorUsd: 10,        // 高价锚的最低美元价（低于它量化误差太大，不采信）
        anchorSelfTol: 0.0005,   // lowest/median 双读自洽容差（0.05%）
        minCount: 3,              // 有效样本下限（不足不给中位数）
        divWarn: 0.015,           // 锚点分歧：注意线
        divAlert: 0.03,           // 锚点分歧：告警线
        asCrossAlert: 0.02,       // 实测值与第三方表的分歧告警线
        zeroDecimals: ['JPY', 'KRW', 'CLP', 'VND', 'IDR', 'CRC'],
    };

    /**
     * 转数字。**null / undefined / 空串 → NaN**（不是 0）。
     * 理由：unknown≠0 —— 「没有这个数」和「这个数是 0」是两回事，
     * 混在一起会让 synthUncertainty 把「全都不知道」报成 0% 误差，
     * 也会让 signalOf 把「不知道不确定度」当成「零误差 → 有差就是真信号」。
     */
    function num(v) {
        if (v === null || v === undefined || v === '') return NaN;
        var n = Number(v);
        return Number.isFinite(n) ? n : NaN;
    }

    /** 该币种价格串的小数位：0（整数币种）或 2 */
    function decimalsOf(code) {
        var c = String(code || '').toUpperCase();
        return DEFAULTS.zeroDecimals.indexOf(c) >= 0 ? 0 : 2;
    }

    /**
     * 解析 Steam 本地化价格串（千分位/小数点/欧式逗号小数/整数币种）。
     * 返回 number 或 null（解析不出来就是 null，不返回 0 —— 0 是有效价格边界）。
     *
     *   parseMoney('$76.01', 'USD')      → 76.01
     *   parseMoney('¥ 510.83', 'CNY')    → 510.83
     *   parseMoney('67,79€', 'EUR')      → 67.79   （欧式逗号小数）
     *   parseMoney('¥ 12,054', 'JPY')    → 12054   （整数币种，千分位是分隔符）
     *   parseMoney('1,234.56', 'USD')    → 1234.56
     */
    function parseMoney(s, code) {
        if (s === null || s === undefined) return null;
        var raw = String(s);
        var neg = /^\s*-/.test(raw);
        var t = raw.replace(/[^\d.,]/g, '');
        if (!/\d/.test(t)) return null;
        if (decimalsOf(code) === 0) {
            t = t.replace(/[.,]/g, '');
        } else if (/^\d{1,3}([.,]\d{3})+$/.test(t)) {
            // 纯千分位：1,234 / 1.234
            t = t.replace(/[.,]/g, '');
        } else if (/^\d{1,3}([.,]\d{3})+\.\d{1,2}$/.test(t) || /^\d{1,3}([.,]\d{3})*,\d{1,2}$/.test(t)) {
            // 混合：1,234.56 / 1.234,56 —— 靠后的那个是小数点
            var lastDot = t.lastIndexOf('.');
            var lastComma = t.lastIndexOf(',');
            if (lastComma > lastDot) t = t.replace(/\./g, '').replace(',', '.');
            else t = t.replace(/,/g, '');
        } else if (/^\d+,\d{1,2}$/.test(t)) {
            t = t.replace(',', '.');           // 欧式小数逗号
        } else if (!/^\d+\.\d{1,2}$/.test(t)) {
            // 兜底：最后一个分隔符当小数点
            var ld = t.lastIndexOf('.');
            var lc = t.lastIndexOf(',');
            if (lc > ld) t = t.replace(/\./g, '').replace(',', '.');
            else if (ld >= 0) t = t.replace(/,/g, '');
        }
        var v = parseFloat(t);
        if (!Number.isFinite(v)) return null;
        return neg ? -v : v;
    }

    /**
     * 价格量化误差上界（百分比）。
     * 两位小数 → 步长 0.005；整数币种 → 步长 0.5。
     * $76.01 → 0.007%；$0.12 → 4.17%；$1.98 → 0.25%。
     */
    function quantErrPct(price, code) {
        var p = num(price);
        if (!(p > 0)) return null;
        var step = decimalsOf(code) === 0 ? 0.5 : 0.005;
        return (step / p) * 100;
    }

    /**
     * 合成不确定度：保守取各样本的最大值（不假设误差独立同分布）。
     * 空样本 / 全非法 → null（unknown≠0）。
     */
    function synthUncertainty(errs) {
        var list = (Array.isArray(errs) ? errs : []).map(num)
            .filter(function (v) { return Number.isFinite(v) && v >= 0; });
        if (!list.length) return null;
        return Math.max.apply(null, list);
    }

    /**
     * Steam 价格取哪个口径：优先 median（抗错价挂单），退回 lowest。
     * pov = { lowest, median }
     */
    function pickSteamPrice(pov, code) {
        pov = pov || {};
        var med = num(pov.median);
        var low = num(pov.lowest);
        var price = med > 0 ? med : (low > 0 ? low : 0);
        if (!(price > 0)) return { price: 0, field: null, errPct: null };
        return { price: price, field: med > 0 ? 'median' : 'lowest', errPct: quantErrPct(price, code || 'USD') };
    }

    /**
     * BUFF 价格取哪个口径：优先 avg3Cny（前三档均价，抗单笔异常），退回 lowCny。
     * buff = { lowCny, avg3Cny }
     */
    function pickBuffPrice(buff) {
        buff = buff || {};
        var avg = num(buff.avg3Cny);
        var low = num(buff.lowCny);
        var price = avg > 0 ? avg : (low > 0 ? low : 0);
        if (!(price > 0)) return { price: 0, field: null, errPct: null };
        return { price: price, field: avg > 0 ? 'avg3' : 'low', errPct: quantErrPct(price, 'CNY') };
    }

    /**
     * 从候选里挑「高价锚」：美元价 ≥ minAnchorUsd，按价格降序。
     * items 形如 { name, lowest, median }（priceoverview 的两个口径）
     */
    function selectAnchorItems(items, opts) {
        opts = opts || {};
        var minUsd = opts.minAnchorUsd != null ? opts.minAnchorUsd : DEFAULTS.minAnchorUsd;
        var list = (Array.isArray(items) ? items : []).filter(function (it) {
            if (!it) return false;
            return pickSteamPrice(it, 'USD').price >= minUsd;
        });
        list.sort(function (a, b) {
            return pickSteamPrice(b, 'USD').price - pickSteamPrice(a, 'USD').price;
        });
        return list;
    }

    /**
     * 从两个币种的价格列表反推 Steam 实际应用的汇率。
     *
     * povUsd    = { lowest, median }   currency=1（美元）
     * povWallet = { lowest, median }   currency=<钱包币种>
     * anchor    = { name }
     *
     * 双重保险：
     *   ① lowest 与 median 两个独立读数必须自洽（差 ≤ anchorSelfTol），
     *      否则说明这个物品的报价本身有问题 → 换下一只锚。
     *   ② 美元价必须 ≥ minAnchorUsd，否则量化误差大到不能当汇率用。
     *
     * 失败返回 { ok:false, reason }，成功返回 { ok:true, rate, errPct, ... }。
     */
    function buildLiveRate(povUsd, povWallet, anchor, opts) {
        opts = opts || {};
        var selfTol = opts.anchorSelfTol != null ? opts.anchorSelfTol : DEFAULTS.anchorSelfTol;
        var minUsd = opts.minAnchorUsd != null ? opts.minAnchorUsd : DEFAULTS.minAnchorUsd;
        var walletCode = String((opts && opts.walletCode) || 'CNY').toUpperCase();
        var anchorName = (anchor && anchor.name) ? String(anchor.name) : '';
        function fail(reason) {
            return { ok: false, reason: reason, anchorName: anchorName, rate: null, errPct: null };
        }

        var ul = num(povUsd && povUsd.lowest);
        var um = num(povUsd && povUsd.median);
        var wl = num(povWallet && povWallet.lowest);
        var wm = num(povWallet && povWallet.median);
        if (!(ul > 0)) return fail('noUsdLowest');
        if (!(wl > 0)) return fail('noWalletLowest');
        if (Math.max(ul, um > 0 ? um : ul) < minUsd) return fail('priceTooLow');

        var rateLow = wl / ul;
        var rateMed = null;
        if (wm > 0 && um > 0) rateMed = wm / um;

        var selfDelta = null;
        var rate;
        if (rateMed !== null) {
            selfDelta = Math.abs(rateLow - rateMed) / Math.max(rateLow, rateMed);
            if (selfDelta > selfTol) return fail('selfInconsistent');
            rate = (rateLow + rateMed) / 2;
        } else {
            rate = rateLow;
        }

        var errPct = synthUncertainty([
            quantErrPct(ul, 'USD'),
            quantErrPct(um > 0 ? um : ul, 'USD'),
            quantErrPct(wl, walletCode),
            quantErrPct(wm > 0 ? wm : wl, walletCode),
        ]);

        return {
            ok: true,
            reason: '',
            rate: rate,
            rateLow: rateLow,
            rateMed: rateMed,
            selfDelta: selfDelta,
            errPct: errPct,
            anchorName: anchorName,
            priceUsd: ul,
            priceField: 'lowest+median',
            walletCode: walletCode,
        };
    }

    /** 相对分歧度 |a−b| / max(a,b)；任一端缺失 → null */
    function divergence(a, b) {
        var x = num(a);
        var y = num(b);
        if (!(x > 0) || !(y > 0)) return null;
        return Math.abs(x - y) / Math.max(x, y);
    }

    /**
     * 给一对锚点分歧定级并写人话。
     * opts = { warn, alert, label, hintOk, hintWarn, hintAlert }
     */
    function explainDivergence(a, b, opts) {
        opts = opts || {};
        var warn = opts.warn != null ? opts.warn : DEFAULTS.divWarn;
        var alert = opts.alert != null ? opts.alert : DEFAULTS.divAlert;
        var d = divergence(a, b);
        if (d === null) {
            return { level: 'unknown', div: null, text: (opts.label || '两个锚点') + '：缺一个可比口径', hint: '' };
        }
        var level = d >= alert ? 'alert' : (d >= warn ? 'warn' : 'ok');
        var pct = (d * 100).toFixed(2);
        var text = (opts.label || '两个锚点') + ' 相差 ' + pct + '%';
        var hint;
        if (level === 'ok') hint = opts.hintOk || '在正常范围内';
        else if (level === 'warn') hint = opts.hintWarn || '差异偏大，值得看一眼';
        else hint = opts.hintAlert || '差异异常，两个口径可能有一个失效';
        return { level: level, div: d, text: text, hint: hint };
    }

    /**
     * 判断一个价差是真信号还是在噪声里。
     * delta        —— 价差（与 reference 同量纲）
     * uncertaintyPct —— 不确定度（百分比）
     * reference    —— 参考量（价差相对于它衡量）
     * → 'real' | 'noise' | 'unknown'
     */
    function signalOf(delta, uncertaintyPct, reference) {
        var d = num(delta);
        var u = num(uncertaintyPct);
        var ref = num(reference);
        if (!Number.isFinite(d) || !Number.isFinite(u) || u < 0) return 'unknown';
        if (!Number.isFinite(ref) || !(ref > 0)) return 'unknown';
        var tol = (u / 100) * ref;
        if (!(tol > 0)) return 'real';          // 没有不确定度信息 → 有差就是有差
        return Math.abs(d) <= tol ? 'noise' : 'real';
    }

    var api = {
        DEFAULTS: DEFAULTS,
        decimalsOf: decimalsOf,
        parseMoney: parseMoney,
        quantErrPct: quantErrPct,
        synthUncertainty: synthUncertainty,
        pickSteamPrice: pickSteamPrice,
        pickBuffPrice: pickBuffPrice,
        selectAnchorItems: selectAnchorItems,
        buildLiveRate: buildLiveRate,
        divergence: divergence,
        explainDivergence: explainDivergence,
        signalOf: signalOf,
    };

    if (typeof module === 'object' && module.exports) module.exports = api;
    if (typeof window !== 'undefined') window.Fxq = api;
    if (typeof self !== 'undefined' && !self.Fxq) self.Fxq = api;
})();
    /* ===== INLINE-END: shared/fxq.lib.js ===== */
    // ==================== 常量配置 ====================
    const CACHE_TTL = {
        PRICE_HISTORY: 30 * 60 * 1000,    // 价格历史缓存30分钟
        ORDER_BOOK: 5 * 60 * 1000,         // 订单簿缓存5分钟
        INVENTORY: 30 * 60 * 1000,         // 库存缓存30分钟
    };
    const INVENTORY_COUNT = 2000;
    const INVENTORY_FALLBACK_COUNT = 1000;
    const REQUEST_DELAY = 600;
    const RETRY_MAX = 2;
    const RETRY_DELAY = 800;
    const APP_CONTEXT = { '753': '6' };
    const SKIP_CONTEXT_1 = { '570': true };
    const CHART_COLORS = {
        line: '#66c0f4',
        area: 'var(--sme-blue-a18)',
        grid: 'rgba(255,255,255,0.05)',
        text: '#8f98a0',
        sell: 'var(--sme-red)',
        buy: 'var(--sme-green)',
        dot: '#66c0f4',
    };

    // 2025年12月Steam市场规则变更：部分币种的手续费需要进位取整而非一律舍去。
    // v2.0.0：口径迁到纯计算层 SME_FEE_ROUND_DEFAULT（依据 Steamworks 官方
    // 「must be charged in increments of N」币种集合），并可在设置里覆写
    // （设置键 feeRoundCurrencies）—— 官方再调整时不必改代码。

    // 库存/挂单请求间隔
    const INV_REQUEST_DELAY = 1000;   // 市场 API 请求间隔
    const SELL_DELAY_MIN = 1000;      // 上架成功后最小等待
    const SELL_DELAY_MAX = 1500;      // 上架成功后最大等待
    const RETRY_BACKOFF_MIN = 30000;  // 重试消息退避最小
    const RETRY_BACKOFF_MAX = 45000;  // 重试消息退避最大

    // ==================== CSS 样式 ====================
    const CSS = `
:root{
    /* ================= v1.5.1 Design Tokens（P1-C UI token 化） ================= */
    /* 色彩 · 表面 */
    --sme-bg:rgba(23,26,33,0.98);
    --sme-bg-card:rgba(30,41,59,0.5);
    --sme-bg-hover:rgba(255,255,255,0.05);
    --sme-track:rgba(255,255,255,0.06);          /* 进度条/滑轨底色 */
    /* 色彩 · 文字 */
    --sme-text:#c7d5e0;
    --sme-text-dim:#8f98a0;
    --sme-text-muted:#5c6b7a;
    --sme-text-bright:#fff;
    /* 色彩 · 语义 */
    --sme-blue:#66c0f4;
    --sme-green:#4caf50;
    --sme-red:#e24a4a;
    --sme-amber:#f59e0b;
    --sme-purple:#8b5cf6;
    /* 语义色 · 柔和背景（按钮/徽章底色） */
    --sme-blue-soft:rgba(102,192,244,0.12);
    --sme-green-soft:rgba(76,175,80,0.15);
    --sme-red-soft:rgba(226,74,74,0.12);
    --sme-amber-soft:rgba(245,158,11,0.12);
    /* 蓝色透明度梯度：收敛全文件 20 余种内联 rgba(102,192,244,X) 写法 */
    --sme-blue-a0:rgba(102,192,244,0);
    --sme-blue-a04:rgba(102,192,244,0.04);
    --sme-blue-a05:rgba(102,192,244,0.05);
    --sme-blue-a06:rgba(102,192,244,0.06);
    --sme-blue-a08:rgba(102,192,244,0.08);
    --sme-blue-a10:rgba(102,192,244,0.10);
    --sme-blue-a12:rgba(102,192,244,0.12);
    --sme-blue-a15:rgba(102,192,244,0.15);
    --sme-blue-a18:rgba(102,192,244,0.18);
    --sme-blue-a20:rgba(102,192,244,0.20);
    --sme-blue-a25:rgba(102,192,244,0.25);
    --sme-blue-a30:rgba(102,192,244,0.30);
    --sme-blue-a35:rgba(102,192,244,0.35);
    --sme-blue-a40:rgba(102,192,244,0.40);
    --sme-blue-a50:rgba(102,192,244,0.50);
    --sme-blue-a55:rgba(102,192,244,0.55);
    --sme-blue-a70:rgba(102,192,244,0.70);
    --sme-blue-a80:rgba(102,192,244,0.80);
    --sme-blue-a95:rgba(102,192,244,0.95);
    --sme-purple-a6:rgba(139,92,246,0.06);
    --sme-purple-a20:rgba(139,92,246,0.2);
    --sme-red-a6:rgba(226,74,74,0.06);
    --sme-red-a8:rgba(226,74,74,0.08);
    --sme-red-a10:rgba(226,74,74,0.1);
    --sme-red-a12:rgba(226,74,74,0.12);
    --sme-red-a15:rgba(226,74,74,0.15);
    --sme-red-a18:rgba(226,74,74,0.18);
    --sme-red-a20:rgba(226,74,74,0.2);
    --sme-red-a25:rgba(226,74,74,0.25);
    --sme-red-a30:rgba(226,74,74,0.3);
    --sme-red-a45:rgba(226,74,74,0.45);
    --sme-red-a60:rgba(226,74,74,0.6);
    --sme-red-a95:rgba(226,74,74,0.95);
    --sme-amber-a8:rgba(245,158,11,0.08);
    --sme-amber-a10:rgba(245,158,11,0.1);
    --sme-amber-a12:rgba(245,158,11,0.12);
    --sme-amber-a15:rgba(245,158,11,0.15);
    --sme-amber-a18:rgba(245,158,11,0.18);
    --sme-amber-a20:rgba(245,158,11,0.2);
    --sme-amber-a22:rgba(245,158,11,0.22);
    --sme-amber-a30:rgba(245,158,11,0.3);
    --sme-amber-a40:rgba(245,158,11,0.4);
    --sme-amber-a50:rgba(245,158,11,0.5);
    --sme-amber-a65:rgba(245,158,11,0.65);
    --sme-amber-a95:rgba(245,158,11,0.95);
    --sme-green-a10:rgba(76,175,80,0.1);
    --sme-green-a12:rgba(76,175,80,0.12);
    --sme-green-a15:rgba(76,175,80,0.15);
    --sme-green-a20:rgba(76,175,80,0.2);
    --sme-green-a22:rgba(76,175,80,0.22);
    --sme-green-a25:rgba(76,175,80,0.25);
    --sme-green-a28:rgba(76,175,80,0.28);
    --sme-green-a30:rgba(76,175,80,0.3);
    --sme-green-a40:rgba(76,175,80,0.4);
    --sme-green-a50:rgba(76,175,80,0.5);
    --sme-green-a60:rgba(76,175,80,0.6);
    --sme-green-a95:rgba(76,175,80,0.95);
    --sme-danger-grad:linear-gradient(180deg,#c44 0%,#a33 100%);
    --sme-danger-border:#a33;
    --sme-danger:#f87171;
    /* 边框 */
    --sme-border:var(--sme-blue-a15);
    --sme-border-hi:var(--sme-blue-a35);
    /* 圆角：11 种收敛为 3 档 + 胶囊 */
    --sme-radius-xs:4px;
    --sme-radius-sm:8px;
    --sme-radius:12px;
    --sme-radius-pill:999px;
    /* 间距：17 种收敛为 5 档（新代码使用，存量渐进迁移） */
    --sme-space-1:4px;
    --sme-space-2:8px;
    --sme-space-3:12px;
    --sme-space-4:16px;
    --sme-space-5:24px;
    /* 层级：3 套 z-index 收敛 */
    --sme-z-panel:500;      /* 面板/浮层 */
    --sme-z-overlay:9000;   /* 模态遮罩/对话框 */
    --sme-z-top:99999;      /* Toast 顶层通知 */
    --sme-transition:all 0.2s cubic-bezier(0.4,0,0.2,1);
}
/* ==== v1.5.1 规范按钮体系 .sme-btn（P1-C）====
   存量 22 个按钮类保持兼容运行，新代码一律使用本体系；存量类按模块逐步迁移：
   .sme-btn            默认（蓝色主操作）
   .sme-btn--sm        小尺寸（行内/表格按钮）
   .sme-btn--ghost     幽灵按钮（次要操作）
   .sme-btn--danger    危险操作（下架/删除）
   .sme-btn--success   确认操作（应用/出售）
   .sme-btn--warning   警示操作 */
.sme-btn{display:inline-flex;align-items:center;justify-content:center;gap:6px;padding:6px 14px;border:1px solid var(--sme-border-hi);border-radius:var(--sme-radius-sm);background:var(--sme-blue-soft);color:var(--sme-blue);font-size:12px;font-weight:600;line-height:1.4;font-family:inherit;cursor:pointer;user-select:none;transition:var(--sme-transition)}
.sme-btn:hover{background:var(--sme-blue-a25);border-color:var(--sme-border-hi)}
.sme-btn:active{transform:scale(0.97)}
.sme-btn:disabled{opacity:.4;cursor:not-allowed;transform:none}
.sme-btn--sm{padding:2px 8px;font-size:11px;border-radius:var(--sme-radius-xs)}
.sme-btn--ghost{background:transparent;color:var(--sme-text-dim);border-color:var(--sme-border)}
.sme-btn--ghost:hover{background:var(--sme-bg-hover);color:var(--sme-text)}
.sme-btn--danger{background:var(--sme-red-soft);border-color:var(--sme-red-a25);color:var(--sme-red)}
.sme-btn--danger:hover{background:var(--sme-red-a20)}
.sme-btn--success{background:var(--sme-green-soft);border-color:var(--sme-green-a40);color:var(--sme-green)}
.sme-btn--success:hover{background:var(--sme-green-a28)}
.sme-btn--warning{background:var(--sme-amber-soft);border-color:var(--sme-amber-a30);color:var(--sme-amber)}
.sme-btn--warning:hover{background:var(--sme-amber-a22)}
.sme-btn .sme-svg{width:13px;height:13px}
.sme-svg{width:16px;height:16px;display:inline-block;vertical-align:middle;stroke-width:2.2;flex-shrink:0}
.sme-panel{
    background:linear-gradient(180deg,rgba(29,31,35,0.98) 0%,rgba(35,38,46,0.98) 100%);
    border:1px solid var(--sme-border);border-radius:var(--sme-radius);
    margin:12px 0;overflow:hidden;font-family:"Motiva Sans",system-ui,-apple-system,sans-serif;
    color:var(--sme-text);box-shadow:0 8px 32px rgba(0,0,0,0.3);
}
.sme-header{
    display:flex;align-items:center;gap:10px;padding:12px 16px;flex-wrap:wrap;
    background:linear-gradient(135deg,var(--sme-blue-a08) 0%,rgba(23,26,33,0.6) 100%);
    border-bottom:1px solid var(--sme-border);
}
.sme-header-title{display:flex;align-items:center;gap:8px;font-size:15px;font-weight:700;color:var(--sme-text-bright);white-space:nowrap}
.sme-header-title .sme-svg{width:20px;height:20px;color:var(--sme-blue)}
.sme-tabs{display:flex;gap:2px;margin-left:auto;flex-wrap:wrap}
.sme-tab{
    padding:6px 14px;border:none;background:transparent;color:var(--sme-text-dim);
    font-size:13px;font-weight:600;cursor:pointer;border-radius:var(--sme-radius-sm);transition:var(--sme-transition);
    display:inline-flex;align-items:center;gap:5px;white-space:nowrap;
}
.sme-tab .sme-svg{width:14px;height:14px}
.sme-tab:hover{color:var(--sme-text);background:rgba(255,255,255,0.04)}
.sme-tab.active{background:var(--sme-blue-a15);color:var(--sme-blue)}
.sme-tab-btn{
    width:28px;height:28px;border:none;border-radius:var(--sme-radius-sm);background:rgba(255,255,255,0.06);
    color:var(--sme-text-dim);cursor:pointer;display:flex;align-items:center;justify-content:center;
    transition:var(--sme-transition);flex-shrink:0;
}
.sme-tab-btn:hover{background:rgba(255,255,255,0.12);color:var(--sme-text-bright)}
.sme-tab-btn .sme-svg{width:14px;height:14px}
.sme-content{padding:16px;min-height:120px}
.sme-tab-pane{display:none}
.sme-tab-pane.active{display:block;animation:sme-fade-in 0.2s ease}
@keyframes sme-fade-in{from{opacity:0;transform:translateY(4px)}to{opacity:1;transform:translateY(0)}}

/* 统计卡片 */
.sme-stats-grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(110px,1fr));gap:10px;margin-bottom:16px}
.sme-stat-card{
    background:var(--sme-bg-card);border:1px solid var(--sme-border);border-radius:var(--sme-radius-sm);
    padding:10px 12px;display:flex;flex-direction:column;gap:4px;transition:var(--sme-transition);
}
.sme-stat-card:hover{border-color:var(--sme-border-hi);background:rgba(30,41,59,0.7)}
.sme-stat-val{font-size:18px;font-weight:800;color:var(--sme-text-bright);line-height:1.2;font-variant-numeric:tabular-nums;display:flex;align-items:baseline;gap:6px;white-space:nowrap;flex-wrap:wrap}
.sme-stat-val-main{flex-shrink:0}
.sme-stat-ref{font-size:12px;font-weight:600;color:var(--sme-text-dim);opacity:.75;flex-shrink:0}
.sme-stat-lbl{font-size:11px;color:var(--sme-text-dim);font-weight:600}

/* 汇总表格 */
.sme-table{width:100%;border-collapse:collapse}
.sme-table th{
    color:var(--sme-text-dim);text-align:left;padding:6px 8px;font-size:12px;
    border-bottom:1px solid var(--sme-border);font-weight:600;
}
.sme-table td{
    color:var(--sme-text);padding:7px 8px;font-size:13px;
    border-bottom:1px solid var(--sme-blue-a06);
}
.sme-table tr:last-child td{border-bottom:none}
.sme-table tr:hover td{background:var(--sme-blue-a04)}
.sme-date-cell{white-space:nowrap;color:var(--sme-blue);font-weight:600;width:110px}
.sme-prices-cell{color:var(--sme-text-dim);line-height:1.8}
.sme-price-tag{
    display:inline-block;background:var(--sme-blue-a08);border:1px solid var(--sme-blue-a15);
    border-radius:var(--sme-radius-xs);padding:1px 7px;margin:2px 3px 2px 0;font-size:12px;color:var(--sme-text);
}
.sme-price-tag .sme-ct{color:var(--sme-text-dim);margin-left:3px}
.sme-count-cell{text-align:right;white-space:nowrap;color:var(--sme-text-dim);width:60px;font-variant-numeric:tabular-nums}
.sme-total-row td{border-top:1px solid var(--sme-border);font-weight:700;color:var(--sme-blue);padding-top:10px}

/* 下架区域 */
.sme-delist-section{margin-top:16px;padding-top:14px;border-top:1px solid var(--sme-border)}
.sme-delist-row{display:flex;align-items:center;gap:10px;flex-wrap:wrap}
.sme-delist-label{color:var(--sme-text-dim);font-size:13px;white-space:nowrap}
.sme-delist-select,.sme-delist-input{
    background:rgba(30,41,59,0.6);border:1px solid var(--sme-border);color:var(--sme-text);
    padding:5px 8px;border-radius:var(--sme-radius-sm);font-size:13px;transition:var(--sme-transition);
}
.sme-delist-select:focus,.sme-delist-input:focus{outline:none;border-color:var(--sme-border-hi)}
.sme-delist-select{min-width:140px}
.sme-delist-input{width:70px;text-align:center}
.sme-delist-btn,.sme-dialog-ok{
    background:var(--sme-danger-grad);border:1px solid transparent;color:#fff;
    padding:6px 16px;border-radius:var(--sme-radius-sm);cursor:pointer;font-size:13px;font-weight:600;
    transition:var(--sme-transition);
}
.sme-dialog-ok{border-color:var(--sme-danger-border)}
.sme-delist-btn:hover,.sme-dialog-ok:hover{opacity:0.85}
.sme-delist-btn:disabled{opacity:0.4;cursor:not-allowed}
.sme-delist-all-btn:hover{border-color:var(--sme-danger-a50)}
.sme-delist-status{color:var(--sme-text-dim);font-size:12px;margin-top:8px}
.sme-delist-status.sme-error{color:var(--sme-red)}
.sme-delist-status.sme-ok{color:var(--sme-green)}
/* v1.5.1 统一进度条：4 套填充实现（主面板/库存/挂单/补充包）收敛为单一基类，轨道各自保留高度 */
.sme-progress-bar,.sme-inv-progress-bar,.sme-ml-progress-bar,.sme-booster-progress-bar{height:100%;width:0;background:linear-gradient(90deg,var(--sme-blue),var(--sme-green));border-radius:var(--sme-radius-xs);transition:width .3s ease}
.sme-progress-wrap{height:3px;background:var(--sme-track);border-radius:var(--sme-radius-xs);margin-top:8px;overflow:hidden}

/* 价格图表 */
.sme-chart-wrap{background:var(--sme-bg-card);border:1px solid var(--sme-border);border-radius:var(--sme-radius-sm);padding:12px}
.sme-chart-svg{width:100%;height:auto;display:block}
.sme-range-bar{display:flex;gap:4px;margin-bottom:12px}
.sme-range-btn{
    padding:4px 12px;border:1px solid var(--sme-border);background:transparent;color:var(--sme-text-dim);
    border-radius:var(--sme-radius-sm);cursor:pointer;font-size:12px;font-weight:600;transition:var(--sme-transition);
}
.sme-range-btn:hover{color:var(--sme-text);border-color:var(--sme-border-hi)}
.sme-range-btn.active{background:var(--sme-blue-a15);color:var(--sme-blue);border-color:var(--sme-blue-a30)}

/* 订单簿：左卖单、右买单。数量色条铺在行底，不占单独一列。 */
.sme-ob-board{
    display:grid;grid-template-columns:minmax(0,1fr) minmax(0,1fr);gap:14px 16px;align-items:start;
}
.sme-order-section{min-width:0;margin-bottom:0;overflow-x:auto}
.sme-order-title{font-size:13px;font-weight:700;margin-bottom:6px;display:flex;align-items:center;gap:6px}
.sme-order-title .sme-svg{width:15px;height:15px}
.sme-order-title.sell{color:var(--sme-red)}
.sme-order-title.buy{color:var(--sme-green)}
.sme-order-head,.sme-order-row{
    position:relative;display:flex;align-items:center;gap:6px;
    padding:1px 6px;font-variant-numeric:tabular-nums;min-width:0;
}
.sme-order-head{
    margin-bottom:2px;padding-bottom:4px;font-size:11px;font-weight:600;color:var(--sme-text-dim);
    border-bottom:1px solid var(--sme-blue-a12);
}
.sme-order-row{min-height:22px;font-size:12px}
/* v1.6.9：订单簿行降级渲染。行高被 min-height:22px 钉死，
   contain-intrinsic-size 的 auto 前缀让浏览器自行记忆真实高度，
   估算几乎无误差、滚动条不跳变。作用域限定 .sme-order-section，
   绝不触碰 .sme-mh-table（表格元素不适用 content-visibility，
   且其 th 用 position:sticky + 不透明背景，强行施加会破坏吸顶）。 */
.sme-order-section .sme-order-row{content-visibility:auto;contain-intrinsic-size:auto var(--sme-order-h,22px)}
.sme-order-bar{
    position:absolute;z-index:0;top:1px;bottom:1px;left:0;border-radius:3px;
    pointer-events:none;opacity:0.22;
}
.sme-order-row.sell .sme-order-bar{background:var(--sme-red)}
.sme-order-row.buy .sme-order-bar{background:var(--sme-green)}
.sme-order-head > span,.sme-order-row > span{position:relative;z-index:1}
.sme-order-price{font-weight:650;white-space:nowrap}
.sme-order-row.sell .sme-order-price{color:var(--sme-red)}
.sme-order-row.buy .sme-order-price{color:var(--sme-green)}
.sme-order-net{color:var(--sme-text);white-space:nowrap;font-size:11px}
.sme-order-cny{color:var(--sme-amber);white-space:nowrap;font-size:11px}
.sme-order-qty{margin-left:auto;color:var(--sme-text);font-weight:600;white-space:nowrap}
.sme-order-head .sme-order-qty,.sme-order-head .sme-order-cum{color:var(--sme-text-dim);font-weight:600}
.sme-order-cum{width:3.6em;text-align:right;color:var(--sme-text-dim);font-size:11px;white-space:nowrap;flex:0 0 auto}
.sme-ob-empty{padding:12px 6px;color:var(--sme-text-dim);font-size:12px}
@media (max-width:760px){
    .sme-ob-board{grid-template-columns:minmax(0,1fr)}
}
.sme-ob-controls{
    display:flex;align-items:center;gap:14px;flex-wrap:wrap;padding:8px 12px;margin-bottom:12px;
    background:var(--sme-blue-a05);border:1px solid var(--sme-border);border-radius:var(--sme-radius-sm);
    font-size:12px;color:var(--sme-text-dim);
}
.sme-ob-ctl{display:flex;align-items:center;gap:6px;cursor:pointer;user-select:none;white-space:nowrap}
.sme-ob-ctl:hover{color:var(--sme-text)}
.sme-ob-ctl input[type=checkbox]{accent-color:var(--sme-blue);cursor:pointer;margin:0}
.sme-ob-slider{width:130px;accent-color:var(--sme-blue);cursor:pointer;padding:0}
.sme-ob-levels-val{min-width:56px;color:var(--sme-text);font-weight:600;font-variant-numeric:tabular-nums}
.sme-ob-refresh{
    margin-left:auto;display:inline-flex;align-items:center;gap:4px;padding:3px 10px;
    border:1px solid var(--sme-border);background:transparent;color:var(--sme-text-dim);
    border-radius:var(--sme-radius-sm);cursor:pointer;font-size:12px;font-weight:600;transition:var(--sme-transition);
}
.sme-ob-refresh:hover{color:var(--sme-blue);border-color:var(--sme-border-hi)}
.sme-ob-refresh:disabled{opacity:0.5;cursor:default}
.sme-ob-total{font-size:12px;color:var(--sme-text-dim);padding:6px 2px 0;font-variant-numeric:tabular-nums}
.sme-ob-total b{color:var(--sme-text)}
.sme-spread-box{
    display:flex;align-items:center;justify-content:center;gap:12px;padding:10px;margin:8px 0;
    background:var(--sme-blue-a06);border:1px solid var(--sme-border);border-radius:var(--sme-radius-sm);
}
.sme-spread-val{font-size:18px;font-weight:800;color:var(--sme-blue);font-variant-numeric:tabular-nums}
.sme-spread-lbl{font-size:12px;color:var(--sme-text-dim)}

/* 设置 */
.sme-setting-row{
    display:flex;align-items:center;justify-content:space-between;padding:10px 0;
    border-bottom:1px solid var(--sme-blue-a06);
}
.sme-setting-row:last-child{border-bottom:none}
.sme-setting-info{display:flex;flex-direction:column;gap:3px}
.sme-setting-name{font-size:13px;font-weight:600;color:var(--sme-text)}
.sme-setting-desc{font-size:11px;color:var(--sme-text-dim)}
.sme-toggle{position:relative;width:40px;height:22px;flex-shrink:0;cursor:pointer}
.sme-toggle input{opacity:0;width:0;height:0}
.sme-toggle-slider{
    position:absolute;inset:0;background:rgba(255,255,255,0.1);border-radius:var(--sme-radius);transition:var(--sme-transition);
}
.sme-toggle-slider::before{
    content:'';position:absolute;width:16px;height:16px;left:3px;top:3px;background:#fff;border-radius:50%;transition:var(--sme-transition);
}
.sme-toggle input:checked + .sme-toggle-slider{background:var(--sme-blue)}
.sme-toggle input:checked + .sme-toggle-slider::before{transform:translateX(18px)}
.sme-setting-select{
    background:rgba(30,41,59,0.6);border:1px solid var(--sme-border);color:var(--sme-text);
    padding:5px 8px;border-radius:var(--sme-radius-sm);font-size:13px;
}
/* v1.5.1 按钮去重：玫瑰红次要危险按钮（批量下架全部 / 危险操作）共享一条规则 */
.sme-delist-all-btn,.sme-danger-btn{
    background:var(--sme-danger-soft);border:1px solid var(--sme-danger-a30);color:var(--sme-danger);
    padding:6px 14px;border-radius:var(--sme-radius-sm);cursor:pointer;font-size:13px;font-weight:600;transition:var(--sme-transition);
}
.sme-danger-btn{padding:7px 16px}
.sme-danger-btn:hover,.sme-delist-all-btn:hover{background:var(--sme-danger-a20)}
.sme-info-box{margin-top:16px;padding:12px;background:var(--sme-blue-a05);border:1px solid var(--sme-border);border-radius:var(--sme-radius-sm);font-size:12px;color:var(--sme-text-dim);line-height:1.6}

/* Toast —— v1.5.0：改为堆栈式（最多 3 条并存），修复批量操作时后一条顶掉前一条的问题 */
.sme-toast{
    position:fixed;bottom:50px;left:50%;transform:translateX(-50%) translateY(20px);
    background:rgba(15,23,42,0.95);color:#fff;border:1px solid var(--sme-blue);
    padding:10px 24px;border-radius:var(--sme-radius-pill);font-size:13px;font-weight:500;
    box-shadow:0 4px 16px rgba(0,0,0,0.3);z-index:var(--sme-z-top);opacity:0;pointer-events:none;
    transition:opacity 0.3s,transform 0.3s;
    max-width:min(520px,calc(100vw - 32px));text-align:center;
}
.sme-toast.sme-show{opacity:1;transform:translateX(-50%) translateY(0)}
.sme-toast.sme-info{border-color:var(--sme-blue)}
.sme-toast.sme-success{border-color:var(--sme-green)}
.sme-toast.sme-error{border-color:var(--sme-red)}
.sme-toast.sme-warning{border-color:var(--sme-amber)}
/* 多条并存时向上堆叠，避免重叠 */
.sme-toast[data-stack="1"]{bottom:104px}
.sme-toast[data-stack="2"]{bottom:158px}

/* 价格状态标注 */
.sme-price-tag.overpriced{background:var(--sme-red-a12);border-color:var(--sme-red-a30);color:var(--sme-red)}
.sme-price-tag.underpriced{background:var(--sme-amber-a12);border-color:var(--sme-amber-a30);color:var(--sme-amber)}
.sme-price-tag.fair{background:var(--sme-green-a12);border-color:var(--sme-green-a30);color:var(--sme-green)}
.sme-price-tag.unchecked{background:var(--sme-blue-a08);border-color:var(--sme-blue-a15)}
.sme-price-tag .sme-suggested{color:var(--sme-text-dim);font-size:10px;margin-left:4px;opacity:0.8}
.sme-price-tag .sme-status-dot{display:inline-block;width:6px;height:6px;border-radius:50%;margin-right:4px;vertical-align:middle}
.sme-price-tag.overpriced .sme-status-dot{background:var(--sme-red)}
.sme-price-tag.underpriced .sme-status-dot{background:var(--sme-amber)}
.sme-price-tag.fair .sme-status-dot{background:var(--sme-green)}

/* 价格检测统计卡片 */
.sme-stat-card.overpriced{border-left:3px solid var(--sme-red)}
.sme-stat-card.underpriced{border-left:3px solid var(--sme-amber)}
.sme-stat-card.fair{border-left:3px solid var(--sme-green)}
.sme-price-check-info{display:flex;align-items:center;gap:8px;margin-bottom:12px;padding:8px 12px;background:var(--sme-blue-a06);border:1px solid var(--sme-border);border-radius:var(--sme-radius-sm);font-size:12px;color:var(--sme-text-dim)}
.sme-price-check-info .sme-svg{width:14px;height:14px;color:var(--sme-blue)}
.sme-price-check-info .sme-algo-name{color:var(--sme-blue);font-weight:600}

/* v1.4.9：参考货币换算价格 */
.sme-ref-price{display:inline-block;margin-left:6px;font-size:12px;color:var(--sme-text-dim);font-weight:500;white-space:nowrap}
.sme-ref-price::before{content:'≈';margin-right:3px;opacity:0.7}
.sme-ref-price.loading{opacity:0.5}
.sme-ref-price.error{display:none}
.sme-ref-net{opacity:.7;margin-left:2px}
/* 新版 React 页面适配：使用页面 CSS 变量 */
[style*="--color-text-body-title"] ~ .sme-ref-price,
[class*="IokSIloSPlA"] + .sme-ref-price{
    color: var(--color-text-body-subtitle, #8f98a0);
    font-size: 13px;
}

/* 重新上架区域 */
.sme-relist-section{margin-top:12px;padding:12px;background:var(--sme-purple-a6);border:1px solid var(--sme-purple-a20);border-radius:var(--sme-radius-sm)}
.sme-relist-row{display:flex;align-items:center;gap:10px;flex-wrap:wrap}
.sme-relist-btn{
    background:linear-gradient(180deg,#7c3aed 0%,#6d28d9 100%);border:none;color:#fff;
    padding:6px 16px;border-radius:var(--sme-radius-sm);cursor:pointer;font-size:13px;font-weight:600;
    transition:opacity 0.15s;display:inline-flex;align-items:center;gap:5px;
}
.sme-relist-btn:hover{opacity:0.85}
.sme-relist-btn:disabled{opacity:0.4;cursor:not-allowed}
.sme-relist-btn .sme-svg{width:14px;height:14px}
.sme-relist-summary{font-size:12px;color:var(--sme-text-dim);margin-top:8px}
.sme-relist-item{display:flex;align-items:center;gap:8px;padding:4px 0;font-size:12px}
.sme-relist-item .sme-relist-from{color:var(--sme-red);text-decoration:line-through;opacity:0.7}
.sme-relist-item .sme-relist-arrow{color:var(--sme-text-dim)}
.sme-relist-item .sme-relist-to{color:var(--sme-green);font-weight:600}

/* 自定义对话框（确认 / 价格输入） */
.sme-dialog-overlay{
    position:fixed;top:0;left:0;right:0;bottom:0;z-index:var(--sme-z-top);
    background:rgba(0,0,0,0.6);display:flex;align-items:center;justify-content:center;
    animation:sme-fade-in 0.15s ease;
}
.sme-dialog-box{
    background:linear-gradient(180deg,rgba(27,40,56,0.98) 0%,rgba(35,38,46,0.98) 100%);
    border:1px solid var(--sme-border-hi);border-radius:var(--sme-radius);
    padding:24px 28px;max-width:420px;width:90%;
    box-shadow:0 8px 32px rgba(0,0,0,0.5);font-family:"Motiva Sans",system-ui,sans-serif;
}
.sme-dialog-title{color:var(--sme-blue);font-size:15px;font-weight:700;margin-bottom:12px}
.sme-dialog-body{color:var(--sme-text);font-size:13px;line-height:1.6;margin-bottom:20px}
.sme-dialog-body strong{color:var(--sme-text-bright)}
.sme-dialog-actions{display:flex;gap:10px;justify-content:flex-end}
.sme-dialog-btn{
    padding:7px 20px;border-radius:var(--sme-radius-sm);font-size:13px;font-weight:600;cursor:pointer;
    border:1px solid var(--sme-border);transition:var(--sme-transition);
}
.sme-dialog-cancel{background:rgba(255,255,255,0.06);color:var(--sme-text)}
.sme-dialog-cancel:hover{background:rgba(255,255,255,0.12)}

.sme-dialog-blue{background:linear-gradient(180deg,var(--sme-blue) 0%,#417a9b 100%);color:#fff;border-color:#417a9b}
.sme-dialog-blue:hover{opacity:0.85}
.sme-dialog-header{display:flex;align-items:center;justify-content:space-between;margin-bottom:12px}
.sme-dialog-header .sme-dialog-title{margin-bottom:0}
.sme-dialog-close{background:none;border:none;color:var(--sme-text-dim);font-size:20px;cursor:pointer;padding:0 4px;line-height:1}
.sme-dialog-close:hover{color:var(--sme-text)}
.sme-dialog-footer{display:flex;gap:10px;justify-content:flex-end;margin-top:16px}
.sme-dialog-footer button{padding:7px 20px;border-radius:var(--sme-radius-sm);font-size:13px;font-weight:600;cursor:pointer;border:1px solid var(--sme-border);transition:var(--sme-transition)}
.sme-price-input{
    background:rgba(30,41,59,0.6);border:1px solid var(--sme-border);color:var(--sme-text);
    padding:7px 12px;border-radius:var(--sme-radius-sm);font-size:14px;width:100%;box-sizing:border-box;
    text-align:center;transition:var(--sme-transition);
}
.sme-price-input:focus{outline:none;border-color:var(--sme-border-hi)}
.sme-price-grid{display:grid;grid-template-columns:1fr 1fr;column-gap:14px;row-gap:6px;margin-bottom:10px}
.sme-price-label{color:var(--sme-text-dim);font-size:12px;white-space:nowrap}

/* 设置：定价算法 */
.sme-setting-group-title{font-size:13px;font-weight:700;color:var(--sme-blue);margin:16px 0 8px;padding-bottom:6px;border-bottom:1px solid var(--sme-border)}
.sme-setting-group-title:first-child{margin-top:0}
.sme-number-input{
    background:rgba(30,41,59,0.6);border:1px solid var(--sme-border);color:var(--sme-text);
    padding:5px 8px;border-radius:var(--sme-radius-sm);font-size:13px;width:80px;transition:var(--sme-transition);
}
.sme-number-input:focus{outline:none;border-color:var(--sme-border-hi)}
.sme-setting-inline{display:flex;align-items:center;gap:8px}
.sme-setting-inline .sme-setting-info{flex:1}

/* 加载 & 空状态 */
.sme-loading{display:flex;flex-direction:column;align-items:center;justify-content:center;gap:12px;padding:40px 20px}
.sme-spinner{
    width:28px;height:28px;border:2.5px solid var(--sme-blue-a15);
    border-top-color:var(--sme-blue);border-radius:50%;animation:sme-spin 0.8s linear infinite;
}
@keyframes sme-spin{to{transform:rotate(360deg)}}
.sme-loading-text{color:var(--sme-text-dim);font-size:13px}
.sme-empty{display:flex;flex-direction:column;align-items:center;justify-content:center;gap:10px;padding:40px 20px;color:var(--sme-text-dim);font-size:13px;text-align:center}
.sme-empty .sme-svg{width:32px;height:32px;opacity:0.4}
.sme-error-box{display:flex;flex-direction:column;align-items:center;gap:10px;padding:30px 20px;color:var(--sme-red);font-size:13px;text-align:center}

/* 已拥有标识 */
.sme-owned-badge{
    display:inline-flex;align-items:center;background:var(--sme-blue-a12);border:1px solid var(--sme-blue-a20);
    color:var(--sme-blue);font-size:11px;font-weight:700;padding:1px 6px;border-radius:var(--sme-radius-xs);margin-right:5px;
    white-space:nowrap;vertical-align:middle;
}

/* 浮动按钮（浏览页设置） */
/* v2.2.5：右下角最底部 16px 让给「常驻汇率徽标」，按钮抬高到它上方，避免被徽标压住 */
.sme-fab{
    position:fixed;bottom:64px;right:16px;width:40px;height:40px;border:none;border-radius:50%;
    background:linear-gradient(135deg,#3b82f6 0%,#1d4ed8 100%);color:#fff;cursor:pointer;z-index:var(--sme-z-panel);
    display:flex;align-items:center;justify-content:center;box-shadow:0 4px 20px rgba(59,130,246,0.4);
    transition:var(--sme-transition);
}
.sme-fab:hover{transform:scale(1.1);box-shadow:0 8px 30px rgba(59,130,246,0.6)}
.sme-fab .sme-svg{width:20px;height:20px}
.sme-fab-popup{
    position:fixed;bottom:114px;right:16px;width:300px;background:var(--sme-bg);border:1px solid var(--sme-border);
    border-radius:var(--sme-radius);padding:16px;z-index:var(--sme-z-panel);box-shadow:0 8px 32px rgba(0,0,0,0.4);
    display:none;font-family:"Motiva Sans",system-ui,sans-serif;color:var(--sme-text);
}
.sme-fab-popup.sme-show{display:block;animation:sme-fade-in 0.2s ease}
.sme-fab-popup h4{margin:0 0 12px;font-size:14px;color:var(--sme-text-bright);display:flex;align-items:center;gap:6px}
/* 详情页：底部交易分析按钮 + 浮窗（Steam 客户端内嵌页裁掉顶部面板时使用） */
.sme-analysis-fab{
    z-index:var(--sme-z-overlay);
    background:linear-gradient(135deg,#22d3ee 0%,#2563eb 100%);
    box-shadow:0 4px 20px rgba(37,99,235,0.45);
}
.sme-analysis-fab:hover{box-shadow:0 8px 30px rgba(37,99,235,0.65)}
.sme-analysis-fab.sme-on{outline:2px solid rgba(255,255,255,.4);outline-offset:2px}
.sme-analysis-pop{
    position:fixed;right:24px;bottom:76px;z-index:var(--sme-z-overlay);
    width:min(980px,calc(100vw - 32px));max-height:min(82vh,880px);
    display:none;flex-direction:column;
}
.sme-analysis-pop.sme-show{display:flex;animation:sme-fade-in 0.2s ease}
.sme-analysis-pop .sme-panel{
    margin:0;width:100%;max-height:min(82vh,880px);
    display:flex;flex-direction:column;
}
.sme-analysis-pop .sme-header{flex:0 0 auto}
.sme-analysis-pop .sme-content{
    flex:1 1 auto;min-height:0;overflow:auto;overscroll-behavior:contain;
}
.sme-analysis-close{margin-left:4px;flex-shrink:0}

/* ===== 库存页价格标签 ===== */
.sme-inv-price{
    display:block;font-size:10px;font-weight:600;color:#beee11;text-align:center;
    padding:1px 3px;line-height:1.3;text-shadow:0 1px 2px rgba(0,0,0,0.8);
    pointer-events:none;white-space:nowrap;
}
.sme-inv-price.sme-na{color:var(--sme-blue)}
.sme-inv-price.sme-inf{color:var(--sme-text-dim)}

/* ===== 库存页工具栏 ===== */
.sme-inv-toolbar{
    display:flex;align-items:center;gap:8px;flex-wrap:wrap;padding:8px 12px;margin:4px 0;
    background:linear-gradient(135deg,var(--sme-blue-a06) 0%,rgba(23,26,33,0.6) 100%);
    border:1px solid var(--sme-border);border-radius:var(--sme-radius-sm);
    font-family:"Motiva Sans",system-ui,sans-serif;
}
.sme-inv-toolbar-title{display:flex;align-items:center;gap:6px;font-size:13px;font-weight:700;color:var(--sme-text-bright);margin-right:8px}
.sme-inv-btn{
    display:inline-flex;align-items:center;gap:5px;padding:5px 12px;border:1px solid var(--sme-blue-a25);
    background:var(--sme-blue-a08);color:var(--sme-text);font-size:12px;font-weight:600;
    border-radius:var(--sme-radius-sm);cursor:pointer;transition:var(--sme-transition);white-space:nowrap;font-family:inherit;
}
.sme-inv-btn:hover{background:var(--sme-blue-a18);border-color:var(--sme-border-hi);color:var(--sme-text-bright)}
.sme-inv-btn:disabled{opacity:0.4;cursor:not-allowed}
.sme-inv-btn.sme-danger{background:var(--sme-red-a10);border-color:var(--sme-red-a30);color:var(--sme-red)}
.sme-inv-btn.sme-danger:hover{background:var(--sme-red-a20)}
.sme-inv-btn .sme-svg{width:13px;height:13px}
.sme-inv-progress{
    flex:1;min-width:120px;height:6px;background:var(--sme-track);border-radius:var(--sme-radius-xs);overflow:hidden;
}
.sme-inv-status{font-size:12px;color:var(--sme-text-dim);white-space:nowrap}

/* ===== 快速出售面板 ===== */
.sme-quick-sell{
    margin-top:8px;padding:10px;background:var(--sme-bg-card);border:1px solid var(--sme-border);
    border-radius:var(--sme-radius-sm);font-family:"Motiva Sans",system-ui,sans-serif;
}
.sme-quick-sell-title{font-size:12px;font-weight:700;color:var(--sme-blue);margin-bottom:8px;display:flex;align-items:center;gap:5px}
.sme-quick-sell-btns{display:flex;gap:6px;flex-wrap:wrap;align-items:center}
.sme-qs-btn{
    padding:5px 10px;border:1px solid var(--sme-green);background:var(--sme-green-a12);color:var(--sme-green);
    font-size:11px;font-weight:700;border-radius:var(--sme-radius-xs);cursor:pointer;transition:var(--sme-transition);font-family:inherit;
}
.sme-qs-btn:hover{background:var(--sme-green-a25)}
.sme-qs-btn.sme-start{border-color:var(--sme-blue);background:var(--sme-blue-a12);color:var(--sme-blue)}
.sme-qs-btn.sme-start:hover{background:var(--sme-blue-a25)}
.sme-qs-input{
    width:70px;padding:4px 6px;border:1px solid var(--sme-border);background:rgba(0,0,0,0.3);
    color:var(--sme-text);font-size:11px;border-radius:var(--sme-radius-xs);font-family:inherit;
}
.sme-qs-book{margin-top:8px;font-size:11px;color:var(--sme-text-dim);line-height:1.5}
.sme-qs-book-row{display:flex;justify-content:space-between;padding:1px 0}
.sme-qs-book-row.sme-sell{color:var(--sme-red)}
.sme-qs-book-row.sme-buy{color:var(--sme-green)}

/* ===== 快速出售面板增强 (1.4.5) ===== */
.sme-qs-modes{display:flex;flex-direction:column;gap:4px;margin:6px 0}
.sme-qs-mode{display:flex;align-items:center;gap:6px;padding:4px 8px;border:1px solid transparent;border-radius:var(--sme-radius-xs);cursor:pointer;transition:var(--sme-transition);font-size:11px;color:var(--sme-text-dim)}
.sme-qs-mode:hover{background:var(--sme-blue-a06);color:var(--sme-text)}
.sme-qs-mode.active{border-color:var(--sme-border-hi);background:var(--sme-blue-a10);color:var(--sme-blue);font-weight:600}
.sme-qs-mode input[type="radio"]{accent-color:var(--sme-blue);margin:0}
.sme-qs-mode-label{flex:1}
.sme-qs-mode-price{color:var(--sme-text-dim);font-variant-numeric:tabular-nums}
.sme-qs-custom-row{display:flex;align-items:center;gap:6px;margin:4px 0}
.sme-qs-custom-row .sme-qs-input{flex:1;width:auto;min-width:80px}
.sme-qs-fee-info{font-size:11px;color:var(--sme-text-dim);margin:6px 0;padding:4px 8px;background:rgba(0,0,0,0.2);border-radius:var(--sme-radius-xs);line-height:1.6}
.sme-qs-fee-info .sme-qs-fee-buyer{color:var(--sme-red)}
.sme-qs-fee-info .sme-qs-fee-received{color:var(--sme-green)}
.sme-qs-warning{font-size:11px;padding:4px 8px;border-radius:var(--sme-radius-xs);margin:4px 0;line-height:1.4}
.sme-qs-warning.sme-warn-mid{background:var(--sme-amber-a12);border:1px solid var(--sme-amber-a30);color:var(--sme-amber)}
.sme-qs-warning.sme-warn-high{background:var(--sme-red-a12);border:1px solid var(--sme-red-a30);color:var(--sme-red)}
.sme-qs-sell-btn{padding:6px 16px;border:none;border-radius:var(--sme-radius-sm);background:linear-gradient(180deg,var(--sme-green) 0%,#388e3c 100%);color:#fff;font-size:12px;font-weight:700;cursor:pointer;transition:opacity 0.15s;font-family:inherit;margin-top:4px}
.sme-qs-sell-btn:hover{opacity:0.85}
.sme-qs-sell-btn:disabled{opacity:0.4;cursor:not-allowed}
.sme-qs-btn-row{display:flex;gap:6px;margin-top:4px}
.sme-qs-btn-row .sme-qs-sell-btn{flex:1;margin-top:0}
.sme-qs-multi-btn{padding:6px 14px;border:1px solid var(--sme-border-hi);border-radius:var(--sme-radius-sm);background:var(--sme-blue-a10);color:var(--sme-blue);font-size:12px;font-weight:600;cursor:pointer;transition:var(--sme-transition);font-family:inherit;white-space:nowrap}
.sme-qs-multi-btn:hover{background:var(--sme-blue-a20)}
.sme-qs-multi-btn:disabled{opacity:0.4;cursor:not-allowed}

.sme-batch-qty-input{width:70px;text-align:center}
/* 自主定价批量出售对话框 */
.sme-batch-sell-dialog{max-width:400px}
.sme-batch-sell-dialog .sme-dialog-body{padding:16px}
.sme-batch-sell-row{display:flex;align-items:center;gap:8px;margin:8px 0}
.sme-batch-sell-row label{font-size:13px;color:var(--sme-text-dim);min-width:70px}
.sme-batch-sell-select,.sme-batch-sell-input{
    background:rgba(30,41,59,0.6);border:1px solid var(--sme-border);color:var(--sme-text);
    padding:5px 8px;border-radius:var(--sme-radius-sm);font-size:13px;font-family:inherit;
}
.sme-batch-sell-select:focus,.sme-batch-sell-input:focus{outline:none;border-color:var(--sme-border-hi)}
.sme-batch-sell-input{width:100px;text-align:center}
.sme-batch-sell-summary{font-size:12px;color:var(--sme-text-dim);margin:8px 0;line-height:1.6}
.sme-batch-sell-summary strong{color:var(--sme-text-bright)}
/* 多件出售页增强 */
.sme-ms-panel{background:rgba(0,0,0,0.4);border:1px solid var(--sme-border);border-radius:var(--sme-radius-sm);padding:12px;margin:8px 0 16px}
.sme-ms-header{display:flex;justify-content:space-between;align-items:center;margin-bottom:10px}
.sme-ms-title{font-size:14px;font-weight:700;color:var(--sme-blue)}
.sme-ms-status{font-size:11px;color:var(--sme-text-dim)}
.sme-ms-controls{display:flex;flex-wrap:wrap;gap:8px;align-items:center}
.sme-ms-mode-row{display:flex;align-items:center;gap:6px}
.sme-ms-select{background:var(--sme-bg);border:1px solid var(--sme-border-hi);border-radius:var(--sme-radius-xs);color:var(--sme-text);padding:4px 8px;font-size:12px}
.sme-ms-price-row{display:flex;align-items:center;gap:6px}
.sme-ms-price-input{width:90px;background:var(--sme-bg);border:1px solid var(--sme-border-hi);border-radius:var(--sme-radius-xs);color:var(--sme-text);padding:4px 8px;font-size:12px}
.sme-ms-fee-info{font-size:11px;color:var(--sme-text-dim);padding:4px 8px;background:rgba(0,0,0,0.2);border-radius:var(--sme-radius-xs)}
.sme-ms-apply-btn{padding:5px 16px;border:1px solid var(--sme-green);border-radius:var(--sme-radius-xs);background:var(--sme-green-a15);color:var(--sme-green);font-size:12px;font-weight:600;cursor:pointer;font-family:inherit}
.sme-ms-apply-btn:hover{background:var(--sme-green-a25)}
.sme-multisell-btn:not(:disabled){border-color:var(--sme-blue);background:var(--sme-blue-a12);color:var(--sme-blue)}
/* 选中物品分组定价 */
.sme-sel-group{border:1px solid var(--sme-border);border-radius:var(--sme-radius-sm);padding:10px;margin:8px 0}
.sme-sell-selected{position:relative}
.sme-sell-selected:not(:disabled){border-color:var(--sme-green);background:var(--sme-green-a12);color:var(--sme-green)}
.sme-sell-selected:not(:disabled):hover{background:var(--sme-green-a25)}

/* ===== 市场我的挂单批量操作 ===== */
.sme-market-toolbar{
    display:flex;align-items:center;gap:6px;flex-wrap:wrap;padding:8px 0;
    font-family:"Motiva Sans",system-ui,sans-serif;
}
.sme-market-btn{
    display:inline-flex;align-items:center;gap:4px;padding:4px 10px;border:1px solid var(--sme-blue-a25);
    background:var(--sme-blue-a06);color:var(--sme-text);font-size:12px;font-weight:600;
    border-radius:var(--sme-radius-xs);cursor:pointer;transition:var(--sme-transition);white-space:nowrap;font-family:inherit;
}
.sme-market-btn:hover{background:var(--sme-blue-a15);border-color:var(--sme-border-hi);color:var(--sme-text-bright)}
.sme-market-btn.sme-danger{background:var(--sme-red-a8);border-color:var(--sme-red-a25);color:var(--sme-red)}
.sme-market-btn.sme-danger:hover{background:var(--sme-red-a18)}
.sme-market-btn .sme-svg{width:13px;height:13px}
.sme-market-search{
    width:140px;padding:4px 8px;border:1px solid var(--sme-border);background:rgba(0,0,0,0.3);
    color:var(--sme-text);font-size:12px;border-radius:var(--sme-radius-xs);font-family:inherit;
}
.sme-market-search:focus{outline:none;border-color:var(--sme-border-hi)}
.sme-market-select{margin-left:4px;cursor:pointer;accent-color:var(--sme-blue)}

/* ===== 交易报价摘要 ===== */
.sme-trade-summary{
    padding:10px 12px;margin:4px 0;background:var(--sme-bg-card);border:1px solid var(--sme-border);
    border-radius:var(--sme-radius-sm);font-family:"Motiva Sans",system-ui,sans-serif;font-size:12px;
    color:var(--sme-text);line-height:1.6;
}
.sme-trade-summary strong{color:var(--sme-text-bright)}
.sme-trade-summary .sme-trade-total{font-size:14px;color:var(--sme-blue);font-weight:700}
.sme-trade-btn{
    display:inline-flex;align-items:center;gap:5px;padding:5px 12px;border:1px solid var(--sme-blue-a25);
    background:var(--sme-blue-a08);color:var(--sme-text);font-size:12px;font-weight:600;
    border-radius:var(--sme-radius-sm);cursor:pointer;transition:var(--sme-transition);font-family:inherit;margin:4px 0;
}
.sme-trade-btn:hover{background:var(--sme-blue-a18);border-color:var(--sme-border-hi)}
.sme-trade-btn .sme-svg{width:13px;height:13px}

/* ==================== 补充包制作器页面 ==================== */
.sme-booster-panel{
    background:linear-gradient(180deg,rgba(29,31,35,0.98) 0%,rgba(35,38,46,0.98) 100%);
    border:1px solid var(--sme-border);border-radius:var(--sme-radius);
    margin:12px 0;overflow:hidden;font-family:"Motiva Sans",system-ui,-apple-system,sans-serif;
    color:var(--sme-text);box-shadow:0 8px 32px rgba(0,0,0,0.3);
}
.sme-booster-header{
    display:flex;align-items:center;gap:10px;padding:12px 16px;flex-wrap:wrap;
    background:linear-gradient(135deg,var(--sme-blue-a08) 0%,rgba(23,26,33,0.6) 100%);
    border-bottom:1px solid var(--sme-border);
}
.sme-booster-title{display:flex;align-items:center;gap:8px;font-size:15px;font-weight:700;color:var(--sme-text-bright);white-space:nowrap}
.sme-booster-title svg{width:20px;height:20px;flex-shrink:0;color:var(--sme-blue)}
.sme-booster-gems{display:inline-flex;align-items:center;gap:4px;padding:4px 10px;background:var(--sme-blue-a10);border:1px solid var(--sme-blue-a20);border-radius:var(--sme-radius-sm);font-size:13px;color:var(--sme-blue);font-weight:600}
.sme-booster-gems svg{width:14px;height:14px;flex-shrink:0}

/* ---- 操作说明提示条 ---- */
.sme-booster-hints{
    display:flex;align-items:center;gap:14px;padding:7px 16px;flex-wrap:wrap;
    background:var(--sme-blue-a04);border-bottom:1px solid var(--sme-blue-a06);
    font-size:11px;color:var(--sme-text-dim);line-height:1.4;
}
.sme-booster-hints b{color:var(--sme-text);font-weight:600}
.sme-booster-hint-item{display:inline-flex;align-items:center;gap:4px;white-space:nowrap}
.sme-booster-hint-icon{width:18px;height:18px;display:inline-flex;align-items:center;justify-content:center;border-radius:var(--sme-radius-xs);flex-shrink:0}
.sme-booster-hint-icon svg{width:11px;height:11px}

/* ---- 工具栏 ---- */
.sme-booster-toolbar{display:flex;align-items:center;gap:6px;flex-wrap:wrap;padding:10px 16px;border-bottom:1px solid var(--sme-blue-a08)}
.sme-booster-tb-group{display:flex;align-items:center;gap:5px;flex-wrap:nowrap}
.sme-booster-tb-sep{width:1px;height:22px;background:var(--sme-blue-a12);margin:0 3px;flex-shrink:0}
.sme-booster-search{
    background:rgba(49,64,77,0.6);border:1px solid var(--sme-border);color:var(--sme-text);
    padding:5px 10px 5px 28px;border-radius:var(--sme-radius-sm);font-size:13px;width:180px;outline:none;transition:border-color 0.2s,box-shadow 0.2s;
    background-image:url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='14' height='14' viewBox='0 0 24 24' fill='none' stroke='%238899a6' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3E%3Ccircle cx='11' cy='11' r='8'/%3E%3Cline x1='21' y1='21' x2='16.65' y2='16.65'/%3E%3C/svg%3E");background-repeat:no-repeat;background-position:8px center;
}
.sme-booster-search:focus{border-color:var(--sme-border-hi);box-shadow:0 0 0 2px var(--sme-blue-a10)}
.sme-booster-search:focus-visible{outline:none;border-color:var(--sme-border-hi);box-shadow:0 0 0 2px var(--sme-blue-a15)}
.sme-booster-select{
    background:rgba(49,64,77,0.6);border:1px solid var(--sme-border);color:var(--sme-text);
    padding:5px 10px;border-radius:var(--sme-radius-sm);font-size:13px;cursor:pointer;outline:none;
}
.sme-booster-select:focus-visible{border-color:var(--sme-border-hi);box-shadow:0 0 0 2px var(--sme-blue-a15)}

/* ---- 按钮层级系统 ---- */
.sme-booster-btn{
    display:inline-flex;align-items:center;gap:5px;padding:6px 12px;border:1px solid var(--sme-blue-a25);
    background:var(--sme-blue-a08);color:var(--sme-text);font-size:12px;font-weight:600;
    border-radius:var(--sme-radius-sm);cursor:pointer;transition:background 0.2s,border-color 0.2s,transform 0.1s;font-family:inherit;white-space:nowrap;
}
.sme-booster-btn:hover{background:var(--sme-blue-a18);border-color:var(--sme-border-hi)}
.sme-booster-btn:active{transform:scale(0.97)}
.sme-booster-btn:disabled{opacity:0.4;cursor:default;transform:none}
.sme-booster-btn:focus-visible{outline:none;box-shadow:0 0 0 2px var(--sme-blue-a30)}
.sme-booster-btn .sme-svg{width:14px;height:14px;flex-shrink:0}
.sme-booster-btn-green{background:var(--sme-green-a15);border-color:var(--sme-green-a40);color:#5cb85c;font-size:13px;padding:7px 16px}
.sme-booster-btn-green:hover{background:var(--sme-green-a28);border-color:var(--sme-green-a60);box-shadow:0 2px 12px var(--sme-green-a15)}
.sme-booster-btn-red{background:var(--sme-red-a10);border-color:var(--sme-red-a25);color:var(--sme-red);font-size:11px;padding:4px 10px}
.sme-booster-btn-red:hover{background:var(--sme-red-a20)}
.sme-booster-btn-amber{background:var(--sme-amber-a12);border-color:var(--sme-amber-a30);color:var(--sme-amber)}
.sme-booster-btn-amber:hover{background:var(--sme-amber-a22)}

/* ---- 表格 ---- */
.sme-booster-content{overflow-x:auto;overflow-y:visible}
.sme-booster-table{width:100%;border-collapse:collapse;font-size:13px}
.sme-booster-table th{
    color:var(--sme-text-dim);text-align:left;padding:8px 10px;font-size:11px;font-weight:600;
    border-bottom:1px solid var(--sme-border);text-transform:uppercase;letter-spacing:0.5px;cursor:pointer;
    user-select:none;white-space:nowrap;position:sticky;top:0;background:rgba(29,31,35,0.98);z-index:1;
}
.sme-booster-table th:hover{color:var(--sme-blue)}
.sme-booster-table th.sme-no-sort{cursor:default}
.sme-booster-table th.sme-no-sort:hover{color:var(--sme-text-dim)}
.sme-booster-table td{padding:5px 8px;border-bottom:1px solid var(--sme-blue-a06);color:var(--sme-text);vertical-align:middle}
.sme-booster-table tr:hover td{background:var(--sme-blue-a04)}
.sme-booster-table tr.sme-done td{opacity:0.45}
.sme-booster-table tr.sme-done td.sme-booster-name{text-decoration:line-through}
.sme-booster-name{color:var(--sme-text-bright);font-weight:500;max-width:260px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
.sme-booster-name a{color:inherit;text-decoration:none}
.sme-booster-name a:hover{color:var(--sme-blue);text-decoration:underline}
.sme-booster-profit-positive{color:var(--sme-green);font-weight:700}
.sme-booster-profit-negative{color:var(--sme-red);font-weight:600}
.sme-booster-profit-neutral{color:var(--sme-text-dim)}

/* ---- 状态徽章 ---- */
.sme-booster-badge{display:inline-flex;align-items:center;gap:4px;padding:2px 8px;border-radius:var(--sme-radius);font-size:11px;font-weight:600;white-space:nowrap}
.sme-booster-badge::before{content:'';width:6px;height:6px;border-radius:50%;flex-shrink:0}
.sme-booster-badge-available{background:var(--sme-green-a12);color:var(--sme-green)}
.sme-booster-badge-available::before{background:var(--sme-green);box-shadow:0 0 4px var(--sme-green-a50)}
.sme-booster-badge-cooldown{background:var(--sme-amber-a10);color:var(--sme-amber)}
.sme-booster-badge-cooldown::before{background:var(--sme-amber)}
.sme-booster-badge-done{background:rgba(136,153,166,0.1);color:var(--sme-text-dim)}
.sme-booster-badge-done::before{background:var(--sme-text-dim)}

/* ---- 操作按钮（重新设计：纯图标固定尺寸，状态变色） ---- */
.sme-booster-actions{display:inline-flex;gap:4px;align-items:center;flex-wrap:nowrap}
.sme-booster-action-btn{
    display:inline-flex;align-items:center;justify-content:center;
    width:28px;height:28px;padding:0;border:1.5px solid transparent;border-radius:var(--sme-radius-sm);
    cursor:pointer;font-family:inherit;white-space:nowrap;
    transition:background 0.15s,border-color 0.15s,transform 0.1s,box-shadow 0.15s;line-height:1;
    flex-shrink:0;
}
.sme-booster-action-btn:hover{transform:translateY(-1px);box-shadow:0 2px 8px rgba(0,0,0,0.2)}
.sme-booster-action-btn:active{transform:translateY(0)}
.sme-booster-action-btn:focus-visible{outline:none;box-shadow:0 0 0 2px var(--sme-blue-a30)}
.sme-booster-action-btn svg{width:15px;height:15px;flex-shrink:0}
/* 队列：未加入=绿色边框，已加入=蓝色填充 */
.sme-booster-action-queue{background:var(--sme-green-a10);color:var(--sme-green);border-color:var(--sme-green-a30)}
.sme-booster-action-queue:hover{background:var(--sme-green-a22);border-color:var(--sme-green-a50)}
.sme-booster-action-queue.active{background:var(--sme-blue-a25);color:var(--sme-blue);border-color:var(--sme-blue-a50);box-shadow:0 0 6px var(--sme-blue-a20)}
.sme-booster-action-queue.active:hover{background:var(--sme-blue-a35);border-color:var(--sme-blue-a70)}
/* 收藏：未收藏=空心星，已收藏=实心星 */
.sme-booster-action-fav{background:var(--sme-amber-a8);color:var(--sme-amber);border-color:var(--sme-amber-a20)}
.sme-booster-action-fav:hover{background:var(--sme-amber-a18);border-color:var(--sme-amber-a40)}
.sme-booster-action-fav.active{background:var(--sme-amber-a20);color:var(--sme-amber);border-color:var(--sme-amber-a50);box-shadow:0 0 6px var(--sme-amber-a15)}
.sme-booster-action-fav.active:hover{background:var(--sme-amber-a30);border-color:var(--sme-amber-a65)}
/* 拉黑：未拉黑=红色边框，已拉黑=红色填充 */
.sme-booster-action-black{background:var(--sme-red-a6);color:var(--sme-red);border-color:var(--sme-red-a15)}
.sme-booster-action-black:hover{background:var(--sme-red-a15);border-color:var(--sme-red-a30)}
.sme-booster-action-black.active{background:var(--sme-red-a20);color:var(--sme-red);border-color:var(--sme-red-a45);box-shadow:0 0 6px var(--sme-red-a15)}
.sme-booster-action-black.active:hover{background:var(--sme-red-a30);border-color:var(--sme-red-a60)}

/* ---- 空数据提示 ---- */
.sme-booster-cell-empty{color:var(--sme-text-dim);font-size:12px;opacity:0.6}
.sme-booster-cell-prompt{color:var(--sme-blue-a70);font-size:11px;font-style:italic}  /* v1.5.1 P2-C: 对比度 2.6:1 → ≥4.5:1 */

/* ---- 链接 ---- */
.sme-booster-link-group{display:inline-flex;align-items:center;gap:6px;flex-wrap:nowrap;white-space:nowrap}
.sme-booster-link-item{display:inline-flex;align-items:center;gap:3px;font-size:11px;color:var(--sme-blue);text-decoration:none;padding:2px 6px;border-radius:var(--sme-radius-xs);transition:background 0.15s;white-space:nowrap;flex-shrink:0}
.sme-booster-link-item:hover{background:var(--sme-blue-a10);text-decoration:none}
.sme-booster-link-item svg{width:12px;height:12px;flex-shrink:0}

/* ---- 横版封面 ---- */
.sme-booster-cover{width:184px;height:69px;border-radius:var(--sme-radius-xs);object-fit:cover;background:rgba(49,64,77,0.4);display:block;flex-shrink:0}
.sme-booster-cover-cell{padding:4px 6px!important}
.sme-booster-cover-failed{opacity:0.3;filter:grayscale(1)}
.sme-booster-cover-wrapper{position:relative;width:184px;height:69px;border-radius:var(--sme-radius-xs);overflow:hidden;background:rgba(29,31,35,0.6);flex-shrink:0}
.sme-booster-cover-wrapper img{width:100%;height:100%;object-fit:cover;display:block;transition:opacity 0.2s}
.sme-booster-cover-wrapper .sme-booster-cover-placeholder{position:absolute;inset:0;display:flex;align-items:center;justify-content:center;font-size:10px;color:var(--sme-text-dim);background:rgba(29,31,35,0.8)}

/* ---- 进度条 & 信息栏 & 分页 ---- */
.sme-booster-progress{height:4px;background:rgba(49,64,77,0.6);border-radius:var(--sme-radius-xs);overflow:hidden;margin-top:8px;display:none}
.sme-booster-progress.sme-visible{display:block}
.sme-booster-info-bar{display:flex;align-items:center;gap:16px;padding:8px 16px;font-size:12px;color:var(--sme-text-dim);border-top:1px solid var(--sme-border);flex-wrap:wrap}
.sme-booster-info-bar strong{color:var(--sme-text-bright)}
.sme-booster-info-bar .sme-booster-profit-positive{font-size:13px}
.sme-booster-pagination{display:flex;align-items:center;gap:8px;justify-content:center;padding:10px 16px}
.sme-booster-pagination button{
    padding:4px 10px;border:1px solid var(--sme-border);background:rgba(49,64,77,0.4);color:var(--sme-text);
    border-radius:var(--sme-radius-xs);cursor:pointer;font-size:12px;transition:border-color 0.2s,color 0.2s;
}
.sme-booster-pagination button:hover{border-color:var(--sme-border-hi);color:var(--sme-blue)}
.sme-booster-pagination button:disabled{opacity:0.3;cursor:default}
.sme-booster-pagination button:focus-visible{outline:none;box-shadow:0 0 0 2px var(--sme-blue-a30)}
.sme-booster-pagination .sme-page-info{color:var(--sme-text-dim);font-size:12px;min-width:80px;text-align:center;font-variant-numeric:tabular-nums}
.sme-booster-spinner{display:inline-block;border:2px solid var(--sme-blue-a20);border-top-color:var(--sme-blue);border-radius:50%;animation:sme-spin 0.7s linear infinite}
.sme-booster-empty{padding:40px;text-align:center;color:var(--sme-text-dim);font-size:13px}
.sme-booster-toast{position:fixed;top:20px;right:20px;z-index:var(--sme-z-top);padding:10px 16px;border-radius:var(--sme-radius-sm);font-size:13px;font-family:"Motiva Sans",system-ui,sans-serif;opacity:0;transform:translateX(20px);transition:opacity 0.3s,transform 0.3s;pointer-events:none;max-width:360px}
.sme-booster-toast.sme-show{opacity:1;transform:translateX(0)}
.sme-booster-toast.sme-success{background:var(--sme-green-a95);color:#fff}
.sme-booster-toast.sme-error{background:var(--sme-red-a95);color:#fff}
.sme-booster-toast.sme-info{background:var(--sme-blue-a95);color:#fff}
.sme-booster-toast.sme-warning{background:var(--sme-amber-a95);color:#fff}
@media(prefers-reduced-motion:reduce){
    .sme-booster-action-btn,.sme-booster-btn,.sme-booster-pagination button{transition:none!important;transform:none!important}
    .sme-booster-progress-bar{transition:none!important}
    .sme-booster-toast{transition:opacity 0.1s!important}
}
    
    /* ================= v2.0.0 变体标注 / 各变体最低价 ================= */
    .sme-ob-variant{margin:8px 0 4px;font-size:11px;color:var(--sme-text-dim);padding:5px 8px;border-radius:4px;background:rgba(255,255,255,.04)}
    .sme-ob-variant.mismatch{color:#e96969;background:rgba(233,105,105,.10);border:1px solid rgba(233,105,105,.25)}
    .sme-ob-variants{margin:10px 0 4px;border:1px solid rgba(255,255,255,.07);border-radius:6px;overflow:hidden}
    .sme-ob-variants-title{padding:6px 10px;font-size:11px;color:var(--sme-text-dim);background:rgba(255,255,255,.04);border-bottom:1px solid rgba(255,255,255,.06)}
    .sme-ob-variants-list{max-height:190px;overflow-y:auto}
    .sme-ob-variant-row{display:flex;justify-content:space-between;gap:10px;padding:4px 10px;font-size:11px;border-bottom:1px solid rgba(255,255,255,.03)}
    .sme-ob-variant-row:last-child{border-bottom:none}
    .sme-ob-variant-row.current{background:rgba(102,192,244,.10)}
    .sme-ob-variant-name{color:var(--sme-text-dim);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
    .sme-ob-variant-price{color:var(--sme-text);font-weight:600;flex-shrink:0}

    /* ================= v2.0.1 交易冷却角标 / 提示 ================= */
    .sme-inv-cooldown{display:inline-block;margin-left:4px;padding:1px 5px;border-radius:8px;font-size:10px;font-weight:700;color:#f59e0b;background:rgba(245,158,11,.16);border:1px solid rgba(245,158,11,.35);white-space:nowrap;vertical-align:middle}
    .sme-cooldown-notice{display:flex;align-items:center;gap:6px;margin:0 0 8px;padding:7px 10px;border-radius:6px;font-size:12px;color:#f59e0b;background:rgba(245,158,11,.10);border:1px solid rgba(245,158,11,.28)}
    .sme-cooldown-notice svg{width:14px;height:14px;flex-shrink:0}

    /* ================= v2.1.0 价格提醒波动率徽章 ================= */
    .sme-vol-badge{display:inline-block;flex-shrink:0;padding:1px 7px;border-radius:var(--sme-radius-pill);font-size:10px;font-weight:700;white-space:nowrap;cursor:help}
    .sme-vol-badge--stable{color:var(--sme-green);background:var(--sme-green-a12);border:1px solid var(--sme-green-a40)}
    .sme-vol-badge--normal{color:var(--sme-text-dim);background:rgba(143,152,160,.12);border:1px solid rgba(143,152,160,.30)}
    .sme-vol-badge--volatile{color:var(--sme-red);background:var(--sme-red-a12);border:1px solid var(--sme-red-a45)}
    .sme-vol-badge--declining{color:var(--sme-amber);background:var(--sme-amber-a12);border:1px solid var(--sme-amber-a40)}
`;

    GM_addStyle(CSS);

    // ==================== v1.4.6 市场顺序跟踪 CSS ====================
    GM_addStyle(`
/* v2.2.5：右下角底部 16px 让给「常驻汇率徽标」，市场顺序浮窗上移，避免互相遮挡 */
.sme-mr-panel{position:fixed;right:16px;bottom:56px;z-index:var(--sme-z-overlay);width:250px;background:rgba(22,28,36,.97);border:1px solid var(--sme-blue-a35);border-radius:var(--sme-radius);box-shadow:0 6px 24px rgba(0,0,0,.55);color:#c6d4df;font-family:"Motiva Sans",Arial,Helvetica,sans-serif;font-size:12px;overflow:hidden;backdrop-filter:blur(6px)}
/* v1.4.9：嵌入到筛选面板内部的侧边栏样式（与筛选面板统一风格） */
.sme-mr-panel.sme-mr-inline{position:relative;right:auto;bottom:auto;width:100%;margin-top:0;z-index:auto;box-shadow:none;background:transparent;border:none;border-radius:0;backdrop-filter:none;padding-top:var(--spacing-2);border-top:1px solid var(--color-border-border)}
.sme-mr-panel.sme-mr-inline .sme-mr-head{background:transparent;border-bottom:none;padding:4px 0}
.sme-mr-panel.sme-mr-inline .sme-mr-head-title{font-size:13px;font-weight:var(--font-weight-medium,600);color:var(--color-text-body-subtitle)}
.sme-mr-panel.sme-mr-inline .sme-mr-body{padding:8px 0 4px}
.sme-mr-panel.sme-mr-inline .sme-mr-foot{padding:6px 0 0;border-top:none}
.sme-mr-panel.sme-mr-inline.collapsed{width:100%;padding-bottom:0}
.sme-mr-panel.sme-mr-inline .sme-mr-main{padding:12px 14px;background:linear-gradient(135deg,var(--color-accent-8-10,var(--sme-blue-a10)),transparent);border:1px solid var(--color-accent-8-20,var(--sme-blue-a20));border-radius:var(--sme-radius-sm)}
.sme-mr-panel.sme-mr-inline .sme-mr-rank-label{color:var(--color-accent-8,var(--sme-blue))}
.sme-mr-panel.sme-mr-inline .sme-mr-rank-big{background:linear-gradient(180deg,var(--color-accent-9,#8ad8ff) 0%,var(--color-accent-8,var(--sme-blue)) 50%,var(--color-accent-7,#4a9fd4) 100%);-webkit-background-clip:text;-webkit-text-fill-color:transparent;background-clip:text}
.sme-mr-panel.sme-mr-inline .sme-mr-total{color:var(--color-text-body-subtitle)}
.sme-mr-panel.sme-mr-inline .sme-mr-note{color:var(--color-text-body-subtitle)}
.sme-mr-panel.sme-mr-inline .sme-mr-row{color:var(--color-text-body-body)}
.sme-mr-panel.sme-mr-inline .sme-mr-row .pr{color:var(--color-text-body-body)}
.sme-mr-panel.sme-mr-inline .sme-mr-row.front{background:var(--color-accent-8-10,var(--sme-blue-a10))}
.sme-mr-panel.sme-mr-inline .sme-mr-rows{border-top-color:var(--color-border-border)}
.sme-mr-panel.sme-mr-inline .sme-mr-foot{color:var(--color-text-body-subtitle)}
.sme-mr-panel.sme-mr-inline .sme-mr-btn{background:var(--color-dull-8-10,rgba(255,255,255,.08));border-color:var(--color-border-border);color:var(--color-text-body-body)}
.sme-mr-panel.sme-mr-inline .sme-mr-btn:hover{background:var(--color-dull-8-20,rgba(255,255,255,.15))}
.sme-mr-panel.sme-mr-inline .sme-mr-changenote{border-top-color:var(--color-border-border);color:var(--color-text-body-subtitle)}
.sme-mr-panel.collapsed{width:auto}
.sme-mr-head{display:flex;align-items:center;gap:6px;padding:8px 10px;background:var(--sme-blue-a10);border-bottom:1px solid var(--sme-blue-a18);cursor:pointer;user-select:none}
.sme-mr-head-title{font-weight:700;color:var(--sme-blue);font-size:12px;flex:1;white-space:nowrap}
.sme-mr-dot{width:8px;height:8px;border-radius:50%;background:var(--sme-text-dim);flex-shrink:0}
.sme-mr-dot.ok{background:#6cc900;box-shadow:0 0 6px rgba(108,201,0,.7)}
.sme-mr-dot.scanning{background:var(--sme-blue);animation:sme-mr-pulse 1s ease-in-out infinite}
.sme-mr-dot.error{background:#e05a5a}
@keyframes sme-mr-pulse{0%,100%{opacity:.35}50%{opacity:1}}
.sme-mr-body{padding:10px}
.sme-mr-main{display:flex;align-items:baseline;gap:8px;margin-bottom:8px;padding:12px 14px;background:linear-gradient(135deg,var(--sme-blue-a12),var(--sme-blue-a04));border:1px solid var(--sme-blue-a20);border-radius:var(--sme-radius-sm)}
.sme-mr-rank-label{font-size:11px;font-weight:700;color:var(--sme-blue);text-transform:uppercase;letter-spacing:1px;opacity:.8}
.sme-mr-rank-big{font-size:34px;font-weight:900;background:linear-gradient(180deg,#8ad8ff 0%,var(--sme-blue) 50%,#4a9fd4 100%);-webkit-background-clip:text;-webkit-text-fill-color:transparent;background-clip:text;line-height:1;transition:filter .3s;text-shadow:0 0 20px var(--sme-blue-a30)}
.sme-mr-rank-big.up{background:linear-gradient(180deg,#a8e063 0%,#6cc900 50%,#5aa800 100%);-webkit-background-clip:text;-webkit-text-fill-color:transparent;background-clip:text;text-shadow:0 0 20px rgba(108,201,0,.3)}
.sme-mr-rank-big.down{background:linear-gradient(180deg,#ff7b7b 0%,#e05a5a 50%,#c44 100%);-webkit-background-clip:text;-webkit-text-fill-color:transparent;background-clip:text;text-shadow:0 0 20px rgba(224,90,90,.3)}
.sme-mr-total{color:var(--sme-text-dim);font-size:14px;font-weight:600}
.sme-mr-note{color:var(--sme-text-dim);font-size:11px;margin-bottom:6px}
.sme-mr-rows{border-top:1px solid rgba(255,255,255,.08);margin-top:6px;padding-top:6px;max-height:120px;overflow-y:auto}
.sme-mr-row{display:flex;align-items:center;gap:6px;padding:2px 0;color:#c6d4df}
.sme-mr-row .rk{color:var(--sme-blue);font-weight:700;min-width:38px}
.sme-mr-row .pr{flex:1;color:#c6d4df}
.sme-mr-row .lid{color:#67c1f5;font-size:10px;cursor:help;text-decoration:underline dotted}
.sme-mr-row.front{background:var(--sme-blue-a10);margin:0 -6px;padding:2px 6px;border-radius:var(--sme-radius-xs)}
.sme-mr-foot{display:flex;align-items:center;gap:6px;padding:6px 10px;border-top:1px solid rgba(255,255,255,.08);color:var(--sme-text-dim);font-size:11px}
.sme-mr-btn{background:var(--sme-blue-a15);border:1px solid var(--sme-blue-a35);color:var(--sme-blue);border-radius:var(--sme-radius-xs);padding:2px 8px;font-size:11px;cursor:pointer;line-height:1.4}
.sme-mr-btn:hover{background:var(--sme-blue-a30)}
.sme-mr-btn:disabled{opacity:.45;cursor:not-allowed}
.sme-mr-changenote{padding:4px 10px;color:#a3cc5a;font-size:11px;border-top:1px solid rgba(255,255,255,.06)}
/* v1.4.9：详情页设置面板改为双列布局 + 分组卡片式，更紧凑清晰 */
.sme-settings-grid{display:flex;flex-direction:column;gap:12px}
.sme-setting-group{
    background:var(--sme-bg-card);
    border:1px solid var(--sme-border);
    border-radius:var(--sme-radius-sm);
    padding:12px 14px;
    display:grid;
    grid-template-columns:repeat(2,1fr);
    gap:0 16px;
    position:relative;
}
.sme-setting-group::before{content:'';position:absolute;left:50%;top:12px;bottom:12px;width:1px;background:var(--sme-border);transform:translateX(-0.5px);pointer-events:none}
.sme-setting-group .sme-setting-group-title{
    grid-column:1/-1;
    margin:0 0 8px 0;
    padding:0 0 8px 0;
    border-bottom:1px solid var(--sme-border);
    font-size:13px;
    font-weight:700;
    color:var(--sme-blue);
    display:flex;
    align-items:center;
    gap:6px;
}
.sme-setting-group .sme-setting-row{padding:7px 10px;border:1px solid transparent;border-radius:var(--sme-radius-sm);margin:1px 0;transition:background 0.15s,border-color 0.15s}
.sme-setting-group .sme-setting-row:hover{background:var(--sme-blue-a04);border-color:var(--sme-blue-a10)}
.sme-setting-group .sme-setting-name{font-size:12px}
.sme-setting-group .sme-setting-desc{font-size:10px}
.sme-setting-group .sme-info-box{grid-column:1/-1;margin-top:8px}
.sme-setting-group .sme-settings-full{grid-column:1/-1}
.sme-setting-group .sme-danger-btn{margin-top:4px}
@media (max-width:640px){
    .sme-setting-group{grid-template-columns:1fr}
    .sme-setting-group::before{display:none}
}
/* v1.4.8：排名徽章改用 data 属性 + ::after 渲染，不再向 React 管理的容器插入子节点，
   避免 hydration/reconciliation 冲突导致新版页面列表被清空重建 */
span[data-sme-rank]::after{content:attr(data-sme-rank);display:inline-block;margin-left:6px;padding:1px 7px;border-radius:var(--sme-radius-sm);background:linear-gradient(135deg,var(--sme-blue-a25),var(--sme-blue-a10));border:1px solid var(--sme-blue-a55);color:#8ad8ff!important;font-size:12px;font-weight:700;line-height:1.5;white-space:nowrap;vertical-align:middle}
span[data-sme-rank][data-sme-front]::after{border-color:#6cc900;color:#6cc900!important;background:rgba(108,201,0,.10)}
div[data-sme-rank]::after{content:attr(data-sme-rank);display:block;margin-top:4px;font-size:11px;color:var(--sme-blue);font-weight:700;text-align:center}
div[data-sme-rank][data-sme-front]::after{color:#6cc900}
.sme-mr-flash{animation:sme-mr-flash 1.2s ease-out}
@keyframes sme-mr-flash{0%{box-shadow:0 0 0 0 var(--sme-blue-a80)}100%{box-shadow:0 0 0 14px var(--sme-blue-a0)}}
`);

    // ==================== SVG 图标 ====================
    const _S = 'viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"';
    const ICONS = {
        bag: `<svg class="sme-svg" ${_S}><path d="M6 2L3 6v14a2 2 0 002 2h14a2 2 0 002-2V6l-3-4z"/><path d="M3 6h18"/><path d="M16 10a4 4 0 01-8 0"/></svg>`,
        list: `<svg class="sme-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>`,
        chart: `<svg class="sme-svg" ${_S}><polyline points="22 12 18 12 15 21 9 3 6 12 2 12"/></svg>`,
        book: `<svg class="sme-svg" ${_S}><path d="M4 19.5A2.5 2.5 0 016.5 17H20"/><path d="M6.5 2H20v20H6.5A2.5 2.5 0 014 19.5v-15A2.5 2.5 0 016.5 2z"/></svg>`,
        settings: `<svg class="sme-svg" ${_S}><circle cx="12" cy="12" r="3"/><path d="M19.4 15a1.65 1.65 0 00.33 1.82l.06.06a2 2 0 010 2.83 2 2 0 01-2.83 0l-.06-.06a1.65 1.65 0 00-1.82-.33 1.65 1.65 0 00-1 1.51V21a2 2 0 01-2 2 2 2 0 01-2-2v-.09A1.65 1.65 0 009 19.4a1.65 1.65 0 00-1.82.33l-.06.06a2 2 0 01-2.83 0 2 2 0 010-2.83l.06-.06A1.65 1.65 0 004.68 15a1.65 1.65 0 00-1.51-1H3a2 2 0 01-2-2 2 2 0 012-2h.09A1.65 1.65 0 004.6 9a1.65 1.65 0 00-.33-1.82l-.06-.06a2 2 0 010-2.83 2 2 0 012.83 0l.06.06A1.65 1.65 0 009 4.68a1.65 1.65 0 001-1.51V3a2 2 0 012-2 2 2 0 012 2v.09a1.65 1.65 0 001 1.51 1.65 1.65 0 001.82-.33l.06-.06a2 2 0 012.83 0 2 2 0 010 2.83l-.06.06A1.65 1.65 0 0019.4 9a1.65 1.65 0 001.51 1H21a2 2 0 012 2 2 2 0 01-2 2h-.09a1.65 1.65 0 00-1.51 1z"/></svg>`,
        refresh: `<svg class="sme-svg" ${_S}><polyline points="23 4 23 10 17 10"/><path d="M20.49 15a9 9 0 11-2.12-9.36L23 10"/></svg>`,
        close: `<svg class="sme-svg" ${_S}><line x1="18" y1="6" x2="6" y2="18"/><line x1="6" y1="6" x2="18" y2="18"/></svg>`,
        trash: `<svg class="sme-svg" ${_S}><polyline points="3 6 5 6 21 6"/><path d="M19 6v14a2 2 0 01-2 2H7a2 2 0 01-2-2V6m3 0V4a2 2 0 012-2h4a2 2 0 012 2v2"/><line x1="10" y1="11" x2="10" y2="17"/><line x1="14" y1="11" x2="14" y2="17"/></svg>`,
        check: `<svg class="sme-svg" ${_S}><polyline points="20 6 9 17 4 12"/></svg>`,
        alert: `<svg class="sme-svg" ${_S}><circle cx="12" cy="12" r="10"/><line x1="12" y1="8" x2="12" y2="12"/><line x1="12" y1="16" x2="12.01" y2="16"/></svg>`,
        package: `<svg class="sme-svg" ${_S}><path d="M16.5 9.4l-9-5.19M21 16V8a2 2 0 00-1-1.73l-7-4a2 2 0 00-2 0l-7 4A2 2 0 003 8v8a2 2 0 001 1.73l7 4a2 2 0 002 0l7-4A2 2 0 0021 16z"/><polyline points="3.27 6.96 12 12.01 20.73 6.96"/><line x1="12" y1="22.08" x2="12" y2="12"/></svg>`,
        trendingDown: `<svg class="sme-svg" ${_S}><polyline points="23 18 13.5 8.5 8.5 13.5 1 6"/><polyline points="17 18 23 18 23 12"/></svg>`,
        trendingUp: `<svg class="sme-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>`,
        layers: `<svg class="sme-svg" ${_S}><polygon points="12 2 2 7 12 12 22 7 12 2"/><polyline points="2 17 12 22 22 17"/><polyline points="2 12 12 17 22 12"/></svg>`,
        refreshCw: `<svg class="sme-svg" ${_S}><polyline points="23 4 23 10 17 10"/><polyline points="1 20 1 14 7 14"/><path d="M3.51 9a9 9 0 0114.85-3.36L23 10M1 14l4.64 4.36A9 9 0 0020.49 15"/></svg>`,
        zap: `<svg class="sme-svg" ${_S}><polygon points="13 2 3 14 12 14 11 22 21 10 12 10 13 2"/></svg>`,
        dollarSign: `<svg class="sme-svg" ${_S}><line x1="12" y1="1" x2="12" y2="23"/><path d="M17 5H9.5a3.5 3.5 0 000 7h5a3.5 3.5 0 010 7H6"/></svg>`,
        // v1.3.0 新增图标
        tag: `<svg class="sme-svg" ${_S}><path d="M20.59 13.41l-7.17 7.17a2 2 0 01-2.83 0L2 12V2h10l8.59 8.59a2 2 0 010 2.82z"/><line x1="7" y1="7" x2="7.01" y2="7"/></svg>`,
        sell: `<svg class="sme-svg" ${_S}><circle cx="9" cy="21" r="1"/><circle cx="20" cy="21" r="1"/><path d="M1 1h4l2.68 13.39a2 2 0 002 1.61h9.72a2 2 0 002-1.61L23 6H6"/></svg>`,
        copy: `<svg class="sme-svg" ${_S}><rect x="9" y="9" width="13" height="13" rx="2" ry="2"/><path d="M5 15H4a2 2 0 01-2-2V4a2 2 0 012-2h9a2 2 0 012 2v1"/></svg>`,
        gem: `<svg class="sme-svg" ${_S}><polygon points="6 3 18 3 22 9 12 22 2 9"/><polyline points="11 3 8 9 12 22"/><polyline points="13 3 16 9 12 22"/><line x1="2" y1="9" x2="22" y2="9"/></svg>`,
        unpack: `<svg class="sme-svg" ${_S}><path d="M16.5 9.4l-9-5.19M21 16V8a2 2 0 00-1-1.73l-7-4a2 2 0 00-2 0l-7 4A2 2 0 003 8v8a2 2 0 001 1.73l7 4a2 2 0 002 0l7-4A2 2 0 0021 16z"/><polyline points="3.27 6.96 12 12.01 20.73 6.96"/><line x1="12" y1="22.08" x2="12" y2="12"/></svg>`,
        exchange: `<svg class="sme-svg" ${_S}><polyline points="17 1 21 5 17 9"/><path d="M3 11V9a4 4 0 014-4h14"/><polyline points="7 23 3 19 7 15"/><path d="M21 13v2a4 4 0 01-4 4H3"/></svg>`,
        sort: `<svg class="sme-svg" ${_S}><line x1="21" y1="10" x2="3" y2="10"/><line x1="21" y1="6" x2="3" y2="6"/><line x1="21" y1="14" x2="9" y2="14"/><line x1="21" y1="18" x2="13" y2="18"/></svg>`,
        search: `<svg class="sme-svg" ${_S}><circle cx="11" cy="11" r="8"/><line x1="21" y1="21" x2="16.65" y2="16.65"/></svg>`,
        selectAll: `<svg class="sme-svg" ${_S}><rect x="3" y="3" width="18" height="18" rx="2"/><polyline points="9 11 12 14 20 6"/></svg>`,
        scale: `<svg class="sme-svg" ${_S}><path d="M6 9l6-6 6 6"/><path d="M6 15l6 6 6-6"/><line x1="12" y1="3" x2="12" y2="21"/></svg>`,
        // v1.4.4 操作按钮专用图标
        queue: `<svg class="sme-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>`,
        queueActive: `<svg class="sme-svg" ${_S}><polyline points="20 6 9 17 4 12"/></svg>`,
        starOutline: `<svg class="sme-svg" ${_S}><polygon points="12 2 15.09 8.26 22 9.27 17 14.14 18.18 21.02 12 17.77 5.82 21.02 7 14.14 2 9.27 8.91 8.26 12 2"/></svg>`,
        starFilled: `<svg class="sme-svg" viewBox="0 0 24 24" fill="currentColor" stroke="currentColor" stroke-width="1.5" stroke-linejoin="round"><polygon points="12 2 15.09 8.26 22 9.27 17 14.14 18.18 21.02 12 17.77 5.82 21.02 7 14.14 2 9.27 8.91 8.26 12 2"/></svg>`,
        ban: `<svg class="sme-svg" ${_S}><circle cx="12" cy="12" r="10"/><line x1="4.93" y1="4.93" x2="19.07" y2="19.07"/></svg>`,
        banActive: `<svg class="sme-svg" viewBox="0 0 24 24" fill="currentColor" stroke="currentColor" stroke-width="1.5"><circle cx="12" cy="12" r="10"/><line x1="4.93" y1="4.93" x2="19.07" y2="19.07" stroke="#fff" stroke-width="2"/></svg>`,
        card: `<svg class="sme-svg" ${_S}><rect x="2" y="3" width="20" height="18" rx="2"/><line x1="2" y1="9" x2="22" y2="9"/></svg>`,
        // v1.6.0 新增图标
        download: `<svg class="sme-svg" ${_S}><path d="M21 15v4a2 2 0 01-2 2H5a2 2 0 01-2-2v-4"/><polyline points="7 10 12 15 17 10"/><line x1="12" y1="15" x2="12" y2="3"/></svg>`,
        calendar: `<svg class="sme-svg" ${_S}><rect x="3" y="4" width="18" height="18" rx="2" ry="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>`,
        clock: `<svg class="sme-svg" ${_S}><circle cx="12" cy="12" r="10"/><polyline points="12 6 12 12 16 14"/></svg>`,
    };

    // ==================== 工具函数 ====================
    // v1.6.9：通用尾沿节流（trailing debounce）。
    // 用途：高频 input 事件（滑杆/拖拽）触发的重绘 + 持久化。
    // 之前订单簿档数滑杆的 input 事件**无节流**，每派发一次就整块重建订单簿
    // （最多 2×200=400 行）并同步写一次 localStorage；拖动全程约 40 次事件，
    // 实测累计 301.8ms。加 120ms 尾沿节流后拖动期间只重绘 1 次，11.4ms。
    function debounce(fn, delay = 120) {
        let timer = null;
        const wrapped = function (...args) {
            if (timer) clearTimeout(timer);
            timer = setTimeout(() => { timer = null; fn.apply(this, args); }, delay);
        };
        wrapped.cancel = () => { if (timer) { clearTimeout(timer); timer = null; } };
        return wrapped;
    }

    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 === 'text') {
                el.textContent = v;
            } else if (k === 'html') {
                el.innerHTML = v;
            } else if (k.startsWith('on') && typeof v === 'function') {
                el.addEventListener(k.slice(2).toLowerCase(), v);
            } else if (k === 'dataset') {
                Object.assign(el.dataset, v);
            } else if (k === 'disabled' && v) {
                el.setAttribute('disabled', '');
            } else if (k === 'checked' && v) {
                el.setAttribute('checked', '');
            } else {
                el.setAttribute(k, v);
            }
        }
        for (const c of (Array.isArray(children) ? children : [children])) {
            if (c == null || c === false) continue;
            el.appendChild(typeof c === 'string' ? document.createTextNode(c) : c);
        }
        return el;
    }

    function escapeHtml(str) {
        if (str == null) return '';
        const d = document.createElement('div');
        d.textContent = String(str);
        return d.innerHTML;
    }

    // v1.5.0：Toast 由单例改为堆栈。
// 原实现复用同一个 DOM 节点并覆盖 textContent，批量操作（如下架 20 件）时
// 每条限流/成功提示都会顶掉前一条，用户只看到最后一条。
// 现在最多 3 条并存，超出时挤掉最旧的一条。
const _toastStack = [];
const _TOAST_MAX = 3;
const _TOAST_MS = 3000;

    function toast(msg, type = 'info') {
        const el = h('div', { class: 'sme-toast' + (type ? ' sme-' + type : '') });
        el.textContent = msg;
        document.body.appendChild(el);
        _toastStack.push(el);

        const dismiss = () => {
            const idx = _toastStack.indexOf(el);
            if (idx === -1) return;
            _toastStack.splice(idx, 1);
            el.classList.remove('sme-show');
            setTimeout(() => el.remove(), 320);
            _restackToasts();
        };

        // 超过上限：挤掉最旧的一条
        while (_toastStack.length > _TOAST_MAX) {
            const oldest = _toastStack[0];
            const oi = _toastStack.indexOf(oldest);
            if (oi !== -1) _toastStack.splice(oi, 1);
            oldest.classList.remove('sme-show');
            oldest.remove();
        }

        requestAnimationFrame(() => el.classList.add('sme-show'));
        setTimeout(dismiss, _TOAST_MS);
    }

    /** 重排堆叠位置，保证多条 toast 垂直不重叠 */
    function _restackToasts() {
        _toastStack.forEach((el, i) => {
            if (i === 0) el.removeAttribute('data-stack');
            else el.setAttribute('data-stack', String(Math.min(i, 2)));
        });
    }

    const LP = '[SME]';
    function L() { console.log.apply(console, [LP].concat([].slice.call(arguments))); }
    function W() { console.warn.apply(console, [LP].concat([].slice.call(arguments))); }

    // ---- 会话ID获取（6级回退链 + 缓存 + 异步远端兜底）----
    // 参考 steam-market-listings-group 2.6.2 的多级 sessionid 解析方案，
    // 解决新版 Steam SSR 页面可能完全不含 sessionid 的兼容问题。

    /** 从任意文本中提取 sessionid（兼容转义引号、大小写变体）；Steam sessionid 为 8–48 位十六进制串 */
    function extractSessionIdFromText(text) {
        if (!text) return '';
        const patterns = [
            /g_sessionID\s*[:=]\s*\\?\s*["']([0-9a-fA-F]{8,48})\\?["']/,
            /\\?["']g_sessionID\\?["']\s*\\?\s*:\s*\\?["']([0-9a-fA-F]{8,48})\\?["']/,
            /\\?["']session[-_]?id\\?["']\s*\\?\s*:\s*\\?["']([0-9a-fA-F]{8,48})\\?["']/i,
            /name=["']sessionid["']\s+content=["']([0-9a-fA-F]{8,48})["']/i,
        ];
        for (const re of patterns) {
            const m = text.match(re);
            if (m) return m[1];
        }
        return '';
    }

    /** 递归扫描对象树中的 sessionid 字段（含嵌套 JSON 字符串内的转义形式） */
    function findSessionIdInObject(node, depth) {
        if (!node || depth > 8) return '';
        if (typeof node === 'string') {
            return node.length > 20 ? extractSessionIdFromText(node) : '';
        }
        if (typeof node !== 'object') return '';
        if (Array.isArray(node)) {
            for (const v of node) {
                const r = findSessionIdInObject(v, depth + 1);
                if (r) return r;
            }
            return '';
        }
        for (const [k, v] of Object.entries(node)) {
            if (/^session[-_]?id$/i.test(k) && typeof v === 'string' && /^[0-9a-fA-F]{8,48}$/.test(v)) return v;
        }
        for (const v of Object.values(node)) {
            const r = findSessionIdInObject(v, depth + 1);
            if (r) return r;
        }
        return '';
    }

    /** 扫描 SSR 全局对象中的 sessionid */
    function scanSSRForSessionId() {
        try {
            if (unsafeWindow.SSR) {
                return findSessionIdInObject(unsafeWindow.SSR, 0);
            }
        } catch (e) {}
        return '';
    }

    let _sessionIdCache = '';
    /** 同步获取 sessionid：g_sessionID → meta → cookie → SSR深度扫描 → 页面源码正则 → 缓存 */
    function getSessionId() {
        if (_sessionIdCache) return _sessionIdCache;
        let sid = '';
        try { sid = unsafeWindow.g_sessionID || ''; } catch (e) {}
        if (!sid) {
            const meta = document.querySelector('meta[name="sessionid"]');
            if (meta && meta.content) sid = meta.content;
        }
        if (!sid) {
            const m = document.cookie.match(/(^|;\s*)sessionid=([^;]+)/);
            if (m) sid = decodeURIComponent(m[2]);
        }
        if (!sid) sid = scanSSRForSessionId();
        if (!sid) sid = extractSessionIdFromText(getSsrHtmlSnapshot());
        if (sid) _sessionIdCache = sid;
        return sid;
    }

    // v1.5.1 P2-B：SSR HTML 快照缓存——documentElement.innerHTML 全量序列化在主线程耗时数百 ms，
    // 而 sessionid/contextid 等提取目标在页面生命周期内不变，快照一次即可
    let _ssrHtmlCache = null;
    function getSsrHtmlSnapshot() {
        if (_ssrHtmlCache === null) {
            try { _ssrHtmlCache = document.documentElement.innerHTML; } catch (e) { _ssrHtmlCache = ''; }
        }
        return _ssrHtmlCache;
    }

    /** 本地全部落空时拉取其他 Steam 页面提取 sessionid（新版 SSR 页面兜底） */
    async function fetchSessionIdFromRemote() {
        for (const url of ['https://steamcommunity.com/my/inventory', 'https://steamcommunity.com/market/']) {
            try {
                const html = await smeRequest(url, { expect: 'text', onNonOk: 'null' });
                if (!html) continue;
                const sid = extractSessionIdFromText(html);
                if (sid) {
                    L('sessionid resolved via remote fetch:', url);
                    return sid;
                }
            } catch (e) {
                W('sessionid remote fetch failed:', url, e);
            }
        }
        return '';
    }

    /** 异步获取 sessionid：同步本地链 → 异步远端兜底；成功后缓存到会话结束 */
    async function resolveSessionId() {
        let sid = getSessionId();
        if (!sid) {
            sid = await fetchSessionIdFromRemote();
            if (sid) _sessionIdCache = sid;
        }
        if (sid) {
            L('sessionid resolved');
        } else {
            W('sessionid not found via g_sessionID / meta / cookie / SSR scan / page source / remote fetch');
        }
        return sid;
    }

    function getSteamId() {
        try {
            if (unsafeWindow.g_steamID) return String(unsafeWindow.g_steamID);
        } catch (e) {}
        try {
            const scripts = document.querySelectorAll('script');
            for (const s of scripts) {
                const m = (s.textContent || '').match(/g_steamID\s*=\s*["'](\d+)["']/);
                if (m) return m[1];
            }
        } catch (e) {}
        try {
            const link = document.querySelector('a[href*="/profiles/"]');
            if (link) {
                const m = link.href.match(/\/profiles\/(\d+)/);
                if (m) return m[1];
            }
        } catch (e) {}
        return null;
    }

    function tsToDateKey(ts) {
        const d = new Date(ts * 1000);
        return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
    }

    function tsToDateTime(ts) {
        const d = new Date(ts * 1000);
        return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')} ${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}`;
    }

    const MONTH_MAP = { Jan: 0, Feb: 1, Mar: 2, Apr: 3, May: 4, Jun: 5, Jul: 6, Aug: 7, Sep: 8, Oct: 9, Nov: 10, Dec: 11 };
    function parsePriceDate(s) {
        const m = String(s).match(/(\w{3})\s+(\d{2})\s+(\d{4})\s+(\d{2}):\s*\+(\d+)/);
        if (!m) return new Date(s);
        return new Date(parseInt(m[3]), MONTH_MAP[m[1]] || 0, parseInt(m[2]), parseInt(m[4]));
    }

    // ==================== v2.0.0 统一存储层（IndexedDB） ====================
    // 背景（见 docs/market-enhancer-research-2026-11.md §1.3）：
    //   旧版存储是**四轨并存** —— 设置走 GM_getValue、缓存走 localStorage、
    //   池子/比价走 GM、补充包/MR/库存又走 localStorage。
    //   后果：① localStorage 5MB 配额被缓存吃掉并频繁触发 QuotaExceededError
    //        ② GM 侧无容量管理，池子日快照可能静默撑爆配额
    //        ③ 无 schema / 无版本，换存储格式无从谈起
    // 现在统一到 IndexedDB：
    //   · db `sme_store` v1，三个 object store：
    //       settings —— 键值设置（迁移自 GM_getValue）
    //       cache    —— 带 TTL 的缓存条目（迁移自 localStorage 的 sme_cache_*）
    //       kv       —— 通用 KV（迁移自 localStorage / GM 的其余键）
    //   · 读：**内存镜像优先**（同步），保证 settings.get / cache.get 的同步语义不变
    //   · 写：内存同步 + IndexedDB 异步落盘（write-behind），不阻塞 UI
    //   · 兜底：IndexedDB 不可用（隐私模式 / 老浏览器）→ 自动退回 GM + localStorage，功能不挂
    const SME_IDB_NAME = 'sme_store';
    const SME_IDB_VERSION = 1;
    const SME_STORE_SETTINGS = 'settings';
    const SME_STORE_CACHE = 'cache';
    const SME_STORE_KV = 'kv';
    const SME_IDB_MIGRATED_KEY = '__sme_migrated_v1';
    // GM 侧的静态遗留键（迁移到 kv store 后即可不再写 GM）
    const SME_LEGACY_GM_KEYS = ['sme_pool_items_v1', 'sme_pool_series_v1', 'sme_ratio_quotes_v1'];

    const smeStore = {
        db: null,
        ready: false,
        failed: false,
        mem: {
            settings: new Map(),
            cache: new Map(),
            kv: new Map(),
        },

        /** 打开数据库；失败时置 failed=true，调用方自动退回旧存储 */
        async open() {
            if (this.ready) return this.db;
            if (this.failed) return null;
            if (typeof indexedDB === 'undefined') { this.failed = true; return null; }
            try {
                this.db = await new Promise((resolve, reject) => {
                    let req;
                    try { req = indexedDB.open(SME_IDB_NAME, SME_IDB_VERSION); }
                    catch (e) { reject(e); return; }
                    req.onupgradeneeded = () => {
                        const db = req.result;
                        for (const name of [SME_STORE_SETTINGS, SME_STORE_CACHE, SME_STORE_KV]) {
                            if (!db.objectStoreNames.contains(name)) {
                                db.createObjectStore(name, { keyPath: 'k' });
                            }
                        }
                    };
                    req.onsuccess = () => resolve(req.result);
                    req.onerror = () => reject(req.error || new Error('IndexedDB open failed'));
                    req.onblocked = () => reject(new Error('IndexedDB blocked'));
                });
                this.db.onversionchange = () => { try { this.db.close(); } catch (e) {} this.db = null; this.ready = false; };
                this.ready = true;
                return this.db;
            } catch (e) {
                W('IndexedDB 不可用，退回旧存储:', e && e.message);
                this.failed = true;
                this.db = null;
                return null;
            }
        },

        _tx(store, mode) {
            if (!this.db) return null;
            try {
                return this.db.transaction(store, mode).objectStore(store);
            } catch (e) { return null; }
        },

        /** 读（异步）；命中内存镜像时直接返回 */
        async get(store, key, fallback) {
            const m = this.mem[store];
            if (m && m.has(key)) return m.get(key);
            const os = this._tx(store, 'readonly');
            if (!os) return fallback;
            try {
                const val = await new Promise((resolve, reject) => {
                    const req = os.get(key);
                    req.onsuccess = () => resolve(req.result);
                    req.onerror = () => reject(req.error);
                });
                if (val && typeof val === 'object' && 'v' in val) {
                    if (m) m.set(key, val.v);
                    return val.v;
                }
                return fallback;
            } catch (e) {
                return fallback;
            }
        },

        /** 写（内存同步 + IndexedDB 异步落盘） */
        async set(store, key, value) {
            const m = this.mem[store];
            if (m) m.set(key, value);
            const os = this._tx(store, 'readwrite');
            if (!os) return false;
            try {
                await new Promise((resolve, reject) => {
                    const req = os.put({ k: key, v: value });
                    req.onsuccess = () => resolve();
                    req.onerror = () => reject(req.error);
                });
                return true;
            } catch (e) {
                W('IndexedDB 写入失败:', store, key, e && e.message);
                return false;
            }
        },

        async del(store, key) {
            const m = this.mem[store];
            if (m) m.delete(key);
            const os = this._tx(store, 'readwrite');
            if (!os) return false;
            try {
                await new Promise((resolve, reject) => {
                    const req = os.delete(key);
                    req.onsuccess = () => resolve();
                    req.onerror = () => reject(req.error);
                });
                return true;
            } catch (e) { return false; }
        },

        async keys(store) {
            const os = this._tx(store, 'readonly');
            if (!os) return [];
            try {
                return await new Promise((resolve, reject) => {
                    const req = os.getAllKeys();
                    req.onsuccess = () => resolve(req.result || []);
                    req.onerror = () => reject(req.error);
                });
            } catch (e) { return []; }
        },

        async getAll(store) {
            const os = this._tx(store, 'readonly');
            if (!os) return [];
            try {
                return await new Promise((resolve, reject) => {
                    const req = os.getAll();
                    req.onsuccess = () => resolve(req.result || []);
                    req.onerror = () => reject(req.error);
                });
            } catch (e) { return []; }
        },

        async clear(store) {
            const m = this.mem[store];
            if (m) m.clear();
            const os = this._tx(store, 'readwrite');
            if (!os) return false;
            try {
                await new Promise((resolve, reject) => {
                    const req = os.clear();
                    req.onsuccess = () => resolve();
                    req.onerror = () => reject(req.error);
                });
                return true;
            } catch (e) { return false; }
        },

        /** 把某个 store 的全部内容灌进内存镜像（启动时一次性 hydrate） */
        async hydrate(store) {
            const rows = await this.getAll(store);
            const m = this.mem[store];
            if (!m) return 0;
            for (const r of rows) {
                if (r && typeof r === 'object' && 'k' in r) m.set(r.k, r.v);
            }
            return rows.length;
        },
    };

    /**
     * 一次性迁移：GM 设置 + localStorage 的 sme_* 键 → IndexedDB。
     * 幂等：靠 kv 里的 __sme_migrated_v1 标记；迁移成功后**不删**旧数据
     *（保留回滚余地，也让老版本脚本仍能读到）。
     */
    async function smeMigrateToIdb(defaults) {
        if (smeStore.failed) return false;
        const db = await smeStore.open();
        if (!db) return false;
        try {
            const done = await smeStore.get(SME_STORE_KV, SME_IDB_MIGRATED_KEY, null);
            if (done) return true;
            // 1) 设置：GM → settings
            for (const key of Object.keys(defaults)) {
                const gmKey = 'sme_' + key;
                let val;
                try { val = GM_getValue(gmKey, undefined); } catch (e) { val = undefined; }
                if (val === undefined) continue;
                await smeStore.set(SME_STORE_SETTINGS, gmKey, val);
            }
            // 2) localStorage 的 sme_* 键 → cache / kv
            let lsKeys = [];
            try { lsKeys = Object.keys(localStorage); } catch (e) {}
            for (const k of lsKeys) {
                if (!k.startsWith('sme_')) continue;
                let raw = null;
                try { raw = localStorage.getItem(k); } catch (e) {}
                if (raw == null) continue;
                if (k.startsWith('sme_cache_')) {
                    try {
                        const entry = JSON.parse(raw);
                        if (entry && typeof entry === 'object' && 'ts' in entry) {
                            await smeStore.set(SME_STORE_CACHE, k.slice('sme_cache_'.length), entry);
                            continue;
                        }
                    } catch (e) { /* 非结构化 → 落 kv */ }
                }
                await smeStore.set(SME_STORE_KV, k, raw);
            }
            // 2b) GM 侧的静态遗留键（池子条目/日快照、比价结果）→ kv
            //     注：GM 没有 listValues 授权，无法枚举全部键；
            //     动态键（如按 appid 的比价索引）走**惰性回退**读取。
            for (const legacyKey of SME_LEGACY_GM_KEYS) {
                let val = null;
                try { val = GM_getValue(legacyKey, null); } catch (e) { val = null; }
                if (val == null) continue;
                await smeStore.set(SME_STORE_KV, legacyKey, typeof val === 'string' ? val : JSON.stringify(val));
            }
            await smeStore.set(SME_STORE_KV, SME_IDB_MIGRATED_KEY, Date.now());
            L('IndexedDB 迁移完成');
            return true;
        } catch (e) {
            W('IndexedDB 迁移失败（保留旧存储继续工作）:', e && e.message);
            return false;
        }
    }

    /**
     * 通用 KV（IndexedDB 的 kv store）。
     * 值统一按**字符串**存（与旧 localStorage 语义一致，避免各处再各自 JSON 化）。
     * IndexedDB 不可用时自动退回 localStorage → 功能不挂。
     */
    const smeKv = {
        async get(key, fallback) {
            if (smeStore.ready) {
                try {
                    const v = await smeStore.get(SME_STORE_KV, key, undefined);
                    if (v !== undefined && v !== null) return v;
                } catch (e) { /* 落到 localStorage */ }
            }
            try {
                const raw = localStorage.getItem(key);
                return raw == null ? fallback : raw;
            } catch (e) { return fallback; }
        },
        async set(key, value) {
            if (smeStore.ready) {
                try { await smeStore.set(SME_STORE_KV, key, value); return; } catch (e) { /* 落到 localStorage */ }
            }
            try { localStorage.setItem(key, value); } catch (e) { W('KV 写入失败:', key); }
        },
        async remove(key) {
            if (smeStore.ready) {
                try { await smeStore.del(SME_STORE_KV, key); } catch (e) { /* ignore */ }
            }
            try { localStorage.removeItem(key); } catch (e) {}
        },
        /**
         * 同步读（只读内存镜像 + localStorage 兜底），**不发请求**。
         *
         * v2.2.1 修：v2.0.0 从 localStorage 迁到 IndexedDB 时漏了这个方法，
         * 7 处调用（库存缓存 / 库存价格标签 / 市场排名 / 补充包 3 处 / 封面缓存）
         * 全被 try/catch 吞掉 → 表现为「只写不读」：数据确实存进了 IndexedDB，
         * 但每次开页面都读不回来，功能从零开始。
         *
         * 内存镜像靠 init 时的 `smeStore.hydrate(SME_STORE_KV)` 填充
         * （smeStore.set 也会同步写 mem，所以同一次会话内写完即可读）。
         */
        getSync(key, fallback) {
            const m = smeStore.mem.kv;
            if (m && m.has(key)) {
                const v = m.get(key);
                if (v !== undefined && v !== null) return v;
            }
            try {
                const raw = localStorage.getItem(key);
                return raw == null ? fallback : raw;
            } catch (e) { return fallback; }
        },
    };

    // ==================== 设置管理 ====================
    const settings = {
        _defaults: {
            ownedBadges: true,
            autoLoadHistory: true,
            historyRange: '30d',
            priceAlgorithm: 1,      // 1=max(历史均价,最低卖单) 2=最低卖单 3=最高买单或最低卖单 4=历史均价
            priceOffset: 0,          // 价格偏移（本地货币单位，可为负）
            historyHours: 12,        // 历史均价计算窗口（小时）
            ignoreLowQuantity: true, // 最低价挂单数量过低时使用第二低价
            autoCheckPrices: true,   // 进入汇总页自动检测价格
            minPrice: 0.03,          // 最低上架价格
            maxPrice: 999,           // 最高上架价格
            // v1.3.0 新增：库存页
            inventoryPriceLabels: true,  // 库存页价格标签
            quickSellButtons: true,      // 快速出售按钮
            // v1.3.0 新增：市场我的挂单页
            marketBatchButtons: true,    // 批量操作按钮
            marketSorting: true,         // 排序功能
            marketSearch: true,          // 搜索过滤
            // v1.3.0 新增：物品类型差异化定价
            minMiscPrice: 0.05,    maxMiscPrice: 10,      // 杂项物品
            minNormalCardPrice: 0.05, maxNormalCardPrice: 2.50,  // 普通卡牌
            minFoilCardPrice: 0.15, maxFoilCardPrice: 10,        // 闪箔卡牌
            // v1.3.0 新增：交易报价
            tradeOfferSummary: true,     // 交易报价价值摘要
            // v1.4.5 新增：自主定价
            priceBypass: true,           // 启用自主定价（突破价格限制）
            defaultPriceMode: 'instant', // 默认定价模式 instant/undercut/match/custom_buyer/custom_received
            // v1.4.6 新增：我的挂单市场顺序跟踪
            marketRankTracker: true,     // 物品页展示我的挂单市场顺序
            rankAutoRefresh: true,       // 自动刷新顺序（跟踪售出变化）
            rankRefreshInterval: 60,     // 刷新间隔（秒）
            // v1.4.7 新增：订单深度增强
            orderDepthLevels: 30,        // 订单深度默认显示档数
            orderDepthShowNet: true,     // 显示税后到手列
            orderDepthShowCumulative: true, // 显示累计列
            orderDepthShowCny: true,     // 外币钱包时额外显示 CNY 税后到手列
            // v1.4.9 新增：参考货币换算
            referenceCurrency: 'CNY',    // 参考货币代码（ISO 4217），默认人民币
            showReferencePrice: true,    // 在市场价格旁显示参考货币价格
            // v1.5.0 新增：市场物品页显示更多价格（新版 React 市场页）
            showMorePrices: true,        // 订单表格显示更多价格行（默认 6 行 → 更多）
            showMorePricesRows: 20,      // 显示行数（6-100）
            // v1.6.0 新增：市场交易记录汇总与导出
            marketHistoryPanel: true,      // 在"出售物品"旁显示汇总/导出工具条
            marketHistoryFormat: 'csv',    // 导出格式 csv | tsv | json | md
            marketHistoryPageSize: 100,    // 每页抓取条数（Steam 单页硬上限 100）
            marketHistoryDelay: 700,       // 翻页请求间隔（毫秒），过小易触发限流
            marketHistoryTopN: 20,         // 汇总榜单展示条目数
            // v1.6.4 新增：隐藏官方 Beta 公告条
            hideMarketBetaNote: true,
            // v2.0.0 新增：价格提醒
            priceAlerts: true,           // 详情页「价格提醒」按钮
            priceAlertDropPct: 0.1,     // 默认跌幅阈值（10%）
            priceAlertNotify: true,      // 同时发浏览器通知
            // v1.7.0 新增：我的池子行情
            poolPanel: true,          // 市场页显示「池子行情」工具条
            poolAutoTrack: true,      // 浏览市场时自动收录物品进池子
            poolWindow: '30d',        // 池子行情默认时间窗口
            poolMaxItems: 300,        // 池子容量上限
            // v1.9.0 新增：跨平台挂刀比价
            crossPlatformQuote: true,     // 详情页「挂刀比价」标签页（仅 CS2/DOTA2）
            crossPlatformAutoExpand: false, // 打开面板后自动后台加载比价数据（默认点开才请求）
            platformFeeFactor: 0.85,      // 平台扣费系数（平台到手 ≈ 平台价 × 系数）
            poolRatioScan: false,         // 池子明细「挂刀」列与手动扫描（默认关）
            // v2.0.2：汇率报价参考。buffFee 只扣 BUFF 卖出手续费，与上面的 0.85 不是一回事。
            fxqBuffFee: 0.025,
            fxqCards: [],
            fxqBadge: true,
            fxqCaseLang: 'zh',       // 箱子列表展示名：zh 中文（默认）| en 英文市场名
            // 浏览器：inline 顶部内嵌，float 底部浮窗。Steam 客户端忽略此项，固定浮窗。
            listingPanelMode: 'inline',
        },
        // v1.5.1 P1-B：内存缓存。设置在 MutationObserver 回调里高频调用，
        //   逐次跨脚本边界读取浪费；首次读取后驻留内存，set 时同步更新。
        // v2.0.0：存储统一到 IndexedDB —— 读仍是**同步**（内存镜像），
        //   写是「内存同步 + IndexedDB 异步落盘」；IndexedDB 不可用时退回 GM。
        _mem: {},
        _ready: false,

        /** 启动时调用：迁移旧存储 → IndexedDB，并把设置灌进内存镜像 */
        async init() {
            if (this._ready) return;
            try {
                await smeMigrateToIdb(this._defaults);
                await smeStore.hydrate(SME_STORE_SETTINGS);
                for (const [k, v] of smeStore.mem.settings) {
                    if (typeof k === 'string' && k.startsWith('sme_')) this._mem[k.slice(4)] = v;
                }
                // v2.2.1：kv store 的内存镜像 —— smeKv.getSync 的数据来源。
                // 不 hydrate 的话 getSync 永远读不到（v2.0.0 迁 IndexedDB 时漏了）。
                await smeStore.hydrate(SME_STORE_KV);
            } catch (e) {
                W('设置初始化失败，退回 GM 存储:', e && e.message);
            }
            // v2.2.5：升级后第一次启动时把「常驻汇率徽标」恢复为开启。
            // 旧版这个开关只有高亮/不高亮，用户很容易误点关掉后以为「徽标坏了」；
            // 只纠正一次，之后用户再关就尊重用户选择。
            try {
                if (GM_getValue('sme_fxqBadgeV225', false) !== true) {
                    if (this.get('fxqBadge') === false) this.set('fxqBadge', true);
                    GM_setValue('sme_fxqBadgeV225', true);
                }
            } catch (e) {}
            this._ready = true;
        },

        get(key) {
            if (key in this._mem) return this._mem[key];
            const gmKey = 'sme_' + key;
            // 优先 IndexedDB 镜像（init 时已 hydrate），退 GM
            let v = smeStore.mem.settings.get(gmKey);
            if (v === undefined) {
                try { v = GM_getValue(gmKey, this._defaults[key]); }
                catch (e) { v = this._defaults[key]; }
            }
            this._mem[key] = v;
            return v;
        },
        set(key, val) {
            const gmKey = 'sme_' + key;
            this._mem[key] = val;
            // ★ 同步镜像：GM 写一份。
            //   原因：插件 @run-at document-start，「显示更多价格」要在 react-dom 初始化前
            //   同步读到设置 —— 那时 IndexedDB 还没 hydrate 完，只有 GM 能同步读到。
            //   GM 侧设置量极小（几十个键值），不占配额；IndexedDB 仍是**持久化主存储**。
            try { GM_setValue(gmKey, val); } catch (e) {}
            if (smeStore.ready) smeStore.set(SME_STORE_SETTINGS, gmKey, val).catch(() => {});
        },
    };

    // ==================== 缓存管理（v2.0.0：IndexedDB 后端） ====================
    // v1.5.0：QuotaExceededError 不再静默失败。
    //   原实现 catch(e){} 直接吞掉配额超限，导致用户浏览一段时间后缓存无声失效
    //   （表现：明明设了 30 分钟 TTL，价格历史却一直不更新），只能手动清缓存恢复。
    // v1.9.1 修复：旧版 _handleCacheQuota 的大小判断写反。
    // v2.0.0：整体迁到 IndexedDB —— localStorage 只有 5MB 且按 UTF-16 计半字节配额，
    //   是这个插件最大的存储痛点；IndexedDB 无此限制，且能存结构化对象（免去
    //   JSON 序列化往返）。读仍是**同步**（内存 LRU 热层），写是异步落盘。
    //
    // 结构：_mem 是 Map<key, {ts, data, bytes}>，Map 迭代序 = 插入序，
    //       get 命中时移到尾部 → 天然 LRU。
    const CACHE_MAX_BYTES = 4 * 1024 * 1024;
    // v2.2.1：单条目上限从 512KB 提到 2MB。
    // 原值下「市场交易记录」缓存（约 200 字节/条，2000~3500 条即 400~700KB）
    // 会被 cache.set **静默丢弃** —— 交易活跃的用户每次开面板都得从头重抓，
    // 「断点 7 天 TTL」形同虚设。总预算仍是 4MB（LRU 淘汰照旧），只是允许
    // 单条占更多 —— 交易记录本来就比其它缓存更值得留着。
    const CACHE_MAX_ITEM_BYTES = 2 * 1024 * 1024;

    const cache = {
        _mem: new Map(),      // key → {ts, data, bytes}
        _inflight: new Map(), // key → Promise（同 key 并发请求去重）
        _totalBytes: 0,

        /** 启动时调用：把 IndexedDB 里的缓存灌进内存热层 */
        async init() {
            try {
                const rows = await smeStore.getAll(SME_STORE_CACHE);
                for (const r of rows) {
                    if (!r || typeof r !== 'object' || !('k' in r)) continue;
                    const entry = r.v;
                    if (!entry || typeof entry !== 'object' || !('ts' in entry)) continue;
                    // v2.2.1：优先用落盘时算好的 bytes；老条目（v2.2.1 之前写的）没有才现算。
                    const bytes = (typeof entry.bytes === 'number' && entry.bytes > 0)
                        ? entry.bytes
                        : this._estimate({ ts: entry.ts, data: entry.data });
                    this._mem.set(r.k, { ts: entry.ts, data: entry.data, bytes: bytes });
                    this._totalBytes += bytes;
                }
                this._evict();
                L('缓存已从 IndexedDB 载入:', this._mem.size, '条 /', this._totalBytes, '字节');
            } catch (e) {
                W('缓存载入失败:', e && e.message);
            }
        },

        _estimate(entry) {
            try { return JSON.stringify(entry).length; }
            catch (e) { return 0; }
        },

        get(key, ttl) {
            const hit = this._mem.get(key);
            if (!hit) return null;
            if (Date.now() - hit.ts > ttl) { this._remove(key); return null; }
            // LRU touch：命中后移到尾部
            this._mem.delete(key);
            this._mem.set(key, hit);
            return hit.data;
        },

        set(key, data) {
            const ts = Date.now();
            const bytes = this._estimate({ ts: ts, data: data });
            if (bytes >= CACHE_MAX_ITEM_BYTES) {
                // v2.2.1：原来这里是静默 _remove + return，条目直接人间蒸发，
                // 现场表现为「缓存好像没生效」但没有任何线索。现在必须告警。
                W('缓存条目过大，已丢弃:', key, Math.round(bytes / 1024), 'KB >', Math.round(CACHE_MAX_ITEM_BYTES / 1024), 'KB');
                this._remove(key);
                return;
            }
            const old = this._mem.get(key);
            if (old) this._totalBytes -= old.bytes;
            this._mem.delete(key);
            this._mem.set(key, { ts: ts, data: data, bytes: bytes });
            this._totalBytes += bytes;
            this._evict();
            // 异步落盘（不阻塞 UI）。
            // v2.2.1：连算好的 bytes 一起存 —— 启动时 cache.init 就不用对每条
            // 再 JSON.stringify 一遍（最坏情况 4MB 内容在主线程同步序列化）。
            smeStore.set(SME_STORE_CACHE, key, { ts: ts, data: data, bytes: bytes }).catch(() => {});
        },

        _remove(key) {
            const old = this._mem.get(key);
            if (!old) return;
            this._totalBytes -= old.bytes;
            this._mem.delete(key);
            smeStore.del(SME_STORE_CACHE, key).catch(() => {});
        },

        /** LRU 淘汰：总量超过 4MB 时从最旧条目开始清理 */
        _evict() {
            if (this._totalBytes <= CACHE_MAX_BYTES) return;
            for (const [k, v] of this._mem) {
                if (this._totalBytes <= CACHE_MAX_BYTES) break;
                this._totalBytes -= v.bytes;
                this._mem.delete(k);
                smeStore.del(SME_STORE_CACHE, k).catch(() => {});
            }
            W('缓存总量超过 4MB，已按 LRU 淘汰最旧条目');
        },

        /** in-flight 去重：同 key 并发调用共享同一 Promise，消除 TTL 到期瞬间的并发穿透 */
        inflight(key, factory) {
            if (this._inflight.has(key)) return this._inflight.get(key);
            const p = Promise.resolve().then(factory).finally(() => this._inflight.delete(key));
            this._inflight.set(key, p);
            return p;
        },

        async clear() {
            this._mem.clear();
            this._totalBytes = 0;
            this._inflight.clear();
            await smeStore.clear(SME_STORE_CACHE);
        },

        /** 诊断：当前缓存统计 */
        stats() {
            return { count: this._mem.size, bytes: this._totalBytes };
        },
    };

    // ==================== 库存缓存（按 SteamID 分离，v2.0.0：改走 IndexedDB） ====================
    // 原实现：localStorage 存 Map 序列化 + sessionStorage 判会话。
    // v2.0.0：落盘改走 IndexedDB 的 kv store（localStorage 5MB 配额是本插件最大痛点）；
    //   会话判定仍用 sessionStorage（浏览器关闭即清，语义不变）。
    const invCache = {};        // { "appid_ctxid_fmt": { ts, data: Map<market_hash_name, count> | null } }
    const invPending = {};      // { "appid_ctxid_fmt": Promise }
    const jsonFallbackDone = {}; // 追踪 json 格式降级尝试，避免逐条触发
    const SESSION_KEY = 'sme_inv_sess';

    /** 检测浏览器新会话：sessionStorage 在浏览器关闭时自动清除 */
    function isFreshSession() {
        try { return sessionStorage.getItem(SESSION_KEY) === null; }
        catch (e) { return true; }
    }

    /** 标记会话已激活（刷新页面后保留，浏览器关闭后自动清除） */
    function markSession() {
        try { sessionStorage.setItem(SESSION_KEY, '1'); } catch (e) {}
    }

    /** 从存储恢复缓存（正确反序列化 Map 对象） */
    function loadInvCache(sid) {
        try {
            const raw = smeKv.getSync('sme_inv_' + sid, null);
            if (!raw) return;
            const obj = JSON.parse(raw);
            // v2.2.1：恢复交易冷却限制表（缓存命中时不会重新解析库存响应，
            // 不恢复的话 invCooldownInfo 拿不到天数 → 冷却角标只在触网那次显示）。
            // 只补缺的不覆盖 —— 真实响应解析出来的更权威。
            if (obj.restrictions && Array.isArray(obj.restrictions)) {
                for (const entry of obj.restrictions) {
                    if (!Array.isArray(entry) || entry.length < 2) continue;
                    const name = entry[0];
                    const rule = entry[1];
                    if (name && rule && !invRestrictions.has(name)) {
                        invRestrictions.set(name, {
                            marketableDays: Number(rule.marketableDays) || 0,
                            tradableDays: Number(rule.tradableDays) || 0,
                        });
                    }
                }
            }
            for (const key in obj) {
                if (key === 'restrictions') continue;   // 限制表不是库存条目
                if (obj[key] && Array.isArray(obj[key].data)) {
                    invCache[key] = { ts: obj[key].ts, data: new Map(obj[key].data) };
                } else if (obj[key] && obj[key].data === null) {
                    invCache[key] = { ts: obj[key].ts, data: null };
                }
            }
            L('Loaded persisted inventory cache:', Object.keys(invCache).length, 'entries');
        } catch (e) {
            L('Failed to load persisted inventory cache:', e.message);
        }
    }

    /** 保存缓存（防抖 200ms，正确序列化 Map 对象） */
    let _invSaveTimer = null;
    function saveInvCache(sid) {
        if (_invSaveTimer) clearTimeout(_invSaveTimer);
        _invSaveTimer = setTimeout(() => {
            try {
                // v2.2.1：交易冷却限制表（market_hash_name → 天数）一起落盘。
                // 它只在**解析库存网络响应**时填充（collectInventoryRestrictions），
                // 缓存命中时不会重新解析 → invRestrictions 空 → invCooldownInfo 返回 null
                // → 冷却角标只在「真正触网的那次」显示，刷新一下就没了。
                const obj = { restrictions: Array.from(invRestrictions.entries()) };
                for (const key in invCache) {
                    if (invCache[key] && invCache[key].data instanceof Map) {
                        obj[key] = { ts: invCache[key].ts, data: Array.from(invCache[key].data.entries()) };
                    } else if (invCache[key]) {
                        obj[key] = { ts: invCache[key].ts, data: null };
                    }
                }
                smeKv.set('sme_inv_' + sid, JSON.stringify(obj)).catch(() => {});
            } catch (e) {
                L('Failed to persist inventory cache:', e.message);
            }
            _invSaveTimer = null;
        }, 200);
    }

    /** 清除指定 SteamID 的库存缓存 */
    function clearInvCache(sid) {
        smeKv.remove('sme_inv_' + sid).catch(() => {});
    }

    /** 会话级缓存加载：新会话清除过期缓存，相同会话从存储恢复 */
    function loadCacheForSession(sid) {
        if (isFreshSession()) {
            L('Fresh browser session, clearing stale inventory cache');
            clearInvCache(sid);
            markSession();
        } else {
            loadInvCache(sid);
            L('Same browser session, restored inventory cache from storage');
        }
    }

    /** 写入内存缓存并触发持久化保存 */
    function writeInvCache(key, data, sid) {
        invCache[key] = { ts: Date.now(), data };
        if (sid) saveInvCache(sid);
    }

    /**
     * 当前页面需要预热哪些库存 → [[appid, ctxId], ...]
     * v2.2.1：按页面类型取当前 appid，不再无脑拉 5 个游戏的库存。
     */
    function invWarmTargets() {
        let appid = null;
        try {
            const page = detectPageType();
            if (page === 'listing') {
                const li = getListingInfo();
                appid = li && li.appid ? String(li.appid) : null;
            } else if (page === 'inventory') {
                const inv = unsafeWindow.g_ActiveInventory;
                if (inv) appid = String(inv.m_appid || inv.appid || '') || null;
            }
        } catch (e) { appid = null; }
        if (!appid || !/^\d+$/.test(appid)) return [];
        return [[appid, APP_CONTEXT[appid] || '2']];
    }

    /**
     * v2.0.1：后台预热库存限制数据（每个会话一次）。
     * 目的：市场物品页要显示「该物品是否还在冷却期」，需要 Steam 自己给的限制天数，
     *   而那只在**用户自己的库存**里 → 需要拉一次库存（走库存限流通道，后台不阻塞 UI）。
     *
     * v2.2.1：只预热**当前页面相关**的库存。
     *   原实现固定拉 730/2、730/6、570/2、440/2、753/6 五个库存（每个最多 2000 件、
     *   还可能分页），跟当前看的游戏毫无关系 —— 纯浪费请求配额，还更容易撞 Steam 限流。
     *   现在按页面类型取当前 appid；取不到就不预热（宁可角标晚点出现，也别打 5 次无用请求）。
     */
    let _invRestrictionsWarm = false;
    function ensureInvRestrictionsWarm() {
        if (_invRestrictionsWarm) return;
        _invRestrictionsWarm = true;
        const sid = getSteamId();
        if (!sid) return;
        const pairs = invWarmTargets();
        if (!pairs.length) return;
        (async () => {
            for (const [appid, ctxId] of pairs) {
                try {
                    await enqueueInv(() => fetchInventory(appid, ctxId, INVENTORY_COUNT, 'default'));
                } catch (e) { /* 失败不影响其它 appid */ }
            }
            // 预热完成后，若面板在位则刷新冷却提示
            if (panelEl) {
                const notice = panelEl.querySelector('.sme-cooldown-notice');
                if (!notice) {
                    const fresh = createPanel();
                    if (fresh && fresh.parentElement) {
                        // 面板已存在 → 只补提示，不整体重建（避免丢失 Tab 状态）
                        const li = getListingInfo();
                        const info = li && li.marketHashName ? invCooldownInfo(li.marketHashName) : null;
                        if (info) {
                            const el = h('div', {
                                class: 'sme-cooldown-notice',
                                html: ICONS.alert + '<span>该物品仍在交易冷却期：' + info.daysLeft + ' 天后（'
                                    + mhFmtTs(info.untilTs).slice(0, 16) + '）才能上架或交易</span>',
                            });
                            const content = panelEl.querySelector('.sme-content');
                            if (content) content.parentElement.insertBefore(el, content);
                        }
                    }
                }
            }
        })().catch(() => {});
    }

    /**
     * v2.0.1：某个物品当前的冷却状态（**不触网**）。
     * 依赖两样本地数据：
     *   ① Steam 自己给的限制天数（inventory API 的 descriptions[]）→ invRestrictions
     *   ② 获得时间（市场买入时间，来自本地已索引的成交记录）→ 成本基准
     * 两样缺一不可：只有限制天数而没有获得时间，无法判断是否仍在冷却期
     * （老物品也会显示 7 天的类级限制值），此时**不显示角标**，避免满屏误报。
     *
     * @param {string} name market_hash_name
     * @returns {{daysLeft:number, untilTs:number, days:number}|null}
     */
    function invCooldownInfo(name) {
        if (!name) return null;
        const rule = invRestrictions.get(name);
        if (!rule) return null;
        const days = rule.marketableDays || rule.tradableDays || 0;
        if (days <= 0) return null;
        if (!mhState.rows || !mhState.rows.length) return null;   // 没有成交记录 → 无法判断
        const cb = _invCooldownBasis();
        if (!cb) return null;
        let hold = null;
        for (const h of cb.holdings) { if (h.name === name) { hold = h; break; } }
        if (!hold || !hold.newestTs) return null;
        const untilTs = hold.newestTs + days * 86400000;
        const daysLeft = Math.ceil((untilTs - Date.now()) / 86400000);
        if (daysLeft <= 0) return null;
        return { daysLeft: daysLeft, untilTs: untilTs, days: days };
    }

    /** 成本基准的轻量缓存（按成交记录条数失效） */
    let _invCooldownBasisCache = { rowsLen: -1, value: null };
    function _invCooldownBasis() {
        const len = (mhState.rows || []).length;
        if (_invCooldownBasisCache.rowsLen === len) return _invCooldownBasisCache.value;
        const value = smeCostBasis(mhState.rows || [], { netOf: (c) => priceBeforeFees(c) });
        _invCooldownBasisCache = { rowsLen: len, value: value };
        return value;
    }

    /**
     * v2.0.1：汇总用户当前**可市场物品**的持仓（名称 → 件数 + 冷却规则）。
     * 数据源：社区库存 API（复用 fetchInventory 的分页/缓存/限流），再合并限制天数。
     * @param {Array} pairs [[appid, ctxId], ...]
     * @returns {Promise<Array<{name, qty, marketableDays, tradableDays}>>}
     */
    async function fetchInventoryHoldings(pairs) {
        const sid = getSteamId();
        if (!sid) return [];
        const merged = new Map();
        const list = (pairs && pairs.length) ? pairs : [
            ['730', '2'], ['730', '6'], ['570', '2'], ['440', '2'], ['753', '6'],
        ];
        for (const [appid, ctxId] of list) {
            let owned = null;
            try {
                owned = await enqueueInv(() => fetchInventory(appid, ctxId, INVENTORY_COUNT, 'default'));
            } catch (e) { owned = null; }
            if (!owned || !(owned instanceof Map)) continue;
            for (const [name, qty] of owned) {
                const rule = invRestrictions.get(name);
                const prev = merged.get(name);
                if (prev) {
                    prev.qty += qty;
                    // 冷却天数取各 appid 中的最大值（保守）
                    if (rule) {
                        prev.marketableDays = Math.max(prev.marketableDays, rule.marketableDays || 0);
                        prev.tradableDays = Math.max(prev.tradableDays, rule.tradableDays || 0);
                    }
                } else {
                    merged.set(name, {
                        name: name,
                        qty: qty,
                        marketableDays: rule ? (rule.marketableDays || 0) : 0,
                        tradableDays: rule ? (rule.tradableDays || 0) : 0,
                    });
                }
            }
        }
        return Array.from(merged.values()).sort((a, b) => b.qty - a.qty);
    }

    // ==================== 统一限流调度器（v1.5.1 P1-A 深化） ====================
    // 此前 4 套限流器（库存串行队列 600ms / 库存页价格串行队列 1000ms / MR 时间窗+冷却 /
    // 批量操作裸 sleep）互不感知，同时活跃时叠加请求量可能超过 Steam 会话限流阈值。
    // 现收敛为单一调度器：
    //   1. 每个通道保留各自节奏策略（行为兼容），实现归一；
    //   2. 新增全局跨通道记账窗口：62s 内所有通道合计不超过 SME_GLOBAL_MAX 次带凭据请求，
    //      作为多模块并发时的安全网（单通道正常使用远低于该上限，无可感知变慢）。
    const SME_GLOBAL_WINDOW = 62000;
    const SME_GLOBAL_MAX = 100;   // ≈1.6 req/s，正常浏览不会触达

    const smeGlobalTs = [];
    function smeGlobalTrim(now) {
        while (smeGlobalTs.length && now - smeGlobalTs[0] > SME_GLOBAL_WINDOW) smeGlobalTs.shift();
    }

    class SmeRateChannel {
        /**
         * @param {string} name 通道名（日志用）
         * @param {object} opt
         *   gapAfter:  任务完成后到下一任务放行的节流间隔 ms（兼容旧"完成后 sleep"队列语义；
         *              当前调用者的 Promise 不被延迟）
         *   gapBefore: 距上次放行的最小间隔 ms（对应旧"起止间隔"语义）
         *   window/max: 本通道滑动窗口限速（不传则不限）
         */
        constructor(name, opt) {
            opt = opt || {};
            this.name = name;
            this.gapAfter = opt.gapAfter || 0;
            this.gapBefore = opt.gapBefore || 0;
            this.window = opt.window || 0;
            this.max = opt.max || Infinity;
            this.ts = [];
            this.last = 0;
            this.tail = Promise.resolve();
        }
        _trim(now) {
            if (!this.window) return;
            while (this.ts.length && now - this.ts[0] > this.window) this.ts.shift();
        }
        /** 预订一个名额：窗口饱和时等待；cancel() 返回 false 则中止（返回 null） */
        async acquire(cancel) {
            for (;;) {
                if (cancel && !cancel()) return null;
                const now = Date.now();
                this._trim(now);
                if (this.ts.length >= this.max) {
                    const wait = this.ts[0] + this.window - now + 100;
                    L(this.name + ': 通道窗口限速，等待 ' + Math.ceil(wait / 1000) + 's');
                    await sleep(Math.min(15000, wait));
                    continue;
                }
                smeGlobalTrim(now);
                if (smeGlobalTs.length >= SME_GLOBAL_MAX) {
                    const wait = smeGlobalTs[0] + SME_GLOBAL_WINDOW - now + 100;
                    L(this.name + ': 全局窗口饱和，等待 ' + Math.ceil(wait / 1000) + 's');
                    await sleep(Math.min(15000, wait));
                    continue;
                }
                if (this.last && this.gapBefore) {
                    const remain = this.gapBefore - (Date.now() - this.last);
                    if (remain > 0) await sleep(remain);
                }
                const now2 = Date.now();
                this.ts.push(now2);
                this.last = now2;
                smeGlobalTrim(now2);
                smeGlobalTs.push(now2);
                return true;
            }
        }
        /** 串行执行 task（严格 FIFO）；节流等待只作用于后续任务，不延迟当前结果 */
        run(task, cancel) {
            const p = this.tail.then(async () => {
                const ok = await this.acquire(cancel);
                if (ok === null) throw new Error('任务已作废');
                return task();
            });
            const throttle = () => (this.gapAfter ? sleep(this.gapAfter) : Promise.resolve());
            this.tail = p.then(throttle, throttle);
            return p;
        }
        /** 清空本通道窗口（收到 429 进入冷却时调用） */
        reset() { this.ts.length = 0; }
    }

    // 库存通道：任务完成后 600ms 节流（与原 invQueue 语义一致）
    const smeChInv = new SmeRateChannel('inventory', { gapAfter: REQUEST_DELAY });

    function enqueueInv(task) {
        return smeChInv.run(task);
    }

    // ==================== 页面检测 ====================
    function detectPageType() {
        const p = location.pathname;
        // 补充包制作器页面
        if (/^\/tradingcards\/boostercreator/.test(p)) return 'booster';
        // 市场详情页
        if (/^\/market\/listings\/\d+\/.+/.test(p)) return 'listing';
        // 市场浏览页 / 我的市场
        if (/^\/market\/?$/.test(p) || /^\/market\/search/.test(p)) return 'browse';
        // 市场多件出售页
        if (/^\/market\/multisell/.test(p)) return 'multisell';
        // 库存页
        if (/^\/(?:id|profiles)\/[^/]+\/inventory/.test(p)) return 'inventory';
        // 交易报价页
        if (/^\/tradeoffer/.test(p)) return 'tradeoffer';
        return 'other';
    }

    /**
     * Steam 客户端内置浏览器（steamwebhelper / 游戏内覆盖）的 UA 带 Valve Steam Client。
     */
    function isSteamClient() {
        try {
            const ua = navigator.userAgent || '';
            if (/Valve Steam Client|Valve Steam GameOverlay|steamwebhelper/i.test(ua)) return true;
        } catch (e) {}
        try {
            const w = unsafeWindow || window;
            if (w.SteamClient || w.Steam || w.Millennium) return true;
        } catch (e) {}
        return false;
    }

    /** 浏览器里记住的选择。旧值 auto 以及未设置都视为顶部内嵌。 */
    function browserListingPanelMode() {
        return settings.get('listingPanelMode') === 'float' ? 'float' : 'inline';
    }

    /** Steam 客户端固定浮窗。浏览器默认内嵌，只有用户选过浮窗才用浮窗。 */
    function shouldUseFloatPanel() {
        if (isSteamClient()) return true;
        return browserListingPanelMode() === 'float';
    }

    /** 只在浏览器里保存。Steam 客户端不写入，避免把固定浮窗记成用户选择。 */
    function applyListingPanelMode(mode) {
        if (isSteamClient()) return;
        const next = mode === 'float' ? 'float' : 'inline';
        settings.set('listingPanelMode', next);
        if (detectPageType() === 'listing') presentListingPanel(next === 'float');
    }

    function listingPanelModeControl() {
        if (isSteamClient()) {
            return h('span', { class: 'sme-setting-desc', text: '底部浮窗' });
        }
        const mode = browserListingPanelMode();
        return h('select', {
            class: 'sme-setting-select',
            'aria-label': '详情页分析面板',
            html: [['页面顶部内嵌', 'inline'], ['底部浮窗按钮', 'float']]
                .map(([l, v]) => `<option value="${v}"${v === mode ? ' selected' : ''}>${l}</option>`).join(''),
            onChange: e => applyListingPanelMode(e.target.value),
        });
    }

    /** v1.9.1：Steam 现把市场详情页 URL 302 成哈希 slug（如 /listings/730/G18DA243004），
     * URL 里的名字不再是 market_hash_name（中文页面连可见名都是本地化名，如「裂空武器箱」）；
     * 皮肤类物品的易读 URL 还会把同皮肤全部磨损 302 到同一个「家族聚合页」，URL 层面
     * 已丢失磨损信息，只能跟随页面默认 bucket（initialSelectedBucketID →
     * initialFallbackBucketID → buckets[0]）。规范 market_hash_name 从
     * renderContext.queryData（dehydrated React Query 缓存）按 classid 精确关联。
     * 解析成功即缓存；失败 2s 内不重试（@run-at document-start 时 SSR 可能尚未就绪）。 */
    let _ssrHashName; // undefined=未解析成功，string=已解析
    let _ssrHashNameTriedAt = 0;
    function ssrMarketHashName() {
        if (_ssrHashName !== undefined) return _ssrHashName;
        const now = Date.now();
        if (now - _ssrHashNameTriedAt < 2000) return null;
        _ssrHashNameTriedAt = now;
        try {
            const SSR = unsafeWindow && unsafeWindow.SSR;
            if (!SSR || !SSR.loaderData || !SSR.renderContext) return null;
            const entries = Array.isArray(SSR.loaderData) ? SSR.loaderData : Object.values(SSR.loaderData || {});
            // 1) 焦点物品 classid（含 buckets 的那份 loaderData）
            let focusClassId = null;
            for (const entry of entries) {
                try {
                    const d = typeof entry === 'string' ? JSON.parse(entry) : entry;
                    const bs = d && d.buckets;
                    if (!bs || !bs.length) continue;
                    const byId = (id) => bs.find((b) => String(b.bucket_id) === String(id));
                    const b = (d.initialSelectedBucketID != null && byId(d.initialSelectedBucketID))
                        || (d.initialFallbackBucketID != null && byId(d.initialFallbackBucketID))
                        || bs[0];
                    if (b && b.classid != null) { focusClassId = String(b.classid); break; }
                } catch (e) { /* 单条解析失败忽略 */ }
            }
            if (!focusClassId) return null;
            // 2) queryData 深度遍历找 classid 匹配的资产描述（queryData 是内嵌 JSON 字符串）
            let qd = SSR.renderContext.queryData;
            if (typeof qd === 'string') {
                try { qd = JSON.parse(qd); } catch (e) { return null; }
            }
            let found = null;
            const walk = (o, depth) => {
                if (found || depth > 12 || !o || typeof o !== 'object') return;
                if (Array.isArray(o)) {
                    for (const x of o) { walk(x, depth + 1); if (found) return; }
                    return;
                }
                if (o.market_hash_name != null && o.classid != null && String(o.classid) === focusClassId) {
                    found = String(o.market_hash_name);
                    return;
                }
                for (const k in o) { walk(o[k], depth + 1); if (found) return; }
            };
            walk(qd, 0);
            if (found) { _ssrHashName = found; return found; }
        } catch (e) { /* SSR 不存在或结构变化，静默回退 URL 名 */ }
        return null;
    }

    function getListingInfo() {
        const m = location.pathname.match(/^\/market\/listings\/(\d+)\/(.+?)(?:\?.*)?$/);
        if (!m) return null;
        let name;
        try { name = decodeURIComponent(m[2]); } catch (e) { name = m[2]; }
        // v1.9.1：URL 名可能是哈希 slug，优先用页面 SSR 的规范 market_hash_name
        const ssrName = ssrMarketHashName();
        if (ssrName) name = ssrName;
        return { appid: m[1], marketHashName: name };
    }

    // ==================== SSR 数据提取 ====================
    let _capturedItemNameId = null;

    /** 递归搜索对象中的 item_nameid 属性（最多 5 层深度） */
    function findItemNameIdDeep(obj, depth) {
        if (!obj || depth > 5) return null;
        if (typeof obj !== 'object') return null;
        // 直接属性
        if (obj.item_nameid) return String(obj.item_nameid);
        // 遍历子属性
        for (const key in obj) {
            if (key === 'item_nameid' && obj[key]) return String(obj[key]);
            if (typeof obj[key] === 'object' && obj[key] !== null) {
                const found = findItemNameIdDeep(obj[key], depth + 1);
                if (found) return found;
            }
        }
        return null;
    }

    function extractSSRData() {
        const result = { sellOrders: null, itemNameId: null };
        try {
            const ssr = unsafeWindow.SSR?.loaderData;
            if (!Array.isArray(ssr)) return result;
            for (const entry of ssr) {
                try {
                    const data = typeof entry === 'string' ? JSON.parse(entry) : entry;
                    if (!data || typeof data !== 'object') continue;
                    if (data.myOrders?.rgSellOrders && Array.isArray(data.myOrders.rgSellOrders)) {
                        result.sellOrders = data.myOrders.rgSellOrders.map(o => ({
                            listingid: o.listingid,
                            assetid: o.assetid,
                            classid: o.classid || '',
                            rtListed: o.rtListed,
                            dateKey: tsToDateKey(o.rtListed),
                            dateTime: tsToDateTime(o.rtListed),
                            buyerPrice: (o.strBuyerPrice || '').trim(),
                            sellerPrice: (o.strSellerPrice || '').trim(),
                        }));
                    }
                    // 直接路径
                    if (data.item_nameid) result.itemNameId = String(data.item_nameid);
                    if (data.asset_description?.item_nameid) result.itemNameId = String(data.asset_description.item_nameid);
                    // 提取 classid（用于下架后 assetid 重新获取）
                    if (data.asset_description?.classid) result.classid = String(data.asset_description.classid);
                    // 递归搜索（处理嵌套结构，如 mediators/servicehelpers 等）
                    if (!result.itemNameId) {
                        const found = findItemNameIdDeep(data, 0);
                        if (found) result.itemNameId = found;
                    }
                } catch (e) {}
            }
        } catch (e) {}
        return result;
    }

    /**
     * 从页面全局取 SSR 上下文（v2.0.0）。
     * 新版 React 市场页的内联脚本会做：
     *   window.SSR = {loaderData, clientAssets, renderContext}
     *   window.Config = d.Config;  window.UserConfig = d.UserConfig;
     * （实测 2026-11：window.Config / window.UserConfig 均已挂到全局，可直接读）
     * @returns {object|null} 与 smeParseValveSsr 同构的上下文对象
     */
    function getPageSsr() {
        try {
            const SSR = unsafeWindow && unsafeWindow.SSR;
            if (!SSR || (!SSR.loaderData && !SSR.renderContext)) return null;
            return {
                loaderData: SSR.loaderData || null,
                renderContext: SSR.renderContext || null,
                clientAssets: SSR.clientAssets || null,
                config: (unsafeWindow && unsafeWindow.Config) || null,
                userConfig: (unsafeWindow && unsafeWindow.UserConfig) || null,
            };
        } catch (e) { return null; }
    }

    /**
     * 当前页面的同款变体清单（含每个变体的最低价）。
     * buckets[] = {bucket_id: <market_hash_name>, classid, min_price}
     * min_price 是**分**（实测 MW 变体 min_price=128230 与该变体 orderbook 的
     * amtMinSellOrder=128230 一致），是 Steam 免费给出的**各变体最低卖价**。
     * @returns {Array<{name, classid, minPriceCents}>}
     */
    function getListingVariants() {
        const out = [];
        const ssr = getPageSsr();
        if (!ssr) return out;
        const ld = ssr.loaderData;
        const entries = Array.isArray(ld) ? ld : (ld && typeof ld === 'object' ? Object.values(ld) : []);
        for (const entry of entries) {
            let d = entry;
            if (typeof d === 'string') { try { d = JSON.parse(d); } catch (e) { continue; } }
            if (!d || !Array.isArray(d.buckets)) continue;
            for (const b of d.buckets) {
                if (!b || !b.bucket_id) continue;
                if (out.some(v => v.name === b.bucket_id)) continue;
                const mp = parseInt(b.min_price, 10);
                out.push({
                    name: String(b.bucket_id),
                    classid: b.classid != null ? String(b.classid) : '',
                    minPriceCents: isFinite(mp) && mp > 0 ? mp : null,
                });
            }
        }
        return out;
    }

    /**
     * 用户**想要**的变体名。
     * 新版路由是 `/market/listings/:appid/:name/:bucket?` —— 第 3 段就是变体
     * （实测加上该段后 initialSelectedBucketID 变成请求的变体，
     *   且 market/orderbook 的 queryKey 也随之指向该变体）。
     * 没有该段时退回焦点变体（initialSelectedBucketID → fallback → buckets[0]）。
     */
    function getTargetVariantName() {
        try {
            const m = location.pathname.match(/^\/market\/listings\/\d+\/[^/]+\/([^/]+)/);
            if (m) {
                try { return decodeURIComponent(m[1]); } catch (e) { return m[1]; }
            }
        } catch (e) {}
        return smeSsrFocusVariant(getPageSsr());
    }

    // ==================== SSR 订单簿提取（新版页面，无 item_nameid） ====================

    /**
     * @deprecated v2.0.0 已废弃。旧表按「货币 ID」索引，且与 CURRENCY_ID_TO_CODE 自相矛盾：
     *   6 标成 BRL（官方 PLN）、7 标成 JPY（官方 BRL）、8 标成 NOK（官方 JPY）、
     *   25-28 标成 HKD/TWD/SAR/AED（官方 CLP/PEN/COP/ZAR），且完全缺 29-47。
     * 现统一走纯计算层 SME_CURRENCY_ECODE + SME_CURRENCY_SYMBOL（依据 Steamworks 官方表）。
     * 保留 Proxy 仅为兼容潜在的外部引用：数字键按 ID 查，字符串键按 ISO 代码查。
     */
    const CURRENCY_SYMBOLS = new Proxy({}, {
        get(t, k) {
            if (typeof k !== 'string') return undefined;
            const id = parseInt(k, 10);
            if (isFinite(id)) return smeCurrencySymbol(id);
            return smeCurrencySymbolByCode(k);
        },
    });

    /**
     * 获取货币前缀/后缀。
     * v2.0.0：优先 Steam 原生 v_currencyformat；新版 React 市场页**没有**这个全局
     * （实测 count=0），落到纯计算层的官方映射表（单一事实源）。
     * ⚠️ 旧版的 CURRENCY_SYMBOLS 表与 CURRENCY_ID_TO_CODE 自相矛盾
     *    （6 标成 BRL / 7 标成 JPY / 25-28 标成 HKD·TWD·SAR·AED），已废弃。
     */
    function getCurrencySymbol(currencyCode) {
        try {
            if (unsafeWindow.v_currencyformat) {
                const formatted = unsafeWindow.v_currencyformat(123456, currencyCode || 1);
                const match = formatted.match(/^([^\d]*)([\d.,]+)([^\d]*)$/);
                if (match) {
                    return { prefix: match[1] || '', suffix: match[3] || '' };
                }
            }
        } catch (e) {}
        return smeCurrencySymbol(currencyCode);
    }

    /** 格式化分（cents）为价格字符串 */
    function formatCentsStr(cents, currencyCode) {
        const sym = getCurrencySymbol(currencyCode);
        try {
            if (unsafeWindow.v_currencyformat) {
                return unsafeWindow.v_currencyformat(cents, currencyCode || 1);
            }
        } catch (e) {}
        return sym.prefix + (cents / 100).toFixed(2) + sym.suffix;
    }

    /** 递归搜索对象中的订单簿数据（rgCompactBuyOrders + rgCompactSellOrders） */
    function findOrderBookDeep(obj, depth) {
        if (!obj || depth > 6 || typeof obj !== 'object') return null;
        if (Array.isArray(obj.rgCompactBuyOrders) && Array.isArray(obj.rgCompactSellOrders)) {
            return obj;
        }
        for (const key in obj) {
            if (typeof obj[key] === 'object' && obj[key] !== null) {
                const found = findOrderBookDeep(obj[key], depth + 1);
                if (found) return found;
            }
        }
        return null;
    }

    /** 解析压缩格式的订单簿数组 [price, qty, price, qty, ...] → [{price, qty}, ...] */
    function parseCompactOrders(arr, currencyCode) {
        const orders = [];
        for (let i = 0; i + 1 < arr.length; i += 2) {
            const priceCents = arr[i];
            const qty = arr[i + 1];
            if (qty > 0) {
                orders.push({
                    price: formatCentsStr(priceCents, currencyCode),
                    qty: qty,
                    _cents: priceCents,
                });
            }
        }
        return orders;
    }

    /** 从 SSR raw 对象（含 rgCompactBuyOrders/rgCompactSellOrders）构建订单簿结果 */
    function buildOrderBookFromRaw(raw, sourceTag, variantName, matched) {
        const currencyCode = raw.eCurrency || 1;
        const sym = getCurrencySymbol(currencyCode);
        const result = {
            sellOrders: parseCompactOrders(raw.rgCompactSellOrders || [], currencyCode),
            buyOrders: parseCompactOrders(raw.rgCompactBuyOrders || [], currencyCode),
            sellSummary: '',
            buySummary: '',
            highestBuy: String(raw.amtMaxBuyOrder || ''),
            lowestSell: String(raw.amtMinSellOrder || ''),
            prefix: sym.prefix,
            suffix: sym.suffix,
            // v2.0.0：该盘所属的磨损变体（来自 queryKey）+ 是否与用户目标变体一致
            variantName: variantName || '',
            variantMatched: matched !== false,
            _source: sourceTag,
        };
        L(`Order book extracted (${sourceTag}):`, result.sellOrders.length, 'sell,', result.buyOrders.length, 'buy',
            variantName ? ('variant=' + variantName + (matched === false ? ' [MISMATCH]' : '')) : '');
        return result;
    }

    /** smeSsrOrderBook 的 levels 结构 → 插件内部的订单簿展示结构 */
    function orderBookFromLevels(ob, sourceTag) {
        if (!ob) return null;
        const currencyCode = ob.currency || 1;
        const sym = getCurrencySymbol(currencyCode);
        return {
            sellOrders: ob.sellLevels.map(l => ({
                price: formatCentsStr(l.cents, currencyCode), qty: l.qty, _cents: l.cents,
            })),
            buyOrders: ob.buyLevels.map(l => ({
                price: formatCentsStr(l.cents, currencyCode), qty: l.qty, _cents: l.cents,
            })),
            sellSummary: '',
            buySummary: '',
            highestBuy: ob.highestBuyCents != null ? String(ob.highestBuyCents) : '',
            lowestSell: ob.lowestSellCents != null ? String(ob.lowestSellCents) : '',
            prefix: sym.prefix,
            suffix: sym.suffix,
            variantName: ob.variantName || '',
            variantMatched: ob.matched !== false,
            buyOrderCount: ob.buyOrderCount,
            sellOrderCount: ob.sellOrderCount,
            _source: sourceTag,
        };
    }

    /**
     * 构造指定变体的市场页 URL。
     * 新版路由 `/market/listings/:appid/:name/:bucket?` 的第 3 段是变体
     * （实测加上该段后 initialSelectedBucketID 与 market/orderbook 的 queryKey
     *   都指向请求的变体）。旧式 URL（name 段本身就是 market_hash_name）无此概念。
     */
    function buildVariantUrl(variantName) {
        const m = location.pathname.match(/^(\/market\/listings\/\d+\/)([^/]+)(\/([^/]+))?\/?$/);
        if (!m) return null;
        const head = m[1];
        const seg1 = m[2];
        const hasBucket = !!m[4];
        // seg1 是家族 slug（如 G1807209A023004）时才需要 bucket 段
        const isSlug = /^G[0-9A-Za-z]{8,}$/.test(seg1);
        if (!isSlug && !hasBucket) return null;   // 旧式 URL：单物品页，无变体概念
        const base = isSlug ? head + seg1 : head + seg1;
        return base + '/' + encodeURIComponent(variantName);
    }

    /**
     * 通过抓取物品市场页的 SSR 取订单簿（v2.0.0）。
     * 取代「抓详情页 → 正则取 item_nameid → itemordershistogram」三连：
     * 实测全站已无 item_nameid（Market_LoadOrderSpread / g_item_nameid / "item_nameid"
     * 在 730 与 753 页面出现次数均为 0），而 SSR 的 market/orderbook 直接给全量档位
     * （实测卖侧 792 档 / 买侧 1,802 档）。
     */
    async function fetchOrderBookByPage(appid, hashName) {
        const cacheKey = `obp_${appid}_${hashName}`;
        const cached = cache.get(cacheKey, CACHE_TTL.ORDER_BOOK);
        if (cached) return cached;
        const url = `https://steamcommunity.com/market/listings/${appid}/${encodeURIComponent(hashName)}`;
        const text = await smeRequest(url, { expect: 'text', onNonOk: 'null' });
        if (!text) return null;
        const parsed = smeParseValveSsr(text);
        if (!parsed) return null;
        const ob = smeSsrOrderBook(parsed, hashName);
        if (!ob) return null;
        const result = orderBookFromLevels(ob, 'ssr-page');
        cache.set(cacheKey, result);
        return result;
    }

    /**
     * 取指定变体的订单盘（v2.0.0）。
     * 同款家族聚合页默认只内嵌**一个**变体（initialFallbackBucketID）的盘，
     * 用户想要别的变体时必须显式请求 —— 否则会把别的变体的盘当成本变体展示。
     */
    async function fetchOrderBookForVariant(variantName) {
        const url = buildVariantUrl(variantName);
        if (!url) return null;
        const text = await smeRequest(url, { expect: 'text', cache: 'no-store' });
        const parsed = smeParseValveSsr(text);
        const ob = smeSsrOrderBook(parsed, variantName);
        if (!ob) return null;
        return orderBookFromLevels(ob, 'ssr-variant:' + variantName);
    }

    /**
     * 从 SSR 数据中提取订单簿（新版页面，无需 item_nameid）。
     *
     * ★ v2.0.0：改为**变体感知**。同款家族聚合页一次 SSR 里，market/orderbook 只对应同款家族聚合页一次 SSR 里，market/orderbook 只对应
     *   initialFallbackBucketID 那个变体（实测 URL 是 FT、orderbook 却是 MW），
     *   盲取会把别的变体的盘当成当前变体展示 → 超价/低价检测与定价建议全部失真。
     *   现在从 queryKey 读出盘的归属变体，与用户目标变体比对，结果写进
     *   variantName / variantMatched，由调用方决定提示还是去取正确变体的盘。
     */
    function extractOrderBookFromSSR() {
        // 0. v2.0.0：走纯计算层的结构化解析（变体感知）
        try {
            const target = getTargetVariantName();
            const ob = smeSsrOrderBook(getPageSsr(), target);
            if (ob && (ob.sellLevels.length || ob.buyLevels.length
                || ob.highestBuyCents != null || ob.lowestSellCents != null)) {
                return orderBookFromLevels(ob, 'ssr-querydata');
            }
        } catch (e) { L('SSR order book parse failed:', e && e.message); }
        // 1. 搜索 loaderData 数组（部分旧版 SSR 页面）
        try {
            const ssr = unsafeWindow.SSR?.loaderData;
            if (Array.isArray(ssr)) {
                for (const entry of ssr) {
                    try {
                        const data = typeof entry === 'string' ? JSON.parse(entry) : entry;
                        if (!data || typeof data !== 'object') continue;
                        const raw = findOrderBookDeep(data, 0);
                        if (raw) return buildOrderBookFromRaw(raw, 'ssr-loaderData');
                    } catch (e) {}
                }
            }
        } catch (e) {}

        // 2. 搜索 renderContext.queryData（新版 React SSR 页面，订单簿内嵌在 React Query dehydrated state 中）
        //    结构: SSR.renderContext = JSON.parse('{"queryData":"{\\"queries\\":[{...\\"rgCompactBuyOrders\\":...}]}"}')
        //    renderContext 已被浏览器 JSON.parse 为对象，但 queryData 仍是嵌套 JSON 字符串，需二次解析
        try {
            const rc = unsafeWindow.SSR?.renderContext;
            if (rc && typeof rc === 'object') {
                // queryData 是嵌套 JSON 字符串，包含 React Query 的 mutations 和 queries
                const qd = rc.queryData;
                if (typeof qd === 'string' && qd.length > 0) {
                    const parsed = JSON.parse(qd);
                    const raw = findOrderBookDeep(parsed, 0);
                    if (raw) return buildOrderBookFromRaw(raw, 'ssr-renderContext');
                }
                // 也直接递归搜索 renderContext 本身（万一 queryData 已被预解析为对象）
                const raw2 = findOrderBookDeep(rc, 0);
                if (raw2) return buildOrderBookFromRaw(raw2, 'ssr-renderContext-obj');
            }
        } catch (e) {}

        // 3. 正则兜底：从页面 script 标签文本提取
        return extractOrderBookFromScripts();
    }

    /** 从页面 script 标签正则提取订单簿数据（兜底方案） */
    function extractOrderBookFromScripts() {
        try {
            for (const script of document.querySelectorAll('script')) {
                const text = script.textContent || '';
                if (text.indexOf('rgCompactBuyOrders') === -1) continue;
                // 提取 rgCompactBuyOrders 数组
                // 注意：新版 SSR 页面中数据被多层 JSON 转义，关键词与冒号间可能出现 \\\" 等转义引号
                // [\\\"]*\s* 匹配任意数量的反斜杠、引号和空白字符
                const buyMatch = text.match(/rgCompactBuyOrders[\\\"]*\s*:\s*\[([^\]]+)\]/);
                const sellMatch = text.match(/rgCompactSellOrders[\\\"]*\s*:\s*\[([^\]]+)\]/);
                const maxBuyMatch = text.match(/amtMaxBuyOrder[\\\"]*\s*:\s*"?(\d+)/);
                const minSellMatch = text.match(/amtMinSellOrder[\\\"]*\s*:\s*"?(\d+)/);
                const curMatch = text.match(/eCurrency[\\\"]*\s*:\s*"?(\d+)/);
                if (buyMatch && sellMatch) {
                    const currencyCode = curMatch ? parseInt(curMatch[1], 10) : 1;
                    const sym = getCurrencySymbol(currencyCode);
                    const buyArr = buyMatch[1].split(',').map(s => parseInt(s.trim(), 10)).filter(n => !isNaN(n));
                    const sellArr = sellMatch[1].split(',').map(s => parseInt(s.trim(), 10)).filter(n => !isNaN(n));
                    const result = {
                        sellOrders: parseCompactOrders(sellArr, currencyCode),
                        buyOrders: parseCompactOrders(buyArr, currencyCode),
                        sellSummary: '',
                        buySummary: '',
                        highestBuy: maxBuyMatch ? maxBuyMatch[1] : '',
                        lowestSell: minSellMatch ? minSellMatch[1] : '',
                        prefix: sym.prefix,
                        suffix: sym.suffix,
                        _source: 'ssr-regex',
                    };
                    L('Order book extracted from scripts (regex):', result.sellOrders.length, 'sell,', result.buyOrders.length, 'buy');
                    return result;
                }
            }
        } catch (e) {}
        return null;
    }

    /**
     * 统一获取订单簿数据（SSR 优先 → item_nameid+API 降级）
     * 新版页面无 item_nameid，订单簿数据直接内嵌在 SSR React Query 状态中
     * @param {boolean} force 强制刷新：绕过 SSR 与缓存，直接请求 histogram API 拿最新全量数据
     */
    async function fetchOrderBook(force) {
        const ssrUsable = (d) => d && (d.sellOrders.length > 0 || d.buyOrders.length > 0 || d.highestBuy || d.lowestSell);
        // 1. 优先从 SSR 提取（新版页面，无需 item_nameid，零网络请求）
        const ssrData = extractOrderBookFromSSR();
        const ssrValid = ssrUsable(ssrData);
        const ssrLevels = ssrData ? Math.max(ssrData.sellOrders.length, ssrData.buyOrders.length) : 0;

        // 2. v2.0.0：**变体一致性校验**（这是本次止血的核心）
        //    同款家族聚合页默认内嵌的盘属于 initialFallbackBucketID 那个变体，
        //    可能不是用户要看的变体。若不一致且用户目标明确 → 显式去取目标变体的盘。
        const target = getTargetVariantName();
        if (ssrValid && ssrData.variantName && target && ssrData.variantName !== target) {
            try {
                const wanted = await fetchOrderBookForVariant(target);
                if (wanted && ssrUsable(wanted)) {
                    wanted.variantMatched = true;
                    wanted._fetchedForVariant = true;
                    return wanted;
                }
            } catch (e) {
                W('取目标变体订单盘失败，回退页面内嵌盘:', e && e.message);
            }
            // 取不到就把「盘属于哪个变体」如实标出来，绝不冒充成目标变体
            ssrData.variantMatched = false;
            ssrData._variantMismatch = true;
            return ssrData;
        }
        if (!force && ssrValid && ssrLevels >= 10) {
            return ssrData;
        }
        if (ssrValid) return ssrData;
        // 3. 兜底：item_nameid + histogram API。
        //    ⚠️ v2.0.0：实测全站已无 item_nameid（Market_LoadOrderSpread / g_item_nameid /
        //    "item_nameid" 在 730 与 753 页面出现次数均为 0），该端点实际不可达，
        //    此路径仅对极老的经典页面有效，保留只为兼容。
        const itemNameId = await getItemNameIdAsync();
        if (itemNameId) {
            return await fetchOrderHistogram(itemNameId, force);
        }
        if (force) throw new Error('无法强制刷新：新版市场页不再提供 item_nameid（请直接刷新网页）');
        throw new Error('无法获取订单簿数据（SSR 无数据且旧版 item_nameid 不可用）');
    }

    function getItemNameId() {
        // 1. 全局变量 g_item_nameid
        try { if (unsafeWindow.g_item_nameid) return String(unsafeWindow.g_item_nameid); } catch (e) {}
        // 2. SSR 数据（含递归搜索）
        const ssr = extractSSRData();
        if (ssr.itemNameId) return ssr.itemNameId;
        // 3. 页面 script 标签正则匹配（多种格式）
        for (const script of document.querySelectorAll('script')) {
            const text = script.textContent || '';
            let m;
            if (m = text.match(/Market_LoadOrderSpread\(\s*(\d+)/)) return m[1];
            if (m = text.match(/g_item_nameid\s*=\s*["']?(\d+)/)) return m[1];
            if (m = text.match(/"item_nameid"\s*:\s*"?(\d+)/)) return m[1];
            if (m = text.match(/item_nameid["'\s:=]+(\d{5,})/)) return m[1];
        }
        // 4. XHR 拦截器捕获的值
        if (_capturedItemNameId) return _capturedItemNameId;
        // 5. DOM data-item-nameid 属性
        const el = document.querySelector('[data-item-nameid]');
        if (el) return el.dataset.itemNameid;
        return null;
    }

    /** 异步获取 item_nameid（带重试，等待页面异步加载完成） */
    async function getItemNameIdAsync(maxRetries, interval) {
        if (maxRetries === undefined) maxRetries = 6;
        if (interval === undefined) interval = 500;
        for (let i = 0; i < maxRetries; i++) {
            const id = getItemNameId();
            if (id) return id;
            if (i < maxRetries - 1) {
                L('getItemNameId retry', (i + 1) + '/' + maxRetries);
                await sleep(interval);
            }
        }
        return null;
    }

    // XHR 拦截器（捕获 item_nameid）
// v1.5.0：新增 `sme_xhr_restore` 事件 + pagehide 还原。
// 原实现永久改写 XMLHttpRequest.prototype.open 且从不还原，会污染整页
// （含 Steam 自身的 XHR 调用）。任何其它脚本若检测 open 是否为原生会误判，
    // 且调试时无法定位是谁改的。现在暴露一个显式还原入口，并在页面离开时自动还原。
    (function interceptXHR() {
        const PATCH_FLAG = '__smeItemNameIdHook';
        if (XMLHttpRequest.prototype.open[PATCH_FLAG]) return;  // 防重复注入
        const origOpen = XMLHttpRequest.prototype.open;
        const patched = function (method, url) {
            if (url && url.indexOf('itemordershistogram') !== -1) {
                const m = url.match(/item_nameid=(\d+)/);
                if (m) _capturedItemNameId = m[1];
            }
            return origOpen.apply(this, arguments);
        };
        patched[PATCH_FLAG] = true;
        patched._smeOriginal = origOpen;
        XMLHttpRequest.prototype.open = patched;

        /** 还原原型方法（幂等）；可由外部主动调用 window.dispatchEvent(new Event('sme_xhr_restore')) */
        window.addEventListener('sme_xhr_restore', () => {
            if (XMLHttpRequest.prototype.open === patched) {
                XMLHttpRequest.prototype.open = origOpen;
                L('XHR open 已还原');
            }
        }, { once: true });
    })();

    // 页面离开时自动还原，避免污染残留到其他页面
    window.addEventListener('pagehide', () => {
        window.dispatchEvent(new Event('sme_xhr_restore'));
    });

    // ==================== 订单分组 ====================
    function groupOrders(orders) {
        const dateMap = new Map();
        for (const o of orders) {
            if (!dateMap.has(o.dateKey)) {
                dateMap.set(o.dateKey, { dateKey: o.dateKey, prices: new Map(), items: [] });
            }
            const dg = dateMap.get(o.dateKey);
            if (!dg.prices.has(o.buyerPrice)) dg.prices.set(o.buyerPrice, []);
            dg.prices.get(o.buyerPrice).push(o);
            dg.items.push(o);
        }
        for (const g of dateMap.values()) {
            for (const items of g.prices.values()) items.sort((a, b) => b.rtListed - a.rtListed);
        }
        return [...dateMap.values()]
            .sort((a, b) => b.dateKey.localeCompare(a.dateKey))
            .map(g => ({
                dateKey: g.dateKey,
                prices: g.prices,
                sortedPrices: [...g.prices.keys()].sort(),
                totalCount: g.items.length,
            }));
    }

    // ==================== 库存 API ====================
    function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }

    // ==================== v1.5.1 P1-A 统一请求层 ====================
    // 目标：收敛散落 20 处的裸 fetch。统一负责：credentials / 超时(AbortController) /
    // 429·400·401·403·5xx 错误码分类 / JSON·text 解析 / 外部 signal 透传。
    // 错误消息与旧实现保持一致（'RateLimited' / 'BadRequest' / 'HTTP xxx'），
    // 确保 withMarketRetry 的重试判定（msg === 'RateLimited' || /429/）无需改动。
    const SME_ERR = Object.freeze({
        RATE_LIMITED: 'RateLimited',
        BAD_REQUEST: 'BadRequest',
        AUTH: 'AuthError',
        TIMEOUT: 'Timeout',
        SERVER: 'ServerError',
        NETWORK: 'NetworkError',
    });

    /** 统一请求错误：err.code ∈ SME_ERR，err.status 为 HTTP 状态码（网络层错误为 0） */
    class SmeRequestError extends Error {
        constructor(code, status, message, retryAfter) {
            super(message || code);
            this.name = 'SmeRequestError';
            this.code = code;
            this.status = status || 0;
            // v2.2.1：429 时带上 Retry-After（秒）—— 调用方据此进入冷却，
            // 而不是用拍脑袋的短间隔去重试（Steam 的限流窗口以分钟计）。
            this.retryAfter = retryAfter || 0;
        }
    }

    /**
     * 统一请求入口（P1-A）。
     * @param {string} url
     * @param {object} [opt]
     *   expect: 'json'(默认) | 'text' | 'none'（返回原始 Response）
     *   timeout: 毫秒，默认 15000；0 表示不设超时（外部 signal 自行控制）
     *   signal: 外部 AbortSignal（传入后本函数不再建超时控制器）
     *   method/headers/body/cache: 透传 fetch
     *   credentials: 默认 'include'
     *   onNonOk: 'throw'(默认) | 'null'（非 2xx 返回 null，对应旧代码 `!resp.ok → null` 语义）
     */
    async function smeRequest(url, opt) {
        opt = opt || {};
        const expect = opt.expect || 'json';
        const externalSignal = opt.signal || null;
        const ctrl = externalSignal ? null : new AbortController();
        const signal = externalSignal || ctrl.signal;
        const timeout = opt.timeout === undefined ? 15000 : opt.timeout;
        const timer = (ctrl && timeout > 0) ? setTimeout(() => ctrl.abort('sme-timeout'), timeout) : null;
        let resp;
        try {
            resp = await fetch(url, {
                method: opt.method || 'GET',
                credentials: opt.credentials || 'include',
                headers: opt.headers,
                body: opt.body,
                cache: opt.cache,
                signal: signal,
            });
        } catch (e) {
            if (e && e.name === 'AbortError') throw new SmeRequestError(SME_ERR.TIMEOUT, 0, 'Timeout');
            throw new SmeRequestError(SME_ERR.NETWORK, 0, 'Network error: ' + ((e && e.message) || e));
        } finally {
            if (timer) clearTimeout(timer);
        }
        if (resp.status === 429) {
            // v2.2.1：把 Retry-After 带出去（Steam 有时给，有时不给）
            let retryAfter = 0;
            try {
                const ra = Number(resp.headers && resp.headers.get('retry-after'));
                if (Number.isFinite(ra) && ra > 0) retryAfter = Math.min(ra, 600);
            } catch (e) { /* 读不到就按缺省冷却 */ }
            throw new SmeRequestError(SME_ERR.RATE_LIMITED, 429, 'RateLimited', retryAfter);
        }
        if (resp.status === 400) throw new SmeRequestError(SME_ERR.BAD_REQUEST, 400, 'BadRequest');
        if (resp.status === 401 || resp.status === 403) throw new SmeRequestError(SME_ERR.AUTH, resp.status, 'HTTP ' + resp.status);
        if (resp.status >= 500) throw new SmeRequestError(SME_ERR.SERVER, resp.status, 'HTTP ' + resp.status);
        if (!resp.ok) {
            if (opt.onNonOk === 'null') return null;
            throw new SmeRequestError(SME_ERR.NETWORK, resp.status, 'HTTP ' + resp.status);
        }
        if (expect === 'none') return resp;
        if (expect === 'text') return resp.text();
        try { return await resp.json(); }
        catch (e) { throw new SmeRequestError(SME_ERR.NETWORK, resp.status, 'JSON parse error: ' + e.message); }
    }

    // v1.5.1 P1-A：doFetch 收敛为统一请求层 smeRequest 的薄包装（错误消息保持兼容）
    function doFetch(url) {
        return smeRequest(url, { expect: 'json' });
    }

    // v1.5.1 P2-A：错误码 → 用户可读文案映射（替代 err.message 英文原文直出）
    const SME_ERR_TEXT = {
        RateLimited: '请求过于频繁（Steam 限流），请稍后再试',
        BadRequest: '请求参数错误',
        AuthError: '登录状态失效，请刷新页面后重试',
        Timeout: '请求超时，请检查网络后重试',
        ServerError: 'Steam 服务器异常，请稍后再试',
        NetworkError: '网络错误，请检查网络连接',
    };
    function friendlyError(err) {
        if (err && err.code && SME_ERR_TEXT[err.code]) return SME_ERR_TEXT[err.code];
        return (err && err.message) ? err.message : String(err || '未知错误');
    }

    /** GM_xmlhttpRequest 封装：跨域获取 JSON（用于 store.steampowered.com API） */
    function gmFetchJson(url, timeout = 15000) {
        return new Promise((resolve, reject) => {
            GM_xmlhttpRequest({
                method: 'GET',
                url: url,
                timeout: timeout,
                onload: (resp) => {
                    if (resp.status >= 200 && resp.status < 300) {
                        try { resolve(JSON.parse(resp.responseText)); }
                        catch (e) { reject(new Error('JSON parse error: ' + e.message)); }
                    } else {
                        reject(new Error('HTTP ' + resp.status));
                    }
                },
                onerror: () => reject(new Error('Network error')),
                ontimeout: () => reject(new Error('Timeout')),
            });
        });
    }

    /**
     * v2.0.1：库存「交易冷却天数」采集。
     * Steam 在 descriptions[] 里给出 market_tradable_restriction / market_marketable_restriction：
     *   · 类级别（GetAssetClassInfo 口径）= **购买后不可交易/上架的天数**，Valve 游戏为 7；
     *   · 注意这不是「剩余天数」——老物品也显示 7（已实测验证）。
     * 真正的「解锁日」需要**获得时间**，由成交记录（市场买入）推算，见 smeCooldownList。
     * 交易/赠送所得的物品没有买入记录 → 起始时间未知，如实标注而非编造。
     */
    const invRestrictions = new Map();   // market_hash_name → {marketableDays, tradableDays}

    function collectInventoryRestrictions(d, name) {
        if (!d || !name) return;
        const m = parseInt(d.market_marketable_restriction, 10);
        const t = parseInt(d.market_tradable_restriction, 10);
        if (!isFinite(m) && !isFinite(t)) return;
        invRestrictions.set(name, {
            marketableDays: isFinite(m) && m > 0 ? m : 0,
            tradableDays: isFinite(t) && t > 0 ? t : 0,
        });
    }

    function parseInventoryData(data) {
        const owned = new Map();
        if (Array.isArray(data.assets) && data.assets.length > 0 && Array.isArray(data.descriptions)) {
            const descMap = {};
            data.descriptions.forEach(d => { descMap[d.classid + '_' + (d.instanceid || '0')] = d; });
            data.assets.forEach(item => {
                const d = descMap[item.classid + '_' + (item.instanceid || '0')];
                if (d) {
                    const name = d.market_hash_name || d.name || d.market_name;
                    if (name) {
                        const amt = parseInt(item.amount, 10) || 1;
                        owned.set(name, (owned.get(name) || 0) + amt);
                        collectInventoryRestrictions(d, name);
                    }
                }
            });
        }
        if (owned.size === 0 && data.rgInventory && data.rgDescriptions) {
            Object.keys(data.rgInventory).forEach(id => {
                const item = data.rgInventory[id];
                const d = data.rgDescriptions[item.classid + '_' + item.instanceid];
                if (d) {
                    const name = d.market_hash_name || d.name || d.market_name;
                    if (name) {
                        const amt = parseInt(item.amount, 10) || 1;
                        owned.set(name, (owned.get(name) || 0) + amt);
                        collectInventoryRestrictions(d, name);
                    }
                }
            });
        }
        return owned;
    }

    function buildInvUrl(sid, appid, ctxId, count, fmt, startAssetid) {
        const base = fmt === 'json'
            ? `https://steamcommunity.com/profiles/${sid}/inventory/json/${appid}/${ctxId}/`
            : `https://steamcommunity.com/inventory/${sid}/${appid}/${ctxId}`;
        let params = `?l=english&count=${count}`;
        if (startAssetid) params += `&start_assetid=${startAssetid}`;
        return base + params;
    }

    /**
     * v2.2.1：库存请求的 429 冷却。
     * 原实现：RateLimited 等 800ms / 1600ms 就重试 —— 但 Steam 的限流窗口以**分钟**计，
     * 这种重试基本必失败，还白白吃掉全局 62s/100 次的请求配额。
     * 现在：429 → 进入冷却（优先用 Retry-After，缺省 60s），冷却期内**直接放弃**不再发请求；
     * 只有网络错误/超时才走短间隔重试。
     */
    const INV_RATE_LIMIT_COOLDOWN = 60 * 1000;
    let _invRateLimitedUntil = 0;

    function fetchOnePage(url, retry) {
        if (retry === undefined) retry = 0;
        // 冷却期内：不发请求，直接失败（上层降级用缓存）
        if (Date.now() < _invRateLimitedUntil) {
            return Promise.reject(new SmeRequestError(
                SME_ERR.RATE_LIMITED, 429, 'RateLimited',
                Math.ceil((_invRateLimitedUntil - Date.now()) / 1000)));
        }
        return doFetch(url).catch(err => {
            const msg = err.message || String(err);
            if (msg === 'RateLimited') {
                const cool = (Number(err.retryAfter) > 0 ? Number(err.retryAfter) * 1000 : INV_RATE_LIMIT_COOLDOWN);
                _invRateLimitedUntil = Date.now() + cool;
                W('库存请求被限流，进入', Math.round(cool / 1000), 's 冷却（不再重试）');
                throw err;   // 不再短间隔重试
            } else if (msg === 'BadRequest') {
                W('Bad request (400), no retry');
                throw err;  // 400 不重试，由上层 fallback 处理
            } else if (msg.indexOf('HTTP 5') === 0) {
                L('Server error (' + msg + '), skipping retry');
                throw err;  // 5xx 不重试，返回 null 触发级联降级
            } else {
                W('Request failed (#' + (retry + 1) + '):', msg);
            }
            if (retry < RETRY_MAX) {
                return sleep(RETRY_DELAY * (retry + 1)).then(() => fetchOnePage(url, retry + 1));
            }
            throw err;
        });
    }

    function fetchInventory(appid, ctxId, count, fmt) {
        if (!fmt) fmt = 'default';
        const key = appid + '_' + ctxId + '_' + fmt;
        const sid = getSteamId();
        if (!sid) return Promise.resolve(null);
        const entry = invCache[key];
        if (entry && (Date.now() - entry.ts) < CACHE_TTL.INVENTORY) return Promise.resolve(entry.data);
        if (invPending[key]) return invPending[key];

        invPending[key] = (async () => {
            try {
                const firstUrl = buildInvUrl(sid, appid, ctxId, count, fmt, null);
                L('Fetching inventory [' + fmt + ']: appid=' + appid + ', ctx=' + ctxId + ', count=' + count);
                const data = await fetchOnePage(firstUrl, 0);
                if (!data || !data.success) {
                    L('Inventory empty/inaccessible [' + fmt + ']: appid=' + appid + ', success=' + (data ? data.success : 'null'));
                    const empty = new Map();
                    writeInvCache(key, empty, sid);
                    return empty;
                }
                let owned = parseInventoryData(data);
                const total = data.total_inventory_count || 0;
                let fetched = (data.assets ? data.assets.length : (data.rgInventory ? Object.keys(data.rgInventory).length : 0));
                if (data.more_items && data.last_assetid && fetched < total) {
                    L('[Pagination] fetched ' + fetched + '/' + total + ' items, continuing with last_assetid=' + data.last_assetid);
                    const fetchNext = async (lastId, acc) => {
                        await sleep(REQUEST_DELAY);
                        L('[Pagination] requesting next page: start_assetid=' + lastId);
                        const pageData = await fetchOnePage(buildInvUrl(sid, appid, ctxId, count, fmt, lastId), 0);
                        if (!pageData || !pageData.success) {
                            L('[Pagination] next page failed, returning data fetched so far');
                            return acc;
                        }
                        const pageOwned = parseInventoryData(pageData);
                        pageOwned.forEach((amt, name) => acc.set(name, (acc.get(name) || 0) + amt));
                        const pageCount = (pageData.assets ? pageData.assets.length : (pageData.rgInventory ? Object.keys(pageData.rgInventory).length : 0));
                        L('[Pagination] this page: ' + pageCount + ' items, cumulative unique items=' + acc.size);
                        if (pageData.more_items && pageData.last_assetid) return fetchNext(pageData.last_assetid, acc);
                        return acc;
                    };
                    owned = await fetchNext(data.last_assetid, owned).catch(() => {
                        L('[Pagination] error fetching next page, returning data fetched so far');
                        return owned;
                    });
                }
                L('[Pagination] complete: appid=' + appid + ', unique items=' + owned.size);
                writeInvCache(key, owned, sid);
                return owned;
            } catch (err) {
                const msg = err.message || String(err);
                // BadRequest(400) — count 可能过大，降级到更小的 count
                if (msg === 'BadRequest') {
                    if (count > INVENTORY_FALLBACK_COUNT) {
                        W('count=' + count + ' rejected, falling back to count=' + INVENTORY_FALLBACK_COUNT);
                        delete invPending[key];
                        return fetchInventory(appid, ctxId, INVENTORY_FALLBACK_COUNT, fmt);
                    }
                    W('Inventory inaccessible (400) [' + fmt + ']: appid=' + appid);
                    const empty400 = new Map();
                    writeInvCache(key, empty400, sid);
                    return empty400;
                }
                // HTTP 5xx — 服务器端错误，返回 null 触发级联降级（json 格式 + context 1）
                if (msg.indexOf('HTTP 5') === 0) {
                    L('Server error [' + fmt + ']: appid=' + appid + ', ' + msg);
                    writeInvCache(key, null, sid);
                    return null;
                }
                W('Inventory fetch failed [' + fmt + ']:', msg);
                writeInvCache(key, null, sid);
                return null;
            } finally {
                delete invPending[key];
            }
        })();
        return invPending[key];
    }

    async function getOwnedCount(appid, hashName, ctxId) {
        if (!ctxId) ctxId = APP_CONTEXT[appid] || '2';

        const tryCtx = async (cid, fmt) => {
            const key = appid + '_' + cid + '_' + fmt;
            const cached = invCache[key];
            // v1.5.0: 补 TTL 校验。原实现直接返回缓存而不检查时间戳，
            // 导致库存数量在整个浏览器会话内永不刷新（TTL 形同虚设）。
            if (cached && Date.now() - cached.ts < CACHE_TTL.INVENTORY) {
                if (cached.data instanceof Map) return cached.data.get(hashName) || 0;
                return -1;  // null = 之前请求失败
            }
            // 缓存过期（或不存在）→ 删除后走正常请求路径，让 fetchInventory 内的 TTL 写入生效
            if (cached) delete invCache[key];
            // 通过请求队列限流，避免同时大量请求触发 429
            const owned = await enqueueInv(() => fetchInventory(appid, cid, INVENTORY_COUNT, fmt));
            if (!owned) return -1;
            return owned.get(hashName) || 0;
        };

        // 主流程：使用游戏默认 context（含分页）
        let count = await tryCtx(ctxId, 'default');
        if (count > 0) return count;

        const fallbackKey = appid + '_' + ctxId;

        // 降级1: default 格式失败时尝试 json 传统格式（用 jsonFallbackDone 避免逐条触发）
        if (count < 0 && !jsonFallbackDone[fallbackKey]) {
            jsonFallbackDone[fallbackKey] = true;
            L('[Fallback] default format failed, trying json legacy format: appid=' + appid);
            count = await tryCtx(ctxId, 'json');
            if (count > 0) return count;
        }

        // 降级2: 尝试 context 1（某些游戏物品在 context 1 下）
        if (ctxId === '2' && !SKIP_CONTEXT_1[appid]) {
            count = await tryCtx('1', 'default');
            if (count > 0) return count;
        }

        return 0;
    }

    // ==================== 市场 API ====================
    async function fetchPriceHistory(appid, hashName) {
        const cacheKey = `ph_${appid}_${hashName}`;
        const cached = cache.get(cacheKey, CACHE_TTL.PRICE_HISTORY);
        // 验证缓存数据：t 必须是数字（时间戳），旧版缓存可能是字符串（Date 序列化）
        if (cached && cached.prices && cached.prices.length > 0 && typeof cached.prices[0].t === 'number') return cached;
        // ★ v2.0.0：SSR 优先 —— 零网络请求，且拿到的是**日频中位价 + 成交量**
        //   （旧版 API 是逐笔成交价、无成交量口径，且实测极易 429）。
        //   同一次页面加载里 SSR 还带着**同款全部变体**的历史（实测 12 个变体 × 4,995 点）。
        try {
            const h = smeSsrPriceHistory(getPageSsr(), hashName);
            if (h && h.prices.length) {
                const wi = getWalletInfo();
                const sym = getCurrencySymbol(wi.wallet_currency);
                const result = {
                    prices: h.prices,
                    prefix: sym.prefix,
                    suffix: sym.suffix,
                    hasVolume: true,
                    _source: 'ssr',
                };
                cache.set(cacheKey, result);
                return result;
            }
        } catch (e) { L('SSR price history unavailable:', e && e.message); }
        const url = `https://steamcommunity.com/market/pricehistory/?appid=${appid}&market_hash_name=${encodeURIComponent(hashName)}`;
        // v1.5.1 P1-B：in-flight 去重——同物品并发调用共享同一次请求
        return cache.inflight('phreq_' + cacheKey, async () => {
            try {
                const data = await smeRequest(url, { expect: 'json' });
                if (!data.success) throw new Error('API returned success=false');
                const result = {
                    prices: (data.prices || []).map(p => ({ t: parsePriceDate(p[0]).getTime(), p: p[1], v: parseInt(p[2], 10) || 0 })),
                    prefix: data.price_prefix || '',
                    suffix: data.price_suffix || '',
                };
                cache.set(cacheKey, result);
                return result;
            } catch (err) {
                W('Price history fetch failed:', err.message);
                throw err;
            }
        });
    }

    async function fetchOrderHistogram(itemNameId, force) {
        const cacheKey = `ob_${itemNameId}`;
        if (!force) {
            const cached = cache.get(cacheKey, CACHE_TTL.ORDER_BOOK);
            // _v:2 标记含全量 graph 档位数据的新结构，旧缓存（仅 table 前几档）视为失效
            if (cached && cached._v === 2) return cached;
        }
        // v1.5.1 P1-B：in-flight 去重——同物品并发调用（含 force 与非 force）共享同一次请求
        return cache.inflight('obreq_' + itemNameId, async () => {
            const wi = getWalletInfo();
            let country = wi.wallet_country || 'US';
            let language = 'english';
            let currency = wi.wallet_currency;
            try {
                if (unsafeWindow.g_strCountryCode) country = unsafeWindow.g_strCountryCode;
                if (unsafeWindow.g_strLanguage) language = unsafeWindow.g_strLanguage;
            } catch (e) {}
            const url = `https://steamcommunity.com/market/itemordershistogram/?country=${country}&language=${language}&currency=${currency}&item_nameid=${itemNameId}&two_factor=0`;
            try {
                const data = await smeRequest(url, { expect: 'json' });
                if (!data.success) throw new Error('API returned success=false');
                const result = {
                    _v: 2,
                    sellSummary: data.sell_order_summary || '',
                    buySummary: data.buy_order_summary || '',
                    highestBuy: data.highest_buy_order || '',
                    lowestSell: data.lowest_sell_order || '',
                    prefix: data.price_prefix || '',
                    suffix: data.price_suffix || '',
                };
                // graph 为全量档位（100+ 档），table 仅前几档；档位数更多者胜出
                const sellGraph = parseOrderGraph(data.sell_order_graph, currency);
                const buyGraph = parseOrderGraph(data.buy_order_graph, currency);
                const tableSell = parseOrderTable(data.sell_order_table);
                const tableBuy = parseOrderTable(data.buy_order_table);
                result.sellOrders = sellGraph.length > tableSell.length ? sellGraph : tableSell;
                result.buyOrders = buyGraph.length > tableBuy.length ? buyGraph : tableBuy;
                cache.set(cacheKey, result);
                return result;
            } catch (err) {
                W('Order histogram fetch failed:', err.message);
                throw err;
            }
        });
    }

    function parseOrderTable(htmlStr) {
        if (!htmlStr) return [];
        try {
            const doc = new DOMParser().parseFromString(htmlStr, 'text/html');
            const rows = doc.querySelectorAll('tr');
            const orders = [];
            rows.forEach(row => {
                const cells = row.querySelectorAll('td');
                if (cells.length >= 2) {
                    const price = cells[0].textContent.trim();
                    const qty = parseInt(cells[1].textContent.trim().replace(/[^\d]/g, ''), 10);
                    if (price && qty > 0) orders.push({ price, qty, _cents: parsePriceToCents(price) });
                }
            });
            return orders;
        } catch (e) {
            return [];
        }
    }

    /**
     * graph 价格 → 最小货币单位（分）
     * itemordershistogram 的 *_order_graph 价格可能是「分」整数（请求时带 currency 参数），
     * 也可能是「显示值」小数（如 5.63），非整数时按 ×100 换算
     */
    function graphPriceToCents(price) {
        const n = parseFloat(price);
        if (isNaN(n)) return 0;
        return n % 1 !== 0 ? Math.round(n * 100) : n;
    }

    /**
     * 解析 itemordershistogram 的 sell_order_graph / buy_order_graph（[[价格, 累计数], ...]）
     * 借鉴 steam-market-quantity-viewer：graph 的数量为累计值，逐档做差还原每档真实在售/求购数，
     * 可获得 100+ 档全量分布（原生 sell_order_table 只返回前几档）。
     * 自适应检测：若逐档数量本就单调不减且非累计格式，差值会得到错误结果——
     * 通过"是否为累计曲线"检测（数量整体单调不减则视为累计），与数据格式无关地输出每档数量。
     */
    function parseOrderGraph(graph, currencyCode) {
        if (!Array.isArray(graph) || graph.length === 0) return [];
        const raw = graph.map(e => ({
            cents: graphPriceToCents(e && e[0]),
            value: parseInt(e && e[1], 10) || 0,
        })).filter(r => r.cents > 0);
        if (raw.length === 0) return [];
        let cumulative = raw.length > 1;
        for (let i = 1; i < raw.length; i++) {
            if (raw[i].value < raw[i - 1].value) { cumulative = false; break; }
        }
        let prev = 0;
        const orders = [];
        for (const r of raw) {
            const qty = cumulative ? Math.max(0, r.value - prev) : r.value;
            if (cumulative) prev = r.value;
            if (qty <= 0) continue;
            orders.push({ price: formatCentsStr(r.cents, currencyCode), qty, _cents: r.cents });
        }
        return orders;
    }

    // ==================== 手续费计算 ====================
    let _walletInfo = null;
    function getWalletInfo() {
        // 仅缓存成功解析出的钱包信息；完全取不到时的默认值不缓存，
        // 以便后续调用在页面数据就绪后能拿到正确的货币。
        if (_walletInfo) return _walletInfo;
        // 1) 经典页面的全局变量 g_rgWalletInfo
        try {
            const wi = unsafeWindow.g_rgWalletInfo;
            if (wi && wi.wallet_currency != null) {
                _walletInfo = {
                    wallet_fee_percent: parseFloat(wi.wallet_fee_percent) || 0.05,
                    wallet_fee_base: parseInt(wi.wallet_fee_base) || 0,
                    wallet_fee_minimum: parseInt(wi.wallet_fee_minimum) || 1,
                    wallet_publisher_fee_percent_default: parseFloat(wi.wallet_publisher_fee_percent_default) || 0.10,
                    wallet_currency: wi.wallet_currency,
                    wallet_country: wi.wallet_country || '',
                };
                // 检测货币代码以决定取整方式（2025年12月Steam变更）
                _walletInfo.currency_code = getCurrencyCode(_walletInfo.wallet_currency);
                _walletInfo.use_round = smeFeeUsesRound(_walletInfo.currency_code);
                return _walletInfo;
            }
        } catch (e) {}
        // 2) ★ v2.0.0：新版 React 市场页**没有** g_rgWalletInfo / v_currencyformat /
        //    GetCurrencyCode / g_strCountryCode（实测出现次数均为 0），
        //    旧实现会静默退回硬编码 USD 默认值 → CNY 用户的「税后到手价」按美元算。
        //    现在从页面 SSR 上下文取：币种(eCurrency) / 地区与语言(Config) /
        //    按游戏的发行商费率(listings[].publisherFeePct)。
        try {
            const ssr = getPageSsr();
            if (ssr) {
                const w = smeSsrWallet(ssr);
                if (w.currency != null || w.country || w.publisherFeePct != null) {
                    const cur = w.currency != null ? w.currency : 1;
                    const code = smeCurrencyCode(cur);
                    _walletInfo = {
                        wallet_fee_percent: 0.05,
                        wallet_fee_base: 0,
                        wallet_fee_minimum: 1,
                        wallet_publisher_fee_percent_default: w.publisherFeePct != null ? w.publisherFeePct : 0.10,
                        wallet_currency: cur,
                        wallet_country: w.country || '',
                        country: w.country || '',
                        language: w.language || '',
                        currency_code: code,
                        use_round: smeFeeUsesRound(code),
                        _fromSsr: true,
                    };
                    return _walletInfo;
                }
            }
        } catch (e) {}
        // 默认值：Steam 5% + 发行商 10%（不缓存，下次调用重试）
        return {
            wallet_fee_percent: 0.05,
            wallet_fee_base: 0,
            wallet_fee_minimum: 1,
            wallet_publisher_fee_percent_default: 0.10,
            wallet_currency: 1,
            wallet_country: '',
            country: '',
            language: '',
            currency_code: 'USD',
            use_round: false,
        };
    }

    /**
     * Steam 货币 ID → 货币代码映射。
     * v2.0.0：旧表与 CURRENCY_SYMBOLS 自相矛盾且缺项（8 漏、38/39/41 写错、43 误写为 JPY），
     * 现委托纯计算层 SME_CURRENCY_ECODE（依据 Steamworks 官方 ECurrency 表）。
     * Proxy 保留 `in` 语义：ISO 代码也能查（旧的 `code in CURRENCY_ID_TO_CODE` 恒为 false）。
     */
    const CURRENCY_ID_TO_CODE = new Proxy({}, {
        get(t, k) {
            if (typeof k !== 'string') return undefined;
            const id = parseInt(k, 10);
            if (!isFinite(id)) return undefined;
            return SME_CURRENCY_ECODE[id] || undefined;
        },
        has(t, k) {
            if (typeof k !== 'string') return false;
            for (const code of Object.keys(SME_CURRENCY_SYMBOL)) {
                if (code === k) return true;
            }
            return false;
        },
    });    function getCurrencyCode(currencyId) {
        try {
            if (unsafeWindow.GetCurrencyCode) return unsafeWindow.GetCurrencyCode(currencyId);
        } catch (e) {}
        // v2.0.0：委托纯计算层的官方映射（Steamworks ECurrency 表）
        return smeCurrencyCode(currencyId);
    }

    // ==================== 汇率换算（v2.2.0 收敛到 shared/fx-core.lib.js） ====================
    // v2.2.0 把旧的 _exchangeCache 整层删掉，改走 FxCore。旧层的四个毛病：
    //   ① **没有 payload 日期校验** —— currency-api 的 jsdelivr 副本实测 date=2026-11-05，
    //      pages.dev 副本是 2026-11-06，两个镜像本身差一天，旧层却都当"新鲜"用。
    //   ② 只有 2 个源（都是 currency-api 镜像），没有 ECB / er-api / AS 冗余。
    //   ③ 没有无 TTL 快照，也没有他脚本快照救援 —— 接口一挂就只能显示原始货币。
    //   ④ 交叉汇率 rates[from][to] 在新表落地后不失效，6h TTL 内可能返回旧表算出的值。
    // 现在：4 个源 + payload 级新鲜度闸门 + 双锚点隔离 + 快照/救援 + 单飞（不惊群）。
    // 宽表模式（wideTable）：spot 锚逐币种合并各源，补上 ECB 不公布的币种
    //（RUB/TRY/UAH/VND/PHP/NOK/SEK/PLN —— ECB 2022 年后不公布卢布）。
    const fxEngine = (window.FxCore && typeof window.FxCore.create === 'function')
        ? window.FxCore.create({ wideTable: true })
        : null;

    /**
     * 取汇率（1 fromCode = ? toCode）。
     * 走 FxCore 的 spot 锚；取不到就抛（unknown≠0 —— 绝不返回 0，也绝不拿旧值充数）。
     */
    async function getExchangeRate(fromCode, toCode) {
        fromCode = String(fromCode || '').toUpperCase();
        toCode = String(toCode || '').toUpperCase();
        if (!fromCode || !toCode) throw new Error('汇率参数缺失');
        if (fromCode === toCode) return 1;
        if (!fxEngine) throw new Error('汇率库没有载入');
        const mem = await fxEngine.load();
        const r = window.FxCore.convert(1, fromCode, toCode, mem.spot && mem.spot.rates);
        if (r === null || !Number.isFinite(r)) throw new Error('汇率不可用：' + fromCode + '→' + toCode);
        return r;
    }

    /**
     * 同步获取汇率（只读内存里的锚点，缓存未命中返回 null，不发起网络请求）
     */
    function getExchangeRateSync(fromCode, toCode) {
        fromCode = String(fromCode || '').toUpperCase();
        toCode = String(toCode || '').toUpperCase();
        if (!fromCode || !toCode) return null;
        if (fromCode === toCode) return 1;
        if (!fxEngine) return null;
        return fxEngine.getRate(fromCode, toCode);
    }

    /**
     * 将指定货币的分值转换为参考货币价格字符串
     * @param {number} cents - 源货币的分值（如 233400 表示 INR 2334.00）
     * @param {number|string} sourceCurrencyIdOrCode - 源货币 ID 或代码
     * @param {string} targetCode - 目标货币代码（默认从设置读取）
     * @returns {Promise<string|null>} 格式化后的参考价格字符串，失败返回 null
     */
    async function formatReferencePrice(cents, sourceCurrencyIdOrCode, targetCode) {
        if (!cents || cents <= 0) return null;
        const refCur = targetCode || settings.get('referenceCurrency') || 'CNY';
        const sourceCode = typeof sourceCurrencyIdOrCode === 'number'
            ? getCurrencyCode(sourceCurrencyIdOrCode)
            : String(sourceCurrencyIdOrCode).toUpperCase();
        if (sourceCode === refCur.toUpperCase()) return null; // 同源无需换算

        try {
            const rate = await getExchangeRate(sourceCode, refCur);
            const amount = (cents / 100) * rate;
            const sym = CURRENCY_SYMBOLS_BY_CODE[refCur.toUpperCase()] || { prefix: '', suffix: ' ' + refCur };
            // 根据货币类型决定小数位数
            const decimals = CURRENCY_ZERO_DECIMAL.includes(refCur.toUpperCase()) ? 0 : 2;
            return sym.prefix + amount.toFixed(decimals) + sym.suffix;
        } catch (e) {
            return null;
        }
    }

    /** 货币代码 → 符号映射（参考货币显示用） */
    const CURRENCY_SYMBOLS_BY_CODE = {
        USD: { prefix: '$', suffix: '' },
        CNY: { prefix: '¥', suffix: '' },
        EUR: { prefix: '€', suffix: '' },
        GBP: { prefix: '£', suffix: '' },
        JPY: { prefix: '¥', suffix: '' },
        KRW: { prefix: '₩', suffix: '' },
        INR: { prefix: '₹', suffix: '' },
        RUB: { prefix: '₽', suffix: '' },
        BRL: { prefix: 'R$', suffix: '' },
        AUD: { prefix: 'A$', suffix: '' },
        CAD: { prefix: 'CDN$', suffix: '' },
        SGD: { prefix: 'S$', suffix: '' },
        HKD: { prefix: 'HK$', suffix: '' },
        TWD: { prefix: 'NT$', suffix: '' },
        THB: { prefix: '฿', suffix: '' },
        VND: { prefix: '₫', suffix: '' },
        IDR: { prefix: 'Rp', suffix: '' },
        MYR: { prefix: 'RM', suffix: '' },
        PHP: { prefix: '₱', suffix: '' },
        MXN: { prefix: 'Mex$', suffix: '' },
        ARS: { prefix: 'ARS$', suffix: '' },
        CLP: { prefix: 'CLP$', suffix: '' },
        COP: { prefix: 'COL$', suffix: '' },
        PEN: { prefix: 'S/', suffix: '' },
        UYU: { prefix: '$U', suffix: '' },
        SAR: { prefix: 'SR ', suffix: ' SR' },
        AED: { prefix: 'AED ', suffix: ' AED' },
        TRY: { prefix: '₺', suffix: '' },
        PLN: { prefix: 'zł', suffix: '' },
        CZK: { prefix: 'Kč', suffix: '' },
        CHF: { prefix: 'CHF ', suffix: '' },
        NOK: { prefix: 'kr', suffix: '' },
        ZAR: { prefix: 'R', suffix: '' },
        ILS: { prefix: '₪', suffix: '' },
        BYN: { prefix: 'Br', suffix: '' },
        KZT: { prefix: '₸', suffix: '' },
        UAH: { prefix: '₴', suffix: '' },
        NZD: { prefix: 'NZ$', suffix: '' },
        CRC: { prefix: '₡', suffix: '' },
        QAR: { prefix: 'QR ', suffix: ' QR' },
    };

    /** 零小数位货币（如日元、韩元） */
    const CURRENCY_ZERO_DECIMAL = ['JPY', 'KRW', 'CLP', 'VND', 'IDR', 'CRC'];

    /** 使用逗号作为小数点的货币（欧洲/拉美等格式） */
    const DECIMAL_COMMA_CURRENCIES = new Set([
        'EUR', 'RUB', 'TRY', 'UAH', 'PLN', 'BRL', 'ARS', 'UYU', 'CZK',
    ]);

    // 符号歧义优先级：同一符号对应多个货币时，优先匹配列表中靠前的货币
    const SYMBOL_AMBIGUITY_PRIORITY = ['CNY', 'USD'];

    // 惰性构建的符号检测列表（按符号长度从长到短排序）
    let _currencyDetectList = null;
    function buildCurrencyDetectList() {
        const symToCodes = {};
        // 从 CURRENCY_SYMBOLS_BY_CODE 提取所有符号
        for (const code in CURRENCY_SYMBOLS_BY_CODE) {
            const sym = CURRENCY_SYMBOLS_BY_CODE[code];
            // 提取 prefix 和 suffix 中的符号（去掉空格）
            const prefixSym = sym.prefix.trim();
            const suffixSym = sym.suffix.trim();
            if (prefixSym) {
                if (!symToCodes[prefixSym]) symToCodes[prefixSym] = [];
                symToCodes[prefixSym].push(code);
            }
            if (suffixSym && suffixSym !== prefixSym) {
                if (!symToCodes[suffixSym]) symToCodes[suffixSym] = [];
                symToCodes[suffixSym].push(code);
            }
        }
        // 转换为 [symbol, code] 数组，并按符号长度从长到短排序
        const list = [];
        for (const sym in symToCodes) {
            const codes = symToCodes[sym];
            let code = codes[0];
            // 有歧义时按优先级选择
            if (codes.length > 1) {
                for (const priorityCode of SYMBOL_AMBIGUITY_PRIORITY) {
                    if (codes.includes(priorityCode)) {
                        code = priorityCode;
                        break;
                    }
                }
            }
            list.push([sym, code]);
        }
        list.sort((a, b) => b[0].length - a[0].length);
        return list;
    }

    /**
     * 从价格文本中检测货币代码（从价格文本中提取符号，匹配最精确的）
     * @param {string} priceText - 价格文本，如 "₹94,780.00"、"$1.23"、"123,45€"
     * @returns {{code: string, dc: boolean}|null} 货币代码和是否逗号小数，检测不到返回 null
     */
    function detectCurrencyFromText(priceText) {
        const text = priceText.trim();
        if (!_currencyDetectList) _currencyDetectList = buildCurrencyDetectList();
        // 按符号长度从长到短匹配，优先匹配多字符符号（如 R$、CDN$、A$ 优先于 $）
        for (const [sym, code] of _currencyDetectList) {
            if (text.includes(sym)) {
                return { code, dc: DECIMAL_COMMA_CURRENCIES.has(code) };
            }
        }
        return null;
    }

    /**
     * 从卖家到手价反推买家支付价（含手续费）
     * 参考 Steam Economy Enhancer 的 CalculateAmountToSendForDesiredReceivedAmount
     * 2025年12月Steam变更：部分货币使用 Math.round 而非 Math.floor
     */
    function calcAmountToSend(receivedAmount, publisherFee) {
        const wi = getWalletInfo();
        if (publisherFee === undefined) publisherFee = wi.wallet_publisher_fee_percent_default;
        // 2025年12月变更：根据货币类型选择取整方式
        const roundFee = wi.use_round ? Math.round : Math.floor;
        const minFee = wi.wallet_fee_minimum;
        // 关键顺序：计算百分比 → 加 base → 取整 → 与最低手续费比较取最大值
        const nSteamFee = Math.max(
            parseInt(roundFee(receivedAmount * wi.wallet_fee_percent + wi.wallet_fee_base)),
            minFee
        );
        const nPublisherFee = publisherFee > 0
            ? Math.max(parseInt(roundFee(receivedAmount * publisherFee)), minFee)
            : 0;
        return {
            steam_fee: nSteamFee,
            publisher_fee: nPublisherFee,
            fees: nSteamFee + nPublisherFee,
            amount: receivedAmount + nSteamFee + nPublisherFee,
        };
    }

    /**
     * 从买家支付价反推卖家到手价（不含手续费）
     * 使用迭代逼近法解决 floor 导致的 1-2 分误差
     */
    function calcReceivedAmount(paidAmount, publisherFee) {
        const wi = getWalletInfo();
        if (publisherFee === undefined) publisherFee = wi.wallet_publisher_fee_percent_default;
        let estimatedReceived = paidAmount;
        let iterations = 0;
        let lastAmount = 0;
        while (iterations < 10) {
            const result = calcAmountToSend(estimatedReceived, publisherFee);
            if (result.amount === paidAmount || result.amount === lastAmount) {
                return { received: estimatedReceived, ...result };
            }
            lastAmount = result.amount;
            estimatedReceived = paidAmount - result.fees;
            iterations++;
        }
        const result = calcAmountToSend(estimatedReceived, publisherFee);
        return { received: estimatedReceived, ...result };
    }

    /** 买家支付价 → 卖家到手价（分） */
    function priceBeforeFees(priceWithFeesCents) {
        return calcReceivedAmount(priceWithFeesCents).received;
    }

    /** 卖家到手价 → 买家支付价（分） */
    function priceIncludingFees(priceBeforeFeesCents) {
        return calcAmountToSend(priceBeforeFeesCents).amount;
    }

    /**
     * 解析价格字符串为分（cents）
     * 如 "¥3.50" → 350, "$0.03" → 3
     */
    function parsePriceToCents(priceStr, decimalComma = false) {
        if (!priceStr) return 0;
        // 提取数字部分：包含数字、逗号、点、空格（支持空格千分位如 "10 863,00"）
        const m = String(priceStr).match(/([\d.,\s]+)/);
        if (!m) return 0;
        let s = m[1].replace(/\s+/g, ''); // 去掉所有空格（包括不间断空格）
        if (!s) return 0;
        const li = s.lastIndexOf('.'), ci = s.lastIndexOf(',');
        if (decimalComma) {
            // 已知该货币使用逗号作为小数点：点是千分位，逗号是小数点
            s = ci >= 0 ? s.replace(/\./g, '').replace(',', '.') : s.replace(/\./g, '');
        } else if (li > 0 && ci > 0) {
            // 两个符号都有：根据最后出现的位置判断
            s = li > ci ? s.replace(/,/g, '') : s.replace(/\./g, '').replace(',', '.');
        } else if (ci > 0 && li < 0) {
            // 只有逗号没有点：如果逗号后面是2位数字，认为是小数点；否则是千分位
            const afterComma = s.length - ci - 1;
            s = afterComma === 2 ? s.replace(',', '.') : s.replace(/,/g, '');
        } else {
            // 只有点或都没有：点是小数点
            s = s.replace(/,/g, '');
        }
        return Math.round(parseFloat(s) * 100) || 0;
    }

    /**
     * 格式化分→价格字符串（复用 Steam 原生函数或自行格式化）
     */
    function formatCents(cents, prefix = '', suffix = '') {
        try {
            const wi = getWalletInfo();
            if (unsafeWindow.v_currencyformat) {
                return unsafeWindow.v_currencyformat(cents, wi.wallet_currency);
            }
        } catch (e) {}
        return prefix + (cents / 100).toFixed(2) + suffix;
    }

    // ==================== 物品类型检测 ====================
    /** 判断是否为交易卡牌 */
    function isTradingCard(item) {
        if (!item) return false;
        const type = (item.type || item.item_type || '').toLowerCase();
        const tags = item.tags || {};
        // 通过 tags 检测
        if (tags.item_class) {
            const cls = Array.isArray(tags.item_class) ? tags.item_class : [tags.item_class];
            for (const t of cls) {
                if (t && t.internal_name === 'item_class_2') return true;
            }
        }
        // 通过 type 名称检测
        return type === 'trading card' || type === '交易卡牌';
    }

    /** 判断是否为闪箔卡牌 */
    function isFoilTradingCard(item) {
        if (!item) return false;
        if (!isTradingCard(item)) return false;
        const name = (item.name || item.market_hash_name || '').toLowerCase();
        return name.includes('foil') || name.includes('闪箔');
    }

    /** 判断是否为宝石 */
    function isGems(item) {
        if (!item) return false;
        const name = (item.name || item.market_hash_name || '').toLowerCase();
        const type = (item.type || '').toLowerCase();
        return name.includes('gem') || type.includes('gem') || name.includes('宝石');
    }

    /**
     * 判断是否为箱子/武器箱（v2.2.5，参考 Steam Economy Enhancer 的 getIsCrate）
     * Steam 库存描述里 tags 是数组，Type 分类的 internal_name 为 Supply Crate；
     * CS2 武器箱没有这个 tag，只能按名称兜底（Case / 武器箱 / Container）。
     */
    function isCrate(item) {
        if (!item) return false;
        const tags = Array.isArray(item.tags) ? item.tags : [];
        for (const t of tags) {
            if (t && /supply crate/i.test(t.internal_name || '')) return true;
        }
        const name = (item.market_hash_name || item.name || '').toLowerCase();
        return /\bcase\b|\bcrate\b|武器箱|箱子|container/.test(name);
    }

    /**
     * 根据物品类型获取差异化价格范围
     * 参考 Steam Economy Enhancer 的 getPriceInformation
     * @returns {{min:number, max:number}} 本地货币单位
     */
    function getItemPriceInfo(item) {
        if (!item) {
            return { min: settings.get('minPrice'), max: settings.get('maxPrice') };
        }
        if (isFoilTradingCard(item)) {
            return { min: settings.get('minFoilCardPrice'), max: settings.get('maxFoilCardPrice') };
        }
        if (isTradingCard(item)) {
            return { min: settings.get('minNormalCardPrice'), max: settings.get('maxNormalCardPrice') };
        }
        return { min: settings.get('minMiscPrice'), max: settings.get('maxMiscPrice') };
    }

    /** 判断错误消息是否为"上一个操作未完成"重试类消息 */
    const RETRY_MSG_RE = /(?:在上一个操作完成之前|before your previous action|You cannot do this right now)/i;
    function isRetryMessage(msg) {
        return RETRY_MSG_RE.test(msg || '');
    }

    /** 随机整数 [min, max] */
    function randInt(min, max) {
        return Math.floor(Math.random() * (max - min + 1)) + min;
    }

    // ==================== 定价算法 ====================
    const ALGORITHM_NAMES = {
        1: '最高价优先（历史均价 vs 最低卖单）',
        2: '最低卖单',
        3: '最高买单或最低卖单',
        4: '历史均价',
    };

    /**
     * 计算价格历史加权均价（转为分，不含手续费）
     * 参考 Steam Economy Enhancer 的 calculateAverageHistoryPriceBeforeFees
     */
    function calcAverageHistoryPrice(priceHistory, hours) {
        if (!priceHistory || !priceHistory.prices || priceHistory.prices.length === 0) return -1;
        const cutoff = Date.now() - hours * 60 * 60 * 1000;
        let totalValue = 0, totalQty = 0;
        for (const p of priceHistory.prices) {
            if (p.t >= cutoff) {
                totalValue += p.p * p.v;
                totalQty += p.v;
            }
        }
        if (totalQty === 0) return -1;
        const avgPrice = Math.floor(totalValue / totalQty) * 100; // 转为分
        return priceBeforeFees(avgPrice);
    }

    /**
     * 获取最低卖单价（分，不含手续费），含智能低数量过滤
     * 参考 Steam Economy Enhancer 的 calculateListingPriceBeforeFees
     */
    function calcLowestListingPrice(orderBook, ignoreLowQty) {
        if (!orderBook || !orderBook.lowestSell) return -1;
        // lowestSell 已是分（cents），直接 parseInt
        const lowestCents = parseInt(orderBook.lowestSell, 10) || 0;
        if (!ignoreLowQty || !orderBook.sellOrders || orderBook.sellOrders.length < 2) {
            return priceBeforeFees(lowestCents);
        }
        // 智能过滤：最低价挂单数量极少时使用第二低价
        const lowestQty = orderBook.sellOrders[0]?.qty || 0;
        // sellOrders 价格可能是格式化字符串（如 "¥20.70"）或带 _cents 属性
        const secondOrder = orderBook.sellOrders[1];
        const secondCents = secondOrder?._cents != null
            ? secondOrder._cents
            : parsePriceToCents(secondOrder?.price);
        const secondQty = secondOrder?.qty || 0;
        if (secondQty === 0 || lowestQty === 0 || !secondCents) return priceBeforeFees(lowestCents);
        const pctLower = 100 * (lowestQty / secondQty);
        // 按第二低价数量分级判断
        let useSecond = false;
        if (secondQty >= 1000 && pctLower <= 5) useSecond = true;
        else if (secondQty >= 100 && pctLower <= 10) useSecond = true;
        else if (secondQty >= 50 && pctLower <= 15) useSecond = true;
        else if (secondQty >= 25 && pctLower <= 20) useSecond = true;
        else if (secondQty >= 10 && pctLower <= 25) useSecond = true;
        else if (pctLower <= 30) useSecond = true;
        return priceBeforeFees(useSecond ? secondCents : lowestCents);
    }

    /**
     * 获取最高买单价（分，不含手续费）
     */
    function calcHighestBuyOrderPrice(orderBook) {
        if (!orderBook || !orderBook.highestBuy) return -1;
        // highestBuy 已是分（cents），直接 parseInt
        return priceBeforeFees(parseInt(orderBook.highestBuy, 10) || 0);
    }

    /**
     * 综合定价算法 — 计算建议出售价格（分，不含手续费）
     * 参考 Steam Economy Enhancer 的 calculateSellPriceBeforeFees
     * @param {object} priceHistory - 价格历史数据
     * @param {object} orderBook - 订单簿数据
     * @param {boolean} applyOffset - 是否应用价格偏移
     * @returns {object} { priceCents, source, historyPrice, listingPrice, buyOrderPrice }
     */
    function calcSellPrice(priceHistory, orderBook, applyOffset) {
        const algo = settings.get('priceAlgorithm');
        const ignoreLowQty = settings.get('ignoreLowQuantity');
        const historyHours = settings.get('historyHours');
        const offsetCents = Math.round(settings.get('priceOffset') * 100);
        const minCents = Math.round(settings.get('minPrice') * 100);
        const maxCents = Math.round(settings.get('maxPrice') * 100);

        const historyPrice = calcAverageHistoryPrice(priceHistory, historyHours);
        const listingPrice = calcLowestListingPrice(orderBook, ignoreLowQty);
        const buyOrderPrice = calcHighestBuyOrderPrice(orderBook);

        let calculatedPrice = 0;
        let source = '';

        if (algo === 3 && buyOrderPrice > 0) {
            // 算法3: 最高买单（即时卖出）
            calculatedPrice = buyOrderPrice;
            source = '最高买单';
        } else if (algo === 4 && historyPrice > 0) {
            // 算法4: 仅历史均价
            calculatedPrice = historyPrice;
            source = '历史均价';
        } else if (algo === 2 && listingPrice > 0) {
            // 算法2: 最低卖单
            calculatedPrice = listingPrice;
            source = '最低卖单';
        } else {
            // 算法1（默认）: max(历史均价, 最低卖单)
            if (historyPrice > 0 && listingPrice > 0) {
                calculatedPrice = Math.max(historyPrice, listingPrice);
                source = historyPrice >= listingPrice ? '历史均价' : '最低卖单';
            } else if (listingPrice > 0) {
                calculatedPrice = listingPrice;
                source = '最低卖单';
            } else if (historyPrice > 0) {
                calculatedPrice = historyPrice;
                source = '历史均价';
            }
        }

        // 无数据时使用最大价格
        let changedToMax = false;
        if (calculatedPrice <= 0) {
            calculatedPrice = maxCents;
            changedToMax = true;
            source = '最大限价';
        }

        // 应用价格偏移
        if (!changedToMax && applyOffset && offsetCents !== 0) {
            calculatedPrice += offsetCents;
        }

        // 钳制在 min/max 范围内
        calculatedPrice = Math.max(minCents, Math.min(maxCents, calculatedPrice));

        // 如果买单价格高于计算价格，使用买单价格（除非算法4）
        if (algo !== 4 && orderBook && orderBook.highestBuy) {
            const buyPrice = calcHighestBuyOrderPrice(orderBook);
            if (buyPrice > calculatedPrice) {
                calculatedPrice = buyPrice;
                source = '最高买单(覆盖)';
            }
        }

        return {
            priceCents: calculatedPrice,
            source,
            historyPrice,
            listingPrice,
            buyOrderPrice,
        };
    }

    /**
     * 判断单个挂单的价格状态
     * @returns {object} { status: 'overpriced'|'underpriced'|'fair'|'unchecked', suggestedCents, source }
     */
    function checkListingPrice(order, priceHistory, orderBook) {
        if (!orderBook || !orderBook.lowestSell) {
            return { status: 'unchecked', suggestedCents: 0, source: '' };
        }
        const result = calcSellPrice(priceHistory, orderBook, false);
        const suggestedWithFees = priceIncludingFees(result.priceCents);
        const orderPriceCents = parsePriceToCents(order.buyerPrice);

        let status;
        if (suggestedWithFees > 0 && orderPriceCents > suggestedWithFees) {
            status = 'overpriced';
        } else if (suggestedWithFees > 0 && orderPriceCents < suggestedWithFees) {
            status = 'underpriced';
        } else {
            status = 'fair';
        }
        return { status, suggestedCents: result.priceCents, source: result.source };
    }

    // ==================== 上架 API ====================
    /**
     * 上架物品
     * POST /market/sellitem/
     * @param {object} params - { assetid, appid, contextid, priceCents }
     * @returns {Promise<object>} Steam API 返回的 data（含 listingid, message, success 等）
     */
    async function sellItem(params) {
        const sessionid = await resolveSessionId();
        if (!sessionid) throw new Error('无法获取会话ID');
        const body = new URLSearchParams({
            sessionid,
            appid: String(params.appid),
            contextid: String(params.contextid),
            assetid: String(params.assetid),
            amount: String(params.amount || 1),
            price: String(params.priceCents),
        });
        const data = await smeRequest('https://steamcommunity.com/market/sellitem/', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
                'X-Requested-With': 'XMLHttpRequest',
            },
            body: body.toString(),
        });
        if (!data.success) throw new Error(data.message || '上架失败');
        return data;
    }

    /**
     * 多来源解析 contextid（参考 steam-market-listings-group 2.6.2）
     * g_rgAppContextData → SSR loaderData 扫描 → 页面 HTML 正则 → 静态映射 → 默认值
     */
    function resolveContextId(appId) {
        appId = String(appId);
        let contextId = '';
        // 1) 旧版 g_rgAppContextData（兼容数组与对象两种结构）
        try {
            const appCtx = unsafeWindow.g_rgAppContextData && unsafeWindow.g_rgAppContextData[appId];
            if (Array.isArray(appCtx) && appCtx.length > 0 && appCtx[0].id) {
                contextId = String(appCtx[0].id);
            } else if (appCtx && typeof appCtx === 'object') {
                if (appCtx.contexts && typeof appCtx.contexts === 'object') {
                    const first = Object.keys(appCtx.contexts).find(k => /^\d+$/.test(k));
                    if (first) contextId = first;
                } else {
                    const first = Object.keys(appCtx).find(k => /^\d+$/.test(k));
                    if (first) contextId = first;
                }
            }
        } catch (e) {}
        // 2) SSR loaderData 深度扫描 contextid 字段
        if (!contextId) {
            try {
                const ssr = unsafeWindow.SSR && unsafeWindow.SSR.loaderData;
                if (Array.isArray(ssr)) {
                    for (const entry of ssr) {
                        let obj = entry;
                        if (typeof entry === 'string') { try { obj = JSON.parse(entry); } catch (e) { continue; } }
                        const html = JSON.stringify(obj || {});
                        const m = html.match(/"contextid"\s*:\s*"?(\d+)"?/i);
                        if (m) { contextId = m[1]; break; }
                    }
                }
            } catch (e) {}
        }
        // 3) 页面 HTML 源码正则（v1.5.1 P2-B：SSR 快照按页面生命周期缓存，避免每次全量序列化阻塞主线程）
        if (!contextId) {
            const html = getSsrHtmlSnapshot();
            const m = html.match(/"contextid"\s*:\s*"?(\d+)"?/i) || html.match(/contextid=(\d+)/i);
            if (m) contextId = m[1];
        }
        // 4) 静态映射 → 默认值
        if (!contextId) contextId = APP_CONTEXT[appId] || '2';
        return contextId;
    }

    /**
     * 从挂单信息获取 asset 信息（appid, contextid, assetid）
     * 使用多来源 contextid 解析，兼容新版 SSR 页面
     */
    function getAssetInfoFromOrder(order) {
        const appid = listingInfo?.appid || '';
        return {
            appid,
            contextid: resolveContextId(appid),
            assetid: order.assetid || '',
        };
    }

    // ==================== 自定义对话框 ====================
    // 参考 steam-market-listings-group 2.6.2 的 confirm/price dialog 实现

    /** 自定义确认对话框（支持 HTML 内容） */
    function showConfirmDialog(message, opts) {
        const { title = '确认操作', okText = '确认', okClass = 'sme-dialog-ok' } = opts || {};
        return new Promise(resolve => {
            const prevFocus = document.activeElement;
            const overlay = document.createElement('div');
            overlay.className = 'sme-dialog-overlay';
            overlay.innerHTML = `
                <div class="sme-dialog-box" role="dialog" aria-modal="true" aria-label="${escapeHtml(title)}">
                    <div class="sme-dialog-title">${escapeHtml(title)}</div>
                    <div class="sme-dialog-body">${message}</div>
                    <div class="sme-dialog-actions">
                        <button class="sme-dialog-btn sme-dialog-cancel" id="sme-dlg-cancel">取消</button>
                        <button class="sme-dialog-btn ${okClass}" id="sme-dlg-ok">${escapeHtml(okText)}</button>
                    </div>
                </div>`;
            document.body.appendChild(overlay);
            const cancelBtn = overlay.querySelector('#sme-dlg-cancel');
            const okBtn = overlay.querySelector('#sme-dlg-ok');
            // v1.5.1 P2-C：ESC 关闭 + Tab 焦点陷阱 + 关闭后焦点还原
            const onKey = (e) => {
                if (e.key === 'Escape') { e.stopPropagation(); cleanup(false); }
                else if (e.key === 'Tab') {
                    e.preventDefault();
                    const items = [cancelBtn, okBtn];
                    const idx = items.indexOf(document.activeElement);
                    const next = e.shiftKey
                        ? items[(idx <= 0 ? items.length : idx) - 1]
                        : items[(idx + 1) % items.length];
                    next.focus();
                }
            };
            const cleanup = (result) => {
                document.removeEventListener('keydown', onKey, true);
                overlay.remove();
                if (prevFocus && typeof prevFocus.focus === 'function') { try { prevFocus.focus(); } catch (e) {} }
                resolve(result);
            };
            document.addEventListener('keydown', onKey, true);
            cancelBtn.addEventListener('click', () => cleanup(false));
            okBtn.addEventListener('click', () => cleanup(true));
            overlay.addEventListener('click', (e) => { if (e.target === overlay) cleanup(false); });
            okBtn.focus();
        });
    }

    /**
     * 价格输入对话框（到手价 ↔ 买方支付价 联动）
     * @param {string} oldPrice - 原价格展示字符串
     * @param {number} count - 待重新上架数量
     * @param {number} suggestedCents - 建议到手价（分），用于预填
     * @returns {Promise<{receivedCents:number, buyerCents:number}|null>} null 表示取消
     */
    function showPriceDialog(oldPrice, count, suggestedCents) {
        return new Promise(resolve => {
            const wi = getWalletInfo();
            const currencyCode = wi.currency_code || 'USD';
            const decimals = smeFeeUsesRound(currencyCode) ? 0 : 2;
            const unit = Math.pow(10, decimals);
            const fmtAmount = cents => (cents / unit).toFixed(decimals);
            const suggestedStr = suggestedCents > 0 ? fmtAmount(suggestedCents) : '';
            const buyerStr = suggestedCents > 0 ? fmtAmount(calcAmountToSend(suggestedCents).amount) : '';

            const overlay = document.createElement('div');
            overlay.className = 'sme-dialog-overlay';
            overlay.innerHTML = `
                <div class="sme-dialog-box" role="dialog" aria-modal="true" aria-label="重新上架 - 输入新价格">
                    <div class="sme-dialog-title">重新上架 - 输入新价格</div>
                    <div class="sme-dialog-body">
                        将价格 <strong>${escapeHtml(oldPrice)}</strong> 的 <strong>${count}</strong> 件商品以新价格重新上架${suggestedCents > 0 ? `（建议到手价 <strong>${escapeHtml(fmtAmount(suggestedCents))}</strong>）` : ''}：
                    </div>
                    <div style="margin-bottom:20px">
                        <div class="sme-price-grid">
                            <span class="sme-price-label">您将收到 (${escapeHtml(currencyCode)})：</span>
                            <span class="sme-price-label">买方支付 (${escapeHtml(currencyCode)})：</span>
                            <input type="text" class="sme-price-input" id="sme-price-received" placeholder="${fmtAmount(0)}" value="${suggestedStr}">
                            <input type="text" class="sme-price-input" id="sme-price-buyer" placeholder="${fmtAmount(0)}" value="${buyerStr}">
                        </div>
                    </div>
                    <div class="sme-dialog-actions">
                        <button class="sme-dialog-btn sme-dialog-cancel" id="sme-price-cancel">取消</button>
                        <button class="sme-dialog-btn sme-dialog-blue" id="sme-price-ok">下一步</button>
                    </div>
                </div>`;
            document.body.appendChild(overlay);

            const receivedInput = overlay.querySelector('#sme-price-received');
            const buyerInput = overlay.querySelector('#sme-price-buyer');
            const cleanup = (result) => { overlay.remove(); resolve(result); };

            // 解析用户输入金额为分（兼容千分位逗号与欧式小数逗号）
            const parseAmount = (str) => {
                let s = String(str).replace(/\s/g, '').replace(/[^\d.,]/g, '');
                if (!s) return 0;
                if (s.includes(',') && s.includes('.')) {
                    s = s.replace(/,/g, '');
                } else if (/\d,\d{3}(?:\D|$)/.test(s)) {
                    s = s.replace(/,/g, '');
                } else {
                    s = s.replace(',', '.');
                }
                const num = parseFloat(s);
                return (!isNaN(num) && num > 0) ? Math.round(num * unit) : 0;
            };

            receivedInput.addEventListener('input', () => {
                const receivedCents = parseAmount(receivedInput.value);
                if (!receivedCents) { buyerInput.value = ''; return; }
                buyerInput.value = fmtAmount(calcAmountToSend(receivedCents).amount);
            });
            buyerInput.addEventListener('input', () => {
                const buyerCents = parseAmount(buyerInput.value);
                if (!buyerCents) { receivedInput.value = ''; return; }
                receivedInput.value = fmtAmount(calcReceivedAmount(buyerCents));
            });

            overlay.querySelector('#sme-price-cancel').addEventListener('click', () => cleanup(null));
            overlay.querySelector('#sme-price-ok').addEventListener('click', () => {
                const receivedCents = parseAmount(receivedInput.value);
                if (!receivedCents) { receivedInput.focus(); return; }
                const buyerCents = calcAmountToSend(receivedCents).amount;
                cleanup({ receivedCents, buyerCents });
            });
            [receivedInput, buyerInput].forEach(inp => inp.addEventListener('keydown', (e) => {
                if (e.key === 'Enter') overlay.querySelector('#sme-price-ok').click();
            }));
            // v1.5.1 P2-C：ESC 关闭对话框
            overlay.addEventListener('keydown', (e) => { if (e.key === 'Escape') cleanup(null); });
            overlay.addEventListener('click', (e) => { if (e.target === overlay) cleanup(null); });
            receivedInput.focus();
            receivedInput.select();
        });
    }

    // ==================== 下架后 assetid 重新获取 ====================
    // 参考 steam-market-listings-group 2.6.2：下架回库后 assetid 可能变化，
    // 需要按 classid 轮询库存 API 定位可用资产

    /**
     * 查询库存中指定 classid 的可用 assetid
     * @param {string} appId
     * @param {string} contextId
     * @param {string} classid
     * @param {Set<string>} excludeIds - 排除已使用的 assetid
     * @returns {Promise<string>} assetid，未找到返回空串
     */
    async function findReturnedAssetId(appId, contextId, classid, excludeIds) {
        try {
            // v1.5.0：走请求队列限流。原实现裸 fetch，在批量重上架循环中
            // 每件物品都会触发最多 7 次（见 waitForReturnedAsset），
            // 完全不受任何限流器约束，极易触发 Steam 429。
            const data = await enqueueInv(async () => {
                return await smeRequest(`https://steamcommunity.com/my/inventory/json/${appId}/${contextId}`, {
                    headers: { 'Accept': 'application/json' },
                    onNonOk: 'null',
                });
            });
            if (!data || !data.success || !data.rgInventory) return '';
            for (const [assetId, entry] of Object.entries(data.rgInventory)) {
                if (entry && String(entry.classid) === String(classid) && !excludeIds.has(assetId)) {
                    return assetId;
                }
            }
        } catch (e) {
            W('inventory lookup error:', e);
        }
        return '';
    }

    /**
     * 轮询等待物品回库并返回其（可能已变化的）assetid
     * @param {string} appId
     * @param {string} contextId
     * @param {string} classid
     * @param {Set<string>} excludeIds - 排除已使用的 assetid
     * @param {number} timeoutMs - 超时毫秒
     * @returns {Promise<string>} assetid，超时返回空串
     */
    async function waitForReturnedAsset(appId, contextId, classid, excludeIds, timeoutMs) {
        const start = Date.now();
        // v1.5.0：指数退避（1.5s → 3s → 6s），并给总尝试次数封顶。
        // 原实现固定 1500ms 轮询，10 秒内最多 7 次 × N 件物品，
        // 在批量重上架 20 件时是 140 次全量库存请求。
        let delay = 1500;
        let attempts = 0;
        const MAX_ATTEMPTS = 6;
        while (Date.now() - start < timeoutMs && attempts < MAX_ATTEMPTS) {
            attempts++;
            const assetId = await findReturnedAssetId(appId, contextId, classid, excludeIds);
            if (assetId) return assetId;
            if (Date.now() - start + delay >= timeoutMs) break;
            await sleep(delay);
            delay = Math.min(delay * 2, 6000);
        }
        return '';
    }

    // ==================== 价格图表 SVG ====================
    function buildPriceChartSVG(prices, prefix = '') {
        if (!prices || prices.length === 0) return '';
        const W = 800, H = 280, pL = 52, pR = 16, pT = 16, pB = 32;
        const cw = W - pL - pR, ch = H - pT - pB;

        let data = prices;
        if (data.length > 200) {
            const step = Math.ceil(data.length / 200);
            data = data.filter((_, i) => i % step === 0);
            data.push(prices[prices.length - 1]);
        }
        const n = data.length;
        const minP = Math.min(...data.map(d => d.p));
        const maxP = Math.max(...data.map(d => d.p));
        const range = maxP - minP || 1;

        const pts = data.map((d, i) => ({
            x: pL + (n === 1 ? cw / 2 : (i / (n - 1)) * cw),
            y: pT + ch - ((d.p - minP) / range) * ch,
        }));

        const linePath = pts.map((pt, i) => (i === 0 ? 'M' : 'L') + pt.x.toFixed(1) + ',' + pt.y.toFixed(1)).join(' ');
        const areaPath = linePath + ` L ${pts[n - 1].x.toFixed(1)},${(pT + ch).toFixed(1)} L ${pts[0].x.toFixed(1)},${(pT + ch).toFixed(1)} Z`;

        let gridSVG = '';
        for (let i = 0; i <= 4; i++) {
            const y = pT + (ch / 4) * i;
            const val = maxP - (range / 4) * i;
            gridSVG += `<line x1="${pL}" y1="${y.toFixed(1)}" x2="${W - pR}" y2="${y.toFixed(1)}" stroke="${CHART_COLORS.grid}" stroke-width="1"/>`;
            gridSVG += `<text x="${pL - 6}" y="${(y + 4).toFixed(1)}" text-anchor="end" fill="${CHART_COLORS.text}" font-size="10" font-family="system-ui">${prefix}${val.toFixed(2)}</text>`;
        }
        let xAxisSVG = '';
        for (let i = 0; i <= 4; i++) {
            const idx = Math.min(Math.floor((n - 1) * i / 4), n - 1);
            const pt = pts[idx];
            const d = new Date(data[idx].t);
            const dateStr = `${d.getMonth() + 1}/${d.getDate()}`;
            xAxisSVG += `<text x="${pt.x.toFixed(1)}" y="${H - 8}" text-anchor="middle" fill="${CHART_COLORS.text}" font-size="10" font-family="system-ui">${dateStr}</text>`;
        }
        const lastPt = pts[n - 1];
        const dotSVG = `<circle cx="${lastPt.x.toFixed(1)}" cy="${lastPt.y.toFixed(1)}" r="4" fill="${CHART_COLORS.dot}" stroke="#fff" stroke-width="2"><title>当前: ${prefix}${data[n-1].p.toFixed(2)}</title></circle>`;

        return `<svg viewBox="0 0 ${W} ${H}" class="sme-chart-svg" preserveAspectRatio="none">
<defs><linearGradient id="sme-grad" x1="0" y1="0" x2="0" y2="1"><stop offset="0%" stop-color="${CHART_COLORS.line}" stop-opacity="0.25"/><stop offset="100%" stop-color="${CHART_COLORS.line}" stop-opacity="0"/></linearGradient></defs>
${gridSVG}
<path d="${areaPath}" fill="url(#sme-grad)"/>
<path d="${linePath}" stroke="${CHART_COLORS.line}" stroke-width="2" fill="none" stroke-linejoin="round" stroke-linecap="round"/>
${dotSVG}
${xAxisSVG}
</svg>`;
    }

    // ==================== 面板状态 ====================
    let panelEl = null;
    let analysisFabEl = null;
    let analysisPopEl = null;
    let analysisDismissBound = false;
    let analysisFabPosTimer = null;
    let allSellOrders = [];
    let _globalClassid = '';  // 从 asset_description 提取的全局 classid，用于下架后 assetid 重获取
    let currentTab = 'summary';
    let priceHistoryData = null;
    let orderBookData = null;
    let listingInfo = null;
    let priceCheckResults = null;  // 价格检测结果：Map<buyerPrice, {status, suggestedCents, source}>
    let priceCheckLoading = false;

    // ==================== 面板创建 ====================
    function createPanel() {
        if (panelEl) return panelEl;
        tabPanes = {};  // v1.5.1 P2-A：面板重建时清空 Tab 缓存
        panelEl = h('div', { class: 'sme-panel', id: 'sme-panel' }, [
            h('div', { class: 'sme-header' }, [
                h('div', { class: 'sme-header-title' }, [
                    h('span', { html: ICONS.bag }),
                    h('span', { text: '社区市场增强' }),
                ]),
                // v1.5.1 P2-C：Tab 组语义（role=tablist/tab + aria-selected，选中态由 switchTab 维护）
                h('div', { class: 'sme-tabs', role: 'tablist', 'aria-label': '面板标签页' }, [
                    h('button', { class: 'sme-tab active', id: 'sme-tab-summary', role: 'tab', 'aria-selected': 'true', html: ICONS.list + '<span>上架汇总</span>', onClick: () => switchTab('summary') }),
                    h('button', { class: 'sme-tab', id: 'sme-tab-history', role: 'tab', 'aria-selected': 'false', html: ICONS.chart + '<span>价格历史</span>', onClick: () => switchTab('history') }),
                    h('button', { class: 'sme-tab', id: 'sme-tab-orderbook', role: 'tab', 'aria-selected': 'false', html: ICONS.layers + '<span>订单深度</span>', onClick: () => switchTab('orderbook') }),
                    // v1.9.0：挂刀比价 Tab —— 仅 CS2(730)/DOTA2(570) 详情页且开关开启时渲染
                    (settings.get('crossPlatformQuote') && (function () {
                        const li = getListingInfo();
                        return li && (li.appid === '730' || li.appid === '570');
                    })())
                        ? h('button', { class: 'sme-tab', id: 'sme-tab-ratio', role: 'tab', 'aria-selected': 'false', html: ICONS.chart + '<span>挂刀比价</span>', onClick: () => switchTab('ratio') })
                        : null,
                    h('button', { class: 'sme-tab', id: 'sme-tab-settings', role: 'tab', 'aria-selected': 'false', html: ICONS.settings + '<span>设置</span>', onClick: () => switchTab('settings') }),
                ]),
            ]),
            // v2.0.1：交易冷却提示 —— 当前物品若仍在冷却期，在面板顶部明示
            //   （数据来自本地：Steam 限制天数 + 成交记录里的获得时间）
            (function () {
                const li = getListingInfo();
                if (!li || !li.marketHashName) return null;
                const info = invCooldownInfo(li.marketHashName);
                if (!info) return null;
                return h('div', {
                    class: 'sme-cooldown-notice',
                    html: ICONS.alert + '<span>该物品仍在交易冷却期：' + info.daysLeft + ' 天后（'
                        + mhFmtTs(info.untilTs).slice(0, 16) + '）才能上架或交易</span>',
                });
            })(),
            h('div', { class: 'sme-content', id: 'sme-content' }),
        ]);
        return panelEl;
    }

    // v1.5.1 P2-A：Tab 缓存——4 个常驻 pane，首次渲染后仅 display 切换（复用既有 .sme-tab-pane 样式），
    // 消除每次切 Tab 的整块清空重绘与重复请求。数据新鲜度：URL 变化时面板整体重建（createPanel 清空缓存）；
    // 面板内批量操作（下架/重上架）后经 invalidateTabPane 主动失效重建。
    let tabPanes = {};

    /** 失效并重建某个 Tab 的常驻 pane（数据变更后调用；若为当前 Tab 立即重渲染） */
    function invalidateTabPane(tab) {
        const pane = tabPanes[tab];
        if (pane) { pane.remove(); delete tabPanes[tab]; }
        if (panelEl && currentTab === tab && document.getElementById('sme-content')) switchTab(tab);
    }

    function switchTab(tab) {
        currentTab = tab;
        panelEl.querySelectorAll('.sme-tab').forEach(b => {
            b.classList.remove('active');
            b.setAttribute('aria-selected', b.id === 'sme-tab-' + tab ? 'true' : 'false');
        });
        const btn = document.getElementById('sme-tab-' + tab);
        if (btn) { btn.classList.add('active'); btn.setAttribute('aria-selected', 'true'); }
        const content = document.getElementById('sme-content');
        if (!content) return;
        let pane = tabPanes[tab];
        if (!pane) {
            pane = h('div', { class: 'sme-tab-pane', id: 'sme-pane-' + tab, role: 'tabpanel', 'aria-label': { summary: '上架汇总', history: '价格历史', orderbook: '订单深度', settings: '设置', ratio: '挂刀比价' }[tab] || tab });
            if (tab === 'summary') renderSummary(pane);
            else if (tab === 'history') renderPriceHistory(pane);
            else if (tab === 'orderbook') renderOrderBook(pane);
            else if (tab === 'settings') renderSettings(pane);
            else if (tab === 'ratio') renderRatioPane(pane);
            tabPanes[tab] = pane;
        }
        if (!pane.isConnected) content.appendChild(pane);
        content.querySelectorAll('.sme-tab-pane').forEach(p => p.classList.toggle('active', p === pane));
        content.classList.toggle('sme-settings-grid', tab === 'settings');
    }

    // ==================== 渲染：上架汇总 ====================
    function renderSummary(container) {
        if (!allSellOrders || allSellOrders.length === 0) {
            container.appendChild(makeEmpty('您没有在售的此物品'));
            return;
        }
        const grouped = groupOrders(allSellOrders);
        const total = grouped.reduce((s, g) => s + g.totalCount, 0);
        const priceSet = new Set(allSellOrders.map(o => o.buyerPrice));

        // 计算买家/卖家总价
        let totalBuyerCents = 0, totalSellerCents = 0;
        for (const o of allSellOrders) {
            const buyerCents = parsePriceToCents(o.buyerPrice);
            totalBuyerCents += buyerCents;
            totalSellerCents += priceBeforeFees(buyerCents);
        }

        // 统计卡片（含买家/卖家总价）
        const statGrid = h('div', { class: 'sme-stats-grid' }, [
            makeStatCard(total, '在售总数'),
            makeStatCard(formatCents(totalBuyerCents), '买家总价'),
            makeStatCard(formatCents(totalSellerCents), '卖家到手'),
            makeStatCard(priceSet.size, '价格种类'),
        ]);
        container.appendChild(statGrid);

        // 价格检测信息条 + 汇总表格
        const tableContainer = h('div');
        container.appendChild(tableContainer);

        if (settings.get('autoCheckPrices') && listingInfo) {
            // 自动检测价格
            renderSummaryWithPriceCheck(tableContainer, grouped, total);
        } else {
            renderSummaryTable(tableContainer, grouped, total, null);
        }

        // 下架区域
        container.appendChild(renderDelistSection(allSellOrders));

        // 重新上架区域（仅当有价格检测结果时显示）
        if (priceCheckResults) {
            container.appendChild(renderRelistSection(allSellOrders, priceCheckResults));
        }
    }

    /**
     * 渲染带价格检测的汇总（异步获取订单簿 + 价格历史后标注）
     */
    function renderSummaryWithPriceCheck(container, grouped, total) {
        container.appendChild(h('div', { class: 'sme-price-check-info', id: 'sme-price-check-info' }, [
            h('span', { html: ICONS.refreshCw }),
            h('span', { text: '正在检测价格...' }),
        ]));
        // v1.5.1 P2-A：表格独立容器——检测完成后仅替换该容器（原地更新，信息条不闪烁）
        const tableWrap = h('div', { id: 'sme-summary-table-wrap' });
        container.appendChild(tableWrap);
        renderSummaryTable(tableWrap, grouped, total, null);

        priceCheckLoading = true;
        const tasks = [];

        // 立即获取价格历史（不依赖 item_nameid）
        tasks.push(
            fetchPriceHistory(listingInfo.appid, listingInfo.marketHashName)
                .then(data => { priceHistoryData = data; })
                .catch(err => W('Price check: price history failed:', err.message))
        );

        // 获取订单簿（SSR 优先，降级到 item_nameid+API）
        tasks.push(
            fetchOrderBook()
                .then(data => { orderBookData = data; })
                .catch(err => W('Price check: order book failed:', err.message))
        );

        Promise.allSettled(tasks).then(() => {
            priceCheckLoading = false;
            // 计算每个价格的检测状态
            priceCheckResults = new Map();
            for (const order of allSellOrders) {
                if (!priceCheckResults.has(order.buyerPrice)) {
                    const result = checkListingPrice(order, priceHistoryData, orderBookData);
                    priceCheckResults.set(order.buyerPrice, result);
                }
            }
            // 重新渲染表格
            const infoBar = document.getElementById('sme-price-check-info');
            if (infoBar) {
                const overpricedCount = [...priceCheckResults.values()].filter(r => r.status === 'overpriced').length;
                const underpricedCount = [...priceCheckResults.values()].filter(r => r.status === 'underpriced').length;
                const fairCount = [...priceCheckResults.values()].filter(r => r.status === 'fair').length;
                const uncheckedCount = [...priceCheckResults.values()].filter(r => r.status === 'unchecked').length;
                const algoName = ALGORITHM_NAMES[settings.get('priceAlgorithm')] || '';
                infoBar.innerHTML = '';
                infoBar.appendChild(h('span', { html: ICONS.check }));
                infoBar.appendChild(h('span', { text: `价格检测完成 · 算法: ` }));
                infoBar.appendChild(h('span', { class: 'sme-algo-name', text: algoName }));
                if (overpricedCount > 0) infoBar.appendChild(h('span', { style: { color: 'var(--sme-red)', marginLeft: '8px' }, text: `超价 ${overpricedCount}种` }));
                if (underpricedCount > 0) infoBar.appendChild(h('span', { style: { color: 'var(--sme-amber)', marginLeft: '8px' }, text: `低价 ${underpricedCount}种` }));
                if (fairCount > 0) infoBar.appendChild(h('span', { style: { color: 'var(--sme-green)', marginLeft: '8px' }, text: `合理 ${fairCount}种` }));
                if (uncheckedCount > 0) infoBar.appendChild(h('span', { style: { color: 'var(--sme-text-dim)', marginLeft: '8px' }, text: `未检 ${uncheckedCount}种` }));
            }
            // v1.5.1 P2-A：原地更新——仅替换表格容器，信息条已在上方原地改写，不再整块重建
            const wrap = document.getElementById('sme-summary-table-wrap');
            if (wrap) {
                wrap.innerHTML = '';
                renderSummaryTable(wrap, grouped, total, priceCheckResults);
            } else {
                // 兜底：旧结构（wrap 不存在时）
                container.innerHTML = '';
                container.appendChild(infoBar || h('div'));
                renderSummaryTable(container, grouped, total, priceCheckResults);
            }
            // 刷新重新上架区域（挂到 summary 常驻 pane 内，随 Tab 一起显示/隐藏）
            const oldRelist = document.getElementById('sme-relist-section');
            if (oldRelist) oldRelist.remove();
            const pane = document.getElementById('sme-pane-summary') || document.getElementById('sme-content');
            if (pane && priceCheckResults) {
                pane.appendChild(renderRelistSection(allSellOrders, priceCheckResults));
            }
        });
    }

    /**
     * 渲染汇总表格（可带价格检测结果）
     */
    function renderSummaryTable(container, grouped, total, checkResults) {
        let rows = '';
        for (const g of grouped) {
            const tags = g.sortedPrices.map(p => {
                const cnt = g.prices.get(p).length;
                const check = checkResults?.get(p);
                let statusClass = '';
                let suggestedHtml = '';
                if (check) {
                    statusClass = ' ' + check.status;
                    if (check.suggestedCents > 0 && check.status !== 'fair') {
                        const suggestedWithFees = priceIncludingFees(check.suggestedCents);
                        suggestedHtml = `<span class="sme-suggested">→ ${escapeHtml(formatCents(suggestedWithFees))}</span>`;
                    }
                }
                const dot = check ? `<span class="sme-status-dot"></span>` : '';
                return `<span class="sme-price-tag${statusClass}">${dot}${escapeHtml(p)}<span class="sme-ct">×${cnt}</span>${suggestedHtml}</span>`;
            }).join('');
            rows += `<tr><td class="sme-date-cell">${escapeHtml(g.dateKey)}</td><td class="sme-prices-cell">${tags}</td><td class="sme-count-cell">${g.totalCount}</td></tr>`;
        }
        const tableWrap = h('div', { style: { overflowX: 'auto' } }, []);
        tableWrap.innerHTML = `<table class="sme-table"><thead><tr><th>日期</th><th>价格分布</th><th style="text-align:right">数量</th></tr></thead><tbody>${rows}<tr class="sme-total-row"><td>合计</td><td></td><td class="sme-count-cell">${total}</td></tr></tbody></table>`;
        container.appendChild(tableWrap);
    }

    function makeStatCard(val, lbl) {
        return h('div', { class: 'sme-stat-card' }, [
            h('div', { class: 'sme-stat-val', text: String(val) }),
            h('div', { class: 'sme-stat-lbl', text: lbl }),
        ]);
    }

    /** 带参考货币的统计卡片（参考价格一行显示） */
    function makeStatCardWithRef(val, lbl, refHtml) {
        const valEl = h('div', { class: 'sme-stat-val' }, [
            h('span', { class: 'sme-stat-val-main', text: String(val) }),
        ]);
        if (refHtml) {
            valEl.appendChild(h('span', { class: 'sme-stat-ref', text: '≈' + refHtml }));
        }
        return h('div', { class: 'sme-stat-card' }, [
            valEl,
            h('div', { class: 'sme-stat-lbl', text: lbl }),
        ]);
    }

    function renderDelistSection(orders) {
        const priceMap = new Map();
        for (const o of orders) {
            priceMap.set(o.buyerPrice, (priceMap.get(o.buyerPrice) || 0) + 1);
        }
        const options = [...priceMap.entries()]
            .sort((a, b) => a[0].localeCompare(b[0]))
            .map(([p, c]) => `<option value="${escapeHtml(p)}">${escapeHtml(p)} (${c}件)</option>`)
            .join('');

        const section = h('div', { class: 'sme-delist-section' }, [
            h('div', { class: 'sme-delist-row' }, [
                h('span', { class: 'sme-delist-label', text: '下架价格:' }),
                h('select', { class: 'sme-delist-select', id: 'sme-delist-price', html: `<option value="">选择价格</option>${options}` }),
                h('span', { class: 'sme-delist-label', text: '数量:' }),
                h('input', { type: 'number', class: 'sme-delist-input', id: 'sme-delist-qty', value: '1', min: '1', placeholder: '数量' }),
                h('button', { class: 'sme-delist-btn', id: 'sme-delist-btn', text: '下架', onClick: () => handleDelist(orders, false) }),
                h('button', { class: 'sme-delist-all-btn', id: 'sme-delist-all-btn', text: '全部下架', onClick: () => handleDelist(orders, true) }),
            ]),
            h('div', { class: 'sme-progress-wrap', id: 'sme-delist-progress', style: { display: 'none' } }, [
                h('div', { class: 'sme-progress-bar', id: 'sme-delist-progress-bar' }),
            ]),
            h('div', { class: 'sme-delist-status', id: 'sme-delist-status' }),
        ]);
        return section;
    }

    async function handleDelist(orders, delistAll) {
        const priceSelect = document.getElementById('sme-delist-price');
        const qtyInput = document.getElementById('sme-delist-qty');
        const statusEl = document.getElementById('sme-delist-status');
        const btn = document.getElementById('sme-delist-btn');
        const allBtn = document.getElementById('sme-delist-all-btn');
        const progressWrap = document.getElementById('sme-delist-progress');
        const progressBar = document.getElementById('sme-delist-progress-bar');

        let candidates;
        if (delistAll) {
            candidates = [...orders].sort((a, b) => b.rtListed - a.rtListed);
            if (!(await showConfirmDialog(`确定要下架全部 <strong>${candidates.length}</strong> 件物品吗？`, { title: '批量下架', okText: '全部下架', okClass: 'sme-dialog-btn sme-dialog-ok' }))) return;
        } else {
            const price = priceSelect.value;
            const qty = parseInt(qtyInput.value, 10);
            if (!price) { statusEl.textContent = '请选择价格'; statusEl.className = 'sme-delist-status sme-error'; return; }
            if (!qty || qty < 1) { statusEl.textContent = '请输入有效数量'; statusEl.className = 'sme-delist-status sme-error'; return; }
            candidates = orders.filter(o => o.buyerPrice === price).sort((a, b) => b.rtListed - a.rtListed).slice(0, qty);
        }
        if (candidates.length === 0) { statusEl.textContent = '没有可下架的商品'; statusEl.className = 'sme-delist-status sme-error'; return; }

        const sessionid = await resolveSessionId();
        if (!sessionid) { statusEl.textContent = '无法获取会话ID'; statusEl.className = 'sme-delist-status sme-error'; return; }

        btn.disabled = true;
        allBtn.disabled = true;
        progressWrap.style.display = '';
        progressBar.style.width = '0%';
        let success = 0, failed = 0;

        for (let i = 0; i < candidates.length; i++) {
            const item = candidates[i];
            statusEl.textContent = `正在下架 ${i + 1}/${candidates.length}...`;
            statusEl.className = 'sme-delist-status';
            progressBar.style.width = Math.round((i / candidates.length) * 100) + '%';
            try {
                const resp = await smeRequest(`https://steamcommunity.com/market/removelisting/${item.listingid}`, {
                    method: 'POST',
                    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
                    body: `sessionid=${encodeURIComponent(sessionid)}`,
                    expect: 'none',
                    onNonOk: 'null',
                });
                if (resp) {
                    success++;
                    const idx = allSellOrders.indexOf(item);
                    if (idx !== -1) allSellOrders.splice(idx, 1);
                } else {
                    failed++;
                    W('Delist failed:', item.listingid, 'HTTP', resp.status);
                }
            } catch (e) {
                failed++;
                W('Delist error:', item.listingid, e);
            }
            if (i < candidates.length - 1) await sleep(300);
        }

        progressBar.style.width = '100%';
        statusEl.textContent = `下架完成: 成功 ${success} 件` + (failed > 0 ? `, 失败 ${failed} 件` : '');
        statusEl.className = 'sme-delist-status' + (failed > 0 ? ' sme-error' : ' sme-ok');
        btn.disabled = false;
        allBtn.disabled = false;
        toast(`下架完成: 成功 ${success} 件` + (failed > 0 ? `, 失败 ${failed} 件` : ''), failed > 0 ? 'warning' : 'success');
        setTimeout(() => { progressWrap.style.display = 'none'; }, 2000);

        // 刷新汇总（v1.5.1 P2-A：失效重建 summary 常驻 pane）
        invalidateTabPane('summary');
    }

    // ==================== 重新上架（超价物品） ====================
    /**
     * 渲染重新上架区域
     */
    function renderRelistSection(orders, checkResults) {
        // 找出所有超价物品
        const overpricedOrders = orders.filter(o => {
            const check = checkResults.get(o.buyerPrice);
            return check && check.status === 'overpriced' && check.suggestedCents > 0;
        });

        if (overpricedOrders.length === 0) return h('div'); // 无超价物品时不显示

        // 按价格分组统计
        const priceMap = new Map();
        for (const o of overpricedOrders) {
            const check = checkResults.get(o.buyerPrice);
            if (!priceMap.has(o.buyerPrice)) {
                priceMap.set(o.buyerPrice, { count: 0, suggestedCents: check.suggestedCents, source: check.source });
            }
            priceMap.get(o.buyerPrice).count++;
        }

        const section = h('div', { class: 'sme-relist-section', id: 'sme-relist-section' }, [
            h('div', { class: 'sme-relist-row' }, [
                h('span', { html: ICONS.zap, style: { color: 'var(--sme-purple)' } }),
                h('span', { style: { fontWeight: '700', color: 'var(--sme-text-bright)' }, text: '重新上架超价物品' }),
                h('button', {
                    class: 'sme-relist-btn',
                    id: 'sme-relist-btn',
                    html: ICONS.refreshCw + '<span>重新上架全部</span>',
                    onClick: () => handleRelist(overpricedOrders, checkResults),
                }),
            ]),
            h('div', { class: 'sme-relist-summary', text: `检测到 ${overpricedOrders.length} 件超价物品，将以下架后按建议价格重新上架` }),
        ]);

        // 列出超价价格和建议价格
        const listEl = h('div', { style: { marginTop: '8px' } });
        for (const [price, info] of priceMap) {
            const suggestedWithFees = priceIncludingFees(info.suggestedCents);
            listEl.appendChild(h('div', { class: 'sme-relist-item' }, [
                h('span', { class: 'sme-relist-from', text: `${price} ×${info.count}` }),
                h('span', { class: 'sme-relist-arrow', text: '→' }),
                h('span', { class: 'sme-relist-to', text: formatCents(suggestedWithFees) }),
                h('span', { style: { color: 'var(--sme-text-dim)', fontSize: '10px' }, text: `(${info.source})` }),
            ]));
        }
        section.appendChild(listEl);

        // 进度条和状态
        section.appendChild(h('div', { class: 'sme-progress-wrap', id: 'sme-relist-progress', style: { display: 'none' } }, [
            h('div', { class: 'sme-progress-bar', id: 'sme-relist-progress-bar' }),
        ]));
        section.appendChild(h('div', { class: 'sme-delist-status', id: 'sme-relist-status' }));

        return section;
    }

    /**
     * 处理重新上架：下架 → 等待回库 → 重新上架
     * 参考 steam-market-listings-group 2.6.2 的三步流程改进：
     * - 异步 resolveSessionId 替代同步 getSessionId（兼容新版 SSR 页面）
     * - waitForReturnedAsset 按 classid 重新定位 assetid（下架后可能变化）
     * - 自定义价格对话框（到手价 ↔ 买方支付价 联动）
     * - 上架失败重试（2 次）
     * - 分别追踪下架/上架失败数
     */
    let _relistBusy = false;
    async function handleRelist(overpricedOrders, checkResults) {
        if (_relistBusy) { toast('已有重新上架操作进行中，请稍候', 'warning'); return; }
        const btn = document.getElementById('sme-relist-btn');
        const statusEl = document.getElementById('sme-relist-status');
        const progressWrap = document.getElementById('sme-relist-progress');
        const progressBar = document.getElementById('sme-relist-progress-bar');

        const sessionid = await resolveSessionId();
        if (!sessionid) {
            statusEl.textContent = '无法获取会话ID（已尝试本地+远端多种方式）';
            statusEl.className = 'sme-delist-status sme-error';
            return;
        }

        // 步骤1: 弹出价格对话框（预填建议到手价，用户可自定义）
        const firstCheck = checkResults.get(overpricedOrders[0].buyerPrice);
        const suggestedCents = firstCheck ? firstCheck.suggestedCents : 0;
        const priceResult = await showPriceDialog(
            overpricedOrders[0].buyerPrice,
            overpricedOrders.length,
            suggestedCents
        );
        if (priceResult === null) {
            statusEl.textContent = '已取消';
            statusEl.className = 'sme-delist-status';
            return;
        }
        const { receivedCents, buyerCents } = priceResult;

        // 步骤2: 二次确认
        const confirmed = await showConfirmDialog(
            `即将下架 <strong>${overpricedOrders.length}</strong> 件超价物品，` +
            `以新价格重新上架（您将收到 <strong>${escapeHtml(formatCents(receivedCents))}</strong>，` +
            `买方支付 <strong>${escapeHtml(formatCents(buyerCents))}</strong>），确认继续？`,
            { title: '确认重新上架', okText: '确认重新上架', okClass: 'sme-dialog-blue' }
        );
        if (!confirmed) {
            statusEl.textContent = '已取消';
            statusEl.className = 'sme-delist-status';
            return;
        }

        _relistBusy = true;
        btn.disabled = true;
        progressWrap.style.display = '';
        progressBar.style.width = '0%';

        let success = 0, delistFailed = 0, relistFailed = 0;
        let lastSellMsg = '';
        const total = overpricedOrders.length;
        const usedAssetIds = new Set();

        for (let i = 0; i < overpricedOrders.length; i++) {
            const order = overpricedOrders[i];

            statusEl.textContent = `重新上架 ${i + 1}/${total}: 下架中...`;
            statusEl.className = 'sme-delist-status';
            progressBar.style.width = Math.round((i / total) * 100) + '%';

            try {
                // 步骤1: 下架
                const removeResp = await smeRequest(`https://steamcommunity.com/market/removelisting/${order.listingid}`, {
                    method: 'POST',
                    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
                    body: `sessionid=${encodeURIComponent(sessionid)}`,
                    expect: 'none',
                    onNonOk: 'null',
                });
                if (!removeResp) {
                    delistFailed++;
                    W('Relist: remove failed:', order.listingid);
                    continue;
                }

                // 从内存列表中移除
                const idx = allSellOrders.indexOf(order);
                if (idx !== -1) allSellOrders.splice(idx, 1);

                // 步骤2: 等待物品返回库存并重新定位 assetid（下架后可能变化）
                statusEl.textContent = `重新上架 ${i + 1}/${total}: 等待物品返回库存...`;
                const assetInfo = getAssetInfoFromOrder(order);
                let sellAssetId = assetInfo.assetid;

                if (order.classid) {
                    const returnedId = await waitForReturnedAsset(
                        assetInfo.appid, assetInfo.contextid, order.classid, usedAssetIds, 10000
                    );
                    if (returnedId) {
                        sellAssetId = returnedId;
                        usedAssetIds.add(returnedId);
                        if (returnedId !== assetInfo.assetid) {
                            L('Relist: assetid changed after delist:', assetInfo.assetid, '->', returnedId);
                        }
                    } else {
                        W('Relist: returned asset not found by classid', order.classid, '; using original assetid', assetInfo.assetid);
                    }
                } else {
                    // 无 classid 时回退到固定等待
                    await sleep(1500 + Math.random() * 1000);
                }

                if (!sellAssetId) {
                    W('Relist: no assetid for order', order.listingid);
                    relistFailed++;
                    continue;
                }

                // 步骤3: 以新价格重新上架（2次重试）
                statusEl.textContent = `重新上架 ${i + 1}/${total}: 上架中 (${formatCents(buyerCents)})...`;
                let sellOk = false;
                let sellMsg = '';
                for (let attempt = 0; attempt < 2 && !sellOk; attempt++) {
                    if (attempt > 0) {
                        statusEl.textContent = `重新上架 ${i + 1}/${total}: 重试上架...`;
                        await sleep(1500);
                    }
                    try {
                        await sellItem({
                            assetid: sellAssetId,
                            appid: assetInfo.appid,
                            contextid: assetInfo.contextid,
                            priceCents: receivedCents,
                        });
                        sellOk = true;
                    } catch (sellErr) {
                        sellMsg = sellErr.message;
                        W(`Relist: sell failed (attempt ${attempt + 1}):`, sellErr.message);
                    }
                }
                if (!sellOk) {
                    relistFailed++;
                    lastSellMsg = lastSellMsg || sellMsg;
                    continue;
                }

                success++;
            } catch (err) {
                W('Relist error:', order.listingid, err);
                delistFailed++;
            }

            // 请求间隔
            if (i < overpricedOrders.length - 1) await sleep(800);
        }

        progressBar.style.width = '100%';
        let msg = `重新上架完成: 成功 ${success} 件`;
        if (delistFailed > 0) msg += `，下架失败 ${delistFailed} 件`;
        if (relistFailed > 0) msg += `，上架失败 ${relistFailed} 件（已回库存${lastSellMsg ? ': ' + lastSellMsg : ''}）`;
        statusEl.textContent = msg;
        statusEl.className = 'sme-delist-status' + ((delistFailed || relistFailed) ? ' sme-error' : ' sme-ok');
        toast(msg, (delistFailed || relistFailed) ? 'warning' : 'success');
        setTimeout(() => { progressWrap.style.display = 'none'; }, 3000);

        _relistBusy = false;
        btn.disabled = false;

        // 刷新汇总（v1.5.1 P2-A：失效重建 summary 常驻 pane）
        priceCheckResults = null;
        setTimeout(() => invalidateTabPane('summary'), 500);
    }

    // ==================== 渲染：价格历史 ====================
    function renderPriceHistory(container) {
        if (!listingInfo) {
            container.appendChild(makeEmpty('无法获取物品信息'));
            return;
        }
        container.appendChild(makeLoading('正在加载价格历史...'));

        const range = settings.get('historyRange');
        fetchPriceHistory(listingInfo.appid, listingInfo.marketHashName)
            .then(data => {
                priceHistoryData = data;
                container.innerHTML = '';
                renderPriceHistoryContent(container, data, range);
            })
            .catch(err => {
                container.innerHTML = '';
                container.appendChild(makeError('价格历史加载失败: ' + err.message));
            });
    }

    function renderPriceHistoryContent(container, data, range) {
        const now = Date.now();
        const rangeMs = { '7d': 7 * 864e5, '30d': 30 * 864e5, '90d': 90 * 864e5, all: Infinity };
        const cutoff = now - (rangeMs[range] || rangeMs['30d']);
        let prices = data.prices.filter(p => p.t >= cutoff);

        if (prices.length === 0) {
            container.appendChild(makeEmpty('所选时间范围内无价格数据'));
            return;
        }

        // 时间范围选择器
        const rangeBar = h('div', { class: 'sme-range-bar' });
        for (const [label, val] of [['7天', '7d'], ['30天', '30d'], ['90天', '90d'], ['全部', 'all']]) {
            rangeBar.appendChild(h('button', {
                class: 'sme-range-btn' + (val === range ? ' active' : ''),
                text: label,
                onClick: () => {
                    settings.set('historyRange', val);
                    container.innerHTML = '';
                    renderPriceHistoryContent(container, data, val);
                },
            }));
        }
        container.appendChild(rangeBar);

        // 统计卡片
        const pricesOnly = prices.map(p => p.p);
        const current = pricesOnly[pricesOnly.length - 1];
        const min = Math.min(...pricesOnly);
        const max = Math.max(...pricesOnly);
        const avg = pricesOnly.reduce((s, v) => s + v, 0) / pricesOnly.length;
        const totalVol = prices.reduce((s, p) => s + p.v, 0);
        const prefix = data.prefix || '';
        const suffix = data.suffix || '';
        const trendIcon = current >= avg ? ICONS.trendingUp : ICONS.trendingDown;
        const trendColor = current >= avg ? 'var(--sme-green)' : 'var(--sme-red)';

        // 参考货币支持：价格历史 API 返回的是钱包货币
        const showRef = settings.get('showReferencePrice');
        const refCur = (settings.get('referenceCurrency') || 'CNY').toUpperCase();
        const wi = getWalletInfo();
        // 只有真实加载到的钱包货币才用，fallback 的 USD 不算
        const sourceCur = _walletInfo ? wi.currency_code : null;
        let refRate = null;
        if (showRef && sourceCur && sourceCur !== refCur) {
            refRate = getExchangeRateSync(sourceCur, refCur);
            // 缓存未命中时异步加载，加载完成后重绘
            if (refRate == null) {
                getExchangeRate(sourceCur, refCur)
                    .then(rate => {
                        if (rate != null && container.isConnected && priceHistoryData) {
                            container.innerHTML = '';
                            renderPriceHistoryContent(container, priceHistoryData, settings.get('historyRange'));
                        }
                    })
                    .catch(() => {});
            }
        } else if (showRef && !sourceCur) {
            // 钱包信息尚未加载，等待后重试
            let tries = 0;
            const waitWallet = setInterval(() => {
                tries++;
                getWalletInfo(); // 尝试初始化钱包信息
                if (_walletInfo || tries > 15 || !container.isConnected) {
                    clearInterval(waitWallet);
                    if (_walletInfo && container.isConnected && priceHistoryData) {
                        container.innerHTML = '';
                        renderPriceHistoryContent(container, priceHistoryData, settings.get('historyRange'));
                    }
                }
            }, 200);
        }
        const fmtRef = (valUnits) => {
            if (!refRate) return null;
            const amount = valUnits * refRate;
            const sym = CURRENCY_SYMBOLS_BY_CODE[refCur] || { prefix: '', suffix: ' ' + refCur };
            const decimals = CURRENCY_ZERO_DECIMAL.includes(refCur) ? 0 : 2;
            return sym.prefix + amount.toFixed(decimals) + sym.suffix;
        };

        const priceCards = [
            makeStatCardWithRef(prefix + current.toFixed(2) + suffix, '当前价格', fmtRef(current)),
            makeStatCardWithRef(prefix + min.toFixed(2) + suffix, '最低价格', fmtRef(min)),
            makeStatCardWithRef(prefix + max.toFixed(2) + suffix, '最高价格', fmtRef(max)),
            makeStatCardWithRef(prefix + avg.toFixed(2) + suffix, '平均价格', fmtRef(avg)),
            makeStatCard(totalVol.toLocaleString(), '总成交量'),
        ];
        container.appendChild(h('div', { class: 'sme-stats-grid' }, priceCards));

        // 图表
        const chartWrap = h('div', { class: 'sme-chart-wrap' });
        chartWrap.innerHTML = buildPriceChartSVG(prices, prefix);
        container.appendChild(chartWrap);
    }

    // ==================== 渲染：订单深度 ====================
    function renderOrderBook(container, force) {
        container.appendChild(makeLoading('正在获取订单深度...'));
        fetchOrderBook(force)
            .then(data => {
                orderBookData = data;
                container.innerHTML = '';
                renderOrderBookContent(container, data);
            })
            .catch(err => {
                container.innerHTML = '';
                container.appendChild(makeError('订单深度加载失败: ' + err.message));
            });
    }

    /** 订单深度控制条复选框 */
    function makeObCheckbox(label, checked, onChange, title) {
        const cb = h('input', { type: 'checkbox' });
        cb.checked = checked;
        cb.addEventListener('change', () => onChange(cb.checked));
        return h('label', { class: 'sme-ob-ctl', title: title || '' }, [cb, h('span', { text: label })]);
    }

    /**
     * 渲染单侧订单列表。数量比例画成行底色，文字叠在上面。
     * @param {string} type 'sell' | 'buy'
     * @param {Array} orders 每档订单 [{price, qty, _cents}]
     * @param {Function} fmtNet 分 → 货币字符串（税后到手列）
     * @param {Function} fmtCny 税后到手分 → CNY 字符串
     */
    function renderOrderSection(container, title, type, orders, state, fmtNet, fmtCny) {
        const list = orders || [];
        const n = Math.min(list.length, state.levels);
        const visible = list.slice(0, n);
        const maxQty = Math.max(...visible.map(o => o.qty), 1);
        const head = h('div', { class: 'sme-order-head' }, [
            h('span', { class: 'sme-order-price', text: '价格' }),
            state.showNet ? h('span', { class: 'sme-order-net', text: '税后到手' }) : null,
            state.showCny ? h('span', { class: 'sme-order-cny', text: 'CNY' }) : null,
            h('span', { class: 'sme-order-qty', text: '数量' }),
            state.showCum ? h('span', { class: 'sme-order-cum', text: '累计' }) : null,
        ]);
        const section = h('div', { class: 'sme-order-section' }, [
            h('div', { class: 'sme-order-title ' + type, html: (type === 'buy' ? ICONS.trendingUp : ICONS.trendingDown) + '<span>' + title + '</span>' }),
            head,
        ]);
        if (!visible.length) {
            section.appendChild(h('div', { class: 'sme-ob-empty', text: '暂无' }));
            container.appendChild(section);
            return;
        }
        let cum = 0;
        for (const o of visible) {
            cum += o.qty;
            const widthPct = (o.qty / maxQty * 100).toFixed(1);
            const cents = o._cents || parsePriceToCents(o.price);
            section.appendChild(h('div', { class: 'sme-order-row ' + type }, [
                h('div', { class: 'sme-order-bar', style: { width: widthPct + '%' } }),
                h('span', { class: 'sme-order-price', text: o.price }),
                state.showNet ? h('span', { class: 'sme-order-net', text: fmtNet(priceBeforeFees(cents)) }) : null,
                state.showCny ? h('span', { class: 'sme-order-cny', text: fmtCny(priceBeforeFees(cents)) }) : null,
                h('span', { class: 'sme-order-qty', text: o.qty.toLocaleString() }),
                state.showCum ? h('span', { class: 'sme-order-cum', text: cum.toLocaleString() }) : null,
            ]));
        }
        container.appendChild(section);
    }

    let _obCnyWalletTimer = null;
    let _obCnyRenderGen = 0;

    /** 钱包货币 → CNY。同源或汇率未就绪时返回 null，失败不抛到界面。 */
    function resolveOrderBookCny(container) {
        if (_obCnyWalletTimer) { clearInterval(_obCnyWalletTimer); _obCnyWalletTimer = null; }
        if (!settings.get('orderDepthShowCny')) return null;
        const wi = getWalletInfo();
        const sourceCur = _walletInfo ? wi.currency_code : null;
        if (!sourceCur) {
            let tries = 0;
            _obCnyWalletTimer = setInterval(() => {
                tries++;
                getWalletInfo();
                if (_walletInfo || tries > 15 || !container.isConnected) {
                    clearInterval(_obCnyWalletTimer);
                    _obCnyWalletTimer = null;
                    if (_walletInfo && _walletInfo.currency_code !== 'CNY' && container.isConnected && orderBookData) {
                        container.innerHTML = '';
                        renderOrderBookContent(container, orderBookData);
                    }
                }
            }, 200);
            return null;
        }
        if (sourceCur === 'CNY') return null;
        const rate = getExchangeRateSync(sourceCur, 'CNY');
        if (rate == null) {
            const gen = _obCnyRenderGen;
            getExchangeRate(sourceCur, 'CNY')
                .then(loaded => {
                    if (loaded == null || gen !== _obCnyRenderGen || !container.isConnected || !orderBookData) return;
                    container.innerHTML = '';
                    renderOrderBookContent(container, orderBookData);
                })
                .catch(() => {});
            return null;
        }
        return rate;
    }

    function renderOrderBookContent(container, data) {
        const prefix = data.prefix || '';
        const suffix = data.suffix || '';
        _obCnyRenderGen++;
        const cnyRate = resolveOrderBookCny(container);
        // fmtPrice: 将分（cents）转换为货币单位显示
        // data.lowestSell/highestBuy 是分字符串（如 "207000"），需 / 100 转为货币单位
        const fmtPrice = (val) => {
            const n = parseFloat(val);
            if (isNaN(n)) return val;
            return prefix + (n / 100).toFixed(2) + suffix;
        };

        // 价差统计（lowestSell/highestBuy 均为分）
        const highestBuy = parseInt(data.highestBuy, 10) || 0;
        const lowestSell = parseInt(data.lowestSell, 10) || 0;
        const spread = lowestSell - highestBuy;
        const spreadPct = lowestSell > 0 ? (spread / lowestSell * 100).toFixed(2) : '0.00';

        // ★ v2.0.0：求购单（买盘）摘要 —— 最高求购价之外，再给**总量与档数**，
        //   并明确「挂到 ≤ 最高求购价即可即时成交」这个可执行结论。
        const buyQty = (data.buyOrders || []).reduce((acc, o) => acc + (o.qty || 0), 0);
        const sellQty = (data.sellOrders || []).reduce((acc, o) => acc + (o.qty || 0), 0);
        container.appendChild(h('div', { class: 'sme-stats-grid' }, [
            makeStatCard(fmtPrice(data.lowestSell), '最低卖单'),
            makeStatCard(fmtPrice(data.highestBuy), '最高求购价'),
            makeStatCard(fmtPrice(spread), '买卖价差'),
            makeStatCard(spreadPct + '%', '价差比'),
        ]));
        container.appendChild(h('div', { class: 'sme-stats-grid' }, [
            makeStatCard(buyQty.toLocaleString(), '求购总量'),
            makeStatCard(sellQty.toLocaleString(), '在售总量'),
            makeStatCard(String((data.buyOrders || []).length), '求购档数'),
            makeStatCard(String((data.sellOrders || []).length), '在售档数'),
        ]));
        if (highestBuy > 0) {
            container.appendChild(h('div', {
                class: 'sme-ob-variant',
                text: '把挂单价压到 ' + fmtPrice(String(highestBuy)) + ' 或更低，即可被求购方直接收走（Steam 按最早挂单优先匹配）。',
            }));
        }

        // ★ v2.0.0：变体归属标注。
        //   同款家族聚合页默认内嵌的盘只属于某个磨损变体（实测 URL=FT 时默认盘是 MW），
        //   不标注的话用户会把别的变体的盘当成本变体 → 定价建议失真。
        if (data.variantName) {
            const isMismatch = data.variantMatched === false;
            container.appendChild(h('div', {
                class: 'sme-ob-variant' + (isMismatch ? ' mismatch' : ''),
                text: isMismatch
                    ? ('⚠ 订单簿属于「' + data.variantName + '」变体，与当前物品不是同一变体，定价建议仅供参考')
                    : ('订单簿变体：' + data.variantName),
            }));
        }

        // ★ v2.0.0：同款各变体最低价一览（buckets[].min_price，零额外请求）
        const variants = getListingVariants();
        if (variants.length > 1) {
            const target = getTargetVariantName();
            const vw = h('div', { class: 'sme-ob-variants' });
            vw.appendChild(h('div', { class: 'sme-ob-variants-title', text: '同款各变体最低价' }));
            const list = h('div', { class: 'sme-ob-variants-list' });
            for (const v of variants) {
                const isTarget = target && v.name === target;
                list.appendChild(h('div', {
                    class: 'sme-ob-variant-row' + (isTarget ? ' current' : ''),
                    title: v.name,
                }, [
                    h('span', { class: 'sme-ob-variant-name', text: v.name }),
                    h('span', {
                        class: 'sme-ob-variant-price',
                        text: v.minPriceCents ? fmtPrice(String(v.minPriceCents)) : '—',
                    }),
                ]));
            }
            vw.appendChild(list);
            container.appendChild(vw);
        }

        const sellAll = data.sellOrders || [];
        const buyAll = data.buyOrders || [];
        if (sellAll.length === 0 && buyAll.length === 0) {
            container.appendChild(makeEmpty('暂无订单数据'));
            return;
        }
        const maxLevels = Math.min(200, Math.max(sellAll.length, buyAll.length, 5));
        const state = {
            levels: Math.min(Math.max(parseInt(settings.get('orderDepthLevels'), 10) || 30, 5), maxLevels),
            showNet: !!settings.get('orderDepthShowNet'),
            showCum: !!settings.get('orderDepthShowCumulative'),
            showCny: cnyRate != null && !!settings.get('orderDepthShowCny'),
        };

        // 列表区独立成容器：滑动条/开关仅重绘列表，不重新请求
        const listWrap = h('div');
        const fmtNet = (cents) => formatCents(cents, prefix, suffix);
        const fmtCny = (netCents) => {
            if (cnyRate == null) return '';
            const amount = (netCents / 100) * cnyRate;
            const sym = CURRENCY_SYMBOLS_BY_CODE.CNY || { prefix: '¥', suffix: '' };
            return sym.prefix + amount.toFixed(2) + sym.suffix;
        };
        const renderLists = () => {
            listWrap.innerHTML = '';
            if (spread > 0) {
                listWrap.appendChild(h('div', { class: 'sme-spread-box' }, [
                    h('span', { class: 'sme-spread-lbl', text: '价差' }),
                    h('span', { class: 'sme-spread-val', text: fmtPrice(spread) + ' (' + spreadPct + '%)' }),
                ]));
            }
            const board = h('div', { class: 'sme-ob-board' });
            renderOrderSection(board, '卖单 (Sell Orders)', 'sell', sellAll, state, fmtNet, fmtCny);
            renderOrderSection(board, '买单 (Buy Orders)', 'buy', buyAll, state, fmtNet, fmtCny);
            listWrap.appendChild(board);
            const sellTotal = sellAll.reduce((s, o) => s + o.qty, 0);
            const buyTotal = buyAll.reduce((s, o) => s + o.qty, 0);
            listWrap.appendChild(h('div', { class: 'sme-ob-total' }, [
                h('span', { html: '在售合计 <b>' + sellTotal.toLocaleString() + '</b> 件 · 求购合计 <b>' + buyTotal.toLocaleString() + '</b> 件 · 显示前 ' + Math.min(state.levels, maxLevels) + ' 档 / 共 ' + maxLevels + ' 档' }),
            ]));
            levelsVal.textContent = state.levels + ' 档';
        };

        const levelsVal = h('span', { class: 'sme-ob-levels-val' });
        const slider = h('input', {
            type: 'range', class: 'sme-ob-slider',
            min: '5', max: String(maxLevels), step: '5',
        });
        slider.value = String(state.levels);
        // v1.6.9：滑杆拖动改为尾沿节流。
        // 原实现每个 input 事件都重建整个订单簿（最多 400 行）并同步写 localStorage，
        // 一次拖动约 40 次事件、累计 301.8ms，表现为拖动时明显卡顿。
        // 节流后：档位数值与滑杆位置即时反馈（跟手），重绘与持久化合并到停手后一次。
        // 注意 state.levels 仍即时更新，故 levelsVal 读到的始终是当前档位。
        const applyLevels = debounce(() => {
            settings.set('orderDepthLevels', state.levels);
            // 期间若触发了刷新（container 整体重建），listWrap 已脱离文档：
            // 此时重绘只会白做 400 行，直接跳过。
            if (!listWrap.isConnected) return;
            renderLists();
        }, 120);
        slider.addEventListener('input', () => {
            state.levels = parseInt(slider.value, 10) || 30;
            levelsVal.textContent = state.levels + ' 档';   // 即时反馈，不等节流
            applyLevels();
        });

        const refreshBtn = h('button', {
            class: 'sme-ob-refresh', text: '⟳ 刷新',
            onClick: async () => {
                refreshBtn.disabled = true;
                refreshBtn.textContent = '刷新中…';
                try {
                    const fresh = await fetchOrderBook(true);
                    orderBookData = fresh;
                    container.innerHTML = '';
                    renderOrderBookContent(container, fresh);
                    toast('订单深度已刷新', 'success');
                } catch (e) {
                    refreshBtn.disabled = false;
                    refreshBtn.textContent = '⟳ 刷新';
                    toast('刷新失败：' + friendlyError(e), 'error');
                }
            },
        });

        const controls = h('div', { class: 'sme-ob-controls' }, [
            h('label', { class: 'sme-ob-ctl' }, [h('span', { text: '档数' }), slider, levelsVal]),
            makeObCheckbox('税后到手', state.showNet, v => { state.showNet = v; settings.set('orderDepthShowNet', v); renderLists(); }),
            makeObCheckbox('CNY到手', !!settings.get('orderDepthShowCny'), v => {
                settings.set('orderDepthShowCny', v);
                state.showCny = v && cnyRate != null;
                if (v && cnyRate == null && !(_walletInfo && _walletInfo.currency_code === 'CNY')) {
                    container.innerHTML = '';
                    renderOrderBookContent(container, data);
                    return;
                }
                renderLists();
                if (tabPanes.settings && currentTab !== 'settings') invalidateTabPane('settings');
            }, (_walletInfo && _walletInfo.currency_code === 'CNY')
                ? '当前钱包已是人民币，税后到手列就是人民币到手价'
                : '把税后到手按汇率换算成人民币'),
            makeObCheckbox('累计', state.showCum, v => { state.showCum = v; settings.set('orderDepthShowCumulative', v); renderLists(); }),
            refreshBtn,
        ]);

        container.appendChild(controls);
        container.appendChild(listWrap);
        renderLists();
    }

    // ==================== 渲染：设置 ====================
    function renderSettings(container) {
        // v1.5.1 P2-D 修复：布局容器下沉为内层 wrapper，避免 pane 同时持有 .sme-tab-pane 和
        // .sme-settings-grid 导致 CSS 同优先级后写的 .sme-settings-grid{display:flex}
        // 在 pane 失活后覆盖 .sme-tab-pane{display:none}，出现切到其他 Tab 后设置页仍残留的问题。
        const layout = h('div', { class: 'sme-settings-grid' });

        function createGroup(titleHtml, children) {
            const group = h('div', { class: 'sme-setting-group' });
            group.appendChild(h('div', { class: 'sme-setting-group-title', html: titleHtml }));
            children.forEach(child => group.appendChild(child));
            layout.appendChild(group);
            return group;
        }

        function makeRow(name, desc, control) {
            // v1.5.1 P2-C：为行内控件补可访问名称（复选框/输入框无可见标签时读屏可用）
            try {
                const input = control.querySelector && control.querySelector('input, select, textarea');
                if (input && !input.getAttribute('aria-label')) input.setAttribute('aria-label', name);
            } catch (e) {}
            return h('div', { class: 'sme-setting-row' }, [
                h('div', { class: 'sme-setting-info' }, [
                    h('div', { class: 'sme-setting-name', text: name }),
                    h('div', { class: 'sme-setting-desc', text: desc }),
                ]),
                control,
            ]);
        }

        // --- 基础设置 ---
        createGroup('基础设置', [
            makeRow('详情页分析面板', isSteamClient()
                ? '当前在 Steam 客户端，分析面板固定用右下角按钮打开。'
                : '当前在浏览器，默认嵌在页面顶部。可以改成右下角按钮，这个选择会记住。',
                listingPanelModeControl()),

            makeRow('已拥有物品标识', '在市场浏览页和详情页显示库存中已拥有的物品数量',
                makeToggle('ownedBadges', settings.get('ownedBadges'), val => settings.set('ownedBadges', val))),

            makeRow('自动加载价格历史', '进入物品详情页时自动加载价格趋势图',
                makeToggle('autoLoadHistory', settings.get('autoLoadHistory'), val => settings.set('autoLoadHistory', val))),

            makeRow('默认价格历史范围', '价格趋势图默认显示的时间范围',
                h('select', {
                    class: 'sme-setting-select',
                    html: [['7天', '7d'], ['30天', '30d'], ['90天', '90d'], ['全部', 'all']]
                        .map(([l, v]) => `<option value="${v}"${v === settings.get('historyRange') ? ' selected' : ''}>${l}</option>`).join(''),
                    onChange: e => settings.set('historyRange', e.target.value),
                })),

            makeRow('显示参考货币价格', '在市场价格旁显示换算后的参考货币价格',
                makeToggle('showReferencePrice', settings.get('showReferencePrice'), val => {
                    settings.set('showReferencePrice', val);
                    if (val) {
                        // 立即尝试加载汇率并刷新显示
                        getExchangeRate('USD', settings.get('referenceCurrency') || 'CNY').catch(() => {});
                        // v1.5.7 修复 v2.16-fix 的回归：renderSettings 作用域内没有 pageType 变量，
                        // 直接引用会抛 ReferenceError，导致开关「开了却没反应」。改为直接复用注入入口。
                        startRefPriceInjection();
                    } else {
                        cleanupRefPriceObserver();
                    }
                })),

            makeRow('参考货币', '用于换算显示的目标货币',
                h('select', {
                    class: 'sme-setting-select',
                    html: [
                        ['人民币 CNY', 'CNY'],
                        ['美元 USD', 'USD'],
                        ['欧元 EUR', 'EUR'],
                        ['英镑 GBP', 'GBP'],
                        ['日元 JPY', 'JPY'],
                        ['韩元 KRW', 'KRW'],
                        ['印度卢比 INR', 'INR'],
                        ['俄罗斯卢布 RUB', 'RUB'],
                        ['巴西雷亚尔 BRL', 'BRL'],
                        ['澳元 AUD', 'AUD'],
                        ['加元 CAD', 'CAD'],
                        ['新加坡元 SGD', 'SGD'],
                        ['港币 HKD', 'HKD'],
                        ['新台币 TWD', 'TWD'],
                        ['泰铢 THB', 'THB'],
                        ['越南盾 VND', 'VND'],
                        ['印尼盾 IDR', 'IDR'],
                        ['马来西亚林吉特 MYR', 'MYR'],
                        ['菲律宾比索 PHP', 'PHP'],
                        ['墨西哥比索 MXN', 'MXN'],
                        ['阿根廷比索 ARS', 'ARS'],
                        ['智利比索 CLP', 'CLP'],
                        ['哥伦比亚比索 COP', 'COP'],
                        ['秘鲁索尔 PEN', 'PEN'],
                        ['乌拉圭比索 UYU', 'UYU'],
                        ['沙特里亚尔 SAR', 'SAR'],
                        ['阿联酋迪拉姆 AED', 'AED'],
                        ['土耳其里拉 TRY', 'TRY'],
                        ['波兰兹罗提 PLN', 'PLN'],
                        ['捷克克朗 CZK', 'CZK'],
                        ['瑞士法郎 CHF', 'CHF'],
                        ['挪威克朗 NOK', 'NOK'],
                        ['南非兰特 ZAR', 'ZAR'],
                        ['以色列新谢克尔 ILS', 'ILS'],
                        ['白俄罗斯卢布 BYN', 'BYN'],
                        ['哈萨克斯坦坚戈 KZT', 'KZT'],
                        ['乌克兰格里夫纳 UAH', 'UAH'],
                        ['新西兰元 NZD', 'NZD'],
                        ['哥斯达黎加科朗 CRC', 'CRC'],
                        ['卡塔尔里亚尔 QAR', 'QAR'],
                    ].map(([l, v]) => `<option value="${v}"${v === settings.get('referenceCurrency') ? ' selected' : ''}>${l}</option>`).join(''),
                    onChange: e => {
                        settings.set('referenceCurrency', e.target.value);
                        // v1.5.7：切换货币后整体重注（cleanupRefPriceObserver 会移除所有
                        // .sme-ref-price 并清掉 data-sme-ref-injected 标记）。
                        // 原实现引用了 renderSettings 作用域内不存在的 pageType，抛 ReferenceError。
                        cleanupRefPriceObserver();
                        if (settings.get('showReferencePrice')) startRefPriceInjection();
                    },
                })),

            makeRow('订单深度 CNY 到手价', '外币钱包时，订单深度增加一列人民币税后到手。钱包已是人民币时不重复显示，沿用「税后到手」列。',
                makeToggle('orderDepthShowCny', settings.get('orderDepthShowCny'), val => {
                    settings.set('orderDepthShowCny', val);
                    if (val) {
                        const code = _walletInfo && _walletInfo.currency_code;
                        if (code && code !== 'CNY') getExchangeRate(code, 'CNY').catch(() => {});
                    }
                    invalidateTabPane('orderbook');
                })),
        ]);

        // --- 市场顺序跟踪设置（v1.4.6） ---
        createGroup('市场顺序跟踪', [
            makeRow('我的挂单市场顺序', '物品页展示我的上架物品在市场中的排序位置（价格从低到高），并在上架表格和卡片上注入顺序徽章',
                makeToggle('marketRankTracker', settings.get('marketRankTracker'), val => {
                    settings.set('marketRankTracker', val);
                    if (!val) cleanupMarketRankTracker();
                })),

            makeRow('自动刷新顺序', '定时探测市场变化（售出/下架会导致顺序前移），自动更新顺序值',
                makeToggle('rankAutoRefresh', settings.get('rankAutoRefresh'), val => settings.set('rankAutoRefresh', val))),

            makeRow('刷新间隔', '顺序自动刷新的时间间隔（连续失败时自动退避延长）',
                h('select', {
                    class: 'sme-setting-select',
                    html: [['30秒', 30], ['1分钟', 60], ['2分钟', 120], ['5分钟', 300], ['10分钟', 600]]
                        .map(([l, v]) => `<option value="${v}"${Number(settings.get('rankRefreshInterval')) === v ? ' selected' : ''}>${l}</option>`).join(''),
                    onChange: e => settings.set('rankRefreshInterval', Number(e.target.value)),
                })),
        ]);

        // --- 显示更多价格（v1.5.0，新版 React 市场页） ---
        createGroup('显示更多价格', [
            makeRow('显示更多价格行', '新版市场物品页订单表格默认只显示前 6 行，开启后显示更多行（更改行数即时生效，重新开关需刷新页面）',
                makeToggle('showMorePrices', settings.get('showMorePrices'), onShowMorePricesToggle)),

            makeRow('显示行数', '订单表格显示的价格行数（6-100）',
                h('div', { class: 'sme-setting-inline' }, [
                    h('input', {
                        type: 'number',
                        class: 'sme-number-input',
                        value: String(settings.get('showMorePricesRows')),
                        step: '1',
                        min: '6',
                        max: '100',
                        onChange: e => {
                            let n = parseInt(e.target.value, 10);
                            if (isNaN(n)) n = SMM_DEFAULT_ROWS;
                            settings.set('showMorePricesRows', Math.min(SMM_MAX_ROWS, Math.max(SMM_INTERCEPT_END, n)));
                        },
                    }),
                    h('span', { style: { color: 'var(--sme-text-dim)', fontSize: '12px' }, text: '行' }),
                ])),
        ]);

        // --- 价格检测设置 ---
        createGroup(ICONS.dollarSign + '<span>价格检测设置</span>', [
            makeRow('自动价格检测', '进入上架汇总页时自动检测超价/低价',
                makeToggle('autoCheckPrices', settings.get('autoCheckPrices'), val => settings.set('autoCheckPrices', val))),

            makeRow('定价算法', '计算建议价格时使用的数据源策略',
                h('select', {
                    class: 'sme-setting-select',
                    html: Object.entries(ALGORITHM_NAMES)
                        .map(([v, l]) => `<option value="${v}"${Number(v) === settings.get('priceAlgorithm') ? ' selected' : ''}>${l}</option>`).join(''),
                    onChange: e => settings.set('priceAlgorithm', parseInt(e.target.value, 10)),
                })),

            makeRow('价格偏移', '在计算价格上加减偏移量（可为负，如 -0.01 表示低于建议价1分上架）',
                h('div', { class: 'sme-setting-inline' }, [
                    h('input', {
                        type: 'number',
                        class: 'sme-number-input',
                        id: 'sme-setting-offset',
                        value: String(settings.get('priceOffset')),
                        step: '0.01',
                        onChange: e => settings.set('priceOffset', parseFloat(e.target.value) || 0),
                    }),
                    h('span', { style: { color: 'var(--sme-text-dim)', fontSize: '12px' }, text: '元' }),
                ])),

            makeRow('历史均价时间窗口', '计算历史加权均价时回溯的小时数',
                h('div', { class: 'sme-setting-inline' }, [
                    h('input', {
                        type: 'number',
                        class: 'sme-number-input',
                        id: 'sme-setting-hours',
                        value: String(settings.get('historyHours')),
                        step: '1',
                        min: '1',
                        onChange: e => settings.set('historyHours', parseInt(e.target.value, 10) || 12),
                    }),
                    h('span', { style: { color: 'var(--sme-text-dim)', fontSize: '12px' }, text: '小时' }),
                ])),

            makeRow('智能过滤异常低价挂单', '最低价挂单数量极少时使用第二低价作为参考',
                makeToggle('ignoreLowQuantity', settings.get('ignoreLowQuantity'), val => settings.set('ignoreLowQuantity', val))),

            makeRow('价格范围限制', '建议价格将被钳制在此范围内',
                h('div', { class: 'sme-setting-inline' }, [
                    h('input', {
                        type: 'number',
                        class: 'sme-number-input',
                        id: 'sme-setting-min',
                        value: String(settings.get('minPrice')),
                        step: '0.01',
                        min: '0.01',
                        style: { width: '60px' },
                        onChange: e => settings.set('minPrice', parseFloat(e.target.value) || 0.03),
                    }),
                    h('span', { style: { color: 'var(--sme-text-dim)', fontSize: '12px' }, text: '~' }),
                    h('input', {
                        type: 'number',
                        class: 'sme-number-input',
                        id: 'sme-setting-max',
                        value: String(settings.get('maxPrice')),
                        step: '1',
                        style: { width: '60px' },
                        onChange: e => settings.set('maxPrice', parseFloat(e.target.value) || 999),
                    }),
                    h('span', { style: { color: 'var(--sme-text-dim)', fontSize: '12px' }, text: '元' }),
                ])),
        ]);

        // --- 物品类型差异化定价 ---
        createGroup(ICONS.layers + '<span>物品类型差异化定价</span>', [
            makeRow('普通卡牌价格范围', '普通交易卡牌的最低/最高上架价格',
                h('div', { class: 'sme-setting-inline' }, [
                    h('input', { type: 'number', class: 'sme-number-input', value: String(settings.get('minNormalCardPrice')), step: '0.01', style: { width: '60px' }, onChange: e => settings.set('minNormalCardPrice', parseFloat(e.target.value) || 0.05) }),
                    h('span', { style: { color: 'var(--sme-text-dim)', fontSize: '12px' }, text: '~' }),
                    h('input', { type: 'number', class: 'sme-number-input', value: String(settings.get('maxNormalCardPrice')), step: '0.5', style: { width: '60px' }, onChange: e => settings.set('maxNormalCardPrice', parseFloat(e.target.value) || 2.5) }),
                    h('span', { style: { color: 'var(--sme-text-dim)', fontSize: '12px' }, text: '元' }),
                ])),

            makeRow('闪箔卡牌价格范围', '闪亮（Foil）交易卡牌的最低/最高上架价格',
                h('div', { class: 'sme-setting-inline' }, [
                    h('input', { type: 'number', class: 'sme-number-input', value: String(settings.get('minFoilCardPrice')), step: '0.01', style: { width: '60px' }, onChange: e => settings.set('minFoilCardPrice', parseFloat(e.target.value) || 0.15) }),
                    h('span', { style: { color: 'var(--sme-text-dim)', fontSize: '12px' }, text: '~' }),
                    h('input', { type: 'number', class: 'sme-number-input', value: String(settings.get('maxFoilCardPrice')), step: '1', style: { width: '60px' }, onChange: e => settings.set('maxFoilCardPrice', parseFloat(e.target.value) || 10) }),
                    h('span', { style: { color: 'var(--sme-text-dim)', fontSize: '12px' }, text: '元' }),
                ])),

            makeRow('杂项物品价格范围', '非卡牌类物品的最低/最高上架价格',
                h('div', { class: 'sme-setting-inline' }, [
                    h('input', { type: 'number', class: 'sme-number-input', value: String(settings.get('minMiscPrice')), step: '0.01', style: { width: '60px' }, onChange: e => settings.set('minMiscPrice', parseFloat(e.target.value) || 0.05) }),
                    h('span', { style: { color: 'var(--sme-text-dim)', fontSize: '12px' }, text: '~' }),
                    h('input', { type: 'number', class: 'sme-number-input', value: String(settings.get('maxMiscPrice')), step: '1', style: { width: '60px' }, onChange: e => settings.set('maxMiscPrice', parseFloat(e.target.value) || 10) }),
                    h('span', { style: { color: 'var(--sme-text-dim)', fontSize: '12px' }, text: '元' }),
                ])),
        ]);

        // --- 库存页设置 ---
        createGroup(ICONS.tag + '<span>库存页设置</span>', [
            makeRow('库存价格标签', '在库存页物品上显示市场参考价格',
                makeToggle('inventoryPriceLabels', settings.get('inventoryPriceLabels'), val => settings.set('inventoryPriceLabels', val))),

            makeRow('快速出售按钮', '选中物品时显示快速出售面板（最高买单/最低卖单等）',
                makeToggle('quickSellButtons', settings.get('quickSellButtons'), val => settings.set('quickSellButtons', val))),
        ]);

        // --- 市场挂单页设置 ---
        createGroup(ICONS.list + '<span>市场挂单页设置</span>', [
            makeRow('批量操作按钮', '在"我的挂单"页显示批量选择/下架/重新上架按钮',
                makeToggle('marketBatchButtons', settings.get('marketBatchButtons'), val => settings.set('marketBatchButtons', val))),

            makeRow('排序功能', '点击表头按名称/价格/日期排序',
                makeToggle('marketSorting', settings.get('marketSorting'), val => settings.set('marketSorting', val))),

            makeRow('搜索过滤', '在挂单列表中添加搜索框实时过滤',
                makeToggle('marketSearch', settings.get('marketSearch'), val => settings.set('marketSearch', val))),
        ]);

        // --- v1.6.0：市场交易记录汇总与导出 ---
        createGroup(ICONS.chart + '<span>交易记录汇总与导出</span>', [
            makeRow('汇总与导出工具条', '在市场页"出售物品"旁显示汇总/导出按钮与格式下拉',
                makeToggle('marketHistoryPanel', settings.get('marketHistoryPanel'), val => settings.set('marketHistoryPanel', val))),

            makeRow('隐藏官方 Beta 公告条', '隐藏社区市场首页顶部的"正在进行 Beta 测试"官方公告',
                makeToggle('hideMarketBetaNote', settings.get('hideMarketBetaNote'), val => settings.set('hideMarketBetaNote', val))),

            makeRow('默认导出格式', '导出按钮默认使用的文件格式（分析窗口内可临时切换）',
                h('select', {
                    class: 'sme-setting-select',
                    'aria-label': '默认导出格式',
                    html: [['CSV（表格）', 'csv'], ['TSV（表格）', 'tsv'], ['JSON（结构化）', 'json'], ['Markdown（报告）', 'md']]
                        .map(([l, v]) => `<option value="${v}"${v === (MH_EXPORT_FORMATS.find((f) => f.id === settings.get('marketHistoryFormat')) ? settings.get('marketHistoryFormat') : 'csv') ? ' selected' : ''}>${l}</option>`).join(''),
                    onChange: (e) => {
                        const v = ['csv', 'tsv', 'json', 'md'].includes(e.target.value) ? e.target.value : 'csv';
                        settings.set('marketHistoryFormat', v);
                        mhState.format = v;
                        mhUi.exportFormat = null;
                        const sel = document.getElementById('sme-mh-format');
                        if (sel) sel.value = v;
                    },
                })),

            makeRow('抓取请求间隔', '翻页抓取交易记录时的间隔（毫秒）。过小容易被 Steam 限流',
                h('input', {
                    class: 'sme-number-input', type: 'number', min: '200', step: '100',
                    'aria-label': '抓取请求间隔',
                    value: String(Math.max(200, parseInt(settings.get('marketHistoryDelay'), 10) || 700)),
                    onChange: (e) => settings.set('marketHistoryDelay', Math.max(200, parseInt(e.target.value, 10) || 700)),
                })),

            makeRow('汇总榜单条目数', '汇总弹窗"按物品"榜单最多展示多少行',
                h('input', {
                    class: 'sme-number-input', type: 'number', min: '5', max: '100', step: '5',
                    'aria-label': '汇总榜单条目数',
                    value: String(Math.max(5, Math.min(100, parseInt(settings.get('marketHistoryTopN'), 10) || 20))),
                    onChange: (e) => settings.set('marketHistoryTopN', Math.max(5, Math.min(100, parseInt(e.target.value, 10) || 20))),
                })),
        ]);

        // --- 交易报价设置 ---
        createGroup(ICONS.exchange + '<span>交易报价设置</span>', [
            makeRow('交易报价价值摘要', '显示双方物品清单、总价值和差额对比',
                makeToggle('tradeOfferSummary', settings.get('tradeOfferSummary'), val => settings.set('tradeOfferSummary', val))),
        ]);

        // --- v1.9.0 挂刀比价 ---
        createGroup(ICONS.chart + '<span>挂刀比价（CS2/DOTA2）</span>', [
            makeRow('挂刀比价标签页', '物品详情页显示「挂刀比价」标签：BUFF/悠悠有品在售价 + 挂刀比例 + 转平台到手对比。点开标签才发请求，数据恒为 CNY',
                makeToggle('crossPlatformQuote', settings.get('crossPlatformQuote'), val => settings.set('crossPlatformQuote', val))),
            makeRow('自动加载比价', '打开详情页面板后自动在后台加载比价数据（默认关：点开标签才请求，避免不必要的平台流量）',
                makeToggle('crossPlatformAutoExpand', settings.get('crossPlatformAutoExpand'), val => settings.set('crossPlatformAutoExpand', val))),
            makeRow('平台扣费系数', '平台到手 ≈ 平台价 × 系数（0.85 为保守估计，含平台成交手续费与提现损耗）',
                h('select', {
                    class: 'sme-setting-select',
                    html: ['0.80', '0.85', '0.90', '0.95'].map(v =>
                        `<option value="${v}"${String(settings.get('platformFeeFactor')) === v ? ' selected' : ''}>${v}（平台到手 ${(v * 100).toFixed(0)}%）</option>`).join(''),
                    onChange: e => settings.set('platformFeeFactor', parseFloat(e.target.value)),
                })),
            makeRow('池子挂刀列与扫描', '池子明细表显示「挂刀」比例列，并提供手动扫描按钮（仅 BUFF 单源，1500ms/件，单轮 100 件上限，可中断）',
                makeToggle('poolRatioScan', settings.get('poolRatioScan'), val => settings.set('poolRatioScan', val))),
        ]);

        // --- 价格提醒（v2.0.0）---
        createGroup('价格提醒', [
            makeToggle('priceAlerts', settings.get('priceAlerts'), val => {
                settings.set('priceAlerts', val);
                if (val) { initAlertsButton(); requestAlertNotifyPermission(); } else {
                    const b = document.getElementById('sme-alert-btn');
                    if (b) b.remove();
                }
            }),
            h('div', { class: 'sme-settings-full', style: { marginTop: '8px', fontSize: '12px' } }, [
                h('span', { text: '默认跌幅阈值: ' }),
                (() => {
                    const inp = h('input', { class: 'sme-qs-input', type: 'number', min: '1', max: '90', step: '1', style: { width: '64px' } });
                    inp.value = String(Math.round((parseFloat(settings.get('priceAlertDropPct')) || 0.1) * 100));
                    inp.addEventListener('change', () => {
                        const pct = Math.max(1, Math.min(90, parseInt(inp.value, 10) || 10)) / 100;
                        inp.value = String(Math.round(pct * 100));
                        settings.set('priceAlertDropPct', pct);
                    });
                    return inp;
                })(),
                h('span', { text: '%' }),
            ]),
            makeToggle('priceAlertNotify', settings.get('priceAlertNotify'), val => {
                settings.set('priceAlertNotify', val);
                if (val) requestAlertNotifyPermission();
            }),
            h('div', { class: 'sme-settings-hint', style: { fontSize: '11px', color: 'var(--sme-text-muted)', marginTop: '6px' } ,
                text: '提醒只读取价格（priceoverview / 池子日快照），不会代你下单或改价。' }),
        ]);

        // --- 数据管理 ---
        createGroup('数据管理', [
            h('div', { class: 'sme-settings-full', style: { marginTop: '12px' } }, [
                h('button', { class: 'sme-danger-btn', text: '清除缓存', onClick: async () => {
                    // v2.0.0：缓存已迁到 IndexedDB，清除是异步的
                    await cache.clear();
                    Object.keys(invCache).forEach(k => delete invCache[k]);
                    Object.keys(jsonFallbackDone).forEach(k => delete jsonFallbackDone[k]);
                    // v1.6.0：交易记录索引也在本脚本缓存里，一并清空并复位内存态
                    mhState.rows = [];
                    mhState.totalCount = 0;
                    mhState.fetchedAt = 0;
                    const sid = getSteamId();
                    if (sid) {
                        clearInvCache(sid);
                        try { sessionStorage.removeItem(SESSION_KEY); } catch (e) {}
                    }
                    // v1.9.0：挂刀比价的缓存一并清除（ID 索引 + 比价结果）。
                    // v2.0.0：已迁到 IndexedDB 的 kv store（GM 侧仅保留同步镜像，不再是数据源）
                    try {
                        await smeKv.remove(RATIO_QUOTES_KEY);
                        for (const appid of RATIO_SUPPORTED_APPS) {
                            await smeKv.remove('sme_ratio_index_v1_' + appid);
                        }
                        ratioState.indexes = {}; ratioState.quotes = null; ratioState.cache = {};
                        ratioState.circuits = {}; ratioState.itemFails = {};
                    } catch (e) {}
                    toast('缓存已清除', 'success');
                }}),
            ]),
            h('div', { class: 'sme-info-box sme-settings-full' }, [
                h('div', { text: `Steam 社区市场增强 v${VERSION}` }),
                h('div', { text: '功能：上架汇总分组 · 超价/低价检测 · 一键重新上架(自定义改价+assetid重获取+多级会话ID回退) · 批量下架 · 价格历史趋势 · 订单深度 · 已拥有标识 · 我的挂单排序搜索批量操作 · 库存页价格标签与快速出售 · 交易报价价值摘要 · 物品类型差异化定价 · 交易记录汇总与导出(CSV/JSON)' }),
            ]),
        ]);

        container.appendChild(layout);
    }

    function makeToggle(key, checked, onChange) {
        const input = h('input', { type: 'checkbox' });
        if (checked) input.setAttribute('checked', '');
        input.addEventListener('change', () => onChange(input.checked));
        return h('label', { class: 'sme-toggle' }, [
            input,
            h('span', { class: 'sme-toggle-slider' }),
        ]);
    }

    // ==================== 辅助：加载/空/错误状态 ====================
    function makeLoading(msg) {
        return h('div', { class: 'sme-loading' }, [
            h('div', { class: 'sme-spinner' }),
            h('div', { class: 'sme-loading-text', text: msg || '加载中...' }),
        ]);
    }
    function makeEmpty(msg) {
        return h('div', { class: 'sme-empty' }, [
            h('span', { html: ICONS.package }),
            h('span', { text: msg || '暂无数据' }),
        ]);
    }
    function makeError(msg) {
        return h('div', { class: 'sme-error-box' }, [
            h('span', { html: ICONS.alert }),
            h('span', { text: msg || '加载失败' }),
        ]);
    }

    // ==================== 参考货币价格注入（v1.4.9） ====================
    const _refPriceObserver = { observer: null, timer: null };
    /** 注入重试调度状态：SPA 换页时随 cleanupRefPriceObserver 一起清空 */
    const _refPriceInject = { running: false, timers: [] };
    const _pageCurrencyCache = { code: null, ts: 0 };
    const PAGE_CURRENCY_CACHE_TTL = 60 * 1000; // 页面货币缓存1分钟

    /** 从页面内容中检测当前显示的货币代码（新版 React 页面 SSR 数据优先） */
    function detectPageCurrencyCode() {
        // 缓存命中则直接返回
        const now = Date.now();
        if (_pageCurrencyCache.code && now - _pageCurrencyCache.ts < PAGE_CURRENCY_CACHE_TTL) {
            return _pageCurrencyCache.code;
        }

        let result = 'USD'; // 默认回退

        // 1. 优先从 SSR renderContext 中获取
        try {
            const ssr = unsafeWindow.SSR?.renderContext;
            if (ssr?.queryData?.[0]?.state?.data?.wallet_currency != null) {
                result = getCurrencyCode(ssr.queryData[0].state.data.wallet_currency);
                _pageCurrencyCache.code = result;
                _pageCurrencyCache.ts = now;
                return result;
            }
            // 尝试从 queryData 其他条目查找
            if (Array.isArray(ssr?.queryData)) {
                for (const entry of ssr.queryData) {
                    const cur = entry?.state?.data?.wallet_currency;
                    if (cur != null) {
                        result = getCurrencyCode(cur);
                        _pageCurrencyCache.code = result;
                        _pageCurrencyCache.ts = now;
                        return result;
                    }
                    const cur2 = entry?.data?.wallet_currency;
                    if (cur2 != null) {
                        result = getCurrencyCode(cur2);
                        _pageCurrencyCache.code = result;
                        _pageCurrencyCache.ts = now;
                        return result;
                    }
                }
            }
        } catch (e) {}

        // 2. 从 wallet info 获取
        try {
            const wi = getWalletInfo?.();
            if (wi?.wallet_currency != null) {
                result = getCurrencyCode(wi.wallet_currency);
                _pageCurrencyCache.code = result;
                _pageCurrencyCache.ts = now;
                return result;
            }
        } catch (e) {}

        // 3. 从页面中的价格文本符号推断（扫描实际价格元素）
        //    找到页面中出现最多的价格符号作为判断依据
        const priceLeafSpans = findPriceLeafSpans();
        const codeCount = {};
        for (const { text } of priceLeafSpans) {
            const detected = detectCurrencyFromText(text);
            if (detected) {
                codeCount[detected.code] = (codeCount[detected.code] || 0) + 1;
            }
        }
        if (Object.keys(codeCount).length > 0) {
            // 返回出现次数最多的货币
            result = Object.entries(codeCount).sort((a, b) => b[1] - a[1])[0][0];
        }

        _pageCurrencyCache.code = result;
        _pageCurrencyCache.ts = now;
        return result;
    }

    /** 查找页面中所有叶子价格 span（无元素子节点、符合价格文本格式） */
    function findPriceLeafSpans() {
        const results = [];
        // v1.5.1 P2-B：TreeWalker 流式遍历替代 querySelectorAll('span') 全量物化（市场页 ~10⁴ 节点）；
        // closest() 单次原生调用替代逐级 parentElement 遍历
        const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_ELEMENT, {
            acceptNode(node) {
                if (node.tagName !== 'SPAN') return NodeFilter.FILTER_SKIP;
                return node.childElementCount === 0 ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
            },
        });
        let span;
        while ((span = walker.nextNode())) {
            if (span.classList.contains('sme-ref-price')) continue;
            // 跳过我们自己注入的内容（订单深度、统计卡片等）
            if (span.closest('#sme-mr-panel, .sme-settings-grid, .sme-setting-select, .sme-stats-grid, .sme-spread-box')) continue;
            const text = span.textContent.trim();
            if (text.length < 4 || text.length > 25) continue;
            if (!isPriceText(text)) continue;
            results.push({ el: span, text });
        }
        return results;
    }

    /**
     * v1.5.1 P2-G：扫描"起价: <price>" / "Starting at: <price>" 形式的搜索页结果卡价格。
     * 区别于 findPriceLeafSpans（只匹配纯价格文本），搜索页卡内"起价: ₹9.00"是 label+price 一体的 span/div。
     * 注入方式：appenchild 到原元素后，ref price 跟在原文本后；返回 [{el, text, sourceCode}] 列表。
     */
    function findSearchPageStartingPrices() {
        const results = [];
        // 中文 / 英文起价前缀；冒号可有可无（Steam 新版搜索页 SSR 渲染为「起价：₹32.00」/「From $0.32」，
        // 后者没有冒号且前缀是 From，因此把冒号设为可选并补上 From / 从 两种前缀）
        const re = /^(?:起价\s*[:：]?\s*|从\s*[:：]?\s*|starting\s+at\s*[:：]?\s*|start\s+price\s*[:：]?\s*|from\s*[:：]?\s*)(.+)$/i;
        const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_ELEMENT, {
            acceptNode(node) {
                const tag = node.tagName;
                if (tag !== 'SPAN' && tag !== 'DIV') return NodeFilter.FILTER_SKIP;
                // 必须是叶子元素（无元素子节点）；文本节点可以有，ref 注入后再扫描时会被 childElementCount>0 过滤
                return node.childElementCount === 0 ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
            },
        });
        let el;
        while ((el = walker.nextNode())) {
            if (el.dataset.smeRefInjected) continue;
            if (el.classList.contains('sme-ref-price')) continue;
            if (el.closest('#sme-mr-panel, .sme-settings-grid, .sme-setting-select, .sme-stats-grid, .sme-spread-box')) continue;
            const text = el.textContent.trim();
            if (text.length < 6 || text.length > 40) continue;
            const m = text.match(re);
            if (!m) continue;
            // 前缀用的是非捕获组 (?:…)，价格落在 m[1]；曾误取 m[2] 导致
            // "Cannot read properties of undefined (reading 'trim')" 在市场首页刷屏。
            const priceStr = (m[1] || '').trim();
            if (!priceStr) continue;
            const detected = detectCurrencyFromText(priceStr);
            if (!detected) continue;
            results.push({ el, text, priceStr, sourceCode: detected.code, dc: detected.dc });
        }
        return results;
    }

    /** v1.5.1 P2-B：空闲调度注入——全页扫描移出主线程关键路径（不可见时跳过） */
    function scheduleRefPriceInject() {
        if (document.visibilityState === 'hidden') return;
        if (typeof requestIdleCallback === 'function') {
            requestIdleCallback(() => { if (document.visibilityState === 'visible') injectAllReferencePrices(); }, { timeout: 2000 });
        } else {
            setTimeout(() => { if (document.visibilityState === 'visible') injectAllReferencePrices(); }, 0);
        }
    }

    /**
     * v1.5.7：启动参考货币换算注入 + 常驻观察器（详情页与浏览/搜索页共用）。
     * React 渲染有延迟，先重试若干次，最后建 observer 覆盖后续分页/筛选追加的节点。
     * v1.5.1 只在 initListingPage 里启动，导致 /market/search（pageType=browse）永远不注入。
     */
    function startRefPriceInjection() {
        if (!settings.get('showReferencePrice')) return;
        if (_refPriceInject.running) return;
        _refPriceInject.running = true;
        let attempts = 0;
        const track = (fn, ms) => {
            const t = setTimeout(fn, ms);
            _refPriceInject.timers.push(t);
            return t;
        };
        const tryInject = () => {
            attempts++;
            scheduleRefPriceInject();
            if (attempts < 5) {
                track(tryInject, attempts * 500);
            } else {
                _refPriceInject.running = false;
                setupRefPriceObserver();
            }
        };
        track(tryInject, 800);
    }

    /** 检查元素是否在不应注入参考价格的 SME 容器内（设置面板、排名面板、统计卡片等已主动加参考价的区域） */
    function isInsideSmeContainer(el) {
        let p = el.parentElement;
        while (p && p !== document.body) {
            if (p.id === 'sme-mr-panel') return true;
            if (p.classList && (
                p.classList.contains('sme-settings-grid') ||
                p.classList.contains('sme-setting-select') ||
                p.classList.contains('sme-stats-grid') ||
                p.classList.contains('sme-spread-box')
            )) return true;
            p = p.parentElement;
        }
        return false;
    }

    /**
     * 在详情页所有市场价格旁注入换算后的参考货币价格
     */
    function injectAllReferencePrices() {
        if (!settings.get('showReferencePrice')) return;
        const refCur = (settings.get('referenceCurrency') || 'CNY').toUpperCase();

        // 先获取全局默认货币（用于旧版选择器匹配的元素）
        const defaultSourceCode = detectPageCurrencyCode();

        // 查找页面上的价格元素
        const priceItems = []; // [{ el, cents, sourceCode }]

        // 1. 经典选择器匹配（旧版页面）
        const classicSelectors = [
            '.market_listing_price_with_fee',
            '.market_listing_price_without_fee',
            '.market_listing_price.market_table_value',
            '#market_buyorder_info .market_commodity_orders_header_promote',
        ];
        document.querySelectorAll(classicSelectors.join(',')).forEach(el => {
            if (el.dataset.smeRefInjected) return;
            if (isInsideSmeContainer(el)) return;
            const text = el.textContent.trim();
            // 优先从文本中检测货币（获取代码+逗号小数标志），检测不到用全局默认
            const detected = detectCurrencyFromText(text);
            const code = detected ? detected.code : defaultSourceCode;
            if (!code || code === refCur) return;
            const dc = detected ? detected.dc : DECIMAL_COMMA_CURRENCIES.has(code);
            const cents = parsePriceToCents(text, dc);
            if (!cents || cents <= 0) return;
            priceItems.push({ el, cents, sourceCode: code });
        });

        // 2. 扫描纯文本叶子 span（新版 React 页面，如 ₹94,780.00）
        //    只匹配没有子元素的叶子 span，避免父子重复匹配
        const priceLeafSpans = findPriceLeafSpans();
        for (const { el: span, text } of priceLeafSpans) {
            if (span.dataset.smeRefInjected) continue;
            if (span.querySelector('.sme-ref-price')) continue;
            // 从价格文本中直接检测货币符号（最准确）
            const detected = detectCurrencyFromText(text);
            if (!detected) continue;
            if (detected.code === refCur) continue; // 同源跳过
            const cents = parsePriceToCents(text, detected.dc);
            if (cents <= 0 || cents >= 100000000) continue;
            priceItems.push({ el: span, cents, sourceCode: detected.code });
        }

        // 3. v1.5.1 P2-G：搜索页"起价: <price>" / "Starting at: <price>" 形式（label+price 一体的 span/div）
        //    区别于上面纯价格 span——这里 text 形如 "起价: ₹9.00" 含中文/英文 label
        const searchPrices = findSearchPageStartingPrices();
        for (const { el, priceStr, sourceCode, dc } of searchPrices) {
            if (el.dataset.smeRefInjected) continue;
            if (sourceCode === refCur) continue; // 同源跳过
            const cents = parsePriceToCents(priceStr, dc);
            if (!cents || cents <= 0) continue;
            priceItems.push({ el, cents, sourceCode });
        }

        if (priceItems.length === 0) return;
        L('参考货币换算: 新增', priceItems.length, '个价格');

        // 预加载所有涉及的汇率
        const codesNeeded = [...new Set(priceItems.map(p => p.sourceCode))];
        codesNeeded.forEach(code => getExchangeRate(code, refCur).catch(() => {}));

        // 注入参考价格
        priceItems.forEach(({ el, cents, sourceCode }) => {
            el.dataset.smeRefInjected = '1';
            const refEl = h('span', { class: 'sme-ref-price loading', text: '…' });
            el.appendChild(refEl);

            // 订单深度区域不显示到手价（避免太挤）
            const inOrderSection = el.closest && el.closest('.sme-order-section');
            const showNet = !inOrderSection;
            const netCents = showNet ? priceBeforeFees(cents) : 0;

            const promises = [formatReferencePrice(cents, sourceCode, refCur)];
            if (showNet) promises.push(formatReferencePrice(netCents, sourceCode, refCur));

            Promise.all(promises).then(([refStr, netStr]) => {
                if (refStr && refEl.isConnected) {
                    let html = refStr;
                    if (showNet && netStr) {
                        html += ' <span class="sme-ref-net">(' + netStr + ')</span>';
                    }
                    refEl.innerHTML = html;
                    refEl.classList.remove('loading');
                } else if (refEl.parentNode) {
                    refEl.remove();
                }
            }).catch(() => {
                if (refEl.parentNode) refEl.remove();
            });
        });
    }

    /** 判断文本是否是纯净的价格字符串（货币符号+数字，不含其他文字） */
    function isPriceText(text) {
        const t = text.trim();
        if (t.length < 4 || t.length > 25) return false;
        // 必须包含数字
        if (!/\d/.test(t)) return false;
        // 使用 detectCurrencyFromText 检测货币符号（复用符号映射，避免重复定义）
        const detected = detectCurrencyFromText(t);
        if (!detected) return false;
        // 检查是否只包含货币符号、数字、千分位逗号/小数点和空格
        // 去掉已识别的货币符号后，剩余部分应只含数字、逗号、点、空格
        const sym = getDetectSymbolForCode(detected.code);
        const remaining = sym ? t.replace(sym, '').trim() : t;
        return /^[\d.,\s]+$/.test(remaining);
    }

    /** 从 CURRENCY_SYMBOLS_BY_CODE 获取货币的检测用符号（去掉前后空格的 prefix） */
    function getDetectSymbolForCode(code) {
        const sym = CURRENCY_SYMBOLS_BY_CODE[code];
        if (!sym) return '';
        // 优先使用 prefix（去掉空格），大多数货币的符号在 prefix 中
        const prefixSym = sym.prefix.trim();
        if (prefixSym) return prefixSym;
        const suffixSym = sym.suffix.trim();
        if (suffixSym) return suffixSym;
        return '';
    }

    /** 启动参考价格的 MutationObserver（React 重渲染后自动补注） */
    function setupRefPriceObserver() {
        if (_refPriceObserver.observer) return;
        if (!settings.get('showReferencePrice')) return;
        _refPriceObserver.observer = new MutationObserver(mutations => {
            // 忽略仅由我们自己的 .sme-ref-price 引起的变化，避免无限循环注入
            // 同时忽略设置面板/排名面板等非价格区域的变化
            let hasExternalChange = false;
            for (const mut of mutations) {
                // 检查新增节点是否全是我们自己注入的
                if (mut.type === 'childList') {
                    for (const node of mut.addedNodes) {
                        if (node.nodeType === 1 && (
                            node.classList?.contains('sme-ref-price') ||
                            node.querySelector?.('.sme-ref-price') ||
                            isInsideSmeContainer(node)
                        )) continue;
                        if (node.nodeType === 3) continue; // 文本节点忽略
                        hasExternalChange = true;
                        break;
                    }
                    // 检查被移除的节点
                    for (const node of mut.removedNodes) {
                        if (node.nodeType === 1 && (
                            node.classList?.contains('sme-ref-price') ||
                            isInsideSmeContainer(node)
                        )) continue;
                        if (node.nodeType === 3) continue;
                        hasExternalChange = true;
                        break;
                    }
                } else if (mut.type === 'characterData') {
                    // 文本变化：如果目标在 .sme-ref-price 内或设置/排名面板内则忽略
                    let el = mut.target;
                    while (el && el.nodeType === 3) el = el.parentElement;
                    if (el?.classList?.contains('sme-ref-price')) continue;
                    if (el && isInsideSmeContainer(el)) continue;
                    hasExternalChange = true;
                }
                if (hasExternalChange) break;
            }
            if (!hasExternalChange) return;

            if (_refPriceObserver.timer) clearTimeout(_refPriceObserver.timer);
            _refPriceObserver.timer = setTimeout(() => {
                scheduleRefPriceInject();
            }, 800);
        });
        _refPriceObserver.observer.observe(document.body, { childList: true, subtree: true, characterData: true });
    }

    function cleanupRefPriceObserver() {
        if (_refPriceObserver.observer) {
            _refPriceObserver.observer.disconnect();
            _refPriceObserver.observer = null;
        }
        if (_refPriceObserver.timer) {
            clearTimeout(_refPriceObserver.timer);
            _refPriceObserver.timer = null;
        }
        // v1.5.7：换页时停掉尚未执行的重试注入，避免旧页面的定时器打到新页面上
        _refPriceInject.timers.forEach(clearTimeout);
        _refPriceInject.timers = [];
        _refPriceInject.running = false;
        document.querySelectorAll('.sme-ref-price').forEach(el => el.remove());
        // 清除注入标记，方便重新注入
        document.querySelectorAll('[data-sme-ref-injected]').forEach(el => {
            delete el.dataset.smeRefInjected;
        });
    }

    // ==================== 面板注入（详情页） ====================
    function findListingContainer() {
        const priceEls = [];
        const walker = document.createTreeWalker(document.body, 4, null);
        let count = 0;
        while (walker.nextNode() && count < 5) {
            if (/¥\s*\d/.test(walker.currentNode.nodeValue)) {
                priceEls.push(walker.currentNode.parentElement);
                count++;
            }
        }
        if (priceEls.length === 0) return null;
        let common = priceEls[0].parentElement;
        while (common && common !== document.body) {
            if (priceEls.every(el => common.contains(el)) && common.children.length > 2) return common;
            common = common.parentElement;
        }
        return priceEls[0].parentElement?.parentElement?.parentElement || null;
    }

    function injectPanel() {
        const panel = createPanel();
        removeAnalysisCloseBtn();
        // 已在页面文档流中则不重复插入；挂在浮窗里时允许挪回页面
        if (panel.isConnected && !panel.closest('#sme-analysis-pop')) return;
        const listingContainer = findListingContainer();
        if (listingContainer && listingContainer.parentNode) {
            listingContainer.parentNode.insertBefore(panel, listingContainer);
        } else {
            const target = document.querySelector('#mainContents') || document.querySelector('[class*="pagecontent"]') || document.body;
            target.insertBefore(panel, target.firstChild);
        }
        if (!panel.querySelector('.sme-tab-pane')) switchTab(currentTab || 'summary');
        L('Panel injected on listing page');
    }

    function positionAnalysisFab() {
        if (!analysisFabEl) return;
        const rank = document.getElementById('sme-mr-panel');
        // v2.2.5：只有浮窗「确实可见」时才把按钮排到它左侧；隐藏时排回右下角。
        const rankShown = !!rank
            && rank.style.display !== 'none'
            && !rank.classList.contains('sme-mr-inline')
            && getComputedStyle(rank).position === 'fixed';
        // 右下角最底部 16px 留给「常驻汇率徽标」，按钮抬高到它上方。
        analysisFabEl.style.right = rankShown ? '280px' : '16px';
        analysisFabEl.style.bottom = '64px';
    }

    function syncAnalysisFab() {
        if (!analysisFabEl) return;
        const open = !!(analysisPopEl && analysisPopEl.classList.contains('sme-show'));
        analysisFabEl.classList.toggle('sme-on', open);
        analysisFabEl.setAttribute('aria-expanded', open ? 'true' : 'false');
    }

    function removeAnalysisCloseBtn() {
        if (panelEl) {
            const btn = panelEl.querySelector('.sme-analysis-close');
            if (btn) btn.remove();
        }
    }

    function ensureAnalysisCloseBtn(panel) {
        if (!panel || panel.querySelector('.sme-analysis-close')) return;
        const header = panel.querySelector('.sme-header');
        if (!header) return;
        header.appendChild(h('button', {
            type: 'button',
            class: 'sme-tab-btn sme-analysis-close',
            title: '关闭',
            'aria-label': '关闭交易分析',
            html: ICONS.close,
            onClick: (e) => {
                e.stopPropagation();
                if (analysisPopEl) analysisPopEl.classList.remove('sme-show');
                syncAnalysisFab();
            },
        }));
    }

    function bindAnalysisDismiss() {
        if (analysisDismissBound) return;
        analysisDismissBound = true;
        document.addEventListener('mousedown', (e) => {
            if (!analysisPopEl || !analysisPopEl.classList.contains('sme-show')) return;
            if (analysisPopEl.contains(e.target) || (analysisFabEl && analysisFabEl.contains(e.target))) return;
            if (e.target.closest && e.target.closest('.sme-dialog-overlay, .sme-toast')) return;
            analysisPopEl.classList.remove('sme-show');
            syncAnalysisFab();
        }, true);
        document.addEventListener('keydown', (e) => {
            if (e.key !== 'Escape' || !analysisPopEl || !analysisPopEl.classList.contains('sme-show')) return;
            if (document.querySelector('.sme-dialog-overlay')) return;
            analysisPopEl.classList.remove('sme-show');
            syncAnalysisFab();
        });
    }

    function ensureAnalysisFab() {
        if (!analysisFabEl || !analysisFabEl.isConnected) {
            analysisFabEl = h('button', {
                type: 'button',
                class: 'sme-fab sme-analysis-fab',
                title: '交易分析',
                'aria-label': '打开交易分析',
                'aria-haspopup': 'dialog',
                'aria-expanded': 'false',
                html: ICONS.layers,
                onClick: toggleAnalysisPop,
            });
            document.body.appendChild(analysisFabEl);
            bindAnalysisDismiss();
        }
        positionAnalysisFab();
        if (!analysisFabPosTimer) {
            analysisFabPosTimer = setTimeout(() => {
                analysisFabPosTimer = null;
                positionAnalysisFab();
            }, 1500);
        }
    }

    function openAnalysisPop() {
        ensureAnalysisFab();
        if (!analysisPopEl || !analysisPopEl.isConnected) {
            analysisPopEl = h('div', {
                class: 'sme-analysis-pop',
                id: 'sme-analysis-pop',
                role: 'dialog',
                'aria-label': '交易分析',
            });
            document.body.appendChild(analysisPopEl);
        }
        const panel = createPanel();
        ensureAnalysisCloseBtn(panel);
        if (panel.parentNode !== analysisPopEl) analysisPopEl.appendChild(panel);
        analysisPopEl.classList.add('sme-show');
        if (!panel.querySelector('.sme-tab-pane.active')) switchTab(currentTab || 'summary');
        syncAnalysisFab();
        L('Analysis float opened');
    }

    function toggleAnalysisPop() {
        if (analysisPopEl && analysisPopEl.classList.contains('sme-show')) {
            analysisPopEl.classList.remove('sme-show');
            syncAnalysisFab();
            return;
        }
        openAnalysisPop();
    }

    function removeAnalysisFloat() {
        if (analysisFabPosTimer) {
            clearTimeout(analysisFabPosTimer);
            analysisFabPosTimer = null;
        }
        if (analysisFabEl) { analysisFabEl.remove(); analysisFabEl = null; }
        if (analysisPopEl) { analysisPopEl.remove(); analysisPopEl = null; }
    }

    /**
     * 详情页分析面板入口。
     * 浏览器按用户记住的选择内嵌或浮窗。Steam 客户端固定浮窗，按钮挂在 document.body 上。
     */
    /** v1.9.0：设置开启时，详情页面板打开后在后台预取比价数据（不切 Tab） */
    function ratioPreloadCurrent() {
        const li = getListingInfo();
        if (!li || !RATIO_SUPPORTED_APPS.includes(li.appid)) return;
        ratioGetQuotes(li.appid, li.marketHashName).catch(() => {});
    }

    function presentListingPanel(openFloat) {
        if (detectPageType() !== 'listing') return;
        if (shouldUseFloatPanel()) {
            if (panelEl && panelEl.isConnected && !panelEl.closest('#sme-analysis-pop')) panelEl.remove();
            ensureAnalysisFab();
            if (openFloat) openAnalysisPop();
            if (settings.get('crossPlatformAutoExpand')) ratioPreloadCurrent();
            return;
        }
        removeAnalysisFloat();
        injectPanel();
        if (settings.get('crossPlatformAutoExpand')) ratioPreloadCurrent();
    }

    function onListingOrdersReady() {
        if (tabPanes.summary) invalidateTabPane('summary');
    }

    // ==================== 详情页：已拥有物品标识 ====================
    /** 在详情页物品名称前显示已拥有数量徽章 */
    function processDetailPageBadge() {
        if (!settings.get('ownedBadges')) return;
        const info = getListingInfo();
        if (!info) return;

        // 尝试多个可能的物品名称位置
        const nameEl = document.querySelector('#largeiteminfo .market_listing_nav .market_listing_item_name')
            || document.querySelector('.market_listing_nav .market_listing_item_name')
            || document.querySelector('.market_listing_item_name:first-of-type');
        if (!nameEl || nameEl.querySelector('.sme-owned-badge')) return;

        getOwnedCount(info.appid, info.marketHashName).then(count => {
            if (count > 0 && nameEl.parentNode && !nameEl.querySelector('.sme-owned-badge')) {
                nameEl.parentNode.insertBefore(
                    h('span', { class: 'sme-owned-badge', title: `您库存中有 ${count} 件此物品`, text: '×' + count }),
                    nameEl
                );
            }
        }).catch(() => {});
    }

    // ==================== 浏览页：已拥有物品标识 ====================
    const browseSeen = new WeakSet();
    let browseObserver = null;

    function processBrowseRow(row) {
        if (browseSeen.has(row)) return;
        browseSeen.add(row);
        if (row.querySelector('.sme-owned-badge')) return;
        const href = row.href || row.getAttribute('href');
        if (!href) return;
        const m = href.match(/\/market\/listings\/(\d+)\/(.+?)(?:\?.*)?$/);
        if (!m) return;
        let appid, hashName;
        try { appid = m[1]; hashName = decodeURIComponent(m[2]); } catch (e) { return; }

        const nameBlock = row.querySelector('.market_listing_item_name_block');
        if (!nameBlock) return;
        const nameSpan = nameBlock.querySelector('.market_listing_item_name');
        if (!nameSpan) return;

        getOwnedCount(appid, hashName).then(count => {
            if (count > 0) {
                nameBlock.insertBefore(
                    h('span', { class: 'sme-owned-badge', title: `您库存中有 ${count} 件此物品`, text: '×' + count }),
                    nameSpan
                );
            }
        }).catch(() => {});
    }

    function processAllBrowseRows() {
        const rows = document.querySelectorAll('a.market_listing_row_link');
        rows.forEach(r => processBrowseRow(r));
    }

    function setupBrowseObserver() {
        if (browseObserver) browseObserver.disconnect();
        const target = document.getElementById('searchResults') || document.body;
        browseObserver = new MutationObserver(mutations => {
            const rows = [];
            mutations.forEach(mut => {
                if (mut.type !== 'childList') return;
                mut.addedNodes.forEach(node => {
                    if (node.nodeType !== 1) return;
                    if (node.classList && node.classList.contains('market_listing_row_link')) rows.push(node);
                    if (node.querySelectorAll) {
                        node.querySelectorAll('a.market_listing_row_link').forEach(r => rows.push(r));
                    }
                });
            });
            if (rows.length > 0) rows.forEach(r => processBrowseRow(r));
        });
        browseObserver.observe(target, { childList: true, subtree: true });
    }

    // ==================== 浏览页：浮动设置按钮 ====================
    let fabEl = null, fabPopup = null;

    function createFab() {
        if (fabEl) return;
        fabEl = h('button', { class: 'sme-fab', title: '市场增强设置', html: ICONS.settings, onClick: toggleFabPopup });
        document.body.appendChild(fabEl);

        fabPopup = h('div', { class: 'sme-fab-popup' }, [
            h('h4', { html: ICONS.settings + '<span>市场增强设置</span>' }),
            h('div', { class: 'sme-setting-row' }, [
                h('div', { class: 'sme-setting-info' }, [
                    h('div', { class: 'sme-setting-name', text: '详情页分析面板' }),
                    h('div', { class: 'sme-setting-desc', text: isSteamClient()
                        ? '当前在 Steam 客户端，固定用右下角按钮打开'
                        : '浏览器默认顶部内嵌，可改为浮窗，选择会记住' }),
                ]),
                listingPanelModeControl(),
            ]),
            h('div', { class: 'sme-setting-row' }, [
                h('div', { class: 'sme-setting-info' }, [
                    h('div', { class: 'sme-setting-name', text: '已拥有物品标识' }),
                    h('div', { class: 'sme-setting-desc', text: '浏览页和详情页显示库存中已拥有的物品数量' }),
                ]),
                makeToggle('ownedBadges', settings.get('ownedBadges'), val => {
                    settings.set('ownedBadges', val);
                    if (val) {
                        processAllBrowseRows();
                        processDetailPageBadge();
                    } else {
                        document.querySelectorAll('.sme-owned-badge').forEach(el => el.remove());
                    }
                }),
            ]),
            h('div', { class: 'sme-setting-row' }, [
                h('div', { class: 'sme-setting-info' }, [
                    h('div', { class: 'sme-setting-name', text: '自动加载价格历史' }),
                    h('div', { class: 'sme-setting-desc', text: '详情页自动加载价格趋势图' }),
                ]),
                makeToggle('autoLoadHistory', settings.get('autoLoadHistory'), val => settings.set('autoLoadHistory', val)),
            ]),
            h('div', { class: 'sme-setting-row' }, [
                h('div', { class: 'sme-setting-info' }, [
                    h('div', { class: 'sme-setting-name', text: '我的挂单市场顺序' }),
                    h('div', { class: 'sme-setting-desc', text: '物品页展示上架物品的市场排序位置' }),
                ]),
                makeToggle('marketRankTracker', settings.get('marketRankTracker'), val => {
                    settings.set('marketRankTracker', val);
                    if (!val) cleanupMarketRankTracker();
                }),
            ]),
            h('div', { class: 'sme-setting-row' }, [
                h('div', { class: 'sme-setting-info' }, [
                    h('div', { class: 'sme-setting-name', text: '显示更多价格' }),
                    h('div', { class: 'sme-setting-desc', text: '新版市场物品页订单表格显示更多价格行' }),
                ]),
                makeToggle('showMorePrices', settings.get('showMorePrices'), onShowMorePricesToggle),
            ]),
            h('div', { style: { marginTop: '12px', fontSize: '11px', color: 'var(--sme-text-dim)', textAlign: 'center' }, text: `Steam 社区市场增强 v${VERSION}` }),
        ]);
        document.body.appendChild(fabPopup);

        document.addEventListener('mousedown', e => {
            if (fabPopup.classList.contains('sme-show') && !fabPopup.contains(e.target) && !fabEl.contains(e.target)) {
                fabPopup.classList.remove('sme-show');
            }
        }, true);
    }

    function toggleFabPopup() {
        fabPopup.classList.toggle('sme-show');
    }

    // ==================== 我的挂单增强（批量选择 / 排序 / 搜索） ====================
    // 为市场主页"我的挂单"区域提供：批量选择与下架、超价检测与重新上架、列排序、名称搜索。
    // 依赖现有工具函数：h, settings, toast, getSessionId, parsePriceToCents, priceBeforeFees,
    //   priceIncludingFees, calcSellPrice, fetchPriceHistory, fetchOrderHistogram, sellItem,
    //   isRetryMessage, randInt, sleep, ICONS, GM_addStyle, unsafeWindow, APP_CONTEXT,
    //   INV_REQUEST_DELAY, RETRY_BACKOFF_MIN, RETRY_BACKOFF_MAX, L, W。
    let myListingsModuleActive = false;      // 模块是否已激活（防止重复初始化）
    let myListingsStyleAdded = false;         // CSS 是否已注入
    let myListingsObserver = null;            // 挂单区域变动观察器
    let myListingsToolbarEl = null;           // 工具栏元素
    let myListingsSortKey = null;             // 当前排序键: 'name' | 'date' | 'price' | null
    let myListingsSortAsc = true;             // 升序/降序
    let myListingsSearchQ = '';               // 搜索关键词（小写）
    let myListingsBusy = false;               // 是否有批量操作进行中
    const myListingsRowData = new WeakMap();  // 行元素 → 解析数据
    const myListingsPriceCheck = new Map();   // listingid → { overpriced, suggestedCents, source, buyerCents, unknown? }

    const MY_LISTINGS_CSS = `
.sme-ml-toolbar{
    display:flex;align-items:center;gap:6px;flex-wrap:wrap;padding:8px 10px;margin:6px 0;
    background:linear-gradient(135deg,var(--sme-blue-a06) 0%,rgba(23,26,33,0.6) 100%);
    border:1px solid var(--sme-border);border-radius:var(--sme-radius-sm);
    font-family:"Motiva Sans",system-ui,-apple-system,sans-serif;
}
.sme-ml-toolbar .sme-market-btn:disabled{opacity:0.4;cursor:not-allowed}
.sme-ml-sep{width:1px;height:18px;background:var(--sme-border);margin:0 2px;display:inline-block}
.sme-ml-count{font-size:12px;color:var(--sme-text-dim);white-space:nowrap;margin-left:auto}
.sme-ml-count b{color:var(--sme-blue)}
.sme-ml-status{width:100%;font-size:12px;color:var(--sme-text-dim);margin-top:6px;min-height:14px}
.sme-ml-status.sme-err{color:var(--sme-red)}
.sme-ml-status.sme-ok{color:var(--sme-green)}
.sme-ml-progress{width:100%;height:3px;background:var(--sme-track);border-radius:var(--sme-radius-xs);margin-top:6px;overflow:hidden;display:none}
.sme-ml-check{margin:0 6px 0 2px;cursor:pointer;accent-color:var(--sme-blue);vertical-align:middle}
.market_listing_row.sme-ml-overpriced{box-shadow:inset 3px 0 0 var(--sme-red)}
.market_listing_row.sme-ml-overpriced .market_listing_my_price{background:var(--sme-red-a8)}
.sme-ml-sortable{cursor:pointer;user-select:none}
.sme-ml-sortable:hover{color:var(--sme-blue)}
.sme-ml-sortarrow{font-size:10px;color:var(--sme-blue);margin-left:3px;opacity:0}
.sme-ml-sortable.sme-active .sme-ml-sortarrow{opacity:1}
    `;

    /** 入口：在市场主页"我的挂单"区域启用增强功能 */
    function initMyListingsEnhancement() {
        if (myListingsModuleActive) return;
        const enableBatch = settings.get('marketBatchButtons');
        const enableSort = settings.get('marketSorting');
        const enableSearch = settings.get('marketSearch');
        if (!enableBatch && !enableSort && !enableSearch) return;

        if (!myListingsStyleAdded) {
            GM_addStyle(MY_LISTINGS_CSS);
            myListingsStyleAdded = true;
        }

        // "我的挂单"区域为 AJAX 异步加载，轮询等待其出现
        let attempts = 0;
        const tryStart = () => {
            const container = document.getElementById('my_market_selllistings');
            if (container && container.querySelector('.market_listing_row')) {
                startMyListingsModule(container);
            } else if (attempts++ < 30) {
                setTimeout(tryStart, 500);
            }
        };
        tryStart();
    }

    function startMyListingsModule(container) {
        if (myListingsModuleActive) return;
        myListingsModuleActive = true;
        L('My Listings enhancement module active');
        injectMyListingsToolbar(container);
        setupMyListingsSortHeaders(container);
        processMyListingsRows(container);
        setupMyListingsObserver(container);
    }

    /** 清理模块状态（URL 变化时调用） */
    function cleanupMyListingsEnhancement() {
        if (myListingsObserver) { myListingsObserver.disconnect(); myListingsObserver = null; }
        if (myListingsToolbarEl) { myListingsToolbarEl.remove(); myListingsToolbarEl = null; }
        myListingsModuleActive = false;
        myListingsSortKey = null;
        myListingsSortAsc = true;
        myListingsSearchQ = '';
        myListingsBusy = false;
        myListingsPriceCheck.clear();
    }

    // ---------- 工具栏 ----------
    function injectMyListingsToolbar(container) {
        if (myListingsToolbarEl && document.body.contains(myListingsToolbarEl)) {
            updateMyListingsCount();
            return;
        }
        const enableBatch = settings.get('marketBatchButtons');
        const enableSearch = settings.get('marketSearch');
        const controls = [];

        if (enableBatch) {
            controls.push(
                h('button', { class: 'sme-market-btn', html: ICONS.selectAll + '<span>全选</span>', onClick: onSelectAllMyListings }),
                h('button', { class: 'sme-market-btn', text: '选5个', onClick: () => selectNMyListings(5) }),
                h('button', { class: 'sme-market-btn', text: '选25个', onClick: () => selectNMyListings(25) }),
                h('button', { class: 'sme-market-btn', html: ICONS.alert + '<span>选超价</span>', onClick: onSelectOverpricedMyListings }),
                h('span', { class: 'sme-ml-sep' }),
                h('button', { class: 'sme-market-btn sme-danger', html: ICONS.trash + '<span>批量下架</span>', onClick: onRemoveSelectedMyListings }),
                h('button', { class: 'sme-market-btn', html: ICONS.refreshCw + '<span>超价重挂</span>', onClick: onRelistOverpricedMyListings }),
            );
        }
        if (enableSearch) {
            controls.push(
                h('span', { html: ICONS.search, style: { color: 'var(--sme-text-dim)', display: 'inline-flex', alignItems: 'center' } }),
                h('input', {
                    class: 'sme-market-search', type: 'text', placeholder: '搜索物品名称…', value: myListingsSearchQ,
                    oninput: (e) => {
                        myListingsSearchQ = e.target.value.trim().toLowerCase();
                        const c = document.getElementById('my_market_selllistings');
                        if (c) applyMyListingsSortAndFilter(c);
                    },
                }),
            );
        }
        controls.push(h('span', { class: 'sme-ml-count', id: 'sme-ml-count' }));

        myListingsToolbarEl = h('div', { class: 'sme-ml-toolbar' }, [
            h('div', { style: { display: 'flex', alignItems: 'center', gap: '6px', flexWrap: 'wrap', width: '100%' } }, controls),
            h('div', { class: 'sme-ml-status', id: 'sme-ml-status' }),
            h('div', { class: 'sme-ml-progress', id: 'sme-ml-progress' }, [
                h('div', { class: 'sme-ml-progress-bar', id: 'sme-ml-progress-bar' }),
            ]),
        ]);
        container.parentNode.insertBefore(myListingsToolbarEl, container);
        updateMyListingsCount();
    }

    function getMyListingsStatusEls() {
        return {
            statusEl: document.getElementById('sme-ml-status'),
            progressEl: document.getElementById('sme-ml-progress'),
            progressBarEl: document.getElementById('sme-ml-progress-bar'),
        };
    }
    function setMyListingsStatus(el, msg, cls) {
        if (!el) return;
        el.textContent = msg || '';
        el.className = 'sme-ml-status' + (cls === 'err' ? ' sme-err' : (cls === 'ok' ? ' sme-ok' : ''));
    }
    function showMyListingsProgress(el, show) { if (el) el.style.display = show ? '' : 'none'; }
    function setMyListingsProgress(el, ratio) { if (el) el.style.width = Math.max(0, Math.min(1, ratio)) * 100 + '%'; }
    function setMyListingsButtonsDisabled(disabled) {
        if (!myListingsToolbarEl) return;
        myListingsToolbarEl.querySelectorAll('button.sme-market-btn').forEach(b => { b.disabled = disabled; });
    }

    function updateMyListingsCount() {
        const el = document.getElementById('sme-ml-count');
        if (!el) return;
        const c = document.getElementById('my_market_selllistings');
        if (!c) return;
        let total = 0, selected = 0, visible = 0;
        c.querySelectorAll('.market_listing_row').forEach(r => {
            const d = myListingsRowData.get(r);
            if (!d) return;
            total++;
            if (r.style.display !== 'none') visible++;
            if (d.checked) selected++;
        });
        el.innerHTML = `已选 <b>${selected}</b> / 显示 ${visible} / 共 ${total}`;
    }

    // ---------- 行解析与复选框 ----------
    function parseMyListingRow(row) {
        const m = (row.id || '').match(/^mylisting_(\d+)$/);
        if (!m) return null;
        const listingid = m[1];
        const nameEl = row.querySelector('.market_listing_item_name');
        const name = nameEl ? nameEl.textContent.trim() : '';
        const dateEl = row.querySelector('.market_listing_listed_date');
        const dateText = dateEl ? dateEl.textContent.trim() : '';
        const { buyerCents, sellerCents } = extractMyListingPrices(row);
        return { row, listingid, name, dateText, dateTs: parseMyListingDate(dateText), buyerCents, sellerCents, checked: false };
    }

    function extractMyListingPrices(row) {
        let buyerCents = 0, sellerCents = 0;
        const sellerRe = /你将收到|You will receive|Sie erhalten|Вы получите|receberá|会收到/i;
        row.querySelectorAll('.market_listing_price').forEach(el => {
            const txt = el.textContent || '';
            const cents = parsePriceToCents(txt);
            if (sellerRe.test(txt)) { if (!sellerCents) sellerCents = cents; }
            else { if (!buyerCents) buyerCents = cents; }
        });
        if (buyerCents && !sellerCents) sellerCents = priceBeforeFees(buyerCents);
        if (sellerCents && !buyerCents) buyerCents = priceIncludingFees(sellerCents);
        return { buyerCents, sellerCents };
    }

    function parseMyListingDate(text) {
        if (!text) return 0;
        const t = text.trim();
        let d = new Date(t);
        if (isNaN(d.getTime())) d = new Date(t + ' ' + new Date().getFullYear());
        if (isNaN(d.getTime())) return 0;
        // 仅含月日时，若解析到未来超过 7 天，视为去年
        if (d.getTime() - Date.now() > 7 * 24 * 3600 * 1000) d.setFullYear(d.getFullYear() - 1);
        return d.getTime();
    }

    function injectMyListingCheckbox(row, data) {
        if (row.querySelector('.sme-ml-check')) return;
        const cb = h('input', { type: 'checkbox', class: 'sme-ml-check', title: '选择此挂单' });
        cb.addEventListener('change', () => { data.checked = cb.checked; updateMyListingsCount(); });
        const area = row.querySelector('.market_listing_cancel_button') || row.querySelector('.market_listing_cancel');
        if (area) area.insertBefore(cb, area.firstChild);
        else row.insertBefore(cb, row.firstChild);
    }

    function processMyListingsRows(container) {
        let fresh = false;
        container.querySelectorAll('.market_listing_row').forEach(row => {
            if (myListingsRowData.has(row)) return;
            const data = parseMyListingRow(row);
            if (!data) return;
            myListingsRowData.set(row, data);
            if (settings.get('marketBatchButtons')) injectMyListingCheckbox(row, data);
            fresh = true;
        });
        if (fresh) {
            applyMyListingsSortAndFilter(container);
            updateMyListingsCount();
        }
    }

    // ---------- 排序与搜索 ----------
    function applyMyListingsSortAndFilter(container) {
        const rows = Array.from(container.querySelectorAll('.market_listing_row'));
        if (rows.length === 0) return;
        if (myListingsSortKey) {
            rows.sort((a, b) => {
                const da = myListingsRowData.get(a), db = myListingsRowData.get(b);
                if (!da || !db) return 0;
                let cmp = 0;
                if (myListingsSortKey === 'name') cmp = da.name.localeCompare(db.name, 'zh');
                else if (myListingsSortKey === 'date') cmp = (da.dateTs || 0) - (db.dateTs || 0);
                else if (myListingsSortKey === 'price') cmp = (da.buyerCents || 0) - (db.buyerCents || 0);
                return myListingsSortAsc ? cmp : -cmp;
            });
            reorderMyListingRows(rows);
        }
        const q = myListingsSearchQ;
        rows.forEach(row => {
            const data = myListingsRowData.get(row);
            const match = !q || (data && data.name.toLowerCase().indexOf(q) !== -1);
            row.style.display = match ? '' : 'none';
        });
        updateMyListingsCount();
    }

    function reorderMyListingRows(sortedRows) {
        if (sortedRows.length === 0) return;
        const parent = sortedRows[0].parentNode;
        const placeholder = document.createComment('sme-ml-sort');
        parent.insertBefore(placeholder, sortedRows[0]);
        // 依次把已排序行插入占位符之前，最终顺序即为排序顺序；表头/分页等非行元素保持原位
        for (const row of sortedRows) parent.insertBefore(row, placeholder);
        placeholder.remove();
    }

    function setupMyListingsSortHeaders(container) {
        if (!settings.get('marketSorting')) return;
        const header = container.querySelector('.market_listing_table_header');
        if (!header || header.dataset.smeMlSort) return;
        header.dataset.smeMlSort = '1';
        const nameRe = /(物品|名称|商品|item|name)/i;
        const priceRe = /(价格|价钱|price)/i;
        const dateRe = /(时间|日期|挂单|listed|date)/i;
        Array.from(header.children).forEach(cell => {
            const txt = cell.textContent || '';
            let key = null;
            if (nameRe.test(txt)) key = 'name';
            else if (priceRe.test(txt)) key = 'price';
            else if (dateRe.test(txt)) key = 'date';
            if (!key) return;
            cell.classList.add('sme-ml-sortable');
            cell.dataset.smeMlKey = key;
            cell.appendChild(h('span', { class: 'sme-ml-sortarrow', text: '▼' }));
            cell.addEventListener('click', () => {
                if (myListingsSortKey === key) myListingsSortAsc = !myListingsSortAsc;
                else { myListingsSortKey = key; myListingsSortAsc = true; }
                refreshMyListingsSortHeaders(header);
                const c = document.getElementById('my_market_selllistings');
                if (c) applyMyListingsSortAndFilter(c);
            });
        });
        refreshMyListingsSortHeaders(header);
    }

    function refreshMyListingsSortHeaders(header) {
        header.querySelectorAll('.sme-ml-sortable').forEach(cell => {
            const key = cell.dataset.smeMlKey;
            const active = key && myListingsSortKey === key;
            cell.classList.toggle('sme-active', active);
            const arrow = cell.querySelector('.sme-ml-sortarrow');
            if (arrow) arrow.textContent = active ? (myListingsSortAsc ? '▲' : '▼') : '▼';
        });
    }

    function setupMyListingsObserver(container) {
        if (myListingsObserver) myListingsObserver.disconnect();
        let debounce = null;
        myListingsObserver = new MutationObserver(() => {
            clearTimeout(debounce);
            debounce = setTimeout(() => processMyListingsRows(container), 200);
        });
        myListingsObserver.observe(container, { childList: true, subtree: true });
    }

    // ---------- 选择操作 ----------
    function getVisibleMyListingRows() {
        const c = document.getElementById('my_market_selllistings');
        if (!c) return [];
        return Array.from(c.querySelectorAll('.market_listing_row')).filter(r => {
            const d = myListingsRowData.get(r);
            return d && r.style.display !== 'none';
        });
    }
    function setMyListingChecked(row, data, checked) {
        if (!data) return;
        data.checked = checked;
        const cb = row.querySelector('.sme-ml-check');
        if (cb) cb.checked = checked;
    }
    function onSelectAllMyListings() {
        const rows = getVisibleMyListingRows();
        const allChecked = rows.length > 0 && rows.every(r => myListingsRowData.get(r).checked);
        rows.forEach(r => setMyListingChecked(r, myListingsRowData.get(r), !allChecked));
        updateMyListingsCount();
    }
    function selectNMyListings(n) {
        const c = document.getElementById('my_market_selllistings');
        if (c) c.querySelectorAll('.market_listing_row').forEach(r => {
            const d = myListingsRowData.get(r);
            if (d) setMyListingChecked(r, d, false);
        });
        getVisibleMyListingRows().slice(0, n).forEach(r => setMyListingChecked(r, myListingsRowData.get(r), true));
        updateMyListingsCount();
    }

    // ---------- 资产信息提取 ----------
    function getMyListingAssetInfo(listingid) {
        let info = null;
        try {
            const ml = unsafeWindow.g_oMyListings;
            if (ml) info = (ml.m_rgListingInfo && ml.m_rgListingInfo[listingid]) || (ml.m_rgListings && ml.m_rgListings[listingid]) || null;
        } catch (e) {}
        if (!info) return null;
        const asset = info.asset || info.rgAsset || info;
        const appid = String(asset.appid || info.appid || '');
        const contextid = String(asset.contextid || info.contextid || resolveContextId(appid));
        const assetid = String(asset.assetid || asset.id || info.assetid || '');
        let marketHashName = '';
        let classid = '';
        if (appid && contextid && assetid) {
            try {
                const ctx = unsafeWindow.g_rgAssets && unsafeWindow.g_rgAssets[appid] && unsafeWindow.g_rgAssets[appid][contextid];
                const a = ctx && ctx[assetid];
                if (a) {
                    const desc = a.description || a;
                    marketHashName = desc.market_hash_name || desc.market_name || desc.name || '';
                    classid = String(a.classid || desc.classid || '');
                }
            } catch (e) {}
        }
        if (!marketHashName) {
            const desc = asset.description || info.description;
            if (desc) {
                marketHashName = desc.market_hash_name || desc.market_name || desc.name || '';
                classid = classid || String(desc.classid || '');
            }
        }
        if (!marketHashName) marketHashName = asset.market_hash_name || info.market_hash_name || '';
        classid = classid || String(asset.classid || info.classid || '');
        return { appid, contextid, assetid, marketHashName, classid };
    }

    // ---------- 带限流重试的请求包装 ----------
    async function withMarketRetry(fn, label, maxAttempts) {
        if (maxAttempts === undefined) maxAttempts = 3;
        let lastErr;
        for (let attempt = 0; attempt < maxAttempts; attempt++) {
            try { return await fn(); }
            catch (err) {
                lastErr = err;
                const msg = err && err.message ? err.message : String(err);
                const isRate = msg === 'RateLimited' || /429/i.test(msg);
                if ((isRate || isRetryMessage(msg)) && attempt < maxAttempts - 1) {
                    const wait = randInt(RETRY_BACKOFF_MIN, RETRY_BACKOFF_MAX);
                    toast(`${label || '操作'}: 请求受限，${Math.round(wait / 1000)} 秒后重试…`, 'warning');
                    await sleep(wait);
                    continue;
                }
                throw err;
            }
        }
        throw lastErr;
    }

    async function fetchMyListingOrderBook(appid, hash) {
        // ★ v2.0.0：item_nameid 链路已死（实测全站无此值）→ 改抓物品页 SSR 取订单簿。
        await sleep(randInt(INV_REQUEST_DELAY, INV_REQUEST_DELAY + 500));
        try {
            return await withMarketRetry(() => fetchOrderBookByPage(appid, hash), '订单簿');
        } catch (e) { return null; }
    }

    async function computeMyListingSuggestedPrice(appid, hash) {
        let priceHistory = null;
        try { priceHistory = await withMarketRetry(() => fetchPriceHistory(appid, hash), '价格历史'); }
        catch (e) {}
        await sleep(randInt(INV_REQUEST_DELAY, INV_REQUEST_DELAY + 500));
        const orderBook = await fetchMyListingOrderBook(appid, hash);
        // calcSellPrice 在缺少订单簿时会退化为仅按历史均价定价
        return calcSellPrice(priceHistory, orderBook, true);
    }

    async function runMyListingsPriceCheck(statusEl, progressEl, progressBarEl) {
        const c = document.getElementById('my_market_selllistings');
        if (!c) return;
        const rows = Array.from(c.querySelectorAll('.market_listing_row')).filter(r => {
            const d = myListingsRowData.get(r);
            return d && r.style.display !== 'none';
        });
        // 按唯一物品分组，避免重复请求
        const itemMap = new Map();
        for (const row of rows) {
            const d = myListingsRowData.get(row);
            const ai = getMyListingAssetInfo(d.listingid);
            if (!ai || !ai.appid || !ai.marketHashName) {
                myListingsPriceCheck.set(d.listingid, { overpriced: false, suggestedCents: 0, source: '无物品信息', buyerCents: d.buyerCents, unknown: true });
                continue;
            }
            d._asset = ai;
            const key = ai.appid + '|' + ai.marketHashName;
            if (!itemMap.has(key)) itemMap.set(key, { appid: ai.appid, hash: ai.marketHashName, listingids: [] });
            itemMap.get(key).listingids.push(d.listingid);
        }
        const items = Array.from(itemMap.values());
        const total = items.length;
        if (total === 0) {
            setMyListingsStatus(statusEl, '无可检测的物品（缺少物品信息）', 'err');
            return;
        }
        showMyListingsProgress(progressEl, true);
        setMyListingsProgress(progressBarEl, 0);
        let done = 0;
        for (const item of items) {
            setMyListingsStatus(statusEl, `正在检测价格 ${done}/${total}：${item.hash.slice(0, 30)}…`, '');
            try {
                const suggested = await computeMyListingSuggestedPrice(item.appid, item.hash);
                const suggestedBuyerCents = priceIncludingFees(suggested.priceCents);
                for (const lid of item.listingids) {
                    const row = document.getElementById('mylisting_' + lid);
                    const d = row ? myListingsRowData.get(row) : null;
                    const buyerCents = d ? d.buyerCents : 0;
                    const overpriced = suggestedBuyerCents > 0 && buyerCents > suggestedBuyerCents;
                    myListingsPriceCheck.set(lid, { overpriced, suggestedCents: suggested.priceCents, source: suggested.source, buyerCents });
                    if (row) {
                        row.classList.toggle('sme-ml-overpriced', overpriced);
                        if (d) d._suggested = suggested;
                    }
                }
            } catch (err) {
                W('Price check failed for', item.appid, item.hash, err && err.message);
                for (const lid of item.listingids) {
                    myListingsPriceCheck.set(lid, { overpriced: false, suggestedCents: 0, source: '检测失败', buyerCents: 0, unknown: true });
                }
            }
            done++;
            setMyListingsProgress(progressBarEl, done / total);
            setMyListingsStatus(statusEl, `正在检测价格 ${done}/${total}…`, '');
            if (done < total) await sleep(randInt(INV_REQUEST_DELAY, INV_REQUEST_DELAY + 500));
        }
        setMyListingsStatus(statusEl, `价格检测完成，共 ${total} 种物品`, 'ok');
        setTimeout(() => showMyListingsProgress(progressEl, false), 1500);
    }

    async function onSelectOverpricedMyListings() {
        if (myListingsBusy) { toast('已有操作进行中，请稍候', 'warning'); return; }
        myListingsBusy = true;
        setMyListingsButtonsDisabled(true);
        const { statusEl, progressEl, progressBarEl } = getMyListingsStatusEls();
        try {
            const c = document.getElementById('my_market_selllistings');
            if (c) c.querySelectorAll('.sme-ml-overpriced').forEach(r => r.classList.remove('sme-ml-overpriced'));
            myListingsPriceCheck.clear();
            await runMyListingsPriceCheck(statusEl, progressEl, progressBarEl);
            let count = 0;
            if (c) c.querySelectorAll('.market_listing_row').forEach(r => {
                const d = myListingsRowData.get(r);
                if (!d) return;
                const chk = myListingsPriceCheck.get(d.listingid);
                const over = chk && chk.overpriced;
                setMyListingChecked(r, d, over);
                if (over) count++;
            });
            updateMyListingsCount();
            toast(`检测完成，选中 ${count} 件超价物品`, count > 0 ? 'success' : 'info');
        } catch (err) {
            setMyListingsStatus(statusEl, '价格检测出错: ' + (err && err.message), 'err');
            toast('价格检测出错: ' + friendlyError(err), 'error');
        } finally {
            myListingsBusy = false;
            setMyListingsButtonsDisabled(false);
        }
    }

    // ---------- 下架 / 重新上架 ----------
    async function removeMyListing(listingid) {
        const sessionid = await resolveSessionId();
        if (!sessionid) throw new Error('无法获取会话ID');
        const resp = await smeRequest(`https://steamcommunity.com/market/removelisting/${listingid}`, {
            method: 'POST',
            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
            body: `sessionid=${encodeURIComponent(sessionid)}`,
            expect: 'none',
        });
        let data = null;
        try { data = await resp.json(); } catch (e) {}
        if (data && data.success === false) throw new Error(data.message || '下架失败');
        return true;
    }

    async function onRemoveSelectedMyListings() {
        if (myListingsBusy) { toast('已有操作进行中，请稍候', 'warning'); return; }
        const c = document.getElementById('my_market_selllistings');
        if (!c) return;
        const selected = Array.from(c.querySelectorAll('.market_listing_row')).filter(r => {
            const d = myListingsRowData.get(r);
            return d && d.checked;
        });
        if (selected.length === 0) { toast('未选中任何挂单', 'warning'); return; }
        if (!(await showConfirmDialog(`确定要下架选中的 <strong>${selected.length}</strong> 件物品吗？`, { title: '批量下架', okText: '下架' }))) return;

        myListingsBusy = true;
        setMyListingsButtonsDisabled(true);
        const { statusEl, progressEl, progressBarEl } = getMyListingsStatusEls();
        showMyListingsProgress(progressEl, true);
        let success = 0, failed = 0;
        for (let i = 0; i < selected.length; i++) {
            const row = selected[i];
            const d = myListingsRowData.get(row);
            setMyListingsStatus(statusEl, `正在下架 ${i + 1}/${selected.length}…`, '');
            setMyListingsProgress(progressBarEl, i / selected.length);
            try {
                await withMarketRetry(() => removeMyListing(d.listingid), '下架');
                success++;
                row.remove();
                myListingsRowData.delete(row);
                myListingsPriceCheck.delete(d.listingid);
            } catch (err) {
                failed++;
                W('下架失败:', d.listingid, err && err.message);
                setMyListingChecked(row, d, false);
            }
            if (i < selected.length - 1) await sleep(randInt(INV_REQUEST_DELAY, INV_REQUEST_DELAY + 500));
        }
        setMyListingsProgress(progressBarEl, 1);
        setMyListingsStatus(statusEl, `下架完成: 成功 ${success} 件` + (failed > 0 ? `，失败 ${failed} 件` : ''), failed > 0 ? 'err' : 'ok');
        toast(`下架完成: 成功 ${success} 件` + (failed > 0 ? `，失败 ${failed} 件` : ''), failed > 0 ? 'warning' : 'success');
        setTimeout(() => showMyListingsProgress(progressEl, false), 2000);
        updateMyListingsCount();
        myListingsBusy = false;
        setMyListingsButtonsDisabled(false);
    }

    async function onRelistOverpricedMyListings() {
        if (myListingsBusy) { toast('已有操作进行中，请稍候', 'warning'); return; }
        const c = document.getElementById('my_market_selllistings');
        if (!c) return;

        const checkedRows = Array.from(c.querySelectorAll('.market_listing_row')).filter(r => {
            const d = myListingsRowData.get(r);
            return d && d.checked;
        });
        // 若尚无价格检测结果或未选中任何行，则先对全部可见挂单进行检测
        const needCheck = myListingsPriceCheck.size === 0 || checkedRows.length === 0;
        const relistAll = needCheck;

        myListingsBusy = true;
        setMyListingsButtonsDisabled(true);
        const { statusEl, progressEl, progressBarEl } = getMyListingsStatusEls();
        try {
            if (needCheck) {
                if (c) c.querySelectorAll('.sme-ml-overpriced').forEach(r => r.classList.remove('sme-ml-overpriced'));
                myListingsPriceCheck.clear();
                await runMyListingsPriceCheck(statusEl, progressEl, progressBarEl);
            }
            const rows = Array.from(c.querySelectorAll('.market_listing_row')).filter(r => {
                const d = myListingsRowData.get(r);
                if (!d) return false;
                const chk = myListingsPriceCheck.get(d.listingid);
                if (!chk || !chk.overpriced || chk.suggestedCents <= 0) return false;
                return relistAll ? true : d.checked;
            });
            if (rows.length === 0) {
                setMyListingsStatus(statusEl, '未检测到超价物品', '');
                toast('未检测到超价物品', 'info');
                return;
            }

            // 步骤1: 弹出价格对话框（预填建议到手价，用户可自定义）
            const firstChk = myListingsPriceCheck.get(myListingsRowData.get(rows[0]).listingid);
            const suggestedCents = firstChk ? firstChk.suggestedCents : 0;
            const priceResult = await showPriceDialog(
                myListingsRowData.get(rows[0]).buyerCents ? formatCents(myListingsRowData.get(rows[0]).buyerCents) : '未知',
                rows.length,
                suggestedCents
            );
            if (priceResult === null) {
                setMyListingsStatus(statusEl, '已取消', '');
                return;
            }
            const { receivedCents, buyerCents } = priceResult;

            // 步骤2: 二次确认
            const confirmed = await showConfirmDialog(
                `即将下架 <strong>${rows.length}</strong> 件超价物品，` +
                `以新价格重新上架（您将收到 <strong>${escapeHtml(formatCents(receivedCents))}</strong>，` +
                `买方支付 <strong>${escapeHtml(formatCents(buyerCents))}</strong>），确认继续？`,
                { title: '确认重新上架', okText: '确认重新上架', okClass: 'sme-dialog-blue' }
            );
            if (!confirmed) {
                setMyListingsStatus(statusEl, '已取消', '');
                return;
            }

            const total = rows.length;
            showMyListingsProgress(progressEl, true);
            let success = 0, delistFailed = 0, relistFailed = 0;
            let lastSellMsg = '';
            const usedAssetIds = new Set();

            for (let i = 0; i < rows.length; i++) {
                const row = rows[i];
                const d = myListingsRowData.get(row);
                setMyListingsStatus(statusEl, `重新上架 ${i + 1}/${total}: 下架中…`, '');
                setMyListingsProgress(progressBarEl, i / total);
                try {
                    // 步骤1: 下架
                    await withMarketRetry(() => removeMyListing(d.listingid), '下架');

                    // 步骤2: 等待物品返回库存并重新定位 assetid（下架后可能变化）
                    setMyListingsStatus(statusEl, `重新上架 ${i + 1}/${total}: 等待物品返回库存…`, '');
                    const ai = d._asset || getMyListingAssetInfo(d.listingid);
                    if (!ai || !ai.assetid || !ai.appid) {
                        W('重挂缺少资产信息:', d.listingid);
                        relistFailed++;
                        row.remove();
                        myListingsRowData.delete(row);
                        continue;
                    }
                    let sellAssetId = ai.assetid;

                    // 有 classid 时按 classid 轮询库存 API 定位回库资产（assetid 可能变化）
                    if (ai.classid) {
                        const returnedId = await waitForReturnedAsset(
                            ai.appid, ai.contextid, ai.classid, usedAssetIds, 10000
                        );
                        if (returnedId) {
                            sellAssetId = returnedId;
                            usedAssetIds.add(returnedId);
                            if (returnedId !== ai.assetid) {
                                L('Relist: assetid changed after delist:', ai.assetid, '->', returnedId);
                            }
                        } else {
                            W('Relist: returned asset not found by classid', ai.classid, '; using original assetid', ai.assetid);
                        }
                    } else {
                        // 无 classid 时回退到固定等待
                        await sleep(randInt(1500, 2500));
                    }

                    // 步骤3: 以新价格重新上架（2 次重试）
                    setMyListingsStatus(statusEl, `重新上架 ${i + 1}/${total}: 上架中 (${formatCents(buyerCents)})…`, '');
                    let sellOk = false;
                    let sellMsg = '';
                    for (let attempt = 0; attempt < 2 && !sellOk; attempt++) {
                        if (attempt > 0) {
                            setMyListingsStatus(statusEl, `重新上架 ${i + 1}/${total}: 重试上架…`, '');
                            await sleep(1500);
                        }
                        try {
                            await sellItem({
                                assetid: sellAssetId, appid: ai.appid, contextid: ai.contextid, priceCents: receivedCents,
                            });
                            sellOk = true;
                        } catch (sellErr) {
                            sellMsg = sellErr.message;
                            W(`重挂上架失败 (attempt ${attempt + 1}):`, d.listingid, sellErr.message);
                        }
                    }
                    if (!sellOk) {
                        relistFailed++;
                        lastSellMsg = lastSellMsg || sellMsg;
                        row.remove();
                        myListingsRowData.delete(row);
                        myListingsPriceCheck.delete(d.listingid);
                        continue;
                    }

                    success++;
                    row.remove();
                    myListingsRowData.delete(row);
                    myListingsPriceCheck.delete(d.listingid);
                } catch (err) {
                    delistFailed++;
                    W('重挂失败:', d.listingid, err && err.message);
                    setMyListingChecked(row, d, false);
                }
                if (i < rows.length - 1) await sleep(randInt(INV_REQUEST_DELAY, INV_REQUEST_DELAY + 500));
            }
            setMyListingsProgress(progressBarEl, 1);
            let msg = `重新上架完成: 成功 ${success} 件`;
            if (delistFailed > 0) msg += `，下架失败 ${delistFailed} 件`;
            if (relistFailed > 0) msg += `，上架失败 ${relistFailed} 件（已回库存${lastSellMsg ? ': ' + lastSellMsg : ''}）`;
            setMyListingsStatus(statusEl, msg, (delistFailed || relistFailed) ? 'err' : 'ok');
            toast(msg, (delistFailed || relistFailed) ? 'warning' : 'success');
            setTimeout(() => showMyListingsProgress(progressEl, false), 3000);
            updateMyListingsCount();
        } catch (err) {
            setMyListingsStatus(statusEl, '重新上架出错: ' + (err && err.message), 'err');
            toast('重新上架出错: ' + friendlyError(err), 'error');
        } finally {
            myListingsBusy = false;
            setMyListingsButtonsDisabled(false);
        }
    }

    // ==================== 库存页 ====================
    // 库存页增强：价格标签、快速出售面板、批量操作工具栏
    let invObserver = null;            // MutationObserver 实例
    let invToolbarEl = null;          // 批量操作工具栏 DOM
    let invPriceLabels = new Map();    // 价格缓存：key=`appid|hash` → {cents,text,done,error}
    // v1.5.1 P2-B：价格标签持久缓存（24h、按币种隔离、防抖写盘）——
    // 重复访问库存页对已查询过的物品零请求；配合按需标注，大库存不再整页排队
    const INV_PRICE_STORE_KEY = 'sme_inv_prices_v1';
    const INV_PRICE_STORE_TTL = 24 * 60 * 60 * 1000;
    let _invPriceStore = null;
    let _invPriceStoreTimer = null;

    function invPriceStoreLoad() {
        if (_invPriceStore) return _invPriceStore;
        let cur = '';
        try { cur = (getWalletInfo() || {}).wallet_currency || ''; } catch (e) {}
        try {
            const raw = smeKv.getSync(INV_PRICE_STORE_KEY, null);
            const obj = raw ? JSON.parse(raw) : null;
            _invPriceStore = (obj && obj.currency === cur && obj.items) ? obj : { currency: cur, items: {} };
        } catch (e) { _invPriceStore = { currency: cur, items: {} }; }
        return _invPriceStore;
    }
    /** 读取持久缓存（过期条目顺手清除）；未命中返回 null */
    function invPriceStoreGet(key) {
        const store = invPriceStoreLoad();
        const it = store.items[key];
        if (!it) return null;
        if (Date.now() - it.ts > INV_PRICE_STORE_TTL) { delete store.items[key]; return null; }
        return { cents: it.c, text: it.t, done: true };
    }
    /** 写入持久缓存（2s 防抖批量落盘） */
    function invPriceStorePut(key, cents, text) {
        const store = invPriceStoreLoad();
        store.items[key] = { c: cents, t: text, ts: Date.now() };
        if (_invPriceStoreTimer) return;
        _invPriceStoreTimer = setTimeout(() => {
            _invPriceStoreTimer = null;
            smeKv.set(INV_PRICE_STORE_KEY, JSON.stringify(store)).catch(() => {});
        }, 2000);
    }
    let invQuickSellEl = null;        // 当前快速出售面板 DOM
    let invSelectedItem = null;       // 当前选中物品数据（供"转宝石"使用）
    let invBatchRunning = false;       // 批量操作进行中标记
    const invPricePending = new Map(); // 正在请求的价格 key → Promise（去重）
    // v1.5.1 P1-A 深化：价格请求串行队列收敛为统一调度器通道（节奏策略保留在任务体内，不变）
    const smeChInvPrice = new SmeRateChannel('invPrice', {});

    /** 库存页入口 */
    function initInventoryPage() {
        L('Initializing inventory page features');
        // v2.0.1：后台预热库存限制天数（交易冷却角标需要），不阻塞首屏
        ensureInvRestrictionsWarm();
        let attempt = 0;
        const tryInit = () => {
            const ready = unsafeWindow.g_ActiveInventory || document.querySelector('.inventory_ctn .item');
            if (ready || attempt >= 30) {
                if (settings.get('inventoryPriceLabels')) {
                    processInventoryItems();
                    setupInventoryObserver();
                }
                if (settings.get('quickSellButtons')) {
                    addInventoryToolbar();
                    hookItemSelection();
                }
                // v2.0.1：预热完成后补一次冷却角标（首屏时限制数据可能还没到）
                setTimeout(() => {
                    for (const el of getInventoryItemElements()) {
                        const data = getRgItemFromElement(el);
                        if (!data || !data.market_hash_name) continue;
                        addCooldownBadgeToItem(el, data.market_hash_name);
                    }
                }, 1500);
            } else {
                attempt++;
                setTimeout(tryInit, 500);
            }
        };
        tryInit();
    }

    /** 注入批量操作工具栏 */
    function addInventoryToolbar() {
        if (invToolbarEl) return;
        const toolbar = h('div', { class: 'sme-inv-toolbar' }, [
            h('div', { class: 'sme-inv-toolbar-title', html: ICONS.bag + '<span>批量操作</span>' }),
            h('button', { class: 'sme-inv-btn', html: ICONS.sell + '<span>出售所有物品</span>', onclick: onBatchSellAll }),
            h('button', { class: 'sme-inv-btn', html: ICONS.layers + '<span>出售重复物品</span>', onclick: onBatchSellDuplicates }),
            h('button', { class: 'sme-inv-btn', html: ICONS.tag + '<span>出售所有卡牌</span>', onclick: onBatchSellCards }),
            // v2.2.5：参考 SEE 的「出售所有箱子」，箱类物品批量清理
            h('button', { class: 'sme-inv-btn', html: ICONS.unpack + '<span>出售所有箱子</span>', onclick: onBatchSellCrates }),
            h('button', { class: 'sme-inv-btn sme-multisell-btn', html: ICONS.layers + '<span>出售多个</span>', onclick: onMultiSell }),
            h('button', { class: 'sme-inv-btn sme-danger', html: ICONS.gem + '<span>选中转宝石</span>', onclick: turnSelectedIntoGems }),
            // v1.7.0：把已加载的可市场物品加入「我的池子」，用于池子行情分析
            h('button', { class: 'sme-inv-btn', html: ICONS.chart + '<span>加入池子</span>', onclick: poolAddInventoryToPool, title: '把本页已加载的可市场物品加入「我的池子」，用于池子行情分析' }),
            h('div', { class: 'sme-inv-progress' }, [h('div', { class: 'sme-inv-progress-bar', style: { width: '0%' } })]),
            h('span', { class: 'sme-inv-status', text: '就绪' }),
        ]);
        invToolbarEl = toolbar;
        const anchor = document.querySelector('.inventory_ctn') || document.querySelector('.filter_ctn') || document.querySelector('.games_list_tab_ctn');
        if (anchor && anchor.parentNode) {
            anchor.parentNode.insertBefore(toolbar, anchor);
        } else {
            const slot = document.querySelector('.responsive_page_template_content') || document.body;
            slot.insertBefore(toolbar, slot.firstChild);
        }
    }

    /** 更新进度条与状态文本 */
    function updateInvProgress(done, total, status) {
        if (!invToolbarEl) return;
        const bar = invToolbarEl.querySelector('.sme-inv-progress-bar');
        const txt = invToolbarEl.querySelector('.sme-inv-status');
        if (bar) bar.style.width = (total > 0 ? Math.round(done / total * 100) : 0) + '%';
        if (txt && status != null) txt.textContent = status;
    }

    /** 禁用/启用工具栏按钮 */
    function setBatchButtonsDisabled(disabled) {
        if (!invToolbarEl) return;
        invToolbarEl.querySelectorAll('.sme-inv-btn').forEach(b => { b.disabled = !!disabled; });
    }

    /** 获取当前游戏库存中可见物品的 DOM 元素（id 形如 appid_contextid_assetid）
     *  仅收集当前激活游戏（g_ActiveInventory）且未被品类筛选隐藏的物品 */
    function getInventoryItemElements() {
        // 确定当前激活的游戏 appid
        let activeAppid = null;
        try {
            const inv = unsafeWindow.g_ActiveInventory;
            if (inv) activeAppid = String(inv.m_appid || inv.appid || '');
        } catch (e) {}

        const els = document.querySelectorAll('.inventory_ctn .item');
        const out = [];
        const seenIds = new Set(); // 去重：同一 assetid 只保留一个
        for (const el of els) {
            if (!el.id || !/^\d+_\d+_\d+$/.test(el.id)) continue;
            if (seenIds.has(el.id)) continue;

            if (activeAppid) {
                // 优先用 appid 过滤：只收集当前游戏库存的物品
                const parts = el.id.split('_');
                if (parts[0] !== activeAppid) continue;
            } else {
                // 回退：跳过隐藏库存容器中的物品（其他游戏的库存容器 display:none）
                const ctn = el.closest('.inventory_ctn');
                if (ctn && ctn.style.display === 'none') continue;
            }

            // 跳过被品类筛选隐藏的物品（Steam 在 .itemHolder 上设置 display:none）
            if (el.style.display === 'none') continue;
            const holder = el.parentElement;
            if (holder && holder.style.display === 'none') continue;

            seenIds.add(el.id);
            out.push(el);
        }
        return out;
    }

    /** 标准化物品数据（合并 asset 与 description） */
    function normalizeInvItem(raw, appid, contextid, assetid) {
        if (!raw) return null;
        const desc = raw.description || raw.rgDescription || raw;
        return {
            appid: String(raw.appid || appid),
            contextid: String(raw.contextid || contextid),
            assetid: String(raw.assetid || raw.id || assetid),
            market_hash_name: desc.market_hash_name || raw.market_hash_name || desc.market_name || raw.name || '',
            name: desc.name || raw.name || desc.market_hash_name || '',
            type: desc.type || raw.type || '',
            marketable: (desc.marketable != null ? desc.marketable : (raw.marketable != null ? raw.marketable : 0)),
            tradable: (desc.tradable != null ? desc.tradable : (raw.tradable != null ? raw.tradable : 0)),
            tags: desc.tags || raw.tags || {},
            owner_actions: desc.owner_actions || raw.owner_actions || [],
            amount: parseInt(raw.amount || raw.original_amount, 10) || 1,
            original_amount: parseInt(raw.original_amount || raw.amount, 10) || 1,
            element: raw.element || null,
        };
    }

    function isInvMarketable(data) {
        return !!(data && (data.marketable === 1 || data.marketable === true));
    }

    /** 通过多种途径获取物品数据（jQuery data → 直接属性 → g_ActiveInventory） */
    function getRgItemFromElement(itemEl) {
        if (!itemEl || !itemEl.id) return null;
        const parts = itemEl.id.split('_');
        if (parts.length < 3) return null;
        const appid = parts[0], contextid = parts[1], assetid = parts[2];

        // 1. jQuery data rgItem（Steam 在元素上挂载 CItem）
        try {
            const jq = unsafeWindow.$J || unsafeWindow.jQuery || unsafeWindow.$;
            if (jq) {
                const data = jq(itemEl).data('rgItem');
                if (data) return normalizeInvItem(data, appid, contextid, assetid);
            }
        } catch (e) {}
        // 2. 直接属性
        try {
            if (itemEl.rgItem) return normalizeInvItem(itemEl.rgItem, appid, contextid, assetid);
        } catch (e) {}
        // 3. g_ActiveInventory 查找
        try {
            const inv = unsafeWindow.g_ActiveInventory;
            if (inv) {
                if (inv.rgChildInventories) {
                    const child = inv.rgChildInventories[contextid];
                    if (child) {
                        if (child.rgItems && child.rgItems[assetid]) {
                            return normalizeInvItem(child.rgItems[assetid], appid, contextid, assetid);
                        }
                        if (child.m_rgAssets && child.m_rgAssets[assetid]) {
                            const asset = child.m_rgAssets[assetid];
                            const descKey = asset.classid + '_' + (asset.instanceid || '0');
                            const desc = (child.m_rgDescriptions && child.m_rgDescriptions[descKey]) ||
                                        (inv.m_rgDescriptions && inv.m_rgDescriptions[descKey]) || null;
                            return normalizeInvItem(desc ? Object.assign({}, asset, desc) : asset, appid, contextid, assetid);
                        }
                    }
                }
                if (inv.m_rgAssets && inv.m_rgAssets[assetid]) {
                    return normalizeInvItem(inv.m_rgAssets[assetid], appid, contextid, assetid);
                }
            }
        } catch (e) {}
        return null;
    }

    /** 遍历可见物品，添加价格标签 */
    function processInventoryItems() {
        const els = getInventoryItemElements();
        for (const el of els) {
            if (el.querySelector('.sme-inv-price')) continue; // 已处理
            const data = getRgItemFromElement(el);
            if (!data || !isInvMarketable(data) || !data.market_hash_name) continue;
            addPriceLabelToItem(el, data);
            // v2.0.1：交易冷却角标（仅在能确定仍在冷却期时才显示，避免误报）
            addCooldownBadgeToItem(el, data.market_hash_name);
        }
    }

    /**
     * v2.0.1：给库存物品加冷却角标。
     * 角标文案「锁 N 天」，title 给出解锁日期与依据。
     * 拿不到获得时间（未索引成交记录 / 交易所得）时**不显示** —— 宁可少说，不可乱说。
     */
    function addCooldownBadgeToItem(itemEl, hashName) {
        if (!itemEl || itemEl.querySelector('.sme-inv-cooldown')) return;
        const info = invCooldownInfo(hashName);
        if (!info) return;
        const badge = h('span', {
            class: 'sme-inv-cooldown',
            text: '锁 ' + info.daysLeft + ' 天',
            title: '交易冷却中：' + mhFmtTs(info.untilTs).slice(0, 16)
                + ' 解锁（Steam 限制 ' + info.days + ' 天，自市场买入日起算）',
        });
        itemEl.appendChild(badge);
    }

    // v1.5.1 P2-B：按需标注——只对进入视口（含前方 400px 预取）的物品发起价格请求。
    // 大库存（2000+ 件）此前一次性把全部物品的价格请求排进串行队列（1s/件 ≈ 33 分钟），
    // 现在仅用户看得见的物品才排队，配合持久缓存与请求去重，感知速度提升一个数量级。
    let invPriceIO = null;
    function getInvPriceIO() {
        if (invPriceIO) return invPriceIO;
        invPriceIO = new IntersectionObserver(entries => {
            for (const en of entries) {
                if (!en.isIntersecting) continue;
                invPriceIO.unobserve(en.target);
                const info = en.target.__smePriceInfo;
                if (!info) continue;
                delete en.target.__smePriceInfo;
                fetchInvPriceOverview(info.appid, info.hashName).then(entry => {
                    info.label.textContent = entry.text;
                    info.label.classList.remove('sme-inf');
                    if (entry.error) info.label.classList.add('sme-na');
                });
            }
        }, { rootMargin: '400px 0px' });
        return invPriceIO;
    }

    /** 为单个物品添加价格标签：命中缓存立即填充，否则进入视口后按需请求 */
    function addPriceLabelToItem(itemEl, data) {
        const label = h('span', { class: 'sme-inv-price sme-inf', text: '···' });
        itemEl.appendChild(label);
        const key = `${data.appid}|${data.market_hash_name}`;
        if (invPriceLabels.has(key) || invPriceStoreGet(key)) {
            // 缓存命中：立即填充（同步可达，无需观察）
            fetchInvPriceOverview(data.appid, data.market_hash_name).then(entry => {
                label.textContent = entry.text;
                label.classList.remove('sme-inf');
                if (entry.error) label.classList.add('sme-na');
            });
            return;
        }
        itemEl.__smePriceInfo = { appid: data.appid, hashName: data.market_hash_name, label };
        getInvPriceIO().observe(itemEl);
    }

    /** 价格概览请求（串行限流 1s/次，按 appid|hash 缓存去重，429 自动重试，不缓存错误） */
    function fetchInvPriceOverview(appid, hashName) {
        const key = `${appid}|${hashName}`;
        if (invPriceLabels.has(key)) return Promise.resolve(invPriceLabels.get(key));
        // v1.5.1 P2-B：持久缓存命中（24h 内、同币种）→ 零请求
        const stored = invPriceStoreGet(key);
        if (stored) {
            invPriceLabels.set(key, stored);
            return Promise.resolve(stored);
        }
        if (invPricePending.has(key)) return invPricePending.get(key);
        const maxRetries = 2;
        const p = smeChInvPrice.run(async () => {
            for (let attempt = 0; attempt <= maxRetries; attempt++) {
                await sleep(attempt === 0 ? INV_REQUEST_DELAY : 5000 * (attempt + 1));
                try {
                    const wi = getWalletInfo();
                    const url = `https://steamcommunity.com/market/priceoverview/?appid=${appid}&market_hash_name=${encodeURIComponent(hashName)}&currency=${wi.wallet_currency}`;
                    const po = await doFetch(url);
                    let cents = 0, text = '—';
                    if (po && po.success) {
                        // 优先使用最低卖单价，回退到中位数价
                        const priceStr = po.lowest_price || po.median_price;
                        if (priceStr) {
                            cents = parsePriceToCents(priceStr);
                            if (cents > 0) text = formatCents(cents);
                        }
                    }
                    const entry = { cents, text, done: true };
                    // 仅缓存成功结果（cents > 0），不缓存零值/错误，允许后续重试
                    if (cents > 0) {
                        invPriceLabels.set(key, entry);
                        invPriceStorePut(key, cents, text);
                    }
                    return entry;
                } catch (e) {
                    if (e.message === 'RateLimited' && attempt < maxRetries) {
                        continue; // 429 限流，等待更长延迟后重试
                    }
                    // 非 429 错误或重试耗尽：返回错误但不缓存，允许未来重试
                    return { cents: 0, text: '×', done: true, error: true };
                }
            }
            return { cents: 0, text: '×', done: true, error: true };
        });
        invPricePending.set(key, p);
        p.then(() => invPricePending.delete(key), () => invPricePending.delete(key));
        return p;
    }

    /** 获取库存物品的订单簿（最低卖单 + 最高买单） */
    async function fetchInventoryOrderBook(appid, hashName) {
        const result = { lowestSell: 0, highestBuy: 0, volume: null, lowestText: '—' };
        // 价格概览（轻量，提供最低卖单与成交量）
        try {
            const entry = await fetchInvPriceOverview(appid, hashName);
            if (entry && entry.cents > 0) {
                result.lowestSell = entry.cents;
                result.lowestText = entry.text;
            }
        } catch (e) {}
        // 订单簿（提供最高买单）—— ★ v2.0.0：改抓物品页 SSR。
        //   原实现依赖 item_nameid + itemordershistogram，实测全站已无 item_nameid → 恒失败。
        try {
            const ob = await fetchOrderBookByPage(appid, hashName);
            if (ob) {
                if (ob.highestBuy) result.highestBuy = parseInt(ob.highestBuy, 10) || 0;
                if (ob.lowestSell && !result.lowestSell) result.lowestSell = parseInt(ob.lowestSell, 10) || 0;
            }
        } catch (e) {
            W('Inventory order book fetch failed:', e.message);
        }
        return result;
    }

    /** 监听库存 DOM 变化，处理新加载的物品（防抖 400ms） */
    function setupInventoryObserver() {
        const ctn = document.querySelector('.inventory_ctn');
        if (!ctn) return;
        if (invObserver) invObserver.disconnect();
        let timer = null;
        invObserver = new MutationObserver(() => {
            if (timer) return;
            timer = setTimeout(() => {
                timer = null;
                if (settings.get('inventoryPriceLabels')) processInventoryItems();
            }, 400);
        });
        invObserver.observe(ctn, { childList: true, subtree: true });
    }

    /** 挂载物品选择钩子（事件委托），选中后显示快速出售面板 */
    function hookItemSelection() {
        const ctn = document.querySelector('.inventory_ctn') || document.body;
        const handler = (e) => {
            const itemEl = e.target && e.target.closest ? e.target.closest('.item') : null;
            if (!itemEl || !/^\d+_\d+_\d+$/.test(itemEl.id)) return;
            setTimeout(() => showQuickSellForElement(itemEl), 300);
        };
        ctn.addEventListener('click', handler, true);
    }

    function showQuickSellForElement(itemEl) {
        const data = getRgItemFromElement(itemEl);
        invSelectedItem = data; // 记录当前选中（供"转宝石"使用）
        removeQuickSellPanel();
        if (!data || !isInvMarketable(data) || !data.market_hash_name) return;
        showQuickSell(data);
    }

    function getActiveItemInfoContent() {
        // 旧版布局
        const old = document.getElementById('iteminfo0_content') || document.getElementById('iteminfo1_content');
        if (old) return old;
        // 新版 React 布局：找到可见的 iteminfo 元素
        for (const id of ['iteminfo0', 'iteminfo1']) {
            const el = document.getElementById(id);
            if (el && el.style.display !== 'none') return el;
        }
        return null;
    }

    /** 获取当前选中物品数据（多重回退：invSelectedItem → .activeInfo → 右侧详情面板） */
    function getActiveInvItem() {
        // 1. 事件钩子设置的 invSelectedItem
        if (invSelectedItem) return invSelectedItem;
        // 2. 网格中带 activeInfo 类的物品元素
        const activeEl = document.querySelector('.item.activeInfo');
        if (activeEl && /^\d+_\d+_\d+$/.test(activeEl.id)) {
            const data = getRgItemFromElement(activeEl);
            if (data) { invSelectedItem = data; return data; }
        }
        // 3. 右侧详情面板的市场链接提取
        const panel = getActiveItemInfoContent();
        if (panel) {
            const sellBtn = panel.querySelector('button[data-accent-color="green"]');
            const link = panel.querySelector('a[href*="/market/listings/"]');
            if (sellBtn && link) {
                const m = link.href.match(/\/market\/listings\/(\d+)\/(.+)$/);
                if (m) {
                    const appid = m[1];
                    const market_hash_name = decodeURIComponent(m[2]);
                    let contextid = '2';
                    try {
                        const inv = unsafeWindow.g_ActiveInventory;
                        if (inv && inv.rgChildInventories) {
                            for (const cid in inv.rgChildInventories) { contextid = cid; break; }
                        }
                    } catch (e) {}
                    const data = { appid, contextid, market_hash_name, name: market_hash_name };
                    invSelectedItem = data;
                    return data;
                }
            }
        }
        return null;
    }

    function removeQuickSellPanel() {
        if (invQuickSellEl && invQuickSellEl.parentNode) {
            invQuickSellEl.parentNode.removeChild(invQuickSellEl);
        }
        invQuickSellEl = null;
    }

    /** 显示快速出售面板 */
    function showQuickSell(data) {
        const content = getActiveItemInfoContent();
        if (!content) return;
        const panel = h('div', { class: 'sme-quick-sell' }, [
            h('div', { class: 'sme-quick-sell-title', html: ICONS.sell + '<span>快速出售 — ' + escapeHtml(data.name || data.market_hash_name) + '</span>' }),
            h('div', { class: 'sme-qs-book', text: '加载价格中...' }),
            h('div', { class: 'sme-quick-sell-btns' }, []),
        ]);
        invQuickSellEl = panel;
        content.appendChild(panel);
        fetchInventoryOrderBook(data.appid, data.market_hash_name).then(book => {
            renderQuickSellPanel(panel, data, book);
        }).catch(() => {
            const bookEl = panel.querySelector('.sme-qs-book');
            if (bookEl) bookEl.textContent = '价格加载失败';
        });
    }

    /** 渲染快速出售面板（1.4.5 重写：5 种定价模式 + 实时费用展示 + 价格偏离警告） */
    function renderQuickSellPanel(panel, data, book) {
        const bookEl = panel.querySelector('.sme-qs-book');
        const btnsEl = panel.querySelector('.sme-quick-sell-btns');
        if (!bookEl || !btnsEl) return;

        const lowestSellCents = book.lowestSell || 0;
        const highestBuyCents = book.highestBuy || 0;
        bookEl.innerHTML = '';
        bookEl.appendChild(h('div', {class:'sme-qs-book-row sme-sell', text:'最低挂单: ' + (lowestSellCents ? formatCents(lowestSellCents) : '—')}));
        bookEl.appendChild(h('div', {class:'sme-qs-book-row sme-buy', text:'最高买单: ' + (highestBuyCents ? formatCents(highestBuyCents) : '—')}));
        if (book.volume) bookEl.appendChild(h('div', {class:'sme-qs-book-row', text:'24h成交量: ' + book.volume}));

        btnsEl.innerHTML = '';

        const instantReceived = highestBuyCents > 0 ? Math.max(priceBeforeFees(highestBuyCents), 1) : 0;
        const undercutReceived = lowestSellCents > 0 ? Math.max(priceBeforeFees(lowestSellCents) - 1, 1) : 0;
        const matchReceived = lowestSellCents > 0 ? Math.max(priceBeforeFees(lowestSellCents), 1) : 0;

        const modesContainer = h('div', {class:'sme-qs-modes'}, []);

        // ★ v2.0.0 新增两种定价口径（社区「一键挂卡」标准流程）：
        //   median —— 近 N 日中位价（市场真实价，抗单笔异常成交）
        //   ratio  —— 挂刀比价目标价（压到「在 Steam 卖 ≈ 在平台卖」）
        const medianDays = parseInt(settings.get('priceStrategyMedianDays'), 10) || 30;
        const medianState = { cents: 0, loading: false, done: false };
        const ratioStateLocal = { cents: 0, done: false };

        // 挂刀目标价：只读已有比价缓存，**绝不主动请求**（跨平台抓取有封 IP 风险）
        function resolveRatioTarget() {
            if (ratioStateLocal.done) return ratioStateLocal.cents;
            ratioStateLocal.done = true;
            try {
                const appid = String(data.appid || '');
                const name = String(data.market_hash_name || '');
                if (!RATIO_SUPPORTED_APPS.includes(appid) || !name) return 0;
                const cached = ratioState.cache[appid + '::' + name];
                if (!cached || !cached.data) return 0;
                const d = cached.data;
                const lowCny = (d.buff && d.buff.lowCny) || (d.uuyp && d.uuyp.lowCny);
                if (!lowCny) return 0;
                const wi = getWalletInfo();
                const code = wi.currency_code || 'USD';
                const rate = code === 'CNY' ? 1 : getExchangeRateSync('CNY', code);
                const fee = parseFloat(settings.get('platformFeeFactor')) || 0.85;
                ratioStateLocal.cents = smeRatioTargetCents(lowCny, fee, rate);
            } catch (e) { ratioStateLocal.cents = 0; }
            return ratioStateLocal.cents;
        }

        const modes = [
            {key:'instant', label:'即时成交（最高求购价）', price: instantReceived, available: instantReceived > 0},
            {key:'undercut', label:'压价（最低卖-1分）', price: undercutReceived, available: undercutReceived > 0},
            {key:'match', label:'匹配最低卖单', price: matchReceived, available: matchReceived > 0},
            {key:'median', label:'近 ' + medianDays + ' 日中位价', price: 0, available: true},
            {key:'ratio', label:'挂刀比价目标价', price: resolveRatioTarget(), available: resolveRatioTarget() > 0},
            {key:'custom_buyer', label:'自定义买家支付价', price: 0, available: true},
            {key:'custom_received', label:'自定义到手价（突破限制）', price: 0, available: true},
        ];

        let selectedMode = settings.get('defaultPriceMode') || 'instant';
        if (!modes.find(m => m.key === selectedMode)?.available) {
            selectedMode = modes.find(m => m.available)?.key || 'custom_received';
        }

        modes.forEach(m => {
            if (!m.available) return;
            const radio = h('input', {type:'radio', name:'sme-qs-mode', value:m.key, checked: m.key === selectedMode});
            const priceText = m.price > 0 ? formatCents(m.price) : '';
            const row = h('label', {class:'sme-qs-mode' + (m.key === selectedMode ? ' active' : '')}, [
                radio,
                h('span', {class:'sme-qs-mode-label', text:m.label}),
                priceText ? h('span', {class:'sme-qs-mode-price', text:priceText}) : null,
            ].filter(Boolean));
            radio.addEventListener('change', async () => {
                modesContainer.querySelectorAll('.sme-qs-mode').forEach(el => el.classList.remove('active'));
                row.classList.add('active');
                // v2.0.0：选中「近 N 日中位价」时才惰性取历史（避免批量出售时打一堆请求）
                if (m.key === 'median' && !medianState.done && !medianState.loading) {
                    medianState.loading = true;
                    try {
                        const hist = await fetchPriceHistory(String(data.appid || ''), String(data.market_hash_name || ''));
                        medianState.cents = calcWindowMedianCents(hist, medianDays);
                    } catch (e) { medianState.cents = 0; }
                    medianState.loading = false;
                    medianState.done = true;
                    const priceEl = row.querySelector('.sme-qs-mode-price');
                    if (priceEl) {
                        priceEl.textContent = medianState.cents > 0 ? formatCents(medianState.cents) : '无历史数据';
                    }
                    updateCustomArea('median');
                }
                updateCustomArea(m.key);
            });
            modesContainer.appendChild(row);
        });
        btnsEl.appendChild(modesContainer);

        const customArea = h('div', {class:'sme-qs-custom-area', style:{display:'none'}}, []);
        const customInput = h('input', {class:'sme-qs-input', type:'number', step:'0.01', min:'0', placeholder:'0.00'});
        const customLabel = h('span', {class:'sme-qs-custom-label', text:'价格: ', style:{fontSize:'11px', color:'var(--sme-text-dim)'}});
        customArea.appendChild(h('div', {class:'sme-qs-custom-row'}, [customLabel, customInput]));
        btnsEl.appendChild(customArea);

        const feeInfo = h('div', {class:'sme-qs-fee-info', style:{display:'none'}}, []);
        btnsEl.appendChild(feeInfo);

        const warningEl = h('div', {class:'sme-qs-warning', style:{display:'none'}}, []);
        btnsEl.appendChild(warningEl);

        const sellBtn = h('button', {class:'sme-qs-sell-btn', html: ICONS.sell + '<span>出售</span>'}, []);
        btnsEl.appendChild(sellBtn);

        function getCurrentReceivedCents() {
            const mode = modesContainer.querySelector('input[name="sme-qs-mode"]:checked')?.value;
            if (mode === 'instant') return instantReceived;
            if (mode === 'undercut') return undercutReceived;
            if (mode === 'match') return matchReceived;
            if (mode === 'median') return medianState.cents;
            if (mode === 'ratio') return ratioStateLocal.cents;
            if (mode === 'custom_buyer') {
                const val = parseFloat(customInput.value);
                if (!val || val <= 0) return 0;
                return Math.max(priceBeforeFees(Math.round(val * 100)), 1);
            }
            if (mode === 'custom_received') {
                const val = parseFloat(customInput.value);
                if (!val || val <= 0) return 0;
                return Math.round(val * 100);
            }
            return 0;
        }

        function updateFeeInfo(receivedCents) {
            if (receivedCents <= 0) { feeInfo.style.display = 'none'; return; }
            feeInfo.style.display = 'block';
            const buyerCents = priceIncludingFees(receivedCents);
            feeInfo.innerHTML = '<span class="sme-qs-fee-buyer">买家支付: ' + formatCents(buyerCents) +
                '</span> | <span class="sme-qs-fee-received">你到手: ' + formatCents(receivedCents) + '</span>';
        }

        function updateWarning(receivedCents) {
            if (receivedCents <= 0 || lowestSellCents <= 0) { warningEl.style.display = 'none'; return; }
            const buyerCents = priceIncludingFees(receivedCents);
            const ratio = buyerCents / lowestSellCents;
            if (ratio >= 5) {
                warningEl.style.display = 'block';
                warningEl.className = 'sme-qs-warning sme-warn-high';
                warningEl.textContent = '⚠ 价格偏离市场价 ' + Math.round((ratio - 1) * 100) + '%，请确认价格正确';
            } else if (ratio >= 2) {
                warningEl.style.display = 'block';
                warningEl.className = 'sme-qs-warning sme-warn-mid';
                warningEl.textContent = '⚠ 价格高于市场参考 ' + Math.round((ratio - 1) * 100) + '%';
            } else {
                warningEl.style.display = 'none';
            }
        }

        function updateCustomArea(mode) {
            const isCustom = mode === 'custom_buyer' || mode === 'custom_received';
            customArea.style.display = isCustom ? 'block' : 'none';
            if (mode === 'custom_buyer') {
                customLabel.textContent = '买家支付价: ';
                customInput.placeholder = '0.00';
            } else if (mode === 'custom_received') {
                customLabel.textContent = '到手价: ';
                customInput.placeholder = '0.00 (无限制)';
            }
            if (isCustom && !customInput.value) {
                if (mode === 'custom_buyer' && lowestSellCents > 0) {
                    customInput.value = (lowestSellCents / 100).toFixed(2);
                } else if (mode === 'custom_received' && matchReceived > 0) {
                    customInput.value = (matchReceived / 100).toFixed(2);
                }
            }
            refreshState();
        }

        function refreshState() {
            const received = getCurrentReceivedCents();
            updateFeeInfo(received);
            updateWarning(received);
            sellBtn.disabled = received <= 0;
        }

        customInput.addEventListener('input', refreshState);

        sellBtn.addEventListener('click', () => {
            const received = getCurrentReceivedCents();
            if (received <= 0) { toast('请输入有效价格', 'warning'); return; }
            doQuickSell(data, received, panel);
        });

        updateCustomArea(selectedMode);
    }

    /**
     * 出售多件定价浮窗（1.4.5 新增）
     * 在快速出售面板中点击"出售多件"触发，弹窗允许用户输入数量并选择定价模式
     * @param {Object} data - 当前选中物品的 rgItem 数据
     * @param {Object} book - 当前物品的订单簿数据（lowestSell/highestBuy）
     */
    function showMultiSellDialog(data, book) {
        if (invBatchRunning) { toast('已有批量操作进行中', 'warning'); return; }

        const sameItems = collectSellableItems(d => d.market_hash_name === data.market_hash_name);
        const maxCount = sameItems.length;
        if (maxCount <= 1) { toast('当前物品没有重复件，无法多件出售', 'info'); return; }

        const lowestSellCents = book?.lowestSell || 0;
        const highestBuyCents = book?.highestBuy || 0;
        const instantReceived = highestBuyCents > 0 ? Math.max(priceBeforeFees(highestBuyCents), 1) : 0;
        const matchReceived = lowestSellCents > 0 ? Math.max(priceBeforeFees(lowestSellCents), 1) : 0;
        const undercutReceived = lowestSellCents > 0 ? Math.max(priceBeforeFees(lowestSellCents) - 1, 1) : 0;

        const overlay = document.createElement('div');
        overlay.className = 'sme-dialog-overlay';

        const modeOptions = [
            {v:'match',         t:'匹配最低卖单（建议价）'},
            {v:'undercut',      t:'压价（最低卖-1分）'},
            {v:'instant',       t:'即时成交（最高买单）'},
            {v:'custom_buyer',  t:'自定义买家支付价'},
            {v:'custom_received', t:'自定义到手价（突破限制）'},
        ];
        const modeSelect = h('select', {class:'sme-batch-sell-select'}, []);
        modeOptions.forEach(o => modeSelect.appendChild(h('option', {value:o.v, text:o.t})));
        modeSelect.value = 'match';

        const qtyInput = h('input', {class:'sme-batch-sell-input sme-batch-qty-input', type:'number', min:'1', max:String(maxCount), value:String(maxCount)});

        const priceInput = h('input', {class:'sme-batch-sell-input', type:'number', step:'0.01', min:'0', placeholder:'0.00'});
        const priceRow = h('div', {class:'sme-batch-sell-row sme-batch-price-row', style:{display:'none'}}, [
            h('label', {text:'到手价'}), priceInput,
        ]);
        const feeInfo = h('div', {class:'sme-qs-fee-info', style:{display:'none'}}, []);
        const warningEl = h('div', {class:'sme-qs-warning', style:{display:'none'}}, []);
        const summary = h('div', {class:'sme-batch-sell-summary'});

        const dialog = h('div', {class:'sme-dialog-box sme-batch-sell-dialog'}, [
            h('div', {class:'sme-dialog-header'}, [
                h('div', {class:'sme-dialog-title', text: '出售多件 — ' + (data.name || data.market_hash_name)}),
                h('button', {class:'sme-dialog-close', text:'×', onclick: () => overlay.remove()}),
            ]),
            h('div', {class:'sme-dialog-body'}, [
                h('div', {class:'sme-batch-sell-summary', html:'当前物品共有 <strong>' + maxCount + '</strong> 件可出售'}),
                h('div', {class:'sme-qs-book'}, [
                    h('div', {class:'sme-qs-book-row sme-sell', text:'最低挂单: ' + (lowestSellCents ? formatCents(lowestSellCents) : '—')}),
                    h('div', {class:'sme-qs-book-row sme-buy', text:'最高买单: ' + (highestBuyCents ? formatCents(highestBuyCents) : '—')}),
                ]),
                h('div', {class:'sme-batch-sell-row'}, [
                    h('label', {text:'出售数量'}),
                    qtyInput,
                    h('span', {text:'/ ' + maxCount, style:{fontSize:'12px', color:'var(--sme-text-dim)'}}),
                ]),
                h('div', {class:'sme-batch-sell-row'}, [
                    h('label', {text:'定价模式'}),
                    modeSelect,
                ]),
                priceRow,
                feeInfo,
                warningEl,
                summary,
            ]),
            h('div', {class:'sme-dialog-footer'}, [
                h('button', {class:'sme-dialog-cancel', text:'取消', onclick: () => overlay.remove()}),
                h('button', {class:'sme-dialog-ok', text:'确认出售', onclick: () => {
                    const qty = parseInt(qtyInput.value, 10);
                    if (!qty || qty < 1 || qty > maxCount) {
                        toast('请输入 1-' + maxCount + ' 之间的数量', 'warning'); return;
                    }
                    const mode = modeSelect.value;
                    let customPriceCents = 0;
                    if (mode === 'custom_buyer' || mode === 'custom_received') {
                        const val = parseFloat(priceInput.value);
                        if (!val || val <= 0) { toast('请输入有效价格', 'warning'); return; }
                        customPriceCents = Math.round(val * 100);
                    }
                    overlay.remove();
                    const itemsToSell = sameItems.slice(0, qty);
                    batchSell(itemsToSell, '出售多件(' + qty + '件)', mode, customPriceCents);
                }}),
            ]),
        ]);
        overlay.appendChild(dialog);
        document.body.appendChild(overlay);

        function updateState() {
            const mode = modeSelect.value;
            const isCustom = mode === 'custom_buyer' || mode === 'custom_received';
            priceRow.style.display = isCustom ? 'flex' : 'none';
            const label = priceRow.querySelector('label');
            if (mode === 'custom_buyer') label.textContent = '买家支付价';
            else if (mode === 'custom_received') label.textContent = '到手价';

            if (isCustom && !priceInput.value && lowestSellCents > 0) {
                const suggested = priceBeforeFees(lowestSellCents);
                priceInput.value = (suggested / 100).toFixed(2);
            }

            const qty = parseInt(qtyInput.value, 10) || 0;
            let receivedCents = 0;

            if (!isCustom) {
                if (mode === 'match') receivedCents = matchReceived;
                else if (mode === 'undercut') receivedCents = undercutReceived;
                else if (mode === 'instant') receivedCents = instantReceived;
            } else {
                const val = parseFloat(priceInput.value);
                if (val > 0) {
                    if (mode === 'custom_buyer')
                        receivedCents = Math.max(priceBeforeFees(Math.round(val * 100)), 1);
                    else
                        receivedCents = Math.round(val * 100);
                }
            }

            if (receivedCents > 0 && qty > 0) {
                const buyerCents = priceIncludingFees(receivedCents);
                feeInfo.style.display = 'block';
                feeInfo.innerHTML = '<span class="sme-qs-fee-buyer">买家支付: ' + formatCents(buyerCents) +
                    '/件</span> | <span class="sme-qs-fee-received">到手: ' + formatCents(receivedCents) + '/件</span>';
                summary.textContent = qty + '件 × ' + formatCents(receivedCents) +
                    ' = 到手总计 ' + formatCents(receivedCents * qty);

                if (lowestSellCents > 0) {
                    const ratio = priceIncludingFees(receivedCents) / lowestSellCents;
                    if (ratio >= 5) {
                        warningEl.style.display = 'block';
                        warningEl.className = 'sme-qs-warning sme-warn-high';
                        warningEl.textContent = '⚠ 偏离市场价 ' + Math.round((ratio-1)*100) + '%';
                    } else if (ratio >= 2) {
                        warningEl.style.display = 'block';
                        warningEl.className = 'sme-qs-warning sme-warn-mid';
                        warningEl.textContent = '⚠ 高于市场参考 ' + Math.round((ratio-1)*100) + '%';
                    } else { warningEl.style.display = 'none'; }
                } else { warningEl.style.display = 'none'; }
            } else {
                feeInfo.style.display = 'none';
                warningEl.style.display = 'none';
                summary.textContent = '';
            }
        }

        modeSelect.addEventListener('change', updateState);
        priceInput.addEventListener('input', updateState);
        qtyInput.addEventListener('input', updateState);
        updateState();
    }

    /** 执行快速出售 */
    async function doQuickSell(data, priceCents, panel) {
        const btns = panel.querySelectorAll('.sme-qs-sell-btn, .sme-qs-btn, .sme-qs-multi-btn');
        btns.forEach(b => b.disabled = true);
        const statusEl = panel.querySelector('.sme-qs-book');
        const prevHtml = statusEl ? statusEl.innerHTML : '';
        if (statusEl) statusEl.innerHTML = '<div class="sme-qs-book-row">出售中...</div>';
        try {
            await sellItem({ appid: data.appid, contextid: data.contextid, assetid: data.assetid, priceCents });
            toast('已上架: ' + (data.name || data.market_hash_name), 'success');
            if (statusEl) statusEl.innerHTML = '<div class="sme-qs-book-row sme-buy">上架成功，到手 ' + formatCents(priceCents) + '</div>';
            if (data.element) data.element.style.opacity = '0.4';
        } catch (e) {
            toast('上架失败: ' + friendlyError(e), 'error');
            if (statusEl) statusEl.innerHTML = prevHtml + '<div class="sme-qs-book-row" style="color:var(--sme-red)">失败: ' + escapeHtml(e.message) + '</div>';
            btns.forEach(b => b.disabled = false);
        }
    }

    /** 收集所有可出售物品 */
    function collectSellableItems(filterFn) {
        const els = getInventoryItemElements();
        const items = [];
        for (const el of els) {
            const data = getRgItemFromElement(el);
            if (!data || !isInvMarketable(data) || !data.market_hash_name) continue;
            if (filterFn && !filterFn(data)) continue;
            items.push({ element: el, data });
        }
        return items;
    }

    /** 收集重复物品（每种保留一件，出售其余） */
    function collectDuplicateItems() {
        const all = collectSellableItems();
        const seen = new Map();
        const result = [];
        for (const it of all) {
            const k = it.data.market_hash_name;
            const n = seen.get(k) || 0;
            if (n > 0) result.push(it); // 跳过首个，出售重复
            seen.set(k, n + 1);
        }
        return result;
    }

    /** 计算批量出售价格：优先用最低卖单到手价，回退到订单直方图最高买单，最终回退到物品类型最低价 */
    async function computeBatchSellPrice(data) {
        // 1. 优先使用价格概览 API（轻量，有缓存）
        try {
            const entry = await fetchInvPriceOverview(data.appid, data.market_hash_name);
            if (entry && entry.cents > 0) return Math.max(priceBeforeFees(entry.cents), 1);
        } catch (e) {}
        // 2. 回退到订单直方图（最高买单价 / 最低卖单价）
        try {
            const nameId = await fetchItemNameIdByListing(data.appid, data.market_hash_name);
            if (nameId) {
                const hist = await fetchOrderHistogram(nameId);
                // highestBuy/lowestSell 均为分（cents，含手续费），需 priceBeforeFees 转为卖家到手价
                if (hist.highestBuy) {
                    const buyCents = parseInt(hist.highestBuy, 10) || 0;
                    if (buyCents > 0) return Math.max(priceBeforeFees(buyCents), 1);
                }
                if (hist.lowestSell) {
                    const sellCents = parseInt(hist.lowestSell, 10) || 0;
                    if (sellCents > 0) return Math.max(priceBeforeFees(sellCents), 1);
                }
            }
        } catch (e) {
            W('Batch sell price fallback (order histogram) failed:', e.message);
        }
        // 3. 最终回退到物品类型最低价
        const info = getItemPriceInfo(data);
        return Math.max(Math.round(parseFloat(info.min) * 100), 1);
    }

    /** 根据定价模式计算批量出售到手价（1.4.5 新增） */
    async function computeBatchPrice(data, priceMode, customPriceCents) {
        let book = null;
        try {
            book = await fetchInventoryOrderBook(data.appid, data.market_hash_name);
        } catch (e) {}

        const lowestSellCents = book?.lowestSell || 0;
        const highestBuyCents = book?.highestBuy || 0;

        switch (priceMode) {
            case 'instant':
                if (highestBuyCents > 0) return Math.max(priceBeforeFees(highestBuyCents), 1);
                return await computeBatchSellPrice(data);
            case 'undercut':
                if (lowestSellCents > 0) return Math.max(priceBeforeFees(lowestSellCents) - 1, 1);
                return await computeBatchSellPrice(data);
            case 'match':
                if (lowestSellCents > 0) return Math.max(priceBeforeFees(lowestSellCents), 1);
                return await computeBatchSellPrice(data);
            case 'custom_buyer':
                if (customPriceCents > 0) return Math.max(priceBeforeFees(customPriceCents), 1);
                return await computeBatchSellPrice(data);
            case 'custom_received':
                return customPriceCents || 1;
            default:
                return await computeBatchSellPrice(data);
        }
    }

    /** 批量出售（带进度与限流重试，1.4.5 增加自定义定价支持） */
    async function batchSell(items, opLabel, priceMode, customPriceCents) {
        if (invBatchRunning) { toast('已有批量操作进行中', 'warning'); return; }
        if (!items || items.length === 0) { toast('没有符合条件的可出售物品', 'info'); return; }
        invBatchRunning = true;
        setBatchButtonsDisabled(true);
        let success = 0, fail = 0;
        updateInvProgress(0, items.length, opLabel + ': 准备出售 ' + items.length + ' 件...');
        for (let i = 0; i < items.length; i++) {
            const { data } = items[i];
            updateInvProgress(i, items.length, opLabel + ' (' + (i + 1) + '/' + items.length + '): ' + (data.name || data.market_hash_name));
            try {
                const price = priceMode && priceMode !== 'auto'
                    ? await computeBatchPrice(data, priceMode, customPriceCents)
                    : await computeBatchSellPrice(data);
                await sellItem({ appid: data.appid, contextid: data.contextid, assetid: data.assetid, priceCents: price, amount: data.amount || 1 });
                success++;
                if (data.element) data.element.style.opacity = '0.4';
            } catch (e) {
                fail++;
                if (isRetryMessage(e.message)) {
                    updateInvProgress(i, items.length, opLabel + ': 遇到限流，等待重试...');
                    await sleep(randInt(RETRY_BACKOFF_MIN, RETRY_BACKOFF_MAX));
                    try {
                        const price = priceMode && priceMode !== 'auto'
                            ? await computeBatchPrice(data, priceMode, customPriceCents)
                            : await computeBatchSellPrice(data);
                        await sellItem({ appid: data.appid, contextid: data.contextid, assetid: data.assetid, priceCents: price, amount: data.amount || 1 });
                        success++; fail--;
                        if (data.element) data.element.style.opacity = '0.4';
                    } catch (e2) {
                        W('Batch sell retry failed:', e2.message);
                    }
                } else {
                    W('Batch sell failed for', data.market_hash_name, e.message);
                }
            }
            await sleep(randInt(SELL_DELAY_MIN, SELL_DELAY_MAX));
        }
        updateInvProgress(items.length, items.length, opLabel + ' 完成: 成功 ' + success + ', 失败 ' + fail);
        toast(opLabel + '完成: 成功 ' + success + ', 失败 ' + fail, success > 0 ? 'success' : 'error');
        invBatchRunning = false;
        setBatchButtonsDisabled(false);
    }

    function onBatchSellAll() {
        if (invBatchRunning) { toast('已有批量操作进行中', 'warning'); return; }
        const items = collectSellableItems();
        if (items.length === 0) { toast('没有可出售的市场物品', 'info'); return; }
        showBatchSellDialog(items, '出售所有物品');
    }

    function onBatchSellDuplicates() {
        if (invBatchRunning) { toast('已有批量操作进行中', 'warning'); return; }
        const items = collectDuplicateItems();
        if (items.length === 0) { toast('没有重复物品可出售', 'info'); return; }
        showBatchSellDialog(items, '出售重复物品');
    }

    function onBatchSellCards() {
        if (invBatchRunning) { toast('已有批量操作进行中', 'warning'); return; }
        const items = collectSellableItems(isTradingCard);
        if (items.length === 0) { toast('没有可出售的卡牌', 'info'); return; }
        showBatchSellDialog(items, '出售所有卡牌');
    }

    function onBatchSellCrates() {
        if (invBatchRunning) { toast('已有批量操作进行中', 'warning'); return; }
        const items = collectSellableItems(isCrate);
        if (items.length === 0) { toast('没有可出售的箱子', 'info'); return; }
        showBatchSellDialog(items, '出售所有箱子');
    }

    /** 出售多个 — 跳转到 Steam 原生多件出售页（1.4.5 新增） */
    function onMultiSell() {
        const data = getActiveInvItem();
        if (!data) { toast('请先选择一个物品', 'warning'); return; }
        if (!data.appid || !data.contextid || !data.market_hash_name) {
            toast('当前物品信息不完整', 'warning'); return;
        }
        const url = 'https://steamcommunity.com/market/multisell?appid=' + data.appid +
            '&contextid=' + data.contextid +
            '&items%5B%5D=' + encodeURIComponent(data.market_hash_name);
        location.href = url;
    }

    /**
     * 批量出售定价浮窗（1.4.5 新增）
     * 所有批量出售操作执行前弹出，显示定价模式选择和价格输入
     * @param {Array} items - collectSellableItems 返回的物品数组
     * @param {string} opLabel - 操作标签
     */
    function showBatchSellDialog(items, opLabel) {
        if (invBatchRunning) { toast('已有批量操作进行中', 'warning'); return; }
        if (!items || items.length === 0) { toast('没有可出售的市场物品', 'info'); return; }

        const overlay = document.createElement('div');
        overlay.className = 'sme-dialog-overlay';

        const modeOptions = [
            {v:'match',         t:'匹配最低卖单（建议价）'},
            {v:'undercut',      t:'压价（最低卖-1分）'},
            {v:'instant',       t:'即时成交（最高买单）'},
            {v:'custom_buyer',  t:'自定义买家支付价'},
            {v:'custom_received', t:'自定义到手价（突破限制）'},
        ];

        const modeSelect = h('select', {class:'sme-batch-sell-select'}, []);
        modeOptions.forEach(o => modeSelect.appendChild(h('option', {value:o.v, text:o.t})));
        modeSelect.value = 'match';

        const priceInput = h('input', {class:'sme-batch-sell-input', type:'number', step:'0.01', min:'0', placeholder:'0.00'});
        const priceRow = h('div', {class:'sme-batch-sell-row sme-batch-price-row', style:{display:'none'}}, [
            h('label', {text:'到手价'}),
            priceInput,
        ]);
        const feeInfo = h('div', {class:'sme-qs-fee-info', style:{display:'none'}}, []);
        const warningEl = h('div', {class:'sme-qs-warning', style:{display:'none'}}, []);
        const summary = h('div', {class:'sme-batch-sell-summary'});

        const dialog = h('div', {class:'sme-dialog-box sme-batch-sell-dialog'}, [
            h('div', {class:'sme-dialog-header'}, [
                h('div', {class:'sme-dialog-title', text: opLabel + ' — 定价确认'}),
                h('button', {class:'sme-dialog-close', text:'×', onclick: () => overlay.remove()}),
            ]),
            h('div', {class:'sme-dialog-body'}, [
                h('div', {class:'sme-batch-sell-summary', html:'将对 <strong>' + items.length + '</strong> 件物品进行上架，请确认定价方式：'}),
                h('div', {class:'sme-batch-sell-row'}, [
                    h('label', {text:'定价模式'}),
                    modeSelect,
                ]),
                priceRow,
                feeInfo,
                warningEl,
                summary,
            ]),
            h('div', {class:'sme-dialog-footer'}, [
                h('button', {class:'sme-dialog-cancel', text:'取消', onclick: () => overlay.remove()}),
                h('button', {class:'sme-dialog-ok', text:'确认出售', onclick: () => {
                    const mode = modeSelect.value;
                    let customPriceCents = 0;
                    if (mode === 'custom_buyer' || mode === 'custom_received') {
                        const val = parseFloat(priceInput.value);
                        if (!val || val <= 0) { toast('请输入有效价格', 'warning'); return; }
                        customPriceCents = Math.round(val * 100);
                    }
                    overlay.remove();
                    batchSell(items, opLabel, mode, customPriceCents);
                }}),
            ]),
        ]);
        overlay.appendChild(dialog);
        document.body.appendChild(overlay);

        function onModeChange() {
            const mode = modeSelect.value;
            const isCustom = mode === 'custom_buyer' || mode === 'custom_received';
            priceRow.style.display = isCustom ? 'flex' : 'none';

            const label = priceRow.querySelector('label');
            if (mode === 'custom_buyer') label.textContent = '买家支付价';
            else if (mode === 'custom_received') label.textContent = '到手价';

            if (isCustom && !priceInput.value && items.length > 0) {
                fetchInventoryOrderBook(items[0].data.appid, items[0].data.market_hash_name).then(book => {
                    if (book.lowestSell > 0) {
                        const suggested = priceBeforeFees(book.lowestSell);
                        priceInput.value = (suggested / 100).toFixed(2);
                        updateFeeAndWarning();
                    }
                }).catch(() => {});
            }

            if (!isCustom) {
                const labels = {
                    'match': '每件物品按各自最低卖单到手价上架',
                    'undercut': '每件物品按各自最低卖单-1分到手价上架',
                    'instant': '每件物品按各自最高买单到手价即时成交',
                };
                summary.textContent = labels[mode] || '';
                feeInfo.style.display = 'none';
                warningEl.style.display = 'none';
            } else {
                updateFeeAndWarning();
            }
        }

        function updateFeeAndWarning() {
            const mode = modeSelect.value;
            if (mode !== 'custom_buyer' && mode !== 'custom_received') {
                feeInfo.style.display = 'none';
                warningEl.style.display = 'none';
                return;
            }
            const val = parseFloat(priceInput.value);
            if (!val || val <= 0) {
                feeInfo.style.display = 'none';
                warningEl.style.display = 'none';
                return;
            }
            let receivedCents;
            if (mode === 'custom_buyer') {
                receivedCents = Math.max(priceBeforeFees(Math.round(val * 100)), 1);
            } else {
                receivedCents = Math.round(val * 100);
            }
            const buyerCents = priceIncludingFees(receivedCents);
            feeInfo.style.display = 'block';
            feeInfo.innerHTML = '<span class="sme-qs-fee-buyer">买家支付: ' + formatCents(buyerCents) +
                '</span> × ' + items.length + ' 件 = <span class="sme-qs-fee-received">到手总计: ' +
                formatCents(receivedCents * items.length) + '</span>';
            summary.textContent = '所有物品统一以到手价 ' + formatCents(receivedCents) + ' 上架';
        }

        modeSelect.addEventListener('change', onModeChange);
        priceInput.addEventListener('input', updateFeeAndWarning);

        onModeChange();
    }

    /** 获取物品可转换的宝石数量（GET /ajaxgetgoovalue/） */
    async function getGooValue(data) {
        const url = `https://steamcommunity.com/ajaxgetgoovalue/?appid=${data.appid}&assetid=${data.assetid}&contextid=${data.contextid}`;
        const json = await doFetch(url);
        if (!json || !json.success) throw new Error((json && json.message) || '无法获取宝石价值');
        return parseInt(json.goo_value, 10) || 0;
    }

    /** 转换为宝石（POST /ajaxgrindintogoo/） */
    async function turnIntoGems(data, gooValue) {
        const sessionid = await resolveSessionId();
        if (!sessionid) throw new Error('无法获取 sessionid');
        const body = new URLSearchParams({
            sessionid,
            appid: String(data.appid),
            assetid: String(data.assetid),
            contextid: String(data.contextid),
            goo_value_expected: String(gooValue),
        });
        const json = await smeRequest('https://steamcommunity.com/ajaxgrindintogoo/', {
            method: 'POST',
            headers: { 'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8' },
            body: body.toString(),
        });
        if (!json || !json.success) throw new Error((json && json.message) || '转换宝石失败');
        return json;
    }

    /** 将当前选中物品转换为宝石 */
    async function turnSelectedIntoGems() {
        if (invBatchRunning) { toast('已有操作进行中', 'warning'); return; }
        const data = getActiveInvItem();
        if (!data) { toast('请先选择一个物品', 'warning'); return; }
        if (isGems(data)) { toast('该物品已经是宝石', 'info'); return; }
        invBatchRunning = true;
        setBatchButtonsDisabled(true);
        try {
            updateInvProgress(0, 1, '转换宝石中: ' + (data.name || data.market_hash_name));
            const goo = await getGooValue(data);
            await turnIntoGems(data, goo);
            updateInvProgress(1, 1, '转换成功: 获得 ' + goo + ' 颗宝石');
            toast('已转换为 ' + goo + ' 颗宝石', 'success');
            if (data.element) data.element.style.opacity = '0.4';
        } catch (e) {
            updateInvProgress(1, 1, '转换失败: ' + e.message);
            toast('转换为宝石失败: ' + friendlyError(e), 'error');
            W('Turn into gems failed:', e.message);
        } finally {
            invBatchRunning = false;
            setBatchButtonsDisabled(false);
        }
    }

    // ==================== 交易报价页 ====================
    let tradeObserver = null;
    let tradeLastSum = 0;

    /** 初始化多件出售页（1.4.5 新增：自动填充价格 + 定价模式增强） */
    function initMultisellPage() {
        L('Initializing multisell page...');
        const tryInit = (attempt) => {
            const inputs = document.querySelectorAll('.market_multi_price_recv');
            if (inputs.length > 0 || attempt >= 40) {
                setupMultisellEnhancer();
            } else {
                attempt++;
                setTimeout(() => tryInit(attempt), 500);
            }
        };
        tryInit(0);
    }

    function setupMultisellEnhancer() {
        const params = new URLSearchParams(location.search);
        const appid = params.get('appid');

        let gNameIds, gHashNames;
        try {
            gNameIds = unsafeWindow.g_rgItemNameIds || [];
            gHashNames = unsafeWindow.g_rgMarketHashNames || [];
        } catch (e) { L('Multisell globals not available:', e.message); return; }
        if (gNameIds.length === 0) { L('Multisell: no items found'); return; }

        const wi = getWalletInfo();
        let gCurrencyCode;
        try { gCurrencyCode = unsafeWindow.GetCurrencyCode(wi.wallet_currency); }
        catch (e) { gCurrencyCode = wi.currency_code || 'USD'; }

        const modeOptions = [
            {v:'match',       t:'匹配最低卖单（建议价）'},
            {v:'undercut',    t:'压价（最低卖-1分）'},
            {v:'custom_recv', t:'自定义到手价'},
            {v:'custom_paid', t:'自定义买家支付价'},
        ];

        const modeSelect = h('select', {class:'sme-ms-select'}, []);
        modeOptions.forEach(o => modeSelect.appendChild(h('option', {value:o.v, text:o.t})));
        modeSelect.value = 'match';

        const priceInput = h('input', {class:'sme-ms-price-input', type:'number', step:'0.01', min:'0', placeholder:'0.00'});
        const priceRow = h('div', {class:'sme-ms-price-row', style:{display:'none'}}, [
            h('span', {text:'价格:', style:{fontSize:'12px', color:'var(--sme-text-dim)'}}), priceInput,
        ]);
        const feeInfo = h('div', {class:'sme-ms-fee-info', style:{display:'none'}}, []);
        const statusEl = h('span', {class:'sme-ms-status', text:'准备就绪'});
        const applyBtn = h('button', {class:'sme-ms-apply-btn', type:'button', text:'应用全部'}, []);

        const panel = h('div', {class:'sme-ms-panel'}, [
            h('div', {class:'sme-ms-header'}, [
                h('span', {class:'sme-ms-title', text:'SME 定价增强'}),
                statusEl,
            ]),
            h('div', {class:'sme-ms-controls'}, [
                h('div', {class:'sme-ms-mode-row'}, [
                    h('span', {text:'定价模式:', style:{fontSize:'12px', color:'var(--sme-text-dim)'}}),
                    modeSelect,
                ]),
                priceRow,
                feeInfo,
                applyBtn,
            ]),
        ]);

        const mainContent = document.querySelector('#market_mutlisell_maincontent') || document.querySelector('.market_multisell');
        if (mainContent) {
            mainContent.insertBefore(panel, mainContent.firstChild);
        } else {
            document.body.insertBefore(panel, document.body.firstChild);
        }

        const itemPriceCache = new Map();

        async function fetchItemPrice(hashName) {
            if (itemPriceCache.has(hashName)) return itemPriceCache.get(hashName);
            try {
                const url = 'https://steamcommunity.com/market/priceoverview/?appid=' + appid +
                    '&market_hash_name=' + encodeURIComponent(hashName) + '&currency=' + wi.wallet_currency;
                const data = await doFetch(url);
                if (data && data.success && data.lowest_price) {
                    const cents = parsePriceToCents(data.lowest_price);
                    itemPriceCache.set(hashName, cents);
                    return cents;
                }
            } catch (e) { W('Price overview failed for', hashName, e.message); }
            itemPriceCache.set(hashName, 0);
            return 0;
        }

        function formatForInput(cents) {
            try { return unsafeWindow.v_currencyformat(cents, gCurrencyCode); }
            catch (e) { return (cents / 100).toFixed(2); }
        }

        function setItemPrice(nameId, receivedCents) {
            const input = document.querySelector('#sell_' + nameId + '_price_recv');
            if (!input) return;
            const formatted = formatForInput(receivedCents);
            try { unsafeWindow.$J(input).val(formatted).keyup(); }
            catch (e) {
                input.value = formatted;
                input.dispatchEvent(new Event('keyup', {bubbles: true}));
            }
        }

        function applyMode(mode, customCents) {
            for (let i = 0; i < gNameIds.length; i++) {
                const nameId = gNameIds[i];
                const hashName = gHashNames[i];
                const lowestSellCents = itemPriceCache.get(hashName) || 0;

                let receivedCents = 0;
                if (mode === 'match' && lowestSellCents > 0) {
                    receivedCents = Math.max(priceBeforeFees(lowestSellCents), 1);
                } else if (mode === 'undercut' && lowestSellCents > 0) {
                    receivedCents = Math.max(priceBeforeFees(lowestSellCents) - 1, 1);
                } else if (mode === 'custom_recv') {
                    receivedCents = customCents;
                } else if (mode === 'custom_paid') {
                    receivedCents = Math.max(priceBeforeFees(customCents), 1);
                }

                if (receivedCents > 0) setItemPrice(nameId, receivedCents);
            }
            try { unsafeWindow.UpdateOrderTotal(); } catch (e) {}
        }

        function onModeChange() {
            const mode = modeSelect.value;
            const isCustom = mode === 'custom_recv' || mode === 'custom_paid';
            priceRow.style.display = isCustom ? 'flex' : 'none';
            priceInput.placeholder = mode === 'custom_recv' ? '到手价(元)' : '买家支付价(元)';
            feeInfo.style.display = 'none';
        }

        function onApply() {
            const mode = modeSelect.value;
            let customCents = 0;
            if (mode === 'custom_recv' || mode === 'custom_paid') {
                const val = parseFloat(priceInput.value);
                if (!val || val <= 0) { statusEl.textContent = '请输入有效价格'; return; }
                customCents = Math.round(val * 100);
                feeInfo.style.display = 'block';
                let received, buyer;
                if (mode === 'custom_recv') {
                    received = customCents;
                    buyer = priceIncludingFees(customCents);
                } else {
                    buyer = customCents;
                    received = Math.max(priceBeforeFees(customCents), 1);
                }
                feeInfo.innerHTML = '买家支付: ' + formatCents(buyer) + ' | 到手: ' + formatCents(received) + '/件';
                applyMode(mode, customCents);
            } else {
                applyMode(mode, 0);
            }
            statusEl.textContent = '已应用: ' + modeOptions.find(o => o.v === mode).t;
        }

        modeSelect.addEventListener('change', onModeChange);
        applyBtn.addEventListener('click', onApply);

        statusEl.textContent = '正在获取价格...';
        const promises = gHashNames.map(name => fetchItemPrice(name));
        Promise.all(promises).then(prices => {
            const valid = prices.filter(p => p > 0).length;
            if (valid > 0) {
                applyMode('match', 0);
                statusEl.textContent = '已自动填充匹配价格（' + valid + '件）';
            } else {
                statusEl.textContent = '未能获取价格，请手动输入';
            }
        });
    }

    /** 初始化交易报价页 */
    function initTradeOfferPage() {
        L('Initializing trade offer page');
        if (!settings.get('tradeOfferSummary')) return;

        // 等待交易报价 DOM 加载
        const tryInit = (attempt) => {
            const tradeBox = document.querySelector('.trade_item_box');
            if (tradeBox) {
                setupTradeObserver();
                injectSelectAllButton();
                setTimeout(updateTradeOfferSummary, 1000);
            } else if (attempt < 30) {
                setTimeout(() => tryInit(attempt + 1), 500);
            }
        };
        tryInit(0);
    }

    /** 设置 MutationObserver 监听交易框变化 */
    function setupTradeObserver() {
        if (tradeObserver) tradeObserver.disconnect();
        tradeObserver = new MutationObserver(() => {
            setTimeout(updateTradeOfferSummary, 300);
        });
        // 监听双方交易框
        const boxes = document.querySelectorAll('.trade_item_box');
        boxes.forEach(box => {
            tradeObserver.observe(box, { childList: true, subtree: true });
        });
        L('Trade observer set up on', boxes.length, 'boxes');
    }

    /** 检查所有交易物品是否已加载 */
    function hasLoadedAllTradeOfferItems() {
        try {
            const status = unsafeWindow.g_rgCurrentTradeStatus;
            if (!status) return false;
            const checkSide = (user, assets) => {
                if (!assets || !user) return true;
                for (const a of assets) {
                    const item = user.findAsset(a.appid, a.contextid, a.assetid);
                    if (!item) return false;
                }
                return true;
            };
            return checkSide(unsafeWindow.UserYou, status.me?.assets)
                && checkSide(unsafeWindow.UserThem, status.them?.assets);
        } catch (e) {
            return false;
        }
    }

    /**
     * 汇总交易一方的物品
     * @param {Array} assets - 资产数组
     * @param {Object} user - UserYou 或 UserThem
     * @returns {{text: string, totalPrice: number, uniqueCount: number, totalCount: number}}
     */
    function sumTradeOfferAssets(assets, user) {
        const grouped = {};
        let totalPrice = 0;
        let totalCount = 0;

        if (!assets || !user) return { text: '', totalPrice: 0, uniqueCount: 0, totalCount: 0 };

        for (const asset of assets) {
            let text = '';
            try {
                const rgItem = user.findAsset(asset.appid, asset.contextid, asset.assetid);
                if (rgItem) {
                    // 从 DOM 读取价格标签（库存页设置的 price_ class）
                    if (rgItem.element) {
                        const priceEl = rgItem.element.querySelector('[class*="price_"]');
                        if (priceEl) {
                            const cls = priceEl.className || '';
                            const m = cls.match(/price_(\d+)/);
                            if (m) totalPrice += parseInt(m[1], 10);
                        }
                    }
                    // 处理堆叠物品的已用数量
                    if (rgItem.original_amount != null && rgItem.amount != null) {
                        const used = parseInt(rgItem.original_amount) - parseInt(rgItem.amount);
                        if (used > 0) text += `${used}x `;
                    }
                    text += rgItem.name || rgItem.market_hash_name || '未知物品';
                    if (rgItem.type && rgItem.type.length > 0) {
                        text += ` (${rgItem.type})`;
                    }
                } else {
                    text = '未知物品';
                }
            } catch (e) {
                text = '未知物品';
            }
            grouped[text] = (grouped[text] || 0) + 1;
            totalCount++;
        }

        // 按数量降序排序
        const sorted = Object.entries(grouped).sort((a, b) => b[1] - a[1]);
        let text = `<strong>唯一物品：${sorted.length} · 总价值：${formatCents(totalPrice)} · 物品总数：${totalCount}</strong><br/><br/>`;
        for (const [name, count] of sorted) {
            text += `${count}x ${name}<br/>`;
        }
        return { text, totalPrice, uniqueCount: sorted.length, totalCount };
    }

    /** 更新交易报价双方摘要 */
    function updateTradeOfferSummary() {
        try {
            if (!hasLoadedAllTradeOfferItems()) return;

            const status = unsafeWindow.g_rgCurrentTradeStatus;
            if (!status) return;

            const currentSum = (status.me?.assets?.length || 0) + (status.them?.assets?.length || 0);
            if (currentSum === tradeLastSum) return; // 无变化
            tradeLastSum = currentSum;

            // 你的物品摘要
            const yourSum = sumTradeOfferAssets(status.me?.assets, unsafeWindow.UserYou);
            const yourEl = document.querySelector('#trade_offer_your_sum');
            if (yourEl) yourEl.remove();
            if (yourSum.text) {
                const yourHeader = document.querySelector('.offerheader.left') || document.querySelector('#trade_offer_your');
                if (yourHeader) {
                    const el = h('div', { id: 'trade_offer_your_sum', class: 'sme-trade-summary', html: yourSum.text });
                    yourHeader.appendChild(el);
                }
            }

            // 对方物品摘要
            const theirSum = sumTradeOfferAssets(status.them?.assets, unsafeWindow.UserThem);
            const theirEl = document.querySelector('#trade_offer_their_sum');
            if (theirEl) theirEl.remove();
            if (theirSum.text) {
                const theirHeader = document.querySelector('.offerheader.right') || document.querySelector('#trade_offer_their');
                if (theirHeader) {
                    const el = h('div', { id: 'trade_offer_their_sum', class: 'sme-trade-summary', html: theirSum.text });
                    theirHeader.appendChild(el);
                }
            }

            // 价值对比提示
            if (yourSum.totalPrice > 0 || theirSum.totalPrice > 0) {
                const diff = yourSum.totalPrice - theirSum.totalPrice;
                let diffText = '';
                if (diff > 0) {
                    diffText = `你多付 ${formatCents(diff)}`;
                } else if (diff < 0) {
                    diffText = `对方多付 ${formatCents(-diff)}`;
                } else {
                    diffText = '双方价值相等';
                }
                const diffEl = document.querySelector('#trade_offer_diff');
                if (diffEl) diffEl.remove();
                const yourSumEl = document.querySelector('#trade_offer_your_sum');
                if (yourSumEl) {
                    yourSumEl.appendChild(h('div', {
                        id: 'trade_offer_diff',
                        style: { marginTop: '6px', fontSize: '13px', fontWeight: '700', color: diff > 0 ? 'var(--sme-red)' : (diff < 0 ? 'var(--sme-green)' : 'var(--sme-blue)') },
                        text: diffText,
                    }));
                }
            }
        } catch (e) {
            W('Trade offer summary error:', e.message);
        }
    }

    /** 注入"选中页面全部物品"按钮 */
    function injectSelectAllButton() {
        if (document.querySelector('#sme_select_all_page')) return;

        // 查找库存区域底部
        const inventoryPage = document.querySelector('.inventory_page_tabs') || document.querySelector('.inventory_ctn');
        if (!inventoryPage) return;

        // 检查是否为还价场景（需先点击"修改报价"）
        const modifyBtn = document.querySelector('.modify_offer_btn');
        if (modifyBtn && modifyBtn.offsetParent !== null) {
            // 还价场景，暂不注入
            return;
        }

        const btn = h('a', {
            id: 'sme_select_all_page',
            class: 'sme-trade-btn',
            html: ICONS.selectAll + ' 选中页面全部物品',
            onClick: selectAllItemsOnPage,
        });

        // 插入到库存页控制区域
        const pageControl = document.querySelector('#inventory_pagecontrols');
        if (pageControl) {
            pageControl.parentElement.insertBefore(btn, pageControl.nextSibling);
        } else {
            inventoryPage.parentElement.insertBefore(btn, inventoryPage);
        }
    }

    /** 选中当前可见库存页的所有可交易物品并移入交易 */
    function selectAllItemsOnPage() {
        try {
            const holders = document.querySelectorAll('.inventory_ctn:visible > .inventory_page:visible > .itemHolder:visible, .inventory_ctn > .inventory_page:not([style*="none"]) > .itemHolder:not([style*="none"])');
            let count = 0;
            const items = [];
            holders.forEach(holder => {
                const itemEl = holder.querySelector('.item');
                if (!itemEl) return;
                const rgItem = itemEl.rgItem || getRgItemFromElement(itemEl);
                if (!rgItem) return;
                if (rgItem.is_stackable) return;
                if (!rgItem.tradable) return;
                items.push(holder);
            });

            if (items.length === 0) {
                toast('当前页面无可交易物品', 'info');
                return;
            }

            toast(`正在移入 ${items.length} 个物品...`, 'info');

            // 逐个移入（250ms 间隔）
            let idx = 0;
            const moveNext = () => {
                if (idx >= items.length) {
                    toast(`已移入 ${count} 个物品`, 'success');
                    return;
                }
                const holder = items[idx++];
                try {
                    if (unsafeWindow.MoveItemToTrade) {
                        unsafeWindow.MoveItemToTrade(holder);
                        count++;
                    }
                } catch (e) {}
                setTimeout(moveNext, 250);
            };
            moveNext();
        } catch (e) {
            toast('选中全部物品失败: ' + friendlyError(e), 'error');
        }
    }

    // ==================== v1.4.6 我的挂单市场顺序跟踪（新版 React 市场页） ====================
    // 原理：新版市场物品页为 React SSR，数据内嵌于 window.SSR.renderContext（React Query
    // dehydrated state，market_item_search 查询含 listings 数组与 bMine 标识）。服务端支持
    // ?start=N 分页参数（默认价格升序，每页 20 条），因此可通过同源 fetch 重新请求页面 HTML
    // 并解析 renderContext，枚举全部挂单、定位 bMine=true 的本人挂单，得到精确的市场顺序
    // （1-based）。再按设定间隔对本人排名附近页窗口探测刷新，跟踪售出导致的顺序变化。
    // 注意：orderbook 阶梯（rgCompactSellOrders）是价格聚合数据且可能属于其它磨损变体，
    // 不能用于精确排名，必须基于 listings 枚举。

    const MR_PAGE_SIZE = 20;
    const MR_MAX_SCAN_PAGES = 100;      // 全量扫描页数上限（2000 条）
    const MR_PROBE_MAX_PAGES = 12;      // v1.4.8：单轮探测请求页数上限（挂单过多时按排名优先保留）
    const MR_MIN_GAP = 1100;            // v1.4.8：相邻请求最小间隔（ms），限速器强制执行
    const MR_RATE_MAX = 18;             // v1.4.8：时间窗内最大请求数（与页面自身请求共享会话限流配额，需保守）
    const MR_RATE_WINDOW = 62000;       // v1.4.8：限速时间窗（ms）
    const MR_COOLDOWN_429 = 60000;      // v1.4.8：收到 429 后的全局冷却时长（ms）
    const MR_MIN_INTERVAL = 30;         // 最小刷新间隔（秒）
    const MR_MAX_INTERVAL = 600;        // 最大刷新间隔（秒）
    const MR_BACKOFF_MAX_POW = 5;       // 连续失败退避上限 2^5=32 倍
    const MR_MY_MARKER_RE = /（\s*我的上架物品\s*）|\(\s*my\s+listings?\s*\)/i;
    const MR_SECTION_RE = /我的上架物品|my\s+listings?/i;
    const MR_CACHE_TTL = 10 * 60 * 1000; // v1.5.0：MR 排名缓存有效期（与 ORDER_BOOK TTL 对齐）

    // v1.4.8：全局限速器。此前扫描 650ms/探测 400ms 一档且探测页数随挂单数无上限增长，
    // 挂单多的物品几分钟内发出上百个带登录态的整页请求，极易触发 Steam 市场限流，
    // 页面自身的 React Query 数据请求同会话被殃及，表现为在售列表"几秒后消失、无法加载"。
    let mrCoolUntil = 0;                // 429 冷却截止时间

    // v1.5.1 P1-A 深化：时间窗收敛为统一调度器通道（策略不变：最小间隔 + 18 次/62s 窗口）
    const smeChMr = new SmeRateChannel('MR', { gapBefore: MR_MIN_GAP, window: MR_RATE_WINDOW, max: MR_RATE_MAX });

    /** 获取一个请求名额（429 冷却 + 通道窗口 + 全局窗口）；任务作废时返回 false */
    async function mrAcquireSlot(gen) {
        for (;;) {
            if (gen !== mrState.gen) return false;
            const now = Date.now();
            if (now < mrCoolUntil) { await sleep(Math.min(15000, mrCoolUntil - now)); continue; }
            const ok = await smeChMr.acquire(() => gen === mrState.gen);
            return ok === true;
        }
    }

    const mrState = {
        gen: 0,                 // 代数计数器：URL 变化/清理后自增，旧任务自动作废
        active: false,
        running: false,         // 一次扫描/探测周期进行中
        paused: false,
        phase: 'init',          // init|scanning|ok|none|error
        mine: [],               // [{id, cents, rank, tieCount}]
        total: 0,
        currency: 0,            // eCurrency（来自 listing）
        lastUpdate: 0,
        failStreak: 0,
        changeNote: '',
        abortCtrl: null,
        timer: null,            // 下一轮刷新 setTimeout
        countdown: 0,
        countdownTimer: null,
        panelEl: null,
        body: null, foot: null, rowsEl: null, noteEl: null, statusEl: null,
        observer: null,
        cardSeen: new WeakSet(),
        rowSeen: new WeakSet(),
        url: '',
        scanPagesDone: 0,
    };

    /** 解析 fetch 回来的 HTML 中的 renderContext（双重 JSON.parse，与浏览器行为一致）。
        v1.4.8：indexOf 跳跃式定位结束引号，替代逐字符拼接（热门物品整页 HTML 可达数 MB，
        逐字符循环占主线程数十 ms/页，扫描上百页时明显卡顿）；顺带修正连续偶数反斜杠后
        引号的转义判定 */
    function mrParseRenderContext(htmlText) {
        try {
            // ★ v2.0.0：Steam 新版市场页的 SSR 数据容器是 <script id="valve-ssr-data">，
            //   页面内联脚本读它后 remove()，再赋值 window.SSR={...}。
            //   旧标记 'window.SSR.renderContext=JSON.parse("' 已**彻底消失**
            //   （实测当前市场页出现次数 = 0）→ 旧实现必然返回 null → 分页解析全废，
            //   市场顺序跟踪只能看到首页 20 条，1683 条挂单的排名严重失真。
            // 现在走纯计算层的统一解析；旧格式仅作极老页面的兜底。
            const parsedSsr = smeParseValveSsr(htmlText);
            if (parsedSsr && parsedSsr.renderContext) return parsedSsr.renderContext;
            const marker = 'window.SSR.renderContext=JSON.parse("';
            const idx = htmlText.indexOf(marker);
            if (idx < 0) return null;
            const begin = idx + marker.length;
            let end = begin, q = -1;
            while ((q = htmlText.indexOf('"', end)) !== -1) {
                let bs = 0, p = q - 1;
                while (p >= 0 && htmlText[p] === '\\') { bs++; p--; }
                if (bs % 2 === 0) break;
                end = q + 1;
            }
            if (q < 0) return null;
            return JSON.parse(JSON.parse('"' + htmlText.slice(begin, q) + '"'));
        } catch (e) { return null; }
    }

    /** 从 renderContext 对象中提取 market_item_search 的 page0（normalized） */
    function mrGetPageFromRC(rcObj) {
        try {
            let qd = null;
            if (rcObj && typeof rcObj.queryData === 'string') qd = JSON.parse(rcObj.queryData);
            else if (rcObj && Array.isArray(rcObj.queries)) qd = rcObj;
            if (!qd || !Array.isArray(qd.queries)) return null;
            for (const q of qd.queries) {
                if (q && q.queryKey && q.queryKey[0] === 'market_item_search'
                    && q.state && q.state.data && Array.isArray(q.state.data.pages) && q.state.data.pages.length) {
                    const p = q.state.data.pages[q.state.data.pages.length - 1];
                    return {
                        start: p.start || 0,
                        total: p.total_count || 0,
                        listings: (p.listings || []).map(l => ({
                            id: String(l.listingid || ''),
                            cents: l.unPrice | 0,
                            bMine: l.bMine === true,
                        })),
                        currency: (p.listings && p.listings[0] && p.listings[0].eCurrency) || 0,
                    };
                }
            }
        } catch (e) {}
        return null;
    }

    /** 构造分页请求 URL：仅保留语言参数 + start（剥离筛选/排序，强制默认价格升序） */
    function mrBuildUrl(start) {
        let lang = '';
        try { lang = new URLSearchParams(location.search).get('l') || ''; } catch (e) {}
        const params = [];
        if (lang) params.push('l=' + encodeURIComponent(lang));
        params.push('start=' + start);
        return location.origin + location.pathname + '?' + params.join('&');
    }

    /** 同源请求一页市场列表（HTML → renderContext → normalized page）。
        v1.4.8：请求前经全局限速器获取名额（gen 作废时抛错由外层 gen 检查吞掉）；
        收到 429 立即进入全局冷却并中止本轮，避免继续加重限流殃及页面自身请求 */
    async function mrFetchPage(start, gen) {
        if (!await mrAcquireSlot(gen)) throw new Error('MR 任务已作废');
        const ctrl = new AbortController();
        mrState.abortCtrl = ctrl;
        let text;
        try {
            text = await smeRequest(mrBuildUrl(start), { cache: 'no-store', signal: ctrl.signal, expect: 'text' });
        } catch (e) {
            if (e && e.code === SME_ERR.RATE_LIMITED) {
                mrCoolUntil = Date.now() + MR_COOLDOWN_429;
                smeChMr.reset();
                throw new Error('RateLimited（Steam 限流，已进入 60s 冷却）');
            }
            throw e;
        }
        const page = mrGetPageFromRC(mrParseRenderContext(text));
        if (!page) throw new Error('页面数据解析失败');
        return page;
    }

    /** 当前文档的 SSR renderContext（已是对象） → page0 */
    function mrCurrentDocPage() {
        try {
            const rc = unsafeWindow.SSR && unsafeWindow.SSR.renderContext;
            if (!rc) return null;
            return mrGetPageFromRC(rc);
        } catch (e) { return null; }
    }

    /** 读取页面上"出售 - 我的上架物品"表格中各行价格（分），用于二分定位加速 */
    function mrFindMyListingsSection() {
        for (const h2 of document.querySelectorAll('h2')) {
            const t = h2.textContent || '';
            if (MR_SECTION_RE.test(t)) {
                let el = h2.parentElement;
                for (let i = 0; i < 4 && el; i++) {
                    const btns = el.querySelectorAll('button');
                    if (btns.length >= 1 && btns.length <= 30) return el;
                    el = el.parentElement;
                }
                return h2.parentElement;
            }
        }
        return null;
    }

    function mrGetMyTableRows() {
        const rows = [];
        const section = mrFindMyListingsSection();
        if (!section) return rows;
        for (const btn of section.querySelectorAll('button')) {
            const t = (btn.textContent || '').trim();
            if (t === '取消' || t === '移除' || t === 'Remove' || /^cancel/i.test(t)) {
                const row = btn.closest('[style*="--grid-column: 1 / -1"]');
                if (row && rows.indexOf(row) === -1) rows.push(row);
            }
        }
        return rows;
    }

    function mrParseRowPriceCents(row) {
        // 数据行子元素顺序：名称 | 上架日期 | 价格 | 操作；价格格含总价 div + 到手 span
        const cells = row.children;
        for (let i = Math.min(2, cells.length - 1); i >= 1; i--) {
            const c = cells[i];
            if (!c) continue;
            const txt = (c.textContent || '').trim();
            if (/[\d]/.test(txt) && !/^\d{4}\/\d{1,2}\/\d{1,2}/.test(txt)) {
                const cents = parsePriceToCents(txt);
                if (cents > 0) return cents;
            }
        }
        return 0;
    }

    /** 计算 tie：同价格档位内位于本人之前/之后的数量（用于显示区间提示） */
    function mrComputeTies(allListings, mineMap) {
        // allListings: [{id,cents,bMine}] 全量有序数组
        const tieCount = new Map(); // cents → qty
        for (const l of allListings) {
            if (mineMap.has(l.id)) tieCount.set(l.cents, (tieCount.get(l.cents) || 0) + 1);
        }
        for (const m of mineMap.values()) {
            m.tieCount = tieCount.get(m.cents) || 1;
        }
    }

    /** 持久化最近一次结果（跨访问即时回显） */
    function mrSaveCache() {
        try {
            smeKv.set('sme_mr_' + location.pathname, JSON.stringify({
                ts: Date.now(),
                total: mrState.total,
                currency: mrState.currency,
                mine: mrState.mine.map(m => ({ id: m.id, cents: m.cents, rank: m.rank, tieCount: m.tieCount })),
            }));
        } catch (e) {}
    }

    function mrLoadCache() {
        try {
            const raw = smeKv.getSync('sme_mr_' + location.pathname, null);
            if (!raw) return null;
            const d = JSON.parse(raw);
            if (!d || !Array.isArray(d.mine) || d.mine.length === 0) return null;
            // v1.5.0: 补 TTL 校验。原实现读到 ts 从不与当前时间比较，
            // 导致过期排名数据永久回显、用户误认为是最新结果。
            if (typeof d.ts !== 'number' || Date.now() - d.ts > MR_CACHE_TTL) {
                smeKv.remove('sme_mr_' + location.pathname).catch(() => {});
                return null;
            }
            return d;
        } catch (e) { return null; }
    }

    // ---- UI：浮动状态面板 ----
    function mrFindFilterContainer() {
        // 查找"重置搜索"按钮所在的筛选容器（用于将市场顺序面板插入到其下方）
        const resetBtn = Array.from(document.querySelectorAll('button')).find(b =>
            b.textContent.trim() === '重置搜索'
        );
        if (resetBtn) {
            // 找到包含重置按钮的容器行（Psv8L3U3Y44- 类名或其父容器）
            let el = resetBtn.parentElement;
            for (let i = 0; i < 4 && el && el !== document.body; i++) {
                const style = getComputedStyle(el);
                // 找到最外层的 sticky 容器，我们要插入到其内部底部
                if (style.position === 'sticky' || el.style.getPropertyValue('--position') === 'sticky') {
                    return { container: el, mode: 'inside' };
                }
                el = el.parentElement;
            }
            // 如果没找到 sticky 容器，返回按钮的父行容器
            return { container: resetBtn.parentElement, mode: 'after' };
        }
        // 回退：用标题查找
        const xpath = "//*[contains(text(),'筛选上架物品')]";
        const result = document.evaluate(xpath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
        const titleEl = result.singleNodeValue;
        if (!titleEl) return null;
        let el = titleEl;
        for (let i = 0; i < 6 && el && el !== document.body; i++) {
            const style = getComputedStyle(el);
            if (style.position === 'sticky' || el.style.getPropertyValue('--position') === 'sticky') {
                return { container: el, mode: 'inside' };
            }
            el = el.parentElement;
        }
        return { container: titleEl.parentElement?.parentElement || null, mode: 'after' };
    }

    function mrEnsurePanel() {
        if (mrState.panelEl && document.body.contains(mrState.panelEl)) return;
        const panel = h('div', { class: 'sme-mr-panel', id: 'sme-mr-panel' });
        const head = h('div', { class: 'sme-mr-head', title: '点击折叠/展开' }, [
            h('span', { class: 'sme-mr-dot', id: 'sme-mr-dot' }),
            h('span', { class: 'sme-mr-head-title', text: '我的市场顺序' }),
            h('span', { class: 'sme-mr-collapse-hint', text: '▾', style: { color: 'var(--sme-text-dim)', fontSize: '10px' } }),
        ]);
        const body = h('div', { class: 'sme-mr-body', id: 'sme-mr-body' });
        const foot = h('div', { class: 'sme-mr-foot' });
        panel.appendChild(head);
        panel.appendChild(body);
        panel.appendChild(foot);
        head.addEventListener('click', () => {
            panel.classList.toggle('collapsed');
            body.style.display = panel.classList.contains('collapsed') ? 'none' : '';
        });

        // v1.4.9：尝试嵌入到"筛选上架物品"侧边栏内部（重置搜索下方），找不到则回退到右下角浮动
        const filterInfo = mrFindFilterContainer();
        if (filterInfo && filterInfo.container) {
            panel.classList.add('sme-mr-inline');
            if (filterInfo.mode === 'inside') {
                // 插入到筛选容器内部末尾
                filterInfo.container.appendChild(panel);
            } else {
                // 插入到重置搜索按钮行的下方
                filterInfo.container.parentNode.insertBefore(panel, filterInfo.container.nextSibling);
            }
        } else {
            document.body.appendChild(panel);
        }
        mrState.panelEl = panel;
        mrState.body = body;
        mrState.foot = foot;
    }

    function mrFormatPrice(cents) {
        return formatCentsStr(cents, mrState.currency || undefined);
    }

    function mrRenderPanel() {
        const panel = mrState.panelEl;
        if (!panel) return;
        const body = mrState.body;
        const hasMine = !!(mrState.mine && mrState.mine.length);
        // v2.2.5：本人没有在售物品（phase=none）、本轮解析失败，或 ok 却没有本人挂单时，
        // 整个浮窗都不显示 —— 不再摆一条「未在此物品发现您的上架物品 / 共 N 件在售」的提示。
        const hidden = mrState.phase === 'error'
            || mrState.phase === 'none'
            || (mrState.phase === 'ok' && !hasMine);
        if (hidden || !body) {
            panel.style.display = 'none';
            positionAnalysisFab();
            return;
        }
        panel.style.display = '';
        positionAnalysisFab();
        body.innerHTML = '';
        const dot = document.getElementById('sme-mr-dot');
        if (dot) {
            dot.className = 'sme-mr-dot ' + (mrState.phase === 'ok' ? 'ok' : mrState.phase === 'scanning' ? 'scanning' : mrState.phase === 'error' ? 'error' : '');
        }

        if (mrState.phase === 'init' || mrState.phase === 'scanning') {
            body.appendChild(h('div', { class: 'sme-mr-note', text: mrState.phase === 'init'
                ? '正在初始化市场数据…'
                : `正在扫描市场顺序… ${mrState.scanPagesDone}/${Math.ceil(mrState.total / MR_PAGE_SIZE) || '?'} 页` }));
            body.appendChild(h('div', { class: 'sme-mr-note', text: `共 ${mrState.total.toLocaleString()} 件在售（价格从低到高）` }));
            return;
        }
        // phase === 'ok'（此时 hasMine 必为真，其余分支已在函数开头隐藏浮窗）
        const sorted = [...mrState.mine].sort((a, b) => a.rank - b.rank);
        const front = sorted[0];
        const main = h('div', { class: 'sme-mr-main' });
        const rankWrap = h('div', { style: { display: 'flex', flexDirection: 'column', gap: '2px' } }, [
            h('div', { class: 'sme-mr-rank-label', text: '我的排名' }),
            h('div', { style: { display: 'flex', alignItems: 'baseline', gap: '6px' } }, [
                h('span', { class: 'sme-mr-rank-big', id: 'sme-mr-rank-big', text: '#' + front.rank.toLocaleString() }),
                h('span', { class: 'sme-mr-total', text: `/ ${mrState.total.toLocaleString()} 件` }),
            ]),
        ]);
        main.appendChild(rankWrap);
        body.appendChild(main);
        body.appendChild(h('div', { class: 'sme-mr-note', text: `${mrFormatPrice(front.cents)}${front.tieCount > 1 ? `（同级 ${front.tieCount} 件）` : ''} · 按价格从低到高` }));

        if (sorted.length > 1) {
            const rows = h('div', { class: 'sme-mr-rows' });
            sorted.forEach((m, i) => {
                rows.appendChild(h('div', { class: 'sme-mr-row' + (i === 0 ? ' front' : '') }, [
                    h('span', { class: 'rk', text: '#' + m.rank.toLocaleString() }),
                    h('span', { class: 'pr', text: mrFormatPrice(m.cents) }),
                    h('span', { class: 'lid', text: m.id.slice(-6), title: '挂单ID ' + m.id }),
                ]));
            });
            body.appendChild(rows);
        }
        if (mrState.changeNote) {
            body.appendChild(h('div', { class: 'sme-mr-changenote', text: mrState.changeNote }));
        }

        // footer
        const foot = mrState.foot;
        if (!foot) return;
        foot.innerHTML = '';
        const t = new Date(mrState.lastUpdate);
        foot.appendChild(h('span', { text: `${String(t.getHours()).padStart(2, '0')}:${String(t.getMinutes()).padStart(2, '0')}:${String(t.getSeconds()).padStart(2, '0')} 更新`, style: { flex: '1' } }));
        foot.appendChild(h('button', { class: 'sme-mr-btn', text: '立即刷新', onClick: mrManualRefresh }));
        const pauseBtn = h('button', { class: 'sme-mr-btn', text: mrState.paused ? '继续' : '暂停', onClick: mrTogglePause });
        foot.appendChild(pauseBtn);
        if (mrState.paused) {
            foot.appendChild(h('span', { text: '已暂停', style: { color: '#e0b05a' } }));
        } else if (mrState.countdown > 0) {
            foot.appendChild(h('span', { id: 'sme-mr-countdown', text: `${mrState.countdown}s` }));
        }
    }

    function mrTogglePause() {
        mrState.paused = !mrState.paused;
        if (mrState.paused) {
            clearTimeout(mrState.timer);
            mrState.timer = null;
            mrState.countdown = 0;
        } else {
            mrScheduleNext(3);
        }
        mrRenderPanel();
    }

    function mrManualRefresh() {
        if (mrState.running) return;
        mrState.paused = false;
        clearTimeout(mrState.timer);
        mrState.gen++;
        mrRunCycle(mrState.gen);
    }

    function mrScheduleNext(delaySec) {
        clearTimeout(mrState.timer);
        if (!mrState.active || mrState.paused || !settings.get('rankAutoRefresh')) return;
        let interval = Math.min(MR_MAX_INTERVAL, Math.max(MR_MIN_INTERVAL, settings.get('rankRefreshInterval') || 60));
        if (mrState.failStreak > 0) interval = Math.min(MR_MAX_INTERVAL * 8, interval * Math.pow(2, Math.min(mrState.failStreak, MR_BACKOFF_MAX_POW)));
        const delay = (delaySec != null ? delaySec : interval) * 1000 + Math.floor(Math.random() * 3000);
        mrState.countdown = Math.round(delay / 1000);
        mrState.timer = setTimeout(() => {
            if (mrState.paused) return;
            if (document.visibilityState === 'hidden') {
                // 页面隐藏时跳过本轮，可见后立即刷新
                mrState.countdown = 10;
                mrState.timer = setTimeout(() => mrRunCycle(mrState.gen), 10000);
                return;
            }
            mrRunCycle(mrState.gen);
        }, delay);
    }

    function mrStartCountdown() {
        clearInterval(mrState.countdownTimer);
        mrState.countdownTimer = setInterval(() => {
            if (!mrState.active || mrState.paused) return;
            if (mrState.countdown > 0) mrState.countdown--;
            const el = document.getElementById('sme-mr-countdown');
            if (el) el.textContent = mrState.countdown + 's';
            else {
                // footer 被重渲染时补回倒计时
                const foot = mrState.foot;
                if (foot && mrState.phase === 'ok' && !mrState.paused && mrState.countdown > 0 && !document.getElementById('sme-mr-countdown')) {
                    foot.appendChild(h('span', { id: 'sme-mr-countdown', text: mrState.countdown + 's' }));
                }
            }
        }, 1000);
    }

    // ---- 排名计算 ----

    /** 全量顺序扫描：从 start=0 枚举所有页，收集 bMine 挂单及精确排名 */
    async function mrScanAll(gen) {
        const page0 = mrCurrentDocPage();
        let total = page0 ? page0.total : 0;
        let currency = page0 ? page0.currency : 0;
        const all = [];
        const mineMap = new Map();
        let pages = 0;
        mrState.scanPagesDone = 0;
        // 页数上限动态计算：page0 不可用时 total=0，首页拉取后才能确定真实页数
        while (pages < Math.max(1, Math.min(MR_MAX_SCAN_PAGES, Math.ceil(total / MR_PAGE_SIZE)))) {
            if (gen !== mrState.gen) return null;
            const start = pages * MR_PAGE_SIZE;
            let page;
            if (pages === 0 && page0 && page0.start === 0) {
                page = page0; // 当前文档 SSR 即第 0 页，零请求
            } else {
                page = await mrFetchPage(start, gen); // 间隔由全局限速器控制
            }
            total = page.total || total;
            currency = page.currency || currency;
            for (let i = 0; i < page.listings.length; i++) {
                const l = page.listings[i];
                all.push(l);
                if (l.bMine && l.id) {
                    mineMap.set(l.id, { id: l.id, cents: l.cents, rank: start + i + 1, tieCount: 1 });
                }
            }
            pages++;
            mrState.scanPagesDone = pages;
            mrState.total = total;
            mrState.currency = currency;
            mrRenderPanel();
            if (page.listings.length < MR_PAGE_SIZE) break; // 已到末页
        }
        mrComputeTies(all, mineMap);
        return { total, currency, mine: [...mineMap.values()], scanned: all.length };
    }

    /**
     * 二分定位：已知本人价格（来自页面上架表格），先二分找到首个触及该价格的页，
     * 再向后顺序扫描覆盖整个同价档位，期间用 bMine 精确识别。比全量扫描省 70%+ 请求。
     */
    async function mrLocateMine(gen, myPrices, page0) {
        const lo = Math.min(...myPrices);
        const hi = Math.max(...myPrices);
        const total = page0 ? page0.total : 0;
        if (!total) return null;
        const maxPage = Math.min(MR_MAX_SCAN_PAGES - 1, Math.floor((total - 1) / MR_PAGE_SIZE));
        // 二分：找最小 k 使 page[k] 末位价格 >= lo
        let a = 0, b = maxPage, hit = -1;
        let firstPage = null;
        while (a <= b) {
            if (gen !== mrState.gen) return null;
            const mid = (a + b) >> 1;
            let page;
            if (mid === 0 && page0 && page0.start === 0) page = page0;
            else page = await mrFetchPage(mid * MR_PAGE_SIZE, gen);
            const lastCents = page.listings.length ? page.listings[page.listings.length - 1].cents : 0;
            if (lastCents >= lo) { hit = mid; firstPage = page; b = mid - 1; }
            else a = mid + 1;
        }
        if (hit < 0) return { total, mine: [], scanned: -1 }; // 本人价格高于全场最高价（异常）
        // 从 hit 顺序向后扫描，直到页首价格 > hi
        const mineMap = new Map();
        const all = [];
        let k = hit;
        while (k <= maxPage) {
            if (gen !== mrState.gen) return null;
            const start = k * MR_PAGE_SIZE;
            const page = (k === hit) ? firstPage : await mrFetchPage(start, gen);
            for (let i = 0; i < page.listings.length; i++) {
                const l = page.listings[i];
                all.push(l);
                if (l.bMine && l.id) mineMap.set(l.id, { id: l.id, cents: l.cents, rank: start + i + 1, tieCount: 1 });
            }
            mrState.scanPagesDone = k - hit + 1;
            if (page.listings.length === 0) break;
            const firstCents = page.listings[0].cents;
            const lastCents = page.listings[page.listings.length - 1].cents;
            if (firstCents > hi) break; // 本页已完全越过本人价格区间
            if (mineMap.size >= myPrices.length && lastCents > hi) break; // 已找齐且越过区间
            k++;
        }
        mrComputeTies(all, mineMap);
        return { total, mine: [...mineMap.values()], scanned: all.length };
    }

    /** 增量探测：只抓取本人排名附近的页窗口，重新定位每个挂单ID的精确位置。
        v1.4.8：窗口数设上限并按排名升序优先保留（面板 #1 来自最靠前挂单）；
        截断时返回 truncated=true，未探测到的挂单不代表已售出，调用方不得触发全量重扫 */
    async function mrProbe(gen) {
        const sorted = [...mrState.mine].sort((a, b) => a.rank - b.rank);
        const pageStarts = new Set();
        let truncated = false;
        for (const m of sorted) {
            if (pageStarts.size >= MR_PROBE_MAX_PAGES) { truncated = true; break; }
            const base = Math.floor((m.rank - 1) / MR_PAGE_SIZE) * MR_PAGE_SIZE;
            pageStarts.add(Math.max(0, base - MR_PAGE_SIZE));
            pageStarts.add(base);
            pageStarts.add(base + MR_PAGE_SIZE);
        }
        const starts = [...pageStarts].sort((x, y) => x - y);
        const found = new Map();       // id → 新 rank
        let total = mrState.total;
        const clusterCents = new Map(); // cents → 本窗口内数量（刷新 tie）
        for (let i = 0; i < starts.length; i++) {
            if (gen !== mrState.gen) return null;
            const start = starts[i];
            const page = await mrFetchPage(start, gen); // 间隔由全局限速器控制
            total = page.total || total;
            for (let j = 0; j < page.listings.length; j++) {
                const l = page.listings[j];
                if (l.bMine && l.id) found.set(l.id, { id: l.id, cents: l.cents, rank: start + j + 1 });
                if (l.bMine) clusterCents.set(l.cents, (clusterCents.get(l.cents) || 0) + 1);
            }
        }
        return { total, found, clusterCents, truncated };
    }

    /** 一次完整周期：探测 → 异常时全量重扫 → 变化检测与 UI 更新 */
    async function mrRunCycle(gen) {
        if (!mrState.active || mrState.running || gen !== mrState.gen) return;
        mrState.running = true;
        try {
            if (mrState.phase === 'ok' && mrState.mine.length > 0) {
                const probe = await mrProbe(gen);
                if (gen !== mrState.gen) return;
                if (probe) {
                    const prevTotal = mrState.total;
                    const prevFront = Math.min(...mrState.mine.map(m => m.rank));
                    const prevIds = new Set(mrState.mine.map(m => m.id));
                    // 全部找到 → 直接更新排名；有丢失 → 全量重扫确认（售出/下架/大位移）
                    // v1.4.8：探测窗口被截断时未找到 ≠ 已售出，保留旧排名合并，避免挂单多时每轮都全量重扫
                    const allFound = [...prevIds].every(id => probe.found.has(id));
                    let soldIds = [];
                    if (allFound) {
                        mrState.mine = [...probe.found.values()].map(m => {
                            const old = mrState.mine.find(x => x.id === m.id);
                            return { ...m, tieCount: probe.clusterCents.get(m.cents) || (old ? old.tieCount : 1) };
                        });
                    } else if (probe.truncated) {
                        mrState.mine = mrState.mine.map(m => {
                            const f = probe.found.get(m.id);
                            if (!f) return m; // 窗口外挂单沿用上次排名
                            const old = m;
                            return { id: f.id, cents: f.cents, rank: f.rank, tieCount: probe.clusterCents.get(f.cents) || old.tieCount };
                        });
                    } else {
                        const rescan = await mrScanAll(gen);
                        if (gen !== mrState.gen) return;
                        if (rescan) {
                            mrState.mine = rescan.mine;
                            soldIds = [...prevIds].filter(id => !rescan.mine.some(m => m.id === id));
                        }
                    }
                    mrState.total = probe.total || mrState.total;
                    const newFront = mrState.mine.length ? Math.min(...mrState.mine.map(m => m.rank)) : null;
                    // 变化提示
                    const notes = [];
                    if (prevTotal !== mrState.total) {
                        const d = mrState.total - prevTotal;
                        notes.push(`在售 ${prevTotal.toLocaleString()}→${mrState.total.toLocaleString()}（${d > 0 ? '+' : ''}${d}）`);
                    }
                    if (newFront != null && newFront !== prevFront) {
                        notes.push(`我的顺序 #${prevFront.toLocaleString()}→#${newFront.toLocaleString()}`);
                    }
                    for (const id of soldIds) {
                        notes.push(`挂单 …${id.slice(-6)} 已售出或下架`);
                        toast(`市场顺序：挂单 …${id.slice(-6)} 已售出或下架`, 'success');
                    }
                    mrState.changeNote = notes.join(' · ');
                    if (notes.length > 0) {
                        mrFlashRank(newFront != null && prevFront != null && newFront < prevFront ? 'up' : 'down');
                        if (!soldIds.length && (newFront !== prevFront)) toast(`我的市场顺序 #${prevFront} → #${newFront}`, 'info');
                    }
                    if (mrState.mine.length === 0) {
                        mrState.phase = 'none';
                    } else {
                        mrState.phase = 'ok';
                        mrState.lastUpdate = Date.now();
                        mrState.failStreak = 0;
                        mrSaveCache();
                    }
                    mrRenderPanel();
                    mrInjectDomBadges();
                } else {
                    throw new Error('探测被中断');
                }
            } else {
                // 初始周期：优先二分定位，失败或数量不符时全量扫描兜底
                const page0 = mrCurrentDocPage();
                if (page0) { mrState.total = page0.total; mrState.currency = page0.currency; }
                const rows = mrGetMyTableRows();
                const myPrices = rows.map(mrParseRowPriceCents).filter(c => c > 0);
                let result = null;
                if (page0 && myPrices.length > 0) {
                    mrState.phase = 'scanning';
                    mrRenderPanel();
                    try {
                        result = await mrLocateMine(gen, myPrices, page0);
                    } catch (e) { W('MR binary locate failed:', e.message); result = null; }
                    // 校验：找到数量应 ≥ 表格行数（表格可能滞后）；不符则全量兜底
                    if (result && result.mine.length < myPrices.length) {
                        L(`MR locate found ${result.mine.length} < table ${myPrices.length}, fallback to full scan`);
                        result = null;
                    }
                }
                if (!result) {
                    mrState.phase = 'scanning';
                    mrRenderPanel();
                    result = await mrScanAll(gen);
                }
                if (gen !== mrState.gen) return;
                if (result) {
                    mrState.total = result.total;
                    mrState.currency = result.currency || mrState.currency;
                    mrState.mine = result.mine;
                    if (result.mine.length === 0) {
                        // v1.5.1 P2-E 修复：API/SSR 的 total_count 与实际 listings 不一致时
                        // （常见 Steam 数据残留：total=1 但 listings=[]），以本轮实际扫到的数量为准，
                        // 避免面板误显"共 1 件在售"——用户在物品页明明看不到任何挂单
                        if (result.scanned === 0 && mrState.total > 0) mrState.total = 0;
                        mrState.phase = 'none';
                        mrState.changeNote = '';
                    } else {
                        mrState.phase = 'ok';
                        mrState.lastUpdate = Date.now();
                        mrState.failStreak = 0;
                        const prev = mrLoadCache();
                        if (prev && prev.mine && prev.mine.length) {
                            const pf = Math.min(...prev.mine.map(m => m.rank));
                            const nf = Math.min(...result.mine.map(m => m.rank));
                            if (pf !== nf) mrState.changeNote = `上次访问 #${pf.toLocaleString()} → 本次 #${nf.toLocaleString()}`;
                        }
                        mrSaveCache();
                    }
                    mrRenderPanel();
                    mrInjectDomBadges();
                }
            }
        } catch (e) {
            if (gen !== mrState.gen) return;
            // v1.5.1 P1-A：请求层迁移后，中止/超时统一为 SmeRequestError('Timeout')
            if (e && (e.name === 'AbortError' || e.code === SME_ERR.TIMEOUT)) return;
            mrState.failStreak++;
            mrState.phase = mrState.mine.length ? 'ok' : 'error';
            mrState.changeNote = e.message || '网络错误';
            mrRenderPanel();
            W('MR cycle error:', e.message);
        } finally {
            mrState.running = false;
            if (gen === mrState.gen && mrState.active) mrScheduleNext();
        }
    }

    function mrFlashRank(dir) {
        const big = document.getElementById('sme-mr-rank-big');
        if (!big) return;
        big.classList.remove('up', 'down');
        void big.offsetWidth;
        big.classList.add(dir === 'up' ? 'up' : 'down');
        const panel = mrState.panelEl;
        if (panel) {
            panel.classList.remove('sme-mr-flash');
            void panel.offsetWidth;
            panel.classList.add('sme-mr-flash');
        }
    }

    // ---- UI：页面 DOM 徽章注入（我的上架表格 + 市场卡片） ----
    function mrInjectDomBadges() {
        if (mrState.phase !== 'ok' || mrState.mine.length === 0) return;
        const sorted = [...mrState.mine].sort((a, b) => a.rank - b.rank);
        const front = sorted[0];
        const rankForCents = (cents) => {
            // 同价多个我的挂单：取该价格下最靠前的；返回 {rank, tieCount, ambiguous}
            const same = sorted.filter(m => m.cents === cents);
            if (same.length === 0) return null;
            return { rank: same[0].rank, tieCount: same[0].tieCount, ambiguous: same.length > 1 };
        };
        // v1.4.8：只设置 data 属性（React diff 不移除非受控属性），徽章由 CSS ::after 渲染，
        // 不再向 React 管理的容器 appendChild/insertAdjacentElement 插入子节点
        const applyBadge = (el, info, labelFmt) => {
            if (!el || !el.setAttribute) return;
            if (info) {
                el.setAttribute('data-sme-rank', labelFmt(info));
                if (info.rank === front.rank) el.setAttribute('data-sme-front', '1');
                else el.removeAttribute('data-sme-front');
            } else {
                el.setAttribute('data-sme-rank', '顺序计算中…');
                el.removeAttribute('data-sme-front');
            }
        };

        // 1) "出售 - 我的上架物品" 表格行价格格注入市场顺序
        const rows = mrGetMyTableRows();
        for (const row of rows) {
            const cents = mrParseRowPriceCents(row);
            // 价格格 = 倒数第二格（操作格含按钮）
            const priceCell = row.children[row.children.length - 2] || row.children[2];
            applyBadge(priceCell, cents ? rankForCents(cents) : null,
                info => `市场第 ${info.rank.toLocaleString()} 位${info.tieCount > 1 ? `（同级 ${info.tieCount} 件）` : ''}`);
        }

        // 2) 市场列表卡片上"（我的上架物品）"标记追加顺序徽章
        // v1.4.8：先按叶子节点过滤再做文本正则，省去大列表页上万个 span 的 textContent 读取
        for (const span of document.querySelectorAll('span')) {
            if (span.childElementCount > 0) continue; // 纯文本标记必然是叶子 span
            const txt = (span.textContent || '').trim();
            if (!txt || txt.length > 30) continue;
            if (!MR_MY_MARKER_RE.test(txt)) continue;
            // 从同级容器文本解析该卡片价格
            const holder = span.parentElement;
            const scope = holder.parentElement || holder;
            const cents = parsePriceToCents(scope.textContent);
            applyBadge(span, cents ? rankForCents(cents) : null,
                info => `第 ${info.rank.toLocaleString()} 位`);
        }
    }

    /** DOM 变化观察：React 重渲染后自动补回徽章（防抖）。
        v1.4.8：后台标签页跳过注入（React 大列表重渲染时 observer 触发密集） */
    function mrSetupObserver() {
        if (mrState.observer) return;
        let timer = null;
        mrState.observer = new MutationObserver(() => {
            if (timer) clearTimeout(timer);
            timer = setTimeout(() => {
                if (!mrState.active || mrState.phase !== 'ok') return;
                if (document.visibilityState === 'hidden') return;
                mrEnsurePanel();
                // v1.4.9：如果面板已断开连接，尝试重新嵌入到筛选面板内部，否则回退到 body
                if (mrState.panelEl && !mrState.panelEl.isConnected) {
                    if (mrState.panelEl.classList.contains('sme-mr-inline')) {
                        const filterInfo = mrFindFilterContainer();
                        if (filterInfo && filterInfo.container) {
                            if (filterInfo.mode === 'inside') {
                                filterInfo.container.appendChild(mrState.panelEl);
                            } else {
                                filterInfo.container.parentNode.insertBefore(mrState.panelEl, filterInfo.container.nextSibling);
                            }
                        } else {
                            mrState.panelEl.classList.remove('sme-mr-inline');
                            document.body.appendChild(mrState.panelEl);
                        }
                    } else {
                        document.body.appendChild(mrState.panelEl);
                    }
                }
                mrInjectDomBadges();
            }, 400);
        });
        mrState.observer.observe(document.body, { childList: true, subtree: true });
    }

    // ---- 初始化与清理 ----
    function initMarketRankTracker() {
        if (!settings.get('marketRankTracker')) return;
        if (mrState.active && mrState.url === location.href) return;

        // 仅新版 React 市场页支持（需 renderContext）；未登录无法识别 bMine
        let rc = null;
        try { rc = unsafeWindow.SSR && unsafeWindow.SSR.renderContext; } catch (e) {}
        if (!rc) { L('MR: 非 React SSR 市场页，跳过市场顺序跟踪'); return; }
        let loggedIn = true;
        try { if (unsafeWindow.UserConfig && unsafeWindow.UserConfig.logged_in === false) loggedIn = false; } catch (e) {}
        if (!loggedIn) { L('MR: 未登录，跳过市场顺序跟踪'); return; }

        cleanupMarketRankTracker();
        mrState.active = true;
        mrState.url = location.href;
        mrState.gen++;
        const gen = mrState.gen;

        // 回显上次结果，随后立即开始扫描
        const cached = mrLoadCache();
        if (cached) {
            mrState.total = cached.total || 0;
            mrState.currency = cached.currency || 0;
            mrState.mine = cached.mine.map(m => ({ ...m }));
            mrState.phase = 'ok';
            mrState.lastUpdate = cached.ts;
            mrState.changeNote = '上次访问结果，正在刷新…';
        }
        mrEnsurePanel();
        mrRenderPanel();
        mrSetupObserver();
        mrStartCountdown();
        L('MR: 市场顺序跟踪已启动', location.pathname, cached ? '(cache hit)' : '');
        setTimeout(() => mrRunCycle(gen), 500);
    }

    function cleanupMarketRankTracker() {
        mrState.gen++;
        mrState.active = false;
        mrState.running = false;
        mrState.paused = false;
        mrState.phase = 'init';
        mrState.mine = [];
        mrState.total = 0;
        mrState.currency = 0;
        mrState.failStreak = 0;
        mrState.changeNote = '';
        mrState.countdown = 0;
        clearTimeout(mrState.timer);
        mrState.timer = null;
        clearInterval(mrState.countdownTimer);
        mrState.countdownTimer = null;
        if (mrState.abortCtrl) { try { mrState.abortCtrl.abort(); } catch (e) {} mrState.abortCtrl = null; }
        if (mrState.observer) { try { mrState.observer.disconnect(); } catch (e) {} mrState.observer = null; }
        if (mrState.panelEl) { try { mrState.panelEl.remove(); } catch (e) {} mrState.panelEl = null; }
        // v1.4.8：徽章已是 data 属性，移除属性即可（不动 React 节点结构）；
        // 限速器时间窗/429 冷却状态跨清理保留，防止换页后立即再次冲撞限流
        document.querySelectorAll('[data-sme-rank]').forEach(el => {
            el.removeAttribute('data-sme-rank');
            el.removeAttribute('data-sme-front');
        });
    }

    // ==================== v1.5.0 市场物品页显示更多价格（新版 React 市场页） ====================
    // 参考 sffxzzp/marketshowmore：新版市场物品页为 React SSR + 客户端 hydrate，订单表格组件
    // 内部只渲染 orders.slice(0, 6)（默认 6 行）。本模块在 document-start 阶段（react-dom
    // 初始化之前）向 window 注入假的 __REACT_DEVTOOLS_GLOBAL_HOOK__：react-dom 初始化时会
    // 调用 hook.inject() 完成绑定，之后每次 commit 都会回调 hook.onCommitFiberRoot；此时遍历
    // fiber 树，把接收 orders 数组 prop（带 currency 属性）的组件定义替换为包装函数，包装函数
    // 将 props.orders 替换为 Proxy——拦截其 .slice(0, 6) 调用并改写为 .slice(0, N)（N 为设置
    // 行数），从而借助页面自身的渲染流程显示更多价格行。
    // 关键约束：必须 @run-at document-start，否则 react-dom 已完成初始化，假 hook 无法绑定。
    // 若页面已存在真实 hook（用户安装了 React DevTools 扩展），本模块让位不注入。

    const SMM_HOOK_NAME = '__REACT_DEVTOOLS_GLOBAL_HOOK__';
    const SMM_PATCH_FLAG = '_smeShowMorePatched';    // props 标记：该 props 已被包装组件处理过
    const SMM_WRAPPER_FLAG = '_smeShowMoreWrapper';  // 组件标记：已是包装组件（防止重复嵌套包装）
    const SMM_DEFAULT_ROWS = 20;     // 默认显示行数
    const SMM_INTERCEPT_END = 6;     // Steam 订单表格默认切片终点 slice(0, 6)
    const SMM_MAX_ROWS = 100;        // 行数上限

    const smmState = {
        hook: null,        // 我们注入的假 hook 对象（关闭时只置灰不删除，保持 react-dom 已建立的绑定）
        enabled: false,
        lastRoot: null,    // 最近一次 commit 的 fiber root（关闭时尽力还原组件定义）
        patched: 0,        // 累计 patch 的组件定义数（日志用）
        walkTimer: null,   // 遍历合并定时器（连续 commit 时只跑最新一次）
    };

    /** 读取设置的行数（钳制在 6-100） */
    function smmRows() {
        let n = parseInt(settings.get('showMorePricesRows'), 10);
        if (isNaN(n)) n = SMM_DEFAULT_ROWS;
        return Math.min(SMM_MAX_ROWS, Math.max(SMM_INTERCEPT_END, n));
    }

    /** 遍历 fiber 树，patch 接收 orders 数组 prop 的组件定义（orders.slice(0,6) → slice(0,N)） */
    function smmProcessFiberRoot(root) {
        smmState.walkTimer = null;
        if (!smmState.enabled || !root) return;
        try {
            smmState.lastRoot = root;
            const stack = [root.current];
            const visited = new Set();
            let patchedNow = 0;
            while (stack.length > 0) {
                const node = stack.pop();
                if (!node || visited.has(node)) continue;
                visited.add(node);
                const { type, memoizedProps } = node;
                if (memoizedProps && Array.isArray(memoizedProps.orders) && memoizedProps.hasOwnProperty('currency')) {
                    const componentFunction = (type && type.type) ? type.type : type;
                    if (componentFunction && typeof componentFunction === 'function' && !componentFunction[SMM_WRAPPER_FLAG]) {
                        const original = componentFunction;
                        const PatchedComponent = function (props, ...args) {
                            if (!props[SMM_PATCH_FLAG] && props.orders && Array.isArray(props.orders)) {
                                const ordersProxy = new Proxy(props.orders, {
                                    get(target, prop, receiver) {
                                        if (prop === 'slice') {
                                            return function (start, end) {
                                                if (start === 0 && end === SMM_INTERCEPT_END) {
                                                    return target.slice(0, smmRows());
                                                }
                                                return target.slice(start, end);
                                            };
                                        }
                                        return Reflect.get(target, prop, receiver);
                                    },
                                });
                                return original.apply(this, [{ ...props, orders: ordersProxy, [SMM_PATCH_FLAG]: true }, ...args]);
                            }
                            return original.apply(this, [props, ...args]);
                        };
                        PatchedComponent[SMM_WRAPPER_FLAG] = true;
                        PatchedComponent._smmOriginal = original;
                        try {
                            if (type && type.type) type.type = PatchedComponent;
                            else if (node.type && typeof node.type === 'function') node.type = PatchedComponent;
                            patchedNow++;
                        } catch (e) {
                            W('SMM: patch 组件定义失败', e);
                        }
                    }
                }
                if (node.child) stack.push(node.child);
                if (node.sibling) stack.push(node.sibling);
            }
            if (patchedNow) {
                smmState.patched += patchedNow;
                L(`SMM: 已 patch ${patchedNow} 个订单组件（累计 ${smmState.patched}），订单表格将显示 ${smmRows()} 行`);
            }
        } catch (e) {
            W('SMM: 处理 fiber 树异常', e);
        }
    }

    /**
     * 注入假 React DevTools hook（须在 document-start 调用）。
     * 返回：'installed' 新建注入 | 'reused' 复用并重新启用既有假 hook | 'conflict' 已存在外部 hook | 'off' 设置未开启
     */
    function installShowMoreHook() {
        if (!settings.get('showMorePrices')) return 'off';
        let existing = null;
        try { existing = unsafeWindow[SMM_HOOK_NAME]; } catch (e) {}
        if (existing) {
            if (existing === smmState.hook) {
                smmState.enabled = true;
                L('SMM: 复用既有假 hook 并重新启用');
                return 'reused';
            }
            W('SMM: 页面已存在 ' + SMM_HOOK_NAME + '（可能安装了 React DevTools 扩展），本模块让位');
            return 'conflict';
        }
        const hook = {
            renderers: new Map(),
            supportsFiber: true,
            inject: function (renderer) {
                const id = (hook.renderers.size || 0) + 1;
                hook.renderers.set(id, renderer);
                return id;
            },
            onCommitFiberRoot: function (rendererID, root) {
                if (!smmState.enabled) return;
                if (smmState.walkTimer) return;   // 连续 commit 合并，只处理最新 root
                smmState.walkTimer = setTimeout(() => smmProcessFiberRoot(root), 200);
            },
            onCommitFiberUnmount: function () {},
            onPostCommitFiberRoot: function () {},
        };
        try {
            Object.defineProperty(unsafeWindow, SMM_HOOK_NAME, { value: hook, configurable: true });
        } catch (e) {
            W('SMM: 注入假 hook 失败', e);
            return 'conflict';
        }
        smmState.hook = hook;
        smmState.enabled = true;
        L(`SMM: 已注入假 React DevTools hook，订单表格将显示 ${smmRows()} 行`);
        return 'installed';
    }

    /** 尽力还原被 patch 的组件定义（关闭功能时调用，返回还原数量） */
    function smmRestorePatched() {
        const root = smmState.lastRoot;
        if (!root) return 0;
        let restored = 0;
        try {
            const stack = [root.current];
            const visited = new Set();
            while (stack.length > 0) {
                const node = stack.pop();
                if (!node || visited.has(node)) continue;
                visited.add(node);
                const t = node.type;
                const inner = t && t.type;
                if (inner && typeof inner === 'function' && inner[SMM_WRAPPER_FLAG] && inner._smmOriginal) {
                    try { t.type = inner._smmOriginal; restored++; } catch (e) {}
                } else if (typeof t === 'function' && t[SMM_WRAPPER_FLAG] && t._smmOriginal) {
                    try { node.type = t._smmOriginal; restored++; } catch (e) {}
                }
                if (node.child) stack.push(node.child);
                if (node.sibling) stack.push(node.sibling);
            }
        } catch (e) {}
        return restored;
    }

    /** 关闭显示更多价格（保留 hook 对象本身以维持 react-dom 绑定，重新开启无需刷新） */
    function disableShowMorePrices() {
        smmState.enabled = false;
        if (smmState.walkTimer) { clearTimeout(smmState.walkTimer); smmState.walkTimer = null; }
        const restored = smmRestorePatched();
        smmState.patched = 0;
        L('SMM: 已关闭显示更多价格' + (restored ? `（还原 ${restored} 个组件定义，刷新页面后完全恢复）` : ''));
    }

    /** 设置开关统一处理（设置面板与浏览页悬浮按钮共用） */
    function onShowMorePricesToggle(val) {
        settings.set('showMorePrices', val);
        if (val) {
            const status = installShowMoreHook();
            if (status === 'reused') toast('显示更多价格已开启', 'success');
            else if (status === 'installed') toast('已开启，刷新页面后生效', 'info');
            else if (status === 'conflict') toast('开启失败：页面已存在 ' + SMM_HOOK_NAME + '（React DevTools 扩展冲突）', 'error');
        } else {
            disableShowMorePrices();
            toast('已关闭，刷新页面后完全恢复', 'info');
        }
    }

    // ==================== v2.0.1 库存仪表（全库存浮盈浮亏 + 交易冷却可视化） ====================
    /**
     * 全行业基本没人做的两件事，这里各做一份：
     *
     * ① **全库存浮盈浮亏**（对标 PriceCharting / SIH 的收藏品 P&L）
     *    · 成本基准：成交记录按 **FIFO** 配对；成本用**卖家到手价**（买家支付价 − 手续费），
     *      否则「买入即亏手续费」会让成本虚高、浮亏虚高。
     *    · 已实现盈亏：卖出按 FIFO 消耗买入批次；买入发生在索引窗口之外的，
     *      单独记「成本未知」计数，**不猜成本**。
     *    · 未实现盈亏：现价用 `priceoverview` 的最低卖价（与市场实际可成交价一致）。
     *
     * ② **交易冷却可视化**（7 天不可再挂 / Trade Protection）
     *    · 冷却天数：取自 Steam 自己的 `descriptions[].market_marketable_restriction`
     *      （Valve 游戏为 7 天；已实测这是**类级别天数**而非剩余天数）。
     *    · 解锁日：获得时间（市场买入时间，来自成交记录）+ 冷却天数。
     *    · 交易/赠送所得的物品没有买入记录 → 起始时间未知，如实标注「来源未知」，
     *      **不编造解锁日期**。
     *
     * 两者都放在「市场交易记录分析」浮窗里（同一份成交记录数据源，不额外抓取）。
     */
    const dashState = {
        loading: false,
        loaded: false,
        holdings: [],      // [{name, qty, marketableDays, tradableDays}]
        costBasis: null,   // smeCostBasis 结果
        prices: {},        // name → 现价（分）
        pnl: null,         // smePnlCalc 结果
        cooldowns: [],     // smeCooldownList 结果
        fetched: 0,
        total: 0,
        error: '',
        updatedAt: 0,
    };

    const DASH_MAX_ITEMS = 300;   // 单次最多估值多少个持仓物品（防限流失控）

    /** 取一批物品的现价（priceoverview），带并发上限与进度回调 */
    async function dashFetchPrices(names, onProgress) {
        const prices = {};
        const list = names.slice(0, DASH_MAX_ITEMS);
        let done = 0;
        const CONCURRENCY = 3;
        let idx = 0;
        async function worker() {
            for (;;) {
                const i = idx++;
                if (i >= list.length) return;
                const name = list[i];
                try {
                    const appid = dashAppidOf(name);
                    const wi = getWalletInfo();
                    const url = 'https://steamcommunity.com/market/priceoverview/?appid=' + encodeURIComponent(appid)
                        + '&market_hash_name=' + encodeURIComponent(name)
                        + '&currency=' + (wi.wallet_currency || 1);
                    const data = await smeRequest(url, { expect: 'json' });
                    if (data && data.success && data.lowest_price) {
                        const cents = parsePriceToCents(String(data.lowest_price));
                        if (cents > 0) prices[name] = cents;
                    }
                } catch (e) { /* 单件失败不影响整体 */ }
                done++;
                if (onProgress) onProgress(done, list.length);
            }
        }
        const workers = [];
        for (let i = 0; i < CONCURRENCY; i++) workers.push(worker());
        await Promise.all(workers);
        return prices;
    }

    /** 从物品名猜 appid（用于 priceoverview）——按已知前缀规则推断 */
    function dashAppidOf(name) {
        const n = String(name || '');
        if (/^CSGO|CS2|Weapon|Cases|Package|Goo|Souvenir/i.test(n)) return '730';
        if (/^Dota/i.test(n)) return '570';
        if (/^Souvenir/i.test(n)) return '730';
        if (/^Bundle|Community| foil|Foil/i.test(n)) return '753';
        return '730';
    }

    /** 加载仪表数据（库存 + 现价 + 成本基准 + 冷却） */
    async function dashLoad(onProgress) {
        if (dashState.loading) return;
        dashState.loading = true;
        dashState.error = '';
        try {
            // 1) 成本基准（来自成交记录，无网络请求）
            dashState.costBasis = smeCostBasis(mhState.rows || [], {
                netOf: (c) => priceBeforeFees(c),
            });
            // 2) 当前库存持仓
            dashState.holdings = await fetchInventoryHoldings();
            // 3) 现价（只取持仓里与成本基准对得上的物品，避免无谓请求）
            const names = [];
            const seen = new Set();
            for (const h of dashState.holdings) {
                if (seen.has(h.name)) continue;
                seen.add(h.name);
                names.push(h.name);
            }
            dashState.total = names.length;
            dashState.fetched = 0;
            dashState.prices = await dashFetchPrices(names, (d, t) => {
                dashState.fetched = d;
                if (onProgress) onProgress(d, t);
            });
            // 4) 未实现盈亏
            const holdMap = new Map(dashState.holdings.map(h => [h.name, h]));
            const valued = [];
            for (const hold of (dashState.costBasis.holdings || [])) {
                const inv = holdMap.get(hold.name);
                valued.push({
                    name: hold.name,
                    qty: inv ? inv.qty : hold.qty,
                    costCents: hold.costCents,
                });
            }
            dashState.pnl = smePnlCalc(valued, dashState.prices);
            // 5) 冷却清单
            const rules = {};
            for (const h of dashState.holdings) {
                rules[h.name] = { marketableDays: h.marketableDays, tradableDays: h.tradableDays };
            }
            dashState.cooldowns = smeCooldownList(
                dashState.costBasis.holdings || [], rules, Date.now());
            dashState.loaded = true;
            dashState.updatedAt = Date.now();
        } catch (e) {
            dashState.error = (e && e.message) || String(e);
            W('库存仪表加载失败:', e && e.message);
        } finally {
            dashState.loading = false;
        }
    }

    /** 「库存浮盈」面板 */
    function dashPanePnl() {
        const code = mhCurrencyCode();
        const money = (c) => formatCentsStr(c, code);
        const pnl = dashState.pnl;
        const cb = dashState.costBasis;

        if (dashState.loading || (!dashState.loaded && !dashState.error)) {
            return `<div class="sme-mh-empty">正在加载库存与现价…<div class="sme-mh-empty-sub">${dashState.fetched}/${dashState.total}</div></div>`;
        }
        if (dashState.error) {
            return `<div class="sme-mh-empty">加载失败：${escapeHtml(dashState.error)}</div>`;
        }
        if (!pnl || !pnl.rows.length) {
            return `<div class="sme-mh-empty">没有可估算的持仓`
                + `<div class="sme-mh-empty-sub">需要先索引市场交易记录（用于建立成本基准），并确保库存里有可市场物品。</div></div>`;
        }

        // 已实现盈亏（来自 FIFO 配对的卖出记录）
        let realizedProceeds = 0, realizedCost = 0, realizedQty = 0, unknownCost = 0;
        if (cb && cb.realized) {
            for (const rec of cb.realized.values()) {
                realizedProceeds += rec.proceedsCents;
                realizedCost += rec.costCents;
                realizedQty += rec.qty;
                unknownCost += rec.unknownCost || 0;
            }
        }
        const realizedPnl = realizedProceeds - realizedCost;

        const cards = [
            mhStatCard('持仓件数', String(pnl.total), '', ICONS.list, '可市场物品种数', '#66c0f4'),
            mhStatCard('持仓市值', money(pnl.totalValue), '', ICONS.chart, '按现价 × 件数', '#38bdf8'),
            mhStatCard('持仓成本', money(pnl.totalCost), '', ICONS.queue, '卖家到手价口径', '#8f98a0'),
            mhStatCard('未实现盈亏', money(pnl.totalPnl),
                pnl.totalPnl >= 0 ? 'sme-up' : 'sme-down', ICONS.trendingUp,
                '现价 − 成本', pnl.totalPnl >= 0 ? '#4caf50' : '#e24a4a'),
            mhStatCard('已实现盈亏', money(realizedPnl),
                realizedPnl >= 0 ? 'sme-up' : 'sme-down', ICONS.trendingDown,
                realizedQty + ' 笔卖出配对', realizedPnl >= 0 ? '#4caf50' : '#e24a4a'),
            mhStatCard('净收益', money(pnl.totalPnl + realizedPnl),
                (pnl.totalPnl + realizedPnl) >= 0 ? 'sme-up' : 'sme-down', ICONS.dollarSign,
                '未实现 + 已实现', '#f59e0b'),
        ].join('');

        const rows = pnl.rows.slice().sort((a, b) => (b.pnlCents || 0) - (a.pnlCents || 0));
        const body = rows.map(r => {
            const cur = r.currentCents != null ? money(r.currentCents) : '—';
            const pnlText = r.pnlCents != null ? money(r.pnlCents) : '—';
            const pct = r.pnlPct != null ? (r.pnlPct * 100).toFixed(1) + '%' : '—';
            const cls = r.pnlCents == null ? '' : (r.pnlCents >= 0 ? 'sme-up' : 'sme-down');
            return `<tr>`
                + `<td title="${escapeHtml(r.name)}">${escapeHtml(r.name)}</td>`
                + `<td class="sme-mh-num">${r.qty}</td>`
                + `<td class="sme-mh-num">${money(r.costCents)}</td>`
                + `<td class="sme-mh-num">${cur}</td>`
                + `<td class="sme-mh-num ${cls}">${pnlText}</td>`
                + `<td class="sme-mh-num ${cls}">${pct}</td>`
                + `</tr>`;
        }).join('');

        const note = '成本基准 = 成交记录按 FIFO 配对，且用**卖家到手价**（已扣手续费）；'
            + '现价 = priceoverview 最低卖价；未实现盈亏未计未来卖出手续费。'
            + (unknownCost ? `另有 ${unknownCost} 笔卖出的买入记录不在索引窗口内，其成本按未知处理。` : '')
            + (dashState.updatedAt ? ' 数据更新于 ' + mhFmtTs(dashState.updatedAt).slice(0, 16) + '。' : '');

        return `<div class="sme-mh-stats">${cards}</div>`
            + `<div class="sme-mh-table-wrap is-scrollable"><table class="sme-mh-table">`
            + `<thead><tr><th>物品</th><th class="sme-mh-num">件数</th><th class="sme-mh-num">单位成本</th>`
            + `<th class="sme-mh-num">现价</th><th class="sme-mh-num">浮盈</th><th class="sme-mh-num">浮盈%</th></tr></thead>`
            + `<tbody>${body}</tbody></table></div>`
            + `<div class="sme-mh-empty-sub" style="margin-top:10px">${note}</div>`;
    }

    /** 「交易冷却」面板 */
    function dashPaneCooldown() {
        const code = mhCurrencyCode();
        const list = dashState.cooldowns || [];
        if (dashState.loading || (!dashState.loaded && !dashState.error)) {
            return `<div class="sme-mh-empty">正在加载库存与冷却规则…<div class="sme-mh-empty-sub">${dashState.fetched}/${dashState.total}</div></div>`;
        }
        if (dashState.error) {
            return `<div class="sme-mh-empty">加载失败：${escapeHtml(dashState.error)}</div>`;
        }
        const lockedItems = list.filter(x => x.daysLeft != null);
        const unknownItems = list.filter(x => x.daysLeft == null);
        const lockedQty = lockedItems.reduce((s, x) => s + x.qty, 0);
        const nextUnlock = lockedItems.length
            ? lockedItems.reduce((m, x) => Math.min(m, x.earliestUntilTs || x.untilTs), Infinity)
            : 0;

        const cards = [
            mhStatCard('锁定物品', String(lockedItems.length), '', ICONS.alert, '仍在 7 天冷却期内', '#f59e0b'),
            mhStatCard('锁定件数', String(lockedQty), '', ICONS.list, '不可立即上架', '#e24a4a'),
            mhStatCard('最早解锁', nextUnlock ? mhFmtTs(nextUnlock).slice(5, 16) : '—', '',
                ICONS.calendar, nextUnlock ? '到时可上架' : '暂无锁定', '#4caf50'),
            mhStatCard('来源未知', String(unknownItems.length), '', ICONS.alert,
                '交易/赠送所得，无买入记录', '#8b5cf6'),
        ].join('');

        let body = '';
        if (!list.length) {
            body = `<tr><td colspan="5" class="sme-mh-empty">没有处于冷却期的物品</td></tr>`;
        } else {
            body = list.map(x => {
                const until = x.untilTs ? mhFmtTs(x.untilTs).slice(0, 16) : '—';
                const left = x.daysLeft != null ? (x.daysLeft + ' 天') : '来源未知';
                const src = x.source === 'market-buy' ? '市场买入' : '交易/赠送（时间未知）';
                const cls = x.daysLeft != null ? 'sme-down' : '';
                return `<tr>`
                    + `<td title="${escapeHtml(x.name)}">${escapeHtml(x.name)}</td>`
                    + `<td class="sme-mh-num">${x.qty}</td>`
                    + `<td class="sme-mh-num">${x.days} 天</td>`
                    + `<td class="sme-mh-num">${until}</td>`
                    + `<td class="sme-mh-num ${cls}">${left}</td>`
                    + `<td>${src}</td>`
                    + `</tr>`;
            }).join('');
        }

        const note = '冷却天数取自 Steam 自己的 descriptions[].market_marketable_restriction（Valve 游戏为 7 天）；'
            + '解锁日 = 获得时间（市场买入时间，来自成交记录）+ 冷却天数。'
            + '交易/赠送所得的物品没有买入记录，起始时间无法确定，标为「来源未知」而非猜测。'
            + '2025-07 起 CS2 交易所得物品另有 7 天 Trade Protection（可被撤销）。';

        return `<div class="sme-mh-stats">${cards}</div>`
            + `<div class="sme-mh-table-wrap is-scrollable"><table class="sme-mh-table">`
            + `<thead><tr><th>物品</th><th class="sme-mh-num">件数</th><th class="sme-mh-num">冷却</th>`
            + `<th class="sme-mh-num">解锁日</th><th class="sme-mh-num">剩余</th><th>来源</th></tr></thead>`
            + `<tbody>${body}</tbody></table></div>`
            + `<div class="sme-mh-empty-sub" style="margin-top:10px">${note}</div>`;
    }

    /** 仪表面板统一入口：渲染 + 异步加载 + 完成后重绘 */
    function mhPaneDashboard(prefix) {
        const build = () => (prefix === 'inventory' ? dashPanePnl() : dashPaneCooldown());
        const note = prefix === 'inventory'
            ? '成本基准来自本地索引的成交记录；现价取自 priceoverview 最低卖价。'
            : '冷却规则与解锁日来自 Steam 的限制字段 + 本地成交记录。';
        return mhRenderPane(prefix, note, build, () => {
            const refresh = () => {
                const bodyEl = document.getElementById('sme-mh-' + prefix + '-body');
                if (!bodyEl || !bodyEl.isConnected) return;
                bodyEl.innerHTML = build();
            };
            if (dashState.loaded) { refresh(); return; }
            dashLoad((d, t) => {
                const bodyEl = document.getElementById('sme-mh-' + prefix + '-body');
                if (!bodyEl || !bodyEl.isConnected) return;
                const sub = bodyEl.querySelector('.sme-mh-empty-sub');
                if (sub) sub.textContent = d + '/' + t;
            }).then(refresh);
        });
    }

    // ==================== v1.6.0 市场交易记录汇总与导出 ====================
    // 在"我的市场历史记录"页（"出售物品"按钮旁）注入工具条：
    //   汇总 —— 多维统计（笔数 / 收支 / 估算手续费 / 按物品·游戏·月份分组）
    //   导出 —— 按下拉选择的 CSV 或 JSON 格式导出全部交易记录
    //   刷新 —— 重新分页抓取全量数据
    //
    // 数据源：https://steamcommunity.com/market/myhistory/render/?query=&start=&count=
    //   单页上限 100 条，返回 { success, results_html, total_count, hovers, assets }。
    //   Steam 只返回渲染好的 HTML 片段，故需在本地解析行节点。
    //
    // 注意：Steam 的历史记录表格不返回年份（只显示"10 月 18 日"），
    //   mhAssignTimestamps 依据接口的倒序分页做跨年推断，得到近似时间戳。
    //
    // 依赖：h, escapeHtml, toast, sleep, settings, cache, smeRequest, SME_ERR,
    //   friendlyError, parsePriceToCents, formatCentsStr, priceBeforeFees,
    //   getWalletInfo, getSteamId, ICONS, showConfirmDialog, RETRY_BACKOFF_MIN/MAX, L, W。
    const MH_PAGE_MAX = 100;          // Steam 单页硬上限
    const MH_CACHE_PREFIX = 'mh_rows_v1_';
    const MH_CACHE_TTL = 12 * 60 * 60 * 1000;  // 本地索引缓存 12 小时

    const mhState = {
        active: false,
        styleAdded: false,
        panelEl: null,     // 独立容器节点（#myMarketTabs 的前一个兄弟）
        rows: [],          // 已索引的交易记录（断点续传时从此继续，不清空）
        totalCount: 0,     // Steam 报告的总数
        fetchedAt: 0,      // 最近一次成功抓取的时间戳
        nextOffset: 0,     // 下次请求的 start 偏移（= 已消费到的接口位置）
        complete: false,   // 是否已抓完
        paused: false,     // 是否因限流暂停
        nextAt: 0,         // 限流冷却到期时间戳（0 = 不在冷却）
        fetching: false,
        abort: false,
        format: 'csv',
    };
    // v1.6.8：缓存结构版本。v1 是「无进度元数据」的旧结构，读到时降级处理（见 mhLoadCache）
    const MH_CACHE_V = 2;
    // 限流冷却时长（毫秒），按连续限流次数递增
    const MH_COOLDOWN_BASE = 60 * 1000;
    const MH_COOLDOWN_MAX = 15 * 60 * 1000;

    const MH_CSS = `
/* ============================================================================
   v1.6.2 视觉系统重构（按 UI Design Master 规范落地）
   - 8px 基准间距阶梯：4 / 8 / 12 / 16 / 24 / 32
   - 圆角收敛为 3 档：6（控件）/ 10（卡片）/ 14（窗口）
   - 表面层级：bg-1 窗口 → bg-2 卡片 → bg-3 控件，三层各差一档亮度
   - 语义色：卖出绿 / 买入红 / 警告琥珀 / 信息蓝 / 强调紫，均满足 WCAG AA 正文对比
   - 动效只用 transform / opacity，时长 140–200ms，缓动 cubic-bezier(.4,0,.2,1)
   - 响应式：栅格 auto-fit，窄屏降列，表格横向滚动
   ============================================================================ */
.sme-mh-modal,.sme-mh-panel{
    --mh-bg-1:#151a21;
    --mh-bg-2:#1b222b;
    --mh-bg-3:#232d39;
    --mh-line:rgba(255,255,255,.07);
    --mh-line-2:rgba(255,255,255,.13);
    --mh-t1:#e9eff5;
    --mh-t2:#9aa9b8;
    --mh-t3:#6b7a89;
    --mh-sell:#4ade80;
    --mh-buy:#f87171;
    --mh-warn:#fbbf24;
    --mh-info:#66c0f4;
    --mh-purple:#a78bfa;
    --mh-r-s:6px;
    --mh-r-m:10px;
    --mh-r-l:14px;
    --mh-ease:cubic-bezier(.4,0,.2,1);
    --mh-shadow-1:0 1px 2px rgba(0,0,0,.30);
    --mh-shadow-2:0 4px 16px rgba(0,0,0,.28);
    --mh-shadow-3:0 18px 48px rgba(0,0,0,.55);
}

/* ---------- 页面工具条容器 ---------- */
/* v1.7.1：市场首页操作栏做成浮动光条，深色页上一眼能定位 */
.sme-mh-panel{
    clear:both;position:relative;z-index:4;
    margin:10px 0 14px;
    font-family:"Motiva Sans",system-ui,-apple-system,sans-serif;
}
.sme-mh-panel-inner{
    position:relative;overflow:hidden;
    display:flex;align-items:center;gap:8px;flex-wrap:wrap;
    padding:7px 12px;
    background:
        radial-gradient(120% 160% at 0% 0%, rgba(102,192,244,.22) 0%, rgba(102,192,244,0) 48%),
        linear-gradient(180deg,#243446 0%,#141b24 100%);
    border:1px solid rgba(168,220,255,.42);
    border-radius:10px;
    box-shadow:
        0 6px 18px rgba(0,0,0,.38),
        0 0 14px rgba(102,192,244,.28);
    animation:sme-mh-bar-glow 2.8s ease-in-out infinite;
}
.sme-mh-panel-inner::before{
    content:"";position:absolute;top:-20%;bottom:-20%;left:0;width:32%;
    background:linear-gradient(100deg,transparent,rgba(214,242,255,.2),transparent);
    transform:translateX(-130%) skewX(-18deg);
    animation:sme-mh-bar-sheen 3.8s ease-in-out infinite;
    pointer-events:none;
}
.sme-mh-panel-inner::after{
    content:"";position:absolute;left:14px;right:14px;top:0;height:1px;
    background:linear-gradient(90deg,transparent,rgba(186,230,255,.85) 50%,transparent);
    pointer-events:none;
}
.sme-mh-panel-inner > *{position:relative;z-index:1}
@keyframes sme-mh-bar-glow{
    0%,100%{
        border-color:rgba(168,220,255,.38);
        box-shadow:0 6px 16px rgba(0,0,0,.36),0 0 12px rgba(102,192,244,.22);
    }
    50%{
        border-color:rgba(198,234,255,.62);
        box-shadow:0 8px 20px rgba(0,0,0,.4),0 0 18px rgba(102,192,244,.38);
    }
}
@keyframes sme-mh-bar-sheen{
    0%{transform:translateX(-130%) skewX(-18deg)}
    58%,100%{transform:translateX(340%) skewX(-18deg)}
}
.sme-mh-title{
    display:inline-flex;align-items:center;gap:6px;
    font-size:13px;font-weight:650;color:#e7f4ff;letter-spacing:.2px;white-space:nowrap;
    padding-right:10px;border-right:1px solid rgba(102,192,244,.28);
}
.sme-mh-title svg{width:14px;height:14px;filter:drop-shadow(0 0 4px rgba(102,192,244,.7))}
.sme-mh-actions{margin-left:auto;display:inline-flex;align-items:center;gap:6px;flex-wrap:wrap}
.sme-mh-actions button:disabled{opacity:.4;cursor:not-allowed}
.sme-mh-actions .sme-market-btn{
    padding:4px 10px;font-size:12px;font-weight:600;border-radius:6px;
    background:rgba(102,192,244,.12);border:1px solid rgba(168,220,255,.38);color:#eaf6ff;
    box-shadow:none;
}
.sme-mh-actions .sme-market-btn:hover{
    background:rgba(102,192,244,.22);border-color:rgba(214,242,255,.7);color:#fff;
    box-shadow:0 0 10px rgba(102,192,244,.28);
}
.sme-mh-actions .sme-market-btn.sme-danger{
    background:rgba(226,74,74,.14);border-color:rgba(255,154,154,.4);color:#ffd8d8;
    box-shadow:none;
}
.sme-mh-actions .sme-market-btn.sme-danger:hover{
    background:rgba(226,74,74,.24);border-color:rgba(255,196,196,.7);color:#fff;
}
.sme-mh-actions .sme-market-btn .sme-svg{width:13px;height:13px}
.sme-mh-format{
    padding:3px 8px;min-height:26px;border:1px solid rgba(168,220,255,.38);background:#1b2836;
    color:#eaf6ff;font-size:12px;font-weight:600;border-radius:6px;cursor:pointer;
    font-family:inherit;transition:border-color .15s var(--mh-ease),background .15s var(--mh-ease);
    box-shadow:none;
}
.sme-mh-format:hover{background:#243446;border-color:rgba(214,242,255,.7)}
.sme-mh-format:focus{outline:none;border-color:rgba(214,242,255,.85);box-shadow:0 0 0 2px rgba(102,192,244,.22)}
.sme-mh-status{
    font-size:12px;font-weight:550;color:#d5e4f0;white-space:nowrap;
    padding:3px 9px;border-radius:999px;
    background:rgba(0,0,0,.28);border:1px solid rgba(255,255,255,.1);
}
.sme-mh-status.sme-ok{color:#b6f5cf;border-color:rgba(74,222,128,.32);background:rgba(74,222,128,.1)}
.sme-mh-status.sme-err{color:#ffd0d0;border-color:rgba(248,113,113,.36);background:rgba(248,113,113,.1)}
.sme-mh-progress{
    height:3px;background:rgba(255,255,255,.07);border-radius:999px;
    margin-top:4px;overflow:hidden;display:none;
}
.sme-mh-progress-bar{
    height:100%;width:0;border-radius:999px;
    background:linear-gradient(90deg,var(--mh-info) 0%,#a5dcff 100%);
    transition:width .25s var(--mh-ease);
}

/* ---------- 分析窗口 ---------- */
.sme-mh-modal{
    position:fixed;inset:0;z-index:var(--sme-z-overlay);
    background:rgba(6,9,13,.72);backdrop-filter:blur(3px);
    display:none;align-items:center;justify-content:center;padding:3vh 2vw;
}
.sme-mh-modal.visible{display:flex;animation:sme-mh-in .2s var(--mh-ease)}
@keyframes sme-mh-in{from{opacity:0}to{opacity:1}}
.sme-mh-win{
    display:flex;flex-direction:column;width:100%;max-width:1200px;max-height:94vh;
    background:linear-gradient(180deg,var(--mh-bg-1) 0%,#11161c 100%);
    border:1px solid var(--mh-line-2);border-radius:var(--mh-r-l);
    box-shadow:var(--mh-shadow-3);overflow:hidden;
    font-family:"Motiva Sans",system-ui,-apple-system,sans-serif;color:var(--mh-t1);
    animation:sme-mh-pop .24s var(--mh-ease);
}
@keyframes sme-mh-pop{from{opacity:0;transform:translateY(12px) scale(.985)}to{opacity:1;transform:none}}
.sme-mh-win-header{
    display:flex;align-items:center;justify-content:space-between;gap:16px;
    padding:12px 16px;border-bottom:1px solid var(--mh-line);
    background:linear-gradient(135deg,var(--mh-cb,var(--sme-blue-a08)) 0%,rgba(13,16,21,.6) 100%);
    flex-shrink:0;
}
.sme-mh-win-title{display:flex;align-items:center;gap:10px;min-width:0}
.sme-mh-win-title #sme-mh-ht{font-size:16px;font-weight:700;letter-spacing:.2px}
.sme-mh-win-ico{display:inline-flex;color:var(--mh-c,var(--mh-info))}
.sme-mh-win-ico svg{width:20px;height:20px}
.sme-mh-win-sub{
    font-size:12px;color:var(--mh-t3);
    border-left:1px solid var(--mh-line-2);padding-left:10px;margin-left:2px;
}
.sme-mh-win-close{
    background:var(--mh-bg-3);border:1px solid var(--mh-line-2);border-radius:var(--mh-r-s);
    color:var(--mh-t2);cursor:pointer;padding:6px;display:inline-flex;flex-shrink:0;
    transition:background .15s var(--mh-ease),color .15s var(--mh-ease),transform .15s var(--mh-ease);
}
.sme-mh-win-close:hover{background:rgba(248,113,113,.16);color:var(--mh-buy);border-color:rgba(248,113,113,.4)}
.sme-mh-win-close:active{transform:scale(.94)}
.sme-mh-win-close svg{width:16px;height:16px;display:block}
.sme-mh-win-body{
    display:flex;flex-direction:column;min-height:0;flex:1;
    padding:12px 16px 14px;overflow:hidden;
}

/* 顶部标签：胶囊分段控件 */
.sme-mh-tabs{
    display:flex;gap:4px;padding:4px;margin-bottom:12px;flex-shrink:0;
    background:rgba(0,0,0,.28);border:1px solid var(--mh-line);border-radius:var(--mh-r-m);
}
.sme-mh-tab{
    display:inline-flex;align-items:center;gap:6px;padding:6px 14px;
    background:transparent;border:1px solid transparent;border-radius:var(--mh-r-s);
    color:var(--mh-t2);font-size:13px;font-weight:500;cursor:pointer;font-family:inherit;
    transition:background .16s var(--mh-ease),color .16s var(--mh-ease),transform .16s var(--mh-ease);
}
.sme-mh-tab svg{width:15px;height:15px;opacity:.85}
.sme-mh-tab:hover{background:rgba(255,255,255,.06);color:var(--mh-t1)}
.sme-mh-tab:active{transform:scale(.97)}
.sme-mh-tab.active{
    background:var(--mh-cb,var(--sme-blue-a15));border-color:var(--c,var(--mh-info));
    color:var(--c,var(--mh-info));font-weight:600;
}
.sme-mh-tab.active svg{opacity:1}
.sme-mh-panels{flex:1;min-height:0;overflow:auto;padding-right:4px}
.sme-mh-view{display:none}
.sme-mh-view.active{display:block;animation:sme-mh-fade .18s var(--mh-ease)}
@keyframes sme-mh-fade{from{opacity:0;transform:translateY(4px)}to{opacity:1;transform:none}}
.sme-mh-mf{
    display:flex;align-items:flex-start;gap:8px;flex-shrink:0;
    margin-top:12px;padding-top:10px;border-top:1px solid var(--mh-line);
    font-size:11px;color:var(--mh-t3);line-height:1.7;
}
.sme-mh-mf svg{width:14px;height:14px;flex-shrink:0;margin-top:2px;opacity:.7}

/* ---------- 面板内工具条 ---------- */
.sme-mh-toolbar{
    display:flex;align-items:center;gap:8px;flex-wrap:wrap;
    padding:10px 12px;margin-bottom:12px;border-radius:var(--mh-r-m);
    background:var(--mh-bg-2);border:1px solid var(--mh-line);
}
.sme-mh-tb-label{font-size:11px;font-weight:600;color:var(--mh-t3);letter-spacing:.4px;margin-right:2px}
.sme-mh-tb-sep{width:1px;height:16px;background:var(--mh-line-2);margin:0 4px}
.sme-mh-tb-range{font-size:11px;color:var(--mh-t3);margin-left:auto}
.sme-mh-chip{
    display:inline-flex;align-items:center;gap:6px;padding:5px 12px;
    background:var(--mh-bg-3);border:1px solid transparent;border-radius:var(--mh-r-s);
    color:var(--mh-t2);font-size:12px;cursor:pointer;font-family:inherit;
    transition:background .15s var(--mh-ease),color .15s var(--mh-ease),
               border-color .15s var(--mh-ease),transform .15s var(--mh-ease);
}
.sme-mh-chip:hover:not(:disabled){background:#2c3745;color:var(--mh-t1)}
.sme-mh-chip:active:not(:disabled){transform:scale(.96)}
.sme-mh-chip:disabled{opacity:.35;cursor:not-allowed}
.sme-mh-chip.active{
    background:var(--cb,var(--sme-blue-a15));border-color:var(--c,var(--mh-info));
    color:var(--c,var(--mh-info));font-weight:600;
}
.sme-mh-chip i{width:10px;height:10px;border-radius:3px;flex-shrink:0}

/* ---------- 数据卡片 ---------- */
.sme-mh-stats{
    display:grid;grid-template-columns:repeat(auto-fit,minmax(168px,1fr));gap:10px;margin-bottom:12px;
}
.sme-mh-stat{
    --accent:#66c0f4;
    position:relative;overflow:hidden;min-width:0;
    background:
        linear-gradient(180deg, color-mix(in srgb, var(--accent) 12%, transparent), transparent 46%),
        var(--mh-bg-2);
    border:1px solid var(--mh-line);
    border-color:color-mix(in srgb, var(--accent) 34%, rgba(255,255,255,.06));
    border-radius:var(--mh-r-m);
    padding:14px 14px 12px;
    transition:transform .16s var(--mh-ease),border-color .16s var(--mh-ease),box-shadow .16s var(--mh-ease);
}
.sme-mh-stat::before{
    content:"";position:absolute;left:16px;right:16px;top:0;height:2px;width:auto;
    background:linear-gradient(90deg, transparent, var(--accent) 16%, var(--accent) 84%, transparent);
    box-shadow:0 0 8px var(--accent);
}
.sme-mh-stat:hover{
    transform:translateY(-2px);
    border-color:color-mix(in srgb, var(--accent) 62%, transparent);
    box-shadow:0 8px 20px rgba(0,0,0,.28), 0 0 16px color-mix(in srgb, var(--accent) 22%, transparent);
}
.sme-mh-stat-ico{
    position:absolute;top:12px;right:12px;display:inline-flex;
    color:var(--accent);opacity:.72;
}
.sme-mh-stat-ico svg{width:15px;height:15px;display:block}
.sme-mh-stat-label{
    font-size:11px;font-weight:500;color:var(--mh-t3);
    letter-spacing:.3px;padding-right:22px;
    overflow:hidden;text-overflow:ellipsis;white-space:nowrap;
}
.sme-mh-stat-value{
    font-size:19px;font-weight:700;color:var(--mh-t1);margin-top:6px;line-height:1.2;
    font-variant-numeric:tabular-nums;
    overflow:hidden;text-overflow:ellipsis;white-space:nowrap;
}
.sme-mh-stat-value.sme-up{color:var(--mh-sell)}
.sme-mh-stat-value.sme-down{color:var(--mh-buy)}
.sme-mh-stat-hint{font-size:10px;color:var(--mh-t3);margin-top:4px;line-height:1.5}

/* ---------- 卡片 / 双栏 ---------- */
.sme-mh-card{
    position:relative;overflow:hidden;
    --accent:#66c0f4;
    margin:0;padding:14px 16px;border-radius:var(--mh-r-m);
    background:var(--mh-bg-2);border:1px solid var(--mh-line);
    border-color:color-mix(in srgb, var(--accent) 28%, rgba(255,255,255,.06));
}
.sme-mh-card::before{
    content:"";position:absolute;left:18px;right:18px;top:0;height:2px;
    background:linear-gradient(90deg, transparent, var(--accent), transparent);
    box-shadow:0 0 8px var(--accent);
}
.sme-mh-card-title{
    font-size:12px;font-weight:600;color:var(--mh-t2);
    margin-bottom:12px;display:flex;align-items:center;gap:8px;
}
.sme-mh-card-title::before{
    content:"";width:3px;height:12px;border-radius:2px;background:var(--accent, var(--mh-info));
}
.sme-mh-split{display:grid;grid-template-columns:1fr 1fr;gap:12px;margin-bottom:12px}
@media (max-width:900px){.sme-mh-split{grid-template-columns:1fr}}

/* v1.6.5：概览页的两块图表重做布局，收紧高度、去掉双滚动条 */
.sme-mh-flowbox{display:flex;align-items:center;gap:18px}
.sme-mh-donut{width:130px;height:130px;flex-shrink:0}
.sme-mh-flowlist{flex:1;min-width:0;display:flex;flex-direction:column;gap:2px}
.sme-mh-flowrow{
    display:grid;grid-template-columns:10px 1fr auto minmax(88px,auto);
    align-items:center;gap:10px;padding:6px 8px;border-radius:var(--mh-r-s);
    transition:background .15s var(--mh-ease);
}
.sme-mh-flowrow:hover{background:rgba(255,255,255,.04)}
.sme-mh-flowrow.is-strong{
    background:var(--mh-bg-3);margin-top:4px;
    border:1px solid var(--mh-line-2);
}
.sme-mh-flowdot{width:10px;height:10px;border-radius:3px}
.sme-mh-flowlabel{font-size:12px;color:var(--mh-t2);white-space:nowrap}
.sme-mh-flowrow.is-strong .sme-mh-flowlabel{color:var(--mh-t1);font-weight:600}
.sme-mh-flowsub{font-size:11px;color:var(--mh-t3);text-align:right}
.sme-mh-flowval{
    font-size:13px;font-weight:700;color:var(--mh-t1);text-align:right;
    font-variant-numeric:tabular-nums;white-space:nowrap;
}
.sme-mh-flowval.is-neg{color:var(--mh-buy)}
@media (max-width:760px){
    .sme-mh-flowbox{flex-direction:column;align-items:stretch}
    .sme-mh-donut{align-self:center}
}

/* 价格直方图：对数分档下柱子数量不定，容器高度收敛 */
.sme-mh-hist{
    display:flex;align-items:flex-end;gap:3px;height:168px;padding-top:8px;
}
.sme-mh-hist-col{
    flex:1;display:flex;flex-direction:column;justify-content:flex-end;
    align-items:center;height:100%;min-width:0;
}
.sme-mh-hist-bar{
    width:100%;border-radius:4px 4px 2px 2px;min-height:3px;
    background:linear-gradient(180deg,#a5dcff,#38bdf8);
    transition:opacity .15s var(--mh-ease);
}
.sme-mh-hist-col:hover .sme-mh-hist-bar{opacity:.82}
.sme-mh-hist-count{
    font-size:10px;color:var(--mh-t2);margin-top:5px;
    font-variant-numeric:tabular-nums;white-space:nowrap;
}
.sme-mh-hist-label{
    font-size:9px;color:var(--mh-t3);margin-top:2px;
    max-width:100%;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;
}
.sme-mh-hist-axis{font-size:11px;color:var(--mh-t3);margin-top:8px}

/* 排行页 */
.sme-mh-barcell{width:130px;min-width:110px}
.sme-mh-barfill{
    display:block;height:6px;border-radius:999px;
    background:linear-gradient(90deg,#38bdf8,rgba(56,189,248,.35));
}
.sme-mh-sub{
    display:block;font-size:10px;color:var(--mh-t3);font-weight:400;
    max-width:280px;overflow:hidden;text-overflow:ellipsis;
}
.sme-mh-th-bar{color:var(--mh-t3);font-weight:500;text-align:left}
.sme-mh-ranktable td.sme-mh-barcell{padding-right:16px}

/* ---------- 图表 / 图例 ---------- */
/* v1.7.1：绘图区按 viewBox 比例撑满卡片宽度。
   旧版容器锁死 400px 高 + preserveAspectRatio meet，宽屏两侧会留出大块空白。 */
.sme-mh-chartbox{
    width:100%;height:auto;box-sizing:border-box;
    display:block;padding:4px 6px 8px;
    background:var(--mh-bg-2);border:1px solid var(--mh-line);border-radius:var(--mh-r-m);
}
.sme-mh-chart-plot{
    position:relative;width:100%;height:0;overflow:visible;
}
.sme-mh-chart-plot svg{
    position:absolute;inset:0;width:100%;height:100%;display:block;overflow:visible;
}
.sme-mh-clipnote{
    margin-top:10px;padding:8px 12px;border-radius:var(--mh-r-s);
    background:rgba(251,191,36,.10);border:1px solid rgba(251,191,36,.28);
    font-size:11px;color:var(--mh-warn);line-height:1.6;
}
.sme-mh-extra{font-size:11px;color:var(--mh-t3);margin-top:10px}

/* 明细页的维度候选 chips 行（替代下拉框） */
.sme-mh-valuebar{
    display:flex;align-items:center;gap:8px;flex-wrap:wrap;
    padding:10px 12px;margin-bottom:12px;
    background:var(--mh-bg-2);border:1px solid var(--mh-line);border-radius:var(--mh-r-m);
}
.sme-mh-chip-axis{
    font-style:normal;font-size:10px;font-weight:400;
    color:var(--mh-t3);padding-left:2px;
}
.sme-mh-chip.active .sme-mh-chip-axis{color:var(--sme-blue-a70)}
/* 趋势筛选：小字展示该曲线的区间合计，选中时跟曲线同色 */
.sme-mh-chip-sum{
    font-style:normal;font-size:11px;font-weight:650;white-space:nowrap;
    font-variant-numeric:tabular-nums;color:var(--mh-t2);
    margin-left:2px;padding-left:6px;border-left:1px solid rgba(255,255,255,.14);
}
.sme-mh-chip.active .sme-mh-chip-sum{color:var(--c,var(--mh-t1))}
.sme-mh-empty-sub{font-size:11px;color:var(--mh-t3);opacity:.8}

/* ---------- 表格 ---------- */
/* v1.6.5：默认只做横向滚动。纵向滚动交给外层 .sme-mh-panels，
   否则面板与表格同时可滚会出现双滚动条（v1.6.4 概览页的实际问题）。
   明细页表格较长，加 .is-scrollable 单独开启内层纵向滚动。 */
.sme-mh-table-wrap{
    max-height:none;overflow-x:auto;overflow-y:hidden;
    border:1px solid var(--mh-line);border-radius:var(--mh-r-m);
    background:var(--mh-bg-2);
}
.sme-mh-table-wrap.is-scrollable{max-height:46vh;overflow-y:auto}
.sme-mh-table{width:100%;border-collapse:separate;border-spacing:0;font-size:12px}
.sme-mh-table td{
    padding:8px 12px;text-align:left;
    border-bottom:1px solid var(--mh-line);white-space:nowrap;
}
.sme-mh-table th{
    padding:9px 12px;text-align:left;white-space:nowrap;
    border-bottom:1px solid var(--mh-line-2);
    background:#1d252f;color:var(--mh-t2);font-weight:600;letter-spacing:.3px;
    position:sticky;top:0;z-index:2;
}
.sme-mh-table th:first-child{top:0}
.sme-mh-table tbody tr{transition:background .12s var(--mh-ease)}
.sme-mh-table tbody tr:hover{background:rgba(255,255,255,.04)}
.sme-mh-table tbody tr:last-child td{border-bottom:none}
.sme-mh-table td.sme-num{text-align:right;font-variant-numeric:tabular-nums;color:var(--mh-t1)}
.sme-mh-table td.sme-mh-dim,.sme-mh-table td.dim{color:var(--mh-t3)}
.sme-mh-table td.sme-mh-name{max-width:340px;overflow:hidden;text-overflow:ellipsis;color:var(--mh-t1)}
.sme-mh-rank{
    width:34px;text-align:center;color:var(--mh-t3);
    font-variant-numeric:tabular-nums;font-weight:600;
}
.sme-mh-zero{color:var(--mh-t3);opacity:.6}
.sme-mh-th-sort{cursor:pointer;user-select:none;transition:color .12s var(--mh-ease)}
.sme-mh-th-sort:hover{color:var(--mh-t1)}

/* ---------- 状态标签 ---------- */
.sme-mh-tag{
    display:inline-block;padding:2px 9px;border-radius:999px;
    font-size:10px;font-weight:600;letter-spacing:.3px;
}
.sme-mh-tag.sold{background:rgba(74,222,128,.16);color:var(--mh-sell)}
.sme-mh-tag.bought{background:rgba(248,113,113,.16);color:var(--mh-buy)}
.sme-mh-tag.listed{background:rgba(102,192,244,.16);color:var(--mh-info)}
.sme-mh-tag.canceled{background:rgba(255,255,255,.07);color:var(--mh-t3)}
.sme-mh-tag.other{background:rgba(255,255,255,.07);color:var(--mh-t3)}

/* ---------- 分页 / 空态 ---------- */
.sme-mh-pager{
    display:flex;align-items:center;gap:10px;flex-wrap:wrap;padding:12px 2px 0;
    font-size:12px;color:var(--mh-t2);
}
.sme-mh-empty{
    display:flex;flex-direction:column;align-items:center;justify-content:center;gap:8px;
    padding:36px 16px;color:var(--mh-t3);font-size:13px;text-align:center;
}
.sme-mh-empty::before{
    content:"";width:40px;height:40px;border-radius:50%;
    border:2px dashed var(--mh-line-2);
}
.sme-mh-hint{font-size:11px;color:var(--mh-t3);margin-top:12px;line-height:1.7}
.sme-mh-hint-sm{font-size:11px;color:var(--mh-t3);line-height:1.7;margin-top:8px}

/* ---------- 日历热力 ---------- */
.sme-mh-cal-container{
    display:flex;flex-direction:column;gap:20px;
    padding:16px;background:var(--mh-bg-2);border:1px solid var(--mh-line);border-radius:var(--mh-r-m);
}
.sme-mh-cal-year-label{
    font-size:14px;font-weight:700;color:var(--mh-t1);margin-bottom:10px;
    display:flex;align-items:center;gap:8px;
}
.sme-mh-cal-year-label::before{
    content:"";width:4px;height:14px;border-radius:2px;background:var(--mh-purple);
}
.sme-mh-cal-months{display:flex;gap:3px;padding-left:28px;margin-bottom:5px}
.sme-mh-cal-months span{flex:1;text-align:left;font-size:11px;color:var(--mh-t3)}
.sme-mh-cal-body{display:flex;gap:5px}
.sme-mh-cal-weekdays{display:flex;flex-direction:column;gap:3px;width:22px;flex-shrink:0}
.sme-mh-cal-weekdays span{
    font-size:10px;color:var(--mh-t3);text-align:center;
    height:17px;line-height:17px;
}
.sme-mh-cal-cells{
    display:grid;grid-template-columns:repeat(53,1fr);grid-template-rows:repeat(7,1fr);
    grid-auto-flow:column;gap:3px;flex:1;
}
/* v1.6.4：格子加大 + 描边，网格结构一眼可辨；颜色由内联 style 逐档给出 */
.sme-mh-cal-cell{
    width:17px;height:17px;border-radius:4px;position:relative;
    display:flex;align-items:center;justify-content:center;
    border:1px solid rgba(255,255,255,.07);
    transition:transform .12s var(--mh-ease),box-shadow .12s var(--mh-ease),border-color .12s var(--mh-ease);
}
.sme-mh-cal-cell.has-data{border-color:rgba(255,255,255,.16)}
.sme-mh-cal-cell.is-empty{background:rgba(255,255,255,.028)!important;border-color:rgba(255,255,255,.05)}
.sme-mh-cal-cell.sme-mh-cal-pad{background:transparent!important;border-color:transparent}
.sme-mh-cal-cell span{font-size:10px;font-weight:700;line-height:1}
.sme-mh-cal-cell:hover{
    transform:scale(1.45);z-index:3;
    box-shadow:0 3px 12px rgba(0,0,0,.65);border-color:#fff;
}
.sme-mh-cal-legend{
    display:inline-flex;align-items:center;gap:4px;
    font-size:11px;color:var(--mh-t3);
}
.sme-mh-cal-legend i{
    width:14px;height:14px;border-radius:4px;display:inline-block;
    border:1px solid rgba(255,255,255,.16);
}
.sme-mh-cal-legend i.is-empty{border-color:rgba(255,255,255,.05)}

/* ---------- 导出 ---------- */
.sme-mh-fmt{
    display:flex;flex-direction:column;align-items:flex-start;gap:3px;text-align:left;
    padding:8px 14px;min-width:136px;
    background:var(--mh-bg-3);border:1px solid transparent;border-radius:var(--mh-r-s);
    color:var(--mh-t2);cursor:pointer;font-family:inherit;
    transition:all .16s var(--mh-ease);
}
.sme-mh-fmt:hover{background:#2c3745;color:var(--mh-t1)}
.sme-mh-fmt.active{
    background:rgba(74,222,128,.14);border-color:var(--mh-sell);color:var(--mh-t1);
}
.sme-mh-fmt-label{font-size:12px;font-weight:700;letter-spacing:.3px}
.sme-mh-fmt-desc{font-size:10px;color:var(--mh-t3);white-space:normal;line-height:1.5}
.sme-mh-fmt.active .sme-mh-fmt-desc{color:var(--mh-t2)}
.sme-mh-export-body{display:flex;gap:12px;flex-wrap:wrap;align-items:stretch}
.sme-mh-export-preview{
    flex:1;min-width:300px;
    padding:14px 16px;background:var(--mh-bg-2);
    border:1px solid var(--mh-line);border-radius:var(--mh-r-m);
}
.sme-mh-export-side{
    width:232px;flex-shrink:0;display:flex;flex-direction:column;gap:10px;
    padding:14px 16px;background:var(--mh-bg-2);
    border:1px solid var(--mh-line);border-radius:var(--mh-r-m);
}
.sme-mh-pre{
    margin:0;padding:12px;border-radius:var(--mh-r-s);
    background:rgba(0,0,0,.42);border:1px solid var(--mh-line);
    font-family:Consolas,"SF Mono",Menlo,monospace;font-size:11px;line-height:1.8;
    color:var(--mh-t2);white-space:pre-wrap;word-break:break-all;
    max-height:300px;overflow:auto;
}
.sme-mh-btn-primary{
    margin-top:auto;padding:10px 16px;border-radius:var(--mh-r-s);
    border:1px solid #3f9c5a;background:linear-gradient(180deg,#4ade80,#2f8f52);color:#06210f;
    font-size:13px;font-weight:700;cursor:pointer;font-family:inherit;
    transition:transform .15s var(--mh-ease),filter .15s var(--mh-ease);
}
.sme-mh-btn-primary:hover{filter:brightness(1.08)}
.sme-mh-btn-primary:active{transform:scale(.97)}

@media (prefers-reduced-motion:reduce){
    .sme-mh-modal.visible,.sme-mh-win,.sme-mh-view.active,
    .sme-mh-panel-inner,.sme-mh-panel-inner::before{
        animation:none;
    }
    .sme-mh-panel-inner{
        border-color:rgba(186,230,255,.55);
        box-shadow:0 6px 16px rgba(0,0,0,.36),0 0 12px rgba(102,192,244,.24);
    }
}
`;

    // ---------- 缓存（含断点续传元数据） ----------
    function mhCacheKey() {
        return MH_CACHE_PREFIX + (getSteamId() || 'anon');
    }

    /** 行去重键：eventId 优先，退化用 挂单ID+交易时间 */
    function mhRowKey(r) {
        return r.eventId || ((r.listingId || '') + '|' + (r.tradeTs || 0) + '|' + (r.priceCents || 0));
    }

    /**
     * 读缓存。
     * - **未完成**的断点用 7 天 TTL：一次限流不该让断点过期，否则用户被迫从头再来
     * - **已完成**的仍按 MH_CACHE_TTL（12h）过期：需要反映新增的交易
     */
    function mhLoadCache() {
        const key = mhCacheKey();
        const c = cache.get(key, 7 * 24 * 60 * 60 * 1000);
        if (!c) return false;
        if (!Array.isArray(c.rows) || c.rows.length === 0) return false;
        if (c.complete && Date.now() - (c.at || 0) > MH_CACHE_TTL) return false;

        // v1 旧缓存没有进度元数据：数据仍可用，按「已抓到 rows.length 处」降级恢复
        const legacy = c._v !== MH_CACHE_V;
        mhState.rows = c.rows;
        mhState.totalCount = c.total || c.rows.length;
        mhState.fetchedAt = c.at || 0;
        if (legacy) {
            mhState.nextOffset = c.rows.length;
            mhState.complete = !c.total || c.rows.length >= c.total;
            mhState.paused = false;
            mhState.nextAt = 0;
            if (legacy) W('MH cache is legacy format, resuming from row count');
        } else {
            mhState.nextOffset = typeof c.nextOffset === 'number' ? c.nextOffset : c.rows.length;
            mhState.complete = !!c.complete;
            mhState.paused = !!c.paused;
            mhState.nextAt = c.nextAt || 0;
            // 冷却期已过则解除暂停标记
            if (mhState.paused && Date.now() >= mhState.nextAt) { mhState.paused = false; mhState.nextAt = 0; }
        }
        // 兜底：任何情况下 nextOffset 都不能超过已有数据量
        if (mhState.nextOffset < mhState.rows.length) mhState.nextOffset = mhState.rows.length;
        return true;
    }

    /** 落盘。rows/total/offset 三个参数让调用方显式决定快照内容。 */
    function mhSaveCache(rows, total, nextOffset) {
        try {
            cache.set(mhCacheKey(), {
                _v: MH_CACHE_V,
                rows: rows || mhState.rows,
                total: total === undefined ? mhState.totalCount : total,
                at: mhState.fetchedAt || Date.now(),
                nextOffset: nextOffset === undefined ? mhState.nextOffset : nextOffset,
                complete: mhState.complete,
                paused: mhState.paused,
                nextAt: mhState.nextAt || 0,
            });
        } catch (e) { /* 配额不足由 cache 内部处理并告警 */ }
    }

    // ---------- 行解析 ----------
    // 表头列序（见 Steam 市场页）：价格 → 交易日期 → 上架日期 → 对手方 → 名称
    // 只承认两种真实交易：卖出 / 买入。
    // Steam 的「我的市场历史记录」只收录已成交记录，「已上架」「已取消」是挂单的动作过程
    // 而非交易，既不产生收支也无法按金额汇总（实测该页 listed/canceled 恒为 0），
    // 因此不再作为独立类型参与分类、筛选与统计；遇到时统一归入 other。
    const MH_ACTION_RULES = [
        [/已售出|已卖出|售出|\bsold\b/i, 'sold', '卖出'],
        [/已购买|已买入|购买|\bbought\b|\bpurchased\b/i, 'bought', '买入'],
    ];

    function mhDetectAction(text) {
        const t = text || '';
        for (const rule of MH_ACTION_RULES) {
            if (rule[0].test(t)) return { key: rule[1], label: rule[2] };
        }
        return { key: 'other', label: '其他' };
    }

    /** 从渲染 HTML 中取 1x 尺寸的经济品图片完整地址 */
    function mhPickImage(imgEl) {
        if (!imgEl) return '';
        const srcset = imgEl.getAttribute('srcset') || '';
        const m = srcset.match(/^(\S+)\s+1x/);
        if (m) return m[1];
        return imgEl.getAttribute('src') || '';
    }

    function mhParseRow(row) {
        const idm = (row.id || '').match(/^history_row_(\d+)_(\d+)$/);
        const nameEl = row.querySelector('.market_listing_item_name');
        const name = nameEl ? nameEl.textContent.trim() : '';
        if (!name) return null;

        const gameEl = row.querySelector('.market_listing_game_name');
        const priceCellEl = row.querySelector('.market_listing_their_price');
        const priceEl = priceCellEl ? priceCellEl.querySelector('.market_listing_price') : null;
        const combinedEl = row.querySelector('.market_listing_listed_date_combined');
        const whoEl = row.querySelector('.market_listing_whoactedwith_name_block');
        const imgEl = row.querySelector('.market_listing_item_img');

        // 两个 can_combine 日期格按表头顺序为：第一个=交易日期，第二个=上架日期
        const dates = row.querySelectorAll('.market_listing_listed_date.can_combine');
        const combinedText = combinedEl ? combinedEl.textContent.replace(/\s+/g, ' ').trim() : '';
        const priceCellText = priceCellEl ? priceCellEl.textContent.replace(/\s+/g, ' ') : '';
        const priceText = priceEl ? priceEl.textContent.replace(/\s+/g, ' ').trim() : '';

        return {
            eventId: idm ? idm[1] : '',
            listingId: idm ? idm[2] : '',
            name: name,
            game: gameEl ? gameEl.textContent.trim() : '',
            action: mhDetectAction(combinedText).key,
            actionLabel: mhDetectAction(combinedText).label,
            priceText: priceText,
            priceCents: parsePriceToCents(priceText),
            pending: /待处理|pending/i.test(combinedText + ' ' + priceCellText),
            tradeDateText: dates.length > 0 ? dates[0].textContent.trim() : '',
            listedDateText: dates.length > 1 ? dates[1].textContent.trim() : '',
            counterpart: whoEl ? whoEl.textContent.replace(/\s+/g, ' ').trim() : '',
            image: mhPickImage(imgEl),
            appId: '',
            tradeTs: 0,
            listedTs: 0,
        };
    }

    function mhParseRows(html) {
        if (!html) return [];
        let doc;
        try { doc = new DOMParser().parseFromString(html, 'text/html'); }
        catch (e) { return []; }
        const out = [];
        doc.querySelectorAll('.market_listing_row[id^="history_row_"]').forEach(row => {
            const r = mhParseRow(row);
            if (r) out.push(r);
        });
        return out;
    }

    // ---------- 日期推断 ----------
    const MH_MONTH_EN = {
        jan: 1, feb: 2, mar: 3, apr: 4, may: 5, jun: 6,
        jul: 7, aug: 8, sep: 9, oct: 10, nov: 11, dec: 12,
    };

    /** 解析 Steam 历史表格的日期文本（中文"10 月 18 日"/英文"Oct 18"/ISO） */
    function mhParseDateText(text) {
        if (!text) return null;
        const s = String(text).trim();
        let m;
        if ((m = s.match(/(\d{4})[-/](\d{1,2})[-/](\d{1,2})/))) {
            return { year: +m[1], month: +m[2], day: +m[3] };
        }
        if ((m = s.match(/(\d{1,2})\s*月\s*(\d{1,2})\s*日?/))) {
            return { year: null, month: +m[1], day: +m[2] };
        }
        if ((m = s.match(/([A-Za-z]{3,9})\.?\s+(\d{1,2})(?:,?\s*(\d{4}))?/))) {
            const key = m[1].slice(0, 3).toLowerCase();
            const mo = MH_MONTH_EN[key];
            if (mo) return { year: m[3] ? +m[3] : null, month: mo, day: +m[2] };
        }
        if ((m = s.match(/^(\d{1,2})\/(\d{1,2})(?:\/(\d{2,4}))?$/))) {
            return { year: m[3] ? +m[3] : null, month: +m[1], day: +m[2] };
        }
        return null;
    }

    /** 取当天正午的时间戳，规避时区把日期推到前一天 */
    function mhToTs(year, month, day) {
        const t = new Date(year, month - 1, day, 12, 0, 0).getTime();
        return isNaN(t) ? 0 : t;
    }

    /**
     * 为缺失年份的日期补全年份。
     * 接口按时间倒序返回，因此"月份比上一条更大"即意味着跨年了。
     * ref 是跨页游标，返回下一批需要接着用的参考年月——
     * 若每页都重扫全量数组，5000+ 条会退化成 O(n²)。
     */
    function mhAssignTimestamps(rows, ref) {
        const now = new Date();
        const cursor = ref || { month: now.getMonth() + 1, year: now.getFullYear() };
        for (const r of rows) {
            const p = mhParseDateText(r.tradeDateText);
            if (p) {
                let y = p.year || cursor.year;
                if (!p.year && p.month > cursor.month) y = cursor.year - 1;
                r.tradeTs = mhToTs(y, p.month, p.day);
                cursor.month = p.month;
                cursor.year = y;
            } else {
                r.tradeTs = 0;
            }
            const lp = mhParseDateText(r.listedDateText);
            if (lp) {
                const baseYear = r.tradeTs ? new Date(r.tradeTs).getFullYear() : cursor.year;
                let lt = mhToTs(lp.year || baseYear, lp.month, lp.day);
                // 上架日期不可能晚于交易日期，越界则回退一年
                if (r.tradeTs && lt > r.tradeTs) {
                    lt = mhToTs((lp.year || baseYear) - 1, lp.month, lp.day);
                }
                r.listedTs = lt;
            } else {
                r.listedTs = 0;
            }
        }
        return cursor;
    }

    function mhFmtTs(ts) {
        if (!ts) return '';
        const d = new Date(ts);
        const p = (n) => String(n).padStart(2, '0');
        return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} `
            + `${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}`;
    }

    function mhMonthKey(ts) {
        if (!ts) return '';
        const d = new Date(ts);
        return d.getFullYear() + '-' + String(d.getMonth() + 1).padStart(2, '0');
    }

    // ---------- AppID 尽力推断 ----------
    function mhNormalizeName(s) {
        return String(s || '').toLowerCase().replace(/[™®©]/g, '').replace(/\s+/g, ' ').trim();
    }

    /**
     * 接口的 assets 字段按 appid → contextid → assetid 组织，内含 market_hash_name。
     * 历史表格本身不带 appid，这里用物品名反查，查不到就留空（不影响导出）。
     */
    function mhBuildAppIdMap(assets) {
        const map = new Map();
        if (!assets || typeof assets !== 'object') return map;
        const put = (k, v) => {
            if (k && !map.has(k)) map.set(k, v);
        };
        for (const appid of Object.keys(assets)) {
            const ctxs = assets[appid];
            if (!ctxs || typeof ctxs !== 'object') continue;
            for (const ctxid of Object.keys(ctxs)) {
                const items = ctxs[ctxid];
                if (!items || typeof items !== 'object') continue;
                for (const assetid of Object.keys(items)) {
                    const a = items[assetid];
                    if (!a) continue;
                    put(a.market_hash_name, appid);
                    put(a.name, appid);
                    put(mhNormalizeName(a.market_hash_name), appid);
                    put(mhNormalizeName(a.name), appid);
                }
            }
        }
        return map;
    }

    function mhApplyAppIds(rows, map) {
        if (!map || map.size === 0) return;
        for (const r of rows) {
            if (r.appId) continue;
            r.appId = map.get(r.name) || map.get(mhNormalizeName(r.name)) || '';
        }
    }

    // ---------- 分页抓取 ----------
    function mhPageSize() {
        return Math.min(MH_PAGE_MAX, Math.max(10, parseInt(settings.get('marketHistoryPageSize'), 10) || MH_PAGE_MAX));
    }

    function mhPageDelay() {
        return Math.max(200, parseInt(settings.get('marketHistoryDelay'), 10) || 700);
    }

    /** 预估抓取耗时（秒），用于确认弹窗提示 */
    function mhEstimateSeconds() {
        if (!mhState.totalCount) return 0;
        return Math.ceil(mhState.totalCount / mhPageSize()) * (mhPageDelay() / 1000);
    }

    /**
     * 请求单页。退避改为**指数 + 抖动**：
     * 原先固定 30–45s 随机，连续限流时会一直踩同一节奏，永远撞不出去。
     * attempt 0/1/2 → 30s / 60s / 120s，各加 ±25% 抖动。
     */
    async function mhFetchPage(start, count, attempt) {
        attempt = attempt || 0;
        const url = `https://steamcommunity.com/market/myhistory/render/?query=&start=${start}&count=${count}`;
        try {
            const data = await smeRequest(url, { expect: 'json', timeout: 20000 });
            if (!data || data.success === false) throw new Error('API success=false');
            return data;
        } catch (err) {
            const code = err && err.code;
            const retryable = code === SME_ERR.RATE_LIMITED || code === SME_ERR.SERVER
                || code === SME_ERR.NETWORK || code === SME_ERR.TIMEOUT;
            if (retryable && attempt < 3) {
                const base = RETRY_BACKOFF_MIN * Math.pow(2, attempt);
                const jitter = Math.floor(base * 0.25 * (Math.random() * 2 - 1));
                const wait = Math.max(1000, Math.min(MH_COOLDOWN_MAX, base + jitter));
                mhSetStatus(`请求受限，${Math.round(wait / 1000)} 秒后重试（${attempt + 1}/3）…`);
                await sleep(wait);
                return mhFetchPage(start, count, attempt + 1);
            }
            throw err;
        }
    }

    /**
     * 抓取交易记录 —— 支持断点续传。
     *
     * v1.6.8 之前有三个致命问题：局部 `const rows = []` 永远从 0 开始；
     * 刷新按钮无条件清空 mhState.rows；限流重试耗尽后 throw 掉全部进度元数据。
     * 现在改为：
     *   - 从 mhState.nextOffset 续传，复用已有 rows
     *   - 限流不再抛错：保存进度 + 进入冷却，状态栏明示「已存 N 条，M 秒后可继续」
     *   - 按 eventId 去重（见下面 start 推进的注释）
     *   - 每 2 页落盘一次，任何退出路径都会先落盘
     */
    async function mhFetchAll(opts) {
        opts = opts || {};
        if (mhState.fetching) return;

        // 已抓完：除非显式要求重建，否则不重复请求
        if (mhState.complete && !opts.force) {
            mhRefreshStatus();
            toast(`已索引全部 ${mhState.rows.length} 条记录，无需继续`, 'info');
            return;
        }
        // 限流冷却未到
        if (mhState.paused && mhState.nextAt && Date.now() < mhState.nextAt && !opts.force) {
            const left = Math.ceil((mhState.nextAt - Date.now()) / 1000);
            mhSetStatus(`限流冷却中，${Math.floor(left / 60)}:${String(left % 60).padStart(2, '0')} 后可继续`, 'err');
            toast(`Steam 仍在限流，${left} 秒后再试`, 'warning');
            return;
        }

        mhState.fetching = true;
        mhState.abort = false;
        mhState.paused = false;
        mhState.nextAt = 0;

        const size = mhPageSize();
        const delay = mhPageDelay();
        const rows = mhState.rows.slice();               // ← 续传：复用已有数据
        const seen = new Set(rows.map(mhRowKey));
        const appIdMap = new Map();
        let dateCursor = null;
        let total = mhState.totalCount || 0;
        let start = mhState.nextOffset || rows.length;
        let rateLimited = false;

        mhSetBusy(true);
        try {
            mhSetProgress(total ? rows.length / total : 0, true);
            if (rows.length) mhSetStatus(`从第 ${rows.length + 1} 条继续索引…`);

            while (true) {
                if (mhState.abort) break;
                if (total && start >= total) break;

                let data;
                try {
                    data = await mhFetchPage(start, size);
                } catch (err) {
                    if (err && err.code === SME_ERR.RATE_LIMITED) {
                        // 限流：保存断点 + 进入冷却，**不抛错**，保住已抓数据
                        rateLimited = true;
                        mhState.paused = true;
                        const cool = Math.min(MH_COOLDOWN_MAX, MH_COOLDOWN_BASE * Math.pow(2, mhState.coolStreak || 0));
                        mhState.coolStreak = (mhState.coolStreak || 0) + 1;
                        mhState.nextAt = Date.now() + cool;
                        mhState.nextOffset = start;
                        mhState.rows = rows;
                        mhState.totalCount = total || mhState.totalCount;
                        mhSaveCache(rows, total, start);
                        const left = Math.round(cool / 1000);
                        mhSetStatus(`触发 Steam 限流：已保存 ${rows.length} 条，${Math.floor(left / 60)}:${String(left % 60).padStart(2, '0')} 后可继续`, 'err');
                        toast(`触发限流，已保留 ${rows.length} 条；${left} 秒后点「继续」接着索引`, 'warning');
                        break;
                    }
                    throw err;
                }

                const batch = mhParseRows(data.results_html);
                const tc = parseInt(data.total_count, 10);
                if (!total && tc) total = tc;
                mhBuildAppIdMap(data.assets).forEach((v, k) => { if (!appIdMap.has(k)) appIdMap.set(k, v); });
                if (batch.length === 0) {
                    // 接口没有更多数据了：这就是可索引范围的终点。
                    // Steam 的 total_count 是**历史累计**总数，而该接口只开放有限窗口，
                    // 二者不等；此处以实际抓到的量为准，否则 complete 永远为 false，
                    // 「继续」按钮会陷入点了没进展的死循环。
                    total = rows.length;
                    break;
                }
                dateCursor = mhAssignTimestamps(batch, dateCursor);
                mhApplyAppIds(batch, appIdMap);

                // 去重：索引期间 Steam 可能新增交易，倒序列表整体后移，
                // 同一 start 再取会与已有数据重叠。按 eventId 去重可同时消除
                // 「重复 N 条」与「末尾漏 N 条」两个问题。
                let added = 0;
                for (const r of batch) {
                    const k = mhRowKey(r);
                    if (seen.has(k)) continue;
                    seen.add(k);
                    rows.push(r);
                    added++;
                }

                // 偏移按**接口返回条数**推进，不能按去重后的条数，
                // 否则重复一旦出现就会永久性偏移。
                start += batch.length;
                mhState.rows = rows;
                mhState.totalCount = total || mhState.totalCount;
                mhState.nextOffset = start;
                mhState.fetchedAt = Date.now();
                mhSetStatus(`已索引 ${rows.length} / ${total || '?'} 条…`);
                mhSetProgress(total ? rows.length / total : 0);

                if (total && rows.length >= total) break;
                if (batch.length < size) {
                    // 末页不足一页 = 接口已到边界，同上以实抓量为准
                    total = rows.length;
                    break;
                }

                // 每 2 页落盘一次（原先 5 页，限流时最多丢 400 条）
                if (Math.floor(start / size) % 2 === 0) mhSaveCache(rows, total, start);
                await sleep(delay);
            }

            mhState.nextOffset = start;
            mhState.rows = rows;
            mhState.totalCount = Math.max(total, rows.length);
            if (!rateLimited) {
                mhState.complete = rows.length >= mhState.totalCount;
                if (mhState.complete) { mhState.coolStreak = 0; mhSetProgress(1, false); }
            }
            mhApplyAppIds(rows, appIdMap);
            mhSaveCache(rows, mhState.totalCount, start);

            if (!rateLimited && !mhState.abort) {
                if (mhState.complete) {
                    mhSetStatus(`索引完成，共 ${rows.length} 条记录`, 'ok');
                    toast(`已索引全部 ${rows.length} 条市场交易记录`, 'success');
                } else {
                    mhSetStatus(`已索引 ${rows.length} / ${mhState.totalCount} 条`, 'ok');
                }
            } else if (mhState.abort) {
                mhSetStatus(`已停止，保留 ${rows.length} / ${mhState.totalCount} 条`, 'ok');
            }
        } catch (err) {
            // 非限流错误：同样先落盘再上报，已抓数据不丢
            W('Market history fetch failed:', err);
            mhState.nextOffset = start;
            mhState.rows = rows;
            mhState.totalCount = total || mhState.totalCount;
            mhSaveCache(rows, mhState.totalCount, start);
            mhSetProgress(total ? rows.length / total : 0, false);
            mhSetStatus(`抓取中断：${friendlyError(err)}（已保留 ${rows.length} 条）`, 'err');
            toast('抓取交易记录失败：' + friendlyError(err), 'error');
        } finally {
            mhState.fetching = false;
            mhSetBusy(false);
            mhRefreshStatus();
        }
    }

    // ---------- 汇总 ----------
    function mhSummarize(rows) {
        const s = {
            count: rows.length,
            sold: { count: 0, grossCents: 0, feeCents: 0, netCents: 0 },
            bought: { count: 0, grossCents: 0 },
            other: 0,
            firstTs: 0, lastTs: 0,
            byItem: [], byGame: [], byMonth: [],
        };
        const items = new Map(), games = new Map(), months = new Map();
        let first = Infinity, last = 0;

        for (const r of rows) {
            const ts = r.tradeTs || r.listedTs || 0;
            if (ts) { if (ts < first) first = ts; if (ts > last) last = ts; }

            let net = 0;
            if (r.action === 'sold') {
                s.sold.count++;
                s.sold.grossCents += r.priceCents;
                net = priceBeforeFees(r.priceCents);
                s.sold.netCents += net;
                s.sold.feeCents += (r.priceCents - net);
            } else if (r.action === 'bought') {
                s.bought.count++;
                s.bought.grossCents += r.priceCents;
            } else s.other++;

            let it = items.get(r.name);
            if (!it) {
                it = { name: r.name, game: r.game, count: 0, soldCount: 0, boughtCount: 0, soldCents: 0, boughtCents: 0, netCents: 0 };
                items.set(r.name, it);
            }
            it.count++;
            if (r.action === 'sold') { it.soldCount++; it.soldCents += r.priceCents; it.netCents += net; }
            else if (r.action === 'bought') { it.boughtCount++; it.boughtCents += r.priceCents; }

            const gk = r.game || '未知游戏';
            let g = games.get(gk);
            if (!g) { g = { game: gk, count: 0, soldCount: 0, boughtCount: 0, soldCents: 0, boughtCents: 0 }; games.set(gk, g); }
            g.count++;
            if (r.action === 'sold') { g.soldCount++; g.soldCents += r.priceCents; }
            else if (r.action === 'bought') { g.boughtCount++; g.boughtCents += r.priceCents; }

            const mk = mhMonthKey(ts);
            if (mk) {
                let mo = months.get(mk);
                if (!mo) { mo = { month: mk, count: 0, soldCount: 0, boughtCount: 0, soldCents: 0, boughtCents: 0, feeCents: 0, netCents: 0 }; months.set(mk, mo); }
                mo.count++;
                if (r.action === 'sold') {
                    mo.soldCount++;
                    mo.soldCents += r.priceCents;
                    mo.feeCents += (r.priceCents - net);
                } else if (r.action === 'bought') { mo.boughtCount++; mo.boughtCents += r.priceCents; }
            }
        }

        s.firstTs = first === Infinity ? 0 : first;
        s.lastTs = last;
        s.grossCents = s.sold.grossCents - s.bought.grossCents;
        s.netCents = s.sold.netCents - s.bought.grossCents;

        const topN = Math.max(5, Math.min(100, parseInt(settings.get('marketHistoryTopN'), 10) || 20));
        const amt = (x) => (x.soldCents + x.boughtCents);
        s.byItem = [...items.values()].sort((a, b) => amt(b) - amt(a) || b.count - a.count).slice(0, topN);
        s.byGame = [...games.values()].sort((a, b) => b.count - a.count);
        s.byMonth = [...months.values()].sort((a, b) => (a.month < b.month ? 1 : -1)).map(mhFinishMonth);
        mhDecorate(s, rows);
        return s;
    }

    // ---------- 衍生统计（v1.6.1） ----------
    // 参考 Steam-License-Classifier / Steam-Spending-History-Classifier 的分析维度，
    // 在原有收支汇总之上补充趋势、分布、日历热力所需的派生数据。

    function mhMedian(nums) {
        if (!nums.length) return 0;
        const a = [...nums].sort((x, y) => x - y);
        const m = a.length >> 1;
        return a.length % 2 ? a[m] : Math.round((a[m - 1] + a[m]) / 2);
    }

    /** 挂单 → 成交的持有时长（仅统计同时有上架与交易时间的记录） */
    function mhHoldStats(rows) {
        const spans = [];
        for (const r of rows) {
            if (r.action !== 'sold') continue;
            if (!r.tradeTs || !r.listedTs || r.listedTs <= 0) continue;
            const d = r.tradeTs - r.listedTs;
            if (d >= 0) spans.push(d);
        }
        if (!spans.length) return { count: 0, avgMs: 0, medianMs: 0, minMs: 0, maxMs: 0 };
        const total = spans.reduce((a, b) => a + b, 0);
        return {
            count: spans.length,
            avgMs: Math.round(total / spans.length),
            medianMs: mhMedian(spans),
            minMs: Math.min(...spans),
            maxMs: Math.max(...spans),
        };
    }

    /** 人性化时长，如 "3 天 4 小时" */
    function mhFmtDuration(ms) {
        if (!ms || ms < 0) return '-';
        const min = Math.floor(ms / 60000);
        if (min < 60) return min + ' 分钟';
        const h = Math.floor(min / 60);
        if (h < 24) return h + ' 小时';
        const d = Math.floor(h / 24);
        if (d < 30) return d + ' 天' + (h % 24 ? ' ' + (h % 24) + ' 小时' : '');
        const mo = Math.floor(d / 30);
        if (mo < 12) return mo + ' 个月';
        return Math.floor(mo / 12) + ' 年';
    }

    const MH_DAY_MS = 86400000;

    function mhDayKey(ts) {
        if (!ts) return '';
        const d = new Date(ts);
        return d.getFullYear() + '-' + String(d.getMonth() + 1).padStart(2, '0') + '-' + String(d.getDate()).padStart(2, '0');
    }

    /** 每日聚合（日历热力图与明细筛选共用） */
    function mhDaily(rows) {
        const map = new Map();
        for (const r of rows) {
            const ts = r.tradeTs || r.listedTs || 0;
            if (!ts) continue;
            const key = mhDayKey(ts);
            let d = map.get(key);
            if (!d) {
                d = { day: key, count: 0, soldCount: 0, boughtCount: 0, soldCents: 0, boughtCents: 0, feeCents: 0 };
                map.set(key, d);
            }
            d.count++;
            if (r.action === 'sold') {
                d.soldCount++;
                d.soldCents += r.priceCents;
                const net = priceBeforeFees(r.priceCents);
                d.feeCents += (r.priceCents - net);
            } else if (r.action === 'bought') {
                d.boughtCount++;
                d.boughtCents += r.priceCents;
            }
        }
        return [...map.values()].sort((a, b) => a.day.localeCompare(b.day));
    }

    /**
     * 月度序列：趋势折线的数据源。
     * gap 为 0 时只输出有数据的月份；否则补齐中间空月，折线才不会把
     * 跨越半年的两笔交易连成一条误导性的直线。
     */
    /** 月度桶收尾：净额 = 卖出 - 估算手续费 - 买入 */
    function mhFinishMonth(m) {
        m.netCents = m.soldCents - m.feeCents - m.boughtCents;
        return m;
    }

    function mhMonthlySeries(rows, gap) {
        const map = new Map();
        for (const r of rows) {
            const ts = r.tradeTs || r.listedTs || 0;
            if (!ts) continue;
            const key = mhMonthKey(ts);
            let m = map.get(key);
            if (!m) {
                m = { month: key, count: 0, soldCount: 0, boughtCount: 0, soldCents: 0, boughtCents: 0, feeCents: 0, netCents: 0 };
                map.set(key, m);
            }
            m.count++;
            if (r.action === 'sold') {
                m.soldCount++;
                m.soldCents += r.priceCents;
                m.feeCents += (r.priceCents - priceBeforeFees(r.priceCents));
            } else if (r.action === 'bought') {
                m.boughtCount++;
                m.boughtCents += r.priceCents;
            }
        }
        let list = [...map.values()].sort((a, b) => a.month.localeCompare(b.month));
        if (!gap || list.length < 2) {
            // 稀疏路径同样要给出净额，否则趋势/导出拿到的 byMonth 净额恒为 0
            list.forEach(mhFinishMonth);
            return list;
        }
        // 补齐空月
        const filled = [];
        const [y0, m0] = list[0].month.split('-').map(Number);
        const [y1, m1] = list[list.length - 1].month.split('-').map(Number);
        let y = y0, mo = m0;
        const blank = (key) => mhFinishMonth({ month: key, count: 0, soldCount: 0, boughtCount: 0, soldCents: 0, boughtCents: 0, feeCents: 0, netCents: 0, empty: true });
        const lookup = new Map(list.map((x) => [x.month, x]));
        while (y < y1 || (y === y1 && mo <= m1)) {
            const key = y + '-' + String(mo).padStart(2, '0');
            filled.push(lookup.get(key) || blank(key));
            mo++;
            if (mo > 12) { mo = 1; y++; }
        }
        filled.forEach(mhFinishMonth);
        return filled;
    }

    /**
     * 价格区间分布（**对数分档**）。
     * 市场成交价通常跨 3–4 个数量级（实测 ₹0.01 ~ ₹1826.81）。
     * 等宽分档会把 99.9% 的样本挤进第一档（实测 5263/5266 落在 ₹0.01–₹228），
     * 直方图完全失真。这里按 10 的幂次分档，每档再按 √10 细分两档（≈半十进位）。
     */
    function mhPriceBuckets(rows) {
        const prices = rows.filter((r) => r.priceCents > 0).map((r) => r.priceCents);
        if (!prices.length) return [];
        const min = Math.min(...prices), max = Math.max(...prices);
        if (max === min) return [{ from: min, to: max, count: prices.length }];

        const loE = Math.floor(Math.log10(Math.max(1, min)));
        const hiE = Math.ceil(Math.log10(max));
        const SUB = Math.sqrt(10);   // ≈3.16，半十进位
        const edges = [];
        for (let e = loE; e <= hiE; e++) {
            const base = Math.pow(10, e);
            edges.push(Math.max(1, Math.round(base)));
            if (e < hiE) edges.push(Math.max(1, Math.round(base * SUB)));
        }
        edges.push(Math.round(max));
        edges.sort((a, b) => a - b);
        // 去重后构造分档
        const uniq = edges.filter((v, i, arr) => i === 0 || v > arr[i - 1]);
        const buckets = [];
        for (let i = 0; i < uniq.length - 1; i++) {
            buckets.push({ from: uniq[i], to: uniq[i + 1], count: 0 });
        }
        for (const p of prices) {
            let idx = buckets.length - 1;
            for (let i = 0; i < buckets.length; i++) {
                if (p < buckets[i].to) { idx = i; break; }
            }
            buckets[idx].count++;
        }
        return buckets.filter((b, i) => b.count > 0 || i === 0 || i === buckets.length - 1);
    }

    /** 在基础汇总上补充均价/中位价/极值/持有时长/日活等派生指标 */
    function mhDecorate(s, rows) {
        const soldPrices = rows.filter((r) => r.action === 'sold' && r.priceCents > 0).map((r) => r.priceCents);
        const boughtPrices = rows.filter((r) => r.action === 'bought' && r.priceCents > 0).map((r) => r.priceCents);

        s.avgSoldCents = soldPrices.length ? Math.round(s.sold.grossCents / soldPrices.length) : 0;
        s.avgBoughtCents = boughtPrices.length ? Math.round(s.bought.grossCents / boughtPrices.length) : 0;
        s.medianSoldCents = mhMedian(soldPrices);
        s.maxSoldCents = soldPrices.length ? Math.max(...soldPrices) : 0;
        s.minSoldCents = soldPrices.length ? Math.min(...soldPrices) : 0;

        s.hold = mhHoldStats(rows);
        s.daily = mhDaily(rows);
        s.priceBuckets = mhPriceBuckets(rows);

        // 活跃天数与日均
        s.activeDays = s.daily.length;
        const spanDays = s.firstTs && s.lastTs
            ? Math.max(1, Math.round((s.lastTs - s.firstTs) / MH_DAY_MS) + 1) : 1;
        s.spanDays = spanDays;
        s.perDay = Math.round((s.count / spanDays) * 100) / 100;
        s.perMonth = Math.round((s.count / Math.max(1, spanDays / 30)) * 100) / 100;

        // 每物品均价补充到 byItem
        const priceByItem = new Map();
        for (const r of rows) {
            if (r.action !== 'sold' || r.priceCents <= 0) continue;
            if (!priceByItem.has(r.name)) priceByItem.set(r.name, []);
            priceByItem.get(r.name).push(r.priceCents);
        }
        for (const it of s.byItem) {
            const ps = priceByItem.get(it.name) || [];
            it.avgSoldCents = ps.length ? Math.round(it.soldCents / ps.length) : 0;
            it.medianSoldCents = mhMedian(ps);
        }

        // ROI：卖出净收入 / 买入总额（无买入时为 null，避免除零与误导）
        s.roi = s.bought.grossCents > 0
            ? Math.round((s.sold.netCents / s.bought.grossCents) * 10000) / 100
            : null;
        return s;
    }

    // ---------- 导出 ----------
    function mhCsvCell(v) {
        const s = v == null ? '' : String(v);
        return /[",\n\r]/.test(s) ? '"' + s.replace(/"/g, '""') + '"' : s;
    }

    function mhMarketUrl(r) {
        if (!r.appId) return '';
        return `https://steamcommunity.com/market/listings/${r.appId}/${encodeURIComponent(r.name)}`;
    }

    function mhToCsv(rows, summary) {
        const wi = getWalletInfo();
        const code = wi.currency_code || 'USD';
        const lines = [[
            '序号', '事件ID', '挂单ID', '物品名称', '游戏', 'AppID', '类型', '状态',
            '价格原文', '价格', '币种', '交易日期原文', '交易时间', '上架日期原文', '上架时间',
            '对手方', '市场链接', '图片链接',
        ].map(mhCsvCell).join(',')];

        rows.forEach((r, i) => {
            lines.push([
                i + 1, r.eventId, r.listingId, r.name, r.game, r.appId || '', r.actionLabel,
                r.pending ? '待处理' : '', r.priceText, (r.priceCents / 100).toFixed(2), code,
                r.tradeDateText, mhFmtTs(r.tradeTs), r.listedDateText, mhFmtTs(r.listedTs),
                r.counterpart || '', mhMarketUrl(r), r.image || '',
            ].map(mhCsvCell).join(','));
        });

        // 末尾附汇总区块，方便直接在表格软件里核对数字
        const money = (c) => (c / 100).toFixed(2);
        lines.push('');
        lines.push(['汇总（由 Steam 社区市场增强生成）'].map(mhCsvCell).join(','));
        lines.push(['记录总数', rows.length].map(mhCsvCell).join(','));
        lines.push(['卖出笔数', summary.sold.count].map(mhCsvCell).join(','));
        lines.push(['卖出总额', money(summary.sold.grossCents), code].map(mhCsvCell).join(','));
        lines.push(['估算手续费', money(summary.sold.feeCents), code].map(mhCsvCell).join(','));
        lines.push(['卖出净收入', money(summary.sold.netCents), code].map(mhCsvCell).join(','));
        lines.push(['买入笔数', summary.bought.count].map(mhCsvCell).join(','));
        lines.push(['买入总额', money(summary.bought.grossCents), code].map(mhCsvCell).join(','));
        lines.push(['净收益', money(summary.netCents), code].map(mhCsvCell).join(','));

        // 前置 BOM，保证 Excel 正确识别 UTF-8 中文
        return '\ufeff' + lines.join('\r\n');
    }

    function mhToJson(rows, summary) {
        const wi = getWalletInfo();
        const code = wi.currency_code || 'USD';
        const money = (c) => Math.round(c) / 100;
        return JSON.stringify({
            meta: {
                generator: 'Steam 社区市场增强 v' + VERSION,
                generatedAt: new Date().toISOString(),
                source: 'https://steamcommunity.com/market/myhistory/render/',
                steamId: getSteamId() || null,
                currency: code,
                walletCurrencyId: wi.wallet_currency,
                recordCount: rows.length,
                steamTotalCount: mhState.totalCount,
                truncated: rows.length < mhState.totalCount,
                indexedAt: mhState.fetchedAt ? new Date(mhState.fetchedAt).toISOString() : null,
                note: 'Steam 历史记录表格不返回年份，时间戳由倒序分页跨年推断得出。',
            },
            summary: {
                total: summary.count,
                sold: {
                    count: summary.sold.count,
                    gross: money(summary.sold.grossCents),
                    estimatedFee: money(summary.sold.feeCents),
                    net: money(summary.sold.netCents),
                },
                bought: { count: summary.bought.count, gross: money(summary.bought.grossCents) },
                other: summary.other,
                grossProfit: money(summary.grossCents),
                netProfit: money(summary.netCents),
                period: {
                    from: summary.firstTs ? new Date(summary.firstTs).toISOString() : null,
                    to: summary.lastTs ? new Date(summary.lastTs).toISOString() : null,
                    spanDays: summary.spanDays,
                    activeDays: summary.activeDays,
                },
                avgSold: money(summary.avgSoldCents),
                avgBought: money(summary.avgBoughtCents),
                medianSold: money(summary.medianSoldCents),
                maxSold: money(summary.maxSoldCents),
                minSold: money(summary.minSoldCents),
                perDay: summary.perDay,
                perMonth: summary.perMonth,
                roi: summary.roi,
                holdDuration: summary.hold ? {
                    samples: summary.hold.count,
                    avgMs: summary.hold.avgMs,
                    medianMs: summary.hold.medianMs,
                    minMs: summary.hold.minMs,
                    maxMs: summary.hold.maxMs,
                } : null,
            },
            byItem: summary.byItem.map(x => ({
                name: x.name, game: x.game, count: x.count,
                soldCount: x.soldCount, boughtCount: x.boughtCount,
                soldTotal: money(x.soldCents), boughtTotal: money(x.boughtCents), net: money(x.netCents),
                avgSold: money(x.avgSoldCents), medianSold: money(x.medianSoldCents),
            })),
            byGame: summary.byGame.map(x => ({
                game: x.game, count: x.count,
                soldCount: x.soldCount, boughtCount: x.boughtCount,
                soldTotal: money(x.soldCents), boughtTotal: money(x.boughtCents),
            })),
            byMonth: summary.byMonth.map(x => ({
                month: x.month, count: x.count,
                soldCount: x.soldCount, boughtCount: x.boughtCount,
                soldTotal: money(x.soldCents), boughtTotal: money(x.boughtCents),
                fee: money(x.feeCents), net: money(x.netCents),
            })),
            byDay: summary.daily.map(x => ({
                day: x.day, count: x.count,
                soldCount: x.soldCount, boughtCount: x.boughtCount,
                soldTotal: money(x.soldCents), boughtTotal: money(x.boughtCents),
                fee: money(x.feeCents),
            })),
            priceBuckets: summary.priceBuckets.map(b => ({
                from: money(b.from), to: money(b.to), count: b.count,
            })),
            transactions: rows.map(r => ({
                eventId: r.eventId,
                listingId: r.listingId,
                name: r.name,
                game: r.game,
                appId: r.appId || null,
                action: r.action,
                actionLabel: r.actionLabel,
                price: money(r.priceCents),
                priceText: r.priceText,
                pending: !!r.pending,
                tradeDateText: r.tradeDateText,
                tradeTime: mhFmtTs(r.tradeTs) || null,
                tradeTimestamp: r.tradeTs || null,
                listedDateText: r.listedDateText,
                listedTime: mhFmtTs(r.listedTs) || null,
                listedTimestamp: r.listedTs || null,
                counterpart: r.counterpart || null,
                marketUrl: mhMarketUrl(r) || null,
                image: r.image || null,
            })),
        }, null, 2);
    }

    function mhDownload(filename, content, mime) {
        const blob = new Blob([content], { type: mime + ';charset=utf-8' });
        const url = URL.createObjectURL(blob);
        const a = h('a', { href: url, download: filename });
        document.body.appendChild(a);
        a.click();
        setTimeout(() => { a.remove(); URL.revokeObjectURL(url); }, 1500);
    }

    // ---------- 附加导出格式（v1.6.1） ----------

    /** TSV：制表符分隔，Excel/Sheets 双击直开，字段内换行与制表符会被转义 */
    function mhToTsv(rows) {
        const cell = (v) => {
            const s = v == null ? '' : String(v);
            return /[\t\r\n]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s;
        };
        const head = ['序号', '事件ID', '挂单ID', '物品名称', '游戏', 'AppID', '类型', '状态',
            '价格原文', '价格', '币种', '交易日期原文', '交易时间', '上架日期原文', '上架时间',
            '对手方', '市场链接', '图片链接'];
        const lines = [head.join('\t')];
        rows.forEach((r, i) => {
            lines.push([
                i + 1, r.eventId, r.listingId, r.name, r.game, r.appId || '', r.actionLabel,
                r.pending ? '待处理' : '', r.priceText, (r.priceCents / 100).toFixed(2), mhCurrencyCode(),
                r.tradeDateText, mhFmtTs(r.tradeTs), r.listedDateText, mhFmtTs(r.listedTs),
                r.counterpart || '', mhMarketUrl(r), r.image || '',
            ].map(cell).join('\t'));
        });
        return '\ufeff' + lines.join('\r\n');
    }

    /** Markdown 报告：统计卡 + 榜单 + 月度表 + 明细表，便于贴到笔记/issue */
    function mhToMarkdown(rows, summary) {
        const code = mhCurrencyCode();
        const money = (c) => formatCentsStr(c, code);
        const m = (c) => (Math.round(c) / 100).toFixed(2);
        const period = summary.firstTs
            ? `${mhFmtTs(summary.firstTs).slice(0, 10)} ~ ${mhFmtTs(summary.lastTs).slice(0, 10)}`
            : '未知';
        const L = [];
        L.push(`# Steam 市场交易记录汇总`);
        L.push('');
        L.push(`> 由 Steam 社区市场增强 v${VERSION} 生成 · ${new Date().toLocaleString('zh-CN', { hour12: false })}`);
        L.push(`> 统计区间：${period} · 币种：${code} · 记录：${rows.length} 条`);
        L.push('');
        L.push('## 总体');
        L.push('');
        L.push('| 指标 | 数值 |');
        L.push('| --- | --- |');
        L.push(`| 卖出笔数 | ${summary.sold.count} |`);
        L.push(`| 卖出总额 | ${money(summary.sold.grossCents)} |`);
        L.push(`| 估算手续费 | ${money(summary.sold.feeCents)} |`);
        L.push(`| 卖出净收入 | ${money(summary.sold.netCents)} |`);
        L.push(`| 买入笔数 | ${summary.bought.count} |`);
        L.push(`| 买入总额 | ${money(summary.bought.grossCents)} |`);
        L.push(`| 净收益 | ${money(summary.netCents)} |`);
        L.push(`| 卖出均价 / 中位价 | ${money(summary.avgSoldCents)} / ${money(summary.medianSoldCents)} |`);
        L.push(`| 最高 / 最低成交 | ${money(summary.maxSoldCents)} / ${money(summary.minSoldCents)} |`);
        L.push(`| 平均持有时长 | ${mhFmtDuration(summary.hold.avgMs)}（中位 ${mhFmtDuration(summary.hold.medianMs)}，样本 ${summary.hold.count}） |`);
        L.push(`| 活跃天数 / 日均笔数 | ${summary.activeDays} / ${summary.perDay} |`);
        if (summary.roi !== null) L.push(`| ROI（净收入 ÷ 买入额） | ${summary.roi}% |`);
        L.push('');
        if (summary.byItem.length) {
            L.push(`## 按物品 Top ${summary.byItem.length}`);
            L.push('');
            L.push('| # | 物品 | 游戏 | 笔数 | 卖出 | 买入 | 卖出金额 | 均价 |');
            L.push('| --- | --- | --- | ---: | ---: | ---: | ---: | ---: |');
            summary.byItem.forEach((it, i) => {
                L.push(`| ${i + 1} | ${mdCell(it.name)} | ${mdCell(it.game)} | ${it.count} | ${it.soldCount} | ${it.boughtCount} | ${it.soldCents ? money(it.soldCents) : ''} | ${it.avgSoldCents ? money(it.avgSoldCents) : ''} |`);
            });
            L.push('');
        }
        if (summary.byMonth.length) {
            L.push('## 按月份');
            L.push('');
            L.push('| 月份 | 笔数 | 卖出 | 买入 | 卖出金额 | 手续费 | 净额 |');
            L.push('| --- | ---: | ---: | ---: | ---: | ---: | ---: |');
            for (const x of summary.byMonth) {
                L.push(`| ${x.month} | ${x.count} | ${x.soldCount} | ${x.boughtCount} | ${m(x.soldCents)} | ${m(x.feeCents)} | ${m(x.netCents)} |`);
            }
            L.push('');
        }
        L.push('## 明细');
        L.push('');
        // v1.6.6：按 500 行分段输出。5266 行挤在单个 <table> 里，
        // markdown-reader 会一次性生成 4 万多个 <td>，预览明显卡顿；
        // 部分渲染器还会截断超长表格。分段后每段独立成表，观感与性能都更好。
        const CHUNK = 500;
        const headRow = '| # | 物品 | 游戏 | 类型 | 价格 | 交易时间 | 上架时间 |';
        const sepRow = '| --- | --- | --- | --- | ---: | --- | --- |';
        const totalChunks = Math.max(1, Math.ceil(rows.length / CHUNK));
        for (let c = 0; c < rows.length; c += CHUNK) {
            const part = rows.slice(c, c + CHUNK);
            if (totalChunks > 1) L.push(`### 第 ${Math.floor(c / CHUNK) + 1} / ${totalChunks} 段（第 ${c + 1} - ${c + part.length} 条）`);
            L.push('');
            L.push(headRow);
            L.push(sepRow);
            part.forEach((r, k) => {
                const i = c + k;
                L.push(`| ${i + 1} | ${mdCell(r.name)} | ${mdCell(r.game)} | ${r.actionLabel} | ${r.priceCents ? m(r.priceCents) : ''} | ${mhFmtTs(r.tradeTs) || '-'} | ${mhFmtTs(r.listedTs) || '-'} |`);
            });
            L.push('');
        }
        L.push('---');
        L.push('');
        L.push(`> 手续费按当前钱包费率估算，非 Steam 结算值。年份由倒序分页跨年推断得出，AppID 尽力匹配、可能为空。`);
        return L.join('\n');
    }

    /**
     * Markdown 单元格转义 —— 标准 GFM 反斜杠转义。
     *
     * 为什么用标准 `\|` 而不是实体 `&#124;`：
     * 历史上为了迁就 scripts-tools/markdown-reader 不认反斜杠的缺陷而改用实体，
     * 代价是源码视图里全是 `&#124;` 这类噪声。v1.6.7 起 reader 已支持标准转义，
     * 故回归 GFM 标准写法 —— 通用 Markdown 工具链（GitHub / VS Code / Obsidian /
     * marked.js 等）都认它，源码也更好读。
     *
     * 两条兼容保证：
     *   - 新导出（本函数，标准转义）→ 新 reader ✓
     *   - v1.6.6 之前的旧导出（实体 &#124;）→ 新 reader ✓（escapeHtml 保留已有实体）
     *
     * 字符分工：
     *   & < >    → HTML 实体（HTML 上下文，任何渲染器下都安全）
     *   其余语法符 → 反斜杠转义（Markdown 标准）
     *
     * 单次扫描完成映射，避免 & 先被转成 &amp; 后自己插入的实体又被二次编码。
     */
    const MD_CELL_ENTITIES = {
        '&': '&amp;',
        '<': '&lt;',
        '>': '&gt;',
    };
    const MD_CELL_ESCAPES = {
        '\\': '\\\\',
        '|': '\\|',
        '`': '\\`',
        '*': '\\*',
        '_': '\\_',
        '~': '\\~',
        '[': '\\[',
        ']': '\\]',
    };
    const MD_CELL_RE = /[&<>\\|`*_~[\]]/g;

    function mdCell(s) {
        const str = String(s == null ? '' : s);
        if (!str) return '';
        return str
            .replace(/\r\n?|\n/g, ' ')   // 换行会截断表格行
            .replace(MD_CELL_RE, (c) =>
                MD_CELL_ENTITIES[c] !== undefined ? MD_CELL_ENTITIES[c] : MD_CELL_ESCAPES[c]);
    }

    function mhCurrencyCode() {
        return getWalletInfo().currency_code || 'USD';
    }

    /**
     * 执行导出。
     * @param {object} opt
     *   format: 'csv' | 'tsv' | 'json' | 'md'
     *   rows:   导出的记录集，缺省为全部已索引记录
     *   label:  文件名后缀标注（如"筛选结果"）
     */
    function mhRunExport(opt) {
        opt = opt || {};
        const rows = opt.rows && opt.rows.length ? opt.rows : mhState.rows;
        if (rows.length === 0) { toast('没有可导出的记录', 'warning'); return false; }
        const format = opt.format || mhState.format || 'csv';
        const summary = mhSummarize(rows);
        const stamp = new Date().toISOString().slice(0, 19).replace(/[:T]/g, '-');
        const suffix = opt.label ? '-' + opt.label : '';
        const base = `steam-market-history${suffix}-${stamp}`;
        const ext = { csv: 'csv', tsv: 'tsv', json: 'json', md: 'md' }[format] || 'csv';
        const mime = {
            csv: 'text/csv', tsv: 'text/tab-separated-values',
            json: 'application/json', md: 'text/markdown',
        }[format] || 'text/csv';
        const content = {
            csv: () => mhToCsv(rows, summary),
            tsv: () => mhToTsv(rows),
            json: () => mhToJson(rows, summary),
            md: () => mhToMarkdown(rows, summary),
        }[format]();
        mhDownload(`${base}.${ext}`, content, mime);
        toast(`已导出 ${rows.length} 条记录（${format.toUpperCase()}）`, 'success');
        return true;
    }

    /** 确保已索引数据：必要时先征得用户同意再抓取 */
    async function mhEnsureData(actionName) {
        if (mhState.fetching) { toast('正在抓取中，请稍候…', 'info'); return false; }
        if (mhState.rows.length > 0) return true;
        const total = mhState.totalCount;
        const est = mhEstimateSeconds();
        const detail = total
            ? `共 <strong>${total}</strong> 条记录，每页 ${mhPageSize()} 条逐页抓取，预计约 <strong>${est}</strong> 秒。`
            : '记录较多时可能需要数分钟。抓取期间请勿切换页面。';
        const ok = await showConfirmDialog(
            `${actionName}前需要先向 Steam 抓取交易记录。<br><br>`
            + `<span style="color:var(--sme-text-dim)">${detail}</span><br>`
            + `<span style="color:var(--sme-text-muted);font-size:12px">抓取结果会缓存在本地 12 小时内，导出与汇总都基于该缓存。</span>`,
            { title: '抓取市场交易记录', okText: '开始抓取', okClass: 'sme-dialog-blue' }
        );
        if (!ok) return false;
        await mhFetchAll();
        return mhState.rows.length > 0;
    }

    // ---------- 分析窗口（v1.6.1） ----------
    // 结构参考 Steam-License-Classifier 的 ensureAnalysisShell / activateAnalysisPanel
    // （顶部标签栏 + 记住上次标签 + 标题栏主题色跟随）与 Steam-Spending-History-Classifier
    // 的 renderModal 通用面板渲染器；图表部分参考其 buildGrid / 折线 / 环形 / 日历热力。
    // v1.6.5：榜单从概览页拆出为独立「排行」页。
    // 概览页此前把 13+ 张卡 + 两张图表 + 一张可内部滚动的 Top20 表格塞在一起，
    // 外层 .sme-mh-panels 与内层 .sme-mh-table-wrap 同时可滚，出现双滚动条且页面极长。
    const MH_TABS = [
        { prefix: 'overview', icon: 'chart', label: '概览', title: '概览', color: '#66c0f4' },
        { prefix: 'trend', icon: 'trendingUp', label: '趋势', title: '交易曲线趋势', color: '#4caf50' },
        { prefix: 'rank', icon: 'queue', label: '排行', title: '成交排行 Top 20', color: '#38bdf8' },
        { prefix: 'calendar', icon: 'calendar', label: '日历', title: '交易日历热力', color: '#8b5cf6' },
        { prefix: 'ledger', icon: 'list', label: '明细', title: '交易明细', color: '#3b82f6' },
        { prefix: 'export', icon: 'download', label: '导出', title: '导出数据', color: '#10b981' },
        { prefix: 'inventory', icon: 'dollarSign', label: '库存浮盈', title: '全库存浮盈浮亏', color: '#22c55e' },
        { prefix: 'cooldown', icon: 'clock', label: '交易冷却', title: '交易冷却可视化', color: '#f59e0b' },
    ];
    const MH_LEDGER_PAGE = 50;

    const mhUi = {
        lastTab: 'overview',
        trendMetric: 'amount',      // amount | count
        trendCumulative: false,
        // v1.6.5：排行页的分组维度与排序依据
        rankDim: 'item',         // item | game | month
        rankSort: 'amount',      // amount | count
        // v1.6.3：默认全选。金额与笔数分列左右双轴，全选也能读
        trendSeries: { soldCents: true, boughtCents: true, netCents: true, feeCents: true, count: true },
        ledgerType: 'all',
        ledgerDim: 'all',        // all | game | item | month（维度筛选，替代下拉框）
        ledgerValue: '',
        ledgerQuery: '',
        ledgerSort: 'tradeTs',
        ledgerDesc: true,
        ledgerPage: 1,
        exportFormat: null,         // null = 跟随工具条选择
    };

    let _mhShell = null;
    const _mhMeta = {};

    function mhTabIcon(name) {
        return ICONS[name] || ICONS.chart;
    }

    function ensureMhShell() {
        if (_mhShell) return _mhShell;
        const modal = document.createElement('div');
        modal.id = 'sme-mh-modal';
        modal.className = 'sme-mh-modal';
        const tabsHtml = MH_TABS.map((t) =>
            `<button class="sme-mh-tab" data-tab="${t.prefix}" style="--c:${t.color};--cb:${t.color}26">`
            + `${mhTabIcon(t.icon)}<span>${escapeHtml(t.label)}</span></button>`).join('');
        modal.innerHTML = `
            <div class="sme-mh-win" role="dialog" aria-modal="true" aria-label="市场交易记录分析">
                <div class="sme-mh-win-header" id="sme-mh-header">
                    <div class="sme-mh-win-title">
                        <span class="sme-mh-win-ico" id="sme-mh-hi"></span>
                        <span id="sme-mh-ht"></span>
                        <span class="sme-mh-win-sub">市场交易记录</span>
                    </div>
                    <button class="sme-mh-win-close" id="sme-mh-close" aria-label="关闭">${ICONS.close}</button>
                </div>
                <div class="sme-mh-win-body">
                    <div class="sme-mh-tabs">${tabsHtml}</div>
                    <div class="sme-mh-panels" id="sme-mh-panels"></div>
                    <div class="sme-mh-mf">${ICONS.alert}<span id="sme-mh-note" class="sme-mh-mf-t"></span></div>
                </div>
            </div>`;
        document.body.appendChild(modal);

        const hide = () => modal.classList.remove('visible');
        modal.addEventListener('click', (e) => { if (e.target === modal) hide(); });
        modal.querySelector('#sme-mh-close').addEventListener('click', hide);
        // 阻止滚轮穿透到页面
        modal.querySelector('.sme-mh-win').addEventListener('wheel', (e) => e.stopPropagation(), { passive: true });
        modal.querySelectorAll('.sme-mh-tab').forEach((btn) => {
            btn.addEventListener('click', (e) => {
                e.stopPropagation();
                mhShowPanel(btn.dataset.tab);
            });
        });
        const onKey = (e) => {
            if (e.key === 'Escape') { e.stopPropagation(); hide(); }
            else if (e.key === 'Tab') {
                const items = [...modal.querySelectorAll('button')].filter((b) => b.offsetParent !== null);
                if (!items.length) return;
                const idx = items.indexOf(document.activeElement);
                const next = e.shiftKey
                    ? items[(idx <= 0 ? items.length : idx) - 1]
                    : items[(idx + 1) % items.length];
                e.preventDefault();
                if (next) next.focus();
            }
        };
        document.addEventListener('keydown', onKey, true);
        modal._dispose = () => document.removeEventListener('keydown', onKey, true);

        _mhShell = {
            modal,
            panelsEl: modal.querySelector('#sme-mh-panels'),
            iconEl: modal.querySelector('#sme-mh-hi'),
            titleEl: modal.querySelector('#sme-mh-ht'),
            noteEl: modal.querySelector('#sme-mh-note'),
            headerEl: modal.querySelector('#sme-mh-header'),
        };
        return _mhShell;
    }

    function activateMhPanel(prefix) {
        const shell = ensureMhShell();
        const tab = MH_TABS.find((t) => t.prefix === prefix) || MH_TABS[0];
        const meta = _mhMeta[prefix] || {};
        shell.modal.classList.add('visible');
        shell.panelsEl.querySelectorAll('.sme-mh-view').forEach((p) => p.classList.toggle('active', p.dataset.panel === prefix));
        shell.modal.querySelectorAll('.sme-mh-tab').forEach((b) => b.classList.toggle('active', b.dataset.tab === prefix));
        shell.headerEl.style.background = `linear-gradient(135deg,${tab.color}26,rgba(13,15,21,0.9))`;
        shell.headerEl.style.borderBottomColor = `${tab.color}40`;
        shell.iconEl.style.color = tab.color;
        shell.iconEl.innerHTML = mhTabIcon(tab.icon);
        shell.titleEl.textContent = meta.title || tab.title;
        shell.noteEl.textContent = meta.note || '';
        mhUi.lastTab = prefix;
    }

    /** 通用面板渲染器：建/复用面板 → 写 HTML → postRender → 显示并激活 */
    function mhRenderPane(prefix, note, buildFn, postRender) {
        const shell = ensureMhShell();
        const tab = MH_TABS.find((t) => t.prefix === prefix) || MH_TABS[0];
        _mhMeta[prefix] = { title: tab.title, note: note };
        let panel = shell.panelsEl.querySelector(`.sme-mh-view[data-panel="${prefix}"]`);
        if (!panel) {
            panel = document.createElement('div');
            panel.className = 'sme-mh-view';
            panel.dataset.panel = prefix;
            const body = document.createElement('div');
            body.className = 'sme-mh-pbody';
            body.id = `sme-mh-${prefix}-body`;
            panel.appendChild(body);
            shell.panelsEl.appendChild(panel);
        }
        const bodyEl = panel.querySelector('.sme-mh-pbody');
        // 面板重建前清理上一轮注册的事件
        if (bodyEl._cleanup) { try { bodyEl._cleanup(); } catch (e) {} bodyEl._cleanup = null; }
        let html;
        try { html = buildFn(); }
        catch (err) {
            W('MH pane render failed:', prefix, err);
            html = `<div class="sme-mh-empty">面板渲染失败：${escapeHtml(err.message)}</div>`;
        }
        bodyEl.innerHTML = html;
        if (postRender) postRender(bodyEl);
        activateMhPanel(prefix);
        return bodyEl;
    }

    function mhShowPanel(prefix) {
        if (mhState.rows.length === 0) {
            // v2.0.1：库存浮盈 / 交易冷却 两页需要成交记录作为成本基准与获得时间来源
            //   → 记录为空时先引导索引（沿用既有确认弹窗流程），而不是点了没反应
            if (prefix === 'inventory' || prefix === 'cooldown') {
                mhEnsureData('查看「' + (prefix === 'inventory' ? '库存浮盈' : '交易冷却') + '」').then(ok => {
                    if (ok) mhShowPanel(prefix);
                });
            }
            return;
        }
        const s = mhSummarize(mhState.rows);
        const code = mhCurrencyCode();
        const wi = getWalletInfo();
        const money = (c) => formatCentsStr(c, code);
        const truncated = mhState.totalCount > s.count
            ? ` Steam 报告共 ${mhState.totalCount} 条，当前已索引 ${s.count} 条。` : '';
        const baseNote = '手续费按当前钱包费率（Steam '
            + Math.round(wi.wallet_fee_percent * 100) + '% + 发行商 '
            + Math.round(wi.wallet_publisher_fee_percent_default * 100) + '%）估算，非 Steam 结算值；'
            + '年份由倒序分页跨年推断得出；AppID 为尽力匹配，可能为空。' + truncated;

        switch (prefix) {
            case 'overview': return mhPaneOverview(s, money, baseNote);
            case 'rank': return mhPaneRank(s, money, baseNote);
            case 'trend': return mhPaneTrend(s, money, baseNote);
            case 'calendar': return mhPaneCalendar(s, money, baseNote);
            case 'ledger': return mhPaneLedger(s, money, baseNote);
            case 'export': return mhPaneExport(s, money, baseNote);
            case 'inventory': return mhPaneDashboard('inventory');
            case 'cooldown': return mhPaneDashboard('cooldown');
            default: return mhPaneOverview(s, money, baseNote);
        }
    }

    function openMhAnalysis() {
        mhShowPanel(mhUi.lastTab || 'overview');
    }

    // ---------- 通用图表零件 ----------
    function mhAxisNum(cents, metric) {
        if (metric === 'count') return String(Math.round(cents));
        const code = mhCurrencyCode();
        if (smeFeeUsesRound(code)) return String(Math.round(cents / 100));
        const n = cents / 100;
        if (n >= 10000) return (n / 1000).toFixed(0) + 'k';
        if (n >= 1000) return (n / 1000).toFixed(1) + 'k';
        if (n >= 10) return n.toFixed(0);
        return n.toFixed(1);
    }

    /** 横向网格 + Y 轴刻度（参考 buildGrid） */
    function mhGrid(min, max, pL, pR, pT, cH, metric) {
        let g = '';
        for (let i = 0; i <= 5; i++) {
            const v = min + (max - min) * (i / 5);
            const y = pT + cH - (cH * i / 5);
            g += `<line x1="${pL}" y1="${y}" x2="${pR}" y2="${y}" stroke="rgba(255,255,255,.08)"/>`
                + `<text x="${pL - 8}" y="${y + 4}" text-anchor="end" fill="#8f98a0" font-size="11">${mhAxisNum(v, metric)}</text>`;
        }
        return g;
    }

    function mhStatCard(label, value, cls, icon, hint, accent) {
        const tone = /^#[0-9a-fA-F]{6}$/.test(accent || '') ? ` style="--accent:${accent}"` : '';
        return `<div class="sme-mh-stat${cls === 'sme-up' ? ' is-up' : (cls === 'sme-down' ? ' is-down' : '')}"${tone}>`
            + (icon ? `<span class="sme-mh-stat-ico">${icon}</span>` : '')
            + `<div class="sme-mh-stat-label">${escapeHtml(label)}</div>`
            + `<div class="sme-mh-stat-value">${escapeHtml(value)}</div>`
            + (hint ? `<div class="sme-mh-stat-hint">${escapeHtml(hint)}</div>` : '')
            + '</div>';
    }

    function mhPaneOverview(s, money, note) {
        const code = mhCurrencyCode();
        const period = s.firstTs ? `${mhFmtTs(s.firstTs).slice(0, 10)} ~ ${mhFmtTs(s.lastTs).slice(0, 10)}` : '未知';
        const hold = s.hold;
        const activeShare = s.spanDays ? Math.round(s.activeDays / s.spanDays * 1000) / 10 : 0;
        const avgBuyCents = s.bought.count ? Math.round(s.bought.grossCents / s.bought.count) : 0;
        // 阅读顺序：汇总 → 买入 → 卖出。同类指标排在一起。
        const cards = [
            mhStatCard('记录总数', String(s.count), '', ICONS.layers, '', '#f5a524'),
            mhStatCard('统计天数', `${s.spanDays} 天`, '', ICONS.clock, period, '#38bdf8'),
            mhStatCard('活跃天数', `${s.activeDays} 天`, '', ICONS.check, s.spanDays ? `占统计天数 ${activeShare}%` : '', '#22d3ee'),
            mhStatCard('日均 / 月均笔数', `${s.perDay} / ${s.perMonth}`, '', ICONS.chart, '', '#60a5fa'),
            mhStatCard('净收益', money(s.netCents), s.netCents >= 0 ? 'sme-up' : 'sme-down', ICONS.trendingUp, '', '#2dd4bf'),
            mhStatCard('ROI（净收入 ÷ 买入额）', s.roi === null ? '—' : s.roi + '%', s.roi === null ? '' : (s.roi >= 0 ? 'sme-up' : 'sme-down'), ICONS.trendingUp, '', s.roi !== null && s.roi < 0 ? '#f472b6' : '#4ade80'),
            mhStatCard('买入笔数', String(s.bought.count), '', ICONS.trendingDown, '', '#fb7185'),
            mhStatCard('买入总额', money(s.bought.grossCents), '', ICONS.bag, '', '#f87171'),
            mhStatCard('买入均价', money(avgBuyCents), '', ICONS.tag, s.bought.count ? `${s.bought.count} 笔` : '暂无买入', '#f472b6'),
            mhStatCard('卖出笔数', String(s.sold.count), '', ICONS.trendingUp, '', '#4ade80'),
            mhStatCard('卖出总额', money(s.sold.grossCents), '', ICONS.sell, '', '#34d399'),
            mhStatCard('估算手续费', money(s.sold.feeCents), '', ICONS.dollarSign, '', '#fbbf24'),
            mhStatCard('卖出净收入', money(s.sold.netCents), 'sme-up', ICONS.check, '', '#10b981'),
            mhStatCard('卖出均价', money(s.avgSoldCents), '', ICONS.tag, `中位 ${money(s.medianSoldCents)}`, '#a78bfa'),
            mhStatCard('最高成交', money(s.maxSoldCents), '', ICONS.gem, `区间 ${money(s.minSoldCents)} ~ ${money(s.maxSoldCents)}`, '#818cf8'),
            mhStatCard('平均持有时长', mhFmtDuration(hold.avgMs), '', ICONS.clock, hold.count ? `中位 ${mhFmtDuration(hold.medianMs)} · 样本 ${hold.count}` : '缺少可对比的上下架时间', '#c084fc'),
        ];


        // v1.6.5：收支对比改为「双占比环 + 关键数字」紧凑布局。
        // 原先只是一根细进度条，卡片被撑到 250px 高却只有 40px 内容，右侧价格分布
        // 被挤成窄条。现在两侧卡片高度对齐、内容填满。
        const inCents = s.sold.netCents, outCents = s.bought.grossCents;
        const sum = Math.max(1, inCents + outCents);
        const inPct = (inCents / sum * 100);
        const donut = (() => {
            const R = 52, C = 2 * Math.PI * R;
            const inLen = C * (inPct / 100);
            return `<svg class="sme-mh-donut" viewBox="0 0 140 140" role="img" aria-label="卖出净收入占比 ${inPct.toFixed(1)}%">
                <circle cx="70" cy="70" r="${R}" fill="none" stroke="rgba(255,255,255,.06)" stroke-width="20"/>
                <circle cx="70" cy="70" r="${R}" fill="none" stroke="#4ade80" stroke-width="20"
                    stroke-dasharray="${inLen.toFixed(2)} ${(C - inLen).toFixed(2)}"
                    stroke-linecap="butt" transform="rotate(-90 70 70)"/>
                <text x="70" y="66" text-anchor="middle" fill="#e9eff5" font-size="24" font-weight="700">${inPct.toFixed(1)}<tspan font-size="13">%</tspan></text>
                <text x="70" y="86" text-anchor="middle" fill="#6b7a89" font-size="11">卖出净收入占比</text>
            </svg>`;
        })();
        const flowRows = [
            { label: '卖出总额', v: s.sold.grossCents, c: '#4ade80', sub: `${s.sold.count} 笔` },
            { label: '减 估算手续费', v: -s.sold.feeCents, c: '#fbbf24', sub: `${Math.round(s.sold.feeCents / Math.max(1, s.sold.grossCents) * 1000) / 10}%` },
            { label: '卖出净收入', v: s.sold.netCents, c: '#4ade80', sub: '', strong: true },
            { label: '买入总额', v: s.bought.grossCents, c: '#f87171', sub: `${s.bought.count} 笔` },
            { label: '净收益', v: s.netCents, c: s.netCents >= 0 ? '#66c0f4' : '#f87171', sub: '', strong: true },
        ];
        const bar = `<div class="sme-mh-flowbox">
            ${donut}
            <div class="sme-mh-flowlist">
                ${flowRows.map((r) => `<div class="sme-mh-flowrow${r.strong ? ' is-strong' : ''}">
                    <span class="sme-mh-flowdot" style="background:${r.c}"></span>
                    <span class="sme-mh-flowlabel">${escapeHtml(r.label)}</span>
                    ${r.sub ? `<span class="sme-mh-flowsub">${escapeHtml(r.sub)}</span>` : '<span class="sme-mh-flowsub"></span>'}
                    <span class="sme-mh-flowval ${r.v < 0 ? 'is-neg' : ''}">${r.v < 0 ? '−' : ''}${escapeHtml(money(Math.abs(r.v)))}</span>
                </div>`).join('')}
            </div>
        </div>`;

        // 价格分布：对数分档。价格通常跨 3–4 个数量级（₹0.01 ~ ₹1826），
        // 等宽分档会把 99% 的样本挤进第一档（实测 5263/5266），直方图完全失真。
        let hist = '<div class="sme-mh-empty">暂无价格数据</div>';
        if (s.priceBuckets.length) {
            const maxC = Math.max(...s.priceBuckets.map((b) => b.count), 1);
            const totalC = s.priceBuckets.reduce((a, b) => a + b.count, 0);
            const fmtV = (c) => {
                const n = c / 100;
                if (n >= 1000) return (n / 1000).toFixed(n >= 10000 ? 0 : 1) + 'k';
                return n >= 100 ? n.toFixed(0) : n.toFixed(n >= 1 ? 2 : 3);
            };
            hist = '<div class="sme-mh-hist">' + s.priceBuckets.map((b) => {
                const pct = (b.count / maxC) * 100;
                const share = totalC ? (b.count / totalC * 100) : 0;
                const range = fmtV(b.from) === fmtV(b.to) ? fmtV(b.from) : `${fmtV(b.from)}~${fmtV(b.to)}`;
                return `<div class="sme-mh-hist-col" title="${escapeHtml(`${code} ${range}：${b.count} 笔（占 ${share.toFixed(1)}%）`)}">`
                    + `<div class="sme-mh-hist-bar" style="height:${Math.max(1.5, pct).toFixed(1)}%"></div>`
                    + `<div class="sme-mh-hist-count">${b.count}</div>`
                    + `<div class="sme-mh-hist-label">${escapeHtml(fmtV(b.from))}</div></div>`;
            }).join('') + '</div>'
                + `<div class="sme-mh-hist-axis">成交价分布 · ${escapeHtml(code)} · 对数分档 ${s.priceBuckets.length} 档`
                + ` · 横轴为该档起始价</div>`;
        }

        return mhRenderPane('overview', note, () =>
            `<div class="sme-mh-stats">${cards.join('')}</div>`
            + `<div class="sme-mh-split">`
            + `<div class="sme-mh-card" style="--accent:#4ade80"><div class="sme-mh-card-title">收支对比</div>${bar}</div>`
            + `<div class="sme-mh-card" style="--accent:#38bdf8"><div class="sme-mh-card-title">价格分布</div>${hist}</div>`
            + `</div>`
        );
    }

    // ---------- 面板：排行（v1.6.5 从概览拆出） ----------
    const MH_RANK_DIMS = [
        { id: 'item', label: '按物品', unit: '件' },
        { id: 'game', label: '按游戏', unit: '个' },
        { id: 'month', label: '按月份', unit: '个月' },
    ];
    const MH_RANK_SORTS = [
        { id: 'amount', label: '按金额' },
        { id: 'count', label: '按笔数' },
    ];
    const MH_RANK_TOP = 20;

    /** 汇总三个维度的排行数据（不受设置的 TopN 截断影响，这里要完整 Top20） */
    function mhRankGroups(dim) {
        const map = new Map();
        const keyOf = (r) => {
            if (dim === 'game') return r.game || '未知游戏';
            if (dim === 'month') return r.tradeTs ? mhMonthKey(r.tradeTs) : '';
            return r.name || '';
        };
        const extraOf = (r, g) => { if (dim === 'item') g.game = r.game || ''; };
        for (const r of mhState.rows) {
            const k = keyOf(r);
            if (!k) continue;
            let g = map.get(k);
            if (!g) { g = { key: k, game: '', count: 0, soldCount: 0, boughtCount: 0, soldCents: 0, boughtCents: 0, firstTs: 0, lastTs: 0 }; map.set(k, g); }
            extraOf(r, g);
            g.count++;
            if (r.tradeTs) { if (!g.firstTs || r.tradeTs < g.firstTs) g.firstTs = r.tradeTs; if (r.tradeTs > g.lastTs) g.lastTs = r.tradeTs; }
            if (r.action === 'sold') { g.soldCount++; g.soldCents += r.priceCents; }
            else if (r.action === 'bought') { g.boughtCount++; g.boughtCents += r.priceCents; }
        }
        for (const g of map.values()) {
            g.totalCents = g.soldCents + g.boughtCents;
            g.avgCents = g.soldCount ? Math.round(g.soldCents / g.soldCount) : 0;
        }
        return [...map.values()];
    }

    function mhPaneRank(s, money, note) {
        const dim = MH_RANK_DIMS.some((d) => d.id === mhUi.rankDim) ? mhUi.rankDim : 'item';
        const sortBy = mhUi.rankSort === 'count' ? 'count' : 'amount';
        const all = mhRankGroups(dim);
        const metric = (g) => (sortBy === 'count' ? g.count : g.totalCents);
        const list = all.slice().sort((a, b) => metric(b) - metric(a) || b.count - a.count || a.key.localeCompare(b.key));
        const shown = list.slice(0, MH_RANK_TOP);
        const peak = shown.length ? Math.max(...shown.map((g) => metric(g)), 1) : 1;
        const restCount = Math.max(0, list.length - shown.length);
        const restMetric = all.slice(MH_RANK_TOP).reduce((a, g) => a + metric(g), 0);
        const dimDef = MH_RANK_DIMS.find((d) => d.id === dim);

        return mhRenderPane('rank', note, () => {
            const dimBtn = (d) => `<button class="sme-mh-chip${dim === d.id ? ' active' : ''}" data-rdim="${d.id}">${escapeHtml(d.label)}</button>`;
            const sortBtn = (x) => `<button class="sme-mh-chip${sortBy === x.id ? ' active' : ''}" data-rsort="${x.id}">${escapeHtml(x.label)}</button>`;
            const toolbar = `<div class="sme-mh-toolbar">
                <span class="sme-mh-tb-label">分组</span>${MH_RANK_DIMS.map(dimBtn).join('')}
                <span class="sme-mh-tb-sep"></span>
                <span class="sme-mh-tb-label">排序</span>${MH_RANK_SORTS.map(sortBtn).join('')}
                <span class="sme-mh-tb-range">共 ${all.length} ${escapeHtml(dimDef.unit)}，显示 Top ${shown.length}${restCount ? `（其余 ${restCount} ${escapeHtml(dimDef.unit)}合计 ${escapeHtml(sortBy === 'count' ? String(restMetric) : money(restMetric))}）` : ''}</span>
            </div>`;

            if (!shown.length) return toolbar + '<div class="sme-mh-empty">暂无符合条件的成交记录</div>';

            // 占比条：直观看出每个条目在当前排序依据下的分量
            const rows = shown.map((g, i) => {
                const m = metric(g);
                const w = Math.max(1.5, (m / peak) * 100);
                const head = dim === 'item'
                    ? `<td class="sme-mh-name" title="${escapeHtml(g.key)}">${escapeHtml(g.key)}<span class="sme-mh-sub">${escapeHtml(g.game || '')}</span></td>`
                    : `<td class="sme-mh-name" title="${escapeHtml(g.key)}">${escapeHtml(g.key)}</td>`;
                return `<tr>
                    <td class="sme-mh-rank">${i + 1}</td>
                    ${head}
                    <td class="sme-mh-barcell"><span class="sme-mh-barfill" style="width:${w.toFixed(1)}%"></span></td>
                    <td class="sme-num">${g.count}</td>
                    <td class="sme-num">${g.soldCount}</td>
                    <td class="sme-num">${g.boughtCount}</td>
                    <td class="sme-num">${g.soldCents ? escapeHtml(money(g.soldCents)) : '<span class="sme-mh-zero">—</span>'}</td>
                    <td class="sme-num">${g.boughtCents ? escapeHtml(money(g.boughtCents)) : '<span class="sme-mh-zero">—</span>'}</td>
                    <td class="sme-num">${g.avgCents ? escapeHtml(money(g.avgCents)) : '<span class="sme-mh-zero">—</span>'}</td>
                    <td class="sme-num">${g.firstTs ? escapeHtml(mhFmtTs(g.firstTs).slice(0, 10)) : '<span class="sme-mh-zero">—</span>'}</td>
                </tr>`;
            }).join('');

            return toolbar
                + `<div class="sme-mh-table-wrap"><table class="sme-mh-table sme-mh-ranktable"><thead><tr>
                    <th class="sme-mh-rank">#</th><th>${escapeHtml(dimDef.label.replace('按', ''))}</th>
                    <th class="sme-mh-th-bar">占比</th>
                    <th>笔数</th><th>卖出</th><th>买入</th><th>卖出金额</th><th>买入金额</th><th>卖出均价</th><th>首次成交</th>
                </tr></thead><tbody>${rows}</tbody></table></div>`;
        }, (bodyEl) => {
            const bar = bodyEl.querySelector('.sme-mh-toolbar');
            const onClick = (e) => {
                const chip = e.target.closest('button.sme-mh-chip');
                if (!chip) return;
                if (chip.dataset.rdim) mhUi.rankDim = chip.dataset.rdim;
                else if (chip.dataset.rsort) mhUi.rankSort = chip.dataset.rsort;
                else return;
                mhShowPanel('rank');
            };
            bar.addEventListener('click', onClick);
            bodyEl._cleanup = () => bar.removeEventListener('click', onClick);
        });
    }

    // ---------- 面板 2：趋势（曲线） ----------
    // v1.6.3：金额类与笔数量级相差 4 个数量级，原先共用一个 Y 轴会把笔数压成直线。
    // 改为**双 Y 轴**：左轴金额、右轴笔数，各自独立缩放，默认全选也能读。
    const MH_TREND_SERIES = [
        { key: 'soldCents', label: '卖出金额', color: '#4ade80', axis: 'money' },
        { key: 'boughtCents', label: '买入金额', color: '#f87171', axis: 'money' },
        { key: 'netCents', label: '净额', color: '#66c0f4', axis: 'money' },
        { key: 'feeCents', label: '手续费', color: '#fbbf24', axis: 'money' },
        { key: 'count', label: '成交笔数', color: '#a78bfa', axis: 'count' },
    ];

    /** 分位数裁剪的 Y 轴域：避免个别尖峰把其余数据压成一条线 */
    function mhRobustDomain(values, includeZero) {
        const v = values.filter((x) => Number.isFinite(x)).sort((a, b) => a - b);
        if (!v.length) return { lo: 0, hi: 1, clipped: 0 };
        const at = (q) => v[Math.min(v.length - 1, Math.max(0, Math.round((v.length - 1) * q)))];
        let lo = at(0.02), hi = at(0.98);
        if (includeZero) lo = Math.min(lo, 0);
        if (hi === lo) hi = lo + Math.max(1, Math.abs(lo) * 0.1);
        const pad = (hi - lo) * 0.1;
        const dom = { lo: lo - pad, hi: hi + pad, clipped: 0 };
        for (const x of v) if (x < dom.lo || x > dom.hi) dom.clipped++;
        return dom;
    }

    function mhPaneTrend(s, money, note) {
        const metric = mhUi.trendMetric;
        const series = mhMonthlySeries(mhState.rows, true);
        const vis = MH_TREND_SERIES.filter((x) => mhUi.trendSeries[x.key]);
        const showMoney = vis.some((d) => d.axis === 'money');
        const showCount = vis.some((d) => d.axis === 'count');

        const build = () => {
            if (!series.length) return '<div class="sme-mh-empty">暂无可推断日期的记录</div>';
            if (!vis.length) return '<div class="sme-mh-empty">请至少勾选一条曲线</div>';

            // 金额统一换算为货币单位，笔数保持原值
            let data = series.map((x) => ({
                month: x.month,
                empty: !!x.empty,
                money: {
                    soldCents: (x.soldCents || 0) / 100,
                    boughtCents: (x.boughtCents || 0) / 100,
                    netCents: (x.netCents || 0) / 100,
                    feeCents: (x.feeCents || 0) / 100,
                },
                count: x.count || 0,
            }));
            if (mhUi.trendCumulative) {
                const cm = {}, cc = { count: 0 };
                data = data.map((o) => {
                    for (const k of ['soldCents', 'boughtCents', 'netCents', 'feeCents']) cm[k] = (cm[k] || 0) + o.money[k];
                    cc.count += o.count;
                    return { month: o.month, empty: o.empty, money: Object.assign({}, cm), count: cc.count };
                });
            }

            const moneyVals = [], countVals = [];
            for (const o of data) {
                for (const d of vis) {
                    if (d.axis === 'money') moneyVals.push(o.money[d.key]);
                    else countVals.push(o.count);
                }
            }
            const mDom = showMoney ? mhRobustDomain(moneyVals, true) : null;
            const cDom = showCount ? mhRobustDomain(countVals, false) : null;

            const svgW = 1080, svgH = 480, pT = 52, pB = 64;
            const pL = 78, pR = showCount ? 74 : 28;
            const cW = svgW - pL - pR, cH = svgH - pT - pB;
            const step = data.length > 1 ? cW / (data.length - 1) : 0;
            const xOf = (i) => pL + i * step;
            const clamp = (v, lo, hi) => Math.max(lo, Math.min(hi, v));
            const yMoney = (v) => pT + cH - ((clamp(v, mDom.lo, mDom.hi) - mDom.lo) / (mDom.hi - mDom.lo)) * cH;
            const yCount = (v) => pT + cH - ((clamp(v, cDom.lo, cDom.hi) - cDom.lo) / (cDom.hi - cDom.lo)) * cH;
            const yOf = (d, o) => (d.axis === 'money' ? yMoney(o.money[d.key]) : yCount(o.count));

            // 网格 + 左侧金额刻度
            let grid = '';
            for (let i = 0; i <= 5; i++) {
                const y = pT + cH - (cH * i / 5);
                grid += `<line x1="${pL}" y1="${y.toFixed(1)}" x2="${svgW - pR}" y2="${y.toFixed(1)}" stroke="rgba(255,255,255,.07)"/>`;
                if (showMoney) {
                    const v = mDom.lo + (mDom.hi - mDom.lo) * (i / 5);
                    grid += `<text x="${pL - 10}" y="${(y + 4).toFixed(1)}" text-anchor="end" fill="#d5e2ee" font-size="13">${mhAxisNum(Math.round(v * 100), 'amount')}</text>`;
                }
            }
            // 右侧笔数刻度
            if (showCount) {
                for (let i = 0; i <= 5; i++) {
                    const y = pT + cH - (cH * i / 5);
                    const v = cDom.lo + (cDom.hi - cDom.lo) * (i / 5);
                    grid += `<text x="${svgW - pR + 10}" y="${(y + 4).toFixed(1)}" text-anchor="start" fill="#d7c9ff" font-size="13">${mhAxisNum(Math.round(v), 'count')}</text>`;
                }
            }
            // 轴标题与时间段同一行：左右是轴名，中间是区间，都落在绘图区上方
            const activeMonths = series.filter((x) => !x.empty).length;
            const rangeLabel = `${series[0].month} – ${series[series.length - 1].month} · ${activeMonths}/${series.length} 月`;
            const midX = (pL + svgW - pR) / 2;
            if (showMoney) grid += `<text x="${pL - 10}" y="22" text-anchor="end" fill="#c5d4e2" font-size="12">金额 ${escapeHtml(mhCurrencyCode())}</text>`;
            if (showCount) grid += `<text x="${svgW - pR + 10}" y="22" text-anchor="start" fill="#c4b6ee" font-size="12">笔数</text>`;
            grid += `<text x="${midX.toFixed(1)}" y="22" text-anchor="middle" fill="#9fb0c0" font-size="12">${escapeHtml(rangeLabel)}</text>`;

            // 零基线（仅当两轴都跨越 0 时画在金额轴上）
            let zeroLine = '';
            if (showMoney && mDom.lo < 0 && mDom.hi > 0) {
                const zy = yMoney(0).toFixed(1);
                zeroLine = `<line x1="${pL}" y1="${zy}" x2="${svgW - pR}" y2="${zy}" stroke="rgba(255,255,255,.26)" stroke-dasharray="5 4"/>`;
            }

            const clipId = 'sme-mh-clip';
            const lines = vis.map((d) => {
                const pts = data.map((o, i) => `${xOf(i).toFixed(1)},${yOf(d, o).toFixed(1)}`).join(' ');
                const baseY = (d.axis === 'money' ? yMoney(Math.max(mDom.lo, 0)) : yCount(Math.max(cDom.lo, 0))).toFixed(1);
                const area = `${pL},${baseY} ${pts} ${xOf(data.length - 1).toFixed(1)},${baseY}`;
                return `<g clip-path="url(#${clipId})">`
                    + `<polygon points="${area}" fill="${d.color}" opacity="0.13"/>`
                    + `<polyline points="${pts}" fill="none" stroke="${d.color}" stroke-width="7" `
                    + `stroke-linecap="round" stroke-linejoin="round" opacity=".2"/>`
                    + `<polyline points="${pts}" fill="none" stroke="${d.color}" stroke-width="2.6" `
                    + `stroke-linecap="round" stroke-linejoin="round"/></g>`;
            }).join('');

            const dots = data.length <= 40 ? vis.map((d) =>
                data.map((o, i) => `<circle cx="${xOf(i).toFixed(1)}" cy="${yOf(d, o).toFixed(1)}" r="3" fill="${d.color}">`
                    + `<title>${escapeHtml(o.month)} ${escapeHtml(d.label)}: ${escapeHtml(d.axis === 'money' ? money(Math.round(o.money[d.key] * 100)) : String(o.count))}</title></circle>`).join('')).join('') : '';

            // X 轴：稀疏标注年份 + 端点月份
            let labels = '';
            let lastKey = '';
            data.forEach((o, i) => {
                const x = xOf(i);
                const parts = o.month.split('-');
                const yy = parts[0], mm = parts[1];
                if ((mm === '01' || i === 0) && lastKey !== yy) {
                    labels += `<text x="${x.toFixed(1)}" y="${pT + cH + 38}" text-anchor="${i === 0 ? 'start' : 'middle'}" fill="#d5e2ee" font-size="13">${yy}</text>`;
                    lastKey = yy;
                }
                if (i === data.length - 1 || (mm !== '01' && data.length <= 14)) {
                    labels += `<text x="${x.toFixed(1)}" y="${pT + cH + 18}" text-anchor="${i === data.length - 1 ? 'end' : 'middle'}" fill="#b7c9d8" font-size="12">${+mm}月</text>`;
                }
            });

            const clipDef = `<clipPath id="${clipId}"><rect x="${pL}" y="${pT}" width="${cW}" height="${cH}"/></clipPath>`;
            const tip = (mDom && mDom.clipped) || (cDom && cDom.clipped)
                ? `<div class="sme-mh-clipnote">Y 轴按 2%–98% 分位裁剪以突出主体走势，超出范围的点贴边显示（共 ${(mDom ? mDom.clipped : 0) + (cDom ? cDom.clipped : 0)} 个）</div>`
                : '';
            const plotFrame = `<rect x="${pL}" y="${pT}" width="${cW}" height="${cH}" fill="rgba(255,255,255,.02)" stroke="rgba(255,255,255,.14)"/>`;
            // padding-bottom 与 viewBox 同比例，SVG 用 none 铺满这块区域，宽屏两侧不再留白
            const plotRatio = (svgH / svgW * 100).toFixed(4);

            return `<div class="sme-mh-chartbox">`
                + `<div class="sme-mh-chart-plot" style="padding-bottom:${plotRatio}%">`
                + `<svg viewBox="0 0 ${svgW} ${svgH}" preserveAspectRatio="none" role="img" aria-label="月度交易趋势">`
                + clipDef + plotFrame + grid + zeroLine + lines + dots + labels
                + '</svg></div></div>'
                + tip;
        };

        return mhRenderPane('trend', note, () => {
            const totals = { soldCents: 0, boughtCents: 0, netCents: 0, feeCents: 0, count: 0 };
            for (const x of series) {
                if (x.empty) continue;
                totals.soldCents += x.soldCents || 0;
                totals.boughtCents += x.boughtCents || 0;
                totals.netCents += x.netCents || 0;
                totals.feeCents += x.feeCents || 0;
                totals.count += x.count || 0;
            }
            const hintOf = (d) => d.axis === 'count'
                ? `${totals.count}笔`
                : money(Math.round(totals[d.key] || 0));
            const toggles = MH_TREND_SERIES.map((d) =>
                `<button class="sme-mh-chip${mhUi.trendSeries[d.key] ? ' active' : ''}" data-series="${d.key}" style="--c:${d.color};--cb:${d.color}26" title="${escapeHtml(d.label)} ${escapeHtml(hintOf(d))}">`
                + `<i style="background:${d.color}"></i>${escapeHtml(d.label)}`
                + `<em class="sme-mh-chip-sum">${escapeHtml(hintOf(d))}</em></button>`).join('');
            const metricBtn = (v, label) =>
                `<button class="sme-mh-chip${mhUi.trendMetric === v ? ' active' : ''}" data-metric="${v}">${escapeHtml(label)}</button>`;
            const cumBtn = `<button class="sme-mh-chip${mhUi.trendCumulative ? ' active' : ''}" data-cum="1">累计</button>`;
            return `<div class="sme-mh-toolbar">
                    <span class="sme-mh-tb-label">口径</span>${metricBtn('amount', '金额优先')}${metricBtn('count', '笔数优先')}
                    <span class="sme-mh-tb-sep"></span>
                    <span class="sme-mh-tb-label">曲线</span>${toggles}
                    <span class="sme-mh-tb-sep"></span>${cumBtn}
                </div><div id="sme-mh-trend-chart">${build()}</div>`;
        }, (bodyEl) => {
            const chartEl = bodyEl.querySelector('#sme-mh-trend-chart');
            const redraw = () => { chartEl.innerHTML = build(); };
            const bar = bodyEl.querySelector('.sme-mh-toolbar');
            const onClick = (e) => {
                const btn = e.target.closest('button.sme-mh-chip');
                if (!btn) return;
                if (btn.dataset.metric) { mhUi.trendMetric = btn.dataset.metric; }
                else if (btn.dataset.cum !== undefined) { mhUi.trendCumulative = !mhUi.trendCumulative; }
                else if (btn.dataset.series) {
                    const k = btn.dataset.series;
                    mhUi.trendSeries[k] = !mhUi.trendSeries[k];
                }
                bar.innerHTML = bar.innerHTML; // no-op，保持引用
                mhShowPanel('trend');
            };
            bar.addEventListener('click', onClick);
            bodyEl._cleanup = () => bar.removeEventListener('click', onClick);
        });
    }

    // ---------- 面板 4：日历热力 ----------
    /**
     * v1.6.4 日历色阶。
     * 旧版用 rgba 透明度叠在深底上，最高才到 .95，格子与背景几乎融在一起；
     * 且格内数字统一深色，在亮底上又看不清。现改为**实色 6 档递进**，
     * 每档同时给出背景色与配套文字色，保证任意档位下数字都可读。
     */
    const MH_CAL_SCALE = [
        { bg: '#16202b', fg: '#5d6f80' },   // 无记录：可见但明显为空
        { bg: '#123b52', fg: '#9fd4ee' },   // 1
        { bg: '#175a7d', fg: '#b8e2f7' },   // 2
        { bg: '#1a6e94', fg: '#e2f4ff' },   // 3（背景压深一档以满足 AA 对比）
        { bg: '#28a0cc', fg: '#06202e' },   // 4（转深色字）
        { bg: '#48c2e8', fg: '#052030' },   // 5
        { bg: '#86dcf5', fg: '#062535' },   // 6（峰值）
    ];
    const MH_CAL_EMPTY = { bg: 'transparent', fg: 'transparent' };

    function mhCalLevel(v, mx) {
        if (!v || v <= 0) return -1;
        const p = v / mx;
        // 6 档等分；最低档 1，峰值落在最后一档
        let lv = Math.ceil(p * 6);
        if (lv < 1) lv = 1;
        if (lv > 6) lv = 6;
        return lv;
    }

    function mhPaneCalendar(s, money, note) {
        const daily = new Map(s.daily.map((d) => [d.day, d]));
        const years = [...new Set(s.daily.map((d) => d.day.slice(0, 4)))].sort();
        const maxCount = Math.max(1, ...s.daily.map((d) => d.count));
        const maxCents = Math.max(1, ...s.daily.map((d) => d.soldCents + d.boughtCents));

        return mhRenderPane('calendar', note, () => {
            if (!years.length) return '<div class="sme-mh-empty">暂无可推断日期的记录，无法生成日历</div>';
            const MD = ['一', '二', '三', '四', '五', '六', '七', '八', '九', '十', '十一', '十二'];
            const buildYear = (y) => {
                const first = new Date(Number(y), 0, 1);
                const last = new Date(Number(y), 11, 31);
                const startDay = (first.getDay() + 6) % 7;   // 周一为第一列
                const totalDays = Math.round((last - first) / 86400000) + 1;
                let cells = '';
                for (let i = 0; i < startDay; i++) cells += '<div class="sme-mh-cal-cell sme-mh-cal-pad"></div>';
                for (let i = 0; i < totalDays; i++) {
                    const cd = new Date(first);
                    cd.setDate(cd.getDate() + i);
                    const key = y + '-' + String(cd.getMonth() + 1).padStart(2, '0') + '-' + String(cd.getDate()).padStart(2, '0');
                    const d = daily.get(key);
                    const n = d ? d.count : 0;
                    const lv = mhCalLevel(n, maxCount);
                    const c = lv < 0 ? MH_CAL_EMPTY : MH_CAL_SCALE[lv];
                    const tip = d
                        ? `${key}｜${d.count} 笔｜卖出 ${money(d.soldCents)}｜买入 ${money(d.boughtCents)}`
                        : `${key}｜无记录`;
                    cells += `<div class="sme-mh-cal-cell${lv < 0 ? ' is-empty' : ' has-data'}" `
                        + `style="background:${c.bg};color:${c.fg}" title="${escapeHtml(tip)}">`
                        + (n ? `<span>${n}</span>` : '') + '</div>';
                }
                return `<div class="sme-mh-cal-year">
                    <div class="sme-mh-cal-year-label">${escapeHtml(y)}</div>
                    <div class="sme-mh-cal-months">${MD.map((m) => `<span>${m}</span>`).join('')}</div>
                    <div class="sme-mh-cal-body">
                        <div class="sme-mh-cal-weekdays">${['一', '二', '三', '四', '五', '六', '日'].map((w) => `<span>${w}</span>`).join('')}</div>
                        <div class="sme-mh-cal-cells">${cells}</div>
                    </div>
                </div>`;
            };
            const totalCents = s.daily.reduce((a, d) => a + d.soldCents + d.boughtCents, 0);
            const activeCells = s.daily.length;
            const legendCells = MH_CAL_SCALE.map((c) =>
                `<i style="background:${c.bg};border-color:${c.bg}" title="${escapeHtml(c.fg)}"></i>`).join('');
            return `<div class="sme-mh-toolbar">
                    <span class="sme-mh-tb-label">按笔数着色</span>
                    <span class="sme-mh-cal-legend">
                        <span>少</span><i class="is-empty" style="background:${MH_CAL_SCALE[0].bg};border-color:${MH_CAL_SCALE[0].bg}"></i>${legendCells}<span>多</span>
                    </span>
                    <span class="sme-mh-tb-range">单日最多 ${maxCount} 笔 · 有成交 ${activeCells} 天 · `
                    + `合计成交额 ${escapeHtml(money(totalCents))}（单日峰值 ${escapeHtml(money(maxCents))}）</span>
                </div>`
                + `<div class="sme-mh-cal-container">${years.map(buildYear).join('')}</div>`;
        });
    }

    // ---------- 面板 5：明细 ----------
    const MH_LEDGER_DIMS = [
        { id: 'all', label: '全部' },
        { id: 'game', label: '按游戏' },
        { id: 'item', label: '按物品' },
        { id: 'month', label: '按月份' },
    ];

    /** 维度 → 行上的取值键 */
    function mhLedgerDimKey(dim, r) {
        if (dim === 'game') return r.game || '未知游戏';
        if (dim === 'item') return r.name || '';
        if (dim === 'month') return r.tradeTs ? mhMonthKey(r.tradeTs) : '';
        return '';
    }

    /** 当前维度下的候选取值，按成交额降序取前 N（供 chips 使用） */
    function mhLedgerDimOptions(dim) {
        if (dim === 'all') return [];
        const cnt = new Map();
        for (const r of mhState.rows) {
            if (mhUi.ledgerType !== 'all' && r.action !== mhUi.ledgerType) continue;
            const k = mhLedgerDimKey(dim, r);
            if (!k) continue;
            cnt.set(k, (cnt.get(k) || 0) + (r.action === 'sold' ? r.priceCents : 0));
        }
        return [...cnt.entries()]
            // 成交额降序；金额相同时按名称升序，保证顺序可预期而不是随 Map 插入序漂移
            .sort((a, b) => (b[1] - a[1]) || a[0].localeCompare(b[0]))
            .map(([k]) => k);
    }

    function mhFilteredRows() {
        const q = mhUi.ledgerQuery.trim().toLowerCase();
        let rows = mhState.rows.filter((r) => {
            if (mhUi.ledgerType !== 'all' && r.action !== mhUi.ledgerType) return false;
            if (mhUi.ledgerDim !== 'all' && mhUi.ledgerValue) {
                const key = mhLedgerDimKey(mhUi.ledgerDim, r);
                if (key !== mhUi.ledgerValue) return false;
            }
            if (q) {
                const hay = `${r.name}\n${r.game}\n${r.counterpart || ''}\n${r.actionLabel}`.toLowerCase();
                if (!hay.includes(q)) return false;
            }
            return true;
        });
        const key = mhUi.ledgerSort;
        const dir = mhUi.ledgerDesc ? -1 : 1;
        rows.sort((a, b) => {
            let va = key === 'price' ? a.priceCents : key === 'name' ? a.name : (a.tradeTs || a.listedTs || 0);
            let vb = key === 'price' ? b.priceCents : key === 'name' ? b.name : (b.tradeTs || b.listedTs || 0);
            if (typeof va === 'string') return va.localeCompare(vb) * dir;
            return (va - vb) * dir;
        });
        return rows;
    }

    function mhPaneLedger(s, money, note) {
        const rows = mhFilteredRows();
        const totalPages = Math.max(1, Math.ceil(rows.length / MH_LEDGER_PAGE));
        if (mhUi.ledgerPage > totalPages) mhUi.ledgerPage = totalPages;
        if (mhUi.ledgerPage < 1) mhUi.ledgerPage = 1;
        const slice = rows.slice((mhUi.ledgerPage - 1) * MH_LEDGER_PAGE, mhUi.ledgerPage * MH_LEDGER_PAGE);
        const opts = mhLedgerDimOptions(mhUi.ledgerDim);

        const th = (key, label) =>
            `<th class="sme-mh-th-sort" data-sort="${key}">${escapeHtml(label)}${mhUi.ledgerSort === key ? (mhUi.ledgerDesc ? ' ▾' : ' ▴') : ''}</th>`;

        const body = slice.length ? slice.map((r) => {
            const hold = (r.action === 'sold' && r.tradeTs && r.listedTs) ? r.tradeTs - r.listedTs : 0;
            return `<tr>
                <td class="sme-mh-name" title="${escapeHtml(r.name)}">${escapeHtml(r.name)}</td>
                <td class="dim">${escapeHtml(r.game || '')}</td>
                <td><span class="sme-mh-tag ${r.action}">${escapeHtml(r.actionLabel)}</span></td>
                <td class="sme-num">${r.priceCents ? escapeHtml(money(r.priceCents)) : '<span class="sme-mh-zero">—</span>'}</td>
                <td class="sme-num">${r.action === 'sold' && r.priceCents ? escapeHtml(money(priceBeforeFees(r.priceCents))) : '<span class="sme-mh-zero">—</span>'}</td>
                <td>${escapeHtml(mhFmtTs(r.tradeTs) || r.tradeDateText || '-')}</td>
                <td class="dim">${hold ? escapeHtml(mhFmtDuration(hold)) : '<span class="sme-mh-zero">—</span>'}</td>
                <td class="dim">${escapeHtml(r.counterpart || '')}</td>
            </tr>`;
        }).join('') : `<tr><td colspan="8"><div class="sme-mh-empty">没有符合当前筛选条件的记录<br><span class="sme-mh-empty-sub">试试切换「类型」或点「重置」</span></div></td></tr>`;

        return mhRenderPane('ledger', note, () => {
            const typeBtn = (v, label) => `<button class="sme-mh-chip${mhUi.ledgerType === v ? ' active' : ''}" data-ltype="${v}">${escapeHtml(label)}</button>`;
            const dimBtn = (v, label) => `<button class="sme-mh-chip${mhUi.ledgerDim === v ? ' active' : ''}" data-ldim="${v}">${escapeHtml(label)}</button>`;            const pager = totalPages > 1
                ? `<div class="sme-mh-pager">
                    <button class="sme-mh-chip" data-page="prev"${mhUi.ledgerPage <= 1 ? ' disabled' : ''}>上一页</button>
                    <span>第 ${mhUi.ledgerPage} / ${totalPages} 页</span>
                    <button class="sme-mh-chip" data-page="next"${mhUi.ledgerPage >= totalPages ? ' disabled' : ''}>下一页</button>
                    <span class="sme-mh-tb-range">共 ${rows.length} 条</span>
                   </div>` : `<div class="sme-mh-pager"><span class="sme-mh-tb-range">共 ${rows.length} 条</span></div>`;

            // 维度候选用 chips 呈现，不用下拉——高基数下列表会拉得很长且难以扫读
            const TOPN = 14;
            let valueRow = '';
            if (mhUi.ledgerDim !== 'all') {
                const shown = opts.slice(0, TOPN);
                const chips = [`<button class="sme-mh-chip${!mhUi.ledgerValue ? ' active' : ''}" data-lvalue="">不限</button>`]
                    .concat(shown.map((k) => {
                        const label = k.length > 16 ? k.slice(0, 15) + '…' : k;
                        return `<button class="sme-mh-chip${mhUi.ledgerValue === k ? ' active' : ''}" data-lvalue="${escapeHtml(k)}" title="${escapeHtml(k)}">${escapeHtml(label)}</button>`;
                    })).join('');
                const more = opts.length > TOPN
                    ? `<span class="sme-mh-tb-range">共 ${opts.length} 个选项，已显示成交额最高的 ${TOPN} 个；可用搜索框精确查找</span>`
                    : `<span class="sme-mh-tb-range">共 ${opts.length} 个选项</span>`;
                valueRow = `<div class="sme-mh-valuebar"><span class="sme-mh-tb-label">${
                    escapeHtml((MH_LEDGER_DIMS.find((d) => d.id === mhUi.ledgerDim) || {}).label || '')
                }</span>${chips}${more}</div>`;
            }

            return `<div class="sme-mh-toolbar">
                    <span class="sme-mh-tb-label">大类</span>${typeBtn('all', '全部')}${typeBtn('sold', '卖出')}${typeBtn('bought', '买入')}
                    <span class="sme-mh-tb-sep"></span>
                    <span class="sme-mh-tb-label">维度</span>${dimBtn('all', '不限')}${dimBtn('game', '按游戏')}${dimBtn('item', '按物品')}${dimBtn('month', '按月份')}
                    <span class="sme-mh-tb-sep"></span>
                    <input class="sme-mh-format" id="sme-mh-ledger-q" type="search" placeholder="搜索物品 / 游戏 / 对方…" value="${escapeHtml(mhUi.ledgerQuery)}" style="min-width:200px">
                    <button class="sme-mh-chip" id="sme-mh-ledger-reset">重置</button>
                    <span class="sme-mh-tb-range">点击表头排序</span>
                </div>
                ${valueRow}
                <div class="sme-mh-table-wrap is-scrollable">
                  <table class="sme-mh-table"><thead><tr>
                    ${th('name', '物品')}<th>游戏</th><th>类型</th>${th('price', '价格')}<th>估算到手</th>${th('ts', '交易时间')}<th>持有时长</th><th>对方</th>
                  </tr></thead><tbody>${body}</tbody></table>
                </div>${pager}`;
        }, (bodyEl) => {
            const bar = bodyEl.querySelector('.sme-mh-toolbar');
            const q = bodyEl.querySelector('#sme-mh-ledger-q');
            const onClick = (e) => {
                const chip = e.target.closest('button.sme-mh-chip');
                const th = e.target.closest('th.sme-mh-th-sort');
                if (chip) {
                    if (chip.dataset.ltype) { mhUi.ledgerType = chip.dataset.ltype; mhUi.ledgerValue = ''; mhUi.ledgerPage = 1; mhShowPanel('ledger'); }
                    else if (chip.dataset.ldim) { mhUi.ledgerDim = chip.dataset.ldim; mhUi.ledgerValue = ''; mhUi.ledgerPage = 1; mhShowPanel('ledger'); }
                    else if (chip.dataset.lvalue !== undefined) { mhUi.ledgerValue = chip.dataset.lvalue; mhUi.ledgerPage = 1; mhShowPanel('ledger'); }
                    else if (chip.dataset.page) {
                        const d = chip.dataset.page;
                        if (d === 'prev' && mhUi.ledgerPage > 1) mhUi.ledgerPage--;
                        else if (d === 'next') mhUi.ledgerPage++;
                        mhShowPanel('ledger');
                    } else if (chip.id === 'sme-mh-ledger-reset') {
                        mhUi.ledgerType = 'all'; mhUi.ledgerDim = 'all';
                        mhUi.ledgerValue = ''; mhUi.ledgerQuery = ''; mhUi.ledgerPage = 1;
                        mhShowPanel('ledger');
                    }
                    return;
                }
                if (th) {
                    const k = th.dataset.sort;
                    if (mhUi.ledgerSort === k) mhUi.ledgerDesc = !mhUi.ledgerDesc;
                    else { mhUi.ledgerSort = k; mhUi.ledgerDesc = k !== 'name'; }
                    mhShowPanel('ledger');
                }
            };
            bar.addEventListener('click', onClick);
            bodyEl.addEventListener('click', onClick);
            let timer = null;
            const onInput = () => {
                clearTimeout(timer);
                timer = setTimeout(() => {
                    mhUi.ledgerQuery = q.value;
                    mhUi.ledgerPage = 1;
                    mhShowPanel('ledger');
                }, 260);
            };
            q.addEventListener('input', onInput);
            bodyEl._cleanup = () => {
                clearTimeout(timer);
                bar.removeEventListener('click', onClick);
                bodyEl.removeEventListener('click', onClick);
                q.removeEventListener('input', onInput);
            };
        });
    }

    // ---------- 面板 6：导出 ----------
    const MH_EXPORT_FORMATS = [
        { id: 'csv', label: 'CSV', desc: '逗号分隔 · 带 UTF-8 BOM · Excel 双击直开' },
        { id: 'tsv', label: 'TSV', desc: '制表符分隔 · 字段内换行自动转义' },
        { id: 'json', label: 'JSON', desc: '结构化 · 含汇总/物品/游戏/月份/每日/价格分档' },
        { id: 'md', label: 'Markdown', desc: '可读报告 · 统计卡 + 榜单 + 月度表 + 明细' },
    ];

    function mhPaneExport(s, money, note) {
        const fmt = mhUi.exportFormat || mhState.format || 'csv';
        const filtered = mhFilteredRows();
        const hasFilter = mhUi.ledgerType !== 'all'
            || (mhUi.ledgerDim !== 'all' && !!mhUi.ledgerValue)
            || !!mhUi.ledgerQuery.trim();

        return mhRenderPane('export', note, () => {
            const cards = MH_EXPORT_FORMATS.map((f) =>
                `<button class="sme-mh-fmt${fmt === f.id ? ' active' : ''}" data-fmt="${f.id}">
                    <span class="sme-mh-fmt-label">${escapeHtml(f.label)}</span>
                    <span class="sme-mh-fmt-desc">${escapeHtml(f.desc)}</span>
                </button>`).join('');

            const scopeRows = hasFilter ? filtered : mhState.rows;
            const preview = fmt === 'json'
                ? ['{', '  "meta": { "recordCount": ' + scopeRows.length + ', "currency": "' + mhCurrencyCode() + '" },',
                    '  "summary": { "total": ' + s.count + ', "netProfit": ' + (Math.round(s.netCents) / 100).toFixed(2) + ' },',
                    '  "transactions": [ … ' + scopeRows.length + ' 条 … ]', '}'].join('\n')
                : fmt === 'md'
                    ? '# Steam 市场交易记录汇总\n\n## 总体\n\n| 指标 | 数值 |\n| --- | --- |\n| 记录总数 | ' + s.count + ' |\n…'
                    : '序号,事件ID,挂单ID,物品名称,游戏,AppID,类型,状态,价格原文,价格,币种,…\n'
                        + '1,' + escapeHtml(scopeRows.length ? scopeRows[0].eventId : '') + ',' + escapeHtml(scopeRows.length ? scopeRows[0].listingId : '') + ','
                        + escapeHtml(scopeRows.length ? scopeRows[0].name : '') + ',…';

            return `<div class="sme-mh-toolbar">
                    <span class="sme-mh-tb-label">格式</span>${cards}
                    <span class="sme-mh-tb-sep"></span>
                    <button class="sme-mh-chip active" data-scope="all">全部（${mhState.rows.length}）</button>
                    <button class="sme-mh-chip${hasFilter ? ' active' : ''}" data-scope="filtered"${hasFilter ? '' : ' disabled title="当前没有筛选条件，先到「明细」页设置"'}">当前筛选（${filtered.length}）</button>
                </div>
                <div class="sme-mh-export-body">
                    <div class="sme-mh-export-preview"><div class="sme-mh-card-title">预览（前几行）</div><pre class="sme-mh-pre">${escapeHtml(preview)}</pre></div>
                    <div class="sme-mh-export-side">
                        <div class="sme-mh-card-title">本次导出</div>
                        <div class="sme-mh-stat"><div class="sme-mh-stat-label">记录数</div><div class="sme-mh-stat-value">${scopeRows.length}</div></div>
                        <div class="sme-mh-stat"><div class="sme-mh-stat-label">格式</div><div class="sme-mh-stat-value">${escapeHtml(fmt.toUpperCase())}</div></div>
                        <div class="sme-mh-stat"><div class="sme-mh-stat-label">币种</div><div class="sme-mh-stat-value">${escapeHtml(mhCurrencyCode())}</div></div>
                        <button class="sme-mh-btn-primary" id="sme-mh-do-export">下载文件</button>
                        <div class="sme-mh-hint-sm">导出会包含全部字段；JSON 与 Markdown 另附多维汇总。时间戳年份为推断值。</div>
                    </div>
                </div>`;
        }, (bodyEl) => {
            const bar = bodyEl.querySelector('.sme-mh-toolbar');
            let scope = hasFilter ? 'filtered' : 'all';
            const onBar = (e) => {
                const chip = e.target.closest('button.sme-mh-fmt, button.sme-mh-chip');
                if (!chip) return;
                if (chip.dataset.fmt) { mhUi.exportFormat = chip.dataset.fmt; mhShowPanel('export'); }
                else if (chip.dataset.scope === 'all') { scope = 'all'; mhShowPanel('export'); }
                else if (chip.dataset.scope === 'filtered') { scope = 'filtered'; mhShowPanel('export'); }
            };
            bar.addEventListener('click', onBar);
            const doBtn = bodyEl.querySelector('#sme-mh-do-export');
            const onExport = () => {
                const rows = scope === 'filtered' ? mhFilteredRows() : mhState.rows;
                if (!rows.length) { toast('没有可导出的记录', 'warning'); return; }
                mhRunExport({ format: fmt, rows, label: scope === 'filtered' ? 'filtered' : '' });
            };
            doBtn.addEventListener('click', onExport);
            bodyEl._cleanup = () => {
                bar.removeEventListener('click', onBar);
                doBtn.removeEventListener('click', onExport);
            };
        });
    }

    // ---------- 工具条 ----------
    function mhSetStatus(msg, cls) {
        const el = document.getElementById('sme-mh-status');
        if (!el) return;
        el.textContent = msg || '';
        el.className = 'sme-mh-status' + (cls === 'ok' ? ' sme-ok' : (cls === 'err' ? ' sme-err' : ''));
    }

    function mhSetProgress(ratio, show) {
        const box = document.getElementById('sme-mh-progress');
        const bar = document.getElementById('sme-mh-progress-bar');
        if (box) box.style.display = show ? '' : 'none';
        if (bar) bar.style.width = Math.max(0, Math.min(1, ratio || 0)) * 100 + '%';
    }

    function mhSetBusy(busy) {
        const panel = document.getElementById('sme-mh-panel');
        if (!panel) return;
        panel.querySelectorAll('button').forEach(b => {
            if (b.id === 'sme-mh-stop') {
                b.style.display = busy ? '' : 'none';
                b.disabled = !busy;
            } else {
                b.disabled = !!busy;
            }
        });
    }

    function mhCooldownLeft() {
        return (mhState.paused && mhState.nextAt) ? Math.max(0, Math.ceil((mhState.nextAt - Date.now()) / 1000)) : 0;
    }

    function mhFmtCountdown(sec) {
        return `${Math.floor(sec / 60)}:${String(sec % 60).padStart(2, '0')}`;
    }

    /** 限流冷却期间每秒刷新倒计时文案，到点自动解锁按钮 */
    let _mhCoolTimer = null;
    function mhStartCooldownWatch() {
        if (_mhCoolTimer) return;
        _mhCoolTimer = setInterval(() => {
            if (mhState.fetching || !mhState.paused) { mhStopCooldownWatch(); return; }
            const left = mhCooldownLeft();
            if (left <= 0) {
                mhState.paused = false;
                mhState.nextAt = 0;
                mhState.coolStreak = 0;
                mhStopCooldownWatch();
                mhSetStatus(`冷却结束，可从第 ${mhState.rows.length + 1} 条继续索引`, 'ok');
                mhRefreshStatus();
                return;
            }
            mhSetStatus(`限流冷却中 ${mhFmtCountdown(left)} · 已保留 ${mhState.rows.length} / ${mhState.totalCount || '?'} 条`, 'err');
        }, 1000);
    }
    function mhStopCooldownWatch() {
        if (_mhCoolTimer) { clearInterval(_mhCoolTimer); _mhCoolTimer = null; }
    }

    function mhRefreshStatus() {
        if (mhState.fetching) {
            mhSetProgress(mhState.totalCount ? mhState.rows.length / mhState.totalCount : 0, true);
            return;
        }
        if (mhState.rows.length === 0 && !mhState.paused) {
            mhSetProgress(0, false);
            mhSetStatus('尚未索引交易记录');
            mhStopCooldownWatch();
            return;
        }
        if (mhState.paused && mhCooldownLeft() > 0) {
            mhSetProgress(mhState.totalCount ? mhState.rows.length / mhState.totalCount : 0, false);
            mhSetStatus(`限流冷却中 ${mhFmtCountdown(mhCooldownLeft())} · 已保留 ${mhState.rows.length} / ${mhState.totalCount || '?'} 条`, 'err');
            mhStartCooldownWatch();
            return;
        }
        mhSetProgress(0, false);
        mhStopCooldownWatch();
        const when = mhState.fetchedAt
            ? new Date(mhState.fetchedAt).toLocaleString('zh-CN', { hour12: false }) : '';
        if (mhState.rows.length === 0) { mhSetStatus('尚未索引交易记录'); return; }
        // v1.6.8：不再重复报同一个数字。完成 / 未完成两套文案。
        const text = mhState.complete
            ? `已索引全部 ${mhState.rows.length} 条`
            : `已索引 ${mhState.rows.length} / ${mhState.totalCount || '?'} 条 · 可继续`;
        mhSetStatus(`${text}${when ? ' · ' + when : ''}`, mhState.complete ? 'ok' : '');
        mhSyncFetchButton();
    }

    /** 刷新/继续/重建按钮的语义随索引状态变化，避免误清缓存 */
    function mhFetchButtonMeta() {
        if (mhState.complete) return { label: '重新索引', title: '已索引完整。点击将清空并从头重新抓取' };
        if (mhState.rows.length > 0) return { label: '继续', title: `从第 ${mhState.rows.length + 1} 条继续索引（保留已抓取部分）` };
        return { label: '索引', title: '开始抓取全量交易记录' };
    }

    function mhUpdateFetchButton(btn) {
        if (!btn) return;
        const meta = mhFetchButtonMeta();
        const span = btn.querySelector('span');
        if (span) span.textContent = meta.label;
        btn.title = meta.title;
        btn.setAttribute('aria-label', meta.title);
    }

    /** 索引状态变化后刷新按钮文案与冷却计时 */
    function mhSyncFetchButton() {
        mhUpdateFetchButton(document.getElementById('sme-mh-refresh-btn'));
    }

    function injectMhPanel() {
        const tabs = document.getElementById('myMarketTabs');
        if (!tabs) return false;
        if (mhState.panelEl && document.body.contains(mhState.panelEl)) return true;

        const formatSel = h('select', {
            id: 'sme-mh-format', class: 'sme-mh-format', 'aria-label': '导出格式',
            onChange: (e) => {
                mhState.format = ['csv', 'tsv', 'json', 'md'].includes(e.target.value) ? e.target.value : 'csv';
                settings.set('marketHistoryFormat', mhState.format);
                toast(`导出格式已切换为 ${mhState.format.toUpperCase()}`, 'info');
            },
            html: '<option value="csv">CSV</option><option value="tsv">TSV</option>'
                + '<option value="json">JSON</option><option value="md">Markdown</option>',
        });
        const savedFmt = settings.get('marketHistoryFormat');
        formatSel.value = MH_EXPORT_FORMATS.some((f) => f.id === savedFmt) ? savedFmt : 'csv';
        mhState.format = formatSel.value;

        const actions = h('span', { class: 'sme-mh-actions' }, [
            h('button', {
                id: 'sme-mh-summary-btn', class: 'sme-market-btn', type: 'button',
                html: ICONS.chart + '<span>汇总</span>',
                title: '查看市场交易记录分析（概览 / 趋势 / 分布 / 日历 / 明细 / 导出）',
                onClick: async () => { if (await mhEnsureData('查看分析')) openMhAnalysis(); },
            }),
            formatSel,
            h('button', {
                id: 'sme-mh-export-btn', class: 'sme-market-btn', type: 'button',
                html: ICONS.download + '<span>导出</span>',
                title: '按所选格式导出全部交易记录',
                onClick: async () => { if (await mhEnsureData('导出')) mhRunExport(); },
            }),
            h('button', {
                id: 'sme-mh-refresh-btn', class: 'sme-market-btn', type: 'button',
                html: ICONS.refreshCw + '<span></span>',
                title: '',
                onClick: async (e) => {
                    if (mhState.fetching) return;
                    const btn = e.currentTarget;
                    const meta = mhFetchButtonMeta();
                    if (meta.force) {
                        // 只有「已完整索引」时才允许从零重来，且二次确认
                        const ok = await showConfirmDialog(
                            '重新索引会<b>清空当前已抓取的 '
                            + `<strong>${mhState.rows.length}</strong> 条记录并从第 1 条重抓。<br><br>`
                            + '<span style="color:var(--sme-text-muted);font-size:12px">'
                            + '如果只是没抓完，请用「继续」从断点接着抓。</span>',
                            { title: '重新索引', okText: '清空并重来', okClass: 'sme-dialog-ok' });
                        if (!ok) return;
                        mhState.rows = [];
                        mhState.totalCount = 0;
                        mhState.fetchedAt = 0;
                        mhState.nextOffset = 0;
                        mhState.complete = false;
                        mhState.paused = false;
                        mhState.nextAt = 0;
                        mhState.coolStreak = 0;
                        mhSetStatus('正在重新索引…');
                        await mhFetchAll({ force: true });
                    } else {
                        // 断点续传：保留已有数据
                        mhSetStatus(`正在从第 ${mhState.rows.length + 1} 条继续索引…`);
                        await mhFetchAll();
                    }
                    mhUpdateFetchButton(btn);
                },
            }),
            h('button', {
                id: 'sme-mh-stop', class: 'sme-market-btn sme-danger', type: 'button',
                text: '停止', style: { display: 'none' },
                onClick: () => { mhState.abort = true; mhSetStatus('正在停止…'); },
            }),
        ]);

        // 按当前索引状态设定按钮文案（索引 / 继续 / 重新索引）
        const fetchBtn = actions.querySelector('#sme-mh-refresh-btn');
        if (fetchBtn) mhUpdateFetchButton(fetchBtn);

        // 独立容器，作为 #myMarketTabs 的前一个兄弟节点插入。
        // Tab 行内部依赖 float 布局（"出售物品"右浮动），同层插入必然重叠；
        // 放到上一行的块级容器里可完全绕开，且不改动 Steam 原有样式。
        const panel = h('div', { class: 'sme-mh-panel', id: 'sme-mh-panel' }, [
            h('div', { class: 'sme-mh-panel-inner' }, [
                h('span', { class: 'sme-mh-title', html: ICONS.chart + '<span>交易记录</span>' }),
                h('span', { class: 'sme-mh-status', id: 'sme-mh-status' }),
                actions,
            ]),
            h('div', { class: 'sme-mh-progress', id: 'sme-mh-progress' }, [
                h('div', { class: 'sme-mh-progress-bar', id: 'sme-mh-progress-bar' }),
            ]),
        ]);

        mhState.panelEl = panel;
        const host = tabs.parentNode || tabs;
        host.insertBefore(panel, tabs);

        mhRefreshStatus();
        return true;
    }

    function initMarketHistoryPanel() {
        if (!settings.get('marketHistoryPanel')) return;
        if (detectPageType() !== 'browse') return;
        if (!mhState.styleAdded) {
            GM_addStyle(MH_CSS);
            mhState.styleAdded = true;
        }
        if (mhState.active) return;
        // #myMarketTabs 由页面脚本异步渲染，轮询等待
        let attempts = 0;
        const tryStart = () => {
            if (injectMhPanel()) {
                mhState.active = true;
                mhLoadCache();
                mhRefreshStatus();
                L('Market history panel active, cached rows:', mhState.rows.length);
                return;
            }
            if (attempts++ < 30) setTimeout(tryStart, 500);
        };
        tryStart();
    }

    function cleanupMarketHistoryPanel() {
        // v1.6.8：切页面前先落盘再中断。
        // 原实现直接 abort = true 却不保存，SPA 导航切走时最多丢掉 400 条进度；
        // 现在确保断点持久化，切回来点「继续」即可接着抓。
        if (mhState.fetching && mhState.rows.length) {
            mhSaveCache(mhState.rows, mhState.totalCount, mhState.nextOffset);
        }
        if (mhState.panelEl) { mhState.panelEl.remove(); mhState.panelEl = null; }
        // 分析窗口挂在 body 上，需单独销毁并解绑全局 keydown
        if (_mhShell) {
            if (_mhShell.modal._dispose) _mhShell.modal._dispose();
            const bodies = _mhShell.panelsEl.querySelectorAll('.sme-mh-pbody');
            bodies.forEach((b) => { if (b._cleanup) { try { b._cleanup(); } catch (e) {} b._cleanup = null; } });
            _mhShell.modal.remove();
            _mhShell = null;
        }
        mhStopCooldownWatch();
        mhState.active = false;
        mhState.abort = true;
    }

    // ==================== v1.6.4 市场页 Beta 公告条隐藏 ====================
    // 社区市场首页顶部有一条官方公告：
    //   「我们目前正在对物品页面和高级搜索等市场功能进行 Beta 测试…」
    // 该条由服务端渲染在 #marketBetaNoteCtn 内，且市场页是 SPA 导航会重新挂载，
    // 因此用一条 CSS 规则常驻压制——比逐次 JS 移除更稳，SPA 切回来也不会复现。
    const MARKET_BETA_HIDE_CSS = `
#marketBetaNoteCtn{display:none!important}
.marketBetaNoteText{display:none!important}
#marketBetaNote{display:none!important}
`;
    let _betaNoteStyleAdded = false;
    function applyMarketBetaNoteHidden() {
        if (!settings.get('hideMarketBetaNote')) return;
        if (_betaNoteStyleAdded) return;
        GM_addStyle(MARKET_BETA_HIDE_CSS);
        _betaNoteStyleAdded = true;
    }

    // ==================== v1.7.0 我的池子行情 ====================
    /**
     * 「我的池子行情」
     * =========================================================================
     * 把「我关心的那一批社区市场物品」聚合成一张行情盘，对标参考图那类行情 App 的形态
     * （指标卡 / 指数曲线 / 板块行情 / 市场热图 / 我的池子明细），
     * 但数据域是 **Steam 社区市场**，不是商店折扣。
     *
     * 为什么是「我的池子」而不是「全市场」：
     *   社区市场**没有全市场 API**——Steam 只提供逐物品的
     *   pricehistory / itemordershistogram，没有任何"全市场行情"端点。
     *   纯客户端做不出全市场指数。能做且有意义的是「我关心的这一批」的指数。
     *   池子来源：① 浏览市场时自动收录（可关）② 详情页手动关注 ③ 库存页批量收录。
     *
     * 数据模型（落在 GM 存储，不占 localStorage 的 5MB 配额）：
     *   poolState.items  Map<`appid::hashName`, {appid,hashName,name,game,kind,sources,qty,addedAt,lastSeen}>
     *   poolState.series Map<`appid::hashName`, [[dayIdx, cents, vol], ...]>
     *   dayIdx = Math.floor(ts / 86400000) —— 相对 1970-01-01 的天数，5 位数，比时间戳省一半
     *
     * 口径纪律（每条都是"错一条整张盘就歪"的级别，务必保持）：
     *   · 「当前价」= 当日成交价按成交量加权（VWAP）；无成交量退化为当日收盘价。
     *     ★ pricehistory 返回的 p 是**单位金额**（如 20.70），不是分 —— 入库要 ×100。
     *   · 「指数」= 基期（窗口内首个有价日）= 100 的成交量加权价格指数。
     *     权重 = 物品在窗口内的总成交量（固定），这样逐日变化只反映价格变化、不受权重漂移影响。
     *   · 「前值延续」= 物品当日无成交时沿用最近一次有价，但最多延续 7 天，超过则视为无价。
     *   · 「历史新低」= 当前价 ≤ 窗口内最低价（容差 0.5%）。
     *   · 所有占比类指标都要写明分母（参与计算的物品数），不能只给一个百分比。
     */

    // ---------- 常量 ----------
    const POOL_MAX_ITEMS = 300;          // 池子容量上限（超出后新物品不再收录）
    const POOL_SNAP_DAYS = 180;           // 每个物品保留的日快照天数
    const POOL_CARRY_DAYS = 7;            // 前值延续上限（天）
    const POOL_REFRESH_DELAY = 600;       // 采集请求间隔（毫秒），过小易触发 Steam 限流
    const POOL_REFRESH_CONCURRENCY = 2;   // 采集并发数
    const POOL_LOW_TOLERANCE = 0.005;     // 历史新低容差（0.5%）
    const POOL_ITEMS_KEY = 'sme_pool_items_v1';
    const POOL_SERIES_KEY = 'sme_pool_series_v1';
    const POOL_WINDOWS = [
        { id: '7d', label: '7日', days: 7 },
        { id: '30d', label: '30日', days: 30 },
        { id: '90d', label: '90日', days: 90 },
        { id: 'all', label: '全部', days: Infinity },
    ];

    // ---------- 状态 ----------
    const poolState = {
        items: new Map(),        // key -> 池子条目
        series: new Map(),       // key -> [[dayIdx, cents, vol], ...]
        lastUpdated: 0,          // 最近一次成功采集的时间戳
        refreshing: false,       // 采集中
        abort: false,            // 中断采集
        active: false,           // 市场页工具条已注入
        styleAdded: false,       // 样式已注入
        panelEl: null,           // 市场页工具条节点
        modalEl: null,           // 分析弹窗节点
        browseObserver: null,    // 浏览页自动收录观察器
        scanTimer: null,         // 浏览页扫描节流
        lastTab: 'overview',     // 记住上次标签
        window: '30d',           // 记住时间窗口
        sectorDim: 'kind',       // 板块维度：kind 品类 | game 游戏
    };

    // ===== v1.7.0 纯计算层开始（可离线测试，勿在此引入 DOM / GM 依赖） =====

    /** 天序号：相对 1970-01-01 的天数 */
    function poolDayIndex(ts) { return Math.floor(ts / 86400000); }

    /** 天序号 → 该日起点的 UTC 时间戳 */
    function poolDayStart(dayIdx) { return dayIdx * 86400000; }

    /** 取序列中落在 [cutoff, nowDay] 的点（序列按 dayIdx 升序） */
    function poolSlice(series, days, nowDay) {
        const cutoff = days === Infinity ? -Infinity : nowDay - days + 1;
        const out = [];
        for (const p of series) {
            if (p[0] >= cutoff && p[0] <= nowDay) out.push(p);
        }
        return out;
    }

    /** 物品在给定时刻的"有效当前价"：最近一次有价点，前值延续最多 carryDays 天 */
    function poolCurrentPoint(series, nowDay, carryDays) {
        const maxAge = (carryDays === undefined ? POOL_CARRY_DAYS : carryDays);
        for (let i = series.length - 1; i >= 0; i--) {
            const p = series[i];
            if (p[0] > nowDay) continue;
            if (!(p[1] > 0)) continue;
            if (maxAge >= 0 && nowDay - p[0] > maxAge) return null;
            return p;
        }
        return null;
    }

    /** 窗口内成交量合计 */
    function poolVolume(points) {
        let v = 0;
        for (const p of points) v += (p[2] || 0);
        return v;
    }

    /**
     * 池子价格指数（基期 = 100）
     * @param {Map<string, Array>} seriesMap 物品 -> 日序列
     * @param {number} days 窗口天数（Infinity = 全部）
     * @param {number} nowDay 当前天序号
     * @returns {{index:number, priced:number, total:number}} priced = 参与计算的物品数
     */
    function poolComputeIndex(seriesMap, days, nowDay) {
        let wsum = 0, rsum = 0, priced = 0, total = 0;
        for (const series of seriesMap.values()) {
            total++;
            const cur = poolCurrentPoint(series, nowDay);
            const base = poolBasePoint(series, days, nowDay);
            if (!cur || !base || !(base.price > 0) || !(cur[1] > 0)) continue;
            // 单点物品没有变化信息 —— 不参与，否则 ratio=1 会稀释真实涨跌
            if (base.count < 2) continue;
            priced++;
            const w = base.weight > 0 ? base.weight : 1;
            wsum += w;
            rsum += w * (cur[1] / base.price);
        }
        return {
            index: wsum > 0 ? (100 * rsum) / wsum : 100,
            priced,
            total,
        };
    }

    /**
     * 基期点：窗口内第一个有价点 + 该物品在窗口内的总成交量（作为固定权重）
     * 同时回传窗口内有价点数 count —— 单点物品没有"变化"信息，
     * 让它以 ratio=1 参与指数会把指数往 100 拽（稀释真实涨跌），必须排除。
     */
    function poolBasePoint(series, days, nowDay) {
        const cutoff = days === Infinity ? -Infinity : nowDay - days + 1;
        let base = null, vol = 0, count = 0;
        for (const p of series) {
            if (p[0] < cutoff || p[0] > nowDay) continue;
            vol += (p[2] || 0);
            if (!(p[1] > 0)) continue;
            count++;
            if (!base) base = p;
        }
        return base ? { day: base[0], price: base[1], weight: vol, count } : null;
    }

    /**
     * 指数日序列：逐日重算"基期固定"的加权指数
     * @returns {Array<[dayIdx, index, hasData]>}
     */
    function poolComputeIndexSeries(seriesMap, days, nowDay) {
        const cutoff = days === Infinity ? -Infinity : nowDay - days + 1;
        const bases = new Map();
        for (const [key, series] of seriesMap) {
            const b = poolBasePoint(series, days, nowDay);
            if (b && b.count >= 2) bases.set(key, b);   // 单点物品不参与（与 poolComputeIndex 口径一致）
        }
        if (!bases.size) return [];
        // 起点取「窗口起点」与「最早有价日」的较晚者：
        // 否则窗口前半段全是"无数据占位点"（index=100），画出来是一段假的平线。
        let minDay = nowDay;
        for (const [key, series] of seriesMap) {
            if (!bases.has(key)) continue;
            for (const p of series) {
                if (p[0] >= cutoff && p[0] <= nowDay && p[1] > 0 && p[0] < minDay) minDay = p[0];
            }
        }
        const start = days === Infinity ? Math.max(minDay, nowDay - POOL_SNAP_DAYS + 1) : Math.max(cutoff, minDay);
        const out = [];
        for (let d = start; d <= nowDay; d++) {
            let wsum = 0, rsum = 0;
            for (const [key, series] of seriesMap) {
                const b = bases.get(key);
                if (!b) continue;
                const cur = poolCurrentPoint(series, d);
                if (!cur || !(cur[1] > 0)) continue;
                const w = b.weight > 0 ? b.weight : 1;
                wsum += w;
                rsum += w * (cur[1] / b.price);
            }
            out.push([d, wsum > 0 ? (100 * rsum) / wsum : 100, wsum > 0]);
        }
        return out;
    }

    /**
     * 历史新低：当前价 ≤ 窗口内最低价（容差 tol）
     * @returns {Array<{key:string, price:number, low:number, lowDay:number}>}
     */
    function poolComputeRecordLows(seriesMap, days, nowDay, tol) {
        const t = tol === undefined ? POOL_LOW_TOLERANCE : tol;
        const hits = [];
        for (const [key, series] of seriesMap) {
            const cur = poolCurrentPoint(series, nowDay);
            if (!cur || !(cur[1] > 0)) continue;
            const pts = poolSlice(series, days, nowDay);
            if (!pts.length) continue;
            let low = Infinity, lowDay = 0;
            for (const p of pts) {
                if (p[1] > 0 && p[1] < low) { low = p[1]; lowDay = p[0]; }
            }
            if (!isFinite(low)) continue;
            if (cur[1] <= low * (1 + t)) hits.push({ key, price: cur[1], low, lowDay });
        }
        return hits;
    }

    /**
     * 池子市值：Σ 当前价 × 数量
     * @param {Map} itemsMap 池子条目（提供 qty）
     */
    function poolComputeValue(seriesMap, itemsMap, nowDay) {
        let cents = 0, priced = 0, count = 0;
        for (const [key, series] of seriesMap) {
            const cur = poolCurrentPoint(series, nowDay);
            if (!cur || !(cur[1] > 0)) continue;
            const it = itemsMap.get(key);
            const qty = it && it.qty > 0 ? it.qty : 1;
            cents += cur[1] * qty;
            count += qty;
            priced++;
        }
        return { cents, priced, count };
    }

    /**
     * 价格覆盖：当日有有效价的物品数 / 池子物品数
     */
    function poolComputeCoverage(seriesMap, nowDay) {
        let priced = 0, total = 0;
        for (const series of seriesMap.values()) {
            total++;
            if (poolCurrentPoint(series, nowDay)) priced++;
        }
        return { priced, total };
    }

    /**
     * 分组聚合：按 dim（kind / game）把物品分组，各组算指数、涨跌、新低、市值
     * @param {Map} itemsMap 池子条目
     * @param {Map} seriesMap 日序列
     * @param {string} dim 'kind' | 'game'
     * @param {number} days
     * @param {number} nowDay
     */
    function poolGroupStats(itemsMap, seriesMap, dim, days, nowDay) {
        const groups = new Map();
        for (const [key, it] of itemsMap) {
            const gname = dim === 'game' ? (it.game || '未知游戏') : (it.kind || '其他');
            let g = groups.get(gname);
            if (!g) {
                g = { name: gname, items: new Map() };
                groups.set(gname, g);
            }
            g.items.set(key, it);
        }
        const lows = new Set(poolComputeRecordLows(seriesMap, days, nowDay).map((h) => h.key));
        const out = [];
        for (const g of groups.values()) {
            const sub = new Map();
            for (const [key, it] of g.items) {
                const s = seriesMap.get(key);
                if (s) sub.set(key, s);
            }
            const idx = poolComputeIndex(sub, days, nowDay);
            const val = poolComputeValue(sub, g.items, nowDay);
            let lowCount = 0;
            for (const key of g.items.keys()) if (lows.has(key)) lowCount++;
            out.push({
                name: g.name,
                count: g.items.size,
                priced: idx.priced,
                index: idx.index,
                changePct: idx.index - 100,
                lowCount,
                valueCents: val.cents,
                items: g.items,
                series: sub,
            });
        }
        out.sort((a, b) => b.count - a.count || b.valueCents - a.valueCents);
        return out;
    }

    /**
     * 把 pricehistory 的原始点折叠成"每日一行"：[dayIdx, cents(分), vol]
     * ★ pricehistory 的 p 是**单位金额**（20.70），不是分 —— 这里统一 ×100 存分。
     * @param {Array<{t:number,p:number,v:number}>} prices
     */
    function poolFoldHistory(prices) {
        if (!Array.isArray(prices)) return [];
        const buckets = new Map();
        for (const p of prices) {
            if (!p || !(p.t > 0) || !(p.p > 0)) continue;
            const d = poolDayIndex(p.t);
            let b = buckets.get(d);
            if (!b) { b = { sum: 0, vol: 0, last: 0, lastT: 0 }; buckets.set(d, b); }
            const v = p.v > 0 ? p.v : 0;
            b.sum += p.p * v;
            b.vol += v;
            if (p.t >= b.lastT) { b.lastT = p.t; b.last = p.p; }
        }
        const out = [];
        for (const [d, b] of buckets) {
            const cents = b.vol > 0 ? Math.round((b.sum / b.vol) * 100) : Math.round(b.last * 100);
            if (cents > 0) out.push([d, cents, b.vol]);
        }
        out.sort((a, b) => a[0] - b[0]);
        return out;
    }

    /** 合并日序列（同一天以新数据为准），保持升序 */
    function poolMergeSeries(oldSeries, fresh) {
        const map = new Map();
        for (const p of oldSeries || []) map.set(p[0], p);
        for (const p of fresh || []) map.set(p[0], p);
        return [...map.values()].sort((a, b) => a[0] - b[0]);
    }

    /** 取窗口内某分组每天的指数（用于热图） */
    function poolGroupIndexByDay(groups, days, nowDay) {
        const map = new Map();  // groupName -> Map<dayIdx, index>
        for (const g of groups) {
            const series = poolComputeIndexSeries(g.series, days, nowDay);
            const m = new Map();
            for (const [d, v] of series) m.set(d, v);
            map.set(g.name, m);
        }
        return map;
    }

    // ===== v1.7.0 纯计算层结束 =====

    // ---------- 池子存取 ----------
    function poolKey(appid, hashName) { return `${appid}::${hashName}`; }

    function poolMaxItems() {
        const n = parseInt(settings.get('poolMaxItems'), 10);
        return Math.max(20, Math.min(POOL_MAX_ITEMS, n || POOL_MAX_ITEMS));
    }

    function poolSave() {
        try {
            const items = [];
            for (const entry of poolState.items) items.push(entry);
            smeKv.set(POOL_ITEMS_KEY, JSON.stringify(items)).catch(() => {});
            const series = [];
            for (const entry of poolState.series) series.push(entry);
            smeKv.set(POOL_SERIES_KEY, JSON.stringify(series)).catch(() => {});
        } catch (e) {
            W('Pool save failed:', e);
        }
    }

    async function poolLoad() {
        try {
            const rawItems = await smeKv.get(POOL_ITEMS_KEY, '[]');
            const items = typeof rawItems === 'string' ? JSON.parse(rawItems || '[]') : (rawItems || []);
            if (Array.isArray(items)) {
                for (const pair of items) {
                    if (!Array.isArray(pair) || pair.length < 2) continue;
                    const key = String(pair[0]);
                    const it = pair[1] || {};
                    if (!it.appid || !it.hashName) continue;
                    poolState.items.set(key, {
                        appid: String(it.appid),
                        hashName: String(it.hashName),
                        name: String(it.name || it.hashName),
                        game: String(it.game || ''),
                        kind: String(it.kind || '其他'),
                        sources: Array.isArray(it.sources) ? it.sources.slice() : [],
                        qty: Math.max(1, parseInt(it.qty, 10) || 1),
                        addedAt: it.addedAt || Date.now(),
                        lastSeen: it.lastSeen || 0,
                    });
                }
            }
            const rawSeries = await smeKv.get(POOL_SERIES_KEY, '[]');
            const series = typeof rawSeries === 'string' ? JSON.parse(rawSeries || '[]') : (rawSeries || []);
            if (Array.isArray(series)) {
                for (const pair of series) {
                    if (!Array.isArray(pair) || pair.length < 2) continue;
                    const pts = Array.isArray(pair[1]) ? pair[1].filter((p) => Array.isArray(p) && p.length >= 2) : [];
                    if (pts.length) poolState.series.set(String(pair[0]), pts);
                }
            }
        } catch (e) {
            W('Pool load failed:', e);
        }
        poolTrimSeries();
    }

    /** 只保留最近 POOL_SNAP_DAYS 天，控制 GM 存储体积 */
    function poolTrimSeries() {
        const cutoff = poolDayIndex(Date.now()) - POOL_SNAP_DAYS;
        for (const [key, s] of poolState.series) {
            const kept = s.filter((p) => p[0] >= cutoff);
            if (kept.length !== s.length) poolState.series.set(key, kept);
        }
    }

    // ---------- 池子条目维护 ----------
    function poolClassify(name, appid) {
        const n = String(name || '');
        const app = String(appid || '');
        if (app === '753') return '卡牌';
        if (app === '730') {
            if (/钥匙/.test(n)) return '钥匙';
            if (/武器箱/.test(n)) return '武器箱';
            if (/印花|贴纸/.test(n)) return '印花';
            if (/挂件/.test(n)) return '挂件';
            if (/布章/.test(n)) return '布章';
            if (/胸章/.test(n)) return '胸章';
            if (/音乐盒/.test(n)) return '音乐盒';
            if (/涂鸦/.test(n)) return '涂鸦';
            if (/特工/.test(n)) return '特工';
            if (/\|/.test(n)) return '皮肤';
            return '其他';
        }
        if (app === '570') {
            if (/载入画面|载入屏/.test(n)) return '载入画面';
            if (/贴纸|印花/.test(n)) return '印花';
            if (/至宝/.test(n)) return '至宝';
            if (/不朽/.test(n)) return '不朽';
            if (/宝箱/.test(n)) return '宝箱';
            if (/饰品|护腕|挂饰/.test(n)) return '饰品';
            if (/嘲讽|语音/.test(n)) return '嘲讽';
            if (/音乐/.test(n)) return '音乐';
            return '其他';
        }
        return '其他';
    }

    function poolAddItem(data, source) {
        if (!data || !data.appid || !data.hashName) return false;
        const key = poolKey(data.appid, data.hashName);
        const existing = poolState.items.get(key);
        if (existing) {
            existing.lastSeen = Date.now();
            if (source && !existing.sources.includes(source)) existing.sources.push(source);
            if (data.name && !existing.name) existing.name = data.name;
            if (data.game && !existing.game) existing.game = data.game;
            return false;
        }
        if (poolState.items.size >= poolMaxItems()) return false;
        const label = data.name || data.hashName;
        poolState.items.set(key, {
            appid: String(data.appid),
            hashName: String(data.hashName),
            name: String(label),
            game: String(data.game || ''),
            kind: poolClassify(label, data.appid),
            sources: [source].filter(Boolean),
            qty: Math.max(1, parseInt(data.qty, 10) || 1),
            addedAt: Date.now(),
            lastSeen: Date.now(),
        });
        poolSave();
        return true;
    }

    function poolRemoveItem(key) {
        if (!poolState.items.delete(key)) return false;
        poolState.series.delete(key);
        poolSave();
        return true;
    }

    function poolHasItem(appid, hashName) {
        return poolState.items.has(poolKey(appid, hashName));
    }

    function poolToggleWatch() {
        if (!listingInfo || !listingInfo.appid || !listingInfo.marketHashName) {
            toast('未能识别当前物品', 'warning');
            return;
        }
        const key = poolKey(listingInfo.appid, listingInfo.marketHashName);
        if (poolState.items.has(key)) {
            poolRemoveItem(key);
            toast('已从池子移除', 'info');
        } else {
            const added = poolAddItem({
                appid: listingInfo.appid,
                hashName: listingInfo.marketHashName,
                name: listingInfo.marketHashName,
                game: '',
            }, 'watch');
            toast(added ? '已加入池子行情' : '池子已满，未能加入', added ? 'success' : 'warning');
        }
        poolSyncWatchButton();
        poolRefreshPanelStatus();
    }

    // ---------- 采集 ----------
    async function poolRefreshQuotes() {
        if (poolState.refreshing) return;
        const items = [...poolState.items.values()];
        if (!items.length) {
            toast('池子为空：浏览市场或点击物品页「关注」加入几件物品', 'warning');
            return;
        }
        poolState.refreshing = true;
        poolState.abort = false;
        let done = 0, ok = 0, fail = 0;
        poolSetStatus(`正在采集 ${items.length} 件物品的行情…`);
        try {
            const queue = items.slice();
            const worker = async () => {
                while (queue.length) {
                    if (poolState.abort) return;
                    const it = queue.shift();
                    const key = poolKey(it.appid, it.hashName);
                    try {
                        const hist = await fetchPriceHistory(it.appid, it.hashName);
                        const folded = poolFoldHistory(hist.prices || []);
                        if (folded.length) {
                            poolState.series.set(key, poolMergeSeries(poolState.series.get(key) || [], folded));
                            ok++;
                        } else {
                            fail++;
                        }
                    } catch (e) {
                        fail++;
                    }
                    done++;
                    poolSetStatus(`采集中 ${done}/${items.length}（成功 ${ok}，失败 ${fail}）`);
                    poolSetProgress(done / items.length);
                    await sleep(POOL_REFRESH_DELAY);
                }
            };
            const workers = [];
            for (let i = 0; i < POOL_REFRESH_CONCURRENCY; i++) workers.push(worker());
            await Promise.all(workers);
            // 中断也要落盘：已经采到的日快照是有效数据，丢了等于白跑
            poolTrimSeries();
            poolSave();
            if (poolState.abort) {
                poolSetStatus(`已中断：已采集 ${done}/${items.length}（已保存）`);
                toast(`采集已中断，已保存 ${ok} 件的行情`, 'warning');
            } else {
                poolState.lastUpdated = Date.now();
                poolSetStatus(`采集完成：成功 ${ok}，失败 ${fail}`);
                toast(`池子行情已更新（${ok} 件成功）`, 'success');
            }
        } finally {
            poolState.refreshing = false;
            poolSetProgress(0);
            poolRefreshPanelStatus();
            if (poolState.modalEl && poolState.modalEl.classList.contains('visible')) poolShowPanel(poolState.lastTab);
        }
    }

    // ---------- 图表零件 ----------
    /** 池子模块的货币代码（不依赖 mh 模块，保持自持） */
    function poolCurrencyCode() {
        return getWalletInfo().currency_code || 'USD';
    }

    /**
     * 指标卡（池子模块自持版，不复用 mhStatCard —— 那个的样式依赖
     * 作用域限定在 .sme-mh-modal/.sme-mh-panel 上的 --mh-* token，
     * 交易记录面板关闭时 MH_CSS 不会注入，卡片会掉样式）
     */
    function poolStatCard(label, value, cls, icon, hint, accent) {
        const tone = /^#[0-9a-fA-F]{6}$/.test(accent || '') ? ` style="--accent:${accent}"` : '';
        return `<div class="sme-pool-stat${cls === 'sme-up' ? ' is-up' : (cls === 'sme-down' ? ' is-down' : '')}"${tone}>`
            + (icon ? `<span class="sme-pool-stat-ico">${icon}</span>` : '')
            + `<div class="sme-pool-stat-label">${escapeHtml(label)}</div>`
            + `<div class="sme-pool-stat-value">${escapeHtml(value)}</div>`
            + (hint ? `<div class="sme-pool-stat-hint">${escapeHtml(hint)}</div>` : '')
            + '</div>';
    }

    /** 指数轴刻度：100 附近用两位小数，大数值用整数 */
    function poolAxisNum(v) {
        const a = Math.abs(v);
        if (a >= 1000) return (v / 1000).toFixed(1) + 'k';
        if (a >= 100) return v.toFixed(0);
        return v.toFixed(2);
    }

    /**
     * 指数曲线（SVG）：折线 + 渐变面积 + Y 轴刻度 + 峰值标注 + 期初标注
     * @param {Array<[number, number, boolean]>} points [dayIdx, value, hasData]
     */
    function poolBuildChart(points, opts) {
        opts = opts || {};
        const W = 760, H = 240, pL = 52, pR = 16, pT = 18, pB = 30;
        const cw = W - pL - pR, ch = H - pT - pB;
        const valid = points.filter((p) => p[2]);
        if (valid.length < 2) return '<div class="sme-pool-empty">数据点不足，无法绘制曲线</div>';

        let data = valid;
        if (data.length > 180) {
            const step = Math.ceil(data.length / 180);
            data = data.filter((_, i) => i % step === 0);
            data.push(valid[valid.length - 1]);
        }
        const n = data.length;
        const vals = data.map((d) => d[1]);
        let minV = Math.min(...vals), maxV = Math.max(...vals);
        if (maxV - minV < 0.5) { const mid = (maxV + minV) / 2; minV = mid - 0.5; maxV = mid + 0.5; }
        const range = maxV - minV;
        const pts = data.map((d, i) => ({
            x: pL + (n === 1 ? cw / 2 : (i / (n - 1)) * cw),
            y: pT + ch - ((d[1] - minV) / range) * ch,
            v: d[1],
            day: d[0],
        }));

        const line = pts.map((pt, i) => (i === 0 ? 'M' : 'L') + pt.x.toFixed(1) + ',' + pt.y.toFixed(1)).join(' ');
        const area = line + ` L ${pts[n - 1].x.toFixed(1)},${(pT + ch).toFixed(1)} L ${pts[0].x.toFixed(1)},${(pT + ch).toFixed(1)} Z`;

        let grid = '';
        for (let i = 0; i <= 4; i++) {
            const y = pT + (ch / 4) * i;
            const val = maxV - (range / 4) * i;
            grid += `<line x1="${pL}" y1="${y.toFixed(1)}" x2="${W - pR}" y2="${y.toFixed(1)}" stroke="rgba(255,255,255,0.05)"/>`;
            grid += `<text x="${pL - 6}" y="${(y + 4).toFixed(1)}" text-anchor="end" fill="#8f98a0" font-size="11">${poolAxisNum(val)}</text>`;
        }
        let xaxis = '';
        for (let i = 0; i <= 4; i++) {
            const idx = Math.min(Math.floor((n - 1) * i / 4), n - 1);
            const d = new Date(poolDayStart(data[idx][0]));
            const label = `${d.getMonth() + 1}/${d.getDate()}`;
            xaxis += `<text x="${pts[idx].x.toFixed(1)}" y="${H - 8}" text-anchor="middle" fill="#8f98a0" font-size="11">${label}</text>`;
        }

        // 峰值标注
        let peakSvg = '';
        let peakIdx = 0;
        for (let i = 1; i < n; i++) if (pts[i].v > pts[peakIdx].v) peakIdx = i;
        const pk = pts[peakIdx];
        const pkDate = new Date(poolDayStart(data[peakIdx][0]));
        peakSvg += `<circle cx="${pk.x.toFixed(1)}" cy="${pk.y.toFixed(1)}" r="3.5" fill="#f59e0b"/>`
            + `<text x="${pk.x.toFixed(1)}" y="${Math.max(pk.y - 9, 12).toFixed(1)}" text-anchor="middle" fill="#f59e0b" font-size="11">峰值 ${poolAxisNum(pk.v)}</text>`
            + `<text x="${pk.x.toFixed(1)}" y="${Math.max(pk.y - 22, 12).toFixed(1)}" text-anchor="middle" fill="#8f98a0" font-size="10">${pkDate.getMonth() + 1}/${pkDate.getDate()}</text>`;

        // 期初标注
        const first = pts[0];
        const firstDate = new Date(poolDayStart(data[0][0]));
        const firstSvg = `<circle cx="${first.x.toFixed(1)}" cy="${first.y.toFixed(1)}" r="3" fill="#38bdf8"/>`
            + `<text x="${(first.x + 6).toFixed(1)}" y="${(first.y + 14).toFixed(1)}" fill="#38bdf8" font-size="11">期初 ${poolAxisNum(first.v)}</text>`
            + `<text x="${(first.x + 6).toFixed(1)}" y="${(first.y + 26).toFixed(1)}" fill="#8f98a0" font-size="10">${firstDate.getMonth() + 1}/${firstDate.getDate()}</text>`;

        const last = pts[n - 1];
        const dot = `<circle cx="${last.x.toFixed(1)}" cy="${last.y.toFixed(1)}" r="4" fill="#66c0f4" stroke="#fff" stroke-width="2"><title>当前 ${poolAxisNum(last.v)}</title></circle>`;

        const color = opts.color || '#66c0f4';
        return `<svg viewBox="0 0 ${W} ${H}" class="sme-pool-chart" preserveAspectRatio="none" role="img" aria-label="池子价格指数曲线">
<defs><linearGradient id="sme-pool-grad" x1="0" y1="0" x2="0" y2="1"><stop offset="0%" stop-color="${color}" stop-opacity="0.25"/><stop offset="100%" stop-color="${color}" stop-opacity="0"/></linearGradient></defs>
${grid}
<path d="${area}" fill="url(#sme-pool-grad)"/>
<path d="${line}" stroke="${color}" stroke-width="2" fill="none" stroke-linejoin="round" stroke-linecap="round"/>
${peakSvg}${firstSvg}${dot}${xaxis}
</svg>`;
    }

    /** 涨跌色：涨绿跌红（沿用插件既有约定） */
    function poolChangeColor(pct) {
        if (Math.abs(pct) < 0.005) return 'var(--sme-text-dim)';
        return pct > 0 ? 'var(--sme-green)' : 'var(--sme-red)';
    }

    function poolFmtPct(pct, decimals) {
        const d = decimals === undefined ? 2 : decimals;
        const sign = pct > 0 ? '+' : '';
        return sign + pct.toFixed(d) + '%';
    }

    /** 热图色阶：涨绿跌红，按绝对幅度分 5 档 */
    function poolHeatColor(pct, maxAbs) {
        if (!isFinite(pct) || maxAbs <= 0) return { bg: 'transparent', fg: 'transparent' };
        const level = Math.min(5, Math.max(1, Math.ceil((Math.abs(pct) / maxAbs) * 5)));
        if (pct > 0) {
            const scale = [
                null,
                { bg: '#123b2a', fg: '#a8e6c0' },
                { bg: '#175a3d', fg: '#c8f2da' },
                { bg: '#1d8055', fg: '#e2fbee' },
                { bg: '#26a86f', fg: '#052e1c' },
                { bg: '#48c98f', fg: '#04231a' },
            ];
            return scale[level];
        }
        const scale = [
            null,
            { bg: '#3b1d1d', fg: '#f0b8b8' },
            { bg: '#5a2323', fg: '#f7d2d2' },
            { bg: '#7d2b2b', fg: '#ffe4e4' },
            { bg: '#a63434', fg: '#fff0f0' },
            { bg: '#c94c4c', fg: '#2a0505' },
        ];
        return scale[level];
    }

    // ---------- 模态框 ----------
    const POOL_TABS = [
        { prefix: 'overview', icon: 'chart', label: '总览', title: '池子行情总览', color: '#66c0f4' },
        { prefix: 'sector', icon: 'layers', label: '板块', title: '板块行情', color: '#4caf50' },
        { prefix: 'heat', icon: 'calendar', label: '热图', title: '市场热图', color: '#8b5cf6' },
        { prefix: 'items', icon: 'list', label: '池子', title: '我的池子', color: '#38bdf8' },
    ];

    function poolEnsureModal() {
        if (poolState.modalEl && document.body.contains(poolState.modalEl)) return poolState.modalEl;
        const modal = document.createElement('div');
        modal.id = 'sme-pool-modal';
        modal.className = 'sme-pool-modal';
        const tabsHtml = POOL_TABS.map((t) =>
            `<button class="sme-pool-tab" data-tab="${t.prefix}" style="--c:${t.color}">`
            + `${ICONS[t.icon] || ICONS.chart}<span>${escapeHtml(t.label)}</span></button>`).join('');
        modal.innerHTML = `
            <div class="sme-pool-win" role="dialog" aria-modal="true" aria-label="我的池子行情">
                <div class="sme-pool-win-header" id="sme-pool-header">
                    <div class="sme-pool-win-title">
                        <span class="sme-pool-win-ico" id="sme-pool-hi"></span>
                        <span id="sme-pool-ht">池子行情总览</span>
                        <span class="sme-pool-win-sub">我的池子</span>
                    </div>
                    <button class="sme-pool-win-close" id="sme-pool-close" aria-label="关闭">${ICONS.close}</button>
                </div>
                <div class="sme-pool-win-body">
                    <div class="sme-pool-toolbar" id="sme-pool-toolbar"></div>
                    <div class="sme-pool-tabs">${tabsHtml}</div>
                    <div class="sme-pool-panels" id="sme-pool-panels"></div>
                    <div class="sme-pool-mf">${ICONS.alert}<span id="sme-pool-note" class="sme-pool-mf-t"></span></div>
                </div>
            </div>`;
        document.body.appendChild(modal);
        poolState.modalEl = modal;

        const hide = () => modal.classList.remove('visible');
        modal.addEventListener('click', (e) => { if (e.target === modal) hide(); });
        modal.querySelector('#sme-pool-close').addEventListener('click', hide);
        modal.querySelector('.sme-pool-win').addEventListener('wheel', (e) => e.stopPropagation(), { passive: true });
        modal.querySelectorAll('.sme-pool-tab').forEach((btn) => {
            btn.addEventListener('click', (e) => {
                e.stopPropagation();
                poolShowPanel(btn.dataset.tab);
            });
        });
        const onKey = (e) => {
            if (e.key === 'Escape') { e.stopPropagation(); hide(); }
        };
        document.addEventListener('keydown', onKey, true);
        modal._dispose = () => document.removeEventListener('keydown', onKey, true);
        return modal;
    }

    function poolRenderPane(prefix) {
        const modal = poolEnsureModal();
        const tab = POOL_TABS.find((t) => t.prefix === prefix) || POOL_TABS[0];
        const panelsEl = modal.querySelector('#sme-pool-panels');
        let panel = panelsEl.querySelector(`.sme-pool-view[data-panel="${prefix}"]`);
        if (!panel) {
            panel = document.createElement('div');
            panel.className = 'sme-pool-view';
            panel.dataset.panel = prefix;
            const body = document.createElement('div');
            body.className = 'sme-pool-pbody';
            panel.appendChild(body);
            panelsEl.appendChild(panel);
        }
        const bodyEl = panel.querySelector('.sme-pool-pbody');
        let html = '';
        try {
            html = prefix === 'overview' ? poolPaneOverview()
                : prefix === 'sector' ? poolPaneSector()
                : prefix === 'heat' ? poolPaneHeat()
                : poolPaneItems();
        } catch (err) {
            W('Pool pane render failed:', prefix, err);
            html = `<div class="sme-pool-empty">面板渲染失败：${escapeHtml(err.message)}</div>`;
        }
        bodyEl.innerHTML = html;

        const header = modal.querySelector('#sme-pool-header');
        header.style.background = `linear-gradient(135deg,${tab.color}26,rgba(13,15,21,0.9))`;
        header.style.borderBottomColor = `${tab.color}40`;
        modal.querySelector('#sme-pool-hi').style.color = tab.color;
        modal.querySelector('#sme-pool-hi').innerHTML = ICONS[tab.icon] || ICONS.chart;
        modal.querySelector('#sme-pool-ht').textContent = tab.title;
        panelsEl.querySelectorAll('.sme-pool-view').forEach((p) => p.classList.toggle('active', p.dataset.panel === prefix));
        modal.querySelectorAll('.sme-pool-tab').forEach((b) => b.classList.toggle('active', b.dataset.tab === prefix));
        modal.classList.add('visible');
        poolState.lastTab = prefix;

        // 交互绑定
        modal.querySelectorAll('[data-pool-window]').forEach((b) => {
            b.addEventListener('click', () => {
                poolState.window = b.dataset.poolWindow;
                settings.set('poolWindow', poolState.window);
                poolShowPanel(prefix);
            });
        });
        modal.querySelectorAll('[data-pool-dim]').forEach((b) => {
            b.addEventListener('click', () => {
                poolState.sectorDim = b.dataset.poolDim;
                poolShowPanel(prefix);
            });
        });
        modal.querySelectorAll('[data-pool-remove]').forEach((b) => {
            b.addEventListener('click', () => {
                poolRemoveItem(b.dataset.poolRemove);
                poolShowPanel('items');
                poolRefreshPanelStatus();
            });
        });
        return bodyEl;
    }

    function poolShowPanel(prefix) {
        poolEnsureModal();
        poolRenderToolbar();
        poolRenderPane(prefix);
    }

    function poolRenderToolbar() {
        const modal = poolEnsureModal();
        const bar = modal.querySelector('#sme-pool-toolbar');
        if (!bar) return;
        const win = poolState.window;
        const winHtml = POOL_WINDOWS.map((w) =>
            `<button class="sme-pool-seg${w.id === win ? ' active' : ''}" data-pool-window="${w.id}">${escapeHtml(w.label)}</button>`).join('');
        const upd = poolState.lastUpdated
            ? new Date(poolState.lastUpdated).toLocaleString('zh-CN', { hour12: false })
            : '未采集';
        bar.innerHTML = `
            <div class="sme-pool-segs">${winHtml}</div>
            <div class="sme-pool-tool-right">
                <span class="sme-pool-tool-meta">池子 ${poolState.items.size} 件 · 更新于 ${escapeHtml(upd)}</span>
                <button class="sme-pool-btn${poolState.refreshing ? ' sme-danger' : ''}" id="sme-pool-refresh">${ICONS.refreshCw}<span>${poolState.refreshing ? '停止' : '刷新行情'}</span></button>
            </div>`;
        const btn = bar.querySelector('#sme-pool-refresh');
        // 采集中再点一次 = 中断（池子可能有几百件，逐件请求要跑一两分钟）
        if (btn) btn.addEventListener('click', () => {
            if (poolState.refreshing) {
                poolState.abort = true;
                poolSetStatus('正在停止…');
                btn.disabled = true;
            } else {
                poolRefreshQuotes();
            }
        });
    }

    /** 窗口 → 天数 */
    function poolWindowDays() {
        const w = POOL_WINDOWS.find((x) => x.id === poolState.window);
        return w ? w.days : 30;
    }

    /** 当前窗口内实际有数据的物品数（用于"数据不足"提示） */
    function poolDataSpan(seriesMap, days, nowDay) {
        let min = null, max = null, priced = 0;
        for (const series of seriesMap.values()) {
            const cur = poolCurrentPoint(series, nowDay);
            if (!cur) continue;
            priced++;
            if (min === null || cur[0] < min) min = cur[0];
            if (max === null || cur[0] > max) max = cur[0];
        }
        return { min, max, priced };
    }

    // ---------- 面板：总览 ----------
    function poolPaneOverview() {
        const nowDay = poolDayIndex(Date.now());
        const days = poolWindowDays();
        const seriesMap = poolState.series;
        const w = POOL_WINDOWS.find((x) => x.id === poolState.window) || POOL_WINDOWS[1];

        if (!poolState.items.size) {
            return '<div class="sme-pool-empty">池子还是空的。浏览市场时会自动收录，也可以点物品页的「关注」按钮加入。</div>';
        }
        if (!seriesMap.size) {
            return '<div class="sme-pool-empty">还没有采集过行情。点右上角「刷新行情」开始采集（每个物品一次请求，会慢一些）。</div>';
        }

        const idx = poolComputeIndex(seriesMap, days, nowDay);
        const idxSeries = poolComputeIndexSeries(seriesMap, days, nowDay);
        const cov = poolComputeCoverage(seriesMap, nowDay);
        const lows = poolComputeRecordLows(seriesMap, days, nowDay);
        const val = poolComputeValue(seriesMap, poolState.items, nowDay);
        const span = poolDataSpan(seriesMap, days, nowDay);
        const code = poolCurrencyCode();

        // 日变动：最后一个有数据的点 - 前一个有数据的点
        const valid = idxSeries.filter((p) => p[2]);
        let dayDelta = null;
        if (valid.length >= 2) dayDelta = valid[valid.length - 1][1] - valid[valid.length - 2][1];

        const cards = [
            poolStatCard('池子价格指数', idx.index.toFixed(2), dayDelta !== null ? (dayDelta >= 0 ? 'sme-up' : 'sme-down') : '', ICONS.chart,
                `较期初 ${poolFmtPct(idx.index - 100)}（${w.label}）`, '#66c0f4'),
            poolStatCard('日变动', dayDelta === null ? '—' : (dayDelta >= 0 ? '+' : '') + dayDelta.toFixed(2) + ' 点', '', ICONS.trendingUp,
                dayDelta === null ? '数据不足' : '较上一有效观测日', '#4caf50'),
            poolStatCard('价格覆盖', `${cov.priced}/${cov.total}`, '', ICONS.layers,
                `${cov.total ? Math.round(cov.priced / cov.total * 100) : 0}% 池子有有效价`, '#38bdf8'),
            poolStatCard('历史新低', String(lows.length) + ' 款', '', ICONS.trendingDown,
                `窗口内最低价（容差 0.5%）`, '#e24a4a'),
            poolStatCard('池子市值', formatCentsStr(val.cents, code), '', ICONS.dollarSign,
                `${val.priced} 款可定价 / ${val.count} 件`, '#f59e0b'),
        ].join('');

        const spanText = span.min !== null
            ? `数据覆盖 ${new Date(poolDayStart(span.min)).getMonth() + 1}/${new Date(poolDayStart(span.min)).getDate()} ~ ${new Date(poolDayStart(span.max)).getMonth() + 1}/${new Date(poolDayStart(span.max)).getDate()}，参与计算 ${idx.priced}/${idx.total} 款`
            : '暂无可用数据';

        const lowList = lows.slice(0, 8).map((hit) => {
            const it = poolState.items.get(hit.key);
            return `<li><span class="sme-pool-li-name">${escapeHtml(it ? it.name : hit.key)}</span>`
                + `<span class="sme-pool-li-meta">${formatCentsStr(hit.price, code)} · 窗口最低 ${formatCentsStr(hit.low, code)}</span></li>`;
        }).join('');

        return `
            <div class="sme-pool-stats">${cards}</div>
            <div class="sme-pool-block">
                <div class="sme-pool-block-title">价格指数曲线 <span class="sme-pool-block-sub">${escapeHtml(spanText)}</span></div>
                ${poolBuildChart(idxSeries, { color: '#66c0f4' })}
            </div>
            ${lows.length ? `<div class="sme-pool-block">
                <div class="sme-pool-block-title">历史新低清单 <span class="sme-pool-block-sub">共 ${lows.length} 款</span></div>
                <ul class="sme-pool-li">${lowList}</ul>
            </div>` : ''}
        `;
    }

    // ---------- 面板：板块 ----------
    function poolPaneSector() {
        const nowDay = poolDayIndex(Date.now());
        const days = poolWindowDays();
        const dim = poolState.sectorDim;
        const w = POOL_WINDOWS.find((x) => x.id === poolState.window);
        if (!poolState.series.size) {
            return '<div class="sme-pool-empty">还没有采集过行情，先点「刷新行情」。</div>';
        }
        const groups = poolGroupStats(poolState.items, poolState.series, dim, days, nowDay);
        if (!groups.length) return '<div class="sme-pool-empty">暂无可分组的物品。</div>';
        const code = poolCurrencyCode();
        const dimHtml = `<div class="sme-pool-segs">
            <button class="sme-pool-seg${dim === 'kind' ? ' active' : ''}" data-pool-dim="kind">按品类</button>
            <button class="sme-pool-seg${dim === 'game' ? ' active' : ''}" data-pool-dim="game">按游戏</button>
        </div>`;

        const rows = groups.map((g) => {
            const color = poolChangeColor(g.changePct);
            return `<tr>
                <td class="sme-pool-td-name">${escapeHtml(g.name)}</td>
                <td>${g.count}</td>
                <td>${g.priced}</td>
                <td style="color:${color}">${g.index.toFixed(2)}</td>
                <td style="color:${color}">${poolFmtPct(g.changePct)}</td>
                <td>${g.lowCount}</td>
                <td>${formatCentsStr(g.valueCents, code)}</td>
            </tr>`;
        }).join('');

        return `
            <div class="sme-pool-block">
                <div class="sme-pool-block-title">板块行情 <span class="sme-pool-block-sub">${escapeHtml(w.label)}窗口 · ${dim === 'kind' ? '按品类' : '按游戏'}</span></div>
                ${dimHtml}
                <div class="sme-pool-table-wrap">
                <table class="sme-pool-table">
                    <thead><tr><th>分组</th><th>物品</th><th>有价</th><th>指数</th><th>较期初</th><th>新低</th><th>市值</th></tr></thead>
                    <tbody>${rows}</tbody>
                </table>
                </div>
            </div>
        `;
    }

    // ---------- 面板：热图 ----------
    function poolPaneHeat() {
        const nowDay = poolDayIndex(Date.now());
        const days = poolWindowDays();
        if (!poolState.series.size) {
            return '<div class="sme-pool-empty">还没有采集过行情，先点「刷新行情」。</div>';
        }
        const groups = poolGroupStats(poolState.items, poolState.series, poolState.sectorDim, days, nowDay);
        if (!groups.length) return '<div class="sme-pool-empty">暂无可分组的物品。</div>';

        // 只画前 12 个分组，避免热图过高
        const top = groups.slice(0, 12);
        const byDay = poolGroupIndexByDay(top, days, nowDay);

        // 收集全部格子，算出最大绝对涨跌幅
        let minDay = Infinity, maxDay = -Infinity;
        for (const m of byDay.values()) {
            for (const d of m.keys()) {
                if (d < minDay) minDay = d;
                if (d > maxDay) maxDay = d;
            }
        }
        if (!isFinite(minDay)) return '<div class="sme-pool-empty">窗口内没有足够的日序列，无法生成热图。</div>';

        const daysList = [];
        for (let d = minDay; d <= maxDay; d++) daysList.push(d);
        // 列太多时抽样（保留首尾）
        let cols = daysList;
        if (daysList.length > 40) {
            const step = Math.ceil(daysList.length / 40);
            cols = daysList.filter((_, i) => i % step === 0);
            if (cols[cols.length - 1] !== daysList[daysList.length - 1]) cols.push(daysList[daysList.length - 1]);
        }

        let maxAbs = 0;
        const cellMap = new Map();
        for (const g of top) {
            const m = byDay.get(g.name);
            for (const d of cols) {
                const idx = m ? m.get(d) : undefined;
                if (idx === undefined) { cellMap.set(g.name + '|' + d, null); continue; }
                const pct = idx - 100;
                if (Math.abs(pct) > maxAbs) maxAbs = Math.abs(pct);
                cellMap.set(g.name + '|' + d, pct);
            }
        }

        const head = '<tr><th class="sme-pool-th-corner"></th>'
            + cols.map((d) => {
                const dt = new Date(poolDayStart(d));
                return `<th class="sme-pool-th-day">${dt.getMonth() + 1}/${dt.getDate()}</th>`;
            }).join('') + '</tr>';

        const body = top.map((g) => {
            const cells = cols.map((d) => {
                const pct = cellMap.get(g.name + '|' + d);
                if (pct === null || pct === undefined) return '<td class="sme-pool-heat-cell empty"></td>';
                const c = poolHeatColor(pct, maxAbs);
                return `<td class="sme-pool-heat-cell" style="background:${c.bg};color:${c.fg}" title="${escapeHtml(g.name)} ${poolFmtPct(pct)}">${pct.toFixed(0)}</td>`;
            }).join('');
            return `<tr><th class="sme-pool-th-name">${escapeHtml(g.name)}</th>${cells}</tr>`;
        }).join('');

        return `
            <div class="sme-pool-block">
                <div class="sme-pool-block-title">市场热图 <span class="sme-pool-block-sub">分组 × 日期 · 数值=较期初涨跌幅(%)</span></div>
                <div class="sme-pool-segs">
                    <button class="sme-pool-seg${poolState.sectorDim === 'kind' ? ' active' : ''}" data-pool-dim="kind">按品类</button>
                    <button class="sme-pool-seg${poolState.sectorDim === 'game' ? ' active' : ''}" data-pool-dim="game">按游戏</button>
                </div>
                <div class="sme-pool-heat-wrap">
                    <table class="sme-pool-heat"><thead>${head}</thead><tbody>${body}</tbody></table>
                </div>
                <div class="sme-pool-legend">
                    <span>跌</span>
                    ${[5, 4, 3, 2, 1].map((l) => {
                        const c = poolHeatColor(-l, 5);
                        return `<i style="background:${c.bg}"></i>`;
                    }).join('')}
                    <span>0</span>
                    ${[1, 2, 3, 4, 5].map((l) => {
                        const c = poolHeatColor(l, 5);
                        return `<i style="background:${c.bg}"></i>`;
                    }).join('')}
                    <span>涨</span>
                    <span class="sme-pool-legend-meta">最大幅度 ${maxAbs.toFixed(1)}%</span>
                </div>
            </div>
        `;
    }

    // ---------- 面板：池子明细 ----------
    function poolPaneItems() {
        const nowDay = poolDayIndex(Date.now());
        const days = poolWindowDays();
        const code = poolCurrencyCode();
        const lows = new Set(poolComputeRecordLows(poolState.series, days, nowDay).map((h) => h.key));

        if (!poolState.items.size) {
            return '<div class="sme-pool-empty">池子还是空的。浏览市场时会自动收录，也可以点物品页的「关注」按钮加入。</div>';
        }

        const rows = [];
        for (const [key, it] of poolState.items) {
            const series = poolState.series.get(key) || [];
            const cur = poolCurrentPoint(series, nowDay);
            const base = poolBasePoint(series, days, nowDay);
            let changePct = null;
            if (cur && base && base[1] > 0) changePct = (cur[1] / base[1] - 1) * 100;
            const isLow = lows.has(key);
            // v1.9.0：挂刀列需要 appid + market_hash_name（poolKey 前2段）
            const [itAppid, ...itNameParts] = key.split('::');
            const itName = it.name || itNameParts.join('::');
            rows.push({
                key, it, price: cur ? cur[1] : 0, hasPrice: !!cur,
                changePct, isLow,
                src: (it.sources || []).join('/') || '—',
                ratioCell: (settings.get('poolRatioScan') && settings.get('crossPlatformQuote'))
                    ? ratioPoolCellHtml(itAppid, itName) : null,
            });
        }
        rows.sort((a, b) => (b.hasPrice - a.hasPrice) || (b.price - a.price));

        const tr = rows.map((r) => {
            const color = r.changePct === null ? 'var(--sme-text-muted)' : poolChangeColor(r.changePct);
            return `<tr>
                <td class="sme-pool-td-name">${escapeHtml(r.it.name)}${r.isLow ? '<span class="sme-pool-low-flag">新低</span>' : ''}</td>
                <td class="sme-pool-td-dim">${escapeHtml(r.it.game || '—')}</td>
                <td class="sme-pool-td-dim">${escapeHtml(r.it.kind || '其他')}</td>
                <td>${r.hasPrice ? formatCentsStr(r.price, code) : '<span class="sme-pool-td-none">无价</span>'}</td>
                <td style="color:${color}">${r.changePct === null ? '—' : poolFmtPct(r.changePct)}</td>
                ${r.ratioCell !== null ? `<td>${r.ratioCell}</td>` : ''}
                <td class="sme-pool-td-dim">${escapeHtml(r.src)}</td>
                <td><button class="sme-pool-del" data-pool-remove="${escapeHtml(r.key)}" title="从池子移除">${ICONS.trash}</button></td>
            </tr>`;
        }).join('');

        return `
            <div class="sme-pool-block">
                <div class="sme-pool-block-title">我的池子 <span class="sme-pool-block-sub">${rows.length} 款 · 有价 ${rows.filter((r) => r.hasPrice).length} 款</span></div>
                <div class="sme-pool-table-wrap">
                <table class="sme-pool-table">
                    <thead><tr><th>物品</th><th>游戏</th><th>品类</th><th>当前价</th><th>较期初</th>${rows.some((r) => r.ratioCell !== null) ? '<th title="平台最低价 ÷ Steam 24h 中位价，来自手动扫描/详情页查看的缓存">挂刀</th>' : ''}<th>来源</th><th></th></tr></thead>
                    <tbody>${tr}</tbody>
                </table>
                </div>
            </div>
        `;
    }

    // ---------- 市场页工具条 ----------
    function poolSetStatus(text) {
        const el = document.getElementById('sme-pool-status');
        if (el) el.textContent = text;
    }

    function poolSetProgress(ratio) {
        const bar = document.getElementById('sme-pool-progress-bar');
        if (bar) bar.style.width = Math.max(0, Math.min(1, ratio)) * 100 + '%';
    }

    function poolRefreshPanelStatus() {
        const el = document.getElementById('sme-pool-status');
        if (!el) return;
        if (poolState.refreshing) return;
        const n = poolState.items.size;
        const upd = poolState.lastUpdated
            ? new Date(poolState.lastUpdated).toLocaleString('zh-CN', { hour12: false })
            : '未采集';
        el.textContent = n ? `池子 ${n} 件 · 更新于 ${upd}` : '池子为空';
    }

    function poolInjectPanel() {
        const tabs = document.getElementById('myMarketTabs');
        if (!tabs) return false;
        if (poolState.panelEl && document.body.contains(poolState.panelEl)) return true;

        const panel = h('div', { class: 'sme-pool-panel', id: 'sme-pool-panel' }, [
            h('div', { class: 'sme-pool-panel-inner' }, [
                h('span', { class: 'sme-pool-title', html: ICONS.chart + '<span>池子行情</span>' }),
                h('span', { class: 'sme-pool-status', id: 'sme-pool-status' }),
                h('span', { class: 'sme-pool-actions' }, [
                    h('button', {
                        id: 'sme-pool-refresh-btn', class: 'sme-pool-btn', type: 'button',
                        html: ICONS.refreshCw + '<span>刷新行情</span>',
                        title: '逐件采集池子内物品的价格历史并落成日快照（采集中再点一次可中断）',
                        onClick: async () => {
                            if (poolState.refreshing) {
                                poolState.abort = true;
                                poolSetStatus('正在停止…');
                                return;
                            }
                            await poolRefreshQuotes();
                        },
                    }),
                    h('button', {
                        id: 'sme-pool-open-btn', class: 'sme-pool-btn', type: 'button',
                        html: ICONS.layers + '<span>行情分析</span>',
                        title: '打开池子行情分析（总览 / 板块 / 热图 / 池子）',
                        onClick: () => poolShowPanel(poolState.lastTab || 'overview'),
                    }),
                    h('button', {
                        id: 'sme-fxq-btn', class: 'sme-pool-btn', type: 'button',
                        html: ICONS.dollarSign + '<span>汇率报价</span>',
                        title: '美金卡比价与 CS2 箱子汇率',
                        onClick: () => fxqToggle(),
                    }),
                    // v1.9.0：挂刀扫描（默认关，设置 poolRatioScan 控制；仅 BUFF 单源）
                    ...(settings.get('poolRatioScan') ? [h('button', {
                        id: 'sme-pool-ratio-btn', class: 'sme-pool-btn', type: 'button',
                        html: ICONS.chart + '<span>扫描挂刀</span>',
                        title: '对池子内 CS2/DOTA2 物品逐件请求 BUFF 在售价并计算挂刀比例（限速 1.5s/件，单轮 100 件，可中断）',
                        onClick: () => poolRatioScan(),
                    })] : []),
                ]),
            ]),
            h('div', { class: 'sme-pool-progress' }, [
                h('div', { class: 'sme-pool-progress-bar', id: 'sme-pool-progress-bar' }),
            ]),
        ]);
        poolState.panelEl = panel;
        const host = tabs.parentNode || tabs;
        host.insertBefore(panel, tabs);
        poolRefreshPanelStatus();
        return true;
    }

    function initPoolPanel() {
        if (!settings.get('poolPanel')) return;
        if (detectPageType() !== 'browse') return;
        if (!poolState.styleAdded) {
            GM_addStyle(POOL_CSS);
            poolState.styleAdded = true;
        }
        let attempts = 0;
        const tryStart = () => {
            if (poolInjectPanel()) {
                poolState.active = true;
                poolRefreshPanelStatus();
                return;
            }
            if (attempts++ < 30) setTimeout(tryStart, 500);
        };
        tryStart();
    }

    function cleanupPoolPanel() {
        if (poolState.panelEl) { poolState.panelEl.remove(); poolState.panelEl = null; }
        if (poolState.browseObserver) { poolState.browseObserver.disconnect(); poolState.browseObserver = null; }
        if (poolState.scanTimer) { clearTimeout(poolState.scanTimer); poolState.scanTimer = null; }
        if (poolState.modalEl) {
            if (poolState.modalEl._dispose) poolState.modalEl._dispose();
            poolState.modalEl.remove();
            poolState.modalEl = null;
        }
        poolState.refreshing = false;
        poolState.abort = true;
    }

    // ---------- 浏览页自动收录 ----------
    function poolInitBrowseTracker() {
        if (!settings.get('poolAutoTrack')) return;
        if (poolState.browseObserver) return;
        const seen = new WeakSet();
        const scan = () => {
            const rows = document.querySelectorAll('a.market_listing_row_link');
            for (const row of rows) {
                if (seen.has(row)) continue;
                seen.add(row);
                const href = row.getAttribute('href') || row.href || '';
                const m = href.match(/\/market\/listings\/(\d+)\/(.+?)(?:\?.*)?$/);
                if (!m) continue;
                let appid, hashName;
                try { appid = m[1]; hashName = decodeURIComponent(m[2]); } catch (e) { continue; }
                const nameEl = row.querySelector('.market_listing_item_name');
                const gameEl = row.querySelector('.market_listing_game_name');
                poolAddItem({
                    appid, hashName,
                    name: nameEl ? nameEl.textContent.trim() : hashName,
                    game: gameEl ? gameEl.textContent.trim() : '',
                }, 'browse');
            }
        };
        const schedule = () => {
            if (poolState.scanTimer) return;
            poolState.scanTimer = setTimeout(() => { poolState.scanTimer = null; scan(); }, 600);
        };
        scan();
        const mo = new MutationObserver(schedule);
        try { mo.observe(document.body, { childList: true, subtree: true }); } catch (e) { return; }
        poolState.browseObserver = mo;
    }

    // ---------- 详情页「关注」按钮 ----------
    function poolSyncWatchButton() {
        const btn = document.getElementById('sme-pool-watch-btn');
        if (!btn) return;
        const has = listingInfo && listingInfo.appid && listingInfo.marketHashName
            ? poolHasItem(listingInfo.appid, listingInfo.marketHashName)
            : false;
        btn.innerHTML = (has ? ICONS.starFilled : ICONS.starOutline) + `<span>${has ? '已关注' : '关注'}</span>`;
        btn.classList.toggle('active', has);
    }

    function initPoolWatchButton() {
        if (!settings.get('poolPanel')) return;
        let tries = 0;
        const tryInject = () => {
            const host = document.querySelector('.sme-panel .sme-header-title');
            if (host && !document.getElementById('sme-pool-watch-btn')) {
                const btn = h('button', {
                    id: 'sme-pool-watch-btn', class: 'sme-pool-watch', type: 'button',
                    html: ICONS.starOutline + '<span>关注</span>',
                    title: '把这件物品加入「我的池子」，用于池子行情分析',
                    onClick: () => poolToggleWatch(),
                });
                host.appendChild(btn);
                poolSyncWatchButton();
                return;
            }
            if (tries++ < 40) setTimeout(tryInject, 300);
        };
        setTimeout(tryInject, 300);
    }

    // ---------- 库存页：批量收录 ----------
    function poolCollectInventoryItems() {
        const out = [];
        const els = document.querySelectorAll('.inventory_ctn .item');
        for (const el of els) {
            const d = getRgItemFromElement(el);
            if (!d || !isInvMarketable(d)) continue;
            const hash = d.market_hash_name;
            if (!hash) continue;
            out.push({
                appid: d.appid,
                hashName: hash,
                name: d.name || hash,
                qty: d.amount,
            });
        }
        return out;
    }

    function poolAddInventoryToPool() {
        const items = poolCollectInventoryItems();
        if (!items.length) {
            toast('未找到可市场物品（库存可能尚未加载）', 'warning');
            return;
        }
        let added = 0;
        for (const it of items) {
            if (poolAddItem(it, 'inventory')) added++;
        }
        poolSave();
        poolRefreshPanelStatus();
        toast(added ? `已加入 ${added} 款到池子` : '池子已满或物品已在池中', added ? 'success' : 'warning');
    }

    // ---------- v1.7.0 样式 ----------
    const POOL_CSS = `
.sme-pool-panel{display:block;margin:8px 0 4px;padding:0;border-radius:6px;background:var(--sme-bg-card);border:1px solid rgba(255,255,255,0.06)}
.sme-pool-panel-inner{display:flex;align-items:center;gap:10px;padding:6px 10px;flex-wrap:wrap}
.sme-pool-title{display:inline-flex;align-items:center;gap:6px;font-size:13px;color:var(--sme-text-bright);font-weight:600}
.sme-pool-title .sme-svg{width:15px;height:15px;color:var(--sme-blue)}
.sme-pool-status{font-size:12px;color:var(--sme-text-muted);flex:1;min-width:120px}
.sme-pool-actions{display:inline-flex;align-items:center;gap:6px;margin-left:auto}
.sme-pool-btn{display:inline-flex;align-items:center;gap:5px;padding:4px 10px;font-size:12px;color:var(--sme-text);
  background:rgba(255,255,255,0.05);border:1px solid rgba(255,255,255,0.09);border-radius:4px;cursor:pointer;line-height:1.4}
.sme-pool-btn:hover{background:rgba(255,255,255,0.1);color:var(--sme-text-bright)}
.sme-pool-btn:disabled{opacity:.5;cursor:default}
.sme-pool-btn .sme-svg{width:13px;height:13px}
.sme-pool-progress{height:2px;background:var(--sme-track);border-radius:0 0 6px 6px;overflow:hidden}
.sme-pool-progress-bar{height:100%;width:0;background:var(--sme-blue);transition:width .2s}
.sme-pool-watch{display:inline-flex;align-items:center;gap:4px;margin-left:auto;padding:3px 9px;font-size:12px;
  color:var(--sme-text);background:rgba(255,255,255,0.05);border:1px solid rgba(255,255,255,0.09);border-radius:4px;cursor:pointer}
.sme-pool-watch:hover{background:rgba(255,255,255,0.1)}
.sme-pool-watch.active{color:var(--sme-amber);border-color:rgba(245,158,11,0.4);background:rgba(245,158,11,0.1)}
.sme-pool-watch .sme-svg{width:13px;height:13px}
.sme-pool-modal{position:fixed;inset:0;z-index:10050;display:none;align-items:center;justify-content:center;
  background:rgba(0,0,0,0.62);backdrop-filter:blur(3px)}
.sme-pool-modal.visible{display:flex}
.sme-pool-modal{
  /* 池子模块自持的 token：指标卡样式不依赖 mh 模块的 --mh-* （那个作用域限定在 .sme-mh-*） */
  --pool-line:rgba(255,255,255,.07);
  --pool-line-2:rgba(255,255,255,.13);
  --pool-t1:#e9eff5;
  --pool-t2:#9aa9b8;
  --pool-t3:#6b7a89;
  --pool-up:#4ade80;
  --pool-down:#f87171;
  --pool-ease:cubic-bezier(.4,0,.2,1);
}
.sme-pool-stats{display:grid;grid-template-columns:repeat(auto-fit,minmax(168px,1fr));gap:10px;margin-bottom:12px}
.sme-pool-stat{
  --accent:#66c0f4;
  position:relative;overflow:hidden;min-width:0;
  padding:11px 13px 10px;border-radius:10px;
  background:linear-gradient(180deg,rgba(35,45,57,.72) 0%,rgba(27,34,43,.72) 100%);
  border:1px solid var(--pool-line);
  box-shadow:0 1px 2px rgba(0,0,0,.30);
  transition:transform .16s var(--pool-ease),border-color .16s var(--pool-ease),box-shadow .16s var(--pool-ease);
}
.sme-pool-stat::before{
  content:"";position:absolute;left:16px;right:16px;top:0;height:2px;width:auto;
  background:linear-gradient(90deg,transparent,var(--accent) 16%,var(--accent) 84%,transparent);
  box-shadow:0 0 8px var(--accent);
}
.sme-pool-stat:hover{
  transform:translateY(-2px);
  border-color:color-mix(in srgb,var(--accent) 62%,transparent);
  box-shadow:0 8px 20px rgba(0,0,0,.28),0 0 16px color-mix(in srgb,var(--accent) 22%,transparent);
}
.sme-pool-stat-ico{position:absolute;top:12px;right:12px;display:inline-flex;color:var(--accent);opacity:.72}
.sme-pool-stat-ico svg{width:15px;height:15px;display:block}
.sme-pool-stat-label{
  font-size:11px;font-weight:500;color:var(--pool-t3);letter-spacing:.3px;padding-right:22px;
  overflow:hidden;text-overflow:ellipsis;white-space:nowrap;
}
.sme-pool-stat-value{
  font-size:19px;font-weight:700;color:var(--pool-t1);margin-top:6px;line-height:1.2;
  font-variant-numeric:tabular-nums;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;
}
.sme-pool-stat-value.is-up{color:var(--pool-up)}
.sme-pool-stat-value.is-down{color:var(--pool-down)}
.sme-pool-stat-hint{font-size:10px;color:var(--pool-t3);margin-top:4px;line-height:1.5}
.sme-pool-win{width:min(980px,94vw);max-height:88vh;display:flex;flex-direction:column;overflow:hidden;
  background:var(--sme-bg);border:1px solid rgba(255,255,255,0.1);border-radius:8px;box-shadow:0 12px 48px rgba(0,0,0,.55)}
.sme-pool-win-header{display:flex;align-items:center;justify-content:space-between;padding:10px 14px;border-bottom:1px solid rgba(255,255,255,0.08)}
.sme-pool-win-title{display:flex;align-items:center;gap:8px;font-size:14px;font-weight:600;color:var(--sme-text-bright)}
.sme-pool-win-ico .sme-svg{width:18px;height:18px}
.sme-pool-win-sub{font-size:11px;color:var(--sme-text-muted);font-weight:400;margin-left:4px}
.sme-pool-win-close{background:none;border:none;cursor:pointer;color:var(--sme-text-dim);padding:4px;line-height:0}
.sme-pool-win-close:hover{color:var(--sme-text-bright)}
.sme-pool-win-close .sme-svg{width:16px;height:16px}
.sme-pool-win-body{display:flex;flex-direction:column;min-height:0;flex:1}
.sme-pool-toolbar{display:flex;align-items:center;gap:10px;padding:8px 14px;border-bottom:1px solid rgba(255,255,255,0.05);flex-wrap:wrap}
.sme-pool-tool-right{display:flex;align-items:center;gap:10px;margin-left:auto}
.sme-pool-tool-meta{font-size:11px;color:var(--sme-text-muted)}
.sme-pool-segs{display:inline-flex;gap:2px;padding:2px;background:rgba(255,255,255,0.05);border-radius:5px}
.sme-pool-seg{padding:3px 10px;font-size:12px;color:var(--sme-text-dim);background:none;border:none;border-radius:3px;cursor:pointer}
.sme-pool-seg.active{background:var(--sme-blue-a20);color:var(--sme-blue)}
.sme-pool-tabs{display:flex;gap:2px;padding:6px 14px 0;border-bottom:1px solid rgba(255,255,255,0.06)}
.sme-pool-tab{display:inline-flex;align-items:center;gap:5px;padding:6px 12px;font-size:12px;color:var(--sme-text-dim);
  background:none;border:none;border-bottom:2px solid transparent;cursor:pointer}
.sme-pool-tab .sme-svg{width:13px;height:13px}
.sme-pool-tab.active{color:var(--c);border-bottom-color:var(--c)}
.sme-pool-panels{flex:1;min-height:0;overflow-y:auto;padding:12px 14px}
.sme-pool-view{display:none}
.sme-pool-view.active{display:block}
.sme-pool-empty{padding:26px 10px;text-align:center;color:var(--sme-text-muted);font-size:13px}
.sme-pool-block{margin-bottom:18px}
.sme-pool-block-title{font-size:13px;font-weight:600;color:var(--sme-text-bright);margin-bottom:8px;display:flex;align-items:baseline;gap:8px}
.sme-pool-block-sub{font-size:11px;font-weight:400;color:var(--sme-text-muted)}
.sme-pool-chart{width:100%;height:auto;display:block}
.sme-pool-li{list-style:none;margin:0;padding:0}
.sme-pool-li li{display:flex;justify-content:space-between;gap:12px;padding:5px 8px;border-bottom:1px solid rgba(255,255,255,0.04);font-size:12px}
.sme-pool-li-name{color:var(--sme-text)}
.sme-pool-li-meta{color:var(--sme-text-muted);white-space:nowrap}
.sme-pool-table-wrap{overflow-x:auto;border:1px solid rgba(255,255,255,0.06);border-radius:5px}
.sme-pool-table{width:100%;border-collapse:collapse;font-size:12px}
.sme-pool-table th{position:sticky;top:0;background:rgba(23,26,33,0.98);color:var(--sme-text-dim);font-weight:600;
  text-align:left;padding:7px 9px;border-bottom:1px solid rgba(255,255,255,0.08);white-space:nowrap}
.sme-pool-table td{padding:6px 9px;border-bottom:1px solid rgba(255,255,255,0.04);color:var(--sme-text);white-space:nowrap}
.sme-pool-table tr:last-child td{border-bottom:none}
.sme-pool-td-name{color:var(--sme-text-bright);max-width:280px;overflow:hidden;text-overflow:ellipsis}
.sme-pool-td-dim{color:var(--sme-text-dim)}
.sme-pool-td-none{color:var(--sme-text-muted)}
.sme-pool-low-flag{display:inline-block;margin-left:6px;padding:0 5px;font-size:10px;color:#2a0505;background:#c94c4c;border-radius:3px}
.sme-pool-del{background:none;border:none;cursor:pointer;color:var(--sme-text-muted);padding:2px;line-height:0}
.sme-pool-del:hover{color:var(--sme-red)}
.sme-pool-del .sme-svg{width:13px;height:13px}
.sme-pool-heat-wrap{overflow:auto;border:1px solid rgba(255,255,255,0.06);border-radius:5px;max-height:60vh}
.sme-pool-heat{border-collapse:separate;border-spacing:2px;font-size:11px}
.sme-pool-heat th{color:var(--sme-text-dim);font-weight:600;padding:3px 5px;white-space:nowrap}
.sme-pool-th-name{position:sticky;left:0;background:var(--sme-bg);z-index:1;text-align:right;max-width:130px;overflow:hidden;text-overflow:ellipsis}
.sme-pool-th-day{font-size:10px}
.sme-pool-th-corner{position:sticky;left:0;background:var(--sme-bg);z-index:2}
.sme-pool-heat-cell{width:26px;height:20px;text-align:center;border-radius:2px;padding:0}
.sme-pool-heat-cell.empty{background:transparent}
.sme-pool-legend{display:flex;align-items:center;gap:3px;margin-top:8px;font-size:11px;color:var(--sme-text-muted)}
.sme-pool-legend i{width:16px;height:10px;border-radius:2px;display:inline-block}
.sme-pool-legend-meta{margin-left:10px}
.sme-pool-mf{display:flex;align-items:center;gap:6px;padding:6px 14px;font-size:11px;color:var(--sme-text-muted);border-top:1px solid rgba(255,255,255,0.05)}
.sme-pool-mf .sme-svg{width:12px;height:12px;flex:none}
`;

    // ==================== v2.0.0 价格提醒 ====================
    /**
     * 「价格提醒」——竞品（SIH / Steam Helper / 各聚合站）都有、本插件此前完全缺失的能力。
     *
     * 设计取舍：
     *   · **只读、不写**：只调 priceoverview 与池子已有的日快照，不碰任何下单接口
     *     → ToS 风险最低，也最不容易把账号搞出问题。
     *   · **基准是「添加提醒那一刻的价格」**，不是滚动均值 —— 用户要的是
     *     「我记下的那个价，跌了多少」，滚动基准会让人看不懂。
     *   · **幂等**：同一价位只通知一次（smeAlertCheck 判定），避免每轮轮询重复推送。
     *   · 优先复用池子的日快照（零请求）；没有快照才回退 priceoverview。
     *
     * 数据落在 IndexedDB 的 kv store（键 sme_alerts_v1）。
     */
    const ALERTS_KEY = 'sme_alerts_v1';
    const alertsState = {
        map: {},          // "appid::hash" → {appid, hash, name, baseCents, dropPct, lastNotifiedCents, addedAt, vol?{cv,r2,level,ts}}
        loaded: false,
        modalEl: null,
        evaluating: false,
    };

    function alertKey(appid, hash) { return String(appid) + '::' + String(hash); }

    async function alertsLoad() {
        if (alertsState.loaded) return alertsState.map;
        const raw = await smeKv.get(ALERTS_KEY, '{}');
        let parsed = {};
        try { parsed = (typeof raw === 'string') ? JSON.parse(raw || '{}') : (raw || {}); }
        catch (e) { parsed = {}; }
        alertsState.map = parsed || {};
        alertsState.loaded = true;
        return alertsState.map;
    }

    async function alertsSave() {
        await smeKv.set(ALERTS_KEY, JSON.stringify(alertsState.map));
    }

    /** 当前物品的价格（分）：优先池子日快照，其次 priceoverview */
    async function alertsCurrentPriceCents(appid, hash) {
        // 1) 池子日快照（零请求）
        try {
            const series = poolState.series.get(appid + '::' + hash);
            if (series && series.length) {
                const nowDay = poolDayIndex(Date.now());
                const pt = poolCurrentPoint(series, nowDay);
                if (pt && pt[1] > 0) return pt[1];
            }
        } catch (e) { /* 落到 priceoverview */ }
        // 2) priceoverview
        try {
            const url = 'https://steamcommunity.com/market/priceoverview/?appid=' + encodeURIComponent(appid)
                + '&market_hash_name=' + encodeURIComponent(hash)
                + '&currency=' + (getWalletInfo().wallet_currency || 1);
            const data = await smeRequest(url, { expect: 'json' });
            if (!data || !data.success || !data.lowest_price) return 0;
            const cents = parsePriceToCents(String(data.lowest_price));
            return cents > 0 ? cents : 0;
        } catch (e) { return 0; }
    }

    /** 添加/移除当前物品的提醒 */
    async function alertsToggleCurrent() {
        const info = listingInfo || getListingInfo();
        if (!info || !info.appid || !info.marketHashName) {
            toast('当前页面没有可识别的市场物品', 'warning');
            return;
        }
        await alertsLoad();
        const key = alertKey(info.appid, info.marketHashName);
        if (alertsState.map[key]) {
            delete alertsState.map[key];
            await alertsSave();
            toast('已取消价格提醒', 'info');
            alertsSyncButton();
            return;
        }
        const base = await alertsCurrentPriceCents(info.appid, info.marketHashName);
        if (!base) { toast('取不到当前价格，无法添加提醒', 'warning'); return; }
        const dropPct = parseFloat(settings.get('priceAlertDropPct')) || 0.1;
        alertsState.map[key] = {
            appid: String(info.appid),
            hash: String(info.marketHashName),
            name: String(info.marketHashName),
            baseCents: base,
            dropPct: dropPct,
            lastNotifiedCents: null,
            addedAt: Date.now(),
        };
        await alertsSave();
        toast('已添加提醒：跌破 ' + Math.round(dropPct * 100) + '% 时通知', 'success');
        alertsSyncButton();
        alertsAttachVol(key); // v2.1.0：异步补波动率标注（失败静默，不阻塞提醒创建）
    }

    /**
     * v2.1.0 波动率标注：给刚创建的提醒异步补 vol 字段（借鉴 AetherSwap 的 CV+R² 选品思想：
     * 低波动物品的「史低/降价提醒」才可信，持续阴跌是趋势而非买点）。
     * 失败静默——拿不到 pricehistory、或近 30 天点数 < 10 就不存 vol，绝不阻塞提醒创建。
     */
    async function alertsAttachVol(key) {
        try {
            const a = alertsState.map[key];
            if (!a || !window.VolMetrics) return;
            const hist = await fetchPriceHistory(a.appid, a.hash);
            if (!hist || !Array.isArray(hist.prices)) return;
            const cutoff = Date.now() - 30 * 24 * 3600 * 1000;
            const series = [];
            for (const pt of hist.prices) {
                // p = 中位价（货币单位；CV 量纲无关，直接用即可）
                if (pt && pt.t >= cutoff && Number.isFinite(pt.p)) series.push(pt.p);
            }
            if (series.length < 10) return; // 点太少，CV 不可信
            const m = window.VolMetrics.metricsOf(series);
            if (!m) return;
            const cur = alertsState.map[key];
            if (!cur) return; // 用户已删掉这条提醒
            cur.vol = { cv: m.cv, r2: m.r2, level: m.level, ts: Date.now() };
            await alertsSave();
        } catch (e) { /* 静默：波动率只是增强标注，任何失败都不影响提醒本身 */ }
    }

    /** v2.1.0：波动率等级 → 徽章文案（hover 提示显示 CV / R²） */
    const ALERT_VOL_BADGES = {
        stable: { text: '稳', cls: 'sme-vol-badge--stable' },
        normal: { text: '一般', cls: 'sme-vol-badge--normal' },
        volatile: { text: '波动大', cls: 'sme-vol-badge--volatile' },
        declining: { text: '下行中', cls: 'sme-vol-badge--declining' },
    };

    function alertsVolBadgeEl(vol) {
        if (!vol || !ALERT_VOL_BADGES[vol.level]) return null;
        const cfg = ALERT_VOL_BADGES[vol.level];
        const cv = Number(vol.cv), r2 = Number(vol.r2);
        const tip = (Number.isFinite(cv) && Number.isFinite(r2))
            ? '近 30 天波动：CV ' + cv.toFixed(2) + ' · R² ' + r2.toFixed(2) : null;
        return h('span', { class: 'sme-vol-badge ' + cfg.cls, text: cfg.text, title: tip });
    }

    /** 请求浏览器通知权限（只在用户开启时请求一次） */
    function requestAlertNotifyPermission() {
        try {
            if (typeof Notification === 'undefined') return;
            if (Notification.permission === 'default') Notification.requestPermission().catch(() => {});
        } catch (e) { /* 浏览器不支持则忽略 */ }
    }

    /** 详情页「提醒」按钮状态 */
    function alertsSyncButton() {
        const btn = document.getElementById('sme-alert-btn');
        if (!btn) return;
        const info = listingInfo || getListingInfo();
        const on = !!(info && info.appid && info.marketHashName
            && alertsState.map[alertKey(info.appid, info.marketHashName)]);
        btn.innerHTML = ICONS.alert + `<span>${on ? '已提醒' : '价格提醒'}</span>`;
        btn.classList.toggle('active', on);
    }

    /** 评估所有提醒并推送通知（幂等） */
    async function alertsEvaluate() {
        if (alertsState.evaluating) return;
        await alertsLoad();
        const keys = Object.keys(alertsState.map);
        if (!keys.length) return;
        alertsState.evaluating = true;
        let changed = false;
        try {
            for (const key of keys) {
                const a = alertsState.map[key];
                if (!a) continue;
                const cur = await alertsCurrentPriceCents(a.appid, a.hash);
                if (!cur) continue;
                const res = smeAlertCheck({
                    currentCents: cur,
                    baseCents: a.baseCents,
                    dropPct: a.dropPct,
                    lastNotifiedCents: a.lastNotifiedCents,
                });
                if (!res.hit) continue;
                a.lastNotifiedCents = cur;
                changed = true;
                const dropText = (res.drop * 100).toFixed(1);
                const msg = a.name + ' 已跌 ' + dropText + '%（' + formatCents(a.baseCents) + ' → ' + formatCents(cur) + '）';
                toast('价格提醒：' + msg, 'warning');
                try {
                    if (settings.get('priceAlertNotify') && typeof Notification !== 'undefined' && Notification.permission === 'granted') {
                        new Notification('Steam 市场价格提醒', { body: msg, tag: 'sme-price-alert-' + key });
                    }
                } catch (e) { /* 浏览器通知不可用则只用站内提示 */ }
            }
            if (changed) await alertsSave();
        } catch (e) {
            W('价格提醒评估失败:', e && e.message);
        } finally {
            alertsState.evaluating = false;
        }
    }

    /** 提醒列表弹窗 */
    async function alertsOpenModal() {
        await alertsLoad();
        if (alertsState.modalEl) { alertsState.modalEl.remove(); alertsState.modalEl = null; }
        const overlay = h('div', { class: 'sme-dialog-overlay' });
        const box = h('div', { class: 'sme-dialog-box', style: { minWidth: '420px' } });
        overlay.appendChild(box);
        document.body.appendChild(overlay);

        const head = h('div', { class: 'sme-dialog-title', text: '价格提醒' });
        const body = h('div', { class: 'sme-dialog-body' });
        const foot = h('div', { style: { display: 'flex', gap: '8px', justifyContent: 'flex-end', marginTop: '12px' } });
        box.appendChild(head);
        box.appendChild(body);
        box.appendChild(foot);

        const dropInput = h('input', { class: 'sme-qs-input', type: 'number', min: '1', max: '90', step: '1', style: { width: '64px' } });
        dropInput.value = String(Math.round((parseFloat(settings.get('priceAlertDropPct')) || 0.1) * 100));
        body.appendChild(h('div', { style: { fontSize: '12px', color: 'var(--sme-text-dim)', marginBottom: '8px' } },
            [h('span', { text: '默认跌幅阈值(%)：' }), dropInput]));

        const list = h('div', { style: { maxHeight: '320px', overflowY: 'auto' } });
        body.appendChild(list);

        const keys = Object.keys(alertsState.map);
        if (!keys.length) {
            list.appendChild(h('div', { class: 'sme-ob-empty', text: '还没有提醒。在物品详情页点「价格提醒」即可添加。' }));
        } else {
            for (const key of keys) {
                const a = alertsState.map[key];
                const row = h('div', {
                    style: {
                        display: 'flex', justifyContent: 'space-between', alignItems: 'center',
                        gap: '10px', padding: '7px 0', borderBottom: '1px solid rgba(255,255,255,.06)',
                        fontSize: '12px',
                    },
                });
                const info = h('div', { style: { minWidth: 0, overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' } }, [
                    h('div', { text: a.name, title: a.name }),
                    h('div', {
                        style: { color: 'var(--sme-text-muted)', fontSize: '11px' },
                        text: '基准 ' + formatCents(a.baseCents) + ' · 阈值 ' + Math.round((a.dropPct || 0.1) * 100) + '%'
                            + (a.lastNotifiedCents ? ' · 已通知 ' + formatCents(a.lastNotifiedCents) : ''),
                    }),
                ]);
                const del = h('button', {
                    class: 'sme-danger-btn', text: '删除',
                    onClick: async () => {
                        delete alertsState.map[key];
                        await alertsSave();
                        row.remove();
                        alertsSyncButton();
                    },
                });
                row.appendChild(info);
                const volBadge = alertsVolBadgeEl(a.vol); // v2.1.0：有波动率数据才显示徽章
                if (volBadge) row.appendChild(volBadge);
                row.appendChild(del);
                list.appendChild(row);
            }
        }

        foot.appendChild(h('button', {
            class: 'sme-dialog-btn', text: '关闭',
            onClick: () => { overlay.remove(); alertsState.modalEl = null; },
        }));
        foot.appendChild(h('button', {
            class: 'sme-dialog-btn sme-dialog-blue', text: '立即检查',
            onClick: async () => {
                await alertsEvaluate();
                toast('已检查价格提醒', 'info');
                overlay.remove();
                alertsState.modalEl = null;
            },
        }));

        overlay.addEventListener('click', (e) => { if (e.target === overlay) { overlay.remove(); alertsState.modalEl = null; } });
        alertsState.modalEl = overlay;
    }

    /** 注入详情页「价格提醒」按钮 */
    function initAlertsButton() {
        let tries = 0;
        const tryInject = () => {
            const host = document.querySelector('.sme-panel .sme-header-title');
            if (host && !document.getElementById('sme-alert-btn')) {
                const btn = h('button', {
                    id: 'sme-alert-btn', class: 'sme-pool-watch', type: 'button',
                    html: ICONS.alert + '<span>价格提醒</span>',
                    title: '记录当前价格，价格跌破设定阈值时通知你（只读，不下单）',
                    onClick: () => alertsToggleCurrent(),
                });
                host.appendChild(btn);
                alertsSyncButton();
                return;
            }
            if (tries++ < 40) setTimeout(tryInject, 300);
        };
        setTimeout(tryInject, 300);
    }

    // ==================== 初始化 ====================
    let initialized = false;
    let lastURL = '';
    let urlCheckTimer = null;

    async function init() {
        if (initialized) return;
        initialized = true;
        L('Initializing on', location.href);
        // v2.0.0：统一存储层初始化（迁移旧存储 → IndexedDB + hydrate 内存镜像）
        try {
            await settings.init();
            await cache.init();
        } catch (e) {
            W('统一存储层初始化失败，继续使用旧存储:', e && e.message);
        }

        const sid = getSteamId();
        if (sid) loadCacheForSession(sid);
        else W('Steam ID not detected, some features may not work');

        // v2.1.0：载入「我的池子」条目与日快照（v2.0.0：改走 IndexedDB，故为异步）
        // v2.2.1：这三个加载互不依赖，改并行（原先串行 await 白白多等两轮）。
        // 注意 alertsEvaluate 仍放在三者全部完成之后 —— 它可能读池子数据。
        await Promise.allSettled([
            (async () => { try { await poolLoad(); } catch (e) { W('池子载入失败:', e && e.message); } })(),
            (async () => { try { await ratioLoadQuotes(); } catch (e) { W('比价缓存载入失败:', e && e.message); } })(),
            (async () => { try { await alertsLoad(); } catch (e) { W('价格提醒载入失败:', e && e.message); } })(),
        ]);
        alertsEvaluate().catch(() => {});
        poolState.window = POOL_WINDOWS.some((w) => w.id === settings.get('poolWindow'))
            ? settings.get('poolWindow') : '30d';

        const pageType = detectPageType();
        L('Page type:', pageType);

        if (pageType === 'listing') {
            initListingPage();
        } else if (pageType === 'browse') {
            initBrowsePage();
        } else if (pageType === 'inventory') {
            initInventoryPage();
        } else if (pageType === 'multisell') {
            initMultisellPage();
        } else if (pageType === 'tradeoffer') {
            initTradeOfferPage();
        } else if (pageType === 'booster') {
            initBoosterPage();
        }

        // URL 变化检测（Steam 市场使用 AJAX 导航）
        lastURL = location.href;
        urlCheckTimer = setInterval(() => {
            if (location.href !== lastURL) {
                lastURL = location.href;
                handleURLChange();
            }
        }, 800);
    }

    function initListingPage() {
        listingInfo = getListingInfo();
        L('Listing info:', listingInfo);

        // 详情页已拥有物品标识
        if (settings.get('ownedBadges')) {
            setTimeout(processDetailPageBadge, 600);
        }

        // 浮窗模式先放出按钮。经典商品页没有 SSR，原先要空等约 10 秒才会插入顶部面板。
        if (shouldUseFloatPanel()) ensureAnalysisFab();

        // 等待 SSR 数据可用
        const pageHref = location.href;
        const tryExtract = (attempt) => {
            if (location.href !== pageHref) return;
            const ssrData = extractSSRData();
            if (ssrData.sellOrders !== null) {
                const hadSummary = !!tabPanes.summary;
                allSellOrders = ssrData.sellOrders;
                // v1.9.2：SSR 就绪后重解析条目信息 —— 脚本启动时 SSR 可能尚未注入，
                // 那时拿到的只是 URL 里的哈希 slug（Steam 已 302 成 slug），名字一错全盘皆错。
                listingInfo = getListingInfo();
                // 设置全局 classid，并为缺少 classid 的订单补充
                if (ssrData.classid) _globalClassid = ssrData.classid;
                if (_globalClassid) {
                    for (const o of allSellOrders) {
                        if (!o.classid) o.classid = _globalClassid;
                    }
                }
                L(`Found ${allSellOrders.length} sell orders`);
                presentListingPanel();
                if (hadSummary) onListingOrdersReady();
                if (settings.get('autoLoadHistory')) {
                    // 预加载价格历史
                    if (listingInfo) {
                        fetchPriceHistory(listingInfo.appid, listingInfo.marketHashName)
                            .then(data => { priceHistoryData = data; })
                            .catch(() => {});
                    }
                }
            } else if (attempt < 20) {
                setTimeout(() => tryExtract(attempt + 1), 500);
            } else {
                L('No sell orders found after timeout, presenting panel anyway');
                presentListingPanel();
            }
        };
        tryExtract(0);

        // v1.4.6：我的挂单市场顺序跟踪（延迟等待 SSR renderContext 与 React 挂载）
        setTimeout(initMarketRankTracker, 800);

        // v1.4.9：参考货币换算价格注入 + 监听 DOM 变化自动补注
        startRefPriceInjection();

        // v1.7.0：详情页「关注」按钮（加入我的池子）
        initPoolWatchButton();

        // v2.0.0：详情页「价格提醒」按钮（只读提醒，不下单）
        if (settings.get('priceAlerts')) {
            initAlertsButton();
            requestAlertNotifyPermission();
        }

        // v2.0.1：后台预热库存限制数据（用于显示「该物品是否仍在交易冷却期」）
        ensureInvRestrictionsWarm();

        // v2.0.2：汇率报价（美金卡 + CS2 箱子）。点开才拉箱子，这里只放按钮。
        fxqEnsureLauncher();
        // v2.2.0：常驻汇率徽标 —— 进市场页就能看到当前汇率，不用点开面板。
        fxqEnsureBadgeLauncher();
    }

    function initBrowsePage() {
        if (settings.get('ownedBadges')) {
            setTimeout(processAllBrowseRows, 400);
            setupBrowseObserver();
        }
        createFab();
        initMyListingsEnhancement();
        // v1.6.0：市场页"我的市场历史记录"工具条（汇总 / 导出 / 格式下拉）
        initMarketHistoryPanel();
        // v1.7.0：池子行情工具条 + 浏览页自动收录
        initPoolPanel();
        poolInitBrowseTracker();
        // v1.6.4：隐藏 Steam 官方的市场 Beta 测试公告条
        applyMarketBetaNoteHidden();
        // v1.5.7：/market/search（pageType=browse）此前完全没有注入入口，
        // 「起价：₹xx」卡片换算一直不出现；这里与详情页共用同一入口。
        startRefPriceInjection();

        // v2.0.2：市场首页的汇率报价按钮跟在池子行情「行情分析」后面。
        fxqEnsureLauncher();
        // v2.2.0：常驻汇率徽标
        fxqEnsureBadgeLauncher();
    }

    function handleURLChange() {
        L('URL changed to', location.href);
        const pageType = detectPageType();
        fxqOnNavigate();

        // 清理旧面板（浮窗按钮挂在 body 上，要单独摘掉）
        removeAnalysisFloat();
        if (panelEl) { panelEl.remove(); panelEl = null; }
        if (fabEl) { fabEl.remove(); fabEl = null; }
        if (fabPopup) { fabPopup.remove(); fabPopup = null; }
        if (browseObserver) { browseObserver.disconnect(); browseObserver = null; }
        if (invObserver) { invObserver.disconnect(); invObserver = null; }
        if (invToolbarEl) { invToolbarEl.remove(); invToolbarEl = null; }
        if (invPriceLabels) { invPriceLabels.clear(); }
        if (invPriceIO) { invPriceIO.disconnect(); invPriceIO = null; }  // v1.5.1 P2-B：断开按需标注观察器
        if (tradeObserver) { tradeObserver.disconnect(); tradeObserver = null; }
        cleanupBoosterPage();
        cleanupMyListingsEnhancement();
        cleanupMarketRankTracker();
        cleanupMarketHistoryPanel();
        cleanupPoolPanel();
        // v1.4.9：清理参考货币价格标签和观察器
        cleanupRefPriceObserver();
        allSellOrders = [];
        priceHistoryData = null;
        orderBookData = null;
        currentTab = 'summary';
        priceCheckResults = null;
        priceCheckLoading = false;
        // v1.9.2：换物品后旧的规范 market_hash_name 必须作废，
        // 否则 SPA 跳到另一件物品时仍会用上一件的名字去查 SSR / 比价索引。
        _ssrHashName = undefined;
        _ssrHashNameTriedAt = 0;

        // v2.2.5：SPA 换页后先把常驻汇率徽标补回右下角（init* 内部也会调，这里兜底，
        // 避免某个初始化分支抛错时徽标整页都不再出现）
        fxqEnsureBadgeLauncher();

        if (pageType === 'listing') {
            // v1.5.0：SPA 导航到物品页时补注入假 hook（完整页面加载已在 document-start 注入过，此处幂等）
            if (settings.get('showMorePrices')) installShowMoreHook();
            initListingPage();
        } else if (pageType === 'browse') {
            initBrowsePage();
        } else if (pageType === 'inventory') {
            initInventoryPage();
        } else if (pageType === 'multisell') {
            initMultisellPage();
        } else if (pageType === 'tradeoffer') {
            initTradeOfferPage();
        } else if (pageType === 'booster') {
            initBoosterPage();
        }
    }

    // ==================== 补充包制作器页面 ====================

    // ---- 补充包页面状态 ----
    let boosterPanelEl = null;
    let boosterGameInfo = null;       // CBoosterCreatorPage.sm_rgBoosterData
    let boosterConfig = null;         // 用户配置 {queue:[], favorites:[], blacklist:[], pageSize, filter}
    let boosterPriceData = {};        // {appid: {cardPrice, boosterBuyOrder, hadCard, hadBooster, sold}}
    let boosterGemsSackPrice = 0;     // 市场一袋宝珠价格（分）
    let boosterCustomSackPrice = 0;   // 自定义一袋宝珠价格（分）
    let boosterPageNum = 1;
    let boosterPageSize = 15;
    let boosterSearchKeyword = '';
    let boosterFilterType = 'all';    // all|queue|favorites|blacklist|available
    let boosterSortKey = 'name';
    let boosterSortDir = 'asc';
    let boosterQueryRunning = false;
    let boosterCreateRunning = false;
    let boosterDoneList = [];
    let boosterGemsDisplay = 0;       // 当前用户宝石数量

    // 卡牌数量 → 宝石成本映射
    const CARD_COUNT_TO_GEMS = { 5:1200, 6:1000, 7:857, 8:750, 9:667, 10:600, 11:545, 12:500, 13:462, 14:429, 15:400 };

    /** 加载补充包配置 */
    function loadBoosterConfig() {
        try {
            const raw = smeKv.getSync('sme_booster_config', null);
            if (raw) {
                const cfg = JSON.parse(raw);
                boosterConfig = {
                    queue: cfg.queue || [],
                    favorites: cfg.favorites || [],
                    blacklist: cfg.blacklist || [],
                    pageSize: cfg.pageSize || 15,
                    filter: cfg.filter !== false,
                    customSackPrice: cfg.customSackPrice || 0,
                    autoQueryBooster: cfg.autoQueryBooster || false,
                };
            }
        } catch (e) {}
        if (!boosterConfig) {
            boosterConfig = { queue: [], favorites: [], blacklist: [], pageSize: 15, filter: true, customSackPrice: 0, autoQueryBooster: false };
        }
        boosterPageSize = boosterConfig.pageSize;
        boosterCustomSackPrice = boosterConfig.customSackPrice || 0;
    }

    /** 保存补充包配置 */
    function saveBoosterConfig() {
        smeKv.set('sme_booster_config', JSON.stringify(boosterConfig)).catch(() => {});
    }

    /** 加载补充包价格缓存 */
    function loadBoosterPriceCache() {
        try {
            const raw = smeKv.getSync('sme_booster_price_cache', null);
            if (raw) boosterPriceData = JSON.parse(raw) || {};
        } catch (e) {}
    }

    /** 保存补充包价格缓存 */
    function saveBoosterPriceCache() {
        smeKv.set('sme_booster_price_cache', JSON.stringify(boosterPriceData)).catch(() => {});
    }

    /** 补充包页面 toast */
    let _boosterToastEl = null;
    function boosterToast(msg, type = 'info') {
        if (!_boosterToastEl) {
            _boosterToastEl = h('div', { class: 'sme-booster-toast' });
            document.body.appendChild(_boosterToastEl);
        }
        _boosterToastEl.textContent = msg;
        _boosterToastEl.className = 'sme-booster-toast sme-show sme-' + type;
        clearTimeout(_boosterToastEl._timer);
        _boosterToastEl._timer = setTimeout(() => {
            _boosterToastEl.classList.remove('sme-show');
        }, 3000);
    }

    /** 获取一袋宝珠市场最低售价 */
    /**
     * v2.0.0：market/search/render 通用取价助手。
     * 实测该端点返回结构化 JSON：results[] 直接带
     *   {name, hash_name, sell_listings, sell_price(分), sell_price_text, app_icon, app_name, asset_description}
     * —— 不再需要 results_html，也**不再需要 item_nameid**。
     * @param {string} query 关键词（空字符串 = 全量浏览）
     * @param {object} extra 额外查询参数
     * @returns {Promise<{results:Array, total:number}>}
     */
    async function searchMarketItems(query, extra) {
        const params = new URLSearchParams();
        params.set('query', query || '');
        params.set('start', '0');
        params.set('count', '100');
        params.set('norender', '1');
        if (extra) {
            for (const k of Object.keys(extra)) params.append(k, extra[k]);
        }
        const url = 'https://steamcommunity.com/market/search/render/?' + params.toString();
        const data = await smeRequest(url, { expect: 'json' });
        if (!data || !Array.isArray(data.results)) return { results: [], total: 0 };
        return { results: data.results, total: parseInt(data.total_count, 10) || data.results.length };
    }

    /** 在 search 结果里按 hash_name 模糊匹配一个物品 */
    function pickMarketItem(results, keyword) {
        if (!Array.isArray(results)) return null;
        const kw = String(keyword || '').toLowerCase();
        if (!kw) return null;
        let best = null;
        for (const r of results) {
            const hn = String(r.hash_name || r.name || '');
            if (!hn) continue;
            const low = hn.toLowerCase();
            if (low === kw) return r;
            if (low.indexOf(kw) !== -1) { if (!best) best = r; }
        }
        return best;
    }

    async function fetchGemsSackPrice() {
        // ★ v2.0.0：原实现依赖「抓详情页 + 正则取 item_nameid + itemordershistogram」，
        //   而实测全站已无 item_nameid（Market_LoadOrderSpread 计数 = 0）→ 恒返回 0。
        //   改为走 market/search/render：results[] 直接带 sell_price（分），1 次请求搞定。
        try {
            const { results } = await searchMarketItems('753-Sack of Gems');
            const item = pickMarketItem(results, '753-sack of gems');
            if (item && item.sell_price) return parseInt(item.sell_price, 10) || 0;
        } catch (e) {
            W('Failed to fetch gems sack price:', e.message);
        }
        return 0;
    }

    /** 获取补充包市场最低售价和最高买单 */
    async function fetchBoosterMarketPrice(appid, name) {
        // ★ v2.0.0：同上，item_nameid 链路已死。改走 market/search/render。
        // 口径说明：原实现取的是**求购价**（买家出价）与**最低卖价**两个值。
        //   求购价需要 itemordershistogram（已不可达），此处退化为**最低卖价**，
        //   对「卖补充包能赚多少」是**保守估计**（实际若存在更高求购价会 instant 成交更高）。
        try {
            const englishName = await resolveBoosterEnglishName(appid, name);
            const marketHash = `${appid}-${englishName} Booster Pack`;
            const { results } = await searchMarketItems(marketHash);
            const item = pickMarketItem(results, marketHash.toLowerCase())
                || pickMarketItem(results, englishName.toLowerCase() + ' booster pack');
            if (!item || !item.sell_price) return null;
            const sell = parseInt(item.sell_price, 10) || 0;
            return { buyOrder: sell, sellOrder: sell, _proxy: true };
        } catch (e) {
            W(`Failed to fetch booster price for ${appid}:`, e.message);
            return null;
        }
    }

    /** 查询单个游戏的卡牌均价 */
    async function fetchCardPrice(appid) {
        // ★ v2.0.0 重写：原实现逐卡牌抓详情页 + 正则取 item_nameid + 调 itemordershistogram
        //   （每个游戏 20 次整页 HTML + 20 次 API，实测恒失败——全站已无 item_nameid）。
        //   现在改走 market/search/render：results[] 直接带 sell_price（分），
        //   **1~2 次请求**即可拿到全部普通卡的最低卖价，且完全不再依赖 item_nameid。
        try {
            const pageSize = 100;
            let totalPrice = 0;
            let successCount = 0;
            let cardCount = 0;
            let start = 0;

            for (let page = 0; page < 5; page++) {
                const params = new URLSearchParams();
                params.set('start', String(start));
                params.set('count', String(pageSize));
                params.set('norender', '1');
                params.set('appid', '753');
                params.append('category_753_cardborder[]', 'tag_cardborder_0');
                params.append('category_753_Game[]', 'tag_app_' + appid);
                const url = 'https://steamcommunity.com/market/search/render/?' + params.toString();
                const data = await smeRequest(url, { expect: 'json' });
                if (!data || !Array.isArray(data.results) || !data.results.length) break;

                cardCount = parseInt(data.total_count, 10) || cardCount || data.results.length;
                for (const r of data.results) {
                    const p = parseInt(r.sell_price, 10) || 0;
                    if (p > 0) { totalPrice += p; successCount++; }
                }
                start += data.results.length;
                if (start >= cardCount || data.results.length < pageSize) break;
                await sleep(600);   // 翻页间隔，避免限流
            }

            if (successCount > 0) {
                // 三张卡牌均价 × 税后（× 0.87）
                const avgCardPrice = totalPrice / successCount;
                const totalCardValue = avgCardPrice * 3; // 补充包含3张卡牌
                return { cardPrice: totalCardValue, cardCount, successCount };
            }
            return null;
        } catch (e) {
            W(`Failed to fetch card prices for ${appid}:`, e.message);
            return null;
        }
    }

    /** 制作补充包 */
    async function createBoosterPack(appid, series) {
        try {
            const sessionid = await resolveSessionId();
            if (!sessionid) throw new Error('无法获取 sessionid');
            const body = new URLSearchParams({
                sessionid,
                appid: String(appid),
                series: String(series),
                tradability_preference: '1',
            });
            const json = await smeRequest('https://steamcommunity.com/tradingcards/ajaxcreatebooster/', {
                method: 'POST',
                headers: { 'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8' },
                body: body.toString(),
            });
            if (!json || !json.success) throw new Error((json && json.message) || '制作失败');
            return json;
        } catch (e) {
            W(`Failed to create booster for ${appid}:`, e.message);
            throw e;
        }
    }

    /** 获取用户当前宝石数量 */
    function getBoosterGems() {
        const el = document.querySelector('.goovalue');
        if (el) {
            const text = el.textContent.replace(/[,，\s]/g, '');
            const num = parseInt(text, 10);
            if (!isNaN(num)) return num;
        }
        return 0;
    }

    // ---- 英文名称缓存（用于补充包链接生成） ----
    let boosterEnglishNameCache = {};   // { appid: 'English Name' }
    let _boosterEnNameFetching = new Set(); // 正在获取中的 appid，避免重复请求

    /** 加载英文名称缓存 */
    function loadBoosterEnglishNameCache() {
        try {
            const raw = smeKv.getSync('sme_booster_en_name_cache', null);
            if (raw) boosterEnglishNameCache = JSON.parse(raw) || {};
        } catch (e) {}
    }

    /** 保存英文名称缓存 */
    function saveBoosterEnglishNameCache() {
        smeKv.set('sme_booster_en_name_cache', JSON.stringify(boosterEnglishNameCache)).catch(() => {});
    }

    /** 去除书名号及特殊符号 */
    function pureName(str) {
        return (str || '').replace(/[《》〈〉「」『』™©®]/g, '');
    }

    /** 异步获取游戏英文名称（带缓存），参考 Steam_Show_English_Name.js 逻辑 */
    async function fetchEnglishName(appid) {
        const id = String(appid);
        if (!id || id === '0') return null;
        // 内存缓存
        if (boosterEnglishNameCache[id]) return boosterEnglishNameCache[id];
        // 防止并发重复请求
        if (_boosterEnNameFetching.has(id)) return null;
        _boosterEnNameFetching.add(id);
        try {
            const url = `https://store.steampowered.com/api/appdetails?appids=${id}&l=english`;
            const data = await gmFetchJson(url, 12000);
            if (data && data[id] && data[id].success === true && data[id].data && data[id].data.name) {
                const enName = pureName(data[id].data.name);
                boosterEnglishNameCache[id] = enName;
                saveBoosterEnglishNameCache();
                return enName;
            }
        } catch (e) {
            W(`Failed to fetch English name for appid ${id}:`, e.message);
        } finally {
            _boosterEnNameFetching.delete(id);
        }
        return null;
    }

    /** 同步获取链接用名称：优先英文缓存，否则回退到去符号的原始名 */
    function getBoosterLinkName(appid, fallbackName) {
        const id = String(appid);
        if (boosterEnglishNameCache[id]) return boosterEnglishNameCache[id];
        return pureName(fallbackName || '');
    }

    /** 异步解析英文名称：缓存命中直接返回，否则请求 API 后返回 */
    async function resolveBoosterEnglishName(appid, fallbackName) {
        const id = String(appid);
        if (boosterEnglishNameCache[id]) return boosterEnglishNameCache[id];
        const en = await fetchEnglishName(id);
        return en || pureName(fallbackName || '');
    }

    /** 构建补充包市场链接 */
    function buildBoosterMarketUrl(appid, name) {
        const linkName = getBoosterLinkName(appid, name);
        const safeName = linkName.replace(/\//g, '-');
        return `https://steamcommunity.com/market/listings/753/${appid}-${encodeURIComponent(safeName)}%20Booster%20Pack`;
    }

    /** 构建卡牌市场搜索链接 */
    function buildCardMarketUrl(appid) {
        return `https://steamcommunity.com/market/search?category_Game=app_${appid}&appid=753`;
    }

    /** 获取游戏可用状态 */
    function getGameStatus(appid) {
        const selector = document.getElementById('booster_game_selector');
        if (!selector) return 'unknown';
        const option = selector.querySelector(`option[value="${appid}"]`);
        if (!option) return 'unknown';
        if (option.classList.contains('available')) return 'available';
        if (boosterDoneList.includes(String(appid))) return 'done';
        return 'cooldown';
    }

    /** 获取游戏宝石成本 */
    function getGameGemsCost(appid) {
        if (!boosterGameInfo) return 0;
        const info = boosterGameInfo[appid];
        if (!info) return 0;
        return parseInt(info.price, 10) || 0;
    }

    /** 计算利润 */
    function calcBoosterProfit(appid) {
        const gemsCost = getGameGemsCost(appid);
        if (gemsCost === 0) return null;
        // 一袋宝珠1000 gems的市场价 → 每gem价值
        const sackPrice = boosterCustomSackPrice > 0 ? boosterCustomSackPrice : boosterGemsSackPrice;
        if (sackPrice === 0) return null;
        const gemCostCents = Math.round(sackPrice * gemsCost / 1000);
        // 卡牌收益（税后）
        const pd = boosterPriceData[appid];
        const cardRevenue = pd && pd.cardPrice ? Math.round(pd.cardPrice * 0.87) : 0;
        // 补充包买单收益
        const boosterBuyRevenue = pd && pd.boosterBuyOrder ? pd.boosterBuyOrder : 0;
        // 取较高者作为预期收益
        const expectedRevenue = Math.max(cardRevenue, boosterBuyRevenue);
        return { cost: gemCostCents, revenue: expectedRevenue, profit: expectedRevenue - gemCostCents };
    }

    /** 格式化价格（分→元） */
    function formatBoosterPrice(cents) {
        if (cents == null || isNaN(cents)) return '--';
        const wi = getWalletInfo();
        return (cents / 100).toFixed(2);
    }

    /** 封面图降级链（参考 sglv-cover-fallback.lib.js） */
    const COVER_CDN_AKAMAI = 'https://shared.akamai.steamstatic.com/store_item_assets/steam/apps/';
    const COVER_CDN_CF = 'https://cdn.cloudflare.steamstatic.com/steam/apps/';
    const COVER_CHAIN = ['capsule_231x87.jpg', 'capsule_184x69.jpg', 'capsule_467x181.jpg', 'header.jpg'];
    const COVER_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";
    const _coverCache = new Map();

    function getBoosterCoverUrl(appId) {
        const id = String(appId);
        if (_coverCache.has(id)) return _coverCache.get(id);
        try {
            const cached = smeKv.getSync('sme_cover_' + id, null);
            if (cached) { _coverCache.set(id, cached); return cached; }
        } catch(e) {}
        return COVER_CDN_AKAMAI + id + '/' + COVER_CHAIN[0];
    }

    function buildCoverFallbackChain(appId) {
        const id = String(appId);
        const chain = [];
        COVER_CHAIN.forEach(p => chain.push(COVER_CDN_AKAMAI + id + '/' + p));
        chain.push(COVER_CDN_CF + id + '/capsule_231x87.jpg');
        chain.push(COVER_CDN_CF + id + '/header.jpg');
        return chain;
    }

    function handleCoverError(img) {
        const appId = img.dataset.appid;
        if (!appId) return;
        const chain = buildCoverFallbackChain(appId);
        let idx = parseInt(img.dataset.fbIdx || '0', 10);
        while (idx < chain.length && (img.src === chain[idx] || img.src === decodeURIComponent(chain[idx]))) idx++;
        if (idx < chain.length) {
            img.dataset.fbIdx = String(idx + 1);
            img.src = chain[idx];
        } else {
            img.src = COVER_PLACEHOLDER;
            img.classList.add('sme-booster-cover-failed');
        }
    }

    function handleCoverLoad(img) {
        const appId = img.dataset.appid;
        if (!appId || !img.src || img.src.indexOf('data:image') === 0) return;
        const id = String(appId);
        _coverCache.set(id, img.src);
        smeKv.set('sme_cover_' + id, img.src).catch(() => {});
    }

    /** 渲染补充包面板 */
    function renderBoosterPanel() {
        if (!boosterPanelEl) return;
        const container = boosterPanelEl.querySelector('.sme-booster-content');
        if (!container) return;

        // 获取过滤后的游戏列表
        let games = [];
        for (const key in boosterGameInfo) {
            const info = boosterGameInfo[key];
            if (!info || !info.appid) continue;
            const appid = String(info.appid);

            // 搜索过滤
            if (boosterSearchKeyword && !(info.name || '').toLowerCase().includes(boosterSearchKeyword.toLowerCase())) continue;

            // 分类过滤
            if (boosterFilterType === 'queue' && !boosterConfig.queue.includes(appid)) continue;
            if (boosterFilterType === 'favorites' && !boosterConfig.favorites.includes(appid)) continue;
            if (boosterFilterType === 'blacklist' && !boosterConfig.blacklist.includes(appid)) continue;
            if (boosterFilterType === 'available' && getGameStatus(appid) !== 'available') continue;
            if (boosterFilterType === 'all' && boosterConfig.blacklist.includes(appid)) continue;

            games.push({ appid, name: info.name, series: info.series, price: info.price, status: getGameStatus(appid) });
        }

        // 排序
        games.sort((a, b) => {
            let va, vb;
            switch (boosterSortKey) {
                case 'name': va = (a.name || '').toLowerCase(); vb = (b.name || '').toLowerCase(); break;
                case 'gems': va = parseInt(a.price, 10) || 0; vb = parseInt(b.price, 10) || 0; break;
                case 'profit': {
                    const pa = calcBoosterProfit(a.appid);
                    const pb = calcBoosterProfit(b.appid);
                    va = pa ? pa.profit : -Infinity;
                    vb = pb ? pb.profit : -Infinity;
                    break;
                }
                case 'cardPrice': {
                    va = (boosterPriceData[a.appid] && boosterPriceData[a.appid].cardPrice) || 0;
                    vb = (boosterPriceData[b.appid] && boosterPriceData[b.appid].cardPrice) || 0;
                    break;
                }
                case 'status': va = a.status; vb = b.status; break;
                default: va = a.name; vb = b.name;
            }
            if (typeof va === 'string') {
                return boosterSortDir === 'asc' ? va.localeCompare(vb) : vb.localeCompare(va);
            }
            return boosterSortDir === 'asc' ? va - vb : vb - va;
        });

        // 分页
        const totalPages = Math.max(1, Math.ceil(games.length / boosterPageSize));
        if (boosterPageNum > totalPages) boosterPageNum = totalPages;
        if (boosterPageNum < 1) boosterPageNum = 1;
        const startIdx = (boosterPageNum - 1) * boosterPageSize;
        const pageGames = games.slice(startIdx, startIdx + boosterPageSize);

        // 构建表格
        let tableHtml = '';
        if (games.length === 0) {
            tableHtml = '<div class="sme-booster-empty">没有匹配的游戏</div>';
        } else {
            const sortArrow = (key) => boosterSortKey === key ? (boosterSortDir === 'asc' ? ' ▲' : ' ▼') : '';
            tableHtml = `<table class="sme-booster-table"><thead><tr>`;
            tableHtml += `<th class="sme-no-sort">封面</th>`;
            tableHtml += `<th data-sort="name">游戏名称${sortArrow('name')}</th>`;
            tableHtml += `<th data-sort="status">状态${sortArrow('status')}</th>`;
            tableHtml += `<th data-sort="gems">宝石成本${sortArrow('gems')}</th>`;
            tableHtml += `<th data-sort="cardPrice">卡牌均价${sortArrow('cardPrice')}</th>`;
            tableHtml += `<th data-sort="profit">利润${sortArrow('profit')}</th>`;
            tableHtml += `<th class="sme-no-sort">操作</th>`;
            tableHtml += `<th class="sme-no-sort">链接</th>`;
            tableHtml += `</tr></thead><tbody>`;

            for (const g of pageGames) {
                const isDone = g.status === 'done';
                const isAvailable = g.status === 'available';
                const inQueue = boosterConfig.queue.includes(g.appid);
                const inFav = boosterConfig.favorites.includes(g.appid);
                const inBlack = boosterConfig.blacklist.includes(g.appid);
                const profit = calcBoosterProfit(g.appid);
                const pd = boosterPriceData[g.appid] || {};
                const gemsCost = parseInt(g.price, 10) || 0;

                let statusHtml = '';
                if (isDone) statusHtml = '<span class="sme-booster-badge sme-booster-badge-done">已完成</span>';
                else if (isAvailable) statusHtml = '<span class="sme-booster-badge sme-booster-badge-available">可制作</span>';
                else statusHtml = '<span class="sme-booster-badge sme-booster-badge-cooldown">冷却中</span>';

                let profitHtml = '<span class="sme-booster-cell-empty">--</span>';
                if (profit) {
                    const cls = profit.profit > 0 ? 'sme-booster-profit-positive' : (profit.profit < 0 ? 'sme-booster-profit-negative' : 'sme-booster-profit-neutral');
                    const sign = profit.profit > 0 ? '+' : '';
                    profitHtml = `<span class="${cls}">${sign}${formatBoosterPrice(profit.profit)}</span>`;
                }

                let cardPriceHtml = '<span class="sme-booster-cell-prompt">点击查询</span>';
                if (pd.cardPrice) {
                    cardPriceHtml = formatBoosterPrice(pd.cardPrice);
                    if (pd.boosterBuyOrder) {
                        cardPriceHtml += `<br><span style="font-size:11px;color:var(--sme-text-dim)">买:${formatBoosterPrice(pd.boosterBuyOrder)}</span>`;
                    }
                } else if (pd.hadCard === false) {
                    cardPriceHtml = '<span class="sme-booster-cell-empty">不可交易</span>';
                }

                // SVG 图标（使用 ICONS 对象）
                const _qIcon = inQueue ? ICONS.queueActive : ICONS.queue;
                const _favIcon = inFav ? ICONS.starFilled : ICONS.starOutline;
                const _banIcon = inBlack ? ICONS.banActive : ICONS.ban;
                const _pkgIcon = ICONS.package;
                const _cardIcon = ICONS.card;

                tableHtml += `<tr class="${isDone ? 'sme-done' : ''}" data-appid="${g.appid}">`;
                // 封面
                tableHtml += `<td class="sme-booster-cover-cell"><div class="sme-booster-cover-wrapper"><img class="sme-booster-cover" src="${getBoosterCoverUrl(g.appid)}" data-appid="${g.appid}" alt="${escapeHtml(g.name)}" loading="lazy"></div></td>`;
                // 游戏名称
                tableHtml += `<td class="sme-booster-name">${escapeHtml(g.name)}</td>`;
                tableHtml += `<td>${statusHtml}</td>`;
                tableHtml += `<td style="font-variant-numeric:tabular-nums">${gemsCost.toLocaleString()}</td>`;
                tableHtml += `<td>${cardPriceHtml}</td>`;
                tableHtml += `<td>${profitHtml}</td>`;
                // 操作（纯图标按钮，固定尺寸）
                tableHtml += `<td><div class="sme-booster-actions">`;
                tableHtml += `<button class="sme-booster-action-btn sme-booster-action-queue ${inQueue ? 'active' : ''}" data-action="queue" aria-label="${inQueue ? '移出队列' : '加入制作队列'}" title="${inQueue ? '移出队列' : '加入制作队列'}">${_qIcon}</button>`;
                tableHtml += `<button class="sme-booster-action-btn sme-booster-action-fav ${inFav ? 'active' : ''}" data-action="fav" aria-label="${inFav ? '取消收藏' : '收藏游戏'}" title="${inFav ? '取消收藏' : '收藏游戏'}">${_favIcon}</button>`;
                tableHtml += `<button class="sme-booster-action-btn sme-booster-action-black ${inBlack ? 'active' : ''}" data-action="black" aria-label="${inBlack ? '取消拉黑' : '加入黑名单（隐藏）'}" title="${inBlack ? '取消拉黑' : '加入黑名单（隐藏）'}">${_banIcon}</button>`;
                tableHtml += `</div></td>`;
                // 链接
                tableHtml += `<td><div class="sme-booster-link-group"><a class="sme-booster-link sme-booster-link-item" href="${buildBoosterMarketUrl(g.appid, g.name)}" target="_blank" aria-label="补充包市场链接" title="查看补充包市场价格">${_pkgIcon}补充包</a><a class="sme-booster-link-item" href="${buildCardMarketUrl(g.appid)}" target="_blank" aria-label="卡牌市场链接" title="查看卡牌市场价格">${_cardIcon}卡牌</a></div></td>`;
                tableHtml += `</tr>`;
            }
            tableHtml += `</tbody></table>`;
        }

        // 分页控件
        let paginationHtml = '';
        if (games.length > boosterPageSize) {
            paginationHtml = `<div class="sme-booster-pagination">`;
            paginationHtml += `<button onclick="void(0)" data-page="prev" ${boosterPageNum <= 1 ? 'disabled' : ''}>上一页</button>`;
            paginationHtml += `<span class="sme-page-info">${boosterPageNum} / ${totalPages}</span>`;
            paginationHtml += `<button onclick="void(0)" data-page="next" ${boosterPageNum >= totalPages ? 'disabled' : ''}>下一页</button>`;
            paginationHtml += `</div>`;
        }

        // 统计信息
        let availableCount = 0;
        let queueAvailableCount = 0;
        let totalGemsCost = 0;
        let totalProfit = 0;
        let profitCount = 0;
        for (const key in boosterGameInfo) {
            const appid = String(boosterGameInfo[key].appid);
            if (getGameStatus(appid) === 'available') {
                availableCount++;
                if (boosterConfig.queue.includes(appid)) {
                    queueAvailableCount++;
                    totalGemsCost += parseInt(boosterGameInfo[key].price, 10) || 0;
                    const p = calcBoosterProfit(appid);
                    if (p) { totalProfit += p.profit; profitCount++; }
                }
            }
        }

        const sackPriceDisplay = boosterCustomSackPrice > 0 ? boosterCustomSackPrice : boosterGemsSackPrice;
        let infoBarHtml = `<div class="sme-booster-info-bar">`;
        infoBarHtml += `<span>宝石余额: <strong>${boosterGemsDisplay.toLocaleString()}</strong></span>`;
        infoBarHtml += `<span>一袋宝珠: <strong>${formatBoosterPrice(sackPriceDisplay)}</strong></span>`;
        infoBarHtml += `<span>可制作: <strong>${availableCount}</strong></span>`;
        infoBarHtml += `<span>队列可做: <strong style="color:var(--sme-green)">${queueAvailableCount}</strong></span>`;
        if (queueAvailableCount > 0) {
            infoBarHtml += `<span>队列宝石消耗: <strong>${totalGemsCost.toLocaleString()}</strong></span>`;
        }
        if (profitCount > 0) {
            const cls = totalProfit > 0 ? 'sme-booster-profit-positive' : 'sme-booster-profit-negative';
            infoBarHtml += `<span>队列预期利润: <strong class="${cls}">${totalProfit > 0 ? '+' : ''}${formatBoosterPrice(totalProfit)}</strong></span>`;
        }
        infoBarHtml += `</div>`;

        container.innerHTML = tableHtml + paginationHtml + infoBarHtml;

        // 封面图降级链：error→尝试下一个CDN，load→缓存成功URL
        container.querySelectorAll('img.sme-booster-cover').forEach(img => {
            img.addEventListener('error', () => handleCoverError(img));
            img.addEventListener('load', () => handleCoverLoad(img));
        });

        // 绑定表头排序事件
        container.querySelectorAll('th[data-sort]').forEach(th => {
            th.addEventListener('click', () => {
                const key = th.dataset.sort;
                if (boosterSortKey === key) {
                    boosterSortDir = boosterSortDir === 'asc' ? 'desc' : 'asc';
                } else {
                    boosterSortKey = key;
                    boosterSortDir = 'asc';
                }
                renderBoosterPanel();
            });
        });

        // 绑定分页事件
        container.querySelectorAll('.sme-booster-pagination button[data-page]').forEach(btn => {
            btn.addEventListener('click', () => {
                if (btn.dataset.page === 'prev') boosterPageNum--;
                else boosterPageNum++;
                renderBoosterPanel();
            });
        });

        // 绑定操作按钮事件
        container.querySelectorAll('.sme-booster-action-btn').forEach(btn => {
            btn.addEventListener('click', (e) => {
                e.stopPropagation();
                const row = btn.closest('tr');
                if (!row) return;
                const appid = row.dataset.appid;
                const action = btn.dataset.action;
                handleBoosterAction(appid, action);
            });
        });

        // 异步获取英文名称并更新补充包链接（避免中文名导致链接失效）
        updateBoosterLinksAsync(pageGames);
    }

    /** 异步获取当前页游戏的英文名称，更新补充包链接 href */
    async function updateBoosterLinksAsync(pageGames) {
        if (!pageGames || pageGames.length === 0) return;
        // 筛选需要获取英文名称的游戏
        const needFetch = pageGames.filter(g => !boosterEnglishNameCache[String(g.appid)]);
        if (needFetch.length > 0) {
            // 并发获取（限制并发数 3），避免触发 Steam API 速率限制
            const CONCURRENCY = 3;
            for (let i = 0; i < needFetch.length; i += CONCURRENCY) {
                const batch = needFetch.slice(i, i + CONCURRENCY);
                await Promise.all(batch.map(g => fetchEnglishName(g.appid)));
                if (i + CONCURRENCY < needFetch.length) await sleep(300);
            }
            // 获取完成后更新当前页面中所有补充包链接的 href
            if (boosterPanelEl) {
                for (const g of pageGames) {
                    const row = boosterPanelEl.querySelector(`tr[data-appid="${g.appid}"]`);
                    if (row) {
                        const link = row.querySelector('.sme-booster-link');
                        if (link) link.href = buildBoosterMarketUrl(g.appid, g.name);
                    }
                }
            }
        }
    }

    /** 处理游戏操作 */
    function handleBoosterAction(appid, action) {
        appid = String(appid);
        const idxQueue = boosterConfig.queue.indexOf(appid);
        const idxFav = boosterConfig.favorites.indexOf(appid);
        const idxBlack = boosterConfig.blacklist.indexOf(appid);

        if (action === 'queue') {
            if (idxQueue > -1) boosterConfig.queue.splice(idxQueue, 1);
            else {
                boosterConfig.queue.push(appid);
                if (idxBlack > -1) boosterConfig.blacklist.splice(idxBlack, 1);
            }
        } else if (action === 'fav') {
            if (idxFav > -1) boosterConfig.favorites.splice(idxFav, 1);
            else {
                boosterConfig.favorites.push(appid);
                if (idxBlack > -1) boosterConfig.blacklist.splice(idxBlack, 1);
            }
        } else if (action === 'black') {
            if (idxBlack > -1) boosterConfig.blacklist.splice(idxBlack, 1);
            else {
                boosterConfig.blacklist.push(appid);
                if (idxQueue > -1) boosterConfig.queue.splice(idxQueue, 1);
                if (idxFav > -1) boosterConfig.favorites.splice(idxFav, 1);
            }
        }
        saveBoosterConfig();
        renderBoosterPanel();
    }

    /** 自动查询卡牌价格 */
    async function autoQueryCardPrices() {
        if (boosterQueryRunning) { boosterToast('查询正在进行中', 'warning'); return; }
        boosterQueryRunning = true;

        // 获取当前过滤后的游戏列表
        const games = [];
        for (const key in boosterGameInfo) {
            const info = boosterGameInfo[key];
            if (!info || !info.appid) continue;
            const appid = String(info.appid);
            if (boosterSearchKeyword && !(info.name || '').toLowerCase().includes(boosterSearchKeyword.toLowerCase())) continue;
            if (boosterFilterType === 'queue' && !boosterConfig.queue.includes(appid)) continue;
            if (boosterFilterType === 'favorites' && !boosterConfig.favorites.includes(appid)) continue;
            if (boosterFilterType === 'blacklist' && !boosterConfig.blacklist.includes(appid)) continue;
            if (boosterFilterType === 'available' && getGameStatus(appid) !== 'available') continue;
            if (boosterFilterType === 'all' && boosterConfig.blacklist.includes(appid)) continue;
            // 跳过已查询的
            if (boosterPriceData[appid] && boosterPriceData[appid].hadCard) continue;
            games.push({ appid, name: info.name });
        }

        if (games.length === 0) {
            boosterToast('没有需要查询的游戏', 'info');
            boosterQueryRunning = false;
            return;
        }

        boosterToast(`开始查询 ${games.length} 个游戏的卡牌价格...`, 'info');

        for (let i = 0; i < games.length; i++) {
            if (!boosterQueryRunning) { boosterToast('查询已停止', 'warning'); break; }
            const g = games[i];
            try {
                const result = await fetchCardPrice(g.appid);
                if (!boosterPriceData[g.appid]) boosterPriceData[g.appid] = {};
                if (result) {
                    boosterPriceData[g.appid].cardPrice = result.cardPrice;
                    boosterPriceData[g.appid].cardCount = result.cardCount;
                    boosterPriceData[g.appid].hadCard = true;
                } else {
                    boosterPriceData[g.appid].hadCard = false;
                }

                // 同时查询补充包价格
                if (boosterConfig.autoQueryBooster) {
                    const boosterResult = await fetchBoosterMarketPrice(g.appid, g.name);
                    if (boosterResult) {
                        boosterPriceData[g.appid].boosterBuyOrder = boosterResult.buyOrder;
                        boosterPriceData[g.appid].boosterSellOrder = boosterResult.sellOrder;
                        boosterPriceData[g.appid].hadBooster = true;
                    }
                }

                saveBoosterPriceCache();
                renderBoosterPanel();
                boosterToast(`[${i + 1}/${games.length}] ${g.name}`, 'info');
            } catch (e) {
                W(`Query failed for ${g.appid}:`, e.message);
            }
        }

        boosterQueryRunning = false;
        boosterToast('卡牌价格查询完成', 'success');
        renderBoosterPanel();
    }

    /** 一键制作队列中的补充包 */
    async function batchCreateBoosters() {
        if (boosterCreateRunning) { boosterToast('制作正在进行中', 'warning'); return; }

        // 获取队列中可制作的游戏
        const available = [];
        for (const appid of boosterConfig.queue) {
            if (getGameStatus(appid) === 'available') {
                const info = boosterGameInfo[appid];
                if (info) available.push({ appid: String(appid), name: info.name, series: info.series, price: info.price });
            }
        }

        if (available.length === 0) {
            boosterToast('队列中没有可制作的补充包', 'warning');
            return;
        }

        // 确认对话框
        const totalGems = available.reduce((s, g) => s + (parseInt(g.price, 10) || 0), 0);
        const confirmed = await showConfirmDialog(
            `确定要制作 <strong style="color:var(--sme-blue)">${available.length}</strong> 个补充包吗？<br>消耗 <strong>${totalGems.toLocaleString()}</strong> 颗宝石`,
            { title: '一键制作补充包', okText: '确认制作', okClass: 'sme-confirm-blue' }
        );
        if (!confirmed) return;

        boosterCreateRunning = true;
        const btn = boosterPanelEl.querySelector('#sme-booster-batch-btn');
        if (btn) { btn.disabled = true; btn.textContent = '制作中...'; }

        const progressBar = boosterPanelEl.querySelector('.sme-booster-progress');
        const progressBarBar = boosterPanelEl.querySelector('.sme-booster-progress-bar');
        if (progressBar) progressBar.classList.add('sme-visible');

        let success = 0;
        let failed = 0;

        for (let i = 0; i < available.length; i++) {
            const g = available[i];
            if (progressBarBar) progressBarBar.style.width = `${((i) / available.length) * 100}%`;
            try {
                await createBoosterPack(g.appid, g.series);
                success++;
                boosterDoneList.push(g.appid);
                boosterToast(`[${i + 1}/${available.length}] ${g.name} 制作成功`, 'success');
                L(`Booster created: ${g.appid} (${g.name})`);
            } catch (e) {
                failed++;
                boosterToast(`[${i + 1}/${available.length}] ${g.name} 失败: ${e.message}`, 'error');
                W(`Booster create failed: ${g.appid}`, e.message);
                if (e.message.includes('宝石') || e.message.includes('gem')) break;
            }
            // 间隔1.5秒避免限流
            if (i < available.length - 1) await new Promise(r => setTimeout(r, 1500));
        }

        if (progressBarBar) progressBarBar.style.width = '100%';
        setTimeout(() => { if (progressBar) progressBar.classList.remove('sme-visible'); }, 2000);

        boosterCreateRunning = false;
        if (btn) { btn.disabled = false; btn.textContent = '一键制作'; }

        // 更新宝石显示
        const newGems = getBoosterGems();
        if (newGems > 0) boosterGemsDisplay = newGems;

        boosterToast(`制作完成: 成功 ${success}, 失败 ${failed}`, success > 0 ? 'success' : 'error');
        renderBoosterPanel();
    }

    /** 初始化补充包制作器页面 */
    function initBoosterPage() {
        L('Initializing booster creator page');
        loadBoosterConfig();
        loadBoosterPriceCache();
        loadBoosterEnglishNameCache();

        // 等待页面加载
        const tryInit = (attempt) => {
            const boosterArea = document.querySelector('.booster_creator_area');
            if (!boosterArea) {
                if (attempt < 30) setTimeout(() => tryInit(attempt + 1), 500);
                return;
            }

            // 获取游戏数据
            try {
                boosterGameInfo = unsafeWindow.CBoosterCreatorPage?.sm_rgBoosterData;
            } catch (e) {}

            if (!boosterGameInfo) {
                if (attempt < 30) {
                    W('Booster data not ready, retrying...', attempt);
                    setTimeout(() => tryInit(attempt + 1), 500);
                    return;
                }
                L('Booster data not found after timeout');
            }

            // 获取当前宝石数量
            boosterGemsDisplay = getBoosterGems();

            // 创建面板
            boosterPanelEl = h('div', { class: 'sme-booster-panel' });

            // 头部
            const header = h('div', { class: 'sme-booster-header' });
            header.appendChild(h('div', { class: 'sme-booster-title' }, [
                h('span', { html: ICONS.package, style: { display: 'inline-flex', alignItems: 'center' } }),
                '补充包制作器增强',
            ]));
            header.appendChild(h('div', { class: 'sme-booster-gems', html: `${ICONS.gem} ${boosterGemsDisplay.toLocaleString()} 宝石` }));

            // 操作说明提示条
            const hints = h('div', { class: 'sme-booster-hints' });
            const _hintSvg = (svg) => svg.replace('class="sme-svg"', '');
            const hintItems = [
                { icon: _hintSvg(ICONS.queue), bg: 'var(--sme-green-a20)', color: 'var(--sme-green)', text: '<b>队列</b>：加入制作队列，一键制作时批量执行' },
                { icon: _hintSvg(ICONS.starFilled), bg: 'var(--sme-amber-a20)', color: 'var(--sme-amber)', text: '<b>收藏</b>：标记常玩游戏，方便快速筛选' },
                { icon: _hintSvg(ICONS.ban), bg: 'var(--sme-red-a20)', color: 'var(--sme-red)', text: '<b>拉黑</b>：隐藏不感兴趣的游戏' },
            ];
            hints.innerHTML = hintItems.map(hint =>
                `<span class="sme-booster-hint-item"><span class="sme-booster-hint-icon" style="background:${hint.bg};color:${hint.color}">${hint.icon}</span>${hint.text}</span>`
            ).join('');
            const _infoIcon = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" style="width:12px;height:12px;flex-shrink:0;vertical-align:middle"><circle cx="12" cy="12" r="10"/><line x1="12" y1="16" x2="12" y2="12"/><line x1="12" y1="8" x2="12.01" y2="8"/></svg>';
            hints.innerHTML += `<span class="sme-booster-hint-item" style="margin-left:auto;color:var(--sme-text-dim)">${_infoIcon} 先<b>查询卡牌均价</b>查看利润，再<b>一键制作</b>队列中的游戏</span>`;

            // 工具栏
            const toolbar = h('div', { class: 'sme-booster-toolbar' });

            // --- 组1: 搜索 + 过滤 ---
            const grp1 = h('div', { class: 'sme-booster-tb-group' });

            // 搜索框
            const searchInput = h('input', {
                type: 'text',
                class: 'sme-booster-search',
                placeholder: '搜索游戏名称…',
                value: boosterSearchKeyword,
                'aria-label': '搜索游戏名称',
            });
            searchInput.addEventListener('input', () => {
                boosterSearchKeyword = searchInput.value;
                boosterPageNum = 1;
                renderBoosterPanel();
            });
            grp1.appendChild(searchInput);

            // 过滤下拉
            const filterSelect = h('select', { class: 'sme-booster-select', 'aria-label': '过滤游戏' });
            const filterOptions = [
                { value: 'all', label: '全部' },
                { value: 'queue', label: '队列' },
                { value: 'favorites', label: '收藏' },
                { value: 'available', label: '可制作' },
                { value: 'blacklist', label: '黑名单' },
            ];
            for (const opt of filterOptions) {
                const o = h('option', { value: opt.value }, opt.label);
                if (boosterFilterType === opt.value) o.setAttribute('selected', '');
                filterSelect.appendChild(o);
            }
            filterSelect.addEventListener('change', () => {
                boosterFilterType = filterSelect.value;
                boosterPageNum = 1;
                renderBoosterPanel();
            });
            grp1.appendChild(filterSelect);
            toolbar.appendChild(grp1);

            // 分隔线
            toolbar.appendChild(h('div', { class: 'sme-booster-tb-sep' }));

            // --- 组2: 每页 + 宝珠价 ---
            const grp2 = h('div', { class: 'sme-booster-tb-group' });

            // 每页数量
            grp2.appendChild(h('span', { style: { fontSize: '12px', color: 'var(--sme-text-dim)' } }, '每页:'));
            const pageSizeInput = h('input', {
                type: 'number',
                class: 'sme-booster-search',
                style: { width: '55px', textAlign: 'center', paddingLeft: '5px', backgroundImage: 'none' },
                value: String(boosterPageSize),
                min: '5',
                max: '100',
                title: '每页显示数量',
                'aria-label': '每页显示数量',
            });
            pageSizeInput.addEventListener('change', () => {
                const n = parseInt(pageSizeInput.value, 10);
                if (n >= 5 && n <= 100) {
                    boosterPageSize = n;
                    boosterConfig.pageSize = n;
                    saveBoosterConfig();
                    boosterPageNum = 1;
                    renderBoosterPanel();
                }
            });
            grp2.appendChild(pageSizeInput);

            // 自定义宝珠价格
            grp2.appendChild(h('span', { style: { fontSize: '12px', color: 'var(--sme-text-dim)' } }, '宝珠价:'));
            const customPriceInput = h('input', {
                type: 'number',
                class: 'sme-booster-search',
                style: { width: '65px', textAlign: 'center', paddingLeft: '5px', backgroundImage: 'none' },
                value: boosterCustomSackPrice > 0 ? String((boosterCustomSackPrice / 100).toFixed(2)) : '',
                placeholder: '自动',
                step: '0.01',
                title: '自定义一袋宝珠成本价（留空使用市场价）',
                'aria-label': '自定义一袋宝珠价格',
            });
            customPriceInput.addEventListener('change', () => {
                const v = parseFloat(customPriceInput.value);
                if (!isNaN(v) && v > 0) {
                    boosterCustomSackPrice = Math.round(v * 100);
                    boosterConfig.customSackPrice = boosterCustomSackPrice;
                } else {
                    boosterCustomSackPrice = 0;
                    boosterConfig.customSackPrice = 0;
                }
                saveBoosterConfig();
                renderBoosterPanel();
            });
            grp2.appendChild(customPriceInput);
            toolbar.appendChild(grp2);

            // 分隔线
            toolbar.appendChild(h('div', { class: 'sme-booster-tb-sep' }));

            // --- 组3: 查询 ---
            const grp3 = h('div', { class: 'sme-booster-tb-group' });

            // 查询按钮
            const queryBtn = h('button', { class: 'sme-booster-btn sme-booster-btn-amber', 'aria-label': '查询卡牌均价' });
            queryBtn.innerHTML = ICONS.search + '<span>查询卡牌均价</span>';
            queryBtn.addEventListener('click', () => {
                if (boosterQueryRunning) {
                    boosterQueryRunning = false;
                    queryBtn.innerHTML = ICONS.search + '<span>查询卡牌均价</span>';
                } else {
                    queryBtn.innerHTML = '<span class="sme-booster-spinner" style="width:14px;height:14px;border-width:2px;flex-shrink:0"></span><span>停止查询</span>';
                    autoQueryCardPrices().then(() => {
                        queryBtn.innerHTML = ICONS.search + '<span>查询卡牌均价</span>';
                    });
                }
            });
            grp3.appendChild(queryBtn);

            // 查询补充包复选框
            const autoBoosterLabel = h('label', { style: { display: 'flex', alignItems: 'center', gap: '4px', fontSize: '12px', color: 'var(--sme-text-dim)', cursor: 'pointer' } });
            const autoBoosterCheckbox = h('input', { type: 'checkbox', 'aria-label': '同时查询补充包价格' });
            if (boosterConfig.autoQueryBooster) autoBoosterCheckbox.setAttribute('checked', '');
            autoBoosterCheckbox.addEventListener('change', () => {
                boosterConfig.autoQueryBooster = autoBoosterCheckbox.checked;
                saveBoosterConfig();
            });
            autoBoosterLabel.appendChild(autoBoosterCheckbox);
            autoBoosterLabel.appendChild(document.createTextNode('同时查补充包'));
            grp3.appendChild(autoBoosterLabel);
            toolbar.appendChild(grp3);

            // 分隔线
            toolbar.appendChild(h('div', { class: 'sme-booster-tb-sep' }));

            // --- 组4: 制作 + 清缓存 ---
            const grp4 = h('div', { class: 'sme-booster-tb-group' });

            // 一键制作按钮（主要操作）
            const batchBtn = h('button', { class: 'sme-booster-btn sme-booster-btn-green', id: 'sme-booster-batch-btn', 'aria-label': '一键制作队列中的补充包' });
            batchBtn.innerHTML = ICONS.zap + '<span>一键制作</span>';
            batchBtn.addEventListener('click', batchCreateBoosters);
            grp4.appendChild(batchBtn);

            // 清空缓存按钮（危险操作，小号字体）
            const clearCacheBtn = h('button', { class: 'sme-booster-btn sme-booster-btn-red', 'aria-label': '清空所有价格缓存' }, '清空缓存');
            clearCacheBtn.addEventListener('click', async () => {
                if (await showConfirmDialog('确定清空所有卡牌价格缓存？', { title: '清空缓存', okText: '清空', okClass: 'sme-dialog-btn sme-dialog-ok' })) {
                    boosterPriceData = {};
                    saveBoosterPriceCache();
                    renderBoosterPanel();
                    boosterToast('价格缓存已清空', 'success');
                }
            });
            grp4.appendChild(clearCacheBtn);
            toolbar.appendChild(grp4);

            // 内容区域
            const content = h('div', { class: 'sme-booster-content' });

            // 进度条
            const progress = h('div', { class: 'sme-booster-progress' }, [
                h('div', { class: 'sme-booster-progress-bar' }),
            ]);

            boosterPanelEl.appendChild(header);
            boosterPanelEl.appendChild(hints);
            boosterPanelEl.appendChild(toolbar);
            boosterPanelEl.appendChild(content);
            boosterPanelEl.appendChild(progress);

            // 插入到页面
            if (boosterArea && boosterArea.parentNode) {
                boosterArea.parentNode.insertBefore(boosterPanelEl, boosterArea.nextSibling);
            } else {
                const mainContent = document.querySelector('.maincontent');
                if (mainContent) mainContent.appendChild(boosterPanelEl);
            }

            // 渲染初始表格
            renderBoosterPanel();

            // 异步获取宝石市场价格
            fetchGemsSackPrice().then(price => {
                boosterGemsSackPrice = price;
                L('Gems sack price:', price);
                renderBoosterPanel();
            }).catch(e => W('Failed to get gems sack price:', e.message));
        };

        tryInit(0);
    }

    /** 清理补充包页面 */
    function cleanupBoosterPage() {
        if (boosterPanelEl) { boosterPanelEl.remove(); boosterPanelEl = null; }
        boosterQueryRunning = false;
        boosterCreateRunning = false;
        boosterDoneList = [];
        boosterGameInfo = null;
        boosterPriceData = {};
        boosterEnglishNameCache = {};
        _boosterEnNameFetching.clear();
    }

    // ==================== v2.2.0 汇率报价参考（美金卡 + CS2 箱子） ====================
    // 口径（2026-11-06 一线实测校准，详见 docs/fx-quote-design.md）：
    //   · 箱子净汇率 = BUFF 前三档均价(CNY) ÷ Steam 24h 中位价(USD) × (1 − BUFF手续费)
    //     两侧都用稳健统计量：Steam 的 lowest_price 可能是错价挂单
    //     （实测 Kilowatt lowest 隐含 6.3333 vs median 隐含 6.6667，差 5%），
    //     BUFF 的 lowCny 是单笔最低价，前三档均价更抗异常。
    //   · 「Steam 参考价」= **实测反推**：同一物品拉 priceoverview?currency=1 与
    //     ?currency=23，比值即 Steam 实际应用的人民币定价汇率。
    //     实测 Operation Bravo Case：$76.01 / ¥510.83 → 6.72056（median 口径 6.71990，自洽到 1e-4）。
    //     ★ AS 的 rates/v1?to=CNY 给的 6.67098 是错的（≈即期，缺了人民币钱包的 0.78% 加成）
    //       → AS 表降级为交叉校验用，不再当基准。
    //   · 即期牌价 = FxCore 的 spot 锚（frankfurter.dev/ECB → currency-api → er-api）。
    //   · 购汇成本 = 用户手填，**独立锚**，不写回自动锚缓存。
    //   · 每个数字带不确定度：价格量化误差 ±0.005/price，$0.12 的箱子就是 ±4.2%。
    // 英文 name 是 Steam market_hash_name：拉价和 BUFF 索引都用它，不能换成中文。
    // zh 是 Steam 简体中文名。icon 是 economy/image 哈希，行首直接画，不为图标再打请求。
    const FXQ_CASES = [
        { name: 'Kilowatt Case', zh: '千瓦武器箱', icon: 'i0CoZ81Ui0m-9KwlBY1L_18myuGuq1wfhWSaZgMttyVfPaERSR0Wqmu7LAocGJKz2lu_XsnXwtmkJjSU91dh8bj35VTqVBP4io_frnEVvqf_a6VoIfGSXz7Hlbwg57QwSS_mxhl15jiGyN37c3_GZw91W8BwRflK7EfKsa2sfw' },
        { name: 'Revolution Case', zh: '变革武器箱', icon: 'i0CoZ81Ui0m-9KwlBY1L_18myuGuq1wfhWSaZgMttyVfPaERSR0Wqmu7LAocGJKz2lu_XsnXwtmkJjSU91dh8bj35VTqVBP4io_frnAVvfb6aqduc_TFVjTCxbx05OU4S3jilE9w4DzRnImtIy2Sa1JzDJEhRPlK7EcO4U8gfA' },
        { name: 'Recoil Case', zh: '反冲武器箱', icon: 'i0CoZ81Ui0m-9KwlBY1L_18myuGuq1wfhWSaZgMttyVfPaERSR0Wqmu7LAocGJKz2lu_XsnXwtmkJjSU91dh8bj35VTqVBP4io_frnMVu6b-avA-JqSSCjSWwuhz47U9TCzlxh9yt2WGnNqgIi-fbgUkWMNxFPlK7EdIJF6a2Q' },
        { name: 'Dreams & Nightmares Case', zh: '梦魇武器箱', icon: 'i0CoZ81Ui0m-9KwlBY1L_18myuGuq1wfhWSaZgMttyVfPaERSR0Wqmu7LAocGJKz2lu_XsnXwtmkJjSU91dh8bj35VTqVBP4io_frnIV7Kb5OaU-JqfHDzXFle0u4LY8Gy_kkRgisGzcm4v4J3vDOAQmDMdyRvlK7EcmeCU3yw' },
        { name: 'Gallery Case', zh: '画廊武器箱', icon: 'i0CoZ81Ui0m-9KwlBY1L_18myuGuq1wfhWSaZgMttyVfPaERSR0Wqmu7LAocGJKz2lu_XsnXwtmkJjSU91dh8bj35VTqVBP4io_frnYVuPD5baE6IfTFCmSRme0j5eU5SXrjkRwmt2rWnoqhdnjEPQQiDpRxTflK7EePRV2-Kg' },
        { name: 'Fever Case', zh: '热潮武器箱', icon: 'i0CoZ81Ui0m-9KwlBY1L_18myuGuq1wfhWSaZgMttyVfPaERSR0Wqmu7LAocGJKz2lu_XsnXwtmkJjSU91dh8bj35VTqVBP4io_frncVtqv7MPE8JaHHCj_Dl-wk4-NtFirikURy4jiGwo2udHqVaAEjDZp3EflK7EeSMnMs4w' },
        { name: 'Fracture Case', zh: '裂空武器箱', icon: 'i0CoZ81Ui0m-9KwlBY1L_18myuGuq1wfhWSaZgMttyVfPaERSR0Wqmu7LAocGJKz2lu_XsnXwtmkJjSU91dh8bj35VTqVBP4io_fr3QV7aD7OP01IfbGDzPCmbsm4LU5GnvkzUsi4WvUmIqtci_CPQNyApsjE_lK7EfrhW545A' },
        { name: 'Snakebite Case', zh: '蛇噬武器箱', icon: 'i0CoZ81Ui0m-9KwlBY1L_18myuGuq1wfhWSaZgMttyVfPaERSR0Wqmu7LAocGJKz2lu_XsnXwtmkJjSU91dh8bj35VTqVBP4io_fr3oVvvT4bfI4dvTLCGTCmLl16ec7TX_mk08k42iHwtqscy-WPVUmCZJ4R_lK7Ed8Q6OYtw' },
    ];
    // 实测汇率探针用的高价箱不在篮子里，页脚锚点名同样走中文。
    const FXQ_EXTRA_ZH = {
        'Operation Bravo Case': '“英勇大行动”武器箱',
        'Operation Hydra Case': '“九头蛇大行动”武器箱',
        'Chroma 2 Case': '幻彩 2 号武器箱',
    };

    function fxqCaseLang() {
        return settings.get('fxqCaseLang') === 'en' ? 'en' : 'zh';
    }

    function fxqCaseSpec(name) {
        for (let i = 0; i < FXQ_CASES.length; i++) {
            if (FXQ_CASES[i].name === name) return FXQ_CASES[i];
        }
        return null;
    }

    /** 列表、拉取进度、页脚锚点用的展示名。请求价仍用英文 market_hash_name。默认中文。 */
    function fxqCaseLabel(name) {
        const en = name ? String(name) : '';
        if (!en || fxqCaseLang() === 'en') return en;
        const spec = fxqCaseSpec(en);
        if (spec && spec.zh) return spec.zh;
        return FXQ_EXTRA_ZH[en] || en;
    }

    function fxqCaseTitle(name) {
        const en = name ? String(name) : '';
        const spec = fxqCaseSpec(en);
        const zh = (spec && spec.zh) || FXQ_EXTRA_ZH[en] || '';
        if (zh && en && zh !== en) return zh + ' · ' + en;
        return en || zh;
    }

    function fxqCaseIconUrl(name) {
        const spec = fxqCaseSpec(name);
        if (!spec || !spec.icon) return '';
        return 'https://community.akamai.steamstatic.com/economy/image/' + spec.icon + '/64fx64f';
    }

    function fxqCaseNameCell(name) {
        const en = name ? String(name) : '';
        const bits = [];
        const icon = fxqCaseIconUrl(en);
        if (icon) {
            bits.push(h('img', {
                class: 'sme-fxq-icon',
                src: icon,
                alt: '',
                width: '32',
                height: '32',
                loading: 'lazy',
                decoding: 'async',
                referrerpolicy: 'no-referrer',
                onError: (e) => { if (e.currentTarget) e.currentTarget.remove(); },
            }));
        }
        bits.push(h('span', { class: 'sme-fxq-caselabel', text: fxqCaseLabel(en) || '—' }));
        const inner = en
            ? h('a', {
                class: 'sme-fxq-caselink',
                href: 'https://steamcommunity.com/market/listings/730/' + encodeURIComponent(en),
                target: '_blank',
                rel: 'noopener noreferrer',
                title: fxqCaseTitle(en),
            }, bits)
            : h('span', { class: 'sme-fxq-caselink', text: '—' });
        return h('td', { class: 'sme-fxq-name' }, [inner]);
    }

    // 实测反推 Steam 汇率用的「高价锚」：价格越高，两位小数量化误差越小。
    // $76 档 ±0.01%，$35 档 ±0.01%，$4.7 档 ±0.11%。
    const FXQ_RATE_ANCHORS = [
        { appid: 730, name: 'Operation Bravo Case', minUsd: 10 },
        { appid: 730, name: 'Operation Hydra Case', minUsd: 10 },
        { appid: 730, name: 'Chroma 2 Case', minUsd: 3 },
    ];

    const FXQ_BASKET_KEY = 'sme_fxq_basket_v1';
    const FXQ_LIVE_KEY = 'sme_fxq_steamlive_v1';
    const FXQ_MANUAL_KEY = 'sme_fxq_manual_v1';
    const FXQ_BADGE_POS_KEY = 'sme_fxq_badge_pos';
    const FXQ_CARD_MAX = 12;
    const FXQ_BASKET_TTL = 30 * 60 * 1000;     // 篮子 30 分钟过期
    const FXQ_LIVE_TTL = 6 * 60 * 60 * 1000;   // 实测汇率 6 小时
    const FXQ_STATUS = { used: '计入', outlier: '偏离', thin: '量不足', missing: '未计入' };

    const fxqState = {
        basket: null,
        rows: null,        // 送进 evaluateBasket 的行（与 result.rows 同序）
        mem: null,         // FxCore 的 spot/steam
        live: null,        // Steam 实测汇率 {rate, errPct, anchorName, ts, ...}
        manual: null,      // 手动购汇成本 {currency, per, value}
        result: null,
        pasted: [],
        loading: false,
        abort: false,
        gen: 0,
        anchorGen: 0,
        liveGen: 0,
        progress: '',
        steamCh: null,
        style: false,
        ui: null,
        badge: null,
        badgeLoading: false,
    };

    function fxqLib() {
        return (window.Fxq && typeof window.Fxq.parseMoney === 'function') ? window.Fxq : null;
    }

    function fxqFee() {
        const v = Number(settings.get('fxqBuffFee'));
        if (Number.isFinite(v) && v >= 0 && v < 1) return v;
        return 0.025;
    }

    function fxqFeePercentText() {
        return String(Math.round(fxqFee() * 1000) / 10);
    }

    /** 输入 2.5 或 0.025 都按 2.5% 存。超出 0~20% 返回 null，调用方保留原值。 */
    function fxqParseFeeInput(raw) {
        const n = parseFloat(raw);
        if (!Number.isFinite(n) || n < 0) return null;
        const frac = n > 1 ? n / 100 : n;
        if (!(frac >= 0) || frac > 0.2) return null;
        return frac;
    }

    function fxqCards() {
        let v = settings.get('fxqCards');
        if (typeof v === 'string') {
            try { v = JSON.parse(v); } catch (e) { v = []; }
        }
        return Array.isArray(v) ? v.slice() : [];
    }

    function fxqSaveCards(list) {
        settings.set('fxqCards', list.slice(0, FXQ_CARD_MAX));
    }

    /**
     * 解析本地化价格串（千分位 / 欧式逗号小数 / 整数币种）。
     * 委托 shared/fxq.lib.js —— **不要**用 /[\d.,]+/ 一把梭（那会把 "1,234.56" 读成 1.234）。
     */
    function fxqParseMoney(s, code) {
        const lib = fxqLib();
        if (!lib) return 0;
        const v = lib.parseMoney(s, code || 'USD');
        return v && v > 0 ? v : 0;
    }

    function fxqUsd(n) {
        if (!(n > 0)) return '—';
        return '$' + n.toFixed(n >= 1 ? 2 : 3);
    }
    function fxqCny(n) {
        return n > 0 ? '¥' + n.toFixed(2) : '—';
    }
    function fxqRate(n) {
        return Number.isFinite(n) && n > 0 ? n.toFixed(2) : '—';
    }
    /** 带不确定度的数字（精度不够时必须显示出来，不能显示得像精确值） */
    function fxqRateErr(n, errPct) {
        if (!Number.isFinite(n) || !(n > 0)) return '—';
        const s = n.toFixed(2);
        if (!Number.isFinite(errPct) || !(errPct > 0)) return s;
        return s + ' ±' + (errPct >= 1 ? errPct.toFixed(1) : errPct.toFixed(2)) + '%';
    }
    function fxqSpreadText(sp) {
        if (!sp || !Number.isFinite(sp.per100)) return '—';
        const sign = sp.per100 > 0 ? '+' : '';
        return sign + '¥' + sp.per100.toFixed(2);
    }
    function fxqBandColor(id) {
        return { gray: '#8b96a3', green: '#a4d007', yellow: '#e6a817', red: '#d9534f', unknown: '#66c0f4' }[id] || '#66c0f4';
    }

    function fxqAgeText(basket) {
        if (!basket || !basket.at) return '';
        const min = Math.max(0, Math.round((Date.now() - basket.at) / 60000));
        let t = min < 1 ? '刚刚' : (min < 60 ? min + ' 分钟前' : Math.round(min / 60) + ' 小时前');
        if (!basket.complete) t += ' · 未拉完';
        else if (min >= 10) t += ' · 已超过 10 分钟';
        return t;
    }

    /** 篮子是否已过期（30 分钟） */
    function fxqBasketStale(basket) {
        if (!basket || !basket.at) return true;
        return (Date.now() - basket.at) > FXQ_BASKET_TTL;
    }

    function fxqEnsureStyle() {
        if (fxqState.style) return;
        fxqState.style = true;
        GM_addStyle(`
.sme-fxq-float{position:fixed;left:16px;bottom:64px;z-index:9500}
.sme-fxq-bar{display:flex;align-items:center;gap:8px;margin:8px 0;padding:6px 10px;background:var(--sme-bg-card);border:1px solid rgba(255,255,255,.06);border-radius:6px;color:var(--sme-text)}
#sme-fxq-panel{position:fixed;inset:0;z-index:10050;display:flex;align-items:center;justify-content:center;
  background:rgba(0,0,0,.62);backdrop-filter:blur(3px);color:var(--sme-text);
  font:13px/1.5 "Motiva Sans",system-ui,sans-serif;
  --fxq-line:rgba(255,255,255,.07);--fxq-t1:#e9eff5;--fxq-t2:#9aa9b8;--fxq-t3:#6b7a89;--fxq-ease:cubic-bezier(.4,0,.2,1)}
.sme-fxq-win{width:min(980px,94vw);max-height:88vh;display:flex;flex-direction:column;overflow:hidden;
  background:var(--sme-bg);border:1px solid rgba(255,255,255,.1);border-radius:8px;box-shadow:0 12px 48px rgba(0,0,0,.55)}
.sme-fxq-head{display:flex;align-items:center;justify-content:space-between;gap:12px;padding:10px 14px;border-bottom:1px solid rgba(255,255,255,.08);flex:none}
.sme-fxq-title{display:flex;align-items:center;gap:8px;font-size:14px;font-weight:600;color:var(--sme-text-bright)}
.sme-fxq-title .sme-svg{width:18px;height:18px;color:#66c0f4}
.sme-fxq-sub{font-size:11px;color:var(--sme-text-muted);font-weight:400}
.sme-fxq-x{background:none;border:none;cursor:pointer;color:var(--sme-text-dim);padding:4px;line-height:0}
.sme-fxq-x:hover{color:var(--sme-text-bright)}
.sme-fxq-x .sme-svg{width:16px;height:16px}
.sme-fxq-toolbar{display:flex;align-items:center;gap:8px;padding:8px 14px;border-bottom:1px solid rgba(255,255,255,.05);flex-wrap:wrap;flex:none}
.sme-fxq-status{margin-left:auto;color:var(--fxq-t3);font-size:12px;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
.sme-fxq-btn{display:inline-flex;align-items:center;gap:5px;padding:4px 10px;font-size:12px;color:var(--sme-text);
  background:rgba(255,255,255,.05);border:1px solid rgba(255,255,255,.09);border-radius:4px;cursor:pointer;line-height:1.4}
.sme-fxq-btn:hover{background:rgba(255,255,255,.1);color:var(--sme-text-bright)}
.sme-fxq-btn.on{background:rgba(102,192,244,.16);border-color:rgba(102,192,244,.5);color:#a8d8ff}
.sme-fxq-scroll{flex:1;min-height:0;overflow-y:auto;padding:12px 14px 16px}
.sme-fxq-note{color:var(--fxq-t3);font-size:12px;line-height:1.6;margin:0 0 12px}
.sme-fxq-stats{display:grid;grid-template-columns:repeat(auto-fit,minmax(168px,1fr));gap:10px;margin-bottom:8px}
.sme-fxq-stat{--accent:#66c0f4;position:relative;overflow:hidden;min-width:0;padding:11px 13px 10px;border-radius:10px;
  background:linear-gradient(180deg,rgba(35,45,57,.72) 0%,rgba(27,34,43,.72) 100%);
  border:1px solid var(--fxq-line);box-shadow:0 1px 2px rgba(0,0,0,.30);
  transition:transform .16s var(--fxq-ease),border-color .16s var(--fxq-ease),box-shadow .16s var(--fxq-ease)}
.sme-fxq-stat::before{content:"";position:absolute;left:16px;right:16px;top:0;height:2px;
  background:linear-gradient(90deg,transparent,var(--accent) 16%,var(--accent) 84%,transparent);box-shadow:0 0 8px var(--accent)}
.sme-fxq-stat:hover{transform:translateY(-2px);border-color:color-mix(in srgb,var(--accent) 62%,transparent);
  box-shadow:0 8px 20px rgba(0,0,0,.28),0 0 16px color-mix(in srgb,var(--accent) 22%,transparent)}
.sme-fxq-stat span{display:block;font-size:11px;font-weight:500;color:var(--fxq-t3);letter-spacing:.3px}
.sme-fxq-stat b{display:block;margin-top:6px;font-size:19px;font-weight:700;line-height:1.2;color:var(--fxq-t1);font-variant-numeric:tabular-nums}
.sme-fxq-stat b small{font-size:11px;font-weight:500;color:var(--fxq-t3);margin-left:4px}
.sme-fxq-meta{color:var(--fxq-t3);font-size:11px;margin:0 0 14px}
.sme-fxq-div{display:flex;flex-direction:column;gap:4px;margin:0 0 14px;padding:8px 11px;border-radius:7px;
  border:1px solid var(--fxq-line);background:rgba(255,255,255,.025);font-size:12px}
.sme-fxq-div .sme-fxq-divrow{display:flex;align-items:baseline;gap:8px;flex-wrap:wrap}
.sme-fxq-div .sme-fxq-divtxt{color:var(--fxq-t1)}
.sme-fxq-div .sme-fxq-divhint{color:var(--fxq-t3);font-size:11px}
.sme-fxq-div.ok{border-color:rgba(74,222,128,.28)}
.sme-fxq-div.warn{border-color:rgba(245,158,11,.35);background:rgba(245,158,11,.06)}
.sme-fxq-div.alert{border-color:rgba(248,113,113,.4);background:rgba(248,113,113,.07)}
.sme-fxq-div.unknown{opacity:.75}
.sme-fxq-tag{display:inline-block;padding:0 6px;border-radius:8px;font-size:10px;font-weight:700;vertical-align:middle}
.sme-fxq-tag-ok{background:rgba(74,222,128,.16);color:#4ade80}
.sme-fxq-tag-warn{background:rgba(245,158,11,.16);color:#fbbf24}
.sme-fxq-tag-alert{background:rgba(248,113,113,.18);color:#f87171}
.sme-fxq-tag-noise{background:rgba(255,255,255,.07);color:var(--fxq-t3)}
.sme-fxq-h{font-size:13px;font-weight:600;color:var(--sme-text-bright);margin:16px 0 8px;display:flex;align-items:center;gap:8px}
.sme-fxq-h span{font-size:11px;font-weight:400;color:var(--fxq-t3)}
.sme-fxq-wrap{overflow-x:auto;border:1px solid rgba(255,255,255,.06);border-radius:5px;margin-bottom:8px}
.sme-fxq-table{width:100%;border-collapse:collapse;font-size:12px;margin:0}
.sme-fxq-table th{position:sticky;top:0;background:rgba(23,26,33,.98);text-align:right;color:var(--sme-text-dim);font-weight:600;padding:7px 9px;border-bottom:1px solid rgba(255,255,255,.08);white-space:nowrap}
.sme-fxq-table th:first-child,.sme-fxq-table td:first-child{text-align:left}
.sme-fxq-table td{padding:6px 9px;border-bottom:1px solid rgba(255,255,255,.04);text-align:right;color:var(--sme-text);font-variant-numeric:tabular-nums;white-space:nowrap;vertical-align:middle}
.sme-fxq-table tr:last-child td{border-bottom:none}
.sme-fxq-table tbody tr:hover td{background:rgba(255,255,255,.03)}
.sme-fxq-table td.sme-fxq-name{color:var(--sme-text-bright);max-width:280px}
.sme-fxq-caselink{display:flex;align-items:center;gap:8px;min-width:0;max-width:268px;color:inherit;text-decoration:none}
.sme-fxq-caselink:hover .sme-fxq-caselabel{color:#a8d8ff}
.sme-fxq-icon{width:32px;height:32px;object-fit:contain;flex:none;border-radius:4px;background:rgba(0,0,0,.28)}
.sme-fxq-caselabel{overflow:hidden;text-overflow:ellipsis;min-width:0}
.sme-fxq-table tr.sme-fxq-off .sme-fxq-icon{opacity:.4}
.sme-fxq-h b{font-size:13px;font-weight:600;color:var(--sme-text-bright)}
.sme-fxq-lang{margin-left:auto;display:inline-flex;border:1px solid rgba(255,255,255,.12);border-radius:4px;overflow:hidden;flex:none}
.sme-fxq-lang button{appearance:none;background:transparent;border:0;color:var(--fxq-t3);font:600 11px/1.7 "Motiva Sans",system-ui,sans-serif;padding:0 8px;cursor:pointer}
.sme-fxq-lang button+button{border-left:1px solid rgba(255,255,255,.12)}
.sme-fxq-lang button.on{background:rgba(102,192,244,.2);color:#d6eeff}
.sme-fxq-table tr.sme-fxq-off td{color:var(--fxq-t3)}
.sme-fxq-table tr.sme-fxq-off td.sme-fxq-name{color:var(--sme-text-dim)}
.sme-fxq-pill{display:inline-block;padding:1px 7px;border-radius:9px;font-size:11px;font-weight:600}
.sme-fxq-pill-used{background:rgba(74,222,128,.14);color:#4ade80}
.sme-fxq-pill-outlier{background:rgba(245,158,11,.14);color:#fbbf24}
.sme-fxq-pill-thin,.sme-fxq-pill-missing{background:rgba(255,255,255,.06);color:var(--fxq-t3)}
.sme-fxq-row{display:flex;gap:8px;align-items:center;flex-wrap:wrap;margin:0 0 8px}
.sme-fxq-row label{color:var(--fxq-t3);font-size:12px}
.sme-fxq-row input,.sme-fxq-row textarea{background:rgba(14,18,26,.9);border:1px solid rgba(255,255,255,.09);color:var(--fxq-t1);border-radius:4px;padding:5px 8px}
.sme-fxq-row input{width:88px}
.sme-fxq-row input:focus,.sme-fxq-row textarea:focus{outline:none;border-color:rgba(102,192,244,.55)}
.sme-fxq-row textarea{width:100%;height:88px;resize:vertical;font-family:ui-monospace,monospace;font-size:12px}
.sme-fxq-cards{border:1px solid rgba(255,255,255,.06);border-radius:5px;overflow:hidden}
.sme-fxq-cards:empty{display:none}
.sme-fxq-card{display:grid;grid-template-columns:1.5fr .7fr .9fr .8fr .7fr .8fr auto;gap:8px;align-items:center;padding:7px 10px;border-bottom:1px solid rgba(255,255,255,.04);font-size:12px}
.sme-fxq-card:last-child{border-bottom:none}
.sme-fxq-card.sme-fxq-best{background:rgba(74,222,128,.08)}
.sme-fxq-band{display:inline-block;padding:1px 8px;border-radius:9px;color:#101822;font-weight:700;font-size:11px}
.sme-fxq-pos{color:#4ade80;font-variant-numeric:tabular-nums}
.sme-fxq-neg{color:#f87171;font-variant-numeric:tabular-nums}
.sme-fxq-foot{display:flex;flex-direction:column;gap:2px;padding:8px 14px;font-size:11px;color:var(--fxq-t3);line-height:1.55;border-top:1px solid rgba(255,255,255,.05);flex:none}
.sme-fxq-lo{color:#fbbf24;font-size:11px}
/* v2.2.5：常驻徽标压在其余右下角浮层之上（市场顺序浮窗 9000 / 汇率按钮 9500） */
.sme-fxq-badge{position:fixed;right:16px;bottom:16px;z-index:9600;display:flex;align-items:center;gap:6px;
  padding:5px 10px;border-radius:16px;font:12px/1.4 "Motiva Sans",system-ui,sans-serif;
  color:var(--sme-text);background:rgba(20,26,34,.92);border:1px solid rgba(255,255,255,.12);
  box-shadow:0 4px 16px rgba(0,0,0,.35);cursor:pointer;user-select:none;backdrop-filter:blur(4px)}
.sme-fxq-badge:hover{border-color:rgba(102,192,244,.55)}
.sme-fxq-badge .sme-fxq-badgeval{font-variant-numeric:tabular-nums;font-weight:700;color:#a8d8ff}
.sme-fxq-badge .sme-fxq-badgeflag{color:#fbbf24;font-size:11px}
.sme-fxq-badge .sme-fxq-badgesrc{color:var(--fxq-t3,#6b7a89);font-size:10px}
@media (max-width:720px){
  .sme-fxq-stats{grid-template-columns:1fr 1fr}
  .sme-fxq-card{grid-template-columns:1fr 1fr}
  .sme-fxq-status{margin-left:0;width:100%}
}
`);
    }

    /** 锚点信息（rate + 来源说明） */
    function fxqAnchorBits(entry) {
        if (!entry || !entry.rates || !window.FxCore) return { rate: null, meta: '不可用' };
        const rate = window.FxCore.cnyPerUnit('USD', entry.rates);
        const date = entry.rateDate ? new Date(entry.rateDate).toISOString().slice(0, 10) : '接口未提供日期';
        const flags = [];
        if (entry.live) flags.push('实测');
        if (entry.cached) flags.push('缓存');
        if (entry.rescued) flags.push('旧快照');
        if (entry.merged) flags.push('宽表');
        const meta = (entry.label || entry.source || '') + ' · ' + date + (flags.length ? ' · ' + flags.join(' / ') : '');
        return { rate: rate, meta: meta };
    }

    /**
     * Steam 参考锚：优先「实测反推」，其次 AS 表（第三方声称，未实测）。
     * 实测口径固定 USD→CNY（面板整段是人民币口径，可比）。
     */
    function fxqSteamAnchor() {
        const live = fxqState.live;
        if (live && live.rate > 0) {
            return {
                rates: { USD: 1, CNY: live.rate },
                source: 'steam-live',
                label: 'Steam 实测' + (live.anchorName ? ' · ' + fxqCaseLabel(live.anchorName) : ''),
                rateDate: live.ts || 0,
                live: true,
            };
        }
        const mem = fxqState.mem || {};
        return mem.steam || null;
    }

    /** 手动购汇成本锚（TopupQuote 的第三个锚槽位）；没设 → null（不是 0） */
    function fxqCostAnchor() {
        const m = fxqState.manual;
        if (!m || !window.FxCore) return null;
        const mem = fxqState.mem || {};
        const base = mem.spot;
        if (!base || !base.rates) return null;
        const r = window.FxCore.applyManualRate(base.rates, m);
        if (!r.ok) return null;
        return { rates: r.rates, source: 'manual', label: '手动购汇成本' };
    }

    /** 从篮子原始字段挑稳健口径 + 误差 */
    function fxqRowPrices(row) {
        const lib = fxqLib();
        if (!lib) {
            return {
                steamPrice: row.steamUsdLow || 0, buffPrice: row.buffCnyLow || 0,
                errPct: null, usdField: 'lowest', buffField: 'low',
            };
        }
        const usd = lib.pickSteamPrice({ lowest: row.steamUsdLow, median: row.steamUsdMed }, 'USD');
        const buff = lib.pickBuffPrice({ lowCny: row.buffCnyLow, avg3Cny: row.buffAvg3Cny });
        return {
            steamPrice: usd.price,
            buffPrice: buff.price,
            errPct: lib.synthUncertainty([usd.errPct, buff.errPct]),
            usdField: usd.field,
            buffField: buff.field,
        };
    }

    function fxqEvalCard(card) {
        const TQ = window.TopupQuote;
        if (!TQ) return null;
        const q = TQ.normalize({ kind: 'per', ccy: 'USD', face: card.face, pay: card.pay, label: card.label || '' });
        if (!q) return null;
        const mem = fxqState.mem || {};
        const ev = TQ.evaluate(q, {
            spot: mem.spot,
            steam: fxqSteamAnchor(),
            cost: fxqCostAnchor(),
        });
        const med = fxqState.result && fxqState.result.median;
        const sp = window.CaseFx ? window.CaseFx.spread(med, ev && ev.rImpl) : null;
        return { ev: ev, sp: sp };
    }

    function fxqRecompute() {
        const items = fxqState.basket && fxqState.basket.items;
        if (!items || !items.length || !window.CaseFx) {
            fxqState.result = null;
            fxqState.rows = null;
            return;
        }
        const mapped = items.map((row) => {
            const p = fxqRowPrices(row);
            return {
                name: row.name,
                steamPrice: p.steamPrice,
                buffPrice: p.buffPrice,
                errPct: p.errPct,
                volume: row.volume || 0,
                note: row.note || '',
                steamUsdMed: row.steamUsdMed || 0,
                steamUsdLow: row.steamUsdLow || 0,
                buffAvg3Cny: row.buffAvg3Cny || 0,
                buffCnyLow: row.buffCnyLow || 0,
                steamField: p.usdField,
                buffField: p.buffField,
            };
        });
        fxqState.rows = mapped;
        fxqState.result = window.CaseFx.evaluateBasket(mapped, { buffFee: fxqFee() });
    }

    function fxqProgressText() {
        const p = fxqState.progress;
        if (!p) return '';
        if (typeof p === 'string') return p;
        if (p.name) return (p.i + 1) + '/' + p.total + ' ' + fxqCaseLabel(p.name);
        return '';
    }

    function fxqPaintStatus() {
        const ui = fxqState.ui;
        if (!ui || !ui.status.isConnected) return;
        ui.fetchBtn.textContent = fxqState.loading ? '停止' : ((fxqState.basket && fxqState.basket.items && fxqState.basket.items.length) ? '重新拉取' : '拉取箱子');
        ui.status.textContent = fxqState.loading
            ? (fxqProgressText() || '拉取中…')
            : '打开面板只读汇率。拉取箱子才会请求 Steam 与 BUFF。';
    }

    /** 三个锚点两两分歧 + 价差是不是噪声 */
    function fxqDivergenceBlock(result, steam, spot) {
        const lib = fxqLib();
        const rows = [];
        if (!lib) return rows;
        const caseNet = result && result.median;

        const d1 = lib.explainDivergence(steam.rate, spot.rate, {
            label: 'Steam 实测 vs 即期牌价',
            warn: 0.015, alert: 0.03,
            hintOk: '两口径基本一致',
            hintWarn: '这就是人民币钱包的换汇摩擦 —— 在 Steam 充值比在外面买余额贵这么多',
            hintAlert: '差异异常，两个口径可能有一个失效',
        });
        rows.push(d1);

        if (caseNet && steam.rate) {
            const delta = caseNet - steam.rate;
            const sig = lib.signalOf(delta, result.uncertainty, steam.rate);
            rows.push({
                level: sig === 'real' ? (Math.abs(delta) / steam.rate >= 0.03 ? 'alert' : 'warn') : 'ok',
                div: Math.abs(delta) / steam.rate,
                text: '箱子净汇率 vs Steam 实测：' + (delta >= 0 ? '+' : '') + delta.toFixed(2) + ' 元/美元',
                hint: sig === 'noise'
                    ? '差额落在价格量化误差（±' + (result.uncertainty || 0).toFixed(2) + '%）以内 —— 不构成信号'
                    : 'BUFF 报价相对 Steam 定价的偏离',
                signal: sig,
            });
        }
        return rows;
    }

    function fxqPaintDerived() {
        const ui = fxqState.ui;
        if (!ui || !ui.root.isConnected) {
            // 面板没开也要刷新徽标 —— 常驻徽标不依赖面板。
            fxqPaintBadge();
            return;
        }
        const zhOn = fxqCaseLang() !== 'en';
        if (ui.langZh) ui.langZh.className = zhOn ? 'on' : '';
        if (ui.langEn) ui.langEn.className = zhOn ? '' : 'on';
        fxqRecompute();
        const result = fxqState.result;
        const mem = fxqState.mem || {};
        const steam = fxqAnchorBits(fxqSteamAnchor());
        const spot = fxqAnchorBits(mem.spot);
        const lib = fxqLib();

        ui.statCase.textContent = result && result.median ? fxqRate(result.median) : '—';
        ui.statCaseErr.textContent = result && result.median && result.uncertainty
            ? '±' + (result.uncertainty >= 1 ? result.uncertainty.toFixed(1) : result.uncertainty.toFixed(2)) + '%'
            : '';
        ui.statSteam.textContent = steam.rate ? fxqRate(steam.rate) : '—';
        ui.statSteamSub.textContent = fxqState.live ? '实测' : '第三方声称';
        ui.statSpot.textContent = spot.rate ? fxqRate(spot.rate) : '—';
        ui.statSample.textContent = result ? (result.used + '/' + result.total) : '—';

        const age = fxqAgeText(fxqState.basket);
        let sampleNote = age;
        if (result && result.unknown && result.used > 0) {
            sampleNote = (sampleNote ? sampleNote + ' · ' : '') + '有效 ' + result.used + ' 只，少于 3 只，不给出中位数';
        }
        if (fxqState.basket && fxqBasketStale(fxqState.basket)) {
            sampleNote = (sampleNote ? sampleNote + ' · ' : '') + '数据已过期，请重新拉取';
        }
        ui.age.textContent = sampleNote;

        // 分歧块
        ui.div.textContent = '';
        const divs = fxqDivergenceBlock(result, steam, spot);
        if (divs.length) {
            ui.div.className = 'sme-fxq-div ' + (divs.some(d => d.level === 'alert') ? 'alert' : (divs.some(d => d.level === 'warn') ? 'warn' : 'ok'));
            divs.forEach((d) => {
                const row = h('div', { class: 'sme-fxq-divrow' }, [
                    h('span', { class: 'sme-fxq-tag sme-fxq-tag-' + (d.level || 'unknown'), text: d.level === 'alert' ? '异常' : (d.level === 'warn' ? '注意' : (d.level === 'ok' ? '正常' : '未知')) }),
                    h('span', { class: 'sme-fxq-divtxt', text: d.text }),
                ]);
                if (d.hint) row.appendChild(h('span', { class: 'sme-fxq-divhint', text: d.hint }));
                ui.div.appendChild(row);
            });
        } else {
            ui.div.className = 'sme-fxq-div unknown';
            ui.div.appendChild(h('div', { class: 'sme-fxq-divrow', text: '锚点分歧：缺可比口径' }));
        }

        // 箱子表
        ui.tbody.textContent = '';
        const rows = result ? result.rows : [];
        if (!rows.length) {
            ui.tbody.appendChild(h('tr', {}, [
                h('td', { colspan: '8', class: 'sme-fxq-meta', text: '还没有箱子数据。' }),
            ]));
        } else {
            rows.forEach((row, i) => {
                const raw = fxqState.rows && fxqState.rows[i] ? fxqState.rows[i] : {};
                const tr = h('tr', { class: row.status === 'used' ? '' : 'sme-fxq-off' });
                tr.appendChild(fxqCaseNameCell(row.name));
                tr.appendChild(h('td', { text: fxqUsd(raw.steamUsdMed || row.steamUsd) }));
                tr.appendChild(h('td', { text: row.volume > 0 ? String(Math.round(row.volume)) : '—' }));
                tr.appendChild(h('td', { text: fxqCny(raw.buffAvg3Cny || row.buffCny) }));
                tr.appendChild(h('td', { text: fxqRate(row.gross) }));
                tr.appendChild(h('td', { text: fxqRate(row.net) }));
                tr.appendChild(h('td', {
                    text: row.errPct && row.errPct > 0 ? '±' + (row.errPct >= 1 ? row.errPct.toFixed(1) : row.errPct.toFixed(2)) + '%' : '—',
                    title: '价格量化误差上界（±0.005/价格）',
                }));
                const badge = h('span', {
                    class: 'sme-fxq-pill sme-fxq-pill-' + (row.status || 'missing'),
                    text: FXQ_STATUS[row.status] || row.status || '—',
                    title: row.reason || '',
                });
                tr.appendChild(h('td', {}, [badge]));
                ui.tbody.appendChild(tr);
            });
        }

        fxqPaintCards(ui);
        fxqPaintPaste(ui);
        fxqPaintFoot(ui, steam, spot);
        fxqPaintStatus();
        fxqPaintBadge();
    }

    function fxqPaintCards(ui) {
        ui.cards.textContent = '';
        const cards = fxqCards();
        let bestId = null;
        let bestRate = Infinity;
        const evals = cards.map((card) => {
            const hit = fxqEvalCard(card);
            const rate = hit && hit.ev ? hit.ev.rImpl : Infinity;
            if (rate < bestRate) { bestRate = rate; bestId = card.id; }
            return hit;
        });
        if (!cards.length) {
            ui.cards.appendChild(h('div', { class: 'sme-fxq-note', text: '保存一条美金卡报价后，这里给出相对箱子净汇率的价差。' }));
            return;
        }
        const best = evals[cards.findIndex((c) => c.id === bestId)];
        if (best && best.ev) {
            const sp = best.sp;
            const name = cards.find((c) => c.id === bestId);
            let line = '最低卡价「' + (name && name.label || '') + '」' + fxqRate(best.ev.rImpl) + ' 元/美元';
            if (sp) line += '，相对箱子净汇率每 100 刀 ' + fxqSpreadText(sp);
            else line += '。箱子净汇率还没有（需要至少 3 只有效箱子）';
            ui.cards.appendChild(h('div', { class: 'sme-fxq-note', text: line }));
        }
        cards.forEach((card, i) => {
            const hit = evals[i];
            const ev = hit && hit.ev;
            const row = h('div', { class: 'sme-fxq-card' + (card.id === bestId ? ' sme-fxq-best' : '') });
            row.appendChild(h('span', { text: card.label || (card.face + '刀') }));
            row.appendChild(h('span', { text: ev ? fxqRate(ev.rImpl) : '—' }));
            if (ev && ev.band) {
                const band = h('span', { class: 'sme-fxq-band', text: ev.band.text, title: ev.band.hint || '' });
                band.style.background = fxqBandColor(ev.band.id);
                row.appendChild(band);
            } else {
                row.appendChild(h('span', { text: '—' }));
            }
            const spEl = h('span', { text: hit && hit.sp ? fxqSpreadText(hit.sp) : '—' });
            if (hit && hit.sp) spEl.className = hit.sp.per100 >= 0 ? 'sme-fxq-pos' : 'sme-fxq-neg';
            row.appendChild(spEl);
            const steamPct = ev && ev.steam ? (ev.steam.ratio * 100).toFixed(1) + '%' : '—';
            row.appendChild(h('span', { text: steamPct, title: '相对 Steam 参考价（实测反推）' }));
            const costPct = ev && ev.cost ? (ev.cost.ratio * 100).toFixed(1) + '%' : '—';
            row.appendChild(h('span', { text: costPct, title: '相对手动购汇成本' }));
            row.appendChild(h('button', {
                type: 'button', class: 'sme-fxq-btn', text: '删除',
                onClick: () => {
                    fxqSaveCards(fxqCards().filter((c) => c.id !== card.id));
                    fxqPaintDerived();
                },
            }));
            ui.cards.appendChild(row);
        });
    }

    function fxqPaintPaste(ui) {
        ui.pasteOut.textContent = '';
        const list = fxqState.pasted || [];
        if (!list.length) return;
        list.forEach((q) => {
            const row = h('div', { class: 'sme-fxq-card' });
            const label = h('span', { text: q.label || q.raw || (q.face + '刀') });
            if (q.confidence === 'lo') label.appendChild(h('span', { class: 'sme-fxq-lo', text: ' 低置信' }));
            row.appendChild(label);
            row.appendChild(h('span', { text: fxqRate(q.payCny / q.face) }));
            row.appendChild(h('span', { text: '' }));
            row.appendChild(h('span', { text: '' }));
            row.appendChild(h('span', { text: '' }));
            row.appendChild(h('span', { text: '' }));
            row.appendChild(h('button', {
                type: 'button', class: 'sme-fxq-btn', text: '保存',
                onClick: () => {
                    const listNow = fxqCards();
                    listNow.push({
                        id: Date.now().toString(36) + Math.floor(Math.random() * 1000).toString(36),
                        label: (q.label || (q.face + '刀')).slice(0, 24),
                        face: q.face,
                        pay: q.payCny,
                    });
                    while (listNow.length > FXQ_CARD_MAX) listNow.shift();
                    fxqSaveCards(listNow);
                    fxqPaintDerived();
                },
            }));
            ui.pasteOut.appendChild(row);
        });
    }

    function fxqPaintFoot(ui, steam, spot) {
        ui.foot.textContent = '';
        const mem = fxqState.mem || {};
        ui.foot.appendChild(h('div', { text: 'Steam 参考 ' + (steam.rate ? steam.rate.toFixed(4) : '—') + ' · ' + steam.meta }));
        ui.foot.appendChild(h('div', { text: '即期牌价 ' + (spot.rate ? spot.rate.toFixed(4) : '—') + ' · ' + spot.meta }));
        if (fxqState.manual) {
            ui.foot.appendChild(h('div', { text: '购汇成本 ' + fxqState.manual.value + ' · 手动（1 ' + fxqState.manual.currency + ' = ? USD 的反向写法）' }));
        }
        const warnings = mem.warnings || [];
        if (warnings.length) {
            ui.foot.appendChild(h('div', {
                text: warnings.map((w) => (w.anchor || '') + (w.reason ? ' ' + w.reason : '') + (w.source ? ' ' + w.source : '')).join('；'),
            }));
        }
    }

    /** 常驻汇率徽标（点一下打开面板） */
    function fxqPaintBadge() {
        const el = fxqState.badge;
        if (!el) return;
        const steam = fxqAnchorBits(fxqSteamAnchor());
        const val = el.querySelector('.sme-fxq-badgeval');
        const flag = el.querySelector('.sme-fxq-badgeflag');
        const src = el.querySelector('.sme-fxq-badgesrc');
        if (!val) return;
        val.textContent = steam.rate ? steam.rate.toFixed(4) : '—';
        if (flag) {
            flag.textContent = fxqState.manual ? '✎' : (fxqState.live ? '' : '?');
            flag.title = fxqState.manual ? '已用手动购汇成本' : (fxqState.live ? '实测反推值' : '第三方声称，未实测');
        }
        if (src) src.textContent = fxqState.live ? 'Steam 实测' : (fxqState.mem && fxqState.mem.steam ? '第三方表' : '');
    }

    function fxqEnsureBadge() {
        if (fxqState.badge && fxqState.badge.isConnected) return fxqState.badge;
        // 已存在（例如 SPA 换页后残留）就接管，而不是返回 null 让徽标永远不上屏
        const old = document.getElementById('sme-fxq-badge');
        if (old) { fxqState.badge = old; return old; }
        // 徽标样式写在面板的 style 里，面板没打开也必须先注入 ——
        // 否则徽标是个没有定位/背景的裸元素，看起来就是「右下角没显示」。
        fxqEnsureStyle();
        if (!document.body) return null;
        const el = h('div', { id: 'sme-fxq-badge', class: 'sme-fxq-badge', title: 'Steam 汇率（点击打开汇率报价面板，可拖动）' }, [
            h('span', { class: 'sme-fxq-badgeval', text: '—' }),
            h('span', { class: 'sme-fxq-badgeflag', text: '' }),
            h('span', { class: 'sme-fxq-badgesrc', text: '' }),
        ]);
        el.addEventListener('click', (e) => {
            if (el._dragged) { el._dragged = false; return; }
            fxqToggle();
        });
        // 拖动
        let dx = 0, dy = 0, moved = false;
        el.addEventListener('mousedown', (e) => {
            if (e.target.tagName === 'BUTTON') return;
            const rect = el.getBoundingClientRect();
            dx = e.clientX - rect.left;
            dy = e.clientY - rect.top;
            moved = false;
            const move = (ev) => {
                moved = true;
                const x = Math.max(4, Math.min(window.innerWidth - el.offsetWidth - 4, ev.clientX - dx));
                const y = Math.max(4, Math.min(window.innerHeight - el.offsetHeight - 4, ev.clientY - dy));
                el.style.left = x + 'px';
                el.style.top = y + 'px';
                el.style.right = 'auto';
                el.style.bottom = 'auto';
            };
            const up = () => {
                document.removeEventListener('mousemove', move);
                document.removeEventListener('mouseup', up);
                if (!moved) return;
                el._dragged = true;
                const rect = el.getBoundingClientRect();
                try { GM_setValue(FXQ_BADGE_POS_KEY, { x: rect.left, y: rect.top }); } catch (e) {}
            };
            document.addEventListener('mousemove', move);
            document.addEventListener('mouseup', up);
        });
        document.body.appendChild(el);
        fxqState.badge = el;
        // 恢复拖动位置：必须在 append 之后量尺寸，并把旧坐标夹回视口内
        // （窗口变小/换分辨率后旧坐标可能落在屏幕外，表现同样像「徽标不见了」）。
        let saved = null;
        try { saved = GM_getValue(FXQ_BADGE_POS_KEY, null); } catch (e) {}
        if (saved && Number.isFinite(saved.x) && Number.isFinite(saved.y)) {
            const w = el.offsetWidth || 120, hgt = el.offsetHeight || 28;
            const x = Math.max(4, Math.min(window.innerWidth - w - 4, saved.x));
            const y = Math.max(4, Math.min(window.innerHeight - hgt - 4, saved.y));
            el.style.left = x + 'px';
            el.style.top = y + 'px';
            el.style.right = 'auto';
            el.style.bottom = 'auto';
        }
        return el;
    }

    function fxqBuild() {
        fxqEnsureStyle();
        const root = h('div', { id: 'sme-fxq-panel', role: 'dialog', 'aria-modal': 'true', 'aria-label': '汇率报价参考' });
        const win = h('div', { class: 'sme-fxq-win' });
        const fetchBtn = h('button', { type: 'button', class: 'sme-fxq-btn', text: '拉取箱子', title: '按顺序请求 8 只武器箱的 Steam 美元价和 BUFF 在售价' });
        const status = h('span', { class: 'sme-fxq-status' });
        const head = h('div', { class: 'sme-fxq-head' }, [
            h('div', { class: 'sme-fxq-title' }, [
                h('span', { html: ICONS.dollarSign }),
                h('span', { text: '汇率报价' }),
                h('span', { class: 'sme-fxq-sub', text: '美金卡 · CS2 箱子' }),
            ]),
            h('button', { type: 'button', class: 'sme-fxq-x', title: '关闭', 'aria-label': '关闭', html: ICONS.close, onClick: () => fxqClose() }),
        ]);
        const toolbar = h('div', { class: 'sme-fxq-toolbar' }, [
            h('button', {
                type: 'button', class: 'sme-fxq-btn', text: '刷新汇率', title: '忽略缓存，重拉 Steam 实测汇率与即期牌价',
                onClick: () => { fxqRefreshAnchors(true); fxqLoadLiveRate(true); },
            }),
            fetchBtn,
            h('button', {
                type: 'button',
                class: 'sme-fxq-btn' + (settings.get('fxqBadge') === false ? '' : ' on'),
                text: settings.get('fxqBadge') === false ? '常驻徽标：关' : '常驻徽标：开',
                title: '在页面右下角常驻显示当前汇率（点击切换）',
                onClick: (e) => {
                    const on = settings.get('fxqBadge') === false;
                    fxqSetBadge(on);
                    e.currentTarget.className = 'sme-fxq-btn' + (on ? ' on' : '');
                    e.currentTarget.textContent = on ? '常驻徽标：开' : '常驻徽标：关';
                },
            }),
            status,
        ]);

        const statCase = h('b', { text: '—' });
        const statCaseErr = h('small', { text: '' });
        const statSteam = h('b', { text: '—' });
        const statSteamSub = h('small', { text: '' });
        const statSpot = h('b', { text: '—' });
        const statSample = h('b', { text: '—' });
        const tbody = h('tbody');
        const cards = h('div', { class: 'sme-fxq-cards' });
        const pasteOut = h('div', { class: 'sme-fxq-cards' });
        const foot = h('div', { class: 'sme-fxq-foot' });
        const age = h('div', { class: 'sme-fxq-meta' });
        const div = h('div', { class: 'sme-fxq-div unknown' });

        // 手动购汇成本（独立锚，不写回自动锚缓存）
        const manualPer = h('select', { class: 'sme-fxq-manualper' });
        [['usd', '1 USD = ? CNY'], ['cur', '1 CNY = ? USD']].forEach(([v, t]) => {
            manualPer.appendChild(h('option', { value: v, text: t }));
        });
        manualPer.value = 'usd';
        const manualVal = h('input', { type: 'number', step: '0.0001', min: '0', placeholder: '如 6.85', title: '你实际拿 1 美元余额要花多少人民币' });
        const manualBtn = h('button', { type: 'button', class: 'sme-fxq-btn', text: '应用', title: '手动汇率只影响本面板的「购汇成本」锚，不改自动汇率' });
        const manualClear = h('button', { type: 'button', class: 'sme-fxq-btn', text: '清除' });

        const faceInput = h('input', { type: 'number', step: '1', min: '0' });
        faceInput.value = '100';
        const payInput = h('input', { type: 'number', step: '0.01', min: '0', placeholder: '590' });
        const labelInput = h('input', { type: 'text', placeholder: '慢充', style: { width: '120px' } });
        const feeInput = h('input', { type: 'number', step: '0.1', min: '0', max: '20', title: 'BUFF 卖出手续费，百分比' });
        feeInput.value = fxqFeePercentText();
        feeInput.addEventListener('change', () => {
            const frac = fxqParseFeeInput(feeInput.value);
            if (frac === null) { feeInput.value = fxqFeePercentText(); return; }
            settings.set('fxqBuffFee', frac);
            feeInput.value = fxqFeePercentText();
            fxqPaintDerived();
        });
        const ta = h('textarea', { placeholder: '把群里的美金报价贴进来，例如：\n【快充】纯美金 610\n【慢充】大额300美金以上\n590' });
        const zhOn = fxqCaseLang() !== 'en';
        const langZh = h('button', {
            type: 'button', class: zhOn ? 'on' : '', text: '中文', title: '箱子列表显示中文名',
            onClick: () => { settings.set('fxqCaseLang', 'zh'); fxqPaintDerived(); },
        });
        const langEn = h('button', {
            type: 'button', class: zhOn ? '' : 'on', text: 'EN', title: '箱子列表显示英文市场名',
            onClick: () => { settings.set('fxqCaseLang', 'en'); fxqPaintDerived(); },
        });

        manualBtn.addEventListener('click', async () => {
            const value = parseFloat(manualVal.value);
            if (!Number.isFinite(value) || value <= 0) {
                manualVal.value = '';
                fxqPaintDerived();
                return;
            }
            const ok = await fxqSaveManual({ currency: 'CNY', per: manualPer.value, value: value });
            if (!ok) { manualVal.value = ''; return; }
            fxqPaintDerived();
        });
        manualClear.addEventListener('click', async () => {
            manualVal.value = '';
            await fxqSaveManual(null);
            fxqPaintDerived();
        });

        const scroll = h('div', { class: 'sme-fxq-scroll' }, [
            h('p', { class: 'sme-fxq-note', text: '箱子汇率按美元钱包买家价计算，对应美金卡入账后的购买力。国区钱包买同一只箱子不走这条汇率。价差未计 7 日交易冷却；BUFF 用的是前三档在售价均值，立刻卖掉要看求购价，通常更低。' }),
            h('div', { class: 'sme-fxq-stats' }, [
                h('div', { class: 'sme-fxq-stat', style: { '--accent': '#4ade80' } }, [h('span', { text: '箱子净汇率' }), statCase, statCaseErr]),
                h('div', { class: 'sme-fxq-stat', style: { '--accent': '#66c0f4' } }, [h('span', { text: 'Steam 参考' }), statSteam, statSteamSub]),
                h('div', { class: 'sme-fxq-stat', style: { '--accent': '#38bdf8' } }, [h('span', { text: '即期牌价' }), statSpot]),
                h('div', { class: 'sme-fxq-stat', style: { '--accent': '#f59e0b' } }, [h('span', { text: '有效样本' }), statSample]),
            ]),
            age,
            div,
            h('div', { class: 'sme-fxq-row' }, [
                h('label', { text: '购汇成本' }), manualPer, manualVal, manualBtn, manualClear,
                h('span', { class: 'sme-fxq-meta', text: '手动值只做「购汇成本」锚，不改自动汇率' }),
            ]),
            h('div', { class: 'sme-fxq-h' }, [
                h('b', { text: '箱子' }),
                h('span', { text: '取净汇率中位数' }),
                h('span', { class: 'sme-fxq-lang' }, [langZh, langEn]),
            ]),
            h('div', { class: 'sme-fxq-wrap' }, [
                h('table', { class: 'sme-fxq-table' }, [
                    h('thead', {}, [h('tr', {}, ['箱子', 'Steam中位', '24h量', 'BUFF均价', '毛汇率', '净汇率', '精度', '状态'].map((t) => h('th', { text: t })))]),
                    tbody,
                ]),
            ]),
            h('p', { class: 'sme-fxq-note', text: '净汇率 = BUFF 前三档均价 ÷ Steam 24h 中位价 × (1 − 手续费)。成交量低于 50 的不计入；偏离超过阈值（或超出该行价格量化误差能解释的范围）的算偏离。至少 3 只有效才给出中位数。' }),
            h('div', { class: 'sme-fxq-h', text: '美金卡' }),
            h('div', { class: 'sme-fxq-row' }, [
                h('label', { text: '面值' }), faceInput,
                h('label', { text: '实付¥' }), payInput,
                h('label', { text: '名称' }), labelInput,
                h('button', {
                    type: 'button', class: 'sme-fxq-btn', text: '保存',
                    onClick: () => {
                        const face = parseFloat(faceInput.value);
                        const pay = parseFloat(payInput.value);
                        if (!(face > 0) || !(pay > 0)) return;
                        const label = (labelInput.value || '').trim().slice(0, 24) || (face + '刀');
                        const list = fxqCards();
                        list.push({
                            id: Date.now().toString(36) + Math.floor(Math.random() * 1000).toString(36),
                            label: label, face: face, pay: pay,
                        });
                        while (list.length > FXQ_CARD_MAX) list.shift();
                        fxqSaveCards(list);
                        payInput.value = '';
                        fxqPaintDerived();
                    },
                }),
                h('label', { text: 'BUFF手续费%' }), feeInput,
            ]),
            cards,
            h('div', { class: 'sme-fxq-h', text: '粘贴群报价' }),
            h('div', { class: 'sme-fxq-row' }, [ta]),
            h('div', { class: 'sme-fxq-row' }, [
                h('button', {
                    type: 'button', class: 'sme-fxq-btn', text: '解析',
                    onClick: () => {
                        const TQ = window.TopupQuote;
                        fxqState.pasted = TQ
                            ? TQ.parseQuoteText(ta.value).filter((q) => q.kind === 'per' && q.ccy === 'USD')
                            : [];
                        if (!fxqState.pasted.length) {
                            pasteOut.textContent = '';
                            pasteOut.appendChild(h('div', { class: 'sme-fxq-note', text: '没有识别出美元面值报价。' }));
                            return;
                        }
                        fxqPaintPaste(fxqState.ui);
                    },
                }),
            ]),
            pasteOut,
        ]);
        win.appendChild(head);
        win.appendChild(toolbar);
        win.appendChild(scroll);
        win.appendChild(foot);
        root.appendChild(win);
        document.body.appendChild(root);
        root.addEventListener('click', (e) => { if (e.target === root) fxqClose(); });
        win.addEventListener('wheel', (e) => e.stopPropagation(), { passive: true });
        const onKey = (e) => {
            if (e.key !== 'Escape' || !document.getElementById('sme-fxq-panel')) return;
            e.stopPropagation();
            fxqClose();
        };
        document.addEventListener('keydown', onKey, true);
        root._dispose = () => document.removeEventListener('keydown', onKey, true);
        fetchBtn.addEventListener('click', () => {
            if (fxqState.loading) { fxqState.abort = true; fxqPaintStatus(); return; }
            fxqLoadBasket();
        });
        fxqState.ui = {
            root: root, fetchBtn: fetchBtn, status: status, age: age, tbody: tbody,
            cards: cards, pasteOut: pasteOut, foot: foot, div: div,
            statCase: statCase, statCaseErr: statCaseErr,
            statSteam: statSteam, statSteamSub: statSteamSub,
            statSpot: statSpot, statSample: statSample,
            manualPer: manualPer, manualVal: manualVal,
            langZh: langZh, langEn: langEn,
        };
        // 回填手动值
        if (fxqState.manual) {
            manualPer.value = fxqState.manual.per || 'usd';
            manualVal.value = fxqState.manual.value;
        }
    }

    async function fxqHydrate() {
        // 手动购汇成本
        try {
            const raw = await smeKv.get(FXQ_MANUAL_KEY, null);
            const p = typeof raw === 'string' ? JSON.parse(raw || 'null') : raw;
            fxqState.manual = (p && Number(p.value) > 0 && p.currency) ? p : null;
        } catch (e) { fxqState.manual = null; }
        // 实测汇率
        try {
            const raw = await smeKv.get(FXQ_LIVE_KEY, null);
            const p = typeof raw === 'string' ? JSON.parse(raw || 'null') : raw;
            if (p && p.rate > 0 && (Date.now() - (p.ts || 0)) < FXQ_LIVE_TTL) {
                fxqState.live = p;
            } else {
                fxqState.live = null;
            }
        } catch (e) { fxqState.live = null; }
        // 篮子
        if (fxqState.basket) return;
        try {
            const raw = await smeKv.get(FXQ_BASKET_KEY, null);
            const parsed = typeof raw === 'string' ? JSON.parse(raw || 'null') : raw;
            if (parsed && Array.isArray(parsed.items)) fxqState.basket = parsed;
        } catch (e) { /* 没有缓存就等用户点拉取 */ }
    }

    async function fxqRefreshAnchors(force) {
        const ui = fxqState.ui;
        const gen = ++fxqState.anchorGen;
        const eng = fxEngine;
        if (!eng) {
            if (ui && ui.foot.isConnected) ui.foot.textContent = '汇率库没有载入。';
            return;
        }
        if (ui && ui.status.isConnected && !fxqState.loading) ui.status.textContent = force ? '正在刷新汇率…' : '正在读取汇率…';
        try {
            const mem = await eng.load(!!force);
            if (gen !== fxqState.anchorGen) return;
            fxqState.mem = mem;
            fxqPaintDerived();
        } catch (e) {
            if (gen !== fxqState.anchorGen || !ui || !ui.foot.isConnected) return;
            ui.foot.textContent = '汇率获取失败：' + (e && e.message || e);
        }
    }

    /** 拉一次 priceoverview，返回 { lowest, median, volume }（各字段可能为 0） */
    async function fxqFetchPriceOverview(appid, name, currency) {
        const url = 'https://steamcommunity.com/market/priceoverview/?appid=' + appid
            + '&currency=' + currency + '&market_hash_name=' + encodeURIComponent(name);
        const j = await gmFetchJson(url, 15000);
        if (!j || j.success === false) throw new Error('priceoverview 响应异常');
        const code = currency === 23 ? 'CNY' : 'USD';
        return {
            lowest: fxqParseMoney(j.lowest_price, code),
            median: fxqParseMoney(j.median_price, code),
            volume: parseInt(String(j.volume || '0').replace(/[^\d]/g, ''), 10) || 0,
        };
    }

    /**
     * 实测反推 Steam 的人民币定价汇率（USD→CNY）。
     * 同一物品拉两个币种的价格，比值即 Steam 实际应用的汇率；
     * lowest / median 两个读数必须自洽，否则换下一只锚。
     */
    async function fxqProbeSteamRate() {
        const lib = fxqLib();
        if (!lib) return null;
        if (!fxqState.steamCh) fxqState.steamCh = new SmeRateChannel('fxq-steam', { gapAfter: 700 });
        for (const a of FXQ_RATE_ANCHORS) {
            if (fxqState.abort) return null;
            let usd = null;
            let cny = null;
            try {
                usd = await fxqState.steamCh.run(() => fxqFetchPriceOverview(a.appid, a.name, 1), () => !fxqState.abort);
                cny = await fxqState.steamCh.run(() => fxqFetchPriceOverview(a.appid, a.name, 23), () => !fxqState.abort);
            } catch (e) {
                if (fxqState.abort) return null;
                L('Fxq: 实测汇率探针失败', a.name, e && e.message);
                continue;
            }
            const r = lib.buildLiveRate(usd, cny, a, { walletCode: 'CNY' });
            if (r.ok) return r;
            L('Fxq: 探针锚点不合格', a.name, r.reason);
        }
        return null;
    }

    async function fxqLoadLiveRate(force) {
        const gen = ++fxqState.liveGen;
        if (!force && fxqState.live) return fxqState.live;
        const live = await fxqProbeSteamRate();
        if (gen !== fxqState.liveGen) return null;
        if (live) {
            live.ts = Date.now();
            fxqState.live = live;
            try { smeKv.set(FXQ_LIVE_KEY, JSON.stringify(live)).catch(() => {}); } catch (e) {}
        }
        fxqPaintDerived();
        return live;
    }

    /** 手动购汇成本：非法值一律拒绝并保留原值（绝不静默改自动汇率） */
    async function fxqSaveManual(v) {
        if (!v) {
            fxqState.manual = null;
            try { await smeKv.remove(FXQ_MANUAL_KEY); } catch (e) {}
            return true;
        }
        if (!window.FxCore) return false;
        const probe = window.FxCore.applyManualRate({ USD: 1, CNY: 1 }, v);
        if (!probe.ok) return false;
        fxqState.manual = v;
        try { await smeKv.set(FXQ_MANUAL_KEY, JSON.stringify(v)); } catch (e) {}
        return true;
    }

    async function fxqLoadBasket() {
        if (fxqState.loading) return;
        const gen = ++fxqState.gen;
        fxqState.loading = true;
        fxqState.abort = false;
        const items = [];
        try {
            fxqState.progress = '正在加载物品索引…';
            fxqPaintStatus();
            let map = {};
            try {
                const idx = await ratioLoadIndex('730');
                map = (idx && idx.items) || {};
            } catch (e) {
                L('Fxq: ID 索引加载失败', e && e.message);
            }
            if (fxqState.abort || gen !== fxqState.gen) return;
            if (!fxqState.steamCh) fxqState.steamCh = new SmeRateChannel('fxq-steam', { gapAfter: 700 });
            for (let i = 0; i < FXQ_CASES.length; i++) {
                if (fxqState.abort || gen !== fxqState.gen) break;
                const name = FXQ_CASES[i].name;
                fxqState.progress = { i: i, total: FXQ_CASES.length, name: name };
                fxqPaintStatus();
                const row = {
                    name: name,
                    steamUsdLow: 0, steamUsdMed: 0,
                    buffCnyLow: 0, buffAvg3Cny: 0,
                    volume: 0, note: '',
                };
                try {
                    const s = await fxqState.steamCh.run(() => fxqFetchPriceOverview(730, name, 1), () => !fxqState.abort);
                    if (fxqState.abort || gen !== fxqState.gen) break;
                    row.steamUsdLow = s.lowest;
                    row.steamUsdMed = s.median;
                    row.volume = s.volume || 0;
                    if (!(s.median > 0) && !(s.lowest > 0)) row.note = '无 Steam 报价';
                } catch (e) {
                    if (fxqState.abort || /任务已作废/.test(String(e && e.message))) break;
                    row.note = /HTTP 429/.test(String(e && e.message)) ? 'Steam 限流' : 'Steam 价格获取失败';
                    if (row.note === 'Steam 限流') await sleep(5000);
                }
                const ids = map[name];
                const buffId = ids && typeof ids.b === 'number' && ids.b > 0 ? ids.b : 0;
                const cacheKey = '730::' + name;
                if (!buffId) row.note = row.note || '索引未收录';
                else if (ratioCircuitOpen('buff') || ratioItemInBackoff('buff', cacheKey)) row.note = row.note || 'BUFF 限流熔断中';
                else if (!fxqState.abort && gen === fxqState.gen) {
                    try {
                        const b = await chBuffRatio.run(() => ratioFetchBuff(buffId, 'csgo'), () => !fxqState.abort);
                        if (b && !b.empty) {
                            row.buffCnyLow = b.lowCny || 0;
                            row.buffAvg3Cny = b.avg3Cny || 0;
                        }
                        if (!(row.buffAvg3Cny > 0) && !(row.buffCnyLow > 0)) row.note = row.note || 'BUFF 暂无在售';
                    } catch (e) {
                        if (fxqState.abort || /任务已作废/.test(String(e && e.message))) break;
                        ratioRecordFailure('buff', cacheKey, e);
                        row.note = row.note || (/HTTP 429|HTTP 403/.test(String(e && e.message)) ? 'BUFF 限流熔断中' : 'BUFF 请求失败');
                    }
                }
                if ((row.steamUsdMed > 0 || row.steamUsdLow > 0) && (row.buffAvg3Cny > 0 || row.buffCnyLow > 0)) row.note = '';
                items.push(row);
                fxqState.basket = { at: Date.now(), complete: false, items: items.slice() };
                fxqPaintDerived();
            }
        } finally {
            const aborted = fxqState.abort || gen !== fxqState.gen;
            fxqState.loading = false;
            fxqState.progress = '';
            if (items.length) {
                fxqState.basket = {
                    at: Date.now(),
                    complete: !aborted && items.length === FXQ_CASES.length,
                    items: items.slice(),
                };
                try { smeKv.set(FXQ_BASKET_KEY, JSON.stringify(fxqState.basket)).catch(() => {}); } catch (e) {}
            }
            fxqPaintDerived();
        }
    }

    function fxqClose() {
        fxqState.abort = true;
        fxqState.anchorGen++;
        fxqState.liveGen++;
        const panel = document.getElementById('sme-fxq-panel');
        if (panel) {
            if (panel._dispose) { try { panel._dispose(); } catch (e) {} }
            panel.remove();
        }
        fxqState.ui = null;
    }

    async function fxqToggle() {
        if (document.getElementById('sme-fxq-panel')) { fxqClose(); return; }
        fxqEnsureStyle();
        fxqBuild();
        await fxqHydrate();
        fxqPaintDerived();
        fxqRefreshAnchors(false);
        fxqLoadLiveRate(false);
    }

    function fxqLaunchButton(id) {
        return h('button', {
            id: id, type: 'button', class: 'sme-market-btn',
            title: '美金卡比价与 CS2 箱子汇率',
            text: '汇率报价',
            onClick: () => { fxqToggle(); },
        });
    }

    function fxqFloatingButton() {
        if (document.getElementById('sme-fxq-btn') || document.getElementById('sme-fxq-float')) return;
        const page = detectPageType();
        if (page !== 'browse' && page !== 'listing') return;
        const btn = fxqLaunchButton('sme-fxq-float');
        btn.classList.add('sme-fxq-float');
        document.body.appendChild(btn);
    }

    function fxqEnsureLauncher() {
        const page = detectPageType();
        if (page !== 'browse' && page !== 'listing') return;
        fxqEnsureStyle();
        if (page === 'listing') {
            let tries = 0;
            const tick = () => {
                if (document.getElementById('sme-fxq-btn') || document.getElementById('sme-fxq-float')) return;
                if (detectPageType() !== 'listing') return;
                const host = document.querySelector('.sme-panel .sme-header-title');
                if (host) { host.appendChild(fxqLaunchButton('sme-fxq-btn')); return; }
                if (++tries < 30) setTimeout(tick, 400);
                else fxqFloatingButton();
            };
            setTimeout(tick, 500);
            return;
        }
        // 市场首页：按钮由池子行情工具条在「行情分析」后面创建。
        // 池子条关着或迟迟没出现时，退到左下角悬浮按钮，避免入口消失。
        if (!settings.get('poolPanel')) { fxqFloatingButton(); return; }
        let tries = 0;
        const tick = () => {
            if (document.getElementById('sme-fxq-btn') || document.getElementById('sme-fxq-float')) return;
            if (detectPageType() !== 'browse') return;
            if (++tries < 40) setTimeout(tick, 400);
            else fxqFloatingButton();
        };
        setTimeout(tick, 600);
    }

    /** 常驻汇率徽标：进市场页就挂上，不用点开面板才知道汇率 */
    function fxqEnsureBadgeLauncher() {
        if (settings.get('fxqBadge') === false) return;
        const page = detectPageType();
        if (page !== 'browse' && page !== 'listing') return;
        const el = fxqEnsureBadge();
        if (!el) return;
        fxqPaintBadge();
        // 徽标占住右下角底部，交易分析按钮要让位
        positionAnalysisFab();
        fxqBadgeWarmup();
    }

    /** 徽标后台取数：先吃 6h 缓存，没有才发探针请求 */
    async function fxqBadgeWarmup() {
        if (fxqState.badgeLoading) return;
        fxqState.badgeLoading = true;
        try {
            try {
                const raw = await smeKv.get(FXQ_LIVE_KEY, null);
                const p = typeof raw === 'string' ? JSON.parse(raw || 'null') : raw;
                if (p && p.rate > 0 && (Date.now() - (p.ts || 0)) < FXQ_LIVE_TTL) {
                    fxqState.live = p;
                    fxqPaintBadge();
                }
            } catch (e) { /* 没有缓存就继续 */ }
            await fxqRefreshAnchors(false);
            if (!fxqState.live) await fxqLoadLiveRate(false);
            fxqPaintBadge();
        } catch (e) {
            L('Fxq: 徽标取数失败', e && e.message);
        } finally {
            fxqState.badgeLoading = false;
        }
    }

    /** 徽标开关：关掉就把浮标摘了 */
    function fxqSetBadge(on) {
        settings.set('fxqBadge', !!on);
        const el = fxqState.badge;
        if (!on) {
            if (el && el.isConnected) el.remove();
            fxqState.badge = null;
        } else {
            fxqEnsureBadge();
            fxqBadgeWarmup();
        }
    }

    function fxqOnNavigate() {
        const bar = document.getElementById('sme-fxq-bar');
        if (bar) bar.remove();
        const btn = document.getElementById('sme-fxq-btn');
        if (btn) btn.remove();
        const flo = document.getElementById('sme-fxq-float');
        if (flo) flo.remove();
    }

    // ==================== v1.9.0 跨平台挂刀比价 ====================
    // 数据源（2026-10-28 实测匿名可用；IGXE/C5/ECO 已要求登录，不接）：
    //   BUFF: GET buff.163.com/api/market/goods/sell_order?game=csgo|dota2&goods_id=X
    //         价格字段 data.items[].price（字符串 CNY），code==='OK'
    //   UUYP: POST api.youpin898.com/api/homepage/es/commodity/GetCsGoPagedList
    //         价格字段 Data.CommodityList[].Price（字符串 CNY），Code===0（仅 730）
    // ID 映射：SmallRob/steam-namespace data/market-ratio-index-v1.{730,570}.json
    //   （源=EricZhu-42/SteamTradingSite-ID-Mapper，market_hash_name → {b: buffId, u?: uuypId}）
    // 护栏：平台级熔断（429/403 → 30 分钟）；单物品连败 2 次 → 10 分钟退避；
    //   渠道限速 1500ms/件；数据永远带时间戳展示，熔断/失败如实降级，不用旧数据冒充。
    const RATIO_INDEX_BASE = 'https://cdn.jsdelivr.net/gh/SmallRob/steam-namespace@main/data/';
    const RATIO_INDEX_TTL = 30 * 24 * 3600 * 1000;      // ID 索引缓存 30 天
    const RATIO_QUOTES_TTL = 7 * 24 * 3600 * 1000;      // 比价结果缓存（池子列用）7 天
    const RATIO_FRESH_MS = 10 * 60 * 1000;              // 详情页 10 分钟内直接用缓存
    const RATIO_CIRCUIT_MS = 30 * 60 * 1000;            // 平台熔断时长
    const RATIO_ITEM_BACKOFF_MS = 10 * 60 * 1000;       // 单物品连败退避
    const RATIO_ITEM_MAX_FAILS = 2;
    const RATIO_SCAN_GAP_MS = 1500;                     // 扫描节奏（渠道层也限速）
    const RATIO_SCAN_BATCH = 100;                       // 单轮扫描上限
    const RATIO_QUOTES_KEY = 'sme_ratio_quotes_v1';     // GM 存储：比价结果缓存
    const RATIO_SUPPORTED_APPS = ['730', '570'];

    const ratioState = {
        indexes: {},        // appid -> { digest, items }（内存）
        indexLoading: {},   // appid -> Promise
        circuits: {},       // 'buff'/'uuyp' -> failUntil 时间戳
        itemFails: {},      // 'buff|appid::name' -> { n, until }
        quotes: null,       // GM 存储的比价结果缓存（懒加载）
        cache: {},          // 'appid::name' -> { at, data }（内存，含 in-flight 复用）
        inflight: {},       // 'appid::name' -> Promise
        scanning: false,
        scanAbort: false,
        styleAdded: false,
    };

    const chBuffRatio = new SmeRateChannel('ratio-buff', { gapAfter: RATIO_SCAN_GAP_MS });
    const chUuypRatio = new SmeRateChannel('ratio-uuyp', { gapAfter: RATIO_SCAN_GAP_MS });

    const RATIO_CSS = `
        .sme-ratio-note{font-size:11px;color:var(--sme-text-muted);line-height:1.5;margin-bottom:8px}
        .sme-ratio-table{width:100%;border-collapse:collapse;font-size:12px;margin:4px 0 10px}
        .sme-ratio-table th{text-align:left;color:var(--sme-text-dim);font-weight:600;padding:4px 8px;border-bottom:1px solid rgba(255,255,255,0.08);white-space:nowrap}
        .sme-ratio-table td{padding:5px 8px;border-bottom:1px solid rgba(255,255,255,0.04);white-space:nowrap}
        .sme-ratio-table tr:last-child td{border-bottom:none}
        .sme-ratio-badge{display:inline-block;padding:1px 7px;border-radius:9px;font-size:11px;font-weight:600}
        .sme-ratio-badge.good{background:rgba(108,220,132,0.16);color:#6cdc84}
        .sme-ratio-badge.mid{background:rgba(255,255,255,0.08);color:var(--sme-text-dim)}
        .sme-ratio-badge.bad{background:rgba(233,105,105,0.14);color:#e96969}
        .sme-ratio-platform{font-weight:600;color:var(--sme-text)}
        .sme-ratio-sub{color:var(--sme-text-muted);font-size:11px}
        .sme-ratio-sub.warn{color:#e0a44c}
        .sme-ratio-sub.bad{color:#e96969}
        .sme-ratio-err{color:#e96969;font-size:11px}
        .sme-ratio-actions{display:flex;gap:8px;align-items:center;margin:6px 0 2px}
    `;

    function ratioEnsureStyle() {
        if (ratioState.styleAdded) return;
        GM_addStyle(RATIO_CSS);
        ratioState.styleAdded = true;
    }

    /**
     * 比价结果缓存（内存）。
     * v2.0.0：持久化改走 IndexedDB 的 kv store，但**读取仍保持同步** ——
     *   池子明细的「挂刀」列是同步渲染 HTML 的，不能改成 async。
     *   载入由 ratioLoadQuotes() 在启动时异步完成，之后这里直接读内存。
     */
    function ratioQuotesStore() {
        if (!ratioState.quotes) ratioState.quotes = {};
        return ratioState.quotes;
    }

    /** 从 IndexedDB 载入比价结果缓存（启动时调用一次） */
    async function ratioLoadQuotes() {
        const raw = await smeKv.get(RATIO_QUOTES_KEY, '{}');
        let parsed = {};
        try { parsed = (typeof raw === 'string') ? JSON.parse(raw || '{}') : (raw || {}); }
        catch (e) { parsed = {}; }
        ratioState.quotes = parsed;
        return parsed;
    }

    async function ratioSaveQuote(key, data) {
        const store = ratioQuotesStore();
        // 顺手清理过期条目，防止 GM 存储无界膨胀
        const now = Date.now();
        for (const k of Object.keys(store)) {
            if (!store[k] || now - store[k].at > RATIO_QUOTES_TTL) delete store[k];
        }
        store[key] = { at: now, data };
        ratioState.quotes = store;
        // v2.0.0：改走 IndexedDB 的 kv store
        smeKv.set(RATIO_QUOTES_KEY, JSON.stringify(store)).catch(() => {});
    }

    /** 懒加载 ID 索引（GM 缓存 30 天 + digest 复用内存） */
    async function ratioLoadIndex(appid) {
        if (ratioState.indexes[appid]) return ratioState.indexes[appid];
        if (ratioState.indexLoading[appid]) return ratioState.indexLoading[appid];
        const task = (async () => {
            // v2.0.0：改走 IndexedDB 的 kv store；动态键（按 appid）迁移时无法枚举，
            //   这里先查 IDB，未命中再回退 GM（老数据仍可读）
            const idxKey = 'sme_ratio_index_v1_' + appid;
            let cached = null;
            const rawIdx = await smeKv.get(idxKey, null);
            if (rawIdx) { try { cached = (typeof rawIdx === 'string') ? JSON.parse(rawIdx) : rawIdx; } catch (e) { cached = null; } }
            if (!cached) { try { cached = GM_getValue(idxKey, null); } catch (e) {} }
            if (cached && cached.items && Date.now() - cached.at < RATIO_INDEX_TTL) {
                ratioState.indexes[appid] = cached;
                return cached;
            }
            const data = await gmFetchJson(RATIO_INDEX_BASE + 'market-ratio-index-v1.' + appid + '.json', 30000);
            if (!data || !data.items || !data.digest) throw new Error('ID 索引格式异常');
            const entry = { at: Date.now(), digest: data.digest, items: data.items };
            smeKv.set(idxKey, JSON.stringify(entry)).catch(() => {});
            ratioState.indexes[appid] = entry;
            return entry;
        })();
        ratioState.indexLoading[appid] = task;
        try { return await task; } finally { delete ratioState.indexLoading[appid]; }
    }

    function ratioCircuitOpen(platform) {
        const until = ratioState.circuits[platform] || 0;
        return until > Date.now();
    }

    function ratioRecordFailure(platform, cacheKey, err) {
        L('Ratio: ' + platform + ' 请求失败', cacheKey, err && err.message);
        if (err && (/HTTP 429|HTTP 403/.test(err.message))) {
            ratioState.circuits[platform] = Date.now() + RATIO_CIRCUIT_MS;
            (platform === 'buff' ? chBuffRatio : chUuypRatio).reset();
            L('Ratio: ' + platform + ' 触发限流，熔断 ' + (RATIO_CIRCUIT_MS / 60000) + ' 分钟');
            return;
        }
        const fk = platform + '|' + cacheKey;
        const cur = ratioState.itemFails[fk] || { n: 0, until: 0 };
        cur.n += 1;
        cur.until = cur.n >= RATIO_ITEM_MAX_FAILS ? Date.now() + RATIO_ITEM_BACKOFF_MS : 0;
        ratioState.itemFails[fk] = cur;
    }

    function ratioItemInBackoff(platform, cacheKey) {
        const fk = platform + '|' + cacheKey;
        const cur = ratioState.itemFails[fk];
        return !!(cur && cur.until > Date.now());
    }

    function gmPostJson(url, body, timeout = 15000) {
        return new Promise((resolve, reject) => {
            GM_xmlhttpRequest({
                method: 'POST',
                url: url,
                headers: { 'Content-Type': 'application/json', 'Referer': 'https://www.youpin898.com/' },
                data: JSON.stringify(body),
                timeout: timeout,
                onload: (resp) => {
                    if (resp.status >= 200 && resp.status < 300) {
                        try { resolve(JSON.parse(resp.responseText)); }
                        catch (e) { reject(new Error('JSON parse error: ' + e.message)); }
                    } else {
                        reject(new Error('HTTP ' + resp.status));
                    }
                },
                onerror: () => reject(new Error('Network error')),
                ontimeout: () => reject(new Error('Timeout')),
            });
        });
    }

    /** BUFF 在售前 10 档 → { lowCny, avg3Cny, count }（价格单位：元，float） */
    async function ratioFetchBuff(buffId, game) {
        const url = 'https://buff.163.com/api/market/goods/sell_order?game=' + game
            + '&goods_id=' + encodeURIComponent(buffId) + '&page_num=1&page_size=10';
        const j = await gmFetchJson(url, 15000);
        if (!j || j.code !== 'OK' || !j.data || !Array.isArray(j.data.items)) throw new Error('BUFF 响应异常');
        const prices = j.data.items.map(i => ratioNum(i.price)).filter(p => p > 0);
        if (!prices.length) return { lowCny: 0, avg3Cny: 0, count: j.data.total_count || 0, empty: true };
        return {
            lowCny: prices[0],
            avg3Cny: prices.slice(0, 3).reduce((a, b) => a + b, 0) / Math.min(3, prices.length),
            count: j.data.total_count || prices.length,
        };
    }

    // ===== v2.2.4 挂刀比价纯计算层开始 =====
    /**
     * 宽松数字解析：第三方平台的数字字段**实际返回的是字符串**（实测悠悠有品 Price = "159"，
     * BUFF price = "162.00"），也可能带千分位/货币符号。
     *
     * ★ 为什么不能直接 parseFloat：parseFloat("1,234.56") === 1 ——
     *   遇到千分位逗号就截断，1234.56 被读成 1，金额直接错 1000 倍。
     * ★ 为什么**严格**匹配而不是「捞出里面的数字」：宽松正则会把 "12件起" 读成 12，
     *   凭空造出一个价格。宁可返回 0（= 未知，UI 显示「—」），也不给一个看着像结论的数。
     */
    function ratioNum(v) {
        if (typeof v === 'number') return Number.isFinite(v) ? v : 0;
        if (v === null || v === undefined) return 0;
        const cleaned = String(v).replace(/[,\s¥￥]/g, '').replace(/[元块]$/, '');
        if (!/^-?\d+(?:\.\d+)?$/.test(cleaned)) return 0;
        const n = parseFloat(cleaned);
        return Number.isFinite(n) ? n : 0;
    }

    /**
     * 平台自己标的 Steam 价 vs Steam 实测价（priceoverview 24h 中位价）的背离度。
     *
     * 背景（2026-11-11 一线实测，AK-47 | 红线 (久经沙场)）：
     *   悠悠有品响应里的 TemplateInfo.SteamPrice = 204.10，
     *   同一时刻 Steam priceoverview 中位价 = ¥210.32 —— 平台标的价**偏旧 2.96%**。
     *
     * ★ 这个值**不能**当锚点（比价仍以 Steam 实测中位价为准）。
     *   它的用途是提示用户「平台网页上标的 Steam 价与实时价有差，别被它误导」——
     *   没有这个提示，用户会以为脚本的挂刀比例和平台页上写的不一样是脚本算错了。
     *
     * @param platformSteamCents 平台标的 Steam 价（分）
     * @param steamMedianCents   Steam 实测 24h 中位价（分）
     * @returns {{pct:number, level:'ok'|'warn'|'bad', lag:boolean}|null}
     *          null = 缺任一端（unknown≠0，绝不硬算一个数出来）
     */
    function ratioSteamPriceDivergence(platformSteamCents, steamMedianCents) {
        if (!(platformSteamCents > 0) || !(steamMedianCents > 0)) return null;
        const pct = (platformSteamCents - steamMedianCents) / steamMedianCents;
        const abs = Math.abs(pct);
        let level = 'ok';
        if (abs >= 0.10) level = 'bad';
        else if (abs >= 0.05) level = 'warn';
        return { pct: pct, level: level, lag: pct < 0 };
    }
    // ===== v2.2.4 挂刀比价纯计算层结束 =====

    /**
     * 悠悠有品在售前 10 档 → { lowCny, avg3Cny, count, steamPriceCny, exterior }（仅 730）
     *
     * ★ v2.2.4 修 count 口径：改用 Data.TemplateInfo.OnSaleCount（真实在售数）。
     *   旧实现填的是 prices.length —— 那是「我取的前 10 档里有几条合法价格」，
     *   跟 BUFF 的 total_count（真实在售数）根本不是一个口径，同一列显示的是假数。
     *   实测（AK-47 | 红线 久经沙场）：真实在售 11492 件，旧实现只显示 ≤10。
     *   ★ 顺带把平台标的 Steam 价（TemplateInfo.SteamPrice）一起取走：
     *   同一个响应里就有，零额外请求。
     */
    async function ratioFetchUuyp(uuypId) {
        const j = await gmPostJson('https://api.youpin898.com/api/homepage/es/commodity/GetCsGoPagedList', {
            listSortType: 1, listType: 10, pageIndex: 1, pageSize: 10, sortType: 1, templateId: String(uuypId),
        }, 15000);
        if (!j || j.Code !== 0 || !j.Data || !Array.isArray(j.Data.CommodityList)) throw new Error('悠悠有品响应异常');
        const prices = j.Data.CommodityList.map(i => ratioNum(i.Price)).filter(p => p > 0);
        const ti = j.Data.TemplateInfo || {};
        const onSale = ratioNum(ti.OnSaleCount);
        const steamPriceCny = ratioNum(ti.SteamPrice);
        const base = {
            // 在售数：0 = 平台没给（未知）→ UI 显示「—」。绝不拿 prices.length 冒充。
            count: onSale > 0 ? Math.round(onSale) : 0,
            steamPriceCny: steamPriceCny > 0 ? steamPriceCny : 0,
            steamPriceUsd: ratioNum(ti.SteamUSDPrice),
            exterior: String(ti.Exterior || ''),
        };
        if (!prices.length) return { lowCny: 0, avg3Cny: 0, empty: true, ...base };
        return {
            lowCny: prices[0],
            avg3Cny: prices.slice(0, 3).reduce((a, b) => a + b, 0) / Math.min(3, prices.length),
            ...base,
        };
    }

    /**
     * 由买家支付价反推卖家到手（分）。Steam 手续费 = max(5%, 1分) + max(10%, 1分)，
     * 与 calcReceivedAmount 同口径但独立实现（这里的锚定价是 CNY，与钱包币种无关）。
     */
    function ratioSteamNetCents(grossCents) {
        if (!(grossCents > 0)) return 0;
        const feeOf = (recv) => {
            const sf = Math.max(Math.floor(recv * 0.05), 1);
            const pf = Math.max(Math.floor(recv * 0.10), 1);
            return recv + sf + pf;
        };
        let est = Math.floor(grossCents / 1.15);
        let undershot = false;
        for (let i = 0; i < 10; i++) {
            const total = feeOf(est);
            if (total === grossCents) return est;
            if (total > grossCents) {
                if (undershot) return est - 1;   // 尾差并入手续费，到手取 est-1
                est -= 1;
            } else {
                undershot = true;
                est += 1;
            }
        }
        return est;
    }

    /** priceoverview（currency=23 强制 CNY）→ { medianCny, lowestCny, volume }，单位：分 */
    async function ratioFetchSteamAnchor(appid, name) {
        const url = 'https://steamcommunity.com/market/priceoverview/?appid=' + appid
            + '&currency=23&market_hash_name=' + encodeURIComponent(name);
        const j = await gmFetchJson(url, 15000);
        if (!j || !j.success) throw new Error('priceoverview 响应异常');
        const toCents = (s) => {
            if (!s) return 0;
            const m = String(s).match(/([\d.,]+)/);
            if (!m) return 0;
            return Math.round(parseFloat(m[1].replace(/,/g, '')) * 100) || 0;
        };
        return {
            medianCny: toCents(j.median_price),
            lowestCny: toCents(j.lowest_price),
            volume: parseInt(String(j.volume || '0').replace(/,/g, ''), 10) || 0,
        };
    }

    /**
     * 拉取一件物品的完整比价数据（缓存 10 分钟；in-flight 复用）。
     * 返回 null 表示：非 730/570、未映射、熔断中或退避中（调用方如实展示「无数据」）。
     * @returns {Promise<{unmapped?:boolean, steam?:object, buff?:object, uuyp?:object}|null>}
     */
    async function ratioGetQuotes(appid, name) {
        if (!RATIO_SUPPORTED_APPS.includes(appid)) return null;
        const cacheKey = appid + '::' + name;
        const cached = ratioState.cache[cacheKey];
        if (cached && Date.now() - cached.at < RATIO_FRESH_MS) return cached.data;
        if (ratioState.inflight[cacheKey]) return ratioState.inflight[cacheKey];

        const task = (async () => {
            let entry = null;
            try { entry = await ratioLoadIndex(appid); } catch (e) {
                L('Ratio: ID 索引加载失败', appid, e && e.message);
                return null;
            }
            const ids = entry.items[name];
            if (!ids) return { unmapped: true };

            const game = appid === '730' ? 'csgo' : 'dota2';
            const wantBuff = typeof ids.b === 'number' && ids.b > 0;
            const wantUuyp = appid === '730' && typeof ids.u === 'number' && ids.u > 0;
            if (!wantBuff && !wantUuyp) return { unmapped: true };

            const out = { };
            // Steam 锚点（CNY）：24h 中位优先，最低价兜底
            try {
                out.steam = await ratioFetchSteamAnchor(appid, name);
            } catch (e) {
                ratioRecordFailure('steam', cacheKey, e);
            }
            if (wantBuff && !ratioCircuitOpen('buff') && !ratioItemInBackoff('buff', cacheKey)) {
                try {
                    out.buff = await chBuffRatio.run(() => ratioFetchBuff(ids.b, game));
                } catch (e) { ratioRecordFailure('buff', cacheKey, e); }
            }
            if (wantUuyp && !ratioCircuitOpen('uuyp') && !ratioItemInBackoff('uuyp', cacheKey)) {
                try {
                    out.uuyp = await chUuypRatio.run(() => ratioFetchUuyp(ids.u));
                } catch (e) { ratioRecordFailure('uuyp', cacheKey, e); }
            }
            const data = (out.steam || out.buff || out.uuyp) ? out : null;
            if (data) await ratioSaveQuote(cacheKey, data);
            ratioState.cache[cacheKey] = { at: Date.now(), data };
            return data;
        })();
        ratioState.inflight[cacheKey] = task;
        try { return await task; } finally { delete ratioState.inflight[cacheKey]; }
    }

    /** 挂刀比例（行情站口径）= 平台最低价 ÷ Steam 24h 中位价；>1 Steam 划算，<1 平台价更低 */
    function ratioComputeRatio(platformLowCnyCents, medianCnyCents) {
        if (!(platformLowCnyCents > 0) || !(medianCnyCents > 0)) return null;
        return platformLowCnyCents / medianCnyCents;
    }

    /** 转平台到手差（分，CNY）= 平台最低×feeFactor − Steam 最低卖单税后到手；正数=转平台多赚 */
    function ratioComputeNetDelta(platformLowCnyCents, steamLowestCnyCents, feeFactor) {
        if (!(platformLowCnyCents > 0) || !(steamLowestCnyCents > 0)) return null;
        const netPlatform = Math.round(platformLowCnyCents * feeFactor);
        const netSteam = ratioSteamNetCents(steamLowestCnyCents);
        return { netPlatform, netSteam, delta: netPlatform - netSteam };
    }

    function ratioCnyFmt(cents) {
        if (!(cents > 0)) return '—';
        return '¥' + (cents / 100).toFixed(2);
    }

    function ratioBadge(ratio) {
        if (ratio === null) return '<span class="sme-ratio-badge mid">—</span>';
        const pct = Math.round(ratio * 100);
        // ≥1：Steam 价不高于平台，挂单划算；<0.85：平台明显更便宜（买刀好时机）；中间灰色带
        const cls = ratio >= 1 ? 'good' : (ratio < 0.85 ? 'bad' : 'mid');
        return `<span class="sme-ratio-badge ${cls}" title="平台最低价 ÷ Steam 24h 中位价">${pct}%</span>`;
    }

    /** 详情页「挂刀比价」标签页渲染（switchTab 调用；点开才发请求） */
    function renderRatioPane(pane) {
        ratioEnsureStyle();
        const info = getListingInfo();
        if (!info || !RATIO_SUPPORTED_APPS.includes(info.appid)) {
            pane.appendChild(makeError('挂刀比价仅支持 CS2(730) / DOTA2(570) 市场物品。'));
            return;
        }
        const feeFactor = settings.get('platformFeeFactor') || 0.85;

        const root = h('div', {});
        pane.appendChild(root);
        let rendering = false;

        async function draw() {
            if (rendering) return;
            rendering = true;
            const paint = (html) => { root.innerHTML = html; };
            const cacheKey = info.appid + '::' + info.marketHashName;
            const cached = ratioState.cache[cacheKey];
            const ageMin = cached ? Math.round((Date.now() - cached.at) / 60000) : null;
            paint(`<div class="sme-ratio-note">拉取中…（BUFF / 悠悠有品 + Steam CNY 锚点，各平台限速 1.5s/件）</div>`);

            const data = await ratioGetQuotes(info.appid, info.marketHashName);
            let html = '<div class="sme-ratio-actions">'
                + `<button class="sme-btn" id="sme-ratio-refresh" type="button">刷新</button>`
                + `<span class="sme-ratio-sub">平台价恒为 CNY${ageMin !== null ? ' · 数据 ' + ageMin + ' 分钟前' : ''} · 扣费系数 ${(feeFactor * 100).toFixed(0)}%</span></div>`;
            html += '<div class="sme-ratio-note">挂刀比例 = 平台最低价 ÷ Steam 24h 中位价（>100% 说明 Steam 更贵，挂 Steam 划算；&lt;85% 说明平台明显更便宜）。到手对比按「平台最低×扣费系数 vs Steam 最低卖单税后(≈87%)」估算，仅供决策参考。</div>';

            if (data === null) {
                html += '<div class="sme-ratio-err">比价数据不可用：' + (
                    ratioCircuitOpen('buff') || ratioCircuitOpen('uuyp')
                        ? '平台限流熔断中（约 ' + Math.ceil(((Math.max(ratioState.circuits.buff || 0, ratioState.circuits.uuyp || 0)) - Date.now()) / 60000) + ' 分钟后恢复）'
                        : '请求失败，可稍后点「刷新」重试'
                ) + '。</div>';
            } else if (data.unmapped) {
                html += '<div class="sme-ratio-sub">该物品没有第三方平台映射（ID 索引未收录，如涂鸦/徽章/新饰品）。</div>';
            } else {
                const st = data.steam;
                html += '<table class="sme-ratio-table"><thead><tr><th>市场</th><th>最低价</th><th>前3档均价</th><th>在售</th><th>挂刀比例</th><th>说明</th></tr></thead><tbody>';
                if (st && (st.medianCny > 0 || st.lowestCny > 0)) {
                    html += `<tr><td class="sme-ratio-platform">Steam（CNY 锚点）</td>`
                        + `<td>${ratioCnyFmt(st.lowestCny)}</td><td>—</td>`
                        + `<td>${st.volume > 0 ? st.volume + ' 件/24h' : '—'}</td><td>—</td>`
                        + `<td class="sme-ratio-sub">24h 中位 ${ratioCnyFmt(st.medianCny)}</td></tr>`;
                } else {
                    // 区分两种「没有数据」：请求本身失败（st 为空） vs 请求成功但该物品当前无报价。
                    // Steam 对无挂单的物品会返回 success:true 但不带价格，混为一谈会被当成 bug。
                    const why = st
                        ? '无报价（该物品当前无在售或无 24h 成交）'
                        : '获取失败（请求出错，可点「刷新」重试）';
                    html += `<tr><td class="sme-ratio-platform">Steam（CNY 锚点）</td><td colspan="5" class="sme-ratio-err">${why}</td></tr>`;
                }
                for (const [pk, label] of [['buff', 'BUFF'], ['uuyp', '悠悠有品']]) {
                    const p = data[pk];
                    if (!p) {
                        // 未请求（未映射到该平台 / UUYP 仅 730）时不占行，保持表格干净
                        continue;
                    }
                    if (p.empty) {
                        html += `<tr><td class="sme-ratio-platform">${label}</td><td colspan="5" class="sme-ratio-sub">平台暂无在售</td></tr>`;
                        continue;
                    }
                    const ratio = st ? ratioComputeRatio(Math.round(p.lowCny * 100), st.medianCny) : null;
                    let deltaTxt = '—';
                    if (st && st.lowestCny > 0) {
                        const d = ratioComputeNetDelta(Math.round(p.lowCny * 100), st.lowestCny, feeFactor);
                        if (d) {
                            deltaTxt = d.delta >= 0
                                ? `<span style="color:#6cdc84">转平台多 ¥${(d.delta / 100).toFixed(2)}</span>`
                                : `<span style="color:#e96969">转平台少 ¥${(-d.delta / 100).toFixed(2)}</span>`;
                        }
                    }
                    // ★ v2.2.4：平台标的 Steam 价 vs Steam 实测价的背离提示。
                    //   平台标的价是平台自己缓存的 Steam 价（实测偏旧），比价锚点仍用 Steam 实测中位价；
                    //   这里只是让用户知道「平台页上写的 Steam 价 ≠ 实时价」，避免误以为脚本算错。
                    let stampHtml = '';
                    if (p.steamPriceCny > 0) {
                        const dv = st ? ratioSteamPriceDivergence(Math.round(p.steamPriceCny * 100), st.medianCny) : null;
                        const lv = dv ? dv.level : 'ok';
                        const pctTxt = dv ? ((dv.pct >= 0 ? '+' : '') + (dv.pct * 100).toFixed(1) + '%') : '';
                        stampHtml = '<br><span class="sme-ratio-sub ' + lv + '">平台标 Steam 价 ¥'
                            + p.steamPriceCny.toFixed(2)
                            + (pctTxt ? '（较实测 ' + pctTxt + '）' : '') + '</span>';
                    }
                    html += `<tr><td class="sme-ratio-platform">${label}${stampHtml}</td>`
                        + `<td>${ratioCnyFmt(Math.round(p.lowCny * 100))}</td>`
                        + `<td>${ratioCnyFmt(Math.round(p.avg3Cny * 100))}</td>`
                        + `<td>${p.count || '—'}</td>`
                        + `<td>${ratioBadge(ratio)}</td>`
                        + `<td class="sme-ratio-sub">${deltaTxt}</td></tr>`;
                }
                html += '</tbody></table>';
                html += '<div class="sme-ratio-sub">「转平台多/少」= 把该物品拿到第三方平台卖 vs 在 Steam 挂单的到手价差（估算）。</div>';
                html += '<div class="sme-ratio-sub">「平台标 Steam 价」= 平台自己标的 Steam 价，与 Steam 实测中位价的偏差；比价锚点始终用 Steam 实测值，平台标价偏旧时以脚本数值为准。</div>';
            }
            paint(html);
            const btn = document.getElementById('sme-ratio-refresh');
            if (btn) btn.addEventListener('click', () => {
                delete ratioState.cache[cacheKey];   // 强制刷新（绕过 10 分钟新鲜期）
                draw();
            });
            rendering = false;
        }

        draw().catch(e => {
            L('Ratio: 渲染失败', e);
            root.innerHTML = '<div class="sme-ratio-err">比价数据加载失败：' + escapeHtml(String(e && e.message || e)) + '</div>';
            rendering = false;
        });
    }

    // ---------- v1.9.0 池子挂刀扫描（仅 BUFF 单源；默认关） ----------
    function ratioPoolScanCandidates() {
        const out = [];
        for (const [key, it] of poolState.items) {
            const appid = String(it.appid || (key.split('::')[0] || ''));
            if (!RATIO_SUPPORTED_APPS.includes(appid)) continue;
            const name = it.name || key.split('::').slice(1).join('::');
            if (!name) continue;
            out.push({ key, appid, name });
        }
        return out;
    }

    async function poolRatioScan() {
        if (ratioState.scanning) { ratioState.scanAbort = true; poolSetStatus('正在停止扫描…'); return; }
        if (!settings.get('crossPlatformQuote')) { poolSetStatus('请先在设置开启「挂刀比价」'); return; }
        const cands = ratioPoolScanCandidates();
        if (!cands.length) { poolSetStatus('池子里没有 CS2/DOTA2 物品'); return; }

        const ok = confirm(`将对池子内 ${Math.min(cands.length, RATIO_SCAN_BATCH)} 件 CS2/DOTA2 物品逐件请求 BUFF 在售价（约 ${(Math.min(cands.length, RATIO_SCAN_BATCH) * RATIO_SCAN_GAP_MS / 1000 / 60).toFixed(1)} 分钟），限速 1.5s/件。继续？`);
        if (!ok) return;

        ratioState.scanning = true;
        ratioState.scanAbort = false;
        // 预热所需 appid 的 ID 索引（懒加载）
        const apps = [...new Set(cands.map(c => c.appid))];
        try { await Promise.all(apps.map(a => ratioLoadIndex(a))); } catch (e) {
            poolSetStatus('ID 索引加载失败：' + (e && e.message || e));
            ratioState.scanning = false;
            return;
        }

        let done = 0, hit = 0;
        for (const c of cands.slice(0, RATIO_SCAN_BATCH)) {
            if (ratioState.scanAbort) break;
            try {
                const data = await ratioGetQuotes(c.appid, c.name);
                if (data && !data.unmapped && (data.buff || data.uuyp)) hit++;
            } catch (e) { /* 失败计数/熔断由 ratioGetQuotes 内部处理 */ }
            done++;
            poolSetStatus(`挂刀扫描 ${done}/${Math.min(cands.length, RATIO_SCAN_BATCH)} · 命中 ${hit}`);
            poolSetProgress(done / Math.min(cands.length, RATIO_SCAN_BATCH));
        }
        const aborted = ratioState.scanAbort;
        ratioState.scanning = false;
        ratioState.scanAbort = false;
        poolSetProgress(0);
        poolSetStatus(aborted ? `挂刀扫描已停止（完成 ${done} 件）` : `挂刀扫描完成：${hit}/${done} 件有平台数据`);
    }

    /**
     * 池子明细行「挂刀」列单元格（有缓存才显示，绝不主动请求）。
     * @returns {string} HTML
     */
    function ratioPoolCellHtml(appid, name) {
        if (!RATIO_SUPPORTED_APPS.includes(String(appid || ''))) return '<span class="sme-pool-td-none">—</span>';
        const store = ratioQuotesStore();
        const q = store[appid + '::' + name];
        if (!q || !q.data) return '<span class="sme-pool-td-none">—</span>';
        const low = (q.data.buff && q.data.buff.lowCny) || (q.data.uuyp && q.data.uuyp.lowCny);
        const median = q.data.steam && q.data.steam.medianCny;
        const ratio = ratioComputeRatio(Math.round(low * 100), median);
        if (ratio === null) return '<span class="sme-pool-td-none">—</span>';
        const ageH = Math.round((Date.now() - q.at) / 3600000);
        const cls = ratio >= 1 ? 'good' : (ratio < 0.85 ? 'bad' : 'mid');
        return `<span class="sme-ratio-badge ${cls}" title="平台最低 ÷ Steam 24h 中位 · ${ageH}h 前">${Math.round(ratio * 100)}%</span>`;
    }

    // ==================== v2.0.0 纯计算层开始（SME-PURE-LAYER）====================
    // 本层刻意**不引入 DOM / GM 依赖** —— test/ 下的 vm 沙箱测试可直接切出执行。
    // 收录三块：
    //   ① Steam 货币映射单一事实源（依据 Steamworks 官方 ECurrency 表）
    //   ② Steam 新版 React SSR（valve-ssr-data）解析
    //   ③ 纯计算：定价策略 / 价格提醒 / 库存浮盈 / 交易冷却
    //
    // ⚠️ v2.0.0 的起因：Steam 市场页面已整体改版为 React SSR，旧版标记全部失效。
    //    详见 docs/market-enhancer-research-2026-11.md。

    // ------------------------------------------------------------------
    // ① 货币映射（单一事实源）
    // ------------------------------------------------------------------
    // 依据：Steamworks 官方文档「Supported Currencies → Appendix A: ECurrency Values」
    //       https://partner.steamgames.com/doc/store/pricing/currencies
    // 取舍：仓库旧版把 8 漏掉（→回退 USD）、把 38/39/41 写错（UYU/CZK/QAR）、
    //       把 43 写成 JPY（官方 43 是已废弃的 HRK）。本表按官方逐条对齐。
    // legacy=true = 官方已划删除线（不再支持），仅为历史数据保留映射。
    const SME_CURRENCY_ECODE = Object.freeze({
        1: 'USD', 2: 'GBP', 3: 'EUR', 4: 'CHF', 5: 'RUB', 6: 'PLN', 7: 'BRL',
        8: 'JPY', 9: 'NOK', 10: 'IDR', 11: 'MYR', 12: 'PHP', 13: 'SGD',
        14: 'THB', 15: 'VND', 16: 'KRW', 17: 'TRY', 18: 'UAH', 19: 'MXN',
        20: 'CAD', 21: 'AUD', 22: 'NZD', 23: 'CNY', 24: 'INR', 25: 'CLP',
        26: 'PEN', 27: 'COP', 28: 'ZAR', 29: 'HKD', 30: 'TWD', 31: 'SAR',
        32: 'AED', 33: 'SEK', 34: 'ARS', 35: 'ILS', 36: 'BYN', 37: 'KZT',
        38: 'KWD', 39: 'QAR', 40: 'CRC', 41: 'UYU', 42: 'BGN', 43: 'HRK',
        44: 'CZK', 45: 'DKK', 46: 'HUF', 47: 'RON',
    });

    // 币种显示符号（Steam 社区通行写法；与 AugmentedSteam 的 steamCurrencies 对齐）
    const SME_CURRENCY_SYMBOL = Object.freeze({
        USD: { prefix: '$', suffix: '' },        GBP: { prefix: '£', suffix: '' },
        EUR: { prefix: '€', suffix: '' },        CHF: { prefix: 'CHF ', suffix: '' },
        RUB: { prefix: 'RUB ', suffix: '' },      PLN: { prefix: 'zł ', suffix: '' },
        BRL: { prefix: 'R$', suffix: '' },       JPY: { prefix: '¥', suffix: '' },
        NOK: { prefix: 'kr ', suffix: '' },      IDR: { prefix: 'Rp', suffix: '' },
        MYR: { prefix: 'RM', suffix: '' },       PHP: { prefix: '₱', suffix: '' },
        SGD: { prefix: 'S$', suffix: '' },       THB: { prefix: '฿', suffix: '' },
        VND: { prefix: '₫', suffix: '' },        KRW: { prefix: '₩', suffix: '' },
        TRY: { prefix: 'TL ', suffix: '' },      UAH: { prefix: '₴', suffix: '' },
        MXN: { prefix: 'Mex$ ', suffix: '' },    CAD: { prefix: 'CDN$ ', suffix: '' },
        AUD: { prefix: 'A$ ', suffix: '' },      NZD: { prefix: 'NZ$ ', suffix: '' },
        CNY: { prefix: '¥', suffix: '' },        INR: { prefix: '₹', suffix: '' },
        CLP: { prefix: 'CLP$ ', suffix: '' },    PEN: { prefix: 'S/ ', suffix: '' },
        COP: { prefix: 'COL$ ', suffix: '' },    ZAR: { prefix: 'R ', suffix: '' },
        HKD: { prefix: 'HK$', suffix: '' },      TWD: { prefix: 'NT$', suffix: '' },
        SAR: { prefix: 'SR ', suffix: '' },      AED: { prefix: 'AED ', suffix: '' },
        ARS: { prefix: 'ARS$ ', suffix: '' },    ILS: { prefix: '₪', suffix: '' },
        BYN: { prefix: 'Br', suffix: '' },       KZT: { prefix: '₸', suffix: '' },
        KWD: { prefix: 'KD ', suffix: '' },      QAR: { prefix: 'QR ', suffix: '' },
        CRC: { prefix: '₡', suffix: '' },        UYU: { prefix: '$U ', suffix: '' },
        BGN: { prefix: 'лв', suffix: '' },       HRK: { prefix: 'kn', suffix: '' },
        CZK: { prefix: 'Kč', suffix: '' },       DKK: { prefix: 'kr ', suffix: '' },
        HUF: { prefix: 'Ft ', suffix: '' },      RON: { prefix: 'lei ', suffix: '' },
        SEK: { prefix: 'kr ', suffix: '' },
    });

    /**
     * 手续费取整需要「向上进位到最小货币单位」的币种。
     * 2025-12 Steam 市场规则变更后，这些币种的手续费不再一律舍去，而是进位。
     * 依据：Steamworks 官方「must be charged in increments of N」的币种集合
     *      （CLP/COP/IDR/INR/JPY/KRW/KZT/TWD/UYU/CRC/VND）∪ UAH（历史口径保留）。
     * 可在设置面板里覆写，避免官方再调整时必须改代码。
     */
    const SME_FEE_ROUND_DEFAULT = [
        'JPY', 'IDR', 'UAH', 'CLP', 'COP', 'TWD', 'KZT', 'CRC', 'UYU', 'KRW', 'VND', 'INR',
    ];

    /** Steam 货币 ID → ISO 4217 代码（未知 ID 回退 USD） */
    function smeCurrencyCode(id) {
        const n = parseInt(id, 10);
        if (!isFinite(n)) return 'USD';
        return SME_CURRENCY_ECODE[n] || 'USD';
    }

    /** ISO 4217 代码 → {prefix, suffix}（未知代码回退 $） */
    function smeCurrencySymbolByCode(code) {
        return SME_CURRENCY_SYMBOL[code] || { prefix: '$', suffix: '' };
    }

    /** Steam 货币 ID → {prefix, suffix} */
    function smeCurrencySymbol(id) {
        return smeCurrencySymbolByCode(smeCurrencyCode(id));
    }

    /** 该币种的手续费是否需要进位取整 */
    function smeFeeUsesRound(code, overrideList) {
        const list = (overrideList && overrideList.length) ? overrideList : SME_FEE_ROUND_DEFAULT;
        return list.indexOf(code) !== -1;
    }

    /**
     * 自检：映射表内部一致性。供静态守卫测试调用（test/test-currency-map.js）。
     * 返回问题列表，空数组 = 通过。
     */
    function smeCurrencySelfCheck() {
        const issues = [];
        for (const id of Object.keys(SME_CURRENCY_ECODE)) {
            const code = SME_CURRENCY_ECODE[id];
            if (!SME_CURRENCY_SYMBOL[code]) issues.push('ID ' + id + ' (' + code + ') 缺符号');
        }
        for (const code of Object.keys(SME_CURRENCY_SYMBOL)) {
            let found = false;
            for (const id of Object.keys(SME_CURRENCY_ECODE)) {
                if (SME_CURRENCY_ECODE[id] === code) { found = true; break; }
            }
            if (!found) issues.push('符号 ' + code + ' 没有对应的 ID');
        }
        // 关键锚点：防止再次写错（实测 2026-11：HK 地区 eCurrency=29 → HKD，23 → CNY）
        const anchors = { 8: 'JPY', 23: 'CNY', 29: 'HKD', 38: 'KWD', 39: 'QAR', 41: 'UYU', 43: 'HRK' };
        for (const id of Object.keys(anchors)) {
            if (SME_CURRENCY_ECODE[id] !== anchors[id]) {
                issues.push('ID ' + id + ' 应为 ' + anchors[id] + '，实际 ' + SME_CURRENCY_ECODE[id]);
            }
        }
        return issues;
    }

    // ------------------------------------------------------------------
    // ② Steam 新版 React SSR（valve-ssr-data）解析
    // ------------------------------------------------------------------
    // 实测（2026-11-01，市场物品页 4.33MB）：
    //   <script id="valve-ssr-data">{JSON}</script>  ← 数据容器
    //   页面内联脚本读它后 e.remove()，再赋值
    //   window.SSR = {loaderData, clientAssets, renderContext}
    //   ⚠️ 旧标记 window.SSR.renderContext=JSON.parse("...) 已彻底消失。
    //   renderContext.queryData 仍是**嵌套 JSON 字符串**，需二次 parse。

    /** 从 HTML 文本中解析 valve-ssr-data → {loaderData, renderContext, config, userConfig} */
    function smeParseValveSsr(html) {
        if (!html || typeof html !== 'string') return null;
        const m = html.match(/<script[^>]*id=["']valve-ssr-data["'][^>]*>([\s\S]*?)<\/script>/i);
        if (!m) return null;
        let data;
        try { data = JSON.parse(m[1]); }
        catch (e) { return null; }
        if (!data || typeof data !== 'object') return null;
        return {
            loaderData: data.loaderData || null,
            renderContext: data.renderContext || null,
            clientAssets: data.clientAssets || null,
            config: data.Config || null,
            userConfig: data.UserConfig || null,
        };
    }

    /** 归一化 React Query dehydrated state → [{key, data}]（queryData 是嵌套 JSON 字符串） */
    function smeSsrQueries(ssr) {
        const out = [];
        if (!ssr) return out;
        let rc = ssr.renderContext;
        if (typeof rc === 'string') { try { rc = JSON.parse(rc); } catch (e) { rc = null; } }
        if (!rc || typeof rc !== 'object') return out;
        let qd = rc.queryData;
        if (typeof qd === 'string') { try { qd = JSON.parse(qd); } catch (e) { qd = null; } }
        if (!qd || !Array.isArray(qd.queries)) return out;
        for (const q of qd.queries) {
            if (!q || !Array.isArray(q.queryKey)) continue;
            out.push({ key: q.queryKey, data: q.state ? q.state.data : null });
        }
        return out;
    }

    /**
     * 按 queryKey 前缀查找。
     * @param {Array} queries smeSsrQueries 的结果
     * @param {Array} prefix 需匹配的前缀片段，如 ['market','orderbook']
     * @param {string} [tail] 需完全相等的**末位**元素。
     *        市场类 queryKey 形如 ['market','pricehistory',730,'<变体名>']，
     *        变体名在**最后一位**（不是 prefix.length 位）——故按末位比对。
     */
    function smeSsrFindQuery(queries, prefix, tail) {
        for (const q of queries) {
            const k = q.key;
            if (k.length < prefix.length) continue;
            let ok = true;
            for (let i = 0; i < prefix.length; i++) {
                if (String(k[i]) !== String(prefix[i])) { ok = false; break; }
            }
            if (!ok) continue;
            if (tail !== undefined && String(k[k.length - 1]) !== String(tail)) continue;
            return q;
        }
        return null;
    }

    /**
     * 解析同款家族聚合页的变体清单。
     * loaderData[3].buckets[] = {bucket_id: <market_hash_name>, classid}
     * @returns {Array<{name:string, classid:string}>}
     */
    function smeSsrVariants(ssr) {
        const out = [];
        if (!ssr) return out;
        const ld = ssr.loaderData;
        const entries = Array.isArray(ld) ? ld : (ld && typeof ld === 'object' ? Object.values(ld) : []);
        for (const entry of entries) {
            let d = entry;
            if (typeof d === 'string') { try { d = JSON.parse(d); } catch (e) { continue; } }
            if (!d || !Array.isArray(d.buckets)) continue;
            for (const b of d.buckets) {
                if (!b) continue;
                const name = b.bucket_id || b.market_hash_name || b.name;
                if (!name) continue;
                if (out.some(v => v.name === name)) continue;
                out.push({ name: String(name), classid: b.classid != null ? String(b.classid) : '' });
            }
        }
        return out;
    }

    /** 焦点变体：initialSelectedBucketID → initialFallbackBucketID → buckets[0] */
    function smeSsrFocusVariant(ssr) {
        if (!ssr) return null;
        const ld = ssr.loaderData;
        const entries = Array.isArray(ld) ? ld : (ld && typeof ld === 'object' ? Object.values(ld) : []);
        for (const entry of entries) {
            let d = entry;
            if (typeof d === 'string') { try { d = JSON.parse(d); } catch (e) { continue; } }
            if (!d || !Array.isArray(d.buckets) || !d.buckets.length) continue;
            const byId = (id) => d.buckets.find(b => b && String(b.bucket_id) === String(id));
            const b = (d.initialSelectedBucketID != null && byId(d.initialSelectedBucketID))
                || (d.initialFallbackBucketID != null && byId(d.initialFallbackBucketID))
                || d.buckets[0];
            if (b && b.bucket_id) return String(b.bucket_id);
        }
        return null;
    }

    /**
     * 从 SSR 取订单簿（**变体感知**）。
     *
     * ★ v2.0.0 修复的静默 bug：同款家族聚合页一次 SSR 里混着多个变体的数据 ——
     *   market/orderbook 对应 initialFallbackBucketID（实测 Minimal Wear），
     *   market_item_search 的 listings 对应 buckets[0]（实测 Battle-Scarred），
     *   而 URL 可能 302 自第三个变体（实测 Field-Tested）。
     *   旧实现盲取第一个 rgCompactSellOrders → 会把**别的变体的盘**当成当前变体展示，
     *   导致超价/低价检测与定价建议全部失真。
     * 现在：返回盘所属变体名 + 是否与目标一致，由调用方决定提示还是切变体。
     *
     * @param {object} ssr smeParseValveSsr 的结果
     * @param {string} [targetName] 目标变体 market_hash_name（用于比对）
     * @returns {object|null} {sellLevels, buyLevels, highestBuyCents, lowestSellCents, currency, variantName, matched}
     */
    function smeSsrOrderBook(ssr, targetName) {
        const queries = smeSsrQueries(ssr);
        const q = smeSsrFindQuery(queries, ['market', 'orderbook']);
        if (!q || !q.data) return null;
        const raw = q.data;
        const sellLevels = smeCompactToLevels(raw.rgCompactSellOrders);
        const buyLevels = smeCompactToLevels(raw.rgCompactBuyOrders);
        if (!sellLevels.length && !buyLevels.length && raw.amtMaxBuyOrder == null && raw.amtMinSellOrder == null) {
            return null;
        }
        // queryKey 第 4 位就是该盘所属的变体名
        const variantName = q.key.length > 3 ? String(q.key[3]) : '';
        const matched = !targetName || !variantName || variantName === String(targetName);
        return {
            sellLevels: sellLevels,
            buyLevels: buyLevels,
            highestBuyCents: raw.amtMaxBuyOrder != null ? parseInt(raw.amtMaxBuyOrder, 10) : null,
            lowestSellCents: raw.amtMinSellOrder != null ? parseInt(raw.amtMinSellOrder, 10) : null,
            currency: raw.eCurrency != null ? parseInt(raw.eCurrency, 10) : null,
            buyOrderCount: raw.cBuyOrders != null ? parseInt(raw.cBuyOrders, 10) : null,
            sellOrderCount: raw.cSellOrders != null ? parseInt(raw.cSellOrders, 10) : null,
            variantName: variantName,
            matched: matched,
        };
    }

    /** 压缩数组 [price, qty, price, qty, ...] → [{cents, qty}] */
    function smeCompactToLevels(arr) {
        const out = [];
        if (!Array.isArray(arr)) return out;
        for (let i = 0; i + 1 < arr.length; i += 2) {
            const cents = parseInt(arr[i], 10);
            const qty = parseInt(arr[i + 1], 10);
            if (isFinite(cents) && cents > 0 && qty > 0) out.push({ cents: cents, qty: qty });
        }
        return out;
    }

    /**
     * 从 SSR 取价格历史（新版格式：{time, price_median, purchases}）。
     * 比旧版 API 的 [[date, price, vol]] 多一个**中位价**口径 —— 中位价比裸成交均价
     * 更能代表「市场真实价」，抗单笔异常成交。
     * @returns {{prices:Array<{t:number, medianCents:number, vol:number}>, ecurrency:number}|null}
     */
    function smeSsrPriceHistory(ssr, name) {
        const queries = smeSsrQueries(ssr);
        const q = smeSsrFindQuery(queries, ['market', 'pricehistory'], name !== undefined ? String(name) : undefined);
        if (!q || !q.data) return null;
        const rows = q.data.prices;
        if (!Array.isArray(rows) || !rows.length) return null;
        const prices = [];
        for (const r of rows) {
            if (!r) continue;
            const t = typeof r.time === 'number' ? r.time : parseInt(r.time, 10);
            if (!isFinite(t)) continue;
            const median = typeof r.price_median === 'number' ? r.price_median : parseFloat(r.price_median);
            if (!isFinite(median)) continue;
            const vol = parseInt(r.purchases, 10) || 0;
            // price_median 是**货币单位**（如 194.03）。
            // p = 单位金额（与旧版 pricehistory API 的 prices[1] 同口径，消费方无需改）
            // medianCents = 同一价格的分值（明确口径，避免各处再乘/除 100 出错）
            prices.push({ t: t * 1000, p: median, medianCents: Math.round(median * 100), vol: vol, v: vol });
        }
        if (!prices.length) return null;
        return {
            prices: prices,
            ecurrency: q.data.ecurrency != null ? parseInt(q.data.ecurrency, 10) : null,
        };
    }

    /**
     * 从 SSR 取挂单列表（market_item_search）。
     * @returns {{start:number, total:number, listings:Array<{id,cents,bMine,classid,strSubtotal,eCurrency,publisherFeePct}}}|null}
     */
    function smeSsrListings(ssr) {
        const queries = smeSsrQueries(ssr);
        const q = smeSsrFindQuery(queries, ['market_item_search']);
        if (!q || !q.data || !Array.isArray(q.data.pages) || !q.data.pages.length) return null;
        const page = q.data.pages[q.data.pages.length - 1];
        const listings = [];
        for (const l of (page.listings || [])) {
            if (!l) continue;
            listings.push({
                id: String(l.listingid || ''),
                cents: parseInt(l.unPrice, 10) || 0,
                feeCents: parseInt(l.unFee, 10) || 0,
                strSubtotal: l.strSubtotal || '',
                bMine: l.bMine === true,
                eCurrency: l.eCurrency != null ? parseInt(l.eCurrency, 10) : null,
                publisherFeePct: typeof l.publisherFeePct === 'number' ? l.publisherFeePct : null,
                classid: l.description && l.description.classid != null ? String(l.description.classid) : '',
            });
        }
        return {
            start: page.start || 0,
            total: page.total_count || 0,
            more: page.more === true,
            listings: listings,
        };
    }

    /**
     * 从 SSR 取钱包上下文（新版页不再有 g_rgWalletInfo / v_currencyformat）。
     * @returns {{currency:number|null, country:string, language:string, publisherFeePct:number|null}}
     */
    function smeSsrWallet(ssr) {
        const out = { currency: null, country: '', language: '', publisherFeePct: null };
        if (!ssr) return out;
        if (ssr.config) {
            out.country = ssr.config.COUNTRY || '';
            out.language = ssr.config.LANGUAGE || '';
        }
        const queries = smeSsrQueries(ssr);
        // 币种：优先 orderbook.eCurrency，其次 market/description.currency
        const ob = smeSsrFindQuery(queries, ['market', 'orderbook']);
        if (ob && ob.data && ob.data.eCurrency != null) out.currency = parseInt(ob.data.eCurrency, 10);
        if (out.currency == null) {
            const desc = queries.find(q => q.key[0] === 'market' && q.key[1] === 'description' && q.data);
            if (desc && desc.data && desc.data.currency != null) {
                // description.currency 是布尔（false = 非特殊货币），不能用；改用 orderbook
                // 拿不到时退化为从 listings 的 eCurrency 取
            }
        }
        if (out.currency == null) {
            const ls = smeSsrFindQuery(queries, ['market_item_search']);
            if (ls && ls.data && Array.isArray(ls.data.pages) && ls.data.pages.length) {
                const l0 = (ls.data.pages[ls.data.pages.length - 1].listings || [])[0];
                if (l0 && l0.eCurrency != null) out.currency = parseInt(l0.eCurrency, 10);
            }
        }
        // 发行商费率（按游戏）：listings[].publisherFeePct（实测 0.10）
        const ls2 = smeSsrFindQuery(queries, ['market_item_search']);
        if (ls2 && ls2.data && Array.isArray(ls2.data.pages) && ls2.data.pages.length) {
            const l0 = (ls2.data.pages[ls2.data.pages.length - 1].listings || [])[0];
            if (l0 && typeof l0.publisherFeePct === 'number') out.publisherFeePct = l0.publisherFeePct;
        }
        return out;
    }

    // ------------------------------------------------------------------
    // ③ 纯计算：定价策略 / 价格提醒 / 库存浮盈 / 交易冷却
    // ------------------------------------------------------------------

    /**
     * 窗口中位价（v2.0.0）：给「近 N 日中位价」定价口径用。
     * 兼容两种历史数据结构：
     *   · 新版 SSR：{t, medianCents, vol}   —— 每日中位价（已是分）
     *   · 旧版 API：{t, p, v}               —— 逐笔成交价（p 是**货币单位**）
     * @param {object} priceHistory {prices:[...]}
     * @param {number} days 窗口天数
     * @returns {number} 分；无数据返回 0
     */
    function calcWindowMedianCents(priceHistory, days) {
        if (!priceHistory || !Array.isArray(priceHistory.prices) || !priceHistory.prices.length) return 0;
        const win = (days && days > 0) ? days : 30;
        const cutoff = Date.now() - win * 86400000;
        const vals = [];
        for (const p of priceHistory.prices) {
            if (!p || !(p.t >= 0)) continue;
            if (p.t < cutoff) continue;
            let cents = 0;
            if (p.medianCents != null) cents = p.medianCents;
            else if (p.p != null) cents = Math.round(p.p * 100);
            if (cents > 0) vals.push(cents);
        }
        if (!vals.length) return 0;
        vals.sort((a, b) => a - b);
        const mid = Math.floor(vals.length / 2);
        return vals.length % 2 ? vals[mid] : Math.round((vals[mid - 1] + vals[mid]) / 2);
    }

    /**
     * 批量定价策略（v2.0.0 新增）。
     * 社区「一键挂卡」标准流程的三种口径：
     *   undercut  最低卖价 - N 分（抢单）
     *   median    近 N 日中位价（按市场真实价）
     *   ratio     跨平台目标价（挂刀比价）
     * @param {object} opt {lowestSellCents, medianCents, targetCents, offsetCents}
     * @returns {{cents:number, source:string}|null}
     */
    function smeStrategyPrice(opt) {
        if (!opt) return null;
        const mode = opt.mode || 'undercut';
        const offset = opt.offsetCents || 0;
        if (mode === 'median') {
            if (!opt.medianCents) return null;
            return { cents: Math.max(0, opt.medianCents + offset), source: 'median' };
        }
        if (mode === 'ratio') {
            if (!opt.targetCents) return null;
            return { cents: Math.max(0, opt.targetCents + offset), source: 'ratio' };
        }
        if (!opt.lowestSellCents) return null;
        return { cents: Math.max(0, opt.lowestSellCents - 1 + offset), source: 'undercut' };
    }

    /**
     * 挂刀目标价（v2.0.0 新增，纯计算）：
     * 平台最低价（CNY 分）× 平台费系数 → 平台到手 → 换算成本地货币的**等效 Steam 售价**。
     * 语义：把挂单价压到这个数，在 Steam 卖 ≈ 在那个平台卖。
     * @param {number} platformLowCnyCents 平台最低卖价（CNY 分）
     * @param {number} feeFactor 平台费系数（0~1）
     * @param {number} cnyToLocal CNY→本地货币汇率（1 = 同币种）
     * @returns {number} 本地货币分；无法换算返回 0
     */
    function smeRatioTargetCents(platformLowCnyCents, feeFactor, cnyToLocal) {
        if (!(platformLowCnyCents > 0)) return 0;
        const fee = (feeFactor > 0 && feeFactor <= 1) ? feeFactor : 0.85;
        const netCny = Math.round(platformLowCnyCents * fee);
        if (!(netCny > 0)) return 0;
        if (!(cnyToLocal > 0)) return 0;
        return Math.round(netCny * cnyToLocal);
    }

    /**
     * 价格提醒判定（v2.0.0 新增）。
     * 阈值语义：现价 ≤ 基准价 × (1 - dropPct) 即触发。
     * 基准默认取 30 日中位价（抗单笔异常）。
     * @param {object} o {currentCents, baseCents, dropPct, lastNotifiedCents}
     * @returns {{hit:boolean, drop:number, reason:string}}
     */
    function smeAlertCheck(o) {
        if (!o || !o.currentCents || !o.baseCents) return { hit: false, drop: 0, reason: 'no-data' };
        const dropPct = o.dropPct != null ? o.dropPct : 0.1;
        const threshold = o.baseCents * (1 - dropPct);
        const drop = (o.baseCents - o.currentCents) / o.baseCents;
        if (o.currentCents > threshold) return { hit: false, drop: drop, reason: 'above' };
        // 幂等：同一价位只通知一次（避免每轮轮询重复推送）
        if (o.lastNotifiedCents != null && o.currentCents >= o.lastNotifiedCents) {
            return { hit: false, drop: drop, reason: 'already' };
        }
        return { hit: true, drop: drop, reason: 'triggered' };
    }

    /**
     * 成本基准引擎（FIFO，v2.0.0 新增）。
     *
     * 口径纪律（错一条整张表就歪）：
     *   · **成本基准用「卖家到手价」**，不是买家支付价。
     *     成交记录里的 priceCents 是买家支付价（含手续费）；拿它当成本，
     *     会让「买入即亏手续费」，成本虚高、浮亏虚高。netOf 负责换算。
     *   · **卖出按 FIFO 消耗买入批次** → 已实现盈亏才有正确配比。
     *   · **卖出找不到对应买入记录**（买入发生在历史窗口之外）→
     *     单独记 unknownCost 计数，**不猜成本**，UI 如实标注「成本未知」。
     *
     * @param {Array} rows 成交记录 [{name, action:'bought'|'sold', priceCents, tradeTs, game}]
     * @param {object} [opts] {netOf: (priceCents)=>到手分}
     * @returns {{holdings:Array, realized:Map, unmatchedSales:number}}
     */
    function smeCostBasis(rows, opts) {
        const o = opts || {};
        const netOf = typeof o.netOf === 'function'
            ? o.netOf
            : (c) => Math.round(c / 1.15);   // 默认：Steam 5% + 发行商 10%
        const list = (Array.isArray(rows) ? rows.slice() : []);
        // 按时间升序；无时间的排到最后（不参与 FIFO 顺序推断）
        list.sort((a, b) => (a.tradeTs || a.listedTs || 0) - (b.tradeTs || b.listedTs || 0));

        const lots = new Map();       // name → [{qty, costCents, ts}]
        const realized = new Map();   // name → {qty, proceedsCents, costCents, unknownCost}
        let unmatchedSales = 0;

        for (const r of list) {
            const name = String(r.name || '');
            if (!name) continue;
            const ts = r.tradeTs || r.listedTs || 0;
            if (r.action === 'bought') {
                if (!lots.has(name)) lots.set(name, []);
                lots.get(name).push({ qty: 1, costCents: netOf(r.priceCents || 0), ts: ts });
            } else if (r.action === 'sold') {
                const arr = lots.get(name);
                if (!arr || !arr.length) {
                    // 买入发生在索引窗口之外 → 成本未知，不猜
                    if (!realized.has(name)) realized.set(name, { qty: 0, proceedsCents: 0, costCents: 0, unknownCost: 0 });
                    const rec = realized.get(name);
                    rec.qty++; rec.proceedsCents += netOf(r.priceCents || 0); rec.unknownCost++;
                    unmatchedSales++;
                    continue;
                }
                const lot = arr.shift();
                if (!realized.has(name)) realized.set(name, { qty: 0, proceedsCents: 0, costCents: 0, unknownCost: 0 });
                const rec = realized.get(name);
                rec.qty++;
                rec.proceedsCents += netOf(r.priceCents || 0);
                rec.costCents += lot.costCents;
            }
        }

        const holdings = [];
        for (const [name, arr] of lots) {
            let qty = 0, totalCost = 0, oldestTs = 0, newestTs = 0;
            for (const l of arr) {
                qty += l.qty;
                totalCost += l.costCents;
                if (l.ts) {
                    if (!oldestTs || l.ts < oldestTs) oldestTs = l.ts;
                    if (l.ts > newestTs) newestTs = l.ts;
                }
            }
            if (!qty) continue;
            holdings.push({
                name: name,
                qty: qty,
                costCents: qty ? Math.round(totalCost / qty) : 0,   // 单位成本（分），与 smePnlCalc 同口径
                costTotalCents: totalCost,
                oldestTs: oldestTs,
                newestTs: newestTs,
                lots: arr.map(l => ({ qty: l.qty, costCents: l.costCents, ts: l.ts })),
            });
        }
        holdings.sort((a, b) => (b.costTotalCents - a.costTotalCents));
        return { holdings: holdings, realized: realized, unmatchedSales: unmatchedSales };
    }

    /**
     * 交易冷却清单（v2.0.0 新增）。
     *
     * 规则依据：
     *   · 2024-10-02 起：市场/军械库/交易报价/游戏内商店获得的物品，7 天内不可再交易/上架
     *     → 冷却天数取自 Steam 自己给的 descriptions[].market_marketable_restriction
     *       （Valve 游戏为 7）与 market_tradable_restriction。
     *   · 2025-07-16 起：CS2 交易所得物品有 7 天 Trade Protection（可被撤销）。
     *
     * 获得时间来自成交记录（市场买入）。**交易/赠送所得的物品没有买入记录 →
     * 起始时间未知**，此时只标「锁定中·来源未知」，不编造解锁日期。
     *
     * @param {Array} holdings smeCostBasis().holdings
     * @param {Object} restrictionDays {name: {marketableDays, tradableDays}}
     * @param {number} now 当前时间戳
     * @returns {Array} 冷却中的持仓 [{name, qty, days, daysLeft, untilTs, earliestUntilTs, source}]
     */
    function smeCooldownList(holdings, restrictionDays, now) {
        const out = [];
        const list = Array.isArray(holdings) ? holdings : [];
        for (const hold of list) {
            const rule = restrictionDays && restrictionDays[hold.name];
            if (!rule) continue;
            const days = parseInt(rule.marketableDays != null ? rule.marketableDays : rule.tradableDays, 10) || 0;
            if (days <= 0) continue;
            if (!hold.newestTs) {
                // 获得时间未知：无法算解锁日
                out.push({
                    name: hold.name, qty: hold.qty, days: days, daysLeft: null,
                    untilTs: 0, earliestUntilTs: 0, source: 'unknown',
                });
                continue;
            }
            const untilTs = hold.newestTs + days * 86400000;
            const earliestUntilTs = (hold.oldestTs || hold.newestTs) + days * 86400000;
            const daysLeft = now >= untilTs ? 0 : Math.ceil((untilTs - now) / 86400000);
            if (daysLeft <= 0) continue;
            out.push({
                name: hold.name, qty: hold.qty, days: days, daysLeft: daysLeft,
                untilTs: untilTs, earliestUntilTs: earliestUntilTs, source: 'market-buy',
            });
        }
        out.sort((a, b) => (b.daysLeft || 999) - (a.daysLeft || 999));
        return out;
    }

    /**
     * 库存浮盈浮亏（v2.0.0 新增）。
     * 成本基准 = 成交记录里的**买入均价**（按 market_hash_name 聚合）。
     * @param {Array} holdings [{name, qty, costCents}]
     * @param {Object} priceMap {name: currentCents}
     * @returns {{rows:Array, totalCost:number, totalValue:number, totalPnl:number, priced:number, total:number}}
     */
    function smePnlCalc(holdings, priceMap) {
        const rows = [];
        let totalCost = 0, totalValue = 0, priced = 0;
        const list = Array.isArray(holdings) ? holdings : [];
        for (const h of list) {
            if (!h || !h.name) continue;
            const qty = h.qty || 0;
            const costCents = h.costCents || 0;
            const cur = priceMap && priceMap[h.name] != null ? priceMap[h.name] : null;
            const cost = costCents * qty;
            const value = cur != null ? cur * qty : null;
            totalCost += cost;
            if (value != null) { totalValue += value; priced++; }
            rows.push({
                name: h.name,
                qty: qty,
                costCents: costCents,
                currentCents: cur,
                pnlCents: value != null ? value - cost : null,
                pnlPct: (value != null && cost > 0) ? (value - cost) / cost : null,
            });
        }
        return {
            rows: rows,
            totalCost: totalCost,
            totalValue: totalValue,
            totalPnl: totalValue - totalCost,
            priced: priced,
            total: list.length,
        };
    }

    /**
     * 交易冷却 / 锁定判定（v2.0.0 新增）。
     * 2024-10-02 起：市场/军械库/交易获得的物品 7 天内不可再上架。
     * 2025-07-16 起：CS2 交易所得物品 7 天 Trade Protection（可被撤销，撤销者禁交易+市场 30 天）。
     * @param {number} acquiredAt 获得时间戳（毫秒）；未知传 0
     * @param {number} now 当前时间戳
     * @param {number} [cooldownDays] 冷却天数，默认 7
     * @returns {{locked:boolean, until:number, daysLeft:number}}
     */
    function smeCooldownCalc(acquiredAt, now, cooldownDays) {
        const days = cooldownDays != null ? cooldownDays : 7;
        if (!acquiredAt || !now) return { locked: false, until: 0, daysLeft: 0 };
        const until = acquiredAt + days * 86400000;
        if (now >= until) return { locked: false, until: until, daysLeft: 0 };
        return {
            locked: true,
            until: until,
            daysLeft: Math.ceil((until - now) / 86400000),
        };
    }

    // ==================== v2.0.0 纯计算层结束 ====================

    // ==================== 启动（等待 URL 稳定） ====================
    let stableSince = 0;
    let lastCheck = location.href;
    let domReady = false;

    function isOnMarket() {
        return /^\/market(?:\/|$)/.test(location.pathname)
            || /^\/(?:id|profiles)\/[^/]+\/inventory/.test(location.pathname)
            || /^\/tradeoffer/.test(location.pathname)
            || /^\/tradingcards\/boostercreator/.test(location.pathname);
    }

    function tryStart() {
        if (!domReady) return;
        const now = Date.now();
        const curURL = location.href;
        if (curURL !== lastCheck) {
            lastCheck = curURL;
            stableSince = now;
            return;
        }
        if (now - stableSince < 800) return;
        if (!isOnMarket()) return;
        clearInterval(stableTimer);
        init();
    }

    let stableTimer;
    function onDOMReady() {
        domReady = true;
        stableSince = Date.now();
        lastCheck = location.href;
        stableTimer = setInterval(tryStart, 250);
        setTimeout(() => {
            if (domReady && isOnMarket() && !initialized) {
                clearInterval(stableTimer);
                init().catch(e => W('初始化失败:', e && e.message));
            }
        }, 2000);
    }

    // v1.5.0：显示更多价格——必须在 document-start、页面 react-dom 初始化前注入假 DevTools hook，
    // 因此这里随脚本执行同步调用（不能放进 init：init 要等 DOM ready，届时 react-dom 早已初始化）
    if (settings.get('showMorePrices') && /^\/market\/listings\/\d+\/.+/.test(location.pathname)) {
        installShowMoreHook();
    }

    if (document.readyState === 'interactive' || document.readyState === 'complete') {
        onDOMReady();
    } else {
        document.addEventListener('DOMContentLoaded', onDOMReady);
    }

})();