// ==UserScript==
// @name         Get Microsoft Rewards (安卓移动端优化版)
// @namespace    https://github.com/Muverix/Get-Microsoft-Rewards
// @version      1.7.3
// @description  微软 Rewards 自动助手：本地自动搜索、每日活动与自动签到。移动端适配、授权码自动获取、真实页面搜索、逐字输入与模糊搜索（错字/数字尾缀/拼音/模糊音），个人词库（导入浏览器历史 CSV，只提取搜索词、本机解析不联网，按个人/混搭/热搜配比选词，无历史可用话题包），可调额度比例、搜索与阅读间隔、分批搜索与机型 UA，面板显示今日积分。1.7.3 起界面改为 Apple 风格（液态玻璃悬浮球、iOS 式开关与分组设置，支持深色模式）；1.7.2 起支持 iPhone / iPad（用户脚本 App），脚本存储缺失时自动改用本机存储。本脚本代码由 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 前缀，避免与网站自己的键冲突

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

    // 注入样式：优先 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', '');
                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;';

        if (code) {
            box.innerHTML = `
                <div style="font-size:34px;line-height:1">✅</div>
                <div style="font-weight:700;font-size:16px;margin:8px 0 6px">授权码已自动获取</div>
                <div style="color:#666;font-size:13px">现在可以关闭本页，回到 Bing 标签页。<br>脚本会自动填充授权码并完成兑换。</div>
                <div style="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)}…</div>
                <div style="display:flex;gap:8px;margin-top:12px">
                    <button id="mr-cap-copy" style="flex:1;min-height:42px;border:1px solid #d0d0d0;background:#fff;color:#333;border-radius:6px;font-size:14px">📋 复制授权码</button>
                    <button id="mr-cap-close" style="flex:1;min-height:42px;border:none;background:#0078d4;color:#fff;border-radius:6px;font-size:14px">关闭本页</button>
                </div>
            `;
        } else {
            const e1 = errM ? errM[1] : '未知错误';
            let e2 = '';
            try { e2 = errDesc ? decodeURIComponent(errDesc[1].replace(/\+/g, ' ')) : ''; } catch (e) { e2 = errDesc ? errDesc[1] : ''; }
            box.innerHTML = `
                <div style="font-size:34px;line-height:1">⚠️</div>
                <div style="font-weight:700;font-size:16px;margin:8px 0 6px">授权被取消或失败</div>
                <div style="color:#666;font-size:13px;word-break:break-all">${e1}${e2 ? '<br>' + e2 : ''}</div>
                <div style="color:#666;font-size:13px;margin-top:8px">关闭本页，回到 Bing 后重新点击「获取授权码」。</div>
                <button id="mr-cap-close" style="width:100%;min-height:42px;margin-top:12px;border:none;background:#0078d4;color:#fff;border-radius:6px;font-size:14px">关闭本页</button>
            `;
        }

        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: {
            pc: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/151.0.0.0 Safari/537.36 Edg/151.0.0.0',
            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分钟
        }
    };

    /* =========================================================================
     * ⚙️ 搜索设置（可在面板「⚙️」里改，保存到脚本存储，跨页面/重启后仍生效）
     * 默认值 = 原脚本行为（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}`;
    }

    // 按设置生成手机 UA；选「自动」时每次随机一款主流机型
    function currentMobileUA() {
        const key = (settings.deviceModel === 'auto')
            ? MOBILE_POOL[Math.floor(Math.random() * MOBILE_POOL.length)]
            : settings.deviceModel;
        return buildMobileUA(key);
    }

    // 是否是「触屏平板」（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}`;
    }

    // 统一入口：按模式与配比给出本次搜索词
    async function pickQuery() {
        const q = await pickQueryRaw();
        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;
    }

    const DEFAULT_SETTINGS = {
        searchMode: 'page', // 搜索方式：page（真实打开搜索结果页）/ api（后台请求，不跳页）
        searchDevice: 'auto', // 搜索端：auto（跟随设备）/ pc / mobile
        deviceModel: 'auto',  // 手机端机型：auto / generic / xiaomi15 ...
        ratio: 100,        // 每日额度使用比例（%），100 = 不限制
        minDelay: 2,       // 两次搜索间隔下限（分钟）
        maxDelay: 6,       // 两次搜索间隔上限（分钟）
        batchSize: 0,      // 每批搜索次数，0 = 不分批
        batchGap: 60,      // 批次间隔（分钟）
        pauseInterval: 10, // 每 N 次触发防风控暂停
        pauseMinutes: 15,  // 暂停分钟数
        clickResult: true, // 搜索后模拟点开一条结果
        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)));
    };

    function normalizeSettings(s) {
        const out = {};
        out.searchMode = ['page', 'api'].includes(s.searchMode) ? s.searchMode : 'page';
        out.searchDevice = ['auto', 'pc', 'mobile'].includes(s.searchDevice) ? s.searchDevice : 'auto';
        out.deviceModel = DEVICE_PROFILES[s.deviceModel] ? s.deviceModel : 'auto';
        out.ratio = clampNum(s.ratio, 10, 100, 100);
        out.minDelay = clampNum(s.minDelay, 1, 60, 2);
        out.maxDelay = clampNum(s.maxDelay, out.minDelay, 240, 6);
        out.batchSize = clampNum(s.batchSize, 0, 100, 0);
        out.batchGap = clampNum(s.batchGap, 0, 720, 60);
        out.pauseInterval = clampNum(s.pauseInterval, 3, 100, 10);
        out.pauseMinutes = clampNum(s.pauseMinutes, 1, 180, 15);
        out.clickResult = s.clickResult !== false;
        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 = 2; // 2 = 间隔单位为「分钟」（1.3.1 起）

    function loadSettings() {
        let raw = {};
        try { raw = gv('mr_settings', {}) || {}; } catch (e) { }
        // 旧版（1.3.0 及以前）保存的间隔是「秒」，直接沿用会变成几十分钟/小时，故重置这几个间隔字段
        if (raw && raw.v !== SETTINGS_VER) {
            delete raw.minDelay;
            delete raw.maxDelay;
            delete raw.readMin;
            delete raw.readMax;
        }
        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 目标
        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,
        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
    };
    let dashboard = null;
    let loginCookie = '';

    // ========== 进度保存/恢复 ==========
    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);
    };

    // GM_xmlhttpRequest 封装
    async function gmRequest(options) {
        const retries = options.retries ?? 2;
        const retryDelay = options.retryDelay ?? 1000;
        let attempt = 0;

        const shouldRetry = (err) => {
            const status = err?.status || 0;
            return status === 0 || status === 429 || status >= 500 || err?.message === 'Timeout';
        };

        while (true) {
            try {
                return await new Promise((resolve, reject) => {
                    GM_xmlhttpRequest({
                        timeout: 20000,
                        ...options,
                        onload: xhr => {
                            if (xhr.status >= 200 && xhr.status < 300) {
                                resolve(options.returnUrl ? xhr.finalUrl : xhr.responseText);
                            } else if (xhr.status >= 300 && xhr.status < 400) {
                                const loc = xhr.responseHeaders.match(/Location:\s*(.*?)\s*[\r\n]/i);
                                resolve(loc ? loc[1] : xhr.responseText);
                            } else {
                                const err = new Error(`HTTP ${xhr.status}`);
                                err.status = xhr.status;
                                err.responseText = xhr.responseText;
                                err.finalUrl = xhr.finalUrl;
                                reject(err);
                            }
                        },
                        onerror: () => {
                            const err = new Error('Network Error');
                            err.status = 0;
                            reject(err);
                        },
                        ontimeout: () => {
                            const err = new Error('Timeout');
                            err.status = 0;
                            reject(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.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 管理
    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);
            --mr-glass: rgba(255, 255, 255, 0.74);
            --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;
        }

        /* ---------- 外壳 ---------- */
        #mr-panel {
            position: fixed;
            bottom: calc(20px + 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(24px) saturate(190%);
            backdrop-filter: blur(24px) saturate(190%);
            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); }
        @media (hover: hover) and (pointer: fine) {
            #mr-panel.collapsed:hover { transform: scale(1.05); }
        }
        #mr-panel.collapsed svg { width: 25px; height: 25px; fill: currentColor; position: relative; }
        #mr-panel.collapsed #mr-container { display: none; }

        /* ---------- 展开状态：玻璃面板 ---------- */
        #mr-panel:not(.collapsed) {
            width: 320px;
            border-radius: 22px;
            overflow: hidden;
            background: var(--mr-glass);
            -webkit-backdrop-filter: blur(30px) saturate(180%);
            backdrop-filter: blur(30px) saturate(180%);
            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 { font-size: 14px; }
        #mr-close { font-size: 19px; }
        #mr-set:active, #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;
        }
        #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;
            border-radius: 12px;
            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: 12px;
            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: 14px;
            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: 10px;
            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 14px 16px;
            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: 22px;
            background: var(--mr-surface);
            -webkit-backdrop-filter: blur(28px) saturate(180%);
            backdrop-filter: blur(28px) saturate(180%);
        }
        #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 -14px 10px;
            padding: 14px 14px 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: 14px;
            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: 10px;
            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: 10px;
            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: 12px;
            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-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: 20px;
            background: var(--mr-surface);
            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: 12px;
            resize: vertical;
        }

        /* =========================================================
         * 尺寸适配：手机（触控）/ 平板（iPad）
         * ========================================================= */
        @media (pointer: coarse) {
            #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 { font-size: 16px; }
            #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 14px 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 14px 14px; }
            .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.80);
                --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-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="设置">⚙️</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 同款：今日已得 / 今日可得分） -->
                <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>
                    <button id="btn-all" class="mr-btn mr-full">🚀 一键全部执行</button>
                </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>
                        <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>
                        <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">
                <label>机型（手机身份搜索时生效）</label>
                <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="100" step="5"><span>%</span>
                </div>
                <div class="mr-hint">默认 100%（等于不限制）。建议 70–80%，留一点额度手动搜索更安全。</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="1"><span>分钟 ~</span>
                    <input type="number" id="set-maxdelay" class="mr-num" min="1" max="240" step="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="5"><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="1"><span>分钟</span>
                </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">模拟真人点开搜索结果并停留，更像人；会额外增加耗时。</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 h = Math.round((vv && vv.height) || window.innerHeight || 0);
            if (h > 120) 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) { }

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

    // 展开/收起
    nodes.panel.onclick = (e) => {
        if (nodes.panel.classList.contains('collapsed')) {
            nodes.panel.classList.remove('collapsed');
        }
    };
    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'),
        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' ? '自动（每次随机一款）' : (DEVICE_PROFILES[mk]?.label || '通用 Android');
            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;
        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();
        };
    }
    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' ? '随机' : (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', '');
        gs('refresh_token', ''); // 用新授权码时清掉旧 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);
                gs('refresh_token', ''); // 清空旧 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() {
        // return null;//test
        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';

            const res = await new Promise((resolve, reject) => {
                GM_xmlhttpRequest({
                    method: 'GET',
                    url: authUrl,
                    headers: {
                        'Cookie': cookie,
                        'User-Agent': (typeof CONFIG !== 'undefined' && CONFIG.ua?.pc) ? CONFIG.ua.pc : 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
                    },
                    timeout: 15000,
                    onload: r => resolve(r),
                    onerror: e => reject(e),
                    ontimeout: () => reject(new Error('Timeout'))
                });
            });

            // 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': CONFIG.ua.pc,
                        '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) {
                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. 搜索进度解析
            let searchCur = 0, searchMax = 0;
            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);
                }
            });

            candidateCounters.forEach(item => {
                if (!item || typeof item !== 'object') return;
                const cur = Number(item.pointProgress ?? item.progress ?? item.current ?? item.points ?? item.attributes?.progress) || 0;
                const max = Number(item.pointProgressMax ?? item.pointMax ?? item.max ?? item.maxPoints ?? item.attributes?.max) || 0;
                searchCur += cur;
                searchMax += max;
            });

            state.searchCur = searchCur;
            state.searchMax = searchMax > 0 ? searchMax : (searchCur > 0 ? searchCur : (state.level > 1 ? 90 : 60));
            state.pcCur = state.searchCur;
            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) {
                state.readCur = parseInt(readPromo.attributes.progress) || 0;
                state.readMax = parseInt(readPromo.attributes.max) || 30;
            } else {
                if (state.readCur === undefined) state.readCur = 0;
                if (state.readMax === undefined) 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;

            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) {
            console.error('updateData error:', e);
            log(`⚠️ 获取数据出错: ${e.message}`);
        } finally {
            state.updating = false;
            state.updatingPromise = null;
        }
    })();
    return state.updatingPromise;
}
    // UI 渲染函数（精准适配原生节点映射）
    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. 搜索进度
        const pcCur = state.searchCur ?? state.pcCur ?? 0;
        const pcMax = state.searchMax ?? state.pcMax ?? 60;
        if (nodes.pc) nodes.pc.textContent = `${pcCur}/${pcMax}`;
        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. 阅读任务
        const readCur = state.readCur ?? 0;
        const readMax = state.readMax ?? 30;
        if (nodes.read) nodes.read.textContent = `${readCur}/${readMax}`;
        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}`;
        }
    }

    // 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 = gv('refresh_token', '');//test
                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) {
                        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) {
                        gs('refresh_token', data.refresh_token);
                    }
                    log('🔑 活动 Token 建立成功');
                    return data.access_token;
                } else {
                    // 若旧 refresh_token 换取失败，清空并重新走 Code 授权
                    if (refreshToken) {
                        console.warn('[Rewards] RefreshToken 失效，尝试重新 Code 授权...');
                        gs('refresh_token', '');
                        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;
    }
    //签到
    const runSign = async () => {
        nodes.btnSign.disabled = true;
        markBusy(1);
        await waitWhilePaused();
        log('⏳ 正在尝试 App 移动端签到...');

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

        try {
            const res = await withAccessTokenRequest(token => gmRequest({
                method: 'POST',
                url: 'https://prod.rewardsplatform.microsoft.com/dapi/me/activities',
                headers: {
                    'content-type': 'application/json; charset=UTF-8',
                    'user-agent': CONFIG.ua.mobile,
                    'authorization': `Bearer ${token}`,
                    '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'
                },
                data: JSON.stringify({
                    amount: 1,
                    id: generateDapiId(),
                    type: 103,
                    country: region,
                    channel: 'SAAndroid',
                    attributes: {
                        offerid: offerId
                    }
                })
            }));

            if (res) {
                const data = typeof res === 'string' ? JSON.parse(res) : res;
                const response = data.response || {};
                const act = response.activity;

                const pts = Number(act?.p ?? act?.points ?? 0);
                const hasOfferId = act?.a?.offerid || act?.attributes?.offerid;

                if (act && pts > 0) {
                    log(`✅ App 签到成功 +${pts}分`);
                    gs("Config.lastSignDate", getDateStr());
                    state.checkedIn = true;
                    render();
                } else if (response.isDuplicate || (act && pts === 0 && hasOfferId)) {
                    log('ℹ️ 今日已经完成过签到');
                    gs("Config.lastSignDate", getDateStr());
                    state.checkedIn = true;
                    render();
                } else {
                    log('⚠️ 签到未成功触发，请稍后重试');
                    console.log('[Rewards 未成功签到响应]:', data);
                }
            } else {
                log('❌ 签到无响应');
            }

            await updateData();
        } catch (e) {
            log('❌ 签到出错: ' + e.message);
        } finally {
            nodes.btnSign.disabled = false;
            markBusy(-1);
        }
    };
    nodes.btnSign.onclick = runSign;

    
    // 阅读
    const runRead = async () => {
    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) {
                let cur = parseInt(p.attributes.progress) || 0;
                let max = parseInt(p.attributes.max) || 30;
                
                // 判断步长：若 max 为 30 则每篇 +3 分（共 10 篇）；若 max 为 10 则每篇 +1 分
                const step = max >= 30 ? 3 : 1;
                const totalArticles = Math.ceil(max / step);

                state.readCur = cur;
                state.readMax = max;
                render();

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

                    let currentArticleIdx = Math.floor(cur / step);
                    while (cur < max) {
                       // 方式一：改用已有的运行状态判定
                        if (!state.readRunning && !state.allRunning) break;

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

                        const res = await withAccessTokenRequest(token => gmRequest({
                            method: 'POST',
                            url: 'https://prod.rewardsplatform.microsoft.com/dapi/me/activities',
                            headers: {
                                'content-type': 'application/json; charset=utf-8',
                                'user-agent': CONFIG.ua.mobile,
                                'authorization': `Bearer ${token}`,
                                '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'
                            },
                            data: JSON.stringify({
                                amount: 1,
                                country: region,
                                id: generateDapiId(),
                                type: 101,
                                channel: 'SAAndroid',
                                attributes: { offerid: readOfferId }
                            })
                        })).catch(() => null);

                        if (res) {
                            const resData = typeof res === 'string' ? JSON.parse(res) : res;
                            console.log(`[Rewards 阅读上报响应 ${currentArticleIdx}/${totalArticles}]:`, resData);

                            // 阅读成功后：进度 +step(3)，积分固定 +3
                            cur = Math.min(max, cur + step);
                            state.points = (state.points || 0) + 3;
                            state.readCur = cur;
                            render();

                            log(`🎉 第 ${currentArticleIdx}/${totalArticles} 篇阅读成功 (+3积分) | 进度: ${state.readCur}/${max} | 当前总积分: ${state.points}`);
                        } else {
                            log(`⚠️ 第 ${currentArticleIdx}/${totalArticles} 篇上报未收到有效响应，继续下一篇...`);
                        }

                        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.readCur}/${max})`);
                    } else {
                        log(`⏹️ 阅读任务已停止 (当前进度: ${state.readCur}/${max})`);
                    }
                }
            } else {
                log(`⚠️ 未找到阅读任务卡片 (offerid: ${readOfferId})`);
            }
        } else {
            log('❌ 获取阅读进度失败');
        }

        await updateData();
    } 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 () => {
        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);
                    return;
                }

                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 = [];

        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})`);
                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})`);
                    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})`);
                    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})`);
                continue;
            }

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

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

        console.groupEnd();

        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 hash = p.hash || p.activityId || p.attributes?.hash || '1';

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

                // 通道 1：Web 端标准 reportactivity
                if (token) {
                    const formData = new URLSearchParams({
                        id: offerId,
                        hash: hash,
                        timeZone: '480',
                        activityAmount: '1',
                        dbs: '0',
                        form: '',
                        type: '',
                        __RequestVerificationToken: token
                    });

                    await gmRequest({
                        method: 'POST',
                        url: 'https://rewards.bing.com/api/reportactivity?X-Requested-With=XMLHttpRequest',
                        headers: {
                            'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
                            'X-Requested-With': 'XMLHttpRequest',
                            'Referer': 'https://rewards.bing.com/'
                        },
                        data: formData.toString()
                    }).catch(() => null);
                }

                // 通道 2：DAPI 移动端 101 上报
                if (accessToken) {
                    await gmRequest({
                        method: 'POST',
                        url: 'https://prod.rewardsplatform.microsoft.com/dapi/me/activities',
                        headers: {
                            'content-type': 'application/json; charset=UTF-8',
                            'user-agent': CONFIG.ua.mobile,
                            'authorization': `Bearer ${accessToken}`,
                            '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'
                        },
                        data: JSON.stringify({
                            amount: 1,
                            country: region,
                            id: generateDapiId(),
                            type: 101,
                            channel: 'SAAndroid',
                            attributes: { offerid: offerId }
                        })
                    }).catch(() => null);
                }

                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} 个活动`);
        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' });
                setTimeout(step, randomRange(900, 2400));
            };
            setTimeout(step, randomRange(400, 1400));
        } 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);
    }

    // 计算「下一次」要等多久（含分批休息、防风控暂停）
    function pageNextGap(loop) {
        const gapMin = Math.max(1, settings.minDelay) * 60000;
        const gapMax = Math.max(settings.minDelay, settings.maxDelay) * 60000;
        let wait = randomRange(gapMin, gapMax);
        if (settings.batchSize > 0 && loop.idx % settings.batchSize === 0) {
            wait += Math.round(Math.max(0, settings.batchGap) * 60000);
            log(`🛏️ 第 ${Math.floor(loop.idx / settings.batchSize)} 批完成，休息 ${settings.batchGap} 分钟再继续`);
        }
        if (settings.pauseInterval > 0 && loop.idx % settings.pauseInterval === 0) {
            wait += Math.round(Math.max(1, settings.pauseMinutes) * 60000);
            log(`⏸️ 已完成 ${loop.idx} 次搜索，额外暂停 ${settings.pauseMinutes} 分钟（防风控）`);
        }
        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
            ? (settings.deviceModel === 'auto' ? '随机主流机型' : (DEVICE_PROFILES[settings.deviceModel]?.label || '通用 Android'))
            : '电脑';
        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();

            // 等一会儿（当作人在看结果），再同步服务器真实积分
            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) {
                finishPageLoop(`✅ 已完成本次目标 ${loop.idx}/${loop.target} 次（额度 ${settings.ratio}%），剩余额度留给你手动搜索`);
                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 () => {
        // 🆕 真实页面模式下，点击按钮 = 停止正在进行的循环
        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();

        // 执行单次搜索与奖励触发
        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() : CONFIG.ua.pc;
            const chHeaders = isMobile ? mobileClientHints(ua) : {};
            const searchUrl = `https://${host}/search?q=${encodeURIComponent(query)}&form=QBLH`;

            try {
                // 1. 发送标准的 Bing 搜索请求
                const searchResult = await gmRequest({
                    url: searchUrl,
                    headers: {
                        'User-Agent': ua,
                        'Cookie': cookie,
                        'Referer': `https://${host}/?form=QBLH`,
                        ...chHeaders
                    }
                });

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

                // 触发奖励计数埋点
                await gmRequest({
                    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'
                }).catch(() => {});

                // 触发活动报告接口
                await gmRequest({
                    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`
                }).catch(() => {});

                // 🆕 模拟点开一条搜索结果并停留（设置里可关闭）
                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));
                    }
                }

                log(`✓ 搜索: "${query.substring(0, 12)}..."`);
            } catch (e) {
                console.error('[Rewards] 搜索异常:', e);
                log(`✗ 搜索失败: ${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') {
            if (state.searchCur >= searchTarget) {
                log(`💻 今日搜索任务已达标（${state.searchCur}/${searchTarget}），如需继续可到 ⚙️ 里调高额度比例`);
                state.running = false;
                resetSearchButton();
                return;
            }
            await startPageLoop(searchTarget);
            state.running = false;
            return;
        }

        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 = settings.deviceModel === 'auto' ? '随机主流机型' : (DEVICE_PROFILES[settings.deviceModel]?.label || '通用 Android');
                    log(`📱 搜索身份：${useMobile ? `手机 · ${modelKey}` : '电脑'}（${useMobile ? '计移动搜索分' : '计电脑搜索分'}）`);
                }
                await doSearch(q, useMobile);

                // 👈 核心修复：每次做完立即同步预估积分 (+3分/次)
                state.searchCur = Math.min(searchTarget, state.searchCur + 3);
                render();
                await checkPause(searchTarget);
                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();
                }

                // 达到本次目标后，再检查服务器真实进度
                if (state.searchCur >= searchTarget) {
                    if (searchIndex % 5 !== 0) {
                        log(`🔄 已达到本次搜索目标，最后同步一次数据...`);
                        await updateData();
                    }
                    if (searchTarget >= state.searchMax) {
                        log(`🎉 搜索积分已达今日上限 (${state.searchCur}/${state.searchMax})！`);
                    } else {
                        log(`✅ 已完成本次目标 (${state.searchCur}/${searchTarget}，额度 ${settings.ratio}%)，剩余额度留给你手动搜索`);
                    }
                    break;
                }
            }
            log(`💻 搜索结束，共执行 ${searchIndex} 次搜索 (最终进度: ${state.searchCur}/${state.searchMax}，本次目标 ${searchTarget})`);
        } else {
            log(`💻 今日搜索任务已达标（${state.searchCur}/${searchTarget}），如需继续可到 ⚙️ 里调高额度比例`);
        }

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

    nodes.btnAll.onclick = async () => {
        if (state.manualPaused || state.running || state.allRunning || state.busyCount > 0) {
            setManualPause(!state.manualPaused);
            return;
        }
        state.allRunning = true;
        updateAllButton();
        log('🚀 一键执行开始');
        try {
            await waitWhilePaused();
            await runSign();
            await runRead();
            await runPromo();
            await runSearch();
        } finally {
            state.allRunning = false;
            updateAllButton();
        }
    };
    // Init
    (async () => {
        try {
            loginCookie = 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) { 
                        state.readCur = parseInt(p.attributes.progress) || 0; 
                        state.readMax = parseInt(p.attributes.max) || 30; 
                        render(); 
                    }
                }
            } catch { }
        } catch { }

        // 🆕 移动端：授权码在登录页被自动捕获后，回到本页立即自动兑换
        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();

        if (hour >= 0 && hour < 8) {
            log('⚠️ 当前时间 00:00-08:00，Rewards 每日任务可能尚未刷新');
            log('💡 建议北京时间 08:00 后运行脚本，避免任务进度显示异常');
        }
        log('🌟 脚本就绪 v1.7.1 (移动端优化版 · 个人词库 / 逐字输入 / 模糊搜索)');

        // 🆕 真实页面搜索：页面加载后自动接力（先不阻塞后续初始化）
        startPageLoopTicker();
        resumePageLoop().catch(e => console.warn('[Rewards] 接管页面搜索失败', e));
    })();

    // 定时同步（移动端修复：后台标签不再空转，省电且避免被浏览器冻结后报错）
    setInterval(() => {
        if (document.hidden) return;
        updateData();
    }, 60000);

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

})();