// ==UserScript==
// @name         Steamdb 增强
// @namespace    https://steamdb.info/
// @version      1.0.8
// @description  免费包列表排序（添加顺序跟随）+ 添加队列预览（全部已添加保留 + 待添加分页，可隐藏官方日志）
// @author       SmallFork
// @license      MIT
// @match        https://steamdb.info/freepackages/*
// @match        https://steamdb.info/freepackages
// @icon         data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><rect x='3' y='3' width='94' height='94' rx='20' fill='%23171a21' stroke='%2366c0f4' stroke-width='2'/><polygon points='27,20 14,42 22,42 22,72 32,72 32,42 40,42' fill='%232ed573'/><rect x='50' y='28' width='14' height='7' rx='3' fill='%2366c0f4' opacity='0.35'/><rect x='50' y='44' width='28' height='7' rx='3' fill='%2366c0f4' opacity='0.65'/><rect x='50' y='60' width='42' height='7' rx='3' fill='%2366c0f4'/></svg>
// @grant        none
// @run-at       document-start
// @tag          Steam
// ==/UserScript==

(function () {
    'use strict';

    /* ---------- 激活间隔：不注入 URL，仅报告 ----------
     * 间隔由站点原生机制决定：默认 180s，URL 手动加 ?delay=秒数 可指定（站点 freepackages.js
     * 与本脚本 rateDelayMs() 同源读取，想改间隔改 URL 即可，脚本全部倒计时自动跟随）。
     * 已带 country 参数时合并写：?country=IN&delay=120
     * 本脚本 @run-at document-start 只在控制台打印当前生效的间隔秒数。 */
    try {
        const d = parseInt(new URLSearchParams(location.search).get('delay'), 10);
        const sec = isNaN(d) || d < 10 ? 180 : d;
        console.log(`[SFP] 当前激活间隔：${sec} 秒`);
    } catch (e) { /* URL 不可读时跳过报告，站点仍按默认 180s */ }

    const PANEL_ID = 'freepackages';
    const TOOLBAR_ID = 'sfd-fp-sort-toolbar';

    /* ============ 排序模块 ============ */

    let currentSort = null;
    let isSorting = false;
    let observer = null;
    let debounceTimer = null;
    let nextOrigIdx = 0;

    // 元素 → 首次出现时的 DOM 序号（用于"原始"恢复）
    const origIdx = new WeakMap();

    // toggle 型排序按钮：模式 → 倒序模式（点击循环 正序↔倒序，按钮文案带 ↑/↓）
    const TOGGLE_SORTS = { 'name-asc': 'name-desc', 'len-asc': 'len-desc' };

    /* 添加监视状态（排序函数需检查添加是否进行中） */
    const ACT = {
        queue: [],          // [{subid, name}] 点击添加时的队列快照
        idxOf: new Map(),   // subid → 索引
        status: new Map(),  // subid → {ok, text}
        ignored: new Set(), // 本轮经预览 [Ignore] 标记的 subid（跨 pvRender 保持按钮状态）
        current: -1,        // 正在添加的索引
        done: 0,            // 已处理数（重试不重复计数）
        okCount: 0,         // 成功数（分层标题用）
        errCount: 0,        // 失败数
        lastSub: 0,
        rateUntil: 0,       // 限制恢复时间戳（进度条用）
        rateStart: 0,       // 限制触发时间戳（进度条总时长）
        rateSub: 0,         // 触发限制的 subid（进度条只挂在该行）
        realTotal: 0,       // 站点添加队列真实长度（#js-activate-count）
        started: false,
        finished: false,
        limited: false,     // 未点击 view all（快照只是队列前缀，添加时实时补充）
        pendPage: 1,        // 待添加分页：当前页（1 起，相对待添加区首条）
        pendManual: false,  // 待添加：用户手动翻页后暂停自动跟随（« 回第 1 页恢复）
        donePage: 1,        // 已成功分页：当前页
        doneManual: false,  // 已成功：手动翻页后停在某页（» 跟到最新页恢复）
        els: {},            // 预览骨架元素引用
        preview: null, progEl: null, segEl: null, hideEl: null,
    };

    function rememberElements(packages) {
        for (const pkg of packages) {
            if (!origIdx.has(pkg)) origIdx.set(pkg, nextOrigIdx++);
        }
    }

    /** 节点内容不可变（移动节点不改变内容），直接从 DOM 解析排序键 */
    function parsePackage(el) {
        const a = el.getElementsByTagName('a')[0];
        const subId = a ? parseInt(a.textContent.trim(), 10) : Infinity;
        let name = '';
        const kids = el.childNodes;
        for (let i = kids.length - 1; i >= 0; i--) {
            const n = kids[i];
            if (n.nodeType === Node.TEXT_NODE && n.textContent.trim()) {
                name = n.textContent.trim();
                break;
            }
        }
        return { subId, name: name.toLowerCase() };
    }

    /**
     * 核心：站点的添加队列 k 只在筛选函数 E() 运行时按 DOM 顺序重建。
     * 排序后必须点击当前添加的筛选按钮触发 E()，添加顺序才会跟随排序。
     */
    function triggerSiteFilter() {
        const active = document.querySelector('.js-filter.btn-info');
        if (active) {
            active.click();
        } else {
            console.warn('[SFP] 未找到添加的筛选按钮，添加顺序可能不会跟随排序');
        }
    }

    function finishSort() {
        isSorting = false;
        setBtnLoading(false);
        refreshPreActivation();
        if (observer) {
            const panel = document.getElementById(PANEL_ID);
            if (panel) observer.observe(panel, { childList: true, subtree: false });
        }
    }

    /**
     * 移动节点排序（data-i 跟随节点走，站点 v[data-i] 取数始终正确）。
     * 分三阶段，每阶段之间让出一帧：内存排序 → 移动节点 → 触发站点 E()。
     * 不再使用 visibility 隐藏（避免 48k 节点两次全量样式重算导致的卡顿）。
     */
    function sortPackages(mode) {
        if (isSorting) return;
        if (ACT.started && !ACT.finished) return; // 添加进行中禁止排序
        const panel = document.getElementById(PANEL_ID);
        if (!panel) return;
        const packages = Array.from(panel.querySelectorAll('.package'));
        if (packages.length === 0) return;

        isSorting = true;
        setBtnLoading(true);
        if (observer) observer.disconnect();

        // 阶段1：内存中排序（同步、快速）
        rememberElements(packages);
        const items = packages.map((el, i) => {
            const { subId, name } = parsePackage(el);
            return { el, subId, name, oi: origIdx.get(el) ?? i };
        });
        if (mode === null) {
            items.sort((a, b) => a.oi - b.oi);
        } else if (mode === 'id-asc') {
            items.sort((a, b) => a.subId - b.subId);
        } else if (mode === 'name-desc') {
            items.sort((a, b) => b.name.localeCompare(a.name, 'zh-CN') || b.subId - a.subId);
        } else if (mode === 'len-asc') {
            items.sort((a, b) => a.name.length - b.name.length || a.name.localeCompare(b.name, 'zh-CN') || a.subId - b.subId);
        } else if (mode === 'len-desc') {
            items.sort((a, b) => b.name.length - a.name.length || b.name.localeCompare(a.name, 'zh-CN') || b.subId - a.subId);
        } else {
            items.sort((a, b) => a.name.localeCompare(b.name, 'zh-CN') || a.subId - b.subId);
        }

        const seenIds = new Set();
        let dups = 0;
        for (const it of items) {
            if (it.subId === Infinity) continue;
            if (seenIds.has(it.subId)) dups++;
            else seenIds.add(it.subId);
        }
        if (dups > 0) console.warn('[SFP] 检测到重复 subid:', dups, '条（DOM 可能被重复渲染），排序仍会执行');

        // 阶段2：下一帧移动节点（先让按钮加载态绘制出来）
        requestAnimationFrame(() => {
            const p = document.getElementById(PANEL_ID);
            if (!p) { finishSort(); return; }
            const frag = document.createDocumentFragment();
            for (const it of items) frag.appendChild(it.el);
            p.appendChild(frag);

            // 阶段3：再让一帧（排序列表先绘制），再触发站点 E() 重建添加队列
            requestAnimationFrame(() => {
                triggerSiteFilter();
                finishSort();
            });
        });
    }

    function setBtnLoading(loading) {
        document.querySelectorAll('#' + TOOLBAR_ID + ' .sfd-fp-sort-btn').forEach(btn => {
            btn.disabled = loading;
            btn.style.opacity = loading ? '0.5' : '';
            btn.style.cursor = loading ? 'wait' : '';
        });
    }

    function updateButtonStates() {
        document.querySelectorAll('#' + TOOLBAR_ID + ' .sfd-fp-sort-btn').forEach(btn => {
            const mode = btn.getAttribute('data-mode');
            // toggle 型按钮（名称/长度）：正↔倒循环，激活时文案带方向箭头（↑正序 ↓倒序）
            const pair = TOGGLE_SORTS[mode];
            if (pair) {
                const active = currentSort === mode || currentSort === pair;
                const base = btn.dataset.base;
                btn.textContent = active ? base + (currentSort === pair ? '↓' : '↑') : base;
                btn.classList.toggle('btn-info', active);
                btn.classList.toggle('btn-outline', !active);
                return;
            }
            const active = mode === (currentSort === null ? 'original' : currentSort);
            btn.classList.toggle('btn-info', active);
            btn.classList.toggle('btn-outline', !active);
        });
    }

    function doSort(mode) {
        currentSort = mode;
        sortPackages(mode);
        updateButtonStates();
    }

    function injectToolbar() {
        if (document.getElementById(TOOLBAR_ID)) return true;
        const filterBar = document.querySelector('.app-history-filters');
        if (!filterBar) return false;

        const toolbar = document.createElement('span');
        toolbar.id = TOOLBAR_ID;
        toolbar.style.cssText = 'display:inline-flex;align-items:center;gap:5px;margin-left:8px;';

        const label = document.createElement('span');
        label.className = 'b';
        label.textContent = '排序:';
        toolbar.appendChild(label);

        [
            { mode: 'original', label: '原始' },
            { mode: 'id-asc',   label: '升序' },
            { mode: 'name-asc', label: '名称' },
            { mode: 'len-asc',  label: '长度' },
        ].forEach(({ mode, label: text }) => {
            const btn = document.createElement('button');
            btn.className = 'btn btn-sm btn-outline sfd-fp-sort-btn';
            btn.textContent = text;
            btn.setAttribute('data-mode', mode);
            if (TOGGLE_SORTS[mode]) btn.dataset.base = text; // toggle 型按钮的基础文案
            btn.addEventListener('click', () => {
                if (mode === 'original') { doSort(null); return; }
                // toggle 型（名称/长度）：再次点击在正/倒序间切换
                const pair = TOGGLE_SORTS[mode];
                if (pair) {
                    doSort(currentSort === mode ? pair : mode);
                    return;
                }
                doSort(mode);
            });
            toolbar.appendChild(btn);
        });

        filterBar.appendChild(toolbar);
        return true;
    }

    /* ============ sub → 名称（仅用页面自身数据，无任何 fetch） ============
       页面内嵌 window.SteamDB.FreePackageData = [[subid,[appids],[],[],"名称",1],...]
       站点读取后会 delete 该属性（delete 时机不定，注入稍晚一步就会错过属性）。
       双路捕获：① document-start 起轮询抢先快照 window 属性；
       ② 属性已被 delete 时，解析常驻 DOM 的内嵌 <script> 文本兜底（行内名称数据源）。
    */

    const SUB_NAMES = new Map();  // subid → 名称
    let fpCaptured = false;
    let fpScriptDead = false;     // 内嵌脚本已完整却提取不出数据：不再重复扫描大文本

    function fillSubNames(rows) {
        for (const row of rows) {
            if (Array.isArray(row) && row[0] && typeof row[4] === 'string' && row[4]) {
                SUB_NAMES.set(row[0], row[4]);
            }
        }
    }

    function fpFinish(source) {
        if (SUB_NAMES.size === 0) return false;
        fpCaptured = true;
        console.log('[SFP] FreePackageData 快照:', SUB_NAMES.size, '条 sub→名称（' + source + '）');
        // 名称数据到位后重渲染（此前行内名称可能为空；分段条数据源是 ACT.queue 与此无关）
        // 加载态期间不抢渲染（避免空骨架顶掉加载动画）
        if (ACT.preview && ACT.preview.isConnected && !ACT.preview.classList.contains('loading')) pvRender();
        return true;
    }

    function tryCaptureFp() {
        if (fpCaptured) return true;
        const d = window.SteamDB && window.SteamDB.FreePackageData;
        if (Array.isArray(d) && d.length > 0) {
            fillSubNames(d);
            return fpFinish('window 属性');
        }
        if (fpScriptDead) return false;
        return captureFromInlineScript();
    }

    /** 兜底解析：script 元素执行后仍留在 DOM，文本不受属性 delete 影响（何时注入都能拿到）。
     *  解析进行中的脚本只有半截文本——平衡扫描找不到闭合括号即失败，由轮询下轮重试。 */
    function captureFromInlineScript() {
        for (const s of document.querySelectorAll('script')) {
            const t = s.textContent;
            // "==UserScript==" 排除自身（本脚本文本同样含 "FreePackageData" 字样）
            if (!t || t.indexOf('FreePackageData') === -1 || t.indexOf('==UserScript==') !== -1) continue;

            let start = t.indexOf('=', t.indexOf('FreePackageData')) + 1;
            while (start < t.length && (t[start] === ' ' || t[start] === '\t')) start++;
            if (t[start] !== '[') continue;

            let depth = 0, inStr = false, end = -1;
            for (let i = start; i < t.length; i++) {
                const c = t[i];
                if (inStr) {
                    if (c === '\\') i++;
                    else if (c === '"') inStr = false;
                    continue;
                }
                if (c === '"') inStr = true;
                else if (c === '[') depth++;
                else if (c === ']' && --depth === 0) { end = i; break; }
            }
            if (end < 0) continue; // 脚本尚未解析完整，等下一轮

            const arrText = t.slice(start, end + 1);
            try {
                fillSubNames(JSON.parse(arrText));
                return fpFinish('内嵌脚本');
            } catch (e) { /* 非 JSON 语法，退化为逐行正则提取 */ }
            const re = /\[\s*(\d+)\s*,\s*\[[^\]]*\]\s*,\s*\[[^\]]*\]\s*,\s*\[[^\]]*\]\s*,\s*"((?:[^"\\]|\\.)*)"/g;
            let m;
            while ((m = re.exec(arrText)) !== null) {
                let name = m[2];
                try { name = JSON.parse('"' + m[2] + '"'); } catch (e2) { }
                SUB_NAMES.set(parseInt(m[1], 10), name);
            }
            if (SUB_NAMES.size > 0) return fpFinish('内嵌脚本·正则');
            fpScriptDead = true;
            return false;
        }
        return false;
    }

    (function pollFp(n) {
        if (tryCaptureFp()) return;
        // 包列表已渲染且两条数据源均未命中：放弃捕获（分段条保持隐藏）
        if (document.querySelector('#freepackages .package')) return;
        if (n > 0) setTimeout(() => pollFp(n - 1), 60);
    })(1000);

    /* ============ 样式注入 ============ */

    function injectStyles() {
        if (document.getElementById('sfp-style') || !document.head) return;
        const style = document.createElement('style');
        style.id = 'sfp-style';
        style.textContent = `
/* 添加队列预览（位于原生添加框上方） */
#sfp-pv{margin:0 0 8px;border:1px solid hsl(204deg 100% 21%);border-radius:6px;background:rgba(0,0,0,.3);font-size:12px;overflow:hidden}
#sfp-pv .sfp-pv-head{display:flex;align-items:center;gap:10px;padding:5px 10px;border-bottom:1px solid rgba(255,255,255,.08)}
#sfp-pv .sfp-pv-title{font-weight:700;color:#c7d5e0;flex-shrink:0}
#sfp-pv .sfp-pv-prog{color:#66c0f4;font-weight:700;margin-left:auto;flex-shrink:0}
#sfp-pv .sfp-pv-prog.done{color:#2ed573}
/* 十万分段占比条（跟随当前筛选，1段=10万 subid 区间，宽度∝数量；色相随区间从青蓝渐变到红，悬停显示数据） */
#sfp-pv .sfp-pv-seg{display:flex;height:6px;width:666px;max-width:38vw;flex-shrink:0;gap:1px;border-radius:3px;overflow:hidden;background:hsla(204deg 100% 21% / .25)}
#sfp-pv .sfp-pv-seg i{display:block;height:100%;min-width:2px;opacity:.8;transition:filter .15s,opacity .15s}
#sfp-pv .sfp-pv-seg i:hover{opacity:1;filter:brightness(1.3)}
/* 上下 padding 归零：分节标题（自带底色与内边距）吸顶后，容器顶部 padding 会在标题上方裸露出缝隙 */
#sfp-pv .sfp-pv-list{padding:0;max-height:300px;overflow-y:auto;position:relative}
#sfp-pv.big .sfp-pv-list{max-height:900px}
#sfp-pv .sfp-pv-done,#sfp-pv .sfp-pv-cur,#sfp-pv .sfp-pv-pend{display:grid;grid-template-columns:1fr 1fr;column-gap:14px;align-content:start}
#sfp-pv .sfp-pv-msg{display:flex;align-items:center;gap:8px;padding:2px 10px;white-space:nowrap;min-height:22px;color:#8f98a0}
#sfp-pv .sfp-pv-row{display:flex;align-items:center;gap:8px;padding:2px 10px;white-space:nowrap;min-height:22px;position:relative}
/* 左侧状态竖条（绿=成功 红=失败）：left:1px 右移 1px，避免贴住预览框边框 */
#sfp-pv .sfp-pv-row.ok::before,#sfp-pv .sfp-pv-row.err::before{content:'';position:absolute;left:1px;top:0;bottom:0;width:2px}
#sfp-pv .sfp-pv-row.ok{background:rgba(46,213,115,.1)}
#sfp-pv .sfp-pv-row.ok::before{background:#2ed573}
#sfp-pv .sfp-pv-row.err{background:rgba(255,107,107,.08)}
#sfp-pv .sfp-pv-row.err::before{background:#ff6b6b}
#sfp-pv .sfp-pv-ico{width:14px;text-align:center;flex-shrink:0;color:#8f98a0}
#sfp-pv .sfp-pv-ico svg{vertical-align:-2px}
#sfp-pv .sfp-pv-row.cur .sfp-pv-ico{color:hsl(204deg 100% 35%)}
#sfp-pv .sfp-pv-row.ok .sfp-pv-ico{color:#2ed573}
#sfp-pv .sfp-pv-row.err .sfp-pv-ico{color:#ff6b6b}
#sfp-pv .sfp-pv-no{color:#8f98a0;flex-shrink:0}
#sfp-pv .sfp-pv-row a{color:#66c0f4;flex-shrink:0}
#sfp-pv .sfp-pv-name{color:#c7d5e0;overflow:hidden;text-overflow:ellipsis;flex:1 1 auto;min-width:0}
/* 激活失败行名称后的 [Ignore]（点击转发到站点列表行自己的忽略按钮） */
#sfp-pv .sfp-pv-ignore{flex-shrink:0;margin-left:4px;cursor:pointer;color:#66c0f4;font-size:11px;user-select:none;white-space:nowrap}
#sfp-pv .sfp-pv-ignore:hover{border-bottom:1px solid rgba(102,192,244,.6)}
#sfp-pv .sfp-pv-ignore.ignored{color:#8f98a0;cursor:default}
#sfp-pv .sfp-pv-ignore.ignored:hover{border-bottom:none}
#sfp-pv .sfp-pv-cd{display:inline-flex;align-items:center;gap:6px;flex-shrink:0;margin-left:auto}
#sfp-pv .sfp-cd-bar{width:450px;max-width:32vw;height:6px;border-radius:3px;background:hsla(204deg 100% 21% / .35);overflow:hidden;flex-shrink:0}
#sfp-pv .sfp-cd-bar i{display:block;height:100%;border-radius:3px;background:linear-gradient(90deg,hsl(204deg 100% 27%),hsl(204deg 100% 45%),hsl(204deg 100% 35%));transition:width .8s linear;position:relative;overflow:hidden}
/* 充电动效：亮带从左到右持续扫过填充区 */
#sfp-pv .sfp-cd-bar i::after{content:'';position:absolute;inset:0;background:linear-gradient(90deg,transparent,hsla(204deg 100% 75% / .55),transparent);animation:sfp-charge 2s linear infinite}
@keyframes sfp-charge{from{transform:translateX(-100%)}to{transform:translateX(100%)}}
#sfp-pv .sfp-cd-txt{color:hsl(204deg 100% 65%);font-weight:700;min-width:42px;text-align:right;font-variant-numeric:tabular-nums;flex-shrink:0}
#sfp-pv .sfp-cd-txt.firing{min-width:96px;animation:sfp-firing 1s ease-in-out infinite}
@keyframes sfp-firing{0%,100%{opacity:.55}50%{opacity:1}}
#sfp-pv .sfp-pv-row.full{grid-column:1 / -1}
/* 分节标题（已添加/添加中/待添加）：状态色底整行，文字统一白灰 */
#sfp-pv .sfp-pv-sec-h{position:sticky;top:0;z-index:3;padding:4px 10px 2px;color:#c7d5e0;font-weight:700;font-size:12px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
/* 吸顶底色须不透明（半透明会透出滚过的行）：原节色叠面板底(≈#171a21)的合成色 */
#sfp-pv .sfp-pv-sec-h.sec-done{background:#1d4735}
#sfp-pv .sfp-pv-sec-h.sec-cur{background:#203b56}
#sfp-pv .sfp-pv-sec-h.sec-pend{background:#3e2e4e}
#sfp-pv .sfp-pv-sec-h.paged{display:flex;align-items:center;gap:8px}
#sfp-pv .sfp-pv-sec-t{flex:1;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
/* 待添加数字右侧的剩余时间估算（待添加数 × 单条延迟，每秒走字） */
#sfp-pv .sfp-pv-eta{margin-left:10px;color:#66c0f4;font-weight:700;font-variant-numeric:tabular-nums}
#sfp-pv .sfp-pv-sec-hint{color:#8f98a0;font-weight:400;font-size:11px;flex-shrink:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;min-width:0}
/* 待添加分页控件（位于"待添加 N"标题行右侧） */
#sfp-pv .sfp-pv-pg{display:flex;align-items:center;gap:3px;flex-shrink:0}
#sfp-pv .sfp-pv-pg button{min-width:22px;height:18px;padding:0 5px;border:1px solid rgba(255,255,255,.2);border-radius:3px;background:rgba(255,255,255,.04);color:#8f98a0;font-size:11px;font-weight:700;cursor:pointer;font-family:inherit;line-height:1}
#sfp-pv .sfp-pv-pg button:hover:not(:disabled){border-color:rgba(102,192,244,.5);background:rgba(102,192,244,.1);color:#66c0f4}
#sfp-pv .sfp-pv-pg button:disabled{opacity:.35;cursor:default}
#sfp-pv .sfp-pv-pg .pg-lbl{color:#66c0f4;font-weight:700;font-size:11px;min-width:64px;text-align:center;cursor:pointer;white-space:nowrap;font-variant-numeric:tabular-nums}
/* 已成功行右侧的 Steam 许可记录外链（新标签打开） */
#sfp-pv .sfp-pv-lic{display:inline-flex;align-items:center;height:18px;padding:0 8px;border:1px solid rgba(102,192,244,.35);border-radius:3px;background:rgba(102,192,244,.08);color:#66c0f4;font-size:11px;font-weight:700;text-decoration:none;cursor:pointer;font-family:inherit;line-height:1;flex-shrink:0}
#sfp-pv .sfp-pv-lic:hover{border-color:rgba(102,192,244,.6);background:rgba(102,192,244,.18)}
/* 显示全部按钮（未点 view all 时挂在"待添加 N"标题行右侧，点击触发站点 view all） */
#sfp-pv .sfp-pv-viewall{height:18px;padding:0 8px;border:1px solid rgba(102,192,244,.35);border-radius:3px;background:rgba(102,192,244,.08);color:#66c0f4;font-size:11px;font-weight:700;cursor:pointer;font-family:inherit;line-height:1;flex-shrink:0}
#sfp-pv .sfp-pv-viewall:hover{border-color:rgba(102,192,244,.6);background:rgba(102,192,244,.18)}
/* 隐藏官方添加框按钮（常驻显示，添加前禁用） */
#sfp-pv .sfp-pv-hide{display:inline-flex;align-items:center;gap:4px;padding:2px 10px;border:1px solid rgba(255,255,255,.28);border-radius:4px;background:rgba(255,255,255,.05);color:#8f98a0;font-weight:700;font-size:11px;cursor:pointer;font-family:inherit;line-height:1.4;flex-shrink:0}
#sfp-pv .sfp-pv-hide:hover:not(:disabled){background:rgba(255,255,255,.14)}
#sfp-pv .sfp-pv-hide:disabled{opacity:.4;cursor:not-allowed}
#sfp-pv .sfp-pv-hide.on{border-color:rgba(102,192,244,.5);background:rgba(102,192,244,.08);color:#66c0f4}
#sfp-pv .sfp-pv-hide.on:hover:not(:disabled){background:rgba(102,192,244,.22)}
/* 加载态科技动效 */
#sfp-pv.loading{border-color:rgba(102,192,244,.35);animation:sfp-glow 2.4s ease-in-out infinite}
@keyframes sfp-glow{0%,100%{box-shadow:0 0 6px rgba(102,192,244,.08)}50%{box-shadow:0 0 16px rgba(102,192,244,.28)}}
#sfp-pv .sfp-pv-load{grid-column:1 / -1;display:flex;align-items:center;gap:12px;padding:16px 12px;min-height:56px}
#sfp-pv .sfp-pv-ring{width:15px;height:15px;border-radius:50%;border:2px solid rgba(102,192,244,.18);border-top-color:#66c0f4;animation:sfp-spin .8s linear infinite;flex-shrink:0}
@keyframes sfp-spin{to{transform:rotate(360deg)}}
#sfp-pv .sfp-pv-loadtxt{font-weight:700;letter-spacing:3px;flex-shrink:0;background:linear-gradient(90deg,rgba(102,192,244,.25) 0%,#66c0f4 50%,rgba(102,192,244,.25) 100%);background-size:200% 100%;-webkit-background-clip:text;background-clip:text;-webkit-text-fill-color:transparent;animation:sfp-shimmer 1.5s linear infinite}
@keyframes sfp-shimmer{0%{background-position:200% 0}100%{background-position:-200% 0}}
#sfp-pv .sfp-pv-scan{position:relative;flex:1;height:2px;border-radius:1px;background:rgba(102,192,244,.14);overflow:hidden}
#sfp-pv .sfp-pv-scan i{position:absolute;top:0;left:-35%;width:35%;height:100%;border-radius:1px;background:linear-gradient(90deg,transparent,#66c0f4,transparent);animation:sfp-scan 1.2s linear infinite}
@keyframes sfp-scan{to{left:100%}}
`;
        document.head.appendChild(style);
    }

    /* ============ 添加监视 ============
       站点添加逻辑（freepackages.js）：
       - 点击 #js-activate-now：loading.textContent="Activating N packages…"（清空日志框）
         → 逐个发添加请求 → 收到响应才追加一行日志并 setTimeout 调度下一发
       - 请求：window.postMessage({type:"steamdb:extension-query",
         contentScriptQuery:"StoreAddFreeLicense", subid}, origin)
       - 响应：扩展 content script window.postMessage → 站点 global.js 转发 BroadcastChannel
         ("steamdb-extension") → freepackages.js 处理结果
       本模块零全局污染（不包装任何原生方法，避免 SteamDB 反篡改检测导致卡死）：
       - 点击时（capture）快照可见队列
       - 站点清空日志后，预览内嵌进原生 #loading 顶部
       - window message 事件监听发出的请求（同源自派发）标记"正在添加"
       - BroadcastChannel 监听响应标记结果
    */

    /**
     * 站点 E() 把全部匹配包压入队列 k（k.push），hidden 只是显示限制——
     * "Showing first 500" 不影响添加范围，#js-activate-count 即队列真实长度。
     * 可见节点快照只是队列前缀，后续条目在添加请求到达时实时补充。
     */
    function readRealTotal() {
        const el = document.getElementById('js-activate-count');
        const n = el ? parseInt(el.textContent, 10) : NaN;
        return (isNaN(n) || n < 1) ? 0 : n;
    }

    /** 点击添加时快照当前可见队列（DOM 顺序 = 站点添加队列顺序） */
    function actSnapshot() {
        const g = document.getElementById(PANEL_ID);
        if (!g) return { queue: [], limited: false };
        const queue = [];
        const seen = new Set();
        let limited = false;
        for (const el of g.children) {
            if (el.classList.contains('package')) {
                if (el.hidden) continue;
                const a = el.getElementsByTagName('a')[0];
                if (!a) continue;
                const subid = parseInt(a.textContent.trim(), 10);
                if (!subid || seen.has(subid)) continue;
                seen.add(subid);
                let name = SUB_NAMES.get(subid) || '';
                if (!name) {
                    const kids = el.childNodes;
                    for (let i = kids.length - 1; i >= 0; i--) {
                        const n = kids[i];
                        if (n.nodeType === Node.TEXT_NODE && n.textContent.trim()) {
                            name = n.textContent.trim();
                            break;
                        }
                    }
                }
                queue.push({ subid, name });
            } else if (el.tagName === 'DIV' && el.textContent.includes('Showing first')) {
                // 未点击 "view all"：可见列表只是队列前缀，队列全长看 #js-activate-count
                limited = true;
            }
        }
        return { queue, limited };
    }

    /* ---------- 原生添加框上方的队列预览 ---------- */

    let userScrolled = false;      // 用户手动滚动查看历史时暂停自动跟随
    let autoScrolling = false;     // 程序滚动中（不误判为用户滚动）

    function wireListScroll(list) {
        if (list.dataset.sfpWired) return;
        list.dataset.sfpWired = '1';
        list.addEventListener('scroll', () => {
            if (autoScrolling) return;
            const atBottom = list.scrollTop + list.clientHeight >= list.scrollHeight - 4;
            userScrolled = !atBottom;
        }, { passive: true });
    }

    /** 自动跟随对位：显示官方日志（窗口 300px）时"添加中"行居中；隐藏日志 big 模式（900px）时贴底（大窗口居中体验差） */
    function pvFollowScroll() {
        if (!ACT.preview) return;
        const list = ACT.preview.querySelector('.sfp-pv-list');
        const curEl = list && list.querySelector('.cur');
        if (!curEl) return;
        const maxTop = list.scrollHeight - list.clientHeight;
        const target = ACT.preview.classList.contains('big')
            ? maxTop
            : Math.min(maxTop, Math.max(0, curEl.offsetTop - (list.clientHeight - curEl.offsetHeight) / 2));
        if (Math.abs(list.scrollTop - target) > 2) {
            if (userScrolled) {
                // 用户在查看历史：若添加中行已远离可视区（超过1屏），恢复跟随
                const dist = curEl.offsetTop - list.scrollTop;
                if (dist < -list.clientHeight || dist > list.clientHeight * 2) {
                    userScrolled = false;
                } else {
                    return;
                }
            }
            autoScrolling = true;
            list.scrollTo({ top: target, behavior: 'smooth' });
            setTimeout(() => { autoScrolling = false; }, 400);
        }
    }

    function pvBuild() {
        if (ACT.preview && ACT.preview.isConnected) return;
        const loading = document.getElementById('loading');
        if (!loading || !loading.parentElement) return;

        const box = document.createElement('div');
        box.id = 'sfp-pv';

        const head = document.createElement('div');
        head.className = 'sfp-pv-head';

        const title = document.createElement('span');
        title.className = 'sfp-pv-title';
        title.textContent = '添加队列预览';

        const seg = document.createElement('span');
        seg.className = 'sfp-pv-seg';
        seg.style.display = 'none';

        const prog = document.createElement('span');
        prog.className = 'sfp-pv-prog';

        const hideBtn = document.createElement('button');
        hideBtn.type = 'button';
        hideBtn.className = 'sfp-pv-hide';
        hideBtn.disabled = !ACT.started; // 添加前禁用，pvRender 每次刷新状态
        hideBtn.addEventListener('click', () => toggleLoading());

        head.append(title, seg, prog, hideBtn);

        const list = document.createElement('div');
        list.className = 'sfp-pv-list';

        box.append(head, list);
        // 放在原生添加框（#loading）上方，添加前后位置不变
        loading.parentElement.insertBefore(box, loading);
        wireListScroll(list);
        // 待添加翻页：事件委托（列表内容每次全量重建，按钮不重复绑定）
        list.addEventListener('click', onPagerClick);

        ACT.preview = box;
        ACT.progEl = prog;
        ACT.segEl = seg;
        ACT.hideEl = hideBtn;
        ACT.els = {};
        segSig = -1; // 新 seg 元素初始 display:none，沿用旧 sig 缓存会让它永远隐藏
    }

    /** 数据未到位时的加载态（页面一加载就显示，带科技感动效） */
    function pvShowLoading() {
        if (!ACT.started && ACT.queue.length > 0) return; // 已有数据，无需加载态
        pvBuild();
        if (!ACT.preview || !ACT.preview.isConnected) return;
        if (ACT.preview.classList.contains('loading')) return; // 轮询不重置动画
        ACT.preview.classList.add('loading');
        ACT.progEl.textContent = '';

        const row = document.createElement('div');
        row.className = 'sfp-pv-load';
        const ring = document.createElement('span');
        ring.className = 'sfp-pv-ring';
        const txt = document.createElement('span');
        txt.className = 'sfp-pv-loadtxt';
        txt.textContent = '正在加载队列数据';
        const scan = document.createElement('span');
        scan.className = 'sfp-pv-scan';
        scan.appendChild(document.createElement('i'));
        row.append(ring, txt, scan);

        ACT.preview.querySelector('.sfp-pv-list').replaceChildren(row);
    }

    const PEND_PAGE = 50;   // 待添加分页：每页条数（全部条目可翻页浏览，性能友好）

    const NAME_MAX = 60;

    /** 游戏名过长截断（完整名称见悬停 title） */
    function truncName(n) {
        if (!n || n.length <= NAME_MAX) return n || '';
        return n.slice(0, NAME_MAX).trimEnd() + ' ...';
    }

    /** 行内 SVG 图标（octicon 风格，fill=currentColor 跟随 CSS color）。
     *  不用 ✔(U+2714)/✖(U+274C)/▶(U+25B6) 文本字符：Windows 字体链下它们会落入
     *  彩色 emoji 字体（Segoe UI Emoji），彩色 emoji 字形自带颜色、无视 CSS color，
     *  导致图标颜色失控（1.0.6/1.0.7 改色从未生效的根因）。SVG 颜色 100% 可控 */
    function svgIcon(kind) {
        const NS = 'http://www.w3.org/2000/svg';
        const svg = document.createElementNS(NS, 'svg');
        svg.setAttribute('viewBox', '0 0 16 16');
        svg.setAttribute('width', '13');
        svg.setAttribute('height', '13');
        svg.setAttribute('aria-hidden', 'true');
        const p = document.createElementNS(NS, 'path');
        p.setAttribute('fill', 'currentColor');
        p.setAttribute('d', kind === 'ok'
            ? 'M13.78 4.22a.75.75 0 0 1 0 1.06l-7.25 7.25a.75.75 0 0 1-1.06 0L2.22 9.28a.751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018L6 10.94l6.72-6.72a.75.75 0 0 1 1.06 0Z'
            : kind === 'err'
                ? 'M3.72 3.72a.75.75 0 0 1 1.06 0L8 6.94l3.22-3.22a.749.749 0 0 1 1.275.326.749.749 0 0 1-.215.734L9.06 8l3.22 3.22a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L8 9.06l-3.22 3.22a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042L6.94 8 3.72 4.78a.75.75 0 0 1 0-1.06Z'
                : kind === 'cur'
                    ? 'M4.5 3.2a.8.8 0 0 1 1.23-.67l7.4 4.7a.8.8 0 0 1 0 1.35l-7.4 4.7A.8.8 0 0 1 4.5 12.6V3.2z'
                    : 'M8 5.5a2.5 2.5 0 1 1 0 5 2.5 2.5 0 0 1 0-5z');
        svg.appendChild(p);
        return svg;
    }

    /** 构建单行（st 为结果状态，isCur 为当前添加项） */
    function pvRow(it, i, st, isCur) {
        // 挂 450px 限制进度条的行保持整行（半宽列放不下）
        const hasBar = !!(st && !st.ok && /rate limited/i.test(st.text)
            && ACT.rateSub === it.subid && ACT.rateUntil > 0);
        const row = document.createElement('div');
        row.className = 'sfp-pv-row'
            + (isCur || hasBar ? ' full' : '')
            + (isCur ? ' cur' : (st ? (st.ok ? ' ok' : ' err') : ''));

        const ico = document.createElement('span');
        ico.className = 'sfp-pv-ico';
        ico.appendChild(svgIcon(st ? (st.ok ? 'ok' : 'err') : (isCur ? 'cur' : 'dot')));
        if (isCur && st && !st.ok) ico.style.color = '#ff6b6b'; // 重试中的 ✖ 同样红（▶ 仍为蓝）

        const no = document.createElement('span');
        no.className = 'sfp-pv-no';
        no.textContent = '#' + (i + 1);

        const link = document.createElement('a');
        link.href = '/sub/' + it.subid + '/';
        link.textContent = it.subid;
        link.target = '_blank';
        link.rel = 'noopener';

        const name = document.createElement('span');
        name.className = 'sfp-pv-name';
        name.textContent = truncName(it.name);
        name.title = it.name;

        row.append(ico, no, link, name);

        // 触发限制：带时间的进度条（只挂在触发限制的那一行）
        if (hasBar) {
            const firing = ACT.rateUntil <= Date.now(); // 已到点：重试网络空窗期
            const cd = buildRateBar(firing);
            if (firing) cd.querySelector('.sfp-cd-txt').classList.add('firing');
            row.appendChild(cd);
            startCountdown();
        }

        // 激活失败行（已落定，非重试中）：名称后挂 [Ignore]——转发点击站点列表行自己的忽略按钮
        // （站点的忽略事件委托在包列表上，预览行不在列表内，直接挂同 class 按钮不会生效）
        if (st && !st.ok && !isCur) {
            const done = ACT.ignored.has(it.subid);
            const ig = document.createElement('span');
            ig.className = 'sfp-pv-ignore' + (done ? ' ignored' : '');
            ig.textContent = done ? '[已忽略]' : '[Ignore]';
            ig.title = done ? '已加入 SteamDB 忽略列表' : '将该包加入 SteamDB 忽略列表';
            if (!done) {
                ig.addEventListener('click', () => {
                    const btn = findSiteIgnore(it.subid);
                    if (!btn) return;
                    btn.click();
                    ACT.ignored.add(it.subid);
                    ig.textContent = '[已忽略]';
                    ig.classList.add('ignored');
                    ig.title = '已加入 SteamDB 忽略列表';
                });
            }
            row.appendChild(ig);
        }

        return row;
    }

    /** 在站点包列表中找到该 subid 行的 [Ignore] 按钮（激活中列表被隐藏，click() 对隐藏元素同样生效） */
    function findSiteIgnore(subid) {
        const panel = document.getElementById(PANEL_ID);
        if (!panel) return null;
        for (const pkg of panel.querySelectorAll('.package')) {
            const a = pkg.getElementsByTagName('a')[0];
            if (a && parseInt(a.textContent.trim(), 10) === subid) {
                return pkg.querySelector('.js-remove');
            }
        }
        return null;
    }

    function pvMsgRow(text) {
        const row = document.createElement('div');
        row.className = 'sfp-pv-row full';
        const ico = document.createElement('span');
        ico.className = 'sfp-pv-ico';
        ico.appendChild(svgIcon('dot'));
        const name = document.createElement('span');
        name.className = 'sfp-pv-name';
        name.textContent = text;
        row.append(ico, name);
        return row;
    }

    /** 分节标题行右侧的灰色提示（如"未点 view all"） */
    function pvHintEl(text) {
        const h = document.createElement('span');
        h.className = 'sfp-pv-sec-hint';
        h.textContent = text;
        return h;
    }

    /** 触发站点 view all：点击 "Showing first" 行内的链接/按钮（与 actSnapshot 同一识别方式） */
    function triggerViewAll() {
        const panel = document.getElementById(PANEL_ID);
        if (!panel) return;
        for (const el of panel.children) {
            if (el.tagName === 'DIV' && el.textContent.includes('Showing first')) {
                const target = el.querySelector('a, button');
                if (target) { target.click(); return; }
            }
        }
        // 兜底：面板内任何 "view all" 字样的链接/按钮
        const fallback = Array.from(panel.querySelectorAll('a, button'))
            .find(el => /view all/i.test(el.textContent || ''));
        if (fallback) fallback.click();
    }

    /** "显示全部"按钮（未点 view all 时显示，点击加载全量后预览/分段条自动重算） */
    function pvViewAllBtn(rendered) {
        const b = document.createElement('button');
        b.type = 'button';
        b.className = 'sfp-pv-viewall';
        b.textContent = '显示全部';
        b.title = `当前仅渲染前 ${rendered} 条（添加范围不受影响），点击加载全部`;
        b.addEventListener('click', triggerViewAll);
        return b;
    }

    /** 待添加区在队列中的起始索引（添加中=当前项后一位；添加前=0；结束后=队列末尾） */
    function pendStart() {
        if (!ACT.started) return 0;
        return ACT.finished ? ACT.queue.length : ACT.current + 1;
    }

    /** 已成功区条数（结束前=添加中前一位；结束=全部） */
    function doneCount() {
        if (!ACT.started) return 0;
        return ACT.finished ? ACT.queue.length : Math.max(0, ACT.current);
    }

    /** 分页计算：count 条每页 PEND_PAGE 条；manual=false 时取 anchor 页（待添加=第1页，已成功=最后一页） */
    function secPageInfo(count, manual, page, anchor) {
        const pages = Math.max(1, Math.ceil(Math.max(0, count) / PEND_PAGE));
        let p = manual ? page : anchor;
        if (p < 1) p = 1;
        if (p > pages) { p = pages; page = p; }
        return { page: p, pages };
    }

    /** 翻页控件（« ‹ 1/N › »，挂在分节标题行右侧） */
    function buildPager(page, pages, sec) {
        const pg = document.createElement('span');
        pg.className = 'sfp-pv-pg';
        pg.dataset.sec = sec;
        const mk = (label, act, dis, title) => {
            const b = document.createElement('button');
            b.type = 'button';
            b.textContent = label;
            b.dataset.pg = act;
            b.title = title;
            if (dis) b.disabled = true;
            pg.appendChild(b);
        };
        mk('«', 'first', page <= 1, '回到第 1 页');
        mk('‹', 'prev', page <= 1, '上一页');
        const lbl = document.createElement('span');
        lbl.className = 'pg-lbl';
        lbl.textContent = page + ' / ' + pages;
        lbl.dataset.pg = 'goto';
        lbl.title = '点击输入页码跳转';
        pg.appendChild(lbl);
        mk('›', 'next', page >= pages, '下一页');
        mk('»', 'last', page >= pages, sec === 'done' ? '最后一页并跟随进度' : '最后一页');
        return pg;
    }

    function onPagerClick(e) {
        const el = e.target.closest('[data-pg]');
        if (!el) return;
        const pg = el.closest('.sfp-pv-pg');
        const sec = pg ? pg.dataset.sec : '';
        const isDone = sec === 'done';
        const count = isDone ? doneCount()
            : (!ACT.started ? (ACT.realTotal || ACT.queue.length)
                : (ACT.finished ? 0 : Math.max(0, (ACT.realTotal || ACT.queue.length) - pendStart())));
        const pages = Math.max(1, Math.ceil(Math.max(0, count) / PEND_PAGE));
        const cur = (isDone ? ACT.doneManual : ACT.pendManual) ? (isDone ? ACT.donePage : ACT.pendPage) : (isDone ? pages : 1);
        const act = el.dataset.pg;
        let p = cur;
        if (act === 'first') p = 1;
        else if (act === 'prev') p = cur - 1;
        else if (act === 'next') p = cur + 1;
        else if (act === 'last') p = pages;
        else if (act === 'goto') {
            const v = parseInt(window.prompt(`跳转页码（1 - ${pages}）`, String(cur)), 10);
            if (isNaN(v)) return;
            p = v;
        }
        p = Math.min(Math.max(1, p), pages);
        // 待添加第 1 页 / 已成功最后一页 = 自动跟随位置，回到该页即恢复跟随
        const anchor = isDone ? pages : 1;
        if (isDone) {
            ACT.doneManual = p !== anchor;
            ACT.donePage = p;
        } else {
            ACT.pendManual = p !== anchor;
            ACT.pendPage = p;
        }
        pvRender();
    }

    /** 预览骨架：已成功 / 添加中 / 待添加 三节 */
    function pvEnsureSkeleton(list) {
        if (ACT.els.list === list && ACT.els.doneGrid && ACT.els.doneGrid.isConnected) return;
        const mk = cls => { const d = document.createElement('div'); d.className = cls; return d; };
        const doneH = mk('sfp-pv-sec-h paged sec-done');
        const doneGrid = mk('sfp-pv-done');
        const curH = mk('sfp-pv-sec-h sec-cur');
        const curGrid = mk('sfp-pv-cur');
        const pendH = mk('sfp-pv-sec-h paged sec-pend');
        const pendGrid = mk('sfp-pv-pend');
        const msg = mk('sfp-pv-msg');
        list.replaceChildren(doneH, doneGrid, curH, curGrid, pendH, pendGrid, msg);
        ACT.els = { list, doneH, doneGrid, curH, curGrid, pendH, pendGrid, msg };
    }

    /** 十万分段占比条：按 subid 每 10 万一个区间分桶，段宽∝数量（悬停显示区间/数量/占比）
     *  数据源与预览列表一致（ACT.queue，跟随当前筛选/排序），切换筛选即同步重算 */
    let segSig = -1;
    function pvRenderSeg() {
        const el = ACT.segEl;
        if (!el) return;
        const q = ACT.queue;
        // 集合不变仅重排（排序）时分段结果相同：条数+最小/最大/全量和与顺序无关，
        // 纯重排签名不变（跳过重算），不同集合也不会因哈希碰撞漏刷新
        let min = Infinity, max = 0, sum = 0;
        for (const it of q) {
            const v = it.subid;
            if (v < min) min = v;
            if (v > max) max = v;
            sum += v;
        }
        const sig = q.length + ':' + min + ':' + max + ':' + sum;
        if (sig === segSig) return;
        segSig = sig;
        el.replaceChildren();
        if (q.length < 2) { el.style.display = 'none'; return; }
        el.style.display = '';

        const W = 100000;
        const buckets = new Map();
        for (const it of q) {
            const b = Math.floor(it.subid / W);
            buckets.set(b, (buckets.get(b) || 0) + 1);
        }
        const ks = [...buckets.keys()].sort((a, b) => a - b);
        const m = ks.length;
        for (let i = 0; i < m; i++) {
            const k = ks[i];
            const n = buckets.get(k);
            const seg = document.createElement('i');
            seg.style.flex = n;
            // 色相随区间位置铺开色谱：低 subid 青蓝(200°) → 高 subid 红(0°)，次序一目了然
            seg.style.background = `hsl(${m > 1 ? 200 - (200 * i / (m - 1)) : 200}deg 65% 52%)`;
            const from = (k * W).toLocaleString();
            const to = (k * W + W - 1).toLocaleString();
            seg.title = `subid ${from} - ${to}：${n} 个（${(n / q.length * 100).toFixed(1)}%）`;
            el.appendChild(seg);
        }
        // 未点 view all 时队列只是已渲染前缀：标题注明覆盖范围
        el.title = (ACT.limited && ACT.realTotal > q.length)
            ? `当前筛选共 ${ACT.realTotal} 条，此处仅统计已渲染 ${q.length} 条（点击"待添加"行"显示全部"加载完整）`
            : `当前筛选 ${q.length} 条`;
    }

    function pvRender() {
        if (!ACT.preview || !ACT.preview.isConnected) return;
        ACT.preview.classList.remove('loading');
        const list = ACT.preview.querySelector('.sfp-pv-list');
        if (!list) return;
        pvEnsureSkeleton(list);
        const E = ACT.els;
        const total = ACT.queue.length;

        // 进度与待添加计数以站点真实队列长度为准（未点 view all 时快照只是前缀）
        const realTotal = ACT.realTotal || total;
        let progText = `${ACT.done} / ${realTotal}`;
        if (ACT.finished) progText += ' · 结束';
        ACT.progEl.classList.toggle('done', !!ACT.finished);
        ACT.progEl.textContent = (total === 0 && !ACT.started) ? '' : progText;
        pvRenderSeg();

        // 隐藏官方日志按钮：常驻显示；添加前禁用（官方日志框尚无内容，隐藏无意义）
        ACT.hideEl.disabled = !ACT.started;
        updateHideBtn();

        // 添加中的条目可能还在重试（如触发限制）：其结果未落入上方区块，计数暂不计入
        const active = ACT.started && !ACT.finished && ACT.current >= 0 && ACT.current < total;
        const curSt = active ? ACT.status.get(ACT.queue[ACT.current].subid) : null;
        let okN = ACT.okCount, errN = ACT.errCount;
        if (curSt) curSt.ok ? okN-- : errN--;

        // ---- 已成功层：分页（默认最后一页跟随进度；手动翻页后停留，» 恢复跟随） ----
        const dCnt = doneCount();
        if (dCnt > 0) {
            const { page, pages } = secPageInfo(dCnt, ACT.doneManual, ACT.donePage, Infinity);
            ACT.donePage = page;
            E.doneH.style.display = '';
            E.doneGrid.style.display = '';

            const t = document.createElement('span');
            t.className = 'sfp-pv-sec-t';
            t.textContent = `已成功 ${okN}` + (errN ? ` · 失败 ${errN}` : '');
            // 许可记录外链：新标签打开 Steam 许可页面，核对添加结果
            const lic = document.createElement('a');
            lic.className = 'sfp-pv-lic';
            lic.href = 'https://store.steampowered.com/account/licenses';
            lic.target = '_blank';
            lic.rel = 'noopener noreferrer';
            lic.textContent = '许可记录';
            lic.title = '在新标签页打开 Steam 许可记录页面';
            E.doneH.replaceChildren(t, lic, ...(pages > 1 ? [buildPager(page, pages, 'done')] : []));

            const from = (page - 1) * PEND_PAGE;
            const to = Math.min(from + PEND_PAGE, dCnt);
            const frag = document.createDocumentFragment();
            for (let i = from; i < to; i++) {
                frag.appendChild(pvRow(ACT.queue[i], i, ACT.status.get(ACT.queue[i].subid), false));
            }
            E.doneGrid.replaceChildren(frag);
        } else {
            E.doneH.style.display = 'none';
            E.doneGrid.style.display = 'none';
        }

        // ---- 添加中 ----（active 已在上方计算，与计数口径一致）
        const cur = ACT.current;
        if (active) {
            E.curH.style.display = '';
            E.curGrid.style.display = '';
            E.curH.textContent = '添加中';
            E.curGrid.replaceChildren(pvRow(ACT.queue[cur], cur, ACT.status.get(ACT.queue[cur].subid), true));
        } else {
            E.curH.style.display = 'none';
            E.curGrid.style.display = 'none';
        }

        // ---- 待添加层：分页（默认第 1 页跟随添加进度；手动翻页后停留，« 恢复跟随） ----
        const ps = pendStart();
        const pendCount = !ACT.started ? realTotal : (ACT.finished ? 0 : Math.max(0, realTotal - ps));
        if (pendCount > 0) {
            const { page, pages } = secPageInfo(pendCount, ACT.pendManual, ACT.pendPage, 1);
            ACT.pendPage = page;
            E.pendH.style.display = '';
            E.pendGrid.style.display = '';
            E.msg.style.display = 'none';

            const t = document.createElement('span');
            t.className = 'sfp-pv-sec-t';
            const cnt = document.createElement('span');
            cnt.textContent = `待添加 ${pendCount}`;
            t.appendChild(cnt);

            // 剩余时间估算：待添加数 × 单条延迟（默认 180s，URL ?delay= 手动指定优先）。
            // 固定按站点 delay 估算（1.0.6 语义）：大队列几乎条条限流，实际节奏就是每条一个 delay；
            // 按"已用总时长÷已完成数"的观测均值开跑时会被前几条快节奏拉低，严重失真。
            // 添加前：静态估算不走字（尚未开始，走字无依据）；添加中：基准仅在"待添加集"
            // 变化时重设（条数+首条 subid 签名），间隔期每秒递减
            const etaEl = document.createElement('span');
            etaEl.className = 'sfp-pv-eta';
            etaEl.title = `按每条 ${rateDelayMs() / 1000} 秒估算`;
            if (!ACT.started) {
                etaBase = null; // 清旧轮基准，开始添加时从当前时刻起算
                etaEl.textContent = '预计剩余 ' + fmtEta(pendCount * rateDelayMs() / 1000);
            } else {
                const etaQid = pendCount + ':' + (ps < ACT.queue.length ? ACT.queue[ps].subid : 0);
                if (!etaBase || etaBase.qid !== etaQid) {
                    etaBase = { count: pendCount, qid: etaQid, t0: Date.now() };
                }
                etaEl.textContent = '预计剩余 ' + fmtEta(etaBase.count * rateDelayMs() / 1000 - (Date.now() - etaBase.t0) / 1000);
                startEtaTimer();
            }
            t.appendChild(etaEl);

            // 未点 view all：添加前显示"显示全部"按钮（点击触发站点 view all）；添加后越过前缀时文字提示
            let hintEl = null;
            if (ACT.limited) {
                if (!ACT.started) {
                    if (total < realTotal) hintEl = pvViewAllBtn(total);
                } else if (ps >= total && ps < realTotal) {
                    hintEl = pvHintEl('未点 view all：后续条目添加时实时显示');
                }
            }
            E.pendH.replaceChildren(t, ...(hintEl ? [hintEl] : []), ...(pages > 1 ? [buildPager(page, pages, 'pend')] : []));

            const from = ps + (page - 1) * PEND_PAGE;
            const to = Math.min(from + PEND_PAGE, total);
            const frag = document.createDocumentFragment();
            for (let i = from; i < to; i++) {
                frag.appendChild(pvRow(ACT.queue[i], i, null, false));
            }
            if (from >= to) frag.appendChild(pvMsgRow('本页暂无条目（未点 view all：后续条目添加时实时补充）'));
            E.pendGrid.replaceChildren(frag);
        } else {
            E.pendH.style.display = 'none';
            E.pendGrid.style.display = 'none';
            E.pendH.replaceChildren(); // 清掉残留 eta 元素：倒计时器检测不到元素自动停止
            if (ACT.started) {
                E.msg.style.display = '';
                E.msg.textContent = '队列已处理完毕';
            } else if (total === 0) {
                E.msg.style.display = '';
                E.msg.textContent = '当前筛选无条目';
            } else {
                E.msg.style.display = 'none';
            }
        }

        // 自动跟随对位（模式见 pvFollowScroll；人工向上滚动查看历史时暂不抢滚动条）
        pvFollowScroll();
    }

    /* ---------- 限制等待进度条（delay 来源：站点默认 180s；URL ?delay= 手动指定，脚本自动跟随） ---------- */

    /** 与站点 freepackages.js 完全一致的 delay 计算 */
    function rateDelayMs() {
        const d = parseInt(new URLSearchParams(location.search).get('delay'), 10);
        return (isNaN(d) || d < 10 ? 180 : d) * 1000;
    }

    /** 秒数折算为 年/月(30天)/天/小时/分/秒，零值单位省略 */
    function fmtEta(sec) {
        sec = Math.max(0, Math.floor(sec));
        const y = Math.floor(sec / 31536000);
        const mo = Math.floor(sec % 31536000 / 2592000);
        const d = Math.floor(sec % 2592000 / 86400);
        const h = Math.floor(sec % 86400 / 3600);
        const m = Math.floor(sec % 3600 / 60);
        const s = sec % 60;
        const parts = [];
        if (y) parts.push(y + '年');
        if (mo) parts.push(mo + '月');
        if (d) parts.push(d + '天');
        if (h) parts.push(h + '小时');
        if (m) parts.push(m + '分');
        if (!parts.length || s) parts.push(s + '秒');
        return parts.join('');
    }

    /** 待添加剩余时间估算：仅添加中每秒走字（添加前静态显示，etaBase=null 时自停） */
    let etaBase = null;
    let etaTimer = 0;

    function startEtaTimer() {
        if (etaTimer) return;
        etaTimer = setInterval(() => {
            const el = document.querySelector('#sfp-pv .sfp-pv-eta');
            if (!el || !etaBase || !ACT.started || ACT.finished) {
                clearInterval(etaTimer);
                etaTimer = 0;
                return;
            }
            const remain = etaBase.count * rateDelayMs() / 1000 - (Date.now() - etaBase.t0) / 1000;
            el.textContent = '预计剩余 ' + fmtEta(remain);
        }, 1000);
    }

    /** 限制进度：已等待占比（0-100）与剩余秒数 */
    function rateProgress() {
        const total = Math.max(1, ACT.rateUntil - ACT.rateStart);
        const remainMs = ACT.rateUntil - Date.now();
        const pct = Math.min(100, Math.max(0, Math.round((1 - remainMs / total) * 100)));
        const left = Math.max(0, Math.ceil(remainMs / 1000));
        return { pct, left };
    }

    function buildRateBar(firing) {
        const { pct, left } = rateProgress();
        const cd = document.createElement('span');
        cd.className = 'sfp-pv-cd';
        const bar = document.createElement('span');
        bar.className = 'sfp-cd-bar';
        const fill = document.createElement('i');
        fill.style.width = firing ? '100%' : pct + '%';
        bar.appendChild(fill);
        const txt = document.createElement('span');
        txt.className = 'sfp-cd-txt';
        txt.textContent = firing ? '正在添加......' : left + 's';
        cd.append(bar, txt);
        return cd;
    }

    let cdTimer = 0;

    function startCountdown() {
        if (cdTimer) return;
        cdTimer = setInterval(() => {
            const els = document.querySelectorAll('#sfp-pv .sfp-pv-cd');
            if (ACT.finished || els.length === 0) {
                clearInterval(cdTimer);
                cdTimer = 0;
                els.forEach(el => el.remove());
                return;
            }
            // 到点后不再移除进度条：保持满格，行内文案切为"正在添加......"
            // （站点实际重试有 2-3s 网络空窗，避免状态闪断）
            if (ACT.rateUntil <= Date.now()) {
                for (const el of els) {
                    const fill = el.querySelector('.sfp-cd-bar i');
                    if (fill) fill.style.width = '100%';
                    const txt = el.querySelector('.sfp-cd-txt');
                    if (txt) { txt.textContent = '正在添加......'; txt.classList.add('firing'); }
                }
                return;
            }
            const { pct, left } = rateProgress();
            for (const el of els) {
                const fill = el.querySelector('.sfp-cd-bar i');
                if (fill) fill.style.width = pct + '%';
                const txt = el.querySelector('.sfp-cd-txt');
                if (txt) txt.textContent = left + 's';
            }
        }, 1000);
    }

    /* ---------- 暂停 / 继续 ---------- */

    /* 隐藏/恢复官方添加框（#loading） */
    let loadingHidden = false;

    function toggleLoading() {
        const loading = document.getElementById('loading');
        if (!loading) return;
        loadingHidden = !loadingHidden;
        loading.style.display = loadingHidden ? 'none' : '';
        // 联动预览高度：官方日志让位后预览撑到 900px，恢复则回落 300px
        if (ACT.preview) {
            ACT.preview.classList.toggle('big', loadingHidden);
            // 高度模式切换后立即按新模式对位：隐藏日志→贴底，恢复日志→添加行居中
            userScrolled = false;
            pvFollowScroll();
        }
        updateHideBtn();
    }

    function updateHideBtn() {
        if (!ACT.hideEl) return;
        ACT.hideEl.textContent = loadingHidden ? '显示官方日志' : '隐藏官方日志';
        ACT.hideEl.classList.toggle('on', loadingHidden);
    }

    function actSetSortDisabled(dis) {
        if (isSorting) return; // 排序流程自身管理按钮状态
        document.querySelectorAll('#' + TOOLBAR_ID + ' .sfd-fp-sort-btn').forEach(btn => {
            btn.disabled = dis;
            btn.style.opacity = dis ? '0.5' : '';
            btn.style.cursor = dis ? 'not-allowed' : '';
        });
    }

    /** 添加进行中禁用站点筛选按钮（中途换筛选会重建站点队列，预览与计数全部失真），结束时恢复 */
    function actSetFilterDisabled(dis) {
        document.querySelectorAll('.js-filter').forEach(btn => {
            btn.disabled = dis;
            btn.style.opacity = dis ? '0.5' : '';
            btn.style.cursor = dis ? 'not-allowed' : '';
        });
    }

    /* ---------- 监视初始化 ---------- */

    /** 筛选结果为空：空态视图（此前直接返回会一直残留上一筛选的旧数据或永久加载态） */
    function pvShowEmpty() {
        ACT.queue = [];
        ACT.idxOf.clear();
        ACT.realTotal = 0;
        ACT.limited = false;
        ACT.current = -1;
        ACT.done = 0;
        ACT.okCount = 0;
        ACT.errCount = 0;
        ACT.status.clear();
        ACT.ignored.clear();
        ACT.rateUntil = 0;
        ACT.rateStart = 0;
        ACT.rateSub = 0;
        ACT.pendPage = 1;
        ACT.pendManual = false;
        ACT.donePage = 1;
        ACT.doneManual = false;
        ACT.started = false;
        ACT.finished = false;
        ACT.lastSub = 0;
        pvBuild();
        pvRender();
    }

    /** 添加前：队列就绪即显示预览（跟随排序/筛选实时刷新）。
     *  force：上一轮结束后用户换筛选/排序时强制刷新并复位（check() 的面板变动不带 force，
     *  不会清掉已结束轮次的汇总视图） */
    function refreshPreActivation(force) {
        if (ACT.started && !ACT.finished) return; // 添加进行中
        if (ACT.started && !force) return;        // 已结束：保留汇总，仅显式刷新时复位
        const snap = actSnapshot();
        if (snap.queue.length === 0) { pvShowEmpty(); return; } // 空筛选：空态

        ACT.queue = snap.queue;
        ACT.limited = snap.limited;
        ACT.realTotal = Math.max(readRealTotal(), snap.queue.length);
        ACT.current = -1;
        ACT.done = 0;
        ACT.okCount = 0;
        ACT.errCount = 0;
        ACT.status.clear();
        ACT.ignored.clear();
        ACT.rateUntil = 0;
        ACT.rateStart = 0;
        ACT.rateSub = 0;
        ACT.pendPage = 1;
        ACT.pendManual = false;
        ACT.donePage = 1;
        ACT.doneManual = false;
        // 上一轮已结束：复位运行标记，回到"待添加"预览并允许再次开始
        ACT.started = false;
        ACT.finished = false;
        ACT.lastSub = 0;

        pvBuild();
        pvRender();
    }

    function onActivateClick() {
        if (ACT.started && !ACT.finished) return; // 进行中忽略重复点击；已结束允许再次开始
        let snap = actSnapshot();
        if (snap.queue.length === 0) return;
        // 未点 view all：先自动触发站点 view all 展开全量列表并重新快照，
        // 预览/分段条/行内名称随即完整（添加范围本就不受渲染条数限制影响）
        if (snap.limited) {
            triggerViewAll();
            snap = actSnapshot();
            if (snap.queue.length === 0) return;
        }

        ACT.started = true;
        ACT.finished = false;
        ACT.lastSub = 0; // 上一轮末条不残留，否则新轮首条与之相同时会漏计 1 条
        ACT.queue = snap.queue;
        ACT.limited = snap.limited;
        ACT.realTotal = Math.max(readRealTotal(), snap.queue.length);
        ACT.idxOf.clear();
        ACT.current = -1; // 二次开始不经过 refreshPreActivation，须清掉上一轮的"添加中"位置
        ACT.done = 0;
        ACT.okCount = 0;
        ACT.errCount = 0;
        ACT.status.clear();
        ACT.ignored.clear();
        ACT.rateUntil = 0;
        ACT.rateStart = 0;
        ACT.rateSub = 0;
        ACT.pendPage = 1;
        ACT.pendManual = false;
        ACT.donePage = 1;
        ACT.doneManual = false;
        snap.queue.forEach((it, i) => ACT.idxOf.set(it.subid, i));

        // 站点 handler 同步清空 #loading 后重建预览（此时位置已移到 #loading 上方）
        setTimeout(() => {
            pvBuild();
            pvRender();
        }, 0);

        actSetSortDisabled(true);
        actSetFilterDisabled(true);
        console.log('[SFP] 添加队列:', ACT.realTotal, '条（可见前缀', snap.queue.length, '条）',
            snap.limited ? '，未点 view all' : '');
    }

    function onMessage(e) {
        if (e.origin !== window.location.origin) return;
        const msg = e.data;
        if (!msg || typeof msg !== 'object') return;

        if (!ACT.started || ACT.finished) return;
        if (msg.type !== 'steamdb:extension-query' || msg.contentScriptQuery !== 'StoreAddFreeLicense') return;

        const idx = ACT.idxOf.get(msg.subid);
        if (idx !== undefined) {
            ACT.current = idx;
        } else if (ACT.limited) {
            // 越过可见前缀：添加请求到达时实时补充进队列
            ACT.queue.push({ subid: msg.subid, name: SUB_NAMES.get(msg.subid) || '' });
            ACT.idxOf.set(msg.subid, ACT.queue.length - 1);
            ACT.current = ACT.queue.length - 1;
        } else {
            return;
        }
        pvRender();
    }

    function onResponse(d) {
        if (!ACT.started || ACT.finished) return;
        if (!d || d.type !== 'steamdb:extension-response') return;
        const req = d.request;
        if (!req || req.contentScriptQuery !== 'StoreAddFreeLicense') return;
        // 只认本页队列内的 subid：BroadcastChannel 全标签页广播，杂散响应不得污染计数
        if (!ACT.idxOf.has(req.subid)) return;

        // 站点串行添加，同一 subid 连续出现 = rate limit 重试，不重复计数
        if (req.subid !== ACT.lastSub) {
            ACT.done++;
            ACT.lastSub = req.subid;
        }
        const err = (d.response && d.response.error) || '';
        // 重试会覆盖旧状态，先回退旧计数
        const prev = ACT.status.get(req.subid);
        if (prev) prev.ok ? ACT.okCount-- : ACT.errCount--;
        ACT.status.set(req.subid, { ok: !err, text: err || 'OK' });
        err ? ACT.errCount++ : ACT.okCount++;
        if (/rate limited/i.test(err)) {
            ACT.rateStart = Date.now();
            ACT.rateUntil = ACT.rateStart + rateDelayMs();
            ACT.rateSub = req.subid;
            startCountdown();
        }
        // 兜底结束判定：末条成功响应即收尾（日志检测为主路，这里防日志文案变更/日志框缺失）
        // 仅认成功：末条首响若是 rate limit，重试成功前不能提前定格
        if (!err && ACT.realTotal > 0 && ACT.done >= ACT.realTotal) markFinished();
        pvRender();
    }

    /** 结束：恢复排序/筛选按钮，预览定格"已处理完毕"。日志检测与响应计数兜底双路都经此去重 */
    function markFinished() {
        if (ACT.finished) return;
        ACT.finished = true;
        actSetSortDisabled(false);
        actSetFilterDisabled(false);
        pvRender();
    }

    let loadingObsWired = false;

    function wireLoadingObserver() {
        const loading = document.getElementById('loading');
        if (!loading || loadingObsWired) return;
        loadingObsWired = true;

        const obs = new MutationObserver((muts) => {
            // 站点日志追加：只检查本次新增节点（全量扫描 loading.children 是 O(n²)，4.8万条日志会拖死页面）
            if (ACT.started && !ACT.finished) {
                outer:
                for (const mut of muts) {
                    for (const el of mut.addedNodes) {
                        if (!(el instanceof HTMLElement) || el.tagName !== 'H4') continue;
                        const txt = el.textContent || '';
                        if (txt.includes('Script finished') || txt.includes('Received license activation')) {
                            markFinished();
                            break outer;
                        }
                    }
                }
            }
            if (ACT.started && ACT.preview && !ACT.preview.isConnected) {
                pvBuild();
                pvRender();
            }
        });
        // subtree：日志行即使被站点写进子容器也能检测到结束标记
        obs.observe(loading, { childList: true, subtree: true });
    }

    function initActMonitor() {
        // 1. 捕获添加按钮点击（capture 先于站点 handler，此时列表尚未隐藏）
        document.addEventListener('click', (e) => {
            const t = e.target instanceof Element ? e.target : null;
            if (t && t.closest('#js-activate-now')) onActivateClick();
            // 站点筛选按钮点击后刷新预览（E() 同步执行，稍等一拍确保 hidden 全部写完）；
            // 上一轮结束后换筛选也强制刷新（复位回"待添加"预览，允许再次开始）
            if (t && t.closest('.js-filter') && (!ACT.started || ACT.finished)) {
                setTimeout(() => refreshPreActivation(true), 600);
            }
        }, true);

        // 2. window message 事件监听添加请求 + 暂停时扣下响应（同源自派发，零全局污染）
        window.addEventListener('message', onMessage);

        // 3. BroadcastChannel 监听响应 → 标记结果
        try {
            const bc = new BroadcastChannel('steamdb-extension');
            bc.addEventListener('message', (c) => onResponse(c.data));
        } catch (e) {
            console.warn('[SFP] BroadcastChannel 不可用，预览将无结果标记');
        }
    }

    /* ============ 启动（document-start：抢在站点 delete 前捕获 FreePackageData） ============ */

    function waitForPackages() {
        let lastCount = 0;
        let dataReady = false;
        let emptySince = 0; // 面板持续 0 包的起始时刻（宽限期满切换空态）

        const check = () => {
            const panel = document.getElementById(PANEL_ID);
            if (!panel) return;

            // 早期：工具栏 + 预览加载态先行（按钮禁用，等数据到位）
            if (!injectToolbar()) return;

            const count = panel.querySelectorAll('.package').length;
            if (count > 0) emptySince = 0;

            if (!dataReady) {
                if (count > 0) {
                    dataReady = true;
                    actSetSortDisabled(false);
                    rememberElements(panel.querySelectorAll('.package'));
                } else {
                    // 面板为空先给 3 秒宽限（E() 未跑完/扩展握手/分批渲染）；
                    // 超时仍为 0 = 当前筛选无条目，显示空态而非永久"正在加载"
                    if (!emptySince) emptySince = Date.now();
                    actSetSortDisabled(true);
                    if (Date.now() - emptySince >= 3000) pvShowEmpty();
                    else pvShowLoading();
                    return;
                }
            }
            if (count === 0) return;

            updateButtonStates();

            if (count !== lastCount) {
                // 仅节点新增时才需重排；[Ignore] 等移除操作不破坏现有顺序（避免每次忽略都全量重排 4.8万节点）
                const grew = count > lastCount;
                lastCount = count;
                if (currentSort && grew) sortPackages(currentSort);
            }
            // 添加前：列表变化（排序/筛选/view all）后刷新预览队列
            refreshPreActivation();
        };

        const debouncedCheck = () => {
            clearTimeout(debounceTimer);
            debounceTimer = setTimeout(check, 300);
        };

        const attach = () => {
            const panel = document.getElementById(PANEL_ID);
            if (panel && !observer) {
                observer = new MutationObserver(debouncedCheck);
                observer.observe(panel, { childList: true, subtree: false });
                return true;
            }
            return !!observer;
        };

        let retries = 0;
        const poll = () => {
            injectStyles();
            wireLoadingObserver();
            attach();
            check();
            // 数据到位即停轮询（observer 兜底后续变化）
            if (retries++ < 200 && !dataReady) {
                setTimeout(poll, 300);
            }
        };
        poll();
    }

    initActMonitor();
    waitForPackages();
})();