// ==UserScript==
// @name         Get Microsoft Rewards (移动端优化版)
// @namespace    https://github.com/Muverix/Get-Microsoft-Rewards
// @version      1.7.14
// @description  微软 Rewards 自动助手（安全防封优先版）。1.7.14 改动：①额度默认 80%（硬上限 80%，可在设置里自行调低）；②脚本发请求的 UA 改为读取指纹环境真实值，不再硬编码 Edge/151（消除同一账号两种浏览器身份的破绽）；③默认开启「顺手点一条搜索结果」（30% 概率，请求 Bing 自己的点击跳转端点，不打断搜索流程）；④搜索间隔/暂停时长支持一位小数，暂停与分批休息各带 ±20% 抖动，不再整点停；⑤卡片提取支持向下扫描子任务，「每周 4/5」这类活动的第 5 个子项终于能抓到；⑥新增体检面板：登录 / 身份 / 额度 / 风控 四个灯，不看代码也能判断能不能跑；⑦活动跳过原因汇总成一行（已完成 / 明天解锁 / 已锁定 / 外区）。1.7.13 起执行「安全防封第一、功能可用第二」全面整改：搜索模式强制「真实页面」并隐藏后台请求（api）选项、移除手动 Cookie/UA 伪造移动端身份（移动搜索完全依赖浏览器真实环境）；签到/阅读/活动移除直连 reportactivity 与 dapi/me/activities 上报，全部改为「打开页面→停留30-90秒→返回任务页」的页面交互模式；搜索词改为「主题链式」；移除「一键全部执行」按钮、新增随机放弃机制。本脚本代码由 AI 生成。
// @author       Muverix
// @license      MIT
// @icon         https://rewards.bing.com/rewardscdn/images/rewards.png
// @homepage     https://scriptcat.org/zh-CN/script-show-page/7354
// @supportURL   https://github.com/Muverix/Get-Microsoft-Rewards/issues
// 注：脚本猫发布时会剥离下面两行；自建/第三方托管时才生效。
// @match        https://www.bing.com/*
// @match        https://cn.bing.com/*
// @match        https://rewards.bing.com/*
// @match        https://login.live.com/*
// @grant        GM_xmlhttpRequest
// @grant        GM_addStyle
// @grant        GM_setValue
// @grant        GM_getValue
// @grant        GM_notification
// @grant        GM_cookie
// @grant        GM_registerMenuCommand
// @grant        GM_openInTab
// @grant        GM_log
// @connect      bing.com
// @connect      rewards.bing.com
// @connect      www.bing.com
// @connect      cn.bing.com
// @connect      login.live.com
// @connect      prod.rewardsplatform.microsoft.com
// @connect      hot.baiwumm.com
// @connect      hotapi.nntool.cc
// @connect      cnxiaobai.com
// @run-at       document-end
// ==/UserScript==

/* =========================================================================
 * 📜 版权声明与免责条款 (License & Disclaimer)
 * -------------------------------------------------------------------------
 * 0. 本脚本基于原作者 QingJ 的《Get Microsoft Rewards》v1.0.6 版本改编。
 *    原作者主页：https://github.com/QingJ01
 *    原项目仓库：https://github.com/QingJ01/Get-Microsoft-Rewards
 * 1. 本脚本基于 QingJ 的开源项目《Get Microsoft Rewards》二次开发；
 *    并接续 Muverix 的《Get Microsoft Rewards (修复/增强版)》继续开发，
 *    感谢其在 Bing 界面报错修复、会员等级识别、多区域兼容与积分卡片过滤上的工作。
 *    Muverix 脚本页面：https://scriptcat.org/zh-CN/script-show-page/7354
 *    Muverix 作者主页：https://scriptcat.org/zh-CN/users/211142
 * 2. 借助 Gemini AI，参考并融合了 liyan20001124-byte 的《微软积分商城签到（全能智能重构版）》的核心逻辑与优化思路。
 * 3. 本脚本 1.5.0 之后的改动（真实页面搜索、机型 UA、逐字输入、模糊搜索等）均由 AI 编写，
 *    代码由 AI 生成、经维护者人工验收后发布；如有问题欢迎在 Issues 反馈。
 * 4. 本脚本遵循 MIT 开源许可协议，仅供个人学习研究与自动化测试使用。
 * 5. 作者不对使用本脚本可能产生的任何风险（如账号积分变动或风控等）承担任何法律责任，请合理使用。
 * ========================================================================= */

(function () {
    'use strict';

    /* =========================================================================
     * 🆕 1.7.2 Apple 双端兼容层（iPhone / iPad 的用户脚本 App）
     * -------------------------------------------------------------------------
     * iOS 上的「用户脚本 / Userscripts」App 只提供 Promise 版 GM.addStyle /
     * GM.getValue / GM.setValue，没有旧式同步的 GM_addStyle / GM_getValue /
     * GM_setValue。旧代码在顶层直接调用会抛 ReferenceError，整个脚本当场中断，
     * 连悬浮球都不会出现。
     *
     * 这里加一层垫片，保证「有就用、没有就退」：
     *   样式 → 没有 GM_addStyle 就自己插一个 <style> 标签
     *   存储 → 没有 GM_getValue/GM_setValue 就用 localStorage（同步，逻辑不用改）
     * 因此后面的业务代码一行都不用动，安卓 / 电脑 / 脚本猫的行为完全不变。
     * ========================================================================= */
    const MR_LS = 'mr_ls_'; // localStorage 前缀，避免与网站自己的键冲突

    // v1.7.8 安全修复：调试开关。默认关闭 —— 授权码长度、接口返回体等诊断信息
    // 只在本地排查时手动改成 true 才会输出到控制台，正式使用不会往控制台写账号相关数据。
    const MR_DEBUG = false;

    function hasGMGet() { try { return typeof GM_getValue === 'function'; } catch (e) { return false; } }
    function hasGMSet() { try { return typeof GM_setValue === 'function'; } catch (e) { return false; } }

    // 读存储：优先脚本存储，其次本机 localStorage，都没有则返回默认值
    // 注意：下面这句必须调用「全局」GM_getValue，不能写成 gv()，否则会自我递归
    function gv(key, def) {
        if (hasGMGet()) {
            try {
                const v = GM_getValue(key, def);
                if (v !== undefined && v !== null) return v;
                if (def !== undefined) return def;
            } catch (e) { }
        }
        try {
            const raw = localStorage.getItem(MR_LS + key);
            if (raw === null || raw === '') return def;
            try { return JSON.parse(raw); } catch (e) { return raw; }
        } catch (e) { }
        return def;
    }

    // 写存储：优先脚本存储，其次本机 localStorage；空值等同于「清除」
    // 同上：这里必须调用全局 GM_setValue
    function gs(key, val) {
        if (hasGMSet()) {
            try { GM_setValue(key, val); return true; } catch (e) { }
        }
        try {
            if (val === '' || val === null || val === undefined) localStorage.removeItem(MR_LS + key);
            else localStorage.setItem(MR_LS + key, JSON.stringify(val));
            return true;
        } catch (e) { return false; }
    }

    /* -------------------------------------------------------------------------
     * v1.7.9 安全修复：refresh_token 是长期凭据，只允许写进脚本存储（GM_setValue）。
     * 没有脚本存储时（部分 iOS 环境）**不做「降级写入 localStorage 明文」**，
     * 只保留在当前页面内存里：刷新/关页即失效，需要重新点一次「获取授权码」。
     * 换来的代价是少一次免授权，收益是长期令牌不会以明文躺在网页脚本可读的位置。
     * ------------------------------------------------------------------------- */
    const TOKEN_KEY = 'refresh_token';
    let volatileRefreshToken = '';
    let tokenPersistWarned = false;

    function hasSafeTokenStore() {
        try { return hasGMGet() && hasGMSet(); } catch (e) { return false; }
    }

    // 清掉历史版本可能留在 localStorage 的明文副本（老版本会写 mr_ls_refresh_token）
    function purgePlaintextToken() {
        try { localStorage.removeItem(MR_LS + TOKEN_KEY); } catch (e) { }
    }

    function getRefreshToken() {
        if (hasSafeTokenStore()) {
            try {
                const v = GM_getValue(TOKEN_KEY, '');
                if (typeof v === 'string' && v) return v;
            } catch (e) { }
        }
        return volatileRefreshToken;
    }

    function setRefreshToken(val) {
        const v = typeof val === 'string' ? val : '';
        volatileRefreshToken = v;
        let persisted = false;
        if (hasSafeTokenStore()) {
            try { GM_setValue(TOKEN_KEY, v); persisted = true; } catch (e) { }
        }
        if (!persisted) {
            purgePlaintextToken(); // 不安全就一个字节都不落盘
            if (v && !tokenPersistWarned) {
                tokenPersistWarned = true;
                try { console.warn('[Rewards] 当前环境没有脚本存储，refresh_token 不落盘（仅本次会话有效，刷新后需重新授权）'); } catch (e) { }
            }
        }
        return persisted;
    }

    // v1.7.10：启动清理不再看「有没有脚本存储」。
    // 旧版只要 GM 存储可用就跳过清理，于是浏览器 localStorage 里的历史明文副本可以一直躺着；
    // 而 localStorage 是网页脚本和同域脚本都能读的位置 —— 清理与当前是否安全存储无关，一律删。
    // 只删脚本自己的这一个键（mr_ls_refresh_token），不碰任何其他数据。
    function initTokenStorage() {
        purgePlaintextToken();
        return hasSafeTokenStore();
    }
    try { initTokenStorage(); } catch (e) { }

    // 注入样式：优先 GM_addStyle，缺失时自建 <style>
    function addStyle(css) {
        try { if (typeof GM_addStyle === 'function') return GM_addStyle(css); } catch (e) { }
        try {
            const s = document.createElement('style');
            s.setAttribute('data-mr-style', '1');
            s.textContent = css;
            (document.head || document.documentElement).appendChild(s);
            return s;
        } catch (e) { return null; }
    }

    /* =========================================================================
     * 🆕 移动端新增：微软登录页「授权码自动捕获」
     * -------------------------------------------------------------------------
     * 在 login.live.com / login.microsoftonline.com 上不再注入 Rewards 面板，
     * 只负责把跳转后网址里的 code 自动存进脚本存储，并给出提示页面。
     * 回到 Bing / Rewards 标签页后，脚本会自动填充并兑换，全程无需复制粘贴。
     * ========================================================================= */
    if (/^(login\.(live|microsoftonline)\.com|account\.live\.com)$/i.test(location.hostname)) {
        initOAuthCapturePage();
        return;
    }

    function initOAuthCapturePage() {
        const href = location.href;
        let code = '';
        const m = href.match(/[?&#]code=([^&#\s"']+)/i);
        if (m) {
            try { code = decodeURIComponent(m[1]); } catch (e) { code = m[1]; }
        }
        const errM = href.match(/[?&#]error=([^&#\s]+)/i);
        const errDesc = href.match(/[?&#]error_description=([^&#]+)/i);

        // 普通登录/授权中间页：不弹任何东西，交给微软自己的页面
        if (!code && !errM) return;

        try {
            if (code) {
                gs('auth_code', code);
                gs('auth_code_time', String(Date.now()));
                gs('auth_pending', '');
                // v1.7.8 安全修复：只打长度，且默认关闭（正式使用不往控制台写授权相关信息）
                if (MR_DEBUG) console.log('[Rewards] 已自动捕获授权码，长度:', code.length);
            }
        } catch (e) { }

        // 极简提示页（白底深字，亮色浏览器下清晰）
        const box = document.createElement('div');
        box.style.cssText = 'position:fixed;left:50%;top:50%;transform:translate(-50%,-50%);width:min(360px,92vw);box-sizing:border-box;background:#fff;color:#222;border:1px solid #e0e0e0;border-radius:12px;box-shadow:0 10px 30px rgba(0,0,0,.15);padding:20px;font:14px/1.6 -apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,sans-serif;z-index:2147483647;text-align:center;';

        // v1.7.8 安全修复：来自网址的文本（授权码 / 错误码 / 错误描述）一律用 textContent 写入，
        // 禁止拼进 innerHTML —— 否则一条恶意链接就能把 <svg onload=...> 注入本页并执行（DOM XSS）。
        const mk = (tag, cssText, text) => {
            const el = document.createElement(tag);
            if (cssText) el.style.cssText = cssText;
            if (text != null) el.textContent = text;
            return el;
        };

        if (code) {
            box.appendChild(mk('div', 'font-size:34px;line-height:1', '✅'));
            box.appendChild(mk('div', 'font-weight:700;font-size:16px;margin:8px 0 6px', '授权码已自动获取'));
            box.appendChild(mk('div', 'color:#666;font-size:13px', '现在可以关闭本页，回到 Bing 标签页。'));
            box.appendChild(mk('div', 'color:#666;font-size:13px', '脚本会自动填充授权码并完成兑换。'));
            // 这里只显示前 24 位供肉眼确认；「复制授权码」复制的仍是完整授权码
            box.appendChild(mk('div', 'margin:12px 0;padding:8px;background:#fafafa;border:1px solid #eee;border-radius:6px;font:11px/1.5 monospace;color:#888;word-break:break-all', code.slice(0, 24) + '…'));

            const row = mk('div', 'display:flex;gap:8px;margin-top:12px');
            const btnCopy = mk('button', 'flex:1;min-height:42px;border:1px solid #d0d0d0;background:#fff;color:#333;border-radius:6px;font-size:14px', '📋 复制授权码');
            btnCopy.id = 'mr-cap-copy';
            const btnClose = mk('button', 'flex:1;min-height:42px;border:none;background:#0078d4;color:#fff;border-radius:6px;font-size:14px', '关闭本页');
            btnClose.id = 'mr-cap-close';
            row.appendChild(btnCopy);
            row.appendChild(btnClose);
            box.appendChild(row);
        } else {
            // 错误码也先解码再写入（原来直接塞原始串，中文/符号会显示成 %E4%BB%80 这种乱码）
            let e1 = '未知错误';
            if (errM) { try { e1 = decodeURIComponent(errM[1]); } catch (e) { e1 = errM[1]; } }
            let e2 = '';
            try { e2 = errDesc ? decodeURIComponent(errDesc[1].replace(/\+/g, ' ')) : ''; } catch (e) { e2 = errDesc ? errDesc[1] : ''; }

            box.appendChild(mk('div', 'font-size:34px;line-height:1', '⚠️'));
            box.appendChild(mk('div', 'font-weight:700;font-size:16px;margin:8px 0 6px', '授权被取消或失败'));
            box.appendChild(mk('div', 'color:#666;font-size:13px;word-break:break-all', e1));
            if (e2) box.appendChild(mk('div', 'color:#666;font-size:13px;word-break:break-all', e2));
            box.appendChild(mk('div', 'color:#666;font-size:13px;margin-top:8px', '关闭本页，回到 Bing 后重新点击「获取授权码」。'));
            const btnClose2 = mk('button', 'width:100%;min-height:42px;margin-top:12px;border:none;background:#0078d4;color:#fff;border-radius:6px;font-size:14px', '关闭本页');
            btnClose2.id = 'mr-cap-close';
            box.appendChild(btnClose2);
        }

        const mount = () => { if (document.body) document.body.appendChild(box); };
        if (document.body) mount(); else document.addEventListener('DOMContentLoaded', mount);

        const closeBtn = box.querySelector('#mr-cap-close');
        if (closeBtn) closeBtn.onclick = () => { window.close(); };
        const copyBtn = box.querySelector('#mr-cap-copy');
        if (copyBtn) copyBtn.onclick = async () => {
            try {
                await navigator.clipboard.writeText(code);
                copyBtn.textContent = '✅ 已复制';
            } catch (e) {
                copyBtn.textContent = '请长按上方授权码复制';
            }
        };
    }

    // ========== 配置 ==========
    const CONFIG = {
        pc: { minDelay: 15000, maxDelay: 30000 },
        mobile: { minDelay: 20000, maxDelay: 35000 },
        ua: {
            // v1.7.14：PC 身份不再硬编码。留空表示「运行时读取环境真实 UA」，
            // 由 envUA() 从 navigator.userAgent 取，保证脚本请求与页面身份完全一致。
            // 旧值（Windows + Edg/151）已移除：指纹环境里根本不存在这个浏览器版本，
            // 同一账号同时出现两种身份是最明显的破绽。
            pc: '',
            mobile: 'Mozilla/5.0 (Linux; Android 16; MEIZU 20 Build/BQ2A.251110.001-BP2A.250605.031.A3; ) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/150.0.7871.181 Mobile Safari/537.36 BingSapphire/33.8.440724006'
        },
        mobileApi: {appId: 'SAAndroid/34.0.440821006'},
        read: { minDelay: 8000, maxDelay: 15000 },
        // 多个热搜API备用源
        hotApis: [
            { url: 'https://hot.baiwumm.com/api/', sources: ['weibo', 'douyin', 'baidu', 'zhihu', 'toutiao'] },
            { url: 'https://hotapi.nntool.cc/', sources: ['weibo', 'douyin', 'baidu', 'toutiao', 'zhihu'] },
            { url: 'https://cnxiaobai.com/DailyHotApi/', sources: ['weibo', 'douyin', 'baidu', 'toutiao'] }
        ],
        keywords: ["天气预报", "今日新闻", "体育赛事", "股票行情", "电影推荐", "科技资讯", "美食食谱", "旅游攻略"],
        // 暂停机制配置
        pause: {
            enabled: true,           // 是否启用暂停机制
            interval: 10,            // 每执行多少次搜索后暂停
            duration: 15 * 60 * 1000 // 暂停时长（毫秒），15分钟
        }
    };

    /* =========================================================================
     * 🆕 v1.7.14：读取「环境真实 UA」
     * -------------------------------------------------------------------------
     * 指纹浏览器（FluxBrowser / AdsPower 等）会把用户配置的 UA 注入浏览器，
     * 所以 navigator.userAgent 返回的就是这个环境自己的身份
     * （例如 Windows 11 + Chrome/130，或 macOS + Chrome/146）。
     *
     * 脚本发后台请求（授权码、积分读取）时必须沿用同一个身份。
     * 旧版本硬编码成 "Windows + Edg/151"，而指纹环境里根本不存在这个版本 ——
     * 同一账号在同一分钟出现两种浏览器身份，是最容易被关联的破绽。
     *
     * 原则：环境是什么就用什么，一个字符都不改。
     * ========================================================================= */
    function envUA() {
        try {
            const u = (typeof navigator !== 'undefined' && navigator.userAgent) ? String(navigator.userAgent) : '';
            if (u && u.length >= 20) return u;
        } catch (e) { }
        // 极端兜底：拿不到环境 UA 时用一个中性的桌面 UA（不会比环境更可疑）
        return 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36';
    }

    /* =========================================================================
     * ⚙️ 搜索设置（可在面板「⚙️」里改，保存到脚本存储，跨页面/重启后仍生效）
     * 默认值 = 原脚本行为（100% 额度），用户不改就完全不变
     * ========================================================================= */
    /* =========================================================================
     * 手机机型 UA 配置（搜索端选「手机」时使用）
     * 型号代码取自各厂商公开的入网型号 / 说明书型号，Android 版本为该机出厂版本。
     * 注意：Chrome 从 110 起已不在 UA 里写机型（真实手机会写成 "Android 10; K"），
     * 这里用带机型的完整格式，是为了让 Bing 能识别成对应机型。
     * ========================================================================= */
    const DEVICE_PROFILES = {
        generic:      { label: '通用 Android', model: '',           android: '15', group: '通用' },
        // 小米系（含子品牌 Redmi）
        xiaomi15:     { label: '小米 15',        model: '24129PN74C', android: '15', group: '小米 / Redmi' },
        xiaomi14:     { label: '小米 14',        model: '23127PN0CC', android: '14', group: '小米 / Redmi' },
        redmik80pro:  { label: '红米 K80 Pro',   model: '24122RKC7C', android: '15', group: '小米 / Redmi' },
        redmik70:     { label: '红米 K70',       model: '23113RKC6C', android: '14', group: '小米 / Redmi' },
        // vivo 系（含子品牌 iQOO）
        vivox300:     { label: 'vivo X300 Pro',  model: 'V2502A',     android: '16', group: 'vivo / iQOO' },
        iqoo13:       { label: 'iQOO 13',        model: 'V2408A',     android: '15', group: 'vivo / iQOO' },
        // OPPO 系（含子品牌 一加）
        opporeno14:   { label: 'OPPO Reno14 Pro', model: 'PKZ110',    android: '15', group: 'OPPO / 一加' },
        oneplus13:    { label: '一加 13',        model: 'PJZ110',     android: '15', group: 'OPPO / 一加' },
        oneplusace5p: { label: '一加 Ace 5 Pro', model: 'PKR110',     android: '15', group: 'OPPO / 一加' },
        honormagic6:  { label: '荣耀 Magic6',    model: 'BVL-AN00',   android: '14', group: '其它' },
        galaxys24:    { label: '三星 Galaxy S24', model: 'SM-S9210',  android: '14', group: '其它' },
        huaweimate60: { label: '华为 Mate 60 Pro', model: 'ALN-AL00', android: '12', group: '其它', browser: 'huawei' }
    };
    const MOBILE_POOL = ['xiaomi15', 'xiaomi14', 'redmik80pro', 'redmik70', 'vivox300', 'iqoo13',
        'opporeno14', 'oneplus13', 'oneplusace5p', 'honormagic6', 'galaxys24'];
    const CHROME_VER = '131.0.6778.135';

    function buildMobileUA(key) {
        const p = DEVICE_PROFILES[key] || DEVICE_PROFILES.generic;
        if (p.browser === 'huawei') {
            // 华为浏览器（鸿蒙兼容模式）：UA 里带 HMSCore，Android 版本固定 12
            return `Mozilla/5.0 (Linux; Android 12; ${p.model}; HMSCore 6.14.0.302) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.5735.196 HuaweiBrowser/15.0.4.312 Mobile Safari/537.36`;
        }
        const tail = `AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${CHROME_VER} Mobile Safari/537.36`;
        if (!p.model) return `Mozilla/5.0 (Linux; Android 10; K) ${tail}`;
        return `Mozilla/5.0 (Linux; Android ${p.android}; ${p.model}) ${tail}`;
    }

    // 「自动」机型：当天抽一款存下来，当轮/当天一直用它（1.7.4 起不再每次调用都重抽）
    function autoModelKey() {
        let st = null;
        try { st = gv('mr_auto_model', null); } catch (e) { }
        const today = new Date().toISOString().slice(0, 10);
        if (!st || typeof st !== 'object' || st.day !== today || MOBILE_POOL.indexOf(st.key) < 0) {
            st = { key: MOBILE_POOL[Math.floor(Math.random() * MOBILE_POOL.length)], day: today };
            try { gs('mr_auto_model', st); } catch (e) { }
        }
        return st.key;
    }

    // 当前实际假装成哪台手机（自动模式下取当天固定的那款）
    function currentModelKey() {
        return (settings.deviceModel === 'auto') ? autoModelKey() : settings.deviceModel;
    }

    function currentModelLabel() {
        const p = DEVICE_PROFILES[currentModelKey()];
        return (p && p.label) || '通用 Android';
    }

    // 换一款（用户手动点「换一款」时用）
    function rerollAutoModel() {
        let key = MOBILE_POOL[Math.floor(Math.random() * MOBILE_POOL.length)];
        if (MOBILE_POOL.length > 1) {
            const cur = autoModelKey();
            let guard = 0;
            while (key === cur && guard++ < 10) key = MOBILE_POOL[Math.floor(Math.random() * MOBILE_POOL.length)];
        }
        try { gs('mr_auto_model', { key: key, day: new Date().toISOString().slice(0, 10) }); } catch (e) { }
        return key;
    }

    // 按设置生成手机 UA；「自动」用当天固定的那一款
    function currentMobileUA() {
        return buildMobileUA(currentModelKey());
    }

    // 是否是「触屏平板」（iPad / iPadOS 的桌面模式 UA 是 Macintosh，需要靠手指数识别）
    function isTouchTablet() {
        try {
            const ua = navigator.userAgent || '';
            if (/iPad/i.test(ua)) return true;
            if (/Macintosh|Mac OS X/i.test(ua) && (navigator.maxTouchPoints || 0) > 1) return true;
        } catch (e) { }
        return false;
    }

    // 本次搜索该用电脑身份还是手机身份
    function resolveSearchDevice() {
        const d = settings.searchDevice;
        if (d === 'pc' || d === 'mobile') return d;
        if (isTouchTablet()) return 'mobile'; // iPad 默认「请求桌面网站」，UA 里没有 Mobile，单独识别
        return /Android|iPhone|iPad|Mobile/i.test(navigator.userAgent || '') ? 'mobile' : 'pc';
    }

    // 与手机 UA 配套的 Client Hints，避免出现「手机 UA + 电脑 CH」的矛盾
    function mobileClientHints(ua) {
        const m = String(ua).match(/Android [\d.]+;\s*([^;)]+)/);
        const model = m ? m[1].trim() : '';
        const h = {
            'sec-ch-ua-mobile': '?1',
            'sec-ch-ua-platform': '"Android"'
        };
        if (model && model !== 'K') h['sec-ch-ua-model'] = `"${model}"`;
        return h;
    }

    /* =====================================================================
     * 🆕 1.7.0 个人词库（全部在本机完成）
     * ---------------------------------------------------------------------
     * 用户自己上传浏览器导出的历史 CSV → 只提取搜索引擎的查询参数
     * （q / wd / query / text …）→ 其余内容（网址、标题、时间、站点路径）
     * 立即丢弃，不保存、不显示、不发送。
     * 全程没有任何网络请求；词库只存在本机脚本存储里。
     * ===================================================================== */

    const TOPIC_PACKS = {
        digital: { label: '数码', words: ['机械键盘', '蓝牙耳机', '移动固态硬盘', '路由器 穿墙', '显示器 护眼', '充电宝 20000mAh', '智能手表', '笔记本电脑 续航', '手机壳 推荐', '扩展坞 接口'] },
        auto: { label: '汽车', words: ['电动车 续航', '行车记录仪 推荐', '轮胎 更换周期', '洗车 团购', '新能源 上牌', '汽车 保养 项目', '车载支架'] },
        home: { label: '家居家电', words: ['扫地机器人 避坑', '床垫 硬度', '抽油烟机 风压', '净水器 滤芯', '窗帘 遮光', '收纳箱 尺寸', '空调 清洗'] },
        money: { label: '理财', words: ['存款利率 最新', '基金 定投 怎么选', '信用卡 积分 兑换', '个人所得税 退税', '理财产品 风险等级', '记账 APP'] },
        baby: { label: '母婴', words: ['婴儿车 轻便', '纸尿裤 尺码', '辅食 添加顺序', '幼儿园 报名', '儿童 安全座椅'] },
        fitness: { label: '健身', words: ['减脂 食谱', '跑步 膝盖疼', '哑铃 重量 选择', '增肌 蛋白粉', '居家 训练 计划', '体脂率 计算'] },
        travel: { label: '旅游', words: ['周末 周边游', '高铁票 候补', '民宿 避坑', '景点 门票 预约', '自驾 路线 推荐', '行李箱 尺寸'] },
        exam: { label: '考试', words: ['备考 时间安排', '真题 下载', '考试 报名 入口', '面试 常见问题', '英语 听力 怎么练'] },
        job: { label: '招聘', words: ['简历 模板', '面试 自我介绍', '试用期 规定', '五险一金 断缴', '跳槽 时机'] },
        food: { label: '美食', words: ['空气炸锅 菜谱', '红烧肉 做法', '减脂 餐 搭配', '手冲咖啡 比例', '火锅 蘸料 配方'] },
        media: { label: '影音', words: ['电影 推荐 高分', '电视剧 2026', '纪录片 自然', '投影仪 亮度', '音响 入门'] },
        pet: { label: '宠物', words: ['猫粮 成分', '狗狗 驱虫', '猫砂 结团', '宠物 托运 规定'] }
    };

    const WL_CITIES = '北京 上海 广州 深圳 杭州 南京 苏州 成都 重庆 武汉 西安 天津 长沙 郑州 青岛 宁波 厦门 福州 合肥 济南 大连 沈阳 哈尔滨 长春 石家庄 太原 南昌 昆明 贵阳 南宁 海口 兰州 西宁 银川 乌鲁木齐 呼和浩特 拉萨 无锡 常州 徐州 温州 嘉兴 绍兴 金华 台州 东莞 佛山 珠海 中山 惠州 汕头 泉州 烟台 潍坊 洛阳 唐山 保定 廊坊 昆山 江阴 义乌 莆田 湛江 茂名 株洲 岳阳 宜昌 襄阳 赣州 九江 芜湖 蚌埠 淄博 济宁 泰安 临沂 威海 邯郸 秦皇岛'.split(' ');
    const WL_CITY_RE = new RegExp(WL_CITIES.join('|'));
    const WL_MODIFIERS = ['推荐', '怎么样', '多少钱', '对比', '哪个好', '测评', '值不值得买', '避坑', '怎么选', '真实体验'];

    // 「不要碰」的敏感类目：命中直接丢弃，不计入统计
    const WL_SENSITIVE_RE = /(密码|账号|帐号|登录|身份证|实名|银行卡|卡号|社保卡|医保卡|公积金|贷款|征信|网贷|医院|挂号|门诊|住院|症状|确诊|用药|处方|体检|病历|抑郁|焦虑|离婚|诉讼|律师|仲裁|工资条|银行流水|住址|门牌|验证码|开房|酒店订单|快递地址|护照|签证材料|落户|户口)/;

    // 只认这几家搜索引擎的查询参数，其余路径一律丢弃
    const WL_ENGINES = [
        { host: /(^|\.)bing\.com$/i, path: /^\/search\/?$/i, params: ['q'] },
        { host: /(^|\.)google\.[a-z.]+$/i, path: /^\/search\/?$/i, params: ['q'] },
        { host: /(^|\.)baidu\.com$/i, path: /^\/s\/?$/i, params: ['wd', 'word'] },
        { host: /(^|\.)sogou\.com$/i, path: /^\/(web|s)\/?$/i, params: ['query', 'keyword'] },
        { host: /(^|\.)so\.com$/i, path: /^\/s\/?$/i, params: ['q'] },
        { host: /(^|\.)sm\.cn$/i, path: /^\/s\/?$/i, params: ['q'] },
        { host: /(^|\.)duckduckgo\.com$/i, path: /^\//i, params: ['q'] },
        { host: /(^|\.)yandex\.[a-z.]+$/i, path: /^\/search\/?$/i, params: ['text'] },
        { host: /(^|\.)ecosia\.org$/i, path: /^\/search\/?$/i, params: ['q'] },
        { host: /(^|\.)startpage\.com$/i, path: /^\/sp\/search/i, params: ['query'] },
        { host: /(^|\.)brave\.com$/i, path: /^\/search\/?$/i, params: ['q'] }
    ];

    function wlNorm(s) {
        return String(s || '')
            .replace(/[\u200b-\u200f\ufeff]/g, '')
            .replace(/\+/g, ' ')
            .replace(/\s+/g, ' ')
            .trim()
            .replace(/^[，,。.、;；:：!！?？"'“”‘’()（）\[\]【】<>《》]+/, '')
            .replace(/[，,。.、;；:：!！?？"'“”‘’()（）\[\]【】<>《》]+$/, '');
    }

    function wlIsSensitive(w) {
        if (WL_SENSITIVE_RE.test(w)) return true;
        if (/[\w.-]+@[\w-]+\.[a-z]{2,}/i.test(w)) return true;  // 邮箱
        if (/1[3-9]\d{9}/.test(w)) return true;                 // 手机号
        if (/\d{15,}/.test(w)) return true;                     // 长数字串（证件/卡号）
        if (/^(https?:|\/\/|www\.)/i.test(w)) return true;
        return false;
    }

    function wlClean(w) {
        const s = wlNorm(w);
        if (!s) return '';
        if (s.length < 2 || s.length > 40) return '';
        if (!/[\u4e00-\u9fa5a-zA-Z]/.test(s)) return '';
        if (wlIsSensitive(s)) return '';
        return s;
    }

    // 从历史 CSV 文本里提取搜索词：返回每个词的出现次数
    function wlExtractFromCsv(text) {
        const out = new Map();
        let rows = 0, dropped = 0;
        const lines = String(text || '').split(/\r?\n/);
        const urlRe = /https?:\/\/[^\s,"'<>]+/g;
        for (const line of lines) {
            if (!line || line.length < 8) continue;
            rows++;
            urlRe.lastIndex = 0;
            let m;
            while ((m = urlRe.exec(line))) {
                let u;
                try { u = new URL(m[0]); } catch (e) { continue; }
                const eng = WL_ENGINES.find(e => e.host.test(u.hostname) && e.path.test(u.pathname));
                if (!eng) continue;
                for (const p of eng.params) {
                    const v = u.searchParams.get(p);
                    if (!v) continue;
                    const q = wlClean(v);
                    if (!q) { if (v.trim()) dropped++; continue; }
                    out.set(q, (out.get(q) || 0) + 1);
                    break;
                }
            }
        }
        return { words: out, rows, dropped };
    }

    function wlTag(w) {
        const tags = [];
        if (/\d|价格|多少钱|报价|预算|性价比|便宜|优惠|折扣|元|块|以内|以上/.test(w)) tags.push('price');
        if (WL_CITY_RE.test(w)) tags.push('place');
        if (/(20[1-3]\d|今年|明年|最新|最近|本月|\d+月|今天|周末|春|夏|秋|冬)/.test(w)) tags.push('time');
        if (/(怎么|如何|为什么|哪个|推荐|对比|区别|教程|方法|攻略|测评|排行|值不值)/.test(w)) tags.push('ask');
        return tags.length ? tags : ['interest'];
    }

    const WL_KEY = 'mr_wordlib';
    const WL_SEEN_KEY = 'mr_seen';
    const WL_SEEN_DAYS = 30;

    function wlGetLib() {
        let o = null;
        try { o = gv(WL_KEY, null); } catch (e) { }
        if (!o || !Array.isArray(o.words)) o = { v: 1, words: [], src: '', savedAt: 0 };
        return o;
    }
    function wlSetLib(o) { try { gs(WL_KEY, o); } catch (e) { } }
    function wlClearLib() { wlSetLib({ v: 1, words: [], src: '', savedAt: 0 }); }

    function wlGetSeen() {
        let o = null;
        try { o = gv(WL_SEEN_KEY, null); } catch (e) { }
        if (!o || typeof o !== 'object') o = {};
        const cut = Date.now() - WL_SEEN_DAYS * 864e5;
        for (const k in o) if (!(o[k] >= cut)) delete o[k];
        const keys = Object.keys(o);
        if (keys.length > 1500) {
            keys.sort((a, b) => o[a] - o[b]);
            while (keys.length > 1500) delete o[keys.shift()];
        }
        return o;
    }
    function wlMarkSeen(w) {
        try {
            const k = wlNorm(w);
            if (!k) return;
            const o = wlGetSeen();
            o[k] = Date.now();
            gs(WL_SEEN_KEY, o);
        } catch (e) { }
    }

    // 合并词条（导入时用），返回总词数与新增数
    function wlMergeWords(mapLike, src) {
        const lib = wlGetLib();
        const idx = new Map(lib.words.map(x => [x.w, x]));
        let added = 0;
        for (const [w, c] of mapLike) {
            const old = idx.get(w);
            if (old) { old.c = Math.min(999, (old.c || 1) + c); old.t = wlTag(w); }
            else { idx.set(w, { w, c, t: wlTag(w) }); added++; }
        }
        lib.words = [...idx.values()].sort((a, b) => b.c - a.c).slice(0, 1200);
        lib.src = src || lib.src || 'file';
        lib.savedAt = Date.now();
        wlSetLib(lib);
        return { total: lib.words.length, added };
    }

    // 有效配比：词库太小时自动降档，避免几十个词反复刷
    function wlEffectiveMix() {
        const n = wlGetLib().words.length;
        const want = { p: settings.mixP, b: settings.mixB, h: settings.mixH };
        if (n >= 150) return { p: want.p, b: want.b, h: want.h, n, ramped: false };
        const ramp = n < 30 ? { p: 0, b: 0, h: 100 } : (n < 80 ? { p: 40, b: 20, h: 40 } : { p: 60, b: 20, h: 20 });
        const p = Math.min(want.p, ramp.p);
        const b = Math.min(want.b, ramp.b);
        return { p, b, h: Math.max(0, 100 - p - b), n, ramped: true };
    }

    function wlTopicQuery() {
        let keys = (settings.topics || []).filter(k => TOPIC_PACKS[k]);
        if (!keys.length) keys = Object.keys(TOPIC_PACKS);
        const pack = TOPIC_PACKS[keys[Math.floor(Math.random() * keys.length)]];
        const base = pack.words[Math.floor(Math.random() * pack.words.length)];
        const city = String(settings.city || '').trim();
        const r = Math.random();
        if (city && r < 0.3) return `${base} ${city}`;
        if (r < 0.8) return `${base} ${WL_MODIFIERS[Math.floor(Math.random() * WL_MODIFIERS.length)]}`;
        return base;
    }

    function wlPickPersonal() {
        const all = wlGetLib().words;
        if (!all.length) return '';
        const seen = wlGetSeen();
        const fresh = all.filter(x => !seen[wlNorm(x.w)]);
        const pool = fresh.length ? fresh : all;
        const top = pool.slice(0, Math.max(8, Math.ceil(pool.length * 0.4)));
        const arr = (Math.random() < 0.7) ? top : pool;
        return arr[Math.floor(Math.random() * arr.length)].w;
    }

    async function wlPickBlend() {
        const base = wlPickPersonal() || wlTopicQuery();
        if (!base) return '';
        const city = String(settings.city || '').trim();
        if (city && !base.includes(city) && Math.random() < 0.25) return `${base} ${city}`;
        if (Math.random() < 0.2) {
            const hot = String(await getHotQuery() || '').split(' ')[0];
            if (hot && hot.length <= 8 && !base.includes(hot)) return `${base} ${hot}`;
        }
        const mod = WL_MODIFIERS[Math.floor(Math.random() * WL_MODIFIERS.length)];
        return base.includes(mod) ? base : `${base} ${mod}`;
    }

    // 统一入口：主题链式搜索（v1.7.12）——围绕当日主题生成搜索词，禁止跨主题跳词
    async function pickQuery() {
        const q = await pickQueryThemed();
        if (q) wlMarkSeen(q);   // 记录已用过的词，30 天内不重复
        return q;
    }

    async function pickQueryRaw() {
        const mode = settings.wordMode || 'auto';
        if (mode === 'hot') return await getHotQuery();
        if (mode === 'topic') return wlTopicQuery();
        if (mode === 'lib' && !wlGetLib().words.length) return await getHotQuery();

        const eff = wlEffectiveMix();
        const total = Math.max(1, eff.p + eff.b + eff.h);
        const x = Math.random() * total;
        let q = '';
        if (x < eff.p) q = wlPickPersonal();
        else if (x < eff.p + eff.b) q = await wlPickBlend();
        if (!q) q = await getHotQuery();
        return q;
    }

    /* =========================================================================
     * 🔗 主题链式搜索（v1.7.12 安全整改）
     * -------------------------------------------------------------------------
     * 防封作用：废弃「每次随机跨主题跳词」（一会数码一会美食，明显不像真人）。
     * 真人搜索通常是「围绕一个需求连续检索」。因此：
     *   ① 每次启动搜索任务，先随机抽 1–2 个话题包作为「当日主题」，当天固定复用；
     *   ② 之后所有搜索词都围绕当日主题生成（主题词 + 修饰/城市 + 逐词轮询），
     *      保证连续搜索的语义相关性；
     *   ③ 个人词库优先匹配当日主题（词库里的词若命中主题关键词则优先用），
     *      禁止跨主题随机跳词。
     * ========================================================================= */
    const DAILY_TOPIC_KEY = 'mr_daily_topics';
    // 主题内的搜索词轮询游标（内存态，保证同一主题内不重复）
    let themedCursor = {};

    // 读取/设定当日主题（1–2 个话题包 key）
    function getDailyTopics() {
        try {
            const raw = gv(DAILY_TOPIC_KEY, '');
            if (!raw) return null;
            const o = JSON.parse(raw);
            if (o && o.date === getDateHyphen() && Array.isArray(o.keys) && o.keys.length) return o.keys;
        } catch (e) { }
        return null;
    }

    function ensureDailyTopics() {
        let keys = getDailyTopics();
        if (keys) return keys;
        // 当天第一次：随机抽 1–2 个话题包
        const pool = (settings.topics && settings.topics.length)
            ? settings.topics.filter(k => TOPIC_PACKS[k])
            : Object.keys(TOPIC_PACKS);
        if (!pool.length) return [];
        const shuffled = [...pool].sort(() => Math.random() - 0.5);
        const n = Math.random() < 0.5 ? 1 : 2;
        keys = shuffled.slice(0, n);
        try { gs(DAILY_TOPIC_KEY, JSON.stringify({ date: getDateHyphen(), keys })); } catch (e) { }
        const labels = keys.map(k => TOPIC_PACKS[k]?.label || k).join('、');
        log(`🎯 今日搜索主题：${labels}（当日固定，后续搜索词均围绕该主题）`);
        return keys;
    }

    // 判断一个词是否命中某主题（主题词的汉字子串相交即算相关）
    function wordHitTopic(word, pack) {
        if (!pack || !word) return false;
        const w = String(word);
        // 主题词里的「核心词」（去掉空格拆分），只要有一个命中即可
        for (const tw of pack.words) {
            const parts = tw.split(/\s+/).filter(s => s.length >= 2);
            for (const part of parts) {
                if (w.includes(part) || part.includes(w)) return true;
            }
        }
        return false;
    }

    // 从个人词库中优先挑「匹配当日主题」的词
    function pickThemedPersonal(topics) {
        const all = wlGetLib().words;
        if (!all.length) return '';
        const packs = topics.map(k => TOPIC_PACKS[k]).filter(Boolean);
        const seen = wlGetSeen();
        const themed = all.filter(x => packs.some(pk => wordHitTopic(x.w, pk)));
        const pool = (themed.length ? themed : all).filter(x => !seen[wlNorm(x.w)]);
        const usable = pool.length ? pool : (themed.length ? themed : all);
        const top = usable.slice(0, Math.max(8, Math.ceil(usable.length * 0.4)));
        const arr = (Math.random() < 0.7) ? top : usable;
        return arr.length ? arr[Math.floor(Math.random() * arr.length)].w : '';
    }

    // 核心：围绕当日主题生成一条搜索词
    async function pickThemedQuery(topics) {
        const packs = topics.map(k => TOPIC_PACKS[k]).filter(Boolean);
        if (!packs.length) return await getHotQuery(); // 没抽到主题（异常）才回退热搜

        // 汇总当日主题的所有词，按轮询游标取（避免同一主题内反复用同一个词）
        const allWords = [];
        for (const pk of packs) allWords.push(...pk.words);
        if (!allWords.length) return await getHotQuery();

        const key = topics.join(',');
        let idx = themedCursor[key] || 0;
        // 打乱一次顺序，让轮询更自然（每次启动主题时 shuffle）
        if (!themedCursor['_seq_' + key]) {
            themedCursor['_seq_' + key] = [...allWords].sort(() => Math.random() - 0.5);
        }
        const seq = themedCursor['_seq_' + key];
        const base = seq[idx % seq.length];
        themedCursor[key] = (idx + 1) % seq.length;

        const city = String(settings.city || '').trim();
        const r = Math.random();
        if (city && r < 0.3) return `${base} ${city}`;
        if (r < 0.8) return `${base} ${WL_MODIFIERS[Math.floor(Math.random() * WL_MODIFIERS.length)]}`;
        return base;
    }

    // 改造后的统一入口：主题链式优先，个人词库仅「匹配主题」时才参与
    async function pickQueryThemed() {
        const topics = ensureDailyTopics();
        const mode = settings.wordMode || 'auto';
        // 用户显式选了「仅热搜」或「仅话题」且无当日主题时，走原逻辑兜底
        if (mode === 'hot') return await getHotQuery();
        if (!topics.length) return await pickQueryRaw();

        // 有当日主题：一定比例用「个人词库里匹配主题的词」，其余用主题词
        const usePersonal = Math.random() < 0.35; // 35% 概率尝试个人词库（且需命中主题）
        if (usePersonal) {
            const pw = pickThemedPersonal(topics);
            if (pw) return pw;
        }
        return await pickThemedQuery(topics);
    }

    const DEFAULT_SETTINGS = {
        searchMode: 'page', // 搜索方式：page（真实打开搜索结果页）/ api（后台请求，不跳页）
        searchDevice: 'auto', // 搜索端：auto（跟随设备）/ pc / mobile
        deviceModel: 'auto',  // 手机端机型：auto / generic / xiaomi15 ...
        ratio: 80,         // 每日额度使用比例（%）；v1.7.14 起默认 80（可在设置里自行调整）
        minDelay: 2,       // 两次搜索间隔下限（分钟）
        maxDelay: 6,       // 两次搜索间隔上限（分钟）
        batchSize: 0,      // 每批搜索次数，0 = 不分批
        batchGap: 60,      // 批次间隔（分钟）
        pauseInterval: 5,  // 每 N 次触发一次暂停；1.7.11 起默认 5（原来是 10）
        pauseMinutes: 15,  // 暂停分钟数
        clickResult: true, // 搜索后按概率点开一条结果；v1.7.14 起默认开启（更像真人，见 clickResultRate）
        stayMin: 8,        // 结果页停留下限（秒）
        stayMax: 20,       // 结果页停留上限（秒）
        readMin: 1,        // 两篇阅读间隔下限（分钟）
        readMax: 2,        // 两篇阅读间隔上限（分钟）
        // 🆕 1.6.0：搜索词拟真
        typoLevel: 'normal', // 模糊搜索强度：off / light / normal / heavy
        fuzzyPinyin: true,   // 模糊音：zh→z、ch→c、sh→s、h→f、n→l 等
        pinyinQuery: true,   // 允许整词拼音（腾讯 → tenxun）
        typing: true,        // 逐字输入（真实页面模式下像人一样一个字一个字敲）
        // 🆕 1.7.0：个人词库
        wordMode: 'auto',    // 词库模式：auto（有词库用词库，无则话题）/ lib / topic / hot
        mixP: 70,            // 配比：个人原词（%）
        mixB: 20,            // 配比：个人词 + 修饰混搭（%）
        mixH: 10,            // 配比：纯热搜（%）
        topics: [],          // 话题包（无历史记录时用）
        city: ''             // 所在地（可留空）
    };

    const clampNum = (v, min, max, def) => {
        const n = Number(v);
        if (!isFinite(n)) return def;
        return Math.min(max, Math.max(min, Math.round(n)));
    };

    // v1.7.14：保留一位小数的数值限制。
    // 用途：搜索间隔可以设成「下限 2.5 分钟」，暂停可以设成「14.3 分钟」。
    // 只有整数的间隔容易形成 2/3/4 这种整数档位，真人不会是整点搜。
    const clampFloat = (v, min, max, def) => {
        const n = Number(v);
        if (!isFinite(n)) return def;
        const r = Math.round(n * 10) / 10;
        return Math.min(max, Math.max(min, r));
    };

    function normalizeSettings(s) {
        const out = {};
        // ===== 安全整改（v1.7.12）：搜索模式强制「真实页面」=====
        // 防封作用：后台 API 直发是机器人最明显特征；真实页面自带 Cookie/Referer/时间戳。
        // 「api」选项在设置面板已隐藏，此处兜底：即便旧配置里是 api，也强制回到 page。
        out.searchMode = 'page';
        // ===== 安全整改（v1.7.12）：搜索端强制跟随浏览器真实环境 =====
        // 防封作用：不再用手机 UA + Client Hints 伪装移动端身份（会与真实设备指纹矛盾）。
        // 移动端计分完全依赖浏览器本身的 User-Agent / 触屏特征，脚本不再干预。
        out.searchDevice = 'auto';
        out.deviceModel = DEVICE_PROFILES[s.deviceModel] ? s.deviceModel : 'auto';
        // ===== v1.7.14：额度默认 80%，上限放宽到 80% =====
        // 用户要求：默认按 80% 跑，且允许自己在设置里调整。
        // 仍保留 80% 硬上限 —— 满额 100% 冲刺是最典型的刷分特征，不建议。
        out.ratio = clampNum(s.ratio, 10, 80, 80);
        // v1.7.14：间隔类参数保留一位小数（2.5、4.8 这种都能存住）
        out.minDelay = clampFloat(s.minDelay, 1, 60, 2);
        out.maxDelay = clampFloat(s.maxDelay, out.minDelay, 240, 6);
        out.batchSize = clampNum(s.batchSize, 0, 100, 0);
        out.batchGap = clampFloat(s.batchGap, 0, 720, 60);
        out.pauseInterval = clampNum(s.pauseInterval, 3, 100, 5);
        out.pauseMinutes = clampFloat(s.pauseMinutes, 1, 180, 15);
        out.clickResult = s.clickResult !== false; // v1.7.14：默认开启（仅在 undefined 时补 true）
        out.stayMin = clampNum(s.stayMin, 0, 120, 8);
        out.stayMax = clampNum(s.stayMax, out.stayMin, 180, 20);
        out.readMin = clampNum(s.readMin, 1, 60, 1);
        out.readMax = clampNum(s.readMax, out.readMin, 120, 2);
        // 🆕 1.6.0 拟真：字段缺失时用默认值（老用户升级后自动生效，其它设置不丢）
        out.typoLevel = ['off', 'light', 'normal', 'heavy'].includes(s.typoLevel) ? s.typoLevel : 'normal';
        out.fuzzyPinyin = s.fuzzyPinyin !== false;
        out.pinyinQuery = s.pinyinQuery !== false;
        out.typing = s.typing !== false;
        // 🆕 1.7.0 个人词库：字段缺失时用默认值（老配置升级后自动生效）
        out.wordMode = ['auto', 'lib', 'topic', 'hot'].includes(s.wordMode) ? s.wordMode : 'auto';
        out.mixP = clampNum(s.mixP, 0, 100, 70);
        out.mixB = clampNum(s.mixB, 0, 100, 20);
        out.mixH = clampNum(s.mixH, 0, 100, 10);
        out.topics = Array.isArray(s.topics) ? s.topics.filter(k => TOPIC_PACKS[k]).slice(0, 12) : [];
        out.city = String(s.city || '').trim().slice(0, 12);
        out.v = SETTINGS_VER;
        return out;
    }

    const SETTINGS_VER = 4; // 2=间隔单位为分钟；3=1.7.11 防封默认值；4=1.7.14 额度80%+默认点结果

    // 1.7.11：老配置升级到 v3 时是否被「按住」过（只用于弹一条提示）
    let SETTINGS_MIGRATED_V3 = false;

    function loadSettings() {
        let raw = {};
        try { raw = gv('mr_settings', {}) || {}; } catch (e) { }
        const rawVer = Number(raw && raw.v) || 0;
        // 旧版（1.3.0 及以前）保存的间隔是「秒」，直接沿用会变成几十分钟/小时，故重置这几个间隔字段
        if (rawVer < 2) {
            delete raw.minDelay;
            delete raw.maxDelay;
            delete raw.readMin;
            delete raw.readMax;
        }
        // 1.7.11：从旧版本升上来时，把强度压到新的防封默认值以内。
        // 只降不升 —— 用户自己调得比默认更保守的，原样保留。
        if (rawVer >= 1 && rawVer < 3) {
            let changed = false;
            if (Number(raw.ratio) > 40) { raw.ratio = 40; changed = true; }
            if (Number(raw.pauseInterval) > 5) { raw.pauseInterval = 5; changed = true; }
            if (raw.clickResult !== false) { raw.clickResult = false; changed = true; }
            SETTINGS_MIGRATED_V3 = changed;
        }
        // v1.7.14：老配置统一升到新默认 —— 额度 80%、默认点开搜索结果。
        // 只处理 v3 及更早的配置；升到 v4 之后用户自己改的值不会再被动。
        if (rawVer >= 1 && rawVer < 4) {
            raw.ratio = 80;
            raw.clickResult = true;
        }
        return normalizeSettings(Object.assign({}, DEFAULT_SETTINGS, raw));
    }

    let settings = loadSettings();

    function saveSettings(patch) {
        settings = normalizeSettings(Object.assign({}, settings, patch || {}, { v: SETTINGS_VER }));
        try { gs('mr_settings', settings); } catch (e) { }
        return settings;
    }

    // 从搜索结果页面里找一条真实结果链接（模拟“点开结果”用）
    function pickResultUrl(html) {
        try {
            const links = [];
            const re = /<h2[^>]*>\s*<a[^>]+href="(https?:\/\/[^"]+)"/gi;
            let m;
            while ((m = re.exec(html)) && links.length < 20) {
                links.push(m[1].replace(/&amp;/g, '&'));
            }
            const bad = /^https?:\/\/([a-z0-9-]+\.)*(bing|microsoft|msn|live|office|microsoftonline)\.(com|net|cn)\//i;
            const ok = links.filter(u => !bad.test(u));
            if (ok.length) return ok[Math.floor(Math.random() * Math.min(ok.length, 5))];
        } catch (e) { }
        return '';
    }

    // ========== 状态 ==========
    let state = {
        level: 1, points: 0,
        readRunning: false,
        searchCur: 0, searchMax: 0, // 👈 先给 0，避免 updateData 失败时算出 NaN 目标
        // v1.7.8 起：把「平台确认的积分」与「本地估算的待确认积分」分开存（v1.7.9 修正清零规则）
        //   searchConfirmed —— 只能由 updateData() 用服务器读数写入，界面主数字只认它
        //   searchPending   —— 已上报、有 HTTP 响应、但平台还没确认的估算分；
        //                      只有「服务器读数真的增加」时才按增量冲销，读数不变则保留
        //   lastSyncOk      —— 最近一次是否拿到有效读数；false 时界面显示 ⚠️
        //   searchUnconfirmedStreak —— 连续几次「读数没变但仍有待确认」，用于止损
        searchConfirmed: 0, searchPending: 0, lastSyncOk: true, searchFailStreak: 0,
        searchUnconfirmedStreak: 0,
        // v1.7.10：记录上一次解析失败的原因，仅用于「同一原因只提示一次」，避免刷屏
        lastSyncReason: '', lastReadReason: '',
        pcCur: 0, pcMax: 0,
        mobileCur: 0, mobileMax: 0,
        promosTotal: 0, promosDone: 0,
        todayCur: -1, todayMax: 0, // 今日积分（对应必应 App 的「今日积分 66/120」），-1 表示未取到
        signDone: false, signPoints: -1,
        readCur: 0, readMax: 0,
        readConfirmed: 0, readPending: 0, // 阅读：已确认 / 待确认（同样只按实际增量冲销）
        running: false,
        busyCount: 0, // 👈 补上此初始化
        accessToken: null,
        accessTokenExpiresAt: 0,
        searchToken: null,
        authPending: false,
        updating: false,
        updatingPromise: null,
        // 新增：搜索进度和暂停状态
        searchCount: 0,           // 当前搜索计数（用于暂停判断）
        isPaused: false,          // 是否处于暂停状态
        pauseEndTime: 0,          // 暂停结束时间戳
        countdownStartTime: 0,    // 倒计时开始时间（精确计时）
        countdownDuration: 0,     // 倒计时总时长
        manualPaused: false,      // 手动暂停
        pausePromise: null,
        pauseResolver: null,
        nightBlocked: false,      // v1.7.12：凌晨 2:00-6:00 休眠时段，禁用所有自动任务
        apiTodayCount: 0          // v1.7.12：API 模式当日已搜索次数（限 15 次）
    };
    let dashboard = null;
    let loginCookie = '';

    /* =========================================================================
     * ⛔ v1.7.11 风控熔断（Circuit Breaker）
     * -------------------------------------------------------------------------
     * 原则：**服务端说「停」，就真的停**，而不是换个姿势继续发。
     *   触发条件：HTTP 401 / 403 / 429，或响应体里出现验证码 / 人机校验 / 账号受限
     * 命中之后：
     *   ① running / allRunning / readRunning 全部置 false
     *   ② 真实页面搜索循环关掉，不再跳下一页
     *   ③ 之后所有请求直接拒绝，不再自动重试
     *   ④ 页面顶部红色警告条 + 一次系统弹窗
     * 只有用户手动点「解除」才恢复 —— 不自动恢复，避免半夜无人时反复撞墙。
     * ========================================================================= */
    const BREAKER_STATUS = [401, 403, 429];

    // 只在「非搜索结果页」的响应体里扫这些词：搜索页 HTML 出现 blocked 这类词概率太高，
    // 那一类只按状态码判断，避免误停。
    const BREAKER_KEYWORDS = [
        /captcha/i,
        /challenge/i,
        /unusual/i,                                  // v1.7.12：unusual 单独出现也拦（原来只认 unusual activity）
        /verify\s+(you\s+are\s+human|that\s+you)/i,
        /account\s+(has\s+been\s+)?(locked|suspended|restricted)/i,
        /(has\s+been\s+|is\s+)?(locked|suspended|blocked)/i, // v1.7.12：裸 locked / suspended / blocked 都拦
        /\bblocked\b/i
    ];

    const BREAKER_TEXT = {
        unauthorized: '登录状态失效（HTTP 401）',
        forbidden: '请求被拒绝（HTTP 403）',
        'rate-limit': '请求过于频繁（HTTP 429）',
        challenge: '服务器要求人机验证'
    };

    const MR_BREAKER = { on: false, at: 0, kind: '', detail: '', url: '', alerted: false };

    function isBreakerOn() { return MR_BREAKER.on; }

    // 搜索结果页只按状态码判断，不扫正文
    function isSearchHtmlUrl(url) {
        const u = String(url || '');
        return /\/search\?/i.test(u) || /\/search\/?$/i.test(u);
    }

    function matchBreakerKeyword(body) {
        const t = String(body || '');
        if (!t) return '';
        const head = t.length > 30000 ? t.slice(0, 30000) : t;
        for (const re of BREAKER_KEYWORDS) {
            const m = head.match(re);
            if (m) return m[0];
        }
        return '';
    }

    /**
     * 每次拿到响应都过一遍（gmRequest / gmRequestEx 都会调）。
     * 返回 true 表示「已熔断，调用方应立即放弃本次及后续操作」。
     */
    function inspectHttpForBreaker(status, body, url) {
        const s = Number(status) || 0;
        if (BREAKER_STATUS.includes(s)) {
            tripBreaker(s === 401 ? 'unauthorized' : (s === 403 ? 'forbidden' : 'rate-limit'), `HTTP ${s}`, url);
            return true;
        }
        if (MR_BREAKER.on) return true;
        if (isSearchHtmlUrl(url)) return false;
        const hit = matchBreakerKeyword(body);
        if (hit) { tripBreaker('challenge', `响应含「${hit}」`, url); return true; }
        return false;
    }

    // 全局硬停：所有循环标记一次性关掉，并清掉真实页面搜索的接力状态
    function stopEverything() {
        try { state.running = false; } catch (e) { }
        try { state.allRunning = false; } catch (e) { }
        try { state.readRunning = false; } catch (e) { }
        try { state.manualPaused = false; } catch (e) { }
        try { finishPageLoop(''); } catch (e) { }
        try { clearPageLoop(); } catch (e) { }
        try { resetSearchButton(); } catch (e) { }
        try { updateAllButton(); } catch (e) { }
    }

    function tripBreaker(kind, detail, url) {
        if (MR_BREAKER.on) return;
        MR_BREAKER.on = true;
        MR_BREAKER.at = Date.now();
        MR_BREAKER.kind = kind || 'unknown';
        MR_BREAKER.detail = detail || '';
        MR_BREAKER.url = url || '';

        stopEverything();

        const why = `${BREAKER_TEXT[MR_BREAKER.kind] || MR_BREAKER.kind}${MR_BREAKER.detail ? '，' + MR_BREAKER.detail : ''}`;
        try { log('⛔⛔ 触发微软风控信号：' + why); } catch (e) { }
        try { log('🛑 已全局停止：搜索 / 阅读 / 活动全部中断，且不会自动重试'); } catch (e) { }
        try { log('👉 请立刻到 rewards.bing.com 手动确认账号状态（是否要求验证、是否还能兑换）'); } catch (e) { }
        try { console.warn('[Rewards] 风控熔断:', why, MR_BREAKER.url); } catch (e) { }

        showBreakerBanner(why);

        // 只弹一次系统对话框；alert 会阻塞线程 —— 这里就是要「不让人无感继续」
        if (!MR_BREAKER.alerted) {
            MR_BREAKER.alerted = true;
            try {
                alert('⚠️ 触发微软风控验证，已紧急停止，请立即手动处理！\n\n原因：' + why
                    + '\n\n脚本已停止全部请求，不会自动重试。请先到 rewards.bing.com 确认账号状态，处理完再在页面顶部点「解除」。');
            } catch (e) { }
        }
        try { render(); } catch (e) { }
    }

    // 顶部警告条（纯内联样式，不动主 CSS）
    function showBreakerBanner(why) {
        try {
            if (document.getElementById('mr-breaker-bar')) return;
            const bar = document.createElement('div');
            bar.id = 'mr-breaker-bar';
            bar.setAttribute('style', 'position:fixed;left:8px;right:8px;top:calc(env(safe-area-inset-top,0px) + 8px);z-index:2147483000;'
                + 'background:#fff1f0;border:1px solid #d83b01;border-radius:16px;padding:12px 14px;color:#8a1c00;'
                + 'font-size:13px;line-height:1.55;box-shadow:0 10px 30px rgba(0,0,0,.2);'
                + 'font-family:-apple-system,BlinkMacSystemFont,"Segoe UI","PingFang SC",sans-serif');

            const h = document.createElement('div');
            h.setAttribute('style', 'font-weight:700;font-size:14px');
            h.textContent = '⛔ 触发微软风控验证，已紧急停止';
            bar.appendChild(h);

            const p1 = document.createElement('div');
            p1.setAttribute('style', 'margin-top:4px');
            p1.textContent = '原因：' + why;
            bar.appendChild(p1);

            const p2 = document.createElement('div');
            p2.setAttribute('style', 'margin-top:4px;color:#a33');
            p2.textContent = '已停止全部搜索 / 阅读 / 活动请求，不会自动重试。请先到 rewards.bing.com 确认账号状态。';
            bar.appendChild(p2);

            const row = document.createElement('div');
            row.setAttribute('style', 'display:flex;gap:8px;margin-top:10px');

            const b1 = document.createElement('button');
            b1.textContent = '我已确认，解除';
            b1.setAttribute('style', 'flex:1;height:36px;border-radius:12px;border:1px solid #d83b01;background:#d83b01;color:#fff;font-size:13px;font-weight:600');
            b1.onclick = () => disarmBreaker(true);

            const b2 = document.createElement('button');
            b2.textContent = '先收起';
            b2.setAttribute('style', 'height:36px;padding:0 14px;border-radius:12px;border:1px solid #e0b4a8;background:transparent;color:#8a1c00;font-size:13px');
            b2.onclick = () => { try { bar.remove(); } catch (e) { } };

            row.appendChild(b1);
            row.appendChild(b2);
            bar.appendChild(row);
            document.body.appendChild(bar);
        } catch (e) { }
    }

    // 解除熔断只能手动：确认一次后恢复请求能力（不自动重启任何任务）
    function disarmBreaker(needConfirm) {
        if (!MR_BREAKER.on) return;
        if (needConfirm) {
            let ok = true;
            try { ok = confirm('确认已在 rewards.bing.com 手动核对过账号状态？\n\n解除后脚本可以重新发请求，但不会自动开始任务。'); } catch (e) { }
            if (!ok) return;
        }
        MR_BREAKER.on = false;
        MR_BREAKER.alerted = false;
        try { const b = document.getElementById('mr-breaker-bar'); if (b) b.remove(); } catch (e) { }
        try { log('✅ 熔断已解除。任务不会自动开始，需要时请自己点按钮（建议先只跑签到，确认账号正常再加搜索）'); } catch (e) { }
    }

    // 每个任务入口统一用这个挡一下：熔断中就直接返回，不发任何请求
    function breakerBlocked() {
        if (!MR_BREAKER.on) return false;
        try { log('⛔ 已处于熔断状态，不会发请求。请先到 rewards.bing.com 确认账号状态，再点页面顶部「解除」'); } catch (e) { }
        try { if (!document.getElementById('mr-breaker-bar')) showBreakerBanner(BREAKER_TEXT[MR_BREAKER.kind] || '风控熔断'); } catch (e) { }
        return true;
    }

    // ===== P3 夜间休眠（v1.7.12）=====
    // 北京时间凌晨 2:00-6:00 是机器人最容易暴露的时段，真人这时候几乎不会刷积分。
    // 一旦处于该时段：禁用所有自动按钮，任务入口统一拦截，日志明确提示。
    function inNightWindow() {
        try {
            const h = new Date().getHours(); // 本地时间；脚本面向国内用户，按北京时间处理
            return h >= 2 && h < 6;
        } catch (e) { return false; }
    }

    function nightBlocked() {
        if (!state.nightBlocked) return false;
        try { log('🌙 当前为凌晨休眠时段（02:00-06:00），为避免异常行为，所有自动任务已禁用，请于早上 8 点后手动运行'); } catch (e) { }
        return true;
    }

    function applyNightBlock() {
        const on = inNightWindow();
        state.nightBlocked = on;
        const btns = [nodes.btnSign, nodes.btnRead, nodes.btnPromo, nodes.btnSearch, nodes.btnAll];
        for (const b of btns) {
            try { if (b) b.disabled = on; } catch (e) { }
        }
        if (on) {
            try { log('🌙 当前为凌晨休眠时段，为避免异常行为，请于早上 8 点后手动运行'); } catch (e) { }
        }
        return on;
    }


    // ========== 进度保存/恢复 ==========
    const STORAGE_KEY = 'mr_search_progress';

    function saveProgress() {
        const today = getDateHyphen();
        const data = {
            date: today,
            searchCount: state.searchCount
        };
        gs(STORAGE_KEY, JSON.stringify(data));
    }

    function loadProgress() {
    try {
        const saved = gv(STORAGE_KEY);
        if (!saved) return null;
        const data = JSON.parse(saved);
        if (data.date === getDateHyphen()) {
            state.searchCount = data.searchCount || 0;
            return data;
        } else {
            resetProgress(); // 👈 跨天重置本地和内存中的计数
        }
    } catch (e) { }
    return null;
}

    async function withAccessTokenRequest(requestFn) {
        // 1. 获取 Token，若为空尝试强制刷新一次
        let token = await getAccessToken();
        if (!token) {
            console.warn('[Rewards] 初始 Token 为空，尝试强制刷新...');
            token = await getAccessToken({ forceRefresh: true });
        }

        if (!token) {
            log('⚠️ 未获取到活动Token，请确认登录状态或刷新页面重试');
            return null;
        }

        try {
            const res = await requestFn(token);

            // 2. 检查返回结果字符串（适配 gmRequest 正常返回 401 错误 JSON 的情况）
            if (typeof res === 'string' && (res.includes('invalid_token') || res.includes('Unauthorized') || res.includes('\"code\":401'))) {
                console.warn('[Rewards] 响应中检测到 Token 失效，重新获取 Token 中...');
                state.accessToken = null;
                state.accessTokenExpiresAt = 0;
                token = await getAccessToken({ forceRefresh: true });
                if (token) {
                    return await requestFn(token);
                }
            }
            return res;
        } catch (e) {
            // 3. 捕获网络层抛出的 401 异常
            const is401 = (e && e.status === 401) || 
                          (e && e.responseStatus === 401) || 
                          (e && e.message && (e.message.includes('401') || e.message.includes('Unauthorized')));

            if (is401) {
                console.warn('[Rewards] 捕获到网络层 401 异常，重新获取 Token 中...');
                state.accessToken = null;
                state.accessTokenExpiresAt = 0;
                token = await getAccessToken({ forceRefresh: true });
                if (token) {
                    return await requestFn(token);
                }
            }
            throw e;
        }
    }
    function resetProgress() {
        state.searchCount = 0;
        gs(STORAGE_KEY, '');
    }

    // ========== 工具函数 ==========
    const sleep = ms => new Promise(r => setTimeout(r, ms));
    const randomPick = arr => arr[Math.floor(Math.random() * arr.length)];
    const randomRange = (min, max) => Math.floor(Math.random() * (max - min + 1)) + min;
    // 移动端修复：部分安卓 WebView / 非安全上下文没有 crypto.randomUUID
    const uuid = () => {
        try {
            if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
                return crypto.randomUUID();
            }
        } catch (e) { }
        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
            const r = Math.random() * 16 | 0;
            const v = c === 'x' ? r : (r & 0x3 | 0x8);
            return v.toString(16);
        });
    };

    const getDateStr = () => {
        const d = new Date();
        return `${d.getMonth() + 1}/${d.getDate()}/${d.getFullYear()}`;
    };
    const getDateHyphen = () => {
        const d = new Date();
        return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
    };
    const isJSON = s => { try { JSON.parse(s); return true; } catch { return false; } };
    const generateDapiId = () => {
    const raw1 = uuid().replace(/-/g, '');
    const raw2 = uuid().replace(/-/g, '');
    return (raw1 + raw2).slice(0, 56);
    };

    /* =========================================================================
     * 🆕 1.7.6 请求层：GM_xmlhttpRequest → GM.xmlHttpRequest → fetch
     * -------------------------------------------------------------------------
     * iOS 上的「用户脚本 / Stay」只提供 Promise 版 GM.xmlHttpRequest，没有旧式
     * GM_xmlhttpRequest。旧代码直接调用会抛 ReferenceError（面板能开、数据全空、
     * 日志停在「正在获取活动 Token...」）。这里做三级兜底：
     *   1) 桌面 / 安卓脚本猫：GM_xmlhttpRequest（同步回调）
     *   2) iOS 扩展：GM.xmlHttpRequest（返回 Promise）
     *   3) 都没有：fetch（同域可用，跨域失败就降级，至少不炸）
     * 顺带把超时 20s → 8s、重试 2 次 → 1 次：死请求最长等待从约 63s 降到约 17s。
     * ========================================================================= */
    const REQ_MODE = (() => {
        try { if (typeof GM_xmlhttpRequest === 'function') return 'gm'; } catch (e) { }
        try { if (typeof GM !== 'undefined' && GM && typeof GM.xmlHttpRequest === 'function') return 'gmp'; } catch (e) { }
        try { if (typeof fetch === 'function') return 'fetch'; } catch (e) { }
        return 'none';
    })();

    // 单次请求，统一返回 { status, responseText, finalUrl, responseHeaders }
    function rawRequest(opts) {
        const timeout = Number(opts.timeout) || 8000;

        // v1.7.11：熔断期间一个请求都不发（含重试），直接拒绝
        if (MR_BREAKER.on) {
            return Promise.reject(Object.assign(new Error('Breaker Active'), { status: 0, breaker: true }));
        }

        if (REQ_MODE === 'gm' || REQ_MODE === 'gmp') {
            return new Promise((resolve, reject) => {
                let settled = false;
                let timer = 0;
                const finish = (fn, arg) => {
                    if (settled) return;
                    settled = true;
                    if (timer) clearTimeout(timer);
                    fn(arg);
                };
                const api = Object.assign({}, opts, {
                    timeout,
                    onload: r => finish(resolve, r),
                    onerror: () => finish(reject, Object.assign(new Error('Network Error'), { status: 0 })),
                    ontimeout: () => finish(reject, Object.assign(new Error('Timeout'), { status: 0 }))
                });
                try {
                    const fn = REQ_MODE === 'gm' ? GM_xmlhttpRequest : GM.xmlHttpRequest.bind(GM);
                    const ret = fn(api);
                    // Promise 版：回调不一定被调用，用返回值再兜一层
                    if (ret && typeof ret.then === 'function') {
                        ret.then(r => finish(resolve, r), e => finish(reject, e));
                    }
                } catch (e) {
                    finish(reject, e);
                }
                // 双保险：扩展既不走回调也不返回 Promise 时不至于永久挂住
                timer = setTimeout(() => finish(reject, Object.assign(new Error('Timeout'), { status: 0 })), timeout + 800);
            });
        }

        // fetch 兜底（Safari 扩展两者都没有时）
        return new Promise((resolve, reject) => {
            if (REQ_MODE !== 'fetch') return reject(Object.assign(new Error('Network Error'), { status: 0 }));
            const ctrl = typeof AbortController === 'function' ? new AbortController() : null;
            const timer = ctrl ? setTimeout(() => ctrl.abort(), timeout) : 0;
            const headers = Object.assign({}, opts.headers || {});
            // v1.7.8：只有确实需要带 Cookie 时才 include，避免向热搜等第三方接口附带凭据
            const needCookie = !!(headers.Cookie || headers.cookie);
            delete headers.Cookie; delete headers.cookie; // fetch 不允许改 Cookie，交给 credentials
            const init = {
                method: opts.method || 'GET',
                headers,
                credentials: needCookie ? 'include' : 'omit',
                redirect: 'follow'
            };
            if (ctrl) init.signal = ctrl.signal;
            if (opts.data != null) init.body = opts.data;
            fetch(opts.url, init).then(async r => {
                const text = await r.text();
                if (timer) clearTimeout(timer);
                resolve({ status: r.status, responseText: text, finalUrl: r.url || opts.url, responseHeaders: '' });
            }).catch(e => {
                if (timer) clearTimeout(timer);
                const isAbort = e && (e.name === 'AbortError');
                reject(Object.assign(new Error(isAbort ? 'Timeout' : 'Network Error'), { status: 0 }));
            });
        });
    }

    // 带重试的请求封装（调用方式与旧版完全一致）
    async function gmRequest(options) {
        const retries = options.retries ?? 1;
        const retryDelay = options.retryDelay ?? 600;
        const timeout = Number(options.timeout) || 8000;
        let attempt = 0;

        const shouldRetry = (err) => {
            if (MR_BREAKER.on || err?.breaker) return false; // 熔断后一律不重试
            const status = err?.status || 0;
            return status === 0 || status === 429 || status >= 500 || err?.message === 'Timeout';
        };

        while (true) {
            try {
                const xhr = await rawRequest(Object.assign({}, options, { timeout }));
                // v1.7.11：先过熔断检查 —— 401/403/429 或验证页特征命中后立刻放弃本次与后续请求
                if (inspectHttpForBreaker(xhr.status, xhr.responseText, options.url)) {
                    const bErr = new Error(`Breaker Active (HTTP ${xhr.status})`);
                    bErr.status = xhr.status;
                    bErr.breaker = true;
                    throw bErr;
                }
                if (xhr.status >= 200 && xhr.status < 300) {
                    return options.returnUrl ? xhr.finalUrl : xhr.responseText;
                }
                if (xhr.status >= 300 && xhr.status < 400) {
                    if (options.returnUrl) return xhr.finalUrl;
                    const loc = (xhr.responseHeaders || '').match(/Location:\s*(.*?)\s*[\r\n]/i);
                    return loc ? loc[1] : xhr.responseText;
                }
                const err = new Error(`HTTP ${xhr.status}`);
                err.status = xhr.status;
                err.responseText = xhr.responseText;
                err.finalUrl = xhr.finalUrl;
                throw err;
            } catch (e) {
                if (attempt >= retries || !shouldRetry(e)) throw e;
                const delay = retryDelay * Math.pow(2, attempt);
                attempt++;
                await sleep(delay + randomRange(0, 250));
            }
        }
    }

    /* =========================================================================
     * 🆕 1.7.10 请求结果分级（P0：HTTP 3xx 不得被当成成功）
     * -------------------------------------------------------------------------
     * 原来的 gmRequest() 对 300–399 也会 return 响应内容，调用方只要「没抛异常」
     * 就以为成功了 —— 一条 302（跳登录/跳验证页）会被算成「上报成功」，直接虚增积分。
     *
     * 这里新增 gmRequestEx()：**不抛异常**，而是返回带状态分级的结果对象。
     *   2xx  → ok=true,  httpClass='2xx'   （只代表「收到成功状态码」，不代表平台认账）
     *   3xx  → ok=false, httpClass='3xx'   （重定向，不是我们要的响应）
     *   4xx  → ok=false, httpClass='4xx'
     *   5xx  → ok=false, httpClass='5xx'
     *   超时 → ok=false, level='timeout'
     *   网络异常 → ok=false, level='network-error'
     *
     * 为了不影响签到 / 授权 / 数据读取等既有调用，gmRequest() 原样保留不动，
     * 只有搜索上报这一处改用 gmRequestEx()。
     * ========================================================================= */
    function classifyHttpStatus(status) {
        const s = Number(status);
        if (!Number.isFinite(s) || s <= 0) return 'no-response'; // 0 = 没拿到有效响应
        if (s >= 200 && s < 300) return '2xx';
        if (s >= 300 && s < 400) return '3xx';
        if (s >= 400 && s < 500) return '4xx';
        if (s >= 500 && s < 600) return '5xx';
        return 'other';
    }

    async function gmRequestEx(options) {
        const retries = options.retries ?? 1;
        const retryDelay = options.retryDelay ?? 600;
        const timeout = Number(options.timeout) || 8000;
        let attempt = 0;
        let lastTry = { status: 0, httpClass: 'no-response', text: '', finalUrl: '', level: 'network-error' };

        const retryable = (cls, status) => cls === 'no-response' || status === 429 || cls === '5xx';

        while (true) {
            try {
                const xhr = await rawRequest(Object.assign({}, options, { timeout }));
                const status = Number(xhr && xhr.status) || 0;
                const cls = classifyHttpStatus(status);
                const meta = {
                    status,
                    httpClass: cls,
                    text: typeof xhr?.responseText === 'string' ? xhr.responseText : '',
                    finalUrl: xhr?.finalUrl || options.url,
                    responseHeaders: xhr?.responseHeaders || '',
                    error: ''
                };
                // v1.7.11：熔断检查优先于一切分级 —— 命中即返回，绝不重试
                if (inspectHttpForBreaker(status, meta.text, options.url)) {
                    meta.error = 'Breaker Active';
                    return Object.assign({ ok: false, level: 'breaker' }, meta);
                }
                if (cls === '2xx') return Object.assign({ ok: true, level: 'response-2xx' }, meta);

                if (cls === '3xx') {
                    // 重定向单独成一级：调用方必须显式区分，不能当成功
                    const loc = String(meta.responseHeaders || '').match(/Location:\s*(.*?)\s*[\r\n]/i);
                    meta.redirectUrl = loc ? loc[1] : '';
                    lastTry = Object.assign({ ok: false, level: 'redirect' }, meta);
                    return lastTry; // 3xx 不重试：再重试也是同一条重定向
                }

                meta.error = cls === 'no-response' ? 'No Response' : `HTTP ${status}`;
                lastTry = Object.assign({ ok: false, level: cls === 'no-response' ? 'network-error' : 'http-error' }, meta);
                if (attempt >= retries || !retryable(cls, status)) return lastTry;
            } catch (e) {
                const isTimeout = e && e.message === 'Timeout';
                lastTry = {
                    // v1.7.11：熔断期间被 rawRequest 直接拒绝的，归为 'breaker'，日志里才说得清楚
                    ok: false, level: (e && e.breaker) ? 'breaker' : (isTimeout ? 'timeout' : 'network-error'),
                    status: 0, httpClass: 'no-response', text: '', finalUrl: options.url,
                    responseHeaders: '', error: (e && e.message) || 'Network Error'
                };
                if (MR_BREAKER.on) return lastTry; // 已熔断：不再重试
                if (attempt >= retries) return lastTry;
            }
            const delay = retryDelay * Math.pow(2, attempt);
            attempt++;
            await sleep(delay + randomRange(0, 250));
        }
    }

    // 只有「2xx」才算收到了成功状态码；其余一切（3xx/4xx/5xx/超时/网络异常）都不算
    function isHttp2xx(res) {
        return !!(res && res.ok === true && res.httpClass === '2xx' && res.status >= 200 && res.status < 300);
    }

    // 把 gmRequestEx 的结果翻译成给上层看的一句话（日志用，不参与判定）
    function describeHttpResult(res) {
        if (!res) return '没有结果';
        if (isHttp2xx(res)) return `HTTP ${res.status}`;
        if (res.level === 'breaker') return `风控熔断（HTTP ${res.status}）`;
        if (res.level === 'redirect') return `HTTP ${res.status} 重定向${res.redirectUrl ? ' → ' + res.redirectUrl : ''}`;
        if (res.level === 'http-error') return `HTTP ${res.status}`;
        if (res.level === 'timeout') return '请求超时';
        return '网络异常';
    }

    /* =========================================================================
     * 🧠 搜索词拟真：模糊搜索 / 错字 / 整词拼音 / 模糊音（1.6.0 新增）
     * -------------------------------------------------------------------------
     * 目的：不要每次都搜「一模一样」的整词，而是像真人用手机输入法敲出来的：
     *   · 同音或形近错字：腾讯 → 腾迅
     *   · 数字尾缀：腾讯 → 腾讯1
     *   · 整词拼音：腾讯 → tengxun / tenxun（配合模糊音）
     *   · 漏字 / 叠字 / 中间多打一个空格
     * 只影响「搜什么」，不影响计分规则；打错字的搜索一样正常计分。
     * ========================================================================= */

    // 常用字拼音表（紧凑写法：汉字+拼音），覆盖热搜标题里的高频字
    const PY_RAW = '天tian 气qi 预yu 报bao 台tai 风feng 暴bao 雨yu 雪xue 温wen 度du 寒han 潮chao 冷leng 热re 高gao 低di ' +
        '今jin 日ri 明ming 年nian 月yue 春chun 夏xia 秋qiu 冬dong 周zhou 星xing 期qi 上shang 下xia 午wu 时shi 点dian 分fen 秒miao ' +
        '新xin 闻wen 头tou 条tiao 事shi 件jian 消xiao 息xi 最zui 近jin 发fa 生sheng 播bo 出chu 版ban 页ye 网wang 站zhan ' +
        '股gu 票piao 市shi 场chang 涨zhang 跌die 停ting 板ban 基ji 金jin 债zhai 券quan 投tou 资zi 收shou 益yi 价jia 格ge 元yuan 万wan 亿yi 指zhi 数shu ' +
        '科ke 技ji 手shou 机ji 电dian 脑nao 芯xin 片pian 华hua 为wei 小xiao 米mi 苹ping 果guo 三san 荣rong 耀yao 红hong 一yi 加jia 魅mei 族zu ' +
        '系xi 统tong 布bu 会hui 鸿hong 蒙meng 安an 卓zhuo 应ying 用yong 软ruan 络luo 本ben 更geng ' +
        '智zhi 能neng 大da 模mo 型xing 算suan 法fa 器qi 人ren 据ju 云yun 块kuai 训xun 练lian ' +
        '演yan 唱chang 视shi 剧ju 综zong 艺yi 娱yu 乐le 游you 戏xi 王wang 者zhe 原yuan 神shen 赛sai 音yin 歌ge 曲qu 明ming 名ming ' +
        '体ti 育yu 足zu 球qiu 篮lan 奥ao 运yun 乒ping 乓pang 羽yu 毛mao 冠guan 军jun 联lian 队dui 员yuan 俱ju 部bu 半ban 决jue 亚ya 洲zhou 杯bei ' +
        '旅lv 攻gong 略lve 景jing 门men 铁tie 火huo 车che 飞fei 酒jiu 店dian 假jia 客ke 速su ' +
        '美mei 食shi 谱pu 菜cai 餐can 厅ting 锅guo 奶nai 茶cha 好hao 吃chi ' +
        '经jing 济ji 政zheng 策ce 房fang 地di 产chan 油you 工gong 资zi 就jiu 业ye 考kao 研yan 公gong 务wu 学xue 校xiao 教jiao 育yu 银yin 行hang 利li 率lv 降jiang 息xi 通tong 胀zhang ' +
        '腾teng 讯xun 阿a 里li 巴ba 抖dou 快kuai 微wei 信xin 博bo 知zhi 乎hu 百bai 搜sou 索suo 中zhong 国guo 北bei 京jing 海hai 广guang 州zhou 深shen 圳zhen ' +
        '特te 斯si 拉la 比bi 迪di 鹏peng 理li 想xiang 来lai 界jie 蔚wei 问wen 源yuan 池chi 充chong 汽qi 商shang 品pin 架jia 多duo 个ge 平ping ' +
        '香xiang 港gang 澳ao 美mei 本ben 韩han 欧ou 俄e 罗luo 兰lan 乌wu 克ke ' +
        '死si 亡wang 伤shang 救jiu 援yuan 故gu 警jing 方fang 通tong 防fang 灾zai 震zhen 洪hong 水shui ' +
        '官guan 链lian 接jie 载zai 装zhuang 免mian 费fei 单dan 藏cang 享xiang 评ping 论lun 赞zan 转zhuan 浏liu 览lan ' +
        '双shuang 十shi 二er 六liu 七qi 八ba 九jiu 五wu 四si 零ling 百bai 千qian 购gou 买mai 卖mai 折zhe 扣kou 优you 惠hui';

    const PY_DICT = Object.create(null);
    PY_RAW.split(/\s+/).forEach(p => {
        if (!p || p.length < 2) return;
        const ch = p.charAt(0);
        const py = p.slice(1);
        if (!PY_DICT[ch]) PY_DICT[ch] = py;
    });

    // 同音 / 形近错字表（左 = 正确字，右 = 真人手滑会打成的字）
    const HOMO = {
        '讯': '迅', '腾': '滕', '视': '是', '事': '世', '新': '心', '闻': '文', '报': '抱', '天': '添', '气': '汽',
        '股': '古', '票': '漂', '场': '厂', '涨': '掌', '跌': '叠', '华': '花', '为': '位', '米': '迷', '果': '过',
        '星': '行', '机': '鸡', '苹': '平', '荣': '容', '耀': '要', '一': '衣', '加': '家', '智': '只', '能': '耐',
        '数': '属', '据': '句', '电': '店', '影': '映', '剧': '聚', '游': '有', '戏': '系', '赛': '塞', '球': '求',
        '队': '对', '门': '们', '高': '搞', '铁': '帖', '火': '伙', '车': '彻', '飞': '非', '假': '架', '期': '奇',
        '美': '每', '食': '十', '菜': '才', '餐': '参', '锅': '过', '奶': '乃', '茶': '查', '经': '精', '济': '剂',
        '政': '正', '策': '册', '房': '防', '地': '的', '产': '铲', '油': '由', '价': '架', '工': '公', '资': '字',
        '就': '旧', '业': '叶', '考': '烤', '研': '严', '务': '物', '员': '圆', '学': '雪', '校': '笑', '教': '交',
        '育': '雨', '阿': '啊', '里': '李', '巴': '八', '抖': '斗', '音': '因', '快': '块', '微': '威', '信': '心',
        '博': '播', '知': '织', '乎': '呼', '百': '白', '度': '杜', '搜': '收', '索': '锁', '中': '钟', '国': '果',
        '北': '被', '京': '经', '上': '尚', '海': '害', '广': '光', '州': '周', '深': '身', '圳': '阵', '商': '伤',
        '品': '拼', '架': '价', '平': '苹', '台': '抬'
    };

    // 各档位的「打错概率」
    const TYPO_RATE = { off: 0, light: 0.2, normal: 0.35, heavy: 0.55 };

    // 单音节模糊音替换（南方口音常见：zh→z、ch→c、sh→s、h→f、n→l、r→l、前后鼻音互换）
    function fuzzySyllable(sy) {
        let s = String(sy || '');
        s = s.replace(/^zh/, 'z').replace(/^ch/, 'c').replace(/^sh/, 's');
        s = s.replace(/^h/, 'f');
        s = s.replace(/^n/, 'l');
        s = s.replace(/^r/, 'l');
        if (Math.random() < 0.5) {
            s = s.replace(/ang$/, 'an').replace(/eng$/, 'en').replace(/ing$/, 'in');
        } else {
            s = s.replace(/an$/, 'ang').replace(/en$/, 'eng').replace(/in$/, 'ing');
        }
        return s;
    }

    // 把词转成拼音；coverage = 词库能覆盖的汉字比例（太低就不用拼音形式，避免半中半英）
    function toPinyin(text, fuzzy) {
        let out = '';
        let known = 0, total = 0;
        for (const ch of String(text || '')) {
            if (/[\u4e00-\u9fa5]/.test(ch)) {
                total++;
                const py = PY_DICT[ch];
                if (py) { known++; out += fuzzy ? fuzzySyllable(py) : py; }
                else out += ch;
            } else {
                out += ch;
            }
        }
        return { text: out, coverage: total ? known / total : 0 };
    }

    // 随机「少打一个字母」，模拟拼音没打完就回车
    function dropOneLetter(s) {
        const arr = [...s];
        const cand = [];
        for (let i = 1; i < arr.length - 1; i++) {
            if (/[a-z]/i.test(arr[i])) cand.push(i);
        }
        if (!cand.length) return s;
        arr.splice(randomPick(cand), 1);
        return arr.join('');
    }

    // 生成一个「像人打错」的变体；返回空串表示这次不做变体
    function makeTypoVariant(q) {
        const chars = [...q];
        const cnIdx = chars.map((c, i) => (/[\u4e00-\u9fa5]/.test(c) ? i : -1)).filter(i => i >= 0);
        if (!cnIdx.length) return '';

        const kinds = [];
        if (cnIdx.some(i => HOMO[chars[i]])) kinds.push('homo', 'homo', 'homo');
        kinds.push('suffix', 'suffix'); // 腾讯1 / 腾讯2 —— 真人做重复搜索的常见做法
        if (settings.pinyinQuery) {
            const py = toPinyin(q, settings.fuzzyPinyin);
            if (py.coverage >= 0.6) kinds.push('pinyin', 'pinyin');
        }
        if (cnIdx.length >= 4) kinds.push('drop');
        if (cnIdx.length >= 3) kinds.push('dup', 'space');

        const kind = randomPick(kinds);
        if (kind === 'homo') {
            const pool = cnIdx.filter(i => HOMO[chars[i]]);
            if (!pool.length) return '';
            const i = randomPick(pool);
            chars[i] = HOMO[chars[i]];
            return chars.join('');
        }
        if (kind === 'suffix') {
            return q + randomPick(['1', '2', '3', '0', '11', '1.0']);
        }
        if (kind === 'pinyin') {
            let py = toPinyin(q, settings.fuzzyPinyin).text;
            if (settings.fuzzyPinyin && Math.random() < 0.45) py = dropOneLetter(py);
            if (!/[a-z]/i.test(py)) return '';
            return py;
        }
        if (kind === 'drop') {
            const i = randomPick(cnIdx);
            const out = chars.filter((_, k) => k !== i).join('').trim();
            return out.length >= 2 ? out : '';
        }
        if (kind === 'dup') {
            const i = randomPick(cnIdx);
            const out = chars.slice();
            out.splice(i + 1, 0, chars[i]);
            return out.join('');
        }
        if (kind === 'space') {
            const i = randomPick(cnIdx.slice(1));
            return chars.slice(0, i).join('') + ' ' + chars.slice(i).join('');
        }
        return '';
    }

    // 统一入口：按设置的强度决定这次要不要「打错」
    function humanizeQuery(raw) {
        const q = String(raw || '').trim();
        if (!q) return q;
        const level = settings.typoLevel || 'normal';
        const rate = TYPO_RATE[level] ?? 0.35;
        if (!rate || Math.random() > rate) return q;
        const v = makeTypoVariant(q);
        return v || q;
    }

    // 给日志用的说明文字
    function humanizeNote() {
        const lv = { off: '关闭', light: '轻度 20%', normal: '中度 35%', heavy: '重度 55%' }[settings.typoLevel] || '中度 35%';
        const extra = [];
        if (settings.fuzzyPinyin) extra.push('模糊音');
        if (settings.pinyinQuery) extra.push('整词拼音');
        if (settings.typing) extra.push('逐字输入');
        return `🎭 搜索词拟真：${lv}${extra.length ? '（' + extra.join(' / ') + '）' : ''}`;
    }

    // 获取热搜词（支持多源自动切换）
    async function getHotQuery() {
        // 打乱API顺序，随机选择
        const apis = [...CONFIG.hotApis].sort(() => Math.random() - 0.5);

        for (const api of apis) {
            try {
                const src = randomPick(api.sources);
                const res = await gmRequest({ method: 'GET', url: api.url + src, timeout: 8000 });
                const data = JSON.parse(res);
                if (data.code === 200 && data.data?.length) {
                    const title = randomPick(data.data).title || '';
                    // 随机截取长度，更自然
                    const len = randomRange(8, 25);
                    return title.substring(0, len);
                }
            } catch { /* 尝试下一个API */ }
        }
        // 所有API都失败，使用本地关键词
        return `${randomPick(CONFIG.keywords)} ${Math.random().toString(36).slice(2, 6)}`;
    }

    // Cookie 管理
    // v1.7.6：判断当前环境到底有没有读 Cookie 的能力（iOS 的「用户脚本 / Stay」都没有）
    function hasCookieApi() {
        try {
            return typeof GM_cookie !== 'undefined' && GM_cookie && typeof GM_cookie.list === 'function';
        } catch (e) { return false; }
    }

    function getCookies(url) {
    return new Promise(resolve => {
        try {
            if (typeof GM_cookie === 'undefined') {
                console.warn('[Rewards] GM_cookie不存在');
                return resolve(fallbackCookies(url));
            }

            GM_cookie.list({ url }, cookies => {
                if (!cookies || !cookies.length) {
                    console.warn('[Rewards] Cookie为空:', url);
                    return resolve(fallbackCookies(url));
                }

                const str = cookies
                    .map(c => `${c.name}=${c.value}`)
                    .join('; ');

                //console.log('[Rewards] Cookie长度:', str.length, url);
                resolve(str);
            });

        } catch (e) {
            console.error('[Rewards] Cookie获取失败', e);
            resolve(fallbackCookies(url));
        }
    });
}

    // 移动端修复：安卓 ScriptCat 下 GM_cookie 可能被系统限制，
    // 当脚本正运行在该域名页面上时，用 document.cookie 兜底（拿不到 HttpOnly，但比空 Cookie 好）
    function fallbackCookies(url) {
        try {
            const u = new URL(url);
            if (u.hostname !== location.hostname) return '';
            const dc = document.cookie || '';
            if (dc) console.warn('[Rewards] 使用 document.cookie 兜底:', u.hostname);
            return dc;
        } catch (e) { return ''; }
    }

    function deleteCookie(name, host = 'bing.com') {
        return new Promise(resolve => {
            try {
                // 修复：GM_cookie 是对象，删除方法为 GM_cookie.delete（原写法 GM_cookie('delete') 会直接报错）
                if (typeof GM_cookie !== 'undefined' && GM_cookie && typeof GM_cookie.delete === 'function') {
                    GM_cookie.delete({ url: `https://${host}`, name }, () => resolve());
                } else {
                    resolve();
                }
            } catch (e) { resolve(); }
        });
    }

    // ========== 样式 (极简版) ==========
    addStyle(`
        /* =========================================================================
         * 🍎 v1.7.3 Apple 风格 UI（Liquid Glass）
         * -------------------------------------------------------------------------
         * 依据 Apple HIG：Materials / Typography / Motion / Accessibility
         * · 玻璃只给「控件层」(悬浮球 + 面板外壳)，面板内部用实色，保证文字可读
         * · 字号/行高/点击目标取 iOS 默认档：正文 15–17px、点击目标 44px
         * · 动画全部 140–340ms，按压即反馈（:active 立刻 scale），可打断
         * · 提供深色 / 降低透明度 / 减少动效 / 增强对比四套系统偏好适配
         * ========================================================================= */

        /* ---------- 语义化颜色（浅色） ---------- */
        #mr-panel, .mr-modal-box {
            --mr-fg: #1c1c1e;
            --mr-fg2: #3c3c43;
            --mr-fg3: #8e8e93;
            --mr-sep: rgba(60, 60, 67, 0.14);
            --mr-fill: rgba(120, 120, 128, 0.12);
            --mr-fill2: rgba(120, 120, 128, 0.22);
            --mr-track: rgba(120, 120, 128, 0.20);
            /* v1.7.5：面板外层只留极薄玻璃，内容层实底——宿主网页不再从面板里透出 */
            --mr-glass: rgba(255, 255, 255, 0.94);
            --mr-solid: #ffffff;
            --mr-ball: rgba(255, 255, 255, 0.46);
            --mr-glass-hi: rgba(255, 255, 255, 0.82);
            --mr-surface: rgba(255, 255, 255, 0.96);
            --mr-card: rgba(255, 255, 255, 0.72);
            --mr-blue: #007aff;
            --mr-blue-weak: rgba(0, 122, 255, 0.12);
            --mr-green: #34c759;
            --mr-orange: #ff9500;
            --mr-rim: rgba(255, 255, 255, 0.7);
            --mr-shadow: 0 18px 48px rgba(0, 0, 0, 0.18), 0 2px 8px rgba(0, 0, 0, 0.07);
            --mr-spring: cubic-bezier(0.22, 1.16, 0.36, 1);
            --mr-vh: 100vh;
            /* 同心圆角（v1.7.5）：全部由外层圆角减内距算出，改外层就自动同步，避免手写不同步
             * 外框 28 · 内容内距 16 → 卡片 12；控件内距 18 → 10；三者圆心重合、弧线平行 */
            /* v1.7.7：外框 28 → 40。同心圆角要「看起来」同心，内圆角必须大于留白：
             *   内圆角 12 < 留白 16 时，内角显得又小又方，和外框大弧线对不上（用户实测反馈）；
             *   改 40 后内角 24 > 留白 16，两条弧线才像 iPhone「屏幕在边框里」那样平行收进去。
             * 约束：圆角 ≤ 留白 + 30 左右，否则四角会切到内容；此处顶栏内距 13px 仍安全。 */
            --mr-r-outer: 40px;
            --mr-pad: 16px;
            --mr-r-card: calc(var(--mr-r-outer) - var(--mr-pad));
            --mr-r-ctl: calc(var(--mr-r-outer) - 26px);
            /* iOS 17「设置」图标：灰色渐变 + 白色齿轮 */
            --mr-icon-a: #a2a2a8;
            --mr-icon-b: #58585e;
            /* v1.7.6：触屏端（无实时模糊）用的实底球面 */
            --mr-ball-solid: linear-gradient(160deg, #ffffff 0%, #eff0f4 100%);
        }

        /* ---------- 外壳 ---------- */
        #mr-panel {
            position: fixed;
            /* v1.7.6：底部 20 → 30px，避开 iOS 17 Safari 底部浮动工具栏（否则看得见、点不到） */
            bottom: calc(30px + env(safe-area-inset-bottom, 0px));
            right: calc(20px + env(safe-area-inset-right, 0px));
            z-index: 2147483647;
            box-sizing: border-box;
            font-family: -apple-system, BlinkMacSystemFont, "SF Pro Text", "SF Pro Display",
                "PingFang SC", "Helvetica Neue", "Segoe UI", Roboto, "Microsoft YaHei", sans-serif;
            font-size: 15px;
            line-height: 1.42;
            color: var(--mr-fg);
            max-width: calc(100vw - 24px);
            max-height: calc(var(--mr-vh, 100vh) - 40px);
            -webkit-font-smoothing: antialiased;
            -webkit-tap-highlight-color: transparent;
        }

        /* ---------- 收起状态：Liquid Glass 圆球 ---------- */
        #mr-panel.collapsed {
            width: 48px;
            height: 48px;
            border-radius: 50%;
            cursor: pointer;
            display: flex;
            align-items: center;
            justify-content: center;
            color: var(--mr-blue);
            background:
                radial-gradient(120% 110% at 30% 14%, var(--mr-glass-hi) 0%, rgba(255, 255, 255, 0) 44%),
                var(--mr-ball);
            -webkit-backdrop-filter: blur(10px);
            backdrop-filter: blur(10px);
            box-shadow:
                inset 0 1px 1px rgba(255, 255, 255, 0.85),
                inset 0 -2px 3px rgba(255, 255, 255, 0.28),
                0 0 0 1px var(--mr-rim),
                0 8px 22px rgba(0, 0, 0, 0.16),
                0 2px 6px rgba(0, 0, 0, 0.08);
            transition: transform 340ms var(--mr-spring), box-shadow 200ms ease-out;
            -webkit-touch-callout: none;
            -webkit-user-select: none;
            user-select: none;
            touch-action: manipulation;
        }
        /* 高光（玻璃边缘反光） */
        #mr-panel.collapsed::before {
            content: "";
            position: absolute;
            inset: 0;
            border-radius: 50%;
            pointer-events: none;
            background: linear-gradient(150deg, rgba(255, 255, 255, 0.62), rgba(255, 255, 255, 0) 42%);
            opacity: 0.85;
        }
        #mr-panel.collapsed:active { transform: scale(0.92); }
        /* v1.7.6：pointerdown 立刻加 .mr-press → 手指按下的那一帧就有反馈，不等 340ms 弹簧 */
        #mr-panel.collapsed.mr-press {
            transform: scale(0.92);
            transition-duration: 90ms;
        }
        @media (hover: hover) and (pointer: fine) {
            #mr-panel.collapsed:hover { transform: scale(1.05); }
        }
        /* v1.7.6：球心的礼盒图标不接收触摸命中。
         * WebKit 判断「这一下算不算点击」看的是命中节点，<svg> 不是可点击元素，
         * 会吞掉落在图标上的点击 → 表现为「点球没反应」。 */
        #mr-panel.collapsed > svg { pointer-events: none; }
        #mr-panel.collapsed > svg { width: 25px; height: 25px; fill: currentColor; position: relative; pointer-events: none; }
        #mr-panel.collapsed #mr-container { display: none; }

        /* ---------- 展开状态：玻璃面板 ---------- */
        #mr-panel:not(.collapsed) {
            width: 320px;
            border-radius: var(--mr-r-outer);
            overflow: hidden;
            background: var(--mr-glass);
            -webkit-backdrop-filter: blur(10px);
            backdrop-filter: blur(10px);
            box-shadow: inset 0 0 0 1px var(--mr-rim), var(--mr-shadow);
        }
        #mr-panel:not(.collapsed) > svg { display: none; }

        #mr-header {
            padding: 13px 14px 11px 16px;
            display: flex;
            align-items: center;
            gap: 4px;
            border-bottom: 1px solid var(--mr-sep);
        }
        #mr-title {
            flex: 1 1 auto;
            min-width: 0;
            font-size: 17px;
            font-weight: 600;
            letter-spacing: -0.2px;
            color: var(--mr-fg);
            white-space: nowrap;
            overflow: hidden;
            text-overflow: ellipsis;
        }
        #mr-set, #mr-close {
            flex: 0 0 auto;
            display: flex;
            align-items: center;
            justify-content: center;
            width: 32px;
            height: 32px;
            border-radius: 50%;
            color: var(--mr-fg3);
            line-height: 1;
            cursor: pointer;
            transition: background 160ms ease-out, color 160ms ease-out;
        }
        #mr-set { width: 30px; height: 30px; border-radius: 9px; }
        #mr-set svg { width: 26px; height: 26px; display: block; filter: drop-shadow(0 1px 1px rgba(0, 0, 0, 0.14)); }
        #mr-set:active { background: transparent; transform: scale(0.9); }
        #mr-close { font-size: 19px; }
        #mr-close:active { background: var(--mr-fill2); color: var(--mr-fg2); }

        /* ---------- 主体 ---------- */
        #mr-container {
            max-height: calc(var(--mr-vh, 100vh) - 52px);
            overflow-y: auto;
            overflow-x: hidden;
            -webkit-overflow-scrolling: touch;
            overscroll-behavior: contain;
            /* v1.7.6：日志每追加一行不再牵动整块面板重绘 */
            contain: layout paint;
            /* v1.7.5：内容层实底 + 继承外框圆角 → 与外框同圆心，网页内容不再透出 */
            background: var(--mr-solid);
            border-radius: inherit;
        }
        #mr-body { padding: 12px 16px 16px; }

        .mr-row {
            display: flex;
            align-items: baseline;
            justify-content: space-between;
            gap: 8px;
            font-size: 15px;
            color: var(--mr-fg2);
            margin: 9px 0 7px;
        }
        .mr-row:first-of-type { margin-top: 2px; }
        .mr-val { font-weight: 600; color: var(--mr-fg); }
        #mr-points { color: var(--mr-fg); font-weight: 600; }
        #mr-level, #mr-pc, #mr-read, #mr-today, #mr-sign-status, #mr-points {
            font-variant-numeric: tabular-nums;
            letter-spacing: 0;
        }
        /* 覆盖 HTML 里的旧配色，统一到系统色 */
        .mr-row > span[style*="d83b01"] { color: var(--mr-fg) !important; }
        #mr-today { color: var(--mr-green) !important; }
        #mr-today-bar { background: var(--mr-green) !important; }
        #mr-read-bar { background: var(--mr-orange) !important; }

        .mr-progress-bg {
            height: 8px;
            background: var(--mr-track);
            border-radius: 999px;
            overflow: hidden;
            margin: 0 0 12px;
        }
        .mr-bar {
            height: 100%;
            width: 0;
            background: var(--mr-blue);
            border-radius: 999px;
            transition: width 320ms var(--mr-spring);
        }

        /* ---------- 按钮 ---------- */
        .mr-grid { display: grid; grid-template-columns: 1fr 1fr; gap: 8px; margin-top: 14px; }
        .mr-btn {
            display: inline-flex;
            align-items: center;
            justify-content: center;
            gap: 4px;
            min-height: 40px;
            padding: 9px 12px;
            border: none;
            /* v1.7.7：按钮不再跟面板圆角联动（40-16=24 放在 40px 高的按钮上太圆），
             * 用控件圆角 14，和输入框、下拉框一致 */
            border-radius: var(--mr-r-ctl);
            background: var(--mr-fill);
            color: var(--mr-fg);
            font-size: 15px;
            font-weight: 500;
            font-family: inherit;
            cursor: pointer;
            touch-action: manipulation;
            -webkit-tap-highlight-color: transparent;
            transition: transform 140ms ease-out, background 160ms ease-out, filter 160ms ease-out;
        }
        .mr-btn:active { transform: scale(0.96); background: var(--mr-fill2); }
        @media (hover: hover) and (pointer: fine) {
            .mr-btn:hover { background: var(--mr-fill2); }
        }
        .mr-full {
            grid-column: span 2;
            min-height: 46px;
            background: var(--mr-blue);
            color: #fff;
            font-weight: 600;
        }
        .mr-full:active { background: var(--mr-blue); filter: brightness(0.92); }

        /* ---------- 日志 ---------- */
        #mr-log {
            margin-top: 12px;
            height: 84px;
            padding: 10px 12px;
            border-radius: var(--mr-r-card);
            background: var(--mr-fill);
            color: var(--mr-fg3);
            font: 11px/1.6 ui-monospace, SFMono-Regular, "SF Mono", Menlo, Consolas, monospace;
            overflow-y: auto;
            -webkit-overflow-scrolling: touch;
            overscroll-behavior: contain;
            word-break: break-all;
        }
        /* 空日志占位，避免一大块空白 */
        #mr-log:empty::before {
            content: "暂无日志";
            color: var(--mr-fg3);
            opacity: 0.75;
        }

        /* ---------- 授权框 ---------- */
        #mr-auth {
            margin: 0 0 12px;
            padding: 12px;
            border-radius: var(--mr-r-card);
            background: rgba(255, 149, 0, 0.12);
            box-shadow: inset 0 0 0 1px rgba(255, 149, 0, 0.3);
        }
        #mr-auth > div:first-child { font-size: 15px; font-weight: 600; margin-bottom: 8px !important; }
        #mr-auth .mr-btn { margin-top: 6px; }
        .mr-input {
            width: 100%;
            padding: 9px 10px;
            margin: 6px 0;
            font-size: 16px;
            font-family: inherit;
            border-radius: var(--mr-r-ctl);
            border: 1px solid var(--mr-sep);
            background: var(--mr-surface);
            color: var(--mr-fg);
            box-sizing: border-box;
        }

        /* ---------- 设置覆盖层 ---------- */
        #mr-settings {
            display: none;
            position: absolute;
            inset: 0;
            padding: 0 var(--mr-pad) var(--mr-pad);
            box-sizing: border-box;
            overflow-y: auto;
            -webkit-overflow-scrolling: touch;
            overscroll-behavior: contain;
            z-index: 20;
            font-size: 13px;
            color: var(--mr-fg);
            border-radius: var(--mr-r-outer);
            background: var(--mr-solid);
        }
        #mr-settings.show { display: block; }

        .mr-set-head {
            display: flex;
            align-items: center;
            justify-content: space-between;
            position: sticky;
            top: 0;
            z-index: 2;
            margin: 0 -16px 10px;
            padding: 14px 16px 10px 16px;
            font-size: 17px;
            font-weight: 600;
            letter-spacing: -0.2px;
            background: var(--mr-surface);
            border-bottom: 1px solid var(--mr-sep);
        }
        #mr-set-close {
            display: flex;
            align-items: center;
            justify-content: center;
            width: 32px;
            height: 32px;
            border-radius: 50%;
            color: var(--mr-fg3) !important;
            font-size: 19px !important;
        }
        #mr-set-close:active { background: var(--mr-fill2); }

        /* 设置卡片（iOS 分组列表观感） */
        .mr-set-item {
            padding: 12px;
            margin-bottom: 10px;
            border-radius: var(--mr-r-card);
            background: var(--mr-card);
            box-shadow: inset 0 0 0 1px var(--mr-sep);
        }
        .mr-set-item > label {
            display: block;
            margin-bottom: 8px;
            font-size: 15px;
            font-weight: 600;
            letter-spacing: -0.1px;
            color: var(--mr-fg);
        }
        .mr-set-item.mr-dim { opacity: 0.5; }
        .mr-set-line {
            display: flex;
            align-items: center;
            flex-wrap: wrap;
            gap: 8px;
            font-size: 13px;
            color: var(--mr-fg2);
        }
        .mr-set-line label {
            display: inline-flex;
            align-items: center;
            gap: 7px;
            color: var(--mr-fg2) !important;
            font-size: 14px;
        }

        .mr-num {
            width: 62px;
            padding: 8px 6px;
            font-size: 16px;
            font-family: inherit;
            text-align: center;
            border-radius: var(--mr-r-ctl);
            border: 1px solid var(--mr-sep);
            background: var(--mr-surface);
            color: var(--mr-fg);
            box-sizing: border-box;
            font-variant-numeric: tabular-nums;
        }
        .mr-txt {
            flex: 1;
            min-width: 0;
            padding: 8px 10px;
            font-size: 16px;
            font-family: inherit;
            border-radius: var(--mr-r-ctl);
            border: 1px solid var(--mr-sep);
            background: var(--mr-surface);
            color: var(--mr-fg);
            box-sizing: border-box;
        }
        .mr-sel {
            flex: 1;
            min-width: 0;
            padding: 10px 30px 10px 12px;
            font-size: 15px;
            font-family: inherit;
            border-radius: var(--mr-r-ctl);
            border: 1px solid var(--mr-sep);
            background-color: var(--mr-surface);
            background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='8' viewBox='0 0 12 8'%3E%3Cpath d='M1 1.2 6 6.2l5-5' fill='none' stroke='%238e8e93' stroke-width='1.8' stroke-linecap='round' stroke-linejoin='round'/%3E%3C/svg%3E");
            background-repeat: no-repeat;
            background-position: right 12px center;
            color: var(--mr-fg);
            box-sizing: border-box;
            -webkit-appearance: none;
            appearance: none;
        }

        /* iOS 风格开关 */
        .mr-set-line input[type="checkbox"] {
            -webkit-appearance: none;
            appearance: none;
            position: relative;
            flex: 0 0 auto;
            width: 51px;
            height: 31px;
            margin: 0;
            border: none;
            border-radius: 999px;
            background: var(--mr-fill2);
            box-sizing: border-box;
            cursor: pointer;
            transition: background 220ms ease-out;
        }
        .mr-set-line input[type="checkbox"]::after {
            content: "";
            position: absolute;
            top: 2px;
            left: 2px;
            width: 27px;
            height: 27px;
            border-radius: 50%;
            background: #fff;
            box-shadow: 0 2px 6px rgba(0, 0, 0, 0.22), 0 0 0 0.5px rgba(0, 0, 0, 0.04);
            transition: transform 280ms var(--mr-spring);
        }
        .mr-set-line input[type="checkbox"]:checked { background: var(--mr-green); }
        .mr-set-line input[type="checkbox"]:checked::after { transform: translateX(20px); }

        /* 导入按钮 + 话题胶囊 */
        .mr-file {
            display: inline-flex;
            align-items: center;
            padding: 9px 14px;
            border-radius: 999px;
            background: var(--mr-blue-weak);
            color: var(--mr-blue) !important;
            font-size: 13px;
            font-weight: 600;
            cursor: pointer;
            white-space: nowrap;
            transition: transform 140ms ease-out, filter 160ms ease-out;
        }
        .mr-file:active { transform: scale(0.96); filter: brightness(0.96); }

        .mr-topic-wrap { display: flex; flex-wrap: wrap; gap: 6px; margin-top: 8px; }
        .mr-chip {
            display: inline-flex;
            align-items: center;
            padding: 7px 12px;
            border-radius: 999px;
            border: 1px solid var(--mr-sep);
            background: var(--mr-surface);
            color: var(--mr-fg2);
            font-size: 13px;
            cursor: pointer;
            user-select: none;
            -webkit-user-select: none;
            touch-action: manipulation;
            transition: transform 140ms ease-out, background 180ms ease-out, color 180ms ease-out, border-color 180ms ease-out;
        }
        .mr-chip:active { transform: scale(0.95); }
        .mr-chip.on {
            background: var(--mr-blue-weak);
            border-color: rgba(0, 122, 255, 0.35);
            color: var(--mr-blue);
            font-weight: 600;
        }

        /* 小号文字按钮（机型「换一款」等） */
        .mr-mini {
            flex: 0 0 auto;
            padding: 9px 12px;
            border: 1px solid var(--mr-sep);
            border-radius: var(--mr-r-ctl);
            background: var(--mr-surface);
            color: var(--mr-blue);
            font-size: 13px;
            font-weight: 600;
            font-family: inherit;
            line-height: 1.2;
            cursor: pointer;
            touch-action: manipulation;
            -webkit-tap-highlight-color: transparent;
            transition: transform 140ms ease-out, background 160ms ease-out;
        }
        .mr-mini:active { transform: scale(0.95); background: var(--mr-fill); }

        .mr-set-head-row {
            display: flex;
            align-items: center;
            justify-content: space-between;
            gap: 8px;
            margin-bottom: 8px;
        }
        .mr-set-head-row > label {
            margin: 0;
            font-size: 15px;
            font-weight: 600;
            letter-spacing: -0.1px;
            color: var(--mr-fg);
        }
        .mr-set-head-row .mr-mini { padding: 6px 10px; font-size: 12.5px; }

        .mr-hint {
            margin-top: 8px;
            font-size: 12px;
            line-height: 1.5;
            color: var(--mr-fg3);
        }

        .mr-set-btns { display: flex; gap: 8px; margin-top: 14px; }
        .mr-set-btns .mr-btn { flex: 1; min-height: 44px; }
        .mr-set-btns .mr-save { background: var(--mr-blue); color: #fff; font-weight: 600; }
        .mr-set-btns .mr-save:active { background: var(--mr-blue); filter: brightness(0.92); }

        /* ---------- 导入预览浮层 ---------- */
        .mr-modal {
            position: fixed;
            inset: 0;
            z-index: 2147483000;
            display: flex;
            align-items: center;
            justify-content: center;
            padding: 16px;
            background: rgba(0, 0, 0, 0.35);
            -webkit-backdrop-filter: blur(6px);
            backdrop-filter: blur(6px);
        }
        .mr-modal-box {
            display: flex;
            flex-direction: column;
            gap: 10px;
            width: 100%;
            max-width: 430px;
            max-height: 82vh;
            padding: 16px;
            border-radius: var(--mr-r-outer);
            background: var(--mr-solid);
            color: var(--mr-fg);
            box-shadow: inset 0 0 0 1px var(--mr-rim), 0 24px 60px rgba(0, 0, 0, 0.3);
            font-family: -apple-system, BlinkMacSystemFont, "SF Pro Text", "PingFang SC", "Helvetica Neue", "Segoe UI", Roboto, sans-serif;
        }
        .mr-modal-title { font-size: 17px; font-weight: 600; letter-spacing: -0.2px; }
        .mr-modal-stat { font-size: 12px; line-height: 1.6; color: var(--mr-fg3); }
        .mr-modal-ta {
            flex: 1;
            min-height: 170px;
            padding: 10px;
            font-size: 16px;
            line-height: 1.6;
            font-family: inherit;
            color: var(--mr-fg);
            background: var(--mr-fill);
            border: 1px solid var(--mr-sep);
            border-radius: var(--mr-r-card);
            resize: vertical;
        }

        /* =========================================================
         * 尺寸适配：手机（触控）/ 平板（iPad）
         * ========================================================= */
        @media (pointer: coarse) {
            /* v1.7.6：触屏端一律关掉实时毛玻璃。
             * iPhone 11 / iPad 上展开与滚动时每帧都要重算整块背景模糊，是
             * 「点开慢 1–3 秒」「iPad 不跟手」的主因；改实底 + 高光后观感几乎不变，
             * 但展开和滚动立刻顺滑。桌面端（(hover:hover) and (pointer:fine)）仍保留模糊。 */
            #mr-panel.collapsed {
                background:
                    radial-gradient(120% 110% at 30% 14%, rgba(255, 255, 255, 0.55) 0%, rgba(255, 255, 255, 0) 46%),
                    var(--mr-ball-solid);
                -webkit-backdrop-filter: none;
                backdrop-filter: none;
            }
            #mr-panel:not(.collapsed) {
                -webkit-backdrop-filter: none;
                backdrop-filter: none;
            }
            .mr-modal {
                -webkit-backdrop-filter: none;
                backdrop-filter: none;
                background: rgba(0, 0, 0, 0.45);
            }
            #mr-panel.collapsed { width: 52px; height: 52px; }
            #mr-panel.collapsed > svg { width: 27px; height: 27px; }
            #mr-panel:not(.collapsed) { width: min(340px, calc(100vw - 20px)); }
            #mr-container { max-height: calc(var(--mr-vh, 100vh) - 30px); }
            #mr-set, #mr-close, #mr-set-close { width: 40px; height: 40px; }
            #mr-set svg { width: 30px; height: 30px; }
            #mr-close, #mr-set-close { font-size: 21px; }
            .mr-btn { min-height: 44px; font-size: 16px; }
            .mr-full { min-height: 48px; font-size: 16px; }
            .mr-row { font-size: 16px; }
            #mr-body { padding: 12px 16px 16px; }
            #mr-log { height: 110px; font-size: 11px; }
            .mr-set-item > label { font-size: 16px; }
            .mr-set-line label { font-size: 15px; }
            .mr-num { width: 66px; min-height: 40px; }
            .mr-txt { min-height: 40px; }
            .mr-sel { min-height: 44px; }
            .mr-hint { font-size: 12.5px; }
            .mr-chip { padding: 8px 14px; font-size: 14px; }
            .mr-file { padding: 10px 16px; font-size: 14px; }
        }
        @media (min-width: 600px) and (pointer: coarse) {
            #mr-panel.collapsed { width: 56px; height: 56px; }
            #mr-panel.collapsed > svg { width: 29px; height: 29px; }
            #mr-panel:not(.collapsed) { width: min(380px, calc(100vw - 32px)); }
        }
        @media (min-width: 900px) and (max-height: 620px) {
            #mr-log { height: 64px; }
            #mr-body { padding: 10px 16px 16px; }
            .mr-grid { margin-top: 10px; gap: 8px; }
        }

        /* =========================================================
         * 系统偏好：深色 / 降低透明度 / 减少动效 / 增强对比
         * ========================================================= */
        @media (prefers-color-scheme: dark) {
            #mr-panel, .mr-modal-box {
                --mr-fg: #f2f2f7;
                --mr-fg2: #d1d1d6;
                --mr-fg3: #98989f;
                --mr-sep: rgba(255, 255, 255, 0.14);
                --mr-fill: rgba(120, 120, 128, 0.24);
                --mr-fill2: rgba(120, 120, 128, 0.4);
                --mr-track: rgba(120, 120, 128, 0.34);
                --mr-glass: rgba(28, 28, 30, 0.94);
                --mr-solid: #1c1c1e;
                --mr-ball: rgba(28, 28, 30, 0.54);
                --mr-glass-hi: rgba(255, 255, 255, 0.20);
                --mr-surface: rgba(28, 28, 30, 0.96);
                --mr-card: rgba(255, 255, 255, 0.06);
                --mr-blue: #0a84ff;
                --mr-blue-weak: rgba(10, 132, 255, 0.22);
                --mr-rim: rgba(255, 255, 255, 0.16);
                --mr-icon-a: #b6b6bc;
                --mr-icon-b: #6c6c72;
                --mr-ball-solid: linear-gradient(160deg, #2c2c2e 0%, #141416 100%);
                --mr-shadow: 0 18px 48px rgba(0, 0, 0, 0.55), 0 2px 8px rgba(0, 0, 0, 0.35);
            }
            #mr-panel.collapsed {
                box-shadow:
                    inset 0 1px 1px rgba(255, 255, 255, 0.28),
                    inset 0 -2px 3px rgba(255, 255, 255, 0.08),
                    0 0 0 1px var(--mr-rim),
                    0 8px 22px rgba(0, 0, 0, 0.45);
            }
            #mr-panel.collapsed::before {
                background: linear-gradient(155deg, rgba(255, 255, 255, 0.22), rgba(255, 255, 255, 0) 46%);
            }
            .mr-set-line input[type="checkbox"]::after { background: #f2f2f7; }
        }
        @media (prefers-reduced-transparency: reduce) {
            #mr-panel, .mr-modal-box, #mr-settings, .mr-modal {
                -webkit-backdrop-filter: none;
                backdrop-filter: none;
            }
            #mr-panel { --mr-glass: #ffffff; --mr-surface: #ffffff; --mr-card: #f2f2f7; }
            .mr-modal { background: rgba(0, 0, 0, 0.55); }
        }
        @media (prefers-reduced-transparency: reduce) and (prefers-color-scheme: dark) {
            #mr-panel { --mr-glass: #1c1c1e; --mr-surface: #1c1c1e; --mr-card: #2c2c2e; }
        }
        @media (prefers-reduced-motion: reduce) {
            #mr-panel, #mr-panel.collapsed, .mr-btn, .mr-chip, .mr-file, .mr-bar,
            .mr-set-line input[type="checkbox"], .mr-set-line input[type="checkbox"]::after {
                transition: none !important;
            }
            #mr-panel.collapsed:active, #mr-panel.collapsed:hover { transform: none; }
            .mr-btn:active, .mr-chip:active, .mr-file:active { transform: none; }
        }
        @media (prefers-contrast: more) {
            #mr-panel {
                --mr-sep: rgba(60, 60, 67, 0.5);
                --mr-fg3: #48484a;
                --mr-fill: rgba(120, 120, 128, 0.2);
            }
            .mr-btn, .mr-chip, .mr-set-item, .mr-sel, .mr-num, .mr-txt, .mr-input {
                box-shadow: inset 0 0 0 1px var(--mr-sep);
            }
            #mr-panel.collapsed { box-shadow: 0 0 0 2px var(--mr-blue), 0 8px 22px rgba(0, 0, 0, 0.2); }
        }
    `);

    // ========== UI 结构 ==========
    const panel = document.createElement('div');
    panel.id = 'mr-panel';
    panel.className = 'collapsed'; // 默认折叠
    // 礼盒 SVG
    const svgIcon = `<svg viewBox="0 0 24 24"><path d="M20 6h-3V4c0-1.1-.9-2-2-2H9c-1.1 0-2 .9-2 2v2H4c-1.1 0-2 .9-2 2v3h2v9c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2v-9h2V8c0-1.1-.9-2-2-2zm-9-2h2v2h-2V4zm0 16H6v-9h5v9zm6 0h-5v-9h5v9zm1.5-11H16V7h2v2zm-4.5 0h-2V7h2v2zm-4.5 0H7V7h2v2zm-3.5 0H4V7h1.5v2z"/></svg>`;

    panel.innerHTML = `
        ${svgIcon}
        <div id="mr-container">
            <div id="mr-header">
                <div id="mr-title"><span>🎁</span> Microsoft Rewards</div>
                <div id="mr-set" title="设置" role="button" aria-label="设置">
                    <svg viewBox="0 0 24 24" aria-hidden="true">
                        <defs>
                            <linearGradient id="mr-set-grad" x1="0" y1="0" x2="0" y2="1">
                                <stop offset="0" style="stop-color:var(--mr-icon-a)"></stop>
                                <stop offset="1" style="stop-color:var(--mr-icon-b)"></stop>
                            </linearGradient>
                        </defs>
                        <rect x="1" y="1" width="22" height="22" rx="6.3" fill="url(#mr-set-grad)"></rect>
                        <g transform="translate(4.6 4.6) scale(0.617)">
                            <path fill="#fff" d="M19.14 12.94c.04-.3.06-.61.06-.94 0-.32-.02-.64-.07-.94l2.03-1.58c.18-.14.23-.41.12-.61l-1.92-3.32c-.12-.22-.37-.29-.59-.22l-2.39.96c-.5-.38-1.03-.7-1.62-.94l-.36-2.54c-.04-.24-.24-.41-.48-.41h-3.84c-.24 0-.43.17-.47.41l-.36 2.54c-.59.24-1.13.57-1.62.94l-2.39-.96c-.22-.08-.47 0-.59.22L2.74 8.87c-.12.21-.08.47.12.61l2.03 1.58c-.05.3-.09.63-.09.94s.02.64.07.94l-2.03 1.58c-.18.14-.23.41-.12.61l1.92 3.32c.12.22.37.29.59.22l2.39-.96c.5.38 1.03.7 1.62.94l.36 2.54c.05.24.24.41.48.41h3.84c.24 0 .44-.17.47-.41l.36-2.54c.59-.24 1.13-.56 1.62-.94l2.39.96c.22.08.47 0 .59-.22l1.92-3.32c.12-.22.07-.47-.12-.61l-2.01-1.58zM12 15.6c-1.98 0-3.6-1.62-3.6-3.6s1.62-3.6 3.6-3.6 3.6 1.62 3.6 3.6-1.62 3.6-3.6 3.6z"></path>
                        </g>
                    </svg>
                </div>
                <div id="mr-close">×</div>
            </div>

            <div id="mr-body">
                <!-- 状态 -->
                <div class="mr-row">
                    <span>等级 <span id="mr-level" style="font-weight:600">-</span></span>
                    <span style="color:#d83b01"><span id="mr-points">0</span> pts</span>
                </div>

                <!-- 今日积分（必应 App 同款：今日已得 / 今日可得分） -->
                <!-- 🆕 v1.7.14 体检区：四个灯，全绿才建议开始跑 -->
                <div id="mr-health" style="margin:2px 0 8px;padding:8px 10px;background:rgba(120,120,128,0.08);border-radius:10px;font-size:12.5px;line-height:1.85"></div>

                <div class="mr-row" id="mr-today-row" style="display:none"><span>📈 今日积分</span><span id="mr-today" style="font-weight:600;color:#107c41">0/0</span></div>
                <div class="mr-progress-bg" id="mr-today-bar-bg" style="display:none"><div class="mr-bar" id="mr-today-bar" style="background:#107c41;width:0%"></div></div>

                <!-- 进度 -->
                <div class="mr-row"><span>🔍 搜索进度</span><span id="mr-pc">0/0</span></div>
                <div class="mr-progress-bg"><div class="mr-bar" id="mr-pc-bar"></div></div>

                <div class="mr-row"><span>📅 每日签到</span><span id="mr-sign-status" style="font-weight:600">未签到</span></div>

                <div class="mr-row"><span>📖 阅读任务</span><span id="mr-read">0/0</span></div>
                <div class="mr-progress-bg"><div class="mr-bar" id="mr-read-bar" style="background:#ff8c00"></div></div>

                <!-- 授权 -->
                <div id="mr-auth" style="display:none">
                    <div style="font-weight:bold;margin-bottom:5px">⚠️ 需授权</div>
                    <button class="mr-btn" id="mr-auth-link" style="width:100%">🔗 获取授权码</button>
                    <input type="text" id="mr-auth-in" class="mr-input" placeholder="粘贴URL...">
                    <button class="mr-btn" id="mr-auth-save" style="width:100%">保存</button>
                </div>

                <!-- 按钮 -->
                <div class="mr-grid">
                    <button id="btn-search" class="mr-btn">🔍 搜索</button>
                    <button id="btn-promo" class="mr-btn">🎯 活动 <span id="val-promo">0/0</span></button>
                    <button id="btn-sign" class="mr-btn">✅ 签到</button>
                    <button id="btn-read" class="mr-btn">📖 阅读</button>
                    <!-- 安全整改（v1.7.12）：移除「一键全部执行」按钮，禁止全自动跑完所有任务。
                         防封作用：一键全跑 = 无人工介入的连续刷分，最易触发风控；现在必须逐个手动点。 -->
                </div>

                <!-- 日志 -->
                <div id="mr-log"></div>
            </div>
        </div>

        <!-- ⚙️ 搜索设置（覆盖层，不改变原界面） -->
        <div id="mr-settings">
            <div class="mr-set-head"><span>搜索 / 阅读设置</span><span id="mr-set-close" style="cursor:pointer;color:#999;font-size:20px;line-height:1">×</span></div>

            <div class="mr-set-item">
                <label>搜索方式</label>
                <div class="mr-set-line">
                    <select id="set-mode" class="mr-sel">
                        <option value="page">真实页面（慢，更自然）</option>
                        <!-- 安全整改（v1.7.12）：后台请求（api）模式已从界面隐藏，防封。
                             开发入口：如需临时恢复，取消下面这行注释即可，但仅限自测、勿长期使用。 -->
                        <!-- <option value="api">后台请求（快，不跳页）</option> -->
                    </select>
                </div>
                <div class="mr-hint">真实页面：每搜一次都会真的打开 Bing 结果页，靠本地记录自动接着搜；期间别关标签页。</div>
            </div>

            <div class="mr-set-item">
                <label>搜索词拟真（模糊搜索）</label>
                <div class="mr-set-line">
                    <select id="set-typo" class="mr-sel">
                        <option value="off">关闭（最稳）</option>
                        <option value="light">轻度（约 20%）</option>
                        <option value="normal">中度（约 35%，推荐）</option>
                        <option value="heavy">重度（约 55%）</option>
                    </select>
                </div>
                <div class="mr-set-line" style="margin-top:6px;gap:12px">
                    <label style="display:flex;align-items:center;gap:5px;color:#555"><input type="checkbox" id="set-fuzzy">模糊音</label>
                    <label style="display:flex;align-items:center;gap:5px;color:#555"><input type="checkbox" id="set-pinyin">整词拼音</label>
                    <label style="display:flex;align-items:center;gap:5px;color:#555"><input type="checkbox" id="set-typing">逐字输入</label>
                </div>
                <div class="mr-hint">模糊搜索 = 偶尔把词打成「腾迅 / 腾讯1 / tenxun」。模糊音 = zh→z、ch→c、sh→s、h→f、n→l、前后鼻音互换。逐字输入 = 在 Bing 搜索框里一个字一个字敲（仅真实页面模式，会自动打错再退格修正）。</div>
            </div>

            <div class="mr-set-item">
                <label>搜索词库（个性化关键词）</label>
                <div class="mr-set-line">
                    <select id="set-wordmode" class="mr-sel">
                        <option value="auto">自动（优先个人词库）</option>
                        <option value="lib">仅个人词库</option>
                        <option value="topic">仅话题包</option>
                        <option value="hot">仅热搜（原版）</option>
                    </select>
                </div>
                <div class="mr-set-line" style="margin-top:6px">
                    <label class="mr-file" for="set-wordfile">📄 导入历史 CSV</label>
                    <input type="file" id="set-wordfile" accept=".csv,.txt,.json,text/csv,text/plain,application/json" style="display:none">
                    <button class="mr-btn" id="mr-word-export">导出词库</button>
                    <button class="mr-btn" id="mr-word-clear">清空</button>
                </div>
                <div class="mr-hint" id="set-wordstat">已存 0 词 · 尚未导入</div>
                <div class="mr-set-line" style="margin-top:6px">
                    <span>个人</span><input type="number" id="set-mixp" class="mr-num" style="width:46px" min="0" max="100" step="5">
                    <span>混搭</span><input type="number" id="set-mixb" class="mr-num" style="width:46px" min="0" max="100" step="5">
                    <span>热搜</span><input type="number" id="set-mixh" class="mr-num" style="width:46px" min="0" max="100" step="5">
                </div>
                <div class="mr-hint" id="set-mixhint">默认 70/20/10：每次搜索按概率抽类别；词库少于 150 条会自动降档。</div>
                <div class="mr-hint" style="margin-top:6px">话题包（没有历史记录也能用，勾 1–5 个）</div>
                <div class="mr-topic-wrap" id="set-topics"></div>
                <div class="mr-set-line" style="margin-top:6px">
                    <span>所在地</span><input type="text" id="set-city" class="mr-txt" maxlength="12" placeholder="可留空，例如：杭州">
                </div>
                <div class="mr-hint">CSV 只在本机解析：仅提取搜索词，网址/标题/时间一律丢弃，不上传、不联网。</div>
            </div>

            <div class="mr-set-item">
                <label>搜索端（用哪种设备身份搜索）</label>
                <div class="mr-set-line">
                    <select id="set-device" class="mr-sel">
                        <option value="auto">自动（跟随当前设备）</option>
                        <!-- 安全整改（v1.7.12）：手动强制「电脑/手机」会伪造 UA + Client Hints，
                             与真实设备指纹矛盾、极易触发风控，已从界面隐藏。移动搜索计分只认
                             浏览器真实环境（手机浏览器/触屏设备天然计移动分，电脑天然计电脑分）。
                             开发入口：如需临时恢复，取消下面两行注释。 -->
                        <!-- <option value="pc">电脑</option> -->
                        <!-- <option value="mobile">手机</option> -->
                    </select>
                </div>
                <div class="mr-hint">自动 = 手机浏览器用手机身份、电脑用电脑身份。脚本不再伪造设备身份，移动搜索积分完全取决于浏览器本身的环境。</div>
            </div>

            <div class="mr-set-item" id="set-model-item">
                <div class="mr-set-head-row">
                    <label>机型（手机身份搜索时生效）</label>
                    <button type="button" id="set-model-reroll" class="mr-mini">换一款</button>
                </div>
                <div class="mr-set-line">
                    <select id="set-model" class="mr-sel">
                        <option value="auto">自动（固定一款）</option>
                        <option value="generic">通用 Android（不报机型，最稳）</option>
                        <optgroup label="小米 / Redmi">
                            <option value="xiaomi15">小米 15</option>
                            <option value="xiaomi14">小米 14</option>
                            <option value="redmik80pro">红米 K80 Pro</option>
                            <option value="redmik70">红米 K70</option>
                        </optgroup>
                        <optgroup label="vivo / iQOO">
                            <option value="vivox300">vivo X300 Pro</option>
                            <option value="iqoo13">iQOO 13</option>
                        </optgroup>
                        <optgroup label="OPPO / 一加">
                            <option value="opporeno14">OPPO Reno14 Pro</option>
                            <option value="oneplus13">一加 13</option>
                            <option value="oneplusace5p">一加 Ace 5 Pro</option>
                        </optgroup>
                        <optgroup label="其它品牌">
                            <option value="honormagic6">荣耀 Magic6</option>
                            <option value="galaxys24">三星 Galaxy S24</option>
                            <option value="huaweimate60">华为 Mate 60 Pro（鸿蒙）</option>
                        </optgroup>
                    </select>
                </div>
                <div class="mr-hint" id="set-model-hint">机型只是 UA 上的标识，选哪个对积分没有影响。自动 = 当天固定一款，同一轮搜索里始终是同一台手机。</div>
            </div>

            <div class="mr-set-item">
                <label>每日额度使用比例</label>
                <div class="mr-set-line">
                    <input type="number" id="set-ratio" class="mr-num" min="10" max="80" step="5"><span>%</span>
                </div>
                <div class="mr-hint">默认 80%（v1.7.14）。上限 80%：满额 100% 冲刺最易触发风控，超过 80% 会自动截断。想更保守可调到 50–60%。</div>
            </div>

            <div class="mr-set-item">
                <label>两次搜索间隔</label>
                <div class="mr-set-line">
                    <input type="number" id="set-mindelay" class="mr-num" min="1" max="60" step="0.1"><span>分钟 ~</span>
                    <input type="number" id="set-maxdelay" class="mr-num" min="1" max="240" step="0.1"><span>分钟</span>
                </div>
                <div class="mr-hint">默认 2–6 分钟，在此区间内随机（只影响搜索）。</div>
            </div>

            <div class="mr-set-item">
                <label>两篇阅读间隔</label>
                <div class="mr-set-line">
                    <input type="number" id="set-readmin" class="mr-num" min="1" max="60" step="1"><span>分钟 ~</span>
                    <input type="number" id="set-readmax" class="mr-num" min="1" max="120" step="1"><span>分钟</span>
                </div>
                <div class="mr-hint">默认 1–2 分钟，只影响「📖 阅读」，与搜索间隔互不影响。</div>
            </div>

            <div class="mr-set-item">
                <label>分批搜索</label>
                <div class="mr-set-line">
                    <span>每</span><input type="number" id="set-batchsize" class="mr-num" min="0" max="100" step="1"><span>次一批，间隔</span>
                    <input type="number" id="set-batchgap" class="mr-num" min="0" max="720" step="0.1"><span>分钟</span>
                </div>
                <div class="mr-hint">填 0 表示不分批（连续跑完）。建议每批 10–15 次、间隔 60 分钟。</div>
            </div>

            <div class="mr-set-item">
                <label>防风控暂停</label>
                <div class="mr-set-line">
                    <span>每</span><input type="number" id="set-pauseint" class="mr-num" min="3" max="100" step="1"><span>次暂停</span>
                    <input type="number" id="set-pausemin" class="mr-num" min="1" max="180" step="0.1"><span>分钟</span>
                </div>
                <div class="mr-hint">默认每 5 次暂停 15 分钟（1.7.11 起，原来是 10 次）。</div>
            </div>

            <div class="mr-set-item">
                <label>搜完点开一条结果</label>
                <div class="mr-set-line">
                    <label style="display:flex;align-items:center;gap:6px;color:#555"><input type="checkbox" id="set-click">启用</label>
                    <span>停留</span><input type="number" id="set-staymin" class="mr-num" min="0" max="120" step="1"><span>~</span>
                    <input type="number" id="set-staymax" class="mr-num" min="0" max="180" step="1"><span>秒</span>
                </div>
                <div class="mr-hint">1.7.11 起默认关闭：这一步只增加请求数量，对计分没有帮助。</div>
            </div>

            <div class="mr-set-btns">
                <button class="mr-btn" id="mr-set-reset">恢复默认</button>
                <button class="mr-btn mr-save" id="mr-set-save">保存</button>
            </div>
        </div>
    `;
    document.body.appendChild(panel);

    // 元素引用
    const $ = id => document.querySelector(id);
    const nodes = {
        panel: $('#mr-panel'),
        close: $('#mr-close'),
        level: $('#mr-level'),
        points: $('#mr-points'),
        todayRow: $('#mr-today-row'),
        today: $('#mr-today'),
        todayBarBg: $('#mr-today-bar-bg'),
        todayBar: $('#mr-today-bar'),
        pc: $('#mr-pc'),
        pcBar: $('#mr-pc-bar'),
        signStatus: $('#mr-sign-status'),
        read: $('#mr-read'),
        readBar: $('#mr-read-bar'),
        btnSearch: $('#btn-search'),
        btnPromo: $('#btn-promo'),
        valPromo: $('#val-promo'),
        btnSign: $('#btn-sign'),
        btnRead: $('#btn-read'),
        btnAll: $('#btn-all'),
        boxAuth: $('#mr-auth'),
        btnAuthLink: $('#mr-auth-link'),
        inAuth: $('#mr-auth-in'),
        btnAuthSave: $('#mr-auth-save'),
        logBox: $('#mr-log')
    };

    /* =========================================================================
     * 🆕 1.7.2 iPhone / iPad：可视高度同步
     * -------------------------------------------------------------------------
     * 手机上 100vh 会算进收起的地址栏，iPad 分屏、横竖屏切换、键盘弹出时更不准，
     * 直接用 100vh 会让面板底部（按钮区）被切掉。这里把 visualViewport 的
     * 真实高度写成 --mr-vh，CSS 里所有高度都用它。
     * ========================================================================= */
    function syncViewport() {
        try {
            const vv = window.visualViewport;
            const raw = Math.round((vv && vv.height) || window.innerHeight || 0);
            const base = Math.round(window.innerHeight || 0);
            // v1.7.6：加下限与上限。以前只挡 <120，iPad 分屏 / 键盘弹出时若取到
            // 异常小的值，面板会被压成一条线，看着就像「点了没反应」。
            if (!raw || raw < 280) return;
            const h = base ? Math.min(raw, base) : raw;
            nodes.panel.style.setProperty('--mr-vh', h + 'px');
        } catch (e) { }
    }
    syncViewport();
    try {
        window.addEventListener('resize', syncViewport, { passive: true });
        window.addEventListener('orientationchange', () => setTimeout(syncViewport, 150), { passive: true });
        if (window.visualViewport) {
            window.visualViewport.addEventListener('resize', syncViewport, { passive: true });
        }
    } catch (e) { }

    // ========== 交互逻辑 ==========

    // 展开/收起
    /* =========================================================================
     * 🆕 1.7.6：pointer 事件 + 按下即反馈
     * -------------------------------------------------------------------------
     * iOS Safari 上合成 click 不可靠（命中 SVG 子元素、手指滑动几像素都会丢事件），
     * 旧版只挂 onclick，于是「点球没反应」。现在：
     *   pointerdown 记录起点并立刻缩放（不等 340ms 弹簧）
     *   pointerup   位移 < 8px 才算点击 → 展开
     *   click       保留作兜底（没有 pointer 事件的环境仍可用）
     * ========================================================================= */
    function expandPanel() {
        if (!nodes.panel.classList.contains('collapsed')) return;
        nodes.panel.classList.remove('collapsed');
    }

    (() => {
        const p = nodes.panel;
        let sx = 0, sy = 0, moved = false, tracking = false;
        const release = () => p.classList.remove('mr-press');

        p.addEventListener('pointerdown', (e) => {
            if (!p.classList.contains('collapsed')) return;
            tracking = true;
            moved = false;
            sx = e.clientX; sy = e.clientY;
            p.classList.add('mr-press');
        }, { passive: true });

        p.addEventListener('pointermove', (e) => {
            if (!tracking) return;
            if (Math.abs(e.clientX - sx) > 8 || Math.abs(e.clientY - sy) > 8) {
                moved = true;
                release();
            }
        }, { passive: true });

        p.addEventListener('pointerup', () => {
            if (!tracking) return;
            tracking = false;
            release();
            if (!moved) expandPanel();
        }, { passive: true });

        p.addEventListener('pointercancel', () => { tracking = false; release(); }, { passive: true });

        // 兜底：只送 click 的环境
        p.addEventListener('click', () => expandPanel());
    })();

    nodes.close.onclick = (e) => {
        e.stopPropagation();
        toggleSettings(false);
        nodes.panel.classList.add('collapsed');
    };

    // ========== ⚙️ 搜索设置面板 ==========
    const setNodes = {
        gear: $('#mr-set'),
        panel: $('#mr-settings'),
        close: $('#mr-set-close'),
        save: $('#mr-set-save'),
        reset: $('#mr-set-reset'),
        ratio: $('#set-ratio'),
        mode: $('#set-mode'),
        device: $('#set-device'),
        model: $('#set-model'),
        modelReroll: $('#set-model-reroll'),
        modelItem: $('#set-model-item'),
        modelHint: $('#set-model-hint'),
        minDelay: $('#set-mindelay'),
        maxDelay: $('#set-maxdelay'),
        batchSize: $('#set-batchsize'),
        batchGap: $('#set-batchgap'),
        pauseInt: $('#set-pauseint'),
        pauseMin: $('#set-pausemin'),
        click: $('#set-click'),
        stayMin: $('#set-staymin'),
        stayMax: $('#set-staymax'),
        readMin: $('#set-readmin'),
        readMax: $('#set-readmax'),
        typo: $('#set-typo'),
        fuzzy: $('#set-fuzzy'),
        pinyin: $('#set-pinyin'),
        typing: $('#set-typing'),
        wordMode: $('#set-wordmode'),
        wordFile: $('#set-wordfile'),
        wordStat: $('#set-wordstat'),
        mixP: $('#set-mixp'),
        mixB: $('#set-mixb'),
        mixH: $('#set-mixh'),
        mixHint: $('#set-mixhint'),
        topics: $('#set-topics'),
        city: $('#set-city'),
        wordExport: $('#mr-word-export'),
        wordClear: $('#mr-word-clear')
    };

    function toggleSettings(show) {
        if (!setNodes.panel) return;
        setNodes.panel.classList.toggle('show', !!show);
    }

    // 机型行始终显示（「自动」下也看得到）；只在真正不按手机身份搜索时置灰并说明原因
    function toggleModelRow() {
        if (!setNodes.modelItem || !setNodes.device) return;
        const dev = setNodes.device.value;
        const effMobile = dev === 'mobile' || (dev === 'auto' && resolveSearchDevice() === 'mobile');
        setNodes.modelItem.style.display = '';
        setNodes.modelItem.classList.toggle('mr-dim', !effMobile);
        if (setNodes.model) setNodes.model.disabled = !effMobile;
        if (setNodes.modelHint) {
            const mk = setNodes.model ? setNodes.model.value : settings.deviceModel;
            const cur = mk === 'auto' ? `${currentModelLabel()}（自动 · 当天固定）` : (DEVICE_PROFILES[mk]?.label || '通用 Android');
            if (setNodes.modelReroll) setNodes.modelReroll.style.display = (mk === 'auto') ? '' : 'none';
            const autoOpt = setNodes.model ? setNodes.model.querySelector('option[value="auto"]') : null;
            if (autoOpt && mk === 'auto') autoOpt.textContent = `自动 · ${currentModelLabel()}`;
            setNodes.modelHint.textContent = effMobile
                ? `当前生效：${cur}。自动模式当天抽一款后固定不变，同一轮搜索里始终是同一台手机。`
                : '当前搜索端不按手机身份搜索，机型暂不生效。选「手机」，或让「自动」在本机按手机搜索时才会用到。';
        }
    }

    /* ---------------- 🆕 1.7.0 词库面板：渲染、导入预览、导出、清空 ---------------- */

    function renderTopicChips(list) {
        if (!setNodes.topics) return;
        const chosen = new Set(Array.isArray(list) ? list : (settings.topics || []));
        setNodes.topics.innerHTML = Object.keys(TOPIC_PACKS).map(k =>
            `<span class="mr-chip${chosen.has(k) ? ' on' : ''}" data-k="${k}">${TOPIC_PACKS[k].label}</span>`
        ).join('');
        [...setNodes.topics.querySelectorAll('.mr-chip')].forEach(el => {
            el.onclick = () => el.classList.toggle('on');
        });
    }

    function getChosenTopics() {
        if (!setNodes.topics) return [];
        return [...setNodes.topics.querySelectorAll('.mr-chip.on')]
            .map(el => el.getAttribute('data-k'))
            .filter(k => TOPIC_PACKS[k]);
    }

    function updateWordStat() {
        if (!setNodes.wordStat) return;
        const lib = wlGetLib();
        const n = lib.words.length;
        const eff = wlEffectiveMix();
        const when = lib.savedAt ? new Date(lib.savedAt).toLocaleDateString('zh-CN') : '—';
        const mode = setNodes.wordMode ? setNodes.wordMode.value : settings.wordMode;
        const modeName = { auto: '自动', lib: '仅词库', topic: '仅话题', hot: '仅热搜' }[mode] || '自动';
        let txt = `已存 ${n} 词 · 模式：${modeName} · 导入：${when}`;
        if (n) txt += ` · 生效配比 ${eff.p}/${eff.b}/${eff.h}`;
        setNodes.wordStat.textContent = txt;
        if (setNodes.mixHint) {
            setNodes.mixHint.textContent = eff.ramped
                ? `当前生效：个人 ${eff.p}% / 混搭 ${eff.b}% / 热搜 ${eff.h}%（词库 ${n} 条，少于 150 条自动降档）`
                : `默认 70/20/10：每次搜索按概率抽类别。当前生效：个人 ${eff.p}% / 混搭 ${eff.b}% / 热搜 ${eff.h}%`;
        }
    }

    function ensureWordModal() {
        let m = document.getElementById('mr-word-modal');
        if (m) return m;
        m = document.createElement('div');
        m.id = 'mr-word-modal';
        m.className = 'mr-modal';
        m.style.display = 'none';
        m.innerHTML = `
            <div class="mr-modal-box">
                <div class="mr-modal-title">导入预览</div>
                <div class="mr-modal-stat" id="mr-word-stat"></div>
                <textarea class="mr-modal-ta" id="mr-word-ta" spellcheck="false" placeholder="一行一个搜索词"></textarea>
                <div class="mr-modal-stat">可以删掉不想留的词，一行一个；确认后只保存这些词，原始文件不会被保存。</div>
                <div class="mr-set-btns">
                    <button class="mr-btn" id="mr-word-cancel">取消</button>
                    <button class="mr-btn mr-save" id="mr-word-ok">确认导入</button>
                </div>
            </div>`;
        document.body.appendChild(m);
        return m;
    }

    function readFileSmart(file) {
        return new Promise((resolve, reject) => {
            const fr = new FileReader();
            fr.onerror = () => reject(fr.error || new Error('read fail'));
            fr.onload = () => {
                const buf = fr.result;
                try { resolve(new TextDecoder('utf-8', { fatal: true }).decode(buf)); }
                catch (e) {
                    try { resolve(new TextDecoder('gbk').decode(buf)); }
                    catch (e2) { resolve(new TextDecoder('utf-8').decode(buf)); }
                }
            };
            fr.readAsArrayBuffer(file);
        });
    }

    let pendingWords = null;

    function openWordPreview(stat, wordsMap) {
        pendingWords = wordsMap;
        const m = ensureWordModal();
        const list = [...wordsMap.entries()].sort((a, b) => b[1] - a[1]).slice(0, 600);
        const statEl = document.getElementById('mr-word-stat');
        const ta = document.getElementById('mr-word-ta');
        if (statEl) statEl.textContent = `${stat}。预览按频次排序、最多 600 条，可删改。`;
        if (ta) ta.value = list.map(x => x[0]).join('\n');
        m.style.display = 'flex';

        document.getElementById('mr-word-cancel').onclick = () => {
            m.style.display = 'none';
            pendingWords = null;
        };
        document.getElementById('mr-word-ok').onclick = () => {
            const finalMap = new Map();
            const raw = document.getElementById('mr-word-ta').value || '';
            for (const line of raw.split(/\r?\n/)) {
                const w = wlClean(line);
                if (!w) continue;
                finalMap.set(w, (pendingWords && pendingWords.get(w)) || 1);
            }
            if (!finalMap.size) return;
            const r = wlMergeWords(finalMap, 'csv');
            m.style.display = 'none';
            pendingWords = null;
            updateWordStat();
            log(`📚 词库已更新：共 ${r.total} 词（本次新增 ${r.added}）`);
        };
    }

    async function handleWordFile(file) {
        if (!file) return;
        let text = '';
        try { text = await readFileSmart(file); }
        catch (e) { log('❌ 文件读取失败，换一个文件试试'); return; }

        const trimmed = String(text).trim();
        if (!trimmed) { log('⚠️ 文件是空的'); return; }

        let stat = '';
        let words = new Map();

        if (/^[[{]/.test(trimmed)) {
            let arr = [];
            try {
                const j = JSON.parse(trimmed);
                if (Array.isArray(j)) arr = j;
                else if (j && Array.isArray(j.words)) arr = j.words;
            } catch (e) { }
            for (const it of arr) {
                const w = wlClean(typeof it === 'string' ? it : (it && (it.w || it.word)));
                if (!w) continue;
                words.set(w, (words.get(w) || 0) + (Number(it && it.c) || 1));
            }
            stat = `词库文件：解析到 ${words.size} 个词`;
        } else if (!/https?:\/\//i.test(text)) {
            // 纯词表：一行一词
            for (const line of text.split(/\r?\n/)) {
                const w = wlClean(line);
                if (w) words.set(w, (words.get(w) || 0) + 1);
            }
            stat = `词表：解析到 ${words.size} 个词`;
        } else {
            const r = wlExtractFromCsv(text);
            words = r.words;
            stat = `历史文件：共 ${r.rows} 行 → 提取 ${words.size} 个搜索词，丢弃敏感/无效 ${r.dropped} 条`;
        }

        if (!words.size) { log('⚠️ 没提取到可用搜索词，确认导出的是浏览器历史记录'); return; }
        openWordPreview(stat, words);
    }

    function exportWordLib() {
        const lib = wlGetLib();
        if (!lib.words.length) { log('⚠️ 词库是空的，先导入历史 CSV 或勾几个话题包'); return; }
        const blob = new Blob([lib.words.map(x => x.w).join('\n')], { type: 'text/plain;charset=utf-8' });
        const a = document.createElement('a');
        const d = new Date();
        const pad = n => String(n).padStart(2, '0');
        a.href = URL.createObjectURL(blob);
        a.download = `rewards-wordlib-${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}.txt`;
        document.body.appendChild(a);
        a.click();
        setTimeout(() => { URL.revokeObjectURL(a.href); a.remove(); }, 1500);
        log(`📤 已导出 ${lib.words.length} 词，可传到手机端再导入`);
    }

    function clearWordLibWithConfirm() {
        if (!confirm('确定清空本机词库？清空后会自动改用「话题包 + 热搜」。')) return;
        wlClearLib();
        updateWordStat();
        log('🗑️ 词库已清空');
    }

    function fillSettingsForm(useDefault = false) {
        const s = useDefault ? normalizeSettings(DEFAULT_SETTINGS) : settings;
        if (setNodes.mode) setNodes.mode.value = s.searchMode;
        if (setNodes.device) setNodes.device.value = s.searchDevice;
        if (setNodes.model) {
            setNodes.model.value = s.deviceModel;
            const autoOpt = setNodes.model.querySelector('option[value="auto"]');
            if (autoOpt) autoOpt.textContent = `自动 · ${currentModelLabel()}`;
        }
        toggleModelRow();
        setNodes.ratio.value = s.ratio;
        setNodes.minDelay.value = s.minDelay;
        setNodes.maxDelay.value = s.maxDelay;
        setNodes.batchSize.value = s.batchSize;
        setNodes.batchGap.value = s.batchGap;
        setNodes.pauseInt.value = s.pauseInterval;
        setNodes.pauseMin.value = s.pauseMinutes;
        setNodes.click.checked = s.clickResult;
        setNodes.stayMin.value = s.stayMin;
        setNodes.stayMax.value = s.stayMax;
        setNodes.readMin.value = s.readMin;
        setNodes.readMax.value = s.readMax;
        if (setNodes.typo) setNodes.typo.value = s.typoLevel;
        if (setNodes.fuzzy) setNodes.fuzzy.checked = s.fuzzyPinyin;
        if (setNodes.pinyin) setNodes.pinyin.checked = s.pinyinQuery;
        if (setNodes.typing) setNodes.typing.checked = s.typing;
        if (setNodes.wordMode) setNodes.wordMode.value = s.wordMode;
        if (setNodes.mixP) setNodes.mixP.value = s.mixP;
        if (setNodes.mixB) setNodes.mixB.value = s.mixB;
        if (setNodes.mixH) setNodes.mixH.value = s.mixH;
        if (setNodes.city) setNodes.city.value = s.city || '';
        renderTopicChips(s.topics || []);
        updateWordStat();
    }

    if (setNodes.device) {
        setNodes.device.onchange = () => {
            toggleModelRow();
        };
    }
    if (setNodes.model) {
        setNodes.model.onchange = () => {
            toggleModelRow();
        };
    }
    // 「自动」下想换一台：立即重抽并刷新文案（不影响当轮已用过的 UA，下一轮生效）
    if (setNodes.modelReroll) {
        setNodes.modelReroll.onclick = () => {
            rerollAutoModel();
            toggleModelRow();
        };
    }
    if (setNodes.wordFile) {
        setNodes.wordFile.onchange = (e) => {
            const f = e.target.files && e.target.files[0];
            if (f) handleWordFile(f);
            e.target.value = '';
        };
    }
    if (setNodes.wordExport) setNodes.wordExport.onclick = exportWordLib;
    if (setNodes.wordClear) setNodes.wordClear.onclick = clearWordLibWithConfirm;
    if (setNodes.wordMode) setNodes.wordMode.onchange = updateWordStat;
    [setNodes.mixP, setNodes.mixB, setNodes.mixH].forEach(el => {
        if (el) el.oninput = updateWordStat;
    });
    if (setNodes.gear) {
        setNodes.gear.onclick = (e) => {
            e.stopPropagation();
            fillSettingsForm();
            toggleSettings(true);
        };
    }
    if (setNodes.panel) {
        // 阻止点击设置区时触发面板其他点击逻辑
        setNodes.panel.onclick = (e) => e.stopPropagation();
    }
    if (setNodes.close) {
        setNodes.close.onclick = (e) => { e.stopPropagation(); toggleSettings(false); };
    }
    if (setNodes.reset) {
        setNodes.reset.onclick = (e) => {
            e.stopPropagation();
            fillSettingsForm(true);
            log('↩️ 已恢复默认值，点击「保存」后生效');
        };
    }
    if (setNodes.save) {
        setNodes.save.onclick = (e) => {
            e.stopPropagation();
            const s = saveSettings({
                searchMode: setNodes.mode ? setNodes.mode.value : 'page',
                searchDevice: setNodes.device ? setNodes.device.value : 'auto',
                deviceModel: setNodes.model ? setNodes.model.value : 'auto',
                ratio: setNodes.ratio.value,
                minDelay: setNodes.minDelay.value,
                maxDelay: setNodes.maxDelay.value,
                batchSize: setNodes.batchSize.value,
                batchGap: setNodes.batchGap.value,
                pauseInterval: setNodes.pauseInt.value,
                pauseMinutes: setNodes.pauseMin.value,
                clickResult: setNodes.click.checked,
                stayMin: setNodes.stayMin.value,
                stayMax: setNodes.stayMax.value,
                readMin: setNodes.readMin.value,
                readMax: setNodes.readMax.value,
                typoLevel: setNodes.typo ? setNodes.typo.value : 'normal',
                fuzzyPinyin: setNodes.fuzzy ? setNodes.fuzzy.checked : true,
                pinyinQuery: setNodes.pinyin ? setNodes.pinyin.checked : true,
                typing: setNodes.typing ? setNodes.typing.checked : true,
                wordMode: setNodes.wordMode ? setNodes.wordMode.value : 'auto',
                mixP: setNodes.mixP ? setNodes.mixP.value : 70,
                mixB: setNodes.mixB ? setNodes.mixB.value : 20,
                mixH: setNodes.mixH ? setNodes.mixH.value : 10,
                topics: getChosenTopics(),
                city: setNodes.city ? setNodes.city.value : ''
            });
            fillSettingsForm();
            toggleSettings(false);
            let msg = `⚙️ 设置已保存：${s.searchMode === 'page' ? '真实页面搜索' : '后台请求搜索'}、额度 ${s.ratio}%、搜索间隔 ${s.minDelay}-${s.maxDelay} 分钟、阅读间隔 ${s.readMin}-${s.readMax} 分钟`;
            const devLabel = s.searchDevice === 'auto' ? `自动（当前按${resolveSearchDevice() === 'mobile' ? '手机' : '电脑'}搜索）` : (s.searchDevice === 'mobile' ? '手机' : '电脑');
            msg += `、搜索身份 ${devLabel}`;
            if (s.searchDevice === 'mobile' || (s.searchDevice === 'auto' && resolveSearchDevice() === 'mobile')) {
                msg += `（机型：${s.deviceModel === 'auto' ? currentModelLabel() : (DEVICE_PROFILES[s.deviceModel]?.label || '通用')}）`;
            }
            if (s.batchSize > 0) msg += `、每 ${s.batchSize} 次分批休息 ${s.batchGap} 分钟`;
            if (s.clickResult) msg += `、点结果停留 ${s.stayMin}-${s.stayMax} 秒`;
            msg += `、${humanizeNote()}`;
            log(msg);
        };
    }

    const LOG_MAX_LINES = 200;
    const log = (msg) => {
        const div = document.createElement('div');
        div.textContent = `[${new Date().toLocaleTimeString().slice(0, 5)}] ${msg}`;
        nodes.logBox.appendChild(div);
        while (nodes.logBox.childNodes.length > LOG_MAX_LINES) {
            nodes.logBox.removeChild(nodes.logBox.firstChild);
        }
        nodes.logBox.scrollTop = nodes.logBox.scrollHeight;
    };

    const updateAllButton = () => {
        if (!nodes.btnAll) return;
        if (state.manualPaused) {
            nodes.btnAll.textContent = '▶️ 继续执行';
        } else if (state.running || state.allRunning || state.busyCount > 0) {
            nodes.btnAll.textContent = '⏸️ 暂停执行';
        } else {
            nodes.btnAll.textContent = '🚀 一键全部执行';
        }
    };

    const setManualPause = (paused, opts = {}) => {
        if (paused === state.manualPaused) return;
        const silent = !!opts.silent;
        state.manualPaused = paused;
        if (paused) {
            if (!state.pausePromise) {
                state.pausePromise = new Promise(resolve => { state.pauseResolver = resolve; });
            }
        } else if (state.pauseResolver) {
            const resolve = state.pauseResolver;
            state.pauseResolver = null;
            state.pausePromise = null;
            resolve();
        }
        updateAllButton();
        if (!silent) {
            log(paused ? '⏸️ 已手动暂停' : '▶️ 已继续执行');
        }
    };

    const markBusy = (delta) => {
        state.busyCount = Math.max(0, state.busyCount + delta);
        updateAllButton();
    };

    const waitWhilePaused = async () => {
        if (!state.manualPaused) return 0;
        if (!state.pausePromise) {
            state.pausePromise = new Promise(resolve => { state.pauseResolver = resolve; });
        }
        const start = Date.now();
        await state.pausePromise;
        return Date.now() - start;
    };

    // ========== 授权相关（移动端增强：自动获取授权码 + 自动填充） ==========
    const AUTH_URL = 'https://login.live.com/oauth20_authorize.srf?client_id=0000000040170455&scope=service::prod.rewardsplatform.microsoft.com::MBI_SSL&response_type=code&redirect_uri=https://login.live.com/oauth20_desktop.srf';

    // 从任意文本中提取 OAuth code（支持完整网址、被截断的网址、纯授权码）
    function extractCodeFromUrl(text) {
        if (!text) return '';
        const s = String(text).trim();
        const m = s.match(/[?&#]code=([^&#\s"']+)/i);
        if (m) {
            try { return decodeURIComponent(m[1]); } catch (e) { return m[1]; }
        }
        // 用户直接粘贴了授权码本身（形如 M.C531_BAY.0.U.-xxx）
        if (/^M\.[A-Za-z0-9._\-]{20,}$/.test(s)) return s;
        return '';
    }

    // 统一的授权码兑换流程
    async function acceptAuthCode(code, opts = {}) {
        if (!code) return false;
        gs('auth_code', code);
        gs('auth_pending', '');
        setRefreshToken(''); // 用新授权码时清掉旧 refresh_token
        state.authPending = false;
        if (nodes.inAuth) nodes.inAuth.value = code;
        if (nodes.boxAuth) nodes.boxAuth.style.display = 'none';
        log(opts.silent ? '📥 检测到新授权码，正在兑换 Token...' : '✅ 授权码已自动填入，正在兑换 Token...');

        const token = await getAccessToken({ forceRefresh: true });
        if (token) {
            log('🎉 授权成功！');
            await updateData();
            return true;
        }
        log('❌ 授权码兑换失败，请重新点击「获取授权码」');
        if (nodes.boxAuth) nodes.boxAuth.style.display = 'block';
        return false;
    }

    // 打开微软授权页：移动端优先 GM_openInTab，避免 window.open 被 Edge 拦截
    function openAuthPage() {
        try {
            if (typeof GM_openInTab === 'function') {
                GM_openInTab(AUTH_URL, { active: true, insert: true, setParent: true });
            } else {
                const w = window.open(AUTH_URL, '_blank');
                if (!w) location.href = AUTH_URL;
            }
            return true;
        } catch (e) {
            try { location.href = AUTH_URL; } catch (e2) { }
            return false;
        }
    }

    // 轮询等待另一个标签页捕获到的授权码 → 自动填充
    let authWatchTimer = null;
    let authWatchCount = 0;
    function startAuthWatch() {
        if (authWatchTimer) return;
        state.authPending = true;
        gs('auth_pending', '1');
        authWatchCount = 0;
        const tick = async () => {
            authWatchCount++;
            let code = '';
            try { code = gv('auth_code', '') || ''; } catch (e) { }
            if (code) {
                stopAuthWatch();
                await acceptAuthCode(code, { silent: true });
                return;
            }
            if (authWatchCount > 150) stopAuthWatch(); // 约 5 分钟超时
        };
        authWatchTimer = setInterval(tick, 2000);
        // 手机上来回切标签时立刻检查一次
        document.addEventListener('visibilitychange', () => { if (!document.hidden) tick(); });
        window.addEventListener('focus', tick);
    }
    function stopAuthWatch() {
        if (authWatchTimer) { clearInterval(authWatchTimer); authWatchTimer = null; }
    }

    nodes.btnAuthLink.onclick = () => {
        openAuthPage();
        startAuthWatch();
        log('🔗 已打开微软授权页，登录完成后授权码会自动填回（无需手工复制）');
    };

    nodes.btnAuthSave.onclick = async () => {
        const val = (nodes.inAuth.value || '').trim();
        try {
            // 兼容三种粘贴内容：完整网址 / 只粘 code / 自动填充
            const code = extractCodeFromUrl(val);
            if (code) stopAuthWatch();
            
            if (code) {
                gs('auth_code', code);
                setRefreshToken(''); // 清空旧 token
                log('✅ 授权码已保存，正在尝试获取 Token...');
                nodes.boxAuth.style.display = 'none';
                nodes.inAuth.value = '';
                
                // 立即强制触发 Token 获取
                const token = await getAccessToken({ forceRefresh: true });
                if (token) {
                    log('🎉 授权成功！');
                    if (typeof updateData === 'function') {
                        await updateData(); 
                    }
                } else {
                    log('❌ 授权码兑换失败，请重新获取');
                }
            } else {
                log('❌ 格式错误：未在URL中找到 code 参数，请复制完整的白屏网址');
            }
        } catch (e) {
            log('❌ 格式错误：请直接粘贴你复制的完整网页链接 (https://...)');
        }
    };
    updateAllButton();

    // 自动抓取微软 OAuth Code
    async function checkAuth() {
        try {
            let cookie = '';
            if (typeof getCookies === 'function') {
                cookie = await getCookies('https://login.live.com');
            }
            // 移动端修复：拿不到登录 Cookie 时静默授权必然失败，直接跳过，
            // 避免整条「一键执行」流程卡在这里干等
            if (!cookie) {
                console.warn('[Rewards] 未取到 login.live.com Cookie，跳过静默授权');
                return null;
            }

            const authUrl = 'https://login.live.com/oauth20_authorize.srf?client_id=0000000040170455&scope=service::prod.rewardsplatform.microsoft.com::MBI_SSL&response_type=code&redirect_uri=https://login.live.com/oauth20_desktop.srf';

            // 1.7.6：不再直接调 GM_xmlhttpRequest（iOS 上没有这个函数会抛错），统一走 rawRequest
            const res = await rawRequest({
                method: 'GET',
                url: authUrl,
                headers: {
                    'Cookie': cookie,
                    'User-Agent': envUA() // v1.7.14：跟随环境真实身份
                },
                timeout: 10000
            });

            // 1. 优先从跳转后的 URL 截取 code
            const finalUrl = res.finalUrl || '';
            let codeMatch = finalUrl.match(/[?&]code=([^&]+)/);
            if (codeMatch) return decodeURIComponent(codeMatch[1]);

            // 2. 次之从响应内容或 Header 截取
            const body = res.responseText || '';
            codeMatch = body.match(/[?&]code=([^&"'\s]+)/);
            if (codeMatch) return decodeURIComponent(codeMatch[1]);

            return null;
        } catch (e) {
            console.error('[Rewards] checkAuth 异常:', e);
            return null;
        }
    }

    // ========== 核心逻辑 (简化版引用) ==========

    // 数据刷新
    // 统一获取 Token 的逻辑
    async function getSearchToken() {
        if (!state.searchToken) await updateData();
        return state.searchToken;
    }

    // 数据刷新函数（修复 allP 报错 + 本地签到日期双重校验）
    // ========== 今日积分解析（对应必应 App 首页「今日积分 66/120」）==========
    // 优先取 dashboard 里 name="day" 的计数器（官方口径）；取不到再用每日任务求和（标 ≈）
    function parseTodayProgress(dashData) {
        const none = { cur: -1, max: 0, estimate: false };
        if (!dashData || typeof dashData !== 'object') return none;
        const num = v => { const n = Number(v); return isFinite(n) ? n : 0; };

        // A. day / today 计数器
        const pools = [];
        if (Array.isArray(dashData.counters)) pools.push(...dashData.counters);
        if (Array.isArray(dashData.userCounters)) pools.push(...dashData.userCounters);
        if (Array.isArray(dashData.userStatus?.counters)) pools.push(...dashData.userStatus.counters);
        if (Array.isArray(dashData.response?.counters)) pools.push(...dashData.response.counters);

        for (const c of pools) {
            if (!c || typeof c !== 'object') continue;
            const key = String(c.name ?? c.counterType ?? c.type ?? c.id ?? '').trim().toLowerCase();
            if (!/^(day|daily|today|dayprogress|dailyprogress)$/.test(key)) continue;
            const max = num(c.pointProgressMax ?? c.pointMax ?? c.max ?? c.maxPoints);
            const cur = num(c.pointProgress ?? c.progress ?? c.current ?? c.points);
            if (max > 0) return { cur: Math.min(cur, max), max, estimate: false };
        }

        // B. 兜底：每日任务（dailySet + 标记 daily 的活动）求和
        let cur = 0, max = 0, found = false;
        const addPromo = p => {
            if (!p || typeof p !== 'object') return;
            const a = p.attributes || {};
            const pm = num(a.max ?? p.pointProgressMax ?? p.max ?? p.maxPoints);
            if (pm <= 0) return;
            found = true;
            max += pm;
            cur += num(a.progress ?? p.pointProgress ?? p.progress);
        };

        const today = getDateStr();
        const ds = dashData.dailySetPromotions?.[today];
        if (Array.isArray(ds)) ds.forEach(addPromo);

        const more = [
            ...(Array.isArray(dashData.morePromotions) ? dashData.morePromotions : []),
            ...(Array.isArray(dashData.activities) ? dashData.activities : []),
            ...(Array.isArray(dashData.userStatus?.promotions) ? dashData.userStatus.promotions : [])
        ];
        more.forEach(p => {
            if (!p || typeof p !== 'object') return;
            const a = p.attributes || {};
            const isDaily = a.daily === true || a.daily === 'true' || a.isDaily === true ||
                            p.daily === true || p.frequency === 'daily';
            if (isDaily) addPromo(p);
        });

        if (found && max > 0) return { cur: Math.min(cur, max), max, estimate: true };
        return none;
    }

    async function updateData() {
    if (state.updatingPromise) return state.updatingPromise;
    state.updating = true;
    state.updatingPromise = (async () => {
        try {
            const cookie = await getCookies('https://rewards.bing.com');

            let htmlRes = '';
            try {
                htmlRes = await gmRequest({
                    method: 'GET',
                    url: 'https://rewards.bing.com/',
                    headers: {
                        'User-Agent': envUA(), // v1.7.14：跟随环境真实身份
                        'Cookie': cookie,
                        'Referer': 'https://www.bing.com/'
                    }
                });

                const tokenMatch = htmlRes.match(/name="__RequestVerificationToken"[^>]*value="([^"]+)"/i)
                                || htmlRes.match(/value="([^"]+)"[^>]*name="__RequestVerificationToken"/i)
                                || htmlRes.match(/RequestVerificationToken["']?\s*[:=]\s*["']([^"']+)["']/i)
                                || htmlRes.match(/"verificationToken"\s*:\s*["']([^"']+)["']/i);
                if (tokenMatch) {
                    state.searchToken = tokenMatch[1];
                }
            } catch (e) {}

            let dashData = null;

            if (htmlRes) {
                const dashMatch = htmlRes.match(/var\s+dashboard\s*=\s*({[\s\S]*?});\s*var/i)
                               || htmlRes.match(/window\.__INITIAL_STATE__\s*=\s*({[\s\S]*?});/i);
                if (dashMatch) {
                    try { dashData = JSON.parse(dashMatch[1]); } catch (e) {}
                }
            }

            if (!dashData || !dashData.userProfile) {
                try {
                    const token = await getAccessToken();
                    if (token) {
                        const dapiRes = await gmRequest({
                            method: 'GET',
                            url: `https://prod.rewardsplatform.microsoft.com/dapi/me?channel=SAAndroid&options=613&_=${Date.now()}`,
                            headers: {
                                'Authorization': `Bearer ${token}`,
                                'X-Rewards-AppId': CONFIG.mobileApi.appId,
                                'X-Rewards-IsMobile': 'true'
                            }
                        });
                        const parsed = JSON.parse(dapiRes);
                        const resp = parsed.response || parsed;
                        dashData = resp.dashboard || resp;
                        // day 计数器常在 response 顶层，挂到 dashboard 上以便统一解析
                        try {
                            if (dashData && !Array.isArray(dashData.counters) && Array.isArray(resp.counters)) {
                                dashData.counters = resp.counters;
                            }
                        } catch (e) { }
                    }
                } catch (e) {
                    console.error('[Rewards] DAPI 请求错误:', e);
                }
            }

            if (!dashData) {
                // v1.7.8：服务器没给出任何可解析数据，同样算「同步失败」，界面要标出来
                state.lastSyncOk = false;
                render();
                log('❌ 获取数据失败，请确认已登录 rewards.bing.com');
                return;
            }

            dashboard = dashData;

            // =========================================================================
            // 1. 解析等级与积分（捕获 profile.attributes.level）
            // =========================================================================
            const profile = dashData.userProfile || dashData.profile || {};
            const balance = dashData.balance;
            const userStatus = dashData.userStatus || dashData.status || {};

            if (typeof balance === 'number') {
                state.points = balance;
            } else if (balance && typeof balance === 'object') {
                state.points = balance.availablePoints ?? balance.points ?? 0;
            } else {
                state.points = profile.availablePoints ?? profile.points ?? dashData.availablePoints ?? 0;
            }

            //直接从 profile.attributes.level 获取新版等级代号（如 newLevel3）
            const rawLevelCandidate = 
                profile?.attributes?.level ||
                userStatus?.levelInfo?.activeLevel ||
                userStatus?.level ||
                (typeof balance === 'object' && balance?.levelInfo?.activeLevel) ||
                (typeof balance === 'object' && balance?.level) ||
                profile?.levelInfo?.activeLevel ||
                profile?.level ||
                dashData?.levelInfo?.activeLevel ||
                dashData?.level ||
                '';

            const rawLevelStr = String(rawLevelCandidate);

            // 🔍 控制台确认日志
            //console.log('[Rewards 最终等级匹配]: 捕获到等级代号 ->', rawLevelStr);

            // 微软新版体系精准匹配（newLevel3 / Level3 / Gold = 金牌）
            if (/Gold|金牌|Level3|newLevel3/i.test(rawLevelStr) || rawLevelStr === '3') {
                state.levelName = '🏅 金牌';
                state.level = 3;
            } else if (/Silver|银牌|Level2|newLevel2/i.test(rawLevelStr) || rawLevelStr === '2') {
                state.levelName = '🥈 银牌';
                state.level = 2;
            } else if (/Member|Bronze|会员|铜牌|Level1|newLevel1/i.test(rawLevelStr) || rawLevelStr === '1') {
                state.levelName = '🥉 会员';
                state.level = 1;
            } else {
                state.level = parseInt(rawLevelStr.replace(/\D/g, '')) || 1;
                state.levelName = rawLevelStr ? rawLevelStr : `Lv.${state.level}`;
            }
            // 2. 搜索进度解析
            const candidateCounters = [];

            if (Array.isArray(dashData.counters)) candidateCounters.push(...dashData.counters);
            if (Array.isArray(dashData.userCounters)) candidateCounters.push(...dashData.userCounters);
            if (Array.isArray(dashData.userStatus?.counters)) candidateCounters.push(...dashData.userStatus.counters);

            const promos = [
                ...(Array.isArray(dashData.promotions) ? dashData.promotions : []),
                ...(Array.isArray(dashData.morePromotions) ? dashData.morePromotions : []),
                ...(Array.isArray(dashData.userStatus?.promotions) ? dashData.userStatus.promotions : [])
            ];

            promos.forEach(p => {
                const name = ((p.name || p.id || p.title || p.type || '') + '').toLowerCase();
                if (name.includes('search')) {
                    candidateCounters.push(p);
                }
            });

            // v1.7.10：汇总交给 parseSearchCounters（严格解析，异常整组作废），
            // 原来的 Number(...) || 0 会把字段缺失算成 0 并计入总数。

            // v1.7.9：只有真的解析到搜索计数器时才更新读数。
            // 解析不到不等于「服务器积分变成 0」——那会把已确认进度和待确认一起抹掉，
            // 所以这种情况按「读到响应但没读到有效读数」处理：保留旧值 + 标 ⚠️。
            // v1.7.10：解析改为严格模式。任一计数器字段缺失/非法 → 整组作废，
            // 不再出现「异常项按 0 计入」的部分汇总（那会让确认值悄悄变小）。
            const counterParse = parseSearchCounters(candidateCounters);
            if (counterParse.ok) {
                state.searchCur = counterParse.cur;
                state.searchMax = counterParse.max;
                state.lastSyncReason = '';
                accSyncConfirmed(counterParse.cur, false);
            } else {
                // 读不到有效读数：保留上一次的已确认值 / 待确认值，只标同步失败
                accSyncConfirmed(null, true);
                if (state.lastSyncReason !== counterParse.reason) {
                    state.lastSyncReason = counterParse.reason;
                    log(`⚠️ 搜索进度读数无法解析（${parseReasonText(counterParse.reason)}），已保留上次确认的 ${state.searchConfirmed || 0} 分，不按 0 处理`);
                }
                if (MR_DEBUG) console.warn('[Rewards] 搜索计数器解析失败:', counterParse);
            }
            if (!state.searchMax) state.searchMax = state.level > 1 ? 90 : 60;
            state.pcCur = state.searchConfirmed;
            state.pcMax = state.searchMax;

            // 3. 统一收集所有活动列表
            const today = getDateStr();
            const dailySet = dashData.dailySetPromotions?.[today] 
                          || Object.values(dashData.dailySetPromotions || {}).flat() 
                          || [];
            const morePromos = dashData.morePromotions || dashData.promotions || [];
            const activities = dashData.activities || [];

            const allP = [
                ...(Array.isArray(dailySet) ? dailySet : []),
                ...(Array.isArray(morePromos) ? morePromos : []),
                ...(Array.isArray(activities) ? activities : [])
            ];

            // 4. 签到状态解析
            const lastSignDate = gv("Config.lastSignDate", "");
            const isLocalSigned = lastSignDate === today;

            let isRemoteSigned = false;

            // A. 从签到活动卡片判断
            const checkInPromo = allP.find(p => {
                if (!p || typeof p !== 'object') return false;
                const str = JSON.stringify(p).toLowerCase();
                if (str.includes('fosbury')) return false;         
                return (
                    str.includes('checkin') ||
                    str.includes('signin') ||
                    str.includes('dailycheckin') ||
                    str.includes('签到')
                );
            });

            if (checkInPromo) {
                const cur = Number(
                    checkInPromo.pointProgress ??
                    checkInPromo.progress ??
                    checkInPromo.attributes?.progress ??
                    0
                );

                const max = Number(
                   checkInPromo.pointProgressMax ??
                   checkInPromo.max ??
                   checkInPromo.attributes?.max ??
                   0
               );

               const complete =
                   checkInPromo.complete === true ||
                   checkInPromo.complete === 'true' ||
                   checkInPromo.attributes?.complete === true ||
                   checkInPromo.attributes?.complete === 'true' ||
                   checkInPromo.attributes?.complete === 'True';
           
              // 只有明确完成，或者存在有效进度且达到最大值，才算签到
              if (complete || (max > 0 && cur >= max)) {
                  isRemoteSigned = true;
              }
            }

            // B. 只接受明确的 claimedToday
            if (!isRemoteSigned) {
                try {
                    const claimed =
                        dashData?.claimedToday === true ||
                        dashData?.claimedToday === 'true' ||
                        dashData?.userStatus?.claimedToday === true ||
                        dashData?.userStatus?.claimedToday === 'true';
                
                    if (claimed) {
                        isRemoteSigned = true;
                    }
                } catch (e) {}
            }

            // C. 本地记录只允许匹配“今天”
            state.checkedIn = isRemoteSigned || isLocalSigned;

            // =========================================================================
            // 5. 阅读任务与活动列表统计（优先从活动列表中提取真实进度，修复日志进度不一致问题）
            const readOfferId = 'ENUS_readarticle3_30points';
            const readPromo = allP.find(p => {
                if (!p || typeof p !== 'object') return false;
                const offerId = p.attributes?.offerid || p.offerid || '';
                return offerId === readOfferId || offerId.toLowerCase().includes('readarticle');
            });

            if (readPromo && readPromo.attributes) {
                // v1.7.10：progress / max 必须严格校验。
                // 旧写法 parseInt(...) || 0 会把字段缺失变成 0，直接把「已确认进度」写回 0。
                const readParse = parseReadProgress(readPromo);
                if (!readParse.ok) {
                    state.lastSyncOk = false;
                    if (!state.readMax) state.readMax = 30;
                    if (state.lastReadReason !== readParse.reason) {
                        state.lastReadReason = readParse.reason;
                        log(`⚠️ 阅读进度读数无法解析（${parseReasonText(readParse.reason)}），已保留上次确认的 ${state.readConfirmed || 0} 分，不按 0 处理`);
                    }
                    if (MR_DEBUG) console.warn('[Rewards] 阅读进度解析失败:', readParse);
                } else {
                    const prevReadConfirmed = Number(state.readConfirmed) || 0;
                    const newReadCur = readParse.cur;
                    state.readCur = newReadCur;
                    state.readMax = readParse.max;
                    // v1.7.9：只有读数相对上次确认值「真的增加」，才按增量冲销待确认；
                    // 读数不变时保留待确认 —— 同步成功不等于平台确认。
                    if (newReadCur > prevReadConfirmed) {
                        state.readPending = Math.max(0, state.readPending - (newReadCur - prevReadConfirmed));
                    }
                    state.readConfirmed = newReadCur;
                    if (newReadCur >= state.readMax) state.readPending = 0;
                    state.readPending = Math.min(Math.max(0, state.readPending),
                        Math.max(0, state.readMax - state.readConfirmed));
                    state.lastReadReason = '';
                }
            } else {
                // 没解析到阅读卡片：不覆盖已确认值，也不动待确认
                if (!state.readCur) state.readCur = 0;
                if (!state.readMax) state.readMax = 30;
            }

            state.promosTotal = allP.length;
            state.promosDone = allP.filter(p => p.complete || p.attributes?.complete === 'true' || p.attributes?.complete === 'True').length;

            // 6. 今日积分（必应 App 首页同款进度）
            const todayProg = parseTodayProgress(dashData);
            state.todayCur = todayProg.cur;
            state.todayMax = todayProg.max;
            state.todayEstimate = !!todayProg.estimate;

            // v1.7.9：lastSyncOk 已由 accSyncConfirmed 按「有没有拿到有效读数」判定，
            // 这里不能再无条件写 true，否则读数缺失也会把 ⚠️ 抹掉。
            render();
            const newStatus = `${state.level}-${state.points}-${state.searchCur}-${state.searchMax}`;
            if (state.lastStatus !== newStatus) {
                log(`✓ 数据已更新: Lv.${state.level} ${state.points}pts`);
                state.lastStatus = newStatus;
            }
        } catch (e) {
            state.lastSyncOk = false; // v1.7.8：同步失败要能被上层看到，不能假装成功
            render();                 // 立刻把 ⚠️ 画出来（数字保持上一次的已确认值）
            console.error('updateData error:', e);
            log(`⚠️ 获取数据出错: ${e.message}`);
        } finally {
            state.updating = false;
            state.updatingPromise = null;
        }
    })();
    return state.updatingPromise;
}
    /* =========================================================================
     * 🆕 v1.7.10 进度字段严格解析（P0：不能把「没读到有效数字」当成 0）
     * -------------------------------------------------------------------------
     * 旧写法 `Number(x) || 0` / `parseInt(x) || 0` 会把
     *   字段缺失 / null / '' / 'abc' / NaN / Infinity / 负数
     * 统统变成 0 —— 一旦服务器换了字段结构，界面上的「已确认进度」会被 0 覆盖，
     * 看起来像「进度回退了」，或者反过来把无效数据当作有效进度。
     *
     * 这里区分三件事：
     *   ① 合法数字（**包括合法的 0**）→ ok:true
     *   ② 字段存在但值不合法        → ok:false, reason
     *   ③ 字段根本不存在            → ok:false, reason:'missing'
     * ========================================================================= */
    function strictNumber(raw) {
        if (typeof raw === 'number') {
            if (!Number.isFinite(raw)) return { ok: false, value: null, reason: 'not-finite' }; // NaN / ±Infinity
            if (raw < 0) return { ok: false, value: null, reason: 'negative' };
            return { ok: true, value: raw, reason: '' };
        }
        if (typeof raw === 'string') {
            const t = raw.trim();
            if (!t) return { ok: false, value: null, reason: 'empty' };
            if (!/^\d+$/.test(t)) return { ok: false, value: null, reason: 'non-numeric' }; // 'abc' '-1' '1e3' '3abc'
            const n = Number(t);
            if (!Number.isFinite(n) || n < 0) return { ok: false, value: null, reason: 'not-finite' };
            return { ok: true, value: n, reason: '' };
        }
        if (raw === undefined) return { ok: false, value: null, reason: 'missing' };
        if (raw === null) return { ok: false, value: null, reason: 'null' };
        return { ok: false, value: null, reason: 'bad-type' }; // 布尔 / 对象 / 数组
    }

    // 搜索计数器里「进度」与「上限」可能出现的字段名（不含 points：那是奖励值，不是进度）
    const COUNTER_PROGRESS_KEYS = ['pointProgress', 'progress', 'current'];
    const COUNTER_MAX_KEYS = ['pointProgressMax', 'pointMax', 'max', 'maxPoints'];

    // 取字段：先看对象自身，再退回 attributes；返回 { present, raw }
    function pickCounterField(obj, keys) {
        if (!obj || typeof obj !== 'object') return { present: false, raw: undefined };
        for (const k of keys) {
            if (Object.prototype.hasOwnProperty.call(obj, k) && obj[k] !== undefined) {
                return { present: true, raw: obj[k] }; // null 也算「字段在、值为空」
            }
        }
        const attrs = obj.attributes;
        if (attrs && typeof attrs === 'object') {
            for (const k of keys) {
                if (Object.prototype.hasOwnProperty.call(attrs, k) && attrs[k] !== undefined) {
                    return { present: true, raw: attrs[k] };
                }
            }
        }
        return { present: false, raw: undefined };
    }

    /**
     * 汇总搜索计数器。**任何一项异常 → 整组作废**（ok:false），
     * 绝不做「异常项按 0 计入」的部分汇总 —— 那会让确认值悄悄变小。
     * 既没有进度字段也没有上限字段的条目视为「不是计数器」，直接跳过（不计 0、不计入）。
     */
    function parseSearchCounters(items) {
        const list = Array.isArray(items) ? items : [];
        let cur = 0, max = 0, counted = 0;
        for (let i = 0; i < list.length; i++) {
            const item = list[i];
            if (!item || typeof item !== 'object') return { ok: false, reason: 'bad-item', index: i, cur: null, max: null };
            const p = pickCounterField(item, COUNTER_PROGRESS_KEYS);
            const m = pickCounterField(item, COUNTER_MAX_KEYS);
            if (!p.present && !m.present) continue; // 不是计数器
            if (!p.present) return { ok: false, reason: 'missing-progress', index: i, cur: null, max: null };
            if (!m.present) return { ok: false, reason: 'missing-max', index: i, cur: null, max: null };
            const pv = strictNumber(p.raw);
            if (!pv.ok) return { ok: false, reason: 'bad-progress:' + pv.reason, index: i, cur: null, max: null };
            const mv = strictNumber(m.raw);
            if (!mv.ok) return { ok: false, reason: 'bad-max:' + mv.reason, index: i, cur: null, max: null };
            if (pv.value > mv.value) return { ok: false, reason: 'progress-over-max', index: i, cur: null, max: null };
            cur += pv.value; max += mv.value; counted++;
        }
        if (!counted) return { ok: false, reason: 'no-counter', index: -1, cur: null, max: null };
        if (!(max > 0)) return { ok: false, reason: 'no-max', index: -1, cur: null, max: null };
        return { ok: true, reason: '', index: -1, cur, max, counted };
    }

    // 阅读活动卡片 → { ok, cur, max }
    function parseReadProgress(promo) {
        if (!promo || typeof promo !== 'object') return { ok: false, reason: 'missing-promo', cur: null, max: null };
        const attrs = (promo.attributes && typeof promo.attributes === 'object') ? promo.attributes : {};
        const pv = strictNumber(attrs.progress);
        if (!pv.ok) return { ok: false, reason: 'bad-progress:' + pv.reason, cur: null, max: null };
        const mv = strictNumber(attrs.max);
        if (!mv.ok) return { ok: false, reason: 'bad-max:' + mv.reason, cur: null, max: null };
        if (!(mv.value > 0)) return { ok: false, reason: 'bad-max-range', cur: null, max: null };
        if (pv.value > mv.value) return { ok: false, reason: 'progress-over-max', cur: null, max: null };
        return { ok: true, reason: '', cur: pv.value, max: mv.value };
    }

    // 把解析失败原因翻成人话（日志用）
    function parseReasonText(reason) {
        const map = {
            'missing': '字段缺失',
            'null': '字段为空值',
            'empty': '字段是空字符串',
            'non-numeric': '字段不是数字',
            'not-finite': '数字非法（NaN/Infinity）',
            'negative': '数字为负',
            'bad-type': '字段类型不对',
            'missing-progress': '缺少当前进度字段',
            'missing-max': '缺少最大进度字段',
            'bad-max-range': '最大进度不是正数',
            'progress-over-max': '进度超过上限',
            'bad-item': '计数器条目结构异常',
            'no-counter': '没有找到搜索计数器',
            'no-max': '搜索上限汇总为 0',
            'missing-promo': '没有阅读活动卡片'
        };
        const key = String(reason || '');
        const base = key.split(':')[0];
        const sub = key.includes(':') ? map[key.split(':')[1]] || key.split(':')[1] : '';
        return (map[base] || base) + (sub ? '（' + sub + '）' : '');
    }

    /* =========================================================================
     * v1.7.9 数据完整性：进度记账（第二轮修正）
     * -------------------------------------------------------------------------
     * 三个状态必须分开，不能混为一谈：
     *   ① 请求送出       —— 只是发出去了，没有任何证据，不产生进度
     *   ② 请求得到响应   —— 服务器回了 2xx，只能算「已上报」，挂成待确认
     *   ③ 平台确认有效   —— 只有回读出「进度确实增加」才算，界面主数字只认它
     * 且：同步成功 ≠ 平台确认。读数没变化时，待确认一律保留。
     * ========================================================================= */
    function accSyncConfirmed(serverCur, failed) {
        if (failed) { state.lastSyncOk = false; return false; }
        const v = Number(serverCur);
        // 读到了响应但没有可用读数（字段缺失 / NaN / 负数）：不算同步成功，也不动待确认
        if (serverCur === null || serverCur === undefined || !Number.isFinite(v) || v < 0) {
            state.lastSyncOk = false;
            return false;
        }
        state.lastSyncOk = true;
        const prev = Number(state.searchConfirmed) || 0;

        if (v > prev) {
            // 服务器读数真的涨了：只按「实际增量」冲销待确认，剩余部分继续挂着
            state.searchConfirmed = v;
            state.searchPending = Math.max(0, state.searchPending - (v - prev));
            state.searchUnconfirmedStreak = 0;
        } else if (v < prev) {
            // 服务器回退（跨天清零 / 平台纠正）：以服务器为准，估算值全部作废
            state.searchConfirmed = v;
            state.searchPending = 0;
            state.searchUnconfirmedStreak = 0;
        } else {
            // 读数没变化：不能因为「同步成功」就把待确认清掉，那等于凭空确认
            if (state.searchPending > 0) state.searchUnconfirmedStreak = (state.searchUnconfirmedStreak || 0) + 1;
        }
        state.searchPending = clampPending(state.searchPending, state.searchConfirmed, state.searchMax);
        return true;
    }

    // 待确认上限：不能超过「还差多少到今日上限」，避免同一动作重复上报把数字顶到离谱
    function clampPending(pending, confirmed, max) {
        const p = Math.max(0, Number(pending) || 0);
        const m = Number(max) || 0;
        if (m <= 0) return p; // 还没读到上限时不裁剪
        return Math.min(p, Math.max(0, m - (Number(confirmed) || 0)));
    }

    // 一次搜索的三种结局：
    //   fail        —— 搜索请求没拿到响应（不推进、不记待确认）
    //   unreported  —— 搜索有响应，但计分上报没成功（不推进，计一次失败）
    //   pending     —— 计分上报已得到响应，等平台确认（进待确认，循环继续往前推）
    function accSearchResult(r, step) {
        if (!r || !r.ok) return { status: 'fail', advanced: false, pending: false };
        // v1.7.10：调用方明确带上非 2xx 分级时，即使 reported 被误设成 true 也不认
        if (r.reportHttpClass && r.reportHttpClass !== '2xx') return { status: 'unreported', advanced: false, pending: false };
        if (!r.reported) return { status: 'unreported', advanced: false, pending: false };
        state.searchPending += step;
        state.searchPending = clampPending(state.searchPending, state.searchConfirmed, state.searchMax);
        return { status: 'pending', advanced: true, pending: true };
    }

    // 阅读上报的返回体 → 本次是否「真的前进了」。只前进才算确认；读数不变一律不认。
    function judgeReadConfirmed(res, offerId, seenCur, maxSeen) {
        if (res == null) return { ok: false, reason: 'no-response', progress: null };
        let data = null;
        try { data = typeof res === 'string' ? JSON.parse(res) : res; } catch (e) {
            return { ok: false, reason: 'bad-json', progress: null };
        }
        if (!data || typeof data !== 'object') return { ok: false, reason: 'bad-shape', progress: null };
        const list = data.response?.promotions || data.promotions || [];
        if (!Array.isArray(list)) return { ok: false, reason: 'bad-shape', progress: null };
        const p = list.find(x => x && x.attributes && x.attributes.offerid === offerId);
        if (!p || !p.attributes) return { ok: false, reason: 'not-found', progress: null };
        // v1.7.10：用严格解析，避免 parseInt('3abc')=3 / parseInt('')=NaN 之类被含糊处理
        const pv = strictNumber(p.attributes.progress);
        if (!pv.ok) return { ok: false, reason: 'bad-progress', progress: null };
        const v = pv.value;

        const seen = Number(seenCur) || 0;
        const capped = Math.min(Number(maxSeen) || v, v);
        // 关键：读数没有超过「已确认值」→ 这次操作没有被平台记上，不能当成功
        if (capped <= seen) return { ok: false, reason: 'unchanged', progress: capped };
        return { ok: true, reason: 'advanced', progress: capped };
    }

    // UI 渲染函数（精准适配原生节点映射）
    /* =========================================================================
     * 🩺 v1.7.14 体检面板
     * -------------------------------------------------------------------------
     * 目的：不看代码也能一眼判断「现在能不能放心跑」。
     * 四个灯：登录 / 身份 / 额度 / 风控。全绿再开始；有红先处理。
     * ========================================================================= */
    // v1.7.14：体检面板里的数值可能来自接口（如账号名），写入 innerHTML 前统一转义
    function escHtml(s) {
        return String(s == null ? '' : s).replace(/[&<>"']/g, c => ({
            '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;'
        })[c]);
    }

    function healthRow(ok, label, value) {
        const color = ok ? '#107c41' : '#d83b01';
        const icon = ok ? '✅' : '❌';
        return '<div style="display:flex;justify-content:space-between;gap:10px">'
            + `<span style="color:${color};white-space:nowrap">${icon} ${label}</span>`
            + `<span style="color:#666;text-align:right;overflow:hidden;text-overflow:ellipsis">${escHtml(value)}</span></div>`;
    }

    function renderHealth() {
        try {
            const box = document.getElementById('mr-health');
            if (!box) return;

            // 1) 登录：读到 dashboard 或拿到 Cookie 才算
            const logged = !!dashboard || !!loginCookie;
            const us = (dashboard && (dashboard.userStatus || dashboard.user)) || {};
            const who = us.userName || us.email || us.name || '';

            // 2) 身份：脚本发请求用的 UA 必须与浏览器自身完全一致
            const ua = envUA();
            const self = (typeof navigator !== 'undefined' && navigator.userAgent) ? navigator.userAgent : ua;
            const same = ua === self;
            const vm = ua.match(/(?:Edg|Chrome|Firefox)\/(\d+)/);
            const ver = vm ? vm[1] : '?';
            const brand = /Edg\//.test(ua) ? 'Edge' : /Firefox\//.test(ua) ? 'Firefox' : 'Chrome';
            const osn = /Windows NT/.test(ua) ? 'Windows'
                : /Macintosh|Mac OS X/.test(ua) ? 'macOS'
                : /Android/.test(ua) ? 'Android'
                : /Linux/.test(ua) ? 'Linux' : '未知';

            // 3) 额度
            const qMax = Number(state.searchMax) || 0;
            const qCur = Number(state.searchConfirmed) || 0;

            // 4) 风控：直接读熔断开关，避免触发 breakerBlocked 的日志副作用
            const blocked = !!MR_BREAKER.on;

            box.innerHTML =
                healthRow(logged, '登录', logged ? (who || '已登录') : '未登录，先点获取授权码')
                + healthRow(same, '身份', `${osn} · ${brand} ${ver}${same ? '' : '（不一致！）'}`)
                + healthRow(qMax > 0, '额度', qMax > 0 ? `${qCur}/${qMax}` : '未读到，通常是没登录')
                + healthRow(!blocked, '风控', blocked ? '已熔断，先停手' : '正常');
        } catch (e) { }
    }

    function render() {
        if (!nodes.level) return;

        // 1. 等级与积分（优先显示金牌/银牌名称）
        nodes.level.textContent = state.levelName || `Lv.${state.level}`;
        nodes.points.textContent = (state.points || 0).toLocaleString();

        // 1.5 今日积分（对应必应 App 首页的「今日积分 66/120」）
        if (nodes.todayRow && nodes.today) {
            const tCur = Number(state.todayCur);
            const tMax = Number(state.todayMax) || 0;
            if (tCur >= 0 && tMax > 0) {
                const c = Math.min(tCur, tMax);
                nodes.todayRow.style.display = '';
                if (nodes.todayBarBg) nodes.todayBarBg.style.display = '';
                nodes.today.textContent = `${state.todayEstimate ? '≈' : ''}${c}/${tMax}`;
                nodes.today.title = state.todayEstimate ? '按每日任务估算，可能与必应 App 略有差异' : '来自微软 Rewards 官方计数器';
                if (nodes.todayBar) nodes.todayBar.style.width = `${(c / tMax) * 100}%`;
            } else {
                nodes.todayRow.style.display = 'none';
                if (nodes.todayBarBg) nodes.todayBarBg.style.display = 'none';
            }
        }
        // 2. 搜索进度（v1.7.8：主数字只认服务器确认值，待确认部分单独标出；同步失败加 ⚠️）
        const pcCur = Number.isFinite(state.searchConfirmed) ? state.searchConfirmed : (state.searchCur ?? state.pcCur ?? 0);
        const pcMax = state.searchMax ?? state.pcMax ?? 60;
        if (nodes.pc) nodes.pc.textContent = `${pcCur}/${pcMax}`
            + (state.searchPending > 0 ? ` (+${state.searchPending}待确认)` : '')
            + (state.lastSyncOk === false ? ' ⚠️' : '');
        if (nodes.pcBar) nodes.pcBar.style.width = pcMax ? `${(pcCur / pcMax) * 100}%` : '0%';

        // 3. 签到状态
        if (nodes.signStatus) {
            nodes.signStatus.textContent = state.checkedIn ? '已签到' : '未签到';
            nodes.signStatus.style.color = state.checkedIn ? '#107c41' : '#d83b01';
        }

        // 4. 阅读任务（v1.7.9：主数字只认平台确认值，待确认部分单独标出）
        const readCur = Number.isFinite(state.readConfirmed) ? state.readConfirmed : (state.readCur ?? 0);
        const readMax = state.readMax ?? 30;
        if (nodes.read) nodes.read.textContent = `${readCur}/${readMax}`
            + (state.readPending > 0 ? ` (+${state.readPending}待确认)` : '');
        if (nodes.readBar) nodes.readBar.style.width = readMax ? `${(readCur / readMax) * 100}%` : '0%';

        // 5. 活动任务
        if (nodes.valPromo) {
            nodes.valPromo.textContent = `${state.promosDone || 0}/${state.promosTotal || 0}`;
        }

        // 6. v1.7.14：体检四灯
        renderHealth();
    }

    // Token 获取
    // 获取/刷新 OAuth Access Token
    async function getAccessToken(opts = {}) {
        const forceRefresh = !!opts.forceRefresh;
        const now = Date.now();

        if (!forceRefresh && state.accessToken && state.accessTokenExpiresAt && now < (state.accessTokenExpiresAt - 60000)) {
            return state.accessToken;
        }

        if (state.tokenPromise) {
            return state.tokenPromise;
        }

        state.tokenPromise = (async () => {
            try {
                if (forceRefresh) {
                    state.accessToken = null;
                    state.accessTokenExpiresAt = 0;
                }

                let refreshToken = getRefreshToken();
                let body = '';

                if (refreshToken) {
                    body = `client_id=0000000040170455&refresh_token=${encodeURIComponent(refreshToken)}&scope=service::prod.rewardsplatform.microsoft.com::MBI_SSL&grant_type=REFRESH_TOKEN`;
                } else {
                    log('🔑 正在获取微软活动 Token...');
                    
                    // 1. 尝试静默获取
                    let code = await checkAuth();
                    
                    // 2. 静默获取失败，检查是否有手动保存的 auth_code
                    if (!code) {
                        const savedCode = gv('auth_code', '');
                        if (savedCode) {
                            code = savedCode;
                            gs('auth_code', ''); // 授权码是一次性的，取出后立即清空
                            log('📥 已读取手动输入的授权码');
                        }
                    }

                    // 3. 仍然没有可用 code 时，弹出手动授权提示面板
                    if (!code) {
                        if (!hasCookieApi()) {
                            log('⚠️ 此环境读不到登录状态（Safari 扩展限制），无法静默授权');
                            log('👉 请点下方「🔗 获取授权码」，一次授权后即可长期使用');
                        } else {
                            log('⚠️ 静默授权失败，请点击面板中的“获取授权码”链接手动授权');
                        }
                        if (nodes.boxAuth) nodes.boxAuth.style.display = 'block';
                        return null;
                    }

                    body = `client_id=0000000040170455&code=${encodeURIComponent(code)}&redirect_uri=https://login.live.com/oauth20_desktop.srf&grant_type=authorization_code`;
                }

                const res = await gmRequest({
                    method: 'POST',
                    url: 'https://login.live.com/oauth20_token.srf',
                    headers: {
                        'Content-Type': 'application/x-www-form-urlencoded'
                    },
                    data: body
                });

                const data = typeof res === 'string' ? JSON.parse(res) : res;

                if (data.access_token) {
                    state.accessToken = data.access_token;
                    state.accessTokenExpiresAt = Date.now() + (Number(data.expires_in) || 3600) * 1000;
                    if (data.refresh_token) {
                        setRefreshToken(data.refresh_token);
                    }
                    log('🔑 活动 Token 建立成功');
                    return data.access_token;
                } else {
                    // 若旧 refresh_token 换取失败，清空并重新走 Code 授权
                    if (refreshToken) {
                        console.warn('[Rewards] RefreshToken 失效，尝试重新 Code 授权...');
                        setRefreshToken('');
                        state.tokenPromise = null;
                        return await getAccessToken({ forceRefresh: true });
                    }
                    log('⚠️ Token 获取失败: ' + (data.error_description || data.error || '未知错误'));
                }
            } catch (e) {
                log('❌ Auth Error: ' + e.message);
            } finally {
                state.tokenPromise = null;
            }
            return null;
        })();

        return state.tokenPromise;
    }

    /* =========================================================================
     * 🛡️ 页面交互任务执行器（v1.7.12 安全整改）
     * -------------------------------------------------------------------------
     * 防封作用：彻底移除「直接 POST reportactivity / dapi/me/activities」的
     * 后台直连上报。真人完成任务一定是「打开页面 → 停留浏览 → 回到任务页」，
     * 浏览器会自然带上 Cookie / Referer / 时间戳，Bing 后台据此记分。
     * 因此这里统一改为：
     *   ① 打开目标页（活动卡的 destinationUrl；取不到就用 rewards 首页）
     *   ② 停留 30–90 秒（随机，模拟真人阅读时长）
     *   ③ 跳回任务页 rewards.bing.com
     * 全程走真实 location 跳转，绝不再发任何「完成」类 POST 请求。
     * ========================================================================= */
    const PAGE_TASK_KEY = 'mr_page_task'; // 页面任务接力状态（跨页面跳转用）

    // 当前页是否是 rewards 任务页
    function isRewardsPage() {
        try { return /rewards\.bing\.com/i.test(location.hostname || ''); } catch (e) { return false; }
    }

    // 记录「跳出去做任务」的接力状态，页面返回后据此回读进度
    function setPageTask(stateObj) {
        try { gs(PAGE_TASK_KEY, JSON.stringify(stateObj || {})); } catch (e) { }
    }
    function getPageTask() {
        try {
            const raw = gv(PAGE_TASK_KEY, '');
            if (!raw) return null;
            return typeof raw === 'string' ? JSON.parse(raw) : raw;
        } catch (e) { return null; }
    }
    function clearPageTask() {
        try { gs(PAGE_TASK_KEY, ''); } catch (e) { }
    }

    // 打开目标页：优先 GM_openInTab（桌面浏览器新标签），否则 location 跳转
    function openTaskPage(url) {
        try {
            if (typeof GM_openInTab === 'function' && !isTouchTablet()) {
                GM_openInTab(url, { active: true, insert: true });
                return;
            }
        } catch (e) { }
        try { location.href = url; } catch (e) { }
    }

    // 页面交互执行：跳目标页停留后回任务页。返回 true 表示已触发跳转（异步接力）。
    async function pageInteractTask(destinationUrl, label) {
        const target = (destinationUrl && /^https?:\/\//i.test(String(destinationUrl)))
            ? String(destinationUrl)
            : 'https://rewards.bing.com/';
        log(`🌐 [${label}] 跳转到目标页并停留阅读（30–90 秒）...`);
        // 记录接力状态，便于返回后回读进度
        setPageTask({ label, at: Date.now(), back: 'https://rewards.bing.com/' });
        await sleep(randomRange(400, 1000));
        openTaskPage(target);
        return true;
    }

    // ===== 随机放弃机制（v1.7.12 安全整改）=====
    // 防封作用：真人不可能每天雷打不动把阅读/活动一个不落做完，总会「忘记/没时间」。
    // 每天都 100% 完成反而像机器人。这里按概率随机跳过，模拟真人节奏：
    //   · 每日 15% 概率跳过阅读任务
    //   · 每日 10% 概率跳过活动任务
    // 用当天日期做随机种子（同一天多次点按钮结果一致，不会「这次跳、下次不跳」反复横跳）。
    function shouldSkipTask(kind) {
        const rate = kind === 'read' ? 0.15 : 0.10;
        const key = kind === 'read' ? 'mr_skip_read' : 'mr_skip_promo';
        try {
            const raw = gv(key, '');
            const today = getDateHyphen();
            const o = raw ? JSON.parse(raw) : null;
            if (o && o.date === today) return o.skip === true; // 当天已定，复用
            // 用「日期 + 任务类型」做确定性种子，避免每次点击结果不一致
            const seed = (today + kind).split('').reduce((a, c) => (a * 31 + c.charCodeAt(0)) >>> 0, 7);
            const skip = (seed % 1000) / 1000 < rate;
            gs(key, JSON.stringify({ date: today, skip }));
            return skip;
        } catch (e) { return false; }
    }

    // 签到
    const runSign = async () => {
        if (breakerBlocked()) return; // v1.7.11
        if (nightBlocked()) return;   // v1.7.12
        nodes.btnSign.disabled = true;
        markBusy(1);
        await waitWhilePaused();
        log('⏳ 正在尝试签到（页面交互模式）...');

        const region = (state.country || dashboard?.userStatus?.country || 'cn').toLowerCase();

        // 优先获取动态 offerId，无则使用 Sapphire 默认 ID
        let offerId = "Gamification_Sapphire_DailyCheckIn";
        const allPromos = [
            ...(dashboard?.dailySetPromotions?.[getDateStr()] || []),
            ...(dashboard?.morePromotions || []),
            ...(dashboard?.activities || [])
        ];
        const targetPromo = allPromos.find(p => {
            const str = (JSON.stringify(p) || '').toLowerCase();
            return str.includes('checkin') || str.includes('签到') || str.includes('dailycheckin');
        });
        if (targetPromo) {
            offerId = targetPromo.offerId || targetPromo.id || targetPromo.offerid || offerId;
        }

        // ===== 安全整改（v1.7.12）：签到不再直连 dapi/me/activities 上报 =====
        // 改为页面交互：跳到 rewards 首页停留，让用户/浏览器真实完成签到；
        // 之后靠 updateData 回读进度确认。宁可这次不自动完成，也不后台直连。
        try {
            // 记录本次签到接力状态
            setPageTask({ kind: 'sign', offerId, at: Date.now(), back: 'https://rewards.bing.com/' });
            log('🌐 正在打开 rewards 首页完成签到（30–90 秒停留）...');
            await sleep(randomRange(400, 1000));
            openTaskPage('https://rewards.bing.com/');

            // 若还在本页（跳转未发生，例如 GM_openInTab 新标签打开），短暂停留后回读进度
            await sleep(randomRange(30000, 90000));
            await updateData();
            // 回读确认签到状态：以 dashboard 里签到卡进度为准
            const sign = (dashboard?.dailySetPromotions?.[getDateStr()] || [])
                .concat(dashboard?.morePromotions || [], dashboard?.activities || [])
                .find(p => {
                    const str = (JSON.stringify(p || {}) || '').toLowerCase();
                    return str.includes('checkin') || str.includes('签到') || str.includes('dailycheckin');
                });
            const done = sign && (
                sign.complete === true || sign.completed === true ||
                sign.state === 'CLAIMED' || sign.state === 'COMPLETED' ||
                (Number(sign.pointProgress) > 0 && Number(sign.pointProgress) >= Number(sign.pointProgressMax))
            );
            if (done) {
                log('✅ 签到已完成（页面交互确认）');
                gs("Config.lastSignDate", getDateStr());
                state.checkedIn = true;
                render();
            } else {
                log('⏳ 签到状态未确认（页面交互后请回 rewards 页核对，或稍后手动点一次签到）');
            }
        } catch (e) {
            log('❌ 签到出错: ' + e.message);
        } finally {
            nodes.btnSign.disabled = false;
            markBusy(-1);
        }
    };
    nodes.btnSign.onclick = runSign;

    
    // 阅读
    const runRead = async () => {
    if (breakerBlocked()) return; // v1.7.11
    if (nightBlocked()) return;   // v1.7.12
    // v1.7.12 随机放弃机制：15% 概率跳过阅读任务，模拟真人「忘记/没时间」
    if (shouldSkipTask('read')) {
        log('🎲 今日随机跳过阅读任务（模拟真人节奏，明日照常）');
        return;
    }
    nodes.btnRead.disabled = true;
    state.readRunning = true;
    markBusy(1);
    await waitWhilePaused();
    log('⏳ 开始阅读任务...');

    const region = (state.country || dashboard?.userStatus?.country || 'cn').toLowerCase();
    const readOfferId = 'ENUS_readarticle3_30points';

    try {
        // 2. 获取当前真实阅读进度
        const info = await withAccessTokenRequest(token => gmRequest({
            url: 'https://prod.rewardsplatform.microsoft.com/dapi/me?channel=SAAndroid&options=613',
            headers: {
                'authorization': `Bearer ${token}`,
                'user-agent': CONFIG.ua.mobile,
                'x-rewards-appid': CONFIG.mobileApi.appId,
                'x-rewards-ismobile': 'true',
                'x-rewards-country': region,
                'x-rewards-language': 'zh',
                'x-rewards-partnerid': 'startapp',
                'x-rewards-flights': 'rwgobig'
            }
        }));

        if (info) {
            const d = typeof info === 'string' ? JSON.parse(info) : info;
            const p = d.response?.promotions?.find(x => x.attributes?.offerid === readOfferId);

            if (p && p.attributes) {
                // v1.7.10：progress / max 严格校验。读不到有效数字时直接停下，
                // 绝不把已确认进度当成 0 再开始刷（那会重复阅读、也会把界面进度抹掉）。
                const readParse = parseReadProgress(p);
                if (!readParse.ok) {
                    log(`⚠️ 阅读进度读数无法解析（${parseReasonText(readParse.reason)}），本次不修改已确认进度，已停下`);
                    if (MR_DEBUG) console.warn('[Rewards] 阅读进度解析失败:', readParse);
                    return;
                }
                let cur = readParse.cur;
                let max = readParse.max;
                
                // 判断步长：若 max 为 30 则每篇 +3 分（共 10 篇）；若 max 为 10 则每篇 +1 分
                const step = max >= 30 ? 3 : 1;
                const totalArticles = Math.ceil(max / step);

                // v1.7.9：这里的读数只是「服务器原有进度」，**不是本次操作成功**。
                // 先按增量冲销上一次遗留的待确认，再把读数当作已确认基线。
                const prevReadConfirmed = Number(state.readConfirmed) || 0;
                if (cur > prevReadConfirmed) {
                    state.readPending = Math.max(0, state.readPending - (cur - prevReadConfirmed));
                }
                state.readCur = cur;
                state.readMax = max;
                state.readConfirmed = cur;
                if (cur >= max) state.readPending = 0;
                state.readPending = Math.min(Math.max(0, state.readPending), Math.max(0, max - cur));
                render();

                if (cur >= max) {
                    log(`✅ 阅读任务已完成 (${cur}/${max})`);
                } else {
                    log(`📖 当前阅读进度 ${cur}/${max}，准备刷文章...`);

                    let currentArticleIdx = Math.floor(cur / step);
                    // v1.7.8：加了「尝试次数上限」。原来进度只增不减，一旦上报没被确认就会原地死循环。
                    let readAttempts = 0;
                    while (cur < max && readAttempts < totalArticles * 2) {
                       // 方式一：改用已有的运行状态判定
                        if (!state.readRunning && !state.allRunning) break;

                        await waitWhilePaused();
                        readAttempts++;
                        currentArticleIdx++;
                        log(`📖 正在阅读第 ${currentArticleIdx}/${totalArticles} 篇文章 (进度: ${cur}/${max})...`);

                        // ===== 安全整改（v1.7.12）：阅读不再直连 dapi/me/activities 上报 =====
                        // 防封作用：彻底移除 type:101 后台直连。真人阅读 = 打开文章页停留后再回来，
                        // 浏览器自然带 Cookie/Referer，Bing 后台据此记「阅读」分。
                        // 因此这里改为：真实跳转到阅读目标页 → 停留 30–90 秒 → 跳回任务页回读进度。
                        // 宁可这一篇没记上，也不后台直连。
                        const readTargets = [
                            'https://cn.bing.com/news',
                            'https://rewards.bing.com/',
                            'https://cn.bing.com/search?q=' + encodeURIComponent('今日新闻')
                        ];
                        const loadUrl = readTargets[Math.floor(Math.random() * readTargets.length)];
                        setPageTask({ kind: 'read', offerId: readOfferId, idx: currentArticleIdx, at: Date.now(), back: 'https://rewards.bing.com/' });
                        log(`📄 正在打开阅读页并停留（约 ${Math.round((Math.random() * 60000 + 30000) / 1000)} 秒）...`);
                        await sleep(randomRange(400, 1000));
                        openTaskPage(loadUrl);

                        // 若跳转没发生（新标签打开），在本页停留，然后回读进度确认这一篇
                        await sleep(Math.floor(Math.random() * 60000) + 30000);
                        const info2 = await withAccessTokenRequest(token => gmRequest({
                            url: 'https://prod.rewardsplatform.microsoft.com/dapi/me?channel=SAAndroid&options=613',
                            headers: {
                                'authorization': `Bearer ${token}`,
                                'user-agent': CONFIG.ua.mobile,
                                'x-rewards-appid': CONFIG.mobileApi.appId,
                                'x-rewards-ismobile': 'true',
                                'x-rewards-country': region,
                                'x-rewards-language': 'zh',
                                'x-rewards-partnerid': 'startapp',
                                'x-rewards-flights': 'rwgobig'
                            }
                        })).catch(() => null);

                        // 回读这一篇是否被平台记上（只有读数真的前进才算）
                        let advanced = false;
                        if (info2) {
                            try {
                                const d2 = typeof info2 === 'string' ? JSON.parse(info2) : info2;
                                const p2 = d2.response?.promotions?.find(x => x.attributes?.offerid === readOfferId);
                                if (p2 && p2.attributes) {
                                    const rp2 = parseReadProgress(p2);
                                    if (rp2.ok && rp2.cur > cur) {
                                        const before = cur;
                                        cur = rp2.cur;
                                        state.readCur = cur;
                                        state.readConfirmed = cur;
                                        state.readPending = Math.max(0, state.readPending - (cur - before));
                                        render();
                                        advanced = true;
                                        log(`✅ 第 ${currentArticleIdx}/${totalArticles} 篇已确认（服务器读数 ${before} → ${cur}）| 进度: ${cur}/${max}`);
                                    }
                                }
                            } catch (e) { }
                        }

                        if (!advanced) {
                            log(`⏳ 第 ${currentArticleIdx}/${totalArticles} 篇暂未确认（页面交互后需回 rewards 页核对；本脚本不后台直连上报）`);
                        }

                        if (cur < max) {
                            // 👈 使用 ⚙️ 里的阅读间隔设置（默认 8–15 秒，与搜索间隔互不影响）
                            const rMin = Math.max(1, settings.readMin) * 60000;
                            const rMax = Math.max(settings.readMin, settings.readMax) * 60000;
                            const readDelay = typeof randomRange === 'function' 
                                ? randomRange(rMin, rMax) 
                                : 10000;
                            log(`☕ 随机等待 ${(readDelay / 60000).toFixed(1)} 分钟...`);
                            await sleep(readDelay);
                        }
                    }

                    if (cur >= max) {
                        log(`✅ 阅读任务执行完毕（服务器确认进度 ${state.readConfirmed}/${max}）`);
                    } else if (state.readPending > 0) {
                        log(`⏹️ 阅读已停止：已确认 ${state.readConfirmed}/${max}，另有 ${state.readPending} 分待服务器确认`);
                    } else {
                        log(`⏹️ 阅读任务已停止（当前进度: ${state.readConfirmed}/${max}）`);
                    }
                }
            } else {
                log(`⚠️ 未找到阅读任务卡片 (offerid: ${readOfferId})`);
            }
        } else {
            log('❌ 获取阅读进度失败');
        }

        await updateData();
        // v1.7.9：同步成功也不代表这些分数被确认了 —— 只有读数变了才算
        if (state.readPending > 0) {
            log(state.lastSyncOk
                ? `⏳ 阅读结束：已确认 ${state.readConfirmed}/${state.readMax}，另有 ${state.readPending} 分服务器尚未确认（读数没变化，不计入进度）`
                : '⚠️ 阅读结束后同步失败，待确认的分数请以 Rewards 网页上的实际进度为准');
        }
    } catch (e) {
        log('❌ 阅读出错: ' + e.message);
        console.error('[Rewards 阅读异常]:', e);
    } finally {
    state.readRunning = false;
    nodes.btnRead.disabled = false;
    markBusy(-1);
    }
};

nodes.btnRead.onclick = runRead;

    const runPromo = async () => {
        if (breakerBlocked()) return; // v1.7.11
        if (nightBlocked()) return;   // v1.7.12
        // v1.7.12 随机放弃机制：10% 概率跳过活动任务，模拟真人「忘记/没时间」
        if (shouldSkipTask('promo')) {
            log('🎲 今日随机跳过活动任务（模拟真人节奏，明日照常）');
            return;
        }
        nodes.btnPromo.disabled = true;
        markBusy(1);
        await waitWhilePaused();
        log('⏳ 开始执行活动任务...');
        await updateData();

        // =========================================================================
        // 🌍 区域配置
        // -------------------------------------------------------------------------
        // 【修改说明】：
        // 1. 默认使用 state.country 或 dashboard.userStatus.country 获取当前区域，若未获取到则回退为 'cn'。
        // 2. 若需要强制锁定为 'cn'，可取消注释第一行并注释第二行。
        // =========================================================================
        //const customRegion = 'cn'; //锁定cn区域
        const customRegion = (state.country || dashboard?.userStatus?.country || 'cn').toLowerCase();// 自动全区域,失败回退cn区域


        const region = customRegion.toLowerCase();

        // 计算今日 YYYYMMDD 日期，用于拦截提前加载的未来每日任务
        const now = new Date();
        const todayYmd = `${now.getFullYear()}${String(now.getMonth() + 1).padStart(2, '0')}${String(now.getDate()).padStart(2, '0')}`;

        const isTrue = (val) => {
            if (typeof val === 'boolean') return val;
            if (typeof val === 'string') return val.trim().toLowerCase() === 'true';
            return false;
        };

        // 1. 获取 Token
        let token = (typeof getSearchToken === 'function') ? await getSearchToken() : null;
        if (!token) token = state.searchToken;
        const accessToken = await getAccessToken();

        if (!token && !accessToken) {
            log('⚠️ 未获取到活动 Token，请刷新页面重试');
            nodes.btnPromo.disabled = false;
            markBusy(-1);
            return;
        }

        console.group('[Rewards 活动卡片诊断]');
        let rawTasks = [];

        // 递归挖掘任意对象中的卡片
        const extractCardsFromAnyObject = (obj, sourceName) => {
            if (!obj || typeof obj !== 'object') return;
            const found = [];
            const visited = new WeakSet();

            const search = (node) => {
                if (!node || typeof node !== 'object' || visited.has(node)) return;
                visited.add(node);

                const hasId = node.offerId || node.offerid || node.id || node.activityId;
                const hasAttr = node.title || node.name || node.points || node.pointProgressMax !== undefined || node.destinationUrl;

                if (hasId && hasAttr) {
                    found.push(node);
                    // v1.7.14：不再 return，继续向下扫描。
                    // 原因：「每周任务 4/5」这类父卡片本身有 offerId + title，但真正的
                    // 5 个子任务挂在它内部的子数组里。旧逻辑 push 父卡片就返回，
                    // 子任务永远抓不到，于是永远停在 4/5。
                    // visited(WeakSet) 已保证同一对象不会被扫两次，不会重复。
                }

                if (Array.isArray(node)) {
                    for (const item of node) search(item);
                } else {
                    for (const key of Object.keys(node)) {
                        if (key.startsWith('jQuery') || key.startsWith('__')) continue;
                        search(node[key]);
                    }
                }
            };

            search(obj);
            if (found.length > 0) {
                console.log(`📌 从 [${sourceName}] 挖掘出 ${found.length} 个活动卡片数据`);
                rawTasks.push(...found);
            }
        };

        // 渠道 1：从本地 state / dashboard 提取
        if (typeof state !== 'undefined' && state.dashboard) extractCardsFromAnyObject(state.dashboard, "state.dashboard");
        if (typeof dashboard !== 'undefined' && dashboard) extractCardsFromAnyObject(dashboard, "全局 dashboard");

        // 渠道 2：通过 DAPI 移动端接口拉取
        if (accessToken) {
            try {
                const dapiRes = await gmRequest({
                    url: `https://prod.rewardsplatform.microsoft.com/dapi/me?channel=SAAndroid&version=33.8.440724006`,
                    headers: {
                        'authorization': `Bearer ${accessToken}`,
                        'user-agent': CONFIG.ua.mobile,
                        'x-rewards-appid': CONFIG.mobileApi.appId,
                        'x-rewards-country': region
                    }
                });
                const dapiData = typeof dapiRes === 'string' ? JSON.parse(dapiRes) : dapiRes;
                if (dapiData?.response) {
                    extractCardsFromAnyObject(dapiData.response, "DAPI 接口 response");
                }
            } catch (e) {
                console.warn('⚠️ DAPI 请求失败:', e.message);
            }
        }

        // 2. 去重与精细化多重校验
        const seenIds = new Set();
        const taskList = [];
        // v1.7.14：把「为什么跳过」分类计数，最后汇总一行，方便判断
        // 是「任务真的都做完了」还是「被日期/锁定/区域拦掉了」。
        const skipStat = { other: 0, future: 0, region: 0, done: 0, locked: 0 };

        for (const p of rawTasks) {
            if (!p) continue;

            const id = String(p.offerId || p.id || p.offerid || '');
            const title = p.title || p.name || p.description || '未命名活动';
            const progress = Number(p.pointProgress || 0);
            const max = Number(p.pointProgressMax || p.max || 0);

            if (!id || seenIds.has(id)) continue;

            // 规则 A：排除系统通知、漫游提示、每日签到卡片（需单独签到接口）及异常进度卡片
            const idUpper = id.toUpperCase();
            if (idUpper.includes('NOTIFICATION') || 
                idUpper.includes('ROAMING') || 
                idUpper.includes('CHECKIN') || 
                idUpper.includes('CHECK_IN') || 
                max > 100000) {
                console.log(`❌ [跳过-非通用任务/签到卡片] ${title} (id: ${id})`);
                skipStat.other++;
                continue;
            }

            // 规则 B：日期精准拦截（对于 DailySet 任务，拦截未到期的未来任务）
            const dateMatch = id.match(/20\d{6}/);
            if (dateMatch) {
                const cardDate = dateMatch[0];
                if (cardDate > todayYmd) {
                    console.log(`❌ [跳过-未来未到期任务] ${title} (id: ${id}, 日期: ${cardDate})`);
                    skipStat.future++; // 就是你截图里那种「灰色，只能第二天做」的
                    continue;
                }
            }

            // 规则 C：区域限制隔离（锁定 CN 时，跳过含有外区编码如 ENUS, US, JP 的任务）
            if (region === 'cn') {
                const nonCnRegex = /_(ENUS|US|UK|JP|DE|FR|CA|AU)_/i;
                if (nonCnRegex.test(id)) {
                    console.log(`❌ [跳过-外区任务] ${title} (id: ${id})`);
                    skipStat.region++;
                    continue;
                }
            }

            // 规则 D：完成度及锁定校验
            const isCompleted = isTrue(p.complete) ||
                                isTrue(p.completed) ||
                                isTrue(p.isCompleted) ||
                                isTrue(p.attributes?.complete) ||
                                p.state === 'CLAIMED' ||
                                (max > 0 && progress >= max);

            if (isCompleted) {
                console.log(`❌ [跳过-已完成] ${title} (id: ${id}, 进度: ${progress}/${max})`);
                skipStat.done++;
                continue;
            }

            if (p.priority <= -2 || p.exclusiveLockedFeatureStatus === 'locked') {
                console.log(`❌ [跳过-已锁定] ${title} (id: ${id})`);
                skipStat.locked++;
                continue;
            }

            seenIds.add(id);
            taskList.push(p);
            console.log(`✅ [待执行活动] ${title} (id: ${id}, 进度: ${progress}/${max})`);
        }

        console.groupEnd();

        // v1.7.14：跳过原因汇总。看不懂控制台也能从面板日志知道"为什么没做"。
        const skippedTotal = skipStat.other + skipStat.future + skipStat.region + skipStat.done + skipStat.locked;
        if (skippedTotal > 0) {
            const parts = [];
            if (skipStat.done) parts.push(`已完成 ${skipStat.done}`);
            if (skipStat.future) parts.push(`明天才解锁 ${skipStat.future}`);
            if (skipStat.locked) parts.push(`已锁定 ${skipStat.locked}`);
            if (skipStat.region) parts.push(`外区 ${skipStat.region}`);
            if (skipStat.other) parts.push(`非任务卡 ${skipStat.other}`);
            log(`ℹ️ 跳过 ${skippedTotal} 项：${parts.join(' · ')}`);
        }

        if (taskList.length === 0) {
            log('✅ 今天能做的活动都做完了（剩下的要么已完成，要么要等明天）');
            nodes.btnPromo.disabled = false;
            markBusy(-1);
            return;
        }

        log(`🎯 准备上报 ${taskList.length} 个未完成活动 (当前区域: ${region.toUpperCase()})`);

        let count = 0;
        const restInterval = randomRange(3, 5);

        for (const p of taskList) {
            await waitWhilePaused();
            try {
                const title = p.title || p.name || p.description || '活动任务';
                const offerId = p.offerId || p.id || p.offerid;
                const destUrl = p.destinationUrl || p.attributes?.destinationUrl || p.url || p.attributes?.url || '';

                log(`▶️ (${count + 1}/${taskList.length}) 执行: ${title}`);

                // ===== 安全整改（v1.7.12）：活动不再直连 reportactivity / dapi 上报 =====
                // 防封作用：移除「通道1 reportactivity + 通道2 dapi/me/activities」两个后台直连。
                // 改为页面交互：打开活动目标页 → 停留 30–90 秒 → 返回任务页，靠页面跳转
                // 完成计分（真人就是点卡片→看页面→回来）。宁可这个活动没记上，也不直连。
                setPageTask({ kind: 'promo', offerId, title, at: Date.now(), back: 'https://rewards.bing.com/' });
                log(`🌐 [${title}] 打开目标页并停留（30–90 秒）...`);
                await sleep(randomRange(400, 1000));
                openTaskPage(destUrl || 'https://rewards.bing.com/');
                // 若跳转未发生（新标签打开），在本页停留模拟浏览
                await sleep(randomRange(30000, 90000));

                count++;

                // 防封随机延迟
                if (count < taskList.length) {
                    if (count % restInterval === 0) {
                        const restTime = randomRange(10000, 18000);
                        log(`☕ 间隔停顿 ${(restTime / 1000).toFixed(1)} 秒...`);
                        await sleep(restTime);
                    } else {
                        const baseDelay = randomRange(4500, 8500);
                        log(`⏳ 间隔等待 ${(baseDelay / 1000).toFixed(1)} 秒...`);
                        await sleep(baseDelay);
                    }
                }
            } catch (e) {
                log(`❌ 活动执行失败: ${e.message}`);
            }
        }

        log(`✅ 活动页面交互已触发 ${count} 个（进度以 rewards 页回读为准，本脚本不后台直连上报）`);
        await updateData();
        nodes.btnPromo.disabled = false;
        markBusy(-1);
    };

    nodes.btnPromo.onclick = runPromo;

    /* =========================================================================
     * 🌐 真实页面搜索（searchMode = 'page'）
     * -------------------------------------------------------------------------
     * 做法：脚本把「要搜什么、搜到第几次、下一次什么时候」记在脚本存储里，
     *      然后真的把当前标签页跳到 Bing 搜索结果页；页面加载后脚本再接管，
     *      停留一会儿、同步一次积分，算好下一次的时间，到点再跳下一页。
     * 这样浏览器里是真实搜索，Cookie / Referer / 时间戳都是自然产生的。
     * ========================================================================= */
    const PAGE_LOOP_KEY = 'mr_page_loop';
    let pageLoopBusy = false;

    function getPageLoop() {
        try {
            const raw = gv(PAGE_LOOP_KEY, '');
            if (!raw) return null;
            const o = typeof raw === 'string' ? JSON.parse(raw) : raw;
            return o && typeof o === 'object' ? o : null;
        } catch (e) { return null; }
    }
    function setPageLoop(o) {
        try { gs(PAGE_LOOP_KEY, JSON.stringify(o || {})); } catch (e) { }
    }
    function clearPageLoop() {
        try { gs(PAGE_LOOP_KEY, ''); } catch (e) { }
    }

    // 当前该用哪个域名搜索：优先用当前页面的域名（真人不会无缘无故换域名）
    // 注意：rewards.bing.com 也以 bing.com 结尾，但它没有搜索框，不能拿来做搜索页
    function pageHost() {
        const h = location.hostname || '';
        if (/^(www|cn)\.bing\.com$/i.test(h) || /^bing\.com$/i.test(h)) return h;
        return resolveSearchDevice() === 'mobile' ? 'cn.bing.com' : 'www.bing.com';
    }

    function buildPageSearchUrl(host, q) {
        return `https://${host}/search?q=${encodeURIComponent(q)}&form=QBLH`;
    }

    // Bing 有时会把关键词做规范化，比较前先统一一下
    function pageNormQ(s) {
        return String(s || '').replace(/\+/g, ' ').replace(/\s+/g, ' ').trim().toLowerCase();
    }

    // 模拟真人看结果页：慢慢滚两下，不全速滚动
    function pageSimulateReading() {
        try {
            const times = randomRange(1, 3);
            let i = 0;
            const step = () => {
                if (i++ >= times || document.hidden) return;
                window.scrollBy({ top: randomRange(220, 520), behavior: 'smooth' });
                // v1.7.12：随机停顿 + 模拟鼠标移动，让页面更像有人在看（P1 防封）
                const rest = randomRange(900, 2400);
                const mm = () => {
                    try {
                        window.dispatchEvent(new MouseEvent('mousemove', {
                            clientX: randomRange(30, 350), clientY: randomRange(80, 500),
                            bubbles: true, view: window
                        }));
                    } catch (e) { }
                };
                mm();
                setTimeout(mm, randomRange(rest, rest + 800));
                setTimeout(step, rest);
            };
            setTimeout(step, randomRange(400, 1400));
        } catch (e) { }
    }

    /* -------------------------------------------------------------------------
     * 🆕 v1.7.14：按概率「点开」一条搜索结果
     * -------------------------------------------------------------------------
     * 真实页面模式下，人搜完一定会看结果、经常点进去一条。而脚本如果连搜 50 次
     * 一个结果都不点，这个行为本身就很假。
     *
     * 实现方式：请求 Bing 自己的点击跳转端点（/ck/a?...）。真实点击时浏览器就是
     * 打这个地址，Bing 由此记录「用户点了第 N 条」。这里用 no-cors 静默发出，
     * 既留下点击记录，又不会导航走、不打断页面搜索流程、不残留标签页。
     *
     * 概率默认 30%，不是每次都点 —— 每次都点反而机械。
     * ------------------------------------------------------------------------- */
    function pageVisitResult() {
        try {
            if (!settings.clickResult) return;
            if (Math.random() > 0.30) return;
            const links = document.querySelectorAll('#b_results li.b_algo h2 a[href]');
            if (!links.length) return;
            const n = Math.min(links.length, 5);
            const el = links[Math.floor(Math.random() * n)];
            const href = el && el.href;
            if (!href || !/bing\.com\/ck\/a/i.test(href)) return;
            fetch(href, { mode: 'no-cors', credentials: 'include' }).catch(() => { });
            log('🖱️ 顺手点开了一条搜索结果（行为拟真）');
        } catch (e) { }
    }


    /* -------------------------------------------------------------------------
     * ⌨️ 逐字输入（1.6.0 新增）
     * -------------------------------------------------------------------------
     * 不再直接跳到 /search?q=xxx，而是在 Bing 首页或结果页的搜索框里
     * 一个字一个字地敲，偶尔打错再按退格修正，最后按回车提交。
     * 找不到搜索框 / 提交失败时，自动退回「直接打开结果页」，保证不会卡住。
     * ------------------------------------------------------------------------- */

    function isElVisible(el) {
        if (!el || !el.getBoundingClientRect) return false;
        const r = el.getBoundingClientRect();
        if (r.width < 20 || r.height < 8) return false;
        const st = window.getComputedStyle(el);
        return st.visibility !== 'hidden' && st.display !== 'none' && Number(st.opacity) > 0.1;
    }

    function findSearchBox() {
        const sels = ['#sb_form_q', 'input[name="q"]', 'textarea[name="q"]'];
        for (const s of sels) {
            let list = [];
            try { list = document.querySelectorAll(s); } catch (e) { }
            for (const el of list) {
                if (isElVisible(el) && !el.disabled && !el.readOnly) return el;
            }
        }
        return null;
    }

    // 用原型上的 setter 赋值，保证页面自己的监听能收到变化
    function setBoxValue(el, v) {
        try {
            const proto = el.tagName === 'TEXTAREA' ? HTMLTextAreaElement.prototype : HTMLInputElement.prototype;
            const desc = Object.getOwnPropertyDescriptor(proto, 'value');
            if (desc && desc.set) desc.set.call(el, v); else el.value = v;
        } catch (e) {
            try { el.value = v; } catch (e2) { }
        }
        try { el.dispatchEvent(new Event('input', { bubbles: true })); } catch (e) { }
    }

    function fireKey(el, type, key) {
        try {
            let code = key;
            if (/^[a-zA-Z]$/.test(key)) code = 'Key' + key.toUpperCase();
            else if (/^[0-9]$/.test(key)) code = 'Digit' + key;
            el.dispatchEvent(new KeyboardEvent(type, {
                key, code, bubbles: true, cancelable: true, composed: true, view: window
            }));
        } catch (e) { }
    }

    // 一个字一个字敲进去（含「打错→退格」的真实动作）
    async function humanType(box, text) {
        if (!box) return false;
        const target = String(text || '');
        try { box.focus(); } catch (e) { }
        setBoxValue(box, '');
        await sleep(randomRange(140, 460)); // 点开输入框后的停顿

        let buf = '';
        const chars = [...target];
        for (let i = 0; i < chars.length; i++) {
            const ch = chars[i];

            // 约 15% 的字先打错，再退格改回来（打字速度/节奏全靠这里像人）
            if (HOMO[ch] && Math.random() < 0.15) {
                const wrong = HOMO[ch];
                fireKey(box, 'keydown', wrong);
                buf += wrong;
                setBoxValue(box, buf);
                fireKey(box, 'keyup', wrong);
                await sleep(randomRange(220, 640));
                fireKey(box, 'keydown', 'Backspace');
                buf = buf.slice(0, -1);
                setBoxValue(box, buf);
                fireKey(box, 'keyup', 'Backspace');
                await sleep(randomRange(90, 280));
            }

            fireKey(box, 'keydown', ch);
            buf += ch;
            setBoxValue(box, buf);
            fireKey(box, 'keyup', ch);
            await sleep(randomRange(65, 245));

            // 偶尔停顿一下（像在挑输入法候选词）
            if (Math.random() < 0.07) await sleep(randomRange(350, 1100));
        }
        return true;
    }

    // 提交搜索框：先回车，不跳转再走表单 / 搜索按钮，最后返回是否已跳转
    async function submitTypedSearch(box, q) {
        const before = location.href;
        fireKey(box, 'keydown', 'Enter');
        fireKey(box, 'keypress', 'Enter');
        fireKey(box, 'keyup', 'Enter');
        await sleep(800);
        if (location.href !== before) return true;

        const form = box.form || document.getElementById('sb_form') ||
            document.querySelector('form[action*="/search"]');
        if (form) {
            try {
                if (typeof form.requestSubmit === 'function') form.requestSubmit();
                else form.submit();
            } catch (e) {
                try { form.submit(); } catch (e2) { }
            }
            await sleep(900);
            if (location.href !== before) return true;
        }

        const btn = document.querySelector('#sb_form_go') ||
            document.querySelector('#search_icon') ||
            document.querySelector('#sb_submit');
        if (btn) {
            try { btn.click(); } catch (e) { }
            await sleep(900);
            if (location.href !== before) return true;
        }
        return false;
    }

    // 在一轮循环里完成一次「逐字输入 + 提交」；成功返回 true（页面即将跳转）
    async function typeIntoLoop(box, q, loop) {
        loop.q = q;
        loop.pendingQ = q;
        loop.pendingAt = Date.now();
        loop.needType = '';
        setPageLoop(loop);
        await humanType(box, q);
        await sleep(randomRange(260, 820));
        const ok = await submitTypedSearch(box, q);
        if (ok) log(`⌨️ 已提交：${q}`);
        return ok;
    }

    function resetSearchButton() {
        if (nodes.btnSearch) nodes.btnSearch.textContent = '🔍 搜索';
        updateAllButton();
    }

    // 结束整个真实页面循环
    function finishPageLoop(reason) {
        const loop = getPageLoop() || {};
        loop.on = false;
        loop.pendingQ = '';
        setPageLoop(loop);
        resetSearchButton();
        if (reason) log(reason);
    }

    // 计算「下一次」要等多久（含分批休息、防风控暂停）
    // v1.7.14：时长抖动。设 15 分钟，实际每次在 12–18 分钟之间浮动。
    // 原因：如果每天都精确停 15:00，这个整数本身就是一种规律。
    function jitterMinutes(minutes, ratio) {
        const m = Number(minutes);
        if (!isFinite(m) || m <= 0) return 0;
        const r = (typeof ratio === 'number' && ratio > 0 && ratio < 1) ? ratio : 0.2;
        return m * (1 - r + Math.random() * r * 2);
    }

    function pageNextGap(loop) {
        const gapMin = Math.max(1, settings.minDelay) * 60000;
        const gapMax = Math.max(settings.minDelay, settings.maxDelay) * 60000;
        // randomRange 出来就是毫秒级随机值，天然带小数，不会卡在整分钟
        let wait = randomRange(gapMin, gapMax);
        if (settings.batchSize > 0 && loop.idx % settings.batchSize === 0) {
            const bg = jitterMinutes(settings.batchGap);
            wait += Math.round(bg * 60000);
            log(`🛏️ 第 ${Math.floor(loop.idx / settings.batchSize)} 批完成，休息 ${bg.toFixed(1)} 分钟再继续`);
        }
        if (settings.pauseInterval > 0 && loop.idx % settings.pauseInterval === 0) {
            const pm = jitterMinutes(settings.pauseMinutes);
            wait += Math.round(pm * 60000);
            log(`⏸️ 已完成 ${loop.idx} 次搜索，额外暂停 ${pm.toFixed(1)} 分钟（防风控）`);
        }
        return wait;
    }

    // 跳到下一次搜索（会真的换页）
    async function pageLoopNext() {
        if (pageLoopBusy) return;
        pageLoopBusy = true;
        try {
            const loop = getPageLoop();
            if (!loop || !loop.on || loop.pendingQ || loop.needType || loop.typingBusy) return;
            if (loop.idx >= loop.target) {
                finishPageLoop(`🎉 真实页面搜索完成：共 ${loop.idx} 次（目标 ${loop.target} 次）`);
                return;
            }
            const q = humanizeQuery(await pickQuery());
            loop.q = q;
            loop.nextAt = 0;

            // ⌨️ 逐字输入：当前页就有搜索框（结果页顶部）→ 直接敲，不用重新加载
            if (settings.typing) {
                const box = findSearchBox();
                if (box) {
                    log(`🔎 第 ${loop.idx + 1}/${loop.target} 次：${q}`);
                    loop.typingBusy = true;
                    setPageLoop(loop);
                    const ok = await typeIntoLoop(box, q, loop);
                    loop.typingBusy = false;
                    if (ok) { setPageLoop(loop); return; }
                    log('⌨️ 逐字输入没能提交，改为直接打开结果页');
                    loop.pendingQ = q;
                    loop.pendingAt = Date.now();
                    setPageLoop(loop);
                    await sleep(randomRange(300, 800));
                    location.href = buildPageSearchUrl(loop.host || pageHost(), q);
                    return;
                }
                // 当前页没有搜索框 → 回首页，加载后由 resumePageLoop 负责敲字
                loop.needType = q;
                loop.pendingQ = '';
                setPageLoop(loop);
                log(`🔎 第 ${loop.idx + 1}/${loop.target} 次：${q}（回首页逐字输入）`);
                await sleep(randomRange(300, 900));
                location.href = `https://${loop.host || pageHost()}/`;
                return;
            }

            loop.pendingQ = q;
            loop.pendingAt = Date.now();
            setPageLoop(loop);
            log(`🔎 第 ${loop.idx + 1}/${loop.target} 次：${q}`);
            await sleep(randomRange(500, 1400));
            location.href = buildPageSearchUrl(loop.host || pageHost(), q);
        } finally {
            pageLoopBusy = false;
        }
    }

    // 用户点了「🔍 搜索」：开一轮真实页面搜索
    async function startPageLoop(target) {
        const safeTarget = Math.max(1, Math.round(Number(target) || 0));
        const host = pageHost();
        const q = humanizeQuery(await pickQuery());
        const typing = !!settings.typing;
        const loop = {
            on: true,
            host,
            q,
            pendingQ: typing ? '' : q,
            needType: typing ? q : '',
            typingBusy: false,
            idx: 0,
            target: safeTarget,
            cur: state.searchCur || 0,
            max: state.searchMax || 0,
            nextAt: 0,
            startedAt: Date.now()
        };
        setPageLoop(loop);
        const useMobile = resolveSearchDevice() === 'mobile';
        const modelLabel = useMobile ? currentModelLabel() : '电脑';
        log(`🌐 真实页面模式（${useMobile ? `手机 · ${modelLabel}` : '电脑'}）`);
        log(`🎯 本次目标 ${safeTarget} 次（额度 ${settings.ratio}%），间隔 ${settings.minDelay}-${settings.maxDelay} 分钟`);
        log(humanizeNote());
        log(`🔎 第 1/${safeTarget} 次：${q}`);
        resetSearchButton();

        // ⌨️ 逐字输入：当前页能直接敲就在这儿敲，否则先去首页
        if (typing) {
            const box = findSearchBox();
            if (box) {
                loop.typingBusy = true;
                setPageLoop(loop);
                const ok = await typeIntoLoop(box, q, loop);
                loop.typingBusy = false;
                setPageLoop(loop);
                if (ok) return;
                log('⌨️ 逐字输入没能提交，改为直接打开结果页');
                loop.needType = '';
                loop.pendingQ = q;
                loop.pendingAt = Date.now();
                setPageLoop(loop);
                await sleep(randomRange(300, 800));
                location.href = buildPageSearchUrl(host, q);
                return;
            }
            log('🌐 先打开 Bing 首页，再逐字输入关键词');
            await sleep(randomRange(300, 900));
            location.href = `https://${host}/`;
            return;
        }

        await sleep(randomRange(500, 1400));
        location.href = buildPageSearchUrl(host, q);
    }

    // 页面加载后接管：刚刚是不是脚本自己跳过来的？
    async function resumePageLoop() {
        const loop = getPageLoop();
        if (!loop || !loop.on) return;

        // 目标次数异常（旧数据 / 没取到额度）直接结束，避免死循环
        if (!Number.isFinite(loop.target) || loop.target <= 0) {
            finishPageLoop('⚠️ 上次的搜索目标无效（可能没取到额度），已结束；请授权后重新点「🔍 搜索」');
            return;
        }

        // 超过 6 小时没动，认为已过期（防止第二天打开页面突然自己开始搜）
        if (loop.startedAt && Date.now() - loop.startedAt > 6 * 3600 * 1000) {
            clearPageLoop();
            log('⌛ 上次的真实页面搜索已过期，已自动结束');
            return;
        }

        if (nodes.btnSearch) nodes.btnSearch.textContent = '⏹ 停止';

        // 新页面里不该再保留上一次的「正在输入」标记（防止旧数据把循环卡死）
        if (loop.typingBusy) { loop.typingBusy = false; setPageLoop(loop); }

        // ⌨️ 情况零：这一轮要用「逐字输入」把关键词敲进搜索框
        //   （启用方式：刚点搜索时不在 Bing 页、或循环中途没有搜索框 → 先去首页）
        if (loop.needType) {
            const target = String(loop.needType);
            const box = findSearchBox();
            if (box) {
                log(`⌨️ 逐字输入（${target.length} 个字）：${target}`);
                loop.typingBusy = true;
                setPageLoop(loop);
                const ok = await typeIntoLoop(box, target, loop);
                loop.typingBusy = false;
                setPageLoop(loop);
                if (ok) return; // 页面即将跳转，交给下一次加载继续
                log('⌨️ 逐字输入没能提交，改为直接打开结果页');
            } else {
                log('⌨️ 这个页面没有找到搜索框，改为直接打开结果页');
            }
            loop.needType = '';
            loop.pendingQ = target;
            setPageLoop(loop);
            await sleep(randomRange(300, 800));
            location.href = buildPageSearchUrl(loop.host || pageHost(), target);
            return;
        }

        const urlQ = new URLSearchParams(location.search).get('q') || '';
        const isSearchPage = /\/search\/?$/i.test(location.pathname) && !!urlQ;

        // 情况一：这就是脚本刚才跳过来的搜索结果页
        // （Bing 有时会把关键词纠错/改写，此时 url 的 q 和原词不一致，也算这一条已完成，避免原地打转）
        if (loop.pendingQ && isSearchPage) {
            const exact = pageNormQ(urlQ) === pageNormQ(loop.pendingQ);
            loop.pendingQ = '';
            loop.idx = (loop.idx || 0) + 1;
            loop.q = urlQ;
            setPageLoop(loop);
            log(`✓ 真实页面搜索：${urlQ}（第 ${loop.idx}/${loop.target} 次）${exact ? '' : '（关键词被 Bing 改写）'}`);
            pageSimulateReading();
            pageVisitResult(); // v1.7.14：30% 概率顺手点一条结果（行为拟真）

            // 等一会儿（当作人在看结果），再同步服务器真实积分
            await sleep(randomRange(3000, 7000));
            try { await updateData(); } catch (e) { }

            if (!getPageLoop()?.on) return; // 期间被用户停止

            if (state.searchCur >= loop.target) {
                finishPageLoop(`🎉 搜索已达标（${state.searchCur}/${state.searchMax}），真实页面搜索结束`);
                return;
            }
            if (loop.idx >= loop.target) {
                // v1.7.9：这里只统计「打开过多少个搜索页」，不等于平台已经记分，
                // 所以达标说法要带上服务器确认值，未确认就不能说「已完成」。
                const confirmed = state.searchConfirmed || 0;
                finishPageLoop(confirmed >= loop.target
                    ? `✅ 已完成本次目标 ${loop.idx}/${loop.target} 次（服务器确认 ${confirmed}/${state.searchMax}）`
                    : `⚠️ 已打开 ${loop.idx}/${loop.target} 个搜索页，服务器只确认到 ${confirmed}/${state.searchMax}，不计为已完成`);
                return;
            }

            const wait = pageNextGap(loop);
            loop.nextAt = Date.now() + wait;
            setPageLoop(loop);
            log(`⏳ 下一次搜索将在 ${(wait / 60000).toFixed(1)} 分钟后（进度 ${state.searchCur}/${state.searchMax}）`);
            return;
        }

        // 情况二：循环还在，但当前不是脚本跳来的搜索页（比如被重定向、或用户自己点回了首页）
        // 清掉「待落地」标记，等 5 秒后跳下一次，避免卡住
        if (loop.pendingQ) loop.pendingQ = '';
        if (!loop.nextAt) loop.nextAt = Date.now() + 5000;
        setPageLoop(loop);
        log('🌐 真实页面搜索进行中，即将继续下一次…');
    }

    // 心跳：每秒看一眼是否该跳下一次
    function startPageLoopTicker() {
        setInterval(() => {
            const loop = getPageLoop();
            if (!loop || !loop.on) {
                if (nodes.btnSearch && nodes.btnSearch.textContent === '⏹ 停止') resetSearchButton();
                return;
            }
            if (loop.pendingQ) {
                // 兜底：提交后 90 秒还没落地（页面没跳/被拦），清掉标记继续下一轮，避免卡死
                if (loop.pendingAt && Date.now() - loop.pendingAt > 90000) {
                    loop.pendingQ = '';
                    loop.pendingAt = 0;
                    loop.nextAt = Date.now() + 3000;
                    setPageLoop(loop);
                }
                return; // 正在等页面加载
            }
            if (loop.needType || loop.typingBusy) return; // 正在逐字输入
            if (document.hidden) return;   // 后台标签不跳页，回来再继续
            if (Date.now() < (loop.nextAt || 0)) return;
            pageLoopNext();
        }, 3000);
    }

    // 搜索模块：重构版（动态判定合并后的总搜索进度）
    const runSearch = async () => {
        if (breakerBlocked()) return; // v1.7.11：熔断中不接管、不发包
        if (nightBlocked()) return;   // v1.7.12
        // 🆕 真实页面模式下，点击按钮 = 停止正在进行的循环
        const runningLoop = getPageLoop();
        if (runningLoop && runningLoop.on) {
            finishPageLoop('⏹️ 已停止真实页面搜索（不会再打开下一页）');
            state.running = false;
            return;
        }
        if (state.running) {
            state.running = false;
            if (state.manualPaused) setManualPause(false, { silent: true });
            nodes.btnSearch.textContent = '🔍 搜索';
            updateAllButton();
            return;
        }
        state.running = true;
        nodes.btnSearch.textContent = '⏹ 停止';
        updateAllButton();
        await waitWhilePaused();

        // 搜索前先同步一次最新数据
        await updateData();
        // v1.7.9：同步失败时基线退回「已确认值」，避免拿上一次的估算值当服务器进度继续往上加；
        // 但待确认信息要保留 —— 那是提示，不是进度，清掉等于把「没确认」粉饰成「没问题」。
        if (!state.lastSyncOk) {
            log(`⚠️ 没能同步服务器进度，本轮以已确认的 ${state.searchConfirmed || 0}/${state.searchMax || 0} 为基线（待确认 ${state.searchPending || 0} 分保留显示）`);
            state.searchCur = state.searchConfirmed || 0;
            render();
        }

        // 执行单次搜索与奖励触发
        const doSearch = async (query, isMobile = false) => {
            const host = isMobile ? 'cn.bing.com' : 'www.bing.com';
            const cookie = await getCookies(`https://${host}`);
            await waitWhilePaused();

            const ua = isMobile ? currentMobileUA() : envUA();
            const chHeaders = isMobile ? mobileClientHints(ua) : {};
            const searchUrl = `https://${host}/search?q=${encodeURIComponent(query)}&form=QBLH`;

            try {
                // 1. 发送标准的 Bing 搜索请求（v1.7.10：必须是 2xx，3xx 跳转页不算搜到）
                const searchRes = await gmRequestEx({
                    url: searchUrl,
                    headers: {
                        'User-Agent': ua,
                        'Cookie': cookie,
                        'Referer': `https://${host}/?form=QBLH`,
                        ...chHeaders
                    }
                });
                if (!isHttp2xx(searchRes)) {
                    log(`✗ 搜索页没有返回正常内容（${describeHttpResult(searchRes)}），本次不计`);
                    return {
                        ok: false, responded: false, reported: false, headerOk: false,
                        httpClass: searchRes.httpClass, level: searchRes.level,
                        error: describeHttpResult(searchRes)
                    };
                }
                const searchResult = searchRes.text;

                // 提取 IG 用于上报
                const igMatch = searchResult.match(/,IG:"([^"]+)"/) || searchResult.match(/"IG":"([^"]+)"/);
                const ig = igMatch ? igMatch[1] : crypto.randomUUID().replace(/-/g, '').toUpperCase();

                // 2. 使用微软 Rewards 专用侧边栏/头部埋点上报积分
                const reportHeaders = {
                    'User-Agent': ua,
                    'Cookie': cookie,
                    'Referer': searchUrl,
                    'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
                    ...chHeaders
                };

                // v1.7.8：两个上报各自记录成败。原来用 .catch(()=>{}) 一律吞掉，
                // 上层根本不知道计分上报是否成功，却照样给本地进度 +3（积分虚增）。
                // v1.7.10：改用 gmRequestEx，只有 2xx 才算「已上报」；
                // 3xx（跳登录/跳验证页）、4xx、5xx、超时、网络异常一律不算成功。
                let headerOk = false, reportOk = false;
                const headerRes = await gmRequestEx({
                    method: 'POST',
                    url: `https://${host}/rewardsapp/ncheader?ver=88888888&IID=SERP.5047&IG=${ig}&ajaxreq=1`,
                    headers: reportHeaders,
                    data: 'wb=1%3bi%3d1%3bv%3d1'
                });
                headerOk = isHttp2xx(headerRes);
                if (!headerOk && MR_DEBUG) console.warn('[Rewards] 计数埋点未成功:', describeHttpResult(headerRes));

                // 触发活动报告接口（这一条才是真正计分的，必须单独判定）
                const reportRes = await gmRequestEx({
                    method: 'POST',
                    url: `https://${host}/rewardsapp/reportActivity?IG=${ig}&IID=SERP.5047&q=${encodeURIComponent(query)}&ajaxreq=1`,
                    headers: reportHeaders,
                    data: `url=${encodeURIComponent(searchUrl)}&V=web`
                });
                reportOk = isHttp2xx(reportRes);
                if (!reportOk && MR_DEBUG) console.warn('[Rewards] 计分上报未成功:', describeHttpResult(reportRes));

                // 🆕 模拟点开一条搜索结果并停留（设置里可关闭）
                if (settings.clickResult) {
                    const target = pickResultUrl(searchResult || '');
                    if (target) {
                        try {
                            await gmRequest({
                                url: target,
                                headers: {
                                    'User-Agent': ua,
                                    'Cookie': cookie,
                                    'Referer': searchUrl
                                },
                                timeout: 12000
                            });
                        } catch (e) { }
                        const stayFrom = Math.max(0, settings.stayMin) * 1000;
                        const stayTo = Math.max(settings.stayMin, settings.stayMax) * 1000;
                        if (stayTo > 0) await preciseWait(randomRange(stayFrom, stayTo));
                    }
                }

                // v1.7.9：三个层级分别返回，不再用一个 ok 混着表达
                //   ok       —— 搜索页拿到了 2xx 响应
                //   reported —— 计分接口回了 2xx（只能算「已上报」）
                //   ★ 有没有真的记分，此处无法得知，只能等同步读数（平台确认）来证明
                // v1.7.10：reported 只在 2xx 时为 true；3xx/4xx/5xx/超时/网络异常都写进 reportLevel
                log(reportOk
                    ? `✓ 搜索: "${query.substring(0, 12)}..."（已上报，待平台确认）`
                    : `✓ 搜索: "${query.substring(0, 12)}..."（计分上报未成功：${describeHttpResult(reportRes)}，本不推进）`);
                return {
                    ok: true, responded: true, reported: reportOk, headerOk,
                    reportHttpClass: reportRes.httpClass, reportLevel: reportRes.level,
                    reportStatus: reportRes.status
                };
            } catch (e) {
                console.error('[Rewards] 搜索异常:', e);
                log(`✗ 搜索失败: ${e.message}`);
                return { ok: false, responded: false, reported: false, headerOk: false, error: e.message };
            }
        };
        // 精确等待函数（优化日志输出频率，彻底杜绝刷屏）
        const preciseWait = async (ms) => {
            state.countdownStartTime = Date.now();
            state.countdownDuration = ms;
            let endTime = Date.now() + ms;

            const totalSecs = Math.ceil(ms / 1000);
            if (totalSecs > 60) {
                const mins = (totalSecs / 60).toFixed(1);
                log(`⏳ 等待中，预计需要 ${mins} 分钟...`);
            } else if (totalSecs > 0) {
                log(`⏳ 等待 ${totalSecs} 秒...`);
            }

            while (Date.now() < endTime && state.running) {
                if (state.manualPaused) {
                    const pausedMs = await waitWhilePaused();
                    endTime += pausedMs;
                    state.countdownStartTime += pausedMs;
                    continue;
                }
                const remaining = Math.max(0, endTime - Date.now());
                await sleep(Math.min(500, remaining));
            }
            
            state.countdownStartTime = 0;
            state.countdownDuration = 0;
        };

        // 暂停检查函数（优化：如果已满直接跳过暂停）
        const checkPause = async (limit) => {
            if (!CONFIG.pause.enabled) return;
            if (state.searchCur >= (limit || state.searchMax)) return;

            state.searchCount++;
            saveProgress();

            // 🆕 暂停间隔与时长改为可在设置里调整
            const everyN = Math.max(3, settings.pauseInterval);
            if (state.searchCount % everyN === 0) {
                state.isPaused = true;
                const pauseMs = Math.max(1, settings.pauseMinutes) * 60000;
                log(`⏸️ 已完成 ${state.searchCount} 次搜索，触发防风控暂停 ${settings.pauseMinutes} 分钟...`);
                state.pauseEndTime = Date.now() + pauseMs;
                await preciseWait(pauseMs);
                state.isPaused = false;
                state.pauseEndTime = 0;
                log(`▶️ 暂停结束，继续搜索...`);
            }
        };

        loadProgress();

        // 动态判定搜索进度 (合并后的总搜索任务)
        // 🆕 按「每日额度使用比例」算本次目标（默认 100%，与原来完全一致）
        // 防御：没取到额度（未登录/未授权）时 searchMax 可能是 0/undefined，不能算出 NaN 目标
        const maxServer = Number.isFinite(state.searchMax) && state.searchMax > 0 ? state.searchMax : 0;
        const curServer = Number.isFinite(state.searchCur) && state.searchCur > 0 ? state.searchCur : 0;
        state.searchMax = maxServer;
        state.searchCur = Math.min(curServer, maxServer || curServer);
        const searchTarget = maxServer > 0
            ? Math.min(maxServer, Math.max(3, Math.round(maxServer * (settings.ratio / 100) / 3) * 3))
            : 0;
        const gapMin = Math.max(1, settings.minDelay) * 60000;
        const gapMax = Math.max(settings.minDelay, settings.maxDelay) * 60000;

        // 没额度就别跑（否则会白搜一整天、也没有意义）
        if (searchTarget <= 0) {
            log('⚠️ 没取到搜索额度（显示 0/0）：通常是没登录或没授权');
            log('👉 点面板「🔗 获取授权码」完成授权后，刷新页面再试');
            state.running = false;
            resetSearchButton();
            return;
        }

        // 🆕 真实页面模式：不用循环，直接跳第一页，后面的交给 resumePageLoop
        if (settings.searchMode === 'page') {
            // v1.7.9：达标只认服务器确认值，本地计数不能当作已完成
            if (state.searchConfirmed >= searchTarget) {
                log(`💻 今日搜索任务已达标（服务器确认 ${state.searchConfirmed}/${searchTarget}），如需继续可到 ⚙️ 里调高额度比例`);
                state.running = false;
                resetSearchButton();
                return;
            }
            await startPageLoop(searchTarget);
            state.running = false;
            return;
        }

        // ===== 安全整改（v1.7.12）：API 模式每日最多 10 次 + 触发 429/403 永久禁用 =====
        // 防封作用：后台直发 API 是「机器人」最明显特征。此处是开发入口的兜底防御——
        // 正常用户走 page 模式根本到不了这里；即便有人手动恢复 api 选项，也会被硬限制挡住。
        //   · 单日 >10 次 → 直接停，引导用真实页面
        //   · 一旦当日触发过 429/403 → 永久禁用 api 模式（写死标记，不再回滚）
        if (settings.searchMode === 'api') {
            const apiTodayKey = 'mr_api_search_count';
            const apiBanKey = 'mr_api_banned';
            const apiToday = getDateHyphen();
            let apiCount = 0, apiBanned = false;
            try {
                const raw = gv(apiTodayKey, '');
                const o = raw ? JSON.parse(raw) : null;
                apiCount = (o && o.date === apiToday) ? (Number(o.n) || 0) : 0;
            } catch (e) { apiCount = 0; }
            try { apiBanned = gv(apiBanKey, '') === '1'; } catch (e) { apiBanned = false; }
            if (apiBanned) {
                log('⛔ API 模式已被永久禁用（此前触发过 429/403 风控）。请使用真实页面模式，本脚本已强制 page 模式。');
                state.running = false;
                resetSearchButton();
                return;
            }
            if (apiCount >= 10) {
                log('⛔ 为避免风控，API 模式每日最多执行 10 次，已停止；请使用真实页面模式（本脚本默认已是真实页面）。');
                state.running = false;
                resetSearchButton();
                return;
            }
            state.apiTodayCount = apiCount;
        }

        if (state.searchCur < searchTarget) {
            log(`💻 开始执行通用搜索，当前进度: ${state.searchCur}/${state.searchMax}，本次目标 ${searchTarget}（额度 ${settings.ratio}%）`);
            log(`⏱️ 搜索间隔 ${settings.minDelay}-${settings.maxDelay} 分钟随机`);
            log(humanizeNote());
            if (settings.batchSize > 0) {
                log(`🧩 分批模式：每 ${settings.batchSize} 次一批，批间隔 ${settings.batchGap} 分钟`);
            }
            let searchIndex = 0;

            while (state.searchCur < searchTarget && state.running) {
                await waitWhilePaused();

                searchIndex++;
                const q = humanizeQuery(await pickQuery());
                const useMobile = resolveSearchDevice() === 'mobile';
                if (searchIndex === 1) {
                    const modelKey = currentModelLabel();
                    log(`📱 搜索身份：${useMobile ? `手机 · ${modelKey}` : '电脑'}（${useMobile ? '计移动搜索分' : '计电脑搜索分'}）`);
                }
                const sr = await doSearch(q, useMobile);
                // v1.7.9：三种结局分开处理（v1.7.8 把两种都当推进，等于让估算值冒充进度）
                //   fail       → 没有响应：不推进、不计待确认
                //   unreported → 有响应但计分上报失败：不推进，计一次失败
                //   pending    → 已上报待平台确认：推进本轮循环，但「已确认」数字不动
                const acc = accSearchResult(sr, 3);
                if (acc.status === 'pending') {
                    state.searchFailStreak = 0;
                    // searchCur 只是本轮循环的推进量，界面主数字仍然是 searchConfirmed
                    state.searchCur = Math.min(searchTarget, state.searchCur + 3);
                    log(`⏳ 已上报待平台确认（+3 待确认，不计入已确认进度）`);
                    // v1.7.12 安全整改：API 模式每日计数 +1 并持久化；达到 10 次立即熔断本次循环
                    if (settings.searchMode === 'api') {
                        state.apiTodayCount = (Number(state.apiTodayCount) || 0) + 1;
                        try { gs('mr_api_search_count', JSON.stringify({ date: getDateHyphen(), n: state.apiTodayCount })); } catch (e) { }
                        if (state.apiTodayCount >= 10) {
                            log('⛔ 为避免风控，API 模式每日最多执行 10 次，已停止；请改用真实页面模式');
                            break;
                        }
                    }
                } else if (acc.status === 'unreported') {
                    state.searchFailStreak++;
                    log(`✗ 计分上报未成功（连续 ${state.searchFailStreak}/5），不推进进度`);
                    // v1.7.12 安全整改：API 模式下触发 429/403 → 永久禁用 API 模式
                    if (settings.searchMode === 'api' && (sr?.reportStatus === 429 || sr?.reportStatus === 403)) {
                        try { gs('mr_api_banned', '1'); } catch (e) { }
                        log('⛔ 检测到 HTTP ' + sr.reportStatus + '（风控），API 模式已永久禁用，请改用真实页面模式');
                        break;
                    }
                } else {
                    state.searchFailStreak++;
                    log(`✗ 本次搜索没有拿到响应（连续 ${state.searchFailStreak}/5），不推进进度`);
                }
                render();
                await checkPause(searchTarget);
                // v1.7.8：连续失败不再无限重试（原来会一直空转到天亮）
                if (state.searchFailStreak >= 5) {
                    log('⛔ 连续 5 次搜索失败，已自动停止；请检查网络或登录状态后重试');
                    break;
                }
                if (!state.running) break;
                // 🆕 搜索间隔可配置（默认 20–60 秒随机）
                await preciseWait(randomRange(gapMin, gapMax));

                // 🆕 分批：跑满一批后休息一段时间再继续
                if (settings.batchSize > 0 && searchIndex % settings.batchSize === 0 &&
                    state.searchCur < searchTarget && state.running) {
                    log(`🛏️ 第 ${Math.floor(searchIndex / settings.batchSize)} 批完成，休息 ${settings.batchGap} 分钟再继续`);
                    if (settings.batchGap > 0) await preciseWait(Math.round(settings.batchGap * 60000));
                }

                // 降低更新频率，每 5 次搜索同步一次数据，避免进度丢失
                if (searchIndex % 5 === 0) {
                    log(`🔄 已完成 ${searchIndex} 次搜索，同步一次数据...`);
                    await updateData();
                    // v1.7.9 止损：连续两次同步「读数没动但还有待确认」→ 平台没有承认这些上报，
                    // 继续发只是白跑，停下来让人去网页核对，而不是把估算值一路堆到「已完成」。
                    if (state.searchUnconfirmedStreak >= 2 && state.searchPending > 0) {
                        log(`⛔ 服务器连续 ${state.searchUnconfirmedStreak} 次没有确认新积分（待确认 ${state.searchPending} 分），已自动停止；请到 Rewards 网页核对实际进度`);
                        break;
                    }
                }

                // 达到本次目标后，再检查服务器真实进度
                if (state.searchCur >= searchTarget) {
                    if (searchIndex % 5 !== 0) {
                        log(`🔄 已达到本次搜索目标，最后同步一次数据...`);
                        await updateData();
                    }
                    // v1.7.9：目标只代表「发了多少次」，不代表服务器记了多少分；
                    // 没被平台确认就不能说「已完成」。
                    if (!state.lastSyncOk) {
                        log('⚠️ 最后一次同步失败，无法确认服务器积分；本地数字仅供参考，请稍后刷新核对');
                    } else if (searchTarget >= state.searchMax && state.searchConfirmed >= state.searchMax) {
                        log(`🎉 搜索积分已达今日上限 (${state.searchConfirmed}/${state.searchMax})！`);
                    } else if (state.searchConfirmed < searchTarget) {
                        log(`⚠️ 本轮已发送 ${searchIndex} 次，服务器只确认到 ${state.searchConfirmed}/${state.searchMax}（本次目标 ${searchTarget}）`
                            + (state.searchPending > 0 ? `，另有 ${state.searchPending} 分待确认` : '')
                            + '；不计为已完成，请稍后刷新核对');
                    } else {
                        log(`✅ 已完成本次目标（服务器确认 ${state.searchConfirmed}/${state.searchMax}，本次目标 ${searchTarget}，额度 ${settings.ratio}%）`);
                    }
                    break;
                }
            }
            log(`💻 搜索结束，共执行 ${searchIndex} 次搜索（服务器确认 ${state.searchConfirmed}/${state.searchMax}，本次目标 ${searchTarget}）`
                + (state.searchPending > 0 ? ` · 待确认 ${state.searchPending}` : '')
                + (state.lastSyncOk ? '' : ' · 最后一次同步失败，数字可能滞后'));
        } else {
            log(state.searchConfirmed >= searchTarget
                ? `💻 今日搜索任务已达标（服务器确认 ${state.searchConfirmed}/${searchTarget}），如需继续可到 ⚙️ 里调高额度比例`
                : `⚠️ 本地计数 ${state.searchCur}/${searchTarget} 已达目标，但服务器只确认到 ${state.searchConfirmed}；本轮未继续搜索，请刷新核对`);
        }

        state.running = false;
        nodes.btnSearch.textContent = '🔍 搜索';
        updateAllButton();
        saveProgress();
    };
    nodes.btnSearch.onclick = runSearch;

    // ===== 安全整改（v1.7.12）：移除「一键全部执行」=====
    // 防封作用：禁止全自动连续跑完签到→阅读→活动→搜索；必须逐个按钮手动触发。
    // 按钮已从界面删除，这里用空保护兜底，避免 btnAll 为 null 时报错。
    if (nodes.btnAll) {
        nodes.btnAll.style.display = 'none';
        nodes.btnAll.onclick = null;
    }
    // Init
    (async () => {
        // 🆕 真实页面搜索：页面加载后立即接力（必须在最前，不能被下面的网络请求拖住）
        startPageLoopTicker();
        resumePageLoop().catch(e => console.warn('[Rewards] 接管页面搜索失败', e));

        // 🆕 移动端：授权码在登录页被自动捕获后，回到本页立即自动兑换
        try {
            const autoCode = gv('auth_code', '');
            const pending = gv('auth_pending', '');
            if (autoCode) {
                await acceptAuthCode(autoCode, { silent: true });
            } else if (pending === '1') {
                log('👀 已开启授权监听，登录完成后会自动填入授权码');
                startAuthWatch();
            }
        } catch (e) { }

        // 输入框自动填充（方便用户直观看到授权码已经拿到）
        try {
            const c = gv('auth_code', '');
            if (c && nodes.inAuth && !nodes.inAuth.value) nodes.inAuth.value = c;
        } catch (e) { }

        const hour = new Date().getHours();

        // v1.7.12：凌晨 2:00-6:00 强制休眠，禁用所有自动任务按钮（P3 防封）
        applyNightBlock();

        if (hour >= 0 && hour < 8) {
            log('⚠️ 当前时间 00:00-08:00，Rewards 每日任务可能尚未刷新');
            log('💡 建议北京时间 08:00 后运行脚本，避免任务进度显示异常');
        }
        // v1.7.5：版本号不再写死，优先读脚本管理器给的版本（iOS 上无 GM_info 时兜底常量）
        const MR_VER = (() => {
            try {
                if (typeof GM_info !== 'undefined' && GM_info && GM_info.script && GM_info.script.version) return GM_info.script.version;
                if (typeof GM !== 'undefined' && GM && GM.info && GM.info.script && GM.info.script.version) return GM.info.script.version;
            } catch (e) { }
            return '1.7.11';
        })();
        log(`🌟 脚本就绪 v${MR_VER} (移动端优化版 · 个人词库 / 逐字输入 / 模糊搜索)`);
        // v1.7.11：老配置被压到新默认值时提示一次
        if (SETTINGS_MIGRATED_V3) {
            log('🛡️ 已按防封默认值调整：额度比例 ≤40%、每 5 次搜索暂停一次、不再自动点开搜索结果（可在 ⚙️ 里改回）');
        }

        /* v1.7.6：数据拉取推迟到浏览器空闲帧。
         * 旧版一进页面就同步跑 Cookie + 多个网络请求，主线程被占住，
         * iOS 上表现为「点了球要等一两秒才出来」。先让界面与点击响应就位，再联网。 */
        await new Promise(resolve => {
            try {
                if (typeof requestIdleCallback === 'function') {
                    requestIdleCallback(() => resolve(), { timeout: 1500 });
                    return;
                }
            } catch (e) { }
            setTimeout(resolve, 280);
        });

        try {
            // v1.7.6：iOS 扩展没有 GM_cookie，读 Cookie 必然为空串 → 别白跑一趟，
            // 直接提示用户走「获取授权码」，界面也不再显示成一片 0。
            const canCookie = hasCookieApi();
            if (!canCookie) {
                log('ℹ️ 当前环境读不到登录 Cookie（Safari 扩展限制）');
                log('👉 请点面板里的「🔗 获取授权码」授权一次，之后靠 Token 工作');
            }
            loginCookie = canCookie ? await getCookies('https://login.live.com') : '';

            console.log('[Rewards] 登录Cookie长度:', loginCookie.length);
            await updateData();

            try {
                const info = await withAccessTokenRequest(token => gmRequest({
                    url: 'https://prod.rewardsplatform.microsoft.com/dapi/me?channel=SAAndroid&options=613',
                    headers: { 
                        'Authorization': `Bearer ${token}`, 
                        'X-Rewards-AppId': CONFIG.mobileApi.appId, 
                        'X-Rewards-IsMobile': 'true' 
                    }
                }));
                if (info) {
                    const d = typeof info === 'string' ? JSON.parse(info) : info;
                    const p = d.response?.promotions?.find(x => x.attributes?.offerid === 'ENUS_readarticle3_30points');
                    if (p && p.attributes) { 
                        // v1.7.10：这里也会写 readCur/readMax，同样不能把缺失字段当 0
                        const rp = parseReadProgress(p);
                        if (rp.ok) { state.readCur = rp.cur; state.readMax = rp.max; render(); }
                    }
                }
            } catch { }
        } catch { }
    })();

    // 定时同步（移动端修复：后台标签不再空转，省电且避免被浏览器冻结后报错）
    setInterval(() => {
        if (document.hidden) return;
        if (isBreakerOn()) return; // v1.7.11：熔断后停止自动同步，避免每分钟撞一次墙
        updateData();
    }, 60000);

    // 移动端便利菜单（手机上不好进脚本存储，直接给菜单命令）
    if (typeof GM_registerMenuCommand === 'function') {
        GM_registerMenuCommand('📋 打开微软授权页（自动获取授权码）', () => {
            openAuthPage();
            startAuthWatch();
        });
        GM_registerMenuCommand('🔄 清除授权信息并重新授权', () => {
            gs('auth_code', '');
            setRefreshToken('');
            gs('auth_pending', '');
            state.accessToken = null;
            state.accessTokenExpiresAt = 0;
            log('🧹 已清除授权信息，请重新点击「获取授权码」');
            if (nodes.boxAuth) nodes.boxAuth.style.display = 'block';
        });
    }

})();